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