1 /* BFD semi-generic back-end for a.out binaries.
2 Copyright (C) 1990-2014 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 BFD supports a number of different flavours of a.out format,
29 though the major differences are only the sizes of the
30 structures on disk, and the shape of the relocation
33 The support is split into a basic support file @file{aoutx.h}
34 and other files which derive functions from the base. One
35 derivation file is @file{aoutf1.h} (for a.out flavour 1), and
36 adds to the basic a.out functions support for sun3, sun4, 386
37 and 29k a.out files, to create a target jump vector for a
40 This information is further split out into more specific files
41 for each machine, including @file{sunos.c} for sun3 and sun4,
42 @file{newsos3.c} for the Sony NEWS, and @file{demo64.c} for a
43 demonstration of a 64 bit a.out format.
45 The base file @file{aoutx.h} defines general mechanisms for
46 reading and writing records to and from disk and various
47 other methods which BFD requires. It is included by
48 @file{aout32.c} and @file{aout64.c} to form the names
49 <<aout_32_swap_exec_header_in>>, <<aout_64_swap_exec_header_in>>, etc.
51 As an example, this is what goes on to make the back end for a
52 sun4, from @file{aout32.c}:
54 | #define ARCH_SIZE 32
60 | aout_32_canonicalize_reloc
61 | aout_32_find_nearest_line
63 | aout_32_get_reloc_upper_bound
68 | #define TARGET_NAME "a.out-sunos-big"
69 | #define VECNAME sparc_aout_sunos_be_vec
72 requires all the names from @file{aout32.c}, and produces the jump vector
74 | sparc_aout_sunos_be_vec
76 The file @file{host-aout.c} is a special case. It is for a large set
77 of hosts that use ``more or less standard'' a.out files, and
78 for which cross-debugging is not interesting. It uses the
79 standard 32-bit a.out support routines, but determines the
80 file offsets and addresses of the text, data, and BSS
81 sections, the machine architecture and machine type, and the
82 entry point address, in a host-dependent manner. Once these
83 values have been determined, generic code is used to handle
86 When porting it to run on a new system, you must supply:
90 | HOST_MACHINE_ARCH (optional)
91 | HOST_MACHINE_MACHINE (optional)
92 | HOST_TEXT_START_ADDR
95 in the file @file{../include/sys/h-@var{XXX}.h} (for your host). These
96 values, plus the structures and macros defined in @file{a.out.h} on
97 your host system, will produce a BFD target that will access
98 ordinary a.out files on your host. To configure a new machine
99 to use @file{host-aout.c}, specify:
101 | TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec
102 | TDEPFILES= host-aout.o trad-core.o
104 in the @file{config/@var{XXX}.mt} file, and modify @file{configure.ac}
106 @file{@var{XXX}.mt} file (by setting "<<bfd_target=XXX>>") when your
107 configuration is selected. */
110 * Any BFD with D_PAGED set is ZMAGIC, and vice versa.
111 Doesn't matter what the setting of WP_TEXT is on output, but it'll
113 * Any BFD with D_PAGED clear and WP_TEXT set is NMAGIC.
114 * Any BFD with both flags clear is OMAGIC.
115 (Just want to make these explicit, so the conditions tested in this
116 file make sense if you're more familiar with a.out than with BFD.) */
118 #define KEEPIT udata.i
122 #include "safe-ctype.h"
127 #include "aout/aout64.h"
128 #include "aout/stab_gnu.h"
136 The file @file{aoutx.h} provides for both the @emph{standard}
137 and @emph{extended} forms of a.out relocation records.
139 The standard records contain only an
140 address, a symbol index, and a type field. The extended records
141 (used on 29ks and sparcs) also have a full integer for an
144 #ifndef CTOR_TABLE_RELOC_HOWTO
145 #define CTOR_TABLE_RELOC_IDX 2
146 #define CTOR_TABLE_RELOC_HOWTO(BFD) \
147 ((obj_reloc_entry_size (BFD) == RELOC_EXT_SIZE \
148 ? howto_table_ext : howto_table_std) \
149 + CTOR_TABLE_RELOC_IDX)
152 #ifndef MY_swap_std_reloc_in
153 #define MY_swap_std_reloc_in NAME (aout, swap_std_reloc_in)
156 #ifndef MY_swap_ext_reloc_in
157 #define MY_swap_ext_reloc_in NAME (aout, swap_ext_reloc_in)
160 #ifndef MY_swap_std_reloc_out
161 #define MY_swap_std_reloc_out NAME (aout, swap_std_reloc_out)
164 #ifndef MY_swap_ext_reloc_out
165 #define MY_swap_ext_reloc_out NAME (aout, swap_ext_reloc_out)
168 #ifndef MY_final_link_relocate
169 #define MY_final_link_relocate _bfd_final_link_relocate
172 #ifndef MY_relocate_contents
173 #define MY_relocate_contents _bfd_relocate_contents
176 #define howto_table_ext NAME (aout, ext_howto_table)
177 #define howto_table_std NAME (aout, std_howto_table)
179 reloc_howto_type howto_table_ext
[] =
181 /* Type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone. */
182 HOWTO (RELOC_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
, 0, "8", FALSE
, 0, 0x000000ff, FALSE
),
183 HOWTO (RELOC_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
, 0, "16", FALSE
, 0, 0x0000ffff, FALSE
),
184 HOWTO (RELOC_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
, 0, "32", FALSE
, 0, 0xffffffff, FALSE
),
185 HOWTO (RELOC_DISP8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
, 0, "DISP8", FALSE
, 0, 0x000000ff, FALSE
),
186 HOWTO (RELOC_DISP16
, 0, 1, 16, TRUE
, 0, complain_overflow_signed
, 0, "DISP16", FALSE
, 0, 0x0000ffff, FALSE
),
187 HOWTO (RELOC_DISP32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
, 0, "DISP32", FALSE
, 0, 0xffffffff, FALSE
),
188 HOWTO (RELOC_WDISP30
, 2, 2, 30, TRUE
, 0, complain_overflow_signed
, 0, "WDISP30", FALSE
, 0, 0x3fffffff, FALSE
),
189 HOWTO (RELOC_WDISP22
, 2, 2, 22, TRUE
, 0, complain_overflow_signed
, 0, "WDISP22", FALSE
, 0, 0x003fffff, FALSE
),
190 HOWTO (RELOC_HI22
, 10, 2, 22, FALSE
, 0, complain_overflow_bitfield
, 0, "HI22", FALSE
, 0, 0x003fffff, FALSE
),
191 HOWTO (RELOC_22
, 0, 2, 22, FALSE
, 0, complain_overflow_bitfield
, 0, "22", FALSE
, 0, 0x003fffff, FALSE
),
192 HOWTO (RELOC_13
, 0, 2, 13, FALSE
, 0, complain_overflow_bitfield
, 0, "13", FALSE
, 0, 0x00001fff, FALSE
),
193 HOWTO (RELOC_LO10
, 0, 2, 10, FALSE
, 0, complain_overflow_dont
, 0, "LO10", FALSE
, 0, 0x000003ff, FALSE
),
194 HOWTO (RELOC_SFA_BASE
,0, 2, 32, FALSE
, 0, complain_overflow_bitfield
, 0, "SFA_BASE", FALSE
, 0, 0xffffffff, FALSE
),
195 HOWTO (RELOC_SFA_OFF13
,0, 2, 32, FALSE
, 0, complain_overflow_bitfield
, 0, "SFA_OFF13", FALSE
, 0, 0xffffffff, FALSE
),
196 HOWTO (RELOC_BASE10
, 0, 2, 10, FALSE
, 0, complain_overflow_dont
, 0, "BASE10", FALSE
, 0, 0x000003ff, FALSE
),
197 HOWTO (RELOC_BASE13
, 0, 2, 13, FALSE
, 0, complain_overflow_signed
, 0, "BASE13", FALSE
, 0, 0x00001fff, FALSE
),
198 HOWTO (RELOC_BASE22
, 10, 2, 22, FALSE
, 0, complain_overflow_bitfield
, 0, "BASE22", FALSE
, 0, 0x003fffff, FALSE
),
199 HOWTO (RELOC_PC10
, 0, 2, 10, TRUE
, 0, complain_overflow_dont
, 0, "PC10", FALSE
, 0, 0x000003ff, TRUE
),
200 HOWTO (RELOC_PC22
, 10, 2, 22, TRUE
, 0, complain_overflow_signed
, 0, "PC22", FALSE
, 0, 0x003fffff, TRUE
),
201 HOWTO (RELOC_JMP_TBL
, 2, 2, 30, TRUE
, 0, complain_overflow_signed
, 0, "JMP_TBL", FALSE
, 0, 0x3fffffff, FALSE
),
202 HOWTO (RELOC_SEGOFF16
,0, 2, 0, FALSE
, 0, complain_overflow_bitfield
, 0, "SEGOFF16", FALSE
, 0, 0x00000000, FALSE
),
203 HOWTO (RELOC_GLOB_DAT
,0, 2, 0, FALSE
, 0, complain_overflow_bitfield
, 0, "GLOB_DAT", FALSE
, 0, 0x00000000, FALSE
),
204 HOWTO (RELOC_JMP_SLOT
,0, 2, 0, FALSE
, 0, complain_overflow_bitfield
, 0, "JMP_SLOT", FALSE
, 0, 0x00000000, FALSE
),
205 HOWTO (RELOC_RELATIVE
,0, 2, 0, FALSE
, 0, complain_overflow_bitfield
, 0, "RELATIVE", FALSE
, 0, 0x00000000, FALSE
),
206 HOWTO (0, 0, 0, 0, FALSE
, 0, complain_overflow_dont
, 0, "R_SPARC_NONE",FALSE
, 0, 0x00000000, TRUE
),
207 HOWTO (0, 0, 0, 0, FALSE
, 0, complain_overflow_dont
, 0, "R_SPARC_NONE",FALSE
, 0, 0x00000000, TRUE
),
208 #define RELOC_SPARC_REV32 RELOC_WDISP19
209 HOWTO (RELOC_SPARC_REV32
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
, 0,"R_SPARC_REV32",FALSE
, 0, 0xffffffff, FALSE
),
212 /* Convert standard reloc records to "arelent" format (incl byte swap). */
214 reloc_howto_type howto_table_std
[] =
216 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone. */
217 HOWTO ( 0, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,0,"8", TRUE
, 0x000000ff,0x000000ff, FALSE
),
218 HOWTO ( 1, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,0,"16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
219 HOWTO ( 2, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,0,"32", TRUE
, 0xffffffff,0xffffffff, FALSE
),
220 HOWTO ( 3, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,0,"64", TRUE
, 0xdeaddead,0xdeaddead, FALSE
),
221 HOWTO ( 4, 0, 0, 8, TRUE
, 0, complain_overflow_signed
, 0,"DISP8", TRUE
, 0x000000ff,0x000000ff, FALSE
),
222 HOWTO ( 5, 0, 1, 16, TRUE
, 0, complain_overflow_signed
, 0,"DISP16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
223 HOWTO ( 6, 0, 2, 32, TRUE
, 0, complain_overflow_signed
, 0,"DISP32", TRUE
, 0xffffffff,0xffffffff, FALSE
),
224 HOWTO ( 7, 0, 4, 64, TRUE
, 0, complain_overflow_signed
, 0,"DISP64", TRUE
, 0xfeedface,0xfeedface, FALSE
),
225 HOWTO ( 8, 0, 2, 0, FALSE
, 0, complain_overflow_bitfield
,0,"GOT_REL", FALSE
, 0,0x00000000, FALSE
),
226 HOWTO ( 9, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,0,"BASE16", FALSE
,0xffffffff,0xffffffff, FALSE
),
227 HOWTO (10, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,0,"BASE32", FALSE
,0xffffffff,0xffffffff, FALSE
),
233 HOWTO (16, 0, 2, 0, FALSE
, 0, complain_overflow_bitfield
,0,"JMP_TABLE", FALSE
, 0,0x00000000, FALSE
),
249 HOWTO (32, 0, 2, 0, FALSE
, 0, complain_overflow_bitfield
,0,"RELATIVE", FALSE
, 0,0x00000000, FALSE
),
257 HOWTO (40, 0, 2, 0, FALSE
, 0, complain_overflow_bitfield
,0,"BASEREL", FALSE
, 0,0x00000000, FALSE
),
260 #define TABLE_SIZE(TABLE) (sizeof (TABLE) / sizeof (TABLE[0]))
263 NAME (aout
, reloc_type_lookup
) (bfd
*abfd
, bfd_reloc_code_real_type code
)
265 #define EXT(i, j) case i: return & howto_table_ext [j]
266 #define STD(i, j) case i: return & howto_table_std [j]
267 int ext
= obj_reloc_entry_size (abfd
) == RELOC_EXT_SIZE
;
269 if (code
== BFD_RELOC_CTOR
)
270 switch (bfd_arch_bits_per_address (abfd
))
283 EXT (BFD_RELOC_8
, 0);
284 EXT (BFD_RELOC_16
, 1);
285 EXT (BFD_RELOC_32
, 2);
286 EXT (BFD_RELOC_HI22
, 8);
287 EXT (BFD_RELOC_LO10
, 11);
288 EXT (BFD_RELOC_32_PCREL_S2
, 6);
289 EXT (BFD_RELOC_SPARC_WDISP22
, 7);
290 EXT (BFD_RELOC_SPARC13
, 10);
291 EXT (BFD_RELOC_SPARC_GOT10
, 14);
292 EXT (BFD_RELOC_SPARC_BASE13
, 15);
293 EXT (BFD_RELOC_SPARC_GOT13
, 15);
294 EXT (BFD_RELOC_SPARC_GOT22
, 16);
295 EXT (BFD_RELOC_SPARC_PC10
, 17);
296 EXT (BFD_RELOC_SPARC_PC22
, 18);
297 EXT (BFD_RELOC_SPARC_WPLT30
, 19);
298 EXT (BFD_RELOC_SPARC_REV32
, 26);
306 STD (BFD_RELOC_8
, 0);
307 STD (BFD_RELOC_16
, 1);
308 STD (BFD_RELOC_32
, 2);
309 STD (BFD_RELOC_8_PCREL
, 4);
310 STD (BFD_RELOC_16_PCREL
, 5);
311 STD (BFD_RELOC_32_PCREL
, 6);
312 STD (BFD_RELOC_16_BASEREL
, 9);
313 STD (BFD_RELOC_32_BASEREL
, 10);
320 NAME (aout
, reloc_name_lookup
) (bfd
*abfd
, const char *r_name
)
322 unsigned int i
, size
;
323 reloc_howto_type
*howto_table
;
325 if (obj_reloc_entry_size (abfd
) == RELOC_EXT_SIZE
)
327 howto_table
= howto_table_ext
;
328 size
= sizeof (howto_table_ext
) / sizeof (howto_table_ext
[0]);
332 howto_table
= howto_table_std
;
333 size
= sizeof (howto_table_std
) / sizeof (howto_table_std
[0]);
336 for (i
= 0; i
< size
; i
++)
337 if (howto_table
[i
].name
!= NULL
338 && strcasecmp (howto_table
[i
].name
, r_name
) == 0)
339 return &howto_table
[i
];
346 Internal entry points
349 @file{aoutx.h} exports several routines for accessing the
350 contents of an a.out file, which are gathered and exported in
351 turn by various format specific files (eg sunos.c).
356 aout_@var{size}_swap_exec_header_in
359 void aout_@var{size}_swap_exec_header_in,
361 struct external_exec *bytes,
362 struct internal_exec *execp);
365 Swap the information in an executable header @var{raw_bytes} taken
366 from a raw byte stream memory image into the internal exec header
367 structure @var{execp}.
370 #ifndef NAME_swap_exec_header_in
372 NAME (aout
, swap_exec_header_in
) (bfd
*abfd
,
373 struct external_exec
*bytes
,
374 struct internal_exec
*execp
)
376 /* The internal_exec structure has some fields that are unused in this
377 configuration (IE for i960), so ensure that all such uninitialized
378 fields are zero'd out. There are places where two of these structs
379 are memcmp'd, and thus the contents do matter. */
380 memset ((void *) execp
, 0, sizeof (struct internal_exec
));
381 /* Now fill in fields in the execp, from the bytes in the raw data. */
382 execp
->a_info
= H_GET_32 (abfd
, bytes
->e_info
);
383 execp
->a_text
= GET_WORD (abfd
, bytes
->e_text
);
384 execp
->a_data
= GET_WORD (abfd
, bytes
->e_data
);
385 execp
->a_bss
= GET_WORD (abfd
, bytes
->e_bss
);
386 execp
->a_syms
= GET_WORD (abfd
, bytes
->e_syms
);
387 execp
->a_entry
= GET_WORD (abfd
, bytes
->e_entry
);
388 execp
->a_trsize
= GET_WORD (abfd
, bytes
->e_trsize
);
389 execp
->a_drsize
= GET_WORD (abfd
, bytes
->e_drsize
);
391 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
396 aout_@var{size}_swap_exec_header_out
399 void aout_@var{size}_swap_exec_header_out
401 struct internal_exec *execp,
402 struct external_exec *raw_bytes);
405 Swap the information in an internal exec header structure
406 @var{execp} into the buffer @var{raw_bytes} ready for writing to disk.
409 NAME (aout
, swap_exec_header_out
) (bfd
*abfd
,
410 struct internal_exec
*execp
,
411 struct external_exec
*bytes
)
413 /* Now fill in fields in the raw data, from the fields in the exec struct. */
414 H_PUT_32 (abfd
, execp
->a_info
, bytes
->e_info
);
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
);
424 /* Make all the section for an a.out file. */
427 NAME (aout
, make_sections
) (bfd
*abfd
)
429 if (obj_textsec (abfd
) == NULL
&& bfd_make_section (abfd
, ".text") == NULL
)
431 if (obj_datasec (abfd
) == NULL
&& bfd_make_section (abfd
, ".data") == NULL
)
433 if (obj_bsssec (abfd
) == NULL
&& bfd_make_section (abfd
, ".bss") == NULL
)
440 aout_@var{size}_some_aout_object_p
443 const bfd_target *aout_@var{size}_some_aout_object_p
445 struct internal_exec *execp,
446 const bfd_target *(*callback_to_real_object_p) (bfd *));
449 Some a.out variant thinks that the file open in @var{abfd}
450 checking is an a.out file. Do some more checking, and set up
451 for access if it really is. Call back to the calling
452 environment's "finish up" function just before returning, to
453 handle any last-minute setup.
457 NAME (aout
, some_aout_object_p
) (bfd
*abfd
,
458 struct internal_exec
*execp
,
459 const bfd_target
*(*callback_to_real_object_p
) (bfd
*))
461 struct aout_data_struct
*rawptr
, *oldrawptr
;
462 const bfd_target
*result
;
463 bfd_size_type amt
= sizeof (* rawptr
);
465 rawptr
= (struct aout_data_struct
*) bfd_zalloc (abfd
, amt
);
469 oldrawptr
= abfd
->tdata
.aout_data
;
470 abfd
->tdata
.aout_data
= rawptr
;
472 /* Copy the contents of the old tdata struct.
473 In particular, we want the subformat, since for hpux it was set in
474 hp300hpux.c:swap_exec_header_in and will be used in
475 hp300hpux.c:callback. */
476 if (oldrawptr
!= NULL
)
477 *abfd
->tdata
.aout_data
= *oldrawptr
;
479 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
480 /* Copy in the internal_exec struct. */
481 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
;
482 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
484 /* Set the file flags. */
485 abfd
->flags
= BFD_NO_FLAGS
;
486 if (execp
->a_drsize
|| execp
->a_trsize
)
487 abfd
->flags
|= HAS_RELOC
;
488 /* Setting of EXEC_P has been deferred to the bottom of this function. */
490 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
491 if (N_DYNAMIC (*execp
))
492 abfd
->flags
|= DYNAMIC
;
494 if (N_MAGIC (*execp
) == ZMAGIC
)
496 abfd
->flags
|= D_PAGED
| WP_TEXT
;
497 adata (abfd
).magic
= z_magic
;
499 else if (N_MAGIC (*execp
) == QMAGIC
)
501 abfd
->flags
|= D_PAGED
| WP_TEXT
;
502 adata (abfd
).magic
= z_magic
;
503 adata (abfd
).subformat
= q_magic_format
;
505 else if (N_MAGIC (*execp
) == NMAGIC
)
507 abfd
->flags
|= WP_TEXT
;
508 adata (abfd
).magic
= n_magic
;
510 else if (N_MAGIC (*execp
) == OMAGIC
511 || N_MAGIC (*execp
) == BMAGIC
)
512 adata (abfd
).magic
= o_magic
;
514 /* Should have been checked with N_BADMAG before this routine
518 bfd_get_start_address (abfd
) = execp
->a_entry
;
520 obj_aout_symbols (abfd
) = NULL
;
521 bfd_get_symcount (abfd
) = execp
->a_syms
/ sizeof (struct external_nlist
);
523 /* The default relocation entry size is that of traditional V7 Unix. */
524 obj_reloc_entry_size (abfd
) = RELOC_STD_SIZE
;
526 /* The default symbol entry size is that of traditional Unix. */
527 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
530 bfd_init_window (&obj_aout_sym_window (abfd
));
531 bfd_init_window (&obj_aout_string_window (abfd
));
533 obj_aout_external_syms (abfd
) = NULL
;
534 obj_aout_external_strings (abfd
) = NULL
;
535 obj_aout_sym_hashes (abfd
) = NULL
;
537 if (! NAME (aout
, make_sections
) (abfd
))
540 obj_datasec (abfd
)->size
= execp
->a_data
;
541 obj_bsssec (abfd
)->size
= execp
->a_bss
;
543 obj_textsec (abfd
)->flags
=
544 (execp
->a_trsize
!= 0
545 ? (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_RELOC
)
546 : (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
));
547 obj_datasec (abfd
)->flags
=
548 (execp
->a_drsize
!= 0
549 ? (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_RELOC
)
550 : (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
));
551 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
553 #ifdef THIS_IS_ONLY_DOCUMENTATION
554 /* The common code can't fill in these things because they depend
555 on either the start address of the text segment, the rounding
556 up of virtual addresses between segments, or the starting file
557 position of the text segment -- all of which varies among different
558 versions of a.out. */
560 /* Call back to the format-dependent code to fill in the rest of the
561 fields and do any further cleanup. Things that should be filled
562 in by the callback: */
564 struct exec
*execp
= exec_hdr (abfd
);
566 obj_textsec (abfd
)->size
= N_TXTSIZE (*execp
);
567 /* Data and bss are already filled in since they're so standard. */
569 /* The virtual memory addresses of the sections. */
570 obj_textsec (abfd
)->vma
= N_TXTADDR (*execp
);
571 obj_datasec (abfd
)->vma
= N_DATADDR (*execp
);
572 obj_bsssec (abfd
)->vma
= N_BSSADDR (*execp
);
574 /* The file offsets of the sections. */
575 obj_textsec (abfd
)->filepos
= N_TXTOFF (*execp
);
576 obj_datasec (abfd
)->filepos
= N_DATOFF (*execp
);
578 /* The file offsets of the relocation info. */
579 obj_textsec (abfd
)->rel_filepos
= N_TRELOFF (*execp
);
580 obj_datasec (abfd
)->rel_filepos
= N_DRELOFF (*execp
);
582 /* The file offsets of the string table and symbol table. */
583 obj_str_filepos (abfd
) = N_STROFF (*execp
);
584 obj_sym_filepos (abfd
) = N_SYMOFF (*execp
);
586 /* Determine the architecture and machine type of the object file. */
587 switch (N_MACHTYPE (*exec_hdr (abfd
)))
590 abfd
->obj_arch
= bfd_arch_obscure
;
594 adata (abfd
)->page_size
= TARGET_PAGE_SIZE
;
595 adata (abfd
)->segment_size
= SEGMENT_SIZE
;
596 adata (abfd
)->exec_bytes_size
= EXEC_BYTES_SIZE
;
600 /* The architecture is encoded in various ways in various a.out variants,
601 or is not encoded at all in some of them. The relocation size depends
602 on the architecture and the a.out variant. Finally, the return value
603 is the bfd_target vector in use. If an error occurs, return zero and
604 set bfd_error to the appropriate error code.
606 Formats such as b.out, which have additional fields in the a.out
607 header, should cope with them in this callback as well. */
608 #endif /* DOCUMENTATION */
610 result
= (*callback_to_real_object_p
) (abfd
);
612 /* Now that the segment addresses have been worked out, take a better
613 guess at whether the file is executable. If the entry point
614 is within the text segment, assume it is. (This makes files
615 executable even if their entry point address is 0, as long as
616 their text starts at zero.).
618 This test had to be changed to deal with systems where the text segment
619 runs at a different location than the default. The problem is that the
620 entry address can appear to be outside the text segment, thus causing an
621 erroneous conclusion that the file isn't executable.
623 To fix this, we now accept any non-zero entry point as an indication of
624 executability. This will work most of the time, since only the linker
625 sets the entry point, and that is likely to be non-zero for most systems. */
627 if (execp
->a_entry
!= 0
628 || (execp
->a_entry
>= obj_textsec (abfd
)->vma
629 && execp
->a_entry
< (obj_textsec (abfd
)->vma
630 + obj_textsec (abfd
)->size
)
631 && execp
->a_trsize
== 0
632 && execp
->a_drsize
== 0))
633 abfd
->flags
|= EXEC_P
;
637 struct stat stat_buf
;
639 /* The original heuristic doesn't work in some important cases.
640 The a.out file has no information about the text start
641 address. For files (like kernels) linked to non-standard
642 addresses (ld -Ttext nnn) the entry point may not be between
643 the default text start (obj_textsec(abfd)->vma) and
644 (obj_textsec(abfd)->vma) + text size. This is not just a mach
645 issue. Many kernels are loaded at non standard addresses. */
646 if (abfd
->iostream
!= NULL
647 && (abfd
->flags
& BFD_IN_MEMORY
) == 0
648 && (fstat (fileno ((FILE *) (abfd
->iostream
)), &stat_buf
) == 0)
649 && ((stat_buf
.st_mode
& 0111) != 0))
650 abfd
->flags
|= EXEC_P
;
652 #endif /* STAT_FOR_EXEC */
658 bfd_release (abfd
, rawptr
);
659 abfd
->tdata
.aout_data
= oldrawptr
;
665 aout_@var{size}_mkobject
668 bfd_boolean aout_@var{size}_mkobject, (bfd *abfd);
671 Initialize BFD @var{abfd} for use with a.out files.
675 NAME (aout
, mkobject
) (bfd
*abfd
)
677 struct aout_data_struct
*rawptr
;
678 bfd_size_type amt
= sizeof (* rawptr
);
680 bfd_set_error (bfd_error_system_call
);
682 rawptr
= (struct aout_data_struct
*) bfd_zalloc (abfd
, amt
);
686 abfd
->tdata
.aout_data
= rawptr
;
687 exec_hdr (abfd
) = &(rawptr
->e
);
689 obj_textsec (abfd
) = NULL
;
690 obj_datasec (abfd
) = NULL
;
691 obj_bsssec (abfd
) = NULL
;
698 aout_@var{size}_machine_type
701 enum machine_type aout_@var{size}_machine_type
702 (enum bfd_architecture arch,
703 unsigned long machine,
704 bfd_boolean *unknown);
707 Keep track of machine architecture and machine type for
708 a.out's. Return the <<machine_type>> for a particular
709 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
710 and machine can't be represented in a.out format.
712 If the architecture is understood, machine type 0 (default)
713 is always understood.
717 NAME (aout
, machine_type
) (enum bfd_architecture arch
,
718 unsigned long machine
,
719 bfd_boolean
*unknown
)
721 enum machine_type arch_flags
;
723 arch_flags
= M_UNKNOWN
;
730 || machine
== bfd_mach_sparc
731 || machine
== bfd_mach_sparc_sparclite
732 || machine
== bfd_mach_sparc_sparclite_le
733 || machine
== bfd_mach_sparc_v8plus
734 || machine
== bfd_mach_sparc_v8plusa
735 || machine
== bfd_mach_sparc_v8plusb
736 || machine
== bfd_mach_sparc_v9
737 || machine
== bfd_mach_sparc_v9a
738 || machine
== bfd_mach_sparc_v9b
)
739 arch_flags
= M_SPARC
;
740 else if (machine
== bfd_mach_sparc_sparclet
)
741 arch_flags
= M_SPARCLET
;
747 case 0: arch_flags
= M_68010
; break;
748 case bfd_mach_m68000
: arch_flags
= M_UNKNOWN
; *unknown
= FALSE
; break;
749 case bfd_mach_m68010
: arch_flags
= M_68010
; break;
750 case bfd_mach_m68020
: arch_flags
= M_68020
; break;
751 default: arch_flags
= M_UNKNOWN
; break;
757 || machine
== bfd_mach_i386_i386
758 || machine
== bfd_mach_i386_i386_intel_syntax
)
771 case bfd_mach_mips3000
:
772 case bfd_mach_mips3900
:
773 arch_flags
= M_MIPS1
;
775 case bfd_mach_mips6000
:
776 arch_flags
= M_MIPS2
;
778 case bfd_mach_mips4000
:
779 case bfd_mach_mips4010
:
780 case bfd_mach_mips4100
:
781 case bfd_mach_mips4300
:
782 case bfd_mach_mips4400
:
783 case bfd_mach_mips4600
:
784 case bfd_mach_mips4650
:
785 case bfd_mach_mips8000
:
786 case bfd_mach_mips9000
:
787 case bfd_mach_mips10000
:
788 case bfd_mach_mips12000
:
789 case bfd_mach_mips14000
:
790 case bfd_mach_mips16000
:
791 case bfd_mach_mips16
:
792 case bfd_mach_mipsisa32
:
793 case bfd_mach_mipsisa32r2
:
794 case bfd_mach_mipsisa32r3
:
795 case bfd_mach_mipsisa32r5
:
797 case bfd_mach_mipsisa64
:
798 case bfd_mach_mipsisa64r2
:
799 case bfd_mach_mipsisa64r3
:
800 case bfd_mach_mipsisa64r5
:
801 case bfd_mach_mips_sb1
:
802 case bfd_mach_mips_xlr
:
803 /* FIXME: These should be MIPS3, MIPS4, MIPS16, MIPS32, etc. */
804 arch_flags
= M_MIPS2
;
807 arch_flags
= M_UNKNOWN
;
815 case 0: arch_flags
= M_NS32532
; break;
816 case 32032: arch_flags
= M_NS32032
; break;
817 case 32532: arch_flags
= M_NS32532
; break;
818 default: arch_flags
= M_UNKNOWN
; break;
827 if (machine
== 0 || machine
== 255)
836 arch_flags
= M_UNKNOWN
;
839 if (arch_flags
!= M_UNKNOWN
)
847 aout_@var{size}_set_arch_mach
850 bfd_boolean aout_@var{size}_set_arch_mach,
852 enum bfd_architecture arch,
853 unsigned long machine);
856 Set the architecture and the machine of the BFD @var{abfd} to the
857 values @var{arch} and @var{machine}. Verify that @var{abfd}'s format
858 can support the architecture required.
862 NAME (aout
, set_arch_mach
) (bfd
*abfd
,
863 enum bfd_architecture arch
,
864 unsigned long machine
)
866 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
869 if (arch
!= bfd_arch_unknown
)
873 NAME (aout
, machine_type
) (arch
, machine
, &unknown
);
878 /* Determine the size of a relocation entry. */
883 obj_reloc_entry_size (abfd
) = RELOC_EXT_SIZE
;
886 obj_reloc_entry_size (abfd
) = RELOC_STD_SIZE
;
890 return (*aout_backend_info (abfd
)->set_sizes
) (abfd
);
894 adjust_o_magic (bfd
*abfd
, struct internal_exec
*execp
)
896 file_ptr pos
= adata (abfd
).exec_bytes_size
;
901 obj_textsec (abfd
)->filepos
= pos
;
902 if (!obj_textsec (abfd
)->user_set_vma
)
903 obj_textsec (abfd
)->vma
= vma
;
905 vma
= obj_textsec (abfd
)->vma
;
907 pos
+= obj_textsec (abfd
)->size
;
908 vma
+= obj_textsec (abfd
)->size
;
911 if (!obj_datasec (abfd
)->user_set_vma
)
913 obj_textsec (abfd
)->size
+= pad
;
916 obj_datasec (abfd
)->vma
= vma
;
919 vma
= obj_datasec (abfd
)->vma
;
920 obj_datasec (abfd
)->filepos
= pos
;
921 pos
+= obj_datasec (abfd
)->size
;
922 vma
+= obj_datasec (abfd
)->size
;
925 if (!obj_bsssec (abfd
)->user_set_vma
)
927 obj_datasec (abfd
)->size
+= pad
;
930 obj_bsssec (abfd
)->vma
= vma
;
934 /* The VMA of the .bss section is set by the VMA of the
935 .data section plus the size of the .data section. We may
936 need to add padding bytes to make this true. */
937 pad
= obj_bsssec (abfd
)->vma
- vma
;
940 obj_datasec (abfd
)->size
+= pad
;
944 obj_bsssec (abfd
)->filepos
= pos
;
946 /* Fix up the exec header. */
947 execp
->a_text
= obj_textsec (abfd
)->size
;
948 execp
->a_data
= obj_datasec (abfd
)->size
;
949 execp
->a_bss
= obj_bsssec (abfd
)->size
;
950 N_SET_MAGIC (*execp
, OMAGIC
);
954 adjust_z_magic (bfd
*abfd
, struct internal_exec
*execp
)
956 bfd_size_type data_pad
, text_pad
;
958 const struct aout_backend_data
*abdp
;
959 /* TRUE if text includes exec header. */
962 abdp
= aout_backend_info (abfd
);
966 && (abdp
->text_includes_header
967 || obj_aout_subformat (abfd
) == q_magic_format
));
968 obj_textsec (abfd
)->filepos
= (ztih
969 ? adata (abfd
).exec_bytes_size
970 : adata (abfd
).zmagic_disk_block_size
);
971 if (! obj_textsec (abfd
)->user_set_vma
)
973 /* ?? Do we really need to check for relocs here? */
974 obj_textsec (abfd
)->vma
= ((abfd
->flags
& HAS_RELOC
)
977 ? (abdp
->default_text_vma
978 + adata (abfd
).exec_bytes_size
)
979 : abdp
->default_text_vma
));
984 /* The .text section is being loaded at an unusual address. We
985 may need to pad it such that the .data section starts at a page
988 text_pad
= ((obj_textsec (abfd
)->filepos
- obj_textsec (abfd
)->vma
)
989 & (adata (abfd
).page_size
- 1));
991 text_pad
= ((- obj_textsec (abfd
)->vma
)
992 & (adata (abfd
).page_size
- 1));
995 /* Find start of data. */
998 text_end
= obj_textsec (abfd
)->filepos
+ obj_textsec (abfd
)->size
;
999 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
1003 /* Note that if page_size == zmagic_disk_block_size, then
1004 filepos == page_size, and this case is the same as the ztih
1006 text_end
= obj_textsec (abfd
)->size
;
1007 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
1008 text_end
+= obj_textsec (abfd
)->filepos
;
1010 obj_textsec (abfd
)->size
+= text_pad
;
1011 text_end
+= text_pad
;
1014 if (!obj_datasec (abfd
)->user_set_vma
)
1017 vma
= obj_textsec (abfd
)->vma
+ obj_textsec (abfd
)->size
;
1018 obj_datasec (abfd
)->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
1020 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
1022 asection
* text
= obj_textsec (abfd
);
1023 asection
* data
= obj_datasec (abfd
);
1025 text_pad
= data
->vma
- (text
->vma
+ text
->size
);
1026 /* Only pad the text section if the data
1027 section is going to be placed after it. */
1029 text
->size
+= text_pad
;
1031 obj_datasec (abfd
)->filepos
= (obj_textsec (abfd
)->filepos
1032 + obj_textsec (abfd
)->size
);
1034 /* Fix up exec header while we're at it. */
1035 execp
->a_text
= obj_textsec (abfd
)->size
;
1036 if (ztih
&& (!abdp
|| (abdp
&& !abdp
->exec_header_not_counted
)))
1037 execp
->a_text
+= adata (abfd
).exec_bytes_size
;
1038 if (obj_aout_subformat (abfd
) == q_magic_format
)
1039 N_SET_MAGIC (*execp
, QMAGIC
);
1041 N_SET_MAGIC (*execp
, ZMAGIC
);
1043 /* Spec says data section should be rounded up to page boundary. */
1044 obj_datasec (abfd
)->size
1045 = align_power (obj_datasec (abfd
)->size
,
1046 obj_bsssec (abfd
)->alignment_power
);
1047 execp
->a_data
= BFD_ALIGN (obj_datasec (abfd
)->size
,
1048 adata (abfd
).page_size
);
1049 data_pad
= execp
->a_data
- obj_datasec (abfd
)->size
;
1052 if (!obj_bsssec (abfd
)->user_set_vma
)
1053 obj_bsssec (abfd
)->vma
= (obj_datasec (abfd
)->vma
1054 + obj_datasec (abfd
)->size
);
1055 /* If the BSS immediately follows the data section and extra space
1056 in the page is left after the data section, fudge data
1057 in the header so that the bss section looks smaller by that
1058 amount. We'll start the bss section there, and lie to the OS.
1059 (Note that a linker script, as well as the above assignment,
1060 could have explicitly set the BSS vma to immediately follow
1061 the data section.) */
1062 if (align_power (obj_bsssec (abfd
)->vma
, obj_bsssec (abfd
)->alignment_power
)
1063 == obj_datasec (abfd
)->vma
+ obj_datasec (abfd
)->size
)
1064 execp
->a_bss
= (data_pad
> obj_bsssec (abfd
)->size
1065 ? 0 : obj_bsssec (abfd
)->size
- data_pad
);
1067 execp
->a_bss
= obj_bsssec (abfd
)->size
;
1071 adjust_n_magic (bfd
*abfd
, struct internal_exec
*execp
)
1073 file_ptr pos
= adata (abfd
).exec_bytes_size
;
1078 obj_textsec (abfd
)->filepos
= pos
;
1079 if (!obj_textsec (abfd
)->user_set_vma
)
1080 obj_textsec (abfd
)->vma
= vma
;
1082 vma
= obj_textsec (abfd
)->vma
;
1083 pos
+= obj_textsec (abfd
)->size
;
1084 vma
+= obj_textsec (abfd
)->size
;
1087 obj_datasec (abfd
)->filepos
= pos
;
1088 if (!obj_datasec (abfd
)->user_set_vma
)
1089 obj_datasec (abfd
)->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
1090 vma
= obj_datasec (abfd
)->vma
;
1092 /* Since BSS follows data immediately, see if it needs alignment. */
1093 vma
+= obj_datasec (abfd
)->size
;
1094 pad
= align_power (vma
, obj_bsssec (abfd
)->alignment_power
) - vma
;
1095 obj_datasec (abfd
)->size
+= pad
;
1096 pos
+= obj_datasec (abfd
)->size
;
1099 if (!obj_bsssec (abfd
)->user_set_vma
)
1100 obj_bsssec (abfd
)->vma
= vma
;
1102 vma
= obj_bsssec (abfd
)->vma
;
1104 /* Fix up exec header. */
1105 execp
->a_text
= obj_textsec (abfd
)->size
;
1106 execp
->a_data
= obj_datasec (abfd
)->size
;
1107 execp
->a_bss
= obj_bsssec (abfd
)->size
;
1108 N_SET_MAGIC (*execp
, NMAGIC
);
1112 NAME (aout
, adjust_sizes_and_vmas
) (bfd
*abfd
,
1113 bfd_size_type
*text_size
,
1114 file_ptr
*text_end ATTRIBUTE_UNUSED
)
1116 struct internal_exec
*execp
= exec_hdr (abfd
);
1118 if (! NAME (aout
, make_sections
) (abfd
))
1121 if (adata (abfd
).magic
!= undecided_magic
)
1124 obj_textsec (abfd
)->size
=
1125 align_power (obj_textsec (abfd
)->size
,
1126 obj_textsec (abfd
)->alignment_power
);
1128 *text_size
= obj_textsec (abfd
)->size
;
1129 /* Rule (heuristic) for when to pad to a new page. Note that there
1130 are (at least) two ways demand-paged (ZMAGIC) files have been
1131 handled. Most Berkeley-based systems start the text segment at
1132 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1133 segment right after the exec header; the latter is counted in the
1134 text segment size, and is paged in by the kernel with the rest of
1137 /* This perhaps isn't the right way to do this, but made it simpler for me
1138 to understand enough to implement it. Better would probably be to go
1139 right from BFD flags to alignment/positioning characteristics. But the
1140 old code was sloppy enough about handling the flags, and had enough
1141 other magic, that it was a little hard for me to understand. I think
1142 I understand it better now, but I haven't time to do the cleanup this
1145 if (abfd
->flags
& D_PAGED
)
1146 /* Whether or not WP_TEXT is set -- let D_PAGED override. */
1147 adata (abfd
).magic
= z_magic
;
1148 else if (abfd
->flags
& WP_TEXT
)
1149 adata (abfd
).magic
= n_magic
;
1151 adata (abfd
).magic
= o_magic
;
1153 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1155 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1157 switch (adata (abfd
).magic
)
1159 case n_magic
: str
= "NMAGIC"; break;
1160 case o_magic
: str
= "OMAGIC"; break;
1161 case z_magic
: str
= "ZMAGIC"; break;
1166 obj_textsec (abfd
)->vma
, obj_textsec (abfd
)->size
,
1167 obj_textsec (abfd
)->alignment_power
,
1168 obj_datasec (abfd
)->vma
, obj_datasec (abfd
)->size
,
1169 obj_datasec (abfd
)->alignment_power
,
1170 obj_bsssec (abfd
)->vma
, obj_bsssec (abfd
)->size
,
1171 obj_bsssec (abfd
)->alignment_power
);
1175 switch (adata (abfd
).magic
)
1178 adjust_o_magic (abfd
, execp
);
1181 adjust_z_magic (abfd
, execp
);
1184 adjust_n_magic (abfd
, execp
);
1190 #ifdef BFD_AOUT_DEBUG
1191 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1192 obj_textsec (abfd
)->vma
, obj_textsec (abfd
)->size
,
1193 obj_textsec (abfd
)->filepos
,
1194 obj_datasec (abfd
)->vma
, obj_datasec (abfd
)->size
,
1195 obj_datasec (abfd
)->filepos
,
1196 obj_bsssec (abfd
)->vma
, obj_bsssec (abfd
)->size
);
1204 aout_@var{size}_new_section_hook
1207 bfd_boolean aout_@var{size}_new_section_hook,
1212 Called by the BFD in response to a @code{bfd_make_section}
1216 NAME (aout
, new_section_hook
) (bfd
*abfd
, asection
*newsect
)
1218 /* Align to double at least. */
1219 newsect
->alignment_power
= bfd_get_arch_info (abfd
)->section_align_power
;
1221 if (bfd_get_format (abfd
) == bfd_object
)
1223 if (obj_textsec (abfd
) == NULL
&& !strcmp (newsect
->name
, ".text"))
1225 obj_textsec (abfd
)= newsect
;
1226 newsect
->target_index
= N_TEXT
;
1228 else if (obj_datasec (abfd
) == NULL
&& !strcmp (newsect
->name
, ".data"))
1230 obj_datasec (abfd
) = newsect
;
1231 newsect
->target_index
= N_DATA
;
1233 else if (obj_bsssec (abfd
) == NULL
&& !strcmp (newsect
->name
, ".bss"))
1235 obj_bsssec (abfd
) = newsect
;
1236 newsect
->target_index
= N_BSS
;
1240 /* We allow more than three sections internally. */
1241 return _bfd_generic_new_section_hook (abfd
, newsect
);
1245 NAME (aout
, set_section_contents
) (bfd
*abfd
,
1247 const void * location
,
1249 bfd_size_type count
)
1252 bfd_size_type text_size
;
1254 if (! abfd
->output_has_begun
)
1256 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
, &text_size
, &text_end
))
1260 if (section
== obj_bsssec (abfd
))
1262 bfd_set_error (bfd_error_no_contents
);
1266 if (section
!= obj_textsec (abfd
)
1267 && section
!= obj_datasec (abfd
))
1269 if (aout_section_merge_with_text_p (abfd
, section
))
1270 section
->filepos
= obj_textsec (abfd
)->filepos
+
1271 (section
->vma
- obj_textsec (abfd
)->vma
);
1274 (*_bfd_error_handler
)
1275 (_("%s: can not represent section `%s' in a.out object file format"),
1276 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
));
1277 bfd_set_error (bfd_error_nonrepresentable_section
);
1284 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
1285 || bfd_bwrite (location
, count
, abfd
) != count
)
1292 /* Read the external symbols from an a.out file. */
1295 aout_get_external_symbols (bfd
*abfd
)
1297 if (obj_aout_external_syms (abfd
) == NULL
)
1299 bfd_size_type count
;
1300 struct external_nlist
*syms
;
1302 count
= exec_hdr (abfd
)->a_syms
/ EXTERNAL_NLIST_SIZE
;
1304 return TRUE
; /* Nothing to do. */
1307 if (! bfd_get_file_window (abfd
, obj_sym_filepos (abfd
),
1308 exec_hdr (abfd
)->a_syms
,
1309 &obj_aout_sym_window (abfd
), TRUE
))
1311 syms
= (struct external_nlist
*) obj_aout_sym_window (abfd
).data
;
1313 /* We allocate using malloc to make the values easy to free
1314 later on. If we put them on the objalloc it might not be
1315 possible to free them. */
1316 syms
= (struct external_nlist
*) bfd_malloc (count
* EXTERNAL_NLIST_SIZE
);
1322 amt
= exec_hdr (abfd
)->a_syms
;
1323 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1324 || bfd_bread (syms
, amt
, abfd
) != amt
)
1332 obj_aout_external_syms (abfd
) = syms
;
1333 obj_aout_external_sym_count (abfd
) = count
;
1336 if (obj_aout_external_strings (abfd
) == NULL
1337 && exec_hdr (abfd
)->a_syms
!= 0)
1339 unsigned char string_chars
[BYTES_IN_WORD
];
1340 bfd_size_type stringsize
;
1342 bfd_size_type amt
= BYTES_IN_WORD
;
1344 /* Get the size of the strings. */
1345 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
1346 || bfd_bread ((void *) string_chars
, amt
, abfd
) != amt
)
1348 stringsize
= GET_WORD (abfd
, string_chars
);
1351 if (! bfd_get_file_window (abfd
, obj_str_filepos (abfd
), stringsize
,
1352 &obj_aout_string_window (abfd
), TRUE
))
1354 strings
= (char *) obj_aout_string_window (abfd
).data
;
1356 strings
= (char *) bfd_malloc (stringsize
+ 1);
1357 if (strings
== NULL
)
1360 /* Skip space for the string count in the buffer for convenience
1361 when using indexes. */
1362 amt
= stringsize
- BYTES_IN_WORD
;
1363 if (bfd_bread (strings
+ BYTES_IN_WORD
, amt
, abfd
) != amt
)
1370 /* Ensure that a zero index yields an empty string. */
1373 strings
[stringsize
- 1] = 0;
1375 obj_aout_external_strings (abfd
) = strings
;
1376 obj_aout_external_string_size (abfd
) = stringsize
;
1382 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1383 and symbol->value fields of CACHE_PTR will be set from the a.out
1384 nlist structure. This function is responsible for setting
1385 symbol->flags and symbol->section, and adjusting symbol->value. */
1388 translate_from_native_sym_flags (bfd
*abfd
, aout_symbol_type
*cache_ptr
)
1392 if ((cache_ptr
->type
& N_STAB
) != 0
1393 || cache_ptr
->type
== N_FN
)
1397 /* This is a debugging symbol. */
1398 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1400 /* Work out the symbol section. */
1401 switch (cache_ptr
->type
& N_TYPE
)
1405 sec
= obj_textsec (abfd
);
1408 sec
= obj_datasec (abfd
);
1411 sec
= obj_bsssec (abfd
);
1415 sec
= bfd_abs_section_ptr
;
1419 cache_ptr
->symbol
.section
= sec
;
1420 cache_ptr
->symbol
.value
-= sec
->vma
;
1425 /* Get the default visibility. This does not apply to all types, so
1426 we just hold it in a local variable to use if wanted. */
1427 if ((cache_ptr
->type
& N_EXT
) == 0)
1428 visible
= BSF_LOCAL
;
1430 visible
= BSF_GLOBAL
;
1432 switch (cache_ptr
->type
)
1435 case N_ABS
: case N_ABS
| N_EXT
:
1436 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1437 cache_ptr
->symbol
.flags
= visible
;
1440 case N_UNDF
| N_EXT
:
1441 if (cache_ptr
->symbol
.value
!= 0)
1443 /* This is a common symbol. */
1444 cache_ptr
->symbol
.flags
= BSF_GLOBAL
;
1445 cache_ptr
->symbol
.section
= bfd_com_section_ptr
;
1449 cache_ptr
->symbol
.flags
= 0;
1450 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1454 case N_TEXT
: case N_TEXT
| N_EXT
:
1455 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1456 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1457 cache_ptr
->symbol
.flags
= visible
;
1460 /* N_SETV symbols used to represent set vectors placed in the
1461 data section. They are no longer generated. Theoretically,
1462 it was possible to extract the entries and combine them with
1463 new ones, although I don't know if that was ever actually
1464 done. Unless that feature is restored, treat them as data
1466 case N_SETV
: case N_SETV
| N_EXT
:
1467 case N_DATA
: case N_DATA
| N_EXT
:
1468 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1469 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1470 cache_ptr
->symbol
.flags
= visible
;
1473 case N_BSS
: case N_BSS
| N_EXT
:
1474 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1475 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1476 cache_ptr
->symbol
.flags
= visible
;
1479 case N_SETA
: case N_SETA
| N_EXT
:
1480 case N_SETT
: case N_SETT
| N_EXT
:
1481 case N_SETD
: case N_SETD
| N_EXT
:
1482 case N_SETB
: case N_SETB
| N_EXT
:
1484 /* This code is no longer needed. It used to be used to make
1485 the linker handle set symbols, but they are now handled in
1486 the add_symbols routine instead. */
1487 switch (cache_ptr
->type
& N_TYPE
)
1490 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1493 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1496 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1499 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1503 cache_ptr
->symbol
.flags
|= BSF_CONSTRUCTOR
;
1508 /* This symbol is the text of a warning message. The next
1509 symbol is the symbol to associate the warning with. If a
1510 reference is made to that symbol, a warning is issued. */
1511 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
| BSF_WARNING
;
1512 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1515 case N_INDR
: case N_INDR
| N_EXT
:
1516 /* An indirect symbol. This consists of two symbols in a row.
1517 The first symbol is the name of the indirection. The second
1518 symbol is the name of the target. A reference to the first
1519 symbol becomes a reference to the second. */
1520 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
| BSF_INDIRECT
| visible
;
1521 cache_ptr
->symbol
.section
= bfd_ind_section_ptr
;
1525 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1526 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1530 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1531 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1535 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1536 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1537 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1541 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1542 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1543 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1547 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1548 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1549 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1556 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1559 translate_to_native_sym_flags (bfd
*abfd
,
1561 struct external_nlist
*sym_pointer
)
1563 bfd_vma value
= cache_ptr
->value
;
1567 /* Mask out any existing type bits in case copying from one section
1569 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1571 sec
= bfd_get_section (cache_ptr
);
1576 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1578 (*_bfd_error_handler
)
1579 (_("%s: can not represent section for symbol `%s' in a.out object file format"),
1580 bfd_get_filename (abfd
),
1581 cache_ptr
->name
!= NULL
? cache_ptr
->name
: _("*unknown*"));
1582 bfd_set_error (bfd_error_nonrepresentable_section
);
1586 if (sec
->output_section
!= NULL
)
1588 off
= sec
->output_offset
;
1589 sec
= sec
->output_section
;
1592 if (bfd_is_abs_section (sec
))
1593 sym_pointer
->e_type
[0] |= N_ABS
;
1594 else if (sec
== obj_textsec (abfd
))
1595 sym_pointer
->e_type
[0] |= N_TEXT
;
1596 else if (sec
== obj_datasec (abfd
))
1597 sym_pointer
->e_type
[0] |= N_DATA
;
1598 else if (sec
== obj_bsssec (abfd
))
1599 sym_pointer
->e_type
[0] |= N_BSS
;
1600 else if (bfd_is_und_section (sec
))
1601 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1602 else if (bfd_is_ind_section (sec
))
1603 sym_pointer
->e_type
[0] = N_INDR
;
1604 else if (bfd_is_com_section (sec
))
1605 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1608 if (aout_section_merge_with_text_p (abfd
, sec
))
1609 sym_pointer
->e_type
[0] |= N_TEXT
;
1612 (*_bfd_error_handler
)
1613 (_("%s: can not represent section `%s' in a.out object file format"),
1614 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sec
));
1615 bfd_set_error (bfd_error_nonrepresentable_section
);
1620 /* Turn the symbol from section relative to absolute again. */
1621 value
+= sec
->vma
+ off
;
1623 if ((cache_ptr
->flags
& BSF_WARNING
) != 0)
1624 sym_pointer
->e_type
[0] = N_WARNING
;
1626 if ((cache_ptr
->flags
& BSF_DEBUGGING
) != 0)
1627 sym_pointer
->e_type
[0] = ((aout_symbol_type
*) cache_ptr
)->type
;
1628 else if ((cache_ptr
->flags
& BSF_GLOBAL
) != 0)
1629 sym_pointer
->e_type
[0] |= N_EXT
;
1630 else if ((cache_ptr
->flags
& BSF_LOCAL
) != 0)
1631 sym_pointer
->e_type
[0] &= ~N_EXT
;
1633 if ((cache_ptr
->flags
& BSF_CONSTRUCTOR
) != 0)
1635 int type
= ((aout_symbol_type
*) cache_ptr
)->type
;
1639 case N_ABS
: type
= N_SETA
; break;
1640 case N_TEXT
: type
= N_SETT
; break;
1641 case N_DATA
: type
= N_SETD
; break;
1642 case N_BSS
: type
= N_SETB
; break;
1644 sym_pointer
->e_type
[0] = type
;
1647 if ((cache_ptr
->flags
& BSF_WEAK
) != 0)
1651 switch (sym_pointer
->e_type
[0] & N_TYPE
)
1654 case N_ABS
: type
= N_WEAKA
; break;
1655 case N_TEXT
: type
= N_WEAKT
; break;
1656 case N_DATA
: type
= N_WEAKD
; break;
1657 case N_BSS
: type
= N_WEAKB
; break;
1658 case N_UNDF
: type
= N_WEAKU
; break;
1660 sym_pointer
->e_type
[0] = type
;
1663 PUT_WORD (abfd
, value
, sym_pointer
->e_value
);
1668 /* Native-level interface to symbols. */
1671 NAME (aout
, make_empty_symbol
) (bfd
*abfd
)
1673 bfd_size_type amt
= sizeof (aout_symbol_type
);
1675 aout_symbol_type
*new_symbol
= (aout_symbol_type
*) bfd_zalloc (abfd
, amt
);
1678 new_symbol
->symbol
.the_bfd
= abfd
;
1680 return &new_symbol
->symbol
;
1683 /* Translate a set of internal symbols into external symbols. */
1686 NAME (aout
, translate_symbol_table
) (bfd
*abfd
,
1687 aout_symbol_type
*in
,
1688 struct external_nlist
*ext
,
1689 bfd_size_type count
,
1691 bfd_size_type strsize
,
1692 bfd_boolean dynamic
)
1694 struct external_nlist
*ext_end
;
1696 ext_end
= ext
+ count
;
1697 for (; ext
< ext_end
; ext
++, in
++)
1701 x
= GET_WORD (abfd
, ext
->e_strx
);
1702 in
->symbol
.the_bfd
= abfd
;
1704 /* For the normal symbols, the zero index points at the number
1705 of bytes in the string table but is to be interpreted as the
1706 null string. For the dynamic symbols, the number of bytes in
1707 the string table is stored in the __DYNAMIC structure and the
1708 zero index points at an actual string. */
1709 if (x
== 0 && ! dynamic
)
1710 in
->symbol
.name
= "";
1711 else if (x
< strsize
)
1712 in
->symbol
.name
= str
+ x
;
1716 in
->symbol
.value
= GET_SWORD (abfd
, ext
->e_value
);
1717 in
->desc
= H_GET_16 (abfd
, ext
->e_desc
);
1718 in
->other
= H_GET_8 (abfd
, ext
->e_other
);
1719 in
->type
= H_GET_8 (abfd
, ext
->e_type
);
1720 in
->symbol
.udata
.p
= NULL
;
1722 if (! translate_from_native_sym_flags (abfd
, in
))
1726 in
->symbol
.flags
|= BSF_DYNAMIC
;
1732 /* We read the symbols into a buffer, which is discarded when this
1733 function exits. We read the strings into a buffer large enough to
1734 hold them all plus all the cached symbol entries. */
1737 NAME (aout
, slurp_symbol_table
) (bfd
*abfd
)
1739 struct external_nlist
*old_external_syms
;
1740 aout_symbol_type
*cached
;
1741 bfd_size_type cached_size
;
1743 /* If there's no work to be done, don't do any. */
1744 if (obj_aout_symbols (abfd
) != NULL
)
1747 old_external_syms
= obj_aout_external_syms (abfd
);
1749 if (! aout_get_external_symbols (abfd
))
1752 cached_size
= obj_aout_external_sym_count (abfd
);
1753 if (cached_size
== 0)
1754 return TRUE
; /* Nothing to do. */
1756 cached_size
*= sizeof (aout_symbol_type
);
1757 cached
= (aout_symbol_type
*) bfd_zmalloc (cached_size
);
1761 /* Convert from external symbol information to internal. */
1762 if (! (NAME (aout
, translate_symbol_table
)
1764 obj_aout_external_syms (abfd
),
1765 obj_aout_external_sym_count (abfd
),
1766 obj_aout_external_strings (abfd
),
1767 obj_aout_external_string_size (abfd
),
1774 bfd_get_symcount (abfd
) = obj_aout_external_sym_count (abfd
);
1776 obj_aout_symbols (abfd
) = cached
;
1778 /* It is very likely that anybody who calls this function will not
1779 want the external symbol information, so if it was allocated
1780 because of our call to aout_get_external_symbols, we free it up
1781 right away to save space. */
1782 if (old_external_syms
== NULL
1783 && obj_aout_external_syms (abfd
) != NULL
)
1786 bfd_free_window (&obj_aout_sym_window (abfd
));
1788 free (obj_aout_external_syms (abfd
));
1790 obj_aout_external_syms (abfd
) = NULL
;
1796 /* We use a hash table when writing out symbols so that we only write
1797 out a particular string once. This helps particularly when the
1798 linker writes out stabs debugging entries, because each different
1799 contributing object file tends to have many duplicate stabs
1802 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1803 if BFD_TRADITIONAL_FORMAT is set. */
1805 /* Get the index of a string in a strtab, adding it if it is not
1808 static inline bfd_size_type
1809 add_to_stringtab (bfd
*abfd
,
1810 struct bfd_strtab_hash
*tab
,
1815 bfd_size_type str_index
;
1817 /* An index of 0 always means the empty string. */
1818 if (str
== 0 || *str
== '\0')
1821 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1822 doesn't understand a hashed string table. */
1824 if ((abfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1827 str_index
= _bfd_stringtab_add (tab
, str
, hash
, copy
);
1829 if (str_index
!= (bfd_size_type
) -1)
1830 /* Add BYTES_IN_WORD to the return value to account for the
1831 space taken up by the string table size. */
1832 str_index
+= BYTES_IN_WORD
;
1837 /* Write out a strtab. ABFD is already at the right location in the
1841 emit_stringtab (bfd
*abfd
, struct bfd_strtab_hash
*tab
)
1843 bfd_byte buffer
[BYTES_IN_WORD
];
1844 bfd_size_type amt
= BYTES_IN_WORD
;
1846 /* The string table starts with the size. */
1847 PUT_WORD (abfd
, _bfd_stringtab_size (tab
) + BYTES_IN_WORD
, buffer
);
1848 if (bfd_bwrite ((void *) buffer
, amt
, abfd
) != amt
)
1851 return _bfd_stringtab_emit (abfd
, tab
);
1855 NAME (aout
, write_syms
) (bfd
*abfd
)
1857 unsigned int count
;
1858 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1859 struct bfd_strtab_hash
*strtab
;
1861 strtab
= _bfd_stringtab_init ();
1865 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1867 asymbol
*g
= generic
[count
];
1869 struct external_nlist nsp
;
1872 indx
= add_to_stringtab (abfd
, strtab
, g
->name
, FALSE
);
1873 if (indx
== (bfd_size_type
) -1)
1875 PUT_WORD (abfd
, indx
, (bfd_byte
*) nsp
.e_strx
);
1877 if (bfd_asymbol_flavour (g
) == abfd
->xvec
->flavour
)
1879 H_PUT_16 (abfd
, aout_symbol (g
)->desc
, nsp
.e_desc
);
1880 H_PUT_8 (abfd
, aout_symbol (g
)->other
, nsp
.e_other
);
1881 H_PUT_8 (abfd
, aout_symbol (g
)->type
, nsp
.e_type
);
1885 H_PUT_16 (abfd
, 0, nsp
.e_desc
);
1886 H_PUT_8 (abfd
, 0, nsp
.e_other
);
1887 H_PUT_8 (abfd
, 0, nsp
.e_type
);
1890 if (! translate_to_native_sym_flags (abfd
, g
, &nsp
))
1893 amt
= EXTERNAL_NLIST_SIZE
;
1894 if (bfd_bwrite ((void *) &nsp
, amt
, abfd
) != amt
)
1897 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1898 here, at the end. */
1902 if (! emit_stringtab (abfd
, strtab
))
1905 _bfd_stringtab_free (strtab
);
1910 _bfd_stringtab_free (strtab
);
1915 NAME (aout
, canonicalize_symtab
) (bfd
*abfd
, asymbol
**location
)
1917 unsigned int counter
= 0;
1918 aout_symbol_type
*symbase
;
1920 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
1923 for (symbase
= obj_aout_symbols (abfd
);
1924 counter
++ < bfd_get_symcount (abfd
);
1926 *(location
++) = (asymbol
*) (symbase
++);
1928 return bfd_get_symcount (abfd
);
1931 /* Standard reloc stuff. */
1932 /* Output standard relocation information to a file in target byte order. */
1934 extern void NAME (aout
, swap_std_reloc_out
)
1935 (bfd
*, arelent
*, struct reloc_std_external
*);
1938 NAME (aout
, swap_std_reloc_out
) (bfd
*abfd
,
1940 struct reloc_std_external
*natptr
)
1943 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1945 unsigned int r_length
;
1947 int r_baserel
, r_jmptable
, r_relative
;
1948 asection
*output_section
= sym
->section
->output_section
;
1950 PUT_WORD (abfd
, g
->address
, natptr
->r_address
);
1952 r_length
= g
->howto
->size
; /* Size as a power of two. */
1953 r_pcrel
= (int) g
->howto
->pc_relative
; /* Relative to PC? */
1954 /* XXX This relies on relocs coming from a.out files. */
1955 r_baserel
= (g
->howto
->type
& 8) != 0;
1956 r_jmptable
= (g
->howto
->type
& 16) != 0;
1957 r_relative
= (g
->howto
->type
& 32) != 0;
1959 /* Name was clobbered by aout_write_syms to be symbol index. */
1961 /* If this relocation is relative to a symbol then set the
1962 r_index to the symbols index, and the r_extern bit.
1964 Absolute symbols can come in in two ways, either as an offset
1965 from the abs section, or as a symbol which has an abs value.
1966 check for that here. */
1968 if (bfd_is_com_section (output_section
)
1969 || bfd_is_abs_section (output_section
)
1970 || bfd_is_und_section (output_section
)
1971 /* PR gas/3041 a.out relocs against weak symbols
1972 must be treated as if they were against externs. */
1973 || (sym
->flags
& BSF_WEAK
))
1975 if (bfd_abs_section_ptr
->symbol
== sym
)
1977 /* Whoops, looked like an abs symbol, but is
1978 really an offset from the abs section. */
1984 /* Fill in symbol. */
1986 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
1991 /* Just an ordinary section. */
1993 r_index
= output_section
->target_index
;
1996 /* Now the fun stuff. */
1997 if (bfd_header_big_endian (abfd
))
1999 natptr
->r_index
[0] = r_index
>> 16;
2000 natptr
->r_index
[1] = r_index
>> 8;
2001 natptr
->r_index
[2] = r_index
;
2002 natptr
->r_type
[0] = ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
2003 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
2004 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
2005 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
2006 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
2007 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
2011 natptr
->r_index
[2] = r_index
>> 16;
2012 natptr
->r_index
[1] = r_index
>> 8;
2013 natptr
->r_index
[0] = r_index
;
2014 natptr
->r_type
[0] = ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
2015 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
2016 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
2017 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
2018 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
2019 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
2023 /* Extended stuff. */
2024 /* Output extended relocation information to a file in target byte order. */
2026 extern void NAME (aout
, swap_ext_reloc_out
)
2027 (bfd
*, arelent
*, struct reloc_ext_external
*);
2030 NAME (aout
, swap_ext_reloc_out
) (bfd
*abfd
,
2032 struct reloc_ext_external
*natptr
)
2036 unsigned int r_type
;
2038 asymbol
*sym
= *(g
->sym_ptr_ptr
);
2039 asection
*output_section
= sym
->section
->output_section
;
2041 PUT_WORD (abfd
, g
->address
, natptr
->r_address
);
2043 r_type
= (unsigned int) g
->howto
->type
;
2045 r_addend
= g
->addend
;
2046 if ((sym
->flags
& BSF_SECTION_SYM
) != 0)
2047 r_addend
+= (*(g
->sym_ptr_ptr
))->section
->output_section
->vma
;
2049 /* If this relocation is relative to a symbol then set the
2050 r_index to the symbols index, and the r_extern bit.
2052 Absolute symbols can come in in two ways, either as an offset
2053 from the abs section, or as a symbol which has an abs value.
2054 check for that here. */
2055 if (bfd_is_abs_section (bfd_get_section (sym
)))
2060 else if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2062 if (bfd_is_und_section (bfd_get_section (sym
))
2063 || (sym
->flags
& BSF_GLOBAL
) != 0)
2067 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
2071 /* Just an ordinary section. */
2073 r_index
= output_section
->target_index
;
2076 /* Now the fun stuff. */
2077 if (bfd_header_big_endian (abfd
))
2079 natptr
->r_index
[0] = r_index
>> 16;
2080 natptr
->r_index
[1] = r_index
>> 8;
2081 natptr
->r_index
[2] = r_index
;
2082 natptr
->r_type
[0] = ((r_extern
? RELOC_EXT_BITS_EXTERN_BIG
: 0)
2083 | (r_type
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
2087 natptr
->r_index
[2] = r_index
>> 16;
2088 natptr
->r_index
[1] = r_index
>> 8;
2089 natptr
->r_index
[0] = r_index
;
2090 natptr
->r_type
[0] = ((r_extern
? RELOC_EXT_BITS_EXTERN_LITTLE
: 0)
2091 | (r_type
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
));
2094 PUT_WORD (abfd
, r_addend
, natptr
->r_addend
);
2097 /* BFD deals internally with all things based from the section they're
2098 in. so, something in 10 bytes into a text section with a base of
2099 50 would have a symbol (.text+10) and know .text vma was 50.
2101 Aout keeps all it's symbols based from zero, so the symbol would
2102 contain 60. This macro subs the base of each section from the value
2103 to give the true offset from the section. */
2105 #define MOVE_ADDRESS(ad) \
2108 /* Undefined symbol. */ \
2109 cache_ptr->sym_ptr_ptr = symbols + r_index; \
2110 cache_ptr->addend = ad; \
2114 /* Defined, section relative. Replace symbol with pointer to \
2115 symbol which points to section. */ \
2119 case N_TEXT | N_EXT: \
2120 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
2121 cache_ptr->addend = ad - su->textsec->vma; \
2124 case N_DATA | N_EXT: \
2125 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
2126 cache_ptr->addend = ad - su->datasec->vma; \
2129 case N_BSS | N_EXT: \
2130 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
2131 cache_ptr->addend = ad - su->bsssec->vma; \
2135 case N_ABS | N_EXT: \
2136 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
2137 cache_ptr->addend = ad; \
2143 NAME (aout
, swap_ext_reloc_in
) (bfd
*abfd
,
2144 struct reloc_ext_external
*bytes
,
2147 bfd_size_type symcount
)
2149 unsigned int r_index
;
2151 unsigned int r_type
;
2152 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
2154 cache_ptr
->address
= (GET_SWORD (abfd
, bytes
->r_address
));
2156 /* Now the fun stuff. */
2157 if (bfd_header_big_endian (abfd
))
2159 r_index
= (((unsigned int) bytes
->r_index
[0] << 16)
2160 | ((unsigned int) bytes
->r_index
[1] << 8)
2161 | bytes
->r_index
[2]);
2162 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
2163 r_type
= ((bytes
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
2164 >> RELOC_EXT_BITS_TYPE_SH_BIG
);
2168 r_index
= (((unsigned int) bytes
->r_index
[2] << 16)
2169 | ((unsigned int) bytes
->r_index
[1] << 8)
2170 | bytes
->r_index
[0]);
2171 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
2172 r_type
= ((bytes
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
2173 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
);
2176 if (r_type
< TABLE_SIZE (howto_table_ext
))
2177 cache_ptr
->howto
= howto_table_ext
+ r_type
;
2179 cache_ptr
->howto
= NULL
;
2181 /* Base relative relocs are always against the symbol table,
2182 regardless of the setting of r_extern. r_extern just reflects
2183 whether the symbol the reloc is against is local or global. */
2184 if (r_type
== (unsigned int) RELOC_BASE10
2185 || r_type
== (unsigned int) RELOC_BASE13
2186 || r_type
== (unsigned int) RELOC_BASE22
)
2189 if (r_extern
&& r_index
> symcount
)
2191 /* We could arrange to return an error, but it might be useful
2192 to see the file even if it is bad. */
2197 MOVE_ADDRESS (GET_SWORD (abfd
, bytes
->r_addend
));
2201 NAME (aout
, swap_std_reloc_in
) (bfd
*abfd
,
2202 struct reloc_std_external
*bytes
,
2205 bfd_size_type symcount
)
2207 unsigned int r_index
;
2209 unsigned int r_length
;
2211 int r_baserel
, r_jmptable
, r_relative
;
2212 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
2213 unsigned int howto_idx
;
2215 cache_ptr
->address
= H_GET_32 (abfd
, bytes
->r_address
);
2217 /* Now the fun stuff. */
2218 if (bfd_header_big_endian (abfd
))
2220 r_index
= (((unsigned int) bytes
->r_index
[0] << 16)
2221 | ((unsigned int) bytes
->r_index
[1] << 8)
2222 | bytes
->r_index
[2]);
2223 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
));
2224 r_pcrel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_PCREL_BIG
));
2225 r_baserel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
2226 r_jmptable
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
2227 r_relative
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_RELATIVE_BIG
));
2228 r_length
= ((bytes
->r_type
[0] & RELOC_STD_BITS_LENGTH_BIG
)
2229 >> RELOC_STD_BITS_LENGTH_SH_BIG
);
2233 r_index
= (((unsigned int) bytes
->r_index
[2] << 16)
2234 | ((unsigned int) bytes
->r_index
[1] << 8)
2235 | bytes
->r_index
[0]);
2236 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
));
2237 r_pcrel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_PCREL_LITTLE
));
2238 r_baserel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_BASEREL_LITTLE
));
2239 r_jmptable
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_LITTLE
));
2240 r_relative
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_RELATIVE_LITTLE
));
2241 r_length
= ((bytes
->r_type
[0] & RELOC_STD_BITS_LENGTH_LITTLE
)
2242 >> RELOC_STD_BITS_LENGTH_SH_LITTLE
);
2245 howto_idx
= (r_length
+ 4 * r_pcrel
+ 8 * r_baserel
2246 + 16 * r_jmptable
+ 32 * r_relative
);
2247 if (howto_idx
< TABLE_SIZE (howto_table_std
))
2249 cache_ptr
->howto
= howto_table_std
+ howto_idx
;
2250 if (cache_ptr
->howto
->type
== (unsigned int) -1)
2251 cache_ptr
->howto
= NULL
;
2254 cache_ptr
->howto
= NULL
;
2256 /* Base relative relocs are always against the symbol table,
2257 regardless of the setting of r_extern. r_extern just reflects
2258 whether the symbol the reloc is against is local or global. */
2262 if (r_extern
&& r_index
> symcount
)
2264 /* We could arrange to return an error, but it might be useful
2265 to see the file even if it is bad. */
2273 /* Read and swap the relocs for a section. */
2276 NAME (aout
, slurp_reloc_table
) (bfd
*abfd
, sec_ptr asect
, asymbol
**symbols
)
2278 bfd_size_type count
;
2279 bfd_size_type reloc_size
;
2281 arelent
*reloc_cache
;
2283 unsigned int counter
= 0;
2287 if (asect
->relocation
)
2290 if (asect
->flags
& SEC_CONSTRUCTOR
)
2293 if (asect
== obj_datasec (abfd
))
2294 reloc_size
= exec_hdr (abfd
)->a_drsize
;
2295 else if (asect
== obj_textsec (abfd
))
2296 reloc_size
= exec_hdr (abfd
)->a_trsize
;
2297 else if (asect
== obj_bsssec (abfd
))
2301 bfd_set_error (bfd_error_invalid_operation
);
2305 if (reloc_size
== 0)
2306 return TRUE
; /* Nothing to be done. */
2308 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
2311 each_size
= obj_reloc_entry_size (abfd
);
2313 count
= reloc_size
/ each_size
;
2315 return TRUE
; /* Nothing to be done. */
2317 amt
= count
* sizeof (arelent
);
2318 reloc_cache
= (arelent
*) bfd_zmalloc (amt
);
2319 if (reloc_cache
== NULL
)
2322 relocs
= bfd_malloc (reloc_size
);
2329 if (bfd_bread (relocs
, reloc_size
, abfd
) != reloc_size
)
2336 cache_ptr
= reloc_cache
;
2337 if (each_size
== RELOC_EXT_SIZE
)
2339 struct reloc_ext_external
*rptr
= (struct reloc_ext_external
*) relocs
;
2341 for (; counter
< count
; counter
++, rptr
++, cache_ptr
++)
2342 MY_swap_ext_reloc_in (abfd
, rptr
, cache_ptr
, symbols
,
2343 (bfd_size_type
) bfd_get_symcount (abfd
));
2347 struct reloc_std_external
*rptr
= (struct reloc_std_external
*) relocs
;
2349 for (; counter
< count
; counter
++, rptr
++, cache_ptr
++)
2350 MY_swap_std_reloc_in (abfd
, rptr
, cache_ptr
, symbols
,
2351 (bfd_size_type
) bfd_get_symcount (abfd
));
2356 asect
->relocation
= reloc_cache
;
2357 asect
->reloc_count
= cache_ptr
- reloc_cache
;
2362 /* Write out a relocation section into an object file. */
2365 NAME (aout
, squirt_out_relocs
) (bfd
*abfd
, asection
*section
)
2368 unsigned char *native
, *natptr
;
2371 unsigned int count
= section
->reloc_count
;
2372 bfd_size_type natsize
;
2374 if (count
== 0 || section
->orelocation
== NULL
)
2377 each_size
= obj_reloc_entry_size (abfd
);
2378 natsize
= (bfd_size_type
) each_size
* count
;
2379 native
= (unsigned char *) bfd_zalloc (abfd
, natsize
);
2383 generic
= section
->orelocation
;
2385 if (each_size
== RELOC_EXT_SIZE
)
2387 for (natptr
= native
;
2389 --count
, natptr
+= each_size
, ++generic
)
2390 MY_swap_ext_reloc_out (abfd
, *generic
,
2391 (struct reloc_ext_external
*) natptr
);
2395 for (natptr
= native
;
2397 --count
, natptr
+= each_size
, ++generic
)
2398 MY_swap_std_reloc_out (abfd
, *generic
,
2399 (struct reloc_std_external
*) natptr
);
2402 if (bfd_bwrite ((void *) native
, natsize
, abfd
) != natsize
)
2404 bfd_release (abfd
, native
);
2407 bfd_release (abfd
, native
);
2412 /* This is stupid. This function should be a boolean predicate. */
2415 NAME (aout
, canonicalize_reloc
) (bfd
*abfd
,
2420 arelent
*tblptr
= section
->relocation
;
2423 if (section
== obj_bsssec (abfd
))
2429 if (!(tblptr
|| NAME (aout
, slurp_reloc_table
) (abfd
, section
, symbols
)))
2432 if (section
->flags
& SEC_CONSTRUCTOR
)
2434 arelent_chain
*chain
= section
->constructor_chain
;
2435 for (count
= 0; count
< section
->reloc_count
; count
++)
2437 *relptr
++ = &chain
->relent
;
2438 chain
= chain
->next
;
2443 tblptr
= section
->relocation
;
2445 for (count
= 0; count
++ < section
->reloc_count
; )
2447 *relptr
++ = tblptr
++;
2452 return section
->reloc_count
;
2456 NAME (aout
, get_reloc_upper_bound
) (bfd
*abfd
, sec_ptr asect
)
2458 if (bfd_get_format (abfd
) != bfd_object
)
2460 bfd_set_error (bfd_error_invalid_operation
);
2464 if (asect
->flags
& SEC_CONSTRUCTOR
)
2465 return sizeof (arelent
*) * (asect
->reloc_count
+ 1);
2467 if (asect
== obj_datasec (abfd
))
2468 return sizeof (arelent
*)
2469 * ((exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
))
2472 if (asect
== obj_textsec (abfd
))
2473 return sizeof (arelent
*)
2474 * ((exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
))
2477 if (asect
== obj_bsssec (abfd
))
2478 return sizeof (arelent
*);
2480 if (asect
== obj_bsssec (abfd
))
2483 bfd_set_error (bfd_error_invalid_operation
);
2488 NAME (aout
, get_symtab_upper_bound
) (bfd
*abfd
)
2490 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
2493 return (bfd_get_symcount (abfd
)+1) * (sizeof (aout_symbol_type
*));
2497 NAME (aout
, get_lineno
) (bfd
*ignore_abfd ATTRIBUTE_UNUSED
,
2498 asymbol
*ignore_symbol ATTRIBUTE_UNUSED
)
2504 NAME (aout
, get_symbol_info
) (bfd
*ignore_abfd ATTRIBUTE_UNUSED
,
2508 bfd_symbol_info (symbol
, ret
);
2510 if (ret
->type
== '?')
2512 int type_code
= aout_symbol (symbol
)->type
& 0xff;
2513 const char *stab_name
= bfd_get_stab_name (type_code
);
2514 static char buf
[10];
2516 if (stab_name
== NULL
)
2518 sprintf (buf
, "(%d)", type_code
);
2522 ret
->stab_type
= type_code
;
2523 ret
->stab_other
= (unsigned) (aout_symbol (symbol
)->other
& 0xff);
2524 ret
->stab_desc
= (unsigned) (aout_symbol (symbol
)->desc
& 0xffff);
2525 ret
->stab_name
= stab_name
;
2530 NAME (aout
, print_symbol
) (bfd
*abfd
,
2533 bfd_print_symbol_type how
)
2535 FILE *file
= (FILE *)afile
;
2539 case bfd_print_symbol_name
:
2541 fprintf (file
,"%s", symbol
->name
);
2543 case bfd_print_symbol_more
:
2544 fprintf (file
,"%4x %2x %2x",
2545 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2546 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2547 (unsigned) (aout_symbol (symbol
)->type
));
2549 case bfd_print_symbol_all
:
2551 const char *section_name
= symbol
->section
->name
;
2553 bfd_print_symbol_vandf (abfd
, (void *)file
, symbol
);
2555 fprintf (file
," %-5s %04x %02x %02x",
2557 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2558 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2559 (unsigned) (aout_symbol (symbol
)->type
& 0xff));
2561 fprintf (file
," %s", symbol
->name
);
2567 /* If we don't have to allocate more than 1MB to hold the generic
2568 symbols, we use the generic minisymbol methord: it's faster, since
2569 it only translates the symbols once, not multiple times. */
2570 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2572 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2573 symbols. The minisymbol_to_symbol function translates these into
2574 BFD asymbol structures. */
2577 NAME (aout
, read_minisymbols
) (bfd
*abfd
,
2578 bfd_boolean dynamic
,
2580 unsigned int *sizep
)
2583 /* We could handle the dynamic symbols here as well, but it's
2584 easier to hand them off. */
2585 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2587 if (! aout_get_external_symbols (abfd
))
2590 if (obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2591 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2593 *minisymsp
= (void *) obj_aout_external_syms (abfd
);
2595 /* By passing the external symbols back from this routine, we are
2596 giving up control over the memory block. Clear
2597 obj_aout_external_syms, so that we do not try to free it
2599 obj_aout_external_syms (abfd
) = NULL
;
2601 *sizep
= EXTERNAL_NLIST_SIZE
;
2602 return obj_aout_external_sym_count (abfd
);
2605 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2606 unmodified a.out symbol. The SYM argument is a structure returned
2607 by bfd_make_empty_symbol, which we fill in here. */
2610 NAME (aout
, minisymbol_to_symbol
) (bfd
*abfd
,
2611 bfd_boolean dynamic
,
2612 const void * minisym
,
2616 || obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2617 return _bfd_generic_minisymbol_to_symbol (abfd
, dynamic
, minisym
, sym
);
2619 memset (sym
, 0, sizeof (aout_symbol_type
));
2621 /* We call translate_symbol_table to translate a single symbol. */
2622 if (! (NAME (aout
, translate_symbol_table
)
2624 (aout_symbol_type
*) sym
,
2625 (struct external_nlist
*) minisym
,
2627 obj_aout_external_strings (abfd
),
2628 obj_aout_external_string_size (abfd
),
2635 /* Provided a BFD, a section and an offset into the section, calculate
2636 and return the name of the source file and the line nearest to the
2640 NAME (aout
, find_nearest_line
) (bfd
*abfd
,
2644 const char **filename_ptr
,
2645 const char **functionname_ptr
,
2646 unsigned int *line_ptr
)
2648 /* Run down the file looking for the filename, function and linenumber. */
2650 const char *directory_name
= NULL
;
2651 const char *main_file_name
= NULL
;
2652 const char *current_file_name
= NULL
;
2653 const char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2654 const char *line_directory_name
= NULL
; /* Value of directory_name at line number. */
2655 bfd_vma low_line_vma
= 0;
2656 bfd_vma low_func_vma
= 0;
2658 bfd_size_type filelen
, funclen
;
2661 *filename_ptr
= abfd
->filename
;
2662 *functionname_ptr
= 0;
2665 if (symbols
!= NULL
)
2667 for (p
= symbols
; *p
; p
++)
2669 aout_symbol_type
*q
= (aout_symbol_type
*) (*p
);
2674 /* If this looks like a file name symbol, and it comes after
2675 the line number we have found so far, but before the
2676 offset, then we have probably not found the right line
2678 if (q
->symbol
.value
<= offset
2679 && ((q
->symbol
.value
> low_line_vma
2680 && (line_file_name
!= NULL
2682 || (q
->symbol
.value
> low_func_vma
2685 const char *symname
;
2687 symname
= q
->symbol
.name
;
2688 if (strcmp (symname
+ strlen (symname
) - 2, ".o") == 0)
2690 if (q
->symbol
.value
> low_line_vma
)
2693 line_file_name
= NULL
;
2695 if (q
->symbol
.value
> low_func_vma
)
2702 /* If this symbol is less than the offset, but greater than
2703 the line number we have found so far, then we have not
2704 found the right line number. */
2705 if (q
->symbol
.value
<= offset
)
2707 if (q
->symbol
.value
> low_line_vma
)
2710 line_file_name
= NULL
;
2712 if (q
->symbol
.value
> low_func_vma
)
2716 main_file_name
= current_file_name
= q
->symbol
.name
;
2717 /* Look ahead to next symbol to check if that too is an N_SO. */
2721 q
= (aout_symbol_type
*) (*p
);
2722 if (q
->type
!= (int)N_SO
)
2725 /* Found a second N_SO First is directory; second is filename. */
2726 directory_name
= current_file_name
;
2727 main_file_name
= current_file_name
= q
->symbol
.name
;
2728 if (obj_textsec (abfd
) != section
)
2732 current_file_name
= q
->symbol
.name
;
2739 /* We'll keep this if it resolves nearer than the one we have
2741 if (q
->symbol
.value
>= low_line_vma
2742 && q
->symbol
.value
<= offset
)
2744 *line_ptr
= q
->desc
;
2745 low_line_vma
= q
->symbol
.value
;
2746 line_file_name
= current_file_name
;
2747 line_directory_name
= directory_name
;
2752 /* We'll keep this if it is nearer than the one we have already. */
2753 if (q
->symbol
.value
>= low_func_vma
&&
2754 q
->symbol
.value
<= offset
)
2756 low_func_vma
= q
->symbol
.value
;
2757 func
= (asymbol
*)q
;
2759 else if (q
->symbol
.value
> offset
)
2770 main_file_name
= line_file_name
;
2771 directory_name
= line_directory_name
;
2774 if (main_file_name
== NULL
2775 || IS_ABSOLUTE_PATH (main_file_name
)
2776 || directory_name
== NULL
)
2779 filelen
= strlen (directory_name
) + strlen (main_file_name
);
2784 funclen
= strlen (bfd_asymbol_name (func
));
2786 if (adata (abfd
).line_buf
!= NULL
)
2787 free (adata (abfd
).line_buf
);
2789 if (filelen
+ funclen
== 0)
2790 adata (abfd
).line_buf
= buf
= NULL
;
2793 buf
= (char *) bfd_malloc (filelen
+ funclen
+ 3);
2794 adata (abfd
).line_buf
= buf
;
2799 if (main_file_name
!= NULL
)
2801 if (IS_ABSOLUTE_PATH (main_file_name
) || directory_name
== NULL
)
2802 *filename_ptr
= main_file_name
;
2805 sprintf (buf
, "%s%s", directory_name
, main_file_name
);
2806 *filename_ptr
= buf
;
2813 const char *function
= func
->name
;
2816 /* The caller expects a symbol name. We actually have a
2817 function name, without the leading underscore. Put the
2818 underscore back in, so that the caller gets a symbol name. */
2819 if (bfd_get_symbol_leading_char (abfd
) == '\0')
2820 strcpy (buf
, function
);
2823 buf
[0] = bfd_get_symbol_leading_char (abfd
);
2824 strcpy (buf
+ 1, function
);
2826 /* Have to remove : stuff. */
2827 colon
= strchr (buf
, ':');
2830 *functionname_ptr
= buf
;
2837 NAME (aout
, sizeof_headers
) (bfd
*abfd
,
2838 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2840 return adata (abfd
).exec_bytes_size
;
2843 /* Free all information we have cached for this BFD. We can always
2844 read it again later if we need it. */
2847 NAME (aout
, bfd_free_cached_info
) (bfd
*abfd
)
2851 if (bfd_get_format (abfd
) != bfd_object
2852 || abfd
->tdata
.aout_data
== NULL
)
2855 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2856 BFCI_FREE (obj_aout_symbols (abfd
));
2858 obj_aout_external_syms (abfd
) = 0;
2859 bfd_free_window (&obj_aout_sym_window (abfd
));
2860 bfd_free_window (&obj_aout_string_window (abfd
));
2861 obj_aout_external_strings (abfd
) = 0;
2863 BFCI_FREE (obj_aout_external_syms (abfd
));
2864 BFCI_FREE (obj_aout_external_strings (abfd
));
2866 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2867 BFCI_FREE (o
->relocation
);
2873 /* a.out link code. */
2875 /* Routine to create an entry in an a.out link hash table. */
2877 struct bfd_hash_entry
*
2878 NAME (aout
, link_hash_newfunc
) (struct bfd_hash_entry
*entry
,
2879 struct bfd_hash_table
*table
,
2882 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2884 /* Allocate the structure if it has not already been allocated by a
2887 ret
= (struct aout_link_hash_entry
*) bfd_hash_allocate (table
,
2892 /* Call the allocation method of the superclass. */
2893 ret
= ((struct aout_link_hash_entry
*)
2894 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2898 /* Set local fields. */
2899 ret
->written
= FALSE
;
2903 return (struct bfd_hash_entry
*) ret
;
2906 /* Initialize an a.out link hash table. */
2909 NAME (aout
, link_hash_table_init
) (struct aout_link_hash_table
*table
,
2911 struct bfd_hash_entry
*(*newfunc
)
2912 (struct bfd_hash_entry
*, struct bfd_hash_table
*,
2914 unsigned int entsize
)
2916 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
2919 /* Create an a.out link hash table. */
2921 struct bfd_link_hash_table
*
2922 NAME (aout
, link_hash_table_create
) (bfd
*abfd
)
2924 struct aout_link_hash_table
*ret
;
2925 bfd_size_type amt
= sizeof (* ret
);
2927 ret
= (struct aout_link_hash_table
*) bfd_malloc (amt
);
2931 if (!NAME (aout
, link_hash_table_init
) (ret
, abfd
,
2932 NAME (aout
, link_hash_newfunc
),
2933 sizeof (struct aout_link_hash_entry
)))
2941 /* Add all symbols from an object file to the hash table. */
2944 aout_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2946 bfd_boolean (*add_one_symbol
)
2947 (struct bfd_link_info
*, bfd
*, const char *, flagword
, asection
*,
2948 bfd_vma
, const char *, bfd_boolean
, bfd_boolean
,
2949 struct bfd_link_hash_entry
**);
2950 struct external_nlist
*syms
;
2951 bfd_size_type sym_count
;
2954 struct aout_link_hash_entry
**sym_hash
;
2955 struct external_nlist
*p
;
2956 struct external_nlist
*pend
;
2959 syms
= obj_aout_external_syms (abfd
);
2960 sym_count
= obj_aout_external_sym_count (abfd
);
2961 strings
= obj_aout_external_strings (abfd
);
2962 if (info
->keep_memory
)
2967 if (aout_backend_info (abfd
)->add_dynamic_symbols
!= NULL
)
2969 if (! ((*aout_backend_info (abfd
)->add_dynamic_symbols
)
2970 (abfd
, info
, &syms
, &sym_count
, &strings
)))
2975 return TRUE
; /* Nothing to do. */
2977 /* We keep a list of the linker hash table entries that correspond
2978 to particular symbols. We could just look them up in the hash
2979 table, but keeping the list is more efficient. Perhaps this
2980 should be conditional on info->keep_memory. */
2981 amt
= sym_count
* sizeof (struct aout_link_hash_entry
*);
2982 sym_hash
= (struct aout_link_hash_entry
**) bfd_alloc (abfd
, amt
);
2983 if (sym_hash
== NULL
)
2985 obj_aout_sym_hashes (abfd
) = sym_hash
;
2987 add_one_symbol
= aout_backend_info (abfd
)->add_one_symbol
;
2988 if (add_one_symbol
== NULL
)
2989 add_one_symbol
= _bfd_generic_link_add_one_symbol
;
2992 pend
= p
+ sym_count
;
2993 for (; p
< pend
; p
++, sym_hash
++)
3004 type
= H_GET_8 (abfd
, p
->e_type
);
3006 /* Ignore debugging symbols. */
3007 if ((type
& N_STAB
) != 0)
3010 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3011 value
= GET_WORD (abfd
, p
->e_value
);
3028 /* Ignore symbols that are not externally visible. */
3031 /* Ignore local indirect symbol. */
3036 case N_UNDF
| N_EXT
:
3039 section
= bfd_und_section_ptr
;
3043 section
= bfd_com_section_ptr
;
3046 section
= bfd_abs_section_ptr
;
3048 case N_TEXT
| N_EXT
:
3049 section
= obj_textsec (abfd
);
3050 value
-= bfd_get_section_vma (abfd
, section
);
3052 case N_DATA
| N_EXT
:
3053 case N_SETV
| N_EXT
:
3054 /* Treat N_SETV symbols as N_DATA symbol; see comment in
3055 translate_from_native_sym_flags. */
3056 section
= obj_datasec (abfd
);
3057 value
-= bfd_get_section_vma (abfd
, section
);
3060 section
= obj_bsssec (abfd
);
3061 value
-= bfd_get_section_vma (abfd
, section
);
3063 case N_INDR
| N_EXT
:
3064 /* An indirect symbol. The next symbol is the symbol
3065 which this one really is. */
3066 BFD_ASSERT (p
+ 1 < pend
);
3068 string
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3069 section
= bfd_ind_section_ptr
;
3070 flags
|= BSF_INDIRECT
;
3072 case N_COMM
| N_EXT
:
3073 section
= bfd_com_section_ptr
;
3075 case N_SETA
: case N_SETA
| N_EXT
:
3076 section
= bfd_abs_section_ptr
;
3077 flags
|= BSF_CONSTRUCTOR
;
3079 case N_SETT
: case N_SETT
| N_EXT
:
3080 section
= obj_textsec (abfd
);
3081 flags
|= BSF_CONSTRUCTOR
;
3082 value
-= bfd_get_section_vma (abfd
, section
);
3084 case N_SETD
: case N_SETD
| N_EXT
:
3085 section
= obj_datasec (abfd
);
3086 flags
|= BSF_CONSTRUCTOR
;
3087 value
-= bfd_get_section_vma (abfd
, section
);
3089 case N_SETB
: case N_SETB
| N_EXT
:
3090 section
= obj_bsssec (abfd
);
3091 flags
|= BSF_CONSTRUCTOR
;
3092 value
-= bfd_get_section_vma (abfd
, section
);
3095 /* A warning symbol. The next symbol is the one to warn
3096 about. If there is no next symbol, just look away. */
3101 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3102 section
= bfd_und_section_ptr
;
3103 flags
|= BSF_WARNING
;
3106 section
= bfd_und_section_ptr
;
3110 section
= bfd_abs_section_ptr
;
3114 section
= obj_textsec (abfd
);
3115 value
-= bfd_get_section_vma (abfd
, section
);
3119 section
= obj_datasec (abfd
);
3120 value
-= bfd_get_section_vma (abfd
, section
);
3124 section
= obj_bsssec (abfd
);
3125 value
-= bfd_get_section_vma (abfd
, section
);
3130 if (! ((*add_one_symbol
)
3131 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, FALSE
,
3132 (struct bfd_link_hash_entry
**) sym_hash
)))
3135 /* Restrict the maximum alignment of a common symbol based on
3136 the architecture, since a.out has no way to represent
3137 alignment requirements of a section in a .o file. FIXME:
3138 This isn't quite right: it should use the architecture of the
3139 output file, not the input files. */
3140 if ((*sym_hash
)->root
.type
== bfd_link_hash_common
3141 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
>
3142 bfd_get_arch_info (abfd
)->section_align_power
))
3143 (*sym_hash
)->root
.u
.c
.p
->alignment_power
=
3144 bfd_get_arch_info (abfd
)->section_align_power
;
3146 /* If this is a set symbol, and we are not building sets, then
3147 it is possible for the hash entry to not have been set. In
3148 such a case, treat the symbol as not globally defined. */
3149 if ((*sym_hash
)->root
.type
== bfd_link_hash_new
)
3151 BFD_ASSERT ((flags
& BSF_CONSTRUCTOR
) != 0);
3155 if (type
== (N_INDR
| N_EXT
) || type
== N_WARNING
)
3162 /* Free up the internal symbols read from an a.out file. */
3165 aout_link_free_symbols (bfd
*abfd
)
3167 if (obj_aout_external_syms (abfd
) != NULL
)
3170 bfd_free_window (&obj_aout_sym_window (abfd
));
3172 free ((void *) obj_aout_external_syms (abfd
));
3174 obj_aout_external_syms (abfd
) = NULL
;
3176 if (obj_aout_external_strings (abfd
) != NULL
)
3179 bfd_free_window (&obj_aout_string_window (abfd
));
3181 free ((void *) obj_aout_external_strings (abfd
));
3183 obj_aout_external_strings (abfd
) = NULL
;
3188 /* Add symbols from an a.out object file. */
3191 aout_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3193 if (! aout_get_external_symbols (abfd
))
3195 if (! aout_link_add_symbols (abfd
, info
))
3197 if (! info
->keep_memory
)
3199 if (! aout_link_free_symbols (abfd
))
3205 /* Look through the internal symbols to see if this object file should
3206 be included in the link. We should include this object file if it
3207 defines any symbols which are currently undefined. If this object
3208 file defines a common symbol, then we may adjust the size of the
3209 known symbol but we do not include the object file in the link
3210 (unless there is some other reason to include it). */
3213 aout_link_check_ar_symbols (bfd
*abfd
,
3214 struct bfd_link_info
*info
,
3215 bfd_boolean
*pneeded
,
3218 struct external_nlist
*p
;
3219 struct external_nlist
*pend
;
3224 /* Look through all the symbols. */
3225 p
= obj_aout_external_syms (abfd
);
3226 pend
= p
+ obj_aout_external_sym_count (abfd
);
3227 strings
= obj_aout_external_strings (abfd
);
3228 for (; p
< pend
; p
++)
3230 int type
= H_GET_8 (abfd
, p
->e_type
);
3232 struct bfd_link_hash_entry
*h
;
3234 /* Ignore symbols that are not externally visible. This is an
3235 optimization only, as we check the type more thoroughly
3237 if (((type
& N_EXT
) == 0
3238 || (type
& N_STAB
) != 0
3245 if (type
== N_WARNING
3251 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3252 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
3254 /* We are only interested in symbols that are currently
3255 undefined or common. */
3257 || (h
->type
!= bfd_link_hash_undefined
3258 && h
->type
!= bfd_link_hash_common
))
3260 if (type
== (N_INDR
| N_EXT
))
3265 if (type
== (N_TEXT
| N_EXT
)
3266 || type
== (N_DATA
| N_EXT
)
3267 || type
== (N_BSS
| N_EXT
)
3268 || type
== (N_ABS
| N_EXT
)
3269 || type
== (N_INDR
| N_EXT
))
3271 /* This object file defines this symbol. We must link it
3272 in. This is true regardless of whether the current
3273 definition of the symbol is undefined or common.
3275 If the current definition is common, we have a case in
3276 which we have already seen an object file including:
3278 and this object file from the archive includes:
3280 In such a case, whether to include this object is target
3281 dependant for backward compatibility.
3283 FIXME: The SunOS 4.1.3 linker will pull in the archive
3284 element if the symbol is defined in the .data section,
3285 but not if it is defined in the .text section. That
3286 seems a bit crazy to me, and it has not been implemented
3287 yet. However, it might be correct. */
3288 if (h
->type
== bfd_link_hash_common
)
3292 switch (info
->common_skip_ar_symbols
)
3294 case bfd_link_common_skip_text
:
3295 skip
= (type
== (N_TEXT
| N_EXT
));
3297 case bfd_link_common_skip_data
:
3298 skip
= (type
== (N_DATA
| N_EXT
));
3301 case bfd_link_common_skip_all
:
3310 if (!(*info
->callbacks
3311 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
3317 if (type
== (N_UNDF
| N_EXT
))
3321 value
= GET_WORD (abfd
, p
->e_value
);
3324 /* This symbol is common in the object from the archive
3326 if (h
->type
== bfd_link_hash_undefined
)
3331 symbfd
= h
->u
.undef
.abfd
;
3334 /* This symbol was created as undefined from
3335 outside BFD. We assume that we should link
3336 in the object file. This is done for the -u
3337 option in the linker. */
3338 if (!(*info
->callbacks
3339 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
3344 /* Turn the current link symbol into a common
3345 symbol. It is already on the undefs list. */
3346 h
->type
= bfd_link_hash_common
;
3347 h
->u
.c
.p
= (struct bfd_link_hash_common_entry
*)
3348 bfd_hash_allocate (&info
->hash
->table
,
3349 sizeof (struct bfd_link_hash_common_entry
));
3350 if (h
->u
.c
.p
== NULL
)
3353 h
->u
.c
.size
= value
;
3355 /* FIXME: This isn't quite right. The maximum
3356 alignment of a common symbol should be set by the
3357 architecture of the output file, not of the input
3359 power
= bfd_log2 (value
);
3360 if (power
> bfd_get_arch_info (abfd
)->section_align_power
)
3361 power
= bfd_get_arch_info (abfd
)->section_align_power
;
3362 h
->u
.c
.p
->alignment_power
= power
;
3364 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
,
3369 /* Adjust the size of the common symbol if
3371 if (value
> h
->u
.c
.size
)
3372 h
->u
.c
.size
= value
;
3382 /* This symbol is weak but defined. We must pull it in if
3383 the current link symbol is undefined, but we don't want
3384 it if the current link symbol is common. */
3385 if (h
->type
== bfd_link_hash_undefined
)
3387 if (!(*info
->callbacks
3388 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
3396 /* We do not need this object file. */
3399 /* Check a single archive element to see if we need to include it in
3400 the link. *PNEEDED is set according to whether this element is
3401 needed in the link or not. This is called from
3402 _bfd_generic_link_add_archive_symbols. */
3405 aout_link_check_archive_element (bfd
*abfd
,
3406 struct bfd_link_info
*info
,
3407 struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
3408 const char *name ATTRIBUTE_UNUSED
,
3409 bfd_boolean
*pneeded
)
3414 if (!aout_get_external_symbols (abfd
))
3418 if (!aout_link_check_ar_symbols (abfd
, info
, pneeded
, &abfd
))
3424 /* Potentially, the add_archive_element hook may have set a
3425 substitute BFD for us. */
3428 if (!info
->keep_memory
3429 && !aout_link_free_symbols (oldbfd
))
3431 if (!aout_get_external_symbols (abfd
))
3434 if (!aout_link_add_symbols (abfd
, info
))
3438 if (!info
->keep_memory
|| !needed
)
3440 if (!aout_link_free_symbols (abfd
))
3447 /* Given an a.out BFD, add symbols to the global hash table as
3451 NAME (aout
, link_add_symbols
) (bfd
*abfd
, struct bfd_link_info
*info
)
3453 switch (bfd_get_format (abfd
))
3456 return aout_link_add_object_symbols (abfd
, info
);
3458 return _bfd_generic_link_add_archive_symbols
3459 (abfd
, info
, aout_link_check_archive_element
);
3461 bfd_set_error (bfd_error_wrong_format
);
3466 /* A hash table used for header files with N_BINCL entries. */
3468 struct aout_link_includes_table
3470 struct bfd_hash_table root
;
3473 /* A linked list of totals that we have found for a particular header
3476 struct aout_link_includes_totals
3478 struct aout_link_includes_totals
*next
;
3482 /* An entry in the header file hash table. */
3484 struct aout_link_includes_entry
3486 struct bfd_hash_entry root
;
3487 /* List of totals we have found for this file. */
3488 struct aout_link_includes_totals
*totals
;
3491 /* Look up an entry in an the header file hash table. */
3493 #define aout_link_includes_lookup(table, string, create, copy) \
3494 ((struct aout_link_includes_entry *) \
3495 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3497 /* During the final link step we need to pass around a bunch of
3498 information, so we do it in an instance of this structure. */
3500 struct aout_final_link_info
3502 /* General link information. */
3503 struct bfd_link_info
*info
;
3506 /* Reloc file positions. */
3507 file_ptr treloff
, dreloff
;
3508 /* File position of symbols. */
3511 struct bfd_strtab_hash
*strtab
;
3512 /* Header file hash table. */
3513 struct aout_link_includes_table includes
;
3514 /* A buffer large enough to hold the contents of any section. */
3516 /* A buffer large enough to hold the relocs of any section. */
3518 /* A buffer large enough to hold the symbol map of any input BFD. */
3520 /* A buffer large enough to hold output symbols of any input BFD. */
3521 struct external_nlist
*output_syms
;
3524 /* The function to create a new entry in the header file hash table. */
3526 static struct bfd_hash_entry
*
3527 aout_link_includes_newfunc (struct bfd_hash_entry
*entry
,
3528 struct bfd_hash_table
*table
,
3531 struct aout_link_includes_entry
*ret
=
3532 (struct aout_link_includes_entry
*) entry
;
3534 /* Allocate the structure if it has not already been allocated by a
3537 ret
= (struct aout_link_includes_entry
*)
3538 bfd_hash_allocate (table
, sizeof (* ret
));
3542 /* Call the allocation method of the superclass. */
3543 ret
= ((struct aout_link_includes_entry
*)
3544 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
3547 /* Set local fields. */
3551 return (struct bfd_hash_entry
*) ret
;
3554 /* Write out a symbol that was not associated with an a.out input
3558 aout_link_write_other_symbol (struct bfd_hash_entry
*bh
, void *data
)
3560 struct aout_link_hash_entry
*h
= (struct aout_link_hash_entry
*) bh
;
3561 struct aout_final_link_info
*flaginfo
= (struct aout_final_link_info
*) data
;
3565 struct external_nlist outsym
;
3569 if (h
->root
.type
== bfd_link_hash_warning
)
3571 h
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
3572 if (h
->root
.type
== bfd_link_hash_new
)
3576 output_bfd
= flaginfo
->output_bfd
;
3578 if (aout_backend_info (output_bfd
)->write_dynamic_symbol
!= NULL
)
3580 if (! ((*aout_backend_info (output_bfd
)->write_dynamic_symbol
)
3581 (output_bfd
, flaginfo
->info
, h
)))
3583 /* FIXME: No way to handle errors. */
3593 /* An indx of -2 means the symbol must be written. */
3595 && (flaginfo
->info
->strip
== strip_all
3596 || (flaginfo
->info
->strip
== strip_some
3597 && bfd_hash_lookup (flaginfo
->info
->keep_hash
, h
->root
.root
.string
,
3598 FALSE
, FALSE
) == NULL
)))
3601 switch (h
->root
.type
)
3604 case bfd_link_hash_warning
:
3606 /* Avoid variable not initialized warnings. */
3608 case bfd_link_hash_new
:
3609 /* This can happen for set symbols when sets are not being
3612 case bfd_link_hash_undefined
:
3613 type
= N_UNDF
| N_EXT
;
3616 case bfd_link_hash_defined
:
3617 case bfd_link_hash_defweak
:
3621 sec
= h
->root
.u
.def
.section
->output_section
;
3622 BFD_ASSERT (bfd_is_abs_section (sec
)
3623 || sec
->owner
== output_bfd
);
3624 if (sec
== obj_textsec (output_bfd
))
3625 type
= h
->root
.type
== bfd_link_hash_defined
? N_TEXT
: N_WEAKT
;
3626 else if (sec
== obj_datasec (output_bfd
))
3627 type
= h
->root
.type
== bfd_link_hash_defined
? N_DATA
: N_WEAKD
;
3628 else if (sec
== obj_bsssec (output_bfd
))
3629 type
= h
->root
.type
== bfd_link_hash_defined
? N_BSS
: N_WEAKB
;
3631 type
= h
->root
.type
== bfd_link_hash_defined
? N_ABS
: N_WEAKA
;
3633 val
= (h
->root
.u
.def
.value
3635 + h
->root
.u
.def
.section
->output_offset
);
3638 case bfd_link_hash_common
:
3639 type
= N_UNDF
| N_EXT
;
3640 val
= h
->root
.u
.c
.size
;
3642 case bfd_link_hash_undefweak
:
3646 case bfd_link_hash_indirect
:
3647 /* We ignore these symbols, since the indirected symbol is
3648 already in the hash table. */
3652 H_PUT_8 (output_bfd
, type
, outsym
.e_type
);
3653 H_PUT_8 (output_bfd
, 0, outsym
.e_other
);
3654 H_PUT_16 (output_bfd
, 0, outsym
.e_desc
);
3655 indx
= add_to_stringtab (output_bfd
, flaginfo
->strtab
, h
->root
.root
.string
,
3657 if (indx
== - (bfd_size_type
) 1)
3658 /* FIXME: No way to handle errors. */
3661 PUT_WORD (output_bfd
, indx
, outsym
.e_strx
);
3662 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
3664 amt
= EXTERNAL_NLIST_SIZE
;
3665 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0
3666 || bfd_bwrite ((void *) &outsym
, amt
, output_bfd
) != amt
)
3667 /* FIXME: No way to handle errors. */
3670 flaginfo
->symoff
+= EXTERNAL_NLIST_SIZE
;
3671 h
->indx
= obj_aout_external_sym_count (output_bfd
);
3672 ++obj_aout_external_sym_count (output_bfd
);
3677 /* Handle a link order which is supposed to generate a reloc. */
3680 aout_link_reloc_link_order (struct aout_final_link_info
*flaginfo
,
3682 struct bfd_link_order
*p
)
3684 struct bfd_link_order_reloc
*pr
;
3687 reloc_howto_type
*howto
;
3688 file_ptr
*reloff_ptr
= NULL
;
3689 struct reloc_std_external srel
;
3690 struct reloc_ext_external erel
;
3696 if (p
->type
== bfd_section_reloc_link_order
)
3699 if (bfd_is_abs_section (pr
->u
.section
))
3700 r_index
= N_ABS
| N_EXT
;
3703 BFD_ASSERT (pr
->u
.section
->owner
== flaginfo
->output_bfd
);
3704 r_index
= pr
->u
.section
->target_index
;
3709 struct aout_link_hash_entry
*h
;
3711 BFD_ASSERT (p
->type
== bfd_symbol_reloc_link_order
);
3713 h
= ((struct aout_link_hash_entry
*)
3714 bfd_wrapped_link_hash_lookup (flaginfo
->output_bfd
, flaginfo
->info
,
3715 pr
->u
.name
, FALSE
, FALSE
, TRUE
));
3721 /* We decided to strip this symbol, but it turns out that we
3722 can't. Note that we lose the other and desc information
3723 here. I don't think that will ever matter for a global
3727 if (!aout_link_write_other_symbol (&h
->root
.root
, flaginfo
))
3733 if (! ((*flaginfo
->info
->callbacks
->unattached_reloc
)
3734 (flaginfo
->info
, pr
->u
.name
, NULL
, NULL
, (bfd_vma
) 0)))
3740 howto
= bfd_reloc_type_lookup (flaginfo
->output_bfd
, pr
->reloc
);
3743 bfd_set_error (bfd_error_bad_value
);
3747 if (o
== obj_textsec (flaginfo
->output_bfd
))
3748 reloff_ptr
= &flaginfo
->treloff
;
3749 else if (o
== obj_datasec (flaginfo
->output_bfd
))
3750 reloff_ptr
= &flaginfo
->dreloff
;
3754 if (obj_reloc_entry_size (flaginfo
->output_bfd
) == RELOC_STD_SIZE
)
3757 MY_put_reloc (flaginfo
->output_bfd
, r_extern
, r_index
, p
->offset
, howto
,
3767 r_pcrel
= (int) howto
->pc_relative
;
3768 r_baserel
= (howto
->type
& 8) != 0;
3769 r_jmptable
= (howto
->type
& 16) != 0;
3770 r_relative
= (howto
->type
& 32) != 0;
3771 r_length
= howto
->size
;
3773 PUT_WORD (flaginfo
->output_bfd
, p
->offset
, srel
.r_address
);
3774 if (bfd_header_big_endian (flaginfo
->output_bfd
))
3776 srel
.r_index
[0] = r_index
>> 16;
3777 srel
.r_index
[1] = r_index
>> 8;
3778 srel
.r_index
[2] = r_index
;
3780 ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
3781 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
3782 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
3783 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
3784 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
3785 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
3789 srel
.r_index
[2] = r_index
>> 16;
3790 srel
.r_index
[1] = r_index
>> 8;
3791 srel
.r_index
[0] = r_index
;
3793 ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
3794 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
3795 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
3796 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
3797 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
3798 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
3802 rel_ptr
= (void *) &srel
;
3804 /* We have to write the addend into the object file, since
3805 standard a.out relocs are in place. It would be more
3806 reliable if we had the current contents of the file here,
3807 rather than assuming zeroes, but we can't read the file since
3808 it was opened using bfd_openw. */
3809 if (pr
->addend
!= 0)
3812 bfd_reloc_status_type r
;
3816 size
= bfd_get_reloc_size (howto
);
3817 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3820 r
= MY_relocate_contents (howto
, flaginfo
->output_bfd
,
3821 (bfd_vma
) pr
->addend
, buf
);
3827 case bfd_reloc_outofrange
:
3829 case bfd_reloc_overflow
:
3830 if (! ((*flaginfo
->info
->callbacks
->reloc_overflow
)
3831 (flaginfo
->info
, NULL
,
3832 (p
->type
== bfd_section_reloc_link_order
3833 ? bfd_section_name (flaginfo
->output_bfd
,
3836 howto
->name
, pr
->addend
, NULL
, NULL
, (bfd_vma
) 0)))
3843 ok
= bfd_set_section_contents (flaginfo
->output_bfd
, o
, (void *) buf
,
3844 (file_ptr
) p
->offset
, size
);
3852 #ifdef MY_put_ext_reloc
3853 MY_put_ext_reloc (flaginfo
->output_bfd
, r_extern
, r_index
, p
->offset
,
3854 howto
, &erel
, pr
->addend
);
3856 PUT_WORD (flaginfo
->output_bfd
, p
->offset
, erel
.r_address
);
3858 if (bfd_header_big_endian (flaginfo
->output_bfd
))
3860 erel
.r_index
[0] = r_index
>> 16;
3861 erel
.r_index
[1] = r_index
>> 8;
3862 erel
.r_index
[2] = r_index
;
3864 ((r_extern
? RELOC_EXT_BITS_EXTERN_BIG
: 0)
3865 | (howto
->type
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
3869 erel
.r_index
[2] = r_index
>> 16;
3870 erel
.r_index
[1] = r_index
>> 8;
3871 erel
.r_index
[0] = r_index
;
3873 (r_extern
? RELOC_EXT_BITS_EXTERN_LITTLE
: 0)
3874 | (howto
->type
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
);
3877 PUT_WORD (flaginfo
->output_bfd
, (bfd_vma
) pr
->addend
, erel
.r_addend
);
3878 #endif /* MY_put_ext_reloc */
3880 rel_ptr
= (void *) &erel
;
3883 amt
= obj_reloc_entry_size (flaginfo
->output_bfd
);
3884 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0
3885 || bfd_bwrite (rel_ptr
, amt
, flaginfo
->output_bfd
) != amt
)
3888 *reloff_ptr
+= obj_reloc_entry_size (flaginfo
->output_bfd
);
3890 /* Assert that the relocs have not run into the symbols, and that n
3891 the text relocs have not run into the data relocs. */
3892 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3893 && (reloff_ptr
!= &flaginfo
->treloff
3895 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3900 /* Get the section corresponding to a reloc index. */
3902 static INLINE asection
*
3903 aout_reloc_index_to_section (bfd
*abfd
, int indx
)
3905 switch (indx
& N_TYPE
)
3907 case N_TEXT
: return obj_textsec (abfd
);
3908 case N_DATA
: return obj_datasec (abfd
);
3909 case N_BSS
: return obj_bsssec (abfd
);
3911 case N_UNDF
: return bfd_abs_section_ptr
;
3917 /* Relocate an a.out section using standard a.out relocs. */
3920 aout_link_input_section_std (struct aout_final_link_info
*flaginfo
,
3922 asection
*input_section
,
3923 struct reloc_std_external
*relocs
,
3924 bfd_size_type rel_size
,
3927 bfd_boolean (*check_dynamic_reloc
)
3928 (struct bfd_link_info
*, bfd
*, asection
*,
3929 struct aout_link_hash_entry
*, void *, bfd_byte
*, bfd_boolean
*,
3932 bfd_boolean relocatable
;
3933 struct external_nlist
*syms
;
3935 struct aout_link_hash_entry
**sym_hashes
;
3937 bfd_size_type reloc_count
;
3938 struct reloc_std_external
*rel
;
3939 struct reloc_std_external
*rel_end
;
3941 output_bfd
= flaginfo
->output_bfd
;
3942 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
3944 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
);
3945 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
3946 == output_bfd
->xvec
->header_byteorder
);
3948 relocatable
= flaginfo
->info
->relocatable
;
3949 syms
= obj_aout_external_syms (input_bfd
);
3950 strings
= obj_aout_external_strings (input_bfd
);
3951 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
3952 symbol_map
= flaginfo
->symbol_map
;
3954 reloc_count
= rel_size
/ RELOC_STD_SIZE
;
3956 rel_end
= rel
+ reloc_count
;
3957 for (; rel
< rel_end
; rel
++)
3964 reloc_howto_type
*howto
;
3965 struct aout_link_hash_entry
*h
= NULL
;
3967 bfd_reloc_status_type r
;
3969 r_addr
= GET_SWORD (input_bfd
, rel
->r_address
);
3971 #ifdef MY_reloc_howto
3972 howto
= MY_reloc_howto (input_bfd
, rel
, r_index
, r_extern
, r_pcrel
);
3978 unsigned int howto_idx
;
3980 if (bfd_header_big_endian (input_bfd
))
3982 r_index
= (((unsigned int) rel
->r_index
[0] << 16)
3983 | ((unsigned int) rel
->r_index
[1] << 8)
3985 r_extern
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
));
3986 r_pcrel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_PCREL_BIG
));
3987 r_baserel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
3988 r_jmptable
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
3989 r_relative
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_RELATIVE_BIG
));
3990 r_length
= ((rel
->r_type
[0] & RELOC_STD_BITS_LENGTH_BIG
)
3991 >> RELOC_STD_BITS_LENGTH_SH_BIG
);
3995 r_index
= (((unsigned int) rel
->r_index
[2] << 16)
3996 | ((unsigned int) rel
->r_index
[1] << 8)
3998 r_extern
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
));
3999 r_pcrel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_PCREL_LITTLE
));
4000 r_baserel
= (0 != (rel
->r_type
[0]
4001 & RELOC_STD_BITS_BASEREL_LITTLE
));
4002 r_jmptable
= (0 != (rel
->r_type
[0]
4003 & RELOC_STD_BITS_JMPTABLE_LITTLE
));
4004 r_relative
= (0 != (rel
->r_type
[0]
4005 & RELOC_STD_BITS_RELATIVE_LITTLE
));
4006 r_length
= ((rel
->r_type
[0] & RELOC_STD_BITS_LENGTH_LITTLE
)
4007 >> RELOC_STD_BITS_LENGTH_SH_LITTLE
);
4010 howto_idx
= (r_length
+ 4 * r_pcrel
+ 8 * r_baserel
4011 + 16 * r_jmptable
+ 32 * r_relative
);
4012 if (howto_idx
< TABLE_SIZE (howto_table_std
))
4013 howto
= howto_table_std
+ howto_idx
;
4021 (*flaginfo
->info
->callbacks
->einfo
)
4022 (_("%P: %B: unexpected relocation type\n"), input_bfd
);
4023 bfd_set_error (bfd_error_bad_value
);
4029 /* We are generating a relocatable output file, and must
4030 modify the reloc accordingly. */
4033 /* If we know the symbol this relocation is against,
4034 convert it into a relocation against a section. This
4035 is what the native linker does. */
4036 h
= sym_hashes
[r_index
];
4038 && (h
->root
.type
== bfd_link_hash_defined
4039 || h
->root
.type
== bfd_link_hash_defweak
))
4041 asection
*output_section
;
4043 /* Change the r_extern value. */
4044 if (bfd_header_big_endian (output_bfd
))
4045 rel
->r_type
[0] &=~ RELOC_STD_BITS_EXTERN_BIG
;
4047 rel
->r_type
[0] &=~ RELOC_STD_BITS_EXTERN_LITTLE
;
4049 /* Compute a new r_index. */
4050 output_section
= h
->root
.u
.def
.section
->output_section
;
4051 if (output_section
== obj_textsec (output_bfd
))
4053 else if (output_section
== obj_datasec (output_bfd
))
4055 else if (output_section
== obj_bsssec (output_bfd
))
4060 /* Add the symbol value and the section VMA to the
4061 addend stored in the contents. */
4062 relocation
= (h
->root
.u
.def
.value
4063 + output_section
->vma
4064 + h
->root
.u
.def
.section
->output_offset
);
4068 /* We must change r_index according to the symbol
4070 r_index
= symbol_map
[r_index
];
4076 /* We decided to strip this symbol, but it
4077 turns out that we can't. Note that we
4078 lose the other and desc information here.
4079 I don't think that will ever matter for a
4085 if (!aout_link_write_other_symbol (&h
->root
.root
,
4095 name
= strings
+ GET_WORD (input_bfd
,
4096 syms
[r_index
].e_strx
);
4097 if (! ((*flaginfo
->info
->callbacks
->unattached_reloc
)
4098 (flaginfo
->info
, name
, input_bfd
, input_section
,
4108 /* Write out the new r_index value. */
4109 if (bfd_header_big_endian (output_bfd
))
4111 rel
->r_index
[0] = r_index
>> 16;
4112 rel
->r_index
[1] = r_index
>> 8;
4113 rel
->r_index
[2] = r_index
;
4117 rel
->r_index
[2] = r_index
>> 16;
4118 rel
->r_index
[1] = r_index
>> 8;
4119 rel
->r_index
[0] = r_index
;
4126 /* This is a relocation against a section. We must
4127 adjust by the amount that the section moved. */
4128 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4129 relocation
= (section
->output_section
->vma
4130 + section
->output_offset
4134 /* Change the address of the relocation. */
4135 PUT_WORD (output_bfd
,
4136 r_addr
+ input_section
->output_offset
,
4139 /* Adjust a PC relative relocation by removing the reference
4140 to the original address in the section and including the
4141 reference to the new address. */
4143 relocation
-= (input_section
->output_section
->vma
4144 + input_section
->output_offset
4145 - input_section
->vma
);
4147 #ifdef MY_relocatable_reloc
4148 MY_relocatable_reloc (howto
, output_bfd
, rel
, relocation
, r_addr
);
4151 if (relocation
== 0)
4154 r
= MY_relocate_contents (howto
,
4155 input_bfd
, relocation
,
4162 /* We are generating an executable, and must do a full
4168 h
= sym_hashes
[r_index
];
4171 && (h
->root
.type
== bfd_link_hash_defined
4172 || h
->root
.type
== bfd_link_hash_defweak
))
4174 relocation
= (h
->root
.u
.def
.value
4175 + h
->root
.u
.def
.section
->output_section
->vma
4176 + h
->root
.u
.def
.section
->output_offset
);
4179 && h
->root
.type
== bfd_link_hash_undefweak
)
4191 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4192 relocation
= (section
->output_section
->vma
4193 + section
->output_offset
4196 relocation
+= input_section
->vma
;
4199 if (check_dynamic_reloc
!= NULL
)
4203 if (! ((*check_dynamic_reloc
)
4204 (flaginfo
->info
, input_bfd
, input_section
, h
,
4205 (void *) rel
, contents
, &skip
, &relocation
)))
4211 /* Now warn if a global symbol is undefined. We could not
4212 do this earlier, because check_dynamic_reloc might want
4213 to skip this reloc. */
4214 if (hundef
&& ! flaginfo
->info
->shared
&& ! r_baserel
)
4219 name
= h
->root
.root
.string
;
4221 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
4222 if (! ((*flaginfo
->info
->callbacks
->undefined_symbol
)
4223 (flaginfo
->info
, name
, input_bfd
, input_section
,
4228 r
= MY_final_link_relocate (howto
,
4229 input_bfd
, input_section
,
4230 contents
, r_addr
, relocation
,
4234 if (r
!= bfd_reloc_ok
)
4239 case bfd_reloc_outofrange
:
4241 case bfd_reloc_overflow
:
4248 name
= strings
+ GET_WORD (input_bfd
,
4249 syms
[r_index
].e_strx
);
4254 s
= aout_reloc_index_to_section (input_bfd
, r_index
);
4255 name
= bfd_section_name (input_bfd
, s
);
4257 if (! ((*flaginfo
->info
->callbacks
->reloc_overflow
)
4258 (flaginfo
->info
, (h
? &h
->root
: NULL
), name
,
4259 howto
->name
, (bfd_vma
) 0, input_bfd
,
4260 input_section
, r_addr
)))
4271 /* Relocate an a.out section using extended a.out relocs. */
4274 aout_link_input_section_ext (struct aout_final_link_info
*flaginfo
,
4276 asection
*input_section
,
4277 struct reloc_ext_external
*relocs
,
4278 bfd_size_type rel_size
,
4281 bfd_boolean (*check_dynamic_reloc
)
4282 (struct bfd_link_info
*, bfd
*, asection
*,
4283 struct aout_link_hash_entry
*, void *, bfd_byte
*, bfd_boolean
*,
4286 bfd_boolean relocatable
;
4287 struct external_nlist
*syms
;
4289 struct aout_link_hash_entry
**sym_hashes
;
4291 bfd_size_type reloc_count
;
4292 struct reloc_ext_external
*rel
;
4293 struct reloc_ext_external
*rel_end
;
4295 output_bfd
= flaginfo
->output_bfd
;
4296 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
4298 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_EXT_SIZE
);
4299 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
4300 == output_bfd
->xvec
->header_byteorder
);
4302 relocatable
= flaginfo
->info
->relocatable
;
4303 syms
= obj_aout_external_syms (input_bfd
);
4304 strings
= obj_aout_external_strings (input_bfd
);
4305 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
4306 symbol_map
= flaginfo
->symbol_map
;
4308 reloc_count
= rel_size
/ RELOC_EXT_SIZE
;
4310 rel_end
= rel
+ reloc_count
;
4311 for (; rel
< rel_end
; rel
++)
4316 unsigned int r_type
;
4318 struct aout_link_hash_entry
*h
= NULL
;
4319 asection
*r_section
= NULL
;
4322 r_addr
= GET_SWORD (input_bfd
, rel
->r_address
);
4324 if (bfd_header_big_endian (input_bfd
))
4326 r_index
= (((unsigned int) rel
->r_index
[0] << 16)
4327 | ((unsigned int) rel
->r_index
[1] << 8)
4329 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
4330 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
4331 >> RELOC_EXT_BITS_TYPE_SH_BIG
);
4335 r_index
= (((unsigned int) rel
->r_index
[2] << 16)
4336 | ((unsigned int) rel
->r_index
[1] << 8)
4338 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
4339 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
4340 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
);
4343 r_addend
= GET_SWORD (input_bfd
, rel
->r_addend
);
4345 if (r_type
>= TABLE_SIZE (howto_table_ext
))
4347 (*flaginfo
->info
->callbacks
->einfo
)
4348 (_("%P: %B: unexpected relocation type\n"), input_bfd
);
4349 bfd_set_error (bfd_error_bad_value
);
4355 /* We are generating a relocatable output file, and must
4356 modify the reloc accordingly. */
4358 || r_type
== (unsigned int) RELOC_BASE10
4359 || r_type
== (unsigned int) RELOC_BASE13
4360 || r_type
== (unsigned int) RELOC_BASE22
)
4362 /* If we know the symbol this relocation is against,
4363 convert it into a relocation against a section. This
4364 is what the native linker does. */
4365 if (r_type
== (unsigned int) RELOC_BASE10
4366 || r_type
== (unsigned int) RELOC_BASE13
4367 || r_type
== (unsigned int) RELOC_BASE22
)
4370 h
= sym_hashes
[r_index
];
4372 && (h
->root
.type
== bfd_link_hash_defined
4373 || h
->root
.type
== bfd_link_hash_defweak
))
4375 asection
*output_section
;
4377 /* Change the r_extern value. */
4378 if (bfd_header_big_endian (output_bfd
))
4379 rel
->r_type
[0] &=~ RELOC_EXT_BITS_EXTERN_BIG
;
4381 rel
->r_type
[0] &=~ RELOC_EXT_BITS_EXTERN_LITTLE
;
4383 /* Compute a new r_index. */
4384 output_section
= h
->root
.u
.def
.section
->output_section
;
4385 if (output_section
== obj_textsec (output_bfd
))
4387 else if (output_section
== obj_datasec (output_bfd
))
4389 else if (output_section
== obj_bsssec (output_bfd
))
4394 /* Add the symbol value and the section VMA to the
4396 relocation
= (h
->root
.u
.def
.value
4397 + output_section
->vma
4398 + h
->root
.u
.def
.section
->output_offset
);
4400 /* Now RELOCATION is the VMA of the final
4401 destination. If this is a PC relative reloc,
4402 then ADDEND is the negative of the source VMA.
4403 We want to set ADDEND to the difference between
4404 the destination VMA and the source VMA, which
4405 means we must adjust RELOCATION by the change in
4406 the source VMA. This is done below. */
4410 /* We must change r_index according to the symbol
4412 r_index
= symbol_map
[r_index
];
4418 /* We decided to strip this symbol, but it
4419 turns out that we can't. Note that we
4420 lose the other and desc information here.
4421 I don't think that will ever matter for a
4427 if (!aout_link_write_other_symbol (&h
->root
.root
,
4437 name
= strings
+ GET_WORD (input_bfd
,
4438 syms
[r_index
].e_strx
);
4439 if (! ((*flaginfo
->info
->callbacks
->unattached_reloc
)
4440 (flaginfo
->info
, name
, input_bfd
, input_section
,
4449 /* If this is a PC relative reloc, then the addend
4450 is the negative of the source VMA. We must
4451 adjust it by the change in the source VMA. This
4455 /* Write out the new r_index value. */
4456 if (bfd_header_big_endian (output_bfd
))
4458 rel
->r_index
[0] = r_index
>> 16;
4459 rel
->r_index
[1] = r_index
>> 8;
4460 rel
->r_index
[2] = r_index
;
4464 rel
->r_index
[2] = r_index
>> 16;
4465 rel
->r_index
[1] = r_index
>> 8;
4466 rel
->r_index
[0] = r_index
;
4471 /* This is a relocation against a section. We must
4472 adjust by the amount that the section moved. */
4473 r_section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4474 relocation
= (r_section
->output_section
->vma
4475 + r_section
->output_offset
4478 /* If this is a PC relative reloc, then the addend is
4479 the difference in VMA between the destination and the
4480 source. We have just adjusted for the change in VMA
4481 of the destination, so we must also adjust by the
4482 change in VMA of the source. This is done below. */
4485 /* As described above, we must always adjust a PC relative
4486 reloc by the change in VMA of the source. However, if
4487 pcrel_offset is set, then the addend does not include the
4488 location within the section, in which case we don't need
4489 to adjust anything. */
4490 if (howto_table_ext
[r_type
].pc_relative
4491 && ! howto_table_ext
[r_type
].pcrel_offset
)
4492 relocation
-= (input_section
->output_section
->vma
4493 + input_section
->output_offset
4494 - input_section
->vma
);
4496 /* Change the addend if necessary. */
4497 if (relocation
!= 0)
4498 PUT_WORD (output_bfd
, r_addend
+ relocation
, rel
->r_addend
);
4500 /* Change the address of the relocation. */
4501 PUT_WORD (output_bfd
,
4502 r_addr
+ input_section
->output_offset
,
4508 bfd_reloc_status_type r
;
4510 /* We are generating an executable, and must do a full
4516 h
= sym_hashes
[r_index
];
4519 && (h
->root
.type
== bfd_link_hash_defined
4520 || h
->root
.type
== bfd_link_hash_defweak
))
4522 relocation
= (h
->root
.u
.def
.value
4523 + h
->root
.u
.def
.section
->output_section
->vma
4524 + h
->root
.u
.def
.section
->output_offset
);
4527 && h
->root
.type
== bfd_link_hash_undefweak
)
4535 else if (r_type
== (unsigned int) RELOC_BASE10
4536 || r_type
== (unsigned int) RELOC_BASE13
4537 || r_type
== (unsigned int) RELOC_BASE22
)
4539 struct external_nlist
*sym
;
4542 /* For base relative relocs, r_index is always an index
4543 into the symbol table, even if r_extern is 0. */
4544 sym
= syms
+ r_index
;
4545 type
= H_GET_8 (input_bfd
, sym
->e_type
);
4546 if ((type
& N_TYPE
) == N_TEXT
4548 r_section
= obj_textsec (input_bfd
);
4549 else if ((type
& N_TYPE
) == N_DATA
4551 r_section
= obj_datasec (input_bfd
);
4552 else if ((type
& N_TYPE
) == N_BSS
4554 r_section
= obj_bsssec (input_bfd
);
4555 else if ((type
& N_TYPE
) == N_ABS
4557 r_section
= bfd_abs_section_ptr
;
4560 relocation
= (r_section
->output_section
->vma
4561 + r_section
->output_offset
4562 + (GET_WORD (input_bfd
, sym
->e_value
)
4567 r_section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4569 /* If this is a PC relative reloc, then R_ADDEND is the
4570 difference between the two vmas, or
4571 old_dest_sec + old_dest_off - (old_src_sec + old_src_off)
4573 old_dest_sec == section->vma
4575 old_src_sec == input_section->vma
4577 old_src_off == r_addr
4579 _bfd_final_link_relocate expects RELOCATION +
4580 R_ADDEND to be the VMA of the destination minus
4581 r_addr (the minus r_addr is because this relocation
4582 is not pcrel_offset, which is a bit confusing and
4583 should, perhaps, be changed), or
4586 new_dest_sec == output_section->vma + output_offset
4587 We arrange for this to happen by setting RELOCATION to
4588 new_dest_sec + old_src_sec - old_dest_sec
4590 If this is not a PC relative reloc, then R_ADDEND is
4591 simply the VMA of the destination, so we set
4592 RELOCATION to the change in the destination VMA, or
4593 new_dest_sec - old_dest_sec
4595 relocation
= (r_section
->output_section
->vma
4596 + r_section
->output_offset
4598 if (howto_table_ext
[r_type
].pc_relative
)
4599 relocation
+= input_section
->vma
;
4602 if (check_dynamic_reloc
!= NULL
)
4606 if (! ((*check_dynamic_reloc
)
4607 (flaginfo
->info
, input_bfd
, input_section
, h
,
4608 (void *) rel
, contents
, &skip
, &relocation
)))
4614 /* Now warn if a global symbol is undefined. We could not
4615 do this earlier, because check_dynamic_reloc might want
4616 to skip this reloc. */
4618 && ! flaginfo
->info
->shared
4619 && r_type
!= (unsigned int) RELOC_BASE10
4620 && r_type
!= (unsigned int) RELOC_BASE13
4621 && r_type
!= (unsigned int) RELOC_BASE22
)
4626 name
= h
->root
.root
.string
;
4628 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
4629 if (! ((*flaginfo
->info
->callbacks
->undefined_symbol
)
4630 (flaginfo
->info
, name
, input_bfd
, input_section
,
4635 if (r_type
!= (unsigned int) RELOC_SPARC_REV32
)
4636 r
= MY_final_link_relocate (howto_table_ext
+ r_type
,
4637 input_bfd
, input_section
,
4638 contents
, r_addr
, relocation
,
4644 x
= bfd_get_32 (input_bfd
, contents
+ r_addr
);
4645 x
= x
+ relocation
+ r_addend
;
4646 bfd_putl32 (/*input_bfd,*/ x
, contents
+ r_addr
);
4650 if (r
!= bfd_reloc_ok
)
4655 case bfd_reloc_outofrange
:
4657 case bfd_reloc_overflow
:
4664 || r_type
== (unsigned int) RELOC_BASE10
4665 || r_type
== (unsigned int) RELOC_BASE13
4666 || r_type
== (unsigned int) RELOC_BASE22
)
4667 name
= strings
+ GET_WORD (input_bfd
,
4668 syms
[r_index
].e_strx
);
4673 s
= aout_reloc_index_to_section (input_bfd
, r_index
);
4674 name
= bfd_section_name (input_bfd
, s
);
4676 if (! ((*flaginfo
->info
->callbacks
->reloc_overflow
)
4677 (flaginfo
->info
, (h
? &h
->root
: NULL
), name
,
4678 howto_table_ext
[r_type
].name
,
4679 r_addend
, input_bfd
, input_section
, r_addr
)))
4691 /* Link an a.out section into the output file. */
4694 aout_link_input_section (struct aout_final_link_info
*flaginfo
,
4696 asection
*input_section
,
4697 file_ptr
*reloff_ptr
,
4698 bfd_size_type rel_size
)
4700 bfd_size_type input_size
;
4703 /* Get the section contents. */
4704 input_size
= input_section
->size
;
4705 if (! bfd_get_section_contents (input_bfd
, input_section
,
4706 (void *) flaginfo
->contents
,
4707 (file_ptr
) 0, input_size
))
4710 /* Read in the relocs if we haven't already done it. */
4711 if (aout_section_data (input_section
) != NULL
4712 && aout_section_data (input_section
)->relocs
!= NULL
)
4713 relocs
= aout_section_data (input_section
)->relocs
;
4716 relocs
= flaginfo
->relocs
;
4719 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
4720 || bfd_bread (relocs
, rel_size
, input_bfd
) != rel_size
)
4725 /* Relocate the section contents. */
4726 if (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
)
4728 if (! aout_link_input_section_std (flaginfo
, input_bfd
, input_section
,
4729 (struct reloc_std_external
*) relocs
,
4730 rel_size
, flaginfo
->contents
))
4735 if (! aout_link_input_section_ext (flaginfo
, input_bfd
, input_section
,
4736 (struct reloc_ext_external
*) relocs
,
4737 rel_size
, flaginfo
->contents
))
4741 /* Write out the section contents. */
4742 if (! bfd_set_section_contents (flaginfo
->output_bfd
,
4743 input_section
->output_section
,
4744 (void *) flaginfo
->contents
,
4745 (file_ptr
) input_section
->output_offset
,
4749 /* If we are producing relocatable output, the relocs were
4750 modified, and we now write them out. */
4751 if (flaginfo
->info
->relocatable
&& rel_size
> 0)
4753 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
4755 if (bfd_bwrite (relocs
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
4757 *reloff_ptr
+= rel_size
;
4759 /* Assert that the relocs have not run into the symbols, and
4760 that if these are the text relocs they have not run into the
4762 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
4763 && (reloff_ptr
!= &flaginfo
->treloff
4765 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
4771 /* Adjust and write out the symbols for an a.out file. Set the new
4772 symbol indices into a symbol_map. */
4775 aout_link_write_symbols (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
4778 bfd_size_type sym_count
;
4780 enum bfd_link_strip strip
;
4781 enum bfd_link_discard discard
;
4782 struct external_nlist
*outsym
;
4783 bfd_size_type strtab_index
;
4784 struct external_nlist
*sym
;
4785 struct external_nlist
*sym_end
;
4786 struct aout_link_hash_entry
**sym_hash
;
4789 bfd_boolean skip_next
;
4791 output_bfd
= flaginfo
->output_bfd
;
4792 sym_count
= obj_aout_external_sym_count (input_bfd
);
4793 strings
= obj_aout_external_strings (input_bfd
);
4794 strip
= flaginfo
->info
->strip
;
4795 discard
= flaginfo
->info
->discard
;
4796 outsym
= flaginfo
->output_syms
;
4798 /* First write out a symbol for this object file, unless we are
4799 discarding such symbols. */
4800 if (strip
!= strip_all
4801 && (strip
!= strip_some
4802 || bfd_hash_lookup (flaginfo
->info
->keep_hash
, input_bfd
->filename
,
4803 FALSE
, FALSE
) != NULL
)
4804 && discard
!= discard_all
)
4806 H_PUT_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
4807 H_PUT_8 (output_bfd
, 0, outsym
->e_other
);
4808 H_PUT_16 (output_bfd
, 0, outsym
->e_desc
);
4809 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4810 input_bfd
->filename
, FALSE
);
4811 if (strtab_index
== (bfd_size_type
) -1)
4813 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4814 PUT_WORD (output_bfd
,
4815 (bfd_get_section_vma (output_bfd
,
4816 obj_textsec (input_bfd
)->output_section
)
4817 + obj_textsec (input_bfd
)->output_offset
),
4819 ++obj_aout_external_sym_count (output_bfd
);
4825 sym
= obj_aout_external_syms (input_bfd
);
4826 sym_end
= sym
+ sym_count
;
4827 sym_hash
= obj_aout_sym_hashes (input_bfd
);
4828 symbol_map
= flaginfo
->symbol_map
;
4829 memset (symbol_map
, 0, (size_t) sym_count
* sizeof *symbol_map
);
4830 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
4834 struct aout_link_hash_entry
*h
;
4840 /* We set *symbol_map to 0 above for all symbols. If it has
4841 already been set to -1 for this symbol, it means that we are
4842 discarding it because it appears in a duplicate header file.
4843 See the N_BINCL code below. */
4844 if (*symbol_map
== -1)
4847 /* Initialize *symbol_map to -1, which means that the symbol was
4848 not copied into the output file. We will change it later if
4849 we do copy the symbol over. */
4852 type
= H_GET_8 (input_bfd
, sym
->e_type
);
4853 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
4859 /* Pass this symbol through. It is the target of an
4860 indirect or warning symbol. */
4861 val
= GET_WORD (input_bfd
, sym
->e_value
);
4866 /* Skip this symbol, which is the target of an indirect
4867 symbol that we have changed to no longer be an indirect
4874 struct aout_link_hash_entry
*hresolve
;
4876 /* We have saved the hash table entry for this symbol, if
4877 there is one. Note that we could just look it up again
4878 in the hash table, provided we first check that it is an
4882 /* Use the name from the hash table, in case the symbol was
4885 && h
->root
.type
!= bfd_link_hash_warning
)
4886 name
= h
->root
.root
.string
;
4888 /* If this is an indirect or warning symbol, then change
4889 hresolve to the base symbol. We also change *sym_hash so
4890 that the relocation routines relocate against the real
4893 if (h
!= (struct aout_link_hash_entry
*) NULL
4894 && (h
->root
.type
== bfd_link_hash_indirect
4895 || h
->root
.type
== bfd_link_hash_warning
))
4897 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
4898 while (hresolve
->root
.type
== bfd_link_hash_indirect
4899 || hresolve
->root
.type
== bfd_link_hash_warning
)
4900 hresolve
= ((struct aout_link_hash_entry
*)
4901 hresolve
->root
.u
.i
.link
);
4902 *sym_hash
= hresolve
;
4905 /* If the symbol has already been written out, skip it. */
4909 if ((type
& N_TYPE
) == N_INDR
4910 || type
== N_WARNING
)
4912 *symbol_map
= h
->indx
;
4916 /* See if we are stripping this symbol. */
4922 case strip_debugger
:
4923 if ((type
& N_STAB
) != 0)
4927 if (bfd_hash_lookup (flaginfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
4942 /* Get the value of the symbol. */
4943 if ((type
& N_TYPE
) == N_TEXT
4945 symsec
= obj_textsec (input_bfd
);
4946 else if ((type
& N_TYPE
) == N_DATA
4948 symsec
= obj_datasec (input_bfd
);
4949 else if ((type
& N_TYPE
) == N_BSS
4951 symsec
= obj_bsssec (input_bfd
);
4952 else if ((type
& N_TYPE
) == N_ABS
4954 symsec
= bfd_abs_section_ptr
;
4955 else if (((type
& N_TYPE
) == N_INDR
4956 && (hresolve
== NULL
4957 || (hresolve
->root
.type
!= bfd_link_hash_defined
4958 && hresolve
->root
.type
!= bfd_link_hash_defweak
4959 && hresolve
->root
.type
!= bfd_link_hash_common
)))
4960 || type
== N_WARNING
)
4962 /* Pass the next symbol through unchanged. The
4963 condition above for indirect symbols is so that if
4964 the indirect symbol was defined, we output it with
4965 the correct definition so the debugger will
4968 val
= GET_WORD (input_bfd
, sym
->e_value
);
4971 else if ((type
& N_STAB
) != 0)
4973 val
= GET_WORD (input_bfd
, sym
->e_value
);
4978 /* If we get here with an indirect symbol, it means that
4979 we are outputting it with a real definition. In such
4980 a case we do not want to output the next symbol,
4981 which is the target of the indirection. */
4982 if ((type
& N_TYPE
) == N_INDR
)
4987 /* We need to get the value from the hash table. We use
4988 hresolve so that if we have defined an indirect
4989 symbol we output the final definition. */
4992 switch (type
& N_TYPE
)
4995 symsec
= obj_textsec (input_bfd
);
4998 symsec
= obj_datasec (input_bfd
);
5001 symsec
= obj_bsssec (input_bfd
);
5004 symsec
= bfd_abs_section_ptr
;
5011 else if (hresolve
->root
.type
== bfd_link_hash_defined
5012 || hresolve
->root
.type
== bfd_link_hash_defweak
)
5014 asection
*input_section
;
5015 asection
*output_section
;
5017 /* This case usually means a common symbol which was
5018 turned into a defined symbol. */
5019 input_section
= hresolve
->root
.u
.def
.section
;
5020 output_section
= input_section
->output_section
;
5021 BFD_ASSERT (bfd_is_abs_section (output_section
)
5022 || output_section
->owner
== output_bfd
);
5023 val
= (hresolve
->root
.u
.def
.value
5024 + bfd_get_section_vma (output_bfd
, output_section
)
5025 + input_section
->output_offset
);
5027 /* Get the correct type based on the section. If
5028 this is a constructed set, force it to be
5029 globally visible. */
5038 if (output_section
== obj_textsec (output_bfd
))
5039 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
5042 else if (output_section
== obj_datasec (output_bfd
))
5043 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
5046 else if (output_section
== obj_bsssec (output_bfd
))
5047 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
5051 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
5055 else if (hresolve
->root
.type
== bfd_link_hash_common
)
5056 val
= hresolve
->root
.u
.c
.size
;
5057 else if (hresolve
->root
.type
== bfd_link_hash_undefweak
)
5066 val
= (symsec
->output_section
->vma
5067 + symsec
->output_offset
5068 + (GET_WORD (input_bfd
, sym
->e_value
)
5071 /* If this is a global symbol set the written flag, and if
5072 it is a local symbol see if we should discard it. */
5076 h
->indx
= obj_aout_external_sym_count (output_bfd
);
5078 else if ((type
& N_TYPE
) != N_SETT
5079 && (type
& N_TYPE
) != N_SETD
5080 && (type
& N_TYPE
) != N_SETB
5081 && (type
& N_TYPE
) != N_SETA
)
5086 case discard_sec_merge
:
5089 if ((type
& N_STAB
) == 0
5090 && bfd_is_local_label_name (input_bfd
, name
))
5104 /* An N_BINCL symbol indicates the start of the stabs
5105 entries for a header file. We need to scan ahead to the
5106 next N_EINCL symbol, ignoring nesting, adding up all the
5107 characters in the symbol names, not including the file
5108 numbers in types (the first number after an open
5110 if (type
== (int) N_BINCL
)
5112 struct external_nlist
*incl_sym
;
5114 struct aout_link_includes_entry
*incl_entry
;
5115 struct aout_link_includes_totals
*t
;
5119 for (incl_sym
= sym
+ 1; incl_sym
< sym_end
; incl_sym
++)
5123 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
5124 if (incl_type
== (int) N_EINCL
)
5130 else if (incl_type
== (int) N_BINCL
)
5136 s
= strings
+ GET_WORD (input_bfd
, incl_sym
->e_strx
);
5137 for (; *s
!= '\0'; s
++)
5142 /* Skip the file number. */
5144 while (ISDIGIT (*s
))
5152 /* If we have already included a header file with the
5153 same value, then replace this one with an N_EXCL
5155 copy
= (bfd_boolean
) (! flaginfo
->info
->keep_memory
);
5156 incl_entry
= aout_link_includes_lookup (&flaginfo
->includes
,
5158 if (incl_entry
== NULL
)
5160 for (t
= incl_entry
->totals
; t
!= NULL
; t
= t
->next
)
5161 if (t
->total
== val
)
5165 /* This is the first time we have seen this header
5166 file with this set of stabs strings. */
5167 t
= (struct aout_link_includes_totals
*)
5168 bfd_hash_allocate (&flaginfo
->includes
.root
,
5173 t
->next
= incl_entry
->totals
;
5174 incl_entry
->totals
= t
;
5180 /* This is a duplicate header file. We must change
5181 it to be an N_EXCL entry, and mark all the
5182 included symbols to prevent outputting them. */
5183 type
= (int) N_EXCL
;
5186 for (incl_sym
= sym
+ 1, incl_map
= symbol_map
+ 1;
5188 incl_sym
++, incl_map
++)
5192 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
5193 if (incl_type
== (int) N_EINCL
)
5202 else if (incl_type
== (int) N_BINCL
)
5211 /* Copy this symbol into the list of symbols we are going to
5213 H_PUT_8 (output_bfd
, type
, outsym
->e_type
);
5214 H_PUT_8 (output_bfd
, H_GET_8 (input_bfd
, sym
->e_other
), outsym
->e_other
);
5215 H_PUT_16 (output_bfd
, H_GET_16 (input_bfd
, sym
->e_desc
), outsym
->e_desc
);
5217 if (! flaginfo
->info
->keep_memory
)
5219 /* name points into a string table which we are going to
5220 free. If there is a hash table entry, use that string.
5221 Otherwise, copy name into memory. */
5223 name
= h
->root
.root
.string
;
5227 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
5229 if (strtab_index
== (bfd_size_type
) -1)
5231 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
5232 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
5233 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
5234 ++obj_aout_external_sym_count (output_bfd
);
5238 /* Write out the output symbols we have just constructed. */
5239 if (outsym
> flaginfo
->output_syms
)
5241 bfd_size_type outsym_size
;
5243 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0)
5245 outsym_size
= outsym
- flaginfo
->output_syms
;
5246 outsym_size
*= EXTERNAL_NLIST_SIZE
;
5247 if (bfd_bwrite ((void *) flaginfo
->output_syms
, outsym_size
, output_bfd
)
5250 flaginfo
->symoff
+= outsym_size
;
5256 /* Link an a.out input BFD into the output file. */
5259 aout_link_input_bfd (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
5261 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
5263 /* If this is a dynamic object, it may need special handling. */
5264 if ((input_bfd
->flags
& DYNAMIC
) != 0
5265 && aout_backend_info (input_bfd
)->link_dynamic_object
!= NULL
)
5266 return ((*aout_backend_info (input_bfd
)->link_dynamic_object
)
5267 (flaginfo
->info
, input_bfd
));
5269 /* Get the symbols. We probably have them already, unless
5270 flaginfo->info->keep_memory is FALSE. */
5271 if (! aout_get_external_symbols (input_bfd
))
5274 /* Write out the symbols and get a map of the new indices. The map
5275 is placed into flaginfo->symbol_map. */
5276 if (! aout_link_write_symbols (flaginfo
, input_bfd
))
5279 /* Relocate and write out the sections. These functions use the
5280 symbol map created by aout_link_write_symbols. The linker_mark
5281 field will be set if these sections are to be included in the
5282 link, which will normally be the case. */
5283 if (obj_textsec (input_bfd
)->linker_mark
)
5285 if (! aout_link_input_section (flaginfo
, input_bfd
,
5286 obj_textsec (input_bfd
),
5288 exec_hdr (input_bfd
)->a_trsize
))
5291 if (obj_datasec (input_bfd
)->linker_mark
)
5293 if (! aout_link_input_section (flaginfo
, input_bfd
,
5294 obj_datasec (input_bfd
),
5296 exec_hdr (input_bfd
)->a_drsize
))
5300 /* If we are not keeping memory, we don't need the symbols any
5301 longer. We still need them if we are keeping memory, because the
5302 strings in the hash table point into them. */
5303 if (! flaginfo
->info
->keep_memory
)
5305 if (! aout_link_free_symbols (input_bfd
))
5312 /* Do the final link step. This is called on the output BFD. The
5313 INFO structure should point to a list of BFDs linked through the
5314 link.next field which can be used to find each BFD which takes part
5315 in the output. Also, each section in ABFD should point to a list
5316 of bfd_link_order structures which list all the input sections for
5317 the output section. */
5320 NAME (aout
, final_link
) (bfd
*abfd
,
5321 struct bfd_link_info
*info
,
5322 void (*callback
) (bfd
*, file_ptr
*, file_ptr
*, file_ptr
*))
5324 struct aout_final_link_info aout_info
;
5325 bfd_boolean includes_hash_initialized
= FALSE
;
5327 bfd_size_type trsize
, drsize
;
5328 bfd_size_type max_contents_size
;
5329 bfd_size_type max_relocs_size
;
5330 bfd_size_type max_sym_count
;
5331 bfd_size_type text_size
;
5333 struct bfd_link_order
*p
;
5335 bfd_boolean have_link_order_relocs
;
5338 abfd
->flags
|= DYNAMIC
;
5340 aout_info
.info
= info
;
5341 aout_info
.output_bfd
= abfd
;
5342 aout_info
.contents
= NULL
;
5343 aout_info
.relocs
= NULL
;
5344 aout_info
.symbol_map
= NULL
;
5345 aout_info
.output_syms
= NULL
;
5347 if (!bfd_hash_table_init_n (&aout_info
.includes
.root
,
5348 aout_link_includes_newfunc
,
5349 sizeof (struct aout_link_includes_entry
),
5352 includes_hash_initialized
= TRUE
;
5354 /* Figure out the largest section size. Also, if generating
5355 relocatable output, count the relocs. */
5358 max_contents_size
= 0;
5359 max_relocs_size
= 0;
5361 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
5365 if (info
->relocatable
)
5367 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
5369 trsize
+= exec_hdr (sub
)->a_trsize
;
5370 drsize
+= exec_hdr (sub
)->a_drsize
;
5374 /* FIXME: We need to identify the .text and .data sections
5375 and call get_reloc_upper_bound and canonicalize_reloc to
5376 work out the number of relocs needed, and then multiply
5377 by the reloc size. */
5378 (*_bfd_error_handler
)
5379 (_("%s: relocatable link from %s to %s not supported"),
5380 bfd_get_filename (abfd
),
5381 sub
->xvec
->name
, abfd
->xvec
->name
);
5382 bfd_set_error (bfd_error_invalid_operation
);
5387 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
5389 sz
= obj_textsec (sub
)->size
;
5390 if (sz
> max_contents_size
)
5391 max_contents_size
= sz
;
5392 sz
= obj_datasec (sub
)->size
;
5393 if (sz
> max_contents_size
)
5394 max_contents_size
= sz
;
5396 sz
= exec_hdr (sub
)->a_trsize
;
5397 if (sz
> max_relocs_size
)
5398 max_relocs_size
= sz
;
5399 sz
= exec_hdr (sub
)->a_drsize
;
5400 if (sz
> max_relocs_size
)
5401 max_relocs_size
= sz
;
5403 sz
= obj_aout_external_sym_count (sub
);
5404 if (sz
> max_sym_count
)
5409 if (info
->relocatable
)
5411 if (obj_textsec (abfd
) != NULL
)
5412 trsize
+= (_bfd_count_link_order_relocs (obj_textsec (abfd
)
5413 ->map_head
.link_order
)
5414 * obj_reloc_entry_size (abfd
));
5415 if (obj_datasec (abfd
) != NULL
)
5416 drsize
+= (_bfd_count_link_order_relocs (obj_datasec (abfd
)
5417 ->map_head
.link_order
)
5418 * obj_reloc_entry_size (abfd
));
5421 exec_hdr (abfd
)->a_trsize
= trsize
;
5422 exec_hdr (abfd
)->a_drsize
= drsize
;
5424 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
5426 /* Adjust the section sizes and vmas according to the magic number.
5427 This sets a_text, a_data and a_bss in the exec_hdr and sets the
5428 filepos for each section. */
5429 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
, &text_size
, &text_end
))
5432 /* The relocation and symbol file positions differ among a.out
5433 targets. We are passed a callback routine from the backend
5434 specific code to handle this.
5435 FIXME: At this point we do not know how much space the symbol
5436 table will require. This will not work for any (nonstandard)
5437 a.out target that needs to know the symbol table size before it
5438 can compute the relocation file positions. This may or may not
5439 be the case for the hp300hpux target, for example. */
5440 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
5442 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
5443 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
5444 obj_sym_filepos (abfd
) = aout_info
.symoff
;
5446 /* We keep a count of the symbols as we output them. */
5447 obj_aout_external_sym_count (abfd
) = 0;
5449 /* We accumulate the string table as we write out the symbols. */
5450 aout_info
.strtab
= _bfd_stringtab_init ();
5451 if (aout_info
.strtab
== NULL
)
5454 /* Allocate buffers to hold section contents and relocs. */
5455 aout_info
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
5456 aout_info
.relocs
= bfd_malloc (max_relocs_size
);
5457 aout_info
.symbol_map
= (int *) bfd_malloc (max_sym_count
* sizeof (int));
5458 aout_info
.output_syms
= (struct external_nlist
*)
5459 bfd_malloc ((max_sym_count
+ 1) * sizeof (struct external_nlist
));
5460 if ((aout_info
.contents
== NULL
&& max_contents_size
!= 0)
5461 || (aout_info
.relocs
== NULL
&& max_relocs_size
!= 0)
5462 || (aout_info
.symbol_map
== NULL
&& max_sym_count
!= 0)
5463 || aout_info
.output_syms
== NULL
)
5466 /* If we have a symbol named __DYNAMIC, force it out now. This is
5467 required by SunOS. Doing this here rather than in sunos.c is a
5468 hack, but it's easier than exporting everything which would be
5471 struct aout_link_hash_entry
*h
;
5473 h
= aout_link_hash_lookup (aout_hash_table (info
), "__DYNAMIC",
5474 FALSE
, FALSE
, FALSE
);
5476 aout_link_write_other_symbol (&h
->root
.root
, &aout_info
);
5479 /* The most time efficient way to do the link would be to read all
5480 the input object files into memory and then sort out the
5481 information into the output file. Unfortunately, that will
5482 probably use too much memory. Another method would be to step
5483 through everything that composes the text section and write it
5484 out, and then everything that composes the data section and write
5485 it out, and then write out the relocs, and then write out the
5486 symbols. Unfortunately, that requires reading stuff from each
5487 input file several times, and we will not be able to keep all the
5488 input files open simultaneously, and reopening them will be slow.
5490 What we do is basically process one input file at a time. We do
5491 everything we need to do with an input file once--copy over the
5492 section contents, handle the relocation information, and write
5493 out the symbols--and then we throw away the information we read
5494 from it. This approach requires a lot of lseeks of the output
5495 file, which is unfortunate but still faster than reopening a lot
5498 We use the output_has_begun field of the input BFDs to see
5499 whether we have already handled it. */
5500 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
5501 sub
->output_has_begun
= FALSE
;
5503 /* Mark all sections which are to be included in the link. This
5504 will normally be every section. We need to do this so that we
5505 can identify any sections which the linker has decided to not
5507 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5509 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
5510 if (p
->type
== bfd_indirect_link_order
)
5511 p
->u
.indirect
.section
->linker_mark
= TRUE
;
5514 have_link_order_relocs
= FALSE
;
5515 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5517 for (p
= o
->map_head
.link_order
;
5521 if (p
->type
== bfd_indirect_link_order
5522 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5523 == bfd_target_aout_flavour
))
5527 input_bfd
= p
->u
.indirect
.section
->owner
;
5528 if (! input_bfd
->output_has_begun
)
5530 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
5532 input_bfd
->output_has_begun
= TRUE
;
5535 else if (p
->type
== bfd_section_reloc_link_order
5536 || p
->type
== bfd_symbol_reloc_link_order
)
5538 /* These are handled below. */
5539 have_link_order_relocs
= TRUE
;
5543 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5549 /* Write out any symbols that we have not already written out. */
5550 bfd_hash_traverse (&info
->hash
->table
,
5551 aout_link_write_other_symbol
,
5554 /* Now handle any relocs we were asked to create by the linker.
5555 These did not come from any input file. We must do these after
5556 we have written out all the symbols, so that we know the symbol
5558 if (have_link_order_relocs
)
5560 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5562 for (p
= o
->map_head
.link_order
;
5566 if (p
->type
== bfd_section_reloc_link_order
5567 || p
->type
== bfd_symbol_reloc_link_order
)
5569 if (! aout_link_reloc_link_order (&aout_info
, o
, p
))
5576 if (aout_info
.contents
!= NULL
)
5578 free (aout_info
.contents
);
5579 aout_info
.contents
= NULL
;
5581 if (aout_info
.relocs
!= NULL
)
5583 free (aout_info
.relocs
);
5584 aout_info
.relocs
= NULL
;
5586 if (aout_info
.symbol_map
!= NULL
)
5588 free (aout_info
.symbol_map
);
5589 aout_info
.symbol_map
= NULL
;
5591 if (aout_info
.output_syms
!= NULL
)
5593 free (aout_info
.output_syms
);
5594 aout_info
.output_syms
= NULL
;
5596 if (includes_hash_initialized
)
5598 bfd_hash_table_free (&aout_info
.includes
.root
);
5599 includes_hash_initialized
= FALSE
;
5602 /* Finish up any dynamic linking we may be doing. */
5603 if (aout_backend_info (abfd
)->finish_dynamic_link
!= NULL
)
5605 if (! (*aout_backend_info (abfd
)->finish_dynamic_link
) (abfd
, info
))
5609 /* Update the header information. */
5610 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
5611 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
5612 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
5613 obj_textsec (abfd
)->reloc_count
=
5614 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
5615 obj_datasec (abfd
)->reloc_count
=
5616 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
5618 /* Write out the string table, unless there are no symbols. */
5619 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0)
5621 if (abfd
->symcount
> 0)
5623 if (!emit_stringtab (abfd
, aout_info
.strtab
))
5628 bfd_byte b
[BYTES_IN_WORD
];
5630 memset (b
, 0, BYTES_IN_WORD
);
5631 if (bfd_bwrite (b
, (bfd_size_type
) BYTES_IN_WORD
, abfd
) != BYTES_IN_WORD
)
5638 if (aout_info
.contents
!= NULL
)
5639 free (aout_info
.contents
);
5640 if (aout_info
.relocs
!= NULL
)
5641 free (aout_info
.relocs
);
5642 if (aout_info
.symbol_map
!= NULL
)
5643 free (aout_info
.symbol_map
);
5644 if (aout_info
.output_syms
!= NULL
)
5645 free (aout_info
.output_syms
);
5646 if (includes_hash_initialized
)
5647 bfd_hash_table_free (&aout_info
.includes
.root
);