Automatic date update in version.in
[external/binutils.git] / bfd / pdp11.c
1 /* BFD back-end for PDP-11 a.out binaries.
2    Copyright (C) 2001-2019 Free Software Foundation, Inc.
3
4    This file is part of BFD, the Binary File Descriptor library.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19    MA 02110-1301, USA. */
20
21
22 /* BFD backend for PDP-11, running 2.11BSD in particular.
23
24    This file was hacked up by looking hard at the existing vaxnetbsd
25    back end and the header files in 2.11BSD.
26
27    TODO
28    * support for V7 file formats
29    * support for overlay object files (see 2.11 a.out(5))
30    * support for old and very old archives
31    (see 2.11 ar(5), historical section)
32
33    Search for TODO to find other areas needing more work.  */
34
35 #define BYTES_IN_WORD   2
36 #define BYTES_IN_LONG   4
37 #define ARCH_SIZE       16
38 #undef TARGET_IS_BIG_ENDIAN_P
39
40 #define TARGET_PAGE_SIZE        256
41 #define SEGMENT__SIZE   TARGET_PAGE_SIZE
42
43 #define DEFAULT_ARCH    bfd_arch_pdp11
44 #define DEFAULT_MID     M_PDP11
45
46 /* Do not "beautify" the CONCAT* macro args.  Traditional C will not
47    remove whitespace added here, and thus will fail to concatenate
48    the tokens.  */
49 #define MY(OP) CONCAT2 (pdp11_aout_,OP)
50
51 /* This needs to start with a.out so GDB knows it is an a.out variant.  */
52 #define TARGETNAME "a.out-pdp11"
53
54 /* This is the normal load address for executables.  */
55 #define TEXT_START_ADDR         0
56
57 /* The header is not included in the text segment.  */
58 #define N_HEADER_IN_TEXT(x)     0
59
60 /* There is no flags field.  */
61 #define N_FLAGS(execp)          0
62
63 #define N_SET_FLAGS(execp, flags) do { } while (0)
64 #define N_BADMAG(x) (N_MAGIC(x) != OMAGIC       \
65                      && N_MAGIC(x) != NMAGIC    \
66                      && N_MAGIC(x) != ZMAGIC)
67
68 #include "sysdep.h"
69 #include <limits.h>
70 #include "bfd.h"
71
72 #define external_exec pdp11_external_exec
73 struct pdp11_external_exec
74 {
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.  */
84 };
85
86 #define EXEC_BYTES_SIZE (8 * 2)
87
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
99
100 #define A_FLAG_RELOC_STRIPPED   0x0001
101
102 #define external_nlist pdp11_external_nlist
103 struct pdp11_external_nlist
104 {
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.  */
110 };
111
112 #define EXTERNAL_NLIST_SIZE     8
113
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)
120
121 #define WRITE_HEADERS(abfd, execp) pdp11_aout_write_headers (abfd, execp)
122
123 #include "libbfd.h"
124 #include "libaout.h"
125
126 #define SWAP_MAGIC(ext) bfd_getl16 (ext)
127
128 #define MY_entry_is_text_address 1
129
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
133
134 #define MY_BFD_TARGET
135
136 #include "aout-target.h"
137
138 /* Start of modified aoutx.h.  */
139 #define KEEPIT udata.i
140
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"
146
147 #include "libaout.h"
148 #include "aout/aout64.h"
149 #include "aout/stab_gnu.h"
150 #include "aout/ar.h"
151
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.  */
170
171 #define RELOC_SIZE 2
172
173 #define RELFLG          0x0001  /* PC-relative flag.  */
174 #define RTYPE           0x000e  /* Type mask.  */
175 #define RIDXMASK        0xfff0  /* Index mask.  */
176
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.  */
182
183 #define RINDEX(x)       (((x) & 0xfff0) >> 4)
184
185 #ifndef MY_final_link_relocate
186 #define MY_final_link_relocate _bfd_final_link_relocate
187 #endif
188
189 #ifndef MY_relocate_contents
190 #define MY_relocate_contents _bfd_relocate_contents
191 #endif
192
193 /* A hash table used for header files with N_BINCL entries.  */
194
195 struct aout_link_includes_table
196 {
197   struct bfd_hash_table root;
198 };
199
200 /* A linked list of totals that we have found for a particular header
201    file.  */
202
203 struct aout_link_includes_totals
204 {
205   struct aout_link_includes_totals *next;
206   bfd_vma total;
207 };
208
209 /* An entry in the header file hash table.  */
210
211 struct aout_link_includes_entry
212 {
213   struct bfd_hash_entry root;
214   /* List of totals we have found for this file.  */
215   struct aout_link_includes_totals *totals;
216 };
217
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.  */
220
221 struct aout_final_link_info
222 {
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;
243 };
244
245 reloc_howto_type howto_table_pdp11[] =
246 {
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),
250 };
251
252 #define TABLE_SIZE(TABLE)       (sizeof(TABLE)/sizeof(TABLE[0]))
253
254
255 static bfd_boolean aout_link_check_archive_element (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, const char *, bfd_boolean *);
256 static bfd_boolean aout_link_add_object_symbols    (bfd *, struct bfd_link_info *);
257 static bfd_boolean aout_link_add_symbols           (bfd *, struct bfd_link_info *);
258 static bfd_boolean aout_link_write_symbols         (struct aout_final_link_info *, bfd *);
259
260
261 reloc_howto_type *
262 NAME (aout, reloc_type_lookup) (bfd * abfd ATTRIBUTE_UNUSED,
263                                 bfd_reloc_code_real_type code)
264 {
265   switch (code)
266     {
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;
273     }
274 }
275
276 reloc_howto_type *
277 NAME (aout, reloc_name_lookup) (bfd *abfd ATTRIBUTE_UNUSED,
278                                       const char *r_name)
279 {
280   unsigned int i;
281
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];
288
289   return NULL;
290 }
291
292 static int
293 pdp11_aout_write_headers (bfd *abfd, struct internal_exec *execp)
294 {
295   struct external_exec exec_bytes;
296
297   if (adata(abfd).magic == undecided_magic)
298     NAME (aout, adjust_sizes_and_vmas) (abfd);
299
300   execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE;
301   execp->a_entry = bfd_get_start_address (abfd);
302
303   if (obj_textsec (abfd)->reloc_count > 0
304       || obj_datasec (abfd)->reloc_count > 0)
305     {
306       execp->a_trsize = execp->a_text;
307       execp->a_drsize = execp->a_data;
308     }
309   else
310     {
311       execp->a_trsize = 0;
312       execp->a_drsize = 0;
313     }
314
315   NAME (aout, swap_exec_header_out) (abfd, execp, & exec_bytes);
316
317   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
318     return FALSE;
319
320   if (bfd_bwrite ((void *) &exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd)
321       != EXEC_BYTES_SIZE)
322     return FALSE;
323
324   /* Now write out reloc info, followed by syms and strings.  */
325   if (bfd_get_outsymbols (abfd) != NULL
326       && bfd_get_symcount (abfd) != 0)
327     {
328       if (bfd_seek (abfd, (file_ptr) (N_SYMOFF (execp)), SEEK_SET) != 0)
329         return FALSE;
330
331       if (! NAME (aout, write_syms) (abfd))
332         return FALSE;
333     }
334
335   if (obj_textsec (abfd)->reloc_count > 0
336       || obj_datasec (abfd)->reloc_count > 0)
337     {
338       if (bfd_seek (abfd, (file_ptr) (N_TRELOFF (execp)), SEEK_SET) != 0
339           || !NAME (aout, squirt_out_relocs) (abfd, obj_textsec (abfd))
340           || bfd_seek (abfd, (file_ptr) (N_DRELOFF (execp)), SEEK_SET) != 0
341           || !NAME (aout, squirt_out_relocs) (abfd, obj_datasec (abfd)))
342         return FALSE;
343     }
344
345   return TRUE;
346 }
347
348 /* Write an object file.
349    Section contents have already been written.  We write the
350    file header, symbols, and relocation.  */
351
352 static bfd_boolean
353 MY(write_object_contents) (bfd *abfd)
354 {
355   struct internal_exec *execp = exec_hdr (abfd);
356
357   /* We must make certain that the magic number has been set.  This
358      will normally have been done by set_section_contents, but only if
359      there actually are some section contents.  */
360   if (! abfd->output_has_begun)
361     NAME (aout, adjust_sizes_and_vmas) (abfd);
362
363   obj_reloc_entry_size (abfd) = RELOC_SIZE;
364
365   return WRITE_HEADERS (abfd, execp);
366 }
367
368 /* Swap the information in an executable header @var{raw_bytes} taken
369    from a raw byte stream memory image into the internal exec header
370    structure "execp".  */
371
372 #ifndef NAME_swap_exec_header_in
373 void
374 NAME (aout, swap_exec_header_in) (bfd *abfd,
375                                   struct external_exec *bytes,
376                                   struct internal_exec *execp)
377 {
378   /* The internal_exec structure has some fields that are unused in this
379      configuration (IE for i960), so ensure that all such uninitialized
380      fields are zero'd out.  There are places where two of these structs
381      are memcmp'd, and thus the contents do matter.  */
382   memset ((void *) execp, 0, sizeof (struct internal_exec));
383   /* Now fill in fields in the execp, from the bytes in the raw data.  */
384   execp->a_info   = GET_MAGIC (abfd, bytes->e_info);
385   execp->a_text   = GET_WORD (abfd, bytes->e_text);
386   execp->a_data   = GET_WORD (abfd, bytes->e_data);
387   execp->a_bss    = GET_WORD (abfd, bytes->e_bss);
388   execp->a_syms   = GET_WORD (abfd, bytes->e_syms);
389   execp->a_entry  = GET_WORD (abfd, bytes->e_entry);
390
391   if (GET_WORD (abfd, bytes->e_flag) & A_FLAG_RELOC_STRIPPED)
392     {
393       execp->a_trsize = 0;
394       execp->a_drsize = 0;
395     }
396   else
397     {
398       execp->a_trsize = execp->a_text;
399       execp->a_drsize = execp->a_data;
400     }
401 }
402 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
403 #endif
404
405 /*  Swap the information in an internal exec header structure
406     "execp" into the buffer "bytes" ready for writing to disk.  */
407 void
408 NAME (aout, swap_exec_header_out) (bfd *abfd,
409                                    struct internal_exec *execp,
410                                    struct external_exec *bytes)
411 {
412   /* Now fill in fields in the raw data, from the fields in the exec struct.  */
413   PUT_MAGIC (abfd, execp->a_info,               bytes->e_info);
414   PUT_WORD (abfd, execp->a_text,                bytes->e_text);
415   PUT_WORD (abfd, execp->a_data,                bytes->e_data);
416   PUT_WORD (abfd, execp->a_bss,                 bytes->e_bss);
417   PUT_WORD (abfd, execp->a_syms,                bytes->e_syms);
418   PUT_WORD (abfd, execp->a_entry,               bytes->e_entry);
419   PUT_WORD (abfd, 0,                            bytes->e_unused);
420
421   if ((execp->a_trsize == 0 || execp->a_text == 0)
422       && (execp->a_drsize == 0 || execp->a_data == 0))
423     PUT_WORD (abfd, A_FLAG_RELOC_STRIPPED, bytes->e_flag);
424   else if (execp->a_trsize == execp->a_text
425            && execp->a_drsize == execp->a_data)
426     PUT_WORD (abfd, 0, bytes->e_flag);
427   else
428     {
429       /* TODO: print a proper warning message.  */
430       fprintf (stderr, "BFD:%s:%d: internal error\n", __FILE__, __LINE__);
431       PUT_WORD (abfd, 0,                        bytes->e_flag);
432     }
433 }
434
435 /* Make all the section for an a.out file.  */
436
437 bfd_boolean
438 NAME (aout, make_sections) (bfd *abfd)
439 {
440   if (obj_textsec (abfd) == NULL && bfd_make_section (abfd, ".text") == NULL)
441     return FALSE;
442   if (obj_datasec (abfd) == NULL && bfd_make_section (abfd, ".data") == NULL)
443     return FALSE;
444   if (obj_bsssec (abfd) == NULL  && bfd_make_section (abfd, ".bss") == NULL)
445     return FALSE;
446   return TRUE;
447 }
448
449 /* Some a.out variant thinks that the file open in ABFD
450    checking is an a.out file.  Do some more checking, and set up
451    for access if it really is.  Call back to the calling
452    environment's "finish up" function just before returning, to
453    handle any last-minute setup.  */
454
455 const bfd_target *
456 NAME (aout, some_aout_object_p) (bfd *abfd,
457                                  struct internal_exec *execp,
458                                  const bfd_target *(*callback_to_real_object_p) (bfd *))
459 {
460   struct aout_data_struct *rawptr, *oldrawptr;
461   const bfd_target *result;
462   bfd_size_type amt = sizeof (struct aout_data_struct);
463
464   rawptr = bfd_zalloc (abfd, amt);
465   if (rawptr == NULL)
466     return 0;
467
468   oldrawptr = abfd->tdata.aout_data;
469   abfd->tdata.aout_data = rawptr;
470
471   /* Copy the contents of the old tdata struct.  */
472   if (oldrawptr != NULL)
473     *abfd->tdata.aout_data = *oldrawptr;
474
475   abfd->tdata.aout_data->a.hdr = &rawptr->e;
476   *(abfd->tdata.aout_data->a.hdr) = *execp;     /* Copy in the internal_exec struct.  */
477   execp = abfd->tdata.aout_data->a.hdr;
478
479   /* Set the file flags.  */
480   abfd->flags = BFD_NO_FLAGS;
481   if (execp->a_drsize || execp->a_trsize)
482     abfd->flags |= HAS_RELOC;
483   /* Setting of EXEC_P has been deferred to the bottom of this function.  */
484   if (execp->a_syms)
485     abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
486   if (N_DYNAMIC (execp))
487     abfd->flags |= DYNAMIC;
488
489   if (N_MAGIC (execp) == ZMAGIC)
490     {
491       abfd->flags |= D_PAGED | WP_TEXT;
492       adata (abfd).magic = z_magic;
493     }
494   else if (N_MAGIC (execp) == NMAGIC)
495     {
496       abfd->flags |= WP_TEXT;
497       adata (abfd).magic = n_magic;
498     }
499   else if (N_MAGIC (execp) == OMAGIC)
500     adata (abfd).magic = o_magic;
501   else
502     {
503       /* Should have been checked with N_BADMAG before this routine
504          was called.  */
505       abort ();
506     }
507
508   bfd_get_start_address (abfd) = execp->a_entry;
509
510   obj_aout_symbols (abfd) = NULL;
511   bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist);
512
513   /* The default relocation entry size is that of traditional V7 Unix.  */
514   obj_reloc_entry_size (abfd) = RELOC_SIZE;
515
516   /* The default symbol entry size is that of traditional Unix.  */
517   obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE;
518
519 #ifdef USE_MMAP
520   bfd_init_window (&obj_aout_sym_window (abfd));
521   bfd_init_window (&obj_aout_string_window (abfd));
522 #endif
523
524   obj_aout_external_syms (abfd) = NULL;
525   obj_aout_external_strings (abfd) = NULL;
526   obj_aout_sym_hashes (abfd) = NULL;
527
528   if (! NAME (aout, make_sections) (abfd))
529     return NULL;
530
531   obj_datasec (abfd)->size = execp->a_data;
532   obj_bsssec (abfd)->size = execp->a_bss;
533
534   obj_textsec (abfd)->flags =
535     (execp->a_trsize != 0
536      ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC)
537      : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS));
538   obj_datasec (abfd)->flags =
539     (execp->a_drsize != 0
540      ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC)
541      : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS));
542   obj_bsssec (abfd)->flags = SEC_ALLOC;
543
544 #ifdef THIS_IS_ONLY_DOCUMENTATION
545   /* The common code can't fill in these things because they depend
546      on either the start address of the text segment, the rounding
547      up of virtual addresses between segments, or the starting file
548      position of the text segment -- all of which varies among different
549      versions of a.out.  */
550
551   /* Call back to the format-dependent code to fill in the rest of the
552      fields and do any further cleanup.  Things that should be filled
553      in by the callback:  */
554   struct exec *execp = exec_hdr (abfd);
555
556   obj_textsec (abfd)->size = N_TXTSIZE (execp);
557   /* Data and bss are already filled in since they're so standard.  */
558
559   /* The virtual memory addresses of the sections.  */
560   obj_textsec (abfd)->vma = N_TXTADDR (execp);
561   obj_datasec (abfd)->vma = N_DATADDR (execp);
562   obj_bsssec  (abfd)->vma = N_BSSADDR (execp);
563
564   /* The file offsets of the sections.  */
565   obj_textsec (abfd)->filepos = N_TXTOFF (execp);
566   obj_datasec (abfd)->filepos = N_DATOFF (execp);
567
568   /* The file offsets of the relocation info.  */
569   obj_textsec (abfd)->rel_filepos = N_TRELOFF (execp);
570   obj_datasec (abfd)->rel_filepos = N_DRELOFF (execp);
571
572   /* The file offsets of the string table and symbol table.  */
573   obj_str_filepos (abfd) = N_STROFF (execp);
574   obj_sym_filepos (abfd) = N_SYMOFF (execp);
575
576   /* Determine the architecture and machine type of the object file.  */
577   abfd->obj_arch = bfd_arch_obscure;
578
579   adata(abfd)->page_size = TARGET_PAGE_SIZE;
580   adata(abfd)->segment_size = SEGMENT_SIZE;
581   adata(abfd)->exec_bytes_size = EXEC_BYTES_SIZE;
582
583   return abfd->xvec;
584
585   /* The architecture is encoded in various ways in various a.out variants,
586      or is not encoded at all in some of them.  The relocation size depends
587      on the architecture and the a.out variant.  Finally, the return value
588      is the bfd_target vector in use.  If an error occurs, return zero and
589      set bfd_error to the appropriate error code.
590
591      Formats such as b.out, which have additional fields in the a.out
592      header, should cope with them in this callback as well.  */
593 #endif  /* DOCUMENTATION */
594
595   result = (*callback_to_real_object_p)(abfd);
596
597   /* Now that the segment addresses have been worked out, take a better
598      guess at whether the file is executable.  If the entry point
599      is within the text segment, assume it is.  (This makes files
600      executable even if their entry point address is 0, as long as
601      their text starts at zero.).
602
603      This test had to be changed to deal with systems where the text segment
604      runs at a different location than the default.  The problem is that the
605      entry address can appear to be outside the text segment, thus causing an
606      erroneous conclusion that the file isn't executable.
607
608      To fix this, we now accept any non-zero entry point as an indication of
609      executability.  This will work most of the time, since only the linker
610      sets the entry point, and that is likely to be non-zero for most systems. */
611
612   if (execp->a_entry != 0
613       || (execp->a_entry >= obj_textsec(abfd)->vma
614           && execp->a_entry < obj_textsec(abfd)->vma + obj_textsec(abfd)->size))
615     abfd->flags |= EXEC_P;
616 #ifdef STAT_FOR_EXEC
617   else
618     {
619       struct stat stat_buf;
620
621       /* The original heuristic doesn't work in some important cases.
622         The a.out file has no information about the text start
623         address.  For files (like kernels) linked to non-standard
624         addresses (ld -Ttext nnn) the entry point may not be between
625         the default text start (obj_textsec(abfd)->vma) and
626         (obj_textsec(abfd)->vma) + text size.  This is not just a mach
627         issue.  Many kernels are loaded at non standard addresses.  */
628       if (abfd->iostream != NULL
629           && (abfd->flags & BFD_IN_MEMORY) == 0
630           && (fstat(fileno((FILE *) (abfd->iostream)), &stat_buf) == 0)
631           && ((stat_buf.st_mode & 0111) != 0))
632         abfd->flags |= EXEC_P;
633     }
634 #endif /* STAT_FOR_EXEC */
635
636   if (!result)
637     {
638       free (rawptr);
639       abfd->tdata.aout_data = oldrawptr;
640     }
641   return result;
642 }
643
644 /* Initialize ABFD for use with a.out files.  */
645
646 bfd_boolean
647 NAME (aout, mkobject) (bfd *abfd)
648 {
649   struct aout_data_struct  *rawptr;
650   bfd_size_type amt = sizeof (struct aout_data_struct);
651
652   bfd_set_error (bfd_error_system_call);
653
654   /* Use an intermediate variable for clarity.  */
655   rawptr = bfd_zalloc (abfd, amt);
656
657   if (rawptr == NULL)
658     return FALSE;
659
660   abfd->tdata.aout_data = rawptr;
661   exec_hdr (abfd) = &(rawptr->e);
662
663   obj_textsec (abfd) = NULL;
664   obj_datasec (abfd) = NULL;
665   obj_bsssec (abfd)  = NULL;
666
667   return TRUE;
668 }
669
670 /* Keep track of machine architecture and machine type for
671    a.out's. Return the <<machine_type>> for a particular
672    architecture and machine, or <<M_UNKNOWN>> if that exact architecture
673    and machine can't be represented in a.out format.
674
675    If the architecture is understood, machine type 0 (default)
676    is always understood.  */
677
678 enum machine_type
679 NAME (aout, machine_type) (enum bfd_architecture arch,
680                            unsigned long machine,
681                            bfd_boolean *unknown)
682 {
683   enum machine_type arch_flags;
684
685   arch_flags = M_UNKNOWN;
686   *unknown = TRUE;
687
688   switch (arch)
689     {
690     case bfd_arch_sparc:
691       if (machine == 0
692           || machine == bfd_mach_sparc
693           || machine == bfd_mach_sparc_sparclite
694           || machine == bfd_mach_sparc_v9)
695         arch_flags = M_SPARC;
696       else if (machine == bfd_mach_sparc_sparclet)
697         arch_flags = M_SPARCLET;
698       break;
699
700     case bfd_arch_i386:
701       if (machine == 0
702           || machine == bfd_mach_i386_i386
703           || machine == bfd_mach_i386_i386_intel_syntax)
704         arch_flags = M_386;
705       break;
706
707     case bfd_arch_arm:
708       if (machine == 0) arch_flags = M_ARM;
709       break;
710
711     case bfd_arch_mips:
712       switch (machine)
713         {
714         case 0:
715         case 2000:
716         case bfd_mach_mips3000:
717           arch_flags = M_MIPS1;
718           break;
719         case bfd_mach_mips4000: /* MIPS3 */
720         case bfd_mach_mips4400:
721         case bfd_mach_mips8000: /* MIPS4 */
722         case bfd_mach_mips6000: /* Real MIPS2: */
723           arch_flags = M_MIPS2;
724           break;
725         default:
726           arch_flags = M_UNKNOWN;
727           break;
728         }
729       break;
730
731     case bfd_arch_ns32k:
732       switch (machine)
733         {
734         case 0:                 arch_flags = M_NS32532; break;
735         case 32032:             arch_flags = M_NS32032; break;
736         case 32532:             arch_flags = M_NS32532; break;
737         default:                arch_flags = M_UNKNOWN; break;
738         }
739       break;
740
741     case bfd_arch_pdp11:
742       /* TODO: arch_flags = M_PDP11; */
743       *unknown = FALSE;
744       break;
745
746     case bfd_arch_vax:
747       *unknown = FALSE;
748       break;
749
750     default:
751       arch_flags = M_UNKNOWN;
752     }
753
754   if (arch_flags != M_UNKNOWN)
755     *unknown = FALSE;
756
757   return arch_flags;
758 }
759
760 /* Set the architecture and the machine of the ABFD to the
761    values ARCH and MACHINE.  Verify that @ABFD's format
762    can support the architecture required.  */
763
764 bfd_boolean
765 NAME (aout, set_arch_mach) (bfd *abfd,
766                             enum bfd_architecture arch,
767                             unsigned long machine)
768 {
769   if (! bfd_default_set_arch_mach (abfd, arch, machine))
770     return FALSE;
771
772   if (arch != bfd_arch_unknown)
773     {
774       bfd_boolean unknown;
775
776       NAME (aout, machine_type) (arch, machine, &unknown);
777       if (unknown)
778         return FALSE;
779     }
780
781   obj_reloc_entry_size (abfd) = RELOC_SIZE;
782
783   return (*aout_backend_info(abfd)->set_sizes) (abfd);
784 }
785
786 static void
787 adjust_o_magic (bfd *abfd, struct internal_exec *execp)
788 {
789   file_ptr pos = adata (abfd).exec_bytes_size;
790   bfd_vma vma = 0;
791   int pad = 0;
792
793   /* Text.  */
794   obj_textsec (abfd)->filepos = pos;
795   if (! obj_textsec (abfd)->user_set_vma)
796     obj_textsec (abfd)->vma = vma;
797   else
798     vma = obj_textsec (abfd)->vma;
799
800   pos += obj_textsec (abfd)->size;
801   vma += obj_textsec (abfd)->size;
802
803   /* Data.  */
804   if (!obj_datasec (abfd)->user_set_vma)
805     {
806       obj_textsec (abfd)->size += pad;
807       pos += pad;
808       vma += pad;
809       obj_datasec (abfd)->vma = vma;
810     }
811   else
812     vma = obj_datasec (abfd)->vma;
813   obj_datasec (abfd)->filepos = pos;
814   pos += obj_datasec (abfd)->size;
815   vma += obj_datasec (abfd)->size;
816
817   /* BSS.  */
818   if (! obj_bsssec (abfd)->user_set_vma)
819     {
820       obj_datasec (abfd)->size += pad;
821       pos += pad;
822       vma += pad;
823       obj_bsssec (abfd)->vma = vma;
824     }
825   else
826     {
827       /* The VMA of the .bss section is set by the VMA of the
828          .data section plus the size of the .data section.  We may
829          need to add padding bytes to make this true.  */
830       pad = obj_bsssec (abfd)->vma - vma;
831       if (pad > 0)
832         {
833           obj_datasec (abfd)->size += pad;
834           pos += pad;
835         }
836     }
837   obj_bsssec (abfd)->filepos = pos;
838
839   /* Fix up the exec header.  */
840   execp->a_text = obj_textsec (abfd)->size;
841   execp->a_data = obj_datasec (abfd)->size;
842   execp->a_bss  = obj_bsssec (abfd)->size;
843   N_SET_MAGIC (execp, OMAGIC);
844 }
845
846 static void
847 adjust_z_magic (bfd *abfd, struct internal_exec *execp)
848 {
849   bfd_size_type data_pad, text_pad;
850   file_ptr text_end;
851   const struct aout_backend_data *abdp;
852   int ztih;                     /* Nonzero if text includes exec header.  */
853
854   abdp = aout_backend_info (abfd);
855
856   /* Text.  */
857   ztih = (abdp != NULL
858           && (abdp->text_includes_header
859               || obj_aout_subformat (abfd) == q_magic_format));
860   obj_textsec(abfd)->filepos = (ztih
861                                 ? adata(abfd).exec_bytes_size
862                                 : adata(abfd).zmagic_disk_block_size);
863   if (! obj_textsec(abfd)->user_set_vma)
864     {
865       /* ?? Do we really need to check for relocs here?  */
866       obj_textsec(abfd)->vma = ((abfd->flags & HAS_RELOC)
867                                 ? 0
868                                 : (ztih
869                                    ? (abdp->default_text_vma
870                                       + adata (abfd).exec_bytes_size)
871                                    : abdp->default_text_vma));
872       text_pad = 0;
873     }
874   else
875     {
876       /* The .text section is being loaded at an unusual address.  We
877          may need to pad it such that the .data section starts at a page
878          boundary.  */
879       if (ztih)
880         text_pad = ((obj_textsec (abfd)->filepos - obj_textsec (abfd)->vma)
881                     & (adata (abfd).page_size - 1));
882       else
883         text_pad = ((- obj_textsec (abfd)->vma)
884                     & (adata (abfd).page_size - 1));
885     }
886
887   /* Find start of data.  */
888   if (ztih)
889     {
890       text_end = obj_textsec (abfd)->filepos + obj_textsec (abfd)->size;
891       text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
892     }
893   else
894     {
895       /* Note that if page_size == zmagic_disk_block_size, then
896          filepos == page_size, and this case is the same as the ztih
897          case.  */
898       text_end = obj_textsec (abfd)->size;
899       text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
900       text_end += obj_textsec (abfd)->filepos;
901     }
902
903   obj_textsec (abfd)->size += text_pad;
904   text_end += text_pad;
905
906   /* Data.  */
907   if (!obj_datasec(abfd)->user_set_vma)
908     {
909       bfd_vma vma;
910       vma = obj_textsec(abfd)->vma + obj_textsec(abfd)->size;
911       obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
912     }
913   if (abdp && abdp->zmagic_mapped_contiguous)
914     {
915       text_pad = (obj_datasec(abfd)->vma
916                   - obj_textsec(abfd)->vma
917                   - obj_textsec(abfd)->size);
918       obj_textsec(abfd)->size += text_pad;
919     }
920   obj_datasec (abfd)->filepos = (obj_textsec (abfd)->filepos
921                                 + obj_textsec (abfd)->size);
922
923   /* Fix up exec header while we're at it.  */
924   execp->a_text = obj_textsec(abfd)->size;
925   if (ztih && (!abdp || (abdp && !abdp->exec_header_not_counted)))
926     execp->a_text += adata(abfd).exec_bytes_size;
927   N_SET_MAGIC (execp, ZMAGIC);
928
929   /* Spec says data section should be rounded up to page boundary.  */
930   obj_datasec(abfd)->size
931     = align_power (obj_datasec(abfd)->size,
932                    obj_bsssec(abfd)->alignment_power);
933   execp->a_data = BFD_ALIGN (obj_datasec(abfd)->size,
934                              adata(abfd).page_size);
935   data_pad = execp->a_data - obj_datasec(abfd)->size;
936
937   /* BSS.  */
938   if (!obj_bsssec(abfd)->user_set_vma)
939     obj_bsssec(abfd)->vma = (obj_datasec(abfd)->vma
940                              + obj_datasec(abfd)->size);
941   /* If the BSS immediately follows the data section and extra space
942      in the page is left after the data section, fudge data
943      in the header so that the bss section looks smaller by that
944      amount.  We'll start the bss section there, and lie to the OS.
945      (Note that a linker script, as well as the above assignment,
946      could have explicitly set the BSS vma to immediately follow
947      the data section.)  */
948   if (align_power (obj_bsssec(abfd)->vma, obj_bsssec(abfd)->alignment_power)
949       == obj_datasec(abfd)->vma + obj_datasec(abfd)->size)
950     execp->a_bss = (data_pad > obj_bsssec(abfd)->size) ? 0 :
951       obj_bsssec(abfd)->size - data_pad;
952   else
953     execp->a_bss = obj_bsssec(abfd)->size;
954 }
955
956 static void
957 adjust_n_magic (bfd *abfd, struct internal_exec *execp)
958 {
959   file_ptr pos = adata(abfd).exec_bytes_size;
960   bfd_vma vma = 0;
961   int pad;
962
963   /* Text.  */
964   obj_textsec(abfd)->filepos = pos;
965   if (!obj_textsec(abfd)->user_set_vma)
966     obj_textsec(abfd)->vma = vma;
967   else
968     vma = obj_textsec(abfd)->vma;
969   pos += obj_textsec(abfd)->size;
970   vma += obj_textsec(abfd)->size;
971
972   /* Data.  */
973   obj_datasec(abfd)->filepos = pos;
974   if (!obj_datasec(abfd)->user_set_vma)
975     obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
976   vma = obj_datasec(abfd)->vma;
977
978   /* Since BSS follows data immediately, see if it needs alignment.  */
979   vma += obj_datasec(abfd)->size;
980   pad = align_power (vma, obj_bsssec(abfd)->alignment_power) - vma;
981   obj_datasec(abfd)->size += pad;
982   pos += obj_datasec(abfd)->size;
983
984   /* BSS.  */
985   if (!obj_bsssec(abfd)->user_set_vma)
986     obj_bsssec(abfd)->vma = vma;
987   else
988     vma = obj_bsssec(abfd)->vma;
989
990   /* Fix up exec header.  */
991   execp->a_text = obj_textsec(abfd)->size;
992   execp->a_data = obj_datasec(abfd)->size;
993   execp->a_bss = obj_bsssec(abfd)->size;
994   N_SET_MAGIC (execp, NMAGIC);
995 }
996
997 bfd_boolean
998 NAME (aout, adjust_sizes_and_vmas) (bfd *abfd)
999 {
1000   struct internal_exec *execp = exec_hdr (abfd);
1001
1002   if (! NAME (aout, make_sections) (abfd))
1003     return FALSE;
1004
1005   if (adata(abfd).magic != undecided_magic)
1006     return TRUE;
1007
1008   obj_textsec(abfd)->size =
1009     align_power(obj_textsec(abfd)->size,
1010                 obj_textsec(abfd)->alignment_power);
1011
1012   /* Rule (heuristic) for when to pad to a new page.  Note that there
1013      are (at least) two ways demand-paged (ZMAGIC) files have been
1014      handled.  Most Berkeley-based systems start the text segment at
1015      (TARGET_PAGE_SIZE).  However, newer versions of SUNOS start the text
1016      segment right after the exec header; the latter is counted in the
1017      text segment size, and is paged in by the kernel with the rest of
1018      the text. */
1019
1020   /* This perhaps isn't the right way to do this, but made it simpler for me
1021      to understand enough to implement it.  Better would probably be to go
1022      right from BFD flags to alignment/positioning characteristics.  But the
1023      old code was sloppy enough about handling the flags, and had enough
1024      other magic, that it was a little hard for me to understand.  I think
1025      I understand it better now, but I haven't time to do the cleanup this
1026      minute.  */
1027
1028   if (abfd->flags & WP_TEXT)
1029     adata(abfd).magic = n_magic;
1030   else
1031     adata(abfd).magic = o_magic;
1032
1033 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1034 #if __GNUC__ >= 2
1035   fprintf (stderr, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1036            ({ char *str;
1037               switch (adata(abfd).magic) {
1038               case n_magic: str = "NMAGIC"; break;
1039               case o_magic: str = "OMAGIC"; break;
1040               case z_magic: str = "ZMAGIC"; break;
1041               default: abort ();
1042               }
1043               str;
1044             }),
1045            obj_textsec(abfd)->vma, obj_textsec(abfd)->size,
1046                 obj_textsec(abfd)->alignment_power,
1047            obj_datasec(abfd)->vma, obj_datasec(abfd)->size,
1048                 obj_datasec(abfd)->alignment_power,
1049            obj_bsssec(abfd)->vma, obj_bsssec(abfd)->size,
1050                 obj_bsssec(abfd)->alignment_power);
1051 #endif
1052 #endif
1053
1054   switch (adata(abfd).magic)
1055     {
1056     case o_magic:
1057       adjust_o_magic (abfd, execp);
1058       break;
1059     case z_magic:
1060       adjust_z_magic (abfd, execp);
1061       break;
1062     case n_magic:
1063       adjust_n_magic (abfd, execp);
1064       break;
1065     default:
1066       abort ();
1067     }
1068
1069 #ifdef BFD_AOUT_DEBUG
1070   fprintf (stderr, "       text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1071            obj_textsec(abfd)->vma, obj_textsec(abfd)->size,
1072                 obj_textsec(abfd)->filepos,
1073            obj_datasec(abfd)->vma, obj_datasec(abfd)->size,
1074                 obj_datasec(abfd)->filepos,
1075            obj_bsssec(abfd)->vma, obj_bsssec(abfd)->size);
1076 #endif
1077
1078   return TRUE;
1079 }
1080
1081 /* Called by the BFD in response to a bfd_make_section request.  */
1082
1083 bfd_boolean
1084 NAME (aout, new_section_hook) (bfd *abfd, asection *newsect)
1085 {
1086   /* Align to double at least.  */
1087   newsect->alignment_power = bfd_get_arch_info(abfd)->section_align_power;
1088
1089   if (bfd_get_format (abfd) == bfd_object)
1090     {
1091       if (obj_textsec (abfd) == NULL
1092           && !strcmp (newsect->name, ".text"))
1093         {
1094           obj_textsec(abfd)= newsect;
1095           newsect->target_index = N_TEXT;
1096         }
1097       else if (obj_datasec (abfd) == NULL
1098                && !strcmp (newsect->name, ".data"))
1099         {
1100           obj_datasec (abfd) = newsect;
1101           newsect->target_index = N_DATA;
1102         }
1103       else if (obj_bsssec (abfd) == NULL
1104                && !strcmp (newsect->name, ".bss"))
1105         {
1106           obj_bsssec (abfd) = newsect;
1107           newsect->target_index = N_BSS;
1108         }
1109     }
1110
1111   /* We allow more than three sections internally.  */
1112   return _bfd_generic_new_section_hook (abfd, newsect);
1113 }
1114
1115 bfd_boolean
1116 NAME (aout, set_section_contents) (bfd *abfd,
1117                                    sec_ptr section,
1118                                    const void * location,
1119                                    file_ptr offset,
1120                                    bfd_size_type count)
1121 {
1122   if (! abfd->output_has_begun)
1123     {
1124       if (! NAME (aout, adjust_sizes_and_vmas) (abfd))
1125         return FALSE;
1126     }
1127
1128   if (section == obj_bsssec (abfd))
1129     {
1130       bfd_set_error (bfd_error_no_contents);
1131       return FALSE;
1132     }
1133
1134   if (section != obj_textsec (abfd)
1135       && section != obj_datasec (abfd))
1136     {
1137       _bfd_error_handler
1138         /* xgettext:c-format */
1139         (_("%pB: can not represent section `%pA' in a.out object file format"),
1140          abfd, section);
1141       bfd_set_error (bfd_error_nonrepresentable_section);
1142       return FALSE;
1143     }
1144
1145   if (count != 0)
1146     {
1147       if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1148           || bfd_bwrite (location, count, abfd) != count)
1149         return FALSE;
1150     }
1151
1152   return TRUE;
1153 }
1154 \f
1155 /* Read the external symbols from an a.out file.  */
1156
1157 static bfd_boolean
1158 aout_get_external_symbols (bfd *abfd)
1159 {
1160   if (obj_aout_external_syms (abfd) == NULL)
1161     {
1162       bfd_size_type count;
1163       struct external_nlist *syms;
1164
1165       count = exec_hdr (abfd)->a_syms / EXTERNAL_NLIST_SIZE;
1166
1167       /* PR 17512: file: 011f5a08.  */
1168       if (count == 0)
1169         {
1170           obj_aout_external_syms (abfd) = NULL;
1171           obj_aout_external_sym_count (abfd) = count;
1172           return TRUE;
1173         }
1174
1175 #ifdef USE_MMAP
1176       if (! bfd_get_file_window (abfd, obj_sym_filepos (abfd),
1177                                  exec_hdr (abfd)->a_syms,
1178                                  &obj_aout_sym_window (abfd), TRUE))
1179         return FALSE;
1180       syms = (struct external_nlist *) obj_aout_sym_window (abfd).data;
1181 #else
1182       /* We allocate using malloc to make the values easy to free
1183          later on.  If we put them on the objalloc it might not be
1184          possible to free them.  */
1185       syms = bfd_malloc (count * EXTERNAL_NLIST_SIZE);
1186       if (syms == NULL && count != 0)
1187         return FALSE;
1188
1189       if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1190           || (bfd_bread (syms, exec_hdr (abfd)->a_syms, abfd)
1191               != exec_hdr (abfd)->a_syms))
1192         {
1193           free (syms);
1194           return FALSE;
1195         }
1196 #endif
1197
1198       obj_aout_external_syms (abfd) = syms;
1199       obj_aout_external_sym_count (abfd) = count;
1200     }
1201
1202   if (obj_aout_external_strings (abfd) == NULL
1203       && exec_hdr (abfd)->a_syms != 0)
1204     {
1205       unsigned char string_chars[BYTES_IN_LONG];
1206       bfd_size_type stringsize;
1207       char *strings;
1208
1209       /* Get the size of the strings.  */
1210       if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
1211           || (bfd_bread ((void *) string_chars, (bfd_size_type) BYTES_IN_LONG,
1212                         abfd) != BYTES_IN_LONG))
1213         return FALSE;
1214       stringsize = H_GET_32 (abfd, string_chars);
1215
1216 #ifdef USE_MMAP
1217       if (! bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize,
1218                                  &obj_aout_string_window (abfd), TRUE))
1219         return FALSE;
1220       strings = (char *) obj_aout_string_window (abfd).data;
1221 #else
1222       strings = bfd_malloc (stringsize + 1);
1223       if (strings == NULL)
1224         return FALSE;
1225
1226       /* Skip space for the string count in the buffer for convenience
1227          when using indexes.  */
1228       if (bfd_bread (strings + 4, stringsize - 4, abfd) != stringsize - 4)
1229         {
1230           free (strings);
1231           return FALSE;
1232         }
1233 #endif
1234       /* Ensure that a zero index yields an empty string.  */
1235       strings[0] = '\0';
1236
1237       strings[stringsize - 1] = 0;
1238
1239       obj_aout_external_strings (abfd) = strings;
1240       obj_aout_external_string_size (abfd) = stringsize;
1241     }
1242
1243   return TRUE;
1244 }
1245
1246 /* Translate an a.out symbol into a BFD symbol.  The desc, other, type
1247    and symbol->value fields of CACHE_PTR will be set from the a.out
1248    nlist structure.  This function is responsible for setting
1249    symbol->flags and symbol->section, and adjusting symbol->value.  */
1250
1251 static bfd_boolean
1252 translate_from_native_sym_flags (bfd *abfd,
1253                                  aout_symbol_type *cache_ptr)
1254 {
1255   flagword visible;
1256
1257   if (cache_ptr->type == N_FN)
1258     {
1259       asection *sec;
1260
1261       /* This is a debugging symbol.  */
1262       cache_ptr->symbol.flags = BSF_DEBUGGING;
1263
1264       /* Work out the symbol section.  */
1265       switch (cache_ptr->type & N_TYPE)
1266         {
1267         case N_TEXT:
1268         case N_FN:
1269           sec = obj_textsec (abfd);
1270           break;
1271         case N_DATA:
1272           sec = obj_datasec (abfd);
1273           break;
1274         case N_BSS:
1275           sec = obj_bsssec (abfd);
1276           break;
1277         default:
1278         case N_ABS:
1279           sec = bfd_abs_section_ptr;
1280           break;
1281         }
1282
1283       cache_ptr->symbol.section = sec;
1284       cache_ptr->symbol.value -= sec->vma;
1285
1286       return TRUE;
1287     }
1288
1289   /* Get the default visibility.  This does not apply to all types, so
1290      we just hold it in a local variable to use if wanted.  */
1291   if ((cache_ptr->type & N_EXT) == 0)
1292     visible = BSF_LOCAL;
1293   else
1294     visible = BSF_GLOBAL;
1295
1296   switch (cache_ptr->type)
1297     {
1298     default:
1299     case N_ABS: case N_ABS | N_EXT:
1300       cache_ptr->symbol.section = bfd_abs_section_ptr;
1301       cache_ptr->symbol.flags = visible;
1302       break;
1303
1304     case N_UNDF | N_EXT:
1305       if (cache_ptr->symbol.value != 0)
1306         {
1307           /* This is a common symbol.  */
1308           cache_ptr->symbol.flags = BSF_GLOBAL;
1309           cache_ptr->symbol.section = bfd_com_section_ptr;
1310         }
1311       else
1312         {
1313           cache_ptr->symbol.flags = 0;
1314           cache_ptr->symbol.section = bfd_und_section_ptr;
1315         }
1316       break;
1317
1318     case N_TEXT: case N_TEXT | N_EXT:
1319       cache_ptr->symbol.section = obj_textsec (abfd);
1320       cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1321       cache_ptr->symbol.flags = visible;
1322       break;
1323
1324     case N_DATA: case N_DATA | N_EXT:
1325       cache_ptr->symbol.section = obj_datasec (abfd);
1326       cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1327       cache_ptr->symbol.flags = visible;
1328       break;
1329
1330     case N_BSS: case N_BSS | N_EXT:
1331       cache_ptr->symbol.section = obj_bsssec (abfd);
1332       cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1333       cache_ptr->symbol.flags = visible;
1334       break;
1335     }
1336
1337   return TRUE;
1338 }
1339
1340 /* Set the fields of SYM_POINTER according to CACHE_PTR.  */
1341
1342 static bfd_boolean
1343 translate_to_native_sym_flags (bfd *abfd,
1344                                asymbol *cache_ptr,
1345                                struct external_nlist *sym_pointer)
1346 {
1347   bfd_vma value = cache_ptr->value;
1348   asection *sec;
1349   bfd_vma off;
1350
1351   /* Mask out any existing type bits in case copying from one section
1352      to another.  */
1353   sym_pointer->e_type[0] &= ~N_TYPE;
1354
1355   sec = bfd_get_section (cache_ptr);
1356   off = 0;
1357
1358   if (sec == NULL)
1359     {
1360       /* This case occurs, e.g., for the *DEBUG* section of a COFF
1361          file.  */
1362       _bfd_error_handler
1363         /* xgettext:c-format */
1364         (_("%pB: can not represent section for symbol `%s' in a.out object file format"),
1365          abfd, cache_ptr->name != NULL ? cache_ptr->name : "*unknown*");
1366       bfd_set_error (bfd_error_nonrepresentable_section);
1367       return FALSE;
1368     }
1369
1370   if (sec->output_section != NULL)
1371     {
1372       off = sec->output_offset;
1373       sec = sec->output_section;
1374     }
1375
1376   if (bfd_is_abs_section (sec))
1377     sym_pointer->e_type[0] |= N_ABS;
1378   else if (sec == obj_textsec (abfd))
1379     sym_pointer->e_type[0] |= N_TEXT;
1380   else if (sec == obj_datasec (abfd))
1381     sym_pointer->e_type[0] |= N_DATA;
1382   else if (sec == obj_bsssec (abfd))
1383     sym_pointer->e_type[0] |= N_BSS;
1384   else if (bfd_is_und_section (sec))
1385     sym_pointer->e_type[0] = N_UNDF | N_EXT;
1386   else if (bfd_is_com_section (sec))
1387     sym_pointer->e_type[0] = N_UNDF | N_EXT;
1388   else
1389     {
1390       _bfd_error_handler
1391         /* xgettext:c-format */
1392         (_("%pB: can not represent section `%pA' in a.out object file format"),
1393          abfd, sec);
1394       bfd_set_error (bfd_error_nonrepresentable_section);
1395       return FALSE;
1396     }
1397
1398   /* Turn the symbol from section relative to absolute again */
1399   value += sec->vma + off;
1400
1401   if ((cache_ptr->flags & BSF_DEBUGGING) != 0)
1402     sym_pointer->e_type[0] = ((aout_symbol_type *) cache_ptr)->type;
1403   else if ((cache_ptr->flags & BSF_GLOBAL) != 0)
1404     sym_pointer->e_type[0] |= N_EXT;
1405
1406   PUT_WORD(abfd, value, sym_pointer->e_value);
1407
1408   return TRUE;
1409 }
1410 \f
1411 /* Native-level interface to symbols. */
1412
1413 asymbol *
1414 NAME (aout, make_empty_symbol) (bfd *abfd)
1415 {
1416   bfd_size_type amt = sizeof (aout_symbol_type);
1417   aout_symbol_type *new_symbol_type = bfd_zalloc (abfd, amt);
1418
1419   if (!new_symbol_type)
1420     return NULL;
1421   new_symbol_type->symbol.the_bfd = abfd;
1422
1423   return &new_symbol_type->symbol;
1424 }
1425
1426 /* Translate a set of internal symbols into external symbols.  */
1427
1428 bfd_boolean
1429 NAME (aout, translate_symbol_table) (bfd *abfd,
1430                                      aout_symbol_type *in,
1431                                      struct external_nlist *ext,
1432                                      bfd_size_type count,
1433                                      char *str,
1434                                      bfd_size_type strsize,
1435                                      bfd_boolean dynamic)
1436 {
1437   struct external_nlist *ext_end;
1438
1439   ext_end = ext + count;
1440   for (; ext < ext_end; ext++, in++)
1441     {
1442       bfd_vma x;
1443
1444       x = GET_WORD (abfd, ext->e_strx);
1445       in->symbol.the_bfd = abfd;
1446
1447       /* For the normal symbols, the zero index points at the number
1448          of bytes in the string table but is to be interpreted as the
1449          null string.  For the dynamic symbols, the number of bytes in
1450          the string table is stored in the __DYNAMIC structure and the
1451          zero index points at an actual string.  */
1452       if (x == 0 && ! dynamic)
1453         in->symbol.name = "";
1454       else if (x < strsize)
1455         in->symbol.name = str + x;
1456       else
1457         return FALSE;
1458
1459       in->symbol.value = GET_SWORD (abfd,  ext->e_value);
1460       /* TODO: is 0 a safe value here?  */
1461       in->desc = 0;
1462       in->other = 0;
1463       in->type = H_GET_8 (abfd,  ext->e_type);
1464       in->symbol.udata.p = NULL;
1465
1466       if (! translate_from_native_sym_flags (abfd, in))
1467         return FALSE;
1468
1469       if (dynamic)
1470         in->symbol.flags |= BSF_DYNAMIC;
1471     }
1472
1473   return TRUE;
1474 }
1475
1476 /* We read the symbols into a buffer, which is discarded when this
1477    function exits.  We read the strings into a buffer large enough to
1478    hold them all plus all the cached symbol entries.  */
1479
1480 bfd_boolean
1481 NAME (aout, slurp_symbol_table) (bfd *abfd)
1482 {
1483   struct external_nlist *old_external_syms;
1484   aout_symbol_type *cached;
1485   bfd_size_type cached_size;
1486
1487   /* If there's no work to be done, don't do any.  */
1488   if (obj_aout_symbols (abfd) != NULL)
1489     return TRUE;
1490
1491   old_external_syms = obj_aout_external_syms (abfd);
1492
1493   if (! aout_get_external_symbols (abfd))
1494     return FALSE;
1495
1496   cached_size = obj_aout_external_sym_count (abfd);
1497   cached_size *= sizeof (aout_symbol_type);
1498   cached = bfd_zmalloc (cached_size);
1499   if (cached == NULL && cached_size != 0)
1500     return FALSE;
1501
1502   /* Convert from external symbol information to internal.  */
1503   if (! (NAME (aout, translate_symbol_table)
1504          (abfd, cached,
1505           obj_aout_external_syms (abfd),
1506           obj_aout_external_sym_count (abfd),
1507           obj_aout_external_strings (abfd),
1508           obj_aout_external_string_size (abfd),
1509           FALSE)))
1510     {
1511       free (cached);
1512       return FALSE;
1513     }
1514
1515   bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd);
1516
1517   obj_aout_symbols (abfd) = cached;
1518
1519   /* It is very likely that anybody who calls this function will not
1520      want the external symbol information, so if it was allocated
1521      because of our call to aout_get_external_symbols, we free it up
1522      right away to save space.  */
1523   if (old_external_syms == NULL
1524       && obj_aout_external_syms (abfd) != NULL)
1525     {
1526 #ifdef USE_MMAP
1527       bfd_free_window (&obj_aout_sym_window (abfd));
1528 #else
1529       free (obj_aout_external_syms (abfd));
1530 #endif
1531       obj_aout_external_syms (abfd) = NULL;
1532     }
1533
1534   return TRUE;
1535 }
1536 \f
1537 /* We use a hash table when writing out symbols so that we only write
1538    out a particular string once.  This helps particularly when the
1539    linker writes out stabs debugging entries, because each different
1540    contributing object file tends to have many duplicate stabs
1541    strings.
1542
1543    This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1544    if BFD_TRADITIONAL_FORMAT is set.  */
1545
1546 /* Get the index of a string in a strtab, adding it if it is not
1547    already present.  */
1548
1549 static INLINE bfd_size_type
1550 add_to_stringtab (bfd *abfd,
1551                   struct bfd_strtab_hash *tab,
1552                   const char *str,
1553                   bfd_boolean copy)
1554 {
1555   bfd_boolean hash;
1556   bfd_size_type str_index;
1557
1558   /* An index of 0 always means the empty string.  */
1559   if (str == 0 || *str == '\0')
1560     return 0;
1561
1562   /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1563      doesn't understand a hashed string table.  */
1564   hash = TRUE;
1565   if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1566     hash = FALSE;
1567
1568   str_index = _bfd_stringtab_add (tab, str, hash, copy);
1569
1570   if (str_index != (bfd_size_type) -1)
1571     /* Add BYTES_IN_LONG to the return value to account for the
1572        space taken up by the string table size.  */
1573     str_index += BYTES_IN_LONG;
1574
1575   return str_index;
1576 }
1577
1578 /* Write out a strtab.  ABFD is already at the right location in the
1579    file.  */
1580
1581 static bfd_boolean
1582 emit_stringtab (bfd *abfd, struct bfd_strtab_hash *tab)
1583 {
1584   bfd_byte buffer[BYTES_IN_LONG];
1585
1586   /* The string table starts with the size.  */
1587   H_PUT_32 (abfd, _bfd_stringtab_size (tab) + BYTES_IN_LONG, buffer);
1588   if (bfd_bwrite ((void *) buffer, (bfd_size_type) BYTES_IN_LONG, abfd)
1589       != BYTES_IN_LONG)
1590     return FALSE;
1591
1592   return _bfd_stringtab_emit (abfd, tab);
1593 }
1594 \f
1595 bfd_boolean
1596 NAME (aout, write_syms) (bfd *abfd)
1597 {
1598   unsigned int count ;
1599   asymbol **generic = bfd_get_outsymbols (abfd);
1600   struct bfd_strtab_hash *strtab;
1601
1602   strtab = _bfd_stringtab_init ();
1603   if (strtab == NULL)
1604     return FALSE;
1605
1606   for (count = 0; count < bfd_get_symcount (abfd); count++)
1607     {
1608       asymbol *g = generic[count];
1609       bfd_size_type indx;
1610       struct external_nlist nsp;
1611
1612       PUT_WORD (abfd, 0, nsp.e_unused);
1613
1614       indx = add_to_stringtab (abfd, strtab, g->name, FALSE);
1615       if (indx == (bfd_size_type) -1)
1616         goto error_return;
1617       PUT_WORD (abfd, indx, nsp.e_strx);
1618
1619       if (bfd_asymbol_flavour(g) == abfd->xvec->flavour)
1620         H_PUT_8 (abfd, aout_symbol(g)->type,  nsp.e_type);
1621       else
1622         H_PUT_8 (abfd, 0, nsp.e_type);
1623
1624       if (! translate_to_native_sym_flags (abfd, g, &nsp))
1625         goto error_return;
1626
1627       H_PUT_8 (abfd, 0, nsp.e_ovly);
1628
1629       if (bfd_bwrite ((void *)&nsp, (bfd_size_type) EXTERNAL_NLIST_SIZE, abfd)
1630           != EXTERNAL_NLIST_SIZE)
1631         goto error_return;
1632
1633       /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1634          here, at the end.  */
1635       g->KEEPIT = count;
1636     }
1637
1638   if (! emit_stringtab (abfd, strtab))
1639     goto error_return;
1640
1641   _bfd_stringtab_free (strtab);
1642
1643   return TRUE;
1644
1645 error_return:
1646   _bfd_stringtab_free (strtab);
1647   return FALSE;
1648 }
1649
1650 \f
1651 long
1652 NAME (aout, canonicalize_symtab) (bfd *abfd, asymbol **location)
1653 {
1654   unsigned int counter = 0;
1655   aout_symbol_type *symbase;
1656
1657   if (!NAME (aout, slurp_symbol_table) (abfd))
1658     return -1;
1659
1660   for (symbase = obj_aout_symbols (abfd); counter++ < bfd_get_symcount (abfd);)
1661     *(location++) = (asymbol *)(symbase++);
1662   *location++ =0;
1663   return bfd_get_symcount (abfd);
1664 }
1665
1666 \f
1667 /* Output extended relocation information to a file in target byte order.  */
1668
1669 static void
1670 pdp11_aout_swap_reloc_out (bfd *abfd, arelent *g, bfd_byte *natptr)
1671 {
1672   int r_index;
1673   int r_pcrel;
1674   int reloc_entry;
1675   int r_type;
1676   asymbol *sym = *(g->sym_ptr_ptr);
1677   asection *output_section = sym->section->output_section;
1678
1679   if (g->addend != 0)
1680     fprintf (stderr, "BFD: can't do this reloc addend stuff\n");
1681
1682   r_pcrel = g->howto->pc_relative;
1683
1684   if (bfd_is_abs_section (output_section))
1685     r_type = RABS;
1686   else if (output_section == obj_textsec (abfd))
1687     r_type = RTEXT;
1688   else if (output_section == obj_datasec (abfd))
1689     r_type = RDATA;
1690   else if (output_section == obj_bsssec (abfd))
1691     r_type = RBSS;
1692   else if (bfd_is_und_section (output_section))
1693     r_type = REXT;
1694   else if (bfd_is_com_section (output_section))
1695     r_type = REXT;
1696   else
1697     r_type = -1;
1698
1699   BFD_ASSERT (r_type != -1);
1700
1701   if (r_type == RABS)
1702     r_index = 0;
1703   else
1704     r_index = (*(g->sym_ptr_ptr))->KEEPIT;
1705
1706   reloc_entry = r_index << 4 | r_type | r_pcrel;
1707
1708   PUT_WORD (abfd, reloc_entry, natptr);
1709 }
1710
1711 /* BFD deals internally with all things based from the section they're
1712    in. so, something in 10 bytes into a text section  with a base of
1713    50 would have a symbol (.text+10) and know .text vma was 50.
1714
1715    Aout keeps all it's symbols based from zero, so the symbol would
1716    contain 60. This macro subs the base of each section from the value
1717    to give the true offset from the section */
1718
1719
1720 #define MOVE_ADDRESS(ad)                                                \
1721   if (r_extern)                                                         \
1722     {                                                                   \
1723       /* Undefined symbol.  */                                          \
1724       cache_ptr->sym_ptr_ptr = symbols + r_index;                       \
1725       cache_ptr->addend = ad;                                           \
1726     }                                                                   \
1727   else                                                                  \
1728     {                                                                   \
1729       /* Defined, section relative. replace symbol with pointer to      \
1730          symbol which points to section.  */                            \
1731       switch (r_index)                                                  \
1732         {                                                               \
1733         case N_TEXT:                                                    \
1734         case N_TEXT | N_EXT:                                            \
1735           cache_ptr->sym_ptr_ptr  = obj_textsec (abfd)->symbol_ptr_ptr; \
1736           cache_ptr->addend = ad  - su->textsec->vma;                   \
1737           break;                                                        \
1738         case N_DATA:                                                    \
1739         case N_DATA | N_EXT:                                            \
1740           cache_ptr->sym_ptr_ptr  = obj_datasec (abfd)->symbol_ptr_ptr; \
1741           cache_ptr->addend = ad - su->datasec->vma;                    \
1742           break;                                                        \
1743         case N_BSS:                                                     \
1744         case N_BSS | N_EXT:                                             \
1745           cache_ptr->sym_ptr_ptr  = obj_bsssec (abfd)->symbol_ptr_ptr;  \
1746           cache_ptr->addend = ad - su->bsssec->vma;                     \
1747           break;                                                        \
1748         default:                                                        \
1749         case N_ABS:                                                     \
1750         case N_ABS | N_EXT:                                             \
1751           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1752           cache_ptr->addend = ad;                                       \
1753           break;                                                        \
1754         }                                                               \
1755     }
1756
1757 static void
1758 pdp11_aout_swap_reloc_in (bfd *          abfd,
1759                           bfd_byte *     bytes,
1760                           arelent *      cache_ptr,
1761                           bfd_size_type  offset,
1762                           asymbol **     symbols,
1763                           bfd_size_type  symcount)
1764 {
1765   struct aoutdata *su = &(abfd->tdata.aout_data->a);
1766   unsigned int r_index;
1767   int reloc_entry;
1768   int r_extern;
1769   int r_pcrel;
1770
1771   reloc_entry = GET_WORD (abfd, (void *) bytes);
1772
1773   r_pcrel = reloc_entry & RELFLG;
1774
1775   cache_ptr->address = offset;
1776   cache_ptr->howto = howto_table_pdp11 + (r_pcrel ? 1 : 0);
1777
1778   if ((reloc_entry & RTYPE) == RABS)
1779     r_index = N_ABS;
1780   else
1781     r_index = RINDEX (reloc_entry);
1782
1783   /* r_extern reflects whether the symbol the reloc is against is
1784      local or global.  */
1785   r_extern = (reloc_entry & RTYPE) == REXT;
1786
1787   if (r_extern && r_index > symcount)
1788     {
1789       /* We could arrange to return an error, but it might be useful
1790          to see the file even if it is bad.  */
1791       r_extern = 0;
1792       r_index = N_ABS;
1793     }
1794
1795   MOVE_ADDRESS(0);
1796 }
1797
1798 /* Read and swap the relocs for a section.  */
1799
1800 bfd_boolean
1801 NAME (aout, slurp_reloc_table) (bfd *abfd, sec_ptr asect, asymbol **symbols)
1802 {
1803   bfd_byte *rptr;
1804   bfd_size_type count;
1805   bfd_size_type reloc_size;
1806   void * relocs;
1807   arelent *reloc_cache;
1808   size_t each_size;
1809   unsigned int counter = 0;
1810   arelent *cache_ptr;
1811
1812   if (asect->relocation)
1813     return TRUE;
1814
1815   if (asect->flags & SEC_CONSTRUCTOR)
1816     return TRUE;
1817
1818   if (asect == obj_datasec (abfd))
1819     reloc_size = exec_hdr(abfd)->a_drsize;
1820   else if (asect == obj_textsec (abfd))
1821     reloc_size = exec_hdr(abfd)->a_trsize;
1822   else if (asect == obj_bsssec (abfd))
1823     reloc_size = 0;
1824   else
1825     {
1826       bfd_set_error (bfd_error_invalid_operation);
1827       return FALSE;
1828     }
1829
1830   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
1831     return FALSE;
1832
1833   each_size = obj_reloc_entry_size (abfd);
1834
1835   relocs = bfd_malloc (reloc_size);
1836   if (relocs == NULL && reloc_size != 0)
1837     return FALSE;
1838
1839   if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
1840     {
1841       free (relocs);
1842       return FALSE;
1843     }
1844
1845   count = reloc_size / each_size;
1846
1847   /* Count the number of NON-ZERO relocs, this is the count we want.  */
1848   {
1849     unsigned int real_count = 0;
1850
1851     for (counter = 0; counter < count; counter++)
1852       {
1853         int x;
1854
1855         x = GET_WORD (abfd, (char *) relocs + each_size * counter);
1856         if (x != 0)
1857           real_count++;
1858       }
1859
1860     count = real_count;
1861   }
1862
1863   reloc_cache = bfd_zmalloc (count * sizeof (arelent));
1864   if (reloc_cache == NULL && count != 0)
1865     return FALSE;
1866
1867   cache_ptr = reloc_cache;
1868
1869   rptr = relocs;
1870   for (counter = 0;
1871        counter < count;
1872        counter++, rptr += RELOC_SIZE, cache_ptr++)
1873     {
1874       while (GET_WORD (abfd, (void *) rptr) == 0)
1875         {
1876           rptr += RELOC_SIZE;
1877           if ((char *) rptr >= (char *) relocs + reloc_size)
1878             goto done;
1879         }
1880
1881       pdp11_aout_swap_reloc_in (abfd, rptr, cache_ptr,
1882                                 (bfd_size_type) ((char *) rptr - (char *) relocs),
1883                                 symbols,
1884                                 (bfd_size_type) bfd_get_symcount (abfd));
1885     }
1886  done:
1887   /* Just in case, if rptr >= relocs + reloc_size should happen
1888      too early.  */
1889   BFD_ASSERT (counter == count);
1890
1891   free (relocs);
1892
1893   asect->relocation = reloc_cache;
1894   asect->reloc_count = cache_ptr - reloc_cache;
1895
1896   return TRUE;
1897 }
1898
1899 /* Write out a relocation section into an object file.  */
1900
1901 bfd_boolean
1902 NAME (aout, squirt_out_relocs) (bfd *abfd, asection *section)
1903 {
1904   arelent **generic;
1905   unsigned char *native;
1906   unsigned int count = section->reloc_count;
1907   bfd_size_type natsize;
1908
1909   natsize = section->size;
1910   native = bfd_zalloc (abfd, natsize);
1911   if (!native)
1912     return FALSE;
1913
1914   generic = section->orelocation;
1915   if (generic != NULL)
1916     {
1917       while (count > 0)
1918         {
1919           bfd_byte *r;
1920
1921           r = native + (*generic)->address;
1922           pdp11_aout_swap_reloc_out (abfd, *generic, r);
1923           count--;
1924           generic++;
1925         }
1926     }
1927
1928   if (bfd_bwrite ((void *) native, natsize, abfd) != natsize)
1929     {
1930       bfd_release (abfd, native);
1931       return FALSE;
1932     }
1933
1934   bfd_release (abfd, native);
1935   return TRUE;
1936 }
1937
1938 /* This is stupid.  This function should be a boolean predicate.  */
1939
1940 long
1941 NAME (aout, canonicalize_reloc) (bfd *abfd,
1942                                  sec_ptr section,
1943                                  arelent **relptr,
1944                                  asymbol **symbols)
1945 {
1946   arelent *tblptr = section->relocation;
1947   unsigned int count;
1948
1949   if (section == obj_bsssec (abfd))
1950     {
1951       *relptr = NULL;
1952       return 0;
1953     }
1954
1955   if (!(tblptr || NAME (aout, slurp_reloc_table)(abfd, section, symbols)))
1956     return -1;
1957
1958   if (section->flags & SEC_CONSTRUCTOR)
1959     {
1960       arelent_chain *chain = section->constructor_chain;
1961
1962       for (count = 0; count < section->reloc_count; count ++)
1963         {
1964           *relptr ++ = &chain->relent;
1965           chain = chain->next;
1966         }
1967     }
1968   else
1969     {
1970       tblptr = section->relocation;
1971
1972       for (count = 0; count++ < section->reloc_count;)
1973         *relptr++ = tblptr++;
1974     }
1975
1976   *relptr = 0;
1977
1978   return section->reloc_count;
1979 }
1980
1981 long
1982 NAME (aout, get_reloc_upper_bound) (bfd *abfd, sec_ptr asect)
1983 {
1984   bfd_size_type count;
1985
1986   if (bfd_get_format (abfd) != bfd_object)
1987     {
1988       bfd_set_error (bfd_error_invalid_operation);
1989       return -1;
1990     }
1991
1992   if (asect->flags & SEC_CONSTRUCTOR)
1993     count = asect->reloc_count;
1994   else if (asect == obj_datasec (abfd))
1995     count = exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
1996   else if (asect == obj_textsec (abfd))
1997     count = exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
1998   else if (asect == obj_bsssec (abfd))
1999     count = 0;
2000   else
2001     {
2002       bfd_set_error (bfd_error_invalid_operation);
2003       return -1;
2004     }
2005
2006   if (count >= LONG_MAX / sizeof (arelent *))
2007     {
2008       bfd_set_error (bfd_error_file_too_big);
2009       return -1;
2010     }
2011   return (count + 1) * sizeof (arelent *);
2012 }
2013
2014 \f
2015 long
2016 NAME (aout, get_symtab_upper_bound) (bfd *abfd)
2017 {
2018   if (!NAME (aout, slurp_symbol_table) (abfd))
2019     return -1;
2020
2021   return (bfd_get_symcount (abfd) + 1) * (sizeof (aout_symbol_type *));
2022 }
2023
2024 alent *
2025 NAME (aout, get_lineno) (bfd * abfd ATTRIBUTE_UNUSED,
2026                          asymbol * symbol ATTRIBUTE_UNUSED)
2027 {
2028   return NULL;
2029 }
2030
2031 void
2032 NAME (aout, get_symbol_info) (bfd * abfd ATTRIBUTE_UNUSED,
2033                               asymbol *symbol,
2034                               symbol_info *ret)
2035 {
2036   bfd_symbol_info (symbol, ret);
2037
2038   if (ret->type == '?')
2039     {
2040       int type_code = aout_symbol(symbol)->type & 0xff;
2041       const char *stab_name = bfd_get_stab_name (type_code);
2042       static char buf[10];
2043
2044       if (stab_name == NULL)
2045         {
2046           sprintf(buf, "(%d)", type_code);
2047           stab_name = buf;
2048         }
2049       ret->type = '-';
2050       ret->stab_type  = type_code;
2051       ret->stab_other = (unsigned) (aout_symbol(symbol)->other & 0xff);
2052       ret->stab_desc  = (unsigned) (aout_symbol(symbol)->desc & 0xffff);
2053       ret->stab_name  = stab_name;
2054     }
2055 }
2056
2057 void
2058 NAME (aout, print_symbol) (bfd * abfd,
2059                            void * afile,
2060                            asymbol *symbol,
2061                            bfd_print_symbol_type how)
2062 {
2063   FILE *file = (FILE *) afile;
2064
2065   switch (how)
2066     {
2067     case bfd_print_symbol_name:
2068       if (symbol->name)
2069         fprintf(file,"%s", symbol->name);
2070       break;
2071     case bfd_print_symbol_more:
2072       fprintf(file,"%4x %2x %2x",
2073               (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2074               (unsigned) (aout_symbol (symbol)->other & 0xff),
2075               (unsigned) (aout_symbol (symbol)->type));
2076       break;
2077     case bfd_print_symbol_all:
2078       {
2079         const char *section_name = symbol->section->name;
2080
2081         bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2082
2083         fprintf (file," %-5s %04x %02x %02x",
2084                  section_name,
2085                  (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2086                  (unsigned) (aout_symbol (symbol)->other & 0xff),
2087                  (unsigned) (aout_symbol (symbol)->type  & 0xff));
2088         if (symbol->name)
2089           fprintf(file," %s", symbol->name);
2090       }
2091       break;
2092     }
2093 }
2094
2095 /* If we don't have to allocate more than 1MB to hold the generic
2096    symbols, we use the generic minisymbol method: it's faster, since
2097    it only translates the symbols once, not multiple times.  */
2098 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2099
2100 /* Read minisymbols.  For minisymbols, we use the unmodified a.out
2101    symbols.  The minisymbol_to_symbol function translates these into
2102    BFD asymbol structures.  */
2103
2104 long
2105 NAME (aout, read_minisymbols) (bfd *abfd,
2106                                bfd_boolean dynamic,
2107                                void * *minisymsp,
2108                                unsigned int *sizep)
2109 {
2110   if (dynamic)
2111     /* We could handle the dynamic symbols here as well, but it's
2112        easier to hand them off.  */
2113     return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2114
2115   if (! aout_get_external_symbols (abfd))
2116     return -1;
2117
2118   if (obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2119     return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2120
2121   *minisymsp = (void *) obj_aout_external_syms (abfd);
2122
2123   /* By passing the external symbols back from this routine, we are
2124      giving up control over the memory block.  Clear
2125      obj_aout_external_syms, so that we do not try to free it
2126      ourselves.  */
2127   obj_aout_external_syms (abfd) = NULL;
2128
2129   *sizep = EXTERNAL_NLIST_SIZE;
2130   return obj_aout_external_sym_count (abfd);
2131 }
2132
2133 /* Convert a minisymbol to a BFD asymbol.  A minisymbol is just an
2134    unmodified a.out symbol.  The SYM argument is a structure returned
2135    by bfd_make_empty_symbol, which we fill in here.  */
2136
2137 asymbol *
2138 NAME (aout, minisymbol_to_symbol) (bfd *abfd,
2139                                    bfd_boolean dynamic,
2140                                    const void * minisym,
2141                                    asymbol *sym)
2142 {
2143   if (dynamic
2144       || obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2145     return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
2146
2147   memset (sym, 0, sizeof (aout_symbol_type));
2148
2149   /* We call translate_symbol_table to translate a single symbol.  */
2150   if (! (NAME (aout, translate_symbol_table)
2151          (abfd,
2152           (aout_symbol_type *) sym,
2153           (struct external_nlist *) minisym,
2154           (bfd_size_type) 1,
2155           obj_aout_external_strings (abfd),
2156           obj_aout_external_string_size (abfd),
2157           FALSE)))
2158     return NULL;
2159
2160   return sym;
2161 }
2162
2163 /* Provided a BFD, a section and an offset into the section, calculate
2164    and return the name of the source file and the line nearest to the
2165    wanted location.  */
2166
2167 bfd_boolean
2168 NAME (aout, find_nearest_line) (bfd *abfd,
2169                                 asymbol **symbols,
2170                                 asection *section,
2171                                 bfd_vma offset,
2172                                 const char **filename_ptr,
2173                                 const char **functionname_ptr,
2174                                 unsigned int *line_ptr,
2175                                 unsigned int *discriminator_ptr)
2176 {
2177   /* Run down the file looking for the filename, function and linenumber.  */
2178   asymbol **p;
2179   const char *directory_name = NULL;
2180   const char *main_file_name = NULL;
2181   const char *current_file_name = NULL;
2182   const char *line_file_name = NULL; /* Value of current_file_name at line number.  */
2183   bfd_vma low_line_vma = 0;
2184   bfd_vma low_func_vma = 0;
2185   asymbol *func = 0;
2186   size_t filelen, funclen;
2187   char *buf;
2188
2189   *filename_ptr = abfd->filename;
2190   *functionname_ptr = 0;
2191   *line_ptr = 0;
2192   if (discriminator_ptr)
2193     *discriminator_ptr = 0;
2194
2195   if (symbols != NULL)
2196     {
2197       for (p = symbols; *p; p++)
2198         {
2199           aout_symbol_type  *q = (aout_symbol_type *)(*p);
2200         next:
2201           switch (q->type)
2202             {
2203             case N_TEXT:
2204               /* If this looks like a file name symbol, and it comes after
2205                  the line number we have found so far, but before the
2206                  offset, then we have probably not found the right line
2207                  number.  */
2208               if (q->symbol.value <= offset
2209                   && ((q->symbol.value > low_line_vma
2210                        && (line_file_name != NULL
2211                            || *line_ptr != 0))
2212                       || (q->symbol.value > low_func_vma
2213                           && func != NULL)))
2214                 {
2215                   const char * symname;
2216
2217                   symname = q->symbol.name;
2218                   if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
2219                     {
2220                       if (q->symbol.value > low_line_vma)
2221                         {
2222                           *line_ptr = 0;
2223                           line_file_name = NULL;
2224                         }
2225                       if (q->symbol.value > low_func_vma)
2226                         func = NULL;
2227                     }
2228                 }
2229               break;
2230
2231             case N_SO:
2232               /* If this symbol is less than the offset, but greater than
2233                  the line number we have found so far, then we have not
2234                  found the right line number.  */
2235               if (q->symbol.value <= offset)
2236                 {
2237                   if (q->symbol.value > low_line_vma)
2238                     {
2239                       *line_ptr = 0;
2240                       line_file_name = NULL;
2241                     }
2242                   if (q->symbol.value > low_func_vma)
2243                     func = NULL;
2244                 }
2245
2246               main_file_name = current_file_name = q->symbol.name;
2247               /* Look ahead to next symbol to check if that too is an N_SO.  */
2248               p++;
2249               if (*p == NULL)
2250                 break;
2251               q = (aout_symbol_type *)(*p);
2252               if (q->type != (int) N_SO)
2253                 goto next;
2254
2255               /* Found a second N_SO  First is directory; second is filename.  */
2256               directory_name = current_file_name;
2257               main_file_name = current_file_name = q->symbol.name;
2258               if (obj_textsec(abfd) != section)
2259                 goto done;
2260               break;
2261             case N_SOL:
2262               current_file_name = q->symbol.name;
2263               break;
2264
2265             case N_SLINE:
2266             case N_DSLINE:
2267             case N_BSLINE:
2268               /* We'll keep this if it resolves nearer than the one we have
2269                  already.  */
2270               if (q->symbol.value >= low_line_vma
2271                   && q->symbol.value <= offset)
2272                 {
2273                   *line_ptr = q->desc;
2274                   low_line_vma = q->symbol.value;
2275                   line_file_name = current_file_name;
2276                 }
2277               break;
2278
2279             case N_FUN:
2280               {
2281                 /* We'll keep this if it is nearer than the one we have already.  */
2282                 if (q->symbol.value >= low_func_vma &&
2283                     q->symbol.value <= offset)
2284                   {
2285                     low_func_vma = q->symbol.value;
2286                     func = (asymbol *) q;
2287                   }
2288                 else if (q->symbol.value > offset)
2289                   goto done;
2290               }
2291               break;
2292             }
2293         }
2294     }
2295
2296  done:
2297   if (*line_ptr != 0)
2298     main_file_name = line_file_name;
2299
2300   if (main_file_name == NULL
2301       || main_file_name[0] == '/'
2302       || directory_name == NULL)
2303     filelen = 0;
2304   else
2305     filelen = strlen (directory_name) + strlen (main_file_name);
2306   if (func == NULL)
2307     funclen = 0;
2308   else
2309     funclen = strlen (bfd_asymbol_name (func));
2310
2311   if (adata (abfd).line_buf != NULL)
2312     free (adata (abfd).line_buf);
2313   if (filelen + funclen == 0)
2314     adata (abfd).line_buf = buf = NULL;
2315   else
2316     {
2317       buf = bfd_malloc ((bfd_size_type) filelen + funclen + 3);
2318       adata (abfd).line_buf = buf;
2319       if (buf == NULL)
2320         return FALSE;
2321     }
2322
2323   if (main_file_name != NULL)
2324     {
2325       if (main_file_name[0] == '/' || directory_name == NULL)
2326         *filename_ptr = main_file_name;
2327       else
2328         {
2329           sprintf (buf, "%s%s", directory_name, main_file_name);
2330           *filename_ptr = buf;
2331           buf += filelen + 1;
2332         }
2333     }
2334
2335   if (func)
2336     {
2337       const char *function = func->name;
2338       char *colon;
2339
2340       /* The caller expects a symbol name.  We actually have a
2341          function name, without the leading underscore.  Put the
2342          underscore back in, so that the caller gets a symbol name.  */
2343       if (bfd_get_symbol_leading_char (abfd) == '\0')
2344         strcpy (buf, function);
2345       else
2346         {
2347           buf[0] = bfd_get_symbol_leading_char (abfd);
2348           strcpy (buf + 1, function);
2349         }
2350
2351       /* Have to remove : stuff.  */
2352       colon = strchr (buf, ':');
2353       if (colon != NULL)
2354         *colon = '\0';
2355       *functionname_ptr = buf;
2356     }
2357
2358   return TRUE;
2359 }
2360
2361 int
2362 NAME (aout, sizeof_headers) (bfd *abfd,
2363                              struct bfd_link_info *info ATTRIBUTE_UNUSED)
2364 {
2365   return adata (abfd).exec_bytes_size;
2366 }
2367
2368 /* Free all information we have cached for this BFD.  We can always
2369    read it again later if we need it.  */
2370
2371 bfd_boolean
2372 NAME (aout, bfd_free_cached_info) (bfd *abfd)
2373 {
2374   asection *o;
2375
2376   if (bfd_get_format (abfd) != bfd_object)
2377     return TRUE;
2378
2379 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2380   BFCI_FREE (obj_aout_symbols (abfd));
2381
2382 #ifdef USE_MMAP
2383   obj_aout_external_syms (abfd) = 0;
2384   bfd_free_window (&obj_aout_sym_window (abfd));
2385   bfd_free_window (&obj_aout_string_window (abfd));
2386   obj_aout_external_strings (abfd) = 0;
2387 #else
2388   BFCI_FREE (obj_aout_external_syms (abfd));
2389   BFCI_FREE (obj_aout_external_strings (abfd));
2390 #endif
2391   for (o = abfd->sections; o != NULL; o = o->next)
2392     BFCI_FREE (o->relocation);
2393 #undef BFCI_FREE
2394
2395   return TRUE;
2396 }
2397 \f
2398 /* Routine to create an entry in an a.out link hash table.  */
2399
2400 struct bfd_hash_entry *
2401 NAME (aout, link_hash_newfunc) (struct bfd_hash_entry *entry,
2402                                 struct bfd_hash_table *table,
2403                                 const char *string)
2404 {
2405   struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry;
2406
2407   /* Allocate the structure if it has not already been allocated by a
2408      subclass.  */
2409   if (ret == NULL)
2410     ret = bfd_hash_allocate (table, sizeof (* ret));
2411   if (ret == NULL)
2412     return NULL;
2413
2414   /* Call the allocation method of the superclass.  */
2415   ret = (struct aout_link_hash_entry *)
2416          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
2417   if (ret)
2418     {
2419       /* Set local fields.  */
2420       ret->written = FALSE;
2421       ret->indx = -1;
2422     }
2423
2424   return (struct bfd_hash_entry *) ret;
2425 }
2426
2427 /* Initialize an a.out link hash table.  */
2428
2429 bfd_boolean
2430 NAME (aout, link_hash_table_init) (struct aout_link_hash_table *table,
2431                                    bfd *abfd,
2432                                    struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
2433                                                                      struct bfd_hash_table *,
2434                                                                      const char *),
2435                                    unsigned int entsize)
2436 {
2437   return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
2438 }
2439
2440 /* Create an a.out link hash table.  */
2441
2442 struct bfd_link_hash_table *
2443 NAME (aout, link_hash_table_create) (bfd *abfd)
2444 {
2445   struct aout_link_hash_table *ret;
2446   bfd_size_type amt = sizeof (struct aout_link_hash_table);
2447
2448   ret = bfd_malloc (amt);
2449   if (ret == NULL)
2450     return NULL;
2451   if (! NAME (aout, link_hash_table_init) (ret, abfd,
2452                                            NAME (aout, link_hash_newfunc),
2453                                            sizeof (struct aout_link_hash_entry)))
2454     {
2455       free (ret);
2456       return NULL;
2457     }
2458   return &ret->root;
2459 }
2460
2461 /* Free up the internal symbols read from an a.out file.  */
2462
2463 static bfd_boolean
2464 aout_link_free_symbols (bfd *abfd)
2465 {
2466   if (obj_aout_external_syms (abfd) != NULL)
2467     {
2468 #ifdef USE_MMAP
2469       bfd_free_window (&obj_aout_sym_window (abfd));
2470 #else
2471       free ((void *) obj_aout_external_syms (abfd));
2472 #endif
2473       obj_aout_external_syms (abfd) = NULL;
2474     }
2475
2476   if (obj_aout_external_strings (abfd) != NULL)
2477     {
2478 #ifdef USE_MMAP
2479       bfd_free_window (&obj_aout_string_window (abfd));
2480 #else
2481       free ((void *) obj_aout_external_strings (abfd));
2482 #endif
2483       obj_aout_external_strings (abfd) = NULL;
2484     }
2485   return TRUE;
2486 }
2487
2488 /* Given an a.out BFD, add symbols to the global hash table as
2489    appropriate.  */
2490
2491 bfd_boolean
2492 NAME (aout, link_add_symbols) (bfd *abfd, struct bfd_link_info *info)
2493 {
2494   switch (bfd_get_format (abfd))
2495     {
2496     case bfd_object:
2497       return aout_link_add_object_symbols (abfd, info);
2498     case bfd_archive:
2499       return _bfd_generic_link_add_archive_symbols
2500         (abfd, info, aout_link_check_archive_element);
2501     default:
2502       bfd_set_error (bfd_error_wrong_format);
2503       return FALSE;
2504     }
2505 }
2506
2507 /* Add symbols from an a.out object file.  */
2508
2509 static bfd_boolean
2510 aout_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
2511 {
2512   if (! aout_get_external_symbols (abfd))
2513     return FALSE;
2514   if (! aout_link_add_symbols (abfd, info))
2515     return FALSE;
2516   if (! info->keep_memory)
2517     {
2518       if (! aout_link_free_symbols (abfd))
2519         return FALSE;
2520     }
2521   return TRUE;
2522 }
2523
2524 /* Look through the internal symbols to see if this object file should
2525    be included in the link.  We should include this object file if it
2526    defines any symbols which are currently undefined.  If this object
2527    file defines a common symbol, then we may adjust the size of the
2528    known symbol but we do not include the object file in the link
2529    (unless there is some other reason to include it).  */
2530
2531 static bfd_boolean
2532 aout_link_check_ar_symbols (bfd *abfd,
2533                             struct bfd_link_info *info,
2534                             bfd_boolean *pneeded,
2535                             bfd **subsbfd)
2536 {
2537   struct external_nlist *p;
2538   struct external_nlist *pend;
2539   char *strings;
2540
2541   *pneeded = FALSE;
2542
2543   /* Look through all the symbols.  */
2544   p = obj_aout_external_syms (abfd);
2545   pend = p + obj_aout_external_sym_count (abfd);
2546   strings = obj_aout_external_strings (abfd);
2547   for (; p < pend; p++)
2548     {
2549       int type = H_GET_8 (abfd, p->e_type);
2550       const char *name;
2551       struct bfd_link_hash_entry *h;
2552
2553       /* Ignore symbols that are not externally visible.  This is an
2554          optimization only, as we check the type more thoroughly
2555          below.  */
2556       if ((type & N_EXT) == 0
2557           || type == N_FN)
2558         continue;
2559
2560       name = strings + GET_WORD (abfd, p->e_strx);
2561       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
2562
2563       /* We are only interested in symbols that are currently
2564          undefined or common.  */
2565       if (h == NULL
2566           || (h->type != bfd_link_hash_undefined
2567               && h->type != bfd_link_hash_common))
2568         continue;
2569
2570       if (type == (N_TEXT | N_EXT)
2571           || type == (N_DATA | N_EXT)
2572           || type == (N_BSS | N_EXT)
2573           || type == (N_ABS | N_EXT))
2574         {
2575           /* This object file defines this symbol.  We must link it
2576              in.  This is true regardless of whether the current
2577              definition of the symbol is undefined or common.  If the
2578              current definition is common, we have a case in which we
2579              have already seen an object file including
2580                  int a;
2581              and this object file from the archive includes
2582                  int a = 5;
2583              In such a case we must include this object file.
2584
2585              FIXME: The SunOS 4.1.3 linker will pull in the archive
2586              element if the symbol is defined in the .data section,
2587              but not if it is defined in the .text section.  That
2588              seems a bit crazy to me, and I haven't implemented it.
2589              However, it might be correct.  */
2590           if (!(*info->callbacks
2591                 ->add_archive_element) (info, abfd, name, subsbfd))
2592             continue;
2593           *pneeded = TRUE;
2594           return TRUE;
2595         }
2596
2597       if (type == (N_UNDF | N_EXT))
2598         {
2599           bfd_vma value;
2600
2601           value = GET_WORD (abfd, p->e_value);
2602           if (value != 0)
2603             {
2604               /* This symbol is common in the object from the archive
2605                  file.  */
2606               if (h->type == bfd_link_hash_undefined)
2607                 {
2608                   bfd *symbfd;
2609                   unsigned int power;
2610
2611                   symbfd = h->u.undef.abfd;
2612                   if (symbfd == NULL)
2613                     {
2614                       /* This symbol was created as undefined from
2615                          outside BFD.  We assume that we should link
2616                          in the object file.  This is done for the -u
2617                          option in the linker.  */
2618                       if (!(*info->callbacks
2619                             ->add_archive_element) (info, abfd, name, subsbfd))
2620                         return FALSE;
2621                       *pneeded = TRUE;
2622                       return TRUE;
2623                     }
2624                   /* Turn the current link symbol into a common
2625                      symbol.  It is already on the undefs list.  */
2626                   h->type = bfd_link_hash_common;
2627                   h->u.c.p = bfd_hash_allocate (&info->hash->table,
2628                                                 sizeof (struct bfd_link_hash_common_entry));
2629                   if (h->u.c.p == NULL)
2630                     return FALSE;
2631
2632                   h->u.c.size = value;
2633
2634                   /* FIXME: This isn't quite right.  The maximum
2635                      alignment of a common symbol should be set by the
2636                      architecture of the output file, not of the input
2637                      file.  */
2638                   power = bfd_log2 (value);
2639                   if (power > bfd_get_arch_info (abfd)->section_align_power)
2640                     power = bfd_get_arch_info (abfd)->section_align_power;
2641                   h->u.c.p->alignment_power = power;
2642
2643                   h->u.c.p->section = bfd_make_section_old_way (symbfd,
2644                                                                 "COMMON");
2645                 }
2646               else
2647                 {
2648                   /* Adjust the size of the common symbol if
2649                      necessary.  */
2650                   if (value > h->u.c.size)
2651                     h->u.c.size = value;
2652                 }
2653             }
2654         }
2655     }
2656
2657   /* We do not need this object file.  */
2658   return TRUE;
2659 }
2660
2661 /* Check a single archive element to see if we need to include it in
2662    the link.  *PNEEDED is set according to whether this element is
2663    needed in the link or not.  This is called from
2664    _bfd_generic_link_add_archive_symbols.  */
2665
2666 static bfd_boolean
2667 aout_link_check_archive_element (bfd *abfd,
2668                                  struct bfd_link_info *info,
2669                                  struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED,
2670                                  const char *name ATTRIBUTE_UNUSED,
2671                                  bfd_boolean *pneeded)
2672 {
2673   bfd *oldbfd;
2674   bfd_boolean needed;
2675
2676   if (!aout_get_external_symbols (abfd))
2677     return FALSE;
2678
2679   oldbfd = abfd;
2680   if (!aout_link_check_ar_symbols (abfd, info, pneeded, &abfd))
2681     return FALSE;
2682
2683   needed = *pneeded;
2684   if (needed)
2685     {
2686       /* Potentially, the add_archive_element hook may have set a
2687          substitute BFD for us.  */
2688       if (abfd != oldbfd)
2689         {
2690           if (!info->keep_memory
2691               && !aout_link_free_symbols (oldbfd))
2692             return FALSE;
2693           if (!aout_get_external_symbols (abfd))
2694             return FALSE;
2695         }
2696       if (!aout_link_add_symbols (abfd, info))
2697         return FALSE;
2698     }
2699
2700   if (!info->keep_memory || !needed)
2701     {
2702       if (!aout_link_free_symbols (abfd))
2703         return FALSE;
2704     }
2705
2706   return TRUE;
2707 }
2708
2709 /* Add all symbols from an object file to the hash table.  */
2710
2711 static bfd_boolean
2712 aout_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
2713 {
2714   bfd_boolean (*add_one_symbol)
2715     (struct bfd_link_info *, bfd *, const char *, flagword, asection *,
2716      bfd_vma, const char *, bfd_boolean, bfd_boolean,
2717      struct bfd_link_hash_entry **);
2718   struct external_nlist *syms;
2719   bfd_size_type sym_count;
2720   char *strings;
2721   bfd_boolean copy;
2722   struct aout_link_hash_entry **sym_hash;
2723   struct external_nlist *p;
2724   struct external_nlist *pend;
2725
2726   syms = obj_aout_external_syms (abfd);
2727   sym_count = obj_aout_external_sym_count (abfd);
2728   strings = obj_aout_external_strings (abfd);
2729   if (info->keep_memory)
2730     copy = FALSE;
2731   else
2732     copy = TRUE;
2733
2734   if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
2735     {
2736       if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
2737              (abfd, info, &syms, &sym_count, &strings)))
2738         return FALSE;
2739     }
2740
2741   /* We keep a list of the linker hash table entries that correspond
2742      to particular symbols.  We could just look them up in the hash
2743      table, but keeping the list is more efficient.  Perhaps this
2744      should be conditional on info->keep_memory.  */
2745   sym_hash = bfd_alloc (abfd,
2746                         sym_count * sizeof (struct aout_link_hash_entry *));
2747   if (sym_hash == NULL && sym_count != 0)
2748     return FALSE;
2749   obj_aout_sym_hashes (abfd) = sym_hash;
2750
2751   add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
2752   if (add_one_symbol == NULL)
2753     add_one_symbol = _bfd_generic_link_add_one_symbol;
2754
2755   p = syms;
2756   pend = p + sym_count;
2757   for (; p < pend; p++, sym_hash++)
2758     {
2759       int type;
2760       const char *name;
2761       bfd_vma value;
2762       asection *section;
2763       flagword flags;
2764       const char *string;
2765
2766       *sym_hash = NULL;
2767
2768       type = H_GET_8 (abfd, p->e_type);
2769
2770       name = strings + GET_WORD (abfd, p->e_strx);
2771       value = GET_WORD (abfd, p->e_value);
2772       flags = BSF_GLOBAL;
2773       string = NULL;
2774       switch (type)
2775         {
2776         default:
2777           /* Anything else should be a debugging symbol.  */
2778           BFD_ASSERT ((type & N_STAB) != 0);
2779           continue;
2780
2781         case N_UNDF:
2782         case N_ABS:
2783         case N_TEXT:
2784         case N_DATA:
2785         case N_BSS:
2786         case N_REG:
2787         case N_FN:
2788           /* Ignore symbols that are not externally visible.  */
2789           continue;
2790
2791         case N_UNDF | N_EXT:
2792           if (value == 0)
2793             {
2794               section = bfd_und_section_ptr;
2795               flags = 0;
2796             }
2797           else
2798             section = bfd_com_section_ptr;
2799           break;
2800         case N_ABS | N_EXT:
2801           section = bfd_abs_section_ptr;
2802           break;
2803         case N_TEXT | N_EXT:
2804           section = obj_textsec (abfd);
2805           value -= bfd_get_section_vma (abfd, section);
2806           break;
2807         case N_DATA | N_EXT:
2808           /* Treat N_SETV symbols as N_DATA symbol; see comment in
2809              translate_from_native_sym_flags.  */
2810           section = obj_datasec (abfd);
2811           value -= bfd_get_section_vma (abfd, section);
2812           break;
2813         case N_BSS | N_EXT:
2814           section = obj_bsssec (abfd);
2815           value -= bfd_get_section_vma (abfd, section);
2816           break;
2817         }
2818
2819       if (! ((*add_one_symbol)
2820              (info, abfd, name, flags, section, value, string, copy, FALSE,
2821               (struct bfd_link_hash_entry **) sym_hash)))
2822         return FALSE;
2823
2824       /* Restrict the maximum alignment of a common symbol based on
2825          the architecture, since a.out has no way to represent
2826          alignment requirements of a section in a .o file.  FIXME:
2827          This isn't quite right: it should use the architecture of the
2828          output file, not the input files.  */
2829       if ((*sym_hash)->root.type == bfd_link_hash_common
2830           && ((*sym_hash)->root.u.c.p->alignment_power >
2831               bfd_get_arch_info (abfd)->section_align_power))
2832         (*sym_hash)->root.u.c.p->alignment_power =
2833           bfd_get_arch_info (abfd)->section_align_power;
2834
2835       /* If this is a set symbol, and we are not building sets, then
2836          it is possible for the hash entry to not have been set.  In
2837          such a case, treat the symbol as not globally defined.  */
2838       if ((*sym_hash)->root.type == bfd_link_hash_new)
2839         {
2840           BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
2841           *sym_hash = NULL;
2842         }
2843     }
2844
2845   return TRUE;
2846 }
2847 \f
2848 /* Look up an entry in an the header file hash table.  */
2849
2850 #define aout_link_includes_lookup(table, string, create, copy) \
2851   ((struct aout_link_includes_entry *) \
2852    bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
2853
2854 /* The function to create a new entry in the header file hash table.  */
2855
2856 static struct bfd_hash_entry *
2857 aout_link_includes_newfunc (struct bfd_hash_entry *entry,
2858                             struct bfd_hash_table *table,
2859                             const char *string)
2860 {
2861   struct aout_link_includes_entry * ret =
2862     (struct aout_link_includes_entry *) entry;
2863
2864   /* Allocate the structure if it has not already been allocated by a
2865      subclass.  */
2866   if (ret == NULL)
2867     ret = bfd_hash_allocate (table,
2868                              sizeof (struct aout_link_includes_entry));
2869   if (ret == NULL)
2870     return NULL;
2871
2872   /* Call the allocation method of the superclass.  */
2873   ret = ((struct aout_link_includes_entry *)
2874          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
2875   if (ret)
2876     /* Set local fields.  */
2877     ret->totals = NULL;
2878
2879   return (struct bfd_hash_entry *) ret;
2880 }
2881
2882 static bfd_boolean
2883 aout_link_write_other_symbol (struct bfd_hash_entry *bh, void *data)
2884 {
2885   struct aout_link_hash_entry *h = (struct aout_link_hash_entry *) bh;
2886   struct aout_final_link_info *flaginfo = (struct aout_final_link_info *) data;
2887   bfd *output_bfd;
2888   int type;
2889   bfd_vma val;
2890   struct external_nlist outsym;
2891   bfd_size_type indx;
2892   bfd_size_type amt;
2893
2894   if (h->root.type == bfd_link_hash_warning)
2895     {
2896       h = (struct aout_link_hash_entry *) h->root.u.i.link;
2897       if (h->root.type == bfd_link_hash_new)
2898         return TRUE;
2899     }
2900
2901   output_bfd = flaginfo->output_bfd;
2902
2903   if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
2904     {
2905       if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
2906              (output_bfd, flaginfo->info, h)))
2907         {
2908           /* FIXME: No way to handle errors.  */
2909           abort ();
2910         }
2911     }
2912
2913   if (h->written)
2914     return TRUE;
2915
2916   h->written = TRUE;
2917
2918   /* An indx of -2 means the symbol must be written.  */
2919   if (h->indx != -2
2920       && (flaginfo->info->strip == strip_all
2921           || (flaginfo->info->strip == strip_some
2922               && bfd_hash_lookup (flaginfo->info->keep_hash, h->root.root.string,
2923                                   FALSE, FALSE) == NULL)))
2924     return TRUE;
2925
2926   switch (h->root.type)
2927     {
2928     default:
2929       abort ();
2930       /* Avoid variable not initialized warnings.  */
2931       return TRUE;
2932     case bfd_link_hash_new:
2933       /* This can happen for set symbols when sets are not being
2934          built.  */
2935       return TRUE;
2936     case bfd_link_hash_undefined:
2937       type = N_UNDF | N_EXT;
2938       val = 0;
2939       break;
2940     case bfd_link_hash_defined:
2941     case bfd_link_hash_defweak:
2942       {
2943         asection *sec;
2944
2945         sec = h->root.u.def.section->output_section;
2946         BFD_ASSERT (bfd_is_abs_section (sec)
2947                     || sec->owner == output_bfd);
2948         if (sec == obj_textsec (output_bfd))
2949           type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
2950         else if (sec == obj_datasec (output_bfd))
2951           type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
2952         else if (sec == obj_bsssec (output_bfd))
2953           type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
2954         else
2955           type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
2956         type |= N_EXT;
2957         val = (h->root.u.def.value
2958                + sec->vma
2959                + h->root.u.def.section->output_offset);
2960       }
2961       break;
2962     case bfd_link_hash_common:
2963       type = N_UNDF | N_EXT;
2964       val = h->root.u.c.size;
2965       break;
2966     case bfd_link_hash_undefweak:
2967       type = N_WEAKU;
2968       val = 0;
2969       /* Fall through.  */
2970     case bfd_link_hash_indirect:
2971     case bfd_link_hash_warning:
2972       /* FIXME: Ignore these for now.  The circumstances under which
2973          they should be written out are not clear to me.  */
2974       return TRUE;
2975     }
2976
2977   H_PUT_8 (output_bfd, type, outsym.e_type);
2978   indx = add_to_stringtab (output_bfd, flaginfo->strtab, h->root.root.string,
2979                            FALSE);
2980   if (indx == (bfd_size_type) -1)
2981     /* FIXME: No way to handle errors.  */
2982     abort ();
2983
2984   PUT_WORD (output_bfd, indx, outsym.e_strx);
2985   PUT_WORD (output_bfd, val, outsym.e_value);
2986
2987   amt = EXTERNAL_NLIST_SIZE;
2988   if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0
2989       || bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt)
2990     /* FIXME: No way to handle errors.  */
2991     abort ();
2992
2993   flaginfo->symoff += amt;
2994   h->indx = obj_aout_external_sym_count (output_bfd);
2995   ++obj_aout_external_sym_count (output_bfd);
2996
2997   return TRUE;
2998 }
2999
3000 /* Handle a link order which is supposed to generate a reloc.  */
3001
3002 static bfd_boolean
3003 aout_link_reloc_link_order (struct aout_final_link_info *flaginfo,
3004                             asection *o,
3005                             struct bfd_link_order *p)
3006 {
3007   struct bfd_link_order_reloc *pr;
3008   int r_index;
3009   int r_extern;
3010   reloc_howto_type *howto;
3011   file_ptr *reloff_ptr;
3012   struct reloc_std_external srel;
3013   void * rel_ptr;
3014   bfd_size_type rel_size;
3015
3016   pr = p->u.reloc.p;
3017
3018   if (p->type == bfd_section_reloc_link_order)
3019     {
3020       r_extern = 0;
3021       if (bfd_is_abs_section (pr->u.section))
3022         r_index = N_ABS | N_EXT;
3023       else
3024         {
3025           BFD_ASSERT (pr->u.section->owner == flaginfo->output_bfd);
3026           r_index = pr->u.section->target_index;
3027         }
3028     }
3029   else
3030     {
3031       struct aout_link_hash_entry *h;
3032
3033       BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
3034       r_extern = 1;
3035       h = ((struct aout_link_hash_entry *)
3036            bfd_wrapped_link_hash_lookup (flaginfo->output_bfd, flaginfo->info,
3037                                          pr->u.name, FALSE, FALSE, TRUE));
3038       if (h != NULL
3039           && h->indx >= 0)
3040         r_index = h->indx;
3041       else if (h != NULL)
3042         {
3043           /* We decided to strip this symbol, but it turns out that we
3044              can't.  Note that we lose the other and desc information
3045              here.  I don't think that will ever matter for a global
3046              symbol.  */
3047           h->indx = -2;
3048           h->written = FALSE;
3049           if (!aout_link_write_other_symbol (&h->root.root, flaginfo))
3050             return FALSE;
3051           r_index = h->indx;
3052         }
3053       else
3054         {
3055           (*flaginfo->info->callbacks->unattached_reloc)
3056             (flaginfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0);
3057           r_index = 0;
3058         }
3059     }
3060
3061   howto = bfd_reloc_type_lookup (flaginfo->output_bfd, pr->reloc);
3062   if (howto == 0)
3063     {
3064       bfd_set_error (bfd_error_bad_value);
3065       return FALSE;
3066     }
3067
3068   if (o == obj_textsec (flaginfo->output_bfd))
3069     reloff_ptr = &flaginfo->treloff;
3070   else if (o == obj_datasec (flaginfo->output_bfd))
3071     reloff_ptr = &flaginfo->dreloff;
3072   else
3073     abort ();
3074
3075 #ifdef MY_put_reloc
3076   MY_put_reloc(flaginfo->output_bfd, r_extern, r_index, p->offset, howto,
3077                &srel);
3078 #else
3079   {
3080     int r_pcrel;
3081     int r_baserel;
3082     int r_jmptable;
3083     int r_relative;
3084     int r_length;
3085
3086     fprintf (stderr, "TODO: line %d in bfd/pdp11.c\n", __LINE__);
3087
3088     r_pcrel = howto->pc_relative;
3089     r_baserel = (howto->type & 8) != 0;
3090     r_jmptable = (howto->type & 16) != 0;
3091     r_relative = (howto->type & 32) != 0;
3092     r_length = howto->size;
3093
3094     PUT_WORD (flaginfo->output_bfd, p->offset, srel.r_address);
3095     if (bfd_header_big_endian (flaginfo->output_bfd))
3096       {
3097         srel.r_index[0] = r_index >> 16;
3098         srel.r_index[1] = r_index >> 8;
3099         srel.r_index[2] = r_index;
3100         srel.r_type[0] =
3101           ((r_extern ?     RELOC_STD_BITS_EXTERN_BIG : 0)
3102            | (r_pcrel ?    RELOC_STD_BITS_PCREL_BIG : 0)
3103            | (r_baserel ?  RELOC_STD_BITS_BASEREL_BIG : 0)
3104            | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
3105            | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
3106            | (r_length <<  RELOC_STD_BITS_LENGTH_SH_BIG));
3107       }
3108     else
3109       {
3110         srel.r_index[2] = r_index >> 16;
3111         srel.r_index[1] = r_index >> 8;
3112         srel.r_index[0] = r_index;
3113         srel.r_type[0] =
3114           ((r_extern ?     RELOC_STD_BITS_EXTERN_LITTLE : 0)
3115            | (r_pcrel ?    RELOC_STD_BITS_PCREL_LITTLE : 0)
3116            | (r_baserel ?  RELOC_STD_BITS_BASEREL_LITTLE : 0)
3117            | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
3118            | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
3119            | (r_length <<  RELOC_STD_BITS_LENGTH_SH_LITTLE));
3120       }
3121   }
3122 #endif
3123   rel_ptr = (void *) &srel;
3124
3125   /* We have to write the addend into the object file, since
3126      standard a.out relocs are in place.  It would be more
3127      reliable if we had the current contents of the file here,
3128      rather than assuming zeroes, but we can't read the file since
3129      it was opened using bfd_openw.  */
3130   if (pr->addend != 0)
3131     {
3132       bfd_size_type size;
3133       bfd_reloc_status_type r;
3134       bfd_byte *buf;
3135       bfd_boolean ok;
3136
3137       size = bfd_get_reloc_size (howto);
3138       buf = bfd_zmalloc (size);
3139       if (buf == NULL && size != 0)
3140         return FALSE;
3141       r = MY_relocate_contents (howto, flaginfo->output_bfd,
3142                                 pr->addend, buf);
3143       switch (r)
3144         {
3145         case bfd_reloc_ok:
3146           break;
3147         default:
3148         case bfd_reloc_outofrange:
3149           abort ();
3150         case bfd_reloc_overflow:
3151           (*flaginfo->info->callbacks->reloc_overflow)
3152             (flaginfo->info, NULL,
3153              (p->type == bfd_section_reloc_link_order
3154               ? bfd_section_name (flaginfo->output_bfd,
3155                                   pr->u.section)
3156               : pr->u.name),
3157              howto->name, pr->addend, NULL,
3158              (asection *) NULL, (bfd_vma) 0);
3159           break;
3160         }
3161       ok = bfd_set_section_contents (flaginfo->output_bfd, o,
3162                                      (void *) buf,
3163                                      (file_ptr) p->offset,
3164                                      size);
3165       free (buf);
3166       if (! ok)
3167         return FALSE;
3168     }
3169
3170   rel_size = obj_reloc_entry_size (flaginfo->output_bfd);
3171   if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
3172       || bfd_bwrite (rel_ptr, rel_size, flaginfo->output_bfd) != rel_size)
3173     return FALSE;
3174
3175   *reloff_ptr += rel_size;
3176
3177   /* Assert that the relocs have not run into the symbols, and that n
3178      the text relocs have not run into the data relocs.  */
3179   BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd)
3180               && (reloff_ptr != &flaginfo->treloff
3181                   || (*reloff_ptr
3182                       <= obj_datasec (flaginfo->output_bfd)->rel_filepos)));
3183
3184   return TRUE;
3185 }
3186
3187 /* Get the section corresponding to a reloc index.  */
3188
3189 static inline asection *
3190 aout_reloc_type_to_section (bfd *abfd, int type)
3191 {
3192   switch (type)
3193     {
3194     case RTEXT: return obj_textsec (abfd);
3195     case RDATA: return obj_datasec (abfd);
3196     case RBSS:  return obj_bsssec (abfd);
3197     case RABS:  return bfd_abs_section_ptr;
3198     case REXT:  return bfd_und_section_ptr;
3199     default:    abort ();
3200     }
3201 }
3202
3203 static bfd_boolean
3204 pdp11_aout_link_input_section (struct aout_final_link_info *flaginfo,
3205                                bfd *input_bfd,
3206                                asection *input_section,
3207                                bfd_byte *relocs,
3208                                bfd_size_type rel_size,
3209                                bfd_byte *contents)
3210 {
3211   bfd_boolean (*check_dynamic_reloc)
3212     (struct bfd_link_info *, bfd *, asection *,
3213      struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
3214      bfd_vma *);
3215   bfd *output_bfd;
3216   bfd_boolean relocatable;
3217   struct external_nlist *syms;
3218   char *strings;
3219   struct aout_link_hash_entry **sym_hashes;
3220   int *symbol_map;
3221   bfd_byte *rel;
3222   bfd_byte *rel_end;
3223
3224   output_bfd = flaginfo->output_bfd;
3225   check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
3226
3227   BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_SIZE);
3228   BFD_ASSERT (input_bfd->xvec->header_byteorder
3229               == output_bfd->xvec->header_byteorder);
3230
3231   relocatable = bfd_link_relocatable (flaginfo->info);
3232   syms = obj_aout_external_syms (input_bfd);
3233   strings = obj_aout_external_strings (input_bfd);
3234   sym_hashes = obj_aout_sym_hashes (input_bfd);
3235   symbol_map = flaginfo->symbol_map;
3236
3237   rel = relocs;
3238   rel_end = rel + rel_size;
3239   for (; rel < rel_end; rel += RELOC_SIZE)
3240     {
3241       bfd_vma r_addr;
3242       int r_index;
3243       int r_type;
3244       int r_pcrel;
3245       int r_extern;
3246       reloc_howto_type *howto;
3247       struct aout_link_hash_entry *h = NULL;
3248       bfd_vma relocation;
3249       bfd_reloc_status_type r;
3250       int reloc_entry;
3251
3252       reloc_entry = GET_WORD (input_bfd, (void *) rel);
3253       if (reloc_entry == 0)
3254         continue;
3255
3256       {
3257         unsigned int howto_idx;
3258
3259         r_index = (reloc_entry & RIDXMASK) >> 4;
3260         r_type = reloc_entry & RTYPE;
3261         r_pcrel = reloc_entry & RELFLG;
3262         r_addr = (char *) rel - (char *) relocs;
3263
3264         r_extern = (r_type == REXT);
3265
3266         howto_idx = r_pcrel;
3267         BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_pdp11));
3268         howto = howto_table_pdp11 + howto_idx;
3269       }
3270
3271       if (relocatable)
3272         {
3273           /* We are generating a relocatable output file, and must
3274              modify the reloc accordingly.  */
3275           if (r_extern)
3276             {
3277               /* If we know the symbol this relocation is against,
3278                  convert it into a relocation against a section.  This
3279                  is what the native linker does.  */
3280               h = sym_hashes[r_index];
3281               if (h != NULL
3282                   && (h->root.type == bfd_link_hash_defined
3283                       || h->root.type == bfd_link_hash_defweak))
3284                 {
3285                   asection *output_section;
3286
3287                   /* Compute a new r_index.  */
3288                   output_section = h->root.u.def.section->output_section;
3289                   if (output_section == obj_textsec (output_bfd))
3290                     r_type = N_TEXT;
3291                   else if (output_section == obj_datasec (output_bfd))
3292                     r_type = N_DATA;
3293                   else if (output_section == obj_bsssec (output_bfd))
3294                     r_type = N_BSS;
3295                   else
3296                     r_type = N_ABS;
3297
3298                   /* Add the symbol value and the section VMA to the
3299                      addend stored in the contents.  */
3300                   relocation = (h->root.u.def.value
3301                                 + output_section->vma
3302                                 + h->root.u.def.section->output_offset);
3303                 }
3304               else
3305                 {
3306                   /* We must change r_index according to the symbol
3307                      map.  */
3308                   r_index = symbol_map[r_index];
3309
3310                   if (r_index == -1)
3311                     {
3312                       if (h != NULL)
3313                         {
3314                           /* We decided to strip this symbol, but it
3315                              turns out that we can't.  Note that we
3316                              lose the other and desc information here.
3317                              I don't think that will ever matter for a
3318                              global symbol.  */
3319                           if (h->indx < 0)
3320                             {
3321                               h->indx = -2;
3322                               h->written = FALSE;
3323                               if (!aout_link_write_other_symbol (&h->root.root,
3324                                                                  flaginfo))
3325                                 return FALSE;
3326                             }
3327                           r_index = h->indx;
3328                         }
3329                       else
3330                         {
3331                           const char *name;
3332
3333                           name = strings + GET_WORD (input_bfd,
3334                                                      syms[r_index].e_strx);
3335                           (*flaginfo->info->callbacks->unattached_reloc)
3336                             (flaginfo->info, name, input_bfd, input_section,
3337                              r_addr);
3338                           r_index = 0;
3339                         }
3340                     }
3341
3342                   relocation = 0;
3343                 }
3344
3345               /* Write out the new r_index value.  */
3346               reloc_entry = GET_WORD (input_bfd, rel);
3347               reloc_entry &= RIDXMASK;
3348               reloc_entry |= r_index << 4;
3349               PUT_WORD (input_bfd, reloc_entry, rel);
3350             }
3351           else
3352             {
3353               asection *section;
3354
3355               /* This is a relocation against a section.  We must
3356                  adjust by the amount that the section moved.  */
3357               section = aout_reloc_type_to_section (input_bfd, r_type);
3358               relocation = (section->output_section->vma
3359                             + section->output_offset
3360                             - section->vma);
3361             }
3362
3363           /* Change the address of the relocation.  */
3364           fprintf (stderr, "TODO: change the address of the relocation\n");
3365
3366           /* Adjust a PC relative relocation by removing the reference
3367              to the original address in the section and including the
3368              reference to the new address.  */
3369           if (r_pcrel)
3370             relocation -= (input_section->output_section->vma
3371                            + input_section->output_offset
3372                            - input_section->vma);
3373
3374 #ifdef MY_relocatable_reloc
3375           MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr);
3376 #endif
3377
3378           if (relocation == 0)
3379             r = bfd_reloc_ok;
3380           else
3381             r = MY_relocate_contents (howto,
3382                                       input_bfd, relocation,
3383                                       contents + r_addr);
3384         }
3385       else
3386         {
3387           bfd_boolean hundef;
3388
3389           /* We are generating an executable, and must do a full
3390              relocation.  */
3391           hundef = FALSE;
3392           if (r_extern)
3393             {
3394               h = sym_hashes[r_index];
3395
3396               if (h != NULL
3397                   && (h->root.type == bfd_link_hash_defined
3398                       || h->root.type == bfd_link_hash_defweak))
3399                 {
3400                   relocation = (h->root.u.def.value
3401                                 + h->root.u.def.section->output_section->vma
3402                                 + h->root.u.def.section->output_offset);
3403                 }
3404               else if (h != NULL
3405                        && h->root.type == bfd_link_hash_undefweak)
3406                 relocation = 0;
3407               else
3408                 {
3409                   hundef = TRUE;
3410                   relocation = 0;
3411                 }
3412             }
3413           else
3414             {
3415               asection *section;
3416
3417               section = aout_reloc_type_to_section (input_bfd, r_type);
3418               relocation = (section->output_section->vma
3419                             + section->output_offset
3420                             - section->vma);
3421               if (r_pcrel)
3422                 relocation += input_section->vma;
3423             }
3424
3425           if (check_dynamic_reloc != NULL)
3426             {
3427               bfd_boolean skip;
3428
3429               if (! ((*check_dynamic_reloc)
3430                      (flaginfo->info, input_bfd, input_section, h,
3431                       (void *) rel, contents, &skip, &relocation)))
3432                 return FALSE;
3433               if (skip)
3434                 continue;
3435             }
3436
3437           /* Now warn if a global symbol is undefined.  We could not
3438              do this earlier, because check_dynamic_reloc might want
3439              to skip this reloc.  */
3440           if (hundef && ! bfd_link_pic (flaginfo->info))
3441             {
3442               const char *name;
3443
3444               if (h != NULL)
3445                 name = h->root.root.string;
3446               else
3447                 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
3448               (*flaginfo->info->callbacks->undefined_symbol)
3449                 (flaginfo->info, name, input_bfd, input_section,
3450                  r_addr, TRUE);
3451             }
3452
3453           r = MY_final_link_relocate (howto,
3454                                       input_bfd, input_section,
3455                                       contents, r_addr, relocation,
3456                                       (bfd_vma) 0);
3457         }
3458
3459       if (r != bfd_reloc_ok)
3460         {
3461           switch (r)
3462             {
3463             default:
3464             case bfd_reloc_outofrange:
3465               abort ();
3466             case bfd_reloc_overflow:
3467               {
3468                 const char *name;
3469
3470                 if (h != NULL)
3471                   name = NULL;
3472                 else if (r_extern)
3473                   name = strings + GET_WORD (input_bfd,
3474                                              syms[r_index].e_strx);
3475                 else
3476                   {
3477                     asection *s;
3478
3479                     s = aout_reloc_type_to_section (input_bfd, r_type);
3480                     name = bfd_section_name (input_bfd, s);
3481                   }
3482                 (*flaginfo->info->callbacks->reloc_overflow)
3483                   (flaginfo->info, (h ? &h->root : NULL), name, howto->name,
3484                    (bfd_vma) 0, input_bfd, input_section, r_addr);
3485               }
3486               break;
3487             }
3488         }
3489     }
3490
3491   return TRUE;
3492 }
3493
3494 /* Link an a.out section into the output file.  */
3495
3496 static bfd_boolean
3497 aout_link_input_section (struct aout_final_link_info *flaginfo,
3498                          bfd *input_bfd,
3499                          asection *input_section,
3500                          file_ptr *reloff_ptr,
3501                          bfd_size_type rel_size)
3502 {
3503   bfd_size_type input_size;
3504   void * relocs;
3505
3506   /* Get the section contents.  */
3507   input_size = input_section->size;
3508   if (! bfd_get_section_contents (input_bfd, input_section,
3509                                   (void *) flaginfo->contents,
3510                                   (file_ptr) 0, input_size))
3511     return FALSE;
3512
3513   /* Read in the relocs if we haven't already done it.  */
3514   if (aout_section_data (input_section) != NULL
3515       && aout_section_data (input_section)->relocs != NULL)
3516     relocs = aout_section_data (input_section)->relocs;
3517   else
3518     {
3519       relocs = flaginfo->relocs;
3520       if (rel_size > 0)
3521         {
3522           if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
3523               || bfd_bread (relocs, rel_size, input_bfd) != rel_size)
3524             return FALSE;
3525         }
3526     }
3527
3528   /* Relocate the section contents.  */
3529   if (! pdp11_aout_link_input_section (flaginfo, input_bfd, input_section,
3530                                        (bfd_byte *) relocs,
3531                                        rel_size, flaginfo->contents))
3532     return FALSE;
3533
3534   /* Write out the section contents.  */
3535   if (! bfd_set_section_contents (flaginfo->output_bfd,
3536                                   input_section->output_section,
3537                                   (void *) flaginfo->contents,
3538                                   (file_ptr) input_section->output_offset,
3539                                   input_size))
3540     return FALSE;
3541
3542   /* If we are producing relocatable output, the relocs were
3543      modified, and we now write them out.  */
3544   if (bfd_link_relocatable (flaginfo->info) && rel_size > 0)
3545     {
3546       if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
3547         return FALSE;
3548       if (bfd_bwrite (relocs, rel_size, flaginfo->output_bfd) != rel_size)
3549         return FALSE;
3550       *reloff_ptr += rel_size;
3551
3552       /* Assert that the relocs have not run into the symbols, and
3553          that if these are the text relocs they have not run into the
3554          data relocs.  */
3555       BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd)
3556                   && (reloff_ptr != &flaginfo->treloff
3557                       || (*reloff_ptr
3558                           <= obj_datasec (flaginfo->output_bfd)->rel_filepos)));
3559     }
3560
3561   return TRUE;
3562 }
3563
3564 /* Link an a.out input BFD into the output file.  */
3565
3566 static bfd_boolean
3567 aout_link_input_bfd (struct aout_final_link_info *flaginfo, bfd *input_bfd)
3568 {
3569   BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
3570
3571   /* If this is a dynamic object, it may need special handling.  */
3572   if ((input_bfd->flags & DYNAMIC) != 0
3573       && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
3574     return ((*aout_backend_info (input_bfd)->link_dynamic_object)
3575             (flaginfo->info, input_bfd));
3576
3577   /* Get the symbols.  We probably have them already, unless
3578      flaginfo->info->keep_memory is FALSE.  */
3579   if (! aout_get_external_symbols (input_bfd))
3580     return FALSE;
3581
3582   /* Write out the symbols and get a map of the new indices.  The map
3583      is placed into flaginfo->symbol_map.  */
3584   if (! aout_link_write_symbols (flaginfo, input_bfd))
3585     return FALSE;
3586
3587   /* Relocate and write out the sections.  These functions use the
3588      symbol map created by aout_link_write_symbols.  The linker_mark
3589      field will be set if these sections are to be included in the
3590      link, which will normally be the case.  */
3591   if (obj_textsec (input_bfd)->linker_mark)
3592     {
3593       if (! aout_link_input_section (flaginfo, input_bfd,
3594                                      obj_textsec (input_bfd),
3595                                      &flaginfo->treloff,
3596                                      exec_hdr (input_bfd)->a_trsize))
3597         return FALSE;
3598     }
3599   if (obj_datasec (input_bfd)->linker_mark)
3600     {
3601       if (! aout_link_input_section (flaginfo, input_bfd,
3602                                      obj_datasec (input_bfd),
3603                                      &flaginfo->dreloff,
3604                                      exec_hdr (input_bfd)->a_drsize))
3605         return FALSE;
3606     }
3607
3608   /* If we are not keeping memory, we don't need the symbols any
3609      longer.  We still need them if we are keeping memory, because the
3610      strings in the hash table point into them.  */
3611   if (! flaginfo->info->keep_memory)
3612     {
3613       if (! aout_link_free_symbols (input_bfd))
3614         return FALSE;
3615     }
3616
3617   return TRUE;
3618 }
3619
3620 /* Do the final link step.  This is called on the output BFD.  The
3621    INFO structure should point to a list of BFDs linked through the
3622    link.next field which can be used to find each BFD which takes part
3623    in the output.  Also, each section in ABFD should point to a list
3624    of bfd_link_order structures which list all the input sections for
3625    the output section.  */
3626
3627 bfd_boolean
3628 NAME (aout, final_link) (bfd *abfd,
3629                          struct bfd_link_info *info,
3630                          void (*callback) (bfd *, file_ptr *, file_ptr *, file_ptr *))
3631 {
3632   struct aout_final_link_info aout_info;
3633   bfd_boolean includes_hash_initialized = FALSE;
3634   bfd *sub;
3635   bfd_size_type trsize, drsize;
3636   bfd_size_type max_contents_size;
3637   bfd_size_type max_relocs_size;
3638   bfd_size_type max_sym_count;
3639   struct bfd_link_order *p;
3640   asection *o;
3641   bfd_boolean have_link_order_relocs;
3642
3643   if (bfd_link_pic (info))
3644     abfd->flags |= DYNAMIC;
3645
3646   aout_info.info = info;
3647   aout_info.output_bfd = abfd;
3648   aout_info.contents = NULL;
3649   aout_info.relocs = NULL;
3650   aout_info.symbol_map = NULL;
3651   aout_info.output_syms = NULL;
3652
3653   if (!bfd_hash_table_init_n (&aout_info.includes.root,
3654                               aout_link_includes_newfunc,
3655                               sizeof (struct aout_link_includes_entry),
3656                               251))
3657     goto error_return;
3658   includes_hash_initialized = TRUE;
3659
3660   /* Figure out the largest section size.  Also, if generating
3661      relocatable output, count the relocs.  */
3662   trsize = 0;
3663   drsize = 0;
3664   max_contents_size = 0;
3665   max_relocs_size = 0;
3666   max_sym_count = 0;
3667   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
3668     {
3669       size_t sz;
3670
3671       if (bfd_link_relocatable (info))
3672         {
3673           if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3674             {
3675               trsize += exec_hdr (sub)->a_trsize;
3676               drsize += exec_hdr (sub)->a_drsize;
3677             }
3678           else
3679             {
3680               /* FIXME: We need to identify the .text and .data sections
3681                  and call get_reloc_upper_bound and canonicalize_reloc to
3682                  work out the number of relocs needed, and then multiply
3683                  by the reloc size.  */
3684               _bfd_error_handler
3685                 /* xgettext:c-format */
3686                 (_("%pB: relocatable link from %s to %s not supported"),
3687                  abfd, sub->xvec->name, abfd->xvec->name);
3688               bfd_set_error (bfd_error_invalid_operation);
3689               goto error_return;
3690             }
3691         }
3692
3693       if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3694         {
3695           sz = obj_textsec (sub)->size;
3696           if (sz > max_contents_size)
3697             max_contents_size = sz;
3698           sz = obj_datasec (sub)->size;
3699           if (sz > max_contents_size)
3700             max_contents_size = sz;
3701
3702           sz = exec_hdr (sub)->a_trsize;
3703           if (sz > max_relocs_size)
3704             max_relocs_size = sz;
3705           sz = exec_hdr (sub)->a_drsize;
3706           if (sz > max_relocs_size)
3707             max_relocs_size = sz;
3708
3709           sz = obj_aout_external_sym_count (sub);
3710           if (sz > max_sym_count)
3711             max_sym_count = sz;
3712         }
3713     }
3714
3715   if (bfd_link_relocatable (info))
3716     {
3717       if (obj_textsec (abfd) != NULL)
3718         trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
3719                                                  ->map_head.link_order)
3720                    * obj_reloc_entry_size (abfd));
3721       if (obj_datasec (abfd) != NULL)
3722         drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
3723                                                  ->map_head.link_order)
3724                    * obj_reloc_entry_size (abfd));
3725     }
3726
3727   exec_hdr (abfd)->a_trsize = trsize;
3728   exec_hdr (abfd)->a_drsize = drsize;
3729   exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
3730
3731   /* Adjust the section sizes and vmas according to the magic number.
3732      This sets a_text, a_data and a_bss in the exec_hdr and sets the
3733      filepos for each section.  */
3734   if (! NAME (aout, adjust_sizes_and_vmas) (abfd))
3735     goto error_return;
3736
3737   /* The relocation and symbol file positions differ among a.out
3738      targets.  We are passed a callback routine from the backend
3739      specific code to handle this.
3740      FIXME: At this point we do not know how much space the symbol
3741      table will require.  This will not work for any (nonstandard)
3742      a.out target that needs to know the symbol table size before it
3743      can compute the relocation file positions.  */
3744   (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
3745                &aout_info.symoff);
3746   obj_textsec (abfd)->rel_filepos = aout_info.treloff;
3747   obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
3748   obj_sym_filepos (abfd) = aout_info.symoff;
3749
3750   /* We keep a count of the symbols as we output them.  */
3751   obj_aout_external_sym_count (abfd) = 0;
3752
3753   /* We accumulate the string table as we write out the symbols.  */
3754   aout_info.strtab = _bfd_stringtab_init ();
3755   if (aout_info.strtab == NULL)
3756     goto error_return;
3757
3758   /* Allocate buffers to hold section contents and relocs.  */
3759   aout_info.contents = bfd_malloc (max_contents_size);
3760   aout_info.relocs = bfd_malloc (max_relocs_size);
3761   aout_info.symbol_map = bfd_malloc (max_sym_count * sizeof (int *));
3762   aout_info.output_syms = bfd_malloc ((max_sym_count + 1)
3763                                       * sizeof (struct external_nlist));
3764   if ((aout_info.contents == NULL && max_contents_size != 0)
3765       || (aout_info.relocs == NULL && max_relocs_size != 0)
3766       || (aout_info.symbol_map == NULL && max_sym_count != 0)
3767       || aout_info.output_syms == NULL)
3768     goto error_return;
3769
3770   /* If we have a symbol named __DYNAMIC, force it out now.  This is
3771      required by SunOS.  Doing this here rather than in sunos.c is a
3772      hack, but it's easier than exporting everything which would be
3773      needed.  */
3774   {
3775     struct aout_link_hash_entry *h;
3776
3777     h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
3778                                FALSE, FALSE, FALSE);
3779     if (h != NULL)
3780       aout_link_write_other_symbol (&h->root.root, &aout_info);
3781   }
3782
3783   /* The most time efficient way to do the link would be to read all
3784      the input object files into memory and then sort out the
3785      information into the output file.  Unfortunately, that will
3786      probably use too much memory.  Another method would be to step
3787      through everything that composes the text section and write it
3788      out, and then everything that composes the data section and write
3789      it out, and then write out the relocs, and then write out the
3790      symbols.  Unfortunately, that requires reading stuff from each
3791      input file several times, and we will not be able to keep all the
3792      input files open simultaneously, and reopening them will be slow.
3793
3794      What we do is basically process one input file at a time.  We do
3795      everything we need to do with an input file once--copy over the
3796      section contents, handle the relocation information, and write
3797      out the symbols--and then we throw away the information we read
3798      from it.  This approach requires a lot of lseeks of the output
3799      file, which is unfortunate but still faster than reopening a lot
3800      of files.
3801
3802      We use the output_has_begun field of the input BFDs to see
3803      whether we have already handled it.  */
3804   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
3805     sub->output_has_begun = FALSE;
3806
3807   /* Mark all sections which are to be included in the link.  This
3808      will normally be every section.  We need to do this so that we
3809      can identify any sections which the linker has decided to not
3810      include.  */
3811   for (o = abfd->sections; o != NULL; o = o->next)
3812     {
3813       for (p = o->map_head.link_order; p != NULL; p = p->next)
3814         if (p->type == bfd_indirect_link_order)
3815           p->u.indirect.section->linker_mark = TRUE;
3816     }
3817
3818   have_link_order_relocs = FALSE;
3819   for (o = abfd->sections; o != NULL; o = o->next)
3820     {
3821       for (p = o->map_head.link_order;
3822            p != NULL;
3823            p = p->next)
3824         {
3825           if (p->type == bfd_indirect_link_order
3826               && (bfd_get_flavour (p->u.indirect.section->owner)
3827                   == bfd_target_aout_flavour))
3828             {
3829               bfd *input_bfd;
3830
3831               input_bfd = p->u.indirect.section->owner;
3832               if (! input_bfd->output_has_begun)
3833                 {
3834                   if (! aout_link_input_bfd (&aout_info, input_bfd))
3835                     goto error_return;
3836                   input_bfd->output_has_begun = TRUE;
3837                 }
3838             }
3839           else if (p->type == bfd_section_reloc_link_order
3840                    || p->type == bfd_symbol_reloc_link_order)
3841             /* These are handled below.  */
3842             have_link_order_relocs = TRUE;
3843           else
3844             {
3845               if (! _bfd_default_link_order (abfd, info, o, p))
3846                 goto error_return;
3847             }
3848         }
3849     }
3850
3851   /* Write out any symbols that we have not already written out.  */
3852   bfd_hash_traverse (&info->hash->table,
3853                      aout_link_write_other_symbol,
3854                      &aout_info);
3855
3856   /* Now handle any relocs we were asked to create by the linker.
3857      These did not come from any input file.  We must do these after
3858      we have written out all the symbols, so that we know the symbol
3859      indices to use.  */
3860   if (have_link_order_relocs)
3861     {
3862       for (o = abfd->sections; o != NULL; o = o->next)
3863         {
3864           for (p = o->map_head.link_order;
3865                p != NULL;
3866                p = p->next)
3867             {
3868               if (p->type == bfd_section_reloc_link_order
3869                   || p->type == bfd_symbol_reloc_link_order)
3870                 {
3871                   if (! aout_link_reloc_link_order (&aout_info, o, p))
3872                     goto error_return;
3873                 }
3874             }
3875         }
3876     }
3877
3878   if (aout_info.contents != NULL)
3879     {
3880       free (aout_info.contents);
3881       aout_info.contents = NULL;
3882     }
3883   if (aout_info.relocs != NULL)
3884     {
3885       free (aout_info.relocs);
3886       aout_info.relocs = NULL;
3887     }
3888   if (aout_info.symbol_map != NULL)
3889     {
3890       free (aout_info.symbol_map);
3891       aout_info.symbol_map = NULL;
3892     }
3893   if (aout_info.output_syms != NULL)
3894     {
3895       free (aout_info.output_syms);
3896       aout_info.output_syms = NULL;
3897     }
3898   if (includes_hash_initialized)
3899     {
3900       bfd_hash_table_free (&aout_info.includes.root);
3901       includes_hash_initialized = FALSE;
3902     }
3903
3904   /* Finish up any dynamic linking we may be doing.  */
3905   if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
3906     {
3907       if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
3908         goto error_return;
3909     }
3910
3911   /* Update the header information.  */
3912   abfd->symcount = obj_aout_external_sym_count (abfd);
3913   exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
3914   obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
3915   obj_textsec (abfd)->reloc_count =
3916     exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
3917   obj_datasec (abfd)->reloc_count =
3918     exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
3919
3920   /* Write out the string table, unless there are no symbols.  */
3921   if (abfd->symcount > 0)
3922     {
3923       if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
3924           || ! emit_stringtab (abfd, aout_info.strtab))
3925         goto error_return;
3926     }
3927   else if (obj_textsec (abfd)->reloc_count == 0
3928            && obj_datasec (abfd)->reloc_count == 0)
3929     {
3930       bfd_byte b;
3931
3932       b = 0;
3933       if (bfd_seek (abfd,
3934                     (file_ptr) (obj_datasec (abfd)->filepos
3935                                 + exec_hdr (abfd)->a_data
3936                                 - 1),
3937                     SEEK_SET) != 0
3938           || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3939         goto error_return;
3940     }
3941
3942   return TRUE;
3943
3944  error_return:
3945   if (aout_info.contents != NULL)
3946     free (aout_info.contents);
3947   if (aout_info.relocs != NULL)
3948     free (aout_info.relocs);
3949   if (aout_info.symbol_map != NULL)
3950     free (aout_info.symbol_map);
3951   if (aout_info.output_syms != NULL)
3952     free (aout_info.output_syms);
3953   if (includes_hash_initialized)
3954     bfd_hash_table_free (&aout_info.includes.root);
3955   return FALSE;
3956 }
3957
3958 /* Adjust and write out the symbols for an a.out file.  Set the new
3959    symbol indices into a symbol_map.  */
3960
3961 static bfd_boolean
3962 aout_link_write_symbols (struct aout_final_link_info *flaginfo, bfd *input_bfd)
3963 {
3964   bfd *output_bfd;
3965   bfd_size_type sym_count;
3966   char *strings;
3967   enum bfd_link_strip strip;
3968   enum bfd_link_discard discard;
3969   struct external_nlist *outsym;
3970   bfd_size_type strtab_index;
3971   struct external_nlist *sym;
3972   struct external_nlist *sym_end;
3973   struct aout_link_hash_entry **sym_hash;
3974   int *symbol_map;
3975   bfd_boolean pass;
3976   bfd_boolean skip_next;
3977
3978   output_bfd = flaginfo->output_bfd;
3979   sym_count = obj_aout_external_sym_count (input_bfd);
3980   strings = obj_aout_external_strings (input_bfd);
3981   strip = flaginfo->info->strip;
3982   discard = flaginfo->info->discard;
3983   outsym = flaginfo->output_syms;
3984
3985   /* First write out a symbol for this object file, unless we are
3986      discarding such symbols.  */
3987   if (strip != strip_all
3988       && (strip != strip_some
3989           || bfd_hash_lookup (flaginfo->info->keep_hash, input_bfd->filename,
3990                               FALSE, FALSE) != NULL)
3991       && discard != discard_all)
3992     {
3993       H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
3994       strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
3995                                        input_bfd->filename, FALSE);
3996       if (strtab_index == (bfd_size_type) -1)
3997         return FALSE;
3998       PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
3999       PUT_WORD (output_bfd,
4000                 (bfd_get_section_vma (output_bfd,
4001                                       obj_textsec (input_bfd)->output_section)
4002                  + obj_textsec (input_bfd)->output_offset),
4003                 outsym->e_value);
4004       ++obj_aout_external_sym_count (output_bfd);
4005       ++outsym;
4006     }
4007
4008   pass = FALSE;
4009   skip_next = FALSE;
4010   sym = obj_aout_external_syms (input_bfd);
4011   sym_end = sym + sym_count;
4012   sym_hash = obj_aout_sym_hashes (input_bfd);
4013   symbol_map = flaginfo->symbol_map;
4014   memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
4015   for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
4016     {
4017       const char *name;
4018       int type;
4019       struct aout_link_hash_entry *h;
4020       bfd_boolean skip;
4021       asection *symsec;
4022       bfd_vma val = 0;
4023       bfd_boolean copy;
4024
4025       /* We set *symbol_map to 0 above for all symbols.  If it has
4026          already been set to -1 for this symbol, it means that we are
4027          discarding it because it appears in a duplicate header file.
4028          See the N_BINCL code below.  */
4029       if (*symbol_map == -1)
4030         continue;
4031
4032       /* Initialize *symbol_map to -1, which means that the symbol was
4033          not copied into the output file.  We will change it later if
4034          we do copy the symbol over.  */
4035       *symbol_map = -1;
4036
4037       type = H_GET_8 (input_bfd, sym->e_type);
4038       name = strings + GET_WORD (input_bfd, sym->e_strx);
4039
4040       h = NULL;
4041
4042       if (pass)
4043         {
4044           /* Pass this symbol through.  It is the target of an
4045              indirect or warning symbol.  */
4046           val = GET_WORD (input_bfd, sym->e_value);
4047           pass = FALSE;
4048         }
4049       else if (skip_next)
4050         {
4051           /* Skip this symbol, which is the target of an indirect
4052              symbol that we have changed to no longer be an indirect
4053              symbol.  */
4054           skip_next = FALSE;
4055           continue;
4056         }
4057       else
4058         {
4059           struct aout_link_hash_entry *hresolve;
4060
4061           /* We have saved the hash table entry for this symbol, if
4062              there is one.  Note that we could just look it up again
4063              in the hash table, provided we first check that it is an
4064              external symbol. */
4065           h = *sym_hash;
4066
4067           /* Use the name from the hash table, in case the symbol was
4068              wrapped.  */
4069           if (h != NULL)
4070             name = h->root.root.string;
4071
4072           /* If this is an indirect or warning symbol, then change
4073              hresolve to the base symbol.  We also change *sym_hash so
4074              that the relocation routines relocate against the real
4075              symbol.  */
4076           hresolve = h;
4077           if (h != NULL
4078               && (h->root.type == bfd_link_hash_indirect
4079                   || h->root.type == bfd_link_hash_warning))
4080             {
4081               hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
4082               while (hresolve->root.type == bfd_link_hash_indirect
4083                      || hresolve->root.type == bfd_link_hash_warning)
4084                 hresolve = ((struct aout_link_hash_entry *)
4085                             hresolve->root.u.i.link);
4086               *sym_hash = hresolve;
4087             }
4088
4089           /* If the symbol has already been written out, skip it.  */
4090           if (h != NULL
4091               && h->root.type != bfd_link_hash_warning
4092               && h->written)
4093             {
4094               if ((type & N_TYPE) == N_INDR
4095                   || type == N_WARNING)
4096                 skip_next = TRUE;
4097               *symbol_map = h->indx;
4098               continue;
4099             }
4100
4101           /* See if we are stripping this symbol.  */
4102           skip = FALSE;
4103           switch (strip)
4104             {
4105             case strip_none:
4106               break;
4107             case strip_debugger:
4108               if ((type & N_STAB) != 0)
4109                 skip = TRUE;
4110               break;
4111             case strip_some:
4112               if (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE, FALSE)
4113                   == NULL)
4114                 skip = TRUE;
4115               break;
4116             case strip_all:
4117               skip = TRUE;
4118               break;
4119             }
4120           if (skip)
4121             {
4122               if (h != NULL)
4123                 h->written = TRUE;
4124               continue;
4125             }
4126
4127           /* Get the value of the symbol.  */
4128           if ((type & N_TYPE) == N_TEXT
4129               || type == N_WEAKT)
4130             symsec = obj_textsec (input_bfd);
4131           else if ((type & N_TYPE) == N_DATA
4132                    || type == N_WEAKD)
4133             symsec = obj_datasec (input_bfd);
4134           else if ((type & N_TYPE) == N_BSS
4135                    || type == N_WEAKB)
4136             symsec = obj_bsssec (input_bfd);
4137           else if ((type & N_TYPE) == N_ABS
4138                    || type == N_WEAKA)
4139             symsec = bfd_abs_section_ptr;
4140           else if (((type & N_TYPE) == N_INDR
4141                     && (hresolve == NULL
4142                         || (hresolve->root.type != bfd_link_hash_defined
4143                             && hresolve->root.type != bfd_link_hash_defweak
4144                             && hresolve->root.type != bfd_link_hash_common)))
4145                    || type == N_WARNING)
4146             {
4147               /* Pass the next symbol through unchanged.  The
4148                  condition above for indirect symbols is so that if
4149                  the indirect symbol was defined, we output it with
4150                  the correct definition so the debugger will
4151                  understand it.  */
4152               pass = TRUE;
4153               val = GET_WORD (input_bfd, sym->e_value);
4154               symsec = NULL;
4155             }
4156           else if ((type & N_STAB) != 0)
4157             {
4158               val = GET_WORD (input_bfd, sym->e_value);
4159               symsec = NULL;
4160             }
4161           else
4162             {
4163               /* If we get here with an indirect symbol, it means that
4164                  we are outputting it with a real definition.  In such
4165                  a case we do not want to output the next symbol,
4166                  which is the target of the indirection.  */
4167               if ((type & N_TYPE) == N_INDR)
4168                 skip_next = TRUE;
4169
4170               symsec = NULL;
4171
4172               /* We need to get the value from the hash table.  We use
4173                  hresolve so that if we have defined an indirect
4174                  symbol we output the final definition.  */
4175               if (h == NULL)
4176                 {
4177                   switch (type & N_TYPE)
4178                     {
4179                     case N_SETT:
4180                       symsec = obj_textsec (input_bfd);
4181                       break;
4182                     case N_SETD:
4183                       symsec = obj_datasec (input_bfd);
4184                       break;
4185                     case N_SETB:
4186                       symsec = obj_bsssec (input_bfd);
4187                       break;
4188                     case N_SETA:
4189                       symsec = bfd_abs_section_ptr;
4190                       break;
4191                     default:
4192                       val = 0;
4193                       break;
4194                     }
4195                 }
4196               else if (hresolve->root.type == bfd_link_hash_defined
4197                        || hresolve->root.type == bfd_link_hash_defweak)
4198                 {
4199                   asection *input_section;
4200                   asection *output_section;
4201
4202                   /* This case usually means a common symbol which was
4203                      turned into a defined symbol.  */
4204                   input_section = hresolve->root.u.def.section;
4205                   output_section = input_section->output_section;
4206                   BFD_ASSERT (bfd_is_abs_section (output_section)
4207                               || output_section->owner == output_bfd);
4208                   val = (hresolve->root.u.def.value
4209                          + bfd_get_section_vma (output_bfd, output_section)
4210                          + input_section->output_offset);
4211
4212                   /* Get the correct type based on the section.  If
4213                      this is a constructed set, force it to be
4214                      globally visible.  */
4215                   if (type == N_SETT
4216                       || type == N_SETD
4217                       || type == N_SETB
4218                       || type == N_SETA)
4219                     type |= N_EXT;
4220
4221                   type &=~ N_TYPE;
4222
4223                   if (output_section == obj_textsec (output_bfd))
4224                     type |= (hresolve->root.type == bfd_link_hash_defined
4225                              ? N_TEXT
4226                              : N_WEAKT);
4227                   else if (output_section == obj_datasec (output_bfd))
4228                     type |= (hresolve->root.type == bfd_link_hash_defined
4229                              ? N_DATA
4230                              : N_WEAKD);
4231                   else if (output_section == obj_bsssec (output_bfd))
4232                     type |= (hresolve->root.type == bfd_link_hash_defined
4233                              ? N_BSS
4234                              : N_WEAKB);
4235                   else
4236                     type |= (hresolve->root.type == bfd_link_hash_defined
4237                              ? N_ABS
4238                              : N_WEAKA);
4239                 }
4240               else if (hresolve->root.type == bfd_link_hash_common)
4241                 val = hresolve->root.u.c.size;
4242               else if (hresolve->root.type == bfd_link_hash_undefweak)
4243                 {
4244                   val = 0;
4245                   type = N_WEAKU;
4246                 }
4247               else
4248                 val = 0;
4249             }
4250           if (symsec != NULL)
4251             val = (symsec->output_section->vma
4252                    + symsec->output_offset
4253                    + (GET_WORD (input_bfd, sym->e_value)
4254                       - symsec->vma));
4255
4256           /* If this is a global symbol set the written flag, and if
4257              it is a local symbol see if we should discard it.  */
4258           if (h != NULL)
4259             {
4260               h->written = TRUE;
4261               h->indx = obj_aout_external_sym_count (output_bfd);
4262             }
4263           else if ((type & N_TYPE) != N_SETT
4264                    && (type & N_TYPE) != N_SETD
4265                    && (type & N_TYPE) != N_SETB
4266                    && (type & N_TYPE) != N_SETA)
4267             {
4268               switch (discard)
4269                 {
4270                 case discard_none:
4271                 case discard_sec_merge:
4272                   break;
4273                 case discard_l:
4274                   if ((type & N_STAB) == 0
4275                       && bfd_is_local_label_name (input_bfd, name))
4276                     skip = TRUE;
4277                   break;
4278                 case discard_all:
4279                   skip = TRUE;
4280                   break;
4281                 }
4282               if (skip)
4283                 {
4284                   pass = FALSE;
4285                   continue;
4286                 }
4287             }
4288
4289           /* An N_BINCL symbol indicates the start of the stabs
4290              entries for a header file.  We need to scan ahead to the
4291              next N_EINCL symbol, ignoring nesting, adding up all the
4292              characters in the symbol names, not including the file
4293              numbers in types (the first number after an open
4294              parenthesis).  */
4295           if (type == N_BINCL)
4296             {
4297               struct external_nlist *incl_sym;
4298               int nest;
4299               struct aout_link_includes_entry *incl_entry;
4300               struct aout_link_includes_totals *t;
4301
4302               val = 0;
4303               nest = 0;
4304               for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++)
4305                 {
4306                   int incl_type;
4307
4308                   incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
4309                   if (incl_type == N_EINCL)
4310                     {
4311                       if (nest == 0)
4312                         break;
4313                       --nest;
4314                     }
4315                   else if (incl_type == N_BINCL)
4316                     ++nest;
4317                   else if (nest == 0)
4318                     {
4319                       const char *s;
4320
4321                       s = strings + GET_WORD (input_bfd, incl_sym->e_strx);
4322                       for (; *s != '\0'; s++)
4323                         {
4324                           val += *s;
4325                           if (*s == '(')
4326                             {
4327                               /* Skip the file number.  */
4328                               ++s;
4329                               while (ISDIGIT (*s))
4330                                 ++s;
4331                               --s;
4332                             }
4333                         }
4334                     }
4335                 }
4336
4337               /* If we have already included a header file with the
4338                  same value, then replace this one with an N_EXCL
4339                  symbol.  */
4340               copy = ! flaginfo->info->keep_memory;
4341               incl_entry = aout_link_includes_lookup (&flaginfo->includes,
4342                                                       name, TRUE, copy);
4343               if (incl_entry == NULL)
4344                 return FALSE;
4345               for (t = incl_entry->totals; t != NULL; t = t->next)
4346                 if (t->total == val)
4347                   break;
4348               if (t == NULL)
4349                 {
4350                   /* This is the first time we have seen this header
4351                      file with this set of stabs strings.  */
4352                   t = bfd_hash_allocate (&flaginfo->includes.root,
4353                                          sizeof *t);
4354                   if (t == NULL)
4355                     return FALSE;
4356                   t->total = val;
4357                   t->next = incl_entry->totals;
4358                   incl_entry->totals = t;
4359                 }
4360               else
4361                 {
4362                   int *incl_map;
4363
4364                   /* This is a duplicate header file.  We must change
4365                      it to be an N_EXCL entry, and mark all the
4366                      included symbols to prevent outputting them.  */
4367                   type = N_EXCL;
4368
4369                   nest = 0;
4370                   for (incl_sym = sym + 1, incl_map = symbol_map + 1;
4371                        incl_sym < sym_end;
4372                        incl_sym++, incl_map++)
4373                     {
4374                       int incl_type;
4375
4376                       incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
4377                       if (incl_type == N_EINCL)
4378                         {
4379                           if (nest == 0)
4380                             {
4381                               *incl_map = -1;
4382                               break;
4383                             }
4384                           --nest;
4385                         }
4386                       else if (incl_type == N_BINCL)
4387                         ++nest;
4388                       else if (nest == 0)
4389                         *incl_map = -1;
4390                     }
4391                 }
4392             }
4393         }
4394
4395       /* Copy this symbol into the list of symbols we are going to
4396          write out.  */
4397       H_PUT_8 (output_bfd, type, outsym->e_type);
4398       copy = FALSE;
4399       if (! flaginfo->info->keep_memory)
4400         {
4401           /* name points into a string table which we are going to
4402              free.  If there is a hash table entry, use that string.
4403              Otherwise, copy name into memory.  */
4404           if (h != NULL)
4405             name = h->root.root.string;
4406           else
4407             copy = TRUE;
4408         }
4409       strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
4410                                        name, copy);
4411       if (strtab_index == (bfd_size_type) -1)
4412         return FALSE;
4413       PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4414       PUT_WORD (output_bfd, val, outsym->e_value);
4415       *symbol_map = obj_aout_external_sym_count (output_bfd);
4416       ++obj_aout_external_sym_count (output_bfd);
4417       ++outsym;
4418     }
4419
4420   /* Write out the output symbols we have just constructed.  */
4421   if (outsym > flaginfo->output_syms)
4422     {
4423       bfd_size_type size;
4424
4425       if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0)
4426         return FALSE;
4427       size = outsym - flaginfo->output_syms;
4428       size *= EXTERNAL_NLIST_SIZE;
4429       if (bfd_bwrite ((void *) flaginfo->output_syms, size, output_bfd) != size)
4430         return FALSE;
4431       flaginfo->symoff += size;
4432     }
4433
4434   return TRUE;
4435 }
4436
4437 /* Write out a symbol that was not associated with an a.out input
4438    object.  */
4439
4440 static bfd_vma
4441 bfd_getp32 (const void *p)
4442 {
4443   const bfd_byte *addr = p;
4444   unsigned long v;
4445
4446   v = (unsigned long) addr[1] << 24;
4447   v |= (unsigned long) addr[0] << 16;
4448   v |= (unsigned long) addr[3] << 8;
4449   v |= (unsigned long) addr[2];
4450   return v;
4451 }
4452
4453 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
4454
4455 static bfd_signed_vma
4456 bfd_getp_signed_32 (const void *p)
4457 {
4458   const bfd_byte *addr = p;
4459   unsigned long v;
4460
4461   v = (unsigned long) addr[1] << 24;
4462   v |= (unsigned long) addr[0] << 16;
4463   v |= (unsigned long) addr[3] << 8;
4464   v |= (unsigned long) addr[2];
4465   return COERCE32 (v);
4466 }
4467
4468 static void
4469 bfd_putp32 (bfd_vma data, void *p)
4470 {
4471   bfd_byte *addr = p;
4472
4473   addr[0] = (data >> 16) & 0xff;
4474   addr[1] = (data >> 24) & 0xff;
4475   addr[2] = (data >> 0) & 0xff;
4476   addr[3] = (data >> 8) & 0xff;
4477 }
4478
4479 const bfd_target MY (vec) =
4480 {
4481   TARGETNAME,                   /* Name.  */
4482   bfd_target_aout_flavour,
4483   BFD_ENDIAN_LITTLE,            /* Target byte order (little).  */
4484   BFD_ENDIAN_LITTLE,            /* Target headers byte order (little).  */
4485   (HAS_RELOC | EXEC_P |         /* Object flags.  */
4486    HAS_LINENO | HAS_DEBUG |
4487    HAS_SYMS | HAS_LOCALS | WP_TEXT),
4488   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
4489   MY_symbol_leading_char,
4490   AR_PAD_CHAR,                  /* AR_pad_char.  */
4491   15,                           /* AR_max_namelen.  */
4492   0,                            /* match priority.  */
4493   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
4494      bfd_getp32, bfd_getp_signed_32, bfd_putp32,
4495      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data.  */
4496   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
4497      bfd_getp32, bfd_getp_signed_32, bfd_putp32,
4498      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Headers.  */
4499   {                             /* bfd_check_format.  */
4500     _bfd_dummy_target,
4501     MY_object_p,
4502     bfd_generic_archive_p,
4503     MY_core_file_p
4504   },
4505   {                             /* bfd_set_format.  */
4506     _bfd_bool_bfd_false_error,
4507     MY_mkobject,
4508     _bfd_generic_mkarchive,
4509     _bfd_bool_bfd_false_error
4510   },
4511   {                     /* bfd_write_contents.  */
4512     _bfd_bool_bfd_false_error,
4513     MY_write_object_contents,
4514     _bfd_write_archive_contents,
4515     _bfd_bool_bfd_false_error
4516   },
4517
4518   BFD_JUMP_TABLE_GENERIC (MY),
4519   BFD_JUMP_TABLE_COPY (MY),
4520   BFD_JUMP_TABLE_CORE (MY),
4521   BFD_JUMP_TABLE_ARCHIVE (MY),
4522   BFD_JUMP_TABLE_SYMBOLS (MY),
4523   BFD_JUMP_TABLE_RELOCS (MY),
4524   BFD_JUMP_TABLE_WRITE (MY),
4525   BFD_JUMP_TABLE_LINK (MY),
4526   BFD_JUMP_TABLE_DYNAMIC (MY),
4527
4528   /* Alternative_target.  */
4529   NULL,
4530
4531   (void *) MY_backend_data
4532 };