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