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