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