1 /* BFD semi-generic back-end for a.out binaries.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
4 Written by Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
29 BFD supports a number of different flavours of a.out format,
30 though the major differences are only the sizes of the
31 structures on disk, and the shape of the relocation
34 The support is split into a basic support file @file{aoutx.h}
35 and other files which derive functions from the base. One
36 derivation file is @file{aoutf1.h} (for a.out flavour 1), and
37 adds to the basic a.out functions support for sun3, sun4, 386
38 and 29k a.out files, to create a target jump vector for a
41 This information is further split out into more specific files
42 for each machine, including @file{sunos.c} for sun3 and sun4,
43 @file{newsos3.c} for the Sony NEWS, and @file{demo64.c} for a
44 demonstration of a 64 bit a.out format.
46 The base file @file{aoutx.h} defines general mechanisms for
47 reading and writing records to and from disk and various
48 other methods which BFD requires. It is included by
49 @file{aout32.c} and @file{aout64.c} to form the names
50 <<aout_32_swap_exec_header_in>>, <<aout_64_swap_exec_header_in>>, etc.
52 As an example, this is what goes on to make the back end for a
53 sun4, from @file{aout32.c}:
55 | #define ARCH_SIZE 32
61 | aout_32_canonicalize_reloc
62 | aout_32_find_nearest_line
64 | aout_32_get_reloc_upper_bound
69 | #define TARGET_NAME "a.out-sunos-big"
70 | #define VECNAME sunos_big_vec
73 requires all the names from @file{aout32.c}, and produces the jump vector
77 The file @file{host-aout.c} is a special case. It is for a large set
78 of hosts that use ``more or less standard'' a.out files, and
79 for which cross-debugging is not interesting. It uses the
80 standard 32-bit a.out support routines, but determines the
81 file offsets and addresses of the text, data, and BSS
82 sections, the machine architecture and machine type, and the
83 entry point address, in a host-dependent manner. Once these
84 values have been determined, generic code is used to handle
87 When porting it to run on a new system, you must supply:
91 | HOST_MACHINE_ARCH (optional)
92 | HOST_MACHINE_MACHINE (optional)
93 | HOST_TEXT_START_ADDR
96 in the file @file{../include/sys/h-@var{XXX}.h} (for your host). These
97 values, plus the structures and macros defined in @file{a.out.h} on
98 your host system, will produce a BFD target that will access
99 ordinary a.out files on your host. To configure a new machine
100 to use @file{host-aout.c}, specify:
102 | TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec
103 | TDEPFILES= host-aout.o trad-core.o
105 in the @file{config/@var{XXX}.mt} file, and modify @file{configure.in}
107 @file{@var{XXX}.mt} file (by setting "<<bfd_target=XXX>>") when your
108 configuration is selected.
113 * Any BFD with D_PAGED set is ZMAGIC, and vice versa.
114 Doesn't matter what the setting of WP_TEXT is on output, but it'll
116 * Any BFD with D_PAGED clear and WP_TEXT set is NMAGIC.
117 * Any BFD with both flags clear is OMAGIC.
118 (Just want to make these explicit, so the conditions tested in this
119 file make sense if you're more familiar with a.out than with BFD.) */
121 #define KEEPIT udata.i
123 #include <string.h> /* For strchr and friends */
131 #include "aout/aout64.h"
132 #include "aout/stab_gnu.h"
135 static boolean aout_get_external_symbols PARAMS ((bfd *));
136 static boolean translate_from_native_sym_flags
137 PARAMS ((bfd *, aout_symbol_type *));
138 static boolean translate_to_native_sym_flags
139 PARAMS ((bfd *, asymbol *, struct external_nlist *));
140 static void adjust_o_magic PARAMS ((bfd *, struct internal_exec *));
141 static void adjust_z_magic PARAMS ((bfd *, struct internal_exec *));
142 static void adjust_n_magic PARAMS ((bfd *, struct internal_exec *));
149 The file @file{aoutx.h} provides for both the @emph{standard}
150 and @emph{extended} forms of a.out relocation records.
152 The standard records contain only an
153 address, a symbol index, and a type field. The extended records
154 (used on 29ks and sparcs) also have a full integer for an
158 #ifndef CTOR_TABLE_RELOC_HOWTO
159 #define CTOR_TABLE_RELOC_IDX 2
160 #define CTOR_TABLE_RELOC_HOWTO(BFD) ((obj_reloc_entry_size(BFD) == RELOC_EXT_SIZE \
161 ? howto_table_ext : howto_table_std) \
162 + CTOR_TABLE_RELOC_IDX)
165 #ifndef MY_swap_std_reloc_in
166 #define MY_swap_std_reloc_in NAME(aout,swap_std_reloc_in)
169 #ifndef MY_swap_std_reloc_out
170 #define MY_swap_std_reloc_out NAME(aout,swap_std_reloc_out)
173 #ifndef MY_final_link_relocate
174 #define MY_final_link_relocate _bfd_final_link_relocate
177 #ifndef MY_relocate_contents
178 #define MY_relocate_contents _bfd_relocate_contents
181 #define howto_table_ext NAME(aout,ext_howto_table)
182 #define howto_table_std NAME(aout,std_howto_table)
184 reloc_howto_type howto_table_ext[] =
186 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
187 HOWTO(RELOC_8, 0, 0, 8, false, 0, complain_overflow_bitfield,0,"8", false, 0,0x000000ff, false),
188 HOWTO(RELOC_16, 0, 1, 16, false, 0, complain_overflow_bitfield,0,"16", false, 0,0x0000ffff, false),
189 HOWTO(RELOC_32, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"32", false, 0,0xffffffff, false),
190 HOWTO(RELOC_DISP8, 0, 0, 8, true, 0, complain_overflow_signed,0,"DISP8", false, 0,0x000000ff, false),
191 HOWTO(RELOC_DISP16, 0, 1, 16, true, 0, complain_overflow_signed,0,"DISP16", false, 0,0x0000ffff, false),
192 HOWTO(RELOC_DISP32, 0, 2, 32, true, 0, complain_overflow_signed,0,"DISP32", false, 0,0xffffffff, false),
193 HOWTO(RELOC_WDISP30,2, 2, 30, true, 0, complain_overflow_signed,0,"WDISP30", false, 0,0x3fffffff, false),
194 HOWTO(RELOC_WDISP22,2, 2, 22, true, 0, complain_overflow_signed,0,"WDISP22", false, 0,0x003fffff, false),
195 HOWTO(RELOC_HI22, 10, 2, 22, false, 0, complain_overflow_bitfield,0,"HI22", false, 0,0x003fffff, false),
196 HOWTO(RELOC_22, 0, 2, 22, false, 0, complain_overflow_bitfield,0,"22", false, 0,0x003fffff, false),
197 HOWTO(RELOC_13, 0, 2, 13, false, 0, complain_overflow_bitfield,0,"13", false, 0,0x00001fff, false),
198 HOWTO(RELOC_LO10, 0, 2, 10, false, 0, complain_overflow_dont,0,"LO10", false, 0,0x000003ff, false),
199 HOWTO(RELOC_SFA_BASE,0, 2, 32, false, 0, complain_overflow_bitfield,0,"SFA_BASE", false, 0,0xffffffff, false),
200 HOWTO(RELOC_SFA_OFF13,0,2, 32, false, 0, complain_overflow_bitfield,0,"SFA_OFF13",false, 0,0xffffffff, false),
201 HOWTO(RELOC_BASE10, 0, 2, 10, false, 0, complain_overflow_dont,0,"BASE10", false, 0,0x000003ff, false),
202 HOWTO(RELOC_BASE13, 0, 2, 13, false, 0, complain_overflow_bitfield,0,"BASE13", false, 0,0x00001fff, false),
203 HOWTO(RELOC_BASE22, 10, 2, 22, false, 0, complain_overflow_bitfield,0,"BASE22", false, 0,0x003fffff, false),
204 HOWTO(RELOC_PC10, 0, 2, 10, true, 0, complain_overflow_dont,0,"PC10", false, 0,0x000003ff, true),
205 HOWTO(RELOC_PC22, 10, 2, 22, true, 0, complain_overflow_signed,0,"PC22", false, 0,0x003fffff, true),
206 HOWTO(RELOC_JMP_TBL,2, 2, 30, true, 0, complain_overflow_signed,0,"JMP_TBL", false, 0,0x3fffffff, false),
207 HOWTO(RELOC_SEGOFF16,0, 2, 0, false, 0, complain_overflow_bitfield,0,"SEGOFF16", false, 0,0x00000000, false),
208 HOWTO(RELOC_GLOB_DAT,0, 2, 0, false, 0, complain_overflow_bitfield,0,"GLOB_DAT", false, 0,0x00000000, false),
209 HOWTO(RELOC_JMP_SLOT,0, 2, 0, false, 0, complain_overflow_bitfield,0,"JMP_SLOT", false, 0,0x00000000, false),
210 HOWTO(RELOC_RELATIVE,0, 2, 0, false, 0, complain_overflow_bitfield,0,"RELATIVE", false, 0,0x00000000, false),
213 /* Convert standard reloc records to "arelent" format (incl byte swap). */
215 reloc_howto_type howto_table_std[] = {
216 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
217 HOWTO( 0, 0, 0, 8, false, 0, complain_overflow_bitfield,0,"8", true, 0x000000ff,0x000000ff, false),
218 HOWTO( 1, 0, 1, 16, false, 0, complain_overflow_bitfield,0,"16", true, 0x0000ffff,0x0000ffff, false),
219 HOWTO( 2, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"32", true, 0xffffffff,0xffffffff, false),
220 HOWTO( 3, 0, 4, 64, false, 0, complain_overflow_bitfield,0,"64", true, 0xdeaddead,0xdeaddead, false),
221 HOWTO( 4, 0, 0, 8, true, 0, complain_overflow_signed, 0,"DISP8", true, 0x000000ff,0x000000ff, false),
222 HOWTO( 5, 0, 1, 16, true, 0, complain_overflow_signed, 0,"DISP16", true, 0x0000ffff,0x0000ffff, false),
223 HOWTO( 6, 0, 2, 32, true, 0, complain_overflow_signed, 0,"DISP32", true, 0xffffffff,0xffffffff, false),
224 HOWTO( 7, 0, 4, 64, true, 0, complain_overflow_signed, 0,"DISP64", true, 0xfeedface,0xfeedface, false),
225 HOWTO( 8, 0, 2, 0, false, 0, complain_overflow_bitfield,0,"GOT_REL", false, 0,0x00000000, false),
226 HOWTO( 9, 0, 1, 16, false, 0, complain_overflow_bitfield,0,"BASE16", false,0xffffffff,0xffffffff, false),
227 HOWTO(10, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"BASE32", false,0xffffffff,0xffffffff, false),
233 HOWTO(16, 0, 2, 0, false, 0, complain_overflow_bitfield,0,"JMP_TABLE", false, 0,0x00000000, false),
241 { -1 }, { -1 }, { -1 }, { -1 }, { -1 }, { -1 }, { -1 }, { -1 },
242 HOWTO(32, 0, 2, 0, false, 0, complain_overflow_bitfield,0,"RELATIVE", false, 0,0x00000000, false),
250 HOWTO(40, 0, 2, 0, false, 0, complain_overflow_bitfield,0,"BASEREL", false, 0,0x00000000, false),
253 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
256 NAME(aout,reloc_type_lookup) (abfd,code)
258 bfd_reloc_code_real_type code;
260 #define EXT(i,j) case i: return &howto_table_ext[j]
261 #define STD(i,j) case i: return &howto_table_std[j]
262 int ext = obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE;
263 if (code == BFD_RELOC_CTOR)
264 switch (bfd_get_arch_info (abfd)->bits_per_address)
276 EXT (BFD_RELOC_32, 2);
277 EXT (BFD_RELOC_HI22, 8);
278 EXT (BFD_RELOC_LO10, 11);
279 EXT (BFD_RELOC_32_PCREL_S2, 6);
280 EXT (BFD_RELOC_SPARC_WDISP22, 7);
281 EXT (BFD_RELOC_SPARC13, 10);
282 EXT (BFD_RELOC_SPARC_GOT10, 14);
283 EXT (BFD_RELOC_SPARC_BASE13, 15);
284 EXT (BFD_RELOC_SPARC_GOT13, 15);
285 EXT (BFD_RELOC_SPARC_GOT22, 16);
286 EXT (BFD_RELOC_SPARC_PC10, 17);
287 EXT (BFD_RELOC_SPARC_PC22, 18);
288 EXT (BFD_RELOC_SPARC_WPLT30, 19);
289 default: return (reloc_howto_type *) NULL;
295 STD (BFD_RELOC_16, 1);
296 STD (BFD_RELOC_32, 2);
297 STD (BFD_RELOC_8_PCREL, 4);
298 STD (BFD_RELOC_16_PCREL, 5);
299 STD (BFD_RELOC_32_PCREL, 6);
300 STD (BFD_RELOC_16_BASEREL, 9);
301 STD (BFD_RELOC_32_BASEREL, 10);
302 default: return (reloc_howto_type *) NULL;
308 Internal entry points
311 @file{aoutx.h} exports several routines for accessing the
312 contents of an a.out file, which are gathered and exported in
313 turn by various format specific files (eg sunos.c).
319 aout_@var{size}_swap_exec_header_in
322 void aout_@var{size}_swap_exec_header_in,
324 struct external_exec *raw_bytes,
325 struct internal_exec *execp);
328 Swap the information in an executable header @var{raw_bytes} taken
329 from a raw byte stream memory image into the internal exec header
330 structure @var{execp}.
333 #ifndef NAME_swap_exec_header_in
335 NAME(aout,swap_exec_header_in) (abfd, raw_bytes, execp)
337 struct external_exec *raw_bytes;
338 struct internal_exec *execp;
340 struct external_exec *bytes = (struct external_exec *)raw_bytes;
342 /* The internal_exec structure has some fields that are unused in this
343 configuration (IE for i960), so ensure that all such uninitialized
344 fields are zero'd out. There are places where two of these structs
345 are memcmp'd, and thus the contents do matter. */
346 memset ((PTR) execp, 0, sizeof (struct internal_exec));
347 /* Now fill in fields in the execp, from the bytes in the raw data. */
348 execp->a_info = bfd_h_get_32 (abfd, bytes->e_info);
349 execp->a_text = GET_WORD (abfd, bytes->e_text);
350 execp->a_data = GET_WORD (abfd, bytes->e_data);
351 execp->a_bss = GET_WORD (abfd, bytes->e_bss);
352 execp->a_syms = GET_WORD (abfd, bytes->e_syms);
353 execp->a_entry = GET_WORD (abfd, bytes->e_entry);
354 execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
355 execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
357 #define NAME_swap_exec_header_in NAME(aout,swap_exec_header_in)
362 aout_@var{size}_swap_exec_header_out
365 void aout_@var{size}_swap_exec_header_out
367 struct internal_exec *execp,
368 struct external_exec *raw_bytes);
371 Swap the information in an internal exec header structure
372 @var{execp} into the buffer @var{raw_bytes} ready for writing to disk.
375 NAME(aout,swap_exec_header_out) (abfd, execp, raw_bytes)
377 struct internal_exec *execp;
378 struct external_exec *raw_bytes;
380 struct external_exec *bytes = (struct external_exec *)raw_bytes;
382 /* Now fill in fields in the raw data, from the fields in the exec struct. */
383 bfd_h_put_32 (abfd, execp->a_info , bytes->e_info);
384 PUT_WORD (abfd, execp->a_text , bytes->e_text);
385 PUT_WORD (abfd, execp->a_data , bytes->e_data);
386 PUT_WORD (abfd, execp->a_bss , bytes->e_bss);
387 PUT_WORD (abfd, execp->a_syms , bytes->e_syms);
388 PUT_WORD (abfd, execp->a_entry , bytes->e_entry);
389 PUT_WORD (abfd, execp->a_trsize, bytes->e_trsize);
390 PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize);
393 /* Make all the section for an a.out file. */
396 NAME(aout,make_sections) (abfd)
399 if (obj_textsec (abfd) == (asection *) NULL
400 && bfd_make_section (abfd, ".text") == (asection *) NULL)
402 if (obj_datasec (abfd) == (asection *) NULL
403 && bfd_make_section (abfd, ".data") == (asection *) NULL)
405 if (obj_bsssec (abfd) == (asection *) NULL
406 && bfd_make_section (abfd, ".bss") == (asection *) NULL)
413 aout_@var{size}_some_aout_object_p
416 const bfd_target *aout_@var{size}_some_aout_object_p
418 const bfd_target *(*callback_to_real_object_p)());
421 Some a.out variant thinks that the file open in @var{abfd}
422 checking is an a.out file. Do some more checking, and set up
423 for access if it really is. Call back to the calling
424 environment's "finish up" function just before returning, to
425 handle any last-minute setup.
429 NAME(aout,some_aout_object_p) (abfd, execp, callback_to_real_object_p)
431 struct internal_exec *execp;
432 const bfd_target *(*callback_to_real_object_p) PARAMS ((bfd *));
434 struct aout_data_struct *rawptr, *oldrawptr;
435 const bfd_target *result;
437 rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, sizeof (struct aout_data_struct ));
441 oldrawptr = abfd->tdata.aout_data;
442 abfd->tdata.aout_data = rawptr;
444 /* Copy the contents of the old tdata struct.
445 In particular, we want the subformat, since for hpux it was set in
446 hp300hpux.c:swap_exec_header_in and will be used in
447 hp300hpux.c:callback. */
448 if (oldrawptr != NULL)
449 *abfd->tdata.aout_data = *oldrawptr;
451 abfd->tdata.aout_data->a.hdr = &rawptr->e;
452 *(abfd->tdata.aout_data->a.hdr) = *execp; /* Copy in the internal_exec struct */
453 execp = abfd->tdata.aout_data->a.hdr;
455 /* Set the file flags */
456 abfd->flags = BFD_NO_FLAGS;
457 if (execp->a_drsize || execp->a_trsize)
458 abfd->flags |= HAS_RELOC;
459 /* Setting of EXEC_P has been deferred to the bottom of this function */
461 abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
462 if (N_DYNAMIC(*execp))
463 abfd->flags |= DYNAMIC;
465 if (N_MAGIC (*execp) == ZMAGIC)
467 abfd->flags |= D_PAGED | WP_TEXT;
468 adata (abfd).magic = z_magic;
470 else if (N_MAGIC (*execp) == QMAGIC)
472 abfd->flags |= D_PAGED | WP_TEXT;
473 adata (abfd).magic = z_magic;
474 adata (abfd).subformat = q_magic_format;
476 else if (N_MAGIC (*execp) == NMAGIC)
478 abfd->flags |= WP_TEXT;
479 adata (abfd).magic = n_magic;
481 else if (N_MAGIC (*execp) == OMAGIC
482 || N_MAGIC (*execp) == BMAGIC)
483 adata (abfd).magic = o_magic;
486 /* Should have been checked with N_BADMAG before this routine
491 bfd_get_start_address (abfd) = execp->a_entry;
493 obj_aout_symbols (abfd) = (aout_symbol_type *)NULL;
494 bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist);
496 /* The default relocation entry size is that of traditional V7 Unix. */
497 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
499 /* The default symbol entry size is that of traditional Unix. */
500 obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE;
503 bfd_init_window (&obj_aout_sym_window (abfd));
504 bfd_init_window (&obj_aout_string_window (abfd));
506 obj_aout_external_syms (abfd) = NULL;
507 obj_aout_external_strings (abfd) = NULL;
508 obj_aout_sym_hashes (abfd) = NULL;
510 if (! NAME(aout,make_sections) (abfd))
513 obj_datasec (abfd)->_raw_size = execp->a_data;
514 obj_bsssec (abfd)->_raw_size = execp->a_bss;
516 obj_textsec (abfd)->flags =
517 (execp->a_trsize != 0
518 ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC)
519 : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS));
520 obj_datasec (abfd)->flags =
521 (execp->a_drsize != 0
522 ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC)
523 : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS));
524 obj_bsssec (abfd)->flags = SEC_ALLOC;
526 #ifdef THIS_IS_ONLY_DOCUMENTATION
527 /* The common code can't fill in these things because they depend
528 on either the start address of the text segment, the rounding
529 up of virtual addresses between segments, or the starting file
530 position of the text segment -- all of which varies among different
531 versions of a.out. */
533 /* Call back to the format-dependent code to fill in the rest of the
534 fields and do any further cleanup. Things that should be filled
535 in by the callback: */
537 struct exec *execp = exec_hdr (abfd);
539 obj_textsec (abfd)->size = N_TXTSIZE(*execp);
540 obj_textsec (abfd)->raw_size = N_TXTSIZE(*execp);
541 /* data and bss are already filled in since they're so standard */
543 /* The virtual memory addresses of the sections */
544 obj_textsec (abfd)->vma = N_TXTADDR(*execp);
545 obj_datasec (abfd)->vma = N_DATADDR(*execp);
546 obj_bsssec (abfd)->vma = N_BSSADDR(*execp);
548 /* The file offsets of the sections */
549 obj_textsec (abfd)->filepos = N_TXTOFF(*execp);
550 obj_datasec (abfd)->filepos = N_DATOFF(*execp);
552 /* The file offsets of the relocation info */
553 obj_textsec (abfd)->rel_filepos = N_TRELOFF(*execp);
554 obj_datasec (abfd)->rel_filepos = N_DRELOFF(*execp);
556 /* The file offsets of the string table and symbol table. */
557 obj_str_filepos (abfd) = N_STROFF (*execp);
558 obj_sym_filepos (abfd) = N_SYMOFF (*execp);
560 /* Determine the architecture and machine type of the object file. */
561 switch (N_MACHTYPE (*exec_hdr (abfd))) {
563 abfd->obj_arch = bfd_arch_obscure;
567 adata(abfd)->page_size = TARGET_PAGE_SIZE;
568 adata(abfd)->segment_size = SEGMENT_SIZE;
569 adata(abfd)->exec_bytes_size = EXEC_BYTES_SIZE;
573 /* The architecture is encoded in various ways in various a.out variants,
574 or is not encoded at all in some of them. The relocation size depends
575 on the architecture and the a.out variant. Finally, the return value
576 is the bfd_target vector in use. If an error occurs, return zero and
577 set bfd_error to the appropriate error code.
579 Formats such as b.out, which have additional fields in the a.out
580 header, should cope with them in this callback as well. */
581 #endif /* DOCUMENTATION */
583 result = (*callback_to_real_object_p)(abfd);
585 /* Now that the segment addresses have been worked out, take a better
586 guess at whether the file is executable. If the entry point
587 is within the text segment, assume it is. (This makes files
588 executable even if their entry point address is 0, as long as
589 their text starts at zero.).
591 This test had to be changed to deal with systems where the text segment
592 runs at a different location than the default. The problem is that the
593 entry address can appear to be outside the text segment, thus causing an
594 erroneous conclusion that the file isn't executable.
596 To fix this, we now accept any non-zero entry point as an indication of
597 executability. This will work most of the time, since only the linker
598 sets the entry point, and that is likely to be non-zero for most systems. */
600 if (execp->a_entry != 0
601 || (execp->a_entry >= obj_textsec(abfd)->vma
602 && execp->a_entry < obj_textsec(abfd)->vma + obj_textsec(abfd)->_raw_size))
603 abfd->flags |= EXEC_P;
607 struct stat stat_buf;
609 /* The original heuristic doesn't work in some important cases.
610 The a.out file has no information about the text start
611 address. For files (like kernels) linked to non-standard
612 addresses (ld -Ttext nnn) the entry point may not be between
613 the default text start (obj_textsec(abfd)->vma) and
614 (obj_textsec(abfd)->vma) + text size. This is not just a mach
615 issue. Many kernels are loaded at non standard addresses. */
616 if (abfd->iostream != NULL
617 && (abfd->flags & BFD_IN_MEMORY) == 0
618 && (fstat(fileno((FILE *) (abfd->iostream)), &stat_buf) == 0)
619 && ((stat_buf.st_mode & 0111) != 0))
620 abfd->flags |= EXEC_P;
622 #endif /* STAT_FOR_EXEC */
626 #if 0 /* These should be set correctly anyways. */
627 abfd->sections = obj_textsec (abfd);
628 obj_textsec (abfd)->next = obj_datasec (abfd);
629 obj_datasec (abfd)->next = obj_bsssec (abfd);
635 abfd->tdata.aout_data = oldrawptr;
642 aout_@var{size}_mkobject
645 boolean aout_@var{size}_mkobject, (bfd *abfd);
648 Initialize BFD @var{abfd} for use with a.out files.
652 NAME(aout,mkobject) (abfd)
655 struct aout_data_struct *rawptr;
657 bfd_set_error (bfd_error_system_call);
659 /* Use an intermediate variable for clarity */
660 rawptr = (struct aout_data_struct *)bfd_zalloc (abfd, sizeof (struct aout_data_struct ));
665 abfd->tdata.aout_data = rawptr;
666 exec_hdr (abfd) = &(rawptr->e);
668 obj_textsec (abfd) = (asection *)NULL;
669 obj_datasec (abfd) = (asection *)NULL;
670 obj_bsssec (abfd) = (asection *)NULL;
678 aout_@var{size}_machine_type
681 enum machine_type aout_@var{size}_machine_type
682 (enum bfd_architecture arch,
683 unsigned long machine));
686 Keep track of machine architecture and machine type for
687 a.out's. Return the <<machine_type>> for a particular
688 architecture and machine, or <<M_UNKNOWN>> if that exact architecture
689 and machine can't be represented in a.out format.
691 If the architecture is understood, machine type 0 (default)
692 is always understood.
696 NAME(aout,machine_type) (arch, machine, unknown)
697 enum bfd_architecture arch;
698 unsigned long machine;
701 enum machine_type arch_flags;
703 arch_flags = M_UNKNOWN;
709 || machine == bfd_mach_sparc
710 || machine == bfd_mach_sparc_sparclite
711 || machine == bfd_mach_sparc_v9)
712 arch_flags = M_SPARC;
713 else if (machine == bfd_mach_sparc_sparclet)
714 arch_flags = M_SPARCLET;
719 case 0: arch_flags = M_68010; break;
720 case bfd_mach_m68000: arch_flags = M_UNKNOWN; *unknown = false; break;
721 case bfd_mach_m68010: arch_flags = M_68010; break;
722 case bfd_mach_m68020: arch_flags = M_68020; break;
723 default: arch_flags = M_UNKNOWN; break;
728 if (machine == 0) arch_flags = M_386;
732 if (machine == 0) arch_flags = M_29K;
736 if (machine == 0) arch_flags = M_ARM;
743 case 3000: arch_flags = M_MIPS1; break;
744 case 4000: /* mips3 */
746 case 8000: /* mips4 */
748 case 6000: arch_flags = M_MIPS2; break;
749 default: arch_flags = M_UNKNOWN; break;
755 case 0: arch_flags = M_NS32532; break;
756 case 32032: arch_flags = M_NS32032; break;
757 case 32532: arch_flags = M_NS32532; break;
758 default: arch_flags = M_UNKNOWN; break;
767 arch_flags = M_UNKNOWN;
770 if (arch_flags != M_UNKNOWN)
779 aout_@var{size}_set_arch_mach
782 boolean aout_@var{size}_set_arch_mach,
784 enum bfd_architecture arch,
785 unsigned long machine));
788 Set the architecture and the machine of the BFD @var{abfd} to the
789 values @var{arch} and @var{machine}. Verify that @var{abfd}'s format
790 can support the architecture required.
794 NAME(aout,set_arch_mach) (abfd, arch, machine)
796 enum bfd_architecture arch;
797 unsigned long machine;
799 if (! bfd_default_set_arch_mach (abfd, arch, machine))
802 if (arch != bfd_arch_unknown)
806 NAME(aout,machine_type) (arch, machine, &unknown);
811 /* Determine the size of a relocation entry */
816 obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE;
819 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
823 return (*aout_backend_info(abfd)->set_sizes) (abfd);
827 adjust_o_magic (abfd, execp)
829 struct internal_exec *execp;
831 file_ptr pos = adata (abfd).exec_bytes_size;
836 obj_textsec(abfd)->filepos = pos;
837 if (!obj_textsec(abfd)->user_set_vma)
838 obj_textsec(abfd)->vma = vma;
840 vma = obj_textsec(abfd)->vma;
842 pos += obj_textsec(abfd)->_raw_size;
843 vma += obj_textsec(abfd)->_raw_size;
846 if (!obj_datasec(abfd)->user_set_vma)
848 #if 0 /* ?? Does alignment in the file image really matter? */
849 pad = align_power (vma, obj_datasec(abfd)->alignment_power) - vma;
851 obj_textsec(abfd)->_raw_size += pad;
854 obj_datasec(abfd)->vma = vma;
857 vma = obj_datasec(abfd)->vma;
858 obj_datasec(abfd)->filepos = pos;
859 pos += obj_datasec(abfd)->_raw_size;
860 vma += obj_datasec(abfd)->_raw_size;
863 if (!obj_bsssec(abfd)->user_set_vma)
866 pad = align_power (vma, obj_bsssec(abfd)->alignment_power) - vma;
868 obj_datasec(abfd)->_raw_size += pad;
871 obj_bsssec(abfd)->vma = vma;
875 /* The VMA of the .bss section is set by the the VMA of the
876 .data section plus the size of the .data section. We may
877 need to add padding bytes to make this true. */
878 pad = obj_bsssec (abfd)->vma - vma;
881 obj_datasec (abfd)->_raw_size += pad;
885 obj_bsssec(abfd)->filepos = pos;
887 /* Fix up the exec header. */
888 execp->a_text = obj_textsec(abfd)->_raw_size;
889 execp->a_data = obj_datasec(abfd)->_raw_size;
890 execp->a_bss = obj_bsssec(abfd)->_raw_size;
891 N_SET_MAGIC (*execp, OMAGIC);
895 adjust_z_magic (abfd, execp)
897 struct internal_exec *execp;
899 bfd_size_type data_pad, text_pad;
901 CONST struct aout_backend_data *abdp;
902 int ztih; /* Nonzero if text includes exec header. */
904 abdp = aout_backend_info (abfd);
908 && (abdp->text_includes_header
909 || obj_aout_subformat (abfd) == q_magic_format));
910 obj_textsec(abfd)->filepos = (ztih
911 ? adata(abfd).exec_bytes_size
912 : adata(abfd).zmagic_disk_block_size);
913 if (! obj_textsec(abfd)->user_set_vma)
915 /* ?? Do we really need to check for relocs here? */
916 obj_textsec(abfd)->vma = ((abfd->flags & HAS_RELOC)
919 ? (abdp->default_text_vma
920 + adata(abfd).exec_bytes_size)
921 : abdp->default_text_vma));
926 /* The .text section is being loaded at an unusual address. We
927 may need to pad it such that the .data section starts at a page
930 text_pad = ((obj_textsec (abfd)->filepos - obj_textsec (abfd)->vma)
931 & (adata (abfd).page_size - 1));
933 text_pad = ((- obj_textsec (abfd)->vma)
934 & (adata (abfd).page_size - 1));
937 /* Find start of data. */
940 text_end = obj_textsec (abfd)->filepos + obj_textsec (abfd)->_raw_size;
941 text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
945 /* Note that if page_size == zmagic_disk_block_size, then
946 filepos == page_size, and this case is the same as the ztih
948 text_end = obj_textsec (abfd)->_raw_size;
949 text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
950 text_end += obj_textsec (abfd)->filepos;
952 obj_textsec(abfd)->_raw_size += text_pad;
953 text_end += text_pad;
956 if (!obj_datasec(abfd)->user_set_vma)
959 vma = obj_textsec(abfd)->vma + obj_textsec(abfd)->_raw_size;
960 obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
962 if (abdp && abdp->zmagic_mapped_contiguous)
964 text_pad = (obj_datasec(abfd)->vma
965 - obj_textsec(abfd)->vma
966 - obj_textsec(abfd)->_raw_size);
967 obj_textsec(abfd)->_raw_size += text_pad;
969 obj_datasec(abfd)->filepos = (obj_textsec(abfd)->filepos
970 + obj_textsec(abfd)->_raw_size);
972 /* Fix up exec header while we're at it. */
973 execp->a_text = obj_textsec(abfd)->_raw_size;
974 if (ztih && (!abdp || (abdp && !abdp->exec_header_not_counted)))
975 execp->a_text += adata(abfd).exec_bytes_size;
976 if (obj_aout_subformat (abfd) == q_magic_format)
977 N_SET_MAGIC (*execp, QMAGIC);
979 N_SET_MAGIC (*execp, ZMAGIC);
981 /* Spec says data section should be rounded up to page boundary. */
982 obj_datasec(abfd)->_raw_size
983 = align_power (obj_datasec(abfd)->_raw_size,
984 obj_bsssec(abfd)->alignment_power);
985 execp->a_data = BFD_ALIGN (obj_datasec(abfd)->_raw_size,
986 adata(abfd).page_size);
987 data_pad = execp->a_data - obj_datasec(abfd)->_raw_size;
990 if (!obj_bsssec(abfd)->user_set_vma)
991 obj_bsssec(abfd)->vma = (obj_datasec(abfd)->vma
992 + obj_datasec(abfd)->_raw_size);
993 /* If the BSS immediately follows the data section and extra space
994 in the page is left after the data section, fudge data
995 in the header so that the bss section looks smaller by that
996 amount. We'll start the bss section there, and lie to the OS.
997 (Note that a linker script, as well as the above assignment,
998 could have explicitly set the BSS vma to immediately follow
999 the data section.) */
1000 if (align_power (obj_bsssec(abfd)->vma, obj_bsssec(abfd)->alignment_power)
1001 == obj_datasec(abfd)->vma + obj_datasec(abfd)->_raw_size)
1002 execp->a_bss = (data_pad > obj_bsssec(abfd)->_raw_size) ? 0 :
1003 obj_bsssec(abfd)->_raw_size - data_pad;
1005 execp->a_bss = obj_bsssec(abfd)->_raw_size;
1009 adjust_n_magic (abfd, execp)
1011 struct internal_exec *execp;
1013 file_ptr pos = adata(abfd).exec_bytes_size;
1018 obj_textsec(abfd)->filepos = pos;
1019 if (!obj_textsec(abfd)->user_set_vma)
1020 obj_textsec(abfd)->vma = vma;
1022 vma = obj_textsec(abfd)->vma;
1023 pos += obj_textsec(abfd)->_raw_size;
1024 vma += obj_textsec(abfd)->_raw_size;
1027 obj_datasec(abfd)->filepos = pos;
1028 if (!obj_datasec(abfd)->user_set_vma)
1029 obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
1030 vma = obj_datasec(abfd)->vma;
1032 /* Since BSS follows data immediately, see if it needs alignment. */
1033 vma += obj_datasec(abfd)->_raw_size;
1034 pad = align_power (vma, obj_bsssec(abfd)->alignment_power) - vma;
1035 obj_datasec(abfd)->_raw_size += pad;
1036 pos += obj_datasec(abfd)->_raw_size;
1039 if (!obj_bsssec(abfd)->user_set_vma)
1040 obj_bsssec(abfd)->vma = vma;
1042 vma = obj_bsssec(abfd)->vma;
1044 /* Fix up exec header. */
1045 execp->a_text = obj_textsec(abfd)->_raw_size;
1046 execp->a_data = obj_datasec(abfd)->_raw_size;
1047 execp->a_bss = obj_bsssec(abfd)->_raw_size;
1048 N_SET_MAGIC (*execp, NMAGIC);
1052 NAME(aout,adjust_sizes_and_vmas) (abfd, text_size, text_end)
1054 bfd_size_type *text_size;
1057 struct internal_exec *execp = exec_hdr (abfd);
1059 if (! NAME(aout,make_sections) (abfd))
1062 if (adata(abfd).magic != undecided_magic)
1065 obj_textsec(abfd)->_raw_size =
1066 align_power(obj_textsec(abfd)->_raw_size,
1067 obj_textsec(abfd)->alignment_power);
1069 *text_size = obj_textsec (abfd)->_raw_size;
1070 /* Rule (heuristic) for when to pad to a new page. Note that there
1071 are (at least) two ways demand-paged (ZMAGIC) files have been
1072 handled. Most Berkeley-based systems start the text segment at
1073 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text
1074 segment right after the exec header; the latter is counted in the
1075 text segment size, and is paged in by the kernel with the rest of
1078 /* This perhaps isn't the right way to do this, but made it simpler for me
1079 to understand enough to implement it. Better would probably be to go
1080 right from BFD flags to alignment/positioning characteristics. But the
1081 old code was sloppy enough about handling the flags, and had enough
1082 other magic, that it was a little hard for me to understand. I think
1083 I understand it better now, but I haven't time to do the cleanup this
1086 if (abfd->flags & D_PAGED)
1087 /* Whether or not WP_TEXT is set -- let D_PAGED override. */
1088 adata(abfd).magic = z_magic;
1089 else if (abfd->flags & WP_TEXT)
1090 adata(abfd).magic = n_magic;
1092 adata(abfd).magic = o_magic;
1094 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1096 fprintf (stderr, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1098 switch (adata(abfd).magic) {
1099 case n_magic: str = "NMAGIC"; break;
1100 case o_magic: str = "OMAGIC"; break;
1101 case z_magic: str = "ZMAGIC"; break;
1106 obj_textsec(abfd)->vma, obj_textsec(abfd)->_raw_size,
1107 obj_textsec(abfd)->alignment_power,
1108 obj_datasec(abfd)->vma, obj_datasec(abfd)->_raw_size,
1109 obj_datasec(abfd)->alignment_power,
1110 obj_bsssec(abfd)->vma, obj_bsssec(abfd)->_raw_size,
1111 obj_bsssec(abfd)->alignment_power);
1115 switch (adata(abfd).magic)
1118 adjust_o_magic (abfd, execp);
1121 adjust_z_magic (abfd, execp);
1124 adjust_n_magic (abfd, execp);
1130 #ifdef BFD_AOUT_DEBUG
1131 fprintf (stderr, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1132 obj_textsec(abfd)->vma, obj_textsec(abfd)->_raw_size,
1133 obj_textsec(abfd)->filepos,
1134 obj_datasec(abfd)->vma, obj_datasec(abfd)->_raw_size,
1135 obj_datasec(abfd)->filepos,
1136 obj_bsssec(abfd)->vma, obj_bsssec(abfd)->_raw_size);
1144 aout_@var{size}_new_section_hook
1147 boolean aout_@var{size}_new_section_hook,
1149 asection *newsect));
1152 Called by the BFD in response to a @code{bfd_make_section}
1156 NAME(aout,new_section_hook) (abfd, newsect)
1160 /* align to double at least */
1161 newsect->alignment_power = bfd_get_arch_info(abfd)->section_align_power;
1164 if (bfd_get_format (abfd) == bfd_object)
1166 if (obj_textsec(abfd) == NULL && !strcmp(newsect->name, ".text")) {
1167 obj_textsec(abfd)= newsect;
1168 newsect->target_index = N_TEXT;
1172 if (obj_datasec(abfd) == NULL && !strcmp(newsect->name, ".data")) {
1173 obj_datasec(abfd) = newsect;
1174 newsect->target_index = N_DATA;
1178 if (obj_bsssec(abfd) == NULL && !strcmp(newsect->name, ".bss")) {
1179 obj_bsssec(abfd) = newsect;
1180 newsect->target_index = N_BSS;
1186 /* We allow more than three sections internally */
1191 NAME(aout,set_section_contents) (abfd, section, location, offset, count)
1196 bfd_size_type count;
1199 bfd_size_type text_size;
1201 if (! abfd->output_has_begun)
1203 if (! NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
1207 if (section == obj_bsssec (abfd))
1209 bfd_set_error (bfd_error_no_contents);
1213 if (section != obj_textsec (abfd)
1214 && section != obj_datasec (abfd))
1216 (*_bfd_error_handler)
1217 ("%s: can not represent section `%s' in a.out object file format",
1218 bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
1219 bfd_set_error (bfd_error_nonrepresentable_section);
1225 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1226 || bfd_write (location, 1, count, abfd) != count)
1233 /* Read the external symbols from an a.out file. */
1236 aout_get_external_symbols (abfd)
1239 if (obj_aout_external_syms (abfd) == (struct external_nlist *) NULL)
1241 bfd_size_type count;
1242 struct external_nlist *syms;
1244 count = exec_hdr (abfd)->a_syms / EXTERNAL_NLIST_SIZE;
1247 if (bfd_get_file_window (abfd,
1248 obj_sym_filepos (abfd), exec_hdr (abfd)->a_syms,
1249 &obj_aout_sym_window (abfd), true) == false)
1251 syms = (struct external_nlist *) obj_aout_sym_window (abfd).data;
1253 /* We allocate using malloc to make the values easy to free
1254 later on. If we put them on the objalloc it might not be
1255 possible to free them. */
1256 syms = ((struct external_nlist *)
1257 bfd_malloc ((size_t) count * EXTERNAL_NLIST_SIZE));
1258 if (syms == (struct external_nlist *) NULL && count != 0)
1261 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1262 || (bfd_read (syms, 1, exec_hdr (abfd)->a_syms, abfd)
1263 != exec_hdr (abfd)->a_syms))
1270 obj_aout_external_syms (abfd) = syms;
1271 obj_aout_external_sym_count (abfd) = count;
1274 if (obj_aout_external_strings (abfd) == NULL
1275 && exec_hdr (abfd)->a_syms != 0)
1277 unsigned char string_chars[BYTES_IN_WORD];
1278 bfd_size_type stringsize;
1281 /* Get the size of the strings. */
1282 if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
1283 || (bfd_read ((PTR) string_chars, BYTES_IN_WORD, 1, abfd)
1286 stringsize = GET_WORD (abfd, string_chars);
1289 if (bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize,
1290 &obj_aout_string_window (abfd), true) == false)
1292 strings = (char *) obj_aout_string_window (abfd).data;
1294 strings = (char *) bfd_malloc ((size_t) stringsize + 1);
1295 if (strings == NULL)
1298 /* Skip space for the string count in the buffer for convenience
1299 when using indexes. */
1300 if (bfd_read (strings + BYTES_IN_WORD, 1, stringsize - BYTES_IN_WORD,
1302 != stringsize - BYTES_IN_WORD)
1309 /* Ensure that a zero index yields an empty string. */
1312 strings[stringsize - 1] = 0;
1314 obj_aout_external_strings (abfd) = strings;
1315 obj_aout_external_string_size (abfd) = stringsize;
1321 /* Translate an a.out symbol into a BFD symbol. The desc, other, type
1322 and symbol->value fields of CACHE_PTR will be set from the a.out
1323 nlist structure. This function is responsible for setting
1324 symbol->flags and symbol->section, and adjusting symbol->value. */
1327 translate_from_native_sym_flags (abfd, cache_ptr)
1329 aout_symbol_type *cache_ptr;
1333 if ((cache_ptr->type & N_STAB) != 0
1334 || cache_ptr->type == N_FN)
1338 /* This is a debugging symbol. */
1340 cache_ptr->symbol.flags = BSF_DEBUGGING;
1342 /* Work out the symbol section. */
1343 switch (cache_ptr->type & N_TYPE)
1347 sec = obj_textsec (abfd);
1350 sec = obj_datasec (abfd);
1353 sec = obj_bsssec (abfd);
1357 sec = bfd_abs_section_ptr;
1361 cache_ptr->symbol.section = sec;
1362 cache_ptr->symbol.value -= sec->vma;
1367 /* Get the default visibility. This does not apply to all types, so
1368 we just hold it in a local variable to use if wanted. */
1369 if ((cache_ptr->type & N_EXT) == 0)
1370 visible = BSF_LOCAL;
1372 visible = BSF_GLOBAL;
1374 switch (cache_ptr->type)
1377 case N_ABS: case N_ABS | N_EXT:
1378 cache_ptr->symbol.section = bfd_abs_section_ptr;
1379 cache_ptr->symbol.flags = visible;
1382 case N_UNDF | N_EXT:
1383 if (cache_ptr->symbol.value != 0)
1385 /* This is a common symbol. */
1386 cache_ptr->symbol.flags = BSF_GLOBAL;
1387 cache_ptr->symbol.section = bfd_com_section_ptr;
1391 cache_ptr->symbol.flags = 0;
1392 cache_ptr->symbol.section = bfd_und_section_ptr;
1396 case N_TEXT: case N_TEXT | N_EXT:
1397 cache_ptr->symbol.section = obj_textsec (abfd);
1398 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1399 cache_ptr->symbol.flags = visible;
1402 /* N_SETV symbols used to represent set vectors placed in the
1403 data section. They are no longer generated. Theoretically,
1404 it was possible to extract the entries and combine them with
1405 new ones, although I don't know if that was ever actually
1406 done. Unless that feature is restored, treat them as data
1408 case N_SETV: case N_SETV | N_EXT:
1409 case N_DATA: case N_DATA | N_EXT:
1410 cache_ptr->symbol.section = obj_datasec (abfd);
1411 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1412 cache_ptr->symbol.flags = visible;
1415 case N_BSS: case N_BSS | N_EXT:
1416 cache_ptr->symbol.section = obj_bsssec (abfd);
1417 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1418 cache_ptr->symbol.flags = visible;
1421 case N_SETA: case N_SETA | N_EXT:
1422 case N_SETT: case N_SETT | N_EXT:
1423 case N_SETD: case N_SETD | N_EXT:
1424 case N_SETB: case N_SETB | N_EXT:
1426 /* This code is no longer needed. It used to be used to make
1427 the linker handle set symbols, but they are now handled in
1428 the add_symbols routine instead. */
1431 arelent_chain *reloc;
1432 asection *into_section;
1434 /* This is a set symbol. The name of the symbol is the name
1435 of the set (e.g., __CTOR_LIST__). The value of the symbol
1436 is the value to add to the set. We create a section with
1437 the same name as the symbol, and add a reloc to insert the
1438 appropriate value into the section.
1440 This action is actually obsolete; it used to make the
1441 linker do the right thing, but the linker no longer uses
1444 section = bfd_get_section_by_name (abfd, cache_ptr->symbol.name);
1445 if (section == NULL)
1449 copy = bfd_alloc (abfd, strlen (cache_ptr->symbol.name) + 1);
1453 strcpy (copy, cache_ptr->symbol.name);
1454 section = bfd_make_section (abfd, copy);
1455 if (section == NULL)
1459 reloc = (arelent_chain *) bfd_alloc (abfd, sizeof (arelent_chain));
1463 /* Build a relocation entry for the constructor. */
1464 switch (cache_ptr->type & N_TYPE)
1467 into_section = bfd_abs_section_ptr;
1468 cache_ptr->type = N_ABS;
1471 into_section = obj_textsec (abfd);
1472 cache_ptr->type = N_TEXT;
1475 into_section = obj_datasec (abfd);
1476 cache_ptr->type = N_DATA;
1479 into_section = obj_bsssec (abfd);
1480 cache_ptr->type = N_BSS;
1484 /* Build a relocation pointing into the constructor section
1485 pointing at the symbol in the set vector specified. */
1486 reloc->relent.addend = cache_ptr->symbol.value;
1487 cache_ptr->symbol.section = into_section;
1488 reloc->relent.sym_ptr_ptr = into_section->symbol_ptr_ptr;
1490 /* We modify the symbol to belong to a section depending upon
1491 the name of the symbol, and add to the size of the section
1492 to contain a pointer to the symbol. Build a reloc entry to
1493 relocate to this symbol attached to this section. */
1494 section->flags = SEC_CONSTRUCTOR | SEC_RELOC;
1496 section->reloc_count++;
1497 section->alignment_power = 2;
1499 reloc->next = section->constructor_chain;
1500 section->constructor_chain = reloc;
1501 reloc->relent.address = section->_raw_size;
1502 section->_raw_size += BYTES_IN_WORD;
1504 reloc->relent.howto = CTOR_TABLE_RELOC_HOWTO(abfd);
1508 switch (cache_ptr->type & N_TYPE)
1511 cache_ptr->symbol.section = bfd_abs_section_ptr;
1514 cache_ptr->symbol.section = obj_textsec (abfd);
1517 cache_ptr->symbol.section = obj_datasec (abfd);
1520 cache_ptr->symbol.section = obj_bsssec (abfd);
1524 cache_ptr->symbol.flags |= BSF_CONSTRUCTOR;
1529 /* This symbol is the text of a warning message. The next
1530 symbol is the symbol to associate the warning with. If a
1531 reference is made to that symbol, a warning is issued. */
1532 cache_ptr->symbol.flags = BSF_DEBUGGING | BSF_WARNING;
1533 cache_ptr->symbol.section = bfd_abs_section_ptr;
1536 case N_INDR: case N_INDR | N_EXT:
1537 /* An indirect symbol. This consists of two symbols in a row.
1538 The first symbol is the name of the indirection. The second
1539 symbol is the name of the target. A reference to the first
1540 symbol becomes a reference to the second. */
1541 cache_ptr->symbol.flags = BSF_DEBUGGING | BSF_INDIRECT | visible;
1542 cache_ptr->symbol.section = bfd_ind_section_ptr;
1546 cache_ptr->symbol.section = bfd_und_section_ptr;
1547 cache_ptr->symbol.flags = BSF_WEAK;
1551 cache_ptr->symbol.section = bfd_abs_section_ptr;
1552 cache_ptr->symbol.flags = BSF_WEAK;
1556 cache_ptr->symbol.section = obj_textsec (abfd);
1557 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1558 cache_ptr->symbol.flags = BSF_WEAK;
1562 cache_ptr->symbol.section = obj_datasec (abfd);
1563 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1564 cache_ptr->symbol.flags = BSF_WEAK;
1568 cache_ptr->symbol.section = obj_bsssec (abfd);
1569 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1570 cache_ptr->symbol.flags = BSF_WEAK;
1577 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
1580 translate_to_native_sym_flags (abfd, cache_ptr, sym_pointer)
1583 struct external_nlist *sym_pointer;
1585 bfd_vma value = cache_ptr->value;
1589 /* Mask out any existing type bits in case copying from one section
1591 sym_pointer->e_type[0] &= ~N_TYPE;
1593 sec = bfd_get_section (cache_ptr);
1598 /* This case occurs, e.g., for the *DEBUG* section of a COFF
1600 (*_bfd_error_handler)
1601 ("%s: can not represent section for symbol `%s' in a.out object file format",
1602 bfd_get_filename (abfd),
1603 cache_ptr->name != NULL ? cache_ptr->name : "*unknown*");
1604 bfd_set_error (bfd_error_nonrepresentable_section);
1608 if (sec->output_section != NULL)
1610 off = sec->output_offset;
1611 sec = sec->output_section;
1614 if (bfd_is_abs_section (sec))
1615 sym_pointer->e_type[0] |= N_ABS;
1616 else if (sec == obj_textsec (abfd))
1617 sym_pointer->e_type[0] |= N_TEXT;
1618 else if (sec == obj_datasec (abfd))
1619 sym_pointer->e_type[0] |= N_DATA;
1620 else if (sec == obj_bsssec (abfd))
1621 sym_pointer->e_type[0] |= N_BSS;
1622 else if (bfd_is_und_section (sec))
1623 sym_pointer->e_type[0] = N_UNDF | N_EXT;
1624 else if (bfd_is_ind_section (sec))
1625 sym_pointer->e_type[0] = N_INDR;
1626 else if (bfd_is_com_section (sec))
1627 sym_pointer->e_type[0] = N_UNDF | N_EXT;
1630 (*_bfd_error_handler)
1631 ("%s: can not represent section `%s' in a.out object file format",
1632 bfd_get_filename (abfd), bfd_get_section_name (abfd, sec));
1633 bfd_set_error (bfd_error_nonrepresentable_section);
1637 /* Turn the symbol from section relative to absolute again */
1638 value += sec->vma + off;
1640 if ((cache_ptr->flags & BSF_WARNING) != 0)
1641 sym_pointer->e_type[0] = N_WARNING;
1643 if ((cache_ptr->flags & BSF_DEBUGGING) != 0)
1644 sym_pointer->e_type[0] = ((aout_symbol_type *) cache_ptr)->type;
1645 else if ((cache_ptr->flags & BSF_GLOBAL) != 0)
1646 sym_pointer->e_type[0] |= N_EXT;
1648 if ((cache_ptr->flags & BSF_CONSTRUCTOR) != 0)
1650 int type = ((aout_symbol_type *) cache_ptr)->type;
1653 case N_ABS: type = N_SETA; break;
1654 case N_TEXT: type = N_SETT; break;
1655 case N_DATA: type = N_SETD; break;
1656 case N_BSS: type = N_SETB; break;
1658 sym_pointer->e_type[0] = type;
1661 if ((cache_ptr->flags & BSF_WEAK) != 0)
1665 switch (sym_pointer->e_type[0] & N_TYPE)
1668 case N_ABS: type = N_WEAKA; break;
1669 case N_TEXT: type = N_WEAKT; break;
1670 case N_DATA: type = N_WEAKD; break;
1671 case N_BSS: type = N_WEAKB; break;
1672 case N_UNDF: type = N_WEAKU; break;
1674 sym_pointer->e_type[0] = type;
1677 PUT_WORD(abfd, value, sym_pointer->e_value);
1682 /* Native-level interface to symbols. */
1685 NAME(aout,make_empty_symbol) (abfd)
1688 aout_symbol_type *new =
1689 (aout_symbol_type *)bfd_zalloc (abfd, sizeof (aout_symbol_type));
1692 new->symbol.the_bfd = abfd;
1694 return &new->symbol;
1697 /* Translate a set of internal symbols into external symbols. */
1700 NAME(aout,translate_symbol_table) (abfd, in, ext, count, str, strsize, dynamic)
1702 aout_symbol_type *in;
1703 struct external_nlist *ext;
1704 bfd_size_type count;
1706 bfd_size_type strsize;
1709 struct external_nlist *ext_end;
1711 ext_end = ext + count;
1712 for (; ext < ext_end; ext++, in++)
1716 x = GET_WORD (abfd, ext->e_strx);
1717 in->symbol.the_bfd = abfd;
1719 /* For the normal symbols, the zero index points at the number
1720 of bytes in the string table but is to be interpreted as the
1721 null string. For the dynamic symbols, the number of bytes in
1722 the string table is stored in the __DYNAMIC structure and the
1723 zero index points at an actual string. */
1724 if (x == 0 && ! dynamic)
1725 in->symbol.name = "";
1726 else if (x < strsize)
1727 in->symbol.name = str + x;
1731 in->symbol.value = GET_SWORD (abfd, ext->e_value);
1732 in->desc = bfd_h_get_16 (abfd, ext->e_desc);
1733 in->other = bfd_h_get_8 (abfd, ext->e_other);
1734 in->type = bfd_h_get_8 (abfd, ext->e_type);
1735 in->symbol.udata.p = NULL;
1737 if (! translate_from_native_sym_flags (abfd, in))
1741 in->symbol.flags |= BSF_DYNAMIC;
1747 /* We read the symbols into a buffer, which is discarded when this
1748 function exits. We read the strings into a buffer large enough to
1749 hold them all plus all the cached symbol entries. */
1752 NAME(aout,slurp_symbol_table) (abfd)
1755 struct external_nlist *old_external_syms;
1756 aout_symbol_type *cached;
1759 /* If there's no work to be done, don't do any */
1760 if (obj_aout_symbols (abfd) != (aout_symbol_type *) NULL)
1763 old_external_syms = obj_aout_external_syms (abfd);
1765 if (! aout_get_external_symbols (abfd))
1768 cached_size = (obj_aout_external_sym_count (abfd)
1769 * sizeof (aout_symbol_type));
1770 cached = (aout_symbol_type *) bfd_malloc (cached_size);
1771 if (cached == NULL && cached_size != 0)
1773 if (cached_size != 0)
1774 memset (cached, 0, cached_size);
1776 /* Convert from external symbol information to internal. */
1777 if (! (NAME(aout,translate_symbol_table)
1779 obj_aout_external_syms (abfd),
1780 obj_aout_external_sym_count (abfd),
1781 obj_aout_external_strings (abfd),
1782 obj_aout_external_string_size (abfd),
1789 bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd);
1791 obj_aout_symbols (abfd) = cached;
1793 /* It is very likely that anybody who calls this function will not
1794 want the external symbol information, so if it was allocated
1795 because of our call to aout_get_external_symbols, we free it up
1796 right away to save space. */
1797 if (old_external_syms == (struct external_nlist *) NULL
1798 && obj_aout_external_syms (abfd) != (struct external_nlist *) NULL)
1801 bfd_free_window (&obj_aout_sym_window (abfd));
1803 free (obj_aout_external_syms (abfd));
1805 obj_aout_external_syms (abfd) = NULL;
1811 /* We use a hash table when writing out symbols so that we only write
1812 out a particular string once. This helps particularly when the
1813 linker writes out stabs debugging entries, because each different
1814 contributing object file tends to have many duplicate stabs
1817 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1818 if BFD_TRADITIONAL_FORMAT is set. */
1820 static bfd_size_type add_to_stringtab
1821 PARAMS ((bfd *, struct bfd_strtab_hash *, const char *, boolean));
1822 static boolean emit_stringtab PARAMS ((bfd *, struct bfd_strtab_hash *));
1824 /* Get the index of a string in a strtab, adding it if it is not
1827 static INLINE bfd_size_type
1828 add_to_stringtab (abfd, tab, str, copy)
1830 struct bfd_strtab_hash *tab;
1835 bfd_size_type index;
1837 /* An index of 0 always means the empty string. */
1838 if (str == 0 || *str == '\0')
1841 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1842 doesn't understand a hashed string table. */
1844 if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1847 index = _bfd_stringtab_add (tab, str, hash, copy);
1849 if (index != (bfd_size_type) -1)
1851 /* Add BYTES_IN_WORD to the return value to account for the
1852 space taken up by the string table size. */
1853 index += BYTES_IN_WORD;
1859 /* Write out a strtab. ABFD is already at the right location in the
1863 emit_stringtab (abfd, tab)
1865 struct bfd_strtab_hash *tab;
1867 bfd_byte buffer[BYTES_IN_WORD];
1869 /* The string table starts with the size. */
1870 PUT_WORD (abfd, _bfd_stringtab_size (tab) + BYTES_IN_WORD, buffer);
1871 if (bfd_write ((PTR) buffer, 1, BYTES_IN_WORD, abfd) != BYTES_IN_WORD)
1874 return _bfd_stringtab_emit (abfd, tab);
1878 NAME(aout,write_syms) (abfd)
1881 unsigned int count ;
1882 asymbol **generic = bfd_get_outsymbols (abfd);
1883 struct bfd_strtab_hash *strtab;
1885 strtab = _bfd_stringtab_init ();
1889 for (count = 0; count < bfd_get_symcount (abfd); count++)
1891 asymbol *g = generic[count];
1893 struct external_nlist nsp;
1895 indx = add_to_stringtab (abfd, strtab, g->name, false);
1896 if (indx == (bfd_size_type) -1)
1898 PUT_WORD (abfd, indx, (bfd_byte *) nsp.e_strx);
1900 if (bfd_asymbol_flavour(g) == abfd->xvec->flavour)
1902 bfd_h_put_16(abfd, aout_symbol(g)->desc, nsp.e_desc);
1903 bfd_h_put_8(abfd, aout_symbol(g)->other, nsp.e_other);
1904 bfd_h_put_8(abfd, aout_symbol(g)->type, nsp.e_type);
1908 bfd_h_put_16(abfd,0, nsp.e_desc);
1909 bfd_h_put_8(abfd, 0, nsp.e_other);
1910 bfd_h_put_8(abfd, 0, nsp.e_type);
1913 if (! translate_to_native_sym_flags (abfd, g, &nsp))
1916 if (bfd_write((PTR)&nsp,1,EXTERNAL_NLIST_SIZE, abfd)
1917 != EXTERNAL_NLIST_SIZE)
1920 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1921 here, at the end. */
1925 if (! emit_stringtab (abfd, strtab))
1928 _bfd_stringtab_free (strtab);
1933 _bfd_stringtab_free (strtab);
1939 NAME(aout,get_symtab) (abfd, location)
1943 unsigned int counter = 0;
1944 aout_symbol_type *symbase;
1946 if (!NAME(aout,slurp_symbol_table)(abfd))
1949 for (symbase = obj_aout_symbols(abfd); counter++ < bfd_get_symcount (abfd);)
1950 *(location++) = (asymbol *)( symbase++);
1952 return bfd_get_symcount (abfd);
1956 /* Standard reloc stuff */
1957 /* Output standard relocation information to a file in target byte order. */
1959 extern void NAME(aout,swap_std_reloc_out)
1960 PARAMS ((bfd *, arelent *, struct reloc_std_external *));
1963 NAME(aout,swap_std_reloc_out) (abfd, g, natptr)
1966 struct reloc_std_external *natptr;
1969 asymbol *sym = *(g->sym_ptr_ptr);
1971 unsigned int r_length;
1973 int r_baserel, r_jmptable, r_relative;
1974 asection *output_section = sym->section->output_section;
1976 PUT_WORD(abfd, g->address, natptr->r_address);
1978 r_length = g->howto->size ; /* Size as a power of two */
1979 r_pcrel = (int) g->howto->pc_relative; /* Relative to PC? */
1980 /* XXX This relies on relocs coming from a.out files. */
1981 r_baserel = (g->howto->type & 8) != 0;
1982 r_jmptable = (g->howto->type & 16) != 0;
1983 r_relative = (g->howto->type & 32) != 0;
1986 /* For a standard reloc, the addend is in the object file. */
1987 r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
1990 /* name was clobbered by aout_write_syms to be symbol index */
1992 /* If this relocation is relative to a symbol then set the
1993 r_index to the symbols index, and the r_extern bit.
1995 Absolute symbols can come in in two ways, either as an offset
1996 from the abs section, or as a symbol which has an abs value.
2001 if (bfd_is_com_section (output_section)
2002 || bfd_is_abs_section (output_section)
2003 || bfd_is_und_section (output_section))
2005 if (bfd_abs_section_ptr->symbol == sym)
2007 /* Whoops, looked like an abs symbol, but is really an offset
2008 from the abs section */
2014 /* Fill in symbol */
2016 r_index = (*(g->sym_ptr_ptr))->KEEPIT;
2022 /* Just an ordinary section */
2024 r_index = output_section->target_index;
2027 /* now the fun stuff */
2028 if (bfd_header_big_endian (abfd)) {
2029 natptr->r_index[0] = r_index >> 16;
2030 natptr->r_index[1] = r_index >> 8;
2031 natptr->r_index[2] = r_index;
2033 (r_extern? RELOC_STD_BITS_EXTERN_BIG: 0)
2034 | (r_pcrel? RELOC_STD_BITS_PCREL_BIG: 0)
2035 | (r_baserel? RELOC_STD_BITS_BASEREL_BIG: 0)
2036 | (r_jmptable? RELOC_STD_BITS_JMPTABLE_BIG: 0)
2037 | (r_relative? RELOC_STD_BITS_RELATIVE_BIG: 0)
2038 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG);
2040 natptr->r_index[2] = r_index >> 16;
2041 natptr->r_index[1] = r_index >> 8;
2042 natptr->r_index[0] = r_index;
2044 (r_extern? RELOC_STD_BITS_EXTERN_LITTLE: 0)
2045 | (r_pcrel? RELOC_STD_BITS_PCREL_LITTLE: 0)
2046 | (r_baserel? RELOC_STD_BITS_BASEREL_LITTLE: 0)
2047 | (r_jmptable? RELOC_STD_BITS_JMPTABLE_LITTLE: 0)
2048 | (r_relative? RELOC_STD_BITS_RELATIVE_LITTLE: 0)
2049 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE);
2054 /* Extended stuff */
2055 /* Output extended relocation information to a file in target byte order. */
2057 extern void NAME(aout,swap_ext_reloc_out)
2058 PARAMS ((bfd *, arelent *, struct reloc_ext_external *));
2061 NAME(aout,swap_ext_reloc_out) (abfd, g, natptr)
2064 register struct reloc_ext_external *natptr;
2068 unsigned int r_type;
2069 unsigned int r_addend;
2070 asymbol *sym = *(g->sym_ptr_ptr);
2071 asection *output_section = sym->section->output_section;
2073 PUT_WORD (abfd, g->address, natptr->r_address);
2075 r_type = (unsigned int) g->howto->type;
2077 r_addend = g->addend;
2078 if ((sym->flags & BSF_SECTION_SYM) != 0)
2079 r_addend += (*(g->sym_ptr_ptr))->section->output_section->vma;
2081 /* If this relocation is relative to a symbol then set the
2082 r_index to the symbols index, and the r_extern bit.
2084 Absolute symbols can come in in two ways, either as an offset
2085 from the abs section, or as a symbol which has an abs value.
2086 check for that here. */
2088 if (bfd_is_abs_section (bfd_get_section (sym)))
2093 else if ((sym->flags & BSF_SECTION_SYM) == 0)
2095 if (bfd_is_und_section (bfd_get_section (sym))
2096 || (sym->flags & BSF_GLOBAL) != 0)
2100 r_index = (*(g->sym_ptr_ptr))->KEEPIT;
2104 /* Just an ordinary section */
2106 r_index = output_section->target_index;
2109 /* now the fun stuff */
2110 if (bfd_header_big_endian (abfd)) {
2111 natptr->r_index[0] = r_index >> 16;
2112 natptr->r_index[1] = r_index >> 8;
2113 natptr->r_index[2] = r_index;
2115 ((r_extern? RELOC_EXT_BITS_EXTERN_BIG: 0)
2116 | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG));
2118 natptr->r_index[2] = r_index >> 16;
2119 natptr->r_index[1] = r_index >> 8;
2120 natptr->r_index[0] = r_index;
2122 (r_extern? RELOC_EXT_BITS_EXTERN_LITTLE: 0)
2123 | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
2126 PUT_WORD (abfd, r_addend, natptr->r_addend);
2129 /* BFD deals internally with all things based from the section they're
2130 in. so, something in 10 bytes into a text section with a base of
2131 50 would have a symbol (.text+10) and know .text vma was 50.
2133 Aout keeps all it's symbols based from zero, so the symbol would
2134 contain 60. This macro subs the base of each section from the value
2135 to give the true offset from the section */
2138 #define MOVE_ADDRESS(ad) \
2140 /* undefined symbol */ \
2141 cache_ptr->sym_ptr_ptr = symbols + r_index; \
2142 cache_ptr->addend = ad; \
2144 /* defined, section relative. replace symbol with pointer to \
2145 symbol which points to section */ \
2146 switch (r_index) { \
2148 case N_TEXT | N_EXT: \
2149 cache_ptr->sym_ptr_ptr = obj_textsec(abfd)->symbol_ptr_ptr; \
2150 cache_ptr->addend = ad - su->textsec->vma; \
2153 case N_DATA | N_EXT: \
2154 cache_ptr->sym_ptr_ptr = obj_datasec(abfd)->symbol_ptr_ptr; \
2155 cache_ptr->addend = ad - su->datasec->vma; \
2158 case N_BSS | N_EXT: \
2159 cache_ptr->sym_ptr_ptr = obj_bsssec(abfd)->symbol_ptr_ptr; \
2160 cache_ptr->addend = ad - su->bsssec->vma; \
2164 case N_ABS | N_EXT: \
2165 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
2166 cache_ptr->addend = ad; \
2172 NAME(aout,swap_ext_reloc_in) (abfd, bytes, cache_ptr, symbols, symcount)
2174 struct reloc_ext_external *bytes;
2177 bfd_size_type symcount;
2179 unsigned int r_index;
2181 unsigned int r_type;
2182 struct aoutdata *su = &(abfd->tdata.aout_data->a);
2184 cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));
2186 /* now the fun stuff */
2187 if (bfd_header_big_endian (abfd)) {
2188 r_index = (bytes->r_index[0] << 16)
2189 | (bytes->r_index[1] << 8)
2190 | bytes->r_index[2];
2191 r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
2192 r_type = (bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
2193 >> RELOC_EXT_BITS_TYPE_SH_BIG;
2195 r_index = (bytes->r_index[2] << 16)
2196 | (bytes->r_index[1] << 8)
2197 | bytes->r_index[0];
2198 r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
2199 r_type = (bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
2200 >> RELOC_EXT_BITS_TYPE_SH_LITTLE;
2203 cache_ptr->howto = howto_table_ext + r_type;
2205 /* Base relative relocs are always against the symbol table,
2206 regardless of the setting of r_extern. r_extern just reflects
2207 whether the symbol the reloc is against is local or global. */
2208 if (r_type == RELOC_BASE10
2209 || r_type == RELOC_BASE13
2210 || r_type == RELOC_BASE22)
2213 if (r_extern && r_index > symcount)
2215 /* We could arrange to return an error, but it might be useful
2216 to see the file even if it is bad. */
2221 MOVE_ADDRESS(GET_SWORD(abfd, bytes->r_addend));
2225 NAME(aout,swap_std_reloc_in) (abfd, bytes, cache_ptr, symbols, symcount)
2227 struct reloc_std_external *bytes;
2230 bfd_size_type symcount;
2232 unsigned int r_index;
2234 unsigned int r_length;
2236 int r_baserel, r_jmptable, r_relative;
2237 struct aoutdata *su = &(abfd->tdata.aout_data->a);
2238 unsigned int howto_idx;
2240 cache_ptr->address = bfd_h_get_32 (abfd, bytes->r_address);
2242 /* now the fun stuff */
2243 if (bfd_header_big_endian (abfd)) {
2244 r_index = (bytes->r_index[0] << 16)
2245 | (bytes->r_index[1] << 8)
2246 | bytes->r_index[2];
2247 r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
2248 r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
2249 r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
2250 r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
2251 r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
2252 r_length = (bytes->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
2253 >> RELOC_STD_BITS_LENGTH_SH_BIG;
2255 r_index = (bytes->r_index[2] << 16)
2256 | (bytes->r_index[1] << 8)
2257 | bytes->r_index[0];
2258 r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
2259 r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
2260 r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE));
2261 r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
2262 r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_LITTLE));
2263 r_length = (bytes->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
2264 >> RELOC_STD_BITS_LENGTH_SH_LITTLE;
2267 howto_idx = r_length + 4 * r_pcrel + 8 * r_baserel
2268 + 16 * r_jmptable + 32 * r_relative;
2269 BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_std));
2270 cache_ptr->howto = howto_table_std + howto_idx;
2271 BFD_ASSERT (cache_ptr->howto->type != (unsigned int) -1);
2273 /* Base relative relocs are always against the symbol table,
2274 regardless of the setting of r_extern. r_extern just reflects
2275 whether the symbol the reloc is against is local or global. */
2279 if (r_extern && r_index > symcount)
2281 /* We could arrange to return an error, but it might be useful
2282 to see the file even if it is bad. */
2290 /* Read and swap the relocs for a section. */
2293 NAME(aout,slurp_reloc_table) (abfd, asect, symbols)
2299 bfd_size_type reloc_size;
2301 arelent *reloc_cache;
2303 unsigned int counter = 0;
2306 if (asect->relocation)
2309 if (asect->flags & SEC_CONSTRUCTOR)
2312 if (asect == obj_datasec (abfd))
2313 reloc_size = exec_hdr(abfd)->a_drsize;
2314 else if (asect == obj_textsec (abfd))
2315 reloc_size = exec_hdr(abfd)->a_trsize;
2316 else if (asect == obj_bsssec (abfd))
2320 bfd_set_error (bfd_error_invalid_operation);
2324 if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
2327 each_size = obj_reloc_entry_size (abfd);
2329 count = reloc_size / each_size;
2331 reloc_cache = (arelent *) bfd_malloc ((size_t) (count * sizeof (arelent)));
2332 if (reloc_cache == NULL && count != 0)
2334 memset (reloc_cache, 0, count * sizeof (arelent));
2336 relocs = bfd_malloc ((size_t) reloc_size);
2337 if (relocs == NULL && reloc_size != 0)
2343 if (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size)
2350 cache_ptr = reloc_cache;
2351 if (each_size == RELOC_EXT_SIZE)
2353 register struct reloc_ext_external *rptr =
2354 (struct reloc_ext_external *) relocs;
2356 for (; counter < count; counter++, rptr++, cache_ptr++)
2357 NAME(aout,swap_ext_reloc_in) (abfd, rptr, cache_ptr, symbols,
2358 bfd_get_symcount (abfd));
2362 register struct reloc_std_external *rptr =
2363 (struct reloc_std_external *) relocs;
2365 for (; counter < count; counter++, rptr++, cache_ptr++)
2366 MY_swap_std_reloc_in (abfd, rptr, cache_ptr, symbols,
2367 bfd_get_symcount (abfd));
2372 asect->relocation = reloc_cache;
2373 asect->reloc_count = cache_ptr - reloc_cache;
2378 /* Write out a relocation section into an object file. */
2381 NAME(aout,squirt_out_relocs) (abfd, section)
2386 unsigned char *native, *natptr;
2389 unsigned int count = section->reloc_count;
2392 if (count == 0 || section->orelocation == NULL)
2395 each_size = obj_reloc_entry_size (abfd);
2396 natsize = each_size * count;
2397 native = (unsigned char *) bfd_zalloc (abfd, natsize);
2401 generic = section->orelocation;
2403 if (each_size == RELOC_EXT_SIZE)
2405 for (natptr = native;
2407 --count, natptr += each_size, ++generic)
2408 NAME(aout,swap_ext_reloc_out) (abfd, *generic, (struct reloc_ext_external *)natptr);
2412 for (natptr = native;
2414 --count, natptr += each_size, ++generic)
2415 MY_swap_std_reloc_out(abfd, *generic, (struct reloc_std_external *)natptr);
2418 if ( bfd_write ((PTR) native, 1, natsize, abfd) != natsize) {
2419 bfd_release(abfd, native);
2422 bfd_release (abfd, native);
2427 /* This is stupid. This function should be a boolean predicate */
2429 NAME(aout,canonicalize_reloc) (abfd, section, relptr, symbols)
2435 arelent *tblptr = section->relocation;
2438 if (section == obj_bsssec (abfd))
2444 if (!(tblptr || NAME(aout,slurp_reloc_table)(abfd, section, symbols)))
2447 if (section->flags & SEC_CONSTRUCTOR) {
2448 arelent_chain *chain = section->constructor_chain;
2449 for (count = 0; count < section->reloc_count; count ++) {
2450 *relptr ++ = &chain->relent;
2451 chain = chain->next;
2455 tblptr = section->relocation;
2457 for (count = 0; count++ < section->reloc_count;)
2459 *relptr++ = tblptr++;
2464 return section->reloc_count;
2468 NAME(aout,get_reloc_upper_bound) (abfd, asect)
2472 if (bfd_get_format (abfd) != bfd_object) {
2473 bfd_set_error (bfd_error_invalid_operation);
2476 if (asect->flags & SEC_CONSTRUCTOR) {
2477 return (sizeof (arelent *) * (asect->reloc_count+1));
2480 if (asect == obj_datasec (abfd))
2481 return (sizeof (arelent *)
2482 * ((exec_hdr(abfd)->a_drsize / obj_reloc_entry_size (abfd))
2485 if (asect == obj_textsec (abfd))
2486 return (sizeof (arelent *)
2487 * ((exec_hdr(abfd)->a_trsize / obj_reloc_entry_size (abfd))
2490 if (asect == obj_bsssec (abfd))
2491 return sizeof (arelent *);
2493 if (asect == obj_bsssec (abfd))
2496 bfd_set_error (bfd_error_invalid_operation);
2502 NAME(aout,get_symtab_upper_bound) (abfd)
2505 if (!NAME(aout,slurp_symbol_table)(abfd))
2508 return (bfd_get_symcount (abfd)+1) * (sizeof (aout_symbol_type *));
2513 NAME(aout,get_lineno) (ignore_abfd, ignore_symbol)
2515 asymbol *ignore_symbol;
2517 return (alent *)NULL;
2522 NAME(aout,get_symbol_info) (ignore_abfd, symbol, ret)
2527 bfd_symbol_info (symbol, ret);
2529 if (ret->type == '?')
2531 int type_code = aout_symbol(symbol)->type & 0xff;
2532 const char *stab_name = bfd_get_stab_name (type_code);
2533 static char buf[10];
2535 if (stab_name == NULL)
2537 sprintf(buf, "(%d)", type_code);
2541 ret->stab_type = type_code;
2542 ret->stab_other = (unsigned)(aout_symbol(symbol)->other & 0xff);
2543 ret->stab_desc = (unsigned)(aout_symbol(symbol)->desc & 0xffff);
2544 ret->stab_name = stab_name;
2550 NAME(aout,print_symbol) (ignore_abfd, afile, symbol, how)
2554 bfd_print_symbol_type how;
2556 FILE *file = (FILE *)afile;
2559 case bfd_print_symbol_name:
2561 fprintf(file,"%s", symbol->name);
2563 case bfd_print_symbol_more:
2564 fprintf(file,"%4x %2x %2x",(unsigned)(aout_symbol(symbol)->desc & 0xffff),
2565 (unsigned)(aout_symbol(symbol)->other & 0xff),
2566 (unsigned)(aout_symbol(symbol)->type));
2568 case bfd_print_symbol_all:
2570 CONST char *section_name = symbol->section->name;
2573 bfd_print_symbol_vandf((PTR)file,symbol);
2575 fprintf(file," %-5s %04x %02x %02x",
2577 (unsigned)(aout_symbol(symbol)->desc & 0xffff),
2578 (unsigned)(aout_symbol(symbol)->other & 0xff),
2579 (unsigned)(aout_symbol(symbol)->type & 0xff));
2581 fprintf(file," %s", symbol->name);
2587 /* If we don't have to allocate more than 1MB to hold the generic
2588 symbols, we use the generic minisymbol methord: it's faster, since
2589 it only translates the symbols once, not multiple times. */
2590 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2592 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2593 symbols. The minisymbol_to_symbol function translates these into
2594 BFD asymbol structures. */
2597 NAME(aout,read_minisymbols) (abfd, dynamic, minisymsp, sizep)
2601 unsigned int *sizep;
2605 /* We could handle the dynamic symbols here as well, but it's
2606 easier to hand them off. */
2607 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2610 if (! aout_get_external_symbols (abfd))
2613 if (obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2614 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2616 *minisymsp = (PTR) obj_aout_external_syms (abfd);
2618 /* By passing the external symbols back from this routine, we are
2619 giving up control over the memory block. Clear
2620 obj_aout_external_syms, so that we do not try to free it
2622 obj_aout_external_syms (abfd) = NULL;
2624 *sizep = EXTERNAL_NLIST_SIZE;
2625 return obj_aout_external_sym_count (abfd);
2628 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2629 unmodified a.out symbol. The SYM argument is a structure returned
2630 by bfd_make_empty_symbol, which we fill in here. */
2633 NAME(aout,minisymbol_to_symbol) (abfd, dynamic, minisym, sym)
2640 || obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2641 return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
2643 memset (sym, 0, sizeof (aout_symbol_type));
2645 /* We call translate_symbol_table to translate a single symbol. */
2646 if (! (NAME(aout,translate_symbol_table)
2648 (aout_symbol_type *) sym,
2649 (struct external_nlist *) minisym,
2651 obj_aout_external_strings (abfd),
2652 obj_aout_external_string_size (abfd),
2660 provided a BFD, a section and an offset into the section, calculate
2661 and return the name of the source file and the line nearest to the
2666 NAME(aout,find_nearest_line)
2667 (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2672 CONST char **filename_ptr;
2673 CONST char **functionname_ptr;
2674 unsigned int *line_ptr;
2676 /* Run down the file looking for the filename, function and linenumber */
2678 CONST char *directory_name = NULL;
2679 CONST char *main_file_name = NULL;
2680 CONST char *current_file_name = NULL;
2681 CONST char *line_file_name = NULL; /* Value of current_file_name at line number. */
2682 bfd_vma low_line_vma = 0;
2683 bfd_vma low_func_vma = 0;
2685 size_t filelen, funclen;
2688 *filename_ptr = abfd->filename;
2689 *functionname_ptr = 0;
2691 if (symbols != (asymbol **)NULL) {
2692 for (p = symbols; *p; p++) {
2693 aout_symbol_type *q = (aout_symbol_type *)(*p);
2697 /* If this looks like a file name symbol, and it comes after
2698 the line number we have found so far, but before the
2699 offset, then we have probably not found the right line
2701 if (q->symbol.value <= offset
2702 && ((q->symbol.value > low_line_vma
2703 && (line_file_name != NULL
2705 || (q->symbol.value > low_func_vma
2708 const char *symname;
2710 symname = q->symbol.name;
2711 if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
2713 if (q->symbol.value > low_line_vma)
2716 line_file_name = NULL;
2718 if (q->symbol.value > low_func_vma)
2725 /* If this symbol is less than the offset, but greater than
2726 the line number we have found so far, then we have not
2727 found the right line number. */
2728 if (q->symbol.value <= offset)
2730 if (q->symbol.value > low_line_vma)
2733 line_file_name = NULL;
2735 if (q->symbol.value > low_func_vma)
2739 main_file_name = current_file_name = q->symbol.name;
2740 /* Look ahead to next symbol to check if that too is an N_SO. */
2744 q = (aout_symbol_type *)(*p);
2745 if (q->type != (int)N_SO)
2748 /* Found a second N_SO First is directory; second is filename. */
2749 directory_name = current_file_name;
2750 main_file_name = current_file_name = q->symbol.name;
2751 if (obj_textsec(abfd) != section)
2755 current_file_name = q->symbol.name;
2762 /* We'll keep this if it resolves nearer than the one we have
2764 if (q->symbol.value >= low_line_vma
2765 && q->symbol.value <= offset)
2767 *line_ptr = q->desc;
2768 low_line_vma = q->symbol.value;
2769 line_file_name = current_file_name;
2774 /* We'll keep this if it is nearer than the one we have already */
2775 if (q->symbol.value >= low_func_vma &&
2776 q->symbol.value <= offset) {
2777 low_func_vma = q->symbol.value;
2778 func = (asymbol *)q;
2780 else if (q->symbol.value > offset)
2790 main_file_name = line_file_name;
2792 if (main_file_name == NULL
2793 || main_file_name[0] == '/'
2794 || directory_name == NULL)
2797 filelen = strlen (directory_name) + strlen (main_file_name);
2801 funclen = strlen (bfd_asymbol_name (func));
2803 if (adata (abfd).line_buf != NULL)
2804 free (adata (abfd).line_buf);
2805 if (filelen + funclen == 0)
2806 adata (abfd).line_buf = buf = NULL;
2809 buf = (char *) bfd_malloc (filelen + funclen + 3);
2810 adata (abfd).line_buf = buf;
2815 if (main_file_name != NULL)
2817 if (main_file_name[0] == '/' || directory_name == NULL)
2818 *filename_ptr = main_file_name;
2821 sprintf (buf, "%s%s", directory_name, main_file_name);
2822 *filename_ptr = buf;
2829 const char *function = func->name;
2832 /* The caller expects a symbol name. We actually have a
2833 function name, without the leading underscore. Put the
2834 underscore back in, so that the caller gets a symbol name. */
2835 if (bfd_get_symbol_leading_char (abfd) == '\0')
2836 strcpy (buf, function);
2839 buf[0] = bfd_get_symbol_leading_char (abfd);
2840 strcpy (buf + 1, function);
2842 /* Have to remove : stuff */
2843 p = strchr (buf, ':');
2846 *functionname_ptr = buf;
2854 NAME(aout,sizeof_headers) (abfd, execable)
2858 return adata(abfd).exec_bytes_size;
2861 /* Free all information we have cached for this BFD. We can always
2862 read it again later if we need it. */
2865 NAME(aout,bfd_free_cached_info) (abfd)
2870 if (bfd_get_format (abfd) != bfd_object)
2873 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2874 BFCI_FREE (obj_aout_symbols (abfd));
2876 obj_aout_external_syms (abfd) = 0;
2877 bfd_free_window (&obj_aout_sym_window (abfd));
2878 bfd_free_window (&obj_aout_string_window (abfd));
2879 obj_aout_external_strings (abfd) = 0;
2881 BFCI_FREE (obj_aout_external_syms (abfd));
2882 BFCI_FREE (obj_aout_external_strings (abfd));
2884 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
2885 BFCI_FREE (o->relocation);
2891 /* a.out link code. */
2893 static boolean aout_link_add_object_symbols
2894 PARAMS ((bfd *, struct bfd_link_info *));
2895 static boolean aout_link_check_archive_element
2896 PARAMS ((bfd *, struct bfd_link_info *, boolean *));
2897 static boolean aout_link_free_symbols PARAMS ((bfd *));
2898 static boolean aout_link_check_ar_symbols
2899 PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
2900 static boolean aout_link_add_symbols
2901 PARAMS ((bfd *, struct bfd_link_info *));
2903 /* Routine to create an entry in an a.out link hash table. */
2905 struct bfd_hash_entry *
2906 NAME(aout,link_hash_newfunc) (entry, table, string)
2907 struct bfd_hash_entry *entry;
2908 struct bfd_hash_table *table;
2911 struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry;
2913 /* Allocate the structure if it has not already been allocated by a
2915 if (ret == (struct aout_link_hash_entry *) NULL)
2916 ret = ((struct aout_link_hash_entry *)
2917 bfd_hash_allocate (table, sizeof (struct aout_link_hash_entry)));
2918 if (ret == (struct aout_link_hash_entry *) NULL)
2919 return (struct bfd_hash_entry *) ret;
2921 /* Call the allocation method of the superclass. */
2922 ret = ((struct aout_link_hash_entry *)
2923 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2927 /* Set local fields. */
2928 ret->written = false;
2932 return (struct bfd_hash_entry *) ret;
2935 /* Initialize an a.out link hash table. */
2938 NAME(aout,link_hash_table_init) (table, abfd, newfunc)
2939 struct aout_link_hash_table *table;
2941 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
2942 struct bfd_hash_table *,
2945 return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
2948 /* Create an a.out link hash table. */
2950 struct bfd_link_hash_table *
2951 NAME(aout,link_hash_table_create) (abfd)
2954 struct aout_link_hash_table *ret;
2956 ret = ((struct aout_link_hash_table *)
2957 bfd_alloc (abfd, sizeof (struct aout_link_hash_table)));
2959 return (struct bfd_link_hash_table *) NULL;
2960 if (! NAME(aout,link_hash_table_init) (ret, abfd,
2961 NAME(aout,link_hash_newfunc)))
2964 return (struct bfd_link_hash_table *) NULL;
2969 /* Given an a.out BFD, add symbols to the global hash table as
2973 NAME(aout,link_add_symbols) (abfd, info)
2975 struct bfd_link_info *info;
2977 switch (bfd_get_format (abfd))
2980 return aout_link_add_object_symbols (abfd, info);
2982 return _bfd_generic_link_add_archive_symbols
2983 (abfd, info, aout_link_check_archive_element);
2985 bfd_set_error (bfd_error_wrong_format);
2990 /* Add symbols from an a.out object file. */
2993 aout_link_add_object_symbols (abfd, info)
2995 struct bfd_link_info *info;
2997 if (! aout_get_external_symbols (abfd))
2999 if (! aout_link_add_symbols (abfd, info))
3001 if (! info->keep_memory)
3003 if (! aout_link_free_symbols (abfd))
3009 /* Check a single archive element to see if we need to include it in
3010 the link. *PNEEDED is set according to whether this element is
3011 needed in the link or not. This is called from
3012 _bfd_generic_link_add_archive_symbols. */
3015 aout_link_check_archive_element (abfd, info, pneeded)
3017 struct bfd_link_info *info;
3020 if (! aout_get_external_symbols (abfd))
3023 if (! aout_link_check_ar_symbols (abfd, info, pneeded))
3028 if (! aout_link_add_symbols (abfd, info))
3032 if (! info->keep_memory || ! *pneeded)
3034 if (! aout_link_free_symbols (abfd))
3041 /* Free up the internal symbols read from an a.out file. */
3044 aout_link_free_symbols (abfd)
3047 if (obj_aout_external_syms (abfd) != (struct external_nlist *) NULL)
3050 bfd_free_window (&obj_aout_sym_window (abfd));
3052 free ((PTR) obj_aout_external_syms (abfd));
3054 obj_aout_external_syms (abfd) = (struct external_nlist *) NULL;
3056 if (obj_aout_external_strings (abfd) != (char *) NULL)
3059 bfd_free_window (&obj_aout_string_window (abfd));
3061 free ((PTR) obj_aout_external_strings (abfd));
3063 obj_aout_external_strings (abfd) = (char *) NULL;
3068 /* Look through the internal symbols to see if this object file should
3069 be included in the link. We should include this object file if it
3070 defines any symbols which are currently undefined. If this object
3071 file defines a common symbol, then we may adjust the size of the
3072 known symbol but we do not include the object file in the link
3073 (unless there is some other reason to include it). */
3076 aout_link_check_ar_symbols (abfd, info, pneeded)
3078 struct bfd_link_info *info;
3081 register struct external_nlist *p;
3082 struct external_nlist *pend;
3087 /* Look through all the symbols. */
3088 p = obj_aout_external_syms (abfd);
3089 pend = p + obj_aout_external_sym_count (abfd);
3090 strings = obj_aout_external_strings (abfd);
3091 for (; p < pend; p++)
3093 int type = bfd_h_get_8 (abfd, p->e_type);
3095 struct bfd_link_hash_entry *h;
3097 /* Ignore symbols that are not externally visible. This is an
3098 optimization only, as we check the type more thoroughly
3100 if (((type & N_EXT) == 0
3101 || (type & N_STAB) != 0
3108 if (type == N_WARNING
3114 name = strings + GET_WORD (abfd, p->e_strx);
3115 h = bfd_link_hash_lookup (info->hash, name, false, false, true);
3117 /* We are only interested in symbols that are currently
3118 undefined or common. */
3119 if (h == (struct bfd_link_hash_entry *) NULL
3120 || (h->type != bfd_link_hash_undefined
3121 && h->type != bfd_link_hash_common))
3123 if (type == (N_INDR | N_EXT))
3128 if (type == (N_TEXT | N_EXT)
3129 || type == (N_DATA | N_EXT)
3130 || type == (N_BSS | N_EXT)
3131 || type == (N_ABS | N_EXT)
3132 || type == (N_INDR | N_EXT))
3134 /* This object file defines this symbol. We must link it
3135 in. This is true regardless of whether the current
3136 definition of the symbol is undefined or common. If the
3137 current definition is common, we have a case in which we
3138 have already seen an object file including
3140 and this object file from the archive includes
3142 In such a case we must include this object file.
3144 FIXME: The SunOS 4.1.3 linker will pull in the archive
3145 element if the symbol is defined in the .data section,
3146 but not if it is defined in the .text section. That
3147 seems a bit crazy to me, and I haven't implemented it.
3148 However, it might be correct. */
3149 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3155 if (type == (N_UNDF | N_EXT))
3159 value = GET_WORD (abfd, p->e_value);
3162 /* This symbol is common in the object from the archive
3164 if (h->type == bfd_link_hash_undefined)
3169 symbfd = h->u.undef.abfd;
3170 if (symbfd == (bfd *) NULL)
3172 /* This symbol was created as undefined from
3173 outside BFD. We assume that we should link
3174 in the object file. This is done for the -u
3175 option in the linker. */
3176 if (! (*info->callbacks->add_archive_element) (info,
3183 /* Turn the current link symbol into a common
3184 symbol. It is already on the undefs list. */
3185 h->type = bfd_link_hash_common;
3186 h->u.c.p = ((struct bfd_link_hash_common_entry *)
3187 bfd_hash_allocate (&info->hash->table,
3188 sizeof (struct bfd_link_hash_common_entry)));
3189 if (h->u.c.p == NULL)
3192 h->u.c.size = value;
3194 /* FIXME: This isn't quite right. The maximum
3195 alignment of a common symbol should be set by the
3196 architecture of the output file, not of the input
3198 power = bfd_log2 (value);
3199 if (power > bfd_get_arch_info (abfd)->section_align_power)
3200 power = bfd_get_arch_info (abfd)->section_align_power;
3201 h->u.c.p->alignment_power = power;
3203 h->u.c.p->section = bfd_make_section_old_way (symbfd,
3208 /* Adjust the size of the common symbol if
3210 if (value > h->u.c.size)
3211 h->u.c.size = value;
3221 /* This symbol is weak but defined. We must pull it in if
3222 the current link symbol is undefined, but we don't want
3223 it if the current link symbol is common. */
3224 if (h->type == bfd_link_hash_undefined)
3226 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3234 /* We do not need this object file. */
3238 /* Add all symbols from an object file to the hash table. */
3241 aout_link_add_symbols (abfd, info)
3243 struct bfd_link_info *info;
3245 boolean (*add_one_symbol) PARAMS ((struct bfd_link_info *, bfd *,
3246 const char *, flagword, asection *,
3247 bfd_vma, const char *, boolean,
3249 struct bfd_link_hash_entry **));
3250 struct external_nlist *syms;
3251 bfd_size_type sym_count;
3254 struct aout_link_hash_entry **sym_hash;
3255 register struct external_nlist *p;
3256 struct external_nlist *pend;
3258 syms = obj_aout_external_syms (abfd);
3259 sym_count = obj_aout_external_sym_count (abfd);
3260 strings = obj_aout_external_strings (abfd);
3261 if (info->keep_memory)
3266 if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
3268 if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
3269 (abfd, info, &syms, &sym_count, &strings)))
3273 /* We keep a list of the linker hash table entries that correspond
3274 to particular symbols. We could just look them up in the hash
3275 table, but keeping the list is more efficient. Perhaps this
3276 should be conditional on info->keep_memory. */
3277 sym_hash = ((struct aout_link_hash_entry **)
3280 * sizeof (struct aout_link_hash_entry *))));
3281 if (sym_hash == NULL && sym_count != 0)
3283 obj_aout_sym_hashes (abfd) = sym_hash;
3285 add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
3286 if (add_one_symbol == NULL)
3287 add_one_symbol = _bfd_generic_link_add_one_symbol;
3290 pend = p + sym_count;
3291 for (; p < pend; p++, sym_hash++)
3302 type = bfd_h_get_8 (abfd, p->e_type);
3304 /* Ignore debugging symbols. */
3305 if ((type & N_STAB) != 0)
3308 name = strings + GET_WORD (abfd, p->e_strx);
3309 value = GET_WORD (abfd, p->e_value);
3326 /* Ignore symbols that are not externally visible. */
3329 /* Ignore local indirect symbol. */
3334 case N_UNDF | N_EXT:
3337 section = bfd_und_section_ptr;
3341 section = bfd_com_section_ptr;
3344 section = bfd_abs_section_ptr;
3346 case N_TEXT | N_EXT:
3347 section = obj_textsec (abfd);
3348 value -= bfd_get_section_vma (abfd, section);
3350 case N_DATA | N_EXT:
3351 case N_SETV | N_EXT:
3352 /* Treat N_SETV symbols as N_DATA symbol; see comment in
3353 translate_from_native_sym_flags. */
3354 section = obj_datasec (abfd);
3355 value -= bfd_get_section_vma (abfd, section);
3358 section = obj_bsssec (abfd);
3359 value -= bfd_get_section_vma (abfd, section);
3361 case N_INDR | N_EXT:
3362 /* An indirect symbol. The next symbol is the symbol
3363 which this one really is. */
3364 BFD_ASSERT (p + 1 < pend);
3366 string = strings + GET_WORD (abfd, p->e_strx);
3367 section = bfd_ind_section_ptr;
3368 flags |= BSF_INDIRECT;
3370 case N_COMM | N_EXT:
3371 section = bfd_com_section_ptr;
3373 case N_SETA: case N_SETA | N_EXT:
3374 section = bfd_abs_section_ptr;
3375 flags |= BSF_CONSTRUCTOR;
3377 case N_SETT: case N_SETT | N_EXT:
3378 section = obj_textsec (abfd);
3379 flags |= BSF_CONSTRUCTOR;
3380 value -= bfd_get_section_vma (abfd, section);
3382 case N_SETD: case N_SETD | N_EXT:
3383 section = obj_datasec (abfd);
3384 flags |= BSF_CONSTRUCTOR;
3385 value -= bfd_get_section_vma (abfd, section);
3387 case N_SETB: case N_SETB | N_EXT:
3388 section = obj_bsssec (abfd);
3389 flags |= BSF_CONSTRUCTOR;
3390 value -= bfd_get_section_vma (abfd, section);
3393 /* A warning symbol. The next symbol is the one to warn
3395 BFD_ASSERT (p + 1 < pend);
3398 name = strings + GET_WORD (abfd, p->e_strx);
3399 section = bfd_und_section_ptr;
3400 flags |= BSF_WARNING;
3403 section = bfd_und_section_ptr;
3407 section = bfd_abs_section_ptr;
3411 section = obj_textsec (abfd);
3412 value -= bfd_get_section_vma (abfd, section);
3416 section = obj_datasec (abfd);
3417 value -= bfd_get_section_vma (abfd, section);
3421 section = obj_bsssec (abfd);
3422 value -= bfd_get_section_vma (abfd, section);
3427 if (! ((*add_one_symbol)
3428 (info, abfd, name, flags, section, value, string, copy, false,
3429 (struct bfd_link_hash_entry **) sym_hash)))
3432 /* Restrict the maximum alignment of a common symbol based on
3433 the architecture, since a.out has no way to represent
3434 alignment requirements of a section in a .o file. FIXME:
3435 This isn't quite right: it should use the architecture of the
3436 output file, not the input files. */
3437 if ((*sym_hash)->root.type == bfd_link_hash_common
3438 && ((*sym_hash)->root.u.c.p->alignment_power >
3439 bfd_get_arch_info (abfd)->section_align_power))
3440 (*sym_hash)->root.u.c.p->alignment_power =
3441 bfd_get_arch_info (abfd)->section_align_power;
3443 /* If this is a set symbol, and we are not building sets, then
3444 it is possible for the hash entry to not have been set. In
3445 such a case, treat the symbol as not globally defined. */
3446 if ((*sym_hash)->root.type == bfd_link_hash_new)
3448 BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
3452 if (type == (N_INDR | N_EXT) || type == N_WARNING)
3459 /* A hash table used for header files with N_BINCL entries. */
3461 struct aout_link_includes_table
3463 struct bfd_hash_table root;
3466 /* A linked list of totals that we have found for a particular header
3469 struct aout_link_includes_totals
3471 struct aout_link_includes_totals *next;
3475 /* An entry in the header file hash table. */
3477 struct aout_link_includes_entry
3479 struct bfd_hash_entry root;
3480 /* List of totals we have found for this file. */
3481 struct aout_link_includes_totals *totals;
3484 /* Look up an entry in an the header file hash table. */
3486 #define aout_link_includes_lookup(table, string, create, copy) \
3487 ((struct aout_link_includes_entry *) \
3488 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3490 /* During the final link step we need to pass around a bunch of
3491 information, so we do it in an instance of this structure. */
3493 struct aout_final_link_info
3495 /* General link information. */
3496 struct bfd_link_info *info;
3499 /* Reloc file positions. */
3500 file_ptr treloff, dreloff;
3501 /* File position of symbols. */
3504 struct bfd_strtab_hash *strtab;
3505 /* Header file hash table. */
3506 struct aout_link_includes_table includes;
3507 /* A buffer large enough to hold the contents of any section. */
3509 /* A buffer large enough to hold the relocs of any section. */
3511 /* A buffer large enough to hold the symbol map of any input BFD. */
3513 /* A buffer large enough to hold output symbols of any input BFD. */
3514 struct external_nlist *output_syms;
3517 static struct bfd_hash_entry *aout_link_includes_newfunc
3518 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
3519 static boolean aout_link_input_bfd
3520 PARAMS ((struct aout_final_link_info *, bfd *input_bfd));
3521 static boolean aout_link_write_symbols
3522 PARAMS ((struct aout_final_link_info *, bfd *input_bfd));
3523 static boolean aout_link_write_other_symbol
3524 PARAMS ((struct aout_link_hash_entry *, PTR));
3525 static boolean aout_link_input_section
3526 PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
3527 asection *input_section, file_ptr *reloff_ptr,
3528 bfd_size_type rel_size));
3529 static boolean aout_link_input_section_std
3530 PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
3531 asection *input_section, struct reloc_std_external *,
3532 bfd_size_type rel_size, bfd_byte *contents));
3533 static boolean aout_link_input_section_ext
3534 PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
3535 asection *input_section, struct reloc_ext_external *,
3536 bfd_size_type rel_size, bfd_byte *contents));
3537 static INLINE asection *aout_reloc_index_to_section
3538 PARAMS ((bfd *, int));
3539 static boolean aout_link_reloc_link_order
3540 PARAMS ((struct aout_final_link_info *, asection *,
3541 struct bfd_link_order *));
3543 /* The function to create a new entry in the header file hash table. */
3545 static struct bfd_hash_entry *
3546 aout_link_includes_newfunc (entry, table, string)
3547 struct bfd_hash_entry *entry;
3548 struct bfd_hash_table *table;
3551 struct aout_link_includes_entry *ret =
3552 (struct aout_link_includes_entry *) entry;
3554 /* Allocate the structure if it has not already been allocated by a
3556 if (ret == (struct aout_link_includes_entry *) NULL)
3557 ret = ((struct aout_link_includes_entry *)
3558 bfd_hash_allocate (table,
3559 sizeof (struct aout_link_includes_entry)));
3560 if (ret == (struct aout_link_includes_entry *) NULL)
3561 return (struct bfd_hash_entry *) ret;
3563 /* Call the allocation method of the superclass. */
3564 ret = ((struct aout_link_includes_entry *)
3565 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
3568 /* Set local fields. */
3572 return (struct bfd_hash_entry *) ret;
3575 /* Do the final link step. This is called on the output BFD. The
3576 INFO structure should point to a list of BFDs linked through the
3577 link_next field which can be used to find each BFD which takes part
3578 in the output. Also, each section in ABFD should point to a list
3579 of bfd_link_order structures which list all the input sections for
3580 the output section. */
3583 NAME(aout,final_link) (abfd, info, callback)
3585 struct bfd_link_info *info;
3586 void (*callback) PARAMS ((bfd *, file_ptr *, file_ptr *, file_ptr *));
3588 struct aout_final_link_info aout_info;
3589 boolean includes_hash_initialized = false;
3591 bfd_size_type trsize, drsize;
3592 size_t max_contents_size;
3593 size_t max_relocs_size;
3594 size_t max_sym_count;
3595 bfd_size_type text_size;
3597 register struct bfd_link_order *p;
3599 boolean have_link_order_relocs;
3602 abfd->flags |= DYNAMIC;
3604 aout_info.info = info;
3605 aout_info.output_bfd = abfd;
3606 aout_info.contents = NULL;
3607 aout_info.relocs = NULL;
3608 aout_info.symbol_map = NULL;
3609 aout_info.output_syms = NULL;
3611 if (! bfd_hash_table_init_n (&aout_info.includes.root,
3612 aout_link_includes_newfunc,
3615 includes_hash_initialized = true;
3617 /* Figure out the largest section size. Also, if generating
3618 relocateable output, count the relocs. */
3621 max_contents_size = 0;
3622 max_relocs_size = 0;
3624 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3628 if (info->relocateable)
3630 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3632 trsize += exec_hdr (sub)->a_trsize;
3633 drsize += exec_hdr (sub)->a_drsize;
3637 /* FIXME: We need to identify the .text and .data sections
3638 and call get_reloc_upper_bound and canonicalize_reloc to
3639 work out the number of relocs needed, and then multiply
3640 by the reloc size. */
3641 (*_bfd_error_handler)
3642 ("%s: relocateable link from %s to %s not supported",
3643 bfd_get_filename (abfd),
3644 sub->xvec->name, abfd->xvec->name);
3645 bfd_set_error (bfd_error_invalid_operation);
3650 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3652 sz = bfd_section_size (sub, obj_textsec (sub));
3653 if (sz > max_contents_size)
3654 max_contents_size = sz;
3655 sz = bfd_section_size (sub, obj_datasec (sub));
3656 if (sz > max_contents_size)
3657 max_contents_size = sz;
3659 sz = exec_hdr (sub)->a_trsize;
3660 if (sz > max_relocs_size)
3661 max_relocs_size = sz;
3662 sz = exec_hdr (sub)->a_drsize;
3663 if (sz > max_relocs_size)
3664 max_relocs_size = sz;
3666 sz = obj_aout_external_sym_count (sub);
3667 if (sz > max_sym_count)
3672 if (info->relocateable)
3674 if (obj_textsec (abfd) != (asection *) NULL)
3675 trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
3677 * obj_reloc_entry_size (abfd));
3678 if (obj_datasec (abfd) != (asection *) NULL)
3679 drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
3681 * obj_reloc_entry_size (abfd));
3684 exec_hdr (abfd)->a_trsize = trsize;
3685 exec_hdr (abfd)->a_drsize = drsize;
3687 exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
3689 /* Adjust the section sizes and vmas according to the magic number.
3690 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3691 filepos for each section. */
3692 if (! NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
3695 /* The relocation and symbol file positions differ among a.out
3696 targets. We are passed a callback routine from the backend
3697 specific code to handle this.
3698 FIXME: At this point we do not know how much space the symbol
3699 table will require. This will not work for any (nonstandard)
3700 a.out target that needs to know the symbol table size before it
3701 can compute the relocation file positions. This may or may not
3702 be the case for the hp300hpux target, for example. */
3703 (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
3705 obj_textsec (abfd)->rel_filepos = aout_info.treloff;
3706 obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
3707 obj_sym_filepos (abfd) = aout_info.symoff;
3709 /* We keep a count of the symbols as we output them. */
3710 obj_aout_external_sym_count (abfd) = 0;
3712 /* We accumulate the string table as we write out the symbols. */
3713 aout_info.strtab = _bfd_stringtab_init ();
3714 if (aout_info.strtab == NULL)
3717 /* Allocate buffers to hold section contents and relocs. */
3718 aout_info.contents = (bfd_byte *) bfd_malloc (max_contents_size);
3719 aout_info.relocs = (PTR) bfd_malloc (max_relocs_size);
3720 aout_info.symbol_map = (int *) bfd_malloc (max_sym_count * sizeof (int *));
3721 aout_info.output_syms = ((struct external_nlist *)
3722 bfd_malloc ((max_sym_count + 1)
3723 * sizeof (struct external_nlist)));
3724 if ((aout_info.contents == NULL && max_contents_size != 0)
3725 || (aout_info.relocs == NULL && max_relocs_size != 0)
3726 || (aout_info.symbol_map == NULL && max_sym_count != 0)
3727 || aout_info.output_syms == NULL)
3730 /* If we have a symbol named __DYNAMIC, force it out now. This is
3731 required by SunOS. Doing this here rather than in sunos.c is a
3732 hack, but it's easier than exporting everything which would be
3735 struct aout_link_hash_entry *h;
3737 h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
3738 false, false, false);
3740 aout_link_write_other_symbol (h, &aout_info);
3743 /* The most time efficient way to do the link would be to read all
3744 the input object files into memory and then sort out the
3745 information into the output file. Unfortunately, that will
3746 probably use too much memory. Another method would be to step
3747 through everything that composes the text section and write it
3748 out, and then everything that composes the data section and write
3749 it out, and then write out the relocs, and then write out the
3750 symbols. Unfortunately, that requires reading stuff from each
3751 input file several times, and we will not be able to keep all the
3752 input files open simultaneously, and reopening them will be slow.
3754 What we do is basically process one input file at a time. We do
3755 everything we need to do with an input file once--copy over the
3756 section contents, handle the relocation information, and write
3757 out the symbols--and then we throw away the information we read
3758 from it. This approach requires a lot of lseeks of the output
3759 file, which is unfortunate but still faster than reopening a lot
3762 We use the output_has_begun field of the input BFDs to see
3763 whether we have already handled it. */
3764 for (sub = info->input_bfds; sub != (bfd *) NULL; sub = sub->link_next)
3765 sub->output_has_begun = false;
3767 /* Mark all sections which are to be included in the link. This
3768 will normally be every section. We need to do this so that we
3769 can identify any sections which the linker has decided to not
3771 for (o = abfd->sections; o != NULL; o = o->next)
3773 for (p = o->link_order_head; p != NULL; p = p->next)
3775 if (p->type == bfd_indirect_link_order)
3776 p->u.indirect.section->linker_mark = true;
3780 have_link_order_relocs = false;
3781 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3783 for (p = o->link_order_head;
3784 p != (struct bfd_link_order *) NULL;
3787 if (p->type == bfd_indirect_link_order
3788 && (bfd_get_flavour (p->u.indirect.section->owner)
3789 == bfd_target_aout_flavour))
3793 input_bfd = p->u.indirect.section->owner;
3794 if (! input_bfd->output_has_begun)
3796 if (! aout_link_input_bfd (&aout_info, input_bfd))
3798 input_bfd->output_has_begun = true;
3801 else if (p->type == bfd_section_reloc_link_order
3802 || p->type == bfd_symbol_reloc_link_order)
3804 /* These are handled below. */
3805 have_link_order_relocs = true;
3809 if (! _bfd_default_link_order (abfd, info, o, p))
3815 /* Write out any symbols that we have not already written out. */
3816 aout_link_hash_traverse (aout_hash_table (info),
3817 aout_link_write_other_symbol,
3820 /* Now handle any relocs we were asked to create by the linker.
3821 These did not come from any input file. We must do these after
3822 we have written out all the symbols, so that we know the symbol
3824 if (have_link_order_relocs)
3826 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3828 for (p = o->link_order_head;
3829 p != (struct bfd_link_order *) NULL;
3832 if (p->type == bfd_section_reloc_link_order
3833 || p->type == bfd_symbol_reloc_link_order)
3835 if (! aout_link_reloc_link_order (&aout_info, o, p))
3842 if (aout_info.contents != NULL)
3844 free (aout_info.contents);
3845 aout_info.contents = NULL;
3847 if (aout_info.relocs != NULL)
3849 free (aout_info.relocs);
3850 aout_info.relocs = NULL;
3852 if (aout_info.symbol_map != NULL)
3854 free (aout_info.symbol_map);
3855 aout_info.symbol_map = NULL;
3857 if (aout_info.output_syms != NULL)
3859 free (aout_info.output_syms);
3860 aout_info.output_syms = NULL;
3862 if (includes_hash_initialized)
3864 bfd_hash_table_free (&aout_info.includes.root);
3865 includes_hash_initialized = false;
3868 /* Finish up any dynamic linking we may be doing. */
3869 if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
3871 if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
3875 /* Update the header information. */
3876 abfd->symcount = obj_aout_external_sym_count (abfd);
3877 exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
3878 obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
3879 obj_textsec (abfd)->reloc_count =
3880 exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
3881 obj_datasec (abfd)->reloc_count =
3882 exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
3884 /* Write out the string table, unless there are no symbols. */
3885 if (abfd->symcount > 0)
3887 if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
3888 || ! emit_stringtab (abfd, aout_info.strtab))
3891 else if (obj_textsec (abfd)->reloc_count == 0
3892 && obj_datasec (abfd)->reloc_count == 0)
3898 (obj_datasec (abfd)->filepos
3899 + exec_hdr (abfd)->a_data
3902 || bfd_write (&b, 1, 1, abfd) != 1)
3909 if (aout_info.contents != NULL)
3910 free (aout_info.contents);
3911 if (aout_info.relocs != NULL)
3912 free (aout_info.relocs);
3913 if (aout_info.symbol_map != NULL)
3914 free (aout_info.symbol_map);
3915 if (aout_info.output_syms != NULL)
3916 free (aout_info.output_syms);
3917 if (includes_hash_initialized)
3918 bfd_hash_table_free (&aout_info.includes.root);
3922 /* Link an a.out input BFD into the output file. */
3925 aout_link_input_bfd (finfo, input_bfd)
3926 struct aout_final_link_info *finfo;
3929 bfd_size_type sym_count;
3931 BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
3933 /* If this is a dynamic object, it may need special handling. */
3934 if ((input_bfd->flags & DYNAMIC) != 0
3935 && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
3937 return ((*aout_backend_info (input_bfd)->link_dynamic_object)
3938 (finfo->info, input_bfd));
3941 /* Get the symbols. We probably have them already, unless
3942 finfo->info->keep_memory is false. */
3943 if (! aout_get_external_symbols (input_bfd))
3946 sym_count = obj_aout_external_sym_count (input_bfd);
3948 /* Write out the symbols and get a map of the new indices. The map
3949 is placed into finfo->symbol_map. */
3950 if (! aout_link_write_symbols (finfo, input_bfd))
3953 /* Relocate and write out the sections. These functions use the
3954 symbol map created by aout_link_write_symbols. The linker_mark
3955 field will be set if these sections are to be included in the
3956 link, which will normally be the case. */
3957 if (obj_textsec (input_bfd)->linker_mark)
3959 if (! aout_link_input_section (finfo, input_bfd,
3960 obj_textsec (input_bfd),
3962 exec_hdr (input_bfd)->a_trsize))
3965 if (obj_datasec (input_bfd)->linker_mark)
3967 if (! aout_link_input_section (finfo, input_bfd,
3968 obj_datasec (input_bfd),
3970 exec_hdr (input_bfd)->a_drsize))
3974 /* If we are not keeping memory, we don't need the symbols any
3975 longer. We still need them if we are keeping memory, because the
3976 strings in the hash table point into them. */
3977 if (! finfo->info->keep_memory)
3979 if (! aout_link_free_symbols (input_bfd))
3986 /* Adjust and write out the symbols for an a.out file. Set the new
3987 symbol indices into a symbol_map. */
3990 aout_link_write_symbols (finfo, input_bfd)
3991 struct aout_final_link_info *finfo;
3995 bfd_size_type sym_count;
3997 enum bfd_link_strip strip;
3998 enum bfd_link_discard discard;
3999 struct external_nlist *outsym;
4000 bfd_size_type strtab_index;
4001 register struct external_nlist *sym;
4002 struct external_nlist *sym_end;
4003 struct aout_link_hash_entry **sym_hash;
4008 output_bfd = finfo->output_bfd;
4009 sym_count = obj_aout_external_sym_count (input_bfd);
4010 strings = obj_aout_external_strings (input_bfd);
4011 strip = finfo->info->strip;
4012 discard = finfo->info->discard;
4013 outsym = finfo->output_syms;
4015 /* First write out a symbol for this object file, unless we are
4016 discarding such symbols. */
4017 if (strip != strip_all
4018 && (strip != strip_some
4019 || bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
4020 false, false) != NULL)
4021 && discard != discard_all)
4023 bfd_h_put_8 (output_bfd, N_TEXT, outsym->e_type);
4024 bfd_h_put_8 (output_bfd, 0, outsym->e_other);
4025 bfd_h_put_16 (output_bfd, (bfd_vma) 0, outsym->e_desc);
4026 strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4027 input_bfd->filename, false);
4028 if (strtab_index == (bfd_size_type) -1)
4030 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4031 PUT_WORD (output_bfd,
4032 (bfd_get_section_vma (output_bfd,
4033 obj_textsec (input_bfd)->output_section)
4034 + obj_textsec (input_bfd)->output_offset),
4036 ++obj_aout_external_sym_count (output_bfd);
4042 sym = obj_aout_external_syms (input_bfd);
4043 sym_end = sym + sym_count;
4044 sym_hash = obj_aout_sym_hashes (input_bfd);
4045 symbol_map = finfo->symbol_map;
4046 memset (symbol_map, 0, sym_count * sizeof *symbol_map);
4047 for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
4051 struct aout_link_hash_entry *h;
4057 /* We set *symbol_map to 0 above for all symbols. If it has
4058 already been set to -1 for this symbol, it means that we are
4059 discarding it because it appears in a duplicate header file.
4060 See the N_BINCL code below. */
4061 if (*symbol_map == -1)
4064 /* Initialize *symbol_map to -1, which means that the symbol was
4065 not copied into the output file. We will change it later if
4066 we do copy the symbol over. */
4069 type = bfd_h_get_8 (input_bfd, sym->e_type);
4070 name = strings + GET_WORD (input_bfd, sym->e_strx);
4076 /* Pass this symbol through. It is the target of an
4077 indirect or warning symbol. */
4078 val = GET_WORD (input_bfd, sym->e_value);
4083 /* Skip this symbol, which is the target of an indirect
4084 symbol that we have changed to no longer be an indirect
4091 struct aout_link_hash_entry *hresolve;
4093 /* We have saved the hash table entry for this symbol, if
4094 there is one. Note that we could just look it up again
4095 in the hash table, provided we first check that it is an
4099 /* Use the name from the hash table, in case the symbol was
4102 name = h->root.root.string;
4104 /* If this is an indirect or warning symbol, then change
4105 hresolve to the base symbol. We also change *sym_hash so
4106 that the relocation routines relocate against the real
4109 if (h != (struct aout_link_hash_entry *) NULL
4110 && (h->root.type == bfd_link_hash_indirect
4111 || h->root.type == bfd_link_hash_warning))
4113 hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
4114 while (hresolve->root.type == bfd_link_hash_indirect
4115 || hresolve->root.type == bfd_link_hash_warning)
4116 hresolve = ((struct aout_link_hash_entry *)
4117 hresolve->root.u.i.link);
4118 *sym_hash = hresolve;
4121 /* If the symbol has already been written out, skip it. */
4122 if (h != (struct aout_link_hash_entry *) NULL
4123 && h->root.type != bfd_link_hash_warning
4126 if ((type & N_TYPE) == N_INDR
4127 || type == N_WARNING)
4129 *symbol_map = h->indx;
4133 /* See if we are stripping this symbol. */
4139 case strip_debugger:
4140 if ((type & N_STAB) != 0)
4144 if (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
4154 if (h != (struct aout_link_hash_entry *) NULL)
4159 /* Get the value of the symbol. */
4160 if ((type & N_TYPE) == N_TEXT
4162 symsec = obj_textsec (input_bfd);
4163 else if ((type & N_TYPE) == N_DATA
4165 symsec = obj_datasec (input_bfd);
4166 else if ((type & N_TYPE) == N_BSS
4168 symsec = obj_bsssec (input_bfd);
4169 else if ((type & N_TYPE) == N_ABS
4171 symsec = bfd_abs_section_ptr;
4172 else if (((type & N_TYPE) == N_INDR
4173 && (hresolve == (struct aout_link_hash_entry *) NULL
4174 || (hresolve->root.type != bfd_link_hash_defined
4175 && hresolve->root.type != bfd_link_hash_defweak
4176 && hresolve->root.type != bfd_link_hash_common)))
4177 || type == N_WARNING)
4179 /* Pass the next symbol through unchanged. The
4180 condition above for indirect symbols is so that if
4181 the indirect symbol was defined, we output it with
4182 the correct definition so the debugger will
4185 val = GET_WORD (input_bfd, sym->e_value);
4188 else if ((type & N_STAB) != 0)
4190 val = GET_WORD (input_bfd, sym->e_value);
4195 /* If we get here with an indirect symbol, it means that
4196 we are outputting it with a real definition. In such
4197 a case we do not want to output the next symbol,
4198 which is the target of the indirection. */
4199 if ((type & N_TYPE) == N_INDR)
4204 /* We need to get the value from the hash table. We use
4205 hresolve so that if we have defined an indirect
4206 symbol we output the final definition. */
4207 if (h == (struct aout_link_hash_entry *) NULL)
4209 switch (type & N_TYPE)
4212 symsec = obj_textsec (input_bfd);
4215 symsec = obj_datasec (input_bfd);
4218 symsec = obj_bsssec (input_bfd);
4221 symsec = bfd_abs_section_ptr;
4228 else if (hresolve->root.type == bfd_link_hash_defined
4229 || hresolve->root.type == bfd_link_hash_defweak)
4231 asection *input_section;
4232 asection *output_section;
4234 /* This case usually means a common symbol which was
4235 turned into a defined symbol. */
4236 input_section = hresolve->root.u.def.section;
4237 output_section = input_section->output_section;
4238 BFD_ASSERT (bfd_is_abs_section (output_section)
4239 || output_section->owner == output_bfd);
4240 val = (hresolve->root.u.def.value
4241 + bfd_get_section_vma (output_bfd, output_section)
4242 + input_section->output_offset);
4244 /* Get the correct type based on the section. If
4245 this is a constructed set, force it to be
4246 globally visible. */
4255 if (output_section == obj_textsec (output_bfd))
4256 type |= (hresolve->root.type == bfd_link_hash_defined
4259 else if (output_section == obj_datasec (output_bfd))
4260 type |= (hresolve->root.type == bfd_link_hash_defined
4263 else if (output_section == obj_bsssec (output_bfd))
4264 type |= (hresolve->root.type == bfd_link_hash_defined
4268 type |= (hresolve->root.type == bfd_link_hash_defined
4272 else if (hresolve->root.type == bfd_link_hash_common)
4273 val = hresolve->root.u.c.size;
4274 else if (hresolve->root.type == bfd_link_hash_undefweak)
4282 if (symsec != (asection *) NULL)
4283 val = (symsec->output_section->vma
4284 + symsec->output_offset
4285 + (GET_WORD (input_bfd, sym->e_value)
4288 /* If this is a global symbol set the written flag, and if
4289 it is a local symbol see if we should discard it. */
4290 if (h != (struct aout_link_hash_entry *) NULL)
4293 h->indx = obj_aout_external_sym_count (output_bfd);
4295 else if ((type & N_TYPE) != N_SETT
4296 && (type & N_TYPE) != N_SETD
4297 && (type & N_TYPE) != N_SETB
4298 && (type & N_TYPE) != N_SETA)
4305 if ((type & N_STAB) == 0
4306 && bfd_is_local_label_name (input_bfd, name))
4320 /* An N_BINCL symbol indicates the start of the stabs
4321 entries for a header file. We need to scan ahead to the
4322 next N_EINCL symbol, ignoring nesting, adding up all the
4323 characters in the symbol names, not including the file
4324 numbers in types (the first number after an open
4326 if (type == N_BINCL)
4328 struct external_nlist *incl_sym;
4330 struct aout_link_includes_entry *incl_entry;
4331 struct aout_link_includes_totals *t;
4335 for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++)
4339 incl_type = bfd_h_get_8 (input_bfd, incl_sym->e_type);
4340 if (incl_type == N_EINCL)
4346 else if (incl_type == N_BINCL)
4352 s = strings + GET_WORD (input_bfd, incl_sym->e_strx);
4353 for (; *s != '\0'; s++)
4358 /* Skip the file number. */
4360 while (isdigit ((unsigned char) *s))
4368 /* If we have already included a header file with the
4369 same value, then replace this one with an N_EXCL
4371 copy = ! finfo->info->keep_memory;
4372 incl_entry = aout_link_includes_lookup (&finfo->includes,
4374 if (incl_entry == NULL)
4376 for (t = incl_entry->totals; t != NULL; t = t->next)
4377 if (t->total == val)
4381 /* This is the first time we have seen this header
4382 file with this set of stabs strings. */
4383 t = ((struct aout_link_includes_totals *)
4384 bfd_hash_allocate (&finfo->includes.root,
4389 t->next = incl_entry->totals;
4390 incl_entry->totals = t;
4396 /* This is a duplicate header file. We must change
4397 it to be an N_EXCL entry, and mark all the
4398 included symbols to prevent outputting them. */
4402 for (incl_sym = sym + 1, incl_map = symbol_map + 1;
4404 incl_sym++, incl_map++)
4408 incl_type = bfd_h_get_8 (input_bfd, incl_sym->e_type);
4409 if (incl_type == N_EINCL)
4418 else if (incl_type == N_BINCL)
4427 /* Copy this symbol into the list of symbols we are going to
4429 bfd_h_put_8 (output_bfd, type, outsym->e_type);
4430 bfd_h_put_8 (output_bfd, bfd_h_get_8 (input_bfd, sym->e_other),
4432 bfd_h_put_16 (output_bfd, bfd_h_get_16 (input_bfd, sym->e_desc),
4435 if (! finfo->info->keep_memory)
4437 /* name points into a string table which we are going to
4438 free. If there is a hash table entry, use that string.
4439 Otherwise, copy name into memory. */
4440 if (h != (struct aout_link_hash_entry *) NULL)
4441 name = h->root.root.string;
4445 strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4447 if (strtab_index == (bfd_size_type) -1)
4449 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4450 PUT_WORD (output_bfd, val, outsym->e_value);
4451 *symbol_map = obj_aout_external_sym_count (output_bfd);
4452 ++obj_aout_external_sym_count (output_bfd);
4456 /* Write out the output symbols we have just constructed. */
4457 if (outsym > finfo->output_syms)
4459 bfd_size_type outsym_count;
4461 if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
4463 outsym_count = outsym - finfo->output_syms;
4464 if (bfd_write ((PTR) finfo->output_syms,
4465 (bfd_size_type) EXTERNAL_NLIST_SIZE,
4466 (bfd_size_type) outsym_count, output_bfd)
4467 != outsym_count * EXTERNAL_NLIST_SIZE)
4469 finfo->symoff += outsym_count * EXTERNAL_NLIST_SIZE;
4475 /* Write out a symbol that was not associated with an a.out input
4479 aout_link_write_other_symbol (h, data)
4480 struct aout_link_hash_entry *h;
4483 struct aout_final_link_info *finfo = (struct aout_final_link_info *) data;
4487 struct external_nlist outsym;
4490 output_bfd = finfo->output_bfd;
4492 if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
4494 if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
4495 (output_bfd, finfo->info, h)))
4497 /* FIXME: No way to handle errors. */
4507 /* An indx of -2 means the symbol must be written. */
4509 && (finfo->info->strip == strip_all
4510 || (finfo->info->strip == strip_some
4511 && bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
4512 false, false) == NULL)))
4515 switch (h->root.type)
4519 /* Avoid variable not initialized warnings. */
4521 case bfd_link_hash_new:
4522 /* This can happen for set symbols when sets are not being
4525 case bfd_link_hash_undefined:
4526 type = N_UNDF | N_EXT;
4529 case bfd_link_hash_defined:
4530 case bfd_link_hash_defweak:
4534 sec = h->root.u.def.section->output_section;
4535 BFD_ASSERT (bfd_is_abs_section (sec)
4536 || sec->owner == output_bfd);
4537 if (sec == obj_textsec (output_bfd))
4538 type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
4539 else if (sec == obj_datasec (output_bfd))
4540 type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
4541 else if (sec == obj_bsssec (output_bfd))
4542 type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
4544 type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
4546 val = (h->root.u.def.value
4548 + h->root.u.def.section->output_offset);
4551 case bfd_link_hash_common:
4552 type = N_UNDF | N_EXT;
4553 val = h->root.u.c.size;
4555 case bfd_link_hash_undefweak:
4558 case bfd_link_hash_indirect:
4559 case bfd_link_hash_warning:
4560 /* FIXME: Ignore these for now. The circumstances under which
4561 they should be written out are not clear to me. */
4565 bfd_h_put_8 (output_bfd, type, outsym.e_type);
4566 bfd_h_put_8 (output_bfd, 0, outsym.e_other);
4567 bfd_h_put_16 (output_bfd, 0, outsym.e_desc);
4568 indx = add_to_stringtab (output_bfd, finfo->strtab, h->root.root.string,
4570 if (indx == (bfd_size_type) -1)
4572 /* FIXME: No way to handle errors. */
4575 PUT_WORD (output_bfd, indx, outsym.e_strx);
4576 PUT_WORD (output_bfd, val, outsym.e_value);
4578 if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0
4579 || bfd_write ((PTR) &outsym, (bfd_size_type) EXTERNAL_NLIST_SIZE,
4580 (bfd_size_type) 1, output_bfd) != EXTERNAL_NLIST_SIZE)
4582 /* FIXME: No way to handle errors. */
4586 finfo->symoff += EXTERNAL_NLIST_SIZE;
4587 h->indx = obj_aout_external_sym_count (output_bfd);
4588 ++obj_aout_external_sym_count (output_bfd);
4593 /* Link an a.out section into the output file. */
4596 aout_link_input_section (finfo, input_bfd, input_section, reloff_ptr,
4598 struct aout_final_link_info *finfo;
4600 asection *input_section;
4601 file_ptr *reloff_ptr;
4602 bfd_size_type rel_size;
4604 bfd_size_type input_size;
4607 /* Get the section contents. */
4608 input_size = bfd_section_size (input_bfd, input_section);
4609 if (! bfd_get_section_contents (input_bfd, input_section,
4610 (PTR) finfo->contents,
4611 (file_ptr) 0, input_size))
4614 /* Read in the relocs if we haven't already done it. */
4615 if (aout_section_data (input_section) != NULL
4616 && aout_section_data (input_section)->relocs != NULL)
4617 relocs = aout_section_data (input_section)->relocs;
4620 relocs = finfo->relocs;
4623 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4624 || bfd_read (relocs, 1, rel_size, input_bfd) != rel_size)
4629 /* Relocate the section contents. */
4630 if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
4632 if (! aout_link_input_section_std (finfo, input_bfd, input_section,
4633 (struct reloc_std_external *) relocs,
4634 rel_size, finfo->contents))
4639 if (! aout_link_input_section_ext (finfo, input_bfd, input_section,
4640 (struct reloc_ext_external *) relocs,
4641 rel_size, finfo->contents))
4645 /* Write out the section contents. */
4646 if (! bfd_set_section_contents (finfo->output_bfd,
4647 input_section->output_section,
4648 (PTR) finfo->contents,
4649 input_section->output_offset,
4653 /* If we are producing relocateable output, the relocs were
4654 modified, and we now write them out. */
4655 if (finfo->info->relocateable && rel_size > 0)
4657 if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
4659 if (bfd_write (relocs, (bfd_size_type) 1, rel_size, finfo->output_bfd)
4662 *reloff_ptr += rel_size;
4664 /* Assert that the relocs have not run into the symbols, and
4665 that if these are the text relocs they have not run into the
4667 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
4668 && (reloff_ptr != &finfo->treloff
4670 <= obj_datasec (finfo->output_bfd)->rel_filepos)));
4676 /* Get the section corresponding to a reloc index. */
4678 static INLINE asection *
4679 aout_reloc_index_to_section (abfd, indx)
4683 switch (indx & N_TYPE)
4686 return obj_textsec (abfd);
4688 return obj_datasec (abfd);
4690 return obj_bsssec (abfd);
4693 return bfd_abs_section_ptr;
4699 /* Relocate an a.out section using standard a.out relocs. */
4702 aout_link_input_section_std (finfo, input_bfd, input_section, relocs,
4704 struct aout_final_link_info *finfo;
4706 asection *input_section;
4707 struct reloc_std_external *relocs;
4708 bfd_size_type rel_size;
4711 boolean (*check_dynamic_reloc) PARAMS ((struct bfd_link_info *,
4713 struct aout_link_hash_entry *,
4714 PTR, bfd_byte *, boolean *,
4717 boolean relocateable;
4718 struct external_nlist *syms;
4720 struct aout_link_hash_entry **sym_hashes;
4722 bfd_size_type reloc_count;
4723 register struct reloc_std_external *rel;
4724 struct reloc_std_external *rel_end;
4726 output_bfd = finfo->output_bfd;
4727 check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
4729 BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE);
4730 BFD_ASSERT (input_bfd->xvec->header_byteorder
4731 == output_bfd->xvec->header_byteorder);
4733 relocateable = finfo->info->relocateable;
4734 syms = obj_aout_external_syms (input_bfd);
4735 strings = obj_aout_external_strings (input_bfd);
4736 sym_hashes = obj_aout_sym_hashes (input_bfd);
4737 symbol_map = finfo->symbol_map;
4739 reloc_count = rel_size / RELOC_STD_SIZE;
4741 rel_end = rel + reloc_count;
4742 for (; rel < rel_end; rel++)
4749 reloc_howto_type *howto;
4750 struct aout_link_hash_entry *h = NULL;
4752 bfd_reloc_status_type r;
4754 r_addr = GET_SWORD (input_bfd, rel->r_address);
4756 #ifdef MY_reloc_howto
4757 howto = MY_reloc_howto(input_bfd, rel, r_index, r_extern, r_pcrel);
4763 unsigned int howto_idx;
4765 if (bfd_header_big_endian (input_bfd))
4767 r_index = ((rel->r_index[0] << 16)
4768 | (rel->r_index[1] << 8)
4770 r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
4771 r_pcrel = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
4772 r_baserel = (0 != (rel->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
4773 r_jmptable= (0 != (rel->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
4774 r_relative= (0 != (rel->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
4775 r_length = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
4776 >> RELOC_STD_BITS_LENGTH_SH_BIG);
4780 r_index = ((rel->r_index[2] << 16)
4781 | (rel->r_index[1] << 8)
4783 r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
4784 r_pcrel = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
4785 r_baserel = (0 != (rel->r_type[0]
4786 & RELOC_STD_BITS_BASEREL_LITTLE));
4787 r_jmptable= (0 != (rel->r_type[0]
4788 & RELOC_STD_BITS_JMPTABLE_LITTLE));
4789 r_relative= (0 != (rel->r_type[0]
4790 & RELOC_STD_BITS_RELATIVE_LITTLE));
4791 r_length = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
4792 >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
4795 howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel
4796 + 16 * r_jmptable + 32 * r_relative);
4797 BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_std));
4798 howto = howto_table_std + howto_idx;
4804 /* We are generating a relocateable output file, and must
4805 modify the reloc accordingly. */
4808 /* If we know the symbol this relocation is against,
4809 convert it into a relocation against a section. This
4810 is what the native linker does. */
4811 h = sym_hashes[r_index];
4812 if (h != (struct aout_link_hash_entry *) NULL
4813 && (h->root.type == bfd_link_hash_defined
4814 || h->root.type == bfd_link_hash_defweak))
4816 asection *output_section;
4818 /* Change the r_extern value. */
4819 if (bfd_header_big_endian (output_bfd))
4820 rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_BIG;
4822 rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_LITTLE;
4824 /* Compute a new r_index. */
4825 output_section = h->root.u.def.section->output_section;
4826 if (output_section == obj_textsec (output_bfd))
4828 else if (output_section == obj_datasec (output_bfd))
4830 else if (output_section == obj_bsssec (output_bfd))
4835 /* Add the symbol value and the section VMA to the
4836 addend stored in the contents. */
4837 relocation = (h->root.u.def.value
4838 + output_section->vma
4839 + h->root.u.def.section->output_offset);
4843 /* We must change r_index according to the symbol
4845 r_index = symbol_map[r_index];
4851 /* We decided to strip this symbol, but it
4852 turns out that we can't. Note that we
4853 lose the other and desc information here.
4854 I don't think that will ever matter for a
4860 if (! aout_link_write_other_symbol (h,
4870 name = strings + GET_WORD (input_bfd,
4871 syms[r_index].e_strx);
4872 if (! ((*finfo->info->callbacks->unattached_reloc)
4873 (finfo->info, name, input_bfd, input_section,
4883 /* Write out the new r_index value. */
4884 if (bfd_header_big_endian (output_bfd))
4886 rel->r_index[0] = r_index >> 16;
4887 rel->r_index[1] = r_index >> 8;
4888 rel->r_index[2] = r_index;
4892 rel->r_index[2] = r_index >> 16;
4893 rel->r_index[1] = r_index >> 8;
4894 rel->r_index[0] = r_index;
4901 /* This is a relocation against a section. We must
4902 adjust by the amount that the section moved. */
4903 section = aout_reloc_index_to_section (input_bfd, r_index);
4904 relocation = (section->output_section->vma
4905 + section->output_offset
4909 /* Change the address of the relocation. */
4910 PUT_WORD (output_bfd,
4911 r_addr + input_section->output_offset,
4914 /* Adjust a PC relative relocation by removing the reference
4915 to the original address in the section and including the
4916 reference to the new address. */
4918 relocation -= (input_section->output_section->vma
4919 + input_section->output_offset
4920 - input_section->vma);
4922 #ifdef MY_relocatable_reloc
4923 MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr);
4926 if (relocation == 0)
4929 r = MY_relocate_contents (howto,
4930 input_bfd, relocation,
4937 /* We are generating an executable, and must do a full
4942 h = sym_hashes[r_index];
4944 if (h != (struct aout_link_hash_entry *) NULL
4945 && (h->root.type == bfd_link_hash_defined
4946 || h->root.type == bfd_link_hash_defweak))
4948 relocation = (h->root.u.def.value
4949 + h->root.u.def.section->output_section->vma
4950 + h->root.u.def.section->output_offset);
4952 else if (h != (struct aout_link_hash_entry *) NULL
4953 && h->root.type == bfd_link_hash_undefweak)
4965 section = aout_reloc_index_to_section (input_bfd, r_index);
4966 relocation = (section->output_section->vma
4967 + section->output_offset
4970 relocation += input_section->vma;
4973 if (check_dynamic_reloc != NULL)
4977 if (! ((*check_dynamic_reloc)
4978 (finfo->info, input_bfd, input_section, h,
4979 (PTR) rel, contents, &skip, &relocation)))
4985 /* Now warn if a global symbol is undefined. We could not
4986 do this earlier, because check_dynamic_reloc might want
4987 to skip this reloc. */
4988 if (hundef && ! finfo->info->shared && ! r_baserel)
4993 name = h->root.root.string;
4995 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
4996 if (! ((*finfo->info->callbacks->undefined_symbol)
4997 (finfo->info, name, input_bfd, input_section, r_addr)))
5001 r = MY_final_link_relocate (howto,
5002 input_bfd, input_section,
5003 contents, r_addr, relocation,
5007 if (r != bfd_reloc_ok)
5012 case bfd_reloc_outofrange:
5014 case bfd_reloc_overflow:
5019 name = h->root.root.string;
5021 name = strings + GET_WORD (input_bfd,
5022 syms[r_index].e_strx);
5027 s = aout_reloc_index_to_section (input_bfd, r_index);
5028 name = bfd_section_name (input_bfd, s);
5030 if (! ((*finfo->info->callbacks->reloc_overflow)
5031 (finfo->info, name, howto->name,
5032 (bfd_vma) 0, input_bfd, input_section, r_addr)))
5043 /* Relocate an a.out section using extended a.out relocs. */
5046 aout_link_input_section_ext (finfo, input_bfd, input_section, relocs,
5048 struct aout_final_link_info *finfo;
5050 asection *input_section;
5051 struct reloc_ext_external *relocs;
5052 bfd_size_type rel_size;
5055 boolean (*check_dynamic_reloc) PARAMS ((struct bfd_link_info *,
5057 struct aout_link_hash_entry *,
5058 PTR, bfd_byte *, boolean *,
5061 boolean relocateable;
5062 struct external_nlist *syms;
5064 struct aout_link_hash_entry **sym_hashes;
5066 bfd_size_type reloc_count;
5067 register struct reloc_ext_external *rel;
5068 struct reloc_ext_external *rel_end;
5070 output_bfd = finfo->output_bfd;
5071 check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
5073 BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_EXT_SIZE);
5074 BFD_ASSERT (input_bfd->xvec->header_byteorder
5075 == output_bfd->xvec->header_byteorder);
5077 relocateable = finfo->info->relocateable;
5078 syms = obj_aout_external_syms (input_bfd);
5079 strings = obj_aout_external_strings (input_bfd);
5080 sym_hashes = obj_aout_sym_hashes (input_bfd);
5081 symbol_map = finfo->symbol_map;
5083 reloc_count = rel_size / RELOC_EXT_SIZE;
5085 rel_end = rel + reloc_count;
5086 for (; rel < rel_end; rel++)
5091 unsigned int r_type;
5093 struct aout_link_hash_entry *h = NULL;
5094 asection *r_section = NULL;
5097 r_addr = GET_SWORD (input_bfd, rel->r_address);
5099 if (bfd_header_big_endian (input_bfd))
5101 r_index = ((rel->r_index[0] << 16)
5102 | (rel->r_index[1] << 8)
5104 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
5105 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
5106 >> RELOC_EXT_BITS_TYPE_SH_BIG);
5110 r_index = ((rel->r_index[2] << 16)
5111 | (rel->r_index[1] << 8)
5113 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
5114 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
5115 >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
5118 r_addend = GET_SWORD (input_bfd, rel->r_addend);
5120 BFD_ASSERT (r_type < TABLE_SIZE (howto_table_ext));
5124 /* We are generating a relocateable output file, and must
5125 modify the reloc accordingly. */
5127 || r_type == RELOC_BASE10
5128 || r_type == RELOC_BASE13
5129 || r_type == RELOC_BASE22)
5131 /* If we know the symbol this relocation is against,
5132 convert it into a relocation against a section. This
5133 is what the native linker does. */
5134 if (r_type == RELOC_BASE10
5135 || r_type == RELOC_BASE13
5136 || r_type == RELOC_BASE22)
5139 h = sym_hashes[r_index];
5140 if (h != (struct aout_link_hash_entry *) NULL
5141 && (h->root.type == bfd_link_hash_defined
5142 || h->root.type == bfd_link_hash_defweak))
5144 asection *output_section;
5146 /* Change the r_extern value. */
5147 if (bfd_header_big_endian (output_bfd))
5148 rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_BIG;
5150 rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_LITTLE;
5152 /* Compute a new r_index. */
5153 output_section = h->root.u.def.section->output_section;
5154 if (output_section == obj_textsec (output_bfd))
5156 else if (output_section == obj_datasec (output_bfd))
5158 else if (output_section == obj_bsssec (output_bfd))
5163 /* Add the symbol value and the section VMA to the
5165 relocation = (h->root.u.def.value
5166 + output_section->vma
5167 + h->root.u.def.section->output_offset);
5169 /* Now RELOCATION is the VMA of the final
5170 destination. If this is a PC relative reloc,
5171 then ADDEND is the negative of the source VMA.
5172 We want to set ADDEND to the difference between
5173 the destination VMA and the source VMA, which
5174 means we must adjust RELOCATION by the change in
5175 the source VMA. This is done below. */
5179 /* We must change r_index according to the symbol
5181 r_index = symbol_map[r_index];
5187 /* We decided to strip this symbol, but it
5188 turns out that we can't. Note that we
5189 lose the other and desc information here.
5190 I don't think that will ever matter for a
5196 if (! aout_link_write_other_symbol (h,
5206 name = strings + GET_WORD (input_bfd,
5207 syms[r_index].e_strx);
5208 if (! ((*finfo->info->callbacks->unattached_reloc)
5209 (finfo->info, name, input_bfd, input_section,
5218 /* If this is a PC relative reloc, then the addend
5219 is the negative of the source VMA. We must
5220 adjust it by the change in the source VMA. This
5224 /* Write out the new r_index value. */
5225 if (bfd_header_big_endian (output_bfd))
5227 rel->r_index[0] = r_index >> 16;
5228 rel->r_index[1] = r_index >> 8;
5229 rel->r_index[2] = r_index;
5233 rel->r_index[2] = r_index >> 16;
5234 rel->r_index[1] = r_index >> 8;
5235 rel->r_index[0] = r_index;
5240 /* This is a relocation against a section. We must
5241 adjust by the amount that the section moved. */
5242 r_section = aout_reloc_index_to_section (input_bfd, r_index);
5243 relocation = (r_section->output_section->vma
5244 + r_section->output_offset
5247 /* If this is a PC relative reloc, then the addend is
5248 the difference in VMA between the destination and the
5249 source. We have just adjusted for the change in VMA
5250 of the destination, so we must also adjust by the
5251 change in VMA of the source. This is done below. */
5254 /* As described above, we must always adjust a PC relative
5255 reloc by the change in VMA of the source. However, if
5256 pcrel_offset is set, then the addend does not include the
5257 location within the section, in which case we don't need
5258 to adjust anything. */
5259 if (howto_table_ext[r_type].pc_relative
5260 && ! howto_table_ext[r_type].pcrel_offset)
5261 relocation -= (input_section->output_section->vma
5262 + input_section->output_offset
5263 - input_section->vma);
5265 /* Change the addend if necessary. */
5266 if (relocation != 0)
5267 PUT_WORD (output_bfd, r_addend + relocation, rel->r_addend);
5269 /* Change the address of the relocation. */
5270 PUT_WORD (output_bfd,
5271 r_addr + input_section->output_offset,
5277 bfd_reloc_status_type r;
5279 /* We are generating an executable, and must do a full
5284 h = sym_hashes[r_index];
5286 if (h != (struct aout_link_hash_entry *) NULL
5287 && (h->root.type == bfd_link_hash_defined
5288 || h->root.type == bfd_link_hash_defweak))
5290 relocation = (h->root.u.def.value
5291 + h->root.u.def.section->output_section->vma
5292 + h->root.u.def.section->output_offset);
5294 else if (h != (struct aout_link_hash_entry *) NULL
5295 && h->root.type == bfd_link_hash_undefweak)
5303 else if (r_type == RELOC_BASE10
5304 || r_type == RELOC_BASE13
5305 || r_type == RELOC_BASE22)
5307 struct external_nlist *sym;
5310 /* For base relative relocs, r_index is always an index
5311 into the symbol table, even if r_extern is 0. */
5312 sym = syms + r_index;
5313 type = bfd_h_get_8 (input_bfd, sym->e_type);
5314 if ((type & N_TYPE) == N_TEXT
5316 r_section = obj_textsec (input_bfd);
5317 else if ((type & N_TYPE) == N_DATA
5319 r_section = obj_datasec (input_bfd);
5320 else if ((type & N_TYPE) == N_BSS
5322 r_section = obj_bsssec (input_bfd);
5323 else if ((type & N_TYPE) == N_ABS
5325 r_section = bfd_abs_section_ptr;
5328 relocation = (r_section->output_section->vma
5329 + r_section->output_offset
5330 + (GET_WORD (input_bfd, sym->e_value)
5335 r_section = aout_reloc_index_to_section (input_bfd, r_index);
5337 /* If this is a PC relative reloc, then R_ADDEND is the
5338 difference between the two vmas, or
5339 old_dest_sec + old_dest_off - (old_src_sec + old_src_off)
5341 old_dest_sec == section->vma
5343 old_src_sec == input_section->vma
5345 old_src_off == r_addr
5347 _bfd_final_link_relocate expects RELOCATION +
5348 R_ADDEND to be the VMA of the destination minus
5349 r_addr (the minus r_addr is because this relocation
5350 is not pcrel_offset, which is a bit confusing and
5351 should, perhaps, be changed), or
5354 new_dest_sec == output_section->vma + output_offset
5355 We arrange for this to happen by setting RELOCATION to
5356 new_dest_sec + old_src_sec - old_dest_sec
5358 If this is not a PC relative reloc, then R_ADDEND is
5359 simply the VMA of the destination, so we set
5360 RELOCATION to the change in the destination VMA, or
5361 new_dest_sec - old_dest_sec
5363 relocation = (r_section->output_section->vma
5364 + r_section->output_offset
5366 if (howto_table_ext[r_type].pc_relative)
5367 relocation += input_section->vma;
5370 if (check_dynamic_reloc != NULL)
5374 if (! ((*check_dynamic_reloc)
5375 (finfo->info, input_bfd, input_section, h,
5376 (PTR) rel, contents, &skip, &relocation)))
5382 /* Now warn if a global symbol is undefined. We could not
5383 do this earlier, because check_dynamic_reloc might want
5384 to skip this reloc. */
5386 && ! finfo->info->shared
5387 && r_type != RELOC_BASE10
5388 && r_type != RELOC_BASE13
5389 && r_type != RELOC_BASE22)
5394 name = h->root.root.string;
5396 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
5397 if (! ((*finfo->info->callbacks->undefined_symbol)
5398 (finfo->info, name, input_bfd, input_section, r_addr)))
5402 r = MY_final_link_relocate (howto_table_ext + r_type,
5403 input_bfd, input_section,
5404 contents, r_addr, relocation,
5406 if (r != bfd_reloc_ok)
5411 case bfd_reloc_outofrange:
5413 case bfd_reloc_overflow:
5418 name = h->root.root.string;
5420 || r_type == RELOC_BASE10
5421 || r_type == RELOC_BASE13
5422 || r_type == RELOC_BASE22)
5423 name = strings + GET_WORD (input_bfd,
5424 syms[r_index].e_strx);
5429 s = aout_reloc_index_to_section (input_bfd, r_index);
5430 name = bfd_section_name (input_bfd, s);
5432 if (! ((*finfo->info->callbacks->reloc_overflow)
5433 (finfo->info, name, howto_table_ext[r_type].name,
5434 r_addend, input_bfd, input_section, r_addr)))
5446 /* Handle a link order which is supposed to generate a reloc. */
5449 aout_link_reloc_link_order (finfo, o, p)
5450 struct aout_final_link_info *finfo;
5452 struct bfd_link_order *p;
5454 struct bfd_link_order_reloc *pr;
5457 reloc_howto_type *howto;
5458 file_ptr *reloff_ptr;
5459 struct reloc_std_external srel;
5460 struct reloc_ext_external erel;
5465 if (p->type == bfd_section_reloc_link_order)
5468 if (bfd_is_abs_section (pr->u.section))
5469 r_index = N_ABS | N_EXT;
5472 BFD_ASSERT (pr->u.section->owner == finfo->output_bfd);
5473 r_index = pr->u.section->target_index;
5478 struct aout_link_hash_entry *h;
5480 BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
5482 h = ((struct aout_link_hash_entry *)
5483 bfd_wrapped_link_hash_lookup (finfo->output_bfd, finfo->info,
5484 pr->u.name, false, false, true));
5485 if (h != (struct aout_link_hash_entry *) NULL
5490 /* We decided to strip this symbol, but it turns out that we
5491 can't. Note that we lose the other and desc information
5492 here. I don't think that will ever matter for a global
5496 if (! aout_link_write_other_symbol (h, (PTR) finfo))
5502 if (! ((*finfo->info->callbacks->unattached_reloc)
5503 (finfo->info, pr->u.name, (bfd *) NULL,
5504 (asection *) NULL, (bfd_vma) 0)))
5510 howto = bfd_reloc_type_lookup (finfo->output_bfd, pr->reloc);
5513 bfd_set_error (bfd_error_bad_value);
5517 if (o == obj_textsec (finfo->output_bfd))
5518 reloff_ptr = &finfo->treloff;
5519 else if (o == obj_datasec (finfo->output_bfd))
5520 reloff_ptr = &finfo->dreloff;
5524 if (obj_reloc_entry_size (finfo->output_bfd) == RELOC_STD_SIZE)
5527 MY_put_reloc(finfo->output_bfd, r_extern, r_index, p->offset, howto,
5537 r_pcrel = howto->pc_relative;
5538 r_baserel = (howto->type & 8) != 0;
5539 r_jmptable = (howto->type & 16) != 0;
5540 r_relative = (howto->type & 32) != 0;
5541 r_length = howto->size;
5543 PUT_WORD (finfo->output_bfd, p->offset, srel.r_address);
5544 if (bfd_header_big_endian (finfo->output_bfd))
5546 srel.r_index[0] = r_index >> 16;
5547 srel.r_index[1] = r_index >> 8;
5548 srel.r_index[2] = r_index;
5550 ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
5551 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
5552 | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
5553 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
5554 | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
5555 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
5559 srel.r_index[2] = r_index >> 16;
5560 srel.r_index[1] = r_index >> 8;
5561 srel.r_index[0] = r_index;
5563 ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
5564 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
5565 | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
5566 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
5567 | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
5568 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
5572 rel_ptr = (PTR) &srel;
5574 /* We have to write the addend into the object file, since
5575 standard a.out relocs are in place. It would be more
5576 reliable if we had the current contents of the file here,
5577 rather than assuming zeroes, but we can't read the file since
5578 it was opened using bfd_openw. */
5579 if (pr->addend != 0)
5582 bfd_reloc_status_type r;
5586 size = bfd_get_reloc_size (howto);
5587 buf = (bfd_byte *) bfd_zmalloc (size);
5588 if (buf == (bfd_byte *) NULL)
5590 r = MY_relocate_contents (howto, finfo->output_bfd,
5597 case bfd_reloc_outofrange:
5599 case bfd_reloc_overflow:
5600 if (! ((*finfo->info->callbacks->reloc_overflow)
5602 (p->type == bfd_section_reloc_link_order
5603 ? bfd_section_name (finfo->output_bfd,
5606 howto->name, pr->addend, (bfd *) NULL,
5607 (asection *) NULL, (bfd_vma) 0)))
5614 ok = bfd_set_section_contents (finfo->output_bfd, o,
5616 (file_ptr) p->offset,
5625 PUT_WORD (finfo->output_bfd, p->offset, erel.r_address);
5627 if (bfd_header_big_endian (finfo->output_bfd))
5629 erel.r_index[0] = r_index >> 16;
5630 erel.r_index[1] = r_index >> 8;
5631 erel.r_index[2] = r_index;
5633 ((r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
5634 | (howto->type << RELOC_EXT_BITS_TYPE_SH_BIG));
5638 erel.r_index[2] = r_index >> 16;
5639 erel.r_index[1] = r_index >> 8;
5640 erel.r_index[0] = r_index;
5642 (r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
5643 | (howto->type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
5646 PUT_WORD (finfo->output_bfd, pr->addend, erel.r_addend);
5648 rel_ptr = (PTR) &erel;
5651 if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
5652 || (bfd_write (rel_ptr, (bfd_size_type) 1,
5653 obj_reloc_entry_size (finfo->output_bfd),
5655 != obj_reloc_entry_size (finfo->output_bfd)))
5658 *reloff_ptr += obj_reloc_entry_size (finfo->output_bfd);
5660 /* Assert that the relocs have not run into the symbols, and that n
5661 the text relocs have not run into the data relocs. */
5662 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
5663 && (reloff_ptr != &finfo->treloff
5665 <= obj_datasec (finfo->output_bfd)->rel_filepos)));