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