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