1 /* BFD back-end for PDP-11 a.out binaries.
2 Copyright (C) 2001-2020 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.
28 * support for V7 file formats
29 * support for overlay object files (see 2.11 a.out(5))
30 * support for old and very old archives
31 (see 2.11 ar(5), historical section)
33 Search for TODO to find other areas needing more work. */
35 #define BYTES_IN_WORD 2
36 #define BYTES_IN_LONG 4
38 #undef TARGET_IS_BIG_ENDIAN_P
40 #define TARGET_PAGE_SIZE 8192
41 #define SEGMENT__SIZE TARGET_PAGE_SIZE
43 #define DEFAULT_ARCH bfd_arch_pdp11
44 #define DEFAULT_MID M_PDP11
46 /* Do not "beautify" the CONCAT* macro args. Traditional C will not
47 remove whitespace added here, and thus will fail to concatenate
49 #define MY(OP) CONCAT2 (pdp11_aout_,OP)
51 /* This needs to start with a.out so GDB knows it is an a.out variant. */
52 #define TARGETNAME "a.out-pdp11"
54 /* This is the normal load address for executables. */
55 #define TEXT_START_ADDR 0
57 /* The header is not included in the text segment. */
58 #define N_HEADER_IN_TEXT(x) 0
60 /* There is no flags field. */
61 #define N_FLAGS(execp) 0
63 #define N_SET_FLAGS(execp, flags) do { } while (0)
64 #define N_BADMAG(x) (N_MAGIC(x) != OMAGIC \
65 && N_MAGIC(x) != NMAGIC \
66 && N_MAGIC(x) != IMAGIC \
67 && N_MAGIC(x) != ZMAGIC)
73 #define external_exec pdp11_external_exec
74 struct pdp11_external_exec
76 bfd_byte e_info
[2]; /* Magic number. */
77 bfd_byte e_text
[2]; /* Length of text section in bytes. */
78 bfd_byte e_data
[2]; /* Length of data section in bytes. */
79 bfd_byte e_bss
[2]; /* Length of bss area in bytes. */
80 bfd_byte e_syms
[2]; /* Length of symbol table in bytes. */
81 bfd_byte e_entry
[2]; /* Start address. */
82 bfd_byte e_unused
[2]; /* Not used. */
83 bfd_byte e_flag
[2]; /* Relocation info stripped. */
84 bfd_byte e_relocatable
; /* Ugly hack. */
87 #define EXEC_BYTES_SIZE (8 * 2)
89 #define A_MAGIC1 OMAGIC
90 #define OMAGIC 0407 /* ...object file or impure executable. */
91 #define A_MAGIC2 NMAGIC
92 #define NMAGIC 0410 /* Pure executable. */
93 #define ZMAGIC 0413 /* Demand-paged executable. */
94 #define IMAGIC 0411 /* Separated I&D. */
95 #define A_MAGIC3 IMAGIC
96 #define A_MAGIC4 0405 /* Overlay. */
97 #define A_MAGIC5 0430 /* Auto-overlay (nonseparate). */
98 #define A_MAGIC6 0431 /* Auto-overlay (separate). */
102 #define A_FLAG_RELOC_STRIPPED 0x0001
104 #define external_nlist pdp11_external_nlist
105 struct pdp11_external_nlist
107 bfd_byte e_unused
[2]; /* Unused. */
108 bfd_byte e_strx
[2]; /* Index into string table of name. */
109 bfd_byte e_type
[1]; /* Type of symbol. */
110 bfd_byte e_ovly
[1]; /* Overlay number. */
111 bfd_byte e_value
[2]; /* Value of symbol. */
114 #define EXTERNAL_NLIST_SIZE 8
116 #define N_TXTOFF(x) (EXEC_BYTES_SIZE)
117 #define N_DATOFF(x) (N_TXTOFF(x) + (x)->a_text)
118 #define N_TRELOFF(x) (N_DATOFF(x) + (x)->a_data)
119 #define N_DRELOFF(x) (N_TRELOFF(x) + (x)->a_trsize)
120 #define N_SYMOFF(x) (N_DRELOFF(x) + (x)->a_drsize)
121 #define N_STROFF(x) (N_SYMOFF(x) + (x)->a_syms)
123 #define WRITE_HEADERS(abfd, execp) pdp11_aout_write_headers (abfd, execp)
128 #define SWAP_MAGIC(ext) bfd_getl16 (ext)
130 #define MY_entry_is_text_address 1
132 #define MY_write_object_contents MY(write_object_contents)
133 static bfd_boolean
MY(write_object_contents
) (bfd
*);
134 #define MY_text_includes_header 1
136 #define MY_BFD_TARGET
138 #include "aout-target.h"
140 /* Start of modified aoutx.h. */
141 #define KEEPIT udata.i
143 #include <string.h> /* For strchr and friends. */
146 #include "safe-ctype.h"
150 #include "aout/aout64.h"
151 #include "aout/stab_gnu.h"
164 #define N_TYPE 0x1f /* Type mask. */
165 #define N_UNDF 0x00 /* Undefined. */
166 #define N_ABS 0x01 /* Absolute. */
167 #define N_TEXT 0x02 /* Text segment. */
168 #define N_DATA 0x03 /* Data segment. */
169 #define N_BSS 0x04 /* Bss segment. */
170 #define N_REG 0x14 /* Register symbol. */
171 #define N_FN 0x1f /* File name. */
172 #define N_EXT 0x20 /* External flag. */
173 #define N_STAB 0xc0 /* Not relevant; modified aout64.h's 0xe0 to avoid N_EXT. */
177 #define RELFLG 0x0001 /* PC-relative flag. */
178 #define RTYPE 0x000e /* Type mask. */
179 #define RIDXMASK 0xfff0 /* Index mask. */
181 #define RABS 0x00 /* Absolute. */
182 #define RTEXT 0x02 /* Text. */
183 #define RDATA 0x04 /* Data. */
184 #define RBSS 0x06 /* Bss. */
185 #define REXT 0x08 /* External. */
187 #define RINDEX(x) (((x) & 0xfff0) >> 4)
189 #ifndef MY_final_link_relocate
190 #define MY_final_link_relocate _bfd_final_link_relocate
193 #ifndef MY_relocate_contents
194 #define MY_relocate_contents _bfd_relocate_contents
197 /* A hash table used for header files with N_BINCL entries. */
199 struct aout_link_includes_table
201 struct bfd_hash_table root
;
204 /* A linked list of totals that we have found for a particular header
207 struct aout_link_includes_totals
209 struct aout_link_includes_totals
*next
;
213 /* An entry in the header file hash table. */
215 struct aout_link_includes_entry
217 struct bfd_hash_entry root
;
218 /* List of totals we have found for this file. */
219 struct aout_link_includes_totals
*totals
;
222 /* During the final link step we need to pass around a bunch of
223 information, so we do it in an instance of this structure. */
225 struct aout_final_link_info
227 /* General link information. */
228 struct bfd_link_info
*info
;
231 /* Reloc file positions. */
232 file_ptr treloff
, dreloff
;
233 /* File position of symbols. */
236 struct bfd_strtab_hash
*strtab
;
237 /* Header file hash table. */
238 struct aout_link_includes_table includes
;
239 /* A buffer large enough to hold the contents of any section. */
241 /* A buffer large enough to hold the relocs of any section. */
243 /* A buffer large enough to hold the symbol map of any input BFD. */
245 /* A buffer large enough to hold output symbols of any input BFD. */
246 struct external_nlist
*output_syms
;
249 /* Copy of the link_info.separate_code boolean to select the output format with
250 separate instruction and data spaces selected by --imagic */
251 static bfd_boolean separate_i_d
= FALSE
;
253 reloc_howto_type howto_table_pdp11
[] =
255 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
256 HOWTO( 0, 0, 1, 16, FALSE
, 0, complain_overflow_signed
,0,"16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
257 HOWTO( 1, 0, 1, 16, TRUE
, 0, complain_overflow_signed
,0,"DISP16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
260 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
263 static bfd_boolean
aout_link_check_archive_element (bfd
*, struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *, bfd_boolean
*);
264 static bfd_boolean
aout_link_add_object_symbols (bfd
*, struct bfd_link_info
*);
265 static bfd_boolean
aout_link_add_symbols (bfd
*, struct bfd_link_info
*);
266 static bfd_boolean
aout_link_write_symbols (struct aout_final_link_info
*, bfd
*);
270 NAME (aout
, reloc_type_lookup
) (bfd
* abfd ATTRIBUTE_UNUSED
,
271 bfd_reloc_code_real_type code
)
276 return &howto_table_pdp11
[0];
277 case BFD_RELOC_16_PCREL
:
278 return &howto_table_pdp11
[1];
285 NAME (aout
, reloc_name_lookup
) (bfd
*abfd ATTRIBUTE_UNUSED
,
291 i
< sizeof (howto_table_pdp11
) / sizeof (howto_table_pdp11
[0]);
293 if (howto_table_pdp11
[i
].name
!= NULL
294 && strcasecmp (howto_table_pdp11
[i
].name
, r_name
) == 0)
295 return &howto_table_pdp11
[i
];
301 pdp11_aout_write_headers (bfd
*abfd
, struct internal_exec
*execp
)
303 struct external_exec exec_bytes
;
305 if (adata(abfd
).magic
== undecided_magic
)
306 NAME (aout
, adjust_sizes_and_vmas
) (abfd
);
308 execp
->a_syms
= bfd_get_symcount (abfd
) * EXTERNAL_NLIST_SIZE
;
309 execp
->a_entry
= bfd_get_start_address (abfd
);
311 if (obj_textsec (abfd
)->reloc_count
> 0
312 || obj_datasec (abfd
)->reloc_count
> 0)
314 execp
->a_trsize
= execp
->a_text
;
315 execp
->a_drsize
= execp
->a_data
;
323 NAME (aout
, swap_exec_header_out
) (abfd
, execp
, & exec_bytes
);
325 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
328 if (bfd_bwrite ((void *) &exec_bytes
, (bfd_size_type
) EXEC_BYTES_SIZE
, abfd
)
332 /* Now write out reloc info, followed by syms and strings. */
333 if (bfd_get_outsymbols (abfd
) != NULL
334 && bfd_get_symcount (abfd
) != 0)
336 if (bfd_seek (abfd
, (file_ptr
) (N_SYMOFF (execp
)), SEEK_SET
) != 0)
339 if (! NAME (aout
, write_syms
) (abfd
))
343 if (obj_textsec (abfd
)->reloc_count
> 0
344 || obj_datasec (abfd
)->reloc_count
> 0)
346 if (bfd_seek (abfd
, (file_ptr
) (N_TRELOFF (execp
)), SEEK_SET
) != 0
347 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_textsec (abfd
))
348 || bfd_seek (abfd
, (file_ptr
) (N_DRELOFF (execp
)), SEEK_SET
) != 0
349 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_datasec (abfd
)))
356 /* Write an object file.
357 Section contents have already been written. We write the
358 file header, symbols, and relocation. */
361 MY(write_object_contents
) (bfd
*abfd
)
363 struct internal_exec
*execp
= exec_hdr (abfd
);
365 /* We must make certain that the magic number has been set. This
366 will normally have been done by set_section_contents, but only if
367 there actually are some section contents. */
368 if (! abfd
->output_has_begun
)
369 NAME (aout
, adjust_sizes_and_vmas
) (abfd
);
371 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
373 return WRITE_HEADERS (abfd
, execp
);
376 /* Swap the information in an executable header @var{raw_bytes} taken
377 from a raw byte stream memory image into the internal exec header
378 structure "execp". */
380 #ifndef NAME_swap_exec_header_in
382 NAME (aout
, swap_exec_header_in
) (bfd
*abfd
,
383 struct external_exec
*bytes
,
384 struct internal_exec
*execp
)
386 /* The internal_exec structure has some fields that are unused in this
387 configuration (IE for i960), so ensure that all such uninitialized
388 fields are zero'd out. There are places where two of these structs
389 are memcmp'd, and thus the contents do matter. */
390 memset ((void *) execp
, 0, sizeof (struct internal_exec
));
391 /* Now fill in fields in the execp, from the bytes in the raw data. */
392 execp
->a_info
= GET_MAGIC (abfd
, bytes
->e_info
);
393 execp
->a_text
= GET_WORD (abfd
, bytes
->e_text
);
394 execp
->a_data
= GET_WORD (abfd
, bytes
->e_data
);
395 execp
->a_bss
= GET_WORD (abfd
, bytes
->e_bss
);
396 execp
->a_syms
= GET_WORD (abfd
, bytes
->e_syms
);
397 execp
->a_entry
= GET_WORD (abfd
, bytes
->e_entry
);
399 if (GET_WORD (abfd
, bytes
->e_flag
) & A_FLAG_RELOC_STRIPPED
)
406 execp
->a_trsize
= execp
->a_text
;
407 execp
->a_drsize
= execp
->a_data
;
410 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
413 /* Swap the information in an internal exec header structure
414 "execp" into the buffer "bytes" ready for writing to disk. */
416 NAME (aout
, swap_exec_header_out
) (bfd
*abfd
,
417 struct internal_exec
*execp
,
418 struct external_exec
*bytes
)
420 /* Now fill in fields in the raw data, from the fields in the exec struct. */
421 PUT_MAGIC (abfd
, execp
->a_info
, bytes
->e_info
);
422 PUT_WORD (abfd
, execp
->a_text
, bytes
->e_text
);
423 PUT_WORD (abfd
, execp
->a_data
, bytes
->e_data
);
424 PUT_WORD (abfd
, execp
->a_bss
, bytes
->e_bss
);
425 PUT_WORD (abfd
, execp
->a_syms
, bytes
->e_syms
);
426 PUT_WORD (abfd
, execp
->a_entry
, bytes
->e_entry
);
427 PUT_WORD (abfd
, 0, bytes
->e_unused
);
429 if ((execp
->a_trsize
== 0 || execp
->a_text
== 0)
430 && (execp
->a_drsize
== 0 || execp
->a_data
== 0))
431 PUT_WORD (abfd
, A_FLAG_RELOC_STRIPPED
, bytes
->e_flag
);
432 else if (execp
->a_trsize
== execp
->a_text
433 && execp
->a_drsize
== execp
->a_data
)
434 PUT_WORD (abfd
, 0, bytes
->e_flag
);
437 /* TODO: print a proper warning message. */
438 fprintf (stderr
, "BFD:%s:%d: internal error\n", __FILE__
, __LINE__
);
439 PUT_WORD (abfd
, 0, bytes
->e_flag
);
443 /* Make all the section for an a.out file. */
446 NAME (aout
, make_sections
) (bfd
*abfd
)
448 if (obj_textsec (abfd
) == NULL
&& bfd_make_section (abfd
, ".text") == NULL
)
450 if (obj_datasec (abfd
) == NULL
&& bfd_make_section (abfd
, ".data") == NULL
)
452 if (obj_bsssec (abfd
) == NULL
&& bfd_make_section (abfd
, ".bss") == NULL
)
457 /* Some a.out variant thinks that the file open in ABFD
458 checking is an a.out file. Do some more checking, and set up
459 for access if it really is. Call back to the calling
460 environment's "finish up" function just before returning, to
461 handle any last-minute setup. */
464 NAME (aout
, some_aout_object_p
) (bfd
*abfd
,
465 struct internal_exec
*execp
,
466 bfd_cleanup (*callback_to_real_object_p
) (bfd
*))
468 struct aout_data_struct
*rawptr
, *oldrawptr
;
470 size_t amt
= sizeof (struct aout_data_struct
);
472 rawptr
= bfd_zalloc (abfd
, amt
);
476 oldrawptr
= abfd
->tdata
.aout_data
;
477 abfd
->tdata
.aout_data
= rawptr
;
479 /* Copy the contents of the old tdata struct. */
480 if (oldrawptr
!= NULL
)
481 *abfd
->tdata
.aout_data
= *oldrawptr
;
483 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
484 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
; /* Copy in the internal_exec struct. */
485 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
487 /* Set the file flags. */
488 abfd
->flags
= BFD_NO_FLAGS
;
489 if (execp
->a_drsize
|| execp
->a_trsize
)
490 abfd
->flags
|= HAS_RELOC
;
491 /* Setting of EXEC_P has been deferred to the bottom of this function. */
493 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
494 if (N_DYNAMIC (execp
))
495 abfd
->flags
|= DYNAMIC
;
497 if (N_MAGIC (execp
) == ZMAGIC
)
499 abfd
->flags
|= D_PAGED
| WP_TEXT
;
500 adata (abfd
).magic
= z_magic
;
502 else if (N_MAGIC (execp
) == NMAGIC
)
504 abfd
->flags
|= WP_TEXT
;
505 adata (abfd
).magic
= n_magic
;
507 else if (N_MAGIC (execp
) == OMAGIC
)
508 adata (abfd
).magic
= o_magic
;
509 else if (N_MAGIC (execp
) == IMAGIC
)
510 adata (abfd
).magic
= i_magic
;
513 /* Should have been checked with N_BADMAG before this routine
518 abfd
->start_address
= execp
->a_entry
;
520 obj_aout_symbols (abfd
) = NULL
;
521 abfd
->symcount
= execp
->a_syms
/ sizeof (struct external_nlist
);
523 /* The default relocation entry size is that of traditional V7 Unix. */
524 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
526 /* The default symbol entry size is that of traditional Unix. */
527 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
530 bfd_init_window (&obj_aout_sym_window (abfd
));
531 bfd_init_window (&obj_aout_string_window (abfd
));
534 obj_aout_external_syms (abfd
) = NULL
;
535 obj_aout_external_strings (abfd
) = NULL
;
536 obj_aout_sym_hashes (abfd
) = NULL
;
538 if (! NAME (aout
, make_sections
) (abfd
))
541 obj_datasec (abfd
)->size
= execp
->a_data
;
542 obj_bsssec (abfd
)->size
= execp
->a_bss
;
544 obj_textsec (abfd
)->flags
=
545 (execp
->a_trsize
!= 0
546 ? (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_RELOC
)
547 : (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
));
548 obj_datasec (abfd
)->flags
=
549 (execp
->a_drsize
!= 0
550 ? (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_RELOC
)
551 : (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
));
552 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
554 #ifdef THIS_IS_ONLY_DOCUMENTATION
555 /* The common code can't fill in these things because they depend
556 on either the start address of the text segment, the rounding
557 up of virtual addresses between segments, or the starting file
558 position of the text segment -- all of which varies among different
559 versions of a.out. */
561 /* Call back to the format-dependent code to fill in the rest of the
562 fields and do any further cleanup. Things that should be filled
563 in by the callback: */
564 struct exec
*execp
= exec_hdr (abfd
);
566 obj_textsec (abfd
)->size
= N_TXTSIZE (execp
);
567 /* Data and bss are already filled in since they're so standard. */
569 /* The virtual memory addresses of the sections. */
570 obj_textsec (abfd
)->vma
= N_TXTADDR (execp
);
571 obj_datasec (abfd
)->vma
= N_DATADDR (execp
);
572 obj_bsssec (abfd
)->vma
= N_BSSADDR (execp
);
574 /* The file offsets of the sections. */
575 obj_textsec (abfd
)->filepos
= N_TXTOFF (execp
);
576 obj_datasec (abfd
)->filepos
= N_DATOFF (execp
);
578 /* The file offsets of the relocation info. */
579 obj_textsec (abfd
)->rel_filepos
= N_TRELOFF (execp
);
580 obj_datasec (abfd
)->rel_filepos
= N_DRELOFF (execp
);
582 /* The file offsets of the string table and symbol table. */
583 obj_str_filepos (abfd
) = N_STROFF (execp
);
584 obj_sym_filepos (abfd
) = N_SYMOFF (execp
);
586 /* Determine the architecture and machine type of the object file. */
587 abfd
->obj_arch
= bfd_arch_obscure
;
589 adata(abfd
)->page_size
= TARGET_PAGE_SIZE
;
590 adata(abfd
)->segment_size
= SEGMENT_SIZE
;
591 adata(abfd
)->exec_bytes_size
= EXEC_BYTES_SIZE
;
593 return _bfd_no_cleanup
;
595 /* The architecture is encoded in various ways in various a.out variants,
596 or is not encoded at all in some of them. The relocation size depends
597 on the architecture and the a.out variant. Finally, the return value
598 is the bfd_target vector in use. If an error occurs, return zero and
599 set bfd_error to the appropriate error code.
601 Formats such as b.out, which have additional fields in the a.out
602 header, should cope with them in this callback as well. */
603 #endif /* DOCUMENTATION */
605 cleanup
= (*callback_to_real_object_p
)(abfd
);
607 /* Now that the segment addresses have been worked out, take a better
608 guess at whether the file is executable. If the entry point
609 is within the text segment, assume it is. (This makes files
610 executable even if their entry point address is 0, as long as
611 their text starts at zero.).
613 This test had to be changed to deal with systems where the text segment
614 runs at a different location than the default. The problem is that the
615 entry address can appear to be outside the text segment, thus causing an
616 erroneous conclusion that the file isn't executable.
618 To fix this, we now accept any non-zero entry point as an indication of
619 executability. This will work most of the time, since only the linker
620 sets the entry point, and that is likely to be non-zero for most systems. */
622 if (execp
->a_entry
!= 0
623 || (execp
->a_entry
>= obj_textsec(abfd
)->vma
624 && execp
->a_entry
< obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->size
))
625 abfd
->flags
|= EXEC_P
;
629 struct stat stat_buf
;
631 /* The original heuristic doesn't work in some important cases.
632 The a.out file has no information about the text start
633 address. For files (like kernels) linked to non-standard
634 addresses (ld -Ttext nnn) the entry point may not be between
635 the default text start (obj_textsec(abfd)->vma) and
636 (obj_textsec(abfd)->vma) + text size. This is not just a mach
637 issue. Many kernels are loaded at non standard addresses. */
638 if (abfd
->iostream
!= NULL
639 && (abfd
->flags
& BFD_IN_MEMORY
) == 0
640 && (fstat(fileno((FILE *) (abfd
->iostream
)), &stat_buf
) == 0)
641 && ((stat_buf
.st_mode
& 0111) != 0))
642 abfd
->flags
|= EXEC_P
;
644 #endif /* STAT_FOR_EXEC */
649 abfd
->tdata
.aout_data
= oldrawptr
;
654 /* Initialize ABFD for use with a.out files. */
657 NAME (aout
, mkobject
) (bfd
*abfd
)
659 struct aout_data_struct
*rawptr
;
660 size_t amt
= sizeof (struct aout_data_struct
);
662 bfd_set_error (bfd_error_system_call
);
664 /* Use an intermediate variable for clarity. */
665 rawptr
= bfd_zalloc (abfd
, amt
);
670 abfd
->tdata
.aout_data
= rawptr
;
671 exec_hdr (abfd
) = &(rawptr
->e
);
673 obj_textsec (abfd
) = NULL
;
674 obj_datasec (abfd
) = NULL
;
675 obj_bsssec (abfd
) = NULL
;
680 /* Keep track of machine architecture and machine type for
681 a.out's. Return the <<machine_type>> for a particular
682 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
683 and machine can't be represented in a.out format.
685 If the architecture is understood, machine type 0 (default)
686 is always understood. */
689 NAME (aout
, machine_type
) (enum bfd_architecture arch
,
690 unsigned long machine
,
691 bfd_boolean
*unknown
)
693 enum machine_type arch_flags
;
695 arch_flags
= M_UNKNOWN
;
702 || machine
== bfd_mach_sparc
703 || machine
== bfd_mach_sparc_sparclite
704 || machine
== bfd_mach_sparc_v9
)
705 arch_flags
= M_SPARC
;
706 else if (machine
== bfd_mach_sparc_sparclet
)
707 arch_flags
= M_SPARCLET
;
712 || machine
== bfd_mach_i386_i386
713 || machine
== bfd_mach_i386_i386_intel_syntax
)
718 if (machine
== 0) arch_flags
= M_ARM
;
726 case bfd_mach_mips3000
:
727 arch_flags
= M_MIPS1
;
729 case bfd_mach_mips4000
: /* MIPS3 */
730 case bfd_mach_mips4400
:
731 case bfd_mach_mips8000
: /* MIPS4 */
732 case bfd_mach_mips6000
: /* Real MIPS2: */
733 arch_flags
= M_MIPS2
;
736 arch_flags
= M_UNKNOWN
;
744 case 0: arch_flags
= M_NS32532
; break;
745 case 32032: arch_flags
= M_NS32032
; break;
746 case 32532: arch_flags
= M_NS32532
; break;
747 default: arch_flags
= M_UNKNOWN
; break;
752 /* TODO: arch_flags = M_PDP11; */
761 arch_flags
= M_UNKNOWN
;
764 if (arch_flags
!= M_UNKNOWN
)
770 /* Set the architecture and the machine of the ABFD to the
771 values ARCH and MACHINE. Verify that @ABFD's format
772 can support the architecture required. */
775 NAME (aout
, set_arch_mach
) (bfd
*abfd
,
776 enum bfd_architecture arch
,
777 unsigned long machine
)
779 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
782 if (arch
!= bfd_arch_unknown
)
786 NAME (aout
, machine_type
) (arch
, machine
, &unknown
);
791 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
793 return (*aout_backend_info(abfd
)->set_sizes
) (abfd
);
797 adjust_o_magic (bfd
*abfd
, struct internal_exec
*execp
)
799 file_ptr pos
= adata (abfd
).exec_bytes_size
;
802 asection
*text
= obj_textsec (abfd
);
803 asection
*data
= obj_datasec (abfd
);
804 asection
*bss
= obj_bsssec (abfd
);
808 if (!text
->user_set_vma
)
813 pos
+= execp
->a_text
;
814 vma
+= execp
->a_text
;
817 if (!data
->user_set_vma
)
825 execp
->a_text
+= pad
;
832 if (!bss
->user_set_vma
)
838 else if (data
->size
> 0 || bss
->size
> 0) /* PR25677: for objcopy --extract-symbol */
840 /* The VMA of the .bss section is set by the VMA of the
841 .data section plus the size of the .data section. We may
842 need to add padding bytes to make this true. */
843 pad
= bss
->vma
- vma
;
848 execp
->a_data
= data
->size
+ pad
;
850 execp
->a_bss
= bss
->size
;
852 N_SET_MAGIC (execp
, OMAGIC
);
856 adjust_z_magic (bfd
*abfd
, struct internal_exec
*execp
)
858 bfd_size_type data_pad
, text_pad
;
860 const struct aout_backend_data
*abdp
;
861 /* TRUE if text includes exec header. */
863 asection
*text
= obj_textsec (abfd
);
864 asection
*data
= obj_datasec (abfd
);
865 asection
*bss
= obj_bsssec (abfd
);
867 abdp
= aout_backend_info (abfd
);
871 && (abdp
->text_includes_header
872 || obj_aout_subformat (abfd
) == q_magic_format
));
873 text
->filepos
= (ztih
874 ? adata (abfd
).exec_bytes_size
875 : adata (abfd
).zmagic_disk_block_size
);
876 if (!text
->user_set_vma
)
878 /* ?? Do we really need to check for relocs here? */
879 text
->vma
= ((abfd
->flags
& HAS_RELOC
)
882 ? abdp
->default_text_vma
+ adata (abfd
).exec_bytes_size
883 : abdp
->default_text_vma
));
888 /* The .text section is being loaded at an unusual address. We
889 may need to pad it such that the .data section starts at a page
892 text_pad
= ((text
->filepos
- text
->vma
)
893 & (adata (abfd
).page_size
- 1));
895 text_pad
= (-text
->vma
896 & (adata (abfd
).page_size
- 1));
899 /* Find start of data. */
902 text_end
= text
->filepos
+ execp
->a_text
;
903 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
907 /* Note that if page_size == zmagic_disk_block_size, then
908 filepos == page_size, and this case is the same as the ztih
910 text_end
= execp
->a_text
;
911 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
912 text_end
+= text
->filepos
;
914 execp
->a_text
+= text_pad
;
917 if (!data
->user_set_vma
)
920 vma
= text
->vma
+ execp
->a_text
;
921 data
->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
923 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
925 text_pad
= data
->vma
- (text
->vma
+ execp
->a_text
);
926 /* Only pad the text section if the data
927 section is going to be placed after it. */
929 execp
->a_text
+= text_pad
;
931 data
->filepos
= text
->filepos
+ execp
->a_text
;
933 /* Fix up exec header while we're at it. */
934 if (ztih
&& (!abdp
|| (abdp
&& !abdp
->exec_header_not_counted
)))
935 execp
->a_text
+= adata (abfd
).exec_bytes_size
;
936 N_SET_MAGIC (execp
, ZMAGIC
);
938 /* Spec says data section should be rounded up to page boundary. */
939 execp
->a_data
= align_power (data
->size
, bss
->alignment_power
);
940 execp
->a_data
= BFD_ALIGN (execp
->a_data
, adata (abfd
).page_size
);
941 data_pad
= execp
->a_data
- data
->size
;
944 if (!bss
->user_set_vma
)
945 bss
->vma
= data
->vma
+ execp
->a_data
;
946 /* If the BSS immediately follows the data section and extra space
947 in the page is left after the data section, fudge data
948 in the header so that the bss section looks smaller by that
949 amount. We'll start the bss section there, and lie to the OS.
950 (Note that a linker script, as well as the above assignment,
951 could have explicitly set the BSS vma to immediately follow
952 the data section.) */
953 if (align_power (bss
->vma
, bss
->alignment_power
) == data
->vma
+ execp
->a_data
)
954 execp
->a_bss
= data_pad
> bss
->size
? 0 : bss
->size
- data_pad
;
956 execp
->a_bss
= bss
->size
;
960 adjust_n_magic (bfd
*abfd
, struct internal_exec
*execp
)
962 file_ptr pos
= adata (abfd
).exec_bytes_size
;
965 asection
*text
= obj_textsec (abfd
);
966 asection
*data
= obj_datasec (abfd
);
967 asection
*bss
= obj_bsssec (abfd
);
971 if (!text
->user_set_vma
)
975 pos
+= execp
->a_text
;
976 vma
+= execp
->a_text
;
980 if (!data
->user_set_vma
)
981 data
->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
984 /* Since BSS follows data immediately, see if it needs alignment. */
986 pad
= align_power (vma
, bss
->alignment_power
) - vma
;
987 execp
->a_data
= data
->size
+ pad
;
988 pos
+= execp
->a_data
;
991 if (!bss
->user_set_vma
)
996 /* Fix up exec header. */
997 execp
->a_bss
= bss
->size
;
998 N_SET_MAGIC (execp
, NMAGIC
);
1002 adjust_i_magic (bfd
*abfd
, struct internal_exec
*execp
)
1004 file_ptr pos
= adata (abfd
).exec_bytes_size
;
1007 asection
*text
= obj_textsec (abfd
);
1008 asection
*data
= obj_datasec (abfd
);
1009 asection
*bss
= obj_bsssec (abfd
);
1012 text
->filepos
= pos
;
1013 if (!text
->user_set_vma
)
1017 pos
+= execp
->a_text
;
1020 data
->filepos
= pos
;
1021 if (!data
->user_set_vma
)
1025 /* Since BSS follows data immediately, see if it needs alignment. */
1027 pad
= align_power (vma
, bss
->alignment_power
) - vma
;
1028 execp
->a_data
= data
->size
+ pad
;
1029 pos
+= execp
->a_data
;
1032 if (!bss
->user_set_vma
)
1037 /* Fix up exec header. */
1038 execp
->a_bss
= bss
->size
;
1039 N_SET_MAGIC (execp
, IMAGIC
);
1043 NAME (aout
, adjust_sizes_and_vmas
) (bfd
*abfd
)
1045 struct internal_exec
*execp
= exec_hdr (abfd
);
1047 if (! NAME (aout
, make_sections
) (abfd
))
1050 if (adata (abfd
).magic
!= undecided_magic
)
1053 execp
->a_text
= align_power (obj_textsec (abfd
)->size
,
1054 obj_textsec (abfd
)->alignment_power
);
1056 /* Rule (heuristic) for when to pad to a new page. Note that there
1057 are (at least) two ways demand-paged (ZMAGIC) files have been
1058 handled. Most Berkeley-based systems start the text segment at
1059 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1060 segment right after the exec header; the latter is counted in the
1061 text segment size, and is paged in by the kernel with the rest of
1064 /* This perhaps isn't the right way to do this, but made it simpler for me
1065 to understand enough to implement it. Better would probably be to go
1066 right from BFD flags to alignment/positioning characteristics. But the
1067 old code was sloppy enough about handling the flags, and had enough
1068 other magic, that it was a little hard for me to understand. I think
1069 I understand it better now, but I haven't time to do the cleanup this
1073 adata (abfd
).magic
= i_magic
;
1074 else if (abfd
->flags
& WP_TEXT
)
1075 adata (abfd
).magic
= n_magic
;
1077 adata (abfd
).magic
= o_magic
;
1079 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1081 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1083 switch (adata (abfd
).magic
)
1085 case n_magic
: str
= "NMAGIC"; break;
1086 case o_magic
: str
= "OMAGIC"; break;
1087 case i_magic
: str
= "IMAGIC"; break;
1088 case z_magic
: str
= "ZMAGIC"; break;
1093 obj_textsec (abfd
)->vma
, obj_textsec (abfd
)->size
,
1094 obj_textsec (abfd
)->alignment_power
,
1095 obj_datasec (abfd
)->vma
, obj_datasec (abfd
)->size
,
1096 obj_datasec (abfd
)->alignment_power
,
1097 obj_bsssec (abfd
)->vma
, obj_bsssec (abfd
)->size
,
1098 obj_bsssec (abfd
)->alignment_power
);
1102 switch (adata (abfd
).magic
)
1105 adjust_o_magic (abfd
, execp
);
1108 adjust_z_magic (abfd
, execp
);
1111 adjust_n_magic (abfd
, execp
);
1114 adjust_i_magic (abfd
, execp
);
1120 #ifdef BFD_AOUT_DEBUG
1121 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1122 obj_textsec (abfd
)->vma
, execp
->a_text
,
1123 obj_textsec (abfd
)->filepos
,
1124 obj_datasec (abfd
)->vma
, execp
->a_data
,
1125 obj_datasec (abfd
)->filepos
,
1126 obj_bsssec (abfd
)->vma
, execp
->a_bss
);
1132 /* Called by the BFD in response to a bfd_make_section request. */
1135 NAME (aout
, new_section_hook
) (bfd
*abfd
, asection
*newsect
)
1137 /* Align to double at least. */
1138 newsect
->alignment_power
= bfd_get_arch_info(abfd
)->section_align_power
;
1140 if (bfd_get_format (abfd
) == bfd_object
)
1142 if (obj_textsec (abfd
) == NULL
1143 && !strcmp (newsect
->name
, ".text"))
1145 obj_textsec(abfd
)= newsect
;
1146 newsect
->target_index
= N_TEXT
;
1148 else if (obj_datasec (abfd
) == NULL
1149 && !strcmp (newsect
->name
, ".data"))
1151 obj_datasec (abfd
) = newsect
;
1152 newsect
->target_index
= N_DATA
;
1154 else if (obj_bsssec (abfd
) == NULL
1155 && !strcmp (newsect
->name
, ".bss"))
1157 obj_bsssec (abfd
) = newsect
;
1158 newsect
->target_index
= N_BSS
;
1162 /* We allow more than three sections internally. */
1163 return _bfd_generic_new_section_hook (abfd
, newsect
);
1167 NAME (aout
, set_section_contents
) (bfd
*abfd
,
1169 const void * location
,
1171 bfd_size_type count
)
1173 if (! abfd
->output_has_begun
)
1175 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
1179 if (section
== obj_bsssec (abfd
))
1181 bfd_set_error (bfd_error_no_contents
);
1185 if (section
!= obj_textsec (abfd
)
1186 && section
!= obj_datasec (abfd
))
1189 /* xgettext:c-format */
1190 (_("%pB: can not represent section `%pA' in a.out object file format"),
1192 bfd_set_error (bfd_error_nonrepresentable_section
);
1198 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
1199 || bfd_bwrite (location
, count
, abfd
) != count
)
1206 /* Read the external symbols from an a.out file. */
1209 aout_get_external_symbols (bfd
*abfd
)
1211 if (obj_aout_external_syms (abfd
) == NULL
)
1213 bfd_size_type count
;
1214 struct external_nlist
*syms
;
1216 count
= exec_hdr (abfd
)->a_syms
/ EXTERNAL_NLIST_SIZE
;
1218 /* PR 17512: file: 011f5a08. */
1221 obj_aout_external_syms (abfd
) = NULL
;
1222 obj_aout_external_sym_count (abfd
) = count
;
1227 if (! bfd_get_file_window (abfd
, obj_sym_filepos (abfd
),
1228 exec_hdr (abfd
)->a_syms
,
1229 &obj_aout_sym_window (abfd
), TRUE
))
1231 syms
= (struct external_nlist
*) obj_aout_sym_window (abfd
).data
;
1233 /* We allocate using malloc to make the values easy to free
1234 later on. If we put them on the objalloc it might not be
1235 possible to free them. */
1236 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1238 syms
= (struct external_nlist
*)
1239 _bfd_malloc_and_read (abfd
, count
* EXTERNAL_NLIST_SIZE
,
1240 count
* EXTERNAL_NLIST_SIZE
);
1241 if (syms
== NULL
&& count
!= 0)
1245 obj_aout_external_syms (abfd
) = syms
;
1246 obj_aout_external_sym_count (abfd
) = count
;
1249 if (obj_aout_external_strings (abfd
) == NULL
1250 && exec_hdr (abfd
)->a_syms
!= 0)
1252 unsigned char string_chars
[BYTES_IN_LONG
];
1253 bfd_size_type stringsize
;
1256 /* Get the size of the strings. */
1257 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
1258 || (bfd_bread ((void *) string_chars
, (bfd_size_type
) BYTES_IN_LONG
,
1259 abfd
) != BYTES_IN_LONG
))
1261 stringsize
= H_GET_32 (abfd
, string_chars
);
1264 if (! bfd_get_file_window (abfd
, obj_str_filepos (abfd
), stringsize
,
1265 &obj_aout_string_window (abfd
), TRUE
))
1267 strings
= (char *) obj_aout_string_window (abfd
).data
;
1269 strings
= bfd_malloc (stringsize
+ 1);
1270 if (strings
== NULL
)
1273 /* Skip space for the string count in the buffer for convenience
1274 when using indexes. */
1275 if (bfd_bread (strings
+ 4, stringsize
- 4, abfd
) != stringsize
- 4)
1281 /* Ensure that a zero index yields an empty string. */
1284 strings
[stringsize
- 1] = 0;
1286 obj_aout_external_strings (abfd
) = strings
;
1287 obj_aout_external_string_size (abfd
) = stringsize
;
1293 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1294 and symbol->value fields of CACHE_PTR will be set from the a.out
1295 nlist structure. This function is responsible for setting
1296 symbol->flags and symbol->section, and adjusting symbol->value. */
1299 translate_from_native_sym_flags (bfd
*abfd
,
1300 aout_symbol_type
*cache_ptr
)
1304 if (cache_ptr
->type
== N_FN
)
1308 /* This is a debugging symbol. */
1309 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1311 /* Work out the symbol section. */
1312 switch (cache_ptr
->type
& N_TYPE
)
1316 sec
= obj_textsec (abfd
);
1319 sec
= obj_datasec (abfd
);
1322 sec
= obj_bsssec (abfd
);
1326 sec
= bfd_abs_section_ptr
;
1330 cache_ptr
->symbol
.section
= sec
;
1331 cache_ptr
->symbol
.value
-= sec
->vma
;
1336 /* Get the default visibility. This does not apply to all types, so
1337 we just hold it in a local variable to use if wanted. */
1338 if ((cache_ptr
->type
& N_EXT
) == 0)
1339 visible
= BSF_LOCAL
;
1341 visible
= BSF_GLOBAL
;
1343 switch (cache_ptr
->type
)
1346 case N_ABS
: case N_ABS
| N_EXT
:
1347 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1348 cache_ptr
->symbol
.flags
= visible
;
1351 case N_UNDF
| N_EXT
:
1352 if (cache_ptr
->symbol
.value
!= 0)
1354 /* This is a common symbol. */
1355 cache_ptr
->symbol
.flags
= BSF_GLOBAL
;
1356 cache_ptr
->symbol
.section
= bfd_com_section_ptr
;
1360 cache_ptr
->symbol
.flags
= 0;
1361 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1365 case N_TEXT
: case N_TEXT
| N_EXT
:
1366 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1367 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1368 cache_ptr
->symbol
.flags
= visible
;
1371 case N_DATA
: case N_DATA
| N_EXT
:
1372 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1373 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1374 cache_ptr
->symbol
.flags
= visible
;
1377 case N_BSS
: case N_BSS
| N_EXT
:
1378 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1379 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1380 cache_ptr
->symbol
.flags
= visible
;
1387 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1390 translate_to_native_sym_flags (bfd
*abfd
,
1392 struct external_nlist
*sym_pointer
)
1394 bfd_vma value
= cache_ptr
->value
;
1398 /* Mask out any existing type bits in case copying from one section
1400 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1402 sec
= bfd_asymbol_section (cache_ptr
);
1407 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1410 /* xgettext:c-format */
1411 (_("%pB: can not represent section for symbol `%s' in a.out object file format"),
1412 abfd
, cache_ptr
->name
!= NULL
? cache_ptr
->name
: "*unknown*");
1413 bfd_set_error (bfd_error_nonrepresentable_section
);
1417 if (sec
->output_section
!= NULL
)
1419 off
= sec
->output_offset
;
1420 sec
= sec
->output_section
;
1423 if (bfd_is_abs_section (sec
))
1424 sym_pointer
->e_type
[0] |= N_ABS
;
1425 else if (sec
== obj_textsec (abfd
))
1426 sym_pointer
->e_type
[0] |= N_TEXT
;
1427 else if (sec
== obj_datasec (abfd
))
1428 sym_pointer
->e_type
[0] |= N_DATA
;
1429 else if (sec
== obj_bsssec (abfd
))
1430 sym_pointer
->e_type
[0] |= N_BSS
;
1431 else if (bfd_is_und_section (sec
))
1432 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1433 else if (bfd_is_com_section (sec
))
1434 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1438 /* xgettext:c-format */
1439 (_("%pB: can not represent section `%pA' in a.out object file format"),
1441 bfd_set_error (bfd_error_nonrepresentable_section
);
1445 /* Turn the symbol from section relative to absolute again */
1446 value
+= sec
->vma
+ off
;
1448 if ((cache_ptr
->flags
& BSF_DEBUGGING
) != 0)
1449 sym_pointer
->e_type
[0] = ((aout_symbol_type
*) cache_ptr
)->type
;
1450 else if ((cache_ptr
->flags
& BSF_GLOBAL
) != 0)
1451 sym_pointer
->e_type
[0] |= N_EXT
;
1453 PUT_WORD(abfd
, value
, sym_pointer
->e_value
);
1458 /* Native-level interface to symbols. */
1461 NAME (aout
, make_empty_symbol
) (bfd
*abfd
)
1463 size_t amt
= sizeof (aout_symbol_type
);
1464 aout_symbol_type
*new_symbol_type
= bfd_zalloc (abfd
, amt
);
1466 if (!new_symbol_type
)
1468 new_symbol_type
->symbol
.the_bfd
= abfd
;
1470 return &new_symbol_type
->symbol
;
1473 /* Translate a set of internal symbols into external symbols. */
1476 NAME (aout
, translate_symbol_table
) (bfd
*abfd
,
1477 aout_symbol_type
*in
,
1478 struct external_nlist
*ext
,
1479 bfd_size_type count
,
1481 bfd_size_type strsize
,
1482 bfd_boolean dynamic
)
1484 struct external_nlist
*ext_end
;
1486 ext_end
= ext
+ count
;
1487 for (; ext
< ext_end
; ext
++, in
++)
1491 x
= GET_WORD (abfd
, ext
->e_strx
);
1492 in
->symbol
.the_bfd
= abfd
;
1494 /* For the normal symbols, the zero index points at the number
1495 of bytes in the string table but is to be interpreted as the
1496 null string. For the dynamic symbols, the number of bytes in
1497 the string table is stored in the __DYNAMIC structure and the
1498 zero index points at an actual string. */
1499 if (x
== 0 && ! dynamic
)
1500 in
->symbol
.name
= "";
1501 else if (x
< strsize
)
1502 in
->symbol
.name
= str
+ x
;
1506 in
->symbol
.value
= GET_WORD (abfd
, ext
->e_value
);
1507 /* TODO: is 0 a safe value here? */
1510 in
->type
= H_GET_8 (abfd
, ext
->e_type
);
1511 in
->symbol
.udata
.p
= NULL
;
1513 if (! translate_from_native_sym_flags (abfd
, in
))
1517 in
->symbol
.flags
|= BSF_DYNAMIC
;
1523 /* We read the symbols into a buffer, which is discarded when this
1524 function exits. We read the strings into a buffer large enough to
1525 hold them all plus all the cached symbol entries. */
1528 NAME (aout
, slurp_symbol_table
) (bfd
*abfd
)
1530 struct external_nlist
*old_external_syms
;
1531 aout_symbol_type
*cached
;
1532 bfd_size_type cached_size
;
1534 /* If there's no work to be done, don't do any. */
1535 if (obj_aout_symbols (abfd
) != NULL
)
1538 old_external_syms
= obj_aout_external_syms (abfd
);
1540 if (! aout_get_external_symbols (abfd
))
1543 cached_size
= obj_aout_external_sym_count (abfd
);
1544 cached_size
*= sizeof (aout_symbol_type
);
1545 cached
= bfd_zmalloc (cached_size
);
1546 if (cached
== NULL
&& cached_size
!= 0)
1549 /* Convert from external symbol information to internal. */
1550 if (! (NAME (aout
, translate_symbol_table
)
1552 obj_aout_external_syms (abfd
),
1553 obj_aout_external_sym_count (abfd
),
1554 obj_aout_external_strings (abfd
),
1555 obj_aout_external_string_size (abfd
),
1562 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
1564 obj_aout_symbols (abfd
) = cached
;
1566 /* It is very likely that anybody who calls this function will not
1567 want the external symbol information, so if it was allocated
1568 because of our call to aout_get_external_symbols, we free it up
1569 right away to save space. */
1570 if (old_external_syms
== NULL
1571 && obj_aout_external_syms (abfd
) != NULL
)
1574 bfd_free_window (&obj_aout_sym_window (abfd
));
1576 free (obj_aout_external_syms (abfd
));
1578 obj_aout_external_syms (abfd
) = NULL
;
1584 /* We use a hash table when writing out symbols so that we only write
1585 out a particular string once. This helps particularly when the
1586 linker writes out stabs debugging entries, because each different
1587 contributing object file tends to have many duplicate stabs
1590 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1591 if BFD_TRADITIONAL_FORMAT is set. */
1593 /* Get the index of a string in a strtab, adding it if it is not
1596 static INLINE bfd_size_type
1597 add_to_stringtab (bfd
*abfd
,
1598 struct bfd_strtab_hash
*tab
,
1603 bfd_size_type str_index
;
1605 /* An index of 0 always means the empty string. */
1606 if (str
== 0 || *str
== '\0')
1609 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1610 doesn't understand a hashed string table. */
1612 if ((abfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1615 str_index
= _bfd_stringtab_add (tab
, str
, hash
, copy
);
1617 if (str_index
!= (bfd_size_type
) -1)
1618 /* Add BYTES_IN_LONG to the return value to account for the
1619 space taken up by the string table size. */
1620 str_index
+= BYTES_IN_LONG
;
1625 /* Write out a strtab. ABFD is already at the right location in the
1629 emit_stringtab (bfd
*abfd
, struct bfd_strtab_hash
*tab
)
1631 bfd_byte buffer
[BYTES_IN_LONG
];
1633 /* The string table starts with the size. */
1634 H_PUT_32 (abfd
, _bfd_stringtab_size (tab
) + BYTES_IN_LONG
, buffer
);
1635 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) BYTES_IN_LONG
, abfd
)
1639 return _bfd_stringtab_emit (abfd
, tab
);
1643 NAME (aout
, write_syms
) (bfd
*abfd
)
1645 unsigned int count
;
1646 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1647 struct bfd_strtab_hash
*strtab
;
1649 strtab
= _bfd_stringtab_init ();
1653 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1655 asymbol
*g
= generic
[count
];
1657 struct external_nlist nsp
;
1659 PUT_WORD (abfd
, 0, nsp
.e_unused
);
1661 indx
= add_to_stringtab (abfd
, strtab
, g
->name
, FALSE
);
1662 if (indx
== (bfd_size_type
) -1)
1664 PUT_WORD (abfd
, indx
, nsp
.e_strx
);
1666 if (bfd_asymbol_flavour(g
) == abfd
->xvec
->flavour
)
1667 H_PUT_8 (abfd
, aout_symbol(g
)->type
, nsp
.e_type
);
1669 H_PUT_8 (abfd
, 0, nsp
.e_type
);
1671 if (! translate_to_native_sym_flags (abfd
, g
, &nsp
))
1674 H_PUT_8 (abfd
, 0, nsp
.e_ovly
);
1676 if (bfd_bwrite ((void *)&nsp
, (bfd_size_type
) EXTERNAL_NLIST_SIZE
, abfd
)
1677 != EXTERNAL_NLIST_SIZE
)
1680 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1681 here, at the end. */
1685 if (! emit_stringtab (abfd
, strtab
))
1688 _bfd_stringtab_free (strtab
);
1693 _bfd_stringtab_free (strtab
);
1699 NAME (aout
, canonicalize_symtab
) (bfd
*abfd
, asymbol
**location
)
1701 unsigned int counter
= 0;
1702 aout_symbol_type
*symbase
;
1704 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
1707 for (symbase
= obj_aout_symbols (abfd
); counter
++ < bfd_get_symcount (abfd
);)
1708 *(location
++) = (asymbol
*)(symbase
++);
1710 return bfd_get_symcount (abfd
);
1714 /* Output extended relocation information to a file in target byte order. */
1717 pdp11_aout_swap_reloc_out (bfd
*abfd
, arelent
*g
, bfd_byte
*natptr
)
1723 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1724 asection
*output_section
= sym
->section
->output_section
;
1727 fprintf (stderr
, "BFD: can't do this reloc addend stuff\n");
1729 r_pcrel
= g
->howto
->pc_relative
;
1731 if (bfd_is_abs_section (output_section
))
1733 else if (output_section
== obj_textsec (abfd
))
1735 else if (output_section
== obj_datasec (abfd
))
1737 else if (output_section
== obj_bsssec (abfd
))
1739 else if (bfd_is_und_section (output_section
))
1741 else if (bfd_is_com_section (output_section
))
1746 BFD_ASSERT (r_type
!= -1);
1751 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
1753 reloc_entry
= r_index
<< 4 | r_type
| r_pcrel
;
1755 PUT_WORD (abfd
, reloc_entry
, natptr
);
1758 /* BFD deals internally with all things based from the section they're
1759 in. so, something in 10 bytes into a text section with a base of
1760 50 would have a symbol (.text+10) and know .text vma was 50.
1762 Aout keeps all it's symbols based from zero, so the symbol would
1763 contain 60. This macro subs the base of each section from the value
1764 to give the true offset from the section */
1767 #define MOVE_ADDRESS(ad) \
1770 /* Undefined symbol. */ \
1771 cache_ptr->sym_ptr_ptr = symbols + r_index; \
1772 cache_ptr->addend = ad; \
1776 /* Defined, section relative. replace symbol with pointer to \
1777 symbol which points to section. */ \
1781 case N_TEXT | N_EXT: \
1782 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
1783 cache_ptr->addend = ad - su->textsec->vma; \
1786 case N_DATA | N_EXT: \
1787 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
1788 cache_ptr->addend = ad - su->datasec->vma; \
1791 case N_BSS | N_EXT: \
1792 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
1793 cache_ptr->addend = ad - su->bsssec->vma; \
1797 case N_ABS | N_EXT: \
1798 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1799 cache_ptr->addend = ad; \
1805 pdp11_aout_swap_reloc_in (bfd
* abfd
,
1807 arelent
* cache_ptr
,
1808 bfd_size_type offset
,
1810 bfd_size_type symcount
)
1812 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
1813 unsigned int r_index
;
1818 reloc_entry
= GET_WORD (abfd
, (void *) bytes
);
1820 r_pcrel
= reloc_entry
& RELFLG
;
1822 cache_ptr
->address
= offset
;
1823 cache_ptr
->howto
= howto_table_pdp11
+ (r_pcrel
? 1 : 0);
1825 if ((reloc_entry
& RTYPE
) == RABS
)
1828 r_index
= RINDEX (reloc_entry
);
1830 /* r_extern reflects whether the symbol the reloc is against is
1832 r_extern
= (reloc_entry
& RTYPE
) == REXT
;
1834 if (r_extern
&& r_index
> symcount
)
1836 /* We could arrange to return an error, but it might be useful
1837 to see the file even if it is bad. */
1845 /* Read and swap the relocs for a section. */
1848 NAME (aout
, slurp_reloc_table
) (bfd
*abfd
, sec_ptr asect
, asymbol
**symbols
)
1851 bfd_size_type count
;
1852 bfd_size_type reloc_size
;
1854 arelent
*reloc_cache
;
1856 unsigned int counter
= 0;
1859 if (asect
->relocation
)
1862 if (asect
->flags
& SEC_CONSTRUCTOR
)
1865 if (asect
== obj_datasec (abfd
))
1866 reloc_size
= exec_hdr(abfd
)->a_drsize
;
1867 else if (asect
== obj_textsec (abfd
))
1868 reloc_size
= exec_hdr(abfd
)->a_trsize
;
1869 else if (asect
== obj_bsssec (abfd
))
1873 bfd_set_error (bfd_error_invalid_operation
);
1877 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
1879 relocs
= _bfd_malloc_and_read (abfd
, reloc_size
, reloc_size
);
1880 if (relocs
== NULL
&& reloc_size
!= 0)
1883 each_size
= obj_reloc_entry_size (abfd
);
1884 count
= reloc_size
/ each_size
;
1886 /* Count the number of NON-ZERO relocs, this is the count we want. */
1888 unsigned int real_count
= 0;
1890 for (counter
= 0; counter
< count
; counter
++)
1894 x
= GET_WORD (abfd
, (char *) relocs
+ each_size
* counter
);
1902 reloc_cache
= bfd_zmalloc (count
* sizeof (arelent
));
1903 if (reloc_cache
== NULL
&& count
!= 0)
1906 cache_ptr
= reloc_cache
;
1911 counter
++, rptr
+= RELOC_SIZE
, cache_ptr
++)
1913 while (GET_WORD (abfd
, (void *) rptr
) == 0)
1916 if ((char *) rptr
>= (char *) relocs
+ reloc_size
)
1920 pdp11_aout_swap_reloc_in (abfd
, rptr
, cache_ptr
,
1921 (bfd_size_type
) ((char *) rptr
- (char *) relocs
),
1923 (bfd_size_type
) bfd_get_symcount (abfd
));
1926 /* Just in case, if rptr >= relocs + reloc_size should happen
1928 BFD_ASSERT (counter
== count
);
1932 asect
->relocation
= reloc_cache
;
1933 asect
->reloc_count
= cache_ptr
- reloc_cache
;
1938 /* Write out a relocation section into an object file. */
1941 NAME (aout
, squirt_out_relocs
) (bfd
*abfd
, asection
*section
)
1944 unsigned char *native
;
1945 unsigned int count
= section
->reloc_count
;
1946 bfd_size_type natsize
;
1948 natsize
= section
->size
;
1949 native
= bfd_zalloc (abfd
, natsize
);
1953 generic
= section
->orelocation
;
1954 if (generic
!= NULL
)
1960 r
= native
+ (*generic
)->address
;
1961 pdp11_aout_swap_reloc_out (abfd
, *generic
, r
);
1967 if (bfd_bwrite ((void *) native
, natsize
, abfd
) != natsize
)
1969 bfd_release (abfd
, native
);
1973 bfd_release (abfd
, native
);
1977 /* This is stupid. This function should be a boolean predicate. */
1980 NAME (aout
, canonicalize_reloc
) (bfd
*abfd
,
1985 arelent
*tblptr
= section
->relocation
;
1988 if (section
== obj_bsssec (abfd
))
1994 if (!(tblptr
|| NAME (aout
, slurp_reloc_table
)(abfd
, section
, symbols
)))
1997 if (section
->flags
& SEC_CONSTRUCTOR
)
1999 arelent_chain
*chain
= section
->constructor_chain
;
2001 for (count
= 0; count
< section
->reloc_count
; count
++)
2003 *relptr
++ = &chain
->relent
;
2004 chain
= chain
->next
;
2009 tblptr
= section
->relocation
;
2011 for (count
= 0; count
++ < section
->reloc_count
;)
2012 *relptr
++ = tblptr
++;
2017 return section
->reloc_count
;
2021 NAME (aout
, get_reloc_upper_bound
) (bfd
*abfd
, sec_ptr asect
)
2023 bfd_size_type count
;
2025 if (bfd_get_format (abfd
) != bfd_object
)
2027 bfd_set_error (bfd_error_invalid_operation
);
2031 if (asect
->flags
& SEC_CONSTRUCTOR
)
2032 count
= asect
->reloc_count
;
2033 else if (asect
== obj_datasec (abfd
))
2034 count
= exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
2035 else if (asect
== obj_textsec (abfd
))
2036 count
= exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
2037 else if (asect
== obj_bsssec (abfd
))
2041 bfd_set_error (bfd_error_invalid_operation
);
2045 if (count
>= LONG_MAX
/ sizeof (arelent
*))
2047 bfd_set_error (bfd_error_file_too_big
);
2050 return (count
+ 1) * sizeof (arelent
*);
2055 NAME (aout
, get_symtab_upper_bound
) (bfd
*abfd
)
2057 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
2060 return (bfd_get_symcount (abfd
) + 1) * (sizeof (aout_symbol_type
*));
2064 NAME (aout
, get_lineno
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2065 asymbol
* symbol ATTRIBUTE_UNUSED
)
2071 NAME (aout
, get_symbol_info
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2075 bfd_symbol_info (symbol
, ret
);
2077 if (ret
->type
== '?')
2079 int type_code
= aout_symbol(symbol
)->type
& 0xff;
2080 const char *stab_name
= bfd_get_stab_name (type_code
);
2081 static char buf
[10];
2083 if (stab_name
== NULL
)
2085 sprintf(buf
, "(%d)", type_code
);
2089 ret
->stab_type
= type_code
;
2090 ret
->stab_other
= (unsigned) (aout_symbol(symbol
)->other
& 0xff);
2091 ret
->stab_desc
= (unsigned) (aout_symbol(symbol
)->desc
& 0xffff);
2092 ret
->stab_name
= stab_name
;
2097 NAME (aout
, print_symbol
) (bfd
* abfd
,
2100 bfd_print_symbol_type how
)
2102 FILE *file
= (FILE *) afile
;
2106 case bfd_print_symbol_name
:
2108 fprintf(file
,"%s", symbol
->name
);
2110 case bfd_print_symbol_more
:
2111 fprintf(file
,"%4x %2x %2x",
2112 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2113 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2114 (unsigned) (aout_symbol (symbol
)->type
));
2116 case bfd_print_symbol_all
:
2118 const char *section_name
= symbol
->section
->name
;
2120 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2122 fprintf (file
," %-5s %04x %02x %02x",
2124 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2125 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2126 (unsigned) (aout_symbol (symbol
)->type
& 0xff));
2128 fprintf(file
," %s", symbol
->name
);
2134 /* If we don't have to allocate more than 1MB to hold the generic
2135 symbols, we use the generic minisymbol method: it's faster, since
2136 it only translates the symbols once, not multiple times. */
2137 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2139 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2140 symbols. The minisymbol_to_symbol function translates these into
2141 BFD asymbol structures. */
2144 NAME (aout
, read_minisymbols
) (bfd
*abfd
,
2145 bfd_boolean dynamic
,
2147 unsigned int *sizep
)
2150 /* We could handle the dynamic symbols here as well, but it's
2151 easier to hand them off. */
2152 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2154 if (! aout_get_external_symbols (abfd
))
2157 if (obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2158 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2160 *minisymsp
= (void *) obj_aout_external_syms (abfd
);
2162 /* By passing the external symbols back from this routine, we are
2163 giving up control over the memory block. Clear
2164 obj_aout_external_syms, so that we do not try to free it
2166 obj_aout_external_syms (abfd
) = NULL
;
2168 *sizep
= EXTERNAL_NLIST_SIZE
;
2169 return obj_aout_external_sym_count (abfd
);
2172 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2173 unmodified a.out symbol. The SYM argument is a structure returned
2174 by bfd_make_empty_symbol, which we fill in here. */
2177 NAME (aout
, minisymbol_to_symbol
) (bfd
*abfd
,
2178 bfd_boolean dynamic
,
2179 const void * minisym
,
2183 || obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2184 return _bfd_generic_minisymbol_to_symbol (abfd
, dynamic
, minisym
, sym
);
2186 memset (sym
, 0, sizeof (aout_symbol_type
));
2188 /* We call translate_symbol_table to translate a single symbol. */
2189 if (! (NAME (aout
, translate_symbol_table
)
2191 (aout_symbol_type
*) sym
,
2192 (struct external_nlist
*) minisym
,
2194 obj_aout_external_strings (abfd
),
2195 obj_aout_external_string_size (abfd
),
2202 /* Provided a BFD, a section and an offset into the section, calculate
2203 and return the name of the source file and the line nearest to the
2207 NAME (aout
, find_nearest_line
) (bfd
*abfd
,
2211 const char **filename_ptr
,
2212 const char **functionname_ptr
,
2213 unsigned int *line_ptr
,
2214 unsigned int *discriminator_ptr
)
2216 /* Run down the file looking for the filename, function and linenumber. */
2218 const char *directory_name
= NULL
;
2219 const char *main_file_name
= NULL
;
2220 const char *current_file_name
= NULL
;
2221 const char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2222 bfd_vma low_line_vma
= 0;
2223 bfd_vma low_func_vma
= 0;
2225 size_t filelen
, funclen
;
2228 *filename_ptr
= abfd
->filename
;
2229 *functionname_ptr
= 0;
2231 if (discriminator_ptr
)
2232 *discriminator_ptr
= 0;
2234 if (symbols
!= NULL
)
2236 for (p
= symbols
; *p
; p
++)
2238 aout_symbol_type
*q
= (aout_symbol_type
*)(*p
);
2243 /* If this looks like a file name symbol, and it comes after
2244 the line number we have found so far, but before the
2245 offset, then we have probably not found the right line
2247 if (q
->symbol
.value
<= offset
2248 && ((q
->symbol
.value
> low_line_vma
2249 && (line_file_name
!= NULL
2251 || (q
->symbol
.value
> low_func_vma
2254 const char * symname
;
2256 symname
= q
->symbol
.name
;
2257 if (strcmp (symname
+ strlen (symname
) - 2, ".o") == 0)
2259 if (q
->symbol
.value
> low_line_vma
)
2262 line_file_name
= NULL
;
2264 if (q
->symbol
.value
> low_func_vma
)
2271 /* If this symbol is less than the offset, but greater than
2272 the line number we have found so far, then we have not
2273 found the right line number. */
2274 if (q
->symbol
.value
<= offset
)
2276 if (q
->symbol
.value
> low_line_vma
)
2279 line_file_name
= NULL
;
2281 if (q
->symbol
.value
> low_func_vma
)
2285 main_file_name
= current_file_name
= q
->symbol
.name
;
2286 /* Look ahead to next symbol to check if that too is an N_SO. */
2290 q
= (aout_symbol_type
*)(*p
);
2291 if (q
->type
!= (int) N_SO
)
2294 /* Found a second N_SO First is directory; second is filename. */
2295 directory_name
= current_file_name
;
2296 main_file_name
= current_file_name
= q
->symbol
.name
;
2297 if (obj_textsec(abfd
) != section
)
2301 current_file_name
= q
->symbol
.name
;
2307 /* We'll keep this if it resolves nearer than the one we have
2309 if (q
->symbol
.value
>= low_line_vma
2310 && q
->symbol
.value
<= offset
)
2312 *line_ptr
= q
->desc
;
2313 low_line_vma
= q
->symbol
.value
;
2314 line_file_name
= current_file_name
;
2320 /* We'll keep this if it is nearer than the one we have already. */
2321 if (q
->symbol
.value
>= low_func_vma
&&
2322 q
->symbol
.value
<= offset
)
2324 low_func_vma
= q
->symbol
.value
;
2325 func
= (asymbol
*) q
;
2327 else if (q
->symbol
.value
> offset
)
2337 main_file_name
= line_file_name
;
2339 if (main_file_name
== NULL
2340 || main_file_name
[0] == '/'
2341 || directory_name
== NULL
)
2344 filelen
= strlen (directory_name
) + strlen (main_file_name
);
2348 funclen
= strlen (bfd_asymbol_name (func
));
2350 if (adata (abfd
).line_buf
!= NULL
)
2351 free (adata (abfd
).line_buf
);
2352 if (filelen
+ funclen
== 0)
2353 adata (abfd
).line_buf
= buf
= NULL
;
2356 buf
= bfd_malloc ((bfd_size_type
) filelen
+ funclen
+ 3);
2357 adata (abfd
).line_buf
= buf
;
2362 if (main_file_name
!= NULL
)
2364 if (main_file_name
[0] == '/' || directory_name
== NULL
)
2365 *filename_ptr
= main_file_name
;
2368 sprintf (buf
, "%s%s", directory_name
, main_file_name
);
2369 *filename_ptr
= buf
;
2376 const char *function
= func
->name
;
2379 /* The caller expects a symbol name. We actually have a
2380 function name, without the leading underscore. Put the
2381 underscore back in, so that the caller gets a symbol name. */
2382 if (bfd_get_symbol_leading_char (abfd
) == '\0')
2383 strcpy (buf
, function
);
2386 buf
[0] = bfd_get_symbol_leading_char (abfd
);
2387 strcpy (buf
+ 1, function
);
2390 /* Have to remove : stuff. */
2391 colon
= strchr (buf
, ':');
2394 *functionname_ptr
= buf
;
2401 NAME (aout
, sizeof_headers
) (bfd
*abfd
,
2402 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2404 return adata (abfd
).exec_bytes_size
;
2407 /* Free all information we have cached for this BFD. We can always
2408 read it again later if we need it. */
2411 NAME (aout
, bfd_free_cached_info
) (bfd
*abfd
)
2415 if (bfd_get_format (abfd
) != bfd_object
)
2418 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2419 BFCI_FREE (obj_aout_symbols (abfd
));
2422 obj_aout_external_syms (abfd
) = 0;
2423 bfd_free_window (&obj_aout_sym_window (abfd
));
2424 bfd_free_window (&obj_aout_string_window (abfd
));
2425 obj_aout_external_strings (abfd
) = 0;
2427 BFCI_FREE (obj_aout_external_syms (abfd
));
2428 BFCI_FREE (obj_aout_external_strings (abfd
));
2430 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2431 BFCI_FREE (o
->relocation
);
2437 /* Routine to create an entry in an a.out link hash table. */
2439 struct bfd_hash_entry
*
2440 NAME (aout
, link_hash_newfunc
) (struct bfd_hash_entry
*entry
,
2441 struct bfd_hash_table
*table
,
2444 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2446 /* Allocate the structure if it has not already been allocated by a
2449 ret
= bfd_hash_allocate (table
, sizeof (* ret
));
2453 /* Call the allocation method of the superclass. */
2454 ret
= (struct aout_link_hash_entry
*)
2455 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
);
2458 /* Set local fields. */
2459 ret
->written
= FALSE
;
2463 return (struct bfd_hash_entry
*) ret
;
2466 /* Initialize an a.out link hash table. */
2469 NAME (aout
, link_hash_table_init
) (struct aout_link_hash_table
*table
,
2471 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
2472 struct bfd_hash_table
*,
2474 unsigned int entsize
)
2476 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
2479 /* Create an a.out link hash table. */
2481 struct bfd_link_hash_table
*
2482 NAME (aout
, link_hash_table_create
) (bfd
*abfd
)
2484 struct aout_link_hash_table
*ret
;
2485 size_t amt
= sizeof (struct aout_link_hash_table
);
2487 ret
= bfd_malloc (amt
);
2490 if (! NAME (aout
, link_hash_table_init
) (ret
, abfd
,
2491 NAME (aout
, link_hash_newfunc
),
2492 sizeof (struct aout_link_hash_entry
)))
2500 /* Free up the internal symbols read from an a.out file. */
2503 aout_link_free_symbols (bfd
*abfd
)
2505 if (obj_aout_external_syms (abfd
) != NULL
)
2508 bfd_free_window (&obj_aout_sym_window (abfd
));
2510 free ((void *) obj_aout_external_syms (abfd
));
2512 obj_aout_external_syms (abfd
) = NULL
;
2515 if (obj_aout_external_strings (abfd
) != NULL
)
2518 bfd_free_window (&obj_aout_string_window (abfd
));
2520 free ((void *) obj_aout_external_strings (abfd
));
2522 obj_aout_external_strings (abfd
) = NULL
;
2527 /* Given an a.out BFD, add symbols to the global hash table as
2531 NAME (aout
, link_add_symbols
) (bfd
*abfd
, struct bfd_link_info
*info
)
2533 switch (bfd_get_format (abfd
))
2536 return aout_link_add_object_symbols (abfd
, info
);
2538 return _bfd_generic_link_add_archive_symbols
2539 (abfd
, info
, aout_link_check_archive_element
);
2541 bfd_set_error (bfd_error_wrong_format
);
2546 /* Add symbols from an a.out object file. */
2549 aout_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2551 if (! aout_get_external_symbols (abfd
))
2553 if (! aout_link_add_symbols (abfd
, info
))
2555 if (! info
->keep_memory
)
2557 if (! aout_link_free_symbols (abfd
))
2563 /* Look through the internal symbols to see if this object file should
2564 be included in the link. We should include this object file if it
2565 defines any symbols which are currently undefined. If this object
2566 file defines a common symbol, then we may adjust the size of the
2567 known symbol but we do not include the object file in the link
2568 (unless there is some other reason to include it). */
2571 aout_link_check_ar_symbols (bfd
*abfd
,
2572 struct bfd_link_info
*info
,
2573 bfd_boolean
*pneeded
,
2576 struct external_nlist
*p
;
2577 struct external_nlist
*pend
;
2582 /* Look through all the symbols. */
2583 p
= obj_aout_external_syms (abfd
);
2584 pend
= p
+ obj_aout_external_sym_count (abfd
);
2585 strings
= obj_aout_external_strings (abfd
);
2586 for (; p
< pend
; p
++)
2588 int type
= H_GET_8 (abfd
, p
->e_type
);
2590 struct bfd_link_hash_entry
*h
;
2592 /* Ignore symbols that are not externally visible. This is an
2593 optimization only, as we check the type more thoroughly
2595 if ((type
& N_EXT
) == 0
2599 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2600 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
2602 /* We are only interested in symbols that are currently
2603 undefined or common. */
2605 || (h
->type
!= bfd_link_hash_undefined
2606 && h
->type
!= bfd_link_hash_common
))
2609 if (type
== (N_TEXT
| N_EXT
)
2610 || type
== (N_DATA
| N_EXT
)
2611 || type
== (N_BSS
| N_EXT
)
2612 || type
== (N_ABS
| N_EXT
))
2614 /* This object file defines this symbol. We must link it
2615 in. This is true regardless of whether the current
2616 definition of the symbol is undefined or common. If the
2617 current definition is common, we have a case in which we
2618 have already seen an object file including
2620 and this object file from the archive includes
2622 In such a case we must include this object file.
2624 FIXME: The SunOS 4.1.3 linker will pull in the archive
2625 element if the symbol is defined in the .data section,
2626 but not if it is defined in the .text section. That
2627 seems a bit crazy to me, and I haven't implemented it.
2628 However, it might be correct. */
2629 if (!(*info
->callbacks
2630 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2636 if (type
== (N_UNDF
| N_EXT
))
2640 value
= GET_WORD (abfd
, p
->e_value
);
2643 /* This symbol is common in the object from the archive
2645 if (h
->type
== bfd_link_hash_undefined
)
2650 symbfd
= h
->u
.undef
.abfd
;
2653 /* This symbol was created as undefined from
2654 outside BFD. We assume that we should link
2655 in the object file. This is done for the -u
2656 option in the linker. */
2657 if (!(*info
->callbacks
2658 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2663 /* Turn the current link symbol into a common
2664 symbol. It is already on the undefs list. */
2665 h
->type
= bfd_link_hash_common
;
2666 h
->u
.c
.p
= bfd_hash_allocate (&info
->hash
->table
,
2667 sizeof (struct bfd_link_hash_common_entry
));
2668 if (h
->u
.c
.p
== NULL
)
2671 h
->u
.c
.size
= value
;
2673 /* FIXME: This isn't quite right. The maximum
2674 alignment of a common symbol should be set by the
2675 architecture of the output file, not of the input
2677 power
= bfd_log2 (value
);
2678 if (power
> bfd_get_arch_info (abfd
)->section_align_power
)
2679 power
= bfd_get_arch_info (abfd
)->section_align_power
;
2680 h
->u
.c
.p
->alignment_power
= power
;
2682 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
,
2687 /* Adjust the size of the common symbol if
2689 if (value
> h
->u
.c
.size
)
2690 h
->u
.c
.size
= value
;
2696 /* We do not need this object file. */
2700 /* Check a single archive element to see if we need to include it in
2701 the link. *PNEEDED is set according to whether this element is
2702 needed in the link or not. This is called from
2703 _bfd_generic_link_add_archive_symbols. */
2706 aout_link_check_archive_element (bfd
*abfd
,
2707 struct bfd_link_info
*info
,
2708 struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
2709 const char *name ATTRIBUTE_UNUSED
,
2710 bfd_boolean
*pneeded
)
2715 if (!aout_get_external_symbols (abfd
))
2719 if (!aout_link_check_ar_symbols (abfd
, info
, pneeded
, &abfd
))
2725 /* Potentially, the add_archive_element hook may have set a
2726 substitute BFD for us. */
2729 if (!info
->keep_memory
2730 && !aout_link_free_symbols (oldbfd
))
2732 if (!aout_get_external_symbols (abfd
))
2735 if (!aout_link_add_symbols (abfd
, info
))
2739 if (!info
->keep_memory
|| !needed
)
2741 if (!aout_link_free_symbols (abfd
))
2748 /* Add all symbols from an object file to the hash table. */
2751 aout_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2753 bfd_boolean (*add_one_symbol
)
2754 (struct bfd_link_info
*, bfd
*, const char *, flagword
, asection
*,
2755 bfd_vma
, const char *, bfd_boolean
, bfd_boolean
,
2756 struct bfd_link_hash_entry
**);
2757 struct external_nlist
*syms
;
2758 bfd_size_type sym_count
;
2761 struct aout_link_hash_entry
**sym_hash
;
2762 struct external_nlist
*p
;
2763 struct external_nlist
*pend
;
2765 syms
= obj_aout_external_syms (abfd
);
2766 sym_count
= obj_aout_external_sym_count (abfd
);
2767 strings
= obj_aout_external_strings (abfd
);
2768 if (info
->keep_memory
)
2773 if (aout_backend_info (abfd
)->add_dynamic_symbols
!= NULL
)
2775 if (! ((*aout_backend_info (abfd
)->add_dynamic_symbols
)
2776 (abfd
, info
, &syms
, &sym_count
, &strings
)))
2780 /* We keep a list of the linker hash table entries that correspond
2781 to particular symbols. We could just look them up in the hash
2782 table, but keeping the list is more efficient. Perhaps this
2783 should be conditional on info->keep_memory. */
2784 sym_hash
= bfd_alloc (abfd
,
2785 sym_count
* sizeof (struct aout_link_hash_entry
*));
2786 if (sym_hash
== NULL
&& sym_count
!= 0)
2788 obj_aout_sym_hashes (abfd
) = sym_hash
;
2790 add_one_symbol
= aout_backend_info (abfd
)->add_one_symbol
;
2791 if (add_one_symbol
== NULL
)
2792 add_one_symbol
= _bfd_generic_link_add_one_symbol
;
2795 pend
= p
+ sym_count
;
2796 for (; p
< pend
; p
++, sym_hash
++)
2807 type
= H_GET_8 (abfd
, p
->e_type
);
2809 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2810 value
= GET_WORD (abfd
, p
->e_value
);
2816 /* Anything else should be a debugging symbol. */
2817 BFD_ASSERT ((type
& N_STAB
) != 0);
2827 /* Ignore symbols that are not externally visible. */
2830 case N_UNDF
| N_EXT
:
2833 section
= bfd_und_section_ptr
;
2837 section
= bfd_com_section_ptr
;
2840 section
= bfd_abs_section_ptr
;
2842 case N_TEXT
| N_EXT
:
2843 section
= obj_textsec (abfd
);
2844 value
-= bfd_section_vma (section
);
2846 case N_DATA
| N_EXT
:
2847 /* Treat N_SETV symbols as N_DATA symbol; see comment in
2848 translate_from_native_sym_flags. */
2849 section
= obj_datasec (abfd
);
2850 value
-= bfd_section_vma (section
);
2853 section
= obj_bsssec (abfd
);
2854 value
-= bfd_section_vma (section
);
2858 if (! ((*add_one_symbol
)
2859 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, FALSE
,
2860 (struct bfd_link_hash_entry
**) sym_hash
)))
2863 /* Restrict the maximum alignment of a common symbol based on
2864 the architecture, since a.out has no way to represent
2865 alignment requirements of a section in a .o file. FIXME:
2866 This isn't quite right: it should use the architecture of the
2867 output file, not the input files. */
2868 if ((*sym_hash
)->root
.type
== bfd_link_hash_common
2869 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
>
2870 bfd_get_arch_info (abfd
)->section_align_power
))
2871 (*sym_hash
)->root
.u
.c
.p
->alignment_power
=
2872 bfd_get_arch_info (abfd
)->section_align_power
;
2874 /* If this is a set symbol, and we are not building sets, then
2875 it is possible for the hash entry to not have been set. In
2876 such a case, treat the symbol as not globally defined. */
2877 if ((*sym_hash
)->root
.type
== bfd_link_hash_new
)
2879 BFD_ASSERT ((flags
& BSF_CONSTRUCTOR
) != 0);
2887 /* Look up an entry in an the header file hash table. */
2889 #define aout_link_includes_lookup(table, string, create, copy) \
2890 ((struct aout_link_includes_entry *) \
2891 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
2893 /* The function to create a new entry in the header file hash table. */
2895 static struct bfd_hash_entry
*
2896 aout_link_includes_newfunc (struct bfd_hash_entry
*entry
,
2897 struct bfd_hash_table
*table
,
2900 struct aout_link_includes_entry
* ret
=
2901 (struct aout_link_includes_entry
*) entry
;
2903 /* Allocate the structure if it has not already been allocated by a
2906 ret
= bfd_hash_allocate (table
,
2907 sizeof (struct aout_link_includes_entry
));
2911 /* Call the allocation method of the superclass. */
2912 ret
= ((struct aout_link_includes_entry
*)
2913 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
2915 /* Set local fields. */
2918 return (struct bfd_hash_entry
*) ret
;
2922 aout_link_write_other_symbol (struct bfd_hash_entry
*bh
, void *data
)
2924 struct aout_link_hash_entry
*h
= (struct aout_link_hash_entry
*) bh
;
2925 struct aout_final_link_info
*flaginfo
= (struct aout_final_link_info
*) data
;
2929 struct external_nlist outsym
;
2933 if (h
->root
.type
== bfd_link_hash_warning
)
2935 h
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
2936 if (h
->root
.type
== bfd_link_hash_new
)
2940 output_bfd
= flaginfo
->output_bfd
;
2942 if (aout_backend_info (output_bfd
)->write_dynamic_symbol
!= NULL
)
2944 if (! ((*aout_backend_info (output_bfd
)->write_dynamic_symbol
)
2945 (output_bfd
, flaginfo
->info
, h
)))
2947 /* FIXME: No way to handle errors. */
2957 /* An indx of -2 means the symbol must be written. */
2959 && (flaginfo
->info
->strip
== strip_all
2960 || (flaginfo
->info
->strip
== strip_some
2961 && bfd_hash_lookup (flaginfo
->info
->keep_hash
, h
->root
.root
.string
,
2962 FALSE
, FALSE
) == NULL
)))
2965 switch (h
->root
.type
)
2969 /* Avoid variable not initialized warnings. */
2971 case bfd_link_hash_new
:
2972 /* This can happen for set symbols when sets are not being
2975 case bfd_link_hash_undefined
:
2976 type
= N_UNDF
| N_EXT
;
2979 case bfd_link_hash_defined
:
2980 case bfd_link_hash_defweak
:
2984 sec
= h
->root
.u
.def
.section
->output_section
;
2985 BFD_ASSERT (bfd_is_abs_section (sec
)
2986 || sec
->owner
== output_bfd
);
2987 if (sec
== obj_textsec (output_bfd
))
2988 type
= h
->root
.type
== bfd_link_hash_defined
? N_TEXT
: N_WEAKT
;
2989 else if (sec
== obj_datasec (output_bfd
))
2990 type
= h
->root
.type
== bfd_link_hash_defined
? N_DATA
: N_WEAKD
;
2991 else if (sec
== obj_bsssec (output_bfd
))
2992 type
= h
->root
.type
== bfd_link_hash_defined
? N_BSS
: N_WEAKB
;
2994 type
= h
->root
.type
== bfd_link_hash_defined
? N_ABS
: N_WEAKA
;
2996 val
= (h
->root
.u
.def
.value
2998 + h
->root
.u
.def
.section
->output_offset
);
3001 case bfd_link_hash_common
:
3002 type
= N_UNDF
| N_EXT
;
3003 val
= h
->root
.u
.c
.size
;
3005 case bfd_link_hash_undefweak
:
3009 case bfd_link_hash_indirect
:
3010 case bfd_link_hash_warning
:
3011 /* FIXME: Ignore these for now. The circumstances under which
3012 they should be written out are not clear to me. */
3016 H_PUT_8 (output_bfd
, type
, outsym
.e_type
);
3017 indx
= add_to_stringtab (output_bfd
, flaginfo
->strtab
, h
->root
.root
.string
,
3019 if (indx
== (bfd_size_type
) -1)
3020 /* FIXME: No way to handle errors. */
3023 PUT_WORD (output_bfd
, indx
, outsym
.e_strx
);
3024 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
3026 amt
= EXTERNAL_NLIST_SIZE
;
3027 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0
3028 || bfd_bwrite ((void *) &outsym
, amt
, output_bfd
) != amt
)
3029 /* FIXME: No way to handle errors. */
3032 flaginfo
->symoff
+= amt
;
3033 h
->indx
= obj_aout_external_sym_count (output_bfd
);
3034 ++obj_aout_external_sym_count (output_bfd
);
3039 /* Handle a link order which is supposed to generate a reloc. */
3042 aout_link_reloc_link_order (struct aout_final_link_info
*flaginfo
,
3044 struct bfd_link_order
*p
)
3046 struct bfd_link_order_reloc
*pr
;
3049 reloc_howto_type
*howto
;
3050 file_ptr
*reloff_ptr
;
3051 struct reloc_std_external srel
;
3053 bfd_size_type rel_size
;
3057 if (p
->type
== bfd_section_reloc_link_order
)
3060 if (bfd_is_abs_section (pr
->u
.section
))
3061 r_index
= N_ABS
| N_EXT
;
3064 BFD_ASSERT (pr
->u
.section
->owner
== flaginfo
->output_bfd
);
3065 r_index
= pr
->u
.section
->target_index
;
3070 struct aout_link_hash_entry
*h
;
3072 BFD_ASSERT (p
->type
== bfd_symbol_reloc_link_order
);
3074 h
= ((struct aout_link_hash_entry
*)
3075 bfd_wrapped_link_hash_lookup (flaginfo
->output_bfd
, flaginfo
->info
,
3076 pr
->u
.name
, FALSE
, FALSE
, TRUE
));
3082 /* We decided to strip this symbol, but it turns out that we
3083 can't. Note that we lose the other and desc information
3084 here. I don't think that will ever matter for a global
3088 if (!aout_link_write_other_symbol (&h
->root
.root
, flaginfo
))
3094 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3095 (flaginfo
->info
, pr
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
3100 howto
= bfd_reloc_type_lookup (flaginfo
->output_bfd
, pr
->reloc
);
3103 bfd_set_error (bfd_error_bad_value
);
3107 if (o
== obj_textsec (flaginfo
->output_bfd
))
3108 reloff_ptr
= &flaginfo
->treloff
;
3109 else if (o
== obj_datasec (flaginfo
->output_bfd
))
3110 reloff_ptr
= &flaginfo
->dreloff
;
3115 MY_put_reloc(flaginfo
->output_bfd
, r_extern
, r_index
, p
->offset
, howto
,
3125 fprintf (stderr
, "TODO: line %d in bfd/pdp11.c\n", __LINE__
);
3127 r_pcrel
= howto
->pc_relative
;
3128 r_baserel
= (howto
->type
& 8) != 0;
3129 r_jmptable
= (howto
->type
& 16) != 0;
3130 r_relative
= (howto
->type
& 32) != 0;
3131 r_length
= howto
->size
;
3133 PUT_WORD (flaginfo
->output_bfd
, p
->offset
, srel
.r_address
);
3134 if (bfd_header_big_endian (flaginfo
->output_bfd
))
3136 srel
.r_index
[0] = r_index
>> 16;
3137 srel
.r_index
[1] = r_index
>> 8;
3138 srel
.r_index
[2] = r_index
;
3140 ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
3141 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
3142 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
3143 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
3144 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
3145 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
3149 srel
.r_index
[2] = r_index
>> 16;
3150 srel
.r_index
[1] = r_index
>> 8;
3151 srel
.r_index
[0] = r_index
;
3153 ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
3154 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
3155 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
3156 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
3157 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
3158 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
3162 rel_ptr
= (void *) &srel
;
3164 /* We have to write the addend into the object file, since
3165 standard a.out relocs are in place. It would be more
3166 reliable if we had the current contents of the file here,
3167 rather than assuming zeroes, but we can't read the file since
3168 it was opened using bfd_openw. */
3169 if (pr
->addend
!= 0)
3172 bfd_reloc_status_type r
;
3176 size
= bfd_get_reloc_size (howto
);
3177 buf
= bfd_zmalloc (size
);
3178 if (buf
== NULL
&& size
!= 0)
3180 r
= MY_relocate_contents (howto
, flaginfo
->output_bfd
,
3187 case bfd_reloc_outofrange
:
3189 case bfd_reloc_overflow
:
3190 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3191 (flaginfo
->info
, NULL
,
3192 (p
->type
== bfd_section_reloc_link_order
3193 ? bfd_section_name (pr
->u
.section
)
3195 howto
->name
, pr
->addend
, NULL
,
3196 (asection
*) NULL
, (bfd_vma
) 0);
3199 ok
= bfd_set_section_contents (flaginfo
->output_bfd
, o
,
3201 (file_ptr
) p
->offset
,
3208 rel_size
= obj_reloc_entry_size (flaginfo
->output_bfd
);
3209 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0
3210 || bfd_bwrite (rel_ptr
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3213 *reloff_ptr
+= rel_size
;
3215 /* Assert that the relocs have not run into the symbols, and that n
3216 the text relocs have not run into the data relocs. */
3217 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3218 && (reloff_ptr
!= &flaginfo
->treloff
3220 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3225 /* Get the section corresponding to a reloc index. */
3227 static inline asection
*
3228 aout_reloc_type_to_section (bfd
*abfd
, int type
)
3232 case RTEXT
: return obj_textsec (abfd
);
3233 case RDATA
: return obj_datasec (abfd
);
3234 case RBSS
: return obj_bsssec (abfd
);
3235 case RABS
: return bfd_abs_section_ptr
;
3236 case REXT
: return bfd_und_section_ptr
;
3242 pdp11_aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3244 asection
*input_section
,
3246 bfd_size_type rel_size
,
3249 bfd_boolean (*check_dynamic_reloc
)
3250 (struct bfd_link_info
*, bfd
*, asection
*,
3251 struct aout_link_hash_entry
*, void *, bfd_byte
*, bfd_boolean
*,
3254 bfd_boolean relocatable
;
3255 struct external_nlist
*syms
;
3257 struct aout_link_hash_entry
**sym_hashes
;
3262 output_bfd
= flaginfo
->output_bfd
;
3263 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
3265 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_SIZE
);
3266 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
3267 == output_bfd
->xvec
->header_byteorder
);
3269 relocatable
= bfd_link_relocatable (flaginfo
->info
);
3270 syms
= obj_aout_external_syms (input_bfd
);
3271 strings
= obj_aout_external_strings (input_bfd
);
3272 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
3273 symbol_map
= flaginfo
->symbol_map
;
3276 rel_end
= rel
+ rel_size
;
3277 for (; rel
< rel_end
; rel
+= RELOC_SIZE
)
3284 reloc_howto_type
*howto
;
3285 struct aout_link_hash_entry
*h
= NULL
;
3287 bfd_reloc_status_type r
;
3290 reloc_entry
= GET_WORD (input_bfd
, (void *) rel
);
3291 if (reloc_entry
== 0)
3295 unsigned int howto_idx
;
3297 r_index
= (reloc_entry
& RIDXMASK
) >> 4;
3298 r_type
= reloc_entry
& RTYPE
;
3299 r_pcrel
= reloc_entry
& RELFLG
;
3300 r_addr
= (char *) rel
- (char *) relocs
;
3302 r_extern
= (r_type
== REXT
);
3304 howto_idx
= r_pcrel
;
3305 BFD_ASSERT (howto_idx
< TABLE_SIZE (howto_table_pdp11
));
3306 howto
= howto_table_pdp11
+ howto_idx
;
3311 /* We are generating a relocatable output file, and must
3312 modify the reloc accordingly. */
3315 /* If we know the symbol this relocation is against,
3316 convert it into a relocation against a section. This
3317 is what the native linker does. */
3318 h
= sym_hashes
[r_index
];
3320 && (h
->root
.type
== bfd_link_hash_defined
3321 || h
->root
.type
== bfd_link_hash_defweak
))
3323 asection
*output_section
;
3325 /* Compute a new r_index. */
3326 output_section
= h
->root
.u
.def
.section
->output_section
;
3327 if (output_section
== obj_textsec (output_bfd
))
3329 else if (output_section
== obj_datasec (output_bfd
))
3331 else if (output_section
== obj_bsssec (output_bfd
))
3336 /* Add the symbol value and the section VMA to the
3337 addend stored in the contents. */
3338 relocation
= (h
->root
.u
.def
.value
3339 + output_section
->vma
3340 + h
->root
.u
.def
.section
->output_offset
);
3344 /* We must change r_index according to the symbol
3346 r_index
= symbol_map
[r_index
];
3352 /* We decided to strip this symbol, but it
3353 turns out that we can't. Note that we
3354 lose the other and desc information here.
3355 I don't think that will ever matter for a
3361 if (!aout_link_write_other_symbol (&h
->root
.root
,
3371 name
= strings
+ GET_WORD (input_bfd
,
3372 syms
[r_index
].e_strx
);
3373 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3374 (flaginfo
->info
, name
, input_bfd
, input_section
,
3383 /* Write out the new r_index value. */
3384 reloc_entry
= GET_WORD (input_bfd
, rel
);
3385 reloc_entry
&= RIDXMASK
;
3386 reloc_entry
|= r_index
<< 4;
3387 PUT_WORD (input_bfd
, reloc_entry
, rel
);
3393 /* This is a relocation against a section. We must
3394 adjust by the amount that the section moved. */
3395 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3396 relocation
= (section
->output_section
->vma
3397 + section
->output_offset
3401 /* Change the address of the relocation. */
3402 fprintf (stderr
, "TODO: change the address of the relocation\n");
3404 /* Adjust a PC relative relocation by removing the reference
3405 to the original address in the section and including the
3406 reference to the new address. */
3408 relocation
-= (input_section
->output_section
->vma
3409 + input_section
->output_offset
3410 - input_section
->vma
);
3412 #ifdef MY_relocatable_reloc
3413 MY_relocatable_reloc (howto
, output_bfd
, rel
, relocation
, r_addr
);
3416 if (relocation
== 0)
3419 r
= MY_relocate_contents (howto
,
3420 input_bfd
, relocation
,
3427 /* We are generating an executable, and must do a full
3432 h
= sym_hashes
[r_index
];
3435 && (h
->root
.type
== bfd_link_hash_defined
3436 || h
->root
.type
== bfd_link_hash_defweak
))
3438 relocation
= (h
->root
.u
.def
.value
3439 + h
->root
.u
.def
.section
->output_section
->vma
3440 + h
->root
.u
.def
.section
->output_offset
);
3443 && h
->root
.type
== bfd_link_hash_undefweak
)
3455 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3456 relocation
= (section
->output_section
->vma
3457 + section
->output_offset
3460 relocation
+= input_section
->vma
;
3463 if (check_dynamic_reloc
!= NULL
)
3467 if (! ((*check_dynamic_reloc
)
3468 (flaginfo
->info
, input_bfd
, input_section
, h
,
3469 (void *) rel
, contents
, &skip
, &relocation
)))
3475 /* Now warn if a global symbol is undefined. We could not
3476 do this earlier, because check_dynamic_reloc might want
3477 to skip this reloc. */
3478 if (hundef
&& ! bfd_link_pic (flaginfo
->info
))
3483 name
= h
->root
.root
.string
;
3485 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
3486 (*flaginfo
->info
->callbacks
->undefined_symbol
)
3487 (flaginfo
->info
, name
, input_bfd
, input_section
,
3491 r
= MY_final_link_relocate (howto
,
3492 input_bfd
, input_section
,
3493 contents
, r_addr
, relocation
,
3497 if (r
!= bfd_reloc_ok
)
3502 case bfd_reloc_outofrange
:
3504 case bfd_reloc_overflow
:
3511 name
= strings
+ GET_WORD (input_bfd
,
3512 syms
[r_index
].e_strx
);
3517 s
= aout_reloc_type_to_section (input_bfd
, r_type
);
3518 name
= bfd_section_name (s
);
3520 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3521 (flaginfo
->info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3522 (bfd_vma
) 0, input_bfd
, input_section
, r_addr
);
3532 /* Link an a.out section into the output file. */
3535 aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3537 asection
*input_section
,
3538 file_ptr
*reloff_ptr
,
3539 bfd_size_type rel_size
)
3541 bfd_size_type input_size
;
3544 /* Get the section contents. */
3545 input_size
= input_section
->size
;
3546 if (! bfd_get_section_contents (input_bfd
, input_section
,
3547 (void *) flaginfo
->contents
,
3548 (file_ptr
) 0, input_size
))
3551 /* Read in the relocs if we haven't already done it. */
3552 if (aout_section_data (input_section
) != NULL
3553 && aout_section_data (input_section
)->relocs
!= NULL
)
3554 relocs
= aout_section_data (input_section
)->relocs
;
3557 relocs
= flaginfo
->relocs
;
3560 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3561 || bfd_bread (relocs
, rel_size
, input_bfd
) != rel_size
)
3566 /* Relocate the section contents. */
3567 if (! pdp11_aout_link_input_section (flaginfo
, input_bfd
, input_section
,
3568 (bfd_byte
*) relocs
,
3569 rel_size
, flaginfo
->contents
))
3572 /* Write out the section contents. */
3573 if (! bfd_set_section_contents (flaginfo
->output_bfd
,
3574 input_section
->output_section
,
3575 (void *) flaginfo
->contents
,
3576 (file_ptr
) input_section
->output_offset
,
3580 /* If we are producing relocatable output, the relocs were
3581 modified, and we now write them out. */
3582 if (bfd_link_relocatable (flaginfo
->info
) && rel_size
> 0)
3584 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
3586 if (bfd_bwrite (relocs
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3588 *reloff_ptr
+= rel_size
;
3590 /* Assert that the relocs have not run into the symbols, and
3591 that if these are the text relocs they have not run into the
3593 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3594 && (reloff_ptr
!= &flaginfo
->treloff
3596 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3602 /* Link an a.out input BFD into the output file. */
3605 aout_link_input_bfd (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
3607 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
3609 /* If this is a dynamic object, it may need special handling. */
3610 if ((input_bfd
->flags
& DYNAMIC
) != 0
3611 && aout_backend_info (input_bfd
)->link_dynamic_object
!= NULL
)
3612 return ((*aout_backend_info (input_bfd
)->link_dynamic_object
)
3613 (flaginfo
->info
, input_bfd
));
3615 /* Get the symbols. We probably have them already, unless
3616 flaginfo->info->keep_memory is FALSE. */
3617 if (! aout_get_external_symbols (input_bfd
))
3620 /* Write out the symbols and get a map of the new indices. The map
3621 is placed into flaginfo->symbol_map. */
3622 if (! aout_link_write_symbols (flaginfo
, input_bfd
))
3625 /* Relocate and write out the sections. These functions use the
3626 symbol map created by aout_link_write_symbols. The linker_mark
3627 field will be set if these sections are to be included in the
3628 link, which will normally be the case. */
3629 if (obj_textsec (input_bfd
)->linker_mark
)
3631 if (! aout_link_input_section (flaginfo
, input_bfd
,
3632 obj_textsec (input_bfd
),
3634 exec_hdr (input_bfd
)->a_trsize
))
3637 if (obj_datasec (input_bfd
)->linker_mark
)
3639 if (! aout_link_input_section (flaginfo
, input_bfd
,
3640 obj_datasec (input_bfd
),
3642 exec_hdr (input_bfd
)->a_drsize
))
3646 /* If we are not keeping memory, we don't need the symbols any
3647 longer. We still need them if we are keeping memory, because the
3648 strings in the hash table point into them. */
3649 if (! flaginfo
->info
->keep_memory
)
3651 if (! aout_link_free_symbols (input_bfd
))
3658 /* Do the final link step. This is called on the output BFD. The
3659 INFO structure should point to a list of BFDs linked through the
3660 link.next field which can be used to find each BFD which takes part
3661 in the output. Also, each section in ABFD should point to a list
3662 of bfd_link_order structures which list all the input sections for
3663 the output section. */
3666 NAME (aout
, final_link
) (bfd
*abfd
,
3667 struct bfd_link_info
*info
,
3668 void (*callback
) (bfd
*, file_ptr
*, file_ptr
*, file_ptr
*))
3670 struct aout_final_link_info aout_info
;
3671 bfd_boolean includes_hash_initialized
= FALSE
;
3673 bfd_size_type trsize
, drsize
;
3674 bfd_size_type max_contents_size
;
3675 bfd_size_type max_relocs_size
;
3676 bfd_size_type max_sym_count
;
3677 struct bfd_link_order
*p
;
3679 bfd_boolean have_link_order_relocs
;
3681 if (bfd_link_pic (info
))
3682 abfd
->flags
|= DYNAMIC
;
3684 separate_i_d
= info
->separate_code
;
3685 aout_info
.info
= info
;
3686 aout_info
.output_bfd
= abfd
;
3687 aout_info
.contents
= NULL
;
3688 aout_info
.relocs
= NULL
;
3689 aout_info
.symbol_map
= NULL
;
3690 aout_info
.output_syms
= NULL
;
3692 if (!bfd_hash_table_init_n (&aout_info
.includes
.root
,
3693 aout_link_includes_newfunc
,
3694 sizeof (struct aout_link_includes_entry
),
3697 includes_hash_initialized
= TRUE
;
3699 /* Figure out the largest section size. Also, if generating
3700 relocatable output, count the relocs. */
3703 max_contents_size
= 0;
3704 max_relocs_size
= 0;
3706 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3710 if (bfd_link_relocatable (info
))
3712 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3714 trsize
+= exec_hdr (sub
)->a_trsize
;
3715 drsize
+= exec_hdr (sub
)->a_drsize
;
3719 /* FIXME: We need to identify the .text and .data sections
3720 and call get_reloc_upper_bound and canonicalize_reloc to
3721 work out the number of relocs needed, and then multiply
3722 by the reloc size. */
3724 /* xgettext:c-format */
3725 (_("%pB: relocatable link from %s to %s not supported"),
3726 abfd
, sub
->xvec
->name
, abfd
->xvec
->name
);
3727 bfd_set_error (bfd_error_invalid_operation
);
3732 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3734 sz
= obj_textsec (sub
)->size
;
3735 if (sz
> max_contents_size
)
3736 max_contents_size
= sz
;
3737 sz
= obj_datasec (sub
)->size
;
3738 if (sz
> max_contents_size
)
3739 max_contents_size
= sz
;
3741 sz
= exec_hdr (sub
)->a_trsize
;
3742 if (sz
> max_relocs_size
)
3743 max_relocs_size
= sz
;
3744 sz
= exec_hdr (sub
)->a_drsize
;
3745 if (sz
> max_relocs_size
)
3746 max_relocs_size
= sz
;
3748 sz
= obj_aout_external_sym_count (sub
);
3749 if (sz
> max_sym_count
)
3754 if (bfd_link_relocatable (info
))
3756 if (obj_textsec (abfd
) != NULL
)
3757 trsize
+= (_bfd_count_link_order_relocs (obj_textsec (abfd
)
3758 ->map_head
.link_order
)
3759 * obj_reloc_entry_size (abfd
));
3760 if (obj_datasec (abfd
) != NULL
)
3761 drsize
+= (_bfd_count_link_order_relocs (obj_datasec (abfd
)
3762 ->map_head
.link_order
)
3763 * obj_reloc_entry_size (abfd
));
3766 exec_hdr (abfd
)->a_trsize
= trsize
;
3767 exec_hdr (abfd
)->a_drsize
= drsize
;
3768 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
3770 /* Adjust the section sizes and vmas according to the magic number.
3771 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3772 filepos for each section. */
3773 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
3776 /* The relocation and symbol file positions differ among a.out
3777 targets. We are passed a callback routine from the backend
3778 specific code to handle this.
3779 FIXME: At this point we do not know how much space the symbol
3780 table will require. This will not work for any (nonstandard)
3781 a.out target that needs to know the symbol table size before it
3782 can compute the relocation file positions. */
3783 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
3785 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
3786 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
3787 obj_sym_filepos (abfd
) = aout_info
.symoff
;
3789 /* We keep a count of the symbols as we output them. */
3790 obj_aout_external_sym_count (abfd
) = 0;
3792 /* We accumulate the string table as we write out the symbols. */
3793 aout_info
.strtab
= _bfd_stringtab_init ();
3794 if (aout_info
.strtab
== NULL
)
3797 /* Allocate buffers to hold section contents and relocs. */
3798 aout_info
.contents
= bfd_malloc (max_contents_size
);
3799 aout_info
.relocs
= bfd_malloc (max_relocs_size
);
3800 aout_info
.symbol_map
= bfd_malloc (max_sym_count
* sizeof (int *));
3801 aout_info
.output_syms
= bfd_malloc ((max_sym_count
+ 1)
3802 * sizeof (struct external_nlist
));
3803 if ((aout_info
.contents
== NULL
&& max_contents_size
!= 0)
3804 || (aout_info
.relocs
== NULL
&& max_relocs_size
!= 0)
3805 || (aout_info
.symbol_map
== NULL
&& max_sym_count
!= 0)
3806 || aout_info
.output_syms
== NULL
)
3809 /* If we have a symbol named __DYNAMIC, force it out now. This is
3810 required by SunOS. Doing this here rather than in sunos.c is a
3811 hack, but it's easier than exporting everything which would be
3814 struct aout_link_hash_entry
*h
;
3816 h
= aout_link_hash_lookup (aout_hash_table (info
), "__DYNAMIC",
3817 FALSE
, FALSE
, FALSE
);
3819 aout_link_write_other_symbol (&h
->root
.root
, &aout_info
);
3822 /* The most time efficient way to do the link would be to read all
3823 the input object files into memory and then sort out the
3824 information into the output file. Unfortunately, that will
3825 probably use too much memory. Another method would be to step
3826 through everything that composes the text section and write it
3827 out, and then everything that composes the data section and write
3828 it out, and then write out the relocs, and then write out the
3829 symbols. Unfortunately, that requires reading stuff from each
3830 input file several times, and we will not be able to keep all the
3831 input files open simultaneously, and reopening them will be slow.
3833 What we do is basically process one input file at a time. We do
3834 everything we need to do with an input file once--copy over the
3835 section contents, handle the relocation information, and write
3836 out the symbols--and then we throw away the information we read
3837 from it. This approach requires a lot of lseeks of the output
3838 file, which is unfortunate but still faster than reopening a lot
3841 We use the output_has_begun field of the input BFDs to see
3842 whether we have already handled it. */
3843 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3844 sub
->output_has_begun
= FALSE
;
3846 /* Mark all sections which are to be included in the link. This
3847 will normally be every section. We need to do this so that we
3848 can identify any sections which the linker has decided to not
3850 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3852 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
3853 if (p
->type
== bfd_indirect_link_order
)
3854 p
->u
.indirect
.section
->linker_mark
= TRUE
;
3857 have_link_order_relocs
= FALSE
;
3858 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3860 for (p
= o
->map_head
.link_order
;
3864 if (p
->type
== bfd_indirect_link_order
3865 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
3866 == bfd_target_aout_flavour
))
3870 input_bfd
= p
->u
.indirect
.section
->owner
;
3871 if (! input_bfd
->output_has_begun
)
3873 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
3875 input_bfd
->output_has_begun
= TRUE
;
3878 else if (p
->type
== bfd_section_reloc_link_order
3879 || p
->type
== bfd_symbol_reloc_link_order
)
3880 /* These are handled below. */
3881 have_link_order_relocs
= TRUE
;
3884 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3890 /* Write out any symbols that we have not already written out. */
3891 bfd_hash_traverse (&info
->hash
->table
,
3892 aout_link_write_other_symbol
,
3895 /* Now handle any relocs we were asked to create by the linker.
3896 These did not come from any input file. We must do these after
3897 we have written out all the symbols, so that we know the symbol
3899 if (have_link_order_relocs
)
3901 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3903 for (p
= o
->map_head
.link_order
;
3907 if (p
->type
== bfd_section_reloc_link_order
3908 || p
->type
== bfd_symbol_reloc_link_order
)
3910 if (! aout_link_reloc_link_order (&aout_info
, o
, p
))
3917 if (aout_info
.contents
!= NULL
)
3919 free (aout_info
.contents
);
3920 aout_info
.contents
= NULL
;
3922 if (aout_info
.relocs
!= NULL
)
3924 free (aout_info
.relocs
);
3925 aout_info
.relocs
= NULL
;
3927 if (aout_info
.symbol_map
!= NULL
)
3929 free (aout_info
.symbol_map
);
3930 aout_info
.symbol_map
= NULL
;
3932 if (aout_info
.output_syms
!= NULL
)
3934 free (aout_info
.output_syms
);
3935 aout_info
.output_syms
= NULL
;
3937 if (includes_hash_initialized
)
3939 bfd_hash_table_free (&aout_info
.includes
.root
);
3940 includes_hash_initialized
= FALSE
;
3943 /* Finish up any dynamic linking we may be doing. */
3944 if (aout_backend_info (abfd
)->finish_dynamic_link
!= NULL
)
3946 if (! (*aout_backend_info (abfd
)->finish_dynamic_link
) (abfd
, info
))
3950 /* Update the header information. */
3951 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
3952 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
3953 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
3954 obj_textsec (abfd
)->reloc_count
=
3955 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
3956 obj_datasec (abfd
)->reloc_count
=
3957 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
3959 /* Write out the string table, unless there are no symbols. */
3960 if (abfd
->symcount
> 0)
3962 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
3963 || ! emit_stringtab (abfd
, aout_info
.strtab
))
3966 else if (obj_textsec (abfd
)->reloc_count
== 0
3967 && obj_datasec (abfd
)->reloc_count
== 0)
3969 /* The layout of a typical a.out file is header, text, data,
3970 relocs, symbols, string table. When there are no relocs,
3971 symbols or string table, the last thing in the file is data
3972 and a_data may be rounded up. However we may have a smaller
3973 sized .data section and thus not written final padding. The
3974 same thing can happen with text if there is no data. Write
3975 final padding here to extend the file. */
3978 if (exec_hdr (abfd
)->a_data
> obj_datasec (abfd
)->size
)
3979 pos
= obj_datasec (abfd
)->filepos
+ exec_hdr (abfd
)->a_data
;
3980 else if (obj_datasec (abfd
)->size
== 0
3981 && exec_hdr (abfd
)->a_text
> obj_textsec (abfd
)->size
)
3982 pos
= obj_textsec (abfd
)->filepos
+ exec_hdr (abfd
)->a_text
;
3987 if (bfd_seek (abfd
, pos
- 1, SEEK_SET
) != 0
3988 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3996 if (aout_info
.contents
!= NULL
)
3997 free (aout_info
.contents
);
3998 if (aout_info
.relocs
!= NULL
)
3999 free (aout_info
.relocs
);
4000 if (aout_info
.symbol_map
!= NULL
)
4001 free (aout_info
.symbol_map
);
4002 if (aout_info
.output_syms
!= NULL
)
4003 free (aout_info
.output_syms
);
4004 if (includes_hash_initialized
)
4005 bfd_hash_table_free (&aout_info
.includes
.root
);
4009 /* Adjust and write out the symbols for an a.out file. Set the new
4010 symbol indices into a symbol_map. */
4013 aout_link_write_symbols (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
4016 bfd_size_type sym_count
;
4018 enum bfd_link_strip strip
;
4019 enum bfd_link_discard discard
;
4020 struct external_nlist
*outsym
;
4021 bfd_size_type strtab_index
;
4022 struct external_nlist
*sym
;
4023 struct external_nlist
*sym_end
;
4024 struct aout_link_hash_entry
**sym_hash
;
4027 bfd_boolean skip_next
;
4029 output_bfd
= flaginfo
->output_bfd
;
4030 sym_count
= obj_aout_external_sym_count (input_bfd
);
4031 strings
= obj_aout_external_strings (input_bfd
);
4032 strip
= flaginfo
->info
->strip
;
4033 discard
= flaginfo
->info
->discard
;
4034 outsym
= flaginfo
->output_syms
;
4036 /* First write out a symbol for this object file, unless we are
4037 discarding such symbols. */
4038 if (strip
!= strip_all
4039 && (strip
!= strip_some
4040 || bfd_hash_lookup (flaginfo
->info
->keep_hash
, input_bfd
->filename
,
4041 FALSE
, FALSE
) != NULL
)
4042 && discard
!= discard_all
)
4044 H_PUT_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
4045 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4046 input_bfd
->filename
, FALSE
);
4047 if (strtab_index
== (bfd_size_type
) -1)
4049 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4050 PUT_WORD (output_bfd
,
4051 (bfd_section_vma (obj_textsec (input_bfd
)->output_section
)
4052 + obj_textsec (input_bfd
)->output_offset
),
4054 ++obj_aout_external_sym_count (output_bfd
);
4060 sym
= obj_aout_external_syms (input_bfd
);
4061 sym_end
= sym
+ sym_count
;
4062 sym_hash
= obj_aout_sym_hashes (input_bfd
);
4063 symbol_map
= flaginfo
->symbol_map
;
4064 memset (symbol_map
, 0, (size_t) sym_count
* sizeof *symbol_map
);
4065 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
4069 struct aout_link_hash_entry
*h
;
4075 /* We set *symbol_map to 0 above for all symbols. If it has
4076 already been set to -1 for this symbol, it means that we are
4077 discarding it because it appears in a duplicate header file.
4078 See the N_BINCL code below. */
4079 if (*symbol_map
== -1)
4082 /* Initialize *symbol_map to -1, which means that the symbol was
4083 not copied into the output file. We will change it later if
4084 we do copy the symbol over. */
4087 type
= H_GET_8 (input_bfd
, sym
->e_type
);
4088 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
4094 /* Pass this symbol through. It is the target of an
4095 indirect or warning symbol. */
4096 val
= GET_WORD (input_bfd
, sym
->e_value
);
4101 /* Skip this symbol, which is the target of an indirect
4102 symbol that we have changed to no longer be an indirect
4109 struct aout_link_hash_entry
*hresolve
;
4111 /* We have saved the hash table entry for this symbol, if
4112 there is one. Note that we could just look it up again
4113 in the hash table, provided we first check that it is an
4117 /* Use the name from the hash table, in case the symbol was
4120 name
= h
->root
.root
.string
;
4122 /* If this is an indirect or warning symbol, then change
4123 hresolve to the base symbol. We also change *sym_hash so
4124 that the relocation routines relocate against the real
4128 && (h
->root
.type
== bfd_link_hash_indirect
4129 || h
->root
.type
== bfd_link_hash_warning
))
4131 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
4132 while (hresolve
->root
.type
== bfd_link_hash_indirect
4133 || hresolve
->root
.type
== bfd_link_hash_warning
)
4134 hresolve
= ((struct aout_link_hash_entry
*)
4135 hresolve
->root
.u
.i
.link
);
4136 *sym_hash
= hresolve
;
4139 /* If the symbol has already been written out, skip it. */
4141 && h
->root
.type
!= bfd_link_hash_warning
4144 if ((type
& N_TYPE
) == N_INDR
4145 || type
== N_WARNING
)
4147 *symbol_map
= h
->indx
;
4151 /* See if we are stripping this symbol. */
4157 case strip_debugger
:
4158 if ((type
& N_STAB
) != 0)
4162 if (bfd_hash_lookup (flaginfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
4177 /* Get the value of the symbol. */
4178 if ((type
& N_TYPE
) == N_TEXT
4180 symsec
= obj_textsec (input_bfd
);
4181 else if ((type
& N_TYPE
) == N_DATA
4183 symsec
= obj_datasec (input_bfd
);
4184 else if ((type
& N_TYPE
) == N_BSS
4186 symsec
= obj_bsssec (input_bfd
);
4187 else if ((type
& N_TYPE
) == N_ABS
4189 symsec
= bfd_abs_section_ptr
;
4190 else if (((type
& N_TYPE
) == N_INDR
4191 && (hresolve
== NULL
4192 || (hresolve
->root
.type
!= bfd_link_hash_defined
4193 && hresolve
->root
.type
!= bfd_link_hash_defweak
4194 && hresolve
->root
.type
!= bfd_link_hash_common
)))
4195 || type
== N_WARNING
)
4197 /* Pass the next symbol through unchanged. The
4198 condition above for indirect symbols is so that if
4199 the indirect symbol was defined, we output it with
4200 the correct definition so the debugger will
4203 val
= GET_WORD (input_bfd
, sym
->e_value
);
4206 else if ((type
& N_STAB
) != 0)
4208 val
= GET_WORD (input_bfd
, sym
->e_value
);
4213 /* If we get here with an indirect symbol, it means that
4214 we are outputting it with a real definition. In such
4215 a case we do not want to output the next symbol,
4216 which is the target of the indirection. */
4217 if ((type
& N_TYPE
) == N_INDR
)
4222 /* We need to get the value from the hash table. We use
4223 hresolve so that if we have defined an indirect
4224 symbol we output the final definition. */
4227 switch (type
& N_TYPE
)
4230 symsec
= obj_textsec (input_bfd
);
4233 symsec
= obj_datasec (input_bfd
);
4236 symsec
= obj_bsssec (input_bfd
);
4239 symsec
= bfd_abs_section_ptr
;
4246 else if (hresolve
->root
.type
== bfd_link_hash_defined
4247 || hresolve
->root
.type
== bfd_link_hash_defweak
)
4249 asection
*input_section
;
4250 asection
*output_section
;
4252 /* This case usually means a common symbol which was
4253 turned into a defined symbol. */
4254 input_section
= hresolve
->root
.u
.def
.section
;
4255 output_section
= input_section
->output_section
;
4256 BFD_ASSERT (bfd_is_abs_section (output_section
)
4257 || output_section
->owner
== output_bfd
);
4258 val
= (hresolve
->root
.u
.def
.value
4259 + bfd_section_vma (output_section
)
4260 + input_section
->output_offset
);
4262 /* Get the correct type based on the section. If
4263 this is a constructed set, force it to be
4264 globally visible. */
4273 if (output_section
== obj_textsec (output_bfd
))
4274 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4277 else if (output_section
== obj_datasec (output_bfd
))
4278 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4281 else if (output_section
== obj_bsssec (output_bfd
))
4282 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4286 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4290 else if (hresolve
->root
.type
== bfd_link_hash_common
)
4291 val
= hresolve
->root
.u
.c
.size
;
4292 else if (hresolve
->root
.type
== bfd_link_hash_undefweak
)
4301 val
= (symsec
->output_section
->vma
4302 + symsec
->output_offset
4303 + (GET_WORD (input_bfd
, sym
->e_value
)
4306 /* If this is a global symbol set the written flag, and if
4307 it is a local symbol see if we should discard it. */
4311 h
->indx
= obj_aout_external_sym_count (output_bfd
);
4313 else if ((type
& N_TYPE
) != N_SETT
4314 && (type
& N_TYPE
) != N_SETD
4315 && (type
& N_TYPE
) != N_SETB
4316 && (type
& N_TYPE
) != N_SETA
)
4321 case discard_sec_merge
:
4324 if ((type
& N_STAB
) == 0
4325 && bfd_is_local_label_name (input_bfd
, name
))
4339 /* An N_BINCL symbol indicates the start of the stabs
4340 entries for a header file. We need to scan ahead to the
4341 next N_EINCL symbol, ignoring nesting, adding up all the
4342 characters in the symbol names, not including the file
4343 numbers in types (the first number after an open
4345 if (type
== N_BINCL
)
4347 struct external_nlist
*incl_sym
;
4349 struct aout_link_includes_entry
*incl_entry
;
4350 struct aout_link_includes_totals
*t
;
4354 for (incl_sym
= sym
+ 1; incl_sym
< sym_end
; incl_sym
++)
4358 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4359 if (incl_type
== N_EINCL
)
4365 else if (incl_type
== N_BINCL
)
4371 s
= strings
+ GET_WORD (input_bfd
, incl_sym
->e_strx
);
4372 for (; *s
!= '\0'; s
++)
4377 /* Skip the file number. */
4379 while (ISDIGIT (*s
))
4387 /* If we have already included a header file with the
4388 same value, then replace this one with an N_EXCL
4390 copy
= ! flaginfo
->info
->keep_memory
;
4391 incl_entry
= aout_link_includes_lookup (&flaginfo
->includes
,
4393 if (incl_entry
== NULL
)
4395 for (t
= incl_entry
->totals
; t
!= NULL
; t
= t
->next
)
4396 if (t
->total
== val
)
4400 /* This is the first time we have seen this header
4401 file with this set of stabs strings. */
4402 t
= bfd_hash_allocate (&flaginfo
->includes
.root
,
4407 t
->next
= incl_entry
->totals
;
4408 incl_entry
->totals
= t
;
4414 /* This is a duplicate header file. We must change
4415 it to be an N_EXCL entry, and mark all the
4416 included symbols to prevent outputting them. */
4420 for (incl_sym
= sym
+ 1, incl_map
= symbol_map
+ 1;
4422 incl_sym
++, incl_map
++)
4426 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4427 if (incl_type
== N_EINCL
)
4436 else if (incl_type
== N_BINCL
)
4445 /* Copy this symbol into the list of symbols we are going to
4447 H_PUT_8 (output_bfd
, type
, outsym
->e_type
);
4449 if (! flaginfo
->info
->keep_memory
)
4451 /* name points into a string table which we are going to
4452 free. If there is a hash table entry, use that string.
4453 Otherwise, copy name into memory. */
4455 name
= h
->root
.root
.string
;
4459 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4461 if (strtab_index
== (bfd_size_type
) -1)
4463 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4464 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
4465 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
4466 ++obj_aout_external_sym_count (output_bfd
);
4470 /* Write out the output symbols we have just constructed. */
4471 if (outsym
> flaginfo
->output_syms
)
4475 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0)
4477 size
= outsym
- flaginfo
->output_syms
;
4478 size
*= EXTERNAL_NLIST_SIZE
;
4479 if (bfd_bwrite ((void *) flaginfo
->output_syms
, size
, output_bfd
) != size
)
4481 flaginfo
->symoff
+= size
;
4487 /* Write out a symbol that was not associated with an a.out input
4491 bfd_getp32 (const void *p
)
4493 const bfd_byte
*addr
= p
;
4496 v
= (unsigned long) addr
[1] << 24;
4497 v
|= (unsigned long) addr
[0] << 16;
4498 v
|= (unsigned long) addr
[3] << 8;
4499 v
|= (unsigned long) addr
[2];
4503 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
4505 static bfd_signed_vma
4506 bfd_getp_signed_32 (const void *p
)
4508 const bfd_byte
*addr
= p
;
4511 v
= (unsigned long) addr
[1] << 24;
4512 v
|= (unsigned long) addr
[0] << 16;
4513 v
|= (unsigned long) addr
[3] << 8;
4514 v
|= (unsigned long) addr
[2];
4515 return COERCE32 (v
);
4519 bfd_putp32 (bfd_vma data
, void *p
)
4523 addr
[0] = (data
>> 16) & 0xff;
4524 addr
[1] = (data
>> 24) & 0xff;
4525 addr
[2] = (data
>> 0) & 0xff;
4526 addr
[3] = (data
>> 8) & 0xff;
4529 const bfd_target
MY (vec
) =
4531 TARGETNAME
, /* Name. */
4532 bfd_target_aout_flavour
,
4533 BFD_ENDIAN_LITTLE
, /* Target byte order (little). */
4534 BFD_ENDIAN_LITTLE
, /* Target headers byte order (little). */
4535 (HAS_RELOC
| EXEC_P
| /* Object flags. */
4536 HAS_LINENO
| HAS_DEBUG
|
4537 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
),
4538 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_CODE
| SEC_DATA
),
4539 MY_symbol_leading_char
,
4540 AR_PAD_CHAR
, /* AR_pad_char. */
4541 15, /* AR_max_namelen. */
4542 0, /* match priority. */
4543 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4544 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4545 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Data. */
4546 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4547 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4548 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Headers. */
4549 { /* bfd_check_format. */
4552 bfd_generic_archive_p
,
4555 { /* bfd_set_format. */
4556 _bfd_bool_bfd_false_error
,
4558 _bfd_generic_mkarchive
,
4559 _bfd_bool_bfd_false_error
4561 { /* bfd_write_contents. */
4562 _bfd_bool_bfd_false_error
,
4563 MY_write_object_contents
,
4564 _bfd_write_archive_contents
,
4565 _bfd_bool_bfd_false_error
4568 BFD_JUMP_TABLE_GENERIC (MY
),
4569 BFD_JUMP_TABLE_COPY (MY
),
4570 BFD_JUMP_TABLE_CORE (MY
),
4571 BFD_JUMP_TABLE_ARCHIVE (MY
),
4572 BFD_JUMP_TABLE_SYMBOLS (MY
),
4573 BFD_JUMP_TABLE_RELOCS (MY
),
4574 BFD_JUMP_TABLE_WRITE (MY
),
4575 BFD_JUMP_TABLE_LINK (MY
),
4576 BFD_JUMP_TABLE_DYNAMIC (MY
),
4578 /* Alternative_target. */
4581 (void *) MY_backend_data