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