1 /* BFD semi-generic back-end for a.out binaries.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995 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., 675 Mass Ave, Cambridge, MA 02139, 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.) */
121 #define KEEPITTYPE int
123 #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 #define howto_table_ext NAME(aout,ext_howto_table)
170 #define howto_table_std NAME(aout,std_howto_table)
172 reloc_howto_type howto_table_ext
[] =
174 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
175 HOWTO(RELOC_8
, 0, 0, 8, false, 0, complain_overflow_bitfield
,0,"8", false, 0,0x000000ff, false),
176 HOWTO(RELOC_16
, 0, 1, 16, false, 0, complain_overflow_bitfield
,0,"16", false, 0,0x0000ffff, false),
177 HOWTO(RELOC_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,0,"32", false, 0,0xffffffff, false),
178 HOWTO(RELOC_DISP8
, 0, 0, 8, true, 0, complain_overflow_signed
,0,"DISP8", false, 0,0x000000ff, false),
179 HOWTO(RELOC_DISP16
, 0, 1, 16, true, 0, complain_overflow_signed
,0,"DISP16", false, 0,0x0000ffff, false),
180 HOWTO(RELOC_DISP32
, 0, 2, 32, true, 0, complain_overflow_signed
,0,"DISP32", false, 0,0xffffffff, false),
181 HOWTO(RELOC_WDISP30
,2, 2, 30, true, 0, complain_overflow_signed
,0,"WDISP30", false, 0,0x3fffffff, false),
182 HOWTO(RELOC_WDISP22
,2, 2, 22, true, 0, complain_overflow_signed
,0,"WDISP22", false, 0,0x003fffff, false),
183 HOWTO(RELOC_HI22
, 10, 2, 22, false, 0, complain_overflow_bitfield
,0,"HI22", false, 0,0x003fffff, false),
184 HOWTO(RELOC_22
, 0, 2, 22, false, 0, complain_overflow_bitfield
,0,"22", false, 0,0x003fffff, false),
185 HOWTO(RELOC_13
, 0, 2, 13, false, 0, complain_overflow_bitfield
,0,"13", false, 0,0x00001fff, false),
186 HOWTO(RELOC_LO10
, 0, 2, 10, false, 0, complain_overflow_dont
,0,"LO10", false, 0,0x000003ff, false),
187 HOWTO(RELOC_SFA_BASE
,0, 2, 32, false, 0, complain_overflow_bitfield
,0,"SFA_BASE", false, 0,0xffffffff, false),
188 HOWTO(RELOC_SFA_OFF13
,0,2, 32, false, 0, complain_overflow_bitfield
,0,"SFA_OFF13",false, 0,0xffffffff, false),
189 HOWTO(RELOC_BASE10
, 0, 2, 16, false, 0, complain_overflow_bitfield
,0,"BASE10", false, 0,0x0000ffff, false),
190 HOWTO(RELOC_BASE13
, 0, 2, 13, false, 0, complain_overflow_bitfield
,0,"BASE13", false, 0,0x00001fff, false),
191 HOWTO(RELOC_BASE22
, 0, 2, 0, false, 0, complain_overflow_bitfield
,0,"BASE22", false, 0,0x00000000, false),
192 HOWTO(RELOC_PC10
, 0, 2, 10, false, 0, complain_overflow_bitfield
,0,"PC10", false, 0,0x000003ff, false),
193 HOWTO(RELOC_PC22
, 0, 2, 22, false, 0, complain_overflow_bitfield
,0,"PC22", false, 0,0x003fffff, false),
194 HOWTO(RELOC_JMP_TBL
,0, 2, 32, false, 0, complain_overflow_bitfield
,0,"JMP_TBL", false, 0,0xffffffff, false),
195 HOWTO(RELOC_SEGOFF16
,0, 2, 0, false, 0, complain_overflow_bitfield
,0,"SEGOFF16", false, 0,0x00000000, false),
196 HOWTO(RELOC_GLOB_DAT
,0, 2, 0, false, 0, complain_overflow_bitfield
,0,"GLOB_DAT", false, 0,0x00000000, false),
197 HOWTO(RELOC_JMP_SLOT
,0, 2, 0, false, 0, complain_overflow_bitfield
,0,"JMP_SLOT", false, 0,0x00000000, false),
198 HOWTO(RELOC_RELATIVE
,0, 2, 0, false, 0, complain_overflow_bitfield
,0,"RELATIVE", false, 0,0x00000000, false),
201 /* Convert standard reloc records to "arelent" format (incl byte swap). */
203 reloc_howto_type howto_table_std
[] = {
204 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
205 HOWTO( 0, 0, 0, 8, false, 0, complain_overflow_bitfield
,0,"8", true, 0x000000ff,0x000000ff, false),
206 HOWTO( 1, 0, 1, 16, false, 0, complain_overflow_bitfield
,0,"16", true, 0x0000ffff,0x0000ffff, false),
207 HOWTO( 2, 0, 2, 32, false, 0, complain_overflow_bitfield
,0,"32", true, 0xffffffff,0xffffffff, false),
208 HOWTO( 3, 0, 4, 64, false, 0, complain_overflow_bitfield
,0,"64", true, 0xdeaddead,0xdeaddead, false),
209 HOWTO( 4, 0, 0, 8, true, 0, complain_overflow_signed
, 0,"DISP8", true, 0x000000ff,0x000000ff, false),
210 HOWTO( 5, 0, 1, 16, true, 0, complain_overflow_signed
, 0,"DISP16", true, 0x0000ffff,0x0000ffff, false),
211 HOWTO( 6, 0, 2, 32, true, 0, complain_overflow_signed
, 0,"DISP32", true, 0xffffffff,0xffffffff, false),
212 HOWTO( 7, 0, 4, 64, true, 0, complain_overflow_signed
, 0,"DISP64", true, 0xfeedface,0xfeedface, false),
213 HOWTO( 8, 0, 2, 0, false, 0, complain_overflow_bitfield
,0,"GOT_REL", false, 0,0x00000000, false),
214 HOWTO( 9, 0, 1, 16, false, 0, complain_overflow_bitfield
,0,"BASE16", false,0xffffffff,0xffffffff, false),
215 HOWTO(10, 0, 2, 32, false, 0, complain_overflow_bitfield
,0,"BASE32", false,0xffffffff,0xffffffff, false),
221 HOWTO(16, 0, 2, 0, false, 0, complain_overflow_bitfield
,0,"JMP_TABLE", false, 0,0x00000000, false),
229 { -1 }, { -1 }, { -1 }, { -1 }, { -1 }, { -1 }, { -1 }, { -1 },
230 HOWTO(32, 0, 2, 0, false, 0, complain_overflow_bitfield
,0,"RELATIVE", false, 0,0x00000000, false),
238 HOWTO(40, 0, 2, 0, false, 0, complain_overflow_bitfield
,0,"BASEREL", false, 0,0x00000000, false),
241 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
244 NAME(aout
,reloc_type_lookup
) (abfd
,code
)
246 bfd_reloc_code_real_type code
;
248 #define EXT(i,j) case i: return &howto_table_ext[j]
249 #define STD(i,j) case i: return &howto_table_std[j]
250 int ext
= obj_reloc_entry_size (abfd
) == RELOC_EXT_SIZE
;
251 if (code
== BFD_RELOC_CTOR
)
252 switch (bfd_get_arch_info (abfd
)->bits_per_address
)
264 EXT (BFD_RELOC_32
, 2);
265 EXT (BFD_RELOC_HI22
, 8);
266 EXT (BFD_RELOC_LO10
, 11);
267 EXT (BFD_RELOC_32_PCREL_S2
, 6);
268 EXT (BFD_RELOC_SPARC_WDISP22
, 7);
269 EXT (BFD_RELOC_SPARC13
, 10);
270 EXT (BFD_RELOC_SPARC_BASE13
, 15);
271 default: return (reloc_howto_type
*) NULL
;
277 STD (BFD_RELOC_16
, 1);
278 STD (BFD_RELOC_32
, 2);
279 STD (BFD_RELOC_8_PCREL
, 4);
280 STD (BFD_RELOC_16_PCREL
, 5);
281 STD (BFD_RELOC_32_PCREL
, 6);
282 STD (BFD_RELOC_16_BASEREL
, 9);
283 STD (BFD_RELOC_32_BASEREL
, 10);
284 default: return (reloc_howto_type
*) NULL
;
290 Internal entry points
293 @file{aoutx.h} exports several routines for accessing the
294 contents of an a.out file, which are gathered and exported in
295 turn by various format specific files (eg sunos.c).
301 aout_@var{size}_swap_exec_header_in
304 void aout_@var{size}_swap_exec_header_in,
306 struct external_exec *raw_bytes,
307 struct internal_exec *execp);
310 Swap the information in an executable header @var{raw_bytes} taken
311 from a raw byte stream memory image into the internal exec header
312 structure @var{execp}.
315 #ifndef NAME_swap_exec_header_in
317 NAME(aout
,swap_exec_header_in
) (abfd
, raw_bytes
, execp
)
319 struct external_exec
*raw_bytes
;
320 struct internal_exec
*execp
;
322 struct external_exec
*bytes
= (struct external_exec
*)raw_bytes
;
324 /* The internal_exec structure has some fields that are unused in this
325 configuration (IE for i960), so ensure that all such uninitialized
326 fields are zero'd out. There are places where two of these structs
327 are memcmp'd, and thus the contents do matter. */
328 memset ((PTR
) execp
, 0, sizeof (struct internal_exec
));
329 /* Now fill in fields in the execp, from the bytes in the raw data. */
330 execp
->a_info
= bfd_h_get_32 (abfd
, bytes
->e_info
);
331 execp
->a_text
= GET_WORD (abfd
, bytes
->e_text
);
332 execp
->a_data
= GET_WORD (abfd
, bytes
->e_data
);
333 execp
->a_bss
= GET_WORD (abfd
, bytes
->e_bss
);
334 execp
->a_syms
= GET_WORD (abfd
, bytes
->e_syms
);
335 execp
->a_entry
= GET_WORD (abfd
, bytes
->e_entry
);
336 execp
->a_trsize
= GET_WORD (abfd
, bytes
->e_trsize
);
337 execp
->a_drsize
= GET_WORD (abfd
, bytes
->e_drsize
);
339 #define NAME_swap_exec_header_in NAME(aout,swap_exec_header_in)
344 aout_@var{size}_swap_exec_header_out
347 void aout_@var{size}_swap_exec_header_out
349 struct internal_exec *execp,
350 struct external_exec *raw_bytes);
353 Swap the information in an internal exec header structure
354 @var{execp} into the buffer @var{raw_bytes} ready for writing to disk.
357 NAME(aout
,swap_exec_header_out
) (abfd
, execp
, raw_bytes
)
359 struct internal_exec
*execp
;
360 struct external_exec
*raw_bytes
;
362 struct external_exec
*bytes
= (struct external_exec
*)raw_bytes
;
364 /* Now fill in fields in the raw data, from the fields in the exec struct. */
365 bfd_h_put_32 (abfd
, execp
->a_info
, bytes
->e_info
);
366 PUT_WORD (abfd
, execp
->a_text
, bytes
->e_text
);
367 PUT_WORD (abfd
, execp
->a_data
, bytes
->e_data
);
368 PUT_WORD (abfd
, execp
->a_bss
, bytes
->e_bss
);
369 PUT_WORD (abfd
, execp
->a_syms
, bytes
->e_syms
);
370 PUT_WORD (abfd
, execp
->a_entry
, bytes
->e_entry
);
371 PUT_WORD (abfd
, execp
->a_trsize
, bytes
->e_trsize
);
372 PUT_WORD (abfd
, execp
->a_drsize
, bytes
->e_drsize
);
375 /* Make all the section for an a.out file. */
378 NAME(aout
,make_sections
) (abfd
)
381 if (obj_textsec (abfd
) == (asection
*) NULL
382 && bfd_make_section (abfd
, ".text") == (asection
*) NULL
)
384 if (obj_datasec (abfd
) == (asection
*) NULL
385 && bfd_make_section (abfd
, ".data") == (asection
*) NULL
)
387 if (obj_bsssec (abfd
) == (asection
*) NULL
388 && bfd_make_section (abfd
, ".bss") == (asection
*) NULL
)
395 aout_@var{size}_some_aout_object_p
398 const bfd_target *aout_@var{size}_some_aout_object_p
400 const bfd_target *(*callback_to_real_object_p)());
403 Some a.out variant thinks that the file open in @var{abfd}
404 checking is an a.out file. Do some more checking, and set up
405 for access if it really is. Call back to the calling
406 environment's "finish up" function just before returning, to
407 handle any last-minute setup.
411 NAME(aout
,some_aout_object_p
) (abfd
, execp
, callback_to_real_object_p
)
413 struct internal_exec
*execp
;
414 const bfd_target
*(*callback_to_real_object_p
) PARAMS ((bfd
*));
416 struct aout_data_struct
*rawptr
, *oldrawptr
;
417 const bfd_target
*result
;
419 rawptr
= (struct aout_data_struct
*) bfd_zalloc (abfd
, sizeof (struct aout_data_struct
));
420 if (rawptr
== NULL
) {
421 bfd_set_error (bfd_error_no_memory
);
425 oldrawptr
= abfd
->tdata
.aout_data
;
426 abfd
->tdata
.aout_data
= rawptr
;
428 /* Copy the contents of the old tdata struct.
429 In particular, we want the subformat, since for hpux it was set in
430 hp300hpux.c:swap_exec_header_in and will be used in
431 hp300hpux.c:callback. */
432 if (oldrawptr
!= NULL
)
433 *abfd
->tdata
.aout_data
= *oldrawptr
;
435 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
436 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
; /* Copy in the internal_exec struct */
437 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
439 /* Set the file flags */
440 abfd
->flags
= NO_FLAGS
;
441 if (execp
->a_drsize
|| execp
->a_trsize
)
442 abfd
->flags
|= HAS_RELOC
;
443 /* Setting of EXEC_P has been deferred to the bottom of this function */
445 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
446 if (N_DYNAMIC(*execp
))
447 abfd
->flags
|= DYNAMIC
;
449 if (N_MAGIC (*execp
) == ZMAGIC
)
451 abfd
->flags
|= D_PAGED
| WP_TEXT
;
452 adata (abfd
).magic
= z_magic
;
454 else if (N_MAGIC (*execp
) == QMAGIC
)
456 abfd
->flags
|= D_PAGED
| WP_TEXT
;
457 adata (abfd
).magic
= z_magic
;
458 adata (abfd
).subformat
= q_magic_format
;
460 else if (N_MAGIC (*execp
) == NMAGIC
)
462 abfd
->flags
|= WP_TEXT
;
463 adata (abfd
).magic
= n_magic
;
465 else if (N_MAGIC (*execp
) == OMAGIC
466 || N_MAGIC (*execp
) == BMAGIC
)
467 adata (abfd
).magic
= o_magic
;
470 /* Should have been checked with N_BADMAG before this routine
475 bfd_get_start_address (abfd
) = execp
->a_entry
;
477 obj_aout_symbols (abfd
) = (aout_symbol_type
*)NULL
;
478 bfd_get_symcount (abfd
) = execp
->a_syms
/ sizeof (struct external_nlist
);
480 /* The default relocation entry size is that of traditional V7 Unix. */
481 obj_reloc_entry_size (abfd
) = RELOC_STD_SIZE
;
483 /* The default symbol entry size is that of traditional Unix. */
484 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
486 obj_aout_external_syms (abfd
) = NULL
;
487 obj_aout_external_strings (abfd
) = NULL
;
488 obj_aout_sym_hashes (abfd
) = NULL
;
490 if (! NAME(aout
,make_sections
) (abfd
))
493 obj_datasec (abfd
)->_raw_size
= execp
->a_data
;
494 obj_bsssec (abfd
)->_raw_size
= execp
->a_bss
;
496 obj_textsec (abfd
)->flags
=
497 (execp
->a_trsize
!= 0
498 ? (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_RELOC
)
499 : (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
));
500 obj_datasec (abfd
)->flags
=
501 (execp
->a_drsize
!= 0
502 ? (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_RELOC
)
503 : (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
));
504 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
506 #ifdef THIS_IS_ONLY_DOCUMENTATION
507 /* The common code can't fill in these things because they depend
508 on either the start address of the text segment, the rounding
509 up of virtual addresses between segments, or the starting file
510 position of the text segment -- all of which varies among different
511 versions of a.out. */
513 /* Call back to the format-dependent code to fill in the rest of the
514 fields and do any further cleanup. Things that should be filled
515 in by the callback: */
517 struct exec
*execp
= exec_hdr (abfd
);
519 obj_textsec (abfd
)->size
= N_TXTSIZE(*execp
);
520 obj_textsec (abfd
)->raw_size
= N_TXTSIZE(*execp
);
521 /* data and bss are already filled in since they're so standard */
523 /* The virtual memory addresses of the sections */
524 obj_textsec (abfd
)->vma
= N_TXTADDR(*execp
);
525 obj_datasec (abfd
)->vma
= N_DATADDR(*execp
);
526 obj_bsssec (abfd
)->vma
= N_BSSADDR(*execp
);
528 /* The file offsets of the sections */
529 obj_textsec (abfd
)->filepos
= N_TXTOFF(*execp
);
530 obj_datasec (abfd
)->filepos
= N_DATOFF(*execp
);
532 /* The file offsets of the relocation info */
533 obj_textsec (abfd
)->rel_filepos
= N_TRELOFF(*execp
);
534 obj_datasec (abfd
)->rel_filepos
= N_DRELOFF(*execp
);
536 /* The file offsets of the string table and symbol table. */
537 obj_str_filepos (abfd
) = N_STROFF (*execp
);
538 obj_sym_filepos (abfd
) = N_SYMOFF (*execp
);
540 /* Determine the architecture and machine type of the object file. */
541 switch (N_MACHTYPE (*exec_hdr (abfd
))) {
543 abfd
->obj_arch
= bfd_arch_obscure
;
547 adata(abfd
)->page_size
= PAGE_SIZE
;
548 adata(abfd
)->segment_size
= SEGMENT_SIZE
;
549 adata(abfd
)->exec_bytes_size
= EXEC_BYTES_SIZE
;
553 /* The architecture is encoded in various ways in various a.out variants,
554 or is not encoded at all in some of them. The relocation size depends
555 on the architecture and the a.out variant. Finally, the return value
556 is the bfd_target vector in use. If an error occurs, return zero and
557 set bfd_error to the appropriate error code.
559 Formats such as b.out, which have additional fields in the a.out
560 header, should cope with them in this callback as well. */
561 #endif /* DOCUMENTATION */
563 result
= (*callback_to_real_object_p
)(abfd
);
565 /* Now that the segment addresses have been worked out, take a better
566 guess at whether the file is executable. If the entry point
567 is within the text segment, assume it is. (This makes files
568 executable even if their entry point address is 0, as long as
569 their text starts at zero.). */
570 if ((execp
->a_entry
>= obj_textsec(abfd
)->vma
) &&
571 (execp
->a_entry
< obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->_raw_size
))
572 abfd
->flags
|= EXEC_P
;
576 struct stat stat_buf
;
578 /* The original heuristic doesn't work in some important cases.
579 The a.out file has no information about the text start
580 address. For files (like kernels) linked to non-standard
581 addresses (ld -Ttext nnn) the entry point may not be between
582 the default text start (obj_textsec(abfd)->vma) and
583 (obj_textsec(abfd)->vma) + text size. This is not just a mach
584 issue. Many kernels are loaded at non standard addresses. */
586 && (fstat(fileno((FILE *) (abfd
->iostream
)), &stat_buf
) == 0)
587 && ((stat_buf
.st_mode
& 0111) != 0))
588 abfd
->flags
|= EXEC_P
;
590 #endif /* STAT_FOR_EXEC */
594 #if 0 /* These should be set correctly anyways. */
595 abfd
->sections
= obj_textsec (abfd
);
596 obj_textsec (abfd
)->next
= obj_datasec (abfd
);
597 obj_datasec (abfd
)->next
= obj_bsssec (abfd
);
603 abfd
->tdata
.aout_data
= oldrawptr
;
610 aout_@var{size}_mkobject
613 boolean aout_@var{size}_mkobject, (bfd *abfd);
616 Initialize BFD @var{abfd} for use with a.out files.
620 NAME(aout
,mkobject
) (abfd
)
623 struct aout_data_struct
*rawptr
;
625 bfd_set_error (bfd_error_system_call
);
627 /* Use an intermediate variable for clarity */
628 rawptr
= (struct aout_data_struct
*)bfd_zalloc (abfd
, sizeof (struct aout_data_struct
));
630 if (rawptr
== NULL
) {
631 bfd_set_error (bfd_error_no_memory
);
635 abfd
->tdata
.aout_data
= rawptr
;
636 exec_hdr (abfd
) = &(rawptr
->e
);
638 obj_textsec (abfd
) = (asection
*)NULL
;
639 obj_datasec (abfd
) = (asection
*)NULL
;
640 obj_bsssec (abfd
) = (asection
*)NULL
;
648 aout_@var{size}_machine_type
651 enum machine_type aout_@var{size}_machine_type
652 (enum bfd_architecture arch,
653 unsigned long machine));
656 Keep track of machine architecture and machine type for
657 a.out's. Return the <<machine_type>> for a particular
658 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
659 and machine can't be represented in a.out format.
661 If the architecture is understood, machine type 0 (default)
662 is always understood.
666 NAME(aout
,machine_type
) (arch
, machine
, unknown
)
667 enum bfd_architecture arch
;
668 unsigned long machine
;
671 enum machine_type arch_flags
;
673 arch_flags
= M_UNKNOWN
;
678 if (machine
== 0) arch_flags
= M_SPARC
;
683 case 0: arch_flags
= M_68010
; break;
684 case 68000: arch_flags
= M_UNKNOWN
; *unknown
= false; break;
685 case 68010: arch_flags
= M_68010
; break;
686 case 68020: arch_flags
= M_68020
; break;
687 default: arch_flags
= M_UNKNOWN
; break;
692 if (machine
== 0) arch_flags
= M_386
;
696 if (machine
== 0) arch_flags
= M_29K
;
700 if (machine
== 0) arch_flags
= M_ARM
;
707 case 3000: arch_flags
= M_MIPS1
; break;
710 case 6000: arch_flags
= M_MIPS2
; break;
711 default: arch_flags
= M_UNKNOWN
; break;
717 case 0: arch_flags
= M_NS32532
; break;
718 case 32032: arch_flags
= M_NS32032
; break;
719 case 32532: arch_flags
= M_NS32532
; break;
720 default: arch_flags
= M_UNKNOWN
; break;
728 /* start-sanitize-rce */
732 /* end-sanitize-rce */
735 arch_flags
= M_UNKNOWN
;
738 if (arch_flags
!= M_UNKNOWN
)
747 aout_@var{size}_set_arch_mach
750 boolean aout_@var{size}_set_arch_mach,
752 enum bfd_architecture arch,
753 unsigned long machine));
756 Set the architecture and the machine of the BFD @var{abfd} to the
757 values @var{arch} and @var{machine}. Verify that @var{abfd}'s format
758 can support the architecture required.
762 NAME(aout
,set_arch_mach
) (abfd
, arch
, machine
)
764 enum bfd_architecture arch
;
765 unsigned long machine
;
767 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
770 if (arch
!= bfd_arch_unknown
)
774 NAME(aout
,machine_type
) (arch
, machine
, &unknown
);
779 /* Determine the size of a relocation entry */
784 obj_reloc_entry_size (abfd
) = RELOC_EXT_SIZE
;
787 obj_reloc_entry_size (abfd
) = RELOC_STD_SIZE
;
791 return (*aout_backend_info(abfd
)->set_sizes
) (abfd
);
795 adjust_o_magic (abfd
, execp
)
797 struct internal_exec
*execp
;
799 file_ptr pos
= adata (abfd
).exec_bytes_size
;
804 obj_textsec(abfd
)->filepos
= pos
;
805 if (!obj_textsec(abfd
)->user_set_vma
)
806 obj_textsec(abfd
)->vma
= vma
;
808 vma
= obj_textsec(abfd
)->vma
;
810 pos
+= obj_textsec(abfd
)->_raw_size
;
811 vma
+= obj_textsec(abfd
)->_raw_size
;
814 if (!obj_datasec(abfd
)->user_set_vma
)
816 #if 0 /* ?? Does alignment in the file image really matter? */
817 pad
= align_power (vma
, obj_datasec(abfd
)->alignment_power
) - vma
;
819 obj_textsec(abfd
)->_raw_size
+= pad
;
822 obj_datasec(abfd
)->vma
= vma
;
825 vma
= obj_datasec(abfd
)->vma
;
826 obj_datasec(abfd
)->filepos
= pos
;
827 pos
+= obj_datasec(abfd
)->_raw_size
;
828 vma
+= obj_datasec(abfd
)->_raw_size
;
831 if (!obj_bsssec(abfd
)->user_set_vma
)
834 pad
= align_power (vma
, obj_bsssec(abfd
)->alignment_power
) - vma
;
836 obj_datasec(abfd
)->_raw_size
+= pad
;
839 obj_bsssec(abfd
)->vma
= vma
;
843 /* The VMA of the .bss section is set by the the VMA of the
844 .data section plus the size of the .data section. We may
845 need to add padding bytes to make this true. */
846 pad
= obj_bsssec (abfd
)->vma
- vma
;
849 obj_datasec (abfd
)->_raw_size
+= pad
;
853 obj_bsssec(abfd
)->filepos
= pos
;
855 /* Fix up the exec header. */
856 execp
->a_text
= obj_textsec(abfd
)->_raw_size
;
857 execp
->a_data
= obj_datasec(abfd
)->_raw_size
;
858 execp
->a_bss
= obj_bsssec(abfd
)->_raw_size
;
859 N_SET_MAGIC (*execp
, OMAGIC
);
863 adjust_z_magic (abfd
, execp
)
865 struct internal_exec
*execp
;
867 bfd_size_type data_pad
, text_pad
;
869 CONST
struct aout_backend_data
*abdp
;
870 int ztih
; /* Nonzero if text includes exec header. */
872 abdp
= aout_backend_info (abfd
);
876 && (abdp
->text_includes_header
877 || obj_aout_subformat (abfd
) == q_magic_format
));
878 obj_textsec(abfd
)->filepos
= (ztih
879 ? adata(abfd
).exec_bytes_size
880 : adata(abfd
).zmagic_disk_block_size
);
881 if (! obj_textsec(abfd
)->user_set_vma
)
883 /* ?? Do we really need to check for relocs here? */
884 obj_textsec(abfd
)->vma
= ((abfd
->flags
& HAS_RELOC
)
887 ? (abdp
->default_text_vma
888 + adata(abfd
).exec_bytes_size
)
889 : abdp
->default_text_vma
));
894 /* The .text section is being loaded at an unusual address. We
895 may need to pad it such that the .data section starts at a page
898 text_pad
= ((obj_textsec (abfd
)->filepos
- obj_textsec (abfd
)->vma
)
899 & (adata (abfd
).page_size
- 1));
901 text_pad
= ((- obj_textsec (abfd
)->vma
)
902 & (adata (abfd
).page_size
- 1));
905 /* Find start of data. */
908 text_end
= obj_textsec (abfd
)->filepos
+ obj_textsec (abfd
)->_raw_size
;
909 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
913 /* Note that if page_size == zmagic_disk_block_size, then
914 filepos == page_size, and this case is the same as the ztih
916 text_end
= obj_textsec (abfd
)->_raw_size
;
917 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
918 text_end
+= obj_textsec (abfd
)->filepos
;
920 obj_textsec(abfd
)->_raw_size
+= text_pad
;
921 text_end
+= text_pad
;
924 if (!obj_datasec(abfd
)->user_set_vma
)
927 vma
= obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->_raw_size
;
928 obj_datasec(abfd
)->vma
= BFD_ALIGN (vma
, adata(abfd
).segment_size
);
930 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
932 text_pad
= (obj_datasec(abfd
)->vma
933 - obj_textsec(abfd
)->vma
934 - obj_textsec(abfd
)->_raw_size
);
935 obj_textsec(abfd
)->_raw_size
+= text_pad
;
937 obj_datasec(abfd
)->filepos
= (obj_textsec(abfd
)->filepos
938 + obj_textsec(abfd
)->_raw_size
);
940 /* Fix up exec header while we're at it. */
941 execp
->a_text
= obj_textsec(abfd
)->_raw_size
;
942 if (ztih
&& (!abdp
|| (abdp
&& !abdp
->exec_header_not_counted
)))
943 execp
->a_text
+= adata(abfd
).exec_bytes_size
;
944 if (obj_aout_subformat (abfd
) == q_magic_format
)
945 N_SET_MAGIC (*execp
, QMAGIC
);
947 N_SET_MAGIC (*execp
, ZMAGIC
);
949 /* Spec says data section should be rounded up to page boundary. */
950 obj_datasec(abfd
)->_raw_size
951 = align_power (obj_datasec(abfd
)->_raw_size
,
952 obj_bsssec(abfd
)->alignment_power
);
953 execp
->a_data
= BFD_ALIGN (obj_datasec(abfd
)->_raw_size
,
954 adata(abfd
).page_size
);
955 data_pad
= execp
->a_data
- obj_datasec(abfd
)->_raw_size
;
958 if (!obj_bsssec(abfd
)->user_set_vma
)
959 obj_bsssec(abfd
)->vma
= (obj_datasec(abfd
)->vma
960 + obj_datasec(abfd
)->_raw_size
);
961 /* If the BSS immediately follows the data section and extra space
962 in the page is left after the data section, fudge data
963 in the header so that the bss section looks smaller by that
964 amount. We'll start the bss section there, and lie to the OS.
965 (Note that a linker script, as well as the above assignment,
966 could have explicitly set the BSS vma to immediately follow
967 the data section.) */
968 if (align_power (obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->alignment_power
)
969 == obj_datasec(abfd
)->vma
+ obj_datasec(abfd
)->_raw_size
)
970 execp
->a_bss
= (data_pad
> obj_bsssec(abfd
)->_raw_size
) ? 0 :
971 obj_bsssec(abfd
)->_raw_size
- data_pad
;
973 execp
->a_bss
= obj_bsssec(abfd
)->_raw_size
;
977 adjust_n_magic (abfd
, execp
)
979 struct internal_exec
*execp
;
981 file_ptr pos
= adata(abfd
).exec_bytes_size
;
986 obj_textsec(abfd
)->filepos
= pos
;
987 if (!obj_textsec(abfd
)->user_set_vma
)
988 obj_textsec(abfd
)->vma
= vma
;
990 vma
= obj_textsec(abfd
)->vma
;
991 pos
+= obj_textsec(abfd
)->_raw_size
;
992 vma
+= obj_textsec(abfd
)->_raw_size
;
995 obj_datasec(abfd
)->filepos
= pos
;
996 if (!obj_datasec(abfd
)->user_set_vma
)
997 obj_datasec(abfd
)->vma
= BFD_ALIGN (vma
, adata(abfd
).segment_size
);
998 vma
= obj_datasec(abfd
)->vma
;
1000 /* Since BSS follows data immediately, see if it needs alignment. */
1001 vma
+= obj_datasec(abfd
)->_raw_size
;
1002 pad
= align_power (vma
, obj_bsssec(abfd
)->alignment_power
) - vma
;
1003 obj_datasec(abfd
)->_raw_size
+= pad
;
1004 pos
+= obj_datasec(abfd
)->_raw_size
;
1007 if (!obj_bsssec(abfd
)->user_set_vma
)
1008 obj_bsssec(abfd
)->vma
= vma
;
1010 vma
= obj_bsssec(abfd
)->vma
;
1012 /* Fix up exec header. */
1013 execp
->a_text
= obj_textsec(abfd
)->_raw_size
;
1014 execp
->a_data
= obj_datasec(abfd
)->_raw_size
;
1015 execp
->a_bss
= obj_bsssec(abfd
)->_raw_size
;
1016 N_SET_MAGIC (*execp
, NMAGIC
);
1020 NAME(aout
,adjust_sizes_and_vmas
) (abfd
, text_size
, text_end
)
1022 bfd_size_type
*text_size
;
1025 struct internal_exec
*execp
= exec_hdr (abfd
);
1027 if (! NAME(aout
,make_sections
) (abfd
))
1030 if (adata(abfd
).magic
!= undecided_magic
)
1033 obj_textsec(abfd
)->_raw_size
=
1034 align_power(obj_textsec(abfd
)->_raw_size
,
1035 obj_textsec(abfd
)->alignment_power
);
1037 *text_size
= obj_textsec (abfd
)->_raw_size
;
1038 /* Rule (heuristic) for when to pad to a new page. Note that there
1039 are (at least) two ways demand-paged (ZMAGIC) files have been
1040 handled. Most Berkeley-based systems start the text segment at
1041 (PAGE_SIZE). However, newer versions of SUNOS start the text
1042 segment right after the exec header; the latter is counted in the
1043 text segment size, and is paged in by the kernel with the rest of
1046 /* This perhaps isn't the right way to do this, but made it simpler for me
1047 to understand enough to implement it. Better would probably be to go
1048 right from BFD flags to alignment/positioning characteristics. But the
1049 old code was sloppy enough about handling the flags, and had enough
1050 other magic, that it was a little hard for me to understand. I think
1051 I understand it better now, but I haven't time to do the cleanup this
1054 if (abfd
->flags
& D_PAGED
)
1055 /* Whether or not WP_TEXT is set -- let D_PAGED override. */
1056 adata(abfd
).magic
= z_magic
;
1057 else if (abfd
->flags
& WP_TEXT
)
1058 adata(abfd
).magic
= n_magic
;
1060 adata(abfd
).magic
= o_magic
;
1062 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1064 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1066 switch (adata(abfd
).magic
) {
1067 case n_magic
: str
= "NMAGIC"; break;
1068 case o_magic
: str
= "OMAGIC"; break;
1069 case z_magic
: str
= "ZMAGIC"; break;
1074 obj_textsec(abfd
)->vma
, obj_textsec(abfd
)->_raw_size
,
1075 obj_textsec(abfd
)->alignment_power
,
1076 obj_datasec(abfd
)->vma
, obj_datasec(abfd
)->_raw_size
,
1077 obj_datasec(abfd
)->alignment_power
,
1078 obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->_raw_size
,
1079 obj_bsssec(abfd
)->alignment_power
);
1083 switch (adata(abfd
).magic
)
1086 adjust_o_magic (abfd
, execp
);
1089 adjust_z_magic (abfd
, execp
);
1092 adjust_n_magic (abfd
, execp
);
1098 #ifdef BFD_AOUT_DEBUG
1099 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1100 obj_textsec(abfd
)->vma
, obj_textsec(abfd
)->_raw_size
,
1101 obj_textsec(abfd
)->filepos
,
1102 obj_datasec(abfd
)->vma
, obj_datasec(abfd
)->_raw_size
,
1103 obj_datasec(abfd
)->filepos
,
1104 obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->_raw_size
);
1112 aout_@var{size}_new_section_hook
1115 boolean aout_@var{size}_new_section_hook,
1117 asection *newsect));
1120 Called by the BFD in response to a @code{bfd_make_section}
1124 NAME(aout
,new_section_hook
) (abfd
, newsect
)
1128 /* align to double at least */
1129 newsect
->alignment_power
= bfd_get_arch_info(abfd
)->section_align_power
;
1132 if (bfd_get_format (abfd
) == bfd_object
)
1134 if (obj_textsec(abfd
) == NULL
&& !strcmp(newsect
->name
, ".text")) {
1135 obj_textsec(abfd
)= newsect
;
1136 newsect
->target_index
= N_TEXT
;
1140 if (obj_datasec(abfd
) == NULL
&& !strcmp(newsect
->name
, ".data")) {
1141 obj_datasec(abfd
) = newsect
;
1142 newsect
->target_index
= N_DATA
;
1146 if (obj_bsssec(abfd
) == NULL
&& !strcmp(newsect
->name
, ".bss")) {
1147 obj_bsssec(abfd
) = newsect
;
1148 newsect
->target_index
= N_BSS
;
1154 /* We allow more than three sections internally */
1159 NAME(aout
,set_section_contents
) (abfd
, section
, location
, offset
, count
)
1164 bfd_size_type count
;
1167 bfd_size_type text_size
;
1169 if (abfd
->output_has_begun
== false)
1171 if (NAME(aout
,adjust_sizes_and_vmas
) (abfd
,
1173 &text_end
) == false)
1177 /* regardless, once we know what we're doing, we might as well get going */
1178 if (section
!= obj_bsssec(abfd
))
1180 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
1184 return (bfd_write ((PTR
)location
, 1, count
, abfd
) == count
) ?
1192 /* Read the external symbols from an a.out file. */
1195 aout_get_external_symbols (abfd
)
1198 if (obj_aout_external_syms (abfd
) == (struct external_nlist
*) NULL
)
1200 bfd_size_type count
;
1201 struct external_nlist
*syms
;
1203 count
= exec_hdr (abfd
)->a_syms
/ EXTERNAL_NLIST_SIZE
;
1205 /* We allocate using malloc to make the values easy to free
1206 later on. If we put them on the obstack it might not be
1207 possible to free them. */
1208 syms
= ((struct external_nlist
*)
1209 malloc ((size_t) count
* EXTERNAL_NLIST_SIZE
));
1210 if (syms
== (struct external_nlist
*) NULL
&& count
!= 0)
1212 bfd_set_error (bfd_error_no_memory
);
1216 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1217 || (bfd_read (syms
, 1, exec_hdr (abfd
)->a_syms
, abfd
)
1218 != exec_hdr (abfd
)->a_syms
))
1224 obj_aout_external_syms (abfd
) = syms
;
1225 obj_aout_external_sym_count (abfd
) = count
;
1228 if (obj_aout_external_strings (abfd
) == NULL
1229 && exec_hdr (abfd
)->a_syms
!= 0)
1231 unsigned char string_chars
[BYTES_IN_WORD
];
1232 bfd_size_type stringsize
;
1235 /* Get the size of the strings. */
1236 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
1237 || (bfd_read ((PTR
) string_chars
, BYTES_IN_WORD
, 1, abfd
)
1240 stringsize
= GET_WORD (abfd
, string_chars
);
1242 strings
= (char *) malloc ((size_t) stringsize
+ 1);
1243 if (strings
== NULL
)
1245 bfd_set_error (bfd_error_no_memory
);
1249 /* Skip space for the string count in the buffer for convenience
1250 when using indexes. */
1251 if (bfd_read (strings
+ BYTES_IN_WORD
, 1, stringsize
- BYTES_IN_WORD
,
1253 != stringsize
- BYTES_IN_WORD
)
1259 /* Ensure that a zero index yields an empty string. */
1262 /* Sanity preservation. */
1263 strings
[stringsize
] = '\0';
1265 obj_aout_external_strings (abfd
) = strings
;
1266 obj_aout_external_string_size (abfd
) = stringsize
;
1272 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1273 and symbol->value fields of CACHE_PTR will be set from the a.out
1274 nlist structure. This function is responsible for setting
1275 symbol->flags and symbol->section, and adjusting symbol->value. */
1278 translate_from_native_sym_flags (abfd
, cache_ptr
)
1280 aout_symbol_type
*cache_ptr
;
1284 if ((cache_ptr
->type
& N_STAB
) != 0
1285 || cache_ptr
->type
== N_FN
)
1289 /* This is a debugging symbol. */
1291 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1293 /* Work out the symbol section. */
1294 switch (cache_ptr
->type
& N_TYPE
)
1298 sec
= obj_textsec (abfd
);
1301 sec
= obj_datasec (abfd
);
1304 sec
= obj_bsssec (abfd
);
1308 sec
= bfd_abs_section_ptr
;
1312 cache_ptr
->symbol
.section
= sec
;
1313 cache_ptr
->symbol
.value
-= sec
->vma
;
1318 /* Get the default visibility. This does not apply to all types, so
1319 we just hold it in a local variable to use if wanted. */
1320 if ((cache_ptr
->type
& N_EXT
) == 0)
1321 visible
= BSF_LOCAL
;
1323 visible
= BSF_GLOBAL
;
1325 switch (cache_ptr
->type
)
1328 case N_ABS
: case N_ABS
| N_EXT
:
1329 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1330 cache_ptr
->symbol
.flags
= visible
;
1333 case N_UNDF
| N_EXT
:
1334 if (cache_ptr
->symbol
.value
!= 0)
1336 /* This is a common symbol. */
1337 cache_ptr
->symbol
.flags
= BSF_GLOBAL
;
1338 cache_ptr
->symbol
.section
= bfd_com_section_ptr
;
1342 cache_ptr
->symbol
.flags
= 0;
1343 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1347 case N_TEXT
: case N_TEXT
| N_EXT
:
1348 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1349 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1350 cache_ptr
->symbol
.flags
= visible
;
1353 /* N_SETV symbols used to represent set vectors placed in the
1354 data section. They are no longer generated. Theoretically,
1355 it was possible to extract the entries and combine them with
1356 new ones, although I don't know if that was ever actually
1357 done. Unless that feature is restored, treat them as data
1359 case N_SETV
: case N_SETV
| N_EXT
:
1360 case N_DATA
: case N_DATA
| N_EXT
:
1361 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1362 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1363 cache_ptr
->symbol
.flags
= visible
;
1366 case N_BSS
: case N_BSS
| N_EXT
:
1367 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1368 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1369 cache_ptr
->symbol
.flags
= visible
;
1372 case N_SETA
: case N_SETA
| N_EXT
:
1373 case N_SETT
: case N_SETT
| N_EXT
:
1374 case N_SETD
: case N_SETD
| N_EXT
:
1375 case N_SETB
: case N_SETB
| N_EXT
:
1378 arelent_chain
*reloc
;
1379 asection
*into_section
;
1381 /* This is a set symbol. The name of the symbol is the name
1382 of the set (e.g., __CTOR_LIST__). The value of the symbol
1383 is the value to add to the set. We create a section with
1384 the same name as the symbol, and add a reloc to insert the
1385 appropriate value into the section.
1387 This action is actually obsolete; it used to make the
1388 linker do the right thing, but the linker no longer uses
1391 section
= bfd_get_section_by_name (abfd
, cache_ptr
->symbol
.name
);
1392 if (section
== NULL
)
1396 copy
= bfd_alloc (abfd
, strlen (cache_ptr
->symbol
.name
) + 1);
1399 bfd_set_error (bfd_error_no_memory
);
1403 strcpy (copy
, cache_ptr
->symbol
.name
);
1404 section
= bfd_make_section (abfd
, copy
);
1405 if (section
== NULL
)
1409 reloc
= (arelent_chain
*) bfd_alloc (abfd
, sizeof (arelent_chain
));
1412 bfd_set_error (bfd_error_no_memory
);
1416 /* Build a relocation entry for the constructor. */
1417 switch (cache_ptr
->type
& N_TYPE
)
1420 into_section
= bfd_abs_section_ptr
;
1421 cache_ptr
->type
= N_ABS
;
1424 into_section
= obj_textsec (abfd
);
1425 cache_ptr
->type
= N_TEXT
;
1428 into_section
= obj_datasec (abfd
);
1429 cache_ptr
->type
= N_DATA
;
1432 into_section
= obj_bsssec (abfd
);
1433 cache_ptr
->type
= N_BSS
;
1437 /* Build a relocation pointing into the constructor section
1438 pointing at the symbol in the set vector specified. */
1439 reloc
->relent
.addend
= cache_ptr
->symbol
.value
;
1440 cache_ptr
->symbol
.section
= into_section
;
1441 reloc
->relent
.sym_ptr_ptr
= into_section
->symbol_ptr_ptr
;
1443 /* We modify the symbol to belong to a section depending upon
1444 the name of the symbol, and add to the size of the section
1445 to contain a pointer to the symbol. Build a reloc entry to
1446 relocate to this symbol attached to this section. */
1447 section
->flags
= SEC_CONSTRUCTOR
| SEC_RELOC
;
1449 section
->reloc_count
++;
1450 section
->alignment_power
= 2;
1452 reloc
->next
= section
->constructor_chain
;
1453 section
->constructor_chain
= reloc
;
1454 reloc
->relent
.address
= section
->_raw_size
;
1455 section
->_raw_size
+= BYTES_IN_WORD
;
1457 reloc
->relent
.howto
= CTOR_TABLE_RELOC_HOWTO(abfd
);
1459 cache_ptr
->symbol
.flags
|= BSF_CONSTRUCTOR
;
1464 /* This symbol is the text of a warning message. The next
1465 symbol is the symbol to associate the warning with. If a
1466 reference is made to that symbol, a warning is issued. */
1467 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
| BSF_WARNING
;
1469 /* @@ Stuffing pointers into integers is a no-no. We can
1470 usually get away with it if the integer is large enough
1472 if (sizeof (cache_ptr
+ 1) > sizeof (bfd_vma
))
1474 cache_ptr
->symbol
.value
= (bfd_vma
) (cache_ptr
+ 1);
1476 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1480 case N_INDR
: case N_INDR
| N_EXT
:
1481 /* An indirect symbol. This consists of two symbols in a row.
1482 The first symbol is the name of the indirection. The second
1483 symbol is the name of the target. A reference to the first
1484 symbol becomes a reference to the second. */
1485 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
| BSF_INDIRECT
| visible
;
1487 /* @@ Stuffing pointers into integers is a no-no. We can
1488 usually get away with it if the integer is large enough
1490 if (sizeof (cache_ptr
+ 1) > sizeof (bfd_vma
))
1492 cache_ptr
->symbol
.value
= (bfd_vma
) (cache_ptr
+ 1);
1494 cache_ptr
->symbol
.section
= bfd_ind_section_ptr
;
1499 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1500 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1504 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1505 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1509 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1510 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1511 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1515 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1516 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1517 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1521 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1522 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1523 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1530 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1533 translate_to_native_sym_flags (abfd
, cache_ptr
, sym_pointer
)
1536 struct external_nlist
*sym_pointer
;
1538 bfd_vma value
= cache_ptr
->value
;
1540 /* Mask out any existing type bits in case copying from one section
1542 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1544 if (bfd_is_abs_section (bfd_get_section (cache_ptr
)))
1545 sym_pointer
->e_type
[0] |= N_ABS
;
1546 else if (bfd_get_section (cache_ptr
) == obj_textsec (abfd
)
1547 || (bfd_get_section (cache_ptr
)->output_section
1548 == obj_textsec (abfd
)))
1549 sym_pointer
->e_type
[0] |= N_TEXT
;
1550 else if (bfd_get_section (cache_ptr
) == obj_datasec (abfd
)
1551 || (bfd_get_section (cache_ptr
)->output_section
1552 == obj_datasec (abfd
)))
1553 sym_pointer
->e_type
[0] |= N_DATA
;
1554 else if (bfd_get_section (cache_ptr
) == obj_bsssec (abfd
)
1555 || (bfd_get_section (cache_ptr
)->output_section
1556 == obj_bsssec (abfd
)))
1557 sym_pointer
->e_type
[0] |= N_BSS
;
1558 else if (bfd_get_section (cache_ptr
) == NULL
)
1560 /* Protect the bfd_is_com_section call. This case occurs, e.g.,
1561 for the *DEBUG* section of a COFF file. */
1562 bfd_set_error (bfd_error_nonrepresentable_section
);
1565 else if (bfd_is_und_section (bfd_get_section (cache_ptr
)))
1566 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1567 else if (bfd_is_ind_section (bfd_get_section (cache_ptr
)))
1568 sym_pointer
->e_type
[0] = N_INDR
;
1569 else if (bfd_is_com_section (bfd_get_section (cache_ptr
)))
1570 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1573 bfd_set_error (bfd_error_nonrepresentable_section
);
1577 /* Turn the symbol from section relative to absolute again */
1578 if (cache_ptr
->section
->output_section
!= NULL
)
1579 value
+= (cache_ptr
->section
->output_section
->vma
1580 + cache_ptr
->section
->output_offset
);
1582 value
+= cache_ptr
->section
->vma
;
1584 if ((cache_ptr
->flags
& BSF_WARNING
) != 0)
1585 sym_pointer
->e_type
[0] = N_WARNING
;
1587 if ((cache_ptr
->flags
& BSF_DEBUGGING
) != 0)
1588 sym_pointer
->e_type
[0] = ((aout_symbol_type
*) cache_ptr
)->type
;
1589 else if ((cache_ptr
->flags
& BSF_GLOBAL
) != 0)
1590 sym_pointer
->e_type
[0] |= N_EXT
;
1592 if ((cache_ptr
->flags
& BSF_CONSTRUCTOR
) != 0)
1594 int type
= ((aout_symbol_type
*) cache_ptr
)->type
;
1597 case N_ABS
: type
= N_SETA
; break;
1598 case N_TEXT
: type
= N_SETT
; break;
1599 case N_DATA
: type
= N_SETD
; break;
1600 case N_BSS
: type
= N_SETB
; break;
1602 sym_pointer
->e_type
[0] = type
;
1605 if ((cache_ptr
->flags
& BSF_WEAK
) != 0)
1609 switch (sym_pointer
->e_type
[0] & N_TYPE
)
1612 case N_ABS
: type
= N_WEAKA
; break;
1613 case N_TEXT
: type
= N_WEAKT
; break;
1614 case N_DATA
: type
= N_WEAKD
; break;
1615 case N_BSS
: type
= N_WEAKB
; break;
1616 case N_UNDF
: type
= N_WEAKU
; break;
1618 sym_pointer
->e_type
[0] = type
;
1621 PUT_WORD(abfd
, value
, sym_pointer
->e_value
);
1626 /* Native-level interface to symbols. */
1629 NAME(aout
,make_empty_symbol
) (abfd
)
1632 aout_symbol_type
*new =
1633 (aout_symbol_type
*)bfd_zalloc (abfd
, sizeof (aout_symbol_type
));
1636 bfd_set_error (bfd_error_no_memory
);
1639 new->symbol
.the_bfd
= abfd
;
1641 return &new->symbol
;
1644 /* Translate a set of internal symbols into external symbols. */
1647 NAME(aout
,translate_symbol_table
) (abfd
, in
, ext
, count
, str
, strsize
, dynamic
)
1649 aout_symbol_type
*in
;
1650 struct external_nlist
*ext
;
1651 bfd_size_type count
;
1653 bfd_size_type strsize
;
1656 struct external_nlist
*ext_end
;
1658 ext_end
= ext
+ count
;
1659 for (; ext
< ext_end
; ext
++, in
++)
1663 x
= GET_WORD (abfd
, ext
->e_strx
);
1664 in
->symbol
.the_bfd
= abfd
;
1666 /* For the normal symbols, the zero index points at the number
1667 of bytes in the string table but is to be interpreted as the
1668 null string. For the dynamic symbols, the number of bytes in
1669 the string table is stored in the __DYNAMIC structure and the
1670 zero index points at an actual string. */
1671 if (x
== 0 && ! dynamic
)
1672 in
->symbol
.name
= "";
1673 else if (x
< strsize
)
1674 in
->symbol
.name
= str
+ x
;
1678 in
->symbol
.value
= GET_SWORD (abfd
, ext
->e_value
);
1679 in
->desc
= bfd_h_get_16 (abfd
, ext
->e_desc
);
1680 in
->other
= bfd_h_get_8 (abfd
, ext
->e_other
);
1681 in
->type
= bfd_h_get_8 (abfd
, ext
->e_type
);
1682 in
->symbol
.udata
.p
= NULL
;
1684 if (! translate_from_native_sym_flags (abfd
, in
))
1688 in
->symbol
.flags
|= BSF_DYNAMIC
;
1694 /* We read the symbols into a buffer, which is discarded when this
1695 function exits. We read the strings into a buffer large enough to
1696 hold them all plus all the cached symbol entries. */
1699 NAME(aout
,slurp_symbol_table
) (abfd
)
1702 struct external_nlist
*old_external_syms
;
1703 aout_symbol_type
*cached
;
1706 /* If there's no work to be done, don't do any */
1707 if (obj_aout_symbols (abfd
) != (aout_symbol_type
*) NULL
)
1710 old_external_syms
= obj_aout_external_syms (abfd
);
1712 if (! aout_get_external_symbols (abfd
))
1715 cached_size
= (obj_aout_external_sym_count (abfd
)
1716 * sizeof (aout_symbol_type
));
1717 cached
= (aout_symbol_type
*) malloc (cached_size
);
1718 if (cached
== NULL
&& cached_size
!= 0)
1720 bfd_set_error (bfd_error_no_memory
);
1723 if (cached_size
!= 0)
1724 memset (cached
, 0, cached_size
);
1726 /* Convert from external symbol information to internal. */
1727 if (! (NAME(aout
,translate_symbol_table
)
1729 obj_aout_external_syms (abfd
),
1730 obj_aout_external_sym_count (abfd
),
1731 obj_aout_external_strings (abfd
),
1732 obj_aout_external_string_size (abfd
),
1739 bfd_get_symcount (abfd
) = obj_aout_external_sym_count (abfd
);
1741 obj_aout_symbols (abfd
) = cached
;
1743 /* It is very likely that anybody who calls this function will not
1744 want the external symbol information, so if it was allocated
1745 because of our call to aout_get_external_symbols, we free it up
1746 right away to save space. */
1747 if (old_external_syms
== (struct external_nlist
*) NULL
1748 && obj_aout_external_syms (abfd
) != (struct external_nlist
*) NULL
)
1750 free (obj_aout_external_syms (abfd
));
1751 obj_aout_external_syms (abfd
) = NULL
;
1757 /* We use a hash table when writing out symbols so that we only write
1758 out a particular string once. This helps particularly when the
1759 linker writes out stabs debugging entries, because each different
1760 contributing object file tends to have many duplicate stabs
1763 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1764 if BFD_TRADITIONAL_FORMAT is set. */
1766 static bfd_size_type add_to_stringtab
1767 PARAMS ((bfd
*, struct bfd_strtab_hash
*, const char *, boolean
));
1768 static boolean emit_stringtab
PARAMS ((bfd
*, struct bfd_strtab_hash
*));
1770 /* Get the index of a string in a strtab, adding it if it is not
1773 static INLINE bfd_size_type
1774 add_to_stringtab (abfd
, tab
, str
, copy
)
1776 struct bfd_strtab_hash
*tab
;
1781 bfd_size_type index
;
1783 /* An index of 0 always means the empty string. */
1784 if (str
== 0 || *str
== '\0')
1787 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1788 doesn't understand a hashed string table. */
1790 if ((abfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1793 index
= _bfd_stringtab_add (tab
, str
, hash
, copy
);
1795 if (index
!= (bfd_size_type
) -1)
1797 /* Add BYTES_IN_WORD to the return value to account for the
1798 space taken up by the string table size. */
1799 index
+= BYTES_IN_WORD
;
1805 /* Write out a strtab. ABFD is already at the right location in the
1809 emit_stringtab (abfd
, tab
)
1811 struct bfd_strtab_hash
*tab
;
1813 bfd_byte buffer
[BYTES_IN_WORD
];
1815 /* The string table starts with the size. */
1816 PUT_WORD (abfd
, _bfd_stringtab_size (tab
) + BYTES_IN_WORD
, buffer
);
1817 if (bfd_write ((PTR
) buffer
, 1, BYTES_IN_WORD
, abfd
) != BYTES_IN_WORD
)
1820 return _bfd_stringtab_emit (abfd
, tab
);
1824 NAME(aout
,write_syms
) (abfd
)
1827 unsigned int count
;
1828 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1829 struct bfd_strtab_hash
*strtab
;
1831 strtab
= _bfd_stringtab_init ();
1835 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1837 asymbol
*g
= generic
[count
];
1839 struct external_nlist nsp
;
1841 indx
= add_to_stringtab (abfd
, strtab
, g
->name
, false);
1842 if (indx
== (bfd_size_type
) -1)
1844 PUT_WORD (abfd
, indx
, (bfd_byte
*) nsp
.e_strx
);
1846 if (bfd_asymbol_flavour(g
) == abfd
->xvec
->flavour
)
1848 bfd_h_put_16(abfd
, aout_symbol(g
)->desc
, nsp
.e_desc
);
1849 bfd_h_put_8(abfd
, aout_symbol(g
)->other
, nsp
.e_other
);
1850 bfd_h_put_8(abfd
, aout_symbol(g
)->type
, nsp
.e_type
);
1854 bfd_h_put_16(abfd
,0, nsp
.e_desc
);
1855 bfd_h_put_8(abfd
, 0, nsp
.e_other
);
1856 bfd_h_put_8(abfd
, 0, nsp
.e_type
);
1859 if (! translate_to_native_sym_flags (abfd
, g
, &nsp
))
1862 if (bfd_write((PTR
)&nsp
,1,EXTERNAL_NLIST_SIZE
, abfd
)
1863 != EXTERNAL_NLIST_SIZE
)
1866 /* NB: `KEEPIT' currently overlays `flags', so set this only
1867 here, at the end. */
1871 if (! emit_stringtab (abfd
, strtab
))
1874 _bfd_stringtab_free (strtab
);
1879 _bfd_stringtab_free (strtab
);
1885 NAME(aout
,get_symtab
) (abfd
, location
)
1889 unsigned int counter
= 0;
1890 aout_symbol_type
*symbase
;
1892 if (!NAME(aout
,slurp_symbol_table
)(abfd
))
1895 for (symbase
= obj_aout_symbols(abfd
); counter
++ < bfd_get_symcount (abfd
);)
1896 *(location
++) = (asymbol
*)( symbase
++);
1898 return bfd_get_symcount (abfd
);
1902 /* Standard reloc stuff */
1903 /* Output standard relocation information to a file in target byte order. */
1906 NAME(aout
,swap_std_reloc_out
) (abfd
, g
, natptr
)
1909 struct reloc_std_external
*natptr
;
1912 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1914 unsigned int r_length
;
1916 int r_baserel
, r_jmptable
, r_relative
;
1917 asection
*output_section
= sym
->section
->output_section
;
1919 PUT_WORD(abfd
, g
->address
, natptr
->r_address
);
1921 r_length
= g
->howto
->size
; /* Size as a power of two */
1922 r_pcrel
= (int) g
->howto
->pc_relative
; /* Relative to PC? */
1923 /* XXX This relies on relocs coming from a.out files. */
1924 r_baserel
= (g
->howto
->type
& 8) != 0;
1925 r_jmptable
= (g
->howto
->type
& 16) != 0;
1926 r_relative
= (g
->howto
->type
& 32) != 0;
1929 /* For a standard reloc, the addend is in the object file. */
1930 r_addend
= g
->addend
+ (*(g
->sym_ptr_ptr
))->section
->output_section
->vma
;
1933 /* name was clobbered by aout_write_syms to be symbol index */
1935 /* If this relocation is relative to a symbol then set the
1936 r_index to the symbols index, and the r_extern bit.
1938 Absolute symbols can come in in two ways, either as an offset
1939 from the abs section, or as a symbol which has an abs value.
1944 if (bfd_is_com_section (output_section
)
1945 || bfd_is_abs_section (output_section
)
1946 || bfd_is_und_section (output_section
))
1948 if (bfd_abs_section_ptr
->symbol
== sym
)
1950 /* Whoops, looked like an abs symbol, but is really an offset
1951 from the abs section */
1957 /* Fill in symbol */
1959 r_index
= stoi((*(g
->sym_ptr_ptr
))->KEEPIT
);
1965 /* Just an ordinary section */
1967 r_index
= output_section
->target_index
;
1970 /* now the fun stuff */
1971 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
1972 natptr
->r_index
[0] = r_index
>> 16;
1973 natptr
->r_index
[1] = r_index
>> 8;
1974 natptr
->r_index
[2] = r_index
;
1976 (r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
1977 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
1978 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
1979 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
1980 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
1981 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
);
1983 natptr
->r_index
[2] = r_index
>> 16;
1984 natptr
->r_index
[1] = r_index
>> 8;
1985 natptr
->r_index
[0] = r_index
;
1987 (r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
1988 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
1989 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
1990 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
1991 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
1992 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
);
1997 /* Extended stuff */
1998 /* Output extended relocation information to a file in target byte order. */
2001 NAME(aout
,swap_ext_reloc_out
) (abfd
, g
, natptr
)
2004 register struct reloc_ext_external
*natptr
;
2008 unsigned int r_type
;
2009 unsigned int r_addend
;
2010 asymbol
*sym
= *(g
->sym_ptr_ptr
);
2011 asection
*output_section
= sym
->section
->output_section
;
2013 PUT_WORD (abfd
, g
->address
, natptr
->r_address
);
2015 r_type
= (unsigned int) g
->howto
->type
;
2017 r_addend
= g
->addend
+ (*(g
->sym_ptr_ptr
))->section
->output_section
->vma
;
2019 /* If this relocation is relative to a symbol then set the
2020 r_index to the symbols index, and the r_extern bit.
2022 Absolute symbols can come in in two ways, either as an offset
2023 from the abs section, or as a symbol which has an abs value.
2024 check for that here. */
2026 if (bfd_is_com_section (output_section
)
2027 || bfd_is_abs_section (output_section
)
2028 || bfd_is_und_section (output_section
))
2030 if (bfd_abs_section_ptr
->symbol
== sym
)
2032 /* Whoops, looked like an abs symbol, but is really an offset
2033 from the abs section */
2040 r_index
= stoi((*(g
->sym_ptr_ptr
))->KEEPIT
);
2045 /* Just an ordinary section */
2047 r_index
= output_section
->target_index
;
2050 /* now the fun stuff */
2051 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
2052 natptr
->r_index
[0] = r_index
>> 16;
2053 natptr
->r_index
[1] = r_index
>> 8;
2054 natptr
->r_index
[2] = r_index
;
2056 ((r_extern
? RELOC_EXT_BITS_EXTERN_BIG
: 0)
2057 | (r_type
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
2059 natptr
->r_index
[2] = r_index
>> 16;
2060 natptr
->r_index
[1] = r_index
>> 8;
2061 natptr
->r_index
[0] = r_index
;
2063 (r_extern
? RELOC_EXT_BITS_EXTERN_LITTLE
: 0)
2064 | (r_type
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
);
2067 PUT_WORD (abfd
, r_addend
, natptr
->r_addend
);
2070 /* BFD deals internally with all things based from the section they're
2071 in. so, something in 10 bytes into a text section with a base of
2072 50 would have a symbol (.text+10) and know .text vma was 50.
2074 Aout keeps all it's symbols based from zero, so the symbol would
2075 contain 60. This macro subs the base of each section from the value
2076 to give the true offset from the section */
2079 #define MOVE_ADDRESS(ad) \
2081 /* undefined symbol */ \
2082 cache_ptr->sym_ptr_ptr = symbols + r_index; \
2083 cache_ptr->addend = ad; \
2085 /* defined, section relative. replace symbol with pointer to \
2086 symbol which points to section */ \
2087 switch (r_index) { \
2089 case N_TEXT | N_EXT: \
2090 cache_ptr->sym_ptr_ptr = obj_textsec(abfd)->symbol_ptr_ptr; \
2091 cache_ptr->addend = ad - su->textsec->vma; \
2094 case N_DATA | N_EXT: \
2095 cache_ptr->sym_ptr_ptr = obj_datasec(abfd)->symbol_ptr_ptr; \
2096 cache_ptr->addend = ad - su->datasec->vma; \
2099 case N_BSS | N_EXT: \
2100 cache_ptr->sym_ptr_ptr = obj_bsssec(abfd)->symbol_ptr_ptr; \
2101 cache_ptr->addend = ad - su->bsssec->vma; \
2105 case N_ABS | N_EXT: \
2106 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
2107 cache_ptr->addend = ad; \
2113 NAME(aout
,swap_ext_reloc_in
) (abfd
, bytes
, cache_ptr
, symbols
)
2115 struct reloc_ext_external
*bytes
;
2121 unsigned int r_type
;
2122 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
2124 cache_ptr
->address
= (GET_SWORD (abfd
, bytes
->r_address
));
2126 /* now the fun stuff */
2127 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
2128 r_index
= (bytes
->r_index
[0] << 16)
2129 | (bytes
->r_index
[1] << 8)
2130 | bytes
->r_index
[2];
2131 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
2132 r_type
= (bytes
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
2133 >> RELOC_EXT_BITS_TYPE_SH_BIG
;
2135 r_index
= (bytes
->r_index
[2] << 16)
2136 | (bytes
->r_index
[1] << 8)
2137 | bytes
->r_index
[0];
2138 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
2139 r_type
= (bytes
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
2140 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
;
2143 cache_ptr
->howto
= howto_table_ext
+ r_type
;
2144 MOVE_ADDRESS(GET_SWORD(abfd
, bytes
->r_addend
));
2148 NAME(aout
,swap_std_reloc_in
) (abfd
, bytes
, cache_ptr
, symbols
)
2150 struct reloc_std_external
*bytes
;
2156 unsigned int r_length
;
2158 int r_baserel
, r_jmptable
, r_relative
;
2159 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
2162 cache_ptr
->address
= bfd_h_get_32 (abfd
, bytes
->r_address
);
2164 /* now the fun stuff */
2165 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
2166 r_index
= (bytes
->r_index
[0] << 16)
2167 | (bytes
->r_index
[1] << 8)
2168 | bytes
->r_index
[2];
2169 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
));
2170 r_pcrel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_PCREL_BIG
));
2171 r_baserel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
2172 r_jmptable
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
2173 r_relative
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_RELATIVE_BIG
));
2174 r_length
= (bytes
->r_type
[0] & RELOC_STD_BITS_LENGTH_BIG
)
2175 >> RELOC_STD_BITS_LENGTH_SH_BIG
;
2177 r_index
= (bytes
->r_index
[2] << 16)
2178 | (bytes
->r_index
[1] << 8)
2179 | bytes
->r_index
[0];
2180 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
));
2181 r_pcrel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_PCREL_LITTLE
));
2182 r_baserel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_BASEREL_LITTLE
));
2183 r_jmptable
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_LITTLE
));
2184 r_relative
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_RELATIVE_LITTLE
));
2185 r_length
= (bytes
->r_type
[0] & RELOC_STD_BITS_LENGTH_LITTLE
)
2186 >> RELOC_STD_BITS_LENGTH_SH_LITTLE
;
2189 howto_idx
= r_length
+ 4 * r_pcrel
+ 8 * r_baserel
2190 + 16 * r_jmptable
+ 32 * r_relative
;
2191 BFD_ASSERT (howto_idx
< TABLE_SIZE (howto_table_std
));
2192 cache_ptr
->howto
= howto_table_std
+ howto_idx
;
2193 BFD_ASSERT (cache_ptr
->howto
->type
!= -1);
2198 /* Read and swap the relocs for a section. */
2201 NAME(aout
,slurp_reloc_table
) (abfd
, asect
, symbols
)
2207 bfd_size_type reloc_size
;
2209 arelent
*reloc_cache
;
2211 unsigned int counter
= 0;
2214 if (asect
->relocation
)
2217 if (asect
->flags
& SEC_CONSTRUCTOR
)
2220 if (asect
== obj_datasec (abfd
))
2221 reloc_size
= exec_hdr(abfd
)->a_drsize
;
2222 else if (asect
== obj_textsec (abfd
))
2223 reloc_size
= exec_hdr(abfd
)->a_trsize
;
2224 else if (asect
== obj_bsssec (abfd
))
2228 bfd_set_error (bfd_error_invalid_operation
);
2232 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
2235 each_size
= obj_reloc_entry_size (abfd
);
2237 count
= reloc_size
/ each_size
;
2239 reloc_cache
= (arelent
*) malloc ((size_t) (count
* sizeof (arelent
)));
2240 if (reloc_cache
== NULL
&& count
!= 0)
2242 bfd_set_error (bfd_error_no_memory
);
2245 memset (reloc_cache
, 0, count
* sizeof (arelent
));
2247 relocs
= malloc (reloc_size
);
2248 if (relocs
== NULL
&& reloc_size
!= 0)
2251 bfd_set_error (bfd_error_no_memory
);
2255 if (bfd_read (relocs
, 1, reloc_size
, abfd
) != reloc_size
)
2262 cache_ptr
= reloc_cache
;
2263 if (each_size
== RELOC_EXT_SIZE
)
2265 register struct reloc_ext_external
*rptr
=
2266 (struct reloc_ext_external
*) relocs
;
2268 for (; counter
< count
; counter
++, rptr
++, cache_ptr
++)
2269 NAME(aout
,swap_ext_reloc_in
) (abfd
, rptr
, cache_ptr
, symbols
);
2273 register struct reloc_std_external
*rptr
=
2274 (struct reloc_std_external
*) relocs
;
2276 for (; counter
< count
; counter
++, rptr
++, cache_ptr
++)
2277 MY_swap_std_reloc_in(abfd
, rptr
, cache_ptr
, symbols
);
2282 asect
->relocation
= reloc_cache
;
2283 asect
->reloc_count
= cache_ptr
- reloc_cache
;
2288 /* Write out a relocation section into an object file. */
2291 NAME(aout
,squirt_out_relocs
) (abfd
, section
)
2296 unsigned char *native
, *natptr
;
2299 unsigned int count
= section
->reloc_count
;
2302 if (count
== 0) return true;
2304 each_size
= obj_reloc_entry_size (abfd
);
2305 natsize
= each_size
* count
;
2306 native
= (unsigned char *) bfd_zalloc (abfd
, natsize
);
2308 bfd_set_error (bfd_error_no_memory
);
2312 generic
= section
->orelocation
;
2314 if (each_size
== RELOC_EXT_SIZE
)
2316 for (natptr
= native
;
2318 --count
, natptr
+= each_size
, ++generic
)
2319 NAME(aout
,swap_ext_reloc_out
) (abfd
, *generic
, (struct reloc_ext_external
*)natptr
);
2323 for (natptr
= native
;
2325 --count
, natptr
+= each_size
, ++generic
)
2326 MY_swap_std_reloc_out(abfd
, *generic
, (struct reloc_std_external
*)natptr
);
2329 if ( bfd_write ((PTR
) native
, 1, natsize
, abfd
) != natsize
) {
2330 bfd_release(abfd
, native
);
2333 bfd_release (abfd
, native
);
2338 /* This is stupid. This function should be a boolean predicate */
2340 NAME(aout
,canonicalize_reloc
) (abfd
, section
, relptr
, symbols
)
2346 arelent
*tblptr
= section
->relocation
;
2349 if (section
== obj_bsssec (abfd
))
2355 if (!(tblptr
|| NAME(aout
,slurp_reloc_table
)(abfd
, section
, symbols
)))
2358 if (section
->flags
& SEC_CONSTRUCTOR
) {
2359 arelent_chain
*chain
= section
->constructor_chain
;
2360 for (count
= 0; count
< section
->reloc_count
; count
++) {
2361 *relptr
++ = &chain
->relent
;
2362 chain
= chain
->next
;
2366 tblptr
= section
->relocation
;
2368 for (count
= 0; count
++ < section
->reloc_count
;)
2370 *relptr
++ = tblptr
++;
2375 return section
->reloc_count
;
2379 NAME(aout
,get_reloc_upper_bound
) (abfd
, asect
)
2383 if (bfd_get_format (abfd
) != bfd_object
) {
2384 bfd_set_error (bfd_error_invalid_operation
);
2387 if (asect
->flags
& SEC_CONSTRUCTOR
) {
2388 return (sizeof (arelent
*) * (asect
->reloc_count
+1));
2391 if (asect
== obj_datasec (abfd
))
2392 return (sizeof (arelent
*)
2393 * ((exec_hdr(abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
))
2396 if (asect
== obj_textsec (abfd
))
2397 return (sizeof (arelent
*)
2398 * ((exec_hdr(abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
))
2401 if (asect
== obj_bsssec (abfd
))
2402 return sizeof (arelent
*);
2404 if (asect
== obj_bsssec (abfd
))
2407 bfd_set_error (bfd_error_invalid_operation
);
2413 NAME(aout
,get_symtab_upper_bound
) (abfd
)
2416 if (!NAME(aout
,slurp_symbol_table
)(abfd
))
2419 return (bfd_get_symcount (abfd
)+1) * (sizeof (aout_symbol_type
*));
2424 NAME(aout
,get_lineno
) (ignore_abfd
, ignore_symbol
)
2426 asymbol
*ignore_symbol
;
2428 return (alent
*)NULL
;
2433 NAME(aout
,get_symbol_info
) (ignore_abfd
, symbol
, ret
)
2438 bfd_symbol_info (symbol
, ret
);
2440 if (ret
->type
== '?')
2442 int type_code
= aout_symbol(symbol
)->type
& 0xff;
2443 CONST
char *stab_name
= aout_stab_name(type_code
);
2444 static char buf
[10];
2446 if (stab_name
== NULL
)
2448 sprintf(buf
, "(%d)", type_code
);
2452 ret
->stab_other
= (unsigned)(aout_symbol(symbol
)->other
& 0xff);
2453 ret
->stab_desc
= (unsigned)(aout_symbol(symbol
)->desc
& 0xffff);
2454 ret
->stab_name
= stab_name
;
2460 NAME(aout
,print_symbol
) (ignore_abfd
, afile
, symbol
, how
)
2464 bfd_print_symbol_type how
;
2466 FILE *file
= (FILE *)afile
;
2469 case bfd_print_symbol_name
:
2471 fprintf(file
,"%s", symbol
->name
);
2473 case bfd_print_symbol_more
:
2474 fprintf(file
,"%4x %2x %2x",(unsigned)(aout_symbol(symbol
)->desc
& 0xffff),
2475 (unsigned)(aout_symbol(symbol
)->other
& 0xff),
2476 (unsigned)(aout_symbol(symbol
)->type
));
2478 case bfd_print_symbol_all
:
2480 CONST
char *section_name
= symbol
->section
->name
;
2483 bfd_print_symbol_vandf((PTR
)file
,symbol
);
2485 fprintf(file
," %-5s %04x %02x %02x",
2487 (unsigned)(aout_symbol(symbol
)->desc
& 0xffff),
2488 (unsigned)(aout_symbol(symbol
)->other
& 0xff),
2489 (unsigned)(aout_symbol(symbol
)->type
& 0xff));
2491 fprintf(file
," %s", symbol
->name
);
2498 provided a BFD, a section and an offset into the section, calculate
2499 and return the name of the source file and the line nearest to the
2504 NAME(aout
,find_nearest_line
)
2505 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2510 CONST
char **filename_ptr
;
2511 CONST
char **functionname_ptr
;
2512 unsigned int *line_ptr
;
2514 /* Run down the file looking for the filename, function and linenumber */
2516 static char buffer
[100];
2517 static char filename_buffer
[200];
2518 CONST
char *directory_name
= NULL
;
2519 CONST
char *main_file_name
= NULL
;
2520 CONST
char *current_file_name
= NULL
;
2521 CONST
char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2522 bfd_vma high_line_vma
= ~0;
2523 bfd_vma low_func_vma
= 0;
2525 *filename_ptr
= abfd
->filename
;
2526 *functionname_ptr
= 0;
2528 if (symbols
!= (asymbol
**)NULL
) {
2529 for (p
= symbols
; *p
; p
++) {
2530 aout_symbol_type
*q
= (aout_symbol_type
*)(*p
);
2534 main_file_name
= current_file_name
= q
->symbol
.name
;
2535 /* Look ahead to next symbol to check if that too is an N_SO. */
2539 q
= (aout_symbol_type
*)(*p
);
2540 if (q
->type
!= (int)N_SO
)
2543 /* Found a second N_SO First is directory; second is filename. */
2544 directory_name
= current_file_name
;
2545 main_file_name
= current_file_name
= q
->symbol
.name
;
2546 if (obj_textsec(abfd
) != section
)
2550 current_file_name
= q
->symbol
.name
;
2557 /* We'll keep this if it resolves nearer than the one we have already */
2558 if (q
->symbol
.value
>= offset
&&
2559 q
->symbol
.value
< high_line_vma
) {
2560 *line_ptr
= q
->desc
;
2561 high_line_vma
= q
->symbol
.value
;
2562 line_file_name
= current_file_name
;
2567 /* We'll keep this if it is nearer than the one we have already */
2568 if (q
->symbol
.value
>= low_func_vma
&&
2569 q
->symbol
.value
<= offset
) {
2570 low_func_vma
= q
->symbol
.value
;
2571 func
= (asymbol
*)q
;
2573 if (*line_ptr
&& func
) {
2574 CONST
char *function
= func
->name
;
2577 /* The caller expects a symbol name. We actually have a
2578 function name, without the leading underscore. Put the
2579 underscore back in, so that the caller gets a symbol
2581 if (bfd_get_symbol_leading_char (abfd
) == '\0')
2582 strncpy (buffer
, function
, sizeof (buffer
) - 1);
2585 buffer
[0] = bfd_get_symbol_leading_char (abfd
);
2586 strncpy (buffer
+ 1, function
, sizeof (buffer
) - 2);
2588 buffer
[sizeof(buffer
)-1] = 0;
2589 /* Have to remove : stuff */
2590 p
= strchr(buffer
,':');
2591 if (p
!= NULL
) { *p
= '\0'; }
2592 *functionname_ptr
= buffer
;
2604 main_file_name
= line_file_name
;
2605 if (main_file_name
) {
2606 if (main_file_name
[0] == '/' || directory_name
== NULL
)
2607 *filename_ptr
= main_file_name
;
2609 sprintf(filename_buffer
, "%.140s%.50s",
2610 directory_name
, main_file_name
);
2611 *filename_ptr
= filename_buffer
;
2620 NAME(aout
,sizeof_headers
) (abfd
, execable
)
2624 return adata(abfd
).exec_bytes_size
;
2627 /* Free all information we have cached for this BFD. We can always
2628 read it again later if we need it. */
2631 NAME(aout
,bfd_free_cached_info
) (abfd
)
2636 if (bfd_get_format (abfd
) != bfd_object
)
2639 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2640 BFCI_FREE (obj_aout_symbols (abfd
));
2641 BFCI_FREE (obj_aout_external_syms (abfd
));
2642 BFCI_FREE (obj_aout_external_strings (abfd
));
2643 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
2644 BFCI_FREE (o
->relocation
);
2650 /* a.out link code. */
2652 static boolean aout_link_add_object_symbols
2653 PARAMS ((bfd
*, struct bfd_link_info
*));
2654 static boolean aout_link_check_archive_element
2655 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*));
2656 static boolean aout_link_free_symbols
PARAMS ((bfd
*));
2657 static boolean aout_link_check_ar_symbols
2658 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*pneeded
));
2659 static boolean aout_link_add_symbols
2660 PARAMS ((bfd
*, struct bfd_link_info
*));
2662 /* Routine to create an entry in an a.out link hash table. */
2664 struct bfd_hash_entry
*
2665 NAME(aout
,link_hash_newfunc
) (entry
, table
, string
)
2666 struct bfd_hash_entry
*entry
;
2667 struct bfd_hash_table
*table
;
2670 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2672 /* Allocate the structure if it has not already been allocated by a
2674 if (ret
== (struct aout_link_hash_entry
*) NULL
)
2675 ret
= ((struct aout_link_hash_entry
*)
2676 bfd_hash_allocate (table
, sizeof (struct aout_link_hash_entry
)));
2677 if (ret
== (struct aout_link_hash_entry
*) NULL
)
2679 bfd_set_error (bfd_error_no_memory
);
2680 return (struct bfd_hash_entry
*) ret
;
2683 /* Call the allocation method of the superclass. */
2684 ret
= ((struct aout_link_hash_entry
*)
2685 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2689 /* Set local fields. */
2690 ret
->written
= false;
2694 return (struct bfd_hash_entry
*) ret
;
2697 /* Initialize an a.out link hash table. */
2700 NAME(aout
,link_hash_table_init
) (table
, abfd
, newfunc
)
2701 struct aout_link_hash_table
*table
;
2703 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
2704 struct bfd_hash_table
*,
2707 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
2710 /* Create an a.out link hash table. */
2712 struct bfd_link_hash_table
*
2713 NAME(aout
,link_hash_table_create
) (abfd
)
2716 struct aout_link_hash_table
*ret
;
2718 ret
= ((struct aout_link_hash_table
*)
2719 malloc (sizeof (struct aout_link_hash_table
)));
2720 if (ret
== (struct aout_link_hash_table
*) NULL
)
2722 bfd_set_error (bfd_error_no_memory
);
2723 return (struct bfd_link_hash_table
*) NULL
;
2725 if (! NAME(aout
,link_hash_table_init
) (ret
, abfd
,
2726 NAME(aout
,link_hash_newfunc
)))
2729 return (struct bfd_link_hash_table
*) NULL
;
2734 /* Given an a.out BFD, add symbols to the global hash table as
2738 NAME(aout
,link_add_symbols
) (abfd
, info
)
2740 struct bfd_link_info
*info
;
2744 switch (bfd_get_format (abfd
))
2747 return aout_link_add_object_symbols (abfd
, info
);
2749 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
2752 if (! bfd_check_format (first
, bfd_object
))
2754 if (bfd_get_flavour (first
) != bfd_target_aout_flavour
)
2756 /* On Linux, we may have an ELF archive which got recognized
2757 as an a.out archive. Therefore, we treat all archives as
2758 though they were actually of the flavour of their first
2760 return (*first
->xvec
->_bfd_link_add_symbols
) (abfd
, info
);
2762 return _bfd_generic_link_add_archive_symbols
2763 (abfd
, info
, aout_link_check_archive_element
);
2765 bfd_set_error (bfd_error_wrong_format
);
2770 /* Add symbols from an a.out object file. */
2773 aout_link_add_object_symbols (abfd
, info
)
2775 struct bfd_link_info
*info
;
2777 if (! aout_get_external_symbols (abfd
))
2779 if (! aout_link_add_symbols (abfd
, info
))
2781 if (! info
->keep_memory
)
2783 if (! aout_link_free_symbols (abfd
))
2789 /* Check a single archive element to see if we need to include it in
2790 the link. *PNEEDED is set according to whether this element is
2791 needed in the link or not. This is called from
2792 _bfd_generic_link_add_archive_symbols. */
2795 aout_link_check_archive_element (abfd
, info
, pneeded
)
2797 struct bfd_link_info
*info
;
2800 if (! aout_get_external_symbols (abfd
))
2803 if (! aout_link_check_ar_symbols (abfd
, info
, pneeded
))
2808 if (! aout_link_add_symbols (abfd
, info
))
2812 if (! info
->keep_memory
|| ! *pneeded
)
2814 if (! aout_link_free_symbols (abfd
))
2821 /* Free up the internal symbols read from an a.out file. */
2824 aout_link_free_symbols (abfd
)
2827 if (obj_aout_external_syms (abfd
) != (struct external_nlist
*) NULL
)
2829 free ((PTR
) obj_aout_external_syms (abfd
));
2830 obj_aout_external_syms (abfd
) = (struct external_nlist
*) NULL
;
2832 if (obj_aout_external_strings (abfd
) != (char *) NULL
)
2834 free ((PTR
) obj_aout_external_strings (abfd
));
2835 obj_aout_external_strings (abfd
) = (char *) NULL
;
2840 /* Look through the internal symbols to see if this object file should
2841 be included in the link. We should include this object file if it
2842 defines any symbols which are currently undefined. If this object
2843 file defines a common symbol, then we may adjust the size of the
2844 known symbol but we do not include the object file in the link
2845 (unless there is some other reason to include it). */
2848 aout_link_check_ar_symbols (abfd
, info
, pneeded
)
2850 struct bfd_link_info
*info
;
2853 register struct external_nlist
*p
;
2854 struct external_nlist
*pend
;
2859 /* Look through all the symbols. */
2860 p
= obj_aout_external_syms (abfd
);
2861 pend
= p
+ obj_aout_external_sym_count (abfd
);
2862 strings
= obj_aout_external_strings (abfd
);
2863 for (; p
< pend
; p
++)
2865 int type
= bfd_h_get_8 (abfd
, p
->e_type
);
2867 struct bfd_link_hash_entry
*h
;
2869 /* Ignore symbols that are not externally visible. This is an
2870 optimization only, as we check the type more thoroughly
2872 if (((type
& N_EXT
) == 0
2873 || (type
& N_STAB
) != 0
2880 if (type
== N_WARNING
2886 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2887 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
2889 /* We are only interested in symbols that are currently
2890 undefined or common. */
2891 if (h
== (struct bfd_link_hash_entry
*) NULL
2892 || (h
->type
!= bfd_link_hash_undefined
2893 && h
->type
!= bfd_link_hash_common
))
2895 if (type
== (N_INDR
| N_EXT
))
2900 if (type
== (N_TEXT
| N_EXT
)
2901 || type
== (N_DATA
| N_EXT
)
2902 || type
== (N_BSS
| N_EXT
)
2903 || type
== (N_ABS
| N_EXT
)
2904 || type
== (N_INDR
| N_EXT
))
2906 /* This object file defines this symbol. We must link it
2907 in. This is true regardless of whether the current
2908 definition of the symbol is undefined or common. If the
2909 current definition is common, we have a case in which we
2910 have already seen an object file including
2912 and this object file from the archive includes
2914 In such a case we must include this object file.
2916 FIXME: The SunOS 4.1.3 linker will pull in the archive
2917 element if the symbol is defined in the .data section,
2918 but not if it is defined in the .text section. That
2919 seems a bit crazy to me, and I haven't implemented it.
2920 However, it might be correct. */
2921 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
2927 if (type
== (N_UNDF
| N_EXT
))
2931 value
= GET_WORD (abfd
, p
->e_value
);
2934 /* This symbol is common in the object from the archive
2936 if (h
->type
== bfd_link_hash_undefined
)
2941 symbfd
= h
->u
.undef
.abfd
;
2942 if (symbfd
== (bfd
*) NULL
)
2944 /* This symbol was created as undefined from
2945 outside BFD. We assume that we should link
2946 in the object file. This is done for the -u
2947 option in the linker. */
2948 if (! (*info
->callbacks
->add_archive_element
) (info
,
2955 /* Turn the current link symbol into a common
2956 symbol. It is already on the undefs list. */
2957 h
->type
= bfd_link_hash_common
;
2958 h
->u
.c
.size
= value
;
2959 if (h
->u
.c
.size
!= value
)
2961 /* The size did not fit in the bitfield. */
2962 bfd_set_error (bfd_error_bad_value
);
2966 /* FIXME: This isn't quite right. The maximum
2967 alignment of a common symbol should be set by the
2968 architecture of the output file, not of the input
2970 power
= bfd_log2 (value
);
2971 if (power
> bfd_get_arch_info (abfd
)->section_align_power
)
2972 power
= bfd_get_arch_info (abfd
)->section_align_power
;
2973 h
->u
.c
.alignment_power
= power
;
2975 h
->u
.c
.section
= bfd_make_section_old_way (symbfd
,
2980 /* Adjust the size of the common symbol if
2982 if (value
> h
->u
.c
.size
)
2983 h
->u
.c
.size
= value
;
2993 /* This symbol is weak but defined. We must pull it in if
2994 the current link symbol is undefined, but we don't want
2995 it if the current link symbol is common. */
2996 if (h
->type
== bfd_link_hash_undefined
)
2998 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
3006 /* We do not need this object file. */
3010 /* Add all symbols from an object file to the hash table. */
3013 aout_link_add_symbols (abfd
, info
)
3015 struct bfd_link_info
*info
;
3017 boolean (*add_one_symbol
) PARAMS ((struct bfd_link_info
*, bfd
*,
3018 const char *, flagword
, asection
*,
3019 bfd_vma
, const char *, boolean
,
3021 struct bfd_link_hash_entry
**));
3022 bfd_size_type sym_count
;
3025 struct aout_link_hash_entry
**sym_hash
;
3026 register struct external_nlist
*p
;
3027 struct external_nlist
*pend
;
3029 sym_count
= obj_aout_external_sym_count (abfd
);
3030 strings
= obj_aout_external_strings (abfd
);
3031 if (info
->keep_memory
)
3036 /* We keep a list of the linker hash table entries that correspond
3037 to particular symbols. We could just look them up in the hash
3038 table, but keeping the list is more efficient. Perhaps this
3039 should be conditional on info->keep_memory. */
3040 sym_hash
= ((struct aout_link_hash_entry
**)
3043 * sizeof (struct aout_link_hash_entry
*))));
3044 if (sym_hash
== NULL
&& sym_count
!= 0)
3046 bfd_set_error (bfd_error_no_memory
);
3049 obj_aout_sym_hashes (abfd
) = sym_hash
;
3051 if ((abfd
->flags
& DYNAMIC
) != 0
3052 && aout_backend_info (abfd
)->add_dynamic_symbols
!= NULL
)
3054 if (! (*aout_backend_info (abfd
)->add_dynamic_symbols
) (abfd
, info
))
3058 add_one_symbol
= aout_backend_info (abfd
)->add_one_symbol
;
3059 if (add_one_symbol
== NULL
)
3060 add_one_symbol
= _bfd_generic_link_add_one_symbol
;
3062 p
= obj_aout_external_syms (abfd
);
3063 pend
= p
+ sym_count
;
3064 for (; p
< pend
; p
++, sym_hash
++)
3075 type
= bfd_h_get_8 (abfd
, p
->e_type
);
3077 /* Ignore debugging symbols. */
3078 if ((type
& N_STAB
) != 0)
3081 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3082 value
= GET_WORD (abfd
, p
->e_value
);
3099 /* Ignore symbols that are not externally visible. */
3102 /* Ignore local indirect symbol. */
3107 case N_UNDF
| N_EXT
:
3110 section
= bfd_und_section_ptr
;
3114 section
= bfd_com_section_ptr
;
3117 section
= bfd_abs_section_ptr
;
3119 case N_TEXT
| N_EXT
:
3120 section
= obj_textsec (abfd
);
3121 value
-= bfd_get_section_vma (abfd
, section
);
3123 case N_DATA
| N_EXT
:
3124 case N_SETV
| N_EXT
:
3125 /* Treat N_SETV symbols as N_DATA symbol; see comment in
3126 translate_from_native_sym_flags. */
3127 section
= obj_datasec (abfd
);
3128 value
-= bfd_get_section_vma (abfd
, section
);
3131 section
= obj_bsssec (abfd
);
3132 value
-= bfd_get_section_vma (abfd
, section
);
3134 case N_INDR
| N_EXT
:
3135 /* An indirect symbol. The next symbol is the symbol
3136 which this one really is. */
3137 BFD_ASSERT (p
+ 1 < pend
);
3139 string
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3140 section
= bfd_ind_section_ptr
;
3141 flags
|= BSF_INDIRECT
;
3143 case N_COMM
| N_EXT
:
3144 section
= bfd_com_section_ptr
;
3146 case N_SETA
: case N_SETA
| N_EXT
:
3147 section
= bfd_abs_section_ptr
;
3148 flags
|= BSF_CONSTRUCTOR
;
3150 case N_SETT
: case N_SETT
| N_EXT
:
3151 section
= obj_textsec (abfd
);
3152 flags
|= BSF_CONSTRUCTOR
;
3153 value
-= bfd_get_section_vma (abfd
, section
);
3155 case N_SETD
: case N_SETD
| N_EXT
:
3156 section
= obj_datasec (abfd
);
3157 flags
|= BSF_CONSTRUCTOR
;
3158 value
-= bfd_get_section_vma (abfd
, section
);
3160 case N_SETB
: case N_SETB
| N_EXT
:
3161 section
= obj_bsssec (abfd
);
3162 flags
|= BSF_CONSTRUCTOR
;
3163 value
-= bfd_get_section_vma (abfd
, section
);
3166 /* A warning symbol. The next symbol is the one to warn
3168 BFD_ASSERT (p
+ 1 < pend
);
3171 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3172 section
= bfd_und_section_ptr
;
3173 flags
|= BSF_WARNING
;
3176 section
= bfd_und_section_ptr
;
3180 section
= bfd_abs_section_ptr
;
3184 section
= obj_textsec (abfd
);
3185 value
-= bfd_get_section_vma (abfd
, section
);
3189 section
= obj_datasec (abfd
);
3190 value
-= bfd_get_section_vma (abfd
, section
);
3194 section
= obj_bsssec (abfd
);
3195 value
-= bfd_get_section_vma (abfd
, section
);
3200 if (! ((*add_one_symbol
)
3201 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, false,
3202 (struct bfd_link_hash_entry
**) sym_hash
)))
3205 /* Restrict the maximum alignment of a common symbol based on
3206 the architecture, since a.out has no way to represent
3207 alignment requirements of a section in a .o file. FIXME:
3208 This isn't quite right: it should use the architecture of the
3209 output file, not the input files. */
3210 if ((*sym_hash
)->root
.type
== bfd_link_hash_common
3211 && ((*sym_hash
)->root
.u
.c
.alignment_power
>
3212 bfd_get_arch_info (abfd
)->section_align_power
))
3213 (*sym_hash
)->root
.u
.c
.alignment_power
=
3214 bfd_get_arch_info (abfd
)->section_align_power
;
3216 /* If this is a set symbol, and we are not building sets, then
3217 it is possible for the hash entry to not have been set. In
3218 such a case, treat the symbol as not globally defined. */
3219 if ((*sym_hash
)->root
.type
== bfd_link_hash_new
)
3221 BFD_ASSERT ((flags
& BSF_CONSTRUCTOR
) != 0);
3225 if (type
== (N_INDR
| N_EXT
) || type
== N_WARNING
)
3232 /* During the final link step we need to pass around a bunch of
3233 information, so we do it in an instance of this structure. */
3235 struct aout_final_link_info
3237 /* General link information. */
3238 struct bfd_link_info
*info
;
3241 /* Reloc file positions. */
3242 file_ptr treloff
, dreloff
;
3243 /* File position of symbols. */
3246 struct bfd_strtab_hash
*strtab
;
3247 /* A buffer large enough to hold the contents of any section. */
3249 /* A buffer large enough to hold the relocs of any section. */
3251 /* A buffer large enough to hold the symbol map of any input BFD. */
3253 /* A buffer large enough to hold output symbols of any input BFD. */
3254 struct external_nlist
*output_syms
;
3257 static boolean aout_link_input_bfd
3258 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
));
3259 static boolean aout_link_write_symbols
3260 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
));
3261 static boolean aout_link_write_other_symbol
3262 PARAMS ((struct aout_link_hash_entry
*, PTR
));
3263 static boolean aout_link_input_section
3264 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
,
3265 asection
*input_section
, file_ptr
*reloff_ptr
,
3266 bfd_size_type rel_size
));
3267 static boolean aout_link_input_section_std
3268 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
,
3269 asection
*input_section
, struct reloc_std_external
*,
3270 bfd_size_type rel_size
, bfd_byte
*contents
));
3271 static boolean aout_link_input_section_ext
3272 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
,
3273 asection
*input_section
, struct reloc_ext_external
*,
3274 bfd_size_type rel_size
, bfd_byte
*contents
));
3275 static INLINE asection
*aout_reloc_index_to_section
3276 PARAMS ((bfd
*, int));
3277 static boolean aout_link_reloc_link_order
3278 PARAMS ((struct aout_final_link_info
*, asection
*,
3279 struct bfd_link_order
*));
3281 /* Do the final link step. This is called on the output BFD. The
3282 INFO structure should point to a list of BFDs linked through the
3283 link_next field which can be used to find each BFD which takes part
3284 in the output. Also, each section in ABFD should point to a list
3285 of bfd_link_order structures which list all the input sections for
3286 the output section. */
3289 NAME(aout
,final_link
) (abfd
, info
, callback
)
3291 struct bfd_link_info
*info
;
3292 void (*callback
) PARAMS ((bfd
*, file_ptr
*, file_ptr
*, file_ptr
*));
3294 struct aout_final_link_info aout_info
;
3296 bfd_size_type trsize
, drsize
;
3297 size_t max_contents_size
;
3298 size_t max_relocs_size
;
3299 size_t max_sym_count
;
3300 bfd_size_type text_size
;
3302 register struct bfd_link_order
*p
;
3304 boolean have_link_order_relocs
;
3306 aout_info
.info
= info
;
3307 aout_info
.output_bfd
= abfd
;
3308 aout_info
.contents
= NULL
;
3309 aout_info
.relocs
= NULL
;
3311 /* Figure out the largest section size. Also, if generating
3312 relocateable output, count the relocs. */
3315 max_contents_size
= 0;
3316 max_relocs_size
= 0;
3318 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3322 if (info
->relocateable
)
3324 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3326 trsize
+= exec_hdr (sub
)->a_trsize
;
3327 drsize
+= exec_hdr (sub
)->a_drsize
;
3331 /* FIXME: We need to identify the .text and .data sections
3332 and call get_reloc_upper_bound and canonicalize_reloc to
3333 work out the number of relocs needed, and then multiply
3334 by the reloc size. */
3339 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3341 sz
= bfd_section_size (sub
, obj_textsec (sub
));
3342 if (sz
> max_contents_size
)
3343 max_contents_size
= sz
;
3344 sz
= bfd_section_size (sub
, obj_datasec (sub
));
3345 if (sz
> max_contents_size
)
3346 max_contents_size
= sz
;
3348 sz
= exec_hdr (sub
)->a_trsize
;
3349 if (sz
> max_relocs_size
)
3350 max_relocs_size
= sz
;
3351 sz
= exec_hdr (sub
)->a_drsize
;
3352 if (sz
> max_relocs_size
)
3353 max_relocs_size
= sz
;
3355 sz
= obj_aout_external_sym_count (sub
);
3356 if (sz
> max_sym_count
)
3361 if (info
->relocateable
)
3363 if (obj_textsec (abfd
) != (asection
*) NULL
)
3364 trsize
+= (_bfd_count_link_order_relocs (obj_textsec (abfd
)
3366 * obj_reloc_entry_size (abfd
));
3367 if (obj_datasec (abfd
) != (asection
*) NULL
)
3368 drsize
+= (_bfd_count_link_order_relocs (obj_datasec (abfd
)
3370 * obj_reloc_entry_size (abfd
));
3373 exec_hdr (abfd
)->a_trsize
= trsize
;
3374 exec_hdr (abfd
)->a_drsize
= drsize
;
3376 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
3378 /* Adjust the section sizes and vmas according to the magic number.
3379 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3380 filepos for each section. */
3381 if (! NAME(aout
,adjust_sizes_and_vmas
) (abfd
, &text_size
, &text_end
))
3384 /* The relocation and symbol file positions differ among a.out
3385 targets. We are passed a callback routine from the backend
3386 specific code to handle this.
3387 FIXME: At this point we do not know how much space the symbol
3388 table will require. This will not work for any (nonstandard)
3389 a.out target that needs to know the symbol table size before it
3390 can compute the relocation file positions. This may or may not
3391 be the case for the hp300hpux target, for example. */
3392 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
3394 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
3395 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
3396 obj_sym_filepos (abfd
) = aout_info
.symoff
;
3398 /* We keep a count of the symbols as we output them. */
3399 obj_aout_external_sym_count (abfd
) = 0;
3401 /* We accumulate the string table as we write out the symbols. */
3402 aout_info
.strtab
= _bfd_stringtab_init ();
3403 if (aout_info
.strtab
== NULL
)
3406 /* Allocate buffers to hold section contents and relocs. */
3407 aout_info
.contents
= (bfd_byte
*) malloc (max_contents_size
);
3408 aout_info
.relocs
= (PTR
) malloc (max_relocs_size
);
3409 aout_info
.symbol_map
= (int *) malloc (max_sym_count
* sizeof (int *));
3410 aout_info
.output_syms
= ((struct external_nlist
*)
3411 malloc ((max_sym_count
+ 1)
3412 * sizeof (struct external_nlist
)));
3413 if ((aout_info
.contents
== NULL
&& max_contents_size
!= 0)
3414 || (aout_info
.relocs
== NULL
&& max_relocs_size
!= 0)
3415 || (aout_info
.symbol_map
== NULL
&& max_sym_count
!= 0)
3416 || aout_info
.output_syms
== NULL
)
3418 bfd_set_error (bfd_error_no_memory
);
3422 /* The most time efficient way to do the link would be to read all
3423 the input object files into memory and then sort out the
3424 information into the output file. Unfortunately, that will
3425 probably use too much memory. Another method would be to step
3426 through everything that composes the text section and write it
3427 out, and then everything that composes the data section and write
3428 it out, and then write out the relocs, and then write out the
3429 symbols. Unfortunately, that requires reading stuff from each
3430 input file several times, and we will not be able to keep all the
3431 input files open simultaneously, and reopening them will be slow.
3433 What we do is basically process one input file at a time. We do
3434 everything we need to do with an input file once--copy over the
3435 section contents, handle the relocation information, and write
3436 out the symbols--and then we throw away the information we read
3437 from it. This approach requires a lot of lseeks of the output
3438 file, which is unfortunate but still faster than reopening a lot
3441 We use the output_has_begun field of the input BFDs to see
3442 whether we have already handled it. */
3443 for (sub
= info
->input_bfds
; sub
!= (bfd
*) NULL
; sub
= sub
->link_next
)
3444 sub
->output_has_begun
= false;
3446 have_link_order_relocs
= false;
3447 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3449 for (p
= o
->link_order_head
;
3450 p
!= (struct bfd_link_order
*) NULL
;
3453 if (p
->type
== bfd_indirect_link_order
3454 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
3455 == bfd_target_aout_flavour
))
3459 input_bfd
= p
->u
.indirect
.section
->owner
;
3460 if (! input_bfd
->output_has_begun
)
3462 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
3464 input_bfd
->output_has_begun
= true;
3467 else if (p
->type
== bfd_section_reloc_link_order
3468 || p
->type
== bfd_symbol_reloc_link_order
)
3470 /* These are handled below. */
3471 have_link_order_relocs
= true;
3475 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3481 /* Write out any symbols that we have not already written out. */
3482 aout_link_hash_traverse (aout_hash_table (info
),
3483 aout_link_write_other_symbol
,
3486 /* Now handle any relocs we were asked to create by the linker.
3487 These did not come from any input file. We must do these after
3488 we have written out all the symbols, so that we know the symbol
3490 if (have_link_order_relocs
)
3492 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3494 for (p
= o
->link_order_head
;
3495 p
!= (struct bfd_link_order
*) NULL
;
3498 if (p
->type
== bfd_section_reloc_link_order
3499 || p
->type
== bfd_symbol_reloc_link_order
)
3501 if (! aout_link_reloc_link_order (&aout_info
, o
, p
))
3508 if (aout_info
.contents
!= NULL
)
3510 free (aout_info
.contents
);
3511 aout_info
.contents
= NULL
;
3513 if (aout_info
.relocs
!= NULL
)
3515 free (aout_info
.relocs
);
3516 aout_info
.relocs
= NULL
;
3518 if (aout_info
.symbol_map
!= NULL
)
3520 free (aout_info
.symbol_map
);
3521 aout_info
.symbol_map
= NULL
;
3523 if (aout_info
.output_syms
!= NULL
)
3525 free (aout_info
.output_syms
);
3526 aout_info
.output_syms
= NULL
;
3529 /* Finish up any dynamic linking we may be doing. */
3530 if (aout_backend_info (abfd
)->finish_dynamic_link
!= NULL
)
3532 if (! (*aout_backend_info (abfd
)->finish_dynamic_link
) (abfd
, info
))
3536 /* Update the header information. */
3537 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
3538 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
3539 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
3540 obj_textsec (abfd
)->reloc_count
=
3541 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
3542 obj_datasec (abfd
)->reloc_count
=
3543 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
3545 /* Write out the string table. */
3546 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0)
3548 return emit_stringtab (abfd
, aout_info
.strtab
);
3551 if (aout_info
.contents
!= NULL
)
3552 free (aout_info
.contents
);
3553 if (aout_info
.relocs
!= NULL
)
3554 free (aout_info
.relocs
);
3555 if (aout_info
.symbol_map
!= NULL
)
3556 free (aout_info
.symbol_map
);
3557 if (aout_info
.output_syms
!= NULL
)
3558 free (aout_info
.output_syms
);
3562 /* Link an a.out input BFD into the output file. */
3565 aout_link_input_bfd (finfo
, input_bfd
)
3566 struct aout_final_link_info
*finfo
;
3569 bfd_size_type sym_count
;
3571 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
3573 /* If this is a dynamic object, it may need special handling. */
3574 if ((input_bfd
->flags
& DYNAMIC
) != 0
3575 && aout_backend_info (input_bfd
)->link_dynamic_object
!= NULL
)
3577 return ((*aout_backend_info (input_bfd
)->link_dynamic_object
)
3578 (finfo
->info
, input_bfd
));
3581 /* Get the symbols. We probably have them already, unless
3582 finfo->info->keep_memory is false. */
3583 if (! aout_get_external_symbols (input_bfd
))
3586 sym_count
= obj_aout_external_sym_count (input_bfd
);
3588 /* Write out the symbols and get a map of the new indices. The map
3589 is placed into finfo->symbol_map. */
3590 if (! aout_link_write_symbols (finfo
, input_bfd
))
3593 /* Relocate and write out the sections. These functions use the
3594 symbol map created by aout_link_write_symbols. */
3595 if (! aout_link_input_section (finfo
, input_bfd
,
3596 obj_textsec (input_bfd
),
3598 exec_hdr (input_bfd
)->a_trsize
)
3599 || ! aout_link_input_section (finfo
, input_bfd
,
3600 obj_datasec (input_bfd
),
3602 exec_hdr (input_bfd
)->a_drsize
))
3605 /* If we are not keeping memory, we don't need the symbols any
3606 longer. We still need them if we are keeping memory, because the
3607 strings in the hash table point into them. */
3608 if (! finfo
->info
->keep_memory
)
3610 if (! aout_link_free_symbols (input_bfd
))
3617 /* Adjust and write out the symbols for an a.out file. Set the new
3618 symbol indices into a symbol_map. */
3621 aout_link_write_symbols (finfo
, input_bfd
)
3622 struct aout_final_link_info
*finfo
;
3626 bfd_size_type sym_count
;
3628 enum bfd_link_strip strip
;
3629 enum bfd_link_discard discard
;
3630 struct external_nlist
*outsym
;
3631 bfd_size_type strtab_index
;
3632 register struct external_nlist
*sym
;
3633 struct external_nlist
*sym_end
;
3634 struct aout_link_hash_entry
**sym_hash
;
3639 output_bfd
= finfo
->output_bfd
;
3640 sym_count
= obj_aout_external_sym_count (input_bfd
);
3641 strings
= obj_aout_external_strings (input_bfd
);
3642 strip
= finfo
->info
->strip
;
3643 discard
= finfo
->info
->discard
;
3644 outsym
= finfo
->output_syms
;
3646 /* First write out a symbol for this object file, unless we are
3647 discarding such symbols. */
3648 if (strip
!= strip_all
3649 && (strip
!= strip_some
3650 || bfd_hash_lookup (finfo
->info
->keep_hash
, input_bfd
->filename
,
3651 false, false) != NULL
)
3652 && discard
!= discard_all
)
3654 bfd_h_put_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
3655 bfd_h_put_8 (output_bfd
, 0, outsym
->e_other
);
3656 bfd_h_put_16 (output_bfd
, (bfd_vma
) 0, outsym
->e_desc
);
3657 strtab_index
= add_to_stringtab (output_bfd
, finfo
->strtab
,
3658 input_bfd
->filename
, false);
3659 if (strtab_index
== (bfd_size_type
) -1)
3661 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
3662 PUT_WORD (output_bfd
,
3663 (bfd_get_section_vma (output_bfd
,
3664 obj_textsec (input_bfd
)->output_section
)
3665 + obj_textsec (input_bfd
)->output_offset
),
3667 ++obj_aout_external_sym_count (output_bfd
);
3673 sym
= obj_aout_external_syms (input_bfd
);
3674 sym_end
= sym
+ sym_count
;
3675 sym_hash
= obj_aout_sym_hashes (input_bfd
);
3676 symbol_map
= finfo
->symbol_map
;
3677 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
3681 struct aout_link_hash_entry
*h
;
3689 type
= bfd_h_get_8 (input_bfd
, sym
->e_type
);
3690 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
3696 /* Pass this symbol through. It is the target of an
3697 indirect or warning symbol. */
3698 val
= GET_WORD (input_bfd
, sym
->e_value
);
3703 /* Skip this symbol, which is the target of an indirect
3704 symbol that we have changed to no longer be an indirect
3711 struct aout_link_hash_entry
*hresolve
;
3713 /* We have saved the hash table entry for this symbol, if
3714 there is one. Note that we could just look it up again
3715 in the hash table, provided we first check that it is an
3719 /* If this is an indirect or warning symbol, then change
3720 hresolve to the base symbol. We also change *sym_hash so
3721 that the relocation routines relocate against the real
3724 if (h
!= (struct aout_link_hash_entry
*) NULL
3725 && (h
->root
.type
== bfd_link_hash_indirect
3726 || h
->root
.type
== bfd_link_hash_warning
))
3728 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
3729 while (hresolve
->root
.type
== bfd_link_hash_indirect
3730 || hresolve
->root
.type
== bfd_link_hash_warning
)
3731 hresolve
= ((struct aout_link_hash_entry
*)
3732 hresolve
->root
.u
.i
.link
);
3733 *sym_hash
= hresolve
;
3736 /* If the symbol has already been written out, skip it. */
3737 if (h
!= (struct aout_link_hash_entry
*) NULL
3738 && h
->root
.type
!= bfd_link_hash_warning
3741 if ((type
& N_TYPE
) == N_INDR
3742 || type
== N_WARNING
)
3744 *symbol_map
= h
->indx
;
3748 /* See if we are stripping this symbol. */
3754 case strip_debugger
:
3755 if ((type
& N_STAB
) != 0)
3759 if (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
3769 if (h
!= (struct aout_link_hash_entry
*) NULL
)
3774 /* Get the value of the symbol. */
3775 if ((type
& N_TYPE
) == N_TEXT
3777 symsec
= obj_textsec (input_bfd
);
3778 else if ((type
& N_TYPE
) == N_DATA
3780 symsec
= obj_datasec (input_bfd
);
3781 else if ((type
& N_TYPE
) == N_BSS
3783 symsec
= obj_bsssec (input_bfd
);
3784 else if ((type
& N_TYPE
) == N_ABS
3786 symsec
= bfd_abs_section_ptr
;
3787 else if (((type
& N_TYPE
) == N_INDR
3788 && (hresolve
== (struct aout_link_hash_entry
*) NULL
3789 || (hresolve
->root
.type
!= bfd_link_hash_defined
3790 && hresolve
->root
.type
!= bfd_link_hash_defweak
3791 && hresolve
->root
.type
!= bfd_link_hash_common
)))
3792 || type
== N_WARNING
)
3794 /* Pass the next symbol through unchanged. The
3795 condition above for indirect symbols is so that if
3796 the indirect symbol was defined, we output it with
3797 the correct definition so the debugger will
3800 val
= GET_WORD (input_bfd
, sym
->e_value
);
3803 else if ((type
& N_STAB
) != 0)
3805 val
= GET_WORD (input_bfd
, sym
->e_value
);
3810 /* If we get here with an indirect symbol, it means that
3811 we are outputting it with a real definition. In such
3812 a case we do not want to output the next symbol,
3813 which is the target of the indirection. */
3814 if ((type
& N_TYPE
) == N_INDR
)
3819 /* We need to get the value from the hash table. We use
3820 hresolve so that if we have defined an indirect
3821 symbol we output the final definition. */
3822 if (h
== (struct aout_link_hash_entry
*) NULL
)
3824 switch (type
& N_TYPE
)
3827 symsec
= obj_textsec (input_bfd
);
3830 symsec
= obj_datasec (input_bfd
);
3833 symsec
= obj_bsssec (input_bfd
);
3836 symsec
= bfd_abs_section_ptr
;
3843 else if (hresolve
->root
.type
== bfd_link_hash_defined
3844 || hresolve
->root
.type
== bfd_link_hash_defweak
)
3846 asection
*input_section
;
3847 asection
*output_section
;
3849 /* This case usually means a common symbol which was
3850 turned into a defined symbol. */
3851 input_section
= hresolve
->root
.u
.def
.section
;
3852 output_section
= input_section
->output_section
;
3853 BFD_ASSERT (bfd_is_abs_section (output_section
)
3854 || output_section
->owner
== output_bfd
);
3855 val
= (hresolve
->root
.u
.def
.value
3856 + bfd_get_section_vma (output_bfd
, output_section
)
3857 + input_section
->output_offset
);
3859 /* Get the correct type based on the section. If
3860 this is a constructed set, force it to be
3861 globally visible. */
3870 if (output_section
== obj_textsec (output_bfd
))
3871 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
3874 else if (output_section
== obj_datasec (output_bfd
))
3875 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
3878 else if (output_section
== obj_bsssec (output_bfd
))
3879 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
3883 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
3887 else if (hresolve
->root
.type
== bfd_link_hash_common
)
3888 val
= hresolve
->root
.u
.c
.size
;
3889 else if (hresolve
->root
.type
== bfd_link_hash_undefweak
)
3897 if (symsec
!= (asection
*) NULL
)
3898 val
= (symsec
->output_section
->vma
3899 + symsec
->output_offset
3900 + (GET_WORD (input_bfd
, sym
->e_value
)
3903 /* If this is a global symbol set the written flag, and if
3904 it is a local symbol see if we should discard it. */
3905 if (h
!= (struct aout_link_hash_entry
*) NULL
)
3908 h
->indx
= obj_aout_external_sym_count (output_bfd
);
3910 else if ((type
& N_TYPE
) != N_SETT
3911 && (type
& N_TYPE
) != N_SETD
3912 && (type
& N_TYPE
) != N_SETB
3913 && (type
& N_TYPE
) != N_SETA
)
3920 if (*name
== *finfo
->info
->lprefix
3921 && (finfo
->info
->lprefix_len
== 1
3922 || strncmp (name
, finfo
->info
->lprefix
,
3923 finfo
->info
->lprefix_len
) == 0))
3938 /* Copy this symbol into the list of symbols we are going to
3940 bfd_h_put_8 (output_bfd
, type
, outsym
->e_type
);
3941 bfd_h_put_8 (output_bfd
, bfd_h_get_8 (input_bfd
, sym
->e_other
),
3943 bfd_h_put_16 (output_bfd
, bfd_h_get_16 (input_bfd
, sym
->e_desc
),
3946 if (! finfo
->info
->keep_memory
)
3948 /* name points into a string table which we are going to
3949 free. If there is a hash table entry, use that string.
3950 Otherwise, copy name into memory. */
3951 if (h
!= (struct aout_link_hash_entry
*) NULL
)
3952 name
= h
->root
.root
.string
;
3956 strtab_index
= add_to_stringtab (output_bfd
, finfo
->strtab
,
3958 if (strtab_index
== (bfd_size_type
) -1)
3960 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
3961 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
3962 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
3963 ++obj_aout_external_sym_count (output_bfd
);
3967 /* Write out the output symbols we have just constructed. */
3968 if (outsym
> finfo
->output_syms
)
3970 bfd_size_type outsym_count
;
3972 if (bfd_seek (output_bfd
, finfo
->symoff
, SEEK_SET
) != 0)
3974 outsym_count
= outsym
- finfo
->output_syms
;
3975 if (bfd_write ((PTR
) finfo
->output_syms
,
3976 (bfd_size_type
) EXTERNAL_NLIST_SIZE
,
3977 (bfd_size_type
) outsym_count
, output_bfd
)
3978 != outsym_count
* EXTERNAL_NLIST_SIZE
)
3980 finfo
->symoff
+= outsym_count
* EXTERNAL_NLIST_SIZE
;
3986 /* Write out a symbol that was not associated with an a.out input
3990 aout_link_write_other_symbol (h
, data
)
3991 struct aout_link_hash_entry
*h
;
3994 struct aout_final_link_info
*finfo
= (struct aout_final_link_info
*) data
;
3998 struct external_nlist outsym
;
4001 output_bfd
= finfo
->output_bfd
;
4003 if (aout_backend_info (output_bfd
)->write_dynamic_symbol
!= NULL
)
4005 if (! ((*aout_backend_info (output_bfd
)->write_dynamic_symbol
)
4006 (output_bfd
, finfo
->info
, h
)))
4008 /* FIXME: No way to handle errors. */
4018 /* An indx of -2 means the symbol must be written. */
4020 && (finfo
->info
->strip
== strip_all
4021 || (finfo
->info
->strip
== strip_some
4022 && bfd_hash_lookup (finfo
->info
->keep_hash
, h
->root
.root
.string
,
4023 false, false) == NULL
)))
4026 switch (h
->root
.type
)
4030 /* Avoid variable not initialized warnings. */
4032 case bfd_link_hash_new
:
4033 /* This can happen for set symbols when sets are not being
4036 case bfd_link_hash_undefined
:
4037 type
= N_UNDF
| N_EXT
;
4040 case bfd_link_hash_defined
:
4041 case bfd_link_hash_defweak
:
4045 sec
= h
->root
.u
.def
.section
->output_section
;
4046 BFD_ASSERT (bfd_is_abs_section (sec
)
4047 || sec
->owner
== output_bfd
);
4048 if (sec
== obj_textsec (output_bfd
))
4049 type
= h
->root
.type
== bfd_link_hash_defined
? N_TEXT
: N_WEAKT
;
4050 else if (sec
== obj_datasec (output_bfd
))
4051 type
= h
->root
.type
== bfd_link_hash_defined
? N_DATA
: N_WEAKD
;
4052 else if (sec
== obj_bsssec (output_bfd
))
4053 type
= h
->root
.type
== bfd_link_hash_defined
? N_BSS
: N_WEAKB
;
4055 type
= h
->root
.type
== bfd_link_hash_defined
? N_ABS
: N_WEAKA
;
4057 val
= (h
->root
.u
.def
.value
4059 + h
->root
.u
.def
.section
->output_offset
);
4062 case bfd_link_hash_common
:
4063 type
= N_UNDF
| N_EXT
;
4064 val
= h
->root
.u
.c
.size
;
4066 case bfd_link_hash_undefweak
:
4069 case bfd_link_hash_indirect
:
4070 case bfd_link_hash_warning
:
4071 /* FIXME: Ignore these for now. The circumstances under which
4072 they should be written out are not clear to me. */
4076 bfd_h_put_8 (output_bfd
, type
, outsym
.e_type
);
4077 bfd_h_put_8 (output_bfd
, 0, outsym
.e_other
);
4078 bfd_h_put_16 (output_bfd
, 0, outsym
.e_desc
);
4079 indx
= add_to_stringtab (output_bfd
, finfo
->strtab
, h
->root
.root
.string
,
4081 if (indx
== (bfd_size_type
) -1)
4083 /* FIXME: No way to handle errors. */
4086 PUT_WORD (output_bfd
, indx
, outsym
.e_strx
);
4087 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
4089 if (bfd_seek (output_bfd
, finfo
->symoff
, SEEK_SET
) != 0
4090 || bfd_write ((PTR
) &outsym
, (bfd_size_type
) EXTERNAL_NLIST_SIZE
,
4091 (bfd_size_type
) 1, output_bfd
) != EXTERNAL_NLIST_SIZE
)
4093 /* FIXME: No way to handle errors. */
4097 finfo
->symoff
+= EXTERNAL_NLIST_SIZE
;
4098 h
->indx
= obj_aout_external_sym_count (output_bfd
);
4099 ++obj_aout_external_sym_count (output_bfd
);
4104 /* Link an a.out section into the output file. */
4107 aout_link_input_section (finfo
, input_bfd
, input_section
, reloff_ptr
,
4109 struct aout_final_link_info
*finfo
;
4111 asection
*input_section
;
4112 file_ptr
*reloff_ptr
;
4113 bfd_size_type rel_size
;
4115 bfd_size_type input_size
;
4118 /* Get the section contents. */
4119 input_size
= bfd_section_size (input_bfd
, input_section
);
4120 if (! bfd_get_section_contents (input_bfd
, input_section
,
4121 (PTR
) finfo
->contents
,
4122 (file_ptr
) 0, input_size
))
4125 /* Read in the relocs if we haven't already done it. */
4126 if (aout_section_data (input_section
) != NULL
4127 && aout_section_data (input_section
)->relocs
!= NULL
)
4128 relocs
= aout_section_data (input_section
)->relocs
;
4131 relocs
= finfo
->relocs
;
4134 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
4135 || bfd_read (relocs
, 1, rel_size
, input_bfd
) != rel_size
)
4140 /* Relocate the section contents. */
4141 if (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
)
4143 if (! aout_link_input_section_std (finfo
, input_bfd
, input_section
,
4144 (struct reloc_std_external
*) relocs
,
4145 rel_size
, finfo
->contents
))
4150 if (! aout_link_input_section_ext (finfo
, input_bfd
, input_section
,
4151 (struct reloc_ext_external
*) relocs
,
4152 rel_size
, finfo
->contents
))
4156 /* Write out the section contents. */
4157 if (! bfd_set_section_contents (finfo
->output_bfd
,
4158 input_section
->output_section
,
4159 (PTR
) finfo
->contents
,
4160 input_section
->output_offset
,
4164 /* If we are producing relocateable output, the relocs were
4165 modified, and we now write them out. */
4166 if (finfo
->info
->relocateable
&& rel_size
> 0)
4168 if (bfd_seek (finfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
4170 if (bfd_write (relocs
, (bfd_size_type
) 1, rel_size
, finfo
->output_bfd
)
4173 *reloff_ptr
+= rel_size
;
4175 /* Assert that the relocs have not run into the symbols, and
4176 that if these are the text relocs they have not run into the
4178 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (finfo
->output_bfd
)
4179 && (reloff_ptr
!= &finfo
->treloff
4181 <= obj_datasec (finfo
->output_bfd
)->rel_filepos
)));
4187 /* Get the section corresponding to a reloc index. */
4189 static INLINE asection
*
4190 aout_reloc_index_to_section (abfd
, indx
)
4194 switch (indx
& N_TYPE
)
4197 return obj_textsec (abfd
);
4199 return obj_datasec (abfd
);
4201 return obj_bsssec (abfd
);
4204 return bfd_abs_section_ptr
;
4210 /* Relocate an a.out section using standard a.out relocs. */
4213 aout_link_input_section_std (finfo
, input_bfd
, input_section
, relocs
,
4215 struct aout_final_link_info
*finfo
;
4217 asection
*input_section
;
4218 struct reloc_std_external
*relocs
;
4219 bfd_size_type rel_size
;
4222 boolean (*check_dynamic_reloc
) PARAMS ((struct bfd_link_info
*,
4224 struct aout_link_hash_entry
*,
4227 boolean relocateable
;
4228 struct external_nlist
*syms
;
4230 struct aout_link_hash_entry
**sym_hashes
;
4232 bfd_size_type reloc_count
;
4233 register struct reloc_std_external
*rel
;
4234 struct reloc_std_external
*rel_end
;
4236 output_bfd
= finfo
->output_bfd
;
4237 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
4239 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
);
4240 BFD_ASSERT (input_bfd
->xvec
->header_byteorder_big_p
4241 == output_bfd
->xvec
->header_byteorder_big_p
);
4243 relocateable
= finfo
->info
->relocateable
;
4244 syms
= obj_aout_external_syms (input_bfd
);
4245 strings
= obj_aout_external_strings (input_bfd
);
4246 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
4247 symbol_map
= finfo
->symbol_map
;
4249 reloc_count
= rel_size
/ RELOC_STD_SIZE
;
4251 rel_end
= rel
+ reloc_count
;
4252 for (; rel
< rel_end
; rel
++)
4263 reloc_howto_type
*howto
;
4265 bfd_reloc_status_type r
;
4267 r_addr
= GET_SWORD (input_bfd
, rel
->r_address
);
4269 #ifdef MY_reloc_howto
4270 howto
= MY_reloc_howto(input_bfd
, rel
, r_index
, r_extern
, r_pcrel
);
4272 if (input_bfd
->xvec
->header_byteorder_big_p
)
4274 r_index
= ((rel
->r_index
[0] << 16)
4275 | (rel
->r_index
[1] << 8)
4277 r_extern
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
));
4278 r_pcrel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_PCREL_BIG
));
4279 r_baserel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
4280 r_jmptable
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
4281 r_relative
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_RELATIVE_BIG
));
4282 r_length
= ((rel
->r_type
[0] & RELOC_STD_BITS_LENGTH_BIG
)
4283 >> RELOC_STD_BITS_LENGTH_SH_BIG
);
4287 r_index
= ((rel
->r_index
[2] << 16)
4288 | (rel
->r_index
[1] << 8)
4290 r_extern
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
));
4291 r_pcrel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_PCREL_LITTLE
));
4292 r_baserel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_BASEREL_LITTLE
));
4293 r_jmptable
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_LITTLE
));
4294 r_relative
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_RELATIVE_LITTLE
));
4295 r_length
= ((rel
->r_type
[0] & RELOC_STD_BITS_LENGTH_LITTLE
)
4296 >> RELOC_STD_BITS_LENGTH_SH_LITTLE
);
4299 howto_idx
= r_length
+ 4 * r_pcrel
+ 8 * r_baserel
4300 + 16 * r_jmptable
+ 32 * r_relative
;
4301 BFD_ASSERT (howto_idx
< TABLE_SIZE (howto_table_std
));
4302 howto
= howto_table_std
+ howto_idx
;
4307 /* We are generating a relocateable output file, and must
4308 modify the reloc accordingly. */
4311 struct aout_link_hash_entry
*h
;
4313 /* If we know the symbol this relocation is against,
4314 convert it into a relocation against a section. This
4315 is what the native linker does. */
4316 h
= sym_hashes
[r_index
];
4317 if (h
!= (struct aout_link_hash_entry
*) NULL
4318 && (h
->root
.type
== bfd_link_hash_defined
4319 || h
->root
.type
== bfd_link_hash_defweak
))
4321 asection
*output_section
;
4323 /* Change the r_extern value. */
4324 if (output_bfd
->xvec
->header_byteorder_big_p
)
4325 rel
->r_type
[0] &=~ RELOC_STD_BITS_EXTERN_BIG
;
4327 rel
->r_type
[0] &=~ RELOC_STD_BITS_EXTERN_LITTLE
;
4329 /* Compute a new r_index. */
4330 output_section
= h
->root
.u
.def
.section
->output_section
;
4331 if (output_section
== obj_textsec (output_bfd
))
4333 else if (output_section
== obj_datasec (output_bfd
))
4335 else if (output_section
== obj_bsssec (output_bfd
))
4340 /* Add the symbol value and the section VMA to the
4341 addend stored in the contents. */
4342 relocation
= (h
->root
.u
.def
.value
4343 + output_section
->vma
4344 + h
->root
.u
.def
.section
->output_offset
);
4348 /* We must change r_index according to the symbol
4350 r_index
= symbol_map
[r_index
];
4356 /* We decided to strip this symbol, but it
4357 turns out that we can't. Note that we
4358 lose the other and desc information here.
4359 I don't think that will ever matter for a
4365 if (! aout_link_write_other_symbol (h
,
4375 name
= strings
+ GET_WORD (input_bfd
,
4376 syms
[r_index
].e_strx
);
4377 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
4378 (finfo
->info
, name
, input_bfd
, input_section
,
4388 /* Write out the new r_index value. */
4389 if (output_bfd
->xvec
->header_byteorder_big_p
)
4391 rel
->r_index
[0] = r_index
>> 16;
4392 rel
->r_index
[1] = r_index
>> 8;
4393 rel
->r_index
[2] = r_index
;
4397 rel
->r_index
[2] = r_index
>> 16;
4398 rel
->r_index
[1] = r_index
>> 8;
4399 rel
->r_index
[0] = r_index
;
4406 /* This is a relocation against a section. We must
4407 adjust by the amount that the section moved. */
4408 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4409 relocation
= (section
->output_section
->vma
4410 + section
->output_offset
4414 /* Change the address of the relocation. */
4415 PUT_WORD (output_bfd
,
4416 r_addr
+ input_section
->output_offset
,
4419 /* Adjust a PC relative relocation by removing the reference
4420 to the original address in the section and including the
4421 reference to the new address. */
4423 relocation
-= (input_section
->output_section
->vma
4424 + input_section
->output_offset
4425 - input_section
->vma
);
4427 if (relocation
== 0)
4430 r
= _bfd_relocate_contents (howto
,
4431 input_bfd
, relocation
,
4436 /* We are generating an executable, and must do a full
4440 struct aout_link_hash_entry
*h
;
4442 h
= sym_hashes
[r_index
];
4444 if (check_dynamic_reloc
!= NULL
)
4448 if (! ((*check_dynamic_reloc
)
4449 (finfo
->info
, input_bfd
, input_section
, h
,
4456 if (h
!= (struct aout_link_hash_entry
*) NULL
4457 && (h
->root
.type
== bfd_link_hash_defined
4458 || h
->root
.type
== bfd_link_hash_defweak
))
4460 relocation
= (h
->root
.u
.def
.value
4461 + h
->root
.u
.def
.section
->output_section
->vma
4462 + h
->root
.u
.def
.section
->output_offset
);
4464 else if (h
!= (struct aout_link_hash_entry
*) NULL
4465 && h
->root
.type
== bfd_link_hash_undefweak
)
4471 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
4472 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
4473 (finfo
->info
, name
, input_bfd
, input_section
,
4483 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4484 relocation
= (section
->output_section
->vma
4485 + section
->output_offset
4488 relocation
+= input_section
->vma
;
4491 r
= _bfd_final_link_relocate (howto
,
4492 input_bfd
, input_section
,
4493 contents
, r_addr
, relocation
,
4497 if (r
!= bfd_reloc_ok
)
4502 case bfd_reloc_outofrange
:
4504 case bfd_reloc_overflow
:
4509 name
= strings
+ GET_WORD (input_bfd
,
4510 syms
[r_index
].e_strx
);
4515 s
= aout_reloc_index_to_section (input_bfd
, r_index
);
4516 name
= bfd_section_name (input_bfd
, s
);
4518 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
4519 (finfo
->info
, name
, howto
->name
,
4520 (bfd_vma
) 0, input_bfd
, input_section
, r_addr
)))
4531 /* Relocate an a.out section using extended a.out relocs. */
4534 aout_link_input_section_ext (finfo
, input_bfd
, input_section
, relocs
,
4536 struct aout_final_link_info
*finfo
;
4538 asection
*input_section
;
4539 struct reloc_ext_external
*relocs
;
4540 bfd_size_type rel_size
;
4543 boolean (*check_dynamic_reloc
) PARAMS ((struct bfd_link_info
*,
4545 struct aout_link_hash_entry
*,
4548 boolean relocateable
;
4549 struct external_nlist
*syms
;
4551 struct aout_link_hash_entry
**sym_hashes
;
4553 bfd_size_type reloc_count
;
4554 register struct reloc_ext_external
*rel
;
4555 struct reloc_ext_external
*rel_end
;
4557 output_bfd
= finfo
->output_bfd
;
4558 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
4560 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_EXT_SIZE
);
4561 BFD_ASSERT (input_bfd
->xvec
->header_byteorder_big_p
4562 == output_bfd
->xvec
->header_byteorder_big_p
);
4564 relocateable
= finfo
->info
->relocateable
;
4565 syms
= obj_aout_external_syms (input_bfd
);
4566 strings
= obj_aout_external_strings (input_bfd
);
4567 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
4568 symbol_map
= finfo
->symbol_map
;
4570 reloc_count
= rel_size
/ RELOC_EXT_SIZE
;
4572 rel_end
= rel
+ reloc_count
;
4573 for (; rel
< rel_end
; rel
++)
4582 r_addr
= GET_SWORD (input_bfd
, rel
->r_address
);
4584 if (input_bfd
->xvec
->header_byteorder_big_p
)
4586 r_index
= ((rel
->r_index
[0] << 16)
4587 | (rel
->r_index
[1] << 8)
4589 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
4590 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
4591 >> RELOC_EXT_BITS_TYPE_SH_BIG
);
4595 r_index
= ((rel
->r_index
[2] << 16)
4596 | (rel
->r_index
[1] << 8)
4598 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
4599 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
4600 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
);
4603 r_addend
= GET_SWORD (input_bfd
, rel
->r_addend
);
4605 BFD_ASSERT (r_type
>= 0
4606 && r_type
< TABLE_SIZE (howto_table_ext
));
4610 /* We are generating a relocateable output file, and must
4611 modify the reloc accordingly. */
4614 struct aout_link_hash_entry
*h
;
4616 /* If we know the symbol this relocation is against,
4617 convert it into a relocation against a section. This
4618 is what the native linker does. */
4619 h
= sym_hashes
[r_index
];
4620 if (h
!= (struct aout_link_hash_entry
*) NULL
4621 && (h
->root
.type
== bfd_link_hash_defined
4622 || h
->root
.type
== bfd_link_hash_defweak
))
4624 asection
*output_section
;
4626 /* Change the r_extern value. */
4627 if (output_bfd
->xvec
->header_byteorder_big_p
)
4628 rel
->r_type
[0] &=~ RELOC_EXT_BITS_EXTERN_BIG
;
4630 rel
->r_type
[0] &=~ RELOC_EXT_BITS_EXTERN_LITTLE
;
4632 /* Compute a new r_index. */
4633 output_section
= h
->root
.u
.def
.section
->output_section
;
4634 if (output_section
== obj_textsec (output_bfd
))
4636 else if (output_section
== obj_datasec (output_bfd
))
4638 else if (output_section
== obj_bsssec (output_bfd
))
4643 /* Add the symbol value and the section VMA to the
4645 relocation
= (h
->root
.u
.def
.value
4646 + output_section
->vma
4647 + h
->root
.u
.def
.section
->output_offset
);
4649 /* Now RELOCATION is the VMA of the final
4650 destination. If this is a PC relative reloc,
4651 then ADDEND is the negative of the source VMA.
4652 We want to set ADDEND to the difference between
4653 the destination VMA and the source VMA, which
4654 means we must adjust RELOCATION by the change in
4655 the source VMA. This is done below. */
4659 /* We must change r_index according to the symbol
4661 r_index
= symbol_map
[r_index
];
4667 /* We decided to strip this symbol, but it
4668 turns out that we can't. Note that we
4669 lose the other and desc information here.
4670 I don't think that will ever matter for a
4676 if (! aout_link_write_other_symbol (h
,
4686 name
= strings
+ GET_WORD (input_bfd
,
4687 syms
[r_index
].e_strx
);
4688 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
4689 (finfo
->info
, name
, input_bfd
, input_section
,
4698 /* If this is a PC relative reloc, then the addend
4699 is the negative of the source VMA. We must
4700 adjust it by the change in the source VMA. This
4704 /* Write out the new r_index value. */
4705 if (output_bfd
->xvec
->header_byteorder_big_p
)
4707 rel
->r_index
[0] = r_index
>> 16;
4708 rel
->r_index
[1] = r_index
>> 8;
4709 rel
->r_index
[2] = r_index
;
4713 rel
->r_index
[2] = r_index
>> 16;
4714 rel
->r_index
[1] = r_index
>> 8;
4715 rel
->r_index
[0] = r_index
;
4722 /* This is a relocation against a section. We must
4723 adjust by the amount that the section moved. */
4724 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4725 relocation
= (section
->output_section
->vma
4726 + section
->output_offset
4729 /* If this is a PC relative reloc, then the addend is
4730 the difference in VMA between the destination and the
4731 source. We have just adjusted for the change in VMA
4732 of the destination, so we must also adjust by the
4733 change in VMA of the source. This is done below. */
4736 /* As described above, we must always adjust a PC relative
4737 reloc by the change in VMA of the source. */
4738 if (howto_table_ext
[r_type
].pc_relative
)
4739 relocation
-= (input_section
->output_section
->vma
4740 + input_section
->output_offset
4741 - input_section
->vma
);
4743 /* Change the addend if necessary. */
4744 if (relocation
!= 0)
4745 PUT_WORD (output_bfd
, r_addend
+ relocation
, rel
->r_addend
);
4747 /* Change the address of the relocation. */
4748 PUT_WORD (output_bfd
,
4749 r_addr
+ input_section
->output_offset
,
4754 bfd_reloc_status_type r
;
4756 /* We are generating an executable, and must do a full
4760 struct aout_link_hash_entry
*h
;
4762 h
= sym_hashes
[r_index
];
4764 if (check_dynamic_reloc
!= NULL
)
4768 if (! ((*check_dynamic_reloc
)
4769 (finfo
->info
, input_bfd
, input_section
, h
,
4776 if (h
!= (struct aout_link_hash_entry
*) NULL
4777 && (h
->root
.type
== bfd_link_hash_defined
4778 || h
->root
.type
== bfd_link_hash_defweak
))
4780 relocation
= (h
->root
.u
.def
.value
4781 + h
->root
.u
.def
.section
->output_section
->vma
4782 + h
->root
.u
.def
.section
->output_offset
);
4784 else if (h
!= (struct aout_link_hash_entry
*) NULL
4785 && h
->root
.type
== bfd_link_hash_undefweak
)
4791 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
4792 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
4793 (finfo
->info
, name
, input_bfd
, input_section
,
4803 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4805 /* If this is a PC relative reloc, then R_ADDEND is the
4806 difference between the two vmas, or
4807 old_dest_sec + old_dest_off - (old_src_sec + old_src_off)
4809 old_dest_sec == section->vma
4811 old_src_sec == input_section->vma
4813 old_src_off == r_addr
4815 _bfd_final_link_relocate expects RELOCATION +
4816 R_ADDEND to be the VMA of the destination minus
4817 r_addr (the minus r_addr is because this relocation
4818 is not pcrel_offset, which is a bit confusing and
4819 should, perhaps, be changed), or
4822 new_dest_sec == output_section->vma + output_offset
4823 We arrange for this to happen by setting RELOCATION to
4824 new_dest_sec + old_src_sec - old_dest_sec
4826 If this is not a PC relative reloc, then R_ADDEND is
4827 simply the VMA of the destination, so we set
4828 RELOCATION to the change in the destination VMA, or
4829 new_dest_sec - old_dest_sec
4831 relocation
= (section
->output_section
->vma
4832 + section
->output_offset
4834 if (howto_table_ext
[r_type
].pc_relative
)
4835 relocation
+= input_section
->vma
;
4838 r
= _bfd_final_link_relocate (howto_table_ext
+ r_type
,
4839 input_bfd
, input_section
,
4840 contents
, r_addr
, relocation
,
4842 if (r
!= bfd_reloc_ok
)
4847 case bfd_reloc_outofrange
:
4849 case bfd_reloc_overflow
:
4854 name
= strings
+ GET_WORD (input_bfd
,
4855 syms
[r_index
].e_strx
);
4860 s
= aout_reloc_index_to_section (input_bfd
, r_index
);
4861 name
= bfd_section_name (input_bfd
, s
);
4863 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
4864 (finfo
->info
, name
, howto_table_ext
[r_type
].name
,
4865 r_addend
, input_bfd
, input_section
, r_addr
)))
4877 /* Handle a link order which is supposed to generate a reloc. */
4880 aout_link_reloc_link_order (finfo
, o
, p
)
4881 struct aout_final_link_info
*finfo
;
4883 struct bfd_link_order
*p
;
4885 struct bfd_link_order_reloc
*pr
;
4888 reloc_howto_type
*howto
;
4889 file_ptr
*reloff_ptr
;
4890 struct reloc_std_external srel
;
4891 struct reloc_ext_external erel
;
4896 if (p
->type
== bfd_section_reloc_link_order
)
4899 if (bfd_is_abs_section (pr
->u
.section
))
4900 r_index
= N_ABS
| N_EXT
;
4903 BFD_ASSERT (pr
->u
.section
->owner
== finfo
->output_bfd
);
4904 r_index
= pr
->u
.section
->target_index
;
4909 struct aout_link_hash_entry
*h
;
4911 BFD_ASSERT (p
->type
== bfd_symbol_reloc_link_order
);
4913 h
= aout_link_hash_lookup (aout_hash_table (finfo
->info
),
4914 pr
->u
.name
, false, false, true);
4915 if (h
!= (struct aout_link_hash_entry
*) NULL
4920 /* We decided to strip this symbol, but it turns out that we
4921 can't. Note that we lose the other and desc information
4922 here. I don't think that will ever matter for a global
4926 if (! aout_link_write_other_symbol (h
, (PTR
) finfo
))
4932 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
4933 (finfo
->info
, pr
->u
.name
, (bfd
*) NULL
,
4934 (asection
*) NULL
, (bfd_vma
) 0)))
4940 howto
= bfd_reloc_type_lookup (finfo
->output_bfd
, pr
->reloc
);
4943 bfd_set_error (bfd_error_bad_value
);
4947 if (o
== obj_textsec (finfo
->output_bfd
))
4948 reloff_ptr
= &finfo
->treloff
;
4949 else if (o
== obj_datasec (finfo
->output_bfd
))
4950 reloff_ptr
= &finfo
->dreloff
;
4954 if (obj_reloc_entry_size (finfo
->output_bfd
) == RELOC_STD_SIZE
)
4963 MY_put_reloc(finfo
->output_bfd
, r_extern
, r_index
, p
->offset
, howto
, &srel
);
4965 r_pcrel
= howto
->pc_relative
;
4966 r_baserel
= (howto
->type
& 8) != 0;
4967 r_jmptable
= (howto
->type
& 16) != 0;
4968 r_relative
= (howto
->type
& 32) != 0;
4969 r_length
= howto
->size
;
4971 PUT_WORD (finfo
->output_bfd
, p
->offset
, srel
.r_address
);
4972 if (finfo
->output_bfd
->xvec
->header_byteorder_big_p
)
4974 srel
.r_index
[0] = r_index
>> 16;
4975 srel
.r_index
[1] = r_index
>> 8;
4976 srel
.r_index
[2] = r_index
;
4978 ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
4979 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
4980 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
4981 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
4982 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
4983 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
4987 srel
.r_index
[2] = r_index
>> 16;
4988 srel
.r_index
[1] = r_index
>> 8;
4989 srel
.r_index
[0] = r_index
;
4991 ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
4992 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
4993 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
4994 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
4995 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
4996 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
4999 rel_ptr
= (PTR
) &srel
;
5001 /* We have to write the addend into the object file, since
5002 standard a.out relocs are in place. It would be more
5003 reliable if we had the current contents of the file here,
5004 rather than assuming zeroes, but we can't read the file since
5005 it was opened using bfd_openw. */
5006 if (pr
->addend
!= 0)
5009 bfd_reloc_status_type r
;
5013 size
= bfd_get_reloc_size (howto
);
5014 buf
= (bfd_byte
*) bfd_zmalloc (size
);
5015 if (buf
== (bfd_byte
*) NULL
)
5017 bfd_set_error (bfd_error_no_memory
);
5020 r
= _bfd_relocate_contents (howto
, finfo
->output_bfd
,
5027 case bfd_reloc_outofrange
:
5029 case bfd_reloc_overflow
:
5030 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
5032 (p
->type
== bfd_section_reloc_link_order
5033 ? bfd_section_name (finfo
->output_bfd
,
5036 howto
->name
, pr
->addend
, (bfd
*) NULL
,
5037 (asection
*) NULL
, (bfd_vma
) 0)))
5044 ok
= bfd_set_section_contents (finfo
->output_bfd
, o
,
5046 (file_ptr
) p
->offset
,
5055 PUT_WORD (finfo
->output_bfd
, p
->offset
, erel
.r_address
);
5057 if (finfo
->output_bfd
->xvec
->header_byteorder_big_p
)
5059 erel
.r_index
[0] = r_index
>> 16;
5060 erel
.r_index
[1] = r_index
>> 8;
5061 erel
.r_index
[2] = r_index
;
5063 ((r_extern
? RELOC_EXT_BITS_EXTERN_BIG
: 0)
5064 | (howto
->type
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
5068 erel
.r_index
[2] = r_index
>> 16;
5069 erel
.r_index
[1] = r_index
>> 8;
5070 erel
.r_index
[0] = r_index
;
5072 (r_extern
? RELOC_EXT_BITS_EXTERN_LITTLE
: 0)
5073 | (howto
->type
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
);
5076 PUT_WORD (finfo
->output_bfd
, pr
->addend
, erel
.r_addend
);
5078 rel_ptr
= (PTR
) &erel
;
5081 if (bfd_seek (finfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0
5082 || (bfd_write (rel_ptr
, (bfd_size_type
) 1,
5083 obj_reloc_entry_size (finfo
->output_bfd
),
5085 != obj_reloc_entry_size (finfo
->output_bfd
)))
5088 *reloff_ptr
+= obj_reloc_entry_size (finfo
->output_bfd
);
5090 /* Assert that the relocs have not run into the symbols, and that n
5091 the text relocs have not run into the data relocs. */
5092 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (finfo
->output_bfd
)
5093 && (reloff_ptr
!= &finfo
->treloff
5095 <= obj_datasec (finfo
->output_bfd
)->rel_filepos
)));