1 /* BFD back-end for PDP-11 a.out binaries.
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
23 /* BFD backend for PDP-11, running 2.11BSD in particular.
25 This file was hacked up by looking hard at the existing vaxnetbsd
26 back end and the header files in 2.11BSD.
29 * support for V7 file formats
30 * support for overlay object files (see 2.11 a.out(5))
31 * support for old and very old archives
32 (see 2.11 ar(5), historical section)
34 Search for TODO to find other areas needing more work. */
36 #define BYTES_IN_WORD 2
37 #define BYTES_IN_LONG 4
39 #undef TARGET_IS_BIG_ENDIAN_P
41 #define TARGET_PAGE_SIZE 1024
42 #define SEGMENT__SIZE TARGET_PAGE_SIZE
44 #define DEFAULT_ARCH bfd_arch_pdp11
45 #define DEFAULT_MID M_PDP11
47 /* Do not "beautify" the CONCAT* macro args. Traditional C will not
48 remove whitespace added here, and thus will fail to concatenate
50 #define MY(OP) CONCAT2 (pdp11_aout_,OP)
52 /* This needs to start with a.out so GDB knows it is an a.out variant. */
53 #define TARGETNAME "a.out-pdp11"
55 /* This is the normal load address for executables. */
56 #define TEXT_START_ADDR 0
58 /* The header is not included in the text segment. */
59 #define N_HEADER_IN_TEXT(x) 0
61 /* There is no flags field. */
62 #define N_FLAGS(exec) 0
64 #define N_SET_FLAGS(exec, flags) do { } while (0)
65 #define N_BADMAG(x) (N_MAGIC(x) != OMAGIC \
66 && N_MAGIC(x) != NMAGIC \
67 && N_MAGIC(x) != ZMAGIC)
72 #define external_exec pdp11_external_exec
73 struct pdp11_external_exec
75 bfd_byte e_info[2]; /* Magic number. */
76 bfd_byte e_text[2]; /* Length of text section in bytes. */
77 bfd_byte e_data[2]; /* Length of data section in bytes. */
78 bfd_byte e_bss[2]; /* Length of bss area in bytes. */
79 bfd_byte e_syms[2]; /* Length of symbol table in bytes. */
80 bfd_byte e_entry[2]; /* Start address. */
81 bfd_byte e_unused[2]; /* Not used. */
82 bfd_byte e_flag[2]; /* Relocation info stripped. */
83 bfd_byte e_relocatable; /* Ugly hack. */
86 #define EXEC_BYTES_SIZE (8 * 2)
88 #define A_MAGIC1 OMAGIC
89 #define OMAGIC 0407 /* ...object file or impure executable. */
90 #define A_MAGIC2 NMAGIC
91 #define NMAGIC 0410 /* Pure executable. */
92 #define ZMAGIC 0413 /* Demand-paged executable. */
93 #define A_MAGIC3 0411 /* Separated I&D. */
94 #define A_MAGIC4 0405 /* Overlay. */
95 #define A_MAGIC5 0430 /* Auto-overlay (nonseparate). */
96 #define A_MAGIC6 0431 /* Auto-overlay (separate). */
100 #define A_FLAG_RELOC_STRIPPED 0x0001
102 #define external_nlist pdp11_external_nlist
103 struct pdp11_external_nlist
105 bfd_byte e_unused[2]; /* Unused. */
106 bfd_byte e_strx[2]; /* Index into string table of name. */
107 bfd_byte e_type[1]; /* Type of symbol. */
108 bfd_byte e_ovly[1]; /* Overlay number. */
109 bfd_byte e_value[2]; /* Value of symbol. */
112 #define EXTERNAL_NLIST_SIZE 8
114 #define N_TXTOFF(x) (EXEC_BYTES_SIZE)
115 #define N_DATOFF(x) (N_TXTOFF(x) + (x).a_text)
116 #define N_TRELOFF(x) (N_DATOFF(x) + (x).a_data)
117 #define N_DRELOFF(x) (N_TRELOFF(x) + (x).a_trsize)
118 #define N_SYMOFF(x) (N_DRELOFF(x) + (x).a_drsize)
119 #define N_STROFF(x) (N_SYMOFF(x) + (x).a_syms)
121 #define WRITE_HEADERS(abfd, execp) pdp11_aout_write_headers (abfd, execp)
126 #define SWAP_MAGIC(ext) bfd_getl16 (ext)
128 #define MY_entry_is_text_address 1
130 #define MY_write_object_contents MY(write_object_contents)
131 static bfd_boolean MY(write_object_contents) (bfd *);
132 #define MY_text_includes_header 1
134 #define MY_BFD_TARGET
136 #include "aout-target.h"
138 /* Start of modified aoutx.h. */
139 #define KEEPIT udata.i
141 #include <string.h> /* For strchr and friends. */
144 #include "safe-ctype.h"
148 #include "aout/aout64.h"
149 #include "aout/stab_gnu.h"
161 #define N_TYPE 0x1f /* Type mask. */
162 #define N_UNDF 0x00 /* Undefined. */
163 #define N_ABS 0x01 /* Absolute. */
164 #define N_TEXT 0x02 /* Text segment. */
165 #define N_DATA 0x03 /* Data segment. */
166 #define N_BSS 0x04 /* Bss segment. */
167 #define N_REG 0x14 /* Register symbol. */
168 #define N_FN 0x1f /* File name. */
169 #define N_EXT 0x20 /* External flag. */
173 #define RELFLG 0x0001 /* PC-relative flag. */
174 #define RTYPE 0x000e /* Type mask. */
175 #define RIDXMASK 0xfff0 /* Index mask. */
177 #define RABS 0x00 /* Absolute. */
178 #define RTEXT 0x02 /* Text. */
179 #define RDATA 0x04 /* Data. */
180 #define RBSS 0x06 /* Bss. */
181 #define REXT 0x08 /* External. */
183 #define RINDEX(x) (((x) & 0xfff0) >> 4)
185 #ifndef MY_final_link_relocate
186 #define MY_final_link_relocate _bfd_final_link_relocate
189 #ifndef MY_relocate_contents
190 #define MY_relocate_contents _bfd_relocate_contents
193 /* A hash table used for header files with N_BINCL entries. */
195 struct aout_link_includes_table
197 struct bfd_hash_table root;
200 /* A linked list of totals that we have found for a particular header
203 struct aout_link_includes_totals
205 struct aout_link_includes_totals *next;
209 /* An entry in the header file hash table. */
211 struct aout_link_includes_entry
213 struct bfd_hash_entry root;
214 /* List of totals we have found for this file. */
215 struct aout_link_includes_totals *totals;
218 /* During the final link step we need to pass around a bunch of
219 information, so we do it in an instance of this structure. */
221 struct aout_final_link_info
223 /* General link information. */
224 struct bfd_link_info *info;
227 /* Reloc file positions. */
228 file_ptr treloff, dreloff;
229 /* File position of symbols. */
232 struct bfd_strtab_hash *strtab;
233 /* Header file hash table. */
234 struct aout_link_includes_table includes;
235 /* A buffer large enough to hold the contents of any section. */
237 /* A buffer large enough to hold the relocs of any section. */
239 /* A buffer large enough to hold the symbol map of any input BFD. */
241 /* A buffer large enough to hold output symbols of any input BFD. */
242 struct external_nlist *output_syms;
245 reloc_howto_type howto_table_pdp11[] =
247 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
248 HOWTO( 0, 0, 1, 16, FALSE, 0, complain_overflow_signed,0,"16", TRUE, 0x0000ffff,0x0000ffff, FALSE),
249 HOWTO( 1, 0, 1, 16, TRUE, 0, complain_overflow_signed,0,"DISP16", TRUE, 0x0000ffff,0x0000ffff, FALSE),
252 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
255 static bfd_boolean aout_link_check_archive_element (bfd *, struct bfd_link_info *, bfd_boolean *);
256 static bfd_boolean aout_link_add_object_symbols (bfd *, struct bfd_link_info *);
257 static bfd_boolean aout_link_add_symbols (bfd *, struct bfd_link_info *);
258 static bfd_boolean aout_link_write_symbols (struct aout_final_link_info *, bfd *);
262 NAME (aout, reloc_type_lookup) (bfd * abfd ATTRIBUTE_UNUSED,
263 bfd_reloc_code_real_type code)
268 return &howto_table_pdp11[0];
269 case BFD_RELOC_16_PCREL:
270 return &howto_table_pdp11[1];
277 NAME (aout, reloc_name_lookup) (bfd *abfd ATTRIBUTE_UNUSED,
283 i < sizeof (howto_table_pdp11) / sizeof (howto_table_pdp11[0]);
285 if (howto_table_pdp11[i].name != NULL
286 && strcasecmp (howto_table_pdp11[i].name, r_name) == 0)
287 return &howto_table_pdp11[i];
293 pdp11_aout_write_headers (bfd *abfd, struct internal_exec *execp)
295 struct external_exec exec_bytes;
296 bfd_size_type text_size;
299 if (adata(abfd).magic == undecided_magic)
300 NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
302 execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE;
303 execp->a_entry = bfd_get_start_address (abfd);
305 if (obj_textsec (abfd)->reloc_count > 0
306 || obj_datasec (abfd)->reloc_count > 0)
308 execp->a_trsize = execp->a_text;
309 execp->a_drsize = execp->a_data;
317 NAME (aout, swap_exec_header_out) (abfd, execp, & exec_bytes);
319 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
322 if (bfd_bwrite ((void *) &exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd)
326 /* Now write out reloc info, followed by syms and strings. */
327 if (bfd_get_outsymbols (abfd) != NULL
328 && bfd_get_symcount (abfd) != 0)
330 if (bfd_seek (abfd, (file_ptr) (N_SYMOFF(*execp)), SEEK_SET) != 0)
333 if (! NAME (aout, write_syms) (abfd))
337 if (obj_textsec (abfd)->reloc_count > 0
338 || obj_datasec (abfd)->reloc_count > 0)
340 if (bfd_seek (abfd, (file_ptr) (N_TRELOFF(*execp)), SEEK_SET) != 0
341 || !NAME (aout, squirt_out_relocs) (abfd, obj_textsec (abfd))
342 || bfd_seek (abfd, (file_ptr) (N_DRELOFF(*execp)), SEEK_SET) != 0
343 || !NAME (aout, squirt_out_relocs) (abfd, obj_datasec (abfd)))
350 /* Write an object file.
351 Section contents have already been written. We write the
352 file header, symbols, and relocation. */
355 MY(write_object_contents) (bfd *abfd)
357 struct internal_exec *execp = exec_hdr (abfd);
359 /* We must make certain that the magic number has been set. This
360 will normally have been done by set_section_contents, but only if
361 there actually are some section contents. */
362 if (! abfd->output_has_begun)
364 bfd_size_type text_size;
367 NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
370 obj_reloc_entry_size (abfd) = RELOC_SIZE;
372 return WRITE_HEADERS (abfd, execp);
375 /* Swap the information in an executable header @var{raw_bytes} taken
376 from a raw byte stream memory image into the internal exec header
377 structure "execp". */
379 #ifndef NAME_swap_exec_header_in
381 NAME (aout, swap_exec_header_in) (bfd *abfd,
382 struct external_exec *bytes,
383 struct internal_exec *execp)
385 /* The internal_exec structure has some fields that are unused in this
386 configuration (IE for i960), so ensure that all such uninitialized
387 fields are zero'd out. There are places where two of these structs
388 are memcmp'd, and thus the contents do matter. */
389 memset ((void *) execp, 0, sizeof (struct internal_exec));
390 /* Now fill in fields in the execp, from the bytes in the raw data. */
391 execp->a_info = GET_MAGIC (abfd, bytes->e_info);
392 execp->a_text = GET_WORD (abfd, bytes->e_text);
393 execp->a_data = GET_WORD (abfd, bytes->e_data);
394 execp->a_bss = GET_WORD (abfd, bytes->e_bss);
395 execp->a_syms = GET_WORD (abfd, bytes->e_syms);
396 execp->a_entry = GET_WORD (abfd, bytes->e_entry);
398 if (GET_WORD (abfd, bytes->e_flag) & A_FLAG_RELOC_STRIPPED)
405 execp->a_trsize = execp->a_text;
406 execp->a_drsize = execp->a_data;
409 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
412 /* Swap the information in an internal exec header structure
413 "execp" into the buffer "bytes" ready for writing to disk. */
415 NAME (aout, swap_exec_header_out) (bfd *abfd,
416 struct internal_exec *execp,
417 struct external_exec *bytes)
419 /* Now fill in fields in the raw data, from the fields in the exec struct. */
420 PUT_MAGIC (abfd, execp->a_info, bytes->e_info);
421 PUT_WORD (abfd, execp->a_text, bytes->e_text);
422 PUT_WORD (abfd, execp->a_data, bytes->e_data);
423 PUT_WORD (abfd, execp->a_bss, bytes->e_bss);
424 PUT_WORD (abfd, execp->a_syms, bytes->e_syms);
425 PUT_WORD (abfd, execp->a_entry, bytes->e_entry);
426 PUT_WORD (abfd, 0, bytes->e_unused);
428 if ((execp->a_trsize == 0 || execp->a_text == 0)
429 && (execp->a_drsize == 0 || execp->a_data == 0))
430 PUT_WORD (abfd, A_FLAG_RELOC_STRIPPED, bytes->e_flag);
431 else if (execp->a_trsize == execp->a_text
432 && execp->a_drsize == execp->a_data)
433 PUT_WORD (abfd, 0, bytes->e_flag);
436 /* TODO: print a proper warning message. */
437 fprintf (stderr, "BFD:%s:%d: internal error\n", __FILE__, __LINE__);
438 PUT_WORD (abfd, 0, bytes->e_flag);
442 /* Make all the section for an a.out file. */
445 NAME (aout, make_sections) (bfd *abfd)
447 if (obj_textsec (abfd) == NULL && bfd_make_section (abfd, ".text") == NULL)
449 if (obj_datasec (abfd) == NULL && bfd_make_section (abfd, ".data") == NULL)
451 if (obj_bsssec (abfd) == NULL && bfd_make_section (abfd, ".bss") == NULL)
456 /* Some a.out variant thinks that the file open in ABFD
457 checking is an a.out file. Do some more checking, and set up
458 for access if it really is. Call back to the calling
459 environment's "finish up" function just before returning, to
460 handle any last-minute setup. */
463 NAME (aout, some_aout_object_p) (bfd *abfd,
464 struct internal_exec *execp,
465 const bfd_target *(*callback_to_real_object_p) (bfd *))
467 struct aout_data_struct *rawptr, *oldrawptr;
468 const bfd_target *result;
469 bfd_size_type amt = sizeof (struct aout_data_struct);
471 rawptr = bfd_zalloc (abfd, amt);
475 oldrawptr = abfd->tdata.aout_data;
476 abfd->tdata.aout_data = rawptr;
478 /* Copy the contents of the old tdata struct.
479 In particular, we want the subformat, since for hpux it was set in
480 hp300hpux.c:swap_exec_header_in and will be used in
481 hp300hpux.c:callback. */
482 if (oldrawptr != NULL)
483 *abfd->tdata.aout_data = *oldrawptr;
485 abfd->tdata.aout_data->a.hdr = &rawptr->e;
486 *(abfd->tdata.aout_data->a.hdr) = *execp; /* Copy in the internal_exec struct. */
487 execp = abfd->tdata.aout_data->a.hdr;
489 /* Set the file flags. */
490 abfd->flags = BFD_NO_FLAGS;
491 if (execp->a_drsize || execp->a_trsize)
492 abfd->flags |= HAS_RELOC;
493 /* Setting of EXEC_P has been deferred to the bottom of this function. */
495 abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
496 if (N_DYNAMIC(*execp))
497 abfd->flags |= DYNAMIC;
499 if (N_MAGIC (*execp) == ZMAGIC)
501 abfd->flags |= D_PAGED | WP_TEXT;
502 adata (abfd).magic = z_magic;
504 else if (N_MAGIC (*execp) == NMAGIC)
506 abfd->flags |= WP_TEXT;
507 adata (abfd).magic = n_magic;
509 else if (N_MAGIC (*execp) == OMAGIC)
510 adata (abfd).magic = o_magic;
513 /* Should have been checked with N_BADMAG before this routine
518 bfd_get_start_address (abfd) = execp->a_entry;
520 obj_aout_symbols (abfd) = NULL;
521 bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist);
523 /* The default relocation entry size is that of traditional V7 Unix. */
524 obj_reloc_entry_size (abfd) = RELOC_SIZE;
526 /* The default symbol entry size is that of traditional Unix. */
527 obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE;
530 bfd_init_window (&obj_aout_sym_window (abfd));
531 bfd_init_window (&obj_aout_string_window (abfd));
534 obj_aout_external_syms (abfd) = NULL;
535 obj_aout_external_strings (abfd) = NULL;
536 obj_aout_sym_hashes (abfd) = NULL;
538 if (! NAME (aout, make_sections) (abfd))
541 obj_datasec (abfd)->size = execp->a_data;
542 obj_bsssec (abfd)->size = execp->a_bss;
544 obj_textsec (abfd)->flags =
545 (execp->a_trsize != 0
546 ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC)
547 : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS));
548 obj_datasec (abfd)->flags =
549 (execp->a_drsize != 0
550 ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC)
551 : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS));
552 obj_bsssec (abfd)->flags = SEC_ALLOC;
554 #ifdef THIS_IS_ONLY_DOCUMENTATION
555 /* The common code can't fill in these things because they depend
556 on either the start address of the text segment, the rounding
557 up of virtual addresses between segments, or the starting file
558 position of the text segment -- all of which varies among different
559 versions of a.out. */
561 /* Call back to the format-dependent code to fill in the rest of the
562 fields and do any further cleanup. Things that should be filled
563 in by the callback: */
564 struct exec *execp = exec_hdr (abfd);
566 obj_textsec (abfd)->size = N_TXTSIZE(*execp);
567 /* Data and bss are already filled in since they're so standard. */
569 /* The virtual memory addresses of the sections. */
570 obj_textsec (abfd)->vma = N_TXTADDR(*execp);
571 obj_datasec (abfd)->vma = N_DATADDR(*execp);
572 obj_bsssec (abfd)->vma = N_BSSADDR(*execp);
574 /* The file offsets of the sections. */
575 obj_textsec (abfd)->filepos = N_TXTOFF(*execp);
576 obj_datasec (abfd)->filepos = N_DATOFF(*execp);
578 /* The file offsets of the relocation info. */
579 obj_textsec (abfd)->rel_filepos = N_TRELOFF(*execp);
580 obj_datasec (abfd)->rel_filepos = N_DRELOFF(*execp);
582 /* The file offsets of the string table and symbol table. */
583 obj_str_filepos (abfd) = N_STROFF (*execp);
584 obj_sym_filepos (abfd) = N_SYMOFF (*execp);
586 /* Determine the architecture and machine type of the object file. */
587 abfd->obj_arch = bfd_arch_obscure;
589 adata(abfd)->page_size = TARGET_PAGE_SIZE;
590 adata(abfd)->segment_size = SEGMENT_SIZE;
591 adata(abfd)->exec_bytes_size = EXEC_BYTES_SIZE;
595 /* The architecture is encoded in various ways in various a.out variants,
596 or is not encoded at all in some of them. The relocation size depends
597 on the architecture and the a.out variant. Finally, the return value
598 is the bfd_target vector in use. If an error occurs, return zero and
599 set bfd_error to the appropriate error code.
601 Formats such as b.out, which have additional fields in the a.out
602 header, should cope with them in this callback as well. */
603 #endif /* DOCUMENTATION */
605 result = (*callback_to_real_object_p)(abfd);
607 /* Now that the segment addresses have been worked out, take a better
608 guess at whether the file is executable. If the entry point
609 is within the text segment, assume it is. (This makes files
610 executable even if their entry point address is 0, as long as
611 their text starts at zero.).
613 This test had to be changed to deal with systems where the text segment
614 runs at a different location than the default. The problem is that the
615 entry address can appear to be outside the text segment, thus causing an
616 erroneous conclusion that the file isn't executable.
618 To fix this, we now accept any non-zero entry point as an indication of
619 executability. This will work most of the time, since only the linker
620 sets the entry point, and that is likely to be non-zero for most systems. */
622 if (execp->a_entry != 0
623 || (execp->a_entry >= obj_textsec(abfd)->vma
624 && execp->a_entry < obj_textsec(abfd)->vma + obj_textsec(abfd)->size))
625 abfd->flags |= EXEC_P;
629 struct stat stat_buf;
631 /* The original heuristic doesn't work in some important cases.
632 The a.out file has no information about the text start
633 address. For files (like kernels) linked to non-standard
634 addresses (ld -Ttext nnn) the entry point may not be between
635 the default text start (obj_textsec(abfd)->vma) and
636 (obj_textsec(abfd)->vma) + text size. This is not just a mach
637 issue. Many kernels are loaded at non standard addresses. */
638 if (abfd->iostream != NULL
639 && (abfd->flags & BFD_IN_MEMORY) == 0
640 && (fstat(fileno((FILE *) (abfd->iostream)), &stat_buf) == 0)
641 && ((stat_buf.st_mode & 0111) != 0))
642 abfd->flags |= EXEC_P;
644 #endif /* STAT_FOR_EXEC */
649 abfd->tdata.aout_data = oldrawptr;
654 /* Initialize ABFD for use with a.out files. */
657 NAME (aout, mkobject) (bfd *abfd)
659 struct aout_data_struct *rawptr;
660 bfd_size_type amt = sizeof (struct aout_data_struct);
662 bfd_set_error (bfd_error_system_call);
664 /* Use an intermediate variable for clarity. */
665 rawptr = bfd_zalloc (abfd, amt);
670 abfd->tdata.aout_data = rawptr;
671 exec_hdr (abfd) = &(rawptr->e);
673 obj_textsec (abfd) = NULL;
674 obj_datasec (abfd) = NULL;
675 obj_bsssec (abfd) = NULL;
680 /* Keep track of machine architecture and machine type for
681 a.out's. Return the <<machine_type>> for a particular
682 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
683 and machine can't be represented in a.out format.
685 If the architecture is understood, machine type 0 (default)
686 is always understood. */
689 NAME (aout, machine_type) (enum bfd_architecture arch,
690 unsigned long machine,
691 bfd_boolean *unknown)
693 enum machine_type arch_flags;
695 arch_flags = M_UNKNOWN;
702 || machine == bfd_mach_sparc
703 || machine == bfd_mach_sparc_sparclite
704 || machine == bfd_mach_sparc_v9)
705 arch_flags = M_SPARC;
706 else if (machine == bfd_mach_sparc_sparclet)
707 arch_flags = M_SPARCLET;
713 case 0: arch_flags = M_68010; break;
714 case bfd_mach_m68000: arch_flags = M_UNKNOWN; *unknown = FALSE; break;
715 case bfd_mach_m68010: arch_flags = M_68010; break;
716 case bfd_mach_m68020: arch_flags = M_68020; break;
717 default: arch_flags = M_UNKNOWN; break;
723 || machine == bfd_mach_i386_i386
724 || machine == bfd_mach_i386_i386_intel_syntax)
729 if (machine == 0) arch_flags = M_ARM;
737 case bfd_mach_mips3000:
738 arch_flags = M_MIPS1;
740 case bfd_mach_mips4000: /* MIPS3 */
741 case bfd_mach_mips4400:
742 case bfd_mach_mips8000: /* MIPS4 */
743 case bfd_mach_mips6000: /* Real MIPS2: */
744 arch_flags = M_MIPS2;
747 arch_flags = M_UNKNOWN;
755 case 0: arch_flags = M_NS32532; break;
756 case 32032: arch_flags = M_NS32032; break;
757 case 32532: arch_flags = M_NS32532; break;
758 default: arch_flags = M_UNKNOWN; break;
763 /* TODO: arch_flags = M_PDP11; */
772 arch_flags = M_UNKNOWN;
775 if (arch_flags != M_UNKNOWN)
781 /* Set the architecture and the machine of the ABFD to the
782 values ARCH and MACHINE. Verify that @ABFD's format
783 can support the architecture required. */
786 NAME (aout, set_arch_mach) (bfd *abfd,
787 enum bfd_architecture arch,
788 unsigned long machine)
790 if (! bfd_default_set_arch_mach (abfd, arch, machine))
793 if (arch != bfd_arch_unknown)
797 NAME (aout, machine_type) (arch, machine, &unknown);
802 obj_reloc_entry_size (abfd) = RELOC_SIZE;
804 return (*aout_backend_info(abfd)->set_sizes) (abfd);
808 adjust_o_magic (bfd *abfd, struct internal_exec *execp)
810 file_ptr pos = adata (abfd).exec_bytes_size;
815 obj_textsec (abfd)->filepos = pos;
816 if (! obj_textsec (abfd)->user_set_vma)
817 obj_textsec (abfd)->vma = vma;
819 vma = obj_textsec (abfd)->vma;
821 pos += obj_textsec (abfd)->size;
822 vma += obj_textsec (abfd)->size;
825 if (!obj_datasec (abfd)->user_set_vma)
827 obj_textsec (abfd)->size += pad;
830 obj_datasec (abfd)->vma = vma;
833 vma = obj_datasec (abfd)->vma;
834 obj_datasec (abfd)->filepos = pos;
835 pos += obj_datasec (abfd)->size;
836 vma += obj_datasec (abfd)->size;
839 if (! obj_bsssec (abfd)->user_set_vma)
841 obj_datasec (abfd)->size += pad;
844 obj_bsssec (abfd)->vma = vma;
848 /* The VMA of the .bss section is set by the VMA of the
849 .data section plus the size of the .data section. We may
850 need to add padding bytes to make this true. */
851 pad = obj_bsssec (abfd)->vma - vma;
854 obj_datasec (abfd)->size += pad;
858 obj_bsssec (abfd)->filepos = pos;
860 /* Fix up the exec header. */
861 execp->a_text = obj_textsec (abfd)->size;
862 execp->a_data = obj_datasec (abfd)->size;
863 execp->a_bss = obj_bsssec (abfd)->size;
864 N_SET_MAGIC (*execp, OMAGIC);
868 adjust_z_magic (bfd *abfd, struct internal_exec *execp)
870 bfd_size_type data_pad, text_pad;
872 const struct aout_backend_data *abdp;
873 int ztih; /* Nonzero if text includes exec header. */
875 abdp = aout_backend_info (abfd);
879 && (abdp->text_includes_header
880 || obj_aout_subformat (abfd) == q_magic_format));
881 obj_textsec(abfd)->filepos = (ztih
882 ? adata(abfd).exec_bytes_size
883 : adata(abfd).zmagic_disk_block_size);
884 if (! obj_textsec(abfd)->user_set_vma)
886 /* ?? Do we really need to check for relocs here? */
887 obj_textsec(abfd)->vma = ((abfd->flags & HAS_RELOC)
890 ? (abdp->default_text_vma
891 + adata (abfd).exec_bytes_size)
892 : abdp->default_text_vma));
897 /* The .text section is being loaded at an unusual address. We
898 may need to pad it such that the .data section starts at a page
901 text_pad = ((obj_textsec (abfd)->filepos - obj_textsec (abfd)->vma)
902 & (adata (abfd).page_size - 1));
904 text_pad = ((- obj_textsec (abfd)->vma)
905 & (adata (abfd).page_size - 1));
908 /* Find start of data. */
911 text_end = obj_textsec (abfd)->filepos + obj_textsec (abfd)->size;
912 text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
916 /* Note that if page_size == zmagic_disk_block_size, then
917 filepos == page_size, and this case is the same as the ztih
919 text_end = obj_textsec (abfd)->size;
920 text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
921 text_end += obj_textsec (abfd)->filepos;
924 obj_textsec (abfd)->size += text_pad;
925 text_end += text_pad;
928 if (!obj_datasec(abfd)->user_set_vma)
931 vma = obj_textsec(abfd)->vma + obj_textsec(abfd)->size;
932 obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
934 if (abdp && abdp->zmagic_mapped_contiguous)
936 text_pad = (obj_datasec(abfd)->vma
937 - obj_textsec(abfd)->vma
938 - obj_textsec(abfd)->size);
939 obj_textsec(abfd)->size += text_pad;
941 obj_datasec (abfd)->filepos = (obj_textsec (abfd)->filepos
942 + obj_textsec (abfd)->size);
944 /* Fix up exec header while we're at it. */
945 execp->a_text = obj_textsec(abfd)->size;
946 if (ztih && (!abdp || (abdp && !abdp->exec_header_not_counted)))
947 execp->a_text += adata(abfd).exec_bytes_size;
948 N_SET_MAGIC (*execp, ZMAGIC);
950 /* Spec says data section should be rounded up to page boundary. */
951 obj_datasec(abfd)->size
952 = align_power (obj_datasec(abfd)->size,
953 obj_bsssec(abfd)->alignment_power);
954 execp->a_data = BFD_ALIGN (obj_datasec(abfd)->size,
955 adata(abfd).page_size);
956 data_pad = execp->a_data - obj_datasec(abfd)->size;
959 if (!obj_bsssec(abfd)->user_set_vma)
960 obj_bsssec(abfd)->vma = (obj_datasec(abfd)->vma
961 + obj_datasec(abfd)->size);
962 /* If the BSS immediately follows the data section and extra space
963 in the page is left after the data section, fudge data
964 in the header so that the bss section looks smaller by that
965 amount. We'll start the bss section there, and lie to the OS.
966 (Note that a linker script, as well as the above assignment,
967 could have explicitly set the BSS vma to immediately follow
968 the data section.) */
969 if (align_power (obj_bsssec(abfd)->vma, obj_bsssec(abfd)->alignment_power)
970 == obj_datasec(abfd)->vma + obj_datasec(abfd)->size)
971 execp->a_bss = (data_pad > obj_bsssec(abfd)->size) ? 0 :
972 obj_bsssec(abfd)->size - data_pad;
974 execp->a_bss = obj_bsssec(abfd)->size;
978 adjust_n_magic (bfd *abfd, struct internal_exec *execp)
980 file_ptr pos = adata(abfd).exec_bytes_size;
985 obj_textsec(abfd)->filepos = pos;
986 if (!obj_textsec(abfd)->user_set_vma)
987 obj_textsec(abfd)->vma = vma;
989 vma = obj_textsec(abfd)->vma;
990 pos += obj_textsec(abfd)->size;
991 vma += obj_textsec(abfd)->size;
994 obj_datasec(abfd)->filepos = pos;
995 if (!obj_datasec(abfd)->user_set_vma)
996 obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
997 vma = obj_datasec(abfd)->vma;
999 /* Since BSS follows data immediately, see if it needs alignment. */
1000 vma += obj_datasec(abfd)->size;
1001 pad = align_power (vma, obj_bsssec(abfd)->alignment_power) - vma;
1002 obj_datasec(abfd)->size += pad;
1003 pos += obj_datasec(abfd)->size;
1006 if (!obj_bsssec(abfd)->user_set_vma)
1007 obj_bsssec(abfd)->vma = vma;
1009 vma = obj_bsssec(abfd)->vma;
1011 /* Fix up exec header. */
1012 execp->a_text = obj_textsec(abfd)->size;
1013 execp->a_data = obj_datasec(abfd)->size;
1014 execp->a_bss = obj_bsssec(abfd)->size;
1015 N_SET_MAGIC (*execp, NMAGIC);
1019 NAME (aout, adjust_sizes_and_vmas) (bfd *abfd,
1020 bfd_size_type *text_size,
1021 file_ptr * text_end ATTRIBUTE_UNUSED)
1023 struct internal_exec *execp = exec_hdr (abfd);
1025 if (! NAME (aout, make_sections) (abfd))
1028 if (adata(abfd).magic != undecided_magic)
1031 obj_textsec(abfd)->size =
1032 align_power(obj_textsec(abfd)->size,
1033 obj_textsec(abfd)->alignment_power);
1035 *text_size = obj_textsec (abfd)->size;
1036 /* Rule (heuristic) for when to pad to a new page. Note that there
1037 are (at least) two ways demand-paged (ZMAGIC) files have been
1038 handled. Most Berkeley-based systems start the text segment at
1039 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1040 segment right after the exec header; the latter is counted in the
1041 text segment size, and is paged in by the kernel with the rest of
1044 /* This perhaps isn't the right way to do this, but made it simpler for me
1045 to understand enough to implement it. Better would probably be to go
1046 right from BFD flags to alignment/positioning characteristics. But the
1047 old code was sloppy enough about handling the flags, and had enough
1048 other magic, that it was a little hard for me to understand. I think
1049 I understand it better now, but I haven't time to do the cleanup this
1052 if (abfd->flags & WP_TEXT)
1053 adata(abfd).magic = n_magic;
1055 adata(abfd).magic = o_magic;
1057 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1059 fprintf (stderr, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1061 switch (adata(abfd).magic) {
1062 case n_magic: str = "NMAGIC"; break;
1063 case o_magic: str = "OMAGIC"; break;
1064 case z_magic: str = "ZMAGIC"; break;
1069 obj_textsec(abfd)->vma, obj_textsec(abfd)->size,
1070 obj_textsec(abfd)->alignment_power,
1071 obj_datasec(abfd)->vma, obj_datasec(abfd)->size,
1072 obj_datasec(abfd)->alignment_power,
1073 obj_bsssec(abfd)->vma, obj_bsssec(abfd)->size,
1074 obj_bsssec(abfd)->alignment_power);
1078 switch (adata(abfd).magic)
1081 adjust_o_magic (abfd, execp);
1084 adjust_z_magic (abfd, execp);
1087 adjust_n_magic (abfd, execp);
1093 #ifdef BFD_AOUT_DEBUG
1094 fprintf (stderr, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1095 obj_textsec(abfd)->vma, obj_textsec(abfd)->size,
1096 obj_textsec(abfd)->filepos,
1097 obj_datasec(abfd)->vma, obj_datasec(abfd)->size,
1098 obj_datasec(abfd)->filepos,
1099 obj_bsssec(abfd)->vma, obj_bsssec(abfd)->size);
1105 /* Called by the BFD in response to a bfd_make_section request. */
1108 NAME (aout, new_section_hook) (bfd *abfd, asection *newsect)
1110 /* Align to double at least. */
1111 newsect->alignment_power = bfd_get_arch_info(abfd)->section_align_power;
1113 if (bfd_get_format (abfd) == bfd_object)
1115 if (obj_textsec (abfd) == NULL
1116 && !strcmp (newsect->name, ".text"))
1118 obj_textsec(abfd)= newsect;
1119 newsect->target_index = N_TEXT;
1121 else if (obj_datasec (abfd) == NULL
1122 && !strcmp (newsect->name, ".data"))
1124 obj_datasec (abfd) = newsect;
1125 newsect->target_index = N_DATA;
1127 else if (obj_bsssec (abfd) == NULL
1128 && !strcmp (newsect->name, ".bss"))
1130 obj_bsssec (abfd) = newsect;
1131 newsect->target_index = N_BSS;
1135 /* We allow more than three sections internally. */
1136 return _bfd_generic_new_section_hook (abfd, newsect);
1140 NAME (aout, set_section_contents) (bfd *abfd,
1142 const void * location,
1144 bfd_size_type count)
1147 bfd_size_type text_size;
1149 if (! abfd->output_has_begun)
1151 if (! NAME (aout, adjust_sizes_and_vmas) (abfd, & text_size, & text_end))
1155 if (section == obj_bsssec (abfd))
1157 bfd_set_error (bfd_error_no_contents);
1161 if (section != obj_textsec (abfd)
1162 && section != obj_datasec (abfd))
1164 (*_bfd_error_handler)
1165 ("%s: can not represent section `%s' in a.out object file format",
1166 bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
1167 bfd_set_error (bfd_error_nonrepresentable_section);
1173 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1174 || bfd_bwrite (location, count, abfd) != count)
1181 /* Read the external symbols from an a.out file. */
1184 aout_get_external_symbols (bfd *abfd)
1186 if (obj_aout_external_syms (abfd) == NULL)
1188 bfd_size_type count;
1189 struct external_nlist *syms;
1191 count = exec_hdr (abfd)->a_syms / EXTERNAL_NLIST_SIZE;
1194 if (! bfd_get_file_window (abfd, obj_sym_filepos (abfd),
1195 exec_hdr (abfd)->a_syms,
1196 &obj_aout_sym_window (abfd), TRUE))
1198 syms = (struct external_nlist *) obj_aout_sym_window (abfd).data;
1200 /* We allocate using malloc to make the values easy to free
1201 later on. If we put them on the objalloc it might not be
1202 possible to free them. */
1203 syms = bfd_malloc (count * EXTERNAL_NLIST_SIZE);
1204 if (syms == NULL && count != 0)
1207 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1208 || (bfd_bread (syms, exec_hdr (abfd)->a_syms, abfd)
1209 != exec_hdr (abfd)->a_syms))
1216 obj_aout_external_syms (abfd) = syms;
1217 obj_aout_external_sym_count (abfd) = count;
1220 if (obj_aout_external_strings (abfd) == NULL
1221 && exec_hdr (abfd)->a_syms != 0)
1223 unsigned char string_chars[BYTES_IN_LONG];
1224 bfd_size_type stringsize;
1227 /* Get the size of the strings. */
1228 if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
1229 || (bfd_bread ((void *) string_chars, (bfd_size_type) BYTES_IN_LONG,
1230 abfd) != BYTES_IN_LONG))
1232 stringsize = H_GET_32 (abfd, string_chars);
1235 if (! bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize,
1236 &obj_aout_string_window (abfd), TRUE))
1238 strings = (char *) obj_aout_string_window (abfd).data;
1240 strings = bfd_malloc (stringsize + 1);
1241 if (strings == NULL)
1244 /* Skip space for the string count in the buffer for convenience
1245 when using indexes. */
1246 if (bfd_bread (strings + 4, stringsize - 4, abfd) != stringsize - 4)
1252 /* Ensure that a zero index yields an empty string. */
1255 strings[stringsize - 1] = 0;
1257 obj_aout_external_strings (abfd) = strings;
1258 obj_aout_external_string_size (abfd) = stringsize;
1264 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1265 and symbol->value fields of CACHE_PTR will be set from the a.out
1266 nlist structure. This function is responsible for setting
1267 symbol->flags and symbol->section, and adjusting symbol->value. */
1270 translate_from_native_sym_flags (bfd *abfd,
1271 aout_symbol_type *cache_ptr)
1275 if (cache_ptr->type == N_FN)
1279 /* This is a debugging symbol. */
1280 cache_ptr->symbol.flags = BSF_DEBUGGING;
1282 /* Work out the symbol section. */
1283 switch (cache_ptr->type & N_TYPE)
1287 sec = obj_textsec (abfd);
1290 sec = obj_datasec (abfd);
1293 sec = obj_bsssec (abfd);
1297 sec = bfd_abs_section_ptr;
1301 cache_ptr->symbol.section = sec;
1302 cache_ptr->symbol.value -= sec->vma;
1307 /* Get the default visibility. This does not apply to all types, so
1308 we just hold it in a local variable to use if wanted. */
1309 if ((cache_ptr->type & N_EXT) == 0)
1310 visible = BSF_LOCAL;
1312 visible = BSF_GLOBAL;
1314 switch (cache_ptr->type)
1317 case N_ABS: case N_ABS | N_EXT:
1318 cache_ptr->symbol.section = bfd_abs_section_ptr;
1319 cache_ptr->symbol.flags = visible;
1322 case N_UNDF | N_EXT:
1323 if (cache_ptr->symbol.value != 0)
1325 /* This is a common symbol. */
1326 cache_ptr->symbol.flags = BSF_GLOBAL;
1327 cache_ptr->symbol.section = bfd_com_section_ptr;
1331 cache_ptr->symbol.flags = 0;
1332 cache_ptr->symbol.section = bfd_und_section_ptr;
1336 case N_TEXT: case N_TEXT | N_EXT:
1337 cache_ptr->symbol.section = obj_textsec (abfd);
1338 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1339 cache_ptr->symbol.flags = visible;
1342 case N_DATA: case N_DATA | N_EXT:
1343 cache_ptr->symbol.section = obj_datasec (abfd);
1344 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1345 cache_ptr->symbol.flags = visible;
1348 case N_BSS: case N_BSS | N_EXT:
1349 cache_ptr->symbol.section = obj_bsssec (abfd);
1350 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1351 cache_ptr->symbol.flags = visible;
1358 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1361 translate_to_native_sym_flags (bfd *abfd,
1363 struct external_nlist *sym_pointer)
1365 bfd_vma value = cache_ptr->value;
1369 /* Mask out any existing type bits in case copying from one section
1371 sym_pointer->e_type[0] &= ~N_TYPE;
1373 sec = bfd_get_section (cache_ptr);
1378 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1380 (*_bfd_error_handler)
1381 ("%B: can not represent section for symbol `%s' in a.out object file format",
1382 abfd, cache_ptr->name != NULL ? cache_ptr->name : "*unknown*");
1383 bfd_set_error (bfd_error_nonrepresentable_section);
1387 if (sec->output_section != NULL)
1389 off = sec->output_offset;
1390 sec = sec->output_section;
1393 if (bfd_is_abs_section (sec))
1394 sym_pointer->e_type[0] |= N_ABS;
1395 else if (sec == obj_textsec (abfd))
1396 sym_pointer->e_type[0] |= N_TEXT;
1397 else if (sec == obj_datasec (abfd))
1398 sym_pointer->e_type[0] |= N_DATA;
1399 else if (sec == obj_bsssec (abfd))
1400 sym_pointer->e_type[0] |= N_BSS;
1401 else if (bfd_is_und_section (sec))
1402 sym_pointer->e_type[0] = N_UNDF | N_EXT;
1403 else if (bfd_is_com_section (sec))
1404 sym_pointer->e_type[0] = N_UNDF | N_EXT;
1407 (*_bfd_error_handler)
1408 ("%B: can not represent section `%A' in a.out object file format",
1410 bfd_set_error (bfd_error_nonrepresentable_section);
1414 /* Turn the symbol from section relative to absolute again */
1415 value += sec->vma + off;
1417 if ((cache_ptr->flags & BSF_DEBUGGING) != 0)
1418 sym_pointer->e_type[0] = ((aout_symbol_type *) cache_ptr)->type;
1419 else if ((cache_ptr->flags & BSF_GLOBAL) != 0)
1420 sym_pointer->e_type[0] |= N_EXT;
1422 PUT_WORD(abfd, value, sym_pointer->e_value);
1427 /* Native-level interface to symbols. */
1430 NAME (aout, make_empty_symbol) (bfd *abfd)
1432 bfd_size_type amt = sizeof (aout_symbol_type);
1433 aout_symbol_type *new_symbol_type = bfd_zalloc (abfd, amt);
1435 if (!new_symbol_type)
1437 new_symbol_type->symbol.the_bfd = abfd;
1439 return &new_symbol_type->symbol;
1442 /* Translate a set of internal symbols into external symbols. */
1445 NAME (aout, translate_symbol_table) (bfd *abfd,
1446 aout_symbol_type *in,
1447 struct external_nlist *ext,
1448 bfd_size_type count,
1450 bfd_size_type strsize,
1451 bfd_boolean dynamic)
1453 struct external_nlist *ext_end;
1455 ext_end = ext + count;
1456 for (; ext < ext_end; ext++, in++)
1460 x = GET_WORD (abfd, ext->e_strx);
1461 in->symbol.the_bfd = abfd;
1463 /* For the normal symbols, the zero index points at the number
1464 of bytes in the string table but is to be interpreted as the
1465 null string. For the dynamic symbols, the number of bytes in
1466 the string table is stored in the __DYNAMIC structure and the
1467 zero index points at an actual string. */
1468 if (x == 0 && ! dynamic)
1469 in->symbol.name = "";
1470 else if (x < strsize)
1471 in->symbol.name = str + x;
1475 in->symbol.value = GET_SWORD (abfd, ext->e_value);
1476 /* TODO: is 0 a safe value here? */
1479 in->type = H_GET_8 (abfd, ext->e_type);
1480 in->symbol.udata.p = NULL;
1482 if (! translate_from_native_sym_flags (abfd, in))
1486 in->symbol.flags |= BSF_DYNAMIC;
1492 /* We read the symbols into a buffer, which is discarded when this
1493 function exits. We read the strings into a buffer large enough to
1494 hold them all plus all the cached symbol entries. */
1497 NAME (aout, slurp_symbol_table) (bfd *abfd)
1499 struct external_nlist *old_external_syms;
1500 aout_symbol_type *cached;
1501 bfd_size_type cached_size;
1503 /* If there's no work to be done, don't do any. */
1504 if (obj_aout_symbols (abfd) != NULL)
1507 old_external_syms = obj_aout_external_syms (abfd);
1509 if (! aout_get_external_symbols (abfd))
1512 cached_size = obj_aout_external_sym_count (abfd);
1513 cached_size *= sizeof (aout_symbol_type);
1514 cached = bfd_zmalloc (cached_size);
1515 if (cached == NULL && cached_size != 0)
1518 /* Convert from external symbol information to internal. */
1519 if (! (NAME (aout, translate_symbol_table)
1521 obj_aout_external_syms (abfd),
1522 obj_aout_external_sym_count (abfd),
1523 obj_aout_external_strings (abfd),
1524 obj_aout_external_string_size (abfd),
1531 bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd);
1533 obj_aout_symbols (abfd) = cached;
1535 /* It is very likely that anybody who calls this function will not
1536 want the external symbol information, so if it was allocated
1537 because of our call to aout_get_external_symbols, we free it up
1538 right away to save space. */
1539 if (old_external_syms == NULL
1540 && obj_aout_external_syms (abfd) != NULL)
1543 bfd_free_window (&obj_aout_sym_window (abfd));
1545 free (obj_aout_external_syms (abfd));
1547 obj_aout_external_syms (abfd) = NULL;
1553 /* We use a hash table when writing out symbols so that we only write
1554 out a particular string once. This helps particularly when the
1555 linker writes out stabs debugging entries, because each different
1556 contributing object file tends to have many duplicate stabs
1559 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1560 if BFD_TRADITIONAL_FORMAT is set. */
1562 /* Get the index of a string in a strtab, adding it if it is not
1565 static INLINE bfd_size_type
1566 add_to_stringtab (bfd *abfd,
1567 struct bfd_strtab_hash *tab,
1572 bfd_size_type str_index;
1574 /* An index of 0 always means the empty string. */
1575 if (str == 0 || *str == '\0')
1578 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1579 doesn't understand a hashed string table. */
1581 if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1584 str_index = _bfd_stringtab_add (tab, str, hash, copy);
1586 if (str_index != (bfd_size_type) -1)
1587 /* Add BYTES_IN_LONG to the return value to account for the
1588 space taken up by the string table size. */
1589 str_index += BYTES_IN_LONG;
1594 /* Write out a strtab. ABFD is already at the right location in the
1598 emit_stringtab (bfd *abfd, struct bfd_strtab_hash *tab)
1600 bfd_byte buffer[BYTES_IN_LONG];
1602 /* The string table starts with the size. */
1603 H_PUT_32 (abfd, _bfd_stringtab_size (tab) + BYTES_IN_LONG, buffer);
1604 if (bfd_bwrite ((void *) buffer, (bfd_size_type) BYTES_IN_LONG, abfd)
1608 return _bfd_stringtab_emit (abfd, tab);
1612 NAME (aout, write_syms) (bfd *abfd)
1614 unsigned int count ;
1615 asymbol **generic = bfd_get_outsymbols (abfd);
1616 struct bfd_strtab_hash *strtab;
1618 strtab = _bfd_stringtab_init ();
1622 for (count = 0; count < bfd_get_symcount (abfd); count++)
1624 asymbol *g = generic[count];
1626 struct external_nlist nsp;
1628 PUT_WORD (abfd, 0, nsp.e_unused);
1630 indx = add_to_stringtab (abfd, strtab, g->name, FALSE);
1631 if (indx == (bfd_size_type) -1)
1633 PUT_WORD (abfd, indx, nsp.e_strx);
1635 if (bfd_asymbol_flavour(g) == abfd->xvec->flavour)
1636 H_PUT_8 (abfd, aout_symbol(g)->type, nsp.e_type);
1638 H_PUT_8 (abfd, 0, nsp.e_type);
1640 if (! translate_to_native_sym_flags (abfd, g, &nsp))
1643 H_PUT_8 (abfd, 0, nsp.e_ovly);
1645 if (bfd_bwrite ((void *)&nsp, (bfd_size_type) EXTERNAL_NLIST_SIZE, abfd)
1646 != EXTERNAL_NLIST_SIZE)
1649 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1650 here, at the end. */
1654 if (! emit_stringtab (abfd, strtab))
1657 _bfd_stringtab_free (strtab);
1662 _bfd_stringtab_free (strtab);
1668 NAME (aout, canonicalize_symtab) (bfd *abfd, asymbol **location)
1670 unsigned int counter = 0;
1671 aout_symbol_type *symbase;
1673 if (!NAME (aout, slurp_symbol_table) (abfd))
1676 for (symbase = obj_aout_symbols (abfd); counter++ < bfd_get_symcount (abfd);)
1677 *(location++) = (asymbol *)(symbase++);
1679 return bfd_get_symcount (abfd);
1683 /* Output extended relocation information to a file in target byte order. */
1686 pdp11_aout_swap_reloc_out (bfd *abfd, arelent *g, bfd_byte *natptr)
1692 asymbol *sym = *(g->sym_ptr_ptr);
1693 asection *output_section = sym->section->output_section;
1696 fprintf (stderr, "BFD: can't do this reloc addend stuff\n");
1698 r_pcrel = g->howto->pc_relative;
1700 if (bfd_is_abs_section (output_section))
1702 else if (output_section == obj_textsec (abfd))
1704 else if (output_section == obj_datasec (abfd))
1706 else if (output_section == obj_bsssec (abfd))
1708 else if (bfd_is_und_section (output_section))
1710 else if (bfd_is_com_section (output_section))
1715 BFD_ASSERT (r_type != -1);
1720 r_index = (*(g->sym_ptr_ptr))->KEEPIT;
1722 reloc_entry = r_index << 4 | r_type | r_pcrel;
1724 PUT_WORD (abfd, reloc_entry, natptr);
1727 /* BFD deals internally with all things based from the section they're
1728 in. so, something in 10 bytes into a text section with a base of
1729 50 would have a symbol (.text+10) and know .text vma was 50.
1731 Aout keeps all it's symbols based from zero, so the symbol would
1732 contain 60. This macro subs the base of each section from the value
1733 to give the true offset from the section */
1736 #define MOVE_ADDRESS(ad) \
1739 /* Undefined symbol. */ \
1740 cache_ptr->sym_ptr_ptr = symbols + r_index; \
1741 cache_ptr->addend = ad; \
1745 /* Defined, section relative. replace symbol with pointer to \
1746 symbol which points to section. */ \
1750 case N_TEXT | N_EXT: \
1751 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
1752 cache_ptr->addend = ad - su->textsec->vma; \
1755 case N_DATA | N_EXT: \
1756 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
1757 cache_ptr->addend = ad - su->datasec->vma; \
1760 case N_BSS | N_EXT: \
1761 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
1762 cache_ptr->addend = ad - su->bsssec->vma; \
1766 case N_ABS | N_EXT: \
1767 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1768 cache_ptr->addend = ad; \
1774 pdp11_aout_swap_reloc_in (bfd * abfd,
1776 arelent * cache_ptr,
1777 bfd_size_type offset,
1779 bfd_size_type symcount)
1781 struct aoutdata *su = &(abfd->tdata.aout_data->a);
1782 unsigned int r_index;
1787 reloc_entry = GET_WORD (abfd, (void *) bytes);
1789 r_pcrel = reloc_entry & RELFLG;
1791 cache_ptr->address = offset;
1792 cache_ptr->howto = howto_table_pdp11 + (r_pcrel ? 1 : 0);
1794 if ((reloc_entry & RTYPE) == RABS)
1797 r_index = RINDEX (reloc_entry);
1799 /* r_extern reflects whether the symbol the reloc is against is
1801 r_extern = (reloc_entry & RTYPE) == REXT;
1803 if (r_extern && r_index > symcount)
1805 /* We could arrange to return an error, but it might be useful
1806 to see the file even if it is bad. */
1814 /* Read and swap the relocs for a section. */
1817 NAME (aout, slurp_reloc_table) (bfd *abfd, sec_ptr asect, asymbol **symbols)
1820 bfd_size_type count;
1821 bfd_size_type reloc_size;
1823 arelent *reloc_cache;
1825 unsigned int counter = 0;
1828 if (asect->relocation)
1831 if (asect->flags & SEC_CONSTRUCTOR)
1834 if (asect == obj_datasec (abfd))
1835 reloc_size = exec_hdr(abfd)->a_drsize;
1836 else if (asect == obj_textsec (abfd))
1837 reloc_size = exec_hdr(abfd)->a_trsize;
1838 else if (asect == obj_bsssec (abfd))
1842 bfd_set_error (bfd_error_invalid_operation);
1846 if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
1849 each_size = obj_reloc_entry_size (abfd);
1851 relocs = bfd_malloc (reloc_size);
1852 if (relocs == NULL && reloc_size != 0)
1855 if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
1861 count = reloc_size / each_size;
1863 /* Count the number of NON-ZERO relocs, this is the count we want. */
1865 unsigned int real_count = 0;
1867 for (counter = 0; counter < count; counter++)
1871 x = GET_WORD (abfd, (char *) relocs + each_size * counter);
1879 reloc_cache = bfd_zmalloc (count * sizeof (arelent));
1880 if (reloc_cache == NULL && count != 0)
1883 cache_ptr = reloc_cache;
1888 counter++, rptr += RELOC_SIZE, cache_ptr++)
1890 while (GET_WORD (abfd, (void *) rptr) == 0)
1893 if ((char *) rptr >= (char *) relocs + reloc_size)
1897 pdp11_aout_swap_reloc_in (abfd, rptr, cache_ptr,
1898 (bfd_size_type) ((char *) rptr - (char *) relocs),
1900 (bfd_size_type) bfd_get_symcount (abfd));
1903 /* Just in case, if rptr >= relocs + reloc_size should happen
1905 BFD_ASSERT (counter == count);
1909 asect->relocation = reloc_cache;
1910 asect->reloc_count = cache_ptr - reloc_cache;
1915 /* Write out a relocation section into an object file. */
1918 NAME (aout, squirt_out_relocs) (bfd *abfd, asection *section)
1921 unsigned char *native;
1922 unsigned int count = section->reloc_count;
1923 bfd_size_type natsize;
1925 natsize = section->size;
1926 native = bfd_zalloc (abfd, natsize);
1930 generic = section->orelocation;
1931 if (generic != NULL)
1937 r = native + (*generic)->address;
1938 pdp11_aout_swap_reloc_out (abfd, *generic, r);
1944 if (bfd_bwrite ((void *) native, natsize, abfd) != natsize)
1946 bfd_release (abfd, native);
1950 bfd_release (abfd, native);
1954 /* This is stupid. This function should be a boolean predicate. */
1957 NAME (aout, canonicalize_reloc) (bfd *abfd,
1962 arelent *tblptr = section->relocation;
1965 if (section == obj_bsssec (abfd))
1971 if (!(tblptr || NAME (aout, slurp_reloc_table)(abfd, section, symbols)))
1974 if (section->flags & SEC_CONSTRUCTOR)
1976 arelent_chain *chain = section->constructor_chain;
1978 for (count = 0; count < section->reloc_count; count ++)
1980 *relptr ++ = &chain->relent;
1981 chain = chain->next;
1986 tblptr = section->relocation;
1988 for (count = 0; count++ < section->reloc_count;)
1989 *relptr++ = tblptr++;
1994 return section->reloc_count;
1998 NAME (aout, get_reloc_upper_bound) (bfd *abfd, sec_ptr asect)
2000 if (bfd_get_format (abfd) != bfd_object)
2002 bfd_set_error (bfd_error_invalid_operation);
2006 if (asect->flags & SEC_CONSTRUCTOR)
2007 return (sizeof (arelent *) * (asect->reloc_count + 1));
2009 if (asect == obj_datasec (abfd))
2010 return (sizeof (arelent *)
2011 * ((exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd))
2014 if (asect == obj_textsec (abfd))
2015 return (sizeof (arelent *)
2016 * ((exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd))
2019 /* TODO: why are there two if statements for obj_bsssec()? */
2021 if (asect == obj_bsssec (abfd))
2022 return sizeof (arelent *);
2024 if (asect == obj_bsssec (abfd))
2027 bfd_set_error (bfd_error_invalid_operation);
2033 NAME (aout, get_symtab_upper_bound) (bfd *abfd)
2035 if (!NAME (aout, slurp_symbol_table) (abfd))
2038 return (bfd_get_symcount (abfd) + 1) * (sizeof (aout_symbol_type *));
2042 NAME (aout, get_lineno) (bfd * abfd ATTRIBUTE_UNUSED,
2043 asymbol * symbol ATTRIBUTE_UNUSED)
2049 NAME (aout, get_symbol_info) (bfd * abfd ATTRIBUTE_UNUSED,
2053 bfd_symbol_info (symbol, ret);
2055 if (ret->type == '?')
2057 int type_code = aout_symbol(symbol)->type & 0xff;
2058 const char *stab_name = bfd_get_stab_name (type_code);
2059 static char buf[10];
2061 if (stab_name == NULL)
2063 sprintf(buf, "(%d)", type_code);
2067 ret->stab_type = type_code;
2068 ret->stab_other = (unsigned) (aout_symbol(symbol)->other & 0xff);
2069 ret->stab_desc = (unsigned) (aout_symbol(symbol)->desc & 0xffff);
2070 ret->stab_name = stab_name;
2075 NAME (aout, print_symbol) (bfd * abfd,
2078 bfd_print_symbol_type how)
2080 FILE *file = (FILE *) afile;
2084 case bfd_print_symbol_name:
2086 fprintf(file,"%s", symbol->name);
2088 case bfd_print_symbol_more:
2089 fprintf(file,"%4x %2x %2x",
2090 (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2091 (unsigned) (aout_symbol (symbol)->other & 0xff),
2092 (unsigned) (aout_symbol (symbol)->type));
2094 case bfd_print_symbol_all:
2096 const char *section_name = symbol->section->name;
2098 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2100 fprintf (file," %-5s %04x %02x %02x",
2102 (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2103 (unsigned) (aout_symbol (symbol)->other & 0xff),
2104 (unsigned) (aout_symbol (symbol)->type & 0xff));
2106 fprintf(file," %s", symbol->name);
2112 /* If we don't have to allocate more than 1MB to hold the generic
2113 symbols, we use the generic minisymbol method: it's faster, since
2114 it only translates the symbols once, not multiple times. */
2115 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2117 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2118 symbols. The minisymbol_to_symbol function translates these into
2119 BFD asymbol structures. */
2122 NAME (aout, read_minisymbols) (bfd *abfd,
2123 bfd_boolean dynamic,
2125 unsigned int *sizep)
2128 /* We could handle the dynamic symbols here as well, but it's
2129 easier to hand them off. */
2130 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2132 if (! aout_get_external_symbols (abfd))
2135 if (obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2136 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2138 *minisymsp = (void *) obj_aout_external_syms (abfd);
2140 /* By passing the external symbols back from this routine, we are
2141 giving up control over the memory block. Clear
2142 obj_aout_external_syms, so that we do not try to free it
2144 obj_aout_external_syms (abfd) = NULL;
2146 *sizep = EXTERNAL_NLIST_SIZE;
2147 return obj_aout_external_sym_count (abfd);
2150 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2151 unmodified a.out symbol. The SYM argument is a structure returned
2152 by bfd_make_empty_symbol, which we fill in here. */
2155 NAME (aout, minisymbol_to_symbol) (bfd *abfd,
2156 bfd_boolean dynamic,
2157 const void * minisym,
2161 || obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2162 return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
2164 memset (sym, 0, sizeof (aout_symbol_type));
2166 /* We call translate_symbol_table to translate a single symbol. */
2167 if (! (NAME (aout, translate_symbol_table)
2169 (aout_symbol_type *) sym,
2170 (struct external_nlist *) minisym,
2172 obj_aout_external_strings (abfd),
2173 obj_aout_external_string_size (abfd),
2180 /* Provided a BFD, a section and an offset into the section, calculate
2181 and return the name of the source file and the line nearest to the
2185 NAME (aout, find_nearest_line) (bfd *abfd,
2189 const char **filename_ptr,
2190 const char **functionname_ptr,
2191 unsigned int *line_ptr)
2193 /* Run down the file looking for the filename, function and linenumber. */
2195 const char *directory_name = NULL;
2196 const char *main_file_name = NULL;
2197 const char *current_file_name = NULL;
2198 const char *line_file_name = NULL; /* Value of current_file_name at line number. */
2199 bfd_vma low_line_vma = 0;
2200 bfd_vma low_func_vma = 0;
2202 size_t filelen, funclen;
2205 *filename_ptr = abfd->filename;
2206 *functionname_ptr = 0;
2209 if (symbols != NULL)
2211 for (p = symbols; *p; p++)
2213 aout_symbol_type *q = (aout_symbol_type *)(*p);
2218 /* If this looks like a file name symbol, and it comes after
2219 the line number we have found so far, but before the
2220 offset, then we have probably not found the right line
2222 if (q->symbol.value <= offset
2223 && ((q->symbol.value > low_line_vma
2224 && (line_file_name != NULL
2226 || (q->symbol.value > low_func_vma
2229 const char * symname;
2231 symname = q->symbol.name;
2232 if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
2234 if (q->symbol.value > low_line_vma)
2237 line_file_name = NULL;
2239 if (q->symbol.value > low_func_vma)
2246 /* If this symbol is less than the offset, but greater than
2247 the line number we have found so far, then we have not
2248 found the right line number. */
2249 if (q->symbol.value <= offset)
2251 if (q->symbol.value > low_line_vma)
2254 line_file_name = NULL;
2256 if (q->symbol.value > low_func_vma)
2260 main_file_name = current_file_name = q->symbol.name;
2261 /* Look ahead to next symbol to check if that too is an N_SO. */
2265 q = (aout_symbol_type *)(*p);
2266 if (q->type != (int) N_SO)
2269 /* Found a second N_SO First is directory; second is filename. */
2270 directory_name = current_file_name;
2271 main_file_name = current_file_name = q->symbol.name;
2272 if (obj_textsec(abfd) != section)
2276 current_file_name = q->symbol.name;
2282 /* We'll keep this if it resolves nearer than the one we have
2284 if (q->symbol.value >= low_line_vma
2285 && q->symbol.value <= offset)
2287 *line_ptr = q->desc;
2288 low_line_vma = q->symbol.value;
2289 line_file_name = current_file_name;
2295 /* We'll keep this if it is nearer than the one we have already. */
2296 if (q->symbol.value >= low_func_vma &&
2297 q->symbol.value <= offset)
2299 low_func_vma = q->symbol.value;
2300 func = (asymbol *) q;
2302 else if (q->symbol.value > offset)
2312 main_file_name = line_file_name;
2314 if (main_file_name == NULL
2315 || main_file_name[0] == '/'
2316 || directory_name == NULL)
2319 filelen = strlen (directory_name) + strlen (main_file_name);
2323 funclen = strlen (bfd_asymbol_name (func));
2325 if (adata (abfd).line_buf != NULL)
2326 free (adata (abfd).line_buf);
2327 if (filelen + funclen == 0)
2328 adata (abfd).line_buf = buf = NULL;
2331 buf = bfd_malloc ((bfd_size_type) filelen + funclen + 3);
2332 adata (abfd).line_buf = buf;
2337 if (main_file_name != NULL)
2339 if (main_file_name[0] == '/' || directory_name == NULL)
2340 *filename_ptr = main_file_name;
2343 sprintf (buf, "%s%s", directory_name, main_file_name);
2344 *filename_ptr = buf;
2351 const char *function = func->name;
2354 /* The caller expects a symbol name. We actually have a
2355 function name, without the leading underscore. Put the
2356 underscore back in, so that the caller gets a symbol name. */
2357 if (bfd_get_symbol_leading_char (abfd) == '\0')
2358 strcpy (buf, function);
2361 buf[0] = bfd_get_symbol_leading_char (abfd);
2362 strcpy (buf + 1, function);
2365 /* Have to remove : stuff. */
2366 colon = strchr (buf, ':');
2369 *functionname_ptr = buf;
2376 NAME (aout, sizeof_headers) (bfd *abfd,
2377 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2379 return adata (abfd).exec_bytes_size;
2382 /* Free all information we have cached for this BFD. We can always
2383 read it again later if we need it. */
2386 NAME (aout, bfd_free_cached_info) (bfd *abfd)
2390 if (bfd_get_format (abfd) != bfd_object)
2393 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2394 BFCI_FREE (obj_aout_symbols (abfd));
2397 obj_aout_external_syms (abfd) = 0;
2398 bfd_free_window (&obj_aout_sym_window (abfd));
2399 bfd_free_window (&obj_aout_string_window (abfd));
2400 obj_aout_external_strings (abfd) = 0;
2402 BFCI_FREE (obj_aout_external_syms (abfd));
2403 BFCI_FREE (obj_aout_external_strings (abfd));
2405 for (o = abfd->sections; o != NULL; o = o->next)
2406 BFCI_FREE (o->relocation);
2412 /* Routine to create an entry in an a.out link hash table. */
2414 struct bfd_hash_entry *
2415 NAME (aout, link_hash_newfunc) (struct bfd_hash_entry *entry,
2416 struct bfd_hash_table *table,
2419 struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry;
2421 /* Allocate the structure if it has not already been allocated by a
2424 ret = bfd_hash_allocate (table, sizeof (* ret));
2428 /* Call the allocation method of the superclass. */
2429 ret = (struct aout_link_hash_entry *)
2430 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
2433 /* Set local fields. */
2434 ret->written = FALSE;
2438 return (struct bfd_hash_entry *) ret;
2441 /* Initialize an a.out link hash table. */
2444 NAME (aout, link_hash_table_init) (struct aout_link_hash_table *table,
2446 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
2447 struct bfd_hash_table *,
2449 unsigned int entsize)
2451 return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
2454 /* Create an a.out link hash table. */
2456 struct bfd_link_hash_table *
2457 NAME (aout, link_hash_table_create) (bfd *abfd)
2459 struct aout_link_hash_table *ret;
2460 bfd_size_type amt = sizeof (struct aout_link_hash_table);
2462 ret = bfd_alloc (abfd, amt);
2465 if (! NAME (aout, link_hash_table_init) (ret, abfd,
2466 NAME (aout, link_hash_newfunc),
2467 sizeof (struct aout_link_hash_entry)))
2475 /* Free up the internal symbols read from an a.out file. */
2478 aout_link_free_symbols (bfd *abfd)
2480 if (obj_aout_external_syms (abfd) != NULL)
2483 bfd_free_window (&obj_aout_sym_window (abfd));
2485 free ((void *) obj_aout_external_syms (abfd));
2487 obj_aout_external_syms (abfd) = NULL;
2490 if (obj_aout_external_strings (abfd) != NULL)
2493 bfd_free_window (&obj_aout_string_window (abfd));
2495 free ((void *) obj_aout_external_strings (abfd));
2497 obj_aout_external_strings (abfd) = NULL;
2502 /* Given an a.out BFD, add symbols to the global hash table as
2506 NAME (aout, link_add_symbols) (bfd *abfd, struct bfd_link_info *info)
2508 switch (bfd_get_format (abfd))
2511 return aout_link_add_object_symbols (abfd, info);
2513 return _bfd_generic_link_add_archive_symbols
2514 (abfd, info, aout_link_check_archive_element);
2516 bfd_set_error (bfd_error_wrong_format);
2521 /* Add symbols from an a.out object file. */
2524 aout_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
2526 if (! aout_get_external_symbols (abfd))
2528 if (! aout_link_add_symbols (abfd, info))
2530 if (! info->keep_memory)
2532 if (! aout_link_free_symbols (abfd))
2538 /* Look through the internal symbols to see if this object file should
2539 be included in the link. We should include this object file if it
2540 defines any symbols which are currently undefined. If this object
2541 file defines a common symbol, then we may adjust the size of the
2542 known symbol but we do not include the object file in the link
2543 (unless there is some other reason to include it). */
2546 aout_link_check_ar_symbols (bfd *abfd,
2547 struct bfd_link_info *info,
2548 bfd_boolean *pneeded,
2551 struct external_nlist *p;
2552 struct external_nlist *pend;
2557 /* Look through all the symbols. */
2558 p = obj_aout_external_syms (abfd);
2559 pend = p + obj_aout_external_sym_count (abfd);
2560 strings = obj_aout_external_strings (abfd);
2561 for (; p < pend; p++)
2563 int type = H_GET_8 (abfd, p->e_type);
2565 struct bfd_link_hash_entry *h;
2567 /* Ignore symbols that are not externally visible. This is an
2568 optimization only, as we check the type more thoroughly
2570 if ((type & N_EXT) == 0
2574 name = strings + GET_WORD (abfd, p->e_strx);
2575 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
2577 /* We are only interested in symbols that are currently
2578 undefined or common. */
2580 || (h->type != bfd_link_hash_undefined
2581 && h->type != bfd_link_hash_common))
2584 if (type == (N_TEXT | N_EXT)
2585 || type == (N_DATA | N_EXT)
2586 || type == (N_BSS | N_EXT)
2587 || type == (N_ABS | N_EXT))
2589 /* This object file defines this symbol. We must link it
2590 in. This is true regardless of whether the current
2591 definition of the symbol is undefined or common. If the
2592 current definition is common, we have a case in which we
2593 have already seen an object file including
2595 and this object file from the archive includes
2597 In such a case we must include this object file.
2599 FIXME: The SunOS 4.1.3 linker will pull in the archive
2600 element if the symbol is defined in the .data section,
2601 but not if it is defined in the .text section. That
2602 seems a bit crazy to me, and I haven't implemented it.
2603 However, it might be correct. */
2604 if (! (*info->callbacks->add_archive_element)
2605 (info, abfd, name, subsbfd))
2611 if (type == (N_UNDF | N_EXT))
2615 value = GET_WORD (abfd, p->e_value);
2618 /* This symbol is common in the object from the archive
2620 if (h->type == bfd_link_hash_undefined)
2625 symbfd = h->u.undef.abfd;
2628 /* This symbol was created as undefined from
2629 outside BFD. We assume that we should link
2630 in the object file. This is done for the -u
2631 option in the linker. */
2632 if (! (*info->callbacks->add_archive_element)
2633 (info, abfd, name, subsbfd))
2638 /* Turn the current link symbol into a common
2639 symbol. It is already on the undefs list. */
2640 h->type = bfd_link_hash_common;
2641 h->u.c.p = bfd_hash_allocate (&info->hash->table,
2642 sizeof (struct bfd_link_hash_common_entry));
2643 if (h->u.c.p == NULL)
2646 h->u.c.size = value;
2648 /* FIXME: This isn't quite right. The maximum
2649 alignment of a common symbol should be set by the
2650 architecture of the output file, not of the input
2652 power = bfd_log2 (value);
2653 if (power > bfd_get_arch_info (abfd)->section_align_power)
2654 power = bfd_get_arch_info (abfd)->section_align_power;
2655 h->u.c.p->alignment_power = power;
2657 h->u.c.p->section = bfd_make_section_old_way (symbfd,
2662 /* Adjust the size of the common symbol if
2664 if (value > h->u.c.size)
2665 h->u.c.size = value;
2671 /* We do not need this object file. */
2675 /* Check a single archive element to see if we need to include it in
2676 the link. *PNEEDED is set according to whether this element is
2677 needed in the link or not. This is called from
2678 _bfd_generic_link_add_archive_symbols. */
2681 aout_link_check_archive_element (bfd *abfd,
2682 struct bfd_link_info *info,
2683 bfd_boolean *pneeded)
2685 bfd *subsbfd = NULL;
2687 if (! aout_get_external_symbols (abfd))
2690 if (! aout_link_check_ar_symbols (abfd, info, pneeded, &subsbfd))
2695 /* Potentially, the add_archive_element hook may have set a
2696 substitute BFD for us. */
2697 if (subsbfd && ! aout_get_external_symbols (subsbfd))
2699 if (! aout_link_add_symbols (subsbfd ? subsbfd : abfd, info))
2703 if (! info->keep_memory || ! *pneeded)
2705 if (! aout_link_free_symbols (abfd))
2712 /* Add all symbols from an object file to the hash table. */
2715 aout_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
2717 bfd_boolean (*add_one_symbol)
2718 (struct bfd_link_info *, bfd *, const char *, flagword, asection *,
2719 bfd_vma, const char *, bfd_boolean, bfd_boolean,
2720 struct bfd_link_hash_entry **);
2721 struct external_nlist *syms;
2722 bfd_size_type sym_count;
2725 struct aout_link_hash_entry **sym_hash;
2726 struct external_nlist *p;
2727 struct external_nlist *pend;
2729 syms = obj_aout_external_syms (abfd);
2730 sym_count = obj_aout_external_sym_count (abfd);
2731 strings = obj_aout_external_strings (abfd);
2732 if (info->keep_memory)
2737 if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
2739 if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
2740 (abfd, info, &syms, &sym_count, &strings)))
2744 /* We keep a list of the linker hash table entries that correspond
2745 to particular symbols. We could just look them up in the hash
2746 table, but keeping the list is more efficient. Perhaps this
2747 should be conditional on info->keep_memory. */
2748 sym_hash = bfd_alloc (abfd,
2749 sym_count * sizeof (struct aout_link_hash_entry *));
2750 if (sym_hash == NULL && sym_count != 0)
2752 obj_aout_sym_hashes (abfd) = sym_hash;
2754 add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
2755 if (add_one_symbol == NULL)
2756 add_one_symbol = _bfd_generic_link_add_one_symbol;
2759 pend = p + sym_count;
2760 for (; p < pend; p++, sym_hash++)
2771 type = H_GET_8 (abfd, p->e_type);
2773 name = strings + GET_WORD (abfd, p->e_strx);
2774 value = GET_WORD (abfd, p->e_value);
2789 /* Ignore symbols that are not externally visible. */
2792 case N_UNDF | N_EXT:
2795 section = bfd_und_section_ptr;
2799 section = bfd_com_section_ptr;
2802 section = bfd_abs_section_ptr;
2804 case N_TEXT | N_EXT:
2805 section = obj_textsec (abfd);
2806 value -= bfd_get_section_vma (abfd, section);
2808 case N_DATA | N_EXT:
2809 /* Treat N_SETV symbols as N_DATA symbol; see comment in
2810 translate_from_native_sym_flags. */
2811 section = obj_datasec (abfd);
2812 value -= bfd_get_section_vma (abfd, section);
2815 section = obj_bsssec (abfd);
2816 value -= bfd_get_section_vma (abfd, section);
2820 if (! ((*add_one_symbol)
2821 (info, abfd, name, flags, section, value, string, copy, FALSE,
2822 (struct bfd_link_hash_entry **) sym_hash)))
2825 /* Restrict the maximum alignment of a common symbol based on
2826 the architecture, since a.out has no way to represent
2827 alignment requirements of a section in a .o file. FIXME:
2828 This isn't quite right: it should use the architecture of the
2829 output file, not the input files. */
2830 if ((*sym_hash)->root.type == bfd_link_hash_common
2831 && ((*sym_hash)->root.u.c.p->alignment_power >
2832 bfd_get_arch_info (abfd)->section_align_power))
2833 (*sym_hash)->root.u.c.p->alignment_power =
2834 bfd_get_arch_info (abfd)->section_align_power;
2836 /* If this is a set symbol, and we are not building sets, then
2837 it is possible for the hash entry to not have been set. In
2838 such a case, treat the symbol as not globally defined. */
2839 if ((*sym_hash)->root.type == bfd_link_hash_new)
2841 BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
2849 /* Look up an entry in an the header file hash table. */
2851 #define aout_link_includes_lookup(table, string, create, copy) \
2852 ((struct aout_link_includes_entry *) \
2853 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
2855 /* The function to create a new entry in the header file hash table. */
2857 static struct bfd_hash_entry *
2858 aout_link_includes_newfunc (struct bfd_hash_entry *entry,
2859 struct bfd_hash_table *table,
2862 struct aout_link_includes_entry * ret =
2863 (struct aout_link_includes_entry *) entry;
2865 /* Allocate the structure if it has not already been allocated by a
2868 ret = bfd_hash_allocate (table,
2869 sizeof (struct aout_link_includes_entry));
2873 /* Call the allocation method of the superclass. */
2874 ret = ((struct aout_link_includes_entry *)
2875 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
2877 /* Set local fields. */
2880 return (struct bfd_hash_entry *) ret;
2884 aout_link_write_other_symbol (struct aout_link_hash_entry *h, void * data)
2886 struct aout_final_link_info *finfo = (struct aout_final_link_info *) data;
2890 struct external_nlist outsym;
2894 if (h->root.type == bfd_link_hash_warning)
2896 h = (struct aout_link_hash_entry *) h->root.u.i.link;
2897 if (h->root.type == bfd_link_hash_new)
2901 output_bfd = finfo->output_bfd;
2903 if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
2905 if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
2906 (output_bfd, finfo->info, h)))
2908 /* FIXME: No way to handle errors. */
2918 /* An indx of -2 means the symbol must be written. */
2920 && (finfo->info->strip == strip_all
2921 || (finfo->info->strip == strip_some
2922 && bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
2923 FALSE, FALSE) == NULL)))
2926 switch (h->root.type)
2930 /* Avoid variable not initialized warnings. */
2932 case bfd_link_hash_new:
2933 /* This can happen for set symbols when sets are not being
2936 case bfd_link_hash_undefined:
2937 type = N_UNDF | N_EXT;
2940 case bfd_link_hash_defined:
2941 case bfd_link_hash_defweak:
2945 sec = h->root.u.def.section->output_section;
2946 BFD_ASSERT (bfd_is_abs_section (sec)
2947 || sec->owner == output_bfd);
2948 if (sec == obj_textsec (output_bfd))
2949 type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
2950 else if (sec == obj_datasec (output_bfd))
2951 type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
2952 else if (sec == obj_bsssec (output_bfd))
2953 type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
2955 type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
2957 val = (h->root.u.def.value
2959 + h->root.u.def.section->output_offset);
2962 case bfd_link_hash_common:
2963 type = N_UNDF | N_EXT;
2964 val = h->root.u.c.size;
2966 case bfd_link_hash_undefweak:
2969 case bfd_link_hash_indirect:
2970 case bfd_link_hash_warning:
2971 /* FIXME: Ignore these for now. The circumstances under which
2972 they should be written out are not clear to me. */
2976 H_PUT_8 (output_bfd, type, outsym.e_type);
2977 indx = add_to_stringtab (output_bfd, finfo->strtab, h->root.root.string,
2979 if (indx == (bfd_size_type) -1)
2980 /* FIXME: No way to handle errors. */
2983 PUT_WORD (output_bfd, indx, outsym.e_strx);
2984 PUT_WORD (output_bfd, val, outsym.e_value);
2986 amt = EXTERNAL_NLIST_SIZE;
2987 if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0
2988 || bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt)
2989 /* FIXME: No way to handle errors. */
2992 finfo->symoff += amt;
2993 h->indx = obj_aout_external_sym_count (output_bfd);
2994 ++obj_aout_external_sym_count (output_bfd);
2999 /* Handle a link order which is supposed to generate a reloc. */
3002 aout_link_reloc_link_order (struct aout_final_link_info *finfo,
3004 struct bfd_link_order *p)
3006 struct bfd_link_order_reloc *pr;
3009 reloc_howto_type *howto;
3010 file_ptr *reloff_ptr;
3011 struct reloc_std_external srel;
3013 bfd_size_type rel_size;
3017 if (p->type == bfd_section_reloc_link_order)
3020 if (bfd_is_abs_section (pr->u.section))
3021 r_index = N_ABS | N_EXT;
3024 BFD_ASSERT (pr->u.section->owner == finfo->output_bfd);
3025 r_index = pr->u.section->target_index;
3030 struct aout_link_hash_entry *h;
3032 BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
3034 h = ((struct aout_link_hash_entry *)
3035 bfd_wrapped_link_hash_lookup (finfo->output_bfd, finfo->info,
3036 pr->u.name, FALSE, FALSE, TRUE));
3042 /* We decided to strip this symbol, but it turns out that we
3043 can't. Note that we lose the other and desc information
3044 here. I don't think that will ever matter for a global
3048 if (! aout_link_write_other_symbol (h, (void *) finfo))
3054 if (! ((*finfo->info->callbacks->unattached_reloc)
3055 (finfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0)))
3061 howto = bfd_reloc_type_lookup (finfo->output_bfd, pr->reloc);
3064 bfd_set_error (bfd_error_bad_value);
3068 if (o == obj_textsec (finfo->output_bfd))
3069 reloff_ptr = &finfo->treloff;
3070 else if (o == obj_datasec (finfo->output_bfd))
3071 reloff_ptr = &finfo->dreloff;
3076 MY_put_reloc(finfo->output_bfd, r_extern, r_index, p->offset, howto,
3086 fprintf (stderr, "TODO: line %d in bfd/pdp11.c\n", __LINE__);
3088 r_pcrel = howto->pc_relative;
3089 r_baserel = (howto->type & 8) != 0;
3090 r_jmptable = (howto->type & 16) != 0;
3091 r_relative = (howto->type & 32) != 0;
3092 r_length = howto->size;
3094 PUT_WORD (finfo->output_bfd, p->offset, srel.r_address);
3095 if (bfd_header_big_endian (finfo->output_bfd))
3097 srel.r_index[0] = r_index >> 16;
3098 srel.r_index[1] = r_index >> 8;
3099 srel.r_index[2] = r_index;
3101 ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
3102 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
3103 | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
3104 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
3105 | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
3106 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
3110 srel.r_index[2] = r_index >> 16;
3111 srel.r_index[1] = r_index >> 8;
3112 srel.r_index[0] = r_index;
3114 ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
3115 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
3116 | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
3117 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
3118 | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
3119 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
3123 rel_ptr = (void *) &srel;
3125 /* We have to write the addend into the object file, since
3126 standard a.out relocs are in place. It would be more
3127 reliable if we had the current contents of the file here,
3128 rather than assuming zeroes, but we can't read the file since
3129 it was opened using bfd_openw. */
3130 if (pr->addend != 0)
3133 bfd_reloc_status_type r;
3137 size = bfd_get_reloc_size (howto);
3138 buf = bfd_zmalloc (size);
3141 r = MY_relocate_contents (howto, finfo->output_bfd,
3148 case bfd_reloc_outofrange:
3150 case bfd_reloc_overflow:
3151 if (! ((*finfo->info->callbacks->reloc_overflow)
3153 (p->type == bfd_section_reloc_link_order
3154 ? bfd_section_name (finfo->output_bfd,
3157 howto->name, pr->addend, NULL,
3158 (asection *) NULL, (bfd_vma) 0)))
3165 ok = bfd_set_section_contents (finfo->output_bfd, o,
3167 (file_ptr) p->offset,
3174 rel_size = obj_reloc_entry_size (finfo->output_bfd);
3175 if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
3176 || bfd_bwrite (rel_ptr, rel_size, finfo->output_bfd) != rel_size)
3179 *reloff_ptr += rel_size;
3181 /* Assert that the relocs have not run into the symbols, and that n
3182 the text relocs have not run into the data relocs. */
3183 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
3184 && (reloff_ptr != &finfo->treloff
3186 <= obj_datasec (finfo->output_bfd)->rel_filepos)));
3191 /* Get the section corresponding to a reloc index. */
3193 static inline asection *
3194 aout_reloc_type_to_section (bfd *abfd, int type)
3198 case RTEXT: return obj_textsec (abfd);
3199 case RDATA: return obj_datasec (abfd);
3200 case RBSS: return obj_bsssec (abfd);
3201 case RABS: return bfd_abs_section_ptr;
3202 case REXT: return bfd_und_section_ptr;
3208 pdp11_aout_link_input_section (struct aout_final_link_info *finfo,
3210 asection *input_section,
3212 bfd_size_type rel_size,
3215 bfd_boolean (*check_dynamic_reloc)
3216 (struct bfd_link_info *, bfd *, asection *,
3217 struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
3220 bfd_boolean relocatable;
3221 struct external_nlist *syms;
3223 struct aout_link_hash_entry **sym_hashes;
3228 output_bfd = finfo->output_bfd;
3229 check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
3231 BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_SIZE);
3232 BFD_ASSERT (input_bfd->xvec->header_byteorder
3233 == output_bfd->xvec->header_byteorder);
3235 relocatable = finfo->info->relocatable;
3236 syms = obj_aout_external_syms (input_bfd);
3237 strings = obj_aout_external_strings (input_bfd);
3238 sym_hashes = obj_aout_sym_hashes (input_bfd);
3239 symbol_map = finfo->symbol_map;
3242 rel_end = rel + rel_size;
3243 for (; rel < rel_end; rel += RELOC_SIZE)
3250 reloc_howto_type *howto;
3251 struct aout_link_hash_entry *h = NULL;
3253 bfd_reloc_status_type r;
3256 reloc_entry = GET_WORD (input_bfd, (void *) rel);
3257 if (reloc_entry == 0)
3261 unsigned int howto_idx;
3263 r_index = (reloc_entry & RIDXMASK) >> 4;
3264 r_type = reloc_entry & RTYPE;
3265 r_pcrel = reloc_entry & RELFLG;
3266 r_addr = (char *) rel - (char *) relocs;
3268 r_extern = (r_type == REXT);
3270 howto_idx = r_pcrel;
3271 BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_pdp11));
3272 howto = howto_table_pdp11 + howto_idx;
3277 /* We are generating a relocatable output file, and must
3278 modify the reloc accordingly. */
3281 /* If we know the symbol this relocation is against,
3282 convert it into a relocation against a section. This
3283 is what the native linker does. */
3284 h = sym_hashes[r_index];
3286 && (h->root.type == bfd_link_hash_defined
3287 || h->root.type == bfd_link_hash_defweak))
3289 asection *output_section;
3291 /* Compute a new r_index. */
3292 output_section = h->root.u.def.section->output_section;
3293 if (output_section == obj_textsec (output_bfd))
3295 else if (output_section == obj_datasec (output_bfd))
3297 else if (output_section == obj_bsssec (output_bfd))
3302 /* Add the symbol value and the section VMA to the
3303 addend stored in the contents. */
3304 relocation = (h->root.u.def.value
3305 + output_section->vma
3306 + h->root.u.def.section->output_offset);
3310 /* We must change r_index according to the symbol
3312 r_index = symbol_map[r_index];
3318 /* We decided to strip this symbol, but it
3319 turns out that we can't. Note that we
3320 lose the other and desc information here.
3321 I don't think that will ever matter for a
3327 if (! aout_link_write_other_symbol (h,
3337 name = strings + GET_WORD (input_bfd,
3338 syms[r_index].e_strx);
3339 if (! ((*finfo->info->callbacks->unattached_reloc)
3340 (finfo->info, name, input_bfd, input_section,
3350 /* Write out the new r_index value. */
3351 reloc_entry = GET_WORD (input_bfd, rel);
3352 reloc_entry &= RIDXMASK;
3353 reloc_entry |= r_index << 4;
3354 PUT_WORD (input_bfd, reloc_entry, rel);
3360 /* This is a relocation against a section. We must
3361 adjust by the amount that the section moved. */
3362 section = aout_reloc_type_to_section (input_bfd, r_type);
3363 relocation = (section->output_section->vma
3364 + section->output_offset
3368 /* Change the address of the relocation. */
3369 fprintf (stderr, "TODO: change the address of the relocation\n");
3371 /* Adjust a PC relative relocation by removing the reference
3372 to the original address in the section and including the
3373 reference to the new address. */
3375 relocation -= (input_section->output_section->vma
3376 + input_section->output_offset
3377 - input_section->vma);
3379 #ifdef MY_relocatable_reloc
3380 MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr);
3383 if (relocation == 0)
3386 r = MY_relocate_contents (howto,
3387 input_bfd, relocation,
3394 /* We are generating an executable, and must do a full
3399 h = sym_hashes[r_index];
3402 && (h->root.type == bfd_link_hash_defined
3403 || h->root.type == bfd_link_hash_defweak))
3405 relocation = (h->root.u.def.value
3406 + h->root.u.def.section->output_section->vma
3407 + h->root.u.def.section->output_offset);
3410 && h->root.type == bfd_link_hash_undefweak)
3422 section = aout_reloc_type_to_section (input_bfd, r_type);
3423 relocation = (section->output_section->vma
3424 + section->output_offset
3427 relocation += input_section->vma;
3430 if (check_dynamic_reloc != NULL)
3434 if (! ((*check_dynamic_reloc)
3435 (finfo->info, input_bfd, input_section, h,
3436 (void *) rel, contents, &skip, &relocation)))
3442 /* Now warn if a global symbol is undefined. We could not
3443 do this earlier, because check_dynamic_reloc might want
3444 to skip this reloc. */
3445 if (hundef && ! finfo->info->shared)
3450 name = h->root.root.string;
3452 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
3453 if (! ((*finfo->info->callbacks->undefined_symbol)
3454 (finfo->info, name, input_bfd, input_section,
3459 r = MY_final_link_relocate (howto,
3460 input_bfd, input_section,
3461 contents, r_addr, relocation,
3465 if (r != bfd_reloc_ok)
3470 case bfd_reloc_outofrange:
3472 case bfd_reloc_overflow:
3479 name = strings + GET_WORD (input_bfd,
3480 syms[r_index].e_strx);
3485 s = aout_reloc_type_to_section (input_bfd, r_type);
3486 name = bfd_section_name (input_bfd, s);
3488 if (! ((*finfo->info->callbacks->reloc_overflow)
3489 (finfo->info, (h ? &h->root : NULL), name,
3490 howto->name, (bfd_vma) 0, input_bfd,
3491 input_section, r_addr)))
3502 /* Link an a.out section into the output file. */
3505 aout_link_input_section (struct aout_final_link_info *finfo,
3507 asection *input_section,
3508 file_ptr *reloff_ptr,
3509 bfd_size_type rel_size)
3511 bfd_size_type input_size;
3514 /* Get the section contents. */
3515 input_size = input_section->size;
3516 if (! bfd_get_section_contents (input_bfd, input_section,
3517 (void *) finfo->contents,
3518 (file_ptr) 0, input_size))
3521 /* Read in the relocs if we haven't already done it. */
3522 if (aout_section_data (input_section) != NULL
3523 && aout_section_data (input_section)->relocs != NULL)
3524 relocs = aout_section_data (input_section)->relocs;
3527 relocs = finfo->relocs;
3530 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
3531 || bfd_bread (relocs, rel_size, input_bfd) != rel_size)
3536 /* Relocate the section contents. */
3537 if (! pdp11_aout_link_input_section (finfo, input_bfd, input_section,
3538 (bfd_byte *) relocs,
3539 rel_size, finfo->contents))
3542 /* Write out the section contents. */
3543 if (! bfd_set_section_contents (finfo->output_bfd,
3544 input_section->output_section,
3545 (void *) finfo->contents,
3546 (file_ptr) input_section->output_offset,
3550 /* If we are producing relocatable output, the relocs were
3551 modified, and we now write them out. */
3552 if (finfo->info->relocatable && rel_size > 0)
3554 if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
3556 if (bfd_bwrite (relocs, rel_size, finfo->output_bfd) != rel_size)
3558 *reloff_ptr += rel_size;
3560 /* Assert that the relocs have not run into the symbols, and
3561 that if these are the text relocs they have not run into the
3563 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
3564 && (reloff_ptr != &finfo->treloff
3566 <= obj_datasec (finfo->output_bfd)->rel_filepos)));
3572 /* Link an a.out input BFD into the output file. */
3575 aout_link_input_bfd (struct aout_final_link_info *finfo, bfd *input_bfd)
3577 BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
3579 /* If this is a dynamic object, it may need special handling. */
3580 if ((input_bfd->flags & DYNAMIC) != 0
3581 && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
3582 return ((*aout_backend_info (input_bfd)->link_dynamic_object)
3583 (finfo->info, input_bfd));
3585 /* Get the symbols. We probably have them already, unless
3586 finfo->info->keep_memory is FALSE. */
3587 if (! aout_get_external_symbols (input_bfd))
3590 /* Write out the symbols and get a map of the new indices. The map
3591 is placed into finfo->symbol_map. */
3592 if (! aout_link_write_symbols (finfo, input_bfd))
3595 /* Relocate and write out the sections. These functions use the
3596 symbol map created by aout_link_write_symbols. The linker_mark
3597 field will be set if these sections are to be included in the
3598 link, which will normally be the case. */
3599 if (obj_textsec (input_bfd)->linker_mark)
3601 if (! aout_link_input_section (finfo, input_bfd,
3602 obj_textsec (input_bfd),
3604 exec_hdr (input_bfd)->a_trsize))
3607 if (obj_datasec (input_bfd)->linker_mark)
3609 if (! aout_link_input_section (finfo, input_bfd,
3610 obj_datasec (input_bfd),
3612 exec_hdr (input_bfd)->a_drsize))
3616 /* If we are not keeping memory, we don't need the symbols any
3617 longer. We still need them if we are keeping memory, because the
3618 strings in the hash table point into them. */
3619 if (! finfo->info->keep_memory)
3621 if (! aout_link_free_symbols (input_bfd))
3628 /* Do the final link step. This is called on the output BFD. The
3629 INFO structure should point to a list of BFDs linked through the
3630 link_next field which can be used to find each BFD which takes part
3631 in the output. Also, each section in ABFD should point to a list
3632 of bfd_link_order structures which list all the input sections for
3633 the output section. */
3636 NAME (aout, final_link) (bfd *abfd,
3637 struct bfd_link_info *info,
3638 void (*callback) (bfd *, file_ptr *, file_ptr *, file_ptr *))
3640 struct aout_final_link_info aout_info;
3641 bfd_boolean includes_hash_initialized = FALSE;
3643 bfd_size_type trsize, drsize;
3644 bfd_size_type max_contents_size;
3645 bfd_size_type max_relocs_size;
3646 bfd_size_type max_sym_count;
3647 bfd_size_type text_size;
3649 struct bfd_link_order *p;
3651 bfd_boolean have_link_order_relocs;
3654 abfd->flags |= DYNAMIC;
3656 aout_info.info = info;
3657 aout_info.output_bfd = abfd;
3658 aout_info.contents = NULL;
3659 aout_info.relocs = NULL;
3660 aout_info.symbol_map = NULL;
3661 aout_info.output_syms = NULL;
3663 if (!bfd_hash_table_init_n (&aout_info.includes.root,
3664 aout_link_includes_newfunc,
3665 sizeof (struct aout_link_includes_entry),
3668 includes_hash_initialized = TRUE;
3670 /* Figure out the largest section size. Also, if generating
3671 relocatable output, count the relocs. */
3674 max_contents_size = 0;
3675 max_relocs_size = 0;
3677 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3681 if (info->relocatable)
3683 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3685 trsize += exec_hdr (sub)->a_trsize;
3686 drsize += exec_hdr (sub)->a_drsize;
3690 /* FIXME: We need to identify the .text and .data sections
3691 and call get_reloc_upper_bound and canonicalize_reloc to
3692 work out the number of relocs needed, and then multiply
3693 by the reloc size. */
3694 (*_bfd_error_handler)
3695 ("%s: relocatable link from %s to %s not supported",
3696 bfd_get_filename (abfd),
3697 sub->xvec->name, abfd->xvec->name);
3698 bfd_set_error (bfd_error_invalid_operation);
3703 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3705 sz = obj_textsec (sub)->size;
3706 if (sz > max_contents_size)
3707 max_contents_size = sz;
3708 sz = obj_datasec (sub)->size;
3709 if (sz > max_contents_size)
3710 max_contents_size = sz;
3712 sz = exec_hdr (sub)->a_trsize;
3713 if (sz > max_relocs_size)
3714 max_relocs_size = sz;
3715 sz = exec_hdr (sub)->a_drsize;
3716 if (sz > max_relocs_size)
3717 max_relocs_size = sz;
3719 sz = obj_aout_external_sym_count (sub);
3720 if (sz > max_sym_count)
3725 if (info->relocatable)
3727 if (obj_textsec (abfd) != NULL)
3728 trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
3729 ->map_head.link_order)
3730 * obj_reloc_entry_size (abfd));
3731 if (obj_datasec (abfd) != NULL)
3732 drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
3733 ->map_head.link_order)
3734 * obj_reloc_entry_size (abfd));
3737 exec_hdr (abfd)->a_trsize = trsize;
3738 exec_hdr (abfd)->a_drsize = drsize;
3739 exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
3741 /* Adjust the section sizes and vmas according to the magic number.
3742 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3743 filepos for each section. */
3744 if (! NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
3747 /* The relocation and symbol file positions differ among a.out
3748 targets. We are passed a callback routine from the backend
3749 specific code to handle this.
3750 FIXME: At this point we do not know how much space the symbol
3751 table will require. This will not work for any (nonstandard)
3752 a.out target that needs to know the symbol table size before it
3753 can compute the relocation file positions. This may or may not
3754 be the case for the hp300hpux target, for example. */
3755 (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
3757 obj_textsec (abfd)->rel_filepos = aout_info.treloff;
3758 obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
3759 obj_sym_filepos (abfd) = aout_info.symoff;
3761 /* We keep a count of the symbols as we output them. */
3762 obj_aout_external_sym_count (abfd) = 0;
3764 /* We accumulate the string table as we write out the symbols. */
3765 aout_info.strtab = _bfd_stringtab_init ();
3766 if (aout_info.strtab == NULL)
3769 /* Allocate buffers to hold section contents and relocs. */
3770 aout_info.contents = bfd_malloc (max_contents_size);
3771 aout_info.relocs = bfd_malloc (max_relocs_size);
3772 aout_info.symbol_map = bfd_malloc (max_sym_count * sizeof (int *));
3773 aout_info.output_syms = bfd_malloc ((max_sym_count + 1)
3774 * sizeof (struct external_nlist));
3775 if ((aout_info.contents == NULL && max_contents_size != 0)
3776 || (aout_info.relocs == NULL && max_relocs_size != 0)
3777 || (aout_info.symbol_map == NULL && max_sym_count != 0)
3778 || aout_info.output_syms == NULL)
3781 /* If we have a symbol named __DYNAMIC, force it out now. This is
3782 required by SunOS. Doing this here rather than in sunos.c is a
3783 hack, but it's easier than exporting everything which would be
3786 struct aout_link_hash_entry *h;
3788 h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
3789 FALSE, FALSE, FALSE);
3791 aout_link_write_other_symbol (h, &aout_info);
3794 /* The most time efficient way to do the link would be to read all
3795 the input object files into memory and then sort out the
3796 information into the output file. Unfortunately, that will
3797 probably use too much memory. Another method would be to step
3798 through everything that composes the text section and write it
3799 out, and then everything that composes the data section and write
3800 it out, and then write out the relocs, and then write out the
3801 symbols. Unfortunately, that requires reading stuff from each
3802 input file several times, and we will not be able to keep all the
3803 input files open simultaneously, and reopening them will be slow.
3805 What we do is basically process one input file at a time. We do
3806 everything we need to do with an input file once--copy over the
3807 section contents, handle the relocation information, and write
3808 out the symbols--and then we throw away the information we read
3809 from it. This approach requires a lot of lseeks of the output
3810 file, which is unfortunate but still faster than reopening a lot
3813 We use the output_has_begun field of the input BFDs to see
3814 whether we have already handled it. */
3815 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3816 sub->output_has_begun = FALSE;
3818 /* Mark all sections which are to be included in the link. This
3819 will normally be every section. We need to do this so that we
3820 can identify any sections which the linker has decided to not
3822 for (o = abfd->sections; o != NULL; o = o->next)
3824 for (p = o->map_head.link_order; p != NULL; p = p->next)
3825 if (p->type == bfd_indirect_link_order)
3826 p->u.indirect.section->linker_mark = TRUE;
3829 have_link_order_relocs = FALSE;
3830 for (o = abfd->sections; o != NULL; o = o->next)
3832 for (p = o->map_head.link_order;
3836 if (p->type == bfd_indirect_link_order
3837 && (bfd_get_flavour (p->u.indirect.section->owner)
3838 == bfd_target_aout_flavour))
3842 input_bfd = p->u.indirect.section->owner;
3843 if (! input_bfd->output_has_begun)
3845 if (! aout_link_input_bfd (&aout_info, input_bfd))
3847 input_bfd->output_has_begun = TRUE;
3850 else if (p->type == bfd_section_reloc_link_order
3851 || p->type == bfd_symbol_reloc_link_order)
3852 /* These are handled below. */
3853 have_link_order_relocs = TRUE;
3856 if (! _bfd_default_link_order (abfd, info, o, p))
3862 /* Write out any symbols that we have not already written out. */
3863 aout_link_hash_traverse (aout_hash_table (info),
3864 aout_link_write_other_symbol,
3865 (void *) &aout_info);
3867 /* Now handle any relocs we were asked to create by the linker.
3868 These did not come from any input file. We must do these after
3869 we have written out all the symbols, so that we know the symbol
3871 if (have_link_order_relocs)
3873 for (o = abfd->sections; o != NULL; o = o->next)
3875 for (p = o->map_head.link_order;
3879 if (p->type == bfd_section_reloc_link_order
3880 || p->type == bfd_symbol_reloc_link_order)
3882 if (! aout_link_reloc_link_order (&aout_info, o, p))
3889 if (aout_info.contents != NULL)
3891 free (aout_info.contents);
3892 aout_info.contents = NULL;
3894 if (aout_info.relocs != NULL)
3896 free (aout_info.relocs);
3897 aout_info.relocs = NULL;
3899 if (aout_info.symbol_map != NULL)
3901 free (aout_info.symbol_map);
3902 aout_info.symbol_map = NULL;
3904 if (aout_info.output_syms != NULL)
3906 free (aout_info.output_syms);
3907 aout_info.output_syms = NULL;
3909 if (includes_hash_initialized)
3911 bfd_hash_table_free (&aout_info.includes.root);
3912 includes_hash_initialized = FALSE;
3915 /* Finish up any dynamic linking we may be doing. */
3916 if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
3918 if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
3922 /* Update the header information. */
3923 abfd->symcount = obj_aout_external_sym_count (abfd);
3924 exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
3925 obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
3926 obj_textsec (abfd)->reloc_count =
3927 exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
3928 obj_datasec (abfd)->reloc_count =
3929 exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
3931 /* Write out the string table, unless there are no symbols. */
3932 if (abfd->symcount > 0)
3934 if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
3935 || ! emit_stringtab (abfd, aout_info.strtab))
3938 else if (obj_textsec (abfd)->reloc_count == 0
3939 && obj_datasec (abfd)->reloc_count == 0)
3945 (file_ptr) (obj_datasec (abfd)->filepos
3946 + exec_hdr (abfd)->a_data
3949 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3956 if (aout_info.contents != NULL)
3957 free (aout_info.contents);
3958 if (aout_info.relocs != NULL)
3959 free (aout_info.relocs);
3960 if (aout_info.symbol_map != NULL)
3961 free (aout_info.symbol_map);
3962 if (aout_info.output_syms != NULL)
3963 free (aout_info.output_syms);
3964 if (includes_hash_initialized)
3965 bfd_hash_table_free (&aout_info.includes.root);
3969 /* Adjust and write out the symbols for an a.out file. Set the new
3970 symbol indices into a symbol_map. */
3973 aout_link_write_symbols (struct aout_final_link_info *finfo, bfd *input_bfd)
3976 bfd_size_type sym_count;
3978 enum bfd_link_strip strip;
3979 enum bfd_link_discard discard;
3980 struct external_nlist *outsym;
3981 bfd_size_type strtab_index;
3982 struct external_nlist *sym;
3983 struct external_nlist *sym_end;
3984 struct aout_link_hash_entry **sym_hash;
3987 bfd_boolean skip_next;
3989 output_bfd = finfo->output_bfd;
3990 sym_count = obj_aout_external_sym_count (input_bfd);
3991 strings = obj_aout_external_strings (input_bfd);
3992 strip = finfo->info->strip;
3993 discard = finfo->info->discard;
3994 outsym = finfo->output_syms;
3996 /* First write out a symbol for this object file, unless we are
3997 discarding such symbols. */
3998 if (strip != strip_all
3999 && (strip != strip_some
4000 || bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
4001 FALSE, FALSE) != NULL)
4002 && discard != discard_all)
4004 H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
4005 strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4006 input_bfd->filename, FALSE);
4007 if (strtab_index == (bfd_size_type) -1)
4009 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4010 PUT_WORD (output_bfd,
4011 (bfd_get_section_vma (output_bfd,
4012 obj_textsec (input_bfd)->output_section)
4013 + obj_textsec (input_bfd)->output_offset),
4015 ++obj_aout_external_sym_count (output_bfd);
4021 sym = obj_aout_external_syms (input_bfd);
4022 sym_end = sym + sym_count;
4023 sym_hash = obj_aout_sym_hashes (input_bfd);
4024 symbol_map = finfo->symbol_map;
4025 memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
4026 for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
4030 struct aout_link_hash_entry *h;
4036 /* We set *symbol_map to 0 above for all symbols. If it has
4037 already been set to -1 for this symbol, it means that we are
4038 discarding it because it appears in a duplicate header file.
4039 See the N_BINCL code below. */
4040 if (*symbol_map == -1)
4043 /* Initialize *symbol_map to -1, which means that the symbol was
4044 not copied into the output file. We will change it later if
4045 we do copy the symbol over. */
4048 type = H_GET_8 (input_bfd, sym->e_type);
4049 name = strings + GET_WORD (input_bfd, sym->e_strx);
4055 /* Pass this symbol through. It is the target of an
4056 indirect or warning symbol. */
4057 val = GET_WORD (input_bfd, sym->e_value);
4062 /* Skip this symbol, which is the target of an indirect
4063 symbol that we have changed to no longer be an indirect
4070 struct aout_link_hash_entry *hresolve;
4072 /* We have saved the hash table entry for this symbol, if
4073 there is one. Note that we could just look it up again
4074 in the hash table, provided we first check that it is an
4078 /* Use the name from the hash table, in case the symbol was
4081 name = h->root.root.string;
4083 /* If this is an indirect or warning symbol, then change
4084 hresolve to the base symbol. We also change *sym_hash so
4085 that the relocation routines relocate against the real
4089 && (h->root.type == bfd_link_hash_indirect
4090 || h->root.type == bfd_link_hash_warning))
4092 hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
4093 while (hresolve->root.type == bfd_link_hash_indirect
4094 || hresolve->root.type == bfd_link_hash_warning)
4095 hresolve = ((struct aout_link_hash_entry *)
4096 hresolve->root.u.i.link);
4097 *sym_hash = hresolve;
4100 /* If the symbol has already been written out, skip it. */
4102 && h->root.type != bfd_link_hash_warning
4105 if ((type & N_TYPE) == N_INDR
4106 || type == N_WARNING)
4108 *symbol_map = h->indx;
4112 /* See if we are stripping this symbol. */
4118 case strip_debugger:
4119 if ((type & N_STAB) != 0)
4123 if (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
4138 /* Get the value of the symbol. */
4139 if ((type & N_TYPE) == N_TEXT
4141 symsec = obj_textsec (input_bfd);
4142 else if ((type & N_TYPE) == N_DATA
4144 symsec = obj_datasec (input_bfd);
4145 else if ((type & N_TYPE) == N_BSS
4147 symsec = obj_bsssec (input_bfd);
4148 else if ((type & N_TYPE) == N_ABS
4150 symsec = bfd_abs_section_ptr;
4151 else if (((type & N_TYPE) == N_INDR
4152 && (hresolve == NULL
4153 || (hresolve->root.type != bfd_link_hash_defined
4154 && hresolve->root.type != bfd_link_hash_defweak
4155 && hresolve->root.type != bfd_link_hash_common)))
4156 || type == N_WARNING)
4158 /* Pass the next symbol through unchanged. The
4159 condition above for indirect symbols is so that if
4160 the indirect symbol was defined, we output it with
4161 the correct definition so the debugger will
4164 val = GET_WORD (input_bfd, sym->e_value);
4167 else if ((type & N_STAB) != 0)
4169 val = GET_WORD (input_bfd, sym->e_value);
4174 /* If we get here with an indirect symbol, it means that
4175 we are outputting it with a real definition. In such
4176 a case we do not want to output the next symbol,
4177 which is the target of the indirection. */
4178 if ((type & N_TYPE) == N_INDR)
4183 /* We need to get the value from the hash table. We use
4184 hresolve so that if we have defined an indirect
4185 symbol we output the final definition. */
4188 switch (type & N_TYPE)
4191 symsec = obj_textsec (input_bfd);
4194 symsec = obj_datasec (input_bfd);
4197 symsec = obj_bsssec (input_bfd);
4200 symsec = bfd_abs_section_ptr;
4207 else if (hresolve->root.type == bfd_link_hash_defined
4208 || hresolve->root.type == bfd_link_hash_defweak)
4210 asection *input_section;
4211 asection *output_section;
4213 /* This case usually means a common symbol which was
4214 turned into a defined symbol. */
4215 input_section = hresolve->root.u.def.section;
4216 output_section = input_section->output_section;
4217 BFD_ASSERT (bfd_is_abs_section (output_section)
4218 || output_section->owner == output_bfd);
4219 val = (hresolve->root.u.def.value
4220 + bfd_get_section_vma (output_bfd, output_section)
4221 + input_section->output_offset);
4223 /* Get the correct type based on the section. If
4224 this is a constructed set, force it to be
4225 globally visible. */
4234 if (output_section == obj_textsec (output_bfd))
4235 type |= (hresolve->root.type == bfd_link_hash_defined
4238 else if (output_section == obj_datasec (output_bfd))
4239 type |= (hresolve->root.type == bfd_link_hash_defined
4242 else if (output_section == obj_bsssec (output_bfd))
4243 type |= (hresolve->root.type == bfd_link_hash_defined
4247 type |= (hresolve->root.type == bfd_link_hash_defined
4251 else if (hresolve->root.type == bfd_link_hash_common)
4252 val = hresolve->root.u.c.size;
4253 else if (hresolve->root.type == bfd_link_hash_undefweak)
4262 val = (symsec->output_section->vma
4263 + symsec->output_offset
4264 + (GET_WORD (input_bfd, sym->e_value)
4267 /* If this is a global symbol set the written flag, and if
4268 it is a local symbol see if we should discard it. */
4272 h->indx = obj_aout_external_sym_count (output_bfd);
4274 else if ((type & N_TYPE) != N_SETT
4275 && (type & N_TYPE) != N_SETD
4276 && (type & N_TYPE) != N_SETB
4277 && (type & N_TYPE) != N_SETA)
4282 case discard_sec_merge:
4285 if ((type & N_STAB) == 0
4286 && bfd_is_local_label_name (input_bfd, name))
4300 /* An N_BINCL symbol indicates the start of the stabs
4301 entries for a header file. We need to scan ahead to the
4302 next N_EINCL symbol, ignoring nesting, adding up all the
4303 characters in the symbol names, not including the file
4304 numbers in types (the first number after an open
4306 if (type == N_BINCL)
4308 struct external_nlist *incl_sym;
4310 struct aout_link_includes_entry *incl_entry;
4311 struct aout_link_includes_totals *t;
4315 for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++)
4319 incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
4320 if (incl_type == N_EINCL)
4326 else if (incl_type == N_BINCL)
4332 s = strings + GET_WORD (input_bfd, incl_sym->e_strx);
4333 for (; *s != '\0'; s++)
4338 /* Skip the file number. */
4340 while (ISDIGIT (*s))
4348 /* If we have already included a header file with the
4349 same value, then replace this one with an N_EXCL
4351 copy = ! finfo->info->keep_memory;
4352 incl_entry = aout_link_includes_lookup (&finfo->includes,
4354 if (incl_entry == NULL)
4356 for (t = incl_entry->totals; t != NULL; t = t->next)
4357 if (t->total == val)
4361 /* This is the first time we have seen this header
4362 file with this set of stabs strings. */
4363 t = bfd_hash_allocate (&finfo->includes.root,
4368 t->next = incl_entry->totals;
4369 incl_entry->totals = t;
4375 /* This is a duplicate header file. We must change
4376 it to be an N_EXCL entry, and mark all the
4377 included symbols to prevent outputting them. */
4381 for (incl_sym = sym + 1, incl_map = symbol_map + 1;
4383 incl_sym++, incl_map++)
4387 incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
4388 if (incl_type == N_EINCL)
4397 else if (incl_type == N_BINCL)
4406 /* Copy this symbol into the list of symbols we are going to
4408 H_PUT_8 (output_bfd, type, outsym->e_type);
4410 if (! finfo->info->keep_memory)
4412 /* name points into a string table which we are going to
4413 free. If there is a hash table entry, use that string.
4414 Otherwise, copy name into memory. */
4416 name = h->root.root.string;
4420 strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4422 if (strtab_index == (bfd_size_type) -1)
4424 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4425 PUT_WORD (output_bfd, val, outsym->e_value);
4426 *symbol_map = obj_aout_external_sym_count (output_bfd);
4427 ++obj_aout_external_sym_count (output_bfd);
4431 /* Write out the output symbols we have just constructed. */
4432 if (outsym > finfo->output_syms)
4436 if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
4438 size = outsym - finfo->output_syms;
4439 size *= EXTERNAL_NLIST_SIZE;
4440 if (bfd_bwrite ((void *) finfo->output_syms, size, output_bfd) != size)
4442 finfo->symoff += size;
4448 /* Write out a symbol that was not associated with an a.out input
4452 bfd_getp32 (const void *p)
4454 const bfd_byte *addr = p;
4457 v = (unsigned long) addr[1] << 24;
4458 v |= (unsigned long) addr[0] << 16;
4459 v |= (unsigned long) addr[3] << 8;
4460 v |= (unsigned long) addr[2];
4464 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
4466 static bfd_signed_vma
4467 bfd_getp_signed_32 (const void *p)
4469 const bfd_byte *addr = p;
4472 v = (unsigned long) addr[1] << 24;
4473 v |= (unsigned long) addr[0] << 16;
4474 v |= (unsigned long) addr[3] << 8;
4475 v |= (unsigned long) addr[2];
4476 return COERCE32 (v);
4480 bfd_putp32 (bfd_vma data, void *p)
4484 addr[0] = (data >> 16) & 0xff;
4485 addr[1] = (data >> 24) & 0xff;
4486 addr[2] = (data >> 0) & 0xff;
4487 addr[3] = (data >> 8) & 0xff;
4490 const bfd_target MY (vec) =
4492 TARGETNAME, /* Name. */
4493 bfd_target_aout_flavour,
4494 BFD_ENDIAN_LITTLE, /* Target byte order (little). */
4495 BFD_ENDIAN_LITTLE, /* Target headers byte order (little). */
4496 (HAS_RELOC | EXEC_P | /* Object flags. */
4497 HAS_LINENO | HAS_DEBUG |
4498 HAS_SYMS | HAS_LOCALS | WP_TEXT),
4499 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
4500 MY_symbol_leading_char,
4501 AR_PAD_CHAR, /* AR_pad_char. */
4502 15, /* AR_max_namelen. */
4503 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
4504 bfd_getp32, bfd_getp_signed_32, bfd_putp32,
4505 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data. */
4506 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
4507 bfd_getp32, bfd_getp_signed_32, bfd_putp32,
4508 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Headers. */
4509 {_bfd_dummy_target, MY_object_p, /* bfd_check_format. */
4510 bfd_generic_archive_p, MY_core_file_p},
4511 {bfd_false, MY_mkobject, /* bfd_set_format. */
4512 _bfd_generic_mkarchive, bfd_false},
4513 {bfd_false, MY_write_object_contents, /* bfd_write_contents. */
4514 _bfd_write_archive_contents, bfd_false},
4516 BFD_JUMP_TABLE_GENERIC (MY),
4517 BFD_JUMP_TABLE_COPY (MY),
4518 BFD_JUMP_TABLE_CORE (MY),
4519 BFD_JUMP_TABLE_ARCHIVE (MY),
4520 BFD_JUMP_TABLE_SYMBOLS (MY),
4521 BFD_JUMP_TABLE_RELOCS (MY),
4522 BFD_JUMP_TABLE_WRITE (MY),
4523 BFD_JUMP_TABLE_LINK (MY),
4524 BFD_JUMP_TABLE_DYNAMIC (MY),
4526 /* Alternative_target. */
4529 (void *) MY_backend_data