projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bfd target vector rationalisation
[deliverable/binutils-gdb.git] / bfd / aoutx.h
CommitLineData
252b5132 1/* BFD semi-generic back-end for a.out binaries.
4b95cf5c 2 Copyright (C) 1990-2014 Free Software Foundation, Inc.
252b5132
RH		 3 Written by Cygnus Support.
4
f7c33884 5 This file is part of BFD, the Binary File Descriptor library.
252b5132 6
f7c33884
NC		 7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
cd123cb7 9 the Free Software Foundation; either version 3 of the License, or
f7c33884 10 (at your option) any later version.
252b5132 11
f7c33884
NC		 12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
252b5132 16
f7c33884
NC		 17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
cd123cb7
NC		 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
252b5132
RH		 21
22/*
23SECTION
24 a.out backends
25
252b5132
RH		 26DESCRIPTION
27
28 BFD supports a number of different flavours of a.out format,
29 though the major differences are only the sizes of the
30 structures on disk, and the shape of the relocation
31 information.
32
33 The support is split into a basic support file @file{aoutx.h}
34 and other files which derive functions from the base. One
35 derivation file is @file{aoutf1.h} (for a.out flavour 1), and
36 adds to the basic a.out functions support for sun3, sun4, 386
37 and 29k a.out files, to create a target jump vector for a
38 specific target.
39
40 This information is further split out into more specific files
41 for each machine, including @file{sunos.c} for sun3 and sun4,
42 @file{newsos3.c} for the Sony NEWS, and @file{demo64.c} for a
43 demonstration of a 64 bit a.out format.
44
45 The base file @file{aoutx.h} defines general mechanisms for
46 reading and writing records to and from disk and various
47 other methods which BFD requires. It is included by
48 @file{aout32.c} and @file{aout64.c} to form the names
49 <<aout_32_swap_exec_header_in>>, <<aout_64_swap_exec_header_in>>, etc.
50
51 As an example, this is what goes on to make the back end for a
52 sun4, from @file{aout32.c}:
53
54| #define ARCH_SIZE 32
55| #include "aoutx.h"
56
57 Which exports names:
58
59| ...
60| aout_32_canonicalize_reloc
61| aout_32_find_nearest_line
62| aout_32_get_lineno
63| aout_32_get_reloc_upper_bound
64| ...
65
66 from @file{sunos.c}:
67
68| #define TARGET_NAME "a.out-sunos-big"
6d00b590 69| #define VECNAME sparc_aout_sunos_be_vec
252b5132
RH		 70| #include "aoutf1.h"
71
72 requires all the names from @file{aout32.c}, and produces the jump vector
73
6d00b590 74| sparc_aout_sunos_be_vec
252b5132
RH		 75
76 The file @file{host-aout.c} is a special case. It is for a large set
77 of hosts that use ``more or less standard'' a.out files, and
78 for which cross-debugging is not interesting. It uses the
79 standard 32-bit a.out support routines, but determines the
80 file offsets and addresses of the text, data, and BSS
81 sections, the machine architecture and machine type, and the
82 entry point address, in a host-dependent manner. Once these
83 values have been determined, generic code is used to handle
84 the object file.
85
86 When porting it to run on a new system, you must supply:
87
88| HOST_PAGE_SIZE
89| HOST_SEGMENT_SIZE
90| HOST_MACHINE_ARCH (optional)
91| HOST_MACHINE_MACHINE (optional)
92| HOST_TEXT_START_ADDR
93| HOST_STACK_END_ADDR
94
95 in the file @file{../include/sys/h-@var{XXX}.h} (for your host). These
96 values, plus the structures and macros defined in @file{a.out.h} on
97 your host system, will produce a BFD target that will access
98 ordinary a.out files on your host. To configure a new machine
99 to use @file{host-aout.c}, specify:
100
101| TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec
102| TDEPFILES= host-aout.o trad-core.o
103
104 in the @file{config/@var{XXX}.mt} file, and modify @file{configure.in}
105 to use the
106 @file{@var{XXX}.mt} file (by setting "<<bfd_target=XXX>>") when your
5ed6aba4 107 configuration is selected. */
252b5132
RH		 108
109/* Some assumptions:
110 * Any BFD with D_PAGED set is ZMAGIC, and vice versa.
111 Doesn't matter what the setting of WP_TEXT is on output, but it'll
112 get set on input.
113 * Any BFD with D_PAGED clear and WP_TEXT set is NMAGIC.
114 * Any BFD with both flags clear is OMAGIC.
115 (Just want to make these explicit, so the conditions tested in this
116 file make sense if you're more familiar with a.out than with BFD.) */
117
118#define KEEPIT udata.i
119
252b5132 120#include "sysdep.h"
3db64b00 121#include "bfd.h"
3882b010 122#include "safe-ctype.h"
252b5132
RH		 123#include "bfdlink.h"
124
125#include "libaout.h"
126#include "libbfd.h"
127#include "aout/aout64.h"
128#include "aout/stab_gnu.h"
129#include "aout/ar.h"
130
252b5132
RH		 131/*
132SUBSECTION
133 Relocations
134
135DESCRIPTION
136 The file @file{aoutx.h} provides for both the @emph{standard}
137 and @emph{extended} forms of a.out relocation records.
138
139 The standard records contain only an
140 address, a symbol index, and a type field. The extended records
141 (used on 29ks and sparcs) also have a full integer for an
5ed6aba4 142 addend. */
252b5132 143
252b5132
RH		 144#ifndef CTOR_TABLE_RELOC_HOWTO
145#define CTOR_TABLE_RELOC_IDX 2
923f08ff
AM		 146#define CTOR_TABLE_RELOC_HOWTO(BFD) \
147 ((obj_reloc_entry_size (BFD) == RELOC_EXT_SIZE \
148 ? howto_table_ext : howto_table_std) \
149 + CTOR_TABLE_RELOC_IDX)
252b5132
RH		 150#endif
151
152#ifndef MY_swap_std_reloc_in
116c20d2 153#define MY_swap_std_reloc_in NAME (aout, swap_std_reloc_in)
252b5132
RH		 154#endif
155
1642229e 156#ifndef MY_swap_ext_reloc_in
116c20d2 157#define MY_swap_ext_reloc_in NAME (aout, swap_ext_reloc_in)
1642229e
HPN		 158#endif
159
252b5132 160#ifndef MY_swap_std_reloc_out
116c20d2 161#define MY_swap_std_reloc_out NAME (aout, swap_std_reloc_out)
252b5132
RH		 162#endif
163
1642229e 164#ifndef MY_swap_ext_reloc_out
116c20d2 165#define MY_swap_ext_reloc_out NAME (aout, swap_ext_reloc_out)
1642229e
HPN		 166#endif
167
252b5132
RH		 168#ifndef MY_final_link_relocate
169#define MY_final_link_relocate _bfd_final_link_relocate
170#endif
171
172#ifndef MY_relocate_contents
173#define MY_relocate_contents _bfd_relocate_contents
174#endif
175
116c20d2
NC		 176#define howto_table_ext NAME (aout, ext_howto_table)
177#define howto_table_std NAME (aout, std_howto_table)
252b5132
RH		 178
179reloc_howto_type howto_table_ext[] =
180{
116c20d2
NC		 181 /* Type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone. */
182 HOWTO (RELOC_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield, 0, "8", FALSE, 0, 0x000000ff, FALSE),
183 HOWTO (RELOC_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, 0, "16", FALSE, 0, 0x0000ffff, FALSE),
184 HOWTO (RELOC_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 0, "32", FALSE, 0, 0xffffffff, FALSE),
185 HOWTO (RELOC_DISP8, 0, 0, 8, TRUE, 0, complain_overflow_signed, 0, "DISP8", FALSE, 0, 0x000000ff, FALSE),
186 HOWTO (RELOC_DISP16, 0, 1, 16, TRUE, 0, complain_overflow_signed, 0, "DISP16", FALSE, 0, 0x0000ffff, FALSE),
187 HOWTO (RELOC_DISP32, 0, 2, 32, TRUE, 0, complain_overflow_signed, 0, "DISP32", FALSE, 0, 0xffffffff, FALSE),
188 HOWTO (RELOC_WDISP30, 2, 2, 30, TRUE, 0, complain_overflow_signed, 0, "WDISP30", FALSE, 0, 0x3fffffff, FALSE),
189 HOWTO (RELOC_WDISP22, 2, 2, 22, TRUE, 0, complain_overflow_signed, 0, "WDISP22", FALSE, 0, 0x003fffff, FALSE),
190 HOWTO (RELOC_HI22, 10, 2, 22, FALSE, 0, complain_overflow_bitfield, 0, "HI22", FALSE, 0, 0x003fffff, FALSE),
191 HOWTO (RELOC_22, 0, 2, 22, FALSE, 0, complain_overflow_bitfield, 0, "22", FALSE, 0, 0x003fffff, FALSE),
192 HOWTO (RELOC_13, 0, 2, 13, FALSE, 0, complain_overflow_bitfield, 0, "13", FALSE, 0, 0x00001fff, FALSE),
193 HOWTO (RELOC_LO10, 0, 2, 10, FALSE, 0, complain_overflow_dont, 0, "LO10", FALSE, 0, 0x000003ff, FALSE),
194 HOWTO (RELOC_SFA_BASE,0, 2, 32, FALSE, 0, complain_overflow_bitfield, 0, "SFA_BASE", FALSE, 0, 0xffffffff, FALSE),
195 HOWTO (RELOC_SFA_OFF13,0, 2, 32, FALSE, 0, complain_overflow_bitfield, 0, "SFA_OFF13", FALSE, 0, 0xffffffff, FALSE),
196 HOWTO (RELOC_BASE10, 0, 2, 10, FALSE, 0, complain_overflow_dont, 0, "BASE10", FALSE, 0, 0x000003ff, FALSE),
197 HOWTO (RELOC_BASE13, 0, 2, 13, FALSE, 0, complain_overflow_signed, 0, "BASE13", FALSE, 0, 0x00001fff, FALSE),
198 HOWTO (RELOC_BASE22, 10, 2, 22, FALSE, 0, complain_overflow_bitfield, 0, "BASE22", FALSE, 0, 0x003fffff, FALSE),
199 HOWTO (RELOC_PC10, 0, 2, 10, TRUE, 0, complain_overflow_dont, 0, "PC10", FALSE, 0, 0x000003ff, TRUE),
200 HOWTO (RELOC_PC22, 10, 2, 22, TRUE, 0, complain_overflow_signed, 0, "PC22", FALSE, 0, 0x003fffff, TRUE),
201 HOWTO (RELOC_JMP_TBL, 2, 2, 30, TRUE, 0, complain_overflow_signed, 0, "JMP_TBL", FALSE, 0, 0x3fffffff, FALSE),
202 HOWTO (RELOC_SEGOFF16,0, 2, 0, FALSE, 0, complain_overflow_bitfield, 0, "SEGOFF16", FALSE, 0, 0x00000000, FALSE),
203 HOWTO (RELOC_GLOB_DAT,0, 2, 0, FALSE, 0, complain_overflow_bitfield, 0, "GLOB_DAT", FALSE, 0, 0x00000000, FALSE),
204 HOWTO (RELOC_JMP_SLOT,0, 2, 0, FALSE, 0, complain_overflow_bitfield, 0, "JMP_SLOT", FALSE, 0, 0x00000000, FALSE),
205 HOWTO (RELOC_RELATIVE,0, 2, 0, FALSE, 0, complain_overflow_bitfield, 0, "RELATIVE", FALSE, 0, 0x00000000, FALSE),
206 HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, 0, "R_SPARC_NONE",FALSE, 0, 0x00000000, TRUE),
207 HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, 0, "R_SPARC_NONE",FALSE, 0, 0x00000000, TRUE),
252b5132 208#define RELOC_SPARC_REV32 RELOC_WDISP19
116c20d2 209 HOWTO (RELOC_SPARC_REV32, 0, 2, 32, FALSE, 0, complain_overflow_dont, 0,"R_SPARC_REV32",FALSE, 0, 0xffffffff, FALSE),
252b5132
RH		 210};
211
212/* Convert standard reloc records to "arelent" format (incl byte swap). */
213
5ed6aba4
NC		 214reloc_howto_type howto_table_std[] =
215{
f7c33884 216 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone. */
b34976b6
AM		 217HOWTO ( 0, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,0,"8", TRUE, 0x000000ff,0x000000ff, FALSE),
218HOWTO ( 1, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,0,"16", TRUE, 0x0000ffff,0x0000ffff, FALSE),
219HOWTO ( 2, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"32", TRUE, 0xffffffff,0xffffffff, FALSE),
220HOWTO ( 3, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,0,"64", TRUE, 0xdeaddead,0xdeaddead, FALSE),
221HOWTO ( 4, 0, 0, 8, TRUE, 0, complain_overflow_signed, 0,"DISP8", TRUE, 0x000000ff,0x000000ff, FALSE),
222HOWTO ( 5, 0, 1, 16, TRUE, 0, complain_overflow_signed, 0,"DISP16", TRUE, 0x0000ffff,0x0000ffff, FALSE),
223HOWTO ( 6, 0, 2, 32, TRUE, 0, complain_overflow_signed, 0,"DISP32", TRUE, 0xffffffff,0xffffffff, FALSE),
224HOWTO ( 7, 0, 4, 64, TRUE, 0, complain_overflow_signed, 0,"DISP64", TRUE, 0xfeedface,0xfeedface, FALSE),
225HOWTO ( 8, 0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"GOT_REL", FALSE, 0,0x00000000, FALSE),
226HOWTO ( 9, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,0,"BASE16", FALSE,0xffffffff,0xffffffff, FALSE),
227HOWTO (10, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"BASE32", FALSE,0xffffffff,0xffffffff, FALSE),
5f771d47
ILT		 228EMPTY_HOWTO (-1),
229EMPTY_HOWTO (-1),
230EMPTY_HOWTO (-1),
231EMPTY_HOWTO (-1),
232EMPTY_HOWTO (-1),
b34976b6 233 HOWTO (16, 0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"JMP_TABLE", FALSE, 0,0x00000000, FALSE),
5f771d47
ILT		 234EMPTY_HOWTO (-1),
235EMPTY_HOWTO (-1),
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),
b34976b6 249 HOWTO (32, 0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"RELATIVE", FALSE, 0,0x00000000, FALSE),
5f771d47
ILT		 250EMPTY_HOWTO (-1),
251EMPTY_HOWTO (-1),
252EMPTY_HOWTO (-1),
253EMPTY_HOWTO (-1),
254EMPTY_HOWTO (-1),
255EMPTY_HOWTO (-1),
256EMPTY_HOWTO (-1),
b34976b6 257 HOWTO (40, 0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"BASEREL", FALSE, 0,0x00000000, FALSE),
252b5132
RH		 258};
259
923f08ff 260#define TABLE_SIZE(TABLE) (sizeof (TABLE) / sizeof (TABLE[0]))
252b5132
RH		 261
262reloc_howto_type *
116c20d2 263NAME (aout, reloc_type_lookup) (bfd *abfd, bfd_reloc_code_real_type code)
252b5132 264{
116c20d2
NC		 265#define EXT(i, j) case i: return & howto_table_ext [j]
266#define STD(i, j) case i: return & howto_table_std [j]
252b5132 267 int ext = obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE;
f7c33884 268
252b5132 269 if (code == BFD_RELOC_CTOR)
30d10e9e 270 switch (bfd_arch_bits_per_address (abfd))
252b5132
RH		 271 {
272 case 32:
273 code = BFD_RELOC_32;
274 break;
275 case 64:
276 code = BFD_RELOC_64;
277 break;
278 }
f7c33884 279
252b5132
RH		 280 if (ext)
281 switch (code)
282 {
1642229e
HPN		 283 EXT (BFD_RELOC_8, 0);
284 EXT (BFD_RELOC_16, 1);
252b5132
RH		 285 EXT (BFD_RELOC_32, 2);
286 EXT (BFD_RELOC_HI22, 8);
287 EXT (BFD_RELOC_LO10, 11);
288 EXT (BFD_RELOC_32_PCREL_S2, 6);
289 EXT (BFD_RELOC_SPARC_WDISP22, 7);
290 EXT (BFD_RELOC_SPARC13, 10);
291 EXT (BFD_RELOC_SPARC_GOT10, 14);
292 EXT (BFD_RELOC_SPARC_BASE13, 15);
293 EXT (BFD_RELOC_SPARC_GOT13, 15);
294 EXT (BFD_RELOC_SPARC_GOT22, 16);
295 EXT (BFD_RELOC_SPARC_PC10, 17);
296 EXT (BFD_RELOC_SPARC_PC22, 18);
297 EXT (BFD_RELOC_SPARC_WPLT30, 19);
298 EXT (BFD_RELOC_SPARC_REV32, 26);
116c20d2
NC		 299 default:
300 return NULL;
252b5132
RH		 301 }
302 else
f7c33884 303 /* std relocs. */
252b5132
RH		 304 switch (code)
305 {
2846975a 306 STD (BFD_RELOC_8, 0);
252b5132
RH		 307 STD (BFD_RELOC_16, 1);
308 STD (BFD_RELOC_32, 2);
309 STD (BFD_RELOC_8_PCREL, 4);
310 STD (BFD_RELOC_16_PCREL, 5);
311 STD (BFD_RELOC_32_PCREL, 6);
312 STD (BFD_RELOC_16_BASEREL, 9);
313 STD (BFD_RELOC_32_BASEREL, 10);
116c20d2
NC		 314 default:
315 return NULL;
252b5132
RH		 316 }
317}
318
157090f7
AM		 319reloc_howto_type *
320NAME (aout, reloc_name_lookup) (bfd *abfd, const char *r_name)
321{
322 unsigned int i, size;
323 reloc_howto_type *howto_table;
324
325 if (obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE)
326 {
327 howto_table = howto_table_ext;
328 size = sizeof (howto_table_ext) / sizeof (howto_table_ext[0]);
329 }
330 else
331 {
332 howto_table = howto_table_std;
333 size = sizeof (howto_table_std) / sizeof (howto_table_std[0]);
334 }
335
336 for (i = 0; i < size; i++)
337 if (howto_table[i].name != NULL
338 && strcasecmp (howto_table[i].name, r_name) == 0)
339 return &howto_table[i];
340
341 return NULL;
342}
343
252b5132
RH		 344/*
345SUBSECTION
346 Internal entry points
347
348DESCRIPTION
349 @file{aoutx.h} exports several routines for accessing the
350 contents of an a.out file, which are gathered and exported in
351 turn by various format specific files (eg sunos.c).
252b5132
RH		 352*/
353
354/*
355FUNCTION
356 aout_@var{size}_swap_exec_header_in
357
358SYNOPSIS
359 void aout_@var{size}_swap_exec_header_in,
360 (bfd *abfd,
116c20d2 361 struct external_exec *bytes,
252b5132
RH		 362 struct internal_exec *execp);
363
364DESCRIPTION
365 Swap the information in an executable header @var{raw_bytes} taken
366 from a raw byte stream memory image into the internal exec header
367 structure @var{execp}.
368*/
369
370#ifndef NAME_swap_exec_header_in
371void
116c20d2
NC		 372NAME (aout, swap_exec_header_in) (bfd *abfd,
373 struct external_exec *bytes,
374 struct internal_exec *execp)
252b5132 375{
252b5132
RH		 376 /* The internal_exec structure has some fields that are unused in this
377 configuration (IE for i960), so ensure that all such uninitialized
378 fields are zero'd out. There are places where two of these structs
0ef5a5bd 379 are memcmp'd, and thus the contents do matter. */
116c20d2 380 memset ((void *) execp, 0, sizeof (struct internal_exec));
252b5132 381 /* Now fill in fields in the execp, from the bytes in the raw data. */
dc810e39 382 execp->a_info = H_GET_32 (abfd, bytes->e_info);
252b5132
RH		 383 execp->a_text = GET_WORD (abfd, bytes->e_text);
384 execp->a_data = GET_WORD (abfd, bytes->e_data);
385 execp->a_bss = GET_WORD (abfd, bytes->e_bss);
386 execp->a_syms = GET_WORD (abfd, bytes->e_syms);
387 execp->a_entry = GET_WORD (abfd, bytes->e_entry);
388 execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
389 execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
390}
116c20d2 391#define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
252b5132
RH		 392#endif
393
394/*
395FUNCTION
396 aout_@var{size}_swap_exec_header_out
397
398SYNOPSIS
399 void aout_@var{size}_swap_exec_header_out
400 (bfd *abfd,
401 struct internal_exec *execp,
402 struct external_exec *raw_bytes);
403
404DESCRIPTION
405 Swap the information in an internal exec header structure
406 @var{execp} into the buffer @var{raw_bytes} ready for writing to disk.
407*/
408void
116c20d2
NC		 409NAME (aout, swap_exec_header_out) (bfd *abfd,
410 struct internal_exec *execp,
411 struct external_exec *bytes)
252b5132 412{
0ef5a5bd 413 /* Now fill in fields in the raw data, from the fields in the exec struct. */
dc810e39 414 H_PUT_32 (abfd, execp->a_info , bytes->e_info);
252b5132
RH		 415 PUT_WORD (abfd, execp->a_text , bytes->e_text);
416 PUT_WORD (abfd, execp->a_data , bytes->e_data);
417 PUT_WORD (abfd, execp->a_bss , bytes->e_bss);
418 PUT_WORD (abfd, execp->a_syms , bytes->e_syms);
419 PUT_WORD (abfd, execp->a_entry , bytes->e_entry);
420 PUT_WORD (abfd, execp->a_trsize, bytes->e_trsize);
421 PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize);
422}
423
424/* Make all the section for an a.out file. */
425
b34976b6 426bfd_boolean
116c20d2 427NAME (aout, make_sections) (bfd *abfd)
252b5132 428{
116c20d2 429 if (obj_textsec (abfd) == NULL && bfd_make_section (abfd, ".text") == NULL)
b34976b6 430 return FALSE;
116c20d2 431 if (obj_datasec (abfd) == NULL && bfd_make_section (abfd, ".data") == NULL)
b34976b6 432 return FALSE;
116c20d2 433 if (obj_bsssec (abfd) == NULL && bfd_make_section (abfd, ".bss") == NULL)
b34976b6
AM		 434 return FALSE;
435 return TRUE;
252b5132
RH		 436}
437
438/*
439FUNCTION
440 aout_@var{size}_some_aout_object_p
441
442SYNOPSIS
443 const bfd_target *aout_@var{size}_some_aout_object_p
444 (bfd *abfd,
116c20d2
NC		 445 struct internal_exec *execp,
446 const bfd_target *(*callback_to_real_object_p) (bfd *));
252b5132
RH		 447
448DESCRIPTION
449 Some a.out variant thinks that the file open in @var{abfd}
450 checking is an a.out file. Do some more checking, and set up
451 for access if it really is. Call back to the calling
452 environment's "finish up" function just before returning, to
453 handle any last-minute setup.
454*/
455
456const bfd_target *
116c20d2
NC		 457NAME (aout, some_aout_object_p) (bfd *abfd,
458 struct internal_exec *execp,
459 const bfd_target *(*callback_to_real_object_p) (bfd *))
252b5132
RH		 460{
461 struct aout_data_struct *rawptr, *oldrawptr;
462 const bfd_target *result;
116c20d2 463 bfd_size_type amt = sizeof (* rawptr);
252b5132 464
a50b1753 465 rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, amt);
252b5132 466 if (rawptr == NULL)
116c20d2 467 return NULL;
252b5132
RH		 468
469 oldrawptr = abfd->tdata.aout_data;
470 abfd->tdata.aout_data = rawptr;
471
472 /* Copy the contents of the old tdata struct.
473 In particular, we want the subformat, since for hpux it was set in
474 hp300hpux.c:swap_exec_header_in and will be used in
475 hp300hpux.c:callback. */
476 if (oldrawptr != NULL)
477 *abfd->tdata.aout_data = *oldrawptr;
478
479 abfd->tdata.aout_data->a.hdr = &rawptr->e;
f7c33884
NC		 480 /* Copy in the internal_exec struct. */
481 *(abfd->tdata.aout_data->a.hdr) = *execp;
252b5132
RH		 482 execp = abfd->tdata.aout_data->a.hdr;
483
f7c33884 484 /* Set the file flags. */
252b5132
RH		 485 abfd->flags = BFD_NO_FLAGS;
486 if (execp->a_drsize || execp->a_trsize)
487 abfd->flags |= HAS_RELOC;
f7c33884 488 /* Setting of EXEC_P has been deferred to the bottom of this function. */
252b5132
RH		 489 if (execp->a_syms)
490 abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
923f08ff 491 if (N_DYNAMIC (*execp))
252b5132
RH		 492 abfd->flags |= DYNAMIC;
493
494 if (N_MAGIC (*execp) == ZMAGIC)
495 {
496 abfd->flags |= D_PAGED | WP_TEXT;
497 adata (abfd).magic = z_magic;
498 }
499 else if (N_MAGIC (*execp) == QMAGIC)
500 {
501 abfd->flags |= D_PAGED | WP_TEXT;
502 adata (abfd).magic = z_magic;
503 adata (abfd).subformat = q_magic_format;
504 }
505 else if (N_MAGIC (*execp) == NMAGIC)
506 {
507 abfd->flags |= WP_TEXT;
508 adata (abfd).magic = n_magic;
509 }
510 else if (N_MAGIC (*execp) == OMAGIC
511 || N_MAGIC (*execp) == BMAGIC)
512 adata (abfd).magic = o_magic;
513 else
116c20d2
NC		 514 /* Should have been checked with N_BADMAG before this routine
515 was called. */
516 abort ();
252b5132
RH		 517
518 bfd_get_start_address (abfd) = execp->a_entry;
519
116c20d2 520 obj_aout_symbols (abfd) = NULL;
252b5132
RH		 521 bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist);
522
523 /* The default relocation entry size is that of traditional V7 Unix. */
524 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
525
0ef5a5bd 526 /* The default symbol entry size is that of traditional Unix. */
252b5132
RH		 527 obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE;
528
529#ifdef USE_MMAP
530 bfd_init_window (&obj_aout_sym_window (abfd));
531 bfd_init_window (&obj_aout_string_window (abfd));
532#endif
533 obj_aout_external_syms (abfd) = NULL;
534 obj_aout_external_strings (abfd) = NULL;
535 obj_aout_sym_hashes (abfd) = NULL;
536
116c20d2 537 if (! NAME (aout, make_sections) (abfd))
487e54f2 538 goto error_ret;
252b5132 539
eea6121a
AM		 540 obj_datasec (abfd)->size = execp->a_data;
541 obj_bsssec (abfd)->size = execp->a_bss;
252b5132
RH		 542
543 obj_textsec (abfd)->flags =
544 (execp->a_trsize != 0
545 ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC)
546 : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS));
547 obj_datasec (abfd)->flags =
548 (execp->a_drsize != 0
549 ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC)
550 : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS));
551 obj_bsssec (abfd)->flags = SEC_ALLOC;
552
553#ifdef THIS_IS_ONLY_DOCUMENTATION
554 /* The common code can't fill in these things because they depend
555 on either the start address of the text segment, the rounding
556 up of virtual addresses between segments, or the starting file
557 position of the text segment -- all of which varies among different
558 versions of a.out. */
559
560 /* Call back to the format-dependent code to fill in the rest of the
561 fields and do any further cleanup. Things that should be filled
562 in by the callback: */
563
564 struct exec *execp = exec_hdr (abfd);
565
923f08ff 566 obj_textsec (abfd)->size = N_TXTSIZE (*execp);
f7c33884 567 /* Data and bss are already filled in since they're so standard. */
252b5132 568
f7c33884 569 /* The virtual memory addresses of the sections. */
923f08ff
AM		 570 obj_textsec (abfd)->vma = N_TXTADDR (*execp);
571 obj_datasec (abfd)->vma = N_DATADDR (*execp);
572 obj_bsssec (abfd)->vma = N_BSSADDR (*execp);
252b5132 573
f7c33884 574 /* The file offsets of the sections. */
923f08ff
AM		 575 obj_textsec (abfd)->filepos = N_TXTOFF (*execp);
576 obj_datasec (abfd)->filepos = N_DATOFF (*execp);
252b5132 577
f7c33884 578 /* The file offsets of the relocation info. */
923f08ff
AM		 579 obj_textsec (abfd)->rel_filepos = N_TRELOFF (*execp);
580 obj_datasec (abfd)->rel_filepos = N_DRELOFF (*execp);
252b5132
RH		 581
582 /* The file offsets of the string table and symbol table. */
583 obj_str_filepos (abfd) = N_STROFF (*execp);
584 obj_sym_filepos (abfd) = N_SYMOFF (*execp);
585
586 /* Determine the architecture and machine type of the object file. */
923f08ff
AM		 587 switch (N_MACHTYPE (*exec_hdr (abfd)))
588 {
589 default:
590 abfd->obj_arch = bfd_arch_obscure;
591 break;
592 }
252b5132 593
923f08ff
AM		 594 adata (abfd)->page_size = TARGET_PAGE_SIZE;
595 adata (abfd)->segment_size = SEGMENT_SIZE;
596 adata (abfd)->exec_bytes_size = EXEC_BYTES_SIZE;
252b5132
RH		 597
598 return abfd->xvec;
599
600 /* The architecture is encoded in various ways in various a.out variants,
601 or is not encoded at all in some of them. The relocation size depends
602 on the architecture and the a.out variant. Finally, the return value
603 is the bfd_target vector in use. If an error occurs, return zero and
604 set bfd_error to the appropriate error code.
605
606 Formats such as b.out, which have additional fields in the a.out
607 header, should cope with them in this callback as well. */
608#endif /* DOCUMENTATION */
609
beb0d161 610 result = (*callback_to_real_object_p) (abfd);
252b5132
RH		 611
612 /* Now that the segment addresses have been worked out, take a better
613 guess at whether the file is executable. If the entry point
614 is within the text segment, assume it is. (This makes files
615 executable even if their entry point address is 0, as long as
616 their text starts at zero.).
617
618 This test had to be changed to deal with systems where the text segment
619 runs at a different location than the default. The problem is that the
620 entry address can appear to be outside the text segment, thus causing an
621 erroneous conclusion that the file isn't executable.
622
623 To fix this, we now accept any non-zero entry point as an indication of
624 executability. This will work most of the time, since only the linker
0ef5a5bd 625 sets the entry point, and that is likely to be non-zero for most systems. */
252b5132
RH		 626
627 if (execp->a_entry != 0
923f08ff
AM		 628 || (execp->a_entry >= obj_textsec (abfd)->vma
629 && execp->a_entry < (obj_textsec (abfd)->vma
4c1534c7
AM		 630 + obj_textsec (abfd)->size)
631 && execp->a_trsize == 0
632 && execp->a_drsize == 0))
252b5132
RH		 633 abfd->flags |= EXEC_P;
634#ifdef STAT_FOR_EXEC
635 else
636 {
637 struct stat stat_buf;
638
639 /* The original heuristic doesn't work in some important cases.
640 The a.out file has no information about the text start
641 address. For files (like kernels) linked to non-standard
642 addresses (ld -Ttext nnn) the entry point may not be between
643 the default text start (obj_textsec(abfd)->vma) and
644 (obj_textsec(abfd)->vma) + text size. This is not just a mach
645 issue. Many kernels are loaded at non standard addresses. */
646 if (abfd->iostream != NULL
647 && (abfd->flags & BFD_IN_MEMORY) == 0
923f08ff 648 && (fstat (fileno ((FILE *) (abfd->iostream)), &stat_buf) == 0)
252b5132
RH		 649 && ((stat_buf.st_mode & 0111) != 0))
650 abfd->flags |= EXEC_P;
651 }
652#endif /* STAT_FOR_EXEC */
653
654 if (result)
0e71e495 655 return result;
487e54f2
AM		 656
657 error_ret:
658 bfd_release (abfd, rawptr);
659 abfd->tdata.aout_data = oldrawptr;
660 return NULL;
252b5132
RH		 661}
662
663/*
664FUNCTION
665 aout_@var{size}_mkobject
666
667SYNOPSIS
b34976b6 668 bfd_boolean aout_@var{size}_mkobject, (bfd *abfd);
252b5132
RH		 669
670DESCRIPTION
671 Initialize BFD @var{abfd} for use with a.out files.
672*/
673
b34976b6 674bfd_boolean
116c20d2 675NAME (aout, mkobject) (bfd *abfd)
252b5132 676{
dc810e39 677 struct aout_data_struct *rawptr;
116c20d2 678 bfd_size_type amt = sizeof (* rawptr);
252b5132
RH		 679
680 bfd_set_error (bfd_error_system_call);
681
a50b1753 682 rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, amt);
252b5132 683 if (rawptr == NULL)
b34976b6 684 return FALSE;
252b5132
RH		 685
686 abfd->tdata.aout_data = rawptr;
687 exec_hdr (abfd) = &(rawptr->e);
688
116c20d2
NC		 689 obj_textsec (abfd) = NULL;
690 obj_datasec (abfd) = NULL;
691 obj_bsssec (abfd) = NULL;
252b5132 692
b34976b6 693 return TRUE;
252b5132
RH		 694}
695
252b5132
RH		 696/*
697FUNCTION
698 aout_@var{size}_machine_type
699
700SYNOPSIS
701 enum machine_type aout_@var{size}_machine_type
702 (enum bfd_architecture arch,
116c20d2
NC		 703 unsigned long machine,
704 bfd_boolean *unknown);
252b5132
RH		 705
706DESCRIPTION
707 Keep track of machine architecture and machine type for
708 a.out's. Return the <<machine_type>> for a particular
709 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
710 and machine can't be represented in a.out format.
711
712 If the architecture is understood, machine type 0 (default)
713 is always understood.
714*/
715
716enum machine_type
116c20d2
NC		 717NAME (aout, machine_type) (enum bfd_architecture arch,
718 unsigned long machine,
719 bfd_boolean *unknown)
252b5132
RH		 720{
721 enum machine_type arch_flags;
722
723 arch_flags = M_UNKNOWN;
b34976b6 724 *unknown = TRUE;
252b5132 725
923f08ff
AM		 726 switch (arch)
727 {
728 case bfd_arch_sparc:
729 if (machine == 0
730 || machine == bfd_mach_sparc
731 || machine == bfd_mach_sparc_sparclite
732 || machine == bfd_mach_sparc_sparclite_le
74d26813
L		 733 || machine == bfd_mach_sparc_v8plus
734 || machine == bfd_mach_sparc_v8plusa
735 || machine == bfd_mach_sparc_v8plusb
736 || machine == bfd_mach_sparc_v9
737 || machine == bfd_mach_sparc_v9a
738 || machine == bfd_mach_sparc_v9b)
923f08ff
AM		 739 arch_flags = M_SPARC;
740 else if (machine == bfd_mach_sparc_sparclet)
741 arch_flags = M_SPARCLET;
742 break;
743
744 case bfd_arch_m68k:
745 switch (machine)
746 {
747 case 0: arch_flags = M_68010; break;
b34976b6 748 case bfd_mach_m68000: arch_flags = M_UNKNOWN; *unknown = FALSE; break;
923f08ff
AM		 749 case bfd_mach_m68010: arch_flags = M_68010; break;
750 case bfd_mach_m68020: arch_flags = M_68020; break;
751 default: arch_flags = M_UNKNOWN; break;
752 }
252b5132 753 break;
923f08ff
AM		 754
755 case bfd_arch_i386:
3b77b1d5
AM		 756 if (machine == 0
757 || machine == bfd_mach_i386_i386
758 || machine == bfd_mach_i386_i386_intel_syntax)
923f08ff 759 arch_flags = M_386;
252b5132 760 break;
923f08ff 761
923f08ff
AM		 762 case bfd_arch_arm:
763 if (machine == 0)
764 arch_flags = M_ARM;
252b5132 765 break;
252b5132 766
923f08ff
AM		 767 case bfd_arch_mips:
768 switch (machine)
769 {
770 case 0:
771 case bfd_mach_mips3000:
772 case bfd_mach_mips3900:
773 arch_flags = M_MIPS1;
774 break;
775 case bfd_mach_mips6000:
776 arch_flags = M_MIPS2;
777 break;
778 case bfd_mach_mips4000:
779 case bfd_mach_mips4010:
780 case bfd_mach_mips4100:
781 case bfd_mach_mips4300:
782 case bfd_mach_mips4400:
783 case bfd_mach_mips4600:
784 case bfd_mach_mips4650:
785 case bfd_mach_mips8000:
0d2e43ed 786 case bfd_mach_mips9000:
923f08ff
AM		 787 case bfd_mach_mips10000:
788 case bfd_mach_mips12000:
3aa3176b
TS		 789 case bfd_mach_mips14000:
790 case bfd_mach_mips16000:
923f08ff
AM		 791 case bfd_mach_mips16:
792 case bfd_mach_mipsisa32:
af7ee8bf 793 case bfd_mach_mipsisa32r2:
923f08ff
AM		 794 case bfd_mach_mips5:
795 case bfd_mach_mipsisa64:
5f74bc13 796 case bfd_mach_mipsisa64r2:
923f08ff 797 case bfd_mach_mips_sb1:
52b6b6b9 798 case bfd_mach_mips_xlr:
923f08ff
AM		 799 /* FIXME: These should be MIPS3, MIPS4, MIPS16, MIPS32, etc. */
800 arch_flags = M_MIPS2;
801 break;
802 default:
803 arch_flags = M_UNKNOWN;
804 break;
805 }
806 break;
807
808 case bfd_arch_ns32k:
809 switch (machine)
810 {
811 case 0: arch_flags = M_NS32532; break;
812 case 32032: arch_flags = M_NS32032; break;
813 case 32532: arch_flags = M_NS32532; break;
814 default: arch_flags = M_UNKNOWN; break;
815 }
816 break;
252b5132 817
923f08ff 818 case bfd_arch_vax:
b34976b6 819 *unknown = FALSE;
923f08ff 820 break;
06c15ad7 821
923f08ff
AM		 822 case bfd_arch_cris:
823 if (machine == 0 || machine == 255)
824 arch_flags = M_CRIS;
825 break;
826
727e493d
MK		 827 case bfd_arch_m88k:
828 *unknown = FALSE;
829 break;
830
923f08ff
AM		 831 default:
832 arch_flags = M_UNKNOWN;
833 }
252b5132
RH		 834
835 if (arch_flags != M_UNKNOWN)
b34976b6 836 *unknown = FALSE;
252b5132
RH		 837
838 return arch_flags;
839}
840
252b5132
RH		 841/*
842FUNCTION
843 aout_@var{size}_set_arch_mach
844
845SYNOPSIS
b34976b6 846 bfd_boolean aout_@var{size}_set_arch_mach,
252b5132
RH		 847 (bfd *,
848 enum bfd_architecture arch,
116c20d2 849 unsigned long machine);
252b5132
RH		 850
851DESCRIPTION
852 Set the architecture and the machine of the BFD @var{abfd} to the
853 values @var{arch} and @var{machine}. Verify that @var{abfd}'s format
854 can support the architecture required.
855*/
856
b34976b6 857bfd_boolean
116c20d2
NC		 858NAME (aout, set_arch_mach) (bfd *abfd,
859 enum bfd_architecture arch,
860 unsigned long machine)
252b5132
RH		 861{
862 if (! bfd_default_set_arch_mach (abfd, arch, machine))
b34976b6 863 return FALSE;
252b5132
RH		 864
865 if (arch != bfd_arch_unknown)
866 {
b34976b6 867 bfd_boolean unknown;
252b5132 868
116c20d2 869 NAME (aout, machine_type) (arch, machine, &unknown);
252b5132 870 if (unknown)
b34976b6 871 return FALSE;
252b5132
RH		 872 }
873
f7c33884 874 /* Determine the size of a relocation entry. */
923f08ff
AM		 875 switch (arch)
876 {
877 case bfd_arch_sparc:
923f08ff
AM		 878 case bfd_arch_mips:
879 obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE;
880 break;
881 default:
882 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
883 break;
884 }
252b5132 885
923f08ff 886 return (*aout_backend_info (abfd)->set_sizes) (abfd);
252b5132
RH		 887}
888
889static void
116c20d2 890adjust_o_magic (bfd *abfd, struct internal_exec *execp)
252b5132
RH		 891{
892 file_ptr pos = adata (abfd).exec_bytes_size;
893 bfd_vma vma = 0;
894 int pad = 0;
895
896 /* Text. */
923f08ff
AM		 897 obj_textsec (abfd)->filepos = pos;
898 if (!obj_textsec (abfd)->user_set_vma)
899 obj_textsec (abfd)->vma = vma;
252b5132 900 else
923f08ff 901 vma = obj_textsec (abfd)->vma;
252b5132 902
eea6121a
AM		 903 pos += obj_textsec (abfd)->size;
904 vma += obj_textsec (abfd)->size;
252b5132
RH		 905
906 /* Data. */
923f08ff 907 if (!obj_datasec (abfd)->user_set_vma)
252b5132 908 {
eea6121a 909 obj_textsec (abfd)->size += pad;
252b5132
RH		 910 pos += pad;
911 vma += pad;
923f08ff 912 obj_datasec (abfd)->vma = vma;
252b5132
RH		 913 }
914 else
923f08ff
AM		 915 vma = obj_datasec (abfd)->vma;
916 obj_datasec (abfd)->filepos = pos;
eea6121a
AM		 917 pos += obj_datasec (abfd)->size;
918 vma += obj_datasec (abfd)->size;
252b5132
RH		 919
920 /* BSS. */
923f08ff 921 if (!obj_bsssec (abfd)->user_set_vma)
252b5132 922 {
eea6121a 923 obj_datasec (abfd)->size += pad;
252b5132
RH		 924 pos += pad;
925 vma += pad;
923f08ff 926 obj_bsssec (abfd)->vma = vma;
252b5132
RH		 927 }
928 else
929 {
08da05b0 930 /* The VMA of the .bss section is set by the VMA of the
252b5132
RH		 931 .data section plus the size of the .data section. We may
932 need to add padding bytes to make this true. */
933 pad = obj_bsssec (abfd)->vma - vma;
934 if (pad > 0)
935 {
eea6121a 936 obj_datasec (abfd)->size += pad;
252b5132
RH		 937 pos += pad;
938 }
939 }
923f08ff 940 obj_bsssec (abfd)->filepos = pos;
252b5132
RH		 941
942 /* Fix up the exec header. */
eea6121a
AM		 943 execp->a_text = obj_textsec (abfd)->size;
944 execp->a_data = obj_datasec (abfd)->size;
945 execp->a_bss = obj_bsssec (abfd)->size;
252b5132
RH		 946 N_SET_MAGIC (*execp, OMAGIC);
947}
948
949static void
116c20d2 950adjust_z_magic (bfd *abfd, struct internal_exec *execp)
252b5132
RH		 951{
952 bfd_size_type data_pad, text_pad;
953 file_ptr text_end;
dc810e39 954 const struct aout_backend_data *abdp;
116c20d2
NC		 955 /* TRUE if text includes exec header. */
956 bfd_boolean ztih;
0ef5a5bd 957
252b5132
RH		 958 abdp = aout_backend_info (abfd);
959
960 /* Text. */
961 ztih = (abdp != NULL
962 && (abdp->text_includes_header
963 || obj_aout_subformat (abfd) == q_magic_format));
923f08ff
AM		 964 obj_textsec (abfd)->filepos = (ztih
965 ? adata (abfd).exec_bytes_size
966 : adata (abfd).zmagic_disk_block_size);
967 if (! obj_textsec (abfd)->user_set_vma)
252b5132
RH		 968 {
969 /* ?? Do we really need to check for relocs here? */
923f08ff
AM		 970 obj_textsec (abfd)->vma = ((abfd->flags & HAS_RELOC)
971 ? 0
972 : (ztih
973 ? (abdp->default_text_vma
974 + adata (abfd).exec_bytes_size)
975 : abdp->default_text_vma));
252b5132
RH		 976 text_pad = 0;
977 }
978 else
979 {
980 /* The .text section is being loaded at an unusual address. We
981 may need to pad it such that the .data section starts at a page
982 boundary. */
983 if (ztih)
984 text_pad = ((obj_textsec (abfd)->filepos - obj_textsec (abfd)->vma)
985 & (adata (abfd).page_size - 1));
986 else
987 text_pad = ((- obj_textsec (abfd)->vma)
988 & (adata (abfd).page_size - 1));
989 }
990
991 /* Find start of data. */
992 if (ztih)
993 {
eea6121a 994 text_end = obj_textsec (abfd)->filepos + obj_textsec (abfd)->size;
252b5132
RH		 995 text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
996 }
997 else
998 {
999 /* Note that if page_size == zmagic_disk_block_size, then
1000 filepos == page_size, and this case is the same as the ztih
1001 case. */
eea6121a 1002 text_end = obj_textsec (abfd)->size;
252b5132
RH		 1003 text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
1004 text_end += obj_textsec (abfd)->filepos;
1005 }
eea6121a 1006 obj_textsec (abfd)->size += text_pad;
252b5132
RH		 1007 text_end += text_pad;
1008
1009 /* Data. */
923f08ff 1010 if (!obj_datasec (abfd)->user_set_vma)
252b5132
RH		 1011 {
1012 bfd_vma vma;
eea6121a 1013 vma = obj_textsec (abfd)->vma + obj_textsec (abfd)->size;
923f08ff 1014 obj_datasec (abfd)->vma = BFD_ALIGN (vma, adata (abfd).segment_size);
252b5132
RH		 1015 }
1016 if (abdp && abdp->zmagic_mapped_contiguous)
1017 {
dee0a8f4
NC		 1018 asection * text = obj_textsec (abfd);
1019 asection * data = obj_datasec (abfd);
1020
eea6121a 1021 text_pad = data->vma - (text->vma + text->size);
dee0a8f4
NC		 1022 /* Only pad the text section if the data
1023 section is going to be placed after it. */
1024 if (text_pad > 0)
eea6121a 1025 text->size += text_pad;
252b5132 1026 }
923f08ff 1027 obj_datasec (abfd)->filepos = (obj_textsec (abfd)->filepos
eea6121a 1028 + obj_textsec (abfd)->size);
0ef5a5bd 1029
252b5132 1030 /* Fix up exec header while we're at it. */
eea6121a 1031 execp->a_text = obj_textsec (abfd)->size;
252b5132 1032 if (ztih && (!abdp || (abdp && !abdp->exec_header_not_counted)))
923f08ff 1033 execp->a_text += adata (abfd).exec_bytes_size;
252b5132
RH		 1034 if (obj_aout_subformat (abfd) == q_magic_format)
1035 N_SET_MAGIC (*execp, QMAGIC);
1036 else
1037 N_SET_MAGIC (*execp, ZMAGIC);
1038
1039 /* Spec says data section should be rounded up to page boundary. */
eea6121a
AM		 1040 obj_datasec (abfd)->size
1041 = align_power (obj_datasec (abfd)->size,
923f08ff 1042 obj_bsssec (abfd)->alignment_power);
eea6121a 1043 execp->a_data = BFD_ALIGN (obj_datasec (abfd)->size,
923f08ff 1044 adata (abfd).page_size);
eea6121a 1045 data_pad = execp->a_data - obj_datasec (abfd)->size;
252b5132
RH		 1046
1047 /* BSS. */
923f08ff
AM		 1048 if (!obj_bsssec (abfd)->user_set_vma)
1049 obj_bsssec (abfd)->vma = (obj_datasec (abfd)->vma
eea6121a 1050 + obj_datasec (abfd)->size);
252b5132
RH		 1051 /* If the BSS immediately follows the data section and extra space
1052 in the page is left after the data section, fudge data
1053 in the header so that the bss section looks smaller by that
1054 amount. We'll start the bss section there, and lie to the OS.
1055 (Note that a linker script, as well as the above assignment,
1056 could have explicitly set the BSS vma to immediately follow
1057 the data section.) */
923f08ff 1058 if (align_power (obj_bsssec (abfd)->vma, obj_bsssec (abfd)->alignment_power)
eea6121a
AM		 1059 == obj_datasec (abfd)->vma + obj_datasec (abfd)->size)
1060 execp->a_bss = (data_pad > obj_bsssec (abfd)->size
1061 ? 0 : obj_bsssec (abfd)->size - data_pad);
252b5132 1062 else
eea6121a 1063 execp->a_bss = obj_bsssec (abfd)->size;
252b5132
RH		 1064}
1065
1066static void
116c20d2 1067adjust_n_magic (bfd *abfd, struct internal_exec *execp)
252b5132 1068{
923f08ff 1069 file_ptr pos = adata (abfd).exec_bytes_size;
252b5132
RH		 1070 bfd_vma vma = 0;
1071 int pad;
0ef5a5bd 1072
252b5132 1073 /* Text. */
923f08ff
AM		 1074 obj_textsec (abfd)->filepos = pos;
1075 if (!obj_textsec (abfd)->user_set_vma)
1076 obj_textsec (abfd)->vma = vma;
252b5132 1077 else
923f08ff 1078 vma = obj_textsec (abfd)->vma;
eea6121a
AM		 1079 pos += obj_textsec (abfd)->size;
1080 vma += obj_textsec (abfd)->size;
252b5132
RH		 1081
1082 /* Data. */
923f08ff
AM		 1083 obj_datasec (abfd)->filepos = pos;
1084 if (!obj_datasec (abfd)->user_set_vma)
1085 obj_datasec (abfd)->vma = BFD_ALIGN (vma, adata (abfd).segment_size);
1086 vma = obj_datasec (abfd)->vma;
0ef5a5bd 1087
252b5132 1088 /* Since BSS follows data immediately, see if it needs alignment. */
eea6121a 1089 vma += obj_datasec (abfd)->size;
923f08ff 1090 pad = align_power (vma, obj_bsssec (abfd)->alignment_power) - vma;
eea6121a
AM		 1091 obj_datasec (abfd)->size += pad;
1092 pos += obj_datasec (abfd)->size;
252b5132
RH		 1093
1094 /* BSS. */
923f08ff
AM		 1095 if (!obj_bsssec (abfd)->user_set_vma)
1096 obj_bsssec (abfd)->vma = vma;
252b5132 1097 else
923f08ff 1098 vma = obj_bsssec (abfd)->vma;
252b5132
RH		 1099
1100 /* Fix up exec header. */
eea6121a
AM		 1101 execp->a_text = obj_textsec (abfd)->size;
1102 execp->a_data = obj_datasec (abfd)->size;
1103 execp->a_bss = obj_bsssec (abfd)->size;
252b5132
RH		 1104 N_SET_MAGIC (*execp, NMAGIC);
1105}
1106
b34976b6 1107bfd_boolean
116c20d2
NC		 1108NAME (aout, adjust_sizes_and_vmas) (bfd *abfd,
1109 bfd_size_type *text_size,
1110 file_ptr *text_end ATTRIBUTE_UNUSED)
252b5132
RH		 1111{
1112 struct internal_exec *execp = exec_hdr (abfd);
1113
116c20d2 1114 if (! NAME (aout, make_sections) (abfd))
b34976b6 1115 return FALSE;
252b5132 1116
923f08ff 1117 if (adata (abfd).magic != undecided_magic)
b34976b6 1118 return TRUE;
252b5132 1119
eea6121a
AM		 1120 obj_textsec (abfd)->size =
1121 align_power (obj_textsec (abfd)->size,
923f08ff 1122 obj_textsec (abfd)->alignment_power);
252b5132 1123
eea6121a 1124 *text_size = obj_textsec (abfd)->size;
252b5132
RH		 1125 /* Rule (heuristic) for when to pad to a new page. Note that there
1126 are (at least) two ways demand-paged (ZMAGIC) files have been
1127 handled. Most Berkeley-based systems start the text segment at
1128 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1129 segment right after the exec header; the latter is counted in the
1130 text segment size, and is paged in by the kernel with the rest of
0ef5a5bd 1131 the text. */
252b5132
RH		 1132
1133 /* This perhaps isn't the right way to do this, but made it simpler for me
1134 to understand enough to implement it. Better would probably be to go
1135 right from BFD flags to alignment/positioning characteristics. But the
1136 old code was sloppy enough about handling the flags, and had enough
1137 other magic, that it was a little hard for me to understand. I think
1138 I understand it better now, but I haven't time to do the cleanup this
1139 minute. */
1140
1141 if (abfd->flags & D_PAGED)
1142 /* Whether or not WP_TEXT is set -- let D_PAGED override. */
923f08ff 1143 adata (abfd).magic = z_magic;
252b5132 1144 else if (abfd->flags & WP_TEXT)
923f08ff 1145 adata (abfd).magic = n_magic;
252b5132 1146 else
923f08ff 1147 adata (abfd).magic = o_magic;
252b5132
RH		 1148
1149#ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1150#if __GNUC__ >= 2
1151 fprintf (stderr, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1152 ({ char *str;
923f08ff
AM		 1153 switch (adata (abfd).magic)
1154 {
1155 case n_magic: str = "NMAGIC"; break;
1156 case o_magic: str = "OMAGIC"; break;
1157 case z_magic: str = "ZMAGIC"; break;
1158 default: abort ();
1159 }
252b5132
RH		 1160 str;
1161 }),
eea6121a 1162 obj_textsec (abfd)->vma, obj_textsec (abfd)->size,
923f08ff 1163 obj_textsec (abfd)->alignment_power,
eea6121a 1164 obj_datasec (abfd)->vma, obj_datasec (abfd)->size,
923f08ff 1165 obj_datasec (abfd)->alignment_power,
eea6121a 1166 obj_bsssec (abfd)->vma, obj_bsssec (abfd)->size,
923f08ff 1167 obj_bsssec (abfd)->alignment_power);
252b5132
RH		 1168#endif
1169#endif
1170
923f08ff 1171 switch (adata (abfd).magic)
252b5132
RH		 1172 {
1173 case o_magic:
1174 adjust_o_magic (abfd, execp);
1175 break;
1176 case z_magic:
1177 adjust_z_magic (abfd, execp);
1178 break;
1179 case n_magic:
1180 adjust_n_magic (abfd, execp);
1181 break;
1182 default:
1183 abort ();
1184 }
1185
1186#ifdef BFD_AOUT_DEBUG
1187 fprintf (stderr, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
eea6121a 1188 obj_textsec (abfd)->vma, obj_textsec (abfd)->size,
923f08ff 1189 obj_textsec (abfd)->filepos,
eea6121a 1190 obj_datasec (abfd)->vma, obj_datasec (abfd)->size,
923f08ff 1191 obj_datasec (abfd)->filepos,
eea6121a 1192 obj_bsssec (abfd)->vma, obj_bsssec (abfd)->size);
252b5132
RH		 1193#endif
1194
b34976b6 1195 return TRUE;
252b5132
RH		 1196}
1197
1198/*
1199FUNCTION
1200 aout_@var{size}_new_section_hook
1201
1202SYNOPSIS
b34976b6 1203 bfd_boolean aout_@var{size}_new_section_hook,
252b5132 1204 (bfd *abfd,
116c20d2 1205 asection *newsect);
252b5132
RH		 1206
1207DESCRIPTION
1208 Called by the BFD in response to a @code{bfd_make_section}
1209 request.
1210*/
b34976b6 1211bfd_boolean
116c20d2 1212NAME (aout, new_section_hook) (bfd *abfd, asection *newsect)
252b5132 1213{
f7c33884 1214 /* Align to double at least. */
923f08ff 1215 newsect->alignment_power = bfd_get_arch_info (abfd)->section_align_power;
252b5132 1216
252b5132 1217 if (bfd_get_format (abfd) == bfd_object)
f7c33884
NC		 1218 {
1219 if (obj_textsec (abfd) == NULL && !strcmp (newsect->name, ".text"))
1220 {
1221 obj_textsec (abfd)= newsect;
1222 newsect->target_index = N_TEXT;
f7c33884 1223 }
f592407e 1224 else if (obj_datasec (abfd) == NULL && !strcmp (newsect->name, ".data"))
f7c33884
NC		 1225 {
1226 obj_datasec (abfd) = newsect;
1227 newsect->target_index = N_DATA;
f7c33884 1228 }
f592407e 1229 else if (obj_bsssec (abfd) == NULL && !strcmp (newsect->name, ".bss"))
f7c33884
NC		 1230 {
1231 obj_bsssec (abfd) = newsect;
1232 newsect->target_index = N_BSS;
f7c33884
NC		 1233 }
1234 }
252b5132 1235
f7c33884 1236 /* We allow more than three sections internally. */
f592407e 1237 return _bfd_generic_new_section_hook (abfd, newsect);
252b5132
RH		 1238}
1239
b34976b6 1240bfd_boolean
116c20d2
NC		 1241NAME (aout, set_section_contents) (bfd *abfd,
1242 sec_ptr section,
1243 const void * location,
1244 file_ptr offset,
1245 bfd_size_type count)
252b5132
RH		 1246{
1247 file_ptr text_end;
1248 bfd_size_type text_size;
1249
1250 if (! abfd->output_has_begun)
1251 {
116c20d2 1252 if (! NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
b34976b6 1253 return FALSE;
252b5132
RH		 1254 }
1255
1256 if (section == obj_bsssec (abfd))
1257 {
1258 bfd_set_error (bfd_error_no_contents);
b34976b6 1259 return FALSE;
252b5132
RH		 1260 }
1261
1262 if (section != obj_textsec (abfd)
1263 && section != obj_datasec (abfd))
1264 {
e6af3a53
NC		 1265 if (aout_section_merge_with_text_p (abfd, section))
1266 section->filepos = obj_textsec (abfd)->filepos +
1267 (section->vma - obj_textsec (abfd)->vma);
1268 else
1269 {
1270 (*_bfd_error_handler)
1271 (_("%s: can not represent section `%s' in a.out object file format"),
1272 bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
1273 bfd_set_error (bfd_error_nonrepresentable_section);
1274 return FALSE;
1275 }
252b5132
RH		 1276 }
1277
1278 if (count != 0)
1279 {
1280 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
dc810e39 1281 || bfd_bwrite (location, count, abfd) != count)
b34976b6 1282 return FALSE;
252b5132
RH		 1283 }
1284
b34976b6 1285 return TRUE;
252b5132
RH		 1286}
1287\f
1288/* Read the external symbols from an a.out file. */
1289
b34976b6 1290static bfd_boolean
116c20d2 1291aout_get_external_symbols (bfd *abfd)
252b5132 1292{
116c20d2 1293 if (obj_aout_external_syms (abfd) == NULL)
252b5132
RH		 1294 {
1295 bfd_size_type count;
1296 struct external_nlist *syms;
1297
1298 count = exec_hdr (abfd)->a_syms / EXTERNAL_NLIST_SIZE;
6b8f0fd5
MS		 1299 if (count == 0)
1300 return TRUE; /* Nothing to do. */
252b5132
RH		 1301
1302#ifdef USE_MMAP
82e51918
AM		 1303 if (! bfd_get_file_window (abfd, obj_sym_filepos (abfd),
1304 exec_hdr (abfd)->a_syms,
b34976b6
AM		 1305 &obj_aout_sym_window (abfd), TRUE))
1306 return FALSE;
252b5132
RH		 1307 syms = (struct external_nlist *) obj_aout_sym_window (abfd).data;
1308#else
1309 /* We allocate using malloc to make the values easy to free
1310 later on. If we put them on the objalloc it might not be
1311 possible to free them. */
a50b1753 1312 syms = (struct external_nlist *) bfd_malloc (count * EXTERNAL_NLIST_SIZE);
6b8f0fd5 1313 if (syms == NULL)
b34976b6 1314 return FALSE;
252b5132 1315
848f5748
TT		 1316 {
1317 bfd_size_type amt;
1318 amt = exec_hdr (abfd)->a_syms;
1319 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1320 || bfd_bread (syms, amt, abfd) != amt)
1321 {
1322 free (syms);
1323 return FALSE;
1324 }
1325 }
252b5132
RH		 1326#endif
1327
1328 obj_aout_external_syms (abfd) = syms;
1329 obj_aout_external_sym_count (abfd) = count;
1330 }
0ef5a5bd 1331
252b5132
RH		 1332 if (obj_aout_external_strings (abfd) == NULL
1333 && exec_hdr (abfd)->a_syms != 0)
1334 {
1335 unsigned char string_chars[BYTES_IN_WORD];
1336 bfd_size_type stringsize;
1337 char *strings;
dc810e39 1338 bfd_size_type amt = BYTES_IN_WORD;
252b5132
RH		 1339
1340 /* Get the size of the strings. */
1341 if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
116c20d2 1342 || bfd_bread ((void *) string_chars, amt, abfd) != amt)
b34976b6 1343 return FALSE;
252b5132
RH		 1344 stringsize = GET_WORD (abfd, string_chars);
1345
1346#ifdef USE_MMAP
82e51918 1347 if (! bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize,
b34976b6
AM		 1348 &obj_aout_string_window (abfd), TRUE))
1349 return FALSE;
252b5132
RH		 1350 strings = (char *) obj_aout_string_window (abfd).data;
1351#else
a50b1753 1352 strings = (char *) bfd_malloc (stringsize + 1);
252b5132 1353 if (strings == NULL)
b34976b6 1354 return FALSE;
252b5132
RH		 1355
1356 /* Skip space for the string count in the buffer for convenience
1357 when using indexes. */
dc810e39
AM		 1358 amt = stringsize - BYTES_IN_WORD;
1359 if (bfd_bread (strings + BYTES_IN_WORD, amt, abfd) != amt)
252b5132
RH		 1360 {
1361 free (strings);
b34976b6 1362 return FALSE;
252b5132
RH		 1363 }
1364#endif
1365
1366 /* Ensure that a zero index yields an empty string. */
1367 strings[0] = '\0';
1368
1369 strings[stringsize - 1] = 0;
1370
1371 obj_aout_external_strings (abfd) = strings;
1372 obj_aout_external_string_size (abfd) = stringsize;
1373 }
1374
b34976b6 1375 return TRUE;
252b5132
RH		 1376}
1377
1378/* Translate an a.out symbol into a BFD symbol. The desc, other, type
1379 and symbol->value fields of CACHE_PTR will be set from the a.out
1380 nlist structure. This function is responsible for setting
1381 symbol->flags and symbol->section, and adjusting symbol->value. */
1382
b34976b6 1383static bfd_boolean
116c20d2 1384translate_from_native_sym_flags (bfd *abfd, aout_symbol_type *cache_ptr)
252b5132
RH		 1385{
1386 flagword visible;
1387
1388 if ((cache_ptr->type & N_STAB) != 0
1389 || cache_ptr->type == N_FN)
1390 {
1391 asection *sec;
1392
1393 /* This is a debugging symbol. */
252b5132
RH		 1394 cache_ptr->symbol.flags = BSF_DEBUGGING;
1395
1396 /* Work out the symbol section. */
1397 switch (cache_ptr->type & N_TYPE)
1398 {
1399 case N_TEXT:
1400 case N_FN:
1401 sec = obj_textsec (abfd);
1402 break;
1403 case N_DATA:
1404 sec = obj_datasec (abfd);
1405 break;
1406 case N_BSS:
1407 sec = obj_bsssec (abfd);
1408 break;
1409 default:
1410 case N_ABS:
1411 sec = bfd_abs_section_ptr;
1412 break;
1413 }
1414
1415 cache_ptr->symbol.section = sec;
1416 cache_ptr->symbol.value -= sec->vma;
1417
b34976b6 1418 return TRUE;
252b5132
RH		 1419 }
1420
1421 /* Get the default visibility. This does not apply to all types, so
1422 we just hold it in a local variable to use if wanted. */
1423 if ((cache_ptr->type & N_EXT) == 0)
1424 visible = BSF_LOCAL;
1425 else
1426 visible = BSF_GLOBAL;
1427
1428 switch (cache_ptr->type)
1429 {
1430 default:
1431 case N_ABS: case N_ABS | N_EXT:
1432 cache_ptr->symbol.section = bfd_abs_section_ptr;
1433 cache_ptr->symbol.flags = visible;
1434 break;
1435
1436 case N_UNDF | N_EXT:
1437 if (cache_ptr->symbol.value != 0)
1438 {
1439 /* This is a common symbol. */
1440 cache_ptr->symbol.flags = BSF_GLOBAL;
1441 cache_ptr->symbol.section = bfd_com_section_ptr;
1442 }
1443 else
1444 {
1445 cache_ptr->symbol.flags = 0;
1446 cache_ptr->symbol.section = bfd_und_section_ptr;
1447 }
1448 break;
1449
1450 case N_TEXT: case N_TEXT | N_EXT:
1451 cache_ptr->symbol.section = obj_textsec (abfd);
1452 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1453 cache_ptr->symbol.flags = visible;
1454 break;
1455
1456 /* N_SETV symbols used to represent set vectors placed in the
1457 data section. They are no longer generated. Theoretically,
1458 it was possible to extract the entries and combine them with
1459 new ones, although I don't know if that was ever actually
1460 done. Unless that feature is restored, treat them as data
1461 symbols. */
1462 case N_SETV: case N_SETV | N_EXT:
1463 case N_DATA: case N_DATA | N_EXT:
1464 cache_ptr->symbol.section = obj_datasec (abfd);
1465 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1466 cache_ptr->symbol.flags = visible;
1467 break;
1468
1469 case N_BSS: case N_BSS | N_EXT:
1470 cache_ptr->symbol.section = obj_bsssec (abfd);
1471 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1472 cache_ptr->symbol.flags = visible;
1473 break;
1474
1475 case N_SETA: case N_SETA | N_EXT:
1476 case N_SETT: case N_SETT | N_EXT:
1477 case N_SETD: case N_SETD | N_EXT:
1478 case N_SETB: case N_SETB | N_EXT:
1479 {
1480 /* This code is no longer needed. It used to be used to make
1481 the linker handle set symbols, but they are now handled in
1482 the add_symbols routine instead. */
252b5132
RH		 1483 switch (cache_ptr->type & N_TYPE)
1484 {
1485 case N_SETA:
1486 cache_ptr->symbol.section = bfd_abs_section_ptr;
1487 break;
1488 case N_SETT:
1489 cache_ptr->symbol.section = obj_textsec (abfd);
1490 break;
1491 case N_SETD:
1492 cache_ptr->symbol.section = obj_datasec (abfd);
1493 break;
1494 case N_SETB:
1495 cache_ptr->symbol.section = obj_bsssec (abfd);
1496 break;
1497 }
1498
1499 cache_ptr->symbol.flags |= BSF_CONSTRUCTOR;
1500 }
1501 break;
1502
1503 case N_WARNING:
1504 /* This symbol is the text of a warning message. The next
1505 symbol is the symbol to associate the warning with. If a
1506 reference is made to that symbol, a warning is issued. */
1507 cache_ptr->symbol.flags = BSF_DEBUGGING | BSF_WARNING;
1508 cache_ptr->symbol.section = bfd_abs_section_ptr;
1509 break;
1510
1511 case N_INDR: case N_INDR | N_EXT:
1512 /* An indirect symbol. This consists of two symbols in a row.
1513 The first symbol is the name of the indirection. The second
1514 symbol is the name of the target. A reference to the first
1515 symbol becomes a reference to the second. */
1516 cache_ptr->symbol.flags = BSF_DEBUGGING | BSF_INDIRECT | visible;
1517 cache_ptr->symbol.section = bfd_ind_section_ptr;
1518 break;
1519
1520 case N_WEAKU:
1521 cache_ptr->symbol.section = bfd_und_section_ptr;
1522 cache_ptr->symbol.flags = BSF_WEAK;
1523 break;
1524
1525 case N_WEAKA:
1526 cache_ptr->symbol.section = bfd_abs_section_ptr;
1527 cache_ptr->symbol.flags = BSF_WEAK;
1528 break;
1529
1530 case N_WEAKT:
1531 cache_ptr->symbol.section = obj_textsec (abfd);
1532 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1533 cache_ptr->symbol.flags = BSF_WEAK;
1534 break;
1535
1536 case N_WEAKD:
1537 cache_ptr->symbol.section = obj_datasec (abfd);
1538 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1539 cache_ptr->symbol.flags = BSF_WEAK;
1540 break;
1541
1542 case N_WEAKB:
1543 cache_ptr->symbol.section = obj_bsssec (abfd);
1544 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1545 cache_ptr->symbol.flags = BSF_WEAK;
1546 break;
1547 }
1548
b34976b6 1549 return TRUE;
252b5132
RH		 1550}
1551
1552/* Set the fields of SYM_POINTER according to CACHE_PTR. */
1553
b34976b6 1554static bfd_boolean
116c20d2
NC		 1555translate_to_native_sym_flags (bfd *abfd,
1556 asymbol *cache_ptr,
1557 struct external_nlist *sym_pointer)
252b5132
RH		 1558{
1559 bfd_vma value = cache_ptr->value;
1560 asection *sec;
1561 bfd_vma off;
1562
1563 /* Mask out any existing type bits in case copying from one section
1564 to another. */
1565 sym_pointer->e_type[0] &= ~N_TYPE;
1566
1567 sec = bfd_get_section (cache_ptr);
1568 off = 0;
1569
1570 if (sec == NULL)
1571 {
1572 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1573 file. */
1574 (*_bfd_error_handler)
1575 (_("%s: can not represent section for symbol `%s' in a.out object file format"),
0ef5a5bd 1576 bfd_get_filename (abfd),
252b5132
RH		 1577 cache_ptr->name != NULL ? cache_ptr->name : _("*unknown*"));
1578 bfd_set_error (bfd_error_nonrepresentable_section);
b34976b6 1579 return FALSE;
252b5132
RH		 1580 }
1581
1582 if (sec->output_section != NULL)
1583 {
1584 off = sec->output_offset;
1585 sec = sec->output_section;
1586 }
1587
1588 if (bfd_is_abs_section (sec))
1589 sym_pointer->e_type[0] |= N_ABS;
1590 else if (sec == obj_textsec (abfd))
1591 sym_pointer->e_type[0] |= N_TEXT;
1592 else if (sec == obj_datasec (abfd))
1593 sym_pointer->e_type[0] |= N_DATA;
1594 else if (sec == obj_bsssec (abfd))
1595 sym_pointer->e_type[0] |= N_BSS;
1596 else if (bfd_is_und_section (sec))
1597 sym_pointer->e_type[0] = N_UNDF | N_EXT;
1598 else if (bfd_is_ind_section (sec))
1599 sym_pointer->e_type[0] = N_INDR;
1600 else if (bfd_is_com_section (sec))
1601 sym_pointer->e_type[0] = N_UNDF | N_EXT;
1602 else
1603 {
e6af3a53
NC		 1604 if (aout_section_merge_with_text_p (abfd, sec))
1605 sym_pointer->e_type[0] |= N_TEXT;
1606 else
1607 {
1608 (*_bfd_error_handler)
1609 (_("%s: can not represent section `%s' in a.out object file format"),
1610 bfd_get_filename (abfd), bfd_get_section_name (abfd, sec));
1611 bfd_set_error (bfd_error_nonrepresentable_section);
1612 return FALSE;
1613 }
252b5132
RH		 1614 }
1615
f7c33884 1616 /* Turn the symbol from section relative to absolute again. */
252b5132
RH		 1617 value += sec->vma + off;
1618
1619 if ((cache_ptr->flags & BSF_WARNING) != 0)
1620 sym_pointer->e_type[0] = N_WARNING;
1621
1622 if ((cache_ptr->flags & BSF_DEBUGGING) != 0)
1623 sym_pointer->e_type[0] = ((aout_symbol_type *) cache_ptr)->type;
1624 else if ((cache_ptr->flags & BSF_GLOBAL) != 0)
1625 sym_pointer->e_type[0] |= N_EXT;
930d924d
L		 1626 else if ((cache_ptr->flags & BSF_LOCAL) != 0)
1627 sym_pointer->e_type[0] &= ~N_EXT;
252b5132
RH		 1628
1629 if ((cache_ptr->flags & BSF_CONSTRUCTOR) != 0)
1630 {
1631 int type = ((aout_symbol_type *) cache_ptr)->type;
f7c33884 1632
252b5132
RH		 1633 switch (type)
1634 {
1635 case N_ABS: type = N_SETA; break;
1636 case N_TEXT: type = N_SETT; break;
1637 case N_DATA: type = N_SETD; break;
1638 case N_BSS: type = N_SETB; break;
1639 }
1640 sym_pointer->e_type[0] = type;
1641 }
1642
1643 if ((cache_ptr->flags & BSF_WEAK) != 0)
1644 {
1645 int type;
1646
1647 switch (sym_pointer->e_type[0] & N_TYPE)
1648 {
1649 default:
1650 case N_ABS: type = N_WEAKA; break;
1651 case N_TEXT: type = N_WEAKT; break;
1652 case N_DATA: type = N_WEAKD; break;
1653 case N_BSS: type = N_WEAKB; break;
1654 case N_UNDF: type = N_WEAKU; break;
1655 }
1656 sym_pointer->e_type[0] = type;
1657 }
1658
923f08ff 1659 PUT_WORD (abfd, value, sym_pointer->e_value);
252b5132 1660
b34976b6 1661 return TRUE;
252b5132
RH		 1662}
1663\f
0ef5a5bd 1664/* Native-level interface to symbols. */
252b5132
RH		 1665
1666asymbol *
116c20d2 1667NAME (aout, make_empty_symbol) (bfd *abfd)
252b5132 1668{
dc810e39 1669 bfd_size_type amt = sizeof (aout_symbol_type);
116c20d2 1670
d3ce72d0
NC		 1671 aout_symbol_type *new_symbol = (aout_symbol_type *) bfd_zalloc (abfd, amt);
1672 if (!new_symbol)
252b5132 1673 return NULL;
d3ce72d0 1674 new_symbol->symbol.the_bfd = abfd;
252b5132 1675
d3ce72d0 1676 return &new_symbol->symbol;
252b5132
RH		 1677}
1678
1679/* Translate a set of internal symbols into external symbols. */
1680
b34976b6 1681bfd_boolean
116c20d2
NC		 1682NAME (aout, translate_symbol_table) (bfd *abfd,
1683 aout_symbol_type *in,
1684 struct external_nlist *ext,
1685 bfd_size_type count,
1686 char *str,
1687 bfd_size_type strsize,
1688 bfd_boolean dynamic)
252b5132
RH		 1689{
1690 struct external_nlist *ext_end;
1691
1692 ext_end = ext + count;
1693 for (; ext < ext_end; ext++, in++)
1694 {
1695 bfd_vma x;
1696
1697 x = GET_WORD (abfd, ext->e_strx);
1698 in->symbol.the_bfd = abfd;
1699
1700 /* For the normal symbols, the zero index points at the number
1701 of bytes in the string table but is to be interpreted as the
1702 null string. For the dynamic symbols, the number of bytes in
1703 the string table is stored in the __DYNAMIC structure and the
1704 zero index points at an actual string. */
1705 if (x == 0 && ! dynamic)
1706 in->symbol.name = "";
1707 else if (x < strsize)
1708 in->symbol.name = str + x;
1709 else
b34976b6 1710 return FALSE;
252b5132
RH		 1711
1712 in->symbol.value = GET_SWORD (abfd, ext->e_value);
dc810e39
AM		 1713 in->desc = H_GET_16 (abfd, ext->e_desc);
1714 in->other = H_GET_8 (abfd, ext->e_other);
1715 in->type = H_GET_8 (abfd, ext->e_type);
252b5132
RH		 1716 in->symbol.udata.p = NULL;
1717
1718 if (! translate_from_native_sym_flags (abfd, in))
b34976b6 1719 return FALSE;
252b5132
RH		 1720
1721 if (dynamic)
1722 in->symbol.flags |= BSF_DYNAMIC;
1723 }
1724
b34976b6 1725 return TRUE;
252b5132
RH		 1726}
1727
1728/* We read the symbols into a buffer, which is discarded when this
1729 function exits. We read the strings into a buffer large enough to
0ef5a5bd 1730 hold them all plus all the cached symbol entries. */
252b5132 1731
b34976b6 1732bfd_boolean
116c20d2 1733NAME (aout, slurp_symbol_table) (bfd *abfd)
252b5132
RH		 1734{
1735 struct external_nlist *old_external_syms;
1736 aout_symbol_type *cached;
dc810e39 1737 bfd_size_type cached_size;
252b5132 1738
f7c33884 1739 /* If there's no work to be done, don't do any. */
116c20d2 1740 if (obj_aout_symbols (abfd) != NULL)
b34976b6 1741 return TRUE;
252b5132
RH		 1742
1743 old_external_syms = obj_aout_external_syms (abfd);
1744
1745 if (! aout_get_external_symbols (abfd))
b34976b6 1746 return FALSE;
252b5132 1747
dc810e39 1748 cached_size = obj_aout_external_sym_count (abfd);
87b32780
MS		 1749 if (cached_size == 0)
1750 return TRUE; /* Nothing to do. */
1751
dc810e39 1752 cached_size *= sizeof (aout_symbol_type);
a50b1753 1753 cached = (aout_symbol_type *) bfd_zmalloc (cached_size);
87b32780 1754 if (cached == NULL)
b34976b6 1755 return FALSE;
252b5132
RH		 1756
1757 /* Convert from external symbol information to internal. */
116c20d2 1758 if (! (NAME (aout, translate_symbol_table)
252b5132
RH		 1759 (abfd, cached,
1760 obj_aout_external_syms (abfd),
1761 obj_aout_external_sym_count (abfd),
1762 obj_aout_external_strings (abfd),
1763 obj_aout_external_string_size (abfd),
b34976b6 1764 FALSE)))
252b5132
RH		 1765 {
1766 free (cached);
b34976b6 1767 return FALSE;
252b5132
RH		 1768 }
1769
1770 bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd);
1771
1772 obj_aout_symbols (abfd) = cached;
1773
1774 /* It is very likely that anybody who calls this function will not
1775 want the external symbol information, so if it was allocated
1776 because of our call to aout_get_external_symbols, we free it up
1777 right away to save space. */
116c20d2
NC		 1778 if (old_external_syms == NULL
1779 && obj_aout_external_syms (abfd) != NULL)
252b5132
RH		 1780 {
1781#ifdef USE_MMAP
1782 bfd_free_window (&obj_aout_sym_window (abfd));
1783#else
1784 free (obj_aout_external_syms (abfd));
1785#endif
1786 obj_aout_external_syms (abfd) = NULL;
1787 }
1788
b34976b6 1789 return TRUE;
252b5132
RH		 1790}
1791\f
1792/* We use a hash table when writing out symbols so that we only write
1793 out a particular string once. This helps particularly when the
1794 linker writes out stabs debugging entries, because each different
1795 contributing object file tends to have many duplicate stabs
1796 strings.
1797
1798 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1799 if BFD_TRADITIONAL_FORMAT is set. */
1800
252b5132
RH		 1801/* Get the index of a string in a strtab, adding it if it is not
1802 already present. */
1803
116c20d2
NC		 1804static inline bfd_size_type
1805add_to_stringtab (bfd *abfd,
1806 struct bfd_strtab_hash *tab,
1807 const char *str,
1808 bfd_boolean copy)
252b5132 1809{
b34976b6 1810 bfd_boolean hash;
91d6fa6a 1811 bfd_size_type str_index;
252b5132
RH		 1812
1813 /* An index of 0 always means the empty string. */
1814 if (str == 0 || *str == '\0')
1815 return 0;
1816
1817 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1818 doesn't understand a hashed string table. */
b34976b6 1819 hash = TRUE;
252b5132 1820 if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
b34976b6 1821 hash = FALSE;
252b5132 1822
91d6fa6a 1823 str_index = _bfd_stringtab_add (tab, str, hash, copy);
252b5132 1824
91d6fa6a 1825 if (str_index != (bfd_size_type) -1)
116c20d2
NC		 1826 /* Add BYTES_IN_WORD to the return value to account for the
1827 space taken up by the string table size. */
91d6fa6a 1828 str_index += BYTES_IN_WORD;
252b5132 1829
91d6fa6a 1830 return str_index;
252b5132
RH		 1831}
1832
1833/* Write out a strtab. ABFD is already at the right location in the
1834 file. */
1835
b34976b6 1836static bfd_boolean
116c20d2 1837emit_stringtab (bfd *abfd, struct bfd_strtab_hash *tab)
252b5132
RH		 1838{
1839 bfd_byte buffer[BYTES_IN_WORD];
dc810e39 1840 bfd_size_type amt = BYTES_IN_WORD;
252b5132
RH		 1841
1842 /* The string table starts with the size. */
1843 PUT_WORD (abfd, _bfd_stringtab_size (tab) + BYTES_IN_WORD, buffer);
116c20d2 1844 if (bfd_bwrite ((void *) buffer, amt, abfd) != amt)
b34976b6 1845 return FALSE;
252b5132
RH		 1846
1847 return _bfd_stringtab_emit (abfd, tab);
1848}
1849\f
b34976b6 1850bfd_boolean
116c20d2 1851NAME (aout, write_syms) (bfd *abfd)
252b5132
RH		 1852{
1853 unsigned int count ;
1854 asymbol **generic = bfd_get_outsymbols (abfd);
1855 struct bfd_strtab_hash *strtab;
1856
1857 strtab = _bfd_stringtab_init ();
1858 if (strtab == NULL)
b34976b6 1859 return FALSE;
252b5132
RH		 1860
1861 for (count = 0; count < bfd_get_symcount (abfd); count++)
1862 {
1863 asymbol *g = generic[count];
1864 bfd_size_type indx;
1865 struct external_nlist nsp;
dc810e39 1866 bfd_size_type amt;
252b5132 1867
b34976b6 1868 indx = add_to_stringtab (abfd, strtab, g->name, FALSE);
252b5132
RH		 1869 if (indx == (bfd_size_type) -1)
1870 goto error_return;
1871 PUT_WORD (abfd, indx, (bfd_byte *) nsp.e_strx);
1872
923f08ff 1873 if (bfd_asymbol_flavour (g) == abfd->xvec->flavour)
252b5132 1874 {
923f08ff
AM		 1875 H_PUT_16 (abfd, aout_symbol (g)->desc, nsp.e_desc);
1876 H_PUT_8 (abfd, aout_symbol (g)->other, nsp.e_other);
1877 H_PUT_8 (abfd, aout_symbol (g)->type, nsp.e_type);
252b5132
RH		 1878 }
1879 else
1880 {
dc810e39
AM		 1881 H_PUT_16 (abfd, 0, nsp.e_desc);
1882 H_PUT_8 (abfd, 0, nsp.e_other);
1883 H_PUT_8 (abfd, 0, nsp.e_type);
252b5132
RH		 1884 }
1885
1886 if (! translate_to_native_sym_flags (abfd, g, &nsp))
1887 goto error_return;
1888
dc810e39 1889 amt = EXTERNAL_NLIST_SIZE;
116c20d2 1890 if (bfd_bwrite ((void *) &nsp, amt, abfd) != amt)
252b5132
RH		 1891 goto error_return;
1892
1893 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1894 here, at the end. */
1895 g->KEEPIT = count;
1896 }
1897
1898 if (! emit_stringtab (abfd, strtab))
1899 goto error_return;
1900
1901 _bfd_stringtab_free (strtab);
1902
b34976b6 1903 return TRUE;
252b5132
RH		 1904
1905error_return:
1906 _bfd_stringtab_free (strtab);
b34976b6 1907 return FALSE;
252b5132 1908}
252b5132
RH		 1909\f
1910long
116c20d2 1911NAME (aout, canonicalize_symtab) (bfd *abfd, asymbol **location)
252b5132 1912{
116c20d2
NC		 1913 unsigned int counter = 0;
1914 aout_symbol_type *symbase;
252b5132 1915
116c20d2
NC		 1916 if (!NAME (aout, slurp_symbol_table) (abfd))
1917 return -1;
252b5132 1918
116c20d2
NC		 1919 for (symbase = obj_aout_symbols (abfd);
1920 counter++ < bfd_get_symcount (abfd);
1921 )
1922 *(location++) = (asymbol *) (symbase++);
1923 *location++ =0;
1924 return bfd_get_symcount (abfd);
252b5132 1925}
252b5132 1926\f
f7c33884 1927/* Standard reloc stuff. */
0ef5a5bd 1928/* Output standard relocation information to a file in target byte order. */
252b5132 1929
116c20d2
NC		 1930extern void NAME (aout, swap_std_reloc_out)
1931 (bfd *, arelent *, struct reloc_std_external *);
252b5132
RH		 1932
1933void
116c20d2
NC		 1934NAME (aout, swap_std_reloc_out) (bfd *abfd,
1935 arelent *g,
1936 struct reloc_std_external *natptr)
252b5132
RH		 1937{
1938 int r_index;
1939 asymbol *sym = *(g->sym_ptr_ptr);
1940 int r_extern;
1941 unsigned int r_length;
1942 int r_pcrel;
1943 int r_baserel, r_jmptable, r_relative;
1944 asection *output_section = sym->section->output_section;
1945
923f08ff 1946 PUT_WORD (abfd, g->address, natptr->r_address);
252b5132 1947
f7c33884
NC		 1948 r_length = g->howto->size ; /* Size as a power of two. */
1949 r_pcrel = (int) g->howto->pc_relative; /* Relative to PC? */
252b5132
RH		 1950 /* XXX This relies on relocs coming from a.out files. */
1951 r_baserel = (g->howto->type & 8) != 0;
1952 r_jmptable = (g->howto->type & 16) != 0;
1953 r_relative = (g->howto->type & 32) != 0;
1954
f7c33884 1955 /* Name was clobbered by aout_write_syms to be symbol index. */
252b5132
RH		 1956
1957 /* If this relocation is relative to a symbol then set the
1958 r_index to the symbols index, and the r_extern bit.
1959
1960 Absolute symbols can come in in two ways, either as an offset
1961 from the abs section, or as a symbol which has an abs value.
f7c33884 1962 check for that here. */
252b5132 1963
252b5132
RH		 1964 if (bfd_is_com_section (output_section)
1965 || bfd_is_abs_section (output_section)
22184a77
NC		 1966 || bfd_is_und_section (output_section)
1967 /* PR gas/3041 a.out relocs against weak symbols
1968 must be treated as if they were against externs. */
1969 || (sym->flags & BSF_WEAK))
252b5132
RH		 1970 {
1971 if (bfd_abs_section_ptr->symbol == sym)
f7c33884
NC		 1972 {
1973 /* Whoops, looked like an abs symbol, but is
1974 really an offset from the abs section. */
1975 r_index = N_ABS;
1976 r_extern = 0;
1977 }
252b5132 1978 else
f7c33884
NC		 1979 {
1980 /* Fill in symbol. */
1981 r_extern = 1;
1982 r_index = (*(g->sym_ptr_ptr))->KEEPIT;
1983 }
252b5132
RH		 1984 }
1985 else
1986 {
f7c33884 1987 /* Just an ordinary section. */
252b5132
RH		 1988 r_extern = 0;
1989 r_index = output_section->target_index;
1990 }
1991
f7c33884 1992 /* Now the fun stuff. */
923f08ff
AM		 1993 if (bfd_header_big_endian (abfd))
1994 {
252b5132
RH		 1995 natptr->r_index[0] = r_index >> 16;
1996 natptr->r_index[1] = r_index >> 8;
1997 natptr->r_index[2] = r_index;
923f08ff
AM		 1998 natptr->r_type[0] = ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
1999 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
2000 | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
2001 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
2002 | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
2003 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
2004 }
2005 else
2006 {
2007 natptr->r_index[2] = r_index >> 16;
2008 natptr->r_index[1] = r_index >> 8;
2009 natptr->r_index[0] = r_index;
2010 natptr->r_type[0] = ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
2011 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
2012 | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
2013 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
2014 | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
2015 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
2016 }
252b5132
RH		 2017}
2018
f7c33884 2019/* Extended stuff. */
0ef5a5bd 2020/* Output extended relocation information to a file in target byte order. */
252b5132 2021
116c20d2
NC		 2022extern void NAME (aout, swap_ext_reloc_out)
2023 (bfd *, arelent *, struct reloc_ext_external *);
252b5132
RH		 2024
2025void
116c20d2
NC		 2026NAME (aout, swap_ext_reloc_out) (bfd *abfd,
2027 arelent *g,
2028 struct reloc_ext_external *natptr)
252b5132
RH		 2029{
2030 int r_index;
2031 int r_extern;
2032 unsigned int r_type;
dc810e39 2033 bfd_vma r_addend;
252b5132
RH		 2034 asymbol *sym = *(g->sym_ptr_ptr);
2035 asection *output_section = sym->section->output_section;
2036
2037 PUT_WORD (abfd, g->address, natptr->r_address);
2038
2039 r_type = (unsigned int) g->howto->type;
2040
2041 r_addend = g->addend;
2042 if ((sym->flags & BSF_SECTION_SYM) != 0)
2043 r_addend += (*(g->sym_ptr_ptr))->section->output_section->vma;
2044
2045 /* If this relocation is relative to a symbol then set the
2046 r_index to the symbols index, and the r_extern bit.
2047
2048 Absolute symbols can come in in two ways, either as an offset
2049 from the abs section, or as a symbol which has an abs value.
2050 check for that here. */
252b5132
RH		 2051 if (bfd_is_abs_section (bfd_get_section (sym)))
2052 {
2053 r_extern = 0;
2054 r_index = N_ABS;
2055 }
2056 else if ((sym->flags & BSF_SECTION_SYM) == 0)
2057 {
2058 if (bfd_is_und_section (bfd_get_section (sym))
2059 || (sym->flags & BSF_GLOBAL) != 0)
2060 r_extern = 1;
2061 else
2062 r_extern = 0;
2063 r_index = (*(g->sym_ptr_ptr))->KEEPIT;
2064 }
2065 else
2066 {
f7c33884 2067 /* Just an ordinary section. */
252b5132
RH		 2068 r_extern = 0;
2069 r_index = output_section->target_index;
2070 }
2071
f7c33884 2072 /* Now the fun stuff. */
923f08ff
AM		 2073 if (bfd_header_big_endian (abfd))
2074 {
2075 natptr->r_index[0] = r_index >> 16;
2076 natptr->r_index[1] = r_index >> 8;
2077 natptr->r_index[2] = r_index;
2078 natptr->r_type[0] = ((r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
2079 | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG));
2080 }
2081 else
2082 {
2083 natptr->r_index[2] = r_index >> 16;
2084 natptr->r_index[1] = r_index >> 8;
2085 natptr->r_index[0] = r_index;
2086 natptr->r_type[0] = ((r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
2087 | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE));
2088 }
252b5132
RH		 2089
2090 PUT_WORD (abfd, r_addend, natptr->r_addend);
2091}
2092
2093/* BFD deals internally with all things based from the section they're
2094 in. so, something in 10 bytes into a text section with a base of
2095 50 would have a symbol (.text+10) and know .text vma was 50.
2096
2097 Aout keeps all it's symbols based from zero, so the symbol would
2098 contain 60. This macro subs the base of each section from the value
923f08ff
AM		 2099 to give the true offset from the section. */
2100
2101#define MOVE_ADDRESS(ad) \
2102 if (r_extern) \
2103 { \
2104 /* Undefined symbol. */ \
2105 cache_ptr->sym_ptr_ptr = symbols + r_index; \
252b5132 2106 cache_ptr->addend = ad; \
252b5132 2107 } \
923f08ff
AM		 2108 else \
2109 { \
2110 /* Defined, section relative. Replace symbol with pointer to \
2111 symbol which points to section. */ \
2112 switch (r_index) \
2113 { \
2114 case N_TEXT: \
2115 case N_TEXT | N_EXT: \
2116 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
2117 cache_ptr->addend = ad - su->textsec->vma; \
2118 break; \
2119 case N_DATA: \
2120 case N_DATA | N_EXT: \
2121 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
2122 cache_ptr->addend = ad - su->datasec->vma; \
2123 break; \
2124 case N_BSS: \
2125 case N_BSS | N_EXT: \
2126 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
2127 cache_ptr->addend = ad - su->bsssec->vma; \
2128 break; \
2129 default: \
2130 case N_ABS: \
2131 case N_ABS | N_EXT: \
2132 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
2133 cache_ptr->addend = ad; \
2134 break; \
2135 } \
2136 }
252b5132
RH		 2137
2138void
116c20d2
NC		 2139NAME (aout, swap_ext_reloc_in) (bfd *abfd,
2140 struct reloc_ext_external *bytes,
2141 arelent *cache_ptr,
2142 asymbol **symbols,
2143 bfd_size_type symcount)
252b5132
RH		 2144{
2145 unsigned int r_index;
2146 int r_extern;
2147 unsigned int r_type;
2148 struct aoutdata *su = &(abfd->tdata.aout_data->a);
2149
2150 cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));
2151
f7c33884 2152 /* Now the fun stuff. */
923f08ff
AM		 2153 if (bfd_header_big_endian (abfd))
2154 {
d45913a0
DA		 2155 r_index = (((unsigned int) bytes->r_index[0] << 16)
2156 | ((unsigned int) bytes->r_index[1] << 8)
923f08ff
AM		 2157 | bytes->r_index[2]);
2158 r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
2159 r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
2160 >> RELOC_EXT_BITS_TYPE_SH_BIG);
2161 }
2162 else
2163 {
d45913a0
DA		 2164 r_index = (((unsigned int) bytes->r_index[2] << 16)
2165 | ((unsigned int) bytes->r_index[1] << 8)
923f08ff
AM		 2166 | bytes->r_index[0]);
2167 r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
2168 r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
2169 >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
2170 }
252b5132 2171
ad756e3f
AM		 2172 if (r_type < TABLE_SIZE (howto_table_ext))
2173 cache_ptr->howto = howto_table_ext + r_type;
2174 else
2175 cache_ptr->howto = NULL;
252b5132
RH		 2176
2177 /* Base relative relocs are always against the symbol table,
2178 regardless of the setting of r_extern. r_extern just reflects
2179 whether the symbol the reloc is against is local or global. */
d45913a0
DA		 2180 if (r_type == (unsigned int) RELOC_BASE10
2181 || r_type == (unsigned int) RELOC_BASE13
2182 || r_type == (unsigned int) RELOC_BASE22)
252b5132
RH		 2183 r_extern = 1;
2184
2185 if (r_extern && r_index > symcount)
2186 {
2187 /* We could arrange to return an error, but it might be useful
2188 to see the file even if it is bad. */
2189 r_extern = 0;
2190 r_index = N_ABS;
2191 }
2192
923f08ff 2193 MOVE_ADDRESS (GET_SWORD (abfd, bytes->r_addend));
252b5132
RH		 2194}
2195
2196void
116c20d2
NC		 2197NAME (aout, swap_std_reloc_in) (bfd *abfd,
2198 struct reloc_std_external *bytes,
2199 arelent *cache_ptr,
2200 asymbol **symbols,
2201 bfd_size_type symcount)
252b5132
RH		 2202{
2203 unsigned int r_index;
2204 int r_extern;
2205 unsigned int r_length;
2206 int r_pcrel;
2207 int r_baserel, r_jmptable, r_relative;
2208 struct aoutdata *su = &(abfd->tdata.aout_data->a);
2209 unsigned int howto_idx;
2210
dc810e39 2211 cache_ptr->address = H_GET_32 (abfd, bytes->r_address);
252b5132 2212
f7c33884 2213 /* Now the fun stuff. */
923f08ff
AM		 2214 if (bfd_header_big_endian (abfd))
2215 {
d45913a0
DA		 2216 r_index = (((unsigned int) bytes->r_index[0] << 16)
2217 | ((unsigned int) bytes->r_index[1] << 8)
923f08ff
AM		 2218 | bytes->r_index[2]);
2219 r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
2220 r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
2221 r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
2222 r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
2223 r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
2224 r_length = ((bytes->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
2225 >> RELOC_STD_BITS_LENGTH_SH_BIG);
2226 }
2227 else
2228 {
d45913a0
DA		 2229 r_index = (((unsigned int) bytes->r_index[2] << 16)
2230 | ((unsigned int) bytes->r_index[1] << 8)
923f08ff
AM		 2231 | bytes->r_index[0]);
2232 r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
2233 r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
2234 r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE));
2235 r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
2236 r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_LITTLE));
2237 r_length = ((bytes->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
2238 >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
2239 }
252b5132 2240
923f08ff
AM		 2241 howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel
2242 + 16 * r_jmptable + 32 * r_relative);
ad756e3f
AM		 2243 if (howto_idx < TABLE_SIZE (howto_table_std))
2244 {
2245 cache_ptr->howto = howto_table_std + howto_idx;
2246 if (cache_ptr->howto->type == (unsigned int) -1)
2247 cache_ptr->howto = NULL;
2248 }
2249 else
2250 cache_ptr->howto = NULL;
252b5132
RH		 2251
2252 /* Base relative relocs are always against the symbol table,
2253 regardless of the setting of r_extern. r_extern just reflects
2254 whether the symbol the reloc is against is local or global. */
2255 if (r_baserel)
2256 r_extern = 1;
2257
2258 if (r_extern && r_index > symcount)
2259 {
2260 /* We could arrange to return an error, but it might be useful
2261 to see the file even if it is bad. */
2262 r_extern = 0;
2263 r_index = N_ABS;
2264 }
2265
923f08ff 2266 MOVE_ADDRESS (0);
252b5132
RH		 2267}
2268
2269/* Read and swap the relocs for a section. */
2270
b34976b6 2271bfd_boolean
116c20d2 2272NAME (aout, slurp_reloc_table) (bfd *abfd, sec_ptr asect, asymbol **symbols)
252b5132 2273{
dc810e39 2274 bfd_size_type count;
252b5132 2275 bfd_size_type reloc_size;
116c20d2 2276 void * relocs;
252b5132
RH		 2277 arelent *reloc_cache;
2278 size_t each_size;
2279 unsigned int counter = 0;
2280 arelent *cache_ptr;
dc810e39 2281 bfd_size_type amt;
252b5132
RH		 2282
2283 if (asect->relocation)
b34976b6 2284 return TRUE;
252b5132
RH		 2285
2286 if (asect->flags & SEC_CONSTRUCTOR)
b34976b6 2287 return TRUE;
252b5132
RH		 2288
2289 if (asect == obj_datasec (abfd))
923f08ff 2290 reloc_size = exec_hdr (abfd)->a_drsize;
252b5132 2291 else if (asect == obj_textsec (abfd))
923f08ff 2292 reloc_size = exec_hdr (abfd)->a_trsize;
252b5132
RH		 2293 else if (asect == obj_bsssec (abfd))
2294 reloc_size = 0;
2295 else
2296 {
2297 bfd_set_error (bfd_error_invalid_operation);
b34976b6 2298 return FALSE;
252b5132
RH		 2299 }
2300
078c4bfc
MS		 2301 if (reloc_size == 0)
2302 return TRUE; /* Nothing to be done. */
2303
252b5132 2304 if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
b34976b6 2305 return FALSE;
252b5132
RH		 2306
2307 each_size = obj_reloc_entry_size (abfd);
2308
2309 count = reloc_size / each_size;
078c4bfc
MS		 2310 if (count == 0)
2311 return TRUE; /* Nothing to be done. */
252b5132 2312
dc810e39 2313 amt = count * sizeof (arelent);
a50b1753 2314 reloc_cache = (arelent *) bfd_zmalloc (amt);
078c4bfc 2315 if (reloc_cache == NULL)
b34976b6 2316 return FALSE;
252b5132 2317
dc810e39 2318 relocs = bfd_malloc (reloc_size);
078c4bfc 2319 if (relocs == NULL)
252b5132
RH		 2320 {
2321 free (reloc_cache);
b34976b6 2322 return FALSE;
252b5132
RH		 2323 }
2324
dc810e39 2325 if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
252b5132
RH		 2326 {
2327 free (relocs);
2328 free (reloc_cache);
b34976b6 2329 return FALSE;
252b5132
RH		 2330 }
2331
2332 cache_ptr = reloc_cache;
2333 if (each_size == RELOC_EXT_SIZE)
2334 {
dc810e39 2335 struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs;
252b5132
RH		 2336
2337 for (; counter < count; counter++, rptr++, cache_ptr++)
1642229e 2338 MY_swap_ext_reloc_in (abfd, rptr, cache_ptr, symbols,
dc810e39 2339 (bfd_size_type) bfd_get_symcount (abfd));
252b5132
RH		 2340 }
2341 else
2342 {
dc810e39 2343 struct reloc_std_external *rptr = (struct reloc_std_external *) relocs;
252b5132
RH		 2344
2345 for (; counter < count; counter++, rptr++, cache_ptr++)
2346 MY_swap_std_reloc_in (abfd, rptr, cache_ptr, symbols,
dc810e39 2347 (bfd_size_type) bfd_get_symcount (abfd));
252b5132
RH		 2348 }
2349
2350 free (relocs);
2351
2352 asect->relocation = reloc_cache;
2353 asect->reloc_count = cache_ptr - reloc_cache;
2354
b34976b6 2355 return TRUE;
252b5132
RH		 2356}
2357
2358/* Write out a relocation section into an object file. */
2359
b34976b6 2360bfd_boolean
116c20d2 2361NAME (aout, squirt_out_relocs) (bfd *abfd, asection *section)
252b5132
RH		 2362{
2363 arelent **generic;
2364 unsigned char *native, *natptr;
2365 size_t each_size;
2366
2367 unsigned int count = section->reloc_count;
dc810e39 2368 bfd_size_type natsize;
252b5132
RH		 2369
2370 if (count == 0 || section->orelocation == NULL)
b34976b6 2371 return TRUE;
252b5132
RH		 2372
2373 each_size = obj_reloc_entry_size (abfd);
dc810e39 2374 natsize = (bfd_size_type) each_size * count;
a50b1753 2375 native = (unsigned char *) bfd_zalloc (abfd, natsize);
252b5132 2376 if (!native)
b34976b6 2377 return FALSE;
252b5132
RH		 2378
2379 generic = section->orelocation;
2380
2381 if (each_size == RELOC_EXT_SIZE)
2382 {
2383 for (natptr = native;
2384 count != 0;
2385 --count, natptr += each_size, ++generic)
1642229e
HPN		 2386 MY_swap_ext_reloc_out (abfd, *generic,
2387 (struct reloc_ext_external *) natptr);
252b5132
RH		 2388 }
2389 else
2390 {
2391 for (natptr = native;
2392 count != 0;
2393 --count, natptr += each_size, ++generic)
923f08ff
AM		 2394 MY_swap_std_reloc_out (abfd, *generic,
2395 (struct reloc_std_external *) natptr);
252b5132
RH		 2396 }
2397
116c20d2 2398 if (bfd_bwrite ((void *) native, natsize, abfd) != natsize)
dc810e39 2399 {
923f08ff 2400 bfd_release (abfd, native);
b34976b6 2401 return FALSE;
dc810e39 2402 }
252b5132
RH		 2403 bfd_release (abfd, native);
2404
b34976b6 2405 return TRUE;
252b5132
RH		 2406}
2407
f7c33884
NC		 2408/* This is stupid. This function should be a boolean predicate. */
2409
252b5132 2410long
116c20d2
NC		 2411NAME (aout, canonicalize_reloc) (bfd *abfd,
2412 sec_ptr section,
2413 arelent **relptr,
2414 asymbol **symbols)
252b5132
RH		 2415{
2416 arelent *tblptr = section->relocation;
2417 unsigned int count;
2418
2419 if (section == obj_bsssec (abfd))
2420 {
2421 *relptr = NULL;
2422 return 0;
2423 }
2424
116c20d2 2425 if (!(tblptr || NAME (aout, slurp_reloc_table) (abfd, section, symbols)))
252b5132
RH		 2426 return -1;
2427
923f08ff
AM		 2428 if (section->flags & SEC_CONSTRUCTOR)
2429 {
2430 arelent_chain *chain = section->constructor_chain;
2431 for (count = 0; count < section->reloc_count; count ++)
2432 {
2433 *relptr ++ = &chain->relent;
2434 chain = chain->next;
2435 }
252b5132 2436 }
923f08ff
AM		 2437 else
2438 {
2439 tblptr = section->relocation;
252b5132 2440
923f08ff
AM		 2441 for (count = 0; count++ < section->reloc_count; )
2442 {
2443 *relptr++ = tblptr++;
2444 }
2445 }
252b5132
RH		 2446 *relptr = 0;
2447
2448 return section->reloc_count;
2449}
2450
2451long
116c20d2 2452NAME (aout, get_reloc_upper_bound) (bfd *abfd, sec_ptr asect)
252b5132 2453{
923f08ff
AM		 2454 if (bfd_get_format (abfd) != bfd_object)
2455 {
2456 bfd_set_error (bfd_error_invalid_operation);
2457 return -1;
2458 }
f7c33884 2459
923f08ff 2460 if (asect->flags & SEC_CONSTRUCTOR)
116c20d2 2461 return sizeof (arelent *) * (asect->reloc_count + 1);
252b5132
RH		 2462
2463 if (asect == obj_datasec (abfd))
116c20d2
NC		 2464 return sizeof (arelent *)
2465 * ((exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd))
2466 + 1);
252b5132
RH		 2467
2468 if (asect == obj_textsec (abfd))
116c20d2
NC		 2469 return sizeof (arelent *)
2470 * ((exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd))
2471 + 1);
252b5132
RH		 2472
2473 if (asect == obj_bsssec (abfd))
2474 return sizeof (arelent *);
2475
2476 if (asect == obj_bsssec (abfd))
2477 return 0;
2478
2479 bfd_set_error (bfd_error_invalid_operation);
2480 return -1;
2481}
252b5132
RH		 2482\f
2483long
116c20d2 2484NAME (aout, get_symtab_upper_bound) (bfd *abfd)
252b5132 2485{
116c20d2 2486 if (!NAME (aout, slurp_symbol_table) (abfd))
252b5132
RH		 2487 return -1;
2488
2489 return (bfd_get_symcount (abfd)+1) * (sizeof (aout_symbol_type *));
2490}
2491
1725a96e 2492alent *
116c20d2
NC		 2493NAME (aout, get_lineno) (bfd *ignore_abfd ATTRIBUTE_UNUSED,
2494 asymbol *ignore_symbol ATTRIBUTE_UNUSED)
252b5132 2495{
116c20d2 2496 return NULL;
252b5132
RH		 2497}
2498
252b5132 2499void
116c20d2
NC		 2500NAME (aout, get_symbol_info) (bfd *ignore_abfd ATTRIBUTE_UNUSED,
2501 asymbol *symbol,
2502 symbol_info *ret)
252b5132
RH		 2503{
2504 bfd_symbol_info (symbol, ret);
2505
2506 if (ret->type == '?')
2507 {
923f08ff 2508 int type_code = aout_symbol (symbol)->type & 0xff;
252b5132
RH		 2509 const char *stab_name = bfd_get_stab_name (type_code);
2510 static char buf[10];
2511
2512 if (stab_name == NULL)
2513 {
e60b52c6 2514 sprintf (buf, "(%d)", type_code);
252b5132
RH		 2515 stab_name = buf;
2516 }
2517 ret->type = '-';
2518 ret->stab_type = type_code;
923f08ff
AM		 2519 ret->stab_other = (unsigned) (aout_symbol (symbol)->other & 0xff);
2520 ret->stab_desc = (unsigned) (aout_symbol (symbol)->desc & 0xffff);
252b5132
RH		 2521 ret->stab_name = stab_name;
2522 }
2523}
2524
252b5132 2525void
116c20d2
NC		 2526NAME (aout, print_symbol) (bfd *abfd,
2527 void * afile,
2528 asymbol *symbol,
2529 bfd_print_symbol_type how)
252b5132
RH		 2530{
2531 FILE *file = (FILE *)afile;
2532
923f08ff 2533 switch (how)
252b5132 2534 {
923f08ff
AM		 2535 case bfd_print_symbol_name:
2536 if (symbol->name)
2537 fprintf (file,"%s", symbol->name);
2538 break;
2539 case bfd_print_symbol_more:
2540 fprintf (file,"%4x %2x %2x",
2541 (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2542 (unsigned) (aout_symbol (symbol)->other & 0xff),
2543 (unsigned) (aout_symbol (symbol)->type));
2544 break;
2545 case bfd_print_symbol_all:
2546 {
2547 const char *section_name = symbol->section->name;
252b5132 2548
116c20d2 2549 bfd_print_symbol_vandf (abfd, (void *)file, symbol);
252b5132 2550
923f08ff
AM		 2551 fprintf (file," %-5s %04x %02x %02x",
2552 section_name,
2553 (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2554 (unsigned) (aout_symbol (symbol)->other & 0xff),
2555 (unsigned) (aout_symbol (symbol)->type & 0xff));
2556 if (symbol->name)
2557 fprintf (file," %s", symbol->name);
2558 }
2559 break;
252b5132 2560 }
252b5132
RH		 2561}
2562
2563/* If we don't have to allocate more than 1MB to hold the generic
2564 symbols, we use the generic minisymbol methord: it's faster, since
2565 it only translates the symbols once, not multiple times. */
2566#define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2567
2568/* Read minisymbols. For minisymbols, we use the unmodified a.out
2569 symbols. The minisymbol_to_symbol function translates these into
2570 BFD asymbol structures. */
2571
2572long
116c20d2
NC		 2573NAME (aout, read_minisymbols) (bfd *abfd,
2574 bfd_boolean dynamic,
2575 void * *minisymsp,
2576 unsigned int *sizep)
252b5132
RH		 2577{
2578 if (dynamic)
116c20d2
NC		 2579 /* We could handle the dynamic symbols here as well, but it's
2580 easier to hand them off. */
2581 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
252b5132
RH		 2582
2583 if (! aout_get_external_symbols (abfd))
2584 return -1;
2585
2586 if (obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2587 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2588
116c20d2 2589 *minisymsp = (void *) obj_aout_external_syms (abfd);
252b5132
RH		 2590
2591 /* By passing the external symbols back from this routine, we are
2592 giving up control over the memory block. Clear
2593 obj_aout_external_syms, so that we do not try to free it
2594 ourselves. */
2595 obj_aout_external_syms (abfd) = NULL;
2596
2597 *sizep = EXTERNAL_NLIST_SIZE;
2598 return obj_aout_external_sym_count (abfd);
2599}
2600
2601/* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2602 unmodified a.out symbol. The SYM argument is a structure returned
2603 by bfd_make_empty_symbol, which we fill in here. */
2604
2605asymbol *
116c20d2
NC		 2606NAME (aout, minisymbol_to_symbol) (bfd *abfd,
2607 bfd_boolean dynamic,
2608 const void * minisym,
2609 asymbol *sym)
252b5132
RH		 2610{
2611 if (dynamic
2612 || obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2613 return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
2614
2615 memset (sym, 0, sizeof (aout_symbol_type));
2616
2617 /* We call translate_symbol_table to translate a single symbol. */
116c20d2 2618 if (! (NAME (aout, translate_symbol_table)
252b5132
RH		 2619 (abfd,
2620 (aout_symbol_type *) sym,
2621 (struct external_nlist *) minisym,
2622 (bfd_size_type) 1,
2623 obj_aout_external_strings (abfd),
2624 obj_aout_external_string_size (abfd),
b34976b6 2625 FALSE)))
252b5132
RH		 2626 return NULL;
2627
2628 return sym;
2629}
2630
f7c33884
NC		 2631/* Provided a BFD, a section and an offset into the section, calculate
2632 and return the name of the source file and the line nearest to the
2633 wanted location. */
252b5132 2634
b34976b6 2635bfd_boolean
116c20d2
NC		 2636NAME (aout, find_nearest_line) (bfd *abfd,
2637 asection *section,
2638 asymbol **symbols,
2639 bfd_vma offset,
2640 const char **filename_ptr,
2641 const char **functionname_ptr,
2642 unsigned int *line_ptr)
252b5132 2643{
f7c33884 2644 /* Run down the file looking for the filename, function and linenumber. */
252b5132 2645 asymbol **p;
dc810e39
AM		 2646 const char *directory_name = NULL;
2647 const char *main_file_name = NULL;
2648 const char *current_file_name = NULL;
116c20d2 2649 const char *line_file_name = NULL; /* Value of current_file_name at line number. */
dc810e39 2650 const char *line_directory_name = NULL; /* Value of directory_name at line number. */
252b5132
RH		 2651 bfd_vma low_line_vma = 0;
2652 bfd_vma low_func_vma = 0;
2653 asymbol *func = 0;
dc810e39 2654 bfd_size_type filelen, funclen;
252b5132
RH		 2655 char *buf;
2656
2657 *filename_ptr = abfd->filename;
2658 *functionname_ptr = 0;
2659 *line_ptr = 0;
f7c33884 2660
116c20d2 2661 if (symbols != NULL)
923f08ff
AM		 2662 {
2663 for (p = symbols; *p; p++)
2664 {
2665 aout_symbol_type *q = (aout_symbol_type *) (*p);
2666 next:
2667 switch (q->type)
2668 {
2669 case N_TEXT:
2670 /* If this looks like a file name symbol, and it comes after
2671 the line number we have found so far, but before the
2672 offset, then we have probably not found the right line
2673 number. */
2674 if (q->symbol.value <= offset
2675 && ((q->symbol.value > low_line_vma
2676 && (line_file_name != NULL
2677 || *line_ptr != 0))
2678 || (q->symbol.value > low_func_vma
2679 && func != NULL)))
2680 {
2681 const char *symname;
252b5132 2682
923f08ff
AM		 2683 symname = q->symbol.name;
2684 if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
2685 {
2686 if (q->symbol.value > low_line_vma)
2687 {
2688 *line_ptr = 0;
2689 line_file_name = NULL;
2690 }
2691 if (q->symbol.value > low_func_vma)
2692 func = NULL;
2693 }
2694 }
2695 break;
252b5132 2696
923f08ff
AM		 2697 case N_SO:
2698 /* If this symbol is less than the offset, but greater than
2699 the line number we have found so far, then we have not
2700 found the right line number. */
2701 if (q->symbol.value <= offset)
2702 {
2703 if (q->symbol.value > low_line_vma)
2704 {
2705 *line_ptr = 0;
2706 line_file_name = NULL;
2707 }
2708 if (q->symbol.value > low_func_vma)
2709 func = NULL;
2710 }
252b5132 2711
923f08ff
AM		 2712 main_file_name = current_file_name = q->symbol.name;
2713 /* Look ahead to next symbol to check if that too is an N_SO. */
2714 p++;
2715 if (*p == NULL)
c3864421 2716 goto done;
923f08ff
AM		 2717 q = (aout_symbol_type *) (*p);
2718 if (q->type != (int)N_SO)
2719 goto next;
2720
2721 /* Found a second N_SO First is directory; second is filename. */
2722 directory_name = current_file_name;
2723 main_file_name = current_file_name = q->symbol.name;
2724 if (obj_textsec (abfd) != section)
2725 goto done;
2726 break;
2727 case N_SOL:
2728 current_file_name = q->symbol.name;
2729 break;
252b5132 2730
923f08ff 2731 case N_SLINE:
252b5132 2732
923f08ff
AM		 2733 case N_DSLINE:
2734 case N_BSLINE:
2735 /* We'll keep this if it resolves nearer than the one we have
2736 already. */
2737 if (q->symbol.value >= low_line_vma
2738 && q->symbol.value <= offset)
2739 {
2740 *line_ptr = q->desc;
2741 low_line_vma = q->symbol.value;
2742 line_file_name = current_file_name;
2743 line_directory_name = directory_name;
2744 }
2745 break;
2746 case N_FUN:
2747 {
f7c33884 2748 /* We'll keep this if it is nearer than the one we have already. */
923f08ff 2749 if (q->symbol.value >= low_func_vma &&
f7c33884
NC		 2750 q->symbol.value <= offset)
2751 {
2752 low_func_vma = q->symbol.value;
2753 func = (asymbol *)q;
2754 }
923f08ff
AM		 2755 else if (q->symbol.value > offset)
2756 goto done;
2757 }
2758 break;
2759 }
252b5132 2760 }
252b5132 2761 }
252b5132
RH		 2762
2763 done:
2764 if (*line_ptr != 0)
2765 {
2766 main_file_name = line_file_name;
2767 directory_name = line_directory_name;
2768 }
2769
2770 if (main_file_name == NULL
5af11cab 2771 || IS_ABSOLUTE_PATH (main_file_name)
252b5132
RH		 2772 || directory_name == NULL)
2773 filelen = 0;
2774 else
2775 filelen = strlen (directory_name) + strlen (main_file_name);
f7c33884 2776
252b5132
RH		 2777 if (func == NULL)
2778 funclen = 0;
2779 else
2780 funclen = strlen (bfd_asymbol_name (func));
2781
2782 if (adata (abfd).line_buf != NULL)
2783 free (adata (abfd).line_buf);
f7c33884 2784
252b5132
RH		 2785 if (filelen + funclen == 0)
2786 adata (abfd).line_buf = buf = NULL;
2787 else
2788 {
a50b1753 2789 buf = (char *) bfd_malloc (filelen + funclen + 3);
252b5132
RH		 2790 adata (abfd).line_buf = buf;
2791 if (buf == NULL)
b34976b6 2792 return FALSE;
252b5132
RH		 2793 }
2794
2795 if (main_file_name != NULL)
2796 {
5af11cab 2797 if (IS_ABSOLUTE_PATH (main_file_name) || directory_name == NULL)
252b5132
RH		 2798 *filename_ptr = main_file_name;
2799 else
2800 {
2801 sprintf (buf, "%s%s", directory_name, main_file_name);
2802 *filename_ptr = buf;
2803 buf += filelen + 1;
2804 }
2805 }
2806
2807 if (func)
2808 {
2809 const char *function = func->name;
dc810e39 2810 char *colon;
252b5132
RH		 2811
2812 /* The caller expects a symbol name. We actually have a
2813 function name, without the leading underscore. Put the
2814 underscore back in, so that the caller gets a symbol name. */
2815 if (bfd_get_symbol_leading_char (abfd) == '\0')
2816 strcpy (buf, function);
2817 else
2818 {
2819 buf[0] = bfd_get_symbol_leading_char (abfd);
2820 strcpy (buf + 1, function);
2821 }
f7c33884 2822 /* Have to remove : stuff. */
dc810e39
AM		 2823 colon = strchr (buf, ':');
2824 if (colon != NULL)
2825 *colon = '\0';
252b5132
RH		 2826 *functionname_ptr = buf;
2827 }
2828
b34976b6 2829 return TRUE;
252b5132
RH		 2830}
2831
252b5132 2832int
a6b96beb
AM		 2833NAME (aout, sizeof_headers) (bfd *abfd,
2834 struct bfd_link_info *info ATTRIBUTE_UNUSED)
252b5132 2835{
923f08ff 2836 return adata (abfd).exec_bytes_size;
252b5132
RH		 2837}
2838
2839/* Free all information we have cached for this BFD. We can always
2840 read it again later if we need it. */
2841
b34976b6 2842bfd_boolean
116c20d2 2843NAME (aout, bfd_free_cached_info) (bfd *abfd)
252b5132
RH		 2844{
2845 asection *o;
2846
920581c5
L		 2847 if (bfd_get_format (abfd) != bfd_object
2848 || abfd->tdata.aout_data == NULL)
b34976b6 2849 return TRUE;
252b5132
RH		 2850
2851#define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2852 BFCI_FREE (obj_aout_symbols (abfd));
2853#ifdef USE_MMAP
2854 obj_aout_external_syms (abfd) = 0;
2855 bfd_free_window (&obj_aout_sym_window (abfd));
2856 bfd_free_window (&obj_aout_string_window (abfd));
2857 obj_aout_external_strings (abfd) = 0;
2858#else
2859 BFCI_FREE (obj_aout_external_syms (abfd));
2860 BFCI_FREE (obj_aout_external_strings (abfd));
2861#endif
116c20d2 2862 for (o = abfd->sections; o != NULL; o = o->next)
252b5132
RH		 2863 BFCI_FREE (o->relocation);
2864#undef BFCI_FREE
2865
b34976b6 2866 return TRUE;
252b5132
RH		 2867}
2868\f
2869/* a.out link code. */
2870
252b5132
RH		 2871/* Routine to create an entry in an a.out link hash table. */
2872
2873struct bfd_hash_entry *
116c20d2
NC		 2874NAME (aout, link_hash_newfunc) (struct bfd_hash_entry *entry,
2875 struct bfd_hash_table *table,
2876 const char *string)
252b5132
RH		 2877{
2878 struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry;
2879
2880 /* Allocate the structure if it has not already been allocated by a
2881 subclass. */
116c20d2 2882 if (ret == NULL)
a50b1753
NC		 2883 ret = (struct aout_link_hash_entry *) bfd_hash_allocate (table,
2884 sizeof (* ret));
116c20d2
NC		 2885 if (ret == NULL)
2886 return NULL;
252b5132
RH		 2887
2888 /* Call the allocation method of the superclass. */
2889 ret = ((struct aout_link_hash_entry *)
2890 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2891 table, string));
2892 if (ret)
2893 {
2894 /* Set local fields. */
b34976b6 2895 ret->written = FALSE;
252b5132
RH		 2896 ret->indx = -1;
2897 }
2898
2899 return (struct bfd_hash_entry *) ret;
2900}
2901
2902/* Initialize an a.out link hash table. */
2903
b34976b6 2904bfd_boolean
116c20d2
NC		 2905NAME (aout, link_hash_table_init) (struct aout_link_hash_table *table,
2906 bfd *abfd,
2907 struct bfd_hash_entry *(*newfunc)
2908 (struct bfd_hash_entry *, struct bfd_hash_table *,
66eb6687
AM		 2909 const char *),
2910 unsigned int entsize)
252b5132 2911{
66eb6687 2912 return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
252b5132
RH		 2913}
2914
2915/* Create an a.out link hash table. */
2916
2917struct bfd_link_hash_table *
116c20d2 2918NAME (aout, link_hash_table_create) (bfd *abfd)
252b5132
RH		 2919{
2920 struct aout_link_hash_table *ret;
116c20d2 2921 bfd_size_type amt = sizeof (* ret);
252b5132 2922
a50b1753 2923 ret = (struct aout_link_hash_table *) bfd_malloc (amt);
252b5132 2924 if (ret == NULL)
116c20d2 2925 return NULL;
5ed6aba4 2926
66eb6687
AM		 2927 if (!NAME (aout, link_hash_table_init) (ret, abfd,
2928 NAME (aout, link_hash_newfunc),
2929 sizeof (struct aout_link_hash_entry)))
252b5132
RH		 2930 {
2931 free (ret);
116c20d2 2932 return NULL;
252b5132
RH		 2933 }
2934 return &ret->root;
2935}
2936
116c20d2 2937/* Add all symbols from an object file to the hash table. */
252b5132 2938
b34976b6 2939static bfd_boolean
116c20d2 2940aout_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
252b5132 2941{
116c20d2
NC		 2942 bfd_boolean (*add_one_symbol)
2943 (struct bfd_link_info *, bfd *, const char *, flagword, asection *,
2944 bfd_vma, const char *, bfd_boolean, bfd_boolean,
2945 struct bfd_link_hash_entry **);
2946 struct external_nlist *syms;
2947 bfd_size_type sym_count;
2948 char *strings;
2949 bfd_boolean copy;
2950 struct aout_link_hash_entry **sym_hash;
2951 struct external_nlist *p;
2952 struct external_nlist *pend;
2953 bfd_size_type amt;
252b5132 2954
116c20d2
NC		 2955 syms = obj_aout_external_syms (abfd);
2956 sym_count = obj_aout_external_sym_count (abfd);
2957 strings = obj_aout_external_strings (abfd);
2958 if (info->keep_memory)
2959 copy = FALSE;
2960 else
2961 copy = TRUE;
252b5132 2962
116c20d2 2963 if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
252b5132 2964 {
116c20d2
NC		 2965 if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
2966 (abfd, info, &syms, &sym_count, &strings)))
b34976b6 2967 return FALSE;
252b5132
RH		 2968 }
2969
20c6e70e
MS		 2970 if (sym_count == 0)
2971 return TRUE; /* Nothing to do. */
2972
116c20d2
NC		 2973 /* We keep a list of the linker hash table entries that correspond
2974 to particular symbols. We could just look them up in the hash
2975 table, but keeping the list is more efficient. Perhaps this
2976 should be conditional on info->keep_memory. */
2977 amt = sym_count * sizeof (struct aout_link_hash_entry *);
a50b1753 2978 sym_hash = (struct aout_link_hash_entry **) bfd_alloc (abfd, amt);
20c6e70e 2979 if (sym_hash == NULL)
116c20d2
NC		 2980 return FALSE;
2981 obj_aout_sym_hashes (abfd) = sym_hash;
252b5132 2982
116c20d2
NC		 2983 add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
2984 if (add_one_symbol == NULL)
2985 add_one_symbol = _bfd_generic_link_add_one_symbol;
252b5132 2986
116c20d2
NC		 2987 p = syms;
2988 pend = p + sym_count;
2989 for (; p < pend; p++, sym_hash++)
252b5132 2990 {
116c20d2 2991 int type;
252b5132 2992 const char *name;
116c20d2
NC		 2993 bfd_vma value;
2994 asection *section;
2995 flagword flags;
2996 const char *string;
252b5132 2997
116c20d2 2998 *sym_hash = NULL;
252b5132 2999
116c20d2 3000 type = H_GET_8 (abfd, p->e_type);
252b5132 3001
116c20d2
NC		 3002 /* Ignore debugging symbols. */
3003 if ((type & N_STAB) != 0)
3004 continue;
252b5132 3005
116c20d2
NC		 3006 name = strings + GET_WORD (abfd, p->e_strx);
3007 value = GET_WORD (abfd, p->e_value);
3008 flags = BSF_GLOBAL;
3009 string = NULL;
3010 switch (type)
252b5132 3011 {
116c20d2
NC		 3012 default:
3013 abort ();
f7c33884 3014
116c20d2
NC		 3015 case N_UNDF:
3016 case N_ABS:
3017 case N_TEXT:
3018 case N_DATA:
3019 case N_BSS:
3020 case N_FN_SEQ:
3021 case N_COMM:
3022 case N_SETV:
3023 case N_FN:
3024 /* Ignore symbols that are not externally visible. */
3025 continue;
3026 case N_INDR:
3027 /* Ignore local indirect symbol. */
3028 ++p;
3029 ++sym_hash;
3030 continue;
252b5132 3031
116c20d2
NC		 3032 case N_UNDF | N_EXT:
3033 if (value == 0)
f7c33884 3034 {
116c20d2
NC		 3035 section = bfd_und_section_ptr;
3036 flags = 0;
252b5132
RH		 3037 }
3038 else
3039 section = bfd_com_section_ptr;
3040 break;
3041 case N_ABS | N_EXT:
3042 section = bfd_abs_section_ptr;
3043 break;
3044 case N_TEXT | N_EXT:
3045 section = obj_textsec (abfd);
3046 value -= bfd_get_section_vma (abfd, section);
3047 break;
3048 case N_DATA | N_EXT:
3049 case N_SETV | N_EXT:
3050 /* Treat N_SETV symbols as N_DATA symbol; see comment in
3051 translate_from_native_sym_flags. */
3052 section = obj_datasec (abfd);
3053 value -= bfd_get_section_vma (abfd, section);
3054 break;
3055 case N_BSS | N_EXT:
3056 section = obj_bsssec (abfd);
3057 value -= bfd_get_section_vma (abfd, section);
3058 break;
3059 case N_INDR | N_EXT:
3060 /* An indirect symbol. The next symbol is the symbol
3061 which this one really is. */
3062 BFD_ASSERT (p + 1 < pend);
3063 ++p;
3064 string = strings + GET_WORD (abfd, p->e_strx);
3065 section = bfd_ind_section_ptr;
3066 flags |= BSF_INDIRECT;
3067 break;
3068 case N_COMM | N_EXT:
3069 section = bfd_com_section_ptr;
3070 break;
3071 case N_SETA: case N_SETA | N_EXT:
3072 section = bfd_abs_section_ptr;
3073 flags |= BSF_CONSTRUCTOR;
3074 break;
3075 case N_SETT: case N_SETT | N_EXT:
3076 section = obj_textsec (abfd);
3077 flags |= BSF_CONSTRUCTOR;
3078 value -= bfd_get_section_vma (abfd, section);
3079 break;
3080 case N_SETD: case N_SETD | N_EXT:
3081 section = obj_datasec (abfd);
3082 flags |= BSF_CONSTRUCTOR;
3083 value -= bfd_get_section_vma (abfd, section);
3084 break;
3085 case N_SETB: case N_SETB | N_EXT:
3086 section = obj_bsssec (abfd);
3087 flags |= BSF_CONSTRUCTOR;
3088 value -= bfd_get_section_vma (abfd, section);
3089 break;
3090 case N_WARNING:
3091 /* A warning symbol. The next symbol is the one to warn
9f400ee9
HPN		 3092 about. If there is no next symbol, just look away. */
3093 if (p + 1 >= pend)
3094 return TRUE;
252b5132
RH		 3095 ++p;
3096 string = name;
3097 name = strings + GET_WORD (abfd, p->e_strx);
3098 section = bfd_und_section_ptr;
3099 flags |= BSF_WARNING;
3100 break;
3101 case N_WEAKU:
3102 section = bfd_und_section_ptr;
3103 flags = BSF_WEAK;
3104 break;
3105 case N_WEAKA:
3106 section = bfd_abs_section_ptr;
3107 flags = BSF_WEAK;
3108 break;
3109 case N_WEAKT:
3110 section = obj_textsec (abfd);
3111 value -= bfd_get_section_vma (abfd, section);
3112 flags = BSF_WEAK;
3113 break;
3114 case N_WEAKD:
3115 section = obj_datasec (abfd);
3116 value -= bfd_get_section_vma (abfd, section);
3117 flags = BSF_WEAK;
3118 break;
3119 case N_WEAKB:
3120 section = obj_bsssec (abfd);
3121 value -= bfd_get_section_vma (abfd, section);
3122 flags = BSF_WEAK;
3123 break;
3124 }
3125
3126 if (! ((*add_one_symbol)
b34976b6 3127 (info, abfd, name, flags, section, value, string, copy, FALSE,
252b5132 3128 (struct bfd_link_hash_entry **) sym_hash)))
b34976b6 3129 return FALSE;
252b5132
RH		 3130
3131 /* Restrict the maximum alignment of a common symbol based on
3132 the architecture, since a.out has no way to represent
3133 alignment requirements of a section in a .o file. FIXME:
3134 This isn't quite right: it should use the architecture of the
3135 output file, not the input files. */
3136 if ((*sym_hash)->root.type == bfd_link_hash_common
3137 && ((*sym_hash)->root.u.c.p->alignment_power >
3138 bfd_get_arch_info (abfd)->section_align_power))
3139 (*sym_hash)->root.u.c.p->alignment_power =
3140 bfd_get_arch_info (abfd)->section_align_power;
3141
3142 /* If this is a set symbol, and we are not building sets, then
3143 it is possible for the hash entry to not have been set. In
3144 such a case, treat the symbol as not globally defined. */
3145 if ((*sym_hash)->root.type == bfd_link_hash_new)
3146 {
3147 BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
3148 *sym_hash = NULL;
3149 }
3150
3151 if (type == (N_INDR | N_EXT) || type == N_WARNING)
3152 ++sym_hash;
3153 }
3154
b34976b6 3155 return TRUE;
252b5132 3156}
252b5132 3157
116c20d2
NC		 3158/* Free up the internal symbols read from an a.out file. */
3159
3160static bfd_boolean
3161aout_link_free_symbols (bfd *abfd)
252b5132 3162{
116c20d2
NC		 3163 if (obj_aout_external_syms (abfd) != NULL)
3164 {
3165#ifdef USE_MMAP
3166 bfd_free_window (&obj_aout_sym_window (abfd));
3167#else
3168 free ((void *) obj_aout_external_syms (abfd));
3169#endif
3170 obj_aout_external_syms (abfd) = NULL;
3171 }
3172 if (obj_aout_external_strings (abfd) != NULL)
3173 {
3174#ifdef USE_MMAP
3175 bfd_free_window (&obj_aout_string_window (abfd));
3176#else
3177 free ((void *) obj_aout_external_strings (abfd));
3178#endif
3179 obj_aout_external_strings (abfd) = NULL;
3180 }
3181 return TRUE;
3182}
252b5132 3183
116c20d2 3184/* Add symbols from an a.out object file. */
252b5132 3185
116c20d2
NC		 3186static bfd_boolean
3187aout_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
252b5132 3188{
116c20d2
NC		 3189 if (! aout_get_external_symbols (abfd))
3190 return FALSE;
3191 if (! aout_link_add_symbols (abfd, info))
3192 return FALSE;
3193 if (! info->keep_memory)
3194 {
3195 if (! aout_link_free_symbols (abfd))
3196 return FALSE;
3197 }
3198 return TRUE;
3199}
252b5132 3200
116c20d2
NC		 3201/* Look through the internal symbols to see if this object file should
3202 be included in the link. We should include this object file if it
3203 defines any symbols which are currently undefined. If this object
3204 file defines a common symbol, then we may adjust the size of the
3205 known symbol but we do not include the object file in the link
3206 (unless there is some other reason to include it). */
252b5132 3207
116c20d2
NC		 3208static bfd_boolean
3209aout_link_check_ar_symbols (bfd *abfd,
3210 struct bfd_link_info *info,
5d3236ee
DK		 3211 bfd_boolean *pneeded,
3212 bfd **subsbfd)
252b5132 3213{
116c20d2
NC		 3214 struct external_nlist *p;
3215 struct external_nlist *pend;
3216 char *strings;
252b5132 3217
116c20d2 3218 *pneeded = FALSE;
252b5132 3219
116c20d2
NC		 3220 /* Look through all the symbols. */
3221 p = obj_aout_external_syms (abfd);
3222 pend = p + obj_aout_external_sym_count (abfd);
3223 strings = obj_aout_external_strings (abfd);
3224 for (; p < pend; p++)
3225 {
3226 int type = H_GET_8 (abfd, p->e_type);
3227 const char *name;
3228 struct bfd_link_hash_entry *h;
252b5132 3229
116c20d2
NC		 3230 /* Ignore symbols that are not externally visible. This is an
3231 optimization only, as we check the type more thoroughly
3232 below. */
3233 if (((type & N_EXT) == 0
3234 || (type & N_STAB) != 0
3235 || type == N_FN)
3236 && type != N_WEAKA
3237 && type != N_WEAKT
3238 && type != N_WEAKD
3239 && type != N_WEAKB)
3240 {
3241 if (type == N_WARNING
3242 || type == N_INDR)
3243 ++p;
3244 continue;
3245 }
3246
3247 name = strings + GET_WORD (abfd, p->e_strx);
3248 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
3249
3250 /* We are only interested in symbols that are currently
3251 undefined or common. */
3252 if (h == NULL
3253 || (h->type != bfd_link_hash_undefined
3254 && h->type != bfd_link_hash_common))
3255 {
3256 if (type == (N_INDR | N_EXT))
3257 ++p;
3258 continue;
3259 }
3260
3261 if (type == (N_TEXT | N_EXT)
3262 || type == (N_DATA | N_EXT)
3263 || type == (N_BSS | N_EXT)
3264 || type == (N_ABS | N_EXT)
3265 || type == (N_INDR | N_EXT))
3266 {
3267 /* This object file defines this symbol. We must link it
3268 in. This is true regardless of whether the current
3269 definition of the symbol is undefined or common.
3270
3271 If the current definition is common, we have a case in
3272 which we have already seen an object file including:
3273 int a;
3274 and this object file from the archive includes:
3275 int a = 5;
3276 In such a case, whether to include this object is target
3277 dependant for backward compatibility.
3278
3279 FIXME: The SunOS 4.1.3 linker will pull in the archive
3280 element if the symbol is defined in the .data section,
3281 but not if it is defined in the .text section. That
3282 seems a bit crazy to me, and it has not been implemented
3283 yet. However, it might be correct. */
3284 if (h->type == bfd_link_hash_common)
3285 {
3286 int skip = 0;
3287
f88dc410 3288 switch (info->common_skip_ar_symbols)
116c20d2
NC		 3289 {
3290 case bfd_link_common_skip_text:
3291 skip = (type == (N_TEXT | N_EXT));
3292 break;
3293 case bfd_link_common_skip_data:
3294 skip = (type == (N_DATA | N_EXT));
3295 break;
3296 default:
3297 case bfd_link_common_skip_all:
3298 skip = 1;
3299 break;
3300 }
3301
3302 if (skip)
3303 continue;
3304 }
3305
0e144ba7
AM		 3306 if (!(*info->callbacks
3307 ->add_archive_element) (info, abfd, name, subsbfd))
116c20d2
NC		 3308 return FALSE;
3309 *pneeded = TRUE;
3310 return TRUE;
3311 }
3312
3313 if (type == (N_UNDF | N_EXT))
3314 {
3315 bfd_vma value;
3316
3317 value = GET_WORD (abfd, p->e_value);
3318 if (value != 0)
3319 {
3320 /* This symbol is common in the object from the archive
3321 file. */
3322 if (h->type == bfd_link_hash_undefined)
3323 {
3324 bfd *symbfd;
3325 unsigned int power;
3326
3327 symbfd = h->u.undef.abfd;
3328 if (symbfd == NULL)
3329 {
3330 /* This symbol was created as undefined from
3331 outside BFD. We assume that we should link
3332 in the object file. This is done for the -u
3333 option in the linker. */
0e144ba7
AM		 3334 if (!(*info->callbacks
3335 ->add_archive_element) (info, abfd, name, subsbfd))
116c20d2
NC		 3336 return FALSE;
3337 *pneeded = TRUE;
3338 return TRUE;
3339 }
3340 /* Turn the current link symbol into a common
3341 symbol. It is already on the undefs list. */
3342 h->type = bfd_link_hash_common;
a50b1753 3343 h->u.c.p = (struct bfd_link_hash_common_entry *)
0e144ba7
AM		 3344 bfd_hash_allocate (&info->hash->table,
3345 sizeof (struct bfd_link_hash_common_entry));
116c20d2
NC		 3346 if (h->u.c.p == NULL)
3347 return FALSE;
3348
3349 h->u.c.size = value;
3350
3351 /* FIXME: This isn't quite right. The maximum
3352 alignment of a common symbol should be set by the
3353 architecture of the output file, not of the input
3354 file. */
3355 power = bfd_log2 (value);
3356 if (power > bfd_get_arch_info (abfd)->section_align_power)
3357 power = bfd_get_arch_info (abfd)->section_align_power;
3358 h->u.c.p->alignment_power = power;
3359
3360 h->u.c.p->section = bfd_make_section_old_way (symbfd,
3361 "COMMON");
3362 }
3363 else
3364 {
3365 /* Adjust the size of the common symbol if
3366 necessary. */
3367 if (value > h->u.c.size)
3368 h->u.c.size = value;
3369 }
3370 }
3371 }
3372
3373 if (type == N_WEAKA
3374 || type == N_WEAKT
3375 || type == N_WEAKD
3376 || type == N_WEAKB)
3377 {
3378 /* This symbol is weak but defined. We must pull it in if
3379 the current link symbol is undefined, but we don't want
3380 it if the current link symbol is common. */
3381 if (h->type == bfd_link_hash_undefined)
3382 {
0e144ba7
AM		 3383 if (!(*info->callbacks
3384 ->add_archive_element) (info, abfd, name, subsbfd))
116c20d2
NC		 3385 return FALSE;
3386 *pneeded = TRUE;
3387 return TRUE;
3388 }
3389 }
3390 }
3391
3392 /* We do not need this object file. */
3393 return TRUE;
3394}
3395/* Check a single archive element to see if we need to include it in
3396 the link. *PNEEDED is set according to whether this element is
3397 needed in the link or not. This is called from
3398 _bfd_generic_link_add_archive_symbols. */
3399
3400static bfd_boolean
3401aout_link_check_archive_element (bfd *abfd,
3402 struct bfd_link_info *info,
3403 bfd_boolean *pneeded)
3404{
0e144ba7
AM		 3405 bfd *oldbfd;
3406 bfd_boolean needed;
5d3236ee 3407
0e144ba7 3408 if (!aout_get_external_symbols (abfd))
116c20d2
NC		 3409 return FALSE;
3410
0e144ba7
AM		 3411 oldbfd = abfd;
3412 if (!aout_link_check_ar_symbols (abfd, info, pneeded, &abfd))
116c20d2
NC		 3413 return FALSE;
3414
0e144ba7
AM		 3415 needed = *pneeded;
3416 if (needed)
116c20d2 3417 {
5d3236ee
DK		 3418 /* Potentially, the add_archive_element hook may have set a
3419 substitute BFD for us. */
0e144ba7
AM		 3420 if (abfd != oldbfd)
3421 {
3422 if (!info->keep_memory
3423 && !aout_link_free_symbols (oldbfd))
3424 return FALSE;
3425 if (!aout_get_external_symbols (abfd))
3426 return FALSE;
3427 }
3428 if (!aout_link_add_symbols (abfd, info))
116c20d2
NC		 3429 return FALSE;
3430 }
3431
0e144ba7 3432 if (!info->keep_memory || !needed)
116c20d2 3433 {
0e144ba7 3434 if (!aout_link_free_symbols (abfd))
116c20d2
NC		 3435 return FALSE;
3436 }
3437
3438 return TRUE;
3439}
3440
3441/* Given an a.out BFD, add symbols to the global hash table as
3442 appropriate. */
3443
3444bfd_boolean
3445NAME (aout, link_add_symbols) (bfd *abfd, struct bfd_link_info *info)
3446{
3447 switch (bfd_get_format (abfd))
3448 {
3449 case bfd_object:
3450 return aout_link_add_object_symbols (abfd, info);
3451 case bfd_archive:
3452 return _bfd_generic_link_add_archive_symbols
3453 (abfd, info, aout_link_check_archive_element);
3454 default:
3455 bfd_set_error (bfd_error_wrong_format);
3456 return FALSE;
3457 }
3458}
3459\f
3460/* A hash table used for header files with N_BINCL entries. */
3461
3462struct aout_link_includes_table
3463{
3464 struct bfd_hash_table root;
3465};
3466
3467/* A linked list of totals that we have found for a particular header
3468 file. */
3469
3470struct aout_link_includes_totals
3471{
3472 struct aout_link_includes_totals *next;
3473 bfd_vma total;
3474};
3475
3476/* An entry in the header file hash table. */
3477
3478struct aout_link_includes_entry
3479{
3480 struct bfd_hash_entry root;
3481 /* List of totals we have found for this file. */
3482 struct aout_link_includes_totals *totals;
3483};
3484
3485/* Look up an entry in an the header file hash table. */
3486
3487#define aout_link_includes_lookup(table, string, create, copy) \
3488 ((struct aout_link_includes_entry *) \
3489 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3490
3491/* During the final link step we need to pass around a bunch of
3492 information, so we do it in an instance of this structure. */
3493
3494struct aout_final_link_info
3495{
3496 /* General link information. */
3497 struct bfd_link_info *info;
3498 /* Output bfd. */
252b5132
RH		 3499 bfd *output_bfd;
3500 /* Reloc file positions. */
3501 file_ptr treloff, dreloff;
3502 /* File position of symbols. */
3503 file_ptr symoff;
3504 /* String table. */
3505 struct bfd_strtab_hash *strtab;
3506 /* Header file hash table. */
3507 struct aout_link_includes_table includes;
3508 /* A buffer large enough to hold the contents of any section. */
3509 bfd_byte *contents;
3510 /* A buffer large enough to hold the relocs of any section. */
116c20d2 3511 void * relocs;
252b5132
RH		 3512 /* A buffer large enough to hold the symbol map of any input BFD. */
3513 int *symbol_map;
3514 /* A buffer large enough to hold output symbols of any input BFD. */
3515 struct external_nlist *output_syms;
3516};
3517
252b5132
RH		 3518/* The function to create a new entry in the header file hash table. */
3519
3520static struct bfd_hash_entry *
116c20d2
NC		 3521aout_link_includes_newfunc (struct bfd_hash_entry *entry,
3522 struct bfd_hash_table *table,
3523 const char *string)
252b5132
RH		 3524{
3525 struct aout_link_includes_entry *ret =
3526 (struct aout_link_includes_entry *) entry;
3527
3528 /* Allocate the structure if it has not already been allocated by a
3529 subclass. */
116c20d2 3530 if (ret == NULL)
a50b1753
NC		 3531 ret = (struct aout_link_includes_entry *)
3532 bfd_hash_allocate (table, sizeof (* ret));
116c20d2
NC		 3533 if (ret == NULL)
3534 return NULL;
252b5132
RH		 3535
3536 /* Call the allocation method of the superclass. */
3537 ret = ((struct aout_link_includes_entry *)
3538 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
3539 if (ret)
3540 {
3541 /* Set local fields. */
3542 ret->totals = NULL;
3543 }
3544
3545 return (struct bfd_hash_entry *) ret;
3546}
3547
116c20d2
NC		 3548/* Write out a symbol that was not associated with an a.out input
3549 object. */
252b5132 3550
116c20d2 3551static bfd_boolean
7686d77d 3552aout_link_write_other_symbol (struct bfd_hash_entry *bh, void *data)
252b5132 3553{
7686d77d 3554 struct aout_link_hash_entry *h = (struct aout_link_hash_entry *) bh;
57402f1e 3555 struct aout_final_link_info *flaginfo = (struct aout_final_link_info *) data;
116c20d2
NC		 3556 bfd *output_bfd;
3557 int type;
3558 bfd_vma val;
3559 struct external_nlist outsym;
3560 bfd_size_type indx;
3561 bfd_size_type amt;
252b5132 3562
116c20d2
NC		 3563 if (h->root.type == bfd_link_hash_warning)
3564 {
3565 h = (struct aout_link_hash_entry *) h->root.u.i.link;
3566 if (h->root.type == bfd_link_hash_new)
3567 return TRUE;
3568 }
252b5132 3569
57402f1e 3570 output_bfd = flaginfo->output_bfd;
252b5132 3571
116c20d2 3572 if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
252b5132 3573 {
116c20d2 3574 if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
57402f1e 3575 (output_bfd, flaginfo->info, h)))
252b5132 3576 {
116c20d2
NC		 3577 /* FIXME: No way to handle errors. */
3578 abort ();
252b5132 3579 }
116c20d2 3580 }
252b5132 3581
116c20d2
NC		 3582 if (h->written)
3583 return TRUE;
252b5132 3584
116c20d2 3585 h->written = TRUE;
252b5132 3586
116c20d2
NC		 3587 /* An indx of -2 means the symbol must be written. */
3588 if (h->indx != -2
57402f1e
NC		 3589 && (flaginfo->info->strip == strip_all
3590 || (flaginfo->info->strip == strip_some
3591 && bfd_hash_lookup (flaginfo->info->keep_hash, h->root.root.string,
116c20d2
NC		 3592 FALSE, FALSE) == NULL)))
3593 return TRUE;
252b5132 3594
116c20d2 3595 switch (h->root.type)
252b5132 3596 {
116c20d2
NC		 3597 default:
3598 case bfd_link_hash_warning:
3599 abort ();
3600 /* Avoid variable not initialized warnings. */
3601 return TRUE;
3602 case bfd_link_hash_new:
3603 /* This can happen for set symbols when sets are not being
3604 built. */
3605 return TRUE;
3606 case bfd_link_hash_undefined:
3607 type = N_UNDF | N_EXT;
3608 val = 0;
3609 break;
3610 case bfd_link_hash_defined:
3611 case bfd_link_hash_defweak:
3612 {
3613 asection *sec;
252b5132 3614
116c20d2
NC		 3615 sec = h->root.u.def.section->output_section;
3616 BFD_ASSERT (bfd_is_abs_section (sec)
3617 || sec->owner == output_bfd);
3618 if (sec == obj_textsec (output_bfd))
3619 type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
3620 else if (sec == obj_datasec (output_bfd))
3621 type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
3622 else if (sec == obj_bsssec (output_bfd))
3623 type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
3624 else
3625 type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
3626 type |= N_EXT;
3627 val = (h->root.u.def.value
3628 + sec->vma
3629 + h->root.u.def.section->output_offset);
3630 }
3631 break;
3632 case bfd_link_hash_common:
3633 type = N_UNDF | N_EXT;
3634 val = h->root.u.c.size;
3635 break;
3636 case bfd_link_hash_undefweak:
3637 type = N_WEAKU;
3638 val = 0;
c38eb2a6 3639 break;
116c20d2
NC		 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);
57402f1e 3649 indx = add_to_stringtab (output_bfd, flaginfo->strtab, h->root.root.string,
116c20d2
NC		 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 3658 amt = EXTERNAL_NLIST_SIZE;
57402f1e 3659 if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0
116c20d2
NC		 3660 || bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt)
3661 /* FIXME: No way to handle errors. */
3662 abort ();
252b5132 3663
57402f1e 3664 flaginfo->symoff += EXTERNAL_NLIST_SIZE;
116c20d2
NC		 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 3673static bfd_boolean
57402f1e 3674aout_link_reloc_link_order (struct aout_final_link_info *flaginfo,
116c20d2
NC		 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 {
57402f1e 3697 BFD_ASSERT (pr->u.section->owner == flaginfo->output_bfd);
116c20d2
NC		 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 *)
57402f1e 3708 bfd_wrapped_link_hash_lookup (flaginfo->output_bfd, flaginfo->info,
116c20d2
NC		 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;
57402f1e 3721 if (!aout_link_write_other_symbol (&h->root.root, flaginfo))
116c20d2
NC		 3722 return FALSE;
3723 r_index = h->indx;
3724 }
3725 else
3726 {
57402f1e
NC		 3727 if (! ((*flaginfo->info->callbacks->unattached_reloc)
3728 (flaginfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0)))
116c20d2
NC		 3729 return FALSE;
3730 r_index = 0;
3731 }
3732 }
252b5132 3733
57402f1e 3734 howto = bfd_reloc_type_lookup (flaginfo->output_bfd, pr->reloc);
116c20d2 3735 if (howto == 0)
252b5132 3736 {
116c20d2
NC		 3737 bfd_set_error (bfd_error_bad_value);
3738 return FALSE;
252b5132
RH		 3739 }
3740
57402f1e
NC		 3741 if (o == obj_textsec (flaginfo->output_bfd))
3742 reloff_ptr = &flaginfo->treloff;
3743 else if (o == obj_datasec (flaginfo->output_bfd))
3744 reloff_ptr = &flaginfo->dreloff;
116c20d2
NC		 3745 else
3746 abort ();
3747
57402f1e 3748 if (obj_reloc_entry_size (flaginfo->output_bfd) == RELOC_STD_SIZE)
252b5132 3749 {
116c20d2 3750#ifdef MY_put_reloc
57402f1e 3751 MY_put_reloc (flaginfo->output_bfd, r_extern, r_index, p->offset, howto,
116c20d2
NC		 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
57402f1e
NC		 3767 PUT_WORD (flaginfo->output_bfd, p->offset, srel.r_address);
3768 if (bfd_header_big_endian (flaginfo->output_bfd))
116c20d2
NC		 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;
57402f1e 3814 r = MY_relocate_contents (howto, flaginfo->output_bfd,
116c20d2
NC		 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:
57402f1e
NC		 3824 if (! ((*flaginfo->info->callbacks->reloc_overflow)
3825 (flaginfo->info, NULL,
116c20d2 3826 (p->type == bfd_section_reloc_link_order
57402f1e 3827 ? bfd_section_name (flaginfo->output_bfd,
116c20d2
NC		 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 }
57402f1e 3837 ok = bfd_set_section_contents (flaginfo->output_bfd, o, (void *) buf,
116c20d2
NC		 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 3846#ifdef MY_put_ext_reloc
57402f1e 3847 MY_put_ext_reloc (flaginfo->output_bfd, r_extern, r_index, p->offset,
116c20d2
NC		 3848 howto, &erel, pr->addend);
3849#else
57402f1e 3850 PUT_WORD (flaginfo->output_bfd, p->offset, erel.r_address);
252b5132 3851
57402f1e 3852 if (bfd_header_big_endian (flaginfo->output_bfd))
116c20d2
NC		 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
57402f1e 3871 PUT_WORD (flaginfo->output_bfd, (bfd_vma) pr->addend, erel.r_addend);
116c20d2 3872#endif /* MY_put_ext_reloc */
252b5132 3873
116c20d2 3874 rel_ptr = (void *) &erel;
252b5132 3875 }
252b5132 3876
57402f1e
NC		 3877 amt = obj_reloc_entry_size (flaginfo->output_bfd);
3878 if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
3879 || bfd_bwrite (rel_ptr, amt, flaginfo->output_bfd) != amt)
116c20d2 3880 return FALSE;
252b5132 3881
57402f1e 3882 *reloff_ptr += obj_reloc_entry_size (flaginfo->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. */
57402f1e
NC		 3886 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd)
3887 && (reloff_ptr != &flaginfo->treloff
116c20d2 3888 || (*reloff_ptr
57402f1e 3889 <= obj_datasec (flaginfo->output_bfd)->rel_filepos)));
116c20d2
NC		 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
57402f1e 3914aout_link_input_section_std (struct aout_final_link_info *flaginfo,
116c20d2
NC		 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 3934
57402f1e 3935 output_bfd = flaginfo->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
57402f1e 3942 relocatable = flaginfo->info->relocatable;
116c20d2
NC		 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);
57402f1e 3946 symbol_map = flaginfo->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 {
57402f1e 4015 (*flaginfo->info->callbacks->einfo)
ad756e3f
AM		 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;
7686d77d 4079 if (!aout_link_write_other_symbol (&h->root.root,
57402f1e 4080 flaginfo))
116c20d2 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);
57402f1e
NC		 4091 if (! ((*flaginfo->info->callbacks->unattached_reloc)
4092 (flaginfo->info, name, input_bfd, input_section,
116c20d2
NC		 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 4197 if (! ((*check_dynamic_reloc)
57402f1e 4198 (flaginfo->info, input_bfd, input_section, h,
116c20d2
NC		 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. */
57402f1e 4208 if (hundef && ! flaginfo->info->shared && ! r_baserel)
116c20d2
NC		 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);
57402f1e
NC		 4216 if (! ((*flaginfo->info->callbacks->undefined_symbol)
4217 (flaginfo->info, name, input_bfd, input_section,
116c20d2
NC		 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 }
57402f1e
NC		 4251 if (! ((*flaginfo->info->callbacks->reloc_overflow)
4252 (flaginfo->info, (h ? &h->root : NULL), name,
116c20d2
NC		 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
57402f1e 4268aout_link_input_section_ext (struct aout_final_link_info *flaginfo,
116c20d2
NC		 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 4288
57402f1e 4289 output_bfd = flaginfo->output_bfd;
252b5132
RH		 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
57402f1e 4296 relocatable = flaginfo->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);
57402f1e 4300 symbol_map = flaginfo->symbol_map;
252b5132 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 {
57402f1e 4341 (*flaginfo->info->callbacks->einfo)
ad756e3f
AM		 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;
7686d77d 4421 if (!aout_link_write_other_symbol (&h->root.root,
57402f1e 4422 flaginfo))
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);
57402f1e
NC		 4433 if (! ((*flaginfo->info->callbacks->unattached_reloc)
4434 (flaginfo->info, name, input_bfd, input_section,
252b5132 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)
57402f1e 4601 (flaginfo->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 4611 if (hundef
57402f1e 4612 && ! flaginfo->info->shared
116c20d2
NC		 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);
57402f1e
NC		 4623 if (! ((*flaginfo->info->callbacks->undefined_symbol)
4624 (flaginfo->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 }
57402f1e
NC		 4670 if (! ((*flaginfo->info->callbacks->reloc_overflow)
4671 (flaginfo->info, (h ? &h->root : NULL), name,
116c20d2
NC		 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
57402f1e 4688aout_link_input_section (struct aout_final_link_info *flaginfo,
116c20d2
NC		 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,
57402f1e 4700 (void *) flaginfo->contents,
116c20d2
NC		 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 {
57402f1e 4710 relocs = flaginfo->relocs;
116c20d2
NC		 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 {
57402f1e 4722 if (! aout_link_input_section_std (flaginfo, input_bfd, input_section,
116c20d2 4723 (struct reloc_std_external *) relocs,
57402f1e 4724 rel_size, flaginfo->contents))
116c20d2
NC		 4725 return FALSE;
4726 }
4727 else
4728 {
57402f1e 4729 if (! aout_link_input_section_ext (flaginfo, input_bfd, input_section,
116c20d2 4730 (struct reloc_ext_external *) relocs,
57402f1e 4731 rel_size, flaginfo->contents))
116c20d2
NC		 4732 return FALSE;
4733 }
4734
4735 /* Write out the section contents. */
57402f1e 4736 if (! bfd_set_section_contents (flaginfo->output_bfd,
116c20d2 4737 input_section->output_section,
57402f1e 4738 (void *) flaginfo->contents,
116c20d2
NC		 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. */
57402f1e 4745 if (flaginfo->info->relocatable && rel_size > 0)
116c20d2 4746 {
57402f1e 4747 if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
116c20d2 4748 return FALSE;
57402f1e 4749 if (bfd_bwrite (relocs, rel_size, flaginfo->output_bfd) != rel_size)
116c20d2
NC		 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. */
57402f1e
NC		 4756 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd)
4757 && (reloff_ptr != &flaginfo->treloff
116c20d2 4758 || (*reloff_ptr
57402f1e 4759 <= obj_datasec (flaginfo->output_bfd)->rel_filepos)));
116c20d2
NC		 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
57402f1e 4769aout_link_write_symbols (struct aout_final_link_info *flaginfo, 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 4784
57402f1e 4785 output_bfd = flaginfo->output_bfd;
116c20d2
NC		 4786 sym_count = obj_aout_external_sym_count (input_bfd);
4787 strings = obj_aout_external_strings (input_bfd);
57402f1e
NC		 4788 strip = flaginfo->info->strip;
4789 discard = flaginfo->info->discard;
4790 outsym = flaginfo->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
57402f1e 4796 || bfd_hash_lookup (flaginfo->info->keep_hash, input_bfd->filename,
116c20d2
NC		 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);
57402f1e 4803 strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
116c20d2
NC		 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);
57402f1e 4822 symbol_map = flaginfo->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:
57402f1e 4921 if (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE, FALSE)
116c20d2
NC		 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. */
57402f1e
NC		 5149 copy = (bfd_boolean) (! flaginfo->info->keep_memory);
5150 incl_entry = aout_link_includes_lookup (&flaginfo->includes,
116c20d2
NC		 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 5161 t = (struct aout_link_includes_totals *)
57402f1e 5162 bfd_hash_allocate (&flaginfo->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;
57402f1e 5211 if (! flaginfo->info->keep_memory)
116c20d2
NC		 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 }
57402f1e 5221 strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
116c20d2
NC		 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 5232 /* Write out the output symbols we have just constructed. */
57402f1e 5233 if (outsym > flaginfo->output_syms)
116c20d2
NC		 5234 {
5235 bfd_size_type outsym_size;
252b5132 5236
57402f1e 5237 if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0)
116c20d2 5238 return FALSE;
57402f1e 5239 outsym_size = outsym - flaginfo->output_syms;
116c20d2 5240 outsym_size *= EXTERNAL_NLIST_SIZE;
57402f1e 5241 if (bfd_bwrite ((void *) flaginfo->output_syms, outsym_size, output_bfd)
116c20d2
NC		 5242 != outsym_size)
5243 return FALSE;
57402f1e 5244 flaginfo->symoff += outsym_size;
116c20d2 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 5252static bfd_boolean
57402f1e 5253aout_link_input_bfd (struct aout_final_link_info *flaginfo, bfd *input_bfd)
116c20d2 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)
57402f1e 5261 (flaginfo->info, input_bfd));
252b5132 5262
116c20d2 5263 /* Get the symbols. We probably have them already, unless
57402f1e 5264 flaginfo->info->keep_memory is FALSE. */
116c20d2
NC		 5265 if (! aout_get_external_symbols (input_bfd))
5266 return FALSE;
252b5132 5267
116c20d2 5268 /* Write out the symbols and get a map of the new indices. The map
57402f1e
NC		 5269 is placed into flaginfo->symbol_map. */
5270 if (! aout_link_write_symbols (flaginfo, input_bfd))
116c20d2 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 {
57402f1e 5279 if (! aout_link_input_section (flaginfo, input_bfd,
116c20d2 5280 obj_textsec (input_bfd),
57402f1e 5281 &flaginfo->treloff,
116c20d2
NC		 5282 exec_hdr (input_bfd)->a_trsize))
5283 return FALSE;
5284 }
5285 if (obj_datasec (input_bfd)->linker_mark)
5286 {
57402f1e 5287 if (! aout_link_input_section (flaginfo, input_bfd,
116c20d2 5288 obj_datasec (input_bfd),
57402f1e 5289 &flaginfo->dreloff,
116c20d2
NC		 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. */
57402f1e 5297 if (! flaginfo->info->keep_memory)
116c20d2
NC		 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);
c38eb2a6 5451 aout_info.symbol_map = (int *) bfd_malloc (max_sym_count * sizeof (int));
a50b1753
NC		 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)
7686d77d 5470 aout_link_write_other_symbol (&h->root.root, &aout_info);
116c20d2
NC		 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 5543 /* Write out any symbols that we have not already written out. */
7686d77d
AM		 5544 bfd_hash_traverse (&info->hash->table,
5545 aout_link_write_other_symbol,
5546 &aout_info);
116c20d2
NC		 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}
GDB Binutils - Deliverables
This page took 1.432494 seconds and 4 git commands to generate.