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