projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
binutils/testsuite: Also consider `*-*-lynxos*' and `*-*-symbianelf*' ELF
[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 */
871b3ab2 1284 (_("%pB: can not represent section `%pA' in a.out object file format"),
dae82561 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 */
871b3ab2 1600 (_("%pB: 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 */
871b3ab2 1636 (_("%pB: can not represent section `%pA' in a.out object file format"),
dae82561 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
0d329c0a
AM		 1737 {
1738 _bfd_error_handler
1739 (_("%pB: invalid string offset %" PRIu64 " >= %" PRIu64),
1740 abfd, (uint64_t) x, (uint64_t) strsize);
1741 bfd_set_error (bfd_error_bad_value);
1742 return FALSE;
1743 }
252b5132
RH		 1744
1745 in->symbol.value = GET_SWORD (abfd, ext->e_value);
dc810e39
AM		 1746 in->desc = H_GET_16 (abfd, ext->e_desc);
1747 in->other = H_GET_8 (abfd, ext->e_other);
1748 in->type = H_GET_8 (abfd, ext->e_type);
252b5132
RH		 1749 in->symbol.udata.p = NULL;
1750
1751 if (! translate_from_native_sym_flags (abfd, in))
b34976b6 1752 return FALSE;
252b5132
RH		 1753
1754 if (dynamic)
1755 in->symbol.flags |= BSF_DYNAMIC;
1756 }
1757
b34976b6 1758 return TRUE;
252b5132
RH		 1759}
1760
1761/* We read the symbols into a buffer, which is discarded when this
1762 function exits. We read the strings into a buffer large enough to
0ef5a5bd 1763 hold them all plus all the cached symbol entries. */
252b5132 1764
b34976b6 1765bfd_boolean
116c20d2 1766NAME (aout, slurp_symbol_table) (bfd *abfd)
252b5132
RH		 1767{
1768 struct external_nlist *old_external_syms;
1769 aout_symbol_type *cached;
dc810e39 1770 bfd_size_type cached_size;
252b5132 1771
f7c33884 1772 /* If there's no work to be done, don't do any. */
116c20d2 1773 if (obj_aout_symbols (abfd) != NULL)
b34976b6 1774 return TRUE;
252b5132
RH		 1775
1776 old_external_syms = obj_aout_external_syms (abfd);
1777
1778 if (! aout_get_external_symbols (abfd))
b34976b6 1779 return FALSE;
252b5132 1780
dc810e39 1781 cached_size = obj_aout_external_sym_count (abfd);
87b32780
MS		 1782 if (cached_size == 0)
1783 return TRUE; /* Nothing to do. */
1784
dc810e39 1785 cached_size *= sizeof (aout_symbol_type);
a50b1753 1786 cached = (aout_symbol_type *) bfd_zmalloc (cached_size);
87b32780 1787 if (cached == NULL)
b34976b6 1788 return FALSE;
252b5132
RH		 1789
1790 /* Convert from external symbol information to internal. */
116c20d2 1791 if (! (NAME (aout, translate_symbol_table)
252b5132
RH		 1792 (abfd, cached,
1793 obj_aout_external_syms (abfd),
1794 obj_aout_external_sym_count (abfd),
1795 obj_aout_external_strings (abfd),
1796 obj_aout_external_string_size (abfd),
b34976b6 1797 FALSE)))
252b5132
RH		 1798 {
1799 free (cached);
b34976b6 1800 return FALSE;
252b5132
RH		 1801 }
1802
1803 bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd);
1804
1805 obj_aout_symbols (abfd) = cached;
1806
1807 /* It is very likely that anybody who calls this function will not
1808 want the external symbol information, so if it was allocated
1809 because of our call to aout_get_external_symbols, we free it up
1810 right away to save space. */
116c20d2
NC		 1811 if (old_external_syms == NULL
1812 && obj_aout_external_syms (abfd) != NULL)
252b5132
RH		 1813 {
1814#ifdef USE_MMAP
1815 bfd_free_window (&obj_aout_sym_window (abfd));
1816#else
1817 free (obj_aout_external_syms (abfd));
1818#endif
1819 obj_aout_external_syms (abfd) = NULL;
1820 }
1821
b34976b6 1822 return TRUE;
252b5132
RH		 1823}
1824\f
1825/* We use a hash table when writing out symbols so that we only write
1826 out a particular string once. This helps particularly when the
1827 linker writes out stabs debugging entries, because each different
1828 contributing object file tends to have many duplicate stabs
1829 strings.
1830
1831 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1832 if BFD_TRADITIONAL_FORMAT is set. */
1833
252b5132
RH		 1834/* Get the index of a string in a strtab, adding it if it is not
1835 already present. */
1836
116c20d2
NC		 1837static inline bfd_size_type
1838add_to_stringtab (bfd *abfd,
1839 struct bfd_strtab_hash *tab,
1840 const char *str,
1841 bfd_boolean copy)
252b5132 1842{
b34976b6 1843 bfd_boolean hash;
91d6fa6a 1844 bfd_size_type str_index;
252b5132
RH		 1845
1846 /* An index of 0 always means the empty string. */
1847 if (str == 0 || *str == '\0')
1848 return 0;
1849
1850 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1851 doesn't understand a hashed string table. */
b34976b6 1852 hash = TRUE;
252b5132 1853 if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
b34976b6 1854 hash = FALSE;
252b5132 1855
91d6fa6a 1856 str_index = _bfd_stringtab_add (tab, str, hash, copy);
252b5132 1857
91d6fa6a 1858 if (str_index != (bfd_size_type) -1)
116c20d2
NC		 1859 /* Add BYTES_IN_WORD to the return value to account for the
1860 space taken up by the string table size. */
91d6fa6a 1861 str_index += BYTES_IN_WORD;
252b5132 1862
91d6fa6a 1863 return str_index;
252b5132
RH		 1864}
1865
1866/* Write out a strtab. ABFD is already at the right location in the
1867 file. */
1868
b34976b6 1869static bfd_boolean
116c20d2 1870emit_stringtab (bfd *abfd, struct bfd_strtab_hash *tab)
252b5132
RH		 1871{
1872 bfd_byte buffer[BYTES_IN_WORD];
dc810e39 1873 bfd_size_type amt = BYTES_IN_WORD;
252b5132
RH		 1874
1875 /* The string table starts with the size. */
1876 PUT_WORD (abfd, _bfd_stringtab_size (tab) + BYTES_IN_WORD, buffer);
116c20d2 1877 if (bfd_bwrite ((void *) buffer, amt, abfd) != amt)
b34976b6 1878 return FALSE;
252b5132
RH		 1879
1880 return _bfd_stringtab_emit (abfd, tab);
1881}
1882\f
b34976b6 1883bfd_boolean
116c20d2 1884NAME (aout, write_syms) (bfd *abfd)
252b5132
RH		 1885{
1886 unsigned int count ;
1887 asymbol **generic = bfd_get_outsymbols (abfd);
1888 struct bfd_strtab_hash *strtab;
1889
1890 strtab = _bfd_stringtab_init ();
1891 if (strtab == NULL)
b34976b6 1892 return FALSE;
252b5132
RH		 1893
1894 for (count = 0; count < bfd_get_symcount (abfd); count++)
1895 {
1896 asymbol *g = generic[count];
1897 bfd_size_type indx;
1898 struct external_nlist nsp;
dc810e39 1899 bfd_size_type amt;
252b5132 1900
b34976b6 1901 indx = add_to_stringtab (abfd, strtab, g->name, FALSE);
252b5132
RH		 1902 if (indx == (bfd_size_type) -1)
1903 goto error_return;
1904 PUT_WORD (abfd, indx, (bfd_byte *) nsp.e_strx);
1905
923f08ff 1906 if (bfd_asymbol_flavour (g) == abfd->xvec->flavour)
252b5132 1907 {
923f08ff
AM		 1908 H_PUT_16 (abfd, aout_symbol (g)->desc, nsp.e_desc);
1909 H_PUT_8 (abfd, aout_symbol (g)->other, nsp.e_other);
1910 H_PUT_8 (abfd, aout_symbol (g)->type, nsp.e_type);
252b5132
RH		 1911 }
1912 else
1913 {
dc810e39
AM		 1914 H_PUT_16 (abfd, 0, nsp.e_desc);
1915 H_PUT_8 (abfd, 0, nsp.e_other);
1916 H_PUT_8 (abfd, 0, nsp.e_type);
252b5132
RH		 1917 }
1918
1919 if (! translate_to_native_sym_flags (abfd, g, &nsp))
1920 goto error_return;
1921
dc810e39 1922 amt = EXTERNAL_NLIST_SIZE;
116c20d2 1923 if (bfd_bwrite ((void *) &nsp, amt, abfd) != amt)
252b5132
RH		 1924 goto error_return;
1925
1926 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1927 here, at the end. */
1928 g->KEEPIT = count;
1929 }
1930
1931 if (! emit_stringtab (abfd, strtab))
1932 goto error_return;
1933
1934 _bfd_stringtab_free (strtab);
1935
b34976b6 1936 return TRUE;
252b5132
RH		 1937
1938error_return:
1939 _bfd_stringtab_free (strtab);
b34976b6 1940 return FALSE;
252b5132 1941}
252b5132
RH		 1942\f
1943long
116c20d2 1944NAME (aout, canonicalize_symtab) (bfd *abfd, asymbol **location)
252b5132 1945{
116c20d2
NC		 1946 unsigned int counter = 0;
1947 aout_symbol_type *symbase;
252b5132 1948
116c20d2
NC		 1949 if (!NAME (aout, slurp_symbol_table) (abfd))
1950 return -1;
252b5132 1951
116c20d2
NC		 1952 for (symbase = obj_aout_symbols (abfd);
1953 counter++ < bfd_get_symcount (abfd);
1954 )
1955 *(location++) = (asymbol *) (symbase++);
1956 *location++ =0;
1957 return bfd_get_symcount (abfd);
252b5132 1958}
252b5132 1959\f
f7c33884 1960/* Standard reloc stuff. */
0ef5a5bd 1961/* Output standard relocation information to a file in target byte order. */
252b5132 1962
116c20d2
NC		 1963extern void NAME (aout, swap_std_reloc_out)
1964 (bfd *, arelent *, struct reloc_std_external *);
252b5132
RH		 1965
1966void
116c20d2
NC		 1967NAME (aout, swap_std_reloc_out) (bfd *abfd,
1968 arelent *g,
1969 struct reloc_std_external *natptr)
252b5132
RH		 1970{
1971 int r_index;
1972 asymbol *sym = *(g->sym_ptr_ptr);
1973 int r_extern;
1974 unsigned int r_length;
1975 int r_pcrel;
1976 int r_baserel, r_jmptable, r_relative;
1977 asection *output_section = sym->section->output_section;
1978
923f08ff 1979 PUT_WORD (abfd, g->address, natptr->r_address);
252b5132 1980
e2996cc3 1981 BFD_ASSERT (g->howto != NULL);
f7c33884
NC		 1982 r_length = g->howto->size ; /* Size as a power of two. */
1983 r_pcrel = (int) g->howto->pc_relative; /* Relative to PC? */
252b5132
RH		 1984 /* XXX This relies on relocs coming from a.out files. */
1985 r_baserel = (g->howto->type & 8) != 0;
1986 r_jmptable = (g->howto->type & 16) != 0;
1987 r_relative = (g->howto->type & 32) != 0;
1988
f7c33884 1989 /* Name was clobbered by aout_write_syms to be symbol index. */
252b5132
RH		 1990
1991 /* If this relocation is relative to a symbol then set the
1992 r_index to the symbols index, and the r_extern bit.
1993
1994 Absolute symbols can come in in two ways, either as an offset
1995 from the abs section, or as a symbol which has an abs value.
f7c33884 1996 check for that here. */
252b5132 1997
252b5132
RH		 1998 if (bfd_is_com_section (output_section)
1999 || bfd_is_abs_section (output_section)
22184a77
NC		 2000 || bfd_is_und_section (output_section)
2001 /* PR gas/3041 a.out relocs against weak symbols
2002 must be treated as if they were against externs. */
2003 || (sym->flags & BSF_WEAK))
252b5132
RH		 2004 {
2005 if (bfd_abs_section_ptr->symbol == sym)
f7c33884
NC		 2006 {
2007 /* Whoops, looked like an abs symbol, but is
2008 really an offset from the abs section. */
2009 r_index = N_ABS;
2010 r_extern = 0;
2011 }
252b5132 2012 else
f7c33884
NC		 2013 {
2014 /* Fill in symbol. */
2015 r_extern = 1;
2016 r_index = (*(g->sym_ptr_ptr))->KEEPIT;
2017 }
252b5132
RH		 2018 }
2019 else
2020 {
f7c33884 2021 /* Just an ordinary section. */
252b5132
RH		 2022 r_extern = 0;
2023 r_index = output_section->target_index;
2024 }
2025
f7c33884 2026 /* Now the fun stuff. */
923f08ff
AM		 2027 if (bfd_header_big_endian (abfd))
2028 {
252b5132
RH		 2029 natptr->r_index[0] = r_index >> 16;
2030 natptr->r_index[1] = r_index >> 8;
2031 natptr->r_index[2] = r_index;
923f08ff
AM		 2032 natptr->r_type[0] = ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
2033 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
2034 | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
2035 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
2036 | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
2037 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
2038 }
2039 else
2040 {
2041 natptr->r_index[2] = r_index >> 16;
2042 natptr->r_index[1] = r_index >> 8;
2043 natptr->r_index[0] = r_index;
2044 natptr->r_type[0] = ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
2045 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
2046 | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
2047 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
2048 | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
2049 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
2050 }
252b5132
RH		 2051}
2052
f7c33884 2053/* Extended stuff. */
0ef5a5bd 2054/* Output extended relocation information to a file in target byte order. */
252b5132 2055
116c20d2
NC		 2056extern void NAME (aout, swap_ext_reloc_out)
2057 (bfd *, arelent *, struct reloc_ext_external *);
252b5132
RH		 2058
2059void
116c20d2
NC		 2060NAME (aout, swap_ext_reloc_out) (bfd *abfd,
2061 arelent *g,
2062 struct reloc_ext_external *natptr)
252b5132
RH		 2063{
2064 int r_index;
2065 int r_extern;
2066 unsigned int r_type;
dc810e39 2067 bfd_vma r_addend;
252b5132
RH		 2068 asymbol *sym = *(g->sym_ptr_ptr);
2069 asection *output_section = sym->section->output_section;
2070
2071 PUT_WORD (abfd, g->address, natptr->r_address);
2072
2073 r_type = (unsigned int) g->howto->type;
2074
2075 r_addend = g->addend;
2076 if ((sym->flags & BSF_SECTION_SYM) != 0)
2077 r_addend += (*(g->sym_ptr_ptr))->section->output_section->vma;
2078
2079 /* If this relocation is relative to a symbol then set the
2080 r_index to the symbols index, and the r_extern bit.
2081
2082 Absolute symbols can come in in two ways, either as an offset
2083 from the abs section, or as a symbol which has an abs value.
2084 check for that here. */
252b5132
RH		 2085 if (bfd_is_abs_section (bfd_get_section (sym)))
2086 {
2087 r_extern = 0;
2088 r_index = N_ABS;
2089 }
2090 else if ((sym->flags & BSF_SECTION_SYM) == 0)
2091 {
2092 if (bfd_is_und_section (bfd_get_section (sym))
2093 || (sym->flags & BSF_GLOBAL) != 0)
2094 r_extern = 1;
2095 else
2096 r_extern = 0;
2097 r_index = (*(g->sym_ptr_ptr))->KEEPIT;
2098 }
2099 else
2100 {
f7c33884 2101 /* Just an ordinary section. */
252b5132
RH		 2102 r_extern = 0;
2103 r_index = output_section->target_index;
2104 }
2105
f7c33884 2106 /* Now the fun stuff. */
923f08ff
AM		 2107 if (bfd_header_big_endian (abfd))
2108 {
2109 natptr->r_index[0] = r_index >> 16;
2110 natptr->r_index[1] = r_index >> 8;
2111 natptr->r_index[2] = r_index;
2112 natptr->r_type[0] = ((r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
2113 | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG));
2114 }
2115 else
2116 {
2117 natptr->r_index[2] = r_index >> 16;
2118 natptr->r_index[1] = r_index >> 8;
2119 natptr->r_index[0] = r_index;
2120 natptr->r_type[0] = ((r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
2121 | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE));
2122 }
252b5132
RH		 2123
2124 PUT_WORD (abfd, r_addend, natptr->r_addend);
2125}
2126
2127/* BFD deals internally with all things based from the section they're
2128 in. so, something in 10 bytes into a text section with a base of
2129 50 would have a symbol (.text+10) and know .text vma was 50.
2130
2131 Aout keeps all it's symbols based from zero, so the symbol would
2132 contain 60. This macro subs the base of each section from the value
923f08ff
AM		 2133 to give the true offset from the section. */
2134
2135#define MOVE_ADDRESS(ad) \
2136 if (r_extern) \
2137 { \
2138 /* Undefined symbol. */ \
2139 cache_ptr->sym_ptr_ptr = symbols + r_index; \
252b5132 2140 cache_ptr->addend = ad; \
252b5132 2141 } \
923f08ff
AM		 2142 else \
2143 { \
2144 /* Defined, section relative. Replace symbol with pointer to \
2145 symbol which points to section. */ \
2146 switch (r_index) \
2147 { \
2148 case N_TEXT: \
2149 case N_TEXT | N_EXT: \
2150 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
2151 cache_ptr->addend = ad - su->textsec->vma; \
2152 break; \
2153 case N_DATA: \
2154 case N_DATA | N_EXT: \
2155 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
2156 cache_ptr->addend = ad - su->datasec->vma; \
2157 break; \
2158 case N_BSS: \
2159 case N_BSS | N_EXT: \
2160 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
2161 cache_ptr->addend = ad - su->bsssec->vma; \
2162 break; \
2163 default: \
2164 case N_ABS: \
2165 case N_ABS | N_EXT: \
2166 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
2167 cache_ptr->addend = ad; \
2168 break; \
2169 } \
2170 }
252b5132
RH		 2171
2172void
116c20d2
NC		 2173NAME (aout, swap_ext_reloc_in) (bfd *abfd,
2174 struct reloc_ext_external *bytes,
2175 arelent *cache_ptr,
2176 asymbol **symbols,
2177 bfd_size_type symcount)
252b5132
RH		 2178{
2179 unsigned int r_index;
2180 int r_extern;
2181 unsigned int r_type;
2182 struct aoutdata *su = &(abfd->tdata.aout_data->a);
2183
2184 cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));
2185
f7c33884 2186 /* Now the fun stuff. */
923f08ff
AM		 2187 if (bfd_header_big_endian (abfd))
2188 {
d45913a0
DA		 2189 r_index = (((unsigned int) bytes->r_index[0] << 16)
2190 | ((unsigned int) bytes->r_index[1] << 8)
923f08ff
AM		 2191 | bytes->r_index[2]);
2192 r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
2193 r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
2194 >> RELOC_EXT_BITS_TYPE_SH_BIG);
2195 }
2196 else
2197 {
d45913a0
DA		 2198 r_index = (((unsigned int) bytes->r_index[2] << 16)
2199 | ((unsigned int) bytes->r_index[1] << 8)
923f08ff
AM		 2200 | bytes->r_index[0]);
2201 r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
2202 r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
2203 >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
2204 }
252b5132 2205
ad756e3f
AM		 2206 if (r_type < TABLE_SIZE (howto_table_ext))
2207 cache_ptr->howto = howto_table_ext + r_type;
2208 else
2209 cache_ptr->howto = NULL;
252b5132
RH		 2210
2211 /* Base relative relocs are always against the symbol table,
2212 regardless of the setting of r_extern. r_extern just reflects
2213 whether the symbol the reloc is against is local or global. */
d45913a0
DA		 2214 if (r_type == (unsigned int) RELOC_BASE10
2215 || r_type == (unsigned int) RELOC_BASE13
2216 || r_type == (unsigned int) RELOC_BASE22)
252b5132
RH		 2217 r_extern = 1;
2218
2219 if (r_extern && r_index > symcount)
2220 {
2221 /* We could arrange to return an error, but it might be useful
07d6d2b8 2222 to see the file even if it is bad. */
252b5132
RH		 2223 r_extern = 0;
2224 r_index = N_ABS;
2225 }
2226
923f08ff 2227 MOVE_ADDRESS (GET_SWORD (abfd, bytes->r_addend));
252b5132
RH		 2228}
2229
2230void
116c20d2
NC		 2231NAME (aout, swap_std_reloc_in) (bfd *abfd,
2232 struct reloc_std_external *bytes,
2233 arelent *cache_ptr,
2234 asymbol **symbols,
2235 bfd_size_type symcount)
252b5132
RH		 2236{
2237 unsigned int r_index;
2238 int r_extern;
2239 unsigned int r_length;
2240 int r_pcrel;
2241 int r_baserel, r_jmptable, r_relative;
2242 struct aoutdata *su = &(abfd->tdata.aout_data->a);
2243 unsigned int howto_idx;
2244
dc810e39 2245 cache_ptr->address = H_GET_32 (abfd, bytes->r_address);
252b5132 2246
f7c33884 2247 /* Now the fun stuff. */
923f08ff
AM		 2248 if (bfd_header_big_endian (abfd))
2249 {
d45913a0
DA		 2250 r_index = (((unsigned int) bytes->r_index[0] << 16)
2251 | ((unsigned int) bytes->r_index[1] << 8)
923f08ff
AM		 2252 | bytes->r_index[2]);
2253 r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
2254 r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
2255 r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
2256 r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
2257 r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
2258 r_length = ((bytes->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
2259 >> RELOC_STD_BITS_LENGTH_SH_BIG);
2260 }
2261 else
2262 {
d45913a0
DA		 2263 r_index = (((unsigned int) bytes->r_index[2] << 16)
2264 | ((unsigned int) bytes->r_index[1] << 8)
923f08ff
AM		 2265 | bytes->r_index[0]);
2266 r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
2267 r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
2268 r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE));
2269 r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
2270 r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_LITTLE));
2271 r_length = ((bytes->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
2272 >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
2273 }
252b5132 2274
923f08ff
AM		 2275 howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel
2276 + 16 * r_jmptable + 32 * r_relative);
ad756e3f
AM		 2277 if (howto_idx < TABLE_SIZE (howto_table_std))
2278 {
2279 cache_ptr->howto = howto_table_std + howto_idx;
2280 if (cache_ptr->howto->type == (unsigned int) -1)
2281 cache_ptr->howto = NULL;
2282 }
2283 else
2284 cache_ptr->howto = NULL;
252b5132
RH		 2285
2286 /* Base relative relocs are always against the symbol table,
2287 regardless of the setting of r_extern. r_extern just reflects
2288 whether the symbol the reloc is against is local or global. */
2289 if (r_baserel)
2290 r_extern = 1;
2291
116acb2c 2292 if (r_extern && r_index >= symcount)
252b5132
RH		 2293 {
2294 /* We could arrange to return an error, but it might be useful
116acb2c
AM		 2295 to see the file even if it is bad. FIXME: Of course this
2296 means that objdump -r *doesn't* see the actual reloc, and
2297 objcopy silently writes a different reloc. */
252b5132
RH		 2298 r_extern = 0;
2299 r_index = N_ABS;
2300 }
2301
923f08ff 2302 MOVE_ADDRESS (0);
252b5132
RH		 2303}
2304
2305/* Read and swap the relocs for a section. */
2306
b34976b6 2307bfd_boolean
116c20d2 2308NAME (aout, slurp_reloc_table) (bfd *abfd, sec_ptr asect, asymbol **symbols)
252b5132 2309{
dc810e39 2310 bfd_size_type count;
252b5132 2311 bfd_size_type reloc_size;
116c20d2 2312 void * relocs;
252b5132
RH		 2313 arelent *reloc_cache;
2314 size_t each_size;
2315 unsigned int counter = 0;
2316 arelent *cache_ptr;
dc810e39 2317 bfd_size_type amt;
252b5132
RH		 2318
2319 if (asect->relocation)
b34976b6 2320 return TRUE;
252b5132
RH		 2321
2322 if (asect->flags & SEC_CONSTRUCTOR)
b34976b6 2323 return TRUE;
252b5132
RH		 2324
2325 if (asect == obj_datasec (abfd))
923f08ff 2326 reloc_size = exec_hdr (abfd)->a_drsize;
252b5132 2327 else if (asect == obj_textsec (abfd))
923f08ff 2328 reloc_size = exec_hdr (abfd)->a_trsize;
252b5132
RH		 2329 else if (asect == obj_bsssec (abfd))
2330 reloc_size = 0;
2331 else
2332 {
2333 bfd_set_error (bfd_error_invalid_operation);
b34976b6 2334 return FALSE;
252b5132
RH		 2335 }
2336
078c4bfc
MS		 2337 if (reloc_size == 0)
2338 return TRUE; /* Nothing to be done. */
2339
252b5132 2340 if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
b34976b6 2341 return FALSE;
252b5132
RH		 2342
2343 each_size = obj_reloc_entry_size (abfd);
2344
2345 count = reloc_size / each_size;
078c4bfc
MS		 2346 if (count == 0)
2347 return TRUE; /* Nothing to be done. */
252b5132 2348
dc810e39 2349 amt = count * sizeof (arelent);
a50b1753 2350 reloc_cache = (arelent *) bfd_zmalloc (amt);
078c4bfc 2351 if (reloc_cache == NULL)
b34976b6 2352 return FALSE;
252b5132 2353
dc810e39 2354 relocs = bfd_malloc (reloc_size);
078c4bfc 2355 if (relocs == NULL)
252b5132
RH		 2356 {
2357 free (reloc_cache);
b34976b6 2358 return FALSE;
252b5132
RH		 2359 }
2360
dc810e39 2361 if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
252b5132
RH		 2362 {
2363 free (relocs);
2364 free (reloc_cache);
b34976b6 2365 return FALSE;
252b5132
RH		 2366 }
2367
2368 cache_ptr = reloc_cache;
2369 if (each_size == RELOC_EXT_SIZE)
2370 {
dc810e39 2371 struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs;
252b5132
RH		 2372
2373 for (; counter < count; counter++, rptr++, cache_ptr++)
1642229e 2374 MY_swap_ext_reloc_in (abfd, rptr, cache_ptr, symbols,
dc810e39 2375 (bfd_size_type) bfd_get_symcount (abfd));
252b5132
RH		 2376 }
2377 else
2378 {
dc810e39 2379 struct reloc_std_external *rptr = (struct reloc_std_external *) relocs;
252b5132
RH		 2380
2381 for (; counter < count; counter++, rptr++, cache_ptr++)
2382 MY_swap_std_reloc_in (abfd, rptr, cache_ptr, symbols,
dc810e39 2383 (bfd_size_type) bfd_get_symcount (abfd));
252b5132
RH		 2384 }
2385
2386 free (relocs);
2387
2388 asect->relocation = reloc_cache;
2389 asect->reloc_count = cache_ptr - reloc_cache;
2390
b34976b6 2391 return TRUE;
252b5132
RH		 2392}
2393
2394/* Write out a relocation section into an object file. */
2395
b34976b6 2396bfd_boolean
116c20d2 2397NAME (aout, squirt_out_relocs) (bfd *abfd, asection *section)
252b5132
RH		 2398{
2399 arelent **generic;
2400 unsigned char *native, *natptr;
2401 size_t each_size;
2402
2403 unsigned int count = section->reloc_count;
dc810e39 2404 bfd_size_type natsize;
252b5132
RH		 2405
2406 if (count == 0 || section->orelocation == NULL)
b34976b6 2407 return TRUE;
252b5132
RH		 2408
2409 each_size = obj_reloc_entry_size (abfd);
dc810e39 2410 natsize = (bfd_size_type) each_size * count;
a50b1753 2411 native = (unsigned char *) bfd_zalloc (abfd, natsize);
252b5132 2412 if (!native)
b34976b6 2413 return FALSE;
252b5132
RH		 2414
2415 generic = section->orelocation;
2416
2417 if (each_size == RELOC_EXT_SIZE)
2418 {
2419 for (natptr = native;
2420 count != 0;
2421 --count, natptr += each_size, ++generic)
e2996cc3 2422 {
92744f05
NC		 2423 /* PR 20921: If the howto field has not been initialised then skip
2424 this reloc.
2425 PR 20929: Similarly for the symbol field. */
2426 if ((*generic)->howto == NULL
2427 || (*generic)->sym_ptr_ptr == NULL)
e2996cc3
NC		 2428 {
2429 bfd_set_error (bfd_error_invalid_operation);
92744f05 2430 _bfd_error_handler (_("\
871b3ab2 2431%pB: attempt to write out unknown reloc type"), abfd);
e2996cc3
NC		 2432 return FALSE;
2433 }
2434 MY_swap_ext_reloc_out (abfd, *generic,
2435 (struct reloc_ext_external *) natptr);
2436 }
252b5132
RH		 2437 }
2438 else
2439 {
2440 for (natptr = native;
2441 count != 0;
2442 --count, natptr += each_size, ++generic)
e2996cc3 2443 {
92744f05
NC		 2444 if ((*generic)->howto == NULL
2445 || (*generic)->sym_ptr_ptr == NULL)
e2996cc3
NC		 2446 {
2447 bfd_set_error (bfd_error_invalid_operation);
92744f05 2448 _bfd_error_handler (_("\
871b3ab2 2449%pB: attempt to write out unknown reloc type"), abfd);
e2996cc3
NC		 2450 return FALSE;
2451 }
2452 MY_swap_std_reloc_out (abfd, *generic,
2453 (struct reloc_std_external *) natptr);
2454 }
252b5132
RH		 2455 }
2456
116c20d2 2457 if (bfd_bwrite ((void *) native, natsize, abfd) != natsize)
dc810e39 2458 {
923f08ff 2459 bfd_release (abfd, native);
b34976b6 2460 return FALSE;
dc810e39 2461 }
252b5132
RH		 2462 bfd_release (abfd, native);
2463
b34976b6 2464 return TRUE;
252b5132
RH		 2465}
2466
f7c33884
NC		 2467/* This is stupid. This function should be a boolean predicate. */
2468
252b5132 2469long
116c20d2
NC		 2470NAME (aout, canonicalize_reloc) (bfd *abfd,
2471 sec_ptr section,
2472 arelent **relptr,
2473 asymbol **symbols)
252b5132
RH		 2474{
2475 arelent *tblptr = section->relocation;
2476 unsigned int count;
2477
2478 if (section == obj_bsssec (abfd))
2479 {
2480 *relptr = NULL;
2481 return 0;
2482 }
2483
116c20d2 2484 if (!(tblptr || NAME (aout, slurp_reloc_table) (abfd, section, symbols)))
252b5132
RH		 2485 return -1;
2486
923f08ff
AM		 2487 if (section->flags & SEC_CONSTRUCTOR)
2488 {
2489 arelent_chain *chain = section->constructor_chain;
2490 for (count = 0; count < section->reloc_count; count ++)
2491 {
2492 *relptr ++ = &chain->relent;
2493 chain = chain->next;
2494 }
252b5132 2495 }
923f08ff
AM		 2496 else
2497 {
2498 tblptr = section->relocation;
252b5132 2499
923f08ff
AM		 2500 for (count = 0; count++ < section->reloc_count; )
2501 {
2502 *relptr++ = tblptr++;
2503 }
2504 }
252b5132
RH		 2505 *relptr = 0;
2506
2507 return section->reloc_count;
2508}
2509
2510long
116c20d2 2511NAME (aout, get_reloc_upper_bound) (bfd *abfd, sec_ptr asect)
252b5132 2512{
923f08ff
AM		 2513 if (bfd_get_format (abfd) != bfd_object)
2514 {
2515 bfd_set_error (bfd_error_invalid_operation);
2516 return -1;
2517 }
f7c33884 2518
923f08ff 2519 if (asect->flags & SEC_CONSTRUCTOR)
116c20d2 2520 return sizeof (arelent *) * (asect->reloc_count + 1);
252b5132
RH		 2521
2522 if (asect == obj_datasec (abfd))
116c20d2
NC		 2523 return sizeof (arelent *)
2524 * ((exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd))
2525 + 1);
252b5132
RH		 2526
2527 if (asect == obj_textsec (abfd))
116c20d2
NC		 2528 return sizeof (arelent *)
2529 * ((exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd))
2530 + 1);
252b5132
RH		 2531
2532 if (asect == obj_bsssec (abfd))
2533 return sizeof (arelent *);
2534
2535 if (asect == obj_bsssec (abfd))
2536 return 0;
2537
2538 bfd_set_error (bfd_error_invalid_operation);
2539 return -1;
2540}
252b5132
RH		 2541\f
2542long
116c20d2 2543NAME (aout, get_symtab_upper_bound) (bfd *abfd)
252b5132 2544{
116c20d2 2545 if (!NAME (aout, slurp_symbol_table) (abfd))
252b5132
RH		 2546 return -1;
2547
2548 return (bfd_get_symcount (abfd)+1) * (sizeof (aout_symbol_type *));
2549}
2550
1725a96e 2551alent *
116c20d2
NC		 2552NAME (aout, get_lineno) (bfd *ignore_abfd ATTRIBUTE_UNUSED,
2553 asymbol *ignore_symbol ATTRIBUTE_UNUSED)
252b5132 2554{
116c20d2 2555 return NULL;
252b5132
RH		 2556}
2557
252b5132 2558void
116c20d2
NC		 2559NAME (aout, get_symbol_info) (bfd *ignore_abfd ATTRIBUTE_UNUSED,
2560 asymbol *symbol,
2561 symbol_info *ret)
252b5132
RH		 2562{
2563 bfd_symbol_info (symbol, ret);
2564
2565 if (ret->type == '?')
2566 {
923f08ff 2567 int type_code = aout_symbol (symbol)->type & 0xff;
252b5132
RH		 2568 const char *stab_name = bfd_get_stab_name (type_code);
2569 static char buf[10];
2570
2571 if (stab_name == NULL)
2572 {
e60b52c6 2573 sprintf (buf, "(%d)", type_code);
252b5132
RH		 2574 stab_name = buf;
2575 }
2576 ret->type = '-';
2577 ret->stab_type = type_code;
923f08ff
AM		 2578 ret->stab_other = (unsigned) (aout_symbol (symbol)->other & 0xff);
2579 ret->stab_desc = (unsigned) (aout_symbol (symbol)->desc & 0xffff);
252b5132
RH		 2580 ret->stab_name = stab_name;
2581 }
2582}
2583
252b5132 2584void
116c20d2
NC		 2585NAME (aout, print_symbol) (bfd *abfd,
2586 void * afile,
2587 asymbol *symbol,
2588 bfd_print_symbol_type how)
252b5132
RH		 2589{
2590 FILE *file = (FILE *)afile;
2591
923f08ff 2592 switch (how)
252b5132 2593 {
923f08ff
AM		 2594 case bfd_print_symbol_name:
2595 if (symbol->name)
2596 fprintf (file,"%s", symbol->name);
2597 break;
2598 case bfd_print_symbol_more:
2599 fprintf (file,"%4x %2x %2x",
2600 (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2601 (unsigned) (aout_symbol (symbol)->other & 0xff),
2602 (unsigned) (aout_symbol (symbol)->type));
2603 break;
2604 case bfd_print_symbol_all:
2605 {
2606 const char *section_name = symbol->section->name;
252b5132 2607
116c20d2 2608 bfd_print_symbol_vandf (abfd, (void *)file, symbol);
252b5132 2609
923f08ff
AM		 2610 fprintf (file," %-5s %04x %02x %02x",
2611 section_name,
2612 (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2613 (unsigned) (aout_symbol (symbol)->other & 0xff),
2614 (unsigned) (aout_symbol (symbol)->type & 0xff));
2615 if (symbol->name)
2616 fprintf (file," %s", symbol->name);
2617 }
2618 break;
252b5132 2619 }
252b5132
RH		 2620}
2621
2622/* If we don't have to allocate more than 1MB to hold the generic
2623 symbols, we use the generic minisymbol methord: it's faster, since
2624 it only translates the symbols once, not multiple times. */
2625#define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2626
2627/* Read minisymbols. For minisymbols, we use the unmodified a.out
2628 symbols. The minisymbol_to_symbol function translates these into
2629 BFD asymbol structures. */
2630
2631long
116c20d2
NC		 2632NAME (aout, read_minisymbols) (bfd *abfd,
2633 bfd_boolean dynamic,
2634 void * *minisymsp,
2635 unsigned int *sizep)
252b5132
RH		 2636{
2637 if (dynamic)
116c20d2
NC		 2638 /* We could handle the dynamic symbols here as well, but it's
2639 easier to hand them off. */
2640 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
252b5132
RH		 2641
2642 if (! aout_get_external_symbols (abfd))
2643 return -1;
2644
2645 if (obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2646 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2647
116c20d2 2648 *minisymsp = (void *) obj_aout_external_syms (abfd);
252b5132
RH		 2649
2650 /* By passing the external symbols back from this routine, we are
2651 giving up control over the memory block. Clear
2652 obj_aout_external_syms, so that we do not try to free it
2653 ourselves. */
2654 obj_aout_external_syms (abfd) = NULL;
2655
2656 *sizep = EXTERNAL_NLIST_SIZE;
2657 return obj_aout_external_sym_count (abfd);
2658}
2659
2660/* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2661 unmodified a.out symbol. The SYM argument is a structure returned
2662 by bfd_make_empty_symbol, which we fill in here. */
2663
2664asymbol *
116c20d2
NC		 2665NAME (aout, minisymbol_to_symbol) (bfd *abfd,
2666 bfd_boolean dynamic,
2667 const void * minisym,
2668 asymbol *sym)
252b5132
RH		 2669{
2670 if (dynamic
2671 || obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2672 return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
2673
2674 memset (sym, 0, sizeof (aout_symbol_type));
2675
2676 /* We call translate_symbol_table to translate a single symbol. */
116c20d2 2677 if (! (NAME (aout, translate_symbol_table)
252b5132
RH		 2678 (abfd,
2679 (aout_symbol_type *) sym,
2680 (struct external_nlist *) minisym,
2681 (bfd_size_type) 1,
2682 obj_aout_external_strings (abfd),
2683 obj_aout_external_string_size (abfd),
b34976b6 2684 FALSE)))
252b5132
RH		 2685 return NULL;
2686
2687 return sym;
2688}
2689
f7c33884
NC		 2690/* Provided a BFD, a section and an offset into the section, calculate
2691 and return the name of the source file and the line nearest to the
2692 wanted location. */
252b5132 2693
b34976b6 2694bfd_boolean
116c20d2 2695NAME (aout, find_nearest_line) (bfd *abfd,
116c20d2 2696 asymbol **symbols,
fb167eb2 2697 asection *section,
116c20d2
NC		 2698 bfd_vma offset,
2699 const char **filename_ptr,
2700 const char **functionname_ptr,
fb167eb2
AM		 2701 unsigned int *line_ptr,
2702 unsigned int *disriminator_ptr)
252b5132 2703{
f7c33884 2704 /* Run down the file looking for the filename, function and linenumber. */
252b5132 2705 asymbol **p;
dc810e39
AM		 2706 const char *directory_name = NULL;
2707 const char *main_file_name = NULL;
2708 const char *current_file_name = NULL;
116c20d2 2709 const char *line_file_name = NULL; /* Value of current_file_name at line number. */
dc810e39 2710 const char *line_directory_name = NULL; /* Value of directory_name at line number. */
252b5132
RH		 2711 bfd_vma low_line_vma = 0;
2712 bfd_vma low_func_vma = 0;
2713 asymbol *func = 0;
dc810e39 2714 bfd_size_type filelen, funclen;
252b5132
RH		 2715 char *buf;
2716
2717 *filename_ptr = abfd->filename;
50455f1a 2718 *functionname_ptr = NULL;
252b5132 2719 *line_ptr = 0;
fb167eb2
AM		 2720 if (disriminator_ptr)
2721 *disriminator_ptr = 0;
f7c33884 2722
116c20d2 2723 if (symbols != NULL)
923f08ff
AM		 2724 {
2725 for (p = symbols; *p; p++)
2726 {
2727 aout_symbol_type *q = (aout_symbol_type *) (*p);
2728 next:
2729 switch (q->type)
2730 {
2731 case N_TEXT:
2732 /* If this looks like a file name symbol, and it comes after
2733 the line number we have found so far, but before the
2734 offset, then we have probably not found the right line
2735 number. */
2736 if (q->symbol.value <= offset
2737 && ((q->symbol.value > low_line_vma
2738 && (line_file_name != NULL
2739 || *line_ptr != 0))
2740 || (q->symbol.value > low_func_vma
2741 && func != NULL)))
2742 {
2743 const char *symname;
252b5132 2744
923f08ff
AM		 2745 symname = q->symbol.name;
2746 if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
2747 {
2748 if (q->symbol.value > low_line_vma)
2749 {
2750 *line_ptr = 0;
2751 line_file_name = NULL;
2752 }
2753 if (q->symbol.value > low_func_vma)
2754 func = NULL;
2755 }
2756 }
2757 break;
252b5132 2758
923f08ff
AM		 2759 case N_SO:
2760 /* If this symbol is less than the offset, but greater than
2761 the line number we have found so far, then we have not
2762 found the right line number. */
2763 if (q->symbol.value <= offset)
2764 {
2765 if (q->symbol.value > low_line_vma)
2766 {
2767 *line_ptr = 0;
2768 line_file_name = NULL;
2769 }
2770 if (q->symbol.value > low_func_vma)
2771 func = NULL;
2772 }
252b5132 2773
923f08ff
AM		 2774 main_file_name = current_file_name = q->symbol.name;
2775 /* Look ahead to next symbol to check if that too is an N_SO. */
2776 p++;
2777 if (*p == NULL)
c3864421 2778 goto done;
923f08ff
AM		 2779 q = (aout_symbol_type *) (*p);
2780 if (q->type != (int)N_SO)
2781 goto next;
2782
2783 /* Found a second N_SO First is directory; second is filename. */
2784 directory_name = current_file_name;
2785 main_file_name = current_file_name = q->symbol.name;
2786 if (obj_textsec (abfd) != section)
2787 goto done;
2788 break;
2789 case N_SOL:
2790 current_file_name = q->symbol.name;
2791 break;
252b5132 2792
923f08ff 2793 case N_SLINE:
252b5132 2794
923f08ff
AM		 2795 case N_DSLINE:
2796 case N_BSLINE:
2797 /* We'll keep this if it resolves nearer than the one we have
2798 already. */
2799 if (q->symbol.value >= low_line_vma
2800 && q->symbol.value <= offset)
2801 {
2802 *line_ptr = q->desc;
2803 low_line_vma = q->symbol.value;
2804 line_file_name = current_file_name;
2805 line_directory_name = directory_name;
2806 }
2807 break;
2808 case N_FUN:
2809 {
f7c33884 2810 /* We'll keep this if it is nearer than the one we have already. */
923f08ff 2811 if (q->symbol.value >= low_func_vma &&
f7c33884
NC		 2812 q->symbol.value <= offset)
2813 {
2814 low_func_vma = q->symbol.value;
2815 func = (asymbol *)q;
2816 }
923f08ff
AM		 2817 else if (q->symbol.value > offset)
2818 goto done;
2819 }
2820 break;
2821 }
252b5132 2822 }
252b5132 2823 }
252b5132
RH		 2824
2825 done:
2826 if (*line_ptr != 0)
2827 {
2828 main_file_name = line_file_name;
2829 directory_name = line_directory_name;
2830 }
2831
2832 if (main_file_name == NULL
5af11cab 2833 || IS_ABSOLUTE_PATH (main_file_name)
252b5132
RH		 2834 || directory_name == NULL)
2835 filelen = 0;
2836 else
2837 filelen = strlen (directory_name) + strlen (main_file_name);
f7c33884 2838
252b5132
RH		 2839 if (func == NULL)
2840 funclen = 0;
2841 else
2842 funclen = strlen (bfd_asymbol_name (func));
2843
2844 if (adata (abfd).line_buf != NULL)
2845 free (adata (abfd).line_buf);
f7c33884 2846
252b5132
RH		 2847 if (filelen + funclen == 0)
2848 adata (abfd).line_buf = buf = NULL;
2849 else
2850 {
a50b1753 2851 buf = (char *) bfd_malloc (filelen + funclen + 3);
252b5132
RH		 2852 adata (abfd).line_buf = buf;
2853 if (buf == NULL)
b34976b6 2854 return FALSE;
252b5132
RH		 2855 }
2856
2857 if (main_file_name != NULL)
2858 {
5af11cab 2859 if (IS_ABSOLUTE_PATH (main_file_name) || directory_name == NULL)
252b5132
RH		 2860 *filename_ptr = main_file_name;
2861 else
2862 {
50455f1a
NC		 2863 if (buf == NULL)
2864 /* PR binutils/20891: In a corrupt input file both
2865 main_file_name and directory_name can be empty... */
2866 * filename_ptr = NULL;
2867 else
2868 {
2869 snprintf (buf, filelen + 1, "%s%s", directory_name,
2870 main_file_name);
2871 *filename_ptr = buf;
2872 buf += filelen + 1;
2873 }
252b5132
RH		 2874 }
2875 }
2876
2877 if (func)
2878 {
2879 const char *function = func->name;
dc810e39 2880 char *colon;
252b5132 2881
e82ab856
NC		 2882 if (buf == NULL)
2883 {
2884 /* PR binutils/20892: In a corrupt input file func can be empty. */
2885 * functionname_ptr = NULL;
2886 return TRUE;
2887 }
252b5132
RH		 2888 /* The caller expects a symbol name. We actually have a
2889 function name, without the leading underscore. Put the
2890 underscore back in, so that the caller gets a symbol name. */
2891 if (bfd_get_symbol_leading_char (abfd) == '\0')
2892 strcpy (buf, function);
2893 else
2894 {
2895 buf[0] = bfd_get_symbol_leading_char (abfd);
2896 strcpy (buf + 1, function);
2897 }
f7c33884 2898 /* Have to remove : stuff. */
dc810e39
AM		 2899 colon = strchr (buf, ':');
2900 if (colon != NULL)
2901 *colon = '\0';
252b5132
RH		 2902 *functionname_ptr = buf;
2903 }
2904
b34976b6 2905 return TRUE;
252b5132
RH		 2906}
2907
252b5132 2908int
a6b96beb
AM		 2909NAME (aout, sizeof_headers) (bfd *abfd,
2910 struct bfd_link_info *info ATTRIBUTE_UNUSED)
252b5132 2911{
923f08ff 2912 return adata (abfd).exec_bytes_size;
252b5132
RH		 2913}
2914
2915/* Free all information we have cached for this BFD. We can always
2916 read it again later if we need it. */
2917
b34976b6 2918bfd_boolean
116c20d2 2919NAME (aout, bfd_free_cached_info) (bfd *abfd)
252b5132
RH		 2920{
2921 asection *o;
2922
920581c5
L		 2923 if (bfd_get_format (abfd) != bfd_object
2924 || abfd->tdata.aout_data == NULL)
b34976b6 2925 return TRUE;
252b5132
RH		 2926
2927#define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2928 BFCI_FREE (obj_aout_symbols (abfd));
2929#ifdef USE_MMAP
2930 obj_aout_external_syms (abfd) = 0;
2931 bfd_free_window (&obj_aout_sym_window (abfd));
2932 bfd_free_window (&obj_aout_string_window (abfd));
2933 obj_aout_external_strings (abfd) = 0;
2934#else
2935 BFCI_FREE (obj_aout_external_syms (abfd));
2936 BFCI_FREE (obj_aout_external_strings (abfd));
2937#endif
116c20d2 2938 for (o = abfd->sections; o != NULL; o = o->next)
252b5132
RH		 2939 BFCI_FREE (o->relocation);
2940#undef BFCI_FREE
2941
b34976b6 2942 return TRUE;
252b5132
RH		 2943}
2944\f
2945/* a.out link code. */
2946
252b5132
RH		 2947/* Routine to create an entry in an a.out link hash table. */
2948
2949struct bfd_hash_entry *
116c20d2
NC		 2950NAME (aout, link_hash_newfunc) (struct bfd_hash_entry *entry,
2951 struct bfd_hash_table *table,
2952 const char *string)
252b5132
RH		 2953{
2954 struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry;
2955
2956 /* Allocate the structure if it has not already been allocated by a
2957 subclass. */
116c20d2 2958 if (ret == NULL)
a50b1753 2959 ret = (struct aout_link_hash_entry *) bfd_hash_allocate (table,
07d6d2b8 2960 sizeof (* ret));
116c20d2
NC		 2961 if (ret == NULL)
2962 return NULL;
252b5132
RH		 2963
2964 /* Call the allocation method of the superclass. */
2965 ret = ((struct aout_link_hash_entry *)
2966 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2967 table, string));
2968 if (ret)
2969 {
2970 /* Set local fields. */
b34976b6 2971 ret->written = FALSE;
252b5132
RH		 2972 ret->indx = -1;
2973 }
2974
2975 return (struct bfd_hash_entry *) ret;
2976}
2977
2978/* Initialize an a.out link hash table. */
2979
b34976b6 2980bfd_boolean
116c20d2
NC		 2981NAME (aout, link_hash_table_init) (struct aout_link_hash_table *table,
2982 bfd *abfd,
2983 struct bfd_hash_entry *(*newfunc)
2984 (struct bfd_hash_entry *, struct bfd_hash_table *,
66eb6687
AM		 2985 const char *),
2986 unsigned int entsize)
252b5132 2987{
66eb6687 2988 return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
252b5132
RH		 2989}
2990
2991/* Create an a.out link hash table. */
2992
2993struct bfd_link_hash_table *
116c20d2 2994NAME (aout, link_hash_table_create) (bfd *abfd)
252b5132
RH		 2995{
2996 struct aout_link_hash_table *ret;
116c20d2 2997 bfd_size_type amt = sizeof (* ret);
252b5132 2998
a50b1753 2999 ret = (struct aout_link_hash_table *) bfd_malloc (amt);
252b5132 3000 if (ret == NULL)
116c20d2 3001 return NULL;
5ed6aba4 3002
66eb6687
AM		 3003 if (!NAME (aout, link_hash_table_init) (ret, abfd,
3004 NAME (aout, link_hash_newfunc),
3005 sizeof (struct aout_link_hash_entry)))
252b5132
RH		 3006 {
3007 free (ret);
116c20d2 3008 return NULL;
252b5132
RH		 3009 }
3010 return &ret->root;
3011}
3012
116c20d2 3013/* Add all symbols from an object file to the hash table. */
252b5132 3014
b34976b6 3015static bfd_boolean
116c20d2 3016aout_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
252b5132 3017{
116c20d2
NC		 3018 bfd_boolean (*add_one_symbol)
3019 (struct bfd_link_info *, bfd *, const char *, flagword, asection *,
3020 bfd_vma, const char *, bfd_boolean, bfd_boolean,
3021 struct bfd_link_hash_entry **);
3022 struct external_nlist *syms;
3023 bfd_size_type sym_count;
3024 char *strings;
3025 bfd_boolean copy;
3026 struct aout_link_hash_entry **sym_hash;
3027 struct external_nlist *p;
3028 struct external_nlist *pend;
3029 bfd_size_type amt;
252b5132 3030
116c20d2
NC		 3031 syms = obj_aout_external_syms (abfd);
3032 sym_count = obj_aout_external_sym_count (abfd);
3033 strings = obj_aout_external_strings (abfd);
3034 if (info->keep_memory)
3035 copy = FALSE;
3036 else
3037 copy = TRUE;
252b5132 3038
116c20d2 3039 if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
252b5132 3040 {
116c20d2
NC		 3041 if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
3042 (abfd, info, &syms, &sym_count, &strings)))
b34976b6 3043 return FALSE;
252b5132
RH		 3044 }
3045
20c6e70e
MS		 3046 if (sym_count == 0)
3047 return TRUE; /* Nothing to do. */
3048
116c20d2
NC		 3049 /* We keep a list of the linker hash table entries that correspond
3050 to particular symbols. We could just look them up in the hash
3051 table, but keeping the list is more efficient. Perhaps this
3052 should be conditional on info->keep_memory. */
3053 amt = sym_count * sizeof (struct aout_link_hash_entry *);
a50b1753 3054 sym_hash = (struct aout_link_hash_entry **) bfd_alloc (abfd, amt);
20c6e70e 3055 if (sym_hash == NULL)
116c20d2
NC		 3056 return FALSE;
3057 obj_aout_sym_hashes (abfd) = sym_hash;
252b5132 3058
116c20d2
NC		 3059 add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
3060 if (add_one_symbol == NULL)
3061 add_one_symbol = _bfd_generic_link_add_one_symbol;
252b5132 3062
116c20d2
NC		 3063 p = syms;
3064 pend = p + sym_count;
3065 for (; p < pend; p++, sym_hash++)
252b5132 3066 {
116c20d2 3067 int type;
252b5132 3068 const char *name;
116c20d2
NC		 3069 bfd_vma value;
3070 asection *section;
3071 flagword flags;
3072 const char *string;
252b5132 3073
116c20d2 3074 *sym_hash = NULL;
252b5132 3075
116c20d2 3076 type = H_GET_8 (abfd, p->e_type);
252b5132 3077
116c20d2
NC		 3078 /* Ignore debugging symbols. */
3079 if ((type & N_STAB) != 0)
3080 continue;
252b5132 3081
e517df3d 3082 /* PR 19629: Corrupt binaries can contain illegal string offsets. */
531336e3 3083 if (GET_WORD (abfd, p->e_strx) >= obj_aout_external_string_size (abfd))
e517df3d 3084 return FALSE;
116c20d2
NC		 3085 name = strings + GET_WORD (abfd, p->e_strx);
3086 value = GET_WORD (abfd, p->e_value);
3087 flags = BSF_GLOBAL;
3088 string = NULL;
3089 switch (type)
252b5132 3090 {
116c20d2
NC		 3091 default:
3092 abort ();
f7c33884 3093
116c20d2
NC		 3094 case N_UNDF:
3095 case N_ABS:
3096 case N_TEXT:
3097 case N_DATA:
3098 case N_BSS:
3099 case N_FN_SEQ:
3100 case N_COMM:
3101 case N_SETV:
3102 case N_FN:
3103 /* Ignore symbols that are not externally visible. */
3104 continue;
3105 case N_INDR:
3106 /* Ignore local indirect symbol. */
3107 ++p;
3108 ++sym_hash;
3109 continue;
252b5132 3110
116c20d2
NC		 3111 case N_UNDF | N_EXT:
3112 if (value == 0)
f7c33884 3113 {
116c20d2
NC		 3114 section = bfd_und_section_ptr;
3115 flags = 0;
252b5132
RH		 3116 }
3117 else
3118 section = bfd_com_section_ptr;
3119 break;
3120 case N_ABS | N_EXT:
3121 section = bfd_abs_section_ptr;
3122 break;
3123 case N_TEXT | N_EXT:
3124 section = obj_textsec (abfd);
3125 value -= bfd_get_section_vma (abfd, section);
3126 break;
3127 case N_DATA | N_EXT:
3128 case N_SETV | N_EXT:
3129 /* Treat N_SETV symbols as N_DATA symbol; see comment in
3130 translate_from_native_sym_flags. */
3131 section = obj_datasec (abfd);
3132 value -= bfd_get_section_vma (abfd, section);
3133 break;
3134 case N_BSS | N_EXT:
3135 section = obj_bsssec (abfd);
3136 value -= bfd_get_section_vma (abfd, section);
3137 break;
3138 case N_INDR | N_EXT:
3139 /* An indirect symbol. The next symbol is the symbol
3140 which this one really is. */
39d4daf6
NC		 3141 /* See PR 20925 for a reproducer. */
3142 if (p + 1 >= pend)
3143 return FALSE;
252b5132 3144 ++p;
e517df3d 3145 /* PR 19629: Corrupt binaries can contain illegal string offsets. */
daae68f4 3146 if (GET_WORD (abfd, p->e_strx) >= obj_aout_external_string_size (abfd))
e517df3d 3147 return FALSE;
252b5132
RH		 3148 string = strings + GET_WORD (abfd, p->e_strx);
3149 section = bfd_ind_section_ptr;
3150 flags |= BSF_INDIRECT;
3151 break;
3152 case N_COMM | N_EXT:
3153 section = bfd_com_section_ptr;
3154 break;
3155 case N_SETA: case N_SETA | N_EXT:
3156 section = bfd_abs_section_ptr;
3157 flags |= BSF_CONSTRUCTOR;
3158 break;
3159 case N_SETT: case N_SETT | N_EXT:
3160 section = obj_textsec (abfd);
3161 flags |= BSF_CONSTRUCTOR;
3162 value -= bfd_get_section_vma (abfd, section);
3163 break;
3164 case N_SETD: case N_SETD | N_EXT:
3165 section = obj_datasec (abfd);
3166 flags |= BSF_CONSTRUCTOR;
3167 value -= bfd_get_section_vma (abfd, section);
3168 break;
3169 case N_SETB: case N_SETB | N_EXT:
3170 section = obj_bsssec (abfd);
3171 flags |= BSF_CONSTRUCTOR;
3172 value -= bfd_get_section_vma (abfd, section);
3173 break;
3174 case N_WARNING:
3175 /* A warning symbol. The next symbol is the one to warn
9f400ee9
HPN		 3176 about. If there is no next symbol, just look away. */
3177 if (p + 1 >= pend)
3178 return TRUE;
252b5132
RH		 3179 ++p;
3180 string = name;
e517df3d 3181 /* PR 19629: Corrupt binaries can contain illegal string offsets. */
daae68f4 3182 if (GET_WORD (abfd, p->e_strx) >= obj_aout_external_string_size (abfd))
e517df3d 3183 return FALSE;
252b5132
RH		 3184 name = strings + GET_WORD (abfd, p->e_strx);
3185 section = bfd_und_section_ptr;
3186 flags |= BSF_WARNING;
3187 break;
3188 case N_WEAKU:
3189 section = bfd_und_section_ptr;
3190 flags = BSF_WEAK;
3191 break;
3192 case N_WEAKA:
3193 section = bfd_abs_section_ptr;
3194 flags = BSF_WEAK;
3195 break;
3196 case N_WEAKT:
3197 section = obj_textsec (abfd);
3198 value -= bfd_get_section_vma (abfd, section);
3199 flags = BSF_WEAK;
3200 break;
3201 case N_WEAKD:
3202 section = obj_datasec (abfd);
3203 value -= bfd_get_section_vma (abfd, section);
3204 flags = BSF_WEAK;
3205 break;
3206 case N_WEAKB:
3207 section = obj_bsssec (abfd);
3208 value -= bfd_get_section_vma (abfd, section);
3209 flags = BSF_WEAK;
3210 break;
3211 }
3212
3213 if (! ((*add_one_symbol)
b34976b6 3214 (info, abfd, name, flags, section, value, string, copy, FALSE,
252b5132 3215 (struct bfd_link_hash_entry **) sym_hash)))
b34976b6 3216 return FALSE;
252b5132
RH		 3217
3218 /* Restrict the maximum alignment of a common symbol based on
3219 the architecture, since a.out has no way to represent
3220 alignment requirements of a section in a .o file. FIXME:
3221 This isn't quite right: it should use the architecture of the
3222 output file, not the input files. */
3223 if ((*sym_hash)->root.type == bfd_link_hash_common
3224 && ((*sym_hash)->root.u.c.p->alignment_power >
3225 bfd_get_arch_info (abfd)->section_align_power))
3226 (*sym_hash)->root.u.c.p->alignment_power =
3227 bfd_get_arch_info (abfd)->section_align_power;
3228
3229 /* If this is a set symbol, and we are not building sets, then
3230 it is possible for the hash entry to not have been set. In
3231 such a case, treat the symbol as not globally defined. */
3232 if ((*sym_hash)->root.type == bfd_link_hash_new)
3233 {
3234 BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
3235 *sym_hash = NULL;
3236 }
3237
3238 if (type == (N_INDR | N_EXT) || type == N_WARNING)
3239 ++sym_hash;
3240 }
3241
b34976b6 3242 return TRUE;
252b5132 3243}
252b5132 3244
116c20d2
NC		 3245/* Free up the internal symbols read from an a.out file. */
3246
3247static bfd_boolean
3248aout_link_free_symbols (bfd *abfd)
252b5132 3249{
116c20d2
NC		 3250 if (obj_aout_external_syms (abfd) != NULL)
3251 {
3252#ifdef USE_MMAP
3253 bfd_free_window (&obj_aout_sym_window (abfd));
3254#else
3255 free ((void *) obj_aout_external_syms (abfd));
3256#endif
3257 obj_aout_external_syms (abfd) = NULL;
3258 }
3259 if (obj_aout_external_strings (abfd) != NULL)
3260 {
3261#ifdef USE_MMAP
3262 bfd_free_window (&obj_aout_string_window (abfd));
3263#else
3264 free ((void *) obj_aout_external_strings (abfd));
3265#endif
3266 obj_aout_external_strings (abfd) = NULL;
3267 }
3268 return TRUE;
3269}
252b5132 3270
116c20d2 3271/* Add symbols from an a.out object file. */
252b5132 3272
116c20d2
NC		 3273static bfd_boolean
3274aout_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
252b5132 3275{
116c20d2
NC		 3276 if (! aout_get_external_symbols (abfd))
3277 return FALSE;
3278 if (! aout_link_add_symbols (abfd, info))
3279 return FALSE;
3280 if (! info->keep_memory)
3281 {
3282 if (! aout_link_free_symbols (abfd))
3283 return FALSE;
3284 }
3285 return TRUE;
3286}
252b5132 3287
116c20d2
NC		 3288/* Look through the internal symbols to see if this object file should
3289 be included in the link. We should include this object file if it
3290 defines any symbols which are currently undefined. If this object
3291 file defines a common symbol, then we may adjust the size of the
3292 known symbol but we do not include the object file in the link
3293 (unless there is some other reason to include it). */
252b5132 3294
116c20d2
NC		 3295static bfd_boolean
3296aout_link_check_ar_symbols (bfd *abfd,
3297 struct bfd_link_info *info,
5d3236ee
DK		 3298 bfd_boolean *pneeded,
3299 bfd **subsbfd)
252b5132 3300{
116c20d2
NC		 3301 struct external_nlist *p;
3302 struct external_nlist *pend;
3303 char *strings;
252b5132 3304
116c20d2 3305 *pneeded = FALSE;
252b5132 3306
116c20d2
NC		 3307 /* Look through all the symbols. */
3308 p = obj_aout_external_syms (abfd);
3309 pend = p + obj_aout_external_sym_count (abfd);
3310 strings = obj_aout_external_strings (abfd);
3311 for (; p < pend; p++)
3312 {
3313 int type = H_GET_8 (abfd, p->e_type);
3314 const char *name;
3315 struct bfd_link_hash_entry *h;
252b5132 3316
116c20d2
NC		 3317 /* Ignore symbols that are not externally visible. This is an
3318 optimization only, as we check the type more thoroughly
3319 below. */
3320 if (((type & N_EXT) == 0
3321 || (type & N_STAB) != 0
3322 || type == N_FN)
3323 && type != N_WEAKA
3324 && type != N_WEAKT
3325 && type != N_WEAKD
3326 && type != N_WEAKB)
3327 {
3328 if (type == N_WARNING
3329 || type == N_INDR)
3330 ++p;
3331 continue;
3332 }
3333
3334 name = strings + GET_WORD (abfd, p->e_strx);
3335 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
3336
3337 /* We are only interested in symbols that are currently
3338 undefined or common. */
3339 if (h == NULL
3340 || (h->type != bfd_link_hash_undefined
3341 && h->type != bfd_link_hash_common))
3342 {
3343 if (type == (N_INDR | N_EXT))
3344 ++p;
3345 continue;
3346 }
3347
3348 if (type == (N_TEXT | N_EXT)
3349 || type == (N_DATA | N_EXT)
3350 || type == (N_BSS | N_EXT)
3351 || type == (N_ABS | N_EXT)
3352 || type == (N_INDR | N_EXT))
3353 {
3354 /* This object file defines this symbol. We must link it
3355 in. This is true regardless of whether the current
3356 definition of the symbol is undefined or common.
3357
07d6d2b8 3358 If the current definition is common, we have a case in
116c20d2 3359 which we have already seen an object file including:
07d6d2b8 3360 int a;
116c20d2 3361 and this object file from the archive includes:
07d6d2b8 3362 int a = 5;
116c20d2 3363 In such a case, whether to include this object is target
07d6d2b8 3364 dependant for backward compatibility.
116c20d2
NC		 3365
3366 FIXME: The SunOS 4.1.3 linker will pull in the archive
3367 element if the symbol is defined in the .data section,
3368 but not if it is defined in the .text section. That
3369 seems a bit crazy to me, and it has not been implemented
3370 yet. However, it might be correct. */
3371 if (h->type == bfd_link_hash_common)
3372 {
3373 int skip = 0;
3374
f88dc410 3375 switch (info->common_skip_ar_symbols)
116c20d2 3376 {
a78eea16
AM		 3377 case bfd_link_common_skip_none:
3378 break;
116c20d2
NC		 3379 case bfd_link_common_skip_text:
3380 skip = (type == (N_TEXT | N_EXT));
3381 break;
3382 case bfd_link_common_skip_data:
3383 skip = (type == (N_DATA | N_EXT));
3384 break;
116c20d2
NC		 3385 case bfd_link_common_skip_all:
3386 skip = 1;
3387 break;
3388 }
3389
3390 if (skip)
3391 continue;
3392 }
3393
0e144ba7
AM		 3394 if (!(*info->callbacks
3395 ->add_archive_element) (info, abfd, name, subsbfd))
116c20d2
NC		 3396 return FALSE;
3397 *pneeded = TRUE;
3398 return TRUE;
3399 }
3400
3401 if (type == (N_UNDF | N_EXT))
3402 {
3403 bfd_vma value;
3404
3405 value = GET_WORD (abfd, p->e_value);
3406 if (value != 0)
3407 {
3408 /* This symbol is common in the object from the archive
3409 file. */
3410 if (h->type == bfd_link_hash_undefined)
3411 {
3412 bfd *symbfd;
3413 unsigned int power;
3414
3415 symbfd = h->u.undef.abfd;
3416 if (symbfd == NULL)
3417 {
3418 /* This symbol was created as undefined from
3419 outside BFD. We assume that we should link
3420 in the object file. This is done for the -u
3421 option in the linker. */
0e144ba7
AM		 3422 if (!(*info->callbacks
3423 ->add_archive_element) (info, abfd, name, subsbfd))
116c20d2
NC		 3424 return FALSE;
3425 *pneeded = TRUE;
3426 return TRUE;
3427 }
3428 /* Turn the current link symbol into a common
3429 symbol. It is already on the undefs list. */
3430 h->type = bfd_link_hash_common;
a50b1753 3431 h->u.c.p = (struct bfd_link_hash_common_entry *)
0e144ba7
AM		 3432 bfd_hash_allocate (&info->hash->table,
3433 sizeof (struct bfd_link_hash_common_entry));
116c20d2
NC		 3434 if (h->u.c.p == NULL)
3435 return FALSE;
3436
3437 h->u.c.size = value;
3438
3439 /* FIXME: This isn't quite right. The maximum
3440 alignment of a common symbol should be set by the
3441 architecture of the output file, not of the input
3442 file. */
3443 power = bfd_log2 (value);
3444 if (power > bfd_get_arch_info (abfd)->section_align_power)
3445 power = bfd_get_arch_info (abfd)->section_align_power;
3446 h->u.c.p->alignment_power = power;
3447
3448 h->u.c.p->section = bfd_make_section_old_way (symbfd,
3449 "COMMON");
3450 }
3451 else
3452 {
3453 /* Adjust the size of the common symbol if
3454 necessary. */
3455 if (value > h->u.c.size)
3456 h->u.c.size = value;
3457 }
3458 }
3459 }
3460
3461 if (type == N_WEAKA
3462 || type == N_WEAKT
3463 || type == N_WEAKD
3464 || type == N_WEAKB)
3465 {
3466 /* This symbol is weak but defined. We must pull it in if
3467 the current link symbol is undefined, but we don't want
3468 it if the current link symbol is common. */
3469 if (h->type == bfd_link_hash_undefined)
3470 {
0e144ba7
AM		 3471 if (!(*info->callbacks
3472 ->add_archive_element) (info, abfd, name, subsbfd))
116c20d2
NC		 3473 return FALSE;
3474 *pneeded = TRUE;
3475 return TRUE;
3476 }
3477 }
3478 }
3479
3480 /* We do not need this object file. */
3481 return TRUE;
3482}
3483/* Check a single archive element to see if we need to include it in
3484 the link. *PNEEDED is set according to whether this element is
3485 needed in the link or not. This is called from
3486 _bfd_generic_link_add_archive_symbols. */
3487
3488static bfd_boolean
3489aout_link_check_archive_element (bfd *abfd,
3490 struct bfd_link_info *info,
13e570f8
AM		 3491 struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED,
3492 const char *name ATTRIBUTE_UNUSED,
116c20d2
NC		 3493 bfd_boolean *pneeded)
3494{
0e144ba7
AM		 3495 bfd *oldbfd;
3496 bfd_boolean needed;
5d3236ee 3497
0e144ba7 3498 if (!aout_get_external_symbols (abfd))
116c20d2
NC		 3499 return FALSE;
3500
0e144ba7
AM		 3501 oldbfd = abfd;
3502 if (!aout_link_check_ar_symbols (abfd, info, pneeded, &abfd))
116c20d2
NC		 3503 return FALSE;
3504
0e144ba7
AM		 3505 needed = *pneeded;
3506 if (needed)
116c20d2 3507 {
5d3236ee
DK		 3508 /* Potentially, the add_archive_element hook may have set a
3509 substitute BFD for us. */
0e144ba7
AM		 3510 if (abfd != oldbfd)
3511 {
3512 if (!info->keep_memory
3513 && !aout_link_free_symbols (oldbfd))
3514 return FALSE;
3515 if (!aout_get_external_symbols (abfd))
3516 return FALSE;
3517 }
3518 if (!aout_link_add_symbols (abfd, info))
116c20d2
NC		 3519 return FALSE;
3520 }
3521
0e144ba7 3522 if (!info->keep_memory || !needed)
116c20d2 3523 {
0e144ba7 3524 if (!aout_link_free_symbols (abfd))
116c20d2
NC		 3525 return FALSE;
3526 }
3527
3528 return TRUE;
3529}
3530
3531/* Given an a.out BFD, add symbols to the global hash table as
3532 appropriate. */
3533
3534bfd_boolean
3535NAME (aout, link_add_symbols) (bfd *abfd, struct bfd_link_info *info)
3536{
3537 switch (bfd_get_format (abfd))
3538 {
3539 case bfd_object:
3540 return aout_link_add_object_symbols (abfd, info);
3541 case bfd_archive:
3542 return _bfd_generic_link_add_archive_symbols
3543 (abfd, info, aout_link_check_archive_element);
3544 default:
3545 bfd_set_error (bfd_error_wrong_format);
3546 return FALSE;
3547 }
3548}
3549\f
3550/* A hash table used for header files with N_BINCL entries. */
3551
3552struct aout_link_includes_table
3553{
3554 struct bfd_hash_table root;
3555};
3556
3557/* A linked list of totals that we have found for a particular header
3558 file. */
3559
3560struct aout_link_includes_totals
3561{
3562 struct aout_link_includes_totals *next;
3563 bfd_vma total;
3564};
3565
3566/* An entry in the header file hash table. */
3567
3568struct aout_link_includes_entry
3569{
3570 struct bfd_hash_entry root;
3571 /* List of totals we have found for this file. */
3572 struct aout_link_includes_totals *totals;
3573};
3574
3575/* Look up an entry in an the header file hash table. */
3576
3577#define aout_link_includes_lookup(table, string, create, copy) \
3578 ((struct aout_link_includes_entry *) \
3579 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3580
3581/* During the final link step we need to pass around a bunch of
3582 information, so we do it in an instance of this structure. */
3583
3584struct aout_final_link_info
3585{
3586 /* General link information. */
3587 struct bfd_link_info *info;
3588 /* Output bfd. */
252b5132
RH		 3589 bfd *output_bfd;
3590 /* Reloc file positions. */
3591 file_ptr treloff, dreloff;
3592 /* File position of symbols. */
3593 file_ptr symoff;
3594 /* String table. */
3595 struct bfd_strtab_hash *strtab;
3596 /* Header file hash table. */
3597 struct aout_link_includes_table includes;
3598 /* A buffer large enough to hold the contents of any section. */
3599 bfd_byte *contents;
3600 /* A buffer large enough to hold the relocs of any section. */
116c20d2 3601 void * relocs;
252b5132
RH		 3602 /* A buffer large enough to hold the symbol map of any input BFD. */
3603 int *symbol_map;
3604 /* A buffer large enough to hold output symbols of any input BFD. */
3605 struct external_nlist *output_syms;
3606};
3607
252b5132
RH		 3608/* The function to create a new entry in the header file hash table. */
3609
3610static struct bfd_hash_entry *
116c20d2
NC		 3611aout_link_includes_newfunc (struct bfd_hash_entry *entry,
3612 struct bfd_hash_table *table,
3613 const char *string)
252b5132
RH		 3614{
3615 struct aout_link_includes_entry *ret =
3616 (struct aout_link_includes_entry *) entry;
3617
3618 /* Allocate the structure if it has not already been allocated by a
3619 subclass. */
116c20d2 3620 if (ret == NULL)
a50b1753 3621 ret = (struct aout_link_includes_entry *)
07d6d2b8 3622 bfd_hash_allocate (table, sizeof (* ret));
116c20d2
NC		 3623 if (ret == NULL)
3624 return NULL;
252b5132
RH		 3625
3626 /* Call the allocation method of the superclass. */
3627 ret = ((struct aout_link_includes_entry *)
3628 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
3629 if (ret)
3630 {
3631 /* Set local fields. */
3632 ret->totals = NULL;
3633 }
3634
3635 return (struct bfd_hash_entry *) ret;
3636}
3637
116c20d2
NC		 3638/* Write out a symbol that was not associated with an a.out input
3639 object. */
252b5132 3640
116c20d2 3641static bfd_boolean
7686d77d 3642aout_link_write_other_symbol (struct bfd_hash_entry *bh, void *data)
252b5132 3643{
7686d77d 3644 struct aout_link_hash_entry *h = (struct aout_link_hash_entry *) bh;
57402f1e 3645 struct aout_final_link_info *flaginfo = (struct aout_final_link_info *) data;
116c20d2
NC		 3646 bfd *output_bfd;
3647 int type;
3648 bfd_vma val;
3649 struct external_nlist outsym;
3650 bfd_size_type indx;
3651 bfd_size_type amt;
252b5132 3652
116c20d2
NC		 3653 if (h->root.type == bfd_link_hash_warning)
3654 {
3655 h = (struct aout_link_hash_entry *) h->root.u.i.link;
3656 if (h->root.type == bfd_link_hash_new)
3657 return TRUE;
3658 }
252b5132 3659
57402f1e 3660 output_bfd = flaginfo->output_bfd;
252b5132 3661
116c20d2 3662 if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
252b5132 3663 {
116c20d2 3664 if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
57402f1e 3665 (output_bfd, flaginfo->info, h)))
252b5132 3666 {
116c20d2
NC		 3667 /* FIXME: No way to handle errors. */
3668 abort ();
252b5132 3669 }
116c20d2 3670 }
252b5132 3671
116c20d2
NC		 3672 if (h->written)
3673 return TRUE;
252b5132 3674
116c20d2 3675 h->written = TRUE;
252b5132 3676
116c20d2
NC		 3677 /* An indx of -2 means the symbol must be written. */
3678 if (h->indx != -2
57402f1e
NC		 3679 && (flaginfo->info->strip == strip_all
3680 || (flaginfo->info->strip == strip_some
3681 && bfd_hash_lookup (flaginfo->info->keep_hash, h->root.root.string,
116c20d2
NC		 3682 FALSE, FALSE) == NULL)))
3683 return TRUE;
252b5132 3684
116c20d2 3685 switch (h->root.type)
252b5132 3686 {
116c20d2
NC		 3687 default:
3688 case bfd_link_hash_warning:
3689 abort ();
3690 /* Avoid variable not initialized warnings. */
3691 return TRUE;
3692 case bfd_link_hash_new:
3693 /* This can happen for set symbols when sets are not being
07d6d2b8 3694 built. */
116c20d2
NC		 3695 return TRUE;
3696 case bfd_link_hash_undefined:
3697 type = N_UNDF | N_EXT;
3698 val = 0;
3699 break;
3700 case bfd_link_hash_defined:
3701 case bfd_link_hash_defweak:
3702 {
3703 asection *sec;
252b5132 3704
116c20d2
NC		 3705 sec = h->root.u.def.section->output_section;
3706 BFD_ASSERT (bfd_is_abs_section (sec)
3707 || sec->owner == output_bfd);
3708 if (sec == obj_textsec (output_bfd))
3709 type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
3710 else if (sec == obj_datasec (output_bfd))
3711 type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
3712 else if (sec == obj_bsssec (output_bfd))
3713 type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
3714 else
3715 type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
3716 type |= N_EXT;
3717 val = (h->root.u.def.value
3718 + sec->vma
3719 + h->root.u.def.section->output_offset);
3720 }
3721 break;
3722 case bfd_link_hash_common:
3723 type = N_UNDF | N_EXT;
3724 val = h->root.u.c.size;
3725 break;
3726 case bfd_link_hash_undefweak:
3727 type = N_WEAKU;
3728 val = 0;
c38eb2a6 3729 break;
116c20d2
NC		 3730 case bfd_link_hash_indirect:
3731 /* We ignore these symbols, since the indirected symbol is
3732 already in the hash table. */
3733 return TRUE;
3734 }
252b5132 3735
116c20d2
NC		 3736 H_PUT_8 (output_bfd, type, outsym.e_type);
3737 H_PUT_8 (output_bfd, 0, outsym.e_other);
3738 H_PUT_16 (output_bfd, 0, outsym.e_desc);
57402f1e 3739 indx = add_to_stringtab (output_bfd, flaginfo->strtab, h->root.root.string,
116c20d2
NC		 3740 FALSE);
3741 if (indx == - (bfd_size_type) 1)
3742 /* FIXME: No way to handle errors. */
3743 abort ();
252b5132 3744
116c20d2
NC		 3745 PUT_WORD (output_bfd, indx, outsym.e_strx);
3746 PUT_WORD (output_bfd, val, outsym.e_value);
252b5132 3747
116c20d2 3748 amt = EXTERNAL_NLIST_SIZE;
57402f1e 3749 if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0
116c20d2
NC		 3750 || bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt)
3751 /* FIXME: No way to handle errors. */
3752 abort ();
252b5132 3753
57402f1e 3754 flaginfo->symoff += EXTERNAL_NLIST_SIZE;
116c20d2
NC		 3755 h->indx = obj_aout_external_sym_count (output_bfd);
3756 ++obj_aout_external_sym_count (output_bfd);
252b5132 3757
116c20d2
NC		 3758 return TRUE;
3759}
252b5132 3760
116c20d2 3761/* Handle a link order which is supposed to generate a reloc. */
252b5132 3762
116c20d2 3763static bfd_boolean
57402f1e 3764aout_link_reloc_link_order (struct aout_final_link_info *flaginfo,
116c20d2
NC		 3765 asection *o,
3766 struct bfd_link_order *p)
3767{
3768 struct bfd_link_order_reloc *pr;
3769 int r_index;
3770 int r_extern;
3771 reloc_howto_type *howto;
3772 file_ptr *reloff_ptr = NULL;
3773 struct reloc_std_external srel;
3774 struct reloc_ext_external erel;
3775 void * rel_ptr;
3776 bfd_size_type amt;
252b5132 3777
116c20d2 3778 pr = p->u.reloc.p;
252b5132 3779
116c20d2
NC		 3780 if (p->type == bfd_section_reloc_link_order)
3781 {
3782 r_extern = 0;
3783 if (bfd_is_abs_section (pr->u.section))
3784 r_index = N_ABS | N_EXT;
3785 else
3786 {
57402f1e 3787 BFD_ASSERT (pr->u.section->owner == flaginfo->output_bfd);
116c20d2
NC		 3788 r_index = pr->u.section->target_index;
3789 }
3790 }
3791 else
3792 {
3793 struct aout_link_hash_entry *h;
252b5132 3794
116c20d2
NC		 3795 BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
3796 r_extern = 1;
3797 h = ((struct aout_link_hash_entry *)
57402f1e 3798 bfd_wrapped_link_hash_lookup (flaginfo->output_bfd, flaginfo->info,
116c20d2
NC		 3799 pr->u.name, FALSE, FALSE, TRUE));
3800 if (h != NULL
3801 && h->indx >= 0)
3802 r_index = h->indx;
3803 else if (h != NULL)
3804 {
3805 /* We decided to strip this symbol, but it turns out that we
3806 can't. Note that we lose the other and desc information
3807 here. I don't think that will ever matter for a global
3808 symbol. */
3809 h->indx = -2;
3810 h->written = FALSE;
57402f1e 3811 if (!aout_link_write_other_symbol (&h->root.root, flaginfo))
116c20d2
NC		 3812 return FALSE;
3813 r_index = h->indx;
3814 }
3815 else
3816 {
1a72702b
AM		 3817 (*flaginfo->info->callbacks->unattached_reloc)
3818 (flaginfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0);
116c20d2
NC		 3819 r_index = 0;
3820 }
3821 }
252b5132 3822
57402f1e 3823 howto = bfd_reloc_type_lookup (flaginfo->output_bfd, pr->reloc);
116c20d2 3824 if (howto == 0)
252b5132 3825 {
116c20d2
NC		 3826 bfd_set_error (bfd_error_bad_value);
3827 return FALSE;
252b5132
RH		 3828 }
3829
57402f1e
NC		 3830 if (o == obj_textsec (flaginfo->output_bfd))
3831 reloff_ptr = &flaginfo->treloff;
3832 else if (o == obj_datasec (flaginfo->output_bfd))
3833 reloff_ptr = &flaginfo->dreloff;
116c20d2
NC		 3834 else
3835 abort ();
3836
57402f1e 3837 if (obj_reloc_entry_size (flaginfo->output_bfd) == RELOC_STD_SIZE)
252b5132 3838 {
116c20d2 3839#ifdef MY_put_reloc
57402f1e 3840 MY_put_reloc (flaginfo->output_bfd, r_extern, r_index, p->offset, howto,
116c20d2
NC		 3841 &srel);
3842#else
3843 {
3844 int r_pcrel;
3845 int r_baserel;
3846 int r_jmptable;
3847 int r_relative;
3848 int r_length;
252b5132 3849
116c20d2
NC		 3850 r_pcrel = (int) howto->pc_relative;
3851 r_baserel = (howto->type & 8) != 0;
3852 r_jmptable = (howto->type & 16) != 0;
3853 r_relative = (howto->type & 32) != 0;
3854 r_length = howto->size;
252b5132 3855
57402f1e
NC		 3856 PUT_WORD (flaginfo->output_bfd, p->offset, srel.r_address);
3857 if (bfd_header_big_endian (flaginfo->output_bfd))
116c20d2
NC		 3858 {
3859 srel.r_index[0] = r_index >> 16;
3860 srel.r_index[1] = r_index >> 8;
3861 srel.r_index[2] = r_index;
3862 srel.r_type[0] =
3863 ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
3864 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
3865 | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
3866 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
3867 | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
3868 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
3869 }
3870 else
3871 {
3872 srel.r_index[2] = r_index >> 16;
3873 srel.r_index[1] = r_index >> 8;
3874 srel.r_index[0] = r_index;
3875 srel.r_type[0] =
3876 ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
3877 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
3878 | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
3879 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
3880 | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
3881 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
3882 }
3883 }
3884#endif
3885 rel_ptr = (void *) &srel;
252b5132 3886
116c20d2
NC		 3887 /* We have to write the addend into the object file, since
3888 standard a.out relocs are in place. It would be more
3889 reliable if we had the current contents of the file here,
3890 rather than assuming zeroes, but we can't read the file since
3891 it was opened using bfd_openw. */
3892 if (pr->addend != 0)
252b5132 3893 {
116c20d2
NC		 3894 bfd_size_type size;
3895 bfd_reloc_status_type r;
3896 bfd_byte *buf;
3897 bfd_boolean ok;
3898
3899 size = bfd_get_reloc_size (howto);
a50b1753 3900 buf = (bfd_byte *) bfd_zmalloc (size);
6346d5ca 3901 if (buf == NULL && size != 0)
116c20d2 3902 return FALSE;
57402f1e 3903 r = MY_relocate_contents (howto, flaginfo->output_bfd,
116c20d2
NC		 3904 (bfd_vma) pr->addend, buf);
3905 switch (r)
252b5132 3906 {
116c20d2
NC		 3907 case bfd_reloc_ok:
3908 break;
3909 default:
3910 case bfd_reloc_outofrange:
3911 abort ();
3912 case bfd_reloc_overflow:
1a72702b
AM		 3913 (*flaginfo->info->callbacks->reloc_overflow)
3914 (flaginfo->info, NULL,
3915 (p->type == bfd_section_reloc_link_order
3916 ? bfd_section_name (flaginfo->output_bfd,
3917 pr->u.section)
3918 : pr->u.name),
3919 howto->name, pr->addend, NULL, NULL, (bfd_vma) 0);
116c20d2 3920 break;
252b5132 3921 }
57402f1e 3922 ok = bfd_set_section_contents (flaginfo->output_bfd, o, (void *) buf,
116c20d2
NC		 3923 (file_ptr) p->offset, size);
3924 free (buf);
3925 if (! ok)
3926 return FALSE;
252b5132
RH		 3927 }
3928 }
116c20d2 3929 else
252b5132 3930 {
116c20d2 3931#ifdef MY_put_ext_reloc
57402f1e 3932 MY_put_ext_reloc (flaginfo->output_bfd, r_extern, r_index, p->offset,
116c20d2
NC		 3933 howto, &erel, pr->addend);
3934#else
57402f1e 3935 PUT_WORD (flaginfo->output_bfd, p->offset, erel.r_address);
252b5132 3936
57402f1e 3937 if (bfd_header_big_endian (flaginfo->output_bfd))
116c20d2
NC		 3938 {
3939 erel.r_index[0] = r_index >> 16;
3940 erel.r_index[1] = r_index >> 8;
3941 erel.r_index[2] = r_index;
3942 erel.r_type[0] =
3943 ((r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
3944 | (howto->type << RELOC_EXT_BITS_TYPE_SH_BIG));
3945 }
3946 else
3947 {
3948 erel.r_index[2] = r_index >> 16;
3949 erel.r_index[1] = r_index >> 8;
3950 erel.r_index[0] = r_index;
3951 erel.r_type[0] =
3952 (r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
3953 | (howto->type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
3954 }
252b5132 3955
57402f1e 3956 PUT_WORD (flaginfo->output_bfd, (bfd_vma) pr->addend, erel.r_addend);
116c20d2 3957#endif /* MY_put_ext_reloc */
252b5132 3958
116c20d2 3959 rel_ptr = (void *) &erel;
252b5132 3960 }
252b5132 3961
57402f1e
NC		 3962 amt = obj_reloc_entry_size (flaginfo->output_bfd);
3963 if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
3964 || bfd_bwrite (rel_ptr, amt, flaginfo->output_bfd) != amt)
116c20d2 3965 return FALSE;
252b5132 3966
57402f1e 3967 *reloff_ptr += obj_reloc_entry_size (flaginfo->output_bfd);
252b5132 3968
116c20d2
NC		 3969 /* Assert that the relocs have not run into the symbols, and that n
3970 the text relocs have not run into the data relocs. */
57402f1e
NC		 3971 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd)
3972 && (reloff_ptr != &flaginfo->treloff
116c20d2 3973 || (*reloff_ptr
57402f1e 3974 <= obj_datasec (flaginfo->output_bfd)->rel_filepos)));
116c20d2
NC		 3975
3976 return TRUE;
252b5132
RH		 3977}
3978
116c20d2 3979/* Get the section corresponding to a reloc index. */
252b5132 3980
116c20d2
NC		 3981static INLINE asection *
3982aout_reloc_index_to_section (bfd *abfd, int indx)
252b5132 3983{
116c20d2 3984 switch (indx & N_TYPE)
252b5132 3985 {
116c20d2
NC		 3986 case N_TEXT: return obj_textsec (abfd);
3987 case N_DATA: return obj_datasec (abfd);
3988 case N_BSS: return obj_bsssec (abfd);
3989 case N_ABS:
3990 case N_UNDF: return bfd_abs_section_ptr;
3991 default: abort ();
252b5132 3992 }
116c20d2 3993 return NULL;
252b5132
RH		 3994}
3995
116c20d2 3996/* Relocate an a.out section using standard a.out relocs. */
252b5132 3997
b34976b6 3998static bfd_boolean
57402f1e 3999aout_link_input_section_std (struct aout_final_link_info *flaginfo,
116c20d2
NC		 4000 bfd *input_bfd,
4001 asection *input_section,
4002 struct reloc_std_external *relocs,
4003 bfd_size_type rel_size,
4004 bfd_byte *contents)
252b5132 4005{
116c20d2
NC		 4006 bfd_boolean (*check_dynamic_reloc)
4007 (struct bfd_link_info *, bfd *, asection *,
4008 struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
4009 bfd_vma *);
252b5132 4010 bfd *output_bfd;
116c20d2
NC		 4011 bfd_boolean relocatable;
4012 struct external_nlist *syms;
252b5132 4013 char *strings;
116c20d2 4014 struct aout_link_hash_entry **sym_hashes;
252b5132 4015 int *symbol_map;
116c20d2
NC		 4016 bfd_size_type reloc_count;
4017 struct reloc_std_external *rel;
4018 struct reloc_std_external *rel_end;
252b5132 4019
57402f1e 4020 output_bfd = flaginfo->output_bfd;
116c20d2 4021 check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
252b5132 4022
116c20d2
NC		 4023 BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE);
4024 BFD_ASSERT (input_bfd->xvec->header_byteorder
4025 == output_bfd->xvec->header_byteorder);
252b5132 4026
0e1862bb 4027 relocatable = bfd_link_relocatable (flaginfo->info);
116c20d2
NC		 4028 syms = obj_aout_external_syms (input_bfd);
4029 strings = obj_aout_external_strings (input_bfd);
4030 sym_hashes = obj_aout_sym_hashes (input_bfd);
57402f1e 4031 symbol_map = flaginfo->symbol_map;
116c20d2
NC		 4032
4033 reloc_count = rel_size / RELOC_STD_SIZE;
4034 rel = relocs;
4035 rel_end = rel + reloc_count;
4036 for (; rel < rel_end; rel++)
252b5132 4037 {
116c20d2
NC		 4038 bfd_vma r_addr;
4039 int r_index;
4040 int r_extern;
4041 int r_pcrel;
4042 int r_baserel = 0;
4043 reloc_howto_type *howto;
4044 struct aout_link_hash_entry *h = NULL;
4045 bfd_vma relocation;
4046 bfd_reloc_status_type r;
252b5132 4047
116c20d2 4048 r_addr = GET_SWORD (input_bfd, rel->r_address);
252b5132 4049
116c20d2
NC		 4050#ifdef MY_reloc_howto
4051 howto = MY_reloc_howto (input_bfd, rel, r_index, r_extern, r_pcrel);
4052#else
4053 {
4054 int r_jmptable;
4055 int r_relative;
4056 int r_length;
4057 unsigned int howto_idx;
252b5132 4058
116c20d2
NC		 4059 if (bfd_header_big_endian (input_bfd))
4060 {
4061 r_index = (((unsigned int) rel->r_index[0] << 16)
4062 | ((unsigned int) rel->r_index[1] << 8)
4063 | rel->r_index[2]);
4064 r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
4065 r_pcrel = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
4066 r_baserel = (0 != (rel->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
4067 r_jmptable= (0 != (rel->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
4068 r_relative= (0 != (rel->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
4069 r_length = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
4070 >> RELOC_STD_BITS_LENGTH_SH_BIG);
4071 }
4072 else
4073 {
4074 r_index = (((unsigned int) rel->r_index[2] << 16)
4075 | ((unsigned int) rel->r_index[1] << 8)
4076 | rel->r_index[0]);
4077 r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
4078 r_pcrel = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
4079 r_baserel = (0 != (rel->r_type[0]
4080 & RELOC_STD_BITS_BASEREL_LITTLE));
4081 r_jmptable= (0 != (rel->r_type[0]
4082 & RELOC_STD_BITS_JMPTABLE_LITTLE));
4083 r_relative= (0 != (rel->r_type[0]
4084 & RELOC_STD_BITS_RELATIVE_LITTLE));
4085 r_length = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
4086 >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
4087 }
252b5132 4088
116c20d2
NC		 4089 howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel
4090 + 16 * r_jmptable + 32 * r_relative);
ad756e3f
AM		 4091 if (howto_idx < TABLE_SIZE (howto_table_std))
4092 howto = howto_table_std + howto_idx;
4093 else
4094 howto = NULL;
116c20d2
NC		 4095 }
4096#endif
252b5132 4097
ad756e3f
AM		 4098 if (howto == NULL)
4099 {
0aa13fee
AM		 4100 _bfd_error_handler (_("%pB: unsupported relocation type"),
4101 input_bfd);
ad756e3f
AM		 4102 bfd_set_error (bfd_error_bad_value);
4103 return FALSE;
4104 }
4105
116c20d2 4106 if (relocatable)
252b5132 4107 {
116c20d2
NC		 4108 /* We are generating a relocatable output file, and must
4109 modify the reloc accordingly. */
4110 if (r_extern)
252b5132 4111 {
116c20d2
NC		 4112 /* If we know the symbol this relocation is against,
4113 convert it into a relocation against a section. This
4114 is what the native linker does. */
4115 h = sym_hashes[r_index];
4116 if (h != NULL
4117 && (h->root.type == bfd_link_hash_defined
4118 || h->root.type == bfd_link_hash_defweak))
252b5132 4119 {
252b5132
RH		 4120 asection *output_section;
4121
116c20d2
NC		 4122 /* Change the r_extern value. */
4123 if (bfd_header_big_endian (output_bfd))
4124 rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_BIG;
4125 else
4126 rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_LITTLE;
252b5132 4127
116c20d2
NC		 4128 /* Compute a new r_index. */
4129 output_section = h->root.u.def.section->output_section;
252b5132 4130 if (output_section == obj_textsec (output_bfd))
116c20d2 4131 r_index = N_TEXT;
252b5132 4132 else if (output_section == obj_datasec (output_bfd))
116c20d2 4133 r_index = N_DATA;
252b5132 4134 else if (output_section == obj_bsssec (output_bfd))
116c20d2 4135 r_index = N_BSS;
252b5132 4136 else
116c20d2 4137 r_index = N_ABS;
252b5132 4138
116c20d2
NC		 4139 /* Add the symbol value and the section VMA to the
4140 addend stored in the contents. */
4141 relocation = (h->root.u.def.value
4142 + output_section->vma
4143 + h->root.u.def.section->output_offset);
252b5132 4144 }
116c20d2 4145 else
252b5132 4146 {
116c20d2
NC		 4147 /* We must change r_index according to the symbol
4148 map. */
4149 r_index = symbol_map[r_index];
252b5132 4150
116c20d2 4151 if (r_index == -1)
252b5132 4152 {
116c20d2 4153 if (h != NULL)
252b5132 4154 {
116c20d2 4155 /* We decided to strip this symbol, but it
07d6d2b8
AM		 4156 turns out that we can't. Note that we
4157 lose the other and desc information here.
4158 I don't think that will ever matter for a
4159 global symbol. */
116c20d2 4160 if (h->indx < 0)
252b5132 4161 {
116c20d2
NC		 4162 h->indx = -2;
4163 h->written = FALSE;
7686d77d 4164 if (!aout_link_write_other_symbol (&h->root.root,
57402f1e 4165 flaginfo))
116c20d2 4166 return FALSE;
252b5132 4167 }
116c20d2
NC		 4168 r_index = h->indx;
4169 }
4170 else
4171 {
4172 const char *name;
4173
4174 name = strings + GET_WORD (input_bfd,
4175 syms[r_index].e_strx);
1a72702b
AM		 4176 (*flaginfo->info->callbacks->unattached_reloc)
4177 (flaginfo->info, name,
4178 input_bfd, input_section, r_addr);
116c20d2 4179 r_index = 0;
252b5132
RH		 4180 }
4181 }
116c20d2
NC		 4182
4183 relocation = 0;
252b5132
RH		 4184 }
4185
116c20d2
NC		 4186 /* Write out the new r_index value. */
4187 if (bfd_header_big_endian (output_bfd))
252b5132 4188 {
116c20d2
NC		 4189 rel->r_index[0] = r_index >> 16;
4190 rel->r_index[1] = r_index >> 8;
4191 rel->r_index[2] = r_index;
252b5132
RH		 4192 }
4193 else
4194 {
116c20d2
NC		 4195 rel->r_index[2] = r_index >> 16;
4196 rel->r_index[1] = r_index >> 8;
4197 rel->r_index[0] = r_index;
252b5132
RH		 4198 }
4199 }
252b5132 4200 else
116c20d2
NC		 4201 {
4202 asection *section;
252b5132 4203
116c20d2
NC		 4204 /* This is a relocation against a section. We must
4205 adjust by the amount that the section moved. */
4206 section = aout_reloc_index_to_section (input_bfd, r_index);
4207 relocation = (section->output_section->vma
4208 + section->output_offset
4209 - section->vma);
4210 }
252b5132 4211
116c20d2
NC		 4212 /* Change the address of the relocation. */
4213 PUT_WORD (output_bfd,
4214 r_addr + input_section->output_offset,
4215 rel->r_address);
252b5132 4216
116c20d2
NC		 4217 /* Adjust a PC relative relocation by removing the reference
4218 to the original address in the section and including the
4219 reference to the new address. */
4220 if (r_pcrel)
4221 relocation -= (input_section->output_section->vma
4222 + input_section->output_offset
4223 - input_section->vma);
e92d460e 4224
116c20d2
NC		 4225#ifdef MY_relocatable_reloc
4226 MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr);
4227#endif
252b5132 4228
116c20d2
NC		 4229 if (relocation == 0)
4230 r = bfd_reloc_ok;
4231 else
4232 r = MY_relocate_contents (howto,
4233 input_bfd, relocation,
4234 contents + r_addr);
252b5132 4235 }
116c20d2
NC		 4236 else
4237 {
4238 bfd_boolean hundef;
252b5132 4239
116c20d2
NC		 4240 /* We are generating an executable, and must do a full
4241 relocation. */
4242 hundef = FALSE;
252b5132 4243
116c20d2
NC		 4244 if (r_extern)
4245 {
4246 h = sym_hashes[r_index];
252b5132 4247
116c20d2
NC		 4248 if (h != NULL
4249 && (h->root.type == bfd_link_hash_defined
4250 || h->root.type == bfd_link_hash_defweak))
4251 {
4252 relocation = (h->root.u.def.value
4253 + h->root.u.def.section->output_section->vma
4254 + h->root.u.def.section->output_offset);
4255 }
4256 else if (h != NULL
4257 && h->root.type == bfd_link_hash_undefweak)
4258 relocation = 0;
4259 else
4260 {
4261 hundef = TRUE;
4262 relocation = 0;
4263 }
4264 }
4265 else
4266 {
4267 asection *section;
252b5132 4268
116c20d2
NC		 4269 section = aout_reloc_index_to_section (input_bfd, r_index);
4270 relocation = (section->output_section->vma
4271 + section->output_offset
4272 - section->vma);
4273 if (r_pcrel)
4274 relocation += input_section->vma;
4275 }
252b5132 4276
116c20d2
NC		 4277 if (check_dynamic_reloc != NULL)
4278 {
4279 bfd_boolean skip;
252b5132 4280
116c20d2 4281 if (! ((*check_dynamic_reloc)
57402f1e 4282 (flaginfo->info, input_bfd, input_section, h,
116c20d2
NC		 4283 (void *) rel, contents, &skip, &relocation)))
4284 return FALSE;
4285 if (skip)
4286 continue;
4287 }
252b5132 4288
116c20d2 4289 /* Now warn if a global symbol is undefined. We could not
07d6d2b8
AM		 4290 do this earlier, because check_dynamic_reloc might want
4291 to skip this reloc. */
0e1862bb 4292 if (hundef && ! bfd_link_pic (flaginfo->info) && ! r_baserel)
116c20d2
NC		 4293 {
4294 const char *name;
252b5132 4295
116c20d2
NC		 4296 if (h != NULL)
4297 name = h->root.root.string;
4298 else
4299 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
1a72702b
AM		 4300 (*flaginfo->info->callbacks->undefined_symbol)
4301 (flaginfo->info, name, input_bfd, input_section, r_addr, TRUE);
116c20d2 4302 }
252b5132 4303
116c20d2
NC		 4304 r = MY_final_link_relocate (howto,
4305 input_bfd, input_section,
4306 contents, r_addr, relocation,
4307 (bfd_vma) 0);
252b5132 4308 }
252b5132 4309
116c20d2
NC		 4310 if (r != bfd_reloc_ok)
4311 {
4312 switch (r)
4313 {
4314 default:
4315 case bfd_reloc_outofrange:
4316 abort ();
4317 case bfd_reloc_overflow:
4318 {
4319 const char *name;
252b5132 4320
116c20d2
NC		 4321 if (h != NULL)
4322 name = NULL;
4323 else if (r_extern)
4324 name = strings + GET_WORD (input_bfd,
4325 syms[r_index].e_strx);
4326 else
4327 {
4328 asection *s;
252b5132 4329
116c20d2
NC		 4330 s = aout_reloc_index_to_section (input_bfd, r_index);
4331 name = bfd_section_name (input_bfd, s);
4332 }
1a72702b
AM		 4333 (*flaginfo->info->callbacks->reloc_overflow)
4334 (flaginfo->info, (h ? &h->root : NULL), name, howto->name,
4335 (bfd_vma) 0, input_bfd, input_section, r_addr);
116c20d2
NC		 4336 }
4337 break;
4338 }
4339 }
252b5132
RH		 4340 }
4341
b34976b6 4342 return TRUE;
252b5132
RH		 4343}
4344
116c20d2 4345/* Relocate an a.out section using extended a.out relocs. */
252b5132 4346
b34976b6 4347static bfd_boolean
57402f1e 4348aout_link_input_section_ext (struct aout_final_link_info *flaginfo,
116c20d2
NC		 4349 bfd *input_bfd,
4350 asection *input_section,
4351 struct reloc_ext_external *relocs,
4352 bfd_size_type rel_size,
4353 bfd_byte *contents)
252b5132 4354{
b34976b6 4355 bfd_boolean (*check_dynamic_reloc)
116c20d2
NC		 4356 (struct bfd_link_info *, bfd *, asection *,
4357 struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
4358 bfd_vma *);
252b5132 4359 bfd *output_bfd;
1049f94e 4360 bfd_boolean relocatable;
252b5132
RH		 4361 struct external_nlist *syms;
4362 char *strings;
4363 struct aout_link_hash_entry **sym_hashes;
4364 int *symbol_map;
4365 bfd_size_type reloc_count;
116c20d2
NC		 4366 struct reloc_ext_external *rel;
4367 struct reloc_ext_external *rel_end;
252b5132 4368
57402f1e 4369 output_bfd = flaginfo->output_bfd;
252b5132
RH		 4370 check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
4371
116c20d2 4372 BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_EXT_SIZE);
252b5132
RH		 4373 BFD_ASSERT (input_bfd->xvec->header_byteorder
4374 == output_bfd->xvec->header_byteorder);
4375
0e1862bb 4376 relocatable = bfd_link_relocatable (flaginfo->info);
252b5132
RH		 4377 syms = obj_aout_external_syms (input_bfd);
4378 strings = obj_aout_external_strings (input_bfd);
4379 sym_hashes = obj_aout_sym_hashes (input_bfd);
57402f1e 4380 symbol_map = flaginfo->symbol_map;
252b5132 4381
116c20d2 4382 reloc_count = rel_size / RELOC_EXT_SIZE;
252b5132
RH		 4383 rel = relocs;
4384 rel_end = rel + reloc_count;
4385 for (; rel < rel_end; rel++)
4386 {
4387 bfd_vma r_addr;
4388 int r_index;
4389 int r_extern;
116c20d2
NC		 4390 unsigned int r_type;
4391 bfd_vma r_addend;
252b5132 4392 struct aout_link_hash_entry *h = NULL;
116c20d2 4393 asection *r_section = NULL;
252b5132 4394 bfd_vma relocation;
252b5132
RH		 4395
4396 r_addr = GET_SWORD (input_bfd, rel->r_address);
4397
116c20d2
NC		 4398 if (bfd_header_big_endian (input_bfd))
4399 {
4400 r_index = (((unsigned int) rel->r_index[0] << 16)
4401 | ((unsigned int) rel->r_index[1] << 8)
4402 | rel->r_index[2]);
4403 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
4404 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
4405 >> RELOC_EXT_BITS_TYPE_SH_BIG);
4406 }
4407 else
4408 {
4409 r_index = (((unsigned int) rel->r_index[2] << 16)
4410 | ((unsigned int) rel->r_index[1] << 8)
4411 | rel->r_index[0]);
4412 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
4413 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
4414 >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
4415 }
252b5132 4416
116c20d2 4417 r_addend = GET_SWORD (input_bfd, rel->r_addend);
252b5132 4418
ad756e3f
AM		 4419 if (r_type >= TABLE_SIZE (howto_table_ext))
4420 {
0aa13fee
AM		 4421 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
4422 input_bfd, r_type);
ad756e3f
AM		 4423 bfd_set_error (bfd_error_bad_value);
4424 return FALSE;
4425 }
252b5132 4426
1049f94e 4427 if (relocatable)
252b5132 4428 {
1049f94e 4429 /* We are generating a relocatable output file, and must
252b5132 4430 modify the reloc accordingly. */
116c20d2
NC		 4431 if (r_extern
4432 || r_type == (unsigned int) RELOC_BASE10
4433 || r_type == (unsigned int) RELOC_BASE13
4434 || r_type == (unsigned int) RELOC_BASE22)
252b5132
RH		 4435 {
4436 /* If we know the symbol this relocation is against,
4437 convert it into a relocation against a section. This
4438 is what the native linker does. */
116c20d2
NC		 4439 if (r_type == (unsigned int) RELOC_BASE10
4440 || r_type == (unsigned int) RELOC_BASE13
4441 || r_type == (unsigned int) RELOC_BASE22)
4442 h = NULL;
4443 else
4444 h = sym_hashes[r_index];
4445 if (h != NULL
252b5132
RH		 4446 && (h->root.type == bfd_link_hash_defined
4447 || h->root.type == bfd_link_hash_defweak))
4448 {
4449 asection *output_section;
4450
4451 /* Change the r_extern value. */
4452 if (bfd_header_big_endian (output_bfd))
116c20d2 4453 rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_BIG;
252b5132 4454 else
116c20d2 4455 rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_LITTLE;
252b5132
RH		 4456
4457 /* Compute a new r_index. */
4458 output_section = h->root.u.def.section->output_section;
4459 if (output_section == obj_textsec (output_bfd))
4460 r_index = N_TEXT;
4461 else if (output_section == obj_datasec (output_bfd))
4462 r_index = N_DATA;
4463 else if (output_section == obj_bsssec (output_bfd))
4464 r_index = N_BSS;
4465 else
4466 r_index = N_ABS;
4467
4468 /* Add the symbol value and the section VMA to the
116c20d2 4469 addend. */
252b5132
RH		 4470 relocation = (h->root.u.def.value
4471 + output_section->vma
4472 + h->root.u.def.section->output_offset);
116c20d2
NC		 4473
4474 /* Now RELOCATION is the VMA of the final
4475 destination. If this is a PC relative reloc,
4476 then ADDEND is the negative of the source VMA.
4477 We want to set ADDEND to the difference between
4478 the destination VMA and the source VMA, which
4479 means we must adjust RELOCATION by the change in
4480 the source VMA. This is done below. */
252b5132
RH		 4481 }
4482 else
4483 {
4484 /* We must change r_index according to the symbol
4485 map. */
4486 r_index = symbol_map[r_index];
4487
4488 if (r_index == -1)
4489 {
4490 if (h != NULL)
4491 {
4492 /* We decided to strip this symbol, but it
07d6d2b8
AM		 4493 turns out that we can't. Note that we
4494 lose the other and desc information here.
4495 I don't think that will ever matter for a
4496 global symbol. */
252b5132
RH		 4497 if (h->indx < 0)
4498 {
4499 h->indx = -2;
b34976b6 4500 h->written = FALSE;
7686d77d 4501 if (!aout_link_write_other_symbol (&h->root.root,
57402f1e 4502 flaginfo))
b34976b6 4503 return FALSE;
252b5132
RH		 4504 }
4505 r_index = h->indx;
4506 }
4507 else
4508 {
4509 const char *name;
4510
4511 name = strings + GET_WORD (input_bfd,
4512 syms[r_index].e_strx);
1a72702b
AM		 4513 (*flaginfo->info->callbacks->unattached_reloc)
4514 (flaginfo->info, name,
4515 input_bfd, input_section, r_addr);
252b5132
RH		 4516 r_index = 0;
4517 }
4518 }
4519
4520 relocation = 0;
116c20d2
NC		 4521
4522 /* If this is a PC relative reloc, then the addend
4523 is the negative of the source VMA. We must
4524 adjust it by the change in the source VMA. This
4525 is done below. */
252b5132
RH		 4526 }
4527
4528 /* Write out the new r_index value. */
4529 if (bfd_header_big_endian (output_bfd))
4530 {
4531 rel->r_index[0] = r_index >> 16;
4532 rel->r_index[1] = r_index >> 8;
4533 rel->r_index[2] = r_index;
4534 }
4535 else
4536 {
4537 rel->r_index[2] = r_index >> 16;
4538 rel->r_index[1] = r_index >> 8;
4539 rel->r_index[0] = r_index;
4540 }
4541 }
4542 else
4543 {
252b5132
RH		 4544 /* This is a relocation against a section. We must
4545 adjust by the amount that the section moved. */
116c20d2
NC		 4546 r_section = aout_reloc_index_to_section (input_bfd, r_index);
4547 relocation = (r_section->output_section->vma
4548 + r_section->output_offset
4549 - r_section->vma);
252b5132 4550
116c20d2
NC		 4551 /* If this is a PC relative reloc, then the addend is
4552 the difference in VMA between the destination and the
4553 source. We have just adjusted for the change in VMA
4554 of the destination, so we must also adjust by the
4555 change in VMA of the source. This is done below. */
4556 }
252b5132 4557
116c20d2
NC		 4558 /* As described above, we must always adjust a PC relative
4559 reloc by the change in VMA of the source. However, if
4560 pcrel_offset is set, then the addend does not include the
4561 location within the section, in which case we don't need
4562 to adjust anything. */
4563 if (howto_table_ext[r_type].pc_relative
4564 && ! howto_table_ext[r_type].pcrel_offset)
252b5132
RH		 4565 relocation -= (input_section->output_section->vma
4566 + input_section->output_offset
4567 - input_section->vma);
4568
116c20d2
NC		 4569 /* Change the addend if necessary. */
4570 if (relocation != 0)
4571 PUT_WORD (output_bfd, r_addend + relocation, rel->r_addend);
252b5132 4572
116c20d2
NC		 4573 /* Change the address of the relocation. */
4574 PUT_WORD (output_bfd,
4575 r_addr + input_section->output_offset,
4576 rel->r_address);
252b5132
RH		 4577 }
4578 else
4579 {
b34976b6 4580 bfd_boolean hundef;
116c20d2 4581 bfd_reloc_status_type r;
252b5132
RH		 4582
4583 /* We are generating an executable, and must do a full
4584 relocation. */
b34976b6 4585 hundef = FALSE;
252b5132
RH		 4586
4587 if (r_extern)
4588 {
4589 h = sym_hashes[r_index];
4590
116c20d2 4591 if (h != NULL
252b5132
RH		 4592 && (h->root.type == bfd_link_hash_defined
4593 || h->root.type == bfd_link_hash_defweak))
4594 {
4595 relocation = (h->root.u.def.value
4596 + h->root.u.def.section->output_section->vma
4597 + h->root.u.def.section->output_offset);
4598 }
116c20d2 4599 else if (h != NULL
252b5132
RH		 4600 && h->root.type == bfd_link_hash_undefweak)
4601 relocation = 0;
4602 else
4603 {
b34976b6 4604 hundef = TRUE;
252b5132
RH		 4605 relocation = 0;
4606 }
4607 }
116c20d2
NC		 4608 else if (r_type == (unsigned int) RELOC_BASE10
4609 || r_type == (unsigned int) RELOC_BASE13
4610 || r_type == (unsigned int) RELOC_BASE22)
4611 {
4612 struct external_nlist *sym;
4613 int type;
4614
4615 /* For base relative relocs, r_index is always an index
07d6d2b8 4616 into the symbol table, even if r_extern is 0. */
116c20d2
NC		 4617 sym = syms + r_index;
4618 type = H_GET_8 (input_bfd, sym->e_type);
4619 if ((type & N_TYPE) == N_TEXT
4620 || type == N_WEAKT)
4621 r_section = obj_textsec (input_bfd);
4622 else if ((type & N_TYPE) == N_DATA
4623 || type == N_WEAKD)
4624 r_section = obj_datasec (input_bfd);
4625 else if ((type & N_TYPE) == N_BSS
4626 || type == N_WEAKB)
4627 r_section = obj_bsssec (input_bfd);
4628 else if ((type & N_TYPE) == N_ABS
4629 || type == N_WEAKA)
4630 r_section = bfd_abs_section_ptr;
4631 else
4632 abort ();
4633 relocation = (r_section->output_section->vma
4634 + r_section->output_offset
4635 + (GET_WORD (input_bfd, sym->e_value)
4636 - r_section->vma));
4637 }
252b5132
RH		 4638 else
4639 {
116c20d2 4640 r_section = aout_reloc_index_to_section (input_bfd, r_index);
252b5132 4641
116c20d2
NC		 4642 /* If this is a PC relative reloc, then R_ADDEND is the
4643 difference between the two vmas, or
4644 old_dest_sec + old_dest_off - (old_src_sec + old_src_off)
4645 where
4646 old_dest_sec == section->vma
4647 and
4648 old_src_sec == input_section->vma
4649 and
4650 old_src_off == r_addr
4651
4652 _bfd_final_link_relocate expects RELOCATION +
4653 R_ADDEND to be the VMA of the destination minus
4654 r_addr (the minus r_addr is because this relocation
4655 is not pcrel_offset, which is a bit confusing and
4656 should, perhaps, be changed), or
4657 new_dest_sec
4658 where
4659 new_dest_sec == output_section->vma + output_offset
4660 We arrange for this to happen by setting RELOCATION to
4661 new_dest_sec + old_src_sec - old_dest_sec
4662
4663 If this is not a PC relative reloc, then R_ADDEND is
4664 simply the VMA of the destination, so we set
4665 RELOCATION to the change in the destination VMA, or
4666 new_dest_sec - old_dest_sec
4667 */
4668 relocation = (r_section->output_section->vma
4669 + r_section->output_offset
4670 - r_section->vma);
4671 if (howto_table_ext[r_type].pc_relative)
252b5132
RH		 4672 relocation += input_section->vma;
4673 }
4674
4675 if (check_dynamic_reloc != NULL)
4676 {
b34976b6 4677 bfd_boolean skip;
252b5132
RH		 4678
4679 if (! ((*check_dynamic_reloc)
57402f1e 4680 (flaginfo->info, input_bfd, input_section, h,
116c20d2 4681 (void *) rel, contents, &skip, &relocation)))
b34976b6 4682 return FALSE;
252b5132
RH		 4683 if (skip)
4684 continue;
4685 }
4686
4687 /* Now warn if a global symbol is undefined. We could not
07d6d2b8
AM		 4688 do this earlier, because check_dynamic_reloc might want
4689 to skip this reloc. */
116c20d2 4690 if (hundef
0e1862bb 4691 && ! bfd_link_pic (flaginfo->info)
116c20d2
NC		 4692 && r_type != (unsigned int) RELOC_BASE10
4693 && r_type != (unsigned int) RELOC_BASE13
4694 && r_type != (unsigned int) RELOC_BASE22)
252b5132
RH		 4695 {
4696 const char *name;
4697
4698 if (h != NULL)
4699 name = h->root.root.string;
4700 else
4701 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
1a72702b
AM		 4702 (*flaginfo->info->callbacks->undefined_symbol)
4703 (flaginfo->info, name, input_bfd, input_section, r_addr, TRUE);
252b5132
RH		 4704 }
4705
116c20d2
NC		 4706 if (r_type != (unsigned int) RELOC_SPARC_REV32)
4707 r = MY_final_link_relocate (howto_table_ext + r_type,
4708 input_bfd, input_section,
4709 contents, r_addr, relocation,
4710 r_addend);
4711 else
252b5132 4712 {
116c20d2 4713 bfd_vma x;
252b5132 4714
116c20d2
NC		 4715 x = bfd_get_32 (input_bfd, contents + r_addr);
4716 x = x + relocation + r_addend;
4717 bfd_putl32 (/*input_bfd,*/ x, contents + r_addr);
4718 r = bfd_reloc_ok;
4719 }
4720
4721 if (r != bfd_reloc_ok)
4722 {
4723 switch (r)
4724 {
4725 default:
4726 case bfd_reloc_outofrange:
4727 abort ();
4728 case bfd_reloc_overflow:
252b5132 4729 {
116c20d2 4730 const char *name;
252b5132 4731
116c20d2
NC		 4732 if (h != NULL)
4733 name = NULL;
4734 else if (r_extern
4735 || r_type == (unsigned int) RELOC_BASE10
4736 || r_type == (unsigned int) RELOC_BASE13
4737 || r_type == (unsigned int) RELOC_BASE22)
4738 name = strings + GET_WORD (input_bfd,
4739 syms[r_index].e_strx);
4740 else
4741 {
4742 asection *s;
4743
4744 s = aout_reloc_index_to_section (input_bfd, r_index);
4745 name = bfd_section_name (input_bfd, s);
4746 }
1a72702b
AM		 4747 (*flaginfo->info->callbacks->reloc_overflow)
4748 (flaginfo->info, (h ? &h->root : NULL), name,
4749 howto_table_ext[r_type].name,
4750 r_addend, input_bfd, input_section, r_addr);
252b5132 4751 }
116c20d2
NC		 4752 break;
4753 }
252b5132
RH		 4754 }
4755 }
4756 }
4757
b34976b6 4758 return TRUE;
252b5132
RH		 4759}
4760
116c20d2
NC		 4761/* Link an a.out section into the output file. */
4762
4763static bfd_boolean
57402f1e 4764aout_link_input_section (struct aout_final_link_info *flaginfo,
116c20d2
NC		 4765 bfd *input_bfd,
4766 asection *input_section,
4767 file_ptr *reloff_ptr,
4768 bfd_size_type rel_size)
4769{
4770 bfd_size_type input_size;
4771 void * relocs;
4772
4773 /* Get the section contents. */
4774 input_size = input_section->size;
4775 if (! bfd_get_section_contents (input_bfd, input_section,
57402f1e 4776 (void *) flaginfo->contents,
116c20d2
NC		 4777 (file_ptr) 0, input_size))
4778 return FALSE;
4779
4780 /* Read in the relocs if we haven't already done it. */
4781 if (aout_section_data (input_section) != NULL
4782 && aout_section_data (input_section)->relocs != NULL)
4783 relocs = aout_section_data (input_section)->relocs;
4784 else
4785 {
57402f1e 4786 relocs = flaginfo->relocs;
116c20d2
NC		 4787 if (rel_size > 0)
4788 {
4789 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4790 || bfd_bread (relocs, rel_size, input_bfd) != rel_size)
4791 return FALSE;
4792 }
4793 }
4794
4795 /* Relocate the section contents. */
4796 if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
4797 {
57402f1e 4798 if (! aout_link_input_section_std (flaginfo, input_bfd, input_section,
116c20d2 4799 (struct reloc_std_external *) relocs,
57402f1e 4800 rel_size, flaginfo->contents))
116c20d2
NC		 4801 return FALSE;
4802 }
4803 else
4804 {
57402f1e 4805 if (! aout_link_input_section_ext (flaginfo, input_bfd, input_section,
116c20d2 4806 (struct reloc_ext_external *) relocs,
57402f1e 4807 rel_size, flaginfo->contents))
116c20d2
NC		 4808 return FALSE;
4809 }
4810
4811 /* Write out the section contents. */
57402f1e 4812 if (! bfd_set_section_contents (flaginfo->output_bfd,
116c20d2 4813 input_section->output_section,
57402f1e 4814 (void *) flaginfo->contents,
116c20d2
NC		 4815 (file_ptr) input_section->output_offset,
4816 input_size))
4817 return FALSE;
4818
4819 /* If we are producing relocatable output, the relocs were
4820 modified, and we now write them out. */
0e1862bb 4821 if (bfd_link_relocatable (flaginfo->info) && rel_size > 0)
116c20d2 4822 {
57402f1e 4823 if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
116c20d2 4824 return FALSE;
57402f1e 4825 if (bfd_bwrite (relocs, rel_size, flaginfo->output_bfd) != rel_size)
116c20d2
NC		 4826 return FALSE;
4827 *reloff_ptr += rel_size;
4828
4829 /* Assert that the relocs have not run into the symbols, and
4830 that if these are the text relocs they have not run into the
4831 data relocs. */
57402f1e
NC		 4832 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd)
4833 && (reloff_ptr != &flaginfo->treloff
116c20d2 4834 || (*reloff_ptr
57402f1e 4835 <= obj_datasec (flaginfo->output_bfd)->rel_filepos)));
116c20d2
NC		 4836 }
4837
4838 return TRUE;
4839}
4840
4841/* Adjust and write out the symbols for an a.out file. Set the new
4842 symbol indices into a symbol_map. */
252b5132 4843
b34976b6 4844static bfd_boolean
57402f1e 4845aout_link_write_symbols (struct aout_final_link_info *flaginfo, bfd *input_bfd)
252b5132 4846{
252b5132 4847 bfd *output_bfd;
116c20d2 4848 bfd_size_type sym_count;
252b5132 4849 char *strings;
116c20d2
NC		 4850 enum bfd_link_strip strip;
4851 enum bfd_link_discard discard;
4852 struct external_nlist *outsym;
4853 bfd_size_type strtab_index;
4854 struct external_nlist *sym;
4855 struct external_nlist *sym_end;
4856 struct aout_link_hash_entry **sym_hash;
252b5132 4857 int *symbol_map;
116c20d2
NC		 4858 bfd_boolean pass;
4859 bfd_boolean skip_next;
252b5132 4860
57402f1e 4861 output_bfd = flaginfo->output_bfd;
116c20d2
NC		 4862 sym_count = obj_aout_external_sym_count (input_bfd);
4863 strings = obj_aout_external_strings (input_bfd);
57402f1e
NC		 4864 strip = flaginfo->info->strip;
4865 discard = flaginfo->info->discard;
4866 outsym = flaginfo->output_syms;
252b5132 4867
116c20d2
NC		 4868 /* First write out a symbol for this object file, unless we are
4869 discarding such symbols. */
4870 if (strip != strip_all
4871 && (strip != strip_some
57402f1e 4872 || bfd_hash_lookup (flaginfo->info->keep_hash, input_bfd->filename,
116c20d2
NC		 4873 FALSE, FALSE) != NULL)
4874 && discard != discard_all)
4875 {
4876 H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
4877 H_PUT_8 (output_bfd, 0, outsym->e_other);
4878 H_PUT_16 (output_bfd, 0, outsym->e_desc);
57402f1e 4879 strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
116c20d2
NC		 4880 input_bfd->filename, FALSE);
4881 if (strtab_index == (bfd_size_type) -1)
4882 return FALSE;
4883 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4884 PUT_WORD (output_bfd,
4885 (bfd_get_section_vma (output_bfd,
4886 obj_textsec (input_bfd)->output_section)
4887 + obj_textsec (input_bfd)->output_offset),
4888 outsym->e_value);
4889 ++obj_aout_external_sym_count (output_bfd);
4890 ++outsym;
4891 }
252b5132 4892
116c20d2
NC		 4893 pass = FALSE;
4894 skip_next = FALSE;
4895 sym = obj_aout_external_syms (input_bfd);
4896 sym_end = sym + sym_count;
4897 sym_hash = obj_aout_sym_hashes (input_bfd);
57402f1e 4898 symbol_map = flaginfo->symbol_map;
116c20d2
NC		 4899 memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
4900 for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
252b5132 4901 {
116c20d2
NC		 4902 const char *name;
4903 int type;
4904 struct aout_link_hash_entry *h;
4905 bfd_boolean skip;
4906 asection *symsec;
4907 bfd_vma val = 0;
4908 bfd_boolean copy;
252b5132 4909
116c20d2 4910 /* We set *symbol_map to 0 above for all symbols. If it has
07d6d2b8
AM		 4911 already been set to -1 for this symbol, it means that we are
4912 discarding it because it appears in a duplicate header file.
4913 See the N_BINCL code below. */
116c20d2
NC		 4914 if (*symbol_map == -1)
4915 continue;
252b5132 4916
116c20d2 4917 /* Initialize *symbol_map to -1, which means that the symbol was
07d6d2b8
AM		 4918 not copied into the output file. We will change it later if
4919 we do copy the symbol over. */
116c20d2
NC		 4920 *symbol_map = -1;
4921
4922 type = H_GET_8 (input_bfd, sym->e_type);
4923 name = strings + GET_WORD (input_bfd, sym->e_strx);
4924
4925 h = NULL;
4926
4927 if (pass)
252b5132 4928 {
116c20d2
NC		 4929 /* Pass this symbol through. It is the target of an
4930 indirect or warning symbol. */
4931 val = GET_WORD (input_bfd, sym->e_value);
4932 pass = FALSE;
252b5132 4933 }
116c20d2 4934 else if (skip_next)
252b5132 4935 {
116c20d2
NC		 4936 /* Skip this symbol, which is the target of an indirect
4937 symbol that we have changed to no longer be an indirect
4938 symbol. */
4939 skip_next = FALSE;
4940 continue;
252b5132 4941 }
116c20d2
NC		 4942 else
4943 {
4944 struct aout_link_hash_entry *hresolve;
252b5132 4945
116c20d2
NC		 4946 /* We have saved the hash table entry for this symbol, if
4947 there is one. Note that we could just look it up again
4948 in the hash table, provided we first check that it is an
4949 external symbol. */
4950 h = *sym_hash;
252b5132 4951
116c20d2 4952 /* Use the name from the hash table, in case the symbol was
07d6d2b8 4953 wrapped. */
116c20d2
NC		 4954 if (h != NULL
4955 && h->root.type != bfd_link_hash_warning)
4956 name = h->root.root.string;
252b5132 4957
116c20d2
NC		 4958 /* If this is an indirect or warning symbol, then change
4959 hresolve to the base symbol. We also change *sym_hash so
4960 that the relocation routines relocate against the real
4961 symbol. */
4962 hresolve = h;
4963 if (h != (struct aout_link_hash_entry *) NULL
4964 && (h->root.type == bfd_link_hash_indirect
4965 || h->root.type == bfd_link_hash_warning))
252b5132 4966 {
116c20d2
NC		 4967 hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
4968 while (hresolve->root.type == bfd_link_hash_indirect
4969 || hresolve->root.type == bfd_link_hash_warning)
4970 hresolve = ((struct aout_link_hash_entry *)
4971 hresolve->root.u.i.link);
4972 *sym_hash = hresolve;
4973 }
4974
4975 /* If the symbol has already been written out, skip it. */
4976 if (h != NULL
4977 && h->written)
4978 {
4979 if ((type & N_TYPE) == N_INDR
4980 || type == N_WARNING)
4981 skip_next = TRUE;
4982 *symbol_map = h->indx;
4983 continue;
4984 }
4985
4986 /* See if we are stripping this symbol. */
4987 skip = FALSE;
4988 switch (strip)
4989 {
4990 case strip_none:
4991 break;
4992 case strip_debugger:
4993 if ((type & N_STAB) != 0)
4994 skip = TRUE;
4995 break;
4996 case strip_some:
57402f1e 4997 if (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE, FALSE)
116c20d2
NC		 4998 == NULL)
4999 skip = TRUE;
5000 break;
5001 case strip_all:
5002 skip = TRUE;
5003 break;
5004 }
5005 if (skip)
5006 {
5007 if (h != NULL)
5008 h->written = TRUE;
5009 continue;
5010 }
5011
5012 /* Get the value of the symbol. */
5013 if ((type & N_TYPE) == N_TEXT
5014 || type == N_WEAKT)
5015 symsec = obj_textsec (input_bfd);
5016 else if ((type & N_TYPE) == N_DATA
5017 || type == N_WEAKD)
5018 symsec = obj_datasec (input_bfd);
5019 else if ((type & N_TYPE) == N_BSS
5020 || type == N_WEAKB)
5021 symsec = obj_bsssec (input_bfd);
5022 else if ((type & N_TYPE) == N_ABS
5023 || type == N_WEAKA)
5024 symsec = bfd_abs_section_ptr;
5025 else if (((type & N_TYPE) == N_INDR
5026 && (hresolve == NULL
5027 || (hresolve->root.type != bfd_link_hash_defined
5028 && hresolve->root.type != bfd_link_hash_defweak
5029 && hresolve->root.type != bfd_link_hash_common)))
5030 || type == N_WARNING)
5031 {
5032 /* Pass the next symbol through unchanged. The
5033 condition above for indirect symbols is so that if
5034 the indirect symbol was defined, we output it with
5035 the correct definition so the debugger will
5036 understand it. */
5037 pass = TRUE;
5038 val = GET_WORD (input_bfd, sym->e_value);
5039 symsec = NULL;
5040 }
5041 else if ((type & N_STAB) != 0)
5042 {
5043 val = GET_WORD (input_bfd, sym->e_value);
5044 symsec = NULL;
5045 }
5046 else
5047 {
5048 /* If we get here with an indirect symbol, it means that
5049 we are outputting it with a real definition. In such
5050 a case we do not want to output the next symbol,
5051 which is the target of the indirection. */
5052 if ((type & N_TYPE) == N_INDR)
5053 skip_next = TRUE;
5054
5055 symsec = NULL;
5056
5057 /* We need to get the value from the hash table. We use
5058 hresolve so that if we have defined an indirect
5059 symbol we output the final definition. */
5060 if (h == NULL)
5061 {
5062 switch (type & N_TYPE)
5063 {
5064 case N_SETT:
5065 symsec = obj_textsec (input_bfd);
5066 break;
5067 case N_SETD:
5068 symsec = obj_datasec (input_bfd);
5069 break;
5070 case N_SETB:
5071 symsec = obj_bsssec (input_bfd);
5072 break;
5073 case N_SETA:
5074 symsec = bfd_abs_section_ptr;
5075 break;
5076 default:
5077 val = 0;
5078 break;
5079 }
5080 }
5081 else if (hresolve->root.type == bfd_link_hash_defined
5082 || hresolve->root.type == bfd_link_hash_defweak)
252b5132 5083 {
116c20d2 5084 asection *input_section;
252b5132
RH		 5085 asection *output_section;
5086
116c20d2
NC		 5087 /* This case usually means a common symbol which was
5088 turned into a defined symbol. */
5089 input_section = hresolve->root.u.def.section;
5090 output_section = input_section->output_section;
5091 BFD_ASSERT (bfd_is_abs_section (output_section)
5092 || output_section->owner == output_bfd);
5093 val = (hresolve->root.u.def.value
5094 + bfd_get_section_vma (output_bfd, output_section)
5095 + input_section->output_offset);
5096
5097 /* Get the correct type based on the section. If
5098 this is a constructed set, force it to be
5099 globally visible. */
5100 if (type == N_SETT
5101 || type == N_SETD
5102 || type == N_SETB
5103 || type == N_SETA)
5104 type |= N_EXT;
5105
5106 type &=~ N_TYPE;
252b5132 5107
252b5132 5108 if (output_section == obj_textsec (output_bfd))
116c20d2
NC		 5109 type |= (hresolve->root.type == bfd_link_hash_defined
5110 ? N_TEXT
5111 : N_WEAKT);
252b5132 5112 else if (output_section == obj_datasec (output_bfd))
116c20d2
NC		 5113 type |= (hresolve->root.type == bfd_link_hash_defined
5114 ? N_DATA
5115 : N_WEAKD);
252b5132 5116 else if (output_section == obj_bsssec (output_bfd))
116c20d2
NC		 5117 type |= (hresolve->root.type == bfd_link_hash_defined
5118 ? N_BSS
5119 : N_WEAKB);
252b5132 5120 else
116c20d2
NC		 5121 type |= (hresolve->root.type == bfd_link_hash_defined
5122 ? N_ABS
5123 : N_WEAKA);
5124 }
5125 else if (hresolve->root.type == bfd_link_hash_common)
5126 val = hresolve->root.u.c.size;
5127 else if (hresolve->root.type == bfd_link_hash_undefweak)
5128 {
5129 val = 0;
5130 type = N_WEAKU;
252b5132
RH		 5131 }
5132 else
116c20d2
NC		 5133 val = 0;
5134 }
5135 if (symsec != NULL)
5136 val = (symsec->output_section->vma
5137 + symsec->output_offset
5138 + (GET_WORD (input_bfd, sym->e_value)
5139 - symsec->vma));
5140
5141 /* If this is a global symbol set the written flag, and if
5142 it is a local symbol see if we should discard it. */
5143 if (h != NULL)
5144 {
5145 h->written = TRUE;
5146 h->indx = obj_aout_external_sym_count (output_bfd);
5147 }
5148 else if ((type & N_TYPE) != N_SETT
5149 && (type & N_TYPE) != N_SETD
5150 && (type & N_TYPE) != N_SETB
5151 && (type & N_TYPE) != N_SETA)
5152 {
5153 switch (discard)
252b5132 5154 {
116c20d2
NC		 5155 case discard_none:
5156 case discard_sec_merge:
5157 break;
5158 case discard_l:
5159 if ((type & N_STAB) == 0
5160 && bfd_is_local_label_name (input_bfd, name))
5161 skip = TRUE;
5162 break;
5163 case discard_all:
5164 skip = TRUE;
5165 break;
5166 }
5167 if (skip)
5168 {
5169 pass = FALSE;
5170 continue;
5171 }
5172 }
252b5132 5173
116c20d2
NC		 5174 /* An N_BINCL symbol indicates the start of the stabs
5175 entries for a header file. We need to scan ahead to the
5176 next N_EINCL symbol, ignoring nesting, adding up all the
5177 characters in the symbol names, not including the file
5178 numbers in types (the first number after an open
5179 parenthesis). */
5180 if (type == (int) N_BINCL)
5181 {
5182 struct external_nlist *incl_sym;
5183 int nest;
5184 struct aout_link_includes_entry *incl_entry;
5185 struct aout_link_includes_totals *t;
5186
5187 val = 0;
5188 nest = 0;
5189 for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++)
5190 {
5191 int incl_type;
5192
5193 incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
5194 if (incl_type == (int) N_EINCL)
252b5132 5195 {
116c20d2
NC		 5196 if (nest == 0)
5197 break;
5198 --nest;
5199 }
5200 else if (incl_type == (int) N_BINCL)
5201 ++nest;
5202 else if (nest == 0)
5203 {
5204 const char *s;
5205
5206 s = strings + GET_WORD (input_bfd, incl_sym->e_strx);
5207 for (; *s != '\0'; s++)
252b5132 5208 {
116c20d2
NC		 5209 val += *s;
5210 if (*s == '(')
252b5132 5211 {
116c20d2
NC		 5212 /* Skip the file number. */
5213 ++s;
5214 while (ISDIGIT (*s))
5215 ++s;
5216 --s;
252b5132 5217 }
252b5132 5218 }
116c20d2
NC		 5219 }
5220 }
252b5132 5221
116c20d2 5222 /* If we have already included a header file with the
07d6d2b8
AM		 5223 same value, then replace this one with an N_EXCL
5224 symbol. */
57402f1e
NC		 5225 copy = (bfd_boolean) (! flaginfo->info->keep_memory);
5226 incl_entry = aout_link_includes_lookup (&flaginfo->includes,
116c20d2
NC		 5227 name, TRUE, copy);
5228 if (incl_entry == NULL)
5229 return FALSE;
5230 for (t = incl_entry->totals; t != NULL; t = t->next)
5231 if (t->total == val)
5232 break;
5233 if (t == NULL)
5234 {
5235 /* This is the first time we have seen this header
07d6d2b8 5236 file with this set of stabs strings. */
a50b1753 5237 t = (struct aout_link_includes_totals *)
07d6d2b8 5238 bfd_hash_allocate (&flaginfo->includes.root,
116c20d2
NC		 5239 sizeof *t);
5240 if (t == NULL)
5241 return FALSE;
5242 t->total = val;
5243 t->next = incl_entry->totals;
5244 incl_entry->totals = t;
5245 }
5246 else
5247 {
5248 int *incl_map;
5249
5250 /* This is a duplicate header file. We must change
07d6d2b8
AM		 5251 it to be an N_EXCL entry, and mark all the
5252 included symbols to prevent outputting them. */
116c20d2
NC		 5253 type = (int) N_EXCL;
5254
5255 nest = 0;
5256 for (incl_sym = sym + 1, incl_map = symbol_map + 1;
5257 incl_sym < sym_end;
5258 incl_sym++, incl_map++)
5259 {
5260 int incl_type;
5261
5262 incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
5263 if (incl_type == (int) N_EINCL)
5264 {
5265 if (nest == 0)
5266 {
5267 *incl_map = -1;
5268 break;
5269 }
5270 --nest;
252b5132 5271 }
116c20d2
NC		 5272 else if (incl_type == (int) N_BINCL)
5273 ++nest;
5274 else if (nest == 0)
5275 *incl_map = -1;
252b5132 5276 }
252b5132
RH		 5277 }
5278 }
116c20d2
NC		 5279 }
5280
5281 /* Copy this symbol into the list of symbols we are going to
5282 write out. */
5283 H_PUT_8 (output_bfd, type, outsym->e_type);
5284 H_PUT_8 (output_bfd, H_GET_8 (input_bfd, sym->e_other), outsym->e_other);
5285 H_PUT_16 (output_bfd, H_GET_16 (input_bfd, sym->e_desc), outsym->e_desc);
5286 copy = FALSE;
57402f1e 5287 if (! flaginfo->info->keep_memory)
116c20d2
NC		 5288 {
5289 /* name points into a string table which we are going to
5290 free. If there is a hash table entry, use that string.
5291 Otherwise, copy name into memory. */
5292 if (h != NULL)
5293 name = h->root.root.string;
252b5132 5294 else
116c20d2
NC		 5295 copy = TRUE;
5296 }
57402f1e 5297 strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
116c20d2
NC		 5298 name, copy);
5299 if (strtab_index == (bfd_size_type) -1)
5300 return FALSE;
5301 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
5302 PUT_WORD (output_bfd, val, outsym->e_value);
5303 *symbol_map = obj_aout_external_sym_count (output_bfd);
5304 ++obj_aout_external_sym_count (output_bfd);
5305 ++outsym;
5306 }
252b5132 5307
116c20d2 5308 /* Write out the output symbols we have just constructed. */
57402f1e 5309 if (outsym > flaginfo->output_syms)
116c20d2
NC		 5310 {
5311 bfd_size_type outsym_size;
252b5132 5312
57402f1e 5313 if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0)
116c20d2 5314 return FALSE;
57402f1e 5315 outsym_size = outsym - flaginfo->output_syms;
116c20d2 5316 outsym_size *= EXTERNAL_NLIST_SIZE;
57402f1e 5317 if (bfd_bwrite ((void *) flaginfo->output_syms, outsym_size, output_bfd)
116c20d2
NC		 5318 != outsym_size)
5319 return FALSE;
57402f1e 5320 flaginfo->symoff += outsym_size;
116c20d2 5321 }
252b5132 5322
116c20d2
NC		 5323 return TRUE;
5324}
252b5132 5325
116c20d2 5326/* Link an a.out input BFD into the output file. */
252b5132 5327
116c20d2 5328static bfd_boolean
57402f1e 5329aout_link_input_bfd (struct aout_final_link_info *flaginfo, bfd *input_bfd)
116c20d2 5330{
116c20d2 5331 BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
252b5132 5332
116c20d2
NC		 5333 /* If this is a dynamic object, it may need special handling. */
5334 if ((input_bfd->flags & DYNAMIC) != 0
5335 && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
5336 return ((*aout_backend_info (input_bfd)->link_dynamic_object)
57402f1e 5337 (flaginfo->info, input_bfd));
252b5132 5338
116c20d2 5339 /* Get the symbols. We probably have them already, unless
57402f1e 5340 flaginfo->info->keep_memory is FALSE. */
116c20d2
NC		 5341 if (! aout_get_external_symbols (input_bfd))
5342 return FALSE;
252b5132 5343
116c20d2 5344 /* Write out the symbols and get a map of the new indices. The map
57402f1e
NC		 5345 is placed into flaginfo->symbol_map. */
5346 if (! aout_link_write_symbols (flaginfo, input_bfd))
116c20d2 5347 return FALSE;
252b5132 5348
116c20d2
NC		 5349 /* Relocate and write out the sections. These functions use the
5350 symbol map created by aout_link_write_symbols. The linker_mark
5351 field will be set if these sections are to be included in the
5352 link, which will normally be the case. */
5353 if (obj_textsec (input_bfd)->linker_mark)
5354 {
57402f1e 5355 if (! aout_link_input_section (flaginfo, input_bfd,
116c20d2 5356 obj_textsec (input_bfd),
57402f1e 5357 &flaginfo->treloff,
116c20d2
NC		 5358 exec_hdr (input_bfd)->a_trsize))
5359 return FALSE;
5360 }
5361 if (obj_datasec (input_bfd)->linker_mark)
5362 {
57402f1e 5363 if (! aout_link_input_section (flaginfo, input_bfd,
116c20d2 5364 obj_datasec (input_bfd),
57402f1e 5365 &flaginfo->dreloff,
116c20d2
NC		 5366 exec_hdr (input_bfd)->a_drsize))
5367 return FALSE;
5368 }
5369
5370 /* If we are not keeping memory, we don't need the symbols any
5371 longer. We still need them if we are keeping memory, because the
5372 strings in the hash table point into them. */
57402f1e 5373 if (! flaginfo->info->keep_memory)
116c20d2
NC		 5374 {
5375 if (! aout_link_free_symbols (input_bfd))
5376 return FALSE;
5377 }
5378
5379 return TRUE;
5380}
5381
5382/* Do the final link step. This is called on the output BFD. The
5383 INFO structure should point to a list of BFDs linked through the
c72f2fb2 5384 link.next field which can be used to find each BFD which takes part
116c20d2
NC		 5385 in the output. Also, each section in ABFD should point to a list
5386 of bfd_link_order structures which list all the input sections for
5387 the output section. */
5388
5389bfd_boolean
5390NAME (aout, final_link) (bfd *abfd,
5391 struct bfd_link_info *info,
5392 void (*callback) (bfd *, file_ptr *, file_ptr *, file_ptr *))
5393{
5394 struct aout_final_link_info aout_info;
5395 bfd_boolean includes_hash_initialized = FALSE;
5396 bfd *sub;
5397 bfd_size_type trsize, drsize;
5398 bfd_size_type max_contents_size;
5399 bfd_size_type max_relocs_size;
5400 bfd_size_type max_sym_count;
116c20d2
NC		 5401 struct bfd_link_order *p;
5402 asection *o;
5403 bfd_boolean have_link_order_relocs;
5404
0e1862bb 5405 if (bfd_link_pic (info))
116c20d2
NC		 5406 abfd->flags |= DYNAMIC;
5407
5408 aout_info.info = info;
5409 aout_info.output_bfd = abfd;
5410 aout_info.contents = NULL;
5411 aout_info.relocs = NULL;
5412 aout_info.symbol_map = NULL;
5413 aout_info.output_syms = NULL;
252b5132 5414
66eb6687
AM		 5415 if (!bfd_hash_table_init_n (&aout_info.includes.root,
5416 aout_link_includes_newfunc,
5417 sizeof (struct aout_link_includes_entry),
5418 251))
116c20d2
NC		 5419 goto error_return;
5420 includes_hash_initialized = TRUE;
252b5132 5421
116c20d2
NC		 5422 /* Figure out the largest section size. Also, if generating
5423 relocatable output, count the relocs. */
5424 trsize = 0;
5425 drsize = 0;
5426 max_contents_size = 0;
5427 max_relocs_size = 0;
5428 max_sym_count = 0;
c72f2fb2 5429 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
116c20d2
NC		 5430 {
5431 bfd_size_type sz;
252b5132 5432
0e1862bb 5433 if (bfd_link_relocatable (info))
116c20d2
NC		 5434 {
5435 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
252b5132 5436 {
116c20d2
NC		 5437 trsize += exec_hdr (sub)->a_trsize;
5438 drsize += exec_hdr (sub)->a_drsize;
252b5132 5439 }
252b5132
RH		 5440 else
5441 {
116c20d2
NC		 5442 /* FIXME: We need to identify the .text and .data sections
5443 and call get_reloc_upper_bound and canonicalize_reloc to
5444 work out the number of relocs needed, and then multiply
5445 by the reloc size. */
4eca0228 5446 _bfd_error_handler
695344c0 5447 /* xgettext:c-format */
871b3ab2 5448 (_("%pB: relocatable link from %s to %s not supported"),
dae82561 5449 abfd, sub->xvec->name, abfd->xvec->name);
116c20d2
NC		 5450 bfd_set_error (bfd_error_invalid_operation);
5451 goto error_return;
252b5132 5452 }
116c20d2 5453 }
252b5132 5454
116c20d2
NC		 5455 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
5456 {
5457 sz = obj_textsec (sub)->size;
5458 if (sz > max_contents_size)
5459 max_contents_size = sz;
5460 sz = obj_datasec (sub)->size;
5461 if (sz > max_contents_size)
5462 max_contents_size = sz;
252b5132 5463
116c20d2
NC		 5464 sz = exec_hdr (sub)->a_trsize;
5465 if (sz > max_relocs_size)
5466 max_relocs_size = sz;
5467 sz = exec_hdr (sub)->a_drsize;
5468 if (sz > max_relocs_size)
5469 max_relocs_size = sz;
252b5132 5470
116c20d2
NC		 5471 sz = obj_aout_external_sym_count (sub);
5472 if (sz > max_sym_count)
5473 max_sym_count = sz;
252b5132
RH		 5474 }
5475 }
5476
0e1862bb 5477 if (bfd_link_relocatable (info))
116c20d2
NC		 5478 {
5479 if (obj_textsec (abfd) != NULL)
5480 trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
8423293d 5481 ->map_head.link_order)
116c20d2
NC		 5482 * obj_reloc_entry_size (abfd));
5483 if (obj_datasec (abfd) != NULL)
5484 drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
8423293d 5485 ->map_head.link_order)
116c20d2
NC		 5486 * obj_reloc_entry_size (abfd));
5487 }
252b5132 5488
116c20d2
NC		 5489 exec_hdr (abfd)->a_trsize = trsize;
5490 exec_hdr (abfd)->a_drsize = drsize;
252b5132 5491
116c20d2 5492 exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
252b5132 5493
116c20d2
NC		 5494 /* Adjust the section sizes and vmas according to the magic number.
5495 This sets a_text, a_data and a_bss in the exec_hdr and sets the
5496 filepos for each section. */
3a8c4a5b 5497 if (! NAME (aout, adjust_sizes_and_vmas) (abfd))
116c20d2 5498 goto error_return;
252b5132 5499
116c20d2
NC		 5500 /* The relocation and symbol file positions differ among a.out
5501 targets. We are passed a callback routine from the backend
5502 specific code to handle this.
5503 FIXME: At this point we do not know how much space the symbol
5504 table will require. This will not work for any (nonstandard)
5505 a.out target that needs to know the symbol table size before it
5506 can compute the relocation file positions. This may or may not
5507 be the case for the hp300hpux target, for example. */
5508 (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
5509 &aout_info.symoff);
5510 obj_textsec (abfd)->rel_filepos = aout_info.treloff;
5511 obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
5512 obj_sym_filepos (abfd) = aout_info.symoff;
252b5132 5513
116c20d2
NC		 5514 /* We keep a count of the symbols as we output them. */
5515 obj_aout_external_sym_count (abfd) = 0;
5516
5517 /* We accumulate the string table as we write out the symbols. */
5518 aout_info.strtab = _bfd_stringtab_init ();
5519 if (aout_info.strtab == NULL)
5520 goto error_return;
5521
5522 /* Allocate buffers to hold section contents and relocs. */
a50b1753 5523 aout_info.contents = (bfd_byte *) bfd_malloc (max_contents_size);
116c20d2 5524 aout_info.relocs = bfd_malloc (max_relocs_size);
c38eb2a6 5525 aout_info.symbol_map = (int *) bfd_malloc (max_sym_count * sizeof (int));
a50b1753
NC		 5526 aout_info.output_syms = (struct external_nlist *)
5527 bfd_malloc ((max_sym_count + 1) * sizeof (struct external_nlist));
116c20d2
NC		 5528 if ((aout_info.contents == NULL && max_contents_size != 0)
5529 || (aout_info.relocs == NULL && max_relocs_size != 0)
5530 || (aout_info.symbol_map == NULL && max_sym_count != 0)
5531 || aout_info.output_syms == NULL)
5532 goto error_return;
5533
5534 /* If we have a symbol named __DYNAMIC, force it out now. This is
5535 required by SunOS. Doing this here rather than in sunos.c is a
5536 hack, but it's easier than exporting everything which would be
5537 needed. */
5538 {
5539 struct aout_link_hash_entry *h;
5540
5541 h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
5542 FALSE, FALSE, FALSE);
5543 if (h != NULL)
7686d77d 5544 aout_link_write_other_symbol (&h->root.root, &aout_info);
116c20d2
NC		 5545 }
5546
5547 /* The most time efficient way to do the link would be to read all
5548 the input object files into memory and then sort out the
5549 information into the output file. Unfortunately, that will
5550 probably use too much memory. Another method would be to step
5551 through everything that composes the text section and write it
5552 out, and then everything that composes the data section and write
5553 it out, and then write out the relocs, and then write out the
5554 symbols. Unfortunately, that requires reading stuff from each
5555 input file several times, and we will not be able to keep all the
5556 input files open simultaneously, and reopening them will be slow.
5557
5558 What we do is basically process one input file at a time. We do
5559 everything we need to do with an input file once--copy over the
5560 section contents, handle the relocation information, and write
5561 out the symbols--and then we throw away the information we read
5562 from it. This approach requires a lot of lseeks of the output
5563 file, which is unfortunate but still faster than reopening a lot
5564 of files.
5565
5566 We use the output_has_begun field of the input BFDs to see
5567 whether we have already handled it. */
c72f2fb2 5568 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
116c20d2 5569 sub->output_has_begun = FALSE;
252b5132 5570
116c20d2
NC		 5571 /* Mark all sections which are to be included in the link. This
5572 will normally be every section. We need to do this so that we
5573 can identify any sections which the linker has decided to not
5574 include. */
5575 for (o = abfd->sections; o != NULL; o = o->next)
252b5132 5576 {
8423293d 5577 for (p = o->map_head.link_order; p != NULL; p = p->next)
116c20d2
NC		 5578 if (p->type == bfd_indirect_link_order)
5579 p->u.indirect.section->linker_mark = TRUE;
252b5132
RH		 5580 }
5581
116c20d2
NC		 5582 have_link_order_relocs = FALSE;
5583 for (o = abfd->sections; o != NULL; o = o->next)
252b5132 5584 {
8423293d 5585 for (p = o->map_head.link_order;
116c20d2
NC		 5586 p != NULL;
5587 p = p->next)
252b5132 5588 {
116c20d2
NC		 5589 if (p->type == bfd_indirect_link_order
5590 && (bfd_get_flavour (p->u.indirect.section->owner)
5591 == bfd_target_aout_flavour))
252b5132 5592 {
116c20d2
NC		 5593 bfd *input_bfd;
5594
5595 input_bfd = p->u.indirect.section->owner;
5596 if (! input_bfd->output_has_begun)
252b5132 5597 {
116c20d2
NC		 5598 if (! aout_link_input_bfd (&aout_info, input_bfd))
5599 goto error_return;
5600 input_bfd->output_has_begun = TRUE;
252b5132 5601 }
252b5132 5602 }
116c20d2
NC		 5603 else if (p->type == bfd_section_reloc_link_order
5604 || p->type == bfd_symbol_reloc_link_order)
5605 {
5606 /* These are handled below. */
5607 have_link_order_relocs = TRUE;
5608 }
5609 else
5610 {
5611 if (! _bfd_default_link_order (abfd, info, o, p))
5612 goto error_return;
5613 }
252b5132
RH		 5614 }
5615 }
252b5132 5616
116c20d2 5617 /* Write out any symbols that we have not already written out. */
7686d77d
AM		 5618 bfd_hash_traverse (&info->hash->table,
5619 aout_link_write_other_symbol,
5620 &aout_info);
116c20d2
NC		 5621
5622 /* Now handle any relocs we were asked to create by the linker.
5623 These did not come from any input file. We must do these after
5624 we have written out all the symbols, so that we know the symbol
5625 indices to use. */
5626 if (have_link_order_relocs)
5627 {
5628 for (o = abfd->sections; o != NULL; o = o->next)
252b5132 5629 {
8423293d 5630 for (p = o->map_head.link_order;
116c20d2
NC		 5631 p != NULL;
5632 p = p->next)
5633 {
5634 if (p->type == bfd_section_reloc_link_order
5635 || p->type == bfd_symbol_reloc_link_order)
5636 {
5637 if (! aout_link_reloc_link_order (&aout_info, o, p))
5638 goto error_return;
5639 }
5640 }
252b5132 5641 }
116c20d2 5642 }
252b5132 5643
116c20d2
NC		 5644 if (aout_info.contents != NULL)
5645 {
5646 free (aout_info.contents);
5647 aout_info.contents = NULL;
5648 }
5649 if (aout_info.relocs != NULL)
5650 {
5651 free (aout_info.relocs);
5652 aout_info.relocs = NULL;
5653 }
5654 if (aout_info.symbol_map != NULL)
5655 {
5656 free (aout_info.symbol_map);
5657 aout_info.symbol_map = NULL;
5658 }
5659 if (aout_info.output_syms != NULL)
5660 {
5661 free (aout_info.output_syms);
5662 aout_info.output_syms = NULL;
5663 }
5664 if (includes_hash_initialized)
5665 {
5666 bfd_hash_table_free (&aout_info.includes.root);
5667 includes_hash_initialized = FALSE;
5668 }
252b5132 5669
116c20d2
NC		 5670 /* Finish up any dynamic linking we may be doing. */
5671 if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
5672 {
5673 if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
5674 goto error_return;
252b5132
RH		 5675 }
5676
116c20d2
NC		 5677 /* Update the header information. */
5678 abfd->symcount = obj_aout_external_sym_count (abfd);
5679 exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
5680 obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
5681 obj_textsec (abfd)->reloc_count =
5682 exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
5683 obj_datasec (abfd)->reloc_count =
5684 exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
252b5132 5685
116c20d2 5686 /* Write out the string table, unless there are no symbols. */
f6e688f7
AM		 5687 if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0)
5688 goto error_return;
116c20d2
NC		 5689 if (abfd->symcount > 0)
5690 {
f6e688f7 5691 if (!emit_stringtab (abfd, aout_info.strtab))
116c20d2
NC		 5692 goto error_return;
5693 }
f6e688f7 5694 else
116c20d2 5695 {
f6e688f7 5696 bfd_byte b[BYTES_IN_WORD];
252b5132 5697
f6e688f7
AM		 5698 memset (b, 0, BYTES_IN_WORD);
5699 if (bfd_bwrite (b, (bfd_size_type) BYTES_IN_WORD, abfd) != BYTES_IN_WORD)
116c20d2
NC		 5700 goto error_return;
5701 }
252b5132 5702
b34976b6 5703 return TRUE;
116c20d2
NC		 5704
5705 error_return:
5706 if (aout_info.contents != NULL)
5707 free (aout_info.contents);
5708 if (aout_info.relocs != NULL)
5709 free (aout_info.relocs);
5710 if (aout_info.symbol_map != NULL)
5711 free (aout_info.symbol_map);
5712 if (aout_info.output_syms != NULL)
5713 free (aout_info.output_syms);
5714 if (includes_hash_initialized)
5715 bfd_hash_table_free (&aout_info.includes.root);
5716 return FALSE;
252b5132 5717}
GDB Binutils - Deliverables
This page took 1.183632 seconds and 4 git commands to generate.