1 /* BFD back-end for PDP-11 a.out binaries.
2 Copyright (C) 2001-2023 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
22 /* BFD backend for PDP-11, running 2.11BSD in particular.
24 This file was hacked up by looking hard at the existing vaxnetbsd
25 back end and the header files in 2.11BSD. The symbol table format
26 of 2.11BSD has been extended to accommodate .stab symbols. See
27 struct pdp11_external_nlist below for details.
30 * support for V7 file formats
31 * support for overlay object files (see 2.11 a.out(5))
32 * support for old and very old archives
33 (see 2.11 ar(5), historical section)
35 Search for TODO to find other areas needing more work. */
37 #define BYTES_IN_WORD 2
38 #define BYTES_IN_LONG 4
40 #undef TARGET_IS_BIG_ENDIAN_P
42 #define TARGET_PAGE_SIZE 8192
43 #define SEGMENT__SIZE TARGET_PAGE_SIZE
45 #define DEFAULT_ARCH bfd_arch_pdp11
46 #define DEFAULT_MID M_PDP11
48 /* Do not "beautify" the CONCAT* macro args. Traditional C will not
49 remove whitespace added here, and thus will fail to concatenate
51 #define MY(OP) CONCAT2 (pdp11_aout_,OP)
53 /* This needs to start with a.out so GDB knows it is an a.out variant. */
54 #define TARGETNAME "a.out-pdp11"
56 /* This is the normal load address for executables. */
57 #define TEXT_START_ADDR 0
59 /* The header is not included in the text segment. */
60 #define N_HEADER_IN_TEXT(x) 0
62 /* There is no flags field. */
63 #define N_FLAGS(execp) 0
65 #define N_SET_FLAGS(execp, flags) do { } while (0)
66 #define N_BADMAG(x) (N_MAGIC(x) != OMAGIC \
67 && N_MAGIC(x) != NMAGIC \
68 && N_MAGIC(x) != IMAGIC \
69 && N_MAGIC(x) != ZMAGIC)
75 #define external_exec pdp11_external_exec
76 struct pdp11_external_exec
78 bfd_byte e_info
[2]; /* Magic number. */
79 bfd_byte e_text
[2]; /* Length of text section in bytes. */
80 bfd_byte e_data
[2]; /* Length of data section in bytes. */
81 bfd_byte e_bss
[2]; /* Length of bss area in bytes. */
82 bfd_byte e_syms
[2]; /* Length of symbol table in bytes. */
83 bfd_byte e_entry
[2]; /* Start address. */
84 bfd_byte e_unused
[2]; /* Not used. */
85 bfd_byte e_flag
[2]; /* Relocation info stripped. */
86 bfd_byte e_relocatable
; /* Ugly hack. */
89 #define EXEC_BYTES_SIZE (8 * 2)
91 #define A_MAGIC1 OMAGIC
92 #define OMAGIC 0407 /* ...object file or impure executable. */
93 #define A_MAGIC2 NMAGIC
94 #define NMAGIC 0410 /* Pure executable. */
95 #define ZMAGIC 0413 /* Demand-paged executable. */
96 #define IMAGIC 0411 /* Separated I&D. */
97 #define A_MAGIC3 IMAGIC
98 #define A_MAGIC4 0405 /* Overlay. */
99 #define A_MAGIC5 0430 /* Auto-overlay (nonseparate). */
100 #define A_MAGIC6 0431 /* Auto-overlay (separate). */
104 #define A_FLAG_RELOC_STRIPPED 0x0001
106 /* The following struct defines the format of an entry in the object file
107 symbol table. In the original 2.11BSD struct the index into the string
108 table is stored as a long, but the PDP11 C convention for storing a long in
109 memory placed the most significant word first even though the bytes within a
110 word are stored least significant first. So here the string table index is
111 considered to be just 16 bits and the first two bytes of the struct were
112 previously named e_unused. To extend the symbol table format to accommodate
113 .stab symbols, the e_unused bytes are renamed e_desc to store the desc field
114 of the .stab symbol. The GDP Project's STABS document says that the "other"
115 field is almost always unused and can be set to zero; the only nonzero cases
116 identified were for stabs in their own sections, which does not apply for
117 pdp11 a.out format, and for a special case of GNU Modula2 which is not
118 supported for the PDP11. */
119 #define external_nlist pdp11_external_nlist
120 struct pdp11_external_nlist
122 bfd_byte e_desc
[2]; /* The desc field for .stab symbols, else 0. */
123 bfd_byte e_strx
[2]; /* Index into string table of name. */
124 bfd_byte e_type
[1]; /* Type of symbol. */
125 bfd_byte e_ovly
[1]; /* Overlay number. */
126 bfd_byte e_value
[2]; /* Value of symbol. */
129 #define EXTERNAL_NLIST_SIZE 8
131 #define N_TXTOFF(x) (EXEC_BYTES_SIZE)
132 #define N_DATOFF(x) (N_TXTOFF(x) + (x)->a_text)
133 #define N_TRELOFF(x) (N_DATOFF(x) + (x)->a_data)
134 #define N_DRELOFF(x) (N_TRELOFF(x) + (x)->a_trsize)
135 #define N_SYMOFF(x) (N_DRELOFF(x) + (x)->a_drsize)
136 #define N_STROFF(x) (N_SYMOFF(x) + (x)->a_syms)
138 #define WRITE_HEADERS(abfd, execp) pdp11_aout_write_headers (abfd, execp)
143 #define SWAP_MAGIC(ext) bfd_getl16 (ext)
145 #define MY_entry_is_text_address 1
147 #define MY_write_object_contents MY(write_object_contents)
148 static bool MY(write_object_contents
) (bfd
*);
149 #define MY_text_includes_header 1
151 #define MY_BFD_TARGET
153 #include "aout-target.h"
155 /* Start of modified aoutx.h. */
156 #define KEEPIT udata.i
158 #include <string.h> /* For strchr and friends. */
161 #include "safe-ctype.h"
165 #include "aout/aout64.h"
166 #include "aout/stab_gnu.h"
169 /* The symbol type numbers for the 16-bit a.out format from 2.11BSD differ from
170 those defined in aout64.h so we must redefine them here. N_EXT changes from
171 0x01 to 0x20 which creates a conflict with some .stab values, in particular
172 between undefined externals (N_UNDF+N_EXT) vs. global variables (N_GYSM) and
173 between external bss symbols (N_BSS+N_EXT) vs. function names (N_FUN). We
174 disambiguate those conflicts with a hack in is_stab() to look for the ':' in
175 the global variable or function name string. */
186 #define N_TYPE 0x1f /* Type mask. */
187 #define N_UNDF 0x00 /* Undefined. */
188 #define N_ABS 0x01 /* Absolute. */
189 #define N_TEXT 0x02 /* Text segment. */
190 #define N_DATA 0x03 /* Data segment. */
191 #define N_BSS 0x04 /* Bss segment. */
192 #define N_REG 0x14 /* Register symbol. */
193 #define N_FN 0x1f /* File name. */
194 #define N_EXT 0x20 /* External flag. */
195 /* Type numbers from .stab entries that could conflict:
196 N_GSYM 0x20 Global variable [conflict with external undef]
197 N_FNAME 0x22 Function name (for BSD Fortran) [ignored]
198 N_FUN 0x24 Function name [conflict with external BSS]
199 N_NOMAP 0x34 No DST map for sym. [ext. reg. doesn't exist]
204 #define RELFLG 0x0001 /* PC-relative flag. */
205 #define RTYPE 0x000e /* Type mask. */
206 #define RIDXMASK 0xfff0 /* Index mask. */
208 #define RABS 0x00 /* Absolute. */
209 #define RTEXT 0x02 /* Text. */
210 #define RDATA 0x04 /* Data. */
211 #define RBSS 0x06 /* Bss. */
212 #define REXT 0x08 /* External. */
214 #define RINDEX(x) (((x) & 0xfff0) >> 4)
216 #ifndef MY_final_link_relocate
217 #define MY_final_link_relocate _bfd_final_link_relocate
220 #ifndef MY_relocate_contents
221 #define MY_relocate_contents _bfd_relocate_contents
224 /* A hash table used for header files with N_BINCL entries. */
226 struct aout_link_includes_table
228 struct bfd_hash_table root
;
231 /* A linked list of totals that we have found for a particular header
234 struct aout_link_includes_totals
236 struct aout_link_includes_totals
*next
;
240 /* An entry in the header file hash table. */
242 struct aout_link_includes_entry
244 struct bfd_hash_entry root
;
245 /* List of totals we have found for this file. */
246 struct aout_link_includes_totals
*totals
;
249 /* During the final link step we need to pass around a bunch of
250 information, so we do it in an instance of this structure. */
252 struct aout_final_link_info
254 /* General link information. */
255 struct bfd_link_info
*info
;
258 /* Reloc file positions. */
259 file_ptr treloff
, dreloff
;
260 /* File position of symbols. */
263 struct bfd_strtab_hash
*strtab
;
264 /* Header file hash table. */
265 struct aout_link_includes_table includes
;
266 /* A buffer large enough to hold the contents of any section. */
268 /* A buffer large enough to hold the relocs of any section. */
270 /* A buffer large enough to hold the symbol map of any input BFD. */
272 /* A buffer large enough to hold output symbols of any input BFD. */
273 struct external_nlist
*output_syms
;
276 /* Copy of the link_info.separate_code boolean to select the output format with
277 separate instruction and data spaces selected by --imagic */
278 static bool separate_i_d
= false;
280 reloc_howto_type howto_table_pdp11
[] =
282 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
283 HOWTO( 0, 0, 2, 16, false, 0, complain_overflow_dont
,0,"16", true, 0x0000ffff,0x0000ffff, false),
284 HOWTO( 1, 0, 2, 16, true, 0, complain_overflow_dont
,0,"DISP16", true, 0x0000ffff,0x0000ffff, false),
285 HOWTO( 2, 0, 4, 32, false, 0, complain_overflow_dont
,0,"32", true, 0x0000ffff,0x0000ffff, false),
288 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
291 static bool aout_link_check_archive_element (bfd
*, struct bfd_link_info
*,
292 struct bfd_link_hash_entry
*,
293 const char *, bool *);
294 static bool aout_link_add_object_symbols (bfd
*, struct bfd_link_info
*);
295 static bool aout_link_add_symbols (bfd
*, struct bfd_link_info
*);
296 static bool aout_link_write_symbols (struct aout_final_link_info
*, bfd
*);
300 NAME (aout
, reloc_type_lookup
) (bfd
* abfd ATTRIBUTE_UNUSED
,
301 bfd_reloc_code_real_type code
)
306 return &howto_table_pdp11
[0];
307 case BFD_RELOC_16_PCREL
:
308 return &howto_table_pdp11
[1];
310 return &howto_table_pdp11
[2];
317 NAME (aout
, reloc_name_lookup
) (bfd
*abfd ATTRIBUTE_UNUSED
,
323 i
< sizeof (howto_table_pdp11
) / sizeof (howto_table_pdp11
[0]);
325 if (howto_table_pdp11
[i
].name
!= NULL
326 && strcasecmp (howto_table_pdp11
[i
].name
, r_name
) == 0)
327 return &howto_table_pdp11
[i
];
332 /* Disambiguate conflicts between normal symbol types and .stab symbol types
333 (undefined externals N_UNDF+N_EXT vs. global variables N_GYSM and external
334 bss symbols N_BSS+N_EXT vs. function names N_FUN) with a hack to look for
335 the ':' in the global variable or function name string. */
338 is_stab (int type
, const char *name
)
340 if (type
== N_GSYM
|| type
== N_FUN
)
341 return strchr (name
, ':') != NULL
;
346 pdp11_aout_write_headers (bfd
*abfd
, struct internal_exec
*execp
)
348 struct external_exec exec_bytes
;
350 if (adata(abfd
).magic
== undecided_magic
)
351 NAME (aout
, adjust_sizes_and_vmas
) (abfd
);
353 execp
->a_syms
= bfd_get_symcount (abfd
) * EXTERNAL_NLIST_SIZE
;
354 execp
->a_entry
= bfd_get_start_address (abfd
);
356 if (obj_textsec (abfd
)->reloc_count
> 0
357 || obj_datasec (abfd
)->reloc_count
> 0)
359 execp
->a_trsize
= execp
->a_text
;
360 execp
->a_drsize
= execp
->a_data
;
368 NAME (aout
, swap_exec_header_out
) (abfd
, execp
, & exec_bytes
);
370 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
373 if (bfd_bwrite ((void *) &exec_bytes
, (bfd_size_type
) EXEC_BYTES_SIZE
, abfd
)
377 /* Now write out reloc info, followed by syms and strings. */
378 if (bfd_get_outsymbols (abfd
) != NULL
379 && bfd_get_symcount (abfd
) != 0)
381 if (bfd_seek (abfd
, (file_ptr
) (N_SYMOFF (execp
)), SEEK_SET
) != 0)
384 if (! NAME (aout
, write_syms
) (abfd
))
388 if (obj_textsec (abfd
)->reloc_count
> 0
389 || obj_datasec (abfd
)->reloc_count
> 0)
391 if (bfd_seek (abfd
, (file_ptr
) (N_TRELOFF (execp
)), SEEK_SET
) != 0
392 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_textsec (abfd
))
393 || bfd_seek (abfd
, (file_ptr
) (N_DRELOFF (execp
)), SEEK_SET
) != 0
394 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_datasec (abfd
)))
401 /* Write an object file.
402 Section contents have already been written. We write the
403 file header, symbols, and relocation. */
406 MY(write_object_contents
) (bfd
*abfd
)
408 struct internal_exec
*execp
= exec_hdr (abfd
);
410 /* We must make certain that the magic number has been set. This
411 will normally have been done by set_section_contents, but only if
412 there actually are some section contents. */
413 if (! abfd
->output_has_begun
)
414 NAME (aout
, adjust_sizes_and_vmas
) (abfd
);
416 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
418 return WRITE_HEADERS (abfd
, execp
);
421 /* Swap the information in an executable header @var{raw_bytes} taken
422 from a raw byte stream memory image into the internal exec header
423 structure "execp". */
425 #ifndef NAME_swap_exec_header_in
427 NAME (aout
, swap_exec_header_in
) (bfd
*abfd
,
428 struct external_exec
*bytes
,
429 struct internal_exec
*execp
)
431 /* The internal_exec structure has some fields that are unused in this
432 configuration (IE for i960), so ensure that all such uninitialized
433 fields are zero'd out. There are places where two of these structs
434 are memcmp'd, and thus the contents do matter. */
435 memset ((void *) execp
, 0, sizeof (struct internal_exec
));
436 /* Now fill in fields in the execp, from the bytes in the raw data. */
437 execp
->a_info
= GET_MAGIC (abfd
, bytes
->e_info
);
438 execp
->a_text
= GET_WORD (abfd
, bytes
->e_text
);
439 execp
->a_data
= GET_WORD (abfd
, bytes
->e_data
);
440 execp
->a_bss
= GET_WORD (abfd
, bytes
->e_bss
);
441 execp
->a_syms
= GET_WORD (abfd
, bytes
->e_syms
);
442 execp
->a_entry
= GET_WORD (abfd
, bytes
->e_entry
);
444 if (GET_WORD (abfd
, bytes
->e_flag
) & A_FLAG_RELOC_STRIPPED
)
451 execp
->a_trsize
= execp
->a_text
;
452 execp
->a_drsize
= execp
->a_data
;
455 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
458 /* Swap the information in an internal exec header structure
459 "execp" into the buffer "bytes" ready for writing to disk. */
461 NAME (aout
, swap_exec_header_out
) (bfd
*abfd
,
462 struct internal_exec
*execp
,
463 struct external_exec
*bytes
)
465 /* Now fill in fields in the raw data, from the fields in the exec struct. */
466 PUT_MAGIC (abfd
, execp
->a_info
, bytes
->e_info
);
467 PUT_WORD (abfd
, execp
->a_text
, bytes
->e_text
);
468 PUT_WORD (abfd
, execp
->a_data
, bytes
->e_data
);
469 PUT_WORD (abfd
, execp
->a_bss
, bytes
->e_bss
);
470 PUT_WORD (abfd
, execp
->a_syms
, bytes
->e_syms
);
471 PUT_WORD (abfd
, execp
->a_entry
, bytes
->e_entry
);
472 PUT_WORD (abfd
, 0, bytes
->e_unused
);
474 if ((execp
->a_trsize
== 0 || execp
->a_text
== 0)
475 && (execp
->a_drsize
== 0 || execp
->a_data
== 0))
476 PUT_WORD (abfd
, A_FLAG_RELOC_STRIPPED
, bytes
->e_flag
);
477 else if (execp
->a_trsize
== execp
->a_text
478 && execp
->a_drsize
== execp
->a_data
)
479 PUT_WORD (abfd
, 0, bytes
->e_flag
);
482 /* TODO: print a proper warning message. */
483 fprintf (stderr
, "BFD:%s:%d: internal error\n", __FILE__
, __LINE__
);
484 PUT_WORD (abfd
, 0, bytes
->e_flag
);
488 /* Make all the section for an a.out file. */
491 NAME (aout
, make_sections
) (bfd
*abfd
)
493 if (obj_textsec (abfd
) == NULL
&& bfd_make_section (abfd
, ".text") == NULL
)
495 if (obj_datasec (abfd
) == NULL
&& bfd_make_section (abfd
, ".data") == NULL
)
497 if (obj_bsssec (abfd
) == NULL
&& bfd_make_section (abfd
, ".bss") == NULL
)
502 /* Some a.out variant thinks that the file open in ABFD
503 checking is an a.out file. Do some more checking, and set up
504 for access if it really is. Call back to the calling
505 environment's "finish up" function just before returning, to
506 handle any last-minute setup. */
509 NAME (aout
, some_aout_object_p
) (bfd
*abfd
,
510 struct internal_exec
*execp
,
511 bfd_cleanup (*callback_to_real_object_p
) (bfd
*))
513 struct aout_data_struct
*rawptr
, *oldrawptr
;
515 size_t amt
= sizeof (struct aout_data_struct
);
517 rawptr
= bfd_zalloc (abfd
, amt
);
521 oldrawptr
= abfd
->tdata
.aout_data
;
522 abfd
->tdata
.aout_data
= rawptr
;
524 /* Copy the contents of the old tdata struct. */
525 if (oldrawptr
!= NULL
)
526 *abfd
->tdata
.aout_data
= *oldrawptr
;
528 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
529 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
; /* Copy in the internal_exec struct. */
530 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
532 /* Set the file flags. */
533 abfd
->flags
= BFD_NO_FLAGS
;
534 if (execp
->a_drsize
|| execp
->a_trsize
)
535 abfd
->flags
|= HAS_RELOC
;
536 /* Setting of EXEC_P has been deferred to the bottom of this function. */
538 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
539 if (N_DYNAMIC (execp
))
540 abfd
->flags
|= DYNAMIC
;
542 if (N_MAGIC (execp
) == ZMAGIC
)
544 abfd
->flags
|= D_PAGED
| WP_TEXT
;
545 adata (abfd
).magic
= z_magic
;
547 else if (N_MAGIC (execp
) == NMAGIC
)
549 abfd
->flags
|= WP_TEXT
;
550 adata (abfd
).magic
= n_magic
;
552 else if (N_MAGIC (execp
) == OMAGIC
)
553 adata (abfd
).magic
= o_magic
;
554 else if (N_MAGIC (execp
) == IMAGIC
)
555 adata (abfd
).magic
= i_magic
;
558 /* Should have been checked with N_BADMAG before this routine
563 abfd
->start_address
= execp
->a_entry
;
565 obj_aout_symbols (abfd
) = NULL
;
566 abfd
->symcount
= execp
->a_syms
/ sizeof (struct external_nlist
);
568 /* The default relocation entry size is that of traditional V7 Unix. */
569 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
571 /* The default symbol entry size is that of traditional Unix. */
572 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
575 bfd_init_window (&obj_aout_sym_window (abfd
));
576 bfd_init_window (&obj_aout_string_window (abfd
));
579 obj_aout_external_syms (abfd
) = NULL
;
580 obj_aout_external_strings (abfd
) = NULL
;
581 obj_aout_sym_hashes (abfd
) = NULL
;
583 if (! NAME (aout
, make_sections
) (abfd
))
586 obj_datasec (abfd
)->size
= execp
->a_data
;
587 obj_bsssec (abfd
)->size
= execp
->a_bss
;
589 obj_textsec (abfd
)->flags
=
590 (execp
->a_trsize
!= 0
591 ? (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_RELOC
)
592 : (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
));
593 obj_datasec (abfd
)->flags
=
594 (execp
->a_drsize
!= 0
595 ? (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_RELOC
)
596 : (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
));
597 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
599 #ifdef THIS_IS_ONLY_DOCUMENTATION
600 /* The common code can't fill in these things because they depend
601 on either the start address of the text segment, the rounding
602 up of virtual addresses between segments, or the starting file
603 position of the text segment -- all of which varies among different
604 versions of a.out. */
606 /* Call back to the format-dependent code to fill in the rest of the
607 fields and do any further cleanup. Things that should be filled
608 in by the callback: */
609 struct exec
*execp
= exec_hdr (abfd
);
611 obj_textsec (abfd
)->size
= N_TXTSIZE (execp
);
612 /* Data and bss are already filled in since they're so standard. */
614 /* The virtual memory addresses of the sections. */
615 obj_textsec (abfd
)->vma
= N_TXTADDR (execp
);
616 obj_datasec (abfd
)->vma
= N_DATADDR (execp
);
617 obj_bsssec (abfd
)->vma
= N_BSSADDR (execp
);
619 /* The file offsets of the sections. */
620 obj_textsec (abfd
)->filepos
= N_TXTOFF (execp
);
621 obj_datasec (abfd
)->filepos
= N_DATOFF (execp
);
623 /* The file offsets of the relocation info. */
624 obj_textsec (abfd
)->rel_filepos
= N_TRELOFF (execp
);
625 obj_datasec (abfd
)->rel_filepos
= N_DRELOFF (execp
);
627 /* The file offsets of the string table and symbol table. */
628 obj_str_filepos (abfd
) = N_STROFF (execp
);
629 obj_sym_filepos (abfd
) = N_SYMOFF (execp
);
631 /* Determine the architecture and machine type of the object file. */
632 abfd
->obj_arch
= bfd_arch_obscure
;
634 adata(abfd
)->page_size
= TARGET_PAGE_SIZE
;
635 adata(abfd
)->segment_size
= SEGMENT_SIZE
;
636 adata(abfd
)->exec_bytes_size
= EXEC_BYTES_SIZE
;
638 return _bfd_no_cleanup
;
640 /* The architecture is encoded in various ways in various a.out variants,
641 or is not encoded at all in some of them. The relocation size depends
642 on the architecture and the a.out variant. Finally, the return value
643 is the bfd_target vector in use. If an error occurs, return zero and
644 set bfd_error to the appropriate error code.
646 Formats such as b.out, which have additional fields in the a.out
647 header, should cope with them in this callback as well. */
648 #endif /* DOCUMENTATION */
650 cleanup
= (*callback_to_real_object_p
)(abfd
);
652 /* Now that the segment addresses have been worked out, take a better
653 guess at whether the file is executable. If the entry point
654 is within the text segment, assume it is. (This makes files
655 executable even if their entry point address is 0, as long as
656 their text starts at zero.).
658 This test had to be changed to deal with systems where the text segment
659 runs at a different location than the default. The problem is that the
660 entry address can appear to be outside the text segment, thus causing an
661 erroneous conclusion that the file isn't executable.
663 To fix this, we now accept any non-zero entry point as an indication of
664 executability. This will work most of the time, since only the linker
665 sets the entry point, and that is likely to be non-zero for most systems. */
667 if (execp
->a_entry
!= 0
668 || (execp
->a_entry
>= obj_textsec (abfd
)->vma
669 && execp
->a_entry
< (obj_textsec (abfd
)->vma
670 + obj_textsec (abfd
)->size
)
671 && execp
->a_trsize
== 0
672 && execp
->a_drsize
== 0))
673 abfd
->flags
|= EXEC_P
;
677 struct stat stat_buf
;
679 /* The original heuristic doesn't work in some important cases.
680 The a.out file has no information about the text start
681 address. For files (like kernels) linked to non-standard
682 addresses (ld -Ttext nnn) the entry point may not be between
683 the default text start (obj_textsec(abfd)->vma) and
684 (obj_textsec(abfd)->vma) + text size. This is not just a mach
685 issue. Many kernels are loaded at non standard addresses. */
686 if (abfd
->iostream
!= NULL
687 && (abfd
->flags
& BFD_IN_MEMORY
) == 0
688 && (fstat(fileno((FILE *) (abfd
->iostream
)), &stat_buf
) == 0)
689 && ((stat_buf
.st_mode
& 0111) != 0))
690 abfd
->flags
|= EXEC_P
;
692 #endif /* STAT_FOR_EXEC */
697 abfd
->tdata
.aout_data
= oldrawptr
;
702 /* Initialize ABFD for use with a.out files. */
705 NAME (aout
, mkobject
) (bfd
*abfd
)
707 struct aout_data_struct
*rawptr
;
708 size_t amt
= sizeof (struct aout_data_struct
);
710 bfd_set_error (bfd_error_system_call
);
712 /* Use an intermediate variable for clarity. */
713 rawptr
= bfd_zalloc (abfd
, amt
);
718 abfd
->tdata
.aout_data
= rawptr
;
719 exec_hdr (abfd
) = &(rawptr
->e
);
721 obj_textsec (abfd
) = NULL
;
722 obj_datasec (abfd
) = NULL
;
723 obj_bsssec (abfd
) = NULL
;
728 /* Keep track of machine architecture and machine type for
729 a.out's. Return the <<machine_type>> for a particular
730 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
731 and machine can't be represented in a.out format.
733 If the architecture is understood, machine type 0 (default)
734 is always understood. */
737 NAME (aout
, machine_type
) (enum bfd_architecture arch
,
738 unsigned long machine
,
741 enum machine_type arch_flags
;
743 arch_flags
= M_UNKNOWN
;
750 || machine
== bfd_mach_sparc
751 || machine
== bfd_mach_sparc_sparclite
752 || machine
== bfd_mach_sparc_v9
)
753 arch_flags
= M_SPARC
;
754 else if (machine
== bfd_mach_sparc_sparclet
)
755 arch_flags
= M_SPARCLET
;
760 || machine
== bfd_mach_i386_i386
761 || machine
== bfd_mach_i386_i386_intel_syntax
)
766 if (machine
== 0) arch_flags
= M_ARM
;
774 case bfd_mach_mips3000
:
775 arch_flags
= M_MIPS1
;
777 case bfd_mach_mips4000
: /* MIPS3 */
778 case bfd_mach_mips4400
:
779 case bfd_mach_mips8000
: /* MIPS4 */
780 case bfd_mach_mips6000
: /* Real MIPS2: */
781 arch_flags
= M_MIPS2
;
784 arch_flags
= M_UNKNOWN
;
792 case 0: arch_flags
= M_NS32532
; break;
793 case 32032: arch_flags
= M_NS32032
; break;
794 case 32532: arch_flags
= M_NS32532
; break;
795 default: arch_flags
= M_UNKNOWN
; break;
800 /* TODO: arch_flags = M_PDP11; */
809 arch_flags
= M_UNKNOWN
;
812 if (arch_flags
!= M_UNKNOWN
)
818 /* Set the architecture and the machine of the ABFD to the
819 values ARCH and MACHINE. Verify that @ABFD's format
820 can support the architecture required. */
823 NAME (aout
, set_arch_mach
) (bfd
*abfd
,
824 enum bfd_architecture arch
,
825 unsigned long machine
)
827 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
830 if (arch
!= bfd_arch_unknown
)
834 NAME (aout
, machine_type
) (arch
, machine
, &unknown
);
839 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
841 return (*aout_backend_info(abfd
)->set_sizes
) (abfd
);
845 adjust_o_magic (bfd
*abfd
, struct internal_exec
*execp
)
847 file_ptr pos
= adata (abfd
).exec_bytes_size
;
850 asection
*text
= obj_textsec (abfd
);
851 asection
*data
= obj_datasec (abfd
);
852 asection
*bss
= obj_bsssec (abfd
);
856 if (!text
->user_set_vma
)
861 pos
+= execp
->a_text
;
862 vma
+= execp
->a_text
;
865 if (!data
->user_set_vma
)
873 execp
->a_text
+= pad
;
880 if (!bss
->user_set_vma
)
886 else if (data
->size
> 0 || bss
->size
> 0) /* PR25677: for objcopy --extract-symbol */
888 /* The VMA of the .bss section is set by the VMA of the
889 .data section plus the size of the .data section. We may
890 need to add padding bytes to make this true. */
891 pad
= bss
->vma
- vma
;
896 execp
->a_data
= data
->size
+ pad
;
898 execp
->a_bss
= bss
->size
;
900 N_SET_MAGIC (execp
, OMAGIC
);
904 adjust_z_magic (bfd
*abfd
, struct internal_exec
*execp
)
906 bfd_size_type data_pad
, text_pad
;
908 const struct aout_backend_data
*abdp
;
909 /* TRUE if text includes exec header. */
911 asection
*text
= obj_textsec (abfd
);
912 asection
*data
= obj_datasec (abfd
);
913 asection
*bss
= obj_bsssec (abfd
);
915 abdp
= aout_backend_info (abfd
);
919 && (abdp
->text_includes_header
920 || obj_aout_subformat (abfd
) == q_magic_format
));
921 text
->filepos
= (ztih
922 ? adata (abfd
).exec_bytes_size
923 : adata (abfd
).zmagic_disk_block_size
);
924 if (!text
->user_set_vma
)
926 /* ?? Do we really need to check for relocs here? */
927 text
->vma
= ((abfd
->flags
& HAS_RELOC
)
930 ? abdp
->default_text_vma
+ adata (abfd
).exec_bytes_size
931 : abdp
->default_text_vma
));
936 /* The .text section is being loaded at an unusual address. We
937 may need to pad it such that the .data section starts at a page
940 text_pad
= ((text
->filepos
- text
->vma
)
941 & (adata (abfd
).page_size
- 1));
943 text_pad
= (-text
->vma
944 & (adata (abfd
).page_size
- 1));
947 /* Find start of data. */
950 text_end
= text
->filepos
+ execp
->a_text
;
951 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
955 /* Note that if page_size == zmagic_disk_block_size, then
956 filepos == page_size, and this case is the same as the ztih
958 text_end
= execp
->a_text
;
959 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
960 text_end
+= text
->filepos
;
962 execp
->a_text
+= text_pad
;
965 if (!data
->user_set_vma
)
968 vma
= text
->vma
+ execp
->a_text
;
969 data
->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
971 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
973 text_pad
= data
->vma
- (text
->vma
+ execp
->a_text
);
974 /* Only pad the text section if the data
975 section is going to be placed after it. */
977 execp
->a_text
+= text_pad
;
979 data
->filepos
= text
->filepos
+ execp
->a_text
;
981 /* Fix up exec header while we're at it. */
982 if (ztih
&& (!abdp
|| (abdp
&& !abdp
->exec_header_not_counted
)))
983 execp
->a_text
+= adata (abfd
).exec_bytes_size
;
984 N_SET_MAGIC (execp
, ZMAGIC
);
986 /* Spec says data section should be rounded up to page boundary. */
987 execp
->a_data
= align_power (data
->size
, bss
->alignment_power
);
988 execp
->a_data
= BFD_ALIGN (execp
->a_data
, adata (abfd
).page_size
);
989 data_pad
= execp
->a_data
- data
->size
;
992 if (!bss
->user_set_vma
)
993 bss
->vma
= data
->vma
+ execp
->a_data
;
994 /* If the BSS immediately follows the data section and extra space
995 in the page is left after the data section, fudge data
996 in the header so that the bss section looks smaller by that
997 amount. We'll start the bss section there, and lie to the OS.
998 (Note that a linker script, as well as the above assignment,
999 could have explicitly set the BSS vma to immediately follow
1000 the data section.) */
1001 if (align_power (bss
->vma
, bss
->alignment_power
) == data
->vma
+ execp
->a_data
)
1002 execp
->a_bss
= data_pad
> bss
->size
? 0 : bss
->size
- data_pad
;
1004 execp
->a_bss
= bss
->size
;
1008 adjust_n_magic (bfd
*abfd
, struct internal_exec
*execp
)
1010 file_ptr pos
= adata (abfd
).exec_bytes_size
;
1013 asection
*text
= obj_textsec (abfd
);
1014 asection
*data
= obj_datasec (abfd
);
1015 asection
*bss
= obj_bsssec (abfd
);
1018 text
->filepos
= pos
;
1019 if (!text
->user_set_vma
)
1023 pos
+= execp
->a_text
;
1024 vma
+= execp
->a_text
;
1027 data
->filepos
= pos
;
1028 if (!data
->user_set_vma
)
1029 data
->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
1032 /* Since BSS follows data immediately, see if it needs alignment. */
1034 pad
= align_power (vma
, bss
->alignment_power
) - vma
;
1035 execp
->a_data
= data
->size
+ pad
;
1036 pos
+= execp
->a_data
;
1039 if (!bss
->user_set_vma
)
1044 /* Fix up exec header. */
1045 execp
->a_bss
= bss
->size
;
1046 N_SET_MAGIC (execp
, NMAGIC
);
1050 adjust_i_magic (bfd
*abfd
, struct internal_exec
*execp
)
1052 file_ptr pos
= adata (abfd
).exec_bytes_size
;
1055 asection
*text
= obj_textsec (abfd
);
1056 asection
*data
= obj_datasec (abfd
);
1057 asection
*bss
= obj_bsssec (abfd
);
1060 text
->filepos
= pos
;
1061 if (!text
->user_set_vma
)
1065 pos
+= execp
->a_text
;
1068 data
->filepos
= pos
;
1069 if (!data
->user_set_vma
)
1073 /* Since BSS follows data immediately, see if it needs alignment. */
1075 pad
= align_power (vma
, bss
->alignment_power
) - vma
;
1076 execp
->a_data
= data
->size
+ pad
;
1077 pos
+= execp
->a_data
;
1080 if (!bss
->user_set_vma
)
1085 /* Fix up exec header. */
1086 execp
->a_bss
= bss
->size
;
1087 N_SET_MAGIC (execp
, IMAGIC
);
1091 NAME (aout
, adjust_sizes_and_vmas
) (bfd
*abfd
)
1093 struct internal_exec
*execp
= exec_hdr (abfd
);
1095 if (! NAME (aout
, make_sections
) (abfd
))
1098 if (adata (abfd
).magic
!= undecided_magic
)
1101 execp
->a_text
= align_power (obj_textsec (abfd
)->size
,
1102 obj_textsec (abfd
)->alignment_power
);
1104 /* Rule (heuristic) for when to pad to a new page. Note that there
1105 are (at least) two ways demand-paged (ZMAGIC) files have been
1106 handled. Most Berkeley-based systems start the text segment at
1107 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1108 segment right after the exec header; the latter is counted in the
1109 text segment size, and is paged in by the kernel with the rest of
1112 /* This perhaps isn't the right way to do this, but made it simpler for me
1113 to understand enough to implement it. Better would probably be to go
1114 right from BFD flags to alignment/positioning characteristics. But the
1115 old code was sloppy enough about handling the flags, and had enough
1116 other magic, that it was a little hard for me to understand. I think
1117 I understand it better now, but I haven't time to do the cleanup this
1121 adata (abfd
).magic
= i_magic
;
1122 else if (abfd
->flags
& WP_TEXT
)
1123 adata (abfd
).magic
= n_magic
;
1125 adata (abfd
).magic
= o_magic
;
1127 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1129 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1131 switch (adata (abfd
).magic
)
1133 case n_magic
: str
= "NMAGIC"; break;
1134 case o_magic
: str
= "OMAGIC"; break;
1135 case i_magic
: str
= "IMAGIC"; break;
1136 case z_magic
: str
= "ZMAGIC"; break;
1141 obj_textsec (abfd
)->vma
, obj_textsec (abfd
)->size
,
1142 obj_textsec (abfd
)->alignment_power
,
1143 obj_datasec (abfd
)->vma
, obj_datasec (abfd
)->size
,
1144 obj_datasec (abfd
)->alignment_power
,
1145 obj_bsssec (abfd
)->vma
, obj_bsssec (abfd
)->size
,
1146 obj_bsssec (abfd
)->alignment_power
);
1150 switch (adata (abfd
).magic
)
1153 adjust_o_magic (abfd
, execp
);
1156 adjust_z_magic (abfd
, execp
);
1159 adjust_n_magic (abfd
, execp
);
1162 adjust_i_magic (abfd
, execp
);
1168 #ifdef BFD_AOUT_DEBUG
1169 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1170 obj_textsec (abfd
)->vma
, execp
->a_text
,
1171 obj_textsec (abfd
)->filepos
,
1172 obj_datasec (abfd
)->vma
, execp
->a_data
,
1173 obj_datasec (abfd
)->filepos
,
1174 obj_bsssec (abfd
)->vma
, execp
->a_bss
);
1180 /* Called by the BFD in response to a bfd_make_section request. */
1183 NAME (aout
, new_section_hook
) (bfd
*abfd
, asection
*newsect
)
1185 /* Align to double at least. */
1186 newsect
->alignment_power
= bfd_get_arch_info(abfd
)->section_align_power
;
1188 if (bfd_get_format (abfd
) == bfd_object
)
1190 if (obj_textsec (abfd
) == NULL
1191 && !strcmp (newsect
->name
, ".text"))
1193 obj_textsec(abfd
)= newsect
;
1194 newsect
->target_index
= N_TEXT
;
1196 else if (obj_datasec (abfd
) == NULL
1197 && !strcmp (newsect
->name
, ".data"))
1199 obj_datasec (abfd
) = newsect
;
1200 newsect
->target_index
= N_DATA
;
1202 else if (obj_bsssec (abfd
) == NULL
1203 && !strcmp (newsect
->name
, ".bss"))
1205 obj_bsssec (abfd
) = newsect
;
1206 newsect
->target_index
= N_BSS
;
1210 /* We allow more than three sections internally. */
1211 return _bfd_generic_new_section_hook (abfd
, newsect
);
1215 NAME (aout
, set_section_contents
) (bfd
*abfd
,
1217 const void * location
,
1219 bfd_size_type count
)
1221 if (! abfd
->output_has_begun
)
1223 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
1227 if (section
== obj_bsssec (abfd
))
1229 bfd_set_error (bfd_error_no_contents
);
1233 if (section
!= obj_textsec (abfd
)
1234 && section
!= obj_datasec (abfd
))
1237 /* xgettext:c-format */
1238 (_("%pB: can not represent section `%pA' in a.out object file format"),
1240 bfd_set_error (bfd_error_nonrepresentable_section
);
1246 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
1247 || bfd_bwrite (location
, count
, abfd
) != count
)
1254 /* Read the external symbols from an a.out file. */
1257 aout_get_external_symbols (bfd
*abfd
)
1259 if (obj_aout_external_syms (abfd
) == NULL
)
1261 bfd_size_type count
;
1262 struct external_nlist
*syms
;
1264 count
= exec_hdr (abfd
)->a_syms
/ EXTERNAL_NLIST_SIZE
;
1266 /* PR 17512: file: 011f5a08. */
1269 obj_aout_external_syms (abfd
) = NULL
;
1270 obj_aout_external_sym_count (abfd
) = count
;
1275 if (! bfd_get_file_window (abfd
, obj_sym_filepos (abfd
),
1276 exec_hdr (abfd
)->a_syms
,
1277 &obj_aout_sym_window (abfd
), true))
1279 syms
= (struct external_nlist
*) obj_aout_sym_window (abfd
).data
;
1281 /* We allocate using malloc to make the values easy to free
1282 later on. If we put them on the objalloc it might not be
1283 possible to free them. */
1284 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1286 syms
= (struct external_nlist
*)
1287 _bfd_malloc_and_read (abfd
, count
* EXTERNAL_NLIST_SIZE
,
1288 count
* EXTERNAL_NLIST_SIZE
);
1293 obj_aout_external_syms (abfd
) = syms
;
1294 obj_aout_external_sym_count (abfd
) = count
;
1297 if (obj_aout_external_strings (abfd
) == NULL
1298 && exec_hdr (abfd
)->a_syms
!= 0)
1300 unsigned char string_chars
[BYTES_IN_LONG
];
1301 bfd_size_type stringsize
;
1303 bfd_size_type amt
= BYTES_IN_LONG
;
1305 /* Get the size of the strings. */
1306 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
1307 || bfd_bread ((void *) string_chars
, amt
, abfd
) != amt
)
1309 stringsize
= H_GET_32 (abfd
, string_chars
);
1310 if (stringsize
== 0)
1312 else if (stringsize
< BYTES_IN_LONG
1313 || (size_t) stringsize
!= stringsize
)
1315 bfd_set_error (bfd_error_bad_value
);
1320 if (stringsize
>= BYTES_IN_LONG
)
1322 if (! bfd_get_file_window (abfd
, obj_str_filepos (abfd
), stringsize
+ 1,
1323 &obj_aout_string_window (abfd
), true))
1325 strings
= (char *) obj_aout_string_window (abfd
).data
;
1330 strings
= (char *) bfd_malloc (stringsize
+ 1);
1331 if (strings
== NULL
)
1334 if (stringsize
>= BYTES_IN_LONG
)
1336 amt
= stringsize
- BYTES_IN_LONG
;
1337 if (bfd_bread (strings
+ BYTES_IN_LONG
, amt
, abfd
) != amt
)
1344 /* Ensure that a zero index yields an empty string. */
1345 if (stringsize
>= BYTES_IN_WORD
)
1346 memset (strings
, 0, BYTES_IN_LONG
);
1348 /* Ensure that the string buffer is NUL terminated. */
1349 strings
[stringsize
] = 0;
1351 obj_aout_external_strings (abfd
) = strings
;
1352 obj_aout_external_string_size (abfd
) = stringsize
;
1358 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1359 and symbol->value fields of CACHE_PTR will be set from the a.out
1360 nlist structure. This function is responsible for setting
1361 symbol->flags and symbol->section, and adjusting symbol->value. */
1364 translate_from_native_sym_flags (bfd
*abfd
,
1365 aout_symbol_type
*cache_ptr
)
1369 if (is_stab (cache_ptr
->type
, cache_ptr
->symbol
.name
))
1373 /* This is a debugging symbol. */
1374 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1376 /* Work out the symbol section. */
1377 switch (cache_ptr
->type
)
1385 sec
= obj_textsec (abfd
);
1389 sec
= obj_datasec (abfd
);
1393 sec
= obj_bsssec (abfd
);
1396 sec
= bfd_abs_section_ptr
;
1400 cache_ptr
->symbol
.section
= sec
;
1401 cache_ptr
->symbol
.value
-= sec
->vma
;
1406 /* Get the default visibility. This does not apply to all types, so
1407 we just hold it in a local variable to use if wanted. */
1408 if ((cache_ptr
->type
& N_EXT
) == 0)
1409 visible
= BSF_LOCAL
;
1411 visible
= BSF_GLOBAL
;
1413 switch (cache_ptr
->type
)
1416 case N_ABS
: case N_ABS
| N_EXT
:
1417 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1418 cache_ptr
->symbol
.flags
= visible
;
1421 case N_UNDF
| N_EXT
:
1422 if (cache_ptr
->symbol
.value
!= 0)
1424 /* This is a common symbol. */
1425 cache_ptr
->symbol
.flags
= BSF_GLOBAL
;
1426 cache_ptr
->symbol
.section
= bfd_com_section_ptr
;
1430 cache_ptr
->symbol
.flags
= 0;
1431 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1435 case N_TEXT
: case N_TEXT
| N_EXT
:
1436 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1437 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1438 cache_ptr
->symbol
.flags
= visible
;
1441 case N_DATA
: case N_DATA
| N_EXT
:
1442 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1443 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1444 cache_ptr
->symbol
.flags
= visible
;
1447 case N_BSS
: case N_BSS
| N_EXT
:
1448 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1449 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1450 cache_ptr
->symbol
.flags
= visible
;
1457 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1460 translate_to_native_sym_flags (bfd
*abfd
,
1462 struct external_nlist
*sym_pointer
)
1464 bfd_vma value
= cache_ptr
->value
;
1467 const char *name
= cache_ptr
->name
!= NULL
? cache_ptr
->name
: "*unknown*";
1469 /* Mask out any existing type bits in case copying from one section
1471 if (!is_stab (sym_pointer
->e_type
[0], name
))
1472 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1474 sec
= bfd_asymbol_section (cache_ptr
);
1479 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1482 /* xgettext:c-format */
1483 (_("%pB: can not represent section for symbol `%s' in a.out object file format"),
1485 bfd_set_error (bfd_error_nonrepresentable_section
);
1489 if (sec
->output_section
!= NULL
)
1491 off
= sec
->output_offset
;
1492 sec
= sec
->output_section
;
1495 if (bfd_is_abs_section (sec
))
1496 sym_pointer
->e_type
[0] |= N_ABS
;
1497 else if (sec
== obj_textsec (abfd
))
1498 sym_pointer
->e_type
[0] |= N_TEXT
;
1499 else if (sec
== obj_datasec (abfd
))
1500 sym_pointer
->e_type
[0] |= N_DATA
;
1501 else if (sec
== obj_bsssec (abfd
))
1502 sym_pointer
->e_type
[0] |= N_BSS
;
1503 else if (bfd_is_und_section (sec
))
1504 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1505 else if (bfd_is_com_section (sec
))
1506 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1510 /* xgettext:c-format */
1511 (_("%pB: can not represent section `%pA' in a.out object file format"),
1513 bfd_set_error (bfd_error_nonrepresentable_section
);
1517 /* Turn the symbol from section relative to absolute again */
1518 value
+= sec
->vma
+ off
;
1520 if ((cache_ptr
->flags
& BSF_DEBUGGING
) != 0)
1521 sym_pointer
->e_type
[0] = ((aout_symbol_type
*) cache_ptr
)->type
;
1522 else if ((cache_ptr
->flags
& BSF_GLOBAL
) != 0)
1523 sym_pointer
->e_type
[0] |= N_EXT
;
1525 PUT_WORD(abfd
, value
, sym_pointer
->e_value
);
1530 /* Native-level interface to symbols. */
1533 NAME (aout
, make_empty_symbol
) (bfd
*abfd
)
1535 size_t amt
= sizeof (aout_symbol_type
);
1536 aout_symbol_type
*new_symbol_type
= bfd_zalloc (abfd
, amt
);
1538 if (!new_symbol_type
)
1540 new_symbol_type
->symbol
.the_bfd
= abfd
;
1542 return &new_symbol_type
->symbol
;
1545 /* Translate a set of external symbols into internal symbols. */
1548 NAME (aout
, translate_symbol_table
) (bfd
*abfd
,
1549 aout_symbol_type
*in
,
1550 struct external_nlist
*ext
,
1551 bfd_size_type count
,
1553 bfd_size_type strsize
,
1556 struct external_nlist
*ext_end
;
1558 ext_end
= ext
+ count
;
1559 for (; ext
< ext_end
; ext
++, in
++)
1564 x
= GET_WORD (abfd
, ext
->e_strx
);
1565 in
->symbol
.the_bfd
= abfd
;
1567 /* For the normal symbols, the zero index points at the number
1568 of bytes in the string table but is to be interpreted as the
1569 null string. For the dynamic symbols, the number of bytes in
1570 the string table is stored in the __DYNAMIC structure and the
1571 zero index points at an actual string. */
1572 if (x
== 0 && ! dynamic
)
1573 in
->symbol
.name
= "";
1574 else if (x
< strsize
)
1575 in
->symbol
.name
= str
+ x
;
1579 (_("%pB: invalid string offset %" PRIu64
" >= %" PRIu64
),
1580 abfd
, (uint64_t) x
, (uint64_t) strsize
);
1581 bfd_set_error (bfd_error_bad_value
);
1585 ovly
= H_GET_8 (abfd
, ext
->e_ovly
);
1589 (_("%pB: symbol indicates overlay (not supported)"), abfd
);
1590 bfd_set_error (bfd_error_bad_value
);
1594 in
->symbol
.value
= GET_WORD (abfd
, ext
->e_value
);
1595 /* e_desc is zero for normal symbols but for .stab symbols it
1596 carries the desc field in our extended 2.11BSD format. */
1597 in
->desc
= H_GET_16 (abfd
, ext
->e_desc
);
1599 in
->type
= H_GET_8 (abfd
, ext
->e_type
);
1600 in
->symbol
.udata
.p
= NULL
;
1602 if (! translate_from_native_sym_flags (abfd
, in
))
1606 in
->symbol
.flags
|= BSF_DYNAMIC
;
1612 /* We read the symbols into a buffer, which is discarded when this
1613 function exits. We read the strings into a buffer large enough to
1614 hold them all plus all the cached symbol entries. */
1617 NAME (aout
, slurp_symbol_table
) (bfd
*abfd
)
1619 struct external_nlist
*old_external_syms
;
1620 aout_symbol_type
*cached
;
1621 bfd_size_type cached_size
;
1623 /* If there's no work to be done, don't do any. */
1624 if (obj_aout_symbols (abfd
) != NULL
)
1627 old_external_syms
= obj_aout_external_syms (abfd
);
1629 if (! aout_get_external_symbols (abfd
))
1632 cached_size
= obj_aout_external_sym_count (abfd
);
1633 cached_size
*= sizeof (aout_symbol_type
);
1634 cached
= bfd_zmalloc (cached_size
);
1635 if (cached
== NULL
&& cached_size
!= 0)
1638 /* Convert from external symbol information to internal. */
1639 if (! (NAME (aout
, translate_symbol_table
)
1641 obj_aout_external_syms (abfd
),
1642 obj_aout_external_sym_count (abfd
),
1643 obj_aout_external_strings (abfd
),
1644 obj_aout_external_string_size (abfd
),
1651 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
1653 obj_aout_symbols (abfd
) = cached
;
1655 /* It is very likely that anybody who calls this function will not
1656 want the external symbol information, so if it was allocated
1657 because of our call to aout_get_external_symbols, we free it up
1658 right away to save space. */
1659 if (old_external_syms
== NULL
1660 && obj_aout_external_syms (abfd
) != NULL
)
1663 bfd_free_window (&obj_aout_sym_window (abfd
));
1665 free (obj_aout_external_syms (abfd
));
1667 obj_aout_external_syms (abfd
) = NULL
;
1673 /* We use a hash table when writing out symbols so that we only write
1674 out a particular string once. This helps particularly when the
1675 linker writes out stabs debugging entries, because each different
1676 contributing object file tends to have many duplicate stabs
1679 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1680 if BFD_TRADITIONAL_FORMAT is set. */
1682 /* Get the index of a string in a strtab, adding it if it is not
1685 static inline bfd_size_type
1686 add_to_stringtab (bfd
*abfd
,
1687 struct bfd_strtab_hash
*tab
,
1692 bfd_size_type str_index
;
1694 /* An index of 0 always means the empty string. */
1695 if (str
== 0 || *str
== '\0')
1698 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1699 doesn't understand a hashed string table. */
1701 if ((abfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1704 str_index
= _bfd_stringtab_add (tab
, str
, hash
, copy
);
1706 if (str_index
!= (bfd_size_type
) -1)
1707 /* Add BYTES_IN_LONG to the return value to account for the
1708 space taken up by the string table size. */
1709 str_index
+= BYTES_IN_LONG
;
1714 /* Write out a strtab. ABFD is already at the right location in the
1718 emit_stringtab (bfd
*abfd
, struct bfd_strtab_hash
*tab
)
1720 bfd_byte buffer
[BYTES_IN_LONG
];
1722 /* The string table starts with the size. */
1723 H_PUT_32 (abfd
, _bfd_stringtab_size (tab
) + BYTES_IN_LONG
, buffer
);
1724 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) BYTES_IN_LONG
, abfd
)
1728 return _bfd_stringtab_emit (abfd
, tab
);
1732 NAME (aout
, write_syms
) (bfd
*abfd
)
1734 unsigned int count
;
1735 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1736 struct bfd_strtab_hash
*strtab
;
1738 strtab
= _bfd_stringtab_init ();
1742 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1744 asymbol
*g
= generic
[count
];
1746 struct external_nlist nsp
;
1748 indx
= add_to_stringtab (abfd
, strtab
, g
->name
, false);
1749 if (indx
== (bfd_size_type
) -1)
1751 PUT_WORD (abfd
, indx
, nsp
.e_strx
);
1753 if (bfd_asymbol_flavour(g
) == abfd
->xvec
->flavour
)
1755 H_PUT_16 (abfd
, aout_symbol (g
)->desc
, nsp
.e_desc
);
1756 H_PUT_8 (abfd
, 0, nsp
.e_ovly
);
1757 H_PUT_8 (abfd
, aout_symbol (g
)->type
, nsp
.e_type
);
1761 H_PUT_16 (abfd
, 0, nsp
.e_desc
);
1762 H_PUT_8 (abfd
, 0, nsp
.e_ovly
);
1763 H_PUT_8 (abfd
, 0, nsp
.e_type
);
1766 if (! translate_to_native_sym_flags (abfd
, g
, &nsp
))
1769 if (bfd_bwrite ((void *)&nsp
, (bfd_size_type
) EXTERNAL_NLIST_SIZE
, abfd
)
1770 != EXTERNAL_NLIST_SIZE
)
1773 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1774 here, at the end. */
1778 if (! emit_stringtab (abfd
, strtab
))
1781 _bfd_stringtab_free (strtab
);
1786 _bfd_stringtab_free (strtab
);
1792 NAME (aout
, canonicalize_symtab
) (bfd
*abfd
, asymbol
**location
)
1794 unsigned int counter
= 0;
1795 aout_symbol_type
*symbase
;
1797 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
1800 for (symbase
= obj_aout_symbols (abfd
); counter
++ < bfd_get_symcount (abfd
);)
1801 *(location
++) = (asymbol
*)(symbase
++);
1803 return bfd_get_symcount (abfd
);
1807 /* Output extended relocation information to a file in target byte order. */
1810 pdp11_aout_swap_reloc_out (bfd
*abfd
, arelent
*g
, bfd_byte
*natptr
)
1816 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1817 asection
*output_section
= sym
->section
->output_section
;
1820 fprintf (stderr
, "BFD: can't do this reloc addend stuff\n");
1822 r_pcrel
= g
->howto
->pc_relative
;
1824 if (bfd_is_abs_section (output_section
))
1826 else if (output_section
== obj_textsec (abfd
))
1828 else if (output_section
== obj_datasec (abfd
))
1830 else if (output_section
== obj_bsssec (abfd
))
1832 else if (bfd_is_und_section (output_section
))
1834 else if (bfd_is_com_section (output_section
))
1839 BFD_ASSERT (r_type
!= -1);
1844 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
1846 reloc_entry
= r_index
<< 4 | r_type
| r_pcrel
;
1848 PUT_WORD (abfd
, reloc_entry
, natptr
);
1851 /* BFD deals internally with all things based from the section they're
1852 in. so, something in 10 bytes into a text section with a base of
1853 50 would have a symbol (.text+10) and know .text vma was 50.
1855 Aout keeps all it's symbols based from zero, so the symbol would
1856 contain 60. This macro subs the base of each section from the value
1857 to give the true offset from the section */
1860 #define MOVE_ADDRESS(ad) \
1863 /* Undefined symbol. */ \
1864 if (symbols != NULL && r_index < bfd_get_symcount (abfd)) \
1865 cache_ptr->sym_ptr_ptr = symbols + r_index; \
1867 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1868 cache_ptr->addend = ad; \
1872 /* Defined, section relative. replace symbol with pointer to \
1873 symbol which points to section. */ \
1877 case N_TEXT | N_EXT: \
1878 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
1879 cache_ptr->addend = ad - su->textsec->vma; \
1882 case N_DATA | N_EXT: \
1883 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
1884 cache_ptr->addend = ad - su->datasec->vma; \
1887 case N_BSS | N_EXT: \
1888 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
1889 cache_ptr->addend = ad - su->bsssec->vma; \
1893 case N_ABS | N_EXT: \
1894 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1895 cache_ptr->addend = ad; \
1901 pdp11_aout_swap_reloc_in (bfd
* abfd
,
1903 arelent
* cache_ptr
,
1904 bfd_size_type offset
,
1906 bfd_size_type symcount
)
1908 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
1909 unsigned int r_index
;
1914 reloc_entry
= GET_WORD (abfd
, (void *) bytes
);
1916 r_pcrel
= reloc_entry
& RELFLG
;
1918 cache_ptr
->address
= offset
;
1919 cache_ptr
->howto
= howto_table_pdp11
+ (r_pcrel
? 1 : 0);
1921 if ((reloc_entry
& RTYPE
) == RABS
)
1924 r_index
= RINDEX (reloc_entry
);
1926 /* r_extern reflects whether the symbol the reloc is against is
1928 r_extern
= (reloc_entry
& RTYPE
) == REXT
;
1930 if (r_extern
&& r_index
>= symcount
)
1932 /* We could arrange to return an error, but it might be useful
1933 to see the file even if it is bad. FIXME: Of course this
1934 means that objdump -r *doesn't* see the actual reloc, and
1935 objcopy silently writes a different reloc. */
1943 /* Read and swap the relocs for a section. */
1946 NAME (aout
, slurp_reloc_table
) (bfd
*abfd
, sec_ptr asect
, asymbol
**symbols
)
1949 bfd_size_type count
;
1950 bfd_size_type reloc_size
;
1952 arelent
*reloc_cache
;
1954 unsigned int counter
= 0;
1957 if (asect
->relocation
)
1960 if (asect
->flags
& SEC_CONSTRUCTOR
)
1963 if (asect
== obj_datasec (abfd
))
1964 reloc_size
= exec_hdr(abfd
)->a_drsize
;
1965 else if (asect
== obj_textsec (abfd
))
1966 reloc_size
= exec_hdr(abfd
)->a_trsize
;
1967 else if (asect
== obj_bsssec (abfd
))
1971 bfd_set_error (bfd_error_invalid_operation
);
1975 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
1977 relocs
= _bfd_malloc_and_read (abfd
, reloc_size
, reloc_size
);
1978 if (relocs
== NULL
&& reloc_size
!= 0)
1981 each_size
= obj_reloc_entry_size (abfd
);
1982 count
= reloc_size
/ each_size
;
1984 /* Count the number of NON-ZERO relocs, this is the count we want. */
1986 unsigned int real_count
= 0;
1988 for (counter
= 0; counter
< count
; counter
++)
1992 x
= GET_WORD (abfd
, (char *) relocs
+ each_size
* counter
);
2000 reloc_cache
= bfd_zmalloc (count
* sizeof (arelent
));
2001 if (reloc_cache
== NULL
&& count
!= 0)
2004 cache_ptr
= reloc_cache
;
2009 counter
++, rptr
+= RELOC_SIZE
, cache_ptr
++)
2011 while (GET_WORD (abfd
, (void *) rptr
) == 0)
2014 if ((char *) rptr
>= (char *) relocs
+ reloc_size
)
2018 pdp11_aout_swap_reloc_in (abfd
, rptr
, cache_ptr
,
2019 (bfd_size_type
) ((char *) rptr
- (char *) relocs
),
2021 (bfd_size_type
) bfd_get_symcount (abfd
));
2024 /* Just in case, if rptr >= relocs + reloc_size should happen
2026 BFD_ASSERT (counter
== count
);
2030 asect
->relocation
= reloc_cache
;
2031 asect
->reloc_count
= cache_ptr
- reloc_cache
;
2036 /* Write out a relocation section into an object file. */
2039 NAME (aout
, squirt_out_relocs
) (bfd
*abfd
, asection
*section
)
2042 unsigned char *native
;
2043 unsigned int count
= section
->reloc_count
;
2044 bfd_size_type natsize
;
2046 natsize
= section
->size
;
2047 native
= bfd_zalloc (abfd
, natsize
);
2051 generic
= section
->orelocation
;
2052 if (generic
!= NULL
)
2058 if ((*generic
)->howto
== NULL
2059 || (*generic
)->sym_ptr_ptr
== NULL
)
2061 bfd_set_error (bfd_error_invalid_operation
);
2062 _bfd_error_handler (_("%pB: attempt to write out "
2063 "unknown reloc type"), abfd
);
2064 bfd_release (abfd
, native
);
2067 r
= native
+ (*generic
)->address
;
2068 pdp11_aout_swap_reloc_out (abfd
, *generic
, r
);
2074 if (bfd_bwrite ((void *) native
, natsize
, abfd
) != natsize
)
2076 bfd_release (abfd
, native
);
2080 bfd_release (abfd
, native
);
2084 /* This is stupid. This function should be a boolean predicate. */
2087 NAME (aout
, canonicalize_reloc
) (bfd
*abfd
,
2092 arelent
*tblptr
= section
->relocation
;
2095 if (section
== obj_bsssec (abfd
))
2101 if (!(tblptr
|| NAME (aout
, slurp_reloc_table
)(abfd
, section
, symbols
)))
2104 if (section
->flags
& SEC_CONSTRUCTOR
)
2106 arelent_chain
*chain
= section
->constructor_chain
;
2108 for (count
= 0; count
< section
->reloc_count
; count
++)
2110 *relptr
++ = &chain
->relent
;
2111 chain
= chain
->next
;
2116 tblptr
= section
->relocation
;
2118 for (count
= 0; count
++ < section
->reloc_count
;)
2119 *relptr
++ = tblptr
++;
2124 return section
->reloc_count
;
2128 NAME (aout
, get_reloc_upper_bound
) (bfd
*abfd
, sec_ptr asect
)
2132 if (asect
->flags
& SEC_CONSTRUCTOR
)
2133 count
= asect
->reloc_count
;
2134 else if (asect
== obj_datasec (abfd
))
2135 count
= exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
2136 else if (asect
== obj_textsec (abfd
))
2137 count
= exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
2138 else if (asect
== obj_bsssec (abfd
))
2142 bfd_set_error (bfd_error_invalid_operation
);
2146 if (count
>= LONG_MAX
/ sizeof (arelent
*)
2147 || _bfd_mul_overflow (count
, obj_reloc_entry_size (abfd
), &raw
))
2149 bfd_set_error (bfd_error_file_too_big
);
2152 if (!bfd_write_p (abfd
))
2154 ufile_ptr filesize
= bfd_get_file_size (abfd
);
2155 if (filesize
!= 0 && raw
> filesize
)
2157 bfd_set_error (bfd_error_file_truncated
);
2161 return (count
+ 1) * sizeof (arelent
*);
2166 NAME (aout
, get_symtab_upper_bound
) (bfd
*abfd
)
2168 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
2171 return (bfd_get_symcount (abfd
) + 1) * (sizeof (aout_symbol_type
*));
2175 NAME (aout
, get_lineno
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2176 asymbol
* symbol ATTRIBUTE_UNUSED
)
2182 NAME (aout
, get_symbol_info
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2186 bfd_symbol_info (symbol
, ret
);
2188 if (ret
->type
== '?')
2190 int type_code
= aout_symbol(symbol
)->type
& 0xff;
2191 const char *stab_name
= bfd_get_stab_name (type_code
);
2192 static char buf
[10];
2194 if (stab_name
== NULL
)
2196 sprintf(buf
, "(%d)", type_code
);
2200 ret
->stab_type
= type_code
;
2201 ret
->stab_other
= (unsigned) (aout_symbol(symbol
)->other
& 0xff);
2202 ret
->stab_desc
= (unsigned) (aout_symbol(symbol
)->desc
& 0xffff);
2203 ret
->stab_name
= stab_name
;
2208 NAME (aout
, print_symbol
) (bfd
* abfd
,
2211 bfd_print_symbol_type how
)
2213 FILE *file
= (FILE *) afile
;
2217 case bfd_print_symbol_name
:
2219 fprintf(file
,"%s", symbol
->name
);
2221 case bfd_print_symbol_more
:
2222 fprintf(file
,"%4x %2x %2x",
2223 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2224 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2225 (unsigned) (aout_symbol (symbol
)->type
));
2227 case bfd_print_symbol_all
:
2229 const char *section_name
= symbol
->section
->name
;
2231 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2233 fprintf (file
," %-5s %04x %02x %02x",
2235 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2236 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2237 (unsigned) (aout_symbol (symbol
)->type
& 0xff));
2239 fprintf(file
," %s", symbol
->name
);
2245 /* If we don't have to allocate more than 1MB to hold the generic
2246 symbols, we use the generic minisymbol method: it's faster, since
2247 it only translates the symbols once, not multiple times. */
2248 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2250 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2251 symbols. The minisymbol_to_symbol function translates these into
2252 BFD asymbol structures. */
2255 NAME (aout
, read_minisymbols
) (bfd
*abfd
,
2258 unsigned int *sizep
)
2261 /* We could handle the dynamic symbols here as well, but it's
2262 easier to hand them off. */
2263 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2265 if (! aout_get_external_symbols (abfd
))
2268 if (obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2269 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2271 *minisymsp
= (void *) obj_aout_external_syms (abfd
);
2273 /* By passing the external symbols back from this routine, we are
2274 giving up control over the memory block. Clear
2275 obj_aout_external_syms, so that we do not try to free it
2277 obj_aout_external_syms (abfd
) = NULL
;
2279 *sizep
= EXTERNAL_NLIST_SIZE
;
2280 return obj_aout_external_sym_count (abfd
);
2283 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2284 unmodified a.out symbol. The SYM argument is a structure returned
2285 by bfd_make_empty_symbol, which we fill in here. */
2288 NAME (aout
, minisymbol_to_symbol
) (bfd
*abfd
,
2290 const void * minisym
,
2294 || obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2295 return _bfd_generic_minisymbol_to_symbol (abfd
, dynamic
, minisym
, sym
);
2297 memset (sym
, 0, sizeof (aout_symbol_type
));
2299 /* We call translate_symbol_table to translate a single symbol. */
2300 if (! (NAME (aout
, translate_symbol_table
)
2302 (aout_symbol_type
*) sym
,
2303 (struct external_nlist
*) minisym
,
2305 obj_aout_external_strings (abfd
),
2306 obj_aout_external_string_size (abfd
),
2313 /* Provided a BFD, a section and an offset into the section, calculate
2314 and return the name of the source file and the line nearest to the
2318 NAME (aout
, find_nearest_line
) (bfd
*abfd
,
2322 const char **filename_ptr
,
2323 const char **functionname_ptr
,
2324 unsigned int *line_ptr
,
2325 unsigned int *discriminator_ptr
)
2327 /* Run down the file looking for the filename, function and linenumber. */
2329 const char *directory_name
= NULL
;
2330 const char *main_file_name
= NULL
;
2331 const char *current_file_name
= NULL
;
2332 const char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2333 bfd_vma low_line_vma
= 0;
2334 bfd_vma low_func_vma
= 0;
2336 size_t filelen
, funclen
;
2339 *filename_ptr
= bfd_get_filename (abfd
);
2340 *functionname_ptr
= NULL
;
2342 if (discriminator_ptr
)
2343 *discriminator_ptr
= 0;
2345 if (symbols
!= NULL
)
2347 for (p
= symbols
; *p
; p
++)
2349 aout_symbol_type
*q
= (aout_symbol_type
*)(*p
);
2354 /* If this looks like a file name symbol, and it comes after
2355 the line number we have found so far, but before the
2356 offset, then we have probably not found the right line
2358 if (q
->symbol
.value
<= offset
2359 && ((q
->symbol
.value
> low_line_vma
2360 && (line_file_name
!= NULL
2362 || (q
->symbol
.value
> low_func_vma
2365 const char * symname
;
2367 symname
= q
->symbol
.name
;
2370 && strlen (symname
) > 2
2371 && strcmp (symname
+ strlen (symname
) - 2, ".o") == 0)
2373 if (q
->symbol
.value
> low_line_vma
)
2376 line_file_name
= NULL
;
2378 if (q
->symbol
.value
> low_func_vma
)
2385 /* If this symbol is less than the offset, but greater than
2386 the line number we have found so far, then we have not
2387 found the right line number. */
2388 if (q
->symbol
.value
<= offset
)
2390 if (q
->symbol
.value
> low_line_vma
)
2393 line_file_name
= NULL
;
2395 if (q
->symbol
.value
> low_func_vma
)
2399 main_file_name
= current_file_name
= q
->symbol
.name
;
2400 /* Look ahead to next symbol to check if that too is an N_SO. */
2404 q
= (aout_symbol_type
*)(*p
);
2405 if (q
->type
!= (int) N_SO
)
2408 /* Found a second N_SO First is directory; second is filename. */
2409 directory_name
= current_file_name
;
2410 main_file_name
= current_file_name
= q
->symbol
.name
;
2411 if (obj_textsec(abfd
) != section
)
2415 current_file_name
= q
->symbol
.name
;
2421 /* We'll keep this if it resolves nearer than the one we have
2423 if (q
->symbol
.value
>= low_line_vma
2424 && q
->symbol
.value
<= offset
)
2426 *line_ptr
= q
->desc
;
2427 low_line_vma
= q
->symbol
.value
;
2428 line_file_name
= current_file_name
;
2434 /* We'll keep this if it is nearer than the one we have already. */
2435 if (q
->symbol
.value
>= low_func_vma
&&
2436 q
->symbol
.value
<= offset
)
2438 low_func_vma
= q
->symbol
.value
;
2439 func
= (asymbol
*) q
;
2441 else if (q
->symbol
.value
> offset
)
2451 main_file_name
= line_file_name
;
2453 if (main_file_name
== NULL
2454 || main_file_name
[0] == '/'
2455 || directory_name
== NULL
)
2458 filelen
= strlen (directory_name
) + strlen (main_file_name
);
2462 funclen
= strlen (bfd_asymbol_name (func
));
2464 free (adata (abfd
).line_buf
);
2465 if (filelen
+ funclen
== 0)
2466 adata (abfd
).line_buf
= buf
= NULL
;
2469 buf
= bfd_malloc ((bfd_size_type
) filelen
+ funclen
+ 3);
2470 adata (abfd
).line_buf
= buf
;
2475 if (main_file_name
!= NULL
)
2477 if (main_file_name
[0] == '/' || directory_name
== NULL
)
2478 *filename_ptr
= main_file_name
;
2482 /* PR binutils/20891: In a corrupt input file both
2483 main_file_name and directory_name can be empty... */
2484 * filename_ptr
= NULL
;
2487 snprintf (buf
, filelen
+ 1, "%s%s", directory_name
,
2489 *filename_ptr
= buf
;
2497 const char *function
= func
->name
;
2502 /* PR binutils/20892: In a corrupt input file func can be empty. */
2503 * functionname_ptr
= NULL
;
2506 /* The caller expects a symbol name. We actually have a
2507 function name, without the leading underscore. Put the
2508 underscore back in, so that the caller gets a symbol name. */
2509 if (bfd_get_symbol_leading_char (abfd
) == '\0')
2510 strcpy (buf
, function
);
2513 buf
[0] = bfd_get_symbol_leading_char (abfd
);
2514 strcpy (buf
+ 1, function
);
2517 /* Have to remove : stuff. */
2518 colon
= strchr (buf
, ':');
2521 *functionname_ptr
= buf
;
2528 NAME (aout
, sizeof_headers
) (bfd
*abfd
,
2529 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2531 return adata (abfd
).exec_bytes_size
;
2534 /* Free all information we have cached for this BFD. We can always
2535 read it again later if we need it. */
2538 NAME (aout
, bfd_free_cached_info
) (bfd
*abfd
)
2542 if (bfd_get_format (abfd
) != bfd_object
2543 || abfd
->tdata
.aout_data
== NULL
)
2546 #define BFCI_FREE(x) do { free (x); x = NULL; } while (0)
2547 BFCI_FREE (adata (abfd
).line_buf
);
2548 BFCI_FREE (obj_aout_symbols (abfd
));
2550 obj_aout_external_syms (abfd
) = 0;
2551 bfd_free_window (&obj_aout_sym_window (abfd
));
2552 bfd_free_window (&obj_aout_string_window (abfd
));
2553 obj_aout_external_strings (abfd
) = 0;
2555 BFCI_FREE (obj_aout_external_syms (abfd
));
2556 BFCI_FREE (obj_aout_external_strings (abfd
));
2558 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2559 BFCI_FREE (o
->relocation
);
2565 /* Routine to create an entry in an a.out link hash table. */
2567 struct bfd_hash_entry
*
2568 NAME (aout
, link_hash_newfunc
) (struct bfd_hash_entry
*entry
,
2569 struct bfd_hash_table
*table
,
2572 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2574 /* Allocate the structure if it has not already been allocated by a
2577 ret
= bfd_hash_allocate (table
, sizeof (* ret
));
2581 /* Call the allocation method of the superclass. */
2582 ret
= (struct aout_link_hash_entry
*)
2583 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
);
2586 /* Set local fields. */
2587 ret
->written
= false;
2591 return (struct bfd_hash_entry
*) ret
;
2594 /* Initialize an a.out link hash table. */
2597 NAME (aout
, link_hash_table_init
) (struct aout_link_hash_table
*table
,
2599 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
2600 struct bfd_hash_table
*,
2602 unsigned int entsize
)
2604 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
2607 /* Create an a.out link hash table. */
2609 struct bfd_link_hash_table
*
2610 NAME (aout
, link_hash_table_create
) (bfd
*abfd
)
2612 struct aout_link_hash_table
*ret
;
2613 size_t amt
= sizeof (struct aout_link_hash_table
);
2615 ret
= bfd_malloc (amt
);
2618 if (! NAME (aout
, link_hash_table_init
) (ret
, abfd
,
2619 NAME (aout
, link_hash_newfunc
),
2620 sizeof (struct aout_link_hash_entry
)))
2628 /* Free up the internal symbols read from an a.out file. */
2631 aout_link_free_symbols (bfd
*abfd
)
2633 if (obj_aout_external_syms (abfd
) != NULL
)
2636 bfd_free_window (&obj_aout_sym_window (abfd
));
2638 free ((void *) obj_aout_external_syms (abfd
));
2640 obj_aout_external_syms (abfd
) = NULL
;
2643 if (obj_aout_external_strings (abfd
) != NULL
)
2646 bfd_free_window (&obj_aout_string_window (abfd
));
2648 free ((void *) obj_aout_external_strings (abfd
));
2650 obj_aout_external_strings (abfd
) = NULL
;
2655 /* Given an a.out BFD, add symbols to the global hash table as
2659 NAME (aout
, link_add_symbols
) (bfd
*abfd
, struct bfd_link_info
*info
)
2661 switch (bfd_get_format (abfd
))
2664 return aout_link_add_object_symbols (abfd
, info
);
2666 return _bfd_generic_link_add_archive_symbols
2667 (abfd
, info
, aout_link_check_archive_element
);
2669 bfd_set_error (bfd_error_wrong_format
);
2674 /* Add symbols from an a.out object file. */
2677 aout_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2679 if (! aout_get_external_symbols (abfd
))
2681 if (! aout_link_add_symbols (abfd
, info
))
2683 if (! info
->keep_memory
)
2685 if (! aout_link_free_symbols (abfd
))
2691 /* Look through the internal symbols to see if this object file should
2692 be included in the link. We should include this object file if it
2693 defines any symbols which are currently undefined. If this object
2694 file defines a common symbol, then we may adjust the size of the
2695 known symbol but we do not include the object file in the link
2696 (unless there is some other reason to include it). */
2699 aout_link_check_ar_symbols (bfd
*abfd
,
2700 struct bfd_link_info
*info
,
2704 struct external_nlist
*p
;
2705 struct external_nlist
*pend
;
2710 /* Look through all the symbols. */
2711 p
= obj_aout_external_syms (abfd
);
2712 pend
= p
+ obj_aout_external_sym_count (abfd
);
2713 strings
= obj_aout_external_strings (abfd
);
2714 for (; p
< pend
; p
++)
2716 int type
= H_GET_8 (abfd
, p
->e_type
);
2717 const char *name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2718 struct bfd_link_hash_entry
*h
;
2720 /* Ignore symbols that are not externally visible. This is an
2721 optimization only, as we check the type more thoroughly
2723 if ((type
& N_EXT
) == 0
2724 || is_stab(type
, name
)
2728 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
2730 /* We are only interested in symbols that are currently
2731 undefined or common. */
2733 || (h
->type
!= bfd_link_hash_undefined
2734 && h
->type
!= bfd_link_hash_common
))
2737 if (type
== (N_TEXT
| N_EXT
)
2738 || type
== (N_DATA
| N_EXT
)
2739 || type
== (N_BSS
| N_EXT
)
2740 || type
== (N_ABS
| N_EXT
))
2742 /* This object file defines this symbol. We must link it
2743 in. This is true regardless of whether the current
2744 definition of the symbol is undefined or common. If the
2745 current definition is common, we have a case in which we
2746 have already seen an object file including
2748 and this object file from the archive includes
2750 In such a case we must include this object file.
2752 FIXME: The SunOS 4.1.3 linker will pull in the archive
2753 element if the symbol is defined in the .data section,
2754 but not if it is defined in the .text section. That
2755 seems a bit crazy to me, and I haven't implemented it.
2756 However, it might be correct. */
2757 if (!(*info
->callbacks
2758 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2764 if (type
== (N_UNDF
| N_EXT
))
2768 value
= GET_WORD (abfd
, p
->e_value
);
2771 /* This symbol is common in the object from the archive
2773 if (h
->type
== bfd_link_hash_undefined
)
2778 symbfd
= h
->u
.undef
.abfd
;
2781 /* This symbol was created as undefined from
2782 outside BFD. We assume that we should link
2783 in the object file. This is done for the -u
2784 option in the linker. */
2785 if (!(*info
->callbacks
2786 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2791 /* Turn the current link symbol into a common
2792 symbol. It is already on the undefs list. */
2793 h
->type
= bfd_link_hash_common
;
2794 h
->u
.c
.p
= bfd_hash_allocate (&info
->hash
->table
,
2795 sizeof (struct bfd_link_hash_common_entry
));
2796 if (h
->u
.c
.p
== NULL
)
2799 h
->u
.c
.size
= value
;
2801 /* FIXME: This isn't quite right. The maximum
2802 alignment of a common symbol should be set by the
2803 architecture of the output file, not of the input
2805 power
= bfd_log2 (value
);
2806 if (power
> bfd_get_arch_info (abfd
)->section_align_power
)
2807 power
= bfd_get_arch_info (abfd
)->section_align_power
;
2808 h
->u
.c
.p
->alignment_power
= power
;
2810 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
,
2815 /* Adjust the size of the common symbol if
2817 if (value
> h
->u
.c
.size
)
2818 h
->u
.c
.size
= value
;
2824 /* We do not need this object file. */
2828 /* Check a single archive element to see if we need to include it in
2829 the link. *PNEEDED is set according to whether this element is
2830 needed in the link or not. This is called from
2831 _bfd_generic_link_add_archive_symbols. */
2834 aout_link_check_archive_element (bfd
*abfd
,
2835 struct bfd_link_info
*info
,
2836 struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
2837 const char *name ATTRIBUTE_UNUSED
,
2843 if (!aout_get_external_symbols (abfd
))
2847 if (!aout_link_check_ar_symbols (abfd
, info
, pneeded
, &abfd
))
2853 /* Potentially, the add_archive_element hook may have set a
2854 substitute BFD for us. */
2857 if (!info
->keep_memory
2858 && !aout_link_free_symbols (oldbfd
))
2860 if (!aout_get_external_symbols (abfd
))
2863 if (!aout_link_add_symbols (abfd
, info
))
2867 if (!info
->keep_memory
|| !needed
)
2869 if (!aout_link_free_symbols (abfd
))
2876 /* Add all symbols from an object file to the hash table. */
2879 aout_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2881 bool (*add_one_symbol
)
2882 (struct bfd_link_info
*, bfd
*, const char *, flagword
, asection
*,
2883 bfd_vma
, const char *, bool, bool, struct bfd_link_hash_entry
**);
2884 struct external_nlist
*syms
;
2885 bfd_size_type sym_count
;
2888 struct aout_link_hash_entry
**sym_hash
;
2889 struct external_nlist
*p
;
2890 struct external_nlist
*pend
;
2892 syms
= obj_aout_external_syms (abfd
);
2893 sym_count
= obj_aout_external_sym_count (abfd
);
2894 strings
= obj_aout_external_strings (abfd
);
2895 if (info
->keep_memory
)
2900 if (aout_backend_info (abfd
)->add_dynamic_symbols
!= NULL
)
2902 if (! ((*aout_backend_info (abfd
)->add_dynamic_symbols
)
2903 (abfd
, info
, &syms
, &sym_count
, &strings
)))
2907 /* We keep a list of the linker hash table entries that correspond
2908 to particular symbols. We could just look them up in the hash
2909 table, but keeping the list is more efficient. Perhaps this
2910 should be conditional on info->keep_memory. */
2911 sym_hash
= bfd_alloc (abfd
,
2912 sym_count
* sizeof (struct aout_link_hash_entry
*));
2913 if (sym_hash
== NULL
&& sym_count
!= 0)
2915 obj_aout_sym_hashes (abfd
) = sym_hash
;
2917 add_one_symbol
= aout_backend_info (abfd
)->add_one_symbol
;
2918 if (add_one_symbol
== NULL
)
2919 add_one_symbol
= _bfd_generic_link_add_one_symbol
;
2922 pend
= p
+ sym_count
;
2923 for (; p
< pend
; p
++, sym_hash
++)
2934 type
= H_GET_8 (abfd
, p
->e_type
);
2936 /* PR 19629: Corrupt binaries can contain illegal string offsets. */
2937 if (GET_WORD (abfd
, p
->e_strx
) >= obj_aout_external_string_size (abfd
))
2939 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2941 /* Ignore debugging symbols. */
2942 if (is_stab (type
, name
))
2945 value
= GET_WORD (abfd
, p
->e_value
);
2951 /* Shouldn't be any types not covered. */
2962 /* Ignore symbols that are not externally visible. */
2965 case N_UNDF
| N_EXT
:
2968 section
= bfd_und_section_ptr
;
2972 section
= bfd_com_section_ptr
;
2975 section
= bfd_abs_section_ptr
;
2977 case N_TEXT
| N_EXT
:
2978 section
= obj_textsec (abfd
);
2979 value
-= bfd_section_vma (section
);
2981 case N_DATA
| N_EXT
:
2982 /* Treat N_SETV symbols as N_DATA symbol; see comment in
2983 translate_from_native_sym_flags. */
2984 section
= obj_datasec (abfd
);
2985 value
-= bfd_section_vma (section
);
2988 section
= obj_bsssec (abfd
);
2989 value
-= bfd_section_vma (section
);
2993 if (! ((*add_one_symbol
)
2994 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, false,
2995 (struct bfd_link_hash_entry
**) sym_hash
)))
2998 /* Restrict the maximum alignment of a common symbol based on
2999 the architecture, since a.out has no way to represent
3000 alignment requirements of a section in a .o file. FIXME:
3001 This isn't quite right: it should use the architecture of the
3002 output file, not the input files. */
3003 if ((*sym_hash
)->root
.type
== bfd_link_hash_common
3004 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
>
3005 bfd_get_arch_info (abfd
)->section_align_power
))
3006 (*sym_hash
)->root
.u
.c
.p
->alignment_power
=
3007 bfd_get_arch_info (abfd
)->section_align_power
;
3009 /* If this is a set symbol, and we are not building sets, then
3010 it is possible for the hash entry to not have been set. In
3011 such a case, treat the symbol as not globally defined. */
3012 if ((*sym_hash
)->root
.type
== bfd_link_hash_new
)
3014 BFD_ASSERT ((flags
& BSF_CONSTRUCTOR
) != 0);
3022 /* Look up an entry in an the header file hash table. */
3024 #define aout_link_includes_lookup(table, string, create, copy) \
3025 ((struct aout_link_includes_entry *) \
3026 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3028 /* The function to create a new entry in the header file hash table. */
3030 static struct bfd_hash_entry
*
3031 aout_link_includes_newfunc (struct bfd_hash_entry
*entry
,
3032 struct bfd_hash_table
*table
,
3035 struct aout_link_includes_entry
* ret
=
3036 (struct aout_link_includes_entry
*) entry
;
3038 /* Allocate the structure if it has not already been allocated by a
3041 ret
= bfd_hash_allocate (table
,
3042 sizeof (struct aout_link_includes_entry
));
3046 /* Call the allocation method of the superclass. */
3047 ret
= ((struct aout_link_includes_entry
*)
3048 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
3050 /* Set local fields. */
3053 return (struct bfd_hash_entry
*) ret
;
3056 /* Write out a symbol that was not associated with an a.out input
3060 aout_link_write_other_symbol (struct bfd_hash_entry
*bh
, void *data
)
3062 struct aout_link_hash_entry
*h
= (struct aout_link_hash_entry
*) bh
;
3063 struct aout_final_link_info
*flaginfo
= (struct aout_final_link_info
*) data
;
3067 struct external_nlist outsym
;
3071 if (h
->root
.type
== bfd_link_hash_warning
)
3073 h
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
3074 if (h
->root
.type
== bfd_link_hash_new
)
3078 output_bfd
= flaginfo
->output_bfd
;
3080 if (aout_backend_info (output_bfd
)->write_dynamic_symbol
!= NULL
)
3082 if (! ((*aout_backend_info (output_bfd
)->write_dynamic_symbol
)
3083 (output_bfd
, flaginfo
->info
, h
)))
3085 /* FIXME: No way to handle errors. */
3095 /* An indx of -2 means the symbol must be written. */
3097 && (flaginfo
->info
->strip
== strip_all
3098 || (flaginfo
->info
->strip
== strip_some
3099 && bfd_hash_lookup (flaginfo
->info
->keep_hash
, h
->root
.root
.string
,
3100 false, false) == NULL
)))
3103 switch (h
->root
.type
)
3107 /* Avoid variable not initialized warnings. */
3109 case bfd_link_hash_new
:
3110 /* This can happen for set symbols when sets are not being
3113 case bfd_link_hash_undefined
:
3114 type
= N_UNDF
| N_EXT
;
3117 case bfd_link_hash_defined
:
3118 case bfd_link_hash_defweak
:
3122 sec
= h
->root
.u
.def
.section
->output_section
;
3123 BFD_ASSERT (bfd_is_abs_section (sec
)
3124 || sec
->owner
== output_bfd
);
3125 if (sec
== obj_textsec (output_bfd
))
3126 type
= h
->root
.type
== bfd_link_hash_defined
? N_TEXT
: N_WEAKT
;
3127 else if (sec
== obj_datasec (output_bfd
))
3128 type
= h
->root
.type
== bfd_link_hash_defined
? N_DATA
: N_WEAKD
;
3129 else if (sec
== obj_bsssec (output_bfd
))
3130 type
= h
->root
.type
== bfd_link_hash_defined
? N_BSS
: N_WEAKB
;
3132 type
= h
->root
.type
== bfd_link_hash_defined
? N_ABS
: N_WEAKA
;
3134 val
= (h
->root
.u
.def
.value
3136 + h
->root
.u
.def
.section
->output_offset
);
3139 case bfd_link_hash_common
:
3140 type
= N_UNDF
| N_EXT
;
3141 val
= h
->root
.u
.c
.size
;
3143 case bfd_link_hash_undefweak
:
3147 case bfd_link_hash_indirect
:
3148 case bfd_link_hash_warning
:
3149 /* FIXME: Ignore these for now. The circumstances under which
3150 they should be written out are not clear to me. */
3154 H_PUT_8 (output_bfd
, type
, outsym
.e_type
);
3155 H_PUT_8 (output_bfd
, 0, outsym
.e_ovly
);
3156 indx
= add_to_stringtab (output_bfd
, flaginfo
->strtab
, h
->root
.root
.string
,
3158 if (indx
== (bfd_size_type
) -1)
3159 /* FIXME: No way to handle errors. */
3162 PUT_WORD (output_bfd
, 0, outsym
.e_desc
);
3163 PUT_WORD (output_bfd
, indx
, outsym
.e_strx
);
3164 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
3166 amt
= EXTERNAL_NLIST_SIZE
;
3167 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0
3168 || bfd_bwrite ((void *) &outsym
, amt
, output_bfd
) != amt
)
3169 /* FIXME: No way to handle errors. */
3172 flaginfo
->symoff
+= amt
;
3173 h
->indx
= obj_aout_external_sym_count (output_bfd
);
3174 ++obj_aout_external_sym_count (output_bfd
);
3179 /* Handle a link order which is supposed to generate a reloc. */
3182 aout_link_reloc_link_order (struct aout_final_link_info
*flaginfo
,
3184 struct bfd_link_order
*p
)
3186 struct bfd_link_order_reloc
*pr
;
3189 reloc_howto_type
*howto
;
3190 file_ptr
*reloff_ptr
;
3191 struct reloc_std_external srel
;
3193 bfd_size_type rel_size
;
3197 if (p
->type
== bfd_section_reloc_link_order
)
3200 if (bfd_is_abs_section (pr
->u
.section
))
3201 r_index
= N_ABS
| N_EXT
;
3204 BFD_ASSERT (pr
->u
.section
->owner
== flaginfo
->output_bfd
);
3205 r_index
= pr
->u
.section
->target_index
;
3210 struct aout_link_hash_entry
*h
;
3212 BFD_ASSERT (p
->type
== bfd_symbol_reloc_link_order
);
3214 h
= ((struct aout_link_hash_entry
*)
3215 bfd_wrapped_link_hash_lookup (flaginfo
->output_bfd
, flaginfo
->info
,
3216 pr
->u
.name
, false, false, true));
3222 /* We decided to strip this symbol, but it turns out that we
3223 can't. Note that we lose the other and desc information
3224 here. I don't think that will ever matter for a global
3228 if (!aout_link_write_other_symbol (&h
->root
.root
, flaginfo
))
3234 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3235 (flaginfo
->info
, pr
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
3240 howto
= bfd_reloc_type_lookup (flaginfo
->output_bfd
, pr
->reloc
);
3243 bfd_set_error (bfd_error_bad_value
);
3247 if (o
== obj_textsec (flaginfo
->output_bfd
))
3248 reloff_ptr
= &flaginfo
->treloff
;
3249 else if (o
== obj_datasec (flaginfo
->output_bfd
))
3250 reloff_ptr
= &flaginfo
->dreloff
;
3255 MY_put_reloc(flaginfo
->output_bfd
, r_extern
, r_index
, p
->offset
, howto
,
3265 fprintf (stderr
, "TODO: line %d in bfd/pdp11.c\n", __LINE__
);
3267 r_pcrel
= howto
->pc_relative
;
3268 r_baserel
= (howto
->type
& 8) != 0;
3269 r_jmptable
= (howto
->type
& 16) != 0;
3270 r_relative
= (howto
->type
& 32) != 0;
3271 r_length
= bfd_log2 (bfd_get_reloc_size (howto
));
3273 PUT_WORD (flaginfo
->output_bfd
, p
->offset
, srel
.r_address
);
3274 if (bfd_header_big_endian (flaginfo
->output_bfd
))
3276 srel
.r_index
[0] = r_index
>> 16;
3277 srel
.r_index
[1] = r_index
>> 8;
3278 srel
.r_index
[2] = r_index
;
3280 ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
3281 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
3282 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
3283 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
3284 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
3285 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
3289 srel
.r_index
[2] = r_index
>> 16;
3290 srel
.r_index
[1] = r_index
>> 8;
3291 srel
.r_index
[0] = r_index
;
3293 ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
3294 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
3295 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
3296 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
3297 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
3298 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
3302 rel_ptr
= (void *) &srel
;
3304 /* We have to write the addend into the object file, since
3305 standard a.out relocs are in place. It would be more
3306 reliable if we had the current contents of the file here,
3307 rather than assuming zeroes, but we can't read the file since
3308 it was opened using bfd_openw. */
3309 if (pr
->addend
!= 0)
3312 bfd_reloc_status_type r
;
3316 size
= bfd_get_reloc_size (howto
);
3317 buf
= bfd_zmalloc (size
);
3318 if (buf
== NULL
&& size
!= 0)
3320 r
= MY_relocate_contents (howto
, flaginfo
->output_bfd
,
3327 case bfd_reloc_outofrange
:
3329 case bfd_reloc_overflow
:
3330 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3331 (flaginfo
->info
, NULL
,
3332 (p
->type
== bfd_section_reloc_link_order
3333 ? bfd_section_name (pr
->u
.section
)
3335 howto
->name
, pr
->addend
, NULL
,
3336 (asection
*) NULL
, (bfd_vma
) 0);
3339 ok
= bfd_set_section_contents (flaginfo
->output_bfd
, o
,
3341 (file_ptr
) p
->offset
,
3348 rel_size
= obj_reloc_entry_size (flaginfo
->output_bfd
);
3349 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0
3350 || bfd_bwrite (rel_ptr
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3353 *reloff_ptr
+= rel_size
;
3355 /* Assert that the relocs have not run into the symbols, and that n
3356 the text relocs have not run into the data relocs. */
3357 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3358 && (reloff_ptr
!= &flaginfo
->treloff
3360 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3365 /* Get the section corresponding to a reloc index. */
3367 static inline asection
*
3368 aout_reloc_type_to_section (bfd
*abfd
, int type
)
3372 case RTEXT
: return obj_textsec (abfd
);
3373 case RDATA
: return obj_datasec (abfd
);
3374 case RBSS
: return obj_bsssec (abfd
);
3375 case RABS
: return bfd_abs_section_ptr
;
3376 case REXT
: return bfd_und_section_ptr
;
3382 pdp11_aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3384 asection
*input_section
,
3386 bfd_size_type rel_size
,
3389 bool (*check_dynamic_reloc
)
3390 (struct bfd_link_info
*, bfd
*, asection
*,
3391 struct aout_link_hash_entry
*, void *, bfd_byte
*, bool *, bfd_vma
*);
3394 struct external_nlist
*syms
;
3396 struct aout_link_hash_entry
**sym_hashes
;
3401 output_bfd
= flaginfo
->output_bfd
;
3402 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
3404 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_SIZE
);
3405 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
3406 == output_bfd
->xvec
->header_byteorder
);
3408 relocatable
= bfd_link_relocatable (flaginfo
->info
);
3409 syms
= obj_aout_external_syms (input_bfd
);
3410 strings
= obj_aout_external_strings (input_bfd
);
3411 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
3412 symbol_map
= flaginfo
->symbol_map
;
3415 rel_end
= rel
+ rel_size
;
3416 for (; rel
< rel_end
; rel
+= RELOC_SIZE
)
3423 reloc_howto_type
*howto
;
3424 struct aout_link_hash_entry
*h
= NULL
;
3426 bfd_reloc_status_type r
;
3429 reloc_entry
= GET_WORD (input_bfd
, (void *) rel
);
3430 if (reloc_entry
== 0)
3434 unsigned int howto_idx
;
3436 r_index
= (reloc_entry
& RIDXMASK
) >> 4;
3437 r_type
= reloc_entry
& RTYPE
;
3438 r_pcrel
= reloc_entry
& RELFLG
;
3439 r_addr
= (char *) rel
- (char *) relocs
;
3441 r_extern
= (r_type
== REXT
);
3443 howto_idx
= r_pcrel
;
3444 if (howto_idx
< TABLE_SIZE (howto_table_pdp11
))
3445 howto
= howto_table_pdp11
+ howto_idx
;
3448 _bfd_error_handler (_("%pB: unsupported relocation type"),
3450 bfd_set_error (bfd_error_bad_value
);
3457 /* We are generating a relocatable output file, and must
3458 modify the reloc accordingly. */
3461 /* If we know the symbol this relocation is against,
3462 convert it into a relocation against a section. This
3463 is what the native linker does. */
3464 h
= sym_hashes
[r_index
];
3466 && (h
->root
.type
== bfd_link_hash_defined
3467 || h
->root
.type
== bfd_link_hash_defweak
))
3469 asection
*output_section
;
3471 /* Compute a new r_index. */
3472 output_section
= h
->root
.u
.def
.section
->output_section
;
3473 if (output_section
== obj_textsec (output_bfd
))
3475 else if (output_section
== obj_datasec (output_bfd
))
3477 else if (output_section
== obj_bsssec (output_bfd
))
3482 /* Add the symbol value and the section VMA to the
3483 addend stored in the contents. */
3484 relocation
= (h
->root
.u
.def
.value
3485 + output_section
->vma
3486 + h
->root
.u
.def
.section
->output_offset
);
3490 /* We must change r_index according to the symbol
3492 r_index
= symbol_map
[r_index
];
3498 /* We decided to strip this symbol, but it
3499 turns out that we can't. Note that we
3500 lose the other and desc information here.
3501 I don't think that will ever matter for a
3507 if (!aout_link_write_other_symbol (&h
->root
.root
,
3517 name
= strings
+ GET_WORD (input_bfd
,
3518 syms
[r_index
].e_strx
);
3519 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3520 (flaginfo
->info
, name
, input_bfd
, input_section
,
3529 /* Write out the new r_index value. */
3530 reloc_entry
= GET_WORD (input_bfd
, rel
);
3531 reloc_entry
&= RIDXMASK
;
3532 reloc_entry
|= r_index
<< 4;
3533 PUT_WORD (input_bfd
, reloc_entry
, rel
);
3539 /* This is a relocation against a section. We must
3540 adjust by the amount that the section moved. */
3541 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3542 relocation
= (section
->output_section
->vma
3543 + section
->output_offset
3547 /* Change the address of the relocation. */
3548 fprintf (stderr
, "TODO: change the address of the relocation\n");
3550 /* Adjust a PC relative relocation by removing the reference
3551 to the original address in the section and including the
3552 reference to the new address. */
3554 relocation
-= (input_section
->output_section
->vma
3555 + input_section
->output_offset
3556 - input_section
->vma
);
3558 #ifdef MY_relocatable_reloc
3559 MY_relocatable_reloc (howto
, output_bfd
, rel
, relocation
, r_addr
);
3562 if (relocation
== 0)
3565 r
= MY_relocate_contents (howto
,
3566 input_bfd
, relocation
,
3573 /* We are generating an executable, and must do a full
3578 h
= sym_hashes
[r_index
];
3581 && (h
->root
.type
== bfd_link_hash_defined
3582 || h
->root
.type
== bfd_link_hash_defweak
))
3584 relocation
= (h
->root
.u
.def
.value
3585 + h
->root
.u
.def
.section
->output_section
->vma
3586 + h
->root
.u
.def
.section
->output_offset
);
3589 && h
->root
.type
== bfd_link_hash_undefweak
)
3601 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3602 relocation
= (section
->output_section
->vma
3603 + section
->output_offset
3606 relocation
+= input_section
->vma
;
3609 if (check_dynamic_reloc
!= NULL
)
3613 if (! ((*check_dynamic_reloc
)
3614 (flaginfo
->info
, input_bfd
, input_section
, h
,
3615 (void *) rel
, contents
, &skip
, &relocation
)))
3621 /* Now warn if a global symbol is undefined. We could not
3622 do this earlier, because check_dynamic_reloc might want
3623 to skip this reloc. */
3624 if (hundef
&& ! bfd_link_pic (flaginfo
->info
))
3629 name
= h
->root
.root
.string
;
3631 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
3632 (*flaginfo
->info
->callbacks
->undefined_symbol
)
3633 (flaginfo
->info
, name
, input_bfd
, input_section
,
3637 r
= MY_final_link_relocate (howto
,
3638 input_bfd
, input_section
,
3639 contents
, r_addr
, relocation
,
3643 if (r
!= bfd_reloc_ok
)
3648 case bfd_reloc_outofrange
:
3650 case bfd_reloc_overflow
:
3657 name
= strings
+ GET_WORD (input_bfd
,
3658 syms
[r_index
].e_strx
);
3663 s
= aout_reloc_type_to_section (input_bfd
, r_type
);
3664 name
= bfd_section_name (s
);
3666 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3667 (flaginfo
->info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3668 (bfd_vma
) 0, input_bfd
, input_section
, r_addr
);
3678 /* Link an a.out section into the output file. */
3681 aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3683 asection
*input_section
,
3684 file_ptr
*reloff_ptr
,
3685 bfd_size_type rel_size
)
3687 bfd_size_type input_size
;
3690 /* Get the section contents. */
3691 input_size
= input_section
->size
;
3692 if (! bfd_get_section_contents (input_bfd
, input_section
,
3693 (void *) flaginfo
->contents
,
3694 (file_ptr
) 0, input_size
))
3697 /* Read in the relocs if we haven't already done it. */
3698 if (aout_section_data (input_section
) != NULL
3699 && aout_section_data (input_section
)->relocs
!= NULL
)
3700 relocs
= aout_section_data (input_section
)->relocs
;
3703 relocs
= flaginfo
->relocs
;
3706 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3707 || bfd_bread (relocs
, rel_size
, input_bfd
) != rel_size
)
3712 /* Relocate the section contents. */
3713 if (! pdp11_aout_link_input_section (flaginfo
, input_bfd
, input_section
,
3714 (bfd_byte
*) relocs
,
3715 rel_size
, flaginfo
->contents
))
3718 /* Write out the section contents. */
3719 if (! bfd_set_section_contents (flaginfo
->output_bfd
,
3720 input_section
->output_section
,
3721 (void *) flaginfo
->contents
,
3722 (file_ptr
) input_section
->output_offset
,
3726 /* If we are producing relocatable output, the relocs were
3727 modified, and we now write them out. */
3728 if (bfd_link_relocatable (flaginfo
->info
) && rel_size
> 0)
3730 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
3732 if (bfd_bwrite (relocs
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3734 *reloff_ptr
+= rel_size
;
3736 /* Assert that the relocs have not run into the symbols, and
3737 that if these are the text relocs they have not run into the
3739 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3740 && (reloff_ptr
!= &flaginfo
->treloff
3742 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3748 /* Link an a.out input BFD into the output file. */
3751 aout_link_input_bfd (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
3753 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
3755 /* If this is a dynamic object, it may need special handling. */
3756 if ((input_bfd
->flags
& DYNAMIC
) != 0
3757 && aout_backend_info (input_bfd
)->link_dynamic_object
!= NULL
)
3758 return ((*aout_backend_info (input_bfd
)->link_dynamic_object
)
3759 (flaginfo
->info
, input_bfd
));
3761 /* Get the symbols. We probably have them already, unless
3762 flaginfo->info->keep_memory is FALSE. */
3763 if (! aout_get_external_symbols (input_bfd
))
3766 /* Write out the symbols and get a map of the new indices. The map
3767 is placed into flaginfo->symbol_map. */
3768 if (! aout_link_write_symbols (flaginfo
, input_bfd
))
3771 /* Relocate and write out the sections. These functions use the
3772 symbol map created by aout_link_write_symbols. The linker_mark
3773 field will be set if these sections are to be included in the
3774 link, which will normally be the case. */
3775 if (obj_textsec (input_bfd
)->linker_mark
)
3777 if (! aout_link_input_section (flaginfo
, input_bfd
,
3778 obj_textsec (input_bfd
),
3780 exec_hdr (input_bfd
)->a_trsize
))
3783 if (obj_datasec (input_bfd
)->linker_mark
)
3785 if (! aout_link_input_section (flaginfo
, input_bfd
,
3786 obj_datasec (input_bfd
),
3788 exec_hdr (input_bfd
)->a_drsize
))
3792 /* If we are not keeping memory, we don't need the symbols any
3793 longer. We still need them if we are keeping memory, because the
3794 strings in the hash table point into them. */
3795 if (! flaginfo
->info
->keep_memory
)
3797 if (! aout_link_free_symbols (input_bfd
))
3804 /* Do the final link step. This is called on the output BFD. The
3805 INFO structure should point to a list of BFDs linked through the
3806 link.next field which can be used to find each BFD which takes part
3807 in the output. Also, each section in ABFD should point to a list
3808 of bfd_link_order structures which list all the input sections for
3809 the output section. */
3812 NAME (aout
, final_link
) (bfd
*abfd
,
3813 struct bfd_link_info
*info
,
3814 void (*callback
) (bfd
*, file_ptr
*, file_ptr
*, file_ptr
*))
3816 struct aout_final_link_info aout_info
;
3817 bool includes_hash_initialized
= false;
3819 bfd_size_type trsize
, drsize
;
3820 bfd_size_type max_contents_size
;
3821 bfd_size_type max_relocs_size
;
3822 bfd_size_type max_sym_count
;
3823 struct bfd_link_order
*p
;
3825 bool have_link_order_relocs
;
3827 if (bfd_link_pic (info
))
3828 abfd
->flags
|= DYNAMIC
;
3830 separate_i_d
= info
->separate_code
;
3831 aout_info
.info
= info
;
3832 aout_info
.output_bfd
= abfd
;
3833 aout_info
.contents
= NULL
;
3834 aout_info
.relocs
= NULL
;
3835 aout_info
.symbol_map
= NULL
;
3836 aout_info
.output_syms
= NULL
;
3838 if (!bfd_hash_table_init_n (&aout_info
.includes
.root
,
3839 aout_link_includes_newfunc
,
3840 sizeof (struct aout_link_includes_entry
),
3843 includes_hash_initialized
= true;
3845 /* Figure out the largest section size. Also, if generating
3846 relocatable output, count the relocs. */
3849 max_contents_size
= 0;
3850 max_relocs_size
= 0;
3852 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3856 if (bfd_link_relocatable (info
))
3858 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3860 trsize
+= exec_hdr (sub
)->a_trsize
;
3861 drsize
+= exec_hdr (sub
)->a_drsize
;
3865 /* FIXME: We need to identify the .text and .data sections
3866 and call get_reloc_upper_bound and canonicalize_reloc to
3867 work out the number of relocs needed, and then multiply
3868 by the reloc size. */
3870 /* xgettext:c-format */
3871 (_("%pB: relocatable link from %s to %s not supported"),
3872 abfd
, sub
->xvec
->name
, abfd
->xvec
->name
);
3873 bfd_set_error (bfd_error_invalid_operation
);
3878 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3880 sz
= obj_textsec (sub
)->size
;
3881 if (sz
> max_contents_size
)
3882 max_contents_size
= sz
;
3883 sz
= obj_datasec (sub
)->size
;
3884 if (sz
> max_contents_size
)
3885 max_contents_size
= sz
;
3887 sz
= exec_hdr (sub
)->a_trsize
;
3888 if (sz
> max_relocs_size
)
3889 max_relocs_size
= sz
;
3890 sz
= exec_hdr (sub
)->a_drsize
;
3891 if (sz
> max_relocs_size
)
3892 max_relocs_size
= sz
;
3894 sz
= obj_aout_external_sym_count (sub
);
3895 if (sz
> max_sym_count
)
3900 if (bfd_link_relocatable (info
))
3902 if (obj_textsec (abfd
) != NULL
)
3903 trsize
+= (_bfd_count_link_order_relocs (obj_textsec (abfd
)
3904 ->map_head
.link_order
)
3905 * obj_reloc_entry_size (abfd
));
3906 if (obj_datasec (abfd
) != NULL
)
3907 drsize
+= (_bfd_count_link_order_relocs (obj_datasec (abfd
)
3908 ->map_head
.link_order
)
3909 * obj_reloc_entry_size (abfd
));
3912 exec_hdr (abfd
)->a_trsize
= trsize
;
3913 exec_hdr (abfd
)->a_drsize
= drsize
;
3914 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
3916 /* Adjust the section sizes and vmas according to the magic number.
3917 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3918 filepos for each section. */
3919 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
3922 /* The relocation and symbol file positions differ among a.out
3923 targets. We are passed a callback routine from the backend
3924 specific code to handle this.
3925 FIXME: At this point we do not know how much space the symbol
3926 table will require. This will not work for any (nonstandard)
3927 a.out target that needs to know the symbol table size before it
3928 can compute the relocation file positions. */
3929 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
3931 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
3932 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
3933 obj_sym_filepos (abfd
) = aout_info
.symoff
;
3935 /* We keep a count of the symbols as we output them. */
3936 obj_aout_external_sym_count (abfd
) = 0;
3938 /* We accumulate the string table as we write out the symbols. */
3939 aout_info
.strtab
= _bfd_stringtab_init ();
3940 if (aout_info
.strtab
== NULL
)
3943 /* Allocate buffers to hold section contents and relocs. */
3944 aout_info
.contents
= bfd_malloc (max_contents_size
);
3945 aout_info
.relocs
= bfd_malloc (max_relocs_size
);
3946 aout_info
.symbol_map
= bfd_malloc (max_sym_count
* sizeof (int *));
3947 aout_info
.output_syms
= bfd_malloc ((max_sym_count
+ 1)
3948 * sizeof (struct external_nlist
));
3949 if ((aout_info
.contents
== NULL
&& max_contents_size
!= 0)
3950 || (aout_info
.relocs
== NULL
&& max_relocs_size
!= 0)
3951 || (aout_info
.symbol_map
== NULL
&& max_sym_count
!= 0)
3952 || aout_info
.output_syms
== NULL
)
3955 /* If we have a symbol named __DYNAMIC, force it out now. This is
3956 required by SunOS. Doing this here rather than in sunos.c is a
3957 hack, but it's easier than exporting everything which would be
3960 struct aout_link_hash_entry
*h
;
3962 h
= aout_link_hash_lookup (aout_hash_table (info
), "__DYNAMIC",
3963 false, false, false);
3965 aout_link_write_other_symbol (&h
->root
.root
, &aout_info
);
3968 /* The most time efficient way to do the link would be to read all
3969 the input object files into memory and then sort out the
3970 information into the output file. Unfortunately, that will
3971 probably use too much memory. Another method would be to step
3972 through everything that composes the text section and write it
3973 out, and then everything that composes the data section and write
3974 it out, and then write out the relocs, and then write out the
3975 symbols. Unfortunately, that requires reading stuff from each
3976 input file several times, and we will not be able to keep all the
3977 input files open simultaneously, and reopening them will be slow.
3979 What we do is basically process one input file at a time. We do
3980 everything we need to do with an input file once--copy over the
3981 section contents, handle the relocation information, and write
3982 out the symbols--and then we throw away the information we read
3983 from it. This approach requires a lot of lseeks of the output
3984 file, which is unfortunate but still faster than reopening a lot
3987 We use the output_has_begun field of the input BFDs to see
3988 whether we have already handled it. */
3989 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3990 sub
->output_has_begun
= false;
3992 /* Mark all sections which are to be included in the link. This
3993 will normally be every section. We need to do this so that we
3994 can identify any sections which the linker has decided to not
3996 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3998 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
3999 if (p
->type
== bfd_indirect_link_order
)
4000 p
->u
.indirect
.section
->linker_mark
= true;
4003 have_link_order_relocs
= false;
4004 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4006 for (p
= o
->map_head
.link_order
;
4010 if (p
->type
== bfd_indirect_link_order
4011 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4012 == bfd_target_aout_flavour
))
4016 input_bfd
= p
->u
.indirect
.section
->owner
;
4017 if (! input_bfd
->output_has_begun
)
4019 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
4021 input_bfd
->output_has_begun
= true;
4024 else if (p
->type
== bfd_section_reloc_link_order
4025 || p
->type
== bfd_symbol_reloc_link_order
)
4026 /* These are handled below. */
4027 have_link_order_relocs
= true;
4030 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4036 /* Write out any symbols that we have not already written out. */
4037 bfd_hash_traverse (&info
->hash
->table
,
4038 aout_link_write_other_symbol
,
4041 /* Now handle any relocs we were asked to create by the linker.
4042 These did not come from any input file. We must do these after
4043 we have written out all the symbols, so that we know the symbol
4045 if (have_link_order_relocs
)
4047 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4049 for (p
= o
->map_head
.link_order
;
4053 if (p
->type
== bfd_section_reloc_link_order
4054 || p
->type
== bfd_symbol_reloc_link_order
)
4056 if (! aout_link_reloc_link_order (&aout_info
, o
, p
))
4063 free (aout_info
.contents
);
4064 aout_info
.contents
= NULL
;
4065 free (aout_info
.relocs
);
4066 aout_info
.relocs
= NULL
;
4067 free (aout_info
.symbol_map
);
4068 aout_info
.symbol_map
= NULL
;
4069 free (aout_info
.output_syms
);
4070 aout_info
.output_syms
= NULL
;
4071 if (includes_hash_initialized
)
4073 bfd_hash_table_free (&aout_info
.includes
.root
);
4074 includes_hash_initialized
= false;
4077 /* Finish up any dynamic linking we may be doing. */
4078 if (aout_backend_info (abfd
)->finish_dynamic_link
!= NULL
)
4080 if (! (*aout_backend_info (abfd
)->finish_dynamic_link
) (abfd
, info
))
4084 /* Update the header information. */
4085 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
4086 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
4087 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
4088 obj_textsec (abfd
)->reloc_count
=
4089 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
4090 obj_datasec (abfd
)->reloc_count
=
4091 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
4093 /* Write out the string table, unless there are no symbols. */
4094 if (abfd
->symcount
> 0)
4096 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
4097 || ! emit_stringtab (abfd
, aout_info
.strtab
))
4100 else if (obj_textsec (abfd
)->reloc_count
== 0
4101 && obj_datasec (abfd
)->reloc_count
== 0)
4103 /* The layout of a typical a.out file is header, text, data,
4104 relocs, symbols, string table. When there are no relocs,
4105 symbols or string table, the last thing in the file is data
4106 and a_data may be rounded up. However we may have a smaller
4107 sized .data section and thus not written final padding. The
4108 same thing can happen with text if there is no data. Write
4109 final padding here to extend the file. */
4112 if (exec_hdr (abfd
)->a_data
> obj_datasec (abfd
)->size
)
4113 pos
= obj_datasec (abfd
)->filepos
+ exec_hdr (abfd
)->a_data
;
4114 else if (obj_datasec (abfd
)->size
== 0
4115 && exec_hdr (abfd
)->a_text
> obj_textsec (abfd
)->size
)
4116 pos
= obj_textsec (abfd
)->filepos
+ exec_hdr (abfd
)->a_text
;
4121 if (bfd_seek (abfd
, pos
- 1, SEEK_SET
) != 0
4122 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4130 free (aout_info
.contents
);
4131 free (aout_info
.relocs
);
4132 free (aout_info
.symbol_map
);
4133 free (aout_info
.output_syms
);
4134 if (includes_hash_initialized
)
4135 bfd_hash_table_free (&aout_info
.includes
.root
);
4139 /* Adjust and write out the symbols for an a.out file. Set the new
4140 symbol indices into a symbol_map. */
4143 aout_link_write_symbols (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
4146 bfd_size_type sym_count
;
4148 enum bfd_link_strip strip
;
4149 enum bfd_link_discard discard
;
4150 struct external_nlist
*outsym
;
4151 bfd_size_type strtab_index
;
4152 struct external_nlist
*sym
;
4153 struct external_nlist
*sym_end
;
4154 struct aout_link_hash_entry
**sym_hash
;
4159 output_bfd
= flaginfo
->output_bfd
;
4160 sym_count
= obj_aout_external_sym_count (input_bfd
);
4161 strings
= obj_aout_external_strings (input_bfd
);
4162 strip
= flaginfo
->info
->strip
;
4163 discard
= flaginfo
->info
->discard
;
4164 outsym
= flaginfo
->output_syms
;
4166 /* First write out a symbol for this object file, unless we are
4167 discarding such symbols. */
4168 if (strip
!= strip_all
4169 && (strip
!= strip_some
4170 || bfd_hash_lookup (flaginfo
->info
->keep_hash
,
4171 bfd_get_filename (input_bfd
),
4172 false, false) != NULL
)
4173 && discard
!= discard_all
)
4175 H_PUT_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
4176 H_PUT_8 (output_bfd
, 0, outsym
->e_ovly
);
4177 H_PUT_16 (output_bfd
, 0, outsym
->e_desc
);
4178 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4179 bfd_get_filename (input_bfd
), false);
4180 if (strtab_index
== (bfd_size_type
) -1)
4182 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4183 PUT_WORD (output_bfd
,
4184 (bfd_section_vma (obj_textsec (input_bfd
)->output_section
)
4185 + obj_textsec (input_bfd
)->output_offset
),
4187 ++obj_aout_external_sym_count (output_bfd
);
4193 sym
= obj_aout_external_syms (input_bfd
);
4194 sym_end
= sym
+ sym_count
;
4195 sym_hash
= obj_aout_sym_hashes (input_bfd
);
4196 symbol_map
= flaginfo
->symbol_map
;
4197 memset (symbol_map
, 0, (size_t) sym_count
* sizeof *symbol_map
);
4198 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
4202 struct aout_link_hash_entry
*h
;
4208 /* We set *symbol_map to 0 above for all symbols. If it has
4209 already been set to -1 for this symbol, it means that we are
4210 discarding it because it appears in a duplicate header file.
4211 See the N_BINCL code below. */
4212 if (*symbol_map
== -1)
4215 /* Initialize *symbol_map to -1, which means that the symbol was
4216 not copied into the output file. We will change it later if
4217 we do copy the symbol over. */
4220 type
= H_GET_8 (input_bfd
, sym
->e_type
);
4221 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
4227 /* Pass this symbol through. It is the target of an
4228 indirect or warning symbol. */
4229 val
= GET_WORD (input_bfd
, sym
->e_value
);
4234 /* Skip this symbol, which is the target of an indirect
4235 symbol that we have changed to no longer be an indirect
4242 struct aout_link_hash_entry
*hresolve
;
4244 /* We have saved the hash table entry for this symbol, if
4245 there is one. Note that we could just look it up again
4246 in the hash table, provided we first check that it is an
4250 /* Use the name from the hash table, in case the symbol was
4253 name
= h
->root
.root
.string
;
4255 /* If this is an indirect or warning symbol, then change
4256 hresolve to the base symbol. We also change *sym_hash so
4257 that the relocation routines relocate against the real
4261 && (h
->root
.type
== bfd_link_hash_indirect
4262 || h
->root
.type
== bfd_link_hash_warning
))
4264 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
4265 while (hresolve
->root
.type
== bfd_link_hash_indirect
4266 || hresolve
->root
.type
== bfd_link_hash_warning
)
4267 hresolve
= ((struct aout_link_hash_entry
*)
4268 hresolve
->root
.u
.i
.link
);
4269 *sym_hash
= hresolve
;
4272 /* If the symbol has already been written out, skip it. */
4274 && h
->root
.type
!= bfd_link_hash_warning
4277 if ((type
& N_TYPE
) == N_INDR
4278 || type
== N_WARNING
)
4280 *symbol_map
= h
->indx
;
4284 /* See if we are stripping this symbol. */
4290 case strip_debugger
:
4291 if (is_stab (type
, name
))
4295 if (bfd_hash_lookup (flaginfo
->info
->keep_hash
, name
,
4296 false, false) == NULL
)
4310 /* Get the value of the symbol. */
4311 if (is_stab (type
, name
))
4316 symsec
= bfd_abs_section_ptr
;
4324 symsec
= obj_textsec (input_bfd
);
4328 symsec
= obj_datasec (input_bfd
);
4332 symsec
= obj_bsssec (input_bfd
);
4335 val
= GET_WORD (input_bfd
, sym
->e_value
);
4337 else if ((type
& N_TYPE
) == N_TEXT
4339 symsec
= obj_textsec (input_bfd
);
4340 else if ((type
& N_TYPE
) == N_DATA
4342 symsec
= obj_datasec (input_bfd
);
4343 else if ((type
& N_TYPE
) == N_BSS
4345 symsec
= obj_bsssec (input_bfd
);
4346 else if ((type
& N_TYPE
) == N_ABS
4348 symsec
= bfd_abs_section_ptr
;
4349 else if (((type
& N_TYPE
) == N_INDR
4350 && (hresolve
== NULL
4351 || (hresolve
->root
.type
!= bfd_link_hash_defined
4352 && hresolve
->root
.type
!= bfd_link_hash_defweak
4353 && hresolve
->root
.type
!= bfd_link_hash_common
)))
4354 || type
== N_WARNING
)
4356 /* Pass the next symbol through unchanged. The
4357 condition above for indirect symbols is so that if
4358 the indirect symbol was defined, we output it with
4359 the correct definition so the debugger will
4362 val
= GET_WORD (input_bfd
, sym
->e_value
);
4367 /* If we get here with an indirect symbol, it means that
4368 we are outputting it with a real definition. In such
4369 a case we do not want to output the next symbol,
4370 which is the target of the indirection. */
4371 if ((type
& N_TYPE
) == N_INDR
)
4376 /* We need to get the value from the hash table. We use
4377 hresolve so that if we have defined an indirect
4378 symbol we output the final definition. */
4381 switch (type
& N_TYPE
)
4384 symsec
= obj_textsec (input_bfd
);
4387 symsec
= obj_datasec (input_bfd
);
4390 symsec
= obj_bsssec (input_bfd
);
4393 symsec
= bfd_abs_section_ptr
;
4400 else if (hresolve
->root
.type
== bfd_link_hash_defined
4401 || hresolve
->root
.type
== bfd_link_hash_defweak
)
4403 asection
*input_section
;
4404 asection
*output_section
;
4406 /* This case usually means a common symbol which was
4407 turned into a defined symbol. */
4408 input_section
= hresolve
->root
.u
.def
.section
;
4409 output_section
= input_section
->output_section
;
4410 BFD_ASSERT (bfd_is_abs_section (output_section
)
4411 || output_section
->owner
== output_bfd
);
4412 val
= (hresolve
->root
.u
.def
.value
4413 + bfd_section_vma (output_section
)
4414 + input_section
->output_offset
);
4416 /* Get the correct type based on the section. If
4417 this is a constructed set, force it to be
4418 globally visible. */
4427 if (output_section
== obj_textsec (output_bfd
))
4428 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4431 else if (output_section
== obj_datasec (output_bfd
))
4432 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4435 else if (output_section
== obj_bsssec (output_bfd
))
4436 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4440 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4444 else if (hresolve
->root
.type
== bfd_link_hash_common
)
4445 val
= hresolve
->root
.u
.c
.size
;
4446 else if (hresolve
->root
.type
== bfd_link_hash_undefweak
)
4455 val
= (symsec
->output_section
->vma
4456 + symsec
->output_offset
4457 + (GET_WORD (input_bfd
, sym
->e_value
)
4460 /* If this is a global symbol set the written flag, and if
4461 it is a local symbol see if we should discard it. */
4465 h
->indx
= obj_aout_external_sym_count (output_bfd
);
4467 else if ((type
& N_TYPE
) != N_SETT
4468 && (type
& N_TYPE
) != N_SETD
4469 && (type
& N_TYPE
) != N_SETB
4470 && (type
& N_TYPE
) != N_SETA
)
4475 case discard_sec_merge
:
4478 if (!is_stab (type
, name
)
4479 && bfd_is_local_label_name (input_bfd
, name
))
4493 /* An N_BINCL symbol indicates the start of the stabs
4494 entries for a header file. We need to scan ahead to the
4495 next N_EINCL symbol, ignoring nesting, adding up all the
4496 characters in the symbol names, not including the file
4497 numbers in types (the first number after an open
4499 if (type
== N_BINCL
)
4501 struct external_nlist
*incl_sym
;
4503 struct aout_link_includes_entry
*incl_entry
;
4504 struct aout_link_includes_totals
*t
;
4508 for (incl_sym
= sym
+ 1; incl_sym
< sym_end
; incl_sym
++)
4512 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4513 if (incl_type
== N_EINCL
)
4519 else if (incl_type
== N_BINCL
)
4525 s
= strings
+ GET_WORD (input_bfd
, incl_sym
->e_strx
);
4526 for (; *s
!= '\0'; s
++)
4531 /* Skip the file number. */
4533 while (ISDIGIT (*s
))
4541 /* If we have already included a header file with the
4542 same value, then replace this one with an N_EXCL
4544 copy
= ! flaginfo
->info
->keep_memory
;
4545 incl_entry
= aout_link_includes_lookup (&flaginfo
->includes
,
4547 if (incl_entry
== NULL
)
4549 for (t
= incl_entry
->totals
; t
!= NULL
; t
= t
->next
)
4550 if (t
->total
== val
)
4554 /* This is the first time we have seen this header
4555 file with this set of stabs strings. */
4556 t
= bfd_hash_allocate (&flaginfo
->includes
.root
,
4561 t
->next
= incl_entry
->totals
;
4562 incl_entry
->totals
= t
;
4568 /* This is a duplicate header file. We must change
4569 it to be an N_EXCL entry, and mark all the
4570 included symbols to prevent outputting them. */
4574 for (incl_sym
= sym
+ 1, incl_map
= symbol_map
+ 1;
4576 incl_sym
++, incl_map
++)
4580 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4581 if (incl_type
== N_EINCL
)
4590 else if (incl_type
== N_BINCL
)
4599 /* Copy this symbol into the list of symbols we are going to
4601 H_PUT_8 (output_bfd
, type
, outsym
->e_type
);
4602 H_PUT_8 (output_bfd
, H_GET_8 (input_bfd
, sym
->e_ovly
), outsym
->e_ovly
);
4603 H_PUT_16 (output_bfd
, H_GET_16 (input_bfd
, sym
->e_desc
), outsym
->e_desc
);
4605 if (! flaginfo
->info
->keep_memory
)
4607 /* name points into a string table which we are going to
4608 free. If there is a hash table entry, use that string.
4609 Otherwise, copy name into memory. */
4611 name
= h
->root
.root
.string
;
4615 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4617 if (strtab_index
== (bfd_size_type
) -1)
4619 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4620 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
4621 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
4622 ++obj_aout_external_sym_count (output_bfd
);
4626 /* Write out the output symbols we have just constructed. */
4627 if (outsym
> flaginfo
->output_syms
)
4631 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0)
4633 size
= outsym
- flaginfo
->output_syms
;
4634 size
*= EXTERNAL_NLIST_SIZE
;
4635 if (bfd_bwrite ((void *) flaginfo
->output_syms
, size
, output_bfd
) != size
)
4637 flaginfo
->symoff
+= size
;
4643 /* Write out a symbol that was not associated with an a.out input
4647 bfd_getp32 (const void *p
)
4649 const bfd_byte
*addr
= p
;
4652 v
= (unsigned long) addr
[1] << 24;
4653 v
|= (unsigned long) addr
[0] << 16;
4654 v
|= (unsigned long) addr
[3] << 8;
4655 v
|= (unsigned long) addr
[2];
4659 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
4661 static bfd_signed_vma
4662 bfd_getp_signed_32 (const void *p
)
4664 const bfd_byte
*addr
= p
;
4667 v
= (unsigned long) addr
[1] << 24;
4668 v
|= (unsigned long) addr
[0] << 16;
4669 v
|= (unsigned long) addr
[3] << 8;
4670 v
|= (unsigned long) addr
[2];
4671 return COERCE32 (v
);
4675 bfd_putp32 (bfd_vma data
, void *p
)
4679 addr
[0] = (data
>> 16) & 0xff;
4680 addr
[1] = (data
>> 24) & 0xff;
4681 addr
[2] = (data
>> 0) & 0xff;
4682 addr
[3] = (data
>> 8) & 0xff;
4685 const bfd_target
MY (vec
) =
4687 TARGETNAME
, /* Name. */
4688 bfd_target_aout_flavour
,
4689 BFD_ENDIAN_LITTLE
, /* Target byte order (little). */
4690 BFD_ENDIAN_LITTLE
, /* Target headers byte order (little). */
4691 (HAS_RELOC
| EXEC_P
| /* Object flags. */
4692 HAS_LINENO
| HAS_DEBUG
|
4693 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
),
4694 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_CODE
| SEC_DATA
),
4695 MY_symbol_leading_char
,
4696 AR_PAD_CHAR
, /* AR_pad_char. */
4697 15, /* AR_max_namelen. */
4698 0, /* match priority. */
4699 TARGET_KEEP_UNUSED_SECTION_SYMBOLS
, /* keep unused section symbols. */
4700 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4701 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4702 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Data. */
4703 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4704 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4705 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Headers. */
4706 { /* bfd_check_format. */
4709 bfd_generic_archive_p
,
4712 { /* bfd_set_format. */
4713 _bfd_bool_bfd_false_error
,
4715 _bfd_generic_mkarchive
,
4716 _bfd_bool_bfd_false_error
4718 { /* bfd_write_contents. */
4719 _bfd_bool_bfd_false_error
,
4720 MY_write_object_contents
,
4721 _bfd_write_archive_contents
,
4722 _bfd_bool_bfd_false_error
4725 BFD_JUMP_TABLE_GENERIC (MY
),
4726 BFD_JUMP_TABLE_COPY (MY
),
4727 BFD_JUMP_TABLE_CORE (MY
),
4728 BFD_JUMP_TABLE_ARCHIVE (MY
),
4729 BFD_JUMP_TABLE_SYMBOLS (MY
),
4730 BFD_JUMP_TABLE_RELOCS (MY
),
4731 BFD_JUMP_TABLE_WRITE (MY
),
4732 BFD_JUMP_TABLE_LINK (MY
),
4733 BFD_JUMP_TABLE_DYNAMIC (MY
),
4735 /* Alternative_target. */
4738 (void *) MY_backend_data