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