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