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