1 /* BFD back-end for PDP-11 a.out binaries.
2 Copyright (C) 2001-2020 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
22 /* BFD backend for PDP-11, running 2.11BSD in particular.
24 This file was hacked up by looking hard at the existing vaxnetbsd
25 back end and the header files in 2.11BSD.
28 * support for V7 file formats
29 * support for overlay object files (see 2.11 a.out(5))
30 * support for old and very old archives
31 (see 2.11 ar(5), historical section)
33 Search for TODO to find other areas needing more work. */
35 #define BYTES_IN_WORD 2
36 #define BYTES_IN_LONG 4
38 #undef TARGET_IS_BIG_ENDIAN_P
40 #define TARGET_PAGE_SIZE 8192
41 #define SEGMENT__SIZE TARGET_PAGE_SIZE
43 #define DEFAULT_ARCH bfd_arch_pdp11
44 #define DEFAULT_MID M_PDP11
46 /* Do not "beautify" the CONCAT* macro args. Traditional C will not
47 remove whitespace added here, and thus will fail to concatenate
49 #define MY(OP) CONCAT2 (pdp11_aout_,OP)
51 /* This needs to start with a.out so GDB knows it is an a.out variant. */
52 #define TARGETNAME "a.out-pdp11"
54 /* This is the normal load address for executables. */
55 #define TEXT_START_ADDR 0
57 /* The header is not included in the text segment. */
58 #define N_HEADER_IN_TEXT(x) 0
60 /* There is no flags field. */
61 #define N_FLAGS(execp) 0
63 #define N_SET_FLAGS(execp, flags) do { } while (0)
64 #define N_BADMAG(x) (N_MAGIC(x) != OMAGIC \
65 && N_MAGIC(x) != NMAGIC \
66 && N_MAGIC(x) != IMAGIC \
67 && N_MAGIC(x) != ZMAGIC)
73 #define external_exec pdp11_external_exec
74 struct pdp11_external_exec
76 bfd_byte e_info
[2]; /* Magic number. */
77 bfd_byte e_text
[2]; /* Length of text section in bytes. */
78 bfd_byte e_data
[2]; /* Length of data section in bytes. */
79 bfd_byte e_bss
[2]; /* Length of bss area in bytes. */
80 bfd_byte e_syms
[2]; /* Length of symbol table in bytes. */
81 bfd_byte e_entry
[2]; /* Start address. */
82 bfd_byte e_unused
[2]; /* Not used. */
83 bfd_byte e_flag
[2]; /* Relocation info stripped. */
84 bfd_byte e_relocatable
; /* Ugly hack. */
87 #define EXEC_BYTES_SIZE (8 * 2)
89 #define A_MAGIC1 OMAGIC
90 #define OMAGIC 0407 /* ...object file or impure executable. */
91 #define A_MAGIC2 NMAGIC
92 #define NMAGIC 0410 /* Pure executable. */
93 #define ZMAGIC 0413 /* Demand-paged executable. */
94 #define IMAGIC 0411 /* Separated I&D. */
95 #define A_MAGIC3 IMAGIC
96 #define A_MAGIC4 0405 /* Overlay. */
97 #define A_MAGIC5 0430 /* Auto-overlay (nonseparate). */
98 #define A_MAGIC6 0431 /* Auto-overlay (separate). */
102 #define A_FLAG_RELOC_STRIPPED 0x0001
104 #define external_nlist pdp11_external_nlist
105 struct pdp11_external_nlist
107 bfd_byte e_unused
[2]; /* Unused. */
108 bfd_byte e_strx
[2]; /* Index into string table of name. */
109 bfd_byte e_type
[1]; /* Type of symbol. */
110 bfd_byte e_ovly
[1]; /* Overlay number. */
111 bfd_byte e_value
[2]; /* Value of symbol. */
114 #define EXTERNAL_NLIST_SIZE 8
116 #define N_TXTOFF(x) (EXEC_BYTES_SIZE)
117 #define N_DATOFF(x) (N_TXTOFF(x) + (x)->a_text)
118 #define N_TRELOFF(x) (N_DATOFF(x) + (x)->a_data)
119 #define N_DRELOFF(x) (N_TRELOFF(x) + (x)->a_trsize)
120 #define N_SYMOFF(x) (N_DRELOFF(x) + (x)->a_drsize)
121 #define N_STROFF(x) (N_SYMOFF(x) + (x)->a_syms)
123 #define WRITE_HEADERS(abfd, execp) pdp11_aout_write_headers (abfd, execp)
128 #define SWAP_MAGIC(ext) bfd_getl16 (ext)
130 #define MY_entry_is_text_address 1
132 #define MY_write_object_contents MY(write_object_contents)
133 static bfd_boolean
MY(write_object_contents
) (bfd
*);
134 #define MY_text_includes_header 1
136 #define MY_BFD_TARGET
138 #include "aout-target.h"
140 /* Start of modified aoutx.h. */
141 #define KEEPIT udata.i
143 #include <string.h> /* For strchr and friends. */
146 #include "safe-ctype.h"
150 #include "aout/aout64.h"
151 #include "aout/stab_gnu.h"
164 #define N_TYPE 0x1f /* Type mask. */
165 #define N_UNDF 0x00 /* Undefined. */
166 #define N_ABS 0x01 /* Absolute. */
167 #define N_TEXT 0x02 /* Text segment. */
168 #define N_DATA 0x03 /* Data segment. */
169 #define N_BSS 0x04 /* Bss segment. */
170 #define N_REG 0x14 /* Register symbol. */
171 #define N_FN 0x1f /* File name. */
172 #define N_EXT 0x20 /* External flag. */
173 #define N_STAB 0xc0 /* Not relevant; modified aout64.h's 0xe0 to avoid N_EXT. */
177 #define RELFLG 0x0001 /* PC-relative flag. */
178 #define RTYPE 0x000e /* Type mask. */
179 #define RIDXMASK 0xfff0 /* Index mask. */
181 #define RABS 0x00 /* Absolute. */
182 #define RTEXT 0x02 /* Text. */
183 #define RDATA 0x04 /* Data. */
184 #define RBSS 0x06 /* Bss. */
185 #define REXT 0x08 /* External. */
187 #define RINDEX(x) (((x) & 0xfff0) >> 4)
189 #ifndef MY_final_link_relocate
190 #define MY_final_link_relocate _bfd_final_link_relocate
193 #ifndef MY_relocate_contents
194 #define MY_relocate_contents _bfd_relocate_contents
197 /* A hash table used for header files with N_BINCL entries. */
199 struct aout_link_includes_table
201 struct bfd_hash_table root
;
204 /* A linked list of totals that we have found for a particular header
207 struct aout_link_includes_totals
209 struct aout_link_includes_totals
*next
;
213 /* An entry in the header file hash table. */
215 struct aout_link_includes_entry
217 struct bfd_hash_entry root
;
218 /* List of totals we have found for this file. */
219 struct aout_link_includes_totals
*totals
;
222 /* During the final link step we need to pass around a bunch of
223 information, so we do it in an instance of this structure. */
225 struct aout_final_link_info
227 /* General link information. */
228 struct bfd_link_info
*info
;
231 /* Reloc file positions. */
232 file_ptr treloff
, dreloff
;
233 /* File position of symbols. */
236 struct bfd_strtab_hash
*strtab
;
237 /* Header file hash table. */
238 struct aout_link_includes_table includes
;
239 /* A buffer large enough to hold the contents of any section. */
241 /* A buffer large enough to hold the relocs of any section. */
243 /* A buffer large enough to hold the symbol map of any input BFD. */
245 /* A buffer large enough to hold output symbols of any input BFD. */
246 struct external_nlist
*output_syms
;
249 /* Copy of the link_info.separate_code boolean to select the output format with
250 separate instruction and data spaces selected by --imagic */
251 static bfd_boolean separate_i_d
= FALSE
;
253 reloc_howto_type howto_table_pdp11
[] =
255 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
256 HOWTO( 0, 0, 1, 16, FALSE
, 0, complain_overflow_signed
,0,"16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
257 HOWTO( 1, 0, 1, 16, TRUE
, 0, complain_overflow_signed
,0,"DISP16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
258 HOWTO( 2, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,0,"32", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
261 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
264 static bfd_boolean
aout_link_check_archive_element (bfd
*, struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *, bfd_boolean
*);
265 static bfd_boolean
aout_link_add_object_symbols (bfd
*, struct bfd_link_info
*);
266 static bfd_boolean
aout_link_add_symbols (bfd
*, struct bfd_link_info
*);
267 static bfd_boolean
aout_link_write_symbols (struct aout_final_link_info
*, bfd
*);
271 NAME (aout
, reloc_type_lookup
) (bfd
* abfd ATTRIBUTE_UNUSED
,
272 bfd_reloc_code_real_type code
)
277 return &howto_table_pdp11
[0];
278 case BFD_RELOC_16_PCREL
:
279 return &howto_table_pdp11
[1];
281 return &howto_table_pdp11
[2];
288 NAME (aout
, reloc_name_lookup
) (bfd
*abfd ATTRIBUTE_UNUSED
,
294 i
< sizeof (howto_table_pdp11
) / sizeof (howto_table_pdp11
[0]);
296 if (howto_table_pdp11
[i
].name
!= NULL
297 && strcasecmp (howto_table_pdp11
[i
].name
, r_name
) == 0)
298 return &howto_table_pdp11
[i
];
304 pdp11_aout_write_headers (bfd
*abfd
, struct internal_exec
*execp
)
306 struct external_exec exec_bytes
;
308 if (adata(abfd
).magic
== undecided_magic
)
309 NAME (aout
, adjust_sizes_and_vmas
) (abfd
);
311 execp
->a_syms
= bfd_get_symcount (abfd
) * EXTERNAL_NLIST_SIZE
;
312 execp
->a_entry
= bfd_get_start_address (abfd
);
314 if (obj_textsec (abfd
)->reloc_count
> 0
315 || obj_datasec (abfd
)->reloc_count
> 0)
317 execp
->a_trsize
= execp
->a_text
;
318 execp
->a_drsize
= execp
->a_data
;
326 NAME (aout
, swap_exec_header_out
) (abfd
, execp
, & exec_bytes
);
328 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
331 if (bfd_bwrite ((void *) &exec_bytes
, (bfd_size_type
) EXEC_BYTES_SIZE
, abfd
)
335 /* Now write out reloc info, followed by syms and strings. */
336 if (bfd_get_outsymbols (abfd
) != NULL
337 && bfd_get_symcount (abfd
) != 0)
339 if (bfd_seek (abfd
, (file_ptr
) (N_SYMOFF (execp
)), SEEK_SET
) != 0)
342 if (! NAME (aout
, write_syms
) (abfd
))
346 if (obj_textsec (abfd
)->reloc_count
> 0
347 || obj_datasec (abfd
)->reloc_count
> 0)
349 if (bfd_seek (abfd
, (file_ptr
) (N_TRELOFF (execp
)), SEEK_SET
) != 0
350 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_textsec (abfd
))
351 || bfd_seek (abfd
, (file_ptr
) (N_DRELOFF (execp
)), SEEK_SET
) != 0
352 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_datasec (abfd
)))
359 /* Write an object file.
360 Section contents have already been written. We write the
361 file header, symbols, and relocation. */
364 MY(write_object_contents
) (bfd
*abfd
)
366 struct internal_exec
*execp
= exec_hdr (abfd
);
368 /* We must make certain that the magic number has been set. This
369 will normally have been done by set_section_contents, but only if
370 there actually are some section contents. */
371 if (! abfd
->output_has_begun
)
372 NAME (aout
, adjust_sizes_and_vmas
) (abfd
);
374 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
376 return WRITE_HEADERS (abfd
, execp
);
379 /* Swap the information in an executable header @var{raw_bytes} taken
380 from a raw byte stream memory image into the internal exec header
381 structure "execp". */
383 #ifndef NAME_swap_exec_header_in
385 NAME (aout
, swap_exec_header_in
) (bfd
*abfd
,
386 struct external_exec
*bytes
,
387 struct internal_exec
*execp
)
389 /* The internal_exec structure has some fields that are unused in this
390 configuration (IE for i960), so ensure that all such uninitialized
391 fields are zero'd out. There are places where two of these structs
392 are memcmp'd, and thus the contents do matter. */
393 memset ((void *) execp
, 0, sizeof (struct internal_exec
));
394 /* Now fill in fields in the execp, from the bytes in the raw data. */
395 execp
->a_info
= GET_MAGIC (abfd
, bytes
->e_info
);
396 execp
->a_text
= GET_WORD (abfd
, bytes
->e_text
);
397 execp
->a_data
= GET_WORD (abfd
, bytes
->e_data
);
398 execp
->a_bss
= GET_WORD (abfd
, bytes
->e_bss
);
399 execp
->a_syms
= GET_WORD (abfd
, bytes
->e_syms
);
400 execp
->a_entry
= GET_WORD (abfd
, bytes
->e_entry
);
402 if (GET_WORD (abfd
, bytes
->e_flag
) & A_FLAG_RELOC_STRIPPED
)
409 execp
->a_trsize
= execp
->a_text
;
410 execp
->a_drsize
= execp
->a_data
;
413 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
416 /* Swap the information in an internal exec header structure
417 "execp" into the buffer "bytes" ready for writing to disk. */
419 NAME (aout
, swap_exec_header_out
) (bfd
*abfd
,
420 struct internal_exec
*execp
,
421 struct external_exec
*bytes
)
423 /* Now fill in fields in the raw data, from the fields in the exec struct. */
424 PUT_MAGIC (abfd
, execp
->a_info
, bytes
->e_info
);
425 PUT_WORD (abfd
, execp
->a_text
, bytes
->e_text
);
426 PUT_WORD (abfd
, execp
->a_data
, bytes
->e_data
);
427 PUT_WORD (abfd
, execp
->a_bss
, bytes
->e_bss
);
428 PUT_WORD (abfd
, execp
->a_syms
, bytes
->e_syms
);
429 PUT_WORD (abfd
, execp
->a_entry
, bytes
->e_entry
);
430 PUT_WORD (abfd
, 0, bytes
->e_unused
);
432 if ((execp
->a_trsize
== 0 || execp
->a_text
== 0)
433 && (execp
->a_drsize
== 0 || execp
->a_data
== 0))
434 PUT_WORD (abfd
, A_FLAG_RELOC_STRIPPED
, bytes
->e_flag
);
435 else if (execp
->a_trsize
== execp
->a_text
436 && execp
->a_drsize
== execp
->a_data
)
437 PUT_WORD (abfd
, 0, bytes
->e_flag
);
440 /* TODO: print a proper warning message. */
441 fprintf (stderr
, "BFD:%s:%d: internal error\n", __FILE__
, __LINE__
);
442 PUT_WORD (abfd
, 0, bytes
->e_flag
);
446 /* Make all the section for an a.out file. */
449 NAME (aout
, make_sections
) (bfd
*abfd
)
451 if (obj_textsec (abfd
) == NULL
&& bfd_make_section (abfd
, ".text") == NULL
)
453 if (obj_datasec (abfd
) == NULL
&& bfd_make_section (abfd
, ".data") == NULL
)
455 if (obj_bsssec (abfd
) == NULL
&& bfd_make_section (abfd
, ".bss") == NULL
)
460 /* Some a.out variant thinks that the file open in ABFD
461 checking is an a.out file. Do some more checking, and set up
462 for access if it really is. Call back to the calling
463 environment's "finish up" function just before returning, to
464 handle any last-minute setup. */
467 NAME (aout
, some_aout_object_p
) (bfd
*abfd
,
468 struct internal_exec
*execp
,
469 bfd_cleanup (*callback_to_real_object_p
) (bfd
*))
471 struct aout_data_struct
*rawptr
, *oldrawptr
;
473 size_t amt
= sizeof (struct aout_data_struct
);
475 rawptr
= bfd_zalloc (abfd
, amt
);
479 oldrawptr
= abfd
->tdata
.aout_data
;
480 abfd
->tdata
.aout_data
= rawptr
;
482 /* Copy the contents of the old tdata struct. */
483 if (oldrawptr
!= NULL
)
484 *abfd
->tdata
.aout_data
= *oldrawptr
;
486 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
487 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
; /* Copy in the internal_exec struct. */
488 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
490 /* Set the file flags. */
491 abfd
->flags
= BFD_NO_FLAGS
;
492 if (execp
->a_drsize
|| execp
->a_trsize
)
493 abfd
->flags
|= HAS_RELOC
;
494 /* Setting of EXEC_P has been deferred to the bottom of this function. */
496 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
497 if (N_DYNAMIC (execp
))
498 abfd
->flags
|= DYNAMIC
;
500 if (N_MAGIC (execp
) == ZMAGIC
)
502 abfd
->flags
|= D_PAGED
| WP_TEXT
;
503 adata (abfd
).magic
= z_magic
;
505 else if (N_MAGIC (execp
) == NMAGIC
)
507 abfd
->flags
|= WP_TEXT
;
508 adata (abfd
).magic
= n_magic
;
510 else if (N_MAGIC (execp
) == OMAGIC
)
511 adata (abfd
).magic
= o_magic
;
512 else if (N_MAGIC (execp
) == IMAGIC
)
513 adata (abfd
).magic
= i_magic
;
516 /* Should have been checked with N_BADMAG before this routine
521 abfd
->start_address
= execp
->a_entry
;
523 obj_aout_symbols (abfd
) = NULL
;
524 abfd
->symcount
= execp
->a_syms
/ sizeof (struct external_nlist
);
526 /* The default relocation entry size is that of traditional V7 Unix. */
527 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
529 /* The default symbol entry size is that of traditional Unix. */
530 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
533 bfd_init_window (&obj_aout_sym_window (abfd
));
534 bfd_init_window (&obj_aout_string_window (abfd
));
537 obj_aout_external_syms (abfd
) = NULL
;
538 obj_aout_external_strings (abfd
) = NULL
;
539 obj_aout_sym_hashes (abfd
) = NULL
;
541 if (! NAME (aout
, make_sections
) (abfd
))
544 obj_datasec (abfd
)->size
= execp
->a_data
;
545 obj_bsssec (abfd
)->size
= execp
->a_bss
;
547 obj_textsec (abfd
)->flags
=
548 (execp
->a_trsize
!= 0
549 ? (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_RELOC
)
550 : (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
));
551 obj_datasec (abfd
)->flags
=
552 (execp
->a_drsize
!= 0
553 ? (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_RELOC
)
554 : (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
));
555 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
557 #ifdef THIS_IS_ONLY_DOCUMENTATION
558 /* The common code can't fill in these things because they depend
559 on either the start address of the text segment, the rounding
560 up of virtual addresses between segments, or the starting file
561 position of the text segment -- all of which varies among different
562 versions of a.out. */
564 /* Call back to the format-dependent code to fill in the rest of the
565 fields and do any further cleanup. Things that should be filled
566 in by the callback: */
567 struct exec
*execp
= exec_hdr (abfd
);
569 obj_textsec (abfd
)->size
= N_TXTSIZE (execp
);
570 /* Data and bss are already filled in since they're so standard. */
572 /* The virtual memory addresses of the sections. */
573 obj_textsec (abfd
)->vma
= N_TXTADDR (execp
);
574 obj_datasec (abfd
)->vma
= N_DATADDR (execp
);
575 obj_bsssec (abfd
)->vma
= N_BSSADDR (execp
);
577 /* The file offsets of the sections. */
578 obj_textsec (abfd
)->filepos
= N_TXTOFF (execp
);
579 obj_datasec (abfd
)->filepos
= N_DATOFF (execp
);
581 /* The file offsets of the relocation info. */
582 obj_textsec (abfd
)->rel_filepos
= N_TRELOFF (execp
);
583 obj_datasec (abfd
)->rel_filepos
= N_DRELOFF (execp
);
585 /* The file offsets of the string table and symbol table. */
586 obj_str_filepos (abfd
) = N_STROFF (execp
);
587 obj_sym_filepos (abfd
) = N_SYMOFF (execp
);
589 /* Determine the architecture and machine type of the object file. */
590 abfd
->obj_arch
= bfd_arch_obscure
;
592 adata(abfd
)->page_size
= TARGET_PAGE_SIZE
;
593 adata(abfd
)->segment_size
= SEGMENT_SIZE
;
594 adata(abfd
)->exec_bytes_size
= EXEC_BYTES_SIZE
;
596 return _bfd_no_cleanup
;
598 /* The architecture is encoded in various ways in various a.out variants,
599 or is not encoded at all in some of them. The relocation size depends
600 on the architecture and the a.out variant. Finally, the return value
601 is the bfd_target vector in use. If an error occurs, return zero and
602 set bfd_error to the appropriate error code.
604 Formats such as b.out, which have additional fields in the a.out
605 header, should cope with them in this callback as well. */
606 #endif /* DOCUMENTATION */
608 cleanup
= (*callback_to_real_object_p
)(abfd
);
610 /* Now that the segment addresses have been worked out, take a better
611 guess at whether the file is executable. If the entry point
612 is within the text segment, assume it is. (This makes files
613 executable even if their entry point address is 0, as long as
614 their text starts at zero.).
616 This test had to be changed to deal with systems where the text segment
617 runs at a different location than the default. The problem is that the
618 entry address can appear to be outside the text segment, thus causing an
619 erroneous conclusion that the file isn't executable.
621 To fix this, we now accept any non-zero entry point as an indication of
622 executability. This will work most of the time, since only the linker
623 sets the entry point, and that is likely to be non-zero for most systems. */
625 if (execp
->a_entry
!= 0
626 || (execp
->a_entry
>= obj_textsec (abfd
)->vma
627 && execp
->a_entry
< (obj_textsec (abfd
)->vma
628 + obj_textsec (abfd
)->size
)
629 && execp
->a_trsize
== 0
630 && execp
->a_drsize
== 0))
631 abfd
->flags
|= EXEC_P
;
635 struct stat stat_buf
;
637 /* The original heuristic doesn't work in some important cases.
638 The a.out file has no information about the text start
639 address. For files (like kernels) linked to non-standard
640 addresses (ld -Ttext nnn) the entry point may not be between
641 the default text start (obj_textsec(abfd)->vma) and
642 (obj_textsec(abfd)->vma) + text size. This is not just a mach
643 issue. Many kernels are loaded at non standard addresses. */
644 if (abfd
->iostream
!= NULL
645 && (abfd
->flags
& BFD_IN_MEMORY
) == 0
646 && (fstat(fileno((FILE *) (abfd
->iostream
)), &stat_buf
) == 0)
647 && ((stat_buf
.st_mode
& 0111) != 0))
648 abfd
->flags
|= EXEC_P
;
650 #endif /* STAT_FOR_EXEC */
655 abfd
->tdata
.aout_data
= oldrawptr
;
660 /* Initialize ABFD for use with a.out files. */
663 NAME (aout
, mkobject
) (bfd
*abfd
)
665 struct aout_data_struct
*rawptr
;
666 size_t amt
= sizeof (struct aout_data_struct
);
668 bfd_set_error (bfd_error_system_call
);
670 /* Use an intermediate variable for clarity. */
671 rawptr
= bfd_zalloc (abfd
, amt
);
676 abfd
->tdata
.aout_data
= rawptr
;
677 exec_hdr (abfd
) = &(rawptr
->e
);
679 obj_textsec (abfd
) = NULL
;
680 obj_datasec (abfd
) = NULL
;
681 obj_bsssec (abfd
) = NULL
;
686 /* Keep track of machine architecture and machine type for
687 a.out's. Return the <<machine_type>> for a particular
688 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
689 and machine can't be represented in a.out format.
691 If the architecture is understood, machine type 0 (default)
692 is always understood. */
695 NAME (aout
, machine_type
) (enum bfd_architecture arch
,
696 unsigned long machine
,
697 bfd_boolean
*unknown
)
699 enum machine_type arch_flags
;
701 arch_flags
= M_UNKNOWN
;
708 || machine
== bfd_mach_sparc
709 || machine
== bfd_mach_sparc_sparclite
710 || machine
== bfd_mach_sparc_v9
)
711 arch_flags
= M_SPARC
;
712 else if (machine
== bfd_mach_sparc_sparclet
)
713 arch_flags
= M_SPARCLET
;
718 || machine
== bfd_mach_i386_i386
719 || machine
== bfd_mach_i386_i386_intel_syntax
)
724 if (machine
== 0) arch_flags
= M_ARM
;
732 case bfd_mach_mips3000
:
733 arch_flags
= M_MIPS1
;
735 case bfd_mach_mips4000
: /* MIPS3 */
736 case bfd_mach_mips4400
:
737 case bfd_mach_mips8000
: /* MIPS4 */
738 case bfd_mach_mips6000
: /* Real MIPS2: */
739 arch_flags
= M_MIPS2
;
742 arch_flags
= M_UNKNOWN
;
750 case 0: arch_flags
= M_NS32532
; break;
751 case 32032: arch_flags
= M_NS32032
; break;
752 case 32532: arch_flags
= M_NS32532
; break;
753 default: arch_flags
= M_UNKNOWN
; break;
758 /* TODO: arch_flags = M_PDP11; */
767 arch_flags
= M_UNKNOWN
;
770 if (arch_flags
!= M_UNKNOWN
)
776 /* Set the architecture and the machine of the ABFD to the
777 values ARCH and MACHINE. Verify that @ABFD's format
778 can support the architecture required. */
781 NAME (aout
, set_arch_mach
) (bfd
*abfd
,
782 enum bfd_architecture arch
,
783 unsigned long machine
)
785 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
788 if (arch
!= bfd_arch_unknown
)
792 NAME (aout
, machine_type
) (arch
, machine
, &unknown
);
797 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
799 return (*aout_backend_info(abfd
)->set_sizes
) (abfd
);
803 adjust_o_magic (bfd
*abfd
, struct internal_exec
*execp
)
805 file_ptr pos
= adata (abfd
).exec_bytes_size
;
808 asection
*text
= obj_textsec (abfd
);
809 asection
*data
= obj_datasec (abfd
);
810 asection
*bss
= obj_bsssec (abfd
);
814 if (!text
->user_set_vma
)
819 pos
+= execp
->a_text
;
820 vma
+= execp
->a_text
;
823 if (!data
->user_set_vma
)
831 execp
->a_text
+= pad
;
838 if (!bss
->user_set_vma
)
844 else if (data
->size
> 0 || bss
->size
> 0) /* PR25677: for objcopy --extract-symbol */
846 /* The VMA of the .bss section is set by the VMA of the
847 .data section plus the size of the .data section. We may
848 need to add padding bytes to make this true. */
849 pad
= bss
->vma
- vma
;
854 execp
->a_data
= data
->size
+ pad
;
856 execp
->a_bss
= bss
->size
;
858 N_SET_MAGIC (execp
, OMAGIC
);
862 adjust_z_magic (bfd
*abfd
, struct internal_exec
*execp
)
864 bfd_size_type data_pad
, text_pad
;
866 const struct aout_backend_data
*abdp
;
867 /* TRUE if text includes exec header. */
869 asection
*text
= obj_textsec (abfd
);
870 asection
*data
= obj_datasec (abfd
);
871 asection
*bss
= obj_bsssec (abfd
);
873 abdp
= aout_backend_info (abfd
);
877 && (abdp
->text_includes_header
878 || obj_aout_subformat (abfd
) == q_magic_format
));
879 text
->filepos
= (ztih
880 ? adata (abfd
).exec_bytes_size
881 : adata (abfd
).zmagic_disk_block_size
);
882 if (!text
->user_set_vma
)
884 /* ?? Do we really need to check for relocs here? */
885 text
->vma
= ((abfd
->flags
& HAS_RELOC
)
888 ? abdp
->default_text_vma
+ adata (abfd
).exec_bytes_size
889 : abdp
->default_text_vma
));
894 /* The .text section is being loaded at an unusual address. We
895 may need to pad it such that the .data section starts at a page
898 text_pad
= ((text
->filepos
- text
->vma
)
899 & (adata (abfd
).page_size
- 1));
901 text_pad
= (-text
->vma
902 & (adata (abfd
).page_size
- 1));
905 /* Find start of data. */
908 text_end
= text
->filepos
+ execp
->a_text
;
909 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
913 /* Note that if page_size == zmagic_disk_block_size, then
914 filepos == page_size, and this case is the same as the ztih
916 text_end
= execp
->a_text
;
917 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
918 text_end
+= text
->filepos
;
920 execp
->a_text
+= text_pad
;
923 if (!data
->user_set_vma
)
926 vma
= text
->vma
+ execp
->a_text
;
927 data
->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
929 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
931 text_pad
= data
->vma
- (text
->vma
+ execp
->a_text
);
932 /* Only pad the text section if the data
933 section is going to be placed after it. */
935 execp
->a_text
+= text_pad
;
937 data
->filepos
= text
->filepos
+ execp
->a_text
;
939 /* Fix up exec header while we're at it. */
940 if (ztih
&& (!abdp
|| (abdp
&& !abdp
->exec_header_not_counted
)))
941 execp
->a_text
+= adata (abfd
).exec_bytes_size
;
942 N_SET_MAGIC (execp
, ZMAGIC
);
944 /* Spec says data section should be rounded up to page boundary. */
945 execp
->a_data
= align_power (data
->size
, bss
->alignment_power
);
946 execp
->a_data
= BFD_ALIGN (execp
->a_data
, adata (abfd
).page_size
);
947 data_pad
= execp
->a_data
- data
->size
;
950 if (!bss
->user_set_vma
)
951 bss
->vma
= data
->vma
+ execp
->a_data
;
952 /* If the BSS immediately follows the data section and extra space
953 in the page is left after the data section, fudge data
954 in the header so that the bss section looks smaller by that
955 amount. We'll start the bss section there, and lie to the OS.
956 (Note that a linker script, as well as the above assignment,
957 could have explicitly set the BSS vma to immediately follow
958 the data section.) */
959 if (align_power (bss
->vma
, bss
->alignment_power
) == data
->vma
+ execp
->a_data
)
960 execp
->a_bss
= data_pad
> bss
->size
? 0 : bss
->size
- data_pad
;
962 execp
->a_bss
= bss
->size
;
966 adjust_n_magic (bfd
*abfd
, struct internal_exec
*execp
)
968 file_ptr pos
= adata (abfd
).exec_bytes_size
;
971 asection
*text
= obj_textsec (abfd
);
972 asection
*data
= obj_datasec (abfd
);
973 asection
*bss
= obj_bsssec (abfd
);
977 if (!text
->user_set_vma
)
981 pos
+= execp
->a_text
;
982 vma
+= execp
->a_text
;
986 if (!data
->user_set_vma
)
987 data
->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
990 /* Since BSS follows data immediately, see if it needs alignment. */
992 pad
= align_power (vma
, bss
->alignment_power
) - vma
;
993 execp
->a_data
= data
->size
+ pad
;
994 pos
+= execp
->a_data
;
997 if (!bss
->user_set_vma
)
1002 /* Fix up exec header. */
1003 execp
->a_bss
= bss
->size
;
1004 N_SET_MAGIC (execp
, NMAGIC
);
1008 adjust_i_magic (bfd
*abfd
, struct internal_exec
*execp
)
1010 file_ptr pos
= adata (abfd
).exec_bytes_size
;
1013 asection
*text
= obj_textsec (abfd
);
1014 asection
*data
= obj_datasec (abfd
);
1015 asection
*bss
= obj_bsssec (abfd
);
1018 text
->filepos
= pos
;
1019 if (!text
->user_set_vma
)
1023 pos
+= execp
->a_text
;
1026 data
->filepos
= pos
;
1027 if (!data
->user_set_vma
)
1031 /* Since BSS follows data immediately, see if it needs alignment. */
1033 pad
= align_power (vma
, bss
->alignment_power
) - vma
;
1034 execp
->a_data
= data
->size
+ pad
;
1035 pos
+= execp
->a_data
;
1038 if (!bss
->user_set_vma
)
1043 /* Fix up exec header. */
1044 execp
->a_bss
= bss
->size
;
1045 N_SET_MAGIC (execp
, IMAGIC
);
1049 NAME (aout
, adjust_sizes_and_vmas
) (bfd
*abfd
)
1051 struct internal_exec
*execp
= exec_hdr (abfd
);
1053 if (! NAME (aout
, make_sections
) (abfd
))
1056 if (adata (abfd
).magic
!= undecided_magic
)
1059 execp
->a_text
= align_power (obj_textsec (abfd
)->size
,
1060 obj_textsec (abfd
)->alignment_power
);
1062 /* Rule (heuristic) for when to pad to a new page. Note that there
1063 are (at least) two ways demand-paged (ZMAGIC) files have been
1064 handled. Most Berkeley-based systems start the text segment at
1065 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1066 segment right after the exec header; the latter is counted in the
1067 text segment size, and is paged in by the kernel with the rest of
1070 /* This perhaps isn't the right way to do this, but made it simpler for me
1071 to understand enough to implement it. Better would probably be to go
1072 right from BFD flags to alignment/positioning characteristics. But the
1073 old code was sloppy enough about handling the flags, and had enough
1074 other magic, that it was a little hard for me to understand. I think
1075 I understand it better now, but I haven't time to do the cleanup this
1079 adata (abfd
).magic
= i_magic
;
1080 else if (abfd
->flags
& WP_TEXT
)
1081 adata (abfd
).magic
= n_magic
;
1083 adata (abfd
).magic
= o_magic
;
1085 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1087 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1089 switch (adata (abfd
).magic
)
1091 case n_magic
: str
= "NMAGIC"; break;
1092 case o_magic
: str
= "OMAGIC"; break;
1093 case i_magic
: str
= "IMAGIC"; break;
1094 case z_magic
: str
= "ZMAGIC"; break;
1099 obj_textsec (abfd
)->vma
, obj_textsec (abfd
)->size
,
1100 obj_textsec (abfd
)->alignment_power
,
1101 obj_datasec (abfd
)->vma
, obj_datasec (abfd
)->size
,
1102 obj_datasec (abfd
)->alignment_power
,
1103 obj_bsssec (abfd
)->vma
, obj_bsssec (abfd
)->size
,
1104 obj_bsssec (abfd
)->alignment_power
);
1108 switch (adata (abfd
).magic
)
1111 adjust_o_magic (abfd
, execp
);
1114 adjust_z_magic (abfd
, execp
);
1117 adjust_n_magic (abfd
, execp
);
1120 adjust_i_magic (abfd
, execp
);
1126 #ifdef BFD_AOUT_DEBUG
1127 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1128 obj_textsec (abfd
)->vma
, execp
->a_text
,
1129 obj_textsec (abfd
)->filepos
,
1130 obj_datasec (abfd
)->vma
, execp
->a_data
,
1131 obj_datasec (abfd
)->filepos
,
1132 obj_bsssec (abfd
)->vma
, execp
->a_bss
);
1138 /* Called by the BFD in response to a bfd_make_section request. */
1141 NAME (aout
, new_section_hook
) (bfd
*abfd
, asection
*newsect
)
1143 /* Align to double at least. */
1144 newsect
->alignment_power
= bfd_get_arch_info(abfd
)->section_align_power
;
1146 if (bfd_get_format (abfd
) == bfd_object
)
1148 if (obj_textsec (abfd
) == NULL
1149 && !strcmp (newsect
->name
, ".text"))
1151 obj_textsec(abfd
)= newsect
;
1152 newsect
->target_index
= N_TEXT
;
1154 else if (obj_datasec (abfd
) == NULL
1155 && !strcmp (newsect
->name
, ".data"))
1157 obj_datasec (abfd
) = newsect
;
1158 newsect
->target_index
= N_DATA
;
1160 else if (obj_bsssec (abfd
) == NULL
1161 && !strcmp (newsect
->name
, ".bss"))
1163 obj_bsssec (abfd
) = newsect
;
1164 newsect
->target_index
= N_BSS
;
1168 /* We allow more than three sections internally. */
1169 return _bfd_generic_new_section_hook (abfd
, newsect
);
1173 NAME (aout
, set_section_contents
) (bfd
*abfd
,
1175 const void * location
,
1177 bfd_size_type count
)
1179 if (! abfd
->output_has_begun
)
1181 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
1185 if (section
== obj_bsssec (abfd
))
1187 bfd_set_error (bfd_error_no_contents
);
1191 if (section
!= obj_textsec (abfd
)
1192 && section
!= obj_datasec (abfd
))
1195 /* xgettext:c-format */
1196 (_("%pB: can not represent section `%pA' in a.out object file format"),
1198 bfd_set_error (bfd_error_nonrepresentable_section
);
1204 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
1205 || bfd_bwrite (location
, count
, abfd
) != count
)
1212 /* Read the external symbols from an a.out file. */
1215 aout_get_external_symbols (bfd
*abfd
)
1217 if (obj_aout_external_syms (abfd
) == NULL
)
1219 bfd_size_type count
;
1220 struct external_nlist
*syms
;
1222 count
= exec_hdr (abfd
)->a_syms
/ EXTERNAL_NLIST_SIZE
;
1224 /* PR 17512: file: 011f5a08. */
1227 obj_aout_external_syms (abfd
) = NULL
;
1228 obj_aout_external_sym_count (abfd
) = count
;
1233 if (! bfd_get_file_window (abfd
, obj_sym_filepos (abfd
),
1234 exec_hdr (abfd
)->a_syms
,
1235 &obj_aout_sym_window (abfd
), TRUE
))
1237 syms
= (struct external_nlist
*) obj_aout_sym_window (abfd
).data
;
1239 /* We allocate using malloc to make the values easy to free
1240 later on. If we put them on the objalloc it might not be
1241 possible to free them. */
1242 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1244 syms
= (struct external_nlist
*)
1245 _bfd_malloc_and_read (abfd
, count
* EXTERNAL_NLIST_SIZE
,
1246 count
* EXTERNAL_NLIST_SIZE
);
1251 obj_aout_external_syms (abfd
) = syms
;
1252 obj_aout_external_sym_count (abfd
) = count
;
1255 if (obj_aout_external_strings (abfd
) == NULL
1256 && exec_hdr (abfd
)->a_syms
!= 0)
1258 unsigned char string_chars
[BYTES_IN_LONG
];
1259 bfd_size_type stringsize
;
1261 bfd_size_type amt
= BYTES_IN_LONG
;
1263 /* Get the size of the strings. */
1264 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
1265 || bfd_bread ((void *) string_chars
, amt
, abfd
) != amt
)
1267 stringsize
= H_GET_32 (abfd
, string_chars
);
1268 if (stringsize
== 0)
1270 else if (stringsize
< BYTES_IN_LONG
1271 || (size_t) stringsize
!= stringsize
)
1273 bfd_set_error (bfd_error_bad_value
);
1278 if (stringsize
>= BYTES_IN_LONG
)
1280 if (! bfd_get_file_window (abfd
, obj_str_filepos (abfd
), stringsize
+ 1,
1281 &obj_aout_string_window (abfd
), TRUE
))
1283 strings
= (char *) obj_aout_string_window (abfd
).data
;
1288 strings
= (char *) bfd_malloc (stringsize
+ 1);
1289 if (strings
== NULL
)
1292 if (stringsize
>= BYTES_IN_LONG
)
1294 /* Keep the string count in the buffer for convenience
1295 when indexing with e_strx. */
1296 amt
= stringsize
- BYTES_IN_LONG
;
1297 if (bfd_bread (strings
+ BYTES_IN_LONG
, amt
, abfd
) != amt
)
1304 /* Ensure that a zero index yields an empty string. */
1307 /* Ensure that the string buffer is NUL terminated. */
1308 strings
[stringsize
] = 0;
1310 obj_aout_external_strings (abfd
) = strings
;
1311 obj_aout_external_string_size (abfd
) = stringsize
;
1317 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1318 and symbol->value fields of CACHE_PTR will be set from the a.out
1319 nlist structure. This function is responsible for setting
1320 symbol->flags and symbol->section, and adjusting symbol->value. */
1323 translate_from_native_sym_flags (bfd
*abfd
,
1324 aout_symbol_type
*cache_ptr
)
1328 if (cache_ptr
->type
== N_FN
)
1332 /* This is a debugging symbol. */
1333 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1335 /* Work out the symbol section. */
1336 switch (cache_ptr
->type
& N_TYPE
)
1340 sec
= obj_textsec (abfd
);
1343 sec
= obj_datasec (abfd
);
1346 sec
= obj_bsssec (abfd
);
1350 sec
= bfd_abs_section_ptr
;
1354 cache_ptr
->symbol
.section
= sec
;
1355 cache_ptr
->symbol
.value
-= sec
->vma
;
1360 /* Get the default visibility. This does not apply to all types, so
1361 we just hold it in a local variable to use if wanted. */
1362 if ((cache_ptr
->type
& N_EXT
) == 0)
1363 visible
= BSF_LOCAL
;
1365 visible
= BSF_GLOBAL
;
1367 switch (cache_ptr
->type
)
1370 case N_ABS
: case N_ABS
| N_EXT
:
1371 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1372 cache_ptr
->symbol
.flags
= visible
;
1375 case N_UNDF
| N_EXT
:
1376 if (cache_ptr
->symbol
.value
!= 0)
1378 /* This is a common symbol. */
1379 cache_ptr
->symbol
.flags
= BSF_GLOBAL
;
1380 cache_ptr
->symbol
.section
= bfd_com_section_ptr
;
1384 cache_ptr
->symbol
.flags
= 0;
1385 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1389 case N_TEXT
: case N_TEXT
| N_EXT
:
1390 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1391 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1392 cache_ptr
->symbol
.flags
= visible
;
1395 case N_DATA
: case N_DATA
| N_EXT
:
1396 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1397 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1398 cache_ptr
->symbol
.flags
= visible
;
1401 case N_BSS
: case N_BSS
| N_EXT
:
1402 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1403 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1404 cache_ptr
->symbol
.flags
= visible
;
1411 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1414 translate_to_native_sym_flags (bfd
*abfd
,
1416 struct external_nlist
*sym_pointer
)
1418 bfd_vma value
= cache_ptr
->value
;
1422 /* Mask out any existing type bits in case copying from one section
1424 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1426 sec
= bfd_asymbol_section (cache_ptr
);
1431 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1434 /* xgettext:c-format */
1435 (_("%pB: can not represent section for symbol `%s' in a.out object file format"),
1436 abfd
, cache_ptr
->name
!= NULL
? cache_ptr
->name
: "*unknown*");
1437 bfd_set_error (bfd_error_nonrepresentable_section
);
1441 if (sec
->output_section
!= NULL
)
1443 off
= sec
->output_offset
;
1444 sec
= sec
->output_section
;
1447 if (bfd_is_abs_section (sec
))
1448 sym_pointer
->e_type
[0] |= N_ABS
;
1449 else if (sec
== obj_textsec (abfd
))
1450 sym_pointer
->e_type
[0] |= N_TEXT
;
1451 else if (sec
== obj_datasec (abfd
))
1452 sym_pointer
->e_type
[0] |= N_DATA
;
1453 else if (sec
== obj_bsssec (abfd
))
1454 sym_pointer
->e_type
[0] |= N_BSS
;
1455 else if (bfd_is_und_section (sec
))
1456 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1457 else if (bfd_is_com_section (sec
))
1458 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1462 /* xgettext:c-format */
1463 (_("%pB: can not represent section `%pA' in a.out object file format"),
1465 bfd_set_error (bfd_error_nonrepresentable_section
);
1469 /* Turn the symbol from section relative to absolute again */
1470 value
+= sec
->vma
+ off
;
1472 if ((cache_ptr
->flags
& BSF_DEBUGGING
) != 0)
1473 sym_pointer
->e_type
[0] = ((aout_symbol_type
*) cache_ptr
)->type
;
1474 else if ((cache_ptr
->flags
& BSF_GLOBAL
) != 0)
1475 sym_pointer
->e_type
[0] |= N_EXT
;
1477 PUT_WORD(abfd
, value
, sym_pointer
->e_value
);
1482 /* Native-level interface to symbols. */
1485 NAME (aout
, make_empty_symbol
) (bfd
*abfd
)
1487 size_t amt
= sizeof (aout_symbol_type
);
1488 aout_symbol_type
*new_symbol_type
= bfd_zalloc (abfd
, amt
);
1490 if (!new_symbol_type
)
1492 new_symbol_type
->symbol
.the_bfd
= abfd
;
1494 return &new_symbol_type
->symbol
;
1497 /* Translate a set of external symbols into internal symbols. */
1500 NAME (aout
, translate_symbol_table
) (bfd
*abfd
,
1501 aout_symbol_type
*in
,
1502 struct external_nlist
*ext
,
1503 bfd_size_type count
,
1505 bfd_size_type strsize
,
1506 bfd_boolean dynamic
)
1508 struct external_nlist
*ext_end
;
1510 ext_end
= ext
+ count
;
1511 for (; ext
< ext_end
; ext
++, in
++)
1515 x
= GET_WORD (abfd
, ext
->e_strx
);
1516 in
->symbol
.the_bfd
= abfd
;
1518 /* For the normal symbols, the zero index points at the number
1519 of bytes in the string table but is to be interpreted as the
1520 null string. For the dynamic symbols, the number of bytes in
1521 the string table is stored in the __DYNAMIC structure and the
1522 zero index points at an actual string. */
1523 if (x
== 0 && ! dynamic
)
1524 in
->symbol
.name
= "";
1525 else if (x
< strsize
)
1526 in
->symbol
.name
= str
+ x
;
1530 (_("%pB: invalid string offset %" PRIu64
" >= %" PRIu64
),
1531 abfd
, (uint64_t) x
, (uint64_t) strsize
);
1532 bfd_set_error (bfd_error_bad_value
);
1536 in
->symbol
.value
= GET_WORD (abfd
, ext
->e_value
);
1537 /* TODO: is 0 a safe value here? */
1540 in
->type
= H_GET_8 (abfd
, ext
->e_type
);
1541 in
->symbol
.udata
.p
= NULL
;
1543 if (! translate_from_native_sym_flags (abfd
, in
))
1547 in
->symbol
.flags
|= BSF_DYNAMIC
;
1553 /* We read the symbols into a buffer, which is discarded when this
1554 function exits. We read the strings into a buffer large enough to
1555 hold them all plus all the cached symbol entries. */
1558 NAME (aout
, slurp_symbol_table
) (bfd
*abfd
)
1560 struct external_nlist
*old_external_syms
;
1561 aout_symbol_type
*cached
;
1562 bfd_size_type cached_size
;
1564 /* If there's no work to be done, don't do any. */
1565 if (obj_aout_symbols (abfd
) != NULL
)
1568 old_external_syms
= obj_aout_external_syms (abfd
);
1570 if (! aout_get_external_symbols (abfd
))
1573 cached_size
= obj_aout_external_sym_count (abfd
);
1574 cached_size
*= sizeof (aout_symbol_type
);
1575 cached
= bfd_zmalloc (cached_size
);
1576 if (cached
== NULL
&& cached_size
!= 0)
1579 /* Convert from external symbol information to internal. */
1580 if (! (NAME (aout
, translate_symbol_table
)
1582 obj_aout_external_syms (abfd
),
1583 obj_aout_external_sym_count (abfd
),
1584 obj_aout_external_strings (abfd
),
1585 obj_aout_external_string_size (abfd
),
1592 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
1594 obj_aout_symbols (abfd
) = cached
;
1596 /* It is very likely that anybody who calls this function will not
1597 want the external symbol information, so if it was allocated
1598 because of our call to aout_get_external_symbols, we free it up
1599 right away to save space. */
1600 if (old_external_syms
== NULL
1601 && obj_aout_external_syms (abfd
) != NULL
)
1604 bfd_free_window (&obj_aout_sym_window (abfd
));
1606 free (obj_aout_external_syms (abfd
));
1608 obj_aout_external_syms (abfd
) = NULL
;
1614 /* We use a hash table when writing out symbols so that we only write
1615 out a particular string once. This helps particularly when the
1616 linker writes out stabs debugging entries, because each different
1617 contributing object file tends to have many duplicate stabs
1620 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1621 if BFD_TRADITIONAL_FORMAT is set. */
1623 /* Get the index of a string in a strtab, adding it if it is not
1626 static inline bfd_size_type
1627 add_to_stringtab (bfd
*abfd
,
1628 struct bfd_strtab_hash
*tab
,
1633 bfd_size_type str_index
;
1635 /* An index of 0 always means the empty string. */
1636 if (str
== 0 || *str
== '\0')
1639 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1640 doesn't understand a hashed string table. */
1642 if ((abfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1645 str_index
= _bfd_stringtab_add (tab
, str
, hash
, copy
);
1647 if (str_index
!= (bfd_size_type
) -1)
1648 /* Add BYTES_IN_LONG to the return value to account for the
1649 space taken up by the string table size. */
1650 str_index
+= BYTES_IN_LONG
;
1655 /* Write out a strtab. ABFD is already at the right location in the
1659 emit_stringtab (bfd
*abfd
, struct bfd_strtab_hash
*tab
)
1661 bfd_byte buffer
[BYTES_IN_LONG
];
1663 /* The string table starts with the size. */
1664 H_PUT_32 (abfd
, _bfd_stringtab_size (tab
) + BYTES_IN_LONG
, buffer
);
1665 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) BYTES_IN_LONG
, abfd
)
1669 return _bfd_stringtab_emit (abfd
, tab
);
1673 NAME (aout
, write_syms
) (bfd
*abfd
)
1675 unsigned int count
;
1676 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1677 struct bfd_strtab_hash
*strtab
;
1679 strtab
= _bfd_stringtab_init ();
1683 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1685 asymbol
*g
= generic
[count
];
1687 struct external_nlist nsp
;
1689 PUT_WORD (abfd
, 0, nsp
.e_unused
);
1691 indx
= add_to_stringtab (abfd
, strtab
, g
->name
, FALSE
);
1692 if (indx
== (bfd_size_type
) -1)
1694 PUT_WORD (abfd
, indx
, nsp
.e_strx
);
1696 if (bfd_asymbol_flavour(g
) == abfd
->xvec
->flavour
)
1697 H_PUT_8 (abfd
, aout_symbol(g
)->type
, nsp
.e_type
);
1699 H_PUT_8 (abfd
, 0, nsp
.e_type
);
1701 if (! translate_to_native_sym_flags (abfd
, g
, &nsp
))
1704 H_PUT_8 (abfd
, 0, nsp
.e_ovly
);
1706 if (bfd_bwrite ((void *)&nsp
, (bfd_size_type
) EXTERNAL_NLIST_SIZE
, abfd
)
1707 != EXTERNAL_NLIST_SIZE
)
1710 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1711 here, at the end. */
1715 if (! emit_stringtab (abfd
, strtab
))
1718 _bfd_stringtab_free (strtab
);
1723 _bfd_stringtab_free (strtab
);
1729 NAME (aout
, canonicalize_symtab
) (bfd
*abfd
, asymbol
**location
)
1731 unsigned int counter
= 0;
1732 aout_symbol_type
*symbase
;
1734 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
1737 for (symbase
= obj_aout_symbols (abfd
); counter
++ < bfd_get_symcount (abfd
);)
1738 *(location
++) = (asymbol
*)(symbase
++);
1740 return bfd_get_symcount (abfd
);
1744 /* Output extended relocation information to a file in target byte order. */
1747 pdp11_aout_swap_reloc_out (bfd
*abfd
, arelent
*g
, bfd_byte
*natptr
)
1753 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1754 asection
*output_section
= sym
->section
->output_section
;
1757 fprintf (stderr
, "BFD: can't do this reloc addend stuff\n");
1759 r_pcrel
= g
->howto
->pc_relative
;
1761 if (bfd_is_abs_section (output_section
))
1763 else if (output_section
== obj_textsec (abfd
))
1765 else if (output_section
== obj_datasec (abfd
))
1767 else if (output_section
== obj_bsssec (abfd
))
1769 else if (bfd_is_und_section (output_section
))
1771 else if (bfd_is_com_section (output_section
))
1776 BFD_ASSERT (r_type
!= -1);
1781 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
1783 reloc_entry
= r_index
<< 4 | r_type
| r_pcrel
;
1785 PUT_WORD (abfd
, reloc_entry
, natptr
);
1788 /* BFD deals internally with all things based from the section they're
1789 in. so, something in 10 bytes into a text section with a base of
1790 50 would have a symbol (.text+10) and know .text vma was 50.
1792 Aout keeps all it's symbols based from zero, so the symbol would
1793 contain 60. This macro subs the base of each section from the value
1794 to give the true offset from the section */
1797 #define MOVE_ADDRESS(ad) \
1800 /* Undefined symbol. */ \
1801 cache_ptr->sym_ptr_ptr = symbols + r_index; \
1802 cache_ptr->addend = ad; \
1806 /* Defined, section relative. replace symbol with pointer to \
1807 symbol which points to section. */ \
1811 case N_TEXT | N_EXT: \
1812 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
1813 cache_ptr->addend = ad - su->textsec->vma; \
1816 case N_DATA | N_EXT: \
1817 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
1818 cache_ptr->addend = ad - su->datasec->vma; \
1821 case N_BSS | N_EXT: \
1822 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
1823 cache_ptr->addend = ad - su->bsssec->vma; \
1827 case N_ABS | N_EXT: \
1828 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1829 cache_ptr->addend = ad; \
1835 pdp11_aout_swap_reloc_in (bfd
* abfd
,
1837 arelent
* cache_ptr
,
1838 bfd_size_type offset
,
1840 bfd_size_type symcount
)
1842 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
1843 unsigned int r_index
;
1848 reloc_entry
= GET_WORD (abfd
, (void *) bytes
);
1850 r_pcrel
= reloc_entry
& RELFLG
;
1852 cache_ptr
->address
= offset
;
1853 cache_ptr
->howto
= howto_table_pdp11
+ (r_pcrel
? 1 : 0);
1855 if ((reloc_entry
& RTYPE
) == RABS
)
1858 r_index
= RINDEX (reloc_entry
);
1860 /* r_extern reflects whether the symbol the reloc is against is
1862 r_extern
= (reloc_entry
& RTYPE
) == REXT
;
1864 if (r_extern
&& r_index
>= symcount
)
1866 /* We could arrange to return an error, but it might be useful
1867 to see the file even if it is bad. FIXME: Of course this
1868 means that objdump -r *doesn't* see the actual reloc, and
1869 objcopy silently writes a different reloc. */
1877 /* Read and swap the relocs for a section. */
1880 NAME (aout
, slurp_reloc_table
) (bfd
*abfd
, sec_ptr asect
, asymbol
**symbols
)
1883 bfd_size_type count
;
1884 bfd_size_type reloc_size
;
1886 arelent
*reloc_cache
;
1888 unsigned int counter
= 0;
1891 if (asect
->relocation
)
1894 if (asect
->flags
& SEC_CONSTRUCTOR
)
1897 if (asect
== obj_datasec (abfd
))
1898 reloc_size
= exec_hdr(abfd
)->a_drsize
;
1899 else if (asect
== obj_textsec (abfd
))
1900 reloc_size
= exec_hdr(abfd
)->a_trsize
;
1901 else if (asect
== obj_bsssec (abfd
))
1905 bfd_set_error (bfd_error_invalid_operation
);
1909 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
1911 relocs
= _bfd_malloc_and_read (abfd
, reloc_size
, reloc_size
);
1912 if (relocs
== NULL
&& reloc_size
!= 0)
1915 each_size
= obj_reloc_entry_size (abfd
);
1916 count
= reloc_size
/ each_size
;
1918 /* Count the number of NON-ZERO relocs, this is the count we want. */
1920 unsigned int real_count
= 0;
1922 for (counter
= 0; counter
< count
; counter
++)
1926 x
= GET_WORD (abfd
, (char *) relocs
+ each_size
* counter
);
1934 reloc_cache
= bfd_zmalloc (count
* sizeof (arelent
));
1935 if (reloc_cache
== NULL
&& count
!= 0)
1938 cache_ptr
= reloc_cache
;
1943 counter
++, rptr
+= RELOC_SIZE
, cache_ptr
++)
1945 while (GET_WORD (abfd
, (void *) rptr
) == 0)
1948 if ((char *) rptr
>= (char *) relocs
+ reloc_size
)
1952 pdp11_aout_swap_reloc_in (abfd
, rptr
, cache_ptr
,
1953 (bfd_size_type
) ((char *) rptr
- (char *) relocs
),
1955 (bfd_size_type
) bfd_get_symcount (abfd
));
1958 /* Just in case, if rptr >= relocs + reloc_size should happen
1960 BFD_ASSERT (counter
== count
);
1964 asect
->relocation
= reloc_cache
;
1965 asect
->reloc_count
= cache_ptr
- reloc_cache
;
1970 /* Write out a relocation section into an object file. */
1973 NAME (aout
, squirt_out_relocs
) (bfd
*abfd
, asection
*section
)
1976 unsigned char *native
;
1977 unsigned int count
= section
->reloc_count
;
1978 bfd_size_type natsize
;
1980 natsize
= section
->size
;
1981 native
= bfd_zalloc (abfd
, natsize
);
1985 generic
= section
->orelocation
;
1986 if (generic
!= NULL
)
1992 if ((*generic
)->howto
== NULL
1993 || (*generic
)->sym_ptr_ptr
== NULL
)
1995 bfd_set_error (bfd_error_invalid_operation
);
1996 _bfd_error_handler (_("%pB: attempt to write out "
1997 "unknown reloc type"), abfd
);
1998 bfd_release (abfd
, native
);
2001 r
= native
+ (*generic
)->address
;
2002 pdp11_aout_swap_reloc_out (abfd
, *generic
, r
);
2008 if (bfd_bwrite ((void *) native
, natsize
, abfd
) != natsize
)
2010 bfd_release (abfd
, native
);
2014 bfd_release (abfd
, native
);
2018 /* This is stupid. This function should be a boolean predicate. */
2021 NAME (aout
, canonicalize_reloc
) (bfd
*abfd
,
2026 arelent
*tblptr
= section
->relocation
;
2029 if (section
== obj_bsssec (abfd
))
2035 if (!(tblptr
|| NAME (aout
, slurp_reloc_table
)(abfd
, section
, symbols
)))
2038 if (section
->flags
& SEC_CONSTRUCTOR
)
2040 arelent_chain
*chain
= section
->constructor_chain
;
2042 for (count
= 0; count
< section
->reloc_count
; count
++)
2044 *relptr
++ = &chain
->relent
;
2045 chain
= chain
->next
;
2050 tblptr
= section
->relocation
;
2052 for (count
= 0; count
++ < section
->reloc_count
;)
2053 *relptr
++ = tblptr
++;
2058 return section
->reloc_count
;
2062 NAME (aout
, get_reloc_upper_bound
) (bfd
*abfd
, sec_ptr asect
)
2064 bfd_size_type count
;
2066 if (bfd_get_format (abfd
) != bfd_object
)
2068 bfd_set_error (bfd_error_invalid_operation
);
2072 if (asect
->flags
& SEC_CONSTRUCTOR
)
2073 count
= asect
->reloc_count
;
2074 else if (asect
== obj_datasec (abfd
))
2075 count
= exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
2076 else if (asect
== obj_textsec (abfd
))
2077 count
= exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
2078 else if (asect
== obj_bsssec (abfd
))
2082 bfd_set_error (bfd_error_invalid_operation
);
2086 if (count
>= LONG_MAX
/ sizeof (arelent
*))
2088 bfd_set_error (bfd_error_file_too_big
);
2091 return (count
+ 1) * sizeof (arelent
*);
2096 NAME (aout
, get_symtab_upper_bound
) (bfd
*abfd
)
2098 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
2101 return (bfd_get_symcount (abfd
) + 1) * (sizeof (aout_symbol_type
*));
2105 NAME (aout
, get_lineno
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2106 asymbol
* symbol ATTRIBUTE_UNUSED
)
2112 NAME (aout
, get_symbol_info
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2116 bfd_symbol_info (symbol
, ret
);
2118 if (ret
->type
== '?')
2120 int type_code
= aout_symbol(symbol
)->type
& 0xff;
2121 const char *stab_name
= bfd_get_stab_name (type_code
);
2122 static char buf
[10];
2124 if (stab_name
== NULL
)
2126 sprintf(buf
, "(%d)", type_code
);
2130 ret
->stab_type
= type_code
;
2131 ret
->stab_other
= (unsigned) (aout_symbol(symbol
)->other
& 0xff);
2132 ret
->stab_desc
= (unsigned) (aout_symbol(symbol
)->desc
& 0xffff);
2133 ret
->stab_name
= stab_name
;
2138 NAME (aout
, print_symbol
) (bfd
* abfd
,
2141 bfd_print_symbol_type how
)
2143 FILE *file
= (FILE *) afile
;
2147 case bfd_print_symbol_name
:
2149 fprintf(file
,"%s", symbol
->name
);
2151 case bfd_print_symbol_more
:
2152 fprintf(file
,"%4x %2x %2x",
2153 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2154 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2155 (unsigned) (aout_symbol (symbol
)->type
));
2157 case bfd_print_symbol_all
:
2159 const char *section_name
= symbol
->section
->name
;
2161 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2163 fprintf (file
," %-5s %04x %02x %02x",
2165 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2166 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2167 (unsigned) (aout_symbol (symbol
)->type
& 0xff));
2169 fprintf(file
," %s", symbol
->name
);
2175 /* If we don't have to allocate more than 1MB to hold the generic
2176 symbols, we use the generic minisymbol method: it's faster, since
2177 it only translates the symbols once, not multiple times. */
2178 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2180 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2181 symbols. The minisymbol_to_symbol function translates these into
2182 BFD asymbol structures. */
2185 NAME (aout
, read_minisymbols
) (bfd
*abfd
,
2186 bfd_boolean dynamic
,
2188 unsigned int *sizep
)
2191 /* We could handle the dynamic symbols here as well, but it's
2192 easier to hand them off. */
2193 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2195 if (! aout_get_external_symbols (abfd
))
2198 if (obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2199 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2201 *minisymsp
= (void *) obj_aout_external_syms (abfd
);
2203 /* By passing the external symbols back from this routine, we are
2204 giving up control over the memory block. Clear
2205 obj_aout_external_syms, so that we do not try to free it
2207 obj_aout_external_syms (abfd
) = NULL
;
2209 *sizep
= EXTERNAL_NLIST_SIZE
;
2210 return obj_aout_external_sym_count (abfd
);
2213 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2214 unmodified a.out symbol. The SYM argument is a structure returned
2215 by bfd_make_empty_symbol, which we fill in here. */
2218 NAME (aout
, minisymbol_to_symbol
) (bfd
*abfd
,
2219 bfd_boolean dynamic
,
2220 const void * minisym
,
2224 || obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2225 return _bfd_generic_minisymbol_to_symbol (abfd
, dynamic
, minisym
, sym
);
2227 memset (sym
, 0, sizeof (aout_symbol_type
));
2229 /* We call translate_symbol_table to translate a single symbol. */
2230 if (! (NAME (aout
, translate_symbol_table
)
2232 (aout_symbol_type
*) sym
,
2233 (struct external_nlist
*) minisym
,
2235 obj_aout_external_strings (abfd
),
2236 obj_aout_external_string_size (abfd
),
2243 /* Provided a BFD, a section and an offset into the section, calculate
2244 and return the name of the source file and the line nearest to the
2248 NAME (aout
, find_nearest_line
) (bfd
*abfd
,
2252 const char **filename_ptr
,
2253 const char **functionname_ptr
,
2254 unsigned int *line_ptr
,
2255 unsigned int *discriminator_ptr
)
2257 /* Run down the file looking for the filename, function and linenumber. */
2259 const char *directory_name
= NULL
;
2260 const char *main_file_name
= NULL
;
2261 const char *current_file_name
= NULL
;
2262 const char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2263 bfd_vma low_line_vma
= 0;
2264 bfd_vma low_func_vma
= 0;
2266 size_t filelen
, funclen
;
2269 *filename_ptr
= bfd_get_filename (abfd
);
2270 *functionname_ptr
= NULL
;
2272 if (discriminator_ptr
)
2273 *discriminator_ptr
= 0;
2275 if (symbols
!= NULL
)
2277 for (p
= symbols
; *p
; p
++)
2279 aout_symbol_type
*q
= (aout_symbol_type
*)(*p
);
2284 /* If this looks like a file name symbol, and it comes after
2285 the line number we have found so far, but before the
2286 offset, then we have probably not found the right line
2288 if (q
->symbol
.value
<= offset
2289 && ((q
->symbol
.value
> low_line_vma
2290 && (line_file_name
!= NULL
2292 || (q
->symbol
.value
> low_func_vma
2295 const char * symname
;
2297 symname
= q
->symbol
.name
;
2300 && strlen (symname
) > 2
2301 && strcmp (symname
+ strlen (symname
) - 2, ".o") == 0)
2303 if (q
->symbol
.value
> low_line_vma
)
2306 line_file_name
= NULL
;
2308 if (q
->symbol
.value
> low_func_vma
)
2315 /* If this symbol is less than the offset, but greater than
2316 the line number we have found so far, then we have not
2317 found the right line number. */
2318 if (q
->symbol
.value
<= offset
)
2320 if (q
->symbol
.value
> low_line_vma
)
2323 line_file_name
= NULL
;
2325 if (q
->symbol
.value
> low_func_vma
)
2329 main_file_name
= current_file_name
= q
->symbol
.name
;
2330 /* Look ahead to next symbol to check if that too is an N_SO. */
2334 q
= (aout_symbol_type
*)(*p
);
2335 if (q
->type
!= (int) N_SO
)
2338 /* Found a second N_SO First is directory; second is filename. */
2339 directory_name
= current_file_name
;
2340 main_file_name
= current_file_name
= q
->symbol
.name
;
2341 if (obj_textsec(abfd
) != section
)
2345 current_file_name
= q
->symbol
.name
;
2351 /* We'll keep this if it resolves nearer than the one we have
2353 if (q
->symbol
.value
>= low_line_vma
2354 && q
->symbol
.value
<= offset
)
2356 *line_ptr
= q
->desc
;
2357 low_line_vma
= q
->symbol
.value
;
2358 line_file_name
= current_file_name
;
2364 /* We'll keep this if it is nearer than the one we have already. */
2365 if (q
->symbol
.value
>= low_func_vma
&&
2366 q
->symbol
.value
<= offset
)
2368 low_func_vma
= q
->symbol
.value
;
2369 func
= (asymbol
*) q
;
2371 else if (q
->symbol
.value
> offset
)
2381 main_file_name
= line_file_name
;
2383 if (main_file_name
== NULL
2384 || main_file_name
[0] == '/'
2385 || directory_name
== NULL
)
2388 filelen
= strlen (directory_name
) + strlen (main_file_name
);
2392 funclen
= strlen (bfd_asymbol_name (func
));
2394 free (adata (abfd
).line_buf
);
2395 if (filelen
+ funclen
== 0)
2396 adata (abfd
).line_buf
= buf
= NULL
;
2399 buf
= bfd_malloc ((bfd_size_type
) filelen
+ funclen
+ 3);
2400 adata (abfd
).line_buf
= buf
;
2405 if (main_file_name
!= NULL
)
2407 if (main_file_name
[0] == '/' || directory_name
== NULL
)
2408 *filename_ptr
= main_file_name
;
2412 /* PR binutils/20891: In a corrupt input file both
2413 main_file_name and directory_name can be empty... */
2414 * filename_ptr
= NULL
;
2417 snprintf (buf
, filelen
+ 1, "%s%s", directory_name
,
2419 *filename_ptr
= buf
;
2427 const char *function
= func
->name
;
2432 /* PR binutils/20892: In a corrupt input file func can be empty. */
2433 * functionname_ptr
= NULL
;
2436 /* The caller expects a symbol name. We actually have a
2437 function name, without the leading underscore. Put the
2438 underscore back in, so that the caller gets a symbol name. */
2439 if (bfd_get_symbol_leading_char (abfd
) == '\0')
2440 strcpy (buf
, function
);
2443 buf
[0] = bfd_get_symbol_leading_char (abfd
);
2444 strcpy (buf
+ 1, function
);
2447 /* Have to remove : stuff. */
2448 colon
= strchr (buf
, ':');
2451 *functionname_ptr
= buf
;
2458 NAME (aout
, sizeof_headers
) (bfd
*abfd
,
2459 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2461 return adata (abfd
).exec_bytes_size
;
2464 /* Free all information we have cached for this BFD. We can always
2465 read it again later if we need it. */
2468 NAME (aout
, bfd_free_cached_info
) (bfd
*abfd
)
2472 if (bfd_get_format (abfd
) != bfd_object
)
2475 #define BFCI_FREE(x) do { free (x); x = NULL; } while (0)
2476 BFCI_FREE (obj_aout_symbols (abfd
));
2479 obj_aout_external_syms (abfd
) = 0;
2480 bfd_free_window (&obj_aout_sym_window (abfd
));
2481 bfd_free_window (&obj_aout_string_window (abfd
));
2482 obj_aout_external_strings (abfd
) = 0;
2484 BFCI_FREE (obj_aout_external_syms (abfd
));
2485 BFCI_FREE (obj_aout_external_strings (abfd
));
2487 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2488 BFCI_FREE (o
->relocation
);
2494 /* Routine to create an entry in an a.out link hash table. */
2496 struct bfd_hash_entry
*
2497 NAME (aout
, link_hash_newfunc
) (struct bfd_hash_entry
*entry
,
2498 struct bfd_hash_table
*table
,
2501 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2503 /* Allocate the structure if it has not already been allocated by a
2506 ret
= bfd_hash_allocate (table
, sizeof (* ret
));
2510 /* Call the allocation method of the superclass. */
2511 ret
= (struct aout_link_hash_entry
*)
2512 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
);
2515 /* Set local fields. */
2516 ret
->written
= FALSE
;
2520 return (struct bfd_hash_entry
*) ret
;
2523 /* Initialize an a.out link hash table. */
2526 NAME (aout
, link_hash_table_init
) (struct aout_link_hash_table
*table
,
2528 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
2529 struct bfd_hash_table
*,
2531 unsigned int entsize
)
2533 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
2536 /* Create an a.out link hash table. */
2538 struct bfd_link_hash_table
*
2539 NAME (aout
, link_hash_table_create
) (bfd
*abfd
)
2541 struct aout_link_hash_table
*ret
;
2542 size_t amt
= sizeof (struct aout_link_hash_table
);
2544 ret
= bfd_malloc (amt
);
2547 if (! NAME (aout
, link_hash_table_init
) (ret
, abfd
,
2548 NAME (aout
, link_hash_newfunc
),
2549 sizeof (struct aout_link_hash_entry
)))
2557 /* Free up the internal symbols read from an a.out file. */
2560 aout_link_free_symbols (bfd
*abfd
)
2562 if (obj_aout_external_syms (abfd
) != NULL
)
2565 bfd_free_window (&obj_aout_sym_window (abfd
));
2567 free ((void *) obj_aout_external_syms (abfd
));
2569 obj_aout_external_syms (abfd
) = NULL
;
2572 if (obj_aout_external_strings (abfd
) != NULL
)
2575 bfd_free_window (&obj_aout_string_window (abfd
));
2577 free ((void *) obj_aout_external_strings (abfd
));
2579 obj_aout_external_strings (abfd
) = NULL
;
2584 /* Given an a.out BFD, add symbols to the global hash table as
2588 NAME (aout
, link_add_symbols
) (bfd
*abfd
, struct bfd_link_info
*info
)
2590 switch (bfd_get_format (abfd
))
2593 return aout_link_add_object_symbols (abfd
, info
);
2595 return _bfd_generic_link_add_archive_symbols
2596 (abfd
, info
, aout_link_check_archive_element
);
2598 bfd_set_error (bfd_error_wrong_format
);
2603 /* Add symbols from an a.out object file. */
2606 aout_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2608 if (! aout_get_external_symbols (abfd
))
2610 if (! aout_link_add_symbols (abfd
, info
))
2612 if (! info
->keep_memory
)
2614 if (! aout_link_free_symbols (abfd
))
2620 /* Look through the internal symbols to see if this object file should
2621 be included in the link. We should include this object file if it
2622 defines any symbols which are currently undefined. If this object
2623 file defines a common symbol, then we may adjust the size of the
2624 known symbol but we do not include the object file in the link
2625 (unless there is some other reason to include it). */
2628 aout_link_check_ar_symbols (bfd
*abfd
,
2629 struct bfd_link_info
*info
,
2630 bfd_boolean
*pneeded
,
2633 struct external_nlist
*p
;
2634 struct external_nlist
*pend
;
2639 /* Look through all the symbols. */
2640 p
= obj_aout_external_syms (abfd
);
2641 pend
= p
+ obj_aout_external_sym_count (abfd
);
2642 strings
= obj_aout_external_strings (abfd
);
2643 for (; p
< pend
; p
++)
2645 int type
= H_GET_8 (abfd
, p
->e_type
);
2647 struct bfd_link_hash_entry
*h
;
2649 /* Ignore symbols that are not externally visible. This is an
2650 optimization only, as we check the type more thoroughly
2652 if ((type
& N_EXT
) == 0
2656 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2657 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
2659 /* We are only interested in symbols that are currently
2660 undefined or common. */
2662 || (h
->type
!= bfd_link_hash_undefined
2663 && h
->type
!= bfd_link_hash_common
))
2666 if (type
== (N_TEXT
| N_EXT
)
2667 || type
== (N_DATA
| N_EXT
)
2668 || type
== (N_BSS
| N_EXT
)
2669 || type
== (N_ABS
| N_EXT
))
2671 /* This object file defines this symbol. We must link it
2672 in. This is true regardless of whether the current
2673 definition of the symbol is undefined or common. If the
2674 current definition is common, we have a case in which we
2675 have already seen an object file including
2677 and this object file from the archive includes
2679 In such a case we must include this object file.
2681 FIXME: The SunOS 4.1.3 linker will pull in the archive
2682 element if the symbol is defined in the .data section,
2683 but not if it is defined in the .text section. That
2684 seems a bit crazy to me, and I haven't implemented it.
2685 However, it might be correct. */
2686 if (!(*info
->callbacks
2687 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2693 if (type
== (N_UNDF
| N_EXT
))
2697 value
= GET_WORD (abfd
, p
->e_value
);
2700 /* This symbol is common in the object from the archive
2702 if (h
->type
== bfd_link_hash_undefined
)
2707 symbfd
= h
->u
.undef
.abfd
;
2710 /* This symbol was created as undefined from
2711 outside BFD. We assume that we should link
2712 in the object file. This is done for the -u
2713 option in the linker. */
2714 if (!(*info
->callbacks
2715 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2720 /* Turn the current link symbol into a common
2721 symbol. It is already on the undefs list. */
2722 h
->type
= bfd_link_hash_common
;
2723 h
->u
.c
.p
= bfd_hash_allocate (&info
->hash
->table
,
2724 sizeof (struct bfd_link_hash_common_entry
));
2725 if (h
->u
.c
.p
== NULL
)
2728 h
->u
.c
.size
= value
;
2730 /* FIXME: This isn't quite right. The maximum
2731 alignment of a common symbol should be set by the
2732 architecture of the output file, not of the input
2734 power
= bfd_log2 (value
);
2735 if (power
> bfd_get_arch_info (abfd
)->section_align_power
)
2736 power
= bfd_get_arch_info (abfd
)->section_align_power
;
2737 h
->u
.c
.p
->alignment_power
= power
;
2739 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
,
2744 /* Adjust the size of the common symbol if
2746 if (value
> h
->u
.c
.size
)
2747 h
->u
.c
.size
= value
;
2753 /* We do not need this object file. */
2757 /* Check a single archive element to see if we need to include it in
2758 the link. *PNEEDED is set according to whether this element is
2759 needed in the link or not. This is called from
2760 _bfd_generic_link_add_archive_symbols. */
2763 aout_link_check_archive_element (bfd
*abfd
,
2764 struct bfd_link_info
*info
,
2765 struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
2766 const char *name ATTRIBUTE_UNUSED
,
2767 bfd_boolean
*pneeded
)
2772 if (!aout_get_external_symbols (abfd
))
2776 if (!aout_link_check_ar_symbols (abfd
, info
, pneeded
, &abfd
))
2782 /* Potentially, the add_archive_element hook may have set a
2783 substitute BFD for us. */
2786 if (!info
->keep_memory
2787 && !aout_link_free_symbols (oldbfd
))
2789 if (!aout_get_external_symbols (abfd
))
2792 if (!aout_link_add_symbols (abfd
, info
))
2796 if (!info
->keep_memory
|| !needed
)
2798 if (!aout_link_free_symbols (abfd
))
2805 /* Add all symbols from an object file to the hash table. */
2808 aout_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2810 bfd_boolean (*add_one_symbol
)
2811 (struct bfd_link_info
*, bfd
*, const char *, flagword
, asection
*,
2812 bfd_vma
, const char *, bfd_boolean
, bfd_boolean
,
2813 struct bfd_link_hash_entry
**);
2814 struct external_nlist
*syms
;
2815 bfd_size_type sym_count
;
2818 struct aout_link_hash_entry
**sym_hash
;
2819 struct external_nlist
*p
;
2820 struct external_nlist
*pend
;
2822 syms
= obj_aout_external_syms (abfd
);
2823 sym_count
= obj_aout_external_sym_count (abfd
);
2824 strings
= obj_aout_external_strings (abfd
);
2825 if (info
->keep_memory
)
2830 if (aout_backend_info (abfd
)->add_dynamic_symbols
!= NULL
)
2832 if (! ((*aout_backend_info (abfd
)->add_dynamic_symbols
)
2833 (abfd
, info
, &syms
, &sym_count
, &strings
)))
2837 /* We keep a list of the linker hash table entries that correspond
2838 to particular symbols. We could just look them up in the hash
2839 table, but keeping the list is more efficient. Perhaps this
2840 should be conditional on info->keep_memory. */
2841 sym_hash
= bfd_alloc (abfd
,
2842 sym_count
* sizeof (struct aout_link_hash_entry
*));
2843 if (sym_hash
== NULL
&& sym_count
!= 0)
2845 obj_aout_sym_hashes (abfd
) = sym_hash
;
2847 add_one_symbol
= aout_backend_info (abfd
)->add_one_symbol
;
2848 if (add_one_symbol
== NULL
)
2849 add_one_symbol
= _bfd_generic_link_add_one_symbol
;
2852 pend
= p
+ sym_count
;
2853 for (; p
< pend
; p
++, sym_hash
++)
2864 type
= H_GET_8 (abfd
, p
->e_type
);
2866 /* PR 19629: Corrupt binaries can contain illegal string offsets. */
2867 if (GET_WORD (abfd
, p
->e_strx
) >= obj_aout_external_string_size (abfd
))
2869 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2870 value
= GET_WORD (abfd
, p
->e_value
);
2876 /* Anything else should be a debugging symbol. */
2877 BFD_ASSERT ((type
& N_STAB
) != 0);
2887 /* Ignore symbols that are not externally visible. */
2890 case N_UNDF
| N_EXT
:
2893 section
= bfd_und_section_ptr
;
2897 section
= bfd_com_section_ptr
;
2900 section
= bfd_abs_section_ptr
;
2902 case N_TEXT
| N_EXT
:
2903 section
= obj_textsec (abfd
);
2904 value
-= bfd_section_vma (section
);
2906 case N_DATA
| N_EXT
:
2907 /* Treat N_SETV symbols as N_DATA symbol; see comment in
2908 translate_from_native_sym_flags. */
2909 section
= obj_datasec (abfd
);
2910 value
-= bfd_section_vma (section
);
2913 section
= obj_bsssec (abfd
);
2914 value
-= bfd_section_vma (section
);
2918 if (! ((*add_one_symbol
)
2919 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, FALSE
,
2920 (struct bfd_link_hash_entry
**) sym_hash
)))
2923 /* Restrict the maximum alignment of a common symbol based on
2924 the architecture, since a.out has no way to represent
2925 alignment requirements of a section in a .o file. FIXME:
2926 This isn't quite right: it should use the architecture of the
2927 output file, not the input files. */
2928 if ((*sym_hash
)->root
.type
== bfd_link_hash_common
2929 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
>
2930 bfd_get_arch_info (abfd
)->section_align_power
))
2931 (*sym_hash
)->root
.u
.c
.p
->alignment_power
=
2932 bfd_get_arch_info (abfd
)->section_align_power
;
2934 /* If this is a set symbol, and we are not building sets, then
2935 it is possible for the hash entry to not have been set. In
2936 such a case, treat the symbol as not globally defined. */
2937 if ((*sym_hash
)->root
.type
== bfd_link_hash_new
)
2939 BFD_ASSERT ((flags
& BSF_CONSTRUCTOR
) != 0);
2947 /* Look up an entry in an the header file hash table. */
2949 #define aout_link_includes_lookup(table, string, create, copy) \
2950 ((struct aout_link_includes_entry *) \
2951 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
2953 /* The function to create a new entry in the header file hash table. */
2955 static struct bfd_hash_entry
*
2956 aout_link_includes_newfunc (struct bfd_hash_entry
*entry
,
2957 struct bfd_hash_table
*table
,
2960 struct aout_link_includes_entry
* ret
=
2961 (struct aout_link_includes_entry
*) entry
;
2963 /* Allocate the structure if it has not already been allocated by a
2966 ret
= bfd_hash_allocate (table
,
2967 sizeof (struct aout_link_includes_entry
));
2971 /* Call the allocation method of the superclass. */
2972 ret
= ((struct aout_link_includes_entry
*)
2973 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
2975 /* Set local fields. */
2978 return (struct bfd_hash_entry
*) ret
;
2981 /* Write out a symbol that was not associated with an a.out input
2985 aout_link_write_other_symbol (struct bfd_hash_entry
*bh
, void *data
)
2987 struct aout_link_hash_entry
*h
= (struct aout_link_hash_entry
*) bh
;
2988 struct aout_final_link_info
*flaginfo
= (struct aout_final_link_info
*) data
;
2992 struct external_nlist outsym
;
2996 if (h
->root
.type
== bfd_link_hash_warning
)
2998 h
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
2999 if (h
->root
.type
== bfd_link_hash_new
)
3003 output_bfd
= flaginfo
->output_bfd
;
3005 if (aout_backend_info (output_bfd
)->write_dynamic_symbol
!= NULL
)
3007 if (! ((*aout_backend_info (output_bfd
)->write_dynamic_symbol
)
3008 (output_bfd
, flaginfo
->info
, h
)))
3010 /* FIXME: No way to handle errors. */
3020 /* An indx of -2 means the symbol must be written. */
3022 && (flaginfo
->info
->strip
== strip_all
3023 || (flaginfo
->info
->strip
== strip_some
3024 && bfd_hash_lookup (flaginfo
->info
->keep_hash
, h
->root
.root
.string
,
3025 FALSE
, FALSE
) == NULL
)))
3028 switch (h
->root
.type
)
3032 /* Avoid variable not initialized warnings. */
3034 case bfd_link_hash_new
:
3035 /* This can happen for set symbols when sets are not being
3038 case bfd_link_hash_undefined
:
3039 type
= N_UNDF
| N_EXT
;
3042 case bfd_link_hash_defined
:
3043 case bfd_link_hash_defweak
:
3047 sec
= h
->root
.u
.def
.section
->output_section
;
3048 BFD_ASSERT (bfd_is_abs_section (sec
)
3049 || sec
->owner
== output_bfd
);
3050 if (sec
== obj_textsec (output_bfd
))
3051 type
= h
->root
.type
== bfd_link_hash_defined
? N_TEXT
: N_WEAKT
;
3052 else if (sec
== obj_datasec (output_bfd
))
3053 type
= h
->root
.type
== bfd_link_hash_defined
? N_DATA
: N_WEAKD
;
3054 else if (sec
== obj_bsssec (output_bfd
))
3055 type
= h
->root
.type
== bfd_link_hash_defined
? N_BSS
: N_WEAKB
;
3057 type
= h
->root
.type
== bfd_link_hash_defined
? N_ABS
: N_WEAKA
;
3059 val
= (h
->root
.u
.def
.value
3061 + h
->root
.u
.def
.section
->output_offset
);
3064 case bfd_link_hash_common
:
3065 type
= N_UNDF
| N_EXT
;
3066 val
= h
->root
.u
.c
.size
;
3068 case bfd_link_hash_undefweak
:
3072 case bfd_link_hash_indirect
:
3073 case bfd_link_hash_warning
:
3074 /* FIXME: Ignore these for now. The circumstances under which
3075 they should be written out are not clear to me. */
3079 H_PUT_8 (output_bfd
, type
, outsym
.e_type
);
3080 indx
= add_to_stringtab (output_bfd
, flaginfo
->strtab
, h
->root
.root
.string
,
3082 if (indx
== (bfd_size_type
) -1)
3083 /* FIXME: No way to handle errors. */
3086 PUT_WORD (output_bfd
, indx
, outsym
.e_strx
);
3087 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
3089 amt
= EXTERNAL_NLIST_SIZE
;
3090 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0
3091 || bfd_bwrite ((void *) &outsym
, amt
, output_bfd
) != amt
)
3092 /* FIXME: No way to handle errors. */
3095 flaginfo
->symoff
+= amt
;
3096 h
->indx
= obj_aout_external_sym_count (output_bfd
);
3097 ++obj_aout_external_sym_count (output_bfd
);
3102 /* Handle a link order which is supposed to generate a reloc. */
3105 aout_link_reloc_link_order (struct aout_final_link_info
*flaginfo
,
3107 struct bfd_link_order
*p
)
3109 struct bfd_link_order_reloc
*pr
;
3112 reloc_howto_type
*howto
;
3113 file_ptr
*reloff_ptr
;
3114 struct reloc_std_external srel
;
3116 bfd_size_type rel_size
;
3120 if (p
->type
== bfd_section_reloc_link_order
)
3123 if (bfd_is_abs_section (pr
->u
.section
))
3124 r_index
= N_ABS
| N_EXT
;
3127 BFD_ASSERT (pr
->u
.section
->owner
== flaginfo
->output_bfd
);
3128 r_index
= pr
->u
.section
->target_index
;
3133 struct aout_link_hash_entry
*h
;
3135 BFD_ASSERT (p
->type
== bfd_symbol_reloc_link_order
);
3137 h
= ((struct aout_link_hash_entry
*)
3138 bfd_wrapped_link_hash_lookup (flaginfo
->output_bfd
, flaginfo
->info
,
3139 pr
->u
.name
, FALSE
, FALSE
, TRUE
));
3145 /* We decided to strip this symbol, but it turns out that we
3146 can't. Note that we lose the other and desc information
3147 here. I don't think that will ever matter for a global
3151 if (!aout_link_write_other_symbol (&h
->root
.root
, flaginfo
))
3157 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3158 (flaginfo
->info
, pr
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
3163 howto
= bfd_reloc_type_lookup (flaginfo
->output_bfd
, pr
->reloc
);
3166 bfd_set_error (bfd_error_bad_value
);
3170 if (o
== obj_textsec (flaginfo
->output_bfd
))
3171 reloff_ptr
= &flaginfo
->treloff
;
3172 else if (o
== obj_datasec (flaginfo
->output_bfd
))
3173 reloff_ptr
= &flaginfo
->dreloff
;
3178 MY_put_reloc(flaginfo
->output_bfd
, r_extern
, r_index
, p
->offset
, howto
,
3188 fprintf (stderr
, "TODO: line %d in bfd/pdp11.c\n", __LINE__
);
3190 r_pcrel
= howto
->pc_relative
;
3191 r_baserel
= (howto
->type
& 8) != 0;
3192 r_jmptable
= (howto
->type
& 16) != 0;
3193 r_relative
= (howto
->type
& 32) != 0;
3194 r_length
= howto
->size
;
3196 PUT_WORD (flaginfo
->output_bfd
, p
->offset
, srel
.r_address
);
3197 if (bfd_header_big_endian (flaginfo
->output_bfd
))
3199 srel
.r_index
[0] = r_index
>> 16;
3200 srel
.r_index
[1] = r_index
>> 8;
3201 srel
.r_index
[2] = r_index
;
3203 ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
3204 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
3205 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
3206 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
3207 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
3208 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
3212 srel
.r_index
[2] = r_index
>> 16;
3213 srel
.r_index
[1] = r_index
>> 8;
3214 srel
.r_index
[0] = r_index
;
3216 ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
3217 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
3218 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
3219 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
3220 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
3221 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
3225 rel_ptr
= (void *) &srel
;
3227 /* We have to write the addend into the object file, since
3228 standard a.out relocs are in place. It would be more
3229 reliable if we had the current contents of the file here,
3230 rather than assuming zeroes, but we can't read the file since
3231 it was opened using bfd_openw. */
3232 if (pr
->addend
!= 0)
3235 bfd_reloc_status_type r
;
3239 size
= bfd_get_reloc_size (howto
);
3240 buf
= bfd_zmalloc (size
);
3241 if (buf
== NULL
&& size
!= 0)
3243 r
= MY_relocate_contents (howto
, flaginfo
->output_bfd
,
3250 case bfd_reloc_outofrange
:
3252 case bfd_reloc_overflow
:
3253 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3254 (flaginfo
->info
, NULL
,
3255 (p
->type
== bfd_section_reloc_link_order
3256 ? bfd_section_name (pr
->u
.section
)
3258 howto
->name
, pr
->addend
, NULL
,
3259 (asection
*) NULL
, (bfd_vma
) 0);
3262 ok
= bfd_set_section_contents (flaginfo
->output_bfd
, o
,
3264 (file_ptr
) p
->offset
,
3271 rel_size
= obj_reloc_entry_size (flaginfo
->output_bfd
);
3272 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0
3273 || bfd_bwrite (rel_ptr
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3276 *reloff_ptr
+= rel_size
;
3278 /* Assert that the relocs have not run into the symbols, and that n
3279 the text relocs have not run into the data relocs. */
3280 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3281 && (reloff_ptr
!= &flaginfo
->treloff
3283 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3288 /* Get the section corresponding to a reloc index. */
3290 static inline asection
*
3291 aout_reloc_type_to_section (bfd
*abfd
, int type
)
3295 case RTEXT
: return obj_textsec (abfd
);
3296 case RDATA
: return obj_datasec (abfd
);
3297 case RBSS
: return obj_bsssec (abfd
);
3298 case RABS
: return bfd_abs_section_ptr
;
3299 case REXT
: return bfd_und_section_ptr
;
3305 pdp11_aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3307 asection
*input_section
,
3309 bfd_size_type rel_size
,
3312 bfd_boolean (*check_dynamic_reloc
)
3313 (struct bfd_link_info
*, bfd
*, asection
*,
3314 struct aout_link_hash_entry
*, void *, bfd_byte
*, bfd_boolean
*,
3317 bfd_boolean relocatable
;
3318 struct external_nlist
*syms
;
3320 struct aout_link_hash_entry
**sym_hashes
;
3325 output_bfd
= flaginfo
->output_bfd
;
3326 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
3328 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_SIZE
);
3329 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
3330 == output_bfd
->xvec
->header_byteorder
);
3332 relocatable
= bfd_link_relocatable (flaginfo
->info
);
3333 syms
= obj_aout_external_syms (input_bfd
);
3334 strings
= obj_aout_external_strings (input_bfd
);
3335 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
3336 symbol_map
= flaginfo
->symbol_map
;
3339 rel_end
= rel
+ rel_size
;
3340 for (; rel
< rel_end
; rel
+= RELOC_SIZE
)
3347 reloc_howto_type
*howto
;
3348 struct aout_link_hash_entry
*h
= NULL
;
3350 bfd_reloc_status_type r
;
3353 reloc_entry
= GET_WORD (input_bfd
, (void *) rel
);
3354 if (reloc_entry
== 0)
3358 unsigned int howto_idx
;
3360 r_index
= (reloc_entry
& RIDXMASK
) >> 4;
3361 r_type
= reloc_entry
& RTYPE
;
3362 r_pcrel
= reloc_entry
& RELFLG
;
3363 r_addr
= (char *) rel
- (char *) relocs
;
3365 r_extern
= (r_type
== REXT
);
3367 howto_idx
= r_pcrel
;
3368 if (howto_idx
< TABLE_SIZE (howto_table_pdp11
))
3369 howto
= howto_table_pdp11
+ howto_idx
;
3372 _bfd_error_handler (_("%pB: unsupported relocation type"),
3374 bfd_set_error (bfd_error_bad_value
);
3381 /* We are generating a relocatable output file, and must
3382 modify the reloc accordingly. */
3385 /* If we know the symbol this relocation is against,
3386 convert it into a relocation against a section. This
3387 is what the native linker does. */
3388 h
= sym_hashes
[r_index
];
3390 && (h
->root
.type
== bfd_link_hash_defined
3391 || h
->root
.type
== bfd_link_hash_defweak
))
3393 asection
*output_section
;
3395 /* Compute a new r_index. */
3396 output_section
= h
->root
.u
.def
.section
->output_section
;
3397 if (output_section
== obj_textsec (output_bfd
))
3399 else if (output_section
== obj_datasec (output_bfd
))
3401 else if (output_section
== obj_bsssec (output_bfd
))
3406 /* Add the symbol value and the section VMA to the
3407 addend stored in the contents. */
3408 relocation
= (h
->root
.u
.def
.value
3409 + output_section
->vma
3410 + h
->root
.u
.def
.section
->output_offset
);
3414 /* We must change r_index according to the symbol
3416 r_index
= symbol_map
[r_index
];
3422 /* We decided to strip this symbol, but it
3423 turns out that we can't. Note that we
3424 lose the other and desc information here.
3425 I don't think that will ever matter for a
3431 if (!aout_link_write_other_symbol (&h
->root
.root
,
3441 name
= strings
+ GET_WORD (input_bfd
,
3442 syms
[r_index
].e_strx
);
3443 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3444 (flaginfo
->info
, name
, input_bfd
, input_section
,
3453 /* Write out the new r_index value. */
3454 reloc_entry
= GET_WORD (input_bfd
, rel
);
3455 reloc_entry
&= RIDXMASK
;
3456 reloc_entry
|= r_index
<< 4;
3457 PUT_WORD (input_bfd
, reloc_entry
, rel
);
3463 /* This is a relocation against a section. We must
3464 adjust by the amount that the section moved. */
3465 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3466 relocation
= (section
->output_section
->vma
3467 + section
->output_offset
3471 /* Change the address of the relocation. */
3472 fprintf (stderr
, "TODO: change the address of the relocation\n");
3474 /* Adjust a PC relative relocation by removing the reference
3475 to the original address in the section and including the
3476 reference to the new address. */
3478 relocation
-= (input_section
->output_section
->vma
3479 + input_section
->output_offset
3480 - input_section
->vma
);
3482 #ifdef MY_relocatable_reloc
3483 MY_relocatable_reloc (howto
, output_bfd
, rel
, relocation
, r_addr
);
3486 if (relocation
== 0)
3489 r
= MY_relocate_contents (howto
,
3490 input_bfd
, relocation
,
3497 /* We are generating an executable, and must do a full
3502 h
= sym_hashes
[r_index
];
3505 && (h
->root
.type
== bfd_link_hash_defined
3506 || h
->root
.type
== bfd_link_hash_defweak
))
3508 relocation
= (h
->root
.u
.def
.value
3509 + h
->root
.u
.def
.section
->output_section
->vma
3510 + h
->root
.u
.def
.section
->output_offset
);
3513 && h
->root
.type
== bfd_link_hash_undefweak
)
3525 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3526 relocation
= (section
->output_section
->vma
3527 + section
->output_offset
3530 relocation
+= input_section
->vma
;
3533 if (check_dynamic_reloc
!= NULL
)
3537 if (! ((*check_dynamic_reloc
)
3538 (flaginfo
->info
, input_bfd
, input_section
, h
,
3539 (void *) rel
, contents
, &skip
, &relocation
)))
3545 /* Now warn if a global symbol is undefined. We could not
3546 do this earlier, because check_dynamic_reloc might want
3547 to skip this reloc. */
3548 if (hundef
&& ! bfd_link_pic (flaginfo
->info
))
3553 name
= h
->root
.root
.string
;
3555 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
3556 (*flaginfo
->info
->callbacks
->undefined_symbol
)
3557 (flaginfo
->info
, name
, input_bfd
, input_section
,
3561 r
= MY_final_link_relocate (howto
,
3562 input_bfd
, input_section
,
3563 contents
, r_addr
, relocation
,
3567 if (r
!= bfd_reloc_ok
)
3572 case bfd_reloc_outofrange
:
3574 case bfd_reloc_overflow
:
3581 name
= strings
+ GET_WORD (input_bfd
,
3582 syms
[r_index
].e_strx
);
3587 s
= aout_reloc_type_to_section (input_bfd
, r_type
);
3588 name
= bfd_section_name (s
);
3590 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3591 (flaginfo
->info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3592 (bfd_vma
) 0, input_bfd
, input_section
, r_addr
);
3602 /* Link an a.out section into the output file. */
3605 aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3607 asection
*input_section
,
3608 file_ptr
*reloff_ptr
,
3609 bfd_size_type rel_size
)
3611 bfd_size_type input_size
;
3614 /* Get the section contents. */
3615 input_size
= input_section
->size
;
3616 if (! bfd_get_section_contents (input_bfd
, input_section
,
3617 (void *) flaginfo
->contents
,
3618 (file_ptr
) 0, input_size
))
3621 /* Read in the relocs if we haven't already done it. */
3622 if (aout_section_data (input_section
) != NULL
3623 && aout_section_data (input_section
)->relocs
!= NULL
)
3624 relocs
= aout_section_data (input_section
)->relocs
;
3627 relocs
= flaginfo
->relocs
;
3630 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3631 || bfd_bread (relocs
, rel_size
, input_bfd
) != rel_size
)
3636 /* Relocate the section contents. */
3637 if (! pdp11_aout_link_input_section (flaginfo
, input_bfd
, input_section
,
3638 (bfd_byte
*) relocs
,
3639 rel_size
, flaginfo
->contents
))
3642 /* Write out the section contents. */
3643 if (! bfd_set_section_contents (flaginfo
->output_bfd
,
3644 input_section
->output_section
,
3645 (void *) flaginfo
->contents
,
3646 (file_ptr
) input_section
->output_offset
,
3650 /* If we are producing relocatable output, the relocs were
3651 modified, and we now write them out. */
3652 if (bfd_link_relocatable (flaginfo
->info
) && rel_size
> 0)
3654 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
3656 if (bfd_bwrite (relocs
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3658 *reloff_ptr
+= rel_size
;
3660 /* Assert that the relocs have not run into the symbols, and
3661 that if these are the text relocs they have not run into the
3663 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3664 && (reloff_ptr
!= &flaginfo
->treloff
3666 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3672 /* Link an a.out input BFD into the output file. */
3675 aout_link_input_bfd (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
3677 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
3679 /* If this is a dynamic object, it may need special handling. */
3680 if ((input_bfd
->flags
& DYNAMIC
) != 0
3681 && aout_backend_info (input_bfd
)->link_dynamic_object
!= NULL
)
3682 return ((*aout_backend_info (input_bfd
)->link_dynamic_object
)
3683 (flaginfo
->info
, input_bfd
));
3685 /* Get the symbols. We probably have them already, unless
3686 flaginfo->info->keep_memory is FALSE. */
3687 if (! aout_get_external_symbols (input_bfd
))
3690 /* Write out the symbols and get a map of the new indices. The map
3691 is placed into flaginfo->symbol_map. */
3692 if (! aout_link_write_symbols (flaginfo
, input_bfd
))
3695 /* Relocate and write out the sections. These functions use the
3696 symbol map created by aout_link_write_symbols. The linker_mark
3697 field will be set if these sections are to be included in the
3698 link, which will normally be the case. */
3699 if (obj_textsec (input_bfd
)->linker_mark
)
3701 if (! aout_link_input_section (flaginfo
, input_bfd
,
3702 obj_textsec (input_bfd
),
3704 exec_hdr (input_bfd
)->a_trsize
))
3707 if (obj_datasec (input_bfd
)->linker_mark
)
3709 if (! aout_link_input_section (flaginfo
, input_bfd
,
3710 obj_datasec (input_bfd
),
3712 exec_hdr (input_bfd
)->a_drsize
))
3716 /* If we are not keeping memory, we don't need the symbols any
3717 longer. We still need them if we are keeping memory, because the
3718 strings in the hash table point into them. */
3719 if (! flaginfo
->info
->keep_memory
)
3721 if (! aout_link_free_symbols (input_bfd
))
3728 /* Do the final link step. This is called on the output BFD. The
3729 INFO structure should point to a list of BFDs linked through the
3730 link.next field which can be used to find each BFD which takes part
3731 in the output. Also, each section in ABFD should point to a list
3732 of bfd_link_order structures which list all the input sections for
3733 the output section. */
3736 NAME (aout
, final_link
) (bfd
*abfd
,
3737 struct bfd_link_info
*info
,
3738 void (*callback
) (bfd
*, file_ptr
*, file_ptr
*, file_ptr
*))
3740 struct aout_final_link_info aout_info
;
3741 bfd_boolean includes_hash_initialized
= FALSE
;
3743 bfd_size_type trsize
, drsize
;
3744 bfd_size_type max_contents_size
;
3745 bfd_size_type max_relocs_size
;
3746 bfd_size_type max_sym_count
;
3747 struct bfd_link_order
*p
;
3749 bfd_boolean have_link_order_relocs
;
3751 if (bfd_link_pic (info
))
3752 abfd
->flags
|= DYNAMIC
;
3754 separate_i_d
= info
->separate_code
;
3755 aout_info
.info
= info
;
3756 aout_info
.output_bfd
= abfd
;
3757 aout_info
.contents
= NULL
;
3758 aout_info
.relocs
= NULL
;
3759 aout_info
.symbol_map
= NULL
;
3760 aout_info
.output_syms
= NULL
;
3762 if (!bfd_hash_table_init_n (&aout_info
.includes
.root
,
3763 aout_link_includes_newfunc
,
3764 sizeof (struct aout_link_includes_entry
),
3767 includes_hash_initialized
= TRUE
;
3769 /* Figure out the largest section size. Also, if generating
3770 relocatable output, count the relocs. */
3773 max_contents_size
= 0;
3774 max_relocs_size
= 0;
3776 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3780 if (bfd_link_relocatable (info
))
3782 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3784 trsize
+= exec_hdr (sub
)->a_trsize
;
3785 drsize
+= exec_hdr (sub
)->a_drsize
;
3789 /* FIXME: We need to identify the .text and .data sections
3790 and call get_reloc_upper_bound and canonicalize_reloc to
3791 work out the number of relocs needed, and then multiply
3792 by the reloc size. */
3794 /* xgettext:c-format */
3795 (_("%pB: relocatable link from %s to %s not supported"),
3796 abfd
, sub
->xvec
->name
, abfd
->xvec
->name
);
3797 bfd_set_error (bfd_error_invalid_operation
);
3802 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3804 sz
= obj_textsec (sub
)->size
;
3805 if (sz
> max_contents_size
)
3806 max_contents_size
= sz
;
3807 sz
= obj_datasec (sub
)->size
;
3808 if (sz
> max_contents_size
)
3809 max_contents_size
= sz
;
3811 sz
= exec_hdr (sub
)->a_trsize
;
3812 if (sz
> max_relocs_size
)
3813 max_relocs_size
= sz
;
3814 sz
= exec_hdr (sub
)->a_drsize
;
3815 if (sz
> max_relocs_size
)
3816 max_relocs_size
= sz
;
3818 sz
= obj_aout_external_sym_count (sub
);
3819 if (sz
> max_sym_count
)
3824 if (bfd_link_relocatable (info
))
3826 if (obj_textsec (abfd
) != NULL
)
3827 trsize
+= (_bfd_count_link_order_relocs (obj_textsec (abfd
)
3828 ->map_head
.link_order
)
3829 * obj_reloc_entry_size (abfd
));
3830 if (obj_datasec (abfd
) != NULL
)
3831 drsize
+= (_bfd_count_link_order_relocs (obj_datasec (abfd
)
3832 ->map_head
.link_order
)
3833 * obj_reloc_entry_size (abfd
));
3836 exec_hdr (abfd
)->a_trsize
= trsize
;
3837 exec_hdr (abfd
)->a_drsize
= drsize
;
3838 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
3840 /* Adjust the section sizes and vmas according to the magic number.
3841 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3842 filepos for each section. */
3843 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
3846 /* The relocation and symbol file positions differ among a.out
3847 targets. We are passed a callback routine from the backend
3848 specific code to handle this.
3849 FIXME: At this point we do not know how much space the symbol
3850 table will require. This will not work for any (nonstandard)
3851 a.out target that needs to know the symbol table size before it
3852 can compute the relocation file positions. */
3853 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
3855 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
3856 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
3857 obj_sym_filepos (abfd
) = aout_info
.symoff
;
3859 /* We keep a count of the symbols as we output them. */
3860 obj_aout_external_sym_count (abfd
) = 0;
3862 /* We accumulate the string table as we write out the symbols. */
3863 aout_info
.strtab
= _bfd_stringtab_init ();
3864 if (aout_info
.strtab
== NULL
)
3867 /* Allocate buffers to hold section contents and relocs. */
3868 aout_info
.contents
= bfd_malloc (max_contents_size
);
3869 aout_info
.relocs
= bfd_malloc (max_relocs_size
);
3870 aout_info
.symbol_map
= bfd_malloc (max_sym_count
* sizeof (int *));
3871 aout_info
.output_syms
= bfd_malloc ((max_sym_count
+ 1)
3872 * sizeof (struct external_nlist
));
3873 if ((aout_info
.contents
== NULL
&& max_contents_size
!= 0)
3874 || (aout_info
.relocs
== NULL
&& max_relocs_size
!= 0)
3875 || (aout_info
.symbol_map
== NULL
&& max_sym_count
!= 0)
3876 || aout_info
.output_syms
== NULL
)
3879 /* If we have a symbol named __DYNAMIC, force it out now. This is
3880 required by SunOS. Doing this here rather than in sunos.c is a
3881 hack, but it's easier than exporting everything which would be
3884 struct aout_link_hash_entry
*h
;
3886 h
= aout_link_hash_lookup (aout_hash_table (info
), "__DYNAMIC",
3887 FALSE
, FALSE
, FALSE
);
3889 aout_link_write_other_symbol (&h
->root
.root
, &aout_info
);
3892 /* The most time efficient way to do the link would be to read all
3893 the input object files into memory and then sort out the
3894 information into the output file. Unfortunately, that will
3895 probably use too much memory. Another method would be to step
3896 through everything that composes the text section and write it
3897 out, and then everything that composes the data section and write
3898 it out, and then write out the relocs, and then write out the
3899 symbols. Unfortunately, that requires reading stuff from each
3900 input file several times, and we will not be able to keep all the
3901 input files open simultaneously, and reopening them will be slow.
3903 What we do is basically process one input file at a time. We do
3904 everything we need to do with an input file once--copy over the
3905 section contents, handle the relocation information, and write
3906 out the symbols--and then we throw away the information we read
3907 from it. This approach requires a lot of lseeks of the output
3908 file, which is unfortunate but still faster than reopening a lot
3911 We use the output_has_begun field of the input BFDs to see
3912 whether we have already handled it. */
3913 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3914 sub
->output_has_begun
= FALSE
;
3916 /* Mark all sections which are to be included in the link. This
3917 will normally be every section. We need to do this so that we
3918 can identify any sections which the linker has decided to not
3920 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3922 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
3923 if (p
->type
== bfd_indirect_link_order
)
3924 p
->u
.indirect
.section
->linker_mark
= TRUE
;
3927 have_link_order_relocs
= FALSE
;
3928 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3930 for (p
= o
->map_head
.link_order
;
3934 if (p
->type
== bfd_indirect_link_order
3935 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
3936 == bfd_target_aout_flavour
))
3940 input_bfd
= p
->u
.indirect
.section
->owner
;
3941 if (! input_bfd
->output_has_begun
)
3943 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
3945 input_bfd
->output_has_begun
= TRUE
;
3948 else if (p
->type
== bfd_section_reloc_link_order
3949 || p
->type
== bfd_symbol_reloc_link_order
)
3950 /* These are handled below. */
3951 have_link_order_relocs
= TRUE
;
3954 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3960 /* Write out any symbols that we have not already written out. */
3961 bfd_hash_traverse (&info
->hash
->table
,
3962 aout_link_write_other_symbol
,
3965 /* Now handle any relocs we were asked to create by the linker.
3966 These did not come from any input file. We must do these after
3967 we have written out all the symbols, so that we know the symbol
3969 if (have_link_order_relocs
)
3971 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3973 for (p
= o
->map_head
.link_order
;
3977 if (p
->type
== bfd_section_reloc_link_order
3978 || p
->type
== bfd_symbol_reloc_link_order
)
3980 if (! aout_link_reloc_link_order (&aout_info
, o
, p
))
3987 free (aout_info
.contents
);
3988 aout_info
.contents
= NULL
;
3989 free (aout_info
.relocs
);
3990 aout_info
.relocs
= NULL
;
3991 free (aout_info
.symbol_map
);
3992 aout_info
.symbol_map
= NULL
;
3993 free (aout_info
.output_syms
);
3994 aout_info
.output_syms
= NULL
;
3995 if (includes_hash_initialized
)
3997 bfd_hash_table_free (&aout_info
.includes
.root
);
3998 includes_hash_initialized
= FALSE
;
4001 /* Finish up any dynamic linking we may be doing. */
4002 if (aout_backend_info (abfd
)->finish_dynamic_link
!= NULL
)
4004 if (! (*aout_backend_info (abfd
)->finish_dynamic_link
) (abfd
, info
))
4008 /* Update the header information. */
4009 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
4010 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
4011 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
4012 obj_textsec (abfd
)->reloc_count
=
4013 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
4014 obj_datasec (abfd
)->reloc_count
=
4015 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
4017 /* Write out the string table, unless there are no symbols. */
4018 if (abfd
->symcount
> 0)
4020 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
4021 || ! emit_stringtab (abfd
, aout_info
.strtab
))
4024 else if (obj_textsec (abfd
)->reloc_count
== 0
4025 && obj_datasec (abfd
)->reloc_count
== 0)
4027 /* The layout of a typical a.out file is header, text, data,
4028 relocs, symbols, string table. When there are no relocs,
4029 symbols or string table, the last thing in the file is data
4030 and a_data may be rounded up. However we may have a smaller
4031 sized .data section and thus not written final padding. The
4032 same thing can happen with text if there is no data. Write
4033 final padding here to extend the file. */
4036 if (exec_hdr (abfd
)->a_data
> obj_datasec (abfd
)->size
)
4037 pos
= obj_datasec (abfd
)->filepos
+ exec_hdr (abfd
)->a_data
;
4038 else if (obj_datasec (abfd
)->size
== 0
4039 && exec_hdr (abfd
)->a_text
> obj_textsec (abfd
)->size
)
4040 pos
= obj_textsec (abfd
)->filepos
+ exec_hdr (abfd
)->a_text
;
4045 if (bfd_seek (abfd
, pos
- 1, SEEK_SET
) != 0
4046 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4054 free (aout_info
.contents
);
4055 free (aout_info
.relocs
);
4056 free (aout_info
.symbol_map
);
4057 free (aout_info
.output_syms
);
4058 if (includes_hash_initialized
)
4059 bfd_hash_table_free (&aout_info
.includes
.root
);
4063 /* Adjust and write out the symbols for an a.out file. Set the new
4064 symbol indices into a symbol_map. */
4067 aout_link_write_symbols (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
4070 bfd_size_type sym_count
;
4072 enum bfd_link_strip strip
;
4073 enum bfd_link_discard discard
;
4074 struct external_nlist
*outsym
;
4075 bfd_size_type strtab_index
;
4076 struct external_nlist
*sym
;
4077 struct external_nlist
*sym_end
;
4078 struct aout_link_hash_entry
**sym_hash
;
4081 bfd_boolean skip_next
;
4083 output_bfd
= flaginfo
->output_bfd
;
4084 sym_count
= obj_aout_external_sym_count (input_bfd
);
4085 strings
= obj_aout_external_strings (input_bfd
);
4086 strip
= flaginfo
->info
->strip
;
4087 discard
= flaginfo
->info
->discard
;
4088 outsym
= flaginfo
->output_syms
;
4090 /* First write out a symbol for this object file, unless we are
4091 discarding such symbols. */
4092 if (strip
!= strip_all
4093 && (strip
!= strip_some
4094 || bfd_hash_lookup (flaginfo
->info
->keep_hash
,
4095 bfd_get_filename (input_bfd
),
4096 FALSE
, FALSE
) != NULL
)
4097 && discard
!= discard_all
)
4099 H_PUT_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
4100 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4101 bfd_get_filename (input_bfd
), FALSE
);
4102 if (strtab_index
== (bfd_size_type
) -1)
4104 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4105 PUT_WORD (output_bfd
,
4106 (bfd_section_vma (obj_textsec (input_bfd
)->output_section
)
4107 + obj_textsec (input_bfd
)->output_offset
),
4109 ++obj_aout_external_sym_count (output_bfd
);
4115 sym
= obj_aout_external_syms (input_bfd
);
4116 sym_end
= sym
+ sym_count
;
4117 sym_hash
= obj_aout_sym_hashes (input_bfd
);
4118 symbol_map
= flaginfo
->symbol_map
;
4119 memset (symbol_map
, 0, (size_t) sym_count
* sizeof *symbol_map
);
4120 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
4124 struct aout_link_hash_entry
*h
;
4130 /* We set *symbol_map to 0 above for all symbols. If it has
4131 already been set to -1 for this symbol, it means that we are
4132 discarding it because it appears in a duplicate header file.
4133 See the N_BINCL code below. */
4134 if (*symbol_map
== -1)
4137 /* Initialize *symbol_map to -1, which means that the symbol was
4138 not copied into the output file. We will change it later if
4139 we do copy the symbol over. */
4142 type
= H_GET_8 (input_bfd
, sym
->e_type
);
4143 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
4149 /* Pass this symbol through. It is the target of an
4150 indirect or warning symbol. */
4151 val
= GET_WORD (input_bfd
, sym
->e_value
);
4156 /* Skip this symbol, which is the target of an indirect
4157 symbol that we have changed to no longer be an indirect
4164 struct aout_link_hash_entry
*hresolve
;
4166 /* We have saved the hash table entry for this symbol, if
4167 there is one. Note that we could just look it up again
4168 in the hash table, provided we first check that it is an
4172 /* Use the name from the hash table, in case the symbol was
4175 name
= h
->root
.root
.string
;
4177 /* If this is an indirect or warning symbol, then change
4178 hresolve to the base symbol. We also change *sym_hash so
4179 that the relocation routines relocate against the real
4183 && (h
->root
.type
== bfd_link_hash_indirect
4184 || h
->root
.type
== bfd_link_hash_warning
))
4186 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
4187 while (hresolve
->root
.type
== bfd_link_hash_indirect
4188 || hresolve
->root
.type
== bfd_link_hash_warning
)
4189 hresolve
= ((struct aout_link_hash_entry
*)
4190 hresolve
->root
.u
.i
.link
);
4191 *sym_hash
= hresolve
;
4194 /* If the symbol has already been written out, skip it. */
4196 && h
->root
.type
!= bfd_link_hash_warning
4199 if ((type
& N_TYPE
) == N_INDR
4200 || type
== N_WARNING
)
4202 *symbol_map
= h
->indx
;
4206 /* See if we are stripping this symbol. */
4212 case strip_debugger
:
4213 if ((type
& N_STAB
) != 0)
4217 if (bfd_hash_lookup (flaginfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
4232 /* Get the value of the symbol. */
4233 if ((type
& N_TYPE
) == N_TEXT
4235 symsec
= obj_textsec (input_bfd
);
4236 else if ((type
& N_TYPE
) == N_DATA
4238 symsec
= obj_datasec (input_bfd
);
4239 else if ((type
& N_TYPE
) == N_BSS
4241 symsec
= obj_bsssec (input_bfd
);
4242 else if ((type
& N_TYPE
) == N_ABS
4244 symsec
= bfd_abs_section_ptr
;
4245 else if (((type
& N_TYPE
) == N_INDR
4246 && (hresolve
== NULL
4247 || (hresolve
->root
.type
!= bfd_link_hash_defined
4248 && hresolve
->root
.type
!= bfd_link_hash_defweak
4249 && hresolve
->root
.type
!= bfd_link_hash_common
)))
4250 || type
== N_WARNING
)
4252 /* Pass the next symbol through unchanged. The
4253 condition above for indirect symbols is so that if
4254 the indirect symbol was defined, we output it with
4255 the correct definition so the debugger will
4258 val
= GET_WORD (input_bfd
, sym
->e_value
);
4261 else if ((type
& N_STAB
) != 0)
4263 val
= GET_WORD (input_bfd
, sym
->e_value
);
4268 /* If we get here with an indirect symbol, it means that
4269 we are outputting it with a real definition. In such
4270 a case we do not want to output the next symbol,
4271 which is the target of the indirection. */
4272 if ((type
& N_TYPE
) == N_INDR
)
4277 /* We need to get the value from the hash table. We use
4278 hresolve so that if we have defined an indirect
4279 symbol we output the final definition. */
4282 switch (type
& N_TYPE
)
4285 symsec
= obj_textsec (input_bfd
);
4288 symsec
= obj_datasec (input_bfd
);
4291 symsec
= obj_bsssec (input_bfd
);
4294 symsec
= bfd_abs_section_ptr
;
4301 else if (hresolve
->root
.type
== bfd_link_hash_defined
4302 || hresolve
->root
.type
== bfd_link_hash_defweak
)
4304 asection
*input_section
;
4305 asection
*output_section
;
4307 /* This case usually means a common symbol which was
4308 turned into a defined symbol. */
4309 input_section
= hresolve
->root
.u
.def
.section
;
4310 output_section
= input_section
->output_section
;
4311 BFD_ASSERT (bfd_is_abs_section (output_section
)
4312 || output_section
->owner
== output_bfd
);
4313 val
= (hresolve
->root
.u
.def
.value
4314 + bfd_section_vma (output_section
)
4315 + input_section
->output_offset
);
4317 /* Get the correct type based on the section. If
4318 this is a constructed set, force it to be
4319 globally visible. */
4328 if (output_section
== obj_textsec (output_bfd
))
4329 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4332 else if (output_section
== obj_datasec (output_bfd
))
4333 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4336 else if (output_section
== obj_bsssec (output_bfd
))
4337 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4341 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4345 else if (hresolve
->root
.type
== bfd_link_hash_common
)
4346 val
= hresolve
->root
.u
.c
.size
;
4347 else if (hresolve
->root
.type
== bfd_link_hash_undefweak
)
4356 val
= (symsec
->output_section
->vma
4357 + symsec
->output_offset
4358 + (GET_WORD (input_bfd
, sym
->e_value
)
4361 /* If this is a global symbol set the written flag, and if
4362 it is a local symbol see if we should discard it. */
4366 h
->indx
= obj_aout_external_sym_count (output_bfd
);
4368 else if ((type
& N_TYPE
) != N_SETT
4369 && (type
& N_TYPE
) != N_SETD
4370 && (type
& N_TYPE
) != N_SETB
4371 && (type
& N_TYPE
) != N_SETA
)
4376 case discard_sec_merge
:
4379 if ((type
& N_STAB
) == 0
4380 && bfd_is_local_label_name (input_bfd
, name
))
4394 /* An N_BINCL symbol indicates the start of the stabs
4395 entries for a header file. We need to scan ahead to the
4396 next N_EINCL symbol, ignoring nesting, adding up all the
4397 characters in the symbol names, not including the file
4398 numbers in types (the first number after an open
4400 if (type
== N_BINCL
)
4402 struct external_nlist
*incl_sym
;
4404 struct aout_link_includes_entry
*incl_entry
;
4405 struct aout_link_includes_totals
*t
;
4409 for (incl_sym
= sym
+ 1; incl_sym
< sym_end
; incl_sym
++)
4413 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4414 if (incl_type
== N_EINCL
)
4420 else if (incl_type
== N_BINCL
)
4426 s
= strings
+ GET_WORD (input_bfd
, incl_sym
->e_strx
);
4427 for (; *s
!= '\0'; s
++)
4432 /* Skip the file number. */
4434 while (ISDIGIT (*s
))
4442 /* If we have already included a header file with the
4443 same value, then replace this one with an N_EXCL
4445 copy
= ! flaginfo
->info
->keep_memory
;
4446 incl_entry
= aout_link_includes_lookup (&flaginfo
->includes
,
4448 if (incl_entry
== NULL
)
4450 for (t
= incl_entry
->totals
; t
!= NULL
; t
= t
->next
)
4451 if (t
->total
== val
)
4455 /* This is the first time we have seen this header
4456 file with this set of stabs strings. */
4457 t
= bfd_hash_allocate (&flaginfo
->includes
.root
,
4462 t
->next
= incl_entry
->totals
;
4463 incl_entry
->totals
= t
;
4469 /* This is a duplicate header file. We must change
4470 it to be an N_EXCL entry, and mark all the
4471 included symbols to prevent outputting them. */
4475 for (incl_sym
= sym
+ 1, incl_map
= symbol_map
+ 1;
4477 incl_sym
++, incl_map
++)
4481 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4482 if (incl_type
== N_EINCL
)
4491 else if (incl_type
== N_BINCL
)
4500 /* Copy this symbol into the list of symbols we are going to
4502 H_PUT_8 (output_bfd
, type
, outsym
->e_type
);
4504 if (! flaginfo
->info
->keep_memory
)
4506 /* name points into a string table which we are going to
4507 free. If there is a hash table entry, use that string.
4508 Otherwise, copy name into memory. */
4510 name
= h
->root
.root
.string
;
4514 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4516 if (strtab_index
== (bfd_size_type
) -1)
4518 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4519 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
4520 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
4521 ++obj_aout_external_sym_count (output_bfd
);
4525 /* Write out the output symbols we have just constructed. */
4526 if (outsym
> flaginfo
->output_syms
)
4530 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0)
4532 size
= outsym
- flaginfo
->output_syms
;
4533 size
*= EXTERNAL_NLIST_SIZE
;
4534 if (bfd_bwrite ((void *) flaginfo
->output_syms
, size
, output_bfd
) != size
)
4536 flaginfo
->symoff
+= size
;
4542 /* Write out a symbol that was not associated with an a.out input
4546 bfd_getp32 (const void *p
)
4548 const bfd_byte
*addr
= p
;
4551 v
= (unsigned long) addr
[1] << 24;
4552 v
|= (unsigned long) addr
[0] << 16;
4553 v
|= (unsigned long) addr
[3] << 8;
4554 v
|= (unsigned long) addr
[2];
4558 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
4560 static bfd_signed_vma
4561 bfd_getp_signed_32 (const void *p
)
4563 const bfd_byte
*addr
= p
;
4566 v
= (unsigned long) addr
[1] << 24;
4567 v
|= (unsigned long) addr
[0] << 16;
4568 v
|= (unsigned long) addr
[3] << 8;
4569 v
|= (unsigned long) addr
[2];
4570 return COERCE32 (v
);
4574 bfd_putp32 (bfd_vma data
, void *p
)
4578 addr
[0] = (data
>> 16) & 0xff;
4579 addr
[1] = (data
>> 24) & 0xff;
4580 addr
[2] = (data
>> 0) & 0xff;
4581 addr
[3] = (data
>> 8) & 0xff;
4584 const bfd_target
MY (vec
) =
4586 TARGETNAME
, /* Name. */
4587 bfd_target_aout_flavour
,
4588 BFD_ENDIAN_LITTLE
, /* Target byte order (little). */
4589 BFD_ENDIAN_LITTLE
, /* Target headers byte order (little). */
4590 (HAS_RELOC
| EXEC_P
| /* Object flags. */
4591 HAS_LINENO
| HAS_DEBUG
|
4592 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
),
4593 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_CODE
| SEC_DATA
),
4594 MY_symbol_leading_char
,
4595 AR_PAD_CHAR
, /* AR_pad_char. */
4596 15, /* AR_max_namelen. */
4597 0, /* match priority. */
4598 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4599 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4600 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Data. */
4601 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4602 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4603 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Headers. */
4604 { /* bfd_check_format. */
4607 bfd_generic_archive_p
,
4610 { /* bfd_set_format. */
4611 _bfd_bool_bfd_false_error
,
4613 _bfd_generic_mkarchive
,
4614 _bfd_bool_bfd_false_error
4616 { /* bfd_write_contents. */
4617 _bfd_bool_bfd_false_error
,
4618 MY_write_object_contents
,
4619 _bfd_write_archive_contents
,
4620 _bfd_bool_bfd_false_error
4623 BFD_JUMP_TABLE_GENERIC (MY
),
4624 BFD_JUMP_TABLE_COPY (MY
),
4625 BFD_JUMP_TABLE_CORE (MY
),
4626 BFD_JUMP_TABLE_ARCHIVE (MY
),
4627 BFD_JUMP_TABLE_SYMBOLS (MY
),
4628 BFD_JUMP_TABLE_RELOCS (MY
),
4629 BFD_JUMP_TABLE_WRITE (MY
),
4630 BFD_JUMP_TABLE_LINK (MY
),
4631 BFD_JUMP_TABLE_DYNAMIC (MY
),
4633 /* Alternative_target. */
4636 (void *) MY_backend_data