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