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 const bfd_target
*(*callback_to_real_object_p
) (bfd
*))
460 struct aout_data_struct
*rawptr
, *oldrawptr
;
461 const bfd_target
*result
;
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
;
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 result
= (*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
;
794 obj_textsec (abfd
)->filepos
= pos
;
795 if (! obj_textsec (abfd
)->user_set_vma
)
796 obj_textsec (abfd
)->vma
= vma
;
798 vma
= obj_textsec (abfd
)->vma
;
800 pos
+= obj_textsec (abfd
)->size
;
801 vma
+= obj_textsec (abfd
)->size
;
804 if (!obj_datasec (abfd
)->user_set_vma
)
806 obj_textsec (abfd
)->size
+= pad
;
809 obj_datasec (abfd
)->vma
= vma
;
812 vma
= obj_datasec (abfd
)->vma
;
813 obj_datasec (abfd
)->filepos
= pos
;
814 pos
+= obj_datasec (abfd
)->size
;
815 vma
+= obj_datasec (abfd
)->size
;
818 if (! obj_bsssec (abfd
)->user_set_vma
)
820 obj_datasec (abfd
)->size
+= pad
;
823 obj_bsssec (abfd
)->vma
= vma
;
827 /* The VMA of the .bss section is set by the VMA of the
828 .data section plus the size of the .data section. We may
829 need to add padding bytes to make this true. */
830 pad
= obj_bsssec (abfd
)->vma
- vma
;
833 obj_datasec (abfd
)->size
+= pad
;
837 obj_bsssec (abfd
)->filepos
= pos
;
839 /* Fix up the exec header. */
840 execp
->a_text
= obj_textsec (abfd
)->size
;
841 execp
->a_data
= obj_datasec (abfd
)->size
;
842 execp
->a_bss
= obj_bsssec (abfd
)->size
;
843 N_SET_MAGIC (execp
, OMAGIC
);
847 adjust_z_magic (bfd
*abfd
, struct internal_exec
*execp
)
849 bfd_size_type data_pad
, text_pad
;
851 const struct aout_backend_data
*abdp
;
852 int ztih
; /* Nonzero if text includes exec header. */
854 abdp
= aout_backend_info (abfd
);
858 && (abdp
->text_includes_header
859 || obj_aout_subformat (abfd
) == q_magic_format
));
860 obj_textsec(abfd
)->filepos
= (ztih
861 ? adata(abfd
).exec_bytes_size
862 : adata(abfd
).zmagic_disk_block_size
);
863 if (! obj_textsec(abfd
)->user_set_vma
)
865 /* ?? Do we really need to check for relocs here? */
866 obj_textsec(abfd
)->vma
= ((abfd
->flags
& HAS_RELOC
)
869 ? (abdp
->default_text_vma
870 + adata (abfd
).exec_bytes_size
)
871 : abdp
->default_text_vma
));
876 /* The .text section is being loaded at an unusual address. We
877 may need to pad it such that the .data section starts at a page
880 text_pad
= ((obj_textsec (abfd
)->filepos
- obj_textsec (abfd
)->vma
)
881 & (adata (abfd
).page_size
- 1));
883 text_pad
= ((- obj_textsec (abfd
)->vma
)
884 & (adata (abfd
).page_size
- 1));
887 /* Find start of data. */
890 text_end
= obj_textsec (abfd
)->filepos
+ obj_textsec (abfd
)->size
;
891 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
895 /* Note that if page_size == zmagic_disk_block_size, then
896 filepos == page_size, and this case is the same as the ztih
898 text_end
= obj_textsec (abfd
)->size
;
899 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
900 text_end
+= obj_textsec (abfd
)->filepos
;
903 obj_textsec (abfd
)->size
+= text_pad
;
904 text_end
+= text_pad
;
907 if (!obj_datasec(abfd
)->user_set_vma
)
910 vma
= obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->size
;
911 obj_datasec(abfd
)->vma
= BFD_ALIGN (vma
, adata(abfd
).segment_size
);
913 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
915 text_pad
= (obj_datasec(abfd
)->vma
916 - obj_textsec(abfd
)->vma
917 - obj_textsec(abfd
)->size
);
918 obj_textsec(abfd
)->size
+= text_pad
;
920 obj_datasec (abfd
)->filepos
= (obj_textsec (abfd
)->filepos
921 + obj_textsec (abfd
)->size
);
923 /* Fix up exec header while we're at it. */
924 execp
->a_text
= obj_textsec(abfd
)->size
;
925 if (ztih
&& (!abdp
|| (abdp
&& !abdp
->exec_header_not_counted
)))
926 execp
->a_text
+= adata(abfd
).exec_bytes_size
;
927 N_SET_MAGIC (execp
, ZMAGIC
);
929 /* Spec says data section should be rounded up to page boundary. */
930 obj_datasec(abfd
)->size
931 = align_power (obj_datasec(abfd
)->size
,
932 obj_bsssec(abfd
)->alignment_power
);
933 execp
->a_data
= BFD_ALIGN (obj_datasec(abfd
)->size
,
934 adata(abfd
).page_size
);
935 data_pad
= execp
->a_data
- obj_datasec(abfd
)->size
;
938 if (!obj_bsssec(abfd
)->user_set_vma
)
939 obj_bsssec(abfd
)->vma
= (obj_datasec(abfd
)->vma
940 + obj_datasec(abfd
)->size
);
941 /* If the BSS immediately follows the data section and extra space
942 in the page is left after the data section, fudge data
943 in the header so that the bss section looks smaller by that
944 amount. We'll start the bss section there, and lie to the OS.
945 (Note that a linker script, as well as the above assignment,
946 could have explicitly set the BSS vma to immediately follow
947 the data section.) */
948 if (align_power (obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->alignment_power
)
949 == obj_datasec(abfd
)->vma
+ obj_datasec(abfd
)->size
)
950 execp
->a_bss
= (data_pad
> obj_bsssec(abfd
)->size
) ? 0 :
951 obj_bsssec(abfd
)->size
- data_pad
;
953 execp
->a_bss
= obj_bsssec(abfd
)->size
;
957 adjust_n_magic (bfd
*abfd
, struct internal_exec
*execp
)
959 file_ptr pos
= adata(abfd
).exec_bytes_size
;
964 obj_textsec(abfd
)->filepos
= pos
;
965 if (!obj_textsec(abfd
)->user_set_vma
)
966 obj_textsec(abfd
)->vma
= vma
;
968 vma
= obj_textsec(abfd
)->vma
;
969 pos
+= obj_textsec(abfd
)->size
;
970 vma
+= obj_textsec(abfd
)->size
;
973 obj_datasec(abfd
)->filepos
= pos
;
974 if (!obj_datasec(abfd
)->user_set_vma
)
975 obj_datasec(abfd
)->vma
= BFD_ALIGN (vma
, adata(abfd
).segment_size
);
976 vma
= obj_datasec(abfd
)->vma
;
978 /* Since BSS follows data immediately, see if it needs alignment. */
979 vma
+= obj_datasec(abfd
)->size
;
980 pad
= align_power (vma
, obj_bsssec(abfd
)->alignment_power
) - vma
;
981 obj_datasec(abfd
)->size
+= pad
;
982 pos
+= obj_datasec(abfd
)->size
;
985 if (!obj_bsssec(abfd
)->user_set_vma
)
986 obj_bsssec(abfd
)->vma
= vma
;
988 vma
= obj_bsssec(abfd
)->vma
;
990 /* Fix up exec header. */
991 execp
->a_text
= obj_textsec(abfd
)->size
;
992 execp
->a_data
= obj_datasec(abfd
)->size
;
993 execp
->a_bss
= obj_bsssec(abfd
)->size
;
994 N_SET_MAGIC (execp
, NMAGIC
);
998 NAME (aout
, adjust_sizes_and_vmas
) (bfd
*abfd
)
1000 struct internal_exec
*execp
= exec_hdr (abfd
);
1002 if (! NAME (aout
, make_sections
) (abfd
))
1005 if (adata(abfd
).magic
!= undecided_magic
)
1008 obj_textsec(abfd
)->size
=
1009 align_power(obj_textsec(abfd
)->size
,
1010 obj_textsec(abfd
)->alignment_power
);
1012 /* Rule (heuristic) for when to pad to a new page. Note that there
1013 are (at least) two ways demand-paged (ZMAGIC) files have been
1014 handled. Most Berkeley-based systems start the text segment at
1015 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1016 segment right after the exec header; the latter is counted in the
1017 text segment size, and is paged in by the kernel with the rest of
1020 /* This perhaps isn't the right way to do this, but made it simpler for me
1021 to understand enough to implement it. Better would probably be to go
1022 right from BFD flags to alignment/positioning characteristics. But the
1023 old code was sloppy enough about handling the flags, and had enough
1024 other magic, that it was a little hard for me to understand. I think
1025 I understand it better now, but I haven't time to do the cleanup this
1028 if (abfd
->flags
& WP_TEXT
)
1029 adata(abfd
).magic
= n_magic
;
1031 adata(abfd
).magic
= o_magic
;
1033 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1035 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1037 switch (adata(abfd
).magic
) {
1038 case n_magic
: str
= "NMAGIC"; break;
1039 case o_magic
: str
= "OMAGIC"; break;
1040 case z_magic
: str
= "ZMAGIC"; break;
1045 obj_textsec(abfd
)->vma
, obj_textsec(abfd
)->size
,
1046 obj_textsec(abfd
)->alignment_power
,
1047 obj_datasec(abfd
)->vma
, obj_datasec(abfd
)->size
,
1048 obj_datasec(abfd
)->alignment_power
,
1049 obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->size
,
1050 obj_bsssec(abfd
)->alignment_power
);
1054 switch (adata(abfd
).magic
)
1057 adjust_o_magic (abfd
, execp
);
1060 adjust_z_magic (abfd
, execp
);
1063 adjust_n_magic (abfd
, execp
);
1069 #ifdef BFD_AOUT_DEBUG
1070 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1071 obj_textsec(abfd
)->vma
, obj_textsec(abfd
)->size
,
1072 obj_textsec(abfd
)->filepos
,
1073 obj_datasec(abfd
)->vma
, obj_datasec(abfd
)->size
,
1074 obj_datasec(abfd
)->filepos
,
1075 obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->size
);
1081 /* Called by the BFD in response to a bfd_make_section request. */
1084 NAME (aout
, new_section_hook
) (bfd
*abfd
, asection
*newsect
)
1086 /* Align to double at least. */
1087 newsect
->alignment_power
= bfd_get_arch_info(abfd
)->section_align_power
;
1089 if (bfd_get_format (abfd
) == bfd_object
)
1091 if (obj_textsec (abfd
) == NULL
1092 && !strcmp (newsect
->name
, ".text"))
1094 obj_textsec(abfd
)= newsect
;
1095 newsect
->target_index
= N_TEXT
;
1097 else if (obj_datasec (abfd
) == NULL
1098 && !strcmp (newsect
->name
, ".data"))
1100 obj_datasec (abfd
) = newsect
;
1101 newsect
->target_index
= N_DATA
;
1103 else if (obj_bsssec (abfd
) == NULL
1104 && !strcmp (newsect
->name
, ".bss"))
1106 obj_bsssec (abfd
) = newsect
;
1107 newsect
->target_index
= N_BSS
;
1111 /* We allow more than three sections internally. */
1112 return _bfd_generic_new_section_hook (abfd
, newsect
);
1116 NAME (aout
, set_section_contents
) (bfd
*abfd
,
1118 const void * location
,
1120 bfd_size_type count
)
1122 if (! abfd
->output_has_begun
)
1124 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
1128 if (section
== obj_bsssec (abfd
))
1130 bfd_set_error (bfd_error_no_contents
);
1134 if (section
!= obj_textsec (abfd
)
1135 && section
!= obj_datasec (abfd
))
1138 /* xgettext:c-format */
1139 (_("%pB: can not represent section `%pA' in a.out object file format"),
1141 bfd_set_error (bfd_error_nonrepresentable_section
);
1147 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
1148 || bfd_bwrite (location
, count
, abfd
) != count
)
1155 /* Read the external symbols from an a.out file. */
1158 aout_get_external_symbols (bfd
*abfd
)
1160 if (obj_aout_external_syms (abfd
) == NULL
)
1162 bfd_size_type count
;
1163 struct external_nlist
*syms
;
1165 count
= exec_hdr (abfd
)->a_syms
/ EXTERNAL_NLIST_SIZE
;
1167 /* PR 17512: file: 011f5a08. */
1170 obj_aout_external_syms (abfd
) = NULL
;
1171 obj_aout_external_sym_count (abfd
) = count
;
1176 if (! bfd_get_file_window (abfd
, obj_sym_filepos (abfd
),
1177 exec_hdr (abfd
)->a_syms
,
1178 &obj_aout_sym_window (abfd
), TRUE
))
1180 syms
= (struct external_nlist
*) obj_aout_sym_window (abfd
).data
;
1182 /* We allocate using malloc to make the values easy to free
1183 later on. If we put them on the objalloc it might not be
1184 possible to free them. */
1185 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1187 syms
= (struct external_nlist
*)
1188 _bfd_malloc_and_read (abfd
, count
* EXTERNAL_NLIST_SIZE
,
1189 count
* EXTERNAL_NLIST_SIZE
);
1190 if (syms
== NULL
&& count
!= 0)
1194 obj_aout_external_syms (abfd
) = syms
;
1195 obj_aout_external_sym_count (abfd
) = count
;
1198 if (obj_aout_external_strings (abfd
) == NULL
1199 && exec_hdr (abfd
)->a_syms
!= 0)
1201 unsigned char string_chars
[BYTES_IN_LONG
];
1202 bfd_size_type stringsize
;
1205 /* Get the size of the strings. */
1206 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
1207 || (bfd_bread ((void *) string_chars
, (bfd_size_type
) BYTES_IN_LONG
,
1208 abfd
) != BYTES_IN_LONG
))
1210 stringsize
= H_GET_32 (abfd
, string_chars
);
1213 if (! bfd_get_file_window (abfd
, obj_str_filepos (abfd
), stringsize
,
1214 &obj_aout_string_window (abfd
), TRUE
))
1216 strings
= (char *) obj_aout_string_window (abfd
).data
;
1218 strings
= bfd_malloc (stringsize
+ 1);
1219 if (strings
== NULL
)
1222 /* Skip space for the string count in the buffer for convenience
1223 when using indexes. */
1224 if (bfd_bread (strings
+ 4, stringsize
- 4, abfd
) != stringsize
- 4)
1230 /* Ensure that a zero index yields an empty string. */
1233 strings
[stringsize
- 1] = 0;
1235 obj_aout_external_strings (abfd
) = strings
;
1236 obj_aout_external_string_size (abfd
) = stringsize
;
1242 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1243 and symbol->value fields of CACHE_PTR will be set from the a.out
1244 nlist structure. This function is responsible for setting
1245 symbol->flags and symbol->section, and adjusting symbol->value. */
1248 translate_from_native_sym_flags (bfd
*abfd
,
1249 aout_symbol_type
*cache_ptr
)
1253 if (cache_ptr
->type
== N_FN
)
1257 /* This is a debugging symbol. */
1258 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1260 /* Work out the symbol section. */
1261 switch (cache_ptr
->type
& N_TYPE
)
1265 sec
= obj_textsec (abfd
);
1268 sec
= obj_datasec (abfd
);
1271 sec
= obj_bsssec (abfd
);
1275 sec
= bfd_abs_section_ptr
;
1279 cache_ptr
->symbol
.section
= sec
;
1280 cache_ptr
->symbol
.value
-= sec
->vma
;
1285 /* Get the default visibility. This does not apply to all types, so
1286 we just hold it in a local variable to use if wanted. */
1287 if ((cache_ptr
->type
& N_EXT
) == 0)
1288 visible
= BSF_LOCAL
;
1290 visible
= BSF_GLOBAL
;
1292 switch (cache_ptr
->type
)
1295 case N_ABS
: case N_ABS
| N_EXT
:
1296 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1297 cache_ptr
->symbol
.flags
= visible
;
1300 case N_UNDF
| N_EXT
:
1301 if (cache_ptr
->symbol
.value
!= 0)
1303 /* This is a common symbol. */
1304 cache_ptr
->symbol
.flags
= BSF_GLOBAL
;
1305 cache_ptr
->symbol
.section
= bfd_com_section_ptr
;
1309 cache_ptr
->symbol
.flags
= 0;
1310 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1314 case N_TEXT
: case N_TEXT
| N_EXT
:
1315 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1316 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1317 cache_ptr
->symbol
.flags
= visible
;
1320 case N_DATA
: case N_DATA
| N_EXT
:
1321 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1322 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1323 cache_ptr
->symbol
.flags
= visible
;
1326 case N_BSS
: case N_BSS
| N_EXT
:
1327 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1328 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1329 cache_ptr
->symbol
.flags
= visible
;
1336 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1339 translate_to_native_sym_flags (bfd
*abfd
,
1341 struct external_nlist
*sym_pointer
)
1343 bfd_vma value
= cache_ptr
->value
;
1347 /* Mask out any existing type bits in case copying from one section
1349 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1351 sec
= bfd_asymbol_section (cache_ptr
);
1356 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1359 /* xgettext:c-format */
1360 (_("%pB: can not represent section for symbol `%s' in a.out object file format"),
1361 abfd
, cache_ptr
->name
!= NULL
? cache_ptr
->name
: "*unknown*");
1362 bfd_set_error (bfd_error_nonrepresentable_section
);
1366 if (sec
->output_section
!= NULL
)
1368 off
= sec
->output_offset
;
1369 sec
= sec
->output_section
;
1372 if (bfd_is_abs_section (sec
))
1373 sym_pointer
->e_type
[0] |= N_ABS
;
1374 else if (sec
== obj_textsec (abfd
))
1375 sym_pointer
->e_type
[0] |= N_TEXT
;
1376 else if (sec
== obj_datasec (abfd
))
1377 sym_pointer
->e_type
[0] |= N_DATA
;
1378 else if (sec
== obj_bsssec (abfd
))
1379 sym_pointer
->e_type
[0] |= N_BSS
;
1380 else if (bfd_is_und_section (sec
))
1381 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1382 else if (bfd_is_com_section (sec
))
1383 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1387 /* xgettext:c-format */
1388 (_("%pB: can not represent section `%pA' in a.out object file format"),
1390 bfd_set_error (bfd_error_nonrepresentable_section
);
1394 /* Turn the symbol from section relative to absolute again */
1395 value
+= sec
->vma
+ off
;
1397 if ((cache_ptr
->flags
& BSF_DEBUGGING
) != 0)
1398 sym_pointer
->e_type
[0] = ((aout_symbol_type
*) cache_ptr
)->type
;
1399 else if ((cache_ptr
->flags
& BSF_GLOBAL
) != 0)
1400 sym_pointer
->e_type
[0] |= N_EXT
;
1402 PUT_WORD(abfd
, value
, sym_pointer
->e_value
);
1407 /* Native-level interface to symbols. */
1410 NAME (aout
, make_empty_symbol
) (bfd
*abfd
)
1412 size_t amt
= sizeof (aout_symbol_type
);
1413 aout_symbol_type
*new_symbol_type
= bfd_zalloc (abfd
, amt
);
1415 if (!new_symbol_type
)
1417 new_symbol_type
->symbol
.the_bfd
= abfd
;
1419 return &new_symbol_type
->symbol
;
1422 /* Translate a set of internal symbols into external symbols. */
1425 NAME (aout
, translate_symbol_table
) (bfd
*abfd
,
1426 aout_symbol_type
*in
,
1427 struct external_nlist
*ext
,
1428 bfd_size_type count
,
1430 bfd_size_type strsize
,
1431 bfd_boolean dynamic
)
1433 struct external_nlist
*ext_end
;
1435 ext_end
= ext
+ count
;
1436 for (; ext
< ext_end
; ext
++, in
++)
1440 x
= GET_WORD (abfd
, ext
->e_strx
);
1441 in
->symbol
.the_bfd
= abfd
;
1443 /* For the normal symbols, the zero index points at the number
1444 of bytes in the string table but is to be interpreted as the
1445 null string. For the dynamic symbols, the number of bytes in
1446 the string table is stored in the __DYNAMIC structure and the
1447 zero index points at an actual string. */
1448 if (x
== 0 && ! dynamic
)
1449 in
->symbol
.name
= "";
1450 else if (x
< strsize
)
1451 in
->symbol
.name
= str
+ x
;
1455 in
->symbol
.value
= GET_SWORD (abfd
, ext
->e_value
);
1456 /* TODO: is 0 a safe value here? */
1459 in
->type
= H_GET_8 (abfd
, ext
->e_type
);
1460 in
->symbol
.udata
.p
= NULL
;
1462 if (! translate_from_native_sym_flags (abfd
, in
))
1466 in
->symbol
.flags
|= BSF_DYNAMIC
;
1472 /* We read the symbols into a buffer, which is discarded when this
1473 function exits. We read the strings into a buffer large enough to
1474 hold them all plus all the cached symbol entries. */
1477 NAME (aout
, slurp_symbol_table
) (bfd
*abfd
)
1479 struct external_nlist
*old_external_syms
;
1480 aout_symbol_type
*cached
;
1481 bfd_size_type cached_size
;
1483 /* If there's no work to be done, don't do any. */
1484 if (obj_aout_symbols (abfd
) != NULL
)
1487 old_external_syms
= obj_aout_external_syms (abfd
);
1489 if (! aout_get_external_symbols (abfd
))
1492 cached_size
= obj_aout_external_sym_count (abfd
);
1493 cached_size
*= sizeof (aout_symbol_type
);
1494 cached
= bfd_zmalloc (cached_size
);
1495 if (cached
== NULL
&& cached_size
!= 0)
1498 /* Convert from external symbol information to internal. */
1499 if (! (NAME (aout
, translate_symbol_table
)
1501 obj_aout_external_syms (abfd
),
1502 obj_aout_external_sym_count (abfd
),
1503 obj_aout_external_strings (abfd
),
1504 obj_aout_external_string_size (abfd
),
1511 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
1513 obj_aout_symbols (abfd
) = cached
;
1515 /* It is very likely that anybody who calls this function will not
1516 want the external symbol information, so if it was allocated
1517 because of our call to aout_get_external_symbols, we free it up
1518 right away to save space. */
1519 if (old_external_syms
== NULL
1520 && obj_aout_external_syms (abfd
) != NULL
)
1523 bfd_free_window (&obj_aout_sym_window (abfd
));
1525 free (obj_aout_external_syms (abfd
));
1527 obj_aout_external_syms (abfd
) = NULL
;
1533 /* We use a hash table when writing out symbols so that we only write
1534 out a particular string once. This helps particularly when the
1535 linker writes out stabs debugging entries, because each different
1536 contributing object file tends to have many duplicate stabs
1539 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1540 if BFD_TRADITIONAL_FORMAT is set. */
1542 /* Get the index of a string in a strtab, adding it if it is not
1545 static INLINE bfd_size_type
1546 add_to_stringtab (bfd
*abfd
,
1547 struct bfd_strtab_hash
*tab
,
1552 bfd_size_type str_index
;
1554 /* An index of 0 always means the empty string. */
1555 if (str
== 0 || *str
== '\0')
1558 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1559 doesn't understand a hashed string table. */
1561 if ((abfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1564 str_index
= _bfd_stringtab_add (tab
, str
, hash
, copy
);
1566 if (str_index
!= (bfd_size_type
) -1)
1567 /* Add BYTES_IN_LONG to the return value to account for the
1568 space taken up by the string table size. */
1569 str_index
+= BYTES_IN_LONG
;
1574 /* Write out a strtab. ABFD is already at the right location in the
1578 emit_stringtab (bfd
*abfd
, struct bfd_strtab_hash
*tab
)
1580 bfd_byte buffer
[BYTES_IN_LONG
];
1582 /* The string table starts with the size. */
1583 H_PUT_32 (abfd
, _bfd_stringtab_size (tab
) + BYTES_IN_LONG
, buffer
);
1584 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) BYTES_IN_LONG
, abfd
)
1588 return _bfd_stringtab_emit (abfd
, tab
);
1592 NAME (aout
, write_syms
) (bfd
*abfd
)
1594 unsigned int count
;
1595 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1596 struct bfd_strtab_hash
*strtab
;
1598 strtab
= _bfd_stringtab_init ();
1602 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1604 asymbol
*g
= generic
[count
];
1606 struct external_nlist nsp
;
1608 PUT_WORD (abfd
, 0, nsp
.e_unused
);
1610 indx
= add_to_stringtab (abfd
, strtab
, g
->name
, FALSE
);
1611 if (indx
== (bfd_size_type
) -1)
1613 PUT_WORD (abfd
, indx
, nsp
.e_strx
);
1615 if (bfd_asymbol_flavour(g
) == abfd
->xvec
->flavour
)
1616 H_PUT_8 (abfd
, aout_symbol(g
)->type
, nsp
.e_type
);
1618 H_PUT_8 (abfd
, 0, nsp
.e_type
);
1620 if (! translate_to_native_sym_flags (abfd
, g
, &nsp
))
1623 H_PUT_8 (abfd
, 0, nsp
.e_ovly
);
1625 if (bfd_bwrite ((void *)&nsp
, (bfd_size_type
) EXTERNAL_NLIST_SIZE
, abfd
)
1626 != EXTERNAL_NLIST_SIZE
)
1629 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1630 here, at the end. */
1634 if (! emit_stringtab (abfd
, strtab
))
1637 _bfd_stringtab_free (strtab
);
1642 _bfd_stringtab_free (strtab
);
1648 NAME (aout
, canonicalize_symtab
) (bfd
*abfd
, asymbol
**location
)
1650 unsigned int counter
= 0;
1651 aout_symbol_type
*symbase
;
1653 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
1656 for (symbase
= obj_aout_symbols (abfd
); counter
++ < bfd_get_symcount (abfd
);)
1657 *(location
++) = (asymbol
*)(symbase
++);
1659 return bfd_get_symcount (abfd
);
1663 /* Output extended relocation information to a file in target byte order. */
1666 pdp11_aout_swap_reloc_out (bfd
*abfd
, arelent
*g
, bfd_byte
*natptr
)
1672 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1673 asection
*output_section
= sym
->section
->output_section
;
1676 fprintf (stderr
, "BFD: can't do this reloc addend stuff\n");
1678 r_pcrel
= g
->howto
->pc_relative
;
1680 if (bfd_is_abs_section (output_section
))
1682 else if (output_section
== obj_textsec (abfd
))
1684 else if (output_section
== obj_datasec (abfd
))
1686 else if (output_section
== obj_bsssec (abfd
))
1688 else if (bfd_is_und_section (output_section
))
1690 else if (bfd_is_com_section (output_section
))
1695 BFD_ASSERT (r_type
!= -1);
1700 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
1702 reloc_entry
= r_index
<< 4 | r_type
| r_pcrel
;
1704 PUT_WORD (abfd
, reloc_entry
, natptr
);
1707 /* BFD deals internally with all things based from the section they're
1708 in. so, something in 10 bytes into a text section with a base of
1709 50 would have a symbol (.text+10) and know .text vma was 50.
1711 Aout keeps all it's symbols based from zero, so the symbol would
1712 contain 60. This macro subs the base of each section from the value
1713 to give the true offset from the section */
1716 #define MOVE_ADDRESS(ad) \
1719 /* Undefined symbol. */ \
1720 cache_ptr->sym_ptr_ptr = symbols + r_index; \
1721 cache_ptr->addend = ad; \
1725 /* Defined, section relative. replace symbol with pointer to \
1726 symbol which points to section. */ \
1730 case N_TEXT | N_EXT: \
1731 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
1732 cache_ptr->addend = ad - su->textsec->vma; \
1735 case N_DATA | N_EXT: \
1736 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
1737 cache_ptr->addend = ad - su->datasec->vma; \
1740 case N_BSS | N_EXT: \
1741 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
1742 cache_ptr->addend = ad - su->bsssec->vma; \
1746 case N_ABS | N_EXT: \
1747 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1748 cache_ptr->addend = ad; \
1754 pdp11_aout_swap_reloc_in (bfd
* abfd
,
1756 arelent
* cache_ptr
,
1757 bfd_size_type offset
,
1759 bfd_size_type symcount
)
1761 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
1762 unsigned int r_index
;
1767 reloc_entry
= GET_WORD (abfd
, (void *) bytes
);
1769 r_pcrel
= reloc_entry
& RELFLG
;
1771 cache_ptr
->address
= offset
;
1772 cache_ptr
->howto
= howto_table_pdp11
+ (r_pcrel
? 1 : 0);
1774 if ((reloc_entry
& RTYPE
) == RABS
)
1777 r_index
= RINDEX (reloc_entry
);
1779 /* r_extern reflects whether the symbol the reloc is against is
1781 r_extern
= (reloc_entry
& RTYPE
) == REXT
;
1783 if (r_extern
&& r_index
> symcount
)
1785 /* We could arrange to return an error, but it might be useful
1786 to see the file even if it is bad. */
1794 /* Read and swap the relocs for a section. */
1797 NAME (aout
, slurp_reloc_table
) (bfd
*abfd
, sec_ptr asect
, asymbol
**symbols
)
1800 bfd_size_type count
;
1801 bfd_size_type reloc_size
;
1803 arelent
*reloc_cache
;
1805 unsigned int counter
= 0;
1808 if (asect
->relocation
)
1811 if (asect
->flags
& SEC_CONSTRUCTOR
)
1814 if (asect
== obj_datasec (abfd
))
1815 reloc_size
= exec_hdr(abfd
)->a_drsize
;
1816 else if (asect
== obj_textsec (abfd
))
1817 reloc_size
= exec_hdr(abfd
)->a_trsize
;
1818 else if (asect
== obj_bsssec (abfd
))
1822 bfd_set_error (bfd_error_invalid_operation
);
1826 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
1828 relocs
= _bfd_malloc_and_read (abfd
, reloc_size
, reloc_size
);
1829 if (relocs
== NULL
&& reloc_size
!= 0)
1832 each_size
= obj_reloc_entry_size (abfd
);
1833 count
= reloc_size
/ each_size
;
1835 /* Count the number of NON-ZERO relocs, this is the count we want. */
1837 unsigned int real_count
= 0;
1839 for (counter
= 0; counter
< count
; counter
++)
1843 x
= GET_WORD (abfd
, (char *) relocs
+ each_size
* counter
);
1851 reloc_cache
= bfd_zmalloc (count
* sizeof (arelent
));
1852 if (reloc_cache
== NULL
&& count
!= 0)
1855 cache_ptr
= reloc_cache
;
1860 counter
++, rptr
+= RELOC_SIZE
, cache_ptr
++)
1862 while (GET_WORD (abfd
, (void *) rptr
) == 0)
1865 if ((char *) rptr
>= (char *) relocs
+ reloc_size
)
1869 pdp11_aout_swap_reloc_in (abfd
, rptr
, cache_ptr
,
1870 (bfd_size_type
) ((char *) rptr
- (char *) relocs
),
1872 (bfd_size_type
) bfd_get_symcount (abfd
));
1875 /* Just in case, if rptr >= relocs + reloc_size should happen
1877 BFD_ASSERT (counter
== count
);
1881 asect
->relocation
= reloc_cache
;
1882 asect
->reloc_count
= cache_ptr
- reloc_cache
;
1887 /* Write out a relocation section into an object file. */
1890 NAME (aout
, squirt_out_relocs
) (bfd
*abfd
, asection
*section
)
1893 unsigned char *native
;
1894 unsigned int count
= section
->reloc_count
;
1895 bfd_size_type natsize
;
1897 natsize
= section
->size
;
1898 native
= bfd_zalloc (abfd
, natsize
);
1902 generic
= section
->orelocation
;
1903 if (generic
!= NULL
)
1909 r
= native
+ (*generic
)->address
;
1910 pdp11_aout_swap_reloc_out (abfd
, *generic
, r
);
1916 if (bfd_bwrite ((void *) native
, natsize
, abfd
) != natsize
)
1918 bfd_release (abfd
, native
);
1922 bfd_release (abfd
, native
);
1926 /* This is stupid. This function should be a boolean predicate. */
1929 NAME (aout
, canonicalize_reloc
) (bfd
*abfd
,
1934 arelent
*tblptr
= section
->relocation
;
1937 if (section
== obj_bsssec (abfd
))
1943 if (!(tblptr
|| NAME (aout
, slurp_reloc_table
)(abfd
, section
, symbols
)))
1946 if (section
->flags
& SEC_CONSTRUCTOR
)
1948 arelent_chain
*chain
= section
->constructor_chain
;
1950 for (count
= 0; count
< section
->reloc_count
; count
++)
1952 *relptr
++ = &chain
->relent
;
1953 chain
= chain
->next
;
1958 tblptr
= section
->relocation
;
1960 for (count
= 0; count
++ < section
->reloc_count
;)
1961 *relptr
++ = tblptr
++;
1966 return section
->reloc_count
;
1970 NAME (aout
, get_reloc_upper_bound
) (bfd
*abfd
, sec_ptr asect
)
1972 bfd_size_type count
;
1974 if (bfd_get_format (abfd
) != bfd_object
)
1976 bfd_set_error (bfd_error_invalid_operation
);
1980 if (asect
->flags
& SEC_CONSTRUCTOR
)
1981 count
= asect
->reloc_count
;
1982 else if (asect
== obj_datasec (abfd
))
1983 count
= exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
1984 else if (asect
== obj_textsec (abfd
))
1985 count
= exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
1986 else if (asect
== obj_bsssec (abfd
))
1990 bfd_set_error (bfd_error_invalid_operation
);
1994 if (count
>= LONG_MAX
/ sizeof (arelent
*))
1996 bfd_set_error (bfd_error_file_too_big
);
1999 return (count
+ 1) * sizeof (arelent
*);
2004 NAME (aout
, get_symtab_upper_bound
) (bfd
*abfd
)
2006 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
2009 return (bfd_get_symcount (abfd
) + 1) * (sizeof (aout_symbol_type
*));
2013 NAME (aout
, get_lineno
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2014 asymbol
* symbol ATTRIBUTE_UNUSED
)
2020 NAME (aout
, get_symbol_info
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2024 bfd_symbol_info (symbol
, ret
);
2026 if (ret
->type
== '?')
2028 int type_code
= aout_symbol(symbol
)->type
& 0xff;
2029 const char *stab_name
= bfd_get_stab_name (type_code
);
2030 static char buf
[10];
2032 if (stab_name
== NULL
)
2034 sprintf(buf
, "(%d)", type_code
);
2038 ret
->stab_type
= type_code
;
2039 ret
->stab_other
= (unsigned) (aout_symbol(symbol
)->other
& 0xff);
2040 ret
->stab_desc
= (unsigned) (aout_symbol(symbol
)->desc
& 0xffff);
2041 ret
->stab_name
= stab_name
;
2046 NAME (aout
, print_symbol
) (bfd
* abfd
,
2049 bfd_print_symbol_type how
)
2051 FILE *file
= (FILE *) afile
;
2055 case bfd_print_symbol_name
:
2057 fprintf(file
,"%s", symbol
->name
);
2059 case bfd_print_symbol_more
:
2060 fprintf(file
,"%4x %2x %2x",
2061 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2062 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2063 (unsigned) (aout_symbol (symbol
)->type
));
2065 case bfd_print_symbol_all
:
2067 const char *section_name
= symbol
->section
->name
;
2069 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2071 fprintf (file
," %-5s %04x %02x %02x",
2073 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2074 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2075 (unsigned) (aout_symbol (symbol
)->type
& 0xff));
2077 fprintf(file
," %s", symbol
->name
);
2083 /* If we don't have to allocate more than 1MB to hold the generic
2084 symbols, we use the generic minisymbol method: it's faster, since
2085 it only translates the symbols once, not multiple times. */
2086 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2088 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2089 symbols. The minisymbol_to_symbol function translates these into
2090 BFD asymbol structures. */
2093 NAME (aout
, read_minisymbols
) (bfd
*abfd
,
2094 bfd_boolean dynamic
,
2096 unsigned int *sizep
)
2099 /* We could handle the dynamic symbols here as well, but it's
2100 easier to hand them off. */
2101 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2103 if (! aout_get_external_symbols (abfd
))
2106 if (obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2107 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2109 *minisymsp
= (void *) obj_aout_external_syms (abfd
);
2111 /* By passing the external symbols back from this routine, we are
2112 giving up control over the memory block. Clear
2113 obj_aout_external_syms, so that we do not try to free it
2115 obj_aout_external_syms (abfd
) = NULL
;
2117 *sizep
= EXTERNAL_NLIST_SIZE
;
2118 return obj_aout_external_sym_count (abfd
);
2121 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2122 unmodified a.out symbol. The SYM argument is a structure returned
2123 by bfd_make_empty_symbol, which we fill in here. */
2126 NAME (aout
, minisymbol_to_symbol
) (bfd
*abfd
,
2127 bfd_boolean dynamic
,
2128 const void * minisym
,
2132 || obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2133 return _bfd_generic_minisymbol_to_symbol (abfd
, dynamic
, minisym
, sym
);
2135 memset (sym
, 0, sizeof (aout_symbol_type
));
2137 /* We call translate_symbol_table to translate a single symbol. */
2138 if (! (NAME (aout
, translate_symbol_table
)
2140 (aout_symbol_type
*) sym
,
2141 (struct external_nlist
*) minisym
,
2143 obj_aout_external_strings (abfd
),
2144 obj_aout_external_string_size (abfd
),
2151 /* Provided a BFD, a section and an offset into the section, calculate
2152 and return the name of the source file and the line nearest to the
2156 NAME (aout
, find_nearest_line
) (bfd
*abfd
,
2160 const char **filename_ptr
,
2161 const char **functionname_ptr
,
2162 unsigned int *line_ptr
,
2163 unsigned int *discriminator_ptr
)
2165 /* Run down the file looking for the filename, function and linenumber. */
2167 const char *directory_name
= NULL
;
2168 const char *main_file_name
= NULL
;
2169 const char *current_file_name
= NULL
;
2170 const char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2171 bfd_vma low_line_vma
= 0;
2172 bfd_vma low_func_vma
= 0;
2174 size_t filelen
, funclen
;
2177 *filename_ptr
= abfd
->filename
;
2178 *functionname_ptr
= 0;
2180 if (discriminator_ptr
)
2181 *discriminator_ptr
= 0;
2183 if (symbols
!= NULL
)
2185 for (p
= symbols
; *p
; p
++)
2187 aout_symbol_type
*q
= (aout_symbol_type
*)(*p
);
2192 /* If this looks like a file name symbol, and it comes after
2193 the line number we have found so far, but before the
2194 offset, then we have probably not found the right line
2196 if (q
->symbol
.value
<= offset
2197 && ((q
->symbol
.value
> low_line_vma
2198 && (line_file_name
!= NULL
2200 || (q
->symbol
.value
> low_func_vma
2203 const char * symname
;
2205 symname
= q
->symbol
.name
;
2206 if (strcmp (symname
+ strlen (symname
) - 2, ".o") == 0)
2208 if (q
->symbol
.value
> low_line_vma
)
2211 line_file_name
= NULL
;
2213 if (q
->symbol
.value
> low_func_vma
)
2220 /* If this symbol is less than the offset, but greater than
2221 the line number we have found so far, then we have not
2222 found the right line number. */
2223 if (q
->symbol
.value
<= offset
)
2225 if (q
->symbol
.value
> low_line_vma
)
2228 line_file_name
= NULL
;
2230 if (q
->symbol
.value
> low_func_vma
)
2234 main_file_name
= current_file_name
= q
->symbol
.name
;
2235 /* Look ahead to next symbol to check if that too is an N_SO. */
2239 q
= (aout_symbol_type
*)(*p
);
2240 if (q
->type
!= (int) N_SO
)
2243 /* Found a second N_SO First is directory; second is filename. */
2244 directory_name
= current_file_name
;
2245 main_file_name
= current_file_name
= q
->symbol
.name
;
2246 if (obj_textsec(abfd
) != section
)
2250 current_file_name
= q
->symbol
.name
;
2256 /* We'll keep this if it resolves nearer than the one we have
2258 if (q
->symbol
.value
>= low_line_vma
2259 && q
->symbol
.value
<= offset
)
2261 *line_ptr
= q
->desc
;
2262 low_line_vma
= q
->symbol
.value
;
2263 line_file_name
= current_file_name
;
2269 /* We'll keep this if it is nearer than the one we have already. */
2270 if (q
->symbol
.value
>= low_func_vma
&&
2271 q
->symbol
.value
<= offset
)
2273 low_func_vma
= q
->symbol
.value
;
2274 func
= (asymbol
*) q
;
2276 else if (q
->symbol
.value
> offset
)
2286 main_file_name
= line_file_name
;
2288 if (main_file_name
== NULL
2289 || main_file_name
[0] == '/'
2290 || directory_name
== NULL
)
2293 filelen
= strlen (directory_name
) + strlen (main_file_name
);
2297 funclen
= strlen (bfd_asymbol_name (func
));
2299 if (adata (abfd
).line_buf
!= NULL
)
2300 free (adata (abfd
).line_buf
);
2301 if (filelen
+ funclen
== 0)
2302 adata (abfd
).line_buf
= buf
= NULL
;
2305 buf
= bfd_malloc ((bfd_size_type
) filelen
+ funclen
+ 3);
2306 adata (abfd
).line_buf
= buf
;
2311 if (main_file_name
!= NULL
)
2313 if (main_file_name
[0] == '/' || directory_name
== NULL
)
2314 *filename_ptr
= main_file_name
;
2317 sprintf (buf
, "%s%s", directory_name
, main_file_name
);
2318 *filename_ptr
= buf
;
2325 const char *function
= func
->name
;
2328 /* The caller expects a symbol name. We actually have a
2329 function name, without the leading underscore. Put the
2330 underscore back in, so that the caller gets a symbol name. */
2331 if (bfd_get_symbol_leading_char (abfd
) == '\0')
2332 strcpy (buf
, function
);
2335 buf
[0] = bfd_get_symbol_leading_char (abfd
);
2336 strcpy (buf
+ 1, function
);
2339 /* Have to remove : stuff. */
2340 colon
= strchr (buf
, ':');
2343 *functionname_ptr
= buf
;
2350 NAME (aout
, sizeof_headers
) (bfd
*abfd
,
2351 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2353 return adata (abfd
).exec_bytes_size
;
2356 /* Free all information we have cached for this BFD. We can always
2357 read it again later if we need it. */
2360 NAME (aout
, bfd_free_cached_info
) (bfd
*abfd
)
2364 if (bfd_get_format (abfd
) != bfd_object
)
2367 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2368 BFCI_FREE (obj_aout_symbols (abfd
));
2371 obj_aout_external_syms (abfd
) = 0;
2372 bfd_free_window (&obj_aout_sym_window (abfd
));
2373 bfd_free_window (&obj_aout_string_window (abfd
));
2374 obj_aout_external_strings (abfd
) = 0;
2376 BFCI_FREE (obj_aout_external_syms (abfd
));
2377 BFCI_FREE (obj_aout_external_strings (abfd
));
2379 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2380 BFCI_FREE (o
->relocation
);
2386 /* Routine to create an entry in an a.out link hash table. */
2388 struct bfd_hash_entry
*
2389 NAME (aout
, link_hash_newfunc
) (struct bfd_hash_entry
*entry
,
2390 struct bfd_hash_table
*table
,
2393 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2395 /* Allocate the structure if it has not already been allocated by a
2398 ret
= bfd_hash_allocate (table
, sizeof (* ret
));
2402 /* Call the allocation method of the superclass. */
2403 ret
= (struct aout_link_hash_entry
*)
2404 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
);
2407 /* Set local fields. */
2408 ret
->written
= FALSE
;
2412 return (struct bfd_hash_entry
*) ret
;
2415 /* Initialize an a.out link hash table. */
2418 NAME (aout
, link_hash_table_init
) (struct aout_link_hash_table
*table
,
2420 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
2421 struct bfd_hash_table
*,
2423 unsigned int entsize
)
2425 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
2428 /* Create an a.out link hash table. */
2430 struct bfd_link_hash_table
*
2431 NAME (aout
, link_hash_table_create
) (bfd
*abfd
)
2433 struct aout_link_hash_table
*ret
;
2434 size_t amt
= sizeof (struct aout_link_hash_table
);
2436 ret
= bfd_malloc (amt
);
2439 if (! NAME (aout
, link_hash_table_init
) (ret
, abfd
,
2440 NAME (aout
, link_hash_newfunc
),
2441 sizeof (struct aout_link_hash_entry
)))
2449 /* Free up the internal symbols read from an a.out file. */
2452 aout_link_free_symbols (bfd
*abfd
)
2454 if (obj_aout_external_syms (abfd
) != NULL
)
2457 bfd_free_window (&obj_aout_sym_window (abfd
));
2459 free ((void *) obj_aout_external_syms (abfd
));
2461 obj_aout_external_syms (abfd
) = NULL
;
2464 if (obj_aout_external_strings (abfd
) != NULL
)
2467 bfd_free_window (&obj_aout_string_window (abfd
));
2469 free ((void *) obj_aout_external_strings (abfd
));
2471 obj_aout_external_strings (abfd
) = NULL
;
2476 /* Given an a.out BFD, add symbols to the global hash table as
2480 NAME (aout
, link_add_symbols
) (bfd
*abfd
, struct bfd_link_info
*info
)
2482 switch (bfd_get_format (abfd
))
2485 return aout_link_add_object_symbols (abfd
, info
);
2487 return _bfd_generic_link_add_archive_symbols
2488 (abfd
, info
, aout_link_check_archive_element
);
2490 bfd_set_error (bfd_error_wrong_format
);
2495 /* Add symbols from an a.out object file. */
2498 aout_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2500 if (! aout_get_external_symbols (abfd
))
2502 if (! aout_link_add_symbols (abfd
, info
))
2504 if (! info
->keep_memory
)
2506 if (! aout_link_free_symbols (abfd
))
2512 /* Look through the internal symbols to see if this object file should
2513 be included in the link. We should include this object file if it
2514 defines any symbols which are currently undefined. If this object
2515 file defines a common symbol, then we may adjust the size of the
2516 known symbol but we do not include the object file in the link
2517 (unless there is some other reason to include it). */
2520 aout_link_check_ar_symbols (bfd
*abfd
,
2521 struct bfd_link_info
*info
,
2522 bfd_boolean
*pneeded
,
2525 struct external_nlist
*p
;
2526 struct external_nlist
*pend
;
2531 /* Look through all the symbols. */
2532 p
= obj_aout_external_syms (abfd
);
2533 pend
= p
+ obj_aout_external_sym_count (abfd
);
2534 strings
= obj_aout_external_strings (abfd
);
2535 for (; p
< pend
; p
++)
2537 int type
= H_GET_8 (abfd
, p
->e_type
);
2539 struct bfd_link_hash_entry
*h
;
2541 /* Ignore symbols that are not externally visible. This is an
2542 optimization only, as we check the type more thoroughly
2544 if ((type
& N_EXT
) == 0
2548 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2549 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
2551 /* We are only interested in symbols that are currently
2552 undefined or common. */
2554 || (h
->type
!= bfd_link_hash_undefined
2555 && h
->type
!= bfd_link_hash_common
))
2558 if (type
== (N_TEXT
| N_EXT
)
2559 || type
== (N_DATA
| N_EXT
)
2560 || type
== (N_BSS
| N_EXT
)
2561 || type
== (N_ABS
| N_EXT
))
2563 /* This object file defines this symbol. We must link it
2564 in. This is true regardless of whether the current
2565 definition of the symbol is undefined or common. If the
2566 current definition is common, we have a case in which we
2567 have already seen an object file including
2569 and this object file from the archive includes
2571 In such a case we must include this object file.
2573 FIXME: The SunOS 4.1.3 linker will pull in the archive
2574 element if the symbol is defined in the .data section,
2575 but not if it is defined in the .text section. That
2576 seems a bit crazy to me, and I haven't implemented it.
2577 However, it might be correct. */
2578 if (!(*info
->callbacks
2579 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2585 if (type
== (N_UNDF
| N_EXT
))
2589 value
= GET_WORD (abfd
, p
->e_value
);
2592 /* This symbol is common in the object from the archive
2594 if (h
->type
== bfd_link_hash_undefined
)
2599 symbfd
= h
->u
.undef
.abfd
;
2602 /* This symbol was created as undefined from
2603 outside BFD. We assume that we should link
2604 in the object file. This is done for the -u
2605 option in the linker. */
2606 if (!(*info
->callbacks
2607 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2612 /* Turn the current link symbol into a common
2613 symbol. It is already on the undefs list. */
2614 h
->type
= bfd_link_hash_common
;
2615 h
->u
.c
.p
= bfd_hash_allocate (&info
->hash
->table
,
2616 sizeof (struct bfd_link_hash_common_entry
));
2617 if (h
->u
.c
.p
== NULL
)
2620 h
->u
.c
.size
= value
;
2622 /* FIXME: This isn't quite right. The maximum
2623 alignment of a common symbol should be set by the
2624 architecture of the output file, not of the input
2626 power
= bfd_log2 (value
);
2627 if (power
> bfd_get_arch_info (abfd
)->section_align_power
)
2628 power
= bfd_get_arch_info (abfd
)->section_align_power
;
2629 h
->u
.c
.p
->alignment_power
= power
;
2631 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
,
2636 /* Adjust the size of the common symbol if
2638 if (value
> h
->u
.c
.size
)
2639 h
->u
.c
.size
= value
;
2645 /* We do not need this object file. */
2649 /* Check a single archive element to see if we need to include it in
2650 the link. *PNEEDED is set according to whether this element is
2651 needed in the link or not. This is called from
2652 _bfd_generic_link_add_archive_symbols. */
2655 aout_link_check_archive_element (bfd
*abfd
,
2656 struct bfd_link_info
*info
,
2657 struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
2658 const char *name ATTRIBUTE_UNUSED
,
2659 bfd_boolean
*pneeded
)
2664 if (!aout_get_external_symbols (abfd
))
2668 if (!aout_link_check_ar_symbols (abfd
, info
, pneeded
, &abfd
))
2674 /* Potentially, the add_archive_element hook may have set a
2675 substitute BFD for us. */
2678 if (!info
->keep_memory
2679 && !aout_link_free_symbols (oldbfd
))
2681 if (!aout_get_external_symbols (abfd
))
2684 if (!aout_link_add_symbols (abfd
, info
))
2688 if (!info
->keep_memory
|| !needed
)
2690 if (!aout_link_free_symbols (abfd
))
2697 /* Add all symbols from an object file to the hash table. */
2700 aout_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2702 bfd_boolean (*add_one_symbol
)
2703 (struct bfd_link_info
*, bfd
*, const char *, flagword
, asection
*,
2704 bfd_vma
, const char *, bfd_boolean
, bfd_boolean
,
2705 struct bfd_link_hash_entry
**);
2706 struct external_nlist
*syms
;
2707 bfd_size_type sym_count
;
2710 struct aout_link_hash_entry
**sym_hash
;
2711 struct external_nlist
*p
;
2712 struct external_nlist
*pend
;
2714 syms
= obj_aout_external_syms (abfd
);
2715 sym_count
= obj_aout_external_sym_count (abfd
);
2716 strings
= obj_aout_external_strings (abfd
);
2717 if (info
->keep_memory
)
2722 if (aout_backend_info (abfd
)->add_dynamic_symbols
!= NULL
)
2724 if (! ((*aout_backend_info (abfd
)->add_dynamic_symbols
)
2725 (abfd
, info
, &syms
, &sym_count
, &strings
)))
2729 /* We keep a list of the linker hash table entries that correspond
2730 to particular symbols. We could just look them up in the hash
2731 table, but keeping the list is more efficient. Perhaps this
2732 should be conditional on info->keep_memory. */
2733 sym_hash
= bfd_alloc (abfd
,
2734 sym_count
* sizeof (struct aout_link_hash_entry
*));
2735 if (sym_hash
== NULL
&& sym_count
!= 0)
2737 obj_aout_sym_hashes (abfd
) = sym_hash
;
2739 add_one_symbol
= aout_backend_info (abfd
)->add_one_symbol
;
2740 if (add_one_symbol
== NULL
)
2741 add_one_symbol
= _bfd_generic_link_add_one_symbol
;
2744 pend
= p
+ sym_count
;
2745 for (; p
< pend
; p
++, sym_hash
++)
2756 type
= H_GET_8 (abfd
, p
->e_type
);
2758 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2759 value
= GET_WORD (abfd
, p
->e_value
);
2765 /* Anything else should be a debugging symbol. */
2766 BFD_ASSERT ((type
& N_STAB
) != 0);
2776 /* Ignore symbols that are not externally visible. */
2779 case N_UNDF
| N_EXT
:
2782 section
= bfd_und_section_ptr
;
2786 section
= bfd_com_section_ptr
;
2789 section
= bfd_abs_section_ptr
;
2791 case N_TEXT
| N_EXT
:
2792 section
= obj_textsec (abfd
);
2793 value
-= bfd_section_vma (section
);
2795 case N_DATA
| N_EXT
:
2796 /* Treat N_SETV symbols as N_DATA symbol; see comment in
2797 translate_from_native_sym_flags. */
2798 section
= obj_datasec (abfd
);
2799 value
-= bfd_section_vma (section
);
2802 section
= obj_bsssec (abfd
);
2803 value
-= bfd_section_vma (section
);
2807 if (! ((*add_one_symbol
)
2808 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, FALSE
,
2809 (struct bfd_link_hash_entry
**) sym_hash
)))
2812 /* Restrict the maximum alignment of a common symbol based on
2813 the architecture, since a.out has no way to represent
2814 alignment requirements of a section in a .o file. FIXME:
2815 This isn't quite right: it should use the architecture of the
2816 output file, not the input files. */
2817 if ((*sym_hash
)->root
.type
== bfd_link_hash_common
2818 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
>
2819 bfd_get_arch_info (abfd
)->section_align_power
))
2820 (*sym_hash
)->root
.u
.c
.p
->alignment_power
=
2821 bfd_get_arch_info (abfd
)->section_align_power
;
2823 /* If this is a set symbol, and we are not building sets, then
2824 it is possible for the hash entry to not have been set. In
2825 such a case, treat the symbol as not globally defined. */
2826 if ((*sym_hash
)->root
.type
== bfd_link_hash_new
)
2828 BFD_ASSERT ((flags
& BSF_CONSTRUCTOR
) != 0);
2836 /* Look up an entry in an the header file hash table. */
2838 #define aout_link_includes_lookup(table, string, create, copy) \
2839 ((struct aout_link_includes_entry *) \
2840 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
2842 /* The function to create a new entry in the header file hash table. */
2844 static struct bfd_hash_entry
*
2845 aout_link_includes_newfunc (struct bfd_hash_entry
*entry
,
2846 struct bfd_hash_table
*table
,
2849 struct aout_link_includes_entry
* ret
=
2850 (struct aout_link_includes_entry
*) entry
;
2852 /* Allocate the structure if it has not already been allocated by a
2855 ret
= bfd_hash_allocate (table
,
2856 sizeof (struct aout_link_includes_entry
));
2860 /* Call the allocation method of the superclass. */
2861 ret
= ((struct aout_link_includes_entry
*)
2862 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
2864 /* Set local fields. */
2867 return (struct bfd_hash_entry
*) ret
;
2871 aout_link_write_other_symbol (struct bfd_hash_entry
*bh
, void *data
)
2873 struct aout_link_hash_entry
*h
= (struct aout_link_hash_entry
*) bh
;
2874 struct aout_final_link_info
*flaginfo
= (struct aout_final_link_info
*) data
;
2878 struct external_nlist outsym
;
2882 if (h
->root
.type
== bfd_link_hash_warning
)
2884 h
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
2885 if (h
->root
.type
== bfd_link_hash_new
)
2889 output_bfd
= flaginfo
->output_bfd
;
2891 if (aout_backend_info (output_bfd
)->write_dynamic_symbol
!= NULL
)
2893 if (! ((*aout_backend_info (output_bfd
)->write_dynamic_symbol
)
2894 (output_bfd
, flaginfo
->info
, h
)))
2896 /* FIXME: No way to handle errors. */
2906 /* An indx of -2 means the symbol must be written. */
2908 && (flaginfo
->info
->strip
== strip_all
2909 || (flaginfo
->info
->strip
== strip_some
2910 && bfd_hash_lookup (flaginfo
->info
->keep_hash
, h
->root
.root
.string
,
2911 FALSE
, FALSE
) == NULL
)))
2914 switch (h
->root
.type
)
2918 /* Avoid variable not initialized warnings. */
2920 case bfd_link_hash_new
:
2921 /* This can happen for set symbols when sets are not being
2924 case bfd_link_hash_undefined
:
2925 type
= N_UNDF
| N_EXT
;
2928 case bfd_link_hash_defined
:
2929 case bfd_link_hash_defweak
:
2933 sec
= h
->root
.u
.def
.section
->output_section
;
2934 BFD_ASSERT (bfd_is_abs_section (sec
)
2935 || sec
->owner
== output_bfd
);
2936 if (sec
== obj_textsec (output_bfd
))
2937 type
= h
->root
.type
== bfd_link_hash_defined
? N_TEXT
: N_WEAKT
;
2938 else if (sec
== obj_datasec (output_bfd
))
2939 type
= h
->root
.type
== bfd_link_hash_defined
? N_DATA
: N_WEAKD
;
2940 else if (sec
== obj_bsssec (output_bfd
))
2941 type
= h
->root
.type
== bfd_link_hash_defined
? N_BSS
: N_WEAKB
;
2943 type
= h
->root
.type
== bfd_link_hash_defined
? N_ABS
: N_WEAKA
;
2945 val
= (h
->root
.u
.def
.value
2947 + h
->root
.u
.def
.section
->output_offset
);
2950 case bfd_link_hash_common
:
2951 type
= N_UNDF
| N_EXT
;
2952 val
= h
->root
.u
.c
.size
;
2954 case bfd_link_hash_undefweak
:
2958 case bfd_link_hash_indirect
:
2959 case bfd_link_hash_warning
:
2960 /* FIXME: Ignore these for now. The circumstances under which
2961 they should be written out are not clear to me. */
2965 H_PUT_8 (output_bfd
, type
, outsym
.e_type
);
2966 indx
= add_to_stringtab (output_bfd
, flaginfo
->strtab
, h
->root
.root
.string
,
2968 if (indx
== (bfd_size_type
) -1)
2969 /* FIXME: No way to handle errors. */
2972 PUT_WORD (output_bfd
, indx
, outsym
.e_strx
);
2973 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
2975 amt
= EXTERNAL_NLIST_SIZE
;
2976 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0
2977 || bfd_bwrite ((void *) &outsym
, amt
, output_bfd
) != amt
)
2978 /* FIXME: No way to handle errors. */
2981 flaginfo
->symoff
+= amt
;
2982 h
->indx
= obj_aout_external_sym_count (output_bfd
);
2983 ++obj_aout_external_sym_count (output_bfd
);
2988 /* Handle a link order which is supposed to generate a reloc. */
2991 aout_link_reloc_link_order (struct aout_final_link_info
*flaginfo
,
2993 struct bfd_link_order
*p
)
2995 struct bfd_link_order_reloc
*pr
;
2998 reloc_howto_type
*howto
;
2999 file_ptr
*reloff_ptr
;
3000 struct reloc_std_external srel
;
3002 bfd_size_type rel_size
;
3006 if (p
->type
== bfd_section_reloc_link_order
)
3009 if (bfd_is_abs_section (pr
->u
.section
))
3010 r_index
= N_ABS
| N_EXT
;
3013 BFD_ASSERT (pr
->u
.section
->owner
== flaginfo
->output_bfd
);
3014 r_index
= pr
->u
.section
->target_index
;
3019 struct aout_link_hash_entry
*h
;
3021 BFD_ASSERT (p
->type
== bfd_symbol_reloc_link_order
);
3023 h
= ((struct aout_link_hash_entry
*)
3024 bfd_wrapped_link_hash_lookup (flaginfo
->output_bfd
, flaginfo
->info
,
3025 pr
->u
.name
, FALSE
, FALSE
, TRUE
));
3031 /* We decided to strip this symbol, but it turns out that we
3032 can't. Note that we lose the other and desc information
3033 here. I don't think that will ever matter for a global
3037 if (!aout_link_write_other_symbol (&h
->root
.root
, flaginfo
))
3043 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3044 (flaginfo
->info
, pr
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
3049 howto
= bfd_reloc_type_lookup (flaginfo
->output_bfd
, pr
->reloc
);
3052 bfd_set_error (bfd_error_bad_value
);
3056 if (o
== obj_textsec (flaginfo
->output_bfd
))
3057 reloff_ptr
= &flaginfo
->treloff
;
3058 else if (o
== obj_datasec (flaginfo
->output_bfd
))
3059 reloff_ptr
= &flaginfo
->dreloff
;
3064 MY_put_reloc(flaginfo
->output_bfd
, r_extern
, r_index
, p
->offset
, howto
,
3074 fprintf (stderr
, "TODO: line %d in bfd/pdp11.c\n", __LINE__
);
3076 r_pcrel
= howto
->pc_relative
;
3077 r_baserel
= (howto
->type
& 8) != 0;
3078 r_jmptable
= (howto
->type
& 16) != 0;
3079 r_relative
= (howto
->type
& 32) != 0;
3080 r_length
= howto
->size
;
3082 PUT_WORD (flaginfo
->output_bfd
, p
->offset
, srel
.r_address
);
3083 if (bfd_header_big_endian (flaginfo
->output_bfd
))
3085 srel
.r_index
[0] = r_index
>> 16;
3086 srel
.r_index
[1] = r_index
>> 8;
3087 srel
.r_index
[2] = r_index
;
3089 ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
3090 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
3091 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
3092 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
3093 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
3094 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
3098 srel
.r_index
[2] = r_index
>> 16;
3099 srel
.r_index
[1] = r_index
>> 8;
3100 srel
.r_index
[0] = r_index
;
3102 ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
3103 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
3104 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
3105 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
3106 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
3107 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
3111 rel_ptr
= (void *) &srel
;
3113 /* We have to write the addend into the object file, since
3114 standard a.out relocs are in place. It would be more
3115 reliable if we had the current contents of the file here,
3116 rather than assuming zeroes, but we can't read the file since
3117 it was opened using bfd_openw. */
3118 if (pr
->addend
!= 0)
3121 bfd_reloc_status_type r
;
3125 size
= bfd_get_reloc_size (howto
);
3126 buf
= bfd_zmalloc (size
);
3127 if (buf
== NULL
&& size
!= 0)
3129 r
= MY_relocate_contents (howto
, flaginfo
->output_bfd
,
3136 case bfd_reloc_outofrange
:
3138 case bfd_reloc_overflow
:
3139 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3140 (flaginfo
->info
, NULL
,
3141 (p
->type
== bfd_section_reloc_link_order
3142 ? bfd_section_name (pr
->u
.section
)
3144 howto
->name
, pr
->addend
, NULL
,
3145 (asection
*) NULL
, (bfd_vma
) 0);
3148 ok
= bfd_set_section_contents (flaginfo
->output_bfd
, o
,
3150 (file_ptr
) p
->offset
,
3157 rel_size
= obj_reloc_entry_size (flaginfo
->output_bfd
);
3158 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0
3159 || bfd_bwrite (rel_ptr
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3162 *reloff_ptr
+= rel_size
;
3164 /* Assert that the relocs have not run into the symbols, and that n
3165 the text relocs have not run into the data relocs. */
3166 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3167 && (reloff_ptr
!= &flaginfo
->treloff
3169 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3174 /* Get the section corresponding to a reloc index. */
3176 static inline asection
*
3177 aout_reloc_type_to_section (bfd
*abfd
, int type
)
3181 case RTEXT
: return obj_textsec (abfd
);
3182 case RDATA
: return obj_datasec (abfd
);
3183 case RBSS
: return obj_bsssec (abfd
);
3184 case RABS
: return bfd_abs_section_ptr
;
3185 case REXT
: return bfd_und_section_ptr
;
3191 pdp11_aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3193 asection
*input_section
,
3195 bfd_size_type rel_size
,
3198 bfd_boolean (*check_dynamic_reloc
)
3199 (struct bfd_link_info
*, bfd
*, asection
*,
3200 struct aout_link_hash_entry
*, void *, bfd_byte
*, bfd_boolean
*,
3203 bfd_boolean relocatable
;
3204 struct external_nlist
*syms
;
3206 struct aout_link_hash_entry
**sym_hashes
;
3211 output_bfd
= flaginfo
->output_bfd
;
3212 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
3214 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_SIZE
);
3215 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
3216 == output_bfd
->xvec
->header_byteorder
);
3218 relocatable
= bfd_link_relocatable (flaginfo
->info
);
3219 syms
= obj_aout_external_syms (input_bfd
);
3220 strings
= obj_aout_external_strings (input_bfd
);
3221 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
3222 symbol_map
= flaginfo
->symbol_map
;
3225 rel_end
= rel
+ rel_size
;
3226 for (; rel
< rel_end
; rel
+= RELOC_SIZE
)
3233 reloc_howto_type
*howto
;
3234 struct aout_link_hash_entry
*h
= NULL
;
3236 bfd_reloc_status_type r
;
3239 reloc_entry
= GET_WORD (input_bfd
, (void *) rel
);
3240 if (reloc_entry
== 0)
3244 unsigned int howto_idx
;
3246 r_index
= (reloc_entry
& RIDXMASK
) >> 4;
3247 r_type
= reloc_entry
& RTYPE
;
3248 r_pcrel
= reloc_entry
& RELFLG
;
3249 r_addr
= (char *) rel
- (char *) relocs
;
3251 r_extern
= (r_type
== REXT
);
3253 howto_idx
= r_pcrel
;
3254 BFD_ASSERT (howto_idx
< TABLE_SIZE (howto_table_pdp11
));
3255 howto
= howto_table_pdp11
+ howto_idx
;
3260 /* We are generating a relocatable output file, and must
3261 modify the reloc accordingly. */
3264 /* If we know the symbol this relocation is against,
3265 convert it into a relocation against a section. This
3266 is what the native linker does. */
3267 h
= sym_hashes
[r_index
];
3269 && (h
->root
.type
== bfd_link_hash_defined
3270 || h
->root
.type
== bfd_link_hash_defweak
))
3272 asection
*output_section
;
3274 /* Compute a new r_index. */
3275 output_section
= h
->root
.u
.def
.section
->output_section
;
3276 if (output_section
== obj_textsec (output_bfd
))
3278 else if (output_section
== obj_datasec (output_bfd
))
3280 else if (output_section
== obj_bsssec (output_bfd
))
3285 /* Add the symbol value and the section VMA to the
3286 addend stored in the contents. */
3287 relocation
= (h
->root
.u
.def
.value
3288 + output_section
->vma
3289 + h
->root
.u
.def
.section
->output_offset
);
3293 /* We must change r_index according to the symbol
3295 r_index
= symbol_map
[r_index
];
3301 /* We decided to strip this symbol, but it
3302 turns out that we can't. Note that we
3303 lose the other and desc information here.
3304 I don't think that will ever matter for a
3310 if (!aout_link_write_other_symbol (&h
->root
.root
,
3320 name
= strings
+ GET_WORD (input_bfd
,
3321 syms
[r_index
].e_strx
);
3322 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3323 (flaginfo
->info
, name
, input_bfd
, input_section
,
3332 /* Write out the new r_index value. */
3333 reloc_entry
= GET_WORD (input_bfd
, rel
);
3334 reloc_entry
&= RIDXMASK
;
3335 reloc_entry
|= r_index
<< 4;
3336 PUT_WORD (input_bfd
, reloc_entry
, rel
);
3342 /* This is a relocation against a section. We must
3343 adjust by the amount that the section moved. */
3344 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3345 relocation
= (section
->output_section
->vma
3346 + section
->output_offset
3350 /* Change the address of the relocation. */
3351 fprintf (stderr
, "TODO: change the address of the relocation\n");
3353 /* Adjust a PC relative relocation by removing the reference
3354 to the original address in the section and including the
3355 reference to the new address. */
3357 relocation
-= (input_section
->output_section
->vma
3358 + input_section
->output_offset
3359 - input_section
->vma
);
3361 #ifdef MY_relocatable_reloc
3362 MY_relocatable_reloc (howto
, output_bfd
, rel
, relocation
, r_addr
);
3365 if (relocation
== 0)
3368 r
= MY_relocate_contents (howto
,
3369 input_bfd
, relocation
,
3376 /* We are generating an executable, and must do a full
3381 h
= sym_hashes
[r_index
];
3384 && (h
->root
.type
== bfd_link_hash_defined
3385 || h
->root
.type
== bfd_link_hash_defweak
))
3387 relocation
= (h
->root
.u
.def
.value
3388 + h
->root
.u
.def
.section
->output_section
->vma
3389 + h
->root
.u
.def
.section
->output_offset
);
3392 && h
->root
.type
== bfd_link_hash_undefweak
)
3404 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3405 relocation
= (section
->output_section
->vma
3406 + section
->output_offset
3409 relocation
+= input_section
->vma
;
3412 if (check_dynamic_reloc
!= NULL
)
3416 if (! ((*check_dynamic_reloc
)
3417 (flaginfo
->info
, input_bfd
, input_section
, h
,
3418 (void *) rel
, contents
, &skip
, &relocation
)))
3424 /* Now warn if a global symbol is undefined. We could not
3425 do this earlier, because check_dynamic_reloc might want
3426 to skip this reloc. */
3427 if (hundef
&& ! bfd_link_pic (flaginfo
->info
))
3432 name
= h
->root
.root
.string
;
3434 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
3435 (*flaginfo
->info
->callbacks
->undefined_symbol
)
3436 (flaginfo
->info
, name
, input_bfd
, input_section
,
3440 r
= MY_final_link_relocate (howto
,
3441 input_bfd
, input_section
,
3442 contents
, r_addr
, relocation
,
3446 if (r
!= bfd_reloc_ok
)
3451 case bfd_reloc_outofrange
:
3453 case bfd_reloc_overflow
:
3460 name
= strings
+ GET_WORD (input_bfd
,
3461 syms
[r_index
].e_strx
);
3466 s
= aout_reloc_type_to_section (input_bfd
, r_type
);
3467 name
= bfd_section_name (s
);
3469 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3470 (flaginfo
->info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3471 (bfd_vma
) 0, input_bfd
, input_section
, r_addr
);
3481 /* Link an a.out section into the output file. */
3484 aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3486 asection
*input_section
,
3487 file_ptr
*reloff_ptr
,
3488 bfd_size_type rel_size
)
3490 bfd_size_type input_size
;
3493 /* Get the section contents. */
3494 input_size
= input_section
->size
;
3495 if (! bfd_get_section_contents (input_bfd
, input_section
,
3496 (void *) flaginfo
->contents
,
3497 (file_ptr
) 0, input_size
))
3500 /* Read in the relocs if we haven't already done it. */
3501 if (aout_section_data (input_section
) != NULL
3502 && aout_section_data (input_section
)->relocs
!= NULL
)
3503 relocs
= aout_section_data (input_section
)->relocs
;
3506 relocs
= flaginfo
->relocs
;
3509 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3510 || bfd_bread (relocs
, rel_size
, input_bfd
) != rel_size
)
3515 /* Relocate the section contents. */
3516 if (! pdp11_aout_link_input_section (flaginfo
, input_bfd
, input_section
,
3517 (bfd_byte
*) relocs
,
3518 rel_size
, flaginfo
->contents
))
3521 /* Write out the section contents. */
3522 if (! bfd_set_section_contents (flaginfo
->output_bfd
,
3523 input_section
->output_section
,
3524 (void *) flaginfo
->contents
,
3525 (file_ptr
) input_section
->output_offset
,
3529 /* If we are producing relocatable output, the relocs were
3530 modified, and we now write them out. */
3531 if (bfd_link_relocatable (flaginfo
->info
) && rel_size
> 0)
3533 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
3535 if (bfd_bwrite (relocs
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3537 *reloff_ptr
+= rel_size
;
3539 /* Assert that the relocs have not run into the symbols, and
3540 that if these are the text relocs they have not run into the
3542 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3543 && (reloff_ptr
!= &flaginfo
->treloff
3545 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3551 /* Link an a.out input BFD into the output file. */
3554 aout_link_input_bfd (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
3556 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
3558 /* If this is a dynamic object, it may need special handling. */
3559 if ((input_bfd
->flags
& DYNAMIC
) != 0
3560 && aout_backend_info (input_bfd
)->link_dynamic_object
!= NULL
)
3561 return ((*aout_backend_info (input_bfd
)->link_dynamic_object
)
3562 (flaginfo
->info
, input_bfd
));
3564 /* Get the symbols. We probably have them already, unless
3565 flaginfo->info->keep_memory is FALSE. */
3566 if (! aout_get_external_symbols (input_bfd
))
3569 /* Write out the symbols and get a map of the new indices. The map
3570 is placed into flaginfo->symbol_map. */
3571 if (! aout_link_write_symbols (flaginfo
, input_bfd
))
3574 /* Relocate and write out the sections. These functions use the
3575 symbol map created by aout_link_write_symbols. The linker_mark
3576 field will be set if these sections are to be included in the
3577 link, which will normally be the case. */
3578 if (obj_textsec (input_bfd
)->linker_mark
)
3580 if (! aout_link_input_section (flaginfo
, input_bfd
,
3581 obj_textsec (input_bfd
),
3583 exec_hdr (input_bfd
)->a_trsize
))
3586 if (obj_datasec (input_bfd
)->linker_mark
)
3588 if (! aout_link_input_section (flaginfo
, input_bfd
,
3589 obj_datasec (input_bfd
),
3591 exec_hdr (input_bfd
)->a_drsize
))
3595 /* If we are not keeping memory, we don't need the symbols any
3596 longer. We still need them if we are keeping memory, because the
3597 strings in the hash table point into them. */
3598 if (! flaginfo
->info
->keep_memory
)
3600 if (! aout_link_free_symbols (input_bfd
))
3607 /* Do the final link step. This is called on the output BFD. The
3608 INFO structure should point to a list of BFDs linked through the
3609 link.next field which can be used to find each BFD which takes part
3610 in the output. Also, each section in ABFD should point to a list
3611 of bfd_link_order structures which list all the input sections for
3612 the output section. */
3615 NAME (aout
, final_link
) (bfd
*abfd
,
3616 struct bfd_link_info
*info
,
3617 void (*callback
) (bfd
*, file_ptr
*, file_ptr
*, file_ptr
*))
3619 struct aout_final_link_info aout_info
;
3620 bfd_boolean includes_hash_initialized
= FALSE
;
3622 bfd_size_type trsize
, drsize
;
3623 bfd_size_type max_contents_size
;
3624 bfd_size_type max_relocs_size
;
3625 bfd_size_type max_sym_count
;
3626 struct bfd_link_order
*p
;
3628 bfd_boolean have_link_order_relocs
;
3630 if (bfd_link_pic (info
))
3631 abfd
->flags
|= DYNAMIC
;
3633 aout_info
.info
= info
;
3634 aout_info
.output_bfd
= abfd
;
3635 aout_info
.contents
= NULL
;
3636 aout_info
.relocs
= NULL
;
3637 aout_info
.symbol_map
= NULL
;
3638 aout_info
.output_syms
= NULL
;
3640 if (!bfd_hash_table_init_n (&aout_info
.includes
.root
,
3641 aout_link_includes_newfunc
,
3642 sizeof (struct aout_link_includes_entry
),
3645 includes_hash_initialized
= TRUE
;
3647 /* Figure out the largest section size. Also, if generating
3648 relocatable output, count the relocs. */
3651 max_contents_size
= 0;
3652 max_relocs_size
= 0;
3654 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3658 if (bfd_link_relocatable (info
))
3660 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3662 trsize
+= exec_hdr (sub
)->a_trsize
;
3663 drsize
+= exec_hdr (sub
)->a_drsize
;
3667 /* FIXME: We need to identify the .text and .data sections
3668 and call get_reloc_upper_bound and canonicalize_reloc to
3669 work out the number of relocs needed, and then multiply
3670 by the reloc size. */
3672 /* xgettext:c-format */
3673 (_("%pB: relocatable link from %s to %s not supported"),
3674 abfd
, sub
->xvec
->name
, abfd
->xvec
->name
);
3675 bfd_set_error (bfd_error_invalid_operation
);
3680 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3682 sz
= obj_textsec (sub
)->size
;
3683 if (sz
> max_contents_size
)
3684 max_contents_size
= sz
;
3685 sz
= obj_datasec (sub
)->size
;
3686 if (sz
> max_contents_size
)
3687 max_contents_size
= sz
;
3689 sz
= exec_hdr (sub
)->a_trsize
;
3690 if (sz
> max_relocs_size
)
3691 max_relocs_size
= sz
;
3692 sz
= exec_hdr (sub
)->a_drsize
;
3693 if (sz
> max_relocs_size
)
3694 max_relocs_size
= sz
;
3696 sz
= obj_aout_external_sym_count (sub
);
3697 if (sz
> max_sym_count
)
3702 if (bfd_link_relocatable (info
))
3704 if (obj_textsec (abfd
) != NULL
)
3705 trsize
+= (_bfd_count_link_order_relocs (obj_textsec (abfd
)
3706 ->map_head
.link_order
)
3707 * obj_reloc_entry_size (abfd
));
3708 if (obj_datasec (abfd
) != NULL
)
3709 drsize
+= (_bfd_count_link_order_relocs (obj_datasec (abfd
)
3710 ->map_head
.link_order
)
3711 * obj_reloc_entry_size (abfd
));
3714 exec_hdr (abfd
)->a_trsize
= trsize
;
3715 exec_hdr (abfd
)->a_drsize
= drsize
;
3716 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
3718 /* Adjust the section sizes and vmas according to the magic number.
3719 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3720 filepos for each section. */
3721 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
3724 /* The relocation and symbol file positions differ among a.out
3725 targets. We are passed a callback routine from the backend
3726 specific code to handle this.
3727 FIXME: At this point we do not know how much space the symbol
3728 table will require. This will not work for any (nonstandard)
3729 a.out target that needs to know the symbol table size before it
3730 can compute the relocation file positions. */
3731 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
3733 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
3734 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
3735 obj_sym_filepos (abfd
) = aout_info
.symoff
;
3737 /* We keep a count of the symbols as we output them. */
3738 obj_aout_external_sym_count (abfd
) = 0;
3740 /* We accumulate the string table as we write out the symbols. */
3741 aout_info
.strtab
= _bfd_stringtab_init ();
3742 if (aout_info
.strtab
== NULL
)
3745 /* Allocate buffers to hold section contents and relocs. */
3746 aout_info
.contents
= bfd_malloc (max_contents_size
);
3747 aout_info
.relocs
= bfd_malloc (max_relocs_size
);
3748 aout_info
.symbol_map
= bfd_malloc (max_sym_count
* sizeof (int *));
3749 aout_info
.output_syms
= bfd_malloc ((max_sym_count
+ 1)
3750 * sizeof (struct external_nlist
));
3751 if ((aout_info
.contents
== NULL
&& max_contents_size
!= 0)
3752 || (aout_info
.relocs
== NULL
&& max_relocs_size
!= 0)
3753 || (aout_info
.symbol_map
== NULL
&& max_sym_count
!= 0)
3754 || aout_info
.output_syms
== NULL
)
3757 /* If we have a symbol named __DYNAMIC, force it out now. This is
3758 required by SunOS. Doing this here rather than in sunos.c is a
3759 hack, but it's easier than exporting everything which would be
3762 struct aout_link_hash_entry
*h
;
3764 h
= aout_link_hash_lookup (aout_hash_table (info
), "__DYNAMIC",
3765 FALSE
, FALSE
, FALSE
);
3767 aout_link_write_other_symbol (&h
->root
.root
, &aout_info
);
3770 /* The most time efficient way to do the link would be to read all
3771 the input object files into memory and then sort out the
3772 information into the output file. Unfortunately, that will
3773 probably use too much memory. Another method would be to step
3774 through everything that composes the text section and write it
3775 out, and then everything that composes the data section and write
3776 it out, and then write out the relocs, and then write out the
3777 symbols. Unfortunately, that requires reading stuff from each
3778 input file several times, and we will not be able to keep all the
3779 input files open simultaneously, and reopening them will be slow.
3781 What we do is basically process one input file at a time. We do
3782 everything we need to do with an input file once--copy over the
3783 section contents, handle the relocation information, and write
3784 out the symbols--and then we throw away the information we read
3785 from it. This approach requires a lot of lseeks of the output
3786 file, which is unfortunate but still faster than reopening a lot
3789 We use the output_has_begun field of the input BFDs to see
3790 whether we have already handled it. */
3791 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3792 sub
->output_has_begun
= FALSE
;
3794 /* Mark all sections which are to be included in the link. This
3795 will normally be every section. We need to do this so that we
3796 can identify any sections which the linker has decided to not
3798 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3800 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
3801 if (p
->type
== bfd_indirect_link_order
)
3802 p
->u
.indirect
.section
->linker_mark
= TRUE
;
3805 have_link_order_relocs
= FALSE
;
3806 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3808 for (p
= o
->map_head
.link_order
;
3812 if (p
->type
== bfd_indirect_link_order
3813 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
3814 == bfd_target_aout_flavour
))
3818 input_bfd
= p
->u
.indirect
.section
->owner
;
3819 if (! input_bfd
->output_has_begun
)
3821 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
3823 input_bfd
->output_has_begun
= TRUE
;
3826 else if (p
->type
== bfd_section_reloc_link_order
3827 || p
->type
== bfd_symbol_reloc_link_order
)
3828 /* These are handled below. */
3829 have_link_order_relocs
= TRUE
;
3832 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3838 /* Write out any symbols that we have not already written out. */
3839 bfd_hash_traverse (&info
->hash
->table
,
3840 aout_link_write_other_symbol
,
3843 /* Now handle any relocs we were asked to create by the linker.
3844 These did not come from any input file. We must do these after
3845 we have written out all the symbols, so that we know the symbol
3847 if (have_link_order_relocs
)
3849 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3851 for (p
= o
->map_head
.link_order
;
3855 if (p
->type
== bfd_section_reloc_link_order
3856 || p
->type
== bfd_symbol_reloc_link_order
)
3858 if (! aout_link_reloc_link_order (&aout_info
, o
, p
))
3865 if (aout_info
.contents
!= NULL
)
3867 free (aout_info
.contents
);
3868 aout_info
.contents
= NULL
;
3870 if (aout_info
.relocs
!= NULL
)
3872 free (aout_info
.relocs
);
3873 aout_info
.relocs
= NULL
;
3875 if (aout_info
.symbol_map
!= NULL
)
3877 free (aout_info
.symbol_map
);
3878 aout_info
.symbol_map
= NULL
;
3880 if (aout_info
.output_syms
!= NULL
)
3882 free (aout_info
.output_syms
);
3883 aout_info
.output_syms
= NULL
;
3885 if (includes_hash_initialized
)
3887 bfd_hash_table_free (&aout_info
.includes
.root
);
3888 includes_hash_initialized
= FALSE
;
3891 /* Finish up any dynamic linking we may be doing. */
3892 if (aout_backend_info (abfd
)->finish_dynamic_link
!= NULL
)
3894 if (! (*aout_backend_info (abfd
)->finish_dynamic_link
) (abfd
, info
))
3898 /* Update the header information. */
3899 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
3900 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
3901 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
3902 obj_textsec (abfd
)->reloc_count
=
3903 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
3904 obj_datasec (abfd
)->reloc_count
=
3905 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
3907 /* Write out the string table, unless there are no symbols. */
3908 if (abfd
->symcount
> 0)
3910 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
3911 || ! emit_stringtab (abfd
, aout_info
.strtab
))
3914 else if (obj_textsec (abfd
)->reloc_count
== 0
3915 && obj_datasec (abfd
)->reloc_count
== 0)
3921 (file_ptr
) (obj_datasec (abfd
)->filepos
3922 + exec_hdr (abfd
)->a_data
3925 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3932 if (aout_info
.contents
!= NULL
)
3933 free (aout_info
.contents
);
3934 if (aout_info
.relocs
!= NULL
)
3935 free (aout_info
.relocs
);
3936 if (aout_info
.symbol_map
!= NULL
)
3937 free (aout_info
.symbol_map
);
3938 if (aout_info
.output_syms
!= NULL
)
3939 free (aout_info
.output_syms
);
3940 if (includes_hash_initialized
)
3941 bfd_hash_table_free (&aout_info
.includes
.root
);
3945 /* Adjust and write out the symbols for an a.out file. Set the new
3946 symbol indices into a symbol_map. */
3949 aout_link_write_symbols (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
3952 bfd_size_type sym_count
;
3954 enum bfd_link_strip strip
;
3955 enum bfd_link_discard discard
;
3956 struct external_nlist
*outsym
;
3957 bfd_size_type strtab_index
;
3958 struct external_nlist
*sym
;
3959 struct external_nlist
*sym_end
;
3960 struct aout_link_hash_entry
**sym_hash
;
3963 bfd_boolean skip_next
;
3965 output_bfd
= flaginfo
->output_bfd
;
3966 sym_count
= obj_aout_external_sym_count (input_bfd
);
3967 strings
= obj_aout_external_strings (input_bfd
);
3968 strip
= flaginfo
->info
->strip
;
3969 discard
= flaginfo
->info
->discard
;
3970 outsym
= flaginfo
->output_syms
;
3972 /* First write out a symbol for this object file, unless we are
3973 discarding such symbols. */
3974 if (strip
!= strip_all
3975 && (strip
!= strip_some
3976 || bfd_hash_lookup (flaginfo
->info
->keep_hash
, input_bfd
->filename
,
3977 FALSE
, FALSE
) != NULL
)
3978 && discard
!= discard_all
)
3980 H_PUT_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
3981 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
3982 input_bfd
->filename
, FALSE
);
3983 if (strtab_index
== (bfd_size_type
) -1)
3985 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
3986 PUT_WORD (output_bfd
,
3987 (bfd_section_vma (obj_textsec (input_bfd
)->output_section
)
3988 + obj_textsec (input_bfd
)->output_offset
),
3990 ++obj_aout_external_sym_count (output_bfd
);
3996 sym
= obj_aout_external_syms (input_bfd
);
3997 sym_end
= sym
+ sym_count
;
3998 sym_hash
= obj_aout_sym_hashes (input_bfd
);
3999 symbol_map
= flaginfo
->symbol_map
;
4000 memset (symbol_map
, 0, (size_t) sym_count
* sizeof *symbol_map
);
4001 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
4005 struct aout_link_hash_entry
*h
;
4011 /* We set *symbol_map to 0 above for all symbols. If it has
4012 already been set to -1 for this symbol, it means that we are
4013 discarding it because it appears in a duplicate header file.
4014 See the N_BINCL code below. */
4015 if (*symbol_map
== -1)
4018 /* Initialize *symbol_map to -1, which means that the symbol was
4019 not copied into the output file. We will change it later if
4020 we do copy the symbol over. */
4023 type
= H_GET_8 (input_bfd
, sym
->e_type
);
4024 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
4030 /* Pass this symbol through. It is the target of an
4031 indirect or warning symbol. */
4032 val
= GET_WORD (input_bfd
, sym
->e_value
);
4037 /* Skip this symbol, which is the target of an indirect
4038 symbol that we have changed to no longer be an indirect
4045 struct aout_link_hash_entry
*hresolve
;
4047 /* We have saved the hash table entry for this symbol, if
4048 there is one. Note that we could just look it up again
4049 in the hash table, provided we first check that it is an
4053 /* Use the name from the hash table, in case the symbol was
4056 name
= h
->root
.root
.string
;
4058 /* If this is an indirect or warning symbol, then change
4059 hresolve to the base symbol. We also change *sym_hash so
4060 that the relocation routines relocate against the real
4064 && (h
->root
.type
== bfd_link_hash_indirect
4065 || h
->root
.type
== bfd_link_hash_warning
))
4067 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
4068 while (hresolve
->root
.type
== bfd_link_hash_indirect
4069 || hresolve
->root
.type
== bfd_link_hash_warning
)
4070 hresolve
= ((struct aout_link_hash_entry
*)
4071 hresolve
->root
.u
.i
.link
);
4072 *sym_hash
= hresolve
;
4075 /* If the symbol has already been written out, skip it. */
4077 && h
->root
.type
!= bfd_link_hash_warning
4080 if ((type
& N_TYPE
) == N_INDR
4081 || type
== N_WARNING
)
4083 *symbol_map
= h
->indx
;
4087 /* See if we are stripping this symbol. */
4093 case strip_debugger
:
4094 if ((type
& N_STAB
) != 0)
4098 if (bfd_hash_lookup (flaginfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
4113 /* Get the value of the symbol. */
4114 if ((type
& N_TYPE
) == N_TEXT
4116 symsec
= obj_textsec (input_bfd
);
4117 else if ((type
& N_TYPE
) == N_DATA
4119 symsec
= obj_datasec (input_bfd
);
4120 else if ((type
& N_TYPE
) == N_BSS
4122 symsec
= obj_bsssec (input_bfd
);
4123 else if ((type
& N_TYPE
) == N_ABS
4125 symsec
= bfd_abs_section_ptr
;
4126 else if (((type
& N_TYPE
) == N_INDR
4127 && (hresolve
== NULL
4128 || (hresolve
->root
.type
!= bfd_link_hash_defined
4129 && hresolve
->root
.type
!= bfd_link_hash_defweak
4130 && hresolve
->root
.type
!= bfd_link_hash_common
)))
4131 || type
== N_WARNING
)
4133 /* Pass the next symbol through unchanged. The
4134 condition above for indirect symbols is so that if
4135 the indirect symbol was defined, we output it with
4136 the correct definition so the debugger will
4139 val
= GET_WORD (input_bfd
, sym
->e_value
);
4142 else if ((type
& N_STAB
) != 0)
4144 val
= GET_WORD (input_bfd
, sym
->e_value
);
4149 /* If we get here with an indirect symbol, it means that
4150 we are outputting it with a real definition. In such
4151 a case we do not want to output the next symbol,
4152 which is the target of the indirection. */
4153 if ((type
& N_TYPE
) == N_INDR
)
4158 /* We need to get the value from the hash table. We use
4159 hresolve so that if we have defined an indirect
4160 symbol we output the final definition. */
4163 switch (type
& N_TYPE
)
4166 symsec
= obj_textsec (input_bfd
);
4169 symsec
= obj_datasec (input_bfd
);
4172 symsec
= obj_bsssec (input_bfd
);
4175 symsec
= bfd_abs_section_ptr
;
4182 else if (hresolve
->root
.type
== bfd_link_hash_defined
4183 || hresolve
->root
.type
== bfd_link_hash_defweak
)
4185 asection
*input_section
;
4186 asection
*output_section
;
4188 /* This case usually means a common symbol which was
4189 turned into a defined symbol. */
4190 input_section
= hresolve
->root
.u
.def
.section
;
4191 output_section
= input_section
->output_section
;
4192 BFD_ASSERT (bfd_is_abs_section (output_section
)
4193 || output_section
->owner
== output_bfd
);
4194 val
= (hresolve
->root
.u
.def
.value
4195 + bfd_section_vma (output_section
)
4196 + input_section
->output_offset
);
4198 /* Get the correct type based on the section. If
4199 this is a constructed set, force it to be
4200 globally visible. */
4209 if (output_section
== obj_textsec (output_bfd
))
4210 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4213 else if (output_section
== obj_datasec (output_bfd
))
4214 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4217 else if (output_section
== obj_bsssec (output_bfd
))
4218 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4222 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4226 else if (hresolve
->root
.type
== bfd_link_hash_common
)
4227 val
= hresolve
->root
.u
.c
.size
;
4228 else if (hresolve
->root
.type
== bfd_link_hash_undefweak
)
4237 val
= (symsec
->output_section
->vma
4238 + symsec
->output_offset
4239 + (GET_WORD (input_bfd
, sym
->e_value
)
4242 /* If this is a global symbol set the written flag, and if
4243 it is a local symbol see if we should discard it. */
4247 h
->indx
= obj_aout_external_sym_count (output_bfd
);
4249 else if ((type
& N_TYPE
) != N_SETT
4250 && (type
& N_TYPE
) != N_SETD
4251 && (type
& N_TYPE
) != N_SETB
4252 && (type
& N_TYPE
) != N_SETA
)
4257 case discard_sec_merge
:
4260 if ((type
& N_STAB
) == 0
4261 && bfd_is_local_label_name (input_bfd
, name
))
4275 /* An N_BINCL symbol indicates the start of the stabs
4276 entries for a header file. We need to scan ahead to the
4277 next N_EINCL symbol, ignoring nesting, adding up all the
4278 characters in the symbol names, not including the file
4279 numbers in types (the first number after an open
4281 if (type
== N_BINCL
)
4283 struct external_nlist
*incl_sym
;
4285 struct aout_link_includes_entry
*incl_entry
;
4286 struct aout_link_includes_totals
*t
;
4290 for (incl_sym
= sym
+ 1; incl_sym
< sym_end
; incl_sym
++)
4294 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4295 if (incl_type
== N_EINCL
)
4301 else if (incl_type
== N_BINCL
)
4307 s
= strings
+ GET_WORD (input_bfd
, incl_sym
->e_strx
);
4308 for (; *s
!= '\0'; s
++)
4313 /* Skip the file number. */
4315 while (ISDIGIT (*s
))
4323 /* If we have already included a header file with the
4324 same value, then replace this one with an N_EXCL
4326 copy
= ! flaginfo
->info
->keep_memory
;
4327 incl_entry
= aout_link_includes_lookup (&flaginfo
->includes
,
4329 if (incl_entry
== NULL
)
4331 for (t
= incl_entry
->totals
; t
!= NULL
; t
= t
->next
)
4332 if (t
->total
== val
)
4336 /* This is the first time we have seen this header
4337 file with this set of stabs strings. */
4338 t
= bfd_hash_allocate (&flaginfo
->includes
.root
,
4343 t
->next
= incl_entry
->totals
;
4344 incl_entry
->totals
= t
;
4350 /* This is a duplicate header file. We must change
4351 it to be an N_EXCL entry, and mark all the
4352 included symbols to prevent outputting them. */
4356 for (incl_sym
= sym
+ 1, incl_map
= symbol_map
+ 1;
4358 incl_sym
++, incl_map
++)
4362 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4363 if (incl_type
== N_EINCL
)
4372 else if (incl_type
== N_BINCL
)
4381 /* Copy this symbol into the list of symbols we are going to
4383 H_PUT_8 (output_bfd
, type
, outsym
->e_type
);
4385 if (! flaginfo
->info
->keep_memory
)
4387 /* name points into a string table which we are going to
4388 free. If there is a hash table entry, use that string.
4389 Otherwise, copy name into memory. */
4391 name
= h
->root
.root
.string
;
4395 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4397 if (strtab_index
== (bfd_size_type
) -1)
4399 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4400 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
4401 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
4402 ++obj_aout_external_sym_count (output_bfd
);
4406 /* Write out the output symbols we have just constructed. */
4407 if (outsym
> flaginfo
->output_syms
)
4411 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0)
4413 size
= outsym
- flaginfo
->output_syms
;
4414 size
*= EXTERNAL_NLIST_SIZE
;
4415 if (bfd_bwrite ((void *) flaginfo
->output_syms
, size
, output_bfd
) != size
)
4417 flaginfo
->symoff
+= size
;
4423 /* Write out a symbol that was not associated with an a.out input
4427 bfd_getp32 (const void *p
)
4429 const bfd_byte
*addr
= p
;
4432 v
= (unsigned long) addr
[1] << 24;
4433 v
|= (unsigned long) addr
[0] << 16;
4434 v
|= (unsigned long) addr
[3] << 8;
4435 v
|= (unsigned long) addr
[2];
4439 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
4441 static bfd_signed_vma
4442 bfd_getp_signed_32 (const void *p
)
4444 const bfd_byte
*addr
= p
;
4447 v
= (unsigned long) addr
[1] << 24;
4448 v
|= (unsigned long) addr
[0] << 16;
4449 v
|= (unsigned long) addr
[3] << 8;
4450 v
|= (unsigned long) addr
[2];
4451 return COERCE32 (v
);
4455 bfd_putp32 (bfd_vma data
, void *p
)
4459 addr
[0] = (data
>> 16) & 0xff;
4460 addr
[1] = (data
>> 24) & 0xff;
4461 addr
[2] = (data
>> 0) & 0xff;
4462 addr
[3] = (data
>> 8) & 0xff;
4465 const bfd_target
MY (vec
) =
4467 TARGETNAME
, /* Name. */
4468 bfd_target_aout_flavour
,
4469 BFD_ENDIAN_LITTLE
, /* Target byte order (little). */
4470 BFD_ENDIAN_LITTLE
, /* Target headers byte order (little). */
4471 (HAS_RELOC
| EXEC_P
| /* Object flags. */
4472 HAS_LINENO
| HAS_DEBUG
|
4473 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
),
4474 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_CODE
| SEC_DATA
),
4475 MY_symbol_leading_char
,
4476 AR_PAD_CHAR
, /* AR_pad_char. */
4477 15, /* AR_max_namelen. */
4478 0, /* match priority. */
4479 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4480 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4481 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Data. */
4482 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4483 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4484 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Headers. */
4485 { /* bfd_check_format. */
4488 bfd_generic_archive_p
,
4491 { /* bfd_set_format. */
4492 _bfd_bool_bfd_false_error
,
4494 _bfd_generic_mkarchive
,
4495 _bfd_bool_bfd_false_error
4497 { /* bfd_write_contents. */
4498 _bfd_bool_bfd_false_error
,
4499 MY_write_object_contents
,
4500 _bfd_write_archive_contents
,
4501 _bfd_bool_bfd_false_error
4504 BFD_JUMP_TABLE_GENERIC (MY
),
4505 BFD_JUMP_TABLE_COPY (MY
),
4506 BFD_JUMP_TABLE_CORE (MY
),
4507 BFD_JUMP_TABLE_ARCHIVE (MY
),
4508 BFD_JUMP_TABLE_SYMBOLS (MY
),
4509 BFD_JUMP_TABLE_RELOCS (MY
),
4510 BFD_JUMP_TABLE_WRITE (MY
),
4511 BFD_JUMP_TABLE_LINK (MY
),
4512 BFD_JUMP_TABLE_DYNAMIC (MY
),
4514 /* Alternative_target. */
4517 (void *) MY_backend_data