1 /* BFD back-end for PDP-11 a.out binaries.
2 Copyright (C) 2001-2015 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 1024
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(exec) 0
63 #define N_SET_FLAGS(exec, flags) do { } while (0)
64 #define N_BADMAG(x) (N_MAGIC(x) != OMAGIC \
65 && N_MAGIC(x) != NMAGIC \
66 && N_MAGIC(x) != ZMAGIC)
71 #define external_exec pdp11_external_exec
72 struct pdp11_external_exec
74 bfd_byte e_info
[2]; /* Magic number. */
75 bfd_byte e_text
[2]; /* Length of text section in bytes. */
76 bfd_byte e_data
[2]; /* Length of data section in bytes. */
77 bfd_byte e_bss
[2]; /* Length of bss area in bytes. */
78 bfd_byte e_syms
[2]; /* Length of symbol table in bytes. */
79 bfd_byte e_entry
[2]; /* Start address. */
80 bfd_byte e_unused
[2]; /* Not used. */
81 bfd_byte e_flag
[2]; /* Relocation info stripped. */
82 bfd_byte e_relocatable
; /* Ugly hack. */
85 #define EXEC_BYTES_SIZE (8 * 2)
87 #define A_MAGIC1 OMAGIC
88 #define OMAGIC 0407 /* ...object file or impure executable. */
89 #define A_MAGIC2 NMAGIC
90 #define NMAGIC 0410 /* Pure executable. */
91 #define ZMAGIC 0413 /* Demand-paged executable. */
92 #define A_MAGIC3 0411 /* Separated I&D. */
93 #define A_MAGIC4 0405 /* Overlay. */
94 #define A_MAGIC5 0430 /* Auto-overlay (nonseparate). */
95 #define A_MAGIC6 0431 /* Auto-overlay (separate). */
99 #define A_FLAG_RELOC_STRIPPED 0x0001
101 #define external_nlist pdp11_external_nlist
102 struct pdp11_external_nlist
104 bfd_byte e_unused
[2]; /* Unused. */
105 bfd_byte e_strx
[2]; /* Index into string table of name. */
106 bfd_byte e_type
[1]; /* Type of symbol. */
107 bfd_byte e_ovly
[1]; /* Overlay number. */
108 bfd_byte e_value
[2]; /* Value of symbol. */
111 #define EXTERNAL_NLIST_SIZE 8
113 #define N_TXTOFF(x) (EXEC_BYTES_SIZE)
114 #define N_DATOFF(x) (N_TXTOFF(x) + (x).a_text)
115 #define N_TRELOFF(x) (N_DATOFF(x) + (x).a_data)
116 #define N_DRELOFF(x) (N_TRELOFF(x) + (x).a_trsize)
117 #define N_SYMOFF(x) (N_DRELOFF(x) + (x).a_drsize)
118 #define N_STROFF(x) (N_SYMOFF(x) + (x).a_syms)
120 #define WRITE_HEADERS(abfd, execp) pdp11_aout_write_headers (abfd, execp)
125 #define SWAP_MAGIC(ext) bfd_getl16 (ext)
127 #define MY_entry_is_text_address 1
129 #define MY_write_object_contents MY(write_object_contents)
130 static bfd_boolean
MY(write_object_contents
) (bfd
*);
131 #define MY_text_includes_header 1
133 #define MY_BFD_TARGET
135 #include "aout-target.h"
137 /* Start of modified aoutx.h. */
138 #define KEEPIT udata.i
140 #include <string.h> /* For strchr and friends. */
143 #include "safe-ctype.h"
147 #include "aout/aout64.h"
148 #include "aout/stab_gnu.h"
160 #define N_TYPE 0x1f /* Type mask. */
161 #define N_UNDF 0x00 /* Undefined. */
162 #define N_ABS 0x01 /* Absolute. */
163 #define N_TEXT 0x02 /* Text segment. */
164 #define N_DATA 0x03 /* Data segment. */
165 #define N_BSS 0x04 /* Bss segment. */
166 #define N_REG 0x14 /* Register symbol. */
167 #define N_FN 0x1f /* File name. */
168 #define N_EXT 0x20 /* External flag. */
172 #define RELFLG 0x0001 /* PC-relative flag. */
173 #define RTYPE 0x000e /* Type mask. */
174 #define RIDXMASK 0xfff0 /* Index mask. */
176 #define RABS 0x00 /* Absolute. */
177 #define RTEXT 0x02 /* Text. */
178 #define RDATA 0x04 /* Data. */
179 #define RBSS 0x06 /* Bss. */
180 #define REXT 0x08 /* External. */
182 #define RINDEX(x) (((x) & 0xfff0) >> 4)
184 #ifndef MY_final_link_relocate
185 #define MY_final_link_relocate _bfd_final_link_relocate
188 #ifndef MY_relocate_contents
189 #define MY_relocate_contents _bfd_relocate_contents
192 /* A hash table used for header files with N_BINCL entries. */
194 struct aout_link_includes_table
196 struct bfd_hash_table root
;
199 /* A linked list of totals that we have found for a particular header
202 struct aout_link_includes_totals
204 struct aout_link_includes_totals
*next
;
208 /* An entry in the header file hash table. */
210 struct aout_link_includes_entry
212 struct bfd_hash_entry root
;
213 /* List of totals we have found for this file. */
214 struct aout_link_includes_totals
*totals
;
217 /* During the final link step we need to pass around a bunch of
218 information, so we do it in an instance of this structure. */
220 struct aout_final_link_info
222 /* General link information. */
223 struct bfd_link_info
*info
;
226 /* Reloc file positions. */
227 file_ptr treloff
, dreloff
;
228 /* File position of symbols. */
231 struct bfd_strtab_hash
*strtab
;
232 /* Header file hash table. */
233 struct aout_link_includes_table includes
;
234 /* A buffer large enough to hold the contents of any section. */
236 /* A buffer large enough to hold the relocs of any section. */
238 /* A buffer large enough to hold the symbol map of any input BFD. */
240 /* A buffer large enough to hold output symbols of any input BFD. */
241 struct external_nlist
*output_syms
;
244 reloc_howto_type howto_table_pdp11
[] =
246 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
247 HOWTO( 0, 0, 1, 16, FALSE
, 0, complain_overflow_signed
,0,"16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
248 HOWTO( 1, 0, 1, 16, TRUE
, 0, complain_overflow_signed
,0,"DISP16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
251 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
254 static bfd_boolean
aout_link_check_archive_element (bfd
*, struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *, bfd_boolean
*);
255 static bfd_boolean
aout_link_add_object_symbols (bfd
*, struct bfd_link_info
*);
256 static bfd_boolean
aout_link_add_symbols (bfd
*, struct bfd_link_info
*);
257 static bfd_boolean
aout_link_write_symbols (struct aout_final_link_info
*, bfd
*);
261 NAME (aout
, reloc_type_lookup
) (bfd
* abfd ATTRIBUTE_UNUSED
,
262 bfd_reloc_code_real_type code
)
267 return &howto_table_pdp11
[0];
268 case BFD_RELOC_16_PCREL
:
269 return &howto_table_pdp11
[1];
276 NAME (aout
, reloc_name_lookup
) (bfd
*abfd ATTRIBUTE_UNUSED
,
282 i
< sizeof (howto_table_pdp11
) / sizeof (howto_table_pdp11
[0]);
284 if (howto_table_pdp11
[i
].name
!= NULL
285 && strcasecmp (howto_table_pdp11
[i
].name
, r_name
) == 0)
286 return &howto_table_pdp11
[i
];
292 pdp11_aout_write_headers (bfd
*abfd
, struct internal_exec
*execp
)
294 struct external_exec exec_bytes
;
295 bfd_size_type text_size
;
298 if (adata(abfd
).magic
== undecided_magic
)
299 NAME (aout
, adjust_sizes_and_vmas
) (abfd
, &text_size
, &text_end
);
301 execp
->a_syms
= bfd_get_symcount (abfd
) * EXTERNAL_NLIST_SIZE
;
302 execp
->a_entry
= bfd_get_start_address (abfd
);
304 if (obj_textsec (abfd
)->reloc_count
> 0
305 || obj_datasec (abfd
)->reloc_count
> 0)
307 execp
->a_trsize
= execp
->a_text
;
308 execp
->a_drsize
= execp
->a_data
;
316 NAME (aout
, swap_exec_header_out
) (abfd
, execp
, & exec_bytes
);
318 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
321 if (bfd_bwrite ((void *) &exec_bytes
, (bfd_size_type
) EXEC_BYTES_SIZE
, abfd
)
325 /* Now write out reloc info, followed by syms and strings. */
326 if (bfd_get_outsymbols (abfd
) != NULL
327 && bfd_get_symcount (abfd
) != 0)
329 if (bfd_seek (abfd
, (file_ptr
) (N_SYMOFF(*execp
)), SEEK_SET
) != 0)
332 if (! NAME (aout
, write_syms
) (abfd
))
336 if (obj_textsec (abfd
)->reloc_count
> 0
337 || obj_datasec (abfd
)->reloc_count
> 0)
339 if (bfd_seek (abfd
, (file_ptr
) (N_TRELOFF(*execp
)), SEEK_SET
) != 0
340 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_textsec (abfd
))
341 || bfd_seek (abfd
, (file_ptr
) (N_DRELOFF(*execp
)), SEEK_SET
) != 0
342 || !NAME (aout
, squirt_out_relocs
) (abfd
, obj_datasec (abfd
)))
349 /* Write an object file.
350 Section contents have already been written. We write the
351 file header, symbols, and relocation. */
354 MY(write_object_contents
) (bfd
*abfd
)
356 struct internal_exec
*execp
= exec_hdr (abfd
);
358 /* We must make certain that the magic number has been set. This
359 will normally have been done by set_section_contents, but only if
360 there actually are some section contents. */
361 if (! abfd
->output_has_begun
)
363 bfd_size_type text_size
;
366 NAME (aout
, adjust_sizes_and_vmas
) (abfd
, &text_size
, &text_end
);
369 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
371 return WRITE_HEADERS (abfd
, execp
);
374 /* Swap the information in an executable header @var{raw_bytes} taken
375 from a raw byte stream memory image into the internal exec header
376 structure "execp". */
378 #ifndef NAME_swap_exec_header_in
380 NAME (aout
, swap_exec_header_in
) (bfd
*abfd
,
381 struct external_exec
*bytes
,
382 struct internal_exec
*execp
)
384 /* The internal_exec structure has some fields that are unused in this
385 configuration (IE for i960), so ensure that all such uninitialized
386 fields are zero'd out. There are places where two of these structs
387 are memcmp'd, and thus the contents do matter. */
388 memset ((void *) execp
, 0, sizeof (struct internal_exec
));
389 /* Now fill in fields in the execp, from the bytes in the raw data. */
390 execp
->a_info
= GET_MAGIC (abfd
, bytes
->e_info
);
391 execp
->a_text
= GET_WORD (abfd
, bytes
->e_text
);
392 execp
->a_data
= GET_WORD (abfd
, bytes
->e_data
);
393 execp
->a_bss
= GET_WORD (abfd
, bytes
->e_bss
);
394 execp
->a_syms
= GET_WORD (abfd
, bytes
->e_syms
);
395 execp
->a_entry
= GET_WORD (abfd
, bytes
->e_entry
);
397 if (GET_WORD (abfd
, bytes
->e_flag
) & A_FLAG_RELOC_STRIPPED
)
404 execp
->a_trsize
= execp
->a_text
;
405 execp
->a_drsize
= execp
->a_data
;
408 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
411 /* Swap the information in an internal exec header structure
412 "execp" into the buffer "bytes" ready for writing to disk. */
414 NAME (aout
, swap_exec_header_out
) (bfd
*abfd
,
415 struct internal_exec
*execp
,
416 struct external_exec
*bytes
)
418 /* Now fill in fields in the raw data, from the fields in the exec struct. */
419 PUT_MAGIC (abfd
, execp
->a_info
, bytes
->e_info
);
420 PUT_WORD (abfd
, execp
->a_text
, bytes
->e_text
);
421 PUT_WORD (abfd
, execp
->a_data
, bytes
->e_data
);
422 PUT_WORD (abfd
, execp
->a_bss
, bytes
->e_bss
);
423 PUT_WORD (abfd
, execp
->a_syms
, bytes
->e_syms
);
424 PUT_WORD (abfd
, execp
->a_entry
, bytes
->e_entry
);
425 PUT_WORD (abfd
, 0, bytes
->e_unused
);
427 if ((execp
->a_trsize
== 0 || execp
->a_text
== 0)
428 && (execp
->a_drsize
== 0 || execp
->a_data
== 0))
429 PUT_WORD (abfd
, A_FLAG_RELOC_STRIPPED
, bytes
->e_flag
);
430 else if (execp
->a_trsize
== execp
->a_text
431 && execp
->a_drsize
== execp
->a_data
)
432 PUT_WORD (abfd
, 0, bytes
->e_flag
);
435 /* TODO: print a proper warning message. */
436 fprintf (stderr
, "BFD:%s:%d: internal error\n", __FILE__
, __LINE__
);
437 PUT_WORD (abfd
, 0, bytes
->e_flag
);
441 /* Make all the section for an a.out file. */
444 NAME (aout
, make_sections
) (bfd
*abfd
)
446 if (obj_textsec (abfd
) == NULL
&& bfd_make_section (abfd
, ".text") == NULL
)
448 if (obj_datasec (abfd
) == NULL
&& bfd_make_section (abfd
, ".data") == NULL
)
450 if (obj_bsssec (abfd
) == NULL
&& bfd_make_section (abfd
, ".bss") == NULL
)
455 /* Some a.out variant thinks that the file open in ABFD
456 checking is an a.out file. Do some more checking, and set up
457 for access if it really is. Call back to the calling
458 environment's "finish up" function just before returning, to
459 handle any last-minute setup. */
462 NAME (aout
, some_aout_object_p
) (bfd
*abfd
,
463 struct internal_exec
*execp
,
464 const bfd_target
*(*callback_to_real_object_p
) (bfd
*))
466 struct aout_data_struct
*rawptr
, *oldrawptr
;
467 const bfd_target
*result
;
468 bfd_size_type amt
= sizeof (struct aout_data_struct
);
470 rawptr
= bfd_zalloc (abfd
, amt
);
474 oldrawptr
= abfd
->tdata
.aout_data
;
475 abfd
->tdata
.aout_data
= rawptr
;
477 /* Copy the contents of the old tdata struct.
478 In particular, we want the subformat, since for hpux it was set in
479 hp300hpux.c:swap_exec_header_in and will be used in
480 hp300hpux.c:callback. */
481 if (oldrawptr
!= NULL
)
482 *abfd
->tdata
.aout_data
= *oldrawptr
;
484 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
485 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
; /* Copy in the internal_exec struct. */
486 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
488 /* Set the file flags. */
489 abfd
->flags
= BFD_NO_FLAGS
;
490 if (execp
->a_drsize
|| execp
->a_trsize
)
491 abfd
->flags
|= HAS_RELOC
;
492 /* Setting of EXEC_P has been deferred to the bottom of this function. */
494 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
495 if (N_DYNAMIC(*execp
))
496 abfd
->flags
|= DYNAMIC
;
498 if (N_MAGIC (*execp
) == ZMAGIC
)
500 abfd
->flags
|= D_PAGED
| WP_TEXT
;
501 adata (abfd
).magic
= z_magic
;
503 else if (N_MAGIC (*execp
) == NMAGIC
)
505 abfd
->flags
|= WP_TEXT
;
506 adata (abfd
).magic
= n_magic
;
508 else if (N_MAGIC (*execp
) == OMAGIC
)
509 adata (abfd
).magic
= o_magic
;
512 /* Should have been checked with N_BADMAG before this routine
517 bfd_get_start_address (abfd
) = execp
->a_entry
;
519 obj_aout_symbols (abfd
) = NULL
;
520 bfd_get_symcount (abfd
) = execp
->a_syms
/ sizeof (struct external_nlist
);
522 /* The default relocation entry size is that of traditional V7 Unix. */
523 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
525 /* The default symbol entry size is that of traditional Unix. */
526 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
529 bfd_init_window (&obj_aout_sym_window (abfd
));
530 bfd_init_window (&obj_aout_string_window (abfd
));
533 obj_aout_external_syms (abfd
) = NULL
;
534 obj_aout_external_strings (abfd
) = NULL
;
535 obj_aout_sym_hashes (abfd
) = NULL
;
537 if (! NAME (aout
, make_sections
) (abfd
))
540 obj_datasec (abfd
)->size
= execp
->a_data
;
541 obj_bsssec (abfd
)->size
= execp
->a_bss
;
543 obj_textsec (abfd
)->flags
=
544 (execp
->a_trsize
!= 0
545 ? (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_RELOC
)
546 : (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
));
547 obj_datasec (abfd
)->flags
=
548 (execp
->a_drsize
!= 0
549 ? (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_RELOC
)
550 : (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
));
551 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
553 #ifdef THIS_IS_ONLY_DOCUMENTATION
554 /* The common code can't fill in these things because they depend
555 on either the start address of the text segment, the rounding
556 up of virtual addresses between segments, or the starting file
557 position of the text segment -- all of which varies among different
558 versions of a.out. */
560 /* Call back to the format-dependent code to fill in the rest of the
561 fields and do any further cleanup. Things that should be filled
562 in by the callback: */
563 struct exec
*execp
= exec_hdr (abfd
);
565 obj_textsec (abfd
)->size
= N_TXTSIZE(*execp
);
566 /* Data and bss are already filled in since they're so standard. */
568 /* The virtual memory addresses of the sections. */
569 obj_textsec (abfd
)->vma
= N_TXTADDR(*execp
);
570 obj_datasec (abfd
)->vma
= N_DATADDR(*execp
);
571 obj_bsssec (abfd
)->vma
= N_BSSADDR(*execp
);
573 /* The file offsets of the sections. */
574 obj_textsec (abfd
)->filepos
= N_TXTOFF(*execp
);
575 obj_datasec (abfd
)->filepos
= N_DATOFF(*execp
);
577 /* The file offsets of the relocation info. */
578 obj_textsec (abfd
)->rel_filepos
= N_TRELOFF(*execp
);
579 obj_datasec (abfd
)->rel_filepos
= N_DRELOFF(*execp
);
581 /* The file offsets of the string table and symbol table. */
582 obj_str_filepos (abfd
) = N_STROFF (*execp
);
583 obj_sym_filepos (abfd
) = N_SYMOFF (*execp
);
585 /* Determine the architecture and machine type of the object file. */
586 abfd
->obj_arch
= bfd_arch_obscure
;
588 adata(abfd
)->page_size
= TARGET_PAGE_SIZE
;
589 adata(abfd
)->segment_size
= SEGMENT_SIZE
;
590 adata(abfd
)->exec_bytes_size
= EXEC_BYTES_SIZE
;
594 /* The architecture is encoded in various ways in various a.out variants,
595 or is not encoded at all in some of them. The relocation size depends
596 on the architecture and the a.out variant. Finally, the return value
597 is the bfd_target vector in use. If an error occurs, return zero and
598 set bfd_error to the appropriate error code.
600 Formats such as b.out, which have additional fields in the a.out
601 header, should cope with them in this callback as well. */
602 #endif /* DOCUMENTATION */
604 result
= (*callback_to_real_object_p
)(abfd
);
606 /* Now that the segment addresses have been worked out, take a better
607 guess at whether the file is executable. If the entry point
608 is within the text segment, assume it is. (This makes files
609 executable even if their entry point address is 0, as long as
610 their text starts at zero.).
612 This test had to be changed to deal with systems where the text segment
613 runs at a different location than the default. The problem is that the
614 entry address can appear to be outside the text segment, thus causing an
615 erroneous conclusion that the file isn't executable.
617 To fix this, we now accept any non-zero entry point as an indication of
618 executability. This will work most of the time, since only the linker
619 sets the entry point, and that is likely to be non-zero for most systems. */
621 if (execp
->a_entry
!= 0
622 || (execp
->a_entry
>= obj_textsec(abfd
)->vma
623 && execp
->a_entry
< obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->size
))
624 abfd
->flags
|= EXEC_P
;
628 struct stat stat_buf
;
630 /* The original heuristic doesn't work in some important cases.
631 The a.out file has no information about the text start
632 address. For files (like kernels) linked to non-standard
633 addresses (ld -Ttext nnn) the entry point may not be between
634 the default text start (obj_textsec(abfd)->vma) and
635 (obj_textsec(abfd)->vma) + text size. This is not just a mach
636 issue. Many kernels are loaded at non standard addresses. */
637 if (abfd
->iostream
!= NULL
638 && (abfd
->flags
& BFD_IN_MEMORY
) == 0
639 && (fstat(fileno((FILE *) (abfd
->iostream
)), &stat_buf
) == 0)
640 && ((stat_buf
.st_mode
& 0111) != 0))
641 abfd
->flags
|= EXEC_P
;
643 #endif /* STAT_FOR_EXEC */
648 abfd
->tdata
.aout_data
= oldrawptr
;
653 /* Initialize ABFD for use with a.out files. */
656 NAME (aout
, mkobject
) (bfd
*abfd
)
658 struct aout_data_struct
*rawptr
;
659 bfd_size_type amt
= sizeof (struct aout_data_struct
);
661 bfd_set_error (bfd_error_system_call
);
663 /* Use an intermediate variable for clarity. */
664 rawptr
= bfd_zalloc (abfd
, amt
);
669 abfd
->tdata
.aout_data
= rawptr
;
670 exec_hdr (abfd
) = &(rawptr
->e
);
672 obj_textsec (abfd
) = NULL
;
673 obj_datasec (abfd
) = NULL
;
674 obj_bsssec (abfd
) = NULL
;
679 /* Keep track of machine architecture and machine type for
680 a.out's. Return the <<machine_type>> for a particular
681 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
682 and machine can't be represented in a.out format.
684 If the architecture is understood, machine type 0 (default)
685 is always understood. */
688 NAME (aout
, machine_type
) (enum bfd_architecture arch
,
689 unsigned long machine
,
690 bfd_boolean
*unknown
)
692 enum machine_type arch_flags
;
694 arch_flags
= M_UNKNOWN
;
701 || machine
== bfd_mach_sparc
702 || machine
== bfd_mach_sparc_sparclite
703 || machine
== bfd_mach_sparc_v9
)
704 arch_flags
= M_SPARC
;
705 else if (machine
== bfd_mach_sparc_sparclet
)
706 arch_flags
= M_SPARCLET
;
712 case 0: arch_flags
= M_68010
; break;
713 case bfd_mach_m68000
: arch_flags
= M_UNKNOWN
; *unknown
= FALSE
; break;
714 case bfd_mach_m68010
: arch_flags
= M_68010
; break;
715 case bfd_mach_m68020
: arch_flags
= M_68020
; break;
716 default: arch_flags
= M_UNKNOWN
; break;
722 || machine
== bfd_mach_i386_i386
723 || machine
== bfd_mach_i386_i386_intel_syntax
)
728 if (machine
== 0) arch_flags
= M_ARM
;
736 case bfd_mach_mips3000
:
737 arch_flags
= M_MIPS1
;
739 case bfd_mach_mips4000
: /* MIPS3 */
740 case bfd_mach_mips4400
:
741 case bfd_mach_mips8000
: /* MIPS4 */
742 case bfd_mach_mips6000
: /* Real MIPS2: */
743 arch_flags
= M_MIPS2
;
746 arch_flags
= M_UNKNOWN
;
754 case 0: arch_flags
= M_NS32532
; break;
755 case 32032: arch_flags
= M_NS32032
; break;
756 case 32532: arch_flags
= M_NS32532
; break;
757 default: arch_flags
= M_UNKNOWN
; break;
762 /* TODO: arch_flags = M_PDP11; */
771 arch_flags
= M_UNKNOWN
;
774 if (arch_flags
!= M_UNKNOWN
)
780 /* Set the architecture and the machine of the ABFD to the
781 values ARCH and MACHINE. Verify that @ABFD's format
782 can support the architecture required. */
785 NAME (aout
, set_arch_mach
) (bfd
*abfd
,
786 enum bfd_architecture arch
,
787 unsigned long machine
)
789 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
792 if (arch
!= bfd_arch_unknown
)
796 NAME (aout
, machine_type
) (arch
, machine
, &unknown
);
801 obj_reloc_entry_size (abfd
) = RELOC_SIZE
;
803 return (*aout_backend_info(abfd
)->set_sizes
) (abfd
);
807 adjust_o_magic (bfd
*abfd
, struct internal_exec
*execp
)
809 file_ptr pos
= adata (abfd
).exec_bytes_size
;
814 obj_textsec (abfd
)->filepos
= pos
;
815 if (! obj_textsec (abfd
)->user_set_vma
)
816 obj_textsec (abfd
)->vma
= vma
;
818 vma
= obj_textsec (abfd
)->vma
;
820 pos
+= obj_textsec (abfd
)->size
;
821 vma
+= obj_textsec (abfd
)->size
;
824 if (!obj_datasec (abfd
)->user_set_vma
)
826 obj_textsec (abfd
)->size
+= pad
;
829 obj_datasec (abfd
)->vma
= vma
;
832 vma
= obj_datasec (abfd
)->vma
;
833 obj_datasec (abfd
)->filepos
= pos
;
834 pos
+= obj_datasec (abfd
)->size
;
835 vma
+= obj_datasec (abfd
)->size
;
838 if (! obj_bsssec (abfd
)->user_set_vma
)
840 obj_datasec (abfd
)->size
+= pad
;
843 obj_bsssec (abfd
)->vma
= vma
;
847 /* The VMA of the .bss section is set by the VMA of the
848 .data section plus the size of the .data section. We may
849 need to add padding bytes to make this true. */
850 pad
= obj_bsssec (abfd
)->vma
- vma
;
853 obj_datasec (abfd
)->size
+= pad
;
857 obj_bsssec (abfd
)->filepos
= pos
;
859 /* Fix up the exec header. */
860 execp
->a_text
= obj_textsec (abfd
)->size
;
861 execp
->a_data
= obj_datasec (abfd
)->size
;
862 execp
->a_bss
= obj_bsssec (abfd
)->size
;
863 N_SET_MAGIC (*execp
, OMAGIC
);
867 adjust_z_magic (bfd
*abfd
, struct internal_exec
*execp
)
869 bfd_size_type data_pad
, text_pad
;
871 const struct aout_backend_data
*abdp
;
872 int ztih
; /* Nonzero if text includes exec header. */
874 abdp
= aout_backend_info (abfd
);
878 && (abdp
->text_includes_header
879 || obj_aout_subformat (abfd
) == q_magic_format
));
880 obj_textsec(abfd
)->filepos
= (ztih
881 ? adata(abfd
).exec_bytes_size
882 : adata(abfd
).zmagic_disk_block_size
);
883 if (! obj_textsec(abfd
)->user_set_vma
)
885 /* ?? Do we really need to check for relocs here? */
886 obj_textsec(abfd
)->vma
= ((abfd
->flags
& HAS_RELOC
)
889 ? (abdp
->default_text_vma
890 + adata (abfd
).exec_bytes_size
)
891 : abdp
->default_text_vma
));
896 /* The .text section is being loaded at an unusual address. We
897 may need to pad it such that the .data section starts at a page
900 text_pad
= ((obj_textsec (abfd
)->filepos
- obj_textsec (abfd
)->vma
)
901 & (adata (abfd
).page_size
- 1));
903 text_pad
= ((- obj_textsec (abfd
)->vma
)
904 & (adata (abfd
).page_size
- 1));
907 /* Find start of data. */
910 text_end
= obj_textsec (abfd
)->filepos
+ obj_textsec (abfd
)->size
;
911 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
915 /* Note that if page_size == zmagic_disk_block_size, then
916 filepos == page_size, and this case is the same as the ztih
918 text_end
= obj_textsec (abfd
)->size
;
919 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
920 text_end
+= obj_textsec (abfd
)->filepos
;
923 obj_textsec (abfd
)->size
+= text_pad
;
924 text_end
+= text_pad
;
927 if (!obj_datasec(abfd
)->user_set_vma
)
930 vma
= obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->size
;
931 obj_datasec(abfd
)->vma
= BFD_ALIGN (vma
, adata(abfd
).segment_size
);
933 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
935 text_pad
= (obj_datasec(abfd
)->vma
936 - obj_textsec(abfd
)->vma
937 - obj_textsec(abfd
)->size
);
938 obj_textsec(abfd
)->size
+= text_pad
;
940 obj_datasec (abfd
)->filepos
= (obj_textsec (abfd
)->filepos
941 + obj_textsec (abfd
)->size
);
943 /* Fix up exec header while we're at it. */
944 execp
->a_text
= obj_textsec(abfd
)->size
;
945 if (ztih
&& (!abdp
|| (abdp
&& !abdp
->exec_header_not_counted
)))
946 execp
->a_text
+= adata(abfd
).exec_bytes_size
;
947 N_SET_MAGIC (*execp
, ZMAGIC
);
949 /* Spec says data section should be rounded up to page boundary. */
950 obj_datasec(abfd
)->size
951 = align_power (obj_datasec(abfd
)->size
,
952 obj_bsssec(abfd
)->alignment_power
);
953 execp
->a_data
= BFD_ALIGN (obj_datasec(abfd
)->size
,
954 adata(abfd
).page_size
);
955 data_pad
= execp
->a_data
- obj_datasec(abfd
)->size
;
958 if (!obj_bsssec(abfd
)->user_set_vma
)
959 obj_bsssec(abfd
)->vma
= (obj_datasec(abfd
)->vma
960 + obj_datasec(abfd
)->size
);
961 /* If the BSS immediately follows the data section and extra space
962 in the page is left after the data section, fudge data
963 in the header so that the bss section looks smaller by that
964 amount. We'll start the bss section there, and lie to the OS.
965 (Note that a linker script, as well as the above assignment,
966 could have explicitly set the BSS vma to immediately follow
967 the data section.) */
968 if (align_power (obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->alignment_power
)
969 == obj_datasec(abfd
)->vma
+ obj_datasec(abfd
)->size
)
970 execp
->a_bss
= (data_pad
> obj_bsssec(abfd
)->size
) ? 0 :
971 obj_bsssec(abfd
)->size
- data_pad
;
973 execp
->a_bss
= obj_bsssec(abfd
)->size
;
977 adjust_n_magic (bfd
*abfd
, struct internal_exec
*execp
)
979 file_ptr pos
= adata(abfd
).exec_bytes_size
;
984 obj_textsec(abfd
)->filepos
= pos
;
985 if (!obj_textsec(abfd
)->user_set_vma
)
986 obj_textsec(abfd
)->vma
= vma
;
988 vma
= obj_textsec(abfd
)->vma
;
989 pos
+= obj_textsec(abfd
)->size
;
990 vma
+= obj_textsec(abfd
)->size
;
993 obj_datasec(abfd
)->filepos
= pos
;
994 if (!obj_datasec(abfd
)->user_set_vma
)
995 obj_datasec(abfd
)->vma
= BFD_ALIGN (vma
, adata(abfd
).segment_size
);
996 vma
= obj_datasec(abfd
)->vma
;
998 /* Since BSS follows data immediately, see if it needs alignment. */
999 vma
+= obj_datasec(abfd
)->size
;
1000 pad
= align_power (vma
, obj_bsssec(abfd
)->alignment_power
) - vma
;
1001 obj_datasec(abfd
)->size
+= pad
;
1002 pos
+= obj_datasec(abfd
)->size
;
1005 if (!obj_bsssec(abfd
)->user_set_vma
)
1006 obj_bsssec(abfd
)->vma
= vma
;
1008 vma
= obj_bsssec(abfd
)->vma
;
1010 /* Fix up exec header. */
1011 execp
->a_text
= obj_textsec(abfd
)->size
;
1012 execp
->a_data
= obj_datasec(abfd
)->size
;
1013 execp
->a_bss
= obj_bsssec(abfd
)->size
;
1014 N_SET_MAGIC (*execp
, NMAGIC
);
1018 NAME (aout
, adjust_sizes_and_vmas
) (bfd
*abfd
,
1019 bfd_size_type
*text_size
,
1020 file_ptr
* text_end ATTRIBUTE_UNUSED
)
1022 struct internal_exec
*execp
= exec_hdr (abfd
);
1024 if (! NAME (aout
, make_sections
) (abfd
))
1027 if (adata(abfd
).magic
!= undecided_magic
)
1030 obj_textsec(abfd
)->size
=
1031 align_power(obj_textsec(abfd
)->size
,
1032 obj_textsec(abfd
)->alignment_power
);
1034 *text_size
= obj_textsec (abfd
)->size
;
1035 /* Rule (heuristic) for when to pad to a new page. Note that there
1036 are (at least) two ways demand-paged (ZMAGIC) files have been
1037 handled. Most Berkeley-based systems start the text segment at
1038 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1039 segment right after the exec header; the latter is counted in the
1040 text segment size, and is paged in by the kernel with the rest of
1043 /* This perhaps isn't the right way to do this, but made it simpler for me
1044 to understand enough to implement it. Better would probably be to go
1045 right from BFD flags to alignment/positioning characteristics. But the
1046 old code was sloppy enough about handling the flags, and had enough
1047 other magic, that it was a little hard for me to understand. I think
1048 I understand it better now, but I haven't time to do the cleanup this
1051 if (abfd
->flags
& WP_TEXT
)
1052 adata(abfd
).magic
= n_magic
;
1054 adata(abfd
).magic
= o_magic
;
1056 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1058 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1060 switch (adata(abfd
).magic
) {
1061 case n_magic
: str
= "NMAGIC"; break;
1062 case o_magic
: str
= "OMAGIC"; break;
1063 case z_magic
: str
= "ZMAGIC"; break;
1068 obj_textsec(abfd
)->vma
, obj_textsec(abfd
)->size
,
1069 obj_textsec(abfd
)->alignment_power
,
1070 obj_datasec(abfd
)->vma
, obj_datasec(abfd
)->size
,
1071 obj_datasec(abfd
)->alignment_power
,
1072 obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->size
,
1073 obj_bsssec(abfd
)->alignment_power
);
1077 switch (adata(abfd
).magic
)
1080 adjust_o_magic (abfd
, execp
);
1083 adjust_z_magic (abfd
, execp
);
1086 adjust_n_magic (abfd
, execp
);
1092 #ifdef BFD_AOUT_DEBUG
1093 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1094 obj_textsec(abfd
)->vma
, obj_textsec(abfd
)->size
,
1095 obj_textsec(abfd
)->filepos
,
1096 obj_datasec(abfd
)->vma
, obj_datasec(abfd
)->size
,
1097 obj_datasec(abfd
)->filepos
,
1098 obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->size
);
1104 /* Called by the BFD in response to a bfd_make_section request. */
1107 NAME (aout
, new_section_hook
) (bfd
*abfd
, asection
*newsect
)
1109 /* Align to double at least. */
1110 newsect
->alignment_power
= bfd_get_arch_info(abfd
)->section_align_power
;
1112 if (bfd_get_format (abfd
) == bfd_object
)
1114 if (obj_textsec (abfd
) == NULL
1115 && !strcmp (newsect
->name
, ".text"))
1117 obj_textsec(abfd
)= newsect
;
1118 newsect
->target_index
= N_TEXT
;
1120 else if (obj_datasec (abfd
) == NULL
1121 && !strcmp (newsect
->name
, ".data"))
1123 obj_datasec (abfd
) = newsect
;
1124 newsect
->target_index
= N_DATA
;
1126 else if (obj_bsssec (abfd
) == NULL
1127 && !strcmp (newsect
->name
, ".bss"))
1129 obj_bsssec (abfd
) = newsect
;
1130 newsect
->target_index
= N_BSS
;
1134 /* We allow more than three sections internally. */
1135 return _bfd_generic_new_section_hook (abfd
, newsect
);
1139 NAME (aout
, set_section_contents
) (bfd
*abfd
,
1141 const void * location
,
1143 bfd_size_type count
)
1146 bfd_size_type text_size
;
1148 if (! abfd
->output_has_begun
)
1150 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
, & text_size
, & text_end
))
1154 if (section
== obj_bsssec (abfd
))
1156 bfd_set_error (bfd_error_no_contents
);
1160 if (section
!= obj_textsec (abfd
)
1161 && section
!= obj_datasec (abfd
))
1163 (*_bfd_error_handler
)
1164 ("%s: can not represent section `%s' in a.out object file format",
1165 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
));
1166 bfd_set_error (bfd_error_nonrepresentable_section
);
1172 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
1173 || bfd_bwrite (location
, count
, abfd
) != count
)
1180 /* Read the external symbols from an a.out file. */
1183 aout_get_external_symbols (bfd
*abfd
)
1185 if (obj_aout_external_syms (abfd
) == NULL
)
1187 bfd_size_type count
;
1188 struct external_nlist
*syms
;
1190 count
= exec_hdr (abfd
)->a_syms
/ EXTERNAL_NLIST_SIZE
;
1192 /* PR 17512: file: 011f5a08. */
1195 obj_aout_external_syms (abfd
) = NULL
;
1196 obj_aout_external_sym_count (abfd
) = count
;
1201 if (! bfd_get_file_window (abfd
, obj_sym_filepos (abfd
),
1202 exec_hdr (abfd
)->a_syms
,
1203 &obj_aout_sym_window (abfd
), TRUE
))
1205 syms
= (struct external_nlist
*) obj_aout_sym_window (abfd
).data
;
1207 /* We allocate using malloc to make the values easy to free
1208 later on. If we put them on the objalloc it might not be
1209 possible to free them. */
1210 syms
= bfd_malloc (count
* EXTERNAL_NLIST_SIZE
);
1211 if (syms
== NULL
&& count
!= 0)
1214 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1215 || (bfd_bread (syms
, exec_hdr (abfd
)->a_syms
, abfd
)
1216 != exec_hdr (abfd
)->a_syms
))
1223 obj_aout_external_syms (abfd
) = syms
;
1224 obj_aout_external_sym_count (abfd
) = count
;
1227 if (obj_aout_external_strings (abfd
) == NULL
1228 && exec_hdr (abfd
)->a_syms
!= 0)
1230 unsigned char string_chars
[BYTES_IN_LONG
];
1231 bfd_size_type stringsize
;
1234 /* Get the size of the strings. */
1235 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
1236 || (bfd_bread ((void *) string_chars
, (bfd_size_type
) BYTES_IN_LONG
,
1237 abfd
) != BYTES_IN_LONG
))
1239 stringsize
= H_GET_32 (abfd
, string_chars
);
1242 if (! bfd_get_file_window (abfd
, obj_str_filepos (abfd
), stringsize
,
1243 &obj_aout_string_window (abfd
), TRUE
))
1245 strings
= (char *) obj_aout_string_window (abfd
).data
;
1247 strings
= bfd_malloc (stringsize
+ 1);
1248 if (strings
== NULL
)
1251 /* Skip space for the string count in the buffer for convenience
1252 when using indexes. */
1253 if (bfd_bread (strings
+ 4, stringsize
- 4, abfd
) != stringsize
- 4)
1259 /* Ensure that a zero index yields an empty string. */
1262 strings
[stringsize
- 1] = 0;
1264 obj_aout_external_strings (abfd
) = strings
;
1265 obj_aout_external_string_size (abfd
) = stringsize
;
1271 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1272 and symbol->value fields of CACHE_PTR will be set from the a.out
1273 nlist structure. This function is responsible for setting
1274 symbol->flags and symbol->section, and adjusting symbol->value. */
1277 translate_from_native_sym_flags (bfd
*abfd
,
1278 aout_symbol_type
*cache_ptr
)
1282 if (cache_ptr
->type
== N_FN
)
1286 /* This is a debugging symbol. */
1287 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1289 /* Work out the symbol section. */
1290 switch (cache_ptr
->type
& N_TYPE
)
1294 sec
= obj_textsec (abfd
);
1297 sec
= obj_datasec (abfd
);
1300 sec
= obj_bsssec (abfd
);
1304 sec
= bfd_abs_section_ptr
;
1308 cache_ptr
->symbol
.section
= sec
;
1309 cache_ptr
->symbol
.value
-= sec
->vma
;
1314 /* Get the default visibility. This does not apply to all types, so
1315 we just hold it in a local variable to use if wanted. */
1316 if ((cache_ptr
->type
& N_EXT
) == 0)
1317 visible
= BSF_LOCAL
;
1319 visible
= BSF_GLOBAL
;
1321 switch (cache_ptr
->type
)
1324 case N_ABS
: case N_ABS
| N_EXT
:
1325 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1326 cache_ptr
->symbol
.flags
= visible
;
1329 case N_UNDF
| N_EXT
:
1330 if (cache_ptr
->symbol
.value
!= 0)
1332 /* This is a common symbol. */
1333 cache_ptr
->symbol
.flags
= BSF_GLOBAL
;
1334 cache_ptr
->symbol
.section
= bfd_com_section_ptr
;
1338 cache_ptr
->symbol
.flags
= 0;
1339 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1343 case N_TEXT
: case N_TEXT
| N_EXT
:
1344 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1345 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1346 cache_ptr
->symbol
.flags
= visible
;
1349 case N_DATA
: case N_DATA
| N_EXT
:
1350 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1351 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1352 cache_ptr
->symbol
.flags
= visible
;
1355 case N_BSS
: case N_BSS
| N_EXT
:
1356 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1357 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1358 cache_ptr
->symbol
.flags
= visible
;
1365 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1368 translate_to_native_sym_flags (bfd
*abfd
,
1370 struct external_nlist
*sym_pointer
)
1372 bfd_vma value
= cache_ptr
->value
;
1376 /* Mask out any existing type bits in case copying from one section
1378 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1380 sec
= bfd_get_section (cache_ptr
);
1385 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1387 (*_bfd_error_handler
)
1388 ("%B: can not represent section for symbol `%s' in a.out object file format",
1389 abfd
, cache_ptr
->name
!= NULL
? cache_ptr
->name
: "*unknown*");
1390 bfd_set_error (bfd_error_nonrepresentable_section
);
1394 if (sec
->output_section
!= NULL
)
1396 off
= sec
->output_offset
;
1397 sec
= sec
->output_section
;
1400 if (bfd_is_abs_section (sec
))
1401 sym_pointer
->e_type
[0] |= N_ABS
;
1402 else if (sec
== obj_textsec (abfd
))
1403 sym_pointer
->e_type
[0] |= N_TEXT
;
1404 else if (sec
== obj_datasec (abfd
))
1405 sym_pointer
->e_type
[0] |= N_DATA
;
1406 else if (sec
== obj_bsssec (abfd
))
1407 sym_pointer
->e_type
[0] |= N_BSS
;
1408 else if (bfd_is_und_section (sec
))
1409 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1410 else if (bfd_is_com_section (sec
))
1411 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1414 (*_bfd_error_handler
)
1415 ("%B: can not represent section `%A' in a.out object file format",
1417 bfd_set_error (bfd_error_nonrepresentable_section
);
1421 /* Turn the symbol from section relative to absolute again */
1422 value
+= sec
->vma
+ off
;
1424 if ((cache_ptr
->flags
& BSF_DEBUGGING
) != 0)
1425 sym_pointer
->e_type
[0] = ((aout_symbol_type
*) cache_ptr
)->type
;
1426 else if ((cache_ptr
->flags
& BSF_GLOBAL
) != 0)
1427 sym_pointer
->e_type
[0] |= N_EXT
;
1429 PUT_WORD(abfd
, value
, sym_pointer
->e_value
);
1434 /* Native-level interface to symbols. */
1437 NAME (aout
, make_empty_symbol
) (bfd
*abfd
)
1439 bfd_size_type amt
= sizeof (aout_symbol_type
);
1440 aout_symbol_type
*new_symbol_type
= bfd_zalloc (abfd
, amt
);
1442 if (!new_symbol_type
)
1444 new_symbol_type
->symbol
.the_bfd
= abfd
;
1446 return &new_symbol_type
->symbol
;
1449 /* Translate a set of internal symbols into external symbols. */
1452 NAME (aout
, translate_symbol_table
) (bfd
*abfd
,
1453 aout_symbol_type
*in
,
1454 struct external_nlist
*ext
,
1455 bfd_size_type count
,
1457 bfd_size_type strsize
,
1458 bfd_boolean dynamic
)
1460 struct external_nlist
*ext_end
;
1462 ext_end
= ext
+ count
;
1463 for (; ext
< ext_end
; ext
++, in
++)
1467 x
= GET_WORD (abfd
, ext
->e_strx
);
1468 in
->symbol
.the_bfd
= abfd
;
1470 /* For the normal symbols, the zero index points at the number
1471 of bytes in the string table but is to be interpreted as the
1472 null string. For the dynamic symbols, the number of bytes in
1473 the string table is stored in the __DYNAMIC structure and the
1474 zero index points at an actual string. */
1475 if (x
== 0 && ! dynamic
)
1476 in
->symbol
.name
= "";
1477 else if (x
< strsize
)
1478 in
->symbol
.name
= str
+ x
;
1482 in
->symbol
.value
= GET_SWORD (abfd
, ext
->e_value
);
1483 /* TODO: is 0 a safe value here? */
1486 in
->type
= H_GET_8 (abfd
, ext
->e_type
);
1487 in
->symbol
.udata
.p
= NULL
;
1489 if (! translate_from_native_sym_flags (abfd
, in
))
1493 in
->symbol
.flags
|= BSF_DYNAMIC
;
1499 /* We read the symbols into a buffer, which is discarded when this
1500 function exits. We read the strings into a buffer large enough to
1501 hold them all plus all the cached symbol entries. */
1504 NAME (aout
, slurp_symbol_table
) (bfd
*abfd
)
1506 struct external_nlist
*old_external_syms
;
1507 aout_symbol_type
*cached
;
1508 bfd_size_type cached_size
;
1510 /* If there's no work to be done, don't do any. */
1511 if (obj_aout_symbols (abfd
) != NULL
)
1514 old_external_syms
= obj_aout_external_syms (abfd
);
1516 if (! aout_get_external_symbols (abfd
))
1519 cached_size
= obj_aout_external_sym_count (abfd
);
1520 cached_size
*= sizeof (aout_symbol_type
);
1521 cached
= bfd_zmalloc (cached_size
);
1522 if (cached
== NULL
&& cached_size
!= 0)
1525 /* Convert from external symbol information to internal. */
1526 if (! (NAME (aout
, translate_symbol_table
)
1528 obj_aout_external_syms (abfd
),
1529 obj_aout_external_sym_count (abfd
),
1530 obj_aout_external_strings (abfd
),
1531 obj_aout_external_string_size (abfd
),
1538 bfd_get_symcount (abfd
) = obj_aout_external_sym_count (abfd
);
1540 obj_aout_symbols (abfd
) = cached
;
1542 /* It is very likely that anybody who calls this function will not
1543 want the external symbol information, so if it was allocated
1544 because of our call to aout_get_external_symbols, we free it up
1545 right away to save space. */
1546 if (old_external_syms
== NULL
1547 && obj_aout_external_syms (abfd
) != NULL
)
1550 bfd_free_window (&obj_aout_sym_window (abfd
));
1552 free (obj_aout_external_syms (abfd
));
1554 obj_aout_external_syms (abfd
) = NULL
;
1560 /* We use a hash table when writing out symbols so that we only write
1561 out a particular string once. This helps particularly when the
1562 linker writes out stabs debugging entries, because each different
1563 contributing object file tends to have many duplicate stabs
1566 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1567 if BFD_TRADITIONAL_FORMAT is set. */
1569 /* Get the index of a string in a strtab, adding it if it is not
1572 static INLINE bfd_size_type
1573 add_to_stringtab (bfd
*abfd
,
1574 struct bfd_strtab_hash
*tab
,
1579 bfd_size_type str_index
;
1581 /* An index of 0 always means the empty string. */
1582 if (str
== 0 || *str
== '\0')
1585 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1586 doesn't understand a hashed string table. */
1588 if ((abfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1591 str_index
= _bfd_stringtab_add (tab
, str
, hash
, copy
);
1593 if (str_index
!= (bfd_size_type
) -1)
1594 /* Add BYTES_IN_LONG to the return value to account for the
1595 space taken up by the string table size. */
1596 str_index
+= BYTES_IN_LONG
;
1601 /* Write out a strtab. ABFD is already at the right location in the
1605 emit_stringtab (bfd
*abfd
, struct bfd_strtab_hash
*tab
)
1607 bfd_byte buffer
[BYTES_IN_LONG
];
1609 /* The string table starts with the size. */
1610 H_PUT_32 (abfd
, _bfd_stringtab_size (tab
) + BYTES_IN_LONG
, buffer
);
1611 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) BYTES_IN_LONG
, abfd
)
1615 return _bfd_stringtab_emit (abfd
, tab
);
1619 NAME (aout
, write_syms
) (bfd
*abfd
)
1621 unsigned int count
;
1622 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1623 struct bfd_strtab_hash
*strtab
;
1625 strtab
= _bfd_stringtab_init ();
1629 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1631 asymbol
*g
= generic
[count
];
1633 struct external_nlist nsp
;
1635 PUT_WORD (abfd
, 0, nsp
.e_unused
);
1637 indx
= add_to_stringtab (abfd
, strtab
, g
->name
, FALSE
);
1638 if (indx
== (bfd_size_type
) -1)
1640 PUT_WORD (abfd
, indx
, nsp
.e_strx
);
1642 if (bfd_asymbol_flavour(g
) == abfd
->xvec
->flavour
)
1643 H_PUT_8 (abfd
, aout_symbol(g
)->type
, nsp
.e_type
);
1645 H_PUT_8 (abfd
, 0, nsp
.e_type
);
1647 if (! translate_to_native_sym_flags (abfd
, g
, &nsp
))
1650 H_PUT_8 (abfd
, 0, nsp
.e_ovly
);
1652 if (bfd_bwrite ((void *)&nsp
, (bfd_size_type
) EXTERNAL_NLIST_SIZE
, abfd
)
1653 != EXTERNAL_NLIST_SIZE
)
1656 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1657 here, at the end. */
1661 if (! emit_stringtab (abfd
, strtab
))
1664 _bfd_stringtab_free (strtab
);
1669 _bfd_stringtab_free (strtab
);
1675 NAME (aout
, canonicalize_symtab
) (bfd
*abfd
, asymbol
**location
)
1677 unsigned int counter
= 0;
1678 aout_symbol_type
*symbase
;
1680 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
1683 for (symbase
= obj_aout_symbols (abfd
); counter
++ < bfd_get_symcount (abfd
);)
1684 *(location
++) = (asymbol
*)(symbase
++);
1686 return bfd_get_symcount (abfd
);
1690 /* Output extended relocation information to a file in target byte order. */
1693 pdp11_aout_swap_reloc_out (bfd
*abfd
, arelent
*g
, bfd_byte
*natptr
)
1699 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1700 asection
*output_section
= sym
->section
->output_section
;
1703 fprintf (stderr
, "BFD: can't do this reloc addend stuff\n");
1705 r_pcrel
= g
->howto
->pc_relative
;
1707 if (bfd_is_abs_section (output_section
))
1709 else if (output_section
== obj_textsec (abfd
))
1711 else if (output_section
== obj_datasec (abfd
))
1713 else if (output_section
== obj_bsssec (abfd
))
1715 else if (bfd_is_und_section (output_section
))
1717 else if (bfd_is_com_section (output_section
))
1722 BFD_ASSERT (r_type
!= -1);
1727 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
1729 reloc_entry
= r_index
<< 4 | r_type
| r_pcrel
;
1731 PUT_WORD (abfd
, reloc_entry
, natptr
);
1734 /* BFD deals internally with all things based from the section they're
1735 in. so, something in 10 bytes into a text section with a base of
1736 50 would have a symbol (.text+10) and know .text vma was 50.
1738 Aout keeps all it's symbols based from zero, so the symbol would
1739 contain 60. This macro subs the base of each section from the value
1740 to give the true offset from the section */
1743 #define MOVE_ADDRESS(ad) \
1746 /* Undefined symbol. */ \
1747 cache_ptr->sym_ptr_ptr = symbols + r_index; \
1748 cache_ptr->addend = ad; \
1752 /* Defined, section relative. replace symbol with pointer to \
1753 symbol which points to section. */ \
1757 case N_TEXT | N_EXT: \
1758 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
1759 cache_ptr->addend = ad - su->textsec->vma; \
1762 case N_DATA | N_EXT: \
1763 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
1764 cache_ptr->addend = ad - su->datasec->vma; \
1767 case N_BSS | N_EXT: \
1768 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
1769 cache_ptr->addend = ad - su->bsssec->vma; \
1773 case N_ABS | N_EXT: \
1774 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1775 cache_ptr->addend = ad; \
1781 pdp11_aout_swap_reloc_in (bfd
* abfd
,
1783 arelent
* cache_ptr
,
1784 bfd_size_type offset
,
1786 bfd_size_type symcount
)
1788 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
1789 unsigned int r_index
;
1794 reloc_entry
= GET_WORD (abfd
, (void *) bytes
);
1796 r_pcrel
= reloc_entry
& RELFLG
;
1798 cache_ptr
->address
= offset
;
1799 cache_ptr
->howto
= howto_table_pdp11
+ (r_pcrel
? 1 : 0);
1801 if ((reloc_entry
& RTYPE
) == RABS
)
1804 r_index
= RINDEX (reloc_entry
);
1806 /* r_extern reflects whether the symbol the reloc is against is
1808 r_extern
= (reloc_entry
& RTYPE
) == REXT
;
1810 if (r_extern
&& r_index
> symcount
)
1812 /* We could arrange to return an error, but it might be useful
1813 to see the file even if it is bad. */
1821 /* Read and swap the relocs for a section. */
1824 NAME (aout
, slurp_reloc_table
) (bfd
*abfd
, sec_ptr asect
, asymbol
**symbols
)
1827 bfd_size_type count
;
1828 bfd_size_type reloc_size
;
1830 arelent
*reloc_cache
;
1832 unsigned int counter
= 0;
1835 if (asect
->relocation
)
1838 if (asect
->flags
& SEC_CONSTRUCTOR
)
1841 if (asect
== obj_datasec (abfd
))
1842 reloc_size
= exec_hdr(abfd
)->a_drsize
;
1843 else if (asect
== obj_textsec (abfd
))
1844 reloc_size
= exec_hdr(abfd
)->a_trsize
;
1845 else if (asect
== obj_bsssec (abfd
))
1849 bfd_set_error (bfd_error_invalid_operation
);
1853 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
1856 each_size
= obj_reloc_entry_size (abfd
);
1858 relocs
= bfd_malloc (reloc_size
);
1859 if (relocs
== NULL
&& reloc_size
!= 0)
1862 if (bfd_bread (relocs
, reloc_size
, abfd
) != reloc_size
)
1868 count
= reloc_size
/ each_size
;
1870 /* Count the number of NON-ZERO relocs, this is the count we want. */
1872 unsigned int real_count
= 0;
1874 for (counter
= 0; counter
< count
; counter
++)
1878 x
= GET_WORD (abfd
, (char *) relocs
+ each_size
* counter
);
1886 reloc_cache
= bfd_zmalloc (count
* sizeof (arelent
));
1887 if (reloc_cache
== NULL
&& count
!= 0)
1890 cache_ptr
= reloc_cache
;
1895 counter
++, rptr
+= RELOC_SIZE
, cache_ptr
++)
1897 while (GET_WORD (abfd
, (void *) rptr
) == 0)
1900 if ((char *) rptr
>= (char *) relocs
+ reloc_size
)
1904 pdp11_aout_swap_reloc_in (abfd
, rptr
, cache_ptr
,
1905 (bfd_size_type
) ((char *) rptr
- (char *) relocs
),
1907 (bfd_size_type
) bfd_get_symcount (abfd
));
1910 /* Just in case, if rptr >= relocs + reloc_size should happen
1912 BFD_ASSERT (counter
== count
);
1916 asect
->relocation
= reloc_cache
;
1917 asect
->reloc_count
= cache_ptr
- reloc_cache
;
1922 /* Write out a relocation section into an object file. */
1925 NAME (aout
, squirt_out_relocs
) (bfd
*abfd
, asection
*section
)
1928 unsigned char *native
;
1929 unsigned int count
= section
->reloc_count
;
1930 bfd_size_type natsize
;
1932 natsize
= section
->size
;
1933 native
= bfd_zalloc (abfd
, natsize
);
1937 generic
= section
->orelocation
;
1938 if (generic
!= NULL
)
1944 r
= native
+ (*generic
)->address
;
1945 pdp11_aout_swap_reloc_out (abfd
, *generic
, r
);
1951 if (bfd_bwrite ((void *) native
, natsize
, abfd
) != natsize
)
1953 bfd_release (abfd
, native
);
1957 bfd_release (abfd
, native
);
1961 /* This is stupid. This function should be a boolean predicate. */
1964 NAME (aout
, canonicalize_reloc
) (bfd
*abfd
,
1969 arelent
*tblptr
= section
->relocation
;
1972 if (section
== obj_bsssec (abfd
))
1978 if (!(tblptr
|| NAME (aout
, slurp_reloc_table
)(abfd
, section
, symbols
)))
1981 if (section
->flags
& SEC_CONSTRUCTOR
)
1983 arelent_chain
*chain
= section
->constructor_chain
;
1985 for (count
= 0; count
< section
->reloc_count
; count
++)
1987 *relptr
++ = &chain
->relent
;
1988 chain
= chain
->next
;
1993 tblptr
= section
->relocation
;
1995 for (count
= 0; count
++ < section
->reloc_count
;)
1996 *relptr
++ = tblptr
++;
2001 return section
->reloc_count
;
2005 NAME (aout
, get_reloc_upper_bound
) (bfd
*abfd
, sec_ptr asect
)
2007 if (bfd_get_format (abfd
) != bfd_object
)
2009 bfd_set_error (bfd_error_invalid_operation
);
2013 if (asect
->flags
& SEC_CONSTRUCTOR
)
2014 return (sizeof (arelent
*) * (asect
->reloc_count
+ 1));
2016 if (asect
== obj_datasec (abfd
))
2017 return (sizeof (arelent
*)
2018 * ((exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
))
2021 if (asect
== obj_textsec (abfd
))
2022 return (sizeof (arelent
*)
2023 * ((exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
))
2026 /* TODO: why are there two if statements for obj_bsssec()? */
2028 if (asect
== obj_bsssec (abfd
))
2029 return sizeof (arelent
*);
2031 if (asect
== obj_bsssec (abfd
))
2034 bfd_set_error (bfd_error_invalid_operation
);
2040 NAME (aout
, get_symtab_upper_bound
) (bfd
*abfd
)
2042 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
2045 return (bfd_get_symcount (abfd
) + 1) * (sizeof (aout_symbol_type
*));
2049 NAME (aout
, get_lineno
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2050 asymbol
* symbol ATTRIBUTE_UNUSED
)
2056 NAME (aout
, get_symbol_info
) (bfd
* abfd ATTRIBUTE_UNUSED
,
2060 bfd_symbol_info (symbol
, ret
);
2062 if (ret
->type
== '?')
2064 int type_code
= aout_symbol(symbol
)->type
& 0xff;
2065 const char *stab_name
= bfd_get_stab_name (type_code
);
2066 static char buf
[10];
2068 if (stab_name
== NULL
)
2070 sprintf(buf
, "(%d)", type_code
);
2074 ret
->stab_type
= type_code
;
2075 ret
->stab_other
= (unsigned) (aout_symbol(symbol
)->other
& 0xff);
2076 ret
->stab_desc
= (unsigned) (aout_symbol(symbol
)->desc
& 0xffff);
2077 ret
->stab_name
= stab_name
;
2082 NAME (aout
, print_symbol
) (bfd
* abfd
,
2085 bfd_print_symbol_type how
)
2087 FILE *file
= (FILE *) afile
;
2091 case bfd_print_symbol_name
:
2093 fprintf(file
,"%s", symbol
->name
);
2095 case bfd_print_symbol_more
:
2096 fprintf(file
,"%4x %2x %2x",
2097 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2098 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2099 (unsigned) (aout_symbol (symbol
)->type
));
2101 case bfd_print_symbol_all
:
2103 const char *section_name
= symbol
->section
->name
;
2105 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2107 fprintf (file
," %-5s %04x %02x %02x",
2109 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2110 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2111 (unsigned) (aout_symbol (symbol
)->type
& 0xff));
2113 fprintf(file
," %s", symbol
->name
);
2119 /* If we don't have to allocate more than 1MB to hold the generic
2120 symbols, we use the generic minisymbol method: it's faster, since
2121 it only translates the symbols once, not multiple times. */
2122 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2124 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2125 symbols. The minisymbol_to_symbol function translates these into
2126 BFD asymbol structures. */
2129 NAME (aout
, read_minisymbols
) (bfd
*abfd
,
2130 bfd_boolean dynamic
,
2132 unsigned int *sizep
)
2135 /* We could handle the dynamic symbols here as well, but it's
2136 easier to hand them off. */
2137 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2139 if (! aout_get_external_symbols (abfd
))
2142 if (obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2143 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2145 *minisymsp
= (void *) obj_aout_external_syms (abfd
);
2147 /* By passing the external symbols back from this routine, we are
2148 giving up control over the memory block. Clear
2149 obj_aout_external_syms, so that we do not try to free it
2151 obj_aout_external_syms (abfd
) = NULL
;
2153 *sizep
= EXTERNAL_NLIST_SIZE
;
2154 return obj_aout_external_sym_count (abfd
);
2157 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2158 unmodified a.out symbol. The SYM argument is a structure returned
2159 by bfd_make_empty_symbol, which we fill in here. */
2162 NAME (aout
, minisymbol_to_symbol
) (bfd
*abfd
,
2163 bfd_boolean dynamic
,
2164 const void * minisym
,
2168 || obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2169 return _bfd_generic_minisymbol_to_symbol (abfd
, dynamic
, minisym
, sym
);
2171 memset (sym
, 0, sizeof (aout_symbol_type
));
2173 /* We call translate_symbol_table to translate a single symbol. */
2174 if (! (NAME (aout
, translate_symbol_table
)
2176 (aout_symbol_type
*) sym
,
2177 (struct external_nlist
*) minisym
,
2179 obj_aout_external_strings (abfd
),
2180 obj_aout_external_string_size (abfd
),
2187 /* Provided a BFD, a section and an offset into the section, calculate
2188 and return the name of the source file and the line nearest to the
2192 NAME (aout
, find_nearest_line
) (bfd
*abfd
,
2196 const char **filename_ptr
,
2197 const char **functionname_ptr
,
2198 unsigned int *line_ptr
,
2199 unsigned int *discriminator_ptr
)
2201 /* Run down the file looking for the filename, function and linenumber. */
2203 const char *directory_name
= NULL
;
2204 const char *main_file_name
= NULL
;
2205 const char *current_file_name
= NULL
;
2206 const char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2207 bfd_vma low_line_vma
= 0;
2208 bfd_vma low_func_vma
= 0;
2210 size_t filelen
, funclen
;
2213 *filename_ptr
= abfd
->filename
;
2214 *functionname_ptr
= 0;
2216 if (discriminator_ptr
)
2217 *discriminator_ptr
= 0;
2219 if (symbols
!= NULL
)
2221 for (p
= symbols
; *p
; p
++)
2223 aout_symbol_type
*q
= (aout_symbol_type
*)(*p
);
2228 /* If this looks like a file name symbol, and it comes after
2229 the line number we have found so far, but before the
2230 offset, then we have probably not found the right line
2232 if (q
->symbol
.value
<= offset
2233 && ((q
->symbol
.value
> low_line_vma
2234 && (line_file_name
!= NULL
2236 || (q
->symbol
.value
> low_func_vma
2239 const char * symname
;
2241 symname
= q
->symbol
.name
;
2242 if (strcmp (symname
+ strlen (symname
) - 2, ".o") == 0)
2244 if (q
->symbol
.value
> low_line_vma
)
2247 line_file_name
= NULL
;
2249 if (q
->symbol
.value
> low_func_vma
)
2256 /* If this symbol is less than the offset, but greater than
2257 the line number we have found so far, then we have not
2258 found the right line number. */
2259 if (q
->symbol
.value
<= offset
)
2261 if (q
->symbol
.value
> low_line_vma
)
2264 line_file_name
= NULL
;
2266 if (q
->symbol
.value
> low_func_vma
)
2270 main_file_name
= current_file_name
= q
->symbol
.name
;
2271 /* Look ahead to next symbol to check if that too is an N_SO. */
2275 q
= (aout_symbol_type
*)(*p
);
2276 if (q
->type
!= (int) N_SO
)
2279 /* Found a second N_SO First is directory; second is filename. */
2280 directory_name
= current_file_name
;
2281 main_file_name
= current_file_name
= q
->symbol
.name
;
2282 if (obj_textsec(abfd
) != section
)
2286 current_file_name
= q
->symbol
.name
;
2292 /* We'll keep this if it resolves nearer than the one we have
2294 if (q
->symbol
.value
>= low_line_vma
2295 && q
->symbol
.value
<= offset
)
2297 *line_ptr
= q
->desc
;
2298 low_line_vma
= q
->symbol
.value
;
2299 line_file_name
= current_file_name
;
2305 /* We'll keep this if it is nearer than the one we have already. */
2306 if (q
->symbol
.value
>= low_func_vma
&&
2307 q
->symbol
.value
<= offset
)
2309 low_func_vma
= q
->symbol
.value
;
2310 func
= (asymbol
*) q
;
2312 else if (q
->symbol
.value
> offset
)
2322 main_file_name
= line_file_name
;
2324 if (main_file_name
== NULL
2325 || main_file_name
[0] == '/'
2326 || directory_name
== NULL
)
2329 filelen
= strlen (directory_name
) + strlen (main_file_name
);
2333 funclen
= strlen (bfd_asymbol_name (func
));
2335 if (adata (abfd
).line_buf
!= NULL
)
2336 free (adata (abfd
).line_buf
);
2337 if (filelen
+ funclen
== 0)
2338 adata (abfd
).line_buf
= buf
= NULL
;
2341 buf
= bfd_malloc ((bfd_size_type
) filelen
+ funclen
+ 3);
2342 adata (abfd
).line_buf
= buf
;
2347 if (main_file_name
!= NULL
)
2349 if (main_file_name
[0] == '/' || directory_name
== NULL
)
2350 *filename_ptr
= main_file_name
;
2353 sprintf (buf
, "%s%s", directory_name
, main_file_name
);
2354 *filename_ptr
= buf
;
2361 const char *function
= func
->name
;
2364 /* The caller expects a symbol name. We actually have a
2365 function name, without the leading underscore. Put the
2366 underscore back in, so that the caller gets a symbol name. */
2367 if (bfd_get_symbol_leading_char (abfd
) == '\0')
2368 strcpy (buf
, function
);
2371 buf
[0] = bfd_get_symbol_leading_char (abfd
);
2372 strcpy (buf
+ 1, function
);
2375 /* Have to remove : stuff. */
2376 colon
= strchr (buf
, ':');
2379 *functionname_ptr
= buf
;
2386 NAME (aout
, sizeof_headers
) (bfd
*abfd
,
2387 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2389 return adata (abfd
).exec_bytes_size
;
2392 /* Free all information we have cached for this BFD. We can always
2393 read it again later if we need it. */
2396 NAME (aout
, bfd_free_cached_info
) (bfd
*abfd
)
2400 if (bfd_get_format (abfd
) != bfd_object
)
2403 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2404 BFCI_FREE (obj_aout_symbols (abfd
));
2407 obj_aout_external_syms (abfd
) = 0;
2408 bfd_free_window (&obj_aout_sym_window (abfd
));
2409 bfd_free_window (&obj_aout_string_window (abfd
));
2410 obj_aout_external_strings (abfd
) = 0;
2412 BFCI_FREE (obj_aout_external_syms (abfd
));
2413 BFCI_FREE (obj_aout_external_strings (abfd
));
2415 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2416 BFCI_FREE (o
->relocation
);
2422 /* Routine to create an entry in an a.out link hash table. */
2424 struct bfd_hash_entry
*
2425 NAME (aout
, link_hash_newfunc
) (struct bfd_hash_entry
*entry
,
2426 struct bfd_hash_table
*table
,
2429 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2431 /* Allocate the structure if it has not already been allocated by a
2434 ret
= bfd_hash_allocate (table
, sizeof (* ret
));
2438 /* Call the allocation method of the superclass. */
2439 ret
= (struct aout_link_hash_entry
*)
2440 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
);
2443 /* Set local fields. */
2444 ret
->written
= FALSE
;
2448 return (struct bfd_hash_entry
*) ret
;
2451 /* Initialize an a.out link hash table. */
2454 NAME (aout
, link_hash_table_init
) (struct aout_link_hash_table
*table
,
2456 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
2457 struct bfd_hash_table
*,
2459 unsigned int entsize
)
2461 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
2464 /* Create an a.out link hash table. */
2466 struct bfd_link_hash_table
*
2467 NAME (aout
, link_hash_table_create
) (bfd
*abfd
)
2469 struct aout_link_hash_table
*ret
;
2470 bfd_size_type amt
= sizeof (struct aout_link_hash_table
);
2472 ret
= bfd_malloc (amt
);
2475 if (! NAME (aout
, link_hash_table_init
) (ret
, abfd
,
2476 NAME (aout
, link_hash_newfunc
),
2477 sizeof (struct aout_link_hash_entry
)))
2485 /* Free up the internal symbols read from an a.out file. */
2488 aout_link_free_symbols (bfd
*abfd
)
2490 if (obj_aout_external_syms (abfd
) != NULL
)
2493 bfd_free_window (&obj_aout_sym_window (abfd
));
2495 free ((void *) obj_aout_external_syms (abfd
));
2497 obj_aout_external_syms (abfd
) = NULL
;
2500 if (obj_aout_external_strings (abfd
) != NULL
)
2503 bfd_free_window (&obj_aout_string_window (abfd
));
2505 free ((void *) obj_aout_external_strings (abfd
));
2507 obj_aout_external_strings (abfd
) = NULL
;
2512 /* Given an a.out BFD, add symbols to the global hash table as
2516 NAME (aout
, link_add_symbols
) (bfd
*abfd
, struct bfd_link_info
*info
)
2518 switch (bfd_get_format (abfd
))
2521 return aout_link_add_object_symbols (abfd
, info
);
2523 return _bfd_generic_link_add_archive_symbols
2524 (abfd
, info
, aout_link_check_archive_element
);
2526 bfd_set_error (bfd_error_wrong_format
);
2531 /* Add symbols from an a.out object file. */
2534 aout_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2536 if (! aout_get_external_symbols (abfd
))
2538 if (! aout_link_add_symbols (abfd
, info
))
2540 if (! info
->keep_memory
)
2542 if (! aout_link_free_symbols (abfd
))
2548 /* Look through the internal symbols to see if this object file should
2549 be included in the link. We should include this object file if it
2550 defines any symbols which are currently undefined. If this object
2551 file defines a common symbol, then we may adjust the size of the
2552 known symbol but we do not include the object file in the link
2553 (unless there is some other reason to include it). */
2556 aout_link_check_ar_symbols (bfd
*abfd
,
2557 struct bfd_link_info
*info
,
2558 bfd_boolean
*pneeded
,
2561 struct external_nlist
*p
;
2562 struct external_nlist
*pend
;
2567 /* Look through all the symbols. */
2568 p
= obj_aout_external_syms (abfd
);
2569 pend
= p
+ obj_aout_external_sym_count (abfd
);
2570 strings
= obj_aout_external_strings (abfd
);
2571 for (; p
< pend
; p
++)
2573 int type
= H_GET_8 (abfd
, p
->e_type
);
2575 struct bfd_link_hash_entry
*h
;
2577 /* Ignore symbols that are not externally visible. This is an
2578 optimization only, as we check the type more thoroughly
2580 if ((type
& N_EXT
) == 0
2584 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2585 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
2587 /* We are only interested in symbols that are currently
2588 undefined or common. */
2590 || (h
->type
!= bfd_link_hash_undefined
2591 && h
->type
!= bfd_link_hash_common
))
2594 if (type
== (N_TEXT
| N_EXT
)
2595 || type
== (N_DATA
| N_EXT
)
2596 || type
== (N_BSS
| N_EXT
)
2597 || type
== (N_ABS
| N_EXT
))
2599 /* This object file defines this symbol. We must link it
2600 in. This is true regardless of whether the current
2601 definition of the symbol is undefined or common. If the
2602 current definition is common, we have a case in which we
2603 have already seen an object file including
2605 and this object file from the archive includes
2607 In such a case we must include this object file.
2609 FIXME: The SunOS 4.1.3 linker will pull in the archive
2610 element if the symbol is defined in the .data section,
2611 but not if it is defined in the .text section. That
2612 seems a bit crazy to me, and I haven't implemented it.
2613 However, it might be correct. */
2614 if (!(*info
->callbacks
2615 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2621 if (type
== (N_UNDF
| N_EXT
))
2625 value
= GET_WORD (abfd
, p
->e_value
);
2628 /* This symbol is common in the object from the archive
2630 if (h
->type
== bfd_link_hash_undefined
)
2635 symbfd
= h
->u
.undef
.abfd
;
2638 /* This symbol was created as undefined from
2639 outside BFD. We assume that we should link
2640 in the object file. This is done for the -u
2641 option in the linker. */
2642 if (!(*info
->callbacks
2643 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2648 /* Turn the current link symbol into a common
2649 symbol. It is already on the undefs list. */
2650 h
->type
= bfd_link_hash_common
;
2651 h
->u
.c
.p
= bfd_hash_allocate (&info
->hash
->table
,
2652 sizeof (struct bfd_link_hash_common_entry
));
2653 if (h
->u
.c
.p
== NULL
)
2656 h
->u
.c
.size
= value
;
2658 /* FIXME: This isn't quite right. The maximum
2659 alignment of a common symbol should be set by the
2660 architecture of the output file, not of the input
2662 power
= bfd_log2 (value
);
2663 if (power
> bfd_get_arch_info (abfd
)->section_align_power
)
2664 power
= bfd_get_arch_info (abfd
)->section_align_power
;
2665 h
->u
.c
.p
->alignment_power
= power
;
2667 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
,
2672 /* Adjust the size of the common symbol if
2674 if (value
> h
->u
.c
.size
)
2675 h
->u
.c
.size
= value
;
2681 /* We do not need this object file. */
2685 /* Check a single archive element to see if we need to include it in
2686 the link. *PNEEDED is set according to whether this element is
2687 needed in the link or not. This is called from
2688 _bfd_generic_link_add_archive_symbols. */
2691 aout_link_check_archive_element (bfd
*abfd
,
2692 struct bfd_link_info
*info
,
2693 struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
2694 const char *name ATTRIBUTE_UNUSED
,
2695 bfd_boolean
*pneeded
)
2700 if (!aout_get_external_symbols (abfd
))
2704 if (!aout_link_check_ar_symbols (abfd
, info
, pneeded
, &abfd
))
2710 /* Potentially, the add_archive_element hook may have set a
2711 substitute BFD for us. */
2714 if (!info
->keep_memory
2715 && !aout_link_free_symbols (oldbfd
))
2717 if (!aout_get_external_symbols (abfd
))
2720 if (!aout_link_add_symbols (abfd
, info
))
2724 if (!info
->keep_memory
|| !needed
)
2726 if (!aout_link_free_symbols (abfd
))
2733 /* Add all symbols from an object file to the hash table. */
2736 aout_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2738 bfd_boolean (*add_one_symbol
)
2739 (struct bfd_link_info
*, bfd
*, const char *, flagword
, asection
*,
2740 bfd_vma
, const char *, bfd_boolean
, bfd_boolean
,
2741 struct bfd_link_hash_entry
**);
2742 struct external_nlist
*syms
;
2743 bfd_size_type sym_count
;
2746 struct aout_link_hash_entry
**sym_hash
;
2747 struct external_nlist
*p
;
2748 struct external_nlist
*pend
;
2750 syms
= obj_aout_external_syms (abfd
);
2751 sym_count
= obj_aout_external_sym_count (abfd
);
2752 strings
= obj_aout_external_strings (abfd
);
2753 if (info
->keep_memory
)
2758 if (aout_backend_info (abfd
)->add_dynamic_symbols
!= NULL
)
2760 if (! ((*aout_backend_info (abfd
)->add_dynamic_symbols
)
2761 (abfd
, info
, &syms
, &sym_count
, &strings
)))
2765 /* We keep a list of the linker hash table entries that correspond
2766 to particular symbols. We could just look them up in the hash
2767 table, but keeping the list is more efficient. Perhaps this
2768 should be conditional on info->keep_memory. */
2769 sym_hash
= bfd_alloc (abfd
,
2770 sym_count
* sizeof (struct aout_link_hash_entry
*));
2771 if (sym_hash
== NULL
&& sym_count
!= 0)
2773 obj_aout_sym_hashes (abfd
) = sym_hash
;
2775 add_one_symbol
= aout_backend_info (abfd
)->add_one_symbol
;
2776 if (add_one_symbol
== NULL
)
2777 add_one_symbol
= _bfd_generic_link_add_one_symbol
;
2780 pend
= p
+ sym_count
;
2781 for (; p
< pend
; p
++, sym_hash
++)
2792 type
= H_GET_8 (abfd
, p
->e_type
);
2794 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2795 value
= GET_WORD (abfd
, p
->e_value
);
2801 /* Anything else should be a debugging symbol. */
2802 BFD_ASSERT ((type
& N_STAB
) != 0);
2812 /* Ignore symbols that are not externally visible. */
2815 case N_UNDF
| N_EXT
:
2818 section
= bfd_und_section_ptr
;
2822 section
= bfd_com_section_ptr
;
2825 section
= bfd_abs_section_ptr
;
2827 case N_TEXT
| N_EXT
:
2828 section
= obj_textsec (abfd
);
2829 value
-= bfd_get_section_vma (abfd
, section
);
2831 case N_DATA
| N_EXT
:
2832 /* Treat N_SETV symbols as N_DATA symbol; see comment in
2833 translate_from_native_sym_flags. */
2834 section
= obj_datasec (abfd
);
2835 value
-= bfd_get_section_vma (abfd
, section
);
2838 section
= obj_bsssec (abfd
);
2839 value
-= bfd_get_section_vma (abfd
, section
);
2843 if (! ((*add_one_symbol
)
2844 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, FALSE
,
2845 (struct bfd_link_hash_entry
**) sym_hash
)))
2848 /* Restrict the maximum alignment of a common symbol based on
2849 the architecture, since a.out has no way to represent
2850 alignment requirements of a section in a .o file. FIXME:
2851 This isn't quite right: it should use the architecture of the
2852 output file, not the input files. */
2853 if ((*sym_hash
)->root
.type
== bfd_link_hash_common
2854 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
>
2855 bfd_get_arch_info (abfd
)->section_align_power
))
2856 (*sym_hash
)->root
.u
.c
.p
->alignment_power
=
2857 bfd_get_arch_info (abfd
)->section_align_power
;
2859 /* If this is a set symbol, and we are not building sets, then
2860 it is possible for the hash entry to not have been set. In
2861 such a case, treat the symbol as not globally defined. */
2862 if ((*sym_hash
)->root
.type
== bfd_link_hash_new
)
2864 BFD_ASSERT ((flags
& BSF_CONSTRUCTOR
) != 0);
2872 /* Look up an entry in an the header file hash table. */
2874 #define aout_link_includes_lookup(table, string, create, copy) \
2875 ((struct aout_link_includes_entry *) \
2876 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
2878 /* The function to create a new entry in the header file hash table. */
2880 static struct bfd_hash_entry
*
2881 aout_link_includes_newfunc (struct bfd_hash_entry
*entry
,
2882 struct bfd_hash_table
*table
,
2885 struct aout_link_includes_entry
* ret
=
2886 (struct aout_link_includes_entry
*) entry
;
2888 /* Allocate the structure if it has not already been allocated by a
2891 ret
= bfd_hash_allocate (table
,
2892 sizeof (struct aout_link_includes_entry
));
2896 /* Call the allocation method of the superclass. */
2897 ret
= ((struct aout_link_includes_entry
*)
2898 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
2900 /* Set local fields. */
2903 return (struct bfd_hash_entry
*) ret
;
2907 aout_link_write_other_symbol (struct bfd_hash_entry
*bh
, void *data
)
2909 struct aout_link_hash_entry
*h
= (struct aout_link_hash_entry
*) bh
;
2910 struct aout_final_link_info
*flaginfo
= (struct aout_final_link_info
*) data
;
2914 struct external_nlist outsym
;
2918 if (h
->root
.type
== bfd_link_hash_warning
)
2920 h
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
2921 if (h
->root
.type
== bfd_link_hash_new
)
2925 output_bfd
= flaginfo
->output_bfd
;
2927 if (aout_backend_info (output_bfd
)->write_dynamic_symbol
!= NULL
)
2929 if (! ((*aout_backend_info (output_bfd
)->write_dynamic_symbol
)
2930 (output_bfd
, flaginfo
->info
, h
)))
2932 /* FIXME: No way to handle errors. */
2942 /* An indx of -2 means the symbol must be written. */
2944 && (flaginfo
->info
->strip
== strip_all
2945 || (flaginfo
->info
->strip
== strip_some
2946 && bfd_hash_lookup (flaginfo
->info
->keep_hash
, h
->root
.root
.string
,
2947 FALSE
, FALSE
) == NULL
)))
2950 switch (h
->root
.type
)
2954 /* Avoid variable not initialized warnings. */
2956 case bfd_link_hash_new
:
2957 /* This can happen for set symbols when sets are not being
2960 case bfd_link_hash_undefined
:
2961 type
= N_UNDF
| N_EXT
;
2964 case bfd_link_hash_defined
:
2965 case bfd_link_hash_defweak
:
2969 sec
= h
->root
.u
.def
.section
->output_section
;
2970 BFD_ASSERT (bfd_is_abs_section (sec
)
2971 || sec
->owner
== output_bfd
);
2972 if (sec
== obj_textsec (output_bfd
))
2973 type
= h
->root
.type
== bfd_link_hash_defined
? N_TEXT
: N_WEAKT
;
2974 else if (sec
== obj_datasec (output_bfd
))
2975 type
= h
->root
.type
== bfd_link_hash_defined
? N_DATA
: N_WEAKD
;
2976 else if (sec
== obj_bsssec (output_bfd
))
2977 type
= h
->root
.type
== bfd_link_hash_defined
? N_BSS
: N_WEAKB
;
2979 type
= h
->root
.type
== bfd_link_hash_defined
? N_ABS
: N_WEAKA
;
2981 val
= (h
->root
.u
.def
.value
2983 + h
->root
.u
.def
.section
->output_offset
);
2986 case bfd_link_hash_common
:
2987 type
= N_UNDF
| N_EXT
;
2988 val
= h
->root
.u
.c
.size
;
2990 case bfd_link_hash_undefweak
:
2993 case bfd_link_hash_indirect
:
2994 case bfd_link_hash_warning
:
2995 /* FIXME: Ignore these for now. The circumstances under which
2996 they should be written out are not clear to me. */
3000 H_PUT_8 (output_bfd
, type
, outsym
.e_type
);
3001 indx
= add_to_stringtab (output_bfd
, flaginfo
->strtab
, h
->root
.root
.string
,
3003 if (indx
== (bfd_size_type
) -1)
3004 /* FIXME: No way to handle errors. */
3007 PUT_WORD (output_bfd
, indx
, outsym
.e_strx
);
3008 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
3010 amt
= EXTERNAL_NLIST_SIZE
;
3011 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0
3012 || bfd_bwrite ((void *) &outsym
, amt
, output_bfd
) != amt
)
3013 /* FIXME: No way to handle errors. */
3016 flaginfo
->symoff
+= amt
;
3017 h
->indx
= obj_aout_external_sym_count (output_bfd
);
3018 ++obj_aout_external_sym_count (output_bfd
);
3023 /* Handle a link order which is supposed to generate a reloc. */
3026 aout_link_reloc_link_order (struct aout_final_link_info
*flaginfo
,
3028 struct bfd_link_order
*p
)
3030 struct bfd_link_order_reloc
*pr
;
3033 reloc_howto_type
*howto
;
3034 file_ptr
*reloff_ptr
;
3035 struct reloc_std_external srel
;
3037 bfd_size_type rel_size
;
3041 if (p
->type
== bfd_section_reloc_link_order
)
3044 if (bfd_is_abs_section (pr
->u
.section
))
3045 r_index
= N_ABS
| N_EXT
;
3048 BFD_ASSERT (pr
->u
.section
->owner
== flaginfo
->output_bfd
);
3049 r_index
= pr
->u
.section
->target_index
;
3054 struct aout_link_hash_entry
*h
;
3056 BFD_ASSERT (p
->type
== bfd_symbol_reloc_link_order
);
3058 h
= ((struct aout_link_hash_entry
*)
3059 bfd_wrapped_link_hash_lookup (flaginfo
->output_bfd
, flaginfo
->info
,
3060 pr
->u
.name
, FALSE
, FALSE
, TRUE
));
3066 /* We decided to strip this symbol, but it turns out that we
3067 can't. Note that we lose the other and desc information
3068 here. I don't think that will ever matter for a global
3072 if (!aout_link_write_other_symbol (&h
->root
.root
, flaginfo
))
3078 if (! ((*flaginfo
->info
->callbacks
->unattached_reloc
)
3079 (flaginfo
->info
, pr
->u
.name
, NULL
, NULL
, (bfd_vma
) 0)))
3085 howto
= bfd_reloc_type_lookup (flaginfo
->output_bfd
, pr
->reloc
);
3088 bfd_set_error (bfd_error_bad_value
);
3092 if (o
== obj_textsec (flaginfo
->output_bfd
))
3093 reloff_ptr
= &flaginfo
->treloff
;
3094 else if (o
== obj_datasec (flaginfo
->output_bfd
))
3095 reloff_ptr
= &flaginfo
->dreloff
;
3100 MY_put_reloc(flaginfo
->output_bfd
, r_extern
, r_index
, p
->offset
, howto
,
3110 fprintf (stderr
, "TODO: line %d in bfd/pdp11.c\n", __LINE__
);
3112 r_pcrel
= howto
->pc_relative
;
3113 r_baserel
= (howto
->type
& 8) != 0;
3114 r_jmptable
= (howto
->type
& 16) != 0;
3115 r_relative
= (howto
->type
& 32) != 0;
3116 r_length
= howto
->size
;
3118 PUT_WORD (flaginfo
->output_bfd
, p
->offset
, srel
.r_address
);
3119 if (bfd_header_big_endian (flaginfo
->output_bfd
))
3121 srel
.r_index
[0] = r_index
>> 16;
3122 srel
.r_index
[1] = r_index
>> 8;
3123 srel
.r_index
[2] = r_index
;
3125 ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
3126 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
3127 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
3128 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
3129 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
3130 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
3134 srel
.r_index
[2] = r_index
>> 16;
3135 srel
.r_index
[1] = r_index
>> 8;
3136 srel
.r_index
[0] = r_index
;
3138 ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
3139 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
3140 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
3141 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
3142 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
3143 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
3147 rel_ptr
= (void *) &srel
;
3149 /* We have to write the addend into the object file, since
3150 standard a.out relocs are in place. It would be more
3151 reliable if we had the current contents of the file here,
3152 rather than assuming zeroes, but we can't read the file since
3153 it was opened using bfd_openw. */
3154 if (pr
->addend
!= 0)
3157 bfd_reloc_status_type r
;
3161 size
= bfd_get_reloc_size (howto
);
3162 buf
= bfd_zmalloc (size
);
3163 if (buf
== NULL
&& size
!= 0)
3165 r
= MY_relocate_contents (howto
, flaginfo
->output_bfd
,
3172 case bfd_reloc_outofrange
:
3174 case bfd_reloc_overflow
:
3175 if (! ((*flaginfo
->info
->callbacks
->reloc_overflow
)
3176 (flaginfo
->info
, NULL
,
3177 (p
->type
== bfd_section_reloc_link_order
3178 ? bfd_section_name (flaginfo
->output_bfd
,
3181 howto
->name
, pr
->addend
, NULL
,
3182 (asection
*) NULL
, (bfd_vma
) 0)))
3189 ok
= bfd_set_section_contents (flaginfo
->output_bfd
, o
,
3191 (file_ptr
) p
->offset
,
3198 rel_size
= obj_reloc_entry_size (flaginfo
->output_bfd
);
3199 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0
3200 || bfd_bwrite (rel_ptr
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3203 *reloff_ptr
+= rel_size
;
3205 /* Assert that the relocs have not run into the symbols, and that n
3206 the text relocs have not run into the data relocs. */
3207 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3208 && (reloff_ptr
!= &flaginfo
->treloff
3210 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3215 /* Get the section corresponding to a reloc index. */
3217 static inline asection
*
3218 aout_reloc_type_to_section (bfd
*abfd
, int type
)
3222 case RTEXT
: return obj_textsec (abfd
);
3223 case RDATA
: return obj_datasec (abfd
);
3224 case RBSS
: return obj_bsssec (abfd
);
3225 case RABS
: return bfd_abs_section_ptr
;
3226 case REXT
: return bfd_und_section_ptr
;
3232 pdp11_aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3234 asection
*input_section
,
3236 bfd_size_type rel_size
,
3239 bfd_boolean (*check_dynamic_reloc
)
3240 (struct bfd_link_info
*, bfd
*, asection
*,
3241 struct aout_link_hash_entry
*, void *, bfd_byte
*, bfd_boolean
*,
3244 bfd_boolean relocatable
;
3245 struct external_nlist
*syms
;
3247 struct aout_link_hash_entry
**sym_hashes
;
3252 output_bfd
= flaginfo
->output_bfd
;
3253 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
3255 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_SIZE
);
3256 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
3257 == output_bfd
->xvec
->header_byteorder
);
3259 relocatable
= flaginfo
->info
->relocatable
;
3260 syms
= obj_aout_external_syms (input_bfd
);
3261 strings
= obj_aout_external_strings (input_bfd
);
3262 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
3263 symbol_map
= flaginfo
->symbol_map
;
3266 rel_end
= rel
+ rel_size
;
3267 for (; rel
< rel_end
; rel
+= RELOC_SIZE
)
3274 reloc_howto_type
*howto
;
3275 struct aout_link_hash_entry
*h
= NULL
;
3277 bfd_reloc_status_type r
;
3280 reloc_entry
= GET_WORD (input_bfd
, (void *) rel
);
3281 if (reloc_entry
== 0)
3285 unsigned int howto_idx
;
3287 r_index
= (reloc_entry
& RIDXMASK
) >> 4;
3288 r_type
= reloc_entry
& RTYPE
;
3289 r_pcrel
= reloc_entry
& RELFLG
;
3290 r_addr
= (char *) rel
- (char *) relocs
;
3292 r_extern
= (r_type
== REXT
);
3294 howto_idx
= r_pcrel
;
3295 BFD_ASSERT (howto_idx
< TABLE_SIZE (howto_table_pdp11
));
3296 howto
= howto_table_pdp11
+ howto_idx
;
3301 /* We are generating a relocatable output file, and must
3302 modify the reloc accordingly. */
3305 /* If we know the symbol this relocation is against,
3306 convert it into a relocation against a section. This
3307 is what the native linker does. */
3308 h
= sym_hashes
[r_index
];
3310 && (h
->root
.type
== bfd_link_hash_defined
3311 || h
->root
.type
== bfd_link_hash_defweak
))
3313 asection
*output_section
;
3315 /* Compute a new r_index. */
3316 output_section
= h
->root
.u
.def
.section
->output_section
;
3317 if (output_section
== obj_textsec (output_bfd
))
3319 else if (output_section
== obj_datasec (output_bfd
))
3321 else if (output_section
== obj_bsssec (output_bfd
))
3326 /* Add the symbol value and the section VMA to the
3327 addend stored in the contents. */
3328 relocation
= (h
->root
.u
.def
.value
3329 + output_section
->vma
3330 + h
->root
.u
.def
.section
->output_offset
);
3334 /* We must change r_index according to the symbol
3336 r_index
= symbol_map
[r_index
];
3342 /* We decided to strip this symbol, but it
3343 turns out that we can't. Note that we
3344 lose the other and desc information here.
3345 I don't think that will ever matter for a
3351 if (!aout_link_write_other_symbol (&h
->root
.root
,
3361 name
= strings
+ GET_WORD (input_bfd
,
3362 syms
[r_index
].e_strx
);
3363 if (! ((*flaginfo
->info
->callbacks
->unattached_reloc
)
3364 (flaginfo
->info
, name
, input_bfd
, input_section
,
3374 /* Write out the new r_index value. */
3375 reloc_entry
= GET_WORD (input_bfd
, rel
);
3376 reloc_entry
&= RIDXMASK
;
3377 reloc_entry
|= r_index
<< 4;
3378 PUT_WORD (input_bfd
, reloc_entry
, rel
);
3384 /* This is a relocation against a section. We must
3385 adjust by the amount that the section moved. */
3386 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3387 relocation
= (section
->output_section
->vma
3388 + section
->output_offset
3392 /* Change the address of the relocation. */
3393 fprintf (stderr
, "TODO: change the address of the relocation\n");
3395 /* Adjust a PC relative relocation by removing the reference
3396 to the original address in the section and including the
3397 reference to the new address. */
3399 relocation
-= (input_section
->output_section
->vma
3400 + input_section
->output_offset
3401 - input_section
->vma
);
3403 #ifdef MY_relocatable_reloc
3404 MY_relocatable_reloc (howto
, output_bfd
, rel
, relocation
, r_addr
);
3407 if (relocation
== 0)
3410 r
= MY_relocate_contents (howto
,
3411 input_bfd
, relocation
,
3418 /* We are generating an executable, and must do a full
3423 h
= sym_hashes
[r_index
];
3426 && (h
->root
.type
== bfd_link_hash_defined
3427 || h
->root
.type
== bfd_link_hash_defweak
))
3429 relocation
= (h
->root
.u
.def
.value
3430 + h
->root
.u
.def
.section
->output_section
->vma
3431 + h
->root
.u
.def
.section
->output_offset
);
3434 && h
->root
.type
== bfd_link_hash_undefweak
)
3446 section
= aout_reloc_type_to_section (input_bfd
, r_type
);
3447 relocation
= (section
->output_section
->vma
3448 + section
->output_offset
3451 relocation
+= input_section
->vma
;
3454 if (check_dynamic_reloc
!= NULL
)
3458 if (! ((*check_dynamic_reloc
)
3459 (flaginfo
->info
, input_bfd
, input_section
, h
,
3460 (void *) rel
, contents
, &skip
, &relocation
)))
3466 /* Now warn if a global symbol is undefined. We could not
3467 do this earlier, because check_dynamic_reloc might want
3468 to skip this reloc. */
3469 if (hundef
&& ! flaginfo
->info
->shared
)
3474 name
= h
->root
.root
.string
;
3476 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
3477 if (! ((*flaginfo
->info
->callbacks
->undefined_symbol
)
3478 (flaginfo
->info
, name
, input_bfd
, input_section
,
3483 r
= MY_final_link_relocate (howto
,
3484 input_bfd
, input_section
,
3485 contents
, r_addr
, relocation
,
3489 if (r
!= bfd_reloc_ok
)
3494 case bfd_reloc_outofrange
:
3496 case bfd_reloc_overflow
:
3503 name
= strings
+ GET_WORD (input_bfd
,
3504 syms
[r_index
].e_strx
);
3509 s
= aout_reloc_type_to_section (input_bfd
, r_type
);
3510 name
= bfd_section_name (input_bfd
, s
);
3512 if (! ((*flaginfo
->info
->callbacks
->reloc_overflow
)
3513 (flaginfo
->info
, (h
? &h
->root
: NULL
), name
,
3514 howto
->name
, (bfd_vma
) 0, input_bfd
,
3515 input_section
, r_addr
)))
3526 /* Link an a.out section into the output file. */
3529 aout_link_input_section (struct aout_final_link_info
*flaginfo
,
3531 asection
*input_section
,
3532 file_ptr
*reloff_ptr
,
3533 bfd_size_type rel_size
)
3535 bfd_size_type input_size
;
3538 /* Get the section contents. */
3539 input_size
= input_section
->size
;
3540 if (! bfd_get_section_contents (input_bfd
, input_section
,
3541 (void *) flaginfo
->contents
,
3542 (file_ptr
) 0, input_size
))
3545 /* Read in the relocs if we haven't already done it. */
3546 if (aout_section_data (input_section
) != NULL
3547 && aout_section_data (input_section
)->relocs
!= NULL
)
3548 relocs
= aout_section_data (input_section
)->relocs
;
3551 relocs
= flaginfo
->relocs
;
3554 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3555 || bfd_bread (relocs
, rel_size
, input_bfd
) != rel_size
)
3560 /* Relocate the section contents. */
3561 if (! pdp11_aout_link_input_section (flaginfo
, input_bfd
, input_section
,
3562 (bfd_byte
*) relocs
,
3563 rel_size
, flaginfo
->contents
))
3566 /* Write out the section contents. */
3567 if (! bfd_set_section_contents (flaginfo
->output_bfd
,
3568 input_section
->output_section
,
3569 (void *) flaginfo
->contents
,
3570 (file_ptr
) input_section
->output_offset
,
3574 /* If we are producing relocatable output, the relocs were
3575 modified, and we now write them out. */
3576 if (flaginfo
->info
->relocatable
&& rel_size
> 0)
3578 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
3580 if (bfd_bwrite (relocs
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
3582 *reloff_ptr
+= rel_size
;
3584 /* Assert that the relocs have not run into the symbols, and
3585 that if these are the text relocs they have not run into the
3587 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3588 && (reloff_ptr
!= &flaginfo
->treloff
3590 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3596 /* Link an a.out input BFD into the output file. */
3599 aout_link_input_bfd (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
3601 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
3603 /* If this is a dynamic object, it may need special handling. */
3604 if ((input_bfd
->flags
& DYNAMIC
) != 0
3605 && aout_backend_info (input_bfd
)->link_dynamic_object
!= NULL
)
3606 return ((*aout_backend_info (input_bfd
)->link_dynamic_object
)
3607 (flaginfo
->info
, input_bfd
));
3609 /* Get the symbols. We probably have them already, unless
3610 flaginfo->info->keep_memory is FALSE. */
3611 if (! aout_get_external_symbols (input_bfd
))
3614 /* Write out the symbols and get a map of the new indices. The map
3615 is placed into flaginfo->symbol_map. */
3616 if (! aout_link_write_symbols (flaginfo
, input_bfd
))
3619 /* Relocate and write out the sections. These functions use the
3620 symbol map created by aout_link_write_symbols. The linker_mark
3621 field will be set if these sections are to be included in the
3622 link, which will normally be the case. */
3623 if (obj_textsec (input_bfd
)->linker_mark
)
3625 if (! aout_link_input_section (flaginfo
, input_bfd
,
3626 obj_textsec (input_bfd
),
3628 exec_hdr (input_bfd
)->a_trsize
))
3631 if (obj_datasec (input_bfd
)->linker_mark
)
3633 if (! aout_link_input_section (flaginfo
, input_bfd
,
3634 obj_datasec (input_bfd
),
3636 exec_hdr (input_bfd
)->a_drsize
))
3640 /* If we are not keeping memory, we don't need the symbols any
3641 longer. We still need them if we are keeping memory, because the
3642 strings in the hash table point into them. */
3643 if (! flaginfo
->info
->keep_memory
)
3645 if (! aout_link_free_symbols (input_bfd
))
3652 /* Do the final link step. This is called on the output BFD. The
3653 INFO structure should point to a list of BFDs linked through the
3654 link.next field which can be used to find each BFD which takes part
3655 in the output. Also, each section in ABFD should point to a list
3656 of bfd_link_order structures which list all the input sections for
3657 the output section. */
3660 NAME (aout
, final_link
) (bfd
*abfd
,
3661 struct bfd_link_info
*info
,
3662 void (*callback
) (bfd
*, file_ptr
*, file_ptr
*, file_ptr
*))
3664 struct aout_final_link_info aout_info
;
3665 bfd_boolean includes_hash_initialized
= FALSE
;
3667 bfd_size_type trsize
, drsize
;
3668 bfd_size_type max_contents_size
;
3669 bfd_size_type max_relocs_size
;
3670 bfd_size_type max_sym_count
;
3671 bfd_size_type text_size
;
3673 struct bfd_link_order
*p
;
3675 bfd_boolean have_link_order_relocs
;
3678 abfd
->flags
|= DYNAMIC
;
3680 aout_info
.info
= info
;
3681 aout_info
.output_bfd
= abfd
;
3682 aout_info
.contents
= NULL
;
3683 aout_info
.relocs
= NULL
;
3684 aout_info
.symbol_map
= NULL
;
3685 aout_info
.output_syms
= NULL
;
3687 if (!bfd_hash_table_init_n (&aout_info
.includes
.root
,
3688 aout_link_includes_newfunc
,
3689 sizeof (struct aout_link_includes_entry
),
3692 includes_hash_initialized
= TRUE
;
3694 /* Figure out the largest section size. Also, if generating
3695 relocatable output, count the relocs. */
3698 max_contents_size
= 0;
3699 max_relocs_size
= 0;
3701 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3705 if (info
->relocatable
)
3707 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3709 trsize
+= exec_hdr (sub
)->a_trsize
;
3710 drsize
+= exec_hdr (sub
)->a_drsize
;
3714 /* FIXME: We need to identify the .text and .data sections
3715 and call get_reloc_upper_bound and canonicalize_reloc to
3716 work out the number of relocs needed, and then multiply
3717 by the reloc size. */
3718 (*_bfd_error_handler
)
3719 ("%s: relocatable link from %s to %s not supported",
3720 bfd_get_filename (abfd
),
3721 sub
->xvec
->name
, abfd
->xvec
->name
);
3722 bfd_set_error (bfd_error_invalid_operation
);
3727 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3729 sz
= obj_textsec (sub
)->size
;
3730 if (sz
> max_contents_size
)
3731 max_contents_size
= sz
;
3732 sz
= obj_datasec (sub
)->size
;
3733 if (sz
> max_contents_size
)
3734 max_contents_size
= sz
;
3736 sz
= exec_hdr (sub
)->a_trsize
;
3737 if (sz
> max_relocs_size
)
3738 max_relocs_size
= sz
;
3739 sz
= exec_hdr (sub
)->a_drsize
;
3740 if (sz
> max_relocs_size
)
3741 max_relocs_size
= sz
;
3743 sz
= obj_aout_external_sym_count (sub
);
3744 if (sz
> max_sym_count
)
3749 if (info
->relocatable
)
3751 if (obj_textsec (abfd
) != NULL
)
3752 trsize
+= (_bfd_count_link_order_relocs (obj_textsec (abfd
)
3753 ->map_head
.link_order
)
3754 * obj_reloc_entry_size (abfd
));
3755 if (obj_datasec (abfd
) != NULL
)
3756 drsize
+= (_bfd_count_link_order_relocs (obj_datasec (abfd
)
3757 ->map_head
.link_order
)
3758 * obj_reloc_entry_size (abfd
));
3761 exec_hdr (abfd
)->a_trsize
= trsize
;
3762 exec_hdr (abfd
)->a_drsize
= drsize
;
3763 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
3765 /* Adjust the section sizes and vmas according to the magic number.
3766 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3767 filepos for each section. */
3768 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
, &text_size
, &text_end
))
3771 /* The relocation and symbol file positions differ among a.out
3772 targets. We are passed a callback routine from the backend
3773 specific code to handle this.
3774 FIXME: At this point we do not know how much space the symbol
3775 table will require. This will not work for any (nonstandard)
3776 a.out target that needs to know the symbol table size before it
3777 can compute the relocation file positions. This may or may not
3778 be the case for the hp300hpux target, for example. */
3779 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
3781 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
3782 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
3783 obj_sym_filepos (abfd
) = aout_info
.symoff
;
3785 /* We keep a count of the symbols as we output them. */
3786 obj_aout_external_sym_count (abfd
) = 0;
3788 /* We accumulate the string table as we write out the symbols. */
3789 aout_info
.strtab
= _bfd_stringtab_init ();
3790 if (aout_info
.strtab
== NULL
)
3793 /* Allocate buffers to hold section contents and relocs. */
3794 aout_info
.contents
= bfd_malloc (max_contents_size
);
3795 aout_info
.relocs
= bfd_malloc (max_relocs_size
);
3796 aout_info
.symbol_map
= bfd_malloc (max_sym_count
* sizeof (int *));
3797 aout_info
.output_syms
= bfd_malloc ((max_sym_count
+ 1)
3798 * sizeof (struct external_nlist
));
3799 if ((aout_info
.contents
== NULL
&& max_contents_size
!= 0)
3800 || (aout_info
.relocs
== NULL
&& max_relocs_size
!= 0)
3801 || (aout_info
.symbol_map
== NULL
&& max_sym_count
!= 0)
3802 || aout_info
.output_syms
== NULL
)
3805 /* If we have a symbol named __DYNAMIC, force it out now. This is
3806 required by SunOS. Doing this here rather than in sunos.c is a
3807 hack, but it's easier than exporting everything which would be
3810 struct aout_link_hash_entry
*h
;
3812 h
= aout_link_hash_lookup (aout_hash_table (info
), "__DYNAMIC",
3813 FALSE
, FALSE
, FALSE
);
3815 aout_link_write_other_symbol (&h
->root
.root
, &aout_info
);
3818 /* The most time efficient way to do the link would be to read all
3819 the input object files into memory and then sort out the
3820 information into the output file. Unfortunately, that will
3821 probably use too much memory. Another method would be to step
3822 through everything that composes the text section and write it
3823 out, and then everything that composes the data section and write
3824 it out, and then write out the relocs, and then write out the
3825 symbols. Unfortunately, that requires reading stuff from each
3826 input file several times, and we will not be able to keep all the
3827 input files open simultaneously, and reopening them will be slow.
3829 What we do is basically process one input file at a time. We do
3830 everything we need to do with an input file once--copy over the
3831 section contents, handle the relocation information, and write
3832 out the symbols--and then we throw away the information we read
3833 from it. This approach requires a lot of lseeks of the output
3834 file, which is unfortunate but still faster than reopening a lot
3837 We use the output_has_begun field of the input BFDs to see
3838 whether we have already handled it. */
3839 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3840 sub
->output_has_begun
= FALSE
;
3842 /* Mark all sections which are to be included in the link. This
3843 will normally be every section. We need to do this so that we
3844 can identify any sections which the linker has decided to not
3846 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3848 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
3849 if (p
->type
== bfd_indirect_link_order
)
3850 p
->u
.indirect
.section
->linker_mark
= TRUE
;
3853 have_link_order_relocs
= FALSE
;
3854 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3856 for (p
= o
->map_head
.link_order
;
3860 if (p
->type
== bfd_indirect_link_order
3861 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
3862 == bfd_target_aout_flavour
))
3866 input_bfd
= p
->u
.indirect
.section
->owner
;
3867 if (! input_bfd
->output_has_begun
)
3869 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
3871 input_bfd
->output_has_begun
= TRUE
;
3874 else if (p
->type
== bfd_section_reloc_link_order
3875 || p
->type
== bfd_symbol_reloc_link_order
)
3876 /* These are handled below. */
3877 have_link_order_relocs
= TRUE
;
3880 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3886 /* Write out any symbols that we have not already written out. */
3887 bfd_hash_traverse (&info
->hash
->table
,
3888 aout_link_write_other_symbol
,
3891 /* Now handle any relocs we were asked to create by the linker.
3892 These did not come from any input file. We must do these after
3893 we have written out all the symbols, so that we know the symbol
3895 if (have_link_order_relocs
)
3897 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3899 for (p
= o
->map_head
.link_order
;
3903 if (p
->type
== bfd_section_reloc_link_order
3904 || p
->type
== bfd_symbol_reloc_link_order
)
3906 if (! aout_link_reloc_link_order (&aout_info
, o
, p
))
3913 if (aout_info
.contents
!= NULL
)
3915 free (aout_info
.contents
);
3916 aout_info
.contents
= NULL
;
3918 if (aout_info
.relocs
!= NULL
)
3920 free (aout_info
.relocs
);
3921 aout_info
.relocs
= NULL
;
3923 if (aout_info
.symbol_map
!= NULL
)
3925 free (aout_info
.symbol_map
);
3926 aout_info
.symbol_map
= NULL
;
3928 if (aout_info
.output_syms
!= NULL
)
3930 free (aout_info
.output_syms
);
3931 aout_info
.output_syms
= NULL
;
3933 if (includes_hash_initialized
)
3935 bfd_hash_table_free (&aout_info
.includes
.root
);
3936 includes_hash_initialized
= FALSE
;
3939 /* Finish up any dynamic linking we may be doing. */
3940 if (aout_backend_info (abfd
)->finish_dynamic_link
!= NULL
)
3942 if (! (*aout_backend_info (abfd
)->finish_dynamic_link
) (abfd
, info
))
3946 /* Update the header information. */
3947 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
3948 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
3949 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
3950 obj_textsec (abfd
)->reloc_count
=
3951 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
3952 obj_datasec (abfd
)->reloc_count
=
3953 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
3955 /* Write out the string table, unless there are no symbols. */
3956 if (abfd
->symcount
> 0)
3958 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
3959 || ! emit_stringtab (abfd
, aout_info
.strtab
))
3962 else if (obj_textsec (abfd
)->reloc_count
== 0
3963 && obj_datasec (abfd
)->reloc_count
== 0)
3969 (file_ptr
) (obj_datasec (abfd
)->filepos
3970 + exec_hdr (abfd
)->a_data
3973 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3980 if (aout_info
.contents
!= NULL
)
3981 free (aout_info
.contents
);
3982 if (aout_info
.relocs
!= NULL
)
3983 free (aout_info
.relocs
);
3984 if (aout_info
.symbol_map
!= NULL
)
3985 free (aout_info
.symbol_map
);
3986 if (aout_info
.output_syms
!= NULL
)
3987 free (aout_info
.output_syms
);
3988 if (includes_hash_initialized
)
3989 bfd_hash_table_free (&aout_info
.includes
.root
);
3993 /* Adjust and write out the symbols for an a.out file. Set the new
3994 symbol indices into a symbol_map. */
3997 aout_link_write_symbols (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
4000 bfd_size_type sym_count
;
4002 enum bfd_link_strip strip
;
4003 enum bfd_link_discard discard
;
4004 struct external_nlist
*outsym
;
4005 bfd_size_type strtab_index
;
4006 struct external_nlist
*sym
;
4007 struct external_nlist
*sym_end
;
4008 struct aout_link_hash_entry
**sym_hash
;
4011 bfd_boolean skip_next
;
4013 output_bfd
= flaginfo
->output_bfd
;
4014 sym_count
= obj_aout_external_sym_count (input_bfd
);
4015 strings
= obj_aout_external_strings (input_bfd
);
4016 strip
= flaginfo
->info
->strip
;
4017 discard
= flaginfo
->info
->discard
;
4018 outsym
= flaginfo
->output_syms
;
4020 /* First write out a symbol for this object file, unless we are
4021 discarding such symbols. */
4022 if (strip
!= strip_all
4023 && (strip
!= strip_some
4024 || bfd_hash_lookup (flaginfo
->info
->keep_hash
, input_bfd
->filename
,
4025 FALSE
, FALSE
) != NULL
)
4026 && discard
!= discard_all
)
4028 H_PUT_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
4029 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4030 input_bfd
->filename
, FALSE
);
4031 if (strtab_index
== (bfd_size_type
) -1)
4033 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4034 PUT_WORD (output_bfd
,
4035 (bfd_get_section_vma (output_bfd
,
4036 obj_textsec (input_bfd
)->output_section
)
4037 + obj_textsec (input_bfd
)->output_offset
),
4039 ++obj_aout_external_sym_count (output_bfd
);
4045 sym
= obj_aout_external_syms (input_bfd
);
4046 sym_end
= sym
+ sym_count
;
4047 sym_hash
= obj_aout_sym_hashes (input_bfd
);
4048 symbol_map
= flaginfo
->symbol_map
;
4049 memset (symbol_map
, 0, (size_t) sym_count
* sizeof *symbol_map
);
4050 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
4054 struct aout_link_hash_entry
*h
;
4060 /* We set *symbol_map to 0 above for all symbols. If it has
4061 already been set to -1 for this symbol, it means that we are
4062 discarding it because it appears in a duplicate header file.
4063 See the N_BINCL code below. */
4064 if (*symbol_map
== -1)
4067 /* Initialize *symbol_map to -1, which means that the symbol was
4068 not copied into the output file. We will change it later if
4069 we do copy the symbol over. */
4072 type
= H_GET_8 (input_bfd
, sym
->e_type
);
4073 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
4079 /* Pass this symbol through. It is the target of an
4080 indirect or warning symbol. */
4081 val
= GET_WORD (input_bfd
, sym
->e_value
);
4086 /* Skip this symbol, which is the target of an indirect
4087 symbol that we have changed to no longer be an indirect
4094 struct aout_link_hash_entry
*hresolve
;
4096 /* We have saved the hash table entry for this symbol, if
4097 there is one. Note that we could just look it up again
4098 in the hash table, provided we first check that it is an
4102 /* Use the name from the hash table, in case the symbol was
4105 name
= h
->root
.root
.string
;
4107 /* If this is an indirect or warning symbol, then change
4108 hresolve to the base symbol. We also change *sym_hash so
4109 that the relocation routines relocate against the real
4113 && (h
->root
.type
== bfd_link_hash_indirect
4114 || h
->root
.type
== bfd_link_hash_warning
))
4116 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
4117 while (hresolve
->root
.type
== bfd_link_hash_indirect
4118 || hresolve
->root
.type
== bfd_link_hash_warning
)
4119 hresolve
= ((struct aout_link_hash_entry
*)
4120 hresolve
->root
.u
.i
.link
);
4121 *sym_hash
= hresolve
;
4124 /* If the symbol has already been written out, skip it. */
4126 && h
->root
.type
!= bfd_link_hash_warning
4129 if ((type
& N_TYPE
) == N_INDR
4130 || type
== N_WARNING
)
4132 *symbol_map
= h
->indx
;
4136 /* See if we are stripping this symbol. */
4142 case strip_debugger
:
4143 if ((type
& N_STAB
) != 0)
4147 if (bfd_hash_lookup (flaginfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
4162 /* Get the value of the symbol. */
4163 if ((type
& N_TYPE
) == N_TEXT
4165 symsec
= obj_textsec (input_bfd
);
4166 else if ((type
& N_TYPE
) == N_DATA
4168 symsec
= obj_datasec (input_bfd
);
4169 else if ((type
& N_TYPE
) == N_BSS
4171 symsec
= obj_bsssec (input_bfd
);
4172 else if ((type
& N_TYPE
) == N_ABS
4174 symsec
= bfd_abs_section_ptr
;
4175 else if (((type
& N_TYPE
) == N_INDR
4176 && (hresolve
== NULL
4177 || (hresolve
->root
.type
!= bfd_link_hash_defined
4178 && hresolve
->root
.type
!= bfd_link_hash_defweak
4179 && hresolve
->root
.type
!= bfd_link_hash_common
)))
4180 || type
== N_WARNING
)
4182 /* Pass the next symbol through unchanged. The
4183 condition above for indirect symbols is so that if
4184 the indirect symbol was defined, we output it with
4185 the correct definition so the debugger will
4188 val
= GET_WORD (input_bfd
, sym
->e_value
);
4191 else if ((type
& N_STAB
) != 0)
4193 val
= GET_WORD (input_bfd
, sym
->e_value
);
4198 /* If we get here with an indirect symbol, it means that
4199 we are outputting it with a real definition. In such
4200 a case we do not want to output the next symbol,
4201 which is the target of the indirection. */
4202 if ((type
& N_TYPE
) == N_INDR
)
4207 /* We need to get the value from the hash table. We use
4208 hresolve so that if we have defined an indirect
4209 symbol we output the final definition. */
4212 switch (type
& N_TYPE
)
4215 symsec
= obj_textsec (input_bfd
);
4218 symsec
= obj_datasec (input_bfd
);
4221 symsec
= obj_bsssec (input_bfd
);
4224 symsec
= bfd_abs_section_ptr
;
4231 else if (hresolve
->root
.type
== bfd_link_hash_defined
4232 || hresolve
->root
.type
== bfd_link_hash_defweak
)
4234 asection
*input_section
;
4235 asection
*output_section
;
4237 /* This case usually means a common symbol which was
4238 turned into a defined symbol. */
4239 input_section
= hresolve
->root
.u
.def
.section
;
4240 output_section
= input_section
->output_section
;
4241 BFD_ASSERT (bfd_is_abs_section (output_section
)
4242 || output_section
->owner
== output_bfd
);
4243 val
= (hresolve
->root
.u
.def
.value
4244 + bfd_get_section_vma (output_bfd
, output_section
)
4245 + input_section
->output_offset
);
4247 /* Get the correct type based on the section. If
4248 this is a constructed set, force it to be
4249 globally visible. */
4258 if (output_section
== obj_textsec (output_bfd
))
4259 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4262 else if (output_section
== obj_datasec (output_bfd
))
4263 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4266 else if (output_section
== obj_bsssec (output_bfd
))
4267 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4271 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4275 else if (hresolve
->root
.type
== bfd_link_hash_common
)
4276 val
= hresolve
->root
.u
.c
.size
;
4277 else if (hresolve
->root
.type
== bfd_link_hash_undefweak
)
4286 val
= (symsec
->output_section
->vma
4287 + symsec
->output_offset
4288 + (GET_WORD (input_bfd
, sym
->e_value
)
4291 /* If this is a global symbol set the written flag, and if
4292 it is a local symbol see if we should discard it. */
4296 h
->indx
= obj_aout_external_sym_count (output_bfd
);
4298 else if ((type
& N_TYPE
) != N_SETT
4299 && (type
& N_TYPE
) != N_SETD
4300 && (type
& N_TYPE
) != N_SETB
4301 && (type
& N_TYPE
) != N_SETA
)
4306 case discard_sec_merge
:
4309 if ((type
& N_STAB
) == 0
4310 && bfd_is_local_label_name (input_bfd
, name
))
4324 /* An N_BINCL symbol indicates the start of the stabs
4325 entries for a header file. We need to scan ahead to the
4326 next N_EINCL symbol, ignoring nesting, adding up all the
4327 characters in the symbol names, not including the file
4328 numbers in types (the first number after an open
4330 if (type
== N_BINCL
)
4332 struct external_nlist
*incl_sym
;
4334 struct aout_link_includes_entry
*incl_entry
;
4335 struct aout_link_includes_totals
*t
;
4339 for (incl_sym
= sym
+ 1; incl_sym
< sym_end
; incl_sym
++)
4343 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4344 if (incl_type
== N_EINCL
)
4350 else if (incl_type
== N_BINCL
)
4356 s
= strings
+ GET_WORD (input_bfd
, incl_sym
->e_strx
);
4357 for (; *s
!= '\0'; s
++)
4362 /* Skip the file number. */
4364 while (ISDIGIT (*s
))
4372 /* If we have already included a header file with the
4373 same value, then replace this one with an N_EXCL
4375 copy
= ! flaginfo
->info
->keep_memory
;
4376 incl_entry
= aout_link_includes_lookup (&flaginfo
->includes
,
4378 if (incl_entry
== NULL
)
4380 for (t
= incl_entry
->totals
; t
!= NULL
; t
= t
->next
)
4381 if (t
->total
== val
)
4385 /* This is the first time we have seen this header
4386 file with this set of stabs strings. */
4387 t
= bfd_hash_allocate (&flaginfo
->includes
.root
,
4392 t
->next
= incl_entry
->totals
;
4393 incl_entry
->totals
= t
;
4399 /* This is a duplicate header file. We must change
4400 it to be an N_EXCL entry, and mark all the
4401 included symbols to prevent outputting them. */
4405 for (incl_sym
= sym
+ 1, incl_map
= symbol_map
+ 1;
4407 incl_sym
++, incl_map
++)
4411 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
4412 if (incl_type
== N_EINCL
)
4421 else if (incl_type
== N_BINCL
)
4430 /* Copy this symbol into the list of symbols we are going to
4432 H_PUT_8 (output_bfd
, type
, outsym
->e_type
);
4434 if (! flaginfo
->info
->keep_memory
)
4436 /* name points into a string table which we are going to
4437 free. If there is a hash table entry, use that string.
4438 Otherwise, copy name into memory. */
4440 name
= h
->root
.root
.string
;
4444 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4446 if (strtab_index
== (bfd_size_type
) -1)
4448 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4449 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
4450 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
4451 ++obj_aout_external_sym_count (output_bfd
);
4455 /* Write out the output symbols we have just constructed. */
4456 if (outsym
> flaginfo
->output_syms
)
4460 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0)
4462 size
= outsym
- flaginfo
->output_syms
;
4463 size
*= EXTERNAL_NLIST_SIZE
;
4464 if (bfd_bwrite ((void *) flaginfo
->output_syms
, size
, output_bfd
) != size
)
4466 flaginfo
->symoff
+= size
;
4472 /* Write out a symbol that was not associated with an a.out input
4476 bfd_getp32 (const void *p
)
4478 const bfd_byte
*addr
= p
;
4481 v
= (unsigned long) addr
[1] << 24;
4482 v
|= (unsigned long) addr
[0] << 16;
4483 v
|= (unsigned long) addr
[3] << 8;
4484 v
|= (unsigned long) addr
[2];
4488 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
4490 static bfd_signed_vma
4491 bfd_getp_signed_32 (const void *p
)
4493 const bfd_byte
*addr
= p
;
4496 v
= (unsigned long) addr
[1] << 24;
4497 v
|= (unsigned long) addr
[0] << 16;
4498 v
|= (unsigned long) addr
[3] << 8;
4499 v
|= (unsigned long) addr
[2];
4500 return COERCE32 (v
);
4504 bfd_putp32 (bfd_vma data
, void *p
)
4508 addr
[0] = (data
>> 16) & 0xff;
4509 addr
[1] = (data
>> 24) & 0xff;
4510 addr
[2] = (data
>> 0) & 0xff;
4511 addr
[3] = (data
>> 8) & 0xff;
4514 const bfd_target
MY (vec
) =
4516 TARGETNAME
, /* Name. */
4517 bfd_target_aout_flavour
,
4518 BFD_ENDIAN_LITTLE
, /* Target byte order (little). */
4519 BFD_ENDIAN_LITTLE
, /* Target headers byte order (little). */
4520 (HAS_RELOC
| EXEC_P
| /* Object flags. */
4521 HAS_LINENO
| HAS_DEBUG
|
4522 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
),
4523 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_CODE
| SEC_DATA
),
4524 MY_symbol_leading_char
,
4525 AR_PAD_CHAR
, /* AR_pad_char. */
4526 15, /* AR_max_namelen. */
4527 0, /* match priority. */
4528 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4529 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4530 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Data. */
4531 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
4532 bfd_getp32
, bfd_getp_signed_32
, bfd_putp32
,
4533 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* Headers. */
4534 {_bfd_dummy_target
, MY_object_p
, /* bfd_check_format. */
4535 bfd_generic_archive_p
, MY_core_file_p
},
4536 {bfd_false
, MY_mkobject
, /* bfd_set_format. */
4537 _bfd_generic_mkarchive
, bfd_false
},
4538 {bfd_false
, MY_write_object_contents
, /* bfd_write_contents. */
4539 _bfd_write_archive_contents
, bfd_false
},
4541 BFD_JUMP_TABLE_GENERIC (MY
),
4542 BFD_JUMP_TABLE_COPY (MY
),
4543 BFD_JUMP_TABLE_CORE (MY
),
4544 BFD_JUMP_TABLE_ARCHIVE (MY
),
4545 BFD_JUMP_TABLE_SYMBOLS (MY
),
4546 BFD_JUMP_TABLE_RELOCS (MY
),
4547 BFD_JUMP_TABLE_WRITE (MY
),
4548 BFD_JUMP_TABLE_LINK (MY
),
4549 BFD_JUMP_TABLE_DYNAMIC (MY
),
4551 /* Alternative_target. */
4554 (void *) MY_backend_data