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