1 /* BFD semi-generic back-end for a.out binaries.
2 Copyright (C) 1990-2020 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 BFD supports a number of different flavours of a.out format,
29 though the major differences are only the sizes of the
30 structures on disk, and the shape of the relocation
33 The support is split into a basic support file @file{aoutx.h}
34 and other files which derive functions from the base. One
35 derivation file is @file{aoutf1.h} (for a.out flavour 1), and
36 adds to the basic a.out functions support for sun3, sun4, and
37 386 a.out files, to create a target jump vector for a specific
40 This information is further split out into more specific files
41 for each machine, including @file{sunos.c} for sun3 and sun4,
42 and @file{demo64.c} for a demonstration of a 64 bit a.out format.
44 The base file @file{aoutx.h} defines general mechanisms for
45 reading and writing records to and from disk and various
46 other methods which BFD requires. It is included by
47 @file{aout32.c} and @file{aout64.c} to form the names
48 <<aout_32_swap_exec_header_in>>, <<aout_64_swap_exec_header_in>>, etc.
50 As an example, this is what goes on to make the back end for a
51 sun4, from @file{aout32.c}:
53 | #define ARCH_SIZE 32
59 | aout_32_canonicalize_reloc
60 | aout_32_find_nearest_line
62 | aout_32_get_reloc_upper_bound
67 | #define TARGET_NAME "a.out-sunos-big"
68 | #define VECNAME sparc_aout_sunos_be_vec
71 requires all the names from @file{aout32.c}, and produces the jump vector
73 | sparc_aout_sunos_be_vec
75 The file @file{host-aout.c} is a special case. It is for a large set
76 of hosts that use ``more or less standard'' a.out files, and
77 for which cross-debugging is not interesting. It uses the
78 standard 32-bit a.out support routines, but determines the
79 file offsets and addresses of the text, data, and BSS
80 sections, the machine architecture and machine type, and the
81 entry point address, in a host-dependent manner. Once these
82 values have been determined, generic code is used to handle
85 When porting it to run on a new system, you must supply:
89 | HOST_MACHINE_ARCH (optional)
90 | HOST_MACHINE_MACHINE (optional)
91 | HOST_TEXT_START_ADDR
94 in the file @file{../include/sys/h-@var{XXX}.h} (for your host). These
95 values, plus the structures and macros defined in @file{a.out.h} on
96 your host system, will produce a BFD target that will access
97 ordinary a.out files on your host. To configure a new machine
98 to use @file{host-aout.c}, specify:
100 | TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec
101 | TDEPFILES= host-aout.o trad-core.o
103 in the @file{config/@var{XXX}.mt} file, and modify @file{configure.ac}
105 @file{@var{XXX}.mt} file (by setting "<<bfd_target=XXX>>") when your
106 configuration is selected. */
109 * Any BFD with D_PAGED set is ZMAGIC, and vice versa.
110 Doesn't matter what the setting of WP_TEXT is on output, but it'll
112 * Any BFD with D_PAGED clear and WP_TEXT set is NMAGIC.
113 * Any BFD with both flags clear is OMAGIC.
114 (Just want to make these explicit, so the conditions tested in this
115 file make sense if you're more familiar with a.out than with BFD.) */
117 #define KEEPIT udata.i
122 #include "safe-ctype.h"
127 #include "aout/aout64.h"
128 #include "aout/stab_gnu.h"
136 The file @file{aoutx.h} provides for both the @emph{standard}
137 and @emph{extended} forms of a.out relocation records.
139 The standard records contain only an address, a symbol index,
140 and a type field. The extended records also have a full
141 integer for an addend. */
143 #ifndef CTOR_TABLE_RELOC_HOWTO
144 #define CTOR_TABLE_RELOC_IDX 2
145 #define CTOR_TABLE_RELOC_HOWTO(BFD) \
146 ((obj_reloc_entry_size (BFD) == RELOC_EXT_SIZE \
147 ? howto_table_ext : howto_table_std) \
148 + CTOR_TABLE_RELOC_IDX)
151 #ifndef MY_swap_std_reloc_in
152 #define MY_swap_std_reloc_in NAME (aout, swap_std_reloc_in)
155 #ifndef MY_swap_ext_reloc_in
156 #define MY_swap_ext_reloc_in NAME (aout, swap_ext_reloc_in)
159 #ifndef MY_swap_std_reloc_out
160 #define MY_swap_std_reloc_out NAME (aout, swap_std_reloc_out)
163 #ifndef MY_swap_ext_reloc_out
164 #define MY_swap_ext_reloc_out NAME (aout, swap_ext_reloc_out)
167 #ifndef MY_final_link_relocate
168 #define MY_final_link_relocate _bfd_final_link_relocate
171 #ifndef MY_relocate_contents
172 #define MY_relocate_contents _bfd_relocate_contents
175 #define howto_table_ext NAME (aout, ext_howto_table)
176 #define howto_table_std NAME (aout, std_howto_table)
178 reloc_howto_type howto_table_ext
[] =
180 /* Type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone. */
181 HOWTO (RELOC_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
, 0, "8", FALSE
, 0, 0x000000ff, FALSE
),
182 HOWTO (RELOC_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
, 0, "16", FALSE
, 0, 0x0000ffff, FALSE
),
183 HOWTO (RELOC_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
, 0, "32", FALSE
, 0, 0xffffffff, FALSE
),
184 HOWTO (RELOC_DISP8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
, 0, "DISP8", FALSE
, 0, 0x000000ff, FALSE
),
185 HOWTO (RELOC_DISP16
, 0, 1, 16, TRUE
, 0, complain_overflow_signed
, 0, "DISP16", FALSE
, 0, 0x0000ffff, FALSE
),
186 HOWTO (RELOC_DISP32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
, 0, "DISP32", FALSE
, 0, 0xffffffff, FALSE
),
187 HOWTO (RELOC_WDISP30
, 2, 2, 30, TRUE
, 0, complain_overflow_signed
, 0, "WDISP30", FALSE
, 0, 0x3fffffff, FALSE
),
188 HOWTO (RELOC_WDISP22
, 2, 2, 22, TRUE
, 0, complain_overflow_signed
, 0, "WDISP22", FALSE
, 0, 0x003fffff, FALSE
),
189 HOWTO (RELOC_HI22
, 10, 2, 22, FALSE
, 0, complain_overflow_bitfield
, 0, "HI22", FALSE
, 0, 0x003fffff, FALSE
),
190 HOWTO (RELOC_22
, 0, 2, 22, FALSE
, 0, complain_overflow_bitfield
, 0, "22", FALSE
, 0, 0x003fffff, FALSE
),
191 HOWTO (RELOC_13
, 0, 2, 13, FALSE
, 0, complain_overflow_bitfield
, 0, "13", FALSE
, 0, 0x00001fff, FALSE
),
192 HOWTO (RELOC_LO10
, 0, 2, 10, FALSE
, 0, complain_overflow_dont
, 0, "LO10", FALSE
, 0, 0x000003ff, FALSE
),
193 HOWTO (RELOC_SFA_BASE
,0, 2, 32, FALSE
, 0, complain_overflow_bitfield
, 0, "SFA_BASE", FALSE
, 0, 0xffffffff, FALSE
),
194 HOWTO (RELOC_SFA_OFF13
,0, 2, 32, FALSE
, 0, complain_overflow_bitfield
, 0, "SFA_OFF13", FALSE
, 0, 0xffffffff, FALSE
),
195 HOWTO (RELOC_BASE10
, 0, 2, 10, FALSE
, 0, complain_overflow_dont
, 0, "BASE10", FALSE
, 0, 0x000003ff, FALSE
),
196 HOWTO (RELOC_BASE13
, 0, 2, 13, FALSE
, 0, complain_overflow_signed
, 0, "BASE13", FALSE
, 0, 0x00001fff, FALSE
),
197 HOWTO (RELOC_BASE22
, 10, 2, 22, FALSE
, 0, complain_overflow_bitfield
, 0, "BASE22", FALSE
, 0, 0x003fffff, FALSE
),
198 HOWTO (RELOC_PC10
, 0, 2, 10, TRUE
, 0, complain_overflow_dont
, 0, "PC10", FALSE
, 0, 0x000003ff, TRUE
),
199 HOWTO (RELOC_PC22
, 10, 2, 22, TRUE
, 0, complain_overflow_signed
, 0, "PC22", FALSE
, 0, 0x003fffff, TRUE
),
200 HOWTO (RELOC_JMP_TBL
, 2, 2, 30, TRUE
, 0, complain_overflow_signed
, 0, "JMP_TBL", FALSE
, 0, 0x3fffffff, FALSE
),
201 HOWTO (RELOC_SEGOFF16
,0, 2, 0, FALSE
, 0, complain_overflow_bitfield
, 0, "SEGOFF16", FALSE
, 0, 0x00000000, FALSE
),
202 HOWTO (RELOC_GLOB_DAT
,0, 2, 0, FALSE
, 0, complain_overflow_bitfield
, 0, "GLOB_DAT", FALSE
, 0, 0x00000000, FALSE
),
203 HOWTO (RELOC_JMP_SLOT
,0, 2, 0, FALSE
, 0, complain_overflow_bitfield
, 0, "JMP_SLOT", FALSE
, 0, 0x00000000, FALSE
),
204 HOWTO (RELOC_RELATIVE
,0, 2, 0, FALSE
, 0, complain_overflow_bitfield
, 0, "RELATIVE", FALSE
, 0, 0x00000000, FALSE
),
205 HOWTO (0, 0, 3, 0, FALSE
, 0, complain_overflow_dont
, 0, "R_SPARC_NONE",FALSE
, 0, 0x00000000, TRUE
),
206 HOWTO (0, 0, 3, 0, FALSE
, 0, complain_overflow_dont
, 0, "R_SPARC_NONE",FALSE
, 0, 0x00000000, TRUE
),
207 #define RELOC_SPARC_REV32 RELOC_WDISP19
208 HOWTO (RELOC_SPARC_REV32
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
, 0,"R_SPARC_REV32",FALSE
, 0, 0xffffffff, FALSE
),
211 /* Convert standard reloc records to "arelent" format (incl byte swap). */
213 reloc_howto_type howto_table_std
[] =
215 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone. */
216 HOWTO ( 0, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,0,"8", TRUE
, 0x000000ff,0x000000ff, FALSE
),
217 HOWTO ( 1, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,0,"16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
218 HOWTO ( 2, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,0,"32", TRUE
, 0xffffffff,0xffffffff, FALSE
),
219 HOWTO ( 3, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,0,"64", TRUE
, 0xdeaddead,0xdeaddead, FALSE
),
220 HOWTO ( 4, 0, 0, 8, TRUE
, 0, complain_overflow_signed
, 0,"DISP8", TRUE
, 0x000000ff,0x000000ff, FALSE
),
221 HOWTO ( 5, 0, 1, 16, TRUE
, 0, complain_overflow_signed
, 0,"DISP16", TRUE
, 0x0000ffff,0x0000ffff, FALSE
),
222 HOWTO ( 6, 0, 2, 32, TRUE
, 0, complain_overflow_signed
, 0,"DISP32", TRUE
, 0xffffffff,0xffffffff, FALSE
),
223 HOWTO ( 7, 0, 4, 64, TRUE
, 0, complain_overflow_signed
, 0,"DISP64", TRUE
, 0xfeedface,0xfeedface, FALSE
),
224 HOWTO ( 8, 0, 2, 0, FALSE
, 0, complain_overflow_bitfield
,0,"GOT_REL", FALSE
, 0,0x00000000, FALSE
),
225 HOWTO ( 9, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,0,"BASE16", FALSE
,0xffffffff,0xffffffff, FALSE
),
226 HOWTO (10, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,0,"BASE32", FALSE
,0xffffffff,0xffffffff, FALSE
),
232 HOWTO (16, 0, 2, 0, FALSE
, 0, complain_overflow_bitfield
,0,"JMP_TABLE", FALSE
, 0,0x00000000, FALSE
),
248 HOWTO (32, 0, 2, 0, FALSE
, 0, complain_overflow_bitfield
,0,"RELATIVE", FALSE
, 0,0x00000000, FALSE
),
256 HOWTO (40, 0, 2, 0, FALSE
, 0, complain_overflow_bitfield
,0,"BASEREL", FALSE
, 0,0x00000000, FALSE
),
259 #define TABLE_SIZE(TABLE) (sizeof (TABLE) / sizeof (TABLE[0]))
262 NAME (aout
, reloc_type_lookup
) (bfd
*abfd
, bfd_reloc_code_real_type code
)
264 #define EXT(i, j) case i: return & howto_table_ext [j]
265 #define STD(i, j) case i: return & howto_table_std [j]
266 int ext
= obj_reloc_entry_size (abfd
) == RELOC_EXT_SIZE
;
268 if (code
== BFD_RELOC_CTOR
)
269 switch (bfd_arch_bits_per_address (abfd
))
282 EXT (BFD_RELOC_8
, 0);
283 EXT (BFD_RELOC_16
, 1);
284 EXT (BFD_RELOC_32
, 2);
285 EXT (BFD_RELOC_HI22
, 8);
286 EXT (BFD_RELOC_LO10
, 11);
287 EXT (BFD_RELOC_32_PCREL_S2
, 6);
288 EXT (BFD_RELOC_SPARC_WDISP22
, 7);
289 EXT (BFD_RELOC_SPARC13
, 10);
290 EXT (BFD_RELOC_SPARC_GOT10
, 14);
291 EXT (BFD_RELOC_SPARC_BASE13
, 15);
292 EXT (BFD_RELOC_SPARC_GOT13
, 15);
293 EXT (BFD_RELOC_SPARC_GOT22
, 16);
294 EXT (BFD_RELOC_SPARC_PC10
, 17);
295 EXT (BFD_RELOC_SPARC_PC22
, 18);
296 EXT (BFD_RELOC_SPARC_WPLT30
, 19);
297 EXT (BFD_RELOC_SPARC_REV32
, 26);
305 STD (BFD_RELOC_8
, 0);
306 STD (BFD_RELOC_16
, 1);
307 STD (BFD_RELOC_32
, 2);
308 STD (BFD_RELOC_8_PCREL
, 4);
309 STD (BFD_RELOC_16_PCREL
, 5);
310 STD (BFD_RELOC_32_PCREL
, 6);
311 STD (BFD_RELOC_16_BASEREL
, 9);
312 STD (BFD_RELOC_32_BASEREL
, 10);
319 NAME (aout
, reloc_name_lookup
) (bfd
*abfd
, const char *r_name
)
321 unsigned int i
, size
;
322 reloc_howto_type
*howto_table
;
324 if (obj_reloc_entry_size (abfd
) == RELOC_EXT_SIZE
)
326 howto_table
= howto_table_ext
;
327 size
= sizeof (howto_table_ext
) / sizeof (howto_table_ext
[0]);
331 howto_table
= howto_table_std
;
332 size
= sizeof (howto_table_std
) / sizeof (howto_table_std
[0]);
335 for (i
= 0; i
< size
; i
++)
336 if (howto_table
[i
].name
!= NULL
337 && strcasecmp (howto_table
[i
].name
, r_name
) == 0)
338 return &howto_table
[i
];
345 Internal entry points
348 @file{aoutx.h} exports several routines for accessing the
349 contents of an a.out file, which are gathered and exported in
350 turn by various format specific files (eg sunos.c).
355 aout_@var{size}_swap_exec_header_in
358 void aout_@var{size}_swap_exec_header_in,
360 struct external_exec *bytes,
361 struct internal_exec *execp);
364 Swap the information in an executable header @var{raw_bytes} taken
365 from a raw byte stream memory image into the internal exec header
366 structure @var{execp}.
369 #ifndef NAME_swap_exec_header_in
371 NAME (aout
, swap_exec_header_in
) (bfd
*abfd
,
372 struct external_exec
*bytes
,
373 struct internal_exec
*execp
)
375 /* The internal_exec structure has some fields that are unused in this
376 configuration (IE for i960), so ensure that all such uninitialized
377 fields are zero'd out. There are places where two of these structs
378 are memcmp'd, and thus the contents do matter. */
379 memset ((void *) execp
, 0, sizeof (struct internal_exec
));
380 /* Now fill in fields in the execp, from the bytes in the raw data. */
381 execp
->a_info
= H_GET_32 (abfd
, bytes
->e_info
);
382 execp
->a_text
= GET_WORD (abfd
, bytes
->e_text
);
383 execp
->a_data
= GET_WORD (abfd
, bytes
->e_data
);
384 execp
->a_bss
= GET_WORD (abfd
, bytes
->e_bss
);
385 execp
->a_syms
= GET_WORD (abfd
, bytes
->e_syms
);
386 execp
->a_entry
= GET_WORD (abfd
, bytes
->e_entry
);
387 execp
->a_trsize
= GET_WORD (abfd
, bytes
->e_trsize
);
388 execp
->a_drsize
= GET_WORD (abfd
, bytes
->e_drsize
);
390 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
395 aout_@var{size}_swap_exec_header_out
398 void aout_@var{size}_swap_exec_header_out
400 struct internal_exec *execp,
401 struct external_exec *raw_bytes);
404 Swap the information in an internal exec header structure
405 @var{execp} into the buffer @var{raw_bytes} ready for writing to disk.
408 NAME (aout
, swap_exec_header_out
) (bfd
*abfd
,
409 struct internal_exec
*execp
,
410 struct external_exec
*bytes
)
412 /* Now fill in fields in the raw data, from the fields in the exec struct. */
413 H_PUT_32 (abfd
, execp
->a_info
, bytes
->e_info
);
414 PUT_WORD (abfd
, execp
->a_text
, bytes
->e_text
);
415 PUT_WORD (abfd
, execp
->a_data
, bytes
->e_data
);
416 PUT_WORD (abfd
, execp
->a_bss
, bytes
->e_bss
);
417 PUT_WORD (abfd
, execp
->a_syms
, bytes
->e_syms
);
418 PUT_WORD (abfd
, execp
->a_entry
, bytes
->e_entry
);
419 PUT_WORD (abfd
, execp
->a_trsize
, bytes
->e_trsize
);
420 PUT_WORD (abfd
, execp
->a_drsize
, bytes
->e_drsize
);
423 /* Make all the section for an a.out file. */
426 NAME (aout
, make_sections
) (bfd
*abfd
)
428 if (obj_textsec (abfd
) == NULL
&& bfd_make_section (abfd
, ".text") == NULL
)
430 if (obj_datasec (abfd
) == NULL
&& bfd_make_section (abfd
, ".data") == NULL
)
432 if (obj_bsssec (abfd
) == NULL
&& bfd_make_section (abfd
, ".bss") == NULL
)
439 aout_@var{size}_some_aout_object_p
442 const bfd_target *aout_@var{size}_some_aout_object_p
444 struct internal_exec *execp,
445 const bfd_target *(*callback_to_real_object_p) (bfd *));
448 Some a.out variant thinks that the file open in @var{abfd}
449 checking is an a.out file. Do some more checking, and set up
450 for access if it really is. Call back to the calling
451 environment's "finish up" function just before returning, to
452 handle any last-minute setup.
456 NAME (aout
, some_aout_object_p
) (bfd
*abfd
,
457 struct internal_exec
*execp
,
458 const bfd_target
*(*callback_to_real_object_p
) (bfd
*))
460 struct aout_data_struct
*rawptr
, *oldrawptr
;
461 const bfd_target
*result
;
462 size_t amt
= sizeof (* rawptr
);
464 rawptr
= (struct aout_data_struct
*) bfd_zalloc (abfd
, amt
);
468 oldrawptr
= abfd
->tdata
.aout_data
;
469 abfd
->tdata
.aout_data
= rawptr
;
471 /* Copy the contents of the old tdata struct. */
472 if (oldrawptr
!= NULL
)
473 *abfd
->tdata
.aout_data
= *oldrawptr
;
475 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
476 /* Copy in the internal_exec struct. */
477 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
;
478 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
480 /* Set the file flags. */
481 abfd
->flags
= BFD_NO_FLAGS
;
482 if (execp
->a_drsize
|| execp
->a_trsize
)
483 abfd
->flags
|= HAS_RELOC
;
484 /* Setting of EXEC_P has been deferred to the bottom of this function. */
486 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
487 if (N_DYNAMIC (execp
))
488 abfd
->flags
|= DYNAMIC
;
490 if (N_MAGIC (execp
) == ZMAGIC
)
492 abfd
->flags
|= D_PAGED
| WP_TEXT
;
493 adata (abfd
).magic
= z_magic
;
495 else if (N_MAGIC (execp
) == QMAGIC
)
497 abfd
->flags
|= D_PAGED
| WP_TEXT
;
498 adata (abfd
).magic
= z_magic
;
499 adata (abfd
).subformat
= q_magic_format
;
501 else if (N_MAGIC (execp
) == NMAGIC
)
503 abfd
->flags
|= WP_TEXT
;
504 adata (abfd
).magic
= n_magic
;
506 else if (N_MAGIC (execp
) == OMAGIC
507 || N_MAGIC (execp
) == BMAGIC
)
508 adata (abfd
).magic
= o_magic
;
510 /* Should have been checked with N_BADMAG before this routine
514 abfd
->start_address
= execp
->a_entry
;
516 obj_aout_symbols (abfd
) = NULL
;
517 abfd
->symcount
= execp
->a_syms
/ sizeof (struct external_nlist
);
519 /* The default relocation entry size is that of traditional V7 Unix. */
520 obj_reloc_entry_size (abfd
) = RELOC_STD_SIZE
;
522 /* The default symbol entry size is that of traditional Unix. */
523 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
526 bfd_init_window (&obj_aout_sym_window (abfd
));
527 bfd_init_window (&obj_aout_string_window (abfd
));
529 obj_aout_external_syms (abfd
) = NULL
;
530 obj_aout_external_strings (abfd
) = NULL
;
531 obj_aout_sym_hashes (abfd
) = NULL
;
533 if (! NAME (aout
, make_sections
) (abfd
))
536 obj_datasec (abfd
)->size
= execp
->a_data
;
537 obj_bsssec (abfd
)->size
= execp
->a_bss
;
539 obj_textsec (abfd
)->flags
=
540 (execp
->a_trsize
!= 0
541 ? (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_RELOC
)
542 : (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
));
543 obj_datasec (abfd
)->flags
=
544 (execp
->a_drsize
!= 0
545 ? (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_RELOC
)
546 : (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
));
547 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
549 #ifdef THIS_IS_ONLY_DOCUMENTATION
550 /* The common code can't fill in these things because they depend
551 on either the start address of the text segment, the rounding
552 up of virtual addresses between segments, or the starting file
553 position of the text segment -- all of which varies among different
554 versions of a.out. */
556 /* Call back to the format-dependent code to fill in the rest of the
557 fields and do any further cleanup. Things that should be filled
558 in by the callback: */
560 struct exec
*execp
= exec_hdr (abfd
);
562 obj_textsec (abfd
)->size
= N_TXTSIZE (execp
);
563 /* Data and bss are already filled in since they're so standard. */
565 /* The virtual memory addresses of the sections. */
566 obj_textsec (abfd
)->vma
= N_TXTADDR (execp
);
567 obj_datasec (abfd
)->vma
= N_DATADDR (execp
);
568 obj_bsssec (abfd
)->vma
= N_BSSADDR (execp
);
570 /* The file offsets of the sections. */
571 obj_textsec (abfd
)->filepos
= N_TXTOFF (execp
);
572 obj_datasec (abfd
)->filepos
= N_DATOFF (execp
);
574 /* The file offsets of the relocation info. */
575 obj_textsec (abfd
)->rel_filepos
= N_TRELOFF (execp
);
576 obj_datasec (abfd
)->rel_filepos
= N_DRELOFF (execp
);
578 /* The file offsets of the string table and symbol table. */
579 obj_str_filepos (abfd
) = N_STROFF (execp
);
580 obj_sym_filepos (abfd
) = N_SYMOFF (execp
);
582 /* Determine the architecture and machine type of the object file. */
583 switch (N_MACHTYPE (exec_hdr (abfd
)))
586 abfd
->obj_arch
= bfd_arch_obscure
;
590 adata (abfd
)->page_size
= TARGET_PAGE_SIZE
;
591 adata (abfd
)->segment_size
= SEGMENT_SIZE
;
592 adata (abfd
)->exec_bytes_size
= EXEC_BYTES_SIZE
;
596 /* The architecture is encoded in various ways in various a.out variants,
597 or is not encoded at all in some of them. The relocation size depends
598 on the architecture and the a.out variant. Finally, the return value
599 is the bfd_target vector in use. If an error occurs, return zero and
600 set bfd_error to the appropriate error code.
602 Formats such as b.out, which have additional fields in the a.out
603 header, should cope with them in this callback as well. */
604 #endif /* DOCUMENTATION */
606 result
= (*callback_to_real_object_p
) (abfd
);
608 /* Now that the segment addresses have been worked out, take a better
609 guess at whether the file is executable. If the entry point
610 is within the text segment, assume it is. (This makes files
611 executable even if their entry point address is 0, as long as
612 their text starts at zero.).
614 This test had to be changed to deal with systems where the text segment
615 runs at a different location than the default. The problem is that the
616 entry address can appear to be outside the text segment, thus causing an
617 erroneous conclusion that the file isn't executable.
619 To fix this, we now accept any non-zero entry point as an indication of
620 executability. This will work most of the time, since only the linker
621 sets the entry point, and that is likely to be non-zero for most systems. */
623 if (execp
->a_entry
!= 0
624 || (execp
->a_entry
>= obj_textsec (abfd
)->vma
625 && execp
->a_entry
< (obj_textsec (abfd
)->vma
626 + obj_textsec (abfd
)->size
)
627 && execp
->a_trsize
== 0
628 && execp
->a_drsize
== 0))
629 abfd
->flags
|= EXEC_P
;
633 struct stat stat_buf
;
635 /* The original heuristic doesn't work in some important cases.
636 The a.out file has no information about the text start
637 address. For files (like kernels) linked to non-standard
638 addresses (ld -Ttext nnn) the entry point may not be between
639 the default text start (obj_textsec(abfd)->vma) and
640 (obj_textsec(abfd)->vma) + text size. This is not just a mach
641 issue. Many kernels are loaded at non standard addresses. */
642 if (abfd
->iostream
!= NULL
643 && (abfd
->flags
& BFD_IN_MEMORY
) == 0
644 && (fstat (fileno ((FILE *) (abfd
->iostream
)), &stat_buf
) == 0)
645 && ((stat_buf
.st_mode
& 0111) != 0))
646 abfd
->flags
|= EXEC_P
;
648 #endif /* STAT_FOR_EXEC */
654 bfd_release (abfd
, rawptr
);
655 abfd
->tdata
.aout_data
= oldrawptr
;
661 aout_@var{size}_mkobject
664 bfd_boolean aout_@var{size}_mkobject, (bfd *abfd);
667 Initialize BFD @var{abfd} for use with a.out files.
671 NAME (aout
, mkobject
) (bfd
*abfd
)
673 struct aout_data_struct
*rawptr
;
674 size_t amt
= sizeof (* rawptr
);
676 bfd_set_error (bfd_error_system_call
);
678 rawptr
= (struct aout_data_struct
*) bfd_zalloc (abfd
, amt
);
682 abfd
->tdata
.aout_data
= rawptr
;
683 exec_hdr (abfd
) = &(rawptr
->e
);
685 obj_textsec (abfd
) = NULL
;
686 obj_datasec (abfd
) = NULL
;
687 obj_bsssec (abfd
) = NULL
;
694 aout_@var{size}_machine_type
697 enum machine_type aout_@var{size}_machine_type
698 (enum bfd_architecture arch,
699 unsigned long machine,
700 bfd_boolean *unknown);
703 Keep track of machine architecture and machine type for
704 a.out's. Return the <<machine_type>> for a particular
705 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
706 and machine can't be represented in a.out format.
708 If the architecture is understood, machine type 0 (default)
709 is always understood.
713 NAME (aout
, machine_type
) (enum bfd_architecture arch
,
714 unsigned long machine
,
715 bfd_boolean
*unknown
)
717 enum machine_type arch_flags
;
719 arch_flags
= M_UNKNOWN
;
726 || machine
== bfd_mach_sparc
727 || machine
== bfd_mach_sparc_sparclite
728 || machine
== bfd_mach_sparc_sparclite_le
729 || machine
== bfd_mach_sparc_v8plus
730 || machine
== bfd_mach_sparc_v8plusa
731 || machine
== bfd_mach_sparc_v8plusb
732 || machine
== bfd_mach_sparc_v8plusc
733 || machine
== bfd_mach_sparc_v8plusd
734 || machine
== bfd_mach_sparc_v8pluse
735 || machine
== bfd_mach_sparc_v8plusv
736 || machine
== bfd_mach_sparc_v8plusm
737 || machine
== bfd_mach_sparc_v8plusm8
738 || machine
== bfd_mach_sparc_v9
739 || machine
== bfd_mach_sparc_v9a
740 || machine
== bfd_mach_sparc_v9b
741 || machine
== bfd_mach_sparc_v9c
742 || machine
== bfd_mach_sparc_v9d
743 || machine
== bfd_mach_sparc_v9e
744 || machine
== bfd_mach_sparc_v9v
745 || machine
== bfd_mach_sparc_v9m
746 || machine
== bfd_mach_sparc_v9m8
)
747 arch_flags
= M_SPARC
;
748 else if (machine
== bfd_mach_sparc_sparclet
)
749 arch_flags
= M_SPARCLET
;
754 || machine
== bfd_mach_i386_i386
755 || machine
== bfd_mach_i386_i386_intel_syntax
)
768 case bfd_mach_mips3000
:
769 case bfd_mach_mips3900
:
770 arch_flags
= M_MIPS1
;
772 case bfd_mach_mips6000
:
773 arch_flags
= M_MIPS2
;
775 case bfd_mach_mips4000
:
776 case bfd_mach_mips4010
:
777 case bfd_mach_mips4100
:
778 case bfd_mach_mips4300
:
779 case bfd_mach_mips4400
:
780 case bfd_mach_mips4600
:
781 case bfd_mach_mips4650
:
782 case bfd_mach_mips8000
:
783 case bfd_mach_mips9000
:
784 case bfd_mach_mips10000
:
785 case bfd_mach_mips12000
:
786 case bfd_mach_mips14000
:
787 case bfd_mach_mips16000
:
788 case bfd_mach_mips16
:
789 case bfd_mach_mipsisa32
:
790 case bfd_mach_mipsisa32r2
:
791 case bfd_mach_mipsisa32r3
:
792 case bfd_mach_mipsisa32r5
:
793 case bfd_mach_mipsisa32r6
:
795 case bfd_mach_mipsisa64
:
796 case bfd_mach_mipsisa64r2
:
797 case bfd_mach_mipsisa64r3
:
798 case bfd_mach_mipsisa64r5
:
799 case bfd_mach_mipsisa64r6
:
800 case bfd_mach_mips_sb1
:
801 case bfd_mach_mips_xlr
:
802 /* FIXME: These should be MIPS3, MIPS4, MIPS16, MIPS32, etc. */
803 arch_flags
= M_MIPS2
;
806 arch_flags
= M_UNKNOWN
;
814 case 0: arch_flags
= M_NS32532
; break;
815 case 32032: arch_flags
= M_NS32032
; break;
816 case 32532: arch_flags
= M_NS32532
; break;
817 default: arch_flags
= M_UNKNOWN
; break;
826 if (machine
== 0 || machine
== 255)
831 arch_flags
= M_UNKNOWN
;
834 if (arch_flags
!= M_UNKNOWN
)
842 aout_@var{size}_set_arch_mach
845 bfd_boolean aout_@var{size}_set_arch_mach,
847 enum bfd_architecture arch,
848 unsigned long machine);
851 Set the architecture and the machine of the BFD @var{abfd} to the
852 values @var{arch} and @var{machine}. Verify that @var{abfd}'s format
853 can support the architecture required.
857 NAME (aout
, set_arch_mach
) (bfd
*abfd
,
858 enum bfd_architecture arch
,
859 unsigned long machine
)
861 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
864 if (arch
!= bfd_arch_unknown
)
868 NAME (aout
, machine_type
) (arch
, machine
, &unknown
);
873 /* Determine the size of a relocation entry. */
878 obj_reloc_entry_size (abfd
) = RELOC_EXT_SIZE
;
881 obj_reloc_entry_size (abfd
) = RELOC_STD_SIZE
;
885 return (*aout_backend_info (abfd
)->set_sizes
) (abfd
);
889 adjust_o_magic (bfd
*abfd
, struct internal_exec
*execp
)
891 file_ptr pos
= adata (abfd
).exec_bytes_size
;
896 obj_textsec (abfd
)->filepos
= pos
;
897 if (!obj_textsec (abfd
)->user_set_vma
)
898 obj_textsec (abfd
)->vma
= vma
;
900 vma
= obj_textsec (abfd
)->vma
;
902 pos
+= obj_textsec (abfd
)->size
;
903 vma
+= obj_textsec (abfd
)->size
;
906 if (!obj_datasec (abfd
)->user_set_vma
)
908 obj_textsec (abfd
)->size
+= pad
;
911 obj_datasec (abfd
)->vma
= vma
;
914 vma
= obj_datasec (abfd
)->vma
;
915 obj_datasec (abfd
)->filepos
= pos
;
916 pos
+= obj_datasec (abfd
)->size
;
917 vma
+= obj_datasec (abfd
)->size
;
920 if (!obj_bsssec (abfd
)->user_set_vma
)
922 obj_datasec (abfd
)->size
+= pad
;
925 obj_bsssec (abfd
)->vma
= vma
;
929 /* The VMA of the .bss section is set by the VMA of the
930 .data section plus the size of the .data section. We may
931 need to add padding bytes to make this true. */
932 pad
= obj_bsssec (abfd
)->vma
- vma
;
935 obj_datasec (abfd
)->size
+= pad
;
939 obj_bsssec (abfd
)->filepos
= pos
;
941 /* Fix up the exec header. */
942 execp
->a_text
= obj_textsec (abfd
)->size
;
943 execp
->a_data
= obj_datasec (abfd
)->size
;
944 execp
->a_bss
= obj_bsssec (abfd
)->size
;
945 N_SET_MAGIC (execp
, OMAGIC
);
949 adjust_z_magic (bfd
*abfd
, struct internal_exec
*execp
)
951 bfd_size_type data_pad
, text_pad
;
953 const struct aout_backend_data
*abdp
;
954 /* TRUE if text includes exec header. */
957 abdp
= aout_backend_info (abfd
);
961 && (abdp
->text_includes_header
962 || obj_aout_subformat (abfd
) == q_magic_format
));
963 obj_textsec (abfd
)->filepos
= (ztih
964 ? adata (abfd
).exec_bytes_size
965 : adata (abfd
).zmagic_disk_block_size
);
966 if (! obj_textsec (abfd
)->user_set_vma
)
968 /* ?? Do we really need to check for relocs here? */
969 obj_textsec (abfd
)->vma
= ((abfd
->flags
& HAS_RELOC
)
972 ? (abdp
->default_text_vma
973 + adata (abfd
).exec_bytes_size
)
974 : abdp
->default_text_vma
));
979 /* The .text section is being loaded at an unusual address. We
980 may need to pad it such that the .data section starts at a page
983 text_pad
= ((obj_textsec (abfd
)->filepos
- obj_textsec (abfd
)->vma
)
984 & (adata (abfd
).page_size
- 1));
986 text_pad
= ((- obj_textsec (abfd
)->vma
)
987 & (adata (abfd
).page_size
- 1));
990 /* Find start of data. */
993 text_end
= obj_textsec (abfd
)->filepos
+ obj_textsec (abfd
)->size
;
994 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
998 /* Note that if page_size == zmagic_disk_block_size, then
999 filepos == page_size, and this case is the same as the ztih
1001 text_end
= obj_textsec (abfd
)->size
;
1002 text_pad
+= BFD_ALIGN (text_end
, adata (abfd
).page_size
) - text_end
;
1003 text_end
+= obj_textsec (abfd
)->filepos
;
1005 obj_textsec (abfd
)->size
+= text_pad
;
1006 text_end
+= text_pad
;
1009 if (!obj_datasec (abfd
)->user_set_vma
)
1012 vma
= obj_textsec (abfd
)->vma
+ obj_textsec (abfd
)->size
;
1013 obj_datasec (abfd
)->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
1015 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
1017 asection
* text
= obj_textsec (abfd
);
1018 asection
* data
= obj_datasec (abfd
);
1020 text_pad
= data
->vma
- (text
->vma
+ text
->size
);
1021 /* Only pad the text section if the data
1022 section is going to be placed after it. */
1024 text
->size
+= text_pad
;
1026 obj_datasec (abfd
)->filepos
= (obj_textsec (abfd
)->filepos
1027 + obj_textsec (abfd
)->size
);
1029 /* Fix up exec header while we're at it. */
1030 execp
->a_text
= obj_textsec (abfd
)->size
;
1031 if (ztih
&& (!abdp
|| (abdp
&& !abdp
->exec_header_not_counted
)))
1032 execp
->a_text
+= adata (abfd
).exec_bytes_size
;
1033 if (obj_aout_subformat (abfd
) == q_magic_format
)
1034 N_SET_MAGIC (execp
, QMAGIC
);
1036 N_SET_MAGIC (execp
, ZMAGIC
);
1038 /* Spec says data section should be rounded up to page boundary. */
1039 obj_datasec (abfd
)->size
1040 = align_power (obj_datasec (abfd
)->size
,
1041 obj_bsssec (abfd
)->alignment_power
);
1042 execp
->a_data
= BFD_ALIGN (obj_datasec (abfd
)->size
,
1043 adata (abfd
).page_size
);
1044 data_pad
= execp
->a_data
- obj_datasec (abfd
)->size
;
1047 if (!obj_bsssec (abfd
)->user_set_vma
)
1048 obj_bsssec (abfd
)->vma
= (obj_datasec (abfd
)->vma
1049 + obj_datasec (abfd
)->size
);
1050 /* If the BSS immediately follows the data section and extra space
1051 in the page is left after the data section, fudge data
1052 in the header so that the bss section looks smaller by that
1053 amount. We'll start the bss section there, and lie to the OS.
1054 (Note that a linker script, as well as the above assignment,
1055 could have explicitly set the BSS vma to immediately follow
1056 the data section.) */
1057 if (align_power (obj_bsssec (abfd
)->vma
, obj_bsssec (abfd
)->alignment_power
)
1058 == obj_datasec (abfd
)->vma
+ obj_datasec (abfd
)->size
)
1059 execp
->a_bss
= (data_pad
> obj_bsssec (abfd
)->size
1060 ? 0 : obj_bsssec (abfd
)->size
- data_pad
);
1062 execp
->a_bss
= obj_bsssec (abfd
)->size
;
1066 adjust_n_magic (bfd
*abfd
, struct internal_exec
*execp
)
1068 file_ptr pos
= adata (abfd
).exec_bytes_size
;
1073 obj_textsec (abfd
)->filepos
= pos
;
1074 if (!obj_textsec (abfd
)->user_set_vma
)
1075 obj_textsec (abfd
)->vma
= vma
;
1077 vma
= obj_textsec (abfd
)->vma
;
1078 pos
+= obj_textsec (abfd
)->size
;
1079 vma
+= obj_textsec (abfd
)->size
;
1082 obj_datasec (abfd
)->filepos
= pos
;
1083 if (!obj_datasec (abfd
)->user_set_vma
)
1084 obj_datasec (abfd
)->vma
= BFD_ALIGN (vma
, adata (abfd
).segment_size
);
1085 vma
= obj_datasec (abfd
)->vma
;
1087 /* Since BSS follows data immediately, see if it needs alignment. */
1088 vma
+= obj_datasec (abfd
)->size
;
1089 pad
= align_power (vma
, obj_bsssec (abfd
)->alignment_power
) - vma
;
1090 obj_datasec (abfd
)->size
+= pad
;
1091 pos
+= obj_datasec (abfd
)->size
;
1094 if (!obj_bsssec (abfd
)->user_set_vma
)
1095 obj_bsssec (abfd
)->vma
= vma
;
1097 vma
= obj_bsssec (abfd
)->vma
;
1099 /* Fix up exec header. */
1100 execp
->a_text
= obj_textsec (abfd
)->size
;
1101 execp
->a_data
= obj_datasec (abfd
)->size
;
1102 execp
->a_bss
= obj_bsssec (abfd
)->size
;
1103 N_SET_MAGIC (execp
, NMAGIC
);
1107 NAME (aout
, adjust_sizes_and_vmas
) (bfd
*abfd
)
1109 struct internal_exec
*execp
= exec_hdr (abfd
);
1111 if (! NAME (aout
, make_sections
) (abfd
))
1114 if (adata (abfd
).magic
!= undecided_magic
)
1117 obj_textsec (abfd
)->size
=
1118 align_power (obj_textsec (abfd
)->size
,
1119 obj_textsec (abfd
)->alignment_power
);
1121 /* Rule (heuristic) for when to pad to a new page. Note that there
1122 are (at least) two ways demand-paged (ZMAGIC) files have been
1123 handled. Most Berkeley-based systems start the text segment at
1124 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1125 segment right after the exec header; the latter is counted in the
1126 text segment size, and is paged in by the kernel with the rest of
1129 /* This perhaps isn't the right way to do this, but made it simpler for me
1130 to understand enough to implement it. Better would probably be to go
1131 right from BFD flags to alignment/positioning characteristics. But the
1132 old code was sloppy enough about handling the flags, and had enough
1133 other magic, that it was a little hard for me to understand. I think
1134 I understand it better now, but I haven't time to do the cleanup this
1137 if (abfd
->flags
& D_PAGED
)
1138 /* Whether or not WP_TEXT is set -- let D_PAGED override. */
1139 adata (abfd
).magic
= z_magic
;
1140 else if (abfd
->flags
& WP_TEXT
)
1141 adata (abfd
).magic
= n_magic
;
1143 adata (abfd
).magic
= o_magic
;
1145 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1147 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1149 switch (adata (abfd
).magic
)
1151 case n_magic
: str
= "NMAGIC"; break;
1152 case o_magic
: str
= "OMAGIC"; break;
1153 case z_magic
: str
= "ZMAGIC"; break;
1158 obj_textsec (abfd
)->vma
, obj_textsec (abfd
)->size
,
1159 obj_textsec (abfd
)->alignment_power
,
1160 obj_datasec (abfd
)->vma
, obj_datasec (abfd
)->size
,
1161 obj_datasec (abfd
)->alignment_power
,
1162 obj_bsssec (abfd
)->vma
, obj_bsssec (abfd
)->size
,
1163 obj_bsssec (abfd
)->alignment_power
);
1167 switch (adata (abfd
).magic
)
1170 adjust_o_magic (abfd
, execp
);
1173 adjust_z_magic (abfd
, execp
);
1176 adjust_n_magic (abfd
, execp
);
1182 #ifdef BFD_AOUT_DEBUG
1183 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1184 obj_textsec (abfd
)->vma
, obj_textsec (abfd
)->size
,
1185 obj_textsec (abfd
)->filepos
,
1186 obj_datasec (abfd
)->vma
, obj_datasec (abfd
)->size
,
1187 obj_datasec (abfd
)->filepos
,
1188 obj_bsssec (abfd
)->vma
, obj_bsssec (abfd
)->size
);
1196 aout_@var{size}_new_section_hook
1199 bfd_boolean aout_@var{size}_new_section_hook,
1204 Called by the BFD in response to a @code{bfd_make_section}
1208 NAME (aout
, new_section_hook
) (bfd
*abfd
, asection
*newsect
)
1210 /* Align to double at least. */
1211 newsect
->alignment_power
= bfd_get_arch_info (abfd
)->section_align_power
;
1213 if (bfd_get_format (abfd
) == bfd_object
)
1215 if (obj_textsec (abfd
) == NULL
&& !strcmp (newsect
->name
, ".text"))
1217 obj_textsec (abfd
)= newsect
;
1218 newsect
->target_index
= N_TEXT
;
1220 else if (obj_datasec (abfd
) == NULL
&& !strcmp (newsect
->name
, ".data"))
1222 obj_datasec (abfd
) = newsect
;
1223 newsect
->target_index
= N_DATA
;
1225 else if (obj_bsssec (abfd
) == NULL
&& !strcmp (newsect
->name
, ".bss"))
1227 obj_bsssec (abfd
) = newsect
;
1228 newsect
->target_index
= N_BSS
;
1232 /* We allow more than three sections internally. */
1233 return _bfd_generic_new_section_hook (abfd
, newsect
);
1237 NAME (aout
, set_section_contents
) (bfd
*abfd
,
1239 const void * location
,
1241 bfd_size_type count
)
1243 if (! abfd
->output_has_begun
)
1245 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
1249 if (section
== obj_bsssec (abfd
))
1251 bfd_set_error (bfd_error_no_contents
);
1255 if (section
!= obj_textsec (abfd
)
1256 && section
!= obj_datasec (abfd
))
1258 if (aout_section_merge_with_text_p (abfd
, section
))
1259 section
->filepos
= obj_textsec (abfd
)->filepos
+
1260 (section
->vma
- obj_textsec (abfd
)->vma
);
1264 /* xgettext:c-format */
1265 (_("%pB: can not represent section `%pA' in a.out object file format"),
1267 bfd_set_error (bfd_error_nonrepresentable_section
);
1274 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
1275 || bfd_bwrite (location
, count
, abfd
) != count
)
1282 /* Read the external symbols from an a.out file. */
1285 aout_get_external_symbols (bfd
*abfd
)
1287 if (obj_aout_external_syms (abfd
) == NULL
)
1289 bfd_size_type count
;
1290 struct external_nlist
*syms
;
1291 bfd_size_type amt
= exec_hdr (abfd
)->a_syms
;
1293 count
= amt
/ EXTERNAL_NLIST_SIZE
;
1295 return TRUE
; /* Nothing to do. */
1298 if (! bfd_get_file_window (abfd
, obj_sym_filepos (abfd
), amt
,
1299 &obj_aout_sym_window (abfd
), TRUE
))
1301 syms
= (struct external_nlist
*) obj_aout_sym_window (abfd
).data
;
1303 /* We allocate using malloc to make the values easy to free
1304 later on. If we put them on the objalloc it might not be
1305 possible to free them. */
1306 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1308 syms
= (struct external_nlist
*) _bfd_malloc_and_read (abfd
, amt
, amt
);
1313 obj_aout_external_syms (abfd
) = syms
;
1314 obj_aout_external_sym_count (abfd
) = count
;
1317 if (obj_aout_external_strings (abfd
) == NULL
1318 && exec_hdr (abfd
)->a_syms
!= 0)
1320 unsigned char string_chars
[BYTES_IN_WORD
];
1321 bfd_size_type stringsize
;
1323 bfd_size_type amt
= BYTES_IN_WORD
;
1325 /* Get the size of the strings. */
1326 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0
1327 || bfd_bread ((void *) string_chars
, amt
, abfd
) != amt
)
1329 stringsize
= GET_WORD (abfd
, string_chars
);
1330 if (stringsize
== 0)
1332 else if (stringsize
< BYTES_IN_WORD
1333 || (size_t) stringsize
!= stringsize
)
1335 bfd_set_error (bfd_error_bad_value
);
1340 if (stringsize
>= BYTES_IN_WORD
)
1342 if (! bfd_get_file_window (abfd
, obj_str_filepos (abfd
), stringsize
+ 1,
1343 &obj_aout_string_window (abfd
), TRUE
))
1345 strings
= (char *) obj_aout_string_window (abfd
).data
;
1350 strings
= (char *) bfd_malloc (stringsize
+ 1);
1351 if (strings
== NULL
)
1354 if (stringsize
>= BYTES_IN_WORD
)
1356 /* Keep the string count in the buffer for convenience
1357 when indexing with e_strx. */
1358 amt
= stringsize
- BYTES_IN_WORD
;
1359 if (bfd_bread (strings
+ BYTES_IN_WORD
, amt
, abfd
) != amt
)
1366 /* Ensure that a zero index yields an empty string. */
1369 /* Ensure that the string buffer is NUL terminated. */
1370 strings
[stringsize
] = 0;
1372 obj_aout_external_strings (abfd
) = strings
;
1373 obj_aout_external_string_size (abfd
) = stringsize
;
1379 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1380 and symbol->value fields of CACHE_PTR will be set from the a.out
1381 nlist structure. This function is responsible for setting
1382 symbol->flags and symbol->section, and adjusting symbol->value. */
1385 translate_from_native_sym_flags (bfd
*abfd
, aout_symbol_type
*cache_ptr
)
1389 if ((cache_ptr
->type
& N_STAB
) != 0
1390 || cache_ptr
->type
== N_FN
)
1394 /* This is a debugging symbol. */
1395 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1397 /* Work out the symbol section. */
1398 switch (cache_ptr
->type
& N_TYPE
)
1402 sec
= obj_textsec (abfd
);
1405 sec
= obj_datasec (abfd
);
1408 sec
= obj_bsssec (abfd
);
1412 sec
= bfd_abs_section_ptr
;
1416 cache_ptr
->symbol
.section
= sec
;
1417 cache_ptr
->symbol
.value
-= sec
->vma
;
1422 /* Get the default visibility. This does not apply to all types, so
1423 we just hold it in a local variable to use if wanted. */
1424 if ((cache_ptr
->type
& N_EXT
) == 0)
1425 visible
= BSF_LOCAL
;
1427 visible
= BSF_GLOBAL
;
1429 switch (cache_ptr
->type
)
1432 case N_ABS
: case N_ABS
| N_EXT
:
1433 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1434 cache_ptr
->symbol
.flags
= visible
;
1437 case N_UNDF
| N_EXT
:
1438 if (cache_ptr
->symbol
.value
!= 0)
1440 /* This is a common symbol. */
1441 cache_ptr
->symbol
.flags
= BSF_GLOBAL
;
1442 cache_ptr
->symbol
.section
= bfd_com_section_ptr
;
1446 cache_ptr
->symbol
.flags
= 0;
1447 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1451 case N_TEXT
: case N_TEXT
| N_EXT
:
1452 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1453 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1454 cache_ptr
->symbol
.flags
= visible
;
1457 /* N_SETV symbols used to represent set vectors placed in the
1458 data section. They are no longer generated. Theoretically,
1459 it was possible to extract the entries and combine them with
1460 new ones, although I don't know if that was ever actually
1461 done. Unless that feature is restored, treat them as data
1463 case N_SETV
: case N_SETV
| N_EXT
:
1464 case N_DATA
: case N_DATA
| N_EXT
:
1465 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1466 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1467 cache_ptr
->symbol
.flags
= visible
;
1470 case N_BSS
: case N_BSS
| N_EXT
:
1471 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1472 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1473 cache_ptr
->symbol
.flags
= visible
;
1476 case N_SETA
: case N_SETA
| N_EXT
:
1477 case N_SETT
: case N_SETT
| N_EXT
:
1478 case N_SETD
: case N_SETD
| N_EXT
:
1479 case N_SETB
: case N_SETB
| N_EXT
:
1481 /* This code is no longer needed. It used to be used to make
1482 the linker handle set symbols, but they are now handled in
1483 the add_symbols routine instead. */
1484 switch (cache_ptr
->type
& N_TYPE
)
1487 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1490 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1493 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1496 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1500 cache_ptr
->symbol
.flags
|= BSF_CONSTRUCTOR
;
1505 /* This symbol is the text of a warning message. The next
1506 symbol is the symbol to associate the warning with. If a
1507 reference is made to that symbol, a warning is issued. */
1508 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
| BSF_WARNING
;
1509 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1512 case N_INDR
: case N_INDR
| N_EXT
:
1513 /* An indirect symbol. This consists of two symbols in a row.
1514 The first symbol is the name of the indirection. The second
1515 symbol is the name of the target. A reference to the first
1516 symbol becomes a reference to the second. */
1517 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
| BSF_INDIRECT
| visible
;
1518 cache_ptr
->symbol
.section
= bfd_ind_section_ptr
;
1522 cache_ptr
->symbol
.section
= bfd_und_section_ptr
;
1523 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1527 cache_ptr
->symbol
.section
= bfd_abs_section_ptr
;
1528 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1532 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1533 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1534 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1538 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1539 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1540 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1544 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1545 cache_ptr
->symbol
.value
-= cache_ptr
->symbol
.section
->vma
;
1546 cache_ptr
->symbol
.flags
= BSF_WEAK
;
1553 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1556 translate_to_native_sym_flags (bfd
*abfd
,
1558 struct external_nlist
*sym_pointer
)
1560 bfd_vma value
= cache_ptr
->value
;
1564 /* Mask out any existing type bits in case copying from one section
1566 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1568 sec
= bfd_asymbol_section (cache_ptr
);
1573 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1576 /* xgettext:c-format */
1577 (_("%pB: can not represent section for symbol `%s' in a.out "
1578 "object file format"),
1580 cache_ptr
->name
!= NULL
? cache_ptr
->name
: _("*unknown*"));
1581 bfd_set_error (bfd_error_nonrepresentable_section
);
1585 if (sec
->output_section
!= NULL
)
1587 off
= sec
->output_offset
;
1588 sec
= sec
->output_section
;
1591 if (bfd_is_abs_section (sec
))
1592 sym_pointer
->e_type
[0] |= N_ABS
;
1593 else if (sec
== obj_textsec (abfd
))
1594 sym_pointer
->e_type
[0] |= N_TEXT
;
1595 else if (sec
== obj_datasec (abfd
))
1596 sym_pointer
->e_type
[0] |= N_DATA
;
1597 else if (sec
== obj_bsssec (abfd
))
1598 sym_pointer
->e_type
[0] |= N_BSS
;
1599 else if (bfd_is_und_section (sec
))
1600 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1601 else if (bfd_is_ind_section (sec
))
1602 sym_pointer
->e_type
[0] = N_INDR
;
1603 else if (bfd_is_com_section (sec
))
1604 sym_pointer
->e_type
[0] = N_UNDF
| N_EXT
;
1607 if (aout_section_merge_with_text_p (abfd
, sec
))
1608 sym_pointer
->e_type
[0] |= N_TEXT
;
1612 /* xgettext:c-format */
1613 (_("%pB: can not represent section `%pA' in a.out object file format"),
1615 bfd_set_error (bfd_error_nonrepresentable_section
);
1620 /* Turn the symbol from section relative to absolute again. */
1621 value
+= sec
->vma
+ off
;
1623 if ((cache_ptr
->flags
& BSF_WARNING
) != 0)
1624 sym_pointer
->e_type
[0] = N_WARNING
;
1626 if ((cache_ptr
->flags
& BSF_DEBUGGING
) != 0)
1627 sym_pointer
->e_type
[0] = ((aout_symbol_type
*) cache_ptr
)->type
;
1628 else if ((cache_ptr
->flags
& BSF_GLOBAL
) != 0)
1629 sym_pointer
->e_type
[0] |= N_EXT
;
1630 else if ((cache_ptr
->flags
& BSF_LOCAL
) != 0)
1631 sym_pointer
->e_type
[0] &= ~N_EXT
;
1633 if ((cache_ptr
->flags
& BSF_CONSTRUCTOR
) != 0)
1635 int type
= ((aout_symbol_type
*) cache_ptr
)->type
;
1639 case N_ABS
: type
= N_SETA
; break;
1640 case N_TEXT
: type
= N_SETT
; break;
1641 case N_DATA
: type
= N_SETD
; break;
1642 case N_BSS
: type
= N_SETB
; break;
1644 sym_pointer
->e_type
[0] = type
;
1647 if ((cache_ptr
->flags
& BSF_WEAK
) != 0)
1651 switch (sym_pointer
->e_type
[0] & N_TYPE
)
1654 case N_ABS
: type
= N_WEAKA
; break;
1655 case N_TEXT
: type
= N_WEAKT
; break;
1656 case N_DATA
: type
= N_WEAKD
; break;
1657 case N_BSS
: type
= N_WEAKB
; break;
1658 case N_UNDF
: type
= N_WEAKU
; break;
1660 sym_pointer
->e_type
[0] = type
;
1663 PUT_WORD (abfd
, value
, sym_pointer
->e_value
);
1668 /* Native-level interface to symbols. */
1671 NAME (aout
, make_empty_symbol
) (bfd
*abfd
)
1673 size_t amt
= sizeof (aout_symbol_type
);
1675 aout_symbol_type
*new_symbol
= (aout_symbol_type
*) bfd_zalloc (abfd
, amt
);
1678 new_symbol
->symbol
.the_bfd
= abfd
;
1680 return &new_symbol
->symbol
;
1683 /* Translate a set of internal symbols into external symbols. */
1686 NAME (aout
, translate_symbol_table
) (bfd
*abfd
,
1687 aout_symbol_type
*in
,
1688 struct external_nlist
*ext
,
1689 bfd_size_type count
,
1691 bfd_size_type strsize
,
1692 bfd_boolean dynamic
)
1694 struct external_nlist
*ext_end
;
1696 ext_end
= ext
+ count
;
1697 for (; ext
< ext_end
; ext
++, in
++)
1701 x
= GET_WORD (abfd
, ext
->e_strx
);
1702 in
->symbol
.the_bfd
= abfd
;
1704 /* For the normal symbols, the zero index points at the number
1705 of bytes in the string table but is to be interpreted as the
1706 null string. For the dynamic symbols, the number of bytes in
1707 the string table is stored in the __DYNAMIC structure and the
1708 zero index points at an actual string. */
1709 if (x
== 0 && ! dynamic
)
1710 in
->symbol
.name
= "";
1711 else if (x
< strsize
)
1712 in
->symbol
.name
= str
+ x
;
1716 (_("%pB: invalid string offset %" PRIu64
" >= %" PRIu64
),
1717 abfd
, (uint64_t) x
, (uint64_t) strsize
);
1718 bfd_set_error (bfd_error_bad_value
);
1722 in
->symbol
.value
= GET_SWORD (abfd
, ext
->e_value
);
1723 in
->desc
= H_GET_16 (abfd
, ext
->e_desc
);
1724 in
->other
= H_GET_8 (abfd
, ext
->e_other
);
1725 in
->type
= H_GET_8 (abfd
, ext
->e_type
);
1726 in
->symbol
.udata
.p
= NULL
;
1728 if (! translate_from_native_sym_flags (abfd
, in
))
1732 in
->symbol
.flags
|= BSF_DYNAMIC
;
1738 /* We read the symbols into a buffer, which is discarded when this
1739 function exits. We read the strings into a buffer large enough to
1740 hold them all plus all the cached symbol entries. */
1743 NAME (aout
, slurp_symbol_table
) (bfd
*abfd
)
1745 struct external_nlist
*old_external_syms
;
1746 aout_symbol_type
*cached
;
1747 bfd_size_type cached_size
;
1749 /* If there's no work to be done, don't do any. */
1750 if (obj_aout_symbols (abfd
) != NULL
)
1753 old_external_syms
= obj_aout_external_syms (abfd
);
1755 if (! aout_get_external_symbols (abfd
))
1758 cached_size
= obj_aout_external_sym_count (abfd
);
1759 if (cached_size
== 0)
1760 return TRUE
; /* Nothing to do. */
1762 cached_size
*= sizeof (aout_symbol_type
);
1763 cached
= (aout_symbol_type
*) bfd_zmalloc (cached_size
);
1767 /* Convert from external symbol information to internal. */
1768 if (! (NAME (aout
, translate_symbol_table
)
1770 obj_aout_external_syms (abfd
),
1771 obj_aout_external_sym_count (abfd
),
1772 obj_aout_external_strings (abfd
),
1773 obj_aout_external_string_size (abfd
),
1780 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
1782 obj_aout_symbols (abfd
) = cached
;
1784 /* It is very likely that anybody who calls this function will not
1785 want the external symbol information, so if it was allocated
1786 because of our call to aout_get_external_symbols, we free it up
1787 right away to save space. */
1788 if (old_external_syms
== NULL
1789 && obj_aout_external_syms (abfd
) != NULL
)
1792 bfd_free_window (&obj_aout_sym_window (abfd
));
1794 free (obj_aout_external_syms (abfd
));
1796 obj_aout_external_syms (abfd
) = NULL
;
1802 /* We use a hash table when writing out symbols so that we only write
1803 out a particular string once. This helps particularly when the
1804 linker writes out stabs debugging entries, because each different
1805 contributing object file tends to have many duplicate stabs
1808 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1809 if BFD_TRADITIONAL_FORMAT is set. */
1811 /* Get the index of a string in a strtab, adding it if it is not
1814 static inline bfd_size_type
1815 add_to_stringtab (bfd
*abfd
,
1816 struct bfd_strtab_hash
*tab
,
1821 bfd_size_type str_index
;
1823 /* An index of 0 always means the empty string. */
1824 if (str
== 0 || *str
== '\0')
1827 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1828 doesn't understand a hashed string table. */
1830 if ((abfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1833 str_index
= _bfd_stringtab_add (tab
, str
, hash
, copy
);
1835 if (str_index
!= (bfd_size_type
) -1)
1836 /* Add BYTES_IN_WORD to the return value to account for the
1837 space taken up by the string table size. */
1838 str_index
+= BYTES_IN_WORD
;
1843 /* Write out a strtab. ABFD is already at the right location in the
1847 emit_stringtab (bfd
*abfd
, struct bfd_strtab_hash
*tab
)
1849 bfd_byte buffer
[BYTES_IN_WORD
];
1850 size_t amt
= BYTES_IN_WORD
;
1852 /* The string table starts with the size. */
1853 PUT_WORD (abfd
, _bfd_stringtab_size (tab
) + BYTES_IN_WORD
, buffer
);
1854 if (bfd_bwrite ((void *) buffer
, amt
, abfd
) != amt
)
1857 return _bfd_stringtab_emit (abfd
, tab
);
1861 NAME (aout
, write_syms
) (bfd
*abfd
)
1863 unsigned int count
;
1864 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1865 struct bfd_strtab_hash
*strtab
;
1867 strtab
= _bfd_stringtab_init ();
1871 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++)
1873 asymbol
*g
= generic
[count
];
1875 struct external_nlist nsp
;
1878 indx
= add_to_stringtab (abfd
, strtab
, g
->name
, FALSE
);
1879 if (indx
== (bfd_size_type
) -1)
1881 PUT_WORD (abfd
, indx
, (bfd_byte
*) nsp
.e_strx
);
1883 if (bfd_asymbol_flavour (g
) == abfd
->xvec
->flavour
)
1885 H_PUT_16 (abfd
, aout_symbol (g
)->desc
, nsp
.e_desc
);
1886 H_PUT_8 (abfd
, aout_symbol (g
)->other
, nsp
.e_other
);
1887 H_PUT_8 (abfd
, aout_symbol (g
)->type
, nsp
.e_type
);
1891 H_PUT_16 (abfd
, 0, nsp
.e_desc
);
1892 H_PUT_8 (abfd
, 0, nsp
.e_other
);
1893 H_PUT_8 (abfd
, 0, nsp
.e_type
);
1896 if (! translate_to_native_sym_flags (abfd
, g
, &nsp
))
1899 amt
= EXTERNAL_NLIST_SIZE
;
1900 if (bfd_bwrite ((void *) &nsp
, amt
, abfd
) != amt
)
1903 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1904 here, at the end. */
1908 if (! emit_stringtab (abfd
, strtab
))
1911 _bfd_stringtab_free (strtab
);
1916 _bfd_stringtab_free (strtab
);
1921 NAME (aout
, canonicalize_symtab
) (bfd
*abfd
, asymbol
**location
)
1923 unsigned int counter
= 0;
1924 aout_symbol_type
*symbase
;
1926 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
1929 for (symbase
= obj_aout_symbols (abfd
);
1930 counter
++ < bfd_get_symcount (abfd
);
1932 *(location
++) = (asymbol
*) (symbase
++);
1934 return bfd_get_symcount (abfd
);
1937 /* Standard reloc stuff. */
1938 /* Output standard relocation information to a file in target byte order. */
1940 extern void NAME (aout
, swap_std_reloc_out
)
1941 (bfd
*, arelent
*, struct reloc_std_external
*);
1944 NAME (aout
, swap_std_reloc_out
) (bfd
*abfd
,
1946 struct reloc_std_external
*natptr
)
1949 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1951 unsigned int r_length
;
1953 int r_baserel
, r_jmptable
, r_relative
;
1954 asection
*output_section
= sym
->section
->output_section
;
1956 PUT_WORD (abfd
, g
->address
, natptr
->r_address
);
1958 BFD_ASSERT (g
->howto
!= NULL
);
1959 r_length
= g
->howto
->size
; /* Size as a power of two. */
1960 r_pcrel
= (int) g
->howto
->pc_relative
; /* Relative to PC? */
1961 /* XXX This relies on relocs coming from a.out files. */
1962 r_baserel
= (g
->howto
->type
& 8) != 0;
1963 r_jmptable
= (g
->howto
->type
& 16) != 0;
1964 r_relative
= (g
->howto
->type
& 32) != 0;
1966 /* Name was clobbered by aout_write_syms to be symbol index. */
1968 /* If this relocation is relative to a symbol then set the
1969 r_index to the symbols index, and the r_extern bit.
1971 Absolute symbols can come in in two ways, either as an offset
1972 from the abs section, or as a symbol which has an abs value.
1973 check for that here. */
1975 if (bfd_is_com_section (output_section
)
1976 || bfd_is_abs_section (output_section
)
1977 || bfd_is_und_section (output_section
)
1978 /* PR gas/3041 a.out relocs against weak symbols
1979 must be treated as if they were against externs. */
1980 || (sym
->flags
& BSF_WEAK
))
1982 if (bfd_abs_section_ptr
->symbol
== sym
)
1984 /* Whoops, looked like an abs symbol, but is
1985 really an offset from the abs section. */
1991 /* Fill in symbol. */
1993 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
1998 /* Just an ordinary section. */
2000 r_index
= output_section
->target_index
;
2003 /* Now the fun stuff. */
2004 if (bfd_header_big_endian (abfd
))
2006 natptr
->r_index
[0] = r_index
>> 16;
2007 natptr
->r_index
[1] = r_index
>> 8;
2008 natptr
->r_index
[2] = r_index
;
2009 natptr
->r_type
[0] = ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
2010 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
2011 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
2012 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
2013 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
2014 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
2018 natptr
->r_index
[2] = r_index
>> 16;
2019 natptr
->r_index
[1] = r_index
>> 8;
2020 natptr
->r_index
[0] = r_index
;
2021 natptr
->r_type
[0] = ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
2022 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
2023 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
2024 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
2025 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
2026 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
2030 /* Extended stuff. */
2031 /* Output extended relocation information to a file in target byte order. */
2033 extern void NAME (aout
, swap_ext_reloc_out
)
2034 (bfd
*, arelent
*, struct reloc_ext_external
*);
2037 NAME (aout
, swap_ext_reloc_out
) (bfd
*abfd
,
2039 struct reloc_ext_external
*natptr
)
2043 unsigned int r_type
;
2045 asymbol
*sym
= *(g
->sym_ptr_ptr
);
2046 asection
*output_section
= sym
->section
->output_section
;
2048 PUT_WORD (abfd
, g
->address
, natptr
->r_address
);
2050 r_type
= (unsigned int) g
->howto
->type
;
2052 r_addend
= g
->addend
;
2053 if ((sym
->flags
& BSF_SECTION_SYM
) != 0)
2054 r_addend
+= (*(g
->sym_ptr_ptr
))->section
->output_section
->vma
;
2056 /* If this relocation is relative to a symbol then set the
2057 r_index to the symbols index, and the r_extern bit.
2059 Absolute symbols can come in in two ways, either as an offset
2060 from the abs section, or as a symbol which has an abs value.
2061 check for that here. */
2062 if (bfd_is_abs_section (bfd_asymbol_section (sym
)))
2067 else if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2069 if (bfd_is_und_section (bfd_asymbol_section (sym
))
2070 || (sym
->flags
& BSF_GLOBAL
) != 0)
2074 r_index
= (*(g
->sym_ptr_ptr
))->KEEPIT
;
2078 /* Just an ordinary section. */
2080 r_index
= output_section
->target_index
;
2083 /* Now the fun stuff. */
2084 if (bfd_header_big_endian (abfd
))
2086 natptr
->r_index
[0] = r_index
>> 16;
2087 natptr
->r_index
[1] = r_index
>> 8;
2088 natptr
->r_index
[2] = r_index
;
2089 natptr
->r_type
[0] = ((r_extern
? RELOC_EXT_BITS_EXTERN_BIG
: 0)
2090 | (r_type
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
2094 natptr
->r_index
[2] = r_index
>> 16;
2095 natptr
->r_index
[1] = r_index
>> 8;
2096 natptr
->r_index
[0] = r_index
;
2097 natptr
->r_type
[0] = ((r_extern
? RELOC_EXT_BITS_EXTERN_LITTLE
: 0)
2098 | (r_type
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
));
2101 PUT_WORD (abfd
, r_addend
, natptr
->r_addend
);
2104 /* BFD deals internally with all things based from the section they're
2105 in. so, something in 10 bytes into a text section with a base of
2106 50 would have a symbol (.text+10) and know .text vma was 50.
2108 Aout keeps all it's symbols based from zero, so the symbol would
2109 contain 60. This macro subs the base of each section from the value
2110 to give the true offset from the section. */
2112 #define MOVE_ADDRESS(ad) \
2115 /* Undefined symbol. */ \
2116 cache_ptr->sym_ptr_ptr = symbols + r_index; \
2117 cache_ptr->addend = ad; \
2121 /* Defined, section relative. Replace symbol with pointer to \
2122 symbol which points to section. */ \
2126 case N_TEXT | N_EXT: \
2127 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \
2128 cache_ptr->addend = ad - su->textsec->vma; \
2131 case N_DATA | N_EXT: \
2132 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \
2133 cache_ptr->addend = ad - su->datasec->vma; \
2136 case N_BSS | N_EXT: \
2137 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \
2138 cache_ptr->addend = ad - su->bsssec->vma; \
2142 case N_ABS | N_EXT: \
2143 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
2144 cache_ptr->addend = ad; \
2150 NAME (aout
, swap_ext_reloc_in
) (bfd
*abfd
,
2151 struct reloc_ext_external
*bytes
,
2154 bfd_size_type symcount
)
2156 unsigned int r_index
;
2158 unsigned int r_type
;
2159 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
2161 cache_ptr
->address
= (GET_SWORD (abfd
, bytes
->r_address
));
2163 /* Now the fun stuff. */
2164 if (bfd_header_big_endian (abfd
))
2166 r_index
= (((unsigned int) bytes
->r_index
[0] << 16)
2167 | ((unsigned int) bytes
->r_index
[1] << 8)
2168 | bytes
->r_index
[2]);
2169 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
2170 r_type
= ((bytes
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
2171 >> RELOC_EXT_BITS_TYPE_SH_BIG
);
2175 r_index
= (((unsigned int) bytes
->r_index
[2] << 16)
2176 | ((unsigned int) bytes
->r_index
[1] << 8)
2177 | bytes
->r_index
[0]);
2178 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
2179 r_type
= ((bytes
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
2180 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
);
2183 if (r_type
< TABLE_SIZE (howto_table_ext
))
2184 cache_ptr
->howto
= howto_table_ext
+ r_type
;
2186 cache_ptr
->howto
= NULL
;
2188 /* Base relative relocs are always against the symbol table,
2189 regardless of the setting of r_extern. r_extern just reflects
2190 whether the symbol the reloc is against is local or global. */
2191 if (r_type
== (unsigned int) RELOC_BASE10
2192 || r_type
== (unsigned int) RELOC_BASE13
2193 || r_type
== (unsigned int) RELOC_BASE22
)
2196 if (r_extern
&& r_index
> symcount
)
2198 /* We could arrange to return an error, but it might be useful
2199 to see the file even if it is bad. */
2204 MOVE_ADDRESS (GET_SWORD (abfd
, bytes
->r_addend
));
2208 NAME (aout
, swap_std_reloc_in
) (bfd
*abfd
,
2209 struct reloc_std_external
*bytes
,
2212 bfd_size_type symcount
)
2214 unsigned int r_index
;
2216 unsigned int r_length
;
2218 int r_baserel
, r_jmptable
, r_relative
;
2219 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
2220 unsigned int howto_idx
;
2222 cache_ptr
->address
= H_GET_32 (abfd
, bytes
->r_address
);
2224 /* Now the fun stuff. */
2225 if (bfd_header_big_endian (abfd
))
2227 r_index
= (((unsigned int) bytes
->r_index
[0] << 16)
2228 | ((unsigned int) bytes
->r_index
[1] << 8)
2229 | bytes
->r_index
[2]);
2230 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
));
2231 r_pcrel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_PCREL_BIG
));
2232 r_baserel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
2233 r_jmptable
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
2234 r_relative
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_RELATIVE_BIG
));
2235 r_length
= ((bytes
->r_type
[0] & RELOC_STD_BITS_LENGTH_BIG
)
2236 >> RELOC_STD_BITS_LENGTH_SH_BIG
);
2240 r_index
= (((unsigned int) bytes
->r_index
[2] << 16)
2241 | ((unsigned int) bytes
->r_index
[1] << 8)
2242 | bytes
->r_index
[0]);
2243 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
));
2244 r_pcrel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_PCREL_LITTLE
));
2245 r_baserel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_BASEREL_LITTLE
));
2246 r_jmptable
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_LITTLE
));
2247 r_relative
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_RELATIVE_LITTLE
));
2248 r_length
= ((bytes
->r_type
[0] & RELOC_STD_BITS_LENGTH_LITTLE
)
2249 >> RELOC_STD_BITS_LENGTH_SH_LITTLE
);
2252 howto_idx
= (r_length
+ 4 * r_pcrel
+ 8 * r_baserel
2253 + 16 * r_jmptable
+ 32 * r_relative
);
2254 if (howto_idx
< TABLE_SIZE (howto_table_std
))
2256 cache_ptr
->howto
= howto_table_std
+ howto_idx
;
2257 if (cache_ptr
->howto
->type
== (unsigned int) -1)
2258 cache_ptr
->howto
= NULL
;
2261 cache_ptr
->howto
= NULL
;
2263 /* Base relative relocs are always against the symbol table,
2264 regardless of the setting of r_extern. r_extern just reflects
2265 whether the symbol the reloc is against is local or global. */
2269 if (r_extern
&& r_index
>= symcount
)
2271 /* We could arrange to return an error, but it might be useful
2272 to see the file even if it is bad. FIXME: Of course this
2273 means that objdump -r *doesn't* see the actual reloc, and
2274 objcopy silently writes a different reloc. */
2282 /* Read and swap the relocs for a section. */
2285 NAME (aout
, slurp_reloc_table
) (bfd
*abfd
, sec_ptr asect
, asymbol
**symbols
)
2287 bfd_size_type count
;
2288 bfd_size_type reloc_size
;
2290 arelent
*reloc_cache
;
2292 unsigned int counter
= 0;
2296 if (asect
->relocation
)
2299 if (asect
->flags
& SEC_CONSTRUCTOR
)
2302 if (asect
== obj_datasec (abfd
))
2303 reloc_size
= exec_hdr (abfd
)->a_drsize
;
2304 else if (asect
== obj_textsec (abfd
))
2305 reloc_size
= exec_hdr (abfd
)->a_trsize
;
2306 else if (asect
== obj_bsssec (abfd
))
2310 bfd_set_error (bfd_error_invalid_operation
);
2314 each_size
= obj_reloc_entry_size (abfd
);
2315 count
= reloc_size
/ each_size
;
2317 return TRUE
; /* Nothing to be done. */
2319 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
2321 relocs
= _bfd_malloc_and_read (abfd
, reloc_size
, reloc_size
);
2325 amt
= count
* sizeof (arelent
);
2326 reloc_cache
= (arelent
*) bfd_zmalloc (amt
);
2327 if (reloc_cache
== NULL
)
2333 cache_ptr
= reloc_cache
;
2334 if (each_size
== RELOC_EXT_SIZE
)
2336 struct reloc_ext_external
*rptr
= (struct reloc_ext_external
*) relocs
;
2338 for (; counter
< count
; counter
++, rptr
++, cache_ptr
++)
2339 MY_swap_ext_reloc_in (abfd
, rptr
, cache_ptr
, symbols
,
2340 (bfd_size_type
) bfd_get_symcount (abfd
));
2344 struct reloc_std_external
*rptr
= (struct reloc_std_external
*) relocs
;
2346 for (; counter
< count
; counter
++, rptr
++, cache_ptr
++)
2347 MY_swap_std_reloc_in (abfd
, rptr
, cache_ptr
, symbols
,
2348 (bfd_size_type
) bfd_get_symcount (abfd
));
2353 asect
->relocation
= reloc_cache
;
2354 asect
->reloc_count
= cache_ptr
- reloc_cache
;
2359 /* Write out a relocation section into an object file. */
2362 NAME (aout
, squirt_out_relocs
) (bfd
*abfd
, asection
*section
)
2365 unsigned char *native
, *natptr
;
2368 unsigned int count
= section
->reloc_count
;
2369 bfd_size_type natsize
;
2371 if (count
== 0 || section
->orelocation
== NULL
)
2374 each_size
= obj_reloc_entry_size (abfd
);
2375 natsize
= (bfd_size_type
) each_size
* count
;
2376 native
= (unsigned char *) bfd_zalloc (abfd
, natsize
);
2380 generic
= section
->orelocation
;
2382 if (each_size
== RELOC_EXT_SIZE
)
2384 for (natptr
= native
;
2386 --count
, natptr
+= each_size
, ++generic
)
2388 /* PR 20921: If the howto field has not been initialised then skip
2390 PR 20929: Similarly for the symbol field. */
2391 if ((*generic
)->howto
== NULL
2392 || (*generic
)->sym_ptr_ptr
== NULL
)
2394 bfd_set_error (bfd_error_invalid_operation
);
2395 _bfd_error_handler (_("\
2396 %pB: attempt to write out unknown reloc type"), abfd
);
2399 MY_swap_ext_reloc_out (abfd
, *generic
,
2400 (struct reloc_ext_external
*) natptr
);
2405 for (natptr
= native
;
2407 --count
, natptr
+= each_size
, ++generic
)
2409 if ((*generic
)->howto
== NULL
2410 || (*generic
)->sym_ptr_ptr
== NULL
)
2412 bfd_set_error (bfd_error_invalid_operation
);
2413 _bfd_error_handler (_("\
2414 %pB: attempt to write out unknown reloc type"), abfd
);
2417 MY_swap_std_reloc_out (abfd
, *generic
,
2418 (struct reloc_std_external
*) natptr
);
2422 if (bfd_bwrite ((void *) native
, natsize
, abfd
) != natsize
)
2424 bfd_release (abfd
, native
);
2427 bfd_release (abfd
, native
);
2432 /* This is stupid. This function should be a boolean predicate. */
2435 NAME (aout
, canonicalize_reloc
) (bfd
*abfd
,
2440 arelent
*tblptr
= section
->relocation
;
2443 if (section
== obj_bsssec (abfd
))
2449 if (!(tblptr
|| NAME (aout
, slurp_reloc_table
) (abfd
, section
, symbols
)))
2452 if (section
->flags
& SEC_CONSTRUCTOR
)
2454 arelent_chain
*chain
= section
->constructor_chain
;
2455 for (count
= 0; count
< section
->reloc_count
; count
++)
2457 *relptr
++ = &chain
->relent
;
2458 chain
= chain
->next
;
2463 tblptr
= section
->relocation
;
2465 for (count
= 0; count
++ < section
->reloc_count
; )
2467 *relptr
++ = tblptr
++;
2472 return section
->reloc_count
;
2476 NAME (aout
, get_reloc_upper_bound
) (bfd
*abfd
, sec_ptr asect
)
2478 bfd_size_type count
;
2480 if (bfd_get_format (abfd
) != bfd_object
)
2482 bfd_set_error (bfd_error_invalid_operation
);
2486 if (asect
->flags
& SEC_CONSTRUCTOR
)
2487 count
= asect
->reloc_count
;
2488 else if (asect
== obj_datasec (abfd
))
2489 count
= exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
2490 else if (asect
== obj_textsec (abfd
))
2491 count
= exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
2492 else if (asect
== obj_bsssec (abfd
))
2496 bfd_set_error (bfd_error_invalid_operation
);
2500 if (count
>= LONG_MAX
/ sizeof (arelent
*))
2502 bfd_set_error (bfd_error_file_too_big
);
2505 return (count
+ 1) * sizeof (arelent
*);
2509 NAME (aout
, get_symtab_upper_bound
) (bfd
*abfd
)
2511 if (!NAME (aout
, slurp_symbol_table
) (abfd
))
2514 return (bfd_get_symcount (abfd
)+1) * (sizeof (aout_symbol_type
*));
2518 NAME (aout
, get_lineno
) (bfd
*ignore_abfd ATTRIBUTE_UNUSED
,
2519 asymbol
*ignore_symbol ATTRIBUTE_UNUSED
)
2525 NAME (aout
, get_symbol_info
) (bfd
*ignore_abfd ATTRIBUTE_UNUSED
,
2529 bfd_symbol_info (symbol
, ret
);
2531 if (ret
->type
== '?')
2533 int type_code
= aout_symbol (symbol
)->type
& 0xff;
2534 const char *stab_name
= bfd_get_stab_name (type_code
);
2535 static char buf
[10];
2537 if (stab_name
== NULL
)
2539 sprintf (buf
, "(%d)", type_code
);
2543 ret
->stab_type
= type_code
;
2544 ret
->stab_other
= (unsigned) (aout_symbol (symbol
)->other
& 0xff);
2545 ret
->stab_desc
= (unsigned) (aout_symbol (symbol
)->desc
& 0xffff);
2546 ret
->stab_name
= stab_name
;
2551 NAME (aout
, print_symbol
) (bfd
*abfd
,
2554 bfd_print_symbol_type how
)
2556 FILE *file
= (FILE *)afile
;
2560 case bfd_print_symbol_name
:
2562 fprintf (file
,"%s", symbol
->name
);
2564 case bfd_print_symbol_more
:
2565 fprintf (file
,"%4x %2x %2x",
2566 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2567 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2568 (unsigned) (aout_symbol (symbol
)->type
));
2570 case bfd_print_symbol_all
:
2572 const char *section_name
= symbol
->section
->name
;
2574 bfd_print_symbol_vandf (abfd
, (void *)file
, symbol
);
2576 fprintf (file
," %-5s %04x %02x %02x",
2578 (unsigned) (aout_symbol (symbol
)->desc
& 0xffff),
2579 (unsigned) (aout_symbol (symbol
)->other
& 0xff),
2580 (unsigned) (aout_symbol (symbol
)->type
& 0xff));
2582 fprintf (file
," %s", symbol
->name
);
2588 /* If we don't have to allocate more than 1MB to hold the generic
2589 symbols, we use the generic minisymbol methord: it's faster, since
2590 it only translates the symbols once, not multiple times. */
2591 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2593 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2594 symbols. The minisymbol_to_symbol function translates these into
2595 BFD asymbol structures. */
2598 NAME (aout
, read_minisymbols
) (bfd
*abfd
,
2599 bfd_boolean dynamic
,
2601 unsigned int *sizep
)
2604 /* We could handle the dynamic symbols here as well, but it's
2605 easier to hand them off. */
2606 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2608 if (! aout_get_external_symbols (abfd
))
2611 if (obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2612 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
2614 *minisymsp
= (void *) obj_aout_external_syms (abfd
);
2616 /* By passing the external symbols back from this routine, we are
2617 giving up control over the memory block. Clear
2618 obj_aout_external_syms, so that we do not try to free it
2620 obj_aout_external_syms (abfd
) = NULL
;
2622 *sizep
= EXTERNAL_NLIST_SIZE
;
2623 return obj_aout_external_sym_count (abfd
);
2626 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2627 unmodified a.out symbol. The SYM argument is a structure returned
2628 by bfd_make_empty_symbol, which we fill in here. */
2631 NAME (aout
, minisymbol_to_symbol
) (bfd
*abfd
,
2632 bfd_boolean dynamic
,
2633 const void * minisym
,
2637 || obj_aout_external_sym_count (abfd
) < MINISYM_THRESHOLD
)
2638 return _bfd_generic_minisymbol_to_symbol (abfd
, dynamic
, minisym
, sym
);
2640 memset (sym
, 0, sizeof (aout_symbol_type
));
2642 /* We call translate_symbol_table to translate a single symbol. */
2643 if (! (NAME (aout
, translate_symbol_table
)
2645 (aout_symbol_type
*) sym
,
2646 (struct external_nlist
*) minisym
,
2648 obj_aout_external_strings (abfd
),
2649 obj_aout_external_string_size (abfd
),
2656 /* Provided a BFD, a section and an offset into the section, calculate
2657 and return the name of the source file and the line nearest to the
2661 NAME (aout
, find_nearest_line
) (bfd
*abfd
,
2665 const char **filename_ptr
,
2666 const char **functionname_ptr
,
2667 unsigned int *line_ptr
,
2668 unsigned int *disriminator_ptr
)
2670 /* Run down the file looking for the filename, function and linenumber. */
2672 const char *directory_name
= NULL
;
2673 const char *main_file_name
= NULL
;
2674 const char *current_file_name
= NULL
;
2675 const char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
2676 const char *line_directory_name
= NULL
; /* Value of directory_name at line number. */
2677 bfd_vma low_line_vma
= 0;
2678 bfd_vma low_func_vma
= 0;
2680 bfd_size_type filelen
, funclen
;
2683 *filename_ptr
= abfd
->filename
;
2684 *functionname_ptr
= NULL
;
2686 if (disriminator_ptr
)
2687 *disriminator_ptr
= 0;
2689 if (symbols
!= NULL
)
2691 for (p
= symbols
; *p
; p
++)
2693 aout_symbol_type
*q
= (aout_symbol_type
*) (*p
);
2698 /* If this looks like a file name symbol, and it comes after
2699 the line number we have found so far, but before the
2700 offset, then we have probably not found the right line
2702 if (q
->symbol
.value
<= offset
2703 && ((q
->symbol
.value
> low_line_vma
2704 && (line_file_name
!= NULL
2706 || (q
->symbol
.value
> low_func_vma
2709 const char *symname
;
2711 symname
= q
->symbol
.name
;
2714 && strlen (symname
) > 2
2715 && strcmp (symname
+ strlen (symname
) - 2, ".o") == 0)
2717 if (q
->symbol
.value
> low_line_vma
)
2720 line_file_name
= NULL
;
2722 if (q
->symbol
.value
> low_func_vma
)
2729 /* If this symbol is less than the offset, but greater than
2730 the line number we have found so far, then we have not
2731 found the right line number. */
2732 if (q
->symbol
.value
<= offset
)
2734 if (q
->symbol
.value
> low_line_vma
)
2737 line_file_name
= NULL
;
2739 if (q
->symbol
.value
> low_func_vma
)
2743 main_file_name
= current_file_name
= q
->symbol
.name
;
2744 /* Look ahead to next symbol to check if that too is an N_SO. */
2748 q
= (aout_symbol_type
*) (*p
);
2749 if (q
->type
!= (int)N_SO
)
2752 /* Found a second N_SO First is directory; second is filename. */
2753 directory_name
= current_file_name
;
2754 main_file_name
= current_file_name
= q
->symbol
.name
;
2755 if (obj_textsec (abfd
) != section
)
2759 current_file_name
= q
->symbol
.name
;
2766 /* We'll keep this if it resolves nearer than the one we have
2768 if (q
->symbol
.value
>= low_line_vma
2769 && q
->symbol
.value
<= offset
)
2771 *line_ptr
= q
->desc
;
2772 low_line_vma
= q
->symbol
.value
;
2773 line_file_name
= current_file_name
;
2774 line_directory_name
= directory_name
;
2779 /* We'll keep this if it is nearer than the one we have already. */
2780 if (q
->symbol
.value
>= low_func_vma
2781 && q
->symbol
.value
<= offset
)
2783 low_func_vma
= q
->symbol
.value
;
2784 func
= (asymbol
*)q
;
2786 else if (q
->symbol
.value
> offset
)
2797 main_file_name
= line_file_name
;
2798 directory_name
= line_directory_name
;
2801 if (main_file_name
== NULL
2802 || IS_ABSOLUTE_PATH (main_file_name
)
2803 || directory_name
== NULL
)
2806 filelen
= strlen (directory_name
) + strlen (main_file_name
);
2811 funclen
= strlen (bfd_asymbol_name (func
));
2813 if (adata (abfd
).line_buf
!= NULL
)
2814 free (adata (abfd
).line_buf
);
2816 if (filelen
+ funclen
== 0)
2817 adata (abfd
).line_buf
= buf
= NULL
;
2820 buf
= (char *) bfd_malloc (filelen
+ funclen
+ 3);
2821 adata (abfd
).line_buf
= buf
;
2826 if (main_file_name
!= NULL
)
2828 if (IS_ABSOLUTE_PATH (main_file_name
) || directory_name
== NULL
)
2829 *filename_ptr
= main_file_name
;
2833 /* PR binutils/20891: In a corrupt input file both
2834 main_file_name and directory_name can be empty... */
2835 * filename_ptr
= NULL
;
2838 snprintf (buf
, filelen
+ 1, "%s%s", directory_name
,
2840 *filename_ptr
= buf
;
2848 const char *function
= func
->name
;
2853 /* PR binutils/20892: In a corrupt input file func can be empty. */
2854 * functionname_ptr
= NULL
;
2857 /* The caller expects a symbol name. We actually have a
2858 function name, without the leading underscore. Put the
2859 underscore back in, so that the caller gets a symbol name. */
2860 if (bfd_get_symbol_leading_char (abfd
) == '\0')
2861 strcpy (buf
, function
);
2864 buf
[0] = bfd_get_symbol_leading_char (abfd
);
2865 strcpy (buf
+ 1, function
);
2867 /* Have to remove : stuff. */
2868 colon
= strchr (buf
, ':');
2871 *functionname_ptr
= buf
;
2878 NAME (aout
, sizeof_headers
) (bfd
*abfd
,
2879 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2881 return adata (abfd
).exec_bytes_size
;
2884 /* Free all information we have cached for this BFD. We can always
2885 read it again later if we need it. */
2888 NAME (aout
, bfd_free_cached_info
) (bfd
*abfd
)
2892 if (bfd_get_format (abfd
) != bfd_object
2893 || abfd
->tdata
.aout_data
== NULL
)
2896 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2897 BFCI_FREE (obj_aout_symbols (abfd
));
2899 obj_aout_external_syms (abfd
) = 0;
2900 bfd_free_window (&obj_aout_sym_window (abfd
));
2901 bfd_free_window (&obj_aout_string_window (abfd
));
2902 obj_aout_external_strings (abfd
) = 0;
2904 BFCI_FREE (obj_aout_external_syms (abfd
));
2905 BFCI_FREE (obj_aout_external_strings (abfd
));
2907 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2908 BFCI_FREE (o
->relocation
);
2914 /* a.out link code. */
2916 /* Routine to create an entry in an a.out link hash table. */
2918 struct bfd_hash_entry
*
2919 NAME (aout
, link_hash_newfunc
) (struct bfd_hash_entry
*entry
,
2920 struct bfd_hash_table
*table
,
2923 struct aout_link_hash_entry
*ret
= (struct aout_link_hash_entry
*) entry
;
2925 /* Allocate the structure if it has not already been allocated by a
2928 ret
= (struct aout_link_hash_entry
*) bfd_hash_allocate (table
,
2933 /* Call the allocation method of the superclass. */
2934 ret
= ((struct aout_link_hash_entry
*)
2935 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2939 /* Set local fields. */
2940 ret
->written
= FALSE
;
2944 return (struct bfd_hash_entry
*) ret
;
2947 /* Initialize an a.out link hash table. */
2950 NAME (aout
, link_hash_table_init
) (struct aout_link_hash_table
*table
,
2952 struct bfd_hash_entry
*(*newfunc
)
2953 (struct bfd_hash_entry
*, struct bfd_hash_table
*,
2955 unsigned int entsize
)
2957 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
2960 /* Create an a.out link hash table. */
2962 struct bfd_link_hash_table
*
2963 NAME (aout
, link_hash_table_create
) (bfd
*abfd
)
2965 struct aout_link_hash_table
*ret
;
2966 size_t amt
= sizeof (* ret
);
2968 ret
= (struct aout_link_hash_table
*) bfd_malloc (amt
);
2972 if (!NAME (aout
, link_hash_table_init
) (ret
, abfd
,
2973 NAME (aout
, link_hash_newfunc
),
2974 sizeof (struct aout_link_hash_entry
)))
2982 /* Add all symbols from an object file to the hash table. */
2985 aout_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2987 bfd_boolean (*add_one_symbol
)
2988 (struct bfd_link_info
*, bfd
*, const char *, flagword
, asection
*,
2989 bfd_vma
, const char *, bfd_boolean
, bfd_boolean
,
2990 struct bfd_link_hash_entry
**);
2991 struct external_nlist
*syms
;
2992 bfd_size_type sym_count
;
2995 struct aout_link_hash_entry
**sym_hash
;
2996 struct external_nlist
*p
;
2997 struct external_nlist
*pend
;
3000 syms
= obj_aout_external_syms (abfd
);
3001 sym_count
= obj_aout_external_sym_count (abfd
);
3002 strings
= obj_aout_external_strings (abfd
);
3003 if (info
->keep_memory
)
3008 if (aout_backend_info (abfd
)->add_dynamic_symbols
!= NULL
)
3010 if (! ((*aout_backend_info (abfd
)->add_dynamic_symbols
)
3011 (abfd
, info
, &syms
, &sym_count
, &strings
)))
3016 return TRUE
; /* Nothing to do. */
3018 /* We keep a list of the linker hash table entries that correspond
3019 to particular symbols. We could just look them up in the hash
3020 table, but keeping the list is more efficient. Perhaps this
3021 should be conditional on info->keep_memory. */
3022 amt
= sym_count
* sizeof (struct aout_link_hash_entry
*);
3023 sym_hash
= (struct aout_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3024 if (sym_hash
== NULL
)
3026 obj_aout_sym_hashes (abfd
) = sym_hash
;
3028 add_one_symbol
= aout_backend_info (abfd
)->add_one_symbol
;
3029 if (add_one_symbol
== NULL
)
3030 add_one_symbol
= _bfd_generic_link_add_one_symbol
;
3033 pend
= p
+ sym_count
;
3034 for (; p
< pend
; p
++, sym_hash
++)
3045 type
= H_GET_8 (abfd
, p
->e_type
);
3047 /* Ignore debugging symbols. */
3048 if ((type
& N_STAB
) != 0)
3051 /* PR 19629: Corrupt binaries can contain illegal string offsets. */
3052 if (GET_WORD (abfd
, p
->e_strx
) >= obj_aout_external_string_size (abfd
))
3054 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3055 value
= GET_WORD (abfd
, p
->e_value
);
3072 /* Ignore symbols that are not externally visible. */
3075 /* Ignore local indirect symbol. */
3080 case N_UNDF
| N_EXT
:
3083 section
= bfd_und_section_ptr
;
3087 section
= bfd_com_section_ptr
;
3090 section
= bfd_abs_section_ptr
;
3092 case N_TEXT
| N_EXT
:
3093 section
= obj_textsec (abfd
);
3094 value
-= bfd_section_vma (section
);
3096 case N_DATA
| N_EXT
:
3097 case N_SETV
| N_EXT
:
3098 /* Treat N_SETV symbols as N_DATA symbol; see comment in
3099 translate_from_native_sym_flags. */
3100 section
= obj_datasec (abfd
);
3101 value
-= bfd_section_vma (section
);
3104 section
= obj_bsssec (abfd
);
3105 value
-= bfd_section_vma (section
);
3107 case N_INDR
| N_EXT
:
3108 /* An indirect symbol. The next symbol is the symbol
3109 which this one really is. */
3110 /* See PR 20925 for a reproducer. */
3114 /* PR 19629: Corrupt binaries can contain illegal string offsets. */
3115 if (GET_WORD (abfd
, p
->e_strx
) >= obj_aout_external_string_size (abfd
))
3117 string
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3118 section
= bfd_ind_section_ptr
;
3119 flags
|= BSF_INDIRECT
;
3121 case N_COMM
| N_EXT
:
3122 section
= bfd_com_section_ptr
;
3124 case N_SETA
: case N_SETA
| N_EXT
:
3125 section
= bfd_abs_section_ptr
;
3126 flags
|= BSF_CONSTRUCTOR
;
3128 case N_SETT
: case N_SETT
| N_EXT
:
3129 section
= obj_textsec (abfd
);
3130 flags
|= BSF_CONSTRUCTOR
;
3131 value
-= bfd_section_vma (section
);
3133 case N_SETD
: case N_SETD
| N_EXT
:
3134 section
= obj_datasec (abfd
);
3135 flags
|= BSF_CONSTRUCTOR
;
3136 value
-= bfd_section_vma (section
);
3138 case N_SETB
: case N_SETB
| N_EXT
:
3139 section
= obj_bsssec (abfd
);
3140 flags
|= BSF_CONSTRUCTOR
;
3141 value
-= bfd_section_vma (section
);
3144 /* A warning symbol. The next symbol is the one to warn
3145 about. If there is no next symbol, just look away. */
3150 /* PR 19629: Corrupt binaries can contain illegal string offsets. */
3151 if (GET_WORD (abfd
, p
->e_strx
) >= obj_aout_external_string_size (abfd
))
3153 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3154 section
= bfd_und_section_ptr
;
3155 flags
|= BSF_WARNING
;
3158 section
= bfd_und_section_ptr
;
3162 section
= bfd_abs_section_ptr
;
3166 section
= obj_textsec (abfd
);
3167 value
-= bfd_section_vma (section
);
3171 section
= obj_datasec (abfd
);
3172 value
-= bfd_section_vma (section
);
3176 section
= obj_bsssec (abfd
);
3177 value
-= bfd_section_vma (section
);
3182 if (! ((*add_one_symbol
)
3183 (info
, abfd
, name
, flags
, section
, value
, string
, copy
, FALSE
,
3184 (struct bfd_link_hash_entry
**) sym_hash
)))
3187 /* Restrict the maximum alignment of a common symbol based on
3188 the architecture, since a.out has no way to represent
3189 alignment requirements of a section in a .o file. FIXME:
3190 This isn't quite right: it should use the architecture of the
3191 output file, not the input files. */
3192 if ((*sym_hash
)->root
.type
== bfd_link_hash_common
3193 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
>
3194 bfd_get_arch_info (abfd
)->section_align_power
))
3195 (*sym_hash
)->root
.u
.c
.p
->alignment_power
=
3196 bfd_get_arch_info (abfd
)->section_align_power
;
3198 /* If this is a set symbol, and we are not building sets, then
3199 it is possible for the hash entry to not have been set. In
3200 such a case, treat the symbol as not globally defined. */
3201 if ((*sym_hash
)->root
.type
== bfd_link_hash_new
)
3203 BFD_ASSERT ((flags
& BSF_CONSTRUCTOR
) != 0);
3207 if (type
== (N_INDR
| N_EXT
) || type
== N_WARNING
)
3214 /* Free up the internal symbols read from an a.out file. */
3217 aout_link_free_symbols (bfd
*abfd
)
3219 if (obj_aout_external_syms (abfd
) != NULL
)
3222 bfd_free_window (&obj_aout_sym_window (abfd
));
3224 free ((void *) obj_aout_external_syms (abfd
));
3226 obj_aout_external_syms (abfd
) = NULL
;
3228 if (obj_aout_external_strings (abfd
) != NULL
)
3231 bfd_free_window (&obj_aout_string_window (abfd
));
3233 free ((void *) obj_aout_external_strings (abfd
));
3235 obj_aout_external_strings (abfd
) = NULL
;
3240 /* Add symbols from an a.out object file. */
3243 aout_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3245 if (! aout_get_external_symbols (abfd
))
3247 if (! aout_link_add_symbols (abfd
, info
))
3249 if (! info
->keep_memory
)
3251 if (! aout_link_free_symbols (abfd
))
3257 /* Look through the internal symbols to see if this object file should
3258 be included in the link. We should include this object file if it
3259 defines any symbols which are currently undefined. If this object
3260 file defines a common symbol, then we may adjust the size of the
3261 known symbol but we do not include the object file in the link
3262 (unless there is some other reason to include it). */
3265 aout_link_check_ar_symbols (bfd
*abfd
,
3266 struct bfd_link_info
*info
,
3267 bfd_boolean
*pneeded
,
3270 struct external_nlist
*p
;
3271 struct external_nlist
*pend
;
3276 /* Look through all the symbols. */
3277 p
= obj_aout_external_syms (abfd
);
3278 pend
= p
+ obj_aout_external_sym_count (abfd
);
3279 strings
= obj_aout_external_strings (abfd
);
3280 for (; p
< pend
; p
++)
3282 int type
= H_GET_8 (abfd
, p
->e_type
);
3284 struct bfd_link_hash_entry
*h
;
3286 /* Ignore symbols that are not externally visible. This is an
3287 optimization only, as we check the type more thoroughly
3289 if (((type
& N_EXT
) == 0
3290 || (type
& N_STAB
) != 0
3297 if (type
== N_WARNING
3303 name
= strings
+ GET_WORD (abfd
, p
->e_strx
);
3304 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
3306 /* We are only interested in symbols that are currently
3307 undefined or common. */
3309 || (h
->type
!= bfd_link_hash_undefined
3310 && h
->type
!= bfd_link_hash_common
))
3312 if (type
== (N_INDR
| N_EXT
))
3317 if (type
== (N_TEXT
| N_EXT
)
3318 || type
== (N_DATA
| N_EXT
)
3319 || type
== (N_BSS
| N_EXT
)
3320 || type
== (N_ABS
| N_EXT
)
3321 || type
== (N_INDR
| N_EXT
))
3323 /* This object file defines this symbol. We must link it
3324 in. This is true regardless of whether the current
3325 definition of the symbol is undefined or common.
3327 If the current definition is common, we have a case in
3328 which we have already seen an object file including:
3330 and this object file from the archive includes:
3332 In such a case, whether to include this object is target
3333 dependant for backward compatibility.
3335 FIXME: The SunOS 4.1.3 linker will pull in the archive
3336 element if the symbol is defined in the .data section,
3337 but not if it is defined in the .text section. That
3338 seems a bit crazy to me, and it has not been implemented
3339 yet. However, it might be correct. */
3340 if (h
->type
== bfd_link_hash_common
)
3344 switch (info
->common_skip_ar_symbols
)
3346 case bfd_link_common_skip_none
:
3348 case bfd_link_common_skip_text
:
3349 skip
= (type
== (N_TEXT
| N_EXT
));
3351 case bfd_link_common_skip_data
:
3352 skip
= (type
== (N_DATA
| N_EXT
));
3354 case bfd_link_common_skip_all
:
3363 if (!(*info
->callbacks
3364 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
3370 if (type
== (N_UNDF
| N_EXT
))
3374 value
= GET_WORD (abfd
, p
->e_value
);
3377 /* This symbol is common in the object from the archive
3379 if (h
->type
== bfd_link_hash_undefined
)
3384 symbfd
= h
->u
.undef
.abfd
;
3387 /* This symbol was created as undefined from
3388 outside BFD. We assume that we should link
3389 in the object file. This is done for the -u
3390 option in the linker. */
3391 if (!(*info
->callbacks
3392 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
3397 /* Turn the current link symbol into a common
3398 symbol. It is already on the undefs list. */
3399 h
->type
= bfd_link_hash_common
;
3400 h
->u
.c
.p
= (struct bfd_link_hash_common_entry
*)
3401 bfd_hash_allocate (&info
->hash
->table
,
3402 sizeof (struct bfd_link_hash_common_entry
));
3403 if (h
->u
.c
.p
== NULL
)
3406 h
->u
.c
.size
= value
;
3408 /* FIXME: This isn't quite right. The maximum
3409 alignment of a common symbol should be set by the
3410 architecture of the output file, not of the input
3412 power
= bfd_log2 (value
);
3413 if (power
> bfd_get_arch_info (abfd
)->section_align_power
)
3414 power
= bfd_get_arch_info (abfd
)->section_align_power
;
3415 h
->u
.c
.p
->alignment_power
= power
;
3417 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
,
3422 /* Adjust the size of the common symbol if
3424 if (value
> h
->u
.c
.size
)
3425 h
->u
.c
.size
= value
;
3435 /* This symbol is weak but defined. We must pull it in if
3436 the current link symbol is undefined, but we don't want
3437 it if the current link symbol is common. */
3438 if (h
->type
== bfd_link_hash_undefined
)
3440 if (!(*info
->callbacks
3441 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
3449 /* We do not need this object file. */
3452 /* Check a single archive element to see if we need to include it in
3453 the link. *PNEEDED is set according to whether this element is
3454 needed in the link or not. This is called from
3455 _bfd_generic_link_add_archive_symbols. */
3458 aout_link_check_archive_element (bfd
*abfd
,
3459 struct bfd_link_info
*info
,
3460 struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
3461 const char *name ATTRIBUTE_UNUSED
,
3462 bfd_boolean
*pneeded
)
3467 if (!aout_get_external_symbols (abfd
))
3471 if (!aout_link_check_ar_symbols (abfd
, info
, pneeded
, &abfd
))
3477 /* Potentially, the add_archive_element hook may have set a
3478 substitute BFD for us. */
3481 if (!info
->keep_memory
3482 && !aout_link_free_symbols (oldbfd
))
3484 if (!aout_get_external_symbols (abfd
))
3487 if (!aout_link_add_symbols (abfd
, info
))
3491 if (!info
->keep_memory
|| !needed
)
3493 if (!aout_link_free_symbols (abfd
))
3500 /* Given an a.out BFD, add symbols to the global hash table as
3504 NAME (aout
, link_add_symbols
) (bfd
*abfd
, struct bfd_link_info
*info
)
3506 switch (bfd_get_format (abfd
))
3509 return aout_link_add_object_symbols (abfd
, info
);
3511 return _bfd_generic_link_add_archive_symbols
3512 (abfd
, info
, aout_link_check_archive_element
);
3514 bfd_set_error (bfd_error_wrong_format
);
3519 /* A hash table used for header files with N_BINCL entries. */
3521 struct aout_link_includes_table
3523 struct bfd_hash_table root
;
3526 /* A linked list of totals that we have found for a particular header
3529 struct aout_link_includes_totals
3531 struct aout_link_includes_totals
*next
;
3535 /* An entry in the header file hash table. */
3537 struct aout_link_includes_entry
3539 struct bfd_hash_entry root
;
3540 /* List of totals we have found for this file. */
3541 struct aout_link_includes_totals
*totals
;
3544 /* Look up an entry in an the header file hash table. */
3546 #define aout_link_includes_lookup(table, string, create, copy) \
3547 ((struct aout_link_includes_entry *) \
3548 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3550 /* During the final link step we need to pass around a bunch of
3551 information, so we do it in an instance of this structure. */
3553 struct aout_final_link_info
3555 /* General link information. */
3556 struct bfd_link_info
*info
;
3559 /* Reloc file positions. */
3560 file_ptr treloff
, dreloff
;
3561 /* File position of symbols. */
3564 struct bfd_strtab_hash
*strtab
;
3565 /* Header file hash table. */
3566 struct aout_link_includes_table includes
;
3567 /* A buffer large enough to hold the contents of any section. */
3569 /* A buffer large enough to hold the relocs of any section. */
3571 /* A buffer large enough to hold the symbol map of any input BFD. */
3573 /* A buffer large enough to hold output symbols of any input BFD. */
3574 struct external_nlist
*output_syms
;
3577 /* The function to create a new entry in the header file hash table. */
3579 static struct bfd_hash_entry
*
3580 aout_link_includes_newfunc (struct bfd_hash_entry
*entry
,
3581 struct bfd_hash_table
*table
,
3584 struct aout_link_includes_entry
*ret
=
3585 (struct aout_link_includes_entry
*) entry
;
3587 /* Allocate the structure if it has not already been allocated by a
3590 ret
= (struct aout_link_includes_entry
*)
3591 bfd_hash_allocate (table
, sizeof (* ret
));
3595 /* Call the allocation method of the superclass. */
3596 ret
= ((struct aout_link_includes_entry
*)
3597 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
3600 /* Set local fields. */
3604 return (struct bfd_hash_entry
*) ret
;
3607 /* Write out a symbol that was not associated with an a.out input
3611 aout_link_write_other_symbol (struct bfd_hash_entry
*bh
, void *data
)
3613 struct aout_link_hash_entry
*h
= (struct aout_link_hash_entry
*) bh
;
3614 struct aout_final_link_info
*flaginfo
= (struct aout_final_link_info
*) data
;
3618 struct external_nlist outsym
;
3622 if (h
->root
.type
== bfd_link_hash_warning
)
3624 h
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
3625 if (h
->root
.type
== bfd_link_hash_new
)
3629 output_bfd
= flaginfo
->output_bfd
;
3631 if (aout_backend_info (output_bfd
)->write_dynamic_symbol
!= NULL
)
3633 if (! ((*aout_backend_info (output_bfd
)->write_dynamic_symbol
)
3634 (output_bfd
, flaginfo
->info
, h
)))
3636 /* FIXME: No way to handle errors. */
3646 /* An indx of -2 means the symbol must be written. */
3648 && (flaginfo
->info
->strip
== strip_all
3649 || (flaginfo
->info
->strip
== strip_some
3650 && bfd_hash_lookup (flaginfo
->info
->keep_hash
, h
->root
.root
.string
,
3651 FALSE
, FALSE
) == NULL
)))
3654 switch (h
->root
.type
)
3657 case bfd_link_hash_warning
:
3659 /* Avoid variable not initialized warnings. */
3661 case bfd_link_hash_new
:
3662 /* This can happen for set symbols when sets are not being
3665 case bfd_link_hash_undefined
:
3666 type
= N_UNDF
| N_EXT
;
3669 case bfd_link_hash_defined
:
3670 case bfd_link_hash_defweak
:
3674 sec
= h
->root
.u
.def
.section
->output_section
;
3675 BFD_ASSERT (bfd_is_abs_section (sec
)
3676 || sec
->owner
== output_bfd
);
3677 if (sec
== obj_textsec (output_bfd
))
3678 type
= h
->root
.type
== bfd_link_hash_defined
? N_TEXT
: N_WEAKT
;
3679 else if (sec
== obj_datasec (output_bfd
))
3680 type
= h
->root
.type
== bfd_link_hash_defined
? N_DATA
: N_WEAKD
;
3681 else if (sec
== obj_bsssec (output_bfd
))
3682 type
= h
->root
.type
== bfd_link_hash_defined
? N_BSS
: N_WEAKB
;
3684 type
= h
->root
.type
== bfd_link_hash_defined
? N_ABS
: N_WEAKA
;
3686 val
= (h
->root
.u
.def
.value
3688 + h
->root
.u
.def
.section
->output_offset
);
3691 case bfd_link_hash_common
:
3692 type
= N_UNDF
| N_EXT
;
3693 val
= h
->root
.u
.c
.size
;
3695 case bfd_link_hash_undefweak
:
3699 case bfd_link_hash_indirect
:
3700 /* We ignore these symbols, since the indirected symbol is
3701 already in the hash table. */
3705 H_PUT_8 (output_bfd
, type
, outsym
.e_type
);
3706 H_PUT_8 (output_bfd
, 0, outsym
.e_other
);
3707 H_PUT_16 (output_bfd
, 0, outsym
.e_desc
);
3708 indx
= add_to_stringtab (output_bfd
, flaginfo
->strtab
, h
->root
.root
.string
,
3710 if (indx
== - (bfd_size_type
) 1)
3711 /* FIXME: No way to handle errors. */
3714 PUT_WORD (output_bfd
, indx
, outsym
.e_strx
);
3715 PUT_WORD (output_bfd
, val
, outsym
.e_value
);
3717 amt
= EXTERNAL_NLIST_SIZE
;
3718 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0
3719 || bfd_bwrite ((void *) &outsym
, amt
, output_bfd
) != amt
)
3720 /* FIXME: No way to handle errors. */
3723 flaginfo
->symoff
+= EXTERNAL_NLIST_SIZE
;
3724 h
->indx
= obj_aout_external_sym_count (output_bfd
);
3725 ++obj_aout_external_sym_count (output_bfd
);
3730 /* Handle a link order which is supposed to generate a reloc. */
3733 aout_link_reloc_link_order (struct aout_final_link_info
*flaginfo
,
3735 struct bfd_link_order
*p
)
3737 struct bfd_link_order_reloc
*pr
;
3740 reloc_howto_type
*howto
;
3741 file_ptr
*reloff_ptr
= NULL
;
3742 struct reloc_std_external srel
;
3743 struct reloc_ext_external erel
;
3749 if (p
->type
== bfd_section_reloc_link_order
)
3752 if (bfd_is_abs_section (pr
->u
.section
))
3753 r_index
= N_ABS
| N_EXT
;
3756 BFD_ASSERT (pr
->u
.section
->owner
== flaginfo
->output_bfd
);
3757 r_index
= pr
->u
.section
->target_index
;
3762 struct aout_link_hash_entry
*h
;
3764 BFD_ASSERT (p
->type
== bfd_symbol_reloc_link_order
);
3766 h
= ((struct aout_link_hash_entry
*)
3767 bfd_wrapped_link_hash_lookup (flaginfo
->output_bfd
, flaginfo
->info
,
3768 pr
->u
.name
, FALSE
, FALSE
, TRUE
));
3774 /* We decided to strip this symbol, but it turns out that we
3775 can't. Note that we lose the other and desc information
3776 here. I don't think that will ever matter for a global
3780 if (!aout_link_write_other_symbol (&h
->root
.root
, flaginfo
))
3786 (*flaginfo
->info
->callbacks
->unattached_reloc
)
3787 (flaginfo
->info
, pr
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
3792 howto
= bfd_reloc_type_lookup (flaginfo
->output_bfd
, pr
->reloc
);
3795 bfd_set_error (bfd_error_bad_value
);
3799 if (o
== obj_textsec (flaginfo
->output_bfd
))
3800 reloff_ptr
= &flaginfo
->treloff
;
3801 else if (o
== obj_datasec (flaginfo
->output_bfd
))
3802 reloff_ptr
= &flaginfo
->dreloff
;
3806 if (obj_reloc_entry_size (flaginfo
->output_bfd
) == RELOC_STD_SIZE
)
3809 MY_put_reloc (flaginfo
->output_bfd
, r_extern
, r_index
, p
->offset
, howto
,
3819 r_pcrel
= (int) howto
->pc_relative
;
3820 r_baserel
= (howto
->type
& 8) != 0;
3821 r_jmptable
= (howto
->type
& 16) != 0;
3822 r_relative
= (howto
->type
& 32) != 0;
3823 r_length
= howto
->size
;
3825 PUT_WORD (flaginfo
->output_bfd
, p
->offset
, srel
.r_address
);
3826 if (bfd_header_big_endian (flaginfo
->output_bfd
))
3828 srel
.r_index
[0] = r_index
>> 16;
3829 srel
.r_index
[1] = r_index
>> 8;
3830 srel
.r_index
[2] = r_index
;
3832 ((r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
3833 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
3834 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
3835 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
3836 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
3837 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
3841 srel
.r_index
[2] = r_index
>> 16;
3842 srel
.r_index
[1] = r_index
>> 8;
3843 srel
.r_index
[0] = r_index
;
3845 ((r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
3846 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
3847 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
3848 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
3849 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
3850 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
3854 rel_ptr
= (void *) &srel
;
3856 /* We have to write the addend into the object file, since
3857 standard a.out relocs are in place. It would be more
3858 reliable if we had the current contents of the file here,
3859 rather than assuming zeroes, but we can't read the file since
3860 it was opened using bfd_openw. */
3861 if (pr
->addend
!= 0)
3864 bfd_reloc_status_type r
;
3868 size
= bfd_get_reloc_size (howto
);
3869 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3870 if (buf
== NULL
&& size
!= 0)
3872 r
= MY_relocate_contents (howto
, flaginfo
->output_bfd
,
3873 (bfd_vma
) pr
->addend
, buf
);
3879 case bfd_reloc_outofrange
:
3881 case bfd_reloc_overflow
:
3882 (*flaginfo
->info
->callbacks
->reloc_overflow
)
3883 (flaginfo
->info
, NULL
,
3884 (p
->type
== bfd_section_reloc_link_order
3885 ? bfd_section_name (pr
->u
.section
)
3887 howto
->name
, pr
->addend
, NULL
, NULL
, (bfd_vma
) 0);
3890 ok
= bfd_set_section_contents (flaginfo
->output_bfd
, o
, (void *) buf
,
3891 (file_ptr
) p
->offset
, size
);
3899 #ifdef MY_put_ext_reloc
3900 MY_put_ext_reloc (flaginfo
->output_bfd
, r_extern
, r_index
, p
->offset
,
3901 howto
, &erel
, pr
->addend
);
3903 PUT_WORD (flaginfo
->output_bfd
, p
->offset
, erel
.r_address
);
3905 if (bfd_header_big_endian (flaginfo
->output_bfd
))
3907 erel
.r_index
[0] = r_index
>> 16;
3908 erel
.r_index
[1] = r_index
>> 8;
3909 erel
.r_index
[2] = r_index
;
3911 ((r_extern
? RELOC_EXT_BITS_EXTERN_BIG
: 0)
3912 | (howto
->type
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
3916 erel
.r_index
[2] = r_index
>> 16;
3917 erel
.r_index
[1] = r_index
>> 8;
3918 erel
.r_index
[0] = r_index
;
3920 (r_extern
? RELOC_EXT_BITS_EXTERN_LITTLE
: 0)
3921 | (howto
->type
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
);
3924 PUT_WORD (flaginfo
->output_bfd
, (bfd_vma
) pr
->addend
, erel
.r_addend
);
3925 #endif /* MY_put_ext_reloc */
3927 rel_ptr
= (void *) &erel
;
3930 amt
= obj_reloc_entry_size (flaginfo
->output_bfd
);
3931 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0
3932 || bfd_bwrite (rel_ptr
, amt
, flaginfo
->output_bfd
) != amt
)
3935 *reloff_ptr
+= obj_reloc_entry_size (flaginfo
->output_bfd
);
3937 /* Assert that the relocs have not run into the symbols, and that n
3938 the text relocs have not run into the data relocs. */
3939 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
3940 && (reloff_ptr
!= &flaginfo
->treloff
3942 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
3947 /* Get the section corresponding to a reloc index. */
3949 static INLINE asection
*
3950 aout_reloc_index_to_section (bfd
*abfd
, int indx
)
3952 switch (indx
& N_TYPE
)
3954 case N_TEXT
: return obj_textsec (abfd
);
3955 case N_DATA
: return obj_datasec (abfd
);
3956 case N_BSS
: return obj_bsssec (abfd
);
3958 case N_UNDF
: return bfd_abs_section_ptr
;
3964 /* Relocate an a.out section using standard a.out relocs. */
3967 aout_link_input_section_std (struct aout_final_link_info
*flaginfo
,
3969 asection
*input_section
,
3970 struct reloc_std_external
*relocs
,
3971 bfd_size_type rel_size
,
3974 bfd_boolean (*check_dynamic_reloc
)
3975 (struct bfd_link_info
*, bfd
*, asection
*,
3976 struct aout_link_hash_entry
*, void *, bfd_byte
*, bfd_boolean
*,
3979 bfd_boolean relocatable
;
3980 struct external_nlist
*syms
;
3982 struct aout_link_hash_entry
**sym_hashes
;
3984 bfd_size_type reloc_count
;
3985 struct reloc_std_external
*rel
;
3986 struct reloc_std_external
*rel_end
;
3988 output_bfd
= flaginfo
->output_bfd
;
3989 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
3991 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
);
3992 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
3993 == output_bfd
->xvec
->header_byteorder
);
3995 relocatable
= bfd_link_relocatable (flaginfo
->info
);
3996 syms
= obj_aout_external_syms (input_bfd
);
3997 strings
= obj_aout_external_strings (input_bfd
);
3998 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
3999 symbol_map
= flaginfo
->symbol_map
;
4001 reloc_count
= rel_size
/ RELOC_STD_SIZE
;
4003 rel_end
= rel
+ reloc_count
;
4004 for (; rel
< rel_end
; rel
++)
4011 reloc_howto_type
*howto
;
4012 struct aout_link_hash_entry
*h
= NULL
;
4014 bfd_reloc_status_type r
;
4016 r_addr
= GET_SWORD (input_bfd
, rel
->r_address
);
4018 #ifdef MY_reloc_howto
4019 howto
= MY_reloc_howto (input_bfd
, rel
, r_index
, r_extern
, r_pcrel
);
4025 unsigned int howto_idx
;
4027 if (bfd_header_big_endian (input_bfd
))
4029 r_index
= (((unsigned int) rel
->r_index
[0] << 16)
4030 | ((unsigned int) rel
->r_index
[1] << 8)
4032 r_extern
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
));
4033 r_pcrel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_PCREL_BIG
));
4034 r_baserel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
4035 r_jmptable
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
4036 r_relative
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_RELATIVE_BIG
));
4037 r_length
= ((rel
->r_type
[0] & RELOC_STD_BITS_LENGTH_BIG
)
4038 >> RELOC_STD_BITS_LENGTH_SH_BIG
);
4042 r_index
= (((unsigned int) rel
->r_index
[2] << 16)
4043 | ((unsigned int) rel
->r_index
[1] << 8)
4045 r_extern
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
));
4046 r_pcrel
= (0 != (rel
->r_type
[0] & RELOC_STD_BITS_PCREL_LITTLE
));
4047 r_baserel
= (0 != (rel
->r_type
[0]
4048 & RELOC_STD_BITS_BASEREL_LITTLE
));
4049 r_jmptable
= (0 != (rel
->r_type
[0]
4050 & RELOC_STD_BITS_JMPTABLE_LITTLE
));
4051 r_relative
= (0 != (rel
->r_type
[0]
4052 & RELOC_STD_BITS_RELATIVE_LITTLE
));
4053 r_length
= ((rel
->r_type
[0] & RELOC_STD_BITS_LENGTH_LITTLE
)
4054 >> RELOC_STD_BITS_LENGTH_SH_LITTLE
);
4057 howto_idx
= (r_length
+ 4 * r_pcrel
+ 8 * r_baserel
4058 + 16 * r_jmptable
+ 32 * r_relative
);
4059 if (howto_idx
< TABLE_SIZE (howto_table_std
))
4060 howto
= howto_table_std
+ howto_idx
;
4068 _bfd_error_handler (_("%pB: unsupported relocation type"),
4070 bfd_set_error (bfd_error_bad_value
);
4076 /* We are generating a relocatable output file, and must
4077 modify the reloc accordingly. */
4080 /* If we know the symbol this relocation is against,
4081 convert it into a relocation against a section. This
4082 is what the native linker does. */
4083 h
= sym_hashes
[r_index
];
4085 && (h
->root
.type
== bfd_link_hash_defined
4086 || h
->root
.type
== bfd_link_hash_defweak
))
4088 asection
*output_section
;
4090 /* Change the r_extern value. */
4091 if (bfd_header_big_endian (output_bfd
))
4092 rel
->r_type
[0] &=~ RELOC_STD_BITS_EXTERN_BIG
;
4094 rel
->r_type
[0] &=~ RELOC_STD_BITS_EXTERN_LITTLE
;
4096 /* Compute a new r_index. */
4097 output_section
= h
->root
.u
.def
.section
->output_section
;
4098 if (output_section
== obj_textsec (output_bfd
))
4100 else if (output_section
== obj_datasec (output_bfd
))
4102 else if (output_section
== obj_bsssec (output_bfd
))
4107 /* Add the symbol value and the section VMA to the
4108 addend stored in the contents. */
4109 relocation
= (h
->root
.u
.def
.value
4110 + output_section
->vma
4111 + h
->root
.u
.def
.section
->output_offset
);
4115 /* We must change r_index according to the symbol
4117 r_index
= symbol_map
[r_index
];
4123 /* We decided to strip this symbol, but it
4124 turns out that we can't. Note that we
4125 lose the other and desc information here.
4126 I don't think that will ever matter for a
4132 if (!aout_link_write_other_symbol (&h
->root
.root
,
4142 name
= strings
+ GET_WORD (input_bfd
,
4143 syms
[r_index
].e_strx
);
4144 (*flaginfo
->info
->callbacks
->unattached_reloc
)
4145 (flaginfo
->info
, name
,
4146 input_bfd
, input_section
, r_addr
);
4154 /* Write out the new r_index value. */
4155 if (bfd_header_big_endian (output_bfd
))
4157 rel
->r_index
[0] = r_index
>> 16;
4158 rel
->r_index
[1] = r_index
>> 8;
4159 rel
->r_index
[2] = r_index
;
4163 rel
->r_index
[2] = r_index
>> 16;
4164 rel
->r_index
[1] = r_index
>> 8;
4165 rel
->r_index
[0] = r_index
;
4172 /* This is a relocation against a section. We must
4173 adjust by the amount that the section moved. */
4174 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4175 relocation
= (section
->output_section
->vma
4176 + section
->output_offset
4180 /* Change the address of the relocation. */
4181 PUT_WORD (output_bfd
,
4182 r_addr
+ input_section
->output_offset
,
4185 /* Adjust a PC relative relocation by removing the reference
4186 to the original address in the section and including the
4187 reference to the new address. */
4189 relocation
-= (input_section
->output_section
->vma
4190 + input_section
->output_offset
4191 - input_section
->vma
);
4193 #ifdef MY_relocatable_reloc
4194 MY_relocatable_reloc (howto
, output_bfd
, rel
, relocation
, r_addr
);
4197 if (relocation
== 0)
4200 r
= MY_relocate_contents (howto
,
4201 input_bfd
, relocation
,
4208 /* We are generating an executable, and must do a full
4214 h
= sym_hashes
[r_index
];
4217 && (h
->root
.type
== bfd_link_hash_defined
4218 || h
->root
.type
== bfd_link_hash_defweak
))
4220 relocation
= (h
->root
.u
.def
.value
4221 + h
->root
.u
.def
.section
->output_section
->vma
4222 + h
->root
.u
.def
.section
->output_offset
);
4225 && h
->root
.type
== bfd_link_hash_undefweak
)
4237 section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4238 relocation
= (section
->output_section
->vma
4239 + section
->output_offset
4242 relocation
+= input_section
->vma
;
4245 if (check_dynamic_reloc
!= NULL
)
4249 if (! ((*check_dynamic_reloc
)
4250 (flaginfo
->info
, input_bfd
, input_section
, h
,
4251 (void *) rel
, contents
, &skip
, &relocation
)))
4257 /* Now warn if a global symbol is undefined. We could not
4258 do this earlier, because check_dynamic_reloc might want
4259 to skip this reloc. */
4260 if (hundef
&& ! bfd_link_pic (flaginfo
->info
) && ! r_baserel
)
4265 name
= h
->root
.root
.string
;
4267 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
4268 (*flaginfo
->info
->callbacks
->undefined_symbol
)
4269 (flaginfo
->info
, name
, input_bfd
, input_section
, r_addr
, TRUE
);
4272 r
= MY_final_link_relocate (howto
,
4273 input_bfd
, input_section
,
4274 contents
, r_addr
, relocation
,
4278 if (r
!= bfd_reloc_ok
)
4283 case bfd_reloc_outofrange
:
4285 case bfd_reloc_overflow
:
4292 name
= strings
+ GET_WORD (input_bfd
,
4293 syms
[r_index
].e_strx
);
4298 s
= aout_reloc_index_to_section (input_bfd
, r_index
);
4299 name
= bfd_section_name (s
);
4301 (*flaginfo
->info
->callbacks
->reloc_overflow
)
4302 (flaginfo
->info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4303 (bfd_vma
) 0, input_bfd
, input_section
, r_addr
);
4313 /* Relocate an a.out section using extended a.out relocs. */
4316 aout_link_input_section_ext (struct aout_final_link_info
*flaginfo
,
4318 asection
*input_section
,
4319 struct reloc_ext_external
*relocs
,
4320 bfd_size_type rel_size
,
4323 bfd_boolean (*check_dynamic_reloc
)
4324 (struct bfd_link_info
*, bfd
*, asection
*,
4325 struct aout_link_hash_entry
*, void *, bfd_byte
*, bfd_boolean
*,
4328 bfd_boolean relocatable
;
4329 struct external_nlist
*syms
;
4331 struct aout_link_hash_entry
**sym_hashes
;
4333 bfd_size_type reloc_count
;
4334 struct reloc_ext_external
*rel
;
4335 struct reloc_ext_external
*rel_end
;
4337 output_bfd
= flaginfo
->output_bfd
;
4338 check_dynamic_reloc
= aout_backend_info (output_bfd
)->check_dynamic_reloc
;
4340 BFD_ASSERT (obj_reloc_entry_size (input_bfd
) == RELOC_EXT_SIZE
);
4341 BFD_ASSERT (input_bfd
->xvec
->header_byteorder
4342 == output_bfd
->xvec
->header_byteorder
);
4344 relocatable
= bfd_link_relocatable (flaginfo
->info
);
4345 syms
= obj_aout_external_syms (input_bfd
);
4346 strings
= obj_aout_external_strings (input_bfd
);
4347 sym_hashes
= obj_aout_sym_hashes (input_bfd
);
4348 symbol_map
= flaginfo
->symbol_map
;
4350 reloc_count
= rel_size
/ RELOC_EXT_SIZE
;
4352 rel_end
= rel
+ reloc_count
;
4353 for (; rel
< rel_end
; rel
++)
4358 unsigned int r_type
;
4360 struct aout_link_hash_entry
*h
= NULL
;
4361 asection
*r_section
= NULL
;
4364 r_addr
= GET_SWORD (input_bfd
, rel
->r_address
);
4366 if (bfd_header_big_endian (input_bfd
))
4368 r_index
= (((unsigned int) rel
->r_index
[0] << 16)
4369 | ((unsigned int) rel
->r_index
[1] << 8)
4371 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
4372 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
4373 >> RELOC_EXT_BITS_TYPE_SH_BIG
);
4377 r_index
= (((unsigned int) rel
->r_index
[2] << 16)
4378 | ((unsigned int) rel
->r_index
[1] << 8)
4380 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
4381 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
4382 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
);
4385 r_addend
= GET_SWORD (input_bfd
, rel
->r_addend
);
4387 if (r_type
>= TABLE_SIZE (howto_table_ext
))
4389 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
4391 bfd_set_error (bfd_error_bad_value
);
4397 /* We are generating a relocatable output file, and must
4398 modify the reloc accordingly. */
4400 || r_type
== (unsigned int) RELOC_BASE10
4401 || r_type
== (unsigned int) RELOC_BASE13
4402 || r_type
== (unsigned int) RELOC_BASE22
)
4404 /* If we know the symbol this relocation is against,
4405 convert it into a relocation against a section. This
4406 is what the native linker does. */
4407 if (r_type
== (unsigned int) RELOC_BASE10
4408 || r_type
== (unsigned int) RELOC_BASE13
4409 || r_type
== (unsigned int) RELOC_BASE22
)
4412 h
= sym_hashes
[r_index
];
4414 && (h
->root
.type
== bfd_link_hash_defined
4415 || h
->root
.type
== bfd_link_hash_defweak
))
4417 asection
*output_section
;
4419 /* Change the r_extern value. */
4420 if (bfd_header_big_endian (output_bfd
))
4421 rel
->r_type
[0] &=~ RELOC_EXT_BITS_EXTERN_BIG
;
4423 rel
->r_type
[0] &=~ RELOC_EXT_BITS_EXTERN_LITTLE
;
4425 /* Compute a new r_index. */
4426 output_section
= h
->root
.u
.def
.section
->output_section
;
4427 if (output_section
== obj_textsec (output_bfd
))
4429 else if (output_section
== obj_datasec (output_bfd
))
4431 else if (output_section
== obj_bsssec (output_bfd
))
4436 /* Add the symbol value and the section VMA to the
4438 relocation
= (h
->root
.u
.def
.value
4439 + output_section
->vma
4440 + h
->root
.u
.def
.section
->output_offset
);
4442 /* Now RELOCATION is the VMA of the final
4443 destination. If this is a PC relative reloc,
4444 then ADDEND is the negative of the source VMA.
4445 We want to set ADDEND to the difference between
4446 the destination VMA and the source VMA, which
4447 means we must adjust RELOCATION by the change in
4448 the source VMA. This is done below. */
4452 /* We must change r_index according to the symbol
4454 r_index
= symbol_map
[r_index
];
4460 /* We decided to strip this symbol, but it
4461 turns out that we can't. Note that we
4462 lose the other and desc information here.
4463 I don't think that will ever matter for a
4469 if (!aout_link_write_other_symbol (&h
->root
.root
,
4479 name
= strings
+ GET_WORD (input_bfd
,
4480 syms
[r_index
].e_strx
);
4481 (*flaginfo
->info
->callbacks
->unattached_reloc
)
4482 (flaginfo
->info
, name
,
4483 input_bfd
, input_section
, r_addr
);
4490 /* If this is a PC relative reloc, then the addend
4491 is the negative of the source VMA. We must
4492 adjust it by the change in the source VMA. This
4496 /* Write out the new r_index value. */
4497 if (bfd_header_big_endian (output_bfd
))
4499 rel
->r_index
[0] = r_index
>> 16;
4500 rel
->r_index
[1] = r_index
>> 8;
4501 rel
->r_index
[2] = r_index
;
4505 rel
->r_index
[2] = r_index
>> 16;
4506 rel
->r_index
[1] = r_index
>> 8;
4507 rel
->r_index
[0] = r_index
;
4512 /* This is a relocation against a section. We must
4513 adjust by the amount that the section moved. */
4514 r_section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4515 relocation
= (r_section
->output_section
->vma
4516 + r_section
->output_offset
4519 /* If this is a PC relative reloc, then the addend is
4520 the difference in VMA between the destination and the
4521 source. We have just adjusted for the change in VMA
4522 of the destination, so we must also adjust by the
4523 change in VMA of the source. This is done below. */
4526 /* As described above, we must always adjust a PC relative
4527 reloc by the change in VMA of the source. However, if
4528 pcrel_offset is set, then the addend does not include the
4529 location within the section, in which case we don't need
4530 to adjust anything. */
4531 if (howto_table_ext
[r_type
].pc_relative
4532 && ! howto_table_ext
[r_type
].pcrel_offset
)
4533 relocation
-= (input_section
->output_section
->vma
4534 + input_section
->output_offset
4535 - input_section
->vma
);
4537 /* Change the addend if necessary. */
4538 if (relocation
!= 0)
4539 PUT_WORD (output_bfd
, r_addend
+ relocation
, rel
->r_addend
);
4541 /* Change the address of the relocation. */
4542 PUT_WORD (output_bfd
,
4543 r_addr
+ input_section
->output_offset
,
4549 bfd_reloc_status_type r
;
4551 /* We are generating an executable, and must do a full
4557 h
= sym_hashes
[r_index
];
4560 && (h
->root
.type
== bfd_link_hash_defined
4561 || h
->root
.type
== bfd_link_hash_defweak
))
4563 relocation
= (h
->root
.u
.def
.value
4564 + h
->root
.u
.def
.section
->output_section
->vma
4565 + h
->root
.u
.def
.section
->output_offset
);
4568 && h
->root
.type
== bfd_link_hash_undefweak
)
4576 else if (r_type
== (unsigned int) RELOC_BASE10
4577 || r_type
== (unsigned int) RELOC_BASE13
4578 || r_type
== (unsigned int) RELOC_BASE22
)
4580 struct external_nlist
*sym
;
4583 /* For base relative relocs, r_index is always an index
4584 into the symbol table, even if r_extern is 0. */
4585 sym
= syms
+ r_index
;
4586 type
= H_GET_8 (input_bfd
, sym
->e_type
);
4587 if ((type
& N_TYPE
) == N_TEXT
4589 r_section
= obj_textsec (input_bfd
);
4590 else if ((type
& N_TYPE
) == N_DATA
4592 r_section
= obj_datasec (input_bfd
);
4593 else if ((type
& N_TYPE
) == N_BSS
4595 r_section
= obj_bsssec (input_bfd
);
4596 else if ((type
& N_TYPE
) == N_ABS
4598 r_section
= bfd_abs_section_ptr
;
4601 relocation
= (r_section
->output_section
->vma
4602 + r_section
->output_offset
4603 + (GET_WORD (input_bfd
, sym
->e_value
)
4608 r_section
= aout_reloc_index_to_section (input_bfd
, r_index
);
4610 /* If this is a PC relative reloc, then R_ADDEND is the
4611 difference between the two vmas, or
4612 old_dest_sec + old_dest_off - (old_src_sec + old_src_off)
4614 old_dest_sec == section->vma
4616 old_src_sec == input_section->vma
4618 old_src_off == r_addr
4620 _bfd_final_link_relocate expects RELOCATION +
4621 R_ADDEND to be the VMA of the destination minus
4622 r_addr (the minus r_addr is because this relocation
4623 is not pcrel_offset, which is a bit confusing and
4624 should, perhaps, be changed), or
4627 new_dest_sec == output_section->vma + output_offset
4628 We arrange for this to happen by setting RELOCATION to
4629 new_dest_sec + old_src_sec - old_dest_sec
4631 If this is not a PC relative reloc, then R_ADDEND is
4632 simply the VMA of the destination, so we set
4633 RELOCATION to the change in the destination VMA, or
4634 new_dest_sec - old_dest_sec
4636 relocation
= (r_section
->output_section
->vma
4637 + r_section
->output_offset
4639 if (howto_table_ext
[r_type
].pc_relative
)
4640 relocation
+= input_section
->vma
;
4643 if (check_dynamic_reloc
!= NULL
)
4647 if (! ((*check_dynamic_reloc
)
4648 (flaginfo
->info
, input_bfd
, input_section
, h
,
4649 (void *) rel
, contents
, &skip
, &relocation
)))
4655 /* Now warn if a global symbol is undefined. We could not
4656 do this earlier, because check_dynamic_reloc might want
4657 to skip this reloc. */
4659 && ! bfd_link_pic (flaginfo
->info
)
4660 && r_type
!= (unsigned int) RELOC_BASE10
4661 && r_type
!= (unsigned int) RELOC_BASE13
4662 && r_type
!= (unsigned int) RELOC_BASE22
)
4667 name
= h
->root
.root
.string
;
4669 name
= strings
+ GET_WORD (input_bfd
, syms
[r_index
].e_strx
);
4670 (*flaginfo
->info
->callbacks
->undefined_symbol
)
4671 (flaginfo
->info
, name
, input_bfd
, input_section
, r_addr
, TRUE
);
4674 if (r_type
!= (unsigned int) RELOC_SPARC_REV32
)
4675 r
= MY_final_link_relocate (howto_table_ext
+ r_type
,
4676 input_bfd
, input_section
,
4677 contents
, r_addr
, relocation
,
4683 x
= bfd_get_32 (input_bfd
, contents
+ r_addr
);
4684 x
= x
+ relocation
+ r_addend
;
4685 bfd_putl32 (/*input_bfd,*/ x
, contents
+ r_addr
);
4689 if (r
!= bfd_reloc_ok
)
4694 case bfd_reloc_outofrange
:
4696 case bfd_reloc_overflow
:
4703 || r_type
== (unsigned int) RELOC_BASE10
4704 || r_type
== (unsigned int) RELOC_BASE13
4705 || r_type
== (unsigned int) RELOC_BASE22
)
4706 name
= strings
+ GET_WORD (input_bfd
,
4707 syms
[r_index
].e_strx
);
4712 s
= aout_reloc_index_to_section (input_bfd
, r_index
);
4713 name
= bfd_section_name (s
);
4715 (*flaginfo
->info
->callbacks
->reloc_overflow
)
4716 (flaginfo
->info
, (h
? &h
->root
: NULL
), name
,
4717 howto_table_ext
[r_type
].name
,
4718 r_addend
, input_bfd
, input_section
, r_addr
);
4729 /* Link an a.out section into the output file. */
4732 aout_link_input_section (struct aout_final_link_info
*flaginfo
,
4734 asection
*input_section
,
4735 file_ptr
*reloff_ptr
,
4736 bfd_size_type rel_size
)
4738 bfd_size_type input_size
;
4741 /* Get the section contents. */
4742 input_size
= input_section
->size
;
4743 if (! bfd_get_section_contents (input_bfd
, input_section
,
4744 (void *) flaginfo
->contents
,
4745 (file_ptr
) 0, input_size
))
4748 /* Read in the relocs if we haven't already done it. */
4749 if (aout_section_data (input_section
) != NULL
4750 && aout_section_data (input_section
)->relocs
!= NULL
)
4751 relocs
= aout_section_data (input_section
)->relocs
;
4754 relocs
= flaginfo
->relocs
;
4757 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
4758 || bfd_bread (relocs
, rel_size
, input_bfd
) != rel_size
)
4763 /* Relocate the section contents. */
4764 if (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
)
4766 if (! aout_link_input_section_std (flaginfo
, input_bfd
, input_section
,
4767 (struct reloc_std_external
*) relocs
,
4768 rel_size
, flaginfo
->contents
))
4773 if (! aout_link_input_section_ext (flaginfo
, input_bfd
, input_section
,
4774 (struct reloc_ext_external
*) relocs
,
4775 rel_size
, flaginfo
->contents
))
4779 /* Write out the section contents. */
4780 if (! bfd_set_section_contents (flaginfo
->output_bfd
,
4781 input_section
->output_section
,
4782 (void *) flaginfo
->contents
,
4783 (file_ptr
) input_section
->output_offset
,
4787 /* If we are producing relocatable output, the relocs were
4788 modified, and we now write them out. */
4789 if (bfd_link_relocatable (flaginfo
->info
) && rel_size
> 0)
4791 if (bfd_seek (flaginfo
->output_bfd
, *reloff_ptr
, SEEK_SET
) != 0)
4793 if (bfd_bwrite (relocs
, rel_size
, flaginfo
->output_bfd
) != rel_size
)
4795 *reloff_ptr
+= rel_size
;
4797 /* Assert that the relocs have not run into the symbols, and
4798 that if these are the text relocs they have not run into the
4800 BFD_ASSERT (*reloff_ptr
<= obj_sym_filepos (flaginfo
->output_bfd
)
4801 && (reloff_ptr
!= &flaginfo
->treloff
4803 <= obj_datasec (flaginfo
->output_bfd
)->rel_filepos
)));
4809 /* Adjust and write out the symbols for an a.out file. Set the new
4810 symbol indices into a symbol_map. */
4813 aout_link_write_symbols (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
4816 bfd_size_type sym_count
;
4818 enum bfd_link_strip strip
;
4819 enum bfd_link_discard discard
;
4820 struct external_nlist
*outsym
;
4821 bfd_size_type strtab_index
;
4822 struct external_nlist
*sym
;
4823 struct external_nlist
*sym_end
;
4824 struct aout_link_hash_entry
**sym_hash
;
4827 bfd_boolean skip_next
;
4829 output_bfd
= flaginfo
->output_bfd
;
4830 sym_count
= obj_aout_external_sym_count (input_bfd
);
4831 strings
= obj_aout_external_strings (input_bfd
);
4832 strip
= flaginfo
->info
->strip
;
4833 discard
= flaginfo
->info
->discard
;
4834 outsym
= flaginfo
->output_syms
;
4836 /* First write out a symbol for this object file, unless we are
4837 discarding such symbols. */
4838 if (strip
!= strip_all
4839 && (strip
!= strip_some
4840 || bfd_hash_lookup (flaginfo
->info
->keep_hash
, input_bfd
->filename
,
4841 FALSE
, FALSE
) != NULL
)
4842 && discard
!= discard_all
)
4844 H_PUT_8 (output_bfd
, N_TEXT
, outsym
->e_type
);
4845 H_PUT_8 (output_bfd
, 0, outsym
->e_other
);
4846 H_PUT_16 (output_bfd
, 0, outsym
->e_desc
);
4847 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
4848 input_bfd
->filename
, FALSE
);
4849 if (strtab_index
== (bfd_size_type
) -1)
4851 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
4852 PUT_WORD (output_bfd
,
4853 (bfd_section_vma (obj_textsec (input_bfd
)->output_section
)
4854 + obj_textsec (input_bfd
)->output_offset
),
4856 ++obj_aout_external_sym_count (output_bfd
);
4862 sym
= obj_aout_external_syms (input_bfd
);
4863 sym_end
= sym
+ sym_count
;
4864 sym_hash
= obj_aout_sym_hashes (input_bfd
);
4865 symbol_map
= flaginfo
->symbol_map
;
4866 memset (symbol_map
, 0, (size_t) sym_count
* sizeof *symbol_map
);
4867 for (; sym
< sym_end
; sym
++, sym_hash
++, symbol_map
++)
4871 struct aout_link_hash_entry
*h
;
4877 /* We set *symbol_map to 0 above for all symbols. If it has
4878 already been set to -1 for this symbol, it means that we are
4879 discarding it because it appears in a duplicate header file.
4880 See the N_BINCL code below. */
4881 if (*symbol_map
== -1)
4884 /* Initialize *symbol_map to -1, which means that the symbol was
4885 not copied into the output file. We will change it later if
4886 we do copy the symbol over. */
4889 type
= H_GET_8 (input_bfd
, sym
->e_type
);
4890 name
= strings
+ GET_WORD (input_bfd
, sym
->e_strx
);
4896 /* Pass this symbol through. It is the target of an
4897 indirect or warning symbol. */
4898 val
= GET_WORD (input_bfd
, sym
->e_value
);
4903 /* Skip this symbol, which is the target of an indirect
4904 symbol that we have changed to no longer be an indirect
4911 struct aout_link_hash_entry
*hresolve
;
4913 /* We have saved the hash table entry for this symbol, if
4914 there is one. Note that we could just look it up again
4915 in the hash table, provided we first check that it is an
4919 /* Use the name from the hash table, in case the symbol was
4922 && h
->root
.type
!= bfd_link_hash_warning
)
4923 name
= h
->root
.root
.string
;
4925 /* If this is an indirect or warning symbol, then change
4926 hresolve to the base symbol. We also change *sym_hash so
4927 that the relocation routines relocate against the real
4930 if (h
!= (struct aout_link_hash_entry
*) NULL
4931 && (h
->root
.type
== bfd_link_hash_indirect
4932 || h
->root
.type
== bfd_link_hash_warning
))
4934 hresolve
= (struct aout_link_hash_entry
*) h
->root
.u
.i
.link
;
4935 while (hresolve
->root
.type
== bfd_link_hash_indirect
4936 || hresolve
->root
.type
== bfd_link_hash_warning
)
4937 hresolve
= ((struct aout_link_hash_entry
*)
4938 hresolve
->root
.u
.i
.link
);
4939 *sym_hash
= hresolve
;
4942 /* If the symbol has already been written out, skip it. */
4946 if ((type
& N_TYPE
) == N_INDR
4947 || type
== N_WARNING
)
4949 *symbol_map
= h
->indx
;
4953 /* See if we are stripping this symbol. */
4959 case strip_debugger
:
4960 if ((type
& N_STAB
) != 0)
4964 if (bfd_hash_lookup (flaginfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
4979 /* Get the value of the symbol. */
4980 if ((type
& N_TYPE
) == N_TEXT
4982 symsec
= obj_textsec (input_bfd
);
4983 else if ((type
& N_TYPE
) == N_DATA
4985 symsec
= obj_datasec (input_bfd
);
4986 else if ((type
& N_TYPE
) == N_BSS
4988 symsec
= obj_bsssec (input_bfd
);
4989 else if ((type
& N_TYPE
) == N_ABS
4991 symsec
= bfd_abs_section_ptr
;
4992 else if (((type
& N_TYPE
) == N_INDR
4993 && (hresolve
== NULL
4994 || (hresolve
->root
.type
!= bfd_link_hash_defined
4995 && hresolve
->root
.type
!= bfd_link_hash_defweak
4996 && hresolve
->root
.type
!= bfd_link_hash_common
)))
4997 || type
== N_WARNING
)
4999 /* Pass the next symbol through unchanged. The
5000 condition above for indirect symbols is so that if
5001 the indirect symbol was defined, we output it with
5002 the correct definition so the debugger will
5005 val
= GET_WORD (input_bfd
, sym
->e_value
);
5008 else if ((type
& N_STAB
) != 0)
5010 val
= GET_WORD (input_bfd
, sym
->e_value
);
5015 /* If we get here with an indirect symbol, it means that
5016 we are outputting it with a real definition. In such
5017 a case we do not want to output the next symbol,
5018 which is the target of the indirection. */
5019 if ((type
& N_TYPE
) == N_INDR
)
5024 /* We need to get the value from the hash table. We use
5025 hresolve so that if we have defined an indirect
5026 symbol we output the final definition. */
5029 switch (type
& N_TYPE
)
5032 symsec
= obj_textsec (input_bfd
);
5035 symsec
= obj_datasec (input_bfd
);
5038 symsec
= obj_bsssec (input_bfd
);
5041 symsec
= bfd_abs_section_ptr
;
5048 else if (hresolve
->root
.type
== bfd_link_hash_defined
5049 || hresolve
->root
.type
== bfd_link_hash_defweak
)
5051 asection
*input_section
;
5052 asection
*output_section
;
5054 /* This case usually means a common symbol which was
5055 turned into a defined symbol. */
5056 input_section
= hresolve
->root
.u
.def
.section
;
5057 output_section
= input_section
->output_section
;
5058 BFD_ASSERT (bfd_is_abs_section (output_section
)
5059 || output_section
->owner
== output_bfd
);
5060 val
= (hresolve
->root
.u
.def
.value
5061 + bfd_section_vma (output_section
)
5062 + input_section
->output_offset
);
5064 /* Get the correct type based on the section. If
5065 this is a constructed set, force it to be
5066 globally visible. */
5075 if (output_section
== obj_textsec (output_bfd
))
5076 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
5079 else if (output_section
== obj_datasec (output_bfd
))
5080 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
5083 else if (output_section
== obj_bsssec (output_bfd
))
5084 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
5088 type
|= (hresolve
->root
.type
== bfd_link_hash_defined
5092 else if (hresolve
->root
.type
== bfd_link_hash_common
)
5093 val
= hresolve
->root
.u
.c
.size
;
5094 else if (hresolve
->root
.type
== bfd_link_hash_undefweak
)
5103 val
= (symsec
->output_section
->vma
5104 + symsec
->output_offset
5105 + (GET_WORD (input_bfd
, sym
->e_value
)
5108 /* If this is a global symbol set the written flag, and if
5109 it is a local symbol see if we should discard it. */
5113 h
->indx
= obj_aout_external_sym_count (output_bfd
);
5115 else if ((type
& N_TYPE
) != N_SETT
5116 && (type
& N_TYPE
) != N_SETD
5117 && (type
& N_TYPE
) != N_SETB
5118 && (type
& N_TYPE
) != N_SETA
)
5123 case discard_sec_merge
:
5126 if ((type
& N_STAB
) == 0
5127 && bfd_is_local_label_name (input_bfd
, name
))
5141 /* An N_BINCL symbol indicates the start of the stabs
5142 entries for a header file. We need to scan ahead to the
5143 next N_EINCL symbol, ignoring nesting, adding up all the
5144 characters in the symbol names, not including the file
5145 numbers in types (the first number after an open
5147 if (type
== (int) N_BINCL
)
5149 struct external_nlist
*incl_sym
;
5151 struct aout_link_includes_entry
*incl_entry
;
5152 struct aout_link_includes_totals
*t
;
5156 for (incl_sym
= sym
+ 1; incl_sym
< sym_end
; incl_sym
++)
5160 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
5161 if (incl_type
== (int) N_EINCL
)
5167 else if (incl_type
== (int) N_BINCL
)
5173 s
= strings
+ GET_WORD (input_bfd
, incl_sym
->e_strx
);
5174 for (; *s
!= '\0'; s
++)
5179 /* Skip the file number. */
5181 while (ISDIGIT (*s
))
5189 /* If we have already included a header file with the
5190 same value, then replace this one with an N_EXCL
5192 copy
= (bfd_boolean
) (! flaginfo
->info
->keep_memory
);
5193 incl_entry
= aout_link_includes_lookup (&flaginfo
->includes
,
5195 if (incl_entry
== NULL
)
5197 for (t
= incl_entry
->totals
; t
!= NULL
; t
= t
->next
)
5198 if (t
->total
== val
)
5202 /* This is the first time we have seen this header
5203 file with this set of stabs strings. */
5204 t
= (struct aout_link_includes_totals
*)
5205 bfd_hash_allocate (&flaginfo
->includes
.root
,
5210 t
->next
= incl_entry
->totals
;
5211 incl_entry
->totals
= t
;
5217 /* This is a duplicate header file. We must change
5218 it to be an N_EXCL entry, and mark all the
5219 included symbols to prevent outputting them. */
5220 type
= (int) N_EXCL
;
5223 for (incl_sym
= sym
+ 1, incl_map
= symbol_map
+ 1;
5225 incl_sym
++, incl_map
++)
5229 incl_type
= H_GET_8 (input_bfd
, incl_sym
->e_type
);
5230 if (incl_type
== (int) N_EINCL
)
5239 else if (incl_type
== (int) N_BINCL
)
5248 /* Copy this symbol into the list of symbols we are going to
5250 H_PUT_8 (output_bfd
, type
, outsym
->e_type
);
5251 H_PUT_8 (output_bfd
, H_GET_8 (input_bfd
, sym
->e_other
), outsym
->e_other
);
5252 H_PUT_16 (output_bfd
, H_GET_16 (input_bfd
, sym
->e_desc
), outsym
->e_desc
);
5254 if (! flaginfo
->info
->keep_memory
)
5256 /* name points into a string table which we are going to
5257 free. If there is a hash table entry, use that string.
5258 Otherwise, copy name into memory. */
5260 name
= h
->root
.root
.string
;
5264 strtab_index
= add_to_stringtab (output_bfd
, flaginfo
->strtab
,
5266 if (strtab_index
== (bfd_size_type
) -1)
5268 PUT_WORD (output_bfd
, strtab_index
, outsym
->e_strx
);
5269 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
5270 *symbol_map
= obj_aout_external_sym_count (output_bfd
);
5271 ++obj_aout_external_sym_count (output_bfd
);
5275 /* Write out the output symbols we have just constructed. */
5276 if (outsym
> flaginfo
->output_syms
)
5278 bfd_size_type outsym_size
;
5280 if (bfd_seek (output_bfd
, flaginfo
->symoff
, SEEK_SET
) != 0)
5282 outsym_size
= outsym
- flaginfo
->output_syms
;
5283 outsym_size
*= EXTERNAL_NLIST_SIZE
;
5284 if (bfd_bwrite ((void *) flaginfo
->output_syms
, outsym_size
, output_bfd
)
5287 flaginfo
->symoff
+= outsym_size
;
5293 /* Link an a.out input BFD into the output file. */
5296 aout_link_input_bfd (struct aout_final_link_info
*flaginfo
, bfd
*input_bfd
)
5298 BFD_ASSERT (bfd_get_format (input_bfd
) == bfd_object
);
5300 /* If this is a dynamic object, it may need special handling. */
5301 if ((input_bfd
->flags
& DYNAMIC
) != 0
5302 && aout_backend_info (input_bfd
)->link_dynamic_object
!= NULL
)
5303 return ((*aout_backend_info (input_bfd
)->link_dynamic_object
)
5304 (flaginfo
->info
, input_bfd
));
5306 /* Get the symbols. We probably have them already, unless
5307 flaginfo->info->keep_memory is FALSE. */
5308 if (! aout_get_external_symbols (input_bfd
))
5311 /* Write out the symbols and get a map of the new indices. The map
5312 is placed into flaginfo->symbol_map. */
5313 if (! aout_link_write_symbols (flaginfo
, input_bfd
))
5316 /* Relocate and write out the sections. These functions use the
5317 symbol map created by aout_link_write_symbols. The linker_mark
5318 field will be set if these sections are to be included in the
5319 link, which will normally be the case. */
5320 if (obj_textsec (input_bfd
)->linker_mark
)
5322 if (! aout_link_input_section (flaginfo
, input_bfd
,
5323 obj_textsec (input_bfd
),
5325 exec_hdr (input_bfd
)->a_trsize
))
5328 if (obj_datasec (input_bfd
)->linker_mark
)
5330 if (! aout_link_input_section (flaginfo
, input_bfd
,
5331 obj_datasec (input_bfd
),
5333 exec_hdr (input_bfd
)->a_drsize
))
5337 /* If we are not keeping memory, we don't need the symbols any
5338 longer. We still need them if we are keeping memory, because the
5339 strings in the hash table point into them. */
5340 if (! flaginfo
->info
->keep_memory
)
5342 if (! aout_link_free_symbols (input_bfd
))
5349 /* Do the final link step. This is called on the output BFD. The
5350 INFO structure should point to a list of BFDs linked through the
5351 link.next field which can be used to find each BFD which takes part
5352 in the output. Also, each section in ABFD should point to a list
5353 of bfd_link_order structures which list all the input sections for
5354 the output section. */
5357 NAME (aout
, final_link
) (bfd
*abfd
,
5358 struct bfd_link_info
*info
,
5359 void (*callback
) (bfd
*, file_ptr
*, file_ptr
*, file_ptr
*))
5361 struct aout_final_link_info aout_info
;
5362 bfd_boolean includes_hash_initialized
= FALSE
;
5364 bfd_size_type trsize
, drsize
;
5365 bfd_size_type max_contents_size
;
5366 bfd_size_type max_relocs_size
;
5367 bfd_size_type max_sym_count
;
5368 struct bfd_link_order
*p
;
5370 bfd_boolean have_link_order_relocs
;
5372 if (bfd_link_pic (info
))
5373 abfd
->flags
|= DYNAMIC
;
5375 aout_info
.info
= info
;
5376 aout_info
.output_bfd
= abfd
;
5377 aout_info
.contents
= NULL
;
5378 aout_info
.relocs
= NULL
;
5379 aout_info
.symbol_map
= NULL
;
5380 aout_info
.output_syms
= NULL
;
5382 if (!bfd_hash_table_init_n (&aout_info
.includes
.root
,
5383 aout_link_includes_newfunc
,
5384 sizeof (struct aout_link_includes_entry
),
5387 includes_hash_initialized
= TRUE
;
5389 /* Figure out the largest section size. Also, if generating
5390 relocatable output, count the relocs. */
5393 max_contents_size
= 0;
5394 max_relocs_size
= 0;
5396 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
5400 if (bfd_link_relocatable (info
))
5402 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
5404 trsize
+= exec_hdr (sub
)->a_trsize
;
5405 drsize
+= exec_hdr (sub
)->a_drsize
;
5409 /* FIXME: We need to identify the .text and .data sections
5410 and call get_reloc_upper_bound and canonicalize_reloc to
5411 work out the number of relocs needed, and then multiply
5412 by the reloc size. */
5414 /* xgettext:c-format */
5415 (_("%pB: relocatable link from %s to %s not supported"),
5416 abfd
, sub
->xvec
->name
, abfd
->xvec
->name
);
5417 bfd_set_error (bfd_error_invalid_operation
);
5422 if (bfd_get_flavour (sub
) == bfd_target_aout_flavour
)
5424 sz
= obj_textsec (sub
)->size
;
5425 if (sz
> max_contents_size
)
5426 max_contents_size
= sz
;
5427 sz
= obj_datasec (sub
)->size
;
5428 if (sz
> max_contents_size
)
5429 max_contents_size
= sz
;
5431 sz
= exec_hdr (sub
)->a_trsize
;
5432 if (sz
> max_relocs_size
)
5433 max_relocs_size
= sz
;
5434 sz
= exec_hdr (sub
)->a_drsize
;
5435 if (sz
> max_relocs_size
)
5436 max_relocs_size
= sz
;
5438 sz
= obj_aout_external_sym_count (sub
);
5439 if (sz
> max_sym_count
)
5444 if (bfd_link_relocatable (info
))
5446 if (obj_textsec (abfd
) != NULL
)
5447 trsize
+= (_bfd_count_link_order_relocs (obj_textsec (abfd
)
5448 ->map_head
.link_order
)
5449 * obj_reloc_entry_size (abfd
));
5450 if (obj_datasec (abfd
) != NULL
)
5451 drsize
+= (_bfd_count_link_order_relocs (obj_datasec (abfd
)
5452 ->map_head
.link_order
)
5453 * obj_reloc_entry_size (abfd
));
5456 exec_hdr (abfd
)->a_trsize
= trsize
;
5457 exec_hdr (abfd
)->a_drsize
= drsize
;
5459 exec_hdr (abfd
)->a_entry
= bfd_get_start_address (abfd
);
5461 /* Adjust the section sizes and vmas according to the magic number.
5462 This sets a_text, a_data and a_bss in the exec_hdr and sets the
5463 filepos for each section. */
5464 if (! NAME (aout
, adjust_sizes_and_vmas
) (abfd
))
5467 /* The relocation and symbol file positions differ among a.out
5468 targets. We are passed a callback routine from the backend
5469 specific code to handle this.
5470 FIXME: At this point we do not know how much space the symbol
5471 table will require. This will not work for any (nonstandard)
5472 a.out target that needs to know the symbol table size before it
5473 can compute the relocation file positions. */
5474 (*callback
) (abfd
, &aout_info
.treloff
, &aout_info
.dreloff
,
5476 obj_textsec (abfd
)->rel_filepos
= aout_info
.treloff
;
5477 obj_datasec (abfd
)->rel_filepos
= aout_info
.dreloff
;
5478 obj_sym_filepos (abfd
) = aout_info
.symoff
;
5480 /* We keep a count of the symbols as we output them. */
5481 obj_aout_external_sym_count (abfd
) = 0;
5483 /* We accumulate the string table as we write out the symbols. */
5484 aout_info
.strtab
= _bfd_stringtab_init ();
5485 if (aout_info
.strtab
== NULL
)
5488 /* Allocate buffers to hold section contents and relocs. */
5489 aout_info
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
5490 aout_info
.relocs
= bfd_malloc (max_relocs_size
);
5491 aout_info
.symbol_map
= (int *) bfd_malloc (max_sym_count
* sizeof (int));
5492 aout_info
.output_syms
= (struct external_nlist
*)
5493 bfd_malloc ((max_sym_count
+ 1) * sizeof (struct external_nlist
));
5494 if ((aout_info
.contents
== NULL
&& max_contents_size
!= 0)
5495 || (aout_info
.relocs
== NULL
&& max_relocs_size
!= 0)
5496 || (aout_info
.symbol_map
== NULL
&& max_sym_count
!= 0)
5497 || aout_info
.output_syms
== NULL
)
5500 /* If we have a symbol named __DYNAMIC, force it out now. This is
5501 required by SunOS. Doing this here rather than in sunos.c is a
5502 hack, but it's easier than exporting everything which would be
5505 struct aout_link_hash_entry
*h
;
5507 h
= aout_link_hash_lookup (aout_hash_table (info
), "__DYNAMIC",
5508 FALSE
, FALSE
, FALSE
);
5510 aout_link_write_other_symbol (&h
->root
.root
, &aout_info
);
5513 /* The most time efficient way to do the link would be to read all
5514 the input object files into memory and then sort out the
5515 information into the output file. Unfortunately, that will
5516 probably use too much memory. Another method would be to step
5517 through everything that composes the text section and write it
5518 out, and then everything that composes the data section and write
5519 it out, and then write out the relocs, and then write out the
5520 symbols. Unfortunately, that requires reading stuff from each
5521 input file several times, and we will not be able to keep all the
5522 input files open simultaneously, and reopening them will be slow.
5524 What we do is basically process one input file at a time. We do
5525 everything we need to do with an input file once--copy over the
5526 section contents, handle the relocation information, and write
5527 out the symbols--and then we throw away the information we read
5528 from it. This approach requires a lot of lseeks of the output
5529 file, which is unfortunate but still faster than reopening a lot
5532 We use the output_has_begun field of the input BFDs to see
5533 whether we have already handled it. */
5534 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
5535 sub
->output_has_begun
= FALSE
;
5537 /* Mark all sections which are to be included in the link. This
5538 will normally be every section. We need to do this so that we
5539 can identify any sections which the linker has decided to not
5541 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5543 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
5544 if (p
->type
== bfd_indirect_link_order
)
5545 p
->u
.indirect
.section
->linker_mark
= TRUE
;
5548 have_link_order_relocs
= FALSE
;
5549 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5551 for (p
= o
->map_head
.link_order
;
5555 if (p
->type
== bfd_indirect_link_order
5556 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
5557 == bfd_target_aout_flavour
))
5561 input_bfd
= p
->u
.indirect
.section
->owner
;
5562 if (! input_bfd
->output_has_begun
)
5564 if (! aout_link_input_bfd (&aout_info
, input_bfd
))
5566 input_bfd
->output_has_begun
= TRUE
;
5569 else if (p
->type
== bfd_section_reloc_link_order
5570 || p
->type
== bfd_symbol_reloc_link_order
)
5572 /* These are handled below. */
5573 have_link_order_relocs
= TRUE
;
5577 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5583 /* Write out any symbols that we have not already written out. */
5584 bfd_hash_traverse (&info
->hash
->table
,
5585 aout_link_write_other_symbol
,
5588 /* Now handle any relocs we were asked to create by the linker.
5589 These did not come from any input file. We must do these after
5590 we have written out all the symbols, so that we know the symbol
5592 if (have_link_order_relocs
)
5594 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5596 for (p
= o
->map_head
.link_order
;
5600 if (p
->type
== bfd_section_reloc_link_order
5601 || p
->type
== bfd_symbol_reloc_link_order
)
5603 if (! aout_link_reloc_link_order (&aout_info
, o
, p
))
5610 if (aout_info
.contents
!= NULL
)
5612 free (aout_info
.contents
);
5613 aout_info
.contents
= NULL
;
5615 if (aout_info
.relocs
!= NULL
)
5617 free (aout_info
.relocs
);
5618 aout_info
.relocs
= NULL
;
5620 if (aout_info
.symbol_map
!= NULL
)
5622 free (aout_info
.symbol_map
);
5623 aout_info
.symbol_map
= NULL
;
5625 if (aout_info
.output_syms
!= NULL
)
5627 free (aout_info
.output_syms
);
5628 aout_info
.output_syms
= NULL
;
5630 if (includes_hash_initialized
)
5632 bfd_hash_table_free (&aout_info
.includes
.root
);
5633 includes_hash_initialized
= FALSE
;
5636 /* Finish up any dynamic linking we may be doing. */
5637 if (aout_backend_info (abfd
)->finish_dynamic_link
!= NULL
)
5639 if (! (*aout_backend_info (abfd
)->finish_dynamic_link
) (abfd
, info
))
5643 /* Update the header information. */
5644 abfd
->symcount
= obj_aout_external_sym_count (abfd
);
5645 exec_hdr (abfd
)->a_syms
= abfd
->symcount
* EXTERNAL_NLIST_SIZE
;
5646 obj_str_filepos (abfd
) = obj_sym_filepos (abfd
) + exec_hdr (abfd
)->a_syms
;
5647 obj_textsec (abfd
)->reloc_count
=
5648 exec_hdr (abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
);
5649 obj_datasec (abfd
)->reloc_count
=
5650 exec_hdr (abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
);
5652 /* Write out the string table, unless there are no symbols. */
5653 if (bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
) != 0)
5655 if (abfd
->symcount
> 0)
5657 if (!emit_stringtab (abfd
, aout_info
.strtab
))
5662 bfd_byte b
[BYTES_IN_WORD
];
5664 memset (b
, 0, BYTES_IN_WORD
);
5665 if (bfd_bwrite (b
, (bfd_size_type
) BYTES_IN_WORD
, abfd
) != BYTES_IN_WORD
)
5672 if (aout_info
.contents
!= NULL
)
5673 free (aout_info
.contents
);
5674 if (aout_info
.relocs
!= NULL
)
5675 free (aout_info
.relocs
);
5676 if (aout_info
.symbol_map
!= NULL
)
5677 free (aout_info
.symbol_map
);
5678 if (aout_info
.output_syms
!= NULL
)
5679 free (aout_info
.output_syms
);
5680 if (includes_hash_initialized
)
5681 bfd_hash_table_free (&aout_info
.includes
.root
);