1 /* BFD semi-generic back-end for a.out binaries.
2 Copyright 1990, 1991, 1992, 1993 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
69 | #define TARGET_NAME "a.out-sunos-big"
70 | #define VECNAME sunos_big_vec
73 requires all the names from @file{aout32.c}, and produces the jump vector
77 The file @file{host-aout.c} is a special case. It is for a large set
78 of hosts that use ``more or less standard'' a.out files, and
79 for which cross-debugging is not interesting. It uses the
80 standard 32-bit a.out support routines, but determines the
81 file offsets and addresses of the text, data, and BSS
82 sections, the machine architecture and machine type, and the
83 entry point address, in a host-dependent manner. Once these
84 values have been determined, generic code is used to handle
87 When porting it to run on a new system, you must supply:
91 | HOST_MACHINE_ARCH (optional)
92 | HOST_MACHINE_MACHINE (optional)
93 | HOST_TEXT_START_ADDR
96 in the file @file{../include/sys/h-@var{XXX}.h} (for your host). These
97 values, plus the structures and macros defined in @file{a.out.h} on
98 your host system, will produce a BFD target that will access
99 ordinary a.out files on your host. To configure a new machine
100 to use @file{host-aout.c}, specify:
102 | TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec
103 | TDEPFILES= host-aout.o trad-core.o
105 in the @file{config/@var{XXX}.mt} file, and modify @file{configure.in}
107 @file{@var{XXX}.mt} file (by setting "<<bfd_target=XXX>>") when your
108 configuration is selected.
113 * Any BFD with D_PAGED set is ZMAGIC, and vice versa.
114 Doesn't matter what the setting of WP_TEXT is on output, but it'll
116 * Any BFD with D_PAGED clear and WP_TEXT set is NMAGIC.
117 * Any BFD with both flags clear is OMAGIC.
118 (Just want to make these explicit, so the conditions tested in this
119 file make sense if you're more familiar with a.out than with BFD.) */
122 #define KEEPITTYPE int
125 #include <string.h> /* For strchr and friends */
128 #include <ansidecl.h>
133 #include "aout/aout64.h"
134 #include "aout/stab_gnu.h"
142 The file @file{aoutx.h} provides for both the @emph{standard}
143 and @emph{extended} forms of a.out relocation records.
145 The standard records contain only an
146 address, a symbol index, and a type field. The extended records
147 (used on 29ks and sparcs) also have a full integer for an
151 #define CTOR_TABLE_RELOC_IDX 2
153 #define howto_table_ext NAME(aout,ext_howto_table)
154 #define howto_table_std NAME(aout,std_howto_table)
156 reloc_howto_type howto_table_ext
[] =
158 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
159 HOWTO(RELOC_8
, 0, 0, 8, false, 0, complain_overflow_bitfield
,0,"8", false, 0,0x000000ff, false),
160 HOWTO(RELOC_16
, 0, 1, 16, false, 0, complain_overflow_bitfield
,0,"16", false, 0,0x0000ffff, false),
161 HOWTO(RELOC_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,0,"32", false, 0,0xffffffff, false),
162 HOWTO(RELOC_DISP8
, 0, 0, 8, true, 0, complain_overflow_signed
,0,"DISP8", false, 0,0x000000ff, false),
163 HOWTO(RELOC_DISP16
, 0, 1, 16, true, 0, complain_overflow_signed
,0,"DISP16", false, 0,0x0000ffff, false),
164 HOWTO(RELOC_DISP32
, 0, 2, 32, true, 0, complain_overflow_signed
,0,"DISP32", false, 0,0xffffffff, false),
165 HOWTO(RELOC_WDISP30
,2, 2, 30, true, 0, complain_overflow_signed
,0,"WDISP30", false, 0,0x3fffffff, false),
166 HOWTO(RELOC_WDISP22
,2, 2, 22, true, 0, complain_overflow_signed
,0,"WDISP22", false, 0,0x003fffff, false),
167 HOWTO(RELOC_HI22
, 10, 2, 22, false, 0, complain_overflow_bitfield
,0,"HI22", false, 0,0x003fffff, false),
168 HOWTO(RELOC_22
, 0, 2, 22, false, 0, complain_overflow_bitfield
,0,"22", false, 0,0x003fffff, false),
169 HOWTO(RELOC_13
, 0, 2, 13, false, 0, complain_overflow_bitfield
,0,"13", false, 0,0x00001fff, false),
170 HOWTO(RELOC_LO10
, 0, 2, 10, false, 0, complain_overflow_dont
,0,"LO10", false, 0,0x000003ff, false),
171 HOWTO(RELOC_SFA_BASE
,0, 2, 32, false, 0, complain_overflow_bitfield
,0,"SFA_BASE", false, 0,0xffffffff, false),
172 HOWTO(RELOC_SFA_OFF13
,0,2, 32, false, 0, complain_overflow_bitfield
,0,"SFA_OFF13",false, 0,0xffffffff, false),
173 HOWTO(RELOC_BASE10
, 0, 2, 16, false, 0, complain_overflow_bitfield
,0,"BASE10", false, 0,0x0000ffff, false),
174 HOWTO(RELOC_BASE13
, 0, 2, 13, false, 0, complain_overflow_bitfield
,0,"BASE13", false, 0,0x00001fff, false),
175 HOWTO(RELOC_BASE22
, 0, 2, 0, false, 0, complain_overflow_bitfield
,0,"BASE22", false, 0,0x00000000, false),
176 HOWTO(RELOC_PC10
, 0, 2, 10, false, 0, complain_overflow_bitfield
,0,"PC10", false, 0,0x000003ff, false),
177 HOWTO(RELOC_PC22
, 0, 2, 22, false, 0, complain_overflow_bitfield
,0,"PC22", false, 0,0x003fffff, false),
178 HOWTO(RELOC_JMP_TBL
,0, 2, 32, false, 0, complain_overflow_bitfield
,0,"JMP_TBL", false, 0,0xffffffff, false),
179 HOWTO(RELOC_SEGOFF16
,0, 2, 0, false, 0, complain_overflow_bitfield
,0,"SEGOFF16", false, 0,0x00000000, false),
180 HOWTO(RELOC_GLOB_DAT
,0, 2, 0, false, 0, complain_overflow_bitfield
,0,"GLOB_DAT", false, 0,0x00000000, false),
181 HOWTO(RELOC_JMP_SLOT
,0, 2, 0, false, 0, complain_overflow_bitfield
,0,"JMP_SLOT", false, 0,0x00000000, false),
182 HOWTO(RELOC_RELATIVE
,0, 2, 0, false, 0, complain_overflow_bitfield
,0,"RELATIVE", false, 0,0x00000000, false),
185 /* Convert standard reloc records to "arelent" format (incl byte swap). */
187 reloc_howto_type howto_table_std
[] = {
188 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
189 HOWTO( 0, 0, 0, 8, false, 0, complain_overflow_bitfield
,0,"8", true, 0x000000ff,0x000000ff, false),
190 HOWTO( 1, 0, 1, 16, false, 0, complain_overflow_bitfield
,0,"16", true, 0x0000ffff,0x0000ffff, false),
191 HOWTO( 2, 0, 2, 32, false, 0, complain_overflow_bitfield
,0,"32", true, 0xffffffff,0xffffffff, false),
192 HOWTO( 3, 0, 4, 64, false, 0, complain_overflow_bitfield
,0,"64", true, 0xdeaddead,0xdeaddead, false),
193 HOWTO( 4, 0, 0, 8, true, 0, complain_overflow_signed
, 0,"DISP8", true, 0x000000ff,0x000000ff, false),
194 HOWTO( 5, 0, 1, 16, true, 0, complain_overflow_signed
, 0,"DISP16", true, 0x0000ffff,0x0000ffff, false),
195 HOWTO( 6, 0, 2, 32, true, 0, complain_overflow_signed
, 0,"DISP32", true, 0xffffffff,0xffffffff, false),
196 HOWTO( 7, 0, 4, 64, true, 0, complain_overflow_signed
, 0,"DISP64", true, 0xfeedface,0xfeedface, false),
198 HOWTO( 9, 0, 1, 16, false, 0, complain_overflow_bitfield
,0,"BASE16", false,0xffffffff,0xffffffff, false),
199 HOWTO(10, 0, 2, 32, false, 0, complain_overflow_bitfield
,0,"BASE32", false,0xffffffff,0xffffffff, false),
202 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
204 CONST
struct reloc_howto_struct
*
205 DEFUN(NAME(aout
,reloc_type_lookup
),(abfd
,code
),
207 bfd_reloc_code_real_type code
)
209 #define EXT(i,j) case i: return &howto_table_ext[j]
210 #define STD(i,j) case i: return &howto_table_std[j]
211 int ext
= obj_reloc_entry_size (abfd
) == RELOC_EXT_SIZE
;
212 if (code
== BFD_RELOC_CTOR
)
213 switch (bfd_get_arch_info (abfd
)->bits_per_address
)
222 EXT (BFD_RELOC_32
, 2);
223 EXT (BFD_RELOC_HI22
, 8);
224 EXT (BFD_RELOC_LO10
, 11);
225 EXT (BFD_RELOC_32_PCREL_S2
, 6);
226 EXT (BFD_RELOC_SPARC_WDISP22
, 7);
227 default: return (CONST
struct reloc_howto_struct
*) 0;
233 STD (BFD_RELOC_16
, 1);
234 STD (BFD_RELOC_32
, 2);
235 STD (BFD_RELOC_8_PCREL
, 4);
236 STD (BFD_RELOC_16_PCREL
, 5);
237 STD (BFD_RELOC_32_PCREL
, 6);
238 STD (BFD_RELOC_16_BASEREL
, 9);
239 STD (BFD_RELOC_32_BASEREL
, 10);
240 default: return (CONST
struct reloc_howto_struct
*) 0;
246 Internal entry points
249 @file{aoutx.h} exports several routines for accessing the
250 contents of an a.out file, which are gathered and exported in
251 turn by various format specific files (eg sunos.c).
257 aout_@var{size}_swap_exec_header_in
260 void aout_@var{size}_swap_exec_header_in,
262 struct external_exec *raw_bytes,
263 struct internal_exec *execp);
266 Swap the information in an executable header @var{raw_bytes} taken
267 from a raw byte stream memory image into the internal exec header
268 structure @var{execp}.
271 #ifndef NAME_swap_exec_header_in
273 DEFUN(NAME(aout
,swap_exec_header_in
),(abfd
, raw_bytes
, execp
),
275 struct external_exec
*raw_bytes AND
276 struct internal_exec
*execp
)
278 struct external_exec
*bytes
= (struct external_exec
*)raw_bytes
;
280 /* The internal_exec structure has some fields that are unused in this
281 configuration (IE for i960), so ensure that all such uninitialized
282 fields are zero'd out. There are places where two of these structs
283 are memcmp'd, and thus the contents do matter. */
284 memset (execp
, 0, sizeof (struct internal_exec
));
285 /* Now fill in fields in the execp, from the bytes in the raw data. */
286 execp
->a_info
= bfd_h_get_32 (abfd
, bytes
->e_info
);
287 execp
->a_text
= GET_WORD (abfd
, bytes
->e_text
);
288 execp
->a_data
= GET_WORD (abfd
, bytes
->e_data
);
289 execp
->a_bss
= GET_WORD (abfd
, bytes
->e_bss
);
290 execp
->a_syms
= GET_WORD (abfd
, bytes
->e_syms
);
291 execp
->a_entry
= GET_WORD (abfd
, bytes
->e_entry
);
292 execp
->a_trsize
= GET_WORD (abfd
, bytes
->e_trsize
);
293 execp
->a_drsize
= GET_WORD (abfd
, bytes
->e_drsize
);
295 #define NAME_swap_exec_header_in NAME(aout,swap_exec_header_in)
300 aout_@var{size}_swap_exec_header_out
303 void aout_@var{size}_swap_exec_header_out
305 struct internal_exec *execp,
306 struct external_exec *raw_bytes);
309 Swap the information in an internal exec header structure
310 @var{execp} into the buffer @var{raw_bytes} ready for writing to disk.
313 DEFUN(NAME(aout
,swap_exec_header_out
),(abfd
, execp
, raw_bytes
),
315 struct internal_exec
*execp AND
316 struct external_exec
*raw_bytes
)
318 struct external_exec
*bytes
= (struct external_exec
*)raw_bytes
;
320 /* Now fill in fields in the raw data, from the fields in the exec struct. */
321 bfd_h_put_32 (abfd
, execp
->a_info
, bytes
->e_info
);
322 PUT_WORD (abfd
, execp
->a_text
, bytes
->e_text
);
323 PUT_WORD (abfd
, execp
->a_data
, bytes
->e_data
);
324 PUT_WORD (abfd
, execp
->a_bss
, bytes
->e_bss
);
325 PUT_WORD (abfd
, execp
->a_syms
, bytes
->e_syms
);
326 PUT_WORD (abfd
, execp
->a_entry
, bytes
->e_entry
);
327 PUT_WORD (abfd
, execp
->a_trsize
, bytes
->e_trsize
);
328 PUT_WORD (abfd
, execp
->a_drsize
, bytes
->e_drsize
);
335 aout_@var{size}_some_aout_object_p
338 bfd_target *aout_@var{size}_some_aout_object_p
340 bfd_target *(*callback_to_real_object_p)());
343 Some a.out variant thinks that the file open in @var{abfd}
344 checking is an a.out file. Do some more checking, and set up
345 for access if it really is. Call back to the calling
346 environment's "finish up" function just before returning, to
347 handle any last-minute setup.
351 DEFUN(NAME(aout
,some_aout_object_p
),(abfd
, execp
, callback_to_real_object_p
),
353 struct internal_exec
*execp AND
354 bfd_target
*(*callback_to_real_object_p
) PARAMS ((bfd
*)))
356 struct aout_data_struct
*rawptr
, *oldrawptr
;
359 rawptr
= (struct aout_data_struct
*) bfd_zalloc (abfd
, sizeof (struct aout_data_struct
));
360 if (rawptr
== NULL
) {
361 bfd_error
= no_memory
;
365 oldrawptr
= abfd
->tdata
.aout_data
;
366 abfd
->tdata
.aout_data
= rawptr
;
368 /* Copy the contents of the old tdata struct.
369 In particular, we want the subformat, since for hpux it was set in
370 hp300hpux.c:swap_exec_header_in and will be used in
371 hp300hpux.c:callback. */
372 if (oldrawptr
!= NULL
)
373 *abfd
->tdata
.aout_data
= *oldrawptr
;
375 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
376 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
; /* Copy in the internal_exec struct */
377 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
379 /* Set the file flags */
380 abfd
->flags
= NO_FLAGS
;
381 if (execp
->a_drsize
|| execp
->a_trsize
)
382 abfd
->flags
|= HAS_RELOC
;
383 /* Setting of EXEC_P has been deferred to the bottom of this function */
385 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
386 if (N_DYNAMIC(*execp
))
387 abfd
->flags
|= DYNAMIC
;
389 if (N_MAGIC (*execp
) == ZMAGIC
)
391 abfd
->flags
|= D_PAGED
|WP_TEXT
;
392 adata(abfd
).magic
= z_magic
;
394 else if (N_MAGIC (*execp
) == NMAGIC
)
396 abfd
->flags
|= WP_TEXT
;
397 adata(abfd
).magic
= n_magic
;
400 adata(abfd
).magic
= o_magic
;
402 bfd_get_start_address (abfd
) = execp
->a_entry
;
404 obj_aout_symbols (abfd
) = (aout_symbol_type
*)NULL
;
405 bfd_get_symcount (abfd
) = execp
->a_syms
/ sizeof (struct external_nlist
);
407 /* The default relocation entry size is that of traditional V7 Unix. */
408 obj_reloc_entry_size (abfd
) = RELOC_STD_SIZE
;
410 /* The default symbol entry size is that of traditional Unix. */
411 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
413 obj_aout_external_syms (abfd
) = NULL
;
414 obj_aout_external_strings (abfd
) = NULL
;
415 obj_aout_sym_hashes (abfd
) = NULL
;
417 /* Create the sections. This is raunchy, but bfd_close wants to reclaim
420 obj_textsec (abfd
) = bfd_make_section_old_way (abfd
, ".text");
421 obj_datasec (abfd
) = bfd_make_section_old_way (abfd
, ".data");
422 obj_bsssec (abfd
) = bfd_make_section_old_way (abfd
, ".bss");
425 (void)bfd_make_section (abfd
, ".text");
426 (void)bfd_make_section (abfd
, ".data");
427 (void)bfd_make_section (abfd
, ".bss");
430 obj_datasec (abfd
)->_raw_size
= execp
->a_data
;
431 obj_bsssec (abfd
)->_raw_size
= execp
->a_bss
;
433 obj_textsec (abfd
)->flags
= (execp
->a_trsize
!= 0 ?
434 (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_RELOC
) :
435 (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
));
436 obj_datasec (abfd
)->flags
= (execp
->a_drsize
!= 0 ?
437 (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_RELOC
) :
438 (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
));
439 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
441 #ifdef THIS_IS_ONLY_DOCUMENTATION
442 /* The common code can't fill in these things because they depend
443 on either the start address of the text segment, the rounding
444 up of virtual addersses between segments, or the starting file
445 position of the text segment -- all of which varies among different
446 versions of a.out. */
448 /* Call back to the format-dependent code to fill in the rest of the
449 fields and do any further cleanup. Things that should be filled
450 in by the callback: */
452 struct exec
*execp
= exec_hdr (abfd
);
454 obj_textsec (abfd
)->size
= N_TXTSIZE(*execp
);
455 obj_textsec (abfd
)->raw_size
= N_TXTSIZE(*execp
);
456 /* data and bss are already filled in since they're so standard */
458 /* The virtual memory addresses of the sections */
459 obj_textsec (abfd
)->vma
= N_TXTADDR(*execp
);
460 obj_datasec (abfd
)->vma
= N_DATADDR(*execp
);
461 obj_bsssec (abfd
)->vma
= N_BSSADDR(*execp
);
463 /* The file offsets of the sections */
464 obj_textsec (abfd
)->filepos
= N_TXTOFF(*execp
);
465 obj_datasec (abfd
)->filepos
= N_DATOFF(*execp
);
467 /* The file offsets of the relocation info */
468 obj_textsec (abfd
)->rel_filepos
= N_TRELOFF(*execp
);
469 obj_datasec (abfd
)->rel_filepos
= N_DRELOFF(*execp
);
471 /* The file offsets of the string table and symbol table. */
472 obj_str_filepos (abfd
) = N_STROFF (*execp
);
473 obj_sym_filepos (abfd
) = N_SYMOFF (*execp
);
475 /* Determine the architecture and machine type of the object file. */
476 switch (N_MACHTYPE (*exec_hdr (abfd
))) {
478 abfd
->obj_arch
= bfd_arch_obscure
;
482 adata(abfd
)->page_size
= PAGE_SIZE
;
483 adata(abfd
)->segment_size
= SEGMENT_SIZE
;
484 adata(abfd
)->exec_bytes_size
= EXEC_BYTES_SIZE
;
488 /* The architecture is encoded in various ways in various a.out variants,
489 or is not encoded at all in some of them. The relocation size depends
490 on the architecture and the a.out variant. Finally, the return value
491 is the bfd_target vector in use. If an error occurs, return zero and
492 set bfd_error to the appropriate error code.
494 Formats such as b.out, which have additional fields in the a.out
495 header, should cope with them in this callback as well. */
496 #endif /* DOCUMENTATION */
498 result
= (*callback_to_real_object_p
)(abfd
);
500 /* Now that the segment addresses have been worked out, take a better
501 guess at whether the file is executable. If the entry point
502 is within the text segment, assume it is. (This makes files
503 executable even if their entry point address is 0, as long as
504 their text starts at zero.)
506 At some point we should probably break down and stat the file and
507 declare it executable if (one of) its 'x' bits are on... */
508 if ((execp
->a_entry
>= obj_textsec(abfd
)->vma
) &&
509 (execp
->a_entry
< obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->_raw_size
))
510 abfd
->flags
|= EXEC_P
;
513 #if 0 /* These should be set correctly anyways. */
514 abfd
->sections
= obj_textsec (abfd
);
515 obj_textsec (abfd
)->next
= obj_datasec (abfd
);
516 obj_datasec (abfd
)->next
= obj_bsssec (abfd
);
522 abfd
->tdata
.aout_data
= oldrawptr
;
529 aout_@var{size}_mkobject
532 boolean aout_@var{size}_mkobject, (bfd *abfd);
535 Initialize BFD @var{abfd} for use with a.out files.
539 DEFUN(NAME(aout
,mkobject
),(abfd
),
542 struct aout_data_struct
*rawptr
;
544 bfd_error
= system_call_error
;
546 /* Use an intermediate variable for clarity */
547 rawptr
= (struct aout_data_struct
*)bfd_zalloc (abfd
, sizeof (struct aout_data_struct
));
549 if (rawptr
== NULL
) {
550 bfd_error
= no_memory
;
554 abfd
->tdata
.aout_data
= rawptr
;
555 exec_hdr (abfd
) = &(rawptr
->e
);
557 /* For simplicity's sake we just make all the sections right here. */
559 obj_textsec (abfd
) = (asection
*)NULL
;
560 obj_datasec (abfd
) = (asection
*)NULL
;
561 obj_bsssec (abfd
) = (asection
*)NULL
;
562 bfd_make_section (abfd
, ".text");
563 bfd_make_section (abfd
, ".data");
564 bfd_make_section (abfd
, ".bss");
565 bfd_make_section (abfd
, BFD_ABS_SECTION_NAME
);
566 bfd_make_section (abfd
, BFD_UND_SECTION_NAME
);
567 bfd_make_section (abfd
, BFD_COM_SECTION_NAME
);
575 aout_@var{size}_machine_type
578 enum machine_type aout_@var{size}_machine_type
579 (enum bfd_architecture arch,
580 unsigned long machine));
583 Keep track of machine architecture and machine type for
584 a.out's. Return the <<machine_type>> for a particular
585 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
586 and machine can't be represented in a.out format.
588 If the architecture is understood, machine type 0 (default)
589 is always understood.
593 DEFUN(NAME(aout
,machine_type
),(arch
, machine
),
594 enum bfd_architecture arch AND
595 unsigned long machine
)
597 enum machine_type arch_flags
;
599 arch_flags
= M_UNKNOWN
;
603 if (machine
== 0) arch_flags
= M_SPARC
;
608 case 0: arch_flags
= M_68010
; break;
609 case 68000: arch_flags
= M_UNKNOWN
; break;
610 case 68010: arch_flags
= M_68010
; break;
611 case 68020: arch_flags
= M_68020
; break;
612 default: arch_flags
= M_UNKNOWN
; break;
617 if (machine
== 0) arch_flags
= M_386
;
621 if (machine
== 0) arch_flags
= M_29K
;
628 case 3000: arch_flags
= M_MIPS1
; break;
631 case 6000: arch_flags
= M_MIPS2
; break;
632 default: arch_flags
= M_UNKNOWN
; break;
637 arch_flags
= M_UNKNOWN
;
645 aout_@var{size}_set_arch_mach
648 boolean aout_@var{size}_set_arch_mach,
650 enum bfd_architecture arch,
651 unsigned long machine));
654 Set the architecture and the machine of the BFD @var{abfd} to the
655 values @var{arch} and @var{machine}. Verify that @var{abfd}'s format
656 can support the architecture required.
660 DEFUN(NAME(aout
,set_arch_mach
),(abfd
, arch
, machine
),
662 enum bfd_architecture arch AND
663 unsigned long machine
)
665 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
668 if (arch
!= bfd_arch_unknown
&&
669 NAME(aout
,machine_type
) (arch
, machine
) == M_UNKNOWN
)
670 return false; /* We can't represent this type */
672 /* Determine the size of a relocation entry */
677 obj_reloc_entry_size (abfd
) = RELOC_EXT_SIZE
;
680 obj_reloc_entry_size (abfd
) = RELOC_STD_SIZE
;
684 return (*aout_backend_info(abfd
)->set_sizes
) (abfd
);
688 adjust_o_magic (abfd
, execp
)
690 struct internal_exec
*execp
;
692 file_ptr pos
= adata (abfd
).exec_bytes_size
;
697 obj_textsec(abfd
)->filepos
= pos
;
698 pos
+= obj_textsec(abfd
)->_raw_size
;
699 vma
+= obj_textsec(abfd
)->_raw_size
;
702 if (!obj_datasec(abfd
)->user_set_vma
)
704 #if 0 /* ?? Does alignment in the file image really matter? */
705 pad
= align_power (vma
, obj_datasec(abfd
)->alignment_power
) - vma
;
707 obj_textsec(abfd
)->_raw_size
+= pad
;
710 obj_datasec(abfd
)->vma
= vma
;
712 obj_datasec(abfd
)->filepos
= pos
;
713 pos
+= obj_datasec(abfd
)->_raw_size
;
714 vma
+= obj_datasec(abfd
)->_raw_size
;
717 if (!obj_bsssec(abfd
)->user_set_vma
)
720 pad
= align_power (vma
, obj_bsssec(abfd
)->alignment_power
) - vma
;
722 obj_datasec(abfd
)->_raw_size
+= pad
;
725 obj_bsssec(abfd
)->vma
= vma
;
727 obj_bsssec(abfd
)->filepos
= pos
;
729 /* Fix up the exec header. */
730 execp
->a_text
= obj_textsec(abfd
)->_raw_size
;
731 execp
->a_data
= obj_datasec(abfd
)->_raw_size
;
732 execp
->a_bss
= obj_bsssec(abfd
)->_raw_size
;
733 N_SET_MAGIC (*execp
, OMAGIC
);
737 adjust_z_magic (abfd
, execp
)
739 struct internal_exec
*execp
;
741 bfd_size_type data_pad
, text_pad
;
743 CONST
struct aout_backend_data
*abdp
;
744 int ztih
; /* Nonzero if text includes exec header. */
746 abdp
= aout_backend_info (abfd
);
749 ztih
= abdp
&& abdp
->text_includes_header
;
750 obj_textsec(abfd
)->filepos
= (ztih
751 ? adata(abfd
).exec_bytes_size
752 : adata(abfd
).page_size
);
753 if (! obj_textsec(abfd
)->user_set_vma
)
754 /* ?? Do we really need to check for relocs here? */
755 obj_textsec(abfd
)->vma
= ((abfd
->flags
& HAS_RELOC
)
758 ? (abdp
->default_text_vma
759 + adata(abfd
).exec_bytes_size
)
760 : abdp
->default_text_vma
));
761 /* Could take strange alignment of text section into account here? */
763 /* Find start of data. */
764 text_end
= obj_textsec(abfd
)->filepos
+ obj_textsec(abfd
)->_raw_size
;
765 text_pad
= BFD_ALIGN (text_end
, adata(abfd
).page_size
) - text_end
;
766 obj_textsec(abfd
)->_raw_size
+= text_pad
;
767 text_end
+= text_pad
;
770 if (!obj_datasec(abfd
)->user_set_vma
)
773 vma
= obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->_raw_size
;
774 obj_datasec(abfd
)->vma
= BFD_ALIGN (vma
, adata(abfd
).segment_size
);
776 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
778 text_pad
= (obj_datasec(abfd
)->vma
779 - obj_textsec(abfd
)->vma
780 - obj_textsec(abfd
)->_raw_size
);
781 obj_textsec(abfd
)->_raw_size
+= text_pad
;
783 obj_datasec(abfd
)->filepos
= (obj_textsec(abfd
)->filepos
784 + obj_textsec(abfd
)->_raw_size
);
786 /* Fix up exec header while we're at it. */
787 execp
->a_text
= obj_textsec(abfd
)->_raw_size
;
788 if (ztih
&& (!abdp
|| (abdp
&& !abdp
->exec_header_not_counted
)))
789 execp
->a_text
+= adata(abfd
).exec_bytes_size
;
790 N_SET_MAGIC (*execp
, ZMAGIC
);
792 /* Spec says data section should be rounded up to page boundary. */
793 obj_datasec(abfd
)->_raw_size
794 = align_power (obj_datasec(abfd
)->_raw_size
,
795 obj_bsssec(abfd
)->alignment_power
);
796 execp
->a_data
= BFD_ALIGN (obj_datasec(abfd
)->_raw_size
,
797 adata(abfd
).page_size
);
798 data_pad
= execp
->a_data
- obj_datasec(abfd
)->_raw_size
;
801 if (!obj_bsssec(abfd
)->user_set_vma
)
802 obj_bsssec(abfd
)->vma
= (obj_datasec(abfd
)->vma
803 + obj_datasec(abfd
)->_raw_size
);
804 /* If the BSS immediately follows the data section and extra space
805 in the page is left after the data section, fudge data
806 in the header so that the bss section looks smaller by that
807 amount. We'll start the bss section there, and lie to the OS.
808 (Note that a linker script, as well as the above assignment,
809 could have explicitly set the BSS vma to immediately follow
810 the data section.) */
811 if (align_power (obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->alignment_power
)
812 == obj_datasec(abfd
)->vma
+ obj_datasec(abfd
)->_raw_size
)
813 execp
->a_bss
= (data_pad
> obj_bsssec(abfd
)->_raw_size
) ? 0 :
814 obj_bsssec(abfd
)->_raw_size
- data_pad
;
816 execp
->a_bss
= obj_bsssec(abfd
)->_raw_size
;
820 adjust_n_magic (abfd
, execp
)
822 struct internal_exec
*execp
;
824 file_ptr pos
= adata(abfd
).exec_bytes_size
;
829 obj_textsec(abfd
)->filepos
= pos
;
830 if (!obj_textsec(abfd
)->user_set_vma
)
831 obj_textsec(abfd
)->vma
= vma
;
833 vma
= obj_textsec(abfd
)->vma
;
834 pos
+= obj_textsec(abfd
)->_raw_size
;
835 vma
+= obj_textsec(abfd
)->_raw_size
;
838 obj_datasec(abfd
)->filepos
= pos
;
839 if (!obj_datasec(abfd
)->user_set_vma
)
840 obj_datasec(abfd
)->vma
= BFD_ALIGN (vma
, adata(abfd
).segment_size
);
841 vma
= obj_datasec(abfd
)->vma
;
843 /* Since BSS follows data immediately, see if it needs alignment. */
844 vma
+= obj_datasec(abfd
)->_raw_size
;
845 pad
= align_power (vma
, obj_bsssec(abfd
)->alignment_power
) - vma
;
846 obj_datasec(abfd
)->_raw_size
+= pad
;
847 pos
+= obj_datasec(abfd
)->_raw_size
;
850 if (!obj_bsssec(abfd
)->user_set_vma
)
851 obj_bsssec(abfd
)->vma
= vma
;
853 vma
= obj_bsssec(abfd
)->vma
;
855 /* Fix up 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
, NMAGIC
);
863 DEFUN (NAME(aout
,adjust_sizes_and_vmas
), (abfd
, text_size
, text_end
),
864 bfd
*abfd AND bfd_size_type
*text_size AND file_ptr
*text_end
)
866 struct internal_exec
*execp
= exec_hdr (abfd
);
868 if ((obj_textsec (abfd
) == NULL
) || (obj_datasec (abfd
) == NULL
))
870 bfd_error
= invalid_operation
;
873 if (adata(abfd
).magic
!= undecided_magic
) return true;
875 obj_textsec(abfd
)->_raw_size
=
876 align_power(obj_textsec(abfd
)->_raw_size
,
877 obj_textsec(abfd
)->alignment_power
);
879 *text_size
= obj_textsec (abfd
)->_raw_size
;
880 /* Rule (heuristic) for when to pad to a new page. Note that there
881 are (at least) two ways demand-paged (ZMAGIC) files have been
882 handled. Most Berkeley-based systems start the text segment at
883 (PAGE_SIZE). However, newer versions of SUNOS start the text
884 segment right after the exec header; the latter is counted in the
885 text segment size, and is paged in by the kernel with the rest of
888 /* This perhaps isn't the right way to do this, but made it simpler for me
889 to understand enough to implement it. Better would probably be to go
890 right from BFD flags to alignment/positioning characteristics. But the
891 old code was sloppy enough about handling the flags, and had enough
892 other magic, that it was a little hard for me to understand. I think
893 I understand it better now, but I haven't time to do the cleanup this
896 if (abfd
->flags
& D_PAGED
)
897 /* Whether or not WP_TEXT is set -- let D_PAGED override. */
898 /* @@ What about QMAGIC? */
899 adata(abfd
).magic
= z_magic
;
900 else if (abfd
->flags
& WP_TEXT
)
901 adata(abfd
).magic
= n_magic
;
903 adata(abfd
).magic
= o_magic
;
905 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
907 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
909 switch (adata(abfd
).magic
) {
910 case n_magic
: str
= "NMAGIC"; break;
911 case o_magic
: str
= "OMAGIC"; break;
912 case z_magic
: str
= "ZMAGIC"; break;
917 obj_textsec(abfd
)->vma
, obj_textsec(abfd
)->_raw_size
,
918 obj_textsec(abfd
)->alignment_power
,
919 obj_datasec(abfd
)->vma
, obj_datasec(abfd
)->_raw_size
,
920 obj_datasec(abfd
)->alignment_power
,
921 obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->_raw_size
,
922 obj_bsssec(abfd
)->alignment_power
);
926 switch (adata(abfd
).magic
)
929 adjust_o_magic (abfd
, execp
);
932 adjust_z_magic (abfd
, execp
);
935 adjust_n_magic (abfd
, execp
);
941 #ifdef BFD_AOUT_DEBUG
942 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
943 obj_textsec(abfd
)->vma
, obj_textsec(abfd
)->_raw_size
,
944 obj_textsec(abfd
)->filepos
,
945 obj_datasec(abfd
)->vma
, obj_datasec(abfd
)->_raw_size
,
946 obj_datasec(abfd
)->filepos
,
947 obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->_raw_size
);
955 aout_@var{size}_new_section_hook
958 boolean aout_@var{size}_new_section_hook,
963 Called by the BFD in response to a @code{bfd_make_section}
967 DEFUN(NAME(aout
,new_section_hook
),(abfd
, newsect
),
971 /* align to double at least */
972 newsect
->alignment_power
= bfd_get_arch_info(abfd
)->section_align_power
;
975 if (bfd_get_format (abfd
) == bfd_object
)
977 if (obj_textsec(abfd
) == NULL
&& !strcmp(newsect
->name
, ".text")) {
978 obj_textsec(abfd
)= newsect
;
979 newsect
->target_index
= N_TEXT
| N_EXT
;
983 if (obj_datasec(abfd
) == NULL
&& !strcmp(newsect
->name
, ".data")) {
984 obj_datasec(abfd
) = newsect
;
985 newsect
->target_index
= N_DATA
| N_EXT
;
989 if (obj_bsssec(abfd
) == NULL
&& !strcmp(newsect
->name
, ".bss")) {
990 obj_bsssec(abfd
) = newsect
;
991 newsect
->target_index
= N_BSS
| N_EXT
;
997 /* We allow more than three sections internally */
1002 DEFUN(NAME(aout
,set_section_contents
),(abfd
, section
, location
, offset
, count
),
1007 bfd_size_type count
)
1010 bfd_size_type text_size
;
1012 if (abfd
->output_has_begun
== false)
1014 if (NAME(aout
,adjust_sizes_and_vmas
) (abfd
,
1016 &text_end
) == false)
1020 /* regardless, once we know what we're doing, we might as well get going */
1021 if (section
!= obj_bsssec(abfd
))
1023 bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
);
1026 return (bfd_write ((PTR
)location
, 1, count
, abfd
) == count
) ?
1034 /* Classify stabs symbols */
1036 #define sym_in_text_section(sym) \
1037 (((sym)->type & (N_ABS | N_TEXT | N_DATA | N_BSS))== N_TEXT)
1039 #define sym_in_data_section(sym) \
1040 (((sym)->type & (N_ABS | N_TEXT | N_DATA | N_BSS))== N_DATA)
1042 #define sym_in_bss_section(sym) \
1043 (((sym)->type & (N_ABS | N_TEXT | N_DATA | N_BSS))== N_BSS)
1045 /* Symbol is undefined if type is N_UNDF|N_EXT and if it has
1046 zero in the "value" field. Nonzeroes there are fortrancommon
1048 #define sym_is_undefined(sym) \
1049 ((sym)->type == (N_UNDF | N_EXT) && (sym)->symbol.value == 0)
1051 /* Symbol is a global definition if N_EXT is on and if it has
1052 a nonzero type field. */
1053 #define sym_is_global_defn(sym) \
1054 (((sym)->type & N_EXT) && (sym)->type & N_TYPE)
1056 /* Symbol is debugger info if any bits outside N_TYPE or N_EXT
1058 #define sym_is_debugger_info(sym) \
1059 (((sym)->type & ~(N_EXT | N_TYPE)) || (sym)->type == N_FN)
1061 #define sym_is_fortrancommon(sym) \
1062 (((sym)->type == (N_EXT)) && (sym)->symbol.value != 0)
1064 /* Symbol is absolute if it has N_ABS set */
1065 #define sym_is_absolute(sym) \
1066 (((sym)->type & N_TYPE)== N_ABS)
1069 #define sym_is_indirect(sym) \
1070 (((sym)->type & N_ABS)== N_ABS)
1072 /* Only in their own functions for ease of debugging; when sym flags have
1073 stabilised these should be inlined into their (single) caller */
1076 DEFUN (translate_from_native_sym_flags
, (sym_pointer
, cache_ptr
, abfd
),
1077 struct external_nlist
*sym_pointer AND
1078 aout_symbol_type
* cache_ptr AND
1081 cache_ptr
->symbol
.section
= 0;
1082 switch (cache_ptr
->type
& N_TYPE
)
1084 case N_SETA
: case N_SETA
| N_EXT
:
1085 case N_SETT
: case N_SETT
| N_EXT
:
1086 case N_SETD
: case N_SETD
| N_EXT
:
1087 case N_SETB
: case N_SETB
| N_EXT
:
1089 char *copy
= bfd_alloc (abfd
, strlen (cache_ptr
->symbol
.name
) + 1);
1091 asection
*into_section
;
1093 arelent_chain
*reloc
= (arelent_chain
*) bfd_alloc (abfd
, sizeof (arelent_chain
));
1094 strcpy (copy
, cache_ptr
->symbol
.name
);
1096 /* Make sure that this bfd has a section with the right contructor
1098 section
= bfd_get_section_by_name (abfd
, copy
);
1100 section
= bfd_make_section (abfd
, copy
);
1102 /* Build a relocation entry for the constructor */
1103 switch ((cache_ptr
->type
& N_TYPE
))
1105 case N_SETA
: case N_SETA
| N_EXT
:
1106 into_section
= &bfd_abs_section
;
1107 cache_ptr
->type
= N_ABS
;
1109 case N_SETT
: case N_SETT
| N_EXT
:
1110 into_section
= (asection
*) obj_textsec (abfd
);
1111 cache_ptr
->type
= N_TEXT
;
1113 case N_SETD
: case N_SETD
| N_EXT
:
1114 into_section
= (asection
*) obj_datasec (abfd
);
1115 cache_ptr
->type
= N_DATA
;
1117 case N_SETB
: case N_SETB
| N_EXT
:
1118 into_section
= (asection
*) obj_bsssec (abfd
);
1119 cache_ptr
->type
= N_BSS
;
1125 /* Build a relocation pointing into the constuctor section
1126 pointing at the symbol in the set vector specified */
1128 reloc
->relent
.addend
= cache_ptr
->symbol
.value
;
1129 cache_ptr
->symbol
.section
= into_section
->symbol
->section
;
1130 reloc
->relent
.sym_ptr_ptr
= into_section
->symbol_ptr_ptr
;
1133 /* We modify the symbol to belong to a section depending upon the
1134 name of the symbol - probably __CTOR__ or __DTOR__ but we don't
1135 really care, and add to the size of the section to contain a
1136 pointer to the symbol. Build a reloc entry to relocate to this
1137 symbol attached to this section. */
1139 section
->flags
= SEC_CONSTRUCTOR
;
1142 section
->reloc_count
++;
1143 section
->alignment_power
= 2;
1145 reloc
->next
= section
->constructor_chain
;
1146 section
->constructor_chain
= reloc
;
1147 reloc
->relent
.address
= section
->_raw_size
;
1148 section
->_raw_size
+= sizeof (int *);
1151 = (obj_reloc_entry_size(abfd
) == RELOC_EXT_SIZE
1152 ? howto_table_ext
: howto_table_std
)
1153 + CTOR_TABLE_RELOC_IDX
;
1154 cache_ptr
->symbol
.flags
|= BSF_CONSTRUCTOR
;
1158 if (cache_ptr
->type
== N_WARNING
)
1160 /* This symbol is the text of a warning message, the next symbol
1161 is the symbol to associate the warning with */
1162 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
| BSF_WARNING
;
1164 /* @@ Stuffing pointers into integers is a no-no.
1165 We can usually get away with it if the integer is
1166 large enough though. */
1167 if (sizeof (cache_ptr
+ 1) > sizeof (bfd_vma
))
1169 cache_ptr
->symbol
.value
= (bfd_vma
) ((cache_ptr
+ 1));
1171 /* We don't use a warning symbol's section, but we need
1172 it to be nonzero for the sanity check below, so
1173 pick one arbitrarily. */
1174 cache_ptr
->symbol
.section
= &bfd_abs_section
;
1176 /* We furgle with the next symbol in place.
1177 We don't want it to be undefined, we'll trample the type */
1178 (sym_pointer
+ 1)->e_type
[0] = 0xff;
1181 if ((cache_ptr
->type
| N_EXT
) == (N_INDR
| N_EXT
))
1183 /* Two symbols in a row for an INDR message. The first symbol
1184 contains the name we will match, the second symbol contains
1185 the name the first name is translated into. It is supplied to
1186 us undefined. This is good, since we want to pull in any files
1188 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
| BSF_INDIRECT
;
1190 /* @@ Stuffing pointers into integers is a no-no.
1191 We can usually get away with it if the integer is
1192 large enough though. */
1193 if (sizeof (cache_ptr
+ 1) > sizeof (bfd_vma
))
1196 cache_ptr
->symbol
.value
= (bfd_vma
) ((cache_ptr
+ 1));
1197 cache_ptr
->symbol
.section
= &bfd_ind_section
;
1200 else if (sym_is_debugger_info (cache_ptr
))
1202 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1203 /* Work out the section correct for this symbol */
1204 switch (cache_ptr
->type
& N_TYPE
)
1208 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1209 cache_ptr
->symbol
.value
-= obj_textsec (abfd
)->vma
;
1212 cache_ptr
->symbol
.value
-= obj_datasec (abfd
)->vma
;
1213 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1216 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1217 cache_ptr
->symbol
.value
-= obj_bsssec (abfd
)->vma
;
1221 cache_ptr
->symbol
.section
= &bfd_abs_section
;
1228 if (sym_is_fortrancommon (cache_ptr
))
1230 cache_ptr
->symbol
.flags
= 0;
1231 cache_ptr
->symbol
.section
= &bfd_com_section
;
1239 /* In a.out, the value of a symbol is always relative to the
1240 * start of the file, if this is a data symbol we'll subtract
1241 * the size of the text section to get the section relative
1242 * value. If this is a bss symbol (which would be strange)
1243 * we'll subtract the size of the previous two sections
1244 * to find the section relative address.
1247 if (sym_in_text_section (cache_ptr
))
1249 cache_ptr
->symbol
.value
-= obj_textsec (abfd
)->vma
;
1250 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1252 else if (sym_in_data_section (cache_ptr
))
1254 cache_ptr
->symbol
.value
-= obj_datasec (abfd
)->vma
;
1255 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1257 else if (sym_in_bss_section (cache_ptr
))
1259 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1260 cache_ptr
->symbol
.value
-= obj_bsssec (abfd
)->vma
;
1262 else if (sym_is_undefined (cache_ptr
))
1264 cache_ptr
->symbol
.flags
= 0;
1265 cache_ptr
->symbol
.section
= &bfd_und_section
;
1267 else if (sym_is_absolute (cache_ptr
))
1269 cache_ptr
->symbol
.section
= &bfd_abs_section
;
1272 if (sym_is_global_defn (cache_ptr
))
1274 cache_ptr
->symbol
.flags
= BSF_GLOBAL
| BSF_EXPORT
;
1278 cache_ptr
->symbol
.flags
= BSF_LOCAL
;
1282 if (cache_ptr
->symbol
.section
== 0)
1289 DEFUN(translate_to_native_sym_flags
,(sym_pointer
, cache_ptr
, abfd
),
1290 struct external_nlist
*sym_pointer AND
1291 asymbol
*cache_ptr AND
1294 bfd_vma value
= cache_ptr
->value
;
1296 /* mask out any existing type bits in case copying from one section
1298 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1300 /* We attempt to order these tests by decreasing frequency of success,
1301 according to tcov when linking the linker. */
1302 if (bfd_get_output_section(cache_ptr
) == &bfd_abs_section
) {
1303 sym_pointer
->e_type
[0] |= N_ABS
;
1305 else if (bfd_get_output_section(cache_ptr
) == obj_textsec (abfd
)) {
1306 sym_pointer
->e_type
[0] |= N_TEXT
;
1308 else if (bfd_get_output_section(cache_ptr
) == obj_datasec (abfd
)) {
1309 sym_pointer
->e_type
[0] |= N_DATA
;
1311 else if (bfd_get_output_section(cache_ptr
) == obj_bsssec (abfd
)) {
1312 sym_pointer
->e_type
[0] |= N_BSS
;
1314 else if (bfd_get_output_section(cache_ptr
) == &bfd_und_section
) {
1315 sym_pointer
->e_type
[0] = (N_UNDF
| N_EXT
);
1317 else if (bfd_get_output_section(cache_ptr
) == &bfd_ind_section
) {
1318 sym_pointer
->e_type
[0] = N_INDR
;
1320 else if (bfd_get_output_section(cache_ptr
) == NULL
) {
1321 /* Protect the bfd_is_com_section call.
1322 This case occurs, e.g., for the *DEBUG* section of a COFF file. */
1323 bfd_error
= bfd_error_nonrepresentable_section
;
1326 else if (bfd_is_com_section (bfd_get_output_section (cache_ptr
))) {
1327 sym_pointer
->e_type
[0] = (N_UNDF
| N_EXT
);
1330 bfd_error
= bfd_error_nonrepresentable_section
;
1334 /* Turn the symbol from section relative to absolute again */
1336 value
+= cache_ptr
->section
->output_section
->vma
+ cache_ptr
->section
->output_offset
;
1339 if (cache_ptr
->flags
& (BSF_WARNING
)) {
1340 (sym_pointer
+1)->e_type
[0] = 1;
1343 if (cache_ptr
->flags
& BSF_DEBUGGING
) {
1344 sym_pointer
->e_type
[0] = ((aout_symbol_type
*)cache_ptr
)->type
;
1346 else if (cache_ptr
->flags
& (BSF_GLOBAL
| BSF_EXPORT
)) {
1347 sym_pointer
->e_type
[0] |= N_EXT
;
1349 if (cache_ptr
->flags
& BSF_CONSTRUCTOR
) {
1350 int type
= ((aout_symbol_type
*)cache_ptr
)->type
;
1353 case N_ABS
: type
= N_SETA
; break;
1354 case N_TEXT
: type
= N_SETT
; break;
1355 case N_DATA
: type
= N_SETD
; break;
1356 case N_BSS
: type
= N_SETB
; break;
1358 sym_pointer
->e_type
[0] = type
;
1361 PUT_WORD(abfd
, value
, sym_pointer
->e_value
);
1366 /* Native-level interface to symbols. */
1368 /* We read the symbols into a buffer, which is discarded when this
1369 function exits. We read the strings into a buffer large enough to
1370 hold them all plus all the cached symbol entries. */
1373 DEFUN(NAME(aout
,make_empty_symbol
),(abfd
),
1376 aout_symbol_type
*new =
1377 (aout_symbol_type
*)bfd_zalloc (abfd
, sizeof (aout_symbol_type
));
1378 new->symbol
.the_bfd
= abfd
;
1380 return &new->symbol
;
1384 DEFUN(NAME(aout
,slurp_symbol_table
),(abfd
),
1387 bfd_size_type symbol_size
;
1388 bfd_size_type string_size
;
1389 unsigned char string_chars
[BYTES_IN_WORD
];
1390 struct external_nlist
*syms
;
1392 aout_symbol_type
*cached
;
1394 /* If there's no work to be done, don't do any */
1395 if (obj_aout_symbols (abfd
) != (aout_symbol_type
*)NULL
) return true;
1396 symbol_size
= exec_hdr(abfd
)->a_syms
;
1397 if (symbol_size
== 0)
1399 bfd_error
= no_symbols
;
1403 bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
);
1404 if (bfd_read ((PTR
)string_chars
, BYTES_IN_WORD
, 1, abfd
) != BYTES_IN_WORD
)
1406 string_size
= GET_WORD (abfd
, string_chars
);
1408 strings
=(char *) bfd_alloc(abfd
, string_size
+ 1);
1409 cached
= (aout_symbol_type
*)
1410 bfd_zalloc(abfd
, (bfd_size_type
)(bfd_get_symcount (abfd
) * sizeof(aout_symbol_type
)));
1412 /* malloc this, so we can free it if simply. The symbol caching
1413 might want to allocate onto the bfd's obstack */
1414 syms
= (struct external_nlist
*) bfd_xmalloc(symbol_size
);
1415 bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
);
1416 if (bfd_read ((PTR
)syms
, 1, symbol_size
, abfd
) != symbol_size
)
1422 bfd_release (abfd
, cached
);
1424 bfd_release (abfd
, strings
);
1428 bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
);
1429 if (bfd_read ((PTR
)strings
, 1, string_size
, abfd
) != string_size
)
1433 strings
[string_size
] = 0; /* Just in case. */
1435 /* OK, now walk the new symtable, cacheing symbol properties */
1437 register struct external_nlist
*sym_pointer
;
1438 register struct external_nlist
*sym_end
= syms
+ bfd_get_symcount (abfd
);
1439 register aout_symbol_type
*cache_ptr
= cached
;
1441 /* Run through table and copy values */
1442 for (sym_pointer
= syms
, cache_ptr
= cached
;
1443 sym_pointer
< sym_end
; sym_pointer
++, cache_ptr
++)
1445 long x
= GET_WORD(abfd
, sym_pointer
->e_strx
);
1446 cache_ptr
->symbol
.the_bfd
= abfd
;
1448 cache_ptr
->symbol
.name
= "";
1449 else if (x
>= 0 && x
< string_size
)
1450 cache_ptr
->symbol
.name
= x
+ strings
;
1454 cache_ptr
->symbol
.value
= GET_SWORD(abfd
, sym_pointer
->e_value
);
1455 cache_ptr
->desc
= bfd_h_get_16(abfd
, sym_pointer
->e_desc
);
1456 cache_ptr
->other
= bfd_h_get_8(abfd
, sym_pointer
->e_other
);
1457 cache_ptr
->type
= bfd_h_get_8(abfd
, sym_pointer
->e_type
);
1458 cache_ptr
->symbol
.udata
= 0;
1459 translate_from_native_sym_flags (sym_pointer
, cache_ptr
, abfd
);
1463 obj_aout_symbols (abfd
) = cached
;
1470 /* Possible improvements:
1471 + look for strings matching trailing substrings of other strings
1472 + better data structures? balanced trees?
1473 + smaller per-string or per-symbol data? re-use some of the symbol's
1475 + also look at reducing memory use elsewhere -- maybe if we didn't have to
1476 construct the entire symbol table at once, we could get by with smaller
1477 amounts of VM? (What effect does that have on the string table
1479 + rip this out of here, put it into its own file in bfd or libiberty, so
1480 coff and elf can use it too. I'll work on this soon, but have more
1481 pressing tasks right now.
1483 A hash table might(?) be more efficient for handling exactly the cases that
1484 are handled now, but for trailing substring matches, I think we want to
1485 examine the `nearest' values (reverse-)lexically, not merely impose a strict
1486 order, nor look only for exact-match or not-match. I don't think a hash
1487 table would be very useful for that, and I don't feel like fleshing out two
1488 completely different implementations. [raeburn:930419.0331EDT] */
1490 struct stringtab_entry
{
1491 /* Hash value for this string. Only useful so long as we aren't doing
1492 substring matches. */
1495 /* Next node to look at, depending on whether the hash value of the string
1496 being searched for is less than or greater than the hash value of the
1497 current node. For now, `equal to' is lumped in with `greater than', for
1498 space efficiency. It's not a common enough case to warrant another field
1499 to be used for all nodes. */
1500 struct stringtab_entry
*less
;
1501 struct stringtab_entry
*greater
;
1503 /* The string itself. */
1506 /* The index allocated for this string. */
1507 bfd_size_type index
;
1509 #ifdef GATHER_STATISTICS
1510 /* How many references have there been to this string? (Not currently used;
1511 could be dumped out for anaylsis, if anyone's interested.) */
1512 unsigned long count
;
1515 /* Next node in linked list, in suggested output order. */
1516 struct stringtab_entry
*next_to_output
;
1519 struct stringtab_data
{
1520 /* Tree of string table entries. */
1521 struct stringtab_entry
*strings
;
1523 /* Fudge factor used to center top node of tree. */
1526 /* Next index value to issue. */
1527 bfd_size_type index
;
1529 /* Index used for empty strings. Cached here because checking for them
1530 is really easy, and we can avoid searching the tree. */
1531 bfd_size_type empty_string_index
;
1533 /* These fields indicate the two ends of a singly-linked list that indicates
1534 the order strings should be written out in. Use this order, and no
1535 seeking will need to be done, so output efficiency should be maximized. */
1536 struct stringtab_entry
**end
;
1537 struct stringtab_entry
*output_order
;
1539 #ifdef GATHER_STATISTICS
1540 /* Number of strings which duplicate strings already in the table. */
1541 unsigned long duplicates
;
1543 /* Number of bytes saved by not having to write all the duplicate strings. */
1544 unsigned long bytes_saved
;
1546 /* Number of zero-length strings. Currently, these all turn into
1547 references to the null byte at the end of the first string. In some
1548 cases (possibly not all? explore this...), it should be possible to
1549 simply write out a zero index value. */
1550 unsigned long empty_strings
;
1552 /* Number of times the hash values matched but the strings were different.
1553 Note that this includes the number of times the other string(s) occurs, so
1554 there may only be two strings hashing to the same value, even if this
1555 number is very large. */
1556 unsigned long bad_hash_matches
;
1558 /* Null strings aren't counted in this one.
1559 This will probably only be nonzero if we've got an input file
1560 which was produced by `ld -r' (i.e., it's already been processed
1561 through this code). Under some operating systems, native tools
1562 may make all empty strings have the same index; but the pointer
1563 check won't catch those, because to get to that stage we'd already
1564 have to compute the checksum, which requires reading the string,
1565 so we short-circuit that case with empty_string_index above. */
1566 unsigned long pointer_matches
;
1568 /* Number of comparisons done. I figure with the algorithms in use below,
1569 the average number of comparisons done (per symbol) should be roughly
1570 log-base-2 of the number of unique strings. */
1571 unsigned long n_compares
;
1575 /* Some utility functions for the string table code. */
1577 /* For speed, only hash on the first this many bytes of strings.
1578 This number was chosen by profiling ld linking itself, with -g. */
1579 #define HASHMAXLEN 25
1581 #define HASH_CHAR(c) (sum ^= sum >> 20, sum ^= sum << 7, sum += (c))
1583 static INLINE
unsigned int
1585 unsigned char *string
;
1586 register unsigned int len
;
1588 register unsigned int sum
= 0;
1590 if (len
> HASHMAXLEN
)
1598 HASH_CHAR (*string
++);
1604 stringtab_init (tab
)
1605 struct stringtab_data
*tab
;
1608 tab
->output_order
= 0;
1610 tab
->end
= &tab
->output_order
;
1612 /* Initial string table length includes size of length field. */
1613 tab
->index
= BYTES_IN_WORD
;
1614 tab
->empty_string_index
= -1;
1615 #ifdef GATHER_STATISTICS
1616 tab
->duplicates
= 0;
1617 tab
->empty_strings
= 0;
1618 tab
->bad_hash_matches
= 0;
1619 tab
->pointer_matches
= 0;
1620 tab
->bytes_saved
= 0;
1621 tab
->n_compares
= 0;
1626 compare (entry
, str
, hash
)
1627 struct stringtab_entry
*entry
;
1631 return hash
- entry
->hash
;
1634 #ifdef GATHER_STATISTICS
1635 /* Don't want to have to link in math library with all bfd applications... */
1636 static INLINE
double
1644 return ((d
> 1.41) ? 0.5 : 0) + n
;
1648 /* Main string table routines. */
1649 /* Returns index in string table. Whether or not this actually adds an
1650 entry into the string table should be irrelevant -- it just has to
1651 return a valid index. */
1652 static bfd_size_type
1653 add_to_stringtab (abfd
, str
, tab
)
1656 struct stringtab_data
*tab
;
1658 struct stringtab_entry
**ep
;
1659 register struct stringtab_entry
*entry
;
1660 unsigned int hashval
, len
;
1664 bfd_size_type index
;
1665 CONST bfd_size_type minus_one
= -1;
1667 #ifdef GATHER_STATISTICS
1668 tab
->empty_strings
++;
1670 index
= tab
->empty_string_index
;
1671 if (index
!= minus_one
)
1674 #ifdef GATHER_STATISTICS
1681 /* Need to find it. */
1682 entry
= tab
->strings
;
1685 index
= entry
->index
+ strlen (entry
->string
);
1686 tab
->empty_string_index
= index
;
1694 /* The hash_zero value is chosen such that the first symbol gets a value of
1695 zero. With a balanced tree, this wouldn't be very useful, but without it,
1696 we might get a more even split at the top level, instead of skewing it
1697 badly should hash("/usr/lib/crt0.o") (or whatever) be far from zero. */
1698 hashval
= hash (str
, len
) ^ tab
->hash_zero
;
1702 tab
->hash_zero
= hashval
;
1712 #ifdef GATHER_STATISTICS
1715 cmp
= compare (entry
, str
, hashval
);
1716 /* The not-equal cases are more frequent, so check them first. */
1718 ep
= &entry
->greater
;
1723 if (entry
->string
== str
)
1725 #ifdef GATHER_STATISTICS
1726 tab
->pointer_matches
++;
1730 /* Compare the first bytes to save a function call if they
1732 if (entry
->string
[0] == str
[0] && !strcmp (entry
->string
, str
))
1735 #ifdef GATHER_STATISTICS
1737 tab
->bytes_saved
+= len
+ 1;
1740 /* If we're in the linker, and the new string is from a new
1741 input file which might have already had these reductions
1742 run over it, we want to keep the new string pointer. I
1743 don't think we're likely to see any (or nearly as many,
1744 at least) cases where a later string is in the same location
1745 as an earlier one rather than this one. */
1746 entry
->string
= str
;
1747 return entry
->index
;
1749 #ifdef GATHER_STATISTICS
1750 tab
->bad_hash_matches
++;
1752 ep
= &entry
->greater
;
1756 /* If we get here, nothing that's in the table already matched.
1757 EP points to the `next' field at the end of the chain; stick a
1758 new entry on here. */
1760 entry
= (struct stringtab_entry
*)
1761 bfd_alloc_by_size_t (abfd
, sizeof (struct stringtab_entry
));
1763 entry
->less
= entry
->greater
= 0;
1764 entry
->hash
= hashval
;
1765 entry
->index
= tab
->index
;
1766 entry
->string
= str
;
1767 entry
->next_to_output
= 0;
1768 #ifdef GATHER_STATISTICS
1772 assert (*tab
->end
== 0);
1773 *(tab
->end
) = entry
;
1774 tab
->end
= &entry
->next_to_output
;
1775 assert (*tab
->end
== 0);
1778 tab
->index
+= len
+ 1;
1780 tab
->empty_string_index
= entry
->index
;
1784 return entry
->index
;
1788 emit_strtab (abfd
, tab
)
1790 struct stringtab_data
*tab
;
1792 struct stringtab_entry
*entry
;
1793 #ifdef GATHER_STATISTICS
1797 /* Be sure to put string length into correct byte ordering before writing
1799 char buffer
[BYTES_IN_WORD
];
1801 PUT_WORD (abfd
, tab
->index
, (unsigned char *) buffer
);
1802 bfd_write ((PTR
) buffer
, 1, BYTES_IN_WORD
, abfd
);
1804 for (entry
= tab
->output_order
; entry
; entry
= entry
->next_to_output
)
1806 bfd_write ((PTR
) entry
->string
, 1, strlen (entry
->string
) + 1, abfd
);
1807 #ifdef GATHER_STATISTICS
1812 #ifdef GATHER_STATISTICS
1813 /* Short form only, for now.
1814 To do: Specify output file. Conditionalize on environment? Detailed
1815 analysis if desired. */
1817 int n_syms
= bfd_get_symcount (abfd
);
1819 fprintf (stderr
, "String table data for output file:\n");
1820 fprintf (stderr
, " %8d symbols output\n", n_syms
);
1821 fprintf (stderr
, " %8d duplicate strings\n", tab
->duplicates
);
1822 fprintf (stderr
, " %8d empty strings\n", tab
->empty_strings
);
1823 fprintf (stderr
, " %8d unique strings output\n", count
);
1824 fprintf (stderr
, " %8d pointer matches\n", tab
->pointer_matches
);
1825 fprintf (stderr
, " %8d bytes saved\n", tab
->bytes_saved
);
1826 fprintf (stderr
, " %8d bad hash matches\n", tab
->bad_hash_matches
);
1827 fprintf (stderr
, " %8d hash-val comparisons\n", tab
->n_compares
);
1830 double n_compares
= tab
->n_compares
;
1831 double avg_compares
= n_compares
/ n_syms
;
1832 /* The second value here should usually be near one. */
1834 "\t average %f comparisons per symbol (%f * log2 nstrings)\n",
1835 avg_compares
, avg_compares
/ log2 (count
));
1842 generic = bfd_get_outsymbols(abfd);
1843 for (count = 0; count < bfd_get_symcount(abfd); count++)
1845 asymbol *g = *(generic++);
1849 size_t length = strlen(g->name)+1;
1850 bfd_write((PTR)g->name, 1, length, abfd);
1852 g->KEEPIT = (KEEPITTYPE) count;
1857 DEFUN(NAME(aout
,write_syms
),(abfd
),
1860 unsigned int count
;
1861 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1862 struct stringtab_data strtab
;
1864 stringtab_init (&strtab
);
1866 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1868 asymbol
*g
= generic
[count
];
1869 struct external_nlist nsp
;
1872 PUT_WORD (abfd
, add_to_stringtab (abfd
, g
->name
, &strtab
),
1873 (unsigned char *) nsp
.e_strx
);
1875 PUT_WORD (abfd
, 0, (unsigned char *)nsp
.e_strx
);
1877 if (bfd_asymbol_flavour(g
) == abfd
->xvec
->flavour
)
1879 bfd_h_put_16(abfd
, aout_symbol(g
)->desc
, nsp
.e_desc
);
1880 bfd_h_put_8(abfd
, aout_symbol(g
)->other
, nsp
.e_other
);
1881 bfd_h_put_8(abfd
, aout_symbol(g
)->type
, nsp
.e_type
);
1885 bfd_h_put_16(abfd
,0, nsp
.e_desc
);
1886 bfd_h_put_8(abfd
, 0, nsp
.e_other
);
1887 bfd_h_put_8(abfd
, 0, nsp
.e_type
);
1890 if (! translate_to_native_sym_flags (&nsp
, g
, abfd
))
1893 if (bfd_write((PTR
)&nsp
,1,EXTERNAL_NLIST_SIZE
, abfd
)
1894 != EXTERNAL_NLIST_SIZE
)
1897 /* NB: `KEEPIT' currently overlays `flags', so set this only
1898 here, at the end. */
1902 emit_strtab (abfd
, &strtab
);
1909 DEFUN(NAME(aout
,get_symtab
),(abfd
, location
),
1913 unsigned int counter
= 0;
1914 aout_symbol_type
*symbase
;
1916 if (!NAME(aout
,slurp_symbol_table
)(abfd
)) return 0;
1918 for (symbase
= obj_aout_symbols(abfd
); counter
++ < bfd_get_symcount (abfd
);)
1919 *(location
++) = (asymbol
*)( symbase
++);
1921 return bfd_get_symcount (abfd
);
1925 /* Standard reloc stuff */
1926 /* Output standard relocation information to a file in target byte order. */
1929 DEFUN(NAME(aout
,swap_std_reloc_out
),(abfd
, g
, natptr
),
1932 struct reloc_std_external
*natptr
)
1935 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1937 unsigned int r_length
;
1939 int r_baserel
, r_jmptable
, r_relative
;
1940 asection
*output_section
= sym
->section
->output_section
;
1942 PUT_WORD(abfd
, g
->address
, natptr
->r_address
);
1944 r_length
= g
->howto
->size
; /* Size as a power of two */
1945 r_pcrel
= (int) g
->howto
->pc_relative
; /* Relative to PC? */
1946 /* XXX This relies on relocs coming from a.out files. */
1947 r_baserel
= (g
->howto
->type
& 8) != 0;
1948 /* r_jmptable, r_relative??? FIXME-soon */
1953 /* For a standard reloc, the addend is in the object file. */
1954 r_addend
= g
->addend
+ (*(g
->sym_ptr_ptr
))->section
->output_section
->vma
;
1957 /* name was clobbered by aout_write_syms to be symbol index */
1959 /* If this relocation is relative to a symbol then set the
1960 r_index to the symbols index, and the r_extern bit.
1962 Absolute symbols can come in in two ways, either as an offset
1963 from the abs section, or as a symbol which has an abs value.
1968 if (bfd_is_com_section (output_section
)
1969 || output_section
== &bfd_abs_section
1970 || output_section
== &bfd_und_section
)
1972 if (bfd_abs_section
.symbol
== sym
)
1974 /* Whoops, looked like an abs symbol, but is really an offset
1975 from the abs section */
1981 /* Fill in symbol */
1983 r_index
= stoi((*(g
->sym_ptr_ptr
))->KEEPIT
);
1989 /* Just an ordinary section */
1991 r_index
= output_section
->target_index
;
1994 /* now the fun stuff */
1995 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
1996 natptr
->r_index
[0] = r_index
>> 16;
1997 natptr
->r_index
[1] = r_index
>> 8;
1998 natptr
->r_index
[2] = r_index
;
2000 (r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
2001 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
2002 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
2003 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
2004 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
2005 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
);
2007 natptr
->r_index
[2] = r_index
>> 16;
2008 natptr
->r_index
[1] = r_index
>> 8;
2009 natptr
->r_index
[0] = r_index
;
2011 (r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
2012 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
2013 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
2014 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
2015 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
2016 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
);
2021 /* Extended stuff */
2022 /* Output extended relocation information to a file in target byte order. */
2025 DEFUN(NAME(aout
,swap_ext_reloc_out
),(abfd
, g
, natptr
),
2028 register struct reloc_ext_external
*natptr
)
2032 unsigned int r_type
;
2033 unsigned int r_addend
;
2034 asymbol
*sym
= *(g
->sym_ptr_ptr
);
2035 asection
*output_section
= sym
->section
->output_section
;
2037 PUT_WORD (abfd
, g
->address
, natptr
->r_address
);
2039 r_type
= (unsigned int) g
->howto
->type
;
2041 r_addend
= g
->addend
+ (*(g
->sym_ptr_ptr
))->section
->output_section
->vma
;
2043 /* If this relocation is relative to a symbol then set the
2044 r_index to the symbols index, and the r_extern bit.
2046 Absolute symbols can come in in two ways, either as an offset
2047 from the abs section, or as a symbol which has an abs value.
2048 check for that here. */
2050 if (bfd_is_com_section (output_section
)
2051 || output_section
== &bfd_abs_section
2052 || output_section
== &bfd_und_section
)
2054 if (bfd_abs_section
.symbol
== sym
)
2056 /* Whoops, looked like an abs symbol, but is really an offset
2057 from the abs section */
2064 r_index
= stoi((*(g
->sym_ptr_ptr
))->KEEPIT
);
2069 /* Just an ordinary section */
2071 r_index
= output_section
->target_index
;
2074 /* now the fun stuff */
2075 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
2076 natptr
->r_index
[0] = r_index
>> 16;
2077 natptr
->r_index
[1] = r_index
>> 8;
2078 natptr
->r_index
[2] = r_index
;
2080 ((r_extern
? RELOC_EXT_BITS_EXTERN_BIG
: 0)
2081 | (r_type
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
2083 natptr
->r_index
[2] = r_index
>> 16;
2084 natptr
->r_index
[1] = r_index
>> 8;
2085 natptr
->r_index
[0] = r_index
;
2087 (r_extern
? RELOC_EXT_BITS_EXTERN_LITTLE
: 0)
2088 | (r_type
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
);
2091 PUT_WORD (abfd
, r_addend
, natptr
->r_addend
);
2094 /* BFD deals internally with all things based from the section they're
2095 in. so, something in 10 bytes into a text section with a base of
2096 50 would have a symbol (.text+10) and know .text vma was 50.
2098 Aout keeps all it's symbols based from zero, so the symbol would
2099 contain 60. This macro subs the base of each section from the value
2100 to give the true offset from the section */
2103 #define MOVE_ADDRESS(ad) \
2105 /* undefined symbol */ \
2106 cache_ptr->sym_ptr_ptr = symbols + r_index; \
2107 cache_ptr->addend = ad; \
2109 /* defined, section relative. replace symbol with pointer to \
2110 symbol which points to section */ \
2111 switch (r_index) { \
2113 case N_TEXT | N_EXT: \
2114 cache_ptr->sym_ptr_ptr = obj_textsec(abfd)->symbol_ptr_ptr; \
2115 cache_ptr->addend = ad - su->textsec->vma; \
2118 case N_DATA | N_EXT: \
2119 cache_ptr->sym_ptr_ptr = obj_datasec(abfd)->symbol_ptr_ptr; \
2120 cache_ptr->addend = ad - su->datasec->vma; \
2123 case N_BSS | N_EXT: \
2124 cache_ptr->sym_ptr_ptr = obj_bsssec(abfd)->symbol_ptr_ptr; \
2125 cache_ptr->addend = ad - su->bsssec->vma; \
2129 case N_ABS | N_EXT: \
2130 cache_ptr->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr; \
2131 cache_ptr->addend = ad; \
2137 DEFUN(NAME(aout
,swap_ext_reloc_in
), (abfd
, bytes
, cache_ptr
, symbols
),
2139 struct reloc_ext_external
*bytes AND
2140 arelent
*cache_ptr AND
2145 unsigned int r_type
;
2146 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
2148 cache_ptr
->address
= (GET_SWORD (abfd
, bytes
->r_address
));
2150 /* now the fun stuff */
2151 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
2152 r_index
= (bytes
->r_index
[0] << 16)
2153 | (bytes
->r_index
[1] << 8)
2154 | bytes
->r_index
[2];
2155 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
2156 r_type
= (bytes
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
2157 >> RELOC_EXT_BITS_TYPE_SH_BIG
;
2159 r_index
= (bytes
->r_index
[2] << 16)
2160 | (bytes
->r_index
[1] << 8)
2161 | bytes
->r_index
[0];
2162 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
2163 r_type
= (bytes
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
2164 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
;
2167 cache_ptr
->howto
= howto_table_ext
+ r_type
;
2168 MOVE_ADDRESS(GET_SWORD(abfd
, bytes
->r_addend
));
2172 DEFUN(NAME(aout
,swap_std_reloc_in
), (abfd
, bytes
, cache_ptr
, symbols
),
2174 struct reloc_std_external
*bytes AND
2175 arelent
*cache_ptr AND
2180 unsigned int r_length
;
2182 int r_baserel
, r_jmptable
, r_relative
;
2183 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
2186 cache_ptr
->address
= bfd_h_get_32 (abfd
, bytes
->r_address
);
2188 /* now the fun stuff */
2189 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
2190 r_index
= (bytes
->r_index
[0] << 16)
2191 | (bytes
->r_index
[1] << 8)
2192 | bytes
->r_index
[2];
2193 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
));
2194 r_pcrel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_PCREL_BIG
));
2195 r_baserel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
2196 r_jmptable
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
2197 r_relative
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_RELATIVE_BIG
));
2198 r_length
= (bytes
->r_type
[0] & RELOC_STD_BITS_LENGTH_BIG
)
2199 >> RELOC_STD_BITS_LENGTH_SH_BIG
;
2201 r_index
= (bytes
->r_index
[2] << 16)
2202 | (bytes
->r_index
[1] << 8)
2203 | bytes
->r_index
[0];
2204 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
));
2205 r_pcrel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_PCREL_LITTLE
));
2206 r_baserel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_BASEREL_LITTLE
));
2207 r_jmptable
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_LITTLE
));
2208 r_relative
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_RELATIVE_LITTLE
));
2209 r_length
= (bytes
->r_type
[0] & RELOC_STD_BITS_LENGTH_LITTLE
)
2210 >> RELOC_STD_BITS_LENGTH_SH_LITTLE
;
2213 howto_idx
= r_length
+ 4 * r_pcrel
+ 8 * r_baserel
;
2214 BFD_ASSERT (howto_idx
< TABLE_SIZE (howto_table_std
));
2215 cache_ptr
->howto
= howto_table_std
+ howto_idx
;
2216 BFD_ASSERT (cache_ptr
->howto
->type
!= -1);
2217 BFD_ASSERT (r_jmptable
== 0);
2218 BFD_ASSERT (r_relative
== 0);
2219 /* FIXME-soon: Roll jmptable, relative bits into howto setting */
2227 DEFUN(NAME(aout
,slurp_reloc_table
),(abfd
, asect
, symbols
),
2233 bfd_size_type reloc_size
;
2235 arelent
*reloc_cache
;
2238 if (asect
->relocation
) return true;
2240 if (asect
->flags
& SEC_CONSTRUCTOR
) return true;
2242 if (asect
== obj_datasec (abfd
)) {
2243 reloc_size
= exec_hdr(abfd
)->a_drsize
;
2244 } else if (asect
== obj_textsec (abfd
)) {
2245 reloc_size
= exec_hdr(abfd
)->a_trsize
;
2247 bfd_error
= invalid_operation
;
2251 bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
);
2252 each_size
= obj_reloc_entry_size (abfd
);
2254 count
= reloc_size
/ each_size
;
2257 reloc_cache
= (arelent
*) bfd_zalloc (abfd
, (size_t)(count
* sizeof
2261 bfd_error
= no_memory
;
2265 relocs
= (PTR
) bfd_alloc (abfd
, reloc_size
);
2267 bfd_release (abfd
, reloc_cache
);
2271 if (bfd_read (relocs
, 1, reloc_size
, abfd
) != reloc_size
) {
2272 bfd_release (abfd
, relocs
);
2273 bfd_release (abfd
, reloc_cache
);
2274 bfd_error
= system_call_error
;
2278 if (each_size
== RELOC_EXT_SIZE
) {
2279 register struct reloc_ext_external
*rptr
= (struct reloc_ext_external
*) relocs
;
2280 unsigned int counter
= 0;
2281 arelent
*cache_ptr
= reloc_cache
;
2283 for (; counter
< count
; counter
++, rptr
++, cache_ptr
++) {
2284 NAME(aout
,swap_ext_reloc_in
)(abfd
, rptr
, cache_ptr
, symbols
);
2287 register struct reloc_std_external
*rptr
= (struct reloc_std_external
*) relocs
;
2288 unsigned int counter
= 0;
2289 arelent
*cache_ptr
= reloc_cache
;
2291 for (; counter
< count
; counter
++, rptr
++, cache_ptr
++) {
2292 NAME(aout
,swap_std_reloc_in
)(abfd
, rptr
, cache_ptr
, symbols
);
2297 bfd_release (abfd
,relocs
);
2298 asect
->relocation
= reloc_cache
;
2299 asect
->reloc_count
= count
;
2305 /* Write out a relocation section into an object file. */
2308 DEFUN(NAME(aout
,squirt_out_relocs
),(abfd
, section
),
2313 unsigned char *native
, *natptr
;
2316 unsigned int count
= section
->reloc_count
;
2319 if (count
== 0) return true;
2321 each_size
= obj_reloc_entry_size (abfd
);
2322 natsize
= each_size
* count
;
2323 native
= (unsigned char *) bfd_zalloc (abfd
, natsize
);
2325 bfd_error
= no_memory
;
2329 generic
= section
->orelocation
;
2331 if (each_size
== RELOC_EXT_SIZE
)
2333 for (natptr
= native
;
2335 --count
, natptr
+= each_size
, ++generic
)
2336 NAME(aout
,swap_ext_reloc_out
) (abfd
, *generic
, (struct reloc_ext_external
*)natptr
);
2340 for (natptr
= native
;
2342 --count
, natptr
+= each_size
, ++generic
)
2343 NAME(aout
,swap_std_reloc_out
)(abfd
, *generic
, (struct reloc_std_external
*)natptr
);
2346 if ( bfd_write ((PTR
) native
, 1, natsize
, abfd
) != natsize
) {
2347 bfd_release(abfd
, native
);
2350 bfd_release (abfd
, native
);
2355 /* This is stupid. This function should be a boolean predicate */
2357 DEFUN(NAME(aout
,canonicalize_reloc
),(abfd
, section
, relptr
, symbols
),
2360 arelent
**relptr AND
2363 arelent
*tblptr
= section
->relocation
;
2366 if (!(tblptr
|| NAME(aout
,slurp_reloc_table
)(abfd
, section
, symbols
)))
2369 if (section
->flags
& SEC_CONSTRUCTOR
) {
2370 arelent_chain
*chain
= section
->constructor_chain
;
2371 for (count
= 0; count
< section
->reloc_count
; count
++) {
2372 *relptr
++ = &chain
->relent
;
2373 chain
= chain
->next
;
2377 tblptr
= section
->relocation
;
2378 if (!tblptr
) return 0;
2380 for (count
= 0; count
++ < section
->reloc_count
;)
2382 *relptr
++ = tblptr
++;
2387 return section
->reloc_count
;
2391 DEFUN(NAME(aout
,get_reloc_upper_bound
),(abfd
, asect
),
2395 if (bfd_get_format (abfd
) != bfd_object
) {
2396 bfd_error
= invalid_operation
;
2399 if (asect
->flags
& SEC_CONSTRUCTOR
) {
2400 return (sizeof (arelent
*) * (asect
->reloc_count
+1));
2404 if (asect
== obj_datasec (abfd
))
2405 return (sizeof (arelent
*) *
2406 ((exec_hdr(abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
))
2409 if (asect
== obj_textsec (abfd
))
2410 return (sizeof (arelent
*) *
2411 ((exec_hdr(abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
))
2414 bfd_error
= invalid_operation
;
2420 DEFUN(NAME(aout
,get_symtab_upper_bound
),(abfd
),
2423 if (!NAME(aout
,slurp_symbol_table
)(abfd
)) return 0;
2425 return (bfd_get_symcount (abfd
)+1) * (sizeof (aout_symbol_type
*));
2430 DEFUN(NAME(aout
,get_lineno
),(ignore_abfd
, ignore_symbol
),
2431 bfd
*ignore_abfd AND
2432 asymbol
*ignore_symbol
)
2434 return (alent
*)NULL
;
2439 DEFUN(NAME(aout
,get_symbol_info
),(ignore_abfd
, symbol
, ret
),
2440 bfd
*ignore_abfd AND
2444 bfd_symbol_info (symbol
, ret
);
2446 if (ret
->type
== '?')
2448 int type_code
= aout_symbol(symbol
)->type
& 0xff;
2449 CONST
char *stab_name
= aout_stab_name(type_code
);
2450 static char buf
[10];
2452 if (stab_name
== NULL
)
2454 sprintf(buf
, "(%d)", type_code
);
2458 ret
->stab_other
= (unsigned)(aout_symbol(symbol
)->other
& 0xff);
2459 ret
->stab_desc
= (unsigned)(aout_symbol(symbol
)->desc
& 0xffff);
2460 ret
->stab_name
= stab_name
;
2466 DEFUN(NAME(aout
,print_symbol
),(ignore_abfd
, afile
, symbol
, how
),
2467 bfd
*ignore_abfd AND
2470 bfd_print_symbol_type how
)
2472 FILE *file
= (FILE *)afile
;
2475 case bfd_print_symbol_name
:
2477 fprintf(file
,"%s", symbol
->name
);
2479 case bfd_print_symbol_more
:
2480 fprintf(file
,"%4x %2x %2x",(unsigned)(aout_symbol(symbol
)->desc
& 0xffff),
2481 (unsigned)(aout_symbol(symbol
)->other
& 0xff),
2482 (unsigned)(aout_symbol(symbol
)->type
));
2484 case bfd_print_symbol_all
:
2486 CONST
char *section_name
= symbol
->section
->name
;
2489 bfd_print_symbol_vandf((PTR
)file
,symbol
);
2491 fprintf(file
," %-5s %04x %02x %02x",
2493 (unsigned)(aout_symbol(symbol
)->desc
& 0xffff),
2494 (unsigned)(aout_symbol(symbol
)->other
& 0xff),
2495 (unsigned)(aout_symbol(symbol
)->type
& 0xff));
2497 fprintf(file
," %s", symbol
->name
);
2504 provided a BFD, a section and an offset into the section, calculate
2505 and return the name of the source file and the line nearest to the
2510 DEFUN(NAME(aout
,find_nearest_line
),(abfd
,
2518 asection
*section AND
2519 asymbol
**symbols AND
2521 CONST
char **filename_ptr AND
2522 CONST
char **functionname_ptr AND
2523 unsigned int *line_ptr
)
2525 /* Run down the file looking for the filename, function and linenumber */
2527 static char buffer
[100];
2528 static char filename_buffer
[200];
2529 CONST
char *directory_name
= NULL
;
2530 CONST
char *main_file_name
= NULL
;
2531 CONST
char *current_file_name
= NULL
;
2532 CONST
char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2533 bfd_vma high_line_vma
= ~0;
2534 bfd_vma low_func_vma
= 0;
2536 *filename_ptr
= abfd
->filename
;
2537 *functionname_ptr
= 0;
2539 if (symbols
!= (asymbol
**)NULL
) {
2540 for (p
= symbols
; *p
; p
++) {
2541 aout_symbol_type
*q
= (aout_symbol_type
*)(*p
);
2545 main_file_name
= current_file_name
= q
->symbol
.name
;
2546 /* Look ahead to next symbol to check if that too is an N_SO. */
2550 q
= (aout_symbol_type
*)(*p
);
2551 if (q
->type
!= (int)N_SO
)
2554 /* Found a second N_SO First is directory; second is filename. */
2555 directory_name
= current_file_name
;
2556 main_file_name
= current_file_name
= q
->symbol
.name
;
2557 if (obj_textsec(abfd
) != section
)
2561 current_file_name
= q
->symbol
.name
;
2568 /* We'll keep this if it resolves nearer than the one we have already */
2569 if (q
->symbol
.value
>= offset
&&
2570 q
->symbol
.value
< high_line_vma
) {
2571 *line_ptr
= q
->desc
;
2572 high_line_vma
= q
->symbol
.value
;
2573 line_file_name
= current_file_name
;
2578 /* We'll keep this if it is nearer than the one we have already */
2579 if (q
->symbol
.value
>= low_func_vma
&&
2580 q
->symbol
.value
<= offset
) {
2581 low_func_vma
= q
->symbol
.value
;
2582 func
= (asymbol
*)q
;
2584 if (*line_ptr
&& func
) {
2585 CONST
char *function
= func
->name
;
2587 strncpy(buffer
, function
, sizeof(buffer
)-1);
2588 buffer
[sizeof(buffer
)-1] = 0;
2589 /* Have to remove : stuff */
2590 p
= strchr(buffer
,':');
2591 if (p
!= NULL
) { *p
= '\0'; }
2592 *functionname_ptr
= buffer
;
2604 main_file_name
= line_file_name
;
2605 if (main_file_name
) {
2606 if (main_file_name
[0] == '/' || directory_name
== NULL
)
2607 *filename_ptr
= main_file_name
;
2609 sprintf(filename_buffer
, "%.140s%.50s",
2610 directory_name
, main_file_name
);
2611 *filename_ptr
= filename_buffer
;
2620 DEFUN(NAME(aout
,sizeof_headers
),(abfd
, execable
),
2624 return adata(abfd
).exec_bytes_size
;
2627 /* a.out link code. */
2629 /* a.out linker hash table entries. */
2631 struct aout_link_hash_entry
2633 struct bfd_link_hash_entry root
;
2634 /* Symbol index in output file. */
2638 /* a.out linker hash table. */
2640 struct aout_link_hash_table
2642 struct bfd_link_hash_table root
;
2645 static struct bfd_hash_entry
*aout_link_hash_newfunc
2646 PARAMS ((struct bfd_hash_entry
*entry
,
2647 struct bfd_hash_table
*table
,
2648 const char *string
));
2649 static boolean aout_link_add_object_symbols
2650 PARAMS ((bfd
*, struct bfd_link_info
*));
2651 static boolean aout_link_check_archive_element
2652 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*));
2653 static boolean aout_link_get_symbols
PARAMS ((bfd
*));
2654 static boolean aout_link_free_symbols
PARAMS ((bfd
*));
2655 static boolean aout_link_check_ar_symbols
2656 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*pneeded
));
2657 static boolean aout_link_add_symbols
2658 PARAMS ((bfd
*, struct bfd_link_info
*));
2660 /* Routine to create an entry in an a.out link hash table. */
2662 static struct bfd_hash_entry
*
2663 aout_link_hash_newfunc (entry
, table
, string
)
2664 struct bfd_hash_entry
*entry
;
2665 struct bfd_hash_table
*table
;
2668 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2670 /* Allocate the structure if it has not already been allocated by a
2672 if (ret
== (struct aout_link_hash_entry
*) NULL
)
2673 ret
= ((struct aout_link_hash_entry
*)
2674 bfd_hash_allocate (table
, sizeof (struct aout_link_hash_entry
)));
2676 /* Call the allocation method of the superclass. */
2677 ret
= ((struct aout_link_hash_entry
*)
2678 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2681 /* Set local fields. */
2684 return (struct bfd_hash_entry
*) ret
;
2687 /* Create an a.out link hash table. */
2689 struct bfd_link_hash_table
*
2690 NAME(aout
,link_hash_table_create
) (abfd
)
2693 struct aout_link_hash_table
*ret
;
2695 ret
= ((struct aout_link_hash_table
*)
2696 bfd_xmalloc (sizeof (struct aout_link_hash_table
)));
2697 if (! _bfd_link_hash_table_init (&ret
->root
, abfd
,
2698 aout_link_hash_newfunc
))
2701 return (struct bfd_link_hash_table
*) NULL
;
2706 /* Look up an entry in an a.out link hash table. */
2708 #define aout_link_hash_lookup(table, string, create, copy, follow) \
2709 ((struct aout_link_hash_entry *) \
2710 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
2712 /* Traverse an a.out link hash table. */
2714 #define aout_link_hash_traverse(table, func, info) \
2715 (bfd_link_hash_traverse \
2717 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
2720 /* Get the a.out link hash table from the info structure. This is
2723 #define aout_hash_table(p) ((struct aout_link_hash_table *) ((p)->hash))
2725 /* Given an a.out BFD, add symbols to the global hash table as
2729 NAME(aout
,link_add_symbols
) (abfd
, info
)
2731 struct bfd_link_info
*info
;
2733 switch (bfd_get_format (abfd
))
2736 return aout_link_add_object_symbols (abfd
, info
);
2738 return _bfd_generic_link_add_archive_symbols
2739 (abfd
, info
, aout_link_check_archive_element
);
2741 bfd_error
= wrong_format
;
2746 /* Add symbols from an a.out object file. */
2749 aout_link_add_object_symbols (abfd
, info
)
2751 struct bfd_link_info
*info
;
2753 if (! aout_link_get_symbols (abfd
))
2755 if (! aout_link_add_symbols (abfd
, info
))
2757 if (! info
->keep_memory
)
2759 if (! aout_link_free_symbols (abfd
))
2765 /* Check a single archive element to see if we need to include it in
2766 the link. *PNEEDED is set according to whether this element is
2767 needed in the link or not. This is called from
2768 _bfd_generic_link_add_archive_symbols. */
2771 aout_link_check_archive_element (abfd
, info
, pneeded
)
2773 struct bfd_link_info
*info
;
2776 if (! aout_link_get_symbols (abfd
))
2779 if (! aout_link_check_ar_symbols (abfd
, info
, pneeded
))
2784 if (! aout_link_add_symbols (abfd
, info
))
2788 /* We keep around the symbols even if we aren't going to use this
2789 object file, because we may want to reread it. This doesn't
2790 waste too much memory, because it isn't all that common to read
2791 an archive element but not need it. */
2792 if (! info
->keep_memory
)
2794 if (! aout_link_free_symbols (abfd
))
2801 /* Read the internal symbols from an a.out file. */
2804 aout_link_get_symbols (abfd
)
2807 bfd_size_type count
;
2808 struct external_nlist
*syms
;
2809 unsigned char string_chars
[BYTES_IN_WORD
];
2810 bfd_size_type stringsize
;
2813 if (obj_aout_external_syms (abfd
) != (struct external_nlist
*) NULL
)
2815 /* We already have them. */
2819 count
= exec_hdr (abfd
)->a_syms
/ EXTERNAL_NLIST_SIZE
;
2821 /* We allocate using bfd_xmalloc to make the values easy to free
2822 later on. If we put them on the obstack it might not be possible
2824 syms
= ((struct external_nlist
*)
2825 bfd_xmalloc ((size_t) count
* EXTERNAL_NLIST_SIZE
));
2827 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2828 || (bfd_read ((PTR
) syms
, 1, exec_hdr (abfd
)->a_syms
, abfd
)
2829 != exec_hdr (abfd
)->a_syms
))
2832 /* Get the size of the strings. */
2833 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
2834 || (bfd_read ((PTR
) string_chars
, BYTES_IN_WORD
, 1, abfd
)
2837 stringsize
= GET_WORD (abfd
, string_chars
);
2838 strings
= (char *) bfd_xmalloc ((size_t) stringsize
);
2840 /* Skip space for the string count in the buffer for convenience
2841 when using indexes. */
2842 if (bfd_read (strings
+ BYTES_IN_WORD
, 1, stringsize
- BYTES_IN_WORD
, abfd
)
2843 != stringsize
- BYTES_IN_WORD
)
2846 /* Save the data. */
2847 obj_aout_external_syms (abfd
) = syms
;
2848 obj_aout_external_sym_count (abfd
) = count
;
2849 obj_aout_external_strings (abfd
) = strings
;
2854 /* Free up the internal symbols read from an a.out file. */
2857 aout_link_free_symbols (abfd
)
2860 if (obj_aout_external_syms (abfd
) != (struct external_nlist
*) NULL
)
2862 free ((PTR
) obj_aout_external_syms (abfd
));
2863 obj_aout_external_syms (abfd
) = (struct external_nlist
*) NULL
;
2865 if (obj_aout_external_strings (abfd
) != (char *) NULL
)
2867 free ((PTR
) obj_aout_external_strings (abfd
));
2868 obj_aout_external_strings (abfd
) = (char *) NULL
;
2873 /* Look through the internal symbols to see if this object file should
2874 be included in the link. We should include this object file if it
2875 defines any symbols which are currently undefined. If this object
2876 file defines a common symbol, then we may adjust the size of the
2877 known symbol but we do not include the object file in the link
2878 (unless there is some other reason to include it). */
2881 aout_link_check_ar_symbols (abfd
, info
, pneeded
)
2883 struct bfd_link_info
*info
;
2886 register struct external_nlist
*p
;
2887 struct external_nlist
*pend
;
2892 /* Look through all the symbols. */
2893 p
= obj_aout_external_syms (abfd
);
2894 pend
= p
+ obj_aout_external_sym_count (abfd
);
2895 strings
= obj_aout_external_strings (abfd
);
2896 for (; p
< pend
; p
++)
2898 int type
= bfd_h_get_8 (abfd
, p
->e_type
);
2900 struct bfd_link_hash_entry
*h
;
2902 /* Ignore symbols that are not externally visible. */
2903 if ((type
& N_EXT
) == 0)
2906 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
2907 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
2909 /* We are only interested in symbols that are currently
2910 undefined or common. */
2911 if (h
== (struct bfd_link_hash_entry
*) NULL
2912 || (h
->type
!= bfd_link_hash_undefined
2913 && h
->type
!= bfd_link_hash_common
))
2916 if ((type
& (N_TEXT
| N_DATA
| N_BSS
)) != 0)
2918 /* This object file defines this symbol. We must link it
2919 in. This is true regardless of whether the current
2920 definition of the symbol is undefined or common. If the
2921 current definition is common, we have a case in which we
2922 have already seen an object file including
2924 and this object file from the archive includes
2926 In such a case we must include this object file. */
2927 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
2933 if (type
== (N_EXT
| N_UNDF
))
2937 value
= GET_WORD (abfd
, p
->e_value
);
2940 /* This symbol is common in the object from the archive
2942 if (h
->type
== bfd_link_hash_undefined
)
2946 symbfd
= h
->u
.undef
.abfd
;
2947 if (symbfd
== (bfd
*) NULL
)
2949 /* This symbol was created as undefined from
2950 outside BFD. We assume that we should link
2951 in the object file. This is done for the -u
2952 option in the linker. */
2953 if (! (*info
->callbacks
->add_archive_element
) (info
,
2960 /* Turn the current link symbol into a common
2961 symbol. It is already on the undefs list. */
2962 h
->type
= bfd_link_hash_common
;
2963 h
->u
.c
.size
= value
;
2964 h
->u
.c
.section
= bfd_make_section_old_way (symbfd
,
2969 /* Adjust the size of the common symbol if
2971 if (value
> h
->u
.c
.size
)
2972 h
->u
.c
.size
= value
;
2978 /* We do not need this object file. */
2982 /* Add all symbols from an object file to the hash table. */
2985 aout_link_add_symbols (abfd
, info
)
2987 struct bfd_link_info
*info
;
2989 bfd_size_type sym_count
;
2992 struct aout_link_hash_entry
**sym_hash
;
2993 register struct external_nlist
*p
;
2994 struct external_nlist
*pend
;
2996 sym_count
= obj_aout_external_sym_count (abfd
);
2997 strings
= obj_aout_external_strings (abfd
);
2998 if (info
->keep_memory
)
3003 /* We keep a list of the linker hash table entries that correspond
3004 to particular symbols. We could just look them up in the hash
3005 table, but keeping the list is more efficient. Perhaps this
3006 should be conditional on info->keep_memory. */
3007 sym_hash
= ((struct aout_link_hash_entry
**)
3010 * sizeof (struct aout_link_hash_entry
*))));
3011 obj_aout_sym_hashes (abfd
) = sym_hash
;
3013 p
= obj_aout_external_syms (abfd
);
3014 pend
= p
+ sym_count
;
3015 for (; p
< pend
; p
++, sym_hash
++)
3026 type
= bfd_h_get_8 (abfd
, p
->e_type
);
3028 /* Ignore debugging symbols. */
3029 if ((type
& N_STAB
) != 0)
3032 /* Ignore symbols that are not external. */
3033 if ((type
& N_EXT
) == 0
3034 && type
!= N_WARNING
3040 /* If this is an N_INDR symbol we must skip the next entry,
3041 which is the symbol to indirect to (actually, an N_INDR
3042 symbol without N_EXT set is pretty useless). */
3051 /* Ignore N_FN symbols (these appear to have N_EXT set). */
3055 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3056 value
= GET_WORD (abfd
, p
->e_value
);
3063 case N_UNDF
| N_EXT
:
3065 section
= &bfd_com_section
;
3067 section
= &bfd_und_section
;
3070 section
= &bfd_abs_section
;
3072 case N_TEXT
| N_EXT
:
3073 section
= obj_textsec (abfd
);
3074 value
-= bfd_get_section_vma (abfd
, section
);
3076 case N_DATA
| N_EXT
:
3077 section
= obj_datasec (abfd
);
3078 value
-= bfd_get_section_vma (abfd
, section
);
3081 section
= obj_bsssec (abfd
);
3082 value
-= bfd_get_section_vma (abfd
, section
);
3084 case N_INDR
| N_EXT
:
3085 /* An indirect symbol. The next symbol is the symbol
3086 which this one really is. */
3087 BFD_ASSERT (p
+ 1 < pend
);
3089 string
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3090 section
= &bfd_ind_section
;
3091 flags
|= BSF_INDIRECT
;
3093 case N_COMM
| N_EXT
:
3094 section
= &bfd_com_section
;
3096 case N_SETA
: case N_SETA
| N_EXT
:
3097 section
= &bfd_abs_section
;
3098 flags
|= BSF_CONSTRUCTOR
;
3100 case N_SETT
: case N_SETT
| N_EXT
:
3101 section
= obj_textsec (abfd
);
3102 flags
|= BSF_CONSTRUCTOR
;
3103 value
-= bfd_get_section_vma (abfd
, section
);
3105 case N_SETD
: case N_SETD
| N_EXT
:
3106 section
= obj_datasec (abfd
);
3107 flags
|= BSF_CONSTRUCTOR
;
3108 value
-= bfd_get_section_vma (abfd
, section
);
3110 case N_SETB
: case N_SETB
| N_EXT
:
3111 section
= obj_bsssec (abfd
);
3112 flags
|= BSF_CONSTRUCTOR
;
3113 value
-= bfd_get_section_vma (abfd
, section
);
3116 /* A warning symbol. The next symbol is the one to warn
3118 BFD_ASSERT (p
+ 1 < pend
);
3121 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3122 section
= &bfd_und_section
;
3123 flags
|= BSF_WARNING
;
3127 if (! (_bfd_generic_link_add_one_symbol
3128 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, false,
3129 ARCH_SIZE
, (struct bfd_link_hash_entry
**) sym_hash
)))
3132 if (type
== (N_INDR
| N_EXT
) || type
== N_WARNING
)
3139 /* During the final link step we need to pass around a bunch of
3140 information, so we do it in an instance of this structure. */
3142 struct aout_final_link_info
3144 /* General link information. */
3145 struct bfd_link_info
*info
;
3148 /* Reloc file positions. */
3149 file_ptr treloff
, dreloff
;
3150 /* File position of symbols. */
3153 struct stringtab_data strtab
;
3156 static boolean aout_link_input_bfd
3157 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
));
3158 static boolean aout_link_write_symbols
3159 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
, int *symbol_map
));
3160 static boolean aout_link_write_other_symbol
3161 PARAMS ((struct aout_link_hash_entry
*, PTR
));
3162 static boolean aout_link_input_section
3163 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
,
3164 asection
*input_section
, file_ptr
*reloff_ptr
,
3165 bfd_size_type rel_size
, int *symbol_map
));
3166 static boolean aout_link_input_section_std
3167 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
,
3168 asection
*input_section
, struct reloc_std_external
*,
3169 bfd_size_type rel_size
, bfd_byte
*contents
, int *symbol_map
));
3170 static boolean aout_link_input_section_ext
3171 PARAMS ((struct aout_final_link_info
*, bfd
*input_bfd
,
3172 asection
*input_section
, struct reloc_ext_external
*,
3173 bfd_size_type rel_size
, bfd_byte
*contents
, int *symbol_map
));
3174 static INLINE asection
*aout_reloc_index_to_section
3175 PARAMS ((bfd
*, int));
3177 /* Do the final link step. This is called on the output BFD. The
3178 INFO structure should point to a list of BFDs linked through the
3179 link_next field which can be used to find each BFD which takes part
3180 in the output. Also, each section in ABFD should point to a list
3181 of bfd_link_order structures which list all the input sections for
3182 the output section. */
3185 NAME(aout
,final_link
) (abfd
, info
, callback
)
3187 struct bfd_link_info
*info
;
3188 void (*callback
) PARAMS ((bfd
*, file_ptr
*, file_ptr
*, file_ptr
*));
3190 struct aout_final_link_info aout_info
;
3192 bfd_size_type text_size
;
3194 register struct bfd_link_order
*p
;
3197 aout_info
.info
= info
;
3198 aout_info
.output_bfd
= abfd
;
3200 if (! info
->relocateable
)
3202 exec_hdr (abfd
)->a_trsize
= 0;
3203 exec_hdr (abfd
)->a_drsize
= 0;
3207 bfd_size_type trsize
, drsize
;
3209 /* Count up the relocation sizes. */
3212 for (sub
= info
->input_bfds
; sub
!= (bfd
*) NULL
; sub
= sub
->link_next
)
3214 if (bfd_get_flavour (abfd
) == bfd_target_aout_flavour
)
3216 trsize
+= exec_hdr (sub
)->a_trsize
;
3217 drsize
+= exec_hdr (sub
)->a_drsize
;
3221 /* FIXME: We need to identify the .text and .data sections
3222 and call get_reloc_upper_bound and canonicalize_reloc to
3223 work out the number of relocs needed, and then multiply
3224 by the reloc size. */
3228 exec_hdr (abfd
)->a_trsize
= trsize
;
3229 exec_hdr (abfd
)->a_drsize
= drsize
;
3232 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
3234 /* Adjust the section sizes and vmas according to the magic number.
3235 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3236 filepos for each section. */
3237 if (! NAME(aout
,adjust_sizes_and_vmas
) (abfd
, &text_size
, &text_end
))
3240 /* The relocation and symbol file positions differ among a.out
3241 targets. We are passed a callback routine from the backend
3242 specific code to handle this.
3243 FIXME: At this point we do not know how much space the symbol
3244 table will require. This will not work for any (nonstandard)
3245 a.out target that needs to know the symbol table size before it
3246 can compute the relocation file positions. This may or may not
3247 be the case for the hp300hpux target, for example. */
3248 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
3250 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
3251 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
3252 obj_sym_filepos (abfd
) = aout_info
.symoff
;
3254 /* We keep a count of the symbols as we output them. */
3255 obj_aout_external_sym_count (abfd
) = 0;
3257 /* We accumulate the string table as we write out the symbols. */
3258 stringtab_init (&aout_info
.strtab
);
3260 /* The most time efficient way to do the link would be to read all
3261 the input object files into memory and then sort out the
3262 information into the output file. Unfortunately, that will
3263 probably use too much memory. Another method would be to step
3264 through everything that composes the text section and write it
3265 out, and then everything that composes the data section and write
3266 it out, and then write out the relocs, and then write out the
3267 symbols. Unfortunately, that requires reading stuff from each
3268 input file several times, and we will not be able to keep all the
3269 input files open simultaneously, and reopening them will be slow.
3271 What we do is basically process one input file at a time. We do
3272 everything we need to do with an input file once--copy over the
3273 section contents, handle the relocation information, and write
3274 out the symbols--and then we throw away the information we read
3275 from it. This approach requires a lot of lseeks of the output
3276 file, which is unfortunate but still faster than reopening a lot
3279 We use the output_has_begun field of the input BFDs to see
3280 whether we have already handled it. */
3281 for (sub
= info
->input_bfds
; sub
!= (bfd
*) NULL
; sub
= sub
->link_next
)
3282 sub
->output_has_begun
= false;
3284 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3286 for (p
= o
->link_order_head
;
3287 p
!= (struct bfd_link_order
*) NULL
;
3290 /* If we might be using the C based alloca function, we need
3291 to dump the memory allocated by aout_link_input_bfd. */
3297 if (p
->type
== bfd_indirect_link_order
3298 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
3299 == bfd_target_aout_flavour
))
3303 input_bfd
= p
->u
.indirect
.section
->owner
;
3304 if (! input_bfd
->output_has_begun
)
3306 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
3308 input_bfd
->output_has_begun
= true;
3313 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3319 /* Write out any symbols that we have not already written out. */
3320 aout_link_hash_traverse (aout_hash_table (info
),
3321 aout_link_write_other_symbol
,
3324 /* Update the header information. */
3325 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
3326 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
3327 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
3328 obj_textsec (abfd
)->reloc_count
=
3329 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
3330 obj_datasec (abfd
)->reloc_count
=
3331 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
3333 /* Write out the string table. */
3334 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0)
3336 emit_strtab (abfd
, &aout_info
.strtab
);
3341 /* Link an a.out input BFD into the output file. */
3344 aout_link_input_bfd (finfo
, input_bfd
)
3345 struct aout_final_link_info
*finfo
;
3348 bfd_size_type sym_count
;
3351 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
3353 /* Get the symbols. We probably have them already, unless
3354 finfo->info->keep_memory is false. */
3355 if (! aout_link_get_symbols (input_bfd
))
3358 sym_count
= obj_aout_external_sym_count (input_bfd
);
3359 symbol_map
= (int *) alloca ((size_t) sym_count
* sizeof (int));
3361 /* Write out the symbols and get a map of the new indices. */
3362 if (! aout_link_write_symbols (finfo
, input_bfd
, symbol_map
))
3365 /* Relocate and write out the sections. */
3366 if (! aout_link_input_section (finfo
, input_bfd
,
3367 obj_textsec (input_bfd
),
3369 exec_hdr (input_bfd
)->a_trsize
,
3371 || ! aout_link_input_section (finfo
, input_bfd
,
3372 obj_datasec (input_bfd
),
3374 exec_hdr (input_bfd
)->a_drsize
,
3378 /* If we are not keeping memory, we don't need the symbols any
3379 longer. We still need them if we are keeping memory, because the
3380 strings in the hash table point into them. */
3381 if (! finfo
->info
->keep_memory
)
3383 if (! aout_link_free_symbols (input_bfd
))
3390 /* Adjust and write out the symbols for an a.out file. Set the new
3391 symbol indices into a symbol_map. */
3394 aout_link_write_symbols (finfo
, input_bfd
, symbol_map
)
3395 struct aout_final_link_info
*finfo
;
3400 bfd_size_type sym_count
;
3402 enum bfd_link_strip strip
;
3403 enum bfd_link_discard discard
;
3404 struct external_nlist
*output_syms
;
3405 struct external_nlist
*outsym
;
3406 register struct external_nlist
*sym
;
3407 struct external_nlist
*sym_end
;
3408 struct aout_link_hash_entry
**sym_hash
;
3410 boolean skip_indirect
;
3412 output_bfd
= finfo
->output_bfd
;
3413 sym_count
= obj_aout_external_sym_count (input_bfd
);
3414 strings
= obj_aout_external_strings (input_bfd
);
3415 strip
= finfo
->info
->strip
;
3416 discard
= finfo
->info
->discard
;
3417 output_syms
= ((struct external_nlist
*)
3418 alloca ((size_t) (sym_count
+ 1) * EXTERNAL_NLIST_SIZE
));
3419 outsym
= output_syms
;
3421 /* First write out a symbol for this object file, unless we are
3422 discarding such symbols. */
3423 if (strip
!= strip_all
3424 && (strip
!= strip_some
3425 || bfd_hash_lookup (finfo
->info
->keep_hash
, input_bfd
->filename
,
3426 false, false) != NULL
)
3427 && discard
!= discard_all
)
3429 bfd_h_put_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
3430 bfd_h_put_8 (output_bfd
, 0, outsym
->e_other
);
3431 bfd_h_put_16 (output_bfd
, (bfd_vma
) 0, outsym
->e_desc
);
3432 PUT_WORD (output_bfd
,
3433 add_to_stringtab (output_bfd
, input_bfd
->filename
,
3436 PUT_WORD (output_bfd
,
3437 bfd_get_section_vma (input_bfd
, obj_textsec (input_bfd
)),
3439 ++obj_aout_external_sym_count (output_bfd
);
3444 skip_indirect
= false;
3445 sym
= obj_aout_external_syms (input_bfd
);
3446 sym_end
= sym
+ sym_count
;
3447 sym_hash
= obj_aout_sym_hashes (input_bfd
);
3448 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
3458 type
= bfd_h_get_8 (input_bfd
, sym
->e_type
);
3459 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
3463 /* Pass this symbol through. It is the target of an
3464 indirect or warning symbol. */
3465 val
= GET_WORD (input_bfd
, sym
->e_value
);
3468 else if (skip_indirect
)
3470 /* Skip this symbol, which is the target of an indirect
3471 symbol that we have changed to no longer be an indirect
3473 skip_indirect
= false;
3478 struct aout_link_hash_entry
*h
;
3479 struct aout_link_hash_entry
*hresolve
;
3481 /* We have saved the hash table entry for this symbol, if
3482 there is one. Note that we could just look it up again
3483 in the hash table, provided we first check that it is an
3487 /* If this is an indirect symbol, then change hresolve to
3488 the base symbol. We also change sym_hash so that the
3489 relocation routines relocate against the real symbol. */
3491 if (h
!= (struct aout_link_hash_entry
*) NULL
3492 && h
->root
.type
== bfd_link_hash_indirect
)
3494 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
3495 while (hresolve
->root
.type
== bfd_link_hash_indirect
)
3496 hresolve
= ((struct aout_link_hash_entry
*)
3497 hresolve
->root
.u
.i
.link
);
3498 *sym_hash
= hresolve
;
3501 /* If the symbol has already been written out, skip it. */
3502 if (h
!= (struct aout_link_hash_entry
*) NULL
3505 *symbol_map
= h
->indx
;
3509 /* See if we are stripping this symbol. */
3515 case strip_debugger
:
3516 if ((type
& N_STAB
) != 0)
3520 if (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
3530 if (h
!= (struct aout_link_hash_entry
*) NULL
)
3531 h
->root
.written
= true;
3535 /* Get the value of the symbol. */
3536 if ((type
& N_TYPE
) == N_TEXT
)
3537 symsec
= obj_textsec (input_bfd
);
3538 else if ((type
& N_TYPE
) == N_DATA
)
3539 symsec
= obj_datasec (input_bfd
);
3540 else if ((type
& N_TYPE
) == N_BSS
)
3541 symsec
= obj_bsssec (input_bfd
);
3542 else if ((type
& N_TYPE
) == N_ABS
)
3543 symsec
= &bfd_abs_section
;
3544 else if (((type
& N_TYPE
) == N_INDR
3545 && (hresolve
== (struct aout_link_hash_entry
*) NULL
3546 || (hresolve
->root
.type
!= bfd_link_hash_defined
3547 && hresolve
->root
.type
!= bfd_link_hash_common
)))
3548 || type
== N_WARNING
)
3550 /* Pass the next symbol through unchanged. The
3551 condition above for indirect symbols is so that if
3552 the indirect symbol was defined, we output it with
3553 the correct definition so the debugger will
3556 val
= GET_WORD (input_bfd
, sym
->e_value
);
3559 else if ((type
& N_STAB
) != 0)
3561 val
= GET_WORD (input_bfd
, sym
->e_value
);
3566 /* If we get here with an indirect symbol, it means that
3567 we are outputting it with a real definition. In such
3568 a case we do not want to output the next symbol,
3569 which is the target of the indirection. */
3570 if ((type
& N_TYPE
) == N_INDR
)
3571 skip_indirect
= true;
3573 /* We need to get the value from the hash table. We use
3574 hresolve so that if we have defined an indirect
3575 symbol we output the final definition. */
3576 if (h
== (struct aout_link_hash_entry
*) NULL
)
3578 else if (hresolve
->root
.type
== bfd_link_hash_defined
)
3580 asection
*input_section
;
3581 asection
*output_section
;
3583 /* This case means a common symbol which was turned
3584 into a defined symbol. */
3585 input_section
= hresolve
->root
.u
.def
.section
;
3586 output_section
= input_section
->output_section
;
3587 BFD_ASSERT (output_section
== &bfd_abs_section
3588 || output_section
->owner
== output_bfd
);
3589 val
= (hresolve
->root
.u
.def
.value
3590 + bfd_get_section_vma (output_bfd
, output_section
)
3591 + input_section
->output_offset
);
3593 /* Get the correct type based on the section. If
3594 this is a constructed set, force it to be
3595 globally visible. */
3604 if (output_section
== obj_textsec (output_bfd
))
3606 else if (output_section
== obj_datasec (output_bfd
))
3608 else if (output_section
== obj_bsssec (output_bfd
))
3613 else if (hresolve
->root
.type
== bfd_link_hash_common
)
3614 val
= hresolve
->root
.u
.c
.size
;
3620 if (symsec
!= (asection
*) NULL
)
3621 val
= (symsec
->output_section
->vma
3622 + symsec
->output_offset
3623 + (GET_WORD (input_bfd
, sym
->e_value
)
3626 /* If this is a global symbol set the written flag, and if
3627 it is a local symbol see if we should discard it. */
3628 if (h
!= (struct aout_link_hash_entry
*) NULL
)
3630 h
->root
.written
= true;
3631 h
->indx
= obj_aout_external_sym_count (output_bfd
);
3640 if (*name
== *finfo
->info
->lprefix
3641 && (finfo
->info
->lprefix_len
== 1
3642 || strncmp (name
, finfo
->info
->lprefix
,
3643 finfo
->info
->lprefix_len
) == 0))
3658 /* Copy this symbol into the list of symbols we are going to
3660 bfd_h_put_8 (output_bfd
, type
, outsym
->e_type
);
3661 bfd_h_put_8 (output_bfd
, bfd_h_get_8 (input_bfd
, sym
->e_other
),
3663 bfd_h_put_16 (output_bfd
, bfd_h_get_16 (input_bfd
, sym
->e_desc
),
3665 PUT_WORD (output_bfd
,
3666 add_to_stringtab (output_bfd
, name
, &finfo
->strtab
),
3668 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
3669 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
3670 ++obj_aout_external_sym_count (output_bfd
);
3674 /* Write out the output symbols we have just constructed. */
3675 if (outsym
> output_syms
)
3677 bfd_size_type outsym_count
;
3679 if (bfd_seek (output_bfd
, finfo
->symoff
, SEEK_SET
) != 0)
3681 outsym_count
= outsym
- output_syms
;
3682 if (bfd_write ((PTR
) output_syms
, (bfd_size_type
) EXTERNAL_NLIST_SIZE
,
3683 (bfd_size_type
) outsym_count
, output_bfd
)
3684 != outsym_count
* EXTERNAL_NLIST_SIZE
)
3686 finfo
->symoff
+= outsym_count
* EXTERNAL_NLIST_SIZE
;
3692 /* Write out a symbol that was not associated with an a.out input
3696 aout_link_write_other_symbol (h
, data
)
3697 struct aout_link_hash_entry
*h
;
3700 struct aout_final_link_info
*finfo
= (struct aout_final_link_info
*) data
;
3704 struct external_nlist outsym
;
3706 if (h
->root
.written
)
3709 output_bfd
= finfo
->output_bfd
;
3711 switch (h
->root
.type
)
3714 case bfd_link_hash_new
:
3716 /* Avoid variable not initialized warnings. */
3718 case bfd_link_hash_undefined
:
3719 type
= N_UNDF
| N_EXT
;
3722 case bfd_link_hash_defined
:
3726 sec
= h
->root
.u
.def
.section
;
3727 BFD_ASSERT (sec
== &bfd_abs_section
3728 || sec
->owner
== output_bfd
);
3729 if (sec
== obj_textsec (output_bfd
))
3730 type
= N_TEXT
| N_EXT
;
3731 else if (sec
== obj_datasec (output_bfd
))
3732 type
= N_DATA
| N_EXT
;
3733 else if (sec
== obj_bsssec (output_bfd
))
3734 type
= N_BSS
| N_EXT
;
3736 type
= N_ABS
| N_EXT
;
3737 val
= (h
->root
.u
.def
.value
3738 + sec
->output_section
->vma
3739 + sec
->output_offset
);
3742 case bfd_link_hash_common
:
3743 type
= N_UNDF
| N_EXT
;
3744 val
= h
->root
.u
.c
.size
;
3746 case bfd_link_hash_indirect
:
3747 case bfd_link_hash_warning
:
3748 /* FIXME: Ignore these for now. The circumstances under which
3749 they should be written out are not clear to me. */
3753 bfd_h_put_8 (output_bfd
, type
, outsym
.e_type
);
3754 bfd_h_put_8 (output_bfd
, 0, outsym
.e_other
);
3755 bfd_h_put_16 (output_bfd
, 0, outsym
.e_desc
);
3756 PUT_WORD (output_bfd
,
3757 add_to_stringtab (output_bfd
, h
->root
.root
.string
, &finfo
->strtab
),
3759 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
3761 if (bfd_seek (output_bfd
, finfo
->symoff
, SEEK_SET
) != 0
3762 || bfd_write ((PTR
) &outsym
, (bfd_size_type
) EXTERNAL_NLIST_SIZE
,
3763 (bfd_size_type
) 1, output_bfd
) != EXTERNAL_NLIST_SIZE
)
3765 /* FIXME: No way to handle errors. */
3769 finfo
->symoff
+= EXTERNAL_NLIST_SIZE
;
3770 h
->indx
= obj_aout_external_sym_count (output_bfd
);
3771 ++obj_aout_external_sym_count (output_bfd
);
3776 /* Link an a.out section into the output file. */
3779 aout_link_input_section (finfo
, input_bfd
, input_section
, reloff_ptr
,
3780 rel_size
, symbol_map
)
3781 struct aout_final_link_info
*finfo
;
3783 asection
*input_section
;
3784 file_ptr
*reloff_ptr
;
3785 bfd_size_type rel_size
;
3788 bfd_size_type input_size
;
3792 /* Get the section contents. */
3793 input_size
= bfd_section_size (input_bfd
, input_section
);
3794 contents
= (bfd_byte
*) alloca (input_size
);
3795 if (! bfd_get_section_contents (input_bfd
, input_section
, (PTR
) contents
,
3796 (file_ptr
) 0, input_size
))
3799 /* Read in the relocs. */
3800 relocs
= (PTR
) alloca (rel_size
);
3801 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3802 || bfd_read (relocs
, 1, rel_size
, input_bfd
) != rel_size
)
3805 /* Relocate the section contents. */
3806 if (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
)
3808 if (! aout_link_input_section_std (finfo
, input_bfd
, input_section
,
3809 (struct reloc_std_external
*) relocs
,
3810 rel_size
, contents
, symbol_map
))
3815 if (! aout_link_input_section_ext (finfo
, input_bfd
, input_section
,
3816 (struct reloc_ext_external
*) relocs
,
3817 rel_size
, contents
, symbol_map
))
3821 /* Write out the section contents. */
3822 if (! bfd_set_section_contents (finfo
->output_bfd
,
3823 input_section
->output_section
,
3825 input_section
->output_offset
,
3829 /* If we are producing relocateable output, the relocs were
3830 modified, and we now write them out. */
3831 if (finfo
->info
->relocateable
)
3833 if (bfd_seek (finfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
3835 if (bfd_write (relocs
, (bfd_size_type
) 1, rel_size
, finfo
->output_bfd
)
3838 *reloff_ptr
+= rel_size
;
3840 /* Assert that the relocs have not run into the symbols, and
3841 that if these are the text relocs they have not run into the
3843 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (finfo
->output_bfd
)
3844 && (reloff_ptr
!= &finfo
->treloff
3846 <= obj_datasec (finfo
->output_bfd
)->rel_filepos
)));
3852 /* Get the section corresponding to a reloc index. */
3854 static INLINE asection
*
3855 aout_reloc_index_to_section (abfd
, indx
)
3859 switch (indx
& N_TYPE
)
3862 return obj_textsec (abfd
);
3864 return obj_datasec (abfd
);
3866 return obj_bsssec (abfd
);
3868 return &bfd_abs_section
;
3874 /* Relocate an a.out section using standard a.out relocs. */
3877 aout_link_input_section_std (finfo
, input_bfd
, input_section
, relocs
,
3878 rel_size
, contents
, symbol_map
)
3879 struct aout_final_link_info
*finfo
;
3881 asection
*input_section
;
3882 struct reloc_std_external
*relocs
;
3883 bfd_size_type rel_size
;
3888 boolean relocateable
;
3889 struct external_nlist
*syms
;
3891 struct aout_link_hash_entry
**sym_hashes
;
3892 bfd_size_type reloc_count
;
3893 register struct reloc_std_external
*rel
;
3894 struct reloc_std_external
*rel_end
;
3896 output_bfd
= finfo
->output_bfd
;
3898 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
);
3899 BFD_ASSERT (input_bfd
->xvec
->header_byteorder_big_p
3900 == output_bfd
->xvec
->header_byteorder_big_p
);
3902 relocateable
= finfo
->info
->relocateable
;
3903 syms
= obj_aout_external_syms (input_bfd
);
3904 strings
= obj_aout_external_strings (input_bfd
);
3905 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
3907 reloc_count
= rel_size
/ RELOC_STD_SIZE
;
3909 rel_end
= rel
+ reloc_count
;
3910 for (; rel
< rel_end
; rel
++)
3922 bfd_reloc_status_type r
;
3924 r_addr
= GET_SWORD (input_bfd
, rel
->r_address
);
3926 if (input_bfd
->xvec
->header_byteorder_big_p
)
3928 r_index
= ((rel
->r_index
[0] << 16)
3929 | (rel
->r_index
[1] << 8)
3931 r_extern
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
));
3932 r_pcrel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_PCREL_BIG
));
3933 r_baserel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
3934 r_jmptable
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
3935 r_relative
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_RELATIVE_BIG
));
3936 r_length
= ((rel
->r_type
[0] & RELOC_STD_BITS_LENGTH_BIG
)
3937 >> RELOC_STD_BITS_LENGTH_SH_BIG
);
3941 r_index
= ((rel
->r_index
[2] << 16)
3942 | (rel
->r_index
[1] << 8)
3944 r_extern
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
));
3945 r_pcrel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_PCREL_LITTLE
));
3946 r_baserel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_BASEREL_LITTLE
));
3947 r_jmptable
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_LITTLE
));
3948 r_relative
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_RELATIVE_LITTLE
));
3949 r_length
= ((rel
->r_type
[0] & RELOC_STD_BITS_LENGTH_LITTLE
)
3950 >> RELOC_STD_BITS_LENGTH_SH_LITTLE
);
3953 howto_idx
= r_length
+ 4 * r_pcrel
+ 8 * r_baserel
;
3954 BFD_ASSERT (howto_idx
< TABLE_SIZE (howto_table_std
));
3955 BFD_ASSERT (r_jmptable
== 0);
3956 BFD_ASSERT (r_relative
== 0);
3960 /* We are generating a relocateable output file, and must
3961 modify the reloc accordingly. */
3964 struct aout_link_hash_entry
*h
;
3966 /* If we know the symbol this relocation is against,
3967 convert it into a relocation against a section. This
3968 is what the native linker does. */
3969 h
= sym_hashes
[r_index
];
3970 if (h
!= (struct aout_link_hash_entry
*) NULL
3971 && h
->root
.type
== bfd_link_hash_defined
)
3973 asection
*output_section
;
3975 /* Change the r_extern value. */
3976 if (output_bfd
->xvec
->header_byteorder_big_p
)
3977 rel
->r_type
[0] &=~ RELOC_STD_BITS_EXTERN_BIG
;
3979 rel
->r_type
[0] &=~ RELOC_STD_BITS_EXTERN_LITTLE
;
3981 /* Compute a new r_index. */
3982 output_section
= h
->root
.u
.def
.section
->output_section
;
3983 if (output_section
== obj_textsec (output_bfd
))
3985 else if (output_section
== obj_datasec (output_bfd
))
3987 else if (output_section
== obj_bsssec (output_bfd
))
3992 /* Add the symbol value and the section VMA to the
3993 addend stored in the contents. */
3994 relocation
= (h
->root
.u
.def
.value
3995 + output_section
->vma
3996 + h
->root
.u
.def
.section
->output_offset
);
4000 /* We must change r_index according to the symbol
4002 r_index
= symbol_map
[r_index
];
4008 name
= strings
+ GET_WORD (input_bfd
,
4009 syms
[r_index
].e_strx
);
4010 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
4011 (finfo
->info
, name
, input_bfd
, input_section
,
4020 /* Write out the new r_index value. */
4021 if (output_bfd
->xvec
->header_byteorder_big_p
)
4023 rel
->r_index
[0] = r_index
>> 16;
4024 rel
->r_index
[1] = r_index
>> 8;
4025 rel
->r_index
[2] = r_index
;
4029 rel
->r_index
[2] = r_index
>> 16;
4030 rel
->r_index
[1] = r_index
>> 8;
4031 rel
->r_index
[0] = r_index
;
4038 /* This is a relocation against a section. We must
4039 adjust by the amount that the section moved. */
4040 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4041 relocation
= (section
->output_section
->vma
4042 + section
->output_offset
4046 /* Change the address of the relocation. */
4047 PUT_WORD (output_bfd
,
4048 r_addr
+ input_section
->output_offset
,
4051 /* Adjust a PC relative relocation by removing the reference
4052 to the original address in the section and including the
4053 reference to the new address. */
4055 relocation
-= (input_section
->output_section
->vma
4056 + input_section
->output_offset
4057 - input_section
->vma
);
4059 if (relocation
== 0)
4062 r
= _bfd_relocate_contents (howto_table_std
+ howto_idx
,
4063 input_bfd
, relocation
,
4068 /* We are generating an executable, and must do a full
4072 struct aout_link_hash_entry
*h
;
4074 h
= sym_hashes
[r_index
];
4075 if (h
!= (struct aout_link_hash_entry
*) NULL
4076 && h
->root
.type
== bfd_link_hash_defined
)
4078 relocation
= (h
->root
.u
.def
.value
4079 + h
->root
.u
.def
.section
->output_section
->vma
4080 + h
->root
.u
.def
.section
->output_offset
);
4086 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
4087 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
4088 (finfo
->info
, name
, input_bfd
, input_section
,
4098 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4099 relocation
= (section
->output_section
->vma
4100 + section
->output_offset
4103 relocation
+= input_section
->vma
;
4106 r
= _bfd_final_link_relocate (howto_table_std
+ howto_idx
,
4107 input_bfd
, input_section
,
4108 contents
, r_addr
, relocation
,
4112 if (r
!= bfd_reloc_ok
)
4117 case bfd_reloc_outofrange
:
4119 case bfd_reloc_overflow
:
4120 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
4121 (finfo
->info
, input_bfd
, input_section
, r_addr
)))
4131 /* Relocate an a.out section using extended a.out relocs. */
4134 aout_link_input_section_ext (finfo
, input_bfd
, input_section
, relocs
,
4135 rel_size
, contents
, symbol_map
)
4136 struct aout_final_link_info
*finfo
;
4138 asection
*input_section
;
4139 struct reloc_ext_external
*relocs
;
4140 bfd_size_type rel_size
;
4145 boolean relocateable
;
4146 struct external_nlist
*syms
;
4148 struct aout_link_hash_entry
**sym_hashes
;
4149 bfd_size_type reloc_count
;
4150 register struct reloc_ext_external
*rel
;
4151 struct reloc_ext_external
*rel_end
;
4153 output_bfd
= finfo
->output_bfd
;
4155 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_EXT_SIZE
);
4156 BFD_ASSERT (input_bfd
->xvec
->header_byteorder_big_p
4157 == output_bfd
->xvec
->header_byteorder_big_p
);
4159 relocateable
= finfo
->info
->relocateable
;
4160 syms
= obj_aout_external_syms (input_bfd
);
4161 strings
= obj_aout_external_strings (input_bfd
);
4162 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
4164 reloc_count
= rel_size
/ RELOC_EXT_SIZE
;
4166 rel_end
= rel
+ reloc_count
;
4167 for (; rel
< rel_end
; rel
++)
4176 r_addr
= GET_SWORD (input_bfd
, rel
->r_address
);
4178 if (input_bfd
->xvec
->header_byteorder_big_p
)
4180 r_index
= ((rel
->r_index
[0] << 16)
4181 | (rel
->r_index
[1] << 8)
4183 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
4184 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
4185 >> RELOC_EXT_BITS_TYPE_SH_BIG
);
4189 r_index
= ((rel
->r_index
[2] << 16)
4190 | (rel
->r_index
[1] << 8)
4192 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
4193 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
4194 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
);
4197 r_addend
= GET_SWORD (input_bfd
, rel
->r_addend
);
4199 BFD_ASSERT (r_type
>= 0
4200 && r_type
< TABLE_SIZE (howto_table_ext
));
4204 /* We are generating a relocateable output file, and must
4205 modify the reloc accordingly. */
4208 struct aout_link_hash_entry
*h
;
4210 /* If we know the symbol this relocation is against,
4211 convert it into a relocation against a section. This
4212 is what the native linker does. */
4213 h
= sym_hashes
[r_index
];
4214 if (h
!= (struct aout_link_hash_entry
*) NULL
4215 && h
->root
.type
== bfd_link_hash_defined
)
4217 asection
*output_section
;
4219 /* Change the r_extern value. */
4220 if (output_bfd
->xvec
->header_byteorder_big_p
)
4221 rel
->r_type
[0] &=~ RELOC_EXT_BITS_EXTERN_BIG
;
4223 rel
->r_type
[0] &=~ RELOC_EXT_BITS_EXTERN_LITTLE
;
4225 /* Compute a new r_index. */
4226 output_section
= h
->root
.u
.def
.section
->output_section
;
4227 if (output_section
== obj_textsec (output_bfd
))
4229 else if (output_section
== obj_datasec (output_bfd
))
4231 else if (output_section
== obj_bsssec (output_bfd
))
4236 /* Add the symbol value and the section VMA to the
4238 relocation
= (h
->root
.u
.def
.value
4239 + output_section
->vma
4240 + h
->root
.u
.def
.section
->output_offset
);
4242 /* Now RELOCATION is the VMA of the final
4243 destination. If this is a PC relative reloc,
4244 then ADDEND is the negative of the source VMA.
4245 We want to set ADDEND to the difference between
4246 the destination VMA and the source VMA, which
4247 means we must adjust RELOCATION by the change in
4248 the source VMA. This is done below. */
4252 /* We must change r_index according to the symbol
4254 r_index
= symbol_map
[r_index
];
4261 + GET_WORD (input_bfd
, syms
[r_index
].e_strx
));
4262 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
4263 (finfo
->info
, name
, input_bfd
, input_section
,
4271 /* If this is a PC relative reloc, then the addend
4272 is the negative of the source VMA. We must
4273 adjust it by the change in the source VMA. This
4277 /* Write out the new r_index value. */
4278 if (output_bfd
->xvec
->header_byteorder_big_p
)
4280 rel
->r_index
[0] = r_index
>> 16;
4281 rel
->r_index
[1] = r_index
>> 8;
4282 rel
->r_index
[2] = r_index
;
4286 rel
->r_index
[2] = r_index
>> 16;
4287 rel
->r_index
[1] = r_index
>> 8;
4288 rel
->r_index
[0] = r_index
;
4295 /* This is a relocation against a section. We must
4296 adjust by the amount that the section moved. */
4297 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4298 relocation
= (section
->output_section
->vma
4299 + section
->output_offset
4302 /* If this is a PC relative reloc, then the addend is
4303 the difference in VMA between the destination and the
4304 source. We have just adjusted for the change in VMA
4305 of the destination, so we must also adjust by the
4306 change in VMA of the source. This is done below. */
4309 /* As described above, we must always adjust a PC relative
4310 reloc by the change in VMA of the source. */
4311 if (howto_table_ext
[r_type
].pc_relative
)
4312 relocation
-= (input_section
->output_section
->vma
4313 + input_section
->output_offset
4314 - input_section
->vma
);
4316 /* Change the addend if necessary. */
4317 if (relocation
!= 0)
4318 PUT_WORD (output_bfd
, r_addend
+ relocation
, rel
->r_addend
);
4320 /* Change the address of the relocation. */
4321 PUT_WORD (output_bfd
,
4322 r_addr
+ input_section
->output_offset
,
4327 bfd_reloc_status_type r
;
4329 /* We are generating an executable, and must do a full
4333 struct aout_link_hash_entry
*h
;
4335 h
= sym_hashes
[r_index
];
4336 if (h
!= (struct aout_link_hash_entry
*) NULL
4337 && h
->root
.type
== bfd_link_hash_defined
)
4339 relocation
= (h
->root
.u
.def
.value
4340 + h
->root
.u
.def
.section
->output_section
->vma
4341 + h
->root
.u
.def
.section
->output_offset
);
4347 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
4348 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
4349 (finfo
->info
, name
, input_bfd
, input_section
,
4359 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4361 /* If this is a PC relative reloc, then R_ADDEND is the
4362 difference between the two vmas, or
4363 old_dest_sec + old_dest_off - (old_src_sec + old_src_off)
4365 old_dest_sec == section->vma
4367 old_src_sec == input_section->vma
4369 old_src_off == r_addr
4371 _bfd_final_link_relocate expects RELOCATION +
4372 R_ADDEND to be the VMA of the destination minus
4373 r_addr (the minus r_addr is because this relocation
4374 is not pcrel_offset, which is a bit confusing and
4375 should, perhaps, be changed), or
4378 new_dest_sec == output_section->vma + output_offset
4379 We arrange for this to happen by setting RELOCATION to
4380 new_dest_sec + old_src_sec - old_dest_sec
4382 If this is not a PC relative reloc, then R_ADDEND is
4383 simply the VMA of the destination, so we set
4384 RELOCATION to the change in the destination VMA, or
4385 new_dest_sec - old_dest_sec
4387 relocation
= (section
->output_section
->vma
4388 + section
->output_offset
4390 if (howto_table_ext
[r_type
].pc_relative
)
4391 relocation
+= input_section
->vma
;
4394 r
= _bfd_final_link_relocate (howto_table_ext
+ r_type
,
4395 input_bfd
, input_section
,
4396 contents
, r_addr
, relocation
,
4398 if (r
!= bfd_reloc_ok
)
4403 case bfd_reloc_outofrange
:
4405 case bfd_reloc_overflow
:
4406 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
4407 (finfo
->info
, input_bfd
, input_section
, r_addr
)))