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