1 /* BFD semi-generic back-end for a.out binaries.
2 Copyright 1990, 91, 92, 93, 94, 95, 1996 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 sunos_big_vec
72 requires all the names from @file{aout32.c}, and produces the jump vector
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.in}
106 @file{@var{XXX}.mt} file (by setting "<<bfd_target=XXX>>") when your
107 configuration is selected.
112 * Any BFD with D_PAGED set is ZMAGIC, and vice versa.
113 Doesn't matter what the setting of WP_TEXT is on output, but it'll
115 * Any BFD with D_PAGED clear and WP_TEXT set is NMAGIC.
116 * Any BFD with both flags clear is OMAGIC.
117 (Just want to make these explicit, so the conditions tested in this
118 file make sense if you're more familiar with a.out than with BFD.) */
120 #define KEEPIT udata.i
122 #include <string.h> /* For strchr and friends */
130 #include "aout/aout64.h"
131 #include "aout/stab_gnu.h"
134 static boolean aout_get_external_symbols
PARAMS ((bfd
*));
135 static boolean translate_from_native_sym_flags
136 PARAMS ((bfd
*, aout_symbol_type
*));
137 static boolean translate_to_native_sym_flags
138 PARAMS ((bfd
*, asymbol
*, struct external_nlist
*));
145 The file @file{aoutx.h} provides for both the @emph{standard}
146 and @emph{extended} forms of a.out relocation records.
148 The standard records contain only an
149 address, a symbol index, and a type field. The extended records
150 (used on 29ks and sparcs) also have a full integer for an
154 #ifndef CTOR_TABLE_RELOC_HOWTO
155 #define CTOR_TABLE_RELOC_IDX 2
156 #define CTOR_TABLE_RELOC_HOWTO(BFD) ((obj_reloc_entry_size(BFD) == RELOC_EXT_SIZE \
157 ? howto_table_ext : howto_table_std) \
158 + CTOR_TABLE_RELOC_IDX)
161 #ifndef MY_swap_std_reloc_in
162 #define MY_swap_std_reloc_in NAME(aout,swap_std_reloc_in)
165 #ifndef MY_swap_std_reloc_out
166 #define MY_swap_std_reloc_out NAME(aout,swap_std_reloc_out)
169 #ifndef MY_final_link_relocate
170 #define MY_final_link_relocate _bfd_final_link_relocate
173 #ifndef MY_relocate_contents
174 #define MY_relocate_contents _bfd_relocate_contents
177 #define howto_table_ext NAME(aout,ext_howto_table)
178 #define howto_table_std NAME(aout,std_howto_table)
180 reloc_howto_type howto_table_ext
[] =
182 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
183 HOWTO(RELOC_8
, 0, 0, 8, false, 0, complain_overflow_bitfield
,0,"8", false, 0,0x000000ff, false),
184 HOWTO(RELOC_16
, 0, 1, 16, false, 0, complain_overflow_bitfield
,0,"16", false, 0,0x0000ffff, false),
185 HOWTO(RELOC_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,0,"32", false, 0,0xffffffff, false),
186 HOWTO(RELOC_DISP8
, 0, 0, 8, true, 0, complain_overflow_signed
,0,"DISP8", false, 0,0x000000ff, false),
187 HOWTO(RELOC_DISP16
, 0, 1, 16, true, 0, complain_overflow_signed
,0,"DISP16", false, 0,0x0000ffff, false),
188 HOWTO(RELOC_DISP32
, 0, 2, 32, true, 0, complain_overflow_signed
,0,"DISP32", false, 0,0xffffffff, false),
189 HOWTO(RELOC_WDISP30
,2, 2, 30, true, 0, complain_overflow_signed
,0,"WDISP30", false, 0,0x3fffffff, false),
190 HOWTO(RELOC_WDISP22
,2, 2, 22, true, 0, complain_overflow_signed
,0,"WDISP22", false, 0,0x003fffff, false),
191 HOWTO(RELOC_HI22
, 10, 2, 22, false, 0, complain_overflow_bitfield
,0,"HI22", false, 0,0x003fffff, false),
192 HOWTO(RELOC_22
, 0, 2, 22, false, 0, complain_overflow_bitfield
,0,"22", false, 0,0x003fffff, false),
193 HOWTO(RELOC_13
, 0, 2, 13, false, 0, complain_overflow_bitfield
,0,"13", false, 0,0x00001fff, false),
194 HOWTO(RELOC_LO10
, 0, 2, 10, false, 0, complain_overflow_dont
,0,"LO10", false, 0,0x000003ff, false),
195 HOWTO(RELOC_SFA_BASE
,0, 2, 32, false, 0, complain_overflow_bitfield
,0,"SFA_BASE", false, 0,0xffffffff, false),
196 HOWTO(RELOC_SFA_OFF13
,0,2, 32, false, 0, complain_overflow_bitfield
,0,"SFA_OFF13",false, 0,0xffffffff, false),
197 HOWTO(RELOC_BASE10
, 0, 2, 10, false, 0, complain_overflow_dont
,0,"BASE10", false, 0,0x000003ff, false),
198 HOWTO(RELOC_BASE13
, 0, 2, 13, false, 0, complain_overflow_bitfield
,0,"BASE13", false, 0,0x00001fff, false),
199 HOWTO(RELOC_BASE22
, 10, 2, 22, false, 0, complain_overflow_bitfield
,0,"BASE22", false, 0,0x003fffff, false),
200 HOWTO(RELOC_PC10
, 0, 2, 10, true, 0, complain_overflow_dont
,0,"PC10", false, 0,0x000003ff, true),
201 HOWTO(RELOC_PC22
, 10, 2, 22, true, 0, complain_overflow_signed
,0,"PC22", false, 0,0x003fffff, true),
202 HOWTO(RELOC_JMP_TBL
,2, 2, 30, true, 0, complain_overflow_signed
,0,"JMP_TBL", false, 0,0x3fffffff, false),
203 HOWTO(RELOC_SEGOFF16
,0, 2, 0, false, 0, complain_overflow_bitfield
,0,"SEGOFF16", false, 0,0x00000000, false),
204 HOWTO(RELOC_GLOB_DAT
,0, 2, 0, false, 0, complain_overflow_bitfield
,0,"GLOB_DAT", false, 0,0x00000000, false),
205 HOWTO(RELOC_JMP_SLOT
,0, 2, 0, false, 0, complain_overflow_bitfield
,0,"JMP_SLOT", false, 0,0x00000000, false),
206 HOWTO(RELOC_RELATIVE
,0, 2, 0, false, 0, complain_overflow_bitfield
,0,"RELATIVE", false, 0,0x00000000, false),
209 /* Convert standard reloc records to "arelent" format (incl byte swap). */
211 reloc_howto_type howto_table_std
[] = {
212 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
213 HOWTO( 0, 0, 0, 8, false, 0, complain_overflow_bitfield
,0,"8", true, 0x000000ff,0x000000ff, false),
214 HOWTO( 1, 0, 1, 16, false, 0, complain_overflow_bitfield
,0,"16", true, 0x0000ffff,0x0000ffff, false),
215 HOWTO( 2, 0, 2, 32, false, 0, complain_overflow_bitfield
,0,"32", true, 0xffffffff,0xffffffff, false),
216 HOWTO( 3, 0, 4, 64, false, 0, complain_overflow_bitfield
,0,"64", true, 0xdeaddead,0xdeaddead, false),
217 HOWTO( 4, 0, 0, 8, true, 0, complain_overflow_signed
, 0,"DISP8", true, 0x000000ff,0x000000ff, false),
218 HOWTO( 5, 0, 1, 16, true, 0, complain_overflow_signed
, 0,"DISP16", true, 0x0000ffff,0x0000ffff, false),
219 HOWTO( 6, 0, 2, 32, true, 0, complain_overflow_signed
, 0,"DISP32", true, 0xffffffff,0xffffffff, false),
220 HOWTO( 7, 0, 4, 64, true, 0, complain_overflow_signed
, 0,"DISP64", true, 0xfeedface,0xfeedface, false),
221 HOWTO( 8, 0, 2, 0, false, 0, complain_overflow_bitfield
,0,"GOT_REL", false, 0,0x00000000, false),
222 HOWTO( 9, 0, 1, 16, false, 0, complain_overflow_bitfield
,0,"BASE16", false,0xffffffff,0xffffffff, false),
223 HOWTO(10, 0, 2, 32, false, 0, complain_overflow_bitfield
,0,"BASE32", false,0xffffffff,0xffffffff, false),
229 HOWTO(16, 0, 2, 0, false, 0, complain_overflow_bitfield
,0,"JMP_TABLE", false, 0,0x00000000, false),
237 { -1 }, { -1 }, { -1 }, { -1 }, { -1 }, { -1 }, { -1 }, { -1 },
238 HOWTO(32, 0, 2, 0, false, 0, complain_overflow_bitfield
,0,"RELATIVE", false, 0,0x00000000, false),
246 HOWTO(40, 0, 2, 0, false, 0, complain_overflow_bitfield
,0,"BASEREL", false, 0,0x00000000, false),
249 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
252 NAME(aout
,reloc_type_lookup
) (abfd
,code
)
254 bfd_reloc_code_real_type code
;
256 #define EXT(i,j) case i: return &howto_table_ext[j]
257 #define STD(i,j) case i: return &howto_table_std[j]
258 int ext
= obj_reloc_entry_size (abfd
) == RELOC_EXT_SIZE
;
259 if (code
== BFD_RELOC_CTOR
)
260 switch (bfd_get_arch_info (abfd
)->bits_per_address
)
272 EXT (BFD_RELOC_32
, 2);
273 EXT (BFD_RELOC_HI22
, 8);
274 EXT (BFD_RELOC_LO10
, 11);
275 EXT (BFD_RELOC_32_PCREL_S2
, 6);
276 EXT (BFD_RELOC_SPARC_WDISP22
, 7);
277 EXT (BFD_RELOC_SPARC13
, 10);
278 EXT (BFD_RELOC_SPARC_GOT10
, 14);
279 EXT (BFD_RELOC_SPARC_BASE13
, 15);
280 EXT (BFD_RELOC_SPARC_GOT13
, 15);
281 EXT (BFD_RELOC_SPARC_GOT22
, 16);
282 EXT (BFD_RELOC_SPARC_PC10
, 17);
283 EXT (BFD_RELOC_SPARC_PC22
, 18);
284 EXT (BFD_RELOC_SPARC_WPLT30
, 19);
285 default: return (reloc_howto_type
*) NULL
;
291 STD (BFD_RELOC_16
, 1);
292 STD (BFD_RELOC_32
, 2);
293 STD (BFD_RELOC_8_PCREL
, 4);
294 STD (BFD_RELOC_16_PCREL
, 5);
295 STD (BFD_RELOC_32_PCREL
, 6);
296 STD (BFD_RELOC_16_BASEREL
, 9);
297 STD (BFD_RELOC_32_BASEREL
, 10);
298 default: return (reloc_howto_type
*) NULL
;
304 Internal entry points
307 @file{aoutx.h} exports several routines for accessing the
308 contents of an a.out file, which are gathered and exported in
309 turn by various format specific files (eg sunos.c).
315 aout_@var{size}_swap_exec_header_in
318 void aout_@var{size}_swap_exec_header_in,
320 struct external_exec *raw_bytes,
321 struct internal_exec *execp);
324 Swap the information in an executable header @var{raw_bytes} taken
325 from a raw byte stream memory image into the internal exec header
326 structure @var{execp}.
329 #ifndef NAME_swap_exec_header_in
331 NAME(aout
,swap_exec_header_in
) (abfd
, raw_bytes
, execp
)
333 struct external_exec
*raw_bytes
;
334 struct internal_exec
*execp
;
336 struct external_exec
*bytes
= (struct external_exec
*)raw_bytes
;
338 /* The internal_exec structure has some fields that are unused in this
339 configuration (IE for i960), so ensure that all such uninitialized
340 fields are zero'd out. There are places where two of these structs
341 are memcmp'd, and thus the contents do matter. */
342 memset ((PTR
) execp
, 0, sizeof (struct internal_exec
));
343 /* Now fill in fields in the execp, from the bytes in the raw data. */
344 execp
->a_info
= bfd_h_get_32 (abfd
, bytes
->e_info
);
345 execp
->a_text
= GET_WORD (abfd
, bytes
->e_text
);
346 execp
->a_data
= GET_WORD (abfd
, bytes
->e_data
);
347 execp
->a_bss
= GET_WORD (abfd
, bytes
->e_bss
);
348 execp
->a_syms
= GET_WORD (abfd
, bytes
->e_syms
);
349 execp
->a_entry
= GET_WORD (abfd
, bytes
->e_entry
);
350 execp
->a_trsize
= GET_WORD (abfd
, bytes
->e_trsize
);
351 execp
->a_drsize
= GET_WORD (abfd
, bytes
->e_drsize
);
353 #define NAME_swap_exec_header_in NAME(aout,swap_exec_header_in)
358 aout_@var{size}_swap_exec_header_out
361 void aout_@var{size}_swap_exec_header_out
363 struct internal_exec *execp,
364 struct external_exec *raw_bytes);
367 Swap the information in an internal exec header structure
368 @var{execp} into the buffer @var{raw_bytes} ready for writing to disk.
371 NAME(aout
,swap_exec_header_out
) (abfd
, execp
, raw_bytes
)
373 struct internal_exec
*execp
;
374 struct external_exec
*raw_bytes
;
376 struct external_exec
*bytes
= (struct external_exec
*)raw_bytes
;
378 /* Now fill in fields in the raw data, from the fields in the exec struct. */
379 bfd_h_put_32 (abfd
, execp
->a_info
, bytes
->e_info
);
380 PUT_WORD (abfd
, execp
->a_text
, bytes
->e_text
);
381 PUT_WORD (abfd
, execp
->a_data
, bytes
->e_data
);
382 PUT_WORD (abfd
, execp
->a_bss
, bytes
->e_bss
);
383 PUT_WORD (abfd
, execp
->a_syms
, bytes
->e_syms
);
384 PUT_WORD (abfd
, execp
->a_entry
, bytes
->e_entry
);
385 PUT_WORD (abfd
, execp
->a_trsize
, bytes
->e_trsize
);
386 PUT_WORD (abfd
, execp
->a_drsize
, bytes
->e_drsize
);
389 /* Make all the section for an a.out file. */
392 NAME(aout
,make_sections
) (abfd
)
395 if (obj_textsec (abfd
) == (asection
*) NULL
396 && bfd_make_section (abfd
, ".text") == (asection
*) NULL
)
398 if (obj_datasec (abfd
) == (asection
*) NULL
399 && bfd_make_section (abfd
, ".data") == (asection
*) NULL
)
401 if (obj_bsssec (abfd
) == (asection
*) NULL
402 && bfd_make_section (abfd
, ".bss") == (asection
*) NULL
)
409 aout_@var{size}_some_aout_object_p
412 const bfd_target *aout_@var{size}_some_aout_object_p
414 const bfd_target *(*callback_to_real_object_p)());
417 Some a.out variant thinks that the file open in @var{abfd}
418 checking is an a.out file. Do some more checking, and set up
419 for access if it really is. Call back to the calling
420 environment's "finish up" function just before returning, to
421 handle any last-minute setup.
425 NAME(aout
,some_aout_object_p
) (abfd
, execp
, callback_to_real_object_p
)
427 struct internal_exec
*execp
;
428 const bfd_target
*(*callback_to_real_object_p
) PARAMS ((bfd
*));
430 struct aout_data_struct
*rawptr
, *oldrawptr
;
431 const bfd_target
*result
;
433 rawptr
= (struct aout_data_struct
*) bfd_zalloc (abfd
, sizeof (struct aout_data_struct
));
437 oldrawptr
= abfd
->tdata
.aout_data
;
438 abfd
->tdata
.aout_data
= rawptr
;
440 /* Copy the contents of the old tdata struct.
441 In particular, we want the subformat, since for hpux it was set in
442 hp300hpux.c:swap_exec_header_in and will be used in
443 hp300hpux.c:callback. */
444 if (oldrawptr
!= NULL
)
445 *abfd
->tdata
.aout_data
= *oldrawptr
;
447 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
448 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
; /* Copy in the internal_exec struct */
449 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
451 /* Set the file flags */
452 abfd
->flags
= NO_FLAGS
;
453 if (execp
->a_drsize
|| execp
->a_trsize
)
454 abfd
->flags
|= HAS_RELOC
;
455 /* Setting of EXEC_P has been deferred to the bottom of this function */
457 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
458 if (N_DYNAMIC(*execp
))
459 abfd
->flags
|= DYNAMIC
;
461 if (N_MAGIC (*execp
) == ZMAGIC
)
463 abfd
->flags
|= D_PAGED
| WP_TEXT
;
464 adata (abfd
).magic
= z_magic
;
466 else if (N_MAGIC (*execp
) == QMAGIC
)
468 abfd
->flags
|= D_PAGED
| WP_TEXT
;
469 adata (abfd
).magic
= z_magic
;
470 adata (abfd
).subformat
= q_magic_format
;
472 else if (N_MAGIC (*execp
) == NMAGIC
)
474 abfd
->flags
|= WP_TEXT
;
475 adata (abfd
).magic
= n_magic
;
477 else if (N_MAGIC (*execp
) == OMAGIC
478 || N_MAGIC (*execp
) == BMAGIC
)
479 adata (abfd
).magic
= o_magic
;
482 /* Should have been checked with N_BADMAG before this routine
487 bfd_get_start_address (abfd
) = execp
->a_entry
;
489 obj_aout_symbols (abfd
) = (aout_symbol_type
*)NULL
;
490 bfd_get_symcount (abfd
) = execp
->a_syms
/ sizeof (struct external_nlist
);
492 /* The default relocation entry size is that of traditional V7 Unix. */
493 obj_reloc_entry_size (abfd
) = RELOC_STD_SIZE
;
495 /* The default symbol entry size is that of traditional Unix. */
496 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
499 bfd_init_window (&obj_aout_sym_window (abfd
));
500 bfd_init_window (&obj_aout_string_window (abfd
));
502 obj_aout_external_syms (abfd
) = NULL
;
503 obj_aout_external_strings (abfd
) = NULL
;
504 obj_aout_sym_hashes (abfd
) = NULL
;
506 if (! NAME(aout
,make_sections
) (abfd
))
509 obj_datasec (abfd
)->_raw_size
= execp
->a_data
;
510 obj_bsssec (abfd
)->_raw_size
= execp
->a_bss
;
512 obj_textsec (abfd
)->flags
=
513 (execp
->a_trsize
!= 0
514 ? (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_RELOC
)
515 : (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
));
516 obj_datasec (abfd
)->flags
=
517 (execp
->a_drsize
!= 0
518 ? (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_RELOC
)
519 : (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
));
520 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
522 #ifdef THIS_IS_ONLY_DOCUMENTATION
523 /* The common code can't fill in these things because they depend
524 on either the start address of the text segment, the rounding
525 up of virtual addresses between segments, or the starting file
526 position of the text segment -- all of which varies among different
527 versions of a.out. */
529 /* Call back to the format-dependent code to fill in the rest of the
530 fields and do any further cleanup. Things that should be filled
531 in by the callback: */
533 struct exec
*execp
= exec_hdr (abfd
);
535 obj_textsec (abfd
)->size
= N_TXTSIZE(*execp
);
536 obj_textsec (abfd
)->raw_size
= N_TXTSIZE(*execp
);
537 /* data and bss are already filled in since they're so standard */
539 /* The virtual memory addresses of the sections */
540 obj_textsec (abfd
)->vma
= N_TXTADDR(*execp
);
541 obj_datasec (abfd
)->vma
= N_DATADDR(*execp
);
542 obj_bsssec (abfd
)->vma
= N_BSSADDR(*execp
);
544 /* The file offsets of the sections */
545 obj_textsec (abfd
)->filepos
= N_TXTOFF(*execp
);
546 obj_datasec (abfd
)->filepos
= N_DATOFF(*execp
);
548 /* The file offsets of the relocation info */
549 obj_textsec (abfd
)->rel_filepos
= N_TRELOFF(*execp
);
550 obj_datasec (abfd
)->rel_filepos
= N_DRELOFF(*execp
);
552 /* The file offsets of the string table and symbol table. */
553 obj_str_filepos (abfd
) = N_STROFF (*execp
);
554 obj_sym_filepos (abfd
) = N_SYMOFF (*execp
);
556 /* Determine the architecture and machine type of the object file. */
557 switch (N_MACHTYPE (*exec_hdr (abfd
))) {
559 abfd
->obj_arch
= bfd_arch_obscure
;
563 adata(abfd
)->page_size
= TARGET_PAGE_SIZE
;
564 adata(abfd
)->segment_size
= SEGMENT_SIZE
;
565 adata(abfd
)->exec_bytes_size
= EXEC_BYTES_SIZE
;
569 /* The architecture is encoded in various ways in various a.out variants,
570 or is not encoded at all in some of them. The relocation size depends
571 on the architecture and the a.out variant. Finally, the return value
572 is the bfd_target vector in use. If an error occurs, return zero and
573 set bfd_error to the appropriate error code.
575 Formats such as b.out, which have additional fields in the a.out
576 header, should cope with them in this callback as well. */
577 #endif /* DOCUMENTATION */
579 result
= (*callback_to_real_object_p
)(abfd
);
581 /* Now that the segment addresses have been worked out, take a better
582 guess at whether the file is executable. If the entry point
583 is within the text segment, assume it is. (This makes files
584 executable even if their entry point address is 0, as long as
585 their text starts at zero.). */
586 if ((execp
->a_entry
>= obj_textsec(abfd
)->vma
) &&
587 (execp
->a_entry
< obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->_raw_size
))
588 abfd
->flags
|= EXEC_P
;
592 struct stat stat_buf
;
594 /* The original heuristic doesn't work in some important cases.
595 The a.out file has no information about the text start
596 address. For files (like kernels) linked to non-standard
597 addresses (ld -Ttext nnn) the entry point may not be between
598 the default text start (obj_textsec(abfd)->vma) and
599 (obj_textsec(abfd)->vma) + text size. This is not just a mach
600 issue. Many kernels are loaded at non standard addresses. */
601 if (abfd
->iostream
!= NULL
602 && (abfd
->flags
& BFD_IN_MEMORY
) == 0
603 && (fstat(fileno((FILE *) (abfd
->iostream
)), &stat_buf
) == 0)
604 && ((stat_buf
.st_mode
& 0111) != 0))
605 abfd
->flags
|= EXEC_P
;
607 #endif /* STAT_FOR_EXEC */
611 #if 0 /* These should be set correctly anyways. */
612 abfd
->sections
= obj_textsec (abfd
);
613 obj_textsec (abfd
)->next
= obj_datasec (abfd
);
614 obj_datasec (abfd
)->next
= obj_bsssec (abfd
);
620 abfd
->tdata
.aout_data
= oldrawptr
;
627 aout_@var{size}_mkobject
630 boolean aout_@var{size}_mkobject, (bfd *abfd);
633 Initialize BFD @var{abfd} for use with a.out files.
637 NAME(aout
,mkobject
) (abfd
)
640 struct aout_data_struct
*rawptr
;
642 bfd_set_error (bfd_error_system_call
);
644 /* Use an intermediate variable for clarity */
645 rawptr
= (struct aout_data_struct
*)bfd_zalloc (abfd
, sizeof (struct aout_data_struct
));
650 abfd
->tdata
.aout_data
= rawptr
;
651 exec_hdr (abfd
) = &(rawptr
->e
);
653 obj_textsec (abfd
) = (asection
*)NULL
;
654 obj_datasec (abfd
) = (asection
*)NULL
;
655 obj_bsssec (abfd
) = (asection
*)NULL
;
663 aout_@var{size}_machine_type
666 enum machine_type aout_@var{size}_machine_type
667 (enum bfd_architecture arch,
668 unsigned long machine));
671 Keep track of machine architecture and machine type for
672 a.out's. Return the <<machine_type>> for a particular
673 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
674 and machine can't be represented in a.out format.
676 If the architecture is understood, machine type 0 (default)
677 is always understood.
681 NAME(aout
,machine_type
) (arch
, machine
, unknown
)
682 enum bfd_architecture arch
;
683 unsigned long machine
;
686 enum machine_type arch_flags
;
688 arch_flags
= M_UNKNOWN
;
694 || machine
== bfd_mach_sparc
695 || machine
== bfd_mach_sparc_sparclite
696 || machine
== bfd_mach_sparc_v9
)
697 arch_flags
= M_SPARC
;
698 else if (machine
== bfd_mach_sparc_sparclet
)
699 arch_flags
= M_SPARCLET
;
704 case 0: arch_flags
= M_68010
; break;
705 case 68000: arch_flags
= M_UNKNOWN
; *unknown
= false; break;
706 case 68010: arch_flags
= M_68010
; break;
707 case 68020: arch_flags
= M_68020
; break;
708 default: arch_flags
= M_UNKNOWN
; break;
713 if (machine
== 0) arch_flags
= M_386
;
717 if (machine
== 0) arch_flags
= M_29K
;
721 if (machine
== 0) arch_flags
= M_ARM
;
728 case 3000: arch_flags
= M_MIPS1
; break;
729 case 4000: /* mips3 */
731 case 8000: /* mips4 */
733 case 6000: arch_flags
= M_MIPS2
; break;
734 default: arch_flags
= M_UNKNOWN
; break;
740 case 0: arch_flags
= M_NS32532
; break;
741 case 32032: arch_flags
= M_NS32032
; break;
742 case 32532: arch_flags
= M_NS32532
; break;
743 default: arch_flags
= M_UNKNOWN
; break;
751 /* start-sanitize-rce */
755 /* end-sanitize-rce */
758 arch_flags
= M_UNKNOWN
;
761 if (arch_flags
!= M_UNKNOWN
)
770 aout_@var{size}_set_arch_mach
773 boolean aout_@var{size}_set_arch_mach,
775 enum bfd_architecture arch,
776 unsigned long machine));
779 Set the architecture and the machine of the BFD @var{abfd} to the
780 values @var{arch} and @var{machine}. Verify that @var{abfd}'s format
781 can support the architecture required.
785 NAME(aout
,set_arch_mach
) (abfd
, arch
, machine
)
787 enum bfd_architecture arch
;
788 unsigned long machine
;
790 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
793 if (arch
!= bfd_arch_unknown
)
797 NAME(aout
,machine_type
) (arch
, machine
, &unknown
);
802 /* Determine the size of a relocation entry */
807 obj_reloc_entry_size (abfd
) = RELOC_EXT_SIZE
;
810 obj_reloc_entry_size (abfd
) = RELOC_STD_SIZE
;
814 return (*aout_backend_info(abfd
)->set_sizes
) (abfd
);
818 adjust_o_magic (abfd
, execp
)
820 struct internal_exec
*execp
;
822 file_ptr pos
= adata (abfd
).exec_bytes_size
;
827 obj_textsec(abfd
)->filepos
= pos
;
828 if (!obj_textsec(abfd
)->user_set_vma
)
829 obj_textsec(abfd
)->vma
= vma
;
831 vma
= obj_textsec(abfd
)->vma
;
833 pos
+= obj_textsec(abfd
)->_raw_size
;
834 vma
+= obj_textsec(abfd
)->_raw_size
;
837 if (!obj_datasec(abfd
)->user_set_vma
)
839 #if 0 /* ?? Does alignment in the file image really matter? */
840 pad
= align_power (vma
, obj_datasec(abfd
)->alignment_power
) - vma
;
842 obj_textsec(abfd
)->_raw_size
+= pad
;
845 obj_datasec(abfd
)->vma
= vma
;
848 vma
= obj_datasec(abfd
)->vma
;
849 obj_datasec(abfd
)->filepos
= pos
;
850 pos
+= obj_datasec(abfd
)->_raw_size
;
851 vma
+= obj_datasec(abfd
)->_raw_size
;
854 if (!obj_bsssec(abfd
)->user_set_vma
)
857 pad
= align_power (vma
, obj_bsssec(abfd
)->alignment_power
) - vma
;
859 obj_datasec(abfd
)->_raw_size
+= pad
;
862 obj_bsssec(abfd
)->vma
= vma
;
866 /* The VMA of the .bss section is set by the the VMA of the
867 .data section plus the size of the .data section. We may
868 need to add padding bytes to make this true. */
869 pad
= obj_bsssec (abfd
)->vma
- vma
;
872 obj_datasec (abfd
)->_raw_size
+= pad
;
876 obj_bsssec(abfd
)->filepos
= pos
;
878 /* Fix up the exec header. */
879 execp
->a_text
= obj_textsec(abfd
)->_raw_size
;
880 execp
->a_data
= obj_datasec(abfd
)->_raw_size
;
881 execp
->a_bss
= obj_bsssec(abfd
)->_raw_size
;
882 N_SET_MAGIC (*execp
, OMAGIC
);
886 adjust_z_magic (abfd
, execp
)
888 struct internal_exec
*execp
;
890 bfd_size_type data_pad
, text_pad
;
892 CONST
struct aout_backend_data
*abdp
;
893 int ztih
; /* Nonzero if text includes exec header. */
895 abdp
= aout_backend_info (abfd
);
899 && (abdp
->text_includes_header
900 || obj_aout_subformat (abfd
) == q_magic_format
));
901 obj_textsec(abfd
)->filepos
= (ztih
902 ? adata(abfd
).exec_bytes_size
903 : adata(abfd
).zmagic_disk_block_size
);
904 if (! obj_textsec(abfd
)->user_set_vma
)
906 /* ?? Do we really need to check for relocs here? */
907 obj_textsec(abfd
)->vma
= ((abfd
->flags
& HAS_RELOC
)
910 ? (abdp
->default_text_vma
911 + adata(abfd
).exec_bytes_size
)
912 : abdp
->default_text_vma
));
917 /* The .text section is being loaded at an unusual address. We
918 may need to pad it such that the .data section starts at a page
921 text_pad
= ((obj_textsec (abfd
)->filepos
- obj_textsec (abfd
)->vma
)
922 & (adata (abfd
).page_size
- 1));
924 text_pad
= ((- obj_textsec (abfd
)->vma
)
925 & (adata (abfd
).page_size
- 1));
928 /* Find start of data. */
931 text_end
= obj_textsec (abfd
)->filepos
+ obj_textsec (abfd
)->_raw_size
;
932 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
936 /* Note that if page_size == zmagic_disk_block_size, then
937 filepos == page_size, and this case is the same as the ztih
939 text_end
= obj_textsec (abfd
)->_raw_size
;
940 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
941 text_end
+= obj_textsec (abfd
)->filepos
;
943 obj_textsec(abfd
)->_raw_size
+= text_pad
;
944 text_end
+= text_pad
;
947 if (!obj_datasec(abfd
)->user_set_vma
)
950 vma
= obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->_raw_size
;
951 obj_datasec(abfd
)->vma
= BFD_ALIGN (vma
, adata(abfd
).segment_size
);
953 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
955 text_pad
= (obj_datasec(abfd
)->vma
956 - obj_textsec(abfd
)->vma
957 - obj_textsec(abfd
)->_raw_size
);
958 obj_textsec(abfd
)->_raw_size
+= text_pad
;
960 obj_datasec(abfd
)->filepos
= (obj_textsec(abfd
)->filepos
961 + obj_textsec(abfd
)->_raw_size
);
963 /* Fix up exec header while we're at it. */
964 execp
->a_text
= obj_textsec(abfd
)->_raw_size
;
965 if (ztih
&& (!abdp
|| (abdp
&& !abdp
->exec_header_not_counted
)))
966 execp
->a_text
+= adata(abfd
).exec_bytes_size
;
967 if (obj_aout_subformat (abfd
) == q_magic_format
)
968 N_SET_MAGIC (*execp
, QMAGIC
);
970 N_SET_MAGIC (*execp
, ZMAGIC
);
972 /* Spec says data section should be rounded up to page boundary. */
973 obj_datasec(abfd
)->_raw_size
974 = align_power (obj_datasec(abfd
)->_raw_size
,
975 obj_bsssec(abfd
)->alignment_power
);
976 execp
->a_data
= BFD_ALIGN (obj_datasec(abfd
)->_raw_size
,
977 adata(abfd
).page_size
);
978 data_pad
= execp
->a_data
- obj_datasec(abfd
)->_raw_size
;
981 if (!obj_bsssec(abfd
)->user_set_vma
)
982 obj_bsssec(abfd
)->vma
= (obj_datasec(abfd
)->vma
983 + obj_datasec(abfd
)->_raw_size
);
984 /* If the BSS immediately follows the data section and extra space
985 in the page is left after the data section, fudge data
986 in the header so that the bss section looks smaller by that
987 amount. We'll start the bss section there, and lie to the OS.
988 (Note that a linker script, as well as the above assignment,
989 could have explicitly set the BSS vma to immediately follow
990 the data section.) */
991 if (align_power (obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->alignment_power
)
992 == obj_datasec(abfd
)->vma
+ obj_datasec(abfd
)->_raw_size
)
993 execp
->a_bss
= (data_pad
> obj_bsssec(abfd
)->_raw_size
) ? 0 :
994 obj_bsssec(abfd
)->_raw_size
- data_pad
;
996 execp
->a_bss
= obj_bsssec(abfd
)->_raw_size
;
1000 adjust_n_magic (abfd
, execp
)
1002 struct internal_exec
*execp
;
1004 file_ptr pos
= adata(abfd
).exec_bytes_size
;
1009 obj_textsec(abfd
)->filepos
= pos
;
1010 if (!obj_textsec(abfd
)->user_set_vma
)
1011 obj_textsec(abfd
)->vma
= vma
;
1013 vma
= obj_textsec(abfd
)->vma
;
1014 pos
+= obj_textsec(abfd
)->_raw_size
;
1015 vma
+= obj_textsec(abfd
)->_raw_size
;
1018 obj_datasec(abfd
)->filepos
= pos
;
1019 if (!obj_datasec(abfd
)->user_set_vma
)
1020 obj_datasec(abfd
)->vma
= BFD_ALIGN (vma
, adata(abfd
).segment_size
);
1021 vma
= obj_datasec(abfd
)->vma
;
1023 /* Since BSS follows data immediately, see if it needs alignment. */
1024 vma
+= obj_datasec(abfd
)->_raw_size
;
1025 pad
= align_power (vma
, obj_bsssec(abfd
)->alignment_power
) - vma
;
1026 obj_datasec(abfd
)->_raw_size
+= pad
;
1027 pos
+= obj_datasec(abfd
)->_raw_size
;
1030 if (!obj_bsssec(abfd
)->user_set_vma
)
1031 obj_bsssec(abfd
)->vma
= vma
;
1033 vma
= obj_bsssec(abfd
)->vma
;
1035 /* Fix up exec header. */
1036 execp
->a_text
= obj_textsec(abfd
)->_raw_size
;
1037 execp
->a_data
= obj_datasec(abfd
)->_raw_size
;
1038 execp
->a_bss
= obj_bsssec(abfd
)->_raw_size
;
1039 N_SET_MAGIC (*execp
, NMAGIC
);
1043 NAME(aout
,adjust_sizes_and_vmas
) (abfd
, text_size
, text_end
)
1045 bfd_size_type
*text_size
;
1048 struct internal_exec
*execp
= exec_hdr (abfd
);
1050 if (! NAME(aout
,make_sections
) (abfd
))
1053 if (adata(abfd
).magic
!= undecided_magic
)
1056 obj_textsec(abfd
)->_raw_size
=
1057 align_power(obj_textsec(abfd
)->_raw_size
,
1058 obj_textsec(abfd
)->alignment_power
);
1060 *text_size
= obj_textsec (abfd
)->_raw_size
;
1061 /* Rule (heuristic) for when to pad to a new page. Note that there
1062 are (at least) two ways demand-paged (ZMAGIC) files have been
1063 handled. Most Berkeley-based systems start the text segment at
1064 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1065 segment right after the exec header; the latter is counted in the
1066 text segment size, and is paged in by the kernel with the rest of
1069 /* This perhaps isn't the right way to do this, but made it simpler for me
1070 to understand enough to implement it. Better would probably be to go
1071 right from BFD flags to alignment/positioning characteristics. But the
1072 old code was sloppy enough about handling the flags, and had enough
1073 other magic, that it was a little hard for me to understand. I think
1074 I understand it better now, but I haven't time to do the cleanup this
1077 if (abfd
->flags
& D_PAGED
)
1078 /* Whether or not WP_TEXT is set -- let D_PAGED override. */
1079 adata(abfd
).magic
= z_magic
;
1080 else if (abfd
->flags
& WP_TEXT
)
1081 adata(abfd
).magic
= n_magic
;
1083 adata(abfd
).magic
= o_magic
;
1085 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1087 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1089 switch (adata(abfd
).magic
) {
1090 case n_magic
: str
= "NMAGIC"; break;
1091 case o_magic
: str
= "OMAGIC"; break;
1092 case z_magic
: str
= "ZMAGIC"; break;
1097 obj_textsec(abfd
)->vma
, obj_textsec(abfd
)->_raw_size
,
1098 obj_textsec(abfd
)->alignment_power
,
1099 obj_datasec(abfd
)->vma
, obj_datasec(abfd
)->_raw_size
,
1100 obj_datasec(abfd
)->alignment_power
,
1101 obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->_raw_size
,
1102 obj_bsssec(abfd
)->alignment_power
);
1106 switch (adata(abfd
).magic
)
1109 adjust_o_magic (abfd
, execp
);
1112 adjust_z_magic (abfd
, execp
);
1115 adjust_n_magic (abfd
, execp
);
1121 #ifdef BFD_AOUT_DEBUG
1122 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1123 obj_textsec(abfd
)->vma
, obj_textsec(abfd
)->_raw_size
,
1124 obj_textsec(abfd
)->filepos
,
1125 obj_datasec(abfd
)->vma
, obj_datasec(abfd
)->_raw_size
,
1126 obj_datasec(abfd
)->filepos
,
1127 obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->_raw_size
);
1135 aout_@var{size}_new_section_hook
1138 boolean aout_@var{size}_new_section_hook,
1140 asection *newsect));
1143 Called by the BFD in response to a @code{bfd_make_section}
1147 NAME(aout
,new_section_hook
) (abfd
, newsect
)
1151 /* align to double at least */
1152 newsect
->alignment_power
= bfd_get_arch_info(abfd
)->section_align_power
;
1155 if (bfd_get_format (abfd
) == bfd_object
)
1157 if (obj_textsec(abfd
) == NULL
&& !strcmp(newsect
->name
, ".text")) {
1158 obj_textsec(abfd
)= newsect
;
1159 newsect
->target_index
= N_TEXT
;
1163 if (obj_datasec(abfd
) == NULL
&& !strcmp(newsect
->name
, ".data")) {
1164 obj_datasec(abfd
) = newsect
;
1165 newsect
->target_index
= N_DATA
;
1169 if (obj_bsssec(abfd
) == NULL
&& !strcmp(newsect
->name
, ".bss")) {
1170 obj_bsssec(abfd
) = newsect
;
1171 newsect
->target_index
= N_BSS
;
1177 /* We allow more than three sections internally */
1182 NAME(aout
,set_section_contents
) (abfd
, section
, location
, offset
, count
)
1187 bfd_size_type count
;
1190 bfd_size_type text_size
;
1192 if (! abfd
->output_has_begun
)
1194 if (! NAME(aout
,adjust_sizes_and_vmas
) (abfd
, &text_size
, &text_end
))
1198 if (section
== obj_bsssec (abfd
))
1200 bfd_set_error (bfd_error_no_contents
);
1204 if (section
!= obj_textsec (abfd
)
1205 && section
!= obj_datasec (abfd
))
1207 (*_bfd_error_handler
)
1208 ("%s: can not represent section `%s' in a.out object file format",
1209 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
));
1210 bfd_set_error (bfd_error_nonrepresentable_section
);
1216 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
1217 || bfd_write (location
, 1, count
, abfd
) != count
)
1224 /* Read the external symbols from an a.out file. */
1227 aout_get_external_symbols (abfd
)
1230 if (obj_aout_external_syms (abfd
) == (struct external_nlist
*) NULL
)
1232 bfd_size_type count
;
1233 struct external_nlist
*syms
;
1235 count
= exec_hdr (abfd
)->a_syms
/ EXTERNAL_NLIST_SIZE
;
1238 if (bfd_get_file_window (abfd
,
1239 obj_sym_filepos (abfd
), exec_hdr (abfd
)->a_syms
,
1240 &obj_aout_sym_window (abfd
), true) == false)
1242 syms
= (struct external_nlist
*) obj_aout_sym_window (abfd
).data
;
1244 /* We allocate using malloc to make the values easy to free
1245 later on. If we put them on the obstack it might not be
1246 possible to free them. */
1247 syms
= ((struct external_nlist
*)
1248 bfd_malloc ((size_t) count
* EXTERNAL_NLIST_SIZE
));
1249 if (syms
== (struct external_nlist
*) NULL
&& count
!= 0)
1252 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1253 || (bfd_read (syms
, 1, exec_hdr (abfd
)->a_syms
, abfd
)
1254 != exec_hdr (abfd
)->a_syms
))
1261 obj_aout_external_syms (abfd
) = syms
;
1262 obj_aout_external_sym_count (abfd
) = count
;
1265 if (obj_aout_external_strings (abfd
) == NULL
1266 && exec_hdr (abfd
)->a_syms
!= 0)
1268 unsigned char string_chars
[BYTES_IN_WORD
];
1269 bfd_size_type stringsize
;
1272 /* Get the size of the strings. */
1273 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
1274 || (bfd_read ((PTR
) string_chars
, BYTES_IN_WORD
, 1, abfd
)
1277 stringsize
= GET_WORD (abfd
, string_chars
);
1280 if (bfd_get_file_window (abfd
, obj_str_filepos (abfd
), stringsize
,
1281 &obj_aout_string_window (abfd
), true) == false)
1283 strings
= (char *) obj_aout_string_window (abfd
).data
;
1285 strings
= (char *) bfd_malloc ((size_t) stringsize
+ 1);
1286 if (strings
== NULL
)
1289 /* Skip space for the string count in the buffer for convenience
1290 when using indexes. */
1291 if (bfd_read (strings
+ BYTES_IN_WORD
, 1, stringsize
- BYTES_IN_WORD
,
1293 != stringsize
- BYTES_IN_WORD
)
1300 /* Ensure that a zero index yields an empty string. */
1303 strings
[stringsize
- 1] = 0;
1305 obj_aout_external_strings (abfd
) = strings
;
1306 obj_aout_external_string_size (abfd
) = stringsize
;
1312 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1313 and symbol->value fields of CACHE_PTR will be set from the a.out
1314 nlist structure. This function is responsible for setting
1315 symbol->flags and symbol->section, and adjusting symbol->value. */
1318 translate_from_native_sym_flags (abfd
, cache_ptr
)
1320 aout_symbol_type
*cache_ptr
;
1324 if ((cache_ptr
->type
& N_STAB
) != 0
1325 || cache_ptr
->type
== N_FN
)
1329 /* This is a debugging symbol. */
1331 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1333 /* Work out the symbol section. */
1334 switch (cache_ptr
->type
& N_TYPE
)
1338 sec
= obj_textsec (abfd
);
1341 sec
= obj_datasec (abfd
);
1344 sec
= obj_bsssec (abfd
);
1348 sec
= bfd_abs_section_ptr
;
1352 cache_ptr
->symbol
.section
= sec
;
1353 cache_ptr
->symbol
.value
-= sec
->vma
;
1358 /* Get the default visibility. This does not apply to all types, so
1359 we just hold it in a local variable to use if wanted. */
1360 if ((cache_ptr
->type
& N_EXT
) == 0)
1361 visible
= BSF_LOCAL
;
1363 visible
= BSF_GLOBAL
;
1365 switch (cache_ptr
->type
)
1368 case N_ABS
: case N_ABS
| N_EXT
:
1369 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1370 cache_ptr
->symbol
.flags
= visible
;
1373 case N_UNDF
| N_EXT
:
1374 if (cache_ptr
->symbol
.value
!= 0)
1376 /* This is a common symbol. */
1377 cache_ptr
->symbol
.flags
= BSF_GLOBAL
;
1378 cache_ptr
->symbol
.section
= bfd_com_section_ptr
;
1382 cache_ptr
->symbol
.flags
= 0;
1383 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1387 case N_TEXT
: case N_TEXT
| N_EXT
:
1388 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1389 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1390 cache_ptr
->symbol
.flags
= visible
;
1393 /* N_SETV symbols used to represent set vectors placed in the
1394 data section. They are no longer generated. Theoretically,
1395 it was possible to extract the entries and combine them with
1396 new ones, although I don't know if that was ever actually
1397 done. Unless that feature is restored, treat them as data
1399 case N_SETV
: case N_SETV
| N_EXT
:
1400 case N_DATA
: case N_DATA
| N_EXT
:
1401 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1402 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1403 cache_ptr
->symbol
.flags
= visible
;
1406 case N_BSS
: case N_BSS
| N_EXT
:
1407 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1408 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1409 cache_ptr
->symbol
.flags
= visible
;
1412 case N_SETA
: case N_SETA
| N_EXT
:
1413 case N_SETT
: case N_SETT
| N_EXT
:
1414 case N_SETD
: case N_SETD
| N_EXT
:
1415 case N_SETB
: case N_SETB
| N_EXT
:
1417 /* This code is no longer needed. It used to be used to make
1418 the linker handle set symbols, but they are now handled in
1419 the add_symbols routine instead. */
1422 arelent_chain
*reloc
;
1423 asection
*into_section
;
1425 /* This is a set symbol. The name of the symbol is the name
1426 of the set (e.g., __CTOR_LIST__). The value of the symbol
1427 is the value to add to the set. We create a section with
1428 the same name as the symbol, and add a reloc to insert the
1429 appropriate value into the section.
1431 This action is actually obsolete; it used to make the
1432 linker do the right thing, but the linker no longer uses
1435 section
= bfd_get_section_by_name (abfd
, cache_ptr
->symbol
.name
);
1436 if (section
== NULL
)
1440 copy
= bfd_alloc (abfd
, strlen (cache_ptr
->symbol
.name
) + 1);
1444 strcpy (copy
, cache_ptr
->symbol
.name
);
1445 section
= bfd_make_section (abfd
, copy
);
1446 if (section
== NULL
)
1450 reloc
= (arelent_chain
*) bfd_alloc (abfd
, sizeof (arelent_chain
));
1454 /* Build a relocation entry for the constructor. */
1455 switch (cache_ptr
->type
& N_TYPE
)
1458 into_section
= bfd_abs_section_ptr
;
1459 cache_ptr
->type
= N_ABS
;
1462 into_section
= obj_textsec (abfd
);
1463 cache_ptr
->type
= N_TEXT
;
1466 into_section
= obj_datasec (abfd
);
1467 cache_ptr
->type
= N_DATA
;
1470 into_section
= obj_bsssec (abfd
);
1471 cache_ptr
->type
= N_BSS
;
1475 /* Build a relocation pointing into the constructor section
1476 pointing at the symbol in the set vector specified. */
1477 reloc
->relent
.addend
= cache_ptr
->symbol
.value
;
1478 cache_ptr
->symbol
.section
= into_section
;
1479 reloc
->relent
.sym_ptr_ptr
= into_section
->symbol_ptr_ptr
;
1481 /* We modify the symbol to belong to a section depending upon
1482 the name of the symbol, and add to the size of the section
1483 to contain a pointer to the symbol. Build a reloc entry to
1484 relocate to this symbol attached to this section. */
1485 section
->flags
= SEC_CONSTRUCTOR
| SEC_RELOC
;
1487 section
->reloc_count
++;
1488 section
->alignment_power
= 2;
1490 reloc
->next
= section
->constructor_chain
;
1491 section
->constructor_chain
= reloc
;
1492 reloc
->relent
.address
= section
->_raw_size
;
1493 section
->_raw_size
+= BYTES_IN_WORD
;
1495 reloc
->relent
.howto
= CTOR_TABLE_RELOC_HOWTO(abfd
);
1499 switch (cache_ptr
->type
& N_TYPE
)
1502 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1505 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1508 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1511 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1515 cache_ptr
->symbol
.flags
|= BSF_CONSTRUCTOR
;
1520 /* This symbol is the text of a warning message. The next
1521 symbol is the symbol to associate the warning with. If a
1522 reference is made to that symbol, a warning is issued. */
1523 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
| BSF_WARNING
;
1524 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1527 case N_INDR
: case N_INDR
| N_EXT
:
1528 /* An indirect symbol. This consists of two symbols in a row.
1529 The first symbol is the name of the indirection. The second
1530 symbol is the name of the target. A reference to the first
1531 symbol becomes a reference to the second. */
1532 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
| BSF_INDIRECT
| visible
;
1533 cache_ptr
->symbol
.section
= bfd_ind_section_ptr
;
1537 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1538 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1542 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1543 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1547 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1548 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1549 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1553 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1554 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1555 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1559 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1560 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1561 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1568 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1571 translate_to_native_sym_flags (abfd
, cache_ptr
, sym_pointer
)
1574 struct external_nlist
*sym_pointer
;
1576 bfd_vma value
= cache_ptr
->value
;
1580 /* Mask out any existing type bits in case copying from one section
1582 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1584 sec
= bfd_get_section (cache_ptr
);
1589 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1591 (*_bfd_error_handler
)
1592 ("%s: can not represent section `%s' in a.out object file format",
1593 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sec
));
1594 bfd_set_error (bfd_error_nonrepresentable_section
);
1598 if (sec
->output_section
!= NULL
)
1600 off
= sec
->output_offset
;
1601 sec
= sec
->output_section
;
1604 if (bfd_is_abs_section (sec
))
1605 sym_pointer
->e_type
[0] |= N_ABS
;
1606 else if (sec
== obj_textsec (abfd
))
1607 sym_pointer
->e_type
[0] |= N_TEXT
;
1608 else if (sec
== obj_datasec (abfd
))
1609 sym_pointer
->e_type
[0] |= N_DATA
;
1610 else if (sec
== obj_bsssec (abfd
))
1611 sym_pointer
->e_type
[0] |= N_BSS
;
1612 else if (bfd_is_und_section (sec
))
1613 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1614 else if (bfd_is_ind_section (sec
))
1615 sym_pointer
->e_type
[0] = N_INDR
;
1616 else if (bfd_is_com_section (sec
))
1617 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1620 (*_bfd_error_handler
)
1621 ("%s: can not represent section `%s' in a.out object file format",
1622 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sec
));
1623 bfd_set_error (bfd_error_nonrepresentable_section
);
1627 /* Turn the symbol from section relative to absolute again */
1628 value
+= sec
->vma
+ off
;
1630 if ((cache_ptr
->flags
& BSF_WARNING
) != 0)
1631 sym_pointer
->e_type
[0] = N_WARNING
;
1633 if ((cache_ptr
->flags
& BSF_DEBUGGING
) != 0)
1634 sym_pointer
->e_type
[0] = ((aout_symbol_type
*) cache_ptr
)->type
;
1635 else if ((cache_ptr
->flags
& BSF_GLOBAL
) != 0)
1636 sym_pointer
->e_type
[0] |= N_EXT
;
1638 if ((cache_ptr
->flags
& BSF_CONSTRUCTOR
) != 0)
1640 int type
= ((aout_symbol_type
*) cache_ptr
)->type
;
1643 case N_ABS
: type
= N_SETA
; break;
1644 case N_TEXT
: type
= N_SETT
; break;
1645 case N_DATA
: type
= N_SETD
; break;
1646 case N_BSS
: type
= N_SETB
; break;
1648 sym_pointer
->e_type
[0] = type
;
1651 if ((cache_ptr
->flags
& BSF_WEAK
) != 0)
1655 switch (sym_pointer
->e_type
[0] & N_TYPE
)
1658 case N_ABS
: type
= N_WEAKA
; break;
1659 case N_TEXT
: type
= N_WEAKT
; break;
1660 case N_DATA
: type
= N_WEAKD
; break;
1661 case N_BSS
: type
= N_WEAKB
; break;
1662 case N_UNDF
: type
= N_WEAKU
; break;
1664 sym_pointer
->e_type
[0] = type
;
1667 PUT_WORD(abfd
, value
, sym_pointer
->e_value
);
1672 /* Native-level interface to symbols. */
1675 NAME(aout
,make_empty_symbol
) (abfd
)
1678 aout_symbol_type
*new =
1679 (aout_symbol_type
*)bfd_zalloc (abfd
, sizeof (aout_symbol_type
));
1682 new->symbol
.the_bfd
= abfd
;
1684 return &new->symbol
;
1687 /* Translate a set of internal symbols into external symbols. */
1690 NAME(aout
,translate_symbol_table
) (abfd
, in
, ext
, count
, str
, strsize
, dynamic
)
1692 aout_symbol_type
*in
;
1693 struct external_nlist
*ext
;
1694 bfd_size_type count
;
1696 bfd_size_type strsize
;
1699 struct external_nlist
*ext_end
;
1701 ext_end
= ext
+ count
;
1702 for (; ext
< ext_end
; ext
++, in
++)
1706 x
= GET_WORD (abfd
, ext
->e_strx
);
1707 in
->symbol
.the_bfd
= abfd
;
1709 /* For the normal symbols, the zero index points at the number
1710 of bytes in the string table but is to be interpreted as the
1711 null string. For the dynamic symbols, the number of bytes in
1712 the string table is stored in the __DYNAMIC structure and the
1713 zero index points at an actual string. */
1714 if (x
== 0 && ! dynamic
)
1715 in
->symbol
.name
= "";
1716 else if (x
< strsize
)
1717 in
->symbol
.name
= str
+ x
;
1721 in
->symbol
.value
= GET_SWORD (abfd
, ext
->e_value
);
1722 in
->desc
= bfd_h_get_16 (abfd
, ext
->e_desc
);
1723 in
->other
= bfd_h_get_8 (abfd
, ext
->e_other
);
1724 in
->type
= bfd_h_get_8 (abfd
, ext
->e_type
);
1725 in
->symbol
.udata
.p
= NULL
;
1727 if (! translate_from_native_sym_flags (abfd
, in
))
1731 in
->symbol
.flags
|= BSF_DYNAMIC
;
1737 /* We read the symbols into a buffer, which is discarded when this
1738 function exits. We read the strings into a buffer large enough to
1739 hold them all plus all the cached symbol entries. */
1742 NAME(aout
,slurp_symbol_table
) (abfd
)
1745 struct external_nlist
*old_external_syms
;
1746 aout_symbol_type
*cached
;
1749 /* If there's no work to be done, don't do any */
1750 if (obj_aout_symbols (abfd
) != (aout_symbol_type
*) NULL
)
1753 old_external_syms
= obj_aout_external_syms (abfd
);
1755 if (! aout_get_external_symbols (abfd
))
1758 cached_size
= (obj_aout_external_sym_count (abfd
)
1759 * sizeof (aout_symbol_type
));
1760 cached
= (aout_symbol_type
*) bfd_malloc (cached_size
);
1761 if (cached
== NULL
&& cached_size
!= 0)
1763 if (cached_size
!= 0)
1764 memset (cached
, 0, cached_size
);
1766 /* Convert from external symbol information to internal. */
1767 if (! (NAME(aout
,translate_symbol_table
)
1769 obj_aout_external_syms (abfd
),
1770 obj_aout_external_sym_count (abfd
),
1771 obj_aout_external_strings (abfd
),
1772 obj_aout_external_string_size (abfd
),
1779 bfd_get_symcount (abfd
) = obj_aout_external_sym_count (abfd
);
1781 obj_aout_symbols (abfd
) = cached
;
1783 /* It is very likely that anybody who calls this function will not
1784 want the external symbol information, so if it was allocated
1785 because of our call to aout_get_external_symbols, we free it up
1786 right away to save space. */
1787 if (old_external_syms
== (struct external_nlist
*) NULL
1788 && obj_aout_external_syms (abfd
) != (struct external_nlist
*) NULL
)
1791 bfd_free_window (&obj_aout_sym_window (abfd
));
1793 free (obj_aout_external_syms (abfd
));
1795 obj_aout_external_syms (abfd
) = NULL
;
1801 /* We use a hash table when writing out symbols so that we only write
1802 out a particular string once. This helps particularly when the
1803 linker writes out stabs debugging entries, because each different
1804 contributing object file tends to have many duplicate stabs
1807 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1808 if BFD_TRADITIONAL_FORMAT is set. */
1810 static bfd_size_type add_to_stringtab
1811 PARAMS ((bfd
*, struct bfd_strtab_hash
*, const char *, boolean
));
1812 static boolean emit_stringtab
PARAMS ((bfd
*, struct bfd_strtab_hash
*));
1814 /* Get the index of a string in a strtab, adding it if it is not
1817 static INLINE bfd_size_type
1818 add_to_stringtab (abfd
, tab
, str
, copy
)
1820 struct bfd_strtab_hash
*tab
;
1825 bfd_size_type index
;
1827 /* An index of 0 always means the empty string. */
1828 if (str
== 0 || *str
== '\0')
1831 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1832 doesn't understand a hashed string table. */
1834 if ((abfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1837 index
= _bfd_stringtab_add (tab
, str
, hash
, copy
);
1839 if (index
!= (bfd_size_type
) -1)
1841 /* Add BYTES_IN_WORD to the return value to account for the
1842 space taken up by the string table size. */
1843 index
+= BYTES_IN_WORD
;
1849 /* Write out a strtab. ABFD is already at the right location in the
1853 emit_stringtab (abfd
, tab
)
1855 struct bfd_strtab_hash
*tab
;
1857 bfd_byte buffer
[BYTES_IN_WORD
];
1859 /* The string table starts with the size. */
1860 PUT_WORD (abfd
, _bfd_stringtab_size (tab
) + BYTES_IN_WORD
, buffer
);
1861 if (bfd_write ((PTR
) buffer
, 1, BYTES_IN_WORD
, abfd
) != BYTES_IN_WORD
)
1864 return _bfd_stringtab_emit (abfd
, tab
);
1868 NAME(aout
,write_syms
) (abfd
)
1871 unsigned int count
;
1872 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1873 struct bfd_strtab_hash
*strtab
;
1875 strtab
= _bfd_stringtab_init ();
1879 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1881 asymbol
*g
= generic
[count
];
1883 struct external_nlist nsp
;
1885 indx
= add_to_stringtab (abfd
, strtab
, g
->name
, false);
1886 if (indx
== (bfd_size_type
) -1)
1888 PUT_WORD (abfd
, indx
, (bfd_byte
*) nsp
.e_strx
);
1890 if (bfd_asymbol_flavour(g
) == abfd
->xvec
->flavour
)
1892 bfd_h_put_16(abfd
, aout_symbol(g
)->desc
, nsp
.e_desc
);
1893 bfd_h_put_8(abfd
, aout_symbol(g
)->other
, nsp
.e_other
);
1894 bfd_h_put_8(abfd
, aout_symbol(g
)->type
, nsp
.e_type
);
1898 bfd_h_put_16(abfd
,0, nsp
.e_desc
);
1899 bfd_h_put_8(abfd
, 0, nsp
.e_other
);
1900 bfd_h_put_8(abfd
, 0, nsp
.e_type
);
1903 if (! translate_to_native_sym_flags (abfd
, g
, &nsp
))
1906 if (bfd_write((PTR
)&nsp
,1,EXTERNAL_NLIST_SIZE
, abfd
)
1907 != EXTERNAL_NLIST_SIZE
)
1910 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1911 here, at the end. */
1915 if (! emit_stringtab (abfd
, strtab
))
1918 _bfd_stringtab_free (strtab
);
1923 _bfd_stringtab_free (strtab
);
1929 NAME(aout
,get_symtab
) (abfd
, location
)
1933 unsigned int counter
= 0;
1934 aout_symbol_type
*symbase
;
1936 if (!NAME(aout
,slurp_symbol_table
)(abfd
))
1939 for (symbase
= obj_aout_symbols(abfd
); counter
++ < bfd_get_symcount (abfd
);)
1940 *(location
++) = (asymbol
*)( symbase
++);
1942 return bfd_get_symcount (abfd
);
1946 /* Standard reloc stuff */
1947 /* Output standard relocation information to a file in target byte order. */
1950 NAME(aout
,swap_std_reloc_out
) (abfd
, g
, natptr
)
1953 struct reloc_std_external
*natptr
;
1956 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1958 unsigned int r_length
;
1960 int r_baserel
, r_jmptable
, r_relative
;
1961 asection
*output_section
= sym
->section
->output_section
;
1963 PUT_WORD(abfd
, g
->address
, natptr
->r_address
);
1965 r_length
= g
->howto
->size
; /* Size as a power of two */
1966 r_pcrel
= (int) g
->howto
->pc_relative
; /* Relative to PC? */
1967 /* XXX This relies on relocs coming from a.out files. */
1968 r_baserel
= (g
->howto
->type
& 8) != 0;
1969 r_jmptable
= (g
->howto
->type
& 16) != 0;
1970 r_relative
= (g
->howto
->type
& 32) != 0;
1973 /* For a standard reloc, the addend is in the object file. */
1974 r_addend
= g
->addend
+ (*(g
->sym_ptr_ptr
))->section
->output_section
->vma
;
1977 /* name was clobbered by aout_write_syms to be symbol index */
1979 /* If this relocation is relative to a symbol then set the
1980 r_index to the symbols index, and the r_extern bit.
1982 Absolute symbols can come in in two ways, either as an offset
1983 from the abs section, or as a symbol which has an abs value.
1988 if (bfd_is_com_section (output_section
)
1989 || bfd_is_abs_section (output_section
)
1990 || bfd_is_und_section (output_section
))
1992 if (bfd_abs_section_ptr
->symbol
== sym
)
1994 /* Whoops, looked like an abs symbol, but is really an offset
1995 from the abs section */
2001 /* Fill in symbol */
2003 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
2009 /* Just an ordinary section */
2011 r_index
= output_section
->target_index
;
2014 /* now the fun stuff */
2015 if (bfd_header_big_endian (abfd
)) {
2016 natptr
->r_index
[0] = r_index
>> 16;
2017 natptr
->r_index
[1] = r_index
>> 8;
2018 natptr
->r_index
[2] = r_index
;
2020 (r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
2021 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
2022 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
2023 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
2024 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
2025 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
);
2027 natptr
->r_index
[2] = r_index
>> 16;
2028 natptr
->r_index
[1] = r_index
>> 8;
2029 natptr
->r_index
[0] = r_index
;
2031 (r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
2032 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
2033 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
2034 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
2035 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
2036 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
);
2041 /* Extended stuff */
2042 /* Output extended relocation information to a file in target byte order. */
2045 NAME(aout
,swap_ext_reloc_out
) (abfd
, g
, natptr
)
2048 register struct reloc_ext_external
*natptr
;
2052 unsigned int r_type
;
2053 unsigned int r_addend
;
2054 asymbol
*sym
= *(g
->sym_ptr_ptr
);
2055 asection
*output_section
= sym
->section
->output_section
;
2057 PUT_WORD (abfd
, g
->address
, natptr
->r_address
);
2059 r_type
= (unsigned int) g
->howto
->type
;
2061 r_addend
= g
->addend
;
2062 if ((sym
->flags
& BSF_SECTION_SYM
) != 0)
2063 r_addend
+= (*(g
->sym_ptr_ptr
))->section
->output_section
->vma
;
2065 /* If this relocation is relative to a symbol then set the
2066 r_index to the symbols index, and the r_extern bit.
2068 Absolute symbols can come in in two ways, either as an offset
2069 from the abs section, or as a symbol which has an abs value.
2070 check for that here. */
2072 if (bfd_is_abs_section (bfd_get_section (sym
)))
2077 else if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2079 if (bfd_is_und_section (bfd_get_section (sym
))
2080 || (sym
->flags
& BSF_GLOBAL
) != 0)
2084 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
2088 /* Just an ordinary section */
2090 r_index
= output_section
->target_index
;
2093 /* now the fun stuff */
2094 if (bfd_header_big_endian (abfd
)) {
2095 natptr
->r_index
[0] = r_index
>> 16;
2096 natptr
->r_index
[1] = r_index
>> 8;
2097 natptr
->r_index
[2] = r_index
;
2099 ((r_extern
? RELOC_EXT_BITS_EXTERN_BIG
: 0)
2100 | (r_type
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
2102 natptr
->r_index
[2] = r_index
>> 16;
2103 natptr
->r_index
[1] = r_index
>> 8;
2104 natptr
->r_index
[0] = r_index
;
2106 (r_extern
? RELOC_EXT_BITS_EXTERN_LITTLE
: 0)
2107 | (r_type
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
);
2110 PUT_WORD (abfd
, r_addend
, natptr
->r_addend
);
2113 /* BFD deals internally with all things based from the section they're
2114 in. so, something in 10 bytes into a text section with a base of
2115 50 would have a symbol (.text+10) and know .text vma was 50.
2117 Aout keeps all it's symbols based from zero, so the symbol would
2118 contain 60. This macro subs the base of each section from the value
2119 to give the true offset from the section */
2122 #define MOVE_ADDRESS(ad) \
2124 /* undefined symbol */ \
2125 cache_ptr->sym_ptr_ptr = symbols + r_index; \
2126 cache_ptr->addend = ad; \
2128 /* defined, section relative. replace symbol with pointer to \
2129 symbol which points to section */ \
2130 switch (r_index) { \
2132 case N_TEXT | N_EXT: \
2133 cache_ptr->sym_ptr_ptr = obj_textsec(abfd)->symbol_ptr_ptr; \
2134 cache_ptr->addend = ad - su->textsec->vma; \
2137 case N_DATA | N_EXT: \
2138 cache_ptr->sym_ptr_ptr = obj_datasec(abfd)->symbol_ptr_ptr; \
2139 cache_ptr->addend = ad - su->datasec->vma; \
2142 case N_BSS | N_EXT: \
2143 cache_ptr->sym_ptr_ptr = obj_bsssec(abfd)->symbol_ptr_ptr; \
2144 cache_ptr->addend = ad - su->bsssec->vma; \
2148 case N_ABS | N_EXT: \
2149 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
2150 cache_ptr->addend = ad; \
2156 NAME(aout
,swap_ext_reloc_in
) (abfd
, bytes
, cache_ptr
, symbols
, symcount
)
2158 struct reloc_ext_external
*bytes
;
2161 bfd_size_type symcount
;
2163 unsigned int r_index
;
2165 unsigned int r_type
;
2166 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
2168 cache_ptr
->address
= (GET_SWORD (abfd
, bytes
->r_address
));
2170 /* now the fun stuff */
2171 if (bfd_header_big_endian (abfd
)) {
2172 r_index
= (bytes
->r_index
[0] << 16)
2173 | (bytes
->r_index
[1] << 8)
2174 | bytes
->r_index
[2];
2175 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
2176 r_type
= (bytes
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
2177 >> RELOC_EXT_BITS_TYPE_SH_BIG
;
2179 r_index
= (bytes
->r_index
[2] << 16)
2180 | (bytes
->r_index
[1] << 8)
2181 | bytes
->r_index
[0];
2182 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
2183 r_type
= (bytes
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
2184 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
;
2187 cache_ptr
->howto
= howto_table_ext
+ r_type
;
2189 /* Base relative relocs are always against the symbol table,
2190 regardless of the setting of r_extern. r_extern just reflects
2191 whether the symbol the reloc is against is local or global. */
2192 if (r_type
== RELOC_BASE10
2193 || r_type
== RELOC_BASE13
2194 || r_type
== RELOC_BASE22
)
2197 if (r_extern
&& r_index
> symcount
)
2199 /* We could arrange to return an error, but it might be useful
2200 to see the file even if it is bad. */
2205 MOVE_ADDRESS(GET_SWORD(abfd
, bytes
->r_addend
));
2209 NAME(aout
,swap_std_reloc_in
) (abfd
, bytes
, cache_ptr
, symbols
, symcount
)
2211 struct reloc_std_external
*bytes
;
2214 bfd_size_type symcount
;
2216 unsigned int r_index
;
2218 unsigned int r_length
;
2220 int r_baserel
, r_jmptable
, r_relative
;
2221 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
2222 unsigned int howto_idx
;
2224 cache_ptr
->address
= bfd_h_get_32 (abfd
, bytes
->r_address
);
2226 /* now the fun stuff */
2227 if (bfd_header_big_endian (abfd
)) {
2228 r_index
= (bytes
->r_index
[0] << 16)
2229 | (bytes
->r_index
[1] << 8)
2230 | bytes
->r_index
[2];
2231 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
));
2232 r_pcrel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_PCREL_BIG
));
2233 r_baserel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
2234 r_jmptable
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
2235 r_relative
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_RELATIVE_BIG
));
2236 r_length
= (bytes
->r_type
[0] & RELOC_STD_BITS_LENGTH_BIG
)
2237 >> RELOC_STD_BITS_LENGTH_SH_BIG
;
2239 r_index
= (bytes
->r_index
[2] << 16)
2240 | (bytes
->r_index
[1] << 8)
2241 | bytes
->r_index
[0];
2242 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
));
2243 r_pcrel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_PCREL_LITTLE
));
2244 r_baserel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_BASEREL_LITTLE
));
2245 r_jmptable
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_LITTLE
));
2246 r_relative
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_RELATIVE_LITTLE
));
2247 r_length
= (bytes
->r_type
[0] & RELOC_STD_BITS_LENGTH_LITTLE
)
2248 >> RELOC_STD_BITS_LENGTH_SH_LITTLE
;
2251 howto_idx
= r_length
+ 4 * r_pcrel
+ 8 * r_baserel
2252 + 16 * r_jmptable
+ 32 * r_relative
;
2253 BFD_ASSERT (howto_idx
< TABLE_SIZE (howto_table_std
));
2254 cache_ptr
->howto
= howto_table_std
+ howto_idx
;
2255 BFD_ASSERT (cache_ptr
->howto
->type
!= (unsigned int) -1);
2257 /* Base relative relocs are always against the symbol table,
2258 regardless of the setting of r_extern. r_extern just reflects
2259 whether the symbol the reloc is against is local or global. */
2263 if (r_extern
&& r_index
> symcount
)
2265 /* We could arrange to return an error, but it might be useful
2266 to see the file even if it is bad. */
2274 /* Read and swap the relocs for a section. */
2277 NAME(aout
,slurp_reloc_table
) (abfd
, asect
, symbols
)
2283 bfd_size_type reloc_size
;
2285 arelent
*reloc_cache
;
2287 unsigned int counter
= 0;
2290 if (asect
->relocation
)
2293 if (asect
->flags
& SEC_CONSTRUCTOR
)
2296 if (asect
== obj_datasec (abfd
))
2297 reloc_size
= exec_hdr(abfd
)->a_drsize
;
2298 else if (asect
== obj_textsec (abfd
))
2299 reloc_size
= exec_hdr(abfd
)->a_trsize
;
2300 else if (asect
== obj_bsssec (abfd
))
2304 bfd_set_error (bfd_error_invalid_operation
);
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 reloc_cache
= (arelent
*) bfd_malloc ((size_t) (count
* sizeof (arelent
)));
2316 if (reloc_cache
== NULL
&& count
!= 0)
2318 memset (reloc_cache
, 0, count
* sizeof (arelent
));
2320 relocs
= bfd_malloc ((size_t) reloc_size
);
2321 if (relocs
== NULL
&& reloc_size
!= 0)
2327 if (bfd_read (relocs
, 1, reloc_size
, abfd
) != reloc_size
)
2334 cache_ptr
= reloc_cache
;
2335 if (each_size
== RELOC_EXT_SIZE
)
2337 register struct reloc_ext_external
*rptr
=
2338 (struct reloc_ext_external
*) relocs
;
2340 for (; counter
< count
; counter
++, rptr
++, cache_ptr
++)
2341 NAME(aout
,swap_ext_reloc_in
) (abfd
, rptr
, cache_ptr
, symbols
,
2342 bfd_get_symcount (abfd
));
2346 register struct reloc_std_external
*rptr
=
2347 (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_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
) (abfd
, section
)
2370 unsigned char *native
, *natptr
;
2373 unsigned int count
= section
->reloc_count
;
2376 if (count
== 0 || section
->orelocation
== NULL
)
2379 each_size
= obj_reloc_entry_size (abfd
);
2380 natsize
= each_size
* count
;
2381 native
= (unsigned char *) bfd_zalloc (abfd
, natsize
);
2385 generic
= section
->orelocation
;
2387 if (each_size
== RELOC_EXT_SIZE
)
2389 for (natptr
= native
;
2391 --count
, natptr
+= each_size
, ++generic
)
2392 NAME(aout
,swap_ext_reloc_out
) (abfd
, *generic
, (struct reloc_ext_external
*)natptr
);
2396 for (natptr
= native
;
2398 --count
, natptr
+= each_size
, ++generic
)
2399 MY_swap_std_reloc_out(abfd
, *generic
, (struct reloc_std_external
*)natptr
);
2402 if ( bfd_write ((PTR
) native
, 1, natsize
, abfd
) != natsize
) {
2403 bfd_release(abfd
, native
);
2406 bfd_release (abfd
, native
);
2411 /* This is stupid. This function should be a boolean predicate */
2413 NAME(aout
,canonicalize_reloc
) (abfd
, section
, relptr
, symbols
)
2419 arelent
*tblptr
= section
->relocation
;
2422 if (section
== obj_bsssec (abfd
))
2428 if (!(tblptr
|| NAME(aout
,slurp_reloc_table
)(abfd
, section
, symbols
)))
2431 if (section
->flags
& SEC_CONSTRUCTOR
) {
2432 arelent_chain
*chain
= section
->constructor_chain
;
2433 for (count
= 0; count
< section
->reloc_count
; count
++) {
2434 *relptr
++ = &chain
->relent
;
2435 chain
= chain
->next
;
2439 tblptr
= section
->relocation
;
2441 for (count
= 0; count
++ < section
->reloc_count
;)
2443 *relptr
++ = tblptr
++;
2448 return section
->reloc_count
;
2452 NAME(aout
,get_reloc_upper_bound
) (abfd
, asect
)
2456 if (bfd_get_format (abfd
) != bfd_object
) {
2457 bfd_set_error (bfd_error_invalid_operation
);
2460 if (asect
->flags
& SEC_CONSTRUCTOR
) {
2461 return (sizeof (arelent
*) * (asect
->reloc_count
+1));
2464 if (asect
== obj_datasec (abfd
))
2465 return (sizeof (arelent
*)
2466 * ((exec_hdr(abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
))
2469 if (asect
== obj_textsec (abfd
))
2470 return (sizeof (arelent
*)
2471 * ((exec_hdr(abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
))
2474 if (asect
== obj_bsssec (abfd
))
2475 return sizeof (arelent
*);
2477 if (asect
== obj_bsssec (abfd
))
2480 bfd_set_error (bfd_error_invalid_operation
);
2486 NAME(aout
,get_symtab_upper_bound
) (abfd
)
2489 if (!NAME(aout
,slurp_symbol_table
)(abfd
))
2492 return (bfd_get_symcount (abfd
)+1) * (sizeof (aout_symbol_type
*));
2497 NAME(aout
,get_lineno
) (ignore_abfd
, ignore_symbol
)
2499 asymbol
*ignore_symbol
;
2501 return (alent
*)NULL
;
2506 NAME(aout
,get_symbol_info
) (ignore_abfd
, symbol
, ret
)
2511 bfd_symbol_info (symbol
, ret
);
2513 if (ret
->type
== '?')
2515 int type_code
= aout_symbol(symbol
)->type
& 0xff;
2516 const char *stab_name
= bfd_get_stab_name (type_code
);
2517 static char buf
[10];
2519 if (stab_name
== NULL
)
2521 sprintf(buf
, "(%d)", type_code
);
2525 ret
->stab_type
= type_code
;
2526 ret
->stab_other
= (unsigned)(aout_symbol(symbol
)->other
& 0xff);
2527 ret
->stab_desc
= (unsigned)(aout_symbol(symbol
)->desc
& 0xffff);
2528 ret
->stab_name
= stab_name
;
2534 NAME(aout
,print_symbol
) (ignore_abfd
, afile
, symbol
, how
)
2538 bfd_print_symbol_type how
;
2540 FILE *file
= (FILE *)afile
;
2543 case bfd_print_symbol_name
:
2545 fprintf(file
,"%s", symbol
->name
);
2547 case bfd_print_symbol_more
:
2548 fprintf(file
,"%4x %2x %2x",(unsigned)(aout_symbol(symbol
)->desc
& 0xffff),
2549 (unsigned)(aout_symbol(symbol
)->other
& 0xff),
2550 (unsigned)(aout_symbol(symbol
)->type
));
2552 case bfd_print_symbol_all
:
2554 CONST
char *section_name
= symbol
->section
->name
;
2557 bfd_print_symbol_vandf((PTR
)file
,symbol
);
2559 fprintf(file
," %-5s %04x %02x %02x",
2561 (unsigned)(aout_symbol(symbol
)->desc
& 0xffff),
2562 (unsigned)(aout_symbol(symbol
)->other
& 0xff),
2563 (unsigned)(aout_symbol(symbol
)->type
& 0xff));
2565 fprintf(file
," %s", symbol
->name
);
2571 /* If we don't have to allocate more than 1MB to hold the generic
2572 symbols, we use the generic minisymbol methord: it's faster, since
2573 it only translates the symbols once, not multiple times. */
2574 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2576 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2577 symbols. The minisymbol_to_symbol function translates these into
2578 BFD asymbol structures. */
2581 NAME(aout
,read_minisymbols
) (abfd
, dynamic
, minisymsp
, sizep
)
2585 unsigned int *sizep
;
2589 /* We could handle the dynamic symbols here as well, but it's
2590 easier to hand them off. */
2591 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2594 if (! aout_get_external_symbols (abfd
))
2597 if (obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2598 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2600 *minisymsp
= (PTR
) obj_aout_external_syms (abfd
);
2602 /* By passing the external symbols back from this routine, we are
2603 giving up control over the memory block. Clear
2604 obj_aout_external_syms, so that we do not try to free it
2606 obj_aout_external_syms (abfd
) = NULL
;
2608 *sizep
= EXTERNAL_NLIST_SIZE
;
2609 return obj_aout_external_sym_count (abfd
);
2612 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2613 unmodified a.out symbol. The SYM argument is a structure returned
2614 by bfd_make_empty_symbol, which we fill in here. */
2617 NAME(aout
,minisymbol_to_symbol
) (abfd
, dynamic
, minisym
, sym
)
2624 || obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2625 return _bfd_generic_minisymbol_to_symbol (abfd
, dynamic
, minisym
, sym
);
2627 memset (sym
, 0, sizeof (aout_symbol_type
));
2629 /* We call translate_symbol_table to translate a single symbol. */
2630 if (! (NAME(aout
,translate_symbol_table
)
2632 (aout_symbol_type
*) sym
,
2633 (struct external_nlist
*) minisym
,
2635 obj_aout_external_strings (abfd
),
2636 obj_aout_external_string_size (abfd
),
2644 provided a BFD, a section and an offset into the section, calculate
2645 and return the name of the source file and the line nearest to the
2650 NAME(aout
,find_nearest_line
)
2651 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2656 CONST
char **filename_ptr
;
2657 CONST
char **functionname_ptr
;
2658 unsigned int *line_ptr
;
2660 /* Run down the file looking for the filename, function and linenumber */
2662 CONST
char *directory_name
= NULL
;
2663 CONST
char *main_file_name
= NULL
;
2664 CONST
char *current_file_name
= NULL
;
2665 CONST
char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2666 bfd_vma low_line_vma
= 0;
2667 bfd_vma low_func_vma
= 0;
2669 size_t filelen
, funclen
;
2672 *filename_ptr
= abfd
->filename
;
2673 *functionname_ptr
= 0;
2675 if (symbols
!= (asymbol
**)NULL
) {
2676 for (p
= symbols
; *p
; p
++) {
2677 aout_symbol_type
*q
= (aout_symbol_type
*)(*p
);
2681 main_file_name
= current_file_name
= q
->symbol
.name
;
2682 /* Look ahead to next symbol to check if that too is an N_SO. */
2686 q
= (aout_symbol_type
*)(*p
);
2687 if (q
->type
!= (int)N_SO
)
2690 /* Found a second N_SO First is directory; second is filename. */
2691 directory_name
= current_file_name
;
2692 main_file_name
= current_file_name
= q
->symbol
.name
;
2693 if (obj_textsec(abfd
) != section
)
2697 current_file_name
= q
->symbol
.name
;
2704 /* We'll keep this if it resolves nearer than the one we have
2706 if (q
->symbol
.value
>= low_line_vma
2707 && q
->symbol
.value
<= offset
)
2709 *line_ptr
= q
->desc
;
2710 low_line_vma
= q
->symbol
.value
;
2711 line_file_name
= current_file_name
;
2716 /* We'll keep this if it is nearer than the one we have already */
2717 if (q
->symbol
.value
>= low_func_vma
&&
2718 q
->symbol
.value
<= offset
) {
2719 low_func_vma
= q
->symbol
.value
;
2720 func
= (asymbol
*)q
;
2722 else if (q
->symbol
.value
> offset
)
2732 main_file_name
= line_file_name
;
2734 if (main_file_name
== NULL
2735 || main_file_name
[0] == '/'
2736 || directory_name
== NULL
)
2739 filelen
= strlen (directory_name
) + strlen (main_file_name
);
2743 funclen
= strlen (bfd_asymbol_name (func
));
2745 if (adata (abfd
).line_buf
!= NULL
)
2746 free (adata (abfd
).line_buf
);
2747 if (filelen
+ funclen
== 0)
2748 adata (abfd
).line_buf
= buf
= NULL
;
2751 buf
= (char *) bfd_malloc (filelen
+ funclen
+ 3);
2752 adata (abfd
).line_buf
= buf
;
2757 if (main_file_name
!= NULL
)
2759 if (main_file_name
[0] == '/' || directory_name
== NULL
)
2760 *filename_ptr
= main_file_name
;
2763 sprintf (buf
, "%s%s", directory_name
, main_file_name
);
2764 *filename_ptr
= buf
;
2771 const char *function
= func
->name
;
2774 /* The caller expects a symbol name. We actually have a
2775 function name, without the leading underscore. Put the
2776 underscore back in, so that the caller gets a symbol name. */
2777 if (bfd_get_symbol_leading_char (abfd
) == '\0')
2778 strcpy (buf
, function
);
2781 buf
[0] = bfd_get_symbol_leading_char (abfd
);
2782 strcpy (buf
+ 1, function
);
2784 /* Have to remove : stuff */
2785 p
= strchr (buf
, ':');
2788 *functionname_ptr
= buf
;
2796 NAME(aout
,sizeof_headers
) (abfd
, execable
)
2800 return adata(abfd
).exec_bytes_size
;
2803 /* Free all information we have cached for this BFD. We can always
2804 read it again later if we need it. */
2807 NAME(aout
,bfd_free_cached_info
) (abfd
)
2812 if (bfd_get_format (abfd
) != bfd_object
)
2815 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2816 BFCI_FREE (obj_aout_symbols (abfd
));
2818 obj_aout_external_syms (abfd
) = 0;
2819 bfd_free_window (&obj_aout_sym_window (abfd
));
2820 bfd_free_window (&obj_aout_string_window (abfd
));
2821 obj_aout_external_strings (abfd
) = 0;
2823 BFCI_FREE (obj_aout_external_syms (abfd
));
2824 BFCI_FREE (obj_aout_external_strings (abfd
));
2826 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
2827 BFCI_FREE (o
->relocation
);
2833 /* a.out link code. */
2835 static boolean aout_link_add_object_symbols
2836 PARAMS ((bfd
*, struct bfd_link_info
*));
2837 static boolean aout_link_check_archive_element
2838 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*));
2839 static boolean aout_link_free_symbols
PARAMS ((bfd
*));
2840 static boolean aout_link_check_ar_symbols
2841 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*pneeded
));
2842 static boolean aout_link_add_symbols
2843 PARAMS ((bfd
*, struct bfd_link_info
*));
2845 /* Routine to create an entry in an a.out link hash table. */
2847 struct bfd_hash_entry
*
2848 NAME(aout
,link_hash_newfunc
) (entry
, table
, string
)
2849 struct bfd_hash_entry
*entry
;
2850 struct bfd_hash_table
*table
;
2853 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2855 /* Allocate the structure if it has not already been allocated by a
2857 if (ret
== (struct aout_link_hash_entry
*) NULL
)
2858 ret
= ((struct aout_link_hash_entry
*)
2859 bfd_hash_allocate (table
, sizeof (struct aout_link_hash_entry
)));
2860 if (ret
== (struct aout_link_hash_entry
*) NULL
)
2861 return (struct bfd_hash_entry
*) ret
;
2863 /* Call the allocation method of the superclass. */
2864 ret
= ((struct aout_link_hash_entry
*)
2865 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2869 /* Set local fields. */
2870 ret
->written
= false;
2874 return (struct bfd_hash_entry
*) ret
;
2877 /* Initialize an a.out link hash table. */
2880 NAME(aout
,link_hash_table_init
) (table
, abfd
, newfunc
)
2881 struct aout_link_hash_table
*table
;
2883 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
2884 struct bfd_hash_table
*,
2887 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
2890 /* Create an a.out link hash table. */
2892 struct bfd_link_hash_table
*
2893 NAME(aout
,link_hash_table_create
) (abfd
)
2896 struct aout_link_hash_table
*ret
;
2898 ret
= ((struct aout_link_hash_table
*)
2899 bfd_alloc (abfd
, sizeof (struct aout_link_hash_table
)));
2901 return (struct bfd_link_hash_table
*) NULL
;
2902 if (! NAME(aout
,link_hash_table_init
) (ret
, abfd
,
2903 NAME(aout
,link_hash_newfunc
)))
2906 return (struct bfd_link_hash_table
*) NULL
;
2911 /* Given an a.out BFD, add symbols to the global hash table as
2915 NAME(aout
,link_add_symbols
) (abfd
, info
)
2917 struct bfd_link_info
*info
;
2919 switch (bfd_get_format (abfd
))
2922 return aout_link_add_object_symbols (abfd
, info
);
2924 return _bfd_generic_link_add_archive_symbols
2925 (abfd
, info
, aout_link_check_archive_element
);
2927 bfd_set_error (bfd_error_wrong_format
);
2932 /* Add symbols from an a.out object file. */
2935 aout_link_add_object_symbols (abfd
, info
)
2937 struct bfd_link_info
*info
;
2939 if (! aout_get_external_symbols (abfd
))
2941 if (! aout_link_add_symbols (abfd
, info
))
2943 if (! info
->keep_memory
)
2945 if (! aout_link_free_symbols (abfd
))
2951 /* Check a single archive element to see if we need to include it in
2952 the link. *PNEEDED is set according to whether this element is
2953 needed in the link or not. This is called from
2954 _bfd_generic_link_add_archive_symbols. */
2957 aout_link_check_archive_element (abfd
, info
, pneeded
)
2959 struct bfd_link_info
*info
;
2962 if (! aout_get_external_symbols (abfd
))
2965 if (! aout_link_check_ar_symbols (abfd
, info
, pneeded
))
2970 if (! aout_link_add_symbols (abfd
, info
))
2974 if (! info
->keep_memory
|| ! *pneeded
)
2976 if (! aout_link_free_symbols (abfd
))
2983 /* Free up the internal symbols read from an a.out file. */
2986 aout_link_free_symbols (abfd
)
2989 if (obj_aout_external_syms (abfd
) != (struct external_nlist
*) NULL
)
2992 bfd_free_window (&obj_aout_sym_window (abfd
));
2994 free ((PTR
) obj_aout_external_syms (abfd
));
2996 obj_aout_external_syms (abfd
) = (struct external_nlist
*) NULL
;
2998 if (obj_aout_external_strings (abfd
) != (char *) NULL
)
3001 bfd_free_window (&obj_aout_string_window (abfd
));
3003 free ((PTR
) obj_aout_external_strings (abfd
));
3005 obj_aout_external_strings (abfd
) = (char *) NULL
;
3010 /* Look through the internal symbols to see if this object file should
3011 be included in the link. We should include this object file if it
3012 defines any symbols which are currently undefined. If this object
3013 file defines a common symbol, then we may adjust the size of the
3014 known symbol but we do not include the object file in the link
3015 (unless there is some other reason to include it). */
3018 aout_link_check_ar_symbols (abfd
, info
, pneeded
)
3020 struct bfd_link_info
*info
;
3023 register struct external_nlist
*p
;
3024 struct external_nlist
*pend
;
3029 /* Look through all the symbols. */
3030 p
= obj_aout_external_syms (abfd
);
3031 pend
= p
+ obj_aout_external_sym_count (abfd
);
3032 strings
= obj_aout_external_strings (abfd
);
3033 for (; p
< pend
; p
++)
3035 int type
= bfd_h_get_8 (abfd
, p
->e_type
);
3037 struct bfd_link_hash_entry
*h
;
3039 /* Ignore symbols that are not externally visible. This is an
3040 optimization only, as we check the type more thoroughly
3042 if (((type
& N_EXT
) == 0
3043 || (type
& N_STAB
) != 0
3050 if (type
== N_WARNING
3056 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3057 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
3059 /* We are only interested in symbols that are currently
3060 undefined or common. */
3061 if (h
== (struct bfd_link_hash_entry
*) NULL
3062 || (h
->type
!= bfd_link_hash_undefined
3063 && h
->type
!= bfd_link_hash_common
))
3065 if (type
== (N_INDR
| N_EXT
))
3070 if (type
== (N_TEXT
| N_EXT
)
3071 || type
== (N_DATA
| N_EXT
)
3072 || type
== (N_BSS
| N_EXT
)
3073 || type
== (N_ABS
| N_EXT
)
3074 || type
== (N_INDR
| N_EXT
))
3076 /* This object file defines this symbol. We must link it
3077 in. This is true regardless of whether the current
3078 definition of the symbol is undefined or common. If the
3079 current definition is common, we have a case in which we
3080 have already seen an object file including
3082 and this object file from the archive includes
3084 In such a case we must include this object file.
3086 FIXME: The SunOS 4.1.3 linker will pull in the archive
3087 element if the symbol is defined in the .data section,
3088 but not if it is defined in the .text section. That
3089 seems a bit crazy to me, and I haven't implemented it.
3090 However, it might be correct. */
3091 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
3097 if (type
== (N_UNDF
| N_EXT
))
3101 value
= GET_WORD (abfd
, p
->e_value
);
3104 /* This symbol is common in the object from the archive
3106 if (h
->type
== bfd_link_hash_undefined
)
3111 symbfd
= h
->u
.undef
.abfd
;
3112 if (symbfd
== (bfd
*) NULL
)
3114 /* This symbol was created as undefined from
3115 outside BFD. We assume that we should link
3116 in the object file. This is done for the -u
3117 option in the linker. */
3118 if (! (*info
->callbacks
->add_archive_element
) (info
,
3125 /* Turn the current link symbol into a common
3126 symbol. It is already on the undefs list. */
3127 h
->type
= bfd_link_hash_common
;
3128 h
->u
.c
.p
= ((struct bfd_link_hash_common_entry
*)
3129 bfd_hash_allocate (&info
->hash
->table
,
3130 sizeof (struct bfd_link_hash_common_entry
)));
3131 if (h
->u
.c
.p
== NULL
)
3134 h
->u
.c
.size
= value
;
3136 /* FIXME: This isn't quite right. The maximum
3137 alignment of a common symbol should be set by the
3138 architecture of the output file, not of the input
3140 power
= bfd_log2 (value
);
3141 if (power
> bfd_get_arch_info (abfd
)->section_align_power
)
3142 power
= bfd_get_arch_info (abfd
)->section_align_power
;
3143 h
->u
.c
.p
->alignment_power
= power
;
3145 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
,
3150 /* Adjust the size of the common symbol if
3152 if (value
> h
->u
.c
.size
)
3153 h
->u
.c
.size
= value
;
3163 /* This symbol is weak but defined. We must pull it in if
3164 the current link symbol is undefined, but we don't want
3165 it if the current link symbol is common. */
3166 if (h
->type
== bfd_link_hash_undefined
)
3168 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
3176 /* We do not need this object file. */
3180 /* Add all symbols from an object file to the hash table. */
3183 aout_link_add_symbols (abfd
, info
)
3185 struct bfd_link_info
*info
;
3187 boolean (*add_one_symbol
) PARAMS ((struct bfd_link_info
*, bfd
*,
3188 const char *, flagword
, asection
*,
3189 bfd_vma
, const char *, boolean
,
3191 struct bfd_link_hash_entry
**));
3192 struct external_nlist
*syms
;
3193 bfd_size_type sym_count
;
3196 struct aout_link_hash_entry
**sym_hash
;
3197 register struct external_nlist
*p
;
3198 struct external_nlist
*pend
;
3200 syms
= obj_aout_external_syms (abfd
);
3201 sym_count
= obj_aout_external_sym_count (abfd
);
3202 strings
= obj_aout_external_strings (abfd
);
3203 if (info
->keep_memory
)
3208 if (aout_backend_info (abfd
)->add_dynamic_symbols
!= NULL
)
3210 if (! ((*aout_backend_info (abfd
)->add_dynamic_symbols
)
3211 (abfd
, info
, &syms
, &sym_count
, &strings
)))
3215 /* We keep a list of the linker hash table entries that correspond
3216 to particular symbols. We could just look them up in the hash
3217 table, but keeping the list is more efficient. Perhaps this
3218 should be conditional on info->keep_memory. */
3219 sym_hash
= ((struct aout_link_hash_entry
**)
3222 * sizeof (struct aout_link_hash_entry
*))));
3223 if (sym_hash
== NULL
&& sym_count
!= 0)
3225 obj_aout_sym_hashes (abfd
) = sym_hash
;
3227 add_one_symbol
= aout_backend_info (abfd
)->add_one_symbol
;
3228 if (add_one_symbol
== NULL
)
3229 add_one_symbol
= _bfd_generic_link_add_one_symbol
;
3232 pend
= p
+ sym_count
;
3233 for (; p
< pend
; p
++, sym_hash
++)
3244 type
= bfd_h_get_8 (abfd
, p
->e_type
);
3246 /* Ignore debugging symbols. */
3247 if ((type
& N_STAB
) != 0)
3250 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3251 value
= GET_WORD (abfd
, p
->e_value
);
3268 /* Ignore symbols that are not externally visible. */
3271 /* Ignore local indirect symbol. */
3276 case N_UNDF
| N_EXT
:
3279 section
= bfd_und_section_ptr
;
3283 section
= bfd_com_section_ptr
;
3286 section
= bfd_abs_section_ptr
;
3288 case N_TEXT
| N_EXT
:
3289 section
= obj_textsec (abfd
);
3290 value
-= bfd_get_section_vma (abfd
, section
);
3292 case N_DATA
| N_EXT
:
3293 case N_SETV
| N_EXT
:
3294 /* Treat N_SETV symbols as N_DATA symbol; see comment in
3295 translate_from_native_sym_flags. */
3296 section
= obj_datasec (abfd
);
3297 value
-= bfd_get_section_vma (abfd
, section
);
3300 section
= obj_bsssec (abfd
);
3301 value
-= bfd_get_section_vma (abfd
, section
);
3303 case N_INDR
| N_EXT
:
3304 /* An indirect symbol. The next symbol is the symbol
3305 which this one really is. */
3306 BFD_ASSERT (p
+ 1 < pend
);
3308 string
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3309 section
= bfd_ind_section_ptr
;
3310 flags
|= BSF_INDIRECT
;
3312 case N_COMM
| N_EXT
:
3313 section
= bfd_com_section_ptr
;
3315 case N_SETA
: case N_SETA
| N_EXT
:
3316 section
= bfd_abs_section_ptr
;
3317 flags
|= BSF_CONSTRUCTOR
;
3319 case N_SETT
: case N_SETT
| N_EXT
:
3320 section
= obj_textsec (abfd
);
3321 flags
|= BSF_CONSTRUCTOR
;
3322 value
-= bfd_get_section_vma (abfd
, section
);
3324 case N_SETD
: case N_SETD
| N_EXT
:
3325 section
= obj_datasec (abfd
);
3326 flags
|= BSF_CONSTRUCTOR
;
3327 value
-= bfd_get_section_vma (abfd
, section
);
3329 case N_SETB
: case N_SETB
| N_EXT
:
3330 section
= obj_bsssec (abfd
);
3331 flags
|= BSF_CONSTRUCTOR
;
3332 value
-= bfd_get_section_vma (abfd
, section
);
3335 /* A warning symbol. The next symbol is the one to warn
3337 BFD_ASSERT (p
+ 1 < pend
);
3340 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3341 section
= bfd_und_section_ptr
;
3342 flags
|= BSF_WARNING
;
3345 section
= bfd_und_section_ptr
;
3349 section
= bfd_abs_section_ptr
;
3353 section
= obj_textsec (abfd
);
3354 value
-= bfd_get_section_vma (abfd
, section
);
3358 section
= obj_datasec (abfd
);
3359 value
-= bfd_get_section_vma (abfd
, section
);
3363 section
= obj_bsssec (abfd
);
3364 value
-= bfd_get_section_vma (abfd
, section
);
3369 if (! ((*add_one_symbol
)
3370 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, false,
3371 (struct bfd_link_hash_entry
**) sym_hash
)))
3374 /* Restrict the maximum alignment of a common symbol based on
3375 the architecture, since a.out has no way to represent
3376 alignment requirements of a section in a .o file. FIXME:
3377 This isn't quite right: it should use the architecture of the
3378 output file, not the input files. */
3379 if ((*sym_hash
)->root
.type
== bfd_link_hash_common
3380 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
>
3381 bfd_get_arch_info (abfd
)->section_align_power
))
3382 (*sym_hash
)->root
.u
.c
.p
->alignment_power
=
3383 bfd_get_arch_info (abfd
)->section_align_power
;
3385 /* If this is a set symbol, and we are not building sets, then
3386 it is possible for the hash entry to not have been set. In
3387 such a case, treat the symbol as not globally defined. */
3388 if ((*sym_hash
)->root
.type
== bfd_link_hash_new
)
3390 BFD_ASSERT ((flags
& BSF_CONSTRUCTOR
) != 0);
3394 if (type
== (N_INDR
| N_EXT
) || type
== N_WARNING
)
3401 /* A hash table used for header files with N_BINCL entries. */
3403 struct aout_link_includes_table
3405 struct bfd_hash_table root
;
3408 /* A linked list of totals that we have found for a particular header
3411 struct aout_link_includes_totals
3413 struct aout_link_includes_totals
*next
;
3417 /* An entry in the header file hash table. */
3419 struct aout_link_includes_entry
3421 struct bfd_hash_entry root
;
3422 /* List of totals we have found for this file. */
3423 struct aout_link_includes_totals
*totals
;
3426 /* Look up an entry in an the header file hash table. */
3428 #define aout_link_includes_lookup(table, string, create, copy) \
3429 ((struct aout_link_includes_entry *) \
3430 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3432 /* During the final link step we need to pass around a bunch of
3433 information, so we do it in an instance of this structure. */
3435 struct aout_final_link_info
3437 /* General link information. */
3438 struct bfd_link_info
*info
;
3441 /* Reloc file positions. */
3442 file_ptr treloff
, dreloff
;
3443 /* File position of symbols. */
3446 struct bfd_strtab_hash
*strtab
;
3447 /* Header file hash table. */
3448 struct aout_link_includes_table includes
;
3449 /* A buffer large enough to hold the contents of any section. */
3451 /* A buffer large enough to hold the relocs of any section. */
3453 /* A buffer large enough to hold the symbol map of any input BFD. */
3455 /* A buffer large enough to hold output symbols of any input BFD. */
3456 struct external_nlist
*output_syms
;
3459 static struct bfd_hash_entry
*aout_link_includes_newfunc
3460 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
3461 static boolean aout_link_input_bfd
3462 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
));
3463 static boolean aout_link_write_symbols
3464 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
));
3465 static boolean aout_link_write_other_symbol
3466 PARAMS ((struct aout_link_hash_entry
*, PTR
));
3467 static boolean aout_link_input_section
3468 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
,
3469 asection
*input_section
, file_ptr
*reloff_ptr
,
3470 bfd_size_type rel_size
));
3471 static boolean aout_link_input_section_std
3472 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
,
3473 asection
*input_section
, struct reloc_std_external
*,
3474 bfd_size_type rel_size
, bfd_byte
*contents
));
3475 static boolean aout_link_input_section_ext
3476 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
,
3477 asection
*input_section
, struct reloc_ext_external
*,
3478 bfd_size_type rel_size
, bfd_byte
*contents
));
3479 static INLINE asection
*aout_reloc_index_to_section
3480 PARAMS ((bfd
*, int));
3481 static boolean aout_link_reloc_link_order
3482 PARAMS ((struct aout_final_link_info
*, asection
*,
3483 struct bfd_link_order
*));
3485 /* The function to create a new entry in the header file hash table. */
3487 static struct bfd_hash_entry
*
3488 aout_link_includes_newfunc (entry
, table
, string
)
3489 struct bfd_hash_entry
*entry
;
3490 struct bfd_hash_table
*table
;
3493 struct aout_link_includes_entry
*ret
=
3494 (struct aout_link_includes_entry
*) entry
;
3496 /* Allocate the structure if it has not already been allocated by a
3498 if (ret
== (struct aout_link_includes_entry
*) NULL
)
3499 ret
= ((struct aout_link_includes_entry
*)
3500 bfd_hash_allocate (table
,
3501 sizeof (struct aout_link_includes_entry
)));
3502 if (ret
== (struct aout_link_includes_entry
*) NULL
)
3503 return (struct bfd_hash_entry
*) ret
;
3505 /* Call the allocation method of the superclass. */
3506 ret
= ((struct aout_link_includes_entry
*)
3507 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
3510 /* Set local fields. */
3514 return (struct bfd_hash_entry
*) ret
;
3517 /* Do the final link step. This is called on the output BFD. The
3518 INFO structure should point to a list of BFDs linked through the
3519 link_next field which can be used to find each BFD which takes part
3520 in the output. Also, each section in ABFD should point to a list
3521 of bfd_link_order structures which list all the input sections for
3522 the output section. */
3525 NAME(aout
,final_link
) (abfd
, info
, callback
)
3527 struct bfd_link_info
*info
;
3528 void (*callback
) PARAMS ((bfd
*, file_ptr
*, file_ptr
*, file_ptr
*));
3530 struct aout_final_link_info aout_info
;
3531 boolean includes_hash_initialized
= false;
3533 bfd_size_type trsize
, drsize
;
3534 size_t max_contents_size
;
3535 size_t max_relocs_size
;
3536 size_t max_sym_count
;
3537 bfd_size_type text_size
;
3539 register struct bfd_link_order
*p
;
3541 boolean have_link_order_relocs
;
3544 abfd
->flags
|= DYNAMIC
;
3546 aout_info
.info
= info
;
3547 aout_info
.output_bfd
= abfd
;
3548 aout_info
.contents
= NULL
;
3549 aout_info
.relocs
= NULL
;
3550 aout_info
.symbol_map
= NULL
;
3551 aout_info
.output_syms
= NULL
;
3553 if (! bfd_hash_table_init_n (&aout_info
.includes
.root
,
3554 aout_link_includes_newfunc
,
3557 includes_hash_initialized
= true;
3559 /* Figure out the largest section size. Also, if generating
3560 relocateable output, count the relocs. */
3563 max_contents_size
= 0;
3564 max_relocs_size
= 0;
3566 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3570 if (info
->relocateable
)
3572 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3574 trsize
+= exec_hdr (sub
)->a_trsize
;
3575 drsize
+= exec_hdr (sub
)->a_drsize
;
3579 /* FIXME: We need to identify the .text and .data sections
3580 and call get_reloc_upper_bound and canonicalize_reloc to
3581 work out the number of relocs needed, and then multiply
3582 by the reloc size. */
3583 (*_bfd_error_handler
)
3584 ("%s: relocateable link from %s to %s not supported",
3585 bfd_get_filename (abfd
),
3586 sub
->xvec
->name
, abfd
->xvec
->name
);
3587 bfd_set_error (bfd_error_invalid_operation
);
3592 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3594 sz
= bfd_section_size (sub
, obj_textsec (sub
));
3595 if (sz
> max_contents_size
)
3596 max_contents_size
= sz
;
3597 sz
= bfd_section_size (sub
, obj_datasec (sub
));
3598 if (sz
> max_contents_size
)
3599 max_contents_size
= sz
;
3601 sz
= exec_hdr (sub
)->a_trsize
;
3602 if (sz
> max_relocs_size
)
3603 max_relocs_size
= sz
;
3604 sz
= exec_hdr (sub
)->a_drsize
;
3605 if (sz
> max_relocs_size
)
3606 max_relocs_size
= sz
;
3608 sz
= obj_aout_external_sym_count (sub
);
3609 if (sz
> max_sym_count
)
3614 if (info
->relocateable
)
3616 if (obj_textsec (abfd
) != (asection
*) NULL
)
3617 trsize
+= (_bfd_count_link_order_relocs (obj_textsec (abfd
)
3619 * obj_reloc_entry_size (abfd
));
3620 if (obj_datasec (abfd
) != (asection
*) NULL
)
3621 drsize
+= (_bfd_count_link_order_relocs (obj_datasec (abfd
)
3623 * obj_reloc_entry_size (abfd
));
3626 exec_hdr (abfd
)->a_trsize
= trsize
;
3627 exec_hdr (abfd
)->a_drsize
= drsize
;
3629 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
3631 /* Adjust the section sizes and vmas according to the magic number.
3632 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3633 filepos for each section. */
3634 if (! NAME(aout
,adjust_sizes_and_vmas
) (abfd
, &text_size
, &text_end
))
3637 /* The relocation and symbol file positions differ among a.out
3638 targets. We are passed a callback routine from the backend
3639 specific code to handle this.
3640 FIXME: At this point we do not know how much space the symbol
3641 table will require. This will not work for any (nonstandard)
3642 a.out target that needs to know the symbol table size before it
3643 can compute the relocation file positions. This may or may not
3644 be the case for the hp300hpux target, for example. */
3645 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
3647 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
3648 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
3649 obj_sym_filepos (abfd
) = aout_info
.symoff
;
3651 /* We keep a count of the symbols as we output them. */
3652 obj_aout_external_sym_count (abfd
) = 0;
3654 /* We accumulate the string table as we write out the symbols. */
3655 aout_info
.strtab
= _bfd_stringtab_init ();
3656 if (aout_info
.strtab
== NULL
)
3659 /* Allocate buffers to hold section contents and relocs. */
3660 aout_info
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
3661 aout_info
.relocs
= (PTR
) bfd_malloc (max_relocs_size
);
3662 aout_info
.symbol_map
= (int *) bfd_malloc (max_sym_count
* sizeof (int *));
3663 aout_info
.output_syms
= ((struct external_nlist
*)
3664 bfd_malloc ((max_sym_count
+ 1)
3665 * sizeof (struct external_nlist
)));
3666 if ((aout_info
.contents
== NULL
&& max_contents_size
!= 0)
3667 || (aout_info
.relocs
== NULL
&& max_relocs_size
!= 0)
3668 || (aout_info
.symbol_map
== NULL
&& max_sym_count
!= 0)
3669 || aout_info
.output_syms
== NULL
)
3672 /* If we have a symbol named __DYNAMIC, force it out now. This is
3673 required by SunOS. Doing this here rather than in sunos.c is a
3674 hack, but it's easier than exporting everything which would be
3677 struct aout_link_hash_entry
*h
;
3679 h
= aout_link_hash_lookup (aout_hash_table (info
), "__DYNAMIC",
3680 false, false, false);
3682 aout_link_write_other_symbol (h
, &aout_info
);
3685 /* The most time efficient way to do the link would be to read all
3686 the input object files into memory and then sort out the
3687 information into the output file. Unfortunately, that will
3688 probably use too much memory. Another method would be to step
3689 through everything that composes the text section and write it
3690 out, and then everything that composes the data section and write
3691 it out, and then write out the relocs, and then write out the
3692 symbols. Unfortunately, that requires reading stuff from each
3693 input file several times, and we will not be able to keep all the
3694 input files open simultaneously, and reopening them will be slow.
3696 What we do is basically process one input file at a time. We do
3697 everything we need to do with an input file once--copy over the
3698 section contents, handle the relocation information, and write
3699 out the symbols--and then we throw away the information we read
3700 from it. This approach requires a lot of lseeks of the output
3701 file, which is unfortunate but still faster than reopening a lot
3704 We use the output_has_begun field of the input BFDs to see
3705 whether we have already handled it. */
3706 for (sub
= info
->input_bfds
; sub
!= (bfd
*) NULL
; sub
= sub
->link_next
)
3707 sub
->output_has_begun
= false;
3709 /* Mark all sections which are to be included in the link. This
3710 will normally be every section. We need to do this so that we
3711 can identify any sections which the linker has decided to not
3713 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3715 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3717 if (p
->type
== bfd_indirect_link_order
)
3718 p
->u
.indirect
.section
->linker_mark
= true;
3722 have_link_order_relocs
= false;
3723 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3725 for (p
= o
->link_order_head
;
3726 p
!= (struct bfd_link_order
*) NULL
;
3729 if (p
->type
== bfd_indirect_link_order
3730 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
3731 == bfd_target_aout_flavour
))
3735 input_bfd
= p
->u
.indirect
.section
->owner
;
3736 if (! input_bfd
->output_has_begun
)
3738 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
3740 input_bfd
->output_has_begun
= true;
3743 else if (p
->type
== bfd_section_reloc_link_order
3744 || p
->type
== bfd_symbol_reloc_link_order
)
3746 /* These are handled below. */
3747 have_link_order_relocs
= true;
3751 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3757 /* Write out any symbols that we have not already written out. */
3758 aout_link_hash_traverse (aout_hash_table (info
),
3759 aout_link_write_other_symbol
,
3762 /* Now handle any relocs we were asked to create by the linker.
3763 These did not come from any input file. We must do these after
3764 we have written out all the symbols, so that we know the symbol
3766 if (have_link_order_relocs
)
3768 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3770 for (p
= o
->link_order_head
;
3771 p
!= (struct bfd_link_order
*) NULL
;
3774 if (p
->type
== bfd_section_reloc_link_order
3775 || p
->type
== bfd_symbol_reloc_link_order
)
3777 if (! aout_link_reloc_link_order (&aout_info
, o
, p
))
3784 if (aout_info
.contents
!= NULL
)
3786 free (aout_info
.contents
);
3787 aout_info
.contents
= NULL
;
3789 if (aout_info
.relocs
!= NULL
)
3791 free (aout_info
.relocs
);
3792 aout_info
.relocs
= NULL
;
3794 if (aout_info
.symbol_map
!= NULL
)
3796 free (aout_info
.symbol_map
);
3797 aout_info
.symbol_map
= NULL
;
3799 if (aout_info
.output_syms
!= NULL
)
3801 free (aout_info
.output_syms
);
3802 aout_info
.output_syms
= NULL
;
3804 if (includes_hash_initialized
)
3806 bfd_hash_table_free (&aout_info
.includes
.root
);
3807 includes_hash_initialized
= false;
3810 /* Finish up any dynamic linking we may be doing. */
3811 if (aout_backend_info (abfd
)->finish_dynamic_link
!= NULL
)
3813 if (! (*aout_backend_info (abfd
)->finish_dynamic_link
) (abfd
, info
))
3817 /* Update the header information. */
3818 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
3819 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
3820 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
3821 obj_textsec (abfd
)->reloc_count
=
3822 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
3823 obj_datasec (abfd
)->reloc_count
=
3824 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
3826 /* Write out the string table. */
3827 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0)
3829 return emit_stringtab (abfd
, aout_info
.strtab
);
3832 if (aout_info
.contents
!= NULL
)
3833 free (aout_info
.contents
);
3834 if (aout_info
.relocs
!= NULL
)
3835 free (aout_info
.relocs
);
3836 if (aout_info
.symbol_map
!= NULL
)
3837 free (aout_info
.symbol_map
);
3838 if (aout_info
.output_syms
!= NULL
)
3839 free (aout_info
.output_syms
);
3840 if (includes_hash_initialized
)
3841 bfd_hash_table_free (&aout_info
.includes
.root
);
3845 /* Link an a.out input BFD into the output file. */
3848 aout_link_input_bfd (finfo
, input_bfd
)
3849 struct aout_final_link_info
*finfo
;
3852 bfd_size_type sym_count
;
3854 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
3856 /* If this is a dynamic object, it may need special handling. */
3857 if ((input_bfd
->flags
& DYNAMIC
) != 0
3858 && aout_backend_info (input_bfd
)->link_dynamic_object
!= NULL
)
3860 return ((*aout_backend_info (input_bfd
)->link_dynamic_object
)
3861 (finfo
->info
, input_bfd
));
3864 /* Get the symbols. We probably have them already, unless
3865 finfo->info->keep_memory is false. */
3866 if (! aout_get_external_symbols (input_bfd
))
3869 sym_count
= obj_aout_external_sym_count (input_bfd
);
3871 /* Write out the symbols and get a map of the new indices. The map
3872 is placed into finfo->symbol_map. */
3873 if (! aout_link_write_symbols (finfo
, input_bfd
))
3876 /* Relocate and write out the sections. These functions use the
3877 symbol map created by aout_link_write_symbols. The linker_mark
3878 field will be set if these sections are to be included in the
3879 link, which will normally be the case. */
3880 if (obj_textsec (input_bfd
)->linker_mark
)
3882 if (! aout_link_input_section (finfo
, input_bfd
,
3883 obj_textsec (input_bfd
),
3885 exec_hdr (input_bfd
)->a_trsize
))
3888 if (obj_datasec (input_bfd
)->linker_mark
)
3890 if (! aout_link_input_section (finfo
, input_bfd
,
3891 obj_datasec (input_bfd
),
3893 exec_hdr (input_bfd
)->a_drsize
))
3897 /* If we are not keeping memory, we don't need the symbols any
3898 longer. We still need them if we are keeping memory, because the
3899 strings in the hash table point into them. */
3900 if (! finfo
->info
->keep_memory
)
3902 if (! aout_link_free_symbols (input_bfd
))
3909 /* Adjust and write out the symbols for an a.out file. Set the new
3910 symbol indices into a symbol_map. */
3913 aout_link_write_symbols (finfo
, input_bfd
)
3914 struct aout_final_link_info
*finfo
;
3918 bfd_size_type sym_count
;
3920 enum bfd_link_strip strip
;
3921 enum bfd_link_discard discard
;
3922 struct external_nlist
*outsym
;
3923 bfd_size_type strtab_index
;
3924 register struct external_nlist
*sym
;
3925 struct external_nlist
*sym_end
;
3926 struct aout_link_hash_entry
**sym_hash
;
3931 output_bfd
= finfo
->output_bfd
;
3932 sym_count
= obj_aout_external_sym_count (input_bfd
);
3933 strings
= obj_aout_external_strings (input_bfd
);
3934 strip
= finfo
->info
->strip
;
3935 discard
= finfo
->info
->discard
;
3936 outsym
= finfo
->output_syms
;
3938 /* First write out a symbol for this object file, unless we are
3939 discarding such symbols. */
3940 if (strip
!= strip_all
3941 && (strip
!= strip_some
3942 || bfd_hash_lookup (finfo
->info
->keep_hash
, input_bfd
->filename
,
3943 false, false) != NULL
)
3944 && discard
!= discard_all
)
3946 bfd_h_put_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
3947 bfd_h_put_8 (output_bfd
, 0, outsym
->e_other
);
3948 bfd_h_put_16 (output_bfd
, (bfd_vma
) 0, outsym
->e_desc
);
3949 strtab_index
= add_to_stringtab (output_bfd
, finfo
->strtab
,
3950 input_bfd
->filename
, false);
3951 if (strtab_index
== (bfd_size_type
) -1)
3953 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
3954 PUT_WORD (output_bfd
,
3955 (bfd_get_section_vma (output_bfd
,
3956 obj_textsec (input_bfd
)->output_section
)
3957 + obj_textsec (input_bfd
)->output_offset
),
3959 ++obj_aout_external_sym_count (output_bfd
);
3965 sym
= obj_aout_external_syms (input_bfd
);
3966 sym_end
= sym
+ sym_count
;
3967 sym_hash
= obj_aout_sym_hashes (input_bfd
);
3968 symbol_map
= finfo
->symbol_map
;
3969 memset (symbol_map
, 0, sym_count
* sizeof *symbol_map
);
3970 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
3974 struct aout_link_hash_entry
*h
;
3980 /* We set *symbol_map to 0 above for all symbols. If it has
3981 already been set to -1 for this symbol, it means that we are
3982 discarding it because it appears in a duplicate header file.
3983 See the N_BINCL code below. */
3984 if (*symbol_map
== -1)
3987 /* Initialize *symbol_map to -1, which means that the symbol was
3988 not copied into the output file. We will change it later if
3989 we do copy the symbol over. */
3992 type
= bfd_h_get_8 (input_bfd
, sym
->e_type
);
3993 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
3999 /* Pass this symbol through. It is the target of an
4000 indirect or warning symbol. */
4001 val
= GET_WORD (input_bfd
, sym
->e_value
);
4006 /* Skip this symbol, which is the target of an indirect
4007 symbol that we have changed to no longer be an indirect
4014 struct aout_link_hash_entry
*hresolve
;
4016 /* We have saved the hash table entry for this symbol, if
4017 there is one. Note that we could just look it up again
4018 in the hash table, provided we first check that it is an
4022 /* Use the name from the hash table, in case the symbol was
4025 name
= h
->root
.root
.string
;
4027 /* If this is an indirect or warning symbol, then change
4028 hresolve to the base symbol. We also change *sym_hash so
4029 that the relocation routines relocate against the real
4032 if (h
!= (struct aout_link_hash_entry
*) NULL
4033 && (h
->root
.type
== bfd_link_hash_indirect
4034 || h
->root
.type
== bfd_link_hash_warning
))
4036 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
4037 while (hresolve
->root
.type
== bfd_link_hash_indirect
4038 || hresolve
->root
.type
== bfd_link_hash_warning
)
4039 hresolve
= ((struct aout_link_hash_entry
*)
4040 hresolve
->root
.u
.i
.link
);
4041 *sym_hash
= hresolve
;
4044 /* If the symbol has already been written out, skip it. */
4045 if (h
!= (struct aout_link_hash_entry
*) NULL
4046 && h
->root
.type
!= bfd_link_hash_warning
4049 if ((type
& N_TYPE
) == N_INDR
4050 || type
== N_WARNING
)
4052 *symbol_map
= h
->indx
;
4056 /* See if we are stripping this symbol. */
4062 case strip_debugger
:
4063 if ((type
& N_STAB
) != 0)
4067 if (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
4077 if (h
!= (struct aout_link_hash_entry
*) NULL
)
4082 /* Get the value of the symbol. */
4083 if ((type
& N_TYPE
) == N_TEXT
4085 symsec
= obj_textsec (input_bfd
);
4086 else if ((type
& N_TYPE
) == N_DATA
4088 symsec
= obj_datasec (input_bfd
);
4089 else if ((type
& N_TYPE
) == N_BSS
4091 symsec
= obj_bsssec (input_bfd
);
4092 else if ((type
& N_TYPE
) == N_ABS
4094 symsec
= bfd_abs_section_ptr
;
4095 else if (((type
& N_TYPE
) == N_INDR
4096 && (hresolve
== (struct aout_link_hash_entry
*) NULL
4097 || (hresolve
->root
.type
!= bfd_link_hash_defined
4098 && hresolve
->root
.type
!= bfd_link_hash_defweak
4099 && hresolve
->root
.type
!= bfd_link_hash_common
)))
4100 || type
== N_WARNING
)
4102 /* Pass the next symbol through unchanged. The
4103 condition above for indirect symbols is so that if
4104 the indirect symbol was defined, we output it with
4105 the correct definition so the debugger will
4108 val
= GET_WORD (input_bfd
, sym
->e_value
);
4111 else if ((type
& N_STAB
) != 0)
4113 val
= GET_WORD (input_bfd
, sym
->e_value
);
4118 /* If we get here with an indirect symbol, it means that
4119 we are outputting it with a real definition. In such
4120 a case we do not want to output the next symbol,
4121 which is the target of the indirection. */
4122 if ((type
& N_TYPE
) == N_INDR
)
4127 /* We need to get the value from the hash table. We use
4128 hresolve so that if we have defined an indirect
4129 symbol we output the final definition. */
4130 if (h
== (struct aout_link_hash_entry
*) NULL
)
4132 switch (type
& N_TYPE
)
4135 symsec
= obj_textsec (input_bfd
);
4138 symsec
= obj_datasec (input_bfd
);
4141 symsec
= obj_bsssec (input_bfd
);
4144 symsec
= bfd_abs_section_ptr
;
4151 else if (hresolve
->root
.type
== bfd_link_hash_defined
4152 || hresolve
->root
.type
== bfd_link_hash_defweak
)
4154 asection
*input_section
;
4155 asection
*output_section
;
4157 /* This case usually means a common symbol which was
4158 turned into a defined symbol. */
4159 input_section
= hresolve
->root
.u
.def
.section
;
4160 output_section
= input_section
->output_section
;
4161 BFD_ASSERT (bfd_is_abs_section (output_section
)
4162 || output_section
->owner
== output_bfd
);
4163 val
= (hresolve
->root
.u
.def
.value
4164 + bfd_get_section_vma (output_bfd
, output_section
)
4165 + input_section
->output_offset
);
4167 /* Get the correct type based on the section. If
4168 this is a constructed set, force it to be
4169 globally visible. */
4178 if (output_section
== obj_textsec (output_bfd
))
4179 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4182 else if (output_section
== obj_datasec (output_bfd
))
4183 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4186 else if (output_section
== obj_bsssec (output_bfd
))
4187 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4191 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
4195 else if (hresolve
->root
.type
== bfd_link_hash_common
)
4196 val
= hresolve
->root
.u
.c
.size
;
4197 else if (hresolve
->root
.type
== bfd_link_hash_undefweak
)
4205 if (symsec
!= (asection
*) NULL
)
4206 val
= (symsec
->output_section
->vma
4207 + symsec
->output_offset
4208 + (GET_WORD (input_bfd
, sym
->e_value
)
4211 /* If this is a global symbol set the written flag, and if
4212 it is a local symbol see if we should discard it. */
4213 if (h
!= (struct aout_link_hash_entry
*) NULL
)
4216 h
->indx
= obj_aout_external_sym_count (output_bfd
);
4218 else if ((type
& N_TYPE
) != N_SETT
4219 && (type
& N_TYPE
) != N_SETD
4220 && (type
& N_TYPE
) != N_SETB
4221 && (type
& N_TYPE
) != N_SETA
)
4228 if (*name
== *finfo
->info
->lprefix
4229 && (finfo
->info
->lprefix_len
== 1
4230 || strncmp (name
, finfo
->info
->lprefix
,
4231 finfo
->info
->lprefix_len
) == 0))
4245 /* An N_BINCL symbol indicates the start of the stabs
4246 entries for a header file. We need to scan ahead to the
4247 next N_EINCL symbol, ignoring nesting, adding up all the
4248 characters in the symbol names, not including the file
4249 numbers in types (the first number after an open
4251 if (type
== N_BINCL
)
4253 struct external_nlist
*incl_sym
;
4255 struct aout_link_includes_entry
*incl_entry
;
4256 struct aout_link_includes_totals
*t
;
4260 for (incl_sym
= sym
+ 1; incl_sym
< sym_end
; incl_sym
++)
4264 incl_type
= bfd_h_get_8 (input_bfd
, incl_sym
->e_type
);
4265 if (incl_type
== N_EINCL
)
4271 else if (incl_type
== N_BINCL
)
4277 s
= strings
+ GET_WORD (input_bfd
, incl_sym
->e_strx
);
4278 for (; *s
!= '\0'; s
++)
4283 /* Skip the file number. */
4285 while (isdigit ((unsigned char) *s
))
4293 /* If we have already included a header file with the
4294 same value, then replace this one with an N_EXCL
4296 copy
= ! finfo
->info
->keep_memory
;
4297 incl_entry
= aout_link_includes_lookup (&finfo
->includes
,
4299 if (incl_entry
== NULL
)
4301 for (t
= incl_entry
->totals
; t
!= NULL
; t
= t
->next
)
4302 if (t
->total
== val
)
4306 /* This is the first time we have seen this header
4307 file with this set of stabs strings. */
4308 t
= ((struct aout_link_includes_totals
*)
4309 bfd_hash_allocate (&finfo
->includes
.root
,
4314 t
->next
= incl_entry
->totals
;
4315 incl_entry
->totals
= t
;
4321 /* This is a duplicate header file. We must change
4322 it to be an N_EXCL entry, and mark all the
4323 included symbols to prevent outputting them. */
4327 for (incl_sym
= sym
+ 1, incl_map
= symbol_map
+ 1;
4329 incl_sym
++, incl_map
++)
4333 incl_type
= bfd_h_get_8 (input_bfd
, incl_sym
->e_type
);
4334 if (incl_type
== N_EINCL
)
4343 else if (incl_type
== N_BINCL
)
4352 /* Copy this symbol into the list of symbols we are going to
4354 bfd_h_put_8 (output_bfd
, type
, outsym
->e_type
);
4355 bfd_h_put_8 (output_bfd
, bfd_h_get_8 (input_bfd
, sym
->e_other
),
4357 bfd_h_put_16 (output_bfd
, bfd_h_get_16 (input_bfd
, sym
->e_desc
),
4360 if (! finfo
->info
->keep_memory
)
4362 /* name points into a string table which we are going to
4363 free. If there is a hash table entry, use that string.
4364 Otherwise, copy name into memory. */
4365 if (h
!= (struct aout_link_hash_entry
*) NULL
)
4366 name
= h
->root
.root
.string
;
4370 strtab_index
= add_to_stringtab (output_bfd
, finfo
->strtab
,
4372 if (strtab_index
== (bfd_size_type
) -1)
4374 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4375 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
4376 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
4377 ++obj_aout_external_sym_count (output_bfd
);
4381 /* Write out the output symbols we have just constructed. */
4382 if (outsym
> finfo
->output_syms
)
4384 bfd_size_type outsym_count
;
4386 if (bfd_seek (output_bfd
, finfo
->symoff
, SEEK_SET
) != 0)
4388 outsym_count
= outsym
- finfo
->output_syms
;
4389 if (bfd_write ((PTR
) finfo
->output_syms
,
4390 (bfd_size_type
) EXTERNAL_NLIST_SIZE
,
4391 (bfd_size_type
) outsym_count
, output_bfd
)
4392 != outsym_count
* EXTERNAL_NLIST_SIZE
)
4394 finfo
->symoff
+= outsym_count
* EXTERNAL_NLIST_SIZE
;
4400 /* Write out a symbol that was not associated with an a.out input
4404 aout_link_write_other_symbol (h
, data
)
4405 struct aout_link_hash_entry
*h
;
4408 struct aout_final_link_info
*finfo
= (struct aout_final_link_info
*) data
;
4412 struct external_nlist outsym
;
4415 output_bfd
= finfo
->output_bfd
;
4417 if (aout_backend_info (output_bfd
)->write_dynamic_symbol
!= NULL
)
4419 if (! ((*aout_backend_info (output_bfd
)->write_dynamic_symbol
)
4420 (output_bfd
, finfo
->info
, h
)))
4422 /* FIXME: No way to handle errors. */
4432 /* An indx of -2 means the symbol must be written. */
4434 && (finfo
->info
->strip
== strip_all
4435 || (finfo
->info
->strip
== strip_some
4436 && bfd_hash_lookup (finfo
->info
->keep_hash
, h
->root
.root
.string
,
4437 false, false) == NULL
)))
4440 switch (h
->root
.type
)
4444 /* Avoid variable not initialized warnings. */
4446 case bfd_link_hash_new
:
4447 /* This can happen for set symbols when sets are not being
4450 case bfd_link_hash_undefined
:
4451 type
= N_UNDF
| N_EXT
;
4454 case bfd_link_hash_defined
:
4455 case bfd_link_hash_defweak
:
4459 sec
= h
->root
.u
.def
.section
->output_section
;
4460 BFD_ASSERT (bfd_is_abs_section (sec
)
4461 || sec
->owner
== output_bfd
);
4462 if (sec
== obj_textsec (output_bfd
))
4463 type
= h
->root
.type
== bfd_link_hash_defined
? N_TEXT
: N_WEAKT
;
4464 else if (sec
== obj_datasec (output_bfd
))
4465 type
= h
->root
.type
== bfd_link_hash_defined
? N_DATA
: N_WEAKD
;
4466 else if (sec
== obj_bsssec (output_bfd
))
4467 type
= h
->root
.type
== bfd_link_hash_defined
? N_BSS
: N_WEAKB
;
4469 type
= h
->root
.type
== bfd_link_hash_defined
? N_ABS
: N_WEAKA
;
4471 val
= (h
->root
.u
.def
.value
4473 + h
->root
.u
.def
.section
->output_offset
);
4476 case bfd_link_hash_common
:
4477 type
= N_UNDF
| N_EXT
;
4478 val
= h
->root
.u
.c
.size
;
4480 case bfd_link_hash_undefweak
:
4483 case bfd_link_hash_indirect
:
4484 case bfd_link_hash_warning
:
4485 /* FIXME: Ignore these for now. The circumstances under which
4486 they should be written out are not clear to me. */
4490 bfd_h_put_8 (output_bfd
, type
, outsym
.e_type
);
4491 bfd_h_put_8 (output_bfd
, 0, outsym
.e_other
);
4492 bfd_h_put_16 (output_bfd
, 0, outsym
.e_desc
);
4493 indx
= add_to_stringtab (output_bfd
, finfo
->strtab
, h
->root
.root
.string
,
4495 if (indx
== (bfd_size_type
) -1)
4497 /* FIXME: No way to handle errors. */
4500 PUT_WORD (output_bfd
, indx
, outsym
.e_strx
);
4501 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
4503 if (bfd_seek (output_bfd
, finfo
->symoff
, SEEK_SET
) != 0
4504 || bfd_write ((PTR
) &outsym
, (bfd_size_type
) EXTERNAL_NLIST_SIZE
,
4505 (bfd_size_type
) 1, output_bfd
) != EXTERNAL_NLIST_SIZE
)
4507 /* FIXME: No way to handle errors. */
4511 finfo
->symoff
+= EXTERNAL_NLIST_SIZE
;
4512 h
->indx
= obj_aout_external_sym_count (output_bfd
);
4513 ++obj_aout_external_sym_count (output_bfd
);
4518 /* Link an a.out section into the output file. */
4521 aout_link_input_section (finfo
, input_bfd
, input_section
, reloff_ptr
,
4523 struct aout_final_link_info
*finfo
;
4525 asection
*input_section
;
4526 file_ptr
*reloff_ptr
;
4527 bfd_size_type rel_size
;
4529 bfd_size_type input_size
;
4532 /* Get the section contents. */
4533 input_size
= bfd_section_size (input_bfd
, input_section
);
4534 if (! bfd_get_section_contents (input_bfd
, input_section
,
4535 (PTR
) finfo
->contents
,
4536 (file_ptr
) 0, input_size
))
4539 /* Read in the relocs if we haven't already done it. */
4540 if (aout_section_data (input_section
) != NULL
4541 && aout_section_data (input_section
)->relocs
!= NULL
)
4542 relocs
= aout_section_data (input_section
)->relocs
;
4545 relocs
= finfo
->relocs
;
4548 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
4549 || bfd_read (relocs
, 1, rel_size
, input_bfd
) != rel_size
)
4554 /* Relocate the section contents. */
4555 if (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
)
4557 if (! aout_link_input_section_std (finfo
, input_bfd
, input_section
,
4558 (struct reloc_std_external
*) relocs
,
4559 rel_size
, finfo
->contents
))
4564 if (! aout_link_input_section_ext (finfo
, input_bfd
, input_section
,
4565 (struct reloc_ext_external
*) relocs
,
4566 rel_size
, finfo
->contents
))
4570 /* Write out the section contents. */
4571 if (! bfd_set_section_contents (finfo
->output_bfd
,
4572 input_section
->output_section
,
4573 (PTR
) finfo
->contents
,
4574 input_section
->output_offset
,
4578 /* If we are producing relocateable output, the relocs were
4579 modified, and we now write them out. */
4580 if (finfo
->info
->relocateable
&& rel_size
> 0)
4582 if (bfd_seek (finfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
4584 if (bfd_write (relocs
, (bfd_size_type
) 1, rel_size
, finfo
->output_bfd
)
4587 *reloff_ptr
+= rel_size
;
4589 /* Assert that the relocs have not run into the symbols, and
4590 that if these are the text relocs they have not run into the
4592 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (finfo
->output_bfd
)
4593 && (reloff_ptr
!= &finfo
->treloff
4595 <= obj_datasec (finfo
->output_bfd
)->rel_filepos
)));
4601 /* Get the section corresponding to a reloc index. */
4603 static INLINE asection
*
4604 aout_reloc_index_to_section (abfd
, indx
)
4608 switch (indx
& N_TYPE
)
4611 return obj_textsec (abfd
);
4613 return obj_datasec (abfd
);
4615 return obj_bsssec (abfd
);
4618 return bfd_abs_section_ptr
;
4624 /* Relocate an a.out section using standard a.out relocs. */
4627 aout_link_input_section_std (finfo
, input_bfd
, input_section
, relocs
,
4629 struct aout_final_link_info
*finfo
;
4631 asection
*input_section
;
4632 struct reloc_std_external
*relocs
;
4633 bfd_size_type rel_size
;
4636 boolean (*check_dynamic_reloc
) PARAMS ((struct bfd_link_info
*,
4638 struct aout_link_hash_entry
*,
4639 PTR
, bfd_byte
*, boolean
*,
4642 boolean relocateable
;
4643 struct external_nlist
*syms
;
4645 struct aout_link_hash_entry
**sym_hashes
;
4647 bfd_size_type reloc_count
;
4648 register struct reloc_std_external
*rel
;
4649 struct reloc_std_external
*rel_end
;
4651 output_bfd
= finfo
->output_bfd
;
4652 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
4654 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
);
4655 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
4656 == output_bfd
->xvec
->header_byteorder
);
4658 relocateable
= finfo
->info
->relocateable
;
4659 syms
= obj_aout_external_syms (input_bfd
);
4660 strings
= obj_aout_external_strings (input_bfd
);
4661 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
4662 symbol_map
= finfo
->symbol_map
;
4664 reloc_count
= rel_size
/ RELOC_STD_SIZE
;
4666 rel_end
= rel
+ reloc_count
;
4667 for (; rel
< rel_end
; rel
++)
4674 reloc_howto_type
*howto
;
4675 struct aout_link_hash_entry
*h
= NULL
;
4677 bfd_reloc_status_type r
;
4679 r_addr
= GET_SWORD (input_bfd
, rel
->r_address
);
4681 #ifdef MY_reloc_howto
4682 howto
= MY_reloc_howto(input_bfd
, rel
, r_index
, r_extern
, r_pcrel
);
4688 unsigned int howto_idx
;
4690 if (bfd_header_big_endian (input_bfd
))
4692 r_index
= ((rel
->r_index
[0] << 16)
4693 | (rel
->r_index
[1] << 8)
4695 r_extern
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
));
4696 r_pcrel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_PCREL_BIG
));
4697 r_baserel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
4698 r_jmptable
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
4699 r_relative
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_RELATIVE_BIG
));
4700 r_length
= ((rel
->r_type
[0] & RELOC_STD_BITS_LENGTH_BIG
)
4701 >> RELOC_STD_BITS_LENGTH_SH_BIG
);
4705 r_index
= ((rel
->r_index
[2] << 16)
4706 | (rel
->r_index
[1] << 8)
4708 r_extern
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
));
4709 r_pcrel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_PCREL_LITTLE
));
4710 r_baserel
= (0 != (rel
->r_type
[0]
4711 & RELOC_STD_BITS_BASEREL_LITTLE
));
4712 r_jmptable
= (0 != (rel
->r_type
[0]
4713 & RELOC_STD_BITS_JMPTABLE_LITTLE
));
4714 r_relative
= (0 != (rel
->r_type
[0]
4715 & RELOC_STD_BITS_RELATIVE_LITTLE
));
4716 r_length
= ((rel
->r_type
[0] & RELOC_STD_BITS_LENGTH_LITTLE
)
4717 >> RELOC_STD_BITS_LENGTH_SH_LITTLE
);
4720 howto_idx
= (r_length
+ 4 * r_pcrel
+ 8 * r_baserel
4721 + 16 * r_jmptable
+ 32 * r_relative
);
4722 BFD_ASSERT (howto_idx
< TABLE_SIZE (howto_table_std
));
4723 howto
= howto_table_std
+ howto_idx
;
4729 /* We are generating a relocateable output file, and must
4730 modify the reloc accordingly. */
4733 /* If we know the symbol this relocation is against,
4734 convert it into a relocation against a section. This
4735 is what the native linker does. */
4736 h
= sym_hashes
[r_index
];
4737 if (h
!= (struct aout_link_hash_entry
*) NULL
4738 && (h
->root
.type
== bfd_link_hash_defined
4739 || h
->root
.type
== bfd_link_hash_defweak
))
4741 asection
*output_section
;
4743 /* Change the r_extern value. */
4744 if (bfd_header_big_endian (output_bfd
))
4745 rel
->r_type
[0] &=~ RELOC_STD_BITS_EXTERN_BIG
;
4747 rel
->r_type
[0] &=~ RELOC_STD_BITS_EXTERN_LITTLE
;
4749 /* Compute a new r_index. */
4750 output_section
= h
->root
.u
.def
.section
->output_section
;
4751 if (output_section
== obj_textsec (output_bfd
))
4753 else if (output_section
== obj_datasec (output_bfd
))
4755 else if (output_section
== obj_bsssec (output_bfd
))
4760 /* Add the symbol value and the section VMA to the
4761 addend stored in the contents. */
4762 relocation
= (h
->root
.u
.def
.value
4763 + output_section
->vma
4764 + h
->root
.u
.def
.section
->output_offset
);
4768 /* We must change r_index according to the symbol
4770 r_index
= symbol_map
[r_index
];
4776 /* We decided to strip this symbol, but it
4777 turns out that we can't. Note that we
4778 lose the other and desc information here.
4779 I don't think that will ever matter for a
4785 if (! aout_link_write_other_symbol (h
,
4795 name
= strings
+ GET_WORD (input_bfd
,
4796 syms
[r_index
].e_strx
);
4797 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
4798 (finfo
->info
, name
, input_bfd
, input_section
,
4808 /* Write out the new r_index value. */
4809 if (bfd_header_big_endian (output_bfd
))
4811 rel
->r_index
[0] = r_index
>> 16;
4812 rel
->r_index
[1] = r_index
>> 8;
4813 rel
->r_index
[2] = r_index
;
4817 rel
->r_index
[2] = r_index
>> 16;
4818 rel
->r_index
[1] = r_index
>> 8;
4819 rel
->r_index
[0] = r_index
;
4826 /* This is a relocation against a section. We must
4827 adjust by the amount that the section moved. */
4828 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4829 relocation
= (section
->output_section
->vma
4830 + section
->output_offset
4834 /* Change the address of the relocation. */
4835 PUT_WORD (output_bfd
,
4836 r_addr
+ input_section
->output_offset
,
4839 /* Adjust a PC relative relocation by removing the reference
4840 to the original address in the section and including the
4841 reference to the new address. */
4843 relocation
-= (input_section
->output_section
->vma
4844 + input_section
->output_offset
4845 - input_section
->vma
);
4847 #ifdef MY_relocatable_reloc
4848 MY_relocatable_reloc (howto
, output_bfd
, rel
, relocation
, r_addr
);
4851 if (relocation
== 0)
4854 r
= MY_relocate_contents (howto
,
4855 input_bfd
, relocation
,
4862 /* We are generating an executable, and must do a full
4867 h
= sym_hashes
[r_index
];
4869 if (h
!= (struct aout_link_hash_entry
*) NULL
4870 && (h
->root
.type
== bfd_link_hash_defined
4871 || h
->root
.type
== bfd_link_hash_defweak
))
4873 relocation
= (h
->root
.u
.def
.value
4874 + h
->root
.u
.def
.section
->output_section
->vma
4875 + h
->root
.u
.def
.section
->output_offset
);
4877 else if (h
!= (struct aout_link_hash_entry
*) NULL
4878 && h
->root
.type
== bfd_link_hash_undefweak
)
4890 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4891 relocation
= (section
->output_section
->vma
4892 + section
->output_offset
4895 relocation
+= input_section
->vma
;
4898 if (check_dynamic_reloc
!= NULL
)
4902 if (! ((*check_dynamic_reloc
)
4903 (finfo
->info
, input_bfd
, input_section
, h
,
4904 (PTR
) rel
, contents
, &skip
, &relocation
)))
4910 /* Now warn if a global symbol is undefined. We could not
4911 do this earlier, because check_dynamic_reloc might want
4912 to skip this reloc. */
4913 if (hundef
&& ! finfo
->info
->shared
&& ! r_baserel
)
4918 name
= h
->root
.root
.string
;
4920 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
4921 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
4922 (finfo
->info
, name
, input_bfd
, input_section
, r_addr
)))
4926 r
= MY_final_link_relocate (howto
,
4927 input_bfd
, input_section
,
4928 contents
, r_addr
, relocation
,
4932 if (r
!= bfd_reloc_ok
)
4937 case bfd_reloc_outofrange
:
4939 case bfd_reloc_overflow
:
4944 name
= h
->root
.root
.string
;
4946 name
= strings
+ GET_WORD (input_bfd
,
4947 syms
[r_index
].e_strx
);
4952 s
= aout_reloc_index_to_section (input_bfd
, r_index
);
4953 name
= bfd_section_name (input_bfd
, s
);
4955 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
4956 (finfo
->info
, name
, howto
->name
,
4957 (bfd_vma
) 0, input_bfd
, input_section
, r_addr
)))
4968 /* Relocate an a.out section using extended a.out relocs. */
4971 aout_link_input_section_ext (finfo
, input_bfd
, input_section
, relocs
,
4973 struct aout_final_link_info
*finfo
;
4975 asection
*input_section
;
4976 struct reloc_ext_external
*relocs
;
4977 bfd_size_type rel_size
;
4980 boolean (*check_dynamic_reloc
) PARAMS ((struct bfd_link_info
*,
4982 struct aout_link_hash_entry
*,
4983 PTR
, bfd_byte
*, boolean
*,
4986 boolean relocateable
;
4987 struct external_nlist
*syms
;
4989 struct aout_link_hash_entry
**sym_hashes
;
4991 bfd_size_type reloc_count
;
4992 register struct reloc_ext_external
*rel
;
4993 struct reloc_ext_external
*rel_end
;
4995 output_bfd
= finfo
->output_bfd
;
4996 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
4998 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_EXT_SIZE
);
4999 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
5000 == output_bfd
->xvec
->header_byteorder
);
5002 relocateable
= finfo
->info
->relocateable
;
5003 syms
= obj_aout_external_syms (input_bfd
);
5004 strings
= obj_aout_external_strings (input_bfd
);
5005 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
5006 symbol_map
= finfo
->symbol_map
;
5008 reloc_count
= rel_size
/ RELOC_EXT_SIZE
;
5010 rel_end
= rel
+ reloc_count
;
5011 for (; rel
< rel_end
; rel
++)
5016 unsigned int r_type
;
5018 struct aout_link_hash_entry
*h
= NULL
;
5019 asection
*r_section
= NULL
;
5022 r_addr
= GET_SWORD (input_bfd
, rel
->r_address
);
5024 if (bfd_header_big_endian (input_bfd
))
5026 r_index
= ((rel
->r_index
[0] << 16)
5027 | (rel
->r_index
[1] << 8)
5029 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
5030 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
5031 >> RELOC_EXT_BITS_TYPE_SH_BIG
);
5035 r_index
= ((rel
->r_index
[2] << 16)
5036 | (rel
->r_index
[1] << 8)
5038 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
5039 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
5040 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
);
5043 r_addend
= GET_SWORD (input_bfd
, rel
->r_addend
);
5045 BFD_ASSERT (r_type
< TABLE_SIZE (howto_table_ext
));
5049 /* We are generating a relocateable output file, and must
5050 modify the reloc accordingly. */
5053 /* If we know the symbol this relocation is against,
5054 convert it into a relocation against a section. This
5055 is what the native linker does. */
5056 h
= sym_hashes
[r_index
];
5057 if (h
!= (struct aout_link_hash_entry
*) NULL
5058 && (h
->root
.type
== bfd_link_hash_defined
5059 || h
->root
.type
== bfd_link_hash_defweak
))
5061 asection
*output_section
;
5063 /* Change the r_extern value. */
5064 if (bfd_header_big_endian (output_bfd
))
5065 rel
->r_type
[0] &=~ RELOC_EXT_BITS_EXTERN_BIG
;
5067 rel
->r_type
[0] &=~ RELOC_EXT_BITS_EXTERN_LITTLE
;
5069 /* Compute a new r_index. */
5070 output_section
= h
->root
.u
.def
.section
->output_section
;
5071 if (output_section
== obj_textsec (output_bfd
))
5073 else if (output_section
== obj_datasec (output_bfd
))
5075 else if (output_section
== obj_bsssec (output_bfd
))
5080 /* Add the symbol value and the section VMA to the
5082 relocation
= (h
->root
.u
.def
.value
5083 + output_section
->vma
5084 + h
->root
.u
.def
.section
->output_offset
);
5086 /* Now RELOCATION is the VMA of the final
5087 destination. If this is a PC relative reloc,
5088 then ADDEND is the negative of the source VMA.
5089 We want to set ADDEND to the difference between
5090 the destination VMA and the source VMA, which
5091 means we must adjust RELOCATION by the change in
5092 the source VMA. This is done below. */
5096 /* We must change r_index according to the symbol
5098 r_index
= symbol_map
[r_index
];
5104 /* We decided to strip this symbol, but it
5105 turns out that we can't. Note that we
5106 lose the other and desc information here.
5107 I don't think that will ever matter for a
5113 if (! aout_link_write_other_symbol (h
,
5123 name
= strings
+ GET_WORD (input_bfd
,
5124 syms
[r_index
].e_strx
);
5125 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
5126 (finfo
->info
, name
, input_bfd
, input_section
,
5135 /* If this is a PC relative reloc, then the addend
5136 is the negative of the source VMA. We must
5137 adjust it by the change in the source VMA. This
5141 /* Write out the new r_index value. */
5142 if (bfd_header_big_endian (output_bfd
))
5144 rel
->r_index
[0] = r_index
>> 16;
5145 rel
->r_index
[1] = r_index
>> 8;
5146 rel
->r_index
[2] = r_index
;
5150 rel
->r_index
[2] = r_index
>> 16;
5151 rel
->r_index
[1] = r_index
>> 8;
5152 rel
->r_index
[0] = r_index
;
5157 /* This is a relocation against a section. We must
5158 adjust by the amount that the section moved. */
5159 r_section
= aout_reloc_index_to_section (input_bfd
, r_index
);
5160 relocation
= (r_section
->output_section
->vma
5161 + r_section
->output_offset
5164 /* If this is a PC relative reloc, then the addend is
5165 the difference in VMA between the destination and the
5166 source. We have just adjusted for the change in VMA
5167 of the destination, so we must also adjust by the
5168 change in VMA of the source. This is done below. */
5171 /* As described above, we must always adjust a PC relative
5172 reloc by the change in VMA of the source. */
5173 if (howto_table_ext
[r_type
].pc_relative
)
5174 relocation
-= (input_section
->output_section
->vma
5175 + input_section
->output_offset
5176 - input_section
->vma
);
5178 /* Change the addend if necessary. */
5179 if (relocation
!= 0)
5180 PUT_WORD (output_bfd
, r_addend
+ relocation
, rel
->r_addend
);
5182 /* Change the address of the relocation. */
5183 PUT_WORD (output_bfd
,
5184 r_addr
+ input_section
->output_offset
,
5190 bfd_reloc_status_type r
;
5192 /* We are generating an executable, and must do a full
5197 h
= sym_hashes
[r_index
];
5199 if (h
!= (struct aout_link_hash_entry
*) NULL
5200 && (h
->root
.type
== bfd_link_hash_defined
5201 || h
->root
.type
== bfd_link_hash_defweak
))
5203 relocation
= (h
->root
.u
.def
.value
5204 + h
->root
.u
.def
.section
->output_section
->vma
5205 + h
->root
.u
.def
.section
->output_offset
);
5207 else if (h
!= (struct aout_link_hash_entry
*) NULL
5208 && h
->root
.type
== bfd_link_hash_undefweak
)
5216 else if (r_type
== RELOC_BASE10
5217 || r_type
== RELOC_BASE13
5218 || r_type
== RELOC_BASE22
)
5220 struct external_nlist
*sym
;
5223 /* For base relative relocs, r_index is always an index
5224 into the symbol table, even if r_extern is 0. */
5225 sym
= syms
+ r_index
;
5226 type
= bfd_h_get_8 (input_bfd
, sym
->e_type
);
5227 if ((type
& N_TYPE
) == N_TEXT
5229 r_section
= obj_textsec (input_bfd
);
5230 else if ((type
& N_TYPE
) == N_DATA
5232 r_section
= obj_datasec (input_bfd
);
5233 else if ((type
& N_TYPE
) == N_BSS
5235 r_section
= obj_bsssec (input_bfd
);
5236 else if ((type
& N_TYPE
) == N_ABS
5238 r_section
= bfd_abs_section_ptr
;
5241 relocation
= (r_section
->output_section
->vma
5242 + r_section
->output_offset
5243 + (GET_WORD (input_bfd
, sym
->e_value
)
5248 r_section
= aout_reloc_index_to_section (input_bfd
, r_index
);
5250 /* If this is a PC relative reloc, then R_ADDEND is the
5251 difference between the two vmas, or
5252 old_dest_sec + old_dest_off - (old_src_sec + old_src_off)
5254 old_dest_sec == section->vma
5256 old_src_sec == input_section->vma
5258 old_src_off == r_addr
5260 _bfd_final_link_relocate expects RELOCATION +
5261 R_ADDEND to be the VMA of the destination minus
5262 r_addr (the minus r_addr is because this relocation
5263 is not pcrel_offset, which is a bit confusing and
5264 should, perhaps, be changed), or
5267 new_dest_sec == output_section->vma + output_offset
5268 We arrange for this to happen by setting RELOCATION to
5269 new_dest_sec + old_src_sec - old_dest_sec
5271 If this is not a PC relative reloc, then R_ADDEND is
5272 simply the VMA of the destination, so we set
5273 RELOCATION to the change in the destination VMA, or
5274 new_dest_sec - old_dest_sec
5276 relocation
= (r_section
->output_section
->vma
5277 + r_section
->output_offset
5279 if (howto_table_ext
[r_type
].pc_relative
)
5280 relocation
+= input_section
->vma
;
5283 if (check_dynamic_reloc
!= NULL
)
5287 if (! ((*check_dynamic_reloc
)
5288 (finfo
->info
, input_bfd
, input_section
, h
,
5289 (PTR
) rel
, contents
, &skip
, &relocation
)))
5295 /* Now warn if a global symbol is undefined. We could not
5296 do this earlier, because check_dynamic_reloc might want
5297 to skip this reloc. */
5299 && ! finfo
->info
->shared
5300 && r_type
!= RELOC_BASE10
5301 && r_type
!= RELOC_BASE13
5302 && r_type
!= RELOC_BASE22
)
5307 name
= h
->root
.root
.string
;
5309 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
5310 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
5311 (finfo
->info
, name
, input_bfd
, input_section
, r_addr
)))
5315 r
= MY_final_link_relocate (howto_table_ext
+ r_type
,
5316 input_bfd
, input_section
,
5317 contents
, r_addr
, relocation
,
5319 if (r
!= bfd_reloc_ok
)
5324 case bfd_reloc_outofrange
:
5326 case bfd_reloc_overflow
:
5331 name
= h
->root
.root
.string
;
5333 || r_type
== RELOC_BASE10
5334 || r_type
== RELOC_BASE13
5335 || r_type
== RELOC_BASE22
)
5336 name
= strings
+ GET_WORD (input_bfd
,
5337 syms
[r_index
].e_strx
);
5342 s
= aout_reloc_index_to_section (input_bfd
, r_index
);
5343 name
= bfd_section_name (input_bfd
, s
);
5345 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
5346 (finfo
->info
, name
, howto_table_ext
[r_type
].name
,
5347 r_addend
, input_bfd
, input_section
, r_addr
)))
5359 /* Handle a link order which is supposed to generate a reloc. */
5362 aout_link_reloc_link_order (finfo
, o
, p
)
5363 struct aout_final_link_info
*finfo
;
5365 struct bfd_link_order
*p
;
5367 struct bfd_link_order_reloc
*pr
;
5370 reloc_howto_type
*howto
;
5371 file_ptr
*reloff_ptr
;
5372 struct reloc_std_external srel
;
5373 struct reloc_ext_external erel
;
5378 if (p
->type
== bfd_section_reloc_link_order
)
5381 if (bfd_is_abs_section (pr
->u
.section
))
5382 r_index
= N_ABS
| N_EXT
;
5385 BFD_ASSERT (pr
->u
.section
->owner
== finfo
->output_bfd
);
5386 r_index
= pr
->u
.section
->target_index
;
5391 struct aout_link_hash_entry
*h
;
5393 BFD_ASSERT (p
->type
== bfd_symbol_reloc_link_order
);
5395 h
= ((struct aout_link_hash_entry
*)
5396 bfd_wrapped_link_hash_lookup (finfo
->output_bfd
, finfo
->info
,
5397 pr
->u
.name
, false, false, true));
5398 if (h
!= (struct aout_link_hash_entry
*) NULL
5403 /* We decided to strip this symbol, but it turns out that we
5404 can't. Note that we lose the other and desc information
5405 here. I don't think that will ever matter for a global
5409 if (! aout_link_write_other_symbol (h
, (PTR
) finfo
))
5415 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
5416 (finfo
->info
, pr
->u
.name
, (bfd
*) NULL
,
5417 (asection
*) NULL
, (bfd_vma
) 0)))
5423 howto
= bfd_reloc_type_lookup (finfo
->output_bfd
, pr
->reloc
);
5426 bfd_set_error (bfd_error_bad_value
);
5430 if (o
== obj_textsec (finfo
->output_bfd
))
5431 reloff_ptr
= &finfo
->treloff
;
5432 else if (o
== obj_datasec (finfo
->output_bfd
))
5433 reloff_ptr
= &finfo
->dreloff
;
5437 if (obj_reloc_entry_size (finfo
->output_bfd
) == RELOC_STD_SIZE
)
5440 MY_put_reloc(finfo
->output_bfd
, r_extern
, r_index
, p
->offset
, howto
,
5450 r_pcrel
= howto
->pc_relative
;
5451 r_baserel
= (howto
->type
& 8) != 0;
5452 r_jmptable
= (howto
->type
& 16) != 0;
5453 r_relative
= (howto
->type
& 32) != 0;
5454 r_length
= howto
->size
;
5456 PUT_WORD (finfo
->output_bfd
, p
->offset
, srel
.r_address
);
5457 if (bfd_header_big_endian (finfo
->output_bfd
))
5459 srel
.r_index
[0] = r_index
>> 16;
5460 srel
.r_index
[1] = r_index
>> 8;
5461 srel
.r_index
[2] = r_index
;
5463 ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
5464 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
5465 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
5466 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
5467 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
5468 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
5472 srel
.r_index
[2] = r_index
>> 16;
5473 srel
.r_index
[1] = r_index
>> 8;
5474 srel
.r_index
[0] = r_index
;
5476 ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
5477 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
5478 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
5479 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
5480 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
5481 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
5485 rel_ptr
= (PTR
) &srel
;
5487 /* We have to write the addend into the object file, since
5488 standard a.out relocs are in place. It would be more
5489 reliable if we had the current contents of the file here,
5490 rather than assuming zeroes, but we can't read the file since
5491 it was opened using bfd_openw. */
5492 if (pr
->addend
!= 0)
5495 bfd_reloc_status_type r
;
5499 size
= bfd_get_reloc_size (howto
);
5500 buf
= (bfd_byte
*) bfd_zmalloc (size
);
5501 if (buf
== (bfd_byte
*) NULL
)
5503 r
= MY_relocate_contents (howto
, finfo
->output_bfd
,
5510 case bfd_reloc_outofrange
:
5512 case bfd_reloc_overflow
:
5513 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
5515 (p
->type
== bfd_section_reloc_link_order
5516 ? bfd_section_name (finfo
->output_bfd
,
5519 howto
->name
, pr
->addend
, (bfd
*) NULL
,
5520 (asection
*) NULL
, (bfd_vma
) 0)))
5527 ok
= bfd_set_section_contents (finfo
->output_bfd
, o
,
5529 (file_ptr
) p
->offset
,
5538 PUT_WORD (finfo
->output_bfd
, p
->offset
, erel
.r_address
);
5540 if (bfd_header_big_endian (finfo
->output_bfd
))
5542 erel
.r_index
[0] = r_index
>> 16;
5543 erel
.r_index
[1] = r_index
>> 8;
5544 erel
.r_index
[2] = r_index
;
5546 ((r_extern
? RELOC_EXT_BITS_EXTERN_BIG
: 0)
5547 | (howto
->type
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
5551 erel
.r_index
[2] = r_index
>> 16;
5552 erel
.r_index
[1] = r_index
>> 8;
5553 erel
.r_index
[0] = r_index
;
5555 (r_extern
? RELOC_EXT_BITS_EXTERN_LITTLE
: 0)
5556 | (howto
->type
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
);
5559 PUT_WORD (finfo
->output_bfd
, pr
->addend
, erel
.r_addend
);
5561 rel_ptr
= (PTR
) &erel
;
5564 if (bfd_seek (finfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0
5565 || (bfd_write (rel_ptr
, (bfd_size_type
) 1,
5566 obj_reloc_entry_size (finfo
->output_bfd
),
5568 != obj_reloc_entry_size (finfo
->output_bfd
)))
5571 *reloff_ptr
+= obj_reloc_entry_size (finfo
->output_bfd
);
5573 /* Assert that the relocs have not run into the symbols, and that n
5574 the text relocs have not run into the data relocs. */
5575 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (finfo
->output_bfd
)
5576 && (reloff_ptr
!= &finfo
->treloff
5578 <= obj_datasec (finfo
->output_bfd
)->rel_filepos
)));