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