]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/aoutx.h
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Use std::string in ui_out_table
[thirdparty/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;
2669 *functionname_ptr = 0;
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 {
2814 sprintf (buf, "%s%s", directory_name, main_file_name);
2815 *filename_ptr = buf;
2816 buf += filelen + 1;
2817 }
2818 }
2819
2820 if (func)
2821 {
2822 const char *function = func->name;
dc810e39 2823 char *colon;
252b5132
RH		 2824
2825 /* The caller expects a symbol name. We actually have a
2826 function name, without the leading underscore. Put the
2827 underscore back in, so that the caller gets a symbol name. */
2828 if (bfd_get_symbol_leading_char (abfd) == '\0')
2829 strcpy (buf, function);
2830 else
2831 {
2832 buf[0] = bfd_get_symbol_leading_char (abfd);
2833 strcpy (buf + 1, function);
2834 }
f7c33884 2835 /* Have to remove : stuff. */
dc810e39
AM		 2836 colon = strchr (buf, ':');
2837 if (colon != NULL)
2838 *colon = '\0';
252b5132
RH		 2839 *functionname_ptr = buf;
2840 }
2841
b34976b6 2842 return TRUE;
252b5132
RH		 2843}
2844
252b5132 2845int
a6b96beb
AM		 2846NAME (aout, sizeof_headers) (bfd *abfd,
2847 struct bfd_link_info *info ATTRIBUTE_UNUSED)
252b5132 2848{
923f08ff 2849 return adata (abfd).exec_bytes_size;
252b5132
RH		 2850}
2851
2852/* Free all information we have cached for this BFD. We can always
2853 read it again later if we need it. */
2854
b34976b6 2855bfd_boolean
116c20d2 2856NAME (aout, bfd_free_cached_info) (bfd *abfd)
252b5132
RH		 2857{
2858 asection *o;
2859
920581c5
L		 2860 if (bfd_get_format (abfd) != bfd_object
2861 || abfd->tdata.aout_data == NULL)
b34976b6 2862 return TRUE;
252b5132
RH		 2863
2864#define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2865 BFCI_FREE (obj_aout_symbols (abfd));
2866#ifdef USE_MMAP
2867 obj_aout_external_syms (abfd) = 0;
2868 bfd_free_window (&obj_aout_sym_window (abfd));
2869 bfd_free_window (&obj_aout_string_window (abfd));
2870 obj_aout_external_strings (abfd) = 0;
2871#else
2872 BFCI_FREE (obj_aout_external_syms (abfd));
2873 BFCI_FREE (obj_aout_external_strings (abfd));
2874#endif
116c20d2 2875 for (o = abfd->sections; o != NULL; o = o->next)
252b5132
RH		 2876 BFCI_FREE (o->relocation);
2877#undef BFCI_FREE
2878
b34976b6 2879 return TRUE;
252b5132
RH		 2880}
2881\f
2882/* a.out link code. */
2883
252b5132
RH		 2884/* Routine to create an entry in an a.out link hash table. */
2885
2886struct bfd_hash_entry *
116c20d2
NC		 2887NAME (aout, link_hash_newfunc) (struct bfd_hash_entry *entry,
2888 struct bfd_hash_table *table,
2889 const char *string)
252b5132
RH		 2890{
2891 struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry;
2892
2893 /* Allocate the structure if it has not already been allocated by a
2894 subclass. */
116c20d2 2895 if (ret == NULL)
a50b1753
NC		 2896 ret = (struct aout_link_hash_entry *) bfd_hash_allocate (table,
2897 sizeof (* ret));
116c20d2
NC		 2898 if (ret == NULL)
2899 return NULL;
252b5132
RH		 2900
2901 /* Call the allocation method of the superclass. */
2902 ret = ((struct aout_link_hash_entry *)
2903 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2904 table, string));
2905 if (ret)
2906 {
2907 /* Set local fields. */
b34976b6 2908 ret->written = FALSE;
252b5132
RH		 2909 ret->indx = -1;
2910 }
2911
2912 return (struct bfd_hash_entry *) ret;
2913}
2914
2915/* Initialize an a.out link hash table. */
2916
b34976b6 2917bfd_boolean
116c20d2
NC		 2918NAME (aout, link_hash_table_init) (struct aout_link_hash_table *table,
2919 bfd *abfd,
2920 struct bfd_hash_entry *(*newfunc)
2921 (struct bfd_hash_entry *, struct bfd_hash_table *,
66eb6687
AM		 2922 const char *),
2923 unsigned int entsize)
252b5132 2924{
66eb6687 2925 return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
252b5132
RH		 2926}
2927
2928/* Create an a.out link hash table. */
2929
2930struct bfd_link_hash_table *
116c20d2 2931NAME (aout, link_hash_table_create) (bfd *abfd)
252b5132
RH		 2932{
2933 struct aout_link_hash_table *ret;
116c20d2 2934 bfd_size_type amt = sizeof (* ret);
252b5132 2935
a50b1753 2936 ret = (struct aout_link_hash_table *) bfd_malloc (amt);
252b5132 2937 if (ret == NULL)
116c20d2 2938 return NULL;
5ed6aba4 2939
66eb6687
AM		 2940 if (!NAME (aout, link_hash_table_init) (ret, abfd,
2941 NAME (aout, link_hash_newfunc),
2942 sizeof (struct aout_link_hash_entry)))
252b5132
RH		 2943 {
2944 free (ret);
116c20d2 2945 return NULL;
252b5132
RH		 2946 }
2947 return &ret->root;
2948}
2949
116c20d2 2950/* Add all symbols from an object file to the hash table. */
252b5132 2951
b34976b6 2952static bfd_boolean
116c20d2 2953aout_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
252b5132 2954{
116c20d2
NC		 2955 bfd_boolean (*add_one_symbol)
2956 (struct bfd_link_info *, bfd *, const char *, flagword, asection *,
2957 bfd_vma, const char *, bfd_boolean, bfd_boolean,
2958 struct bfd_link_hash_entry **);
2959 struct external_nlist *syms;
2960 bfd_size_type sym_count;
2961 char *strings;
2962 bfd_boolean copy;
2963 struct aout_link_hash_entry **sym_hash;
2964 struct external_nlist *p;
2965 struct external_nlist *pend;
2966 bfd_size_type amt;
252b5132 2967
116c20d2
NC		 2968 syms = obj_aout_external_syms (abfd);
2969 sym_count = obj_aout_external_sym_count (abfd);
2970 strings = obj_aout_external_strings (abfd);
2971 if (info->keep_memory)
2972 copy = FALSE;
2973 else
2974 copy = TRUE;
252b5132 2975
116c20d2 2976 if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
252b5132 2977 {
116c20d2
NC		 2978 if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
2979 (abfd, info, &syms, &sym_count, &strings)))
b34976b6 2980 return FALSE;
252b5132
RH		 2981 }
2982
20c6e70e
MS		 2983 if (sym_count == 0)
2984 return TRUE; /* Nothing to do. */
2985
116c20d2
NC		 2986 /* We keep a list of the linker hash table entries that correspond
2987 to particular symbols. We could just look them up in the hash
2988 table, but keeping the list is more efficient. Perhaps this
2989 should be conditional on info->keep_memory. */
2990 amt = sym_count * sizeof (struct aout_link_hash_entry *);
a50b1753 2991 sym_hash = (struct aout_link_hash_entry **) bfd_alloc (abfd, amt);
20c6e70e 2992 if (sym_hash == NULL)
116c20d2
NC		 2993 return FALSE;
2994 obj_aout_sym_hashes (abfd) = sym_hash;
252b5132 2995
116c20d2
NC		 2996 add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
2997 if (add_one_symbol == NULL)
2998 add_one_symbol = _bfd_generic_link_add_one_symbol;
252b5132 2999
116c20d2
NC		 3000 p = syms;
3001 pend = p + sym_count;
3002 for (; p < pend; p++, sym_hash++)
252b5132 3003 {
116c20d2 3004 int type;
252b5132 3005 const char *name;
116c20d2
NC		 3006 bfd_vma value;
3007 asection *section;
3008 flagword flags;
3009 const char *string;
252b5132 3010
116c20d2 3011 *sym_hash = NULL;
252b5132 3012
116c20d2 3013 type = H_GET_8 (abfd, p->e_type);
252b5132 3014
116c20d2
NC		 3015 /* Ignore debugging symbols. */
3016 if ((type & N_STAB) != 0)
3017 continue;
252b5132 3018
e517df3d
NC		 3019 /* PR 19629: Corrupt binaries can contain illegal string offsets. */
3020 if (GET_WORD (abfd, p->e_strx) > obj_aout_external_string_size (abfd))
3021 return FALSE;
116c20d2 3022 name = strings + GET_WORD (abfd, p->e_strx);
e517df3d 3023
116c20d2
NC		 3024 value = GET_WORD (abfd, p->e_value);
3025 flags = BSF_GLOBAL;
3026 string = NULL;
3027 switch (type)
252b5132 3028 {
116c20d2
NC		 3029 default:
3030 abort ();
f7c33884 3031
116c20d2
NC		 3032 case N_UNDF:
3033 case N_ABS:
3034 case N_TEXT:
3035 case N_DATA:
3036 case N_BSS:
3037 case N_FN_SEQ:
3038 case N_COMM:
3039 case N_SETV:
3040 case N_FN:
3041 /* Ignore symbols that are not externally visible. */
3042 continue;
3043 case N_INDR:
3044 /* Ignore local indirect symbol. */
3045 ++p;
3046 ++sym_hash;
3047 continue;
252b5132 3048
116c20d2
NC		 3049 case N_UNDF | N_EXT:
3050 if (value == 0)
f7c33884 3051 {
116c20d2
NC		 3052 section = bfd_und_section_ptr;
3053 flags = 0;
252b5132
RH		 3054 }
3055 else
3056 section = bfd_com_section_ptr;
3057 break;
3058 case N_ABS | N_EXT:
3059 section = bfd_abs_section_ptr;
3060 break;
3061 case N_TEXT | N_EXT:
3062 section = obj_textsec (abfd);
3063 value -= bfd_get_section_vma (abfd, section);
3064 break;
3065 case N_DATA | N_EXT:
3066 case N_SETV | N_EXT:
3067 /* Treat N_SETV symbols as N_DATA symbol; see comment in
3068 translate_from_native_sym_flags. */
3069 section = obj_datasec (abfd);
3070 value -= bfd_get_section_vma (abfd, section);
3071 break;
3072 case N_BSS | N_EXT:
3073 section = obj_bsssec (abfd);
3074 value -= bfd_get_section_vma (abfd, section);
3075 break;
3076 case N_INDR | N_EXT:
3077 /* An indirect symbol. The next symbol is the symbol
3078 which this one really is. */
3079 BFD_ASSERT (p + 1 < pend);
3080 ++p;
e517df3d
NC		 3081 /* PR 19629: Corrupt binaries can contain illegal string offsets. */
3082 if (GET_WORD (abfd, p->e_strx) > obj_aout_external_string_size (abfd))
3083 return FALSE;
252b5132
RH		 3084 string = strings + GET_WORD (abfd, p->e_strx);
3085 section = bfd_ind_section_ptr;
3086 flags |= BSF_INDIRECT;
3087 break;
3088 case N_COMM | N_EXT:
3089 section = bfd_com_section_ptr;
3090 break;
3091 case N_SETA: case N_SETA | N_EXT:
3092 section = bfd_abs_section_ptr;
3093 flags |= BSF_CONSTRUCTOR;
3094 break;
3095 case N_SETT: case N_SETT | N_EXT:
3096 section = obj_textsec (abfd);
3097 flags |= BSF_CONSTRUCTOR;
3098 value -= bfd_get_section_vma (abfd, section);
3099 break;
3100 case N_SETD: case N_SETD | N_EXT:
3101 section = obj_datasec (abfd);
3102 flags |= BSF_CONSTRUCTOR;
3103 value -= bfd_get_section_vma (abfd, section);
3104 break;
3105 case N_SETB: case N_SETB | N_EXT:
3106 section = obj_bsssec (abfd);
3107 flags |= BSF_CONSTRUCTOR;
3108 value -= bfd_get_section_vma (abfd, section);
3109 break;
3110 case N_WARNING:
3111 /* A warning symbol. The next symbol is the one to warn
9f400ee9
HPN		 3112 about. If there is no next symbol, just look away. */
3113 if (p + 1 >= pend)
3114 return TRUE;
252b5132
RH		 3115 ++p;
3116 string = name;
e517df3d
NC		 3117 /* PR 19629: Corrupt binaries can contain illegal string offsets. */
3118 if (GET_WORD (abfd, p->e_strx) > obj_aout_external_string_size (abfd))
3119 return FALSE;
252b5132
RH		 3120 name = strings + GET_WORD (abfd, p->e_strx);
3121 section = bfd_und_section_ptr;
3122 flags |= BSF_WARNING;
3123 break;
3124 case N_WEAKU:
3125 section = bfd_und_section_ptr;
3126 flags = BSF_WEAK;
3127 break;
3128 case N_WEAKA:
3129 section = bfd_abs_section_ptr;
3130 flags = BSF_WEAK;
3131 break;
3132 case N_WEAKT:
3133 section = obj_textsec (abfd);
3134 value -= bfd_get_section_vma (abfd, section);
3135 flags = BSF_WEAK;
3136 break;
3137 case N_WEAKD:
3138 section = obj_datasec (abfd);
3139 value -= bfd_get_section_vma (abfd, section);
3140 flags = BSF_WEAK;
3141 break;
3142 case N_WEAKB:
3143 section = obj_bsssec (abfd);
3144 value -= bfd_get_section_vma (abfd, section);
3145 flags = BSF_WEAK;
3146 break;
3147 }
3148
3149 if (! ((*add_one_symbol)
b34976b6 3150 (info, abfd, name, flags, section, value, string, copy, FALSE,
252b5132 3151 (struct bfd_link_hash_entry **) sym_hash)))
b34976b6 3152 return FALSE;
252b5132
RH		 3153
3154 /* Restrict the maximum alignment of a common symbol based on
3155 the architecture, since a.out has no way to represent
3156 alignment requirements of a section in a .o file. FIXME:
3157 This isn't quite right: it should use the architecture of the
3158 output file, not the input files. */
3159 if ((*sym_hash)->root.type == bfd_link_hash_common
3160 && ((*sym_hash)->root.u.c.p->alignment_power >
3161 bfd_get_arch_info (abfd)->section_align_power))
3162 (*sym_hash)->root.u.c.p->alignment_power =
3163 bfd_get_arch_info (abfd)->section_align_power;
3164
3165 /* If this is a set symbol, and we are not building sets, then
3166 it is possible for the hash entry to not have been set. In
3167 such a case, treat the symbol as not globally defined. */
3168 if ((*sym_hash)->root.type == bfd_link_hash_new)
3169 {
3170 BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
3171 *sym_hash = NULL;
3172 }
3173
3174 if (type == (N_INDR | N_EXT) || type == N_WARNING)
3175 ++sym_hash;
3176 }
3177
b34976b6 3178 return TRUE;
252b5132 3179}
252b5132 3180
116c20d2
NC		 3181/* Free up the internal symbols read from an a.out file. */
3182
3183static bfd_boolean
3184aout_link_free_symbols (bfd *abfd)
252b5132 3185{
116c20d2
NC		 3186 if (obj_aout_external_syms (abfd) != NULL)
3187 {
3188#ifdef USE_MMAP
3189 bfd_free_window (&obj_aout_sym_window (abfd));
3190#else
3191 free ((void *) obj_aout_external_syms (abfd));
3192#endif
3193 obj_aout_external_syms (abfd) = NULL;
3194 }
3195 if (obj_aout_external_strings (abfd) != NULL)
3196 {
3197#ifdef USE_MMAP
3198 bfd_free_window (&obj_aout_string_window (abfd));
3199#else
3200 free ((void *) obj_aout_external_strings (abfd));
3201#endif
3202 obj_aout_external_strings (abfd) = NULL;
3203 }
3204 return TRUE;
3205}
252b5132 3206
116c20d2 3207/* Add symbols from an a.out object file. */
252b5132 3208
116c20d2
NC		 3209static bfd_boolean
3210aout_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
252b5132 3211{
116c20d2
NC		 3212 if (! aout_get_external_symbols (abfd))
3213 return FALSE;
3214 if (! aout_link_add_symbols (abfd, info))
3215 return FALSE;
3216 if (! info->keep_memory)
3217 {
3218 if (! aout_link_free_symbols (abfd))
3219 return FALSE;
3220 }
3221 return TRUE;
3222}
252b5132 3223
116c20d2
NC		 3224/* Look through the internal symbols to see if this object file should
3225 be included in the link. We should include this object file if it
3226 defines any symbols which are currently undefined. If this object
3227 file defines a common symbol, then we may adjust the size of the
3228 known symbol but we do not include the object file in the link
3229 (unless there is some other reason to include it). */
252b5132 3230
116c20d2
NC		 3231static bfd_boolean
3232aout_link_check_ar_symbols (bfd *abfd,
3233 struct bfd_link_info *info,
5d3236ee
DK		 3234 bfd_boolean *pneeded,
3235 bfd **subsbfd)
252b5132 3236{
116c20d2
NC		 3237 struct external_nlist *p;
3238 struct external_nlist *pend;
3239 char *strings;
252b5132 3240
116c20d2 3241 *pneeded = FALSE;
252b5132 3242
116c20d2
NC		 3243 /* Look through all the symbols. */
3244 p = obj_aout_external_syms (abfd);
3245 pend = p + obj_aout_external_sym_count (abfd);
3246 strings = obj_aout_external_strings (abfd);
3247 for (; p < pend; p++)
3248 {
3249 int type = H_GET_8 (abfd, p->e_type);
3250 const char *name;
3251 struct bfd_link_hash_entry *h;
252b5132 3252
116c20d2
NC		 3253 /* Ignore symbols that are not externally visible. This is an
3254 optimization only, as we check the type more thoroughly
3255 below. */
3256 if (((type & N_EXT) == 0
3257 || (type & N_STAB) != 0
3258 || type == N_FN)
3259 && type != N_WEAKA
3260 && type != N_WEAKT
3261 && type != N_WEAKD
3262 && type != N_WEAKB)
3263 {
3264 if (type == N_WARNING
3265 || type == N_INDR)
3266 ++p;
3267 continue;
3268 }
3269
3270 name = strings + GET_WORD (abfd, p->e_strx);
3271 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
3272
3273 /* We are only interested in symbols that are currently
3274 undefined or common. */
3275 if (h == NULL
3276 || (h->type != bfd_link_hash_undefined
3277 && h->type != bfd_link_hash_common))
3278 {
3279 if (type == (N_INDR | N_EXT))
3280 ++p;
3281 continue;
3282 }
3283
3284 if (type == (N_TEXT | N_EXT)
3285 || type == (N_DATA | N_EXT)
3286 || type == (N_BSS | N_EXT)
3287 || type == (N_ABS | N_EXT)
3288 || type == (N_INDR | N_EXT))
3289 {
3290 /* This object file defines this symbol. We must link it
3291 in. This is true regardless of whether the current
3292 definition of the symbol is undefined or common.
3293
3294 If the current definition is common, we have a case in
3295 which we have already seen an object file including:
3296 int a;
3297 and this object file from the archive includes:
3298 int a = 5;
3299 In such a case, whether to include this object is target
3300 dependant for backward compatibility.
3301
3302 FIXME: The SunOS 4.1.3 linker will pull in the archive
3303 element if the symbol is defined in the .data section,
3304 but not if it is defined in the .text section. That
3305 seems a bit crazy to me, and it has not been implemented
3306 yet. However, it might be correct. */
3307 if (h->type == bfd_link_hash_common)
3308 {
3309 int skip = 0;
3310
f88dc410 3311 switch (info->common_skip_ar_symbols)
116c20d2
NC		 3312 {
3313 case bfd_link_common_skip_text:
3314 skip = (type == (N_TEXT | N_EXT));
3315 break;
3316 case bfd_link_common_skip_data:
3317 skip = (type == (N_DATA | N_EXT));
3318 break;
3319 default:
3320 case bfd_link_common_skip_all:
3321 skip = 1;
3322 break;
3323 }
3324
3325 if (skip)
3326 continue;
3327 }
3328
0e144ba7
AM		 3329 if (!(*info->callbacks
3330 ->add_archive_element) (info, abfd, name, subsbfd))
116c20d2
NC		 3331 return FALSE;
3332 *pneeded = TRUE;
3333 return TRUE;
3334 }
3335
3336 if (type == (N_UNDF | N_EXT))
3337 {
3338 bfd_vma value;
3339
3340 value = GET_WORD (abfd, p->e_value);
3341 if (value != 0)
3342 {
3343 /* This symbol is common in the object from the archive
3344 file. */
3345 if (h->type == bfd_link_hash_undefined)
3346 {
3347 bfd *symbfd;
3348 unsigned int power;
3349
3350 symbfd = h->u.undef.abfd;
3351 if (symbfd == NULL)
3352 {
3353 /* This symbol was created as undefined from
3354 outside BFD. We assume that we should link
3355 in the object file. This is done for the -u
3356 option in the linker. */
0e144ba7
AM		 3357 if (!(*info->callbacks
3358 ->add_archive_element) (info, abfd, name, subsbfd))
116c20d2
NC		 3359 return FALSE;
3360 *pneeded = TRUE;
3361 return TRUE;
3362 }
3363 /* Turn the current link symbol into a common
3364 symbol. It is already on the undefs list. */
3365 h->type = bfd_link_hash_common;
a50b1753 3366 h->u.c.p = (struct bfd_link_hash_common_entry *)
0e144ba7
AM		 3367 bfd_hash_allocate (&info->hash->table,
3368 sizeof (struct bfd_link_hash_common_entry));
116c20d2
NC		 3369 if (h->u.c.p == NULL)
3370 return FALSE;
3371
3372 h->u.c.size = value;
3373
3374 /* FIXME: This isn't quite right. The maximum
3375 alignment of a common symbol should be set by the
3376 architecture of the output file, not of the input
3377 file. */
3378 power = bfd_log2 (value);
3379 if (power > bfd_get_arch_info (abfd)->section_align_power)
3380 power = bfd_get_arch_info (abfd)->section_align_power;
3381 h->u.c.p->alignment_power = power;
3382
3383 h->u.c.p->section = bfd_make_section_old_way (symbfd,
3384 "COMMON");
3385 }
3386 else
3387 {
3388 /* Adjust the size of the common symbol if
3389 necessary. */
3390 if (value > h->u.c.size)
3391 h->u.c.size = value;
3392 }
3393 }
3394 }
3395
3396 if (type == N_WEAKA
3397 || type == N_WEAKT
3398 || type == N_WEAKD
3399 || type == N_WEAKB)
3400 {
3401 /* This symbol is weak but defined. We must pull it in if
3402 the current link symbol is undefined, but we don't want
3403 it if the current link symbol is common. */
3404 if (h->type == bfd_link_hash_undefined)
3405 {
0e144ba7
AM		 3406 if (!(*info->callbacks
3407 ->add_archive_element) (info, abfd, name, subsbfd))
116c20d2
NC		 3408 return FALSE;
3409 *pneeded = TRUE;
3410 return TRUE;
3411 }
3412 }
3413 }
3414
3415 /* We do not need this object file. */
3416 return TRUE;
3417}
3418/* Check a single archive element to see if we need to include it in
3419 the link. *PNEEDED is set according to whether this element is
3420 needed in the link or not. This is called from
3421 _bfd_generic_link_add_archive_symbols. */
3422
3423static bfd_boolean
3424aout_link_check_archive_element (bfd *abfd,
3425 struct bfd_link_info *info,
13e570f8
AM		 3426 struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED,
3427 const char *name ATTRIBUTE_UNUSED,
116c20d2
NC		 3428 bfd_boolean *pneeded)
3429{
0e144ba7
AM		 3430 bfd *oldbfd;
3431 bfd_boolean needed;
5d3236ee 3432
0e144ba7 3433 if (!aout_get_external_symbols (abfd))
116c20d2
NC		 3434 return FALSE;
3435
0e144ba7
AM		 3436 oldbfd = abfd;
3437 if (!aout_link_check_ar_symbols (abfd, info, pneeded, &abfd))
116c20d2
NC		 3438 return FALSE;
3439
0e144ba7
AM		 3440 needed = *pneeded;
3441 if (needed)
116c20d2 3442 {
5d3236ee
DK		 3443 /* Potentially, the add_archive_element hook may have set a
3444 substitute BFD for us. */
0e144ba7
AM		 3445 if (abfd != oldbfd)
3446 {
3447 if (!info->keep_memory
3448 && !aout_link_free_symbols (oldbfd))
3449 return FALSE;
3450 if (!aout_get_external_symbols (abfd))
3451 return FALSE;
3452 }
3453 if (!aout_link_add_symbols (abfd, info))
116c20d2
NC		 3454 return FALSE;
3455 }
3456
0e144ba7 3457 if (!info->keep_memory || !needed)
116c20d2 3458 {
0e144ba7 3459 if (!aout_link_free_symbols (abfd))
116c20d2
NC		 3460 return FALSE;
3461 }
3462
3463 return TRUE;
3464}
3465
3466/* Given an a.out BFD, add symbols to the global hash table as
3467 appropriate. */
3468
3469bfd_boolean
3470NAME (aout, link_add_symbols) (bfd *abfd, struct bfd_link_info *info)
3471{
3472 switch (bfd_get_format (abfd))
3473 {
3474 case bfd_object:
3475 return aout_link_add_object_symbols (abfd, info);
3476 case bfd_archive:
3477 return _bfd_generic_link_add_archive_symbols
3478 (abfd, info, aout_link_check_archive_element);
3479 default:
3480 bfd_set_error (bfd_error_wrong_format);
3481 return FALSE;
3482 }
3483}
3484\f
3485/* A hash table used for header files with N_BINCL entries. */
3486
3487struct aout_link_includes_table
3488{
3489 struct bfd_hash_table root;
3490};
3491
3492/* A linked list of totals that we have found for a particular header
3493 file. */
3494
3495struct aout_link_includes_totals
3496{
3497 struct aout_link_includes_totals *next;
3498 bfd_vma total;
3499};
3500
3501/* An entry in the header file hash table. */
3502
3503struct aout_link_includes_entry
3504{
3505 struct bfd_hash_entry root;
3506 /* List of totals we have found for this file. */
3507 struct aout_link_includes_totals *totals;
3508};
3509
3510/* Look up an entry in an the header file hash table. */
3511
3512#define aout_link_includes_lookup(table, string, create, copy) \
3513 ((struct aout_link_includes_entry *) \
3514 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3515
3516/* During the final link step we need to pass around a bunch of
3517 information, so we do it in an instance of this structure. */
3518
3519struct aout_final_link_info
3520{
3521 /* General link information. */
3522 struct bfd_link_info *info;
3523 /* Output bfd. */
252b5132
RH		 3524 bfd *output_bfd;
3525 /* Reloc file positions. */
3526 file_ptr treloff, dreloff;
3527 /* File position of symbols. */
3528 file_ptr symoff;
3529 /* String table. */
3530 struct bfd_strtab_hash *strtab;
3531 /* Header file hash table. */
3532 struct aout_link_includes_table includes;
3533 /* A buffer large enough to hold the contents of any section. */
3534 bfd_byte *contents;
3535 /* A buffer large enough to hold the relocs of any section. */
116c20d2 3536 void * relocs;
252b5132
RH		 3537 /* A buffer large enough to hold the symbol map of any input BFD. */
3538 int *symbol_map;
3539 /* A buffer large enough to hold output symbols of any input BFD. */
3540 struct external_nlist *output_syms;
3541};
3542
252b5132
RH		 3543/* The function to create a new entry in the header file hash table. */
3544
3545static struct bfd_hash_entry *
116c20d2
NC		 3546aout_link_includes_newfunc (struct bfd_hash_entry *entry,
3547 struct bfd_hash_table *table,
3548 const char *string)
252b5132
RH		 3549{
3550 struct aout_link_includes_entry *ret =
3551 (struct aout_link_includes_entry *) entry;
3552
3553 /* Allocate the structure if it has not already been allocated by a
3554 subclass. */
116c20d2 3555 if (ret == NULL)
a50b1753
NC		 3556 ret = (struct aout_link_includes_entry *)
3557 bfd_hash_allocate (table, sizeof (* ret));
116c20d2
NC		 3558 if (ret == NULL)
3559 return NULL;
252b5132
RH		 3560
3561 /* Call the allocation method of the superclass. */
3562 ret = ((struct aout_link_includes_entry *)
3563 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
3564 if (ret)
3565 {
3566 /* Set local fields. */
3567 ret->totals = NULL;
3568 }
3569
3570 return (struct bfd_hash_entry *) ret;
3571}
3572
116c20d2
NC		 3573/* Write out a symbol that was not associated with an a.out input
3574 object. */
252b5132 3575
116c20d2 3576static bfd_boolean
7686d77d 3577aout_link_write_other_symbol (struct bfd_hash_entry *bh, void *data)
252b5132 3578{
7686d77d 3579 struct aout_link_hash_entry *h = (struct aout_link_hash_entry *) bh;
57402f1e 3580 struct aout_final_link_info *flaginfo = (struct aout_final_link_info *) data;
116c20d2
NC		 3581 bfd *output_bfd;
3582 int type;
3583 bfd_vma val;
3584 struct external_nlist outsym;
3585 bfd_size_type indx;
3586 bfd_size_type amt;
252b5132 3587
116c20d2
NC		 3588 if (h->root.type == bfd_link_hash_warning)
3589 {
3590 h = (struct aout_link_hash_entry *) h->root.u.i.link;
3591 if (h->root.type == bfd_link_hash_new)
3592 return TRUE;
3593 }
252b5132 3594
57402f1e 3595 output_bfd = flaginfo->output_bfd;
252b5132 3596
116c20d2 3597 if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
252b5132 3598 {
116c20d2 3599 if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
57402f1e 3600 (output_bfd, flaginfo->info, h)))
252b5132 3601 {
116c20d2
NC		 3602 /* FIXME: No way to handle errors. */
3603 abort ();
252b5132 3604 }
116c20d2 3605 }
252b5132 3606
116c20d2
NC		 3607 if (h->written)
3608 return TRUE;
252b5132 3609
116c20d2 3610 h->written = TRUE;
252b5132 3611
116c20d2
NC		 3612 /* An indx of -2 means the symbol must be written. */
3613 if (h->indx != -2
57402f1e
NC		 3614 && (flaginfo->info->strip == strip_all
3615 || (flaginfo->info->strip == strip_some
3616 && bfd_hash_lookup (flaginfo->info->keep_hash, h->root.root.string,
116c20d2
NC		 3617 FALSE, FALSE) == NULL)))
3618 return TRUE;
252b5132 3619
116c20d2 3620 switch (h->root.type)
252b5132 3621 {
116c20d2
NC		 3622 default:
3623 case bfd_link_hash_warning:
3624 abort ();
3625 /* Avoid variable not initialized warnings. */
3626 return TRUE;
3627 case bfd_link_hash_new:
3628 /* This can happen for set symbols when sets are not being
3629 built. */
3630 return TRUE;
3631 case bfd_link_hash_undefined:
3632 type = N_UNDF | N_EXT;
3633 val = 0;
3634 break;
3635 case bfd_link_hash_defined:
3636 case bfd_link_hash_defweak:
3637 {
3638 asection *sec;
252b5132 3639
116c20d2
NC		 3640 sec = h->root.u.def.section->output_section;
3641 BFD_ASSERT (bfd_is_abs_section (sec)
3642 || sec->owner == output_bfd);
3643 if (sec == obj_textsec (output_bfd))
3644 type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
3645 else if (sec == obj_datasec (output_bfd))
3646 type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
3647 else if (sec == obj_bsssec (output_bfd))
3648 type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
3649 else
3650 type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
3651 type |= N_EXT;
3652 val = (h->root.u.def.value
3653 + sec->vma
3654 + h->root.u.def.section->output_offset);
3655 }
3656 break;
3657 case bfd_link_hash_common:
3658 type = N_UNDF | N_EXT;
3659 val = h->root.u.c.size;
3660 break;
3661 case bfd_link_hash_undefweak:
3662 type = N_WEAKU;
3663 val = 0;
c38eb2a6 3664 break;
116c20d2
NC		 3665 case bfd_link_hash_indirect:
3666 /* We ignore these symbols, since the indirected symbol is
3667 already in the hash table. */
3668 return TRUE;
3669 }
252b5132 3670
116c20d2
NC		 3671 H_PUT_8 (output_bfd, type, outsym.e_type);
3672 H_PUT_8 (output_bfd, 0, outsym.e_other);
3673 H_PUT_16 (output_bfd, 0, outsym.e_desc);
57402f1e 3674 indx = add_to_stringtab (output_bfd, flaginfo->strtab, h->root.root.string,
116c20d2
NC		 3675 FALSE);
3676 if (indx == - (bfd_size_type) 1)
3677 /* FIXME: No way to handle errors. */
3678 abort ();
252b5132 3679
116c20d2
NC		 3680 PUT_WORD (output_bfd, indx, outsym.e_strx);
3681 PUT_WORD (output_bfd, val, outsym.e_value);
252b5132 3682
116c20d2 3683 amt = EXTERNAL_NLIST_SIZE;
57402f1e 3684 if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0
116c20d2
NC		 3685 || bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt)
3686 /* FIXME: No way to handle errors. */
3687 abort ();
252b5132 3688
57402f1e 3689 flaginfo->symoff += EXTERNAL_NLIST_SIZE;
116c20d2
NC		 3690 h->indx = obj_aout_external_sym_count (output_bfd);
3691 ++obj_aout_external_sym_count (output_bfd);
252b5132 3692
116c20d2
NC		 3693 return TRUE;
3694}
252b5132 3695
116c20d2 3696/* Handle a link order which is supposed to generate a reloc. */
252b5132 3697
116c20d2 3698static bfd_boolean
57402f1e 3699aout_link_reloc_link_order (struct aout_final_link_info *flaginfo,
116c20d2
NC		 3700 asection *o,
3701 struct bfd_link_order *p)
3702{
3703 struct bfd_link_order_reloc *pr;
3704 int r_index;
3705 int r_extern;
3706 reloc_howto_type *howto;
3707 file_ptr *reloff_ptr = NULL;
3708 struct reloc_std_external srel;
3709 struct reloc_ext_external erel;
3710 void * rel_ptr;
3711 bfd_size_type amt;
252b5132 3712
116c20d2 3713 pr = p->u.reloc.p;
252b5132 3714
116c20d2
NC		 3715 if (p->type == bfd_section_reloc_link_order)
3716 {
3717 r_extern = 0;
3718 if (bfd_is_abs_section (pr->u.section))
3719 r_index = N_ABS | N_EXT;
3720 else
3721 {
57402f1e 3722 BFD_ASSERT (pr->u.section->owner == flaginfo->output_bfd);
116c20d2
NC		 3723 r_index = pr->u.section->target_index;
3724 }
3725 }
3726 else
3727 {
3728 struct aout_link_hash_entry *h;
252b5132 3729
116c20d2
NC		 3730 BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
3731 r_extern = 1;
3732 h = ((struct aout_link_hash_entry *)
57402f1e 3733 bfd_wrapped_link_hash_lookup (flaginfo->output_bfd, flaginfo->info,
116c20d2
NC		 3734 pr->u.name, FALSE, FALSE, TRUE));
3735 if (h != NULL
3736 && h->indx >= 0)
3737 r_index = h->indx;
3738 else if (h != NULL)
3739 {
3740 /* We decided to strip this symbol, but it turns out that we
3741 can't. Note that we lose the other and desc information
3742 here. I don't think that will ever matter for a global
3743 symbol. */
3744 h->indx = -2;
3745 h->written = FALSE;
57402f1e 3746 if (!aout_link_write_other_symbol (&h->root.root, flaginfo))
116c20d2
NC		 3747 return FALSE;
3748 r_index = h->indx;
3749 }
3750 else
3751 {
1a72702b
AM		 3752 (*flaginfo->info->callbacks->unattached_reloc)
3753 (flaginfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0);
116c20d2
NC		 3754 r_index = 0;
3755 }
3756 }
252b5132 3757
57402f1e 3758 howto = bfd_reloc_type_lookup (flaginfo->output_bfd, pr->reloc);
116c20d2 3759 if (howto == 0)
252b5132 3760 {
116c20d2
NC		 3761 bfd_set_error (bfd_error_bad_value);
3762 return FALSE;
252b5132
RH		 3763 }
3764
57402f1e
NC		 3765 if (o == obj_textsec (flaginfo->output_bfd))
3766 reloff_ptr = &flaginfo->treloff;
3767 else if (o == obj_datasec (flaginfo->output_bfd))
3768 reloff_ptr = &flaginfo->dreloff;
116c20d2
NC		 3769 else
3770 abort ();
3771
57402f1e 3772 if (obj_reloc_entry_size (flaginfo->output_bfd) == RELOC_STD_SIZE)
252b5132 3773 {
116c20d2 3774#ifdef MY_put_reloc
57402f1e 3775 MY_put_reloc (flaginfo->output_bfd, r_extern, r_index, p->offset, howto,
116c20d2
NC		 3776 &srel);
3777#else
3778 {
3779 int r_pcrel;
3780 int r_baserel;
3781 int r_jmptable;
3782 int r_relative;
3783 int r_length;
252b5132 3784
116c20d2
NC		 3785 r_pcrel = (int) howto->pc_relative;
3786 r_baserel = (howto->type & 8) != 0;
3787 r_jmptable = (howto->type & 16) != 0;
3788 r_relative = (howto->type & 32) != 0;
3789 r_length = howto->size;
252b5132 3790
57402f1e
NC		 3791 PUT_WORD (flaginfo->output_bfd, p->offset, srel.r_address);
3792 if (bfd_header_big_endian (flaginfo->output_bfd))
116c20d2
NC		 3793 {
3794 srel.r_index[0] = r_index >> 16;
3795 srel.r_index[1] = r_index >> 8;
3796 srel.r_index[2] = r_index;
3797 srel.r_type[0] =
3798 ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
3799 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
3800 | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
3801 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
3802 | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
3803 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
3804 }
3805 else
3806 {
3807 srel.r_index[2] = r_index >> 16;
3808 srel.r_index[1] = r_index >> 8;
3809 srel.r_index[0] = r_index;
3810 srel.r_type[0] =
3811 ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
3812 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
3813 | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
3814 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
3815 | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
3816 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
3817 }
3818 }
3819#endif
3820 rel_ptr = (void *) &srel;
252b5132 3821
116c20d2
NC		 3822 /* We have to write the addend into the object file, since
3823 standard a.out relocs are in place. It would be more
3824 reliable if we had the current contents of the file here,
3825 rather than assuming zeroes, but we can't read the file since
3826 it was opened using bfd_openw. */
3827 if (pr->addend != 0)
252b5132 3828 {
116c20d2
NC		 3829 bfd_size_type size;
3830 bfd_reloc_status_type r;
3831 bfd_byte *buf;
3832 bfd_boolean ok;
3833
3834 size = bfd_get_reloc_size (howto);
a50b1753 3835 buf = (bfd_byte *) bfd_zmalloc (size);
6346d5ca 3836 if (buf == NULL && size != 0)
116c20d2 3837 return FALSE;
57402f1e 3838 r = MY_relocate_contents (howto, flaginfo->output_bfd,
116c20d2
NC		 3839 (bfd_vma) pr->addend, buf);
3840 switch (r)
252b5132 3841 {
116c20d2
NC		 3842 case bfd_reloc_ok:
3843 break;
3844 default:
3845 case bfd_reloc_outofrange:
3846 abort ();
3847 case bfd_reloc_overflow:
1a72702b
AM		 3848 (*flaginfo->info->callbacks->reloc_overflow)
3849 (flaginfo->info, NULL,
3850 (p->type == bfd_section_reloc_link_order
3851 ? bfd_section_name (flaginfo->output_bfd,
3852 pr->u.section)
3853 : pr->u.name),
3854 howto->name, pr->addend, NULL, NULL, (bfd_vma) 0);
116c20d2 3855 break;
252b5132 3856 }
57402f1e 3857 ok = bfd_set_section_contents (flaginfo->output_bfd, o, (void *) buf,
116c20d2
NC		 3858 (file_ptr) p->offset, size);
3859 free (buf);
3860 if (! ok)
3861 return FALSE;
252b5132
RH		 3862 }
3863 }
116c20d2 3864 else
252b5132 3865 {
116c20d2 3866#ifdef MY_put_ext_reloc
57402f1e 3867 MY_put_ext_reloc (flaginfo->output_bfd, r_extern, r_index, p->offset,
116c20d2
NC		 3868 howto, &erel, pr->addend);
3869#else
57402f1e 3870 PUT_WORD (flaginfo->output_bfd, p->offset, erel.r_address);
252b5132 3871
57402f1e 3872 if (bfd_header_big_endian (flaginfo->output_bfd))
116c20d2
NC		 3873 {
3874 erel.r_index[0] = r_index >> 16;
3875 erel.r_index[1] = r_index >> 8;
3876 erel.r_index[2] = r_index;
3877 erel.r_type[0] =
3878 ((r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
3879 | (howto->type << RELOC_EXT_BITS_TYPE_SH_BIG));
3880 }
3881 else
3882 {
3883 erel.r_index[2] = r_index >> 16;
3884 erel.r_index[1] = r_index >> 8;
3885 erel.r_index[0] = r_index;
3886 erel.r_type[0] =
3887 (r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
3888 | (howto->type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
3889 }
252b5132 3890
57402f1e 3891 PUT_WORD (flaginfo->output_bfd, (bfd_vma) pr->addend, erel.r_addend);
116c20d2 3892#endif /* MY_put_ext_reloc */
252b5132 3893
116c20d2 3894 rel_ptr = (void *) &erel;
252b5132 3895 }
252b5132 3896
57402f1e
NC		 3897 amt = obj_reloc_entry_size (flaginfo->output_bfd);
3898 if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
3899 || bfd_bwrite (rel_ptr, amt, flaginfo->output_bfd) != amt)
116c20d2 3900 return FALSE;
252b5132 3901
57402f1e 3902 *reloff_ptr += obj_reloc_entry_size (flaginfo->output_bfd);
252b5132 3903
116c20d2
NC		 3904 /* Assert that the relocs have not run into the symbols, and that n
3905 the text relocs have not run into the data relocs. */
57402f1e
NC		 3906 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd)
3907 && (reloff_ptr != &flaginfo->treloff
116c20d2 3908 || (*reloff_ptr
57402f1e 3909 <= obj_datasec (flaginfo->output_bfd)->rel_filepos)));
116c20d2
NC		 3910
3911 return TRUE;
252b5132
RH		 3912}
3913
116c20d2 3914/* Get the section corresponding to a reloc index. */
252b5132 3915
116c20d2
NC		 3916static INLINE asection *
3917aout_reloc_index_to_section (bfd *abfd, int indx)
252b5132 3918{
116c20d2 3919 switch (indx & N_TYPE)
252b5132 3920 {
116c20d2
NC		 3921 case N_TEXT: return obj_textsec (abfd);
3922 case N_DATA: return obj_datasec (abfd);
3923 case N_BSS: return obj_bsssec (abfd);
3924 case N_ABS:
3925 case N_UNDF: return bfd_abs_section_ptr;
3926 default: abort ();
252b5132 3927 }
116c20d2 3928 return NULL;
252b5132
RH		 3929}
3930
116c20d2 3931/* Relocate an a.out section using standard a.out relocs. */
252b5132 3932
b34976b6 3933static bfd_boolean
57402f1e 3934aout_link_input_section_std (struct aout_final_link_info *flaginfo,
116c20d2
NC		 3935 bfd *input_bfd,
3936 asection *input_section,
3937 struct reloc_std_external *relocs,
3938 bfd_size_type rel_size,
3939 bfd_byte *contents)
252b5132 3940{
116c20d2
NC		 3941 bfd_boolean (*check_dynamic_reloc)
3942 (struct bfd_link_info *, bfd *, asection *,
3943 struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
3944 bfd_vma *);
252b5132 3945 bfd *output_bfd;
116c20d2
NC		 3946 bfd_boolean relocatable;
3947 struct external_nlist *syms;
252b5132 3948 char *strings;
116c20d2 3949 struct aout_link_hash_entry **sym_hashes;
252b5132 3950 int *symbol_map;
116c20d2
NC		 3951 bfd_size_type reloc_count;
3952 struct reloc_std_external *rel;
3953 struct reloc_std_external *rel_end;
252b5132 3954
57402f1e 3955 output_bfd = flaginfo->output_bfd;
116c20d2 3956 check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
252b5132 3957
116c20d2
NC		 3958 BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE);
3959 BFD_ASSERT (input_bfd->xvec->header_byteorder
3960 == output_bfd->xvec->header_byteorder);
252b5132 3961
0e1862bb 3962 relocatable = bfd_link_relocatable (flaginfo->info);
116c20d2
NC		 3963 syms = obj_aout_external_syms (input_bfd);
3964 strings = obj_aout_external_strings (input_bfd);
3965 sym_hashes = obj_aout_sym_hashes (input_bfd);
57402f1e 3966 symbol_map = flaginfo->symbol_map;
116c20d2
NC		 3967
3968 reloc_count = rel_size / RELOC_STD_SIZE;
3969 rel = relocs;
3970 rel_end = rel + reloc_count;
3971 for (; rel < rel_end; rel++)
252b5132 3972 {
116c20d2
NC		 3973 bfd_vma r_addr;
3974 int r_index;
3975 int r_extern;
3976 int r_pcrel;
3977 int r_baserel = 0;
3978 reloc_howto_type *howto;
3979 struct aout_link_hash_entry *h = NULL;
3980 bfd_vma relocation;
3981 bfd_reloc_status_type r;
252b5132 3982
116c20d2 3983 r_addr = GET_SWORD (input_bfd, rel->r_address);
252b5132 3984
116c20d2
NC		 3985#ifdef MY_reloc_howto
3986 howto = MY_reloc_howto (input_bfd, rel, r_index, r_extern, r_pcrel);
3987#else
3988 {
3989 int r_jmptable;
3990 int r_relative;
3991 int r_length;
3992 unsigned int howto_idx;
252b5132 3993
116c20d2
NC		 3994 if (bfd_header_big_endian (input_bfd))
3995 {
3996 r_index = (((unsigned int) rel->r_index[0] << 16)
3997 | ((unsigned int) rel->r_index[1] << 8)
3998 | rel->r_index[2]);
3999 r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
4000 r_pcrel = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
4001 r_baserel = (0 != (rel->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
4002 r_jmptable= (0 != (rel->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
4003 r_relative= (0 != (rel->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
4004 r_length = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
4005 >> RELOC_STD_BITS_LENGTH_SH_BIG);
4006 }
4007 else
4008 {
4009 r_index = (((unsigned int) rel->r_index[2] << 16)
4010 | ((unsigned int) rel->r_index[1] << 8)
4011 | rel->r_index[0]);
4012 r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
4013 r_pcrel = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
4014 r_baserel = (0 != (rel->r_type[0]
4015 & RELOC_STD_BITS_BASEREL_LITTLE));
4016 r_jmptable= (0 != (rel->r_type[0]
4017 & RELOC_STD_BITS_JMPTABLE_LITTLE));
4018 r_relative= (0 != (rel->r_type[0]
4019 & RELOC_STD_BITS_RELATIVE_LITTLE));
4020 r_length = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
4021 >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
4022 }
252b5132 4023
116c20d2
NC		 4024 howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel
4025 + 16 * r_jmptable + 32 * r_relative);
ad756e3f
AM		 4026 if (howto_idx < TABLE_SIZE (howto_table_std))
4027 howto = howto_table_std + howto_idx;
4028 else
4029 howto = NULL;
116c20d2
NC		 4030 }
4031#endif
252b5132 4032
ad756e3f
AM		 4033 if (howto == NULL)
4034 {
57402f1e 4035 (*flaginfo->info->callbacks->einfo)
ad756e3f
AM		 4036 (_("%P: %B: unexpected relocation type\n"), input_bfd);
4037 bfd_set_error (bfd_error_bad_value);
4038 return FALSE;
4039 }
4040
116c20d2 4041 if (relocatable)
252b5132 4042 {
116c20d2
NC		 4043 /* We are generating a relocatable output file, and must
4044 modify the reloc accordingly. */
4045 if (r_extern)
252b5132 4046 {
116c20d2
NC		 4047 /* If we know the symbol this relocation is against,
4048 convert it into a relocation against a section. This
4049 is what the native linker does. */
4050 h = sym_hashes[r_index];
4051 if (h != NULL
4052 && (h->root.type == bfd_link_hash_defined
4053 || h->root.type == bfd_link_hash_defweak))
252b5132 4054 {
252b5132
RH		 4055 asection *output_section;
4056
116c20d2
NC		 4057 /* Change the r_extern value. */
4058 if (bfd_header_big_endian (output_bfd))
4059 rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_BIG;
4060 else
4061 rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_LITTLE;
252b5132 4062
116c20d2
NC		 4063 /* Compute a new r_index. */
4064 output_section = h->root.u.def.section->output_section;
252b5132 4065 if (output_section == obj_textsec (output_bfd))
116c20d2 4066 r_index = N_TEXT;
252b5132 4067 else if (output_section == obj_datasec (output_bfd))
116c20d2 4068 r_index = N_DATA;
252b5132 4069 else if (output_section == obj_bsssec (output_bfd))
116c20d2 4070 r_index = N_BSS;
252b5132 4071 else
116c20d2 4072 r_index = N_ABS;
252b5132 4073
116c20d2
NC		 4074 /* Add the symbol value and the section VMA to the
4075 addend stored in the contents. */
4076 relocation = (h->root.u.def.value
4077 + output_section->vma
4078 + h->root.u.def.section->output_offset);
252b5132 4079 }
116c20d2 4080 else
252b5132 4081 {
116c20d2
NC		 4082 /* We must change r_index according to the symbol
4083 map. */
4084 r_index = symbol_map[r_index];
252b5132 4085
116c20d2 4086 if (r_index == -1)
252b5132 4087 {
116c20d2 4088 if (h != NULL)
252b5132 4089 {
116c20d2
NC		 4090 /* We decided to strip this symbol, but it
4091 turns out that we can't. Note that we
4092 lose the other and desc information here.
4093 I don't think that will ever matter for a
4094 global symbol. */
4095 if (h->indx < 0)
252b5132 4096 {
116c20d2
NC		 4097 h->indx = -2;
4098 h->written = FALSE;
7686d77d 4099 if (!aout_link_write_other_symbol (&h->root.root,
57402f1e 4100 flaginfo))
116c20d2 4101 return FALSE;
252b5132 4102 }
116c20d2
NC		 4103 r_index = h->indx;
4104 }
4105 else
4106 {
4107 const char *name;
4108
4109 name = strings + GET_WORD (input_bfd,
4110 syms[r_index].e_strx);
1a72702b
AM		 4111 (*flaginfo->info->callbacks->unattached_reloc)
4112 (flaginfo->info, name,
4113 input_bfd, input_section, r_addr);
116c20d2 4114 r_index = 0;
252b5132
RH		 4115 }
4116 }
116c20d2
NC		 4117
4118 relocation = 0;
252b5132
RH		 4119 }
4120
116c20d2
NC		 4121 /* Write out the new r_index value. */
4122 if (bfd_header_big_endian (output_bfd))
252b5132 4123 {
116c20d2
NC		 4124 rel->r_index[0] = r_index >> 16;
4125 rel->r_index[1] = r_index >> 8;
4126 rel->r_index[2] = r_index;
252b5132
RH		 4127 }
4128 else
4129 {
116c20d2
NC		 4130 rel->r_index[2] = r_index >> 16;
4131 rel->r_index[1] = r_index >> 8;
4132 rel->r_index[0] = r_index;
252b5132
RH		 4133 }
4134 }
252b5132 4135 else
116c20d2
NC		 4136 {
4137 asection *section;
252b5132 4138
116c20d2
NC		 4139 /* This is a relocation against a section. We must
4140 adjust by the amount that the section moved. */
4141 section = aout_reloc_index_to_section (input_bfd, r_index);
4142 relocation = (section->output_section->vma
4143 + section->output_offset
4144 - section->vma);
4145 }
252b5132 4146
116c20d2
NC		 4147 /* Change the address of the relocation. */
4148 PUT_WORD (output_bfd,
4149 r_addr + input_section->output_offset,
4150 rel->r_address);
252b5132 4151
116c20d2
NC		 4152 /* Adjust a PC relative relocation by removing the reference
4153 to the original address in the section and including the
4154 reference to the new address. */
4155 if (r_pcrel)
4156 relocation -= (input_section->output_section->vma
4157 + input_section->output_offset
4158 - input_section->vma);
e92d460e 4159
116c20d2
NC		 4160#ifdef MY_relocatable_reloc
4161 MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr);
4162#endif
252b5132 4163
116c20d2
NC		 4164 if (relocation == 0)
4165 r = bfd_reloc_ok;
4166 else
4167 r = MY_relocate_contents (howto,
4168 input_bfd, relocation,
4169 contents + r_addr);
252b5132 4170 }
116c20d2
NC		 4171 else
4172 {
4173 bfd_boolean hundef;
252b5132 4174
116c20d2
NC		 4175 /* We are generating an executable, and must do a full
4176 relocation. */
4177 hundef = FALSE;
252b5132 4178
116c20d2
NC		 4179 if (r_extern)
4180 {
4181 h = sym_hashes[r_index];
252b5132 4182
116c20d2
NC		 4183 if (h != NULL
4184 && (h->root.type == bfd_link_hash_defined
4185 || h->root.type == bfd_link_hash_defweak))
4186 {
4187 relocation = (h->root.u.def.value
4188 + h->root.u.def.section->output_section->vma
4189 + h->root.u.def.section->output_offset);
4190 }
4191 else if (h != NULL
4192 && h->root.type == bfd_link_hash_undefweak)
4193 relocation = 0;
4194 else
4195 {
4196 hundef = TRUE;
4197 relocation = 0;
4198 }
4199 }
4200 else
4201 {
4202 asection *section;
252b5132 4203
116c20d2
NC		 4204 section = aout_reloc_index_to_section (input_bfd, r_index);
4205 relocation = (section->output_section->vma
4206 + section->output_offset
4207 - section->vma);
4208 if (r_pcrel)
4209 relocation += input_section->vma;
4210 }
252b5132 4211
116c20d2
NC		 4212 if (check_dynamic_reloc != NULL)
4213 {
4214 bfd_boolean skip;
252b5132 4215
116c20d2 4216 if (! ((*check_dynamic_reloc)
57402f1e 4217 (flaginfo->info, input_bfd, input_section, h,
116c20d2
NC		 4218 (void *) rel, contents, &skip, &relocation)))
4219 return FALSE;
4220 if (skip)
4221 continue;
4222 }
252b5132 4223
116c20d2
NC		 4224 /* Now warn if a global symbol is undefined. We could not
4225 do this earlier, because check_dynamic_reloc might want
4226 to skip this reloc. */
0e1862bb 4227 if (hundef && ! bfd_link_pic (flaginfo->info) && ! r_baserel)
116c20d2
NC		 4228 {
4229 const char *name;
252b5132 4230
116c20d2
NC		 4231 if (h != NULL)
4232 name = h->root.root.string;
4233 else
4234 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
1a72702b
AM		 4235 (*flaginfo->info->callbacks->undefined_symbol)
4236 (flaginfo->info, name, input_bfd, input_section, r_addr, TRUE);
116c20d2 4237 }
252b5132 4238
116c20d2
NC		 4239 r = MY_final_link_relocate (howto,
4240 input_bfd, input_section,
4241 contents, r_addr, relocation,
4242 (bfd_vma) 0);
252b5132 4243 }
252b5132 4244
116c20d2
NC		 4245 if (r != bfd_reloc_ok)
4246 {
4247 switch (r)
4248 {
4249 default:
4250 case bfd_reloc_outofrange:
4251 abort ();
4252 case bfd_reloc_overflow:
4253 {
4254 const char *name;
252b5132 4255
116c20d2
NC		 4256 if (h != NULL)
4257 name = NULL;
4258 else if (r_extern)
4259 name = strings + GET_WORD (input_bfd,
4260 syms[r_index].e_strx);
4261 else
4262 {
4263 asection *s;
252b5132 4264
116c20d2
NC		 4265 s = aout_reloc_index_to_section (input_bfd, r_index);
4266 name = bfd_section_name (input_bfd, s);
4267 }
1a72702b
AM		 4268 (*flaginfo->info->callbacks->reloc_overflow)
4269 (flaginfo->info, (h ? &h->root : NULL), name, howto->name,
4270 (bfd_vma) 0, input_bfd, input_section, r_addr);
116c20d2
NC		 4271 }
4272 break;
4273 }
4274 }
252b5132
RH		 4275 }
4276
b34976b6 4277 return TRUE;
252b5132
RH		 4278}
4279
116c20d2 4280/* Relocate an a.out section using extended a.out relocs. */
252b5132 4281
b34976b6 4282static bfd_boolean
57402f1e 4283aout_link_input_section_ext (struct aout_final_link_info *flaginfo,
116c20d2
NC		 4284 bfd *input_bfd,
4285 asection *input_section,
4286 struct reloc_ext_external *relocs,
4287 bfd_size_type rel_size,
4288 bfd_byte *contents)
252b5132 4289{
b34976b6 4290 bfd_boolean (*check_dynamic_reloc)
116c20d2
NC		 4291 (struct bfd_link_info *, bfd *, asection *,
4292 struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
4293 bfd_vma *);
252b5132 4294 bfd *output_bfd;
1049f94e 4295 bfd_boolean relocatable;
252b5132
RH		 4296 struct external_nlist *syms;
4297 char *strings;
4298 struct aout_link_hash_entry **sym_hashes;
4299 int *symbol_map;
4300 bfd_size_type reloc_count;
116c20d2
NC		 4301 struct reloc_ext_external *rel;
4302 struct reloc_ext_external *rel_end;
252b5132 4303
57402f1e 4304 output_bfd = flaginfo->output_bfd;
252b5132
RH		 4305 check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
4306
116c20d2 4307 BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_EXT_SIZE);
252b5132
RH		 4308 BFD_ASSERT (input_bfd->xvec->header_byteorder
4309 == output_bfd->xvec->header_byteorder);
4310
0e1862bb 4311 relocatable = bfd_link_relocatable (flaginfo->info);
252b5132
RH		 4312 syms = obj_aout_external_syms (input_bfd);
4313 strings = obj_aout_external_strings (input_bfd);
4314 sym_hashes = obj_aout_sym_hashes (input_bfd);
57402f1e 4315 symbol_map = flaginfo->symbol_map;
252b5132 4316
116c20d2 4317 reloc_count = rel_size / RELOC_EXT_SIZE;
252b5132
RH		 4318 rel = relocs;
4319 rel_end = rel + reloc_count;
4320 for (; rel < rel_end; rel++)
4321 {
4322 bfd_vma r_addr;
4323 int r_index;
4324 int r_extern;
116c20d2
NC		 4325 unsigned int r_type;
4326 bfd_vma r_addend;
252b5132 4327 struct aout_link_hash_entry *h = NULL;
116c20d2 4328 asection *r_section = NULL;
252b5132 4329 bfd_vma relocation;
252b5132
RH		 4330
4331 r_addr = GET_SWORD (input_bfd, rel->r_address);
4332
116c20d2
NC		 4333 if (bfd_header_big_endian (input_bfd))
4334 {
4335 r_index = (((unsigned int) rel->r_index[0] << 16)
4336 | ((unsigned int) rel->r_index[1] << 8)
4337 | rel->r_index[2]);
4338 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
4339 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
4340 >> RELOC_EXT_BITS_TYPE_SH_BIG);
4341 }
4342 else
4343 {
4344 r_index = (((unsigned int) rel->r_index[2] << 16)
4345 | ((unsigned int) rel->r_index[1] << 8)
4346 | rel->r_index[0]);
4347 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
4348 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
4349 >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
4350 }
252b5132 4351
116c20d2 4352 r_addend = GET_SWORD (input_bfd, rel->r_addend);
252b5132 4353
ad756e3f
AM		 4354 if (r_type >= TABLE_SIZE (howto_table_ext))
4355 {
57402f1e 4356 (*flaginfo->info->callbacks->einfo)
ad756e3f
AM		 4357 (_("%P: %B: unexpected relocation type\n"), input_bfd);
4358 bfd_set_error (bfd_error_bad_value);
4359 return FALSE;
4360 }
252b5132 4361
1049f94e 4362 if (relocatable)
252b5132 4363 {
1049f94e 4364 /* We are generating a relocatable output file, and must
252b5132 4365 modify the reloc accordingly. */
116c20d2
NC		 4366 if (r_extern
4367 || r_type == (unsigned int) RELOC_BASE10
4368 || r_type == (unsigned int) RELOC_BASE13
4369 || r_type == (unsigned int) RELOC_BASE22)
252b5132
RH		 4370 {
4371 /* If we know the symbol this relocation is against,
4372 convert it into a relocation against a section. This
4373 is what the native linker does. */
116c20d2
NC		 4374 if (r_type == (unsigned int) RELOC_BASE10
4375 || r_type == (unsigned int) RELOC_BASE13
4376 || r_type == (unsigned int) RELOC_BASE22)
4377 h = NULL;
4378 else
4379 h = sym_hashes[r_index];
4380 if (h != NULL
252b5132
RH		 4381 && (h->root.type == bfd_link_hash_defined
4382 || h->root.type == bfd_link_hash_defweak))
4383 {
4384 asection *output_section;
4385
4386 /* Change the r_extern value. */
4387 if (bfd_header_big_endian (output_bfd))
116c20d2 4388 rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_BIG;
252b5132 4389 else
116c20d2 4390 rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_LITTLE;
252b5132
RH		 4391
4392 /* Compute a new r_index. */
4393 output_section = h->root.u.def.section->output_section;
4394 if (output_section == obj_textsec (output_bfd))
4395 r_index = N_TEXT;
4396 else if (output_section == obj_datasec (output_bfd))
4397 r_index = N_DATA;
4398 else if (output_section == obj_bsssec (output_bfd))
4399 r_index = N_BSS;
4400 else
4401 r_index = N_ABS;
4402
4403 /* Add the symbol value and the section VMA to the
116c20d2 4404 addend. */
252b5132
RH		 4405 relocation = (h->root.u.def.value
4406 + output_section->vma
4407 + h->root.u.def.section->output_offset);
116c20d2
NC		 4408
4409 /* Now RELOCATION is the VMA of the final
4410 destination. If this is a PC relative reloc,
4411 then ADDEND is the negative of the source VMA.
4412 We want to set ADDEND to the difference between
4413 the destination VMA and the source VMA, which
4414 means we must adjust RELOCATION by the change in
4415 the source VMA. This is done below. */
252b5132
RH		 4416 }
4417 else
4418 {
4419 /* We must change r_index according to the symbol
4420 map. */
4421 r_index = symbol_map[r_index];
4422
4423 if (r_index == -1)
4424 {
4425 if (h != NULL)
4426 {
4427 /* We decided to strip this symbol, but it
4428 turns out that we can't. Note that we
4429 lose the other and desc information here.
4430 I don't think that will ever matter for a
4431 global symbol. */
4432 if (h->indx < 0)
4433 {
4434 h->indx = -2;
b34976b6 4435 h->written = FALSE;
7686d77d 4436 if (!aout_link_write_other_symbol (&h->root.root,
57402f1e 4437 flaginfo))
b34976b6 4438 return FALSE;
252b5132
RH		 4439 }
4440 r_index = h->indx;
4441 }
4442 else
4443 {
4444 const char *name;
4445
4446 name = strings + GET_WORD (input_bfd,
4447 syms[r_index].e_strx);
1a72702b
AM		 4448 (*flaginfo->info->callbacks->unattached_reloc)
4449 (flaginfo->info, name,
4450 input_bfd, input_section, r_addr);
252b5132
RH		 4451 r_index = 0;
4452 }
4453 }
4454
4455 relocation = 0;
116c20d2
NC		 4456
4457 /* If this is a PC relative reloc, then the addend
4458 is the negative of the source VMA. We must
4459 adjust it by the change in the source VMA. This
4460 is done below. */
252b5132
RH		 4461 }
4462
4463 /* Write out the new r_index value. */
4464 if (bfd_header_big_endian (output_bfd))
4465 {
4466 rel->r_index[0] = r_index >> 16;
4467 rel->r_index[1] = r_index >> 8;
4468 rel->r_index[2] = r_index;
4469 }
4470 else
4471 {
4472 rel->r_index[2] = r_index >> 16;
4473 rel->r_index[1] = r_index >> 8;
4474 rel->r_index[0] = r_index;
4475 }
4476 }
4477 else
4478 {
252b5132
RH		 4479 /* This is a relocation against a section. We must
4480 adjust by the amount that the section moved. */
116c20d2
NC		 4481 r_section = aout_reloc_index_to_section (input_bfd, r_index);
4482 relocation = (r_section->output_section->vma
4483 + r_section->output_offset
4484 - r_section->vma);
252b5132 4485
116c20d2
NC		 4486 /* If this is a PC relative reloc, then the addend is
4487 the difference in VMA between the destination and the
4488 source. We have just adjusted for the change in VMA
4489 of the destination, so we must also adjust by the
4490 change in VMA of the source. This is done below. */
4491 }
252b5132 4492
116c20d2
NC		 4493 /* As described above, we must always adjust a PC relative
4494 reloc by the change in VMA of the source. However, if
4495 pcrel_offset is set, then the addend does not include the
4496 location within the section, in which case we don't need
4497 to adjust anything. */
4498 if (howto_table_ext[r_type].pc_relative
4499 && ! howto_table_ext[r_type].pcrel_offset)
252b5132
RH		 4500 relocation -= (input_section->output_section->vma
4501 + input_section->output_offset
4502 - input_section->vma);
4503
116c20d2
NC		 4504 /* Change the addend if necessary. */
4505 if (relocation != 0)
4506 PUT_WORD (output_bfd, r_addend + relocation, rel->r_addend);
252b5132 4507
116c20d2
NC		 4508 /* Change the address of the relocation. */
4509 PUT_WORD (output_bfd,
4510 r_addr + input_section->output_offset,
4511 rel->r_address);
252b5132
RH		 4512 }
4513 else
4514 {
b34976b6 4515 bfd_boolean hundef;
116c20d2 4516 bfd_reloc_status_type r;
252b5132
RH		 4517
4518 /* We are generating an executable, and must do a full
4519 relocation. */
b34976b6 4520 hundef = FALSE;
252b5132
RH		 4521
4522 if (r_extern)
4523 {
4524 h = sym_hashes[r_index];
4525
116c20d2 4526 if (h != NULL
252b5132
RH		 4527 && (h->root.type == bfd_link_hash_defined
4528 || h->root.type == bfd_link_hash_defweak))
4529 {
4530 relocation = (h->root.u.def.value
4531 + h->root.u.def.section->output_section->vma
4532 + h->root.u.def.section->output_offset);
4533 }
116c20d2 4534 else if (h != NULL
252b5132
RH		 4535 && h->root.type == bfd_link_hash_undefweak)
4536 relocation = 0;
4537 else
4538 {
b34976b6 4539 hundef = TRUE;
252b5132
RH		 4540 relocation = 0;
4541 }
4542 }
116c20d2
NC		 4543 else if (r_type == (unsigned int) RELOC_BASE10
4544 || r_type == (unsigned int) RELOC_BASE13
4545 || r_type == (unsigned int) RELOC_BASE22)
4546 {
4547 struct external_nlist *sym;
4548 int type;
4549
4550 /* For base relative relocs, r_index is always an index
4551 into the symbol table, even if r_extern is 0. */
4552 sym = syms + r_index;
4553 type = H_GET_8 (input_bfd, sym->e_type);
4554 if ((type & N_TYPE) == N_TEXT
4555 || type == N_WEAKT)
4556 r_section = obj_textsec (input_bfd);
4557 else if ((type & N_TYPE) == N_DATA
4558 || type == N_WEAKD)
4559 r_section = obj_datasec (input_bfd);
4560 else if ((type & N_TYPE) == N_BSS
4561 || type == N_WEAKB)
4562 r_section = obj_bsssec (input_bfd);
4563 else if ((type & N_TYPE) == N_ABS
4564 || type == N_WEAKA)
4565 r_section = bfd_abs_section_ptr;
4566 else
4567 abort ();
4568 relocation = (r_section->output_section->vma
4569 + r_section->output_offset
4570 + (GET_WORD (input_bfd, sym->e_value)
4571 - r_section->vma));
4572 }
252b5132
RH		 4573 else
4574 {
116c20d2 4575 r_section = aout_reloc_index_to_section (input_bfd, r_index);
252b5132 4576
116c20d2
NC		 4577 /* If this is a PC relative reloc, then R_ADDEND is the
4578 difference between the two vmas, or
4579 old_dest_sec + old_dest_off - (old_src_sec + old_src_off)
4580 where
4581 old_dest_sec == section->vma
4582 and
4583 old_src_sec == input_section->vma
4584 and
4585 old_src_off == r_addr
4586
4587 _bfd_final_link_relocate expects RELOCATION +
4588 R_ADDEND to be the VMA of the destination minus
4589 r_addr (the minus r_addr is because this relocation
4590 is not pcrel_offset, which is a bit confusing and
4591 should, perhaps, be changed), or
4592 new_dest_sec
4593 where
4594 new_dest_sec == output_section->vma + output_offset
4595 We arrange for this to happen by setting RELOCATION to
4596 new_dest_sec + old_src_sec - old_dest_sec
4597
4598 If this is not a PC relative reloc, then R_ADDEND is
4599 simply the VMA of the destination, so we set
4600 RELOCATION to the change in the destination VMA, or
4601 new_dest_sec - old_dest_sec
4602 */
4603 relocation = (r_section->output_section->vma
4604 + r_section->output_offset
4605 - r_section->vma);
4606 if (howto_table_ext[r_type].pc_relative)
252b5132
RH		 4607 relocation += input_section->vma;
4608 }
4609
4610 if (check_dynamic_reloc != NULL)
4611 {
b34976b6 4612 bfd_boolean skip;
252b5132
RH		 4613
4614 if (! ((*check_dynamic_reloc)
57402f1e 4615 (flaginfo->info, input_bfd, input_section, h,
116c20d2 4616 (void *) rel, contents, &skip, &relocation)))
b34976b6 4617 return FALSE;
252b5132
RH		 4618 if (skip)
4619 continue;
4620 }
4621
4622 /* Now warn if a global symbol is undefined. We could not
4623 do this earlier, because check_dynamic_reloc might want
4624 to skip this reloc. */
116c20d2 4625 if (hundef
0e1862bb 4626 && ! bfd_link_pic (flaginfo->info)
116c20d2
NC		 4627 && r_type != (unsigned int) RELOC_BASE10
4628 && r_type != (unsigned int) RELOC_BASE13
4629 && r_type != (unsigned int) RELOC_BASE22)
252b5132
RH		 4630 {
4631 const char *name;
4632
4633 if (h != NULL)
4634 name = h->root.root.string;
4635 else
4636 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
1a72702b
AM		 4637 (*flaginfo->info->callbacks->undefined_symbol)
4638 (flaginfo->info, name, input_bfd, input_section, r_addr, TRUE);
252b5132
RH		 4639 }
4640
116c20d2
NC		 4641 if (r_type != (unsigned int) RELOC_SPARC_REV32)
4642 r = MY_final_link_relocate (howto_table_ext + r_type,
4643 input_bfd, input_section,
4644 contents, r_addr, relocation,
4645 r_addend);
4646 else
252b5132 4647 {
116c20d2 4648 bfd_vma x;
252b5132 4649
116c20d2
NC		 4650 x = bfd_get_32 (input_bfd, contents + r_addr);
4651 x = x + relocation + r_addend;
4652 bfd_putl32 (/*input_bfd,*/ x, contents + r_addr);
4653 r = bfd_reloc_ok;
4654 }
4655
4656 if (r != bfd_reloc_ok)
4657 {
4658 switch (r)
4659 {
4660 default:
4661 case bfd_reloc_outofrange:
4662 abort ();
4663 case bfd_reloc_overflow:
252b5132 4664 {
116c20d2 4665 const char *name;
252b5132 4666
116c20d2
NC		 4667 if (h != NULL)
4668 name = NULL;
4669 else if (r_extern
4670 || r_type == (unsigned int) RELOC_BASE10
4671 || r_type == (unsigned int) RELOC_BASE13
4672 || r_type == (unsigned int) RELOC_BASE22)
4673 name = strings + GET_WORD (input_bfd,
4674 syms[r_index].e_strx);
4675 else
4676 {
4677 asection *s;
4678
4679 s = aout_reloc_index_to_section (input_bfd, r_index);
4680 name = bfd_section_name (input_bfd, s);
4681 }
1a72702b
AM		 4682 (*flaginfo->info->callbacks->reloc_overflow)
4683 (flaginfo->info, (h ? &h->root : NULL), name,
4684 howto_table_ext[r_type].name,
4685 r_addend, input_bfd, input_section, r_addr);
252b5132 4686 }
116c20d2
NC		 4687 break;
4688 }
252b5132
RH		 4689 }
4690 }
4691 }
4692
b34976b6 4693 return TRUE;
252b5132
RH		 4694}
4695
116c20d2
NC		 4696/* Link an a.out section into the output file. */
4697
4698static bfd_boolean
57402f1e 4699aout_link_input_section (struct aout_final_link_info *flaginfo,
116c20d2
NC		 4700 bfd *input_bfd,
4701 asection *input_section,
4702 file_ptr *reloff_ptr,
4703 bfd_size_type rel_size)
4704{
4705 bfd_size_type input_size;
4706 void * relocs;
4707
4708 /* Get the section contents. */
4709 input_size = input_section->size;
4710 if (! bfd_get_section_contents (input_bfd, input_section,
57402f1e 4711 (void *) flaginfo->contents,
116c20d2
NC		 4712 (file_ptr) 0, input_size))
4713 return FALSE;
4714
4715 /* Read in the relocs if we haven't already done it. */
4716 if (aout_section_data (input_section) != NULL
4717 && aout_section_data (input_section)->relocs != NULL)
4718 relocs = aout_section_data (input_section)->relocs;
4719 else
4720 {
57402f1e 4721 relocs = flaginfo->relocs;
116c20d2
NC		 4722 if (rel_size > 0)
4723 {
4724 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4725 || bfd_bread (relocs, rel_size, input_bfd) != rel_size)
4726 return FALSE;
4727 }
4728 }
4729
4730 /* Relocate the section contents. */
4731 if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
4732 {
57402f1e 4733 if (! aout_link_input_section_std (flaginfo, input_bfd, input_section,
116c20d2 4734 (struct reloc_std_external *) relocs,
57402f1e 4735 rel_size, flaginfo->contents))
116c20d2
NC		 4736 return FALSE;
4737 }
4738 else
4739 {
57402f1e 4740 if (! aout_link_input_section_ext (flaginfo, input_bfd, input_section,
116c20d2 4741 (struct reloc_ext_external *) relocs,
57402f1e 4742 rel_size, flaginfo->contents))
116c20d2
NC		 4743 return FALSE;
4744 }
4745
4746 /* Write out the section contents. */
57402f1e 4747 if (! bfd_set_section_contents (flaginfo->output_bfd,
116c20d2 4748 input_section->output_section,
57402f1e 4749 (void *) flaginfo->contents,
116c20d2
NC		 4750 (file_ptr) input_section->output_offset,
4751 input_size))
4752 return FALSE;
4753
4754 /* If we are producing relocatable output, the relocs were
4755 modified, and we now write them out. */
0e1862bb 4756 if (bfd_link_relocatable (flaginfo->info) && rel_size > 0)
116c20d2 4757 {
57402f1e 4758 if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
116c20d2 4759 return FALSE;
57402f1e 4760 if (bfd_bwrite (relocs, rel_size, flaginfo->output_bfd) != rel_size)
116c20d2
NC		 4761 return FALSE;
4762 *reloff_ptr += rel_size;
4763
4764 /* Assert that the relocs have not run into the symbols, and
4765 that if these are the text relocs they have not run into the
4766 data relocs. */
57402f1e
NC		 4767 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd)
4768 && (reloff_ptr != &flaginfo->treloff
116c20d2 4769 || (*reloff_ptr
57402f1e 4770 <= obj_datasec (flaginfo->output_bfd)->rel_filepos)));
116c20d2
NC		 4771 }
4772
4773 return TRUE;
4774}
4775
4776/* Adjust and write out the symbols for an a.out file. Set the new
4777 symbol indices into a symbol_map. */
252b5132 4778
b34976b6 4779static bfd_boolean
57402f1e 4780aout_link_write_symbols (struct aout_final_link_info *flaginfo, bfd *input_bfd)
252b5132 4781{
252b5132 4782 bfd *output_bfd;
116c20d2 4783 bfd_size_type sym_count;
252b5132 4784 char *strings;
116c20d2
NC		 4785 enum bfd_link_strip strip;
4786 enum bfd_link_discard discard;
4787 struct external_nlist *outsym;
4788 bfd_size_type strtab_index;
4789 struct external_nlist *sym;
4790 struct external_nlist *sym_end;
4791 struct aout_link_hash_entry **sym_hash;
252b5132 4792 int *symbol_map;
116c20d2
NC		 4793 bfd_boolean pass;
4794 bfd_boolean skip_next;
252b5132 4795
57402f1e 4796 output_bfd = flaginfo->output_bfd;
116c20d2
NC		 4797 sym_count = obj_aout_external_sym_count (input_bfd);
4798 strings = obj_aout_external_strings (input_bfd);
57402f1e
NC		 4799 strip = flaginfo->info->strip;
4800 discard = flaginfo->info->discard;
4801 outsym = flaginfo->output_syms;
252b5132 4802
116c20d2
NC		 4803 /* First write out a symbol for this object file, unless we are
4804 discarding such symbols. */
4805 if (strip != strip_all
4806 && (strip != strip_some
57402f1e 4807 || bfd_hash_lookup (flaginfo->info->keep_hash, input_bfd->filename,
116c20d2
NC		 4808 FALSE, FALSE) != NULL)
4809 && discard != discard_all)
4810 {
4811 H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
4812 H_PUT_8 (output_bfd, 0, outsym->e_other);
4813 H_PUT_16 (output_bfd, 0, outsym->e_desc);
57402f1e 4814 strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
116c20d2
NC		 4815 input_bfd->filename, FALSE);
4816 if (strtab_index == (bfd_size_type) -1)
4817 return FALSE;
4818 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4819 PUT_WORD (output_bfd,
4820 (bfd_get_section_vma (output_bfd,
4821 obj_textsec (input_bfd)->output_section)
4822 + obj_textsec (input_bfd)->output_offset),
4823 outsym->e_value);
4824 ++obj_aout_external_sym_count (output_bfd);
4825 ++outsym;
4826 }
252b5132 4827
116c20d2
NC		 4828 pass = FALSE;
4829 skip_next = FALSE;
4830 sym = obj_aout_external_syms (input_bfd);
4831 sym_end = sym + sym_count;
4832 sym_hash = obj_aout_sym_hashes (input_bfd);
57402f1e 4833 symbol_map = flaginfo->symbol_map;
116c20d2
NC		 4834 memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
4835 for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
252b5132 4836 {
116c20d2
NC		 4837 const char *name;
4838 int type;
4839 struct aout_link_hash_entry *h;
4840 bfd_boolean skip;
4841 asection *symsec;
4842 bfd_vma val = 0;
4843 bfd_boolean copy;
252b5132 4844
116c20d2
NC		 4845 /* We set *symbol_map to 0 above for all symbols. If it has
4846 already been set to -1 for this symbol, it means that we are
4847 discarding it because it appears in a duplicate header file.
4848 See the N_BINCL code below. */
4849 if (*symbol_map == -1)
4850 continue;
252b5132 4851
116c20d2
NC		 4852 /* Initialize *symbol_map to -1, which means that the symbol was
4853 not copied into the output file. We will change it later if
4854 we do copy the symbol over. */
4855 *symbol_map = -1;
4856
4857 type = H_GET_8 (input_bfd, sym->e_type);
4858 name = strings + GET_WORD (input_bfd, sym->e_strx);
4859
4860 h = NULL;
4861
4862 if (pass)
252b5132 4863 {
116c20d2
NC		 4864 /* Pass this symbol through. It is the target of an
4865 indirect or warning symbol. */
4866 val = GET_WORD (input_bfd, sym->e_value);
4867 pass = FALSE;
252b5132 4868 }
116c20d2 4869 else if (skip_next)
252b5132 4870 {
116c20d2
NC		 4871 /* Skip this symbol, which is the target of an indirect
4872 symbol that we have changed to no longer be an indirect
4873 symbol. */
4874 skip_next = FALSE;
4875 continue;
252b5132 4876 }
116c20d2
NC		 4877 else
4878 {
4879 struct aout_link_hash_entry *hresolve;
252b5132 4880
116c20d2
NC		 4881 /* We have saved the hash table entry for this symbol, if
4882 there is one. Note that we could just look it up again
4883 in the hash table, provided we first check that it is an
4884 external symbol. */
4885 h = *sym_hash;
252b5132 4886
116c20d2
NC		 4887 /* Use the name from the hash table, in case the symbol was
4888 wrapped. */
4889 if (h != NULL
4890 && h->root.type != bfd_link_hash_warning)
4891 name = h->root.root.string;
252b5132 4892
116c20d2
NC		 4893 /* If this is an indirect or warning symbol, then change
4894 hresolve to the base symbol. We also change *sym_hash so
4895 that the relocation routines relocate against the real
4896 symbol. */
4897 hresolve = h;
4898 if (h != (struct aout_link_hash_entry *) NULL
4899 && (h->root.type == bfd_link_hash_indirect
4900 || h->root.type == bfd_link_hash_warning))
252b5132 4901 {
116c20d2
NC		 4902 hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
4903 while (hresolve->root.type == bfd_link_hash_indirect
4904 || hresolve->root.type == bfd_link_hash_warning)
4905 hresolve = ((struct aout_link_hash_entry *)
4906 hresolve->root.u.i.link);
4907 *sym_hash = hresolve;
4908 }
4909
4910 /* If the symbol has already been written out, skip it. */
4911 if (h != NULL
4912 && h->written)
4913 {
4914 if ((type & N_TYPE) == N_INDR
4915 || type == N_WARNING)
4916 skip_next = TRUE;
4917 *symbol_map = h->indx;
4918 continue;
4919 }
4920
4921 /* See if we are stripping this symbol. */
4922 skip = FALSE;
4923 switch (strip)
4924 {
4925 case strip_none:
4926 break;
4927 case strip_debugger:
4928 if ((type & N_STAB) != 0)
4929 skip = TRUE;
4930 break;
4931 case strip_some:
57402f1e 4932 if (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE, FALSE)
116c20d2
NC		 4933 == NULL)
4934 skip = TRUE;
4935 break;
4936 case strip_all:
4937 skip = TRUE;
4938 break;
4939 }
4940 if (skip)
4941 {
4942 if (h != NULL)
4943 h->written = TRUE;
4944 continue;
4945 }
4946
4947 /* Get the value of the symbol. */
4948 if ((type & N_TYPE) == N_TEXT
4949 || type == N_WEAKT)
4950 symsec = obj_textsec (input_bfd);
4951 else if ((type & N_TYPE) == N_DATA
4952 || type == N_WEAKD)
4953 symsec = obj_datasec (input_bfd);
4954 else if ((type & N_TYPE) == N_BSS
4955 || type == N_WEAKB)
4956 symsec = obj_bsssec (input_bfd);
4957 else if ((type & N_TYPE) == N_ABS
4958 || type == N_WEAKA)
4959 symsec = bfd_abs_section_ptr;
4960 else if (((type & N_TYPE) == N_INDR
4961 && (hresolve == NULL
4962 || (hresolve->root.type != bfd_link_hash_defined
4963 && hresolve->root.type != bfd_link_hash_defweak
4964 && hresolve->root.type != bfd_link_hash_common)))
4965 || type == N_WARNING)
4966 {
4967 /* Pass the next symbol through unchanged. The
4968 condition above for indirect symbols is so that if
4969 the indirect symbol was defined, we output it with
4970 the correct definition so the debugger will
4971 understand it. */
4972 pass = TRUE;
4973 val = GET_WORD (input_bfd, sym->e_value);
4974 symsec = NULL;
4975 }
4976 else if ((type & N_STAB) != 0)
4977 {
4978 val = GET_WORD (input_bfd, sym->e_value);
4979 symsec = NULL;
4980 }
4981 else
4982 {
4983 /* If we get here with an indirect symbol, it means that
4984 we are outputting it with a real definition. In such
4985 a case we do not want to output the next symbol,
4986 which is the target of the indirection. */
4987 if ((type & N_TYPE) == N_INDR)
4988 skip_next = TRUE;
4989
4990 symsec = NULL;
4991
4992 /* We need to get the value from the hash table. We use
4993 hresolve so that if we have defined an indirect
4994 symbol we output the final definition. */
4995 if (h == NULL)
4996 {
4997 switch (type & N_TYPE)
4998 {
4999 case N_SETT:
5000 symsec = obj_textsec (input_bfd);
5001 break;
5002 case N_SETD:
5003 symsec = obj_datasec (input_bfd);
5004 break;
5005 case N_SETB:
5006 symsec = obj_bsssec (input_bfd);
5007 break;
5008 case N_SETA:
5009 symsec = bfd_abs_section_ptr;
5010 break;
5011 default:
5012 val = 0;
5013 break;
5014 }
5015 }
5016 else if (hresolve->root.type == bfd_link_hash_defined
5017 || hresolve->root.type == bfd_link_hash_defweak)
252b5132 5018 {
116c20d2 5019 asection *input_section;
252b5132
RH		 5020 asection *output_section;
5021
116c20d2
NC		 5022 /* This case usually means a common symbol which was
5023 turned into a defined symbol. */
5024 input_section = hresolve->root.u.def.section;
5025 output_section = input_section->output_section;
5026 BFD_ASSERT (bfd_is_abs_section (output_section)
5027 || output_section->owner == output_bfd);
5028 val = (hresolve->root.u.def.value
5029 + bfd_get_section_vma (output_bfd, output_section)
5030 + input_section->output_offset);
5031
5032 /* Get the correct type based on the section. If
5033 this is a constructed set, force it to be
5034 globally visible. */
5035 if (type == N_SETT
5036 || type == N_SETD
5037 || type == N_SETB
5038 || type == N_SETA)
5039 type |= N_EXT;
5040
5041 type &=~ N_TYPE;
252b5132 5042
252b5132 5043 if (output_section == obj_textsec (output_bfd))
116c20d2
NC		 5044 type |= (hresolve->root.type == bfd_link_hash_defined
5045 ? N_TEXT
5046 : N_WEAKT);
252b5132 5047 else if (output_section == obj_datasec (output_bfd))
116c20d2
NC		 5048 type |= (hresolve->root.type == bfd_link_hash_defined
5049 ? N_DATA
5050 : N_WEAKD);
252b5132 5051 else if (output_section == obj_bsssec (output_bfd))
116c20d2
NC		 5052 type |= (hresolve->root.type == bfd_link_hash_defined
5053 ? N_BSS
5054 : N_WEAKB);
252b5132 5055 else
116c20d2
NC		 5056 type |= (hresolve->root.type == bfd_link_hash_defined
5057 ? N_ABS
5058 : N_WEAKA);
5059 }
5060 else if (hresolve->root.type == bfd_link_hash_common)
5061 val = hresolve->root.u.c.size;
5062 else if (hresolve->root.type == bfd_link_hash_undefweak)
5063 {
5064 val = 0;
5065 type = N_WEAKU;
252b5132
RH		 5066 }
5067 else
116c20d2
NC		 5068 val = 0;
5069 }
5070 if (symsec != NULL)
5071 val = (symsec->output_section->vma
5072 + symsec->output_offset
5073 + (GET_WORD (input_bfd, sym->e_value)
5074 - symsec->vma));
5075
5076 /* If this is a global symbol set the written flag, and if
5077 it is a local symbol see if we should discard it. */
5078 if (h != NULL)
5079 {
5080 h->written = TRUE;
5081 h->indx = obj_aout_external_sym_count (output_bfd);
5082 }
5083 else if ((type & N_TYPE) != N_SETT
5084 && (type & N_TYPE) != N_SETD
5085 && (type & N_TYPE) != N_SETB
5086 && (type & N_TYPE) != N_SETA)
5087 {
5088 switch (discard)
252b5132 5089 {
116c20d2
NC		 5090 case discard_none:
5091 case discard_sec_merge:
5092 break;
5093 case discard_l:
5094 if ((type & N_STAB) == 0
5095 && bfd_is_local_label_name (input_bfd, name))
5096 skip = TRUE;
5097 break;
5098 case discard_all:
5099 skip = TRUE;
5100 break;
5101 }
5102 if (skip)
5103 {
5104 pass = FALSE;
5105 continue;
5106 }
5107 }
252b5132 5108
116c20d2
NC		 5109 /* An N_BINCL symbol indicates the start of the stabs
5110 entries for a header file. We need to scan ahead to the
5111 next N_EINCL symbol, ignoring nesting, adding up all the
5112 characters in the symbol names, not including the file
5113 numbers in types (the first number after an open
5114 parenthesis). */
5115 if (type == (int) N_BINCL)
5116 {
5117 struct external_nlist *incl_sym;
5118 int nest;
5119 struct aout_link_includes_entry *incl_entry;
5120 struct aout_link_includes_totals *t;
5121
5122 val = 0;
5123 nest = 0;
5124 for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++)
5125 {
5126 int incl_type;
5127
5128 incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
5129 if (incl_type == (int) N_EINCL)
252b5132 5130 {
116c20d2
NC		 5131 if (nest == 0)
5132 break;
5133 --nest;
5134 }
5135 else if (incl_type == (int) N_BINCL)
5136 ++nest;
5137 else if (nest == 0)
5138 {
5139 const char *s;
5140
5141 s = strings + GET_WORD (input_bfd, incl_sym->e_strx);
5142 for (; *s != '\0'; s++)
252b5132 5143 {
116c20d2
NC		 5144 val += *s;
5145 if (*s == '(')
252b5132 5146 {
116c20d2
NC		 5147 /* Skip the file number. */
5148 ++s;
5149 while (ISDIGIT (*s))
5150 ++s;
5151 --s;
252b5132 5152 }
252b5132 5153 }
116c20d2
NC		 5154 }
5155 }
252b5132 5156
116c20d2
NC		 5157 /* If we have already included a header file with the
5158 same value, then replace this one with an N_EXCL
5159 symbol. */
57402f1e
NC		 5160 copy = (bfd_boolean) (! flaginfo->info->keep_memory);
5161 incl_entry = aout_link_includes_lookup (&flaginfo->includes,
116c20d2
NC		 5162 name, TRUE, copy);
5163 if (incl_entry == NULL)
5164 return FALSE;
5165 for (t = incl_entry->totals; t != NULL; t = t->next)
5166 if (t->total == val)
5167 break;
5168 if (t == NULL)
5169 {
5170 /* This is the first time we have seen this header
5171 file with this set of stabs strings. */
a50b1753 5172 t = (struct aout_link_includes_totals *)
57402f1e 5173 bfd_hash_allocate (&flaginfo->includes.root,
116c20d2
NC		 5174 sizeof *t);
5175 if (t == NULL)
5176 return FALSE;
5177 t->total = val;
5178 t->next = incl_entry->totals;
5179 incl_entry->totals = t;
5180 }
5181 else
5182 {
5183 int *incl_map;
5184
5185 /* This is a duplicate header file. We must change
5186 it to be an N_EXCL entry, and mark all the
5187 included symbols to prevent outputting them. */
5188 type = (int) N_EXCL;
5189
5190 nest = 0;
5191 for (incl_sym = sym + 1, incl_map = symbol_map + 1;
5192 incl_sym < sym_end;
5193 incl_sym++, incl_map++)
5194 {
5195 int incl_type;
5196
5197 incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
5198 if (incl_type == (int) N_EINCL)
5199 {
5200 if (nest == 0)
5201 {
5202 *incl_map = -1;
5203 break;
5204 }
5205 --nest;
252b5132 5206 }
116c20d2
NC		 5207 else if (incl_type == (int) N_BINCL)
5208 ++nest;
5209 else if (nest == 0)
5210 *incl_map = -1;
252b5132 5211 }
252b5132
RH		 5212 }
5213 }
116c20d2
NC		 5214 }
5215
5216 /* Copy this symbol into the list of symbols we are going to
5217 write out. */
5218 H_PUT_8 (output_bfd, type, outsym->e_type);
5219 H_PUT_8 (output_bfd, H_GET_8 (input_bfd, sym->e_other), outsym->e_other);
5220 H_PUT_16 (output_bfd, H_GET_16 (input_bfd, sym->e_desc), outsym->e_desc);
5221 copy = FALSE;
57402f1e 5222 if (! flaginfo->info->keep_memory)
116c20d2
NC		 5223 {
5224 /* name points into a string table which we are going to
5225 free. If there is a hash table entry, use that string.
5226 Otherwise, copy name into memory. */
5227 if (h != NULL)
5228 name = h->root.root.string;
252b5132 5229 else
116c20d2
NC		 5230 copy = TRUE;
5231 }
57402f1e 5232 strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
116c20d2
NC		 5233 name, copy);
5234 if (strtab_index == (bfd_size_type) -1)
5235 return FALSE;
5236 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
5237 PUT_WORD (output_bfd, val, outsym->e_value);
5238 *symbol_map = obj_aout_external_sym_count (output_bfd);
5239 ++obj_aout_external_sym_count (output_bfd);
5240 ++outsym;
5241 }
252b5132 5242
116c20d2 5243 /* Write out the output symbols we have just constructed. */
57402f1e 5244 if (outsym > flaginfo->output_syms)
116c20d2
NC		 5245 {
5246 bfd_size_type outsym_size;
252b5132 5247
57402f1e 5248 if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0)
116c20d2 5249 return FALSE;
57402f1e 5250 outsym_size = outsym - flaginfo->output_syms;
116c20d2 5251 outsym_size *= EXTERNAL_NLIST_SIZE;
57402f1e 5252 if (bfd_bwrite ((void *) flaginfo->output_syms, outsym_size, output_bfd)
116c20d2
NC		 5253 != outsym_size)
5254 return FALSE;
57402f1e 5255 flaginfo->symoff += outsym_size;
116c20d2 5256 }
252b5132 5257
116c20d2
NC		 5258 return TRUE;
5259}
252b5132 5260
116c20d2 5261/* Link an a.out input BFD into the output file. */
252b5132 5262
116c20d2 5263static bfd_boolean
57402f1e 5264aout_link_input_bfd (struct aout_final_link_info *flaginfo, bfd *input_bfd)
116c20d2 5265{
116c20d2 5266 BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
252b5132 5267
116c20d2
NC		 5268 /* If this is a dynamic object, it may need special handling. */
5269 if ((input_bfd->flags & DYNAMIC) != 0
5270 && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
5271 return ((*aout_backend_info (input_bfd)->link_dynamic_object)
57402f1e 5272 (flaginfo->info, input_bfd));
252b5132 5273
116c20d2 5274 /* Get the symbols. We probably have them already, unless
57402f1e 5275 flaginfo->info->keep_memory is FALSE. */
116c20d2
NC		 5276 if (! aout_get_external_symbols (input_bfd))
5277 return FALSE;
252b5132 5278
116c20d2 5279 /* Write out the symbols and get a map of the new indices. The map
57402f1e
NC		 5280 is placed into flaginfo->symbol_map. */
5281 if (! aout_link_write_symbols (flaginfo, input_bfd))
116c20d2 5282 return FALSE;
252b5132 5283
116c20d2
NC		 5284 /* Relocate and write out the sections. These functions use the
5285 symbol map created by aout_link_write_symbols. The linker_mark
5286 field will be set if these sections are to be included in the
5287 link, which will normally be the case. */
5288 if (obj_textsec (input_bfd)->linker_mark)
5289 {
57402f1e 5290 if (! aout_link_input_section (flaginfo, input_bfd,
116c20d2 5291 obj_textsec (input_bfd),
57402f1e 5292 &flaginfo->treloff,
116c20d2
NC		 5293 exec_hdr (input_bfd)->a_trsize))
5294 return FALSE;
5295 }
5296 if (obj_datasec (input_bfd)->linker_mark)
5297 {
57402f1e 5298 if (! aout_link_input_section (flaginfo, input_bfd,
116c20d2 5299 obj_datasec (input_bfd),
57402f1e 5300 &flaginfo->dreloff,
116c20d2
NC		 5301 exec_hdr (input_bfd)->a_drsize))
5302 return FALSE;
5303 }
5304
5305 /* If we are not keeping memory, we don't need the symbols any
5306 longer. We still need them if we are keeping memory, because the
5307 strings in the hash table point into them. */
57402f1e 5308 if (! flaginfo->info->keep_memory)
116c20d2
NC		 5309 {
5310 if (! aout_link_free_symbols (input_bfd))
5311 return FALSE;
5312 }
5313
5314 return TRUE;
5315}
5316
5317/* Do the final link step. This is called on the output BFD. The
5318 INFO structure should point to a list of BFDs linked through the
c72f2fb2 5319 link.next field which can be used to find each BFD which takes part
116c20d2
NC		 5320 in the output. Also, each section in ABFD should point to a list
5321 of bfd_link_order structures which list all the input sections for
5322 the output section. */
5323
5324bfd_boolean
5325NAME (aout, final_link) (bfd *abfd,
5326 struct bfd_link_info *info,
5327 void (*callback) (bfd *, file_ptr *, file_ptr *, file_ptr *))
5328{
5329 struct aout_final_link_info aout_info;
5330 bfd_boolean includes_hash_initialized = FALSE;
5331 bfd *sub;
5332 bfd_size_type trsize, drsize;
5333 bfd_size_type max_contents_size;
5334 bfd_size_type max_relocs_size;
5335 bfd_size_type max_sym_count;
116c20d2
NC		 5336 struct bfd_link_order *p;
5337 asection *o;
5338 bfd_boolean have_link_order_relocs;
5339
0e1862bb 5340 if (bfd_link_pic (info))
116c20d2
NC		 5341 abfd->flags |= DYNAMIC;
5342
5343 aout_info.info = info;
5344 aout_info.output_bfd = abfd;
5345 aout_info.contents = NULL;
5346 aout_info.relocs = NULL;
5347 aout_info.symbol_map = NULL;
5348 aout_info.output_syms = NULL;
252b5132 5349
66eb6687
AM		 5350 if (!bfd_hash_table_init_n (&aout_info.includes.root,
5351 aout_link_includes_newfunc,
5352 sizeof (struct aout_link_includes_entry),
5353 251))
116c20d2
NC		 5354 goto error_return;
5355 includes_hash_initialized = TRUE;
252b5132 5356
116c20d2
NC		 5357 /* Figure out the largest section size. Also, if generating
5358 relocatable output, count the relocs. */
5359 trsize = 0;
5360 drsize = 0;
5361 max_contents_size = 0;
5362 max_relocs_size = 0;
5363 max_sym_count = 0;
c72f2fb2 5364 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
116c20d2
NC		 5365 {
5366 bfd_size_type sz;
252b5132 5367
0e1862bb 5368 if (bfd_link_relocatable (info))
116c20d2
NC		 5369 {
5370 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
252b5132 5371 {
116c20d2
NC		 5372 trsize += exec_hdr (sub)->a_trsize;
5373 drsize += exec_hdr (sub)->a_drsize;
252b5132 5374 }
252b5132
RH		 5375 else
5376 {
116c20d2
NC		 5377 /* FIXME: We need to identify the .text and .data sections
5378 and call get_reloc_upper_bound and canonicalize_reloc to
5379 work out the number of relocs needed, and then multiply
5380 by the reloc size. */
4eca0228 5381 _bfd_error_handler
695344c0 5382 /* xgettext:c-format */
116c20d2
NC		 5383 (_("%s: relocatable link from %s to %s not supported"),
5384 bfd_get_filename (abfd),
5385 sub->xvec->name, abfd->xvec->name);
5386 bfd_set_error (bfd_error_invalid_operation);
5387 goto error_return;
252b5132 5388 }
116c20d2 5389 }
252b5132 5390
116c20d2
NC		 5391 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
5392 {
5393 sz = obj_textsec (sub)->size;
5394 if (sz > max_contents_size)
5395 max_contents_size = sz;
5396 sz = obj_datasec (sub)->size;
5397 if (sz > max_contents_size)
5398 max_contents_size = sz;
252b5132 5399
116c20d2
NC		 5400 sz = exec_hdr (sub)->a_trsize;
5401 if (sz > max_relocs_size)
5402 max_relocs_size = sz;
5403 sz = exec_hdr (sub)->a_drsize;
5404 if (sz > max_relocs_size)
5405 max_relocs_size = sz;
252b5132 5406
116c20d2
NC		 5407 sz = obj_aout_external_sym_count (sub);
5408 if (sz > max_sym_count)
5409 max_sym_count = sz;
252b5132
RH		 5410 }
5411 }
5412
0e1862bb 5413 if (bfd_link_relocatable (info))
116c20d2
NC		 5414 {
5415 if (obj_textsec (abfd) != NULL)
5416 trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
8423293d 5417 ->map_head.link_order)
116c20d2
NC		 5418 * obj_reloc_entry_size (abfd));
5419 if (obj_datasec (abfd) != NULL)
5420 drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
8423293d 5421 ->map_head.link_order)
116c20d2
NC		 5422 * obj_reloc_entry_size (abfd));
5423 }
252b5132 5424
116c20d2
NC		 5425 exec_hdr (abfd)->a_trsize = trsize;
5426 exec_hdr (abfd)->a_drsize = drsize;
252b5132 5427
116c20d2 5428 exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
252b5132 5429
116c20d2
NC		 5430 /* Adjust the section sizes and vmas according to the magic number.
5431 This sets a_text, a_data and a_bss in the exec_hdr and sets the
5432 filepos for each section. */
3a8c4a5b 5433 if (! NAME (aout, adjust_sizes_and_vmas) (abfd))
116c20d2 5434 goto error_return;
252b5132 5435
116c20d2
NC		 5436 /* The relocation and symbol file positions differ among a.out
5437 targets. We are passed a callback routine from the backend
5438 specific code to handle this.
5439 FIXME: At this point we do not know how much space the symbol
5440 table will require. This will not work for any (nonstandard)
5441 a.out target that needs to know the symbol table size before it
5442 can compute the relocation file positions. This may or may not
5443 be the case for the hp300hpux target, for example. */
5444 (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
5445 &aout_info.symoff);
5446 obj_textsec (abfd)->rel_filepos = aout_info.treloff;
5447 obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
5448 obj_sym_filepos (abfd) = aout_info.symoff;
252b5132 5449
116c20d2
NC		 5450 /* We keep a count of the symbols as we output them. */
5451 obj_aout_external_sym_count (abfd) = 0;
5452
5453 /* We accumulate the string table as we write out the symbols. */
5454 aout_info.strtab = _bfd_stringtab_init ();
5455 if (aout_info.strtab == NULL)
5456 goto error_return;
5457
5458 /* Allocate buffers to hold section contents and relocs. */
a50b1753 5459 aout_info.contents = (bfd_byte *) bfd_malloc (max_contents_size);
116c20d2 5460 aout_info.relocs = bfd_malloc (max_relocs_size);
c38eb2a6 5461 aout_info.symbol_map = (int *) bfd_malloc (max_sym_count * sizeof (int));
a50b1753
NC		 5462 aout_info.output_syms = (struct external_nlist *)
5463 bfd_malloc ((max_sym_count + 1) * sizeof (struct external_nlist));
116c20d2
NC		 5464 if ((aout_info.contents == NULL && max_contents_size != 0)
5465 || (aout_info.relocs == NULL && max_relocs_size != 0)
5466 || (aout_info.symbol_map == NULL && max_sym_count != 0)
5467 || aout_info.output_syms == NULL)
5468 goto error_return;
5469
5470 /* If we have a symbol named __DYNAMIC, force it out now. This is
5471 required by SunOS. Doing this here rather than in sunos.c is a
5472 hack, but it's easier than exporting everything which would be
5473 needed. */
5474 {
5475 struct aout_link_hash_entry *h;
5476
5477 h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
5478 FALSE, FALSE, FALSE);
5479 if (h != NULL)
7686d77d 5480 aout_link_write_other_symbol (&h->root.root, &aout_info);
116c20d2
NC		 5481 }
5482
5483 /* The most time efficient way to do the link would be to read all
5484 the input object files into memory and then sort out the
5485 information into the output file. Unfortunately, that will
5486 probably use too much memory. Another method would be to step
5487 through everything that composes the text section and write it
5488 out, and then everything that composes the data section and write
5489 it out, and then write out the relocs, and then write out the
5490 symbols. Unfortunately, that requires reading stuff from each
5491 input file several times, and we will not be able to keep all the
5492 input files open simultaneously, and reopening them will be slow.
5493
5494 What we do is basically process one input file at a time. We do
5495 everything we need to do with an input file once--copy over the
5496 section contents, handle the relocation information, and write
5497 out the symbols--and then we throw away the information we read
5498 from it. This approach requires a lot of lseeks of the output
5499 file, which is unfortunate but still faster than reopening a lot
5500 of files.
5501
5502 We use the output_has_begun field of the input BFDs to see
5503 whether we have already handled it. */
c72f2fb2 5504 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
116c20d2 5505 sub->output_has_begun = FALSE;
252b5132 5506
116c20d2
NC		 5507 /* Mark all sections which are to be included in the link. This
5508 will normally be every section. We need to do this so that we
5509 can identify any sections which the linker has decided to not
5510 include. */
5511 for (o = abfd->sections; o != NULL; o = o->next)
252b5132 5512 {
8423293d 5513 for (p = o->map_head.link_order; p != NULL; p = p->next)
116c20d2
NC		 5514 if (p->type == bfd_indirect_link_order)
5515 p->u.indirect.section->linker_mark = TRUE;
252b5132
RH		 5516 }
5517
116c20d2
NC		 5518 have_link_order_relocs = FALSE;
5519 for (o = abfd->sections; o != NULL; o = o->next)
252b5132 5520 {
8423293d 5521 for (p = o->map_head.link_order;
116c20d2
NC		 5522 p != NULL;
5523 p = p->next)
252b5132 5524 {
116c20d2
NC		 5525 if (p->type == bfd_indirect_link_order
5526 && (bfd_get_flavour (p->u.indirect.section->owner)
5527 == bfd_target_aout_flavour))
252b5132 5528 {
116c20d2
NC		 5529 bfd *input_bfd;
5530
5531 input_bfd = p->u.indirect.section->owner;
5532 if (! input_bfd->output_has_begun)
252b5132 5533 {
116c20d2
NC		 5534 if (! aout_link_input_bfd (&aout_info, input_bfd))
5535 goto error_return;
5536 input_bfd->output_has_begun = TRUE;
252b5132 5537 }
252b5132 5538 }
116c20d2
NC		 5539 else if (p->type == bfd_section_reloc_link_order
5540 || p->type == bfd_symbol_reloc_link_order)
5541 {
5542 /* These are handled below. */
5543 have_link_order_relocs = TRUE;
5544 }
5545 else
5546 {
5547 if (! _bfd_default_link_order (abfd, info, o, p))
5548 goto error_return;
5549 }
252b5132
RH		 5550 }
5551 }
252b5132 5552
116c20d2 5553 /* Write out any symbols that we have not already written out. */
7686d77d
AM		 5554 bfd_hash_traverse (&info->hash->table,
5555 aout_link_write_other_symbol,
5556 &aout_info);
116c20d2
NC		 5557
5558 /* Now handle any relocs we were asked to create by the linker.
5559 These did not come from any input file. We must do these after
5560 we have written out all the symbols, so that we know the symbol
5561 indices to use. */
5562 if (have_link_order_relocs)
5563 {
5564 for (o = abfd->sections; o != NULL; o = o->next)
252b5132 5565 {
8423293d 5566 for (p = o->map_head.link_order;
116c20d2
NC		 5567 p != NULL;
5568 p = p->next)
5569 {
5570 if (p->type == bfd_section_reloc_link_order
5571 || p->type == bfd_symbol_reloc_link_order)
5572 {
5573 if (! aout_link_reloc_link_order (&aout_info, o, p))
5574 goto error_return;
5575 }
5576 }
252b5132 5577 }
116c20d2 5578 }
252b5132 5579
116c20d2
NC		 5580 if (aout_info.contents != NULL)
5581 {
5582 free (aout_info.contents);
5583 aout_info.contents = NULL;
5584 }
5585 if (aout_info.relocs != NULL)
5586 {
5587 free (aout_info.relocs);
5588 aout_info.relocs = NULL;
5589 }
5590 if (aout_info.symbol_map != NULL)
5591 {
5592 free (aout_info.symbol_map);
5593 aout_info.symbol_map = NULL;
5594 }
5595 if (aout_info.output_syms != NULL)
5596 {
5597 free (aout_info.output_syms);
5598 aout_info.output_syms = NULL;
5599 }
5600 if (includes_hash_initialized)
5601 {
5602 bfd_hash_table_free (&aout_info.includes.root);
5603 includes_hash_initialized = FALSE;
5604 }
252b5132 5605
116c20d2
NC		 5606 /* Finish up any dynamic linking we may be doing. */
5607 if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
5608 {
5609 if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
5610 goto error_return;
252b5132
RH		 5611 }
5612
116c20d2
NC		 5613 /* Update the header information. */
5614 abfd->symcount = obj_aout_external_sym_count (abfd);
5615 exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
5616 obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
5617 obj_textsec (abfd)->reloc_count =
5618 exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
5619 obj_datasec (abfd)->reloc_count =
5620 exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
252b5132 5621
116c20d2 5622 /* Write out the string table, unless there are no symbols. */
f6e688f7
AM		 5623 if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0)
5624 goto error_return;
116c20d2
NC		 5625 if (abfd->symcount > 0)
5626 {
f6e688f7 5627 if (!emit_stringtab (abfd, aout_info.strtab))
116c20d2
NC		 5628 goto error_return;
5629 }
f6e688f7 5630 else
116c20d2 5631 {
f6e688f7 5632 bfd_byte b[BYTES_IN_WORD];
252b5132 5633
f6e688f7
AM		 5634 memset (b, 0, BYTES_IN_WORD);
5635 if (bfd_bwrite (b, (bfd_size_type) BYTES_IN_WORD, abfd) != BYTES_IN_WORD)
116c20d2
NC		 5636 goto error_return;
5637 }
252b5132 5638
b34976b6 5639 return TRUE;
116c20d2
NC		 5640
5641 error_return:
5642 if (aout_info.contents != NULL)
5643 free (aout_info.contents);
5644 if (aout_info.relocs != NULL)
5645 free (aout_info.relocs);
5646 if (aout_info.symbol_map != NULL)
5647 free (aout_info.symbol_map);
5648 if (aout_info.output_syms != NULL)
5649 free (aout_info.output_syms);
5650 if (includes_hash_initialized)
5651 bfd_hash_table_free (&aout_info.includes.root);
5652 return FALSE;
252b5132 5653}
A mirror of the official binutils-gdb repository