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
)
1171 if (! NAME(aout
,adjust_sizes_and_vmas
) (abfd
, &text_size
, &text_end
))
1175 if (section
== obj_bsssec (abfd
))
1177 bfd_set_error (bfd_error_no_contents
);
1181 if (section
!= obj_textsec (abfd
)
1182 && section
!= obj_datasec (abfd
))
1184 bfd_set_error (bfd_error_nonrepresentable_section
);
1190 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
1191 || bfd_write (location
, 1, count
, abfd
) != count
)
1198 /* Read the external symbols from an a.out file. */
1201 aout_get_external_symbols (abfd
)
1204 if (obj_aout_external_syms (abfd
) == (struct external_nlist
*) NULL
)
1206 bfd_size_type count
;
1207 struct external_nlist
*syms
;
1209 count
= exec_hdr (abfd
)->a_syms
/ EXTERNAL_NLIST_SIZE
;
1211 /* We allocate using malloc to make the values easy to free
1212 later on. If we put them on the obstack it might not be
1213 possible to free them. */
1214 syms
= ((struct external_nlist
*)
1215 malloc ((size_t) count
* EXTERNAL_NLIST_SIZE
));
1216 if (syms
== (struct external_nlist
*) NULL
&& count
!= 0)
1218 bfd_set_error (bfd_error_no_memory
);
1222 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1223 || (bfd_read (syms
, 1, exec_hdr (abfd
)->a_syms
, abfd
)
1224 != exec_hdr (abfd
)->a_syms
))
1230 obj_aout_external_syms (abfd
) = syms
;
1231 obj_aout_external_sym_count (abfd
) = count
;
1234 if (obj_aout_external_strings (abfd
) == NULL
1235 && exec_hdr (abfd
)->a_syms
!= 0)
1237 unsigned char string_chars
[BYTES_IN_WORD
];
1238 bfd_size_type stringsize
;
1241 /* Get the size of the strings. */
1242 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
1243 || (bfd_read ((PTR
) string_chars
, BYTES_IN_WORD
, 1, abfd
)
1246 stringsize
= GET_WORD (abfd
, string_chars
);
1248 strings
= (char *) malloc ((size_t) stringsize
+ 1);
1249 if (strings
== NULL
)
1251 bfd_set_error (bfd_error_no_memory
);
1255 /* Skip space for the string count in the buffer for convenience
1256 when using indexes. */
1257 if (bfd_read (strings
+ BYTES_IN_WORD
, 1, stringsize
- BYTES_IN_WORD
,
1259 != stringsize
- BYTES_IN_WORD
)
1265 /* Ensure that a zero index yields an empty string. */
1268 /* Sanity preservation. */
1269 strings
[stringsize
] = '\0';
1271 obj_aout_external_strings (abfd
) = strings
;
1272 obj_aout_external_string_size (abfd
) = stringsize
;
1278 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1279 and symbol->value fields of CACHE_PTR will be set from the a.out
1280 nlist structure. This function is responsible for setting
1281 symbol->flags and symbol->section, and adjusting symbol->value. */
1284 translate_from_native_sym_flags (abfd
, cache_ptr
)
1286 aout_symbol_type
*cache_ptr
;
1290 if ((cache_ptr
->type
& N_STAB
) != 0
1291 || cache_ptr
->type
== N_FN
)
1295 /* This is a debugging symbol. */
1297 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1299 /* Work out the symbol section. */
1300 switch (cache_ptr
->type
& N_TYPE
)
1304 sec
= obj_textsec (abfd
);
1307 sec
= obj_datasec (abfd
);
1310 sec
= obj_bsssec (abfd
);
1314 sec
= bfd_abs_section_ptr
;
1318 cache_ptr
->symbol
.section
= sec
;
1319 cache_ptr
->symbol
.value
-= sec
->vma
;
1324 /* Get the default visibility. This does not apply to all types, so
1325 we just hold it in a local variable to use if wanted. */
1326 if ((cache_ptr
->type
& N_EXT
) == 0)
1327 visible
= BSF_LOCAL
;
1329 visible
= BSF_GLOBAL
;
1331 switch (cache_ptr
->type
)
1334 case N_ABS
: case N_ABS
| N_EXT
:
1335 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1336 cache_ptr
->symbol
.flags
= visible
;
1339 case N_UNDF
| N_EXT
:
1340 if (cache_ptr
->symbol
.value
!= 0)
1342 /* This is a common symbol. */
1343 cache_ptr
->symbol
.flags
= BSF_GLOBAL
;
1344 cache_ptr
->symbol
.section
= bfd_com_section_ptr
;
1348 cache_ptr
->symbol
.flags
= 0;
1349 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1353 case N_TEXT
: case N_TEXT
| N_EXT
:
1354 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1355 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1356 cache_ptr
->symbol
.flags
= visible
;
1359 /* N_SETV symbols used to represent set vectors placed in the
1360 data section. They are no longer generated. Theoretically,
1361 it was possible to extract the entries and combine them with
1362 new ones, although I don't know if that was ever actually
1363 done. Unless that feature is restored, treat them as data
1365 case N_SETV
: case N_SETV
| N_EXT
:
1366 case N_DATA
: case N_DATA
| N_EXT
:
1367 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1368 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1369 cache_ptr
->symbol
.flags
= visible
;
1372 case N_BSS
: case N_BSS
| N_EXT
:
1373 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1374 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1375 cache_ptr
->symbol
.flags
= visible
;
1378 case N_SETA
: case N_SETA
| N_EXT
:
1379 case N_SETT
: case N_SETT
| N_EXT
:
1380 case N_SETD
: case N_SETD
| N_EXT
:
1381 case N_SETB
: case N_SETB
| N_EXT
:
1384 arelent_chain
*reloc
;
1385 asection
*into_section
;
1387 /* This is a set symbol. The name of the symbol is the name
1388 of the set (e.g., __CTOR_LIST__). The value of the symbol
1389 is the value to add to the set. We create a section with
1390 the same name as the symbol, and add a reloc to insert the
1391 appropriate value into the section.
1393 This action is actually obsolete; it used to make the
1394 linker do the right thing, but the linker no longer uses
1397 section
= bfd_get_section_by_name (abfd
, cache_ptr
->symbol
.name
);
1398 if (section
== NULL
)
1402 copy
= bfd_alloc (abfd
, strlen (cache_ptr
->symbol
.name
) + 1);
1405 bfd_set_error (bfd_error_no_memory
);
1409 strcpy (copy
, cache_ptr
->symbol
.name
);
1410 section
= bfd_make_section (abfd
, copy
);
1411 if (section
== NULL
)
1415 reloc
= (arelent_chain
*) bfd_alloc (abfd
, sizeof (arelent_chain
));
1418 bfd_set_error (bfd_error_no_memory
);
1422 /* Build a relocation entry for the constructor. */
1423 switch (cache_ptr
->type
& N_TYPE
)
1426 into_section
= bfd_abs_section_ptr
;
1427 cache_ptr
->type
= N_ABS
;
1430 into_section
= obj_textsec (abfd
);
1431 cache_ptr
->type
= N_TEXT
;
1434 into_section
= obj_datasec (abfd
);
1435 cache_ptr
->type
= N_DATA
;
1438 into_section
= obj_bsssec (abfd
);
1439 cache_ptr
->type
= N_BSS
;
1443 /* Build a relocation pointing into the constructor section
1444 pointing at the symbol in the set vector specified. */
1445 reloc
->relent
.addend
= cache_ptr
->symbol
.value
;
1446 cache_ptr
->symbol
.section
= into_section
;
1447 reloc
->relent
.sym_ptr_ptr
= into_section
->symbol_ptr_ptr
;
1449 /* We modify the symbol to belong to a section depending upon
1450 the name of the symbol, and add to the size of the section
1451 to contain a pointer to the symbol. Build a reloc entry to
1452 relocate to this symbol attached to this section. */
1453 section
->flags
= SEC_CONSTRUCTOR
| SEC_RELOC
;
1455 section
->reloc_count
++;
1456 section
->alignment_power
= 2;
1458 reloc
->next
= section
->constructor_chain
;
1459 section
->constructor_chain
= reloc
;
1460 reloc
->relent
.address
= section
->_raw_size
;
1461 section
->_raw_size
+= BYTES_IN_WORD
;
1463 reloc
->relent
.howto
= CTOR_TABLE_RELOC_HOWTO(abfd
);
1465 cache_ptr
->symbol
.flags
|= BSF_CONSTRUCTOR
;
1470 /* This symbol is the text of a warning message. The next
1471 symbol is the symbol to associate the warning with. If a
1472 reference is made to that symbol, a warning is issued. */
1473 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
| BSF_WARNING
;
1475 /* @@ Stuffing pointers into integers is a no-no. We can
1476 usually get away with it if the integer is large enough
1478 if (sizeof (cache_ptr
+ 1) > sizeof (bfd_vma
))
1480 cache_ptr
->symbol
.value
= (bfd_vma
) (cache_ptr
+ 1);
1482 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1486 case N_INDR
: case N_INDR
| N_EXT
:
1487 /* An indirect symbol. This consists of two symbols in a row.
1488 The first symbol is the name of the indirection. The second
1489 symbol is the name of the target. A reference to the first
1490 symbol becomes a reference to the second. */
1491 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
| BSF_INDIRECT
| visible
;
1493 /* @@ Stuffing pointers into integers is a no-no. We can
1494 usually get away with it if the integer is large enough
1496 if (sizeof (cache_ptr
+ 1) > sizeof (bfd_vma
))
1498 cache_ptr
->symbol
.value
= (bfd_vma
) (cache_ptr
+ 1);
1500 cache_ptr
->symbol
.section
= bfd_ind_section_ptr
;
1505 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1506 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1510 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1511 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1515 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1516 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1517 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1521 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1522 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1523 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1527 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1528 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1529 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1536 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1539 translate_to_native_sym_flags (abfd
, cache_ptr
, sym_pointer
)
1542 struct external_nlist
*sym_pointer
;
1544 bfd_vma value
= cache_ptr
->value
;
1546 /* Mask out any existing type bits in case copying from one section
1548 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1550 if (bfd_is_abs_section (bfd_get_section (cache_ptr
)))
1551 sym_pointer
->e_type
[0] |= N_ABS
;
1552 else if (bfd_get_section (cache_ptr
) == obj_textsec (abfd
)
1553 || (bfd_get_section (cache_ptr
)->output_section
1554 == obj_textsec (abfd
)))
1555 sym_pointer
->e_type
[0] |= N_TEXT
;
1556 else if (bfd_get_section (cache_ptr
) == obj_datasec (abfd
)
1557 || (bfd_get_section (cache_ptr
)->output_section
1558 == obj_datasec (abfd
)))
1559 sym_pointer
->e_type
[0] |= N_DATA
;
1560 else if (bfd_get_section (cache_ptr
) == obj_bsssec (abfd
)
1561 || (bfd_get_section (cache_ptr
)->output_section
1562 == obj_bsssec (abfd
)))
1563 sym_pointer
->e_type
[0] |= N_BSS
;
1564 else if (bfd_get_section (cache_ptr
) == NULL
)
1566 /* Protect the bfd_is_com_section call. This case occurs, e.g.,
1567 for the *DEBUG* section of a COFF file. */
1568 bfd_set_error (bfd_error_nonrepresentable_section
);
1571 else if (bfd_is_und_section (bfd_get_section (cache_ptr
)))
1572 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1573 else if (bfd_is_ind_section (bfd_get_section (cache_ptr
)))
1574 sym_pointer
->e_type
[0] = N_INDR
;
1575 else if (bfd_is_com_section (bfd_get_section (cache_ptr
)))
1576 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1579 bfd_set_error (bfd_error_nonrepresentable_section
);
1583 /* Turn the symbol from section relative to absolute again */
1584 if (cache_ptr
->section
->output_section
!= NULL
)
1585 value
+= (cache_ptr
->section
->output_section
->vma
1586 + cache_ptr
->section
->output_offset
);
1588 value
+= cache_ptr
->section
->vma
;
1590 if ((cache_ptr
->flags
& BSF_WARNING
) != 0)
1591 sym_pointer
->e_type
[0] = N_WARNING
;
1593 if ((cache_ptr
->flags
& BSF_DEBUGGING
) != 0)
1594 sym_pointer
->e_type
[0] = ((aout_symbol_type
*) cache_ptr
)->type
;
1595 else if ((cache_ptr
->flags
& BSF_GLOBAL
) != 0)
1596 sym_pointer
->e_type
[0] |= N_EXT
;
1598 if ((cache_ptr
->flags
& BSF_CONSTRUCTOR
) != 0)
1600 int type
= ((aout_symbol_type
*) cache_ptr
)->type
;
1603 case N_ABS
: type
= N_SETA
; break;
1604 case N_TEXT
: type
= N_SETT
; break;
1605 case N_DATA
: type
= N_SETD
; break;
1606 case N_BSS
: type
= N_SETB
; break;
1608 sym_pointer
->e_type
[0] = type
;
1611 if ((cache_ptr
->flags
& BSF_WEAK
) != 0)
1615 switch (sym_pointer
->e_type
[0] & N_TYPE
)
1618 case N_ABS
: type
= N_WEAKA
; break;
1619 case N_TEXT
: type
= N_WEAKT
; break;
1620 case N_DATA
: type
= N_WEAKD
; break;
1621 case N_BSS
: type
= N_WEAKB
; break;
1622 case N_UNDF
: type
= N_WEAKU
; break;
1624 sym_pointer
->e_type
[0] = type
;
1627 PUT_WORD(abfd
, value
, sym_pointer
->e_value
);
1632 /* Native-level interface to symbols. */
1635 NAME(aout
,make_empty_symbol
) (abfd
)
1638 aout_symbol_type
*new =
1639 (aout_symbol_type
*)bfd_zalloc (abfd
, sizeof (aout_symbol_type
));
1642 bfd_set_error (bfd_error_no_memory
);
1645 new->symbol
.the_bfd
= abfd
;
1647 return &new->symbol
;
1650 /* Translate a set of internal symbols into external symbols. */
1653 NAME(aout
,translate_symbol_table
) (abfd
, in
, ext
, count
, str
, strsize
, dynamic
)
1655 aout_symbol_type
*in
;
1656 struct external_nlist
*ext
;
1657 bfd_size_type count
;
1659 bfd_size_type strsize
;
1662 struct external_nlist
*ext_end
;
1664 ext_end
= ext
+ count
;
1665 for (; ext
< ext_end
; ext
++, in
++)
1669 x
= GET_WORD (abfd
, ext
->e_strx
);
1670 in
->symbol
.the_bfd
= abfd
;
1672 /* For the normal symbols, the zero index points at the number
1673 of bytes in the string table but is to be interpreted as the
1674 null string. For the dynamic symbols, the number of bytes in
1675 the string table is stored in the __DYNAMIC structure and the
1676 zero index points at an actual string. */
1677 if (x
== 0 && ! dynamic
)
1678 in
->symbol
.name
= "";
1679 else if (x
< strsize
)
1680 in
->symbol
.name
= str
+ x
;
1684 in
->symbol
.value
= GET_SWORD (abfd
, ext
->e_value
);
1685 in
->desc
= bfd_h_get_16 (abfd
, ext
->e_desc
);
1686 in
->other
= bfd_h_get_8 (abfd
, ext
->e_other
);
1687 in
->type
= bfd_h_get_8 (abfd
, ext
->e_type
);
1688 in
->symbol
.udata
.p
= NULL
;
1690 if (! translate_from_native_sym_flags (abfd
, in
))
1694 in
->symbol
.flags
|= BSF_DYNAMIC
;
1700 /* We read the symbols into a buffer, which is discarded when this
1701 function exits. We read the strings into a buffer large enough to
1702 hold them all plus all the cached symbol entries. */
1705 NAME(aout
,slurp_symbol_table
) (abfd
)
1708 struct external_nlist
*old_external_syms
;
1709 aout_symbol_type
*cached
;
1712 /* If there's no work to be done, don't do any */
1713 if (obj_aout_symbols (abfd
) != (aout_symbol_type
*) NULL
)
1716 old_external_syms
= obj_aout_external_syms (abfd
);
1718 if (! aout_get_external_symbols (abfd
))
1721 cached_size
= (obj_aout_external_sym_count (abfd
)
1722 * sizeof (aout_symbol_type
));
1723 cached
= (aout_symbol_type
*) malloc (cached_size
);
1724 if (cached
== NULL
&& cached_size
!= 0)
1726 bfd_set_error (bfd_error_no_memory
);
1729 if (cached_size
!= 0)
1730 memset (cached
, 0, cached_size
);
1732 /* Convert from external symbol information to internal. */
1733 if (! (NAME(aout
,translate_symbol_table
)
1735 obj_aout_external_syms (abfd
),
1736 obj_aout_external_sym_count (abfd
),
1737 obj_aout_external_strings (abfd
),
1738 obj_aout_external_string_size (abfd
),
1745 bfd_get_symcount (abfd
) = obj_aout_external_sym_count (abfd
);
1747 obj_aout_symbols (abfd
) = cached
;
1749 /* It is very likely that anybody who calls this function will not
1750 want the external symbol information, so if it was allocated
1751 because of our call to aout_get_external_symbols, we free it up
1752 right away to save space. */
1753 if (old_external_syms
== (struct external_nlist
*) NULL
1754 && obj_aout_external_syms (abfd
) != (struct external_nlist
*) NULL
)
1756 free (obj_aout_external_syms (abfd
));
1757 obj_aout_external_syms (abfd
) = NULL
;
1763 /* We use a hash table when writing out symbols so that we only write
1764 out a particular string once. This helps particularly when the
1765 linker writes out stabs debugging entries, because each different
1766 contributing object file tends to have many duplicate stabs
1769 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1770 if BFD_TRADITIONAL_FORMAT is set. */
1772 static bfd_size_type add_to_stringtab
1773 PARAMS ((bfd
*, struct bfd_strtab_hash
*, const char *, boolean
));
1774 static boolean emit_stringtab
PARAMS ((bfd
*, struct bfd_strtab_hash
*));
1776 /* Get the index of a string in a strtab, adding it if it is not
1779 static INLINE bfd_size_type
1780 add_to_stringtab (abfd
, tab
, str
, copy
)
1782 struct bfd_strtab_hash
*tab
;
1787 bfd_size_type index
;
1789 /* An index of 0 always means the empty string. */
1790 if (str
== 0 || *str
== '\0')
1793 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1794 doesn't understand a hashed string table. */
1796 if ((abfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1799 index
= _bfd_stringtab_add (tab
, str
, hash
, copy
);
1801 if (index
!= (bfd_size_type
) -1)
1803 /* Add BYTES_IN_WORD to the return value to account for the
1804 space taken up by the string table size. */
1805 index
+= BYTES_IN_WORD
;
1811 /* Write out a strtab. ABFD is already at the right location in the
1815 emit_stringtab (abfd
, tab
)
1817 struct bfd_strtab_hash
*tab
;
1819 bfd_byte buffer
[BYTES_IN_WORD
];
1821 /* The string table starts with the size. */
1822 PUT_WORD (abfd
, _bfd_stringtab_size (tab
) + BYTES_IN_WORD
, buffer
);
1823 if (bfd_write ((PTR
) buffer
, 1, BYTES_IN_WORD
, abfd
) != BYTES_IN_WORD
)
1826 return _bfd_stringtab_emit (abfd
, tab
);
1830 NAME(aout
,write_syms
) (abfd
)
1833 unsigned int count
;
1834 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1835 struct bfd_strtab_hash
*strtab
;
1837 strtab
= _bfd_stringtab_init ();
1841 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1843 asymbol
*g
= generic
[count
];
1845 struct external_nlist nsp
;
1847 indx
= add_to_stringtab (abfd
, strtab
, g
->name
, false);
1848 if (indx
== (bfd_size_type
) -1)
1850 PUT_WORD (abfd
, indx
, (bfd_byte
*) nsp
.e_strx
);
1852 if (bfd_asymbol_flavour(g
) == abfd
->xvec
->flavour
)
1854 bfd_h_put_16(abfd
, aout_symbol(g
)->desc
, nsp
.e_desc
);
1855 bfd_h_put_8(abfd
, aout_symbol(g
)->other
, nsp
.e_other
);
1856 bfd_h_put_8(abfd
, aout_symbol(g
)->type
, nsp
.e_type
);
1860 bfd_h_put_16(abfd
,0, nsp
.e_desc
);
1861 bfd_h_put_8(abfd
, 0, nsp
.e_other
);
1862 bfd_h_put_8(abfd
, 0, nsp
.e_type
);
1865 if (! translate_to_native_sym_flags (abfd
, g
, &nsp
))
1868 if (bfd_write((PTR
)&nsp
,1,EXTERNAL_NLIST_SIZE
, abfd
)
1869 != EXTERNAL_NLIST_SIZE
)
1872 /* NB: `KEEPIT' currently overlays `flags', so set this only
1873 here, at the end. */
1877 if (! emit_stringtab (abfd
, strtab
))
1880 _bfd_stringtab_free (strtab
);
1885 _bfd_stringtab_free (strtab
);
1891 NAME(aout
,get_symtab
) (abfd
, location
)
1895 unsigned int counter
= 0;
1896 aout_symbol_type
*symbase
;
1898 if (!NAME(aout
,slurp_symbol_table
)(abfd
))
1901 for (symbase
= obj_aout_symbols(abfd
); counter
++ < bfd_get_symcount (abfd
);)
1902 *(location
++) = (asymbol
*)( symbase
++);
1904 return bfd_get_symcount (abfd
);
1908 /* Standard reloc stuff */
1909 /* Output standard relocation information to a file in target byte order. */
1912 NAME(aout
,swap_std_reloc_out
) (abfd
, g
, natptr
)
1915 struct reloc_std_external
*natptr
;
1918 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1920 unsigned int r_length
;
1922 int r_baserel
, r_jmptable
, r_relative
;
1923 asection
*output_section
= sym
->section
->output_section
;
1925 PUT_WORD(abfd
, g
->address
, natptr
->r_address
);
1927 r_length
= g
->howto
->size
; /* Size as a power of two */
1928 r_pcrel
= (int) g
->howto
->pc_relative
; /* Relative to PC? */
1929 /* XXX This relies on relocs coming from a.out files. */
1930 r_baserel
= (g
->howto
->type
& 8) != 0;
1931 r_jmptable
= (g
->howto
->type
& 16) != 0;
1932 r_relative
= (g
->howto
->type
& 32) != 0;
1935 /* For a standard reloc, the addend is in the object file. */
1936 r_addend
= g
->addend
+ (*(g
->sym_ptr_ptr
))->section
->output_section
->vma
;
1939 /* name was clobbered by aout_write_syms to be symbol index */
1941 /* If this relocation is relative to a symbol then set the
1942 r_index to the symbols index, and the r_extern bit.
1944 Absolute symbols can come in in two ways, either as an offset
1945 from the abs section, or as a symbol which has an abs value.
1950 if (bfd_is_com_section (output_section
)
1951 || bfd_is_abs_section (output_section
)
1952 || bfd_is_und_section (output_section
))
1954 if (bfd_abs_section_ptr
->symbol
== sym
)
1956 /* Whoops, looked like an abs symbol, but is really an offset
1957 from the abs section */
1963 /* Fill in symbol */
1965 r_index
= stoi((*(g
->sym_ptr_ptr
))->KEEPIT
);
1971 /* Just an ordinary section */
1973 r_index
= output_section
->target_index
;
1976 /* now the fun stuff */
1977 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
1978 natptr
->r_index
[0] = r_index
>> 16;
1979 natptr
->r_index
[1] = r_index
>> 8;
1980 natptr
->r_index
[2] = r_index
;
1982 (r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
1983 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
1984 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
1985 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
1986 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
1987 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
);
1989 natptr
->r_index
[2] = r_index
>> 16;
1990 natptr
->r_index
[1] = r_index
>> 8;
1991 natptr
->r_index
[0] = r_index
;
1993 (r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
1994 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
1995 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
1996 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
1997 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
1998 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
);
2003 /* Extended stuff */
2004 /* Output extended relocation information to a file in target byte order. */
2007 NAME(aout
,swap_ext_reloc_out
) (abfd
, g
, natptr
)
2010 register struct reloc_ext_external
*natptr
;
2014 unsigned int r_type
;
2015 unsigned int r_addend
;
2016 asymbol
*sym
= *(g
->sym_ptr_ptr
);
2017 asection
*output_section
= sym
->section
->output_section
;
2019 PUT_WORD (abfd
, g
->address
, natptr
->r_address
);
2021 r_type
= (unsigned int) g
->howto
->type
;
2023 r_addend
= g
->addend
+ (*(g
->sym_ptr_ptr
))->section
->output_section
->vma
;
2025 /* If this relocation is relative to a symbol then set the
2026 r_index to the symbols index, and the r_extern bit.
2028 Absolute symbols can come in in two ways, either as an offset
2029 from the abs section, or as a symbol which has an abs value.
2030 check for that here. */
2032 if (bfd_is_com_section (output_section
)
2033 || bfd_is_abs_section (output_section
)
2034 || bfd_is_und_section (output_section
))
2036 if (bfd_abs_section_ptr
->symbol
== sym
)
2038 /* Whoops, looked like an abs symbol, but is really an offset
2039 from the abs section */
2046 r_index
= stoi((*(g
->sym_ptr_ptr
))->KEEPIT
);
2051 /* Just an ordinary section */
2053 r_index
= output_section
->target_index
;
2056 /* now the fun stuff */
2057 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
2058 natptr
->r_index
[0] = r_index
>> 16;
2059 natptr
->r_index
[1] = r_index
>> 8;
2060 natptr
->r_index
[2] = r_index
;
2062 ((r_extern
? RELOC_EXT_BITS_EXTERN_BIG
: 0)
2063 | (r_type
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
2065 natptr
->r_index
[2] = r_index
>> 16;
2066 natptr
->r_index
[1] = r_index
>> 8;
2067 natptr
->r_index
[0] = r_index
;
2069 (r_extern
? RELOC_EXT_BITS_EXTERN_LITTLE
: 0)
2070 | (r_type
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
);
2073 PUT_WORD (abfd
, r_addend
, natptr
->r_addend
);
2076 /* BFD deals internally with all things based from the section they're
2077 in. so, something in 10 bytes into a text section with a base of
2078 50 would have a symbol (.text+10) and know .text vma was 50.
2080 Aout keeps all it's symbols based from zero, so the symbol would
2081 contain 60. This macro subs the base of each section from the value
2082 to give the true offset from the section */
2085 #define MOVE_ADDRESS(ad) \
2087 /* undefined symbol */ \
2088 cache_ptr->sym_ptr_ptr = symbols + r_index; \
2089 cache_ptr->addend = ad; \
2091 /* defined, section relative. replace symbol with pointer to \
2092 symbol which points to section */ \
2093 switch (r_index) { \
2095 case N_TEXT | N_EXT: \
2096 cache_ptr->sym_ptr_ptr = obj_textsec(abfd)->symbol_ptr_ptr; \
2097 cache_ptr->addend = ad - su->textsec->vma; \
2100 case N_DATA | N_EXT: \
2101 cache_ptr->sym_ptr_ptr = obj_datasec(abfd)->symbol_ptr_ptr; \
2102 cache_ptr->addend = ad - su->datasec->vma; \
2105 case N_BSS | N_EXT: \
2106 cache_ptr->sym_ptr_ptr = obj_bsssec(abfd)->symbol_ptr_ptr; \
2107 cache_ptr->addend = ad - su->bsssec->vma; \
2111 case N_ABS | N_EXT: \
2112 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
2113 cache_ptr->addend = ad; \
2119 NAME(aout
,swap_ext_reloc_in
) (abfd
, bytes
, cache_ptr
, symbols
, symcount
)
2121 struct reloc_ext_external
*bytes
;
2124 bfd_size_type symcount
;
2128 unsigned int r_type
;
2129 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
2131 cache_ptr
->address
= (GET_SWORD (abfd
, bytes
->r_address
));
2133 /* now the fun stuff */
2134 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
2135 r_index
= (bytes
->r_index
[0] << 16)
2136 | (bytes
->r_index
[1] << 8)
2137 | bytes
->r_index
[2];
2138 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
2139 r_type
= (bytes
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
2140 >> RELOC_EXT_BITS_TYPE_SH_BIG
;
2142 r_index
= (bytes
->r_index
[2] << 16)
2143 | (bytes
->r_index
[1] << 8)
2144 | bytes
->r_index
[0];
2145 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
2146 r_type
= (bytes
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
2147 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
;
2150 cache_ptr
->howto
= howto_table_ext
+ r_type
;
2152 /* Base relative relocs are always against the symbol table,
2153 regardless of the setting of r_extern. r_extern just reflects
2154 whether the symbol the reloc is against is local or global. */
2155 if (r_type
== RELOC_BASE10
2156 || r_type
== RELOC_BASE13
2157 || r_type
== RELOC_BASE22
)
2160 if (r_extern
&& r_index
> symcount
)
2162 /* We could arrange to return an error, but it might be useful
2163 to see the file even if it is bad. */
2168 MOVE_ADDRESS(GET_SWORD(abfd
, bytes
->r_addend
));
2172 NAME(aout
,swap_std_reloc_in
) (abfd
, bytes
, cache_ptr
, symbols
, symcount
)
2174 struct reloc_std_external
*bytes
;
2177 bfd_size_type symcount
;
2181 unsigned int r_length
;
2183 int r_baserel
, r_jmptable
, r_relative
;
2184 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
2187 cache_ptr
->address
= bfd_h_get_32 (abfd
, bytes
->r_address
);
2189 /* now the fun stuff */
2190 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
2191 r_index
= (bytes
->r_index
[0] << 16)
2192 | (bytes
->r_index
[1] << 8)
2193 | bytes
->r_index
[2];
2194 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
));
2195 r_pcrel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_PCREL_BIG
));
2196 r_baserel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
2197 r_jmptable
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
2198 r_relative
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_RELATIVE_BIG
));
2199 r_length
= (bytes
->r_type
[0] & RELOC_STD_BITS_LENGTH_BIG
)
2200 >> RELOC_STD_BITS_LENGTH_SH_BIG
;
2202 r_index
= (bytes
->r_index
[2] << 16)
2203 | (bytes
->r_index
[1] << 8)
2204 | bytes
->r_index
[0];
2205 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
));
2206 r_pcrel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_PCREL_LITTLE
));
2207 r_baserel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_BASEREL_LITTLE
));
2208 r_jmptable
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_LITTLE
));
2209 r_relative
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_RELATIVE_LITTLE
));
2210 r_length
= (bytes
->r_type
[0] & RELOC_STD_BITS_LENGTH_LITTLE
)
2211 >> RELOC_STD_BITS_LENGTH_SH_LITTLE
;
2214 howto_idx
= r_length
+ 4 * r_pcrel
+ 8 * r_baserel
2215 + 16 * r_jmptable
+ 32 * r_relative
;
2216 BFD_ASSERT (howto_idx
< TABLE_SIZE (howto_table_std
));
2217 cache_ptr
->howto
= howto_table_std
+ howto_idx
;
2218 BFD_ASSERT (cache_ptr
->howto
->type
!= -1);
2220 /* Base relative relocs are always against the symbol table,
2221 regardless of the setting of r_extern. r_extern just reflects
2222 whether the symbol the reloc is against is local or global. */
2226 if (r_extern
&& r_index
> symcount
)
2228 /* We could arrange to return an error, but it might be useful
2229 to see the file even if it is bad. */
2237 /* Read and swap the relocs for a section. */
2240 NAME(aout
,slurp_reloc_table
) (abfd
, asect
, symbols
)
2246 bfd_size_type reloc_size
;
2248 arelent
*reloc_cache
;
2250 unsigned int counter
= 0;
2253 if (asect
->relocation
)
2256 if (asect
->flags
& SEC_CONSTRUCTOR
)
2259 if (asect
== obj_datasec (abfd
))
2260 reloc_size
= exec_hdr(abfd
)->a_drsize
;
2261 else if (asect
== obj_textsec (abfd
))
2262 reloc_size
= exec_hdr(abfd
)->a_trsize
;
2263 else if (asect
== obj_bsssec (abfd
))
2267 bfd_set_error (bfd_error_invalid_operation
);
2271 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
2274 each_size
= obj_reloc_entry_size (abfd
);
2276 count
= reloc_size
/ each_size
;
2278 reloc_cache
= (arelent
*) malloc ((size_t) (count
* sizeof (arelent
)));
2279 if (reloc_cache
== NULL
&& count
!= 0)
2281 bfd_set_error (bfd_error_no_memory
);
2284 memset (reloc_cache
, 0, count
* sizeof (arelent
));
2286 relocs
= malloc (reloc_size
);
2287 if (relocs
== NULL
&& reloc_size
!= 0)
2290 bfd_set_error (bfd_error_no_memory
);
2294 if (bfd_read (relocs
, 1, reloc_size
, abfd
) != reloc_size
)
2301 cache_ptr
= reloc_cache
;
2302 if (each_size
== RELOC_EXT_SIZE
)
2304 register struct reloc_ext_external
*rptr
=
2305 (struct reloc_ext_external
*) relocs
;
2307 for (; counter
< count
; counter
++, rptr
++, cache_ptr
++)
2308 NAME(aout
,swap_ext_reloc_in
) (abfd
, rptr
, cache_ptr
, symbols
,
2309 bfd_get_symcount (abfd
));
2313 register struct reloc_std_external
*rptr
=
2314 (struct reloc_std_external
*) relocs
;
2316 for (; counter
< count
; counter
++, rptr
++, cache_ptr
++)
2317 MY_swap_std_reloc_in (abfd
, rptr
, cache_ptr
, symbols
,
2318 bfd_get_symcount (abfd
));
2323 asect
->relocation
= reloc_cache
;
2324 asect
->reloc_count
= cache_ptr
- reloc_cache
;
2329 /* Write out a relocation section into an object file. */
2332 NAME(aout
,squirt_out_relocs
) (abfd
, section
)
2337 unsigned char *native
, *natptr
;
2340 unsigned int count
= section
->reloc_count
;
2343 if (count
== 0) return true;
2345 each_size
= obj_reloc_entry_size (abfd
);
2346 natsize
= each_size
* count
;
2347 native
= (unsigned char *) bfd_zalloc (abfd
, natsize
);
2349 bfd_set_error (bfd_error_no_memory
);
2353 generic
= section
->orelocation
;
2355 if (each_size
== RELOC_EXT_SIZE
)
2357 for (natptr
= native
;
2359 --count
, natptr
+= each_size
, ++generic
)
2360 NAME(aout
,swap_ext_reloc_out
) (abfd
, *generic
, (struct reloc_ext_external
*)natptr
);
2364 for (natptr
= native
;
2366 --count
, natptr
+= each_size
, ++generic
)
2367 MY_swap_std_reloc_out(abfd
, *generic
, (struct reloc_std_external
*)natptr
);
2370 if ( bfd_write ((PTR
) native
, 1, natsize
, abfd
) != natsize
) {
2371 bfd_release(abfd
, native
);
2374 bfd_release (abfd
, native
);
2379 /* This is stupid. This function should be a boolean predicate */
2381 NAME(aout
,canonicalize_reloc
) (abfd
, section
, relptr
, symbols
)
2387 arelent
*tblptr
= section
->relocation
;
2390 if (section
== obj_bsssec (abfd
))
2396 if (!(tblptr
|| NAME(aout
,slurp_reloc_table
)(abfd
, section
, symbols
)))
2399 if (section
->flags
& SEC_CONSTRUCTOR
) {
2400 arelent_chain
*chain
= section
->constructor_chain
;
2401 for (count
= 0; count
< section
->reloc_count
; count
++) {
2402 *relptr
++ = &chain
->relent
;
2403 chain
= chain
->next
;
2407 tblptr
= section
->relocation
;
2409 for (count
= 0; count
++ < section
->reloc_count
;)
2411 *relptr
++ = tblptr
++;
2416 return section
->reloc_count
;
2420 NAME(aout
,get_reloc_upper_bound
) (abfd
, asect
)
2424 if (bfd_get_format (abfd
) != bfd_object
) {
2425 bfd_set_error (bfd_error_invalid_operation
);
2428 if (asect
->flags
& SEC_CONSTRUCTOR
) {
2429 return (sizeof (arelent
*) * (asect
->reloc_count
+1));
2432 if (asect
== obj_datasec (abfd
))
2433 return (sizeof (arelent
*)
2434 * ((exec_hdr(abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
))
2437 if (asect
== obj_textsec (abfd
))
2438 return (sizeof (arelent
*)
2439 * ((exec_hdr(abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
))
2442 if (asect
== obj_bsssec (abfd
))
2443 return sizeof (arelent
*);
2445 if (asect
== obj_bsssec (abfd
))
2448 bfd_set_error (bfd_error_invalid_operation
);
2454 NAME(aout
,get_symtab_upper_bound
) (abfd
)
2457 if (!NAME(aout
,slurp_symbol_table
)(abfd
))
2460 return (bfd_get_symcount (abfd
)+1) * (sizeof (aout_symbol_type
*));
2465 NAME(aout
,get_lineno
) (ignore_abfd
, ignore_symbol
)
2467 asymbol
*ignore_symbol
;
2469 return (alent
*)NULL
;
2474 NAME(aout
,get_symbol_info
) (ignore_abfd
, symbol
, ret
)
2479 bfd_symbol_info (symbol
, ret
);
2481 if (ret
->type
== '?')
2483 int type_code
= aout_symbol(symbol
)->type
& 0xff;
2484 CONST
char *stab_name
= aout_stab_name(type_code
);
2485 static char buf
[10];
2487 if (stab_name
== NULL
)
2489 sprintf(buf
, "(%d)", type_code
);
2493 ret
->stab_other
= (unsigned)(aout_symbol(symbol
)->other
& 0xff);
2494 ret
->stab_desc
= (unsigned)(aout_symbol(symbol
)->desc
& 0xffff);
2495 ret
->stab_name
= stab_name
;
2501 NAME(aout
,print_symbol
) (ignore_abfd
, afile
, symbol
, how
)
2505 bfd_print_symbol_type how
;
2507 FILE *file
= (FILE *)afile
;
2510 case bfd_print_symbol_name
:
2512 fprintf(file
,"%s", symbol
->name
);
2514 case bfd_print_symbol_more
:
2515 fprintf(file
,"%4x %2x %2x",(unsigned)(aout_symbol(symbol
)->desc
& 0xffff),
2516 (unsigned)(aout_symbol(symbol
)->other
& 0xff),
2517 (unsigned)(aout_symbol(symbol
)->type
));
2519 case bfd_print_symbol_all
:
2521 CONST
char *section_name
= symbol
->section
->name
;
2524 bfd_print_symbol_vandf((PTR
)file
,symbol
);
2526 fprintf(file
," %-5s %04x %02x %02x",
2528 (unsigned)(aout_symbol(symbol
)->desc
& 0xffff),
2529 (unsigned)(aout_symbol(symbol
)->other
& 0xff),
2530 (unsigned)(aout_symbol(symbol
)->type
& 0xff));
2532 fprintf(file
," %s", symbol
->name
);
2539 provided a BFD, a section and an offset into the section, calculate
2540 and return the name of the source file and the line nearest to the
2545 NAME(aout
,find_nearest_line
)
2546 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2551 CONST
char **filename_ptr
;
2552 CONST
char **functionname_ptr
;
2553 unsigned int *line_ptr
;
2555 /* Run down the file looking for the filename, function and linenumber */
2557 static char buffer
[100];
2558 static char filename_buffer
[200];
2559 CONST
char *directory_name
= NULL
;
2560 CONST
char *main_file_name
= NULL
;
2561 CONST
char *current_file_name
= NULL
;
2562 CONST
char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2563 bfd_vma high_line_vma
= ~0;
2564 bfd_vma low_func_vma
= 0;
2566 *filename_ptr
= abfd
->filename
;
2567 *functionname_ptr
= 0;
2569 if (symbols
!= (asymbol
**)NULL
) {
2570 for (p
= symbols
; *p
; p
++) {
2571 aout_symbol_type
*q
= (aout_symbol_type
*)(*p
);
2575 main_file_name
= current_file_name
= q
->symbol
.name
;
2576 /* Look ahead to next symbol to check if that too is an N_SO. */
2580 q
= (aout_symbol_type
*)(*p
);
2581 if (q
->type
!= (int)N_SO
)
2584 /* Found a second N_SO First is directory; second is filename. */
2585 directory_name
= current_file_name
;
2586 main_file_name
= current_file_name
= q
->symbol
.name
;
2587 if (obj_textsec(abfd
) != section
)
2591 current_file_name
= q
->symbol
.name
;
2598 /* We'll keep this if it resolves nearer than the one we have already */
2599 if (q
->symbol
.value
>= offset
&&
2600 q
->symbol
.value
< high_line_vma
) {
2601 *line_ptr
= q
->desc
;
2602 high_line_vma
= q
->symbol
.value
;
2603 line_file_name
= current_file_name
;
2608 /* We'll keep this if it is nearer than the one we have already */
2609 if (q
->symbol
.value
>= low_func_vma
&&
2610 q
->symbol
.value
<= offset
) {
2611 low_func_vma
= q
->symbol
.value
;
2612 func
= (asymbol
*)q
;
2614 if (*line_ptr
&& func
) {
2615 CONST
char *function
= func
->name
;
2618 /* The caller expects a symbol name. We actually have a
2619 function name, without the leading underscore. Put the
2620 underscore back in, so that the caller gets a symbol
2622 if (bfd_get_symbol_leading_char (abfd
) == '\0')
2623 strncpy (buffer
, function
, sizeof (buffer
) - 1);
2626 buffer
[0] = bfd_get_symbol_leading_char (abfd
);
2627 strncpy (buffer
+ 1, function
, sizeof (buffer
) - 2);
2629 buffer
[sizeof(buffer
)-1] = 0;
2630 /* Have to remove : stuff */
2631 p
= strchr(buffer
,':');
2632 if (p
!= NULL
) { *p
= '\0'; }
2633 *functionname_ptr
= buffer
;
2645 main_file_name
= line_file_name
;
2646 if (main_file_name
) {
2647 if (main_file_name
[0] == '/' || directory_name
== NULL
)
2648 *filename_ptr
= main_file_name
;
2650 sprintf(filename_buffer
, "%.140s%.50s",
2651 directory_name
, main_file_name
);
2652 *filename_ptr
= filename_buffer
;
2661 NAME(aout
,sizeof_headers
) (abfd
, execable
)
2665 return adata(abfd
).exec_bytes_size
;
2668 /* Free all information we have cached for this BFD. We can always
2669 read it again later if we need it. */
2672 NAME(aout
,bfd_free_cached_info
) (abfd
)
2677 if (bfd_get_format (abfd
) != bfd_object
)
2680 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2681 BFCI_FREE (obj_aout_symbols (abfd
));
2682 BFCI_FREE (obj_aout_external_syms (abfd
));
2683 BFCI_FREE (obj_aout_external_strings (abfd
));
2684 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
2685 BFCI_FREE (o
->relocation
);
2691 /* a.out link code. */
2693 static boolean aout_link_add_object_symbols
2694 PARAMS ((bfd
*, struct bfd_link_info
*));
2695 static boolean aout_link_check_archive_element
2696 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*));
2697 static boolean aout_link_free_symbols
PARAMS ((bfd
*));
2698 static boolean aout_link_check_ar_symbols
2699 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*pneeded
));
2700 static boolean aout_link_add_symbols
2701 PARAMS ((bfd
*, struct bfd_link_info
*));
2703 /* Routine to create an entry in an a.out link hash table. */
2705 struct bfd_hash_entry
*
2706 NAME(aout
,link_hash_newfunc
) (entry
, table
, string
)
2707 struct bfd_hash_entry
*entry
;
2708 struct bfd_hash_table
*table
;
2711 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2713 /* Allocate the structure if it has not already been allocated by a
2715 if (ret
== (struct aout_link_hash_entry
*) NULL
)
2716 ret
= ((struct aout_link_hash_entry
*)
2717 bfd_hash_allocate (table
, sizeof (struct aout_link_hash_entry
)));
2718 if (ret
== (struct aout_link_hash_entry
*) NULL
)
2720 bfd_set_error (bfd_error_no_memory
);
2721 return (struct bfd_hash_entry
*) ret
;
2724 /* Call the allocation method of the superclass. */
2725 ret
= ((struct aout_link_hash_entry
*)
2726 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2730 /* Set local fields. */
2731 ret
->written
= false;
2735 return (struct bfd_hash_entry
*) ret
;
2738 /* Initialize an a.out link hash table. */
2741 NAME(aout
,link_hash_table_init
) (table
, abfd
, newfunc
)
2742 struct aout_link_hash_table
*table
;
2744 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
2745 struct bfd_hash_table
*,
2748 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
2751 /* Create an a.out link hash table. */
2753 struct bfd_link_hash_table
*
2754 NAME(aout
,link_hash_table_create
) (abfd
)
2757 struct aout_link_hash_table
*ret
;
2759 ret
= ((struct aout_link_hash_table
*)
2760 malloc (sizeof (struct aout_link_hash_table
)));
2761 if (ret
== (struct aout_link_hash_table
*) NULL
)
2763 bfd_set_error (bfd_error_no_memory
);
2764 return (struct bfd_link_hash_table
*) NULL
;
2766 if (! NAME(aout
,link_hash_table_init
) (ret
, abfd
,
2767 NAME(aout
,link_hash_newfunc
)))
2770 return (struct bfd_link_hash_table
*) NULL
;
2775 /* Given an a.out BFD, add symbols to the global hash table as
2779 NAME(aout
,link_add_symbols
) (abfd
, info
)
2781 struct bfd_link_info
*info
;
2785 switch (bfd_get_format (abfd
))
2788 return aout_link_add_object_symbols (abfd
, info
);
2790 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
2793 if (! bfd_check_format (first
, bfd_object
))
2795 if (bfd_get_flavour (first
) != bfd_target_aout_flavour
)
2797 /* On Linux, we may have an ELF archive which got recognized
2798 as an a.out archive. Therefore, we treat all archives as
2799 though they were actually of the flavour of their first
2801 return (*first
->xvec
->_bfd_link_add_symbols
) (abfd
, info
);
2803 return _bfd_generic_link_add_archive_symbols
2804 (abfd
, info
, aout_link_check_archive_element
);
2806 bfd_set_error (bfd_error_wrong_format
);
2811 /* Add symbols from an a.out object file. */
2814 aout_link_add_object_symbols (abfd
, info
)
2816 struct bfd_link_info
*info
;
2818 if (! aout_get_external_symbols (abfd
))
2820 if (! aout_link_add_symbols (abfd
, info
))
2822 if (! info
->keep_memory
)
2824 if (! aout_link_free_symbols (abfd
))
2830 /* Check a single archive element to see if we need to include it in
2831 the link. *PNEEDED is set according to whether this element is
2832 needed in the link or not. This is called from
2833 _bfd_generic_link_add_archive_symbols. */
2836 aout_link_check_archive_element (abfd
, info
, pneeded
)
2838 struct bfd_link_info
*info
;
2841 if (! aout_get_external_symbols (abfd
))
2844 if (! aout_link_check_ar_symbols (abfd
, info
, pneeded
))
2849 if (! aout_link_add_symbols (abfd
, info
))
2853 if (! info
->keep_memory
|| ! *pneeded
)
2855 if (! aout_link_free_symbols (abfd
))
2862 /* Free up the internal symbols read from an a.out file. */
2865 aout_link_free_symbols (abfd
)
2868 if (obj_aout_external_syms (abfd
) != (struct external_nlist
*) NULL
)
2870 free ((PTR
) obj_aout_external_syms (abfd
));
2871 obj_aout_external_syms (abfd
) = (struct external_nlist
*) NULL
;
2873 if (obj_aout_external_strings (abfd
) != (char *) NULL
)
2875 free ((PTR
) obj_aout_external_strings (abfd
));
2876 obj_aout_external_strings (abfd
) = (char *) NULL
;
2881 /* Look through the internal symbols to see if this object file should
2882 be included in the link. We should include this object file if it
2883 defines any symbols which are currently undefined. If this object
2884 file defines a common symbol, then we may adjust the size of the
2885 known symbol but we do not include the object file in the link
2886 (unless there is some other reason to include it). */
2889 aout_link_check_ar_symbols (abfd
, info
, pneeded
)
2891 struct bfd_link_info
*info
;
2894 register struct external_nlist
*p
;
2895 struct external_nlist
*pend
;
2900 /* Look through all the symbols. */
2901 p
= obj_aout_external_syms (abfd
);
2902 pend
= p
+ obj_aout_external_sym_count (abfd
);
2903 strings
= obj_aout_external_strings (abfd
);
2904 for (; p
< pend
; p
++)
2906 int type
= bfd_h_get_8 (abfd
, p
->e_type
);
2908 struct bfd_link_hash_entry
*h
;
2910 /* Ignore symbols that are not externally visible. This is an
2911 optimization only, as we check the type more thoroughly
2913 if (((type
& N_EXT
) == 0
2914 || (type
& N_STAB
) != 0
2921 if (type
== N_WARNING
2927 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2928 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
2930 /* We are only interested in symbols that are currently
2931 undefined or common. */
2932 if (h
== (struct bfd_link_hash_entry
*) NULL
2933 || (h
->type
!= bfd_link_hash_undefined
2934 && h
->type
!= bfd_link_hash_common
))
2936 if (type
== (N_INDR
| N_EXT
))
2941 if (type
== (N_TEXT
| N_EXT
)
2942 || type
== (N_DATA
| N_EXT
)
2943 || type
== (N_BSS
| N_EXT
)
2944 || type
== (N_ABS
| N_EXT
)
2945 || type
== (N_INDR
| N_EXT
))
2947 /* This object file defines this symbol. We must link it
2948 in. This is true regardless of whether the current
2949 definition of the symbol is undefined or common. If the
2950 current definition is common, we have a case in which we
2951 have already seen an object file including
2953 and this object file from the archive includes
2955 In such a case we must include this object file.
2957 FIXME: The SunOS 4.1.3 linker will pull in the archive
2958 element if the symbol is defined in the .data section,
2959 but not if it is defined in the .text section. That
2960 seems a bit crazy to me, and I haven't implemented it.
2961 However, it might be correct. */
2962 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
2968 if (type
== (N_UNDF
| N_EXT
))
2972 value
= GET_WORD (abfd
, p
->e_value
);
2975 /* This symbol is common in the object from the archive
2977 if (h
->type
== bfd_link_hash_undefined
)
2982 symbfd
= h
->u
.undef
.abfd
;
2983 if (symbfd
== (bfd
*) NULL
)
2985 /* This symbol was created as undefined from
2986 outside BFD. We assume that we should link
2987 in the object file. This is done for the -u
2988 option in the linker. */
2989 if (! (*info
->callbacks
->add_archive_element
) (info
,
2996 /* Turn the current link symbol into a common
2997 symbol. It is already on the undefs list. */
2998 h
->type
= bfd_link_hash_common
;
2999 h
->u
.c
.p
= ((struct bfd_link_hash_common_entry
*)
3000 bfd_hash_allocate (&info
->hash
->table
,
3001 sizeof (struct bfd_link_hash_common_entry
)));
3002 if (h
->u
.c
.p
== NULL
)
3005 h
->u
.c
.size
= value
;
3007 /* FIXME: This isn't quite right. The maximum
3008 alignment of a common symbol should be set by the
3009 architecture of the output file, not of the input
3011 power
= bfd_log2 (value
);
3012 if (power
> bfd_get_arch_info (abfd
)->section_align_power
)
3013 power
= bfd_get_arch_info (abfd
)->section_align_power
;
3014 h
->u
.c
.p
->alignment_power
= power
;
3016 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
,
3021 /* Adjust the size of the common symbol if
3023 if (value
> h
->u
.c
.size
)
3024 h
->u
.c
.size
= value
;
3034 /* This symbol is weak but defined. We must pull it in if
3035 the current link symbol is undefined, but we don't want
3036 it if the current link symbol is common. */
3037 if (h
->type
== bfd_link_hash_undefined
)
3039 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
3047 /* We do not need this object file. */
3051 /* Add all symbols from an object file to the hash table. */
3054 aout_link_add_symbols (abfd
, info
)
3056 struct bfd_link_info
*info
;
3058 boolean (*add_one_symbol
) PARAMS ((struct bfd_link_info
*, bfd
*,
3059 const char *, flagword
, asection
*,
3060 bfd_vma
, const char *, boolean
,
3062 struct bfd_link_hash_entry
**));
3063 bfd_size_type sym_count
;
3066 struct aout_link_hash_entry
**sym_hash
;
3067 register struct external_nlist
*p
;
3068 struct external_nlist
*pend
;
3070 sym_count
= obj_aout_external_sym_count (abfd
);
3071 strings
= obj_aout_external_strings (abfd
);
3072 if (info
->keep_memory
)
3077 /* We keep a list of the linker hash table entries that correspond
3078 to particular symbols. We could just look them up in the hash
3079 table, but keeping the list is more efficient. Perhaps this
3080 should be conditional on info->keep_memory. */
3081 sym_hash
= ((struct aout_link_hash_entry
**)
3084 * sizeof (struct aout_link_hash_entry
*))));
3085 if (sym_hash
== NULL
&& sym_count
!= 0)
3087 bfd_set_error (bfd_error_no_memory
);
3090 obj_aout_sym_hashes (abfd
) = sym_hash
;
3092 if ((abfd
->flags
& DYNAMIC
) != 0
3093 && aout_backend_info (abfd
)->add_dynamic_symbols
!= NULL
)
3095 if (! (*aout_backend_info (abfd
)->add_dynamic_symbols
) (abfd
, info
))
3099 add_one_symbol
= aout_backend_info (abfd
)->add_one_symbol
;
3100 if (add_one_symbol
== NULL
)
3101 add_one_symbol
= _bfd_generic_link_add_one_symbol
;
3103 p
= obj_aout_external_syms (abfd
);
3104 pend
= p
+ sym_count
;
3105 for (; p
< pend
; p
++, sym_hash
++)
3116 type
= bfd_h_get_8 (abfd
, p
->e_type
);
3118 /* Ignore debugging symbols. */
3119 if ((type
& N_STAB
) != 0)
3122 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3123 value
= GET_WORD (abfd
, p
->e_value
);
3140 /* Ignore symbols that are not externally visible. */
3143 /* Ignore local indirect symbol. */
3148 case N_UNDF
| N_EXT
:
3151 section
= bfd_und_section_ptr
;
3155 section
= bfd_com_section_ptr
;
3158 section
= bfd_abs_section_ptr
;
3160 case N_TEXT
| N_EXT
:
3161 section
= obj_textsec (abfd
);
3162 value
-= bfd_get_section_vma (abfd
, section
);
3164 case N_DATA
| N_EXT
:
3165 case N_SETV
| N_EXT
:
3166 /* Treat N_SETV symbols as N_DATA symbol; see comment in
3167 translate_from_native_sym_flags. */
3168 section
= obj_datasec (abfd
);
3169 value
-= bfd_get_section_vma (abfd
, section
);
3172 section
= obj_bsssec (abfd
);
3173 value
-= bfd_get_section_vma (abfd
, section
);
3175 case N_INDR
| N_EXT
:
3176 /* An indirect symbol. The next symbol is the symbol
3177 which this one really is. */
3178 BFD_ASSERT (p
+ 1 < pend
);
3180 string
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3181 section
= bfd_ind_section_ptr
;
3182 flags
|= BSF_INDIRECT
;
3184 case N_COMM
| N_EXT
:
3185 section
= bfd_com_section_ptr
;
3187 case N_SETA
: case N_SETA
| N_EXT
:
3188 section
= bfd_abs_section_ptr
;
3189 flags
|= BSF_CONSTRUCTOR
;
3191 case N_SETT
: case N_SETT
| N_EXT
:
3192 section
= obj_textsec (abfd
);
3193 flags
|= BSF_CONSTRUCTOR
;
3194 value
-= bfd_get_section_vma (abfd
, section
);
3196 case N_SETD
: case N_SETD
| N_EXT
:
3197 section
= obj_datasec (abfd
);
3198 flags
|= BSF_CONSTRUCTOR
;
3199 value
-= bfd_get_section_vma (abfd
, section
);
3201 case N_SETB
: case N_SETB
| N_EXT
:
3202 section
= obj_bsssec (abfd
);
3203 flags
|= BSF_CONSTRUCTOR
;
3204 value
-= bfd_get_section_vma (abfd
, section
);
3207 /* A warning symbol. The next symbol is the one to warn
3209 BFD_ASSERT (p
+ 1 < pend
);
3212 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3213 section
= bfd_und_section_ptr
;
3214 flags
|= BSF_WARNING
;
3217 section
= bfd_und_section_ptr
;
3221 section
= bfd_abs_section_ptr
;
3225 section
= obj_textsec (abfd
);
3226 value
-= bfd_get_section_vma (abfd
, section
);
3230 section
= obj_datasec (abfd
);
3231 value
-= bfd_get_section_vma (abfd
, section
);
3235 section
= obj_bsssec (abfd
);
3236 value
-= bfd_get_section_vma (abfd
, section
);
3241 if (! ((*add_one_symbol
)
3242 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, false,
3243 (struct bfd_link_hash_entry
**) sym_hash
)))
3246 /* Restrict the maximum alignment of a common symbol based on
3247 the architecture, since a.out has no way to represent
3248 alignment requirements of a section in a .o file. FIXME:
3249 This isn't quite right: it should use the architecture of the
3250 output file, not the input files. */
3251 if ((*sym_hash
)->root
.type
== bfd_link_hash_common
3252 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
>
3253 bfd_get_arch_info (abfd
)->section_align_power
))
3254 (*sym_hash
)->root
.u
.c
.p
->alignment_power
=
3255 bfd_get_arch_info (abfd
)->section_align_power
;
3257 /* If this is a set symbol, and we are not building sets, then
3258 it is possible for the hash entry to not have been set. In
3259 such a case, treat the symbol as not globally defined. */
3260 if ((*sym_hash
)->root
.type
== bfd_link_hash_new
)
3262 BFD_ASSERT ((flags
& BSF_CONSTRUCTOR
) != 0);
3266 if (type
== (N_INDR
| N_EXT
) || type
== N_WARNING
)
3273 /* During the final link step we need to pass around a bunch of
3274 information, so we do it in an instance of this structure. */
3276 struct aout_final_link_info
3278 /* General link information. */
3279 struct bfd_link_info
*info
;
3282 /* Reloc file positions. */
3283 file_ptr treloff
, dreloff
;
3284 /* File position of symbols. */
3287 struct bfd_strtab_hash
*strtab
;
3288 /* A buffer large enough to hold the contents of any section. */
3290 /* A buffer large enough to hold the relocs of any section. */
3292 /* A buffer large enough to hold the symbol map of any input BFD. */
3294 /* A buffer large enough to hold output symbols of any input BFD. */
3295 struct external_nlist
*output_syms
;
3298 static boolean aout_link_input_bfd
3299 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
));
3300 static boolean aout_link_write_symbols
3301 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
));
3302 static boolean aout_link_write_other_symbol
3303 PARAMS ((struct aout_link_hash_entry
*, PTR
));
3304 static boolean aout_link_input_section
3305 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
,
3306 asection
*input_section
, file_ptr
*reloff_ptr
,
3307 bfd_size_type rel_size
));
3308 static boolean aout_link_input_section_std
3309 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
,
3310 asection
*input_section
, struct reloc_std_external
*,
3311 bfd_size_type rel_size
, bfd_byte
*contents
));
3312 static boolean aout_link_input_section_ext
3313 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
,
3314 asection
*input_section
, struct reloc_ext_external
*,
3315 bfd_size_type rel_size
, bfd_byte
*contents
));
3316 static INLINE asection
*aout_reloc_index_to_section
3317 PARAMS ((bfd
*, int));
3318 static boolean aout_link_reloc_link_order
3319 PARAMS ((struct aout_final_link_info
*, asection
*,
3320 struct bfd_link_order
*));
3322 /* Do the final link step. This is called on the output BFD. The
3323 INFO structure should point to a list of BFDs linked through the
3324 link_next field which can be used to find each BFD which takes part
3325 in the output. Also, each section in ABFD should point to a list
3326 of bfd_link_order structures which list all the input sections for
3327 the output section. */
3330 NAME(aout
,final_link
) (abfd
, info
, callback
)
3332 struct bfd_link_info
*info
;
3333 void (*callback
) PARAMS ((bfd
*, file_ptr
*, file_ptr
*, file_ptr
*));
3335 struct aout_final_link_info aout_info
;
3337 bfd_size_type trsize
, drsize
;
3338 size_t max_contents_size
;
3339 size_t max_relocs_size
;
3340 size_t max_sym_count
;
3341 bfd_size_type text_size
;
3343 register struct bfd_link_order
*p
;
3345 boolean have_link_order_relocs
;
3347 aout_info
.info
= info
;
3348 aout_info
.output_bfd
= abfd
;
3349 aout_info
.contents
= NULL
;
3350 aout_info
.relocs
= NULL
;
3352 /* Figure out the largest section size. Also, if generating
3353 relocateable output, count the relocs. */
3356 max_contents_size
= 0;
3357 max_relocs_size
= 0;
3359 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3363 if (info
->relocateable
)
3365 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3367 trsize
+= exec_hdr (sub
)->a_trsize
;
3368 drsize
+= exec_hdr (sub
)->a_drsize
;
3372 /* FIXME: We need to identify the .text and .data sections
3373 and call get_reloc_upper_bound and canonicalize_reloc to
3374 work out the number of relocs needed, and then multiply
3375 by the reloc size. */
3380 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
3382 sz
= bfd_section_size (sub
, obj_textsec (sub
));
3383 if (sz
> max_contents_size
)
3384 max_contents_size
= sz
;
3385 sz
= bfd_section_size (sub
, obj_datasec (sub
));
3386 if (sz
> max_contents_size
)
3387 max_contents_size
= sz
;
3389 sz
= exec_hdr (sub
)->a_trsize
;
3390 if (sz
> max_relocs_size
)
3391 max_relocs_size
= sz
;
3392 sz
= exec_hdr (sub
)->a_drsize
;
3393 if (sz
> max_relocs_size
)
3394 max_relocs_size
= sz
;
3396 sz
= obj_aout_external_sym_count (sub
);
3397 if (sz
> max_sym_count
)
3402 if (info
->relocateable
)
3404 if (obj_textsec (abfd
) != (asection
*) NULL
)
3405 trsize
+= (_bfd_count_link_order_relocs (obj_textsec (abfd
)
3407 * obj_reloc_entry_size (abfd
));
3408 if (obj_datasec (abfd
) != (asection
*) NULL
)
3409 drsize
+= (_bfd_count_link_order_relocs (obj_datasec (abfd
)
3411 * obj_reloc_entry_size (abfd
));
3414 exec_hdr (abfd
)->a_trsize
= trsize
;
3415 exec_hdr (abfd
)->a_drsize
= drsize
;
3417 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
3419 /* Adjust the section sizes and vmas according to the magic number.
3420 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3421 filepos for each section. */
3422 if (! NAME(aout
,adjust_sizes_and_vmas
) (abfd
, &text_size
, &text_end
))
3425 /* The relocation and symbol file positions differ among a.out
3426 targets. We are passed a callback routine from the backend
3427 specific code to handle this.
3428 FIXME: At this point we do not know how much space the symbol
3429 table will require. This will not work for any (nonstandard)
3430 a.out target that needs to know the symbol table size before it
3431 can compute the relocation file positions. This may or may not
3432 be the case for the hp300hpux target, for example. */
3433 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
3435 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
3436 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
3437 obj_sym_filepos (abfd
) = aout_info
.symoff
;
3439 /* We keep a count of the symbols as we output them. */
3440 obj_aout_external_sym_count (abfd
) = 0;
3442 /* We accumulate the string table as we write out the symbols. */
3443 aout_info
.strtab
= _bfd_stringtab_init ();
3444 if (aout_info
.strtab
== NULL
)
3447 /* Allocate buffers to hold section contents and relocs. */
3448 aout_info
.contents
= (bfd_byte
*) malloc (max_contents_size
);
3449 aout_info
.relocs
= (PTR
) malloc (max_relocs_size
);
3450 aout_info
.symbol_map
= (int *) malloc (max_sym_count
* sizeof (int *));
3451 aout_info
.output_syms
= ((struct external_nlist
*)
3452 malloc ((max_sym_count
+ 1)
3453 * sizeof (struct external_nlist
)));
3454 if ((aout_info
.contents
== NULL
&& max_contents_size
!= 0)
3455 || (aout_info
.relocs
== NULL
&& max_relocs_size
!= 0)
3456 || (aout_info
.symbol_map
== NULL
&& max_sym_count
!= 0)
3457 || aout_info
.output_syms
== NULL
)
3459 bfd_set_error (bfd_error_no_memory
);
3463 /* The most time efficient way to do the link would be to read all
3464 the input object files into memory and then sort out the
3465 information into the output file. Unfortunately, that will
3466 probably use too much memory. Another method would be to step
3467 through everything that composes the text section and write it
3468 out, and then everything that composes the data section and write
3469 it out, and then write out the relocs, and then write out the
3470 symbols. Unfortunately, that requires reading stuff from each
3471 input file several times, and we will not be able to keep all the
3472 input files open simultaneously, and reopening them will be slow.
3474 What we do is basically process one input file at a time. We do
3475 everything we need to do with an input file once--copy over the
3476 section contents, handle the relocation information, and write
3477 out the symbols--and then we throw away the information we read
3478 from it. This approach requires a lot of lseeks of the output
3479 file, which is unfortunate but still faster than reopening a lot
3482 We use the output_has_begun field of the input BFDs to see
3483 whether we have already handled it. */
3484 for (sub
= info
->input_bfds
; sub
!= (bfd
*) NULL
; sub
= sub
->link_next
)
3485 sub
->output_has_begun
= false;
3487 have_link_order_relocs
= false;
3488 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3490 for (p
= o
->link_order_head
;
3491 p
!= (struct bfd_link_order
*) NULL
;
3494 if (p
->type
== bfd_indirect_link_order
3495 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
3496 == bfd_target_aout_flavour
))
3500 input_bfd
= p
->u
.indirect
.section
->owner
;
3501 if (! input_bfd
->output_has_begun
)
3503 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
3505 input_bfd
->output_has_begun
= true;
3508 else if (p
->type
== bfd_section_reloc_link_order
3509 || p
->type
== bfd_symbol_reloc_link_order
)
3511 /* These are handled below. */
3512 have_link_order_relocs
= true;
3516 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3522 /* Write out any symbols that we have not already written out. */
3523 aout_link_hash_traverse (aout_hash_table (info
),
3524 aout_link_write_other_symbol
,
3527 /* Now handle any relocs we were asked to create by the linker.
3528 These did not come from any input file. We must do these after
3529 we have written out all the symbols, so that we know the symbol
3531 if (have_link_order_relocs
)
3533 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3535 for (p
= o
->link_order_head
;
3536 p
!= (struct bfd_link_order
*) NULL
;
3539 if (p
->type
== bfd_section_reloc_link_order
3540 || p
->type
== bfd_symbol_reloc_link_order
)
3542 if (! aout_link_reloc_link_order (&aout_info
, o
, p
))
3549 if (aout_info
.contents
!= NULL
)
3551 free (aout_info
.contents
);
3552 aout_info
.contents
= NULL
;
3554 if (aout_info
.relocs
!= NULL
)
3556 free (aout_info
.relocs
);
3557 aout_info
.relocs
= NULL
;
3559 if (aout_info
.symbol_map
!= NULL
)
3561 free (aout_info
.symbol_map
);
3562 aout_info
.symbol_map
= NULL
;
3564 if (aout_info
.output_syms
!= NULL
)
3566 free (aout_info
.output_syms
);
3567 aout_info
.output_syms
= NULL
;
3570 /* Finish up any dynamic linking we may be doing. */
3571 if (aout_backend_info (abfd
)->finish_dynamic_link
!= NULL
)
3573 if (! (*aout_backend_info (abfd
)->finish_dynamic_link
) (abfd
, info
))
3577 /* Update the header information. */
3578 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
3579 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
3580 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
3581 obj_textsec (abfd
)->reloc_count
=
3582 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
3583 obj_datasec (abfd
)->reloc_count
=
3584 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
3586 /* Write out the string table. */
3587 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0)
3589 return emit_stringtab (abfd
, aout_info
.strtab
);
3592 if (aout_info
.contents
!= NULL
)
3593 free (aout_info
.contents
);
3594 if (aout_info
.relocs
!= NULL
)
3595 free (aout_info
.relocs
);
3596 if (aout_info
.symbol_map
!= NULL
)
3597 free (aout_info
.symbol_map
);
3598 if (aout_info
.output_syms
!= NULL
)
3599 free (aout_info
.output_syms
);
3603 /* Link an a.out input BFD into the output file. */
3606 aout_link_input_bfd (finfo
, input_bfd
)
3607 struct aout_final_link_info
*finfo
;
3610 bfd_size_type sym_count
;
3612 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
3614 /* If this is a dynamic object, it may need special handling. */
3615 if ((input_bfd
->flags
& DYNAMIC
) != 0
3616 && aout_backend_info (input_bfd
)->link_dynamic_object
!= NULL
)
3618 return ((*aout_backend_info (input_bfd
)->link_dynamic_object
)
3619 (finfo
->info
, input_bfd
));
3622 /* Get the symbols. We probably have them already, unless
3623 finfo->info->keep_memory is false. */
3624 if (! aout_get_external_symbols (input_bfd
))
3627 sym_count
= obj_aout_external_sym_count (input_bfd
);
3629 /* Write out the symbols and get a map of the new indices. The map
3630 is placed into finfo->symbol_map. */
3631 if (! aout_link_write_symbols (finfo
, input_bfd
))
3634 /* Relocate and write out the sections. These functions use the
3635 symbol map created by aout_link_write_symbols. */
3636 if (! aout_link_input_section (finfo
, input_bfd
,
3637 obj_textsec (input_bfd
),
3639 exec_hdr (input_bfd
)->a_trsize
)
3640 || ! aout_link_input_section (finfo
, input_bfd
,
3641 obj_datasec (input_bfd
),
3643 exec_hdr (input_bfd
)->a_drsize
))
3646 /* If we are not keeping memory, we don't need the symbols any
3647 longer. We still need them if we are keeping memory, because the
3648 strings in the hash table point into them. */
3649 if (! finfo
->info
->keep_memory
)
3651 if (! aout_link_free_symbols (input_bfd
))
3658 /* Adjust and write out the symbols for an a.out file. Set the new
3659 symbol indices into a symbol_map. */
3662 aout_link_write_symbols (finfo
, input_bfd
)
3663 struct aout_final_link_info
*finfo
;
3667 bfd_size_type sym_count
;
3669 enum bfd_link_strip strip
;
3670 enum bfd_link_discard discard
;
3671 struct external_nlist
*outsym
;
3672 bfd_size_type strtab_index
;
3673 register struct external_nlist
*sym
;
3674 struct external_nlist
*sym_end
;
3675 struct aout_link_hash_entry
**sym_hash
;
3680 output_bfd
= finfo
->output_bfd
;
3681 sym_count
= obj_aout_external_sym_count (input_bfd
);
3682 strings
= obj_aout_external_strings (input_bfd
);
3683 strip
= finfo
->info
->strip
;
3684 discard
= finfo
->info
->discard
;
3685 outsym
= finfo
->output_syms
;
3687 /* First write out a symbol for this object file, unless we are
3688 discarding such symbols. */
3689 if (strip
!= strip_all
3690 && (strip
!= strip_some
3691 || bfd_hash_lookup (finfo
->info
->keep_hash
, input_bfd
->filename
,
3692 false, false) != NULL
)
3693 && discard
!= discard_all
)
3695 bfd_h_put_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
3696 bfd_h_put_8 (output_bfd
, 0, outsym
->e_other
);
3697 bfd_h_put_16 (output_bfd
, (bfd_vma
) 0, outsym
->e_desc
);
3698 strtab_index
= add_to_stringtab (output_bfd
, finfo
->strtab
,
3699 input_bfd
->filename
, false);
3700 if (strtab_index
== (bfd_size_type
) -1)
3702 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
3703 PUT_WORD (output_bfd
,
3704 (bfd_get_section_vma (output_bfd
,
3705 obj_textsec (input_bfd
)->output_section
)
3706 + obj_textsec (input_bfd
)->output_offset
),
3708 ++obj_aout_external_sym_count (output_bfd
);
3714 sym
= obj_aout_external_syms (input_bfd
);
3715 sym_end
= sym
+ sym_count
;
3716 sym_hash
= obj_aout_sym_hashes (input_bfd
);
3717 symbol_map
= finfo
->symbol_map
;
3718 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
3722 struct aout_link_hash_entry
*h
;
3730 type
= bfd_h_get_8 (input_bfd
, sym
->e_type
);
3731 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
3737 /* Pass this symbol through. It is the target of an
3738 indirect or warning symbol. */
3739 val
= GET_WORD (input_bfd
, sym
->e_value
);
3744 /* Skip this symbol, which is the target of an indirect
3745 symbol that we have changed to no longer be an indirect
3752 struct aout_link_hash_entry
*hresolve
;
3754 /* We have saved the hash table entry for this symbol, if
3755 there is one. Note that we could just look it up again
3756 in the hash table, provided we first check that it is an
3760 /* If this is an indirect or warning symbol, then change
3761 hresolve to the base symbol. We also change *sym_hash so
3762 that the relocation routines relocate against the real
3765 if (h
!= (struct aout_link_hash_entry
*) NULL
3766 && (h
->root
.type
== bfd_link_hash_indirect
3767 || h
->root
.type
== bfd_link_hash_warning
))
3769 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
3770 while (hresolve
->root
.type
== bfd_link_hash_indirect
3771 || hresolve
->root
.type
== bfd_link_hash_warning
)
3772 hresolve
= ((struct aout_link_hash_entry
*)
3773 hresolve
->root
.u
.i
.link
);
3774 *sym_hash
= hresolve
;
3777 /* If the symbol has already been written out, skip it. */
3778 if (h
!= (struct aout_link_hash_entry
*) NULL
3779 && h
->root
.type
!= bfd_link_hash_warning
3782 if ((type
& N_TYPE
) == N_INDR
3783 || type
== N_WARNING
)
3785 *symbol_map
= h
->indx
;
3789 /* See if we are stripping this symbol. */
3795 case strip_debugger
:
3796 if ((type
& N_STAB
) != 0)
3800 if (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
3810 if (h
!= (struct aout_link_hash_entry
*) NULL
)
3815 /* Get the value of the symbol. */
3816 if ((type
& N_TYPE
) == N_TEXT
3818 symsec
= obj_textsec (input_bfd
);
3819 else if ((type
& N_TYPE
) == N_DATA
3821 symsec
= obj_datasec (input_bfd
);
3822 else if ((type
& N_TYPE
) == N_BSS
3824 symsec
= obj_bsssec (input_bfd
);
3825 else if ((type
& N_TYPE
) == N_ABS
3827 symsec
= bfd_abs_section_ptr
;
3828 else if (((type
& N_TYPE
) == N_INDR
3829 && (hresolve
== (struct aout_link_hash_entry
*) NULL
3830 || (hresolve
->root
.type
!= bfd_link_hash_defined
3831 && hresolve
->root
.type
!= bfd_link_hash_defweak
3832 && hresolve
->root
.type
!= bfd_link_hash_common
)))
3833 || type
== N_WARNING
)
3835 /* Pass the next symbol through unchanged. The
3836 condition above for indirect symbols is so that if
3837 the indirect symbol was defined, we output it with
3838 the correct definition so the debugger will
3841 val
= GET_WORD (input_bfd
, sym
->e_value
);
3844 else if ((type
& N_STAB
) != 0)
3846 val
= GET_WORD (input_bfd
, sym
->e_value
);
3851 /* If we get here with an indirect symbol, it means that
3852 we are outputting it with a real definition. In such
3853 a case we do not want to output the next symbol,
3854 which is the target of the indirection. */
3855 if ((type
& N_TYPE
) == N_INDR
)
3860 /* We need to get the value from the hash table. We use
3861 hresolve so that if we have defined an indirect
3862 symbol we output the final definition. */
3863 if (h
== (struct aout_link_hash_entry
*) NULL
)
3865 switch (type
& N_TYPE
)
3868 symsec
= obj_textsec (input_bfd
);
3871 symsec
= obj_datasec (input_bfd
);
3874 symsec
= obj_bsssec (input_bfd
);
3877 symsec
= bfd_abs_section_ptr
;
3884 else if (hresolve
->root
.type
== bfd_link_hash_defined
3885 || hresolve
->root
.type
== bfd_link_hash_defweak
)
3887 asection
*input_section
;
3888 asection
*output_section
;
3890 /* This case usually means a common symbol which was
3891 turned into a defined symbol. */
3892 input_section
= hresolve
->root
.u
.def
.section
;
3893 output_section
= input_section
->output_section
;
3894 BFD_ASSERT (bfd_is_abs_section (output_section
)
3895 || output_section
->owner
== output_bfd
);
3896 val
= (hresolve
->root
.u
.def
.value
3897 + bfd_get_section_vma (output_bfd
, output_section
)
3898 + input_section
->output_offset
);
3900 /* Get the correct type based on the section. If
3901 this is a constructed set, force it to be
3902 globally visible. */
3911 if (output_section
== obj_textsec (output_bfd
))
3912 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
3915 else if (output_section
== obj_datasec (output_bfd
))
3916 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
3919 else if (output_section
== obj_bsssec (output_bfd
))
3920 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
3924 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
3928 else if (hresolve
->root
.type
== bfd_link_hash_common
)
3929 val
= hresolve
->root
.u
.c
.size
;
3930 else if (hresolve
->root
.type
== bfd_link_hash_undefweak
)
3938 if (symsec
!= (asection
*) NULL
)
3939 val
= (symsec
->output_section
->vma
3940 + symsec
->output_offset
3941 + (GET_WORD (input_bfd
, sym
->e_value
)
3944 /* If this is a global symbol set the written flag, and if
3945 it is a local symbol see if we should discard it. */
3946 if (h
!= (struct aout_link_hash_entry
*) NULL
)
3949 h
->indx
= obj_aout_external_sym_count (output_bfd
);
3951 else if ((type
& N_TYPE
) != N_SETT
3952 && (type
& N_TYPE
) != N_SETD
3953 && (type
& N_TYPE
) != N_SETB
3954 && (type
& N_TYPE
) != N_SETA
)
3961 if (*name
== *finfo
->info
->lprefix
3962 && (finfo
->info
->lprefix_len
== 1
3963 || strncmp (name
, finfo
->info
->lprefix
,
3964 finfo
->info
->lprefix_len
) == 0))
3979 /* Copy this symbol into the list of symbols we are going to
3981 bfd_h_put_8 (output_bfd
, type
, outsym
->e_type
);
3982 bfd_h_put_8 (output_bfd
, bfd_h_get_8 (input_bfd
, sym
->e_other
),
3984 bfd_h_put_16 (output_bfd
, bfd_h_get_16 (input_bfd
, sym
->e_desc
),
3987 if (! finfo
->info
->keep_memory
)
3989 /* name points into a string table which we are going to
3990 free. If there is a hash table entry, use that string.
3991 Otherwise, copy name into memory. */
3992 if (h
!= (struct aout_link_hash_entry
*) NULL
)
3993 name
= h
->root
.root
.string
;
3997 strtab_index
= add_to_stringtab (output_bfd
, finfo
->strtab
,
3999 if (strtab_index
== (bfd_size_type
) -1)
4001 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4002 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
4003 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
4004 ++obj_aout_external_sym_count (output_bfd
);
4008 /* Write out the output symbols we have just constructed. */
4009 if (outsym
> finfo
->output_syms
)
4011 bfd_size_type outsym_count
;
4013 if (bfd_seek (output_bfd
, finfo
->symoff
, SEEK_SET
) != 0)
4015 outsym_count
= outsym
- finfo
->output_syms
;
4016 if (bfd_write ((PTR
) finfo
->output_syms
,
4017 (bfd_size_type
) EXTERNAL_NLIST_SIZE
,
4018 (bfd_size_type
) outsym_count
, output_bfd
)
4019 != outsym_count
* EXTERNAL_NLIST_SIZE
)
4021 finfo
->symoff
+= outsym_count
* EXTERNAL_NLIST_SIZE
;
4027 /* Write out a symbol that was not associated with an a.out input
4031 aout_link_write_other_symbol (h
, data
)
4032 struct aout_link_hash_entry
*h
;
4035 struct aout_final_link_info
*finfo
= (struct aout_final_link_info
*) data
;
4039 struct external_nlist outsym
;
4042 output_bfd
= finfo
->output_bfd
;
4044 if (aout_backend_info (output_bfd
)->write_dynamic_symbol
!= NULL
)
4046 if (! ((*aout_backend_info (output_bfd
)->write_dynamic_symbol
)
4047 (output_bfd
, finfo
->info
, h
)))
4049 /* FIXME: No way to handle errors. */
4059 /* An indx of -2 means the symbol must be written. */
4061 && (finfo
->info
->strip
== strip_all
4062 || (finfo
->info
->strip
== strip_some
4063 && bfd_hash_lookup (finfo
->info
->keep_hash
, h
->root
.root
.string
,
4064 false, false) == NULL
)))
4067 switch (h
->root
.type
)
4071 /* Avoid variable not initialized warnings. */
4073 case bfd_link_hash_new
:
4074 /* This can happen for set symbols when sets are not being
4077 case bfd_link_hash_undefined
:
4078 type
= N_UNDF
| N_EXT
;
4081 case bfd_link_hash_defined
:
4082 case bfd_link_hash_defweak
:
4086 sec
= h
->root
.u
.def
.section
->output_section
;
4087 BFD_ASSERT (bfd_is_abs_section (sec
)
4088 || sec
->owner
== output_bfd
);
4089 if (sec
== obj_textsec (output_bfd
))
4090 type
= h
->root
.type
== bfd_link_hash_defined
? N_TEXT
: N_WEAKT
;
4091 else if (sec
== obj_datasec (output_bfd
))
4092 type
= h
->root
.type
== bfd_link_hash_defined
? N_DATA
: N_WEAKD
;
4093 else if (sec
== obj_bsssec (output_bfd
))
4094 type
= h
->root
.type
== bfd_link_hash_defined
? N_BSS
: N_WEAKB
;
4096 type
= h
->root
.type
== bfd_link_hash_defined
? N_ABS
: N_WEAKA
;
4098 val
= (h
->root
.u
.def
.value
4100 + h
->root
.u
.def
.section
->output_offset
);
4103 case bfd_link_hash_common
:
4104 type
= N_UNDF
| N_EXT
;
4105 val
= h
->root
.u
.c
.size
;
4107 case bfd_link_hash_undefweak
:
4110 case bfd_link_hash_indirect
:
4111 case bfd_link_hash_warning
:
4112 /* FIXME: Ignore these for now. The circumstances under which
4113 they should be written out are not clear to me. */
4117 bfd_h_put_8 (output_bfd
, type
, outsym
.e_type
);
4118 bfd_h_put_8 (output_bfd
, 0, outsym
.e_other
);
4119 bfd_h_put_16 (output_bfd
, 0, outsym
.e_desc
);
4120 indx
= add_to_stringtab (output_bfd
, finfo
->strtab
, h
->root
.root
.string
,
4122 if (indx
== (bfd_size_type
) -1)
4124 /* FIXME: No way to handle errors. */
4127 PUT_WORD (output_bfd
, indx
, outsym
.e_strx
);
4128 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
4130 if (bfd_seek (output_bfd
, finfo
->symoff
, SEEK_SET
) != 0
4131 || bfd_write ((PTR
) &outsym
, (bfd_size_type
) EXTERNAL_NLIST_SIZE
,
4132 (bfd_size_type
) 1, output_bfd
) != EXTERNAL_NLIST_SIZE
)
4134 /* FIXME: No way to handle errors. */
4138 finfo
->symoff
+= EXTERNAL_NLIST_SIZE
;
4139 h
->indx
= obj_aout_external_sym_count (output_bfd
);
4140 ++obj_aout_external_sym_count (output_bfd
);
4145 /* Link an a.out section into the output file. */
4148 aout_link_input_section (finfo
, input_bfd
, input_section
, reloff_ptr
,
4150 struct aout_final_link_info
*finfo
;
4152 asection
*input_section
;
4153 file_ptr
*reloff_ptr
;
4154 bfd_size_type rel_size
;
4156 bfd_size_type input_size
;
4159 /* Get the section contents. */
4160 input_size
= bfd_section_size (input_bfd
, input_section
);
4161 if (! bfd_get_section_contents (input_bfd
, input_section
,
4162 (PTR
) finfo
->contents
,
4163 (file_ptr
) 0, input_size
))
4166 /* Read in the relocs if we haven't already done it. */
4167 if (aout_section_data (input_section
) != NULL
4168 && aout_section_data (input_section
)->relocs
!= NULL
)
4169 relocs
= aout_section_data (input_section
)->relocs
;
4172 relocs
= finfo
->relocs
;
4175 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
4176 || bfd_read (relocs
, 1, rel_size
, input_bfd
) != rel_size
)
4181 /* Relocate the section contents. */
4182 if (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
)
4184 if (! aout_link_input_section_std (finfo
, input_bfd
, input_section
,
4185 (struct reloc_std_external
*) relocs
,
4186 rel_size
, finfo
->contents
))
4191 if (! aout_link_input_section_ext (finfo
, input_bfd
, input_section
,
4192 (struct reloc_ext_external
*) relocs
,
4193 rel_size
, finfo
->contents
))
4197 /* Write out the section contents. */
4198 if (! bfd_set_section_contents (finfo
->output_bfd
,
4199 input_section
->output_section
,
4200 (PTR
) finfo
->contents
,
4201 input_section
->output_offset
,
4205 /* If we are producing relocateable output, the relocs were
4206 modified, and we now write them out. */
4207 if (finfo
->info
->relocateable
&& rel_size
> 0)
4209 if (bfd_seek (finfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
4211 if (bfd_write (relocs
, (bfd_size_type
) 1, rel_size
, finfo
->output_bfd
)
4214 *reloff_ptr
+= rel_size
;
4216 /* Assert that the relocs have not run into the symbols, and
4217 that if these are the text relocs they have not run into the
4219 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (finfo
->output_bfd
)
4220 && (reloff_ptr
!= &finfo
->treloff
4222 <= obj_datasec (finfo
->output_bfd
)->rel_filepos
)));
4228 /* Get the section corresponding to a reloc index. */
4230 static INLINE asection
*
4231 aout_reloc_index_to_section (abfd
, indx
)
4235 switch (indx
& N_TYPE
)
4238 return obj_textsec (abfd
);
4240 return obj_datasec (abfd
);
4242 return obj_bsssec (abfd
);
4245 return bfd_abs_section_ptr
;
4251 /* Relocate an a.out section using standard a.out relocs. */
4254 aout_link_input_section_std (finfo
, input_bfd
, input_section
, relocs
,
4256 struct aout_final_link_info
*finfo
;
4258 asection
*input_section
;
4259 struct reloc_std_external
*relocs
;
4260 bfd_size_type rel_size
;
4263 boolean (*check_dynamic_reloc
) PARAMS ((struct bfd_link_info
*,
4265 struct aout_link_hash_entry
*,
4268 boolean relocateable
;
4269 struct external_nlist
*syms
;
4271 struct aout_link_hash_entry
**sym_hashes
;
4273 bfd_size_type reloc_count
;
4274 register struct reloc_std_external
*rel
;
4275 struct reloc_std_external
*rel_end
;
4277 output_bfd
= finfo
->output_bfd
;
4278 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
4280 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
);
4281 BFD_ASSERT (input_bfd
->xvec
->header_byteorder_big_p
4282 == output_bfd
->xvec
->header_byteorder_big_p
);
4284 relocateable
= finfo
->info
->relocateable
;
4285 syms
= obj_aout_external_syms (input_bfd
);
4286 strings
= obj_aout_external_strings (input_bfd
);
4287 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
4288 symbol_map
= finfo
->symbol_map
;
4290 reloc_count
= rel_size
/ RELOC_STD_SIZE
;
4292 rel_end
= rel
+ reloc_count
;
4293 for (; rel
< rel_end
; rel
++)
4304 reloc_howto_type
*howto
;
4306 bfd_reloc_status_type r
;
4308 r_addr
= GET_SWORD (input_bfd
, rel
->r_address
);
4310 #ifdef MY_reloc_howto
4311 howto
= MY_reloc_howto(input_bfd
, rel
, r_index
, r_extern
, r_pcrel
);
4313 if (input_bfd
->xvec
->header_byteorder_big_p
)
4315 r_index
= ((rel
->r_index
[0] << 16)
4316 | (rel
->r_index
[1] << 8)
4318 r_extern
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
));
4319 r_pcrel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_PCREL_BIG
));
4320 r_baserel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
4321 r_jmptable
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
4322 r_relative
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_RELATIVE_BIG
));
4323 r_length
= ((rel
->r_type
[0] & RELOC_STD_BITS_LENGTH_BIG
)
4324 >> RELOC_STD_BITS_LENGTH_SH_BIG
);
4328 r_index
= ((rel
->r_index
[2] << 16)
4329 | (rel
->r_index
[1] << 8)
4331 r_extern
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
));
4332 r_pcrel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_PCREL_LITTLE
));
4333 r_baserel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_BASEREL_LITTLE
));
4334 r_jmptable
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_LITTLE
));
4335 r_relative
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_RELATIVE_LITTLE
));
4336 r_length
= ((rel
->r_type
[0] & RELOC_STD_BITS_LENGTH_LITTLE
)
4337 >> RELOC_STD_BITS_LENGTH_SH_LITTLE
);
4340 howto_idx
= r_length
+ 4 * r_pcrel
+ 8 * r_baserel
4341 + 16 * r_jmptable
+ 32 * r_relative
;
4342 BFD_ASSERT (howto_idx
< TABLE_SIZE (howto_table_std
));
4343 howto
= howto_table_std
+ howto_idx
;
4348 /* We are generating a relocateable output file, and must
4349 modify the reloc accordingly. */
4352 struct aout_link_hash_entry
*h
;
4354 /* If we know the symbol this relocation is against,
4355 convert it into a relocation against a section. This
4356 is what the native linker does. */
4357 h
= sym_hashes
[r_index
];
4358 if (h
!= (struct aout_link_hash_entry
*) NULL
4359 && (h
->root
.type
== bfd_link_hash_defined
4360 || h
->root
.type
== bfd_link_hash_defweak
))
4362 asection
*output_section
;
4364 /* Change the r_extern value. */
4365 if (output_bfd
->xvec
->header_byteorder_big_p
)
4366 rel
->r_type
[0] &=~ RELOC_STD_BITS_EXTERN_BIG
;
4368 rel
->r_type
[0] &=~ RELOC_STD_BITS_EXTERN_LITTLE
;
4370 /* Compute a new r_index. */
4371 output_section
= h
->root
.u
.def
.section
->output_section
;
4372 if (output_section
== obj_textsec (output_bfd
))
4374 else if (output_section
== obj_datasec (output_bfd
))
4376 else if (output_section
== obj_bsssec (output_bfd
))
4381 /* Add the symbol value and the section VMA to the
4382 addend stored in the contents. */
4383 relocation
= (h
->root
.u
.def
.value
4384 + output_section
->vma
4385 + h
->root
.u
.def
.section
->output_offset
);
4389 /* We must change r_index according to the symbol
4391 r_index
= symbol_map
[r_index
];
4397 /* We decided to strip this symbol, but it
4398 turns out that we can't. Note that we
4399 lose the other and desc information here.
4400 I don't think that will ever matter for a
4406 if (! aout_link_write_other_symbol (h
,
4416 name
= strings
+ GET_WORD (input_bfd
,
4417 syms
[r_index
].e_strx
);
4418 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
4419 (finfo
->info
, name
, input_bfd
, input_section
,
4429 /* Write out the new r_index value. */
4430 if (output_bfd
->xvec
->header_byteorder_big_p
)
4432 rel
->r_index
[0] = r_index
>> 16;
4433 rel
->r_index
[1] = r_index
>> 8;
4434 rel
->r_index
[2] = r_index
;
4438 rel
->r_index
[2] = r_index
>> 16;
4439 rel
->r_index
[1] = r_index
>> 8;
4440 rel
->r_index
[0] = r_index
;
4447 /* This is a relocation against a section. We must
4448 adjust by the amount that the section moved. */
4449 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4450 relocation
= (section
->output_section
->vma
4451 + section
->output_offset
4455 /* Change the address of the relocation. */
4456 PUT_WORD (output_bfd
,
4457 r_addr
+ input_section
->output_offset
,
4460 /* Adjust a PC relative relocation by removing the reference
4461 to the original address in the section and including the
4462 reference to the new address. */
4464 relocation
-= (input_section
->output_section
->vma
4465 + input_section
->output_offset
4466 - input_section
->vma
);
4468 if (relocation
== 0)
4471 r
= _bfd_relocate_contents (howto
,
4472 input_bfd
, relocation
,
4477 /* We are generating an executable, and must do a full
4481 struct aout_link_hash_entry
*h
;
4483 h
= sym_hashes
[r_index
];
4485 if (check_dynamic_reloc
!= NULL
)
4489 if (! ((*check_dynamic_reloc
)
4490 (finfo
->info
, input_bfd
, input_section
, h
,
4497 if (h
!= (struct aout_link_hash_entry
*) NULL
4498 && (h
->root
.type
== bfd_link_hash_defined
4499 || h
->root
.type
== bfd_link_hash_defweak
))
4501 relocation
= (h
->root
.u
.def
.value
4502 + h
->root
.u
.def
.section
->output_section
->vma
4503 + h
->root
.u
.def
.section
->output_offset
);
4505 else if (h
!= (struct aout_link_hash_entry
*) NULL
4506 && h
->root
.type
== bfd_link_hash_undefweak
)
4512 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
4513 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
4514 (finfo
->info
, name
, input_bfd
, input_section
,
4524 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4525 relocation
= (section
->output_section
->vma
4526 + section
->output_offset
4529 relocation
+= input_section
->vma
;
4532 r
= _bfd_final_link_relocate (howto
,
4533 input_bfd
, input_section
,
4534 contents
, r_addr
, relocation
,
4538 if (r
!= bfd_reloc_ok
)
4543 case bfd_reloc_outofrange
:
4545 case bfd_reloc_overflow
:
4550 name
= strings
+ GET_WORD (input_bfd
,
4551 syms
[r_index
].e_strx
);
4556 s
= aout_reloc_index_to_section (input_bfd
, r_index
);
4557 name
= bfd_section_name (input_bfd
, s
);
4559 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
4560 (finfo
->info
, name
, howto
->name
,
4561 (bfd_vma
) 0, input_bfd
, input_section
, r_addr
)))
4572 /* Relocate an a.out section using extended a.out relocs. */
4575 aout_link_input_section_ext (finfo
, input_bfd
, input_section
, relocs
,
4577 struct aout_final_link_info
*finfo
;
4579 asection
*input_section
;
4580 struct reloc_ext_external
*relocs
;
4581 bfd_size_type rel_size
;
4584 boolean (*check_dynamic_reloc
) PARAMS ((struct bfd_link_info
*,
4586 struct aout_link_hash_entry
*,
4589 boolean relocateable
;
4590 struct external_nlist
*syms
;
4592 struct aout_link_hash_entry
**sym_hashes
;
4594 bfd_size_type reloc_count
;
4595 register struct reloc_ext_external
*rel
;
4596 struct reloc_ext_external
*rel_end
;
4598 output_bfd
= finfo
->output_bfd
;
4599 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
4601 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_EXT_SIZE
);
4602 BFD_ASSERT (input_bfd
->xvec
->header_byteorder_big_p
4603 == output_bfd
->xvec
->header_byteorder_big_p
);
4605 relocateable
= finfo
->info
->relocateable
;
4606 syms
= obj_aout_external_syms (input_bfd
);
4607 strings
= obj_aout_external_strings (input_bfd
);
4608 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
4609 symbol_map
= finfo
->symbol_map
;
4611 reloc_count
= rel_size
/ RELOC_EXT_SIZE
;
4613 rel_end
= rel
+ reloc_count
;
4614 for (; rel
< rel_end
; rel
++)
4623 r_addr
= GET_SWORD (input_bfd
, rel
->r_address
);
4625 if (input_bfd
->xvec
->header_byteorder_big_p
)
4627 r_index
= ((rel
->r_index
[0] << 16)
4628 | (rel
->r_index
[1] << 8)
4630 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
4631 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
4632 >> RELOC_EXT_BITS_TYPE_SH_BIG
);
4636 r_index
= ((rel
->r_index
[2] << 16)
4637 | (rel
->r_index
[1] << 8)
4639 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
4640 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
4641 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
);
4644 r_addend
= GET_SWORD (input_bfd
, rel
->r_addend
);
4646 BFD_ASSERT (r_type
>= 0
4647 && r_type
< TABLE_SIZE (howto_table_ext
));
4651 /* We are generating a relocateable output file, and must
4652 modify the reloc accordingly. */
4655 struct aout_link_hash_entry
*h
;
4657 /* If we know the symbol this relocation is against,
4658 convert it into a relocation against a section. This
4659 is what the native linker does. */
4660 h
= sym_hashes
[r_index
];
4661 if (h
!= (struct aout_link_hash_entry
*) NULL
4662 && (h
->root
.type
== bfd_link_hash_defined
4663 || h
->root
.type
== bfd_link_hash_defweak
))
4665 asection
*output_section
;
4667 /* Change the r_extern value. */
4668 if (output_bfd
->xvec
->header_byteorder_big_p
)
4669 rel
->r_type
[0] &=~ RELOC_EXT_BITS_EXTERN_BIG
;
4671 rel
->r_type
[0] &=~ RELOC_EXT_BITS_EXTERN_LITTLE
;
4673 /* Compute a new r_index. */
4674 output_section
= h
->root
.u
.def
.section
->output_section
;
4675 if (output_section
== obj_textsec (output_bfd
))
4677 else if (output_section
== obj_datasec (output_bfd
))
4679 else if (output_section
== obj_bsssec (output_bfd
))
4684 /* Add the symbol value and the section VMA to the
4686 relocation
= (h
->root
.u
.def
.value
4687 + output_section
->vma
4688 + h
->root
.u
.def
.section
->output_offset
);
4690 /* Now RELOCATION is the VMA of the final
4691 destination. If this is a PC relative reloc,
4692 then ADDEND is the negative of the source VMA.
4693 We want to set ADDEND to the difference between
4694 the destination VMA and the source VMA, which
4695 means we must adjust RELOCATION by the change in
4696 the source VMA. This is done below. */
4700 /* We must change r_index according to the symbol
4702 r_index
= symbol_map
[r_index
];
4708 /* We decided to strip this symbol, but it
4709 turns out that we can't. Note that we
4710 lose the other and desc information here.
4711 I don't think that will ever matter for a
4717 if (! aout_link_write_other_symbol (h
,
4727 name
= strings
+ GET_WORD (input_bfd
,
4728 syms
[r_index
].e_strx
);
4729 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
4730 (finfo
->info
, name
, input_bfd
, input_section
,
4739 /* If this is a PC relative reloc, then the addend
4740 is the negative of the source VMA. We must
4741 adjust it by the change in the source VMA. This
4745 /* Write out the new r_index value. */
4746 if (output_bfd
->xvec
->header_byteorder_big_p
)
4748 rel
->r_index
[0] = r_index
>> 16;
4749 rel
->r_index
[1] = r_index
>> 8;
4750 rel
->r_index
[2] = r_index
;
4754 rel
->r_index
[2] = r_index
>> 16;
4755 rel
->r_index
[1] = r_index
>> 8;
4756 rel
->r_index
[0] = r_index
;
4763 /* This is a relocation against a section. We must
4764 adjust by the amount that the section moved. */
4765 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4766 relocation
= (section
->output_section
->vma
4767 + section
->output_offset
4770 /* If this is a PC relative reloc, then the addend is
4771 the difference in VMA between the destination and the
4772 source. We have just adjusted for the change in VMA
4773 of the destination, so we must also adjust by the
4774 change in VMA of the source. This is done below. */
4777 /* As described above, we must always adjust a PC relative
4778 reloc by the change in VMA of the source. */
4779 if (howto_table_ext
[r_type
].pc_relative
)
4780 relocation
-= (input_section
->output_section
->vma
4781 + input_section
->output_offset
4782 - input_section
->vma
);
4784 /* Change the addend if necessary. */
4785 if (relocation
!= 0)
4786 PUT_WORD (output_bfd
, r_addend
+ relocation
, rel
->r_addend
);
4788 /* Change the address of the relocation. */
4789 PUT_WORD (output_bfd
,
4790 r_addr
+ input_section
->output_offset
,
4795 bfd_reloc_status_type r
;
4797 /* We are generating an executable, and must do a full
4801 struct aout_link_hash_entry
*h
;
4803 h
= sym_hashes
[r_index
];
4805 if (check_dynamic_reloc
!= NULL
)
4809 if (! ((*check_dynamic_reloc
)
4810 (finfo
->info
, input_bfd
, input_section
, h
,
4817 if (h
!= (struct aout_link_hash_entry
*) NULL
4818 && (h
->root
.type
== bfd_link_hash_defined
4819 || h
->root
.type
== bfd_link_hash_defweak
))
4821 relocation
= (h
->root
.u
.def
.value
4822 + h
->root
.u
.def
.section
->output_section
->vma
4823 + h
->root
.u
.def
.section
->output_offset
);
4825 else if (h
!= (struct aout_link_hash_entry
*) NULL
4826 && h
->root
.type
== bfd_link_hash_undefweak
)
4832 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
4833 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
4834 (finfo
->info
, name
, input_bfd
, input_section
,
4844 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4846 /* If this is a PC relative reloc, then R_ADDEND is the
4847 difference between the two vmas, or
4848 old_dest_sec + old_dest_off - (old_src_sec + old_src_off)
4850 old_dest_sec == section->vma
4852 old_src_sec == input_section->vma
4854 old_src_off == r_addr
4856 _bfd_final_link_relocate expects RELOCATION +
4857 R_ADDEND to be the VMA of the destination minus
4858 r_addr (the minus r_addr is because this relocation
4859 is not pcrel_offset, which is a bit confusing and
4860 should, perhaps, be changed), or
4863 new_dest_sec == output_section->vma + output_offset
4864 We arrange for this to happen by setting RELOCATION to
4865 new_dest_sec + old_src_sec - old_dest_sec
4867 If this is not a PC relative reloc, then R_ADDEND is
4868 simply the VMA of the destination, so we set
4869 RELOCATION to the change in the destination VMA, or
4870 new_dest_sec - old_dest_sec
4872 relocation
= (section
->output_section
->vma
4873 + section
->output_offset
4875 if (howto_table_ext
[r_type
].pc_relative
)
4876 relocation
+= input_section
->vma
;
4879 r
= _bfd_final_link_relocate (howto_table_ext
+ r_type
,
4880 input_bfd
, input_section
,
4881 contents
, r_addr
, relocation
,
4883 if (r
!= bfd_reloc_ok
)
4888 case bfd_reloc_outofrange
:
4890 case bfd_reloc_overflow
:
4895 name
= strings
+ GET_WORD (input_bfd
,
4896 syms
[r_index
].e_strx
);
4901 s
= aout_reloc_index_to_section (input_bfd
, r_index
);
4902 name
= bfd_section_name (input_bfd
, s
);
4904 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
4905 (finfo
->info
, name
, howto_table_ext
[r_type
].name
,
4906 r_addend
, input_bfd
, input_section
, r_addr
)))
4918 /* Handle a link order which is supposed to generate a reloc. */
4921 aout_link_reloc_link_order (finfo
, o
, p
)
4922 struct aout_final_link_info
*finfo
;
4924 struct bfd_link_order
*p
;
4926 struct bfd_link_order_reloc
*pr
;
4929 reloc_howto_type
*howto
;
4930 file_ptr
*reloff_ptr
;
4931 struct reloc_std_external srel
;
4932 struct reloc_ext_external erel
;
4937 if (p
->type
== bfd_section_reloc_link_order
)
4940 if (bfd_is_abs_section (pr
->u
.section
))
4941 r_index
= N_ABS
| N_EXT
;
4944 BFD_ASSERT (pr
->u
.section
->owner
== finfo
->output_bfd
);
4945 r_index
= pr
->u
.section
->target_index
;
4950 struct aout_link_hash_entry
*h
;
4952 BFD_ASSERT (p
->type
== bfd_symbol_reloc_link_order
);
4954 h
= aout_link_hash_lookup (aout_hash_table (finfo
->info
),
4955 pr
->u
.name
, false, false, true);
4956 if (h
!= (struct aout_link_hash_entry
*) NULL
4961 /* We decided to strip this symbol, but it turns out that we
4962 can't. Note that we lose the other and desc information
4963 here. I don't think that will ever matter for a global
4967 if (! aout_link_write_other_symbol (h
, (PTR
) finfo
))
4973 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
4974 (finfo
->info
, pr
->u
.name
, (bfd
*) NULL
,
4975 (asection
*) NULL
, (bfd_vma
) 0)))
4981 howto
= bfd_reloc_type_lookup (finfo
->output_bfd
, pr
->reloc
);
4984 bfd_set_error (bfd_error_bad_value
);
4988 if (o
== obj_textsec (finfo
->output_bfd
))
4989 reloff_ptr
= &finfo
->treloff
;
4990 else if (o
== obj_datasec (finfo
->output_bfd
))
4991 reloff_ptr
= &finfo
->dreloff
;
4995 if (obj_reloc_entry_size (finfo
->output_bfd
) == RELOC_STD_SIZE
)
5004 MY_put_reloc(finfo
->output_bfd
, r_extern
, r_index
, p
->offset
, howto
, &srel
);
5006 r_pcrel
= howto
->pc_relative
;
5007 r_baserel
= (howto
->type
& 8) != 0;
5008 r_jmptable
= (howto
->type
& 16) != 0;
5009 r_relative
= (howto
->type
& 32) != 0;
5010 r_length
= howto
->size
;
5012 PUT_WORD (finfo
->output_bfd
, p
->offset
, srel
.r_address
);
5013 if (finfo
->output_bfd
->xvec
->header_byteorder_big_p
)
5015 srel
.r_index
[0] = r_index
>> 16;
5016 srel
.r_index
[1] = r_index
>> 8;
5017 srel
.r_index
[2] = r_index
;
5019 ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
5020 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
5021 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
5022 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
5023 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
5024 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
5028 srel
.r_index
[2] = r_index
>> 16;
5029 srel
.r_index
[1] = r_index
>> 8;
5030 srel
.r_index
[0] = r_index
;
5032 ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
5033 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
5034 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
5035 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
5036 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
5037 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
5040 rel_ptr
= (PTR
) &srel
;
5042 /* We have to write the addend into the object file, since
5043 standard a.out relocs are in place. It would be more
5044 reliable if we had the current contents of the file here,
5045 rather than assuming zeroes, but we can't read the file since
5046 it was opened using bfd_openw. */
5047 if (pr
->addend
!= 0)
5050 bfd_reloc_status_type r
;
5054 size
= bfd_get_reloc_size (howto
);
5055 buf
= (bfd_byte
*) bfd_zmalloc (size
);
5056 if (buf
== (bfd_byte
*) NULL
)
5058 bfd_set_error (bfd_error_no_memory
);
5061 r
= _bfd_relocate_contents (howto
, finfo
->output_bfd
,
5068 case bfd_reloc_outofrange
:
5070 case bfd_reloc_overflow
:
5071 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
5073 (p
->type
== bfd_section_reloc_link_order
5074 ? bfd_section_name (finfo
->output_bfd
,
5077 howto
->name
, pr
->addend
, (bfd
*) NULL
,
5078 (asection
*) NULL
, (bfd_vma
) 0)))
5085 ok
= bfd_set_section_contents (finfo
->output_bfd
, o
,
5087 (file_ptr
) p
->offset
,
5096 PUT_WORD (finfo
->output_bfd
, p
->offset
, erel
.r_address
);
5098 if (finfo
->output_bfd
->xvec
->header_byteorder_big_p
)
5100 erel
.r_index
[0] = r_index
>> 16;
5101 erel
.r_index
[1] = r_index
>> 8;
5102 erel
.r_index
[2] = r_index
;
5104 ((r_extern
? RELOC_EXT_BITS_EXTERN_BIG
: 0)
5105 | (howto
->type
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
5109 erel
.r_index
[2] = r_index
>> 16;
5110 erel
.r_index
[1] = r_index
>> 8;
5111 erel
.r_index
[0] = r_index
;
5113 (r_extern
? RELOC_EXT_BITS_EXTERN_LITTLE
: 0)
5114 | (howto
->type
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
);
5117 PUT_WORD (finfo
->output_bfd
, pr
->addend
, erel
.r_addend
);
5119 rel_ptr
= (PTR
) &erel
;
5122 if (bfd_seek (finfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0
5123 || (bfd_write (rel_ptr
, (bfd_size_type
) 1,
5124 obj_reloc_entry_size (finfo
->output_bfd
),
5126 != obj_reloc_entry_size (finfo
->output_bfd
)))
5129 *reloff_ptr
+= obj_reloc_entry_size (finfo
->output_bfd
);
5131 /* Assert that the relocs have not run into the symbols, and that n
5132 the text relocs have not run into the data relocs. */
5133 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (finfo
->output_bfd
)
5134 && (reloff_ptr
!= &finfo
->treloff
5136 <= obj_datasec (finfo
->output_bfd
)->rel_filepos
)));