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