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. The symbol table format
26 of 2.11BSD has been extended to accommodate .stab symbols. See
27 struct pdp11_external_nlist below for details.
30 * support for V7 file formats
31 * support for overlay object files (see 2.11 a.out(5))
32 * support for old and very old archives
33 (see 2.11 ar(5), historical section)
35 Search for TODO to find other areas needing more work. */
37 #define BYTES_IN_WORD 2
38 #define BYTES_IN_LONG 4
40 #undef TARGET_IS_BIG_ENDIAN_P
42 #define TARGET_PAGE_SIZE 8192
43 #define SEGMENT__SIZE TARGET_PAGE_SIZE
45 #define DEFAULT_ARCH bfd_arch_pdp11
46 #define DEFAULT_MID M_PDP11
48 /* Do not "beautify" the CONCAT* macro args. Traditional C will not
49 remove whitespace added here, and thus will fail to concatenate
51 #define MY(OP) CONCAT2 (pdp11_aout_,OP)
53 /* This needs to start with a.out so GDB knows it is an a.out variant. */
54 #define TARGETNAME "a.out-pdp11"
56 /* This is the normal load address for executables. */
57 #define TEXT_START_ADDR 0
59 /* The header is not included in the text segment. */
60 #define N_HEADER_IN_TEXT(x) 0
62 /* There is no flags field. */
63 #define N_FLAGS(execp) 0
65 #define N_SET_FLAGS(execp, flags) do { } while (0)
66 #define N_BADMAG(x) (N_MAGIC(x) != OMAGIC \
67 && N_MAGIC(x) != NMAGIC \
68 && N_MAGIC(x) != IMAGIC \
69 && N_MAGIC(x) != ZMAGIC)
75 #define external_exec pdp11_external_exec
76 struct pdp11_external_exec
78 bfd_byte e_info
[2]; /* Magic number. */
79 bfd_byte e_text
[2]; /* Length of text section in bytes. */
80 bfd_byte e_data
[2]; /* Length of data section in bytes. */
81 bfd_byte e_bss
[2]; /* Length of bss area in bytes. */
82 bfd_byte e_syms
[2]; /* Length of symbol table in bytes. */
83 bfd_byte e_entry
[2]; /* Start address. */
84 bfd_byte e_unused
[2]; /* Not used. */
85 bfd_byte e_flag
[2]; /* Relocation info stripped. */
86 bfd_byte e_relocatable
; /* Ugly hack. */
89 #define EXEC_BYTES_SIZE (8 * 2)
91 #define A_MAGIC1 OMAGIC
92 #define OMAGIC 0407 /* ...object file or impure executable. */
93 #define A_MAGIC2 NMAGIC
94 #define NMAGIC 0410 /* Pure executable. */
95 #define ZMAGIC 0413 /* Demand-paged executable. */
96 #define IMAGIC 0411 /* Separated I&D. */
97 #define A_MAGIC3 IMAGIC
98 #define A_MAGIC4 0405 /* Overlay. */
99 #define A_MAGIC5 0430 /* Auto-overlay (nonseparate). */
100 #define A_MAGIC6 0431 /* Auto-overlay (separate). */
104 #define A_FLAG_RELOC_STRIPPED 0x0001
106 /* The following struct defines the format of an entry in the object file
107 symbol table. In the original 2.11BSD struct the index into the string
108 table is stored as a long, but the PDP11 C convention for storing a long in
109 memory placed the most significant word first even though the bytes within a
110 word are stored least significant first. So here the string table index is
111 considered to be just 16 bits and the first two bytes of the struct were
112 previously named e_unused. To extend the symbol table format to accommodate
113 .stab symbols, the e_unused bytes are renamed e_desc to store the desc field
114 of the .stab symbol. The GDP Project's STABS document says that the "other"
115 field is almost always unused and can be set to zero; the only nonzero cases
116 identified were for stabs in their own sections, which does not apply for
117 pdp11 a.out format, and for a special case of GNU Modula2 which is not
118 supported for the PDP11. */
119 #define external_nlist pdp11_external_nlist
120 struct pdp11_external_nlist
122 bfd_byte e_desc
[2]; /* The desc field for .stab symbols, else 0. */
123 bfd_byte e_strx
[2]; /* Index into string table of name. */
124 bfd_byte e_type
[1]; /* Type of symbol. */
125 bfd_byte e_ovly
[1]; /* Overlay number. */
126 bfd_byte e_value
[2]; /* Value of symbol. */
129 #define EXTERNAL_NLIST_SIZE 8
131 #define N_TXTOFF(x) (EXEC_BYTES_SIZE)
132 #define N_DATOFF(x) (N_TXTOFF(x) + (x)->a_text)
133 #define N_TRELOFF(x) (N_DATOFF(x) + (x)->a_data)
134 #define N_DRELOFF(x) (N_TRELOFF(x) + (x)->a_trsize)
135 #define N_SYMOFF(x) (N_DRELOFF(x) + (x)->a_drsize)
136 #define N_STROFF(x) (N_SYMOFF(x) + (x)->a_syms)
138 #define WRITE_HEADERS(abfd, execp) pdp11_aout_write_headers (abfd, execp)
143 #define SWAP_MAGIC(ext) bfd_getl16 (ext)
145 #define MY_entry_is_text_address 1
147 #define MY_write_object_contents MY(write_object_contents)
148 static bfd_boolean
MY(write_object_contents
) (bfd
*);
149 #define MY_text_includes_header 1
151 #define MY_BFD_TARGET
153 #include "aout-target.h"
155 /* Start of modified aoutx.h. */
156 #define KEEPIT udata.i
158 #include <string.h> /* For strchr and friends. */
161 #include "safe-ctype.h"
165 #include "aout/aout64.h"
166 #include "aout/stab_gnu.h"
169 /* The symbol type numbers for the 16-bit a.out format from 2.11BSD differ from
170 those defined in aout64.h so we must redefine them here. N_EXT changes from
171 0x01 to 0x20 which creates a conflict with some .stab values, in particular
172 between undefined externals (N_UNDF+N_EXT) vs. global variables (N_GYSM) and
173 between external bss symbols (N_BSS+N_EXT) vs. function names (N_FUN). We
174 disambiguate those conflicts with a hack in is_stab() to look for the ':' in
175 the global variable or function name string. */
186 #define N_TYPE 0x1f /* Type mask. */
187 #define N_UNDF 0x00 /* Undefined. */
188 #define N_ABS 0x01 /* Absolute. */
189 #define N_TEXT 0x02 /* Text segment. */
190 #define N_DATA 0x03 /* Data segment. */
191 #define N_BSS 0x04 /* Bss segment. */
192 #define N_REG 0x14 /* Register symbol. */
193 #define N_FN 0x1f /* File name. */
194 #define N_EXT 0x20 /* External flag. */
195 /* Type numbers from .stab entries that could conflict:
196 N_GSYM 0x20 Global variable [conflict with external undef]
197 N_FNAME 0x22 Function name (for BSD Fortran) [ignored]
198 N_FUN 0x24 Function name [conflict with external BSS]
199 N_NOMAP 0x34 No DST map for sym. [ext. reg. doesn't exist]
204 #define RELFLG 0x0001 /* PC-relative flag. */
205 #define RTYPE 0x000e /* Type mask. */
206 #define RIDXMASK 0xfff0 /* Index mask. */
208 #define RABS 0x00 /* Absolute. */
209 #define RTEXT 0x02 /* Text. */
210 #define RDATA 0x04 /* Data. */
211 #define RBSS 0x06 /* Bss. */
212 #define REXT 0x08 /* External. */
214 #define RINDEX(x) (((x) & 0xfff0) >> 4)
216 #ifndef MY_final_link_relocate
217 #define MY_final_link_relocate _bfd_final_link_relocate
220 #ifndef MY_relocate_contents
221 #define MY_relocate_contents _bfd_relocate_contents
224 /* A hash table used for header files with N_BINCL entries. */
226 struct aout_link_includes_table
228 struct bfd_hash_table root
;
231 /* A linked list of totals that we have found for a particular header
234 struct aout_link_includes_totals
236 struct aout_link_includes_totals
*next
;
240 /* An entry in the header file hash table. */
242 struct aout_link_includes_entry
244 struct bfd_hash_entry root
;
245 /* List of totals we have found for this file. */
246 struct aout_link_includes_totals
*totals
;
249 /* During the final link step we need to pass around a bunch of
250 information, so we do it in an instance of this structure. */
252 struct aout_final_link_info
254 /* General link information. */
255 struct bfd_link_info
*info
;
258 /* Reloc file positions. */
259 file_ptr treloff
, dreloff
;
260 /* File position of symbols. */
263 struct bfd_strtab_hash
*strtab
;
264 /* Header file hash table. */
265 struct aout_link_includes_table includes
;
266 /* A buffer large enough to hold the contents of any section. */
268 /* A buffer large enough to hold the relocs of any section. */
270 /* A buffer large enough to hold the symbol map of any input BFD. */
272 /* A buffer large enough to hold output symbols of any input BFD. */
273 struct external_nlist
*output_syms
;
276 /* Copy of the link_info.separate_code boolean to select the output format with
277 separate instruction and data spaces selected by --imagic */
278 static bfd_boolean separate_i_d
= FALSE
;
280 reloc_howto_type howto_table_pdp11
[] =
282 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
283 HOWTO( 0, 0, 1, 16, FALSE
, 0, complain_overflow_signed
,0,"16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
284 HOWTO( 1, 0, 1, 16, TRUE
, 0, complain_overflow_signed
,0,"DISP16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
285 HOWTO( 2, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,0,"32", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
288 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
291 static bfd_boolean
aout_link_check_archive_element (bfd
*, struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *, bfd_boolean
*);
292 static bfd_boolean
aout_link_add_object_symbols (bfd
*, struct bfd_link_info
*);
293 static bfd_boolean
aout_link_add_symbols (bfd
*, struct bfd_link_info
*);
294 static bfd_boolean
aout_link_write_symbols (struct aout_final_link_info
*, bfd
*);
298 NAME (aout
, reloc_type_lookup
) (bfd
* abfd ATTRIBUTE_UNUSED
,
299 bfd_reloc_code_real_type code
)
304 return &howto_table_pdp11
[0];
305 case BFD_RELOC_16_PCREL
:
306 return &howto_table_pdp11
[1];
308 return &howto_table_pdp11
[2];
315 NAME (aout
, reloc_name_lookup
) (bfd
*abfd ATTRIBUTE_UNUSED
,
321 i
< sizeof (howto_table_pdp11
) / sizeof (howto_table_pdp11
[0]);
323 if (howto_table_pdp11
[i
].name
!= NULL
324 && strcasecmp (howto_table_pdp11
[i
].name
, r_name
) == 0)
325 return &howto_table_pdp11
[i
];
330 /* Disambiguate conflicts between normal symbol types and .stab symbol types
331 (undefined externals N_UNDF+N_EXT vs. global variables N_GYSM and external
332 bss symbols N_BSS+N_EXT vs. function names N_FUN) with a hack to look for
333 the ':' in the global variable or function name string. */
336 is_stab (int type
, const char *name
)
338 if (type
== N_GSYM
|| type
== N_FUN
)
339 return (index(name
, ':') != NULL
);
340 return (type
> N_FUN
);
344 pdp11_aout_write_headers (bfd
*abfd
, struct internal_exec
*execp
)
346 struct external_exec exec_bytes
;
348 if (adata(abfd
).magic
== undecided_magic
)
349 NAME (aout
, adjust_sizes_and_vmas
) (abfd
);
351 execp
->a_syms
= bfd_get_symcount (abfd
) * EXTERNAL_NLIST_SIZE
;
352 execp
->a_entry
= bfd_get_start_address (abfd
);
354 if (obj_textsec (abfd
)->reloc_count
> 0
355 || obj_datasec (abfd
)->reloc_count
> 0)
357 execp
->a_trsize
= execp
->a_text
;
358 execp
->a_drsize
= execp
->a_data
;
366 NAME (aout
, swap_exec_header_out
) (abfd
, execp
, & exec_bytes
);
368 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
371 if (bfd_bwrite ((void *) &exec_bytes
, (bfd_size_type
) EXEC_BYTES_SIZE
, abfd
)
375 /* Now write out reloc info, followed by syms and strings. */
376 if (bfd_get_outsymbols (abfd
) != NULL
377 && bfd_get_symcount (abfd
) != 0)
379 if (bfd_seek (abfd
, (file_ptr
) (N_SYMOFF (execp
)), SEEK_SET
) != 0)
382 if (! NAME (aout
, write_syms
) (abfd
))
386 if (obj_textsec (abfd
)->reloc_count
> 0
387 || obj_datasec (abfd
)->reloc_count
> 0)
389 if (bfd_seek (abfd
, (file_ptr
) (N_TRELOFF (execp
)), SEEK_SET
) != 0
390 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_textsec (abfd
))
391 || bfd_seek (abfd
, (file_ptr
) (N_DRELOFF (execp
)), SEEK_SET
) != 0
392 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_datasec (abfd
)))
399 /* Write an object file.
400 Section contents have already been written. We write the
401 file header, symbols, and relocation. */
404 MY(write_object_contents
) (bfd
*abfd
)
406 struct internal_exec
*execp
= exec_hdr (abfd
);
408 /* We must make certain that the magic number has been set. This
409 will normally have been done by set_section_contents, but only if
410 there actually are some section contents. */
411 if (! abfd
->output_has_begun
)
412 NAME (aout
, adjust_sizes_and_vmas
) (abfd
);
414 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
416 return WRITE_HEADERS (abfd
, execp
);
419 /* Swap the information in an executable header @var{raw_bytes} taken
420 from a raw byte stream memory image into the internal exec header
421 structure "execp". */
423 #ifndef NAME_swap_exec_header_in
425 NAME (aout
, swap_exec_header_in
) (bfd
*abfd
,
426 struct external_exec
*bytes
,
427 struct internal_exec
*execp
)
429 /* The internal_exec structure has some fields that are unused in this
430 configuration (IE for i960), so ensure that all such uninitialized
431 fields are zero'd out. There are places where two of these structs
432 are memcmp'd, and thus the contents do matter. */
433 memset ((void *) execp
, 0, sizeof (struct internal_exec
));
434 /* Now fill in fields in the execp, from the bytes in the raw data. */
435 execp
->a_info
= GET_MAGIC (abfd
, bytes
->e_info
);
436 execp
->a_text
= GET_WORD (abfd
, bytes
->e_text
);
437 execp
->a_data
= GET_WORD (abfd
, bytes
->e_data
);
438 execp
->a_bss
= GET_WORD (abfd
, bytes
->e_bss
);
439 execp
->a_syms
= GET_WORD (abfd
, bytes
->e_syms
);
440 execp
->a_entry
= GET_WORD (abfd
, bytes
->e_entry
);
442 if (GET_WORD (abfd
, bytes
->e_flag
) & A_FLAG_RELOC_STRIPPED
)
449 execp
->a_trsize
= execp
->a_text
;
450 execp
->a_drsize
= execp
->a_data
;
453 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
456 /* Swap the information in an internal exec header structure
457 "execp" into the buffer "bytes" ready for writing to disk. */
459 NAME (aout
, swap_exec_header_out
) (bfd
*abfd
,
460 struct internal_exec
*execp
,
461 struct external_exec
*bytes
)
463 /* Now fill in fields in the raw data, from the fields in the exec struct. */
464 PUT_MAGIC (abfd
, execp
->a_info
, bytes
->e_info
);
465 PUT_WORD (abfd
, execp
->a_text
, bytes
->e_text
);
466 PUT_WORD (abfd
, execp
->a_data
, bytes
->e_data
);
467 PUT_WORD (abfd
, execp
->a_bss
, bytes
->e_bss
);
468 PUT_WORD (abfd
, execp
->a_syms
, bytes
->e_syms
);
469 PUT_WORD (abfd
, execp
->a_entry
, bytes
->e_entry
);
470 PUT_WORD (abfd
, 0, bytes
->e_unused
);
472 if ((execp
->a_trsize
== 0 || execp
->a_text
== 0)
473 && (execp
->a_drsize
== 0 || execp
->a_data
== 0))
474 PUT_WORD (abfd
, A_FLAG_RELOC_STRIPPED
, bytes
->e_flag
);
475 else if (execp
->a_trsize
== execp
->a_text
476 && execp
->a_drsize
== execp
->a_data
)
477 PUT_WORD (abfd
, 0, bytes
->e_flag
);
480 /* TODO: print a proper warning message. */
481 fprintf (stderr
, "BFD:%s:%d: internal error\n", __FILE__
, __LINE__
);
482 PUT_WORD (abfd
, 0, bytes
->e_flag
);
486 /* Make all the section for an a.out file. */
489 NAME (aout
, make_sections
) (bfd
*abfd
)
491 if (obj_textsec (abfd
) == NULL
&& bfd_make_section (abfd
, ".text") == NULL
)
493 if (obj_datasec (abfd
) == NULL
&& bfd_make_section (abfd
, ".data") == NULL
)
495 if (obj_bsssec (abfd
) == NULL
&& bfd_make_section (abfd
, ".bss") == NULL
)
500 /* Some a.out variant thinks that the file open in ABFD
501 checking is an a.out file. Do some more checking, and set up
502 for access if it really is. Call back to the calling
503 environment's "finish up" function just before returning, to
504 handle any last-minute setup. */
507 NAME (aout
, some_aout_object_p
) (bfd
*abfd
,
508 struct internal_exec
*execp
,
509 bfd_cleanup (*callback_to_real_object_p
) (bfd
*))
511 struct aout_data_struct
*rawptr
, *oldrawptr
;
513 size_t amt
= sizeof (struct aout_data_struct
);
515 rawptr
= bfd_zalloc (abfd
, amt
);
519 oldrawptr
= abfd
->tdata
.aout_data
;
520 abfd
->tdata
.aout_data
= rawptr
;
522 /* Copy the contents of the old tdata struct. */
523 if (oldrawptr
!= NULL
)
524 *abfd
->tdata
.aout_data
= *oldrawptr
;
526 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
527 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
; /* Copy in the internal_exec struct. */
528 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
530 /* Set the file flags. */
531 abfd
->flags
= BFD_NO_FLAGS
;
532 if (execp
->a_drsize
|| execp
->a_trsize
)
533 abfd
->flags
|= HAS_RELOC
;
534 /* Setting of EXEC_P has been deferred to the bottom of this function. */
536 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
537 if (N_DYNAMIC (execp
))
538 abfd
->flags
|= DYNAMIC
;
540 if (N_MAGIC (execp
) == ZMAGIC
)
542 abfd
->flags
|= D_PAGED
| WP_TEXT
;
543 adata (abfd
).magic
= z_magic
;
545 else if (N_MAGIC (execp
) == NMAGIC
)
547 abfd
->flags
|= WP_TEXT
;
548 adata (abfd
).magic
= n_magic
;
550 else if (N_MAGIC (execp
) == OMAGIC
)
551 adata (abfd
).magic
= o_magic
;
552 else if (N_MAGIC (execp
) == IMAGIC
)
553 adata (abfd
).magic
= i_magic
;
556 /* Should have been checked with N_BADMAG before this routine
561 abfd
->start_address
= execp
->a_entry
;
563 obj_aout_symbols (abfd
) = NULL
;
564 abfd
->symcount
= execp
->a_syms
/ sizeof (struct external_nlist
);
566 /* The default relocation entry size is that of traditional V7 Unix. */
567 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
569 /* The default symbol entry size is that of traditional Unix. */
570 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
573 bfd_init_window (&obj_aout_sym_window (abfd
));
574 bfd_init_window (&obj_aout_string_window (abfd
));
577 obj_aout_external_syms (abfd
) = NULL
;
578 obj_aout_external_strings (abfd
) = NULL
;
579 obj_aout_sym_hashes (abfd
) = NULL
;
581 if (! NAME (aout
, make_sections
) (abfd
))
584 obj_datasec (abfd
)->size
= execp
->a_data
;
585 obj_bsssec (abfd
)->size
= execp
->a_bss
;
587 obj_textsec (abfd
)->flags
=
588 (execp
->a_trsize
!= 0
589 ? (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_RELOC
)
590 : (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
));
591 obj_datasec (abfd
)->flags
=
592 (execp
->a_drsize
!= 0
593 ? (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_RELOC
)
594 : (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
));
595 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
597 #ifdef THIS_IS_ONLY_DOCUMENTATION
598 /* The common code can't fill in these things because they depend
599 on either the start address of the text segment, the rounding
600 up of virtual addresses between segments, or the starting file
601 position of the text segment -- all of which varies among different
602 versions of a.out. */
604 /* Call back to the format-dependent code to fill in the rest of the
605 fields and do any further cleanup. Things that should be filled
606 in by the callback: */
607 struct exec
*execp
= exec_hdr (abfd
);
609 obj_textsec (abfd
)->size
= N_TXTSIZE (execp
);
610 /* Data and bss are already filled in since they're so standard. */
612 /* The virtual memory addresses of the sections. */
613 obj_textsec (abfd
)->vma
= N_TXTADDR (execp
);
614 obj_datasec (abfd
)->vma
= N_DATADDR (execp
);
615 obj_bsssec (abfd
)->vma
= N_BSSADDR (execp
);
617 /* The file offsets of the sections. */
618 obj_textsec (abfd
)->filepos
= N_TXTOFF (execp
);
619 obj_datasec (abfd
)->filepos
= N_DATOFF (execp
);
621 /* The file offsets of the relocation info. */
622 obj_textsec (abfd
)->rel_filepos
= N_TRELOFF (execp
);
623 obj_datasec (abfd
)->rel_filepos
= N_DRELOFF (execp
);
625 /* The file offsets of the string table and symbol table. */
626 obj_str_filepos (abfd
) = N_STROFF (execp
);
627 obj_sym_filepos (abfd
) = N_SYMOFF (execp
);
629 /* Determine the architecture and machine type of the object file. */
630 abfd
->obj_arch
= bfd_arch_obscure
;
632 adata(abfd
)->page_size
= TARGET_PAGE_SIZE
;
633 adata(abfd
)->segment_size
= SEGMENT_SIZE
;
634 adata(abfd
)->exec_bytes_size
= EXEC_BYTES_SIZE
;
636 return _bfd_no_cleanup
;
638 /* The architecture is encoded in various ways in various a.out variants,
639 or is not encoded at all in some of them. The relocation size depends
640 on the architecture and the a.out variant. Finally, the return value
641 is the bfd_target vector in use. If an error occurs, return zero and
642 set bfd_error to the appropriate error code.
644 Formats such as b.out, which have additional fields in the a.out
645 header, should cope with them in this callback as well. */
646 #endif /* DOCUMENTATION */
648 cleanup
= (*callback_to_real_object_p
)(abfd
);
650 /* Now that the segment addresses have been worked out, take a better
651 guess at whether the file is executable. If the entry point
652 is within the text segment, assume it is. (This makes files
653 executable even if their entry point address is 0, as long as
654 their text starts at zero.).
656 This test had to be changed to deal with systems where the text segment
657 runs at a different location than the default. The problem is that the
658 entry address can appear to be outside the text segment, thus causing an
659 erroneous conclusion that the file isn't executable.
661 To fix this, we now accept any non-zero entry point as an indication of
662 executability. This will work most of the time, since only the linker
663 sets the entry point, and that is likely to be non-zero for most systems. */
665 if (execp
->a_entry
!= 0
666 || (execp
->a_entry
>= obj_textsec (abfd
)->vma
667 && execp
->a_entry
< (obj_textsec (abfd
)->vma
668 + obj_textsec (abfd
)->size
)
669 && execp
->a_trsize
== 0
670 && execp
->a_drsize
== 0))
671 abfd
->flags
|= EXEC_P
;
675 struct stat stat_buf
;
677 /* The original heuristic doesn't work in some important cases.
678 The a.out file has no information about the text start
679 address. For files (like kernels) linked to non-standard
680 addresses (ld -Ttext nnn) the entry point may not be between
681 the default text start (obj_textsec(abfd)->vma) and
682 (obj_textsec(abfd)->vma) + text size. This is not just a mach
683 issue. Many kernels are loaded at non standard addresses. */
684 if (abfd
->iostream
!= NULL
685 && (abfd
->flags
& BFD_IN_MEMORY
) == 0
686 && (fstat(fileno((FILE *) (abfd
->iostream
)), &stat_buf
) == 0)
687 && ((stat_buf
.st_mode
& 0111) != 0))
688 abfd
->flags
|= EXEC_P
;
690 #endif /* STAT_FOR_EXEC */
695 abfd
->tdata
.aout_data
= oldrawptr
;
700 /* Initialize ABFD for use with a.out files. */
703 NAME (aout
, mkobject
) (bfd
*abfd
)
705 struct aout_data_struct
*rawptr
;
706 size_t amt
= sizeof (struct aout_data_struct
);
708 bfd_set_error (bfd_error_system_call
);
710 /* Use an intermediate variable for clarity. */
711 rawptr
= bfd_zalloc (abfd
, amt
);
716 abfd
->tdata
.aout_data
= rawptr
;
717 exec_hdr (abfd
) = &(rawptr
->e
);
719 obj_textsec (abfd
) = NULL
;
720 obj_datasec (abfd
) = NULL
;
721 obj_bsssec (abfd
) = NULL
;
726 /* Keep track of machine architecture and machine type for
727 a.out's. Return the <<machine_type>> for a particular
728 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
729 and machine can't be represented in a.out format.
731 If the architecture is understood, machine type 0 (default)
732 is always understood. */
735 NAME (aout
, machine_type
) (enum bfd_architecture arch
,
736 unsigned long machine
,
737 bfd_boolean
*unknown
)
739 enum machine_type arch_flags
;
741 arch_flags
= M_UNKNOWN
;
748 || machine
== bfd_mach_sparc
749 || machine
== bfd_mach_sparc_sparclite
750 || machine
== bfd_mach_sparc_v9
)
751 arch_flags
= M_SPARC
;
752 else if (machine
== bfd_mach_sparc_sparclet
)
753 arch_flags
= M_SPARCLET
;
758 || machine
== bfd_mach_i386_i386
759 || machine
== bfd_mach_i386_i386_intel_syntax
)
764 if (machine
== 0) arch_flags
= M_ARM
;
772 case bfd_mach_mips3000
:
773 arch_flags
= M_MIPS1
;
775 case bfd_mach_mips4000
: /* MIPS3 */
776 case bfd_mach_mips4400
:
777 case bfd_mach_mips8000
: /* MIPS4 */
778 case bfd_mach_mips6000
: /* Real MIPS2: */
779 arch_flags
= M_MIPS2
;
782 arch_flags
= M_UNKNOWN
;
790 case 0: arch_flags
= M_NS32532
; break;
791 case 32032: arch_flags
= M_NS32032
; break;
792 case 32532: arch_flags
= M_NS32532
; break;
793 default: arch_flags
= M_UNKNOWN
; break;
798 /* TODO: arch_flags = M_PDP11; */
807 arch_flags
= M_UNKNOWN
;
810 if (arch_flags
!= M_UNKNOWN
)
816 /* Set the architecture and the machine of the ABFD to the
817 values ARCH and MACHINE. Verify that @ABFD's format
818 can support the architecture required. */
821 NAME (aout
, set_arch_mach
) (bfd
*abfd
,
822 enum bfd_architecture arch
,
823 unsigned long machine
)
825 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
828 if (arch
!= bfd_arch_unknown
)
832 NAME (aout
, machine_type
) (arch
, machine
, &unknown
);
837 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
839 return (*aout_backend_info(abfd
)->set_sizes
) (abfd
);
843 adjust_o_magic (bfd
*abfd
, struct internal_exec
*execp
)
845 file_ptr pos
= adata (abfd
).exec_bytes_size
;
848 asection
*text
= obj_textsec (abfd
);
849 asection
*data
= obj_datasec (abfd
);
850 asection
*bss
= obj_bsssec (abfd
);
854 if (!text
->user_set_vma
)
859 pos
+= execp
->a_text
;
860 vma
+= execp
->a_text
;
863 if (!data
->user_set_vma
)
871 execp
->a_text
+= pad
;
878 if (!bss
->user_set_vma
)
884 else if (data
->size
> 0 || bss
->size
> 0) /* PR25677: for objcopy --extract-symbol */
886 /* The VMA of the .bss section is set by the VMA of the
887 .data section plus the size of the .data section. We may
888 need to add padding bytes to make this true. */
889 pad
= bss
->vma
- vma
;
894 execp
->a_data
= data
->size
+ pad
;
896 execp
->a_bss
= bss
->size
;
898 N_SET_MAGIC (execp
, OMAGIC
);
902 adjust_z_magic (bfd
*abfd
, struct internal_exec
*execp
)
904 bfd_size_type data_pad
, text_pad
;
906 const struct aout_backend_data
*abdp
;
907 /* TRUE if text includes exec header. */
909 asection
*text
= obj_textsec (abfd
);
910 asection
*data
= obj_datasec (abfd
);
911 asection
*bss
= obj_bsssec (abfd
);
913 abdp
= aout_backend_info (abfd
);
917 && (abdp
->text_includes_header
918 || obj_aout_subformat (abfd
) == q_magic_format
));
919 text
->filepos
= (ztih
920 ? adata (abfd
).exec_bytes_size
921 : adata (abfd
).zmagic_disk_block_size
);
922 if (!text
->user_set_vma
)
924 /* ?? Do we really need to check for relocs here? */
925 text
->vma
= ((abfd
->flags
& HAS_RELOC
)
928 ? abdp
->default_text_vma
+ adata (abfd
).exec_bytes_size
929 : abdp
->default_text_vma
));
934 /* The .text section is being loaded at an unusual address. We
935 may need to pad it such that the .data section starts at a page
938 text_pad
= ((text
->filepos
- text
->vma
)
939 & (adata (abfd
).page_size
- 1));
941 text_pad
= (-text
->vma
942 & (adata (abfd
).page_size
- 1));
945 /* Find start of data. */
948 text_end
= text
->filepos
+ execp
->a_text
;
949 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
953 /* Note that if page_size == zmagic_disk_block_size, then
954 filepos == page_size, and this case is the same as the ztih
956 text_end
= execp
->a_text
;
957 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
958 text_end
+= text
->filepos
;
960 execp
->a_text
+= text_pad
;
963 if (!data
->user_set_vma
)
966 vma
= text
->vma
+ execp
->a_text
;
967 data
->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
969 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
971 text_pad
= data
->vma
- (text
->vma
+ execp
->a_text
);
972 /* Only pad the text section if the data
973 section is going to be placed after it. */
975 execp
->a_text
+= text_pad
;
977 data
->filepos
= text
->filepos
+ execp
->a_text
;
979 /* Fix up exec header while we're at it. */
980 if (ztih
&& (!abdp
|| (abdp
&& !abdp
->exec_header_not_counted
)))
981 execp
->a_text
+= adata (abfd
).exec_bytes_size
;
982 N_SET_MAGIC (execp
, ZMAGIC
);
984 /* Spec says data section should be rounded up to page boundary. */
985 execp
->a_data
= align_power (data
->size
, bss
->alignment_power
);
986 execp
->a_data
= BFD_ALIGN (execp
->a_data
, adata (abfd
).page_size
);
987 data_pad
= execp
->a_data
- data
->size
;
990 if (!bss
->user_set_vma
)
991 bss
->vma
= data
->vma
+ execp
->a_data
;
992 /* If the BSS immediately follows the data section and extra space
993 in the page is left after the data section, fudge data
994 in the header so that the bss section looks smaller by that
995 amount. We'll start the bss section there, and lie to the OS.
996 (Note that a linker script, as well as the above assignment,
997 could have explicitly set the BSS vma to immediately follow
998 the data section.) */
999 if (align_power (bss
->vma
, bss
->alignment_power
) == data
->vma
+ execp
->a_data
)
1000 execp
->a_bss
= data_pad
> bss
->size
? 0 : bss
->size
- data_pad
;
1002 execp
->a_bss
= bss
->size
;
1006 adjust_n_magic (bfd
*abfd
, struct internal_exec
*execp
)
1008 file_ptr pos
= adata (abfd
).exec_bytes_size
;
1011 asection
*text
= obj_textsec (abfd
);
1012 asection
*data
= obj_datasec (abfd
);
1013 asection
*bss
= obj_bsssec (abfd
);
1016 text
->filepos
= pos
;
1017 if (!text
->user_set_vma
)
1021 pos
+= execp
->a_text
;
1022 vma
+= execp
->a_text
;
1025 data
->filepos
= pos
;
1026 if (!data
->user_set_vma
)
1027 data
->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
1030 /* Since BSS follows data immediately, see if it needs alignment. */
1032 pad
= align_power (vma
, bss
->alignment_power
) - vma
;
1033 execp
->a_data
= data
->size
+ pad
;
1034 pos
+= execp
->a_data
;
1037 if (!bss
->user_set_vma
)
1042 /* Fix up exec header. */
1043 execp
->a_bss
= bss
->size
;
1044 N_SET_MAGIC (execp
, NMAGIC
);
1048 adjust_i_magic (bfd
*abfd
, struct internal_exec
*execp
)
1050 file_ptr pos
= adata (abfd
).exec_bytes_size
;
1053 asection
*text
= obj_textsec (abfd
);
1054 asection
*data
= obj_datasec (abfd
);
1055 asection
*bss
= obj_bsssec (abfd
);
1058 text
->filepos
= pos
;
1059 if (!text
->user_set_vma
)
1063 pos
+= execp
->a_text
;
1066 data
->filepos
= pos
;
1067 if (!data
->user_set_vma
)
1071 /* Since BSS follows data immediately, see if it needs alignment. */
1073 pad
= align_power (vma
, bss
->alignment_power
) - vma
;
1074 execp
->a_data
= data
->size
+ pad
;
1075 pos
+= execp
->a_data
;
1078 if (!bss
->user_set_vma
)
1083 /* Fix up exec header. */
1084 execp
->a_bss
= bss
->size
;
1085 N_SET_MAGIC (execp
, IMAGIC
);
1089 NAME (aout
, adjust_sizes_and_vmas
) (bfd
*abfd
)
1091 struct internal_exec
*execp
= exec_hdr (abfd
);
1093 if (! NAME (aout
, make_sections
) (abfd
))
1096 if (adata (abfd
).magic
!= undecided_magic
)
1099 execp
->a_text
= align_power (obj_textsec (abfd
)->size
,
1100 obj_textsec (abfd
)->alignment_power
);
1102 /* Rule (heuristic) for when to pad to a new page. Note that there
1103 are (at least) two ways demand-paged (ZMAGIC) files have been
1104 handled. Most Berkeley-based systems start the text segment at
1105 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1106 segment right after the exec header; the latter is counted in the
1107 text segment size, and is paged in by the kernel with the rest of
1110 /* This perhaps isn't the right way to do this, but made it simpler for me
1111 to understand enough to implement it. Better would probably be to go
1112 right from BFD flags to alignment/positioning characteristics. But the
1113 old code was sloppy enough about handling the flags, and had enough
1114 other magic, that it was a little hard for me to understand. I think
1115 I understand it better now, but I haven't time to do the cleanup this
1119 adata (abfd
).magic
= i_magic
;
1120 else if (abfd
->flags
& WP_TEXT
)
1121 adata (abfd
).magic
= n_magic
;
1123 adata (abfd
).magic
= o_magic
;
1125 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1127 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1129 switch (adata (abfd
).magic
)
1131 case n_magic
: str
= "NMAGIC"; break;
1132 case o_magic
: str
= "OMAGIC"; break;
1133 case i_magic
: str
= "IMAGIC"; break;
1134 case z_magic
: str
= "ZMAGIC"; break;
1139 obj_textsec (abfd
)->vma
, obj_textsec (abfd
)->size
,
1140 obj_textsec (abfd
)->alignment_power
,
1141 obj_datasec (abfd
)->vma
, obj_datasec (abfd
)->size
,
1142 obj_datasec (abfd
)->alignment_power
,
1143 obj_bsssec (abfd
)->vma
, obj_bsssec (abfd
)->size
,
1144 obj_bsssec (abfd
)->alignment_power
);
1148 switch (adata (abfd
).magic
)
1151 adjust_o_magic (abfd
, execp
);
1154 adjust_z_magic (abfd
, execp
);
1157 adjust_n_magic (abfd
, execp
);
1160 adjust_i_magic (abfd
, execp
);
1166 #ifdef BFD_AOUT_DEBUG
1167 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1168 obj_textsec (abfd
)->vma
, execp
->a_text
,
1169 obj_textsec (abfd
)->filepos
,
1170 obj_datasec (abfd
)->vma
, execp
->a_data
,
1171 obj_datasec (abfd
)->filepos
,
1172 obj_bsssec (abfd
)->vma
, execp
->a_bss
);
1178 /* Called by the BFD in response to a bfd_make_section request. */
1181 NAME (aout
, new_section_hook
) (bfd
*abfd
, asection
*newsect
)
1183 /* Align to double at least. */
1184 newsect
->alignment_power
= bfd_get_arch_info(abfd
)->section_align_power
;
1186 if (bfd_get_format (abfd
) == bfd_object
)
1188 if (obj_textsec (abfd
) == NULL
1189 && !strcmp (newsect
->name
, ".text"))
1191 obj_textsec(abfd
)= newsect
;
1192 newsect
->target_index
= N_TEXT
;
1194 else if (obj_datasec (abfd
) == NULL
1195 && !strcmp (newsect
->name
, ".data"))
1197 obj_datasec (abfd
) = newsect
;
1198 newsect
->target_index
= N_DATA
;
1200 else if (obj_bsssec (abfd
) == NULL
1201 && !strcmp (newsect
->name
, ".bss"))
1203 obj_bsssec (abfd
) = newsect
;
1204 newsect
->target_index
= N_BSS
;
1208 /* We allow more than three sections internally. */
1209 return _bfd_generic_new_section_hook (abfd
, newsect
);
1213 NAME (aout
, set_section_contents
) (bfd
*abfd
,
1215 const void * location
,
1217 bfd_size_type count
)
1219 if (! abfd
->output_has_begun
)
1221 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
1225 if (section
== obj_bsssec (abfd
))
1227 bfd_set_error (bfd_error_no_contents
);
1231 if (section
!= obj_textsec (abfd
)
1232 && section
!= obj_datasec (abfd
))
1235 /* xgettext:c-format */
1236 (_("%pB: can not represent section `%pA' in a.out object file format"),
1238 bfd_set_error (bfd_error_nonrepresentable_section
);
1244 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
1245 || bfd_bwrite (location
, count
, abfd
) != count
)
1252 /* Read the external symbols from an a.out file. */
1255 aout_get_external_symbols (bfd
*abfd
)
1257 if (obj_aout_external_syms (abfd
) == NULL
)
1259 bfd_size_type count
;
1260 struct external_nlist
*syms
;
1262 count
= exec_hdr (abfd
)->a_syms
/ EXTERNAL_NLIST_SIZE
;
1264 /* PR 17512: file: 011f5a08. */
1267 obj_aout_external_syms (abfd
) = NULL
;
1268 obj_aout_external_sym_count (abfd
) = count
;
1273 if (! bfd_get_file_window (abfd
, obj_sym_filepos (abfd
),
1274 exec_hdr (abfd
)->a_syms
,
1275 &obj_aout_sym_window (abfd
), TRUE
))
1277 syms
= (struct external_nlist
*) obj_aout_sym_window (abfd
).data
;
1279 /* We allocate using malloc to make the values easy to free
1280 later on. If we put them on the objalloc it might not be
1281 possible to free them. */
1282 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1284 syms
= (struct external_nlist
*)
1285 _bfd_malloc_and_read (abfd
, count
* EXTERNAL_NLIST_SIZE
,
1286 count
* EXTERNAL_NLIST_SIZE
);
1291 obj_aout_external_syms (abfd
) = syms
;
1292 obj_aout_external_sym_count (abfd
) = count
;
1295 if (obj_aout_external_strings (abfd
) == NULL
1296 && exec_hdr (abfd
)->a_syms
!= 0)
1298 unsigned char string_chars
[BYTES_IN_LONG
];
1299 bfd_size_type stringsize
;
1301 bfd_size_type amt
= BYTES_IN_LONG
;
1303 /* Get the size of the strings. */
1304 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
1305 || bfd_bread ((void *) string_chars
, amt
, abfd
) != amt
)
1307 stringsize
= H_GET_32 (abfd
, string_chars
);
1308 if (stringsize
== 0)
1310 else if (stringsize
< BYTES_IN_LONG
1311 || (size_t) stringsize
!= stringsize
)
1313 bfd_set_error (bfd_error_bad_value
);
1318 if (stringsize
>= BYTES_IN_LONG
)
1320 if (! bfd_get_file_window (abfd
, obj_str_filepos (abfd
), stringsize
+ 1,
1321 &obj_aout_string_window (abfd
), TRUE
))
1323 strings
= (char *) obj_aout_string_window (abfd
).data
;
1328 strings
= (char *) bfd_malloc (stringsize
+ 1);
1329 if (strings
== NULL
)
1332 if (stringsize
>= BYTES_IN_LONG
)
1334 /* Keep the string count in the buffer for convenience
1335 when indexing with e_strx. */
1336 amt
= stringsize
- BYTES_IN_LONG
;
1337 if (bfd_bread (strings
+ BYTES_IN_LONG
, amt
, abfd
) != amt
)
1344 /* Ensure that a zero index yields an empty string. */
1347 /* Ensure that the string buffer is NUL terminated. */
1348 strings
[stringsize
] = 0;
1350 obj_aout_external_strings (abfd
) = strings
;
1351 obj_aout_external_string_size (abfd
) = stringsize
;
1357 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1358 and symbol->value fields of CACHE_PTR will be set from the a.out
1359 nlist structure. This function is responsible for setting
1360 symbol->flags and symbol->section, and adjusting symbol->value. */
1363 translate_from_native_sym_flags (bfd
*abfd
,
1364 aout_symbol_type
*cache_ptr
)
1368 if (is_stab (cache_ptr
->type
, cache_ptr
->symbol
.name
))
1372 /* This is a debugging symbol. */
1373 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1375 /* Work out the symbol section. */
1376 switch (cache_ptr
->type
)
1384 sec
= obj_textsec (abfd
);
1388 sec
= obj_datasec (abfd
);
1392 sec
= obj_bsssec (abfd
);
1395 sec
= bfd_abs_section_ptr
;
1399 cache_ptr
->symbol
.section
= sec
;
1400 cache_ptr
->symbol
.value
-= sec
->vma
;
1405 /* Get the default visibility. This does not apply to all types, so
1406 we just hold it in a local variable to use if wanted. */
1407 if ((cache_ptr
->type
& N_EXT
) == 0)
1408 visible
= BSF_LOCAL
;
1410 visible
= BSF_GLOBAL
;
1412 switch (cache_ptr
->type
)
1415 case N_ABS
: case N_ABS
| N_EXT
:
1416 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1417 cache_ptr
->symbol
.flags
= visible
;
1420 case N_UNDF
| N_EXT
:
1421 if (cache_ptr
->symbol
.value
!= 0)
1423 /* This is a common symbol. */
1424 cache_ptr
->symbol
.flags
= BSF_GLOBAL
;
1425 cache_ptr
->symbol
.section
= bfd_com_section_ptr
;
1429 cache_ptr
->symbol
.flags
= 0;
1430 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1434 case N_TEXT
: case N_TEXT
| N_EXT
:
1435 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1436 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1437 cache_ptr
->symbol
.flags
= visible
;
1440 case N_DATA
: case N_DATA
| N_EXT
:
1441 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1442 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1443 cache_ptr
->symbol
.flags
= visible
;
1446 case N_BSS
: case N_BSS
| N_EXT
:
1447 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1448 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1449 cache_ptr
->symbol
.flags
= visible
;
1456 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1459 translate_to_native_sym_flags (bfd
*abfd
,
1461 struct external_nlist
*sym_pointer
)
1463 bfd_vma value
= cache_ptr
->value
;
1466 const char *name
= cache_ptr
->name
!= NULL
? cache_ptr
->name
: "*unknown*";
1468 /* Mask out any existing type bits in case copying from one section
1470 if (!is_stab (sym_pointer
->e_type
[0], name
))
1471 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1473 sec
= bfd_asymbol_section (cache_ptr
);
1478 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1481 /* xgettext:c-format */
1482 (_("%pB: can not represent section for symbol `%s' in a.out object file format"),
1484 bfd_set_error (bfd_error_nonrepresentable_section
);
1488 if (sec
->output_section
!= NULL
)
1490 off
= sec
->output_offset
;
1491 sec
= sec
->output_section
;
1494 if (bfd_is_abs_section (sec
))
1495 sym_pointer
->e_type
[0] |= N_ABS
;
1496 else if (sec
== obj_textsec (abfd
))
1497 sym_pointer
->e_type
[0] |= N_TEXT
;
1498 else if (sec
== obj_datasec (abfd
))
1499 sym_pointer
->e_type
[0] |= N_DATA
;
1500 else if (sec
== obj_bsssec (abfd
))
1501 sym_pointer
->e_type
[0] |= N_BSS
;
1502 else if (bfd_is_und_section (sec
))
1503 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1504 else if (bfd_is_com_section (sec
))
1505 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1509 /* xgettext:c-format */
1510 (_("%pB: can not represent section `%pA' in a.out object file format"),
1512 bfd_set_error (bfd_error_nonrepresentable_section
);
1516 /* Turn the symbol from section relative to absolute again */
1517 value
+= sec
->vma
+ off
;
1519 if ((cache_ptr
->flags
& BSF_DEBUGGING
) != 0)
1520 sym_pointer
->e_type
[0] = ((aout_symbol_type
*) cache_ptr
)->type
;
1521 else if ((cache_ptr
->flags
& BSF_GLOBAL
) != 0)
1522 sym_pointer
->e_type
[0] |= N_EXT
;
1524 PUT_WORD(abfd
, value
, sym_pointer
->e_value
);
1529 /* Native-level interface to symbols. */
1532 NAME (aout
, make_empty_symbol
) (bfd
*abfd
)
1534 size_t amt
= sizeof (aout_symbol_type
);
1535 aout_symbol_type
*new_symbol_type
= bfd_zalloc (abfd
, amt
);
1537 if (!new_symbol_type
)
1539 new_symbol_type
->symbol
.the_bfd
= abfd
;
1541 return &new_symbol_type
->symbol
;
1544 /* Translate a set of external symbols into internal symbols. */
1547 NAME (aout
, translate_symbol_table
) (bfd
*abfd
,
1548 aout_symbol_type
*in
,
1549 struct external_nlist
*ext
,
1550 bfd_size_type count
,
1552 bfd_size_type strsize
,
1553 bfd_boolean dynamic
)
1555 struct external_nlist
*ext_end
;
1557 ext_end
= ext
+ count
;
1558 for (; ext
< ext_end
; ext
++, in
++)
1563 x
= GET_WORD (abfd
, ext
->e_strx
);
1564 in
->symbol
.the_bfd
= abfd
;
1566 /* For the normal symbols, the zero index points at the number
1567 of bytes in the string table but is to be interpreted as the
1568 null string. For the dynamic symbols, the number of bytes in
1569 the string table is stored in the __DYNAMIC structure and the
1570 zero index points at an actual string. */
1571 if (x
== 0 && ! dynamic
)
1572 in
->symbol
.name
= "";
1573 else if (x
< strsize
)
1574 in
->symbol
.name
= str
+ x
;
1578 (_("%pB: invalid string offset %" PRIu64
" >= %" PRIu64
),
1579 abfd
, (uint64_t) x
, (uint64_t) strsize
);
1580 bfd_set_error (bfd_error_bad_value
);
1584 ovly
= H_GET_8 (abfd
, ext
->e_ovly
);
1588 (_("%pB: symbol indicates overlay (not supported)"), abfd
);
1589 bfd_set_error (bfd_error_bad_value
);
1593 in
->symbol
.value
= GET_WORD (abfd
, ext
->e_value
);
1594 /* e_desc is zero for normal symbols but for .stab symbols it
1595 carries the desc field in our extended 2.11BSD format. */
1596 in
->desc
= H_GET_16 (abfd
, ext
->e_desc
);
1598 in
->type
= H_GET_8 (abfd
, ext
->e_type
);
1599 in
->symbol
.udata
.p
= NULL
;
1601 if (! translate_from_native_sym_flags (abfd
, in
))
1605 in
->symbol
.flags
|= BSF_DYNAMIC
;
1611 /* We read the symbols into a buffer, which is discarded when this
1612 function exits. We read the strings into a buffer large enough to
1613 hold them all plus all the cached symbol entries. */
1616 NAME (aout
, slurp_symbol_table
) (bfd
*abfd
)
1618 struct external_nlist
*old_external_syms
;
1619 aout_symbol_type
*cached
;
1620 bfd_size_type cached_size
;
1622 /* If there's no work to be done, don't do any. */
1623 if (obj_aout_symbols (abfd
) != NULL
)
1626 old_external_syms
= obj_aout_external_syms (abfd
);
1628 if (! aout_get_external_symbols (abfd
))
1631 cached_size
= obj_aout_external_sym_count (abfd
);
1632 cached_size
*= sizeof (aout_symbol_type
);
1633 cached
= bfd_zmalloc (cached_size
);
1634 if (cached
== NULL
&& cached_size
!= 0)
1637 /* Convert from external symbol information to internal. */
1638 if (! (NAME (aout
, translate_symbol_table
)
1640 obj_aout_external_syms (abfd
),
1641 obj_aout_external_sym_count (abfd
),
1642 obj_aout_external_strings (abfd
),
1643 obj_aout_external_string_size (abfd
),
1650 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
1652 obj_aout_symbols (abfd
) = cached
;
1654 /* It is very likely that anybody who calls this function will not
1655 want the external symbol information, so if it was allocated
1656 because of our call to aout_get_external_symbols, we free it up
1657 right away to save space. */
1658 if (old_external_syms
== NULL
1659 && obj_aout_external_syms (abfd
) != NULL
)
1662 bfd_free_window (&obj_aout_sym_window (abfd
));
1664 free (obj_aout_external_syms (abfd
));
1666 obj_aout_external_syms (abfd
) = NULL
;
1672 /* We use a hash table when writing out symbols so that we only write
1673 out a particular string once. This helps particularly when the
1674 linker writes out stabs debugging entries, because each different
1675 contributing object file tends to have many duplicate stabs
1678 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1679 if BFD_TRADITIONAL_FORMAT is set. */
1681 /* Get the index of a string in a strtab, adding it if it is not
1684 static inline bfd_size_type
1685 add_to_stringtab (bfd
*abfd
,
1686 struct bfd_strtab_hash
*tab
,
1691 bfd_size_type str_index
;
1693 /* An index of 0 always means the empty string. */
1694 if (str
== 0 || *str
== '\0')
1697 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1698 doesn't understand a hashed string table. */
1700 if ((abfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1703 str_index
= _bfd_stringtab_add (tab
, str
, hash
, copy
);
1705 if (str_index
!= (bfd_size_type
) -1)
1706 /* Add BYTES_IN_LONG to the return value to account for the
1707 space taken up by the string table size. */
1708 str_index
+= BYTES_IN_LONG
;
1713 /* Write out a strtab. ABFD is already at the right location in the
1717 emit_stringtab (bfd
*abfd
, struct bfd_strtab_hash
*tab
)
1719 bfd_byte buffer
[BYTES_IN_LONG
];
1721 /* The string table starts with the size. */
1722 H_PUT_32 (abfd
, _bfd_stringtab_size (tab
) + BYTES_IN_LONG
, buffer
);
1723 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) BYTES_IN_LONG
, abfd
)
1727 return _bfd_stringtab_emit (abfd
, tab
);
1731 NAME (aout
, write_syms
) (bfd
*abfd
)
1733 unsigned int count
;
1734 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1735 struct bfd_strtab_hash
*strtab
;
1737 strtab
= _bfd_stringtab_init ();
1741 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1743 asymbol
*g
= generic
[count
];
1745 struct external_nlist nsp
;
1747 indx
= add_to_stringtab (abfd
, strtab
, g
->name
, FALSE
);
1748 if (indx
== (bfd_size_type
) -1)
1750 PUT_WORD (abfd
, indx
, nsp
.e_strx
);
1752 if (bfd_asymbol_flavour(g
) == abfd
->xvec
->flavour
)
1754 H_PUT_16 (abfd
, aout_symbol (g
)->desc
, nsp
.e_desc
);
1755 H_PUT_8 (abfd
, 0, nsp
.e_ovly
);
1756 H_PUT_8 (abfd
, aout_symbol (g
)->type
, nsp
.e_type
);
1760 H_PUT_16 (abfd
, 0, nsp
.e_desc
);
1761 H_PUT_8 (abfd
, 0, nsp
.e_ovly
);
1762 H_PUT_8 (abfd
, 0, nsp
.e_type
);
1765 if (! translate_to_native_sym_flags (abfd
, g
, &nsp
))
1768 if (bfd_bwrite ((void *)&nsp
, (bfd_size_type
) EXTERNAL_NLIST_SIZE
, abfd
)
1769 != EXTERNAL_NLIST_SIZE
)
1772 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1773 here, at the end. */
1777 if (! emit_stringtab (abfd
, strtab
))
1780 _bfd_stringtab_free (strtab
);
1785 _bfd_stringtab_free (strtab
);
1791 NAME (aout
, canonicalize_symtab
) (bfd
*abfd
, asymbol
**location
)
1793 unsigned int counter
= 0;
1794 aout_symbol_type
*symbase
;
1796 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
1799 for (symbase
= obj_aout_symbols (abfd
); counter
++ < bfd_get_symcount (abfd
);)
1800 *(location
++) = (asymbol
*)(symbase
++);
1802 return bfd_get_symcount (abfd
);
1806 /* Output extended relocation information to a file in target byte order. */
1809 pdp11_aout_swap_reloc_out (bfd
*abfd
, arelent
*g
, bfd_byte
*natptr
)
1815 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1816 asection
*output_section
= sym
->section
->output_section
;
1819 fprintf (stderr
, "BFD: can't do this reloc addend stuff\n");
1821 r_pcrel
= g
->howto
->pc_relative
;
1823 if (bfd_is_abs_section (output_section
))
1825 else if (output_section
== obj_textsec (abfd
))
1827 else if (output_section
== obj_datasec (abfd
))
1829 else if (output_section
== obj_bsssec (abfd
))
1831 else if (bfd_is_und_section (output_section
))
1833 else if (bfd_is_com_section (output_section
))
1838 BFD_ASSERT (r_type
!= -1);
1843 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
1845 reloc_entry
= r_index
<< 4 | r_type
| r_pcrel
;
1847 PUT_WORD (abfd
, reloc_entry
, natptr
);
1850 /* BFD deals internally with all things based from the section they're
1851 in. so, something in 10 bytes into a text section with a base of
1852 50 would have a symbol (.text+10) and know .text vma was 50.
1854 Aout keeps all it's symbols based from zero, so the symbol would
1855 contain 60. This macro subs the base of each section from the value
1856 to give the true offset from the section */
1859 #define MOVE_ADDRESS(ad) \
1862 /* Undefined symbol. */ \
1863 cache_ptr->sym_ptr_ptr = symbols + r_index; \
1864 cache_ptr->addend = ad; \
1868 /* Defined, section relative. replace symbol with pointer to \
1869 symbol which points to section. */ \
1873 case N_TEXT | N_EXT: \
1874 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
1875 cache_ptr->addend = ad - su->textsec->vma; \
1878 case N_DATA | N_EXT: \
1879 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
1880 cache_ptr->addend = ad - su->datasec->vma; \
1883 case N_BSS | N_EXT: \
1884 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
1885 cache_ptr->addend = ad - su->bsssec->vma; \
1889 case N_ABS | N_EXT: \
1890 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1891 cache_ptr->addend = ad; \
1897 pdp11_aout_swap_reloc_in (bfd
* abfd
,
1899 arelent
* cache_ptr
,
1900 bfd_size_type offset
,
1902 bfd_size_type symcount
)
1904 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
1905 unsigned int r_index
;
1910 reloc_entry
= GET_WORD (abfd
, (void *) bytes
);
1912 r_pcrel
= reloc_entry
& RELFLG
;
1914 cache_ptr
->address
= offset
;
1915 cache_ptr
->howto
= howto_table_pdp11
+ (r_pcrel
? 1 : 0);
1917 if ((reloc_entry
& RTYPE
) == RABS
)
1920 r_index
= RINDEX (reloc_entry
);
1922 /* r_extern reflects whether the symbol the reloc is against is
1924 r_extern
= (reloc_entry
& RTYPE
) == REXT
;
1926 if (r_extern
&& r_index
>= symcount
)
1928 /* We could arrange to return an error, but it might be useful
1929 to see the file even if it is bad. FIXME: Of course this
1930 means that objdump -r *doesn't* see the actual reloc, and
1931 objcopy silently writes a different reloc. */
1939 /* Read and swap the relocs for a section. */
1942 NAME (aout
, slurp_reloc_table
) (bfd
*abfd
, sec_ptr asect
, asymbol
**symbols
)
1945 bfd_size_type count
;
1946 bfd_size_type reloc_size
;
1948 arelent
*reloc_cache
;
1950 unsigned int counter
= 0;
1953 if (asect
->relocation
)
1956 if (asect
->flags
& SEC_CONSTRUCTOR
)
1959 if (asect
== obj_datasec (abfd
))
1960 reloc_size
= exec_hdr(abfd
)->a_drsize
;
1961 else if (asect
== obj_textsec (abfd
))
1962 reloc_size
= exec_hdr(abfd
)->a_trsize
;
1963 else if (asect
== obj_bsssec (abfd
))
1967 bfd_set_error (bfd_error_invalid_operation
);
1971 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
1973 relocs
= _bfd_malloc_and_read (abfd
, reloc_size
, reloc_size
);
1974 if (relocs
== NULL
&& reloc_size
!= 0)
1977 each_size
= obj_reloc_entry_size (abfd
);
1978 count
= reloc_size
/ each_size
;
1980 /* Count the number of NON-ZERO relocs, this is the count we want. */
1982 unsigned int real_count
= 0;
1984 for (counter
= 0; counter
< count
; counter
++)
1988 x
= GET_WORD (abfd
, (char *) relocs
+ each_size
* counter
);
1996 reloc_cache
= bfd_zmalloc (count
* sizeof (arelent
));
1997 if (reloc_cache
== NULL
&& count
!= 0)
2000 cache_ptr
= reloc_cache
;
2005 counter
++, rptr
+= RELOC_SIZE
, cache_ptr
++)
2007 while (GET_WORD (abfd
, (void *) rptr
) == 0)
2010 if ((char *) rptr
>= (char *) relocs
+ reloc_size
)
2014 pdp11_aout_swap_reloc_in (abfd
, rptr
, cache_ptr
,
2015 (bfd_size_type
) ((char *) rptr
- (char *) relocs
),
2017 (bfd_size_type
) bfd_get_symcount (abfd
));
2020 /* Just in case, if rptr >= relocs + reloc_size should happen
2022 BFD_ASSERT (counter
== count
);
2026 asect
->relocation
= reloc_cache
;
2027 asect
->reloc_count
= cache_ptr
- reloc_cache
;
2032 /* Write out a relocation section into an object file. */
2035 NAME (aout
, squirt_out_relocs
) (bfd
*abfd
, asection
*section
)
2038 unsigned char *native
;
2039 unsigned int count
= section
->reloc_count
;
2040 bfd_size_type natsize
;
2042 natsize
= section
->size
;
2043 native
= bfd_zalloc (abfd
, natsize
);
2047 generic
= section
->orelocation
;
2048 if (generic
!= NULL
)
2054 if ((*generic
)->howto
== NULL
2055 || (*generic
)->sym_ptr_ptr
== NULL
)
2057 bfd_set_error (bfd_error_invalid_operation
);
2058 _bfd_error_handler (_("%pB: attempt to write out "
2059 "unknown reloc type"), abfd
);
2060 bfd_release (abfd
, native
);
2063 r
= native
+ (*generic
)->address
;
2064 pdp11_aout_swap_reloc_out (abfd
, *generic
, r
);
2070 if (bfd_bwrite ((void *) native
, natsize
, abfd
) != natsize
)
2072 bfd_release (abfd
, native
);
2076 bfd_release (abfd
, native
);
2080 /* This is stupid. This function should be a boolean predicate. */
2083 NAME (aout
, canonicalize_reloc
) (bfd
*abfd
,
2088 arelent
*tblptr
= section
->relocation
;
2091 if (section
== obj_bsssec (abfd
))
2097 if (!(tblptr
|| NAME (aout
, slurp_reloc_table
)(abfd
, section
, symbols
)))
2100 if (section
->flags
& SEC_CONSTRUCTOR
)
2102 arelent_chain
*chain
= section
->constructor_chain
;
2104 for (count
= 0; count
< section
->reloc_count
; count
++)
2106 *relptr
++ = &chain
->relent
;
2107 chain
= chain
->next
;
2112 tblptr
= section
->relocation
;
2114 for (count
= 0; count
++ < section
->reloc_count
;)
2115 *relptr
++ = tblptr
++;
2120 return section
->reloc_count
;
2124 NAME (aout
, get_reloc_upper_bound
) (bfd
*abfd
, sec_ptr asect
)
2126 bfd_size_type count
;
2128 if (bfd_get_format (abfd
) != bfd_object
)
2130 bfd_set_error (bfd_error_invalid_operation
);
2134 if (asect
->flags
& SEC_CONSTRUCTOR
)
2135 count
= asect
->reloc_count
;
2136 else if (asect
== obj_datasec (abfd
))
2137 count
= exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
2138 else if (asect
== obj_textsec (abfd
))
2139 count
= exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
2140 else if (asect
== obj_bsssec (abfd
))
2144 bfd_set_error (bfd_error_invalid_operation
);
2148 if (count
>= LONG_MAX
/ sizeof (arelent
*))
2150 bfd_set_error (bfd_error_file_too_big
);
2153 return (count
+ 1) * sizeof (arelent
*);
2158 NAME (aout
, get_symtab_upper_bound
) (bfd
*abfd
)
2160 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
2163 return (bfd_get_symcount (abfd
) + 1) * (sizeof (aout_symbol_type
*));
2167 NAME (aout
, get_lineno
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2168 asymbol
* symbol ATTRIBUTE_UNUSED
)
2174 NAME (aout
, get_symbol_info
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2178 bfd_symbol_info (symbol
, ret
);
2180 if (ret
->type
== '?')
2182 int type_code
= aout_symbol(symbol
)->type
& 0xff;
2183 const char *stab_name
= bfd_get_stab_name (type_code
);
2184 static char buf
[10];
2186 if (stab_name
== NULL
)
2188 sprintf(buf
, "(%d)", type_code
);
2192 ret
->stab_type
= type_code
;
2193 ret
->stab_other
= (unsigned) (aout_symbol(symbol
)->other
& 0xff);
2194 ret
->stab_desc
= (unsigned) (aout_symbol(symbol
)->desc
& 0xffff);
2195 ret
->stab_name
= stab_name
;
2200 NAME (aout
, print_symbol
) (bfd
* abfd
,
2203 bfd_print_symbol_type how
)
2205 FILE *file
= (FILE *) afile
;
2209 case bfd_print_symbol_name
:
2211 fprintf(file
,"%s", symbol
->name
);
2213 case bfd_print_symbol_more
:
2214 fprintf(file
,"%4x %2x %2x",
2215 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2216 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2217 (unsigned) (aout_symbol (symbol
)->type
));
2219 case bfd_print_symbol_all
:
2221 const char *section_name
= symbol
->section
->name
;
2223 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2225 fprintf (file
," %-5s %04x %02x %02x",
2227 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2228 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2229 (unsigned) (aout_symbol (symbol
)->type
& 0xff));
2231 fprintf(file
," %s", symbol
->name
);
2237 /* If we don't have to allocate more than 1MB to hold the generic
2238 symbols, we use the generic minisymbol method: it's faster, since
2239 it only translates the symbols once, not multiple times. */
2240 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2242 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2243 symbols. The minisymbol_to_symbol function translates these into
2244 BFD asymbol structures. */
2247 NAME (aout
, read_minisymbols
) (bfd
*abfd
,
2248 bfd_boolean dynamic
,
2250 unsigned int *sizep
)
2253 /* We could handle the dynamic symbols here as well, but it's
2254 easier to hand them off. */
2255 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2257 if (! aout_get_external_symbols (abfd
))
2260 if (obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2261 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2263 *minisymsp
= (void *) obj_aout_external_syms (abfd
);
2265 /* By passing the external symbols back from this routine, we are
2266 giving up control over the memory block. Clear
2267 obj_aout_external_syms, so that we do not try to free it
2269 obj_aout_external_syms (abfd
) = NULL
;
2271 *sizep
= EXTERNAL_NLIST_SIZE
;
2272 return obj_aout_external_sym_count (abfd
);
2275 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2276 unmodified a.out symbol. The SYM argument is a structure returned
2277 by bfd_make_empty_symbol, which we fill in here. */
2280 NAME (aout
, minisymbol_to_symbol
) (bfd
*abfd
,
2281 bfd_boolean dynamic
,
2282 const void * minisym
,
2286 || obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2287 return _bfd_generic_minisymbol_to_symbol (abfd
, dynamic
, minisym
, sym
);
2289 memset (sym
, 0, sizeof (aout_symbol_type
));
2291 /* We call translate_symbol_table to translate a single symbol. */
2292 if (! (NAME (aout
, translate_symbol_table
)
2294 (aout_symbol_type
*) sym
,
2295 (struct external_nlist
*) minisym
,
2297 obj_aout_external_strings (abfd
),
2298 obj_aout_external_string_size (abfd
),
2305 /* Provided a BFD, a section and an offset into the section, calculate
2306 and return the name of the source file and the line nearest to the
2310 NAME (aout
, find_nearest_line
) (bfd
*abfd
,
2314 const char **filename_ptr
,
2315 const char **functionname_ptr
,
2316 unsigned int *line_ptr
,
2317 unsigned int *discriminator_ptr
)
2319 /* Run down the file looking for the filename, function and linenumber. */
2321 const char *directory_name
= NULL
;
2322 const char *main_file_name
= NULL
;
2323 const char *current_file_name
= NULL
;
2324 const char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2325 bfd_vma low_line_vma
= 0;
2326 bfd_vma low_func_vma
= 0;
2328 size_t filelen
, funclen
;
2331 *filename_ptr
= bfd_get_filename (abfd
);
2332 *functionname_ptr
= NULL
;
2334 if (discriminator_ptr
)
2335 *discriminator_ptr
= 0;
2337 if (symbols
!= NULL
)
2339 for (p
= symbols
; *p
; p
++)
2341 aout_symbol_type
*q
= (aout_symbol_type
*)(*p
);
2346 /* If this looks like a file name symbol, and it comes after
2347 the line number we have found so far, but before the
2348 offset, then we have probably not found the right line
2350 if (q
->symbol
.value
<= offset
2351 && ((q
->symbol
.value
> low_line_vma
2352 && (line_file_name
!= NULL
2354 || (q
->symbol
.value
> low_func_vma
2357 const char * symname
;
2359 symname
= q
->symbol
.name
;
2362 && strlen (symname
) > 2
2363 && strcmp (symname
+ strlen (symname
) - 2, ".o") == 0)
2365 if (q
->symbol
.value
> low_line_vma
)
2368 line_file_name
= NULL
;
2370 if (q
->symbol
.value
> low_func_vma
)
2377 /* If this symbol is less than the offset, but greater than
2378 the line number we have found so far, then we have not
2379 found the right line number. */
2380 if (q
->symbol
.value
<= offset
)
2382 if (q
->symbol
.value
> low_line_vma
)
2385 line_file_name
= NULL
;
2387 if (q
->symbol
.value
> low_func_vma
)
2391 main_file_name
= current_file_name
= q
->symbol
.name
;
2392 /* Look ahead to next symbol to check if that too is an N_SO. */
2396 q
= (aout_symbol_type
*)(*p
);
2397 if (q
->type
!= (int) N_SO
)
2400 /* Found a second N_SO First is directory; second is filename. */
2401 directory_name
= current_file_name
;
2402 main_file_name
= current_file_name
= q
->symbol
.name
;
2403 if (obj_textsec(abfd
) != section
)
2407 current_file_name
= q
->symbol
.name
;
2413 /* We'll keep this if it resolves nearer than the one we have
2415 if (q
->symbol
.value
>= low_line_vma
2416 && q
->symbol
.value
<= offset
)
2418 *line_ptr
= q
->desc
;
2419 low_line_vma
= q
->symbol
.value
;
2420 line_file_name
= current_file_name
;
2426 /* We'll keep this if it is nearer than the one we have already. */
2427 if (q
->symbol
.value
>= low_func_vma
&&
2428 q
->symbol
.value
<= offset
)
2430 low_func_vma
= q
->symbol
.value
;
2431 func
= (asymbol
*) q
;
2433 else if (q
->symbol
.value
> offset
)
2443 main_file_name
= line_file_name
;
2445 if (main_file_name
== NULL
2446 || main_file_name
[0] == '/'
2447 || directory_name
== NULL
)
2450 filelen
= strlen (directory_name
) + strlen (main_file_name
);
2454 funclen
= strlen (bfd_asymbol_name (func
));
2456 free (adata (abfd
).line_buf
);
2457 if (filelen
+ funclen
== 0)
2458 adata (abfd
).line_buf
= buf
= NULL
;
2461 buf
= bfd_malloc ((bfd_size_type
) filelen
+ funclen
+ 3);
2462 adata (abfd
).line_buf
= buf
;
2467 if (main_file_name
!= NULL
)
2469 if (main_file_name
[0] == '/' || directory_name
== NULL
)
2470 *filename_ptr
= main_file_name
;
2474 /* PR binutils/20891: In a corrupt input file both
2475 main_file_name and directory_name can be empty... */
2476 * filename_ptr
= NULL
;
2479 snprintf (buf
, filelen
+ 1, "%s%s", directory_name
,
2481 *filename_ptr
= buf
;
2489 const char *function
= func
->name
;
2494 /* PR binutils/20892: In a corrupt input file func can be empty. */
2495 * functionname_ptr
= NULL
;
2498 /* The caller expects a symbol name. We actually have a
2499 function name, without the leading underscore. Put the
2500 underscore back in, so that the caller gets a symbol name. */
2501 if (bfd_get_symbol_leading_char (abfd
) == '\0')
2502 strcpy (buf
, function
);
2505 buf
[0] = bfd_get_symbol_leading_char (abfd
);
2506 strcpy (buf
+ 1, function
);
2509 /* Have to remove : stuff. */
2510 colon
= strchr (buf
, ':');
2513 *functionname_ptr
= buf
;
2520 NAME (aout
, sizeof_headers
) (bfd
*abfd
,
2521 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2523 return adata (abfd
).exec_bytes_size
;
2526 /* Free all information we have cached for this BFD. We can always
2527 read it again later if we need it. */
2530 NAME (aout
, bfd_free_cached_info
) (bfd
*abfd
)
2534 if (bfd_get_format (abfd
) != bfd_object
)
2537 #define BFCI_FREE(x) do { free (x); x = NULL; } while (0)
2538 BFCI_FREE (obj_aout_symbols (abfd
));
2541 obj_aout_external_syms (abfd
) = 0;
2542 bfd_free_window (&obj_aout_sym_window (abfd
));
2543 bfd_free_window (&obj_aout_string_window (abfd
));
2544 obj_aout_external_strings (abfd
) = 0;
2546 BFCI_FREE (obj_aout_external_syms (abfd
));
2547 BFCI_FREE (obj_aout_external_strings (abfd
));
2549 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2550 BFCI_FREE (o
->relocation
);
2556 /* Routine to create an entry in an a.out link hash table. */
2558 struct bfd_hash_entry
*
2559 NAME (aout
, link_hash_newfunc
) (struct bfd_hash_entry
*entry
,
2560 struct bfd_hash_table
*table
,
2563 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2565 /* Allocate the structure if it has not already been allocated by a
2568 ret
= bfd_hash_allocate (table
, sizeof (* ret
));
2572 /* Call the allocation method of the superclass. */
2573 ret
= (struct aout_link_hash_entry
*)
2574 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
);
2577 /* Set local fields. */
2578 ret
->written
= FALSE
;
2582 return (struct bfd_hash_entry
*) ret
;
2585 /* Initialize an a.out link hash table. */
2588 NAME (aout
, link_hash_table_init
) (struct aout_link_hash_table
*table
,
2590 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
2591 struct bfd_hash_table
*,
2593 unsigned int entsize
)
2595 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
2598 /* Create an a.out link hash table. */
2600 struct bfd_link_hash_table
*
2601 NAME (aout
, link_hash_table_create
) (bfd
*abfd
)
2603 struct aout_link_hash_table
*ret
;
2604 size_t amt
= sizeof (struct aout_link_hash_table
);
2606 ret
= bfd_malloc (amt
);
2609 if (! NAME (aout
, link_hash_table_init
) (ret
, abfd
,
2610 NAME (aout
, link_hash_newfunc
),
2611 sizeof (struct aout_link_hash_entry
)))
2619 /* Free up the internal symbols read from an a.out file. */
2622 aout_link_free_symbols (bfd
*abfd
)
2624 if (obj_aout_external_syms (abfd
) != NULL
)
2627 bfd_free_window (&obj_aout_sym_window (abfd
));
2629 free ((void *) obj_aout_external_syms (abfd
));
2631 obj_aout_external_syms (abfd
) = NULL
;
2634 if (obj_aout_external_strings (abfd
) != NULL
)
2637 bfd_free_window (&obj_aout_string_window (abfd
));
2639 free ((void *) obj_aout_external_strings (abfd
));
2641 obj_aout_external_strings (abfd
) = NULL
;
2646 /* Given an a.out BFD, add symbols to the global hash table as
2650 NAME (aout
, link_add_symbols
) (bfd
*abfd
, struct bfd_link_info
*info
)
2652 switch (bfd_get_format (abfd
))
2655 return aout_link_add_object_symbols (abfd
, info
);
2657 return _bfd_generic_link_add_archive_symbols
2658 (abfd
, info
, aout_link_check_archive_element
);
2660 bfd_set_error (bfd_error_wrong_format
);
2665 /* Add symbols from an a.out object file. */
2668 aout_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2670 if (! aout_get_external_symbols (abfd
))
2672 if (! aout_link_add_symbols (abfd
, info
))
2674 if (! info
->keep_memory
)
2676 if (! aout_link_free_symbols (abfd
))
2682 /* Look through the internal symbols to see if this object file should
2683 be included in the link. We should include this object file if it
2684 defines any symbols which are currently undefined. If this object
2685 file defines a common symbol, then we may adjust the size of the
2686 known symbol but we do not include the object file in the link
2687 (unless there is some other reason to include it). */
2690 aout_link_check_ar_symbols (bfd
*abfd
,
2691 struct bfd_link_info
*info
,
2692 bfd_boolean
*pneeded
,
2695 struct external_nlist
*p
;
2696 struct external_nlist
*pend
;
2701 /* Look through all the symbols. */
2702 p
= obj_aout_external_syms (abfd
);
2703 pend
= p
+ obj_aout_external_sym_count (abfd
);
2704 strings
= obj_aout_external_strings (abfd
);
2705 for (; p
< pend
; p
++)
2707 int type
= H_GET_8 (abfd
, p
->e_type
);
2708 const char *name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2709 struct bfd_link_hash_entry
*h
;
2711 /* Ignore symbols that are not externally visible. This is an
2712 optimization only, as we check the type more thoroughly
2714 if ((type
& N_EXT
) == 0
2715 || is_stab(type
, name
)
2719 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
2721 /* We are only interested in symbols that are currently
2722 undefined or common. */
2724 || (h
->type
!= bfd_link_hash_undefined
2725 && h
->type
!= bfd_link_hash_common
))
2728 if (type
== (N_TEXT
| N_EXT
)
2729 || type
== (N_DATA
| N_EXT
)
2730 || type
== (N_BSS
| N_EXT
)
2731 || type
== (N_ABS
| N_EXT
))
2733 /* This object file defines this symbol. We must link it
2734 in. This is true regardless of whether the current
2735 definition of the symbol is undefined or common. If the
2736 current definition is common, we have a case in which we
2737 have already seen an object file including
2739 and this object file from the archive includes
2741 In such a case we must include this object file.
2743 FIXME: The SunOS 4.1.3 linker will pull in the archive
2744 element if the symbol is defined in the .data section,
2745 but not if it is defined in the .text section. That
2746 seems a bit crazy to me, and I haven't implemented it.
2747 However, it might be correct. */
2748 if (!(*info
->callbacks
2749 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2755 if (type
== (N_UNDF
| N_EXT
))
2759 value
= GET_WORD (abfd
, p
->e_value
);
2762 /* This symbol is common in the object from the archive
2764 if (h
->type
== bfd_link_hash_undefined
)
2769 symbfd
= h
->u
.undef
.abfd
;
2772 /* This symbol was created as undefined from
2773 outside BFD. We assume that we should link
2774 in the object file. This is done for the -u
2775 option in the linker. */
2776 if (!(*info
->callbacks
2777 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2782 /* Turn the current link symbol into a common
2783 symbol. It is already on the undefs list. */
2784 h
->type
= bfd_link_hash_common
;
2785 h
->u
.c
.p
= bfd_hash_allocate (&info
->hash
->table
,
2786 sizeof (struct bfd_link_hash_common_entry
));
2787 if (h
->u
.c
.p
== NULL
)
2790 h
->u
.c
.size
= value
;
2792 /* FIXME: This isn't quite right. The maximum
2793 alignment of a common symbol should be set by the
2794 architecture of the output file, not of the input
2796 power
= bfd_log2 (value
);
2797 if (power
> bfd_get_arch_info (abfd
)->section_align_power
)
2798 power
= bfd_get_arch_info (abfd
)->section_align_power
;
2799 h
->u
.c
.p
->alignment_power
= power
;
2801 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
,
2806 /* Adjust the size of the common symbol if
2808 if (value
> h
->u
.c
.size
)
2809 h
->u
.c
.size
= value
;
2815 /* We do not need this object file. */
2819 /* Check a single archive element to see if we need to include it in
2820 the link. *PNEEDED is set according to whether this element is
2821 needed in the link or not. This is called from
2822 _bfd_generic_link_add_archive_symbols. */
2825 aout_link_check_archive_element (bfd
*abfd
,
2826 struct bfd_link_info
*info
,
2827 struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
2828 const char *name ATTRIBUTE_UNUSED
,
2829 bfd_boolean
*pneeded
)
2834 if (!aout_get_external_symbols (abfd
))
2838 if (!aout_link_check_ar_symbols (abfd
, info
, pneeded
, &abfd
))
2844 /* Potentially, the add_archive_element hook may have set a
2845 substitute BFD for us. */
2848 if (!info
->keep_memory
2849 && !aout_link_free_symbols (oldbfd
))
2851 if (!aout_get_external_symbols (abfd
))
2854 if (!aout_link_add_symbols (abfd
, info
))
2858 if (!info
->keep_memory
|| !needed
)
2860 if (!aout_link_free_symbols (abfd
))
2867 /* Add all symbols from an object file to the hash table. */
2870 aout_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2872 bfd_boolean (*add_one_symbol
)
2873 (struct bfd_link_info
*, bfd
*, const char *, flagword
, asection
*,
2874 bfd_vma
, const char *, bfd_boolean
, bfd_boolean
,
2875 struct bfd_link_hash_entry
**);
2876 struct external_nlist
*syms
;
2877 bfd_size_type sym_count
;
2880 struct aout_link_hash_entry
**sym_hash
;
2881 struct external_nlist
*p
;
2882 struct external_nlist
*pend
;
2884 syms
= obj_aout_external_syms (abfd
);
2885 sym_count
= obj_aout_external_sym_count (abfd
);
2886 strings
= obj_aout_external_strings (abfd
);
2887 if (info
->keep_memory
)
2892 if (aout_backend_info (abfd
)->add_dynamic_symbols
!= NULL
)
2894 if (! ((*aout_backend_info (abfd
)->add_dynamic_symbols
)
2895 (abfd
, info
, &syms
, &sym_count
, &strings
)))
2899 /* We keep a list of the linker hash table entries that correspond
2900 to particular symbols. We could just look them up in the hash
2901 table, but keeping the list is more efficient. Perhaps this
2902 should be conditional on info->keep_memory. */
2903 sym_hash
= bfd_alloc (abfd
,
2904 sym_count
* sizeof (struct aout_link_hash_entry
*));
2905 if (sym_hash
== NULL
&& sym_count
!= 0)
2907 obj_aout_sym_hashes (abfd
) = sym_hash
;
2909 add_one_symbol
= aout_backend_info (abfd
)->add_one_symbol
;
2910 if (add_one_symbol
== NULL
)
2911 add_one_symbol
= _bfd_generic_link_add_one_symbol
;
2914 pend
= p
+ sym_count
;
2915 for (; p
< pend
; p
++, sym_hash
++)
2926 type
= H_GET_8 (abfd
, p
->e_type
);
2928 /* Ignore debugging symbols. */
2929 if (is_stab(type
, name
))
2932 /* PR 19629: Corrupt binaries can contain illegal string offsets. */
2933 if (GET_WORD (abfd
, p
->e_strx
) >= obj_aout_external_string_size (abfd
))
2935 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2936 value
= GET_WORD (abfd
, p
->e_value
);
2942 /* Shouldn't be any types not covered. */
2953 /* Ignore symbols that are not externally visible. */
2956 case N_UNDF
| N_EXT
:
2959 section
= bfd_und_section_ptr
;
2963 section
= bfd_com_section_ptr
;
2966 section
= bfd_abs_section_ptr
;
2968 case N_TEXT
| N_EXT
:
2969 section
= obj_textsec (abfd
);
2970 value
-= bfd_section_vma (section
);
2972 case N_DATA
| N_EXT
:
2973 /* Treat N_SETV symbols as N_DATA symbol; see comment in
2974 translate_from_native_sym_flags. */
2975 section
= obj_datasec (abfd
);
2976 value
-= bfd_section_vma (section
);
2979 section
= obj_bsssec (abfd
);
2980 value
-= bfd_section_vma (section
);
2984 if (! ((*add_one_symbol
)
2985 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, FALSE
,
2986 (struct bfd_link_hash_entry
**) sym_hash
)))
2989 /* Restrict the maximum alignment of a common symbol based on
2990 the architecture, since a.out has no way to represent
2991 alignment requirements of a section in a .o file. FIXME:
2992 This isn't quite right: it should use the architecture of the
2993 output file, not the input files. */
2994 if ((*sym_hash
)->root
.type
== bfd_link_hash_common
2995 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
>
2996 bfd_get_arch_info (abfd
)->section_align_power
))
2997 (*sym_hash
)->root
.u
.c
.p
->alignment_power
=
2998 bfd_get_arch_info (abfd
)->section_align_power
;
3000 /* If this is a set symbol, and we are not building sets, then
3001 it is possible for the hash entry to not have been set. In
3002 such a case, treat the symbol as not globally defined. */
3003 if ((*sym_hash
)->root
.type
== bfd_link_hash_new
)
3005 BFD_ASSERT ((flags
& BSF_CONSTRUCTOR
) != 0);
3013 /* Look up an entry in an the header file hash table. */
3015 #define aout_link_includes_lookup(table, string, create, copy) \
3016 ((struct aout_link_includes_entry *) \
3017 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3019 /* The function to create a new entry in the header file hash table. */
3021 static struct bfd_hash_entry
*
3022 aout_link_includes_newfunc (struct bfd_hash_entry
*entry
,
3023 struct bfd_hash_table
*table
,
3026 struct aout_link_includes_entry
* ret
=
3027 (struct aout_link_includes_entry
*) entry
;
3029 /* Allocate the structure if it has not already been allocated by a
3032 ret
= bfd_hash_allocate (table
,
3033 sizeof (struct aout_link_includes_entry
));
3037 /* Call the allocation method of the superclass. */
3038 ret
= ((struct aout_link_includes_entry
*)
3039 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
3041 /* Set local fields. */
3044 return (struct bfd_hash_entry
*) ret
;
3047 /* Write out a symbol that was not associated with an a.out input
3051 aout_link_write_other_symbol (struct bfd_hash_entry
*bh
, void *data
)
3053 struct aout_link_hash_entry
*h
= (struct aout_link_hash_entry
*) bh
;
3054 struct aout_final_link_info
*flaginfo
= (struct aout_final_link_info
*) data
;
3058 struct external_nlist outsym
;
3062 if (h
->root
.type
== bfd_link_hash_warning
)
3064 h
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
3065 if (h
->root
.type
== bfd_link_hash_new
)
3069 output_bfd
= flaginfo
->output_bfd
;
3071 if (aout_backend_info (output_bfd
)->write_dynamic_symbol
!= NULL
)
3073 if (! ((*aout_backend_info (output_bfd
)->write_dynamic_symbol
)
3074 (output_bfd
, flaginfo
->info
, h
)))
3076 /* FIXME: No way to handle errors. */
3086 /* An indx of -2 means the symbol must be written. */
3088 && (flaginfo
->info
->strip
== strip_all
3089 || (flaginfo
->info
->strip
== strip_some
3090 && bfd_hash_lookup (flaginfo
->info
->keep_hash
, h
->root
.root
.string
,
3091 FALSE
, FALSE
) == NULL
)))
3094 switch (h
->root
.type
)
3098 /* Avoid variable not initialized warnings. */
3100 case bfd_link_hash_new
:
3101 /* This can happen for set symbols when sets are not being
3104 case bfd_link_hash_undefined
:
3105 type
= N_UNDF
| N_EXT
;
3108 case bfd_link_hash_defined
:
3109 case bfd_link_hash_defweak
:
3113 sec
= h
->root
.u
.def
.section
->output_section
;
3114 BFD_ASSERT (bfd_is_abs_section (sec
)
3115 || sec
->owner
== output_bfd
);
3116 if (sec
== obj_textsec (output_bfd
))
3117 type
= h
->root
.type
== bfd_link_hash_defined
? N_TEXT
: N_WEAKT
;
3118 else if (sec
== obj_datasec (output_bfd
))
3119 type
= h
->root
.type
== bfd_link_hash_defined
? N_DATA
: N_WEAKD
;
3120 else if (sec
== obj_bsssec (output_bfd
))
3121 type
= h
->root
.type
== bfd_link_hash_defined
? N_BSS
: N_WEAKB
;
3123 type
= h
->root
.type
== bfd_link_hash_defined
? N_ABS
: N_WEAKA
;
3125 val
= (h
->root
.u
.def
.value
3127 + h
->root
.u
.def
.section
->output_offset
);
3130 case bfd_link_hash_common
:
3131 type
= N_UNDF
| N_EXT
;
3132 val
= h
->root
.u
.c
.size
;
3134 case bfd_link_hash_undefweak
:
3138 case bfd_link_hash_indirect
:
3139 case bfd_link_hash_warning
:
3140 /* FIXME: Ignore these for now. The circumstances under which
3141 they should be written out are not clear to me. */
3145 H_PUT_8 (output_bfd
, type
, outsym
.e_type
);
3146 H_PUT_8 (output_bfd
, 0, outsym
.e_ovly
);
3147 indx
= add_to_stringtab (output_bfd
, flaginfo
->strtab
, h
->root
.root
.string
,
3149 if (indx
== (bfd_size_type
) -1)
3150 /* FIXME: No way to handle errors. */
3153 PUT_WORD (output_bfd
, 0, outsym
.e_desc
);
3154 PUT_WORD (output_bfd
, indx
, outsym
.e_strx
);
3155 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
3157 amt
= EXTERNAL_NLIST_SIZE
;
3158 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0
3159 || bfd_bwrite ((void *) &outsym
, amt
, output_bfd
) != amt
)
3160 /* FIXME: No way to handle errors. */
3163 flaginfo
->symoff
+= amt
;
3164 h
->indx
= obj_aout_external_sym_count (output_bfd
);
3165 ++obj_aout_external_sym_count (output_bfd
);
3170 /* Handle a link order which is supposed to generate a reloc. */
3173 aout_link_reloc_link_order (struct aout_final_link_info
*flaginfo
,
3175 struct bfd_link_order
*p
)
3177 struct bfd_link_order_reloc
*pr
;
3180 reloc_howto_type
*howto
;
3181 file_ptr
*reloff_ptr
;
3182 struct reloc_std_external srel
;
3184 bfd_size_type rel_size
;
3188 if (p
->type
== bfd_section_reloc_link_order
)
3191 if (bfd_is_abs_section (pr
->u
.section
))
3192 r_index
= N_ABS
| N_EXT
;
3195 BFD_ASSERT (pr
->u
.section
->owner
== flaginfo
->output_bfd
);
3196 r_index
= pr
->u
.section
->target_index
;
3201 struct aout_link_hash_entry
*h
;
3203 BFD_ASSERT (p
->type
== bfd_symbol_reloc_link_order
);
3205 h
= ((struct aout_link_hash_entry
*)
3206 bfd_wrapped_link_hash_lookup (flaginfo
->output_bfd
, flaginfo
->info
,
3207 pr
->u
.name
, FALSE
, FALSE
, TRUE
));
3213 /* We decided to strip this symbol, but it turns out that we
3214 can't. Note that we lose the other and desc information
3215 here. I don't think that will ever matter for a global
3219 if (!aout_link_write_other_symbol (&h
->root
.root
, flaginfo
))
3225 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3226 (flaginfo
->info
, pr
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
3231 howto
= bfd_reloc_type_lookup (flaginfo
->output_bfd
, pr
->reloc
);
3234 bfd_set_error (bfd_error_bad_value
);
3238 if (o
== obj_textsec (flaginfo
->output_bfd
))
3239 reloff_ptr
= &flaginfo
->treloff
;
3240 else if (o
== obj_datasec (flaginfo
->output_bfd
))
3241 reloff_ptr
= &flaginfo
->dreloff
;
3246 MY_put_reloc(flaginfo
->output_bfd
, r_extern
, r_index
, p
->offset
, howto
,
3256 fprintf (stderr
, "TODO: line %d in bfd/pdp11.c\n", __LINE__
);
3258 r_pcrel
= howto
->pc_relative
;
3259 r_baserel
= (howto
->type
& 8) != 0;
3260 r_jmptable
= (howto
->type
& 16) != 0;
3261 r_relative
= (howto
->type
& 32) != 0;
3262 r_length
= howto
->size
;
3264 PUT_WORD (flaginfo
->output_bfd
, p
->offset
, srel
.r_address
);
3265 if (bfd_header_big_endian (flaginfo
->output_bfd
))
3267 srel
.r_index
[0] = r_index
>> 16;
3268 srel
.r_index
[1] = r_index
>> 8;
3269 srel
.r_index
[2] = r_index
;
3271 ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
3272 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
3273 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
3274 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
3275 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
3276 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
3280 srel
.r_index
[2] = r_index
>> 16;
3281 srel
.r_index
[1] = r_index
>> 8;
3282 srel
.r_index
[0] = r_index
;
3284 ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
3285 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
3286 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
3287 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
3288 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
3289 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
3293 rel_ptr
= (void *) &srel
;
3295 /* We have to write the addend into the object file, since
3296 standard a.out relocs are in place. It would be more
3297 reliable if we had the current contents of the file here,
3298 rather than assuming zeroes, but we can't read the file since
3299 it was opened using bfd_openw. */
3300 if (pr
->addend
!= 0)
3303 bfd_reloc_status_type r
;
3307 size
= bfd_get_reloc_size (howto
);
3308 buf
= bfd_zmalloc (size
);
3309 if (buf
== NULL
&& size
!= 0)
3311 r
= MY_relocate_contents (howto
, flaginfo
->output_bfd
,
3318 case bfd_reloc_outofrange
:
3320 case bfd_reloc_overflow
:
3321 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3322 (flaginfo
->info
, NULL
,
3323 (p
->type
== bfd_section_reloc_link_order
3324 ? bfd_section_name (pr
->u
.section
)
3326 howto
->name
, pr
->addend
, NULL
,
3327 (asection
*) NULL
, (bfd_vma
) 0);
3330 ok
= bfd_set_section_contents (flaginfo
->output_bfd
, o
,
3332 (file_ptr
) p
->offset
,
3339 rel_size
= obj_reloc_entry_size (flaginfo
->output_bfd
);
3340 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0
3341 || bfd_bwrite (rel_ptr
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3344 *reloff_ptr
+= rel_size
;
3346 /* Assert that the relocs have not run into the symbols, and that n
3347 the text relocs have not run into the data relocs. */
3348 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3349 && (reloff_ptr
!= &flaginfo
->treloff
3351 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3356 /* Get the section corresponding to a reloc index. */
3358 static inline asection
*
3359 aout_reloc_type_to_section (bfd
*abfd
, int type
)
3363 case RTEXT
: return obj_textsec (abfd
);
3364 case RDATA
: return obj_datasec (abfd
);
3365 case RBSS
: return obj_bsssec (abfd
);
3366 case RABS
: return bfd_abs_section_ptr
;
3367 case REXT
: return bfd_und_section_ptr
;
3373 pdp11_aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3375 asection
*input_section
,
3377 bfd_size_type rel_size
,
3380 bfd_boolean (*check_dynamic_reloc
)
3381 (struct bfd_link_info
*, bfd
*, asection
*,
3382 struct aout_link_hash_entry
*, void *, bfd_byte
*, bfd_boolean
*,
3385 bfd_boolean relocatable
;
3386 struct external_nlist
*syms
;
3388 struct aout_link_hash_entry
**sym_hashes
;
3393 output_bfd
= flaginfo
->output_bfd
;
3394 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
3396 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_SIZE
);
3397 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
3398 == output_bfd
->xvec
->header_byteorder
);
3400 relocatable
= bfd_link_relocatable (flaginfo
->info
);
3401 syms
= obj_aout_external_syms (input_bfd
);
3402 strings
= obj_aout_external_strings (input_bfd
);
3403 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
3404 symbol_map
= flaginfo
->symbol_map
;
3407 rel_end
= rel
+ rel_size
;
3408 for (; rel
< rel_end
; rel
+= RELOC_SIZE
)
3415 reloc_howto_type
*howto
;
3416 struct aout_link_hash_entry
*h
= NULL
;
3418 bfd_reloc_status_type r
;
3421 reloc_entry
= GET_WORD (input_bfd
, (void *) rel
);
3422 if (reloc_entry
== 0)
3426 unsigned int howto_idx
;
3428 r_index
= (reloc_entry
& RIDXMASK
) >> 4;
3429 r_type
= reloc_entry
& RTYPE
;
3430 r_pcrel
= reloc_entry
& RELFLG
;
3431 r_addr
= (char *) rel
- (char *) relocs
;
3433 r_extern
= (r_type
== REXT
);
3435 howto_idx
= r_pcrel
;
3436 if (howto_idx
< TABLE_SIZE (howto_table_pdp11
))
3437 howto
= howto_table_pdp11
+ howto_idx
;
3440 _bfd_error_handler (_("%pB: unsupported relocation type"),
3442 bfd_set_error (bfd_error_bad_value
);
3449 /* We are generating a relocatable output file, and must
3450 modify the reloc accordingly. */
3453 /* If we know the symbol this relocation is against,
3454 convert it into a relocation against a section. This
3455 is what the native linker does. */
3456 h
= sym_hashes
[r_index
];
3458 && (h
->root
.type
== bfd_link_hash_defined
3459 || h
->root
.type
== bfd_link_hash_defweak
))
3461 asection
*output_section
;
3463 /* Compute a new r_index. */
3464 output_section
= h
->root
.u
.def
.section
->output_section
;
3465 if (output_section
== obj_textsec (output_bfd
))
3467 else if (output_section
== obj_datasec (output_bfd
))
3469 else if (output_section
== obj_bsssec (output_bfd
))
3474 /* Add the symbol value and the section VMA to the
3475 addend stored in the contents. */
3476 relocation
= (h
->root
.u
.def
.value
3477 + output_section
->vma
3478 + h
->root
.u
.def
.section
->output_offset
);
3482 /* We must change r_index according to the symbol
3484 r_index
= symbol_map
[r_index
];
3490 /* We decided to strip this symbol, but it
3491 turns out that we can't. Note that we
3492 lose the other and desc information here.
3493 I don't think that will ever matter for a
3499 if (!aout_link_write_other_symbol (&h
->root
.root
,
3509 name
= strings
+ GET_WORD (input_bfd
,
3510 syms
[r_index
].e_strx
);
3511 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3512 (flaginfo
->info
, name
, input_bfd
, input_section
,
3521 /* Write out the new r_index value. */
3522 reloc_entry
= GET_WORD (input_bfd
, rel
);
3523 reloc_entry
&= RIDXMASK
;
3524 reloc_entry
|= r_index
<< 4;
3525 PUT_WORD (input_bfd
, reloc_entry
, rel
);
3531 /* This is a relocation against a section. We must
3532 adjust by the amount that the section moved. */
3533 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3534 relocation
= (section
->output_section
->vma
3535 + section
->output_offset
3539 /* Change the address of the relocation. */
3540 fprintf (stderr
, "TODO: change the address of the relocation\n");
3542 /* Adjust a PC relative relocation by removing the reference
3543 to the original address in the section and including the
3544 reference to the new address. */
3546 relocation
-= (input_section
->output_section
->vma
3547 + input_section
->output_offset
3548 - input_section
->vma
);
3550 #ifdef MY_relocatable_reloc
3551 MY_relocatable_reloc (howto
, output_bfd
, rel
, relocation
, r_addr
);
3554 if (relocation
== 0)
3557 r
= MY_relocate_contents (howto
,
3558 input_bfd
, relocation
,
3565 /* We are generating an executable, and must do a full
3570 h
= sym_hashes
[r_index
];
3573 && (h
->root
.type
== bfd_link_hash_defined
3574 || h
->root
.type
== bfd_link_hash_defweak
))
3576 relocation
= (h
->root
.u
.def
.value
3577 + h
->root
.u
.def
.section
->output_section
->vma
3578 + h
->root
.u
.def
.section
->output_offset
);
3581 && h
->root
.type
== bfd_link_hash_undefweak
)
3593 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3594 relocation
= (section
->output_section
->vma
3595 + section
->output_offset
3598 relocation
+= input_section
->vma
;
3601 if (check_dynamic_reloc
!= NULL
)
3605 if (! ((*check_dynamic_reloc
)
3606 (flaginfo
->info
, input_bfd
, input_section
, h
,
3607 (void *) rel
, contents
, &skip
, &relocation
)))
3613 /* Now warn if a global symbol is undefined. We could not
3614 do this earlier, because check_dynamic_reloc might want
3615 to skip this reloc. */
3616 if (hundef
&& ! bfd_link_pic (flaginfo
->info
))
3621 name
= h
->root
.root
.string
;
3623 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
3624 (*flaginfo
->info
->callbacks
->undefined_symbol
)
3625 (flaginfo
->info
, name
, input_bfd
, input_section
,
3629 r
= MY_final_link_relocate (howto
,
3630 input_bfd
, input_section
,
3631 contents
, r_addr
, relocation
,
3635 if (r
!= bfd_reloc_ok
)
3640 case bfd_reloc_outofrange
:
3642 case bfd_reloc_overflow
:
3649 name
= strings
+ GET_WORD (input_bfd
,
3650 syms
[r_index
].e_strx
);
3655 s
= aout_reloc_type_to_section (input_bfd
, r_type
);
3656 name
= bfd_section_name (s
);
3658 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3659 (flaginfo
->info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3660 (bfd_vma
) 0, input_bfd
, input_section
, r_addr
);
3670 /* Link an a.out section into the output file. */
3673 aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3675 asection
*input_section
,
3676 file_ptr
*reloff_ptr
,
3677 bfd_size_type rel_size
)
3679 bfd_size_type input_size
;
3682 /* Get the section contents. */
3683 input_size
= input_section
->size
;
3684 if (! bfd_get_section_contents (input_bfd
, input_section
,
3685 (void *) flaginfo
->contents
,
3686 (file_ptr
) 0, input_size
))
3689 /* Read in the relocs if we haven't already done it. */
3690 if (aout_section_data (input_section
) != NULL
3691 && aout_section_data (input_section
)->relocs
!= NULL
)
3692 relocs
= aout_section_data (input_section
)->relocs
;
3695 relocs
= flaginfo
->relocs
;
3698 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3699 || bfd_bread (relocs
, rel_size
, input_bfd
) != rel_size
)
3704 /* Relocate the section contents. */
3705 if (! pdp11_aout_link_input_section (flaginfo
, input_bfd
, input_section
,
3706 (bfd_byte
*) relocs
,
3707 rel_size
, flaginfo
->contents
))
3710 /* Write out the section contents. */
3711 if (! bfd_set_section_contents (flaginfo
->output_bfd
,
3712 input_section
->output_section
,
3713 (void *) flaginfo
->contents
,
3714 (file_ptr
) input_section
->output_offset
,
3718 /* If we are producing relocatable output, the relocs were
3719 modified, and we now write them out. */
3720 if (bfd_link_relocatable (flaginfo
->info
) && rel_size
> 0)
3722 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
3724 if (bfd_bwrite (relocs
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3726 *reloff_ptr
+= rel_size
;
3728 /* Assert that the relocs have not run into the symbols, and
3729 that if these are the text relocs they have not run into the
3731 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3732 && (reloff_ptr
!= &flaginfo
->treloff
3734 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3740 /* Link an a.out input BFD into the output file. */
3743 aout_link_input_bfd (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
3745 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
3747 /* If this is a dynamic object, it may need special handling. */
3748 if ((input_bfd
->flags
& DYNAMIC
) != 0
3749 && aout_backend_info (input_bfd
)->link_dynamic_object
!= NULL
)
3750 return ((*aout_backend_info (input_bfd
)->link_dynamic_object
)
3751 (flaginfo
->info
, input_bfd
));
3753 /* Get the symbols. We probably have them already, unless
3754 flaginfo->info->keep_memory is FALSE. */
3755 if (! aout_get_external_symbols (input_bfd
))
3758 /* Write out the symbols and get a map of the new indices. The map
3759 is placed into flaginfo->symbol_map. */
3760 if (! aout_link_write_symbols (flaginfo
, input_bfd
))
3763 /* Relocate and write out the sections. These functions use the
3764 symbol map created by aout_link_write_symbols. The linker_mark
3765 field will be set if these sections are to be included in the
3766 link, which will normally be the case. */
3767 if (obj_textsec (input_bfd
)->linker_mark
)
3769 if (! aout_link_input_section (flaginfo
, input_bfd
,
3770 obj_textsec (input_bfd
),
3772 exec_hdr (input_bfd
)->a_trsize
))
3775 if (obj_datasec (input_bfd
)->linker_mark
)
3777 if (! aout_link_input_section (flaginfo
, input_bfd
,
3778 obj_datasec (input_bfd
),
3780 exec_hdr (input_bfd
)->a_drsize
))
3784 /* If we are not keeping memory, we don't need the symbols any
3785 longer. We still need them if we are keeping memory, because the
3786 strings in the hash table point into them. */
3787 if (! flaginfo
->info
->keep_memory
)
3789 if (! aout_link_free_symbols (input_bfd
))
3796 /* Do the final link step. This is called on the output BFD. The
3797 INFO structure should point to a list of BFDs linked through the
3798 link.next field which can be used to find each BFD which takes part
3799 in the output. Also, each section in ABFD should point to a list
3800 of bfd_link_order structures which list all the input sections for
3801 the output section. */
3804 NAME (aout
, final_link
) (bfd
*abfd
,
3805 struct bfd_link_info
*info
,
3806 void (*callback
) (bfd
*, file_ptr
*, file_ptr
*, file_ptr
*))
3808 struct aout_final_link_info aout_info
;
3809 bfd_boolean includes_hash_initialized
= FALSE
;
3811 bfd_size_type trsize
, drsize
;
3812 bfd_size_type max_contents_size
;
3813 bfd_size_type max_relocs_size
;
3814 bfd_size_type max_sym_count
;
3815 struct bfd_link_order
*p
;
3817 bfd_boolean have_link_order_relocs
;
3819 if (bfd_link_pic (info
))
3820 abfd
->flags
|= DYNAMIC
;
3822 separate_i_d
= info
->separate_code
;
3823 aout_info
.info
= info
;
3824 aout_info
.output_bfd
= abfd
;
3825 aout_info
.contents
= NULL
;
3826 aout_info
.relocs
= NULL
;
3827 aout_info
.symbol_map
= NULL
;
3828 aout_info
.output_syms
= NULL
;
3830 if (!bfd_hash_table_init_n (&aout_info
.includes
.root
,
3831 aout_link_includes_newfunc
,
3832 sizeof (struct aout_link_includes_entry
),
3835 includes_hash_initialized
= TRUE
;
3837 /* Figure out the largest section size. Also, if generating
3838 relocatable output, count the relocs. */
3841 max_contents_size
= 0;
3842 max_relocs_size
= 0;
3844 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3848 if (bfd_link_relocatable (info
))
3850 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3852 trsize
+= exec_hdr (sub
)->a_trsize
;
3853 drsize
+= exec_hdr (sub
)->a_drsize
;
3857 /* FIXME: We need to identify the .text and .data sections
3858 and call get_reloc_upper_bound and canonicalize_reloc to
3859 work out the number of relocs needed, and then multiply
3860 by the reloc size. */
3862 /* xgettext:c-format */
3863 (_("%pB: relocatable link from %s to %s not supported"),
3864 abfd
, sub
->xvec
->name
, abfd
->xvec
->name
);
3865 bfd_set_error (bfd_error_invalid_operation
);
3870 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3872 sz
= obj_textsec (sub
)->size
;
3873 if (sz
> max_contents_size
)
3874 max_contents_size
= sz
;
3875 sz
= obj_datasec (sub
)->size
;
3876 if (sz
> max_contents_size
)
3877 max_contents_size
= sz
;
3879 sz
= exec_hdr (sub
)->a_trsize
;
3880 if (sz
> max_relocs_size
)
3881 max_relocs_size
= sz
;
3882 sz
= exec_hdr (sub
)->a_drsize
;
3883 if (sz
> max_relocs_size
)
3884 max_relocs_size
= sz
;
3886 sz
= obj_aout_external_sym_count (sub
);
3887 if (sz
> max_sym_count
)
3892 if (bfd_link_relocatable (info
))
3894 if (obj_textsec (abfd
) != NULL
)
3895 trsize
+= (_bfd_count_link_order_relocs (obj_textsec (abfd
)
3896 ->map_head
.link_order
)
3897 * obj_reloc_entry_size (abfd
));
3898 if (obj_datasec (abfd
) != NULL
)
3899 drsize
+= (_bfd_count_link_order_relocs (obj_datasec (abfd
)
3900 ->map_head
.link_order
)
3901 * obj_reloc_entry_size (abfd
));
3904 exec_hdr (abfd
)->a_trsize
= trsize
;
3905 exec_hdr (abfd
)->a_drsize
= drsize
;
3906 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
3908 /* Adjust the section sizes and vmas according to the magic number.
3909 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3910 filepos for each section. */
3911 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
3914 /* The relocation and symbol file positions differ among a.out
3915 targets. We are passed a callback routine from the backend
3916 specific code to handle this.
3917 FIXME: At this point we do not know how much space the symbol
3918 table will require. This will not work for any (nonstandard)
3919 a.out target that needs to know the symbol table size before it
3920 can compute the relocation file positions. */
3921 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
3923 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
3924 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
3925 obj_sym_filepos (abfd
) = aout_info
.symoff
;
3927 /* We keep a count of the symbols as we output them. */
3928 obj_aout_external_sym_count (abfd
) = 0;
3930 /* We accumulate the string table as we write out the symbols. */
3931 aout_info
.strtab
= _bfd_stringtab_init ();
3932 if (aout_info
.strtab
== NULL
)
3935 /* Allocate buffers to hold section contents and relocs. */
3936 aout_info
.contents
= bfd_malloc (max_contents_size
);
3937 aout_info
.relocs
= bfd_malloc (max_relocs_size
);
3938 aout_info
.symbol_map
= bfd_malloc (max_sym_count
* sizeof (int *));
3939 aout_info
.output_syms
= bfd_malloc ((max_sym_count
+ 1)
3940 * sizeof (struct external_nlist
));
3941 if ((aout_info
.contents
== NULL
&& max_contents_size
!= 0)
3942 || (aout_info
.relocs
== NULL
&& max_relocs_size
!= 0)
3943 || (aout_info
.symbol_map
== NULL
&& max_sym_count
!= 0)
3944 || aout_info
.output_syms
== NULL
)
3947 /* If we have a symbol named __DYNAMIC, force it out now. This is
3948 required by SunOS. Doing this here rather than in sunos.c is a
3949 hack, but it's easier than exporting everything which would be
3952 struct aout_link_hash_entry
*h
;
3954 h
= aout_link_hash_lookup (aout_hash_table (info
), "__DYNAMIC",
3955 FALSE
, FALSE
, FALSE
);
3957 aout_link_write_other_symbol (&h
->root
.root
, &aout_info
);
3960 /* The most time efficient way to do the link would be to read all
3961 the input object files into memory and then sort out the
3962 information into the output file. Unfortunately, that will
3963 probably use too much memory. Another method would be to step
3964 through everything that composes the text section and write it
3965 out, and then everything that composes the data section and write
3966 it out, and then write out the relocs, and then write out the
3967 symbols. Unfortunately, that requires reading stuff from each
3968 input file several times, and we will not be able to keep all the
3969 input files open simultaneously, and reopening them will be slow.
3971 What we do is basically process one input file at a time. We do
3972 everything we need to do with an input file once--copy over the
3973 section contents, handle the relocation information, and write
3974 out the symbols--and then we throw away the information we read
3975 from it. This approach requires a lot of lseeks of the output
3976 file, which is unfortunate but still faster than reopening a lot
3979 We use the output_has_begun field of the input BFDs to see
3980 whether we have already handled it. */
3981 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3982 sub
->output_has_begun
= FALSE
;
3984 /* Mark all sections which are to be included in the link. This
3985 will normally be every section. We need to do this so that we
3986 can identify any sections which the linker has decided to not
3988 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3990 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
3991 if (p
->type
== bfd_indirect_link_order
)
3992 p
->u
.indirect
.section
->linker_mark
= TRUE
;
3995 have_link_order_relocs
= FALSE
;
3996 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3998 for (p
= o
->map_head
.link_order
;
4002 if (p
->type
== bfd_indirect_link_order
4003 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4004 == bfd_target_aout_flavour
))
4008 input_bfd
= p
->u
.indirect
.section
->owner
;
4009 if (! input_bfd
->output_has_begun
)
4011 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
4013 input_bfd
->output_has_begun
= TRUE
;
4016 else if (p
->type
== bfd_section_reloc_link_order
4017 || p
->type
== bfd_symbol_reloc_link_order
)
4018 /* These are handled below. */
4019 have_link_order_relocs
= TRUE
;
4022 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4028 /* Write out any symbols that we have not already written out. */
4029 bfd_hash_traverse (&info
->hash
->table
,
4030 aout_link_write_other_symbol
,
4033 /* Now handle any relocs we were asked to create by the linker.
4034 These did not come from any input file. We must do these after
4035 we have written out all the symbols, so that we know the symbol
4037 if (have_link_order_relocs
)
4039 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4041 for (p
= o
->map_head
.link_order
;
4045 if (p
->type
== bfd_section_reloc_link_order
4046 || p
->type
== bfd_symbol_reloc_link_order
)
4048 if (! aout_link_reloc_link_order (&aout_info
, o
, p
))
4055 free (aout_info
.contents
);
4056 aout_info
.contents
= NULL
;
4057 free (aout_info
.relocs
);
4058 aout_info
.relocs
= NULL
;
4059 free (aout_info
.symbol_map
);
4060 aout_info
.symbol_map
= NULL
;
4061 free (aout_info
.output_syms
);
4062 aout_info
.output_syms
= NULL
;
4063 if (includes_hash_initialized
)
4065 bfd_hash_table_free (&aout_info
.includes
.root
);
4066 includes_hash_initialized
= FALSE
;
4069 /* Finish up any dynamic linking we may be doing. */
4070 if (aout_backend_info (abfd
)->finish_dynamic_link
!= NULL
)
4072 if (! (*aout_backend_info (abfd
)->finish_dynamic_link
) (abfd
, info
))
4076 /* Update the header information. */
4077 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
4078 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
4079 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
4080 obj_textsec (abfd
)->reloc_count
=
4081 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
4082 obj_datasec (abfd
)->reloc_count
=
4083 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
4085 /* Write out the string table, unless there are no symbols. */
4086 if (abfd
->symcount
> 0)
4088 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
4089 || ! emit_stringtab (abfd
, aout_info
.strtab
))
4092 else if (obj_textsec (abfd
)->reloc_count
== 0
4093 && obj_datasec (abfd
)->reloc_count
== 0)
4095 /* The layout of a typical a.out file is header, text, data,
4096 relocs, symbols, string table. When there are no relocs,
4097 symbols or string table, the last thing in the file is data
4098 and a_data may be rounded up. However we may have a smaller
4099 sized .data section and thus not written final padding. The
4100 same thing can happen with text if there is no data. Write
4101 final padding here to extend the file. */
4104 if (exec_hdr (abfd
)->a_data
> obj_datasec (abfd
)->size
)
4105 pos
= obj_datasec (abfd
)->filepos
+ exec_hdr (abfd
)->a_data
;
4106 else if (obj_datasec (abfd
)->size
== 0
4107 && exec_hdr (abfd
)->a_text
> obj_textsec (abfd
)->size
)
4108 pos
= obj_textsec (abfd
)->filepos
+ exec_hdr (abfd
)->a_text
;
4113 if (bfd_seek (abfd
, pos
- 1, SEEK_SET
) != 0
4114 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4122 free (aout_info
.contents
);
4123 free (aout_info
.relocs
);
4124 free (aout_info
.symbol_map
);
4125 free (aout_info
.output_syms
);
4126 if (includes_hash_initialized
)
4127 bfd_hash_table_free (&aout_info
.includes
.root
);
4131 /* Adjust and write out the symbols for an a.out file. Set the new
4132 symbol indices into a symbol_map. */
4135 aout_link_write_symbols (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
4138 bfd_size_type sym_count
;
4140 enum bfd_link_strip strip
;
4141 enum bfd_link_discard discard
;
4142 struct external_nlist
*outsym
;
4143 bfd_size_type strtab_index
;
4144 struct external_nlist
*sym
;
4145 struct external_nlist
*sym_end
;
4146 struct aout_link_hash_entry
**sym_hash
;
4149 bfd_boolean skip_next
;
4151 output_bfd
= flaginfo
->output_bfd
;
4152 sym_count
= obj_aout_external_sym_count (input_bfd
);
4153 strings
= obj_aout_external_strings (input_bfd
);
4154 strip
= flaginfo
->info
->strip
;
4155 discard
= flaginfo
->info
->discard
;
4156 outsym
= flaginfo
->output_syms
;
4158 /* First write out a symbol for this object file, unless we are
4159 discarding such symbols. */
4160 if (strip
!= strip_all
4161 && (strip
!= strip_some
4162 || bfd_hash_lookup (flaginfo
->info
->keep_hash
,
4163 bfd_get_filename (input_bfd
),
4164 FALSE
, FALSE
) != NULL
)
4165 && discard
!= discard_all
)
4167 H_PUT_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
4168 H_PUT_8 (output_bfd
, 0, outsym
->e_ovly
);
4169 H_PUT_16 (output_bfd
, 0, outsym
->e_desc
);
4170 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4171 bfd_get_filename (input_bfd
), FALSE
);
4172 if (strtab_index
== (bfd_size_type
) -1)
4174 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4175 PUT_WORD (output_bfd
,
4176 (bfd_section_vma (obj_textsec (input_bfd
)->output_section
)
4177 + obj_textsec (input_bfd
)->output_offset
),
4179 ++obj_aout_external_sym_count (output_bfd
);
4185 sym
= obj_aout_external_syms (input_bfd
);
4186 sym_end
= sym
+ sym_count
;
4187 sym_hash
= obj_aout_sym_hashes (input_bfd
);
4188 symbol_map
= flaginfo
->symbol_map
;
4189 memset (symbol_map
, 0, (size_t) sym_count
* sizeof *symbol_map
);
4190 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
4194 struct aout_link_hash_entry
*h
;
4200 /* We set *symbol_map to 0 above for all symbols. If it has
4201 already been set to -1 for this symbol, it means that we are
4202 discarding it because it appears in a duplicate header file.
4203 See the N_BINCL code below. */
4204 if (*symbol_map
== -1)
4207 /* Initialize *symbol_map to -1, which means that the symbol was
4208 not copied into the output file. We will change it later if
4209 we do copy the symbol over. */
4212 type
= H_GET_8 (input_bfd
, sym
->e_type
);
4213 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
4219 /* Pass this symbol through. It is the target of an
4220 indirect or warning symbol. */
4221 val
= GET_WORD (input_bfd
, sym
->e_value
);
4226 /* Skip this symbol, which is the target of an indirect
4227 symbol that we have changed to no longer be an indirect
4234 struct aout_link_hash_entry
*hresolve
;
4236 /* We have saved the hash table entry for this symbol, if
4237 there is one. Note that we could just look it up again
4238 in the hash table, provided we first check that it is an
4242 /* Use the name from the hash table, in case the symbol was
4245 name
= h
->root
.root
.string
;
4247 /* If this is an indirect or warning symbol, then change
4248 hresolve to the base symbol. We also change *sym_hash so
4249 that the relocation routines relocate against the real
4253 && (h
->root
.type
== bfd_link_hash_indirect
4254 || h
->root
.type
== bfd_link_hash_warning
))
4256 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
4257 while (hresolve
->root
.type
== bfd_link_hash_indirect
4258 || hresolve
->root
.type
== bfd_link_hash_warning
)
4259 hresolve
= ((struct aout_link_hash_entry
*)
4260 hresolve
->root
.u
.i
.link
);
4261 *sym_hash
= hresolve
;
4264 /* If the symbol has already been written out, skip it. */
4266 && h
->root
.type
!= bfd_link_hash_warning
4269 if ((type
& N_TYPE
) == N_INDR
4270 || type
== N_WARNING
)
4272 *symbol_map
= h
->indx
;
4276 /* See if we are stripping this symbol. */
4282 case strip_debugger
:
4283 if (is_stab (type
, name
))
4287 if (bfd_hash_lookup (flaginfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
4302 /* Get the value of the symbol. */
4303 if (is_stab (type
, name
))
4308 symsec
= bfd_abs_section_ptr
;
4316 symsec
= obj_textsec (input_bfd
);
4320 symsec
= obj_datasec (input_bfd
);
4324 symsec
= obj_bsssec (input_bfd
);
4327 val
= GET_WORD (input_bfd
, sym
->e_value
);
4329 else if ((type
& N_TYPE
) == N_TEXT
4331 symsec
= obj_textsec (input_bfd
);
4332 else if ((type
& N_TYPE
) == N_DATA
4334 symsec
= obj_datasec (input_bfd
);
4335 else if ((type
& N_TYPE
) == N_BSS
4337 symsec
= obj_bsssec (input_bfd
);
4338 else if ((type
& N_TYPE
) == N_ABS
4340 symsec
= bfd_abs_section_ptr
;
4341 else if (((type
& N_TYPE
) == N_INDR
4342 && (hresolve
== NULL
4343 || (hresolve
->root
.type
!= bfd_link_hash_defined
4344 && hresolve
->root
.type
!= bfd_link_hash_defweak
4345 && hresolve
->root
.type
!= bfd_link_hash_common
)))
4346 || type
== N_WARNING
)
4348 /* Pass the next symbol through unchanged. The
4349 condition above for indirect symbols is so that if
4350 the indirect symbol was defined, we output it with
4351 the correct definition so the debugger will
4354 val
= GET_WORD (input_bfd
, sym
->e_value
);
4359 /* If we get here with an indirect symbol, it means that
4360 we are outputting it with a real definition. In such
4361 a case we do not want to output the next symbol,
4362 which is the target of the indirection. */
4363 if ((type
& N_TYPE
) == N_INDR
)
4368 /* We need to get the value from the hash table. We use
4369 hresolve so that if we have defined an indirect
4370 symbol we output the final definition. */
4373 switch (type
& N_TYPE
)
4376 symsec
= obj_textsec (input_bfd
);
4379 symsec
= obj_datasec (input_bfd
);
4382 symsec
= obj_bsssec (input_bfd
);
4385 symsec
= bfd_abs_section_ptr
;
4392 else if (hresolve
->root
.type
== bfd_link_hash_defined
4393 || hresolve
->root
.type
== bfd_link_hash_defweak
)
4395 asection
*input_section
;
4396 asection
*output_section
;
4398 /* This case usually means a common symbol which was
4399 turned into a defined symbol. */
4400 input_section
= hresolve
->root
.u
.def
.section
;
4401 output_section
= input_section
->output_section
;
4402 BFD_ASSERT (bfd_is_abs_section (output_section
)
4403 || output_section
->owner
== output_bfd
);
4404 val
= (hresolve
->root
.u
.def
.value
4405 + bfd_section_vma (output_section
)
4406 + input_section
->output_offset
);
4408 /* Get the correct type based on the section. If
4409 this is a constructed set, force it to be
4410 globally visible. */
4419 if (output_section
== obj_textsec (output_bfd
))
4420 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4423 else if (output_section
== obj_datasec (output_bfd
))
4424 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4427 else if (output_section
== obj_bsssec (output_bfd
))
4428 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4432 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4436 else if (hresolve
->root
.type
== bfd_link_hash_common
)
4437 val
= hresolve
->root
.u
.c
.size
;
4438 else if (hresolve
->root
.type
== bfd_link_hash_undefweak
)
4447 val
= (symsec
->output_section
->vma
4448 + symsec
->output_offset
4449 + (GET_WORD (input_bfd
, sym
->e_value
)
4452 /* If this is a global symbol set the written flag, and if
4453 it is a local symbol see if we should discard it. */
4457 h
->indx
= obj_aout_external_sym_count (output_bfd
);
4459 else if ((type
& N_TYPE
) != N_SETT
4460 && (type
& N_TYPE
) != N_SETD
4461 && (type
& N_TYPE
) != N_SETB
4462 && (type
& N_TYPE
) != N_SETA
)
4467 case discard_sec_merge
:
4470 if (!is_stab (type
, name
)
4471 && bfd_is_local_label_name (input_bfd
, name
))
4485 /* An N_BINCL symbol indicates the start of the stabs
4486 entries for a header file. We need to scan ahead to the
4487 next N_EINCL symbol, ignoring nesting, adding up all the
4488 characters in the symbol names, not including the file
4489 numbers in types (the first number after an open
4491 if (type
== N_BINCL
)
4493 struct external_nlist
*incl_sym
;
4495 struct aout_link_includes_entry
*incl_entry
;
4496 struct aout_link_includes_totals
*t
;
4500 for (incl_sym
= sym
+ 1; incl_sym
< sym_end
; incl_sym
++)
4504 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4505 if (incl_type
== N_EINCL
)
4511 else if (incl_type
== N_BINCL
)
4517 s
= strings
+ GET_WORD (input_bfd
, incl_sym
->e_strx
);
4518 for (; *s
!= '\0'; s
++)
4523 /* Skip the file number. */
4525 while (ISDIGIT (*s
))
4533 /* If we have already included a header file with the
4534 same value, then replace this one with an N_EXCL
4536 copy
= ! flaginfo
->info
->keep_memory
;
4537 incl_entry
= aout_link_includes_lookup (&flaginfo
->includes
,
4539 if (incl_entry
== NULL
)
4541 for (t
= incl_entry
->totals
; t
!= NULL
; t
= t
->next
)
4542 if (t
->total
== val
)
4546 /* This is the first time we have seen this header
4547 file with this set of stabs strings. */
4548 t
= bfd_hash_allocate (&flaginfo
->includes
.root
,
4553 t
->next
= incl_entry
->totals
;
4554 incl_entry
->totals
= t
;
4560 /* This is a duplicate header file. We must change
4561 it to be an N_EXCL entry, and mark all the
4562 included symbols to prevent outputting them. */
4566 for (incl_sym
= sym
+ 1, incl_map
= symbol_map
+ 1;
4568 incl_sym
++, incl_map
++)
4572 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4573 if (incl_type
== N_EINCL
)
4582 else if (incl_type
== N_BINCL
)
4591 /* Copy this symbol into the list of symbols we are going to
4593 H_PUT_8 (output_bfd
, type
, outsym
->e_type
);
4594 H_PUT_8 (output_bfd
, H_GET_8 (input_bfd
, sym
->e_ovly
), outsym
->e_ovly
);
4595 H_PUT_16 (output_bfd
, H_GET_16 (input_bfd
, sym
->e_desc
), outsym
->e_desc
);
4597 if (! flaginfo
->info
->keep_memory
)
4599 /* name points into a string table which we are going to
4600 free. If there is a hash table entry, use that string.
4601 Otherwise, copy name into memory. */
4603 name
= h
->root
.root
.string
;
4607 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4609 if (strtab_index
== (bfd_size_type
) -1)
4611 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4612 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
4613 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
4614 ++obj_aout_external_sym_count (output_bfd
);
4618 /* Write out the output symbols we have just constructed. */
4619 if (outsym
> flaginfo
->output_syms
)
4623 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0)
4625 size
= outsym
- flaginfo
->output_syms
;
4626 size
*= EXTERNAL_NLIST_SIZE
;
4627 if (bfd_bwrite ((void *) flaginfo
->output_syms
, size
, output_bfd
) != size
)
4629 flaginfo
->symoff
+= size
;
4635 /* Write out a symbol that was not associated with an a.out input
4639 bfd_getp32 (const void *p
)
4641 const bfd_byte
*addr
= p
;
4644 v
= (unsigned long) addr
[1] << 24;
4645 v
|= (unsigned long) addr
[0] << 16;
4646 v
|= (unsigned long) addr
[3] << 8;
4647 v
|= (unsigned long) addr
[2];
4651 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
4653 static bfd_signed_vma
4654 bfd_getp_signed_32 (const void *p
)
4656 const bfd_byte
*addr
= p
;
4659 v
= (unsigned long) addr
[1] << 24;
4660 v
|= (unsigned long) addr
[0] << 16;
4661 v
|= (unsigned long) addr
[3] << 8;
4662 v
|= (unsigned long) addr
[2];
4663 return COERCE32 (v
);
4667 bfd_putp32 (bfd_vma data
, void *p
)
4671 addr
[0] = (data
>> 16) & 0xff;
4672 addr
[1] = (data
>> 24) & 0xff;
4673 addr
[2] = (data
>> 0) & 0xff;
4674 addr
[3] = (data
>> 8) & 0xff;
4677 const bfd_target
MY (vec
) =
4679 TARGETNAME
, /* Name. */
4680 bfd_target_aout_flavour
,
4681 BFD_ENDIAN_LITTLE
, /* Target byte order (little). */
4682 BFD_ENDIAN_LITTLE
, /* Target headers byte order (little). */
4683 (HAS_RELOC
| EXEC_P
| /* Object flags. */
4684 HAS_LINENO
| HAS_DEBUG
|
4685 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
),
4686 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_CODE
| SEC_DATA
),
4687 MY_symbol_leading_char
,
4688 AR_PAD_CHAR
, /* AR_pad_char. */
4689 15, /* AR_max_namelen. */
4690 0, /* match priority. */
4691 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4692 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4693 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Data. */
4694 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4695 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4696 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Headers. */
4697 { /* bfd_check_format. */
4700 bfd_generic_archive_p
,
4703 { /* bfd_set_format. */
4704 _bfd_bool_bfd_false_error
,
4706 _bfd_generic_mkarchive
,
4707 _bfd_bool_bfd_false_error
4709 { /* bfd_write_contents. */
4710 _bfd_bool_bfd_false_error
,
4711 MY_write_object_contents
,
4712 _bfd_write_archive_contents
,
4713 _bfd_bool_bfd_false_error
4716 BFD_JUMP_TABLE_GENERIC (MY
),
4717 BFD_JUMP_TABLE_COPY (MY
),
4718 BFD_JUMP_TABLE_CORE (MY
),
4719 BFD_JUMP_TABLE_ARCHIVE (MY
),
4720 BFD_JUMP_TABLE_SYMBOLS (MY
),
4721 BFD_JUMP_TABLE_RELOCS (MY
),
4722 BFD_JUMP_TABLE_WRITE (MY
),
4723 BFD_JUMP_TABLE_LINK (MY
),
4724 BFD_JUMP_TABLE_DYNAMIC (MY
),
4726 /* Alternative_target. */
4729 (void *) MY_backend_data