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