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