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