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"
163 #define N_TYPE 0x1f /* Type mask. */
164 #define N_UNDF 0x00 /* Undefined. */
165 #define N_ABS 0x01 /* Absolute. */
166 #define N_TEXT 0x02 /* Text segment. */
167 #define N_DATA 0x03 /* Data segment. */
168 #define N_BSS 0x04 /* Bss segment. */
169 #define N_REG 0x14 /* Register symbol. */
170 #define N_FN 0x1f /* File name. */
171 #define N_EXT 0x20 /* External flag. */
175 #define RELFLG 0x0001 /* PC-relative flag. */
176 #define RTYPE 0x000e /* Type mask. */
177 #define RIDXMASK 0xfff0 /* Index mask. */
179 #define RABS 0x00 /* Absolute. */
180 #define RTEXT 0x02 /* Text. */
181 #define RDATA 0x04 /* Data. */
182 #define RBSS 0x06 /* Bss. */
183 #define REXT 0x08 /* External. */
185 #define RINDEX(x) (((x) & 0xfff0) >> 4)
187 #ifndef MY_final_link_relocate
188 #define MY_final_link_relocate _bfd_final_link_relocate
191 #ifndef MY_relocate_contents
192 #define MY_relocate_contents _bfd_relocate_contents
195 /* A hash table used for header files with N_BINCL entries. */
197 struct aout_link_includes_table
199 struct bfd_hash_table root
;
202 /* A linked list of totals that we have found for a particular header
205 struct aout_link_includes_totals
207 struct aout_link_includes_totals
*next
;
211 /* An entry in the header file hash table. */
213 struct aout_link_includes_entry
215 struct bfd_hash_entry root
;
216 /* List of totals we have found for this file. */
217 struct aout_link_includes_totals
*totals
;
220 /* During the final link step we need to pass around a bunch of
221 information, so we do it in an instance of this structure. */
223 struct aout_final_link_info
225 /* General link information. */
226 struct bfd_link_info
*info
;
229 /* Reloc file positions. */
230 file_ptr treloff
, dreloff
;
231 /* File position of symbols. */
234 struct bfd_strtab_hash
*strtab
;
235 /* Header file hash table. */
236 struct aout_link_includes_table includes
;
237 /* A buffer large enough to hold the contents of any section. */
239 /* A buffer large enough to hold the relocs of any section. */
241 /* A buffer large enough to hold the symbol map of any input BFD. */
243 /* A buffer large enough to hold output symbols of any input BFD. */
244 struct external_nlist
*output_syms
;
247 /* Copy of the link_info.separate_code boolean to select the output format with
248 separate instruction and data spaces selected by --imagic */
249 static bfd_boolean separate_i_d
= FALSE
;
251 reloc_howto_type howto_table_pdp11
[] =
253 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
254 HOWTO( 0, 0, 1, 16, FALSE
, 0, complain_overflow_signed
,0,"16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
255 HOWTO( 1, 0, 1, 16, TRUE
, 0, complain_overflow_signed
,0,"DISP16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
258 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
261 static bfd_boolean
aout_link_check_archive_element (bfd
*, struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *, bfd_boolean
*);
262 static bfd_boolean
aout_link_add_object_symbols (bfd
*, struct bfd_link_info
*);
263 static bfd_boolean
aout_link_add_symbols (bfd
*, struct bfd_link_info
*);
264 static bfd_boolean
aout_link_write_symbols (struct aout_final_link_info
*, bfd
*);
268 NAME (aout
, reloc_type_lookup
) (bfd
* abfd ATTRIBUTE_UNUSED
,
269 bfd_reloc_code_real_type code
)
274 return &howto_table_pdp11
[0];
275 case BFD_RELOC_16_PCREL
:
276 return &howto_table_pdp11
[1];
283 NAME (aout
, reloc_name_lookup
) (bfd
*abfd ATTRIBUTE_UNUSED
,
289 i
< sizeof (howto_table_pdp11
) / sizeof (howto_table_pdp11
[0]);
291 if (howto_table_pdp11
[i
].name
!= NULL
292 && strcasecmp (howto_table_pdp11
[i
].name
, r_name
) == 0)
293 return &howto_table_pdp11
[i
];
299 pdp11_aout_write_headers (bfd
*abfd
, struct internal_exec
*execp
)
301 struct external_exec exec_bytes
;
303 if (adata(abfd
).magic
== undecided_magic
)
304 NAME (aout
, adjust_sizes_and_vmas
) (abfd
);
306 execp
->a_syms
= bfd_get_symcount (abfd
) * EXTERNAL_NLIST_SIZE
;
307 execp
->a_entry
= bfd_get_start_address (abfd
);
309 if (obj_textsec (abfd
)->reloc_count
> 0
310 || obj_datasec (abfd
)->reloc_count
> 0)
312 execp
->a_trsize
= execp
->a_text
;
313 execp
->a_drsize
= execp
->a_data
;
321 NAME (aout
, swap_exec_header_out
) (abfd
, execp
, & exec_bytes
);
323 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
326 if (bfd_bwrite ((void *) &exec_bytes
, (bfd_size_type
) EXEC_BYTES_SIZE
, abfd
)
330 /* Now write out reloc info, followed by syms and strings. */
331 if (bfd_get_outsymbols (abfd
) != NULL
332 && bfd_get_symcount (abfd
) != 0)
334 if (bfd_seek (abfd
, (file_ptr
) (N_SYMOFF (execp
)), SEEK_SET
) != 0)
337 if (! NAME (aout
, write_syms
) (abfd
))
341 if (obj_textsec (abfd
)->reloc_count
> 0
342 || obj_datasec (abfd
)->reloc_count
> 0)
344 if (bfd_seek (abfd
, (file_ptr
) (N_TRELOFF (execp
)), SEEK_SET
) != 0
345 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_textsec (abfd
))
346 || bfd_seek (abfd
, (file_ptr
) (N_DRELOFF (execp
)), SEEK_SET
) != 0
347 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_datasec (abfd
)))
354 /* Write an object file.
355 Section contents have already been written. We write the
356 file header, symbols, and relocation. */
359 MY(write_object_contents
) (bfd
*abfd
)
361 struct internal_exec
*execp
= exec_hdr (abfd
);
363 /* We must make certain that the magic number has been set. This
364 will normally have been done by set_section_contents, but only if
365 there actually are some section contents. */
366 if (! abfd
->output_has_begun
)
367 NAME (aout
, adjust_sizes_and_vmas
) (abfd
);
369 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
371 return WRITE_HEADERS (abfd
, execp
);
374 /* Swap the information in an executable header @var{raw_bytes} taken
375 from a raw byte stream memory image into the internal exec header
376 structure "execp". */
378 #ifndef NAME_swap_exec_header_in
380 NAME (aout
, swap_exec_header_in
) (bfd
*abfd
,
381 struct external_exec
*bytes
,
382 struct internal_exec
*execp
)
384 /* The internal_exec structure has some fields that are unused in this
385 configuration (IE for i960), so ensure that all such uninitialized
386 fields are zero'd out. There are places where two of these structs
387 are memcmp'd, and thus the contents do matter. */
388 memset ((void *) execp
, 0, sizeof (struct internal_exec
));
389 /* Now fill in fields in the execp, from the bytes in the raw data. */
390 execp
->a_info
= GET_MAGIC (abfd
, bytes
->e_info
);
391 execp
->a_text
= GET_WORD (abfd
, bytes
->e_text
);
392 execp
->a_data
= GET_WORD (abfd
, bytes
->e_data
);
393 execp
->a_bss
= GET_WORD (abfd
, bytes
->e_bss
);
394 execp
->a_syms
= GET_WORD (abfd
, bytes
->e_syms
);
395 execp
->a_entry
= GET_WORD (abfd
, bytes
->e_entry
);
397 if (GET_WORD (abfd
, bytes
->e_flag
) & A_FLAG_RELOC_STRIPPED
)
404 execp
->a_trsize
= execp
->a_text
;
405 execp
->a_drsize
= execp
->a_data
;
408 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
411 /* Swap the information in an internal exec header structure
412 "execp" into the buffer "bytes" ready for writing to disk. */
414 NAME (aout
, swap_exec_header_out
) (bfd
*abfd
,
415 struct internal_exec
*execp
,
416 struct external_exec
*bytes
)
418 /* Now fill in fields in the raw data, from the fields in the exec struct. */
419 PUT_MAGIC (abfd
, execp
->a_info
, bytes
->e_info
);
420 PUT_WORD (abfd
, execp
->a_text
, bytes
->e_text
);
421 PUT_WORD (abfd
, execp
->a_data
, bytes
->e_data
);
422 PUT_WORD (abfd
, execp
->a_bss
, bytes
->e_bss
);
423 PUT_WORD (abfd
, execp
->a_syms
, bytes
->e_syms
);
424 PUT_WORD (abfd
, execp
->a_entry
, bytes
->e_entry
);
425 PUT_WORD (abfd
, 0, bytes
->e_unused
);
427 if ((execp
->a_trsize
== 0 || execp
->a_text
== 0)
428 && (execp
->a_drsize
== 0 || execp
->a_data
== 0))
429 PUT_WORD (abfd
, A_FLAG_RELOC_STRIPPED
, bytes
->e_flag
);
430 else if (execp
->a_trsize
== execp
->a_text
431 && execp
->a_drsize
== execp
->a_data
)
432 PUT_WORD (abfd
, 0, bytes
->e_flag
);
435 /* TODO: print a proper warning message. */
436 fprintf (stderr
, "BFD:%s:%d: internal error\n", __FILE__
, __LINE__
);
437 PUT_WORD (abfd
, 0, bytes
->e_flag
);
441 /* Make all the section for an a.out file. */
444 NAME (aout
, make_sections
) (bfd
*abfd
)
446 if (obj_textsec (abfd
) == NULL
&& bfd_make_section (abfd
, ".text") == NULL
)
448 if (obj_datasec (abfd
) == NULL
&& bfd_make_section (abfd
, ".data") == NULL
)
450 if (obj_bsssec (abfd
) == NULL
&& bfd_make_section (abfd
, ".bss") == NULL
)
455 /* Some a.out variant thinks that the file open in ABFD
456 checking is an a.out file. Do some more checking, and set up
457 for access if it really is. Call back to the calling
458 environment's "finish up" function just before returning, to
459 handle any last-minute setup. */
462 NAME (aout
, some_aout_object_p
) (bfd
*abfd
,
463 struct internal_exec
*execp
,
464 bfd_cleanup (*callback_to_real_object_p
) (bfd
*))
466 struct aout_data_struct
*rawptr
, *oldrawptr
;
468 size_t amt
= sizeof (struct aout_data_struct
);
470 rawptr
= bfd_zalloc (abfd
, amt
);
474 oldrawptr
= abfd
->tdata
.aout_data
;
475 abfd
->tdata
.aout_data
= rawptr
;
477 /* Copy the contents of the old tdata struct. */
478 if (oldrawptr
!= NULL
)
479 *abfd
->tdata
.aout_data
= *oldrawptr
;
481 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
482 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
; /* Copy in the internal_exec struct. */
483 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
485 /* Set the file flags. */
486 abfd
->flags
= BFD_NO_FLAGS
;
487 if (execp
->a_drsize
|| execp
->a_trsize
)
488 abfd
->flags
|= HAS_RELOC
;
489 /* Setting of EXEC_P has been deferred to the bottom of this function. */
491 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
492 if (N_DYNAMIC (execp
))
493 abfd
->flags
|= DYNAMIC
;
495 if (N_MAGIC (execp
) == ZMAGIC
)
497 abfd
->flags
|= D_PAGED
| WP_TEXT
;
498 adata (abfd
).magic
= z_magic
;
500 else if (N_MAGIC (execp
) == NMAGIC
)
502 abfd
->flags
|= WP_TEXT
;
503 adata (abfd
).magic
= n_magic
;
505 else if (N_MAGIC (execp
) == OMAGIC
)
506 adata (abfd
).magic
= o_magic
;
507 else if (N_MAGIC (execp
) == IMAGIC
)
508 adata (abfd
).magic
= i_magic
;
511 /* Should have been checked with N_BADMAG before this routine
516 abfd
->start_address
= execp
->a_entry
;
518 obj_aout_symbols (abfd
) = NULL
;
519 abfd
->symcount
= execp
->a_syms
/ sizeof (struct external_nlist
);
521 /* The default relocation entry size is that of traditional V7 Unix. */
522 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
524 /* The default symbol entry size is that of traditional Unix. */
525 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
528 bfd_init_window (&obj_aout_sym_window (abfd
));
529 bfd_init_window (&obj_aout_string_window (abfd
));
532 obj_aout_external_syms (abfd
) = NULL
;
533 obj_aout_external_strings (abfd
) = NULL
;
534 obj_aout_sym_hashes (abfd
) = NULL
;
536 if (! NAME (aout
, make_sections
) (abfd
))
539 obj_datasec (abfd
)->size
= execp
->a_data
;
540 obj_bsssec (abfd
)->size
= execp
->a_bss
;
542 obj_textsec (abfd
)->flags
=
543 (execp
->a_trsize
!= 0
544 ? (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_RELOC
)
545 : (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
));
546 obj_datasec (abfd
)->flags
=
547 (execp
->a_drsize
!= 0
548 ? (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_RELOC
)
549 : (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
));
550 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
552 #ifdef THIS_IS_ONLY_DOCUMENTATION
553 /* The common code can't fill in these things because they depend
554 on either the start address of the text segment, the rounding
555 up of virtual addresses between segments, or the starting file
556 position of the text segment -- all of which varies among different
557 versions of a.out. */
559 /* Call back to the format-dependent code to fill in the rest of the
560 fields and do any further cleanup. Things that should be filled
561 in by the callback: */
562 struct exec
*execp
= exec_hdr (abfd
);
564 obj_textsec (abfd
)->size
= N_TXTSIZE (execp
);
565 /* Data and bss are already filled in since they're so standard. */
567 /* The virtual memory addresses of the sections. */
568 obj_textsec (abfd
)->vma
= N_TXTADDR (execp
);
569 obj_datasec (abfd
)->vma
= N_DATADDR (execp
);
570 obj_bsssec (abfd
)->vma
= N_BSSADDR (execp
);
572 /* The file offsets of the sections. */
573 obj_textsec (abfd
)->filepos
= N_TXTOFF (execp
);
574 obj_datasec (abfd
)->filepos
= N_DATOFF (execp
);
576 /* The file offsets of the relocation info. */
577 obj_textsec (abfd
)->rel_filepos
= N_TRELOFF (execp
);
578 obj_datasec (abfd
)->rel_filepos
= N_DRELOFF (execp
);
580 /* The file offsets of the string table and symbol table. */
581 obj_str_filepos (abfd
) = N_STROFF (execp
);
582 obj_sym_filepos (abfd
) = N_SYMOFF (execp
);
584 /* Determine the architecture and machine type of the object file. */
585 abfd
->obj_arch
= bfd_arch_obscure
;
587 adata(abfd
)->page_size
= TARGET_PAGE_SIZE
;
588 adata(abfd
)->segment_size
= SEGMENT_SIZE
;
589 adata(abfd
)->exec_bytes_size
= EXEC_BYTES_SIZE
;
591 return _bfd_no_cleanup
;
593 /* The architecture is encoded in various ways in various a.out variants,
594 or is not encoded at all in some of them. The relocation size depends
595 on the architecture and the a.out variant. Finally, the return value
596 is the bfd_target vector in use. If an error occurs, return zero and
597 set bfd_error to the appropriate error code.
599 Formats such as b.out, which have additional fields in the a.out
600 header, should cope with them in this callback as well. */
601 #endif /* DOCUMENTATION */
603 cleanup
= (*callback_to_real_object_p
)(abfd
);
605 /* Now that the segment addresses have been worked out, take a better
606 guess at whether the file is executable. If the entry point
607 is within the text segment, assume it is. (This makes files
608 executable even if their entry point address is 0, as long as
609 their text starts at zero.).
611 This test had to be changed to deal with systems where the text segment
612 runs at a different location than the default. The problem is that the
613 entry address can appear to be outside the text segment, thus causing an
614 erroneous conclusion that the file isn't executable.
616 To fix this, we now accept any non-zero entry point as an indication of
617 executability. This will work most of the time, since only the linker
618 sets the entry point, and that is likely to be non-zero for most systems. */
620 if (execp
->a_entry
!= 0
621 || (execp
->a_entry
>= obj_textsec(abfd
)->vma
622 && execp
->a_entry
< obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->size
))
623 abfd
->flags
|= EXEC_P
;
627 struct stat stat_buf
;
629 /* The original heuristic doesn't work in some important cases.
630 The a.out file has no information about the text start
631 address. For files (like kernels) linked to non-standard
632 addresses (ld -Ttext nnn) the entry point may not be between
633 the default text start (obj_textsec(abfd)->vma) and
634 (obj_textsec(abfd)->vma) + text size. This is not just a mach
635 issue. Many kernels are loaded at non standard addresses. */
636 if (abfd
->iostream
!= NULL
637 && (abfd
->flags
& BFD_IN_MEMORY
) == 0
638 && (fstat(fileno((FILE *) (abfd
->iostream
)), &stat_buf
) == 0)
639 && ((stat_buf
.st_mode
& 0111) != 0))
640 abfd
->flags
|= EXEC_P
;
642 #endif /* STAT_FOR_EXEC */
647 abfd
->tdata
.aout_data
= oldrawptr
;
652 /* Initialize ABFD for use with a.out files. */
655 NAME (aout
, mkobject
) (bfd
*abfd
)
657 struct aout_data_struct
*rawptr
;
658 size_t amt
= sizeof (struct aout_data_struct
);
660 bfd_set_error (bfd_error_system_call
);
662 /* Use an intermediate variable for clarity. */
663 rawptr
= bfd_zalloc (abfd
, amt
);
668 abfd
->tdata
.aout_data
= rawptr
;
669 exec_hdr (abfd
) = &(rawptr
->e
);
671 obj_textsec (abfd
) = NULL
;
672 obj_datasec (abfd
) = NULL
;
673 obj_bsssec (abfd
) = NULL
;
678 /* Keep track of machine architecture and machine type for
679 a.out's. Return the <<machine_type>> for a particular
680 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
681 and machine can't be represented in a.out format.
683 If the architecture is understood, machine type 0 (default)
684 is always understood. */
687 NAME (aout
, machine_type
) (enum bfd_architecture arch
,
688 unsigned long machine
,
689 bfd_boolean
*unknown
)
691 enum machine_type arch_flags
;
693 arch_flags
= M_UNKNOWN
;
700 || machine
== bfd_mach_sparc
701 || machine
== bfd_mach_sparc_sparclite
702 || machine
== bfd_mach_sparc_v9
)
703 arch_flags
= M_SPARC
;
704 else if (machine
== bfd_mach_sparc_sparclet
)
705 arch_flags
= M_SPARCLET
;
710 || machine
== bfd_mach_i386_i386
711 || machine
== bfd_mach_i386_i386_intel_syntax
)
716 if (machine
== 0) arch_flags
= M_ARM
;
724 case bfd_mach_mips3000
:
725 arch_flags
= M_MIPS1
;
727 case bfd_mach_mips4000
: /* MIPS3 */
728 case bfd_mach_mips4400
:
729 case bfd_mach_mips8000
: /* MIPS4 */
730 case bfd_mach_mips6000
: /* Real MIPS2: */
731 arch_flags
= M_MIPS2
;
734 arch_flags
= M_UNKNOWN
;
742 case 0: arch_flags
= M_NS32532
; break;
743 case 32032: arch_flags
= M_NS32032
; break;
744 case 32532: arch_flags
= M_NS32532
; break;
745 default: arch_flags
= M_UNKNOWN
; break;
750 /* TODO: arch_flags = M_PDP11; */
759 arch_flags
= M_UNKNOWN
;
762 if (arch_flags
!= M_UNKNOWN
)
768 /* Set the architecture and the machine of the ABFD to the
769 values ARCH and MACHINE. Verify that @ABFD's format
770 can support the architecture required. */
773 NAME (aout
, set_arch_mach
) (bfd
*abfd
,
774 enum bfd_architecture arch
,
775 unsigned long machine
)
777 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
780 if (arch
!= bfd_arch_unknown
)
784 NAME (aout
, machine_type
) (arch
, machine
, &unknown
);
789 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
791 return (*aout_backend_info(abfd
)->set_sizes
) (abfd
);
795 adjust_o_magic (bfd
*abfd
, struct internal_exec
*execp
)
797 file_ptr pos
= adata (abfd
).exec_bytes_size
;
800 asection
*text
= obj_textsec (abfd
);
801 asection
*data
= obj_datasec (abfd
);
802 asection
*bss
= obj_bsssec (abfd
);
806 if (!text
->user_set_vma
)
811 pos
+= execp
->a_text
;
812 vma
+= execp
->a_text
;
815 if (!data
->user_set_vma
)
823 execp
->a_text
+= pad
;
830 if (!bss
->user_set_vma
)
836 else if (data
->size
> 0 || bss
->size
> 0) /* PR25677: for objcopy --extract-symbol */
838 /* The VMA of the .bss section is set by the VMA of the
839 .data section plus the size of the .data section. We may
840 need to add padding bytes to make this true. */
841 pad
= bss
->vma
- vma
;
846 execp
->a_data
= data
->size
+ pad
;
848 execp
->a_bss
= bss
->size
;
850 N_SET_MAGIC (execp
, OMAGIC
);
854 adjust_z_magic (bfd
*abfd
, struct internal_exec
*execp
)
856 bfd_size_type data_pad
, text_pad
;
858 const struct aout_backend_data
*abdp
;
859 /* TRUE if text includes exec header. */
861 asection
*text
= obj_textsec (abfd
);
862 asection
*data
= obj_datasec (abfd
);
863 asection
*bss
= obj_bsssec (abfd
);
865 abdp
= aout_backend_info (abfd
);
869 && (abdp
->text_includes_header
870 || obj_aout_subformat (abfd
) == q_magic_format
));
871 text
->filepos
= (ztih
872 ? adata (abfd
).exec_bytes_size
873 : adata (abfd
).zmagic_disk_block_size
);
874 if (!text
->user_set_vma
)
876 /* ?? Do we really need to check for relocs here? */
877 text
->vma
= ((abfd
->flags
& HAS_RELOC
)
880 ? abdp
->default_text_vma
+ adata (abfd
).exec_bytes_size
881 : abdp
->default_text_vma
));
886 /* The .text section is being loaded at an unusual address. We
887 may need to pad it such that the .data section starts at a page
890 text_pad
= ((text
->filepos
- text
->vma
)
891 & (adata (abfd
).page_size
- 1));
893 text_pad
= (-text
->vma
894 & (adata (abfd
).page_size
- 1));
897 /* Find start of data. */
900 text_end
= text
->filepos
+ execp
->a_text
;
901 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
905 /* Note that if page_size == zmagic_disk_block_size, then
906 filepos == page_size, and this case is the same as the ztih
908 text_end
= execp
->a_text
;
909 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
910 text_end
+= text
->filepos
;
912 execp
->a_text
+= text_pad
;
915 if (!data
->user_set_vma
)
918 vma
= text
->vma
+ execp
->a_text
;
919 data
->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
921 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
923 text_pad
= data
->vma
- (text
->vma
+ execp
->a_text
);
924 /* Only pad the text section if the data
925 section is going to be placed after it. */
927 execp
->a_text
+= text_pad
;
929 data
->filepos
= text
->filepos
+ execp
->a_text
;
931 /* Fix up exec header while we're at it. */
932 if (ztih
&& (!abdp
|| (abdp
&& !abdp
->exec_header_not_counted
)))
933 execp
->a_text
+= adata (abfd
).exec_bytes_size
;
934 N_SET_MAGIC (execp
, ZMAGIC
);
936 /* Spec says data section should be rounded up to page boundary. */
937 execp
->a_data
= align_power (data
->size
, bss
->alignment_power
);
938 execp
->a_data
= BFD_ALIGN (execp
->a_data
, adata (abfd
).page_size
);
939 data_pad
= execp
->a_data
- data
->size
;
942 if (!bss
->user_set_vma
)
943 bss
->vma
= data
->vma
+ execp
->a_data
;
944 /* If the BSS immediately follows the data section and extra space
945 in the page is left after the data section, fudge data
946 in the header so that the bss section looks smaller by that
947 amount. We'll start the bss section there, and lie to the OS.
948 (Note that a linker script, as well as the above assignment,
949 could have explicitly set the BSS vma to immediately follow
950 the data section.) */
951 if (align_power (bss
->vma
, bss
->alignment_power
) == data
->vma
+ execp
->a_data
)
952 execp
->a_bss
= data_pad
> bss
->size
? 0 : bss
->size
- data_pad
;
954 execp
->a_bss
= bss
->size
;
958 adjust_n_magic (bfd
*abfd
, struct internal_exec
*execp
)
960 file_ptr pos
= adata (abfd
).exec_bytes_size
;
963 asection
*text
= obj_textsec (abfd
);
964 asection
*data
= obj_datasec (abfd
);
965 asection
*bss
= obj_bsssec (abfd
);
969 if (!text
->user_set_vma
)
973 pos
+= execp
->a_text
;
974 vma
+= execp
->a_text
;
978 if (!data
->user_set_vma
)
979 data
->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
982 /* Since BSS follows data immediately, see if it needs alignment. */
984 pad
= align_power (vma
, bss
->alignment_power
) - vma
;
985 execp
->a_data
= data
->size
+ pad
;
986 pos
+= execp
->a_data
;
989 if (!bss
->user_set_vma
)
994 /* Fix up exec header. */
995 execp
->a_bss
= bss
->size
;
996 N_SET_MAGIC (execp
, NMAGIC
);
1000 adjust_i_magic (bfd
*abfd
, struct internal_exec
*execp
)
1002 file_ptr pos
= adata (abfd
).exec_bytes_size
;
1005 asection
*text
= obj_textsec (abfd
);
1006 asection
*data
= obj_datasec (abfd
);
1007 asection
*bss
= obj_bsssec (abfd
);
1010 text
->filepos
= pos
;
1011 if (!text
->user_set_vma
)
1015 pos
+= execp
->a_text
;
1018 data
->filepos
= pos
;
1019 if (!data
->user_set_vma
)
1023 /* Since BSS follows data immediately, see if it needs alignment. */
1025 pad
= align_power (vma
, bss
->alignment_power
) - vma
;
1026 execp
->a_data
= data
->size
+ pad
;
1027 pos
+= execp
->a_data
;
1030 if (!bss
->user_set_vma
)
1035 /* Fix up exec header. */
1036 execp
->a_bss
= bss
->size
;
1037 N_SET_MAGIC (execp
, IMAGIC
);
1041 NAME (aout
, adjust_sizes_and_vmas
) (bfd
*abfd
)
1043 struct internal_exec
*execp
= exec_hdr (abfd
);
1045 if (! NAME (aout
, make_sections
) (abfd
))
1048 if (adata (abfd
).magic
!= undecided_magic
)
1051 execp
->a_text
= align_power (obj_textsec (abfd
)->size
,
1052 obj_textsec (abfd
)->alignment_power
);
1054 /* Rule (heuristic) for when to pad to a new page. Note that there
1055 are (at least) two ways demand-paged (ZMAGIC) files have been
1056 handled. Most Berkeley-based systems start the text segment at
1057 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1058 segment right after the exec header; the latter is counted in the
1059 text segment size, and is paged in by the kernel with the rest of
1062 /* This perhaps isn't the right way to do this, but made it simpler for me
1063 to understand enough to implement it. Better would probably be to go
1064 right from BFD flags to alignment/positioning characteristics. But the
1065 old code was sloppy enough about handling the flags, and had enough
1066 other magic, that it was a little hard for me to understand. I think
1067 I understand it better now, but I haven't time to do the cleanup this
1071 adata (abfd
).magic
= i_magic
;
1072 else if (abfd
->flags
& WP_TEXT
)
1073 adata (abfd
).magic
= n_magic
;
1075 adata (abfd
).magic
= o_magic
;
1077 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1079 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1081 switch (adata (abfd
).magic
)
1083 case n_magic
: str
= "NMAGIC"; break;
1084 case o_magic
: str
= "OMAGIC"; break;
1085 case i_magic
: str
= "IMAGIC"; break;
1086 case z_magic
: str
= "ZMAGIC"; break;
1091 obj_textsec (abfd
)->vma
, obj_textsec (abfd
)->size
,
1092 obj_textsec (abfd
)->alignment_power
,
1093 obj_datasec (abfd
)->vma
, obj_datasec (abfd
)->size
,
1094 obj_datasec (abfd
)->alignment_power
,
1095 obj_bsssec (abfd
)->vma
, obj_bsssec (abfd
)->size
,
1096 obj_bsssec (abfd
)->alignment_power
);
1100 switch (adata (abfd
).magic
)
1103 adjust_o_magic (abfd
, execp
);
1106 adjust_z_magic (abfd
, execp
);
1109 adjust_n_magic (abfd
, execp
);
1112 adjust_i_magic (abfd
, execp
);
1118 #ifdef BFD_AOUT_DEBUG
1119 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1120 obj_textsec (abfd
)->vma
, execp
->a_text
,
1121 obj_textsec (abfd
)->filepos
,
1122 obj_datasec (abfd
)->vma
, execp
->a_data
,
1123 obj_datasec (abfd
)->filepos
,
1124 obj_bsssec (abfd
)->vma
, execp
->a_bss
);
1130 /* Called by the BFD in response to a bfd_make_section request. */
1133 NAME (aout
, new_section_hook
) (bfd
*abfd
, asection
*newsect
)
1135 /* Align to double at least. */
1136 newsect
->alignment_power
= bfd_get_arch_info(abfd
)->section_align_power
;
1138 if (bfd_get_format (abfd
) == bfd_object
)
1140 if (obj_textsec (abfd
) == NULL
1141 && !strcmp (newsect
->name
, ".text"))
1143 obj_textsec(abfd
)= newsect
;
1144 newsect
->target_index
= N_TEXT
;
1146 else if (obj_datasec (abfd
) == NULL
1147 && !strcmp (newsect
->name
, ".data"))
1149 obj_datasec (abfd
) = newsect
;
1150 newsect
->target_index
= N_DATA
;
1152 else if (obj_bsssec (abfd
) == NULL
1153 && !strcmp (newsect
->name
, ".bss"))
1155 obj_bsssec (abfd
) = newsect
;
1156 newsect
->target_index
= N_BSS
;
1160 /* We allow more than three sections internally. */
1161 return _bfd_generic_new_section_hook (abfd
, newsect
);
1165 NAME (aout
, set_section_contents
) (bfd
*abfd
,
1167 const void * location
,
1169 bfd_size_type count
)
1171 if (! abfd
->output_has_begun
)
1173 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
1177 if (section
== obj_bsssec (abfd
))
1179 bfd_set_error (bfd_error_no_contents
);
1183 if (section
!= obj_textsec (abfd
)
1184 && section
!= obj_datasec (abfd
))
1187 /* xgettext:c-format */
1188 (_("%pB: can not represent section `%pA' in a.out object file format"),
1190 bfd_set_error (bfd_error_nonrepresentable_section
);
1196 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
1197 || bfd_bwrite (location
, count
, abfd
) != count
)
1204 /* Read the external symbols from an a.out file. */
1207 aout_get_external_symbols (bfd
*abfd
)
1209 if (obj_aout_external_syms (abfd
) == NULL
)
1211 bfd_size_type count
;
1212 struct external_nlist
*syms
;
1214 count
= exec_hdr (abfd
)->a_syms
/ EXTERNAL_NLIST_SIZE
;
1216 /* PR 17512: file: 011f5a08. */
1219 obj_aout_external_syms (abfd
) = NULL
;
1220 obj_aout_external_sym_count (abfd
) = count
;
1225 if (! bfd_get_file_window (abfd
, obj_sym_filepos (abfd
),
1226 exec_hdr (abfd
)->a_syms
,
1227 &obj_aout_sym_window (abfd
), TRUE
))
1229 syms
= (struct external_nlist
*) obj_aout_sym_window (abfd
).data
;
1231 /* We allocate using malloc to make the values easy to free
1232 later on. If we put them on the objalloc it might not be
1233 possible to free them. */
1234 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1236 syms
= (struct external_nlist
*)
1237 _bfd_malloc_and_read (abfd
, count
* EXTERNAL_NLIST_SIZE
,
1238 count
* EXTERNAL_NLIST_SIZE
);
1239 if (syms
== NULL
&& count
!= 0)
1243 obj_aout_external_syms (abfd
) = syms
;
1244 obj_aout_external_sym_count (abfd
) = count
;
1247 if (obj_aout_external_strings (abfd
) == NULL
1248 && exec_hdr (abfd
)->a_syms
!= 0)
1250 unsigned char string_chars
[BYTES_IN_LONG
];
1251 bfd_size_type stringsize
;
1254 /* Get the size of the strings. */
1255 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
1256 || (bfd_bread ((void *) string_chars
, (bfd_size_type
) BYTES_IN_LONG
,
1257 abfd
) != BYTES_IN_LONG
))
1259 stringsize
= H_GET_32 (abfd
, string_chars
);
1262 if (! bfd_get_file_window (abfd
, obj_str_filepos (abfd
), stringsize
,
1263 &obj_aout_string_window (abfd
), TRUE
))
1265 strings
= (char *) obj_aout_string_window (abfd
).data
;
1267 strings
= bfd_malloc (stringsize
+ 1);
1268 if (strings
== NULL
)
1271 /* Skip space for the string count in the buffer for convenience
1272 when using indexes. */
1273 if (bfd_bread (strings
+ 4, stringsize
- 4, abfd
) != stringsize
- 4)
1279 /* Ensure that a zero index yields an empty string. */
1282 strings
[stringsize
- 1] = 0;
1284 obj_aout_external_strings (abfd
) = strings
;
1285 obj_aout_external_string_size (abfd
) = stringsize
;
1291 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1292 and symbol->value fields of CACHE_PTR will be set from the a.out
1293 nlist structure. This function is responsible for setting
1294 symbol->flags and symbol->section, and adjusting symbol->value. */
1297 translate_from_native_sym_flags (bfd
*abfd
,
1298 aout_symbol_type
*cache_ptr
)
1302 if (cache_ptr
->type
== N_FN
)
1306 /* This is a debugging symbol. */
1307 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1309 /* Work out the symbol section. */
1310 switch (cache_ptr
->type
& N_TYPE
)
1314 sec
= obj_textsec (abfd
);
1317 sec
= obj_datasec (abfd
);
1320 sec
= obj_bsssec (abfd
);
1324 sec
= bfd_abs_section_ptr
;
1328 cache_ptr
->symbol
.section
= sec
;
1329 cache_ptr
->symbol
.value
-= sec
->vma
;
1334 /* Get the default visibility. This does not apply to all types, so
1335 we just hold it in a local variable to use if wanted. */
1336 if ((cache_ptr
->type
& N_EXT
) == 0)
1337 visible
= BSF_LOCAL
;
1339 visible
= BSF_GLOBAL
;
1341 switch (cache_ptr
->type
)
1344 case N_ABS
: case N_ABS
| N_EXT
:
1345 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1346 cache_ptr
->symbol
.flags
= visible
;
1349 case N_UNDF
| N_EXT
:
1350 if (cache_ptr
->symbol
.value
!= 0)
1352 /* This is a common symbol. */
1353 cache_ptr
->symbol
.flags
= BSF_GLOBAL
;
1354 cache_ptr
->symbol
.section
= bfd_com_section_ptr
;
1358 cache_ptr
->symbol
.flags
= 0;
1359 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1363 case N_TEXT
: case N_TEXT
| N_EXT
:
1364 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1365 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1366 cache_ptr
->symbol
.flags
= visible
;
1369 case N_DATA
: case N_DATA
| N_EXT
:
1370 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1371 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1372 cache_ptr
->symbol
.flags
= visible
;
1375 case N_BSS
: case N_BSS
| N_EXT
:
1376 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1377 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1378 cache_ptr
->symbol
.flags
= visible
;
1385 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1388 translate_to_native_sym_flags (bfd
*abfd
,
1390 struct external_nlist
*sym_pointer
)
1392 bfd_vma value
= cache_ptr
->value
;
1396 /* Mask out any existing type bits in case copying from one section
1398 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1400 sec
= bfd_asymbol_section (cache_ptr
);
1405 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1408 /* xgettext:c-format */
1409 (_("%pB: can not represent section for symbol `%s' in a.out object file format"),
1410 abfd
, cache_ptr
->name
!= NULL
? cache_ptr
->name
: "*unknown*");
1411 bfd_set_error (bfd_error_nonrepresentable_section
);
1415 if (sec
->output_section
!= NULL
)
1417 off
= sec
->output_offset
;
1418 sec
= sec
->output_section
;
1421 if (bfd_is_abs_section (sec
))
1422 sym_pointer
->e_type
[0] |= N_ABS
;
1423 else if (sec
== obj_textsec (abfd
))
1424 sym_pointer
->e_type
[0] |= N_TEXT
;
1425 else if (sec
== obj_datasec (abfd
))
1426 sym_pointer
->e_type
[0] |= N_DATA
;
1427 else if (sec
== obj_bsssec (abfd
))
1428 sym_pointer
->e_type
[0] |= N_BSS
;
1429 else if (bfd_is_und_section (sec
))
1430 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1431 else if (bfd_is_com_section (sec
))
1432 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1436 /* xgettext:c-format */
1437 (_("%pB: can not represent section `%pA' in a.out object file format"),
1439 bfd_set_error (bfd_error_nonrepresentable_section
);
1443 /* Turn the symbol from section relative to absolute again */
1444 value
+= sec
->vma
+ off
;
1446 if ((cache_ptr
->flags
& BSF_DEBUGGING
) != 0)
1447 sym_pointer
->e_type
[0] = ((aout_symbol_type
*) cache_ptr
)->type
;
1448 else if ((cache_ptr
->flags
& BSF_GLOBAL
) != 0)
1449 sym_pointer
->e_type
[0] |= N_EXT
;
1451 PUT_WORD(abfd
, value
, sym_pointer
->e_value
);
1456 /* Native-level interface to symbols. */
1459 NAME (aout
, make_empty_symbol
) (bfd
*abfd
)
1461 size_t amt
= sizeof (aout_symbol_type
);
1462 aout_symbol_type
*new_symbol_type
= bfd_zalloc (abfd
, amt
);
1464 if (!new_symbol_type
)
1466 new_symbol_type
->symbol
.the_bfd
= abfd
;
1468 return &new_symbol_type
->symbol
;
1471 /* Translate a set of internal symbols into external symbols. */
1474 NAME (aout
, translate_symbol_table
) (bfd
*abfd
,
1475 aout_symbol_type
*in
,
1476 struct external_nlist
*ext
,
1477 bfd_size_type count
,
1479 bfd_size_type strsize
,
1480 bfd_boolean dynamic
)
1482 struct external_nlist
*ext_end
;
1484 ext_end
= ext
+ count
;
1485 for (; ext
< ext_end
; ext
++, in
++)
1489 x
= GET_WORD (abfd
, ext
->e_strx
);
1490 in
->symbol
.the_bfd
= abfd
;
1492 /* For the normal symbols, the zero index points at the number
1493 of bytes in the string table but is to be interpreted as the
1494 null string. For the dynamic symbols, the number of bytes in
1495 the string table is stored in the __DYNAMIC structure and the
1496 zero index points at an actual string. */
1497 if (x
== 0 && ! dynamic
)
1498 in
->symbol
.name
= "";
1499 else if (x
< strsize
)
1500 in
->symbol
.name
= str
+ x
;
1504 in
->symbol
.value
= GET_SWORD (abfd
, ext
->e_value
);
1505 /* TODO: is 0 a safe value here? */
1508 in
->type
= H_GET_8 (abfd
, ext
->e_type
);
1509 in
->symbol
.udata
.p
= NULL
;
1511 if (! translate_from_native_sym_flags (abfd
, in
))
1515 in
->symbol
.flags
|= BSF_DYNAMIC
;
1521 /* We read the symbols into a buffer, which is discarded when this
1522 function exits. We read the strings into a buffer large enough to
1523 hold them all plus all the cached symbol entries. */
1526 NAME (aout
, slurp_symbol_table
) (bfd
*abfd
)
1528 struct external_nlist
*old_external_syms
;
1529 aout_symbol_type
*cached
;
1530 bfd_size_type cached_size
;
1532 /* If there's no work to be done, don't do any. */
1533 if (obj_aout_symbols (abfd
) != NULL
)
1536 old_external_syms
= obj_aout_external_syms (abfd
);
1538 if (! aout_get_external_symbols (abfd
))
1541 cached_size
= obj_aout_external_sym_count (abfd
);
1542 cached_size
*= sizeof (aout_symbol_type
);
1543 cached
= bfd_zmalloc (cached_size
);
1544 if (cached
== NULL
&& cached_size
!= 0)
1547 /* Convert from external symbol information to internal. */
1548 if (! (NAME (aout
, translate_symbol_table
)
1550 obj_aout_external_syms (abfd
),
1551 obj_aout_external_sym_count (abfd
),
1552 obj_aout_external_strings (abfd
),
1553 obj_aout_external_string_size (abfd
),
1560 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
1562 obj_aout_symbols (abfd
) = cached
;
1564 /* It is very likely that anybody who calls this function will not
1565 want the external symbol information, so if it was allocated
1566 because of our call to aout_get_external_symbols, we free it up
1567 right away to save space. */
1568 if (old_external_syms
== NULL
1569 && obj_aout_external_syms (abfd
) != NULL
)
1572 bfd_free_window (&obj_aout_sym_window (abfd
));
1574 free (obj_aout_external_syms (abfd
));
1576 obj_aout_external_syms (abfd
) = NULL
;
1582 /* We use a hash table when writing out symbols so that we only write
1583 out a particular string once. This helps particularly when the
1584 linker writes out stabs debugging entries, because each different
1585 contributing object file tends to have many duplicate stabs
1588 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1589 if BFD_TRADITIONAL_FORMAT is set. */
1591 /* Get the index of a string in a strtab, adding it if it is not
1594 static INLINE bfd_size_type
1595 add_to_stringtab (bfd
*abfd
,
1596 struct bfd_strtab_hash
*tab
,
1601 bfd_size_type str_index
;
1603 /* An index of 0 always means the empty string. */
1604 if (str
== 0 || *str
== '\0')
1607 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1608 doesn't understand a hashed string table. */
1610 if ((abfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1613 str_index
= _bfd_stringtab_add (tab
, str
, hash
, copy
);
1615 if (str_index
!= (bfd_size_type
) -1)
1616 /* Add BYTES_IN_LONG to the return value to account for the
1617 space taken up by the string table size. */
1618 str_index
+= BYTES_IN_LONG
;
1623 /* Write out a strtab. ABFD is already at the right location in the
1627 emit_stringtab (bfd
*abfd
, struct bfd_strtab_hash
*tab
)
1629 bfd_byte buffer
[BYTES_IN_LONG
];
1631 /* The string table starts with the size. */
1632 H_PUT_32 (abfd
, _bfd_stringtab_size (tab
) + BYTES_IN_LONG
, buffer
);
1633 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) BYTES_IN_LONG
, abfd
)
1637 return _bfd_stringtab_emit (abfd
, tab
);
1641 NAME (aout
, write_syms
) (bfd
*abfd
)
1643 unsigned int count
;
1644 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1645 struct bfd_strtab_hash
*strtab
;
1647 strtab
= _bfd_stringtab_init ();
1651 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1653 asymbol
*g
= generic
[count
];
1655 struct external_nlist nsp
;
1657 PUT_WORD (abfd
, 0, nsp
.e_unused
);
1659 indx
= add_to_stringtab (abfd
, strtab
, g
->name
, FALSE
);
1660 if (indx
== (bfd_size_type
) -1)
1662 PUT_WORD (abfd
, indx
, nsp
.e_strx
);
1664 if (bfd_asymbol_flavour(g
) == abfd
->xvec
->flavour
)
1665 H_PUT_8 (abfd
, aout_symbol(g
)->type
, nsp
.e_type
);
1667 H_PUT_8 (abfd
, 0, nsp
.e_type
);
1669 if (! translate_to_native_sym_flags (abfd
, g
, &nsp
))
1672 H_PUT_8 (abfd
, 0, nsp
.e_ovly
);
1674 if (bfd_bwrite ((void *)&nsp
, (bfd_size_type
) EXTERNAL_NLIST_SIZE
, abfd
)
1675 != EXTERNAL_NLIST_SIZE
)
1678 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1679 here, at the end. */
1683 if (! emit_stringtab (abfd
, strtab
))
1686 _bfd_stringtab_free (strtab
);
1691 _bfd_stringtab_free (strtab
);
1697 NAME (aout
, canonicalize_symtab
) (bfd
*abfd
, asymbol
**location
)
1699 unsigned int counter
= 0;
1700 aout_symbol_type
*symbase
;
1702 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
1705 for (symbase
= obj_aout_symbols (abfd
); counter
++ < bfd_get_symcount (abfd
);)
1706 *(location
++) = (asymbol
*)(symbase
++);
1708 return bfd_get_symcount (abfd
);
1712 /* Output extended relocation information to a file in target byte order. */
1715 pdp11_aout_swap_reloc_out (bfd
*abfd
, arelent
*g
, bfd_byte
*natptr
)
1721 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1722 asection
*output_section
= sym
->section
->output_section
;
1725 fprintf (stderr
, "BFD: can't do this reloc addend stuff\n");
1727 r_pcrel
= g
->howto
->pc_relative
;
1729 if (bfd_is_abs_section (output_section
))
1731 else if (output_section
== obj_textsec (abfd
))
1733 else if (output_section
== obj_datasec (abfd
))
1735 else if (output_section
== obj_bsssec (abfd
))
1737 else if (bfd_is_und_section (output_section
))
1739 else if (bfd_is_com_section (output_section
))
1744 BFD_ASSERT (r_type
!= -1);
1749 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
1751 reloc_entry
= r_index
<< 4 | r_type
| r_pcrel
;
1753 PUT_WORD (abfd
, reloc_entry
, natptr
);
1756 /* BFD deals internally with all things based from the section they're
1757 in. so, something in 10 bytes into a text section with a base of
1758 50 would have a symbol (.text+10) and know .text vma was 50.
1760 Aout keeps all it's symbols based from zero, so the symbol would
1761 contain 60. This macro subs the base of each section from the value
1762 to give the true offset from the section */
1765 #define MOVE_ADDRESS(ad) \
1768 /* Undefined symbol. */ \
1769 cache_ptr->sym_ptr_ptr = symbols + r_index; \
1770 cache_ptr->addend = ad; \
1774 /* Defined, section relative. replace symbol with pointer to \
1775 symbol which points to section. */ \
1779 case N_TEXT | N_EXT: \
1780 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
1781 cache_ptr->addend = ad - su->textsec->vma; \
1784 case N_DATA | N_EXT: \
1785 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
1786 cache_ptr->addend = ad - su->datasec->vma; \
1789 case N_BSS | N_EXT: \
1790 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
1791 cache_ptr->addend = ad - su->bsssec->vma; \
1795 case N_ABS | N_EXT: \
1796 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1797 cache_ptr->addend = ad; \
1803 pdp11_aout_swap_reloc_in (bfd
* abfd
,
1805 arelent
* cache_ptr
,
1806 bfd_size_type offset
,
1808 bfd_size_type symcount
)
1810 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
1811 unsigned int r_index
;
1816 reloc_entry
= GET_WORD (abfd
, (void *) bytes
);
1818 r_pcrel
= reloc_entry
& RELFLG
;
1820 cache_ptr
->address
= offset
;
1821 cache_ptr
->howto
= howto_table_pdp11
+ (r_pcrel
? 1 : 0);
1823 if ((reloc_entry
& RTYPE
) == RABS
)
1826 r_index
= RINDEX (reloc_entry
);
1828 /* r_extern reflects whether the symbol the reloc is against is
1830 r_extern
= (reloc_entry
& RTYPE
) == REXT
;
1832 if (r_extern
&& r_index
> symcount
)
1834 /* We could arrange to return an error, but it might be useful
1835 to see the file even if it is bad. */
1843 /* Read and swap the relocs for a section. */
1846 NAME (aout
, slurp_reloc_table
) (bfd
*abfd
, sec_ptr asect
, asymbol
**symbols
)
1849 bfd_size_type count
;
1850 bfd_size_type reloc_size
;
1852 arelent
*reloc_cache
;
1854 unsigned int counter
= 0;
1857 if (asect
->relocation
)
1860 if (asect
->flags
& SEC_CONSTRUCTOR
)
1863 if (asect
== obj_datasec (abfd
))
1864 reloc_size
= exec_hdr(abfd
)->a_drsize
;
1865 else if (asect
== obj_textsec (abfd
))
1866 reloc_size
= exec_hdr(abfd
)->a_trsize
;
1867 else if (asect
== obj_bsssec (abfd
))
1871 bfd_set_error (bfd_error_invalid_operation
);
1875 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
1877 relocs
= _bfd_malloc_and_read (abfd
, reloc_size
, reloc_size
);
1878 if (relocs
== NULL
&& reloc_size
!= 0)
1881 each_size
= obj_reloc_entry_size (abfd
);
1882 count
= reloc_size
/ each_size
;
1884 /* Count the number of NON-ZERO relocs, this is the count we want. */
1886 unsigned int real_count
= 0;
1888 for (counter
= 0; counter
< count
; counter
++)
1892 x
= GET_WORD (abfd
, (char *) relocs
+ each_size
* counter
);
1900 reloc_cache
= bfd_zmalloc (count
* sizeof (arelent
));
1901 if (reloc_cache
== NULL
&& count
!= 0)
1904 cache_ptr
= reloc_cache
;
1909 counter
++, rptr
+= RELOC_SIZE
, cache_ptr
++)
1911 while (GET_WORD (abfd
, (void *) rptr
) == 0)
1914 if ((char *) rptr
>= (char *) relocs
+ reloc_size
)
1918 pdp11_aout_swap_reloc_in (abfd
, rptr
, cache_ptr
,
1919 (bfd_size_type
) ((char *) rptr
- (char *) relocs
),
1921 (bfd_size_type
) bfd_get_symcount (abfd
));
1924 /* Just in case, if rptr >= relocs + reloc_size should happen
1926 BFD_ASSERT (counter
== count
);
1930 asect
->relocation
= reloc_cache
;
1931 asect
->reloc_count
= cache_ptr
- reloc_cache
;
1936 /* Write out a relocation section into an object file. */
1939 NAME (aout
, squirt_out_relocs
) (bfd
*abfd
, asection
*section
)
1942 unsigned char *native
;
1943 unsigned int count
= section
->reloc_count
;
1944 bfd_size_type natsize
;
1946 natsize
= section
->size
;
1947 native
= bfd_zalloc (abfd
, natsize
);
1951 generic
= section
->orelocation
;
1952 if (generic
!= NULL
)
1958 r
= native
+ (*generic
)->address
;
1959 pdp11_aout_swap_reloc_out (abfd
, *generic
, r
);
1965 if (bfd_bwrite ((void *) native
, natsize
, abfd
) != natsize
)
1967 bfd_release (abfd
, native
);
1971 bfd_release (abfd
, native
);
1975 /* This is stupid. This function should be a boolean predicate. */
1978 NAME (aout
, canonicalize_reloc
) (bfd
*abfd
,
1983 arelent
*tblptr
= section
->relocation
;
1986 if (section
== obj_bsssec (abfd
))
1992 if (!(tblptr
|| NAME (aout
, slurp_reloc_table
)(abfd
, section
, symbols
)))
1995 if (section
->flags
& SEC_CONSTRUCTOR
)
1997 arelent_chain
*chain
= section
->constructor_chain
;
1999 for (count
= 0; count
< section
->reloc_count
; count
++)
2001 *relptr
++ = &chain
->relent
;
2002 chain
= chain
->next
;
2007 tblptr
= section
->relocation
;
2009 for (count
= 0; count
++ < section
->reloc_count
;)
2010 *relptr
++ = tblptr
++;
2015 return section
->reloc_count
;
2019 NAME (aout
, get_reloc_upper_bound
) (bfd
*abfd
, sec_ptr asect
)
2021 bfd_size_type count
;
2023 if (bfd_get_format (abfd
) != bfd_object
)
2025 bfd_set_error (bfd_error_invalid_operation
);
2029 if (asect
->flags
& SEC_CONSTRUCTOR
)
2030 count
= asect
->reloc_count
;
2031 else if (asect
== obj_datasec (abfd
))
2032 count
= exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
2033 else if (asect
== obj_textsec (abfd
))
2034 count
= exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
2035 else if (asect
== obj_bsssec (abfd
))
2039 bfd_set_error (bfd_error_invalid_operation
);
2043 if (count
>= LONG_MAX
/ sizeof (arelent
*))
2045 bfd_set_error (bfd_error_file_too_big
);
2048 return (count
+ 1) * sizeof (arelent
*);
2053 NAME (aout
, get_symtab_upper_bound
) (bfd
*abfd
)
2055 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
2058 return (bfd_get_symcount (abfd
) + 1) * (sizeof (aout_symbol_type
*));
2062 NAME (aout
, get_lineno
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2063 asymbol
* symbol ATTRIBUTE_UNUSED
)
2069 NAME (aout
, get_symbol_info
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2073 bfd_symbol_info (symbol
, ret
);
2075 if (ret
->type
== '?')
2077 int type_code
= aout_symbol(symbol
)->type
& 0xff;
2078 const char *stab_name
= bfd_get_stab_name (type_code
);
2079 static char buf
[10];
2081 if (stab_name
== NULL
)
2083 sprintf(buf
, "(%d)", type_code
);
2087 ret
->stab_type
= type_code
;
2088 ret
->stab_other
= (unsigned) (aout_symbol(symbol
)->other
& 0xff);
2089 ret
->stab_desc
= (unsigned) (aout_symbol(symbol
)->desc
& 0xffff);
2090 ret
->stab_name
= stab_name
;
2095 NAME (aout
, print_symbol
) (bfd
* abfd
,
2098 bfd_print_symbol_type how
)
2100 FILE *file
= (FILE *) afile
;
2104 case bfd_print_symbol_name
:
2106 fprintf(file
,"%s", symbol
->name
);
2108 case bfd_print_symbol_more
:
2109 fprintf(file
,"%4x %2x %2x",
2110 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2111 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2112 (unsigned) (aout_symbol (symbol
)->type
));
2114 case bfd_print_symbol_all
:
2116 const char *section_name
= symbol
->section
->name
;
2118 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2120 fprintf (file
," %-5s %04x %02x %02x",
2122 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2123 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2124 (unsigned) (aout_symbol (symbol
)->type
& 0xff));
2126 fprintf(file
," %s", symbol
->name
);
2132 /* If we don't have to allocate more than 1MB to hold the generic
2133 symbols, we use the generic minisymbol method: it's faster, since
2134 it only translates the symbols once, not multiple times. */
2135 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2137 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2138 symbols. The minisymbol_to_symbol function translates these into
2139 BFD asymbol structures. */
2142 NAME (aout
, read_minisymbols
) (bfd
*abfd
,
2143 bfd_boolean dynamic
,
2145 unsigned int *sizep
)
2148 /* We could handle the dynamic symbols here as well, but it's
2149 easier to hand them off. */
2150 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2152 if (! aout_get_external_symbols (abfd
))
2155 if (obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2156 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2158 *minisymsp
= (void *) obj_aout_external_syms (abfd
);
2160 /* By passing the external symbols back from this routine, we are
2161 giving up control over the memory block. Clear
2162 obj_aout_external_syms, so that we do not try to free it
2164 obj_aout_external_syms (abfd
) = NULL
;
2166 *sizep
= EXTERNAL_NLIST_SIZE
;
2167 return obj_aout_external_sym_count (abfd
);
2170 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2171 unmodified a.out symbol. The SYM argument is a structure returned
2172 by bfd_make_empty_symbol, which we fill in here. */
2175 NAME (aout
, minisymbol_to_symbol
) (bfd
*abfd
,
2176 bfd_boolean dynamic
,
2177 const void * minisym
,
2181 || obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2182 return _bfd_generic_minisymbol_to_symbol (abfd
, dynamic
, minisym
, sym
);
2184 memset (sym
, 0, sizeof (aout_symbol_type
));
2186 /* We call translate_symbol_table to translate a single symbol. */
2187 if (! (NAME (aout
, translate_symbol_table
)
2189 (aout_symbol_type
*) sym
,
2190 (struct external_nlist
*) minisym
,
2192 obj_aout_external_strings (abfd
),
2193 obj_aout_external_string_size (abfd
),
2200 /* Provided a BFD, a section and an offset into the section, calculate
2201 and return the name of the source file and the line nearest to the
2205 NAME (aout
, find_nearest_line
) (bfd
*abfd
,
2209 const char **filename_ptr
,
2210 const char **functionname_ptr
,
2211 unsigned int *line_ptr
,
2212 unsigned int *discriminator_ptr
)
2214 /* Run down the file looking for the filename, function and linenumber. */
2216 const char *directory_name
= NULL
;
2217 const char *main_file_name
= NULL
;
2218 const char *current_file_name
= NULL
;
2219 const char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2220 bfd_vma low_line_vma
= 0;
2221 bfd_vma low_func_vma
= 0;
2223 size_t filelen
, funclen
;
2226 *filename_ptr
= abfd
->filename
;
2227 *functionname_ptr
= 0;
2229 if (discriminator_ptr
)
2230 *discriminator_ptr
= 0;
2232 if (symbols
!= NULL
)
2234 for (p
= symbols
; *p
; p
++)
2236 aout_symbol_type
*q
= (aout_symbol_type
*)(*p
);
2241 /* If this looks like a file name symbol, and it comes after
2242 the line number we have found so far, but before the
2243 offset, then we have probably not found the right line
2245 if (q
->symbol
.value
<= offset
2246 && ((q
->symbol
.value
> low_line_vma
2247 && (line_file_name
!= NULL
2249 || (q
->symbol
.value
> low_func_vma
2252 const char * symname
;
2254 symname
= q
->symbol
.name
;
2255 if (strcmp (symname
+ strlen (symname
) - 2, ".o") == 0)
2257 if (q
->symbol
.value
> low_line_vma
)
2260 line_file_name
= NULL
;
2262 if (q
->symbol
.value
> low_func_vma
)
2269 /* If this symbol is less than the offset, but greater than
2270 the line number we have found so far, then we have not
2271 found the right line number. */
2272 if (q
->symbol
.value
<= offset
)
2274 if (q
->symbol
.value
> low_line_vma
)
2277 line_file_name
= NULL
;
2279 if (q
->symbol
.value
> low_func_vma
)
2283 main_file_name
= current_file_name
= q
->symbol
.name
;
2284 /* Look ahead to next symbol to check if that too is an N_SO. */
2288 q
= (aout_symbol_type
*)(*p
);
2289 if (q
->type
!= (int) N_SO
)
2292 /* Found a second N_SO First is directory; second is filename. */
2293 directory_name
= current_file_name
;
2294 main_file_name
= current_file_name
= q
->symbol
.name
;
2295 if (obj_textsec(abfd
) != section
)
2299 current_file_name
= q
->symbol
.name
;
2305 /* We'll keep this if it resolves nearer than the one we have
2307 if (q
->symbol
.value
>= low_line_vma
2308 && q
->symbol
.value
<= offset
)
2310 *line_ptr
= q
->desc
;
2311 low_line_vma
= q
->symbol
.value
;
2312 line_file_name
= current_file_name
;
2318 /* We'll keep this if it is nearer than the one we have already. */
2319 if (q
->symbol
.value
>= low_func_vma
&&
2320 q
->symbol
.value
<= offset
)
2322 low_func_vma
= q
->symbol
.value
;
2323 func
= (asymbol
*) q
;
2325 else if (q
->symbol
.value
> offset
)
2335 main_file_name
= line_file_name
;
2337 if (main_file_name
== NULL
2338 || main_file_name
[0] == '/'
2339 || directory_name
== NULL
)
2342 filelen
= strlen (directory_name
) + strlen (main_file_name
);
2346 funclen
= strlen (bfd_asymbol_name (func
));
2348 if (adata (abfd
).line_buf
!= NULL
)
2349 free (adata (abfd
).line_buf
);
2350 if (filelen
+ funclen
== 0)
2351 adata (abfd
).line_buf
= buf
= NULL
;
2354 buf
= bfd_malloc ((bfd_size_type
) filelen
+ funclen
+ 3);
2355 adata (abfd
).line_buf
= buf
;
2360 if (main_file_name
!= NULL
)
2362 if (main_file_name
[0] == '/' || directory_name
== NULL
)
2363 *filename_ptr
= main_file_name
;
2366 sprintf (buf
, "%s%s", directory_name
, main_file_name
);
2367 *filename_ptr
= buf
;
2374 const char *function
= func
->name
;
2377 /* The caller expects a symbol name. We actually have a
2378 function name, without the leading underscore. Put the
2379 underscore back in, so that the caller gets a symbol name. */
2380 if (bfd_get_symbol_leading_char (abfd
) == '\0')
2381 strcpy (buf
, function
);
2384 buf
[0] = bfd_get_symbol_leading_char (abfd
);
2385 strcpy (buf
+ 1, function
);
2388 /* Have to remove : stuff. */
2389 colon
= strchr (buf
, ':');
2392 *functionname_ptr
= buf
;
2399 NAME (aout
, sizeof_headers
) (bfd
*abfd
,
2400 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2402 return adata (abfd
).exec_bytes_size
;
2405 /* Free all information we have cached for this BFD. We can always
2406 read it again later if we need it. */
2409 NAME (aout
, bfd_free_cached_info
) (bfd
*abfd
)
2413 if (bfd_get_format (abfd
) != bfd_object
)
2416 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2417 BFCI_FREE (obj_aout_symbols (abfd
));
2420 obj_aout_external_syms (abfd
) = 0;
2421 bfd_free_window (&obj_aout_sym_window (abfd
));
2422 bfd_free_window (&obj_aout_string_window (abfd
));
2423 obj_aout_external_strings (abfd
) = 0;
2425 BFCI_FREE (obj_aout_external_syms (abfd
));
2426 BFCI_FREE (obj_aout_external_strings (abfd
));
2428 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2429 BFCI_FREE (o
->relocation
);
2435 /* Routine to create an entry in an a.out link hash table. */
2437 struct bfd_hash_entry
*
2438 NAME (aout
, link_hash_newfunc
) (struct bfd_hash_entry
*entry
,
2439 struct bfd_hash_table
*table
,
2442 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2444 /* Allocate the structure if it has not already been allocated by a
2447 ret
= bfd_hash_allocate (table
, sizeof (* ret
));
2451 /* Call the allocation method of the superclass. */
2452 ret
= (struct aout_link_hash_entry
*)
2453 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
);
2456 /* Set local fields. */
2457 ret
->written
= FALSE
;
2461 return (struct bfd_hash_entry
*) ret
;
2464 /* Initialize an a.out link hash table. */
2467 NAME (aout
, link_hash_table_init
) (struct aout_link_hash_table
*table
,
2469 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
2470 struct bfd_hash_table
*,
2472 unsigned int entsize
)
2474 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
2477 /* Create an a.out link hash table. */
2479 struct bfd_link_hash_table
*
2480 NAME (aout
, link_hash_table_create
) (bfd
*abfd
)
2482 struct aout_link_hash_table
*ret
;
2483 size_t amt
= sizeof (struct aout_link_hash_table
);
2485 ret
= bfd_malloc (amt
);
2488 if (! NAME (aout
, link_hash_table_init
) (ret
, abfd
,
2489 NAME (aout
, link_hash_newfunc
),
2490 sizeof (struct aout_link_hash_entry
)))
2498 /* Free up the internal symbols read from an a.out file. */
2501 aout_link_free_symbols (bfd
*abfd
)
2503 if (obj_aout_external_syms (abfd
) != NULL
)
2506 bfd_free_window (&obj_aout_sym_window (abfd
));
2508 free ((void *) obj_aout_external_syms (abfd
));
2510 obj_aout_external_syms (abfd
) = NULL
;
2513 if (obj_aout_external_strings (abfd
) != NULL
)
2516 bfd_free_window (&obj_aout_string_window (abfd
));
2518 free ((void *) obj_aout_external_strings (abfd
));
2520 obj_aout_external_strings (abfd
) = NULL
;
2525 /* Given an a.out BFD, add symbols to the global hash table as
2529 NAME (aout
, link_add_symbols
) (bfd
*abfd
, struct bfd_link_info
*info
)
2531 switch (bfd_get_format (abfd
))
2534 return aout_link_add_object_symbols (abfd
, info
);
2536 return _bfd_generic_link_add_archive_symbols
2537 (abfd
, info
, aout_link_check_archive_element
);
2539 bfd_set_error (bfd_error_wrong_format
);
2544 /* Add symbols from an a.out object file. */
2547 aout_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2549 if (! aout_get_external_symbols (abfd
))
2551 if (! aout_link_add_symbols (abfd
, info
))
2553 if (! info
->keep_memory
)
2555 if (! aout_link_free_symbols (abfd
))
2561 /* Look through the internal symbols to see if this object file should
2562 be included in the link. We should include this object file if it
2563 defines any symbols which are currently undefined. If this object
2564 file defines a common symbol, then we may adjust the size of the
2565 known symbol but we do not include the object file in the link
2566 (unless there is some other reason to include it). */
2569 aout_link_check_ar_symbols (bfd
*abfd
,
2570 struct bfd_link_info
*info
,
2571 bfd_boolean
*pneeded
,
2574 struct external_nlist
*p
;
2575 struct external_nlist
*pend
;
2580 /* Look through all the symbols. */
2581 p
= obj_aout_external_syms (abfd
);
2582 pend
= p
+ obj_aout_external_sym_count (abfd
);
2583 strings
= obj_aout_external_strings (abfd
);
2584 for (; p
< pend
; p
++)
2586 int type
= H_GET_8 (abfd
, p
->e_type
);
2588 struct bfd_link_hash_entry
*h
;
2590 /* Ignore symbols that are not externally visible. This is an
2591 optimization only, as we check the type more thoroughly
2593 if ((type
& N_EXT
) == 0
2597 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2598 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
2600 /* We are only interested in symbols that are currently
2601 undefined or common. */
2603 || (h
->type
!= bfd_link_hash_undefined
2604 && h
->type
!= bfd_link_hash_common
))
2607 if (type
== (N_TEXT
| N_EXT
)
2608 || type
== (N_DATA
| N_EXT
)
2609 || type
== (N_BSS
| N_EXT
)
2610 || type
== (N_ABS
| N_EXT
))
2612 /* This object file defines this symbol. We must link it
2613 in. This is true regardless of whether the current
2614 definition of the symbol is undefined or common. If the
2615 current definition is common, we have a case in which we
2616 have already seen an object file including
2618 and this object file from the archive includes
2620 In such a case we must include this object file.
2622 FIXME: The SunOS 4.1.3 linker will pull in the archive
2623 element if the symbol is defined in the .data section,
2624 but not if it is defined in the .text section. That
2625 seems a bit crazy to me, and I haven't implemented it.
2626 However, it might be correct. */
2627 if (!(*info
->callbacks
2628 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2634 if (type
== (N_UNDF
| N_EXT
))
2638 value
= GET_WORD (abfd
, p
->e_value
);
2641 /* This symbol is common in the object from the archive
2643 if (h
->type
== bfd_link_hash_undefined
)
2648 symbfd
= h
->u
.undef
.abfd
;
2651 /* This symbol was created as undefined from
2652 outside BFD. We assume that we should link
2653 in the object file. This is done for the -u
2654 option in the linker. */
2655 if (!(*info
->callbacks
2656 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2661 /* Turn the current link symbol into a common
2662 symbol. It is already on the undefs list. */
2663 h
->type
= bfd_link_hash_common
;
2664 h
->u
.c
.p
= bfd_hash_allocate (&info
->hash
->table
,
2665 sizeof (struct bfd_link_hash_common_entry
));
2666 if (h
->u
.c
.p
== NULL
)
2669 h
->u
.c
.size
= value
;
2671 /* FIXME: This isn't quite right. The maximum
2672 alignment of a common symbol should be set by the
2673 architecture of the output file, not of the input
2675 power
= bfd_log2 (value
);
2676 if (power
> bfd_get_arch_info (abfd
)->section_align_power
)
2677 power
= bfd_get_arch_info (abfd
)->section_align_power
;
2678 h
->u
.c
.p
->alignment_power
= power
;
2680 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
,
2685 /* Adjust the size of the common symbol if
2687 if (value
> h
->u
.c
.size
)
2688 h
->u
.c
.size
= value
;
2694 /* We do not need this object file. */
2698 /* Check a single archive element to see if we need to include it in
2699 the link. *PNEEDED is set according to whether this element is
2700 needed in the link or not. This is called from
2701 _bfd_generic_link_add_archive_symbols. */
2704 aout_link_check_archive_element (bfd
*abfd
,
2705 struct bfd_link_info
*info
,
2706 struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
2707 const char *name ATTRIBUTE_UNUSED
,
2708 bfd_boolean
*pneeded
)
2713 if (!aout_get_external_symbols (abfd
))
2717 if (!aout_link_check_ar_symbols (abfd
, info
, pneeded
, &abfd
))
2723 /* Potentially, the add_archive_element hook may have set a
2724 substitute BFD for us. */
2727 if (!info
->keep_memory
2728 && !aout_link_free_symbols (oldbfd
))
2730 if (!aout_get_external_symbols (abfd
))
2733 if (!aout_link_add_symbols (abfd
, info
))
2737 if (!info
->keep_memory
|| !needed
)
2739 if (!aout_link_free_symbols (abfd
))
2746 /* Add all symbols from an object file to the hash table. */
2749 aout_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2751 bfd_boolean (*add_one_symbol
)
2752 (struct bfd_link_info
*, bfd
*, const char *, flagword
, asection
*,
2753 bfd_vma
, const char *, bfd_boolean
, bfd_boolean
,
2754 struct bfd_link_hash_entry
**);
2755 struct external_nlist
*syms
;
2756 bfd_size_type sym_count
;
2759 struct aout_link_hash_entry
**sym_hash
;
2760 struct external_nlist
*p
;
2761 struct external_nlist
*pend
;
2763 syms
= obj_aout_external_syms (abfd
);
2764 sym_count
= obj_aout_external_sym_count (abfd
);
2765 strings
= obj_aout_external_strings (abfd
);
2766 if (info
->keep_memory
)
2771 if (aout_backend_info (abfd
)->add_dynamic_symbols
!= NULL
)
2773 if (! ((*aout_backend_info (abfd
)->add_dynamic_symbols
)
2774 (abfd
, info
, &syms
, &sym_count
, &strings
)))
2778 /* We keep a list of the linker hash table entries that correspond
2779 to particular symbols. We could just look them up in the hash
2780 table, but keeping the list is more efficient. Perhaps this
2781 should be conditional on info->keep_memory. */
2782 sym_hash
= bfd_alloc (abfd
,
2783 sym_count
* sizeof (struct aout_link_hash_entry
*));
2784 if (sym_hash
== NULL
&& sym_count
!= 0)
2786 obj_aout_sym_hashes (abfd
) = sym_hash
;
2788 add_one_symbol
= aout_backend_info (abfd
)->add_one_symbol
;
2789 if (add_one_symbol
== NULL
)
2790 add_one_symbol
= _bfd_generic_link_add_one_symbol
;
2793 pend
= p
+ sym_count
;
2794 for (; p
< pend
; p
++, sym_hash
++)
2805 type
= H_GET_8 (abfd
, p
->e_type
);
2807 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2808 value
= GET_WORD (abfd
, p
->e_value
);
2814 /* Anything else should be a debugging symbol. */
2815 BFD_ASSERT ((type
& N_STAB
) != 0);
2825 /* Ignore symbols that are not externally visible. */
2828 case N_UNDF
| N_EXT
:
2831 section
= bfd_und_section_ptr
;
2835 section
= bfd_com_section_ptr
;
2838 section
= bfd_abs_section_ptr
;
2840 case N_TEXT
| N_EXT
:
2841 section
= obj_textsec (abfd
);
2842 value
-= bfd_section_vma (section
);
2844 case N_DATA
| N_EXT
:
2845 /* Treat N_SETV symbols as N_DATA symbol; see comment in
2846 translate_from_native_sym_flags. */
2847 section
= obj_datasec (abfd
);
2848 value
-= bfd_section_vma (section
);
2851 section
= obj_bsssec (abfd
);
2852 value
-= bfd_section_vma (section
);
2856 if (! ((*add_one_symbol
)
2857 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, FALSE
,
2858 (struct bfd_link_hash_entry
**) sym_hash
)))
2861 /* Restrict the maximum alignment of a common symbol based on
2862 the architecture, since a.out has no way to represent
2863 alignment requirements of a section in a .o file. FIXME:
2864 This isn't quite right: it should use the architecture of the
2865 output file, not the input files. */
2866 if ((*sym_hash
)->root
.type
== bfd_link_hash_common
2867 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
>
2868 bfd_get_arch_info (abfd
)->section_align_power
))
2869 (*sym_hash
)->root
.u
.c
.p
->alignment_power
=
2870 bfd_get_arch_info (abfd
)->section_align_power
;
2872 /* If this is a set symbol, and we are not building sets, then
2873 it is possible for the hash entry to not have been set. In
2874 such a case, treat the symbol as not globally defined. */
2875 if ((*sym_hash
)->root
.type
== bfd_link_hash_new
)
2877 BFD_ASSERT ((flags
& BSF_CONSTRUCTOR
) != 0);
2885 /* Look up an entry in an the header file hash table. */
2887 #define aout_link_includes_lookup(table, string, create, copy) \
2888 ((struct aout_link_includes_entry *) \
2889 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
2891 /* The function to create a new entry in the header file hash table. */
2893 static struct bfd_hash_entry
*
2894 aout_link_includes_newfunc (struct bfd_hash_entry
*entry
,
2895 struct bfd_hash_table
*table
,
2898 struct aout_link_includes_entry
* ret
=
2899 (struct aout_link_includes_entry
*) entry
;
2901 /* Allocate the structure if it has not already been allocated by a
2904 ret
= bfd_hash_allocate (table
,
2905 sizeof (struct aout_link_includes_entry
));
2909 /* Call the allocation method of the superclass. */
2910 ret
= ((struct aout_link_includes_entry
*)
2911 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
2913 /* Set local fields. */
2916 return (struct bfd_hash_entry
*) ret
;
2920 aout_link_write_other_symbol (struct bfd_hash_entry
*bh
, void *data
)
2922 struct aout_link_hash_entry
*h
= (struct aout_link_hash_entry
*) bh
;
2923 struct aout_final_link_info
*flaginfo
= (struct aout_final_link_info
*) data
;
2927 struct external_nlist outsym
;
2931 if (h
->root
.type
== bfd_link_hash_warning
)
2933 h
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
2934 if (h
->root
.type
== bfd_link_hash_new
)
2938 output_bfd
= flaginfo
->output_bfd
;
2940 if (aout_backend_info (output_bfd
)->write_dynamic_symbol
!= NULL
)
2942 if (! ((*aout_backend_info (output_bfd
)->write_dynamic_symbol
)
2943 (output_bfd
, flaginfo
->info
, h
)))
2945 /* FIXME: No way to handle errors. */
2955 /* An indx of -2 means the symbol must be written. */
2957 && (flaginfo
->info
->strip
== strip_all
2958 || (flaginfo
->info
->strip
== strip_some
2959 && bfd_hash_lookup (flaginfo
->info
->keep_hash
, h
->root
.root
.string
,
2960 FALSE
, FALSE
) == NULL
)))
2963 switch (h
->root
.type
)
2967 /* Avoid variable not initialized warnings. */
2969 case bfd_link_hash_new
:
2970 /* This can happen for set symbols when sets are not being
2973 case bfd_link_hash_undefined
:
2974 type
= N_UNDF
| N_EXT
;
2977 case bfd_link_hash_defined
:
2978 case bfd_link_hash_defweak
:
2982 sec
= h
->root
.u
.def
.section
->output_section
;
2983 BFD_ASSERT (bfd_is_abs_section (sec
)
2984 || sec
->owner
== output_bfd
);
2985 if (sec
== obj_textsec (output_bfd
))
2986 type
= h
->root
.type
== bfd_link_hash_defined
? N_TEXT
: N_WEAKT
;
2987 else if (sec
== obj_datasec (output_bfd
))
2988 type
= h
->root
.type
== bfd_link_hash_defined
? N_DATA
: N_WEAKD
;
2989 else if (sec
== obj_bsssec (output_bfd
))
2990 type
= h
->root
.type
== bfd_link_hash_defined
? N_BSS
: N_WEAKB
;
2992 type
= h
->root
.type
== bfd_link_hash_defined
? N_ABS
: N_WEAKA
;
2994 val
= (h
->root
.u
.def
.value
2996 + h
->root
.u
.def
.section
->output_offset
);
2999 case bfd_link_hash_common
:
3000 type
= N_UNDF
| N_EXT
;
3001 val
= h
->root
.u
.c
.size
;
3003 case bfd_link_hash_undefweak
:
3007 case bfd_link_hash_indirect
:
3008 case bfd_link_hash_warning
:
3009 /* FIXME: Ignore these for now. The circumstances under which
3010 they should be written out are not clear to me. */
3014 H_PUT_8 (output_bfd
, type
, outsym
.e_type
);
3015 indx
= add_to_stringtab (output_bfd
, flaginfo
->strtab
, h
->root
.root
.string
,
3017 if (indx
== (bfd_size_type
) -1)
3018 /* FIXME: No way to handle errors. */
3021 PUT_WORD (output_bfd
, indx
, outsym
.e_strx
);
3022 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
3024 amt
= EXTERNAL_NLIST_SIZE
;
3025 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0
3026 || bfd_bwrite ((void *) &outsym
, amt
, output_bfd
) != amt
)
3027 /* FIXME: No way to handle errors. */
3030 flaginfo
->symoff
+= amt
;
3031 h
->indx
= obj_aout_external_sym_count (output_bfd
);
3032 ++obj_aout_external_sym_count (output_bfd
);
3037 /* Handle a link order which is supposed to generate a reloc. */
3040 aout_link_reloc_link_order (struct aout_final_link_info
*flaginfo
,
3042 struct bfd_link_order
*p
)
3044 struct bfd_link_order_reloc
*pr
;
3047 reloc_howto_type
*howto
;
3048 file_ptr
*reloff_ptr
;
3049 struct reloc_std_external srel
;
3051 bfd_size_type rel_size
;
3055 if (p
->type
== bfd_section_reloc_link_order
)
3058 if (bfd_is_abs_section (pr
->u
.section
))
3059 r_index
= N_ABS
| N_EXT
;
3062 BFD_ASSERT (pr
->u
.section
->owner
== flaginfo
->output_bfd
);
3063 r_index
= pr
->u
.section
->target_index
;
3068 struct aout_link_hash_entry
*h
;
3070 BFD_ASSERT (p
->type
== bfd_symbol_reloc_link_order
);
3072 h
= ((struct aout_link_hash_entry
*)
3073 bfd_wrapped_link_hash_lookup (flaginfo
->output_bfd
, flaginfo
->info
,
3074 pr
->u
.name
, FALSE
, FALSE
, TRUE
));
3080 /* We decided to strip this symbol, but it turns out that we
3081 can't. Note that we lose the other and desc information
3082 here. I don't think that will ever matter for a global
3086 if (!aout_link_write_other_symbol (&h
->root
.root
, flaginfo
))
3092 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3093 (flaginfo
->info
, pr
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
3098 howto
= bfd_reloc_type_lookup (flaginfo
->output_bfd
, pr
->reloc
);
3101 bfd_set_error (bfd_error_bad_value
);
3105 if (o
== obj_textsec (flaginfo
->output_bfd
))
3106 reloff_ptr
= &flaginfo
->treloff
;
3107 else if (o
== obj_datasec (flaginfo
->output_bfd
))
3108 reloff_ptr
= &flaginfo
->dreloff
;
3113 MY_put_reloc(flaginfo
->output_bfd
, r_extern
, r_index
, p
->offset
, howto
,
3123 fprintf (stderr
, "TODO: line %d in bfd/pdp11.c\n", __LINE__
);
3125 r_pcrel
= howto
->pc_relative
;
3126 r_baserel
= (howto
->type
& 8) != 0;
3127 r_jmptable
= (howto
->type
& 16) != 0;
3128 r_relative
= (howto
->type
& 32) != 0;
3129 r_length
= howto
->size
;
3131 PUT_WORD (flaginfo
->output_bfd
, p
->offset
, srel
.r_address
);
3132 if (bfd_header_big_endian (flaginfo
->output_bfd
))
3134 srel
.r_index
[0] = r_index
>> 16;
3135 srel
.r_index
[1] = r_index
>> 8;
3136 srel
.r_index
[2] = r_index
;
3138 ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
3139 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
3140 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
3141 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
3142 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
3143 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
3147 srel
.r_index
[2] = r_index
>> 16;
3148 srel
.r_index
[1] = r_index
>> 8;
3149 srel
.r_index
[0] = r_index
;
3151 ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
3152 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
3153 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
3154 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
3155 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
3156 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
3160 rel_ptr
= (void *) &srel
;
3162 /* We have to write the addend into the object file, since
3163 standard a.out relocs are in place. It would be more
3164 reliable if we had the current contents of the file here,
3165 rather than assuming zeroes, but we can't read the file since
3166 it was opened using bfd_openw. */
3167 if (pr
->addend
!= 0)
3170 bfd_reloc_status_type r
;
3174 size
= bfd_get_reloc_size (howto
);
3175 buf
= bfd_zmalloc (size
);
3176 if (buf
== NULL
&& size
!= 0)
3178 r
= MY_relocate_contents (howto
, flaginfo
->output_bfd
,
3185 case bfd_reloc_outofrange
:
3187 case bfd_reloc_overflow
:
3188 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3189 (flaginfo
->info
, NULL
,
3190 (p
->type
== bfd_section_reloc_link_order
3191 ? bfd_section_name (pr
->u
.section
)
3193 howto
->name
, pr
->addend
, NULL
,
3194 (asection
*) NULL
, (bfd_vma
) 0);
3197 ok
= bfd_set_section_contents (flaginfo
->output_bfd
, o
,
3199 (file_ptr
) p
->offset
,
3206 rel_size
= obj_reloc_entry_size (flaginfo
->output_bfd
);
3207 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0
3208 || bfd_bwrite (rel_ptr
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3211 *reloff_ptr
+= rel_size
;
3213 /* Assert that the relocs have not run into the symbols, and that n
3214 the text relocs have not run into the data relocs. */
3215 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3216 && (reloff_ptr
!= &flaginfo
->treloff
3218 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3223 /* Get the section corresponding to a reloc index. */
3225 static inline asection
*
3226 aout_reloc_type_to_section (bfd
*abfd
, int type
)
3230 case RTEXT
: return obj_textsec (abfd
);
3231 case RDATA
: return obj_datasec (abfd
);
3232 case RBSS
: return obj_bsssec (abfd
);
3233 case RABS
: return bfd_abs_section_ptr
;
3234 case REXT
: return bfd_und_section_ptr
;
3240 pdp11_aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3242 asection
*input_section
,
3244 bfd_size_type rel_size
,
3247 bfd_boolean (*check_dynamic_reloc
)
3248 (struct bfd_link_info
*, bfd
*, asection
*,
3249 struct aout_link_hash_entry
*, void *, bfd_byte
*, bfd_boolean
*,
3252 bfd_boolean relocatable
;
3253 struct external_nlist
*syms
;
3255 struct aout_link_hash_entry
**sym_hashes
;
3260 output_bfd
= flaginfo
->output_bfd
;
3261 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
3263 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_SIZE
);
3264 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
3265 == output_bfd
->xvec
->header_byteorder
);
3267 relocatable
= bfd_link_relocatable (flaginfo
->info
);
3268 syms
= obj_aout_external_syms (input_bfd
);
3269 strings
= obj_aout_external_strings (input_bfd
);
3270 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
3271 symbol_map
= flaginfo
->symbol_map
;
3274 rel_end
= rel
+ rel_size
;
3275 for (; rel
< rel_end
; rel
+= RELOC_SIZE
)
3282 reloc_howto_type
*howto
;
3283 struct aout_link_hash_entry
*h
= NULL
;
3285 bfd_reloc_status_type r
;
3288 reloc_entry
= GET_WORD (input_bfd
, (void *) rel
);
3289 if (reloc_entry
== 0)
3293 unsigned int howto_idx
;
3295 r_index
= (reloc_entry
& RIDXMASK
) >> 4;
3296 r_type
= reloc_entry
& RTYPE
;
3297 r_pcrel
= reloc_entry
& RELFLG
;
3298 r_addr
= (char *) rel
- (char *) relocs
;
3300 r_extern
= (r_type
== REXT
);
3302 howto_idx
= r_pcrel
;
3303 BFD_ASSERT (howto_idx
< TABLE_SIZE (howto_table_pdp11
));
3304 howto
= howto_table_pdp11
+ howto_idx
;
3309 /* We are generating a relocatable output file, and must
3310 modify the reloc accordingly. */
3313 /* If we know the symbol this relocation is against,
3314 convert it into a relocation against a section. This
3315 is what the native linker does. */
3316 h
= sym_hashes
[r_index
];
3318 && (h
->root
.type
== bfd_link_hash_defined
3319 || h
->root
.type
== bfd_link_hash_defweak
))
3321 asection
*output_section
;
3323 /* Compute a new r_index. */
3324 output_section
= h
->root
.u
.def
.section
->output_section
;
3325 if (output_section
== obj_textsec (output_bfd
))
3327 else if (output_section
== obj_datasec (output_bfd
))
3329 else if (output_section
== obj_bsssec (output_bfd
))
3334 /* Add the symbol value and the section VMA to the
3335 addend stored in the contents. */
3336 relocation
= (h
->root
.u
.def
.value
3337 + output_section
->vma
3338 + h
->root
.u
.def
.section
->output_offset
);
3342 /* We must change r_index according to the symbol
3344 r_index
= symbol_map
[r_index
];
3350 /* We decided to strip this symbol, but it
3351 turns out that we can't. Note that we
3352 lose the other and desc information here.
3353 I don't think that will ever matter for a
3359 if (!aout_link_write_other_symbol (&h
->root
.root
,
3369 name
= strings
+ GET_WORD (input_bfd
,
3370 syms
[r_index
].e_strx
);
3371 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3372 (flaginfo
->info
, name
, input_bfd
, input_section
,
3381 /* Write out the new r_index value. */
3382 reloc_entry
= GET_WORD (input_bfd
, rel
);
3383 reloc_entry
&= RIDXMASK
;
3384 reloc_entry
|= r_index
<< 4;
3385 PUT_WORD (input_bfd
, reloc_entry
, rel
);
3391 /* This is a relocation against a section. We must
3392 adjust by the amount that the section moved. */
3393 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3394 relocation
= (section
->output_section
->vma
3395 + section
->output_offset
3399 /* Change the address of the relocation. */
3400 fprintf (stderr
, "TODO: change the address of the relocation\n");
3402 /* Adjust a PC relative relocation by removing the reference
3403 to the original address in the section and including the
3404 reference to the new address. */
3406 relocation
-= (input_section
->output_section
->vma
3407 + input_section
->output_offset
3408 - input_section
->vma
);
3410 #ifdef MY_relocatable_reloc
3411 MY_relocatable_reloc (howto
, output_bfd
, rel
, relocation
, r_addr
);
3414 if (relocation
== 0)
3417 r
= MY_relocate_contents (howto
,
3418 input_bfd
, relocation
,
3425 /* We are generating an executable, and must do a full
3430 h
= sym_hashes
[r_index
];
3433 && (h
->root
.type
== bfd_link_hash_defined
3434 || h
->root
.type
== bfd_link_hash_defweak
))
3436 relocation
= (h
->root
.u
.def
.value
3437 + h
->root
.u
.def
.section
->output_section
->vma
3438 + h
->root
.u
.def
.section
->output_offset
);
3441 && h
->root
.type
== bfd_link_hash_undefweak
)
3453 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3454 relocation
= (section
->output_section
->vma
3455 + section
->output_offset
3458 relocation
+= input_section
->vma
;
3461 if (check_dynamic_reloc
!= NULL
)
3465 if (! ((*check_dynamic_reloc
)
3466 (flaginfo
->info
, input_bfd
, input_section
, h
,
3467 (void *) rel
, contents
, &skip
, &relocation
)))
3473 /* Now warn if a global symbol is undefined. We could not
3474 do this earlier, because check_dynamic_reloc might want
3475 to skip this reloc. */
3476 if (hundef
&& ! bfd_link_pic (flaginfo
->info
))
3481 name
= h
->root
.root
.string
;
3483 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
3484 (*flaginfo
->info
->callbacks
->undefined_symbol
)
3485 (flaginfo
->info
, name
, input_bfd
, input_section
,
3489 r
= MY_final_link_relocate (howto
,
3490 input_bfd
, input_section
,
3491 contents
, r_addr
, relocation
,
3495 if (r
!= bfd_reloc_ok
)
3500 case bfd_reloc_outofrange
:
3502 case bfd_reloc_overflow
:
3509 name
= strings
+ GET_WORD (input_bfd
,
3510 syms
[r_index
].e_strx
);
3515 s
= aout_reloc_type_to_section (input_bfd
, r_type
);
3516 name
= bfd_section_name (s
);
3518 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3519 (flaginfo
->info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3520 (bfd_vma
) 0, input_bfd
, input_section
, r_addr
);
3530 /* Link an a.out section into the output file. */
3533 aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3535 asection
*input_section
,
3536 file_ptr
*reloff_ptr
,
3537 bfd_size_type rel_size
)
3539 bfd_size_type input_size
;
3542 /* Get the section contents. */
3543 input_size
= input_section
->size
;
3544 if (! bfd_get_section_contents (input_bfd
, input_section
,
3545 (void *) flaginfo
->contents
,
3546 (file_ptr
) 0, input_size
))
3549 /* Read in the relocs if we haven't already done it. */
3550 if (aout_section_data (input_section
) != NULL
3551 && aout_section_data (input_section
)->relocs
!= NULL
)
3552 relocs
= aout_section_data (input_section
)->relocs
;
3555 relocs
= flaginfo
->relocs
;
3558 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3559 || bfd_bread (relocs
, rel_size
, input_bfd
) != rel_size
)
3564 /* Relocate the section contents. */
3565 if (! pdp11_aout_link_input_section (flaginfo
, input_bfd
, input_section
,
3566 (bfd_byte
*) relocs
,
3567 rel_size
, flaginfo
->contents
))
3570 /* Write out the section contents. */
3571 if (! bfd_set_section_contents (flaginfo
->output_bfd
,
3572 input_section
->output_section
,
3573 (void *) flaginfo
->contents
,
3574 (file_ptr
) input_section
->output_offset
,
3578 /* If we are producing relocatable output, the relocs were
3579 modified, and we now write them out. */
3580 if (bfd_link_relocatable (flaginfo
->info
) && rel_size
> 0)
3582 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
3584 if (bfd_bwrite (relocs
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3586 *reloff_ptr
+= rel_size
;
3588 /* Assert that the relocs have not run into the symbols, and
3589 that if these are the text relocs they have not run into the
3591 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3592 && (reloff_ptr
!= &flaginfo
->treloff
3594 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3600 /* Link an a.out input BFD into the output file. */
3603 aout_link_input_bfd (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
3605 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
3607 /* If this is a dynamic object, it may need special handling. */
3608 if ((input_bfd
->flags
& DYNAMIC
) != 0
3609 && aout_backend_info (input_bfd
)->link_dynamic_object
!= NULL
)
3610 return ((*aout_backend_info (input_bfd
)->link_dynamic_object
)
3611 (flaginfo
->info
, input_bfd
));
3613 /* Get the symbols. We probably have them already, unless
3614 flaginfo->info->keep_memory is FALSE. */
3615 if (! aout_get_external_symbols (input_bfd
))
3618 /* Write out the symbols and get a map of the new indices. The map
3619 is placed into flaginfo->symbol_map. */
3620 if (! aout_link_write_symbols (flaginfo
, input_bfd
))
3623 /* Relocate and write out the sections. These functions use the
3624 symbol map created by aout_link_write_symbols. The linker_mark
3625 field will be set if these sections are to be included in the
3626 link, which will normally be the case. */
3627 if (obj_textsec (input_bfd
)->linker_mark
)
3629 if (! aout_link_input_section (flaginfo
, input_bfd
,
3630 obj_textsec (input_bfd
),
3632 exec_hdr (input_bfd
)->a_trsize
))
3635 if (obj_datasec (input_bfd
)->linker_mark
)
3637 if (! aout_link_input_section (flaginfo
, input_bfd
,
3638 obj_datasec (input_bfd
),
3640 exec_hdr (input_bfd
)->a_drsize
))
3644 /* If we are not keeping memory, we don't need the symbols any
3645 longer. We still need them if we are keeping memory, because the
3646 strings in the hash table point into them. */
3647 if (! flaginfo
->info
->keep_memory
)
3649 if (! aout_link_free_symbols (input_bfd
))
3656 /* Do the final link step. This is called on the output BFD. The
3657 INFO structure should point to a list of BFDs linked through the
3658 link.next field which can be used to find each BFD which takes part
3659 in the output. Also, each section in ABFD should point to a list
3660 of bfd_link_order structures which list all the input sections for
3661 the output section. */
3664 NAME (aout
, final_link
) (bfd
*abfd
,
3665 struct bfd_link_info
*info
,
3666 void (*callback
) (bfd
*, file_ptr
*, file_ptr
*, file_ptr
*))
3668 struct aout_final_link_info aout_info
;
3669 bfd_boolean includes_hash_initialized
= FALSE
;
3671 bfd_size_type trsize
, drsize
;
3672 bfd_size_type max_contents_size
;
3673 bfd_size_type max_relocs_size
;
3674 bfd_size_type max_sym_count
;
3675 struct bfd_link_order
*p
;
3677 bfd_boolean have_link_order_relocs
;
3679 if (bfd_link_pic (info
))
3680 abfd
->flags
|= DYNAMIC
;
3682 separate_i_d
= info
->separate_code
;
3683 aout_info
.info
= info
;
3684 aout_info
.output_bfd
= abfd
;
3685 aout_info
.contents
= NULL
;
3686 aout_info
.relocs
= NULL
;
3687 aout_info
.symbol_map
= NULL
;
3688 aout_info
.output_syms
= NULL
;
3690 if (!bfd_hash_table_init_n (&aout_info
.includes
.root
,
3691 aout_link_includes_newfunc
,
3692 sizeof (struct aout_link_includes_entry
),
3695 includes_hash_initialized
= TRUE
;
3697 /* Figure out the largest section size. Also, if generating
3698 relocatable output, count the relocs. */
3701 max_contents_size
= 0;
3702 max_relocs_size
= 0;
3704 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3708 if (bfd_link_relocatable (info
))
3710 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3712 trsize
+= exec_hdr (sub
)->a_trsize
;
3713 drsize
+= exec_hdr (sub
)->a_drsize
;
3717 /* FIXME: We need to identify the .text and .data sections
3718 and call get_reloc_upper_bound and canonicalize_reloc to
3719 work out the number of relocs needed, and then multiply
3720 by the reloc size. */
3722 /* xgettext:c-format */
3723 (_("%pB: relocatable link from %s to %s not supported"),
3724 abfd
, sub
->xvec
->name
, abfd
->xvec
->name
);
3725 bfd_set_error (bfd_error_invalid_operation
);
3730 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3732 sz
= obj_textsec (sub
)->size
;
3733 if (sz
> max_contents_size
)
3734 max_contents_size
= sz
;
3735 sz
= obj_datasec (sub
)->size
;
3736 if (sz
> max_contents_size
)
3737 max_contents_size
= sz
;
3739 sz
= exec_hdr (sub
)->a_trsize
;
3740 if (sz
> max_relocs_size
)
3741 max_relocs_size
= sz
;
3742 sz
= exec_hdr (sub
)->a_drsize
;
3743 if (sz
> max_relocs_size
)
3744 max_relocs_size
= sz
;
3746 sz
= obj_aout_external_sym_count (sub
);
3747 if (sz
> max_sym_count
)
3752 if (bfd_link_relocatable (info
))
3754 if (obj_textsec (abfd
) != NULL
)
3755 trsize
+= (_bfd_count_link_order_relocs (obj_textsec (abfd
)
3756 ->map_head
.link_order
)
3757 * obj_reloc_entry_size (abfd
));
3758 if (obj_datasec (abfd
) != NULL
)
3759 drsize
+= (_bfd_count_link_order_relocs (obj_datasec (abfd
)
3760 ->map_head
.link_order
)
3761 * obj_reloc_entry_size (abfd
));
3764 exec_hdr (abfd
)->a_trsize
= trsize
;
3765 exec_hdr (abfd
)->a_drsize
= drsize
;
3766 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
3768 /* Adjust the section sizes and vmas according to the magic number.
3769 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3770 filepos for each section. */
3771 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
3774 /* The relocation and symbol file positions differ among a.out
3775 targets. We are passed a callback routine from the backend
3776 specific code to handle this.
3777 FIXME: At this point we do not know how much space the symbol
3778 table will require. This will not work for any (nonstandard)
3779 a.out target that needs to know the symbol table size before it
3780 can compute the relocation file positions. */
3781 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
3783 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
3784 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
3785 obj_sym_filepos (abfd
) = aout_info
.symoff
;
3787 /* We keep a count of the symbols as we output them. */
3788 obj_aout_external_sym_count (abfd
) = 0;
3790 /* We accumulate the string table as we write out the symbols. */
3791 aout_info
.strtab
= _bfd_stringtab_init ();
3792 if (aout_info
.strtab
== NULL
)
3795 /* Allocate buffers to hold section contents and relocs. */
3796 aout_info
.contents
= bfd_malloc (max_contents_size
);
3797 aout_info
.relocs
= bfd_malloc (max_relocs_size
);
3798 aout_info
.symbol_map
= bfd_malloc (max_sym_count
* sizeof (int *));
3799 aout_info
.output_syms
= bfd_malloc ((max_sym_count
+ 1)
3800 * sizeof (struct external_nlist
));
3801 if ((aout_info
.contents
== NULL
&& max_contents_size
!= 0)
3802 || (aout_info
.relocs
== NULL
&& max_relocs_size
!= 0)
3803 || (aout_info
.symbol_map
== NULL
&& max_sym_count
!= 0)
3804 || aout_info
.output_syms
== NULL
)
3807 /* If we have a symbol named __DYNAMIC, force it out now. This is
3808 required by SunOS. Doing this here rather than in sunos.c is a
3809 hack, but it's easier than exporting everything which would be
3812 struct aout_link_hash_entry
*h
;
3814 h
= aout_link_hash_lookup (aout_hash_table (info
), "__DYNAMIC",
3815 FALSE
, FALSE
, FALSE
);
3817 aout_link_write_other_symbol (&h
->root
.root
, &aout_info
);
3820 /* The most time efficient way to do the link would be to read all
3821 the input object files into memory and then sort out the
3822 information into the output file. Unfortunately, that will
3823 probably use too much memory. Another method would be to step
3824 through everything that composes the text section and write it
3825 out, and then everything that composes the data section and write
3826 it out, and then write out the relocs, and then write out the
3827 symbols. Unfortunately, that requires reading stuff from each
3828 input file several times, and we will not be able to keep all the
3829 input files open simultaneously, and reopening them will be slow.
3831 What we do is basically process one input file at a time. We do
3832 everything we need to do with an input file once--copy over the
3833 section contents, handle the relocation information, and write
3834 out the symbols--and then we throw away the information we read
3835 from it. This approach requires a lot of lseeks of the output
3836 file, which is unfortunate but still faster than reopening a lot
3839 We use the output_has_begun field of the input BFDs to see
3840 whether we have already handled it. */
3841 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3842 sub
->output_has_begun
= FALSE
;
3844 /* Mark all sections which are to be included in the link. This
3845 will normally be every section. We need to do this so that we
3846 can identify any sections which the linker has decided to not
3848 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3850 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
3851 if (p
->type
== bfd_indirect_link_order
)
3852 p
->u
.indirect
.section
->linker_mark
= TRUE
;
3855 have_link_order_relocs
= FALSE
;
3856 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3858 for (p
= o
->map_head
.link_order
;
3862 if (p
->type
== bfd_indirect_link_order
3863 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
3864 == bfd_target_aout_flavour
))
3868 input_bfd
= p
->u
.indirect
.section
->owner
;
3869 if (! input_bfd
->output_has_begun
)
3871 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
3873 input_bfd
->output_has_begun
= TRUE
;
3876 else if (p
->type
== bfd_section_reloc_link_order
3877 || p
->type
== bfd_symbol_reloc_link_order
)
3878 /* These are handled below. */
3879 have_link_order_relocs
= TRUE
;
3882 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3888 /* Write out any symbols that we have not already written out. */
3889 bfd_hash_traverse (&info
->hash
->table
,
3890 aout_link_write_other_symbol
,
3893 /* Now handle any relocs we were asked to create by the linker.
3894 These did not come from any input file. We must do these after
3895 we have written out all the symbols, so that we know the symbol
3897 if (have_link_order_relocs
)
3899 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3901 for (p
= o
->map_head
.link_order
;
3905 if (p
->type
== bfd_section_reloc_link_order
3906 || p
->type
== bfd_symbol_reloc_link_order
)
3908 if (! aout_link_reloc_link_order (&aout_info
, o
, p
))
3915 if (aout_info
.contents
!= NULL
)
3917 free (aout_info
.contents
);
3918 aout_info
.contents
= NULL
;
3920 if (aout_info
.relocs
!= NULL
)
3922 free (aout_info
.relocs
);
3923 aout_info
.relocs
= NULL
;
3925 if (aout_info
.symbol_map
!= NULL
)
3927 free (aout_info
.symbol_map
);
3928 aout_info
.symbol_map
= NULL
;
3930 if (aout_info
.output_syms
!= NULL
)
3932 free (aout_info
.output_syms
);
3933 aout_info
.output_syms
= NULL
;
3935 if (includes_hash_initialized
)
3937 bfd_hash_table_free (&aout_info
.includes
.root
);
3938 includes_hash_initialized
= FALSE
;
3941 /* Finish up any dynamic linking we may be doing. */
3942 if (aout_backend_info (abfd
)->finish_dynamic_link
!= NULL
)
3944 if (! (*aout_backend_info (abfd
)->finish_dynamic_link
) (abfd
, info
))
3948 /* Update the header information. */
3949 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
3950 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
3951 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
3952 obj_textsec (abfd
)->reloc_count
=
3953 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
3954 obj_datasec (abfd
)->reloc_count
=
3955 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
3957 /* Write out the string table, unless there are no symbols. */
3958 if (abfd
->symcount
> 0)
3960 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
3961 || ! emit_stringtab (abfd
, aout_info
.strtab
))
3964 else if (obj_textsec (abfd
)->reloc_count
== 0
3965 && obj_datasec (abfd
)->reloc_count
== 0)
3967 /* The layout of a typical a.out file is header, text, data,
3968 relocs, symbols, string table. When there are no relocs,
3969 symbols or string table, the last thing in the file is data
3970 and a_data may be rounded up. However we may have a smaller
3971 sized .data section and thus not written final padding. The
3972 same thing can happen with text if there is no data. Write
3973 final padding here to extend the file. */
3976 if (exec_hdr (abfd
)->a_data
> obj_datasec (abfd
)->size
)
3977 pos
= obj_datasec (abfd
)->filepos
+ exec_hdr (abfd
)->a_data
;
3978 else if (obj_datasec (abfd
)->size
== 0
3979 && exec_hdr (abfd
)->a_text
> obj_textsec (abfd
)->size
)
3980 pos
= obj_textsec (abfd
)->filepos
+ exec_hdr (abfd
)->a_text
;
3985 if (bfd_seek (abfd
, pos
- 1, SEEK_SET
) != 0
3986 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3994 if (aout_info
.contents
!= NULL
)
3995 free (aout_info
.contents
);
3996 if (aout_info
.relocs
!= NULL
)
3997 free (aout_info
.relocs
);
3998 if (aout_info
.symbol_map
!= NULL
)
3999 free (aout_info
.symbol_map
);
4000 if (aout_info
.output_syms
!= NULL
)
4001 free (aout_info
.output_syms
);
4002 if (includes_hash_initialized
)
4003 bfd_hash_table_free (&aout_info
.includes
.root
);
4007 /* Adjust and write out the symbols for an a.out file. Set the new
4008 symbol indices into a symbol_map. */
4011 aout_link_write_symbols (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
4014 bfd_size_type sym_count
;
4016 enum bfd_link_strip strip
;
4017 enum bfd_link_discard discard
;
4018 struct external_nlist
*outsym
;
4019 bfd_size_type strtab_index
;
4020 struct external_nlist
*sym
;
4021 struct external_nlist
*sym_end
;
4022 struct aout_link_hash_entry
**sym_hash
;
4025 bfd_boolean skip_next
;
4027 output_bfd
= flaginfo
->output_bfd
;
4028 sym_count
= obj_aout_external_sym_count (input_bfd
);
4029 strings
= obj_aout_external_strings (input_bfd
);
4030 strip
= flaginfo
->info
->strip
;
4031 discard
= flaginfo
->info
->discard
;
4032 outsym
= flaginfo
->output_syms
;
4034 /* First write out a symbol for this object file, unless we are
4035 discarding such symbols. */
4036 if (strip
!= strip_all
4037 && (strip
!= strip_some
4038 || bfd_hash_lookup (flaginfo
->info
->keep_hash
, input_bfd
->filename
,
4039 FALSE
, FALSE
) != NULL
)
4040 && discard
!= discard_all
)
4042 H_PUT_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
4043 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4044 input_bfd
->filename
, FALSE
);
4045 if (strtab_index
== (bfd_size_type
) -1)
4047 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4048 PUT_WORD (output_bfd
,
4049 (bfd_section_vma (obj_textsec (input_bfd
)->output_section
)
4050 + obj_textsec (input_bfd
)->output_offset
),
4052 ++obj_aout_external_sym_count (output_bfd
);
4058 sym
= obj_aout_external_syms (input_bfd
);
4059 sym_end
= sym
+ sym_count
;
4060 sym_hash
= obj_aout_sym_hashes (input_bfd
);
4061 symbol_map
= flaginfo
->symbol_map
;
4062 memset (symbol_map
, 0, (size_t) sym_count
* sizeof *symbol_map
);
4063 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
4067 struct aout_link_hash_entry
*h
;
4073 /* We set *symbol_map to 0 above for all symbols. If it has
4074 already been set to -1 for this symbol, it means that we are
4075 discarding it because it appears in a duplicate header file.
4076 See the N_BINCL code below. */
4077 if (*symbol_map
== -1)
4080 /* Initialize *symbol_map to -1, which means that the symbol was
4081 not copied into the output file. We will change it later if
4082 we do copy the symbol over. */
4085 type
= H_GET_8 (input_bfd
, sym
->e_type
);
4086 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
4092 /* Pass this symbol through. It is the target of an
4093 indirect or warning symbol. */
4094 val
= GET_WORD (input_bfd
, sym
->e_value
);
4099 /* Skip this symbol, which is the target of an indirect
4100 symbol that we have changed to no longer be an indirect
4107 struct aout_link_hash_entry
*hresolve
;
4109 /* We have saved the hash table entry for this symbol, if
4110 there is one. Note that we could just look it up again
4111 in the hash table, provided we first check that it is an
4115 /* Use the name from the hash table, in case the symbol was
4118 name
= h
->root
.root
.string
;
4120 /* If this is an indirect or warning symbol, then change
4121 hresolve to the base symbol. We also change *sym_hash so
4122 that the relocation routines relocate against the real
4126 && (h
->root
.type
== bfd_link_hash_indirect
4127 || h
->root
.type
== bfd_link_hash_warning
))
4129 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
4130 while (hresolve
->root
.type
== bfd_link_hash_indirect
4131 || hresolve
->root
.type
== bfd_link_hash_warning
)
4132 hresolve
= ((struct aout_link_hash_entry
*)
4133 hresolve
->root
.u
.i
.link
);
4134 *sym_hash
= hresolve
;
4137 /* If the symbol has already been written out, skip it. */
4139 && h
->root
.type
!= bfd_link_hash_warning
4142 if ((type
& N_TYPE
) == N_INDR
4143 || type
== N_WARNING
)
4145 *symbol_map
= h
->indx
;
4149 /* See if we are stripping this symbol. */
4155 case strip_debugger
:
4156 if ((type
& N_STAB
) != 0)
4160 if (bfd_hash_lookup (flaginfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
4175 /* Get the value of the symbol. */
4176 if ((type
& N_TYPE
) == N_TEXT
4178 symsec
= obj_textsec (input_bfd
);
4179 else if ((type
& N_TYPE
) == N_DATA
4181 symsec
= obj_datasec (input_bfd
);
4182 else if ((type
& N_TYPE
) == N_BSS
4184 symsec
= obj_bsssec (input_bfd
);
4185 else if ((type
& N_TYPE
) == N_ABS
4187 symsec
= bfd_abs_section_ptr
;
4188 else if (((type
& N_TYPE
) == N_INDR
4189 && (hresolve
== NULL
4190 || (hresolve
->root
.type
!= bfd_link_hash_defined
4191 && hresolve
->root
.type
!= bfd_link_hash_defweak
4192 && hresolve
->root
.type
!= bfd_link_hash_common
)))
4193 || type
== N_WARNING
)
4195 /* Pass the next symbol through unchanged. The
4196 condition above for indirect symbols is so that if
4197 the indirect symbol was defined, we output it with
4198 the correct definition so the debugger will
4201 val
= GET_WORD (input_bfd
, sym
->e_value
);
4204 else if ((type
& N_STAB
) != 0)
4206 val
= GET_WORD (input_bfd
, sym
->e_value
);
4211 /* If we get here with an indirect symbol, it means that
4212 we are outputting it with a real definition. In such
4213 a case we do not want to output the next symbol,
4214 which is the target of the indirection. */
4215 if ((type
& N_TYPE
) == N_INDR
)
4220 /* We need to get the value from the hash table. We use
4221 hresolve so that if we have defined an indirect
4222 symbol we output the final definition. */
4225 switch (type
& N_TYPE
)
4228 symsec
= obj_textsec (input_bfd
);
4231 symsec
= obj_datasec (input_bfd
);
4234 symsec
= obj_bsssec (input_bfd
);
4237 symsec
= bfd_abs_section_ptr
;
4244 else if (hresolve
->root
.type
== bfd_link_hash_defined
4245 || hresolve
->root
.type
== bfd_link_hash_defweak
)
4247 asection
*input_section
;
4248 asection
*output_section
;
4250 /* This case usually means a common symbol which was
4251 turned into a defined symbol. */
4252 input_section
= hresolve
->root
.u
.def
.section
;
4253 output_section
= input_section
->output_section
;
4254 BFD_ASSERT (bfd_is_abs_section (output_section
)
4255 || output_section
->owner
== output_bfd
);
4256 val
= (hresolve
->root
.u
.def
.value
4257 + bfd_section_vma (output_section
)
4258 + input_section
->output_offset
);
4260 /* Get the correct type based on the section. If
4261 this is a constructed set, force it to be
4262 globally visible. */
4271 if (output_section
== obj_textsec (output_bfd
))
4272 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4275 else if (output_section
== obj_datasec (output_bfd
))
4276 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4279 else if (output_section
== obj_bsssec (output_bfd
))
4280 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4284 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4288 else if (hresolve
->root
.type
== bfd_link_hash_common
)
4289 val
= hresolve
->root
.u
.c
.size
;
4290 else if (hresolve
->root
.type
== bfd_link_hash_undefweak
)
4299 val
= (symsec
->output_section
->vma
4300 + symsec
->output_offset
4301 + (GET_WORD (input_bfd
, sym
->e_value
)
4304 /* If this is a global symbol set the written flag, and if
4305 it is a local symbol see if we should discard it. */
4309 h
->indx
= obj_aout_external_sym_count (output_bfd
);
4311 else if ((type
& N_TYPE
) != N_SETT
4312 && (type
& N_TYPE
) != N_SETD
4313 && (type
& N_TYPE
) != N_SETB
4314 && (type
& N_TYPE
) != N_SETA
)
4319 case discard_sec_merge
:
4322 if ((type
& N_STAB
) == 0
4323 && bfd_is_local_label_name (input_bfd
, name
))
4337 /* An N_BINCL symbol indicates the start of the stabs
4338 entries for a header file. We need to scan ahead to the
4339 next N_EINCL symbol, ignoring nesting, adding up all the
4340 characters in the symbol names, not including the file
4341 numbers in types (the first number after an open
4343 if (type
== N_BINCL
)
4345 struct external_nlist
*incl_sym
;
4347 struct aout_link_includes_entry
*incl_entry
;
4348 struct aout_link_includes_totals
*t
;
4352 for (incl_sym
= sym
+ 1; incl_sym
< sym_end
; incl_sym
++)
4356 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4357 if (incl_type
== N_EINCL
)
4363 else if (incl_type
== N_BINCL
)
4369 s
= strings
+ GET_WORD (input_bfd
, incl_sym
->e_strx
);
4370 for (; *s
!= '\0'; s
++)
4375 /* Skip the file number. */
4377 while (ISDIGIT (*s
))
4385 /* If we have already included a header file with the
4386 same value, then replace this one with an N_EXCL
4388 copy
= ! flaginfo
->info
->keep_memory
;
4389 incl_entry
= aout_link_includes_lookup (&flaginfo
->includes
,
4391 if (incl_entry
== NULL
)
4393 for (t
= incl_entry
->totals
; t
!= NULL
; t
= t
->next
)
4394 if (t
->total
== val
)
4398 /* This is the first time we have seen this header
4399 file with this set of stabs strings. */
4400 t
= bfd_hash_allocate (&flaginfo
->includes
.root
,
4405 t
->next
= incl_entry
->totals
;
4406 incl_entry
->totals
= t
;
4412 /* This is a duplicate header file. We must change
4413 it to be an N_EXCL entry, and mark all the
4414 included symbols to prevent outputting them. */
4418 for (incl_sym
= sym
+ 1, incl_map
= symbol_map
+ 1;
4420 incl_sym
++, incl_map
++)
4424 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4425 if (incl_type
== N_EINCL
)
4434 else if (incl_type
== N_BINCL
)
4443 /* Copy this symbol into the list of symbols we are going to
4445 H_PUT_8 (output_bfd
, type
, outsym
->e_type
);
4447 if (! flaginfo
->info
->keep_memory
)
4449 /* name points into a string table which we are going to
4450 free. If there is a hash table entry, use that string.
4451 Otherwise, copy name into memory. */
4453 name
= h
->root
.root
.string
;
4457 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4459 if (strtab_index
== (bfd_size_type
) -1)
4461 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4462 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
4463 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
4464 ++obj_aout_external_sym_count (output_bfd
);
4468 /* Write out the output symbols we have just constructed. */
4469 if (outsym
> flaginfo
->output_syms
)
4473 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0)
4475 size
= outsym
- flaginfo
->output_syms
;
4476 size
*= EXTERNAL_NLIST_SIZE
;
4477 if (bfd_bwrite ((void *) flaginfo
->output_syms
, size
, output_bfd
) != size
)
4479 flaginfo
->symoff
+= size
;
4485 /* Write out a symbol that was not associated with an a.out input
4489 bfd_getp32 (const void *p
)
4491 const bfd_byte
*addr
= p
;
4494 v
= (unsigned long) addr
[1] << 24;
4495 v
|= (unsigned long) addr
[0] << 16;
4496 v
|= (unsigned long) addr
[3] << 8;
4497 v
|= (unsigned long) addr
[2];
4501 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
4503 static bfd_signed_vma
4504 bfd_getp_signed_32 (const void *p
)
4506 const bfd_byte
*addr
= p
;
4509 v
= (unsigned long) addr
[1] << 24;
4510 v
|= (unsigned long) addr
[0] << 16;
4511 v
|= (unsigned long) addr
[3] << 8;
4512 v
|= (unsigned long) addr
[2];
4513 return COERCE32 (v
);
4517 bfd_putp32 (bfd_vma data
, void *p
)
4521 addr
[0] = (data
>> 16) & 0xff;
4522 addr
[1] = (data
>> 24) & 0xff;
4523 addr
[2] = (data
>> 0) & 0xff;
4524 addr
[3] = (data
>> 8) & 0xff;
4527 const bfd_target
MY (vec
) =
4529 TARGETNAME
, /* Name. */
4530 bfd_target_aout_flavour
,
4531 BFD_ENDIAN_LITTLE
, /* Target byte order (little). */
4532 BFD_ENDIAN_LITTLE
, /* Target headers byte order (little). */
4533 (HAS_RELOC
| EXEC_P
| /* Object flags. */
4534 HAS_LINENO
| HAS_DEBUG
|
4535 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
),
4536 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_CODE
| SEC_DATA
),
4537 MY_symbol_leading_char
,
4538 AR_PAD_CHAR
, /* AR_pad_char. */
4539 15, /* AR_max_namelen. */
4540 0, /* match priority. */
4541 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4542 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4543 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Data. */
4544 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4545 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4546 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Headers. */
4547 { /* bfd_check_format. */
4550 bfd_generic_archive_p
,
4553 { /* bfd_set_format. */
4554 _bfd_bool_bfd_false_error
,
4556 _bfd_generic_mkarchive
,
4557 _bfd_bool_bfd_false_error
4559 { /* bfd_write_contents. */
4560 _bfd_bool_bfd_false_error
,
4561 MY_write_object_contents
,
4562 _bfd_write_archive_contents
,
4563 _bfd_bool_bfd_false_error
4566 BFD_JUMP_TABLE_GENERIC (MY
),
4567 BFD_JUMP_TABLE_COPY (MY
),
4568 BFD_JUMP_TABLE_CORE (MY
),
4569 BFD_JUMP_TABLE_ARCHIVE (MY
),
4570 BFD_JUMP_TABLE_SYMBOLS (MY
),
4571 BFD_JUMP_TABLE_RELOCS (MY
),
4572 BFD_JUMP_TABLE_WRITE (MY
),
4573 BFD_JUMP_TABLE_LINK (MY
),
4574 BFD_JUMP_TABLE_DYNAMIC (MY
),
4576 /* Alternative_target. */
4579 (void *) MY_backend_data