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