* aoutx.h (aout_link_check_ar_symbols): Formatting.
[binutils.git] / bfd / pdp11.c
blob3821037827982642cc72dc7bfbaa2d6eb234c362
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.
28 TODO
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
38 #define ARCH_SIZE 16
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
49 the tokens. */
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)
69 #include "sysdep.h"
70 #include "bfd.h"
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). */
97 #define QMAGIC 0
98 #define BMAGIC 0
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)
123 #include "libbfd.h"
124 #include "libaout.h"
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. */
142 #include "bfd.h"
143 #include "sysdep.h"
144 #include "safe-ctype.h"
145 #include "bfdlink.h"
147 #include "libaout.h"
148 #include "aout/aout64.h"
149 #include "aout/stab_gnu.h"
150 #include "aout/ar.h"
152 #undef N_TYPE
153 #undef N_UNDF
154 #undef N_ABS
155 #undef N_TEXT
156 #undef N_DATA
157 #undef N_BSS
158 #undef N_REG
159 #undef N_FN
160 #undef N_EXT
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. */
171 #define RELOC_SIZE 2
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
187 #endif
189 #ifndef MY_relocate_contents
190 #define MY_relocate_contents _bfd_relocate_contents
191 #endif
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
201 file. */
203 struct aout_link_includes_totals
205 struct aout_link_includes_totals *next;
206 bfd_vma total;
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;
225 /* Output bfd. */
226 bfd *output_bfd;
227 /* Reloc file positions. */
228 file_ptr treloff, dreloff;
229 /* File position of symbols. */
230 file_ptr symoff;
231 /* String table. */
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. */
236 bfd_byte *contents;
237 /* A buffer large enough to hold the relocs of any section. */
238 void * relocs;
239 /* A buffer large enough to hold the symbol map of any input BFD. */
240 int *symbol_map;
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 *);
261 reloc_howto_type *
262 NAME (aout, reloc_type_lookup) (bfd * abfd ATTRIBUTE_UNUSED,
263 bfd_reloc_code_real_type code)
265 switch (code)
267 case BFD_RELOC_16:
268 return &howto_table_pdp11[0];
269 case BFD_RELOC_16_PCREL:
270 return &howto_table_pdp11[1];
271 default:
272 return NULL;
276 reloc_howto_type *
277 NAME (aout, reloc_name_lookup) (bfd *abfd ATTRIBUTE_UNUSED,
278 const char *r_name)
280 unsigned int i;
282 for (i = 0;
283 i < sizeof (howto_table_pdp11) / sizeof (howto_table_pdp11[0]);
284 i++)
285 if (howto_table_pdp11[i].name != NULL
286 && strcasecmp (howto_table_pdp11[i].name, r_name) == 0)
287 return &howto_table_pdp11[i];
289 return NULL;
292 static int
293 pdp11_aout_write_headers (bfd *abfd, struct internal_exec *execp)
295 struct external_exec exec_bytes;
296 bfd_size_type text_size;
297 file_ptr text_end;
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;
311 else
313 execp->a_trsize = 0;
314 execp->a_drsize = 0;
317 NAME (aout, swap_exec_header_out) (abfd, execp, & exec_bytes);
319 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
320 return FALSE;
322 if (bfd_bwrite ((void *) &exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd)
323 != EXEC_BYTES_SIZE)
324 return FALSE;
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)
331 return FALSE;
333 if (! NAME (aout, write_syms) (abfd))
334 return FALSE;
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)))
344 return FALSE;
347 return TRUE;
350 /* Write an object file.
351 Section contents have already been written. We write the
352 file header, symbols, and relocation. */
354 static bfd_boolean
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;
365 file_ptr text_end;
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
380 void
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)
400 execp->a_trsize = 0;
401 execp->a_drsize = 0;
403 else
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)
410 #endif
412 /* Swap the information in an internal exec header structure
413 "execp" into the buffer "bytes" ready for writing to disk. */
414 void
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);
434 else
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. */
444 bfd_boolean
445 NAME (aout, make_sections) (bfd *abfd)
447 if (obj_textsec (abfd) == NULL && bfd_make_section (abfd, ".text") == NULL)
448 return FALSE;
449 if (obj_datasec (abfd) == NULL && bfd_make_section (abfd, ".data") == NULL)
450 return FALSE;
451 if (obj_bsssec (abfd) == NULL && bfd_make_section (abfd, ".bss") == NULL)
452 return FALSE;
453 return TRUE;
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. */
462 const bfd_target *
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);
472 if (rawptr == NULL)
473 return 0;
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. */
494 if (execp->a_syms)
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;
511 else
513 /* Should have been checked with N_BADMAG before this routine
514 was called. */
515 abort ();
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;
529 #ifdef USE_MMAP
530 bfd_init_window (&obj_aout_sym_window (abfd));
531 bfd_init_window (&obj_aout_string_window (abfd));
532 #endif
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))
539 return NULL;
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;
593 return abfd->xvec;
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;
626 #ifdef STAT_FOR_EXEC
627 else
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 */
646 if (!result)
648 free (rawptr);
649 abfd->tdata.aout_data = oldrawptr;
651 return result;
654 /* Initialize ABFD for use with a.out files. */
656 bfd_boolean
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);
667 if (rawptr == NULL)
668 return FALSE;
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;
677 return TRUE;
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. */
688 enum machine_type
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;
696 *unknown = TRUE;
698 switch (arch)
700 case bfd_arch_sparc:
701 if (machine == 0
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;
708 break;
710 case bfd_arch_m68k:
711 switch (machine)
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;
719 break;
721 case bfd_arch_i386:
722 if (machine == 0
723 || machine == bfd_mach_i386_i386
724 || machine == bfd_mach_i386_i386_intel_syntax)
725 arch_flags = M_386;
726 break;
728 case bfd_arch_arm:
729 if (machine == 0) arch_flags = M_ARM;
730 break;
732 case bfd_arch_mips:
733 switch (machine)
735 case 0:
736 case 2000:
737 case bfd_mach_mips3000:
738 arch_flags = M_MIPS1;
739 break;
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;
745 break;
746 default:
747 arch_flags = M_UNKNOWN;
748 break;
750 break;
752 case bfd_arch_ns32k:
753 switch (machine)
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;
760 break;
762 case bfd_arch_pdp11:
763 /* TODO: arch_flags = M_PDP11; */
764 *unknown = FALSE;
765 break;
767 case bfd_arch_vax:
768 *unknown = FALSE;
769 break;
771 default:
772 arch_flags = M_UNKNOWN;
775 if (arch_flags != M_UNKNOWN)
776 *unknown = FALSE;
778 return arch_flags;
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. */
785 bfd_boolean
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))
791 return FALSE;
793 if (arch != bfd_arch_unknown)
795 bfd_boolean unknown;
797 NAME (aout, machine_type) (arch, machine, &unknown);
798 if (unknown)
799 return FALSE;
802 obj_reloc_entry_size (abfd) = RELOC_SIZE;
804 return (*aout_backend_info(abfd)->set_sizes) (abfd);
807 static void
808 adjust_o_magic (bfd *abfd, struct internal_exec *execp)
810 file_ptr pos = adata (abfd).exec_bytes_size;
811 bfd_vma vma = 0;
812 int pad = 0;
814 /* Text. */
815 obj_textsec (abfd)->filepos = pos;
816 if (! obj_textsec (abfd)->user_set_vma)
817 obj_textsec (abfd)->vma = vma;
818 else
819 vma = obj_textsec (abfd)->vma;
821 pos += obj_textsec (abfd)->size;
822 vma += obj_textsec (abfd)->size;
824 /* Data. */
825 if (!obj_datasec (abfd)->user_set_vma)
827 obj_textsec (abfd)->size += pad;
828 pos += pad;
829 vma += pad;
830 obj_datasec (abfd)->vma = vma;
832 else
833 vma = obj_datasec (abfd)->vma;
834 obj_datasec (abfd)->filepos = pos;
835 pos += obj_datasec (abfd)->size;
836 vma += obj_datasec (abfd)->size;
838 /* BSS. */
839 if (! obj_bsssec (abfd)->user_set_vma)
841 obj_datasec (abfd)->size += pad;
842 pos += pad;
843 vma += pad;
844 obj_bsssec (abfd)->vma = vma;
846 else
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;
852 if (pad > 0)
854 obj_datasec (abfd)->size += pad;
855 pos += 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);
867 static void
868 adjust_z_magic (bfd *abfd, struct internal_exec *execp)
870 bfd_size_type data_pad, text_pad;
871 file_ptr text_end;
872 const struct aout_backend_data *abdp;
873 int ztih; /* Nonzero if text includes exec header. */
875 abdp = aout_backend_info (abfd);
877 /* Text. */
878 ztih = (abdp != NULL
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)
889 : (ztih
890 ? (abdp->default_text_vma
891 + adata (abfd).exec_bytes_size)
892 : abdp->default_text_vma));
893 text_pad = 0;
895 else
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
899 boundary. */
900 if (ztih)
901 text_pad = ((obj_textsec (abfd)->filepos - obj_textsec (abfd)->vma)
902 & (adata (abfd).page_size - 1));
903 else
904 text_pad = ((- obj_textsec (abfd)->vma)
905 & (adata (abfd).page_size - 1));
908 /* Find start of data. */
909 if (ztih)
911 text_end = obj_textsec (abfd)->filepos + obj_textsec (abfd)->size;
912 text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
914 else
916 /* Note that if page_size == zmagic_disk_block_size, then
917 filepos == page_size, and this case is the same as the ztih
918 case. */
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;
927 /* Data. */
928 if (!obj_datasec(abfd)->user_set_vma)
930 bfd_vma 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;
958 /* BSS. */
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;
973 else
974 execp->a_bss = obj_bsssec(abfd)->size;
977 static void
978 adjust_n_magic (bfd *abfd, struct internal_exec *execp)
980 file_ptr pos = adata(abfd).exec_bytes_size;
981 bfd_vma vma = 0;
982 int pad;
984 /* Text. */
985 obj_textsec(abfd)->filepos = pos;
986 if (!obj_textsec(abfd)->user_set_vma)
987 obj_textsec(abfd)->vma = vma;
988 else
989 vma = obj_textsec(abfd)->vma;
990 pos += obj_textsec(abfd)->size;
991 vma += obj_textsec(abfd)->size;
993 /* Data. */
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;
1005 /* BSS. */
1006 if (!obj_bsssec(abfd)->user_set_vma)
1007 obj_bsssec(abfd)->vma = vma;
1008 else
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);
1018 bfd_boolean
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))
1026 return FALSE;
1028 if (adata(abfd).magic != undecided_magic)
1029 return TRUE;
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
1042 the text. */
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
1050 minute. */
1052 if (abfd->flags & WP_TEXT)
1053 adata(abfd).magic = n_magic;
1054 else
1055 adata(abfd).magic = o_magic;
1057 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1058 #if __GNUC__ >= 2
1059 fprintf (stderr, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1060 ({ char *str;
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;
1065 default: abort ();
1067 str;
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);
1075 #endif
1076 #endif
1078 switch (adata(abfd).magic)
1080 case o_magic:
1081 adjust_o_magic (abfd, execp);
1082 break;
1083 case z_magic:
1084 adjust_z_magic (abfd, execp);
1085 break;
1086 case n_magic:
1087 adjust_n_magic (abfd, execp);
1088 break;
1089 default:
1090 abort ();
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);
1100 #endif
1102 return TRUE;
1105 /* Called by the BFD in response to a bfd_make_section request. */
1107 bfd_boolean
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);
1139 bfd_boolean
1140 NAME (aout, set_section_contents) (bfd *abfd,
1141 sec_ptr section,
1142 const void * location,
1143 file_ptr offset,
1144 bfd_size_type count)
1146 file_ptr text_end;
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))
1152 return FALSE;
1155 if (section == obj_bsssec (abfd))
1157 bfd_set_error (bfd_error_no_contents);
1158 return FALSE;
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);
1168 return FALSE;
1171 if (count != 0)
1173 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1174 || bfd_bwrite (location, count, abfd) != count)
1175 return FALSE;
1178 return TRUE;
1181 /* Read the external symbols from an a.out file. */
1183 static bfd_boolean
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;
1193 #ifdef USE_MMAP
1194 if (! bfd_get_file_window (abfd, obj_sym_filepos (abfd),
1195 exec_hdr (abfd)->a_syms,
1196 &obj_aout_sym_window (abfd), TRUE))
1197 return FALSE;
1198 syms = (struct external_nlist *) obj_aout_sym_window (abfd).data;
1199 #else
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)
1205 return FALSE;
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))
1211 free (syms);
1212 return FALSE;
1214 #endif
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;
1225 char *strings;
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))
1231 return FALSE;
1232 stringsize = H_GET_32 (abfd, string_chars);
1234 #ifdef USE_MMAP
1235 if (! bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize,
1236 &obj_aout_string_window (abfd), TRUE))
1237 return FALSE;
1238 strings = (char *) obj_aout_string_window (abfd).data;
1239 #else
1240 strings = bfd_malloc (stringsize + 1);
1241 if (strings == NULL)
1242 return FALSE;
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)
1248 free (strings);
1249 return FALSE;
1251 #endif
1252 /* Ensure that a zero index yields an empty string. */
1253 strings[0] = '\0';
1255 strings[stringsize - 1] = 0;
1257 obj_aout_external_strings (abfd) = strings;
1258 obj_aout_external_string_size (abfd) = stringsize;
1261 return TRUE;
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. */
1269 static bfd_boolean
1270 translate_from_native_sym_flags (bfd *abfd,
1271 aout_symbol_type *cache_ptr)
1273 flagword visible;
1275 if (cache_ptr->type == N_FN)
1277 asection *sec;
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)
1285 case N_TEXT:
1286 case N_FN:
1287 sec = obj_textsec (abfd);
1288 break;
1289 case N_DATA:
1290 sec = obj_datasec (abfd);
1291 break;
1292 case N_BSS:
1293 sec = obj_bsssec (abfd);
1294 break;
1295 default:
1296 case N_ABS:
1297 sec = bfd_abs_section_ptr;
1298 break;
1301 cache_ptr->symbol.section = sec;
1302 cache_ptr->symbol.value -= sec->vma;
1304 return TRUE;
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;
1311 else
1312 visible = BSF_GLOBAL;
1314 switch (cache_ptr->type)
1316 default:
1317 case N_ABS: case N_ABS | N_EXT:
1318 cache_ptr->symbol.section = bfd_abs_section_ptr;
1319 cache_ptr->symbol.flags = visible;
1320 break;
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;
1329 else
1331 cache_ptr->symbol.flags = 0;
1332 cache_ptr->symbol.section = bfd_und_section_ptr;
1334 break;
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;
1340 break;
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;
1346 break;
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;
1352 break;
1355 return TRUE;
1358 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1360 static bfd_boolean
1361 translate_to_native_sym_flags (bfd *abfd,
1362 asymbol *cache_ptr,
1363 struct external_nlist *sym_pointer)
1365 bfd_vma value = cache_ptr->value;
1366 asection *sec;
1367 bfd_vma off;
1369 /* Mask out any existing type bits in case copying from one section
1370 to another. */
1371 sym_pointer->e_type[0] &= ~N_TYPE;
1373 sec = bfd_get_section (cache_ptr);
1374 off = 0;
1376 if (sec == NULL)
1378 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1379 file. */
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);
1384 return FALSE;
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;
1405 else
1407 (*_bfd_error_handler)
1408 ("%B: can not represent section `%A' in a.out object file format",
1409 abfd, sec);
1410 bfd_set_error (bfd_error_nonrepresentable_section);
1411 return FALSE;
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);
1424 return TRUE;
1427 /* Native-level interface to symbols. */
1429 asymbol *
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)
1436 return NULL;
1437 new_symbol_type->symbol.the_bfd = abfd;
1439 return &new_symbol_type->symbol;
1442 /* Translate a set of internal symbols into external symbols. */
1444 bfd_boolean
1445 NAME (aout, translate_symbol_table) (bfd *abfd,
1446 aout_symbol_type *in,
1447 struct external_nlist *ext,
1448 bfd_size_type count,
1449 char *str,
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++)
1458 bfd_vma x;
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;
1472 else
1473 return FALSE;
1475 in->symbol.value = GET_SWORD (abfd, ext->e_value);
1476 /* TODO: is 0 a safe value here? */
1477 in->desc = 0;
1478 in->other = 0;
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))
1483 return FALSE;
1485 if (dynamic)
1486 in->symbol.flags |= BSF_DYNAMIC;
1489 return TRUE;
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. */
1496 bfd_boolean
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)
1505 return TRUE;
1507 old_external_syms = obj_aout_external_syms (abfd);
1509 if (! aout_get_external_symbols (abfd))
1510 return FALSE;
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)
1516 return FALSE;
1518 /* Convert from external symbol information to internal. */
1519 if (! (NAME (aout, translate_symbol_table)
1520 (abfd, cached,
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),
1525 FALSE)))
1527 free (cached);
1528 return FALSE;
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)
1542 #ifdef USE_MMAP
1543 bfd_free_window (&obj_aout_sym_window (abfd));
1544 #else
1545 free (obj_aout_external_syms (abfd));
1546 #endif
1547 obj_aout_external_syms (abfd) = NULL;
1550 return TRUE;
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
1557 strings.
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
1563 already present. */
1565 static INLINE bfd_size_type
1566 add_to_stringtab (bfd *abfd,
1567 struct bfd_strtab_hash *tab,
1568 const char *str,
1569 bfd_boolean copy)
1571 bfd_boolean hash;
1572 bfd_size_type str_index;
1574 /* An index of 0 always means the empty string. */
1575 if (str == 0 || *str == '\0')
1576 return 0;
1578 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1579 doesn't understand a hashed string table. */
1580 hash = TRUE;
1581 if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1582 hash = FALSE;
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;
1591 return str_index;
1594 /* Write out a strtab. ABFD is already at the right location in the
1595 file. */
1597 static bfd_boolean
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)
1605 != BYTES_IN_LONG)
1606 return FALSE;
1608 return _bfd_stringtab_emit (abfd, tab);
1611 bfd_boolean
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 ();
1619 if (strtab == NULL)
1620 return FALSE;
1622 for (count = 0; count < bfd_get_symcount (abfd); count++)
1624 asymbol *g = generic[count];
1625 bfd_size_type indx;
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)
1632 goto error_return;
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);
1637 else
1638 H_PUT_8 (abfd, 0, nsp.e_type);
1640 if (! translate_to_native_sym_flags (abfd, g, &nsp))
1641 goto error_return;
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)
1647 goto error_return;
1649 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1650 here, at the end. */
1651 g->KEEPIT = count;
1654 if (! emit_stringtab (abfd, strtab))
1655 goto error_return;
1657 _bfd_stringtab_free (strtab);
1659 return TRUE;
1661 error_return:
1662 _bfd_stringtab_free (strtab);
1663 return FALSE;
1667 long
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))
1674 return -1;
1676 for (symbase = obj_aout_symbols (abfd); counter++ < bfd_get_symcount (abfd);)
1677 *(location++) = (asymbol *)(symbase++);
1678 *location++ =0;
1679 return bfd_get_symcount (abfd);
1683 /* Output extended relocation information to a file in target byte order. */
1685 static void
1686 pdp11_aout_swap_reloc_out (bfd *abfd, arelent *g, bfd_byte *natptr)
1688 int r_index;
1689 int r_pcrel;
1690 int reloc_entry;
1691 int r_type;
1692 asymbol *sym = *(g->sym_ptr_ptr);
1693 asection *output_section = sym->section->output_section;
1695 if (g->addend != 0)
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))
1701 r_type = RABS;
1702 else if (output_section == obj_textsec (abfd))
1703 r_type = RTEXT;
1704 else if (output_section == obj_datasec (abfd))
1705 r_type = RDATA;
1706 else if (output_section == obj_bsssec (abfd))
1707 r_type = RBSS;
1708 else if (bfd_is_und_section (output_section))
1709 r_type = REXT;
1710 else if (bfd_is_com_section (output_section))
1711 r_type = REXT;
1712 else
1713 r_type = -1;
1715 BFD_ASSERT (r_type != -1);
1717 if (r_type == RABS)
1718 r_index = 0;
1719 else
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) \
1737 if (r_extern) \
1739 /* Undefined symbol. */ \
1740 cache_ptr->sym_ptr_ptr = symbols + r_index; \
1741 cache_ptr->addend = ad; \
1743 else \
1745 /* Defined, section relative. replace symbol with pointer to \
1746 symbol which points to section. */ \
1747 switch (r_index) \
1749 case N_TEXT: \
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; \
1753 break; \
1754 case N_DATA: \
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; \
1758 break; \
1759 case N_BSS: \
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; \
1763 break; \
1764 default: \
1765 case N_ABS: \
1766 case N_ABS | N_EXT: \
1767 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1768 cache_ptr->addend = ad; \
1769 break; \
1773 static void
1774 pdp11_aout_swap_reloc_in (bfd * abfd,
1775 bfd_byte * bytes,
1776 arelent * cache_ptr,
1777 bfd_size_type offset,
1778 asymbol ** symbols,
1779 bfd_size_type symcount)
1781 struct aoutdata *su = &(abfd->tdata.aout_data->a);
1782 unsigned int r_index;
1783 int reloc_entry;
1784 int r_extern;
1785 int r_pcrel;
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)
1795 r_index = N_ABS;
1796 else
1797 r_index = RINDEX (reloc_entry);
1799 /* r_extern reflects whether the symbol the reloc is against is
1800 local or global. */
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. */
1807 r_extern = 0;
1808 r_index = N_ABS;
1811 MOVE_ADDRESS(0);
1814 /* Read and swap the relocs for a section. */
1816 bfd_boolean
1817 NAME (aout, slurp_reloc_table) (bfd *abfd, sec_ptr asect, asymbol **symbols)
1819 bfd_byte *rptr;
1820 bfd_size_type count;
1821 bfd_size_type reloc_size;
1822 void * relocs;
1823 arelent *reloc_cache;
1824 size_t each_size;
1825 unsigned int counter = 0;
1826 arelent *cache_ptr;
1828 if (asect->relocation)
1829 return TRUE;
1831 if (asect->flags & SEC_CONSTRUCTOR)
1832 return TRUE;
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))
1839 reloc_size = 0;
1840 else
1842 bfd_set_error (bfd_error_invalid_operation);
1843 return FALSE;
1846 if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
1847 return FALSE;
1849 each_size = obj_reloc_entry_size (abfd);
1851 relocs = bfd_malloc (reloc_size);
1852 if (relocs == NULL && reloc_size != 0)
1853 return FALSE;
1855 if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
1857 free (relocs);
1858 return FALSE;
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++)
1869 int x;
1871 x = GET_WORD (abfd, (char *) relocs + each_size * counter);
1872 if (x != 0)
1873 real_count++;
1876 count = real_count;
1879 reloc_cache = bfd_zmalloc (count * sizeof (arelent));
1880 if (reloc_cache == NULL && count != 0)
1881 return FALSE;
1883 cache_ptr = reloc_cache;
1885 rptr = relocs;
1886 for (counter = 0;
1887 counter < count;
1888 counter++, rptr += RELOC_SIZE, cache_ptr++)
1890 while (GET_WORD (abfd, (void *) rptr) == 0)
1892 rptr += RELOC_SIZE;
1893 if ((char *) rptr >= (char *) relocs + reloc_size)
1894 goto done;
1897 pdp11_aout_swap_reloc_in (abfd, rptr, cache_ptr,
1898 (bfd_size_type) ((char *) rptr - (char *) relocs),
1899 symbols,
1900 (bfd_size_type) bfd_get_symcount (abfd));
1902 done:
1903 /* Just in case, if rptr >= relocs + reloc_size should happen
1904 too early. */
1905 BFD_ASSERT (counter == count);
1907 free (relocs);
1909 asect->relocation = reloc_cache;
1910 asect->reloc_count = cache_ptr - reloc_cache;
1912 return TRUE;
1915 /* Write out a relocation section into an object file. */
1917 bfd_boolean
1918 NAME (aout, squirt_out_relocs) (bfd *abfd, asection *section)
1920 arelent **generic;
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);
1927 if (!native)
1928 return FALSE;
1930 generic = section->orelocation;
1931 if (generic != NULL)
1933 while (count > 0)
1935 bfd_byte *r;
1937 r = native + (*generic)->address;
1938 pdp11_aout_swap_reloc_out (abfd, *generic, r);
1939 count--;
1940 generic++;
1944 if (bfd_bwrite ((void *) native, natsize, abfd) != natsize)
1946 bfd_release (abfd, native);
1947 return FALSE;
1950 bfd_release (abfd, native);
1951 return TRUE;
1954 /* This is stupid. This function should be a boolean predicate. */
1956 long
1957 NAME (aout, canonicalize_reloc) (bfd *abfd,
1958 sec_ptr section,
1959 arelent **relptr,
1960 asymbol **symbols)
1962 arelent *tblptr = section->relocation;
1963 unsigned int count;
1965 if (section == obj_bsssec (abfd))
1967 *relptr = NULL;
1968 return 0;
1971 if (!(tblptr || NAME (aout, slurp_reloc_table)(abfd, section, symbols)))
1972 return -1;
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;
1984 else
1986 tblptr = section->relocation;
1988 for (count = 0; count++ < section->reloc_count;)
1989 *relptr++ = tblptr++;
1992 *relptr = 0;
1994 return section->reloc_count;
1997 long
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);
2003 return -1;
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))
2012 + 1));
2014 if (asect == obj_textsec (abfd))
2015 return (sizeof (arelent *)
2016 * ((exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd))
2017 + 1));
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))
2025 return 0;
2027 bfd_set_error (bfd_error_invalid_operation);
2028 return -1;
2032 long
2033 NAME (aout, get_symtab_upper_bound) (bfd *abfd)
2035 if (!NAME (aout, slurp_symbol_table) (abfd))
2036 return -1;
2038 return (bfd_get_symcount (abfd) + 1) * (sizeof (aout_symbol_type *));
2041 alent *
2042 NAME (aout, get_lineno) (bfd * abfd ATTRIBUTE_UNUSED,
2043 asymbol * symbol ATTRIBUTE_UNUSED)
2045 return NULL;
2048 void
2049 NAME (aout, get_symbol_info) (bfd * abfd ATTRIBUTE_UNUSED,
2050 asymbol *symbol,
2051 symbol_info *ret)
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);
2064 stab_name = buf;
2066 ret->type = '-';
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;
2074 void
2075 NAME (aout, print_symbol) (bfd * abfd,
2076 void * afile,
2077 asymbol *symbol,
2078 bfd_print_symbol_type how)
2080 FILE *file = (FILE *) afile;
2082 switch (how)
2084 case bfd_print_symbol_name:
2085 if (symbol->name)
2086 fprintf(file,"%s", symbol->name);
2087 break;
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));
2093 break;
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",
2101 section_name,
2102 (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2103 (unsigned) (aout_symbol (symbol)->other & 0xff),
2104 (unsigned) (aout_symbol (symbol)->type & 0xff));
2105 if (symbol->name)
2106 fprintf(file," %s", symbol->name);
2108 break;
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. */
2121 long
2122 NAME (aout, read_minisymbols) (bfd *abfd,
2123 bfd_boolean dynamic,
2124 void * *minisymsp,
2125 unsigned int *sizep)
2127 if (dynamic)
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))
2133 return -1;
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
2143 ourselves. */
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. */
2154 asymbol *
2155 NAME (aout, minisymbol_to_symbol) (bfd *abfd,
2156 bfd_boolean dynamic,
2157 const void * minisym,
2158 asymbol *sym)
2160 if (dynamic
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)
2168 (abfd,
2169 (aout_symbol_type *) sym,
2170 (struct external_nlist *) minisym,
2171 (bfd_size_type) 1,
2172 obj_aout_external_strings (abfd),
2173 obj_aout_external_string_size (abfd),
2174 FALSE)))
2175 return NULL;
2177 return sym;
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
2182 wanted location. */
2184 bfd_boolean
2185 NAME (aout, find_nearest_line) (bfd *abfd,
2186 asection *section,
2187 asymbol **symbols,
2188 bfd_vma offset,
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. */
2194 asymbol **p;
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;
2201 asymbol *func = 0;
2202 size_t filelen, funclen;
2203 char *buf;
2205 *filename_ptr = abfd->filename;
2206 *functionname_ptr = 0;
2207 *line_ptr = 0;
2209 if (symbols != NULL)
2211 for (p = symbols; *p; p++)
2213 aout_symbol_type *q = (aout_symbol_type *)(*p);
2214 next:
2215 switch (q->type)
2217 case N_TEXT:
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
2221 number. */
2222 if (q->symbol.value <= offset
2223 && ((q->symbol.value > low_line_vma
2224 && (line_file_name != NULL
2225 || *line_ptr != 0))
2226 || (q->symbol.value > low_func_vma
2227 && func != NULL)))
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)
2236 *line_ptr = 0;
2237 line_file_name = NULL;
2239 if (q->symbol.value > low_func_vma)
2240 func = NULL;
2243 break;
2245 case N_SO:
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)
2253 *line_ptr = 0;
2254 line_file_name = NULL;
2256 if (q->symbol.value > low_func_vma)
2257 func = NULL;
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. */
2262 p++;
2263 if (*p == NULL)
2264 break;
2265 q = (aout_symbol_type *)(*p);
2266 if (q->type != (int) N_SO)
2267 goto next;
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)
2273 goto done;
2274 break;
2275 case N_SOL:
2276 current_file_name = q->symbol.name;
2277 break;
2279 case N_SLINE:
2280 case N_DSLINE:
2281 case N_BSLINE:
2282 /* We'll keep this if it resolves nearer than the one we have
2283 already. */
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;
2291 break;
2293 case N_FUN:
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)
2303 goto done;
2305 break;
2310 done:
2311 if (*line_ptr != 0)
2312 main_file_name = line_file_name;
2314 if (main_file_name == NULL
2315 || main_file_name[0] == '/'
2316 || directory_name == NULL)
2317 filelen = 0;
2318 else
2319 filelen = strlen (directory_name) + strlen (main_file_name);
2320 if (func == NULL)
2321 funclen = 0;
2322 else
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;
2329 else
2331 buf = bfd_malloc ((bfd_size_type) filelen + funclen + 3);
2332 adata (abfd).line_buf = buf;
2333 if (buf == NULL)
2334 return FALSE;
2337 if (main_file_name != NULL)
2339 if (main_file_name[0] == '/' || directory_name == NULL)
2340 *filename_ptr = main_file_name;
2341 else
2343 sprintf (buf, "%s%s", directory_name, main_file_name);
2344 *filename_ptr = buf;
2345 buf += filelen + 1;
2349 if (func)
2351 const char *function = func->name;
2352 char *colon;
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);
2359 else
2361 buf[0] = bfd_get_symbol_leading_char (abfd);
2362 strcpy (buf + 1, function);
2365 /* Have to remove : stuff. */
2366 colon = strchr (buf, ':');
2367 if (colon != NULL)
2368 *colon = '\0';
2369 *functionname_ptr = buf;
2372 return TRUE;
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. */
2385 bfd_boolean
2386 NAME (aout, bfd_free_cached_info) (bfd *abfd)
2388 asection *o;
2390 if (bfd_get_format (abfd) != bfd_object)
2391 return TRUE;
2393 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2394 BFCI_FREE (obj_aout_symbols (abfd));
2396 #ifdef USE_MMAP
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;
2401 #else
2402 BFCI_FREE (obj_aout_external_syms (abfd));
2403 BFCI_FREE (obj_aout_external_strings (abfd));
2404 #endif
2405 for (o = abfd->sections; o != NULL; o = o->next)
2406 BFCI_FREE (o->relocation);
2407 #undef BFCI_FREE
2409 return TRUE;
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,
2417 const char *string)
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
2422 subclass. */
2423 if (ret == NULL)
2424 ret = bfd_hash_allocate (table, sizeof (* ret));
2425 if (ret == NULL)
2426 return NULL;
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);
2431 if (ret)
2433 /* Set local fields. */
2434 ret->written = FALSE;
2435 ret->indx = -1;
2438 return (struct bfd_hash_entry *) ret;
2441 /* Initialize an a.out link hash table. */
2443 bfd_boolean
2444 NAME (aout, link_hash_table_init) (struct aout_link_hash_table *table,
2445 bfd *abfd,
2446 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
2447 struct bfd_hash_table *,
2448 const char *),
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);
2463 if (ret == NULL)
2464 return NULL;
2465 if (! NAME (aout, link_hash_table_init) (ret, abfd,
2466 NAME (aout, link_hash_newfunc),
2467 sizeof (struct aout_link_hash_entry)))
2469 free (ret);
2470 return NULL;
2472 return &ret->root;
2475 /* Free up the internal symbols read from an a.out file. */
2477 static bfd_boolean
2478 aout_link_free_symbols (bfd *abfd)
2480 if (obj_aout_external_syms (abfd) != NULL)
2482 #ifdef USE_MMAP
2483 bfd_free_window (&obj_aout_sym_window (abfd));
2484 #else
2485 free ((void *) obj_aout_external_syms (abfd));
2486 #endif
2487 obj_aout_external_syms (abfd) = NULL;
2490 if (obj_aout_external_strings (abfd) != NULL)
2492 #ifdef USE_MMAP
2493 bfd_free_window (&obj_aout_string_window (abfd));
2494 #else
2495 free ((void *) obj_aout_external_strings (abfd));
2496 #endif
2497 obj_aout_external_strings (abfd) = NULL;
2499 return TRUE;
2502 /* Given an a.out BFD, add symbols to the global hash table as
2503 appropriate. */
2505 bfd_boolean
2506 NAME (aout, link_add_symbols) (bfd *abfd, struct bfd_link_info *info)
2508 switch (bfd_get_format (abfd))
2510 case bfd_object:
2511 return aout_link_add_object_symbols (abfd, info);
2512 case bfd_archive:
2513 return _bfd_generic_link_add_archive_symbols
2514 (abfd, info, aout_link_check_archive_element);
2515 default:
2516 bfd_set_error (bfd_error_wrong_format);
2517 return FALSE;
2521 /* Add symbols from an a.out object file. */
2523 static bfd_boolean
2524 aout_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
2526 if (! aout_get_external_symbols (abfd))
2527 return FALSE;
2528 if (! aout_link_add_symbols (abfd, info))
2529 return FALSE;
2530 if (! info->keep_memory)
2532 if (! aout_link_free_symbols (abfd))
2533 return FALSE;
2535 return TRUE;
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). */
2545 static bfd_boolean
2546 aout_link_check_ar_symbols (bfd *abfd,
2547 struct bfd_link_info *info,
2548 bfd_boolean *pneeded,
2549 bfd **subsbfd)
2551 struct external_nlist *p;
2552 struct external_nlist *pend;
2553 char *strings;
2555 *pneeded = FALSE;
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);
2564 const char *name;
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
2569 below. */
2570 if ((type & N_EXT) == 0
2571 || type == N_FN)
2572 continue;
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. */
2579 if (h == NULL
2580 || (h->type != bfd_link_hash_undefined
2581 && h->type != bfd_link_hash_common))
2582 continue;
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
2594 int a;
2595 and this object file from the archive includes
2596 int a = 5;
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
2605 ->add_archive_element) (info, abfd, name, subsbfd))
2606 return FALSE;
2607 *pneeded = TRUE;
2608 return TRUE;
2611 if (type == (N_UNDF | N_EXT))
2613 bfd_vma value;
2615 value = GET_WORD (abfd, p->e_value);
2616 if (value != 0)
2618 /* This symbol is common in the object from the archive
2619 file. */
2620 if (h->type == bfd_link_hash_undefined)
2622 bfd *symbfd;
2623 unsigned int power;
2625 symbfd = h->u.undef.abfd;
2626 if (symbfd == NULL)
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
2633 ->add_archive_element) (info, abfd, name, subsbfd))
2634 return FALSE;
2635 *pneeded = TRUE;
2636 return TRUE;
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)
2644 return FALSE;
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
2651 file. */
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,
2658 "COMMON");
2660 else
2662 /* Adjust the size of the common symbol if
2663 necessary. */
2664 if (value > h->u.c.size)
2665 h->u.c.size = value;
2671 /* We do not need this object file. */
2672 return TRUE;
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. */
2680 static bfd_boolean
2681 aout_link_check_archive_element (bfd *abfd,
2682 struct bfd_link_info *info,
2683 bfd_boolean *pneeded)
2685 bfd *oldbfd;
2686 bfd_boolean needed;
2688 if (!aout_get_external_symbols (abfd))
2689 return FALSE;
2691 oldbfd = abfd;
2692 if (!aout_link_check_ar_symbols (abfd, info, pneeded, &abfd))
2693 return FALSE;
2695 needed = *pneeded;
2696 if (needed)
2698 /* Potentially, the add_archive_element hook may have set a
2699 substitute BFD for us. */
2700 if (abfd != oldbfd)
2702 if (!info->keep_memory
2703 && !aout_link_free_symbols (oldbfd))
2704 return FALSE;
2705 if (!aout_get_external_symbols (abfd))
2706 return FALSE;
2708 if (!aout_link_add_symbols (abfd, info))
2709 return FALSE;
2712 if (!info->keep_memory || !needed)
2714 if (!aout_link_free_symbols (abfd))
2715 return FALSE;
2718 return TRUE;
2721 /* Add all symbols from an object file to the hash table. */
2723 static bfd_boolean
2724 aout_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
2726 bfd_boolean (*add_one_symbol)
2727 (struct bfd_link_info *, bfd *, const char *, flagword, asection *,
2728 bfd_vma, const char *, bfd_boolean, bfd_boolean,
2729 struct bfd_link_hash_entry **);
2730 struct external_nlist *syms;
2731 bfd_size_type sym_count;
2732 char *strings;
2733 bfd_boolean copy;
2734 struct aout_link_hash_entry **sym_hash;
2735 struct external_nlist *p;
2736 struct external_nlist *pend;
2738 syms = obj_aout_external_syms (abfd);
2739 sym_count = obj_aout_external_sym_count (abfd);
2740 strings = obj_aout_external_strings (abfd);
2741 if (info->keep_memory)
2742 copy = FALSE;
2743 else
2744 copy = TRUE;
2746 if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
2748 if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
2749 (abfd, info, &syms, &sym_count, &strings)))
2750 return FALSE;
2753 /* We keep a list of the linker hash table entries that correspond
2754 to particular symbols. We could just look them up in the hash
2755 table, but keeping the list is more efficient. Perhaps this
2756 should be conditional on info->keep_memory. */
2757 sym_hash = bfd_alloc (abfd,
2758 sym_count * sizeof (struct aout_link_hash_entry *));
2759 if (sym_hash == NULL && sym_count != 0)
2760 return FALSE;
2761 obj_aout_sym_hashes (abfd) = sym_hash;
2763 add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
2764 if (add_one_symbol == NULL)
2765 add_one_symbol = _bfd_generic_link_add_one_symbol;
2767 p = syms;
2768 pend = p + sym_count;
2769 for (; p < pend; p++, sym_hash++)
2771 int type;
2772 const char *name;
2773 bfd_vma value;
2774 asection *section;
2775 flagword flags;
2776 const char *string;
2778 *sym_hash = NULL;
2780 type = H_GET_8 (abfd, p->e_type);
2782 name = strings + GET_WORD (abfd, p->e_strx);
2783 value = GET_WORD (abfd, p->e_value);
2784 flags = BSF_GLOBAL;
2785 string = NULL;
2786 switch (type)
2788 default:
2789 /* Anything else should be a debugging symbol. */
2790 BFD_ASSERT ((type & N_STAB) != 0);
2791 continue;
2793 case N_UNDF:
2794 case N_ABS:
2795 case N_TEXT:
2796 case N_DATA:
2797 case N_BSS:
2798 case N_REG:
2799 case N_FN:
2800 /* Ignore symbols that are not externally visible. */
2801 continue;
2803 case N_UNDF | N_EXT:
2804 if (value == 0)
2806 section = bfd_und_section_ptr;
2807 flags = 0;
2809 else
2810 section = bfd_com_section_ptr;
2811 break;
2812 case N_ABS | N_EXT:
2813 section = bfd_abs_section_ptr;
2814 break;
2815 case N_TEXT | N_EXT:
2816 section = obj_textsec (abfd);
2817 value -= bfd_get_section_vma (abfd, section);
2818 break;
2819 case N_DATA | N_EXT:
2820 /* Treat N_SETV symbols as N_DATA symbol; see comment in
2821 translate_from_native_sym_flags. */
2822 section = obj_datasec (abfd);
2823 value -= bfd_get_section_vma (abfd, section);
2824 break;
2825 case N_BSS | N_EXT:
2826 section = obj_bsssec (abfd);
2827 value -= bfd_get_section_vma (abfd, section);
2828 break;
2831 if (! ((*add_one_symbol)
2832 (info, abfd, name, flags, section, value, string, copy, FALSE,
2833 (struct bfd_link_hash_entry **) sym_hash)))
2834 return FALSE;
2836 /* Restrict the maximum alignment of a common symbol based on
2837 the architecture, since a.out has no way to represent
2838 alignment requirements of a section in a .o file. FIXME:
2839 This isn't quite right: it should use the architecture of the
2840 output file, not the input files. */
2841 if ((*sym_hash)->root.type == bfd_link_hash_common
2842 && ((*sym_hash)->root.u.c.p->alignment_power >
2843 bfd_get_arch_info (abfd)->section_align_power))
2844 (*sym_hash)->root.u.c.p->alignment_power =
2845 bfd_get_arch_info (abfd)->section_align_power;
2847 /* If this is a set symbol, and we are not building sets, then
2848 it is possible for the hash entry to not have been set. In
2849 such a case, treat the symbol as not globally defined. */
2850 if ((*sym_hash)->root.type == bfd_link_hash_new)
2852 BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
2853 *sym_hash = NULL;
2857 return TRUE;
2860 /* Look up an entry in an the header file hash table. */
2862 #define aout_link_includes_lookup(table, string, create, copy) \
2863 ((struct aout_link_includes_entry *) \
2864 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
2866 /* The function to create a new entry in the header file hash table. */
2868 static struct bfd_hash_entry *
2869 aout_link_includes_newfunc (struct bfd_hash_entry *entry,
2870 struct bfd_hash_table *table,
2871 const char *string)
2873 struct aout_link_includes_entry * ret =
2874 (struct aout_link_includes_entry *) entry;
2876 /* Allocate the structure if it has not already been allocated by a
2877 subclass. */
2878 if (ret == NULL)
2879 ret = bfd_hash_allocate (table,
2880 sizeof (struct aout_link_includes_entry));
2881 if (ret == NULL)
2882 return NULL;
2884 /* Call the allocation method of the superclass. */
2885 ret = ((struct aout_link_includes_entry *)
2886 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
2887 if (ret)
2888 /* Set local fields. */
2889 ret->totals = NULL;
2891 return (struct bfd_hash_entry *) ret;
2894 static bfd_boolean
2895 aout_link_write_other_symbol (struct aout_link_hash_entry *h, void * data)
2897 struct aout_final_link_info *finfo = (struct aout_final_link_info *) data;
2898 bfd *output_bfd;
2899 int type;
2900 bfd_vma val;
2901 struct external_nlist outsym;
2902 bfd_size_type indx;
2903 bfd_size_type amt;
2905 if (h->root.type == bfd_link_hash_warning)
2907 h = (struct aout_link_hash_entry *) h->root.u.i.link;
2908 if (h->root.type == bfd_link_hash_new)
2909 return TRUE;
2912 output_bfd = finfo->output_bfd;
2914 if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
2916 if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
2917 (output_bfd, finfo->info, h)))
2919 /* FIXME: No way to handle errors. */
2920 abort ();
2924 if (h->written)
2925 return TRUE;
2927 h->written = TRUE;
2929 /* An indx of -2 means the symbol must be written. */
2930 if (h->indx != -2
2931 && (finfo->info->strip == strip_all
2932 || (finfo->info->strip == strip_some
2933 && bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
2934 FALSE, FALSE) == NULL)))
2935 return TRUE;
2937 switch (h->root.type)
2939 default:
2940 abort ();
2941 /* Avoid variable not initialized warnings. */
2942 return TRUE;
2943 case bfd_link_hash_new:
2944 /* This can happen for set symbols when sets are not being
2945 built. */
2946 return TRUE;
2947 case bfd_link_hash_undefined:
2948 type = N_UNDF | N_EXT;
2949 val = 0;
2950 break;
2951 case bfd_link_hash_defined:
2952 case bfd_link_hash_defweak:
2954 asection *sec;
2956 sec = h->root.u.def.section->output_section;
2957 BFD_ASSERT (bfd_is_abs_section (sec)
2958 || sec->owner == output_bfd);
2959 if (sec == obj_textsec (output_bfd))
2960 type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
2961 else if (sec == obj_datasec (output_bfd))
2962 type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
2963 else if (sec == obj_bsssec (output_bfd))
2964 type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
2965 else
2966 type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
2967 type |= N_EXT;
2968 val = (h->root.u.def.value
2969 + sec->vma
2970 + h->root.u.def.section->output_offset);
2972 break;
2973 case bfd_link_hash_common:
2974 type = N_UNDF | N_EXT;
2975 val = h->root.u.c.size;
2976 break;
2977 case bfd_link_hash_undefweak:
2978 type = N_WEAKU;
2979 val = 0;
2980 case bfd_link_hash_indirect:
2981 case bfd_link_hash_warning:
2982 /* FIXME: Ignore these for now. The circumstances under which
2983 they should be written out are not clear to me. */
2984 return TRUE;
2987 H_PUT_8 (output_bfd, type, outsym.e_type);
2988 indx = add_to_stringtab (output_bfd, finfo->strtab, h->root.root.string,
2989 FALSE);
2990 if (indx == (bfd_size_type) -1)
2991 /* FIXME: No way to handle errors. */
2992 abort ();
2994 PUT_WORD (output_bfd, indx, outsym.e_strx);
2995 PUT_WORD (output_bfd, val, outsym.e_value);
2997 amt = EXTERNAL_NLIST_SIZE;
2998 if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0
2999 || bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt)
3000 /* FIXME: No way to handle errors. */
3001 abort ();
3003 finfo->symoff += amt;
3004 h->indx = obj_aout_external_sym_count (output_bfd);
3005 ++obj_aout_external_sym_count (output_bfd);
3007 return TRUE;
3010 /* Handle a link order which is supposed to generate a reloc. */
3012 static bfd_boolean
3013 aout_link_reloc_link_order (struct aout_final_link_info *finfo,
3014 asection *o,
3015 struct bfd_link_order *p)
3017 struct bfd_link_order_reloc *pr;
3018 int r_index;
3019 int r_extern;
3020 reloc_howto_type *howto;
3021 file_ptr *reloff_ptr;
3022 struct reloc_std_external srel;
3023 void * rel_ptr;
3024 bfd_size_type rel_size;
3026 pr = p->u.reloc.p;
3028 if (p->type == bfd_section_reloc_link_order)
3030 r_extern = 0;
3031 if (bfd_is_abs_section (pr->u.section))
3032 r_index = N_ABS | N_EXT;
3033 else
3035 BFD_ASSERT (pr->u.section->owner == finfo->output_bfd);
3036 r_index = pr->u.section->target_index;
3039 else
3041 struct aout_link_hash_entry *h;
3043 BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
3044 r_extern = 1;
3045 h = ((struct aout_link_hash_entry *)
3046 bfd_wrapped_link_hash_lookup (finfo->output_bfd, finfo->info,
3047 pr->u.name, FALSE, FALSE, TRUE));
3048 if (h != NULL
3049 && h->indx >= 0)
3050 r_index = h->indx;
3051 else if (h != NULL)
3053 /* We decided to strip this symbol, but it turns out that we
3054 can't. Note that we lose the other and desc information
3055 here. I don't think that will ever matter for a global
3056 symbol. */
3057 h->indx = -2;
3058 h->written = FALSE;
3059 if (! aout_link_write_other_symbol (h, (void *) finfo))
3060 return FALSE;
3061 r_index = h->indx;
3063 else
3065 if (! ((*finfo->info->callbacks->unattached_reloc)
3066 (finfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0)))
3067 return FALSE;
3068 r_index = 0;
3072 howto = bfd_reloc_type_lookup (finfo->output_bfd, pr->reloc);
3073 if (howto == 0)
3075 bfd_set_error (bfd_error_bad_value);
3076 return FALSE;
3079 if (o == obj_textsec (finfo->output_bfd))
3080 reloff_ptr = &finfo->treloff;
3081 else if (o == obj_datasec (finfo->output_bfd))
3082 reloff_ptr = &finfo->dreloff;
3083 else
3084 abort ();
3086 #ifdef MY_put_reloc
3087 MY_put_reloc(finfo->output_bfd, r_extern, r_index, p->offset, howto,
3088 &srel);
3089 #else
3091 int r_pcrel;
3092 int r_baserel;
3093 int r_jmptable;
3094 int r_relative;
3095 int r_length;
3097 fprintf (stderr, "TODO: line %d in bfd/pdp11.c\n", __LINE__);
3099 r_pcrel = howto->pc_relative;
3100 r_baserel = (howto->type & 8) != 0;
3101 r_jmptable = (howto->type & 16) != 0;
3102 r_relative = (howto->type & 32) != 0;
3103 r_length = howto->size;
3105 PUT_WORD (finfo->output_bfd, p->offset, srel.r_address);
3106 if (bfd_header_big_endian (finfo->output_bfd))
3108 srel.r_index[0] = r_index >> 16;
3109 srel.r_index[1] = r_index >> 8;
3110 srel.r_index[2] = r_index;
3111 srel.r_type[0] =
3112 ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
3113 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
3114 | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
3115 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
3116 | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
3117 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
3119 else
3121 srel.r_index[2] = r_index >> 16;
3122 srel.r_index[1] = r_index >> 8;
3123 srel.r_index[0] = r_index;
3124 srel.r_type[0] =
3125 ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
3126 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
3127 | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
3128 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
3129 | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
3130 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
3133 #endif
3134 rel_ptr = (void *) &srel;
3136 /* We have to write the addend into the object file, since
3137 standard a.out relocs are in place. It would be more
3138 reliable if we had the current contents of the file here,
3139 rather than assuming zeroes, but we can't read the file since
3140 it was opened using bfd_openw. */
3141 if (pr->addend != 0)
3143 bfd_size_type size;
3144 bfd_reloc_status_type r;
3145 bfd_byte *buf;
3146 bfd_boolean ok;
3148 size = bfd_get_reloc_size (howto);
3149 buf = bfd_zmalloc (size);
3150 if (buf == NULL)
3151 return FALSE;
3152 r = MY_relocate_contents (howto, finfo->output_bfd,
3153 pr->addend, buf);
3154 switch (r)
3156 case bfd_reloc_ok:
3157 break;
3158 default:
3159 case bfd_reloc_outofrange:
3160 abort ();
3161 case bfd_reloc_overflow:
3162 if (! ((*finfo->info->callbacks->reloc_overflow)
3163 (finfo->info, NULL,
3164 (p->type == bfd_section_reloc_link_order
3165 ? bfd_section_name (finfo->output_bfd,
3166 pr->u.section)
3167 : pr->u.name),
3168 howto->name, pr->addend, NULL,
3169 (asection *) NULL, (bfd_vma) 0)))
3171 free (buf);
3172 return FALSE;
3174 break;
3176 ok = bfd_set_section_contents (finfo->output_bfd, o,
3177 (void *) buf,
3178 (file_ptr) p->offset,
3179 size);
3180 free (buf);
3181 if (! ok)
3182 return FALSE;
3185 rel_size = obj_reloc_entry_size (finfo->output_bfd);
3186 if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
3187 || bfd_bwrite (rel_ptr, rel_size, finfo->output_bfd) != rel_size)
3188 return FALSE;
3190 *reloff_ptr += rel_size;
3192 /* Assert that the relocs have not run into the symbols, and that n
3193 the text relocs have not run into the data relocs. */
3194 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
3195 && (reloff_ptr != &finfo->treloff
3196 || (*reloff_ptr
3197 <= obj_datasec (finfo->output_bfd)->rel_filepos)));
3199 return TRUE;
3202 /* Get the section corresponding to a reloc index. */
3204 static inline asection *
3205 aout_reloc_type_to_section (bfd *abfd, int type)
3207 switch (type)
3209 case RTEXT: return obj_textsec (abfd);
3210 case RDATA: return obj_datasec (abfd);
3211 case RBSS: return obj_bsssec (abfd);
3212 case RABS: return bfd_abs_section_ptr;
3213 case REXT: return bfd_und_section_ptr;
3214 default: abort ();
3218 static bfd_boolean
3219 pdp11_aout_link_input_section (struct aout_final_link_info *finfo,
3220 bfd *input_bfd,
3221 asection *input_section,
3222 bfd_byte *relocs,
3223 bfd_size_type rel_size,
3224 bfd_byte *contents)
3226 bfd_boolean (*check_dynamic_reloc)
3227 (struct bfd_link_info *, bfd *, asection *,
3228 struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
3229 bfd_vma *);
3230 bfd *output_bfd;
3231 bfd_boolean relocatable;
3232 struct external_nlist *syms;
3233 char *strings;
3234 struct aout_link_hash_entry **sym_hashes;
3235 int *symbol_map;
3236 bfd_byte *rel;
3237 bfd_byte *rel_end;
3239 output_bfd = finfo->output_bfd;
3240 check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
3242 BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_SIZE);
3243 BFD_ASSERT (input_bfd->xvec->header_byteorder
3244 == output_bfd->xvec->header_byteorder);
3246 relocatable = finfo->info->relocatable;
3247 syms = obj_aout_external_syms (input_bfd);
3248 strings = obj_aout_external_strings (input_bfd);
3249 sym_hashes = obj_aout_sym_hashes (input_bfd);
3250 symbol_map = finfo->symbol_map;
3252 rel = relocs;
3253 rel_end = rel + rel_size;
3254 for (; rel < rel_end; rel += RELOC_SIZE)
3256 bfd_vma r_addr;
3257 int r_index;
3258 int r_type;
3259 int r_pcrel;
3260 int r_extern;
3261 reloc_howto_type *howto;
3262 struct aout_link_hash_entry *h = NULL;
3263 bfd_vma relocation;
3264 bfd_reloc_status_type r;
3265 int reloc_entry;
3267 reloc_entry = GET_WORD (input_bfd, (void *) rel);
3268 if (reloc_entry == 0)
3269 continue;
3272 unsigned int howto_idx;
3274 r_index = (reloc_entry & RIDXMASK) >> 4;
3275 r_type = reloc_entry & RTYPE;
3276 r_pcrel = reloc_entry & RELFLG;
3277 r_addr = (char *) rel - (char *) relocs;
3279 r_extern = (r_type == REXT);
3281 howto_idx = r_pcrel;
3282 BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_pdp11));
3283 howto = howto_table_pdp11 + howto_idx;
3286 if (relocatable)
3288 /* We are generating a relocatable output file, and must
3289 modify the reloc accordingly. */
3290 if (r_extern)
3292 /* If we know the symbol this relocation is against,
3293 convert it into a relocation against a section. This
3294 is what the native linker does. */
3295 h = sym_hashes[r_index];
3296 if (h != NULL
3297 && (h->root.type == bfd_link_hash_defined
3298 || h->root.type == bfd_link_hash_defweak))
3300 asection *output_section;
3302 /* Compute a new r_index. */
3303 output_section = h->root.u.def.section->output_section;
3304 if (output_section == obj_textsec (output_bfd))
3305 r_type = N_TEXT;
3306 else if (output_section == obj_datasec (output_bfd))
3307 r_type = N_DATA;
3308 else if (output_section == obj_bsssec (output_bfd))
3309 r_type = N_BSS;
3310 else
3311 r_type = N_ABS;
3313 /* Add the symbol value and the section VMA to the
3314 addend stored in the contents. */
3315 relocation = (h->root.u.def.value
3316 + output_section->vma
3317 + h->root.u.def.section->output_offset);
3319 else
3321 /* We must change r_index according to the symbol
3322 map. */
3323 r_index = symbol_map[r_index];
3325 if (r_index == -1)
3327 if (h != NULL)
3329 /* We decided to strip this symbol, but it
3330 turns out that we can't. Note that we
3331 lose the other and desc information here.
3332 I don't think that will ever matter for a
3333 global symbol. */
3334 if (h->indx < 0)
3336 h->indx = -2;
3337 h->written = FALSE;
3338 if (! aout_link_write_other_symbol (h,
3339 (void *) finfo))
3340 return FALSE;
3342 r_index = h->indx;
3344 else
3346 const char *name;
3348 name = strings + GET_WORD (input_bfd,
3349 syms[r_index].e_strx);
3350 if (! ((*finfo->info->callbacks->unattached_reloc)
3351 (finfo->info, name, input_bfd, input_section,
3352 r_addr)))
3353 return FALSE;
3354 r_index = 0;
3358 relocation = 0;
3361 /* Write out the new r_index value. */
3362 reloc_entry = GET_WORD (input_bfd, rel);
3363 reloc_entry &= RIDXMASK;
3364 reloc_entry |= r_index << 4;
3365 PUT_WORD (input_bfd, reloc_entry, rel);
3367 else
3369 asection *section;
3371 /* This is a relocation against a section. We must
3372 adjust by the amount that the section moved. */
3373 section = aout_reloc_type_to_section (input_bfd, r_type);
3374 relocation = (section->output_section->vma
3375 + section->output_offset
3376 - section->vma);
3379 /* Change the address of the relocation. */
3380 fprintf (stderr, "TODO: change the address of the relocation\n");
3382 /* Adjust a PC relative relocation by removing the reference
3383 to the original address in the section and including the
3384 reference to the new address. */
3385 if (r_pcrel)
3386 relocation -= (input_section->output_section->vma
3387 + input_section->output_offset
3388 - input_section->vma);
3390 #ifdef MY_relocatable_reloc
3391 MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr);
3392 #endif
3394 if (relocation == 0)
3395 r = bfd_reloc_ok;
3396 else
3397 r = MY_relocate_contents (howto,
3398 input_bfd, relocation,
3399 contents + r_addr);
3401 else
3403 bfd_boolean hundef;
3405 /* We are generating an executable, and must do a full
3406 relocation. */
3407 hundef = FALSE;
3408 if (r_extern)
3410 h = sym_hashes[r_index];
3412 if (h != NULL
3413 && (h->root.type == bfd_link_hash_defined
3414 || h->root.type == bfd_link_hash_defweak))
3416 relocation = (h->root.u.def.value
3417 + h->root.u.def.section->output_section->vma
3418 + h->root.u.def.section->output_offset);
3420 else if (h != NULL
3421 && h->root.type == bfd_link_hash_undefweak)
3422 relocation = 0;
3423 else
3425 hundef = TRUE;
3426 relocation = 0;
3429 else
3431 asection *section;
3433 section = aout_reloc_type_to_section (input_bfd, r_type);
3434 relocation = (section->output_section->vma
3435 + section->output_offset
3436 - section->vma);
3437 if (r_pcrel)
3438 relocation += input_section->vma;
3441 if (check_dynamic_reloc != NULL)
3443 bfd_boolean skip;
3445 if (! ((*check_dynamic_reloc)
3446 (finfo->info, input_bfd, input_section, h,
3447 (void *) rel, contents, &skip, &relocation)))
3448 return FALSE;
3449 if (skip)
3450 continue;
3453 /* Now warn if a global symbol is undefined. We could not
3454 do this earlier, because check_dynamic_reloc might want
3455 to skip this reloc. */
3456 if (hundef && ! finfo->info->shared)
3458 const char *name;
3460 if (h != NULL)
3461 name = h->root.root.string;
3462 else
3463 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
3464 if (! ((*finfo->info->callbacks->undefined_symbol)
3465 (finfo->info, name, input_bfd, input_section,
3466 r_addr, TRUE)))
3467 return FALSE;
3470 r = MY_final_link_relocate (howto,
3471 input_bfd, input_section,
3472 contents, r_addr, relocation,
3473 (bfd_vma) 0);
3476 if (r != bfd_reloc_ok)
3478 switch (r)
3480 default:
3481 case bfd_reloc_outofrange:
3482 abort ();
3483 case bfd_reloc_overflow:
3485 const char *name;
3487 if (h != NULL)
3488 name = NULL;
3489 else if (r_extern)
3490 name = strings + GET_WORD (input_bfd,
3491 syms[r_index].e_strx);
3492 else
3494 asection *s;
3496 s = aout_reloc_type_to_section (input_bfd, r_type);
3497 name = bfd_section_name (input_bfd, s);
3499 if (! ((*finfo->info->callbacks->reloc_overflow)
3500 (finfo->info, (h ? &h->root : NULL), name,
3501 howto->name, (bfd_vma) 0, input_bfd,
3502 input_section, r_addr)))
3503 return FALSE;
3505 break;
3510 return TRUE;
3513 /* Link an a.out section into the output file. */
3515 static bfd_boolean
3516 aout_link_input_section (struct aout_final_link_info *finfo,
3517 bfd *input_bfd,
3518 asection *input_section,
3519 file_ptr *reloff_ptr,
3520 bfd_size_type rel_size)
3522 bfd_size_type input_size;
3523 void * relocs;
3525 /* Get the section contents. */
3526 input_size = input_section->size;
3527 if (! bfd_get_section_contents (input_bfd, input_section,
3528 (void *) finfo->contents,
3529 (file_ptr) 0, input_size))
3530 return FALSE;
3532 /* Read in the relocs if we haven't already done it. */
3533 if (aout_section_data (input_section) != NULL
3534 && aout_section_data (input_section)->relocs != NULL)
3535 relocs = aout_section_data (input_section)->relocs;
3536 else
3538 relocs = finfo->relocs;
3539 if (rel_size > 0)
3541 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
3542 || bfd_bread (relocs, rel_size, input_bfd) != rel_size)
3543 return FALSE;
3547 /* Relocate the section contents. */
3548 if (! pdp11_aout_link_input_section (finfo, input_bfd, input_section,
3549 (bfd_byte *) relocs,
3550 rel_size, finfo->contents))
3551 return FALSE;
3553 /* Write out the section contents. */
3554 if (! bfd_set_section_contents (finfo->output_bfd,
3555 input_section->output_section,
3556 (void *) finfo->contents,
3557 (file_ptr) input_section->output_offset,
3558 input_size))
3559 return FALSE;
3561 /* If we are producing relocatable output, the relocs were
3562 modified, and we now write them out. */
3563 if (finfo->info->relocatable && rel_size > 0)
3565 if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
3566 return FALSE;
3567 if (bfd_bwrite (relocs, rel_size, finfo->output_bfd) != rel_size)
3568 return FALSE;
3569 *reloff_ptr += rel_size;
3571 /* Assert that the relocs have not run into the symbols, and
3572 that if these are the text relocs they have not run into the
3573 data relocs. */
3574 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
3575 && (reloff_ptr != &finfo->treloff
3576 || (*reloff_ptr
3577 <= obj_datasec (finfo->output_bfd)->rel_filepos)));
3580 return TRUE;
3583 /* Link an a.out input BFD into the output file. */
3585 static bfd_boolean
3586 aout_link_input_bfd (struct aout_final_link_info *finfo, bfd *input_bfd)
3588 BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
3590 /* If this is a dynamic object, it may need special handling. */
3591 if ((input_bfd->flags & DYNAMIC) != 0
3592 && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
3593 return ((*aout_backend_info (input_bfd)->link_dynamic_object)
3594 (finfo->info, input_bfd));
3596 /* Get the symbols. We probably have them already, unless
3597 finfo->info->keep_memory is FALSE. */
3598 if (! aout_get_external_symbols (input_bfd))
3599 return FALSE;
3601 /* Write out the symbols and get a map of the new indices. The map
3602 is placed into finfo->symbol_map. */
3603 if (! aout_link_write_symbols (finfo, input_bfd))
3604 return FALSE;
3606 /* Relocate and write out the sections. These functions use the
3607 symbol map created by aout_link_write_symbols. The linker_mark
3608 field will be set if these sections are to be included in the
3609 link, which will normally be the case. */
3610 if (obj_textsec (input_bfd)->linker_mark)
3612 if (! aout_link_input_section (finfo, input_bfd,
3613 obj_textsec (input_bfd),
3614 &finfo->treloff,
3615 exec_hdr (input_bfd)->a_trsize))
3616 return FALSE;
3618 if (obj_datasec (input_bfd)->linker_mark)
3620 if (! aout_link_input_section (finfo, input_bfd,
3621 obj_datasec (input_bfd),
3622 &finfo->dreloff,
3623 exec_hdr (input_bfd)->a_drsize))
3624 return FALSE;
3627 /* If we are not keeping memory, we don't need the symbols any
3628 longer. We still need them if we are keeping memory, because the
3629 strings in the hash table point into them. */
3630 if (! finfo->info->keep_memory)
3632 if (! aout_link_free_symbols (input_bfd))
3633 return FALSE;
3636 return TRUE;
3639 /* Do the final link step. This is called on the output BFD. The
3640 INFO structure should point to a list of BFDs linked through the
3641 link_next field which can be used to find each BFD which takes part
3642 in the output. Also, each section in ABFD should point to a list
3643 of bfd_link_order structures which list all the input sections for
3644 the output section. */
3646 bfd_boolean
3647 NAME (aout, final_link) (bfd *abfd,
3648 struct bfd_link_info *info,
3649 void (*callback) (bfd *, file_ptr *, file_ptr *, file_ptr *))
3651 struct aout_final_link_info aout_info;
3652 bfd_boolean includes_hash_initialized = FALSE;
3653 bfd *sub;
3654 bfd_size_type trsize, drsize;
3655 bfd_size_type max_contents_size;
3656 bfd_size_type max_relocs_size;
3657 bfd_size_type max_sym_count;
3658 bfd_size_type text_size;
3659 file_ptr text_end;
3660 struct bfd_link_order *p;
3661 asection *o;
3662 bfd_boolean have_link_order_relocs;
3664 if (info->shared)
3665 abfd->flags |= DYNAMIC;
3667 aout_info.info = info;
3668 aout_info.output_bfd = abfd;
3669 aout_info.contents = NULL;
3670 aout_info.relocs = NULL;
3671 aout_info.symbol_map = NULL;
3672 aout_info.output_syms = NULL;
3674 if (!bfd_hash_table_init_n (&aout_info.includes.root,
3675 aout_link_includes_newfunc,
3676 sizeof (struct aout_link_includes_entry),
3677 251))
3678 goto error_return;
3679 includes_hash_initialized = TRUE;
3681 /* Figure out the largest section size. Also, if generating
3682 relocatable output, count the relocs. */
3683 trsize = 0;
3684 drsize = 0;
3685 max_contents_size = 0;
3686 max_relocs_size = 0;
3687 max_sym_count = 0;
3688 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3690 size_t sz;
3692 if (info->relocatable)
3694 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3696 trsize += exec_hdr (sub)->a_trsize;
3697 drsize += exec_hdr (sub)->a_drsize;
3699 else
3701 /* FIXME: We need to identify the .text and .data sections
3702 and call get_reloc_upper_bound and canonicalize_reloc to
3703 work out the number of relocs needed, and then multiply
3704 by the reloc size. */
3705 (*_bfd_error_handler)
3706 ("%s: relocatable link from %s to %s not supported",
3707 bfd_get_filename (abfd),
3708 sub->xvec->name, abfd->xvec->name);
3709 bfd_set_error (bfd_error_invalid_operation);
3710 goto error_return;
3714 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3716 sz = obj_textsec (sub)->size;
3717 if (sz > max_contents_size)
3718 max_contents_size = sz;
3719 sz = obj_datasec (sub)->size;
3720 if (sz > max_contents_size)
3721 max_contents_size = sz;
3723 sz = exec_hdr (sub)->a_trsize;
3724 if (sz > max_relocs_size)
3725 max_relocs_size = sz;
3726 sz = exec_hdr (sub)->a_drsize;
3727 if (sz > max_relocs_size)
3728 max_relocs_size = sz;
3730 sz = obj_aout_external_sym_count (sub);
3731 if (sz > max_sym_count)
3732 max_sym_count = sz;
3736 if (info->relocatable)
3738 if (obj_textsec (abfd) != NULL)
3739 trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
3740 ->map_head.link_order)
3741 * obj_reloc_entry_size (abfd));
3742 if (obj_datasec (abfd) != NULL)
3743 drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
3744 ->map_head.link_order)
3745 * obj_reloc_entry_size (abfd));
3748 exec_hdr (abfd)->a_trsize = trsize;
3749 exec_hdr (abfd)->a_drsize = drsize;
3750 exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
3752 /* Adjust the section sizes and vmas according to the magic number.
3753 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3754 filepos for each section. */
3755 if (! NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
3756 goto error_return;
3758 /* The relocation and symbol file positions differ among a.out
3759 targets. We are passed a callback routine from the backend
3760 specific code to handle this.
3761 FIXME: At this point we do not know how much space the symbol
3762 table will require. This will not work for any (nonstandard)
3763 a.out target that needs to know the symbol table size before it
3764 can compute the relocation file positions. This may or may not
3765 be the case for the hp300hpux target, for example. */
3766 (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
3767 &aout_info.symoff);
3768 obj_textsec (abfd)->rel_filepos = aout_info.treloff;
3769 obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
3770 obj_sym_filepos (abfd) = aout_info.symoff;
3772 /* We keep a count of the symbols as we output them. */
3773 obj_aout_external_sym_count (abfd) = 0;
3775 /* We accumulate the string table as we write out the symbols. */
3776 aout_info.strtab = _bfd_stringtab_init ();
3777 if (aout_info.strtab == NULL)
3778 goto error_return;
3780 /* Allocate buffers to hold section contents and relocs. */
3781 aout_info.contents = bfd_malloc (max_contents_size);
3782 aout_info.relocs = bfd_malloc (max_relocs_size);
3783 aout_info.symbol_map = bfd_malloc (max_sym_count * sizeof (int *));
3784 aout_info.output_syms = bfd_malloc ((max_sym_count + 1)
3785 * sizeof (struct external_nlist));
3786 if ((aout_info.contents == NULL && max_contents_size != 0)
3787 || (aout_info.relocs == NULL && max_relocs_size != 0)
3788 || (aout_info.symbol_map == NULL && max_sym_count != 0)
3789 || aout_info.output_syms == NULL)
3790 goto error_return;
3792 /* If we have a symbol named __DYNAMIC, force it out now. This is
3793 required by SunOS. Doing this here rather than in sunos.c is a
3794 hack, but it's easier than exporting everything which would be
3795 needed. */
3797 struct aout_link_hash_entry *h;
3799 h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
3800 FALSE, FALSE, FALSE);
3801 if (h != NULL)
3802 aout_link_write_other_symbol (h, &aout_info);
3805 /* The most time efficient way to do the link would be to read all
3806 the input object files into memory and then sort out the
3807 information into the output file. Unfortunately, that will
3808 probably use too much memory. Another method would be to step
3809 through everything that composes the text section and write it
3810 out, and then everything that composes the data section and write
3811 it out, and then write out the relocs, and then write out the
3812 symbols. Unfortunately, that requires reading stuff from each
3813 input file several times, and we will not be able to keep all the
3814 input files open simultaneously, and reopening them will be slow.
3816 What we do is basically process one input file at a time. We do
3817 everything we need to do with an input file once--copy over the
3818 section contents, handle the relocation information, and write
3819 out the symbols--and then we throw away the information we read
3820 from it. This approach requires a lot of lseeks of the output
3821 file, which is unfortunate but still faster than reopening a lot
3822 of files.
3824 We use the output_has_begun field of the input BFDs to see
3825 whether we have already handled it. */
3826 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3827 sub->output_has_begun = FALSE;
3829 /* Mark all sections which are to be included in the link. This
3830 will normally be every section. We need to do this so that we
3831 can identify any sections which the linker has decided to not
3832 include. */
3833 for (o = abfd->sections; o != NULL; o = o->next)
3835 for (p = o->map_head.link_order; p != NULL; p = p->next)
3836 if (p->type == bfd_indirect_link_order)
3837 p->u.indirect.section->linker_mark = TRUE;
3840 have_link_order_relocs = FALSE;
3841 for (o = abfd->sections; o != NULL; o = o->next)
3843 for (p = o->map_head.link_order;
3844 p != NULL;
3845 p = p->next)
3847 if (p->type == bfd_indirect_link_order
3848 && (bfd_get_flavour (p->u.indirect.section->owner)
3849 == bfd_target_aout_flavour))
3851 bfd *input_bfd;
3853 input_bfd = p->u.indirect.section->owner;
3854 if (! input_bfd->output_has_begun)
3856 if (! aout_link_input_bfd (&aout_info, input_bfd))
3857 goto error_return;
3858 input_bfd->output_has_begun = TRUE;
3861 else if (p->type == bfd_section_reloc_link_order
3862 || p->type == bfd_symbol_reloc_link_order)
3863 /* These are handled below. */
3864 have_link_order_relocs = TRUE;
3865 else
3867 if (! _bfd_default_link_order (abfd, info, o, p))
3868 goto error_return;
3873 /* Write out any symbols that we have not already written out. */
3874 aout_link_hash_traverse (aout_hash_table (info),
3875 aout_link_write_other_symbol,
3876 (void *) &aout_info);
3878 /* Now handle any relocs we were asked to create by the linker.
3879 These did not come from any input file. We must do these after
3880 we have written out all the symbols, so that we know the symbol
3881 indices to use. */
3882 if (have_link_order_relocs)
3884 for (o = abfd->sections; o != NULL; o = o->next)
3886 for (p = o->map_head.link_order;
3887 p != NULL;
3888 p = p->next)
3890 if (p->type == bfd_section_reloc_link_order
3891 || p->type == bfd_symbol_reloc_link_order)
3893 if (! aout_link_reloc_link_order (&aout_info, o, p))
3894 goto error_return;
3900 if (aout_info.contents != NULL)
3902 free (aout_info.contents);
3903 aout_info.contents = NULL;
3905 if (aout_info.relocs != NULL)
3907 free (aout_info.relocs);
3908 aout_info.relocs = NULL;
3910 if (aout_info.symbol_map != NULL)
3912 free (aout_info.symbol_map);
3913 aout_info.symbol_map = NULL;
3915 if (aout_info.output_syms != NULL)
3917 free (aout_info.output_syms);
3918 aout_info.output_syms = NULL;
3920 if (includes_hash_initialized)
3922 bfd_hash_table_free (&aout_info.includes.root);
3923 includes_hash_initialized = FALSE;
3926 /* Finish up any dynamic linking we may be doing. */
3927 if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
3929 if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
3930 goto error_return;
3933 /* Update the header information. */
3934 abfd->symcount = obj_aout_external_sym_count (abfd);
3935 exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
3936 obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
3937 obj_textsec (abfd)->reloc_count =
3938 exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
3939 obj_datasec (abfd)->reloc_count =
3940 exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
3942 /* Write out the string table, unless there are no symbols. */
3943 if (abfd->symcount > 0)
3945 if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
3946 || ! emit_stringtab (abfd, aout_info.strtab))
3947 goto error_return;
3949 else if (obj_textsec (abfd)->reloc_count == 0
3950 && obj_datasec (abfd)->reloc_count == 0)
3952 bfd_byte b;
3954 b = 0;
3955 if (bfd_seek (abfd,
3956 (file_ptr) (obj_datasec (abfd)->filepos
3957 + exec_hdr (abfd)->a_data
3958 - 1),
3959 SEEK_SET) != 0
3960 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3961 goto error_return;
3964 return TRUE;
3966 error_return:
3967 if (aout_info.contents != NULL)
3968 free (aout_info.contents);
3969 if (aout_info.relocs != NULL)
3970 free (aout_info.relocs);
3971 if (aout_info.symbol_map != NULL)
3972 free (aout_info.symbol_map);
3973 if (aout_info.output_syms != NULL)
3974 free (aout_info.output_syms);
3975 if (includes_hash_initialized)
3976 bfd_hash_table_free (&aout_info.includes.root);
3977 return FALSE;
3980 /* Adjust and write out the symbols for an a.out file. Set the new
3981 symbol indices into a symbol_map. */
3983 static bfd_boolean
3984 aout_link_write_symbols (struct aout_final_link_info *finfo, bfd *input_bfd)
3986 bfd *output_bfd;
3987 bfd_size_type sym_count;
3988 char *strings;
3989 enum bfd_link_strip strip;
3990 enum bfd_link_discard discard;
3991 struct external_nlist *outsym;
3992 bfd_size_type strtab_index;
3993 struct external_nlist *sym;
3994 struct external_nlist *sym_end;
3995 struct aout_link_hash_entry **sym_hash;
3996 int *symbol_map;
3997 bfd_boolean pass;
3998 bfd_boolean skip_next;
4000 output_bfd = finfo->output_bfd;
4001 sym_count = obj_aout_external_sym_count (input_bfd);
4002 strings = obj_aout_external_strings (input_bfd);
4003 strip = finfo->info->strip;
4004 discard = finfo->info->discard;
4005 outsym = finfo->output_syms;
4007 /* First write out a symbol for this object file, unless we are
4008 discarding such symbols. */
4009 if (strip != strip_all
4010 && (strip != strip_some
4011 || bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
4012 FALSE, FALSE) != NULL)
4013 && discard != discard_all)
4015 H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
4016 strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4017 input_bfd->filename, FALSE);
4018 if (strtab_index == (bfd_size_type) -1)
4019 return FALSE;
4020 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4021 PUT_WORD (output_bfd,
4022 (bfd_get_section_vma (output_bfd,
4023 obj_textsec (input_bfd)->output_section)
4024 + obj_textsec (input_bfd)->output_offset),
4025 outsym->e_value);
4026 ++obj_aout_external_sym_count (output_bfd);
4027 ++outsym;
4030 pass = FALSE;
4031 skip_next = FALSE;
4032 sym = obj_aout_external_syms (input_bfd);
4033 sym_end = sym + sym_count;
4034 sym_hash = obj_aout_sym_hashes (input_bfd);
4035 symbol_map = finfo->symbol_map;
4036 memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
4037 for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
4039 const char *name;
4040 int type;
4041 struct aout_link_hash_entry *h;
4042 bfd_boolean skip;
4043 asection *symsec;
4044 bfd_vma val = 0;
4045 bfd_boolean copy;
4047 /* We set *symbol_map to 0 above for all symbols. If it has
4048 already been set to -1 for this symbol, it means that we are
4049 discarding it because it appears in a duplicate header file.
4050 See the N_BINCL code below. */
4051 if (*symbol_map == -1)
4052 continue;
4054 /* Initialize *symbol_map to -1, which means that the symbol was
4055 not copied into the output file. We will change it later if
4056 we do copy the symbol over. */
4057 *symbol_map = -1;
4059 type = H_GET_8 (input_bfd, sym->e_type);
4060 name = strings + GET_WORD (input_bfd, sym->e_strx);
4062 h = NULL;
4064 if (pass)
4066 /* Pass this symbol through. It is the target of an
4067 indirect or warning symbol. */
4068 val = GET_WORD (input_bfd, sym->e_value);
4069 pass = FALSE;
4071 else if (skip_next)
4073 /* Skip this symbol, which is the target of an indirect
4074 symbol that we have changed to no longer be an indirect
4075 symbol. */
4076 skip_next = FALSE;
4077 continue;
4079 else
4081 struct aout_link_hash_entry *hresolve;
4083 /* We have saved the hash table entry for this symbol, if
4084 there is one. Note that we could just look it up again
4085 in the hash table, provided we first check that it is an
4086 external symbol. */
4087 h = *sym_hash;
4089 /* Use the name from the hash table, in case the symbol was
4090 wrapped. */
4091 if (h != NULL)
4092 name = h->root.root.string;
4094 /* If this is an indirect or warning symbol, then change
4095 hresolve to the base symbol. We also change *sym_hash so
4096 that the relocation routines relocate against the real
4097 symbol. */
4098 hresolve = h;
4099 if (h != NULL
4100 && (h->root.type == bfd_link_hash_indirect
4101 || h->root.type == bfd_link_hash_warning))
4103 hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
4104 while (hresolve->root.type == bfd_link_hash_indirect
4105 || hresolve->root.type == bfd_link_hash_warning)
4106 hresolve = ((struct aout_link_hash_entry *)
4107 hresolve->root.u.i.link);
4108 *sym_hash = hresolve;
4111 /* If the symbol has already been written out, skip it. */
4112 if (h != NULL
4113 && h->root.type != bfd_link_hash_warning
4114 && h->written)
4116 if ((type & N_TYPE) == N_INDR
4117 || type == N_WARNING)
4118 skip_next = TRUE;
4119 *symbol_map = h->indx;
4120 continue;
4123 /* See if we are stripping this symbol. */
4124 skip = FALSE;
4125 switch (strip)
4127 case strip_none:
4128 break;
4129 case strip_debugger:
4130 if ((type & N_STAB) != 0)
4131 skip = TRUE;
4132 break;
4133 case strip_some:
4134 if (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
4135 == NULL)
4136 skip = TRUE;
4137 break;
4138 case strip_all:
4139 skip = TRUE;
4140 break;
4142 if (skip)
4144 if (h != NULL)
4145 h->written = TRUE;
4146 continue;
4149 /* Get the value of the symbol. */
4150 if ((type & N_TYPE) == N_TEXT
4151 || type == N_WEAKT)
4152 symsec = obj_textsec (input_bfd);
4153 else if ((type & N_TYPE) == N_DATA
4154 || type == N_WEAKD)
4155 symsec = obj_datasec (input_bfd);
4156 else if ((type & N_TYPE) == N_BSS
4157 || type == N_WEAKB)
4158 symsec = obj_bsssec (input_bfd);
4159 else if ((type & N_TYPE) == N_ABS
4160 || type == N_WEAKA)
4161 symsec = bfd_abs_section_ptr;
4162 else if (((type & N_TYPE) == N_INDR
4163 && (hresolve == NULL
4164 || (hresolve->root.type != bfd_link_hash_defined
4165 && hresolve->root.type != bfd_link_hash_defweak
4166 && hresolve->root.type != bfd_link_hash_common)))
4167 || type == N_WARNING)
4169 /* Pass the next symbol through unchanged. The
4170 condition above for indirect symbols is so that if
4171 the indirect symbol was defined, we output it with
4172 the correct definition so the debugger will
4173 understand it. */
4174 pass = TRUE;
4175 val = GET_WORD (input_bfd, sym->e_value);
4176 symsec = NULL;
4178 else if ((type & N_STAB) != 0)
4180 val = GET_WORD (input_bfd, sym->e_value);
4181 symsec = NULL;
4183 else
4185 /* If we get here with an indirect symbol, it means that
4186 we are outputting it with a real definition. In such
4187 a case we do not want to output the next symbol,
4188 which is the target of the indirection. */
4189 if ((type & N_TYPE) == N_INDR)
4190 skip_next = TRUE;
4192 symsec = NULL;
4194 /* We need to get the value from the hash table. We use
4195 hresolve so that if we have defined an indirect
4196 symbol we output the final definition. */
4197 if (h == NULL)
4199 switch (type & N_TYPE)
4201 case N_SETT:
4202 symsec = obj_textsec (input_bfd);
4203 break;
4204 case N_SETD:
4205 symsec = obj_datasec (input_bfd);
4206 break;
4207 case N_SETB:
4208 symsec = obj_bsssec (input_bfd);
4209 break;
4210 case N_SETA:
4211 symsec = bfd_abs_section_ptr;
4212 break;
4213 default:
4214 val = 0;
4215 break;
4218 else if (hresolve->root.type == bfd_link_hash_defined
4219 || hresolve->root.type == bfd_link_hash_defweak)
4221 asection *input_section;
4222 asection *output_section;
4224 /* This case usually means a common symbol which was
4225 turned into a defined symbol. */
4226 input_section = hresolve->root.u.def.section;
4227 output_section = input_section->output_section;
4228 BFD_ASSERT (bfd_is_abs_section (output_section)
4229 || output_section->owner == output_bfd);
4230 val = (hresolve->root.u.def.value
4231 + bfd_get_section_vma (output_bfd, output_section)
4232 + input_section->output_offset);
4234 /* Get the correct type based on the section. If
4235 this is a constructed set, force it to be
4236 globally visible. */
4237 if (type == N_SETT
4238 || type == N_SETD
4239 || type == N_SETB
4240 || type == N_SETA)
4241 type |= N_EXT;
4243 type &=~ N_TYPE;
4245 if (output_section == obj_textsec (output_bfd))
4246 type |= (hresolve->root.type == bfd_link_hash_defined
4247 ? N_TEXT
4248 : N_WEAKT);
4249 else if (output_section == obj_datasec (output_bfd))
4250 type |= (hresolve->root.type == bfd_link_hash_defined
4251 ? N_DATA
4252 : N_WEAKD);
4253 else if (output_section == obj_bsssec (output_bfd))
4254 type |= (hresolve->root.type == bfd_link_hash_defined
4255 ? N_BSS
4256 : N_WEAKB);
4257 else
4258 type |= (hresolve->root.type == bfd_link_hash_defined
4259 ? N_ABS
4260 : N_WEAKA);
4262 else if (hresolve->root.type == bfd_link_hash_common)
4263 val = hresolve->root.u.c.size;
4264 else if (hresolve->root.type == bfd_link_hash_undefweak)
4266 val = 0;
4267 type = N_WEAKU;
4269 else
4270 val = 0;
4272 if (symsec != NULL)
4273 val = (symsec->output_section->vma
4274 + symsec->output_offset
4275 + (GET_WORD (input_bfd, sym->e_value)
4276 - symsec->vma));
4278 /* If this is a global symbol set the written flag, and if
4279 it is a local symbol see if we should discard it. */
4280 if (h != NULL)
4282 h->written = TRUE;
4283 h->indx = obj_aout_external_sym_count (output_bfd);
4285 else if ((type & N_TYPE) != N_SETT
4286 && (type & N_TYPE) != N_SETD
4287 && (type & N_TYPE) != N_SETB
4288 && (type & N_TYPE) != N_SETA)
4290 switch (discard)
4292 case discard_none:
4293 case discard_sec_merge:
4294 break;
4295 case discard_l:
4296 if ((type & N_STAB) == 0
4297 && bfd_is_local_label_name (input_bfd, name))
4298 skip = TRUE;
4299 break;
4300 case discard_all:
4301 skip = TRUE;
4302 break;
4304 if (skip)
4306 pass = FALSE;
4307 continue;
4311 /* An N_BINCL symbol indicates the start of the stabs
4312 entries for a header file. We need to scan ahead to the
4313 next N_EINCL symbol, ignoring nesting, adding up all the
4314 characters in the symbol names, not including the file
4315 numbers in types (the first number after an open
4316 parenthesis). */
4317 if (type == N_BINCL)
4319 struct external_nlist *incl_sym;
4320 int nest;
4321 struct aout_link_includes_entry *incl_entry;
4322 struct aout_link_includes_totals *t;
4324 val = 0;
4325 nest = 0;
4326 for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++)
4328 int incl_type;
4330 incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
4331 if (incl_type == N_EINCL)
4333 if (nest == 0)
4334 break;
4335 --nest;
4337 else if (incl_type == N_BINCL)
4338 ++nest;
4339 else if (nest == 0)
4341 const char *s;
4343 s = strings + GET_WORD (input_bfd, incl_sym->e_strx);
4344 for (; *s != '\0'; s++)
4346 val += *s;
4347 if (*s == '(')
4349 /* Skip the file number. */
4350 ++s;
4351 while (ISDIGIT (*s))
4352 ++s;
4353 --s;
4359 /* If we have already included a header file with the
4360 same value, then replace this one with an N_EXCL
4361 symbol. */
4362 copy = ! finfo->info->keep_memory;
4363 incl_entry = aout_link_includes_lookup (&finfo->includes,
4364 name, TRUE, copy);
4365 if (incl_entry == NULL)
4366 return FALSE;
4367 for (t = incl_entry->totals; t != NULL; t = t->next)
4368 if (t->total == val)
4369 break;
4370 if (t == NULL)
4372 /* This is the first time we have seen this header
4373 file with this set of stabs strings. */
4374 t = bfd_hash_allocate (&finfo->includes.root,
4375 sizeof *t);
4376 if (t == NULL)
4377 return FALSE;
4378 t->total = val;
4379 t->next = incl_entry->totals;
4380 incl_entry->totals = t;
4382 else
4384 int *incl_map;
4386 /* This is a duplicate header file. We must change
4387 it to be an N_EXCL entry, and mark all the
4388 included symbols to prevent outputting them. */
4389 type = N_EXCL;
4391 nest = 0;
4392 for (incl_sym = sym + 1, incl_map = symbol_map + 1;
4393 incl_sym < sym_end;
4394 incl_sym++, incl_map++)
4396 int incl_type;
4398 incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
4399 if (incl_type == N_EINCL)
4401 if (nest == 0)
4403 *incl_map = -1;
4404 break;
4406 --nest;
4408 else if (incl_type == N_BINCL)
4409 ++nest;
4410 else if (nest == 0)
4411 *incl_map = -1;
4417 /* Copy this symbol into the list of symbols we are going to
4418 write out. */
4419 H_PUT_8 (output_bfd, type, outsym->e_type);
4420 copy = FALSE;
4421 if (! finfo->info->keep_memory)
4423 /* name points into a string table which we are going to
4424 free. If there is a hash table entry, use that string.
4425 Otherwise, copy name into memory. */
4426 if (h != NULL)
4427 name = h->root.root.string;
4428 else
4429 copy = TRUE;
4431 strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4432 name, copy);
4433 if (strtab_index == (bfd_size_type) -1)
4434 return FALSE;
4435 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4436 PUT_WORD (output_bfd, val, outsym->e_value);
4437 *symbol_map = obj_aout_external_sym_count (output_bfd);
4438 ++obj_aout_external_sym_count (output_bfd);
4439 ++outsym;
4442 /* Write out the output symbols we have just constructed. */
4443 if (outsym > finfo->output_syms)
4445 bfd_size_type size;
4447 if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
4448 return FALSE;
4449 size = outsym - finfo->output_syms;
4450 size *= EXTERNAL_NLIST_SIZE;
4451 if (bfd_bwrite ((void *) finfo->output_syms, size, output_bfd) != size)
4452 return FALSE;
4453 finfo->symoff += size;
4456 return TRUE;
4459 /* Write out a symbol that was not associated with an a.out input
4460 object. */
4462 static bfd_vma
4463 bfd_getp32 (const void *p)
4465 const bfd_byte *addr = p;
4466 unsigned long v;
4468 v = (unsigned long) addr[1] << 24;
4469 v |= (unsigned long) addr[0] << 16;
4470 v |= (unsigned long) addr[3] << 8;
4471 v |= (unsigned long) addr[2];
4472 return v;
4475 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
4477 static bfd_signed_vma
4478 bfd_getp_signed_32 (const void *p)
4480 const bfd_byte *addr = p;
4481 unsigned long v;
4483 v = (unsigned long) addr[1] << 24;
4484 v |= (unsigned long) addr[0] << 16;
4485 v |= (unsigned long) addr[3] << 8;
4486 v |= (unsigned long) addr[2];
4487 return COERCE32 (v);
4490 static void
4491 bfd_putp32 (bfd_vma data, void *p)
4493 bfd_byte *addr = p;
4495 addr[0] = (data >> 16) & 0xff;
4496 addr[1] = (data >> 24) & 0xff;
4497 addr[2] = (data >> 0) & 0xff;
4498 addr[3] = (data >> 8) & 0xff;
4501 const bfd_target MY (vec) =
4503 TARGETNAME, /* Name. */
4504 bfd_target_aout_flavour,
4505 BFD_ENDIAN_LITTLE, /* Target byte order (little). */
4506 BFD_ENDIAN_LITTLE, /* Target headers byte order (little). */
4507 (HAS_RELOC | EXEC_P | /* Object flags. */
4508 HAS_LINENO | HAS_DEBUG |
4509 HAS_SYMS | HAS_LOCALS | WP_TEXT),
4510 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
4511 MY_symbol_leading_char,
4512 AR_PAD_CHAR, /* AR_pad_char. */
4513 15, /* AR_max_namelen. */
4514 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
4515 bfd_getp32, bfd_getp_signed_32, bfd_putp32,
4516 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data. */
4517 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
4518 bfd_getp32, bfd_getp_signed_32, bfd_putp32,
4519 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Headers. */
4520 {_bfd_dummy_target, MY_object_p, /* bfd_check_format. */
4521 bfd_generic_archive_p, MY_core_file_p},
4522 {bfd_false, MY_mkobject, /* bfd_set_format. */
4523 _bfd_generic_mkarchive, bfd_false},
4524 {bfd_false, MY_write_object_contents, /* bfd_write_contents. */
4525 _bfd_write_archive_contents, bfd_false},
4527 BFD_JUMP_TABLE_GENERIC (MY),
4528 BFD_JUMP_TABLE_COPY (MY),
4529 BFD_JUMP_TABLE_CORE (MY),
4530 BFD_JUMP_TABLE_ARCHIVE (MY),
4531 BFD_JUMP_TABLE_SYMBOLS (MY),
4532 BFD_JUMP_TABLE_RELOCS (MY),
4533 BFD_JUMP_TABLE_WRITE (MY),
4534 BFD_JUMP_TABLE_LINK (MY),
4535 BFD_JUMP_TABLE_DYNAMIC (MY),
4537 /* Alternative_target. */
4538 NULL,
4540 (void *) MY_backend_data