projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2007-07-27 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 1741 cached_size = obj_aout_external_sym_count (abfd);
87b32780
MS		 1742 if (cached_size == 0)
1743 return TRUE; /* Nothing to do. */
1744
dc810e39 1745 cached_size *= sizeof (aout_symbol_type);
116c20d2 1746 cached = bfd_zmalloc (cached_size);
87b32780 1747 if (cached == NULL)
b34976b6 1748 return FALSE;
252b5132
RH		 1749
1750 /* Convert from external symbol information to internal. */
116c20d2 1751 if (! (NAME (aout, translate_symbol_table)
252b5132
RH		 1752 (abfd, cached,
1753 obj_aout_external_syms (abfd),
1754 obj_aout_external_sym_count (abfd),
1755 obj_aout_external_strings (abfd),
1756 obj_aout_external_string_size (abfd),
b34976b6 1757 FALSE)))
252b5132
RH		 1758 {
1759 free (cached);
b34976b6 1760 return FALSE;
252b5132
RH		 1761 }
1762
1763 bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd);
1764
1765 obj_aout_symbols (abfd) = cached;
1766
1767 /* It is very likely that anybody who calls this function will not
1768 want the external symbol information, so if it was allocated
1769 because of our call to aout_get_external_symbols, we free it up
1770 right away to save space. */
116c20d2
NC		 1771 if (old_external_syms == NULL
1772 && obj_aout_external_syms (abfd) != NULL)
252b5132
RH		 1773 {
1774#ifdef USE_MMAP
1775 bfd_free_window (&obj_aout_sym_window (abfd));
1776#else
1777 free (obj_aout_external_syms (abfd));
1778#endif
1779 obj_aout_external_syms (abfd) = NULL;
1780 }
1781
b34976b6 1782 return TRUE;
252b5132
RH		 1783}
1784\f
1785/* We use a hash table when writing out symbols so that we only write
1786 out a particular string once. This helps particularly when the
1787 linker writes out stabs debugging entries, because each different
1788 contributing object file tends to have many duplicate stabs
1789 strings.
1790
1791 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1792 if BFD_TRADITIONAL_FORMAT is set. */
1793
252b5132
RH		 1794/* Get the index of a string in a strtab, adding it if it is not
1795 already present. */
1796
116c20d2
NC		 1797static inline bfd_size_type
1798add_to_stringtab (bfd *abfd,
1799 struct bfd_strtab_hash *tab,
1800 const char *str,
1801 bfd_boolean copy)
252b5132 1802{
b34976b6 1803 bfd_boolean hash;
252b5132
RH		 1804 bfd_size_type index;
1805
1806 /* An index of 0 always means the empty string. */
1807 if (str == 0 || *str == '\0')
1808 return 0;
1809
1810 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1811 doesn't understand a hashed string table. */
b34976b6 1812 hash = TRUE;
252b5132 1813 if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
b34976b6 1814 hash = FALSE;
252b5132
RH		 1815
1816 index = _bfd_stringtab_add (tab, str, hash, copy);
1817
1818 if (index != (bfd_size_type) -1)
116c20d2
NC		 1819 /* Add BYTES_IN_WORD to the return value to account for the
1820 space taken up by the string table size. */
1821 index += BYTES_IN_WORD;
252b5132
RH		 1822
1823 return index;
1824}
1825
1826/* Write out a strtab. ABFD is already at the right location in the
1827 file. */
1828
b34976b6 1829static bfd_boolean
116c20d2 1830emit_stringtab (bfd *abfd, struct bfd_strtab_hash *tab)
252b5132
RH		 1831{
1832 bfd_byte buffer[BYTES_IN_WORD];
dc810e39 1833 bfd_size_type amt = BYTES_IN_WORD;
252b5132
RH		 1834
1835 /* The string table starts with the size. */
1836 PUT_WORD (abfd, _bfd_stringtab_size (tab) + BYTES_IN_WORD, buffer);
116c20d2 1837 if (bfd_bwrite ((void *) buffer, amt, abfd) != amt)
b34976b6 1838 return FALSE;
252b5132
RH		 1839
1840 return _bfd_stringtab_emit (abfd, tab);
1841}
1842\f
b34976b6 1843bfd_boolean
116c20d2 1844NAME (aout, write_syms) (bfd *abfd)
252b5132
RH		 1845{
1846 unsigned int count ;
1847 asymbol **generic = bfd_get_outsymbols (abfd);
1848 struct bfd_strtab_hash *strtab;
1849
1850 strtab = _bfd_stringtab_init ();
1851 if (strtab == NULL)
b34976b6 1852 return FALSE;
252b5132
RH		 1853
1854 for (count = 0; count < bfd_get_symcount (abfd); count++)
1855 {
1856 asymbol *g = generic[count];
1857 bfd_size_type indx;
1858 struct external_nlist nsp;
dc810e39 1859 bfd_size_type amt;
252b5132 1860
b34976b6 1861 indx = add_to_stringtab (abfd, strtab, g->name, FALSE);
252b5132
RH		 1862 if (indx == (bfd_size_type) -1)
1863 goto error_return;
1864 PUT_WORD (abfd, indx, (bfd_byte *) nsp.e_strx);
1865
923f08ff 1866 if (bfd_asymbol_flavour (g) == abfd->xvec->flavour)
252b5132 1867 {
923f08ff
AM		 1868 H_PUT_16 (abfd, aout_symbol (g)->desc, nsp.e_desc);
1869 H_PUT_8 (abfd, aout_symbol (g)->other, nsp.e_other);
1870 H_PUT_8 (abfd, aout_symbol (g)->type, nsp.e_type);
252b5132
RH		 1871 }
1872 else
1873 {
dc810e39
AM		 1874 H_PUT_16 (abfd, 0, nsp.e_desc);
1875 H_PUT_8 (abfd, 0, nsp.e_other);
1876 H_PUT_8 (abfd, 0, nsp.e_type);
252b5132
RH		 1877 }
1878
1879 if (! translate_to_native_sym_flags (abfd, g, &nsp))
1880 goto error_return;
1881
dc810e39 1882 amt = EXTERNAL_NLIST_SIZE;
116c20d2 1883 if (bfd_bwrite ((void *) &nsp, amt, abfd) != amt)
252b5132
RH		 1884 goto error_return;
1885
1886 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1887 here, at the end. */
1888 g->KEEPIT = count;
1889 }
1890
1891 if (! emit_stringtab (abfd, strtab))
1892 goto error_return;
1893
1894 _bfd_stringtab_free (strtab);
1895
b34976b6 1896 return TRUE;
252b5132
RH		 1897
1898error_return:
1899 _bfd_stringtab_free (strtab);
b34976b6 1900 return FALSE;
252b5132 1901}
252b5132
RH		 1902\f
1903long
116c20d2 1904NAME (aout, canonicalize_symtab) (bfd *abfd, asymbol **location)
252b5132 1905{
116c20d2
NC		 1906 unsigned int counter = 0;
1907 aout_symbol_type *symbase;
252b5132 1908
116c20d2
NC		 1909 if (!NAME (aout, slurp_symbol_table) (abfd))
1910 return -1;
252b5132 1911
116c20d2
NC		 1912 for (symbase = obj_aout_symbols (abfd);
1913 counter++ < bfd_get_symcount (abfd);
1914 )
1915 *(location++) = (asymbol *) (symbase++);
1916 *location++ =0;
1917 return bfd_get_symcount (abfd);
252b5132 1918}
252b5132 1919\f
f7c33884 1920/* Standard reloc stuff. */
0ef5a5bd 1921/* Output standard relocation information to a file in target byte order. */
252b5132 1922
116c20d2
NC		 1923extern void NAME (aout, swap_std_reloc_out)
1924 (bfd *, arelent *, struct reloc_std_external *);
252b5132
RH		 1925
1926void
116c20d2
NC		 1927NAME (aout, swap_std_reloc_out) (bfd *abfd,
1928 arelent *g,
1929 struct reloc_std_external *natptr)
252b5132
RH		 1930{
1931 int r_index;
1932 asymbol *sym = *(g->sym_ptr_ptr);
1933 int r_extern;
1934 unsigned int r_length;
1935 int r_pcrel;
1936 int r_baserel, r_jmptable, r_relative;
1937 asection *output_section = sym->section->output_section;
1938
923f08ff 1939 PUT_WORD (abfd, g->address, natptr->r_address);
252b5132 1940
f7c33884
NC		 1941 r_length = g->howto->size ; /* Size as a power of two. */
1942 r_pcrel = (int) g->howto->pc_relative; /* Relative to PC? */
252b5132
RH		 1943 /* XXX This relies on relocs coming from a.out files. */
1944 r_baserel = (g->howto->type & 8) != 0;
1945 r_jmptable = (g->howto->type & 16) != 0;
1946 r_relative = (g->howto->type & 32) != 0;
1947
f7c33884 1948 /* Name was clobbered by aout_write_syms to be symbol index. */
252b5132
RH		 1949
1950 /* If this relocation is relative to a symbol then set the
1951 r_index to the symbols index, and the r_extern bit.
1952
1953 Absolute symbols can come in in two ways, either as an offset
1954 from the abs section, or as a symbol which has an abs value.
f7c33884 1955 check for that here. */
252b5132 1956
252b5132
RH		 1957 if (bfd_is_com_section (output_section)
1958 || bfd_is_abs_section (output_section)
22184a77
NC		 1959 || bfd_is_und_section (output_section)
1960 /* PR gas/3041 a.out relocs against weak symbols
1961 must be treated as if they were against externs. */
1962 || (sym->flags & BSF_WEAK))
252b5132
RH		 1963 {
1964 if (bfd_abs_section_ptr->symbol == sym)
f7c33884
NC		 1965 {
1966 /* Whoops, looked like an abs symbol, but is
1967 really an offset from the abs section. */
1968 r_index = N_ABS;
1969 r_extern = 0;
1970 }
252b5132 1971 else
f7c33884
NC		 1972 {
1973 /* Fill in symbol. */
1974 r_extern = 1;
1975 r_index = (*(g->sym_ptr_ptr))->KEEPIT;
1976 }
252b5132
RH		 1977 }
1978 else
1979 {
f7c33884 1980 /* Just an ordinary section. */
252b5132
RH		 1981 r_extern = 0;
1982 r_index = output_section->target_index;
1983 }
1984
f7c33884 1985 /* Now the fun stuff. */
923f08ff
AM		 1986 if (bfd_header_big_endian (abfd))
1987 {
252b5132
RH		 1988 natptr->r_index[0] = r_index >> 16;
1989 natptr->r_index[1] = r_index >> 8;
1990 natptr->r_index[2] = r_index;
923f08ff
AM		 1991 natptr->r_type[0] = ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
1992 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
1993 | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
1994 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
1995 | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
1996 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
1997 }
1998 else
1999 {
2000 natptr->r_index[2] = r_index >> 16;
2001 natptr->r_index[1] = r_index >> 8;
2002 natptr->r_index[0] = r_index;
2003 natptr->r_type[0] = ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
2004 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
2005 | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
2006 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
2007 | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
2008 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
2009 }
252b5132
RH		 2010}
2011
f7c33884 2012/* Extended stuff. */
0ef5a5bd 2013/* Output extended relocation information to a file in target byte order. */
252b5132 2014
116c20d2
NC		 2015extern void NAME (aout, swap_ext_reloc_out)
2016 (bfd *, arelent *, struct reloc_ext_external *);
252b5132
RH		 2017
2018void
116c20d2
NC		 2019NAME (aout, swap_ext_reloc_out) (bfd *abfd,
2020 arelent *g,
2021 struct reloc_ext_external *natptr)
252b5132
RH		 2022{
2023 int r_index;
2024 int r_extern;
2025 unsigned int r_type;
dc810e39 2026 bfd_vma r_addend;
252b5132
RH		 2027 asymbol *sym = *(g->sym_ptr_ptr);
2028 asection *output_section = sym->section->output_section;
2029
2030 PUT_WORD (abfd, g->address, natptr->r_address);
2031
2032 r_type = (unsigned int) g->howto->type;
2033
2034 r_addend = g->addend;
2035 if ((sym->flags & BSF_SECTION_SYM) != 0)
2036 r_addend += (*(g->sym_ptr_ptr))->section->output_section->vma;
2037
2038 /* If this relocation is relative to a symbol then set the
2039 r_index to the symbols index, and the r_extern bit.
2040
2041 Absolute symbols can come in in two ways, either as an offset
2042 from the abs section, or as a symbol which has an abs value.
2043 check for that here. */
252b5132
RH		 2044 if (bfd_is_abs_section (bfd_get_section (sym)))
2045 {
2046 r_extern = 0;
2047 r_index = N_ABS;
2048 }
2049 else if ((sym->flags & BSF_SECTION_SYM) == 0)
2050 {
2051 if (bfd_is_und_section (bfd_get_section (sym))
2052 || (sym->flags & BSF_GLOBAL) != 0)
2053 r_extern = 1;
2054 else
2055 r_extern = 0;
2056 r_index = (*(g->sym_ptr_ptr))->KEEPIT;
2057 }
2058 else
2059 {
f7c33884 2060 /* Just an ordinary section. */
252b5132
RH		 2061 r_extern = 0;
2062 r_index = output_section->target_index;
2063 }
2064
f7c33884 2065 /* Now the fun stuff. */
923f08ff
AM		 2066 if (bfd_header_big_endian (abfd))
2067 {
2068 natptr->r_index[0] = r_index >> 16;
2069 natptr->r_index[1] = r_index >> 8;
2070 natptr->r_index[2] = r_index;
2071 natptr->r_type[0] = ((r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
2072 | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG));
2073 }
2074 else
2075 {
2076 natptr->r_index[2] = r_index >> 16;
2077 natptr->r_index[1] = r_index >> 8;
2078 natptr->r_index[0] = r_index;
2079 natptr->r_type[0] = ((r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
2080 | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE));
2081 }
252b5132
RH		 2082
2083 PUT_WORD (abfd, r_addend, natptr->r_addend);
2084}
2085
2086/* BFD deals internally with all things based from the section they're
2087 in. so, something in 10 bytes into a text section with a base of
2088 50 would have a symbol (.text+10) and know .text vma was 50.
2089
2090 Aout keeps all it's symbols based from zero, so the symbol would
2091 contain 60. This macro subs the base of each section from the value
923f08ff
AM		 2092 to give the true offset from the section. */
2093
2094#define MOVE_ADDRESS(ad) \
2095 if (r_extern) \
2096 { \
2097 /* Undefined symbol. */ \
2098 cache_ptr->sym_ptr_ptr = symbols + r_index; \
252b5132 2099 cache_ptr->addend = ad; \
252b5132 2100 } \
923f08ff
AM		 2101 else \
2102 { \
2103 /* Defined, section relative. Replace symbol with pointer to \
2104 symbol which points to section. */ \
2105 switch (r_index) \
2106 { \
2107 case N_TEXT: \
2108 case N_TEXT | N_EXT: \
2109 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
2110 cache_ptr->addend = ad - su->textsec->vma; \
2111 break; \
2112 case N_DATA: \
2113 case N_DATA | N_EXT: \
2114 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
2115 cache_ptr->addend = ad - su->datasec->vma; \
2116 break; \
2117 case N_BSS: \
2118 case N_BSS | N_EXT: \
2119 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
2120 cache_ptr->addend = ad - su->bsssec->vma; \
2121 break; \
2122 default: \
2123 case N_ABS: \
2124 case N_ABS | N_EXT: \
2125 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
2126 cache_ptr->addend = ad; \
2127 break; \
2128 } \
2129 }
252b5132
RH		 2130
2131void
116c20d2
NC		 2132NAME (aout, swap_ext_reloc_in) (bfd *abfd,
2133 struct reloc_ext_external *bytes,
2134 arelent *cache_ptr,
2135 asymbol **symbols,
2136 bfd_size_type symcount)
252b5132
RH		 2137{
2138 unsigned int r_index;
2139 int r_extern;
2140 unsigned int r_type;
2141 struct aoutdata *su = &(abfd->tdata.aout_data->a);
2142
2143 cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));
2144
f7c33884 2145 /* Now the fun stuff. */
923f08ff
AM		 2146 if (bfd_header_big_endian (abfd))
2147 {
d45913a0
DA		 2148 r_index = (((unsigned int) bytes->r_index[0] << 16)
2149 | ((unsigned int) bytes->r_index[1] << 8)
923f08ff
AM		 2150 | bytes->r_index[2]);
2151 r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
2152 r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
2153 >> RELOC_EXT_BITS_TYPE_SH_BIG);
2154 }
2155 else
2156 {
d45913a0
DA		 2157 r_index = (((unsigned int) bytes->r_index[2] << 16)
2158 | ((unsigned int) bytes->r_index[1] << 8)
923f08ff
AM		 2159 | bytes->r_index[0]);
2160 r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
2161 r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
2162 >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
2163 }
252b5132
RH		 2164
2165 cache_ptr->howto = howto_table_ext + r_type;
2166
2167 /* Base relative relocs are always against the symbol table,
2168 regardless of the setting of r_extern. r_extern just reflects
2169 whether the symbol the reloc is against is local or global. */
d45913a0
DA		 2170 if (r_type == (unsigned int) RELOC_BASE10
2171 || r_type == (unsigned int) RELOC_BASE13
2172 || r_type == (unsigned int) RELOC_BASE22)
252b5132
RH		 2173 r_extern = 1;
2174
2175 if (r_extern && r_index > symcount)
2176 {
2177 /* We could arrange to return an error, but it might be useful
2178 to see the file even if it is bad. */
2179 r_extern = 0;
2180 r_index = N_ABS;
2181 }
2182
923f08ff 2183 MOVE_ADDRESS (GET_SWORD (abfd, bytes->r_addend));
252b5132
RH		 2184}
2185
2186void
116c20d2
NC		 2187NAME (aout, swap_std_reloc_in) (bfd *abfd,
2188 struct reloc_std_external *bytes,
2189 arelent *cache_ptr,
2190 asymbol **symbols,
2191 bfd_size_type symcount)
252b5132
RH		 2192{
2193 unsigned int r_index;
2194 int r_extern;
2195 unsigned int r_length;
2196 int r_pcrel;
2197 int r_baserel, r_jmptable, r_relative;
2198 struct aoutdata *su = &(abfd->tdata.aout_data->a);
2199 unsigned int howto_idx;
2200
dc810e39 2201 cache_ptr->address = H_GET_32 (abfd, bytes->r_address);
252b5132 2202
f7c33884 2203 /* Now the fun stuff. */
923f08ff
AM		 2204 if (bfd_header_big_endian (abfd))
2205 {
d45913a0
DA		 2206 r_index = (((unsigned int) bytes->r_index[0] << 16)
2207 | ((unsigned int) bytes->r_index[1] << 8)
923f08ff
AM		 2208 | bytes->r_index[2]);
2209 r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
2210 r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
2211 r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
2212 r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
2213 r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
2214 r_length = ((bytes->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
2215 >> RELOC_STD_BITS_LENGTH_SH_BIG);
2216 }
2217 else
2218 {
d45913a0
DA		 2219 r_index = (((unsigned int) bytes->r_index[2] << 16)
2220 | ((unsigned int) bytes->r_index[1] << 8)
923f08ff
AM		 2221 | bytes->r_index[0]);
2222 r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
2223 r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
2224 r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE));
2225 r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
2226 r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_LITTLE));
2227 r_length = ((bytes->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
2228 >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
2229 }
252b5132 2230
923f08ff
AM		 2231 howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel
2232 + 16 * r_jmptable + 32 * r_relative);
252b5132
RH		 2233 BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_std));
2234 cache_ptr->howto = howto_table_std + howto_idx;
2235 BFD_ASSERT (cache_ptr->howto->type != (unsigned int) -1);
2236
2237 /* Base relative relocs are always against the symbol table,
2238 regardless of the setting of r_extern. r_extern just reflects
2239 whether the symbol the reloc is against is local or global. */
2240 if (r_baserel)
2241 r_extern = 1;
2242
2243 if (r_extern && r_index > symcount)
2244 {
2245 /* We could arrange to return an error, but it might be useful
2246 to see the file even if it is bad. */
2247 r_extern = 0;
2248 r_index = N_ABS;
2249 }
2250
923f08ff 2251 MOVE_ADDRESS (0);
252b5132
RH		 2252}
2253
2254/* Read and swap the relocs for a section. */
2255
b34976b6 2256bfd_boolean
116c20d2 2257NAME (aout, slurp_reloc_table) (bfd *abfd, sec_ptr asect, asymbol **symbols)
252b5132 2258{
dc810e39 2259 bfd_size_type count;
252b5132 2260 bfd_size_type reloc_size;
116c20d2 2261 void * relocs;
252b5132
RH		 2262 arelent *reloc_cache;
2263 size_t each_size;
2264 unsigned int counter = 0;
2265 arelent *cache_ptr;
dc810e39 2266 bfd_size_type amt;
252b5132
RH		 2267
2268 if (asect->relocation)
b34976b6 2269 return TRUE;
252b5132
RH		 2270
2271 if (asect->flags & SEC_CONSTRUCTOR)
b34976b6 2272 return TRUE;
252b5132
RH		 2273
2274 if (asect == obj_datasec (abfd))
923f08ff 2275 reloc_size = exec_hdr (abfd)->a_drsize;
252b5132 2276 else if (asect == obj_textsec (abfd))
923f08ff 2277 reloc_size = exec_hdr (abfd)->a_trsize;
252b5132
RH		 2278 else if (asect == obj_bsssec (abfd))
2279 reloc_size = 0;
2280 else
2281 {
2282 bfd_set_error (bfd_error_invalid_operation);
b34976b6 2283 return FALSE;
252b5132
RH		 2284 }
2285
078c4bfc
MS		 2286 if (reloc_size == 0)
2287 return TRUE; /* Nothing to be done. */
2288
252b5132 2289 if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
b34976b6 2290 return FALSE;
252b5132
RH		 2291
2292 each_size = obj_reloc_entry_size (abfd);
2293
2294 count = reloc_size / each_size;
078c4bfc
MS		 2295 if (count == 0)
2296 return TRUE; /* Nothing to be done. */
252b5132 2297
dc810e39 2298 amt = count * sizeof (arelent);
116c20d2 2299 reloc_cache = bfd_zmalloc (amt);
078c4bfc 2300 if (reloc_cache == NULL)
b34976b6 2301 return FALSE;
252b5132 2302
dc810e39 2303 relocs = bfd_malloc (reloc_size);
078c4bfc 2304 if (relocs == NULL)
252b5132
RH		 2305 {
2306 free (reloc_cache);
b34976b6 2307 return FALSE;
252b5132
RH		 2308 }
2309
dc810e39 2310 if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
252b5132
RH		 2311 {
2312 free (relocs);
2313 free (reloc_cache);
b34976b6 2314 return FALSE;
252b5132
RH		 2315 }
2316
2317 cache_ptr = reloc_cache;
2318 if (each_size == RELOC_EXT_SIZE)
2319 {
dc810e39 2320 struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs;
252b5132
RH		 2321
2322 for (; counter < count; counter++, rptr++, cache_ptr++)
1642229e 2323 MY_swap_ext_reloc_in (abfd, rptr, cache_ptr, symbols,
dc810e39 2324 (bfd_size_type) bfd_get_symcount (abfd));
252b5132
RH		 2325 }
2326 else
2327 {
dc810e39 2328 struct reloc_std_external *rptr = (struct reloc_std_external *) relocs;
252b5132
RH		 2329
2330 for (; counter < count; counter++, rptr++, cache_ptr++)
2331 MY_swap_std_reloc_in (abfd, rptr, cache_ptr, symbols,
dc810e39 2332 (bfd_size_type) bfd_get_symcount (abfd));
252b5132
RH		 2333 }
2334
2335 free (relocs);
2336
2337 asect->relocation = reloc_cache;
2338 asect->reloc_count = cache_ptr - reloc_cache;
2339
b34976b6 2340 return TRUE;
252b5132
RH		 2341}
2342
2343/* Write out a relocation section into an object file. */
2344
b34976b6 2345bfd_boolean
116c20d2 2346NAME (aout, squirt_out_relocs) (bfd *abfd, asection *section)
252b5132
RH		 2347{
2348 arelent **generic;
2349 unsigned char *native, *natptr;
2350 size_t each_size;
2351
2352 unsigned int count = section->reloc_count;
dc810e39 2353 bfd_size_type natsize;
252b5132
RH		 2354
2355 if (count == 0 || section->orelocation == NULL)
b34976b6 2356 return TRUE;
252b5132
RH		 2357
2358 each_size = obj_reloc_entry_size (abfd);
dc810e39 2359 natsize = (bfd_size_type) each_size * count;
116c20d2 2360 native = bfd_zalloc (abfd, natsize);
252b5132 2361 if (!native)
b34976b6 2362 return FALSE;
252b5132
RH		 2363
2364 generic = section->orelocation;
2365
2366 if (each_size == RELOC_EXT_SIZE)
2367 {
2368 for (natptr = native;
2369 count != 0;
2370 --count, natptr += each_size, ++generic)
1642229e
HPN		 2371 MY_swap_ext_reloc_out (abfd, *generic,
2372 (struct reloc_ext_external *) natptr);
252b5132
RH		 2373 }
2374 else
2375 {
2376 for (natptr = native;
2377 count != 0;
2378 --count, natptr += each_size, ++generic)
923f08ff
AM		 2379 MY_swap_std_reloc_out (abfd, *generic,
2380 (struct reloc_std_external *) natptr);
252b5132
RH		 2381 }
2382
116c20d2 2383 if (bfd_bwrite ((void *) native, natsize, abfd) != natsize)
dc810e39 2384 {
923f08ff 2385 bfd_release (abfd, native);
b34976b6 2386 return FALSE;
dc810e39 2387 }
252b5132
RH		 2388 bfd_release (abfd, native);
2389
b34976b6 2390 return TRUE;
252b5132
RH		 2391}
2392
f7c33884
NC		 2393/* This is stupid. This function should be a boolean predicate. */
2394
252b5132 2395long
116c20d2
NC		 2396NAME (aout, canonicalize_reloc) (bfd *abfd,
2397 sec_ptr section,
2398 arelent **relptr,
2399 asymbol **symbols)
252b5132
RH		 2400{
2401 arelent *tblptr = section->relocation;
2402 unsigned int count;
2403
2404 if (section == obj_bsssec (abfd))
2405 {
2406 *relptr = NULL;
2407 return 0;
2408 }
2409
116c20d2 2410 if (!(tblptr || NAME (aout, slurp_reloc_table) (abfd, section, symbols)))
252b5132
RH		 2411 return -1;
2412
923f08ff
AM		 2413 if (section->flags & SEC_CONSTRUCTOR)
2414 {
2415 arelent_chain *chain = section->constructor_chain;
2416 for (count = 0; count < section->reloc_count; count ++)
2417 {
2418 *relptr ++ = &chain->relent;
2419 chain = chain->next;
2420 }
252b5132 2421 }
923f08ff
AM		 2422 else
2423 {
2424 tblptr = section->relocation;
252b5132 2425
923f08ff
AM		 2426 for (count = 0; count++ < section->reloc_count; )
2427 {
2428 *relptr++ = tblptr++;
2429 }
2430 }
252b5132
RH		 2431 *relptr = 0;
2432
2433 return section->reloc_count;
2434}
2435
2436long
116c20d2 2437NAME (aout, get_reloc_upper_bound) (bfd *abfd, sec_ptr asect)
252b5132 2438{
923f08ff
AM		 2439 if (bfd_get_format (abfd) != bfd_object)
2440 {
2441 bfd_set_error (bfd_error_invalid_operation);
2442 return -1;
2443 }
f7c33884 2444
923f08ff 2445 if (asect->flags & SEC_CONSTRUCTOR)
116c20d2 2446 return sizeof (arelent *) * (asect->reloc_count + 1);
252b5132
RH		 2447
2448 if (asect == obj_datasec (abfd))
116c20d2
NC		 2449 return sizeof (arelent *)
2450 * ((exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd))
2451 + 1);
252b5132
RH		 2452
2453 if (asect == obj_textsec (abfd))
116c20d2
NC		 2454 return sizeof (arelent *)
2455 * ((exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd))
2456 + 1);
252b5132
RH		 2457
2458 if (asect == obj_bsssec (abfd))
2459 return sizeof (arelent *);
2460
2461 if (asect == obj_bsssec (abfd))
2462 return 0;
2463
2464 bfd_set_error (bfd_error_invalid_operation);
2465 return -1;
2466}
252b5132
RH		 2467\f
2468long
116c20d2 2469NAME (aout, get_symtab_upper_bound) (bfd *abfd)
252b5132 2470{
116c20d2 2471 if (!NAME (aout, slurp_symbol_table) (abfd))
252b5132
RH		 2472 return -1;
2473
2474 return (bfd_get_symcount (abfd)+1) * (sizeof (aout_symbol_type *));
2475}
2476
1725a96e 2477alent *
116c20d2
NC		 2478NAME (aout, get_lineno) (bfd *ignore_abfd ATTRIBUTE_UNUSED,
2479 asymbol *ignore_symbol ATTRIBUTE_UNUSED)
252b5132 2480{
116c20d2 2481 return NULL;
252b5132
RH		 2482}
2483
252b5132 2484void
116c20d2
NC		 2485NAME (aout, get_symbol_info) (bfd *ignore_abfd ATTRIBUTE_UNUSED,
2486 asymbol *symbol,
2487 symbol_info *ret)
252b5132
RH		 2488{
2489 bfd_symbol_info (symbol, ret);
2490
2491 if (ret->type == '?')
2492 {
923f08ff 2493 int type_code = aout_symbol (symbol)->type & 0xff;
252b5132
RH		 2494 const char *stab_name = bfd_get_stab_name (type_code);
2495 static char buf[10];
2496
2497 if (stab_name == NULL)
2498 {
e60b52c6 2499 sprintf (buf, "(%d)", type_code);
252b5132
RH		 2500 stab_name = buf;
2501 }
2502 ret->type = '-';
2503 ret->stab_type = type_code;
923f08ff
AM		 2504 ret->stab_other = (unsigned) (aout_symbol (symbol)->other & 0xff);
2505 ret->stab_desc = (unsigned) (aout_symbol (symbol)->desc & 0xffff);
252b5132
RH		 2506 ret->stab_name = stab_name;
2507 }
2508}
2509
252b5132 2510void
116c20d2
NC		 2511NAME (aout, print_symbol) (bfd *abfd,
2512 void * afile,
2513 asymbol *symbol,
2514 bfd_print_symbol_type how)
252b5132
RH		 2515{
2516 FILE *file = (FILE *)afile;
2517
923f08ff 2518 switch (how)
252b5132 2519 {
923f08ff
AM		 2520 case bfd_print_symbol_name:
2521 if (symbol->name)
2522 fprintf (file,"%s", symbol->name);
2523 break;
2524 case bfd_print_symbol_more:
2525 fprintf (file,"%4x %2x %2x",
2526 (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2527 (unsigned) (aout_symbol (symbol)->other & 0xff),
2528 (unsigned) (aout_symbol (symbol)->type));
2529 break;
2530 case bfd_print_symbol_all:
2531 {
2532 const char *section_name = symbol->section->name;
252b5132 2533
116c20d2 2534 bfd_print_symbol_vandf (abfd, (void *)file, symbol);
252b5132 2535
923f08ff
AM		 2536 fprintf (file," %-5s %04x %02x %02x",
2537 section_name,
2538 (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2539 (unsigned) (aout_symbol (symbol)->other & 0xff),
2540 (unsigned) (aout_symbol (symbol)->type & 0xff));
2541 if (symbol->name)
2542 fprintf (file," %s", symbol->name);
2543 }
2544 break;
252b5132 2545 }
252b5132
RH		 2546}
2547
2548/* If we don't have to allocate more than 1MB to hold the generic
2549 symbols, we use the generic minisymbol methord: it's faster, since
2550 it only translates the symbols once, not multiple times. */
2551#define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2552
2553/* Read minisymbols. For minisymbols, we use the unmodified a.out
2554 symbols. The minisymbol_to_symbol function translates these into
2555 BFD asymbol structures. */
2556
2557long
116c20d2
NC		 2558NAME (aout, read_minisymbols) (bfd *abfd,
2559 bfd_boolean dynamic,
2560 void * *minisymsp,
2561 unsigned int *sizep)
252b5132
RH		 2562{
2563 if (dynamic)
116c20d2
NC		 2564 /* We could handle the dynamic symbols here as well, but it's
2565 easier to hand them off. */
2566 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
252b5132
RH		 2567
2568 if (! aout_get_external_symbols (abfd))
2569 return -1;
2570
2571 if (obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2572 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2573
116c20d2 2574 *minisymsp = (void *) obj_aout_external_syms (abfd);
252b5132
RH		 2575
2576 /* By passing the external symbols back from this routine, we are
2577 giving up control over the memory block. Clear
2578 obj_aout_external_syms, so that we do not try to free it
2579 ourselves. */
2580 obj_aout_external_syms (abfd) = NULL;
2581
2582 *sizep = EXTERNAL_NLIST_SIZE;
2583 return obj_aout_external_sym_count (abfd);
2584}
2585
2586/* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2587 unmodified a.out symbol. The SYM argument is a structure returned
2588 by bfd_make_empty_symbol, which we fill in here. */
2589
2590asymbol *
116c20d2
NC		 2591NAME (aout, minisymbol_to_symbol) (bfd *abfd,
2592 bfd_boolean dynamic,
2593 const void * minisym,
2594 asymbol *sym)
252b5132
RH		 2595{
2596 if (dynamic
2597 || obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2598 return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
2599
2600 memset (sym, 0, sizeof (aout_symbol_type));
2601
2602 /* We call translate_symbol_table to translate a single symbol. */
116c20d2 2603 if (! (NAME (aout, translate_symbol_table)
252b5132
RH		 2604 (abfd,
2605 (aout_symbol_type *) sym,
2606 (struct external_nlist *) minisym,
2607 (bfd_size_type) 1,
2608 obj_aout_external_strings (abfd),
2609 obj_aout_external_string_size (abfd),
b34976b6 2610 FALSE)))
252b5132
RH		 2611 return NULL;
2612
2613 return sym;
2614}
2615
f7c33884
NC		 2616/* Provided a BFD, a section and an offset into the section, calculate
2617 and return the name of the source file and the line nearest to the
2618 wanted location. */
252b5132 2619
b34976b6 2620bfd_boolean
116c20d2
NC		 2621NAME (aout, find_nearest_line) (bfd *abfd,
2622 asection *section,
2623 asymbol **symbols,
2624 bfd_vma offset,
2625 const char **filename_ptr,
2626 const char **functionname_ptr,
2627 unsigned int *line_ptr)
252b5132 2628{
f7c33884 2629 /* Run down the file looking for the filename, function and linenumber. */
252b5132 2630 asymbol **p;
dc810e39
AM		 2631 const char *directory_name = NULL;
2632 const char *main_file_name = NULL;
2633 const char *current_file_name = NULL;
116c20d2 2634 const char *line_file_name = NULL; /* Value of current_file_name at line number. */
dc810e39 2635 const char *line_directory_name = NULL; /* Value of directory_name at line number. */
252b5132
RH		 2636 bfd_vma low_line_vma = 0;
2637 bfd_vma low_func_vma = 0;
2638 asymbol *func = 0;
dc810e39 2639 bfd_size_type filelen, funclen;
252b5132
RH		 2640 char *buf;
2641
2642 *filename_ptr = abfd->filename;
2643 *functionname_ptr = 0;
2644 *line_ptr = 0;
f7c33884 2645
116c20d2 2646 if (symbols != NULL)
923f08ff
AM		 2647 {
2648 for (p = symbols; *p; p++)
2649 {
2650 aout_symbol_type *q = (aout_symbol_type *) (*p);
2651 next:
2652 switch (q->type)
2653 {
2654 case N_TEXT:
2655 /* If this looks like a file name symbol, and it comes after
2656 the line number we have found so far, but before the
2657 offset, then we have probably not found the right line
2658 number. */
2659 if (q->symbol.value <= offset
2660 && ((q->symbol.value > low_line_vma
2661 && (line_file_name != NULL
2662 || *line_ptr != 0))
2663 || (q->symbol.value > low_func_vma
2664 && func != NULL)))
2665 {
2666 const char *symname;
252b5132 2667
923f08ff
AM		 2668 symname = q->symbol.name;
2669 if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
2670 {
2671 if (q->symbol.value > low_line_vma)
2672 {
2673 *line_ptr = 0;
2674 line_file_name = NULL;
2675 }
2676 if (q->symbol.value > low_func_vma)
2677 func = NULL;
2678 }
2679 }
2680 break;
252b5132 2681
923f08ff
AM		 2682 case N_SO:
2683 /* If this symbol is less than the offset, but greater than
2684 the line number we have found so far, then we have not
2685 found the right line number. */
2686 if (q->symbol.value <= offset)
2687 {
2688 if (q->symbol.value > low_line_vma)
2689 {
2690 *line_ptr = 0;
2691 line_file_name = NULL;
2692 }
2693 if (q->symbol.value > low_func_vma)
2694 func = NULL;
2695 }
252b5132 2696
923f08ff
AM		 2697 main_file_name = current_file_name = q->symbol.name;
2698 /* Look ahead to next symbol to check if that too is an N_SO. */
2699 p++;
2700 if (*p == NULL)
c3864421 2701 goto done;
923f08ff
AM		 2702 q = (aout_symbol_type *) (*p);
2703 if (q->type != (int)N_SO)
2704 goto next;
2705
2706 /* Found a second N_SO First is directory; second is filename. */
2707 directory_name = current_file_name;
2708 main_file_name = current_file_name = q->symbol.name;
2709 if (obj_textsec (abfd) != section)
2710 goto done;
2711 break;
2712 case N_SOL:
2713 current_file_name = q->symbol.name;
2714 break;
252b5132 2715
923f08ff 2716 case N_SLINE:
252b5132 2717
923f08ff
AM		 2718 case N_DSLINE:
2719 case N_BSLINE:
2720 /* We'll keep this if it resolves nearer than the one we have
2721 already. */
2722 if (q->symbol.value >= low_line_vma
2723 && q->symbol.value <= offset)
2724 {
2725 *line_ptr = q->desc;
2726 low_line_vma = q->symbol.value;
2727 line_file_name = current_file_name;
2728 line_directory_name = directory_name;
2729 }
2730 break;
2731 case N_FUN:
2732 {
f7c33884 2733 /* We'll keep this if it is nearer than the one we have already. */
923f08ff 2734 if (q->symbol.value >= low_func_vma &&
f7c33884
NC		 2735 q->symbol.value <= offset)
2736 {
2737 low_func_vma = q->symbol.value;
2738 func = (asymbol *)q;
2739 }
923f08ff
AM		 2740 else if (q->symbol.value > offset)
2741 goto done;
2742 }
2743 break;
2744 }
252b5132 2745 }
252b5132 2746 }
252b5132
RH		 2747
2748 done:
2749 if (*line_ptr != 0)
2750 {
2751 main_file_name = line_file_name;
2752 directory_name = line_directory_name;
2753 }
2754
2755 if (main_file_name == NULL
5af11cab 2756 || IS_ABSOLUTE_PATH (main_file_name)
252b5132
RH		 2757 || directory_name == NULL)
2758 filelen = 0;
2759 else
2760 filelen = strlen (directory_name) + strlen (main_file_name);
f7c33884 2761
252b5132
RH		 2762 if (func == NULL)
2763 funclen = 0;
2764 else
2765 funclen = strlen (bfd_asymbol_name (func));
2766
2767 if (adata (abfd).line_buf != NULL)
2768 free (adata (abfd).line_buf);
f7c33884 2769
252b5132
RH		 2770 if (filelen + funclen == 0)
2771 adata (abfd).line_buf = buf = NULL;
2772 else
2773 {
116c20d2 2774 buf = bfd_malloc (filelen + funclen + 3);
252b5132
RH		 2775 adata (abfd).line_buf = buf;
2776 if (buf == NULL)
b34976b6 2777 return FALSE;
252b5132
RH		 2778 }
2779
2780 if (main_file_name != NULL)
2781 {
5af11cab 2782 if (IS_ABSOLUTE_PATH (main_file_name) || directory_name == NULL)
252b5132
RH		 2783 *filename_ptr = main_file_name;
2784 else
2785 {
2786 sprintf (buf, "%s%s", directory_name, main_file_name);
2787 *filename_ptr = buf;
2788 buf += filelen + 1;
2789 }
2790 }
2791
2792 if (func)
2793 {
2794 const char *function = func->name;
dc810e39 2795 char *colon;
252b5132
RH		 2796
2797 /* The caller expects a symbol name. We actually have a
2798 function name, without the leading underscore. Put the
2799 underscore back in, so that the caller gets a symbol name. */
2800 if (bfd_get_symbol_leading_char (abfd) == '\0')
2801 strcpy (buf, function);
2802 else
2803 {
2804 buf[0] = bfd_get_symbol_leading_char (abfd);
2805 strcpy (buf + 1, function);
2806 }
f7c33884 2807 /* Have to remove : stuff. */
dc810e39
AM		 2808 colon = strchr (buf, ':');
2809 if (colon != NULL)
2810 *colon = '\0';
252b5132
RH		 2811 *functionname_ptr = buf;
2812 }
2813
b34976b6 2814 return TRUE;
252b5132
RH		 2815}
2816
252b5132 2817int
a6b96beb
AM		 2818NAME (aout, sizeof_headers) (bfd *abfd,
2819 struct bfd_link_info *info ATTRIBUTE_UNUSED)
252b5132 2820{
923f08ff 2821 return adata (abfd).exec_bytes_size;
252b5132
RH		 2822}
2823
2824/* Free all information we have cached for this BFD. We can always
2825 read it again later if we need it. */
2826
b34976b6 2827bfd_boolean
116c20d2 2828NAME (aout, bfd_free_cached_info) (bfd *abfd)
252b5132
RH		 2829{
2830 asection *o;
2831
920581c5
L		 2832 if (bfd_get_format (abfd) != bfd_object
2833 || abfd->tdata.aout_data == NULL)
b34976b6 2834 return TRUE;
252b5132
RH		 2835
2836#define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2837 BFCI_FREE (obj_aout_symbols (abfd));
2838#ifdef USE_MMAP
2839 obj_aout_external_syms (abfd) = 0;
2840 bfd_free_window (&obj_aout_sym_window (abfd));
2841 bfd_free_window (&obj_aout_string_window (abfd));
2842 obj_aout_external_strings (abfd) = 0;
2843#else
2844 BFCI_FREE (obj_aout_external_syms (abfd));
2845 BFCI_FREE (obj_aout_external_strings (abfd));
2846#endif
116c20d2 2847 for (o = abfd->sections; o != NULL; o = o->next)
252b5132
RH		 2848 BFCI_FREE (o->relocation);
2849#undef BFCI_FREE
2850
b34976b6 2851 return TRUE;
252b5132
RH		 2852}
2853\f
2854/* a.out link code. */
2855
252b5132
RH		 2856/* Routine to create an entry in an a.out link hash table. */
2857
2858struct bfd_hash_entry *
116c20d2
NC		 2859NAME (aout, link_hash_newfunc) (struct bfd_hash_entry *entry,
2860 struct bfd_hash_table *table,
2861 const char *string)
252b5132
RH		 2862{
2863 struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry;
2864
2865 /* Allocate the structure if it has not already been allocated by a
2866 subclass. */
116c20d2
NC		 2867 if (ret == NULL)
2868 ret = bfd_hash_allocate (table, sizeof (* ret));
2869 if (ret == NULL)
2870 return NULL;
252b5132
RH		 2871
2872 /* Call the allocation method of the superclass. */
2873 ret = ((struct aout_link_hash_entry *)
2874 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2875 table, string));
2876 if (ret)
2877 {
2878 /* Set local fields. */
b34976b6 2879 ret->written = FALSE;
252b5132
RH		 2880 ret->indx = -1;
2881 }
2882
2883 return (struct bfd_hash_entry *) ret;
2884}
2885
2886/* Initialize an a.out link hash table. */
2887
b34976b6 2888bfd_boolean
116c20d2
NC		 2889NAME (aout, link_hash_table_init) (struct aout_link_hash_table *table,
2890 bfd *abfd,
2891 struct bfd_hash_entry *(*newfunc)
2892 (struct bfd_hash_entry *, struct bfd_hash_table *,
66eb6687
AM		 2893 const char *),
2894 unsigned int entsize)
252b5132 2895{
66eb6687 2896 return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
252b5132
RH		 2897}
2898
2899/* Create an a.out link hash table. */
2900
2901struct bfd_link_hash_table *
116c20d2 2902NAME (aout, link_hash_table_create) (bfd *abfd)
252b5132
RH		 2903{
2904 struct aout_link_hash_table *ret;
116c20d2 2905 bfd_size_type amt = sizeof (* ret);
252b5132 2906
116c20d2 2907 ret = bfd_malloc (amt);
252b5132 2908 if (ret == NULL)
116c20d2 2909 return NULL;
5ed6aba4 2910
66eb6687
AM		 2911 if (!NAME (aout, link_hash_table_init) (ret, abfd,
2912 NAME (aout, link_hash_newfunc),
2913 sizeof (struct aout_link_hash_entry)))
252b5132
RH		 2914 {
2915 free (ret);
116c20d2 2916 return NULL;
252b5132
RH		 2917 }
2918 return &ret->root;
2919}
2920
116c20d2 2921/* Add all symbols from an object file to the hash table. */
252b5132 2922
b34976b6 2923static bfd_boolean
116c20d2 2924aout_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
252b5132 2925{
116c20d2
NC		 2926 bfd_boolean (*add_one_symbol)
2927 (struct bfd_link_info *, bfd *, const char *, flagword, asection *,
2928 bfd_vma, const char *, bfd_boolean, bfd_boolean,
2929 struct bfd_link_hash_entry **);
2930 struct external_nlist *syms;
2931 bfd_size_type sym_count;
2932 char *strings;
2933 bfd_boolean copy;
2934 struct aout_link_hash_entry **sym_hash;
2935 struct external_nlist *p;
2936 struct external_nlist *pend;
2937 bfd_size_type amt;
252b5132 2938
116c20d2
NC		 2939 syms = obj_aout_external_syms (abfd);
2940 sym_count = obj_aout_external_sym_count (abfd);
2941 strings = obj_aout_external_strings (abfd);
2942 if (info->keep_memory)
2943 copy = FALSE;
2944 else
2945 copy = TRUE;
252b5132 2946
116c20d2 2947 if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
252b5132 2948 {
116c20d2
NC		 2949 if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
2950 (abfd, info, &syms, &sym_count, &strings)))
b34976b6 2951 return FALSE;
252b5132
RH		 2952 }
2953
116c20d2
NC		 2954 /* We keep a list of the linker hash table entries that correspond
2955 to particular symbols. We could just look them up in the hash
2956 table, but keeping the list is more efficient. Perhaps this
2957 should be conditional on info->keep_memory. */
2958 amt = sym_count * sizeof (struct aout_link_hash_entry *);
2959 sym_hash = bfd_alloc (abfd, amt);
2960 if (sym_hash == NULL && sym_count != 0)
2961 return FALSE;
2962 obj_aout_sym_hashes (abfd) = sym_hash;
252b5132 2963
116c20d2
NC		 2964 add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
2965 if (add_one_symbol == NULL)
2966 add_one_symbol = _bfd_generic_link_add_one_symbol;
252b5132 2967
116c20d2
NC		 2968 p = syms;
2969 pend = p + sym_count;
2970 for (; p < pend; p++, sym_hash++)
252b5132 2971 {
116c20d2 2972 int type;
252b5132 2973 const char *name;
116c20d2
NC		 2974 bfd_vma value;
2975 asection *section;
2976 flagword flags;
2977 const char *string;
252b5132 2978
116c20d2 2979 *sym_hash = NULL;
252b5132 2980
116c20d2 2981 type = H_GET_8 (abfd, p->e_type);
252b5132 2982
116c20d2
NC		 2983 /* Ignore debugging symbols. */
2984 if ((type & N_STAB) != 0)
2985 continue;
252b5132 2986
116c20d2
NC		 2987 name = strings + GET_WORD (abfd, p->e_strx);
2988 value = GET_WORD (abfd, p->e_value);
2989 flags = BSF_GLOBAL;
2990 string = NULL;
2991 switch (type)
252b5132 2992 {
116c20d2
NC		 2993 default:
2994 abort ();
f7c33884 2995
116c20d2
NC		 2996 case N_UNDF:
2997 case N_ABS:
2998 case N_TEXT:
2999 case N_DATA:
3000 case N_BSS:
3001 case N_FN_SEQ:
3002 case N_COMM:
3003 case N_SETV:
3004 case N_FN:
3005 /* Ignore symbols that are not externally visible. */
3006 continue;
3007 case N_INDR:
3008 /* Ignore local indirect symbol. */
3009 ++p;
3010 ++sym_hash;
3011 continue;
252b5132 3012
116c20d2
NC		 3013 case N_UNDF | N_EXT:
3014 if (value == 0)
f7c33884 3015 {
116c20d2
NC		 3016 section = bfd_und_section_ptr;
3017 flags = 0;
252b5132
RH		 3018 }
3019 else
3020 section = bfd_com_section_ptr;
3021 break;
3022 case N_ABS | N_EXT:
3023 section = bfd_abs_section_ptr;
3024 break;
3025 case N_TEXT | N_EXT:
3026 section = obj_textsec (abfd);
3027 value -= bfd_get_section_vma (abfd, section);
3028 break;
3029 case N_DATA | N_EXT:
3030 case N_SETV | N_EXT:
3031 /* Treat N_SETV symbols as N_DATA symbol; see comment in
3032 translate_from_native_sym_flags. */
3033 section = obj_datasec (abfd);
3034 value -= bfd_get_section_vma (abfd, section);
3035 break;
3036 case N_BSS | N_EXT:
3037 section = obj_bsssec (abfd);
3038 value -= bfd_get_section_vma (abfd, section);
3039 break;
3040 case N_INDR | N_EXT:
3041 /* An indirect symbol. The next symbol is the symbol
3042 which this one really is. */
3043 BFD_ASSERT (p + 1 < pend);
3044 ++p;
3045 string = strings + GET_WORD (abfd, p->e_strx);
3046 section = bfd_ind_section_ptr;
3047 flags |= BSF_INDIRECT;
3048 break;
3049 case N_COMM | N_EXT:
3050 section = bfd_com_section_ptr;
3051 break;
3052 case N_SETA: case N_SETA | N_EXT:
3053 section = bfd_abs_section_ptr;
3054 flags |= BSF_CONSTRUCTOR;
3055 break;
3056 case N_SETT: case N_SETT | N_EXT:
3057 section = obj_textsec (abfd);
3058 flags |= BSF_CONSTRUCTOR;
3059 value -= bfd_get_section_vma (abfd, section);
3060 break;
3061 case N_SETD: case N_SETD | N_EXT:
3062 section = obj_datasec (abfd);
3063 flags |= BSF_CONSTRUCTOR;
3064 value -= bfd_get_section_vma (abfd, section);
3065 break;
3066 case N_SETB: case N_SETB | N_EXT:
3067 section = obj_bsssec (abfd);
3068 flags |= BSF_CONSTRUCTOR;
3069 value -= bfd_get_section_vma (abfd, section);
3070 break;
3071 case N_WARNING:
3072 /* A warning symbol. The next symbol is the one to warn
9f400ee9
HPN		 3073 about. If there is no next symbol, just look away. */
3074 if (p + 1 >= pend)
3075 return TRUE;
252b5132
RH		 3076 ++p;
3077 string = name;
3078 name = strings + GET_WORD (abfd, p->e_strx);
3079 section = bfd_und_section_ptr;
3080 flags |= BSF_WARNING;
3081 break;
3082 case N_WEAKU:
3083 section = bfd_und_section_ptr;
3084 flags = BSF_WEAK;
3085 break;
3086 case N_WEAKA:
3087 section = bfd_abs_section_ptr;
3088 flags = BSF_WEAK;
3089 break;
3090 case N_WEAKT:
3091 section = obj_textsec (abfd);
3092 value -= bfd_get_section_vma (abfd, section);
3093 flags = BSF_WEAK;
3094 break;
3095 case N_WEAKD:
3096 section = obj_datasec (abfd);
3097 value -= bfd_get_section_vma (abfd, section);
3098 flags = BSF_WEAK;
3099 break;
3100 case N_WEAKB:
3101 section = obj_bsssec (abfd);
3102 value -= bfd_get_section_vma (abfd, section);
3103 flags = BSF_WEAK;
3104 break;
3105 }
3106
3107 if (! ((*add_one_symbol)
b34976b6 3108 (info, abfd, name, flags, section, value, string, copy, FALSE,
252b5132 3109 (struct bfd_link_hash_entry **) sym_hash)))
b34976b6 3110 return FALSE;
252b5132
RH		 3111
3112 /* Restrict the maximum alignment of a common symbol based on
3113 the architecture, since a.out has no way to represent
3114 alignment requirements of a section in a .o file. FIXME:
3115 This isn't quite right: it should use the architecture of the
3116 output file, not the input files. */
3117 if ((*sym_hash)->root.type == bfd_link_hash_common
3118 && ((*sym_hash)->root.u.c.p->alignment_power >
3119 bfd_get_arch_info (abfd)->section_align_power))
3120 (*sym_hash)->root.u.c.p->alignment_power =
3121 bfd_get_arch_info (abfd)->section_align_power;
3122
3123 /* If this is a set symbol, and we are not building sets, then
3124 it is possible for the hash entry to not have been set. In
3125 such a case, treat the symbol as not globally defined. */
3126 if ((*sym_hash)->root.type == bfd_link_hash_new)
3127 {
3128 BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
3129 *sym_hash = NULL;
3130 }
3131
3132 if (type == (N_INDR | N_EXT) || type == N_WARNING)
3133 ++sym_hash;
3134 }
3135
b34976b6 3136 return TRUE;
252b5132 3137}
252b5132 3138
116c20d2
NC		 3139/* Free up the internal symbols read from an a.out file. */
3140
3141static bfd_boolean
3142aout_link_free_symbols (bfd *abfd)
252b5132 3143{
116c20d2
NC		 3144 if (obj_aout_external_syms (abfd) != NULL)
3145 {
3146#ifdef USE_MMAP
3147 bfd_free_window (&obj_aout_sym_window (abfd));
3148#else
3149 free ((void *) obj_aout_external_syms (abfd));
3150#endif
3151 obj_aout_external_syms (abfd) = NULL;
3152 }
3153 if (obj_aout_external_strings (abfd) != NULL)
3154 {
3155#ifdef USE_MMAP
3156 bfd_free_window (&obj_aout_string_window (abfd));
3157#else
3158 free ((void *) obj_aout_external_strings (abfd));
3159#endif
3160 obj_aout_external_strings (abfd) = NULL;
3161 }
3162 return TRUE;
3163}
252b5132 3164
116c20d2 3165/* Add symbols from an a.out object file. */
252b5132 3166
116c20d2
NC		 3167static bfd_boolean
3168aout_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
252b5132 3169{
116c20d2
NC		 3170 if (! aout_get_external_symbols (abfd))
3171 return FALSE;
3172 if (! aout_link_add_symbols (abfd, info))
3173 return FALSE;
3174 if (! info->keep_memory)
3175 {
3176 if (! aout_link_free_symbols (abfd))
3177 return FALSE;
3178 }
3179 return TRUE;
3180}
252b5132 3181
116c20d2
NC		 3182/* Look through the internal symbols to see if this object file should
3183 be included in the link. We should include this object file if it
3184 defines any symbols which are currently undefined. If this object
3185 file defines a common symbol, then we may adjust the size of the
3186 known symbol but we do not include the object file in the link
3187 (unless there is some other reason to include it). */
252b5132 3188
116c20d2
NC		 3189static bfd_boolean
3190aout_link_check_ar_symbols (bfd *abfd,
3191 struct bfd_link_info *info,
3192 bfd_boolean *pneeded)
252b5132 3193{
116c20d2
NC		 3194 struct external_nlist *p;
3195 struct external_nlist *pend;
3196 char *strings;
252b5132 3197
116c20d2 3198 *pneeded = FALSE;
252b5132 3199
116c20d2
NC		 3200 /* Look through all the symbols. */
3201 p = obj_aout_external_syms (abfd);
3202 pend = p + obj_aout_external_sym_count (abfd);
3203 strings = obj_aout_external_strings (abfd);
3204 for (; p < pend; p++)
3205 {
3206 int type = H_GET_8 (abfd, p->e_type);
3207 const char *name;
3208 struct bfd_link_hash_entry *h;
252b5132 3209
116c20d2
NC		 3210 /* Ignore symbols that are not externally visible. This is an
3211 optimization only, as we check the type more thoroughly
3212 below. */
3213 if (((type & N_EXT) == 0
3214 || (type & N_STAB) != 0
3215 || type == N_FN)
3216 && type != N_WEAKA
3217 && type != N_WEAKT
3218 && type != N_WEAKD
3219 && type != N_WEAKB)
3220 {
3221 if (type == N_WARNING
3222 || type == N_INDR)
3223 ++p;
3224 continue;
3225 }
3226
3227 name = strings + GET_WORD (abfd, p->e_strx);
3228 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
3229
3230 /* We are only interested in symbols that are currently
3231 undefined or common. */
3232 if (h == NULL
3233 || (h->type != bfd_link_hash_undefined
3234 && h->type != bfd_link_hash_common))
3235 {
3236 if (type == (N_INDR | N_EXT))
3237 ++p;
3238 continue;
3239 }
3240
3241 if (type == (N_TEXT | N_EXT)
3242 || type == (N_DATA | N_EXT)
3243 || type == (N_BSS | N_EXT)
3244 || type == (N_ABS | N_EXT)
3245 || type == (N_INDR | N_EXT))
3246 {
3247 /* This object file defines this symbol. We must link it
3248 in. This is true regardless of whether the current
3249 definition of the symbol is undefined or common.
3250
3251 If the current definition is common, we have a case in
3252 which we have already seen an object file including:
3253 int a;
3254 and this object file from the archive includes:
3255 int a = 5;
3256 In such a case, whether to include this object is target
3257 dependant for backward compatibility.
3258
3259 FIXME: The SunOS 4.1.3 linker will pull in the archive
3260 element if the symbol is defined in the .data section,
3261 but not if it is defined in the .text section. That
3262 seems a bit crazy to me, and it has not been implemented
3263 yet. However, it might be correct. */
3264 if (h->type == bfd_link_hash_common)
3265 {
3266 int skip = 0;
3267
3268 switch (info->common_skip_ar_aymbols)
3269 {
3270 case bfd_link_common_skip_text:
3271 skip = (type == (N_TEXT | N_EXT));
3272 break;
3273 case bfd_link_common_skip_data:
3274 skip = (type == (N_DATA | N_EXT));
3275 break;
3276 default:
3277 case bfd_link_common_skip_all:
3278 skip = 1;
3279 break;
3280 }
3281
3282 if (skip)
3283 continue;
3284 }
3285
3286 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3287 return FALSE;
3288 *pneeded = TRUE;
3289 return TRUE;
3290 }
3291
3292 if (type == (N_UNDF | N_EXT))
3293 {
3294 bfd_vma value;
3295
3296 value = GET_WORD (abfd, p->e_value);
3297 if (value != 0)
3298 {
3299 /* This symbol is common in the object from the archive
3300 file. */
3301 if (h->type == bfd_link_hash_undefined)
3302 {
3303 bfd *symbfd;
3304 unsigned int power;
3305
3306 symbfd = h->u.undef.abfd;
3307 if (symbfd == NULL)
3308 {
3309 /* This symbol was created as undefined from
3310 outside BFD. We assume that we should link
3311 in the object file. This is done for the -u
3312 option in the linker. */
3313 if (! (*info->callbacks->add_archive_element) (info,
3314 abfd,
3315 name))
3316 return FALSE;
3317 *pneeded = TRUE;
3318 return TRUE;
3319 }
3320 /* Turn the current link symbol into a common
3321 symbol. It is already on the undefs list. */
3322 h->type = bfd_link_hash_common;
3323 h->u.c.p = bfd_hash_allocate (&info->hash->table,
3324 sizeof (struct bfd_link_hash_common_entry));
3325 if (h->u.c.p == NULL)
3326 return FALSE;
3327
3328 h->u.c.size = value;
3329
3330 /* FIXME: This isn't quite right. The maximum
3331 alignment of a common symbol should be set by the
3332 architecture of the output file, not of the input
3333 file. */
3334 power = bfd_log2 (value);
3335 if (power > bfd_get_arch_info (abfd)->section_align_power)
3336 power = bfd_get_arch_info (abfd)->section_align_power;
3337 h->u.c.p->alignment_power = power;
3338
3339 h->u.c.p->section = bfd_make_section_old_way (symbfd,
3340 "COMMON");
3341 }
3342 else
3343 {
3344 /* Adjust the size of the common symbol if
3345 necessary. */
3346 if (value > h->u.c.size)
3347 h->u.c.size = value;
3348 }
3349 }
3350 }
3351
3352 if (type == N_WEAKA
3353 || type == N_WEAKT
3354 || type == N_WEAKD
3355 || type == N_WEAKB)
3356 {
3357 /* This symbol is weak but defined. We must pull it in if
3358 the current link symbol is undefined, but we don't want
3359 it if the current link symbol is common. */
3360 if (h->type == bfd_link_hash_undefined)
3361 {
3362 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3363 return FALSE;
3364 *pneeded = TRUE;
3365 return TRUE;
3366 }
3367 }
3368 }
3369
3370 /* We do not need this object file. */
3371 return TRUE;
3372}
3373/* Check a single archive element to see if we need to include it in
3374 the link. *PNEEDED is set according to whether this element is
3375 needed in the link or not. This is called from
3376 _bfd_generic_link_add_archive_symbols. */
3377
3378static bfd_boolean
3379aout_link_check_archive_element (bfd *abfd,
3380 struct bfd_link_info *info,
3381 bfd_boolean *pneeded)
3382{
3383 if (! aout_get_external_symbols (abfd))
3384 return FALSE;
3385
3386 if (! aout_link_check_ar_symbols (abfd, info, pneeded))
3387 return FALSE;
3388
3389 if (*pneeded)
3390 {
3391 if (! aout_link_add_symbols (abfd, info))
3392 return FALSE;
3393 }
3394
3395 if (! info->keep_memory || ! *pneeded)
3396 {
3397 if (! aout_link_free_symbols (abfd))
3398 return FALSE;
3399 }
3400
3401 return TRUE;
3402}
3403
3404/* Given an a.out BFD, add symbols to the global hash table as
3405 appropriate. */
3406
3407bfd_boolean
3408NAME (aout, link_add_symbols) (bfd *abfd, struct bfd_link_info *info)
3409{
3410 switch (bfd_get_format (abfd))
3411 {
3412 case bfd_object:
3413 return aout_link_add_object_symbols (abfd, info);
3414 case bfd_archive:
3415 return _bfd_generic_link_add_archive_symbols
3416 (abfd, info, aout_link_check_archive_element);
3417 default:
3418 bfd_set_error (bfd_error_wrong_format);
3419 return FALSE;
3420 }
3421}
3422\f
3423/* A hash table used for header files with N_BINCL entries. */
3424
3425struct aout_link_includes_table
3426{
3427 struct bfd_hash_table root;
3428};
3429
3430/* A linked list of totals that we have found for a particular header
3431 file. */
3432
3433struct aout_link_includes_totals
3434{
3435 struct aout_link_includes_totals *next;
3436 bfd_vma total;
3437};
3438
3439/* An entry in the header file hash table. */
3440
3441struct aout_link_includes_entry
3442{
3443 struct bfd_hash_entry root;
3444 /* List of totals we have found for this file. */
3445 struct aout_link_includes_totals *totals;
3446};
3447
3448/* Look up an entry in an the header file hash table. */
3449
3450#define aout_link_includes_lookup(table, string, create, copy) \
3451 ((struct aout_link_includes_entry *) \
3452 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3453
3454/* During the final link step we need to pass around a bunch of
3455 information, so we do it in an instance of this structure. */
3456
3457struct aout_final_link_info
3458{
3459 /* General link information. */
3460 struct bfd_link_info *info;
3461 /* Output bfd. */
252b5132
RH		 3462 bfd *output_bfd;
3463 /* Reloc file positions. */
3464 file_ptr treloff, dreloff;
3465 /* File position of symbols. */
3466 file_ptr symoff;
3467 /* String table. */
3468 struct bfd_strtab_hash *strtab;
3469 /* Header file hash table. */
3470 struct aout_link_includes_table includes;
3471 /* A buffer large enough to hold the contents of any section. */
3472 bfd_byte *contents;
3473 /* A buffer large enough to hold the relocs of any section. */
116c20d2 3474 void * relocs;
252b5132
RH		 3475 /* A buffer large enough to hold the symbol map of any input BFD. */
3476 int *symbol_map;
3477 /* A buffer large enough to hold output symbols of any input BFD. */
3478 struct external_nlist *output_syms;
3479};
3480
252b5132
RH		 3481/* The function to create a new entry in the header file hash table. */
3482
3483static struct bfd_hash_entry *
116c20d2
NC		 3484aout_link_includes_newfunc (struct bfd_hash_entry *entry,
3485 struct bfd_hash_table *table,
3486 const char *string)
252b5132
RH		 3487{
3488 struct aout_link_includes_entry *ret =
3489 (struct aout_link_includes_entry *) entry;
3490
3491 /* Allocate the structure if it has not already been allocated by a
3492 subclass. */
116c20d2
NC		 3493 if (ret == NULL)
3494 ret = bfd_hash_allocate (table, sizeof (* ret));
3495 if (ret == NULL)
3496 return NULL;
252b5132
RH		 3497
3498 /* Call the allocation method of the superclass. */
3499 ret = ((struct aout_link_includes_entry *)
3500 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
3501 if (ret)
3502 {
3503 /* Set local fields. */
3504 ret->totals = NULL;
3505 }
3506
3507 return (struct bfd_hash_entry *) ret;
3508}
3509
116c20d2
NC		 3510/* Write out a symbol that was not associated with an a.out input
3511 object. */
252b5132 3512
116c20d2
NC		 3513static bfd_boolean
3514aout_link_write_other_symbol (struct aout_link_hash_entry *h, void * data)
252b5132 3515{
116c20d2
NC		 3516 struct aout_final_link_info *finfo = (struct aout_final_link_info *) data;
3517 bfd *output_bfd;
3518 int type;
3519 bfd_vma val;
3520 struct external_nlist outsym;
3521 bfd_size_type indx;
3522 bfd_size_type amt;
252b5132 3523
116c20d2
NC		 3524 if (h->root.type == bfd_link_hash_warning)
3525 {
3526 h = (struct aout_link_hash_entry *) h->root.u.i.link;
3527 if (h->root.type == bfd_link_hash_new)
3528 return TRUE;
3529 }
252b5132 3530
116c20d2 3531 output_bfd = finfo->output_bfd;
252b5132 3532
116c20d2 3533 if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
252b5132 3534 {
116c20d2
NC		 3535 if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
3536 (output_bfd, finfo->info, h)))
252b5132 3537 {
116c20d2
NC		 3538 /* FIXME: No way to handle errors. */
3539 abort ();
252b5132 3540 }
116c20d2 3541 }
252b5132 3542
116c20d2
NC		 3543 if (h->written)
3544 return TRUE;
252b5132 3545
116c20d2 3546 h->written = TRUE;
252b5132 3547
116c20d2
NC		 3548 /* An indx of -2 means the symbol must be written. */
3549 if (h->indx != -2
3550 && (finfo->info->strip == strip_all
3551 || (finfo->info->strip == strip_some
3552 && bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
3553 FALSE, FALSE) == NULL)))
3554 return TRUE;
252b5132 3555
116c20d2 3556 switch (h->root.type)
252b5132 3557 {
116c20d2
NC		 3558 default:
3559 case bfd_link_hash_warning:
3560 abort ();
3561 /* Avoid variable not initialized warnings. */
3562 return TRUE;
3563 case bfd_link_hash_new:
3564 /* This can happen for set symbols when sets are not being
3565 built. */
3566 return TRUE;
3567 case bfd_link_hash_undefined:
3568 type = N_UNDF | N_EXT;
3569 val = 0;
3570 break;
3571 case bfd_link_hash_defined:
3572 case bfd_link_hash_defweak:
3573 {
3574 asection *sec;
252b5132 3575
116c20d2
NC		 3576 sec = h->root.u.def.section->output_section;
3577 BFD_ASSERT (bfd_is_abs_section (sec)
3578 || sec->owner == output_bfd);
3579 if (sec == obj_textsec (output_bfd))
3580 type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
3581 else if (sec == obj_datasec (output_bfd))
3582 type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
3583 else if (sec == obj_bsssec (output_bfd))
3584 type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
3585 else
3586 type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
3587 type |= N_EXT;
3588 val = (h->root.u.def.value
3589 + sec->vma
3590 + h->root.u.def.section->output_offset);
3591 }
3592 break;
3593 case bfd_link_hash_common:
3594 type = N_UNDF | N_EXT;
3595 val = h->root.u.c.size;
3596 break;
3597 case bfd_link_hash_undefweak:
3598 type = N_WEAKU;
3599 val = 0;
3600 case bfd_link_hash_indirect:
3601 /* We ignore these symbols, since the indirected symbol is
3602 already in the hash table. */
3603 return TRUE;
3604 }
252b5132 3605
116c20d2
NC		 3606 H_PUT_8 (output_bfd, type, outsym.e_type);
3607 H_PUT_8 (output_bfd, 0, outsym.e_other);
3608 H_PUT_16 (output_bfd, 0, outsym.e_desc);
3609 indx = add_to_stringtab (output_bfd, finfo->strtab, h->root.root.string,
3610 FALSE);
3611 if (indx == - (bfd_size_type) 1)
3612 /* FIXME: No way to handle errors. */
3613 abort ();
252b5132 3614
116c20d2
NC		 3615 PUT_WORD (output_bfd, indx, outsym.e_strx);
3616 PUT_WORD (output_bfd, val, outsym.e_value);
252b5132 3617
116c20d2
NC		 3618 amt = EXTERNAL_NLIST_SIZE;
3619 if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0
3620 || bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt)
3621 /* FIXME: No way to handle errors. */
3622 abort ();
252b5132 3623
116c20d2
NC		 3624 finfo->symoff += EXTERNAL_NLIST_SIZE;
3625 h->indx = obj_aout_external_sym_count (output_bfd);
3626 ++obj_aout_external_sym_count (output_bfd);
252b5132 3627
116c20d2
NC		 3628 return TRUE;
3629}
252b5132 3630
116c20d2 3631/* Handle a link order which is supposed to generate a reloc. */
252b5132 3632
116c20d2
NC		 3633static bfd_boolean
3634aout_link_reloc_link_order (struct aout_final_link_info *finfo,
3635 asection *o,
3636 struct bfd_link_order *p)
3637{
3638 struct bfd_link_order_reloc *pr;
3639 int r_index;
3640 int r_extern;
3641 reloc_howto_type *howto;
3642 file_ptr *reloff_ptr = NULL;
3643 struct reloc_std_external srel;
3644 struct reloc_ext_external erel;
3645 void * rel_ptr;
3646 bfd_size_type amt;
252b5132 3647
116c20d2 3648 pr = p->u.reloc.p;
252b5132 3649
116c20d2
NC		 3650 if (p->type == bfd_section_reloc_link_order)
3651 {
3652 r_extern = 0;
3653 if (bfd_is_abs_section (pr->u.section))
3654 r_index = N_ABS | N_EXT;
3655 else
3656 {
3657 BFD_ASSERT (pr->u.section->owner == finfo->output_bfd);
3658 r_index = pr->u.section->target_index;
3659 }
3660 }
3661 else
3662 {
3663 struct aout_link_hash_entry *h;
252b5132 3664
116c20d2
NC		 3665 BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
3666 r_extern = 1;
3667 h = ((struct aout_link_hash_entry *)
3668 bfd_wrapped_link_hash_lookup (finfo->output_bfd, finfo->info,
3669 pr->u.name, FALSE, FALSE, TRUE));
3670 if (h != NULL
3671 && h->indx >= 0)
3672 r_index = h->indx;
3673 else if (h != NULL)
3674 {
3675 /* We decided to strip this symbol, but it turns out that we
3676 can't. Note that we lose the other and desc information
3677 here. I don't think that will ever matter for a global
3678 symbol. */
3679 h->indx = -2;
3680 h->written = FALSE;
3681 if (! aout_link_write_other_symbol (h, (void *) finfo))
3682 return FALSE;
3683 r_index = h->indx;
3684 }
3685 else
3686 {
3687 if (! ((*finfo->info->callbacks->unattached_reloc)
3688 (finfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0)))
3689 return FALSE;
3690 r_index = 0;
3691 }
3692 }
252b5132 3693
116c20d2
NC		 3694 howto = bfd_reloc_type_lookup (finfo->output_bfd, pr->reloc);
3695 if (howto == 0)
252b5132 3696 {
116c20d2
NC		 3697 bfd_set_error (bfd_error_bad_value);
3698 return FALSE;
252b5132
RH		 3699 }
3700
116c20d2
NC		 3701 if (o == obj_textsec (finfo->output_bfd))
3702 reloff_ptr = &finfo->treloff;
3703 else if (o == obj_datasec (finfo->output_bfd))
3704 reloff_ptr = &finfo->dreloff;
3705 else
3706 abort ();
3707
3708 if (obj_reloc_entry_size (finfo->output_bfd) == RELOC_STD_SIZE)
252b5132 3709 {
116c20d2
NC		 3710#ifdef MY_put_reloc
3711 MY_put_reloc (finfo->output_bfd, r_extern, r_index, p->offset, howto,
3712 &srel);
3713#else
3714 {
3715 int r_pcrel;
3716 int r_baserel;
3717 int r_jmptable;
3718 int r_relative;
3719 int r_length;
252b5132 3720
116c20d2
NC		 3721 r_pcrel = (int) howto->pc_relative;
3722 r_baserel = (howto->type & 8) != 0;
3723 r_jmptable = (howto->type & 16) != 0;
3724 r_relative = (howto->type & 32) != 0;
3725 r_length = howto->size;
252b5132 3726
116c20d2
NC		 3727 PUT_WORD (finfo->output_bfd, p->offset, srel.r_address);
3728 if (bfd_header_big_endian (finfo->output_bfd))
3729 {
3730 srel.r_index[0] = r_index >> 16;
3731 srel.r_index[1] = r_index >> 8;
3732 srel.r_index[2] = r_index;
3733 srel.r_type[0] =
3734 ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
3735 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
3736 | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
3737 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
3738 | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
3739 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
3740 }
3741 else
3742 {
3743 srel.r_index[2] = r_index >> 16;
3744 srel.r_index[1] = r_index >> 8;
3745 srel.r_index[0] = r_index;
3746 srel.r_type[0] =
3747 ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
3748 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
3749 | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
3750 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
3751 | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
3752 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
3753 }
3754 }
3755#endif
3756 rel_ptr = (void *) &srel;
252b5132 3757
116c20d2
NC		 3758 /* We have to write the addend into the object file, since
3759 standard a.out relocs are in place. It would be more
3760 reliable if we had the current contents of the file here,
3761 rather than assuming zeroes, but we can't read the file since
3762 it was opened using bfd_openw. */
3763 if (pr->addend != 0)
252b5132 3764 {
116c20d2
NC		 3765 bfd_size_type size;
3766 bfd_reloc_status_type r;
3767 bfd_byte *buf;
3768 bfd_boolean ok;
3769
3770 size = bfd_get_reloc_size (howto);
3771 buf = bfd_zmalloc (size);
3772 if (buf == NULL)
3773 return FALSE;
3774 r = MY_relocate_contents (howto, finfo->output_bfd,
3775 (bfd_vma) pr->addend, buf);
3776 switch (r)
252b5132 3777 {
116c20d2
NC		 3778 case bfd_reloc_ok:
3779 break;
3780 default:
3781 case bfd_reloc_outofrange:
3782 abort ();
3783 case bfd_reloc_overflow:
3784 if (! ((*finfo->info->callbacks->reloc_overflow)
3785 (finfo->info, NULL,
3786 (p->type == bfd_section_reloc_link_order
3787 ? bfd_section_name (finfo->output_bfd,
3788 pr->u.section)
3789 : pr->u.name),
3790 howto->name, pr->addend, NULL, NULL, (bfd_vma) 0)))
252b5132 3791 {
116c20d2
NC		 3792 free (buf);
3793 return FALSE;
252b5132 3794 }
116c20d2 3795 break;
252b5132 3796 }
116c20d2
NC		 3797 ok = bfd_set_section_contents (finfo->output_bfd, o, (void *) buf,
3798 (file_ptr) p->offset, size);
3799 free (buf);
3800 if (! ok)
3801 return FALSE;
252b5132
RH		 3802 }
3803 }
116c20d2 3804 else
252b5132 3805 {
116c20d2
NC		 3806#ifdef MY_put_ext_reloc
3807 MY_put_ext_reloc (finfo->output_bfd, r_extern, r_index, p->offset,
3808 howto, &erel, pr->addend);
3809#else
3810 PUT_WORD (finfo->output_bfd, p->offset, erel.r_address);
252b5132 3811
116c20d2
NC		 3812 if (bfd_header_big_endian (finfo->output_bfd))
3813 {
3814 erel.r_index[0] = r_index >> 16;
3815 erel.r_index[1] = r_index >> 8;
3816 erel.r_index[2] = r_index;
3817 erel.r_type[0] =
3818 ((r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
3819 | (howto->type << RELOC_EXT_BITS_TYPE_SH_BIG));
3820 }
3821 else
3822 {
3823 erel.r_index[2] = r_index >> 16;
3824 erel.r_index[1] = r_index >> 8;
3825 erel.r_index[0] = r_index;
3826 erel.r_type[0] =
3827 (r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
3828 | (howto->type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
3829 }
252b5132 3830
116c20d2
NC		 3831 PUT_WORD (finfo->output_bfd, (bfd_vma) pr->addend, erel.r_addend);
3832#endif /* MY_put_ext_reloc */
252b5132 3833
116c20d2 3834 rel_ptr = (void *) &erel;
252b5132 3835 }
252b5132 3836
116c20d2
NC		 3837 amt = obj_reloc_entry_size (finfo->output_bfd);
3838 if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
3839 || bfd_bwrite (rel_ptr, amt, finfo->output_bfd) != amt)
3840 return FALSE;
252b5132 3841
116c20d2 3842 *reloff_ptr += obj_reloc_entry_size (finfo->output_bfd);
252b5132 3843
116c20d2
NC		 3844 /* Assert that the relocs have not run into the symbols, and that n
3845 the text relocs have not run into the data relocs. */
3846 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
3847 && (reloff_ptr != &finfo->treloff
3848 || (*reloff_ptr
3849 <= obj_datasec (finfo->output_bfd)->rel_filepos)));
3850
3851 return TRUE;
252b5132
RH		 3852}
3853
116c20d2 3854/* Get the section corresponding to a reloc index. */
252b5132 3855
116c20d2
NC		 3856static INLINE asection *
3857aout_reloc_index_to_section (bfd *abfd, int indx)
252b5132 3858{
116c20d2 3859 switch (indx & N_TYPE)
252b5132 3860 {
116c20d2
NC		 3861 case N_TEXT: return obj_textsec (abfd);
3862 case N_DATA: return obj_datasec (abfd);
3863 case N_BSS: return obj_bsssec (abfd);
3864 case N_ABS:
3865 case N_UNDF: return bfd_abs_section_ptr;
3866 default: abort ();
252b5132 3867 }
116c20d2 3868 return NULL;
252b5132
RH		 3869}
3870
116c20d2 3871/* Relocate an a.out section using standard a.out relocs. */
252b5132 3872
b34976b6 3873static bfd_boolean
116c20d2
NC		 3874aout_link_input_section_std (struct aout_final_link_info *finfo,
3875 bfd *input_bfd,
3876 asection *input_section,
3877 struct reloc_std_external *relocs,
3878 bfd_size_type rel_size,
3879 bfd_byte *contents)
252b5132 3880{
116c20d2
NC		 3881 bfd_boolean (*check_dynamic_reloc)
3882 (struct bfd_link_info *, bfd *, asection *,
3883 struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
3884 bfd_vma *);
252b5132 3885 bfd *output_bfd;
116c20d2
NC		 3886 bfd_boolean relocatable;
3887 struct external_nlist *syms;
252b5132 3888 char *strings;
116c20d2 3889 struct aout_link_hash_entry **sym_hashes;
252b5132 3890 int *symbol_map;
116c20d2
NC		 3891 bfd_size_type reloc_count;
3892 struct reloc_std_external *rel;
3893 struct reloc_std_external *rel_end;
252b5132
RH		 3894
3895 output_bfd = finfo->output_bfd;
116c20d2 3896 check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
252b5132 3897
116c20d2
NC		 3898 BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE);
3899 BFD_ASSERT (input_bfd->xvec->header_byteorder
3900 == output_bfd->xvec->header_byteorder);
252b5132 3901
116c20d2
NC		 3902 relocatable = finfo->info->relocatable;
3903 syms = obj_aout_external_syms (input_bfd);
3904 strings = obj_aout_external_strings (input_bfd);
3905 sym_hashes = obj_aout_sym_hashes (input_bfd);
252b5132 3906 symbol_map = finfo->symbol_map;
116c20d2
NC		 3907
3908 reloc_count = rel_size / RELOC_STD_SIZE;
3909 rel = relocs;
3910 rel_end = rel + reloc_count;
3911 for (; rel < rel_end; rel++)
252b5132 3912 {
116c20d2
NC		 3913 bfd_vma r_addr;
3914 int r_index;
3915 int r_extern;
3916 int r_pcrel;
3917 int r_baserel = 0;
3918 reloc_howto_type *howto;
3919 struct aout_link_hash_entry *h = NULL;
3920 bfd_vma relocation;
3921 bfd_reloc_status_type r;
252b5132 3922
116c20d2 3923 r_addr = GET_SWORD (input_bfd, rel->r_address);
252b5132 3924
116c20d2
NC		 3925#ifdef MY_reloc_howto
3926 howto = MY_reloc_howto (input_bfd, rel, r_index, r_extern, r_pcrel);
3927#else
3928 {
3929 int r_jmptable;
3930 int r_relative;
3931 int r_length;
3932 unsigned int howto_idx;
252b5132 3933
116c20d2
NC		 3934 if (bfd_header_big_endian (input_bfd))
3935 {
3936 r_index = (((unsigned int) rel->r_index[0] << 16)
3937 | ((unsigned int) rel->r_index[1] << 8)
3938 | rel->r_index[2]);
3939 r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
3940 r_pcrel = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
3941 r_baserel = (0 != (rel->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
3942 r_jmptable= (0 != (rel->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
3943 r_relative= (0 != (rel->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
3944 r_length = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
3945 >> RELOC_STD_BITS_LENGTH_SH_BIG);
3946 }
3947 else
3948 {
3949 r_index = (((unsigned int) rel->r_index[2] << 16)
3950 | ((unsigned int) rel->r_index[1] << 8)
3951 | rel->r_index[0]);
3952 r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
3953 r_pcrel = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
3954 r_baserel = (0 != (rel->r_type[0]
3955 & RELOC_STD_BITS_BASEREL_LITTLE));
3956 r_jmptable= (0 != (rel->r_type[0]
3957 & RELOC_STD_BITS_JMPTABLE_LITTLE));
3958 r_relative= (0 != (rel->r_type[0]
3959 & RELOC_STD_BITS_RELATIVE_LITTLE));
3960 r_length = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
3961 >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
3962 }
252b5132 3963
116c20d2
NC		 3964 howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel
3965 + 16 * r_jmptable + 32 * r_relative);
3966 BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_std));
3967 howto = howto_table_std + howto_idx;
3968 }
3969#endif
252b5132 3970
116c20d2 3971 if (relocatable)
252b5132 3972 {
116c20d2
NC		 3973 /* We are generating a relocatable output file, and must
3974 modify the reloc accordingly. */
3975 if (r_extern)
252b5132 3976 {
116c20d2
NC		 3977 /* If we know the symbol this relocation is against,
3978 convert it into a relocation against a section. This
3979 is what the native linker does. */
3980 h = sym_hashes[r_index];
3981 if (h != NULL
3982 && (h->root.type == bfd_link_hash_defined
3983 || h->root.type == bfd_link_hash_defweak))
252b5132 3984 {
252b5132
RH		 3985 asection *output_section;
3986
116c20d2
NC		 3987 /* Change the r_extern value. */
3988 if (bfd_header_big_endian (output_bfd))
3989 rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_BIG;
3990 else
3991 rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_LITTLE;
252b5132 3992
116c20d2
NC		 3993 /* Compute a new r_index. */
3994 output_section = h->root.u.def.section->output_section;
252b5132 3995 if (output_section == obj_textsec (output_bfd))
116c20d2 3996 r_index = N_TEXT;
252b5132 3997 else if (output_section == obj_datasec (output_bfd))
116c20d2 3998 r_index = N_DATA;
252b5132 3999 else if (output_section == obj_bsssec (output_bfd))
116c20d2 4000 r_index = N_BSS;
252b5132 4001 else
116c20d2 4002 r_index = N_ABS;
252b5132 4003
116c20d2
NC		 4004 /* Add the symbol value and the section VMA to the
4005 addend stored in the contents. */
4006 relocation = (h->root.u.def.value
4007 + output_section->vma
4008 + h->root.u.def.section->output_offset);
252b5132 4009 }
116c20d2 4010 else
252b5132 4011 {
116c20d2
NC		 4012 /* We must change r_index according to the symbol
4013 map. */
4014 r_index = symbol_map[r_index];
252b5132 4015
116c20d2 4016 if (r_index == -1)
252b5132 4017 {
116c20d2 4018 if (h != NULL)
252b5132 4019 {
116c20d2
NC		 4020 /* We decided to strip this symbol, but it
4021 turns out that we can't. Note that we
4022 lose the other and desc information here.
4023 I don't think that will ever matter for a
4024 global symbol. */
4025 if (h->indx < 0)
252b5132 4026 {
116c20d2
NC		 4027 h->indx = -2;
4028 h->written = FALSE;
4029 if (! aout_link_write_other_symbol (h,
4030 (void *) finfo))
4031 return FALSE;
252b5132 4032 }
116c20d2
NC		 4033 r_index = h->indx;
4034 }
4035 else
4036 {
4037 const char *name;
4038
4039 name = strings + GET_WORD (input_bfd,
4040 syms[r_index].e_strx);
4041 if (! ((*finfo->info->callbacks->unattached_reloc)
4042 (finfo->info, name, input_bfd, input_section,
4043 r_addr)))
4044 return FALSE;
4045 r_index = 0;
252b5132
RH		 4046 }
4047 }
116c20d2
NC		 4048
4049 relocation = 0;
252b5132
RH		 4050 }
4051
116c20d2
NC		 4052 /* Write out the new r_index value. */
4053 if (bfd_header_big_endian (output_bfd))
252b5132 4054 {
116c20d2
NC		 4055 rel->r_index[0] = r_index >> 16;
4056 rel->r_index[1] = r_index >> 8;
4057 rel->r_index[2] = r_index;
252b5132
RH		 4058 }
4059 else
4060 {
116c20d2
NC		 4061 rel->r_index[2] = r_index >> 16;
4062 rel->r_index[1] = r_index >> 8;
4063 rel->r_index[0] = r_index;
252b5132
RH		 4064 }
4065 }
252b5132 4066 else
116c20d2
NC		 4067 {
4068 asection *section;
252b5132 4069
116c20d2
NC		 4070 /* This is a relocation against a section. We must
4071 adjust by the amount that the section moved. */
4072 section = aout_reloc_index_to_section (input_bfd, r_index);
4073 relocation = (section->output_section->vma
4074 + section->output_offset
4075 - section->vma);
4076 }
252b5132 4077
116c20d2
NC		 4078 /* Change the address of the relocation. */
4079 PUT_WORD (output_bfd,
4080 r_addr + input_section->output_offset,
4081 rel->r_address);
252b5132 4082
116c20d2
NC		 4083 /* Adjust a PC relative relocation by removing the reference
4084 to the original address in the section and including the
4085 reference to the new address. */
4086 if (r_pcrel)
4087 relocation -= (input_section->output_section->vma
4088 + input_section->output_offset
4089 - input_section->vma);
e92d460e 4090
116c20d2
NC		 4091#ifdef MY_relocatable_reloc
4092 MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr);
4093#endif
252b5132 4094
116c20d2
NC		 4095 if (relocation == 0)
4096 r = bfd_reloc_ok;
4097 else
4098 r = MY_relocate_contents (howto,
4099 input_bfd, relocation,
4100 contents + r_addr);
252b5132 4101 }
116c20d2
NC		 4102 else
4103 {
4104 bfd_boolean hundef;
252b5132 4105
116c20d2
NC		 4106 /* We are generating an executable, and must do a full
4107 relocation. */
4108 hundef = FALSE;
252b5132 4109
116c20d2
NC		 4110 if (r_extern)
4111 {
4112 h = sym_hashes[r_index];
252b5132 4113
116c20d2
NC		 4114 if (h != NULL
4115 && (h->root.type == bfd_link_hash_defined
4116 || h->root.type == bfd_link_hash_defweak))
4117 {
4118 relocation = (h->root.u.def.value
4119 + h->root.u.def.section->output_section->vma
4120 + h->root.u.def.section->output_offset);
4121 }
4122 else if (h != NULL
4123 && h->root.type == bfd_link_hash_undefweak)
4124 relocation = 0;
4125 else
4126 {
4127 hundef = TRUE;
4128 relocation = 0;
4129 }
4130 }
4131 else
4132 {
4133 asection *section;
252b5132 4134
116c20d2
NC		 4135 section = aout_reloc_index_to_section (input_bfd, r_index);
4136 relocation = (section->output_section->vma
4137 + section->output_offset
4138 - section->vma);
4139 if (r_pcrel)
4140 relocation += input_section->vma;
4141 }
252b5132 4142
116c20d2
NC		 4143 if (check_dynamic_reloc != NULL)
4144 {
4145 bfd_boolean skip;
252b5132 4146
116c20d2
NC		 4147 if (! ((*check_dynamic_reloc)
4148 (finfo->info, input_bfd, input_section, h,
4149 (void *) rel, contents, &skip, &relocation)))
4150 return FALSE;
4151 if (skip)
4152 continue;
4153 }
252b5132 4154
116c20d2
NC		 4155 /* Now warn if a global symbol is undefined. We could not
4156 do this earlier, because check_dynamic_reloc might want
4157 to skip this reloc. */
4158 if (hundef && ! finfo->info->shared && ! r_baserel)
4159 {
4160 const char *name;
252b5132 4161
116c20d2
NC		 4162 if (h != NULL)
4163 name = h->root.root.string;
4164 else
4165 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
4166 if (! ((*finfo->info->callbacks->undefined_symbol)
4167 (finfo->info, name, input_bfd, input_section,
4168 r_addr, TRUE)))
4169 return FALSE;
4170 }
252b5132 4171
116c20d2
NC		 4172 r = MY_final_link_relocate (howto,
4173 input_bfd, input_section,
4174 contents, r_addr, relocation,
4175 (bfd_vma) 0);
252b5132 4176 }
252b5132 4177
116c20d2
NC		 4178 if (r != bfd_reloc_ok)
4179 {
4180 switch (r)
4181 {
4182 default:
4183 case bfd_reloc_outofrange:
4184 abort ();
4185 case bfd_reloc_overflow:
4186 {
4187 const char *name;
252b5132 4188
116c20d2
NC		 4189 if (h != NULL)
4190 name = NULL;
4191 else if (r_extern)
4192 name = strings + GET_WORD (input_bfd,
4193 syms[r_index].e_strx);
4194 else
4195 {
4196 asection *s;
252b5132 4197
116c20d2
NC		 4198 s = aout_reloc_index_to_section (input_bfd, r_index);
4199 name = bfd_section_name (input_bfd, s);
4200 }
4201 if (! ((*finfo->info->callbacks->reloc_overflow)
4202 (finfo->info, (h ? &h->root : NULL), name,
4203 howto->name, (bfd_vma) 0, input_bfd,
4204 input_section, r_addr)))
4205 return FALSE;
4206 }
4207 break;
4208 }
4209 }
252b5132
RH		 4210 }
4211
b34976b6 4212 return TRUE;
252b5132
RH		 4213}
4214
116c20d2 4215/* Relocate an a.out section using extended a.out relocs. */
252b5132 4216
b34976b6 4217static bfd_boolean
116c20d2
NC		 4218aout_link_input_section_ext (struct aout_final_link_info *finfo,
4219 bfd *input_bfd,
4220 asection *input_section,
4221 struct reloc_ext_external *relocs,
4222 bfd_size_type rel_size,
4223 bfd_byte *contents)
252b5132 4224{
b34976b6 4225 bfd_boolean (*check_dynamic_reloc)
116c20d2
NC		 4226 (struct bfd_link_info *, bfd *, asection *,
4227 struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
4228 bfd_vma *);
252b5132 4229 bfd *output_bfd;
1049f94e 4230 bfd_boolean relocatable;
252b5132
RH		 4231 struct external_nlist *syms;
4232 char *strings;
4233 struct aout_link_hash_entry **sym_hashes;
4234 int *symbol_map;
4235 bfd_size_type reloc_count;
116c20d2
NC		 4236 struct reloc_ext_external *rel;
4237 struct reloc_ext_external *rel_end;
252b5132
RH		 4238
4239 output_bfd = finfo->output_bfd;
4240 check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
4241
116c20d2 4242 BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_EXT_SIZE);
252b5132
RH		 4243 BFD_ASSERT (input_bfd->xvec->header_byteorder
4244 == output_bfd->xvec->header_byteorder);
4245
1049f94e 4246 relocatable = finfo->info->relocatable;
252b5132
RH		 4247 syms = obj_aout_external_syms (input_bfd);
4248 strings = obj_aout_external_strings (input_bfd);
4249 sym_hashes = obj_aout_sym_hashes (input_bfd);
4250 symbol_map = finfo->symbol_map;
4251
116c20d2 4252 reloc_count = rel_size / RELOC_EXT_SIZE;
252b5132
RH		 4253 rel = relocs;
4254 rel_end = rel + reloc_count;
4255 for (; rel < rel_end; rel++)
4256 {
4257 bfd_vma r_addr;
4258 int r_index;
4259 int r_extern;
116c20d2
NC		 4260 unsigned int r_type;
4261 bfd_vma r_addend;
252b5132 4262 struct aout_link_hash_entry *h = NULL;
116c20d2 4263 asection *r_section = NULL;
252b5132 4264 bfd_vma relocation;
252b5132
RH		 4265
4266 r_addr = GET_SWORD (input_bfd, rel->r_address);
4267
116c20d2
NC		 4268 if (bfd_header_big_endian (input_bfd))
4269 {
4270 r_index = (((unsigned int) rel->r_index[0] << 16)
4271 | ((unsigned int) rel->r_index[1] << 8)
4272 | rel->r_index[2]);
4273 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
4274 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
4275 >> RELOC_EXT_BITS_TYPE_SH_BIG);
4276 }
4277 else
4278 {
4279 r_index = (((unsigned int) rel->r_index[2] << 16)
4280 | ((unsigned int) rel->r_index[1] << 8)
4281 | rel->r_index[0]);
4282 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
4283 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
4284 >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
4285 }
252b5132 4286
116c20d2 4287 r_addend = GET_SWORD (input_bfd, rel->r_addend);
252b5132 4288
116c20d2 4289 BFD_ASSERT (r_type < TABLE_SIZE (howto_table_ext));
252b5132 4290
1049f94e 4291 if (relocatable)
252b5132 4292 {
1049f94e 4293 /* We are generating a relocatable output file, and must
252b5132 4294 modify the reloc accordingly. */
116c20d2
NC		 4295 if (r_extern
4296 || r_type == (unsigned int) RELOC_BASE10
4297 || r_type == (unsigned int) RELOC_BASE13
4298 || r_type == (unsigned int) RELOC_BASE22)
252b5132
RH		 4299 {
4300 /* If we know the symbol this relocation is against,
4301 convert it into a relocation against a section. This
4302 is what the native linker does. */
116c20d2
NC		 4303 if (r_type == (unsigned int) RELOC_BASE10
4304 || r_type == (unsigned int) RELOC_BASE13
4305 || r_type == (unsigned int) RELOC_BASE22)
4306 h = NULL;
4307 else
4308 h = sym_hashes[r_index];
4309 if (h != NULL
252b5132
RH		 4310 && (h->root.type == bfd_link_hash_defined
4311 || h->root.type == bfd_link_hash_defweak))
4312 {
4313 asection *output_section;
4314
4315 /* Change the r_extern value. */
4316 if (bfd_header_big_endian (output_bfd))
116c20d2 4317 rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_BIG;
252b5132 4318 else
116c20d2 4319 rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_LITTLE;
252b5132
RH		 4320
4321 /* Compute a new r_index. */
4322 output_section = h->root.u.def.section->output_section;
4323 if (output_section == obj_textsec (output_bfd))
4324 r_index = N_TEXT;
4325 else if (output_section == obj_datasec (output_bfd))
4326 r_index = N_DATA;
4327 else if (output_section == obj_bsssec (output_bfd))
4328 r_index = N_BSS;
4329 else
4330 r_index = N_ABS;
4331
4332 /* Add the symbol value and the section VMA to the
116c20d2 4333 addend. */
252b5132
RH		 4334 relocation = (h->root.u.def.value
4335 + output_section->vma
4336 + h->root.u.def.section->output_offset);
116c20d2
NC		 4337
4338 /* Now RELOCATION is the VMA of the final
4339 destination. If this is a PC relative reloc,
4340 then ADDEND is the negative of the source VMA.
4341 We want to set ADDEND to the difference between
4342 the destination VMA and the source VMA, which
4343 means we must adjust RELOCATION by the change in
4344 the source VMA. This is done below. */
252b5132
RH		 4345 }
4346 else
4347 {
4348 /* We must change r_index according to the symbol
4349 map. */
4350 r_index = symbol_map[r_index];
4351
4352 if (r_index == -1)
4353 {
4354 if (h != NULL)
4355 {
4356 /* We decided to strip this symbol, but it
4357 turns out that we can't. Note that we
4358 lose the other and desc information here.
4359 I don't think that will ever matter for a
4360 global symbol. */
4361 if (h->indx < 0)
4362 {
4363 h->indx = -2;
b34976b6 4364 h->written = FALSE;
252b5132 4365 if (! aout_link_write_other_symbol (h,
116c20d2 4366 (void *) finfo))
b34976b6 4367 return FALSE;
252b5132
RH		 4368 }
4369 r_index = h->indx;
4370 }
4371 else
4372 {
4373 const char *name;
4374
4375 name = strings + GET_WORD (input_bfd,
4376 syms[r_index].e_strx);
4377 if (! ((*finfo->info->callbacks->unattached_reloc)
4378 (finfo->info, name, input_bfd, input_section,
4379 r_addr)))
b34976b6 4380 return FALSE;
252b5132
RH		 4381 r_index = 0;
4382 }
4383 }
4384
4385 relocation = 0;
116c20d2
NC		 4386
4387 /* If this is a PC relative reloc, then the addend
4388 is the negative of the source VMA. We must
4389 adjust it by the change in the source VMA. This
4390 is done below. */
252b5132
RH		 4391 }
4392
4393 /* Write out the new r_index value. */
4394 if (bfd_header_big_endian (output_bfd))
4395 {
4396 rel->r_index[0] = r_index >> 16;
4397 rel->r_index[1] = r_index >> 8;
4398 rel->r_index[2] = r_index;
4399 }
4400 else
4401 {
4402 rel->r_index[2] = r_index >> 16;
4403 rel->r_index[1] = r_index >> 8;
4404 rel->r_index[0] = r_index;
4405 }
4406 }
4407 else
4408 {
252b5132
RH		 4409 /* This is a relocation against a section. We must
4410 adjust by the amount that the section moved. */
116c20d2
NC		 4411 r_section = aout_reloc_index_to_section (input_bfd, r_index);
4412 relocation = (r_section->output_section->vma
4413 + r_section->output_offset
4414 - r_section->vma);
252b5132 4415
116c20d2
NC		 4416 /* If this is a PC relative reloc, then the addend is
4417 the difference in VMA between the destination and the
4418 source. We have just adjusted for the change in VMA
4419 of the destination, so we must also adjust by the
4420 change in VMA of the source. This is done below. */
4421 }
252b5132 4422
116c20d2
NC		 4423 /* As described above, we must always adjust a PC relative
4424 reloc by the change in VMA of the source. However, if
4425 pcrel_offset is set, then the addend does not include the
4426 location within the section, in which case we don't need
4427 to adjust anything. */
4428 if (howto_table_ext[r_type].pc_relative
4429 && ! howto_table_ext[r_type].pcrel_offset)
252b5132
RH		 4430 relocation -= (input_section->output_section->vma
4431 + input_section->output_offset
4432 - input_section->vma);
4433
116c20d2
NC		 4434 /* Change the addend if necessary. */
4435 if (relocation != 0)
4436 PUT_WORD (output_bfd, r_addend + relocation, rel->r_addend);
252b5132 4437
116c20d2
NC		 4438 /* Change the address of the relocation. */
4439 PUT_WORD (output_bfd,
4440 r_addr + input_section->output_offset,
4441 rel->r_address);
252b5132
RH		 4442 }
4443 else
4444 {
b34976b6 4445 bfd_boolean hundef;
116c20d2 4446 bfd_reloc_status_type r;
252b5132
RH		 4447
4448 /* We are generating an executable, and must do a full
4449 relocation. */
b34976b6 4450 hundef = FALSE;
252b5132
RH		 4451
4452 if (r_extern)
4453 {
4454 h = sym_hashes[r_index];
4455
116c20d2 4456 if (h != NULL
252b5132
RH		 4457 && (h->root.type == bfd_link_hash_defined
4458 || h->root.type == bfd_link_hash_defweak))
4459 {
4460 relocation = (h->root.u.def.value
4461 + h->root.u.def.section->output_section->vma
4462 + h->root.u.def.section->output_offset);
4463 }
116c20d2 4464 else if (h != NULL
252b5132
RH		 4465 && h->root.type == bfd_link_hash_undefweak)
4466 relocation = 0;
4467 else
4468 {
b34976b6 4469 hundef = TRUE;
252b5132
RH		 4470 relocation = 0;
4471 }
4472 }
116c20d2
NC		 4473 else if (r_type == (unsigned int) RELOC_BASE10
4474 || r_type == (unsigned int) RELOC_BASE13
4475 || r_type == (unsigned int) RELOC_BASE22)
4476 {
4477 struct external_nlist *sym;
4478 int type;
4479
4480 /* For base relative relocs, r_index is always an index
4481 into the symbol table, even if r_extern is 0. */
4482 sym = syms + r_index;
4483 type = H_GET_8 (input_bfd, sym->e_type);
4484 if ((type & N_TYPE) == N_TEXT
4485 || type == N_WEAKT)
4486 r_section = obj_textsec (input_bfd);
4487 else if ((type & N_TYPE) == N_DATA
4488 || type == N_WEAKD)
4489 r_section = obj_datasec (input_bfd);
4490 else if ((type & N_TYPE) == N_BSS
4491 || type == N_WEAKB)
4492 r_section = obj_bsssec (input_bfd);
4493 else if ((type & N_TYPE) == N_ABS
4494 || type == N_WEAKA)
4495 r_section = bfd_abs_section_ptr;
4496 else
4497 abort ();
4498 relocation = (r_section->output_section->vma
4499 + r_section->output_offset
4500 + (GET_WORD (input_bfd, sym->e_value)
4501 - r_section->vma));
4502 }
252b5132
RH		 4503 else
4504 {
116c20d2 4505 r_section = aout_reloc_index_to_section (input_bfd, r_index);
252b5132 4506
116c20d2
NC		 4507 /* If this is a PC relative reloc, then R_ADDEND is the
4508 difference between the two vmas, or
4509 old_dest_sec + old_dest_off - (old_src_sec + old_src_off)
4510 where
4511 old_dest_sec == section->vma
4512 and
4513 old_src_sec == input_section->vma
4514 and
4515 old_src_off == r_addr
4516
4517 _bfd_final_link_relocate expects RELOCATION +
4518 R_ADDEND to be the VMA of the destination minus
4519 r_addr (the minus r_addr is because this relocation
4520 is not pcrel_offset, which is a bit confusing and
4521 should, perhaps, be changed), or
4522 new_dest_sec
4523 where
4524 new_dest_sec == output_section->vma + output_offset
4525 We arrange for this to happen by setting RELOCATION to
4526 new_dest_sec + old_src_sec - old_dest_sec
4527
4528 If this is not a PC relative reloc, then R_ADDEND is
4529 simply the VMA of the destination, so we set
4530 RELOCATION to the change in the destination VMA, or
4531 new_dest_sec - old_dest_sec
4532 */
4533 relocation = (r_section->output_section->vma
4534 + r_section->output_offset
4535 - r_section->vma);
4536 if (howto_table_ext[r_type].pc_relative)
252b5132
RH		 4537 relocation += input_section->vma;
4538 }
4539
4540 if (check_dynamic_reloc != NULL)
4541 {
b34976b6 4542 bfd_boolean skip;
252b5132
RH		 4543
4544 if (! ((*check_dynamic_reloc)
4545 (finfo->info, input_bfd, input_section, h,
116c20d2 4546 (void *) rel, contents, &skip, &relocation)))
b34976b6 4547 return FALSE;
252b5132
RH		 4548 if (skip)
4549 continue;
4550 }
4551
4552 /* Now warn if a global symbol is undefined. We could not
4553 do this earlier, because check_dynamic_reloc might want
4554 to skip this reloc. */
116c20d2
NC		 4555 if (hundef
4556 && ! finfo->info->shared
4557 && r_type != (unsigned int) RELOC_BASE10
4558 && r_type != (unsigned int) RELOC_BASE13
4559 && r_type != (unsigned int) RELOC_BASE22)
252b5132
RH		 4560 {
4561 const char *name;
4562
4563 if (h != NULL)
4564 name = h->root.root.string;
4565 else
4566 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
4567 if (! ((*finfo->info->callbacks->undefined_symbol)
5cc7c785 4568 (finfo->info, name, input_bfd, input_section,
b34976b6
AM		 4569 r_addr, TRUE)))
4570 return FALSE;
252b5132
RH		 4571 }
4572
116c20d2
NC		 4573 if (r_type != (unsigned int) RELOC_SPARC_REV32)
4574 r = MY_final_link_relocate (howto_table_ext + r_type,
4575 input_bfd, input_section,
4576 contents, r_addr, relocation,
4577 r_addend);
4578 else
252b5132 4579 {
116c20d2 4580 bfd_vma x;
252b5132 4581
116c20d2
NC		 4582 x = bfd_get_32 (input_bfd, contents + r_addr);
4583 x = x + relocation + r_addend;
4584 bfd_putl32 (/*input_bfd,*/ x, contents + r_addr);
4585 r = bfd_reloc_ok;
4586 }
4587
4588 if (r != bfd_reloc_ok)
4589 {
4590 switch (r)
4591 {
4592 default:
4593 case bfd_reloc_outofrange:
4594 abort ();
4595 case bfd_reloc_overflow:
252b5132 4596 {
116c20d2 4597 const char *name;
252b5132 4598
116c20d2
NC		 4599 if (h != NULL)
4600 name = NULL;
4601 else if (r_extern
4602 || r_type == (unsigned int) RELOC_BASE10
4603 || r_type == (unsigned int) RELOC_BASE13
4604 || r_type == (unsigned int) RELOC_BASE22)
4605 name = strings + GET_WORD (input_bfd,
4606 syms[r_index].e_strx);
4607 else
4608 {
4609 asection *s;
4610
4611 s = aout_reloc_index_to_section (input_bfd, r_index);
4612 name = bfd_section_name (input_bfd, s);
4613 }
4614 if (! ((*finfo->info->callbacks->reloc_overflow)
4615 (finfo->info, (h ? &h->root : NULL), name,
4616 howto_table_ext[r_type].name,
4617 r_addend, input_bfd, input_section, r_addr)))
4618 return FALSE;
252b5132 4619 }
116c20d2
NC		 4620 break;
4621 }
252b5132
RH		 4622 }
4623 }
4624 }
4625
b34976b6 4626 return TRUE;
252b5132
RH		 4627}
4628
116c20d2
NC		 4629/* Link an a.out section into the output file. */
4630
4631static bfd_boolean
4632aout_link_input_section (struct aout_final_link_info *finfo,
4633 bfd *input_bfd,
4634 asection *input_section,
4635 file_ptr *reloff_ptr,
4636 bfd_size_type rel_size)
4637{
4638 bfd_size_type input_size;
4639 void * relocs;
4640
4641 /* Get the section contents. */
4642 input_size = input_section->size;
4643 if (! bfd_get_section_contents (input_bfd, input_section,
4644 (void *) finfo->contents,
4645 (file_ptr) 0, input_size))
4646 return FALSE;
4647
4648 /* Read in the relocs if we haven't already done it. */
4649 if (aout_section_data (input_section) != NULL
4650 && aout_section_data (input_section)->relocs != NULL)
4651 relocs = aout_section_data (input_section)->relocs;
4652 else
4653 {
4654 relocs = finfo->relocs;
4655 if (rel_size > 0)
4656 {
4657 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4658 || bfd_bread (relocs, rel_size, input_bfd) != rel_size)
4659 return FALSE;
4660 }
4661 }
4662
4663 /* Relocate the section contents. */
4664 if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
4665 {
4666 if (! aout_link_input_section_std (finfo, input_bfd, input_section,
4667 (struct reloc_std_external *) relocs,
4668 rel_size, finfo->contents))
4669 return FALSE;
4670 }
4671 else
4672 {
4673 if (! aout_link_input_section_ext (finfo, input_bfd, input_section,
4674 (struct reloc_ext_external *) relocs,
4675 rel_size, finfo->contents))
4676 return FALSE;
4677 }
4678
4679 /* Write out the section contents. */
4680 if (! bfd_set_section_contents (finfo->output_bfd,
4681 input_section->output_section,
4682 (void *) finfo->contents,
4683 (file_ptr) input_section->output_offset,
4684 input_size))
4685 return FALSE;
4686
4687 /* If we are producing relocatable output, the relocs were
4688 modified, and we now write them out. */
4689 if (finfo->info->relocatable && rel_size > 0)
4690 {
4691 if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
4692 return FALSE;
4693 if (bfd_bwrite (relocs, rel_size, finfo->output_bfd) != rel_size)
4694 return FALSE;
4695 *reloff_ptr += rel_size;
4696
4697 /* Assert that the relocs have not run into the symbols, and
4698 that if these are the text relocs they have not run into the
4699 data relocs. */
4700 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
4701 && (reloff_ptr != &finfo->treloff
4702 || (*reloff_ptr
4703 <= obj_datasec (finfo->output_bfd)->rel_filepos)));
4704 }
4705
4706 return TRUE;
4707}
4708
4709/* Adjust and write out the symbols for an a.out file. Set the new
4710 symbol indices into a symbol_map. */
252b5132 4711
b34976b6 4712static bfd_boolean
116c20d2 4713aout_link_write_symbols (struct aout_final_link_info *finfo, bfd *input_bfd)
252b5132 4714{
252b5132 4715 bfd *output_bfd;
116c20d2 4716 bfd_size_type sym_count;
252b5132 4717 char *strings;
116c20d2
NC		 4718 enum bfd_link_strip strip;
4719 enum bfd_link_discard discard;
4720 struct external_nlist *outsym;
4721 bfd_size_type strtab_index;
4722 struct external_nlist *sym;
4723 struct external_nlist *sym_end;
4724 struct aout_link_hash_entry **sym_hash;
252b5132 4725 int *symbol_map;
116c20d2
NC		 4726 bfd_boolean pass;
4727 bfd_boolean skip_next;
252b5132
RH		 4728
4729 output_bfd = finfo->output_bfd;
116c20d2
NC		 4730 sym_count = obj_aout_external_sym_count (input_bfd);
4731 strings = obj_aout_external_strings (input_bfd);
4732 strip = finfo->info->strip;
4733 discard = finfo->info->discard;
4734 outsym = finfo->output_syms;
252b5132 4735
116c20d2
NC		 4736 /* First write out a symbol for this object file, unless we are
4737 discarding such symbols. */
4738 if (strip != strip_all
4739 && (strip != strip_some
4740 || bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
4741 FALSE, FALSE) != NULL)
4742 && discard != discard_all)
4743 {
4744 H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
4745 H_PUT_8 (output_bfd, 0, outsym->e_other);
4746 H_PUT_16 (output_bfd, 0, outsym->e_desc);
4747 strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4748 input_bfd->filename, FALSE);
4749 if (strtab_index == (bfd_size_type) -1)
4750 return FALSE;
4751 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4752 PUT_WORD (output_bfd,
4753 (bfd_get_section_vma (output_bfd,
4754 obj_textsec (input_bfd)->output_section)
4755 + obj_textsec (input_bfd)->output_offset),
4756 outsym->e_value);
4757 ++obj_aout_external_sym_count (output_bfd);
4758 ++outsym;
4759 }
252b5132 4760
116c20d2
NC		 4761 pass = FALSE;
4762 skip_next = FALSE;
4763 sym = obj_aout_external_syms (input_bfd);
4764 sym_end = sym + sym_count;
4765 sym_hash = obj_aout_sym_hashes (input_bfd);
252b5132 4766 symbol_map = finfo->symbol_map;
116c20d2
NC		 4767 memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
4768 for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
252b5132 4769 {
116c20d2
NC		 4770 const char *name;
4771 int type;
4772 struct aout_link_hash_entry *h;
4773 bfd_boolean skip;
4774 asection *symsec;
4775 bfd_vma val = 0;
4776 bfd_boolean copy;
252b5132 4777
116c20d2
NC		 4778 /* We set *symbol_map to 0 above for all symbols. If it has
4779 already been set to -1 for this symbol, it means that we are
4780 discarding it because it appears in a duplicate header file.
4781 See the N_BINCL code below. */
4782 if (*symbol_map == -1)
4783 continue;
252b5132 4784
116c20d2
NC		 4785 /* Initialize *symbol_map to -1, which means that the symbol was
4786 not copied into the output file. We will change it later if
4787 we do copy the symbol over. */
4788 *symbol_map = -1;
4789
4790 type = H_GET_8 (input_bfd, sym->e_type);
4791 name = strings + GET_WORD (input_bfd, sym->e_strx);
4792
4793 h = NULL;
4794
4795 if (pass)
252b5132 4796 {
116c20d2
NC		 4797 /* Pass this symbol through. It is the target of an
4798 indirect or warning symbol. */
4799 val = GET_WORD (input_bfd, sym->e_value);
4800 pass = FALSE;
252b5132 4801 }
116c20d2 4802 else if (skip_next)
252b5132 4803 {
116c20d2
NC		 4804 /* Skip this symbol, which is the target of an indirect
4805 symbol that we have changed to no longer be an indirect
4806 symbol. */
4807 skip_next = FALSE;
4808 continue;
252b5132 4809 }
116c20d2
NC		 4810 else
4811 {
4812 struct aout_link_hash_entry *hresolve;
252b5132 4813
116c20d2
NC		 4814 /* We have saved the hash table entry for this symbol, if
4815 there is one. Note that we could just look it up again
4816 in the hash table, provided we first check that it is an
4817 external symbol. */
4818 h = *sym_hash;
252b5132 4819
116c20d2
NC		 4820 /* Use the name from the hash table, in case the symbol was
4821 wrapped. */
4822 if (h != NULL
4823 && h->root.type != bfd_link_hash_warning)
4824 name = h->root.root.string;
252b5132 4825
116c20d2
NC		 4826 /* If this is an indirect or warning symbol, then change
4827 hresolve to the base symbol. We also change *sym_hash so
4828 that the relocation routines relocate against the real
4829 symbol. */
4830 hresolve = h;
4831 if (h != (struct aout_link_hash_entry *) NULL
4832 && (h->root.type == bfd_link_hash_indirect
4833 || h->root.type == bfd_link_hash_warning))
252b5132 4834 {
116c20d2
NC		 4835 hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
4836 while (hresolve->root.type == bfd_link_hash_indirect
4837 || hresolve->root.type == bfd_link_hash_warning)
4838 hresolve = ((struct aout_link_hash_entry *)
4839 hresolve->root.u.i.link);
4840 *sym_hash = hresolve;
4841 }
4842
4843 /* If the symbol has already been written out, skip it. */
4844 if (h != NULL
4845 && h->written)
4846 {
4847 if ((type & N_TYPE) == N_INDR
4848 || type == N_WARNING)
4849 skip_next = TRUE;
4850 *symbol_map = h->indx;
4851 continue;
4852 }
4853
4854 /* See if we are stripping this symbol. */
4855 skip = FALSE;
4856 switch (strip)
4857 {
4858 case strip_none:
4859 break;
4860 case strip_debugger:
4861 if ((type & N_STAB) != 0)
4862 skip = TRUE;
4863 break;
4864 case strip_some:
4865 if (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
4866 == NULL)
4867 skip = TRUE;
4868 break;
4869 case strip_all:
4870 skip = TRUE;
4871 break;
4872 }
4873 if (skip)
4874 {
4875 if (h != NULL)
4876 h->written = TRUE;
4877 continue;
4878 }
4879
4880 /* Get the value of the symbol. */
4881 if ((type & N_TYPE) == N_TEXT
4882 || type == N_WEAKT)
4883 symsec = obj_textsec (input_bfd);
4884 else if ((type & N_TYPE) == N_DATA
4885 || type == N_WEAKD)
4886 symsec = obj_datasec (input_bfd);
4887 else if ((type & N_TYPE) == N_BSS
4888 || type == N_WEAKB)
4889 symsec = obj_bsssec (input_bfd);
4890 else if ((type & N_TYPE) == N_ABS
4891 || type == N_WEAKA)
4892 symsec = bfd_abs_section_ptr;
4893 else if (((type & N_TYPE) == N_INDR
4894 && (hresolve == NULL
4895 || (hresolve->root.type != bfd_link_hash_defined
4896 && hresolve->root.type != bfd_link_hash_defweak
4897 && hresolve->root.type != bfd_link_hash_common)))
4898 || type == N_WARNING)
4899 {
4900 /* Pass the next symbol through unchanged. The
4901 condition above for indirect symbols is so that if
4902 the indirect symbol was defined, we output it with
4903 the correct definition so the debugger will
4904 understand it. */
4905 pass = TRUE;
4906 val = GET_WORD (input_bfd, sym->e_value);
4907 symsec = NULL;
4908 }
4909 else if ((type & N_STAB) != 0)
4910 {
4911 val = GET_WORD (input_bfd, sym->e_value);
4912 symsec = NULL;
4913 }
4914 else
4915 {
4916 /* If we get here with an indirect symbol, it means that
4917 we are outputting it with a real definition. In such
4918 a case we do not want to output the next symbol,
4919 which is the target of the indirection. */
4920 if ((type & N_TYPE) == N_INDR)
4921 skip_next = TRUE;
4922
4923 symsec = NULL;
4924
4925 /* We need to get the value from the hash table. We use
4926 hresolve so that if we have defined an indirect
4927 symbol we output the final definition. */
4928 if (h == NULL)
4929 {
4930 switch (type & N_TYPE)
4931 {
4932 case N_SETT:
4933 symsec = obj_textsec (input_bfd);
4934 break;
4935 case N_SETD:
4936 symsec = obj_datasec (input_bfd);
4937 break;
4938 case N_SETB:
4939 symsec = obj_bsssec (input_bfd);
4940 break;
4941 case N_SETA:
4942 symsec = bfd_abs_section_ptr;
4943 break;
4944 default:
4945 val = 0;
4946 break;
4947 }
4948 }
4949 else if (hresolve->root.type == bfd_link_hash_defined
4950 || hresolve->root.type == bfd_link_hash_defweak)
252b5132 4951 {
116c20d2 4952 asection *input_section;
252b5132
RH		 4953 asection *output_section;
4954
116c20d2
NC		 4955 /* This case usually means a common symbol which was
4956 turned into a defined symbol. */
4957 input_section = hresolve->root.u.def.section;
4958 output_section = input_section->output_section;
4959 BFD_ASSERT (bfd_is_abs_section (output_section)
4960 || output_section->owner == output_bfd);
4961 val = (hresolve->root.u.def.value
4962 + bfd_get_section_vma (output_bfd, output_section)
4963 + input_section->output_offset);
4964
4965 /* Get the correct type based on the section. If
4966 this is a constructed set, force it to be
4967 globally visible. */
4968 if (type == N_SETT
4969 || type == N_SETD
4970 || type == N_SETB
4971 || type == N_SETA)
4972 type |= N_EXT;
4973
4974 type &=~ N_TYPE;
252b5132 4975
252b5132 4976 if (output_section == obj_textsec (output_bfd))
116c20d2
NC		 4977 type |= (hresolve->root.type == bfd_link_hash_defined
4978 ? N_TEXT
4979 : N_WEAKT);
252b5132 4980 else if (output_section == obj_datasec (output_bfd))
116c20d2
NC		 4981 type |= (hresolve->root.type == bfd_link_hash_defined
4982 ? N_DATA
4983 : N_WEAKD);
252b5132 4984 else if (output_section == obj_bsssec (output_bfd))
116c20d2
NC		 4985 type |= (hresolve->root.type == bfd_link_hash_defined
4986 ? N_BSS
4987 : N_WEAKB);
252b5132 4988 else
116c20d2
NC		 4989 type |= (hresolve->root.type == bfd_link_hash_defined
4990 ? N_ABS
4991 : N_WEAKA);
4992 }
4993 else if (hresolve->root.type == bfd_link_hash_common)
4994 val = hresolve->root.u.c.size;
4995 else if (hresolve->root.type == bfd_link_hash_undefweak)
4996 {
4997 val = 0;
4998 type = N_WEAKU;
252b5132
RH		 4999 }
5000 else
116c20d2
NC		 5001 val = 0;
5002 }
5003 if (symsec != NULL)
5004 val = (symsec->output_section->vma
5005 + symsec->output_offset
5006 + (GET_WORD (input_bfd, sym->e_value)
5007 - symsec->vma));
5008
5009 /* If this is a global symbol set the written flag, and if
5010 it is a local symbol see if we should discard it. */
5011 if (h != NULL)
5012 {
5013 h->written = TRUE;
5014 h->indx = obj_aout_external_sym_count (output_bfd);
5015 }
5016 else if ((type & N_TYPE) != N_SETT
5017 && (type & N_TYPE) != N_SETD
5018 && (type & N_TYPE) != N_SETB
5019 && (type & N_TYPE) != N_SETA)
5020 {
5021 switch (discard)
252b5132 5022 {
116c20d2
NC		 5023 case discard_none:
5024 case discard_sec_merge:
5025 break;
5026 case discard_l:
5027 if ((type & N_STAB) == 0
5028 && bfd_is_local_label_name (input_bfd, name))
5029 skip = TRUE;
5030 break;
5031 case discard_all:
5032 skip = TRUE;
5033 break;
5034 }
5035 if (skip)
5036 {
5037 pass = FALSE;
5038 continue;
5039 }
5040 }
252b5132 5041
116c20d2
NC		 5042 /* An N_BINCL symbol indicates the start of the stabs
5043 entries for a header file. We need to scan ahead to the
5044 next N_EINCL symbol, ignoring nesting, adding up all the
5045 characters in the symbol names, not including the file
5046 numbers in types (the first number after an open
5047 parenthesis). */
5048 if (type == (int) N_BINCL)
5049 {
5050 struct external_nlist *incl_sym;
5051 int nest;
5052 struct aout_link_includes_entry *incl_entry;
5053 struct aout_link_includes_totals *t;
5054
5055 val = 0;
5056 nest = 0;
5057 for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++)
5058 {
5059 int incl_type;
5060
5061 incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
5062 if (incl_type == (int) N_EINCL)
252b5132 5063 {
116c20d2
NC		 5064 if (nest == 0)
5065 break;
5066 --nest;
5067 }
5068 else if (incl_type == (int) N_BINCL)
5069 ++nest;
5070 else if (nest == 0)
5071 {
5072 const char *s;
5073
5074 s = strings + GET_WORD (input_bfd, incl_sym->e_strx);
5075 for (; *s != '\0'; s++)
252b5132 5076 {
116c20d2
NC		 5077 val += *s;
5078 if (*s == '(')
252b5132 5079 {
116c20d2
NC		 5080 /* Skip the file number. */
5081 ++s;
5082 while (ISDIGIT (*s))
5083 ++s;
5084 --s;
252b5132 5085 }
252b5132 5086 }
116c20d2
NC		 5087 }
5088 }
252b5132 5089
116c20d2
NC		 5090 /* If we have already included a header file with the
5091 same value, then replace this one with an N_EXCL
5092 symbol. */
5093 copy = (bfd_boolean) (! finfo->info->keep_memory);
5094 incl_entry = aout_link_includes_lookup (&finfo->includes,
5095 name, TRUE, copy);
5096 if (incl_entry == NULL)
5097 return FALSE;
5098 for (t = incl_entry->totals; t != NULL; t = t->next)
5099 if (t->total == val)
5100 break;
5101 if (t == NULL)
5102 {
5103 /* This is the first time we have seen this header
5104 file with this set of stabs strings. */
5105 t = bfd_hash_allocate (&finfo->includes.root,
5106 sizeof *t);
5107 if (t == NULL)
5108 return FALSE;
5109 t->total = val;
5110 t->next = incl_entry->totals;
5111 incl_entry->totals = t;
5112 }
5113 else
5114 {
5115 int *incl_map;
5116
5117 /* This is a duplicate header file. We must change
5118 it to be an N_EXCL entry, and mark all the
5119 included symbols to prevent outputting them. */
5120 type = (int) N_EXCL;
5121
5122 nest = 0;
5123 for (incl_sym = sym + 1, incl_map = symbol_map + 1;
5124 incl_sym < sym_end;
5125 incl_sym++, incl_map++)
5126 {
5127 int incl_type;
5128
5129 incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
5130 if (incl_type == (int) N_EINCL)
5131 {
5132 if (nest == 0)
5133 {
5134 *incl_map = -1;
5135 break;
5136 }
5137 --nest;
252b5132 5138 }
116c20d2
NC		 5139 else if (incl_type == (int) N_BINCL)
5140 ++nest;
5141 else if (nest == 0)
5142 *incl_map = -1;
252b5132 5143 }
252b5132
RH		 5144 }
5145 }
116c20d2
NC		 5146 }
5147
5148 /* Copy this symbol into the list of symbols we are going to
5149 write out. */
5150 H_PUT_8 (output_bfd, type, outsym->e_type);
5151 H_PUT_8 (output_bfd, H_GET_8 (input_bfd, sym->e_other), outsym->e_other);
5152 H_PUT_16 (output_bfd, H_GET_16 (input_bfd, sym->e_desc), outsym->e_desc);
5153 copy = FALSE;
5154 if (! finfo->info->keep_memory)
5155 {
5156 /* name points into a string table which we are going to
5157 free. If there is a hash table entry, use that string.
5158 Otherwise, copy name into memory. */
5159 if (h != NULL)
5160 name = h->root.root.string;
252b5132 5161 else
116c20d2
NC		 5162 copy = TRUE;
5163 }
5164 strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
5165 name, copy);
5166 if (strtab_index == (bfd_size_type) -1)
5167 return FALSE;
5168 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
5169 PUT_WORD (output_bfd, val, outsym->e_value);
5170 *symbol_map = obj_aout_external_sym_count (output_bfd);
5171 ++obj_aout_external_sym_count (output_bfd);
5172 ++outsym;
5173 }
252b5132 5174
116c20d2
NC		 5175 /* Write out the output symbols we have just constructed. */
5176 if (outsym > finfo->output_syms)
5177 {
5178 bfd_size_type outsym_size;
252b5132 5179
116c20d2
NC		 5180 if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
5181 return FALSE;
5182 outsym_size = outsym - finfo->output_syms;
5183 outsym_size *= EXTERNAL_NLIST_SIZE;
5184 if (bfd_bwrite ((void *) finfo->output_syms, outsym_size, output_bfd)
5185 != outsym_size)
5186 return FALSE;
5187 finfo->symoff += outsym_size;
5188 }
252b5132 5189
116c20d2
NC		 5190 return TRUE;
5191}
252b5132 5192
116c20d2 5193/* Link an a.out input BFD into the output file. */
252b5132 5194
116c20d2
NC		 5195static bfd_boolean
5196aout_link_input_bfd (struct aout_final_link_info *finfo, bfd *input_bfd)
5197{
5198 bfd_size_type sym_count;
252b5132 5199
116c20d2 5200 BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
252b5132 5201
116c20d2
NC		 5202 /* If this is a dynamic object, it may need special handling. */
5203 if ((input_bfd->flags & DYNAMIC) != 0
5204 && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
5205 return ((*aout_backend_info (input_bfd)->link_dynamic_object)
5206 (finfo->info, input_bfd));
252b5132 5207
116c20d2
NC		 5208 /* Get the symbols. We probably have them already, unless
5209 finfo->info->keep_memory is FALSE. */
5210 if (! aout_get_external_symbols (input_bfd))
5211 return FALSE;
252b5132 5212
116c20d2 5213 sym_count = obj_aout_external_sym_count (input_bfd);
252b5132 5214
116c20d2
NC		 5215 /* Write out the symbols and get a map of the new indices. The map
5216 is placed into finfo->symbol_map. */
5217 if (! aout_link_write_symbols (finfo, input_bfd))
5218 return FALSE;
252b5132 5219
116c20d2
NC		 5220 /* Relocate and write out the sections. These functions use the
5221 symbol map created by aout_link_write_symbols. The linker_mark
5222 field will be set if these sections are to be included in the
5223 link, which will normally be the case. */
5224 if (obj_textsec (input_bfd)->linker_mark)
5225 {
5226 if (! aout_link_input_section (finfo, input_bfd,
5227 obj_textsec (input_bfd),
5228 &finfo->treloff,
5229 exec_hdr (input_bfd)->a_trsize))
5230 return FALSE;
5231 }
5232 if (obj_datasec (input_bfd)->linker_mark)
5233 {
5234 if (! aout_link_input_section (finfo, input_bfd,
5235 obj_datasec (input_bfd),
5236 &finfo->dreloff,
5237 exec_hdr (input_bfd)->a_drsize))
5238 return FALSE;
5239 }
5240
5241 /* If we are not keeping memory, we don't need the symbols any
5242 longer. We still need them if we are keeping memory, because the
5243 strings in the hash table point into them. */
5244 if (! finfo->info->keep_memory)
5245 {
5246 if (! aout_link_free_symbols (input_bfd))
5247 return FALSE;
5248 }
5249
5250 return TRUE;
5251}
5252
5253/* Do the final link step. This is called on the output BFD. The
5254 INFO structure should point to a list of BFDs linked through the
5255 link_next field which can be used to find each BFD which takes part
5256 in the output. Also, each section in ABFD should point to a list
5257 of bfd_link_order structures which list all the input sections for
5258 the output section. */
5259
5260bfd_boolean
5261NAME (aout, final_link) (bfd *abfd,
5262 struct bfd_link_info *info,
5263 void (*callback) (bfd *, file_ptr *, file_ptr *, file_ptr *))
5264{
5265 struct aout_final_link_info aout_info;
5266 bfd_boolean includes_hash_initialized = FALSE;
5267 bfd *sub;
5268 bfd_size_type trsize, drsize;
5269 bfd_size_type max_contents_size;
5270 bfd_size_type max_relocs_size;
5271 bfd_size_type max_sym_count;
5272 bfd_size_type text_size;
5273 file_ptr text_end;
5274 struct bfd_link_order *p;
5275 asection *o;
5276 bfd_boolean have_link_order_relocs;
5277
5278 if (info->shared)
5279 abfd->flags |= DYNAMIC;
5280
5281 aout_info.info = info;
5282 aout_info.output_bfd = abfd;
5283 aout_info.contents = NULL;
5284 aout_info.relocs = NULL;
5285 aout_info.symbol_map = NULL;
5286 aout_info.output_syms = NULL;
252b5132 5287
66eb6687
AM		 5288 if (!bfd_hash_table_init_n (&aout_info.includes.root,
5289 aout_link_includes_newfunc,
5290 sizeof (struct aout_link_includes_entry),
5291 251))
116c20d2
NC		 5292 goto error_return;
5293 includes_hash_initialized = TRUE;
252b5132 5294
116c20d2
NC		 5295 /* Figure out the largest section size. Also, if generating
5296 relocatable output, count the relocs. */
5297 trsize = 0;
5298 drsize = 0;
5299 max_contents_size = 0;
5300 max_relocs_size = 0;
5301 max_sym_count = 0;
5302 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
5303 {
5304 bfd_size_type sz;
252b5132 5305
116c20d2
NC		 5306 if (info->relocatable)
5307 {
5308 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
252b5132 5309 {
116c20d2
NC		 5310 trsize += exec_hdr (sub)->a_trsize;
5311 drsize += exec_hdr (sub)->a_drsize;
252b5132 5312 }
252b5132
RH		 5313 else
5314 {
116c20d2
NC		 5315 /* FIXME: We need to identify the .text and .data sections
5316 and call get_reloc_upper_bound and canonicalize_reloc to
5317 work out the number of relocs needed, and then multiply
5318 by the reloc size. */
5319 (*_bfd_error_handler)
5320 (_("%s: relocatable link from %s to %s not supported"),
5321 bfd_get_filename (abfd),
5322 sub->xvec->name, abfd->xvec->name);
5323 bfd_set_error (bfd_error_invalid_operation);
5324 goto error_return;
252b5132 5325 }
116c20d2 5326 }
252b5132 5327
116c20d2
NC		 5328 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
5329 {
5330 sz = obj_textsec (sub)->size;
5331 if (sz > max_contents_size)
5332 max_contents_size = sz;
5333 sz = obj_datasec (sub)->size;
5334 if (sz > max_contents_size)
5335 max_contents_size = sz;
252b5132 5336
116c20d2
NC		 5337 sz = exec_hdr (sub)->a_trsize;
5338 if (sz > max_relocs_size)
5339 max_relocs_size = sz;
5340 sz = exec_hdr (sub)->a_drsize;
5341 if (sz > max_relocs_size)
5342 max_relocs_size = sz;
252b5132 5343
116c20d2
NC		 5344 sz = obj_aout_external_sym_count (sub);
5345 if (sz > max_sym_count)
5346 max_sym_count = sz;
252b5132
RH		 5347 }
5348 }
5349
116c20d2
NC		 5350 if (info->relocatable)
5351 {
5352 if (obj_textsec (abfd) != NULL)
5353 trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
8423293d 5354 ->map_head.link_order)
116c20d2
NC		 5355 * obj_reloc_entry_size (abfd));
5356 if (obj_datasec (abfd) != NULL)
5357 drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
8423293d 5358 ->map_head.link_order)
116c20d2
NC		 5359 * obj_reloc_entry_size (abfd));
5360 }
252b5132 5361
116c20d2
NC		 5362 exec_hdr (abfd)->a_trsize = trsize;
5363 exec_hdr (abfd)->a_drsize = drsize;
252b5132 5364
116c20d2 5365 exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
252b5132 5366
116c20d2
NC		 5367 /* Adjust the section sizes and vmas according to the magic number.
5368 This sets a_text, a_data and a_bss in the exec_hdr and sets the
5369 filepos for each section. */
5370 if (! NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
5371 goto error_return;
252b5132 5372
116c20d2
NC		 5373 /* The relocation and symbol file positions differ among a.out
5374 targets. We are passed a callback routine from the backend
5375 specific code to handle this.
5376 FIXME: At this point we do not know how much space the symbol
5377 table will require. This will not work for any (nonstandard)
5378 a.out target that needs to know the symbol table size before it
5379 can compute the relocation file positions. This may or may not
5380 be the case for the hp300hpux target, for example. */
5381 (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
5382 &aout_info.symoff);
5383 obj_textsec (abfd)->rel_filepos = aout_info.treloff;
5384 obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
5385 obj_sym_filepos (abfd) = aout_info.symoff;
252b5132 5386
116c20d2
NC		 5387 /* We keep a count of the symbols as we output them. */
5388 obj_aout_external_sym_count (abfd) = 0;
5389
5390 /* We accumulate the string table as we write out the symbols. */
5391 aout_info.strtab = _bfd_stringtab_init ();
5392 if (aout_info.strtab == NULL)
5393 goto error_return;
5394
5395 /* Allocate buffers to hold section contents and relocs. */
5396 aout_info.contents = bfd_malloc (max_contents_size);
5397 aout_info.relocs = bfd_malloc (max_relocs_size);
5398 aout_info.symbol_map = bfd_malloc (max_sym_count * sizeof (int *));
5399 aout_info.output_syms = bfd_malloc ((max_sym_count + 1)
5400 * sizeof (struct external_nlist));
5401 if ((aout_info.contents == NULL && max_contents_size != 0)
5402 || (aout_info.relocs == NULL && max_relocs_size != 0)
5403 || (aout_info.symbol_map == NULL && max_sym_count != 0)
5404 || aout_info.output_syms == NULL)
5405 goto error_return;
5406
5407 /* If we have a symbol named __DYNAMIC, force it out now. This is
5408 required by SunOS. Doing this here rather than in sunos.c is a
5409 hack, but it's easier than exporting everything which would be
5410 needed. */
5411 {
5412 struct aout_link_hash_entry *h;
5413
5414 h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
5415 FALSE, FALSE, FALSE);
5416 if (h != NULL)
5417 aout_link_write_other_symbol (h, &aout_info);
5418 }
5419
5420 /* The most time efficient way to do the link would be to read all
5421 the input object files into memory and then sort out the
5422 information into the output file. Unfortunately, that will
5423 probably use too much memory. Another method would be to step
5424 through everything that composes the text section and write it
5425 out, and then everything that composes the data section and write
5426 it out, and then write out the relocs, and then write out the
5427 symbols. Unfortunately, that requires reading stuff from each
5428 input file several times, and we will not be able to keep all the
5429 input files open simultaneously, and reopening them will be slow.
5430
5431 What we do is basically process one input file at a time. We do
5432 everything we need to do with an input file once--copy over the
5433 section contents, handle the relocation information, and write
5434 out the symbols--and then we throw away the information we read
5435 from it. This approach requires a lot of lseeks of the output
5436 file, which is unfortunate but still faster than reopening a lot
5437 of files.
5438
5439 We use the output_has_begun field of the input BFDs to see
5440 whether we have already handled it. */
5441 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
5442 sub->output_has_begun = FALSE;
252b5132 5443
116c20d2
NC		 5444 /* Mark all sections which are to be included in the link. This
5445 will normally be every section. We need to do this so that we
5446 can identify any sections which the linker has decided to not
5447 include. */
5448 for (o = abfd->sections; o != NULL; o = o->next)
252b5132 5449 {
8423293d 5450 for (p = o->map_head.link_order; p != NULL; p = p->next)
116c20d2
NC		 5451 if (p->type == bfd_indirect_link_order)
5452 p->u.indirect.section->linker_mark = TRUE;
252b5132
RH		 5453 }
5454
116c20d2
NC		 5455 have_link_order_relocs = FALSE;
5456 for (o = abfd->sections; o != NULL; o = o->next)
252b5132 5457 {
8423293d 5458 for (p = o->map_head.link_order;
116c20d2
NC		 5459 p != NULL;
5460 p = p->next)
252b5132 5461 {
116c20d2
NC		 5462 if (p->type == bfd_indirect_link_order
5463 && (bfd_get_flavour (p->u.indirect.section->owner)
5464 == bfd_target_aout_flavour))
252b5132 5465 {
116c20d2
NC		 5466 bfd *input_bfd;
5467
5468 input_bfd = p->u.indirect.section->owner;
5469 if (! input_bfd->output_has_begun)
252b5132 5470 {
116c20d2
NC		 5471 if (! aout_link_input_bfd (&aout_info, input_bfd))
5472 goto error_return;
5473 input_bfd->output_has_begun = TRUE;
252b5132 5474 }
252b5132 5475 }
116c20d2
NC		 5476 else if (p->type == bfd_section_reloc_link_order
5477 || p->type == bfd_symbol_reloc_link_order)
5478 {
5479 /* These are handled below. */
5480 have_link_order_relocs = TRUE;
5481 }
5482 else
5483 {
5484 if (! _bfd_default_link_order (abfd, info, o, p))
5485 goto error_return;
5486 }
252b5132
RH		 5487 }
5488 }
252b5132 5489
116c20d2
NC		 5490 /* Write out any symbols that we have not already written out. */
5491 aout_link_hash_traverse (aout_hash_table (info),
5492 aout_link_write_other_symbol,
5493 (void *) &aout_info);
5494
5495 /* Now handle any relocs we were asked to create by the linker.
5496 These did not come from any input file. We must do these after
5497 we have written out all the symbols, so that we know the symbol
5498 indices to use. */
5499 if (have_link_order_relocs)
5500 {
5501 for (o = abfd->sections; o != NULL; o = o->next)
252b5132 5502 {
8423293d 5503 for (p = o->map_head.link_order;
116c20d2
NC		 5504 p != NULL;
5505 p = p->next)
5506 {
5507 if (p->type == bfd_section_reloc_link_order
5508 || p->type == bfd_symbol_reloc_link_order)
5509 {
5510 if (! aout_link_reloc_link_order (&aout_info, o, p))
5511 goto error_return;
5512 }
5513 }
252b5132 5514 }
116c20d2 5515 }
252b5132 5516
116c20d2
NC		 5517 if (aout_info.contents != NULL)
5518 {
5519 free (aout_info.contents);
5520 aout_info.contents = NULL;
5521 }
5522 if (aout_info.relocs != NULL)
5523 {
5524 free (aout_info.relocs);
5525 aout_info.relocs = NULL;
5526 }
5527 if (aout_info.symbol_map != NULL)
5528 {
5529 free (aout_info.symbol_map);
5530 aout_info.symbol_map = NULL;
5531 }
5532 if (aout_info.output_syms != NULL)
5533 {
5534 free (aout_info.output_syms);
5535 aout_info.output_syms = NULL;
5536 }
5537 if (includes_hash_initialized)
5538 {
5539 bfd_hash_table_free (&aout_info.includes.root);
5540 includes_hash_initialized = FALSE;
5541 }
252b5132 5542
116c20d2
NC		 5543 /* Finish up any dynamic linking we may be doing. */
5544 if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
5545 {
5546 if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
5547 goto error_return;
252b5132
RH		 5548 }
5549
116c20d2
NC		 5550 /* Update the header information. */
5551 abfd->symcount = obj_aout_external_sym_count (abfd);
5552 exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
5553 obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
5554 obj_textsec (abfd)->reloc_count =
5555 exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
5556 obj_datasec (abfd)->reloc_count =
5557 exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
252b5132 5558
116c20d2
NC		 5559 /* Write out the string table, unless there are no symbols. */
5560 if (abfd->symcount > 0)
5561 {
5562 if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
5563 || ! emit_stringtab (abfd, aout_info.strtab))
5564 goto error_return;
5565 }
5566 else if (obj_textsec (abfd)->reloc_count == 0
5567 && obj_datasec (abfd)->reloc_count == 0)
5568 {
5569 bfd_byte b;
5570 file_ptr pos;
252b5132 5571
116c20d2
NC		 5572 b = 0;
5573 pos = obj_datasec (abfd)->filepos + exec_hdr (abfd)->a_data - 1;
5574 if (bfd_seek (abfd, pos, SEEK_SET) != 0
5575 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
5576 goto error_return;
5577 }
252b5132 5578
b34976b6 5579 return TRUE;
116c20d2
NC		 5580
5581 error_return:
5582 if (aout_info.contents != NULL)
5583 free (aout_info.contents);
5584 if (aout_info.relocs != NULL)
5585 free (aout_info.relocs);
5586 if (aout_info.symbol_map != NULL)
5587 free (aout_info.symbol_map);
5588 if (aout_info.output_syms != NULL)
5589 free (aout_info.output_syms);
5590 if (includes_hash_initialized)
5591 bfd_hash_table_free (&aout_info.includes.root);
5592 return FALSE;
252b5132 5593}
GDB Binutils - Deliverables
This page took 0.768008 seconds and 4 git commands to generate.