1 /* POWER/PowerPC XCOFF linker support.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@cygnus.com>, 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 3 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., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "coff/internal.h"
28 #include "coff/xcoff.h"
32 /* This file holds the XCOFF linker code. */
34 #undef STRING_SIZE_SIZE
35 #define STRING_SIZE_SIZE 4
37 /* We reuse the SEC_ROM flag as a mark flag for garbage collection.
38 This flag will only be used on input sections. */
40 #define SEC_MARK (SEC_ROM)
42 /* The list of import files. */
44 struct xcoff_import_file
46 /* The next entry in the list. */
47 struct xcoff_import_file
*next
;
52 /* The member name. */
56 /* Information we keep for each section in the output file during the
59 struct xcoff_link_section_info
61 /* The relocs to be output. */
62 struct internal_reloc
*relocs
;
63 /* For each reloc against a global symbol whose index was not known
64 when the reloc was handled, the global hash table entry. */
65 struct xcoff_link_hash_entry
**rel_hashes
;
66 /* If there is a TOC relative reloc against a global symbol, and the
67 index of the TOC symbol is not known when the reloc was handled,
68 an entry is added to this linked list. This is not an array,
69 like rel_hashes, because this case is quite uncommon. */
70 struct xcoff_toc_rel_hash
72 struct xcoff_toc_rel_hash
*next
;
73 struct xcoff_link_hash_entry
*h
;
74 struct internal_reloc
*rel
;
78 /* Information that we pass around while doing the final link step. */
80 struct xcoff_final_link_info
82 /* General link information. */
83 struct bfd_link_info
*info
;
86 /* Hash table for long symbol names. */
87 struct bfd_strtab_hash
*strtab
;
88 /* Array of information kept for each output section, indexed by the
89 target_index field. */
90 struct xcoff_link_section_info
*section_info
;
91 /* Symbol index of last C_FILE symbol (-1 if none). */
93 /* Contents of last C_FILE symbol. */
94 struct internal_syment last_file
;
95 /* Symbol index of TOC symbol. */
97 /* Start of .loader symbols. */
99 /* Next .loader reloc to swap out. */
101 /* File position of start of line numbers. */
102 file_ptr line_filepos
;
103 /* Buffer large enough to hold swapped symbols of any input file. */
104 struct internal_syment
*internal_syms
;
105 /* Buffer large enough to hold output indices of symbols of any
108 /* Buffer large enough to hold output symbols for any input file. */
110 /* Buffer large enough to hold external line numbers for any input
113 /* Buffer large enough to hold any input section. */
115 /* Buffer large enough to hold external relocs of any input section. */
116 bfd_byte
*external_relocs
;
119 static bfd_boolean
xcoff_mark (struct bfd_link_info
*, asection
*);
123 /* Routines to read XCOFF dynamic information. This don't really
124 belong here, but we already have the ldsym manipulation routines
127 /* Read the contents of a section. */
130 xcoff_get_section_contents (bfd
*abfd
, asection
*sec
)
132 if (coff_section_data (abfd
, sec
) == NULL
)
134 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
136 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
137 if (sec
->used_by_bfd
== NULL
)
141 if (coff_section_data (abfd
, sec
)->contents
== NULL
)
145 if (! bfd_malloc_and_get_section (abfd
, sec
, &contents
))
147 if (contents
!= NULL
)
151 coff_section_data (abfd
, sec
)->contents
= contents
;
157 /* Get the size required to hold the dynamic symbols. */
160 _bfd_xcoff_get_dynamic_symtab_upper_bound (bfd
*abfd
)
164 struct internal_ldhdr ldhdr
;
166 if ((abfd
->flags
& DYNAMIC
) == 0)
168 bfd_set_error (bfd_error_invalid_operation
);
172 lsec
= bfd_get_section_by_name (abfd
, ".loader");
175 bfd_set_error (bfd_error_no_symbols
);
179 if (! xcoff_get_section_contents (abfd
, lsec
))
181 contents
= coff_section_data (abfd
, lsec
)->contents
;
183 bfd_xcoff_swap_ldhdr_in (abfd
, (void *) contents
, &ldhdr
);
185 return (ldhdr
.l_nsyms
+ 1) * sizeof (asymbol
*);
188 /* Get the dynamic symbols. */
191 _bfd_xcoff_canonicalize_dynamic_symtab (bfd
*abfd
, asymbol
**psyms
)
195 struct internal_ldhdr ldhdr
;
197 bfd_byte
*elsym
, *elsymend
;
198 coff_symbol_type
*symbuf
;
200 if ((abfd
->flags
& DYNAMIC
) == 0)
202 bfd_set_error (bfd_error_invalid_operation
);
206 lsec
= bfd_get_section_by_name (abfd
, ".loader");
209 bfd_set_error (bfd_error_no_symbols
);
213 if (! xcoff_get_section_contents (abfd
, lsec
))
215 contents
= coff_section_data (abfd
, lsec
)->contents
;
217 coff_section_data (abfd
, lsec
)->keep_contents
= TRUE
;
219 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
221 strings
= (char *) contents
+ ldhdr
.l_stoff
;
223 symbuf
= bfd_zalloc (abfd
, ldhdr
.l_nsyms
* sizeof (* symbuf
));
227 elsym
= contents
+ bfd_xcoff_loader_symbol_offset(abfd
, &ldhdr
);
229 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz(abfd
);
230 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz(abfd
), symbuf
++, psyms
++)
232 struct internal_ldsym ldsym
;
234 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
236 symbuf
->symbol
.the_bfd
= abfd
;
238 if (ldsym
._l
._l_l
._l_zeroes
== 0)
239 symbuf
->symbol
.name
= strings
+ ldsym
._l
._l_l
._l_offset
;
244 c
= bfd_alloc (abfd
, (bfd_size_type
) SYMNMLEN
+ 1);
247 memcpy (c
, ldsym
._l
._l_name
, SYMNMLEN
);
249 symbuf
->symbol
.name
= c
;
252 if (ldsym
.l_smclas
== XMC_XO
)
253 symbuf
->symbol
.section
= bfd_abs_section_ptr
;
255 symbuf
->symbol
.section
= coff_section_from_bfd_index (abfd
,
257 symbuf
->symbol
.value
= ldsym
.l_value
- symbuf
->symbol
.section
->vma
;
259 symbuf
->symbol
.flags
= BSF_NO_FLAGS
;
260 if ((ldsym
.l_smtype
& L_EXPORT
) != 0)
262 if ((ldsym
.l_smtype
& L_WEAK
) != 0)
263 symbuf
->symbol
.flags
|= BSF_WEAK
;
265 symbuf
->symbol
.flags
|= BSF_GLOBAL
;
268 /* FIXME: We have no way to record the other information stored
269 with the loader symbol. */
270 *psyms
= (asymbol
*) symbuf
;
275 return ldhdr
.l_nsyms
;
278 /* Get the size required to hold the dynamic relocs. */
281 _bfd_xcoff_get_dynamic_reloc_upper_bound (bfd
*abfd
)
285 struct internal_ldhdr ldhdr
;
287 if ((abfd
->flags
& DYNAMIC
) == 0)
289 bfd_set_error (bfd_error_invalid_operation
);
293 lsec
= bfd_get_section_by_name (abfd
, ".loader");
296 bfd_set_error (bfd_error_no_symbols
);
300 if (! xcoff_get_section_contents (abfd
, lsec
))
302 contents
= coff_section_data (abfd
, lsec
)->contents
;
304 bfd_xcoff_swap_ldhdr_in (abfd
, (struct external_ldhdr
*) contents
, &ldhdr
);
306 return (ldhdr
.l_nreloc
+ 1) * sizeof (arelent
*);
309 /* Get the dynamic relocs. */
312 _bfd_xcoff_canonicalize_dynamic_reloc (bfd
*abfd
,
318 struct internal_ldhdr ldhdr
;
320 bfd_byte
*elrel
, *elrelend
;
322 if ((abfd
->flags
& DYNAMIC
) == 0)
324 bfd_set_error (bfd_error_invalid_operation
);
328 lsec
= bfd_get_section_by_name (abfd
, ".loader");
331 bfd_set_error (bfd_error_no_symbols
);
335 if (! xcoff_get_section_contents (abfd
, lsec
))
337 contents
= coff_section_data (abfd
, lsec
)->contents
;
339 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
341 relbuf
= bfd_alloc (abfd
, ldhdr
.l_nreloc
* sizeof (arelent
));
345 elrel
= contents
+ bfd_xcoff_loader_reloc_offset(abfd
, &ldhdr
);
347 elrelend
= elrel
+ ldhdr
.l_nreloc
* bfd_xcoff_ldrelsz(abfd
);
348 for (; elrel
< elrelend
; elrel
+= bfd_xcoff_ldrelsz(abfd
), relbuf
++,
351 struct internal_ldrel ldrel
;
353 bfd_xcoff_swap_ldrel_in (abfd
, elrel
, &ldrel
);
355 if (ldrel
.l_symndx
>= 3)
356 relbuf
->sym_ptr_ptr
= syms
+ (ldrel
.l_symndx
- 3);
362 switch (ldrel
.l_symndx
)
378 sec
= bfd_get_section_by_name (abfd
, name
);
381 bfd_set_error (bfd_error_bad_value
);
385 relbuf
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
388 relbuf
->address
= ldrel
.l_vaddr
;
391 /* Most dynamic relocs have the same type. FIXME: This is only
392 correct if ldrel.l_rtype == 0. In other cases, we should use
393 a different howto. */
394 relbuf
->howto
= bfd_xcoff_dynamic_reloc_howto(abfd
);
396 /* FIXME: We have no way to record the l_rsecnm field. */
403 return ldhdr
.l_nreloc
;
406 /* Routine to create an entry in an XCOFF link hash table. */
408 static struct bfd_hash_entry
*
409 xcoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
410 struct bfd_hash_table
*table
,
413 struct xcoff_link_hash_entry
*ret
= (struct xcoff_link_hash_entry
*) entry
;
415 /* Allocate the structure if it has not already been allocated by a
418 ret
= bfd_hash_allocate (table
, sizeof (* ret
));
422 /* Call the allocation method of the superclass. */
423 ret
= ((struct xcoff_link_hash_entry
*)
424 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
428 /* Set local fields. */
430 ret
->toc_section
= NULL
;
431 ret
->u
.toc_indx
= -1;
432 ret
->descriptor
= NULL
;
436 ret
->smclas
= XMC_UA
;
439 return (struct bfd_hash_entry
*) ret
;
442 /* Create a XCOFF link hash table. */
444 struct bfd_link_hash_table
*
445 _bfd_xcoff_bfd_link_hash_table_create (bfd
*abfd
)
447 struct xcoff_link_hash_table
*ret
;
448 bfd_size_type amt
= sizeof (* ret
);
450 ret
= bfd_malloc (amt
);
453 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
, xcoff_link_hash_newfunc
,
454 sizeof (struct xcoff_link_hash_entry
)))
460 ret
->debug_strtab
= _bfd_xcoff_stringtab_init ();
461 ret
->debug_section
= NULL
;
462 ret
->loader_section
= NULL
;
463 ret
->ldrel_count
= 0;
464 memset (&ret
->ldhdr
, 0, sizeof (struct internal_ldhdr
));
465 ret
->linkage_section
= NULL
;
466 ret
->toc_section
= NULL
;
467 ret
->descriptor_section
= NULL
;
472 memset (ret
->special_sections
, 0, sizeof ret
->special_sections
);
474 /* The linker will always generate a full a.out header. We need to
475 record that fact now, before the sizeof_headers routine could be
477 xcoff_data (abfd
)->full_aouthdr
= TRUE
;
482 /* Free a XCOFF link hash table. */
485 _bfd_xcoff_bfd_link_hash_table_free (struct bfd_link_hash_table
*hash
)
487 struct xcoff_link_hash_table
*ret
= (struct xcoff_link_hash_table
*) hash
;
489 _bfd_stringtab_free (ret
->debug_strtab
);
490 bfd_hash_table_free (&ret
->root
.table
);
494 /* Read internal relocs for an XCOFF csect. This is a wrapper around
495 _bfd_coff_read_internal_relocs which tries to take advantage of any
496 relocs which may have been cached for the enclosing section. */
498 static struct internal_reloc
*
499 xcoff_read_internal_relocs (bfd
*abfd
,
502 bfd_byte
*external_relocs
,
503 bfd_boolean require_internal
,
504 struct internal_reloc
*internal_relocs
)
506 if (coff_section_data (abfd
, sec
) != NULL
507 && coff_section_data (abfd
, sec
)->relocs
== NULL
508 && xcoff_section_data (abfd
, sec
) != NULL
)
512 enclosing
= xcoff_section_data (abfd
, sec
)->enclosing
;
514 if (enclosing
!= NULL
515 && (coff_section_data (abfd
, enclosing
) == NULL
516 || coff_section_data (abfd
, enclosing
)->relocs
== NULL
)
518 && enclosing
->reloc_count
> 0)
520 if (_bfd_coff_read_internal_relocs (abfd
, enclosing
, TRUE
,
521 external_relocs
, FALSE
, NULL
)
526 if (enclosing
!= NULL
527 && coff_section_data (abfd
, enclosing
) != NULL
528 && coff_section_data (abfd
, enclosing
)->relocs
!= NULL
)
532 off
= ((sec
->rel_filepos
- enclosing
->rel_filepos
)
533 / bfd_coff_relsz (abfd
));
535 if (! require_internal
)
536 return coff_section_data (abfd
, enclosing
)->relocs
+ off
;
537 memcpy (internal_relocs
,
538 coff_section_data (abfd
, enclosing
)->relocs
+ off
,
539 sec
->reloc_count
* sizeof (struct internal_reloc
));
540 return internal_relocs
;
544 return _bfd_coff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
545 require_internal
, internal_relocs
);
548 /* H is the bfd symbol associated with exported .loader symbol LDSYM.
549 Return true if LDSYM defines H. */
552 xcoff_dynamic_definition_p (struct xcoff_link_hash_entry
*h
,
553 struct internal_ldsym
*ldsym
)
555 /* If we didn't know about H before processing LDSYM, LDSYM
556 definitely defines H. */
557 if (h
->root
.type
== bfd_link_hash_new
)
560 /* If H is currently a weak dynamic symbol, and if LDSYM is a strong
561 dynamic symbol, LDSYM trumps the current definition of H. */
562 if ((ldsym
->l_smtype
& L_WEAK
) == 0
563 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0
564 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
565 && (h
->root
.type
== bfd_link_hash_defweak
566 || h
->root
.type
== bfd_link_hash_undefweak
))
569 /* If H is currently undefined, LDSYM defines it. */
570 if ((h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
571 && (h
->root
.type
== bfd_link_hash_undefined
572 || h
->root
.type
== bfd_link_hash_undefweak
))
578 /* This function is used to add symbols from a dynamic object to the
579 global symbol table. */
582 xcoff_link_add_dynamic_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
586 struct internal_ldhdr ldhdr
;
588 bfd_byte
*elsym
, *elsymend
;
589 struct xcoff_import_file
*n
;
594 struct xcoff_import_file
**pp
;
596 /* We can only handle a dynamic object if we are generating an XCOFF
598 if (info
->output_bfd
->xvec
!= abfd
->xvec
)
600 (*_bfd_error_handler
)
601 (_("%s: XCOFF shared object when not producing XCOFF output"),
602 bfd_get_filename (abfd
));
603 bfd_set_error (bfd_error_invalid_operation
);
607 /* The symbols we use from a dynamic object are not the symbols in
608 the normal symbol table, but, rather, the symbols in the export
609 table. If there is a global symbol in a dynamic object which is
610 not in the export table, the loader will not be able to find it,
611 so we don't want to find it either. Also, on AIX 4.1.3, shr.o in
612 libc.a has symbols in the export table which are not in the
615 /* Read in the .loader section. FIXME: We should really use the
616 o_snloader field in the a.out header, rather than grabbing the
618 lsec
= bfd_get_section_by_name (abfd
, ".loader");
621 (*_bfd_error_handler
)
622 (_("%s: dynamic object with no .loader section"),
623 bfd_get_filename (abfd
));
624 bfd_set_error (bfd_error_no_symbols
);
628 if (! xcoff_get_section_contents (abfd
, lsec
))
630 contents
= coff_section_data (abfd
, lsec
)->contents
;
632 /* Remove the sections from this object, so that they do not get
633 included in the link. */
634 bfd_section_list_clear (abfd
);
636 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
638 strings
= (char *) contents
+ ldhdr
.l_stoff
;
640 elsym
= contents
+ bfd_xcoff_loader_symbol_offset(abfd
, &ldhdr
);
642 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz(abfd
);
644 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz(abfd
))
646 struct internal_ldsym ldsym
;
647 char nambuf
[SYMNMLEN
+ 1];
649 struct xcoff_link_hash_entry
*h
;
651 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
653 /* We are only interested in exported symbols. */
654 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
657 if (ldsym
._l
._l_l
._l_zeroes
== 0)
658 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
661 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
662 nambuf
[SYMNMLEN
] = '\0';
666 /* Normally we could not call xcoff_link_hash_lookup in an add
667 symbols routine, since we might not be using an XCOFF hash
668 table. However, we verified above that we are using an XCOFF
671 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, TRUE
,
676 if (!xcoff_dynamic_definition_p (h
, &ldsym
))
679 h
->flags
|= XCOFF_DEF_DYNAMIC
;
680 h
->smclas
= ldsym
.l_smclas
;
681 if (h
->smclas
== XMC_XO
)
683 /* This symbol has an absolute value. */
684 if ((ldsym
.l_smtype
& L_WEAK
) != 0)
685 h
->root
.type
= bfd_link_hash_defweak
;
687 h
->root
.type
= bfd_link_hash_defined
;
688 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
689 h
->root
.u
.def
.value
= ldsym
.l_value
;
693 /* Otherwise, we don't bother to actually define the symbol,
694 since we don't have a section to put it in anyhow.
695 We assume instead that an undefined XCOFF_DEF_DYNAMIC symbol
696 should be imported from the symbol's undef.abfd. */
697 if ((ldsym
.l_smtype
& L_WEAK
) != 0)
698 h
->root
.type
= bfd_link_hash_undefweak
;
700 h
->root
.type
= bfd_link_hash_undefined
;
701 h
->root
.u
.undef
.abfd
= abfd
;
704 /* If this symbol defines a function descriptor, then it
705 implicitly defines the function code as well. */
706 if (h
->smclas
== XMC_DS
707 || (h
->smclas
== XMC_XO
&& name
[0] != '.'))
708 h
->flags
|= XCOFF_DESCRIPTOR
;
709 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
711 struct xcoff_link_hash_entry
*hds
;
718 dsnm
= bfd_malloc ((bfd_size_type
) strlen (name
) + 2);
722 strcpy (dsnm
+ 1, name
);
723 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
), dsnm
,
733 if (xcoff_dynamic_definition_p (hds
, &ldsym
))
735 hds
->root
.type
= h
->root
.type
;
736 hds
->flags
|= XCOFF_DEF_DYNAMIC
;
737 if (h
->smclas
== XMC_XO
)
739 /* An absolute symbol appears to actually define code, not a
740 function descriptor. This is how some math functions are
741 implemented on AIX 4.1. */
742 hds
->smclas
= XMC_XO
;
743 hds
->root
.u
.def
.section
= bfd_abs_section_ptr
;
744 hds
->root
.u
.def
.value
= ldsym
.l_value
;
748 hds
->smclas
= XMC_PR
;
749 hds
->root
.u
.undef
.abfd
= abfd
;
750 /* We do not want to add this to the undefined
757 if (contents
!= NULL
&& ! coff_section_data (abfd
, lsec
)->keep_contents
)
759 free (coff_section_data (abfd
, lsec
)->contents
);
760 coff_section_data (abfd
, lsec
)->contents
= NULL
;
763 /* Record this file in the import files. */
764 n
= bfd_alloc (abfd
, (bfd_size_type
) sizeof (struct xcoff_import_file
));
769 /* For some reason, the path entry in the import file list for a
770 shared object appears to always be empty. The file name is the
773 if (abfd
->my_archive
== NULL
)
775 bname
= bfd_get_filename (abfd
);
780 bname
= bfd_get_filename (abfd
->my_archive
);
781 mname
= bfd_get_filename (abfd
);
783 s
= strrchr (bname
, '/');
789 /* We start c at 1 because the first import file number is reserved
791 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
793 pp
= &(*pp
)->next
, ++c
)
797 xcoff_data (abfd
)->import_file_id
= c
;
802 /* xcoff_link_create_extra_sections
804 Takes care of creating the .loader, .gl, .ds, .debug and sections. */
807 xcoff_link_create_extra_sections (bfd
* abfd
, struct bfd_link_info
*info
)
809 bfd_boolean return_value
= FALSE
;
811 if (info
->output_bfd
->xvec
== abfd
->xvec
)
813 /* We need to build a .loader section, so we do it here. This
814 won't work if we're producing an XCOFF output file with no
815 XCOFF input files. FIXME. */
817 if (xcoff_hash_table (info
)->loader_section
== NULL
)
820 flagword flags
= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
822 lsec
= bfd_make_section_anyway_with_flags (abfd
, ".loader", flags
);
826 xcoff_hash_table (info
)->loader_section
= lsec
;
829 /* Likewise for the linkage section. */
830 if (xcoff_hash_table (info
)->linkage_section
== NULL
)
833 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
836 lsec
= bfd_make_section_anyway_with_flags (abfd
, ".gl", flags
);
840 xcoff_hash_table (info
)->linkage_section
= lsec
;
841 lsec
->alignment_power
= 2;
844 /* Likewise for the TOC section. */
845 if (xcoff_hash_table (info
)->toc_section
== NULL
)
848 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
851 tsec
= bfd_make_section_anyway_with_flags (abfd
, ".tc", flags
);
855 xcoff_hash_table (info
)->toc_section
= tsec
;
856 tsec
->alignment_power
= 2;
859 /* Likewise for the descriptor section. */
860 if (xcoff_hash_table (info
)->descriptor_section
== NULL
)
863 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
866 dsec
= bfd_make_section_anyway_with_flags (abfd
, ".ds", flags
);
870 xcoff_hash_table (info
)->descriptor_section
= dsec
;
871 dsec
->alignment_power
= 2;
874 /* Likewise for the .debug section. */
875 if (xcoff_hash_table (info
)->debug_section
== NULL
876 && info
->strip
!= strip_all
)
879 flagword flags
= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
881 dsec
= bfd_make_section_anyway_with_flags (abfd
, ".debug", flags
);
885 xcoff_hash_table (info
)->debug_section
= dsec
;
896 /* Returns the index of reloc in RELOCS with the least address greater
897 than or equal to ADDRESS. The relocs are sorted by address. */
900 xcoff_find_reloc (struct internal_reloc
*relocs
,
904 bfd_size_type min
, max
, this;
908 if (count
== 1 && relocs
[0].r_vaddr
< address
)
917 /* Do a binary search over (min,max]. */
918 while (min
+ 1 < max
)
922 this = (max
+ min
) / 2;
923 raddr
= relocs
[this].r_vaddr
;
926 else if (raddr
< address
)
935 if (relocs
[min
].r_vaddr
< address
)
939 && relocs
[min
- 1].r_vaddr
== address
)
945 /* Add all the symbols from an object file to the hash table.
947 XCOFF is a weird format. A normal XCOFF .o files will have three
948 COFF sections--.text, .data, and .bss--but each COFF section will
949 contain many csects. These csects are described in the symbol
950 table. From the linker's point of view, each csect must be
951 considered a section in its own right. For example, a TOC entry is
952 handled as a small XMC_TC csect. The linker must be able to merge
953 different TOC entries together, which means that it must be able to
954 extract the XMC_TC csects from the .data section of the input .o
957 From the point of view of our linker, this is, of course, a hideous
958 nightmare. We cope by actually creating sections for each csect,
959 and discarding the original sections. We then have to handle the
960 relocation entries carefully, since the only way to tell which
961 csect they belong to is to examine the address. */
964 xcoff_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
966 unsigned int n_tmask
;
967 unsigned int n_btshft
;
968 bfd_boolean default_copy
;
969 bfd_size_type symcount
;
970 struct xcoff_link_hash_entry
**sym_hash
;
971 asection
**csect_cache
;
972 unsigned int *lineno_counts
;
973 bfd_size_type linesz
;
976 bfd_boolean keep_syms
;
978 unsigned int csect_index
;
979 asection
*first_csect
;
980 bfd_size_type symesz
;
983 struct reloc_info_struct
985 struct internal_reloc
*relocs
;
988 } *reloc_info
= NULL
;
991 keep_syms
= obj_coff_keep_syms (abfd
);
993 if ((abfd
->flags
& DYNAMIC
) != 0
994 && ! info
->static_link
)
996 if (! xcoff_link_add_dynamic_symbols (abfd
, info
))
1000 /* Create the loader, toc, gl, ds and debug sections, if needed. */
1001 if (! xcoff_link_create_extra_sections (abfd
, info
))
1004 if ((abfd
->flags
& DYNAMIC
) != 0
1005 && ! info
->static_link
)
1008 n_tmask
= coff_data (abfd
)->local_n_tmask
;
1009 n_btshft
= coff_data (abfd
)->local_n_btshft
;
1011 /* Define macros so that ISFCN, et. al., macros work correctly. */
1012 #define N_TMASK n_tmask
1013 #define N_BTSHFT n_btshft
1015 if (info
->keep_memory
)
1016 default_copy
= FALSE
;
1018 default_copy
= TRUE
;
1020 symcount
= obj_raw_syment_count (abfd
);
1022 /* We keep a list of the linker hash table entries that correspond
1023 to each external symbol. */
1024 amt
= symcount
* sizeof (struct xcoff_link_hash_entry
*);
1025 sym_hash
= bfd_zalloc (abfd
, amt
);
1026 if (sym_hash
== NULL
&& symcount
!= 0)
1028 coff_data (abfd
)->sym_hashes
= (struct coff_link_hash_entry
**) sym_hash
;
1030 /* Because of the weird stuff we are doing with XCOFF csects, we can
1031 not easily determine which section a symbol is in, so we store
1032 the information in the tdata for the input file. */
1033 amt
= symcount
* sizeof (asection
*);
1034 csect_cache
= bfd_zalloc (abfd
, amt
);
1035 if (csect_cache
== NULL
&& symcount
!= 0)
1037 xcoff_data (abfd
)->csects
= csect_cache
;
1039 /* We garbage-collect line-number information on a symbol-by-symbol
1040 basis, so we need to have quick access to the number of entries
1042 amt
= symcount
* sizeof (unsigned int);
1043 lineno_counts
= bfd_zalloc (abfd
, amt
);
1044 if (lineno_counts
== NULL
&& symcount
!= 0)
1046 xcoff_data (abfd
)->lineno_counts
= lineno_counts
;
1048 /* While splitting sections into csects, we need to assign the
1049 relocs correctly. The relocs and the csects must both be in
1050 order by VMA within a given section, so we handle this by
1051 scanning along the relocs as we process the csects. We index
1052 into reloc_info using the section target_index. */
1053 amt
= abfd
->section_count
+ 1;
1054 amt
*= sizeof (struct reloc_info_struct
);
1055 reloc_info
= bfd_zmalloc (amt
);
1056 if (reloc_info
== NULL
)
1059 /* Read in the relocs and line numbers for each section. */
1060 linesz
= bfd_coff_linesz (abfd
);
1062 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1066 if ((o
->flags
& SEC_RELOC
) != 0)
1068 reloc_info
[o
->target_index
].relocs
=
1069 xcoff_read_internal_relocs (abfd
, o
, TRUE
, NULL
, FALSE
, NULL
);
1070 amt
= o
->reloc_count
;
1071 amt
*= sizeof (asection
*);
1072 reloc_info
[o
->target_index
].csects
= bfd_zmalloc (amt
);
1073 if (reloc_info
[o
->target_index
].csects
== NULL
)
1077 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1078 && o
->lineno_count
> 0)
1082 amt
= linesz
* o
->lineno_count
;
1083 linenos
= bfd_malloc (amt
);
1084 if (linenos
== NULL
)
1086 reloc_info
[o
->target_index
].linenos
= linenos
;
1087 if (bfd_seek (abfd
, o
->line_filepos
, SEEK_SET
) != 0
1088 || bfd_bread (linenos
, amt
, abfd
) != amt
)
1093 /* Don't let the linker relocation routines discard the symbols. */
1094 obj_coff_keep_syms (abfd
) = TRUE
;
1100 symesz
= bfd_coff_symesz (abfd
);
1101 BFD_ASSERT (symesz
== bfd_coff_auxesz (abfd
));
1102 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
1103 esym_end
= esym
+ symcount
* symesz
;
1105 while (esym
< esym_end
)
1107 struct internal_syment sym
;
1108 union internal_auxent aux
;
1110 char buf
[SYMNMLEN
+ 1];
1114 struct xcoff_link_hash_entry
*set_toc
;
1116 bfd_coff_swap_sym_in (abfd
, (void *) esym
, (void *) &sym
);
1118 /* In this pass we are only interested in symbols with csect
1120 if (!CSECT_SYM_P (sym
.n_sclass
))
1123 Normally csect is a .pr, .rw etc. created in the loop
1124 If C_FILE or first time, handle special
1126 Advance esym, sym_hash, csect_hash ptrs. */
1127 if (sym
.n_sclass
== C_FILE
)
1130 *csect_cache
= csect
;
1131 else if (first_csect
== NULL
|| sym
.n_sclass
== C_FILE
)
1132 *csect_cache
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1134 *csect_cache
= NULL
;
1135 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1136 sym_hash
+= sym
.n_numaux
+ 1;
1137 csect_cache
+= sym
.n_numaux
+ 1;
1138 lineno_counts
+= sym
.n_numaux
+ 1;
1143 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
1148 /* If this symbol has line number information attached to it,
1149 and we're not stripping it, count the number of entries and
1150 add them to the count for this csect. In the final link pass
1151 we are going to attach line number information by symbol,
1152 rather than by section, in order to more easily handle
1153 garbage collection. */
1154 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1157 && ISFCN (sym
.n_type
))
1159 union internal_auxent auxlin
;
1161 bfd_coff_swap_aux_in (abfd
, (void *) (esym
+ symesz
),
1162 sym
.n_type
, sym
.n_sclass
,
1163 0, sym
.n_numaux
, (void *) &auxlin
);
1165 if (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
1167 asection
*enclosing
;
1168 bfd_signed_vma linoff
;
1170 enclosing
= xcoff_section_data (abfd
, csect
)->enclosing
;
1171 if (enclosing
== NULL
)
1173 (*_bfd_error_handler
)
1174 (_("%B: `%s' has line numbers but no enclosing section"),
1176 bfd_set_error (bfd_error_bad_value
);
1179 linoff
= (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
1180 - enclosing
->line_filepos
);
1181 /* Explicit cast to bfd_signed_vma for compiler. */
1182 if (linoff
< (bfd_signed_vma
) (enclosing
->lineno_count
* linesz
))
1184 struct internal_lineno lin
;
1185 bfd_byte
*linpstart
;
1187 linpstart
= (reloc_info
[enclosing
->target_index
].linenos
1189 bfd_coff_swap_lineno_in (abfd
, (void *) linpstart
, (void *) &lin
);
1191 && ((bfd_size_type
) lin
.l_addr
.l_symndx
1193 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1196 bfd_byte
*linpend
, *linp
;
1198 linpend
= (reloc_info
[enclosing
->target_index
].linenos
1199 + enclosing
->lineno_count
* linesz
);
1200 for (linp
= linpstart
+ linesz
;
1204 bfd_coff_swap_lineno_in (abfd
, (void *) linp
,
1206 if (lin
.l_lnno
== 0)
1209 *lineno_counts
= (linp
- linpstart
) / linesz
;
1210 /* The setting of line_filepos will only be
1211 useful if all the line number entries for a
1212 csect are contiguous; this only matters for
1214 if (csect
->line_filepos
== 0)
1215 csect
->line_filepos
=
1216 auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1222 /* Pick up the csect auxiliary information. */
1223 if (sym
.n_numaux
== 0)
1225 (*_bfd_error_handler
)
1226 (_("%B: class %d symbol `%s' has no aux entries"),
1227 abfd
, sym
.n_sclass
, name
);
1228 bfd_set_error (bfd_error_bad_value
);
1232 bfd_coff_swap_aux_in (abfd
,
1233 (void *) (esym
+ symesz
* sym
.n_numaux
),
1234 sym
.n_type
, sym
.n_sclass
,
1235 sym
.n_numaux
- 1, sym
.n_numaux
,
1238 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
1247 (*_bfd_error_handler
)
1248 (_("%B: symbol `%s' has unrecognized csect type %d"),
1250 bfd_set_error (bfd_error_bad_value
);
1254 /* This is an external reference. */
1255 if (sym
.n_sclass
== C_HIDEXT
1256 || sym
.n_scnum
!= N_UNDEF
1257 || aux
.x_csect
.x_scnlen
.l
!= 0)
1259 (*_bfd_error_handler
)
1260 (_("%B: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d"),
1261 abfd
, name
, sym
.n_sclass
, sym
.n_scnum
,
1262 aux
.x_csect
.x_scnlen
.l
);
1263 bfd_set_error (bfd_error_bad_value
);
1267 /* An XMC_XO external reference is actually a reference to
1268 an absolute location. */
1269 if (aux
.x_csect
.x_smclas
!= XMC_XO
)
1270 section
= bfd_und_section_ptr
;
1273 section
= bfd_abs_section_ptr
;
1274 value
= sym
.n_value
;
1280 csect_index
= -(unsigned) 1;
1282 /* When we see a TOC anchor, we record the TOC value. */
1283 if (aux
.x_csect
.x_smclas
== XMC_TC0
)
1285 if (sym
.n_sclass
!= C_HIDEXT
1286 || aux
.x_csect
.x_scnlen
.l
!= 0)
1288 (*_bfd_error_handler
)
1289 (_("%B: XMC_TC0 symbol `%s' is class %d scnlen %d"),
1290 abfd
, name
, sym
.n_sclass
, aux
.x_csect
.x_scnlen
.l
);
1291 bfd_set_error (bfd_error_bad_value
);
1294 xcoff_data (abfd
)->toc
= sym
.n_value
;
1297 /* We must merge TOC entries for the same symbol. We can
1298 merge two TOC entries if they are both C_HIDEXT, they
1299 both have the same name, they are both 4 or 8 bytes long, and
1300 they both have a relocation table entry for an external
1301 symbol with the same name. Unfortunately, this means
1302 that we must look through the relocations. Ick.
1304 Logic for 32 bit vs 64 bit.
1305 32 bit has a csect length of 4 for TOC
1306 64 bit has a csect length of 8 for TOC
1308 The conditions to get past the if-check are not that bad.
1309 They are what is used to create the TOC csects in the first
1311 if (aux
.x_csect
.x_smclas
== XMC_TC
1312 && sym
.n_sclass
== C_HIDEXT
1313 && info
->output_bfd
->xvec
== abfd
->xvec
1314 && ((bfd_xcoff_is_xcoff32 (abfd
)
1315 && aux
.x_csect
.x_scnlen
.l
== 4)
1316 || (bfd_xcoff_is_xcoff64 (abfd
)
1317 && aux
.x_csect
.x_scnlen
.l
== 8)))
1319 asection
*enclosing
;
1320 struct internal_reloc
*relocs
;
1321 bfd_size_type relindx
;
1322 struct internal_reloc
*rel
;
1324 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1325 if (enclosing
== NULL
)
1328 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1329 amt
= enclosing
->reloc_count
;
1330 relindx
= xcoff_find_reloc (relocs
, amt
, sym
.n_value
);
1331 rel
= relocs
+ relindx
;
1333 /* 32 bit R_POS r_size is 31
1334 64 bit R_POS r_size is 63 */
1335 if (relindx
< enclosing
->reloc_count
1336 && rel
->r_vaddr
== (bfd_vma
) sym
.n_value
1337 && rel
->r_type
== R_POS
1338 && ((bfd_xcoff_is_xcoff32 (abfd
)
1339 && rel
->r_size
== 31)
1340 || (bfd_xcoff_is_xcoff64 (abfd
)
1341 && rel
->r_size
== 63)))
1345 struct internal_syment relsym
;
1347 erelsym
= ((bfd_byte
*) obj_coff_external_syms (abfd
)
1348 + rel
->r_symndx
* symesz
);
1349 bfd_coff_swap_sym_in (abfd
, (void *) erelsym
, (void *) &relsym
);
1350 if (EXTERN_SYM_P (relsym
.n_sclass
))
1352 const char *relname
;
1353 char relbuf
[SYMNMLEN
+ 1];
1355 struct xcoff_link_hash_entry
*h
;
1357 /* At this point we know that the TOC entry is
1358 for an externally visible symbol. */
1359 relname
= _bfd_coff_internal_syment_name (abfd
, &relsym
,
1361 if (relname
== NULL
)
1364 /* We only merge TOC entries if the TC name is
1365 the same as the symbol name. This handles
1366 the normal case, but not common cases like
1367 SYM.P4 which gcc generates to store SYM + 4
1368 in the TOC. FIXME. */
1369 if (strcmp (name
, relname
) == 0)
1371 copy
= (! info
->keep_memory
1372 || relsym
._n
._n_n
._n_zeroes
!= 0
1373 || relsym
._n
._n_n
._n_offset
== 0);
1374 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1375 relname
, TRUE
, copy
,
1380 /* At this point h->root.type could be
1381 bfd_link_hash_new. That should be OK,
1382 since we know for sure that we will come
1383 across this symbol as we step through the
1386 /* We store h in *sym_hash for the
1387 convenience of the relocate_section
1391 if (h
->toc_section
!= NULL
)
1393 asection
**rel_csects
;
1395 /* We already have a TOC entry for this
1396 symbol, so we can just ignore this
1399 reloc_info
[enclosing
->target_index
].csects
;
1400 rel_csects
[relindx
] = bfd_und_section_ptr
;
1404 /* We are about to create a TOC entry for
1413 asection
*enclosing
;
1415 /* We need to create a new section. We get the name from
1416 the csect storage mapping class, so that the linker can
1417 accumulate similar csects together. */
1419 csect
= bfd_xcoff_create_csect_from_smclas(abfd
, &aux
, name
);
1423 /* The enclosing section is the main section : .data, .text
1424 or .bss that the csect is coming from. */
1425 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1426 if (enclosing
== NULL
)
1429 if (! bfd_is_abs_section (enclosing
)
1430 && ((bfd_vma
) sym
.n_value
< enclosing
->vma
1431 || ((bfd_vma
) sym
.n_value
+ aux
.x_csect
.x_scnlen
.l
1432 > enclosing
->vma
+ enclosing
->size
)))
1434 (*_bfd_error_handler
)
1435 (_("%B: csect `%s' not in enclosing section"),
1437 bfd_set_error (bfd_error_bad_value
);
1440 csect
->vma
= sym
.n_value
;
1441 csect
->filepos
= (enclosing
->filepos
1444 csect
->size
= aux
.x_csect
.x_scnlen
.l
;
1445 csect
->flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
;
1446 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1448 /* Record the enclosing section in the tdata for this new
1450 amt
= sizeof (struct coff_section_tdata
);
1451 csect
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1452 if (csect
->used_by_bfd
== NULL
)
1454 amt
= sizeof (struct xcoff_section_tdata
);
1455 coff_section_data (abfd
, csect
)->tdata
= bfd_zalloc (abfd
, amt
);
1456 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1458 xcoff_section_data (abfd
, csect
)->enclosing
= enclosing
;
1459 xcoff_section_data (abfd
, csect
)->lineno_count
=
1460 enclosing
->lineno_count
;
1462 if (enclosing
->owner
== abfd
)
1464 struct internal_reloc
*relocs
;
1465 bfd_size_type relindx
;
1466 struct internal_reloc
*rel
;
1467 asection
**rel_csect
;
1469 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1470 amt
= enclosing
->reloc_count
;
1471 relindx
= xcoff_find_reloc (relocs
, amt
, csect
->vma
);
1473 rel
= relocs
+ relindx
;
1474 rel_csect
= (reloc_info
[enclosing
->target_index
].csects
1477 csect
->rel_filepos
= (enclosing
->rel_filepos
1478 + relindx
* bfd_coff_relsz (abfd
));
1479 while (relindx
< enclosing
->reloc_count
1480 && *rel_csect
== NULL
1481 && rel
->r_vaddr
< csect
->vma
+ csect
->size
)
1485 csect
->flags
|= SEC_RELOC
;
1486 ++csect
->reloc_count
;
1493 /* There are a number of other fields and section flags
1494 which we do not bother to set. */
1496 csect_index
= ((esym
1497 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1500 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1502 if (first_csect
== NULL
)
1503 first_csect
= csect
;
1505 /* If this symbol is external, we treat it as starting at the
1506 beginning of the newly created section. */
1507 if (EXTERN_SYM_P (sym
.n_sclass
))
1513 /* If this is a TOC section for a symbol, record it. */
1514 if (set_toc
!= NULL
)
1515 set_toc
->toc_section
= csect
;
1520 /* This is a label definition. The x_scnlen field is the
1521 symbol index of the csect. Usually the XTY_LD symbol will
1522 follow its appropriate XTY_SD symbol. The .set pseudo op can
1523 cause the XTY_LD to not follow the XTY_SD symbol. */
1528 if (aux
.x_csect
.x_scnlen
.l
< 0
1529 || (aux
.x_csect
.x_scnlen
.l
1530 >= esym
- (bfd_byte
*) obj_coff_external_syms (abfd
)))
1534 section
= xcoff_data (abfd
)->csects
[aux
.x_csect
.x_scnlen
.l
];
1536 || (section
->flags
& SEC_HAS_CONTENTS
) == 0)
1541 (*_bfd_error_handler
)
1542 (_("%B: misplaced XTY_LD `%s'"),
1544 bfd_set_error (bfd_error_bad_value
);
1548 value
= sym
.n_value
- csect
->vma
;
1553 /* This is an unitialized csect. We could base the name on
1554 the storage mapping class, but we don't bother except for
1555 an XMC_TD symbol. If this csect is externally visible,
1556 it is a common symbol. We put XMC_TD symbols in sections
1557 named .tocbss, and rely on the linker script to put that
1560 if (aux
.x_csect
.x_smclas
== XMC_TD
)
1562 /* The linker script puts the .td section in the data
1563 section after the .tc section. */
1564 csect
= bfd_make_section_anyway_with_flags (abfd
, ".td",
1568 csect
= bfd_make_section_anyway_with_flags (abfd
, ".bss",
1573 csect
->vma
= sym
.n_value
;
1574 csect
->size
= aux
.x_csect
.x_scnlen
.l
;
1575 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1576 /* There are a number of other fields and section flags
1577 which we do not bother to set. */
1579 csect_index
= ((esym
1580 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1583 amt
= sizeof (struct coff_section_tdata
);
1584 csect
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1585 if (csect
->used_by_bfd
== NULL
)
1587 amt
= sizeof (struct xcoff_section_tdata
);
1588 coff_section_data (abfd
, csect
)->tdata
= bfd_zalloc (abfd
, amt
);
1589 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1591 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1593 if (first_csect
== NULL
)
1594 first_csect
= csect
;
1596 if (EXTERN_SYM_P (sym
.n_sclass
))
1598 csect
->flags
|= SEC_IS_COMMON
;
1601 value
= aux
.x_csect
.x_scnlen
.l
;
1607 /* Check for magic symbol names. */
1608 if ((smtyp
== XTY_SD
|| smtyp
== XTY_CM
)
1609 && aux
.x_csect
.x_smclas
!= XMC_TC
1610 && aux
.x_csect
.x_smclas
!= XMC_TD
)
1616 if (strcmp (name
, "_text") == 0)
1617 i
= XCOFF_SPECIAL_SECTION_TEXT
;
1618 else if (strcmp (name
, "_etext") == 0)
1619 i
= XCOFF_SPECIAL_SECTION_ETEXT
;
1620 else if (strcmp (name
, "_data") == 0)
1621 i
= XCOFF_SPECIAL_SECTION_DATA
;
1622 else if (strcmp (name
, "_edata") == 0)
1623 i
= XCOFF_SPECIAL_SECTION_EDATA
;
1624 else if (strcmp (name
, "_end") == 0)
1625 i
= XCOFF_SPECIAL_SECTION_END
;
1627 else if (name
[0] == 'e' && strcmp (name
, "end") == 0)
1628 i
= XCOFF_SPECIAL_SECTION_END2
;
1631 xcoff_hash_table (info
)->special_sections
[i
] = csect
;
1634 /* Now we have enough information to add the symbol to the
1635 linker hash table. */
1637 if (EXTERN_SYM_P (sym
.n_sclass
))
1642 BFD_ASSERT (section
!= NULL
);
1644 /* We must copy the name into memory if we got it from the
1645 syment itself, rather than the string table. */
1646 copy
= default_copy
;
1647 if (sym
._n
._n_n
._n_zeroes
!= 0
1648 || sym
._n
._n_n
._n_offset
== 0)
1651 /* The AIX linker appears to only detect multiple symbol
1652 definitions when there is a reference to the symbol. If
1653 a symbol is defined multiple times, and the only
1654 references are from the same object file, the AIX linker
1655 appears to permit it. It does not merge the different
1656 definitions, but handles them independently. On the
1657 other hand, if there is a reference, the linker reports
1660 This matters because the AIX <net/net_globals.h> header
1661 file actually defines an initialized array, so we have to
1662 actually permit that to work.
1664 Just to make matters even more confusing, the AIX linker
1665 appears to permit multiple symbol definitions whenever
1666 the second definition is in an archive rather than an
1667 object file. This may be a consequence of the manner in
1668 which it handles archives: I think it may load the entire
1669 archive in as separate csects, and then let garbage
1670 collection discard symbols.
1672 We also have to handle the case of statically linking a
1673 shared object, which will cause symbol redefinitions,
1674 although this is an easier case to detect. */
1676 if (info
->output_bfd
->xvec
== abfd
->xvec
)
1678 if (! bfd_is_und_section (section
))
1679 *sym_hash
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1680 name
, TRUE
, copy
, FALSE
);
1682 /* Make a copy of the symbol name to prevent problems with
1684 *sym_hash
= ((struct xcoff_link_hash_entry
*)
1685 bfd_wrapped_link_hash_lookup (abfd
, info
, name
,
1686 TRUE
, TRUE
, FALSE
));
1688 if (*sym_hash
== NULL
)
1690 if (((*sym_hash
)->root
.type
== bfd_link_hash_defined
1691 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
1692 && ! bfd_is_und_section (section
)
1693 && ! bfd_is_com_section (section
))
1695 /* This is a second definition of a defined symbol. */
1696 if ((abfd
->flags
& DYNAMIC
) != 0
1697 && ((*sym_hash
)->smclas
!= XMC_GL
1698 || aux
.x_csect
.x_smclas
== XMC_GL
1699 || ((*sym_hash
)->root
.u
.def
.section
->owner
->flags
1702 /* The new symbol is from a shared library, and
1703 either the existing symbol is not global
1704 linkage code or this symbol is global linkage
1705 code. If the existing symbol is global
1706 linkage code and the new symbol is not, then
1707 we want to use the new symbol. */
1708 section
= bfd_und_section_ptr
;
1711 else if (((*sym_hash
)->flags
& XCOFF_DEF_REGULAR
) == 0
1712 && ((*sym_hash
)->flags
& XCOFF_DEF_DYNAMIC
) != 0)
1714 /* The existing symbol is from a shared library.
1716 (*sym_hash
)->root
.type
= bfd_link_hash_undefined
;
1717 (*sym_hash
)->root
.u
.undef
.abfd
=
1718 (*sym_hash
)->root
.u
.def
.section
->owner
;
1720 else if (abfd
->my_archive
!= NULL
)
1722 /* This is a redefinition in an object contained
1723 in an archive. Just ignore it. See the
1725 section
= bfd_und_section_ptr
;
1728 else if (sym
.n_sclass
== C_AIX_WEAKEXT
1729 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
1731 /* At least one of the definitions is weak.
1732 Allow the normal rules to take effect. */
1734 else if ((*sym_hash
)->root
.u
.undef
.next
!= NULL
1735 || info
->hash
->undefs_tail
== &(*sym_hash
)->root
)
1737 /* This symbol has been referenced. In this
1738 case, we just continue and permit the
1739 multiple definition error. See the comment
1740 above about the behaviour of the AIX linker. */
1742 else if ((*sym_hash
)->smclas
== aux
.x_csect
.x_smclas
)
1744 /* The symbols are both csects of the same
1745 class. There is at least a chance that this
1746 is a semi-legitimate redefinition. */
1747 section
= bfd_und_section_ptr
;
1749 (*sym_hash
)->flags
|= XCOFF_MULTIPLY_DEFINED
;
1752 else if (((*sym_hash
)->flags
& XCOFF_MULTIPLY_DEFINED
) != 0
1753 && (*sym_hash
)->root
.type
== bfd_link_hash_defined
1754 && (bfd_is_und_section (section
)
1755 || bfd_is_com_section (section
)))
1757 /* This is a reference to a multiply defined symbol.
1758 Report the error now. See the comment above
1759 about the behaviour of the AIX linker. We could
1760 also do this with warning symbols, but I'm not
1761 sure the XCOFF linker is wholly prepared to
1762 handle them, and that would only be a warning,
1764 if (! ((*info
->callbacks
->multiple_definition
)
1765 (info
, (*sym_hash
)->root
.root
.string
,
1766 NULL
, NULL
, (bfd_vma
) 0,
1767 (*sym_hash
)->root
.u
.def
.section
->owner
,
1768 (*sym_hash
)->root
.u
.def
.section
,
1769 (*sym_hash
)->root
.u
.def
.value
)))
1771 /* Try not to give this error too many times. */
1772 (*sym_hash
)->flags
&= ~XCOFF_MULTIPLY_DEFINED
;
1776 /* _bfd_generic_link_add_one_symbol may call the linker to
1777 generate an error message, and the linker may try to read
1778 the symbol table to give a good error. Right now, the
1779 line numbers are in an inconsistent state, since they are
1780 counted both in the real sections and in the new csects.
1781 We need to leave the count in the real sections so that
1782 the linker can report the line number of the error
1783 correctly, so temporarily clobber the link to the csects
1784 so that the linker will not try to read the line numbers
1785 a second time from the csects. */
1786 BFD_ASSERT (last_real
->next
== first_csect
);
1787 last_real
->next
= NULL
;
1788 flags
= (sym
.n_sclass
== C_EXT
? BSF_GLOBAL
: BSF_WEAK
);
1789 if (! (_bfd_generic_link_add_one_symbol
1790 (info
, abfd
, name
, flags
, section
, value
,
1792 (struct bfd_link_hash_entry
**) sym_hash
)))
1794 last_real
->next
= first_csect
;
1796 if (smtyp
== XTY_CM
)
1798 if ((*sym_hash
)->root
.type
!= bfd_link_hash_common
1799 || (*sym_hash
)->root
.u
.c
.p
->section
!= csect
)
1800 /* We don't need the common csect we just created. */
1803 (*sym_hash
)->root
.u
.c
.p
->alignment_power
1804 = csect
->alignment_power
;
1807 if (info
->output_bfd
->xvec
== abfd
->xvec
)
1811 if (smtyp
== XTY_ER
|| smtyp
== XTY_CM
)
1812 flag
= XCOFF_REF_REGULAR
;
1814 flag
= XCOFF_DEF_REGULAR
;
1815 (*sym_hash
)->flags
|= flag
;
1817 if ((*sym_hash
)->smclas
== XMC_UA
1818 || flag
== XCOFF_DEF_REGULAR
)
1819 (*sym_hash
)->smclas
= aux
.x_csect
.x_smclas
;
1823 if (smtyp
== XTY_ER
)
1824 *csect_cache
= section
;
1827 *csect_cache
= csect
;
1829 xcoff_section_data (abfd
, csect
)->last_symndx
1830 = (esym
- (bfd_byte
*) obj_coff_external_syms (abfd
)) / symesz
;
1833 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1834 sym_hash
+= sym
.n_numaux
+ 1;
1835 csect_cache
+= sym
.n_numaux
+ 1;
1836 lineno_counts
+= sym
.n_numaux
+ 1;
1839 BFD_ASSERT (last_real
== NULL
|| last_real
->next
== first_csect
);
1841 /* Make sure that we have seen all the relocs. */
1842 for (o
= abfd
->sections
; o
!= first_csect
; o
= o
->next
)
1844 /* Reset the section size and the line number count, since the
1845 data is now attached to the csects. Don't reset the size of
1846 the .debug section, since we need to read it below in
1847 bfd_xcoff_size_dynamic_sections. */
1848 if (strcmp (bfd_get_section_name (abfd
, o
), ".debug") != 0)
1850 o
->lineno_count
= 0;
1852 if ((o
->flags
& SEC_RELOC
) != 0)
1855 struct internal_reloc
*rel
;
1856 asection
**rel_csect
;
1858 rel
= reloc_info
[o
->target_index
].relocs
;
1859 rel_csect
= reloc_info
[o
->target_index
].csects
;
1861 for (i
= 0; i
< o
->reloc_count
; i
++, rel
++, rel_csect
++)
1863 if (*rel_csect
== NULL
)
1865 (*_bfd_error_handler
)
1866 (_("%B: reloc %s:%d not in csect"),
1868 bfd_set_error (bfd_error_bad_value
);
1872 /* We identify all function symbols that are the target
1873 of a relocation, so that we can create glue code for
1874 functions imported from dynamic objects. */
1875 if (info
->output_bfd
->xvec
== abfd
->xvec
1876 && *rel_csect
!= bfd_und_section_ptr
1877 && obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
] != NULL
)
1879 struct xcoff_link_hash_entry
*h
;
1881 h
= obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
];
1882 /* If the symbol name starts with a period, it is
1883 the code of a function. If the symbol is
1884 currently undefined, then add an undefined symbol
1885 for the function descriptor. This should do no
1886 harm, because any regular object that defines the
1887 function should also define the function
1888 descriptor. It helps, because it means that we
1889 will identify the function descriptor with a
1890 dynamic object if a dynamic object defines it. */
1891 if (h
->root
.root
.string
[0] == '.'
1892 && h
->descriptor
== NULL
)
1894 struct xcoff_link_hash_entry
*hds
;
1895 struct bfd_link_hash_entry
*bh
;
1897 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1898 h
->root
.root
.string
+ 1,
1902 if (hds
->root
.type
== bfd_link_hash_new
)
1905 if (! (_bfd_generic_link_add_one_symbol
1906 (info
, abfd
, hds
->root
.root
.string
,
1907 (flagword
) 0, bfd_und_section_ptr
,
1908 (bfd_vma
) 0, NULL
, FALSE
,
1911 hds
= (struct xcoff_link_hash_entry
*) bh
;
1913 hds
->flags
|= XCOFF_DESCRIPTOR
;
1914 BFD_ASSERT ((h
->flags
& XCOFF_DESCRIPTOR
) == 0);
1915 hds
->descriptor
= h
;
1916 h
->descriptor
= hds
;
1918 if (h
->root
.root
.string
[0] == '.')
1919 h
->flags
|= XCOFF_CALLED
;
1923 free (reloc_info
[o
->target_index
].csects
);
1924 reloc_info
[o
->target_index
].csects
= NULL
;
1926 /* Reset SEC_RELOC and the reloc_count, since the reloc
1927 information is now attached to the csects. */
1928 o
->flags
&=~ SEC_RELOC
;
1931 /* If we are not keeping memory, free the reloc information. */
1932 if (! info
->keep_memory
1933 && coff_section_data (abfd
, o
) != NULL
1934 && coff_section_data (abfd
, o
)->relocs
!= NULL
1935 && ! coff_section_data (abfd
, o
)->keep_relocs
)
1937 free (coff_section_data (abfd
, o
)->relocs
);
1938 coff_section_data (abfd
, o
)->relocs
= NULL
;
1942 /* Free up the line numbers. FIXME: We could cache these
1943 somewhere for the final link, to avoid reading them again. */
1944 if (reloc_info
[o
->target_index
].linenos
!= NULL
)
1946 free (reloc_info
[o
->target_index
].linenos
);
1947 reloc_info
[o
->target_index
].linenos
= NULL
;
1953 obj_coff_keep_syms (abfd
) = keep_syms
;
1958 if (reloc_info
!= NULL
)
1960 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1962 if (reloc_info
[o
->target_index
].csects
!= NULL
)
1963 free (reloc_info
[o
->target_index
].csects
);
1964 if (reloc_info
[o
->target_index
].linenos
!= NULL
)
1965 free (reloc_info
[o
->target_index
].linenos
);
1969 obj_coff_keep_syms (abfd
) = keep_syms
;
1976 /* Add symbols from an XCOFF object file. */
1979 xcoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
1981 if (! _bfd_coff_get_external_symbols (abfd
))
1983 if (! xcoff_link_add_symbols (abfd
, info
))
1985 if (! info
->keep_memory
)
1987 if (! _bfd_coff_free_symbols (abfd
))
1993 /* Look through the loader symbols to see if this dynamic object
1994 should be included in the link. The native linker uses the loader
1995 symbols, not the normal symbol table, so we do too. */
1998 xcoff_link_check_dynamic_ar_symbols (bfd
*abfd
,
1999 struct bfd_link_info
*info
,
2000 bfd_boolean
*pneeded
)
2004 struct internal_ldhdr ldhdr
;
2005 const char *strings
;
2006 bfd_byte
*elsym
, *elsymend
;
2010 lsec
= bfd_get_section_by_name (abfd
, ".loader");
2012 /* There are no symbols, so don't try to include it. */
2015 if (! xcoff_get_section_contents (abfd
, lsec
))
2017 contents
= coff_section_data (abfd
, lsec
)->contents
;
2019 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
2021 strings
= (char *) contents
+ ldhdr
.l_stoff
;
2023 elsym
= contents
+ bfd_xcoff_loader_symbol_offset (abfd
, &ldhdr
);
2025 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz (abfd
);
2026 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz (abfd
))
2028 struct internal_ldsym ldsym
;
2029 char nambuf
[SYMNMLEN
+ 1];
2031 struct bfd_link_hash_entry
*h
;
2033 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
2035 /* We are only interested in exported symbols. */
2036 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
2039 if (ldsym
._l
._l_l
._l_zeroes
== 0)
2040 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
2043 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
2044 nambuf
[SYMNMLEN
] = '\0';
2048 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
2050 /* We are only interested in symbols that are currently
2051 undefined. At this point we know that we are using an XCOFF
2054 && h
->type
== bfd_link_hash_undefined
2055 && (((struct xcoff_link_hash_entry
*) h
)->flags
2056 & XCOFF_DEF_DYNAMIC
) == 0)
2058 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
2065 /* We do not need this shared object. */
2066 if (contents
!= NULL
&& ! coff_section_data (abfd
, lsec
)->keep_contents
)
2068 free (coff_section_data (abfd
, lsec
)->contents
);
2069 coff_section_data (abfd
, lsec
)->contents
= NULL
;
2075 /* Look through the symbols to see if this object file should be
2076 included in the link. */
2079 xcoff_link_check_ar_symbols (bfd
*abfd
,
2080 struct bfd_link_info
*info
,
2081 bfd_boolean
*pneeded
)
2083 bfd_size_type symesz
;
2089 if ((abfd
->flags
& DYNAMIC
) != 0
2090 && ! info
->static_link
2091 && info
->output_bfd
->xvec
== abfd
->xvec
)
2092 return xcoff_link_check_dynamic_ar_symbols (abfd
, info
, pneeded
);
2094 symesz
= bfd_coff_symesz (abfd
);
2095 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
2096 esym_end
= esym
+ obj_raw_syment_count (abfd
) * symesz
;
2097 while (esym
< esym_end
)
2099 struct internal_syment sym
;
2101 bfd_coff_swap_sym_in (abfd
, (void *) esym
, (void *) &sym
);
2103 if (EXTERN_SYM_P (sym
.n_sclass
) && sym
.n_scnum
!= N_UNDEF
)
2106 char buf
[SYMNMLEN
+ 1];
2107 struct bfd_link_hash_entry
*h
;
2109 /* This symbol is externally visible, and is defined by this
2111 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
2115 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
2117 /* We are only interested in symbols that are currently
2118 undefined. If a symbol is currently known to be common,
2119 XCOFF linkers do not bring in an object file which
2120 defines it. We also don't bring in symbols to satisfy
2121 undefined references in shared objects. */
2123 && h
->type
== bfd_link_hash_undefined
2124 && (info
->output_bfd
->xvec
!= abfd
->xvec
2125 || (((struct xcoff_link_hash_entry
*) h
)->flags
2126 & XCOFF_DEF_DYNAMIC
) == 0))
2128 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
2135 esym
+= (sym
.n_numaux
+ 1) * symesz
;
2138 /* We do not need this object file. */
2142 /* Check a single archive element to see if we need to include it in
2143 the link. *PNEEDED is set according to whether this element is
2144 needed in the link or not. This is called via
2145 _bfd_generic_link_add_archive_symbols. */
2148 xcoff_link_check_archive_element (bfd
*abfd
,
2149 struct bfd_link_info
*info
,
2150 bfd_boolean
*pneeded
)
2152 if (! _bfd_coff_get_external_symbols (abfd
))
2155 if (! xcoff_link_check_ar_symbols (abfd
, info
, pneeded
))
2160 if (! xcoff_link_add_symbols (abfd
, info
))
2164 if (! info
->keep_memory
|| ! *pneeded
)
2166 if (! _bfd_coff_free_symbols (abfd
))
2173 /* Given an XCOFF BFD, add symbols to the global hash table as
2177 _bfd_xcoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2179 switch (bfd_get_format (abfd
))
2182 return xcoff_link_add_object_symbols (abfd
, info
);
2185 /* If the archive has a map, do the usual search. We then need
2186 to check the archive for dynamic objects, because they may not
2187 appear in the archive map even though they should, perhaps, be
2188 included. If the archive has no map, we just consider each object
2189 file in turn, since that apparently is what the AIX native linker
2191 if (bfd_has_map (abfd
))
2193 if (! (_bfd_generic_link_add_archive_symbols
2194 (abfd
, info
, xcoff_link_check_archive_element
)))
2201 member
= bfd_openr_next_archived_file (abfd
, NULL
);
2202 while (member
!= NULL
)
2204 if (bfd_check_format (member
, bfd_object
)
2205 && (info
->output_bfd
->xvec
== member
->xvec
)
2206 && (! bfd_has_map (abfd
) || (member
->flags
& DYNAMIC
) != 0))
2210 if (! xcoff_link_check_archive_element (member
, info
,
2214 member
->archive_pass
= -1;
2216 member
= bfd_openr_next_archived_file (abfd
, member
);
2223 bfd_set_error (bfd_error_wrong_format
);
2228 /* If symbol H has not been interpreted as a function descriptor,
2229 see whether it should be. Set up its descriptor information if so. */
2232 xcoff_find_function (struct bfd_link_info
*info
,
2233 struct xcoff_link_hash_entry
*h
)
2235 if ((h
->flags
& XCOFF_DESCRIPTOR
) == 0
2236 && h
->root
.root
.string
[0] != '.')
2239 struct xcoff_link_hash_entry
*hfn
;
2242 amt
= strlen (h
->root
.root
.string
) + 2;
2243 fnname
= bfd_malloc (amt
);
2247 strcpy (fnname
+ 1, h
->root
.root
.string
);
2248 hfn
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2249 fnname
, FALSE
, FALSE
, TRUE
);
2252 && hfn
->smclas
== XMC_PR
2253 && (hfn
->root
.type
== bfd_link_hash_defined
2254 || hfn
->root
.type
== bfd_link_hash_defweak
))
2256 h
->flags
|= XCOFF_DESCRIPTOR
;
2257 h
->descriptor
= hfn
;
2258 hfn
->descriptor
= h
;
2264 /* H is an imported symbol. Set the import module's path, file and member
2265 to IMPATH, IMPFILE and IMPMEMBER respectively. All three are null if
2266 no specific import module is specified. */
2269 xcoff_set_import_path (struct bfd_link_info
*info
,
2270 struct xcoff_link_hash_entry
*h
,
2271 const char *imppath
, const char *impfile
,
2272 const char *impmember
)
2275 struct xcoff_import_file
**pp
;
2277 /* We overload the ldindx field to hold the l_ifile value for this
2279 BFD_ASSERT (h
->ldsym
== NULL
);
2280 BFD_ASSERT ((h
->flags
& XCOFF_BUILT_LDSYM
) == 0);
2281 if (imppath
== NULL
)
2285 /* We start c at 1 because the first entry in the import list is
2286 reserved for the library search path. */
2287 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
2289 pp
= &(*pp
)->next
, ++c
)
2291 if (strcmp ((*pp
)->path
, imppath
) == 0
2292 && strcmp ((*pp
)->file
, impfile
) == 0
2293 && strcmp ((*pp
)->member
, impmember
) == 0)
2299 struct xcoff_import_file
*n
;
2300 bfd_size_type amt
= sizeof (* n
);
2302 n
= bfd_alloc (info
->output_bfd
, amt
);
2308 n
->member
= impmember
;
2316 /* Mark a symbol as not being garbage, including the section in which
2319 static inline bfd_boolean
2320 xcoff_mark_symbol (struct bfd_link_info
*info
, struct xcoff_link_hash_entry
*h
)
2322 if ((h
->flags
& XCOFF_MARK
) != 0)
2325 h
->flags
|= XCOFF_MARK
;
2327 /* If we're marking an undefined symbol, try find some way of
2329 if (!info
->relocatable
2330 && (h
->flags
& XCOFF_IMPORT
) == 0
2331 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
2332 && (h
->root
.type
== bfd_link_hash_undefined
2333 || h
->root
.type
== bfd_link_hash_undefweak
))
2335 /* First check whether this symbol can be interpreted as an
2336 undefined function descriptor for a defined function symbol. */
2337 if (!xcoff_find_function (info
, h
))
2340 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
2341 && (h
->descriptor
->root
.type
== bfd_link_hash_defined
2342 || h
->descriptor
->root
.type
== bfd_link_hash_defweak
))
2344 /* This is a descriptor for a defined symbol, but the input
2345 objects have not defined the descriptor itself. Fill in
2346 the definition automatically.
2348 Note that we do this even if we found a dynamic definition
2349 of H. The local function definition logically overrides
2353 sec
= xcoff_hash_table (info
)->descriptor_section
;
2354 h
->root
.type
= bfd_link_hash_defined
;
2355 h
->root
.u
.def
.section
= sec
;
2356 h
->root
.u
.def
.value
= sec
->size
;
2358 h
->flags
|= XCOFF_DEF_REGULAR
;
2360 /* The size of the function descriptor depends on whether this
2361 is xcoff32 (12) or xcoff64 (24). */
2362 sec
->size
+= bfd_xcoff_function_descriptor_size (sec
->owner
);
2364 /* A function descriptor uses two relocs: one for the
2365 associated code, and one for the TOC address. */
2366 xcoff_hash_table (info
)->ldrel_count
+= 2;
2367 sec
->reloc_count
+= 2;
2369 /* Mark the function itself. */
2370 if (!xcoff_mark_symbol (info
, h
->descriptor
))
2373 /* Mark the TOC section, so that we get an anchor
2374 to relocate against. */
2375 if (!xcoff_mark (info
, xcoff_hash_table (info
)->toc_section
))
2378 /* We handle writing out the contents of the descriptor in
2379 xcoff_write_global_symbol. */
2381 else if ((h
->flags
& XCOFF_CALLED
) != 0)
2383 /* This is a function symbol for which we need to create
2386 struct xcoff_link_hash_entry
*hds
;
2388 /* Mark the descriptor (and its TOC section). */
2389 hds
= h
->descriptor
;
2390 BFD_ASSERT ((hds
->root
.type
== bfd_link_hash_undefined
2391 || hds
->root
.type
== bfd_link_hash_undefweak
)
2392 && (hds
->flags
& XCOFF_DEF_REGULAR
) == 0);
2393 if (!xcoff_mark_symbol (info
, hds
))
2396 /* Treat this symbol as undefined if the descriptor was. */
2397 if ((hds
->flags
& XCOFF_WAS_UNDEFINED
) != 0)
2398 h
->flags
|= XCOFF_WAS_UNDEFINED
;
2400 /* Allocate room for the global linkage code itself. */
2401 sec
= xcoff_hash_table (info
)->linkage_section
;
2402 h
->root
.type
= bfd_link_hash_defined
;
2403 h
->root
.u
.def
.section
= sec
;
2404 h
->root
.u
.def
.value
= sec
->size
;
2406 h
->flags
|= XCOFF_DEF_REGULAR
;
2407 sec
->size
+= bfd_xcoff_glink_code_size (info
->output_bfd
);
2409 /* The global linkage code requires a TOC entry for the
2411 if (hds
->toc_section
== NULL
)
2416 xcoff32 uses 4 bytes in the toc.
2417 xcoff64 uses 8 bytes in the toc. */
2418 if (bfd_xcoff_is_xcoff64 (info
->output_bfd
))
2420 else if (bfd_xcoff_is_xcoff32 (info
->output_bfd
))
2425 /* Allocate room in the fallback TOC section. */
2426 hds
->toc_section
= xcoff_hash_table (info
)->toc_section
;
2427 hds
->u
.toc_offset
= hds
->toc_section
->size
;
2428 hds
->toc_section
->size
+= byte_size
;
2429 if (!xcoff_mark (info
, hds
->toc_section
))
2432 /* Allocate room for a static and dynamic R_TOC
2434 ++xcoff_hash_table (info
)->ldrel_count
;
2435 ++hds
->toc_section
->reloc_count
;
2437 /* Set the index to -2 to force this symbol to
2440 hds
->flags
|= XCOFF_SET_TOC
| XCOFF_LDREL
;
2443 else if ((h
->flags
& XCOFF_DEF_DYNAMIC
) == 0)
2445 /* Record that the symbol was undefined, then import it.
2446 -brtl links use a special fake import file. */
2447 h
->flags
|= XCOFF_WAS_UNDEFINED
| XCOFF_IMPORT
;
2448 if (xcoff_hash_table (info
)->rtld
)
2450 if (!xcoff_set_import_path (info
, h
, "", "..", ""))
2455 if (!xcoff_set_import_path (info
, h
, NULL
, NULL
, NULL
))
2461 if (h
->root
.type
== bfd_link_hash_defined
2462 || h
->root
.type
== bfd_link_hash_defweak
)
2466 hsec
= h
->root
.u
.def
.section
;
2467 if (! bfd_is_abs_section (hsec
)
2468 && (hsec
->flags
& SEC_MARK
) == 0)
2470 if (! xcoff_mark (info
, hsec
))
2475 if (h
->toc_section
!= NULL
2476 && (h
->toc_section
->flags
& SEC_MARK
) == 0)
2478 if (! xcoff_mark (info
, h
->toc_section
))
2485 /* Look for a symbol called NAME. If the symbol is defined, mark it.
2486 If the symbol exists, set FLAGS. */
2489 xcoff_mark_symbol_by_name (struct bfd_link_info
*info
,
2490 const char *name
, unsigned int flags
)
2492 struct xcoff_link_hash_entry
*h
;
2494 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
,
2495 FALSE
, FALSE
, TRUE
);
2499 if (h
->root
.type
== bfd_link_hash_defined
2500 || h
->root
.type
== bfd_link_hash_defweak
)
2502 if (!xcoff_mark (info
, h
->root
.u
.def
.section
))
2509 /* The mark phase of garbage collection. For a given section, mark
2510 it, and all the sections which define symbols to which it refers.
2511 Because this function needs to look at the relocs, we also count
2512 the number of relocs which need to be copied into the .loader
2516 xcoff_mark (struct bfd_link_info
*info
, asection
*sec
)
2518 if (bfd_is_abs_section (sec
)
2519 || (sec
->flags
& SEC_MARK
) != 0)
2522 sec
->flags
|= SEC_MARK
;
2524 if (sec
->owner
->xvec
== info
->output_bfd
->xvec
2525 && coff_section_data (sec
->owner
, sec
) != NULL
2526 && xcoff_section_data (sec
->owner
, sec
) != NULL
)
2528 struct xcoff_link_hash_entry
**syms
;
2529 struct internal_reloc
*rel
, *relend
;
2531 unsigned long i
, first
, last
;
2533 /* Mark all the symbols in this section. */
2534 syms
= obj_xcoff_sym_hashes (sec
->owner
);
2535 csects
= xcoff_data (sec
->owner
)->csects
;
2536 first
= xcoff_section_data (sec
->owner
, sec
)->first_symndx
;
2537 last
= xcoff_section_data (sec
->owner
, sec
)->last_symndx
;
2538 for (i
= first
; i
<= last
; i
++)
2539 if (csects
[i
] == sec
2541 && (syms
[i
]->flags
& XCOFF_MARK
) == 0)
2543 if (!xcoff_mark_symbol (info
, syms
[i
]))
2547 /* Look through the section relocs. */
2548 if ((sec
->flags
& SEC_RELOC
) != 0
2549 && sec
->reloc_count
> 0)
2551 rel
= xcoff_read_internal_relocs (sec
->owner
, sec
, TRUE
,
2555 relend
= rel
+ sec
->reloc_count
;
2556 for (; rel
< relend
; rel
++)
2558 struct xcoff_link_hash_entry
*h
;
2560 if ((unsigned int) rel
->r_symndx
2561 > obj_raw_syment_count (sec
->owner
))
2564 h
= obj_xcoff_sym_hashes (sec
->owner
)[rel
->r_symndx
];
2567 if ((h
->flags
& XCOFF_MARK
) == 0)
2569 if (!xcoff_mark_symbol (info
, h
))
2577 rsec
= xcoff_data (sec
->owner
)->csects
[rel
->r_symndx
];
2579 && (rsec
->flags
& SEC_MARK
) == 0)
2581 if (!xcoff_mark (info
, rsec
))
2586 /* See if this reloc needs to be copied into the .loader
2588 switch (rel
->r_type
)
2592 || h
->root
.type
== bfd_link_hash_defined
2593 || h
->root
.type
== bfd_link_hash_defweak
2594 || h
->root
.type
== bfd_link_hash_common
2595 /* We will always provide a local definition of
2596 function symbols. */
2597 || (h
->flags
& XCOFF_CALLED
) != 0)
2605 && (h
->root
.type
== bfd_link_hash_defined
2606 || h
->root
.type
== bfd_link_hash_defweak
)
2607 && bfd_is_abs_section (h
->root
.u
.def
.section
))
2609 ++xcoff_hash_table (info
)->ldrel_count
;
2611 h
->flags
|= XCOFF_LDREL
;
2618 /* We should never need a .loader reloc for a TOC
2624 if (! info
->keep_memory
2625 && coff_section_data (sec
->owner
, sec
) != NULL
2626 && coff_section_data (sec
->owner
, sec
)->relocs
!= NULL
2627 && ! coff_section_data (sec
->owner
, sec
)->keep_relocs
)
2629 free (coff_section_data (sec
->owner
, sec
)->relocs
);
2630 coff_section_data (sec
->owner
, sec
)->relocs
= NULL
;
2638 /* Routines that are called after all the input files have been
2639 handled, but before the sections are laid out in memory. */
2641 /* The sweep phase of garbage collection. Remove all garbage
2645 xcoff_sweep (struct bfd_link_info
*info
)
2649 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
2653 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
2655 if ((o
->flags
& SEC_MARK
) == 0)
2657 /* Keep all sections from non-XCOFF input files. Keep
2658 special sections. Keep .debug sections for the
2660 if (sub
->xvec
!= info
->output_bfd
->xvec
2661 || o
== xcoff_hash_table (info
)->debug_section
2662 || o
== xcoff_hash_table (info
)->loader_section
2663 || o
== xcoff_hash_table (info
)->linkage_section
2664 || o
== xcoff_hash_table (info
)->descriptor_section
2665 || strcmp (o
->name
, ".debug") == 0)
2666 o
->flags
|= SEC_MARK
;
2677 /* Record the number of elements in a set. This is used to output the
2678 correct csect length. */
2681 bfd_xcoff_link_record_set (bfd
*output_bfd
,
2682 struct bfd_link_info
*info
,
2683 struct bfd_link_hash_entry
*harg
,
2686 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2687 struct xcoff_link_size_list
*n
;
2690 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2693 /* This will hardly ever be called. I don't want to burn four bytes
2694 per global symbol, so instead the size is kept on a linked list
2695 attached to the hash table. */
2697 n
= bfd_alloc (output_bfd
, amt
);
2700 n
->next
= xcoff_hash_table (info
)->size_list
;
2703 xcoff_hash_table (info
)->size_list
= n
;
2705 h
->flags
|= XCOFF_HAS_SIZE
;
2710 /* Import a symbol. */
2713 bfd_xcoff_import_symbol (bfd
*output_bfd
,
2714 struct bfd_link_info
*info
,
2715 struct bfd_link_hash_entry
*harg
,
2717 const char *imppath
,
2718 const char *impfile
,
2719 const char *impmember
,
2720 unsigned int syscall_flag
)
2722 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2724 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2727 /* A symbol name which starts with a period is the code for a
2728 function. If the symbol is undefined, then add an undefined
2729 symbol for the function descriptor, and import that instead. */
2730 if (h
->root
.root
.string
[0] == '.'
2731 && h
->root
.type
== bfd_link_hash_undefined
2732 && val
== (bfd_vma
) -1)
2734 struct xcoff_link_hash_entry
*hds
;
2736 hds
= h
->descriptor
;
2739 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2740 h
->root
.root
.string
+ 1,
2744 if (hds
->root
.type
== bfd_link_hash_new
)
2746 hds
->root
.type
= bfd_link_hash_undefined
;
2747 hds
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
2749 hds
->flags
|= XCOFF_DESCRIPTOR
;
2750 BFD_ASSERT ((h
->flags
& XCOFF_DESCRIPTOR
) == 0);
2751 hds
->descriptor
= h
;
2752 h
->descriptor
= hds
;
2755 /* Now, if the descriptor is undefined, import the descriptor
2756 rather than the symbol we were told to import. FIXME: Is
2757 this correct in all cases? */
2758 if (hds
->root
.type
== bfd_link_hash_undefined
)
2762 h
->flags
|= (XCOFF_IMPORT
| syscall_flag
);
2764 if (val
!= (bfd_vma
) -1)
2766 if (h
->root
.type
== bfd_link_hash_defined
2767 && (! bfd_is_abs_section (h
->root
.u
.def
.section
)
2768 || h
->root
.u
.def
.value
!= val
))
2770 if (! ((*info
->callbacks
->multiple_definition
)
2771 (info
, h
->root
.root
.string
, h
->root
.u
.def
.section
->owner
,
2772 h
->root
.u
.def
.section
, h
->root
.u
.def
.value
,
2773 output_bfd
, bfd_abs_section_ptr
, val
)))
2777 h
->root
.type
= bfd_link_hash_defined
;
2778 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2779 h
->root
.u
.def
.value
= val
;
2783 if (!xcoff_set_import_path (info
, h
, imppath
, impfile
, impmember
))
2789 /* Export a symbol. */
2792 bfd_xcoff_export_symbol (bfd
*output_bfd
,
2793 struct bfd_link_info
*info
,
2794 struct bfd_link_hash_entry
*harg
)
2796 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2798 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2801 h
->flags
|= XCOFF_EXPORT
;
2803 /* FIXME: I'm not at all sure what syscall is supposed to mean, so
2804 I'm just going to ignore it until somebody explains it. */
2806 /* Make sure we don't garbage collect this symbol. */
2807 if (! xcoff_mark_symbol (info
, h
))
2810 /* If this is a function descriptor, make sure we don't garbage
2811 collect the associated function code. We normally don't have to
2812 worry about this, because the descriptor will be attached to a
2813 section with relocs, but if we are creating the descriptor
2814 ourselves those relocs will not be visible to the mark code. */
2815 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
2817 if (! xcoff_mark_symbol (info
, h
->descriptor
))
2824 /* Count a reloc against a symbol. This is called for relocs
2825 generated by the linker script, typically for global constructors
2829 bfd_xcoff_link_count_reloc (bfd
*output_bfd
,
2830 struct bfd_link_info
*info
,
2833 struct xcoff_link_hash_entry
*h
;
2835 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2838 h
= ((struct xcoff_link_hash_entry
*)
2839 bfd_wrapped_link_hash_lookup (output_bfd
, info
, name
, FALSE
, FALSE
,
2843 (*_bfd_error_handler
) (_("%s: no such symbol"), name
);
2844 bfd_set_error (bfd_error_no_symbols
);
2848 h
->flags
|= XCOFF_REF_REGULAR
| XCOFF_LDREL
;
2849 ++xcoff_hash_table (info
)->ldrel_count
;
2851 /* Mark the symbol to avoid garbage collection. */
2852 if (! xcoff_mark_symbol (info
, h
))
2858 /* This function is called for each symbol to which the linker script
2862 bfd_xcoff_record_link_assignment (bfd
*output_bfd
,
2863 struct bfd_link_info
*info
,
2866 struct xcoff_link_hash_entry
*h
;
2868 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2871 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, TRUE
, TRUE
,
2876 h
->flags
|= XCOFF_DEF_REGULAR
;
2881 /* Add a symbol to the .loader symbols, if necessary. */
2883 /* INPUT_BFD has an external symbol associated with hash table entry H
2884 and csect CSECT. Return true if INPUT_BFD defines H. */
2887 xcoff_final_definition_p (bfd
*input_bfd
, struct xcoff_link_hash_entry
*h
,
2890 switch (h
->root
.type
)
2892 case bfd_link_hash_defined
:
2893 case bfd_link_hash_defweak
:
2894 /* No input bfd owns absolute symbols. They are written by
2895 xcoff_write_global_symbol instead. */
2896 return (!bfd_is_abs_section (csect
)
2897 && h
->root
.u
.def
.section
== csect
);
2899 case bfd_link_hash_common
:
2900 return h
->root
.u
.c
.p
->section
->owner
== input_bfd
;
2902 case bfd_link_hash_undefined
:
2903 case bfd_link_hash_undefweak
:
2904 /* We can't treat undef.abfd as the owner because that bfd
2905 might be a dynamic object. Allow any bfd to claim it. */
2914 xcoff_build_ldsyms (struct xcoff_link_hash_entry
*h
, void * p
)
2916 struct xcoff_loader_info
*ldinfo
= (struct xcoff_loader_info
*) p
;
2919 if (h
->root
.type
== bfd_link_hash_warning
)
2920 h
= (struct xcoff_link_hash_entry
*) h
->root
.u
.i
.link
;
2922 /* __rtinit, this symbol has special handling. */
2923 if (h
->flags
& XCOFF_RTINIT
)
2926 /* If this is a final link, and the symbol was defined as a common
2927 symbol in a regular object file, and there was no definition in
2928 any dynamic object, then the linker will have allocated space for
2929 the symbol in a common section but the XCOFF_DEF_REGULAR flag
2930 will not have been set. */
2931 if (h
->root
.type
== bfd_link_hash_defined
2932 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
2933 && (h
->flags
& XCOFF_REF_REGULAR
) != 0
2934 && (h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
2935 && (bfd_is_abs_section (h
->root
.u
.def
.section
)
2936 || (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0))
2937 h
->flags
|= XCOFF_DEF_REGULAR
;
2939 /* If all defined symbols should be exported, mark them now. We
2940 don't want to export the actual functions, just the function
2942 if (ldinfo
->export_defineds
2943 && (h
->flags
& XCOFF_DEF_REGULAR
) != 0
2944 && h
->root
.root
.string
[0] != '.')
2948 /* We don't export a symbol which is being defined by an object
2949 included from an archive which contains a shared object. The
2950 rationale is that if an archive contains both an unshared and
2951 a shared object, then there must be some reason that the
2952 unshared object is unshared, and we don't want to start
2953 providing a shared version of it. In particular, this solves
2954 a bug involving the _savefNN set of functions. gcc will call
2955 those functions without providing a slot to restore the TOC,
2956 so it is essential that these functions be linked in directly
2957 and not from a shared object, which means that a shared
2958 object which also happens to link them in must not export
2959 them. This is confusing, but I haven't been able to think of
2960 a different approach. Note that the symbols can, of course,
2961 be exported explicitly. */
2963 if ((h
->root
.type
== bfd_link_hash_defined
2964 || h
->root
.type
== bfd_link_hash_defweak
)
2965 && h
->root
.u
.def
.section
->owner
!= NULL
2966 && h
->root
.u
.def
.section
->owner
->my_archive
!= NULL
)
2968 bfd
*arbfd
, *member
;
2970 arbfd
= h
->root
.u
.def
.section
->owner
->my_archive
;
2971 member
= bfd_openr_next_archived_file (arbfd
, NULL
);
2972 while (member
!= NULL
)
2974 if ((member
->flags
& DYNAMIC
) != 0)
2979 member
= bfd_openr_next_archived_file (arbfd
, member
);
2984 h
->flags
|= XCOFF_EXPORT
;
2987 /* We don't want to garbage collect symbols which are not defined in
2988 XCOFF files. This is a convenient place to mark them. */
2989 if (xcoff_hash_table (ldinfo
->info
)->gc
2990 && (h
->flags
& XCOFF_MARK
) == 0
2991 && (h
->root
.type
== bfd_link_hash_defined
2992 || h
->root
.type
== bfd_link_hash_defweak
)
2993 && (h
->root
.u
.def
.section
->owner
== NULL
2994 || (h
->root
.u
.def
.section
->owner
->xvec
2995 != ldinfo
->info
->output_bfd
->xvec
)))
2996 h
->flags
|= XCOFF_MARK
;
2998 /* If this symbol is exported, but not defined, we need to try to
3000 if ((h
->flags
& XCOFF_EXPORT
) != 0
3001 && (h
->flags
& XCOFF_WAS_UNDEFINED
) != 0)
3003 (*_bfd_error_handler
)
3004 (_("warning: attempt to export undefined symbol `%s'"),
3005 h
->root
.root
.string
);
3010 /* If this is still a common symbol, and it wasn't garbage
3011 collected, we need to actually allocate space for it in the .bss
3013 if (h
->root
.type
== bfd_link_hash_common
3014 && (! xcoff_hash_table (ldinfo
->info
)->gc
3015 || (h
->flags
& XCOFF_MARK
) != 0)
3016 && h
->root
.u
.c
.p
->section
->size
== 0)
3018 BFD_ASSERT (bfd_is_com_section (h
->root
.u
.c
.p
->section
));
3019 h
->root
.u
.c
.p
->section
->size
= h
->root
.u
.c
.size
;
3022 /* We need to add a symbol to the .loader section if it is mentioned
3023 in a reloc which we are copying to the .loader section and it was
3024 not defined or common, or if it is the entry point, or if it is
3027 if (((h
->flags
& XCOFF_LDREL
) == 0
3028 || h
->root
.type
== bfd_link_hash_defined
3029 || h
->root
.type
== bfd_link_hash_defweak
3030 || h
->root
.type
== bfd_link_hash_common
)
3031 && (h
->flags
& XCOFF_ENTRY
) == 0
3032 && (h
->flags
& XCOFF_EXPORT
) == 0)
3038 /* We don't need to add this symbol if we did garbage collection and
3039 we did not mark this symbol. */
3040 if (xcoff_hash_table (ldinfo
->info
)->gc
3041 && (h
->flags
& XCOFF_MARK
) == 0)
3047 /* We may have already processed this symbol due to the recursive
3049 if ((h
->flags
& XCOFF_BUILT_LDSYM
) != 0)
3052 /* We need to add this symbol to the .loader symbols. */
3054 BFD_ASSERT (h
->ldsym
== NULL
);
3055 amt
= sizeof (struct internal_ldsym
);
3056 h
->ldsym
= bfd_zalloc (ldinfo
->output_bfd
, amt
);
3057 if (h
->ldsym
== NULL
)
3059 ldinfo
->failed
= TRUE
;
3063 if ((h
->flags
& XCOFF_IMPORT
) != 0)
3064 h
->ldsym
->l_ifile
= h
->ldindx
;
3066 /* The first 3 symbol table indices are reserved to indicate the
3067 data, text and bss sections. */
3068 h
->ldindx
= ldinfo
->ldsym_count
+ 3;
3070 ++ldinfo
->ldsym_count
;
3072 if (! bfd_xcoff_put_ldsymbol_name (ldinfo
->output_bfd
, ldinfo
,
3073 h
->ldsym
, h
->root
.root
.string
))
3076 h
->flags
|= XCOFF_BUILT_LDSYM
;
3081 /* INPUT_BFD includes XCOFF symbol ISYM, which is associated with linker
3082 hash table entry H and csect CSECT. AUX contains ISYM's auxillary
3083 csect information, if any. NAME is the function's name if the name
3084 is stored in the .debug section, otherwise it is null.
3086 Return 1 if we should include an appropriately-adjusted ISYM
3087 in the output file, 0 if we should discard ISYM, or -1 if an
3091 xcoff_keep_symbol_p (struct bfd_link_info
*info
, bfd
*input_bfd
,
3092 struct internal_syment
*isym
,
3093 union internal_auxent
*aux
,
3094 struct xcoff_link_hash_entry
*h
,
3095 asection
*csect
, const char *name
)
3099 /* If we are skipping this csect, we want to strip the symbol too. */
3103 /* Likewise if we garbage-collected the csect. */
3104 if (xcoff_hash_table (info
)->gc
3105 && !bfd_is_abs_section (csect
)
3106 && !bfd_is_und_section (csect
)
3107 && (csect
->flags
& SEC_MARK
) == 0)
3110 /* An XCOFF linker always removes C_STAT symbols. */
3111 if (isym
->n_sclass
== C_STAT
)
3114 /* We generate the TOC anchor separately. */
3115 if (isym
->n_sclass
== C_HIDEXT
3116 && aux
->x_csect
.x_smclas
== XMC_TC0
)
3119 /* If we are stripping all symbols, we want to discard this one. */
3120 if (info
->strip
== strip_all
)
3123 /* Discard symbols that are defined elsewhere. */
3124 if (EXTERN_SYM_P (isym
->n_sclass
))
3126 if ((h
->flags
& XCOFF_ALLOCATED
) != 0)
3128 if (!xcoff_final_definition_p (input_bfd
, h
, csect
))
3132 /* If we're discarding local symbols, check whether ISYM is local. */
3133 smtyp
= SMTYP_SMTYP (aux
->x_csect
.x_smtyp
);
3134 if (info
->discard
== discard_all
3135 && !EXTERN_SYM_P (isym
->n_sclass
)
3136 && (isym
->n_sclass
!= C_HIDEXT
|| smtyp
!= XTY_SD
))
3139 /* If we're stripping debugging symbols, check whether ISYM is one. */
3140 if (info
->strip
== strip_debugger
3141 && isym
->n_scnum
== N_DEBUG
)
3144 /* If we are stripping symbols based on name, check how ISYM's
3145 name should be handled. */
3146 if (info
->strip
== strip_some
3147 || info
->discard
== discard_l
)
3149 char buf
[SYMNMLEN
+ 1];
3153 name
= _bfd_coff_internal_syment_name (input_bfd
, isym
, buf
);
3158 if (info
->strip
== strip_some
3159 && bfd_hash_lookup (info
->keep_hash
, name
, FALSE
, FALSE
) == NULL
)
3162 if (info
->discard
== discard_l
3163 && !EXTERN_SYM_P (isym
->n_sclass
)
3164 && (isym
->n_sclass
!= C_HIDEXT
|| smtyp
!= XTY_SD
)
3165 && bfd_is_local_label_name (input_bfd
, name
))
3172 /* Build the .loader section. This is called by the XCOFF linker
3173 emulation before_allocation routine. We must set the size of the
3174 .loader section before the linker lays out the output file.
3175 LIBPATH is the library path to search for shared objects; this is
3176 normally built from the -L arguments passed to the linker. ENTRY
3177 is the name of the entry point symbol (the -e linker option).
3178 FILE_ALIGN is the alignment to use for sections within the file
3179 (the -H linker option). MAXSTACK is the maximum stack size (the
3180 -bmaxstack linker option). MAXDATA is the maximum data size (the
3181 -bmaxdata linker option). GC is whether to do garbage collection
3182 (the -bgc linker option). MODTYPE is the module type (the
3183 -bmodtype linker option). TEXTRO is whether the text section must
3184 be read only (the -btextro linker option). EXPORT_DEFINEDS is
3185 whether all defined symbols should be exported (the -unix linker
3186 option). SPECIAL_SECTIONS is set by this routine to csects with
3187 magic names like _end. */
3190 bfd_xcoff_size_dynamic_sections (bfd
*output_bfd
,
3191 struct bfd_link_info
*info
,
3192 const char *libpath
,
3194 unsigned long file_align
,
3195 unsigned long maxstack
,
3196 unsigned long maxdata
,
3200 bfd_boolean export_defineds
,
3201 asection
**special_sections
,
3205 struct xcoff_loader_info ldinfo
;
3207 size_t impsize
, impcount
;
3208 struct xcoff_import_file
*fl
;
3209 struct internal_ldhdr
*ldhdr
;
3210 bfd_size_type stoff
;
3214 struct bfd_strtab_hash
*debug_strtab
;
3215 bfd_byte
*debug_contents
= NULL
;
3218 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
3220 for (i
= 0; i
< XCOFF_NUMBER_OF_SPECIAL_SECTIONS
; i
++)
3221 special_sections
[i
] = NULL
;
3225 ldinfo
.failed
= FALSE
;
3226 ldinfo
.output_bfd
= output_bfd
;
3228 ldinfo
.export_defineds
= export_defineds
;
3229 ldinfo
.ldsym_count
= 0;
3230 ldinfo
.string_size
= 0;
3231 ldinfo
.strings
= NULL
;
3232 ldinfo
.string_alc
= 0;
3234 xcoff_data (output_bfd
)->maxstack
= maxstack
;
3235 xcoff_data (output_bfd
)->maxdata
= maxdata
;
3236 xcoff_data (output_bfd
)->modtype
= modtype
;
3238 xcoff_hash_table (info
)->file_align
= file_align
;
3239 xcoff_hash_table (info
)->textro
= textro
;
3240 xcoff_hash_table (info
)->rtld
= rtld
;
3243 if (info
->init_function
|| info
->fini_function
|| rtld
)
3245 struct xcoff_link_hash_entry
*hsym
;
3246 struct internal_ldsym
*ldsym
;
3248 hsym
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
3249 "__rtinit", FALSE
, FALSE
, TRUE
);
3252 (*_bfd_error_handler
)
3253 (_("error: undefined symbol __rtinit"));
3257 xcoff_mark_symbol (info
, hsym
);
3258 hsym
->flags
|= (XCOFF_DEF_REGULAR
| XCOFF_RTINIT
);
3260 /* __rtinit initialized. */
3261 amt
= sizeof (* ldsym
);
3262 ldsym
= bfd_malloc (amt
);
3264 ldsym
->l_value
= 0; /* Will be filled in later. */
3265 ldsym
->l_scnum
= 2; /* Data section. */
3266 ldsym
->l_smtype
= XTY_SD
; /* Csect section definition. */
3267 ldsym
->l_smclas
= 5; /* .rw. */
3268 ldsym
->l_ifile
= 0; /* Special system loader symbol. */
3269 ldsym
->l_parm
= 0; /* NA. */
3271 /* Force __rtinit to be the first symbol in the loader symbol table
3272 See xcoff_build_ldsyms
3274 The first 3 symbol table indices are reserved to indicate the data,
3275 text and bss sections. */
3276 BFD_ASSERT (0 == ldinfo
.ldsym_count
);
3279 ldinfo
.ldsym_count
= 1;
3280 hsym
->ldsym
= ldsym
;
3282 if (! bfd_xcoff_put_ldsymbol_name (ldinfo
.output_bfd
, &ldinfo
,
3283 hsym
->ldsym
, hsym
->root
.root
.string
))
3286 /* This symbol is written out by xcoff_write_global_symbol
3287 Set stuff up so xcoff_write_global_symbol logic works. */
3288 hsym
->flags
|= XCOFF_DEF_REGULAR
| XCOFF_MARK
;
3289 hsym
->root
.type
= bfd_link_hash_defined
;
3290 hsym
->root
.u
.def
.value
= 0;
3293 /* Garbage collect unused sections. */
3294 if (info
->relocatable
|| !gc
)
3297 xcoff_hash_table (info
)->gc
= FALSE
;
3299 /* We still need to call xcoff_mark, in order to set ldrel_count
3301 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3305 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3307 /* We shouldn't unconditionaly mark the TOC section.
3308 The output file should only have a TOC if either
3309 (a) one of the input files did or (b) we end up
3310 creating TOC references as part of the link process. */
3311 if (o
!= xcoff_hash_table (info
)->toc_section
3312 && (o
->flags
& SEC_MARK
) == 0)
3314 if (! xcoff_mark (info
, o
))
3323 && !xcoff_mark_symbol_by_name (info
, entry
, XCOFF_ENTRY
))
3325 if (info
->init_function
!= NULL
3326 && !xcoff_mark_symbol_by_name (info
, info
->init_function
, 0))
3328 if (info
->fini_function
!= NULL
3329 && !xcoff_mark_symbol_by_name (info
, info
->fini_function
, 0))
3332 xcoff_hash_table (info
)->gc
= TRUE
;
3335 /* Return special sections to the caller. */
3336 for (i
= 0; i
< XCOFF_NUMBER_OF_SPECIAL_SECTIONS
; i
++)
3338 sec
= xcoff_hash_table (info
)->special_sections
[i
];
3342 && (sec
->flags
& SEC_MARK
) == 0)
3345 special_sections
[i
] = sec
;
3348 if (info
->input_bfds
== NULL
)
3349 /* I'm not sure what to do in this bizarre case. */
3352 xcoff_link_hash_traverse (xcoff_hash_table (info
), xcoff_build_ldsyms
,
3357 /* Work out the size of the import file names. Each import file ID
3358 consists of three null terminated strings: the path, the file
3359 name, and the archive member name. The first entry in the list
3360 of names is the path to use to find objects, which the linker has
3361 passed in as the libpath argument. For some reason, the path
3362 entry in the other import file names appears to always be empty. */
3363 impsize
= strlen (libpath
) + 3;
3365 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
3368 impsize
+= (strlen (fl
->path
)
3370 + strlen (fl
->member
)
3374 /* Set up the .loader section header. */
3375 ldhdr
= &xcoff_hash_table (info
)->ldhdr
;
3376 ldhdr
->l_version
= bfd_xcoff_ldhdr_version(output_bfd
);
3377 ldhdr
->l_nsyms
= ldinfo
.ldsym_count
;
3378 ldhdr
->l_nreloc
= xcoff_hash_table (info
)->ldrel_count
;
3379 ldhdr
->l_istlen
= impsize
;
3380 ldhdr
->l_nimpid
= impcount
;
3381 ldhdr
->l_impoff
= (bfd_xcoff_ldhdrsz(output_bfd
)
3382 + ldhdr
->l_nsyms
* bfd_xcoff_ldsymsz(output_bfd
)
3383 + ldhdr
->l_nreloc
* bfd_xcoff_ldrelsz(output_bfd
));
3384 ldhdr
->l_stlen
= ldinfo
.string_size
;
3385 stoff
= ldhdr
->l_impoff
+ impsize
;
3386 if (ldinfo
.string_size
== 0)
3389 ldhdr
->l_stoff
= stoff
;
3391 /* 64 bit elements to ldhdr
3392 The swap out routine for 32 bit will ignore them.
3393 Nothing fancy, symbols come after the header and relocs come
3395 ldhdr
->l_symoff
= bfd_xcoff_ldhdrsz (output_bfd
);
3396 ldhdr
->l_rldoff
= (bfd_xcoff_ldhdrsz (output_bfd
)
3397 + ldhdr
->l_nsyms
* bfd_xcoff_ldsymsz (output_bfd
));
3399 /* We now know the final size of the .loader section. Allocate
3401 lsec
= xcoff_hash_table (info
)->loader_section
;
3402 lsec
->size
= stoff
+ ldhdr
->l_stlen
;
3403 lsec
->contents
= bfd_zalloc (output_bfd
, lsec
->size
);
3404 if (lsec
->contents
== NULL
)
3407 /* Set up the header. */
3408 bfd_xcoff_swap_ldhdr_out (output_bfd
, ldhdr
, lsec
->contents
);
3410 /* Set up the import file names. */
3411 out
= (char *) lsec
->contents
+ ldhdr
->l_impoff
;
3412 strcpy (out
, libpath
);
3413 out
+= strlen (libpath
) + 1;
3416 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
3421 while ((*out
++ = *s
++) != '\0')
3424 while ((*out
++ = *s
++) != '\0')
3427 while ((*out
++ = *s
++) != '\0')
3431 BFD_ASSERT ((bfd_size_type
) ((bfd_byte
*) out
- lsec
->contents
) == stoff
);
3433 /* Set up the symbol string table. */
3434 if (ldinfo
.string_size
> 0)
3436 memcpy (out
, ldinfo
.strings
, ldinfo
.string_size
);
3437 free (ldinfo
.strings
);
3438 ldinfo
.strings
= NULL
;
3441 /* We can't set up the symbol table or the relocs yet, because we
3442 don't yet know the final position of the various sections. The
3443 .loader symbols are written out when the corresponding normal
3444 symbols are written out in xcoff_link_input_bfd or
3445 xcoff_write_global_symbol. The .loader relocs are written out
3446 when the corresponding normal relocs are handled in
3447 xcoff_link_input_bfd. */
3449 /* Allocate space for the magic sections. */
3450 sec
= xcoff_hash_table (info
)->linkage_section
;
3453 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
3454 if (sec
->contents
== NULL
)
3457 sec
= xcoff_hash_table (info
)->toc_section
;
3460 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
3461 if (sec
->contents
== NULL
)
3464 sec
= xcoff_hash_table (info
)->descriptor_section
;
3467 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
3468 if (sec
->contents
== NULL
)
3472 /* Now that we've done garbage collection, decide which symbols to keep,
3473 and figure out the contents of the .debug section. */
3474 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
3476 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3479 bfd_size_type symcount
;
3482 unsigned int *lineno_counts
;
3483 struct xcoff_link_hash_entry
**sym_hash
;
3484 bfd_byte
*esym
, *esymend
;
3485 bfd_size_type symesz
;
3487 if (sub
->xvec
!= info
->output_bfd
->xvec
)
3490 if ((sub
->flags
& DYNAMIC
) != 0
3491 && !info
->static_link
)
3494 if (! _bfd_coff_get_external_symbols (sub
))
3497 symcount
= obj_raw_syment_count (sub
);
3498 debug_index
= bfd_zalloc (sub
, symcount
* sizeof (long));
3499 if (debug_index
== NULL
)
3501 xcoff_data (sub
)->debug_indices
= debug_index
;
3503 if (info
->strip
== strip_all
3504 || info
->strip
== strip_debugger
3505 || info
->discard
== discard_all
)
3506 /* We're stripping all debugging information, so there's no need
3507 to read SUB's .debug section. */
3511 /* Grab the contents of SUB's .debug section, if any. */
3512 subdeb
= bfd_get_section_by_name (sub
, ".debug");
3513 if (subdeb
!= NULL
&& subdeb
->size
> 0)
3515 /* We use malloc and copy the names into the debug
3516 stringtab, rather than bfd_alloc, because I expect
3517 that, when linking many files together, many of the
3518 strings will be the same. Storing the strings in the
3519 hash table should save space in this case. */
3520 if (!bfd_malloc_and_get_section (sub
, subdeb
, &debug_contents
))
3525 csectpp
= xcoff_data (sub
)->csects
;
3526 lineno_counts
= xcoff_data (sub
)->lineno_counts
;
3527 sym_hash
= obj_xcoff_sym_hashes (sub
);
3528 symesz
= bfd_coff_symesz (sub
);
3529 esym
= (bfd_byte
*) obj_coff_external_syms (sub
);
3530 esymend
= esym
+ symcount
* symesz
;
3532 while (esym
< esymend
)
3534 struct internal_syment sym
;
3535 union internal_auxent aux
;
3540 bfd_coff_swap_sym_in (sub
, esym
, &sym
);
3542 /* Read in the csect information, if any. */
3543 if (CSECT_SYM_P (sym
.n_sclass
))
3545 BFD_ASSERT (sym
.n_numaux
> 0);
3546 bfd_coff_swap_aux_in (sub
, esym
+ symesz
* sym
.n_numaux
,
3547 sym
.n_type
, sym
.n_sclass
,
3548 sym
.n_numaux
- 1, sym
.n_numaux
, &aux
);
3551 /* If this symbol's name is stored in the debug section,
3552 get a pointer to it. */
3553 if (debug_contents
!= NULL
3554 && sym
._n
._n_n
._n_zeroes
== 0
3555 && bfd_coff_symname_in_debug (sub
, &sym
))
3556 name
= (const char *) debug_contents
+ sym
._n
._n_n
._n_offset
;
3560 /* Decide whether to copy this symbol to the output file. */
3562 keep_p
= xcoff_keep_symbol_p (info
, sub
, &sym
, &aux
,
3563 *sym_hash
, csect
, name
);
3568 /* Use a debug_index of -2 to record that a symbol should
3573 /* See whether we should store the symbol name in the
3574 output .debug section. */
3579 indx
= _bfd_stringtab_add (debug_strtab
, name
, TRUE
, TRUE
);
3580 if (indx
== (bfd_size_type
) -1)
3582 *debug_index
= indx
;
3587 (*sym_hash
)->flags
|= XCOFF_ALLOCATED
;
3588 if (*lineno_counts
> 0)
3589 csect
->output_section
->lineno_count
+= *lineno_counts
;
3592 esym
+= (sym
.n_numaux
+ 1) * symesz
;
3593 csectpp
+= sym
.n_numaux
+ 1;
3594 sym_hash
+= sym
.n_numaux
+ 1;
3595 lineno_counts
+= sym
.n_numaux
+ 1;
3596 debug_index
+= sym
.n_numaux
+ 1;
3601 free (debug_contents
);
3602 debug_contents
= NULL
;
3604 /* Clear the size of subdeb, so that it is not included directly
3605 in the output file. */
3609 if (! info
->keep_memory
)
3611 if (! _bfd_coff_free_symbols (sub
))
3616 if (info
->strip
!= strip_all
)
3617 xcoff_hash_table (info
)->debug_section
->size
=
3618 _bfd_stringtab_size (debug_strtab
);
3623 if (ldinfo
.strings
!= NULL
)
3624 free (ldinfo
.strings
);
3625 if (debug_contents
!= NULL
)
3626 free (debug_contents
);
3631 bfd_xcoff_link_generate_rtinit (bfd
*abfd
,
3636 struct bfd_in_memory
*bim
;
3638 bim
= bfd_malloc ((bfd_size_type
) sizeof (* bim
));
3645 abfd
->link_next
= 0;
3646 abfd
->format
= bfd_object
;
3647 abfd
->iostream
= (void *) bim
;
3648 abfd
->flags
= BFD_IN_MEMORY
;
3649 abfd
->direction
= write_direction
;
3652 if (! bfd_xcoff_generate_rtinit (abfd
, init
, fini
, rtld
))
3655 /* need to reset to unknown or it will not be read back in correctly */
3656 abfd
->format
= bfd_unknown
;
3657 abfd
->direction
= read_direction
;
3663 /* Link an input file into the linker output file. This function
3664 handles all the sections and relocations of the input file at once. */
3667 xcoff_link_input_bfd (struct xcoff_final_link_info
*finfo
,
3671 const char *strings
;
3672 bfd_size_type syment_base
;
3673 unsigned int n_tmask
;
3674 unsigned int n_btshft
;
3675 bfd_boolean copy
, hash
;
3676 bfd_size_type isymesz
;
3677 bfd_size_type osymesz
;
3678 bfd_size_type linesz
;
3681 struct xcoff_link_hash_entry
**sym_hash
;
3682 struct internal_syment
*isymp
;
3684 unsigned int *lineno_counts
;
3687 unsigned long output_index
;
3691 bfd_boolean keep_syms
;
3694 /* We can just skip DYNAMIC files, unless this is a static link. */
3695 if ((input_bfd
->flags
& DYNAMIC
) != 0
3696 && ! finfo
->info
->static_link
)
3699 /* Move all the symbols to the output file. */
3700 output_bfd
= finfo
->output_bfd
;
3702 syment_base
= obj_raw_syment_count (output_bfd
);
3703 isymesz
= bfd_coff_symesz (input_bfd
);
3704 osymesz
= bfd_coff_symesz (output_bfd
);
3705 linesz
= bfd_coff_linesz (input_bfd
);
3706 BFD_ASSERT (linesz
== bfd_coff_linesz (output_bfd
));
3708 n_tmask
= coff_data (input_bfd
)->local_n_tmask
;
3709 n_btshft
= coff_data (input_bfd
)->local_n_btshft
;
3711 /* Define macros so that ISFCN, et. al., macros work correctly. */
3712 #define N_TMASK n_tmask
3713 #define N_BTSHFT n_btshft
3716 if (! finfo
->info
->keep_memory
)
3719 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
3722 if (! _bfd_coff_get_external_symbols (input_bfd
))
3725 /* Make one pass over the symbols and assign indices to symbols that
3726 we have decided to keep. Also use create .loader symbol information
3727 and update information in hash table entries. */
3728 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
3729 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
3730 sym_hash
= obj_xcoff_sym_hashes (input_bfd
);
3731 csectpp
= xcoff_data (input_bfd
)->csects
;
3732 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
3733 isymp
= finfo
->internal_syms
;
3734 indexp
= finfo
->sym_indices
;
3735 output_index
= syment_base
;
3736 while (esym
< esym_end
)
3738 union internal_auxent aux
;
3742 bfd_coff_swap_sym_in (input_bfd
, (void *) esym
, (void *) isymp
);
3744 /* Read in the csect information, if any. */
3745 if (CSECT_SYM_P (isymp
->n_sclass
))
3747 BFD_ASSERT (isymp
->n_numaux
> 0);
3748 bfd_coff_swap_aux_in (input_bfd
,
3749 (void *) (esym
+ isymesz
* isymp
->n_numaux
),
3750 isymp
->n_type
, isymp
->n_sclass
,
3751 isymp
->n_numaux
- 1, isymp
->n_numaux
,
3754 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
3757 /* If this symbol is in the .loader section, swap out the
3758 .loader symbol information. If this is an external symbol
3759 reference to a defined symbol, though, then wait until we get
3760 to the definition. */
3761 if (EXTERN_SYM_P (isymp
->n_sclass
)
3762 && *sym_hash
!= NULL
3763 && (*sym_hash
)->ldsym
!= NULL
3764 && xcoff_final_definition_p (input_bfd
, *sym_hash
, *csectpp
))
3766 struct xcoff_link_hash_entry
*h
;
3767 struct internal_ldsym
*ldsym
;
3771 if (isymp
->n_scnum
> 0)
3773 ldsym
->l_scnum
= (*csectpp
)->output_section
->target_index
;
3774 ldsym
->l_value
= (isymp
->n_value
3775 + (*csectpp
)->output_section
->vma
3776 + (*csectpp
)->output_offset
3781 ldsym
->l_scnum
= isymp
->n_scnum
;
3782 ldsym
->l_value
= isymp
->n_value
;
3785 ldsym
->l_smtype
= smtyp
;
3786 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
3787 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
3788 || (h
->flags
& XCOFF_IMPORT
) != 0)
3789 ldsym
->l_smtype
|= L_IMPORT
;
3790 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
3791 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
3792 || (h
->flags
& XCOFF_EXPORT
) != 0)
3793 ldsym
->l_smtype
|= L_EXPORT
;
3794 if ((h
->flags
& XCOFF_ENTRY
) != 0)
3795 ldsym
->l_smtype
|= L_ENTRY
;
3796 if (isymp
->n_sclass
== C_AIX_WEAKEXT
)
3797 ldsym
->l_smtype
|= L_WEAK
;
3799 ldsym
->l_smclas
= aux
.x_csect
.x_smclas
;
3801 if (ldsym
->l_ifile
== (bfd_size_type
) -1)
3803 else if (ldsym
->l_ifile
== 0)
3805 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
3811 if (h
->root
.type
== bfd_link_hash_defined
3812 || h
->root
.type
== bfd_link_hash_defweak
)
3813 impbfd
= h
->root
.u
.def
.section
->owner
;
3814 else if (h
->root
.type
== bfd_link_hash_undefined
3815 || h
->root
.type
== bfd_link_hash_undefweak
)
3816 impbfd
= h
->root
.u
.undef
.abfd
;
3824 BFD_ASSERT (impbfd
->xvec
== finfo
->output_bfd
->xvec
);
3825 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
3832 BFD_ASSERT (h
->ldindx
>= 0);
3833 bfd_xcoff_swap_ldsym_out (finfo
->output_bfd
, ldsym
,
3836 * bfd_xcoff_ldsymsz (finfo
->output_bfd
))));
3839 /* Fill in snentry now that we know the target_index. */
3840 if ((h
->flags
& XCOFF_ENTRY
) != 0
3841 && (h
->root
.type
== bfd_link_hash_defined
3842 || h
->root
.type
== bfd_link_hash_defweak
))
3844 xcoff_data (output_bfd
)->snentry
=
3845 h
->root
.u
.def
.section
->output_section
->target_index
;
3849 add
= 1 + isymp
->n_numaux
;
3851 if (*debug_index
== -2)
3852 /* We've decided to strip this symbol. */
3856 /* Assign the next unused index to this symbol. */
3857 *indexp
= output_index
;
3859 if (EXTERN_SYM_P (isymp
->n_sclass
))
3861 BFD_ASSERT (*sym_hash
!= NULL
);
3862 (*sym_hash
)->indx
= output_index
;
3865 /* If this is a symbol in the TOC which we may have merged
3866 (class XMC_TC), remember the symbol index of the TOC
3868 if (isymp
->n_sclass
== C_HIDEXT
3869 && aux
.x_csect
.x_smclas
== XMC_TC
3870 && *sym_hash
!= NULL
)
3872 BFD_ASSERT (((*sym_hash
)->flags
& XCOFF_SET_TOC
) == 0);
3873 BFD_ASSERT ((*sym_hash
)->toc_section
!= NULL
);
3874 (*sym_hash
)->u
.toc_indx
= output_index
;
3877 output_index
+= add
;
3880 esym
+= add
* isymesz
;
3886 for (--add
; add
> 0; --add
)
3890 /* Now write out the symbols that we decided to keep. */
3892 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
3893 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
3894 isymp
= finfo
->internal_syms
;
3895 indexp
= finfo
->sym_indices
;
3896 csectpp
= xcoff_data (input_bfd
)->csects
;
3897 lineno_counts
= xcoff_data (input_bfd
)->lineno_counts
;
3898 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
3899 outsym
= finfo
->outsyms
;
3902 while (esym
< esym_end
)
3906 add
= 1 + isymp
->n_numaux
;
3909 esym
+= add
* isymesz
;
3912 struct internal_syment isym
;
3915 /* Adjust the symbol in order to output it. */
3917 if (isym
._n
._n_n
._n_zeroes
== 0
3918 && isym
._n
._n_n
._n_offset
!= 0)
3920 /* This symbol has a long name. Enter it in the string
3921 table we are building. If *debug_index != -1, the
3922 name has already been entered in the .debug section. */
3923 if (*debug_index
>= 0)
3924 isym
._n
._n_n
._n_offset
= *debug_index
;
3930 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, NULL
);
3934 indx
= _bfd_stringtab_add (finfo
->strtab
, name
, hash
, copy
);
3935 if (indx
== (bfd_size_type
) -1)
3937 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
3941 /* The value of a C_FILE symbol is the symbol index of the
3942 next C_FILE symbol. The value of the last C_FILE symbol
3943 is -1. We try to get this right, below, just before we
3944 write the symbols out, but in the general case we may
3945 have to write the symbol out twice. */
3946 if (isym
.n_sclass
== C_FILE
)
3948 if (finfo
->last_file_index
!= -1
3949 && finfo
->last_file
.n_value
!= (bfd_vma
) *indexp
)
3951 /* We must correct the value of the last C_FILE entry. */
3952 finfo
->last_file
.n_value
= *indexp
;
3953 if ((bfd_size_type
) finfo
->last_file_index
>= syment_base
)
3955 /* The last C_FILE symbol is in this input file. */
3956 bfd_coff_swap_sym_out (output_bfd
,
3957 (void *) &finfo
->last_file
,
3958 (void *) (finfo
->outsyms
3959 + ((finfo
->last_file_index
3965 /* We have already written out the last C_FILE
3966 symbol. We need to write it out again. We
3967 borrow *outsym temporarily. */
3970 bfd_coff_swap_sym_out (output_bfd
,
3971 (void *) &finfo
->last_file
,
3974 pos
= obj_sym_filepos (output_bfd
);
3975 pos
+= finfo
->last_file_index
* osymesz
;
3976 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
3977 || (bfd_bwrite (outsym
, osymesz
, output_bfd
)
3983 finfo
->last_file_index
= *indexp
;
3984 finfo
->last_file
= isym
;
3987 /* The value of a C_BINCL or C_EINCL symbol is a file offset
3988 into the line numbers. We update the symbol values when
3989 we handle the line numbers. */
3990 if (isym
.n_sclass
== C_BINCL
3991 || isym
.n_sclass
== C_EINCL
)
3993 isym
.n_value
= finfo
->line_filepos
;
3996 /* The value of a C_BSTAT symbol is the symbol table
3997 index of the containing csect. */
3998 else if (isym
.n_sclass
== C_BSTAT
)
4002 indx
= isym
.n_value
;
4003 if (indx
< obj_raw_syment_count (input_bfd
))
4007 symindx
= finfo
->sym_indices
[indx
];
4011 isym
.n_value
= symindx
;
4014 else if (isym
.n_sclass
!= C_ESTAT
4015 && isym
.n_sclass
!= C_DECL
4016 && isym
.n_scnum
> 0)
4018 isym
.n_scnum
= (*csectpp
)->output_section
->target_index
;
4019 isym
.n_value
+= ((*csectpp
)->output_section
->vma
4020 + (*csectpp
)->output_offset
4024 /* Output the symbol. */
4025 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
4030 for (i
= 0; i
< isymp
->n_numaux
&& esym
< esym_end
; i
++)
4032 union internal_auxent aux
;
4034 bfd_coff_swap_aux_in (input_bfd
, (void *) esym
, isymp
->n_type
,
4035 isymp
->n_sclass
, i
, isymp
->n_numaux
,
4038 if (isymp
->n_sclass
== C_FILE
)
4040 /* This is the file name (or some comment put in by
4041 the compiler). If it is long, we must put it in
4042 the string table. */
4043 if (aux
.x_file
.x_n
.x_zeroes
== 0
4044 && aux
.x_file
.x_n
.x_offset
!= 0)
4046 const char *filename
;
4049 BFD_ASSERT (aux
.x_file
.x_n
.x_offset
4050 >= STRING_SIZE_SIZE
);
4051 if (strings
== NULL
)
4053 strings
= _bfd_coff_read_string_table (input_bfd
);
4054 if (strings
== NULL
)
4057 filename
= strings
+ aux
.x_file
.x_n
.x_offset
;
4058 indx
= _bfd_stringtab_add (finfo
->strtab
, filename
,
4060 if (indx
== (bfd_size_type
) -1)
4062 aux
.x_file
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
4065 else if (CSECT_SYM_P (isymp
->n_sclass
)
4066 && i
+ 1 == isymp
->n_numaux
)
4069 /* We don't support type checking. I don't know if
4071 aux
.x_csect
.x_parmhash
= 0;
4072 /* I don't think anybody uses these fields, but we'd
4073 better clobber them just in case. */
4074 aux
.x_csect
.x_stab
= 0;
4075 aux
.x_csect
.x_snstab
= 0;
4077 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_LD
)
4081 indx
= aux
.x_csect
.x_scnlen
.l
;
4082 if (indx
< obj_raw_syment_count (input_bfd
))
4086 symindx
= finfo
->sym_indices
[indx
];
4089 aux
.x_csect
.x_scnlen
.l
= 0;
4093 aux
.x_csect
.x_scnlen
.l
= symindx
;
4098 else if (isymp
->n_sclass
!= C_STAT
|| isymp
->n_type
!= T_NULL
)
4102 if (ISFCN (isymp
->n_type
)
4103 || ISTAG (isymp
->n_sclass
)
4104 || isymp
->n_sclass
== C_BLOCK
4105 || isymp
->n_sclass
== C_FCN
)
4107 indx
= aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
4109 && indx
< obj_raw_syment_count (input_bfd
))
4111 /* We look forward through the symbol for
4112 the index of the next symbol we are going
4113 to include. I don't know if this is
4115 while (finfo
->sym_indices
[indx
] < 0
4116 && indx
< obj_raw_syment_count (input_bfd
))
4118 if (indx
>= obj_raw_syment_count (input_bfd
))
4119 indx
= output_index
;
4121 indx
= finfo
->sym_indices
[indx
];
4122 aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= indx
;
4127 indx
= aux
.x_sym
.x_tagndx
.l
;
4128 if (indx
> 0 && indx
< obj_raw_syment_count (input_bfd
))
4132 symindx
= finfo
->sym_indices
[indx
];
4134 aux
.x_sym
.x_tagndx
.l
= 0;
4136 aux
.x_sym
.x_tagndx
.l
= symindx
;
4141 /* Copy over the line numbers, unless we are stripping
4142 them. We do this on a symbol by symbol basis in
4143 order to more easily handle garbage collection. */
4144 if (CSECT_SYM_P (isymp
->n_sclass
)
4146 && isymp
->n_numaux
> 1
4147 && ISFCN (isymp
->n_type
)
4148 && aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
4150 if (*lineno_counts
== 0)
4151 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
4154 asection
*enclosing
;
4155 unsigned int enc_count
;
4156 bfd_signed_vma linoff
;
4157 struct internal_lineno lin
;
4164 /* Read in the enclosing section's line-number
4165 information, if we haven't already. */
4167 enclosing
= xcoff_section_data (abfd
, o
)->enclosing
;
4168 enc_count
= xcoff_section_data (abfd
, o
)->lineno_count
;
4169 if (oline
!= enclosing
)
4171 pos
= enclosing
->line_filepos
;
4172 amt
= linesz
* enc_count
;
4173 if (bfd_seek (input_bfd
, pos
, SEEK_SET
) != 0
4174 || (bfd_bread (finfo
->linenos
, amt
, input_bfd
)
4180 /* Copy across the first entry, adjusting its
4182 linoff
= (aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
4183 - enclosing
->line_filepos
);
4184 linp
= finfo
->linenos
+ linoff
;
4185 bfd_coff_swap_lineno_in (input_bfd
, linp
, &lin
);
4186 lin
.l_addr
.l_symndx
= *indexp
;
4187 bfd_coff_swap_lineno_out (output_bfd
, &lin
, linp
);
4190 /* Copy the other entries, adjusting their addresses. */
4191 linpend
= linp
+ *lineno_counts
* linesz
;
4192 offset
= (o
->output_section
->vma
4195 for (; linp
< linpend
; linp
+= linesz
)
4197 bfd_coff_swap_lineno_in (input_bfd
, linp
, &lin
);
4198 lin
.l_addr
.l_paddr
+= offset
;
4199 bfd_coff_swap_lineno_out (output_bfd
, &lin
, linp
);
4202 /* Write out the entries we've just processed. */
4203 pos
= (o
->output_section
->line_filepos
4204 + o
->output_section
->lineno_count
* linesz
);
4205 amt
= linesz
* *lineno_counts
;
4206 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4207 || bfd_bwrite (finfo
->linenos
+ linoff
,
4208 amt
, output_bfd
) != amt
)
4210 o
->output_section
->lineno_count
+= *lineno_counts
;
4212 /* Record the offset of the symbol's line numbers
4213 in the output file. */
4214 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= pos
;
4218 struct internal_syment
*iisp
, *iispend
;
4221 bfd_vma range_start
, range_end
;
4224 /* Update any C_BINCL or C_EINCL symbols
4225 that refer to a line number in the
4226 range we just output. */
4227 iisp
= finfo
->internal_syms
;
4228 iispend
= iisp
+ obj_raw_syment_count (input_bfd
);
4229 iindp
= finfo
->sym_indices
;
4230 oos
= finfo
->outsyms
;
4231 range_start
= enclosing
->line_filepos
+ linoff
;
4232 range_end
= range_start
+ *lineno_counts
* linesz
;
4233 while (iisp
< iispend
)
4236 && (iisp
->n_sclass
== C_BINCL
4237 || iisp
->n_sclass
== C_EINCL
)
4238 && iisp
->n_value
>= range_start
4239 && iisp
->n_value
< range_end
)
4241 struct internal_syment iis
;
4243 bfd_coff_swap_sym_in (output_bfd
, oos
, &iis
);
4244 iis
.n_value
= (iisp
->n_value
4247 bfd_coff_swap_sym_out (output_bfd
,
4252 iiadd
= 1 + iisp
->n_numaux
;
4254 oos
+= iiadd
* osymesz
;
4262 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, isymp
->n_type
,
4263 isymp
->n_sclass
, i
, isymp
->n_numaux
,
4273 lineno_counts
+= add
;
4277 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
4278 symbol will be the first symbol in the next input file. In the
4279 normal case, this will save us from writing out the C_FILE symbol
4281 if (finfo
->last_file_index
!= -1
4282 && (bfd_size_type
) finfo
->last_file_index
>= syment_base
)
4284 finfo
->last_file
.n_value
= output_index
;
4285 bfd_coff_swap_sym_out (output_bfd
, (void *) &finfo
->last_file
,
4286 (void *) (finfo
->outsyms
4287 + ((finfo
->last_file_index
- syment_base
)
4291 /* Write the modified symbols to the output file. */
4292 if (outsym
> finfo
->outsyms
)
4294 file_ptr pos
= obj_sym_filepos (output_bfd
) + syment_base
* osymesz
;
4295 bfd_size_type amt
= outsym
- finfo
->outsyms
;
4296 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4297 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
4300 BFD_ASSERT ((obj_raw_syment_count (output_bfd
)
4301 + (outsym
- finfo
->outsyms
) / osymesz
)
4304 obj_raw_syment_count (output_bfd
) = output_index
;
4307 /* Don't let the linker relocation routines discard the symbols. */
4308 keep_syms
= obj_coff_keep_syms (input_bfd
);
4309 obj_coff_keep_syms (input_bfd
) = TRUE
;
4311 /* Relocate the contents of each section. */
4312 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4316 if (! o
->linker_mark
)
4317 /* This section was omitted from the link. */
4320 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
4322 || (o
->flags
& SEC_IN_MEMORY
) != 0)
4325 /* We have set filepos correctly for the sections we created to
4326 represent csects, so bfd_get_section_contents should work. */
4327 if (coff_section_data (input_bfd
, o
) != NULL
4328 && coff_section_data (input_bfd
, o
)->contents
!= NULL
)
4329 contents
= coff_section_data (input_bfd
, o
)->contents
;
4332 bfd_size_type sz
= o
->rawsize
? o
->rawsize
: o
->size
;
4333 if (!bfd_get_section_contents (input_bfd
, o
, finfo
->contents
, 0, sz
))
4335 contents
= finfo
->contents
;
4338 if ((o
->flags
& SEC_RELOC
) != 0)
4341 struct internal_reloc
*internal_relocs
;
4342 struct internal_reloc
*irel
;
4344 struct internal_reloc
*irelend
;
4345 struct xcoff_link_hash_entry
**rel_hash
;
4348 /* Read in the relocs. */
4349 target_index
= o
->output_section
->target_index
;
4350 internal_relocs
= (xcoff_read_internal_relocs
4351 (input_bfd
, o
, FALSE
, finfo
->external_relocs
,
4353 (finfo
->section_info
[target_index
].relocs
4354 + o
->output_section
->reloc_count
)));
4355 if (internal_relocs
== NULL
)
4358 /* Call processor specific code to relocate the section
4360 if (! bfd_coff_relocate_section (output_bfd
, finfo
->info
,
4364 finfo
->internal_syms
,
4365 xcoff_data (input_bfd
)->csects
))
4368 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
4369 irel
= internal_relocs
;
4370 irelend
= irel
+ o
->reloc_count
;
4371 rel_hash
= (finfo
->section_info
[target_index
].rel_hashes
4372 + o
->output_section
->reloc_count
);
4373 for (; irel
< irelend
; irel
++, rel_hash
++)
4375 struct xcoff_link_hash_entry
*h
= NULL
;
4376 struct internal_ldrel ldrel
;
4380 /* Adjust the reloc address and symbol index. */
4382 irel
->r_vaddr
+= offset
;
4384 r_symndx
= irel
->r_symndx
;
4389 h
= obj_xcoff_sym_hashes (input_bfd
)[r_symndx
];
4391 if (r_symndx
!= -1 && finfo
->info
->strip
!= strip_all
)
4394 && h
->smclas
!= XMC_TD
4395 && (irel
->r_type
== R_TOC
4396 || irel
->r_type
== R_GL
4397 || irel
->r_type
== R_TCL
4398 || irel
->r_type
== R_TRL
4399 || irel
->r_type
== R_TRLA
))
4401 /* This is a TOC relative reloc with a symbol
4402 attached. The symbol should be the one which
4403 this reloc is for. We want to make this
4404 reloc against the TOC address of the symbol,
4405 not the symbol itself. */
4406 BFD_ASSERT (h
->toc_section
!= NULL
);
4407 BFD_ASSERT ((h
->flags
& XCOFF_SET_TOC
) == 0);
4408 if (h
->u
.toc_indx
!= -1)
4409 irel
->r_symndx
= h
->u
.toc_indx
;
4412 struct xcoff_toc_rel_hash
*n
;
4413 struct xcoff_link_section_info
*si
;
4417 n
= bfd_alloc (finfo
->output_bfd
, amt
);
4420 si
= finfo
->section_info
+ target_index
;
4421 n
->next
= si
->toc_rel_hashes
;
4424 si
->toc_rel_hashes
= n
;
4429 /* This is a global symbol. */
4431 irel
->r_symndx
= h
->indx
;
4434 /* This symbol is being written at the end
4435 of the file, and we do not yet know the
4436 symbol index. We save the pointer to the
4437 hash table entry in the rel_hash list.
4438 We set the indx field to -2 to indicate
4439 that this symbol must not be stripped. */
4448 indx
= finfo
->sym_indices
[r_symndx
];
4452 struct internal_syment
*is
;
4454 /* Relocations against a TC0 TOC anchor are
4455 automatically transformed to be against
4456 the TOC anchor in the output file. */
4457 is
= finfo
->internal_syms
+ r_symndx
;
4458 if (is
->n_sclass
== C_HIDEXT
4459 && is
->n_numaux
> 0)
4462 union internal_auxent aux
;
4466 obj_coff_external_syms (input_bfd
))
4467 + ((r_symndx
+ is
->n_numaux
)
4469 bfd_coff_swap_aux_in (input_bfd
, auxptr
,
4470 is
->n_type
, is
->n_sclass
,
4474 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_SD
4475 && aux
.x_csect
.x_smclas
== XMC_TC0
)
4476 indx
= finfo
->toc_symindx
;
4481 irel
->r_symndx
= indx
;
4485 struct internal_syment
*is
;
4488 char buf
[SYMNMLEN
+ 1];
4490 /* This reloc is against a symbol we are
4491 stripping. It would be possible to handle
4492 this case, but I don't think it's worth it. */
4493 is
= finfo
->internal_syms
+ r_symndx
;
4495 name
= (_bfd_coff_internal_syment_name
4496 (input_bfd
, is
, buf
));
4501 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
4502 (finfo
->info
, name
, input_bfd
, o
,
4509 switch (irel
->r_type
)
4513 || h
->root
.type
== bfd_link_hash_defined
4514 || h
->root
.type
== bfd_link_hash_defweak
4515 || h
->root
.type
== bfd_link_hash_common
)
4523 && (h
->root
.type
== bfd_link_hash_defined
4524 || h
->root
.type
== bfd_link_hash_defweak
)
4525 && bfd_is_abs_section (h
->root
.u
.def
.section
))
4527 /* This reloc needs to be copied into the .loader
4529 ldrel
.l_vaddr
= irel
->r_vaddr
;
4531 ldrel
.l_symndx
= -(bfd_size_type
) 1;
4533 || (h
->root
.type
== bfd_link_hash_defined
4534 || h
->root
.type
== bfd_link_hash_defweak
4535 || h
->root
.type
== bfd_link_hash_common
))
4540 sec
= xcoff_data (input_bfd
)->csects
[r_symndx
];
4541 else if (h
->root
.type
== bfd_link_hash_common
)
4542 sec
= h
->root
.u
.c
.p
->section
;
4544 sec
= h
->root
.u
.def
.section
;
4545 sec
= sec
->output_section
;
4547 if (strcmp (sec
->name
, ".text") == 0)
4549 else if (strcmp (sec
->name
, ".data") == 0)
4551 else if (strcmp (sec
->name
, ".bss") == 0)
4555 (*_bfd_error_handler
)
4556 (_("%B: loader reloc in unrecognized section `%A'"),
4558 bfd_set_error (bfd_error_nonrepresentable_section
);
4566 (*_bfd_error_handler
)
4567 (_("%B: `%s' in loader reloc but not loader sym"),
4569 h
->root
.root
.string
);
4570 bfd_set_error (bfd_error_bad_value
);
4573 ldrel
.l_symndx
= h
->ldindx
;
4575 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
4576 ldrel
.l_rsecnm
= o
->output_section
->target_index
;
4577 if (xcoff_hash_table (finfo
->info
)->textro
4578 && strcmp (o
->output_section
->name
, ".text") == 0)
4580 (*_bfd_error_handler
)
4581 (_("%B: loader reloc in read-only section %A"),
4582 input_bfd
, o
->output_section
);
4583 bfd_set_error (bfd_error_invalid_operation
);
4586 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
,
4589 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
4597 /* We should never need a .loader reloc for a TOC
4603 o
->output_section
->reloc_count
+= o
->reloc_count
;
4606 /* Write out the modified section contents. */
4607 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
4608 contents
, (file_ptr
) o
->output_offset
,
4613 obj_coff_keep_syms (input_bfd
) = keep_syms
;
4615 if (! finfo
->info
->keep_memory
)
4617 if (! _bfd_coff_free_symbols (input_bfd
))
4627 /* Sort relocs by VMA. This is called via qsort. */
4630 xcoff_sort_relocs (const void * p1
, const void * p2
)
4632 const struct internal_reloc
*r1
= (const struct internal_reloc
*) p1
;
4633 const struct internal_reloc
*r2
= (const struct internal_reloc
*) p2
;
4635 if (r1
->r_vaddr
> r2
->r_vaddr
)
4637 else if (r1
->r_vaddr
< r2
->r_vaddr
)
4643 /* Return true if section SEC is a TOC section. */
4645 static inline bfd_boolean
4646 xcoff_toc_section_p (asection
*sec
)
4651 if (name
[0] == '.' && name
[1] == 't')
4655 if (name
[3] == '0' && name
[4] == 0)
4660 if (name
[2] == 'd' && name
[3] == 0)
4666 /* See if the link requires a TOC (it usually does!). If so, find a
4667 good place to put the TOC anchor csect, and write out the associated
4671 xcoff_find_tc0 (bfd
*output_bfd
, struct xcoff_final_link_info
*finfo
)
4673 bfd_vma toc_start
, toc_end
, start
, end
, best_address
;
4677 struct internal_syment irsym
;
4678 union internal_auxent iraux
;
4682 /* Set [TOC_START, TOC_END) to the range of the TOC. Record the
4683 index of a csect at the beginning of the TOC. */
4684 toc_start
= ~(bfd_vma
) 0;
4687 for (input_bfd
= finfo
->info
->input_bfds
;
4689 input_bfd
= input_bfd
->link_next
)
4690 for (sec
= input_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4691 if ((sec
->flags
& SEC_MARK
) != 0 && xcoff_toc_section_p (sec
))
4693 start
= sec
->output_section
->vma
+ sec
->output_offset
;
4694 if (toc_start
> start
)
4697 section_index
= sec
->output_section
->target_index
;
4700 end
= start
+ sec
->size
;
4705 /* There's no need for a TC0 symbol if we don't have a TOC. */
4706 if (toc_end
< toc_start
)
4708 xcoff_data (output_bfd
)->toc
= toc_start
;
4712 if (toc_end
- toc_start
< 0x8000)
4713 /* Every TOC csect can be accessed from TOC_START. */
4714 best_address
= toc_start
;
4717 /* Find the lowest TOC csect that is still within range of TOC_END. */
4718 best_address
= toc_end
;
4719 for (input_bfd
= finfo
->info
->input_bfds
;
4721 input_bfd
= input_bfd
->link_next
)
4722 for (sec
= input_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4723 if ((sec
->flags
& SEC_MARK
) != 0 && xcoff_toc_section_p (sec
))
4725 start
= sec
->output_section
->vma
+ sec
->output_offset
;
4726 if (start
< best_address
4727 && start
+ 0x8000 >= toc_end
)
4729 best_address
= start
;
4730 section_index
= sec
->output_section
->target_index
;
4734 /* Make sure that the start of the TOC is also within range. */
4735 if (best_address
> toc_start
+ 0x8000)
4737 (*_bfd_error_handler
)
4738 (_("TOC overflow: 0x%lx > 0x10000; try -mminimal-toc "
4740 (unsigned long) (toc_end
- toc_start
));
4741 bfd_set_error (bfd_error_file_too_big
);
4746 /* Record the chosen TOC value. */
4747 finfo
->toc_symindx
= obj_raw_syment_count (output_bfd
);
4748 xcoff_data (output_bfd
)->toc
= best_address
;
4749 xcoff_data (output_bfd
)->sntoc
= section_index
;
4751 /* Fill out the TC0 symbol. */
4752 if (!bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
, &irsym
, "TOC"))
4754 irsym
.n_value
= best_address
;
4755 irsym
.n_scnum
= section_index
;
4756 irsym
.n_sclass
= C_HIDEXT
;
4757 irsym
.n_type
= T_NULL
;
4759 bfd_coff_swap_sym_out (output_bfd
, &irsym
, finfo
->outsyms
);
4761 /* Fill out the auxillary csect information. */
4762 memset (&iraux
, 0, sizeof iraux
);
4763 iraux
.x_csect
.x_smtyp
= XTY_SD
;
4764 iraux
.x_csect
.x_smclas
= XMC_TC0
;
4765 iraux
.x_csect
.x_scnlen
.l
= 0;
4766 bfd_coff_swap_aux_out (output_bfd
, &iraux
, T_NULL
, C_HIDEXT
, 0, 1,
4767 finfo
->outsyms
+ bfd_coff_symesz (output_bfd
));
4769 /* Write the contents to the file. */
4770 pos
= obj_sym_filepos (output_bfd
);
4771 pos
+= obj_raw_syment_count (output_bfd
) * bfd_coff_symesz (output_bfd
);
4772 size
= 2 * bfd_coff_symesz (output_bfd
);
4773 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4774 || bfd_bwrite (finfo
->outsyms
, size
, output_bfd
) != size
)
4776 obj_raw_syment_count (output_bfd
) += 2;
4781 /* Write out a non-XCOFF global symbol. */
4784 xcoff_write_global_symbol (struct xcoff_link_hash_entry
*h
, void * inf
)
4786 struct xcoff_final_link_info
*finfo
= (struct xcoff_final_link_info
*) inf
;
4789 struct internal_syment isym
;
4790 union internal_auxent aux
;
4795 output_bfd
= finfo
->output_bfd
;
4796 outsym
= finfo
->outsyms
;
4798 if (h
->root
.type
== bfd_link_hash_warning
)
4800 h
= (struct xcoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4801 if (h
->root
.type
== bfd_link_hash_new
)
4805 /* If this symbol was garbage collected, just skip it. */
4806 if (xcoff_hash_table (finfo
->info
)->gc
4807 && (h
->flags
& XCOFF_MARK
) == 0)
4810 /* If we need a .loader section entry, write it out. */
4811 if (h
->ldsym
!= NULL
)
4813 struct internal_ldsym
*ldsym
;
4818 if (h
->root
.type
== bfd_link_hash_undefined
4819 || h
->root
.type
== bfd_link_hash_undefweak
)
4823 ldsym
->l_scnum
= N_UNDEF
;
4824 ldsym
->l_smtype
= XTY_ER
;
4825 impbfd
= h
->root
.u
.undef
.abfd
;
4828 else if (h
->root
.type
== bfd_link_hash_defined
4829 || h
->root
.type
== bfd_link_hash_defweak
)
4833 sec
= h
->root
.u
.def
.section
;
4834 ldsym
->l_value
= (sec
->output_section
->vma
4835 + sec
->output_offset
4836 + h
->root
.u
.def
.value
);
4837 ldsym
->l_scnum
= sec
->output_section
->target_index
;
4838 ldsym
->l_smtype
= XTY_SD
;
4839 impbfd
= sec
->owner
;
4845 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
4846 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4847 || (h
->flags
& XCOFF_IMPORT
) != 0)
4849 Import symbols are defined so the check above will make
4850 the l_smtype XTY_SD. But this is not correct, it should
4852 ldsym
->l_smtype
|= L_IMPORT
;
4854 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
4855 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4856 || (h
->flags
& XCOFF_EXPORT
) != 0)
4857 ldsym
->l_smtype
|= L_EXPORT
;
4859 if ((h
->flags
& XCOFF_ENTRY
) != 0)
4860 ldsym
->l_smtype
|= L_ENTRY
;
4862 if ((h
->flags
& XCOFF_RTINIT
) != 0)
4863 ldsym
->l_smtype
= XTY_SD
;
4865 ldsym
->l_smclas
= h
->smclas
;
4867 if (ldsym
->l_smtype
& L_IMPORT
)
4869 if ((h
->root
.type
== bfd_link_hash_defined
4870 || h
->root
.type
== bfd_link_hash_defweak
)
4871 && (h
->root
.u
.def
.value
!= 0))
4872 ldsym
->l_smclas
= XMC_XO
;
4874 else if ((h
->flags
& (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
)) ==
4875 (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
))
4876 ldsym
->l_smclas
= XMC_SV3264
;
4878 else if (h
->flags
& XCOFF_SYSCALL32
)
4879 ldsym
->l_smclas
= XMC_SV
;
4881 else if (h
->flags
& XCOFF_SYSCALL64
)
4882 ldsym
->l_smclas
= XMC_SV64
;
4885 if (ldsym
->l_ifile
== -(bfd_size_type
) 1)
4889 else if (ldsym
->l_ifile
== 0)
4891 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
4893 else if (impbfd
== NULL
)
4897 BFD_ASSERT (impbfd
->xvec
== output_bfd
->xvec
);
4898 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
4904 BFD_ASSERT (h
->ldindx
>= 0);
4906 bfd_xcoff_swap_ldsym_out (output_bfd
, ldsym
,
4909 * bfd_xcoff_ldsymsz(finfo
->output_bfd
)));
4913 /* If this symbol needs global linkage code, write it out. */
4914 if (h
->root
.type
== bfd_link_hash_defined
4915 && (h
->root
.u
.def
.section
4916 == xcoff_hash_table (finfo
->info
)->linkage_section
))
4922 p
= h
->root
.u
.def
.section
->contents
+ h
->root
.u
.def
.value
;
4924 /* The first instruction in the global linkage code loads a
4925 specific TOC element. */
4926 tocoff
= (h
->descriptor
->toc_section
->output_section
->vma
4927 + h
->descriptor
->toc_section
->output_offset
4928 - xcoff_data (output_bfd
)->toc
);
4930 if ((h
->descriptor
->flags
& XCOFF_SET_TOC
) != 0)
4931 tocoff
+= h
->descriptor
->u
.toc_offset
;
4933 /* The first instruction in the glink code needs to be
4934 cooked to to hold the correct offset in the toc. The
4935 rest are just output raw. */
4936 bfd_put_32 (output_bfd
,
4937 bfd_xcoff_glink_code(output_bfd
, 0) | (tocoff
& 0xffff), p
);
4939 /* Start with i == 1 to get past the first instruction done above
4940 The /4 is because the glink code is in bytes and we are going
4942 for (i
= 1; i
< bfd_xcoff_glink_code_size(output_bfd
) / 4; i
++)
4943 bfd_put_32 (output_bfd
,
4944 (bfd_vma
) bfd_xcoff_glink_code(output_bfd
, i
),
4948 /* If we created a TOC entry for this symbol, write out the required
4950 if ((h
->flags
& XCOFF_SET_TOC
) != 0)
4955 struct internal_reloc
*irel
;
4956 struct internal_ldrel ldrel
;
4957 struct internal_syment irsym
;
4958 union internal_auxent iraux
;
4960 tocsec
= h
->toc_section
;
4961 osec
= tocsec
->output_section
;
4962 oindx
= osec
->target_index
;
4963 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
4964 irel
->r_vaddr
= (osec
->vma
4965 + tocsec
->output_offset
4969 irel
->r_symndx
= h
->indx
;
4973 irel
->r_symndx
= obj_raw_syment_count (output_bfd
);
4976 BFD_ASSERT (h
->ldindx
>= 0);
4978 /* Initialize the aux union here instead of closer to when it is
4979 written out below because the length of the csect depends on
4980 whether the output is 32 or 64 bit. */
4981 memset (&iraux
, 0, sizeof iraux
);
4982 iraux
.x_csect
.x_smtyp
= XTY_SD
;
4983 /* iraux.x_csect.x_scnlen.l = 4 or 8, see below. */
4984 iraux
.x_csect
.x_smclas
= XMC_TC
;
4986 /* 32 bit uses a 32 bit R_POS to do the relocations
4987 64 bit uses a 64 bit R_POS to do the relocations
4989 Also needs to change the csect size : 4 for 32 bit, 8 for 64 bit
4991 Which one is determined by the backend. */
4992 if (bfd_xcoff_is_xcoff64 (output_bfd
))
4995 iraux
.x_csect
.x_scnlen
.l
= 8;
4997 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
5000 iraux
.x_csect
.x_scnlen
.l
= 4;
5005 irel
->r_type
= R_POS
;
5006 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5007 ++osec
->reloc_count
;
5009 ldrel
.l_vaddr
= irel
->r_vaddr
;
5010 ldrel
.l_symndx
= h
->ldindx
;
5011 ldrel
.l_rtype
= (irel
->r_size
<< 8) | R_POS
;
5012 ldrel
.l_rsecnm
= oindx
;
5013 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5014 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5016 /* We need to emit a symbol to define a csect which holds
5018 if (finfo
->info
->strip
!= strip_all
)
5020 result
= bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
,
5021 &irsym
, h
->root
.root
.string
);
5025 irsym
.n_value
= irel
->r_vaddr
;
5026 irsym
.n_scnum
= osec
->target_index
;
5027 irsym
.n_sclass
= C_HIDEXT
;
5028 irsym
.n_type
= T_NULL
;
5031 bfd_coff_swap_sym_out (output_bfd
, (void *) &irsym
, (void *) outsym
);
5032 outsym
+= bfd_coff_symesz (output_bfd
);
5034 /* Note : iraux is initialized above. */
5035 bfd_coff_swap_aux_out (output_bfd
, (void *) &iraux
, T_NULL
, C_HIDEXT
,
5036 0, 1, (void *) outsym
);
5037 outsym
+= bfd_coff_auxesz (output_bfd
);
5041 /* We aren't going to write out the symbols below, so we
5042 need to write them out now. */
5043 pos
= obj_sym_filepos (output_bfd
);
5044 pos
+= (obj_raw_syment_count (output_bfd
)
5045 * bfd_coff_symesz (output_bfd
));
5046 amt
= outsym
- finfo
->outsyms
;
5047 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5048 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
5050 obj_raw_syment_count (output_bfd
) +=
5051 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
5053 outsym
= finfo
->outsyms
;
5058 /* If this symbol is a specially defined function descriptor, write
5059 it out. The first word is the address of the function code
5060 itself, the second word is the address of the TOC, and the third
5064 The addresses for the 32 bit will take 4 bytes and the addresses
5065 for 64 bit will take 8 bytes. Similar for the relocs. This type
5066 of logic was also done above to create a TOC entry in
5067 xcoff_write_global_symbol. */
5068 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
5069 && h
->root
.type
== bfd_link_hash_defined
5070 && (h
->root
.u
.def
.section
5071 == xcoff_hash_table (finfo
->info
)->descriptor_section
))
5077 struct xcoff_link_hash_entry
*hentry
;
5079 struct internal_reloc
*irel
;
5080 struct internal_ldrel ldrel
;
5082 unsigned int reloc_size
, byte_size
;
5084 if (bfd_xcoff_is_xcoff64 (output_bfd
))
5089 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
5097 sec
= h
->root
.u
.def
.section
;
5098 osec
= sec
->output_section
;
5099 oindx
= osec
->target_index
;
5100 p
= sec
->contents
+ h
->root
.u
.def
.value
;
5102 hentry
= h
->descriptor
;
5103 BFD_ASSERT (hentry
!= NULL
5104 && (hentry
->root
.type
== bfd_link_hash_defined
5105 || hentry
->root
.type
== bfd_link_hash_defweak
));
5106 esec
= hentry
->root
.u
.def
.section
;
5108 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
5109 irel
->r_vaddr
= (osec
->vma
5110 + sec
->output_offset
5111 + h
->root
.u
.def
.value
);
5112 irel
->r_symndx
= esec
->output_section
->target_index
;
5113 irel
->r_type
= R_POS
;
5114 irel
->r_size
= reloc_size
;
5115 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5116 ++osec
->reloc_count
;
5118 ldrel
.l_vaddr
= irel
->r_vaddr
;
5119 if (strcmp (esec
->output_section
->name
, ".text") == 0)
5121 else if (strcmp (esec
->output_section
->name
, ".data") == 0)
5123 else if (strcmp (esec
->output_section
->name
, ".bss") == 0)
5127 (*_bfd_error_handler
)
5128 (_("%s: loader reloc in unrecognized section `%s'"),
5129 bfd_get_filename (output_bfd
),
5130 esec
->output_section
->name
);
5131 bfd_set_error (bfd_error_nonrepresentable_section
);
5134 ldrel
.l_rtype
= (reloc_size
<< 8) | R_POS
;
5135 ldrel
.l_rsecnm
= oindx
;
5136 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5137 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5139 /* There are three items to write out,
5140 the address of the code
5141 the address of the toc anchor
5142 the environment pointer.
5143 We are ignoring the environment pointer. So set it to zero. */
5144 if (bfd_xcoff_is_xcoff64 (output_bfd
))
5146 bfd_put_64 (output_bfd
,
5147 (esec
->output_section
->vma
+ esec
->output_offset
5148 + hentry
->root
.u
.def
.value
),
5150 bfd_put_64 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 8);
5151 bfd_put_64 (output_bfd
, (bfd_vma
) 0, p
+ 16);
5156 This logic was already called above so the error case where
5157 the backend is neither has already been checked. */
5158 bfd_put_32 (output_bfd
,
5159 (esec
->output_section
->vma
+ esec
->output_offset
5160 + hentry
->root
.u
.def
.value
),
5162 bfd_put_32 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 4);
5163 bfd_put_32 (output_bfd
, (bfd_vma
) 0, p
+ 8);
5166 tsec
= coff_section_from_bfd_index (output_bfd
,
5167 xcoff_data (output_bfd
)->sntoc
);
5170 irel
->r_vaddr
= (osec
->vma
5171 + sec
->output_offset
5172 + h
->root
.u
.def
.value
5174 irel
->r_symndx
= tsec
->output_section
->target_index
;
5175 irel
->r_type
= R_POS
;
5176 irel
->r_size
= reloc_size
;
5177 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5178 ++osec
->reloc_count
;
5180 ldrel
.l_vaddr
= irel
->r_vaddr
;
5181 if (strcmp (tsec
->output_section
->name
, ".text") == 0)
5183 else if (strcmp (tsec
->output_section
->name
, ".data") == 0)
5185 else if (strcmp (tsec
->output_section
->name
, ".bss") == 0)
5189 (*_bfd_error_handler
)
5190 (_("%s: loader reloc in unrecognized section `%s'"),
5191 bfd_get_filename (output_bfd
),
5192 tsec
->output_section
->name
);
5193 bfd_set_error (bfd_error_nonrepresentable_section
);
5196 ldrel
.l_rtype
= (reloc_size
<< 8) | R_POS
;
5197 ldrel
.l_rsecnm
= oindx
;
5198 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5199 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5202 if (h
->indx
>= 0 || finfo
->info
->strip
== strip_all
)
5204 BFD_ASSERT (outsym
== finfo
->outsyms
);
5209 && (finfo
->info
->strip
== strip_all
5210 || (finfo
->info
->strip
== strip_some
5211 && bfd_hash_lookup (finfo
->info
->keep_hash
, h
->root
.root
.string
,
5212 FALSE
, FALSE
) == NULL
)))
5214 BFD_ASSERT (outsym
== finfo
->outsyms
);
5219 && (h
->flags
& (XCOFF_REF_REGULAR
| XCOFF_DEF_REGULAR
)) == 0)
5221 BFD_ASSERT (outsym
== finfo
->outsyms
);
5225 memset (&aux
, 0, sizeof aux
);
5227 h
->indx
= obj_raw_syment_count (output_bfd
);
5229 result
= bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
, &isym
,
5230 h
->root
.root
.string
);
5234 if (h
->root
.type
== bfd_link_hash_undefined
5235 || h
->root
.type
== bfd_link_hash_undefweak
)
5238 isym
.n_scnum
= N_UNDEF
;
5239 if (h
->root
.type
== bfd_link_hash_undefweak
5240 && C_WEAKEXT
== C_AIX_WEAKEXT
)
5241 isym
.n_sclass
= C_WEAKEXT
;
5243 isym
.n_sclass
= C_EXT
;
5244 aux
.x_csect
.x_smtyp
= XTY_ER
;
5246 else if ((h
->root
.type
== bfd_link_hash_defined
5247 || h
->root
.type
== bfd_link_hash_defweak
)
5248 && h
->smclas
== XMC_XO
)
5250 BFD_ASSERT (bfd_is_abs_section (h
->root
.u
.def
.section
));
5251 isym
.n_value
= h
->root
.u
.def
.value
;
5252 isym
.n_scnum
= N_UNDEF
;
5253 if (h
->root
.type
== bfd_link_hash_undefweak
5254 && C_WEAKEXT
== C_AIX_WEAKEXT
)
5255 isym
.n_sclass
= C_WEAKEXT
;
5257 isym
.n_sclass
= C_EXT
;
5258 aux
.x_csect
.x_smtyp
= XTY_ER
;
5260 else if (h
->root
.type
== bfd_link_hash_defined
5261 || h
->root
.type
== bfd_link_hash_defweak
)
5263 struct xcoff_link_size_list
*l
;
5265 isym
.n_value
= (h
->root
.u
.def
.section
->output_section
->vma
5266 + h
->root
.u
.def
.section
->output_offset
5267 + h
->root
.u
.def
.value
);
5268 if (bfd_is_abs_section (h
->root
.u
.def
.section
->output_section
))
5269 isym
.n_scnum
= N_ABS
;
5271 isym
.n_scnum
= h
->root
.u
.def
.section
->output_section
->target_index
;
5272 isym
.n_sclass
= C_HIDEXT
;
5273 aux
.x_csect
.x_smtyp
= XTY_SD
;
5275 if ((h
->flags
& XCOFF_HAS_SIZE
) != 0)
5277 for (l
= xcoff_hash_table (finfo
->info
)->size_list
;
5283 aux
.x_csect
.x_scnlen
.l
= l
->size
;
5289 else if (h
->root
.type
== bfd_link_hash_common
)
5291 isym
.n_value
= (h
->root
.u
.c
.p
->section
->output_section
->vma
5292 + h
->root
.u
.c
.p
->section
->output_offset
);
5293 isym
.n_scnum
= h
->root
.u
.c
.p
->section
->output_section
->target_index
;
5294 isym
.n_sclass
= C_EXT
;
5295 aux
.x_csect
.x_smtyp
= XTY_CM
;
5296 aux
.x_csect
.x_scnlen
.l
= h
->root
.u
.c
.size
;
5301 isym
.n_type
= T_NULL
;
5304 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
5305 outsym
+= bfd_coff_symesz (output_bfd
);
5307 aux
.x_csect
.x_smclas
= h
->smclas
;
5308 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, T_NULL
, isym
.n_sclass
, 0, 1,
5310 outsym
+= bfd_coff_auxesz (output_bfd
);
5312 if ((h
->root
.type
== bfd_link_hash_defined
5313 || h
->root
.type
== bfd_link_hash_defweak
)
5314 && h
->smclas
!= XMC_XO
)
5316 /* We just output an SD symbol. Now output an LD symbol. */
5319 if (h
->root
.type
== bfd_link_hash_undefweak
5320 && C_WEAKEXT
== C_AIX_WEAKEXT
)
5321 isym
.n_sclass
= C_WEAKEXT
;
5323 isym
.n_sclass
= C_EXT
;
5324 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
5325 outsym
+= bfd_coff_symesz (output_bfd
);
5327 aux
.x_csect
.x_smtyp
= XTY_LD
;
5328 aux
.x_csect
.x_scnlen
.l
= obj_raw_syment_count (output_bfd
);
5329 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, T_NULL
, C_EXT
, 0, 1,
5331 outsym
+= bfd_coff_auxesz (output_bfd
);
5334 pos
= obj_sym_filepos (output_bfd
);
5335 pos
+= obj_raw_syment_count (output_bfd
) * bfd_coff_symesz (output_bfd
);
5336 amt
= outsym
- finfo
->outsyms
;
5337 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5338 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
5340 obj_raw_syment_count (output_bfd
) +=
5341 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
5346 /* Handle a link order which is supposed to generate a reloc. */
5349 xcoff_reloc_link_order (bfd
*output_bfd
,
5350 struct xcoff_final_link_info
*finfo
,
5351 asection
*output_section
,
5352 struct bfd_link_order
*link_order
)
5354 reloc_howto_type
*howto
;
5355 struct xcoff_link_hash_entry
*h
;
5359 struct internal_reloc
*irel
;
5360 struct xcoff_link_hash_entry
**rel_hash_ptr
;
5361 struct internal_ldrel ldrel
;
5363 if (link_order
->type
== bfd_section_reloc_link_order
)
5364 /* We need to somehow locate a symbol in the right section. The
5365 symbol must either have a value of zero, or we must adjust
5366 the addend by the value of the symbol. FIXME: Write this
5367 when we need it. The old linker couldn't handle this anyhow. */
5370 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
5373 bfd_set_error (bfd_error_bad_value
);
5377 h
= ((struct xcoff_link_hash_entry
*)
5378 bfd_wrapped_link_hash_lookup (output_bfd
, finfo
->info
,
5379 link_order
->u
.reloc
.p
->u
.name
,
5380 FALSE
, FALSE
, TRUE
));
5383 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
5384 (finfo
->info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0)))
5389 if (h
->root
.type
== bfd_link_hash_common
)
5391 hsec
= h
->root
.u
.c
.p
->section
;
5394 else if (h
->root
.type
== bfd_link_hash_defined
5395 || h
->root
.type
== bfd_link_hash_defweak
)
5397 hsec
= h
->root
.u
.def
.section
;
5398 hval
= h
->root
.u
.def
.value
;
5406 addend
= link_order
->u
.reloc
.p
->addend
;
5408 addend
+= (hsec
->output_section
->vma
5409 + hsec
->output_offset
5416 bfd_reloc_status_type rstat
;
5419 size
= bfd_get_reloc_size (howto
);
5420 buf
= bfd_zmalloc (size
);
5424 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
5430 case bfd_reloc_outofrange
:
5432 case bfd_reloc_overflow
:
5433 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
5434 (finfo
->info
, NULL
, link_order
->u
.reloc
.p
->u
.name
,
5435 howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0)))
5442 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
5443 (file_ptr
) link_order
->offset
, size
);
5449 /* Store the reloc information in the right place. It will get
5450 swapped and written out at the end of the final_link routine. */
5451 irel
= (finfo
->section_info
[output_section
->target_index
].relocs
5452 + output_section
->reloc_count
);
5453 rel_hash_ptr
= (finfo
->section_info
[output_section
->target_index
].rel_hashes
5454 + output_section
->reloc_count
);
5456 memset (irel
, 0, sizeof (struct internal_reloc
));
5457 *rel_hash_ptr
= NULL
;
5459 irel
->r_vaddr
= output_section
->vma
+ link_order
->offset
;
5462 irel
->r_symndx
= h
->indx
;
5465 /* Set the index to -2 to force this symbol to get written out. */
5471 irel
->r_type
= howto
->type
;
5472 irel
->r_size
= howto
->bitsize
- 1;
5473 if (howto
->complain_on_overflow
== complain_overflow_signed
)
5474 irel
->r_size
|= 0x80;
5476 ++output_section
->reloc_count
;
5478 /* Now output the reloc to the .loader section. */
5480 ldrel
.l_vaddr
= irel
->r_vaddr
;
5484 const char *secname
;
5486 secname
= hsec
->output_section
->name
;
5488 if (strcmp (secname
, ".text") == 0)
5490 else if (strcmp (secname
, ".data") == 0)
5492 else if (strcmp (secname
, ".bss") == 0)
5496 (*_bfd_error_handler
)
5497 (_("%s: loader reloc in unrecognized section `%s'"),
5498 bfd_get_filename (output_bfd
), secname
);
5499 bfd_set_error (bfd_error_nonrepresentable_section
);
5507 (*_bfd_error_handler
)
5508 (_("%s: `%s' in loader reloc but not loader sym"),
5509 bfd_get_filename (output_bfd
),
5510 h
->root
.root
.string
);
5511 bfd_set_error (bfd_error_bad_value
);
5514 ldrel
.l_symndx
= h
->ldindx
;
5517 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
5518 ldrel
.l_rsecnm
= output_section
->target_index
;
5519 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5520 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5525 /* Do the final link step. */
5528 _bfd_xcoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
5530 bfd_size_type symesz
;
5531 struct xcoff_final_link_info finfo
;
5533 struct bfd_link_order
*p
;
5534 bfd_size_type max_contents_size
;
5535 bfd_size_type max_sym_count
;
5536 bfd_size_type max_lineno_count
;
5537 bfd_size_type max_reloc_count
;
5538 bfd_size_type max_output_reloc_count
;
5539 file_ptr rel_filepos
;
5541 file_ptr line_filepos
;
5542 unsigned int linesz
;
5544 bfd_byte
*external_relocs
= NULL
;
5545 char strbuf
[STRING_SIZE_SIZE
];
5550 abfd
->flags
|= DYNAMIC
;
5552 symesz
= bfd_coff_symesz (abfd
);
5555 finfo
.output_bfd
= abfd
;
5556 finfo
.strtab
= NULL
;
5557 finfo
.section_info
= NULL
;
5558 finfo
.last_file_index
= -1;
5559 finfo
.toc_symindx
= -1;
5560 finfo
.internal_syms
= NULL
;
5561 finfo
.sym_indices
= NULL
;
5562 finfo
.outsyms
= NULL
;
5563 finfo
.linenos
= NULL
;
5564 finfo
.contents
= NULL
;
5565 finfo
.external_relocs
= NULL
;
5567 finfo
.ldsym
= (xcoff_hash_table (info
)->loader_section
->contents
5568 + bfd_xcoff_ldhdrsz (abfd
));
5569 finfo
.ldrel
= (xcoff_hash_table (info
)->loader_section
->contents
5570 + bfd_xcoff_ldhdrsz(abfd
)
5571 + (xcoff_hash_table (info
)->ldhdr
.l_nsyms
5572 * bfd_xcoff_ldsymsz(abfd
)));
5574 xcoff_data (abfd
)->coff
.link_info
= info
;
5576 finfo
.strtab
= _bfd_stringtab_init ();
5577 if (finfo
.strtab
== NULL
)
5580 /* Count the relocation entries required for the output file.
5581 (We've already counted the line numbers.) Determine a few
5583 max_contents_size
= 0;
5584 max_lineno_count
= 0;
5585 max_reloc_count
= 0;
5586 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5589 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
5591 if (p
->type
== bfd_indirect_link_order
)
5595 sec
= p
->u
.indirect
.section
;
5597 /* Mark all sections which are to be included in the
5598 link. This will normally be every section. We need
5599 to do this so that we can identify any sections which
5600 the linker has decided to not include. */
5601 sec
->linker_mark
= TRUE
;
5603 o
->reloc_count
+= sec
->reloc_count
;
5605 if (sec
->rawsize
> max_contents_size
)
5606 max_contents_size
= sec
->rawsize
;
5607 if (sec
->size
> max_contents_size
)
5608 max_contents_size
= sec
->size
;
5609 if (coff_section_data (sec
->owner
, sec
) != NULL
5610 && xcoff_section_data (sec
->owner
, sec
) != NULL
5611 && (xcoff_section_data (sec
->owner
, sec
)->lineno_count
5612 > max_lineno_count
))
5614 xcoff_section_data (sec
->owner
, sec
)->lineno_count
;
5615 if (sec
->reloc_count
> max_reloc_count
)
5616 max_reloc_count
= sec
->reloc_count
;
5618 else if (p
->type
== bfd_section_reloc_link_order
5619 || p
->type
== bfd_symbol_reloc_link_order
)
5624 /* Compute the file positions for all the sections. */
5625 if (abfd
->output_has_begun
)
5627 if (xcoff_hash_table (info
)->file_align
!= 0)
5634 file_align
= xcoff_hash_table (info
)->file_align
;
5635 if (file_align
!= 0)
5637 bfd_boolean saw_contents
;
5641 /* Insert .pad sections before every section which has
5642 contents and is loaded, if it is preceded by some other
5643 section which has contents and is loaded. */
5644 saw_contents
= TRUE
;
5645 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5647 if (strcmp (o
->name
, ".pad") == 0)
5648 saw_contents
= FALSE
;
5649 else if ((o
->flags
& SEC_HAS_CONTENTS
) != 0
5650 && (o
->flags
& SEC_LOAD
) != 0)
5653 saw_contents
= TRUE
;
5658 /* Create a pad section and place it before the section
5659 that needs padding. This requires unlinking and
5660 relinking the bfd's section list. */
5662 n
= bfd_make_section_anyway_with_flags (abfd
, ".pad",
5664 n
->alignment_power
= 0;
5666 bfd_section_list_remove (abfd
, n
);
5667 bfd_section_list_insert_before (abfd
, o
, n
);
5668 saw_contents
= FALSE
;
5673 /* Reset the section indices after inserting the new
5676 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5679 o
->target_index
= indx
;
5681 BFD_ASSERT ((unsigned int) indx
== abfd
->section_count
);
5683 /* Work out appropriate sizes for the .pad sections to force
5684 each section to land on a page boundary. This bit of
5685 code knows what compute_section_file_positions is going
5687 sofar
= bfd_coff_filhsz (abfd
);
5688 sofar
+= bfd_coff_aoutsz (abfd
);
5689 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
5690 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5691 if ((bfd_xcoff_is_reloc_count_overflow
5692 (abfd
, (bfd_vma
) o
->reloc_count
))
5693 || (bfd_xcoff_is_lineno_count_overflow
5694 (abfd
, (bfd_vma
) o
->lineno_count
)))
5695 /* 64 does not overflow, need to check if 32 does */
5696 sofar
+= bfd_coff_scnhsz (abfd
);
5698 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5700 if (strcmp (o
->name
, ".pad") == 0)
5704 BFD_ASSERT (o
->size
== 0);
5705 pageoff
= sofar
& (file_align
- 1);
5708 o
->size
= file_align
- pageoff
;
5709 sofar
+= file_align
- pageoff
;
5710 o
->flags
|= SEC_HAS_CONTENTS
;
5715 if ((o
->flags
& SEC_HAS_CONTENTS
) != 0)
5716 sofar
+= BFD_ALIGN (o
->size
,
5717 1 << o
->alignment_power
);
5722 if (! bfd_coff_compute_section_file_positions (abfd
))
5726 /* Allocate space for the pointers we need to keep for the relocs. */
5730 /* We use section_count + 1, rather than section_count, because
5731 the target_index fields are 1 based. */
5732 amt
= abfd
->section_count
+ 1;
5733 amt
*= sizeof (struct xcoff_link_section_info
);
5734 finfo
.section_info
= bfd_malloc (amt
);
5735 if (finfo
.section_info
== NULL
)
5737 for (i
= 0; i
<= abfd
->section_count
; i
++)
5739 finfo
.section_info
[i
].relocs
= NULL
;
5740 finfo
.section_info
[i
].rel_hashes
= NULL
;
5741 finfo
.section_info
[i
].toc_rel_hashes
= NULL
;
5745 /* Set the file positions for the relocs. */
5746 rel_filepos
= obj_relocbase (abfd
);
5747 relsz
= bfd_coff_relsz (abfd
);
5748 max_output_reloc_count
= 0;
5749 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5751 if (o
->reloc_count
== 0)
5755 /* A stripped file has no relocs. However, we still
5756 allocate the buffers, so that later code doesn't have to
5757 worry about whether we are stripping or not. */
5758 if (info
->strip
== strip_all
)
5762 o
->flags
|= SEC_RELOC
;
5763 o
->rel_filepos
= rel_filepos
;
5764 rel_filepos
+= o
->reloc_count
* relsz
;
5767 /* We don't know the indices of global symbols until we have
5768 written out all the local symbols. For each section in
5769 the output file, we keep an array of pointers to hash
5770 table entries. Each entry in the array corresponds to a
5771 reloc. When we find a reloc against a global symbol, we
5772 set the corresponding entry in this array so that we can
5773 fix up the symbol index after we have written out all the
5776 Because of this problem, we also keep the relocs in
5777 memory until the end of the link. This wastes memory.
5778 We could backpatch the file later, I suppose, although it
5780 amt
= o
->reloc_count
;
5781 amt
*= sizeof (struct internal_reloc
);
5782 finfo
.section_info
[o
->target_index
].relocs
= bfd_malloc (amt
);
5784 amt
= o
->reloc_count
;
5785 amt
*= sizeof (struct xcoff_link_hash_entry
*);
5786 finfo
.section_info
[o
->target_index
].rel_hashes
= bfd_malloc (amt
);
5788 if (finfo
.section_info
[o
->target_index
].relocs
== NULL
5789 || finfo
.section_info
[o
->target_index
].rel_hashes
== NULL
)
5792 if (o
->reloc_count
> max_output_reloc_count
)
5793 max_output_reloc_count
= o
->reloc_count
;
5797 /* We now know the size of the relocs, so we can determine the file
5798 positions of the line numbers. */
5799 line_filepos
= rel_filepos
;
5800 finfo
.line_filepos
= line_filepos
;
5801 linesz
= bfd_coff_linesz (abfd
);
5802 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5804 if (o
->lineno_count
== 0)
5805 o
->line_filepos
= 0;
5808 o
->line_filepos
= line_filepos
;
5809 line_filepos
+= o
->lineno_count
* linesz
;
5812 /* Reset the reloc and lineno counts, so that we can use them to
5813 count the number of entries we have output so far. */
5815 o
->lineno_count
= 0;
5818 obj_sym_filepos (abfd
) = line_filepos
;
5820 /* Figure out the largest number of symbols in an input BFD. Take
5821 the opportunity to clear the output_has_begun fields of all the
5822 input BFD's. We want at least 6 symbols, since that is the
5823 number which xcoff_write_global_symbol may need. */
5825 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
5829 sub
->output_has_begun
= FALSE
;
5830 sz
= obj_raw_syment_count (sub
);
5831 if (sz
> max_sym_count
)
5835 /* Allocate some buffers used while linking. */
5836 amt
= max_sym_count
* sizeof (struct internal_syment
);
5837 finfo
.internal_syms
= bfd_malloc (amt
);
5839 amt
= max_sym_count
* sizeof (long);
5840 finfo
.sym_indices
= bfd_malloc (amt
);
5842 amt
= (max_sym_count
+ 1) * symesz
;
5843 finfo
.outsyms
= bfd_malloc (amt
);
5845 amt
= max_lineno_count
* bfd_coff_linesz (abfd
);
5846 finfo
.linenos
= bfd_malloc (amt
);
5848 amt
= max_contents_size
;
5849 finfo
.contents
= bfd_malloc (amt
);
5851 amt
= max_reloc_count
* relsz
;
5852 finfo
.external_relocs
= bfd_malloc (amt
);
5854 if ((finfo
.internal_syms
== NULL
&& max_sym_count
> 0)
5855 || (finfo
.sym_indices
== NULL
&& max_sym_count
> 0)
5856 || finfo
.outsyms
== NULL
5857 || (finfo
.linenos
== NULL
&& max_lineno_count
> 0)
5858 || (finfo
.contents
== NULL
&& max_contents_size
> 0)
5859 || (finfo
.external_relocs
== NULL
&& max_reloc_count
> 0))
5862 obj_raw_syment_count (abfd
) = 0;
5864 /* Find a TOC symbol, if we need one. */
5865 if (!xcoff_find_tc0 (abfd
, &finfo
))
5868 /* We now know the position of everything in the file, except that
5869 we don't know the size of the symbol table and therefore we don't
5870 know where the string table starts. We just build the string
5871 table in memory as we go along. We process all the relocations
5872 for a single input file at once. */
5873 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5875 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
5877 if (p
->type
== bfd_indirect_link_order
5878 && p
->u
.indirect
.section
->owner
->xvec
== abfd
->xvec
)
5880 sub
= p
->u
.indirect
.section
->owner
;
5881 if (! sub
->output_has_begun
)
5883 if (! xcoff_link_input_bfd (&finfo
, sub
))
5885 sub
->output_has_begun
= TRUE
;
5888 else if (p
->type
== bfd_section_reloc_link_order
5889 || p
->type
== bfd_symbol_reloc_link_order
)
5891 if (! xcoff_reloc_link_order (abfd
, &finfo
, o
, p
))
5896 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5902 /* Free up the buffers used by xcoff_link_input_bfd. */
5903 if (finfo
.internal_syms
!= NULL
)
5905 free (finfo
.internal_syms
);
5906 finfo
.internal_syms
= NULL
;
5908 if (finfo
.sym_indices
!= NULL
)
5910 free (finfo
.sym_indices
);
5911 finfo
.sym_indices
= NULL
;
5913 if (finfo
.linenos
!= NULL
)
5915 free (finfo
.linenos
);
5916 finfo
.linenos
= NULL
;
5918 if (finfo
.contents
!= NULL
)
5920 free (finfo
.contents
);
5921 finfo
.contents
= NULL
;
5923 if (finfo
.external_relocs
!= NULL
)
5925 free (finfo
.external_relocs
);
5926 finfo
.external_relocs
= NULL
;
5929 /* The value of the last C_FILE symbol is supposed to be -1. Write
5931 if (finfo
.last_file_index
!= -1)
5933 finfo
.last_file
.n_value
= -(bfd_vma
) 1;
5934 bfd_coff_swap_sym_out (abfd
, (void *) &finfo
.last_file
,
5935 (void *) finfo
.outsyms
);
5936 pos
= obj_sym_filepos (abfd
) + finfo
.last_file_index
* symesz
;
5937 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
5938 || bfd_bwrite (finfo
.outsyms
, symesz
, abfd
) != symesz
)
5942 /* Write out all the global symbols which do not come from XCOFF
5944 xcoff_link_hash_traverse (xcoff_hash_table (info
),
5945 xcoff_write_global_symbol
,
5948 if (finfo
.outsyms
!= NULL
)
5950 free (finfo
.outsyms
);
5951 finfo
.outsyms
= NULL
;
5954 /* Now that we have written out all the global symbols, we know the
5955 symbol indices to use for relocs against them, and we can finally
5956 write out the relocs. */
5957 amt
= max_output_reloc_count
* relsz
;
5958 external_relocs
= bfd_malloc (amt
);
5959 if (external_relocs
== NULL
&& max_output_reloc_count
!= 0)
5962 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5964 struct internal_reloc
*irel
;
5965 struct internal_reloc
*irelend
;
5966 struct xcoff_link_hash_entry
**rel_hash
;
5967 struct xcoff_toc_rel_hash
*toc_rel_hash
;
5969 bfd_size_type rel_size
;
5971 /* A stripped file has no relocs. */
5972 if (info
->strip
== strip_all
)
5978 if (o
->reloc_count
== 0)
5981 irel
= finfo
.section_info
[o
->target_index
].relocs
;
5982 irelend
= irel
+ o
->reloc_count
;
5983 rel_hash
= finfo
.section_info
[o
->target_index
].rel_hashes
;
5984 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
5986 if (*rel_hash
!= NULL
)
5988 if ((*rel_hash
)->indx
< 0)
5990 if (! ((*info
->callbacks
->unattached_reloc
)
5991 (info
, (*rel_hash
)->root
.root
.string
,
5992 NULL
, o
, irel
->r_vaddr
)))
5994 (*rel_hash
)->indx
= 0;
5996 irel
->r_symndx
= (*rel_hash
)->indx
;
6000 for (toc_rel_hash
= finfo
.section_info
[o
->target_index
].toc_rel_hashes
;
6001 toc_rel_hash
!= NULL
;
6002 toc_rel_hash
= toc_rel_hash
->next
)
6004 if (toc_rel_hash
->h
->u
.toc_indx
< 0)
6006 if (! ((*info
->callbacks
->unattached_reloc
)
6007 (info
, toc_rel_hash
->h
->root
.root
.string
,
6008 NULL
, o
, toc_rel_hash
->rel
->r_vaddr
)))
6010 toc_rel_hash
->h
->u
.toc_indx
= 0;
6012 toc_rel_hash
->rel
->r_symndx
= toc_rel_hash
->h
->u
.toc_indx
;
6015 /* XCOFF requires that the relocs be sorted by address. We tend
6016 to produce them in the order in which their containing csects
6017 appear in the symbol table, which is not necessarily by
6018 address. So we sort them here. There may be a better way to
6020 qsort ((void *) finfo
.section_info
[o
->target_index
].relocs
,
6021 o
->reloc_count
, sizeof (struct internal_reloc
),
6024 irel
= finfo
.section_info
[o
->target_index
].relocs
;
6025 irelend
= irel
+ o
->reloc_count
;
6026 erel
= external_relocs
;
6027 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
6028 bfd_coff_swap_reloc_out (abfd
, (void *) irel
, (void *) erel
);
6030 rel_size
= relsz
* o
->reloc_count
;
6031 if (bfd_seek (abfd
, o
->rel_filepos
, SEEK_SET
) != 0
6032 || bfd_bwrite ((void *) external_relocs
, rel_size
, abfd
) != rel_size
)
6036 if (external_relocs
!= NULL
)
6038 free (external_relocs
);
6039 external_relocs
= NULL
;
6042 /* Free up the section information. */
6043 if (finfo
.section_info
!= NULL
)
6047 for (i
= 0; i
< abfd
->section_count
; i
++)
6049 if (finfo
.section_info
[i
].relocs
!= NULL
)
6050 free (finfo
.section_info
[i
].relocs
);
6051 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
6052 free (finfo
.section_info
[i
].rel_hashes
);
6054 free (finfo
.section_info
);
6055 finfo
.section_info
= NULL
;
6058 /* Write out the loader section contents. */
6059 BFD_ASSERT ((bfd_byte
*) finfo
.ldrel
6060 == (xcoff_hash_table (info
)->loader_section
->contents
6061 + xcoff_hash_table (info
)->ldhdr
.l_impoff
));
6062 o
= xcoff_hash_table (info
)->loader_section
;
6063 if (! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
6064 (file_ptr
) o
->output_offset
, o
->size
))
6067 /* Write out the magic sections. */
6068 o
= xcoff_hash_table (info
)->linkage_section
;
6070 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
6071 (file_ptr
) o
->output_offset
,
6074 o
= xcoff_hash_table (info
)->toc_section
;
6076 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
6077 (file_ptr
) o
->output_offset
,
6080 o
= xcoff_hash_table (info
)->descriptor_section
;
6082 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
6083 (file_ptr
) o
->output_offset
,
6087 /* Write out the string table. */
6088 pos
= obj_sym_filepos (abfd
) + obj_raw_syment_count (abfd
) * symesz
;
6089 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
6092 _bfd_stringtab_size (finfo
.strtab
) + STRING_SIZE_SIZE
,
6094 amt
= STRING_SIZE_SIZE
;
6095 if (bfd_bwrite (strbuf
, amt
, abfd
) != amt
)
6097 if (! _bfd_stringtab_emit (abfd
, finfo
.strtab
))
6100 _bfd_stringtab_free (finfo
.strtab
);
6102 /* Write out the debugging string table. */
6103 o
= xcoff_hash_table (info
)->debug_section
;
6106 struct bfd_strtab_hash
*debug_strtab
;
6108 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
6109 BFD_ASSERT (o
->output_section
->size
- o
->output_offset
6110 >= _bfd_stringtab_size (debug_strtab
));
6111 pos
= o
->output_section
->filepos
+ o
->output_offset
;
6112 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
6114 if (! _bfd_stringtab_emit (abfd
, debug_strtab
))
6118 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
6119 not try to write out the symbols. */
6120 bfd_get_symcount (abfd
) = 0;
6125 if (finfo
.strtab
!= NULL
)
6126 _bfd_stringtab_free (finfo
.strtab
);
6128 if (finfo
.section_info
!= NULL
)
6132 for (i
= 0; i
< abfd
->section_count
; i
++)
6134 if (finfo
.section_info
[i
].relocs
!= NULL
)
6135 free (finfo
.section_info
[i
].relocs
);
6136 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
6137 free (finfo
.section_info
[i
].rel_hashes
);
6139 free (finfo
.section_info
);
6142 if (finfo
.internal_syms
!= NULL
)
6143 free (finfo
.internal_syms
);
6144 if (finfo
.sym_indices
!= NULL
)
6145 free (finfo
.sym_indices
);
6146 if (finfo
.outsyms
!= NULL
)
6147 free (finfo
.outsyms
);
6148 if (finfo
.linenos
!= NULL
)
6149 free (finfo
.linenos
);
6150 if (finfo
.contents
!= NULL
)
6151 free (finfo
.contents
);
6152 if (finfo
.external_relocs
!= NULL
)
6153 free (finfo
.external_relocs
);
6154 if (external_relocs
!= NULL
)
6155 free (external_relocs
);