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
),
258 HOWTO( 2, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,0,"32", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
261 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
264 static bfd_boolean
aout_link_check_archive_element (bfd
*, struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *, bfd_boolean
*);
265 static bfd_boolean
aout_link_add_object_symbols (bfd
*, struct bfd_link_info
*);
266 static bfd_boolean
aout_link_add_symbols (bfd
*, struct bfd_link_info
*);
267 static bfd_boolean
aout_link_write_symbols (struct aout_final_link_info
*, bfd
*);
271 NAME (aout
, reloc_type_lookup
) (bfd
* abfd ATTRIBUTE_UNUSED
,
272 bfd_reloc_code_real_type code
)
277 return &howto_table_pdp11
[0];
278 case BFD_RELOC_16_PCREL
:
279 return &howto_table_pdp11
[1];
281 return &howto_table_pdp11
[2];
288 NAME (aout
, reloc_name_lookup
) (bfd
*abfd ATTRIBUTE_UNUSED
,
294 i
< sizeof (howto_table_pdp11
) / sizeof (howto_table_pdp11
[0]);
296 if (howto_table_pdp11
[i
].name
!= NULL
297 && strcasecmp (howto_table_pdp11
[i
].name
, r_name
) == 0)
298 return &howto_table_pdp11
[i
];
304 pdp11_aout_write_headers (bfd
*abfd
, struct internal_exec
*execp
)
306 struct external_exec exec_bytes
;
308 if (adata(abfd
).magic
== undecided_magic
)
309 NAME (aout
, adjust_sizes_and_vmas
) (abfd
);
311 execp
->a_syms
= bfd_get_symcount (abfd
) * EXTERNAL_NLIST_SIZE
;
312 execp
->a_entry
= bfd_get_start_address (abfd
);
314 if (obj_textsec (abfd
)->reloc_count
> 0
315 || obj_datasec (abfd
)->reloc_count
> 0)
317 execp
->a_trsize
= execp
->a_text
;
318 execp
->a_drsize
= execp
->a_data
;
326 NAME (aout
, swap_exec_header_out
) (abfd
, execp
, & exec_bytes
);
328 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
331 if (bfd_bwrite ((void *) &exec_bytes
, (bfd_size_type
) EXEC_BYTES_SIZE
, abfd
)
335 /* Now write out reloc info, followed by syms and strings. */
336 if (bfd_get_outsymbols (abfd
) != NULL
337 && bfd_get_symcount (abfd
) != 0)
339 if (bfd_seek (abfd
, (file_ptr
) (N_SYMOFF (execp
)), SEEK_SET
) != 0)
342 if (! NAME (aout
, write_syms
) (abfd
))
346 if (obj_textsec (abfd
)->reloc_count
> 0
347 || obj_datasec (abfd
)->reloc_count
> 0)
349 if (bfd_seek (abfd
, (file_ptr
) (N_TRELOFF (execp
)), SEEK_SET
) != 0
350 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_textsec (abfd
))
351 || bfd_seek (abfd
, (file_ptr
) (N_DRELOFF (execp
)), SEEK_SET
) != 0
352 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_datasec (abfd
)))
359 /* Write an object file.
360 Section contents have already been written. We write the
361 file header, symbols, and relocation. */
364 MY(write_object_contents
) (bfd
*abfd
)
366 struct internal_exec
*execp
= exec_hdr (abfd
);
368 /* We must make certain that the magic number has been set. This
369 will normally have been done by set_section_contents, but only if
370 there actually are some section contents. */
371 if (! abfd
->output_has_begun
)
372 NAME (aout
, adjust_sizes_and_vmas
) (abfd
);
374 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
376 return WRITE_HEADERS (abfd
, execp
);
379 /* Swap the information in an executable header @var{raw_bytes} taken
380 from a raw byte stream memory image into the internal exec header
381 structure "execp". */
383 #ifndef NAME_swap_exec_header_in
385 NAME (aout
, swap_exec_header_in
) (bfd
*abfd
,
386 struct external_exec
*bytes
,
387 struct internal_exec
*execp
)
389 /* The internal_exec structure has some fields that are unused in this
390 configuration (IE for i960), so ensure that all such uninitialized
391 fields are zero'd out. There are places where two of these structs
392 are memcmp'd, and thus the contents do matter. */
393 memset ((void *) execp
, 0, sizeof (struct internal_exec
));
394 /* Now fill in fields in the execp, from the bytes in the raw data. */
395 execp
->a_info
= GET_MAGIC (abfd
, bytes
->e_info
);
396 execp
->a_text
= GET_WORD (abfd
, bytes
->e_text
);
397 execp
->a_data
= GET_WORD (abfd
, bytes
->e_data
);
398 execp
->a_bss
= GET_WORD (abfd
, bytes
->e_bss
);
399 execp
->a_syms
= GET_WORD (abfd
, bytes
->e_syms
);
400 execp
->a_entry
= GET_WORD (abfd
, bytes
->e_entry
);
402 if (GET_WORD (abfd
, bytes
->e_flag
) & A_FLAG_RELOC_STRIPPED
)
409 execp
->a_trsize
= execp
->a_text
;
410 execp
->a_drsize
= execp
->a_data
;
413 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
416 /* Swap the information in an internal exec header structure
417 "execp" into the buffer "bytes" ready for writing to disk. */
419 NAME (aout
, swap_exec_header_out
) (bfd
*abfd
,
420 struct internal_exec
*execp
,
421 struct external_exec
*bytes
)
423 /* Now fill in fields in the raw data, from the fields in the exec struct. */
424 PUT_MAGIC (abfd
, execp
->a_info
, bytes
->e_info
);
425 PUT_WORD (abfd
, execp
->a_text
, bytes
->e_text
);
426 PUT_WORD (abfd
, execp
->a_data
, bytes
->e_data
);
427 PUT_WORD (abfd
, execp
->a_bss
, bytes
->e_bss
);
428 PUT_WORD (abfd
, execp
->a_syms
, bytes
->e_syms
);
429 PUT_WORD (abfd
, execp
->a_entry
, bytes
->e_entry
);
430 PUT_WORD (abfd
, 0, bytes
->e_unused
);
432 if ((execp
->a_trsize
== 0 || execp
->a_text
== 0)
433 && (execp
->a_drsize
== 0 || execp
->a_data
== 0))
434 PUT_WORD (abfd
, A_FLAG_RELOC_STRIPPED
, bytes
->e_flag
);
435 else if (execp
->a_trsize
== execp
->a_text
436 && execp
->a_drsize
== execp
->a_data
)
437 PUT_WORD (abfd
, 0, bytes
->e_flag
);
440 /* TODO: print a proper warning message. */
441 fprintf (stderr
, "BFD:%s:%d: internal error\n", __FILE__
, __LINE__
);
442 PUT_WORD (abfd
, 0, bytes
->e_flag
);
446 /* Make all the section for an a.out file. */
449 NAME (aout
, make_sections
) (bfd
*abfd
)
451 if (obj_textsec (abfd
) == NULL
&& bfd_make_section (abfd
, ".text") == NULL
)
453 if (obj_datasec (abfd
) == NULL
&& bfd_make_section (abfd
, ".data") == NULL
)
455 if (obj_bsssec (abfd
) == NULL
&& bfd_make_section (abfd
, ".bss") == NULL
)
460 /* Some a.out variant thinks that the file open in ABFD
461 checking is an a.out file. Do some more checking, and set up
462 for access if it really is. Call back to the calling
463 environment's "finish up" function just before returning, to
464 handle any last-minute setup. */
467 NAME (aout
, some_aout_object_p
) (bfd
*abfd
,
468 struct internal_exec
*execp
,
469 bfd_cleanup (*callback_to_real_object_p
) (bfd
*))
471 struct aout_data_struct
*rawptr
, *oldrawptr
;
473 size_t amt
= sizeof (struct aout_data_struct
);
475 rawptr
= bfd_zalloc (abfd
, amt
);
479 oldrawptr
= abfd
->tdata
.aout_data
;
480 abfd
->tdata
.aout_data
= rawptr
;
482 /* Copy the contents of the old tdata struct. */
483 if (oldrawptr
!= NULL
)
484 *abfd
->tdata
.aout_data
= *oldrawptr
;
486 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
487 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
; /* Copy in the internal_exec struct. */
488 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
490 /* Set the file flags. */
491 abfd
->flags
= BFD_NO_FLAGS
;
492 if (execp
->a_drsize
|| execp
->a_trsize
)
493 abfd
->flags
|= HAS_RELOC
;
494 /* Setting of EXEC_P has been deferred to the bottom of this function. */
496 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
497 if (N_DYNAMIC (execp
))
498 abfd
->flags
|= DYNAMIC
;
500 if (N_MAGIC (execp
) == ZMAGIC
)
502 abfd
->flags
|= D_PAGED
| WP_TEXT
;
503 adata (abfd
).magic
= z_magic
;
505 else if (N_MAGIC (execp
) == NMAGIC
)
507 abfd
->flags
|= WP_TEXT
;
508 adata (abfd
).magic
= n_magic
;
510 else if (N_MAGIC (execp
) == OMAGIC
)
511 adata (abfd
).magic
= o_magic
;
512 else if (N_MAGIC (execp
) == IMAGIC
)
513 adata (abfd
).magic
= i_magic
;
516 /* Should have been checked with N_BADMAG before this routine
521 abfd
->start_address
= execp
->a_entry
;
523 obj_aout_symbols (abfd
) = NULL
;
524 abfd
->symcount
= execp
->a_syms
/ sizeof (struct external_nlist
);
526 /* The default relocation entry size is that of traditional V7 Unix. */
527 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
529 /* The default symbol entry size is that of traditional Unix. */
530 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
533 bfd_init_window (&obj_aout_sym_window (abfd
));
534 bfd_init_window (&obj_aout_string_window (abfd
));
537 obj_aout_external_syms (abfd
) = NULL
;
538 obj_aout_external_strings (abfd
) = NULL
;
539 obj_aout_sym_hashes (abfd
) = NULL
;
541 if (! NAME (aout
, make_sections
) (abfd
))
544 obj_datasec (abfd
)->size
= execp
->a_data
;
545 obj_bsssec (abfd
)->size
= execp
->a_bss
;
547 obj_textsec (abfd
)->flags
=
548 (execp
->a_trsize
!= 0
549 ? (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_RELOC
)
550 : (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
));
551 obj_datasec (abfd
)->flags
=
552 (execp
->a_drsize
!= 0
553 ? (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_RELOC
)
554 : (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
));
555 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
557 #ifdef THIS_IS_ONLY_DOCUMENTATION
558 /* The common code can't fill in these things because they depend
559 on either the start address of the text segment, the rounding
560 up of virtual addresses between segments, or the starting file
561 position of the text segment -- all of which varies among different
562 versions of a.out. */
564 /* Call back to the format-dependent code to fill in the rest of the
565 fields and do any further cleanup. Things that should be filled
566 in by the callback: */
567 struct exec
*execp
= exec_hdr (abfd
);
569 obj_textsec (abfd
)->size
= N_TXTSIZE (execp
);
570 /* Data and bss are already filled in since they're so standard. */
572 /* The virtual memory addresses of the sections. */
573 obj_textsec (abfd
)->vma
= N_TXTADDR (execp
);
574 obj_datasec (abfd
)->vma
= N_DATADDR (execp
);
575 obj_bsssec (abfd
)->vma
= N_BSSADDR (execp
);
577 /* The file offsets of the sections. */
578 obj_textsec (abfd
)->filepos
= N_TXTOFF (execp
);
579 obj_datasec (abfd
)->filepos
= N_DATOFF (execp
);
581 /* The file offsets of the relocation info. */
582 obj_textsec (abfd
)->rel_filepos
= N_TRELOFF (execp
);
583 obj_datasec (abfd
)->rel_filepos
= N_DRELOFF (execp
);
585 /* The file offsets of the string table and symbol table. */
586 obj_str_filepos (abfd
) = N_STROFF (execp
);
587 obj_sym_filepos (abfd
) = N_SYMOFF (execp
);
589 /* Determine the architecture and machine type of the object file. */
590 abfd
->obj_arch
= bfd_arch_obscure
;
592 adata(abfd
)->page_size
= TARGET_PAGE_SIZE
;
593 adata(abfd
)->segment_size
= SEGMENT_SIZE
;
594 adata(abfd
)->exec_bytes_size
= EXEC_BYTES_SIZE
;
596 return _bfd_no_cleanup
;
598 /* The architecture is encoded in various ways in various a.out variants,
599 or is not encoded at all in some of them. The relocation size depends
600 on the architecture and the a.out variant. Finally, the return value
601 is the bfd_target vector in use. If an error occurs, return zero and
602 set bfd_error to the appropriate error code.
604 Formats such as b.out, which have additional fields in the a.out
605 header, should cope with them in this callback as well. */
606 #endif /* DOCUMENTATION */
608 cleanup
= (*callback_to_real_object_p
)(abfd
);
610 /* Now that the segment addresses have been worked out, take a better
611 guess at whether the file is executable. If the entry point
612 is within the text segment, assume it is. (This makes files
613 executable even if their entry point address is 0, as long as
614 their text starts at zero.).
616 This test had to be changed to deal with systems where the text segment
617 runs at a different location than the default. The problem is that the
618 entry address can appear to be outside the text segment, thus causing an
619 erroneous conclusion that the file isn't executable.
621 To fix this, we now accept any non-zero entry point as an indication of
622 executability. This will work most of the time, since only the linker
623 sets the entry point, and that is likely to be non-zero for most systems. */
625 if (execp
->a_entry
!= 0
626 || (execp
->a_entry
>= obj_textsec(abfd
)->vma
627 && execp
->a_entry
< obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->size
))
628 abfd
->flags
|= EXEC_P
;
632 struct stat stat_buf
;
634 /* The original heuristic doesn't work in some important cases.
635 The a.out file has no information about the text start
636 address. For files (like kernels) linked to non-standard
637 addresses (ld -Ttext nnn) the entry point may not be between
638 the default text start (obj_textsec(abfd)->vma) and
639 (obj_textsec(abfd)->vma) + text size. This is not just a mach
640 issue. Many kernels are loaded at non standard addresses. */
641 if (abfd
->iostream
!= NULL
642 && (abfd
->flags
& BFD_IN_MEMORY
) == 0
643 && (fstat(fileno((FILE *) (abfd
->iostream
)), &stat_buf
) == 0)
644 && ((stat_buf
.st_mode
& 0111) != 0))
645 abfd
->flags
|= EXEC_P
;
647 #endif /* STAT_FOR_EXEC */
652 abfd
->tdata
.aout_data
= oldrawptr
;
657 /* Initialize ABFD for use with a.out files. */
660 NAME (aout
, mkobject
) (bfd
*abfd
)
662 struct aout_data_struct
*rawptr
;
663 size_t amt
= sizeof (struct aout_data_struct
);
665 bfd_set_error (bfd_error_system_call
);
667 /* Use an intermediate variable for clarity. */
668 rawptr
= bfd_zalloc (abfd
, amt
);
673 abfd
->tdata
.aout_data
= rawptr
;
674 exec_hdr (abfd
) = &(rawptr
->e
);
676 obj_textsec (abfd
) = NULL
;
677 obj_datasec (abfd
) = NULL
;
678 obj_bsssec (abfd
) = NULL
;
683 /* Keep track of machine architecture and machine type for
684 a.out's. Return the <<machine_type>> for a particular
685 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
686 and machine can't be represented in a.out format.
688 If the architecture is understood, machine type 0 (default)
689 is always understood. */
692 NAME (aout
, machine_type
) (enum bfd_architecture arch
,
693 unsigned long machine
,
694 bfd_boolean
*unknown
)
696 enum machine_type arch_flags
;
698 arch_flags
= M_UNKNOWN
;
705 || machine
== bfd_mach_sparc
706 || machine
== bfd_mach_sparc_sparclite
707 || machine
== bfd_mach_sparc_v9
)
708 arch_flags
= M_SPARC
;
709 else if (machine
== bfd_mach_sparc_sparclet
)
710 arch_flags
= M_SPARCLET
;
715 || machine
== bfd_mach_i386_i386
716 || machine
== bfd_mach_i386_i386_intel_syntax
)
721 if (machine
== 0) arch_flags
= M_ARM
;
729 case bfd_mach_mips3000
:
730 arch_flags
= M_MIPS1
;
732 case bfd_mach_mips4000
: /* MIPS3 */
733 case bfd_mach_mips4400
:
734 case bfd_mach_mips8000
: /* MIPS4 */
735 case bfd_mach_mips6000
: /* Real MIPS2: */
736 arch_flags
= M_MIPS2
;
739 arch_flags
= M_UNKNOWN
;
747 case 0: arch_flags
= M_NS32532
; break;
748 case 32032: arch_flags
= M_NS32032
; break;
749 case 32532: arch_flags
= M_NS32532
; break;
750 default: arch_flags
= M_UNKNOWN
; break;
755 /* TODO: arch_flags = M_PDP11; */
764 arch_flags
= M_UNKNOWN
;
767 if (arch_flags
!= M_UNKNOWN
)
773 /* Set the architecture and the machine of the ABFD to the
774 values ARCH and MACHINE. Verify that @ABFD's format
775 can support the architecture required. */
778 NAME (aout
, set_arch_mach
) (bfd
*abfd
,
779 enum bfd_architecture arch
,
780 unsigned long machine
)
782 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
785 if (arch
!= bfd_arch_unknown
)
789 NAME (aout
, machine_type
) (arch
, machine
, &unknown
);
794 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
796 return (*aout_backend_info(abfd
)->set_sizes
) (abfd
);
800 adjust_o_magic (bfd
*abfd
, struct internal_exec
*execp
)
802 file_ptr pos
= adata (abfd
).exec_bytes_size
;
805 asection
*text
= obj_textsec (abfd
);
806 asection
*data
= obj_datasec (abfd
);
807 asection
*bss
= obj_bsssec (abfd
);
811 if (!text
->user_set_vma
)
816 pos
+= execp
->a_text
;
817 vma
+= execp
->a_text
;
820 if (!data
->user_set_vma
)
828 execp
->a_text
+= pad
;
835 if (!bss
->user_set_vma
)
841 else if (data
->size
> 0 || bss
->size
> 0) /* PR25677: for objcopy --extract-symbol */
843 /* The VMA of the .bss section is set by the VMA of the
844 .data section plus the size of the .data section. We may
845 need to add padding bytes to make this true. */
846 pad
= bss
->vma
- vma
;
851 execp
->a_data
= data
->size
+ pad
;
853 execp
->a_bss
= bss
->size
;
855 N_SET_MAGIC (execp
, OMAGIC
);
859 adjust_z_magic (bfd
*abfd
, struct internal_exec
*execp
)
861 bfd_size_type data_pad
, text_pad
;
863 const struct aout_backend_data
*abdp
;
864 /* TRUE if text includes exec header. */
866 asection
*text
= obj_textsec (abfd
);
867 asection
*data
= obj_datasec (abfd
);
868 asection
*bss
= obj_bsssec (abfd
);
870 abdp
= aout_backend_info (abfd
);
874 && (abdp
->text_includes_header
875 || obj_aout_subformat (abfd
) == q_magic_format
));
876 text
->filepos
= (ztih
877 ? adata (abfd
).exec_bytes_size
878 : adata (abfd
).zmagic_disk_block_size
);
879 if (!text
->user_set_vma
)
881 /* ?? Do we really need to check for relocs here? */
882 text
->vma
= ((abfd
->flags
& HAS_RELOC
)
885 ? abdp
->default_text_vma
+ adata (abfd
).exec_bytes_size
886 : abdp
->default_text_vma
));
891 /* The .text section is being loaded at an unusual address. We
892 may need to pad it such that the .data section starts at a page
895 text_pad
= ((text
->filepos
- text
->vma
)
896 & (adata (abfd
).page_size
- 1));
898 text_pad
= (-text
->vma
899 & (adata (abfd
).page_size
- 1));
902 /* Find start of data. */
905 text_end
= text
->filepos
+ execp
->a_text
;
906 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
910 /* Note that if page_size == zmagic_disk_block_size, then
911 filepos == page_size, and this case is the same as the ztih
913 text_end
= execp
->a_text
;
914 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
915 text_end
+= text
->filepos
;
917 execp
->a_text
+= text_pad
;
920 if (!data
->user_set_vma
)
923 vma
= text
->vma
+ execp
->a_text
;
924 data
->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
926 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
928 text_pad
= data
->vma
- (text
->vma
+ execp
->a_text
);
929 /* Only pad the text section if the data
930 section is going to be placed after it. */
932 execp
->a_text
+= text_pad
;
934 data
->filepos
= text
->filepos
+ execp
->a_text
;
936 /* Fix up exec header while we're at it. */
937 if (ztih
&& (!abdp
|| (abdp
&& !abdp
->exec_header_not_counted
)))
938 execp
->a_text
+= adata (abfd
).exec_bytes_size
;
939 N_SET_MAGIC (execp
, ZMAGIC
);
941 /* Spec says data section should be rounded up to page boundary. */
942 execp
->a_data
= align_power (data
->size
, bss
->alignment_power
);
943 execp
->a_data
= BFD_ALIGN (execp
->a_data
, adata (abfd
).page_size
);
944 data_pad
= execp
->a_data
- data
->size
;
947 if (!bss
->user_set_vma
)
948 bss
->vma
= data
->vma
+ execp
->a_data
;
949 /* If the BSS immediately follows the data section and extra space
950 in the page is left after the data section, fudge data
951 in the header so that the bss section looks smaller by that
952 amount. We'll start the bss section there, and lie to the OS.
953 (Note that a linker script, as well as the above assignment,
954 could have explicitly set the BSS vma to immediately follow
955 the data section.) */
956 if (align_power (bss
->vma
, bss
->alignment_power
) == data
->vma
+ execp
->a_data
)
957 execp
->a_bss
= data_pad
> bss
->size
? 0 : bss
->size
- data_pad
;
959 execp
->a_bss
= bss
->size
;
963 adjust_n_magic (bfd
*abfd
, struct internal_exec
*execp
)
965 file_ptr pos
= adata (abfd
).exec_bytes_size
;
968 asection
*text
= obj_textsec (abfd
);
969 asection
*data
= obj_datasec (abfd
);
970 asection
*bss
= obj_bsssec (abfd
);
974 if (!text
->user_set_vma
)
978 pos
+= execp
->a_text
;
979 vma
+= execp
->a_text
;
983 if (!data
->user_set_vma
)
984 data
->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
987 /* Since BSS follows data immediately, see if it needs alignment. */
989 pad
= align_power (vma
, bss
->alignment_power
) - vma
;
990 execp
->a_data
= data
->size
+ pad
;
991 pos
+= execp
->a_data
;
994 if (!bss
->user_set_vma
)
999 /* Fix up exec header. */
1000 execp
->a_bss
= bss
->size
;
1001 N_SET_MAGIC (execp
, NMAGIC
);
1005 adjust_i_magic (bfd
*abfd
, struct internal_exec
*execp
)
1007 file_ptr pos
= adata (abfd
).exec_bytes_size
;
1010 asection
*text
= obj_textsec (abfd
);
1011 asection
*data
= obj_datasec (abfd
);
1012 asection
*bss
= obj_bsssec (abfd
);
1015 text
->filepos
= pos
;
1016 if (!text
->user_set_vma
)
1020 pos
+= execp
->a_text
;
1023 data
->filepos
= pos
;
1024 if (!data
->user_set_vma
)
1028 /* Since BSS follows data immediately, see if it needs alignment. */
1030 pad
= align_power (vma
, bss
->alignment_power
) - vma
;
1031 execp
->a_data
= data
->size
+ pad
;
1032 pos
+= execp
->a_data
;
1035 if (!bss
->user_set_vma
)
1040 /* Fix up exec header. */
1041 execp
->a_bss
= bss
->size
;
1042 N_SET_MAGIC (execp
, IMAGIC
);
1046 NAME (aout
, adjust_sizes_and_vmas
) (bfd
*abfd
)
1048 struct internal_exec
*execp
= exec_hdr (abfd
);
1050 if (! NAME (aout
, make_sections
) (abfd
))
1053 if (adata (abfd
).magic
!= undecided_magic
)
1056 execp
->a_text
= align_power (obj_textsec (abfd
)->size
,
1057 obj_textsec (abfd
)->alignment_power
);
1059 /* Rule (heuristic) for when to pad to a new page. Note that there
1060 are (at least) two ways demand-paged (ZMAGIC) files have been
1061 handled. Most Berkeley-based systems start the text segment at
1062 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1063 segment right after the exec header; the latter is counted in the
1064 text segment size, and is paged in by the kernel with the rest of
1067 /* This perhaps isn't the right way to do this, but made it simpler for me
1068 to understand enough to implement it. Better would probably be to go
1069 right from BFD flags to alignment/positioning characteristics. But the
1070 old code was sloppy enough about handling the flags, and had enough
1071 other magic, that it was a little hard for me to understand. I think
1072 I understand it better now, but I haven't time to do the cleanup this
1076 adata (abfd
).magic
= i_magic
;
1077 else if (abfd
->flags
& WP_TEXT
)
1078 adata (abfd
).magic
= n_magic
;
1080 adata (abfd
).magic
= o_magic
;
1082 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1084 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1086 switch (adata (abfd
).magic
)
1088 case n_magic
: str
= "NMAGIC"; break;
1089 case o_magic
: str
= "OMAGIC"; break;
1090 case i_magic
: str
= "IMAGIC"; break;
1091 case z_magic
: str
= "ZMAGIC"; break;
1096 obj_textsec (abfd
)->vma
, obj_textsec (abfd
)->size
,
1097 obj_textsec (abfd
)->alignment_power
,
1098 obj_datasec (abfd
)->vma
, obj_datasec (abfd
)->size
,
1099 obj_datasec (abfd
)->alignment_power
,
1100 obj_bsssec (abfd
)->vma
, obj_bsssec (abfd
)->size
,
1101 obj_bsssec (abfd
)->alignment_power
);
1105 switch (adata (abfd
).magic
)
1108 adjust_o_magic (abfd
, execp
);
1111 adjust_z_magic (abfd
, execp
);
1114 adjust_n_magic (abfd
, execp
);
1117 adjust_i_magic (abfd
, execp
);
1123 #ifdef BFD_AOUT_DEBUG
1124 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1125 obj_textsec (abfd
)->vma
, execp
->a_text
,
1126 obj_textsec (abfd
)->filepos
,
1127 obj_datasec (abfd
)->vma
, execp
->a_data
,
1128 obj_datasec (abfd
)->filepos
,
1129 obj_bsssec (abfd
)->vma
, execp
->a_bss
);
1135 /* Called by the BFD in response to a bfd_make_section request. */
1138 NAME (aout
, new_section_hook
) (bfd
*abfd
, asection
*newsect
)
1140 /* Align to double at least. */
1141 newsect
->alignment_power
= bfd_get_arch_info(abfd
)->section_align_power
;
1143 if (bfd_get_format (abfd
) == bfd_object
)
1145 if (obj_textsec (abfd
) == NULL
1146 && !strcmp (newsect
->name
, ".text"))
1148 obj_textsec(abfd
)= newsect
;
1149 newsect
->target_index
= N_TEXT
;
1151 else if (obj_datasec (abfd
) == NULL
1152 && !strcmp (newsect
->name
, ".data"))
1154 obj_datasec (abfd
) = newsect
;
1155 newsect
->target_index
= N_DATA
;
1157 else if (obj_bsssec (abfd
) == NULL
1158 && !strcmp (newsect
->name
, ".bss"))
1160 obj_bsssec (abfd
) = newsect
;
1161 newsect
->target_index
= N_BSS
;
1165 /* We allow more than three sections internally. */
1166 return _bfd_generic_new_section_hook (abfd
, newsect
);
1170 NAME (aout
, set_section_contents
) (bfd
*abfd
,
1172 const void * location
,
1174 bfd_size_type count
)
1176 if (! abfd
->output_has_begun
)
1178 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
1182 if (section
== obj_bsssec (abfd
))
1184 bfd_set_error (bfd_error_no_contents
);
1188 if (section
!= obj_textsec (abfd
)
1189 && section
!= obj_datasec (abfd
))
1192 /* xgettext:c-format */
1193 (_("%pB: can not represent section `%pA' in a.out object file format"),
1195 bfd_set_error (bfd_error_nonrepresentable_section
);
1201 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
1202 || bfd_bwrite (location
, count
, abfd
) != count
)
1209 /* Read the external symbols from an a.out file. */
1212 aout_get_external_symbols (bfd
*abfd
)
1214 if (obj_aout_external_syms (abfd
) == NULL
)
1216 bfd_size_type count
;
1217 struct external_nlist
*syms
;
1219 count
= exec_hdr (abfd
)->a_syms
/ EXTERNAL_NLIST_SIZE
;
1221 /* PR 17512: file: 011f5a08. */
1224 obj_aout_external_syms (abfd
) = NULL
;
1225 obj_aout_external_sym_count (abfd
) = count
;
1230 if (! bfd_get_file_window (abfd
, obj_sym_filepos (abfd
),
1231 exec_hdr (abfd
)->a_syms
,
1232 &obj_aout_sym_window (abfd
), TRUE
))
1234 syms
= (struct external_nlist
*) obj_aout_sym_window (abfd
).data
;
1236 /* We allocate using malloc to make the values easy to free
1237 later on. If we put them on the objalloc it might not be
1238 possible to free them. */
1239 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1241 syms
= (struct external_nlist
*)
1242 _bfd_malloc_and_read (abfd
, count
* EXTERNAL_NLIST_SIZE
,
1243 count
* EXTERNAL_NLIST_SIZE
);
1244 if (syms
== NULL
&& count
!= 0)
1248 obj_aout_external_syms (abfd
) = syms
;
1249 obj_aout_external_sym_count (abfd
) = count
;
1252 if (obj_aout_external_strings (abfd
) == NULL
1253 && exec_hdr (abfd
)->a_syms
!= 0)
1255 unsigned char string_chars
[BYTES_IN_LONG
];
1256 bfd_size_type stringsize
;
1259 /* Get the size of the strings. */
1260 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
1261 || (bfd_bread ((void *) string_chars
, (bfd_size_type
) BYTES_IN_LONG
,
1262 abfd
) != BYTES_IN_LONG
))
1264 stringsize
= H_GET_32 (abfd
, string_chars
);
1267 if (! bfd_get_file_window (abfd
, obj_str_filepos (abfd
), stringsize
,
1268 &obj_aout_string_window (abfd
), TRUE
))
1270 strings
= (char *) obj_aout_string_window (abfd
).data
;
1272 strings
= bfd_malloc (stringsize
+ 1);
1273 if (strings
== NULL
)
1276 /* Skip space for the string count in the buffer for convenience
1277 when using indexes. */
1278 if (bfd_bread (strings
+ 4, stringsize
- 4, abfd
) != stringsize
- 4)
1284 /* Ensure that a zero index yields an empty string. */
1287 strings
[stringsize
- 1] = 0;
1289 obj_aout_external_strings (abfd
) = strings
;
1290 obj_aout_external_string_size (abfd
) = stringsize
;
1296 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1297 and symbol->value fields of CACHE_PTR will be set from the a.out
1298 nlist structure. This function is responsible for setting
1299 symbol->flags and symbol->section, and adjusting symbol->value. */
1302 translate_from_native_sym_flags (bfd
*abfd
,
1303 aout_symbol_type
*cache_ptr
)
1307 if (cache_ptr
->type
== N_FN
)
1311 /* This is a debugging symbol. */
1312 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1314 /* Work out the symbol section. */
1315 switch (cache_ptr
->type
& N_TYPE
)
1319 sec
= obj_textsec (abfd
);
1322 sec
= obj_datasec (abfd
);
1325 sec
= obj_bsssec (abfd
);
1329 sec
= bfd_abs_section_ptr
;
1333 cache_ptr
->symbol
.section
= sec
;
1334 cache_ptr
->symbol
.value
-= sec
->vma
;
1339 /* Get the default visibility. This does not apply to all types, so
1340 we just hold it in a local variable to use if wanted. */
1341 if ((cache_ptr
->type
& N_EXT
) == 0)
1342 visible
= BSF_LOCAL
;
1344 visible
= BSF_GLOBAL
;
1346 switch (cache_ptr
->type
)
1349 case N_ABS
: case N_ABS
| N_EXT
:
1350 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1351 cache_ptr
->symbol
.flags
= visible
;
1354 case N_UNDF
| N_EXT
:
1355 if (cache_ptr
->symbol
.value
!= 0)
1357 /* This is a common symbol. */
1358 cache_ptr
->symbol
.flags
= BSF_GLOBAL
;
1359 cache_ptr
->symbol
.section
= bfd_com_section_ptr
;
1363 cache_ptr
->symbol
.flags
= 0;
1364 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1368 case N_TEXT
: case N_TEXT
| N_EXT
:
1369 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1370 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1371 cache_ptr
->symbol
.flags
= visible
;
1374 case N_DATA
: case N_DATA
| N_EXT
:
1375 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1376 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1377 cache_ptr
->symbol
.flags
= visible
;
1380 case N_BSS
: case N_BSS
| N_EXT
:
1381 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1382 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1383 cache_ptr
->symbol
.flags
= visible
;
1390 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1393 translate_to_native_sym_flags (bfd
*abfd
,
1395 struct external_nlist
*sym_pointer
)
1397 bfd_vma value
= cache_ptr
->value
;
1401 /* Mask out any existing type bits in case copying from one section
1403 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1405 sec
= bfd_asymbol_section (cache_ptr
);
1410 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1413 /* xgettext:c-format */
1414 (_("%pB: can not represent section for symbol `%s' in a.out object file format"),
1415 abfd
, cache_ptr
->name
!= NULL
? cache_ptr
->name
: "*unknown*");
1416 bfd_set_error (bfd_error_nonrepresentable_section
);
1420 if (sec
->output_section
!= NULL
)
1422 off
= sec
->output_offset
;
1423 sec
= sec
->output_section
;
1426 if (bfd_is_abs_section (sec
))
1427 sym_pointer
->e_type
[0] |= N_ABS
;
1428 else if (sec
== obj_textsec (abfd
))
1429 sym_pointer
->e_type
[0] |= N_TEXT
;
1430 else if (sec
== obj_datasec (abfd
))
1431 sym_pointer
->e_type
[0] |= N_DATA
;
1432 else if (sec
== obj_bsssec (abfd
))
1433 sym_pointer
->e_type
[0] |= N_BSS
;
1434 else if (bfd_is_und_section (sec
))
1435 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1436 else if (bfd_is_com_section (sec
))
1437 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1441 /* xgettext:c-format */
1442 (_("%pB: can not represent section `%pA' in a.out object file format"),
1444 bfd_set_error (bfd_error_nonrepresentable_section
);
1448 /* Turn the symbol from section relative to absolute again */
1449 value
+= sec
->vma
+ off
;
1451 if ((cache_ptr
->flags
& BSF_DEBUGGING
) != 0)
1452 sym_pointer
->e_type
[0] = ((aout_symbol_type
*) cache_ptr
)->type
;
1453 else if ((cache_ptr
->flags
& BSF_GLOBAL
) != 0)
1454 sym_pointer
->e_type
[0] |= N_EXT
;
1456 PUT_WORD(abfd
, value
, sym_pointer
->e_value
);
1461 /* Native-level interface to symbols. */
1464 NAME (aout
, make_empty_symbol
) (bfd
*abfd
)
1466 size_t amt
= sizeof (aout_symbol_type
);
1467 aout_symbol_type
*new_symbol_type
= bfd_zalloc (abfd
, amt
);
1469 if (!new_symbol_type
)
1471 new_symbol_type
->symbol
.the_bfd
= abfd
;
1473 return &new_symbol_type
->symbol
;
1476 /* Translate a set of internal symbols into external symbols. */
1479 NAME (aout
, translate_symbol_table
) (bfd
*abfd
,
1480 aout_symbol_type
*in
,
1481 struct external_nlist
*ext
,
1482 bfd_size_type count
,
1484 bfd_size_type strsize
,
1485 bfd_boolean dynamic
)
1487 struct external_nlist
*ext_end
;
1489 ext_end
= ext
+ count
;
1490 for (; ext
< ext_end
; ext
++, in
++)
1494 x
= GET_WORD (abfd
, ext
->e_strx
);
1495 in
->symbol
.the_bfd
= abfd
;
1497 /* For the normal symbols, the zero index points at the number
1498 of bytes in the string table but is to be interpreted as the
1499 null string. For the dynamic symbols, the number of bytes in
1500 the string table is stored in the __DYNAMIC structure and the
1501 zero index points at an actual string. */
1502 if (x
== 0 && ! dynamic
)
1503 in
->symbol
.name
= "";
1504 else if (x
< strsize
)
1505 in
->symbol
.name
= str
+ x
;
1509 in
->symbol
.value
= GET_WORD (abfd
, ext
->e_value
);
1510 /* TODO: is 0 a safe value here? */
1513 in
->type
= H_GET_8 (abfd
, ext
->e_type
);
1514 in
->symbol
.udata
.p
= NULL
;
1516 if (! translate_from_native_sym_flags (abfd
, in
))
1520 in
->symbol
.flags
|= BSF_DYNAMIC
;
1526 /* We read the symbols into a buffer, which is discarded when this
1527 function exits. We read the strings into a buffer large enough to
1528 hold them all plus all the cached symbol entries. */
1531 NAME (aout
, slurp_symbol_table
) (bfd
*abfd
)
1533 struct external_nlist
*old_external_syms
;
1534 aout_symbol_type
*cached
;
1535 bfd_size_type cached_size
;
1537 /* If there's no work to be done, don't do any. */
1538 if (obj_aout_symbols (abfd
) != NULL
)
1541 old_external_syms
= obj_aout_external_syms (abfd
);
1543 if (! aout_get_external_symbols (abfd
))
1546 cached_size
= obj_aout_external_sym_count (abfd
);
1547 cached_size
*= sizeof (aout_symbol_type
);
1548 cached
= bfd_zmalloc (cached_size
);
1549 if (cached
== NULL
&& cached_size
!= 0)
1552 /* Convert from external symbol information to internal. */
1553 if (! (NAME (aout
, translate_symbol_table
)
1555 obj_aout_external_syms (abfd
),
1556 obj_aout_external_sym_count (abfd
),
1557 obj_aout_external_strings (abfd
),
1558 obj_aout_external_string_size (abfd
),
1565 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
1567 obj_aout_symbols (abfd
) = cached
;
1569 /* It is very likely that anybody who calls this function will not
1570 want the external symbol information, so if it was allocated
1571 because of our call to aout_get_external_symbols, we free it up
1572 right away to save space. */
1573 if (old_external_syms
== NULL
1574 && obj_aout_external_syms (abfd
) != NULL
)
1577 bfd_free_window (&obj_aout_sym_window (abfd
));
1579 free (obj_aout_external_syms (abfd
));
1581 obj_aout_external_syms (abfd
) = NULL
;
1587 /* We use a hash table when writing out symbols so that we only write
1588 out a particular string once. This helps particularly when the
1589 linker writes out stabs debugging entries, because each different
1590 contributing object file tends to have many duplicate stabs
1593 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1594 if BFD_TRADITIONAL_FORMAT is set. */
1596 /* Get the index of a string in a strtab, adding it if it is not
1599 static INLINE bfd_size_type
1600 add_to_stringtab (bfd
*abfd
,
1601 struct bfd_strtab_hash
*tab
,
1606 bfd_size_type str_index
;
1608 /* An index of 0 always means the empty string. */
1609 if (str
== 0 || *str
== '\0')
1612 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1613 doesn't understand a hashed string table. */
1615 if ((abfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1618 str_index
= _bfd_stringtab_add (tab
, str
, hash
, copy
);
1620 if (str_index
!= (bfd_size_type
) -1)
1621 /* Add BYTES_IN_LONG to the return value to account for the
1622 space taken up by the string table size. */
1623 str_index
+= BYTES_IN_LONG
;
1628 /* Write out a strtab. ABFD is already at the right location in the
1632 emit_stringtab (bfd
*abfd
, struct bfd_strtab_hash
*tab
)
1634 bfd_byte buffer
[BYTES_IN_LONG
];
1636 /* The string table starts with the size. */
1637 H_PUT_32 (abfd
, _bfd_stringtab_size (tab
) + BYTES_IN_LONG
, buffer
);
1638 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) BYTES_IN_LONG
, abfd
)
1642 return _bfd_stringtab_emit (abfd
, tab
);
1646 NAME (aout
, write_syms
) (bfd
*abfd
)
1648 unsigned int count
;
1649 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1650 struct bfd_strtab_hash
*strtab
;
1652 strtab
= _bfd_stringtab_init ();
1656 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1658 asymbol
*g
= generic
[count
];
1660 struct external_nlist nsp
;
1662 PUT_WORD (abfd
, 0, nsp
.e_unused
);
1664 indx
= add_to_stringtab (abfd
, strtab
, g
->name
, FALSE
);
1665 if (indx
== (bfd_size_type
) -1)
1667 PUT_WORD (abfd
, indx
, nsp
.e_strx
);
1669 if (bfd_asymbol_flavour(g
) == abfd
->xvec
->flavour
)
1670 H_PUT_8 (abfd
, aout_symbol(g
)->type
, nsp
.e_type
);
1672 H_PUT_8 (abfd
, 0, nsp
.e_type
);
1674 if (! translate_to_native_sym_flags (abfd
, g
, &nsp
))
1677 H_PUT_8 (abfd
, 0, nsp
.e_ovly
);
1679 if (bfd_bwrite ((void *)&nsp
, (bfd_size_type
) EXTERNAL_NLIST_SIZE
, abfd
)
1680 != EXTERNAL_NLIST_SIZE
)
1683 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1684 here, at the end. */
1688 if (! emit_stringtab (abfd
, strtab
))
1691 _bfd_stringtab_free (strtab
);
1696 _bfd_stringtab_free (strtab
);
1702 NAME (aout
, canonicalize_symtab
) (bfd
*abfd
, asymbol
**location
)
1704 unsigned int counter
= 0;
1705 aout_symbol_type
*symbase
;
1707 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
1710 for (symbase
= obj_aout_symbols (abfd
); counter
++ < bfd_get_symcount (abfd
);)
1711 *(location
++) = (asymbol
*)(symbase
++);
1713 return bfd_get_symcount (abfd
);
1717 /* Output extended relocation information to a file in target byte order. */
1720 pdp11_aout_swap_reloc_out (bfd
*abfd
, arelent
*g
, bfd_byte
*natptr
)
1726 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1727 asection
*output_section
= sym
->section
->output_section
;
1730 fprintf (stderr
, "BFD: can't do this reloc addend stuff\n");
1732 r_pcrel
= g
->howto
->pc_relative
;
1734 if (bfd_is_abs_section (output_section
))
1736 else if (output_section
== obj_textsec (abfd
))
1738 else if (output_section
== obj_datasec (abfd
))
1740 else if (output_section
== obj_bsssec (abfd
))
1742 else if (bfd_is_und_section (output_section
))
1744 else if (bfd_is_com_section (output_section
))
1749 BFD_ASSERT (r_type
!= -1);
1754 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
1756 reloc_entry
= r_index
<< 4 | r_type
| r_pcrel
;
1758 PUT_WORD (abfd
, reloc_entry
, natptr
);
1761 /* BFD deals internally with all things based from the section they're
1762 in. so, something in 10 bytes into a text section with a base of
1763 50 would have a symbol (.text+10) and know .text vma was 50.
1765 Aout keeps all it's symbols based from zero, so the symbol would
1766 contain 60. This macro subs the base of each section from the value
1767 to give the true offset from the section */
1770 #define MOVE_ADDRESS(ad) \
1773 /* Undefined symbol. */ \
1774 cache_ptr->sym_ptr_ptr = symbols + r_index; \
1775 cache_ptr->addend = ad; \
1779 /* Defined, section relative. replace symbol with pointer to \
1780 symbol which points to section. */ \
1784 case N_TEXT | N_EXT: \
1785 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
1786 cache_ptr->addend = ad - su->textsec->vma; \
1789 case N_DATA | N_EXT: \
1790 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
1791 cache_ptr->addend = ad - su->datasec->vma; \
1794 case N_BSS | N_EXT: \
1795 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
1796 cache_ptr->addend = ad - su->bsssec->vma; \
1800 case N_ABS | N_EXT: \
1801 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1802 cache_ptr->addend = ad; \
1808 pdp11_aout_swap_reloc_in (bfd
* abfd
,
1810 arelent
* cache_ptr
,
1811 bfd_size_type offset
,
1813 bfd_size_type symcount
)
1815 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
1816 unsigned int r_index
;
1821 reloc_entry
= GET_WORD (abfd
, (void *) bytes
);
1823 r_pcrel
= reloc_entry
& RELFLG
;
1825 cache_ptr
->address
= offset
;
1826 cache_ptr
->howto
= howto_table_pdp11
+ (r_pcrel
? 1 : 0);
1828 if ((reloc_entry
& RTYPE
) == RABS
)
1831 r_index
= RINDEX (reloc_entry
);
1833 /* r_extern reflects whether the symbol the reloc is against is
1835 r_extern
= (reloc_entry
& RTYPE
) == REXT
;
1837 if (r_extern
&& r_index
> symcount
)
1839 /* We could arrange to return an error, but it might be useful
1840 to see the file even if it is bad. */
1848 /* Read and swap the relocs for a section. */
1851 NAME (aout
, slurp_reloc_table
) (bfd
*abfd
, sec_ptr asect
, asymbol
**symbols
)
1854 bfd_size_type count
;
1855 bfd_size_type reloc_size
;
1857 arelent
*reloc_cache
;
1859 unsigned int counter
= 0;
1862 if (asect
->relocation
)
1865 if (asect
->flags
& SEC_CONSTRUCTOR
)
1868 if (asect
== obj_datasec (abfd
))
1869 reloc_size
= exec_hdr(abfd
)->a_drsize
;
1870 else if (asect
== obj_textsec (abfd
))
1871 reloc_size
= exec_hdr(abfd
)->a_trsize
;
1872 else if (asect
== obj_bsssec (abfd
))
1876 bfd_set_error (bfd_error_invalid_operation
);
1880 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
1882 relocs
= _bfd_malloc_and_read (abfd
, reloc_size
, reloc_size
);
1883 if (relocs
== NULL
&& reloc_size
!= 0)
1886 each_size
= obj_reloc_entry_size (abfd
);
1887 count
= reloc_size
/ each_size
;
1889 /* Count the number of NON-ZERO relocs, this is the count we want. */
1891 unsigned int real_count
= 0;
1893 for (counter
= 0; counter
< count
; counter
++)
1897 x
= GET_WORD (abfd
, (char *) relocs
+ each_size
* counter
);
1905 reloc_cache
= bfd_zmalloc (count
* sizeof (arelent
));
1906 if (reloc_cache
== NULL
&& count
!= 0)
1909 cache_ptr
= reloc_cache
;
1914 counter
++, rptr
+= RELOC_SIZE
, cache_ptr
++)
1916 while (GET_WORD (abfd
, (void *) rptr
) == 0)
1919 if ((char *) rptr
>= (char *) relocs
+ reloc_size
)
1923 pdp11_aout_swap_reloc_in (abfd
, rptr
, cache_ptr
,
1924 (bfd_size_type
) ((char *) rptr
- (char *) relocs
),
1926 (bfd_size_type
) bfd_get_symcount (abfd
));
1929 /* Just in case, if rptr >= relocs + reloc_size should happen
1931 BFD_ASSERT (counter
== count
);
1935 asect
->relocation
= reloc_cache
;
1936 asect
->reloc_count
= cache_ptr
- reloc_cache
;
1941 /* Write out a relocation section into an object file. */
1944 NAME (aout
, squirt_out_relocs
) (bfd
*abfd
, asection
*section
)
1947 unsigned char *native
;
1948 unsigned int count
= section
->reloc_count
;
1949 bfd_size_type natsize
;
1951 natsize
= section
->size
;
1952 native
= bfd_zalloc (abfd
, natsize
);
1956 generic
= section
->orelocation
;
1957 if (generic
!= NULL
)
1963 r
= native
+ (*generic
)->address
;
1964 pdp11_aout_swap_reloc_out (abfd
, *generic
, r
);
1970 if (bfd_bwrite ((void *) native
, natsize
, abfd
) != natsize
)
1972 bfd_release (abfd
, native
);
1976 bfd_release (abfd
, native
);
1980 /* This is stupid. This function should be a boolean predicate. */
1983 NAME (aout
, canonicalize_reloc
) (bfd
*abfd
,
1988 arelent
*tblptr
= section
->relocation
;
1991 if (section
== obj_bsssec (abfd
))
1997 if (!(tblptr
|| NAME (aout
, slurp_reloc_table
)(abfd
, section
, symbols
)))
2000 if (section
->flags
& SEC_CONSTRUCTOR
)
2002 arelent_chain
*chain
= section
->constructor_chain
;
2004 for (count
= 0; count
< section
->reloc_count
; count
++)
2006 *relptr
++ = &chain
->relent
;
2007 chain
= chain
->next
;
2012 tblptr
= section
->relocation
;
2014 for (count
= 0; count
++ < section
->reloc_count
;)
2015 *relptr
++ = tblptr
++;
2020 return section
->reloc_count
;
2024 NAME (aout
, get_reloc_upper_bound
) (bfd
*abfd
, sec_ptr asect
)
2026 bfd_size_type count
;
2028 if (bfd_get_format (abfd
) != bfd_object
)
2030 bfd_set_error (bfd_error_invalid_operation
);
2034 if (asect
->flags
& SEC_CONSTRUCTOR
)
2035 count
= asect
->reloc_count
;
2036 else if (asect
== obj_datasec (abfd
))
2037 count
= exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
2038 else if (asect
== obj_textsec (abfd
))
2039 count
= exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
2040 else if (asect
== obj_bsssec (abfd
))
2044 bfd_set_error (bfd_error_invalid_operation
);
2048 if (count
>= LONG_MAX
/ sizeof (arelent
*))
2050 bfd_set_error (bfd_error_file_too_big
);
2053 return (count
+ 1) * sizeof (arelent
*);
2058 NAME (aout
, get_symtab_upper_bound
) (bfd
*abfd
)
2060 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
2063 return (bfd_get_symcount (abfd
) + 1) * (sizeof (aout_symbol_type
*));
2067 NAME (aout
, get_lineno
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2068 asymbol
* symbol ATTRIBUTE_UNUSED
)
2074 NAME (aout
, get_symbol_info
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2078 bfd_symbol_info (symbol
, ret
);
2080 if (ret
->type
== '?')
2082 int type_code
= aout_symbol(symbol
)->type
& 0xff;
2083 const char *stab_name
= bfd_get_stab_name (type_code
);
2084 static char buf
[10];
2086 if (stab_name
== NULL
)
2088 sprintf(buf
, "(%d)", type_code
);
2092 ret
->stab_type
= type_code
;
2093 ret
->stab_other
= (unsigned) (aout_symbol(symbol
)->other
& 0xff);
2094 ret
->stab_desc
= (unsigned) (aout_symbol(symbol
)->desc
& 0xffff);
2095 ret
->stab_name
= stab_name
;
2100 NAME (aout
, print_symbol
) (bfd
* abfd
,
2103 bfd_print_symbol_type how
)
2105 FILE *file
= (FILE *) afile
;
2109 case bfd_print_symbol_name
:
2111 fprintf(file
,"%s", symbol
->name
);
2113 case bfd_print_symbol_more
:
2114 fprintf(file
,"%4x %2x %2x",
2115 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2116 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2117 (unsigned) (aout_symbol (symbol
)->type
));
2119 case bfd_print_symbol_all
:
2121 const char *section_name
= symbol
->section
->name
;
2123 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2125 fprintf (file
," %-5s %04x %02x %02x",
2127 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2128 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2129 (unsigned) (aout_symbol (symbol
)->type
& 0xff));
2131 fprintf(file
," %s", symbol
->name
);
2137 /* If we don't have to allocate more than 1MB to hold the generic
2138 symbols, we use the generic minisymbol method: it's faster, since
2139 it only translates the symbols once, not multiple times. */
2140 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2142 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2143 symbols. The minisymbol_to_symbol function translates these into
2144 BFD asymbol structures. */
2147 NAME (aout
, read_minisymbols
) (bfd
*abfd
,
2148 bfd_boolean dynamic
,
2150 unsigned int *sizep
)
2153 /* We could handle the dynamic symbols here as well, but it's
2154 easier to hand them off. */
2155 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2157 if (! aout_get_external_symbols (abfd
))
2160 if (obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2161 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2163 *minisymsp
= (void *) obj_aout_external_syms (abfd
);
2165 /* By passing the external symbols back from this routine, we are
2166 giving up control over the memory block. Clear
2167 obj_aout_external_syms, so that we do not try to free it
2169 obj_aout_external_syms (abfd
) = NULL
;
2171 *sizep
= EXTERNAL_NLIST_SIZE
;
2172 return obj_aout_external_sym_count (abfd
);
2175 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2176 unmodified a.out symbol. The SYM argument is a structure returned
2177 by bfd_make_empty_symbol, which we fill in here. */
2180 NAME (aout
, minisymbol_to_symbol
) (bfd
*abfd
,
2181 bfd_boolean dynamic
,
2182 const void * minisym
,
2186 || obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2187 return _bfd_generic_minisymbol_to_symbol (abfd
, dynamic
, minisym
, sym
);
2189 memset (sym
, 0, sizeof (aout_symbol_type
));
2191 /* We call translate_symbol_table to translate a single symbol. */
2192 if (! (NAME (aout
, translate_symbol_table
)
2194 (aout_symbol_type
*) sym
,
2195 (struct external_nlist
*) minisym
,
2197 obj_aout_external_strings (abfd
),
2198 obj_aout_external_string_size (abfd
),
2205 /* Provided a BFD, a section and an offset into the section, calculate
2206 and return the name of the source file and the line nearest to the
2210 NAME (aout
, find_nearest_line
) (bfd
*abfd
,
2214 const char **filename_ptr
,
2215 const char **functionname_ptr
,
2216 unsigned int *line_ptr
,
2217 unsigned int *discriminator_ptr
)
2219 /* Run down the file looking for the filename, function and linenumber. */
2221 const char *directory_name
= NULL
;
2222 const char *main_file_name
= NULL
;
2223 const char *current_file_name
= NULL
;
2224 const char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2225 bfd_vma low_line_vma
= 0;
2226 bfd_vma low_func_vma
= 0;
2228 size_t filelen
, funclen
;
2231 *filename_ptr
= bfd_get_filename (abfd
);
2232 *functionname_ptr
= 0;
2234 if (discriminator_ptr
)
2235 *discriminator_ptr
= 0;
2237 if (symbols
!= NULL
)
2239 for (p
= symbols
; *p
; p
++)
2241 aout_symbol_type
*q
= (aout_symbol_type
*)(*p
);
2246 /* If this looks like a file name symbol, and it comes after
2247 the line number we have found so far, but before the
2248 offset, then we have probably not found the right line
2250 if (q
->symbol
.value
<= offset
2251 && ((q
->symbol
.value
> low_line_vma
2252 && (line_file_name
!= NULL
2254 || (q
->symbol
.value
> low_func_vma
2257 const char * symname
;
2259 symname
= q
->symbol
.name
;
2260 if (strcmp (symname
+ strlen (symname
) - 2, ".o") == 0)
2262 if (q
->symbol
.value
> low_line_vma
)
2265 line_file_name
= NULL
;
2267 if (q
->symbol
.value
> low_func_vma
)
2274 /* If this symbol is less than the offset, but greater than
2275 the line number we have found so far, then we have not
2276 found the right line number. */
2277 if (q
->symbol
.value
<= offset
)
2279 if (q
->symbol
.value
> low_line_vma
)
2282 line_file_name
= NULL
;
2284 if (q
->symbol
.value
> low_func_vma
)
2288 main_file_name
= current_file_name
= q
->symbol
.name
;
2289 /* Look ahead to next symbol to check if that too is an N_SO. */
2293 q
= (aout_symbol_type
*)(*p
);
2294 if (q
->type
!= (int) N_SO
)
2297 /* Found a second N_SO First is directory; second is filename. */
2298 directory_name
= current_file_name
;
2299 main_file_name
= current_file_name
= q
->symbol
.name
;
2300 if (obj_textsec(abfd
) != section
)
2304 current_file_name
= q
->symbol
.name
;
2310 /* We'll keep this if it resolves nearer than the one we have
2312 if (q
->symbol
.value
>= low_line_vma
2313 && q
->symbol
.value
<= offset
)
2315 *line_ptr
= q
->desc
;
2316 low_line_vma
= q
->symbol
.value
;
2317 line_file_name
= current_file_name
;
2323 /* We'll keep this if it is nearer than the one we have already. */
2324 if (q
->symbol
.value
>= low_func_vma
&&
2325 q
->symbol
.value
<= offset
)
2327 low_func_vma
= q
->symbol
.value
;
2328 func
= (asymbol
*) q
;
2330 else if (q
->symbol
.value
> offset
)
2340 main_file_name
= line_file_name
;
2342 if (main_file_name
== NULL
2343 || main_file_name
[0] == '/'
2344 || directory_name
== NULL
)
2347 filelen
= strlen (directory_name
) + strlen (main_file_name
);
2351 funclen
= strlen (bfd_asymbol_name (func
));
2353 free (adata (abfd
).line_buf
);
2354 if (filelen
+ funclen
== 0)
2355 adata (abfd
).line_buf
= buf
= NULL
;
2358 buf
= bfd_malloc ((bfd_size_type
) filelen
+ funclen
+ 3);
2359 adata (abfd
).line_buf
= buf
;
2364 if (main_file_name
!= NULL
)
2366 if (main_file_name
[0] == '/' || directory_name
== NULL
)
2367 *filename_ptr
= main_file_name
;
2370 sprintf (buf
, "%s%s", directory_name
, main_file_name
);
2371 *filename_ptr
= buf
;
2378 const char *function
= func
->name
;
2381 /* The caller expects a symbol name. We actually have a
2382 function name, without the leading underscore. Put the
2383 underscore back in, so that the caller gets a symbol name. */
2384 if (bfd_get_symbol_leading_char (abfd
) == '\0')
2385 strcpy (buf
, function
);
2388 buf
[0] = bfd_get_symbol_leading_char (abfd
);
2389 strcpy (buf
+ 1, function
);
2392 /* Have to remove : stuff. */
2393 colon
= strchr (buf
, ':');
2396 *functionname_ptr
= buf
;
2403 NAME (aout
, sizeof_headers
) (bfd
*abfd
,
2404 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2406 return adata (abfd
).exec_bytes_size
;
2409 /* Free all information we have cached for this BFD. We can always
2410 read it again later if we need it. */
2413 NAME (aout
, bfd_free_cached_info
) (bfd
*abfd
)
2417 if (bfd_get_format (abfd
) != bfd_object
)
2420 #define BFCI_FREE(x) do { free (x); x = NULL; } while (0)
2421 BFCI_FREE (obj_aout_symbols (abfd
));
2424 obj_aout_external_syms (abfd
) = 0;
2425 bfd_free_window (&obj_aout_sym_window (abfd
));
2426 bfd_free_window (&obj_aout_string_window (abfd
));
2427 obj_aout_external_strings (abfd
) = 0;
2429 BFCI_FREE (obj_aout_external_syms (abfd
));
2430 BFCI_FREE (obj_aout_external_strings (abfd
));
2432 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2433 BFCI_FREE (o
->relocation
);
2439 /* Routine to create an entry in an a.out link hash table. */
2441 struct bfd_hash_entry
*
2442 NAME (aout
, link_hash_newfunc
) (struct bfd_hash_entry
*entry
,
2443 struct bfd_hash_table
*table
,
2446 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2448 /* Allocate the structure if it has not already been allocated by a
2451 ret
= bfd_hash_allocate (table
, sizeof (* ret
));
2455 /* Call the allocation method of the superclass. */
2456 ret
= (struct aout_link_hash_entry
*)
2457 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
);
2460 /* Set local fields. */
2461 ret
->written
= FALSE
;
2465 return (struct bfd_hash_entry
*) ret
;
2468 /* Initialize an a.out link hash table. */
2471 NAME (aout
, link_hash_table_init
) (struct aout_link_hash_table
*table
,
2473 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
2474 struct bfd_hash_table
*,
2476 unsigned int entsize
)
2478 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
2481 /* Create an a.out link hash table. */
2483 struct bfd_link_hash_table
*
2484 NAME (aout
, link_hash_table_create
) (bfd
*abfd
)
2486 struct aout_link_hash_table
*ret
;
2487 size_t amt
= sizeof (struct aout_link_hash_table
);
2489 ret
= bfd_malloc (amt
);
2492 if (! NAME (aout
, link_hash_table_init
) (ret
, abfd
,
2493 NAME (aout
, link_hash_newfunc
),
2494 sizeof (struct aout_link_hash_entry
)))
2502 /* Free up the internal symbols read from an a.out file. */
2505 aout_link_free_symbols (bfd
*abfd
)
2507 if (obj_aout_external_syms (abfd
) != NULL
)
2510 bfd_free_window (&obj_aout_sym_window (abfd
));
2512 free ((void *) obj_aout_external_syms (abfd
));
2514 obj_aout_external_syms (abfd
) = NULL
;
2517 if (obj_aout_external_strings (abfd
) != NULL
)
2520 bfd_free_window (&obj_aout_string_window (abfd
));
2522 free ((void *) obj_aout_external_strings (abfd
));
2524 obj_aout_external_strings (abfd
) = NULL
;
2529 /* Given an a.out BFD, add symbols to the global hash table as
2533 NAME (aout
, link_add_symbols
) (bfd
*abfd
, struct bfd_link_info
*info
)
2535 switch (bfd_get_format (abfd
))
2538 return aout_link_add_object_symbols (abfd
, info
);
2540 return _bfd_generic_link_add_archive_symbols
2541 (abfd
, info
, aout_link_check_archive_element
);
2543 bfd_set_error (bfd_error_wrong_format
);
2548 /* Add symbols from an a.out object file. */
2551 aout_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2553 if (! aout_get_external_symbols (abfd
))
2555 if (! aout_link_add_symbols (abfd
, info
))
2557 if (! info
->keep_memory
)
2559 if (! aout_link_free_symbols (abfd
))
2565 /* Look through the internal symbols to see if this object file should
2566 be included in the link. We should include this object file if it
2567 defines any symbols which are currently undefined. If this object
2568 file defines a common symbol, then we may adjust the size of the
2569 known symbol but we do not include the object file in the link
2570 (unless there is some other reason to include it). */
2573 aout_link_check_ar_symbols (bfd
*abfd
,
2574 struct bfd_link_info
*info
,
2575 bfd_boolean
*pneeded
,
2578 struct external_nlist
*p
;
2579 struct external_nlist
*pend
;
2584 /* Look through all the symbols. */
2585 p
= obj_aout_external_syms (abfd
);
2586 pend
= p
+ obj_aout_external_sym_count (abfd
);
2587 strings
= obj_aout_external_strings (abfd
);
2588 for (; p
< pend
; p
++)
2590 int type
= H_GET_8 (abfd
, p
->e_type
);
2592 struct bfd_link_hash_entry
*h
;
2594 /* Ignore symbols that are not externally visible. This is an
2595 optimization only, as we check the type more thoroughly
2597 if ((type
& N_EXT
) == 0
2601 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2602 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
2604 /* We are only interested in symbols that are currently
2605 undefined or common. */
2607 || (h
->type
!= bfd_link_hash_undefined
2608 && h
->type
!= bfd_link_hash_common
))
2611 if (type
== (N_TEXT
| N_EXT
)
2612 || type
== (N_DATA
| N_EXT
)
2613 || type
== (N_BSS
| N_EXT
)
2614 || type
== (N_ABS
| N_EXT
))
2616 /* This object file defines this symbol. We must link it
2617 in. This is true regardless of whether the current
2618 definition of the symbol is undefined or common. If the
2619 current definition is common, we have a case in which we
2620 have already seen an object file including
2622 and this object file from the archive includes
2624 In such a case we must include this object file.
2626 FIXME: The SunOS 4.1.3 linker will pull in the archive
2627 element if the symbol is defined in the .data section,
2628 but not if it is defined in the .text section. That
2629 seems a bit crazy to me, and I haven't implemented it.
2630 However, it might be correct. */
2631 if (!(*info
->callbacks
2632 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2638 if (type
== (N_UNDF
| N_EXT
))
2642 value
= GET_WORD (abfd
, p
->e_value
);
2645 /* This symbol is common in the object from the archive
2647 if (h
->type
== bfd_link_hash_undefined
)
2652 symbfd
= h
->u
.undef
.abfd
;
2655 /* This symbol was created as undefined from
2656 outside BFD. We assume that we should link
2657 in the object file. This is done for the -u
2658 option in the linker. */
2659 if (!(*info
->callbacks
2660 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2665 /* Turn the current link symbol into a common
2666 symbol. It is already on the undefs list. */
2667 h
->type
= bfd_link_hash_common
;
2668 h
->u
.c
.p
= bfd_hash_allocate (&info
->hash
->table
,
2669 sizeof (struct bfd_link_hash_common_entry
));
2670 if (h
->u
.c
.p
== NULL
)
2673 h
->u
.c
.size
= value
;
2675 /* FIXME: This isn't quite right. The maximum
2676 alignment of a common symbol should be set by the
2677 architecture of the output file, not of the input
2679 power
= bfd_log2 (value
);
2680 if (power
> bfd_get_arch_info (abfd
)->section_align_power
)
2681 power
= bfd_get_arch_info (abfd
)->section_align_power
;
2682 h
->u
.c
.p
->alignment_power
= power
;
2684 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
,
2689 /* Adjust the size of the common symbol if
2691 if (value
> h
->u
.c
.size
)
2692 h
->u
.c
.size
= value
;
2698 /* We do not need this object file. */
2702 /* Check a single archive element to see if we need to include it in
2703 the link. *PNEEDED is set according to whether this element is
2704 needed in the link or not. This is called from
2705 _bfd_generic_link_add_archive_symbols. */
2708 aout_link_check_archive_element (bfd
*abfd
,
2709 struct bfd_link_info
*info
,
2710 struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
2711 const char *name ATTRIBUTE_UNUSED
,
2712 bfd_boolean
*pneeded
)
2717 if (!aout_get_external_symbols (abfd
))
2721 if (!aout_link_check_ar_symbols (abfd
, info
, pneeded
, &abfd
))
2727 /* Potentially, the add_archive_element hook may have set a
2728 substitute BFD for us. */
2731 if (!info
->keep_memory
2732 && !aout_link_free_symbols (oldbfd
))
2734 if (!aout_get_external_symbols (abfd
))
2737 if (!aout_link_add_symbols (abfd
, info
))
2741 if (!info
->keep_memory
|| !needed
)
2743 if (!aout_link_free_symbols (abfd
))
2750 /* Add all symbols from an object file to the hash table. */
2753 aout_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2755 bfd_boolean (*add_one_symbol
)
2756 (struct bfd_link_info
*, bfd
*, const char *, flagword
, asection
*,
2757 bfd_vma
, const char *, bfd_boolean
, bfd_boolean
,
2758 struct bfd_link_hash_entry
**);
2759 struct external_nlist
*syms
;
2760 bfd_size_type sym_count
;
2763 struct aout_link_hash_entry
**sym_hash
;
2764 struct external_nlist
*p
;
2765 struct external_nlist
*pend
;
2767 syms
= obj_aout_external_syms (abfd
);
2768 sym_count
= obj_aout_external_sym_count (abfd
);
2769 strings
= obj_aout_external_strings (abfd
);
2770 if (info
->keep_memory
)
2775 if (aout_backend_info (abfd
)->add_dynamic_symbols
!= NULL
)
2777 if (! ((*aout_backend_info (abfd
)->add_dynamic_symbols
)
2778 (abfd
, info
, &syms
, &sym_count
, &strings
)))
2782 /* We keep a list of the linker hash table entries that correspond
2783 to particular symbols. We could just look them up in the hash
2784 table, but keeping the list is more efficient. Perhaps this
2785 should be conditional on info->keep_memory. */
2786 sym_hash
= bfd_alloc (abfd
,
2787 sym_count
* sizeof (struct aout_link_hash_entry
*));
2788 if (sym_hash
== NULL
&& sym_count
!= 0)
2790 obj_aout_sym_hashes (abfd
) = sym_hash
;
2792 add_one_symbol
= aout_backend_info (abfd
)->add_one_symbol
;
2793 if (add_one_symbol
== NULL
)
2794 add_one_symbol
= _bfd_generic_link_add_one_symbol
;
2797 pend
= p
+ sym_count
;
2798 for (; p
< pend
; p
++, sym_hash
++)
2809 type
= H_GET_8 (abfd
, p
->e_type
);
2811 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2812 value
= GET_WORD (abfd
, p
->e_value
);
2818 /* Anything else should be a debugging symbol. */
2819 BFD_ASSERT ((type
& N_STAB
) != 0);
2829 /* Ignore symbols that are not externally visible. */
2832 case N_UNDF
| N_EXT
:
2835 section
= bfd_und_section_ptr
;
2839 section
= bfd_com_section_ptr
;
2842 section
= bfd_abs_section_ptr
;
2844 case N_TEXT
| N_EXT
:
2845 section
= obj_textsec (abfd
);
2846 value
-= bfd_section_vma (section
);
2848 case N_DATA
| N_EXT
:
2849 /* Treat N_SETV symbols as N_DATA symbol; see comment in
2850 translate_from_native_sym_flags. */
2851 section
= obj_datasec (abfd
);
2852 value
-= bfd_section_vma (section
);
2855 section
= obj_bsssec (abfd
);
2856 value
-= bfd_section_vma (section
);
2860 if (! ((*add_one_symbol
)
2861 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, FALSE
,
2862 (struct bfd_link_hash_entry
**) sym_hash
)))
2865 /* Restrict the maximum alignment of a common symbol based on
2866 the architecture, since a.out has no way to represent
2867 alignment requirements of a section in a .o file. FIXME:
2868 This isn't quite right: it should use the architecture of the
2869 output file, not the input files. */
2870 if ((*sym_hash
)->root
.type
== bfd_link_hash_common
2871 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
>
2872 bfd_get_arch_info (abfd
)->section_align_power
))
2873 (*sym_hash
)->root
.u
.c
.p
->alignment_power
=
2874 bfd_get_arch_info (abfd
)->section_align_power
;
2876 /* If this is a set symbol, and we are not building sets, then
2877 it is possible for the hash entry to not have been set. In
2878 such a case, treat the symbol as not globally defined. */
2879 if ((*sym_hash
)->root
.type
== bfd_link_hash_new
)
2881 BFD_ASSERT ((flags
& BSF_CONSTRUCTOR
) != 0);
2889 /* Look up an entry in an the header file hash table. */
2891 #define aout_link_includes_lookup(table, string, create, copy) \
2892 ((struct aout_link_includes_entry *) \
2893 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
2895 /* The function to create a new entry in the header file hash table. */
2897 static struct bfd_hash_entry
*
2898 aout_link_includes_newfunc (struct bfd_hash_entry
*entry
,
2899 struct bfd_hash_table
*table
,
2902 struct aout_link_includes_entry
* ret
=
2903 (struct aout_link_includes_entry
*) entry
;
2905 /* Allocate the structure if it has not already been allocated by a
2908 ret
= bfd_hash_allocate (table
,
2909 sizeof (struct aout_link_includes_entry
));
2913 /* Call the allocation method of the superclass. */
2914 ret
= ((struct aout_link_includes_entry
*)
2915 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
2917 /* Set local fields. */
2920 return (struct bfd_hash_entry
*) ret
;
2924 aout_link_write_other_symbol (struct bfd_hash_entry
*bh
, void *data
)
2926 struct aout_link_hash_entry
*h
= (struct aout_link_hash_entry
*) bh
;
2927 struct aout_final_link_info
*flaginfo
= (struct aout_final_link_info
*) data
;
2931 struct external_nlist outsym
;
2935 if (h
->root
.type
== bfd_link_hash_warning
)
2937 h
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
2938 if (h
->root
.type
== bfd_link_hash_new
)
2942 output_bfd
= flaginfo
->output_bfd
;
2944 if (aout_backend_info (output_bfd
)->write_dynamic_symbol
!= NULL
)
2946 if (! ((*aout_backend_info (output_bfd
)->write_dynamic_symbol
)
2947 (output_bfd
, flaginfo
->info
, h
)))
2949 /* FIXME: No way to handle errors. */
2959 /* An indx of -2 means the symbol must be written. */
2961 && (flaginfo
->info
->strip
== strip_all
2962 || (flaginfo
->info
->strip
== strip_some
2963 && bfd_hash_lookup (flaginfo
->info
->keep_hash
, h
->root
.root
.string
,
2964 FALSE
, FALSE
) == NULL
)))
2967 switch (h
->root
.type
)
2971 /* Avoid variable not initialized warnings. */
2973 case bfd_link_hash_new
:
2974 /* This can happen for set symbols when sets are not being
2977 case bfd_link_hash_undefined
:
2978 type
= N_UNDF
| N_EXT
;
2981 case bfd_link_hash_defined
:
2982 case bfd_link_hash_defweak
:
2986 sec
= h
->root
.u
.def
.section
->output_section
;
2987 BFD_ASSERT (bfd_is_abs_section (sec
)
2988 || sec
->owner
== output_bfd
);
2989 if (sec
== obj_textsec (output_bfd
))
2990 type
= h
->root
.type
== bfd_link_hash_defined
? N_TEXT
: N_WEAKT
;
2991 else if (sec
== obj_datasec (output_bfd
))
2992 type
= h
->root
.type
== bfd_link_hash_defined
? N_DATA
: N_WEAKD
;
2993 else if (sec
== obj_bsssec (output_bfd
))
2994 type
= h
->root
.type
== bfd_link_hash_defined
? N_BSS
: N_WEAKB
;
2996 type
= h
->root
.type
== bfd_link_hash_defined
? N_ABS
: N_WEAKA
;
2998 val
= (h
->root
.u
.def
.value
3000 + h
->root
.u
.def
.section
->output_offset
);
3003 case bfd_link_hash_common
:
3004 type
= N_UNDF
| N_EXT
;
3005 val
= h
->root
.u
.c
.size
;
3007 case bfd_link_hash_undefweak
:
3011 case bfd_link_hash_indirect
:
3012 case bfd_link_hash_warning
:
3013 /* FIXME: Ignore these for now. The circumstances under which
3014 they should be written out are not clear to me. */
3018 H_PUT_8 (output_bfd
, type
, outsym
.e_type
);
3019 indx
= add_to_stringtab (output_bfd
, flaginfo
->strtab
, h
->root
.root
.string
,
3021 if (indx
== (bfd_size_type
) -1)
3022 /* FIXME: No way to handle errors. */
3025 PUT_WORD (output_bfd
, indx
, outsym
.e_strx
);
3026 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
3028 amt
= EXTERNAL_NLIST_SIZE
;
3029 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0
3030 || bfd_bwrite ((void *) &outsym
, amt
, output_bfd
) != amt
)
3031 /* FIXME: No way to handle errors. */
3034 flaginfo
->symoff
+= amt
;
3035 h
->indx
= obj_aout_external_sym_count (output_bfd
);
3036 ++obj_aout_external_sym_count (output_bfd
);
3041 /* Handle a link order which is supposed to generate a reloc. */
3044 aout_link_reloc_link_order (struct aout_final_link_info
*flaginfo
,
3046 struct bfd_link_order
*p
)
3048 struct bfd_link_order_reloc
*pr
;
3051 reloc_howto_type
*howto
;
3052 file_ptr
*reloff_ptr
;
3053 struct reloc_std_external srel
;
3055 bfd_size_type rel_size
;
3059 if (p
->type
== bfd_section_reloc_link_order
)
3062 if (bfd_is_abs_section (pr
->u
.section
))
3063 r_index
= N_ABS
| N_EXT
;
3066 BFD_ASSERT (pr
->u
.section
->owner
== flaginfo
->output_bfd
);
3067 r_index
= pr
->u
.section
->target_index
;
3072 struct aout_link_hash_entry
*h
;
3074 BFD_ASSERT (p
->type
== bfd_symbol_reloc_link_order
);
3076 h
= ((struct aout_link_hash_entry
*)
3077 bfd_wrapped_link_hash_lookup (flaginfo
->output_bfd
, flaginfo
->info
,
3078 pr
->u
.name
, FALSE
, FALSE
, TRUE
));
3084 /* We decided to strip this symbol, but it turns out that we
3085 can't. Note that we lose the other and desc information
3086 here. I don't think that will ever matter for a global
3090 if (!aout_link_write_other_symbol (&h
->root
.root
, flaginfo
))
3096 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3097 (flaginfo
->info
, pr
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
3102 howto
= bfd_reloc_type_lookup (flaginfo
->output_bfd
, pr
->reloc
);
3105 bfd_set_error (bfd_error_bad_value
);
3109 if (o
== obj_textsec (flaginfo
->output_bfd
))
3110 reloff_ptr
= &flaginfo
->treloff
;
3111 else if (o
== obj_datasec (flaginfo
->output_bfd
))
3112 reloff_ptr
= &flaginfo
->dreloff
;
3117 MY_put_reloc(flaginfo
->output_bfd
, r_extern
, r_index
, p
->offset
, howto
,
3127 fprintf (stderr
, "TODO: line %d in bfd/pdp11.c\n", __LINE__
);
3129 r_pcrel
= howto
->pc_relative
;
3130 r_baserel
= (howto
->type
& 8) != 0;
3131 r_jmptable
= (howto
->type
& 16) != 0;
3132 r_relative
= (howto
->type
& 32) != 0;
3133 r_length
= howto
->size
;
3135 PUT_WORD (flaginfo
->output_bfd
, p
->offset
, srel
.r_address
);
3136 if (bfd_header_big_endian (flaginfo
->output_bfd
))
3138 srel
.r_index
[0] = r_index
>> 16;
3139 srel
.r_index
[1] = r_index
>> 8;
3140 srel
.r_index
[2] = r_index
;
3142 ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
3143 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
3144 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
3145 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
3146 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
3147 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
3151 srel
.r_index
[2] = r_index
>> 16;
3152 srel
.r_index
[1] = r_index
>> 8;
3153 srel
.r_index
[0] = r_index
;
3155 ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
3156 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
3157 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
3158 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
3159 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
3160 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
3164 rel_ptr
= (void *) &srel
;
3166 /* We have to write the addend into the object file, since
3167 standard a.out relocs are in place. It would be more
3168 reliable if we had the current contents of the file here,
3169 rather than assuming zeroes, but we can't read the file since
3170 it was opened using bfd_openw. */
3171 if (pr
->addend
!= 0)
3174 bfd_reloc_status_type r
;
3178 size
= bfd_get_reloc_size (howto
);
3179 buf
= bfd_zmalloc (size
);
3180 if (buf
== NULL
&& size
!= 0)
3182 r
= MY_relocate_contents (howto
, flaginfo
->output_bfd
,
3189 case bfd_reloc_outofrange
:
3191 case bfd_reloc_overflow
:
3192 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3193 (flaginfo
->info
, NULL
,
3194 (p
->type
== bfd_section_reloc_link_order
3195 ? bfd_section_name (pr
->u
.section
)
3197 howto
->name
, pr
->addend
, NULL
,
3198 (asection
*) NULL
, (bfd_vma
) 0);
3201 ok
= bfd_set_section_contents (flaginfo
->output_bfd
, o
,
3203 (file_ptr
) p
->offset
,
3210 rel_size
= obj_reloc_entry_size (flaginfo
->output_bfd
);
3211 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0
3212 || bfd_bwrite (rel_ptr
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3215 *reloff_ptr
+= rel_size
;
3217 /* Assert that the relocs have not run into the symbols, and that n
3218 the text relocs have not run into the data relocs. */
3219 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3220 && (reloff_ptr
!= &flaginfo
->treloff
3222 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3227 /* Get the section corresponding to a reloc index. */
3229 static inline asection
*
3230 aout_reloc_type_to_section (bfd
*abfd
, int type
)
3234 case RTEXT
: return obj_textsec (abfd
);
3235 case RDATA
: return obj_datasec (abfd
);
3236 case RBSS
: return obj_bsssec (abfd
);
3237 case RABS
: return bfd_abs_section_ptr
;
3238 case REXT
: return bfd_und_section_ptr
;
3244 pdp11_aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3246 asection
*input_section
,
3248 bfd_size_type rel_size
,
3251 bfd_boolean (*check_dynamic_reloc
)
3252 (struct bfd_link_info
*, bfd
*, asection
*,
3253 struct aout_link_hash_entry
*, void *, bfd_byte
*, bfd_boolean
*,
3256 bfd_boolean relocatable
;
3257 struct external_nlist
*syms
;
3259 struct aout_link_hash_entry
**sym_hashes
;
3264 output_bfd
= flaginfo
->output_bfd
;
3265 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
3267 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_SIZE
);
3268 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
3269 == output_bfd
->xvec
->header_byteorder
);
3271 relocatable
= bfd_link_relocatable (flaginfo
->info
);
3272 syms
= obj_aout_external_syms (input_bfd
);
3273 strings
= obj_aout_external_strings (input_bfd
);
3274 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
3275 symbol_map
= flaginfo
->symbol_map
;
3278 rel_end
= rel
+ rel_size
;
3279 for (; rel
< rel_end
; rel
+= RELOC_SIZE
)
3286 reloc_howto_type
*howto
;
3287 struct aout_link_hash_entry
*h
= NULL
;
3289 bfd_reloc_status_type r
;
3292 reloc_entry
= GET_WORD (input_bfd
, (void *) rel
);
3293 if (reloc_entry
== 0)
3297 unsigned int howto_idx
;
3299 r_index
= (reloc_entry
& RIDXMASK
) >> 4;
3300 r_type
= reloc_entry
& RTYPE
;
3301 r_pcrel
= reloc_entry
& RELFLG
;
3302 r_addr
= (char *) rel
- (char *) relocs
;
3304 r_extern
= (r_type
== REXT
);
3306 howto_idx
= r_pcrel
;
3307 BFD_ASSERT (howto_idx
< TABLE_SIZE (howto_table_pdp11
));
3308 howto
= howto_table_pdp11
+ howto_idx
;
3313 /* We are generating a relocatable output file, and must
3314 modify the reloc accordingly. */
3317 /* If we know the symbol this relocation is against,
3318 convert it into a relocation against a section. This
3319 is what the native linker does. */
3320 h
= sym_hashes
[r_index
];
3322 && (h
->root
.type
== bfd_link_hash_defined
3323 || h
->root
.type
== bfd_link_hash_defweak
))
3325 asection
*output_section
;
3327 /* Compute a new r_index. */
3328 output_section
= h
->root
.u
.def
.section
->output_section
;
3329 if (output_section
== obj_textsec (output_bfd
))
3331 else if (output_section
== obj_datasec (output_bfd
))
3333 else if (output_section
== obj_bsssec (output_bfd
))
3338 /* Add the symbol value and the section VMA to the
3339 addend stored in the contents. */
3340 relocation
= (h
->root
.u
.def
.value
3341 + output_section
->vma
3342 + h
->root
.u
.def
.section
->output_offset
);
3346 /* We must change r_index according to the symbol
3348 r_index
= symbol_map
[r_index
];
3354 /* We decided to strip this symbol, but it
3355 turns out that we can't. Note that we
3356 lose the other and desc information here.
3357 I don't think that will ever matter for a
3363 if (!aout_link_write_other_symbol (&h
->root
.root
,
3373 name
= strings
+ GET_WORD (input_bfd
,
3374 syms
[r_index
].e_strx
);
3375 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3376 (flaginfo
->info
, name
, input_bfd
, input_section
,
3385 /* Write out the new r_index value. */
3386 reloc_entry
= GET_WORD (input_bfd
, rel
);
3387 reloc_entry
&= RIDXMASK
;
3388 reloc_entry
|= r_index
<< 4;
3389 PUT_WORD (input_bfd
, reloc_entry
, rel
);
3395 /* This is a relocation against a section. We must
3396 adjust by the amount that the section moved. */
3397 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3398 relocation
= (section
->output_section
->vma
3399 + section
->output_offset
3403 /* Change the address of the relocation. */
3404 fprintf (stderr
, "TODO: change the address of the relocation\n");
3406 /* Adjust a PC relative relocation by removing the reference
3407 to the original address in the section and including the
3408 reference to the new address. */
3410 relocation
-= (input_section
->output_section
->vma
3411 + input_section
->output_offset
3412 - input_section
->vma
);
3414 #ifdef MY_relocatable_reloc
3415 MY_relocatable_reloc (howto
, output_bfd
, rel
, relocation
, r_addr
);
3418 if (relocation
== 0)
3421 r
= MY_relocate_contents (howto
,
3422 input_bfd
, relocation
,
3429 /* We are generating an executable, and must do a full
3434 h
= sym_hashes
[r_index
];
3437 && (h
->root
.type
== bfd_link_hash_defined
3438 || h
->root
.type
== bfd_link_hash_defweak
))
3440 relocation
= (h
->root
.u
.def
.value
3441 + h
->root
.u
.def
.section
->output_section
->vma
3442 + h
->root
.u
.def
.section
->output_offset
);
3445 && h
->root
.type
== bfd_link_hash_undefweak
)
3457 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3458 relocation
= (section
->output_section
->vma
3459 + section
->output_offset
3462 relocation
+= input_section
->vma
;
3465 if (check_dynamic_reloc
!= NULL
)
3469 if (! ((*check_dynamic_reloc
)
3470 (flaginfo
->info
, input_bfd
, input_section
, h
,
3471 (void *) rel
, contents
, &skip
, &relocation
)))
3477 /* Now warn if a global symbol is undefined. We could not
3478 do this earlier, because check_dynamic_reloc might want
3479 to skip this reloc. */
3480 if (hundef
&& ! bfd_link_pic (flaginfo
->info
))
3485 name
= h
->root
.root
.string
;
3487 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
3488 (*flaginfo
->info
->callbacks
->undefined_symbol
)
3489 (flaginfo
->info
, name
, input_bfd
, input_section
,
3493 r
= MY_final_link_relocate (howto
,
3494 input_bfd
, input_section
,
3495 contents
, r_addr
, relocation
,
3499 if (r
!= bfd_reloc_ok
)
3504 case bfd_reloc_outofrange
:
3506 case bfd_reloc_overflow
:
3513 name
= strings
+ GET_WORD (input_bfd
,
3514 syms
[r_index
].e_strx
);
3519 s
= aout_reloc_type_to_section (input_bfd
, r_type
);
3520 name
= bfd_section_name (s
);
3522 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3523 (flaginfo
->info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3524 (bfd_vma
) 0, input_bfd
, input_section
, r_addr
);
3534 /* Link an a.out section into the output file. */
3537 aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3539 asection
*input_section
,
3540 file_ptr
*reloff_ptr
,
3541 bfd_size_type rel_size
)
3543 bfd_size_type input_size
;
3546 /* Get the section contents. */
3547 input_size
= input_section
->size
;
3548 if (! bfd_get_section_contents (input_bfd
, input_section
,
3549 (void *) flaginfo
->contents
,
3550 (file_ptr
) 0, input_size
))
3553 /* Read in the relocs if we haven't already done it. */
3554 if (aout_section_data (input_section
) != NULL
3555 && aout_section_data (input_section
)->relocs
!= NULL
)
3556 relocs
= aout_section_data (input_section
)->relocs
;
3559 relocs
= flaginfo
->relocs
;
3562 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3563 || bfd_bread (relocs
, rel_size
, input_bfd
) != rel_size
)
3568 /* Relocate the section contents. */
3569 if (! pdp11_aout_link_input_section (flaginfo
, input_bfd
, input_section
,
3570 (bfd_byte
*) relocs
,
3571 rel_size
, flaginfo
->contents
))
3574 /* Write out the section contents. */
3575 if (! bfd_set_section_contents (flaginfo
->output_bfd
,
3576 input_section
->output_section
,
3577 (void *) flaginfo
->contents
,
3578 (file_ptr
) input_section
->output_offset
,
3582 /* If we are producing relocatable output, the relocs were
3583 modified, and we now write them out. */
3584 if (bfd_link_relocatable (flaginfo
->info
) && rel_size
> 0)
3586 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
3588 if (bfd_bwrite (relocs
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3590 *reloff_ptr
+= rel_size
;
3592 /* Assert that the relocs have not run into the symbols, and
3593 that if these are the text relocs they have not run into the
3595 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3596 && (reloff_ptr
!= &flaginfo
->treloff
3598 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3604 /* Link an a.out input BFD into the output file. */
3607 aout_link_input_bfd (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
3609 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
3611 /* If this is a dynamic object, it may need special handling. */
3612 if ((input_bfd
->flags
& DYNAMIC
) != 0
3613 && aout_backend_info (input_bfd
)->link_dynamic_object
!= NULL
)
3614 return ((*aout_backend_info (input_bfd
)->link_dynamic_object
)
3615 (flaginfo
->info
, input_bfd
));
3617 /* Get the symbols. We probably have them already, unless
3618 flaginfo->info->keep_memory is FALSE. */
3619 if (! aout_get_external_symbols (input_bfd
))
3622 /* Write out the symbols and get a map of the new indices. The map
3623 is placed into flaginfo->symbol_map. */
3624 if (! aout_link_write_symbols (flaginfo
, input_bfd
))
3627 /* Relocate and write out the sections. These functions use the
3628 symbol map created by aout_link_write_symbols. The linker_mark
3629 field will be set if these sections are to be included in the
3630 link, which will normally be the case. */
3631 if (obj_textsec (input_bfd
)->linker_mark
)
3633 if (! aout_link_input_section (flaginfo
, input_bfd
,
3634 obj_textsec (input_bfd
),
3636 exec_hdr (input_bfd
)->a_trsize
))
3639 if (obj_datasec (input_bfd
)->linker_mark
)
3641 if (! aout_link_input_section (flaginfo
, input_bfd
,
3642 obj_datasec (input_bfd
),
3644 exec_hdr (input_bfd
)->a_drsize
))
3648 /* If we are not keeping memory, we don't need the symbols any
3649 longer. We still need them if we are keeping memory, because the
3650 strings in the hash table point into them. */
3651 if (! flaginfo
->info
->keep_memory
)
3653 if (! aout_link_free_symbols (input_bfd
))
3660 /* Do the final link step. This is called on the output BFD. The
3661 INFO structure should point to a list of BFDs linked through the
3662 link.next field which can be used to find each BFD which takes part
3663 in the output. Also, each section in ABFD should point to a list
3664 of bfd_link_order structures which list all the input sections for
3665 the output section. */
3668 NAME (aout
, final_link
) (bfd
*abfd
,
3669 struct bfd_link_info
*info
,
3670 void (*callback
) (bfd
*, file_ptr
*, file_ptr
*, file_ptr
*))
3672 struct aout_final_link_info aout_info
;
3673 bfd_boolean includes_hash_initialized
= FALSE
;
3675 bfd_size_type trsize
, drsize
;
3676 bfd_size_type max_contents_size
;
3677 bfd_size_type max_relocs_size
;
3678 bfd_size_type max_sym_count
;
3679 struct bfd_link_order
*p
;
3681 bfd_boolean have_link_order_relocs
;
3683 if (bfd_link_pic (info
))
3684 abfd
->flags
|= DYNAMIC
;
3686 separate_i_d
= info
->separate_code
;
3687 aout_info
.info
= info
;
3688 aout_info
.output_bfd
= abfd
;
3689 aout_info
.contents
= NULL
;
3690 aout_info
.relocs
= NULL
;
3691 aout_info
.symbol_map
= NULL
;
3692 aout_info
.output_syms
= NULL
;
3694 if (!bfd_hash_table_init_n (&aout_info
.includes
.root
,
3695 aout_link_includes_newfunc
,
3696 sizeof (struct aout_link_includes_entry
),
3699 includes_hash_initialized
= TRUE
;
3701 /* Figure out the largest section size. Also, if generating
3702 relocatable output, count the relocs. */
3705 max_contents_size
= 0;
3706 max_relocs_size
= 0;
3708 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3712 if (bfd_link_relocatable (info
))
3714 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3716 trsize
+= exec_hdr (sub
)->a_trsize
;
3717 drsize
+= exec_hdr (sub
)->a_drsize
;
3721 /* FIXME: We need to identify the .text and .data sections
3722 and call get_reloc_upper_bound and canonicalize_reloc to
3723 work out the number of relocs needed, and then multiply
3724 by the reloc size. */
3726 /* xgettext:c-format */
3727 (_("%pB: relocatable link from %s to %s not supported"),
3728 abfd
, sub
->xvec
->name
, abfd
->xvec
->name
);
3729 bfd_set_error (bfd_error_invalid_operation
);
3734 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3736 sz
= obj_textsec (sub
)->size
;
3737 if (sz
> max_contents_size
)
3738 max_contents_size
= sz
;
3739 sz
= obj_datasec (sub
)->size
;
3740 if (sz
> max_contents_size
)
3741 max_contents_size
= sz
;
3743 sz
= exec_hdr (sub
)->a_trsize
;
3744 if (sz
> max_relocs_size
)
3745 max_relocs_size
= sz
;
3746 sz
= exec_hdr (sub
)->a_drsize
;
3747 if (sz
> max_relocs_size
)
3748 max_relocs_size
= sz
;
3750 sz
= obj_aout_external_sym_count (sub
);
3751 if (sz
> max_sym_count
)
3756 if (bfd_link_relocatable (info
))
3758 if (obj_textsec (abfd
) != NULL
)
3759 trsize
+= (_bfd_count_link_order_relocs (obj_textsec (abfd
)
3760 ->map_head
.link_order
)
3761 * obj_reloc_entry_size (abfd
));
3762 if (obj_datasec (abfd
) != NULL
)
3763 drsize
+= (_bfd_count_link_order_relocs (obj_datasec (abfd
)
3764 ->map_head
.link_order
)
3765 * obj_reloc_entry_size (abfd
));
3768 exec_hdr (abfd
)->a_trsize
= trsize
;
3769 exec_hdr (abfd
)->a_drsize
= drsize
;
3770 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
3772 /* Adjust the section sizes and vmas according to the magic number.
3773 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3774 filepos for each section. */
3775 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
3778 /* The relocation and symbol file positions differ among a.out
3779 targets. We are passed a callback routine from the backend
3780 specific code to handle this.
3781 FIXME: At this point we do not know how much space the symbol
3782 table will require. This will not work for any (nonstandard)
3783 a.out target that needs to know the symbol table size before it
3784 can compute the relocation file positions. */
3785 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
3787 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
3788 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
3789 obj_sym_filepos (abfd
) = aout_info
.symoff
;
3791 /* We keep a count of the symbols as we output them. */
3792 obj_aout_external_sym_count (abfd
) = 0;
3794 /* We accumulate the string table as we write out the symbols. */
3795 aout_info
.strtab
= _bfd_stringtab_init ();
3796 if (aout_info
.strtab
== NULL
)
3799 /* Allocate buffers to hold section contents and relocs. */
3800 aout_info
.contents
= bfd_malloc (max_contents_size
);
3801 aout_info
.relocs
= bfd_malloc (max_relocs_size
);
3802 aout_info
.symbol_map
= bfd_malloc (max_sym_count
* sizeof (int *));
3803 aout_info
.output_syms
= bfd_malloc ((max_sym_count
+ 1)
3804 * sizeof (struct external_nlist
));
3805 if ((aout_info
.contents
== NULL
&& max_contents_size
!= 0)
3806 || (aout_info
.relocs
== NULL
&& max_relocs_size
!= 0)
3807 || (aout_info
.symbol_map
== NULL
&& max_sym_count
!= 0)
3808 || aout_info
.output_syms
== NULL
)
3811 /* If we have a symbol named __DYNAMIC, force it out now. This is
3812 required by SunOS. Doing this here rather than in sunos.c is a
3813 hack, but it's easier than exporting everything which would be
3816 struct aout_link_hash_entry
*h
;
3818 h
= aout_link_hash_lookup (aout_hash_table (info
), "__DYNAMIC",
3819 FALSE
, FALSE
, FALSE
);
3821 aout_link_write_other_symbol (&h
->root
.root
, &aout_info
);
3824 /* The most time efficient way to do the link would be to read all
3825 the input object files into memory and then sort out the
3826 information into the output file. Unfortunately, that will
3827 probably use too much memory. Another method would be to step
3828 through everything that composes the text section and write it
3829 out, and then everything that composes the data section and write
3830 it out, and then write out the relocs, and then write out the
3831 symbols. Unfortunately, that requires reading stuff from each
3832 input file several times, and we will not be able to keep all the
3833 input files open simultaneously, and reopening them will be slow.
3835 What we do is basically process one input file at a time. We do
3836 everything we need to do with an input file once--copy over the
3837 section contents, handle the relocation information, and write
3838 out the symbols--and then we throw away the information we read
3839 from it. This approach requires a lot of lseeks of the output
3840 file, which is unfortunate but still faster than reopening a lot
3843 We use the output_has_begun field of the input BFDs to see
3844 whether we have already handled it. */
3845 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3846 sub
->output_has_begun
= FALSE
;
3848 /* Mark all sections which are to be included in the link. This
3849 will normally be every section. We need to do this so that we
3850 can identify any sections which the linker has decided to not
3852 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3854 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
3855 if (p
->type
== bfd_indirect_link_order
)
3856 p
->u
.indirect
.section
->linker_mark
= TRUE
;
3859 have_link_order_relocs
= FALSE
;
3860 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3862 for (p
= o
->map_head
.link_order
;
3866 if (p
->type
== bfd_indirect_link_order
3867 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
3868 == bfd_target_aout_flavour
))
3872 input_bfd
= p
->u
.indirect
.section
->owner
;
3873 if (! input_bfd
->output_has_begun
)
3875 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
3877 input_bfd
->output_has_begun
= TRUE
;
3880 else if (p
->type
== bfd_section_reloc_link_order
3881 || p
->type
== bfd_symbol_reloc_link_order
)
3882 /* These are handled below. */
3883 have_link_order_relocs
= TRUE
;
3886 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3892 /* Write out any symbols that we have not already written out. */
3893 bfd_hash_traverse (&info
->hash
->table
,
3894 aout_link_write_other_symbol
,
3897 /* Now handle any relocs we were asked to create by the linker.
3898 These did not come from any input file. We must do these after
3899 we have written out all the symbols, so that we know the symbol
3901 if (have_link_order_relocs
)
3903 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3905 for (p
= o
->map_head
.link_order
;
3909 if (p
->type
== bfd_section_reloc_link_order
3910 || p
->type
== bfd_symbol_reloc_link_order
)
3912 if (! aout_link_reloc_link_order (&aout_info
, o
, p
))
3919 free (aout_info
.contents
);
3920 aout_info
.contents
= NULL
;
3921 free (aout_info
.relocs
);
3922 aout_info
.relocs
= NULL
;
3923 free (aout_info
.symbol_map
);
3924 aout_info
.symbol_map
= NULL
;
3925 free (aout_info
.output_syms
);
3926 aout_info
.output_syms
= NULL
;
3927 if (includes_hash_initialized
)
3929 bfd_hash_table_free (&aout_info
.includes
.root
);
3930 includes_hash_initialized
= FALSE
;
3933 /* Finish up any dynamic linking we may be doing. */
3934 if (aout_backend_info (abfd
)->finish_dynamic_link
!= NULL
)
3936 if (! (*aout_backend_info (abfd
)->finish_dynamic_link
) (abfd
, info
))
3940 /* Update the header information. */
3941 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
3942 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
3943 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
3944 obj_textsec (abfd
)->reloc_count
=
3945 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
3946 obj_datasec (abfd
)->reloc_count
=
3947 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
3949 /* Write out the string table, unless there are no symbols. */
3950 if (abfd
->symcount
> 0)
3952 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
3953 || ! emit_stringtab (abfd
, aout_info
.strtab
))
3956 else if (obj_textsec (abfd
)->reloc_count
== 0
3957 && obj_datasec (abfd
)->reloc_count
== 0)
3959 /* The layout of a typical a.out file is header, text, data,
3960 relocs, symbols, string table. When there are no relocs,
3961 symbols or string table, the last thing in the file is data
3962 and a_data may be rounded up. However we may have a smaller
3963 sized .data section and thus not written final padding. The
3964 same thing can happen with text if there is no data. Write
3965 final padding here to extend the file. */
3968 if (exec_hdr (abfd
)->a_data
> obj_datasec (abfd
)->size
)
3969 pos
= obj_datasec (abfd
)->filepos
+ exec_hdr (abfd
)->a_data
;
3970 else if (obj_datasec (abfd
)->size
== 0
3971 && exec_hdr (abfd
)->a_text
> obj_textsec (abfd
)->size
)
3972 pos
= obj_textsec (abfd
)->filepos
+ exec_hdr (abfd
)->a_text
;
3977 if (bfd_seek (abfd
, pos
- 1, SEEK_SET
) != 0
3978 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3986 free (aout_info
.contents
);
3987 free (aout_info
.relocs
);
3988 free (aout_info
.symbol_map
);
3989 free (aout_info
.output_syms
);
3990 if (includes_hash_initialized
)
3991 bfd_hash_table_free (&aout_info
.includes
.root
);
3995 /* Adjust and write out the symbols for an a.out file. Set the new
3996 symbol indices into a symbol_map. */
3999 aout_link_write_symbols (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
4002 bfd_size_type sym_count
;
4004 enum bfd_link_strip strip
;
4005 enum bfd_link_discard discard
;
4006 struct external_nlist
*outsym
;
4007 bfd_size_type strtab_index
;
4008 struct external_nlist
*sym
;
4009 struct external_nlist
*sym_end
;
4010 struct aout_link_hash_entry
**sym_hash
;
4013 bfd_boolean skip_next
;
4015 output_bfd
= flaginfo
->output_bfd
;
4016 sym_count
= obj_aout_external_sym_count (input_bfd
);
4017 strings
= obj_aout_external_strings (input_bfd
);
4018 strip
= flaginfo
->info
->strip
;
4019 discard
= flaginfo
->info
->discard
;
4020 outsym
= flaginfo
->output_syms
;
4022 /* First write out a symbol for this object file, unless we are
4023 discarding such symbols. */
4024 if (strip
!= strip_all
4025 && (strip
!= strip_some
4026 || bfd_hash_lookup (flaginfo
->info
->keep_hash
,
4027 bfd_get_filename (input_bfd
),
4028 FALSE
, FALSE
) != NULL
)
4029 && discard
!= discard_all
)
4031 H_PUT_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
4032 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4033 bfd_get_filename (input_bfd
), FALSE
);
4034 if (strtab_index
== (bfd_size_type
) -1)
4036 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4037 PUT_WORD (output_bfd
,
4038 (bfd_section_vma (obj_textsec (input_bfd
)->output_section
)
4039 + obj_textsec (input_bfd
)->output_offset
),
4041 ++obj_aout_external_sym_count (output_bfd
);
4047 sym
= obj_aout_external_syms (input_bfd
);
4048 sym_end
= sym
+ sym_count
;
4049 sym_hash
= obj_aout_sym_hashes (input_bfd
);
4050 symbol_map
= flaginfo
->symbol_map
;
4051 memset (symbol_map
, 0, (size_t) sym_count
* sizeof *symbol_map
);
4052 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
4056 struct aout_link_hash_entry
*h
;
4062 /* We set *symbol_map to 0 above for all symbols. If it has
4063 already been set to -1 for this symbol, it means that we are
4064 discarding it because it appears in a duplicate header file.
4065 See the N_BINCL code below. */
4066 if (*symbol_map
== -1)
4069 /* Initialize *symbol_map to -1, which means that the symbol was
4070 not copied into the output file. We will change it later if
4071 we do copy the symbol over. */
4074 type
= H_GET_8 (input_bfd
, sym
->e_type
);
4075 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
4081 /* Pass this symbol through. It is the target of an
4082 indirect or warning symbol. */
4083 val
= GET_WORD (input_bfd
, sym
->e_value
);
4088 /* Skip this symbol, which is the target of an indirect
4089 symbol that we have changed to no longer be an indirect
4096 struct aout_link_hash_entry
*hresolve
;
4098 /* We have saved the hash table entry for this symbol, if
4099 there is one. Note that we could just look it up again
4100 in the hash table, provided we first check that it is an
4104 /* Use the name from the hash table, in case the symbol was
4107 name
= h
->root
.root
.string
;
4109 /* If this is an indirect or warning symbol, then change
4110 hresolve to the base symbol. We also change *sym_hash so
4111 that the relocation routines relocate against the real
4115 && (h
->root
.type
== bfd_link_hash_indirect
4116 || h
->root
.type
== bfd_link_hash_warning
))
4118 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
4119 while (hresolve
->root
.type
== bfd_link_hash_indirect
4120 || hresolve
->root
.type
== bfd_link_hash_warning
)
4121 hresolve
= ((struct aout_link_hash_entry
*)
4122 hresolve
->root
.u
.i
.link
);
4123 *sym_hash
= hresolve
;
4126 /* If the symbol has already been written out, skip it. */
4128 && h
->root
.type
!= bfd_link_hash_warning
4131 if ((type
& N_TYPE
) == N_INDR
4132 || type
== N_WARNING
)
4134 *symbol_map
= h
->indx
;
4138 /* See if we are stripping this symbol. */
4144 case strip_debugger
:
4145 if ((type
& N_STAB
) != 0)
4149 if (bfd_hash_lookup (flaginfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
4164 /* Get the value of the symbol. */
4165 if ((type
& N_TYPE
) == N_TEXT
4167 symsec
= obj_textsec (input_bfd
);
4168 else if ((type
& N_TYPE
) == N_DATA
4170 symsec
= obj_datasec (input_bfd
);
4171 else if ((type
& N_TYPE
) == N_BSS
4173 symsec
= obj_bsssec (input_bfd
);
4174 else if ((type
& N_TYPE
) == N_ABS
4176 symsec
= bfd_abs_section_ptr
;
4177 else if (((type
& N_TYPE
) == N_INDR
4178 && (hresolve
== NULL
4179 || (hresolve
->root
.type
!= bfd_link_hash_defined
4180 && hresolve
->root
.type
!= bfd_link_hash_defweak
4181 && hresolve
->root
.type
!= bfd_link_hash_common
)))
4182 || type
== N_WARNING
)
4184 /* Pass the next symbol through unchanged. The
4185 condition above for indirect symbols is so that if
4186 the indirect symbol was defined, we output it with
4187 the correct definition so the debugger will
4190 val
= GET_WORD (input_bfd
, sym
->e_value
);
4193 else if ((type
& N_STAB
) != 0)
4195 val
= GET_WORD (input_bfd
, sym
->e_value
);
4200 /* If we get here with an indirect symbol, it means that
4201 we are outputting it with a real definition. In such
4202 a case we do not want to output the next symbol,
4203 which is the target of the indirection. */
4204 if ((type
& N_TYPE
) == N_INDR
)
4209 /* We need to get the value from the hash table. We use
4210 hresolve so that if we have defined an indirect
4211 symbol we output the final definition. */
4214 switch (type
& N_TYPE
)
4217 symsec
= obj_textsec (input_bfd
);
4220 symsec
= obj_datasec (input_bfd
);
4223 symsec
= obj_bsssec (input_bfd
);
4226 symsec
= bfd_abs_section_ptr
;
4233 else if (hresolve
->root
.type
== bfd_link_hash_defined
4234 || hresolve
->root
.type
== bfd_link_hash_defweak
)
4236 asection
*input_section
;
4237 asection
*output_section
;
4239 /* This case usually means a common symbol which was
4240 turned into a defined symbol. */
4241 input_section
= hresolve
->root
.u
.def
.section
;
4242 output_section
= input_section
->output_section
;
4243 BFD_ASSERT (bfd_is_abs_section (output_section
)
4244 || output_section
->owner
== output_bfd
);
4245 val
= (hresolve
->root
.u
.def
.value
4246 + bfd_section_vma (output_section
)
4247 + input_section
->output_offset
);
4249 /* Get the correct type based on the section. If
4250 this is a constructed set, force it to be
4251 globally visible. */
4260 if (output_section
== obj_textsec (output_bfd
))
4261 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4264 else if (output_section
== obj_datasec (output_bfd
))
4265 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4268 else if (output_section
== obj_bsssec (output_bfd
))
4269 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4273 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4277 else if (hresolve
->root
.type
== bfd_link_hash_common
)
4278 val
= hresolve
->root
.u
.c
.size
;
4279 else if (hresolve
->root
.type
== bfd_link_hash_undefweak
)
4288 val
= (symsec
->output_section
->vma
4289 + symsec
->output_offset
4290 + (GET_WORD (input_bfd
, sym
->e_value
)
4293 /* If this is a global symbol set the written flag, and if
4294 it is a local symbol see if we should discard it. */
4298 h
->indx
= obj_aout_external_sym_count (output_bfd
);
4300 else if ((type
& N_TYPE
) != N_SETT
4301 && (type
& N_TYPE
) != N_SETD
4302 && (type
& N_TYPE
) != N_SETB
4303 && (type
& N_TYPE
) != N_SETA
)
4308 case discard_sec_merge
:
4311 if ((type
& N_STAB
) == 0
4312 && bfd_is_local_label_name (input_bfd
, name
))
4326 /* An N_BINCL symbol indicates the start of the stabs
4327 entries for a header file. We need to scan ahead to the
4328 next N_EINCL symbol, ignoring nesting, adding up all the
4329 characters in the symbol names, not including the file
4330 numbers in types (the first number after an open
4332 if (type
== N_BINCL
)
4334 struct external_nlist
*incl_sym
;
4336 struct aout_link_includes_entry
*incl_entry
;
4337 struct aout_link_includes_totals
*t
;
4341 for (incl_sym
= sym
+ 1; incl_sym
< sym_end
; incl_sym
++)
4345 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4346 if (incl_type
== N_EINCL
)
4352 else if (incl_type
== N_BINCL
)
4358 s
= strings
+ GET_WORD (input_bfd
, incl_sym
->e_strx
);
4359 for (; *s
!= '\0'; s
++)
4364 /* Skip the file number. */
4366 while (ISDIGIT (*s
))
4374 /* If we have already included a header file with the
4375 same value, then replace this one with an N_EXCL
4377 copy
= ! flaginfo
->info
->keep_memory
;
4378 incl_entry
= aout_link_includes_lookup (&flaginfo
->includes
,
4380 if (incl_entry
== NULL
)
4382 for (t
= incl_entry
->totals
; t
!= NULL
; t
= t
->next
)
4383 if (t
->total
== val
)
4387 /* This is the first time we have seen this header
4388 file with this set of stabs strings. */
4389 t
= bfd_hash_allocate (&flaginfo
->includes
.root
,
4394 t
->next
= incl_entry
->totals
;
4395 incl_entry
->totals
= t
;
4401 /* This is a duplicate header file. We must change
4402 it to be an N_EXCL entry, and mark all the
4403 included symbols to prevent outputting them. */
4407 for (incl_sym
= sym
+ 1, incl_map
= symbol_map
+ 1;
4409 incl_sym
++, incl_map
++)
4413 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4414 if (incl_type
== N_EINCL
)
4423 else if (incl_type
== N_BINCL
)
4432 /* Copy this symbol into the list of symbols we are going to
4434 H_PUT_8 (output_bfd
, type
, outsym
->e_type
);
4436 if (! flaginfo
->info
->keep_memory
)
4438 /* name points into a string table which we are going to
4439 free. If there is a hash table entry, use that string.
4440 Otherwise, copy name into memory. */
4442 name
= h
->root
.root
.string
;
4446 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4448 if (strtab_index
== (bfd_size_type
) -1)
4450 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4451 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
4452 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
4453 ++obj_aout_external_sym_count (output_bfd
);
4457 /* Write out the output symbols we have just constructed. */
4458 if (outsym
> flaginfo
->output_syms
)
4462 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0)
4464 size
= outsym
- flaginfo
->output_syms
;
4465 size
*= EXTERNAL_NLIST_SIZE
;
4466 if (bfd_bwrite ((void *) flaginfo
->output_syms
, size
, output_bfd
) != size
)
4468 flaginfo
->symoff
+= size
;
4474 /* Write out a symbol that was not associated with an a.out input
4478 bfd_getp32 (const void *p
)
4480 const bfd_byte
*addr
= p
;
4483 v
= (unsigned long) addr
[1] << 24;
4484 v
|= (unsigned long) addr
[0] << 16;
4485 v
|= (unsigned long) addr
[3] << 8;
4486 v
|= (unsigned long) addr
[2];
4490 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
4492 static bfd_signed_vma
4493 bfd_getp_signed_32 (const void *p
)
4495 const bfd_byte
*addr
= p
;
4498 v
= (unsigned long) addr
[1] << 24;
4499 v
|= (unsigned long) addr
[0] << 16;
4500 v
|= (unsigned long) addr
[3] << 8;
4501 v
|= (unsigned long) addr
[2];
4502 return COERCE32 (v
);
4506 bfd_putp32 (bfd_vma data
, void *p
)
4510 addr
[0] = (data
>> 16) & 0xff;
4511 addr
[1] = (data
>> 24) & 0xff;
4512 addr
[2] = (data
>> 0) & 0xff;
4513 addr
[3] = (data
>> 8) & 0xff;
4516 const bfd_target
MY (vec
) =
4518 TARGETNAME
, /* Name. */
4519 bfd_target_aout_flavour
,
4520 BFD_ENDIAN_LITTLE
, /* Target byte order (little). */
4521 BFD_ENDIAN_LITTLE
, /* Target headers byte order (little). */
4522 (HAS_RELOC
| EXEC_P
| /* Object flags. */
4523 HAS_LINENO
| HAS_DEBUG
|
4524 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
),
4525 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_CODE
| SEC_DATA
),
4526 MY_symbol_leading_char
,
4527 AR_PAD_CHAR
, /* AR_pad_char. */
4528 15, /* AR_max_namelen. */
4529 0, /* match priority. */
4530 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4531 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4532 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Data. */
4533 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4534 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4535 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Headers. */
4536 { /* bfd_check_format. */
4539 bfd_generic_archive_p
,
4542 { /* bfd_set_format. */
4543 _bfd_bool_bfd_false_error
,
4545 _bfd_generic_mkarchive
,
4546 _bfd_bool_bfd_false_error
4548 { /* bfd_write_contents. */
4549 _bfd_bool_bfd_false_error
,
4550 MY_write_object_contents
,
4551 _bfd_write_archive_contents
,
4552 _bfd_bool_bfd_false_error
4555 BFD_JUMP_TABLE_GENERIC (MY
),
4556 BFD_JUMP_TABLE_COPY (MY
),
4557 BFD_JUMP_TABLE_CORE (MY
),
4558 BFD_JUMP_TABLE_ARCHIVE (MY
),
4559 BFD_JUMP_TABLE_SYMBOLS (MY
),
4560 BFD_JUMP_TABLE_RELOCS (MY
),
4561 BFD_JUMP_TABLE_WRITE (MY
),
4562 BFD_JUMP_TABLE_LINK (MY
),
4563 BFD_JUMP_TABLE_DYNAMIC (MY
),
4565 /* Alternative_target. */
4568 (void *) MY_backend_data