1 /* POWER/PowerPC XCOFF linker support.
2 Copyright (C) 1995-2023 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>, Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
26 #include "coff/internal.h"
27 #include "coff/xcoff.h"
30 #include "libiberty.h"
31 #include "xcofflink.h"
33 /* This file holds the XCOFF linker code. */
35 #undef STRING_SIZE_SIZE
36 #define STRING_SIZE_SIZE 4
38 /* The list of import files. */
40 struct xcoff_import_file
42 /* The next entry in the list. */
43 struct xcoff_import_file
*next
;
48 /* The member name. */
52 /* Information we keep for each section in the output file during the
55 struct xcoff_link_section_info
57 /* The relocs to be output. */
58 struct internal_reloc
*relocs
;
59 /* For each reloc against a global symbol whose index was not known
60 when the reloc was handled, the global hash table entry. */
61 struct xcoff_link_hash_entry
**rel_hashes
;
62 /* If there is a TOC relative reloc against a global symbol, and the
63 index of the TOC symbol is not known when the reloc was handled,
64 an entry is added to this linked list. This is not an array,
65 like rel_hashes, because this case is quite uncommon. */
66 struct xcoff_toc_rel_hash
68 struct xcoff_toc_rel_hash
*next
;
69 struct xcoff_link_hash_entry
*h
;
70 struct internal_reloc
*rel
;
74 /* Information that the XCOFF linker collects about an archive. */
75 struct xcoff_archive_info
77 /* The archive described by this entry. */
80 /* The import path and import filename to use when referring to
81 this archive in the .loader section. */
85 /* True if the archive contains a dynamic object. */
86 unsigned int contains_shared_object_p
: 1;
88 /* True if the previous field is valid. */
89 unsigned int know_contains_shared_object_p
: 1;
92 struct xcoff_link_hash_table
94 struct bfd_link_hash_table root
;
96 /* The stub hash table. */
97 struct bfd_hash_table stub_hash_table
;
99 /* Info passed by the linker. */
100 struct bfd_xcoff_link_params
*params
;
102 /* The .debug string hash table. We need to compute this while
103 reading the input files, so that we know how large the .debug
104 section will be before we assign section positions. */
105 struct bfd_strtab_hash
*debug_strtab
;
107 /* The .debug section we will use for the final output. */
108 asection
*debug_section
;
110 /* The .loader section we will use for the final output. */
111 asection
*loader_section
;
113 /* The structure holding information about the .loader section. */
114 struct xcoff_loader_info ldinfo
;
116 /* The .loader section header. */
117 struct internal_ldhdr ldhdr
;
119 /* The .gl section we use to hold global linkage code. */
120 asection
*linkage_section
;
122 /* The .tc section we use to hold toc entries we build for global
124 asection
*toc_section
;
126 /* The .ds section we use to hold function descriptors which we
127 create for exported symbols. */
128 asection
*descriptor_section
;
130 /* The list of import files. */
131 struct xcoff_import_file
*imports
;
133 /* Required alignment of sections within the output file. */
134 unsigned long file_align
;
136 /* Whether the .text section must be read-only. */
139 /* Whether -brtl was specified. */
142 /* Whether garbage collection was done. */
145 /* A linked list of symbols for which we have size information. */
146 struct xcoff_link_size_list
148 struct xcoff_link_size_list
*next
;
149 struct xcoff_link_hash_entry
*h
;
154 /* Information about archives. */
157 /* Magic sections: _text, _etext, _data, _edata, _end, end. */
158 asection
*special_sections
[XCOFF_NUMBER_OF_SPECIAL_SECTIONS
];
161 /* Information that we pass around while doing the final link step. */
163 struct xcoff_final_link_info
165 /* General link information. */
166 struct bfd_link_info
*info
;
169 /* Hash table for long symbol names. */
170 struct bfd_strtab_hash
*strtab
;
171 /* Array of information kept for each output section, indexed by the
172 target_index field. */
173 struct xcoff_link_section_info
*section_info
;
174 /* Symbol index of last C_FILE symbol (-1 if none). */
175 long last_file_index
;
176 /* Contents of last C_FILE symbol. */
177 struct internal_syment last_file
;
178 /* Symbol index of TOC symbol. */
180 /* Start of .loader symbols. */
182 /* Next .loader reloc to swap out. */
184 /* File position of start of line numbers. */
185 file_ptr line_filepos
;
186 /* Buffer large enough to hold swapped symbols of any input file. */
187 struct internal_syment
*internal_syms
;
188 /* Buffer large enough to hold output indices of symbols of any
191 /* Buffer large enough to hold output symbols for any input file. */
193 /* Buffer large enough to hold external line numbers for any input
196 /* Buffer large enough to hold any input section. */
198 /* Buffer large enough to hold external relocs of any input section. */
199 bfd_byte
*external_relocs
;
202 #define xcoff_stub_hash_entry(ent) \
203 ((struct xcoff_stub_hash_entry *)(ent))
205 #define xcoff_stub_hash_lookup(table, string, create, copy) \
206 ((struct xcoff_stub_hash_entry *) \
207 bfd_hash_lookup ((table), (string), (create), (copy)))
209 static bool xcoff_mark (struct bfd_link_info
*, asection
*);
213 /* Routines to read XCOFF dynamic information. This don't really
214 belong here, but we already have the ldsym manipulation routines
217 /* Read the contents of a section. */
220 xcoff_get_section_contents (bfd
*abfd
, asection
*sec
)
222 if (coff_section_data (abfd
, sec
) == NULL
)
224 size_t amt
= sizeof (struct coff_section_tdata
);
226 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
227 if (sec
->used_by_bfd
== NULL
)
231 bfd_byte
*contents
= coff_section_data (abfd
, sec
)->contents
;
232 if (contents
== NULL
)
234 if (bfd_malloc_and_get_section (abfd
, sec
, &contents
))
235 coff_section_data (abfd
, sec
)->contents
= contents
;
246 /* Get the size required to hold the dynamic symbols. */
249 _bfd_xcoff_get_dynamic_symtab_upper_bound (bfd
*abfd
)
253 struct internal_ldhdr ldhdr
;
255 if ((abfd
->flags
& DYNAMIC
) == 0)
257 bfd_set_error (bfd_error_invalid_operation
);
261 lsec
= bfd_get_section_by_name (abfd
, ".loader");
262 if (lsec
== NULL
|| (lsec
->flags
& SEC_HAS_CONTENTS
) == 0)
264 bfd_set_error (bfd_error_no_symbols
);
268 contents
= xcoff_get_section_contents (abfd
, lsec
);
272 bfd_xcoff_swap_ldhdr_in (abfd
, (void *) contents
, &ldhdr
);
274 return (ldhdr
.l_nsyms
+ 1) * sizeof (asymbol
*);
277 /* Get the dynamic symbols. */
280 _bfd_xcoff_canonicalize_dynamic_symtab (bfd
*abfd
, asymbol
**psyms
)
284 struct internal_ldhdr ldhdr
;
286 bfd_byte
*elsym
, *elsymend
;
287 coff_symbol_type
*symbuf
;
289 if ((abfd
->flags
& DYNAMIC
) == 0)
291 bfd_set_error (bfd_error_invalid_operation
);
295 lsec
= bfd_get_section_by_name (abfd
, ".loader");
296 if (lsec
== NULL
|| (lsec
->flags
& SEC_HAS_CONTENTS
) == 0)
298 bfd_set_error (bfd_error_no_symbols
);
302 contents
= xcoff_get_section_contents (abfd
, lsec
);
306 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
308 strings
= (char *) contents
+ ldhdr
.l_stoff
;
310 symbuf
= bfd_zalloc (abfd
, ldhdr
.l_nsyms
* sizeof (* symbuf
));
314 elsym
= contents
+ bfd_xcoff_loader_symbol_offset(abfd
, &ldhdr
);
316 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz(abfd
);
317 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz(abfd
), symbuf
++, psyms
++)
319 struct internal_ldsym ldsym
;
321 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
323 symbuf
->symbol
.the_bfd
= abfd
;
325 if (ldsym
._l
._l_l
._l_zeroes
== 0)
326 symbuf
->symbol
.name
= strings
+ ldsym
._l
._l_l
._l_offset
;
331 c
= bfd_alloc (abfd
, (bfd_size_type
) SYMNMLEN
+ 1);
334 memcpy (c
, ldsym
._l
._l_name
, SYMNMLEN
);
336 symbuf
->symbol
.name
= c
;
339 if (ldsym
.l_smclas
== XMC_XO
)
340 symbuf
->symbol
.section
= bfd_abs_section_ptr
;
342 symbuf
->symbol
.section
= coff_section_from_bfd_index (abfd
,
344 symbuf
->symbol
.value
= ldsym
.l_value
- symbuf
->symbol
.section
->vma
;
346 symbuf
->symbol
.flags
= BSF_NO_FLAGS
;
347 if ((ldsym
.l_smtype
& L_EXPORT
) != 0)
349 if ((ldsym
.l_smtype
& L_WEAK
) != 0)
350 symbuf
->symbol
.flags
|= BSF_WEAK
;
352 symbuf
->symbol
.flags
|= BSF_GLOBAL
;
355 /* FIXME: We have no way to record the other information stored
356 with the loader symbol. */
357 *psyms
= (asymbol
*) symbuf
;
362 return ldhdr
.l_nsyms
;
365 /* Get the size required to hold the dynamic relocs. */
368 _bfd_xcoff_get_dynamic_reloc_upper_bound (bfd
*abfd
)
372 struct internal_ldhdr ldhdr
;
374 if ((abfd
->flags
& DYNAMIC
) == 0)
376 bfd_set_error (bfd_error_invalid_operation
);
380 lsec
= bfd_get_section_by_name (abfd
, ".loader");
381 if (lsec
== NULL
|| (lsec
->flags
& SEC_HAS_CONTENTS
) == 0)
383 bfd_set_error (bfd_error_no_symbols
);
387 contents
= xcoff_get_section_contents (abfd
, lsec
);
391 bfd_xcoff_swap_ldhdr_in (abfd
, (struct external_ldhdr
*) contents
, &ldhdr
);
393 return (ldhdr
.l_nreloc
+ 1) * sizeof (arelent
*);
396 /* Get the dynamic relocs. */
399 _bfd_xcoff_canonicalize_dynamic_reloc (bfd
*abfd
,
405 struct internal_ldhdr ldhdr
;
407 bfd_byte
*elrel
, *elrelend
;
409 if ((abfd
->flags
& DYNAMIC
) == 0)
411 bfd_set_error (bfd_error_invalid_operation
);
415 lsec
= bfd_get_section_by_name (abfd
, ".loader");
416 if (lsec
== NULL
|| (lsec
->flags
& SEC_HAS_CONTENTS
) == 0)
418 bfd_set_error (bfd_error_no_symbols
);
422 contents
= xcoff_get_section_contents (abfd
, lsec
);
426 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
428 relbuf
= bfd_alloc (abfd
, ldhdr
.l_nreloc
* sizeof (arelent
));
432 elrel
= contents
+ bfd_xcoff_loader_reloc_offset(abfd
, &ldhdr
);
434 elrelend
= elrel
+ ldhdr
.l_nreloc
* bfd_xcoff_ldrelsz(abfd
);
435 for (; elrel
< elrelend
; elrel
+= bfd_xcoff_ldrelsz(abfd
), relbuf
++,
438 struct internal_ldrel ldrel
;
440 bfd_xcoff_swap_ldrel_in (abfd
, elrel
, &ldrel
);
442 if (ldrel
.l_symndx
>= 3)
443 relbuf
->sym_ptr_ptr
= syms
+ (ldrel
.l_symndx
- 3);
449 switch (ldrel
.l_symndx
)
465 sec
= bfd_get_section_by_name (abfd
, name
);
468 bfd_set_error (bfd_error_bad_value
);
472 relbuf
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
475 relbuf
->address
= ldrel
.l_vaddr
;
478 /* Most dynamic relocs have the same type. FIXME: This is only
479 correct if ldrel.l_rtype == 0. In other cases, we should use
480 a different howto. */
481 relbuf
->howto
= bfd_xcoff_dynamic_reloc_howto(abfd
);
483 /* FIXME: We have no way to record the l_rsecnm field. */
490 return ldhdr
.l_nreloc
;
493 /* Hash functions for xcoff_link_hash_table's archive_info. */
496 xcoff_archive_info_hash (const void *data
)
498 const struct xcoff_archive_info
*info
;
500 info
= (const struct xcoff_archive_info
*) data
;
501 return htab_hash_pointer (info
->archive
);
505 xcoff_archive_info_eq (const void *data1
, const void *data2
)
507 const struct xcoff_archive_info
*info1
;
508 const struct xcoff_archive_info
*info2
;
510 info1
= (const struct xcoff_archive_info
*) data1
;
511 info2
= (const struct xcoff_archive_info
*) data2
;
512 return info1
->archive
== info2
->archive
;
515 /* Return information about archive ARCHIVE. Return NULL on error. */
517 static struct xcoff_archive_info
*
518 xcoff_get_archive_info (struct bfd_link_info
*info
, bfd
*archive
)
520 struct xcoff_link_hash_table
*htab
;
521 struct xcoff_archive_info
*entryp
, entry
;
524 htab
= xcoff_hash_table (info
);
525 entry
.archive
= archive
;
526 slot
= htab_find_slot (htab
->archive_info
, &entry
, INSERT
);
533 entryp
= bfd_zalloc (info
->output_bfd
, sizeof (entry
));
537 entryp
->archive
= archive
;
544 /* Initialize an entry in the stub hash table. */
545 static struct bfd_hash_entry
*
546 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
547 struct bfd_hash_table
*table
,
550 /* Allocate the structure if it has not already been allocated by a
554 entry
= bfd_hash_allocate (table
,
555 sizeof (struct xcoff_stub_hash_entry
));
560 /* Call the allocation method of the superclass. */
561 entry
= bfd_hash_newfunc (entry
, table
, string
);
564 struct xcoff_stub_hash_entry
*hsh
;
566 /* Initialize the local fields. */
567 hsh
= (struct xcoff_stub_hash_entry
*) entry
;
568 hsh
->stub_type
= xcoff_stub_none
;
570 hsh
->stub_offset
= 0;
571 hsh
->target_section
= NULL
;
578 /* Routine to create an entry in an XCOFF link hash table. */
580 static struct bfd_hash_entry
*
581 xcoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
582 struct bfd_hash_table
*table
,
585 struct xcoff_link_hash_entry
*ret
= (struct xcoff_link_hash_entry
*) entry
;
587 /* Allocate the structure if it has not already been allocated by a
590 ret
= bfd_hash_allocate (table
, sizeof (* ret
));
594 /* Call the allocation method of the superclass. */
595 ret
= ((struct xcoff_link_hash_entry
*)
596 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
600 /* Set local fields. */
602 ret
->toc_section
= NULL
;
603 ret
->u
.toc_indx
= -1;
604 ret
->descriptor
= NULL
;
608 ret
->smclas
= XMC_UA
;
611 return (struct bfd_hash_entry
*) ret
;
614 /* Destroy an XCOFF link hash table. */
617 _bfd_xcoff_bfd_link_hash_table_free (bfd
*obfd
)
619 struct xcoff_link_hash_table
*ret
;
621 ret
= (struct xcoff_link_hash_table
*) obfd
->link
.hash
;
622 if (ret
->archive_info
)
623 htab_delete (ret
->archive_info
);
624 if (ret
->debug_strtab
)
625 _bfd_stringtab_free (ret
->debug_strtab
);
627 bfd_hash_table_free (&ret
->stub_hash_table
);
628 _bfd_generic_link_hash_table_free (obfd
);
631 /* Create an XCOFF link hash table. */
633 struct bfd_link_hash_table
*
634 _bfd_xcoff_bfd_link_hash_table_create (bfd
*abfd
)
636 struct xcoff_link_hash_table
*ret
;
637 bool isxcoff64
= false;
638 size_t amt
= sizeof (* ret
);
640 ret
= bfd_zmalloc (amt
);
643 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
, xcoff_link_hash_newfunc
,
644 sizeof (struct xcoff_link_hash_entry
)))
650 /* Init the stub hash table too. */
651 if (!bfd_hash_table_init (&ret
->stub_hash_table
, stub_hash_newfunc
,
652 sizeof (struct xcoff_stub_hash_entry
)))
654 _bfd_xcoff_bfd_link_hash_table_free (abfd
);
658 isxcoff64
= bfd_coff_debug_string_prefix_length (abfd
) == 4;
660 ret
->debug_strtab
= _bfd_xcoff_stringtab_init (isxcoff64
);
661 ret
->archive_info
= htab_create (37, xcoff_archive_info_hash
,
662 xcoff_archive_info_eq
, NULL
);
663 if (!ret
->debug_strtab
|| !ret
->archive_info
)
665 _bfd_xcoff_bfd_link_hash_table_free (abfd
);
668 ret
->root
.hash_table_free
= _bfd_xcoff_bfd_link_hash_table_free
;
670 /* The linker will always generate a full a.out header. We need to
671 record that fact now, before the sizeof_headers routine could be
673 xcoff_data (abfd
)->full_aouthdr
= true;
678 /* Read internal relocs for an XCOFF csect. This is a wrapper around
679 _bfd_coff_read_internal_relocs which tries to take advantage of any
680 relocs which may have been cached for the enclosing section. */
682 static struct internal_reloc
*
683 xcoff_read_internal_relocs (bfd
*abfd
,
686 bfd_byte
*external_relocs
,
687 bool require_internal
,
688 struct internal_reloc
*internal_relocs
)
690 if (coff_section_data (abfd
, sec
) != NULL
691 && coff_section_data (abfd
, sec
)->relocs
== NULL
692 && xcoff_section_data (abfd
, sec
) != NULL
)
696 enclosing
= xcoff_section_data (abfd
, sec
)->enclosing
;
698 if (enclosing
!= NULL
699 && (coff_section_data (abfd
, enclosing
) == NULL
700 || coff_section_data (abfd
, enclosing
)->relocs
== NULL
)
702 && enclosing
->reloc_count
> 0)
704 if (_bfd_coff_read_internal_relocs (abfd
, enclosing
, true,
705 external_relocs
, false, NULL
)
710 if (enclosing
!= NULL
711 && coff_section_data (abfd
, enclosing
) != NULL
712 && coff_section_data (abfd
, enclosing
)->relocs
!= NULL
)
716 off
= ((sec
->rel_filepos
- enclosing
->rel_filepos
)
717 / bfd_coff_relsz (abfd
));
719 if (! require_internal
)
720 return coff_section_data (abfd
, enclosing
)->relocs
+ off
;
721 memcpy (internal_relocs
,
722 coff_section_data (abfd
, enclosing
)->relocs
+ off
,
723 sec
->reloc_count
* sizeof (struct internal_reloc
));
724 return internal_relocs
;
728 return _bfd_coff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
729 require_internal
, internal_relocs
);
732 /* Split FILENAME into an import path and an import filename,
733 storing them in *IMPPATH and *IMPFILE respectively. */
736 bfd_xcoff_split_import_path (bfd
*abfd
, const char *filename
,
737 const char **imppath
, const char **impfile
)
743 base
= lbasename (filename
);
744 length
= base
- filename
;
746 /* The filename has no directory component, so use an empty path. */
748 else if (length
== 1)
749 /* The filename is in the root directory. */
753 /* Extract the (non-empty) directory part. Note that we don't
754 need to strip duplicate directory separators from any part
755 of the string; the native linker doesn't do that either. */
756 path
= bfd_alloc (abfd
, length
);
759 memcpy (path
, filename
, length
- 1);
760 path
[length
- 1] = 0;
767 /* Set ARCHIVE's import path as though its filename had been given
771 bfd_xcoff_set_archive_import_path (struct bfd_link_info
*info
,
772 bfd
*archive
, const char *filename
)
774 struct xcoff_archive_info
*archive_info
;
776 archive_info
= xcoff_get_archive_info (info
, archive
);
777 return (archive_info
!= NULL
778 && bfd_xcoff_split_import_path (archive
, filename
,
779 &archive_info
->imppath
,
780 &archive_info
->impfile
));
783 /* H is an imported symbol. Set the import module's path, file and member
784 to IMPATH, IMPFILE and IMPMEMBER respectively. All three are null if
785 no specific import module is specified. */
788 xcoff_set_import_path (struct bfd_link_info
*info
,
789 struct xcoff_link_hash_entry
*h
,
790 const char *imppath
, const char *impfile
,
791 const char *impmember
)
794 struct xcoff_import_file
**pp
;
796 /* We overload the ldindx field to hold the l_ifile value for this
798 BFD_ASSERT (h
->ldsym
== NULL
);
799 BFD_ASSERT ((h
->flags
& XCOFF_BUILT_LDSYM
) == 0);
804 /* We start c at 1 because the first entry in the import list is
805 reserved for the library search path. */
806 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
808 pp
= &(*pp
)->next
, ++c
)
810 if (filename_cmp ((*pp
)->path
, imppath
) == 0
811 && filename_cmp ((*pp
)->file
, impfile
) == 0
812 && filename_cmp ((*pp
)->member
, impmember
) == 0)
818 struct xcoff_import_file
*n
;
819 size_t amt
= sizeof (*n
);
821 n
= bfd_alloc (info
->output_bfd
, amt
);
827 n
->member
= impmember
;
835 /* H is the bfd symbol associated with exported .loader symbol LDSYM.
836 Return true if LDSYM defines H. */
839 xcoff_dynamic_definition_p (struct xcoff_link_hash_entry
*h
,
840 struct internal_ldsym
*ldsym
)
842 /* If we didn't know about H before processing LDSYM, LDSYM
843 definitely defines H. */
844 if (h
->root
.type
== bfd_link_hash_new
)
847 /* If H is currently a weak dynamic symbol, and if LDSYM is a strong
848 dynamic symbol, LDSYM trumps the current definition of H. */
849 if ((ldsym
->l_smtype
& L_WEAK
) == 0
850 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0
851 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
852 && (h
->root
.type
== bfd_link_hash_defweak
853 || h
->root
.type
== bfd_link_hash_undefweak
))
856 /* If H is currently undefined, LDSYM defines it.
857 However, if H has a hidden visibility, LDSYM must not
859 if ((h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
860 && (h
->root
.type
== bfd_link_hash_undefined
861 || h
->root
.type
== bfd_link_hash_undefweak
)
862 && (h
->visibility
!= SYM_V_HIDDEN
863 && h
->visibility
!= SYM_V_INTERNAL
))
869 /* This function is used to add symbols from a dynamic object to the
870 global symbol table. */
873 xcoff_link_add_dynamic_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
877 struct internal_ldhdr ldhdr
;
879 bfd_byte
*elsym
, *elsymend
;
880 struct xcoff_import_file
*n
;
882 struct xcoff_import_file
**pp
;
884 /* We can only handle a dynamic object if we are generating an XCOFF
886 if (info
->output_bfd
->xvec
!= abfd
->xvec
)
889 (_("%pB: XCOFF shared object when not producing XCOFF output"),
891 bfd_set_error (bfd_error_invalid_operation
);
895 /* The symbols we use from a dynamic object are not the symbols in
896 the normal symbol table, but, rather, the symbols in the export
897 table. If there is a global symbol in a dynamic object which is
898 not in the export table, the loader will not be able to find it,
899 so we don't want to find it either. Also, on AIX 4.1.3, shr.o in
900 libc.a has symbols in the export table which are not in the
903 /* Read in the .loader section. FIXME: We should really use the
904 o_snloader field in the a.out header, rather than grabbing the
906 lsec
= bfd_get_section_by_name (abfd
, ".loader");
907 if (lsec
== NULL
|| (lsec
->flags
& SEC_HAS_CONTENTS
) == 0)
910 (_("%pB: dynamic object with no .loader section"),
912 bfd_set_error (bfd_error_no_symbols
);
916 contents
= xcoff_get_section_contents (abfd
, lsec
);
920 /* Remove the sections from this object, so that they do not get
921 included in the link. */
922 bfd_section_list_clear (abfd
);
924 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
926 strings
= (char *) contents
+ ldhdr
.l_stoff
;
928 elsym
= contents
+ bfd_xcoff_loader_symbol_offset(abfd
, &ldhdr
);
930 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz(abfd
);
932 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz(abfd
))
934 struct internal_ldsym ldsym
;
935 char nambuf
[SYMNMLEN
+ 1];
937 struct xcoff_link_hash_entry
*h
;
939 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
941 /* We are only interested in exported symbols. */
942 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
945 if (ldsym
._l
._l_l
._l_zeroes
== 0)
946 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
949 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
950 nambuf
[SYMNMLEN
] = '\0';
954 /* Normally we could not call xcoff_link_hash_lookup in an add
955 symbols routine, since we might not be using an XCOFF hash
956 table. However, we verified above that we are using an XCOFF
959 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, true,
964 if (!xcoff_dynamic_definition_p (h
, &ldsym
))
967 h
->flags
|= XCOFF_DEF_DYNAMIC
;
968 h
->smclas
= ldsym
.l_smclas
;
969 if (h
->smclas
== XMC_XO
)
971 /* This symbol has an absolute value. */
972 if ((ldsym
.l_smtype
& L_WEAK
) != 0)
973 h
->root
.type
= bfd_link_hash_defweak
;
975 h
->root
.type
= bfd_link_hash_defined
;
976 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
977 h
->root
.u
.def
.value
= ldsym
.l_value
;
981 /* Otherwise, we don't bother to actually define the symbol,
982 since we don't have a section to put it in anyhow.
983 We assume instead that an undefined XCOFF_DEF_DYNAMIC symbol
984 should be imported from the symbol's undef.abfd. */
985 if ((ldsym
.l_smtype
& L_WEAK
) != 0)
986 h
->root
.type
= bfd_link_hash_undefweak
;
988 h
->root
.type
= bfd_link_hash_undefined
;
989 h
->root
.u
.undef
.abfd
= abfd
;
992 /* If this symbol defines a function descriptor, then it
993 implicitly defines the function code as well. */
994 if (h
->smclas
== XMC_DS
995 || (h
->smclas
== XMC_XO
&& name
[0] != '.'))
996 h
->flags
|= XCOFF_DESCRIPTOR
;
997 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
999 struct xcoff_link_hash_entry
*hds
;
1001 hds
= h
->descriptor
;
1006 dsnm
= bfd_malloc ((bfd_size_type
) strlen (name
) + 2);
1010 strcpy (dsnm
+ 1, name
);
1011 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
), dsnm
,
1017 hds
->descriptor
= h
;
1018 h
->descriptor
= hds
;
1021 if (xcoff_dynamic_definition_p (hds
, &ldsym
))
1023 hds
->root
.type
= h
->root
.type
;
1024 hds
->flags
|= XCOFF_DEF_DYNAMIC
;
1025 if (h
->smclas
== XMC_XO
)
1027 /* An absolute symbol appears to actually define code, not a
1028 function descriptor. This is how some math functions are
1029 implemented on AIX 4.1. */
1030 hds
->smclas
= XMC_XO
;
1031 hds
->root
.u
.def
.section
= bfd_abs_section_ptr
;
1032 hds
->root
.u
.def
.value
= ldsym
.l_value
;
1036 hds
->smclas
= XMC_PR
;
1037 hds
->root
.u
.undef
.abfd
= abfd
;
1038 /* We do not want to add this to the undefined
1046 coff_section_data (abfd
, lsec
)->contents
= NULL
;
1048 /* Record this file in the import files. */
1049 n
= bfd_alloc (abfd
, (bfd_size_type
) sizeof (struct xcoff_import_file
));
1054 if (abfd
->my_archive
== NULL
|| bfd_is_thin_archive (abfd
->my_archive
))
1056 if (!bfd_xcoff_split_import_path (abfd
, bfd_get_filename (abfd
),
1057 &n
->path
, &n
->file
))
1063 struct xcoff_archive_info
*archive_info
;
1065 archive_info
= xcoff_get_archive_info (info
, abfd
->my_archive
);
1066 if (!archive_info
->impfile
)
1068 if (!bfd_xcoff_split_import_path (archive_info
->archive
,
1069 bfd_get_filename (archive_info
1071 &archive_info
->imppath
,
1072 &archive_info
->impfile
))
1075 n
->path
= archive_info
->imppath
;
1076 n
->file
= archive_info
->impfile
;
1077 n
->member
= bfd_get_filename (abfd
);
1080 /* We start c at 1 because the first import file number is reserved
1082 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
1084 pp
= &(*pp
)->next
, ++c
)
1088 xcoff_data (abfd
)->import_file_id
= c
;
1093 /* xcoff_link_create_extra_sections
1095 Takes care of creating the .loader, .gl, .ds, .debug and sections. */
1098 xcoff_link_create_extra_sections (bfd
* abfd
, struct bfd_link_info
*info
)
1100 bool return_value
= false;
1102 if (info
->output_bfd
->xvec
== abfd
->xvec
)
1104 /* We need to build a .loader section, so we do it here. This
1105 won't work if we're producing an XCOFF output file with no
1106 XCOFF input files. FIXME. */
1108 if (!bfd_link_relocatable (info
)
1109 && xcoff_hash_table (info
)->loader_section
== NULL
)
1112 flagword flags
= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
1114 lsec
= bfd_make_section_anyway_with_flags (abfd
, ".loader", flags
);
1118 xcoff_hash_table (info
)->loader_section
= lsec
;
1121 /* Likewise for the linkage section. */
1122 if (xcoff_hash_table (info
)->linkage_section
== NULL
)
1125 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1128 lsec
= bfd_make_section_anyway_with_flags (abfd
, ".gl", flags
);
1132 xcoff_hash_table (info
)->linkage_section
= lsec
;
1133 lsec
->alignment_power
= 2;
1136 /* Likewise for the TOC section. */
1137 if (xcoff_hash_table (info
)->toc_section
== NULL
)
1140 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1143 tsec
= bfd_make_section_anyway_with_flags (abfd
, ".tc", flags
);
1147 xcoff_hash_table (info
)->toc_section
= tsec
;
1148 tsec
->alignment_power
= 2;
1151 /* Likewise for the descriptor section. */
1152 if (xcoff_hash_table (info
)->descriptor_section
== NULL
)
1155 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1158 dsec
= bfd_make_section_anyway_with_flags (abfd
, ".ds", flags
);
1162 xcoff_hash_table (info
)->descriptor_section
= dsec
;
1163 dsec
->alignment_power
= 2;
1166 /* Likewise for the .debug section. */
1167 if (xcoff_hash_table (info
)->debug_section
== NULL
1168 && info
->strip
!= strip_all
)
1171 flagword flags
= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
1173 dsec
= bfd_make_section_anyway_with_flags (abfd
, ".debug", flags
);
1177 xcoff_hash_table (info
)->debug_section
= dsec
;
1181 return_value
= true;
1185 return return_value
;
1188 /* Returns the index of reloc in RELOCS with the least address greater
1189 than or equal to ADDRESS. The relocs are sorted by address. */
1191 static bfd_size_type
1192 xcoff_find_reloc (struct internal_reloc
*relocs
,
1193 bfd_size_type count
,
1196 bfd_size_type min
, max
, this;
1200 if (count
== 1 && relocs
[0].r_vaddr
< address
)
1209 /* Do a binary search over (min,max]. */
1210 while (min
+ 1 < max
)
1214 this = (max
+ min
) / 2;
1215 raddr
= relocs
[this].r_vaddr
;
1216 if (raddr
> address
)
1218 else if (raddr
< address
)
1227 if (relocs
[min
].r_vaddr
< address
)
1231 && relocs
[min
- 1].r_vaddr
== address
)
1237 /* Return true if the symbol has to be added to the linker hash
1240 xcoff_link_add_symbols_to_hash_table (struct internal_syment sym
,
1241 union internal_auxent aux
)
1243 /* External symbols must be added. */
1244 if (EXTERN_SYM_P (sym
.n_sclass
))
1247 /* Hidden TLS symbols must be added to verify TLS relocations
1248 in xcoff_reloc_type_tls. */
1249 if (sym
.n_sclass
== C_HIDEXT
1250 && ((aux
.x_csect
.x_smclas
== XMC_TL
1251 || aux
.x_csect
.x_smclas
== XMC_UL
)))
1257 /* Add all the symbols from an object file to the hash table.
1259 XCOFF is a weird format. A normal XCOFF .o files will have three
1260 COFF sections--.text, .data, and .bss--but each COFF section will
1261 contain many csects. These csects are described in the symbol
1262 table. From the linker's point of view, each csect must be
1263 considered a section in its own right. For example, a TOC entry is
1264 handled as a small XMC_TC csect. The linker must be able to merge
1265 different TOC entries together, which means that it must be able to
1266 extract the XMC_TC csects from the .data section of the input .o
1269 From the point of view of our linker, this is, of course, a hideous
1270 nightmare. We cope by actually creating sections for each csect,
1271 and discarding the original sections. We then have to handle the
1272 relocation entries carefully, since the only way to tell which
1273 csect they belong to is to examine the address. */
1276 xcoff_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
1278 unsigned int n_tmask
;
1279 unsigned int n_btshft
;
1281 bfd_size_type symcount
;
1282 struct xcoff_link_hash_entry
**sym_hash
;
1283 asection
**csect_cache
;
1284 unsigned int *lineno_counts
;
1285 bfd_size_type linesz
;
1287 asection
*last_real
;
1290 unsigned int csect_index
;
1291 asection
*first_csect
;
1292 bfd_size_type symesz
;
1295 struct reloc_info_struct
1297 struct internal_reloc
*relocs
;
1300 } *reloc_info
= NULL
;
1302 unsigned short visibility
;
1304 keep_syms
= obj_coff_keep_syms (abfd
);
1306 if ((abfd
->flags
& DYNAMIC
) != 0
1307 && ! info
->static_link
)
1309 if (! xcoff_link_add_dynamic_symbols (abfd
, info
))
1313 /* Create the loader, toc, gl, ds and debug sections, if needed. */
1314 if (! xcoff_link_create_extra_sections (abfd
, info
))
1317 if ((abfd
->flags
& DYNAMIC
) != 0
1318 && ! info
->static_link
)
1321 n_tmask
= coff_data (abfd
)->local_n_tmask
;
1322 n_btshft
= coff_data (abfd
)->local_n_btshft
;
1324 /* Define macros so that ISFCN, et. al., macros work correctly. */
1325 #define N_TMASK n_tmask
1326 #define N_BTSHFT n_btshft
1328 if (info
->keep_memory
)
1329 default_copy
= false;
1331 default_copy
= true;
1333 symcount
= obj_raw_syment_count (abfd
);
1335 /* We keep a list of the linker hash table entries that correspond
1336 to each external symbol. */
1337 amt
= symcount
* sizeof (struct xcoff_link_hash_entry
*);
1338 sym_hash
= bfd_zalloc (abfd
, amt
);
1339 if (sym_hash
== NULL
&& symcount
!= 0)
1341 coff_data (abfd
)->sym_hashes
= (struct coff_link_hash_entry
**) sym_hash
;
1343 /* Because of the weird stuff we are doing with XCOFF csects, we can
1344 not easily determine which section a symbol is in, so we store
1345 the information in the tdata for the input file. */
1346 amt
= symcount
* sizeof (asection
*);
1347 csect_cache
= bfd_zalloc (abfd
, amt
);
1348 if (csect_cache
== NULL
&& symcount
!= 0)
1350 xcoff_data (abfd
)->csects
= csect_cache
;
1352 /* We garbage-collect line-number information on a symbol-by-symbol
1353 basis, so we need to have quick access to the number of entries
1355 amt
= symcount
* sizeof (unsigned int);
1356 lineno_counts
= bfd_zalloc (abfd
, amt
);
1357 if (lineno_counts
== NULL
&& symcount
!= 0)
1359 xcoff_data (abfd
)->lineno_counts
= lineno_counts
;
1361 /* While splitting sections into csects, we need to assign the
1362 relocs correctly. The relocs and the csects must both be in
1363 order by VMA within a given section, so we handle this by
1364 scanning along the relocs as we process the csects. We index
1365 into reloc_info using the section target_index. */
1366 amt
= abfd
->section_count
+ 1;
1367 amt
*= sizeof (struct reloc_info_struct
);
1368 reloc_info
= bfd_zmalloc (amt
);
1369 if (reloc_info
== NULL
)
1372 /* Read in the relocs and line numbers for each section. */
1373 linesz
= bfd_coff_linesz (abfd
);
1375 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1379 if ((o
->flags
& SEC_RELOC
) != 0)
1381 reloc_info
[o
->target_index
].relocs
=
1382 xcoff_read_internal_relocs (abfd
, o
, true, NULL
, false, NULL
);
1383 amt
= o
->reloc_count
;
1384 amt
*= sizeof (asection
*);
1385 reloc_info
[o
->target_index
].csects
= bfd_zmalloc (amt
);
1386 if (reloc_info
[o
->target_index
].csects
== NULL
)
1390 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1391 && o
->lineno_count
> 0)
1395 if (bfd_seek (abfd
, o
->line_filepos
, SEEK_SET
) != 0)
1397 if (_bfd_mul_overflow (linesz
, o
->lineno_count
, &amt
))
1399 bfd_set_error (bfd_error_file_too_big
);
1402 linenos
= _bfd_malloc_and_read (abfd
, amt
, amt
);
1403 if (linenos
== NULL
)
1405 reloc_info
[o
->target_index
].linenos
= linenos
;
1409 /* Don't let the linker relocation routines discard the symbols. */
1410 obj_coff_keep_syms (abfd
) = true;
1416 symesz
= bfd_coff_symesz (abfd
);
1417 BFD_ASSERT (symesz
== bfd_coff_auxesz (abfd
));
1418 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
1419 esym_end
= esym
+ symcount
* symesz
;
1421 while (esym
< esym_end
)
1423 struct internal_syment sym
;
1424 union internal_auxent aux
;
1426 char buf
[SYMNMLEN
+ 1];
1430 struct xcoff_link_hash_entry
*set_toc
;
1432 bfd_coff_swap_sym_in (abfd
, (void *) esym
, (void *) &sym
);
1434 /* In this pass we are only interested in symbols with csect
1436 if (!CSECT_SYM_P (sym
.n_sclass
))
1439 Normally csect is a .pr, .rw etc. created in the loop
1440 If C_FILE or first time, handle special
1442 Advance esym, sym_hash, csect_hash ptrs. */
1443 if (sym
.n_sclass
== C_FILE
|| sym
.n_sclass
== C_DWARF
)
1446 *csect_cache
= csect
;
1447 else if (first_csect
== NULL
1448 || sym
.n_sclass
== C_FILE
|| sym
.n_sclass
== C_DWARF
)
1449 *csect_cache
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1451 *csect_cache
= NULL
;
1452 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1453 sym_hash
+= sym
.n_numaux
+ 1;
1454 csect_cache
+= sym
.n_numaux
+ 1;
1455 lineno_counts
+= sym
.n_numaux
+ 1;
1460 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
1465 /* If this symbol has line number information attached to it,
1466 and we're not stripping it, count the number of entries and
1467 add them to the count for this csect. In the final link pass
1468 we are going to attach line number information by symbol,
1469 rather than by section, in order to more easily handle
1470 garbage collection. */
1471 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1474 && ISFCN (sym
.n_type
))
1476 union internal_auxent auxlin
;
1478 bfd_coff_swap_aux_in (abfd
, (void *) (esym
+ symesz
),
1479 sym
.n_type
, sym
.n_sclass
,
1480 0, sym
.n_numaux
, (void *) &auxlin
);
1482 if (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
1484 asection
*enclosing
;
1485 bfd_signed_vma linoff
;
1487 enclosing
= xcoff_section_data (abfd
, csect
)->enclosing
;
1488 if (enclosing
== NULL
)
1491 /* xgettext:c-format */
1492 (_("%pB: `%s' has line numbers but no enclosing section"),
1494 bfd_set_error (bfd_error_bad_value
);
1497 linoff
= (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
1498 - enclosing
->line_filepos
);
1499 /* Explicit cast to bfd_signed_vma for compiler. */
1500 if (linoff
< (bfd_signed_vma
) (enclosing
->lineno_count
* linesz
))
1502 struct internal_lineno lin
;
1503 bfd_byte
*linpstart
;
1505 linpstart
= (reloc_info
[enclosing
->target_index
].linenos
1507 bfd_coff_swap_lineno_in (abfd
, (void *) linpstart
, (void *) &lin
);
1509 && ((bfd_size_type
) lin
.l_addr
.l_symndx
1511 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1514 bfd_byte
*linpend
, *linp
;
1516 linpend
= (reloc_info
[enclosing
->target_index
].linenos
1517 + enclosing
->lineno_count
* linesz
);
1518 for (linp
= linpstart
+ linesz
;
1522 bfd_coff_swap_lineno_in (abfd
, (void *) linp
,
1524 if (lin
.l_lnno
== 0)
1527 *lineno_counts
= (linp
- linpstart
) / linesz
;
1528 /* The setting of line_filepos will only be
1529 useful if all the line number entries for a
1530 csect are contiguous; this only matters for
1532 if (csect
->line_filepos
== 0)
1533 csect
->line_filepos
=
1534 auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1540 /* Record visibility. */
1541 visibility
= sym
.n_type
& SYM_V_MASK
;
1543 /* Pick up the csect auxiliary information. */
1544 if (sym
.n_numaux
== 0)
1547 /* xgettext:c-format */
1548 (_("%pB: class %d symbol `%s' has no aux entries"),
1549 abfd
, sym
.n_sclass
, name
);
1550 bfd_set_error (bfd_error_bad_value
);
1554 bfd_coff_swap_aux_in (abfd
,
1555 (void *) (esym
+ symesz
* sym
.n_numaux
),
1556 sym
.n_type
, sym
.n_sclass
,
1557 sym
.n_numaux
- 1, sym
.n_numaux
,
1560 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
1570 /* xgettext:c-format */
1571 (_("%pB: symbol `%s' has unrecognized csect type %d"),
1573 bfd_set_error (bfd_error_bad_value
);
1577 /* This is an external reference. */
1578 if (sym
.n_sclass
== C_HIDEXT
1579 || sym
.n_scnum
!= N_UNDEF
1580 || aux
.x_csect
.x_scnlen
.l
!= 0)
1583 /* xgettext:c-format */
1584 (_("%pB: bad XTY_ER symbol `%s': class %d scnum %d "
1586 abfd
, name
, sym
.n_sclass
, sym
.n_scnum
,
1587 (int64_t) aux
.x_csect
.x_scnlen
.l
);
1588 bfd_set_error (bfd_error_bad_value
);
1592 /* An XMC_XO external reference is actually a reference to
1593 an absolute location. */
1594 if (aux
.x_csect
.x_smclas
!= XMC_XO
)
1595 section
= bfd_und_section_ptr
;
1598 section
= bfd_abs_section_ptr
;
1599 value
= sym
.n_value
;
1605 csect_index
= -(unsigned) 1;
1607 /* When we see a TOC anchor, we record the TOC value. */
1608 if (aux
.x_csect
.x_smclas
== XMC_TC0
)
1610 if (sym
.n_sclass
!= C_HIDEXT
1611 || aux
.x_csect
.x_scnlen
.l
!= 0)
1614 /* xgettext:c-format */
1615 (_("%pB: XMC_TC0 symbol `%s' is class %d scnlen %" PRId64
),
1616 abfd
, name
, sym
.n_sclass
, (int64_t) aux
.x_csect
.x_scnlen
.l
);
1617 bfd_set_error (bfd_error_bad_value
);
1620 xcoff_data (abfd
)->toc
= sym
.n_value
;
1623 /* We must merge TOC entries for the same symbol. We can
1624 merge two TOC entries if they are both C_HIDEXT, they
1625 both have the same name, they are both 4 or 8 bytes long, and
1626 they both have a relocation table entry for an external
1627 symbol with the same name. Unfortunately, this means
1628 that we must look through the relocations. Ick.
1630 Logic for 32 bit vs 64 bit.
1631 32 bit has a csect length of 4 for TOC
1632 64 bit has a csect length of 8 for TOC
1634 An exception is made for TOC entries with a R_TLSML
1635 relocation. This relocation is made for the loader.
1636 We must check that the referenced symbol is the TOC entry
1639 The conditions to get past the if-check are not that bad.
1640 They are what is used to create the TOC csects in the first
1642 if (aux
.x_csect
.x_smclas
== XMC_TC
1643 && sym
.n_sclass
== C_HIDEXT
1644 && info
->output_bfd
->xvec
== abfd
->xvec
1645 && ((bfd_xcoff_is_xcoff32 (abfd
)
1646 && aux
.x_csect
.x_scnlen
.l
== 4)
1647 || (bfd_xcoff_is_xcoff64 (abfd
)
1648 && aux
.x_csect
.x_scnlen
.l
== 8)))
1650 asection
*enclosing
;
1651 struct internal_reloc
*relocs
;
1652 bfd_size_type relindx
;
1653 struct internal_reloc
*rel
;
1655 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1656 if (enclosing
== NULL
)
1659 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1660 amt
= enclosing
->reloc_count
;
1661 relindx
= xcoff_find_reloc (relocs
, amt
, sym
.n_value
);
1662 rel
= relocs
+ relindx
;
1664 /* 32 bit R_POS r_size is 31
1665 64 bit R_POS r_size is 63 */
1666 if (relindx
< enclosing
->reloc_count
1667 && rel
->r_vaddr
== (bfd_vma
) sym
.n_value
1668 && (rel
->r_type
== R_POS
||
1669 rel
->r_type
== R_TLSML
)
1670 && ((bfd_xcoff_is_xcoff32 (abfd
)
1671 && rel
->r_size
== 31)
1672 || (bfd_xcoff_is_xcoff64 (abfd
)
1673 && rel
->r_size
== 63)))
1677 struct internal_syment relsym
;
1679 erelsym
= ((bfd_byte
*) obj_coff_external_syms (abfd
)
1680 + rel
->r_symndx
* symesz
);
1681 bfd_coff_swap_sym_in (abfd
, (void *) erelsym
, (void *) &relsym
);
1682 if (EXTERN_SYM_P (relsym
.n_sclass
))
1684 const char *relname
;
1685 char relbuf
[SYMNMLEN
+ 1];
1687 struct xcoff_link_hash_entry
*h
;
1689 /* At this point we know that the TOC entry is
1690 for an externally visible symbol. */
1691 relname
= _bfd_coff_internal_syment_name (abfd
, &relsym
,
1693 if (relname
== NULL
)
1696 /* We only merge TOC entries if the TC name is
1697 the same as the symbol name. This handles
1698 the normal case, but not common cases like
1699 SYM.P4 which gcc generates to store SYM + 4
1700 in the TOC. FIXME. */
1701 if (strcmp (name
, relname
) == 0)
1703 copy
= (! info
->keep_memory
1704 || relsym
._n
._n_n
._n_zeroes
!= 0
1705 || relsym
._n
._n_n
._n_offset
== 0);
1706 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1707 relname
, true, copy
,
1712 /* At this point h->root.type could be
1713 bfd_link_hash_new. That should be OK,
1714 since we know for sure that we will come
1715 across this symbol as we step through the
1718 /* We store h in *sym_hash for the
1719 convenience of the relocate_section
1723 if (h
->toc_section
!= NULL
)
1725 asection
**rel_csects
;
1727 /* We already have a TOC entry for this
1728 symbol, so we can just ignore this
1731 reloc_info
[enclosing
->target_index
].csects
;
1732 rel_csects
[relindx
] = bfd_und_section_ptr
;
1736 /* We are about to create a TOC entry for
1741 else if (rel
->r_type
== R_TLSML
)
1743 csect_index
= ((esym
1744 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1746 if (((unsigned long) rel
->r_symndx
) != csect_index
)
1749 /* xgettext:c-format */
1750 (_("%pB: TOC entry `%s' has a R_TLSML"
1751 "relocation not targeting itself"),
1753 bfd_set_error (bfd_error_bad_value
);
1761 asection
*enclosing
;
1763 /* We need to create a new section. We get the name from
1764 the csect storage mapping class, so that the linker can
1765 accumulate similar csects together. */
1767 csect
= bfd_xcoff_create_csect_from_smclas(abfd
, &aux
, name
);
1771 /* The enclosing section is the main section : .data, .text
1772 or .bss that the csect is coming from. */
1773 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1774 if (enclosing
== NULL
)
1777 if (! bfd_is_abs_section (enclosing
)
1778 && ((bfd_vma
) sym
.n_value
< enclosing
->vma
1779 || ((bfd_vma
) sym
.n_value
+ aux
.x_csect
.x_scnlen
.l
1780 > enclosing
->vma
+ enclosing
->size
)))
1783 /* xgettext:c-format */
1784 (_("%pB: csect `%s' not in enclosing section"),
1786 bfd_set_error (bfd_error_bad_value
);
1789 csect
->vma
= sym
.n_value
;
1790 csect
->filepos
= (enclosing
->filepos
1793 csect
->size
= aux
.x_csect
.x_scnlen
.l
;
1794 csect
->rawsize
= aux
.x_csect
.x_scnlen
.l
;
1795 csect
->flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
;
1796 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1798 /* Record the enclosing section in the tdata for this new
1800 amt
= sizeof (struct coff_section_tdata
);
1801 csect
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1802 if (csect
->used_by_bfd
== NULL
)
1804 amt
= sizeof (struct xcoff_section_tdata
);
1805 coff_section_data (abfd
, csect
)->tdata
= bfd_zalloc (abfd
, amt
);
1806 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1808 xcoff_section_data (abfd
, csect
)->enclosing
= enclosing
;
1809 xcoff_section_data (abfd
, csect
)->lineno_count
=
1810 enclosing
->lineno_count
;
1812 if (enclosing
->owner
== abfd
)
1814 struct internal_reloc
*relocs
;
1815 bfd_size_type relindx
;
1816 struct internal_reloc
*rel
;
1817 asection
**rel_csect
;
1819 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1820 amt
= enclosing
->reloc_count
;
1821 relindx
= xcoff_find_reloc (relocs
, amt
, csect
->vma
);
1823 rel
= relocs
+ relindx
;
1824 rel_csect
= (reloc_info
[enclosing
->target_index
].csects
1827 csect
->rel_filepos
= (enclosing
->rel_filepos
1828 + relindx
* bfd_coff_relsz (abfd
));
1829 while (relindx
< enclosing
->reloc_count
1830 && *rel_csect
== NULL
1831 && rel
->r_vaddr
< csect
->vma
+ csect
->size
)
1835 csect
->flags
|= SEC_RELOC
;
1836 ++csect
->reloc_count
;
1843 /* There are a number of other fields and section flags
1844 which we do not bother to set. */
1846 csect_index
= ((esym
1847 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1850 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1852 if (first_csect
== NULL
)
1853 first_csect
= csect
;
1855 /* If this symbol must be added to the linker hash table,
1856 we treat it as starting at the beginning of the newly
1858 if (xcoff_link_add_symbols_to_hash_table (sym
, aux
))
1864 /* If this is a TOC section for a symbol, record it. */
1865 if (set_toc
!= NULL
)
1866 set_toc
->toc_section
= csect
;
1871 /* This is a label definition. The x_scnlen field is the
1872 symbol index of the csect. Usually the XTY_LD symbol will
1873 follow its appropriate XTY_SD symbol. The .set pseudo op can
1874 cause the XTY_LD to not follow the XTY_SD symbol. */
1879 if (aux
.x_csect
.x_scnlen
.l
< 0
1880 || (aux
.x_csect
.x_scnlen
.l
1881 >= esym
- (bfd_byte
*) obj_coff_external_syms (abfd
)))
1885 section
= xcoff_data (abfd
)->csects
[aux
.x_csect
.x_scnlen
.l
];
1887 || (section
->flags
& SEC_HAS_CONTENTS
) == 0)
1893 /* xgettext:c-format */
1894 (_("%pB: misplaced XTY_LD `%s'"),
1896 bfd_set_error (bfd_error_bad_value
);
1900 value
= sym
.n_value
- csect
->vma
;
1905 /* This is an unitialized csect. We could base the name on
1906 the storage mapping class, but we don't bother except for
1907 an XMC_TD symbol. If this csect is externally visible,
1908 it is a common symbol. We put XMC_TD symbols in sections
1909 named .tocbss, and rely on the linker script to put that
1912 if (aux
.x_csect
.x_smclas
== XMC_TD
)
1914 /* The linker script puts the .td section in the data
1915 section after the .tc section. */
1916 csect
= bfd_make_section_anyway_with_flags (abfd
, ".td",
1919 else if (aux
.x_csect
.x_smclas
== XMC_UL
)
1921 /* This is a thread-local unitialized csect. */
1922 csect
= bfd_make_section_anyway_with_flags (abfd
, ".tbss",
1923 SEC_ALLOC
| SEC_THREAD_LOCAL
);
1926 csect
= bfd_make_section_anyway_with_flags (abfd
, ".bss",
1931 csect
->vma
= sym
.n_value
;
1932 csect
->size
= aux
.x_csect
.x_scnlen
.l
;
1933 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1934 /* There are a number of other fields and section flags
1935 which we do not bother to set. */
1937 csect_index
= ((esym
1938 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1941 amt
= sizeof (struct coff_section_tdata
);
1942 csect
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1943 if (csect
->used_by_bfd
== NULL
)
1945 amt
= sizeof (struct xcoff_section_tdata
);
1946 coff_section_data (abfd
, csect
)->tdata
= bfd_zalloc (abfd
, amt
);
1947 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1949 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1951 if (first_csect
== NULL
)
1952 first_csect
= csect
;
1954 if (xcoff_link_add_symbols_to_hash_table (sym
, aux
))
1956 csect
->flags
|= SEC_IS_COMMON
;
1959 value
= aux
.x_csect
.x_scnlen
.l
;
1965 /* Check for magic symbol names. */
1966 if ((smtyp
== XTY_SD
|| smtyp
== XTY_CM
)
1967 && aux
.x_csect
.x_smclas
!= XMC_TC
1968 && aux
.x_csect
.x_smclas
!= XMC_TD
)
1974 if (strcmp (name
, "_text") == 0)
1975 i
= XCOFF_SPECIAL_SECTION_TEXT
;
1976 else if (strcmp (name
, "_etext") == 0)
1977 i
= XCOFF_SPECIAL_SECTION_ETEXT
;
1978 else if (strcmp (name
, "_data") == 0)
1979 i
= XCOFF_SPECIAL_SECTION_DATA
;
1980 else if (strcmp (name
, "_edata") == 0)
1981 i
= XCOFF_SPECIAL_SECTION_EDATA
;
1982 else if (strcmp (name
, "_end") == 0)
1983 i
= XCOFF_SPECIAL_SECTION_END
;
1985 else if (name
[0] == 'e' && strcmp (name
, "end") == 0)
1986 i
= XCOFF_SPECIAL_SECTION_END2
;
1989 xcoff_hash_table (info
)->special_sections
[i
] = csect
;
1992 /* Now we have enough information to add the symbol to the
1993 linker hash table. */
1995 if (xcoff_link_add_symbols_to_hash_table (sym
, aux
))
2000 BFD_ASSERT (section
!= NULL
);
2002 /* We must copy the name into memory if we got it from the
2003 syment itself, rather than the string table. */
2004 copy
= default_copy
;
2005 if (sym
._n
._n_n
._n_zeroes
!= 0
2006 || sym
._n
._n_n
._n_offset
== 0)
2009 /* Ignore global linkage code when linking statically. */
2010 if (info
->static_link
2011 && (smtyp
== XTY_SD
|| smtyp
== XTY_LD
)
2012 && aux
.x_csect
.x_smclas
== XMC_GL
)
2014 section
= bfd_und_section_ptr
;
2018 /* The AIX linker appears to only detect multiple symbol
2019 definitions when there is a reference to the symbol. If
2020 a symbol is defined multiple times, and the only
2021 references are from the same object file, the AIX linker
2022 appears to permit it. It does not merge the different
2023 definitions, but handles them independently. On the
2024 other hand, if there is a reference, the linker reports
2027 This matters because the AIX <net/net_globals.h> header
2028 file actually defines an initialized array, so we have to
2029 actually permit that to work.
2031 Just to make matters even more confusing, the AIX linker
2032 appears to permit multiple symbol definitions whenever
2033 the second definition is in an archive rather than an
2034 object file. This may be a consequence of the manner in
2035 which it handles archives: I think it may load the entire
2036 archive in as separate csects, and then let garbage
2037 collection discard symbols.
2039 We also have to handle the case of statically linking a
2040 shared object, which will cause symbol redefinitions,
2041 although this is an easier case to detect. */
2042 else if (info
->output_bfd
->xvec
== abfd
->xvec
)
2044 if (! bfd_is_und_section (section
))
2045 *sym_hash
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2046 name
, true, copy
, false);
2048 /* Make a copy of the symbol name to prevent problems with
2050 *sym_hash
= ((struct xcoff_link_hash_entry
*)
2051 bfd_wrapped_link_hash_lookup (abfd
, info
, name
,
2052 true, true, false));
2054 if (*sym_hash
== NULL
)
2056 if (((*sym_hash
)->root
.type
== bfd_link_hash_defined
2057 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
2058 && ! bfd_is_und_section (section
)
2059 && ! bfd_is_com_section (section
))
2061 /* This is a second definition of a defined symbol. */
2062 if (((*sym_hash
)->flags
& XCOFF_DEF_REGULAR
) == 0
2063 && ((*sym_hash
)->flags
& XCOFF_DEF_DYNAMIC
) != 0)
2065 /* The existing symbol is from a shared library.
2067 (*sym_hash
)->root
.type
= bfd_link_hash_undefined
;
2068 (*sym_hash
)->root
.u
.undef
.abfd
=
2069 (*sym_hash
)->root
.u
.def
.section
->owner
;
2071 else if (abfd
->my_archive
!= NULL
)
2073 /* This is a redefinition in an object contained
2074 in an archive. Just ignore it. See the
2076 section
= bfd_und_section_ptr
;
2079 else if (sym
.n_sclass
== C_AIX_WEAKEXT
2080 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
2082 /* At least one of the definitions is weak.
2083 Allow the normal rules to take effect. */
2085 else if ((*sym_hash
)->root
.u
.undef
.next
!= NULL
2086 || info
->hash
->undefs_tail
== &(*sym_hash
)->root
)
2088 /* This symbol has been referenced. In this
2089 case, we just continue and permit the
2090 multiple definition error. See the comment
2091 above about the behaviour of the AIX linker. */
2093 else if ((*sym_hash
)->smclas
== aux
.x_csect
.x_smclas
)
2095 /* The symbols are both csects of the same
2096 class. There is at least a chance that this
2097 is a semi-legitimate redefinition. */
2098 section
= bfd_und_section_ptr
;
2100 (*sym_hash
)->flags
|= XCOFF_MULTIPLY_DEFINED
;
2103 else if (((*sym_hash
)->flags
& XCOFF_MULTIPLY_DEFINED
) != 0
2104 && (*sym_hash
)->root
.type
== bfd_link_hash_defined
2105 && (bfd_is_und_section (section
)
2106 || bfd_is_com_section (section
)))
2108 /* This is a reference to a multiply defined symbol.
2109 Report the error now. See the comment above
2110 about the behaviour of the AIX linker. We could
2111 also do this with warning symbols, but I'm not
2112 sure the XCOFF linker is wholly prepared to
2113 handle them, and that would only be a warning,
2115 (*info
->callbacks
->multiple_definition
) (info
,
2119 /* Try not to give this error too many times. */
2120 (*sym_hash
)->flags
&= ~XCOFF_MULTIPLY_DEFINED
;
2124 /* If the symbol is hidden or internal, completely undo
2125 any dynamic link state. */
2126 if ((*sym_hash
)->flags
& XCOFF_DEF_DYNAMIC
2127 && (visibility
== SYM_V_HIDDEN
2128 || visibility
== SYM_V_INTERNAL
))
2129 (*sym_hash
)->flags
&= ~XCOFF_DEF_DYNAMIC
;
2132 /* Keep the most constraining visibility. */
2133 unsigned short hvis
= (*sym_hash
)->visibility
;
2134 if (visibility
&& ( !hvis
|| visibility
< hvis
))
2135 (*sym_hash
)->visibility
= visibility
;
2140 /* _bfd_generic_link_add_one_symbol may call the linker to
2141 generate an error message, and the linker may try to read
2142 the symbol table to give a good error. Right now, the
2143 line numbers are in an inconsistent state, since they are
2144 counted both in the real sections and in the new csects.
2145 We need to leave the count in the real sections so that
2146 the linker can report the line number of the error
2147 correctly, so temporarily clobber the link to the csects
2148 so that the linker will not try to read the line numbers
2149 a second time from the csects. */
2150 BFD_ASSERT (last_real
->next
== first_csect
);
2151 last_real
->next
= NULL
;
2152 flags
= (sym
.n_sclass
== C_EXT
? BSF_GLOBAL
: BSF_WEAK
);
2153 ok
= (_bfd_generic_link_add_one_symbol
2154 (info
, abfd
, name
, flags
, section
, value
, NULL
, copy
, true,
2155 (struct bfd_link_hash_entry
**) sym_hash
));
2156 last_real
->next
= first_csect
;
2160 if (smtyp
== XTY_CM
)
2162 if ((*sym_hash
)->root
.type
!= bfd_link_hash_common
2163 || (*sym_hash
)->root
.u
.c
.p
->section
!= csect
)
2164 /* We don't need the common csect we just created. */
2167 (*sym_hash
)->root
.u
.c
.p
->alignment_power
2168 = csect
->alignment_power
;
2171 if (info
->output_bfd
->xvec
== abfd
->xvec
)
2177 || section
== bfd_und_section_ptr
)
2178 flag
= XCOFF_REF_REGULAR
;
2180 flag
= XCOFF_DEF_REGULAR
;
2181 (*sym_hash
)->flags
|= flag
;
2183 if ((*sym_hash
)->smclas
== XMC_UA
2184 || flag
== XCOFF_DEF_REGULAR
)
2185 (*sym_hash
)->smclas
= aux
.x_csect
.x_smclas
;
2189 if (smtyp
== XTY_ER
)
2190 *csect_cache
= section
;
2193 *csect_cache
= csect
;
2195 xcoff_section_data (abfd
, csect
)->last_symndx
2196 = (esym
- (bfd_byte
*) obj_coff_external_syms (abfd
)) / symesz
;
2199 esym
+= (sym
.n_numaux
+ 1) * symesz
;
2200 sym_hash
+= sym
.n_numaux
+ 1;
2201 csect_cache
+= sym
.n_numaux
+ 1;
2202 lineno_counts
+= sym
.n_numaux
+ 1;
2205 BFD_ASSERT (last_real
== NULL
|| last_real
->next
== first_csect
);
2207 /* Make sure that we have seen all the relocs. */
2208 for (o
= abfd
->sections
; o
!= first_csect
; o
= o
->next
)
2210 /* Debugging sections have no csects. */
2211 if (bfd_section_flags (o
) & SEC_DEBUGGING
)
2214 /* Reset the section size and the line number count, since the
2215 data is now attached to the csects. Don't reset the size of
2216 the .debug section, since we need to read it below in
2217 bfd_xcoff_size_dynamic_sections. */
2218 if (strcmp (bfd_section_name (o
), ".debug") != 0)
2220 o
->lineno_count
= 0;
2222 if ((o
->flags
& SEC_RELOC
) != 0)
2225 struct internal_reloc
*rel
;
2226 asection
**rel_csect
;
2228 rel
= reloc_info
[o
->target_index
].relocs
;
2229 rel_csect
= reloc_info
[o
->target_index
].csects
;
2231 for (i
= 0; i
< o
->reloc_count
; i
++, rel
++, rel_csect
++)
2233 if (*rel_csect
== NULL
)
2236 /* xgettext:c-format */
2237 (_("%pB: reloc %s:%" PRId64
" not in csect"),
2238 abfd
, o
->name
, (int64_t) i
);
2239 bfd_set_error (bfd_error_bad_value
);
2243 /* We identify all function symbols that are the target
2244 of a relocation, so that we can create glue code for
2245 functions imported from dynamic objects. */
2246 if (info
->output_bfd
->xvec
== abfd
->xvec
2247 && *rel_csect
!= bfd_und_section_ptr
2248 && obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
] != NULL
)
2250 struct xcoff_link_hash_entry
*h
;
2252 h
= obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
];
2253 /* If the symbol name starts with a period, it is
2254 the code of a function. If the symbol is
2255 currently undefined, then add an undefined symbol
2256 for the function descriptor. This should do no
2257 harm, because any regular object that defines the
2258 function should also define the function
2259 descriptor. It helps, because it means that we
2260 will identify the function descriptor with a
2261 dynamic object if a dynamic object defines it. */
2262 if (h
->root
.root
.string
[0] == '.'
2263 && h
->descriptor
== NULL
)
2265 struct xcoff_link_hash_entry
*hds
;
2266 struct bfd_link_hash_entry
*bh
;
2268 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2269 h
->root
.root
.string
+ 1,
2273 if (hds
->root
.type
== bfd_link_hash_new
)
2276 if (! (_bfd_generic_link_add_one_symbol
2277 (info
, abfd
, hds
->root
.root
.string
,
2278 (flagword
) 0, bfd_und_section_ptr
,
2279 (bfd_vma
) 0, NULL
, false,
2282 hds
= (struct xcoff_link_hash_entry
*) bh
;
2284 hds
->flags
|= XCOFF_DESCRIPTOR
;
2285 BFD_ASSERT ((h
->flags
& XCOFF_DESCRIPTOR
) == 0);
2286 hds
->descriptor
= h
;
2287 h
->descriptor
= hds
;
2289 if (h
->root
.root
.string
[0] == '.')
2290 h
->flags
|= XCOFF_CALLED
;
2294 free (reloc_info
[o
->target_index
].csects
);
2295 reloc_info
[o
->target_index
].csects
= NULL
;
2297 /* Reset SEC_RELOC and the reloc_count, since the reloc
2298 information is now attached to the csects. */
2299 o
->flags
&=~ SEC_RELOC
;
2302 /* If we are not keeping memory, free the reloc information. */
2303 if (! info
->keep_memory
2304 && coff_section_data (abfd
, o
) != NULL
)
2306 free (coff_section_data (abfd
, o
)->relocs
);
2307 coff_section_data (abfd
, o
)->relocs
= NULL
;
2311 /* Free up the line numbers. FIXME: We could cache these
2312 somewhere for the final link, to avoid reading them again. */
2313 free (reloc_info
[o
->target_index
].linenos
);
2314 reloc_info
[o
->target_index
].linenos
= NULL
;
2319 obj_coff_keep_syms (abfd
) = keep_syms
;
2324 if (reloc_info
!= NULL
)
2326 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2328 free (reloc_info
[o
->target_index
].csects
);
2329 free (reloc_info
[o
->target_index
].linenos
);
2333 obj_coff_keep_syms (abfd
) = keep_syms
;
2340 /* Add symbols from an XCOFF object file. */
2343 xcoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2345 if (! _bfd_coff_get_external_symbols (abfd
))
2347 if (! xcoff_link_add_symbols (abfd
, info
))
2349 if (! info
->keep_memory
)
2351 if (! _bfd_coff_free_symbols (abfd
))
2357 /* Look through the loader symbols to see if this dynamic object
2358 should be included in the link. The native linker uses the loader
2359 symbols, not the normal symbol table, so we do too. */
2362 xcoff_link_check_dynamic_ar_symbols (bfd
*abfd
,
2363 struct bfd_link_info
*info
,
2369 struct internal_ldhdr ldhdr
;
2370 const char *strings
;
2371 bfd_byte
*elsym
, *elsymend
;
2375 lsec
= bfd_get_section_by_name (abfd
, ".loader");
2376 if (lsec
== NULL
|| (lsec
->flags
& SEC_HAS_CONTENTS
) == 0)
2377 /* There are no symbols, so don't try to include it. */
2380 contents
= xcoff_get_section_contents (abfd
, lsec
);
2384 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
2386 strings
= (char *) contents
+ ldhdr
.l_stoff
;
2388 elsym
= contents
+ bfd_xcoff_loader_symbol_offset (abfd
, &ldhdr
);
2390 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz (abfd
);
2391 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz (abfd
))
2393 struct internal_ldsym ldsym
;
2394 char nambuf
[SYMNMLEN
+ 1];
2396 struct bfd_link_hash_entry
*h
;
2398 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
2400 /* We are only interested in exported symbols. */
2401 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
2404 if (ldsym
._l
._l_l
._l_zeroes
== 0)
2405 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
2408 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
2409 nambuf
[SYMNMLEN
] = '\0';
2413 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
2415 /* We are only interested in symbols that are currently
2416 undefined. At this point we know that we are using an XCOFF
2419 && h
->type
== bfd_link_hash_undefined
2420 && (((struct xcoff_link_hash_entry
*) h
)->flags
2421 & XCOFF_DEF_DYNAMIC
) == 0)
2423 if (!(*info
->callbacks
2424 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2431 /* We do not need this shared object's .loader section. */
2433 coff_section_data (abfd
, lsec
)->contents
= NULL
;
2438 /* Look through the symbols to see if this object file should be
2439 included in the link. */
2442 xcoff_link_check_ar_symbols (bfd
*abfd
,
2443 struct bfd_link_info
*info
,
2447 bfd_size_type symesz
;
2453 if ((abfd
->flags
& DYNAMIC
) != 0
2454 && ! info
->static_link
2455 && info
->output_bfd
->xvec
== abfd
->xvec
)
2456 return xcoff_link_check_dynamic_ar_symbols (abfd
, info
, pneeded
, subsbfd
);
2458 symesz
= bfd_coff_symesz (abfd
);
2459 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
2460 esym_end
= esym
+ obj_raw_syment_count (abfd
) * symesz
;
2461 while (esym
< esym_end
)
2463 struct internal_syment sym
;
2465 bfd_coff_swap_sym_in (abfd
, (void *) esym
, (void *) &sym
);
2466 esym
+= (sym
.n_numaux
+ 1) * symesz
;
2468 if (EXTERN_SYM_P (sym
.n_sclass
) && sym
.n_scnum
!= N_UNDEF
)
2471 char buf
[SYMNMLEN
+ 1];
2472 struct bfd_link_hash_entry
*h
;
2474 /* This symbol is externally visible, and is defined by this
2476 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
2480 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
2482 /* We are only interested in symbols that are currently
2483 undefined. If a symbol is currently known to be common,
2484 XCOFF linkers do not bring in an object file which
2485 defines it. We also don't bring in symbols to satisfy
2486 undefined references in shared objects. */
2488 && h
->type
== bfd_link_hash_undefined
2489 && (info
->output_bfd
->xvec
!= abfd
->xvec
2490 || (((struct xcoff_link_hash_entry
*) h
)->flags
2491 & XCOFF_DEF_DYNAMIC
) == 0))
2493 if (!(*info
->callbacks
2494 ->add_archive_element
) (info
, abfd
, name
, subsbfd
))
2502 /* We do not need this object file. */
2506 /* Check a single archive element to see if we need to include it in
2507 the link. *PNEEDED is set according to whether this element is
2508 needed in the link or not. This is called via
2509 _bfd_generic_link_add_archive_symbols. */
2512 xcoff_link_check_archive_element (bfd
*abfd
,
2513 struct bfd_link_info
*info
,
2514 struct bfd_link_hash_entry
*h ATTRIBUTE_UNUSED
,
2515 const char *name ATTRIBUTE_UNUSED
,
2521 keep_syms_p
= (obj_coff_external_syms (abfd
) != NULL
);
2522 if (!_bfd_coff_get_external_symbols (abfd
))
2526 if (!xcoff_link_check_ar_symbols (abfd
, info
, pneeded
, &abfd
))
2531 /* Potentially, the add_archive_element hook may have set a
2532 substitute BFD for us. */
2536 && !_bfd_coff_free_symbols (oldbfd
))
2538 keep_syms_p
= (obj_coff_external_syms (abfd
) != NULL
);
2539 if (!_bfd_coff_get_external_symbols (abfd
))
2542 if (!xcoff_link_add_symbols (abfd
, info
))
2544 if (info
->keep_memory
)
2550 if (!_bfd_coff_free_symbols (abfd
))
2557 /* Given an XCOFF BFD, add symbols to the global hash table as
2561 _bfd_xcoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2563 switch (bfd_get_format (abfd
))
2566 return xcoff_link_add_object_symbols (abfd
, info
);
2569 /* If the archive has a map, do the usual search. We then need
2570 to check the archive for dynamic objects, because they may not
2571 appear in the archive map even though they should, perhaps, be
2572 included. If the archive has no map, we just consider each object
2573 file in turn, since that apparently is what the AIX native linker
2575 if (bfd_has_map (abfd
))
2577 if (! (_bfd_generic_link_add_archive_symbols
2578 (abfd
, info
, xcoff_link_check_archive_element
)))
2585 member
= bfd_openr_next_archived_file (abfd
, NULL
);
2586 while (member
!= NULL
)
2588 if (bfd_check_format (member
, bfd_object
)
2589 && (info
->output_bfd
->xvec
== member
->xvec
)
2590 && (! bfd_has_map (abfd
) || (member
->flags
& DYNAMIC
) != 0))
2594 if (! xcoff_link_check_archive_element (member
, info
,
2595 NULL
, NULL
, &needed
))
2598 member
->archive_pass
= -1;
2600 member
= bfd_openr_next_archived_file (abfd
, member
);
2607 bfd_set_error (bfd_error_wrong_format
);
2613 _bfd_xcoff_define_common_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2614 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2615 struct bfd_link_hash_entry
*harg
)
2617 struct xcoff_link_hash_entry
*h
;
2619 if (!bfd_generic_define_common_symbol (output_bfd
, info
, harg
))
2622 h
= (struct xcoff_link_hash_entry
*) harg
;
2623 h
->flags
|= XCOFF_DEF_REGULAR
;
2627 /* If symbol H has not been interpreted as a function descriptor,
2628 see whether it should be. Set up its descriptor information if so. */
2631 xcoff_find_function (struct bfd_link_info
*info
,
2632 struct xcoff_link_hash_entry
*h
)
2634 if ((h
->flags
& XCOFF_DESCRIPTOR
) == 0
2635 && h
->root
.root
.string
[0] != '.')
2638 struct xcoff_link_hash_entry
*hfn
;
2641 amt
= strlen (h
->root
.root
.string
) + 2;
2642 fnname
= bfd_malloc (amt
);
2646 strcpy (fnname
+ 1, h
->root
.root
.string
);
2647 hfn
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2648 fnname
, false, false, true);
2651 && hfn
->smclas
== XMC_PR
2652 && (hfn
->root
.type
== bfd_link_hash_defined
2653 || hfn
->root
.type
== bfd_link_hash_defweak
))
2655 h
->flags
|= XCOFF_DESCRIPTOR
;
2656 h
->descriptor
= hfn
;
2657 hfn
->descriptor
= h
;
2663 /* Return true if the given bfd contains at least one shared object. */
2666 xcoff_archive_contains_shared_object_p (struct bfd_link_info
*info
,
2669 struct xcoff_archive_info
*archive_info
;
2672 archive_info
= xcoff_get_archive_info (info
, archive
);
2673 if (!archive_info
->know_contains_shared_object_p
)
2675 member
= bfd_openr_next_archived_file (archive
, NULL
);
2676 while (member
!= NULL
&& (member
->flags
& DYNAMIC
) == 0)
2677 member
= bfd_openr_next_archived_file (archive
, member
);
2679 archive_info
->contains_shared_object_p
= (member
!= NULL
);
2680 archive_info
->know_contains_shared_object_p
= 1;
2682 return archive_info
->contains_shared_object_p
;
2685 /* Symbol H qualifies for export by -bexpfull. Return true if it also
2686 qualifies for export by -bexpall. */
2689 xcoff_covered_by_expall_p (struct xcoff_link_hash_entry
*h
)
2691 /* Exclude symbols beginning with '_'. */
2692 if (h
->root
.root
.string
[0] == '_')
2695 /* Exclude archive members that would otherwise be unreferenced. */
2696 if ((h
->flags
& XCOFF_MARK
) == 0
2697 && (h
->root
.type
== bfd_link_hash_defined
2698 || h
->root
.type
== bfd_link_hash_defweak
)
2699 && h
->root
.u
.def
.section
->owner
!= NULL
2700 && h
->root
.u
.def
.section
->owner
->my_archive
!= NULL
)
2706 /* Return true if symbol H qualifies for the forms of automatic export
2707 specified by AUTO_EXPORT_FLAGS. */
2710 xcoff_auto_export_p (struct bfd_link_info
*info
,
2711 struct xcoff_link_hash_entry
*h
,
2712 unsigned int auto_export_flags
)
2714 /* Don't automatically export things that were explicitly exported. */
2715 if ((h
->flags
& XCOFF_EXPORT
) != 0)
2718 /* Don't export things that we don't define. */
2719 if ((h
->flags
& XCOFF_DEF_REGULAR
) == 0)
2722 /* Don't export functions; export their descriptors instead. */
2723 if (h
->root
.root
.string
[0] == '.')
2726 /* Don't export hidden or internal symbols. */
2727 if (h
->visibility
== SYM_V_HIDDEN
2728 || h
->visibility
== SYM_V_INTERNAL
)
2731 /* We don't export a symbol which is being defined by an object
2732 included from an archive which contains a shared object. The
2733 rationale is that if an archive contains both an unshared and
2734 a shared object, then there must be some reason that the
2735 unshared object is unshared, and we don't want to start
2736 providing a shared version of it. In particular, this solves
2737 a bug involving the _savefNN set of functions. gcc will call
2738 those functions without providing a slot to restore the TOC,
2739 so it is essential that these functions be linked in directly
2740 and not from a shared object, which means that a shared
2741 object which also happens to link them in must not export
2742 them. This is confusing, but I haven't been able to think of
2743 a different approach. Note that the symbols can, of course,
2744 be exported explicitly. */
2745 if (h
->root
.type
== bfd_link_hash_defined
2746 || h
->root
.type
== bfd_link_hash_defweak
)
2750 owner
= h
->root
.u
.def
.section
->owner
;
2752 && owner
->my_archive
!= NULL
2753 && xcoff_archive_contains_shared_object_p (info
, owner
->my_archive
))
2757 /* Otherwise, all symbols are exported by -bexpfull. */
2758 if ((auto_export_flags
& XCOFF_EXPFULL
) != 0)
2761 /* Despite its name, -bexpall exports most but not all symbols. */
2762 if ((auto_export_flags
& XCOFF_EXPALL
) != 0
2763 && xcoff_covered_by_expall_p (h
))
2769 /* Return true if relocation REL needs to be copied to the .loader section.
2770 If REL is against a global symbol, H is that symbol, otherwise it
2774 xcoff_need_ldrel_p (struct bfd_link_info
*info
, struct internal_reloc
*rel
,
2775 struct xcoff_link_hash_entry
*h
, asection
*ssec
)
2777 if (!xcoff_hash_table (info
)->loader_section
)
2780 switch (rel
->r_type
)
2787 /* We should never need a .loader reloc for a TOC-relative reloc. */
2791 /* In this case, relocations against defined symbols can be resolved
2794 || h
->root
.type
== bfd_link_hash_defined
2795 || h
->root
.type
== bfd_link_hash_defweak
2796 || h
->root
.type
== bfd_link_hash_common
)
2799 /* We will always provide a local definition of function symbols,
2800 even if we don't have one yet. */
2801 if ((h
->flags
& XCOFF_CALLED
) != 0)
2810 /* Absolute relocations against absolute symbols can be
2811 resolved statically. */
2813 && (h
->root
.type
== bfd_link_hash_defined
2814 || h
->root
.type
== bfd_link_hash_defweak
)
2815 && !h
->root
.rel_from_abs
)
2817 asection
*sec
= h
->root
.u
.def
.section
;
2818 if (bfd_is_abs_section (sec
)
2820 && bfd_is_abs_section (sec
->output_section
)))
2824 /* Absolute relocations from read-only sections are forbidden
2825 by AIX loader. However, they can appear in their section's
2828 && (ssec
->output_section
->flags
& SEC_READONLY
) != 0)
2843 /* Mark a symbol as not being garbage, including the section in which
2847 xcoff_mark_symbol (struct bfd_link_info
*info
, struct xcoff_link_hash_entry
*h
)
2849 if ((h
->flags
& XCOFF_MARK
) != 0)
2852 h
->flags
|= XCOFF_MARK
;
2854 /* If we're marking an undefined symbol, try find some way of
2856 if (!bfd_link_relocatable (info
)
2857 && (h
->flags
& XCOFF_IMPORT
) == 0
2858 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
2859 && (h
->root
.type
== bfd_link_hash_undefined
2860 || h
->root
.type
== bfd_link_hash_undefweak
))
2862 /* First check whether this symbol can be interpreted as an
2863 undefined function descriptor for a defined function symbol. */
2864 if (!xcoff_find_function (info
, h
))
2867 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
2868 && (h
->descriptor
->root
.type
== bfd_link_hash_defined
2869 || h
->descriptor
->root
.type
== bfd_link_hash_defweak
))
2871 /* This is a descriptor for a defined symbol, but the input
2872 objects have not defined the descriptor itself. Fill in
2873 the definition automatically.
2875 Note that we do this even if we found a dynamic definition
2876 of H. The local function definition logically overrides
2880 sec
= xcoff_hash_table (info
)->descriptor_section
;
2881 h
->root
.type
= bfd_link_hash_defined
;
2882 h
->root
.u
.def
.section
= sec
;
2883 h
->root
.u
.def
.value
= sec
->size
;
2885 h
->flags
|= XCOFF_DEF_REGULAR
;
2887 /* The size of the function descriptor depends on whether this
2888 is xcoff32 (12) or xcoff64 (24). */
2889 sec
->size
+= bfd_xcoff_function_descriptor_size (sec
->owner
);
2891 /* A function descriptor uses two relocs: one for the
2892 associated code, and one for the TOC address. */
2893 xcoff_hash_table (info
)->ldinfo
.ldrel_count
+= 2;
2894 sec
->reloc_count
+= 2;
2896 /* Mark the function itself. */
2897 if (!xcoff_mark_symbol (info
, h
->descriptor
))
2900 /* Mark the TOC section, so that we get an anchor
2901 to relocate against. */
2902 if (!xcoff_mark (info
, xcoff_hash_table (info
)->toc_section
))
2905 /* We handle writing out the contents of the descriptor in
2906 xcoff_write_global_symbol. */
2908 else if (info
->static_link
)
2909 /* We can't get a symbol value dynamically, so just assume
2910 that it's undefined. */
2911 h
->flags
|= XCOFF_WAS_UNDEFINED
;
2912 else if ((h
->flags
& XCOFF_CALLED
) != 0)
2914 /* This is a function symbol for which we need to create
2917 struct xcoff_link_hash_entry
*hds
;
2919 /* Mark the descriptor (and its TOC section). */
2920 hds
= h
->descriptor
;
2921 BFD_ASSERT ((hds
->root
.type
== bfd_link_hash_undefined
2922 || hds
->root
.type
== bfd_link_hash_undefweak
)
2923 && (hds
->flags
& XCOFF_DEF_REGULAR
) == 0);
2924 if (!xcoff_mark_symbol (info
, hds
))
2927 /* Treat this symbol as undefined if the descriptor was. */
2928 if ((hds
->flags
& XCOFF_WAS_UNDEFINED
) != 0)
2929 h
->flags
|= XCOFF_WAS_UNDEFINED
;
2931 /* Allocate room for the global linkage code itself. */
2932 sec
= xcoff_hash_table (info
)->linkage_section
;
2933 h
->root
.type
= bfd_link_hash_defined
;
2934 h
->root
.u
.def
.section
= sec
;
2935 h
->root
.u
.def
.value
= sec
->size
;
2937 h
->flags
|= XCOFF_DEF_REGULAR
;
2938 sec
->size
+= bfd_xcoff_glink_code_size (info
->output_bfd
);
2940 /* The global linkage code requires a TOC entry for the
2942 if (hds
->toc_section
== NULL
)
2947 xcoff32 uses 4 bytes in the toc.
2948 xcoff64 uses 8 bytes in the toc. */
2949 if (bfd_xcoff_is_xcoff64 (info
->output_bfd
))
2951 else if (bfd_xcoff_is_xcoff32 (info
->output_bfd
))
2956 /* Allocate room in the fallback TOC section. */
2957 hds
->toc_section
= xcoff_hash_table (info
)->toc_section
;
2958 hds
->u
.toc_offset
= hds
->toc_section
->size
;
2959 hds
->toc_section
->size
+= byte_size
;
2960 if (!xcoff_mark (info
, hds
->toc_section
))
2963 /* Allocate room for a static and dynamic R_TOC
2965 ++xcoff_hash_table (info
)->ldinfo
.ldrel_count
;
2966 ++hds
->toc_section
->reloc_count
;
2968 /* Set the index to -2 to force this symbol to
2971 hds
->flags
|= XCOFF_SET_TOC
| XCOFF_LDREL
;
2974 else if ((h
->flags
& XCOFF_DEF_DYNAMIC
) == 0)
2976 /* Record that the symbol was undefined, then import it.
2977 -brtl links use a special fake import file. */
2978 h
->flags
|= XCOFF_WAS_UNDEFINED
| XCOFF_IMPORT
;
2979 if (xcoff_hash_table (info
)->rtld
)
2981 if (!xcoff_set_import_path (info
, h
, "", "..", ""))
2986 if (!xcoff_set_import_path (info
, h
, NULL
, NULL
, NULL
))
2992 if (h
->root
.type
== bfd_link_hash_defined
2993 || h
->root
.type
== bfd_link_hash_defweak
)
2997 hsec
= h
->root
.u
.def
.section
;
2998 if (! bfd_is_abs_section (hsec
)
2999 && hsec
->gc_mark
== 0)
3001 if (! xcoff_mark (info
, hsec
))
3006 if (h
->toc_section
!= NULL
3007 && h
->toc_section
->gc_mark
== 0)
3009 if (! xcoff_mark (info
, h
->toc_section
))
3016 /* Look for a symbol called NAME. If the symbol is defined, mark it.
3017 If the symbol exists, set FLAGS. */
3020 xcoff_mark_symbol_by_name (struct bfd_link_info
*info
,
3021 const char *name
, unsigned int flags
)
3023 struct xcoff_link_hash_entry
*h
;
3025 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
,
3026 false, false, true);
3030 if (h
->root
.type
== bfd_link_hash_defined
3031 || h
->root
.type
== bfd_link_hash_defweak
)
3033 if (!xcoff_mark (info
, h
->root
.u
.def
.section
))
3040 /* The mark phase of garbage collection. For a given section, mark
3041 it, and all the sections which define symbols to which it refers.
3042 Because this function needs to look at the relocs, we also count
3043 the number of relocs which need to be copied into the .loader
3047 xcoff_mark (struct bfd_link_info
*info
, asection
*sec
)
3049 if (bfd_is_const_section (sec
)
3050 || sec
->gc_mark
!= 0)
3055 if (sec
->owner
->xvec
!= info
->output_bfd
->xvec
)
3058 if (coff_section_data (sec
->owner
, sec
) == NULL
)
3062 if (xcoff_section_data (sec
->owner
, sec
) != NULL
)
3064 struct xcoff_link_hash_entry
**syms
;
3066 unsigned long i
, first
, last
;
3068 /* Mark all the symbols in this section. */
3069 syms
= obj_xcoff_sym_hashes (sec
->owner
);
3070 csects
= xcoff_data (sec
->owner
)->csects
;
3071 first
= xcoff_section_data (sec
->owner
, sec
)->first_symndx
;
3072 last
= xcoff_section_data (sec
->owner
, sec
)->last_symndx
;
3073 for (i
= first
; i
<= last
; i
++)
3074 if (csects
[i
] == sec
3076 && (syms
[i
]->flags
& XCOFF_MARK
) == 0)
3078 if (!xcoff_mark_symbol (info
, syms
[i
]))
3083 /* Look through the section relocs. */
3084 if ((sec
->flags
& SEC_RELOC
) != 0
3085 && sec
->reloc_count
> 0)
3087 struct internal_reloc
*rel
, *relend
;
3089 rel
= xcoff_read_internal_relocs (sec
->owner
, sec
, true,
3093 relend
= rel
+ sec
->reloc_count
;
3094 for (; rel
< relend
; rel
++)
3096 struct xcoff_link_hash_entry
*h
;
3098 if ((unsigned int) rel
->r_symndx
3099 > obj_raw_syment_count (sec
->owner
))
3102 h
= obj_xcoff_sym_hashes (sec
->owner
)[rel
->r_symndx
];
3105 if ((h
->flags
& XCOFF_MARK
) == 0)
3107 if (!xcoff_mark_symbol (info
, h
))
3115 rsec
= xcoff_data (sec
->owner
)->csects
[rel
->r_symndx
];
3117 && rsec
->gc_mark
== 0)
3119 if (!xcoff_mark (info
, rsec
))
3124 /* See if this reloc needs to be copied into the .loader
3126 if ((sec
->flags
& SEC_DEBUGGING
) == 0
3127 && xcoff_need_ldrel_p (info
, rel
, h
, sec
))
3129 ++xcoff_hash_table (info
)->ldinfo
.ldrel_count
;
3131 h
->flags
|= XCOFF_LDREL
;
3135 if (! info
->keep_memory
3136 && coff_section_data (sec
->owner
, sec
) != NULL
)
3138 free (coff_section_data (sec
->owner
, sec
)->relocs
);
3139 coff_section_data (sec
->owner
, sec
)->relocs
= NULL
;
3146 /* Routines that are called after all the input files have been
3147 handled, but before the sections are laid out in memory. */
3149 /* The sweep phase of garbage collection. Remove all garbage
3153 xcoff_sweep (struct bfd_link_info
*info
)
3157 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3160 bool some_kept
= false;
3162 /* As says below keep all sections from non-XCOFF
3164 if (sub
->xvec
!= info
->output_bfd
->xvec
)
3168 /* See whether any section is already marked. */
3169 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3174 /* If no section in this file will be kept, then we can
3175 toss out debug sections. */
3178 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3186 /* Keep all sections from non-XCOFF input files. Keep
3187 special sections. Keep .debug sections for the
3189 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3191 if (o
->gc_mark
== 1)
3194 if (sub
->xvec
!= info
->output_bfd
->xvec
3195 || o
== xcoff_hash_table (info
)->debug_section
3196 || o
== xcoff_hash_table (info
)->loader_section
3197 || o
== xcoff_hash_table (info
)->linkage_section
3198 || o
== xcoff_hash_table (info
)->descriptor_section
3199 || (bfd_section_flags (o
) & SEC_DEBUGGING
)
3200 || strcmp (o
->name
, ".debug") == 0)
3201 xcoff_mark (info
, o
);
3211 /* Initialize the back-end with linker infos. */
3214 bfd_xcoff_link_init (struct bfd_link_info
*info
,
3215 struct bfd_xcoff_link_params
*params
)
3217 xcoff_hash_table (info
)->params
= params
;
3222 /* Record the number of elements in a set. This is used to output the
3223 correct csect length. */
3226 bfd_xcoff_link_record_set (bfd
*output_bfd
,
3227 struct bfd_link_info
*info
,
3228 struct bfd_link_hash_entry
*harg
,
3231 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
3232 struct xcoff_link_size_list
*n
;
3235 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
3238 /* This will hardly ever be called. I don't want to burn four bytes
3239 per global symbol, so instead the size is kept on a linked list
3240 attached to the hash table. */
3242 n
= bfd_alloc (output_bfd
, amt
);
3245 n
->next
= xcoff_hash_table (info
)->size_list
;
3248 xcoff_hash_table (info
)->size_list
= n
;
3250 h
->flags
|= XCOFF_HAS_SIZE
;
3255 /* Import a symbol. */
3258 bfd_xcoff_import_symbol (bfd
*output_bfd
,
3259 struct bfd_link_info
*info
,
3260 struct bfd_link_hash_entry
*harg
,
3262 const char *imppath
,
3263 const char *impfile
,
3264 const char *impmember
,
3265 unsigned int syscall_flag
)
3267 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
3269 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
3272 /* A symbol name which starts with a period is the code for a
3273 function. If the symbol is undefined, then add an undefined
3274 symbol for the function descriptor, and import that instead. */
3275 if (h
->root
.root
.string
[0] == '.'
3276 && h
->root
.type
== bfd_link_hash_undefined
3277 && val
== (bfd_vma
) -1)
3279 struct xcoff_link_hash_entry
*hds
;
3281 hds
= h
->descriptor
;
3284 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
3285 h
->root
.root
.string
+ 1,
3289 if (hds
->root
.type
== bfd_link_hash_new
)
3291 hds
->root
.type
= bfd_link_hash_undefined
;
3292 hds
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
3294 hds
->flags
|= XCOFF_DESCRIPTOR
;
3295 BFD_ASSERT ((h
->flags
& XCOFF_DESCRIPTOR
) == 0);
3296 hds
->descriptor
= h
;
3297 h
->descriptor
= hds
;
3300 /* Now, if the descriptor is undefined, import the descriptor
3301 rather than the symbol we were told to import. FIXME: Is
3302 this correct in all cases? */
3303 if (hds
->root
.type
== bfd_link_hash_undefined
)
3307 h
->flags
|= (XCOFF_IMPORT
| syscall_flag
);
3309 if (val
!= (bfd_vma
) -1)
3311 if (h
->root
.type
== bfd_link_hash_defined
)
3312 (*info
->callbacks
->multiple_definition
) (info
, &h
->root
, output_bfd
,
3313 bfd_abs_section_ptr
, val
);
3315 h
->root
.type
= bfd_link_hash_defined
;
3316 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3317 h
->root
.u
.def
.value
= val
;
3321 if (!xcoff_set_import_path (info
, h
, imppath
, impfile
, impmember
))
3327 /* Export a symbol. */
3330 bfd_xcoff_export_symbol (bfd
*output_bfd
,
3331 struct bfd_link_info
*info
,
3332 struct bfd_link_hash_entry
*harg
)
3334 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
3336 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
3339 /* As AIX linker, symbols exported with hidden visibility are
3340 silently ignored. */
3341 if (h
->visibility
== SYM_V_HIDDEN
)
3344 if (h
->visibility
== SYM_V_INTERNAL
)
3346 _bfd_error_handler (_("%pB: cannot export internal symbol `%s`."),
3347 output_bfd
, h
->root
.root
.string
);
3348 bfd_set_error (bfd_error_bad_value
);
3352 h
->flags
|= XCOFF_EXPORT
;
3354 /* FIXME: I'm not at all sure what syscall is supposed to mean, so
3355 I'm just going to ignore it until somebody explains it. */
3357 /* Make sure we don't garbage collect this symbol. */
3358 if (! xcoff_mark_symbol (info
, h
))
3361 /* If this is a function descriptor, make sure we don't garbage
3362 collect the associated function code. We normally don't have to
3363 worry about this, because the descriptor will be attached to a
3364 section with relocs, but if we are creating the descriptor
3365 ourselves those relocs will not be visible to the mark code. */
3366 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
3368 if (! xcoff_mark_symbol (info
, h
->descriptor
))
3375 /* Count a reloc against a symbol. This is called for relocs
3376 generated by the linker script, typically for global constructors
3380 bfd_xcoff_link_count_reloc (bfd
*output_bfd
,
3381 struct bfd_link_info
*info
,
3384 struct xcoff_link_hash_entry
*h
;
3386 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
3389 h
= ((struct xcoff_link_hash_entry
*)
3390 bfd_wrapped_link_hash_lookup (output_bfd
, info
, name
, false, false,
3394 _bfd_error_handler (_("%s: no such symbol"), name
);
3395 bfd_set_error (bfd_error_no_symbols
);
3399 h
->flags
|= XCOFF_REF_REGULAR
;
3400 if (xcoff_hash_table (info
)->loader_section
)
3402 h
->flags
|= XCOFF_LDREL
;
3403 ++xcoff_hash_table (info
)->ldinfo
.ldrel_count
;
3406 /* Mark the symbol to avoid garbage collection. */
3407 if (! xcoff_mark_symbol (info
, h
))
3413 /* This function is called for each symbol to which the linker script
3415 FIXME: In cases like the linker test ld-scripts/defined5 where a
3416 symbol is defined both by an input object file and the script,
3417 the script definition doesn't override the object file definition
3418 as is usual for other targets. At least not when the symbol is
3419 output. Other uses of the symbol value by the linker do use the
3423 bfd_xcoff_record_link_assignment (bfd
*output_bfd
,
3424 struct bfd_link_info
*info
,
3427 struct xcoff_link_hash_entry
*h
;
3429 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
3432 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, true, true,
3437 h
->flags
|= XCOFF_DEF_REGULAR
;
3442 /* An xcoff_link_hash_traverse callback for which DATA points to an
3443 xcoff_loader_info. Mark all symbols that should be automatically
3447 xcoff_mark_auto_exports (struct xcoff_link_hash_entry
*h
, void *data
)
3449 struct xcoff_loader_info
*ldinfo
;
3451 ldinfo
= (struct xcoff_loader_info
*) data
;
3452 if (xcoff_auto_export_p (ldinfo
->info
, h
, ldinfo
->auto_export_flags
))
3454 if (!xcoff_mark_symbol (ldinfo
->info
, h
))
3455 ldinfo
->failed
= true;
3460 /* INPUT_BFD has an external symbol associated with hash table entry H
3461 and csect CSECT. Return true if INPUT_BFD defines H. */
3464 xcoff_final_definition_p (bfd
*input_bfd
, struct xcoff_link_hash_entry
*h
,
3467 switch (h
->root
.type
)
3469 case bfd_link_hash_defined
:
3470 case bfd_link_hash_defweak
:
3471 /* No input bfd owns absolute symbols. They are written by
3472 xcoff_write_global_symbol instead. */
3473 return (!bfd_is_abs_section (csect
)
3474 && h
->root
.u
.def
.section
== csect
);
3476 case bfd_link_hash_common
:
3477 return h
->root
.u
.c
.p
->section
->owner
== input_bfd
;
3479 case bfd_link_hash_undefined
:
3480 case bfd_link_hash_undefweak
:
3481 /* We can't treat undef.abfd as the owner because that bfd
3482 might be a dynamic object. Allow any bfd to claim it. */
3490 /* See if H should have a loader symbol associated with it. */
3493 xcoff_build_ldsym (struct xcoff_loader_info
*ldinfo
,
3494 struct xcoff_link_hash_entry
*h
)
3498 /* Warn if this symbol is exported but not defined. */
3499 if ((h
->flags
& XCOFF_EXPORT
) != 0
3500 && (h
->flags
& XCOFF_WAS_UNDEFINED
) != 0)
3503 (_("warning: attempt to export undefined symbol `%s'"),
3504 h
->root
.root
.string
);
3508 /* We need to add a symbol to the .loader section if it is mentioned
3509 in a reloc which we are copying to the .loader section and it was
3510 not defined or common, or if it is the entry point, or if it is
3512 if (((h
->flags
& XCOFF_LDREL
) == 0
3513 || h
->root
.type
== bfd_link_hash_defined
3514 || h
->root
.type
== bfd_link_hash_defweak
3515 || h
->root
.type
== bfd_link_hash_common
)
3516 && (h
->flags
& XCOFF_ENTRY
) == 0
3517 && (h
->flags
& XCOFF_EXPORT
) == 0)
3520 /* We need to add this symbol to the .loader symbols. */
3522 BFD_ASSERT (h
->ldsym
== NULL
);
3523 amt
= sizeof (struct internal_ldsym
);
3524 h
->ldsym
= bfd_zalloc (ldinfo
->output_bfd
, amt
);
3525 if (h
->ldsym
== NULL
)
3527 ldinfo
->failed
= true;
3531 if ((h
->flags
& XCOFF_IMPORT
) != 0)
3533 /* Give imported descriptors class XMC_DS rather than XMC_UA. */
3534 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
3536 h
->ldsym
->l_ifile
= h
->ldindx
;
3539 /* The first 3 symbol table indices are reserved to indicate the
3540 data, text and bss sections. */
3541 h
->ldindx
= ldinfo
->ldsym_count
+ 3;
3543 ++ldinfo
->ldsym_count
;
3545 if (! bfd_xcoff_put_ldsymbol_name (ldinfo
->output_bfd
, ldinfo
,
3546 h
->ldsym
, h
->root
.root
.string
))
3549 h
->flags
|= XCOFF_BUILT_LDSYM
;
3553 /* An xcoff_htab_traverse callback that is called for each symbol
3554 once garbage collection is complete. */
3557 xcoff_post_gc_symbol (struct xcoff_link_hash_entry
*h
, void * p
)
3559 struct xcoff_loader_info
*ldinfo
= (struct xcoff_loader_info
*) p
;
3561 /* __rtinit, this symbol has special handling. */
3562 if (h
->flags
& XCOFF_RTINIT
)
3565 /* We don't want to garbage collect symbols which are not defined in
3566 XCOFF files. This is a convenient place to mark them. */
3567 if (xcoff_hash_table (ldinfo
->info
)->gc
3568 && (h
->flags
& XCOFF_MARK
) == 0
3569 && (h
->root
.type
== bfd_link_hash_defined
3570 || h
->root
.type
== bfd_link_hash_defweak
)
3571 && (h
->root
.u
.def
.section
->owner
== NULL
3572 || (h
->root
.u
.def
.section
->owner
->xvec
3573 != ldinfo
->info
->output_bfd
->xvec
)))
3574 h
->flags
|= XCOFF_MARK
;
3576 /* Skip discarded symbols. */
3577 if (xcoff_hash_table (ldinfo
->info
)->gc
3578 && (h
->flags
& XCOFF_MARK
) == 0)
3581 /* If this is still a common symbol, and it wasn't garbage
3582 collected, we need to actually allocate space for it in the .bss
3584 if (h
->root
.type
== bfd_link_hash_common
3585 && h
->root
.u
.c
.p
->section
->size
== 0)
3587 BFD_ASSERT (bfd_is_com_section (h
->root
.u
.c
.p
->section
));
3588 h
->root
.u
.c
.p
->section
->size
= h
->root
.u
.c
.size
;
3591 if (xcoff_hash_table (ldinfo
->info
)->loader_section
)
3593 if (xcoff_auto_export_p (ldinfo
->info
, h
, ldinfo
->auto_export_flags
))
3594 h
->flags
|= XCOFF_EXPORT
;
3596 if (!xcoff_build_ldsym (ldinfo
, h
))
3603 /* INPUT_BFD includes XCOFF symbol ISYM, which is associated with linker
3604 hash table entry H and csect CSECT. AUX contains ISYM's auxiliary
3605 csect information, if any. NAME is the function's name if the name
3606 is stored in the .debug section, otherwise it is null.
3608 Return 1 if we should include an appropriately-adjusted ISYM
3609 in the output file, 0 if we should discard ISYM, or -1 if an
3613 xcoff_keep_symbol_p (struct bfd_link_info
*info
, bfd
*input_bfd
,
3614 struct internal_syment
*isym
,
3615 union internal_auxent
*aux
,
3616 struct xcoff_link_hash_entry
*h
,
3617 asection
*csect
, const char *name
)
3621 /* If we are skipping this csect, we want to strip the symbol too. */
3625 /* Likewise if we garbage-collected the csect. */
3626 if (xcoff_hash_table (info
)->gc
3627 && !bfd_is_abs_section (csect
)
3628 && !bfd_is_und_section (csect
)
3629 && csect
->gc_mark
== 0)
3632 /* An XCOFF linker always removes C_STAT symbols. */
3633 if (isym
->n_sclass
== C_STAT
)
3636 /* We generate the TOC anchor separately. */
3637 if (isym
->n_sclass
== C_HIDEXT
3638 && aux
->x_csect
.x_smclas
== XMC_TC0
)
3641 /* If we are stripping all symbols, we want to discard this one. */
3642 if (info
->strip
== strip_all
)
3645 /* Discard symbols that are defined elsewhere. */
3646 if (EXTERN_SYM_P (isym
->n_sclass
))
3648 if ((h
->flags
& XCOFF_ALLOCATED
) != 0)
3650 if (!xcoff_final_definition_p (input_bfd
, h
, csect
))
3654 /* If we're discarding local symbols, check whether ISYM is local. */
3655 smtyp
= SMTYP_SMTYP (aux
->x_csect
.x_smtyp
);
3656 if (info
->discard
== discard_all
3657 && !EXTERN_SYM_P (isym
->n_sclass
)
3658 && (isym
->n_sclass
!= C_HIDEXT
|| smtyp
!= XTY_SD
))
3661 /* If we're stripping debugging symbols, check whether ISYM is one. */
3662 if (info
->strip
== strip_debugger
3663 && isym
->n_scnum
== N_DEBUG
)
3666 /* If we are stripping symbols based on name, check how ISYM's
3667 name should be handled. */
3668 if (info
->strip
== strip_some
3669 || info
->discard
== discard_l
)
3671 char buf
[SYMNMLEN
+ 1];
3675 name
= _bfd_coff_internal_syment_name (input_bfd
, isym
, buf
);
3680 if (info
->strip
== strip_some
3681 && bfd_hash_lookup (info
->keep_hash
, name
, false, false) == NULL
)
3684 if (info
->discard
== discard_l
3685 && !EXTERN_SYM_P (isym
->n_sclass
)
3686 && (isym
->n_sclass
!= C_HIDEXT
|| smtyp
!= XTY_SD
)
3687 && bfd_is_local_label_name (input_bfd
, name
))
3694 /* Compute the current size of the .loader section. Start filling
3695 its header but it will be finalized in xcoff_build_loader_section. */
3698 xcoff_size_loader_section (struct xcoff_loader_info
*ldinfo
)
3701 struct xcoff_link_hash_table
*htab
;
3702 struct internal_ldhdr
*ldhdr
;
3703 struct xcoff_import_file
*fl
;
3704 bfd_size_type stoff
;
3705 size_t impsize
, impcount
;
3708 output_bfd
= ldinfo
->output_bfd
;
3709 htab
= xcoff_hash_table (ldinfo
->info
);
3710 ldhdr
= &htab
->ldhdr
;
3712 /* If this function has already been called (ie l_version is set)
3713 and the number of symbols or relocations haven't changed since
3714 last call, the size is already known. */
3715 if (ldhdr
->l_version
!= 0
3716 && ldhdr
->l_nsyms
== ldinfo
->ldsym_count
3717 && ldhdr
->l_nreloc
== ldinfo
->ldrel_count
)
3720 /* Work out the size of the import file names. Each import file ID
3721 consists of three null terminated strings: the path, the file
3722 name, and the archive member name. The first entry in the list
3723 of names is the path to use to find objects, which the linker has
3724 passed in as the libpath argument. For some reason, the path
3725 entry in the other import file names appears to always be empty. */
3726 if (ldhdr
->l_nimpid
== 0)
3728 impsize
= strlen (ldinfo
->libpath
) + 3;
3730 for (fl
= htab
->imports
; fl
!= NULL
; fl
= fl
->next
)
3733 impsize
+= (strlen (fl
->path
)
3735 + strlen (fl
->member
)
3738 ldhdr
->l_istlen
= impsize
;
3739 ldhdr
->l_nimpid
= impcount
;
3742 /* Set up the .loader section header. */
3743 ldhdr
->l_version
= bfd_xcoff_ldhdr_version(output_bfd
);
3744 ldhdr
->l_nsyms
= ldinfo
->ldsym_count
;
3745 ldhdr
->l_nreloc
= ldinfo
->ldrel_count
;
3746 ldhdr
->l_impoff
= (bfd_xcoff_ldhdrsz (output_bfd
)
3747 + ldhdr
->l_nsyms
* bfd_xcoff_ldsymsz (output_bfd
)
3748 + ldhdr
->l_nreloc
* bfd_xcoff_ldrelsz (output_bfd
));
3749 ldhdr
->l_stlen
= ldinfo
->string_size
;
3750 stoff
= ldhdr
->l_impoff
+ ldhdr
->l_istlen
;
3751 if (ldinfo
->string_size
== 0)
3754 ldhdr
->l_stoff
= stoff
;
3756 /* 64 bit elements to ldhdr
3757 The swap out routine for 32 bit will ignore them.
3758 Nothing fancy, symbols come after the header and relocs come
3760 ldhdr
->l_symoff
= bfd_xcoff_ldhdrsz (output_bfd
);
3761 ldhdr
->l_rldoff
= (bfd_xcoff_ldhdrsz (output_bfd
)
3762 + ldhdr
->l_nsyms
* bfd_xcoff_ldsymsz (output_bfd
));
3764 /* Save the size of the .loader section. */
3765 lsec
= htab
->loader_section
;
3766 lsec
->size
= stoff
+ ldhdr
->l_stlen
;
3771 /* Prepare the .loader section. This is called by the XCOFF linker
3772 emulation before_allocation routine. We must set the size of the
3773 .loader section before the linker lays out the output file. However,
3774 some symbols or relocations might be append to the .loader section
3775 when processing the addresses, thus it's not layout right now and
3776 its size might change.
3777 LIBPATH is the library path to search for shared objects; this is
3778 normally built from the -L arguments passed to the linker. ENTRY
3779 is the name of the entry point symbol (the -e linker option).
3780 FILE_ALIGN is the alignment to use for sections within the file
3781 (the -H linker option). MAXSTACK is the maximum stack size (the
3782 -bmaxstack linker option). MAXDATA is the maximum data size (the
3783 -bmaxdata linker option). GC is whether to do garbage collection
3784 (the -bgc linker option). MODTYPE is the module type (the
3785 -bmodtype linker option). TEXTRO is whether the text section must
3786 be read only (the -btextro linker option). AUTO_EXPORT_FLAGS
3787 is a mask of XCOFF_EXPALL and XCOFF_EXPFULL. SPECIAL_SECTIONS
3788 is set by this routine to csects with magic names like _end. */
3791 bfd_xcoff_size_dynamic_sections (bfd
*output_bfd
,
3792 struct bfd_link_info
*info
,
3793 const char *libpath
,
3795 unsigned long file_align
,
3796 unsigned long maxstack
,
3797 unsigned long maxdata
,
3801 unsigned int auto_export_flags
,
3802 asection
**special_sections
,
3805 struct xcoff_loader_info
*ldinfo
;
3811 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
3813 for (i
= 0; i
< XCOFF_NUMBER_OF_SPECIAL_SECTIONS
; i
++)
3814 special_sections
[i
] = NULL
;
3819 ldinfo
= &(xcoff_hash_table (info
)->ldinfo
);
3821 ldinfo
->failed
= false;
3822 ldinfo
->output_bfd
= output_bfd
;
3823 ldinfo
->info
= info
;
3824 ldinfo
->auto_export_flags
= auto_export_flags
;
3825 ldinfo
->ldsym_count
= 0;
3826 ldinfo
->string_size
= 0;
3827 ldinfo
->strings
= NULL
;
3828 ldinfo
->string_alc
= 0;
3829 ldinfo
->libpath
= libpath
;
3831 xcoff_data (output_bfd
)->maxstack
= maxstack
;
3832 xcoff_data (output_bfd
)->maxdata
= maxdata
;
3833 xcoff_data (output_bfd
)->modtype
= modtype
;
3835 xcoff_hash_table (info
)->file_align
= file_align
;
3836 xcoff_hash_table (info
)->textro
= textro
;
3837 xcoff_hash_table (info
)->rtld
= rtld
;
3840 if (xcoff_hash_table (info
)->loader_section
3841 && (info
->init_function
|| info
->fini_function
|| rtld
))
3843 struct xcoff_link_hash_entry
*hsym
;
3844 struct internal_ldsym
*ldsym
;
3846 hsym
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
3847 "__rtinit", false, false, true);
3851 (_("error: undefined symbol __rtinit"));
3855 xcoff_mark_symbol (info
, hsym
);
3856 hsym
->flags
|= (XCOFF_DEF_REGULAR
| XCOFF_RTINIT
);
3858 /* __rtinit initialized. */
3859 amt
= sizeof (* ldsym
);
3860 ldsym
= bfd_malloc (amt
);
3862 ldsym
->l_value
= 0; /* Will be filled in later. */
3863 ldsym
->l_scnum
= 2; /* Data section. */
3864 ldsym
->l_smtype
= XTY_SD
; /* Csect section definition. */
3865 ldsym
->l_smclas
= 5; /* .rw. */
3866 ldsym
->l_ifile
= 0; /* Special system loader symbol. */
3867 ldsym
->l_parm
= 0; /* NA. */
3869 /* Force __rtinit to be the first symbol in the loader symbol table
3870 See xcoff_build_ldsyms
3872 The first 3 symbol table indices are reserved to indicate the data,
3873 text and bss sections. */
3874 BFD_ASSERT (0 == ldinfo
->ldsym_count
);
3877 ldinfo
->ldsym_count
= 1;
3878 hsym
->ldsym
= ldsym
;
3880 if (! bfd_xcoff_put_ldsymbol_name (ldinfo
->output_bfd
, ldinfo
,
3881 hsym
->ldsym
, hsym
->root
.root
.string
))
3884 /* This symbol is written out by xcoff_write_global_symbol
3885 Set stuff up so xcoff_write_global_symbol logic works. */
3886 hsym
->flags
|= XCOFF_DEF_REGULAR
| XCOFF_MARK
;
3887 hsym
->root
.type
= bfd_link_hash_defined
;
3888 hsym
->root
.u
.def
.value
= 0;
3891 /* Garbage collect unused sections. */
3892 if (bfd_link_relocatable (info
) || !gc
)
3895 xcoff_hash_table (info
)->gc
= false;
3897 /* We still need to call xcoff_mark, in order to set ldrel_count
3899 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3903 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3905 /* We shouldn't unconditionaly mark the TOC section.
3906 The output file should only have a TOC if either
3907 (a) one of the input files did or (b) we end up
3908 creating TOC references as part of the link process. */
3909 if (o
!= xcoff_hash_table (info
)->toc_section
3912 if (! xcoff_mark (info
, o
))
3921 && !xcoff_mark_symbol_by_name (info
, entry
, XCOFF_ENTRY
))
3923 if (info
->init_function
!= NULL
3924 && !xcoff_mark_symbol_by_name (info
, info
->init_function
, 0))
3926 if (info
->fini_function
!= NULL
3927 && !xcoff_mark_symbol_by_name (info
, info
->fini_function
, 0))
3929 if (auto_export_flags
!= 0)
3931 xcoff_link_hash_traverse (xcoff_hash_table (info
),
3932 xcoff_mark_auto_exports
, ldinfo
);
3937 xcoff_hash_table (info
)->gc
= true;
3940 /* Return special sections to the caller. */
3941 for (i
= 0; i
< XCOFF_NUMBER_OF_SPECIAL_SECTIONS
; i
++)
3943 sec
= xcoff_hash_table (info
)->special_sections
[i
];
3947 && sec
->gc_mark
== 0)
3950 special_sections
[i
] = sec
;
3953 if (info
->input_bfds
== NULL
)
3954 /* I'm not sure what to do in this bizarre case. */
3957 xcoff_link_hash_traverse (xcoff_hash_table (info
), xcoff_post_gc_symbol
,
3962 if (xcoff_hash_table (info
)->loader_section
3963 && !xcoff_size_loader_section (ldinfo
))
3969 free (ldinfo
->strings
);
3973 /* Lay out the .loader section, finalizing its header and
3974 filling the import paths */
3976 xcoff_build_loader_section (struct xcoff_loader_info
*ldinfo
)
3980 struct xcoff_link_hash_table
*htab
;
3981 struct internal_ldhdr
*ldhdr
;
3982 struct xcoff_import_file
*fl
;
3985 output_bfd
= ldinfo
->output_bfd
;
3986 htab
= xcoff_hash_table (ldinfo
->info
);
3987 lsec
= htab
->loader_section
;
3988 ldhdr
= &htab
->ldhdr
;
3990 /* We could have called xcoff_size_loader_section one more time.
3991 However, this function is called once all the addresses have
3992 been layout thus the .loader section shouldn't be changed
3994 BFD_ASSERT (ldhdr
->l_nsyms
== ldinfo
->ldsym_count
);
3995 BFD_ASSERT (ldhdr
->l_nreloc
== ldinfo
->ldrel_count
);
3997 /* We now know the final size of the .loader section. Allocate
3999 lsec
->contents
= bfd_zalloc (output_bfd
, lsec
->size
);
4000 if (lsec
->contents
== NULL
)
4003 /* Set up the header. */
4004 bfd_xcoff_swap_ldhdr_out (output_bfd
, ldhdr
, lsec
->contents
);
4006 /* Set up the import file names. */
4007 out
= (char *) lsec
->contents
+ ldhdr
->l_impoff
;
4008 strcpy (out
, ldinfo
->libpath
);
4009 out
+= strlen (ldinfo
->libpath
) + 1;
4012 for (fl
= htab
->imports
; fl
!= NULL
; fl
= fl
->next
)
4017 while ((*out
++ = *s
++) != '\0')
4020 while ((*out
++ = *s
++) != '\0')
4023 while ((*out
++ = *s
++) != '\0')
4027 BFD_ASSERT ((bfd_size_type
) ((bfd_byte
*) out
- lsec
->contents
) == ldhdr
->l_impoff
+ ldhdr
->l_istlen
);
4029 /* Set up the symbol string table. */
4030 if (ldinfo
->string_size
> 0)
4032 memcpy (out
, ldinfo
->strings
, ldinfo
->string_size
);
4033 free (ldinfo
->strings
);
4034 ldinfo
->strings
= NULL
;
4037 /* We can't set up the symbol table or the relocs yet, because we
4038 don't yet know the final position of the various sections. The
4039 .loader symbols are written out when the corresponding normal
4040 symbols are written out in xcoff_link_input_bfd or
4041 xcoff_write_global_symbol. The .loader relocs are written out
4042 when the corresponding normal relocs are handled in
4043 xcoff_link_input_bfd. */
4049 /* Lay out the .loader section and allocate the space for
4050 the other dynamic sections of XCOFF. */
4052 bfd_xcoff_build_dynamic_sections (bfd
*output_bfd
,
4053 struct bfd_link_info
*info
)
4055 struct xcoff_loader_info
*ldinfo
;
4056 struct bfd_strtab_hash
*debug_strtab
;
4057 bfd_byte
*debug_contents
= NULL
;
4061 ldinfo
= &(xcoff_hash_table (info
)->ldinfo
);
4063 if (xcoff_hash_table (info
)->loader_section
4064 && !xcoff_build_loader_section (ldinfo
))
4067 /* Allocate space for the magic sections. */
4068 sec
= xcoff_hash_table (info
)->linkage_section
;
4071 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
4072 if (sec
->contents
== NULL
)
4075 sec
= xcoff_hash_table (info
)->toc_section
;
4078 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
4079 if (sec
->contents
== NULL
)
4082 sec
= xcoff_hash_table (info
)->descriptor_section
;
4085 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
4086 if (sec
->contents
== NULL
)
4090 /* Now that we've done garbage collection, decide which symbols to keep,
4091 and figure out the contents of the .debug section. */
4092 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
4094 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
4097 bfd_size_type symcount
;
4100 unsigned int *lineno_counts
;
4101 struct xcoff_link_hash_entry
**sym_hash
;
4102 bfd_byte
*esym
, *esymend
;
4103 bfd_size_type symesz
;
4105 if (sub
->xvec
!= info
->output_bfd
->xvec
)
4108 if ((sub
->flags
& DYNAMIC
) != 0
4109 && !info
->static_link
)
4112 if (! _bfd_coff_get_external_symbols (sub
))
4115 symcount
= obj_raw_syment_count (sub
);
4116 debug_index
= bfd_zalloc (sub
, symcount
* sizeof (long));
4117 if (debug_index
== NULL
)
4119 xcoff_data (sub
)->debug_indices
= debug_index
;
4121 if (info
->strip
== strip_all
4122 || info
->strip
== strip_debugger
4123 || info
->discard
== discard_all
)
4124 /* We're stripping all debugging information, so there's no need
4125 to read SUB's .debug section. */
4129 /* Grab the contents of SUB's .debug section, if any. */
4130 subdeb
= bfd_get_section_by_name (sub
, ".debug");
4132 && subdeb
->size
!= 0
4133 && (subdeb
->flags
& SEC_HAS_CONTENTS
) != 0)
4135 /* We use malloc and copy the names into the debug
4136 stringtab, rather than bfd_alloc, because I expect
4137 that, when linking many files together, many of the
4138 strings will be the same. Storing the strings in the
4139 hash table should save space in this case. */
4140 if (!bfd_malloc_and_get_section (sub
, subdeb
, &debug_contents
))
4145 csectpp
= xcoff_data (sub
)->csects
;
4146 lineno_counts
= xcoff_data (sub
)->lineno_counts
;
4147 sym_hash
= obj_xcoff_sym_hashes (sub
);
4148 symesz
= bfd_coff_symesz (sub
);
4149 esym
= (bfd_byte
*) obj_coff_external_syms (sub
);
4150 esymend
= esym
+ symcount
* symesz
;
4152 while (esym
< esymend
)
4154 struct internal_syment sym
;
4155 union internal_auxent aux
;
4160 bfd_coff_swap_sym_in (sub
, esym
, &sym
);
4162 /* Read in the csect information, if any. */
4163 if (CSECT_SYM_P (sym
.n_sclass
))
4165 BFD_ASSERT (sym
.n_numaux
> 0);
4166 bfd_coff_swap_aux_in (sub
, esym
+ symesz
* sym
.n_numaux
,
4167 sym
.n_type
, sym
.n_sclass
,
4168 sym
.n_numaux
- 1, sym
.n_numaux
, &aux
);
4171 /* If this symbol's name is stored in the debug section,
4172 get a pointer to it. */
4173 if (debug_contents
!= NULL
4174 && sym
._n
._n_n
._n_zeroes
== 0
4175 && bfd_coff_symname_in_debug (sub
, &sym
))
4176 name
= (const char *) debug_contents
+ sym
._n
._n_n
._n_offset
;
4180 /* Decide whether to copy this symbol to the output file. */
4182 keep_p
= xcoff_keep_symbol_p (info
, sub
, &sym
, &aux
,
4183 *sym_hash
, csect
, name
);
4188 /* Use a debug_index of -2 to record that a symbol should
4193 /* See whether we should store the symbol name in the
4194 output .debug section. */
4199 indx
= _bfd_stringtab_add (debug_strtab
, name
, true, true);
4200 if (indx
== (bfd_size_type
) -1)
4202 *debug_index
= indx
;
4207 (*sym_hash
)->flags
|= XCOFF_ALLOCATED
;
4208 if (*lineno_counts
> 0)
4209 csect
->output_section
->lineno_count
+= *lineno_counts
;
4212 esym
+= (sym
.n_numaux
+ 1) * symesz
;
4213 csectpp
+= sym
.n_numaux
+ 1;
4214 sym_hash
+= sym
.n_numaux
+ 1;
4215 lineno_counts
+= sym
.n_numaux
+ 1;
4216 debug_index
+= sym
.n_numaux
+ 1;
4221 free (debug_contents
);
4222 debug_contents
= NULL
;
4224 /* Clear the size of subdeb, so that it is not included directly
4225 in the output file. */
4229 if (! info
->keep_memory
)
4231 if (! _bfd_coff_free_symbols (sub
))
4236 if (info
->strip
!= strip_all
4237 && xcoff_hash_table (info
)->debug_section
!= NULL
)
4238 xcoff_hash_table (info
)->debug_section
->size
=
4239 _bfd_stringtab_size (debug_strtab
);
4244 free (debug_contents
);
4249 bfd_xcoff_link_generate_rtinit (bfd
*abfd
,
4254 struct bfd_in_memory
*bim
;
4256 bim
= bfd_malloc ((bfd_size_type
) sizeof (* bim
));
4263 abfd
->link
.next
= 0;
4264 abfd
->format
= bfd_object
;
4265 abfd
->iostream
= (void *) bim
;
4266 abfd
->flags
= BFD_IN_MEMORY
;
4267 abfd
->iovec
= &_bfd_memory_iovec
;
4268 abfd
->direction
= write_direction
;
4272 if (! bfd_xcoff_generate_rtinit (abfd
, init
, fini
, rtld
))
4275 /* need to reset to unknown or it will not be read back in correctly */
4276 abfd
->format
= bfd_unknown
;
4277 abfd
->direction
= read_direction
;
4285 The stubs will be gathered in stub csects named "@FIX'number'".
4286 A new csect will be created by xcoff_stub_get_csect_in_range,
4287 everytime a relocation cannot reach its target and its section
4288 is too far from the others stub csects.
4289 The stubs will simply be code generated inside these stub
4290 csects. In order to simplify the symbol table, only the symbols
4291 for the stub csects are written.
4293 As the code is dependent of the architecture, it's defined
4296 xcoff_stub_indirect_call:
4297 Used when a 24 bit branch cannot reach its destination and that
4298 this destination isn't a global linkage symbol.
4300 xcoff_stub_shared_call:
4301 As above but when it's a global linkage symbol.
4302 The main difference being that it doesn't branch to the global
4303 linkage symbol which will then call the shared library. It
4304 directly call it saving the TOC.
4306 TODO: -bbigtoc option should be able to be implemented using
4309 /* Get the name of a csect which will contain stubs.
4310 It has the same pattern as AIX linker: @FIX"number". */
4312 xcoff_stub_csect_name (unsigned int n
)
4318 /* For now, allow "only" 1000000 stub csects. */
4325 sprintf (buf
, "%d", n
);
4326 len
= 4 + strlen (buf
) + 1;
4328 csect_name
= bfd_malloc (len
);
4329 if (csect_name
== NULL
)
4331 sprintf (csect_name
, "@FIX%d", n
);
4336 /* Return a stub section which can be reach with a single branch
4337 from SECTION. CREATE means that creating a csect is allowed. */
4338 static struct xcoff_link_hash_entry
*
4339 xcoff_stub_get_csect_in_range (asection
*section
,
4340 struct bfd_link_info
*info
,
4343 struct xcoff_link_hash_table
*htab
= xcoff_hash_table (info
);
4344 struct xcoff_link_hash_entry
*csect_entry
;
4345 struct bfd_link_hash_entry
*bh
= NULL
;
4350 /* Search for a csect in range. */
4351 for (csect
= htab
->params
->stub_bfd
->sections
, it
= 0;
4353 csect
= csect
->next
, it
++)
4355 /* A csect is in range if everything instructions in SECTION
4356 can branch to every stubs in the stub csect. This can
4357 be simplify by saying that the first entry of each sections
4358 (ie the vma of this section) can reach the last entry of the
4359 stub csect (ie the vma of the csect + its size).
4360 However, as the stub csect might be growing its size isn't
4361 fixed. Thus, the last entry of SECTION might not be able
4362 to reach the first entry of the stub csect anymore.
4363 If this case happens, the following condition will be
4364 false during the next pass of bfd_xcoff_size_stubs and
4365 another csect will be used.
4366 This means we might create more stubs than needed. */
4367 bfd_vma csect_vma
, section_vma
;
4368 bfd_vma csect_last_vma
, section_last_vma
;
4370 csect_vma
= (csect
->output_section
->vma
4371 + csect
->output_offset
);
4372 csect_last_vma
= (csect
->output_section
->vma
4373 + csect
->output_offset
4375 section_vma
= (section
->output_section
->vma
4376 + section
->output_offset
);
4377 section_last_vma
= (section
->output_section
->vma
4378 + section
->output_offset
4381 if (csect_last_vma
- section_vma
+ (1 << 25) < 2 * (1 << 25)
4382 && section_last_vma
- csect_vma
+ (1 << 25) < 2 * (1 << 25))
4386 if (!create
&& csect
== NULL
)
4389 csect_name
= xcoff_stub_csect_name (it
);
4393 /* A stub csect already exists, get its entry. */
4396 csect_entry
= xcoff_link_hash_lookup (htab
, csect_name
, false, false, true);
4401 /* Create the csect and its symbol. */
4402 csect
= (*htab
->params
->add_stub_section
) (".pr", section
);
4409 csect
->alignment_power
= 2;
4411 csect
->reloc_count
= 0;
4413 /* We need to associate a VMA to this new csect. Otherwise,
4414 our "in range" algorithm won't find it for the next stub.
4415 And as we will be adding this stub section just after the
4416 SECTION, we know its address. */
4417 csect
->output_offset
= BFD_ALIGN (section
->output_offset
+ section
->size
,
4420 if (!_bfd_generic_link_add_one_symbol (info
, htab
->params
->stub_bfd
,
4421 csect_name
, BSF_GLOBAL
, csect
, 0,
4422 NULL
, true, true, &bh
))
4428 csect_entry
= (struct xcoff_link_hash_entry
*)bh
;
4429 csect_entry
->smclas
= XMC_PR
;
4430 csect_entry
->flags
= XCOFF_MARK
| XCOFF_DEF_REGULAR
;
4437 /* Build a name for an entry in the stub hash table. */
4439 xcoff_stub_name (const struct xcoff_link_hash_entry
*h
,
4440 const struct xcoff_link_hash_entry
*hcsect
)
4447 /* The name of a stub is based on its stub csect and the
4448 symbol it wants to reach. It looks like: ".@FIX0.tramp.f".
4449 When the stub targets a function, the last dot of ".tramp."
4450 is removed to avoid having two dot. */
4452 + strlen (hcsect
->root
.root
.string
)
4453 + strlen (h
->root
.root
.string
)
4455 if (h
->root
.root
.string
[0] != '.')
4458 stub_name
= bfd_malloc (len
);
4459 if (stub_name
== NULL
)
4462 if (h
->root
.root
.string
[0] == '.')
4463 sprintf (stub_name
, ".%s.tramp%s",
4464 hcsect
->root
.root
.string
,
4465 h
->root
.root
.string
);
4467 sprintf (stub_name
, ".%s.tramp.%s",
4468 hcsect
->root
.root
.string
,
4469 h
->root
.root
.string
);
4480 /* Look up an entry in the stub hash. */
4481 struct xcoff_stub_hash_entry
*
4482 bfd_xcoff_get_stub_entry (asection
*section
,
4483 struct xcoff_link_hash_entry
*h
,
4484 struct bfd_link_info
*info
)
4486 struct xcoff_link_hash_table
*htab
= xcoff_hash_table (info
);
4487 struct xcoff_link_hash_entry
*hcsect
;
4488 struct xcoff_stub_hash_entry
*hstub
;
4491 hcsect
= xcoff_stub_get_csect_in_range (section
, info
, false);
4495 stub_name
= xcoff_stub_name (h
, hcsect
);
4496 if (stub_name
== NULL
)
4499 hstub
= xcoff_stub_hash_lookup (&htab
->stub_hash_table
,
4500 stub_name
, false, false);
4506 /* Check if the symbol targeted by IREL is reachable.
4507 Return the type of stub needed otherwise. */
4508 enum xcoff_stub_type
4509 bfd_xcoff_type_of_stub (asection
*sec
,
4510 const struct internal_reloc
*irel
,
4511 bfd_vma destination
,
4512 struct xcoff_link_hash_entry
*h
)
4514 bfd_vma location
, offset
, max_offset
;
4516 switch (irel
->r_type
)
4519 return xcoff_stub_none
;
4523 location
= (sec
->output_section
->vma
4524 + sec
->output_offset
4528 max_offset
= 1 << 25 ;
4530 offset
= destination
- location
;
4532 if (offset
+ max_offset
< 2 * max_offset
)
4533 return xcoff_stub_none
;
4535 /* A stub is needed. Now, check that we can make one. */
4537 && h
->descriptor
!= NULL
)
4539 /* Not sure how to handle this case. For now, skip it. */
4540 if (bfd_is_abs_section (h
->root
.u
.def
.section
))
4541 return xcoff_stub_none
;
4543 if (h
->smclas
== XMC_GL
)
4544 return xcoff_stub_shared_call
;
4546 return xcoff_stub_indirect_call
;
4551 return xcoff_stub_none
;
4554 /* Add a new stub entry to the stub hash. Not all fields of the new
4555 stub entry are initialised. */
4556 static struct xcoff_stub_hash_entry
*
4557 xcoff_add_stub (const char *stub_name
,
4558 struct xcoff_link_hash_entry
*hstub_csect
,
4559 struct xcoff_link_hash_entry
*htarget
,
4560 struct bfd_link_info
*info
,
4561 enum xcoff_stub_type stub_type
)
4563 struct xcoff_link_hash_table
*htab
= xcoff_hash_table (info
);
4564 struct xcoff_stub_hash_entry
*hstub
;
4565 bfd_vma stub_offset
;
4566 asection
*stub_csect
;
4568 stub_csect
= hstub_csect
->root
.u
.def
.section
;
4569 stub_offset
= stub_csect
->size
;
4571 /* Update the relocation counter and the size of
4572 the containing csect. The size is needed for
4573 the algorithm in xcoff_stub_get_csect_in_range. */
4580 case xcoff_stub_indirect_call
:
4581 stub_csect
->reloc_count
++;
4582 stub_csect
->size
+= bfd_xcoff_stub_indirect_call_size (info
->output_bfd
);
4585 case xcoff_stub_shared_call
:
4586 stub_csect
->reloc_count
++;
4587 stub_csect
->size
+= bfd_xcoff_stub_shared_call_size (info
->output_bfd
);
4591 /* Create the stub entry. */
4592 hstub
= xcoff_stub_hash_lookup (&htab
->stub_hash_table
, stub_name
,
4597 hstub
->htarget
= htarget
;
4598 hstub
->stub_offset
= stub_offset
;
4600 /* For indirect call or shared call, the relocations are against
4601 the target descriptor. Its toc entry will be used. */
4602 if (stub_type
== xcoff_stub_indirect_call
4603 || stub_type
== xcoff_stub_shared_call
)
4605 struct xcoff_link_hash_entry
*hds
= htarget
->descriptor
;
4606 asection
*hds_section
= hds
->root
.u
.def
.section
;
4608 hstub
->htarget
= hds
;
4610 /* If the symbol haven't been marked, its section might have
4611 its size and its relocation count been deleted by xcoff_sweep.
4613 if ((hds
->flags
& XCOFF_MARK
) == 0)
4615 if (hds_section
->size
== 0
4616 && hds_section
->reloc_count
== 0
4617 && hds_section
->rawsize
!= 0)
4619 hds_section
->size
= hds_section
->rawsize
;
4620 /* Always two relocations for a XMC_DS symbol. */
4621 hds_section
->reloc_count
= 2;
4624 /* Mark the section and the symbol. */
4625 if (!xcoff_mark (info
, hds_section
))
4629 /* Add a TOC entry for the descriptor if non exists. */
4630 if (hds
->toc_section
== NULL
)
4634 if (bfd_xcoff_is_xcoff64 (info
->output_bfd
))
4636 else if (bfd_xcoff_is_xcoff32 (info
->output_bfd
))
4641 /* Allocate room in the fallback TOC section. */
4642 hds
->toc_section
= xcoff_hash_table (info
)->toc_section
;
4643 hds
->u
.toc_offset
= hds
->toc_section
->size
;
4644 hds
->toc_section
->size
+= byte_size
;
4645 if (!xcoff_mark (info
, hds
->toc_section
))
4648 /* Update relocation counters for a static and dynamic
4649 R_TOC relocation. */
4650 ++hds
->toc_section
->reloc_count
;
4651 ++htab
->ldinfo
.ldrel_count
;
4653 /* Set the index to -2 to force this symbol to
4656 hds
->flags
|= XCOFF_SET_TOC
;
4664 xcoff_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
4666 struct xcoff_stub_hash_entry
*hstub
4667 = (struct xcoff_stub_hash_entry
*) gen_entry
;
4671 struct bfd_link_info
*info
;
4676 info
= (struct bfd_link_info
*) in_arg
;
4677 stub_bfd
= xcoff_hash_table (info
)->params
->stub_bfd
;
4678 output_bfd
= info
->output_bfd
;
4680 /* Fail if the target section could not be assigned to an output
4681 section. The user should fix his linker script. */
4682 if (hstub
->target_section
!= NULL
4683 && hstub
->target_section
->output_section
== NULL
4684 && info
->non_contiguous_regions
)
4685 info
->callbacks
->einfo (_("%F%P: Could not assign `%pA' to an output section. "
4686 "Retry without --enable-non-contiguous-regions.\n"),
4687 hstub
->target_section
);
4689 loc
= (hstub
->hcsect
->root
.u
.def
.section
->contents
4690 + hstub
->stub_offset
);
4693 switch (hstub
->stub_type
)
4695 case xcoff_stub_indirect_call
:
4696 BFD_ASSERT (hstub
->htarget
->toc_section
!= NULL
);
4697 /* The first instruction in the stub code needs to be
4698 cooked to hold the correct offset in the toc. It will
4699 be filled by xcoff_stub_create_relocations. */
4700 for (i
= 0; i
< bfd_xcoff_stub_indirect_call_size(output_bfd
) / 4; i
++)
4701 bfd_put_32 (stub_bfd
,
4702 (bfd_vma
) bfd_xcoff_stub_indirect_call_code(output_bfd
, i
),
4706 case xcoff_stub_shared_call
:
4707 BFD_ASSERT (hstub
->htarget
->toc_section
!= NULL
);
4708 /* The first instruction in the glink code needs to be
4709 cooked to hold the correct offset in the toc. It will
4710 be filled by xcoff_stub_create_relocations. */
4711 for (i
= 0; i
< bfd_xcoff_stub_shared_call_size(output_bfd
) / 4; i
++)
4712 bfd_put_32 (stub_bfd
,
4713 (bfd_vma
) bfd_xcoff_stub_shared_call_code(output_bfd
, i
),
4725 /* Check relocations and adds stubs if needed. */
4728 bfd_xcoff_size_stubs (struct bfd_link_info
*info
)
4730 struct xcoff_link_hash_table
*htab
= xcoff_hash_table (info
);
4731 struct xcoff_loader_info
*ldinfo
= &(htab
->ldinfo
);
4736 bool stub_changed
= false;
4738 for (input_bfd
= info
->input_bfds
;
4740 input_bfd
= input_bfd
->link
.next
)
4743 bfd_size_type symcount
;
4744 bfd_size_type symesz
;
4747 if (bfd_get_flavour (input_bfd
) != bfd_target_xcoff_flavour
)
4750 symcount
= obj_raw_syment_count (input_bfd
);
4753 symesz
= bfd_coff_symesz (input_bfd
);
4754 esyms
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
4756 /* Walk over each section attached to the input bfd. */
4757 for (section
= input_bfd
->sections
;
4759 section
= section
->next
)
4761 struct internal_reloc
*internal_relocs
;
4762 struct internal_reloc
*irel
, *irelend
;
4764 /* If there aren't any relocs, then there's nothing more
4766 if ((section
->flags
& SEC_RELOC
) == 0
4767 || section
->reloc_count
== 0)
4770 /* If this section is a link-once section that will be
4771 discarded, then don't create any stubs. */
4772 if (section
->output_section
== NULL
4773 || section
->output_section
->owner
!= info
->output_bfd
)
4776 /* This section have been garbage-collected. */
4777 if (section
->gc_mark
== 0)
4780 /* Read in the relocs. */
4781 internal_relocs
= (xcoff_read_internal_relocs
4782 (input_bfd
, section
, true, NULL
,
4784 if (internal_relocs
== NULL
)
4787 irel
= internal_relocs
;
4788 irelend
= irel
+ section
->reloc_count
;
4789 for (; irel
< irelend
; irel
++)
4791 enum xcoff_stub_type stub_type
;
4792 struct xcoff_link_hash_entry
*hsym
= NULL
;
4793 struct xcoff_link_hash_entry
*hstub_csect
= NULL
;
4794 struct xcoff_stub_hash_entry
*hstub
= NULL
;
4797 bfd_vma destination
;
4800 if (irel
->r_symndx
== -1)
4803 switch (irel
->r_type
)
4813 /* Retrieve targeted symbol address */
4814 hsym
= obj_xcoff_sym_hashes (input_bfd
)[irel
->r_symndx
];
4817 struct internal_syment sym
;
4818 if ((long unsigned int)irel
->r_symndx
> symcount
)
4824 bfd_coff_swap_sym_in (input_bfd
,
4825 (void *) esyms
+ irel
->r_symndx
* symesz
,
4828 sym_sec
= xcoff_data (input_bfd
)->csects
[irel
->r_symndx
];
4829 sym_value
= sym
.n_value
- sym_sec
->vma
;
4831 destination
= (sym_value
4832 + sym_sec
->output_section
->vma
4833 + sym_sec
->output_offset
);
4835 else if (hsym
->root
.type
== bfd_link_hash_defined
4836 || hsym
->root
.type
== bfd_link_hash_defweak
)
4838 sym_sec
= hsym
->root
.u
.def
.section
;
4839 sym_value
= hsym
->root
.u
.def
.value
;
4840 destination
= (sym_value
4841 + sym_sec
->output_section
->vma
4842 + sym_sec
->output_offset
);
4846 bfd_set_error (bfd_error_bad_value
);
4850 /* I'm not sure how to handle this case. Skip it for now. */
4851 if (bfd_is_abs_section (sym_sec
))
4854 stub_type
= bfd_xcoff_type_of_stub (section
, irel
, destination
, hsym
);
4856 if (stub_type
== xcoff_stub_none
)
4859 /* Get a stub csect in ranch. */
4860 hstub_csect
= xcoff_stub_get_csect_in_range (section
, info
, true);
4863 /* xgettext:c-format */
4864 _bfd_error_handler (_("%pB: Unable to find a stub csect in range"
4865 "of relocation at %#" PRIx64
" targeting"
4867 section
->owner
, (uint64_t) irel
->r_vaddr
,
4868 hsym
->root
.root
.string
);
4872 /* Get the name of this stub. */
4873 stub_name
= xcoff_stub_name (hsym
, hstub_csect
);
4877 hstub
= xcoff_stub_hash_lookup (&(xcoff_hash_table (info
)->stub_hash_table
),
4878 stub_name
, false, false);
4880 /* A stub entry inside the in range csect already exists. */
4887 stub_changed
= true;
4889 hstub
= xcoff_add_stub (stub_name
, hstub_csect
, hsym
, info
, stub_type
);
4892 /* xgettext:c-format */
4893 _bfd_error_handler (_("%pB: Cannot create stub entry '%s'"),
4894 section
->owner
, stub_name
);
4899 hstub
->stub_type
= stub_type
;
4900 hstub
->hcsect
= hstub_csect
;
4901 hstub
->target_section
= sym_sec
;
4910 /* Update the size of the loader. */
4911 if (xcoff_hash_table (info
)->loader_section
4912 && !xcoff_size_loader_section (ldinfo
))
4915 /* Ask the linker to do its stuff. */
4916 (*htab
->params
->layout_sections_again
) ();
4922 bfd_set_error (bfd_error_bad_value
);
4927 bfd_xcoff_build_stubs (struct bfd_link_info
*info
)
4929 struct xcoff_link_hash_table
*htab
= xcoff_hash_table (info
);
4932 for (stub_sec
= htab
->params
->stub_bfd
->sections
;
4934 stub_sec
= stub_sec
->next
)
4938 /* Allocate memory to hold the linker stubs. */
4939 size
= stub_sec
->size
;
4940 stub_sec
->contents
= bfd_zalloc (htab
->params
->stub_bfd
, size
);
4941 if (stub_sec
->contents
== NULL
&& size
!= 0)
4946 /* Build the stubs as directed by the stub hash table. */
4947 bfd_hash_traverse (&htab
->stub_hash_table
, xcoff_build_one_stub
, info
);
4951 /* Create and apply relocations made by a stub entry. */
4953 xcoff_stub_create_relocations (struct bfd_hash_entry
*bh
, void * inf
)
4955 struct xcoff_stub_hash_entry
*hstub
4956 = (struct xcoff_stub_hash_entry
*) bh
;
4957 struct xcoff_final_link_info
*flinfo
4958 = (struct xcoff_final_link_info
*) inf
;
4961 struct internal_reloc
*irel
;
4962 struct xcoff_link_hash_entry
**rel_hash
;
4963 struct xcoff_link_hash_entry
*htarget
;
4964 asection
*sec
, *osec
;
4968 htarget
= hstub
->htarget
;
4969 sec
= hstub
->hcsect
->root
.u
.def
.section
;
4970 osec
= sec
->output_section
;
4972 irel
= (flinfo
->section_info
[osec
->target_index
].relocs
4973 + osec
->reloc_count
);
4974 rel_hash
= (flinfo
->section_info
[osec
->target_index
].rel_hashes
4975 + osec
->output_section
->reloc_count
);
4977 output_bfd
= flinfo
->output_bfd
;
4979 irel
->r_symndx
= htarget
->indx
;
4980 irel
->r_vaddr
= (osec
->vma
4981 + sec
->output_offset
4982 + hstub
->hcsect
->root
.u
.def
.value
4983 + hstub
->stub_offset
);
4986 + hstub
->stub_offset
);
4988 switch (hstub
->stub_type
)
4994 /* The first instruction of this stub code need
4995 a R_TOC relocation. */
4996 case xcoff_stub_indirect_call
:
4997 case xcoff_stub_shared_call
:
4999 irel
->r_type
= R_TOC
;
5001 /* Retrieve the toc offset of the target which is
5002 a function descriptor. */
5003 BFD_ASSERT (htarget
->toc_section
!= NULL
);
5004 if ((htarget
->flags
& XCOFF_SET_TOC
) != 0)
5005 off
= hstub
->htarget
->u
.toc_offset
;
5007 off
= (htarget
->toc_section
->output_section
->vma
5008 + htarget
->toc_section
->output_offset
5009 - xcoff_data (flinfo
->output_bfd
)->toc
);
5010 if ((off
& 0xffff) != off
)
5013 (_("TOC overflow during stub generation; try -mminimal-toc "
5015 bfd_set_error (bfd_error_file_too_big
);
5019 bfd_put_16 (output_bfd
, off
& 0xffff, p
+2);
5023 ++osec
->reloc_count
;
5028 /* Return the section that defines H. Return null if no section does. */
5031 xcoff_symbol_section (struct xcoff_link_hash_entry
*h
)
5033 switch (h
->root
.type
)
5035 case bfd_link_hash_defined
:
5036 case bfd_link_hash_defweak
:
5037 return h
->root
.u
.def
.section
;
5039 case bfd_link_hash_common
:
5040 return h
->root
.u
.c
.p
->section
;
5047 /* Add a .loader relocation for input relocation IREL. If the loader
5048 relocation should be against an output section, HSEC points to the
5049 input section that IREL is against, otherwise HSEC is null. H is the
5050 symbol that IREL is against, or null if it isn't against a global symbol.
5051 REFERENCE_BFD is the bfd to use in error messages about the relocation. */
5054 xcoff_create_ldrel (bfd
*output_bfd
, struct xcoff_final_link_info
*flinfo
,
5055 asection
*output_section
, bfd
*reference_bfd
,
5056 struct internal_reloc
*irel
, asection
*hsec
,
5057 struct xcoff_link_hash_entry
*h
)
5059 struct internal_ldrel ldrel
;
5061 ldrel
.l_vaddr
= irel
->r_vaddr
;
5064 const char *secname
;
5066 secname
= hsec
->output_section
->name
;
5067 if (strcmp (secname
, ".text") == 0)
5069 else if (strcmp (secname
, ".data") == 0)
5071 else if (strcmp (secname
, ".bss") == 0)
5073 else if (strcmp (secname
, ".tdata") == 0)
5074 ldrel
.l_symndx
= -1;
5075 else if (strcmp (secname
, ".tbss") == 0)
5076 ldrel
.l_symndx
= -2;
5080 /* xgettext:c-format */
5081 (_("%pB: loader reloc in unrecognized section `%s'"),
5082 reference_bfd
, secname
);
5083 bfd_set_error (bfd_error_nonrepresentable_section
);
5092 /* xgettext:c-format */
5093 (_("%pB: `%s' in loader reloc but not loader sym"),
5094 reference_bfd
, h
->root
.root
.string
);
5095 bfd_set_error (bfd_error_bad_value
);
5098 ldrel
.l_symndx
= h
->ldindx
;
5101 ldrel
.l_symndx
= -(bfd_size_type
) 1;
5103 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
5104 ldrel
.l_rsecnm
= output_section
->target_index
;
5105 if (xcoff_hash_table (flinfo
->info
)->textro
5106 && strcmp (output_section
->name
, ".text") == 0)
5109 /* xgettext:c-format */
5110 (_("%pB: loader reloc in read-only section %pA"),
5111 reference_bfd
, output_section
);
5112 bfd_set_error (bfd_error_invalid_operation
);
5115 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, flinfo
->ldrel
);
5116 flinfo
->ldrel
+= bfd_xcoff_ldrelsz (output_bfd
);
5120 /* Link an input file into the linker output file. This function
5121 handles all the sections and relocations of the input file at once. */
5124 xcoff_link_input_bfd (struct xcoff_final_link_info
*flinfo
,
5128 const char *strings
;
5129 bfd_size_type syment_base
;
5130 unsigned int n_tmask
;
5131 unsigned int n_btshft
;
5133 bfd_size_type isymesz
;
5134 bfd_size_type osymesz
;
5135 bfd_size_type linesz
;
5138 struct xcoff_link_hash_entry
**sym_hash
;
5139 struct internal_syment
*isymp
;
5141 unsigned int *lineno_counts
;
5144 unsigned long output_index
;
5151 /* We can just skip DYNAMIC files, unless this is a static link. */
5152 if ((input_bfd
->flags
& DYNAMIC
) != 0
5153 && ! flinfo
->info
->static_link
)
5156 /* Move all the symbols to the output file. */
5157 output_bfd
= flinfo
->output_bfd
;
5159 syment_base
= obj_raw_syment_count (output_bfd
);
5160 isymesz
= bfd_coff_symesz (input_bfd
);
5161 osymesz
= bfd_coff_symesz (output_bfd
);
5162 linesz
= bfd_coff_linesz (input_bfd
);
5163 BFD_ASSERT (linesz
== bfd_coff_linesz (output_bfd
));
5165 n_tmask
= coff_data (input_bfd
)->local_n_tmask
;
5166 n_btshft
= coff_data (input_bfd
)->local_n_btshft
;
5168 /* Define macros so that ISFCN, et. al., macros work correctly. */
5169 #define N_TMASK n_tmask
5170 #define N_BTSHFT n_btshft
5173 if (! flinfo
->info
->keep_memory
)
5176 if (flinfo
->info
->traditional_format
)
5179 if (! _bfd_coff_get_external_symbols (input_bfd
))
5182 /* Make one pass over the symbols and assign indices to symbols that
5183 we have decided to keep. Also use create .loader symbol information
5184 and update information in hash table entries. */
5185 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
5186 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
5187 sym_hash
= obj_xcoff_sym_hashes (input_bfd
);
5188 csectpp
= xcoff_data (input_bfd
)->csects
;
5189 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
5190 isymp
= flinfo
->internal_syms
;
5191 indexp
= flinfo
->sym_indices
;
5192 output_index
= syment_base
;
5193 while (esym
< esym_end
)
5195 union internal_auxent aux
;
5199 bfd_coff_swap_sym_in (input_bfd
, (void *) esym
, (void *) isymp
);
5201 /* Read in the csect information, if any. */
5202 if (CSECT_SYM_P (isymp
->n_sclass
))
5204 BFD_ASSERT (isymp
->n_numaux
> 0);
5205 bfd_coff_swap_aux_in (input_bfd
,
5206 (void *) (esym
+ isymesz
* isymp
->n_numaux
),
5207 isymp
->n_type
, isymp
->n_sclass
,
5208 isymp
->n_numaux
- 1, isymp
->n_numaux
,
5211 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
5214 /* If this symbol is in the .loader section, swap out the
5215 .loader symbol information. If this is an external symbol
5216 reference to a defined symbol, though, then wait until we get
5217 to the definition. */
5218 if (EXTERN_SYM_P (isymp
->n_sclass
)
5219 && *sym_hash
!= NULL
5220 && (*sym_hash
)->ldsym
!= NULL
5221 && xcoff_final_definition_p (input_bfd
, *sym_hash
, *csectpp
))
5223 struct xcoff_link_hash_entry
*h
;
5224 struct internal_ldsym
*ldsym
;
5228 if (isymp
->n_scnum
> 0)
5230 ldsym
->l_scnum
= (*csectpp
)->output_section
->target_index
;
5231 ldsym
->l_value
= (isymp
->n_value
5232 + (*csectpp
)->output_section
->vma
5233 + (*csectpp
)->output_offset
5238 ldsym
->l_scnum
= isymp
->n_scnum
;
5239 ldsym
->l_value
= isymp
->n_value
;
5242 ldsym
->l_smtype
= smtyp
;
5243 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
5244 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
5245 || (h
->flags
& XCOFF_IMPORT
) != 0)
5246 ldsym
->l_smtype
|= L_IMPORT
;
5247 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
5248 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
5249 || (h
->flags
& XCOFF_EXPORT
) != 0)
5250 ldsym
->l_smtype
|= L_EXPORT
;
5251 if ((h
->flags
& XCOFF_ENTRY
) != 0)
5252 ldsym
->l_smtype
|= L_ENTRY
;
5253 if (isymp
->n_sclass
== C_AIX_WEAKEXT
)
5254 ldsym
->l_smtype
|= L_WEAK
;
5256 ldsym
->l_smclas
= aux
.x_csect
.x_smclas
;
5258 if (ldsym
->l_ifile
== (bfd_size_type
) -1)
5260 else if (ldsym
->l_ifile
== 0)
5262 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
5268 if (h
->root
.type
== bfd_link_hash_defined
5269 || h
->root
.type
== bfd_link_hash_defweak
)
5270 impbfd
= h
->root
.u
.def
.section
->owner
;
5271 else if (h
->root
.type
== bfd_link_hash_undefined
5272 || h
->root
.type
== bfd_link_hash_undefweak
)
5273 impbfd
= h
->root
.u
.undef
.abfd
;
5281 BFD_ASSERT (impbfd
->xvec
== flinfo
->output_bfd
->xvec
);
5282 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
5289 BFD_ASSERT (h
->ldindx
>= 0);
5290 bfd_xcoff_swap_ldsym_out (flinfo
->output_bfd
, ldsym
,
5293 * bfd_xcoff_ldsymsz (flinfo
->output_bfd
))));
5296 /* Fill in snentry now that we know the target_index. */
5297 if ((h
->flags
& XCOFF_ENTRY
) != 0
5298 && (h
->root
.type
== bfd_link_hash_defined
5299 || h
->root
.type
== bfd_link_hash_defweak
))
5301 xcoff_data (output_bfd
)->snentry
=
5302 h
->root
.u
.def
.section
->output_section
->target_index
;
5306 add
= 1 + isymp
->n_numaux
;
5308 if (*debug_index
== -2)
5309 /* We've decided to strip this symbol. */
5313 /* Assign the next unused index to this symbol. */
5314 *indexp
= output_index
;
5316 if (EXTERN_SYM_P (isymp
->n_sclass
))
5318 BFD_ASSERT (*sym_hash
!= NULL
);
5319 (*sym_hash
)->indx
= output_index
;
5322 /* If this is a symbol in the TOC which we may have merged
5323 (class XMC_TC), remember the symbol index of the TOC
5325 if (isymp
->n_sclass
== C_HIDEXT
5326 && aux
.x_csect
.x_smclas
== XMC_TC
5327 && *sym_hash
!= NULL
)
5329 BFD_ASSERT (((*sym_hash
)->flags
& XCOFF_SET_TOC
) == 0);
5330 BFD_ASSERT ((*sym_hash
)->toc_section
!= NULL
);
5331 (*sym_hash
)->u
.toc_indx
= output_index
;
5334 output_index
+= add
;
5337 esym
+= add
* isymesz
;
5343 for (--add
; add
> 0; --add
)
5347 /* Now write out the symbols that we decided to keep. */
5349 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
5350 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
5351 sym_hash
= obj_xcoff_sym_hashes (input_bfd
);
5352 isymp
= flinfo
->internal_syms
;
5353 indexp
= flinfo
->sym_indices
;
5354 csectpp
= xcoff_data (input_bfd
)->csects
;
5355 lineno_counts
= xcoff_data (input_bfd
)->lineno_counts
;
5356 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
5357 outsym
= flinfo
->outsyms
;
5360 while (esym
< esym_end
)
5364 add
= 1 + isymp
->n_numaux
;
5367 esym
+= add
* isymesz
;
5370 struct internal_syment isym
;
5373 /* Adjust the symbol in order to output it. */
5375 if (isym
._n
._n_n
._n_zeroes
== 0
5376 && isym
._n
._n_n
._n_offset
!= 0)
5378 /* This symbol has a long name. Enter it in the string
5379 table we are building. If *debug_index != -1, the
5380 name has already been entered in the .debug section. */
5381 if (*debug_index
>= 0)
5382 isym
._n
._n_n
._n_offset
= *debug_index
;
5388 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, NULL
);
5392 indx
= _bfd_stringtab_add (flinfo
->strtab
, name
, hash
, copy
);
5393 if (indx
== (bfd_size_type
) -1)
5395 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
5399 /* Make __rtinit C_HIDEXT rather than C_EXT. This avoids
5400 multiple definition problems when linking a shared object
5401 statically. (The native linker doesn't enter __rtinit into
5402 the normal table at all, but having a local symbol can make
5403 the objdump output easier to read.) */
5404 if (isym
.n_sclass
== C_EXT
5406 && ((*sym_hash
)->flags
& XCOFF_RTINIT
) != 0)
5407 isym
.n_sclass
= C_HIDEXT
;
5409 /* The value of a C_FILE symbol is the symbol index of the
5410 next C_FILE symbol. The value of the last C_FILE symbol
5411 is -1. We try to get this right, below, just before we
5412 write the symbols out, but in the general case we may
5413 have to write the symbol out twice. */
5414 if (isym
.n_sclass
== C_FILE
)
5416 if (flinfo
->last_file_index
!= -1
5417 && flinfo
->last_file
.n_value
!= (bfd_vma
) *indexp
)
5419 /* We must correct the value of the last C_FILE entry. */
5420 flinfo
->last_file
.n_value
= *indexp
;
5421 if ((bfd_size_type
) flinfo
->last_file_index
>= syment_base
)
5423 /* The last C_FILE symbol is in this input file. */
5424 bfd_coff_swap_sym_out (output_bfd
,
5425 (void *) &flinfo
->last_file
,
5426 (void *) (flinfo
->outsyms
5427 + ((flinfo
->last_file_index
5433 /* We have already written out the last C_FILE
5434 symbol. We need to write it out again. We
5435 borrow *outsym temporarily. */
5438 bfd_coff_swap_sym_out (output_bfd
,
5439 (void *) &flinfo
->last_file
,
5442 pos
= obj_sym_filepos (output_bfd
);
5443 pos
+= flinfo
->last_file_index
* osymesz
;
5444 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5445 || (bfd_bwrite (outsym
, osymesz
, output_bfd
)
5451 flinfo
->last_file_index
= *indexp
;
5452 flinfo
->last_file
= isym
;
5455 /* The value of a C_BINCL or C_EINCL symbol is a file offset
5456 into the line numbers. We update the symbol values when
5457 we handle the line numbers. */
5458 if (isym
.n_sclass
== C_BINCL
5459 || isym
.n_sclass
== C_EINCL
)
5461 isym
.n_value
= flinfo
->line_filepos
;
5464 /* The value of a C_BSTAT symbol is the symbol table
5465 index of the containing csect. */
5466 else if (isym
.n_sclass
== C_BSTAT
)
5470 indx
= isym
.n_value
;
5471 if (indx
< obj_raw_syment_count (input_bfd
))
5475 symindx
= flinfo
->sym_indices
[indx
];
5479 isym
.n_value
= symindx
;
5482 else if (isym
.n_sclass
!= C_ESTAT
5483 && isym
.n_sclass
!= C_DECL
5484 && isym
.n_scnum
> 0)
5486 isym
.n_scnum
= (*csectpp
)->output_section
->target_index
;
5487 isym
.n_value
+= ((*csectpp
)->output_section
->vma
5488 + (*csectpp
)->output_offset
5492 /* Update visibility. */
5495 isym
.n_type
&= ~SYM_V_MASK
;
5496 isym
.n_type
|= (*sym_hash
)->visibility
;
5499 /* Output the symbol. */
5500 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
5505 for (i
= 0; i
< isymp
->n_numaux
&& esym
< esym_end
; i
++)
5507 union internal_auxent aux
;
5509 bfd_coff_swap_aux_in (input_bfd
, (void *) esym
, isymp
->n_type
,
5510 isymp
->n_sclass
, i
, isymp
->n_numaux
,
5513 if (isymp
->n_sclass
== C_FILE
)
5515 /* This is the file name (or some comment put in by
5516 the compiler). If it is long, we must put it in
5517 the string table. */
5518 if (aux
.x_file
.x_n
.x_n
.x_zeroes
== 0
5519 && aux
.x_file
.x_n
.x_n
.x_offset
!= 0)
5521 const char *filename
;
5524 BFD_ASSERT (aux
.x_file
.x_n
.x_n
.x_offset
5525 >= STRING_SIZE_SIZE
);
5526 if (strings
== NULL
)
5528 strings
= _bfd_coff_read_string_table (input_bfd
);
5529 if (strings
== NULL
)
5532 if ((bfd_size_type
) aux
.x_file
.x_n
.x_n
.x_offset
>= obj_coff_strings_len (input_bfd
))
5533 filename
= _("<corrupt>");
5535 filename
= strings
+ aux
.x_file
.x_n
.x_n
.x_offset
;
5536 indx
= _bfd_stringtab_add (flinfo
->strtab
, filename
,
5538 if (indx
== (bfd_size_type
) -1)
5540 aux
.x_file
.x_n
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
5543 else if (CSECT_SYM_P (isymp
->n_sclass
)
5544 && i
+ 1 == isymp
->n_numaux
)
5547 /* We don't support type checking. I don't know if
5549 aux
.x_csect
.x_parmhash
= 0;
5550 /* I don't think anybody uses these fields, but we'd
5551 better clobber them just in case. */
5552 aux
.x_csect
.x_stab
= 0;
5553 aux
.x_csect
.x_snstab
= 0;
5555 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_LD
)
5559 indx
= aux
.x_csect
.x_scnlen
.l
;
5560 if (indx
< obj_raw_syment_count (input_bfd
))
5564 symindx
= flinfo
->sym_indices
[indx
];
5567 aux
.x_csect
.x_scnlen
.l
= 0;
5571 aux
.x_csect
.x_scnlen
.l
= symindx
;
5576 else if (isymp
->n_sclass
!= C_STAT
|| isymp
->n_type
!= T_NULL
)
5580 if (ISFCN (isymp
->n_type
)
5581 || ISTAG (isymp
->n_sclass
)
5582 || isymp
->n_sclass
== C_BLOCK
5583 || isymp
->n_sclass
== C_FCN
)
5585 indx
= aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
5587 && indx
< obj_raw_syment_count (input_bfd
))
5589 /* We look forward through the symbol for
5590 the index of the next symbol we are going
5591 to include. I don't know if this is
5593 while (flinfo
->sym_indices
[indx
] < 0
5594 && indx
< obj_raw_syment_count (input_bfd
))
5596 if (indx
>= obj_raw_syment_count (input_bfd
))
5597 indx
= output_index
;
5599 indx
= flinfo
->sym_indices
[indx
];
5600 aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= indx
;
5605 indx
= aux
.x_sym
.x_tagndx
.l
;
5606 if (indx
> 0 && indx
< obj_raw_syment_count (input_bfd
))
5610 symindx
= flinfo
->sym_indices
[indx
];
5612 aux
.x_sym
.x_tagndx
.l
= 0;
5614 aux
.x_sym
.x_tagndx
.l
= symindx
;
5619 /* Copy over the line numbers, unless we are stripping
5620 them. We do this on a symbol by symbol basis in
5621 order to more easily handle garbage collection. */
5622 if (CSECT_SYM_P (isymp
->n_sclass
)
5624 && isymp
->n_numaux
> 1
5625 && ISFCN (isymp
->n_type
)
5626 && aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
5628 if (*lineno_counts
== 0)
5629 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
5632 asection
*enclosing
;
5633 unsigned int enc_count
;
5634 bfd_signed_vma linoff
;
5635 struct internal_lineno lin
;
5642 /* Read in the enclosing section's line-number
5643 information, if we haven't already. */
5645 enclosing
= xcoff_section_data (abfd
, o
)->enclosing
;
5646 enc_count
= xcoff_section_data (abfd
, o
)->lineno_count
;
5647 if (oline
!= enclosing
)
5649 pos
= enclosing
->line_filepos
;
5650 amt
= linesz
* enc_count
;
5651 if (bfd_seek (input_bfd
, pos
, SEEK_SET
) != 0
5652 || (bfd_bread (flinfo
->linenos
, amt
, input_bfd
)
5658 /* Copy across the first entry, adjusting its
5660 linoff
= (aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
5661 - enclosing
->line_filepos
);
5662 linp
= flinfo
->linenos
+ linoff
;
5663 bfd_coff_swap_lineno_in (input_bfd
, linp
, &lin
);
5664 lin
.l_addr
.l_symndx
= *indexp
;
5665 bfd_coff_swap_lineno_out (output_bfd
, &lin
, linp
);
5667 /* Copy the other entries, adjusting their addresses. */
5668 linpend
= linp
+ *lineno_counts
* linesz
;
5669 offset
= (o
->output_section
->vma
5672 for (linp
+= linesz
; linp
< linpend
; linp
+= linesz
)
5674 bfd_coff_swap_lineno_in (input_bfd
, linp
, &lin
);
5675 lin
.l_addr
.l_paddr
+= offset
;
5676 bfd_coff_swap_lineno_out (output_bfd
, &lin
, linp
);
5679 /* Write out the entries we've just processed. */
5680 pos
= (o
->output_section
->line_filepos
5681 + o
->output_section
->lineno_count
* linesz
);
5682 amt
= linesz
* *lineno_counts
;
5683 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5684 || bfd_bwrite (flinfo
->linenos
+ linoff
,
5685 amt
, output_bfd
) != amt
)
5687 o
->output_section
->lineno_count
+= *lineno_counts
;
5689 /* Record the offset of the symbol's line numbers
5690 in the output file. */
5691 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= pos
;
5695 struct internal_syment
*iisp
, *iispend
;
5698 bfd_vma range_start
, range_end
;
5701 /* Update any C_BINCL or C_EINCL symbols
5702 that refer to a line number in the
5703 range we just output. */
5704 iisp
= flinfo
->internal_syms
;
5705 iispend
= iisp
+ obj_raw_syment_count (input_bfd
);
5706 iindp
= flinfo
->sym_indices
;
5707 oos
= flinfo
->outsyms
;
5708 range_start
= enclosing
->line_filepos
+ linoff
;
5709 range_end
= range_start
+ *lineno_counts
* linesz
;
5710 while (iisp
< iispend
)
5713 && (iisp
->n_sclass
== C_BINCL
5714 || iisp
->n_sclass
== C_EINCL
)
5715 && iisp
->n_value
>= range_start
5716 && iisp
->n_value
< range_end
)
5718 struct internal_syment iis
;
5720 bfd_coff_swap_sym_in (output_bfd
, oos
, &iis
);
5721 iis
.n_value
= (iisp
->n_value
5724 bfd_coff_swap_sym_out (output_bfd
,
5729 iiadd
= 1 + iisp
->n_numaux
;
5731 oos
+= iiadd
* osymesz
;
5739 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, isymp
->n_type
,
5740 isymp
->n_sclass
, i
, isymp
->n_numaux
,
5751 lineno_counts
+= add
;
5755 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
5756 symbol will be the first symbol in the next input file. In the
5757 normal case, this will save us from writing out the C_FILE symbol
5759 if (flinfo
->last_file_index
!= -1
5760 && (bfd_size_type
) flinfo
->last_file_index
>= syment_base
)
5762 flinfo
->last_file
.n_value
= output_index
;
5763 bfd_coff_swap_sym_out (output_bfd
, (void *) &flinfo
->last_file
,
5764 (void *) (flinfo
->outsyms
5765 + ((flinfo
->last_file_index
- syment_base
)
5769 /* Write the modified symbols to the output file. */
5770 if (outsym
> flinfo
->outsyms
)
5772 file_ptr pos
= obj_sym_filepos (output_bfd
) + syment_base
* osymesz
;
5773 bfd_size_type amt
= outsym
- flinfo
->outsyms
;
5774 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5775 || bfd_bwrite (flinfo
->outsyms
, amt
, output_bfd
) != amt
)
5778 BFD_ASSERT ((obj_raw_syment_count (output_bfd
)
5779 + (outsym
- flinfo
->outsyms
) / osymesz
)
5782 obj_raw_syment_count (output_bfd
) = output_index
;
5785 /* Don't let the linker relocation routines discard the symbols. */
5786 keep_syms
= obj_coff_keep_syms (input_bfd
);
5787 obj_coff_keep_syms (input_bfd
) = true;
5789 /* Relocate the contents of each section. */
5790 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5794 if (! o
->linker_mark
)
5795 /* This section was omitted from the link. */
5798 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5800 || (o
->flags
& SEC_IN_MEMORY
) != 0)
5803 /* We have set filepos correctly for the sections we created to
5804 represent csects, so bfd_get_section_contents should work. */
5805 if (coff_section_data (input_bfd
, o
) != NULL
5806 && coff_section_data (input_bfd
, o
)->contents
!= NULL
)
5807 contents
= coff_section_data (input_bfd
, o
)->contents
;
5810 bfd_size_type sz
= o
->rawsize
? o
->rawsize
: o
->size
;
5811 if (!bfd_get_section_contents (input_bfd
, o
, flinfo
->contents
, 0, sz
))
5813 contents
= flinfo
->contents
;
5816 if ((o
->flags
& SEC_RELOC
) != 0)
5819 struct internal_reloc
*internal_relocs
;
5820 struct internal_reloc
*irel
;
5822 struct internal_reloc
*irelend
;
5823 struct xcoff_link_hash_entry
**rel_hash
;
5826 /* Read in the relocs. */
5827 target_index
= o
->output_section
->target_index
;
5828 internal_relocs
= (xcoff_read_internal_relocs
5829 (input_bfd
, o
, false, flinfo
->external_relocs
,
5831 (flinfo
->section_info
[target_index
].relocs
5832 + o
->output_section
->reloc_count
)));
5833 if (internal_relocs
== NULL
)
5836 /* Call processor specific code to relocate the section
5838 if (! bfd_coff_relocate_section (output_bfd
, flinfo
->info
,
5842 flinfo
->internal_syms
,
5843 xcoff_data (input_bfd
)->csects
))
5846 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
5847 irel
= internal_relocs
;
5848 irelend
= irel
+ o
->reloc_count
;
5849 rel_hash
= (flinfo
->section_info
[target_index
].rel_hashes
5850 + o
->output_section
->reloc_count
);
5851 for (; irel
< irelend
; irel
++, rel_hash
++)
5853 struct xcoff_link_hash_entry
*h
= NULL
;
5857 /* Adjust the reloc address and symbol index. */
5859 r_symndx
= irel
->r_symndx
;
5864 h
= obj_xcoff_sym_hashes (input_bfd
)[r_symndx
];
5866 /* In case of a R_BR or R_RBR, change the target if
5867 a stub is being called. */
5869 && (irel
->r_type
== R_BR
5870 || irel
->r_type
== R_RBR
))
5874 struct xcoff_stub_hash_entry
*hstub
= NULL
;
5875 enum xcoff_stub_type stub_type
;
5877 if (h
->root
.type
== bfd_link_hash_defined
5878 || h
->root
.type
== bfd_link_hash_defweak
)
5880 sym_sec
= h
->root
.u
.def
.section
;
5881 dest
= (h
->root
.u
.def
.value
5882 + sym_sec
->output_section
->vma
5883 + sym_sec
->output_offset
);
5891 stub_type
= bfd_xcoff_type_of_stub (o
, irel
, dest
, h
);
5892 if (stub_type
!= xcoff_stub_none
)
5894 hstub
= bfd_xcoff_get_stub_entry (o
, h
, flinfo
->info
);
5903 irel
->r_vaddr
+= offset
;
5905 if (r_symndx
!= -1 && flinfo
->info
->strip
!= strip_all
)
5909 && h
->smclas
!= XMC_TD
5910 && (irel
->r_type
== R_TOC
5911 || irel
->r_type
== R_GL
5912 || irel
->r_type
== R_TCL
5913 || irel
->r_type
== R_TRL
5914 || irel
->r_type
== R_TRLA
))
5916 /* This is a TOC relative reloc with a symbol
5917 attached. The symbol should be the one which
5918 this reloc is for. We want to make this
5919 reloc against the TOC address of the symbol,
5920 not the symbol itself. */
5921 BFD_ASSERT (h
->toc_section
!= NULL
);
5922 BFD_ASSERT ((h
->flags
& XCOFF_SET_TOC
) == 0);
5923 if (h
->u
.toc_indx
!= -1)
5924 irel
->r_symndx
= h
->u
.toc_indx
;
5927 struct xcoff_toc_rel_hash
*n
;
5928 struct xcoff_link_section_info
*si
;
5932 n
= bfd_alloc (flinfo
->output_bfd
, amt
);
5935 si
= flinfo
->section_info
+ target_index
;
5936 n
->next
= si
->toc_rel_hashes
;
5939 si
->toc_rel_hashes
= n
;
5944 /* This is a global symbol. */
5946 irel
->r_symndx
= h
->indx
;
5949 /* This symbol is being written at the end
5950 of the file, and we do not yet know the
5951 symbol index. We save the pointer to the
5952 hash table entry in the rel_hash list.
5953 We set the indx field to -2 to indicate
5954 that this symbol must not be stripped. */
5963 indx
= flinfo
->sym_indices
[r_symndx
];
5967 struct internal_syment
*is
;
5969 /* Relocations against a TC0 TOC anchor are
5970 automatically transformed to be against
5971 the TOC anchor in the output file. */
5972 is
= flinfo
->internal_syms
+ r_symndx
;
5973 if (is
->n_sclass
== C_HIDEXT
5974 && is
->n_numaux
> 0)
5977 union internal_auxent aux
;
5981 obj_coff_external_syms (input_bfd
))
5982 + ((r_symndx
+ is
->n_numaux
)
5984 bfd_coff_swap_aux_in (input_bfd
, auxptr
,
5985 is
->n_type
, is
->n_sclass
,
5989 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_SD
5990 && aux
.x_csect
.x_smclas
== XMC_TC0
)
5991 indx
= flinfo
->toc_symindx
;
5996 irel
->r_symndx
= indx
;
6000 struct internal_syment
*is
;
6003 char buf
[SYMNMLEN
+ 1];
6005 /* This reloc is against a symbol we are
6006 stripping. It would be possible to handle
6007 this case, but I don't think it's worth it. */
6008 is
= flinfo
->internal_syms
+ r_symndx
;
6010 if (is
->n_sclass
!= C_DWARF
)
6012 name
= (_bfd_coff_internal_syment_name
6013 (input_bfd
, is
, buf
));
6018 (*flinfo
->info
->callbacks
->unattached_reloc
)
6019 (flinfo
->info
, name
,
6020 input_bfd
, o
, irel
->r_vaddr
);
6026 if ((o
->flags
& SEC_DEBUGGING
) == 0
6027 && xcoff_need_ldrel_p (flinfo
->info
, irel
, h
, o
))
6034 sec
= xcoff_data (input_bfd
)->csects
[r_symndx
];
6036 sec
= xcoff_symbol_section (h
);
6037 if (!xcoff_create_ldrel (output_bfd
, flinfo
,
6038 o
->output_section
, input_bfd
,
6044 o
->output_section
->reloc_count
+= o
->reloc_count
;
6047 /* Write out the modified section contents. */
6048 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6049 contents
, (file_ptr
) o
->output_offset
,
6054 obj_coff_keep_syms (input_bfd
) = keep_syms
;
6056 if (! flinfo
->info
->keep_memory
)
6058 if (! _bfd_coff_free_symbols (input_bfd
))
6065 obj_coff_keep_syms (input_bfd
) = keep_syms
;
6072 /* Sort relocs by VMA. This is called via qsort. */
6075 xcoff_sort_relocs (const void * p1
, const void * p2
)
6077 const struct internal_reloc
*r1
= (const struct internal_reloc
*) p1
;
6078 const struct internal_reloc
*r2
= (const struct internal_reloc
*) p2
;
6080 if (r1
->r_vaddr
> r2
->r_vaddr
)
6082 else if (r1
->r_vaddr
< r2
->r_vaddr
)
6088 /* Return true if section SEC is a TOC section. */
6091 xcoff_toc_section_p (asection
*sec
)
6096 if (name
[0] == '.' && name
[1] == 't')
6100 if (name
[3] == '0' && name
[4] == 0)
6105 if (name
[2] == 'd' && name
[3] == 0)
6111 /* See if the link requires a TOC (it usually does!). If so, find a
6112 good place to put the TOC anchor csect, and write out the associated
6116 xcoff_find_tc0 (bfd
*output_bfd
, struct xcoff_final_link_info
*flinfo
)
6118 bfd_vma toc_start
, toc_end
, start
, end
, best_address
;
6122 struct internal_syment irsym
;
6123 union internal_auxent iraux
;
6127 /* Set [TOC_START, TOC_END) to the range of the TOC. Record the
6128 index of a csect at the beginning of the TOC. */
6129 toc_start
= ~(bfd_vma
) 0;
6132 for (input_bfd
= flinfo
->info
->input_bfds
;
6134 input_bfd
= input_bfd
->link
.next
)
6135 for (sec
= input_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6136 if (sec
->gc_mark
!= 0 && xcoff_toc_section_p (sec
))
6138 start
= sec
->output_section
->vma
+ sec
->output_offset
;
6139 if (toc_start
> start
)
6142 section_index
= sec
->output_section
->target_index
;
6145 end
= start
+ sec
->size
;
6150 /* There's no need for a TC0 symbol if we don't have a TOC. */
6151 if (toc_end
< toc_start
)
6153 xcoff_data (output_bfd
)->toc
= toc_start
;
6157 if (toc_end
- toc_start
< 0x8000)
6158 /* Every TOC csect can be accessed from TOC_START. */
6159 best_address
= toc_start
;
6162 /* Find the lowest TOC csect that is still within range of TOC_END. */
6163 best_address
= toc_end
;
6164 for (input_bfd
= flinfo
->info
->input_bfds
;
6166 input_bfd
= input_bfd
->link
.next
)
6167 for (sec
= input_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6168 if (sec
->gc_mark
!= 0 && xcoff_toc_section_p (sec
))
6170 start
= sec
->output_section
->vma
+ sec
->output_offset
;
6171 if (start
< best_address
6172 && start
+ 0x8000 >= toc_end
)
6174 best_address
= start
;
6175 section_index
= sec
->output_section
->target_index
;
6179 /* Make sure that the start of the TOC is also within range. */
6180 if (best_address
> toc_start
+ 0x8000)
6183 (_("TOC overflow: %#" PRIx64
" > 0x10000; try -mminimal-toc "
6185 (uint64_t) (toc_end
- toc_start
));
6186 bfd_set_error (bfd_error_file_too_big
);
6191 /* Record the chosen TOC value. */
6192 flinfo
->toc_symindx
= obj_raw_syment_count (output_bfd
);
6193 xcoff_data (output_bfd
)->toc
= best_address
;
6194 xcoff_data (output_bfd
)->sntoc
= section_index
;
6196 /* Fill out the TC0 symbol. */
6197 if (!bfd_xcoff_put_symbol_name (output_bfd
, flinfo
->info
, flinfo
->strtab
,
6200 irsym
.n_value
= best_address
;
6201 irsym
.n_scnum
= section_index
;
6202 irsym
.n_sclass
= C_HIDEXT
;
6203 irsym
.n_type
= T_NULL
;
6205 bfd_coff_swap_sym_out (output_bfd
, &irsym
, flinfo
->outsyms
);
6207 /* Fill out the auxiliary csect information. */
6208 memset (&iraux
, 0, sizeof iraux
);
6209 iraux
.x_csect
.x_smtyp
= XTY_SD
;
6210 iraux
.x_csect
.x_smclas
= XMC_TC0
;
6211 iraux
.x_csect
.x_scnlen
.l
= 0;
6212 bfd_coff_swap_aux_out (output_bfd
, &iraux
, T_NULL
, C_HIDEXT
, 0, 1,
6213 flinfo
->outsyms
+ bfd_coff_symesz (output_bfd
));
6215 /* Write the contents to the file. */
6216 pos
= obj_sym_filepos (output_bfd
);
6217 pos
+= obj_raw_syment_count (output_bfd
) * bfd_coff_symesz (output_bfd
);
6218 size
= 2 * bfd_coff_symesz (output_bfd
);
6219 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
6220 || bfd_bwrite (flinfo
->outsyms
, size
, output_bfd
) != size
)
6222 obj_raw_syment_count (output_bfd
) += 2;
6227 /* Write out a non-XCOFF global symbol. */
6230 xcoff_write_global_symbol (struct bfd_hash_entry
*bh
, void * inf
)
6232 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) bh
;
6233 struct xcoff_final_link_info
*flinfo
= (struct xcoff_final_link_info
*) inf
;
6236 struct internal_syment isym
;
6237 union internal_auxent aux
;
6242 output_bfd
= flinfo
->output_bfd
;
6243 outsym
= flinfo
->outsyms
;
6245 if (h
->root
.type
== bfd_link_hash_warning
)
6247 h
= (struct xcoff_link_hash_entry
*) h
->root
.u
.i
.link
;
6248 if (h
->root
.type
== bfd_link_hash_new
)
6252 /* If this symbol was garbage collected, just skip it. */
6253 if (xcoff_hash_table (flinfo
->info
)->gc
6254 && (h
->flags
& XCOFF_MARK
) == 0)
6257 /* If we need a .loader section entry, write it out. */
6258 if (h
->ldsym
!= NULL
)
6260 struct internal_ldsym
*ldsym
;
6265 if (h
->root
.type
== bfd_link_hash_undefined
6266 || h
->root
.type
== bfd_link_hash_undefweak
)
6270 ldsym
->l_scnum
= N_UNDEF
;
6271 ldsym
->l_smtype
= XTY_ER
;
6272 impbfd
= h
->root
.u
.undef
.abfd
;
6275 else if (h
->root
.type
== bfd_link_hash_defined
6276 || h
->root
.type
== bfd_link_hash_defweak
)
6280 sec
= h
->root
.u
.def
.section
;
6281 ldsym
->l_value
= (sec
->output_section
->vma
6282 + sec
->output_offset
6283 + h
->root
.u
.def
.value
);
6284 ldsym
->l_scnum
= sec
->output_section
->target_index
;
6285 ldsym
->l_smtype
= XTY_SD
;
6286 impbfd
= sec
->owner
;
6292 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
6293 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
6294 || (h
->flags
& XCOFF_IMPORT
) != 0)
6296 Import symbols are defined so the check above will make
6297 the l_smtype XTY_SD. But this is not correct, it should
6299 ldsym
->l_smtype
|= L_IMPORT
;
6301 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
6302 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
6303 || (h
->flags
& XCOFF_EXPORT
) != 0)
6304 ldsym
->l_smtype
|= L_EXPORT
;
6306 if ((h
->flags
& XCOFF_ENTRY
) != 0)
6307 ldsym
->l_smtype
|= L_ENTRY
;
6309 if ((h
->flags
& XCOFF_RTINIT
) != 0)
6310 ldsym
->l_smtype
= XTY_SD
;
6312 ldsym
->l_smclas
= h
->smclas
;
6314 if (ldsym
->l_smtype
& L_IMPORT
)
6316 if ((h
->root
.type
== bfd_link_hash_defined
6317 || h
->root
.type
== bfd_link_hash_defweak
)
6318 && (h
->root
.u
.def
.value
!= 0))
6319 ldsym
->l_smclas
= XMC_XO
;
6321 else if ((h
->flags
& (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
)) ==
6322 (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
))
6323 ldsym
->l_smclas
= XMC_SV3264
;
6325 else if (h
->flags
& XCOFF_SYSCALL32
)
6326 ldsym
->l_smclas
= XMC_SV
;
6328 else if (h
->flags
& XCOFF_SYSCALL64
)
6329 ldsym
->l_smclas
= XMC_SV64
;
6332 if (ldsym
->l_ifile
== -(bfd_size_type
) 1)
6336 else if (ldsym
->l_ifile
== 0)
6338 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
6340 else if (impbfd
== NULL
)
6344 BFD_ASSERT (impbfd
->xvec
== output_bfd
->xvec
);
6345 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
6351 BFD_ASSERT (h
->ldindx
>= 0);
6353 bfd_xcoff_swap_ldsym_out (output_bfd
, ldsym
,
6356 * bfd_xcoff_ldsymsz(flinfo
->output_bfd
)));
6360 /* If this symbol needs global linkage code, write it out. */
6361 if (h
->root
.type
== bfd_link_hash_defined
6362 && (h
->root
.u
.def
.section
6363 == xcoff_hash_table (flinfo
->info
)->linkage_section
))
6369 p
= h
->root
.u
.def
.section
->contents
+ h
->root
.u
.def
.value
;
6371 /* The first instruction in the global linkage code loads a
6372 specific TOC element. */
6373 tocoff
= (h
->descriptor
->toc_section
->output_section
->vma
6374 + h
->descriptor
->toc_section
->output_offset
6375 - xcoff_data (output_bfd
)->toc
);
6377 if ((h
->descriptor
->flags
& XCOFF_SET_TOC
) != 0)
6378 tocoff
+= h
->descriptor
->u
.toc_offset
;
6380 /* The first instruction in the glink code needs to be
6381 cooked to hold the correct offset in the toc. The
6382 rest are just output raw. */
6383 bfd_put_32 (output_bfd
,
6384 bfd_xcoff_glink_code(output_bfd
, 0) | (tocoff
& 0xffff), p
);
6386 /* Start with i == 1 to get past the first instruction done above
6387 The /4 is because the glink code is in bytes and we are going
6389 for (i
= 1; i
< bfd_xcoff_glink_code_size(output_bfd
) / 4; i
++)
6390 bfd_put_32 (output_bfd
,
6391 (bfd_vma
) bfd_xcoff_glink_code(output_bfd
, i
),
6395 /* If we created a TOC entry for this symbol, write out the required
6397 if ((h
->flags
& XCOFF_SET_TOC
) != 0)
6402 struct internal_reloc
*irel
;
6403 struct internal_syment irsym
;
6404 union internal_auxent iraux
;
6406 tocsec
= h
->toc_section
;
6407 osec
= tocsec
->output_section
;
6408 oindx
= osec
->target_index
;
6409 irel
= flinfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
6410 irel
->r_vaddr
= (osec
->vma
6411 + tocsec
->output_offset
6415 irel
->r_symndx
= h
->indx
;
6419 irel
->r_symndx
= obj_raw_syment_count (output_bfd
);
6422 /* Initialize the aux union here instead of closer to when it is
6423 written out below because the length of the csect depends on
6424 whether the output is 32 or 64 bit. */
6425 memset (&iraux
, 0, sizeof iraux
);
6426 iraux
.x_csect
.x_smtyp
= XTY_SD
;
6427 /* iraux.x_csect.x_scnlen.l = 4 or 8, see below. */
6428 iraux
.x_csect
.x_smclas
= XMC_TC
;
6430 /* 32 bit uses a 32 bit R_POS to do the relocations
6431 64 bit uses a 64 bit R_POS to do the relocations
6433 Also needs to change the csect size : 4 for 32 bit, 8 for 64 bit
6435 Which one is determined by the backend. */
6436 if (bfd_xcoff_is_xcoff64 (output_bfd
))
6439 iraux
.x_csect
.x_scnlen
.l
= 8;
6441 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
6444 iraux
.x_csect
.x_scnlen
.l
= 4;
6449 irel
->r_type
= R_POS
;
6450 flinfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
6451 ++osec
->reloc_count
;
6453 /* There are two kind of linker-created TOC entry.
6454 The ones importing their symbols from outside, made for the
6455 global linkage. These symbols have XCOFF_LDREL set and only
6456 requires a loader relocation on their imported symbol.
6457 On the other hand, symbols without XCOFF_LDREL are TOC entries
6458 of internal symbols (like function descriptors made for stubs).
6459 These symbols needs a loader relocation over .data and this
6460 relocation must be applied. */
6462 if ((h
->flags
& XCOFF_LDREL
) != 0
6465 if (!xcoff_create_ldrel (output_bfd
, flinfo
, osec
,
6466 output_bfd
, irel
, NULL
, h
))
6474 p
= tocsec
->contents
+ h
->u
.toc_offset
;
6475 val
= (h
->root
.u
.def
.value
6476 + h
->root
.u
.def
.section
->output_section
->vma
6477 + h
->root
.u
.def
.section
->output_offset
);
6479 if (bfd_xcoff_is_xcoff64 (output_bfd
))
6480 bfd_put_64 (output_bfd
, val
, p
);
6481 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
6482 bfd_put_32 (output_bfd
, val
, p
);
6486 if (!xcoff_create_ldrel (output_bfd
, flinfo
, osec
,
6487 output_bfd
, irel
, h
->root
.u
.def
.section
, h
))
6491 /* We need to emit a symbol to define a csect which holds
6493 if (flinfo
->info
->strip
!= strip_all
)
6495 result
= bfd_xcoff_put_symbol_name (output_bfd
, flinfo
->info
,
6497 &irsym
, h
->root
.root
.string
);
6501 irsym
.n_value
= irel
->r_vaddr
;
6502 irsym
.n_scnum
= osec
->target_index
;
6503 irsym
.n_sclass
= C_HIDEXT
;
6504 irsym
.n_type
= T_NULL
;
6507 bfd_coff_swap_sym_out (output_bfd
, (void *) &irsym
, (void *) outsym
);
6508 outsym
+= bfd_coff_symesz (output_bfd
);
6510 /* Note : iraux is initialized above. */
6511 bfd_coff_swap_aux_out (output_bfd
, (void *) &iraux
, T_NULL
, C_HIDEXT
,
6512 0, 1, (void *) outsym
);
6513 outsym
+= bfd_coff_auxesz (output_bfd
);
6517 /* We aren't going to write out the symbols below, so we
6518 need to write them out now. */
6519 pos
= obj_sym_filepos (output_bfd
);
6520 pos
+= (obj_raw_syment_count (output_bfd
)
6521 * bfd_coff_symesz (output_bfd
));
6522 amt
= outsym
- flinfo
->outsyms
;
6523 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
6524 || bfd_bwrite (flinfo
->outsyms
, amt
, output_bfd
) != amt
)
6526 obj_raw_syment_count (output_bfd
) +=
6527 (outsym
- flinfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
6529 outsym
= flinfo
->outsyms
;
6534 /* If this symbol is a specially defined function descriptor, write
6535 it out. The first word is the address of the function code
6536 itself, the second word is the address of the TOC, and the third
6540 The addresses for the 32 bit will take 4 bytes and the addresses
6541 for 64 bit will take 8 bytes. Similar for the relocs. This type
6542 of logic was also done above to create a TOC entry in
6543 xcoff_write_global_symbol. */
6544 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
6545 && h
->root
.type
== bfd_link_hash_defined
6546 && (h
->root
.u
.def
.section
6547 == xcoff_hash_table (flinfo
->info
)->descriptor_section
))
6553 struct xcoff_link_hash_entry
*hentry
;
6555 struct internal_reloc
*irel
;
6557 unsigned int reloc_size
, byte_size
;
6559 if (bfd_xcoff_is_xcoff64 (output_bfd
))
6564 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
6572 sec
= h
->root
.u
.def
.section
;
6573 osec
= sec
->output_section
;
6574 oindx
= osec
->target_index
;
6575 p
= sec
->contents
+ h
->root
.u
.def
.value
;
6577 hentry
= h
->descriptor
;
6578 BFD_ASSERT (hentry
!= NULL
6579 && (hentry
->root
.type
== bfd_link_hash_defined
6580 || hentry
->root
.type
== bfd_link_hash_defweak
));
6581 esec
= hentry
->root
.u
.def
.section
;
6583 irel
= flinfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
6584 irel
->r_vaddr
= (osec
->vma
6585 + sec
->output_offset
6586 + h
->root
.u
.def
.value
);
6587 irel
->r_symndx
= esec
->output_section
->target_index
;
6588 irel
->r_type
= R_POS
;
6589 irel
->r_size
= reloc_size
;
6590 flinfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
6591 ++osec
->reloc_count
;
6593 if (!xcoff_create_ldrel (output_bfd
, flinfo
, osec
,
6594 output_bfd
, irel
, esec
, NULL
))
6597 /* There are three items to write out,
6598 the address of the code
6599 the address of the toc anchor
6600 the environment pointer.
6601 We are ignoring the environment pointer. So set it to zero. */
6602 if (bfd_xcoff_is_xcoff64 (output_bfd
))
6604 bfd_put_64 (output_bfd
,
6605 (esec
->output_section
->vma
+ esec
->output_offset
6606 + hentry
->root
.u
.def
.value
),
6608 bfd_put_64 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 8);
6609 bfd_put_64 (output_bfd
, (bfd_vma
) 0, p
+ 16);
6614 This logic was already called above so the error case where
6615 the backend is neither has already been checked. */
6616 bfd_put_32 (output_bfd
,
6617 (esec
->output_section
->vma
+ esec
->output_offset
6618 + hentry
->root
.u
.def
.value
),
6620 bfd_put_32 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 4);
6621 bfd_put_32 (output_bfd
, (bfd_vma
) 0, p
+ 8);
6624 tsec
= coff_section_from_bfd_index (output_bfd
,
6625 xcoff_data (output_bfd
)->sntoc
);
6628 irel
->r_vaddr
= (osec
->vma
6629 + sec
->output_offset
6630 + h
->root
.u
.def
.value
6632 irel
->r_symndx
= tsec
->output_section
->target_index
;
6633 irel
->r_type
= R_POS
;
6634 irel
->r_size
= reloc_size
;
6635 flinfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
6636 ++osec
->reloc_count
;
6638 if (!xcoff_create_ldrel (output_bfd
, flinfo
, osec
,
6639 output_bfd
, irel
, tsec
, NULL
))
6643 if (h
->indx
>= 0 || flinfo
->info
->strip
== strip_all
)
6645 BFD_ASSERT (outsym
== flinfo
->outsyms
);
6650 && (flinfo
->info
->strip
== strip_all
6651 || (flinfo
->info
->strip
== strip_some
6652 && bfd_hash_lookup (flinfo
->info
->keep_hash
, h
->root
.root
.string
,
6653 false, false) == NULL
)))
6655 BFD_ASSERT (outsym
== flinfo
->outsyms
);
6660 && (h
->flags
& (XCOFF_REF_REGULAR
| XCOFF_DEF_REGULAR
)) == 0)
6662 BFD_ASSERT (outsym
== flinfo
->outsyms
);
6666 memset (&aux
, 0, sizeof aux
);
6668 h
->indx
= obj_raw_syment_count (output_bfd
);
6670 result
= bfd_xcoff_put_symbol_name (output_bfd
, flinfo
->info
, flinfo
->strtab
,
6671 &isym
, h
->root
.root
.string
);
6675 if (h
->root
.type
== bfd_link_hash_undefined
6676 || h
->root
.type
== bfd_link_hash_undefweak
)
6679 isym
.n_scnum
= N_UNDEF
;
6680 if (h
->root
.type
== bfd_link_hash_undefweak
6681 && C_WEAKEXT
== C_AIX_WEAKEXT
)
6682 isym
.n_sclass
= C_WEAKEXT
;
6684 isym
.n_sclass
= C_EXT
;
6685 aux
.x_csect
.x_smtyp
= XTY_ER
;
6687 else if ((h
->root
.type
== bfd_link_hash_defined
6688 || h
->root
.type
== bfd_link_hash_defweak
)
6689 && h
->smclas
== XMC_XO
)
6691 BFD_ASSERT (bfd_is_abs_symbol (&h
->root
));
6692 isym
.n_value
= h
->root
.u
.def
.value
;
6693 isym
.n_scnum
= N_UNDEF
;
6694 if (h
->root
.type
== bfd_link_hash_defweak
6695 && C_WEAKEXT
== C_AIX_WEAKEXT
)
6696 isym
.n_sclass
= C_WEAKEXT
;
6698 isym
.n_sclass
= C_EXT
;
6699 aux
.x_csect
.x_smtyp
= XTY_ER
;
6701 else if (h
->root
.type
== bfd_link_hash_defined
6702 || h
->root
.type
== bfd_link_hash_defweak
)
6704 struct xcoff_link_size_list
*l
;
6706 isym
.n_value
= (h
->root
.u
.def
.section
->output_section
->vma
6707 + h
->root
.u
.def
.section
->output_offset
6708 + h
->root
.u
.def
.value
);
6709 if (bfd_is_abs_section (h
->root
.u
.def
.section
->output_section
))
6710 isym
.n_scnum
= N_ABS
;
6712 isym
.n_scnum
= h
->root
.u
.def
.section
->output_section
->target_index
;
6713 isym
.n_sclass
= C_HIDEXT
;
6714 aux
.x_csect
.x_smtyp
= XTY_SD
;
6716 /* For stub symbols, the section already has its correct size. */
6717 if (h
->root
.u
.def
.section
->owner
== xcoff_hash_table (flinfo
->info
)->params
->stub_bfd
)
6719 aux
.x_csect
.x_scnlen
.l
= h
->root
.u
.def
.section
->size
;
6721 else if ((h
->flags
& XCOFF_HAS_SIZE
) != 0)
6723 for (l
= xcoff_hash_table (flinfo
->info
)->size_list
;
6729 aux
.x_csect
.x_scnlen
.l
= l
->size
;
6735 else if (h
->root
.type
== bfd_link_hash_common
)
6737 isym
.n_value
= (h
->root
.u
.c
.p
->section
->output_section
->vma
6738 + h
->root
.u
.c
.p
->section
->output_offset
);
6739 isym
.n_scnum
= h
->root
.u
.c
.p
->section
->output_section
->target_index
;
6740 isym
.n_sclass
= C_EXT
;
6741 aux
.x_csect
.x_smtyp
= XTY_CM
;
6742 aux
.x_csect
.x_scnlen
.l
= h
->root
.u
.c
.size
;
6747 isym
.n_type
= T_NULL
;
6750 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
6751 outsym
+= bfd_coff_symesz (output_bfd
);
6753 aux
.x_csect
.x_smclas
= h
->smclas
;
6754 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, T_NULL
, isym
.n_sclass
, 0, 1,
6756 outsym
+= bfd_coff_auxesz (output_bfd
);
6758 if ((h
->root
.type
== bfd_link_hash_defined
6759 || h
->root
.type
== bfd_link_hash_defweak
)
6760 && h
->smclas
!= XMC_XO
)
6762 /* We just output an SD symbol. Now output an LD symbol. */
6765 if (h
->root
.type
== bfd_link_hash_defweak
6766 && C_WEAKEXT
== C_AIX_WEAKEXT
)
6767 isym
.n_sclass
= C_WEAKEXT
;
6769 isym
.n_sclass
= C_EXT
;
6770 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
6771 outsym
+= bfd_coff_symesz (output_bfd
);
6773 aux
.x_csect
.x_smtyp
= XTY_LD
;
6774 aux
.x_csect
.x_scnlen
.l
= obj_raw_syment_count (output_bfd
);
6775 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, T_NULL
, C_EXT
, 0, 1,
6777 outsym
+= bfd_coff_auxesz (output_bfd
);
6780 pos
= obj_sym_filepos (output_bfd
);
6781 pos
+= obj_raw_syment_count (output_bfd
) * bfd_coff_symesz (output_bfd
);
6782 amt
= outsym
- flinfo
->outsyms
;
6783 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
6784 || bfd_bwrite (flinfo
->outsyms
, amt
, output_bfd
) != amt
)
6786 obj_raw_syment_count (output_bfd
) +=
6787 (outsym
- flinfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
6792 /* Handle a link order which is supposed to generate a reloc. */
6795 xcoff_reloc_link_order (bfd
*output_bfd
,
6796 struct xcoff_final_link_info
*flinfo
,
6797 asection
*output_section
,
6798 struct bfd_link_order
*link_order
)
6800 reloc_howto_type
*howto
;
6801 struct xcoff_link_hash_entry
*h
;
6805 struct internal_reloc
*irel
;
6806 struct xcoff_link_hash_entry
**rel_hash_ptr
;
6808 if (link_order
->type
== bfd_section_reloc_link_order
)
6809 /* We need to somehow locate a symbol in the right section. The
6810 symbol must either have a value of zero, or we must adjust
6811 the addend by the value of the symbol. FIXME: Write this
6812 when we need it. The old linker couldn't handle this anyhow. */
6815 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6818 bfd_set_error (bfd_error_bad_value
);
6822 h
= ((struct xcoff_link_hash_entry
*)
6823 bfd_wrapped_link_hash_lookup (output_bfd
, flinfo
->info
,
6824 link_order
->u
.reloc
.p
->u
.name
,
6825 false, false, true));
6828 (*flinfo
->info
->callbacks
->unattached_reloc
)
6829 (flinfo
->info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
6833 hsec
= xcoff_symbol_section (h
);
6834 if (h
->root
.type
== bfd_link_hash_defined
6835 || h
->root
.type
== bfd_link_hash_defweak
)
6836 hval
= h
->root
.u
.def
.value
;
6840 addend
= link_order
->u
.reloc
.p
->addend
;
6842 addend
+= (hsec
->output_section
->vma
6843 + hsec
->output_offset
6850 bfd_reloc_status_type rstat
;
6853 size
= bfd_get_reloc_size (howto
);
6854 buf
= bfd_zmalloc (size
);
6855 if (buf
== NULL
&& size
!= 0)
6858 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
6864 case bfd_reloc_outofrange
:
6866 case bfd_reloc_overflow
:
6867 (*flinfo
->info
->callbacks
->reloc_overflow
)
6868 (flinfo
->info
, NULL
, link_order
->u
.reloc
.p
->u
.name
,
6869 howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0);
6872 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
6873 (file_ptr
) link_order
->offset
, size
);
6879 /* Store the reloc information in the right place. It will get
6880 swapped and written out at the end of the final_link routine. */
6881 irel
= (flinfo
->section_info
[output_section
->target_index
].relocs
6882 + output_section
->reloc_count
);
6883 rel_hash_ptr
= (flinfo
->section_info
[output_section
->target_index
].rel_hashes
6884 + output_section
->reloc_count
);
6886 memset (irel
, 0, sizeof (struct internal_reloc
));
6887 *rel_hash_ptr
= NULL
;
6889 irel
->r_vaddr
= output_section
->vma
+ link_order
->offset
;
6892 irel
->r_symndx
= h
->indx
;
6895 /* Set the index to -2 to force this symbol to get written out. */
6901 irel
->r_type
= howto
->type
;
6902 irel
->r_size
= howto
->bitsize
- 1;
6903 if (howto
->complain_on_overflow
== complain_overflow_signed
)
6904 irel
->r_size
|= 0x80;
6906 ++output_section
->reloc_count
;
6908 /* Now output the reloc to the .loader section. */
6909 if (xcoff_hash_table (flinfo
->info
)->loader_section
)
6911 if (!xcoff_create_ldrel (output_bfd
, flinfo
, output_section
,
6912 output_bfd
, irel
, hsec
, h
))
6919 /* Do the final link step. */
6922 _bfd_xcoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
6924 bfd_size_type symesz
;
6925 struct xcoff_final_link_info flinfo
;
6927 struct bfd_link_order
*p
;
6928 bfd_size_type max_contents_size
;
6929 bfd_size_type max_sym_count
;
6930 bfd_size_type max_lineno_count
;
6931 bfd_size_type max_reloc_count
;
6932 bfd_size_type max_output_reloc_count
;
6933 file_ptr rel_filepos
;
6935 file_ptr line_filepos
;
6936 unsigned int linesz
;
6938 bfd_byte
*external_relocs
= NULL
;
6939 char strbuf
[STRING_SIZE_SIZE
];
6943 if (bfd_link_pic (info
))
6944 abfd
->flags
|= DYNAMIC
;
6946 symesz
= bfd_coff_symesz (abfd
);
6949 flinfo
.output_bfd
= abfd
;
6950 flinfo
.strtab
= NULL
;
6951 flinfo
.section_info
= NULL
;
6952 flinfo
.last_file_index
= -1;
6953 flinfo
.toc_symindx
= -1;
6954 flinfo
.internal_syms
= NULL
;
6955 flinfo
.sym_indices
= NULL
;
6956 flinfo
.outsyms
= NULL
;
6957 flinfo
.linenos
= NULL
;
6958 flinfo
.contents
= NULL
;
6959 flinfo
.external_relocs
= NULL
;
6961 if (xcoff_hash_table (info
)->loader_section
)
6963 flinfo
.ldsym
= (xcoff_hash_table (info
)->loader_section
->contents
6964 + bfd_xcoff_ldhdrsz (abfd
));
6965 flinfo
.ldrel
= (xcoff_hash_table (info
)->loader_section
->contents
6966 + bfd_xcoff_ldhdrsz (abfd
)
6967 + (xcoff_hash_table (info
)->ldhdr
.l_nsyms
6968 * bfd_xcoff_ldsymsz (abfd
)));
6972 flinfo
.ldsym
= NULL
;
6973 flinfo
.ldrel
= NULL
;
6976 xcoff_data (abfd
)->coff
.link_info
= info
;
6978 flinfo
.strtab
= _bfd_stringtab_init ();
6979 if (flinfo
.strtab
== NULL
)
6982 /* Count the relocation entries required for the output file.
6983 (We've already counted the line numbers.) Determine a few
6985 max_contents_size
= 0;
6986 max_lineno_count
= 0;
6987 max_reloc_count
= 0;
6988 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6991 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
6993 if (p
->type
== bfd_indirect_link_order
)
6997 sec
= p
->u
.indirect
.section
;
6999 /* Mark all sections which are to be included in the
7000 link. This will normally be every section. We need
7001 to do this so that we can identify any sections which
7002 the linker has decided to not include. */
7003 sec
->linker_mark
= true;
7005 o
->reloc_count
+= sec
->reloc_count
;
7007 if ((sec
->flags
& SEC_IN_MEMORY
) == 0)
7009 if (sec
->rawsize
> max_contents_size
)
7010 max_contents_size
= sec
->rawsize
;
7011 if (sec
->size
> max_contents_size
)
7012 max_contents_size
= sec
->size
;
7014 if (coff_section_data (sec
->owner
, sec
) != NULL
7015 && xcoff_section_data (sec
->owner
, sec
) != NULL
7016 && (xcoff_section_data (sec
->owner
, sec
)->lineno_count
7017 > max_lineno_count
))
7019 xcoff_section_data (sec
->owner
, sec
)->lineno_count
;
7020 if (sec
->reloc_count
> max_reloc_count
)
7021 max_reloc_count
= sec
->reloc_count
;
7023 else if (p
->type
== bfd_section_reloc_link_order
7024 || p
->type
== bfd_symbol_reloc_link_order
)
7029 /* Compute the file positions for all the sections. */
7030 if (abfd
->output_has_begun
)
7032 if (xcoff_hash_table (info
)->file_align
!= 0)
7039 file_align
= xcoff_hash_table (info
)->file_align
;
7040 if (file_align
!= 0)
7046 /* Insert .pad sections before every section which has
7047 contents and is loaded, if it is preceded by some other
7048 section which has contents and is loaded. */
7049 saw_contents
= true;
7050 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7052 if (strcmp (o
->name
, ".pad") == 0)
7053 saw_contents
= false;
7054 else if ((o
->flags
& SEC_HAS_CONTENTS
) != 0
7055 && (o
->flags
& SEC_LOAD
) != 0)
7058 saw_contents
= true;
7063 /* Create a pad section and place it before the section
7064 that needs padding. This requires unlinking and
7065 relinking the bfd's section list. */
7067 n
= bfd_make_section_anyway_with_flags (abfd
, ".pad",
7069 n
->alignment_power
= 0;
7071 bfd_section_list_remove (abfd
, n
);
7072 bfd_section_list_insert_before (abfd
, o
, n
);
7073 saw_contents
= false;
7078 /* Reset the section indices after inserting the new
7081 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7084 o
->target_index
= indx
;
7086 BFD_ASSERT ((unsigned int) indx
== abfd
->section_count
);
7088 /* Work out appropriate sizes for the .pad sections to force
7089 each section to land on a page boundary. This bit of
7090 code knows what compute_section_file_positions is going
7092 sofar
= bfd_coff_filhsz (abfd
);
7093 sofar
+= bfd_coff_aoutsz (abfd
);
7094 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
7095 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7096 if ((bfd_xcoff_is_reloc_count_overflow
7097 (abfd
, (bfd_vma
) o
->reloc_count
))
7098 || (bfd_xcoff_is_lineno_count_overflow
7099 (abfd
, (bfd_vma
) o
->lineno_count
)))
7100 /* 64 does not overflow, need to check if 32 does */
7101 sofar
+= bfd_coff_scnhsz (abfd
);
7103 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7105 if (strcmp (o
->name
, ".pad") == 0)
7109 BFD_ASSERT (o
->size
== 0);
7110 pageoff
= sofar
& (file_align
- 1);
7113 o
->size
= file_align
- pageoff
;
7114 sofar
+= file_align
- pageoff
;
7115 o
->flags
|= SEC_HAS_CONTENTS
;
7120 if ((o
->flags
& SEC_HAS_CONTENTS
) != 0)
7121 sofar
+= BFD_ALIGN (o
->size
,
7122 1 << o
->alignment_power
);
7127 if (! bfd_coff_compute_section_file_positions (abfd
))
7131 /* Allocate space for the pointers we need to keep for the relocs. */
7135 /* We use section_count + 1, rather than section_count, because
7136 the target_index fields are 1 based. */
7137 amt
= abfd
->section_count
+ 1;
7138 amt
*= sizeof (struct xcoff_link_section_info
);
7139 flinfo
.section_info
= bfd_malloc (amt
);
7140 if (flinfo
.section_info
== NULL
)
7142 for (i
= 0; i
<= abfd
->section_count
; i
++)
7144 flinfo
.section_info
[i
].relocs
= NULL
;
7145 flinfo
.section_info
[i
].rel_hashes
= NULL
;
7146 flinfo
.section_info
[i
].toc_rel_hashes
= NULL
;
7150 /* Set the file positions for the relocs. */
7151 rel_filepos
= obj_relocbase (abfd
);
7152 relsz
= bfd_coff_relsz (abfd
);
7153 max_output_reloc_count
= 0;
7154 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7156 if (o
->reloc_count
== 0)
7160 /* A stripped file has no relocs. However, we still
7161 allocate the buffers, so that later code doesn't have to
7162 worry about whether we are stripping or not. */
7163 if (info
->strip
== strip_all
)
7167 o
->flags
|= SEC_RELOC
;
7168 o
->rel_filepos
= rel_filepos
;
7169 rel_filepos
+= o
->reloc_count
* relsz
;
7172 /* We don't know the indices of global symbols until we have
7173 written out all the local symbols. For each section in
7174 the output file, we keep an array of pointers to hash
7175 table entries. Each entry in the array corresponds to a
7176 reloc. When we find a reloc against a global symbol, we
7177 set the corresponding entry in this array so that we can
7178 fix up the symbol index after we have written out all the
7181 Because of this problem, we also keep the relocs in
7182 memory until the end of the link. This wastes memory.
7183 We could backpatch the file later, I suppose, although it
7185 amt
= o
->reloc_count
;
7186 amt
*= sizeof (struct internal_reloc
);
7187 flinfo
.section_info
[o
->target_index
].relocs
= bfd_malloc (amt
);
7189 amt
= o
->reloc_count
;
7190 amt
*= sizeof (struct xcoff_link_hash_entry
*);
7191 flinfo
.section_info
[o
->target_index
].rel_hashes
= bfd_malloc (amt
);
7193 if (flinfo
.section_info
[o
->target_index
].relocs
== NULL
7194 || flinfo
.section_info
[o
->target_index
].rel_hashes
== NULL
)
7197 if (o
->reloc_count
> max_output_reloc_count
)
7198 max_output_reloc_count
= o
->reloc_count
;
7202 /* We now know the size of the relocs, so we can determine the file
7203 positions of the line numbers. */
7204 line_filepos
= rel_filepos
;
7205 flinfo
.line_filepos
= line_filepos
;
7206 linesz
= bfd_coff_linesz (abfd
);
7207 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7209 if (o
->lineno_count
== 0)
7210 o
->line_filepos
= 0;
7213 o
->line_filepos
= line_filepos
;
7214 line_filepos
+= o
->lineno_count
* linesz
;
7217 /* Reset the reloc and lineno counts, so that we can use them to
7218 count the number of entries we have output so far. */
7220 o
->lineno_count
= 0;
7223 obj_sym_filepos (abfd
) = line_filepos
;
7225 /* Figure out the largest number of symbols in an input BFD. Take
7226 the opportunity to clear the output_has_begun fields of all the
7227 input BFD's. We want at least 6 symbols, since that is the
7228 number which xcoff_write_global_symbol may need. */
7230 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
7234 sub
->output_has_begun
= false;
7235 sz
= obj_raw_syment_count (sub
);
7236 if (sz
> max_sym_count
)
7240 /* Allocate some buffers used while linking. */
7241 amt
= max_sym_count
* sizeof (struct internal_syment
);
7242 flinfo
.internal_syms
= bfd_malloc (amt
);
7244 amt
= max_sym_count
* sizeof (long);
7245 flinfo
.sym_indices
= bfd_malloc (amt
);
7247 amt
= (max_sym_count
+ 1) * symesz
;
7248 flinfo
.outsyms
= bfd_malloc (amt
);
7250 amt
= max_lineno_count
* bfd_coff_linesz (abfd
);
7251 flinfo
.linenos
= bfd_malloc (amt
);
7253 amt
= max_contents_size
;
7254 flinfo
.contents
= bfd_malloc (amt
);
7256 amt
= max_reloc_count
* relsz
;
7257 flinfo
.external_relocs
= bfd_malloc (amt
);
7259 if ((flinfo
.internal_syms
== NULL
&& max_sym_count
> 0)
7260 || (flinfo
.sym_indices
== NULL
&& max_sym_count
> 0)
7261 || flinfo
.outsyms
== NULL
7262 || (flinfo
.linenos
== NULL
&& max_lineno_count
> 0)
7263 || (flinfo
.contents
== NULL
&& max_contents_size
> 0)
7264 || (flinfo
.external_relocs
== NULL
&& max_reloc_count
> 0))
7267 obj_raw_syment_count (abfd
) = 0;
7269 /* Find a TOC symbol, if we need one. */
7270 if (!xcoff_find_tc0 (abfd
, &flinfo
))
7273 /* We now know the position of everything in the file, except that
7274 we don't know the size of the symbol table and therefore we don't
7275 know where the string table starts. We just build the string
7276 table in memory as we go along. We process all the relocations
7277 for a single input file at once. */
7278 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7280 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
7282 if (p
->type
== bfd_indirect_link_order
7283 && p
->u
.indirect
.section
->owner
->xvec
== abfd
->xvec
)
7285 sub
= p
->u
.indirect
.section
->owner
;
7286 if (! sub
->output_has_begun
)
7288 if (sub
== xcoff_hash_table (info
)->params
->stub_bfd
)
7294 if (! xcoff_link_input_bfd (&flinfo
, sub
))
7297 (_("Unable to link input file: %s"), sub
->filename
);
7298 bfd_set_error (bfd_error_sorry
);
7302 sub
->output_has_begun
= true;
7305 else if (p
->type
== bfd_section_reloc_link_order
7306 || p
->type
== bfd_symbol_reloc_link_order
)
7308 if (! xcoff_reloc_link_order (abfd
, &flinfo
, o
, p
))
7313 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
7319 /* Free up the buffers used by xcoff_link_input_bfd. */
7320 free (flinfo
.internal_syms
);
7321 flinfo
.internal_syms
= NULL
;
7322 free (flinfo
.sym_indices
);
7323 flinfo
.sym_indices
= NULL
;
7324 free (flinfo
.linenos
);
7325 flinfo
.linenos
= NULL
;
7326 free (flinfo
.contents
);
7327 flinfo
.contents
= NULL
;
7328 free (flinfo
.external_relocs
);
7329 flinfo
.external_relocs
= NULL
;
7331 /* The value of the last C_FILE symbol is supposed to be -1. Write
7333 if (flinfo
.last_file_index
!= -1)
7335 flinfo
.last_file
.n_value
= -(bfd_vma
) 1;
7336 bfd_coff_swap_sym_out (abfd
, (void *) &flinfo
.last_file
,
7337 (void *) flinfo
.outsyms
);
7338 pos
= obj_sym_filepos (abfd
) + flinfo
.last_file_index
* symesz
;
7339 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
7340 || bfd_bwrite (flinfo
.outsyms
, symesz
, abfd
) != symesz
)
7344 /* Write out all the global symbols which do not come from XCOFF
7346 bfd_hash_traverse (&info
->hash
->table
, xcoff_write_global_symbol
, &flinfo
);
7348 /* Write out the relocations created by stub entries. The symbols
7349 will have been already written by xcoff_write_global_symbol. */
7350 bfd_hash_traverse (&xcoff_hash_table(info
)->stub_hash_table
,
7351 xcoff_stub_create_relocations
,
7354 free (flinfo
.outsyms
);
7355 flinfo
.outsyms
= NULL
;
7357 /* Now that we have written out all the global symbols, we know the
7358 symbol indices to use for relocs against them, and we can finally
7359 write out the relocs. */
7360 amt
= max_output_reloc_count
* relsz
;
7361 external_relocs
= bfd_malloc (amt
);
7362 if (external_relocs
== NULL
&& max_output_reloc_count
!= 0)
7365 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7367 struct internal_reloc
*irel
;
7368 struct internal_reloc
*irelend
;
7369 struct xcoff_link_hash_entry
**rel_hash
;
7370 struct xcoff_toc_rel_hash
*toc_rel_hash
;
7372 bfd_size_type rel_size
;
7374 /* A stripped file has no relocs. */
7375 if (info
->strip
== strip_all
)
7381 if (o
->reloc_count
== 0)
7384 irel
= flinfo
.section_info
[o
->target_index
].relocs
;
7385 irelend
= irel
+ o
->reloc_count
;
7386 rel_hash
= flinfo
.section_info
[o
->target_index
].rel_hashes
;
7387 for (; irel
< irelend
; irel
++, rel_hash
++)
7389 if (*rel_hash
!= NULL
)
7391 if ((*rel_hash
)->indx
< 0)
7393 (*info
->callbacks
->unattached_reloc
)
7394 (info
, (*rel_hash
)->root
.root
.string
,
7395 NULL
, o
, irel
->r_vaddr
);
7396 (*rel_hash
)->indx
= 0;
7398 irel
->r_symndx
= (*rel_hash
)->indx
;
7402 for (toc_rel_hash
= flinfo
.section_info
[o
->target_index
].toc_rel_hashes
;
7403 toc_rel_hash
!= NULL
;
7404 toc_rel_hash
= toc_rel_hash
->next
)
7406 if (toc_rel_hash
->h
->u
.toc_indx
< 0)
7408 (*info
->callbacks
->unattached_reloc
)
7409 (info
, toc_rel_hash
->h
->root
.root
.string
,
7410 NULL
, o
, toc_rel_hash
->rel
->r_vaddr
);
7411 toc_rel_hash
->h
->u
.toc_indx
= 0;
7413 toc_rel_hash
->rel
->r_symndx
= toc_rel_hash
->h
->u
.toc_indx
;
7416 /* XCOFF requires that the relocs be sorted by address. We tend
7417 to produce them in the order in which their containing csects
7418 appear in the symbol table, which is not necessarily by
7419 address. So we sort them here. There may be a better way to
7421 qsort ((void *) flinfo
.section_info
[o
->target_index
].relocs
,
7422 o
->reloc_count
, sizeof (struct internal_reloc
),
7425 irel
= flinfo
.section_info
[o
->target_index
].relocs
;
7426 irelend
= irel
+ o
->reloc_count
;
7427 erel
= external_relocs
;
7428 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
7429 bfd_coff_swap_reloc_out (abfd
, (void *) irel
, (void *) erel
);
7431 rel_size
= relsz
* o
->reloc_count
;
7432 if (bfd_seek (abfd
, o
->rel_filepos
, SEEK_SET
) != 0
7433 || bfd_bwrite ((void *) external_relocs
, rel_size
, abfd
) != rel_size
)
7437 free (external_relocs
);
7438 external_relocs
= NULL
;
7440 /* Free up the section information. */
7441 if (flinfo
.section_info
!= NULL
)
7445 for (i
= 0; i
< abfd
->section_count
; i
++)
7447 free (flinfo
.section_info
[i
].relocs
);
7448 free (flinfo
.section_info
[i
].rel_hashes
);
7450 free (flinfo
.section_info
);
7451 flinfo
.section_info
= NULL
;
7454 /* Write out the stub sections. */
7455 for (o
= xcoff_hash_table (info
)->params
->stub_bfd
->sections
;
7456 o
!= NULL
; o
= o
->next
)
7458 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
7462 if (!bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
7463 (file_ptr
) o
->output_offset
, o
->size
))
7467 /* Write out the loader section contents. */
7468 o
= xcoff_hash_table (info
)->loader_section
;
7471 && o
->output_section
!= bfd_abs_section_ptr
)
7473 BFD_ASSERT ((bfd_byte
*) flinfo
.ldrel
7474 == (xcoff_hash_table (info
)->loader_section
->contents
7475 + xcoff_hash_table (info
)->ldhdr
.l_impoff
));
7476 if (!bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
7477 (file_ptr
) o
->output_offset
, o
->size
))
7481 /* Write out the magic sections. */
7482 o
= xcoff_hash_table (info
)->linkage_section
;
7485 && o
->output_section
!= bfd_abs_section_ptr
7486 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
7487 (file_ptr
) o
->output_offset
,
7490 o
= xcoff_hash_table (info
)->toc_section
;
7493 && o
->output_section
!= bfd_abs_section_ptr
7494 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
7495 (file_ptr
) o
->output_offset
,
7498 o
= xcoff_hash_table (info
)->descriptor_section
;
7501 && o
->output_section
!= bfd_abs_section_ptr
7502 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
7503 (file_ptr
) o
->output_offset
,
7507 /* Write out the string table. */
7508 pos
= obj_sym_filepos (abfd
) + obj_raw_syment_count (abfd
) * symesz
;
7509 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
7512 _bfd_stringtab_size (flinfo
.strtab
) + STRING_SIZE_SIZE
,
7514 amt
= STRING_SIZE_SIZE
;
7515 if (bfd_bwrite (strbuf
, amt
, abfd
) != amt
)
7517 if (! _bfd_stringtab_emit (abfd
, flinfo
.strtab
))
7520 _bfd_stringtab_free (flinfo
.strtab
);
7522 /* Write out the debugging string table. */
7523 o
= xcoff_hash_table (info
)->debug_section
;
7526 && o
->output_section
!= bfd_abs_section_ptr
)
7528 struct bfd_strtab_hash
*debug_strtab
;
7530 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
7531 BFD_ASSERT (o
->output_section
->size
- o
->output_offset
7532 >= _bfd_stringtab_size (debug_strtab
));
7533 pos
= o
->output_section
->filepos
+ o
->output_offset
;
7534 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
7536 if (! _bfd_stringtab_emit (abfd
, debug_strtab
))
7540 /* Setting symcount to 0 will cause write_object_contents to
7541 not try to write out the symbols. */
7547 if (flinfo
.strtab
!= NULL
)
7548 _bfd_stringtab_free (flinfo
.strtab
);
7550 if (flinfo
.section_info
!= NULL
)
7554 for (i
= 0; i
< abfd
->section_count
; i
++)
7556 free (flinfo
.section_info
[i
].relocs
);
7557 free (flinfo
.section_info
[i
].rel_hashes
);
7559 free (flinfo
.section_info
);
7562 free (flinfo
.internal_syms
);
7563 free (flinfo
.sym_indices
);
7564 free (flinfo
.outsyms
);
7565 free (flinfo
.linenos
);
7566 free (flinfo
.contents
);
7567 free (flinfo
.external_relocs
);
7568 free (external_relocs
);