1 /* BFD back-end for PDP-11 a.out binaries.
2 Copyright (C) 2001-2020 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
22 /* BFD backend for PDP-11, running 2.11BSD in particular.
24 This file was hacked up by looking hard at the existing vaxnetbsd
25 back end and the header files in 2.11BSD.
28 * support for V7 file formats
29 * support for overlay object files (see 2.11 a.out(5))
30 * support for old and very old archives
31 (see 2.11 ar(5), historical section)
33 Search for TODO to find other areas needing more work. */
35 #define BYTES_IN_WORD 2
36 #define BYTES_IN_LONG 4
38 #undef TARGET_IS_BIG_ENDIAN_P
40 #define TARGET_PAGE_SIZE 8192
41 #define SEGMENT__SIZE TARGET_PAGE_SIZE
43 #define DEFAULT_ARCH bfd_arch_pdp11
44 #define DEFAULT_MID M_PDP11
46 /* Do not "beautify" the CONCAT* macro args. Traditional C will not
47 remove whitespace added here, and thus will fail to concatenate
49 #define MY(OP) CONCAT2 (pdp11_aout_,OP)
51 /* This needs to start with a.out so GDB knows it is an a.out variant. */
52 #define TARGETNAME "a.out-pdp11"
54 /* This is the normal load address for executables. */
55 #define TEXT_START_ADDR 0
57 /* The header is not included in the text segment. */
58 #define N_HEADER_IN_TEXT(x) 0
60 /* There is no flags field. */
61 #define N_FLAGS(execp) 0
63 #define N_SET_FLAGS(execp, flags) do { } while (0)
64 #define N_BADMAG(x) (N_MAGIC(x) != OMAGIC \
65 && N_MAGIC(x) != NMAGIC \
66 && N_MAGIC(x) != ZMAGIC)
72 #define external_exec pdp11_external_exec
73 struct pdp11_external_exec
75 bfd_byte e_info
[2]; /* Magic number. */
76 bfd_byte e_text
[2]; /* Length of text section in bytes. */
77 bfd_byte e_data
[2]; /* Length of data section in bytes. */
78 bfd_byte e_bss
[2]; /* Length of bss area in bytes. */
79 bfd_byte e_syms
[2]; /* Length of symbol table in bytes. */
80 bfd_byte e_entry
[2]; /* Start address. */
81 bfd_byte e_unused
[2]; /* Not used. */
82 bfd_byte e_flag
[2]; /* Relocation info stripped. */
83 bfd_byte e_relocatable
; /* Ugly hack. */
86 #define EXEC_BYTES_SIZE (8 * 2)
88 #define A_MAGIC1 OMAGIC
89 #define OMAGIC 0407 /* ...object file or impure executable. */
90 #define A_MAGIC2 NMAGIC
91 #define NMAGIC 0410 /* Pure executable. */
92 #define ZMAGIC 0413 /* Demand-paged executable. */
93 #define A_MAGIC3 0411 /* Separated I&D. */
94 #define A_MAGIC4 0405 /* Overlay. */
95 #define A_MAGIC5 0430 /* Auto-overlay (nonseparate). */
96 #define A_MAGIC6 0431 /* Auto-overlay (separate). */
100 #define A_FLAG_RELOC_STRIPPED 0x0001
102 #define external_nlist pdp11_external_nlist
103 struct pdp11_external_nlist
105 bfd_byte e_unused
[2]; /* Unused. */
106 bfd_byte e_strx
[2]; /* Index into string table of name. */
107 bfd_byte e_type
[1]; /* Type of symbol. */
108 bfd_byte e_ovly
[1]; /* Overlay number. */
109 bfd_byte e_value
[2]; /* Value of symbol. */
112 #define EXTERNAL_NLIST_SIZE 8
114 #define N_TXTOFF(x) (EXEC_BYTES_SIZE)
115 #define N_DATOFF(x) (N_TXTOFF(x) + (x)->a_text)
116 #define N_TRELOFF(x) (N_DATOFF(x) + (x)->a_data)
117 #define N_DRELOFF(x) (N_TRELOFF(x) + (x)->a_trsize)
118 #define N_SYMOFF(x) (N_DRELOFF(x) + (x)->a_drsize)
119 #define N_STROFF(x) (N_SYMOFF(x) + (x)->a_syms)
121 #define WRITE_HEADERS(abfd, execp) pdp11_aout_write_headers (abfd, execp)
126 #define SWAP_MAGIC(ext) bfd_getl16 (ext)
128 #define MY_entry_is_text_address 1
130 #define MY_write_object_contents MY(write_object_contents)
131 static bfd_boolean
MY(write_object_contents
) (bfd
*);
132 #define MY_text_includes_header 1
134 #define MY_BFD_TARGET
136 #include "aout-target.h"
138 /* Start of modified aoutx.h. */
139 #define KEEPIT udata.i
141 #include <string.h> /* For strchr and friends. */
144 #include "safe-ctype.h"
148 #include "aout/aout64.h"
149 #include "aout/stab_gnu.h"
161 #define N_TYPE 0x1f /* Type mask. */
162 #define N_UNDF 0x00 /* Undefined. */
163 #define N_ABS 0x01 /* Absolute. */
164 #define N_TEXT 0x02 /* Text segment. */
165 #define N_DATA 0x03 /* Data segment. */
166 #define N_BSS 0x04 /* Bss segment. */
167 #define N_REG 0x14 /* Register symbol. */
168 #define N_FN 0x1f /* File name. */
169 #define N_EXT 0x20 /* External flag. */
173 #define RELFLG 0x0001 /* PC-relative flag. */
174 #define RTYPE 0x000e /* Type mask. */
175 #define RIDXMASK 0xfff0 /* Index mask. */
177 #define RABS 0x00 /* Absolute. */
178 #define RTEXT 0x02 /* Text. */
179 #define RDATA 0x04 /* Data. */
180 #define RBSS 0x06 /* Bss. */
181 #define REXT 0x08 /* External. */
183 #define RINDEX(x) (((x) & 0xfff0) >> 4)
185 #ifndef MY_final_link_relocate
186 #define MY_final_link_relocate _bfd_final_link_relocate
189 #ifndef MY_relocate_contents
190 #define MY_relocate_contents _bfd_relocate_contents
193 /* A hash table used for header files with N_BINCL entries. */
195 struct aout_link_includes_table
197 struct bfd_hash_table root
;
200 /* A linked list of totals that we have found for a particular header
203 struct aout_link_includes_totals
205 struct aout_link_includes_totals
*next
;
209 /* An entry in the header file hash table. */
211 struct aout_link_includes_entry
213 struct bfd_hash_entry root
;
214 /* List of totals we have found for this file. */
215 struct aout_link_includes_totals
*totals
;
218 /* During the final link step we need to pass around a bunch of
219 information, so we do it in an instance of this structure. */
221 struct aout_final_link_info
223 /* General link information. */
224 struct bfd_link_info
*info
;
227 /* Reloc file positions. */
228 file_ptr treloff
, dreloff
;
229 /* File position of symbols. */
232 struct bfd_strtab_hash
*strtab
;
233 /* Header file hash table. */
234 struct aout_link_includes_table includes
;
235 /* A buffer large enough to hold the contents of any section. */
237 /* A buffer large enough to hold the relocs of any section. */
239 /* A buffer large enough to hold the symbol map of any input BFD. */
241 /* A buffer large enough to hold output symbols of any input BFD. */
242 struct external_nlist
*output_syms
;
245 reloc_howto_type howto_table_pdp11
[] =
247 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
248 HOWTO( 0, 0, 1, 16, FALSE
, 0, complain_overflow_signed
,0,"16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
249 HOWTO( 1, 0, 1, 16, TRUE
, 0, complain_overflow_signed
,0,"DISP16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
252 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
255 static bfd_boolean
aout_link_check_archive_element (bfd
*, struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *, bfd_boolean
*);
256 static bfd_boolean
aout_link_add_object_symbols (bfd
*, struct bfd_link_info
*);
257 static bfd_boolean
aout_link_add_symbols (bfd
*, struct bfd_link_info
*);
258 static bfd_boolean
aout_link_write_symbols (struct aout_final_link_info
*, bfd
*);
262 NAME (aout
, reloc_type_lookup
) (bfd
* abfd ATTRIBUTE_UNUSED
,
263 bfd_reloc_code_real_type code
)
268 return &howto_table_pdp11
[0];
269 case BFD_RELOC_16_PCREL
:
270 return &howto_table_pdp11
[1];
277 NAME (aout
, reloc_name_lookup
) (bfd
*abfd ATTRIBUTE_UNUSED
,
283 i
< sizeof (howto_table_pdp11
) / sizeof (howto_table_pdp11
[0]);
285 if (howto_table_pdp11
[i
].name
!= NULL
286 && strcasecmp (howto_table_pdp11
[i
].name
, r_name
) == 0)
287 return &howto_table_pdp11
[i
];
293 pdp11_aout_write_headers (bfd
*abfd
, struct internal_exec
*execp
)
295 struct external_exec exec_bytes
;
297 if (adata(abfd
).magic
== undecided_magic
)
298 NAME (aout
, adjust_sizes_and_vmas
) (abfd
);
300 execp
->a_syms
= bfd_get_symcount (abfd
) * EXTERNAL_NLIST_SIZE
;
301 execp
->a_entry
= bfd_get_start_address (abfd
);
303 if (obj_textsec (abfd
)->reloc_count
> 0
304 || obj_datasec (abfd
)->reloc_count
> 0)
306 execp
->a_trsize
= execp
->a_text
;
307 execp
->a_drsize
= execp
->a_data
;
315 NAME (aout
, swap_exec_header_out
) (abfd
, execp
, & exec_bytes
);
317 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
320 if (bfd_bwrite ((void *) &exec_bytes
, (bfd_size_type
) EXEC_BYTES_SIZE
, abfd
)
324 /* Now write out reloc info, followed by syms and strings. */
325 if (bfd_get_outsymbols (abfd
) != NULL
326 && bfd_get_symcount (abfd
) != 0)
328 if (bfd_seek (abfd
, (file_ptr
) (N_SYMOFF (execp
)), SEEK_SET
) != 0)
331 if (! NAME (aout
, write_syms
) (abfd
))
335 if (obj_textsec (abfd
)->reloc_count
> 0
336 || obj_datasec (abfd
)->reloc_count
> 0)
338 if (bfd_seek (abfd
, (file_ptr
) (N_TRELOFF (execp
)), SEEK_SET
) != 0
339 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_textsec (abfd
))
340 || bfd_seek (abfd
, (file_ptr
) (N_DRELOFF (execp
)), SEEK_SET
) != 0
341 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_datasec (abfd
)))
348 /* Write an object file.
349 Section contents have already been written. We write the
350 file header, symbols, and relocation. */
353 MY(write_object_contents
) (bfd
*abfd
)
355 struct internal_exec
*execp
= exec_hdr (abfd
);
357 /* We must make certain that the magic number has been set. This
358 will normally have been done by set_section_contents, but only if
359 there actually are some section contents. */
360 if (! abfd
->output_has_begun
)
361 NAME (aout
, adjust_sizes_and_vmas
) (abfd
);
363 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
365 return WRITE_HEADERS (abfd
, execp
);
368 /* Swap the information in an executable header @var{raw_bytes} taken
369 from a raw byte stream memory image into the internal exec header
370 structure "execp". */
372 #ifndef NAME_swap_exec_header_in
374 NAME (aout
, swap_exec_header_in
) (bfd
*abfd
,
375 struct external_exec
*bytes
,
376 struct internal_exec
*execp
)
378 /* The internal_exec structure has some fields that are unused in this
379 configuration (IE for i960), so ensure that all such uninitialized
380 fields are zero'd out. There are places where two of these structs
381 are memcmp'd, and thus the contents do matter. */
382 memset ((void *) execp
, 0, sizeof (struct internal_exec
));
383 /* Now fill in fields in the execp, from the bytes in the raw data. */
384 execp
->a_info
= GET_MAGIC (abfd
, bytes
->e_info
);
385 execp
->a_text
= GET_WORD (abfd
, bytes
->e_text
);
386 execp
->a_data
= GET_WORD (abfd
, bytes
->e_data
);
387 execp
->a_bss
= GET_WORD (abfd
, bytes
->e_bss
);
388 execp
->a_syms
= GET_WORD (abfd
, bytes
->e_syms
);
389 execp
->a_entry
= GET_WORD (abfd
, bytes
->e_entry
);
391 if (GET_WORD (abfd
, bytes
->e_flag
) & A_FLAG_RELOC_STRIPPED
)
398 execp
->a_trsize
= execp
->a_text
;
399 execp
->a_drsize
= execp
->a_data
;
402 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
405 /* Swap the information in an internal exec header structure
406 "execp" into the buffer "bytes" ready for writing to disk. */
408 NAME (aout
, swap_exec_header_out
) (bfd
*abfd
,
409 struct internal_exec
*execp
,
410 struct external_exec
*bytes
)
412 /* Now fill in fields in the raw data, from the fields in the exec struct. */
413 PUT_MAGIC (abfd
, execp
->a_info
, bytes
->e_info
);
414 PUT_WORD (abfd
, execp
->a_text
, bytes
->e_text
);
415 PUT_WORD (abfd
, execp
->a_data
, bytes
->e_data
);
416 PUT_WORD (abfd
, execp
->a_bss
, bytes
->e_bss
);
417 PUT_WORD (abfd
, execp
->a_syms
, bytes
->e_syms
);
418 PUT_WORD (abfd
, execp
->a_entry
, bytes
->e_entry
);
419 PUT_WORD (abfd
, 0, bytes
->e_unused
);
421 if ((execp
->a_trsize
== 0 || execp
->a_text
== 0)
422 && (execp
->a_drsize
== 0 || execp
->a_data
== 0))
423 PUT_WORD (abfd
, A_FLAG_RELOC_STRIPPED
, bytes
->e_flag
);
424 else if (execp
->a_trsize
== execp
->a_text
425 && execp
->a_drsize
== execp
->a_data
)
426 PUT_WORD (abfd
, 0, bytes
->e_flag
);
429 /* TODO: print a proper warning message. */
430 fprintf (stderr
, "BFD:%s:%d: internal error\n", __FILE__
, __LINE__
);
431 PUT_WORD (abfd
, 0, bytes
->e_flag
);
435 /* Make all the section for an a.out file. */
438 NAME (aout
, make_sections
) (bfd
*abfd
)
440 if (obj_textsec (abfd
) == NULL
&& bfd_make_section (abfd
, ".text") == NULL
)
442 if (obj_datasec (abfd
) == NULL
&& bfd_make_section (abfd
, ".data") == NULL
)
444 if (obj_bsssec (abfd
) == NULL
&& bfd_make_section (abfd
, ".bss") == NULL
)
449 /* Some a.out variant thinks that the file open in ABFD
450 checking is an a.out file. Do some more checking, and set up
451 for access if it really is. Call back to the calling
452 environment's "finish up" function just before returning, to
453 handle any last-minute setup. */
456 NAME (aout
, some_aout_object_p
) (bfd
*abfd
,
457 struct internal_exec
*execp
,
458 bfd_cleanup (*callback_to_real_object_p
) (bfd
*))
460 struct aout_data_struct
*rawptr
, *oldrawptr
;
462 size_t amt
= sizeof (struct aout_data_struct
);
464 rawptr
= bfd_zalloc (abfd
, amt
);
468 oldrawptr
= abfd
->tdata
.aout_data
;
469 abfd
->tdata
.aout_data
= rawptr
;
471 /* Copy the contents of the old tdata struct. */
472 if (oldrawptr
!= NULL
)
473 *abfd
->tdata
.aout_data
= *oldrawptr
;
475 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
476 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
; /* Copy in the internal_exec struct. */
477 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
479 /* Set the file flags. */
480 abfd
->flags
= BFD_NO_FLAGS
;
481 if (execp
->a_drsize
|| execp
->a_trsize
)
482 abfd
->flags
|= HAS_RELOC
;
483 /* Setting of EXEC_P has been deferred to the bottom of this function. */
485 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
486 if (N_DYNAMIC (execp
))
487 abfd
->flags
|= DYNAMIC
;
489 if (N_MAGIC (execp
) == ZMAGIC
)
491 abfd
->flags
|= D_PAGED
| WP_TEXT
;
492 adata (abfd
).magic
= z_magic
;
494 else if (N_MAGIC (execp
) == NMAGIC
)
496 abfd
->flags
|= WP_TEXT
;
497 adata (abfd
).magic
= n_magic
;
499 else if (N_MAGIC (execp
) == OMAGIC
)
500 adata (abfd
).magic
= o_magic
;
503 /* Should have been checked with N_BADMAG before this routine
508 abfd
->start_address
= execp
->a_entry
;
510 obj_aout_symbols (abfd
) = NULL
;
511 abfd
->symcount
= execp
->a_syms
/ sizeof (struct external_nlist
);
513 /* The default relocation entry size is that of traditional V7 Unix. */
514 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
516 /* The default symbol entry size is that of traditional Unix. */
517 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
520 bfd_init_window (&obj_aout_sym_window (abfd
));
521 bfd_init_window (&obj_aout_string_window (abfd
));
524 obj_aout_external_syms (abfd
) = NULL
;
525 obj_aout_external_strings (abfd
) = NULL
;
526 obj_aout_sym_hashes (abfd
) = NULL
;
528 if (! NAME (aout
, make_sections
) (abfd
))
531 obj_datasec (abfd
)->size
= execp
->a_data
;
532 obj_bsssec (abfd
)->size
= execp
->a_bss
;
534 obj_textsec (abfd
)->flags
=
535 (execp
->a_trsize
!= 0
536 ? (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_RELOC
)
537 : (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
));
538 obj_datasec (abfd
)->flags
=
539 (execp
->a_drsize
!= 0
540 ? (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_RELOC
)
541 : (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
));
542 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
544 #ifdef THIS_IS_ONLY_DOCUMENTATION
545 /* The common code can't fill in these things because they depend
546 on either the start address of the text segment, the rounding
547 up of virtual addresses between segments, or the starting file
548 position of the text segment -- all of which varies among different
549 versions of a.out. */
551 /* Call back to the format-dependent code to fill in the rest of the
552 fields and do any further cleanup. Things that should be filled
553 in by the callback: */
554 struct exec
*execp
= exec_hdr (abfd
);
556 obj_textsec (abfd
)->size
= N_TXTSIZE (execp
);
557 /* Data and bss are already filled in since they're so standard. */
559 /* The virtual memory addresses of the sections. */
560 obj_textsec (abfd
)->vma
= N_TXTADDR (execp
);
561 obj_datasec (abfd
)->vma
= N_DATADDR (execp
);
562 obj_bsssec (abfd
)->vma
= N_BSSADDR (execp
);
564 /* The file offsets of the sections. */
565 obj_textsec (abfd
)->filepos
= N_TXTOFF (execp
);
566 obj_datasec (abfd
)->filepos
= N_DATOFF (execp
);
568 /* The file offsets of the relocation info. */
569 obj_textsec (abfd
)->rel_filepos
= N_TRELOFF (execp
);
570 obj_datasec (abfd
)->rel_filepos
= N_DRELOFF (execp
);
572 /* The file offsets of the string table and symbol table. */
573 obj_str_filepos (abfd
) = N_STROFF (execp
);
574 obj_sym_filepos (abfd
) = N_SYMOFF (execp
);
576 /* Determine the architecture and machine type of the object file. */
577 abfd
->obj_arch
= bfd_arch_obscure
;
579 adata(abfd
)->page_size
= TARGET_PAGE_SIZE
;
580 adata(abfd
)->segment_size
= SEGMENT_SIZE
;
581 adata(abfd
)->exec_bytes_size
= EXEC_BYTES_SIZE
;
583 return _bfd_no_cleanup
;
585 /* The architecture is encoded in various ways in various a.out variants,
586 or is not encoded at all in some of them. The relocation size depends
587 on the architecture and the a.out variant. Finally, the return value
588 is the bfd_target vector in use. If an error occurs, return zero and
589 set bfd_error to the appropriate error code.
591 Formats such as b.out, which have additional fields in the a.out
592 header, should cope with them in this callback as well. */
593 #endif /* DOCUMENTATION */
595 cleanup
= (*callback_to_real_object_p
)(abfd
);
597 /* Now that the segment addresses have been worked out, take a better
598 guess at whether the file is executable. If the entry point
599 is within the text segment, assume it is. (This makes files
600 executable even if their entry point address is 0, as long as
601 their text starts at zero.).
603 This test had to be changed to deal with systems where the text segment
604 runs at a different location than the default. The problem is that the
605 entry address can appear to be outside the text segment, thus causing an
606 erroneous conclusion that the file isn't executable.
608 To fix this, we now accept any non-zero entry point as an indication of
609 executability. This will work most of the time, since only the linker
610 sets the entry point, and that is likely to be non-zero for most systems. */
612 if (execp
->a_entry
!= 0
613 || (execp
->a_entry
>= obj_textsec(abfd
)->vma
614 && execp
->a_entry
< obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->size
))
615 abfd
->flags
|= EXEC_P
;
619 struct stat stat_buf
;
621 /* The original heuristic doesn't work in some important cases.
622 The a.out file has no information about the text start
623 address. For files (like kernels) linked to non-standard
624 addresses (ld -Ttext nnn) the entry point may not be between
625 the default text start (obj_textsec(abfd)->vma) and
626 (obj_textsec(abfd)->vma) + text size. This is not just a mach
627 issue. Many kernels are loaded at non standard addresses. */
628 if (abfd
->iostream
!= NULL
629 && (abfd
->flags
& BFD_IN_MEMORY
) == 0
630 && (fstat(fileno((FILE *) (abfd
->iostream
)), &stat_buf
) == 0)
631 && ((stat_buf
.st_mode
& 0111) != 0))
632 abfd
->flags
|= EXEC_P
;
634 #endif /* STAT_FOR_EXEC */
639 abfd
->tdata
.aout_data
= oldrawptr
;
644 /* Initialize ABFD for use with a.out files. */
647 NAME (aout
, mkobject
) (bfd
*abfd
)
649 struct aout_data_struct
*rawptr
;
650 size_t amt
= sizeof (struct aout_data_struct
);
652 bfd_set_error (bfd_error_system_call
);
654 /* Use an intermediate variable for clarity. */
655 rawptr
= bfd_zalloc (abfd
, amt
);
660 abfd
->tdata
.aout_data
= rawptr
;
661 exec_hdr (abfd
) = &(rawptr
->e
);
663 obj_textsec (abfd
) = NULL
;
664 obj_datasec (abfd
) = NULL
;
665 obj_bsssec (abfd
) = NULL
;
670 /* Keep track of machine architecture and machine type for
671 a.out's. Return the <<machine_type>> for a particular
672 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
673 and machine can't be represented in a.out format.
675 If the architecture is understood, machine type 0 (default)
676 is always understood. */
679 NAME (aout
, machine_type
) (enum bfd_architecture arch
,
680 unsigned long machine
,
681 bfd_boolean
*unknown
)
683 enum machine_type arch_flags
;
685 arch_flags
= M_UNKNOWN
;
692 || machine
== bfd_mach_sparc
693 || machine
== bfd_mach_sparc_sparclite
694 || machine
== bfd_mach_sparc_v9
)
695 arch_flags
= M_SPARC
;
696 else if (machine
== bfd_mach_sparc_sparclet
)
697 arch_flags
= M_SPARCLET
;
702 || machine
== bfd_mach_i386_i386
703 || machine
== bfd_mach_i386_i386_intel_syntax
)
708 if (machine
== 0) arch_flags
= M_ARM
;
716 case bfd_mach_mips3000
:
717 arch_flags
= M_MIPS1
;
719 case bfd_mach_mips4000
: /* MIPS3 */
720 case bfd_mach_mips4400
:
721 case bfd_mach_mips8000
: /* MIPS4 */
722 case bfd_mach_mips6000
: /* Real MIPS2: */
723 arch_flags
= M_MIPS2
;
726 arch_flags
= M_UNKNOWN
;
734 case 0: arch_flags
= M_NS32532
; break;
735 case 32032: arch_flags
= M_NS32032
; break;
736 case 32532: arch_flags
= M_NS32532
; break;
737 default: arch_flags
= M_UNKNOWN
; break;
742 /* TODO: arch_flags = M_PDP11; */
751 arch_flags
= M_UNKNOWN
;
754 if (arch_flags
!= M_UNKNOWN
)
760 /* Set the architecture and the machine of the ABFD to the
761 values ARCH and MACHINE. Verify that @ABFD's format
762 can support the architecture required. */
765 NAME (aout
, set_arch_mach
) (bfd
*abfd
,
766 enum bfd_architecture arch
,
767 unsigned long machine
)
769 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
772 if (arch
!= bfd_arch_unknown
)
776 NAME (aout
, machine_type
) (arch
, machine
, &unknown
);
781 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
783 return (*aout_backend_info(abfd
)->set_sizes
) (abfd
);
787 adjust_o_magic (bfd
*abfd
, struct internal_exec
*execp
)
789 file_ptr pos
= adata (abfd
).exec_bytes_size
;
792 asection
*text
= obj_textsec (abfd
);
793 asection
*data
= obj_datasec (abfd
);
794 asection
*bss
= obj_bsssec (abfd
);
798 if (!text
->user_set_vma
)
803 pos
+= execp
->a_text
;
804 vma
+= execp
->a_text
;
807 if (!data
->user_set_vma
)
815 execp
->a_text
+= pad
;
822 if (!bss
->user_set_vma
)
830 /* The VMA of the .bss section is set by the VMA of the
831 .data section plus the size of the .data section. We may
832 need to add padding bytes to make this true. */
833 pad
= bss
->vma
- vma
;
838 execp
->a_data
= data
->size
+ pad
;
840 execp
->a_bss
= bss
->size
;
842 N_SET_MAGIC (execp
, OMAGIC
);
846 adjust_z_magic (bfd
*abfd
, struct internal_exec
*execp
)
848 bfd_size_type data_pad
, text_pad
;
850 const struct aout_backend_data
*abdp
;
851 /* TRUE if text includes exec header. */
853 asection
*text
= obj_textsec (abfd
);
854 asection
*data
= obj_datasec (abfd
);
855 asection
*bss
= obj_bsssec (abfd
);
857 abdp
= aout_backend_info (abfd
);
861 && (abdp
->text_includes_header
862 || obj_aout_subformat (abfd
) == q_magic_format
));
863 text
->filepos
= (ztih
864 ? adata (abfd
).exec_bytes_size
865 : adata (abfd
).zmagic_disk_block_size
);
866 if (!text
->user_set_vma
)
868 /* ?? Do we really need to check for relocs here? */
869 text
->vma
= ((abfd
->flags
& HAS_RELOC
)
872 ? abdp
->default_text_vma
+ adata (abfd
).exec_bytes_size
873 : abdp
->default_text_vma
));
878 /* The .text section is being loaded at an unusual address. We
879 may need to pad it such that the .data section starts at a page
882 text_pad
= ((text
->filepos
- text
->vma
)
883 & (adata (abfd
).page_size
- 1));
885 text_pad
= (-text
->vma
886 & (adata (abfd
).page_size
- 1));
889 /* Find start of data. */
892 text_end
= text
->filepos
+ execp
->a_text
;
893 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
897 /* Note that if page_size == zmagic_disk_block_size, then
898 filepos == page_size, and this case is the same as the ztih
900 text_end
= execp
->a_text
;
901 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
902 text_end
+= text
->filepos
;
904 execp
->a_text
+= text_pad
;
907 if (!data
->user_set_vma
)
910 vma
= text
->vma
+ execp
->a_text
;
911 data
->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
913 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
915 text_pad
= data
->vma
- (text
->vma
+ execp
->a_text
);
916 /* Only pad the text section if the data
917 section is going to be placed after it. */
919 execp
->a_text
+= text_pad
;
921 data
->filepos
= text
->filepos
+ execp
->a_text
;
923 /* Fix up exec header while we're at it. */
924 if (ztih
&& (!abdp
|| (abdp
&& !abdp
->exec_header_not_counted
)))
925 execp
->a_text
+= adata (abfd
).exec_bytes_size
;
926 N_SET_MAGIC (execp
, ZMAGIC
);
928 /* Spec says data section should be rounded up to page boundary. */
929 execp
->a_data
= align_power (data
->size
, bss
->alignment_power
);
930 execp
->a_data
= BFD_ALIGN (execp
->a_data
, adata (abfd
).page_size
);
931 data_pad
= execp
->a_data
- data
->size
;
934 if (!bss
->user_set_vma
)
935 bss
->vma
= data
->vma
+ execp
->a_data
;
936 /* If the BSS immediately follows the data section and extra space
937 in the page is left after the data section, fudge data
938 in the header so that the bss section looks smaller by that
939 amount. We'll start the bss section there, and lie to the OS.
940 (Note that a linker script, as well as the above assignment,
941 could have explicitly set the BSS vma to immediately follow
942 the data section.) */
943 if (align_power (bss
->vma
, bss
->alignment_power
) == data
->vma
+ execp
->a_data
)
944 execp
->a_bss
= data_pad
> bss
->size
? 0 : bss
->size
- data_pad
;
946 execp
->a_bss
= bss
->size
;
950 adjust_n_magic (bfd
*abfd
, struct internal_exec
*execp
)
952 file_ptr pos
= adata (abfd
).exec_bytes_size
;
955 asection
*text
= obj_textsec (abfd
);
956 asection
*data
= obj_datasec (abfd
);
957 asection
*bss
= obj_bsssec (abfd
);
961 if (!text
->user_set_vma
)
965 pos
+= execp
->a_text
;
966 vma
+= execp
->a_text
;
970 if (!data
->user_set_vma
)
971 data
->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
974 /* Since BSS follows data immediately, see if it needs alignment. */
976 pad
= align_power (vma
, bss
->alignment_power
) - vma
;
977 execp
->a_data
= data
->size
+ pad
;
978 pos
+= execp
->a_data
;
981 if (!bss
->user_set_vma
)
986 /* Fix up exec header. */
987 execp
->a_bss
= bss
->size
;
988 N_SET_MAGIC (execp
, NMAGIC
);
992 NAME (aout
, adjust_sizes_and_vmas
) (bfd
*abfd
)
994 struct internal_exec
*execp
= exec_hdr (abfd
);
996 if (! NAME (aout
, make_sections
) (abfd
))
999 if (adata (abfd
).magic
!= undecided_magic
)
1002 execp
->a_text
= align_power (obj_textsec (abfd
)->size
,
1003 obj_textsec (abfd
)->alignment_power
);
1005 /* Rule (heuristic) for when to pad to a new page. Note that there
1006 are (at least) two ways demand-paged (ZMAGIC) files have been
1007 handled. Most Berkeley-based systems start the text segment at
1008 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1009 segment right after the exec header; the latter is counted in the
1010 text segment size, and is paged in by the kernel with the rest of
1013 /* This perhaps isn't the right way to do this, but made it simpler for me
1014 to understand enough to implement it. Better would probably be to go
1015 right from BFD flags to alignment/positioning characteristics. But the
1016 old code was sloppy enough about handling the flags, and had enough
1017 other magic, that it was a little hard for me to understand. I think
1018 I understand it better now, but I haven't time to do the cleanup this
1021 if (abfd
->flags
& WP_TEXT
)
1022 adata (abfd
).magic
= n_magic
;
1024 adata (abfd
).magic
= o_magic
;
1026 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1028 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1030 switch (adata (abfd
).magic
)
1032 case n_magic
: str
= "NMAGIC"; break;
1033 case o_magic
: str
= "OMAGIC"; break;
1034 case z_magic
: str
= "ZMAGIC"; break;
1039 obj_textsec (abfd
)->vma
, obj_textsec (abfd
)->size
,
1040 obj_textsec (abfd
)->alignment_power
,
1041 obj_datasec (abfd
)->vma
, obj_datasec (abfd
)->size
,
1042 obj_datasec (abfd
)->alignment_power
,
1043 obj_bsssec (abfd
)->vma
, obj_bsssec (abfd
)->size
,
1044 obj_bsssec (abfd
)->alignment_power
);
1048 switch (adata (abfd
).magic
)
1051 adjust_o_magic (abfd
, execp
);
1054 adjust_z_magic (abfd
, execp
);
1057 adjust_n_magic (abfd
, execp
);
1063 #ifdef BFD_AOUT_DEBUG
1064 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1065 obj_textsec (abfd
)->vma
, execp
->a_text
,
1066 obj_textsec (abfd
)->filepos
,
1067 obj_datasec (abfd
)->vma
, execp
->a_data
,
1068 obj_datasec (abfd
)->filepos
,
1069 obj_bsssec (abfd
)->vma
, execp
->a_bss
);
1075 /* Called by the BFD in response to a bfd_make_section request. */
1078 NAME (aout
, new_section_hook
) (bfd
*abfd
, asection
*newsect
)
1080 /* Align to double at least. */
1081 newsect
->alignment_power
= bfd_get_arch_info(abfd
)->section_align_power
;
1083 if (bfd_get_format (abfd
) == bfd_object
)
1085 if (obj_textsec (abfd
) == NULL
1086 && !strcmp (newsect
->name
, ".text"))
1088 obj_textsec(abfd
)= newsect
;
1089 newsect
->target_index
= N_TEXT
;
1091 else if (obj_datasec (abfd
) == NULL
1092 && !strcmp (newsect
->name
, ".data"))
1094 obj_datasec (abfd
) = newsect
;
1095 newsect
->target_index
= N_DATA
;
1097 else if (obj_bsssec (abfd
) == NULL
1098 && !strcmp (newsect
->name
, ".bss"))
1100 obj_bsssec (abfd
) = newsect
;
1101 newsect
->target_index
= N_BSS
;
1105 /* We allow more than three sections internally. */
1106 return _bfd_generic_new_section_hook (abfd
, newsect
);
1110 NAME (aout
, set_section_contents
) (bfd
*abfd
,
1112 const void * location
,
1114 bfd_size_type count
)
1116 if (! abfd
->output_has_begun
)
1118 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
1122 if (section
== obj_bsssec (abfd
))
1124 bfd_set_error (bfd_error_no_contents
);
1128 if (section
!= obj_textsec (abfd
)
1129 && section
!= obj_datasec (abfd
))
1132 /* xgettext:c-format */
1133 (_("%pB: can not represent section `%pA' in a.out object file format"),
1135 bfd_set_error (bfd_error_nonrepresentable_section
);
1141 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
1142 || bfd_bwrite (location
, count
, abfd
) != count
)
1149 /* Read the external symbols from an a.out file. */
1152 aout_get_external_symbols (bfd
*abfd
)
1154 if (obj_aout_external_syms (abfd
) == NULL
)
1156 bfd_size_type count
;
1157 struct external_nlist
*syms
;
1159 count
= exec_hdr (abfd
)->a_syms
/ EXTERNAL_NLIST_SIZE
;
1161 /* PR 17512: file: 011f5a08. */
1164 obj_aout_external_syms (abfd
) = NULL
;
1165 obj_aout_external_sym_count (abfd
) = count
;
1170 if (! bfd_get_file_window (abfd
, obj_sym_filepos (abfd
),
1171 exec_hdr (abfd
)->a_syms
,
1172 &obj_aout_sym_window (abfd
), TRUE
))
1174 syms
= (struct external_nlist
*) obj_aout_sym_window (abfd
).data
;
1176 /* We allocate using malloc to make the values easy to free
1177 later on. If we put them on the objalloc it might not be
1178 possible to free them. */
1179 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1181 syms
= (struct external_nlist
*)
1182 _bfd_malloc_and_read (abfd
, count
* EXTERNAL_NLIST_SIZE
,
1183 count
* EXTERNAL_NLIST_SIZE
);
1184 if (syms
== NULL
&& count
!= 0)
1188 obj_aout_external_syms (abfd
) = syms
;
1189 obj_aout_external_sym_count (abfd
) = count
;
1192 if (obj_aout_external_strings (abfd
) == NULL
1193 && exec_hdr (abfd
)->a_syms
!= 0)
1195 unsigned char string_chars
[BYTES_IN_LONG
];
1196 bfd_size_type stringsize
;
1199 /* Get the size of the strings. */
1200 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
1201 || (bfd_bread ((void *) string_chars
, (bfd_size_type
) BYTES_IN_LONG
,
1202 abfd
) != BYTES_IN_LONG
))
1204 stringsize
= H_GET_32 (abfd
, string_chars
);
1207 if (! bfd_get_file_window (abfd
, obj_str_filepos (abfd
), stringsize
,
1208 &obj_aout_string_window (abfd
), TRUE
))
1210 strings
= (char *) obj_aout_string_window (abfd
).data
;
1212 strings
= bfd_malloc (stringsize
+ 1);
1213 if (strings
== NULL
)
1216 /* Skip space for the string count in the buffer for convenience
1217 when using indexes. */
1218 if (bfd_bread (strings
+ 4, stringsize
- 4, abfd
) != stringsize
- 4)
1224 /* Ensure that a zero index yields an empty string. */
1227 strings
[stringsize
- 1] = 0;
1229 obj_aout_external_strings (abfd
) = strings
;
1230 obj_aout_external_string_size (abfd
) = stringsize
;
1236 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1237 and symbol->value fields of CACHE_PTR will be set from the a.out
1238 nlist structure. This function is responsible for setting
1239 symbol->flags and symbol->section, and adjusting symbol->value. */
1242 translate_from_native_sym_flags (bfd
*abfd
,
1243 aout_symbol_type
*cache_ptr
)
1247 if (cache_ptr
->type
== N_FN
)
1251 /* This is a debugging symbol. */
1252 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1254 /* Work out the symbol section. */
1255 switch (cache_ptr
->type
& N_TYPE
)
1259 sec
= obj_textsec (abfd
);
1262 sec
= obj_datasec (abfd
);
1265 sec
= obj_bsssec (abfd
);
1269 sec
= bfd_abs_section_ptr
;
1273 cache_ptr
->symbol
.section
= sec
;
1274 cache_ptr
->symbol
.value
-= sec
->vma
;
1279 /* Get the default visibility. This does not apply to all types, so
1280 we just hold it in a local variable to use if wanted. */
1281 if ((cache_ptr
->type
& N_EXT
) == 0)
1282 visible
= BSF_LOCAL
;
1284 visible
= BSF_GLOBAL
;
1286 switch (cache_ptr
->type
)
1289 case N_ABS
: case N_ABS
| N_EXT
:
1290 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1291 cache_ptr
->symbol
.flags
= visible
;
1294 case N_UNDF
| N_EXT
:
1295 if (cache_ptr
->symbol
.value
!= 0)
1297 /* This is a common symbol. */
1298 cache_ptr
->symbol
.flags
= BSF_GLOBAL
;
1299 cache_ptr
->symbol
.section
= bfd_com_section_ptr
;
1303 cache_ptr
->symbol
.flags
= 0;
1304 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1308 case N_TEXT
: case N_TEXT
| N_EXT
:
1309 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1310 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1311 cache_ptr
->symbol
.flags
= visible
;
1314 case N_DATA
: case N_DATA
| N_EXT
:
1315 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1316 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1317 cache_ptr
->symbol
.flags
= visible
;
1320 case N_BSS
: case N_BSS
| N_EXT
:
1321 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1322 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1323 cache_ptr
->symbol
.flags
= visible
;
1330 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1333 translate_to_native_sym_flags (bfd
*abfd
,
1335 struct external_nlist
*sym_pointer
)
1337 bfd_vma value
= cache_ptr
->value
;
1341 /* Mask out any existing type bits in case copying from one section
1343 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1345 sec
= bfd_asymbol_section (cache_ptr
);
1350 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1353 /* xgettext:c-format */
1354 (_("%pB: can not represent section for symbol `%s' in a.out object file format"),
1355 abfd
, cache_ptr
->name
!= NULL
? cache_ptr
->name
: "*unknown*");
1356 bfd_set_error (bfd_error_nonrepresentable_section
);
1360 if (sec
->output_section
!= NULL
)
1362 off
= sec
->output_offset
;
1363 sec
= sec
->output_section
;
1366 if (bfd_is_abs_section (sec
))
1367 sym_pointer
->e_type
[0] |= N_ABS
;
1368 else if (sec
== obj_textsec (abfd
))
1369 sym_pointer
->e_type
[0] |= N_TEXT
;
1370 else if (sec
== obj_datasec (abfd
))
1371 sym_pointer
->e_type
[0] |= N_DATA
;
1372 else if (sec
== obj_bsssec (abfd
))
1373 sym_pointer
->e_type
[0] |= N_BSS
;
1374 else if (bfd_is_und_section (sec
))
1375 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1376 else if (bfd_is_com_section (sec
))
1377 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1381 /* xgettext:c-format */
1382 (_("%pB: can not represent section `%pA' in a.out object file format"),
1384 bfd_set_error (bfd_error_nonrepresentable_section
);
1388 /* Turn the symbol from section relative to absolute again */
1389 value
+= sec
->vma
+ off
;
1391 if ((cache_ptr
->flags
& BSF_DEBUGGING
) != 0)
1392 sym_pointer
->e_type
[0] = ((aout_symbol_type
*) cache_ptr
)->type
;
1393 else if ((cache_ptr
->flags
& BSF_GLOBAL
) != 0)
1394 sym_pointer
->e_type
[0] |= N_EXT
;
1396 PUT_WORD(abfd
, value
, sym_pointer
->e_value
);
1401 /* Native-level interface to symbols. */
1404 NAME (aout
, make_empty_symbol
) (bfd
*abfd
)
1406 size_t amt
= sizeof (aout_symbol_type
);
1407 aout_symbol_type
*new_symbol_type
= bfd_zalloc (abfd
, amt
);
1409 if (!new_symbol_type
)
1411 new_symbol_type
->symbol
.the_bfd
= abfd
;
1413 return &new_symbol_type
->symbol
;
1416 /* Translate a set of internal symbols into external symbols. */
1419 NAME (aout
, translate_symbol_table
) (bfd
*abfd
,
1420 aout_symbol_type
*in
,
1421 struct external_nlist
*ext
,
1422 bfd_size_type count
,
1424 bfd_size_type strsize
,
1425 bfd_boolean dynamic
)
1427 struct external_nlist
*ext_end
;
1429 ext_end
= ext
+ count
;
1430 for (; ext
< ext_end
; ext
++, in
++)
1434 x
= GET_WORD (abfd
, ext
->e_strx
);
1435 in
->symbol
.the_bfd
= abfd
;
1437 /* For the normal symbols, the zero index points at the number
1438 of bytes in the string table but is to be interpreted as the
1439 null string. For the dynamic symbols, the number of bytes in
1440 the string table is stored in the __DYNAMIC structure and the
1441 zero index points at an actual string. */
1442 if (x
== 0 && ! dynamic
)
1443 in
->symbol
.name
= "";
1444 else if (x
< strsize
)
1445 in
->symbol
.name
= str
+ x
;
1449 in
->symbol
.value
= GET_SWORD (abfd
, ext
->e_value
);
1450 /* TODO: is 0 a safe value here? */
1453 in
->type
= H_GET_8 (abfd
, ext
->e_type
);
1454 in
->symbol
.udata
.p
= NULL
;
1456 if (! translate_from_native_sym_flags (abfd
, in
))
1460 in
->symbol
.flags
|= BSF_DYNAMIC
;
1466 /* We read the symbols into a buffer, which is discarded when this
1467 function exits. We read the strings into a buffer large enough to
1468 hold them all plus all the cached symbol entries. */
1471 NAME (aout
, slurp_symbol_table
) (bfd
*abfd
)
1473 struct external_nlist
*old_external_syms
;
1474 aout_symbol_type
*cached
;
1475 bfd_size_type cached_size
;
1477 /* If there's no work to be done, don't do any. */
1478 if (obj_aout_symbols (abfd
) != NULL
)
1481 old_external_syms
= obj_aout_external_syms (abfd
);
1483 if (! aout_get_external_symbols (abfd
))
1486 cached_size
= obj_aout_external_sym_count (abfd
);
1487 cached_size
*= sizeof (aout_symbol_type
);
1488 cached
= bfd_zmalloc (cached_size
);
1489 if (cached
== NULL
&& cached_size
!= 0)
1492 /* Convert from external symbol information to internal. */
1493 if (! (NAME (aout
, translate_symbol_table
)
1495 obj_aout_external_syms (abfd
),
1496 obj_aout_external_sym_count (abfd
),
1497 obj_aout_external_strings (abfd
),
1498 obj_aout_external_string_size (abfd
),
1505 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
1507 obj_aout_symbols (abfd
) = cached
;
1509 /* It is very likely that anybody who calls this function will not
1510 want the external symbol information, so if it was allocated
1511 because of our call to aout_get_external_symbols, we free it up
1512 right away to save space. */
1513 if (old_external_syms
== NULL
1514 && obj_aout_external_syms (abfd
) != NULL
)
1517 bfd_free_window (&obj_aout_sym_window (abfd
));
1519 free (obj_aout_external_syms (abfd
));
1521 obj_aout_external_syms (abfd
) = NULL
;
1527 /* We use a hash table when writing out symbols so that we only write
1528 out a particular string once. This helps particularly when the
1529 linker writes out stabs debugging entries, because each different
1530 contributing object file tends to have many duplicate stabs
1533 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1534 if BFD_TRADITIONAL_FORMAT is set. */
1536 /* Get the index of a string in a strtab, adding it if it is not
1539 static INLINE bfd_size_type
1540 add_to_stringtab (bfd
*abfd
,
1541 struct bfd_strtab_hash
*tab
,
1546 bfd_size_type str_index
;
1548 /* An index of 0 always means the empty string. */
1549 if (str
== 0 || *str
== '\0')
1552 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1553 doesn't understand a hashed string table. */
1555 if ((abfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1558 str_index
= _bfd_stringtab_add (tab
, str
, hash
, copy
);
1560 if (str_index
!= (bfd_size_type
) -1)
1561 /* Add BYTES_IN_LONG to the return value to account for the
1562 space taken up by the string table size. */
1563 str_index
+= BYTES_IN_LONG
;
1568 /* Write out a strtab. ABFD is already at the right location in the
1572 emit_stringtab (bfd
*abfd
, struct bfd_strtab_hash
*tab
)
1574 bfd_byte buffer
[BYTES_IN_LONG
];
1576 /* The string table starts with the size. */
1577 H_PUT_32 (abfd
, _bfd_stringtab_size (tab
) + BYTES_IN_LONG
, buffer
);
1578 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) BYTES_IN_LONG
, abfd
)
1582 return _bfd_stringtab_emit (abfd
, tab
);
1586 NAME (aout
, write_syms
) (bfd
*abfd
)
1588 unsigned int count
;
1589 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1590 struct bfd_strtab_hash
*strtab
;
1592 strtab
= _bfd_stringtab_init ();
1596 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1598 asymbol
*g
= generic
[count
];
1600 struct external_nlist nsp
;
1602 PUT_WORD (abfd
, 0, nsp
.e_unused
);
1604 indx
= add_to_stringtab (abfd
, strtab
, g
->name
, FALSE
);
1605 if (indx
== (bfd_size_type
) -1)
1607 PUT_WORD (abfd
, indx
, nsp
.e_strx
);
1609 if (bfd_asymbol_flavour(g
) == abfd
->xvec
->flavour
)
1610 H_PUT_8 (abfd
, aout_symbol(g
)->type
, nsp
.e_type
);
1612 H_PUT_8 (abfd
, 0, nsp
.e_type
);
1614 if (! translate_to_native_sym_flags (abfd
, g
, &nsp
))
1617 H_PUT_8 (abfd
, 0, nsp
.e_ovly
);
1619 if (bfd_bwrite ((void *)&nsp
, (bfd_size_type
) EXTERNAL_NLIST_SIZE
, abfd
)
1620 != EXTERNAL_NLIST_SIZE
)
1623 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1624 here, at the end. */
1628 if (! emit_stringtab (abfd
, strtab
))
1631 _bfd_stringtab_free (strtab
);
1636 _bfd_stringtab_free (strtab
);
1642 NAME (aout
, canonicalize_symtab
) (bfd
*abfd
, asymbol
**location
)
1644 unsigned int counter
= 0;
1645 aout_symbol_type
*symbase
;
1647 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
1650 for (symbase
= obj_aout_symbols (abfd
); counter
++ < bfd_get_symcount (abfd
);)
1651 *(location
++) = (asymbol
*)(symbase
++);
1653 return bfd_get_symcount (abfd
);
1657 /* Output extended relocation information to a file in target byte order. */
1660 pdp11_aout_swap_reloc_out (bfd
*abfd
, arelent
*g
, bfd_byte
*natptr
)
1666 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1667 asection
*output_section
= sym
->section
->output_section
;
1670 fprintf (stderr
, "BFD: can't do this reloc addend stuff\n");
1672 r_pcrel
= g
->howto
->pc_relative
;
1674 if (bfd_is_abs_section (output_section
))
1676 else if (output_section
== obj_textsec (abfd
))
1678 else if (output_section
== obj_datasec (abfd
))
1680 else if (output_section
== obj_bsssec (abfd
))
1682 else if (bfd_is_und_section (output_section
))
1684 else if (bfd_is_com_section (output_section
))
1689 BFD_ASSERT (r_type
!= -1);
1694 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
1696 reloc_entry
= r_index
<< 4 | r_type
| r_pcrel
;
1698 PUT_WORD (abfd
, reloc_entry
, natptr
);
1701 /* BFD deals internally with all things based from the section they're
1702 in. so, something in 10 bytes into a text section with a base of
1703 50 would have a symbol (.text+10) and know .text vma was 50.
1705 Aout keeps all it's symbols based from zero, so the symbol would
1706 contain 60. This macro subs the base of each section from the value
1707 to give the true offset from the section */
1710 #define MOVE_ADDRESS(ad) \
1713 /* Undefined symbol. */ \
1714 cache_ptr->sym_ptr_ptr = symbols + r_index; \
1715 cache_ptr->addend = ad; \
1719 /* Defined, section relative. replace symbol with pointer to \
1720 symbol which points to section. */ \
1724 case N_TEXT | N_EXT: \
1725 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
1726 cache_ptr->addend = ad - su->textsec->vma; \
1729 case N_DATA | N_EXT: \
1730 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
1731 cache_ptr->addend = ad - su->datasec->vma; \
1734 case N_BSS | N_EXT: \
1735 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
1736 cache_ptr->addend = ad - su->bsssec->vma; \
1740 case N_ABS | N_EXT: \
1741 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1742 cache_ptr->addend = ad; \
1748 pdp11_aout_swap_reloc_in (bfd
* abfd
,
1750 arelent
* cache_ptr
,
1751 bfd_size_type offset
,
1753 bfd_size_type symcount
)
1755 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
1756 unsigned int r_index
;
1761 reloc_entry
= GET_WORD (abfd
, (void *) bytes
);
1763 r_pcrel
= reloc_entry
& RELFLG
;
1765 cache_ptr
->address
= offset
;
1766 cache_ptr
->howto
= howto_table_pdp11
+ (r_pcrel
? 1 : 0);
1768 if ((reloc_entry
& RTYPE
) == RABS
)
1771 r_index
= RINDEX (reloc_entry
);
1773 /* r_extern reflects whether the symbol the reloc is against is
1775 r_extern
= (reloc_entry
& RTYPE
) == REXT
;
1777 if (r_extern
&& r_index
> symcount
)
1779 /* We could arrange to return an error, but it might be useful
1780 to see the file even if it is bad. */
1788 /* Read and swap the relocs for a section. */
1791 NAME (aout
, slurp_reloc_table
) (bfd
*abfd
, sec_ptr asect
, asymbol
**symbols
)
1794 bfd_size_type count
;
1795 bfd_size_type reloc_size
;
1797 arelent
*reloc_cache
;
1799 unsigned int counter
= 0;
1802 if (asect
->relocation
)
1805 if (asect
->flags
& SEC_CONSTRUCTOR
)
1808 if (asect
== obj_datasec (abfd
))
1809 reloc_size
= exec_hdr(abfd
)->a_drsize
;
1810 else if (asect
== obj_textsec (abfd
))
1811 reloc_size
= exec_hdr(abfd
)->a_trsize
;
1812 else if (asect
== obj_bsssec (abfd
))
1816 bfd_set_error (bfd_error_invalid_operation
);
1820 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
1822 relocs
= _bfd_malloc_and_read (abfd
, reloc_size
, reloc_size
);
1823 if (relocs
== NULL
&& reloc_size
!= 0)
1826 each_size
= obj_reloc_entry_size (abfd
);
1827 count
= reloc_size
/ each_size
;
1829 /* Count the number of NON-ZERO relocs, this is the count we want. */
1831 unsigned int real_count
= 0;
1833 for (counter
= 0; counter
< count
; counter
++)
1837 x
= GET_WORD (abfd
, (char *) relocs
+ each_size
* counter
);
1845 reloc_cache
= bfd_zmalloc (count
* sizeof (arelent
));
1846 if (reloc_cache
== NULL
&& count
!= 0)
1849 cache_ptr
= reloc_cache
;
1854 counter
++, rptr
+= RELOC_SIZE
, cache_ptr
++)
1856 while (GET_WORD (abfd
, (void *) rptr
) == 0)
1859 if ((char *) rptr
>= (char *) relocs
+ reloc_size
)
1863 pdp11_aout_swap_reloc_in (abfd
, rptr
, cache_ptr
,
1864 (bfd_size_type
) ((char *) rptr
- (char *) relocs
),
1866 (bfd_size_type
) bfd_get_symcount (abfd
));
1869 /* Just in case, if rptr >= relocs + reloc_size should happen
1871 BFD_ASSERT (counter
== count
);
1875 asect
->relocation
= reloc_cache
;
1876 asect
->reloc_count
= cache_ptr
- reloc_cache
;
1881 /* Write out a relocation section into an object file. */
1884 NAME (aout
, squirt_out_relocs
) (bfd
*abfd
, asection
*section
)
1887 unsigned char *native
;
1888 unsigned int count
= section
->reloc_count
;
1889 bfd_size_type natsize
;
1891 natsize
= section
->size
;
1892 native
= bfd_zalloc (abfd
, natsize
);
1896 generic
= section
->orelocation
;
1897 if (generic
!= NULL
)
1903 r
= native
+ (*generic
)->address
;
1904 pdp11_aout_swap_reloc_out (abfd
, *generic
, r
);
1910 if (bfd_bwrite ((void *) native
, natsize
, abfd
) != natsize
)
1912 bfd_release (abfd
, native
);
1916 bfd_release (abfd
, native
);
1920 /* This is stupid. This function should be a boolean predicate. */
1923 NAME (aout
, canonicalize_reloc
) (bfd
*abfd
,
1928 arelent
*tblptr
= section
->relocation
;
1931 if (section
== obj_bsssec (abfd
))
1937 if (!(tblptr
|| NAME (aout
, slurp_reloc_table
)(abfd
, section
, symbols
)))
1940 if (section
->flags
& SEC_CONSTRUCTOR
)
1942 arelent_chain
*chain
= section
->constructor_chain
;
1944 for (count
= 0; count
< section
->reloc_count
; count
++)
1946 *relptr
++ = &chain
->relent
;
1947 chain
= chain
->next
;
1952 tblptr
= section
->relocation
;
1954 for (count
= 0; count
++ < section
->reloc_count
;)
1955 *relptr
++ = tblptr
++;
1960 return section
->reloc_count
;
1964 NAME (aout
, get_reloc_upper_bound
) (bfd
*abfd
, sec_ptr asect
)
1966 bfd_size_type count
;
1968 if (bfd_get_format (abfd
) != bfd_object
)
1970 bfd_set_error (bfd_error_invalid_operation
);
1974 if (asect
->flags
& SEC_CONSTRUCTOR
)
1975 count
= asect
->reloc_count
;
1976 else if (asect
== obj_datasec (abfd
))
1977 count
= exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
1978 else if (asect
== obj_textsec (abfd
))
1979 count
= exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
1980 else if (asect
== obj_bsssec (abfd
))
1984 bfd_set_error (bfd_error_invalid_operation
);
1988 if (count
>= LONG_MAX
/ sizeof (arelent
*))
1990 bfd_set_error (bfd_error_file_too_big
);
1993 return (count
+ 1) * sizeof (arelent
*);
1998 NAME (aout
, get_symtab_upper_bound
) (bfd
*abfd
)
2000 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
2003 return (bfd_get_symcount (abfd
) + 1) * (sizeof (aout_symbol_type
*));
2007 NAME (aout
, get_lineno
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2008 asymbol
* symbol ATTRIBUTE_UNUSED
)
2014 NAME (aout
, get_symbol_info
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2018 bfd_symbol_info (symbol
, ret
);
2020 if (ret
->type
== '?')
2022 int type_code
= aout_symbol(symbol
)->type
& 0xff;
2023 const char *stab_name
= bfd_get_stab_name (type_code
);
2024 static char buf
[10];
2026 if (stab_name
== NULL
)
2028 sprintf(buf
, "(%d)", type_code
);
2032 ret
->stab_type
= type_code
;
2033 ret
->stab_other
= (unsigned) (aout_symbol(symbol
)->other
& 0xff);
2034 ret
->stab_desc
= (unsigned) (aout_symbol(symbol
)->desc
& 0xffff);
2035 ret
->stab_name
= stab_name
;
2040 NAME (aout
, print_symbol
) (bfd
* abfd
,
2043 bfd_print_symbol_type how
)
2045 FILE *file
= (FILE *) afile
;
2049 case bfd_print_symbol_name
:
2051 fprintf(file
,"%s", symbol
->name
);
2053 case bfd_print_symbol_more
:
2054 fprintf(file
,"%4x %2x %2x",
2055 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2056 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2057 (unsigned) (aout_symbol (symbol
)->type
));
2059 case bfd_print_symbol_all
:
2061 const char *section_name
= symbol
->section
->name
;
2063 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2065 fprintf (file
," %-5s %04x %02x %02x",
2067 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2068 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2069 (unsigned) (aout_symbol (symbol
)->type
& 0xff));
2071 fprintf(file
," %s", symbol
->name
);
2077 /* If we don't have to allocate more than 1MB to hold the generic
2078 symbols, we use the generic minisymbol method: it's faster, since
2079 it only translates the symbols once, not multiple times. */
2080 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2082 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2083 symbols. The minisymbol_to_symbol function translates these into
2084 BFD asymbol structures. */
2087 NAME (aout
, read_minisymbols
) (bfd
*abfd
,
2088 bfd_boolean dynamic
,
2090 unsigned int *sizep
)
2093 /* We could handle the dynamic symbols here as well, but it's
2094 easier to hand them off. */
2095 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2097 if (! aout_get_external_symbols (abfd
))
2100 if (obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2101 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2103 *minisymsp
= (void *) obj_aout_external_syms (abfd
);
2105 /* By passing the external symbols back from this routine, we are
2106 giving up control over the memory block. Clear
2107 obj_aout_external_syms, so that we do not try to free it
2109 obj_aout_external_syms (abfd
) = NULL
;
2111 *sizep
= EXTERNAL_NLIST_SIZE
;
2112 return obj_aout_external_sym_count (abfd
);
2115 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2116 unmodified a.out symbol. The SYM argument is a structure returned
2117 by bfd_make_empty_symbol, which we fill in here. */
2120 NAME (aout
, minisymbol_to_symbol
) (bfd
*abfd
,
2121 bfd_boolean dynamic
,
2122 const void * minisym
,
2126 || obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2127 return _bfd_generic_minisymbol_to_symbol (abfd
, dynamic
, minisym
, sym
);
2129 memset (sym
, 0, sizeof (aout_symbol_type
));
2131 /* We call translate_symbol_table to translate a single symbol. */
2132 if (! (NAME (aout
, translate_symbol_table
)
2134 (aout_symbol_type
*) sym
,
2135 (struct external_nlist
*) minisym
,
2137 obj_aout_external_strings (abfd
),
2138 obj_aout_external_string_size (abfd
),
2145 /* Provided a BFD, a section and an offset into the section, calculate
2146 and return the name of the source file and the line nearest to the
2150 NAME (aout
, find_nearest_line
) (bfd
*abfd
,
2154 const char **filename_ptr
,
2155 const char **functionname_ptr
,
2156 unsigned int *line_ptr
,
2157 unsigned int *discriminator_ptr
)
2159 /* Run down the file looking for the filename, function and linenumber. */
2161 const char *directory_name
= NULL
;
2162 const char *main_file_name
= NULL
;
2163 const char *current_file_name
= NULL
;
2164 const char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2165 bfd_vma low_line_vma
= 0;
2166 bfd_vma low_func_vma
= 0;
2168 size_t filelen
, funclen
;
2171 *filename_ptr
= abfd
->filename
;
2172 *functionname_ptr
= 0;
2174 if (discriminator_ptr
)
2175 *discriminator_ptr
= 0;
2177 if (symbols
!= NULL
)
2179 for (p
= symbols
; *p
; p
++)
2181 aout_symbol_type
*q
= (aout_symbol_type
*)(*p
);
2186 /* If this looks like a file name symbol, and it comes after
2187 the line number we have found so far, but before the
2188 offset, then we have probably not found the right line
2190 if (q
->symbol
.value
<= offset
2191 && ((q
->symbol
.value
> low_line_vma
2192 && (line_file_name
!= NULL
2194 || (q
->symbol
.value
> low_func_vma
2197 const char * symname
;
2199 symname
= q
->symbol
.name
;
2200 if (strcmp (symname
+ strlen (symname
) - 2, ".o") == 0)
2202 if (q
->symbol
.value
> low_line_vma
)
2205 line_file_name
= NULL
;
2207 if (q
->symbol
.value
> low_func_vma
)
2214 /* If this symbol is less than the offset, but greater than
2215 the line number we have found so far, then we have not
2216 found the right line number. */
2217 if (q
->symbol
.value
<= offset
)
2219 if (q
->symbol
.value
> low_line_vma
)
2222 line_file_name
= NULL
;
2224 if (q
->symbol
.value
> low_func_vma
)
2228 main_file_name
= current_file_name
= q
->symbol
.name
;
2229 /* Look ahead to next symbol to check if that too is an N_SO. */
2233 q
= (aout_symbol_type
*)(*p
);
2234 if (q
->type
!= (int) N_SO
)
2237 /* Found a second N_SO First is directory; second is filename. */
2238 directory_name
= current_file_name
;
2239 main_file_name
= current_file_name
= q
->symbol
.name
;
2240 if (obj_textsec(abfd
) != section
)
2244 current_file_name
= q
->symbol
.name
;
2250 /* We'll keep this if it resolves nearer than the one we have
2252 if (q
->symbol
.value
>= low_line_vma
2253 && q
->symbol
.value
<= offset
)
2255 *line_ptr
= q
->desc
;
2256 low_line_vma
= q
->symbol
.value
;
2257 line_file_name
= current_file_name
;
2263 /* We'll keep this if it is nearer than the one we have already. */
2264 if (q
->symbol
.value
>= low_func_vma
&&
2265 q
->symbol
.value
<= offset
)
2267 low_func_vma
= q
->symbol
.value
;
2268 func
= (asymbol
*) q
;
2270 else if (q
->symbol
.value
> offset
)
2280 main_file_name
= line_file_name
;
2282 if (main_file_name
== NULL
2283 || main_file_name
[0] == '/'
2284 || directory_name
== NULL
)
2287 filelen
= strlen (directory_name
) + strlen (main_file_name
);
2291 funclen
= strlen (bfd_asymbol_name (func
));
2293 if (adata (abfd
).line_buf
!= NULL
)
2294 free (adata (abfd
).line_buf
);
2295 if (filelen
+ funclen
== 0)
2296 adata (abfd
).line_buf
= buf
= NULL
;
2299 buf
= bfd_malloc ((bfd_size_type
) filelen
+ funclen
+ 3);
2300 adata (abfd
).line_buf
= buf
;
2305 if (main_file_name
!= NULL
)
2307 if (main_file_name
[0] == '/' || directory_name
== NULL
)
2308 *filename_ptr
= main_file_name
;
2311 sprintf (buf
, "%s%s", directory_name
, main_file_name
);
2312 *filename_ptr
= buf
;
2319 const char *function
= func
->name
;
2322 /* The caller expects a symbol name. We actually have a
2323 function name, without the leading underscore. Put the
2324 underscore back in, so that the caller gets a symbol name. */
2325 if (bfd_get_symbol_leading_char (abfd
) == '\0')
2326 strcpy (buf
, function
);
2329 buf
[0] = bfd_get_symbol_leading_char (abfd
);
2330 strcpy (buf
+ 1, function
);
2333 /* Have to remove : stuff. */
2334 colon
= strchr (buf
, ':');
2337 *functionname_ptr
= buf
;
2344 NAME (aout
, sizeof_headers
) (bfd
*abfd
,
2345 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2347 return adata (abfd
).exec_bytes_size
;
2350 /* Free all information we have cached for this BFD. We can always
2351 read it again later if we need it. */
2354 NAME (aout
, bfd_free_cached_info
) (bfd
*abfd
)
2358 if (bfd_get_format (abfd
) != bfd_object
)
2361 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2362 BFCI_FREE (obj_aout_symbols (abfd
));
2365 obj_aout_external_syms (abfd
) = 0;
2366 bfd_free_window (&obj_aout_sym_window (abfd
));
2367 bfd_free_window (&obj_aout_string_window (abfd
));
2368 obj_aout_external_strings (abfd
) = 0;
2370 BFCI_FREE (obj_aout_external_syms (abfd
));
2371 BFCI_FREE (obj_aout_external_strings (abfd
));
2373 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2374 BFCI_FREE (o
->relocation
);
2380 /* Routine to create an entry in an a.out link hash table. */
2382 struct bfd_hash_entry
*
2383 NAME (aout
, link_hash_newfunc
) (struct bfd_hash_entry
*entry
,
2384 struct bfd_hash_table
*table
,
2387 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2389 /* Allocate the structure if it has not already been allocated by a
2392 ret
= bfd_hash_allocate (table
, sizeof (* ret
));
2396 /* Call the allocation method of the superclass. */
2397 ret
= (struct aout_link_hash_entry
*)
2398 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
);
2401 /* Set local fields. */
2402 ret
->written
= FALSE
;
2406 return (struct bfd_hash_entry
*) ret
;
2409 /* Initialize an a.out link hash table. */
2412 NAME (aout
, link_hash_table_init
) (struct aout_link_hash_table
*table
,
2414 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
2415 struct bfd_hash_table
*,
2417 unsigned int entsize
)
2419 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
2422 /* Create an a.out link hash table. */
2424 struct bfd_link_hash_table
*
2425 NAME (aout
, link_hash_table_create
) (bfd
*abfd
)
2427 struct aout_link_hash_table
*ret
;
2428 size_t amt
= sizeof (struct aout_link_hash_table
);
2430 ret
= bfd_malloc (amt
);
2433 if (! NAME (aout
, link_hash_table_init
) (ret
, abfd
,
2434 NAME (aout
, link_hash_newfunc
),
2435 sizeof (struct aout_link_hash_entry
)))
2443 /* Free up the internal symbols read from an a.out file. */
2446 aout_link_free_symbols (bfd
*abfd
)
2448 if (obj_aout_external_syms (abfd
) != NULL
)
2451 bfd_free_window (&obj_aout_sym_window (abfd
));
2453 free ((void *) obj_aout_external_syms (abfd
));
2455 obj_aout_external_syms (abfd
) = NULL
;
2458 if (obj_aout_external_strings (abfd
) != NULL
)
2461 bfd_free_window (&obj_aout_string_window (abfd
));
2463 free ((void *) obj_aout_external_strings (abfd
));
2465 obj_aout_external_strings (abfd
) = NULL
;
2470 /* Given an a.out BFD, add symbols to the global hash table as
2474 NAME (aout
, link_add_symbols
) (bfd
*abfd
, struct bfd_link_info
*info
)
2476 switch (bfd_get_format (abfd
))
2479 return aout_link_add_object_symbols (abfd
, info
);
2481 return _bfd_generic_link_add_archive_symbols
2482 (abfd
, info
, aout_link_check_archive_element
);
2484 bfd_set_error (bfd_error_wrong_format
);
2489 /* Add symbols from an a.out object file. */
2492 aout_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2494 if (! aout_get_external_symbols (abfd
))
2496 if (! aout_link_add_symbols (abfd
, info
))
2498 if (! info
->keep_memory
)
2500 if (! aout_link_free_symbols (abfd
))
2506 /* Look through the internal symbols to see if this object file should
2507 be included in the link. We should include this object file if it
2508 defines any symbols which are currently undefined. If this object
2509 file defines a common symbol, then we may adjust the size of the
2510 known symbol but we do not include the object file in the link
2511 (unless there is some other reason to include it). */
2514 aout_link_check_ar_symbols (bfd
*abfd
,
2515 struct bfd_link_info
*info
,
2516 bfd_boolean
*pneeded
,
2519 struct external_nlist
*p
;
2520 struct external_nlist
*pend
;
2525 /* Look through all the symbols. */
2526 p
= obj_aout_external_syms (abfd
);
2527 pend
= p
+ obj_aout_external_sym_count (abfd
);
2528 strings
= obj_aout_external_strings (abfd
);
2529 for (; p
< pend
; p
++)
2531 int type
= H_GET_8 (abfd
, p
->e_type
);
2533 struct bfd_link_hash_entry
*h
;
2535 /* Ignore symbols that are not externally visible. This is an
2536 optimization only, as we check the type more thoroughly
2538 if ((type
& N_EXT
) == 0
2542 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2543 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
2545 /* We are only interested in symbols that are currently
2546 undefined or common. */
2548 || (h
->type
!= bfd_link_hash_undefined
2549 && h
->type
!= bfd_link_hash_common
))
2552 if (type
== (N_TEXT
| N_EXT
)
2553 || type
== (N_DATA
| N_EXT
)
2554 || type
== (N_BSS
| N_EXT
)
2555 || type
== (N_ABS
| N_EXT
))
2557 /* This object file defines this symbol. We must link it
2558 in. This is true regardless of whether the current
2559 definition of the symbol is undefined or common. If the
2560 current definition is common, we have a case in which we
2561 have already seen an object file including
2563 and this object file from the archive includes
2565 In such a case we must include this object file.
2567 FIXME: The SunOS 4.1.3 linker will pull in the archive
2568 element if the symbol is defined in the .data section,
2569 but not if it is defined in the .text section. That
2570 seems a bit crazy to me, and I haven't implemented it.
2571 However, it might be correct. */
2572 if (!(*info
->callbacks
2573 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2579 if (type
== (N_UNDF
| N_EXT
))
2583 value
= GET_WORD (abfd
, p
->e_value
);
2586 /* This symbol is common in the object from the archive
2588 if (h
->type
== bfd_link_hash_undefined
)
2593 symbfd
= h
->u
.undef
.abfd
;
2596 /* This symbol was created as undefined from
2597 outside BFD. We assume that we should link
2598 in the object file. This is done for the -u
2599 option in the linker. */
2600 if (!(*info
->callbacks
2601 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2606 /* Turn the current link symbol into a common
2607 symbol. It is already on the undefs list. */
2608 h
->type
= bfd_link_hash_common
;
2609 h
->u
.c
.p
= bfd_hash_allocate (&info
->hash
->table
,
2610 sizeof (struct bfd_link_hash_common_entry
));
2611 if (h
->u
.c
.p
== NULL
)
2614 h
->u
.c
.size
= value
;
2616 /* FIXME: This isn't quite right. The maximum
2617 alignment of a common symbol should be set by the
2618 architecture of the output file, not of the input
2620 power
= bfd_log2 (value
);
2621 if (power
> bfd_get_arch_info (abfd
)->section_align_power
)
2622 power
= bfd_get_arch_info (abfd
)->section_align_power
;
2623 h
->u
.c
.p
->alignment_power
= power
;
2625 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
,
2630 /* Adjust the size of the common symbol if
2632 if (value
> h
->u
.c
.size
)
2633 h
->u
.c
.size
= value
;
2639 /* We do not need this object file. */
2643 /* Check a single archive element to see if we need to include it in
2644 the link. *PNEEDED is set according to whether this element is
2645 needed in the link or not. This is called from
2646 _bfd_generic_link_add_archive_symbols. */
2649 aout_link_check_archive_element (bfd
*abfd
,
2650 struct bfd_link_info
*info
,
2651 struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
2652 const char *name ATTRIBUTE_UNUSED
,
2653 bfd_boolean
*pneeded
)
2658 if (!aout_get_external_symbols (abfd
))
2662 if (!aout_link_check_ar_symbols (abfd
, info
, pneeded
, &abfd
))
2668 /* Potentially, the add_archive_element hook may have set a
2669 substitute BFD for us. */
2672 if (!info
->keep_memory
2673 && !aout_link_free_symbols (oldbfd
))
2675 if (!aout_get_external_symbols (abfd
))
2678 if (!aout_link_add_symbols (abfd
, info
))
2682 if (!info
->keep_memory
|| !needed
)
2684 if (!aout_link_free_symbols (abfd
))
2691 /* Add all symbols from an object file to the hash table. */
2694 aout_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2696 bfd_boolean (*add_one_symbol
)
2697 (struct bfd_link_info
*, bfd
*, const char *, flagword
, asection
*,
2698 bfd_vma
, const char *, bfd_boolean
, bfd_boolean
,
2699 struct bfd_link_hash_entry
**);
2700 struct external_nlist
*syms
;
2701 bfd_size_type sym_count
;
2704 struct aout_link_hash_entry
**sym_hash
;
2705 struct external_nlist
*p
;
2706 struct external_nlist
*pend
;
2708 syms
= obj_aout_external_syms (abfd
);
2709 sym_count
= obj_aout_external_sym_count (abfd
);
2710 strings
= obj_aout_external_strings (abfd
);
2711 if (info
->keep_memory
)
2716 if (aout_backend_info (abfd
)->add_dynamic_symbols
!= NULL
)
2718 if (! ((*aout_backend_info (abfd
)->add_dynamic_symbols
)
2719 (abfd
, info
, &syms
, &sym_count
, &strings
)))
2723 /* We keep a list of the linker hash table entries that correspond
2724 to particular symbols. We could just look them up in the hash
2725 table, but keeping the list is more efficient. Perhaps this
2726 should be conditional on info->keep_memory. */
2727 sym_hash
= bfd_alloc (abfd
,
2728 sym_count
* sizeof (struct aout_link_hash_entry
*));
2729 if (sym_hash
== NULL
&& sym_count
!= 0)
2731 obj_aout_sym_hashes (abfd
) = sym_hash
;
2733 add_one_symbol
= aout_backend_info (abfd
)->add_one_symbol
;
2734 if (add_one_symbol
== NULL
)
2735 add_one_symbol
= _bfd_generic_link_add_one_symbol
;
2738 pend
= p
+ sym_count
;
2739 for (; p
< pend
; p
++, sym_hash
++)
2750 type
= H_GET_8 (abfd
, p
->e_type
);
2752 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2753 value
= GET_WORD (abfd
, p
->e_value
);
2759 /* Anything else should be a debugging symbol. */
2760 BFD_ASSERT ((type
& N_STAB
) != 0);
2770 /* Ignore symbols that are not externally visible. */
2773 case N_UNDF
| N_EXT
:
2776 section
= bfd_und_section_ptr
;
2780 section
= bfd_com_section_ptr
;
2783 section
= bfd_abs_section_ptr
;
2785 case N_TEXT
| N_EXT
:
2786 section
= obj_textsec (abfd
);
2787 value
-= bfd_section_vma (section
);
2789 case N_DATA
| N_EXT
:
2790 /* Treat N_SETV symbols as N_DATA symbol; see comment in
2791 translate_from_native_sym_flags. */
2792 section
= obj_datasec (abfd
);
2793 value
-= bfd_section_vma (section
);
2796 section
= obj_bsssec (abfd
);
2797 value
-= bfd_section_vma (section
);
2801 if (! ((*add_one_symbol
)
2802 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, FALSE
,
2803 (struct bfd_link_hash_entry
**) sym_hash
)))
2806 /* Restrict the maximum alignment of a common symbol based on
2807 the architecture, since a.out has no way to represent
2808 alignment requirements of a section in a .o file. FIXME:
2809 This isn't quite right: it should use the architecture of the
2810 output file, not the input files. */
2811 if ((*sym_hash
)->root
.type
== bfd_link_hash_common
2812 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
>
2813 bfd_get_arch_info (abfd
)->section_align_power
))
2814 (*sym_hash
)->root
.u
.c
.p
->alignment_power
=
2815 bfd_get_arch_info (abfd
)->section_align_power
;
2817 /* If this is a set symbol, and we are not building sets, then
2818 it is possible for the hash entry to not have been set. In
2819 such a case, treat the symbol as not globally defined. */
2820 if ((*sym_hash
)->root
.type
== bfd_link_hash_new
)
2822 BFD_ASSERT ((flags
& BSF_CONSTRUCTOR
) != 0);
2830 /* Look up an entry in an the header file hash table. */
2832 #define aout_link_includes_lookup(table, string, create, copy) \
2833 ((struct aout_link_includes_entry *) \
2834 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
2836 /* The function to create a new entry in the header file hash table. */
2838 static struct bfd_hash_entry
*
2839 aout_link_includes_newfunc (struct bfd_hash_entry
*entry
,
2840 struct bfd_hash_table
*table
,
2843 struct aout_link_includes_entry
* ret
=
2844 (struct aout_link_includes_entry
*) entry
;
2846 /* Allocate the structure if it has not already been allocated by a
2849 ret
= bfd_hash_allocate (table
,
2850 sizeof (struct aout_link_includes_entry
));
2854 /* Call the allocation method of the superclass. */
2855 ret
= ((struct aout_link_includes_entry
*)
2856 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
2858 /* Set local fields. */
2861 return (struct bfd_hash_entry
*) ret
;
2865 aout_link_write_other_symbol (struct bfd_hash_entry
*bh
, void *data
)
2867 struct aout_link_hash_entry
*h
= (struct aout_link_hash_entry
*) bh
;
2868 struct aout_final_link_info
*flaginfo
= (struct aout_final_link_info
*) data
;
2872 struct external_nlist outsym
;
2876 if (h
->root
.type
== bfd_link_hash_warning
)
2878 h
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
2879 if (h
->root
.type
== bfd_link_hash_new
)
2883 output_bfd
= flaginfo
->output_bfd
;
2885 if (aout_backend_info (output_bfd
)->write_dynamic_symbol
!= NULL
)
2887 if (! ((*aout_backend_info (output_bfd
)->write_dynamic_symbol
)
2888 (output_bfd
, flaginfo
->info
, h
)))
2890 /* FIXME: No way to handle errors. */
2900 /* An indx of -2 means the symbol must be written. */
2902 && (flaginfo
->info
->strip
== strip_all
2903 || (flaginfo
->info
->strip
== strip_some
2904 && bfd_hash_lookup (flaginfo
->info
->keep_hash
, h
->root
.root
.string
,
2905 FALSE
, FALSE
) == NULL
)))
2908 switch (h
->root
.type
)
2912 /* Avoid variable not initialized warnings. */
2914 case bfd_link_hash_new
:
2915 /* This can happen for set symbols when sets are not being
2918 case bfd_link_hash_undefined
:
2919 type
= N_UNDF
| N_EXT
;
2922 case bfd_link_hash_defined
:
2923 case bfd_link_hash_defweak
:
2927 sec
= h
->root
.u
.def
.section
->output_section
;
2928 BFD_ASSERT (bfd_is_abs_section (sec
)
2929 || sec
->owner
== output_bfd
);
2930 if (sec
== obj_textsec (output_bfd
))
2931 type
= h
->root
.type
== bfd_link_hash_defined
? N_TEXT
: N_WEAKT
;
2932 else if (sec
== obj_datasec (output_bfd
))
2933 type
= h
->root
.type
== bfd_link_hash_defined
? N_DATA
: N_WEAKD
;
2934 else if (sec
== obj_bsssec (output_bfd
))
2935 type
= h
->root
.type
== bfd_link_hash_defined
? N_BSS
: N_WEAKB
;
2937 type
= h
->root
.type
== bfd_link_hash_defined
? N_ABS
: N_WEAKA
;
2939 val
= (h
->root
.u
.def
.value
2941 + h
->root
.u
.def
.section
->output_offset
);
2944 case bfd_link_hash_common
:
2945 type
= N_UNDF
| N_EXT
;
2946 val
= h
->root
.u
.c
.size
;
2948 case bfd_link_hash_undefweak
:
2952 case bfd_link_hash_indirect
:
2953 case bfd_link_hash_warning
:
2954 /* FIXME: Ignore these for now. The circumstances under which
2955 they should be written out are not clear to me. */
2959 H_PUT_8 (output_bfd
, type
, outsym
.e_type
);
2960 indx
= add_to_stringtab (output_bfd
, flaginfo
->strtab
, h
->root
.root
.string
,
2962 if (indx
== (bfd_size_type
) -1)
2963 /* FIXME: No way to handle errors. */
2966 PUT_WORD (output_bfd
, indx
, outsym
.e_strx
);
2967 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
2969 amt
= EXTERNAL_NLIST_SIZE
;
2970 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0
2971 || bfd_bwrite ((void *) &outsym
, amt
, output_bfd
) != amt
)
2972 /* FIXME: No way to handle errors. */
2975 flaginfo
->symoff
+= amt
;
2976 h
->indx
= obj_aout_external_sym_count (output_bfd
);
2977 ++obj_aout_external_sym_count (output_bfd
);
2982 /* Handle a link order which is supposed to generate a reloc. */
2985 aout_link_reloc_link_order (struct aout_final_link_info
*flaginfo
,
2987 struct bfd_link_order
*p
)
2989 struct bfd_link_order_reloc
*pr
;
2992 reloc_howto_type
*howto
;
2993 file_ptr
*reloff_ptr
;
2994 struct reloc_std_external srel
;
2996 bfd_size_type rel_size
;
3000 if (p
->type
== bfd_section_reloc_link_order
)
3003 if (bfd_is_abs_section (pr
->u
.section
))
3004 r_index
= N_ABS
| N_EXT
;
3007 BFD_ASSERT (pr
->u
.section
->owner
== flaginfo
->output_bfd
);
3008 r_index
= pr
->u
.section
->target_index
;
3013 struct aout_link_hash_entry
*h
;
3015 BFD_ASSERT (p
->type
== bfd_symbol_reloc_link_order
);
3017 h
= ((struct aout_link_hash_entry
*)
3018 bfd_wrapped_link_hash_lookup (flaginfo
->output_bfd
, flaginfo
->info
,
3019 pr
->u
.name
, FALSE
, FALSE
, TRUE
));
3025 /* We decided to strip this symbol, but it turns out that we
3026 can't. Note that we lose the other and desc information
3027 here. I don't think that will ever matter for a global
3031 if (!aout_link_write_other_symbol (&h
->root
.root
, flaginfo
))
3037 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3038 (flaginfo
->info
, pr
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
3043 howto
= bfd_reloc_type_lookup (flaginfo
->output_bfd
, pr
->reloc
);
3046 bfd_set_error (bfd_error_bad_value
);
3050 if (o
== obj_textsec (flaginfo
->output_bfd
))
3051 reloff_ptr
= &flaginfo
->treloff
;
3052 else if (o
== obj_datasec (flaginfo
->output_bfd
))
3053 reloff_ptr
= &flaginfo
->dreloff
;
3058 MY_put_reloc(flaginfo
->output_bfd
, r_extern
, r_index
, p
->offset
, howto
,
3068 fprintf (stderr
, "TODO: line %d in bfd/pdp11.c\n", __LINE__
);
3070 r_pcrel
= howto
->pc_relative
;
3071 r_baserel
= (howto
->type
& 8) != 0;
3072 r_jmptable
= (howto
->type
& 16) != 0;
3073 r_relative
= (howto
->type
& 32) != 0;
3074 r_length
= howto
->size
;
3076 PUT_WORD (flaginfo
->output_bfd
, p
->offset
, srel
.r_address
);
3077 if (bfd_header_big_endian (flaginfo
->output_bfd
))
3079 srel
.r_index
[0] = r_index
>> 16;
3080 srel
.r_index
[1] = r_index
>> 8;
3081 srel
.r_index
[2] = r_index
;
3083 ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
3084 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
3085 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
3086 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
3087 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
3088 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
3092 srel
.r_index
[2] = r_index
>> 16;
3093 srel
.r_index
[1] = r_index
>> 8;
3094 srel
.r_index
[0] = r_index
;
3096 ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
3097 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
3098 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
3099 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
3100 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
3101 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
3105 rel_ptr
= (void *) &srel
;
3107 /* We have to write the addend into the object file, since
3108 standard a.out relocs are in place. It would be more
3109 reliable if we had the current contents of the file here,
3110 rather than assuming zeroes, but we can't read the file since
3111 it was opened using bfd_openw. */
3112 if (pr
->addend
!= 0)
3115 bfd_reloc_status_type r
;
3119 size
= bfd_get_reloc_size (howto
);
3120 buf
= bfd_zmalloc (size
);
3121 if (buf
== NULL
&& size
!= 0)
3123 r
= MY_relocate_contents (howto
, flaginfo
->output_bfd
,
3130 case bfd_reloc_outofrange
:
3132 case bfd_reloc_overflow
:
3133 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3134 (flaginfo
->info
, NULL
,
3135 (p
->type
== bfd_section_reloc_link_order
3136 ? bfd_section_name (pr
->u
.section
)
3138 howto
->name
, pr
->addend
, NULL
,
3139 (asection
*) NULL
, (bfd_vma
) 0);
3142 ok
= bfd_set_section_contents (flaginfo
->output_bfd
, o
,
3144 (file_ptr
) p
->offset
,
3151 rel_size
= obj_reloc_entry_size (flaginfo
->output_bfd
);
3152 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0
3153 || bfd_bwrite (rel_ptr
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3156 *reloff_ptr
+= rel_size
;
3158 /* Assert that the relocs have not run into the symbols, and that n
3159 the text relocs have not run into the data relocs. */
3160 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3161 && (reloff_ptr
!= &flaginfo
->treloff
3163 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3168 /* Get the section corresponding to a reloc index. */
3170 static inline asection
*
3171 aout_reloc_type_to_section (bfd
*abfd
, int type
)
3175 case RTEXT
: return obj_textsec (abfd
);
3176 case RDATA
: return obj_datasec (abfd
);
3177 case RBSS
: return obj_bsssec (abfd
);
3178 case RABS
: return bfd_abs_section_ptr
;
3179 case REXT
: return bfd_und_section_ptr
;
3185 pdp11_aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3187 asection
*input_section
,
3189 bfd_size_type rel_size
,
3192 bfd_boolean (*check_dynamic_reloc
)
3193 (struct bfd_link_info
*, bfd
*, asection
*,
3194 struct aout_link_hash_entry
*, void *, bfd_byte
*, bfd_boolean
*,
3197 bfd_boolean relocatable
;
3198 struct external_nlist
*syms
;
3200 struct aout_link_hash_entry
**sym_hashes
;
3205 output_bfd
= flaginfo
->output_bfd
;
3206 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
3208 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_SIZE
);
3209 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
3210 == output_bfd
->xvec
->header_byteorder
);
3212 relocatable
= bfd_link_relocatable (flaginfo
->info
);
3213 syms
= obj_aout_external_syms (input_bfd
);
3214 strings
= obj_aout_external_strings (input_bfd
);
3215 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
3216 symbol_map
= flaginfo
->symbol_map
;
3219 rel_end
= rel
+ rel_size
;
3220 for (; rel
< rel_end
; rel
+= RELOC_SIZE
)
3227 reloc_howto_type
*howto
;
3228 struct aout_link_hash_entry
*h
= NULL
;
3230 bfd_reloc_status_type r
;
3233 reloc_entry
= GET_WORD (input_bfd
, (void *) rel
);
3234 if (reloc_entry
== 0)
3238 unsigned int howto_idx
;
3240 r_index
= (reloc_entry
& RIDXMASK
) >> 4;
3241 r_type
= reloc_entry
& RTYPE
;
3242 r_pcrel
= reloc_entry
& RELFLG
;
3243 r_addr
= (char *) rel
- (char *) relocs
;
3245 r_extern
= (r_type
== REXT
);
3247 howto_idx
= r_pcrel
;
3248 BFD_ASSERT (howto_idx
< TABLE_SIZE (howto_table_pdp11
));
3249 howto
= howto_table_pdp11
+ howto_idx
;
3254 /* We are generating a relocatable output file, and must
3255 modify the reloc accordingly. */
3258 /* If we know the symbol this relocation is against,
3259 convert it into a relocation against a section. This
3260 is what the native linker does. */
3261 h
= sym_hashes
[r_index
];
3263 && (h
->root
.type
== bfd_link_hash_defined
3264 || h
->root
.type
== bfd_link_hash_defweak
))
3266 asection
*output_section
;
3268 /* Compute a new r_index. */
3269 output_section
= h
->root
.u
.def
.section
->output_section
;
3270 if (output_section
== obj_textsec (output_bfd
))
3272 else if (output_section
== obj_datasec (output_bfd
))
3274 else if (output_section
== obj_bsssec (output_bfd
))
3279 /* Add the symbol value and the section VMA to the
3280 addend stored in the contents. */
3281 relocation
= (h
->root
.u
.def
.value
3282 + output_section
->vma
3283 + h
->root
.u
.def
.section
->output_offset
);
3287 /* We must change r_index according to the symbol
3289 r_index
= symbol_map
[r_index
];
3295 /* We decided to strip this symbol, but it
3296 turns out that we can't. Note that we
3297 lose the other and desc information here.
3298 I don't think that will ever matter for a
3304 if (!aout_link_write_other_symbol (&h
->root
.root
,
3314 name
= strings
+ GET_WORD (input_bfd
,
3315 syms
[r_index
].e_strx
);
3316 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3317 (flaginfo
->info
, name
, input_bfd
, input_section
,
3326 /* Write out the new r_index value. */
3327 reloc_entry
= GET_WORD (input_bfd
, rel
);
3328 reloc_entry
&= RIDXMASK
;
3329 reloc_entry
|= r_index
<< 4;
3330 PUT_WORD (input_bfd
, reloc_entry
, rel
);
3336 /* This is a relocation against a section. We must
3337 adjust by the amount that the section moved. */
3338 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3339 relocation
= (section
->output_section
->vma
3340 + section
->output_offset
3344 /* Change the address of the relocation. */
3345 fprintf (stderr
, "TODO: change the address of the relocation\n");
3347 /* Adjust a PC relative relocation by removing the reference
3348 to the original address in the section and including the
3349 reference to the new address. */
3351 relocation
-= (input_section
->output_section
->vma
3352 + input_section
->output_offset
3353 - input_section
->vma
);
3355 #ifdef MY_relocatable_reloc
3356 MY_relocatable_reloc (howto
, output_bfd
, rel
, relocation
, r_addr
);
3359 if (relocation
== 0)
3362 r
= MY_relocate_contents (howto
,
3363 input_bfd
, relocation
,
3370 /* We are generating an executable, and must do a full
3375 h
= sym_hashes
[r_index
];
3378 && (h
->root
.type
== bfd_link_hash_defined
3379 || h
->root
.type
== bfd_link_hash_defweak
))
3381 relocation
= (h
->root
.u
.def
.value
3382 + h
->root
.u
.def
.section
->output_section
->vma
3383 + h
->root
.u
.def
.section
->output_offset
);
3386 && h
->root
.type
== bfd_link_hash_undefweak
)
3398 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3399 relocation
= (section
->output_section
->vma
3400 + section
->output_offset
3403 relocation
+= input_section
->vma
;
3406 if (check_dynamic_reloc
!= NULL
)
3410 if (! ((*check_dynamic_reloc
)
3411 (flaginfo
->info
, input_bfd
, input_section
, h
,
3412 (void *) rel
, contents
, &skip
, &relocation
)))
3418 /* Now warn if a global symbol is undefined. We could not
3419 do this earlier, because check_dynamic_reloc might want
3420 to skip this reloc. */
3421 if (hundef
&& ! bfd_link_pic (flaginfo
->info
))
3426 name
= h
->root
.root
.string
;
3428 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
3429 (*flaginfo
->info
->callbacks
->undefined_symbol
)
3430 (flaginfo
->info
, name
, input_bfd
, input_section
,
3434 r
= MY_final_link_relocate (howto
,
3435 input_bfd
, input_section
,
3436 contents
, r_addr
, relocation
,
3440 if (r
!= bfd_reloc_ok
)
3445 case bfd_reloc_outofrange
:
3447 case bfd_reloc_overflow
:
3454 name
= strings
+ GET_WORD (input_bfd
,
3455 syms
[r_index
].e_strx
);
3460 s
= aout_reloc_type_to_section (input_bfd
, r_type
);
3461 name
= bfd_section_name (s
);
3463 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3464 (flaginfo
->info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3465 (bfd_vma
) 0, input_bfd
, input_section
, r_addr
);
3475 /* Link an a.out section into the output file. */
3478 aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3480 asection
*input_section
,
3481 file_ptr
*reloff_ptr
,
3482 bfd_size_type rel_size
)
3484 bfd_size_type input_size
;
3487 /* Get the section contents. */
3488 input_size
= input_section
->size
;
3489 if (! bfd_get_section_contents (input_bfd
, input_section
,
3490 (void *) flaginfo
->contents
,
3491 (file_ptr
) 0, input_size
))
3494 /* Read in the relocs if we haven't already done it. */
3495 if (aout_section_data (input_section
) != NULL
3496 && aout_section_data (input_section
)->relocs
!= NULL
)
3497 relocs
= aout_section_data (input_section
)->relocs
;
3500 relocs
= flaginfo
->relocs
;
3503 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3504 || bfd_bread (relocs
, rel_size
, input_bfd
) != rel_size
)
3509 /* Relocate the section contents. */
3510 if (! pdp11_aout_link_input_section (flaginfo
, input_bfd
, input_section
,
3511 (bfd_byte
*) relocs
,
3512 rel_size
, flaginfo
->contents
))
3515 /* Write out the section contents. */
3516 if (! bfd_set_section_contents (flaginfo
->output_bfd
,
3517 input_section
->output_section
,
3518 (void *) flaginfo
->contents
,
3519 (file_ptr
) input_section
->output_offset
,
3523 /* If we are producing relocatable output, the relocs were
3524 modified, and we now write them out. */
3525 if (bfd_link_relocatable (flaginfo
->info
) && rel_size
> 0)
3527 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
3529 if (bfd_bwrite (relocs
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3531 *reloff_ptr
+= rel_size
;
3533 /* Assert that the relocs have not run into the symbols, and
3534 that if these are the text relocs they have not run into the
3536 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3537 && (reloff_ptr
!= &flaginfo
->treloff
3539 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3545 /* Link an a.out input BFD into the output file. */
3548 aout_link_input_bfd (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
3550 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
3552 /* If this is a dynamic object, it may need special handling. */
3553 if ((input_bfd
->flags
& DYNAMIC
) != 0
3554 && aout_backend_info (input_bfd
)->link_dynamic_object
!= NULL
)
3555 return ((*aout_backend_info (input_bfd
)->link_dynamic_object
)
3556 (flaginfo
->info
, input_bfd
));
3558 /* Get the symbols. We probably have them already, unless
3559 flaginfo->info->keep_memory is FALSE. */
3560 if (! aout_get_external_symbols (input_bfd
))
3563 /* Write out the symbols and get a map of the new indices. The map
3564 is placed into flaginfo->symbol_map. */
3565 if (! aout_link_write_symbols (flaginfo
, input_bfd
))
3568 /* Relocate and write out the sections. These functions use the
3569 symbol map created by aout_link_write_symbols. The linker_mark
3570 field will be set if these sections are to be included in the
3571 link, which will normally be the case. */
3572 if (obj_textsec (input_bfd
)->linker_mark
)
3574 if (! aout_link_input_section (flaginfo
, input_bfd
,
3575 obj_textsec (input_bfd
),
3577 exec_hdr (input_bfd
)->a_trsize
))
3580 if (obj_datasec (input_bfd
)->linker_mark
)
3582 if (! aout_link_input_section (flaginfo
, input_bfd
,
3583 obj_datasec (input_bfd
),
3585 exec_hdr (input_bfd
)->a_drsize
))
3589 /* If we are not keeping memory, we don't need the symbols any
3590 longer. We still need them if we are keeping memory, because the
3591 strings in the hash table point into them. */
3592 if (! flaginfo
->info
->keep_memory
)
3594 if (! aout_link_free_symbols (input_bfd
))
3601 /* Do the final link step. This is called on the output BFD. The
3602 INFO structure should point to a list of BFDs linked through the
3603 link.next field which can be used to find each BFD which takes part
3604 in the output. Also, each section in ABFD should point to a list
3605 of bfd_link_order structures which list all the input sections for
3606 the output section. */
3609 NAME (aout
, final_link
) (bfd
*abfd
,
3610 struct bfd_link_info
*info
,
3611 void (*callback
) (bfd
*, file_ptr
*, file_ptr
*, file_ptr
*))
3613 struct aout_final_link_info aout_info
;
3614 bfd_boolean includes_hash_initialized
= FALSE
;
3616 bfd_size_type trsize
, drsize
;
3617 bfd_size_type max_contents_size
;
3618 bfd_size_type max_relocs_size
;
3619 bfd_size_type max_sym_count
;
3620 struct bfd_link_order
*p
;
3622 bfd_boolean have_link_order_relocs
;
3624 if (bfd_link_pic (info
))
3625 abfd
->flags
|= DYNAMIC
;
3627 aout_info
.info
= info
;
3628 aout_info
.output_bfd
= abfd
;
3629 aout_info
.contents
= NULL
;
3630 aout_info
.relocs
= NULL
;
3631 aout_info
.symbol_map
= NULL
;
3632 aout_info
.output_syms
= NULL
;
3634 if (!bfd_hash_table_init_n (&aout_info
.includes
.root
,
3635 aout_link_includes_newfunc
,
3636 sizeof (struct aout_link_includes_entry
),
3639 includes_hash_initialized
= TRUE
;
3641 /* Figure out the largest section size. Also, if generating
3642 relocatable output, count the relocs. */
3645 max_contents_size
= 0;
3646 max_relocs_size
= 0;
3648 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3652 if (bfd_link_relocatable (info
))
3654 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3656 trsize
+= exec_hdr (sub
)->a_trsize
;
3657 drsize
+= exec_hdr (sub
)->a_drsize
;
3661 /* FIXME: We need to identify the .text and .data sections
3662 and call get_reloc_upper_bound and canonicalize_reloc to
3663 work out the number of relocs needed, and then multiply
3664 by the reloc size. */
3666 /* xgettext:c-format */
3667 (_("%pB: relocatable link from %s to %s not supported"),
3668 abfd
, sub
->xvec
->name
, abfd
->xvec
->name
);
3669 bfd_set_error (bfd_error_invalid_operation
);
3674 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3676 sz
= obj_textsec (sub
)->size
;
3677 if (sz
> max_contents_size
)
3678 max_contents_size
= sz
;
3679 sz
= obj_datasec (sub
)->size
;
3680 if (sz
> max_contents_size
)
3681 max_contents_size
= sz
;
3683 sz
= exec_hdr (sub
)->a_trsize
;
3684 if (sz
> max_relocs_size
)
3685 max_relocs_size
= sz
;
3686 sz
= exec_hdr (sub
)->a_drsize
;
3687 if (sz
> max_relocs_size
)
3688 max_relocs_size
= sz
;
3690 sz
= obj_aout_external_sym_count (sub
);
3691 if (sz
> max_sym_count
)
3696 if (bfd_link_relocatable (info
))
3698 if (obj_textsec (abfd
) != NULL
)
3699 trsize
+= (_bfd_count_link_order_relocs (obj_textsec (abfd
)
3700 ->map_head
.link_order
)
3701 * obj_reloc_entry_size (abfd
));
3702 if (obj_datasec (abfd
) != NULL
)
3703 drsize
+= (_bfd_count_link_order_relocs (obj_datasec (abfd
)
3704 ->map_head
.link_order
)
3705 * obj_reloc_entry_size (abfd
));
3708 exec_hdr (abfd
)->a_trsize
= trsize
;
3709 exec_hdr (abfd
)->a_drsize
= drsize
;
3710 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
3712 /* Adjust the section sizes and vmas according to the magic number.
3713 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3714 filepos for each section. */
3715 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
3718 /* The relocation and symbol file positions differ among a.out
3719 targets. We are passed a callback routine from the backend
3720 specific code to handle this.
3721 FIXME: At this point we do not know how much space the symbol
3722 table will require. This will not work for any (nonstandard)
3723 a.out target that needs to know the symbol table size before it
3724 can compute the relocation file positions. */
3725 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
3727 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
3728 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
3729 obj_sym_filepos (abfd
) = aout_info
.symoff
;
3731 /* We keep a count of the symbols as we output them. */
3732 obj_aout_external_sym_count (abfd
) = 0;
3734 /* We accumulate the string table as we write out the symbols. */
3735 aout_info
.strtab
= _bfd_stringtab_init ();
3736 if (aout_info
.strtab
== NULL
)
3739 /* Allocate buffers to hold section contents and relocs. */
3740 aout_info
.contents
= bfd_malloc (max_contents_size
);
3741 aout_info
.relocs
= bfd_malloc (max_relocs_size
);
3742 aout_info
.symbol_map
= bfd_malloc (max_sym_count
* sizeof (int *));
3743 aout_info
.output_syms
= bfd_malloc ((max_sym_count
+ 1)
3744 * sizeof (struct external_nlist
));
3745 if ((aout_info
.contents
== NULL
&& max_contents_size
!= 0)
3746 || (aout_info
.relocs
== NULL
&& max_relocs_size
!= 0)
3747 || (aout_info
.symbol_map
== NULL
&& max_sym_count
!= 0)
3748 || aout_info
.output_syms
== NULL
)
3751 /* If we have a symbol named __DYNAMIC, force it out now. This is
3752 required by SunOS. Doing this here rather than in sunos.c is a
3753 hack, but it's easier than exporting everything which would be
3756 struct aout_link_hash_entry
*h
;
3758 h
= aout_link_hash_lookup (aout_hash_table (info
), "__DYNAMIC",
3759 FALSE
, FALSE
, FALSE
);
3761 aout_link_write_other_symbol (&h
->root
.root
, &aout_info
);
3764 /* The most time efficient way to do the link would be to read all
3765 the input object files into memory and then sort out the
3766 information into the output file. Unfortunately, that will
3767 probably use too much memory. Another method would be to step
3768 through everything that composes the text section and write it
3769 out, and then everything that composes the data section and write
3770 it out, and then write out the relocs, and then write out the
3771 symbols. Unfortunately, that requires reading stuff from each
3772 input file several times, and we will not be able to keep all the
3773 input files open simultaneously, and reopening them will be slow.
3775 What we do is basically process one input file at a time. We do
3776 everything we need to do with an input file once--copy over the
3777 section contents, handle the relocation information, and write
3778 out the symbols--and then we throw away the information we read
3779 from it. This approach requires a lot of lseeks of the output
3780 file, which is unfortunate but still faster than reopening a lot
3783 We use the output_has_begun field of the input BFDs to see
3784 whether we have already handled it. */
3785 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3786 sub
->output_has_begun
= FALSE
;
3788 /* Mark all sections which are to be included in the link. This
3789 will normally be every section. We need to do this so that we
3790 can identify any sections which the linker has decided to not
3792 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3794 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
3795 if (p
->type
== bfd_indirect_link_order
)
3796 p
->u
.indirect
.section
->linker_mark
= TRUE
;
3799 have_link_order_relocs
= FALSE
;
3800 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3802 for (p
= o
->map_head
.link_order
;
3806 if (p
->type
== bfd_indirect_link_order
3807 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
3808 == bfd_target_aout_flavour
))
3812 input_bfd
= p
->u
.indirect
.section
->owner
;
3813 if (! input_bfd
->output_has_begun
)
3815 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
3817 input_bfd
->output_has_begun
= TRUE
;
3820 else if (p
->type
== bfd_section_reloc_link_order
3821 || p
->type
== bfd_symbol_reloc_link_order
)
3822 /* These are handled below. */
3823 have_link_order_relocs
= TRUE
;
3826 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3832 /* Write out any symbols that we have not already written out. */
3833 bfd_hash_traverse (&info
->hash
->table
,
3834 aout_link_write_other_symbol
,
3837 /* Now handle any relocs we were asked to create by the linker.
3838 These did not come from any input file. We must do these after
3839 we have written out all the symbols, so that we know the symbol
3841 if (have_link_order_relocs
)
3843 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3845 for (p
= o
->map_head
.link_order
;
3849 if (p
->type
== bfd_section_reloc_link_order
3850 || p
->type
== bfd_symbol_reloc_link_order
)
3852 if (! aout_link_reloc_link_order (&aout_info
, o
, p
))
3859 if (aout_info
.contents
!= NULL
)
3861 free (aout_info
.contents
);
3862 aout_info
.contents
= NULL
;
3864 if (aout_info
.relocs
!= NULL
)
3866 free (aout_info
.relocs
);
3867 aout_info
.relocs
= NULL
;
3869 if (aout_info
.symbol_map
!= NULL
)
3871 free (aout_info
.symbol_map
);
3872 aout_info
.symbol_map
= NULL
;
3874 if (aout_info
.output_syms
!= NULL
)
3876 free (aout_info
.output_syms
);
3877 aout_info
.output_syms
= NULL
;
3879 if (includes_hash_initialized
)
3881 bfd_hash_table_free (&aout_info
.includes
.root
);
3882 includes_hash_initialized
= FALSE
;
3885 /* Finish up any dynamic linking we may be doing. */
3886 if (aout_backend_info (abfd
)->finish_dynamic_link
!= NULL
)
3888 if (! (*aout_backend_info (abfd
)->finish_dynamic_link
) (abfd
, info
))
3892 /* Update the header information. */
3893 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
3894 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
3895 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
3896 obj_textsec (abfd
)->reloc_count
=
3897 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
3898 obj_datasec (abfd
)->reloc_count
=
3899 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
3901 /* Write out the string table, unless there are no symbols. */
3902 if (abfd
->symcount
> 0)
3904 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
3905 || ! emit_stringtab (abfd
, aout_info
.strtab
))
3908 else if (obj_textsec (abfd
)->reloc_count
== 0
3909 && obj_datasec (abfd
)->reloc_count
== 0)
3911 /* The layout of a typical a.out file is header, text, data,
3912 relocs, symbols, string table. When there are no relocs,
3913 symbols or string table, the last thing in the file is data
3914 and a_data may be rounded up. However we may have a smaller
3915 sized .data section and thus not written final padding. The
3916 same thing can happen with text if there is no data. Write
3917 final padding here to extend the file. */
3920 if (exec_hdr (abfd
)->a_data
> obj_datasec (abfd
)->size
)
3921 pos
= obj_datasec (abfd
)->filepos
+ exec_hdr (abfd
)->a_data
;
3922 else if (obj_datasec (abfd
)->size
== 0
3923 && exec_hdr (abfd
)->a_text
> obj_textsec (abfd
)->size
)
3924 pos
= obj_textsec (abfd
)->filepos
+ exec_hdr (abfd
)->a_text
;
3929 if (bfd_seek (abfd
, pos
- 1, SEEK_SET
) != 0
3930 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3938 if (aout_info
.contents
!= NULL
)
3939 free (aout_info
.contents
);
3940 if (aout_info
.relocs
!= NULL
)
3941 free (aout_info
.relocs
);
3942 if (aout_info
.symbol_map
!= NULL
)
3943 free (aout_info
.symbol_map
);
3944 if (aout_info
.output_syms
!= NULL
)
3945 free (aout_info
.output_syms
);
3946 if (includes_hash_initialized
)
3947 bfd_hash_table_free (&aout_info
.includes
.root
);
3951 /* Adjust and write out the symbols for an a.out file. Set the new
3952 symbol indices into a symbol_map. */
3955 aout_link_write_symbols (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
3958 bfd_size_type sym_count
;
3960 enum bfd_link_strip strip
;
3961 enum bfd_link_discard discard
;
3962 struct external_nlist
*outsym
;
3963 bfd_size_type strtab_index
;
3964 struct external_nlist
*sym
;
3965 struct external_nlist
*sym_end
;
3966 struct aout_link_hash_entry
**sym_hash
;
3969 bfd_boolean skip_next
;
3971 output_bfd
= flaginfo
->output_bfd
;
3972 sym_count
= obj_aout_external_sym_count (input_bfd
);
3973 strings
= obj_aout_external_strings (input_bfd
);
3974 strip
= flaginfo
->info
->strip
;
3975 discard
= flaginfo
->info
->discard
;
3976 outsym
= flaginfo
->output_syms
;
3978 /* First write out a symbol for this object file, unless we are
3979 discarding such symbols. */
3980 if (strip
!= strip_all
3981 && (strip
!= strip_some
3982 || bfd_hash_lookup (flaginfo
->info
->keep_hash
, input_bfd
->filename
,
3983 FALSE
, FALSE
) != NULL
)
3984 && discard
!= discard_all
)
3986 H_PUT_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
3987 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
3988 input_bfd
->filename
, FALSE
);
3989 if (strtab_index
== (bfd_size_type
) -1)
3991 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
3992 PUT_WORD (output_bfd
,
3993 (bfd_section_vma (obj_textsec (input_bfd
)->output_section
)
3994 + obj_textsec (input_bfd
)->output_offset
),
3996 ++obj_aout_external_sym_count (output_bfd
);
4002 sym
= obj_aout_external_syms (input_bfd
);
4003 sym_end
= sym
+ sym_count
;
4004 sym_hash
= obj_aout_sym_hashes (input_bfd
);
4005 symbol_map
= flaginfo
->symbol_map
;
4006 memset (symbol_map
, 0, (size_t) sym_count
* sizeof *symbol_map
);
4007 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
4011 struct aout_link_hash_entry
*h
;
4017 /* We set *symbol_map to 0 above for all symbols. If it has
4018 already been set to -1 for this symbol, it means that we are
4019 discarding it because it appears in a duplicate header file.
4020 See the N_BINCL code below. */
4021 if (*symbol_map
== -1)
4024 /* Initialize *symbol_map to -1, which means that the symbol was
4025 not copied into the output file. We will change it later if
4026 we do copy the symbol over. */
4029 type
= H_GET_8 (input_bfd
, sym
->e_type
);
4030 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
4036 /* Pass this symbol through. It is the target of an
4037 indirect or warning symbol. */
4038 val
= GET_WORD (input_bfd
, sym
->e_value
);
4043 /* Skip this symbol, which is the target of an indirect
4044 symbol that we have changed to no longer be an indirect
4051 struct aout_link_hash_entry
*hresolve
;
4053 /* We have saved the hash table entry for this symbol, if
4054 there is one. Note that we could just look it up again
4055 in the hash table, provided we first check that it is an
4059 /* Use the name from the hash table, in case the symbol was
4062 name
= h
->root
.root
.string
;
4064 /* If this is an indirect or warning symbol, then change
4065 hresolve to the base symbol. We also change *sym_hash so
4066 that the relocation routines relocate against the real
4070 && (h
->root
.type
== bfd_link_hash_indirect
4071 || h
->root
.type
== bfd_link_hash_warning
))
4073 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
4074 while (hresolve
->root
.type
== bfd_link_hash_indirect
4075 || hresolve
->root
.type
== bfd_link_hash_warning
)
4076 hresolve
= ((struct aout_link_hash_entry
*)
4077 hresolve
->root
.u
.i
.link
);
4078 *sym_hash
= hresolve
;
4081 /* If the symbol has already been written out, skip it. */
4083 && h
->root
.type
!= bfd_link_hash_warning
4086 if ((type
& N_TYPE
) == N_INDR
4087 || type
== N_WARNING
)
4089 *symbol_map
= h
->indx
;
4093 /* See if we are stripping this symbol. */
4099 case strip_debugger
:
4100 if ((type
& N_STAB
) != 0)
4104 if (bfd_hash_lookup (flaginfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
4119 /* Get the value of the symbol. */
4120 if ((type
& N_TYPE
) == N_TEXT
4122 symsec
= obj_textsec (input_bfd
);
4123 else if ((type
& N_TYPE
) == N_DATA
4125 symsec
= obj_datasec (input_bfd
);
4126 else if ((type
& N_TYPE
) == N_BSS
4128 symsec
= obj_bsssec (input_bfd
);
4129 else if ((type
& N_TYPE
) == N_ABS
4131 symsec
= bfd_abs_section_ptr
;
4132 else if (((type
& N_TYPE
) == N_INDR
4133 && (hresolve
== NULL
4134 || (hresolve
->root
.type
!= bfd_link_hash_defined
4135 && hresolve
->root
.type
!= bfd_link_hash_defweak
4136 && hresolve
->root
.type
!= bfd_link_hash_common
)))
4137 || type
== N_WARNING
)
4139 /* Pass the next symbol through unchanged. The
4140 condition above for indirect symbols is so that if
4141 the indirect symbol was defined, we output it with
4142 the correct definition so the debugger will
4145 val
= GET_WORD (input_bfd
, sym
->e_value
);
4148 else if ((type
& N_STAB
) != 0)
4150 val
= GET_WORD (input_bfd
, sym
->e_value
);
4155 /* If we get here with an indirect symbol, it means that
4156 we are outputting it with a real definition. In such
4157 a case we do not want to output the next symbol,
4158 which is the target of the indirection. */
4159 if ((type
& N_TYPE
) == N_INDR
)
4164 /* We need to get the value from the hash table. We use
4165 hresolve so that if we have defined an indirect
4166 symbol we output the final definition. */
4169 switch (type
& N_TYPE
)
4172 symsec
= obj_textsec (input_bfd
);
4175 symsec
= obj_datasec (input_bfd
);
4178 symsec
= obj_bsssec (input_bfd
);
4181 symsec
= bfd_abs_section_ptr
;
4188 else if (hresolve
->root
.type
== bfd_link_hash_defined
4189 || hresolve
->root
.type
== bfd_link_hash_defweak
)
4191 asection
*input_section
;
4192 asection
*output_section
;
4194 /* This case usually means a common symbol which was
4195 turned into a defined symbol. */
4196 input_section
= hresolve
->root
.u
.def
.section
;
4197 output_section
= input_section
->output_section
;
4198 BFD_ASSERT (bfd_is_abs_section (output_section
)
4199 || output_section
->owner
== output_bfd
);
4200 val
= (hresolve
->root
.u
.def
.value
4201 + bfd_section_vma (output_section
)
4202 + input_section
->output_offset
);
4204 /* Get the correct type based on the section. If
4205 this is a constructed set, force it to be
4206 globally visible. */
4215 if (output_section
== obj_textsec (output_bfd
))
4216 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4219 else if (output_section
== obj_datasec (output_bfd
))
4220 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4223 else if (output_section
== obj_bsssec (output_bfd
))
4224 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4228 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4232 else if (hresolve
->root
.type
== bfd_link_hash_common
)
4233 val
= hresolve
->root
.u
.c
.size
;
4234 else if (hresolve
->root
.type
== bfd_link_hash_undefweak
)
4243 val
= (symsec
->output_section
->vma
4244 + symsec
->output_offset
4245 + (GET_WORD (input_bfd
, sym
->e_value
)
4248 /* If this is a global symbol set the written flag, and if
4249 it is a local symbol see if we should discard it. */
4253 h
->indx
= obj_aout_external_sym_count (output_bfd
);
4255 else if ((type
& N_TYPE
) != N_SETT
4256 && (type
& N_TYPE
) != N_SETD
4257 && (type
& N_TYPE
) != N_SETB
4258 && (type
& N_TYPE
) != N_SETA
)
4263 case discard_sec_merge
:
4266 if ((type
& N_STAB
) == 0
4267 && bfd_is_local_label_name (input_bfd
, name
))
4281 /* An N_BINCL symbol indicates the start of the stabs
4282 entries for a header file. We need to scan ahead to the
4283 next N_EINCL symbol, ignoring nesting, adding up all the
4284 characters in the symbol names, not including the file
4285 numbers in types (the first number after an open
4287 if (type
== N_BINCL
)
4289 struct external_nlist
*incl_sym
;
4291 struct aout_link_includes_entry
*incl_entry
;
4292 struct aout_link_includes_totals
*t
;
4296 for (incl_sym
= sym
+ 1; incl_sym
< sym_end
; incl_sym
++)
4300 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4301 if (incl_type
== N_EINCL
)
4307 else if (incl_type
== N_BINCL
)
4313 s
= strings
+ GET_WORD (input_bfd
, incl_sym
->e_strx
);
4314 for (; *s
!= '\0'; s
++)
4319 /* Skip the file number. */
4321 while (ISDIGIT (*s
))
4329 /* If we have already included a header file with the
4330 same value, then replace this one with an N_EXCL
4332 copy
= ! flaginfo
->info
->keep_memory
;
4333 incl_entry
= aout_link_includes_lookup (&flaginfo
->includes
,
4335 if (incl_entry
== NULL
)
4337 for (t
= incl_entry
->totals
; t
!= NULL
; t
= t
->next
)
4338 if (t
->total
== val
)
4342 /* This is the first time we have seen this header
4343 file with this set of stabs strings. */
4344 t
= bfd_hash_allocate (&flaginfo
->includes
.root
,
4349 t
->next
= incl_entry
->totals
;
4350 incl_entry
->totals
= t
;
4356 /* This is a duplicate header file. We must change
4357 it to be an N_EXCL entry, and mark all the
4358 included symbols to prevent outputting them. */
4362 for (incl_sym
= sym
+ 1, incl_map
= symbol_map
+ 1;
4364 incl_sym
++, incl_map
++)
4368 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4369 if (incl_type
== N_EINCL
)
4378 else if (incl_type
== N_BINCL
)
4387 /* Copy this symbol into the list of symbols we are going to
4389 H_PUT_8 (output_bfd
, type
, outsym
->e_type
);
4391 if (! flaginfo
->info
->keep_memory
)
4393 /* name points into a string table which we are going to
4394 free. If there is a hash table entry, use that string.
4395 Otherwise, copy name into memory. */
4397 name
= h
->root
.root
.string
;
4401 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4403 if (strtab_index
== (bfd_size_type
) -1)
4405 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4406 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
4407 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
4408 ++obj_aout_external_sym_count (output_bfd
);
4412 /* Write out the output symbols we have just constructed. */
4413 if (outsym
> flaginfo
->output_syms
)
4417 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0)
4419 size
= outsym
- flaginfo
->output_syms
;
4420 size
*= EXTERNAL_NLIST_SIZE
;
4421 if (bfd_bwrite ((void *) flaginfo
->output_syms
, size
, output_bfd
) != size
)
4423 flaginfo
->symoff
+= size
;
4429 /* Write out a symbol that was not associated with an a.out input
4433 bfd_getp32 (const void *p
)
4435 const bfd_byte
*addr
= p
;
4438 v
= (unsigned long) addr
[1] << 24;
4439 v
|= (unsigned long) addr
[0] << 16;
4440 v
|= (unsigned long) addr
[3] << 8;
4441 v
|= (unsigned long) addr
[2];
4445 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
4447 static bfd_signed_vma
4448 bfd_getp_signed_32 (const void *p
)
4450 const bfd_byte
*addr
= p
;
4453 v
= (unsigned long) addr
[1] << 24;
4454 v
|= (unsigned long) addr
[0] << 16;
4455 v
|= (unsigned long) addr
[3] << 8;
4456 v
|= (unsigned long) addr
[2];
4457 return COERCE32 (v
);
4461 bfd_putp32 (bfd_vma data
, void *p
)
4465 addr
[0] = (data
>> 16) & 0xff;
4466 addr
[1] = (data
>> 24) & 0xff;
4467 addr
[2] = (data
>> 0) & 0xff;
4468 addr
[3] = (data
>> 8) & 0xff;
4471 const bfd_target
MY (vec
) =
4473 TARGETNAME
, /* Name. */
4474 bfd_target_aout_flavour
,
4475 BFD_ENDIAN_LITTLE
, /* Target byte order (little). */
4476 BFD_ENDIAN_LITTLE
, /* Target headers byte order (little). */
4477 (HAS_RELOC
| EXEC_P
| /* Object flags. */
4478 HAS_LINENO
| HAS_DEBUG
|
4479 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
),
4480 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_CODE
| SEC_DATA
),
4481 MY_symbol_leading_char
,
4482 AR_PAD_CHAR
, /* AR_pad_char. */
4483 15, /* AR_max_namelen. */
4484 0, /* match priority. */
4485 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4486 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4487 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Data. */
4488 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4489 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4490 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Headers. */
4491 { /* bfd_check_format. */
4494 bfd_generic_archive_p
,
4497 { /* bfd_set_format. */
4498 _bfd_bool_bfd_false_error
,
4500 _bfd_generic_mkarchive
,
4501 _bfd_bool_bfd_false_error
4503 { /* bfd_write_contents. */
4504 _bfd_bool_bfd_false_error
,
4505 MY_write_object_contents
,
4506 _bfd_write_archive_contents
,
4507 _bfd_bool_bfd_false_error
4510 BFD_JUMP_TABLE_GENERIC (MY
),
4511 BFD_JUMP_TABLE_COPY (MY
),
4512 BFD_JUMP_TABLE_CORE (MY
),
4513 BFD_JUMP_TABLE_ARCHIVE (MY
),
4514 BFD_JUMP_TABLE_SYMBOLS (MY
),
4515 BFD_JUMP_TABLE_RELOCS (MY
),
4516 BFD_JUMP_TABLE_WRITE (MY
),
4517 BFD_JUMP_TABLE_LINK (MY
),
4518 BFD_JUMP_TABLE_DYNAMIC (MY
),
4520 /* Alternative_target. */
4523 (void *) MY_backend_data