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");
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");
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");
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");
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");
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");
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");
4131 if (subdeb
!= NULL
&& subdeb
->size
> 0)
4133 /* We use malloc and copy the names into the debug
4134 stringtab, rather than bfd_alloc, because I expect
4135 that, when linking many files together, many of the
4136 strings will be the same. Storing the strings in the
4137 hash table should save space in this case. */
4138 if (!bfd_malloc_and_get_section (sub
, subdeb
, &debug_contents
))
4143 csectpp
= xcoff_data (sub
)->csects
;
4144 lineno_counts
= xcoff_data (sub
)->lineno_counts
;
4145 sym_hash
= obj_xcoff_sym_hashes (sub
);
4146 symesz
= bfd_coff_symesz (sub
);
4147 esym
= (bfd_byte
*) obj_coff_external_syms (sub
);
4148 esymend
= esym
+ symcount
* symesz
;
4150 while (esym
< esymend
)
4152 struct internal_syment sym
;
4153 union internal_auxent aux
;
4158 bfd_coff_swap_sym_in (sub
, esym
, &sym
);
4160 /* Read in the csect information, if any. */
4161 if (CSECT_SYM_P (sym
.n_sclass
))
4163 BFD_ASSERT (sym
.n_numaux
> 0);
4164 bfd_coff_swap_aux_in (sub
, esym
+ symesz
* sym
.n_numaux
,
4165 sym
.n_type
, sym
.n_sclass
,
4166 sym
.n_numaux
- 1, sym
.n_numaux
, &aux
);
4169 /* If this symbol's name is stored in the debug section,
4170 get a pointer to it. */
4171 if (debug_contents
!= NULL
4172 && sym
._n
._n_n
._n_zeroes
== 0
4173 && bfd_coff_symname_in_debug (sub
, &sym
))
4174 name
= (const char *) debug_contents
+ sym
._n
._n_n
._n_offset
;
4178 /* Decide whether to copy this symbol to the output file. */
4180 keep_p
= xcoff_keep_symbol_p (info
, sub
, &sym
, &aux
,
4181 *sym_hash
, csect
, name
);
4186 /* Use a debug_index of -2 to record that a symbol should
4191 /* See whether we should store the symbol name in the
4192 output .debug section. */
4197 indx
= _bfd_stringtab_add (debug_strtab
, name
, true, true);
4198 if (indx
== (bfd_size_type
) -1)
4200 *debug_index
= indx
;
4205 (*sym_hash
)->flags
|= XCOFF_ALLOCATED
;
4206 if (*lineno_counts
> 0)
4207 csect
->output_section
->lineno_count
+= *lineno_counts
;
4210 esym
+= (sym
.n_numaux
+ 1) * symesz
;
4211 csectpp
+= sym
.n_numaux
+ 1;
4212 sym_hash
+= sym
.n_numaux
+ 1;
4213 lineno_counts
+= sym
.n_numaux
+ 1;
4214 debug_index
+= sym
.n_numaux
+ 1;
4219 free (debug_contents
);
4220 debug_contents
= NULL
;
4222 /* Clear the size of subdeb, so that it is not included directly
4223 in the output file. */
4227 if (! info
->keep_memory
)
4229 if (! _bfd_coff_free_symbols (sub
))
4234 if (info
->strip
!= strip_all
4235 && xcoff_hash_table (info
)->debug_section
!= NULL
)
4236 xcoff_hash_table (info
)->debug_section
->size
=
4237 _bfd_stringtab_size (debug_strtab
);
4242 free (debug_contents
);
4247 bfd_xcoff_link_generate_rtinit (bfd
*abfd
,
4252 struct bfd_in_memory
*bim
;
4254 bim
= bfd_malloc ((bfd_size_type
) sizeof (* bim
));
4261 abfd
->link
.next
= 0;
4262 abfd
->format
= bfd_object
;
4263 abfd
->iostream
= (void *) bim
;
4264 abfd
->flags
= BFD_IN_MEMORY
;
4265 abfd
->iovec
= &_bfd_memory_iovec
;
4266 abfd
->direction
= write_direction
;
4270 if (! bfd_xcoff_generate_rtinit (abfd
, init
, fini
, rtld
))
4273 /* need to reset to unknown or it will not be read back in correctly */
4274 abfd
->format
= bfd_unknown
;
4275 abfd
->direction
= read_direction
;
4283 The stubs will be gathered in stub csects named "@FIX'number'".
4284 A new csect will be created by xcoff_stub_get_csect_in_range,
4285 everytime a relocation cannot reach its target and its section
4286 is too far from the others stub csects.
4287 The stubs will simply be code generated inside these stub
4288 csects. In order to simplify the symbol table, only the symbols
4289 for the stub csects are written.
4291 As the code is dependent of the architecture, it's defined
4294 xcoff_stub_indirect_call:
4295 Used when a 24 bit branch cannot reach its destination and that
4296 this destination isn't a global linkage symbol.
4298 xcoff_stub_shared_call:
4299 As above but when it's a global linkage symbol.
4300 The main difference being that it doesn't branch to the global
4301 linkage symbol which will then call the shared library. It
4302 directly call it saving the TOC.
4304 TODO: -bbigtoc option should be able to be implemented using
4307 /* Get the name of a csect which will contain stubs.
4308 It has the same pattern as AIX linker: @FIX"number". */
4310 xcoff_stub_csect_name (unsigned int n
)
4316 /* For now, allow "only" 1000000 stub csects. */
4323 sprintf (buf
, "%d", n
);
4324 len
= 4 + strlen (buf
) + 1;
4326 csect_name
= bfd_malloc (len
);
4327 if (csect_name
== NULL
)
4329 sprintf (csect_name
, "@FIX%d", n
);
4334 /* Return a stub section which can be reach with a single branch
4335 from SECTION. CREATE means that creating a csect is allowed. */
4336 static struct xcoff_link_hash_entry
*
4337 xcoff_stub_get_csect_in_range (asection
*section
,
4338 struct bfd_link_info
*info
,
4341 struct xcoff_link_hash_table
*htab
= xcoff_hash_table (info
);
4342 struct xcoff_link_hash_entry
*csect_entry
;
4343 struct bfd_link_hash_entry
*bh
= NULL
;
4348 /* Search for a csect in range. */
4349 for (csect
= htab
->params
->stub_bfd
->sections
, it
= 0;
4351 csect
= csect
->next
, it
++)
4353 /* A csect is in range if everything instructions in SECTION
4354 can branch to every stubs in the stub csect. This can
4355 be simplify by saying that the first entry of each sections
4356 (ie the vma of this section) can reach the last entry of the
4357 stub csect (ie the vma of the csect + its size).
4358 However, as the stub csect might be growing its size isn't
4359 fixed. Thus, the last entry of SECTION might not be able
4360 to reach the first entry of the stub csect anymore.
4361 If this case happens, the following condition will be
4362 false during the next pass of bfd_xcoff_size_stubs and
4363 another csect will be used.
4364 This means we might create more stubs than needed. */
4365 bfd_vma csect_vma
, section_vma
;
4366 bfd_vma csect_last_vma
, section_last_vma
;
4368 csect_vma
= (csect
->output_section
->vma
4369 + csect
->output_offset
);
4370 csect_last_vma
= (csect
->output_section
->vma
4371 + csect
->output_offset
4373 section_vma
= (section
->output_section
->vma
4374 + section
->output_offset
);
4375 section_last_vma
= (section
->output_section
->vma
4376 + section
->output_offset
4379 if (csect_last_vma
- section_vma
+ (1 << 25) < 2 * (1 << 25)
4380 && section_last_vma
- csect_vma
+ (1 << 25) < 2 * (1 << 25))
4384 if (!create
&& csect
== NULL
)
4387 csect_name
= xcoff_stub_csect_name (it
);
4391 /* A stub csect already exists, get its entry. */
4394 csect_entry
= xcoff_link_hash_lookup (htab
, csect_name
, false, false, true);
4399 /* Create the csect and its symbol. */
4400 csect
= (*htab
->params
->add_stub_section
) (".pr", section
);
4407 csect
->alignment_power
= 2;
4409 csect
->reloc_count
= 0;
4411 /* We need to associate a VMA to this new csect. Otherwise,
4412 our "in range" algorithm won't find it for the next stub.
4413 And as we will be adding this stub section just after the
4414 SECTION, we know its address. */
4415 csect
->output_offset
= BFD_ALIGN (section
->output_offset
+ section
->size
,
4418 if (!_bfd_generic_link_add_one_symbol (info
, htab
->params
->stub_bfd
,
4419 csect_name
, BSF_GLOBAL
, csect
, 0,
4420 NULL
, true, true, &bh
))
4426 csect_entry
= (struct xcoff_link_hash_entry
*)bh
;
4427 csect_entry
->smclas
= XMC_PR
;
4428 csect_entry
->flags
= XCOFF_MARK
| XCOFF_DEF_REGULAR
;
4435 /* Build a name for an entry in the stub hash table. */
4437 xcoff_stub_name (const struct xcoff_link_hash_entry
*h
,
4438 const struct xcoff_link_hash_entry
*hcsect
)
4445 /* The name of a stub is based on its stub csect and the
4446 symbol it wants to reach. It looks like: ".@FIX0.tramp.f".
4447 When the stub targets a function, the last dot of ".tramp."
4448 is removed to avoid having two dot. */
4450 + strlen (hcsect
->root
.root
.string
)
4451 + strlen (h
->root
.root
.string
)
4453 if (h
->root
.root
.string
[0] != '.')
4456 stub_name
= bfd_malloc (len
);
4457 if (stub_name
== NULL
)
4460 if (h
->root
.root
.string
[0] == '.')
4461 sprintf (stub_name
, ".%s.tramp%s",
4462 hcsect
->root
.root
.string
,
4463 h
->root
.root
.string
);
4465 sprintf (stub_name
, ".%s.tramp.%s",
4466 hcsect
->root
.root
.string
,
4467 h
->root
.root
.string
);
4478 /* Look up an entry in the stub hash. */
4479 struct xcoff_stub_hash_entry
*
4480 bfd_xcoff_get_stub_entry (asection
*section
,
4481 struct xcoff_link_hash_entry
*h
,
4482 struct bfd_link_info
*info
)
4484 struct xcoff_link_hash_table
*htab
= xcoff_hash_table (info
);
4485 struct xcoff_link_hash_entry
*hcsect
;
4486 struct xcoff_stub_hash_entry
*hstub
;
4489 hcsect
= xcoff_stub_get_csect_in_range (section
, info
, false);
4493 stub_name
= xcoff_stub_name (h
, hcsect
);
4494 if (stub_name
== NULL
)
4497 hstub
= xcoff_stub_hash_lookup (&htab
->stub_hash_table
,
4498 stub_name
, false, false);
4504 /* Check if the symbol targeted by IREL is reachable.
4505 Return the type of stub needed otherwise. */
4506 enum xcoff_stub_type
4507 bfd_xcoff_type_of_stub (asection
*sec
,
4508 const struct internal_reloc
*irel
,
4509 bfd_vma destination
,
4510 struct xcoff_link_hash_entry
*h
)
4512 bfd_vma location
, offset
, max_offset
;
4514 switch (irel
->r_type
)
4517 return xcoff_stub_none
;
4521 location
= (sec
->output_section
->vma
4522 + sec
->output_offset
4526 max_offset
= 1 << 25 ;
4528 offset
= destination
- location
;
4530 if (offset
+ max_offset
< 2 * max_offset
)
4531 return xcoff_stub_none
;
4533 /* A stub is needed. Now, check that we can make one. */
4535 && h
->descriptor
!= NULL
)
4537 /* Not sure how to handle this case. For now, skip it. */
4538 if (bfd_is_abs_section (h
->root
.u
.def
.section
))
4539 return xcoff_stub_none
;
4541 if (h
->smclas
== XMC_GL
)
4542 return xcoff_stub_shared_call
;
4544 return xcoff_stub_indirect_call
;
4549 return xcoff_stub_none
;
4552 /* Add a new stub entry to the stub hash. Not all fields of the new
4553 stub entry are initialised. */
4554 static struct xcoff_stub_hash_entry
*
4555 xcoff_add_stub (const char *stub_name
,
4556 struct xcoff_link_hash_entry
*hstub_csect
,
4557 struct xcoff_link_hash_entry
*htarget
,
4558 struct bfd_link_info
*info
,
4559 enum xcoff_stub_type stub_type
)
4561 struct xcoff_link_hash_table
*htab
= xcoff_hash_table (info
);
4562 struct xcoff_stub_hash_entry
*hstub
;
4563 bfd_vma stub_offset
;
4564 asection
*stub_csect
;
4566 stub_csect
= hstub_csect
->root
.u
.def
.section
;
4567 stub_offset
= stub_csect
->size
;
4569 /* Update the relocation counter and the size of
4570 the containing csect. The size is needed for
4571 the algorithm in xcoff_stub_get_csect_in_range. */
4578 case xcoff_stub_indirect_call
:
4579 stub_csect
->reloc_count
++;
4580 stub_csect
->size
+= bfd_xcoff_stub_indirect_call_size (info
->output_bfd
);
4583 case xcoff_stub_shared_call
:
4584 stub_csect
->reloc_count
++;
4585 stub_csect
->size
+= bfd_xcoff_stub_shared_call_size (info
->output_bfd
);
4589 /* Create the stub entry. */
4590 hstub
= xcoff_stub_hash_lookup (&htab
->stub_hash_table
, stub_name
,
4595 hstub
->htarget
= htarget
;
4596 hstub
->stub_offset
= stub_offset
;
4598 /* For indirect call or shared call, the relocations are against
4599 the target descriptor. Its toc entry will be used. */
4600 if (stub_type
== xcoff_stub_indirect_call
4601 || stub_type
== xcoff_stub_shared_call
)
4603 struct xcoff_link_hash_entry
*hds
= htarget
->descriptor
;
4604 asection
*hds_section
= hds
->root
.u
.def
.section
;
4606 hstub
->htarget
= hds
;
4608 /* If the symbol haven't been marked, its section might have
4609 its size and its relocation count been deleted by xcoff_sweep.
4611 if ((hds
->flags
& XCOFF_MARK
) == 0)
4613 if (hds_section
->size
== 0
4614 && hds_section
->reloc_count
== 0
4615 && hds_section
->rawsize
!= 0)
4617 hds_section
->size
= hds_section
->rawsize
;
4618 /* Always two relocations for a XMC_DS symbol. */
4619 hds_section
->reloc_count
= 2;
4622 /* Mark the section and the symbol. */
4623 if (!xcoff_mark (info
, hds_section
))
4627 /* Add a TOC entry for the descriptor if non exists. */
4628 if (hds
->toc_section
== NULL
)
4632 if (bfd_xcoff_is_xcoff64 (info
->output_bfd
))
4634 else if (bfd_xcoff_is_xcoff32 (info
->output_bfd
))
4639 /* Allocate room in the fallback TOC section. */
4640 hds
->toc_section
= xcoff_hash_table (info
)->toc_section
;
4641 hds
->u
.toc_offset
= hds
->toc_section
->size
;
4642 hds
->toc_section
->size
+= byte_size
;
4643 if (!xcoff_mark (info
, hds
->toc_section
))
4646 /* Update relocation counters for a static and dynamic
4647 R_TOC relocation. */
4648 ++hds
->toc_section
->reloc_count
;
4649 ++htab
->ldinfo
.ldrel_count
;
4651 /* Set the index to -2 to force this symbol to
4654 hds
->flags
|= XCOFF_SET_TOC
;
4662 xcoff_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
4664 struct xcoff_stub_hash_entry
*hstub
4665 = (struct xcoff_stub_hash_entry
*) gen_entry
;
4669 struct bfd_link_info
*info
;
4674 info
= (struct bfd_link_info
*) in_arg
;
4675 stub_bfd
= xcoff_hash_table (info
)->params
->stub_bfd
;
4676 output_bfd
= info
->output_bfd
;
4678 /* Fail if the target section could not be assigned to an output
4679 section. The user should fix his linker script. */
4680 if (hstub
->target_section
!= NULL
4681 && hstub
->target_section
->output_section
== NULL
4682 && info
->non_contiguous_regions
)
4683 info
->callbacks
->einfo (_("%F%P: Could not assign `%pA' to an output section. "
4684 "Retry without --enable-non-contiguous-regions.\n"),
4685 hstub
->target_section
);
4687 loc
= (hstub
->hcsect
->root
.u
.def
.section
->contents
4688 + hstub
->stub_offset
);
4691 switch (hstub
->stub_type
)
4693 case xcoff_stub_indirect_call
:
4694 BFD_ASSERT (hstub
->htarget
->toc_section
!= NULL
);
4695 /* The first instruction in the stub code needs to be
4696 cooked to hold the correct offset in the toc. It will
4697 be filled by xcoff_stub_create_relocations. */
4698 for (i
= 0; i
< bfd_xcoff_stub_indirect_call_size(output_bfd
) / 4; i
++)
4699 bfd_put_32 (stub_bfd
,
4700 (bfd_vma
) bfd_xcoff_stub_indirect_call_code(output_bfd
, i
),
4704 case xcoff_stub_shared_call
:
4705 BFD_ASSERT (hstub
->htarget
->toc_section
!= NULL
);
4706 /* The first instruction in the glink code needs to be
4707 cooked to hold the correct offset in the toc. It will
4708 be filled by xcoff_stub_create_relocations. */
4709 for (i
= 0; i
< bfd_xcoff_stub_shared_call_size(output_bfd
) / 4; i
++)
4710 bfd_put_32 (stub_bfd
,
4711 (bfd_vma
) bfd_xcoff_stub_shared_call_code(output_bfd
, i
),
4723 /* Check relocations and adds stubs if needed. */
4726 bfd_xcoff_size_stubs (struct bfd_link_info
*info
)
4728 struct xcoff_link_hash_table
*htab
= xcoff_hash_table (info
);
4729 struct xcoff_loader_info
*ldinfo
= &(htab
->ldinfo
);
4734 bool stub_changed
= false;
4736 for (input_bfd
= info
->input_bfds
;
4738 input_bfd
= input_bfd
->link
.next
)
4741 bfd_size_type symcount
;
4742 bfd_size_type symesz
;
4745 if (bfd_get_flavour (input_bfd
) != bfd_target_xcoff_flavour
)
4748 symcount
= obj_raw_syment_count (input_bfd
);
4751 symesz
= bfd_coff_symesz (input_bfd
);
4752 esyms
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
4754 /* Walk over each section attached to the input bfd. */
4755 for (section
= input_bfd
->sections
;
4757 section
= section
->next
)
4759 struct internal_reloc
*internal_relocs
;
4760 struct internal_reloc
*irel
, *irelend
;
4762 /* If there aren't any relocs, then there's nothing more
4764 if ((section
->flags
& SEC_RELOC
) == 0
4765 || section
->reloc_count
== 0)
4768 /* If this section is a link-once section that will be
4769 discarded, then don't create any stubs. */
4770 if (section
->output_section
== NULL
4771 || section
->output_section
->owner
!= info
->output_bfd
)
4774 /* This section have been garbage-collected. */
4775 if (section
->gc_mark
== 0)
4778 /* Read in the relocs. */
4779 internal_relocs
= (xcoff_read_internal_relocs
4780 (input_bfd
, section
, true, NULL
,
4782 if (internal_relocs
== NULL
)
4785 irel
= internal_relocs
;
4786 irelend
= irel
+ section
->reloc_count
;
4787 for (; irel
< irelend
; irel
++)
4789 enum xcoff_stub_type stub_type
;
4790 struct xcoff_link_hash_entry
*hsym
= NULL
;
4791 struct xcoff_link_hash_entry
*hstub_csect
= NULL
;
4792 struct xcoff_stub_hash_entry
*hstub
= NULL
;
4795 bfd_vma destination
;
4798 if (irel
->r_symndx
== -1)
4801 switch (irel
->r_type
)
4811 /* Retrieve targeted symbol address */
4812 hsym
= obj_xcoff_sym_hashes (input_bfd
)[irel
->r_symndx
];
4815 struct internal_syment sym
;
4816 if ((long unsigned int)irel
->r_symndx
> symcount
)
4822 bfd_coff_swap_sym_in (input_bfd
,
4823 (void *) esyms
+ irel
->r_symndx
* symesz
,
4826 sym_sec
= xcoff_data (input_bfd
)->csects
[irel
->r_symndx
];
4827 sym_value
= sym
.n_value
- sym_sec
->vma
;
4829 destination
= (sym_value
4830 + sym_sec
->output_section
->vma
4831 + sym_sec
->output_offset
);
4833 else if (hsym
->root
.type
== bfd_link_hash_defined
4834 || hsym
->root
.type
== bfd_link_hash_defweak
)
4836 sym_sec
= hsym
->root
.u
.def
.section
;
4837 sym_value
= hsym
->root
.u
.def
.value
;
4838 destination
= (sym_value
4839 + sym_sec
->output_section
->vma
4840 + sym_sec
->output_offset
);
4844 bfd_set_error (bfd_error_bad_value
);
4848 /* I'm not sure how to handle this case. Skip it for now. */
4849 if (bfd_is_abs_section (sym_sec
))
4852 stub_type
= bfd_xcoff_type_of_stub (section
, irel
, destination
, hsym
);
4854 if (stub_type
== xcoff_stub_none
)
4857 /* Get a stub csect in ranch. */
4858 hstub_csect
= xcoff_stub_get_csect_in_range (section
, info
, true);
4861 /* xgettext:c-format */
4862 _bfd_error_handler (_("%pB: Unable to find a stub csect in range"
4863 "of relocation at %#" PRIx64
" targeting"
4865 section
->owner
, (uint64_t) irel
->r_vaddr
,
4866 hsym
->root
.root
.string
);
4870 /* Get the name of this stub. */
4871 stub_name
= xcoff_stub_name (hsym
, hstub_csect
);
4875 hstub
= xcoff_stub_hash_lookup (&(xcoff_hash_table (info
)->stub_hash_table
),
4876 stub_name
, false, false);
4878 /* A stub entry inside the in range csect already exists. */
4885 stub_changed
= true;
4887 hstub
= xcoff_add_stub (stub_name
, hstub_csect
, hsym
, info
, stub_type
);
4890 /* xgettext:c-format */
4891 _bfd_error_handler (_("%pB: Cannot create stub entry '%s'"),
4892 section
->owner
, stub_name
);
4897 hstub
->stub_type
= stub_type
;
4898 hstub
->hcsect
= hstub_csect
;
4899 hstub
->target_section
= sym_sec
;
4908 /* Update the size of the loader. */
4909 if (xcoff_hash_table (info
)->loader_section
4910 && !xcoff_size_loader_section (ldinfo
))
4913 /* Ask the linker to do its stuff. */
4914 (*htab
->params
->layout_sections_again
) ();
4920 bfd_set_error (bfd_error_bad_value
);
4925 bfd_xcoff_build_stubs (struct bfd_link_info
*info
)
4927 struct xcoff_link_hash_table
*htab
= xcoff_hash_table (info
);
4930 for (stub_sec
= htab
->params
->stub_bfd
->sections
;
4932 stub_sec
= stub_sec
->next
)
4936 /* Allocate memory to hold the linker stubs. */
4937 size
= stub_sec
->size
;
4938 stub_sec
->contents
= bfd_zalloc (htab
->params
->stub_bfd
, size
);
4939 if (stub_sec
->contents
== NULL
&& size
!= 0)
4944 /* Build the stubs as directed by the stub hash table. */
4945 bfd_hash_traverse (&htab
->stub_hash_table
, xcoff_build_one_stub
, info
);
4949 /* Create and apply relocations made by a stub entry. */
4951 xcoff_stub_create_relocations (struct bfd_hash_entry
*bh
, void * inf
)
4953 struct xcoff_stub_hash_entry
*hstub
4954 = (struct xcoff_stub_hash_entry
*) bh
;
4955 struct xcoff_final_link_info
*flinfo
4956 = (struct xcoff_final_link_info
*) inf
;
4959 struct internal_reloc
*irel
;
4960 struct xcoff_link_hash_entry
**rel_hash
;
4961 struct xcoff_link_hash_entry
*htarget
;
4962 asection
*sec
, *osec
;
4966 htarget
= hstub
->htarget
;
4967 sec
= hstub
->hcsect
->root
.u
.def
.section
;
4968 osec
= sec
->output_section
;
4970 irel
= (flinfo
->section_info
[osec
->target_index
].relocs
4971 + osec
->reloc_count
);
4972 rel_hash
= (flinfo
->section_info
[osec
->target_index
].rel_hashes
4973 + osec
->output_section
->reloc_count
);
4975 output_bfd
= flinfo
->output_bfd
;
4977 irel
->r_symndx
= htarget
->indx
;
4978 irel
->r_vaddr
= (osec
->vma
4979 + sec
->output_offset
4980 + hstub
->hcsect
->root
.u
.def
.value
4981 + hstub
->stub_offset
);
4984 + hstub
->stub_offset
);
4986 switch (hstub
->stub_type
)
4992 /* The first instruction of this stub code need
4993 a R_TOC relocation. */
4994 case xcoff_stub_indirect_call
:
4995 case xcoff_stub_shared_call
:
4997 irel
->r_type
= R_TOC
;
4999 /* Retrieve the toc offset of the target which is
5000 a function descriptor. */
5001 BFD_ASSERT (htarget
->toc_section
!= NULL
);
5002 if ((htarget
->flags
& XCOFF_SET_TOC
) != 0)
5003 off
= hstub
->htarget
->u
.toc_offset
;
5005 off
= (htarget
->toc_section
->output_section
->vma
5006 + htarget
->toc_section
->output_offset
5007 - xcoff_data (flinfo
->output_bfd
)->toc
);
5008 if ((off
& 0xffff) != off
)
5011 (_("TOC overflow during stub generation; try -mminimal-toc "
5013 bfd_set_error (bfd_error_file_too_big
);
5017 bfd_put_16 (output_bfd
, off
& 0xffff, p
+2);
5021 ++osec
->reloc_count
;
5026 /* Return the section that defines H. Return null if no section does. */
5029 xcoff_symbol_section (struct xcoff_link_hash_entry
*h
)
5031 switch (h
->root
.type
)
5033 case bfd_link_hash_defined
:
5034 case bfd_link_hash_defweak
:
5035 return h
->root
.u
.def
.section
;
5037 case bfd_link_hash_common
:
5038 return h
->root
.u
.c
.p
->section
;
5045 /* Add a .loader relocation for input relocation IREL. If the loader
5046 relocation should be against an output section, HSEC points to the
5047 input section that IREL is against, otherwise HSEC is null. H is the
5048 symbol that IREL is against, or null if it isn't against a global symbol.
5049 REFERENCE_BFD is the bfd to use in error messages about the relocation. */
5052 xcoff_create_ldrel (bfd
*output_bfd
, struct xcoff_final_link_info
*flinfo
,
5053 asection
*output_section
, bfd
*reference_bfd
,
5054 struct internal_reloc
*irel
, asection
*hsec
,
5055 struct xcoff_link_hash_entry
*h
)
5057 struct internal_ldrel ldrel
;
5059 ldrel
.l_vaddr
= irel
->r_vaddr
;
5062 const char *secname
;
5064 secname
= hsec
->output_section
->name
;
5065 if (strcmp (secname
, ".text") == 0)
5067 else if (strcmp (secname
, ".data") == 0)
5069 else if (strcmp (secname
, ".bss") == 0)
5071 else if (strcmp (secname
, ".tdata") == 0)
5072 ldrel
.l_symndx
= -1;
5073 else if (strcmp (secname
, ".tbss") == 0)
5074 ldrel
.l_symndx
= -2;
5078 /* xgettext:c-format */
5079 (_("%pB: loader reloc in unrecognized section `%s'"),
5080 reference_bfd
, secname
);
5081 bfd_set_error (bfd_error_nonrepresentable_section
);
5090 /* xgettext:c-format */
5091 (_("%pB: `%s' in loader reloc but not loader sym"),
5092 reference_bfd
, h
->root
.root
.string
);
5093 bfd_set_error (bfd_error_bad_value
);
5096 ldrel
.l_symndx
= h
->ldindx
;
5099 ldrel
.l_symndx
= -(bfd_size_type
) 1;
5101 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
5102 ldrel
.l_rsecnm
= output_section
->target_index
;
5103 if (xcoff_hash_table (flinfo
->info
)->textro
5104 && strcmp (output_section
->name
, ".text") == 0)
5107 /* xgettext:c-format */
5108 (_("%pB: loader reloc in read-only section %pA"),
5109 reference_bfd
, output_section
);
5110 bfd_set_error (bfd_error_invalid_operation
);
5113 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, flinfo
->ldrel
);
5114 flinfo
->ldrel
+= bfd_xcoff_ldrelsz (output_bfd
);
5118 /* Link an input file into the linker output file. This function
5119 handles all the sections and relocations of the input file at once. */
5122 xcoff_link_input_bfd (struct xcoff_final_link_info
*flinfo
,
5126 const char *strings
;
5127 bfd_size_type syment_base
;
5128 unsigned int n_tmask
;
5129 unsigned int n_btshft
;
5131 bfd_size_type isymesz
;
5132 bfd_size_type osymesz
;
5133 bfd_size_type linesz
;
5136 struct xcoff_link_hash_entry
**sym_hash
;
5137 struct internal_syment
*isymp
;
5139 unsigned int *lineno_counts
;
5142 unsigned long output_index
;
5149 /* We can just skip DYNAMIC files, unless this is a static link. */
5150 if ((input_bfd
->flags
& DYNAMIC
) != 0
5151 && ! flinfo
->info
->static_link
)
5154 /* Move all the symbols to the output file. */
5155 output_bfd
= flinfo
->output_bfd
;
5157 syment_base
= obj_raw_syment_count (output_bfd
);
5158 isymesz
= bfd_coff_symesz (input_bfd
);
5159 osymesz
= bfd_coff_symesz (output_bfd
);
5160 linesz
= bfd_coff_linesz (input_bfd
);
5161 BFD_ASSERT (linesz
== bfd_coff_linesz (output_bfd
));
5163 n_tmask
= coff_data (input_bfd
)->local_n_tmask
;
5164 n_btshft
= coff_data (input_bfd
)->local_n_btshft
;
5166 /* Define macros so that ISFCN, et. al., macros work correctly. */
5167 #define N_TMASK n_tmask
5168 #define N_BTSHFT n_btshft
5171 if (! flinfo
->info
->keep_memory
)
5174 if (flinfo
->info
->traditional_format
)
5177 if (! _bfd_coff_get_external_symbols (input_bfd
))
5180 /* Make one pass over the symbols and assign indices to symbols that
5181 we have decided to keep. Also use create .loader symbol information
5182 and update information in hash table entries. */
5183 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
5184 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
5185 sym_hash
= obj_xcoff_sym_hashes (input_bfd
);
5186 csectpp
= xcoff_data (input_bfd
)->csects
;
5187 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
5188 isymp
= flinfo
->internal_syms
;
5189 indexp
= flinfo
->sym_indices
;
5190 output_index
= syment_base
;
5191 while (esym
< esym_end
)
5193 union internal_auxent aux
;
5197 bfd_coff_swap_sym_in (input_bfd
, (void *) esym
, (void *) isymp
);
5199 /* Read in the csect information, if any. */
5200 if (CSECT_SYM_P (isymp
->n_sclass
))
5202 BFD_ASSERT (isymp
->n_numaux
> 0);
5203 bfd_coff_swap_aux_in (input_bfd
,
5204 (void *) (esym
+ isymesz
* isymp
->n_numaux
),
5205 isymp
->n_type
, isymp
->n_sclass
,
5206 isymp
->n_numaux
- 1, isymp
->n_numaux
,
5209 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
5212 /* If this symbol is in the .loader section, swap out the
5213 .loader symbol information. If this is an external symbol
5214 reference to a defined symbol, though, then wait until we get
5215 to the definition. */
5216 if (EXTERN_SYM_P (isymp
->n_sclass
)
5217 && *sym_hash
!= NULL
5218 && (*sym_hash
)->ldsym
!= NULL
5219 && xcoff_final_definition_p (input_bfd
, *sym_hash
, *csectpp
))
5221 struct xcoff_link_hash_entry
*h
;
5222 struct internal_ldsym
*ldsym
;
5226 if (isymp
->n_scnum
> 0)
5228 ldsym
->l_scnum
= (*csectpp
)->output_section
->target_index
;
5229 ldsym
->l_value
= (isymp
->n_value
5230 + (*csectpp
)->output_section
->vma
5231 + (*csectpp
)->output_offset
5236 ldsym
->l_scnum
= isymp
->n_scnum
;
5237 ldsym
->l_value
= isymp
->n_value
;
5240 ldsym
->l_smtype
= smtyp
;
5241 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
5242 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
5243 || (h
->flags
& XCOFF_IMPORT
) != 0)
5244 ldsym
->l_smtype
|= L_IMPORT
;
5245 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
5246 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
5247 || (h
->flags
& XCOFF_EXPORT
) != 0)
5248 ldsym
->l_smtype
|= L_EXPORT
;
5249 if ((h
->flags
& XCOFF_ENTRY
) != 0)
5250 ldsym
->l_smtype
|= L_ENTRY
;
5251 if (isymp
->n_sclass
== C_AIX_WEAKEXT
)
5252 ldsym
->l_smtype
|= L_WEAK
;
5254 ldsym
->l_smclas
= aux
.x_csect
.x_smclas
;
5256 if (ldsym
->l_ifile
== (bfd_size_type
) -1)
5258 else if (ldsym
->l_ifile
== 0)
5260 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
5266 if (h
->root
.type
== bfd_link_hash_defined
5267 || h
->root
.type
== bfd_link_hash_defweak
)
5268 impbfd
= h
->root
.u
.def
.section
->owner
;
5269 else if (h
->root
.type
== bfd_link_hash_undefined
5270 || h
->root
.type
== bfd_link_hash_undefweak
)
5271 impbfd
= h
->root
.u
.undef
.abfd
;
5279 BFD_ASSERT (impbfd
->xvec
== flinfo
->output_bfd
->xvec
);
5280 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
5287 BFD_ASSERT (h
->ldindx
>= 0);
5288 bfd_xcoff_swap_ldsym_out (flinfo
->output_bfd
, ldsym
,
5291 * bfd_xcoff_ldsymsz (flinfo
->output_bfd
))));
5294 /* Fill in snentry now that we know the target_index. */
5295 if ((h
->flags
& XCOFF_ENTRY
) != 0
5296 && (h
->root
.type
== bfd_link_hash_defined
5297 || h
->root
.type
== bfd_link_hash_defweak
))
5299 xcoff_data (output_bfd
)->snentry
=
5300 h
->root
.u
.def
.section
->output_section
->target_index
;
5304 add
= 1 + isymp
->n_numaux
;
5306 if (*debug_index
== -2)
5307 /* We've decided to strip this symbol. */
5311 /* Assign the next unused index to this symbol. */
5312 *indexp
= output_index
;
5314 if (EXTERN_SYM_P (isymp
->n_sclass
))
5316 BFD_ASSERT (*sym_hash
!= NULL
);
5317 (*sym_hash
)->indx
= output_index
;
5320 /* If this is a symbol in the TOC which we may have merged
5321 (class XMC_TC), remember the symbol index of the TOC
5323 if (isymp
->n_sclass
== C_HIDEXT
5324 && aux
.x_csect
.x_smclas
== XMC_TC
5325 && *sym_hash
!= NULL
)
5327 BFD_ASSERT (((*sym_hash
)->flags
& XCOFF_SET_TOC
) == 0);
5328 BFD_ASSERT ((*sym_hash
)->toc_section
!= NULL
);
5329 (*sym_hash
)->u
.toc_indx
= output_index
;
5332 output_index
+= add
;
5335 esym
+= add
* isymesz
;
5341 for (--add
; add
> 0; --add
)
5345 /* Now write out the symbols that we decided to keep. */
5347 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
5348 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
5349 sym_hash
= obj_xcoff_sym_hashes (input_bfd
);
5350 isymp
= flinfo
->internal_syms
;
5351 indexp
= flinfo
->sym_indices
;
5352 csectpp
= xcoff_data (input_bfd
)->csects
;
5353 lineno_counts
= xcoff_data (input_bfd
)->lineno_counts
;
5354 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
5355 outsym
= flinfo
->outsyms
;
5358 while (esym
< esym_end
)
5362 add
= 1 + isymp
->n_numaux
;
5365 esym
+= add
* isymesz
;
5368 struct internal_syment isym
;
5371 /* Adjust the symbol in order to output it. */
5373 if (isym
._n
._n_n
._n_zeroes
== 0
5374 && isym
._n
._n_n
._n_offset
!= 0)
5376 /* This symbol has a long name. Enter it in the string
5377 table we are building. If *debug_index != -1, the
5378 name has already been entered in the .debug section. */
5379 if (*debug_index
>= 0)
5380 isym
._n
._n_n
._n_offset
= *debug_index
;
5386 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, NULL
);
5390 indx
= _bfd_stringtab_add (flinfo
->strtab
, name
, hash
, copy
);
5391 if (indx
== (bfd_size_type
) -1)
5393 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
5397 /* Make __rtinit C_HIDEXT rather than C_EXT. This avoids
5398 multiple definition problems when linking a shared object
5399 statically. (The native linker doesn't enter __rtinit into
5400 the normal table at all, but having a local symbol can make
5401 the objdump output easier to read.) */
5402 if (isym
.n_sclass
== C_EXT
5404 && ((*sym_hash
)->flags
& XCOFF_RTINIT
) != 0)
5405 isym
.n_sclass
= C_HIDEXT
;
5407 /* The value of a C_FILE symbol is the symbol index of the
5408 next C_FILE symbol. The value of the last C_FILE symbol
5409 is -1. We try to get this right, below, just before we
5410 write the symbols out, but in the general case we may
5411 have to write the symbol out twice. */
5412 if (isym
.n_sclass
== C_FILE
)
5414 if (flinfo
->last_file_index
!= -1
5415 && flinfo
->last_file
.n_value
!= (bfd_vma
) *indexp
)
5417 /* We must correct the value of the last C_FILE entry. */
5418 flinfo
->last_file
.n_value
= *indexp
;
5419 if ((bfd_size_type
) flinfo
->last_file_index
>= syment_base
)
5421 /* The last C_FILE symbol is in this input file. */
5422 bfd_coff_swap_sym_out (output_bfd
,
5423 (void *) &flinfo
->last_file
,
5424 (void *) (flinfo
->outsyms
5425 + ((flinfo
->last_file_index
5431 /* We have already written out the last C_FILE
5432 symbol. We need to write it out again. We
5433 borrow *outsym temporarily. */
5436 bfd_coff_swap_sym_out (output_bfd
,
5437 (void *) &flinfo
->last_file
,
5440 pos
= obj_sym_filepos (output_bfd
);
5441 pos
+= flinfo
->last_file_index
* osymesz
;
5442 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5443 || (bfd_bwrite (outsym
, osymesz
, output_bfd
)
5449 flinfo
->last_file_index
= *indexp
;
5450 flinfo
->last_file
= isym
;
5453 /* The value of a C_BINCL or C_EINCL symbol is a file offset
5454 into the line numbers. We update the symbol values when
5455 we handle the line numbers. */
5456 if (isym
.n_sclass
== C_BINCL
5457 || isym
.n_sclass
== C_EINCL
)
5459 isym
.n_value
= flinfo
->line_filepos
;
5462 /* The value of a C_BSTAT symbol is the symbol table
5463 index of the containing csect. */
5464 else if (isym
.n_sclass
== C_BSTAT
)
5468 indx
= isym
.n_value
;
5469 if (indx
< obj_raw_syment_count (input_bfd
))
5473 symindx
= flinfo
->sym_indices
[indx
];
5477 isym
.n_value
= symindx
;
5480 else if (isym
.n_sclass
!= C_ESTAT
5481 && isym
.n_sclass
!= C_DECL
5482 && isym
.n_scnum
> 0)
5484 isym
.n_scnum
= (*csectpp
)->output_section
->target_index
;
5485 isym
.n_value
+= ((*csectpp
)->output_section
->vma
5486 + (*csectpp
)->output_offset
5490 /* Update visibility. */
5493 isym
.n_type
&= ~SYM_V_MASK
;
5494 isym
.n_type
|= (*sym_hash
)->visibility
;
5497 /* Output the symbol. */
5498 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
5503 for (i
= 0; i
< isymp
->n_numaux
&& esym
< esym_end
; i
++)
5505 union internal_auxent aux
;
5507 bfd_coff_swap_aux_in (input_bfd
, (void *) esym
, isymp
->n_type
,
5508 isymp
->n_sclass
, i
, isymp
->n_numaux
,
5511 if (isymp
->n_sclass
== C_FILE
)
5513 /* This is the file name (or some comment put in by
5514 the compiler). If it is long, we must put it in
5515 the string table. */
5516 if (aux
.x_file
.x_n
.x_n
.x_zeroes
== 0
5517 && aux
.x_file
.x_n
.x_n
.x_offset
!= 0)
5519 const char *filename
;
5522 BFD_ASSERT (aux
.x_file
.x_n
.x_n
.x_offset
5523 >= STRING_SIZE_SIZE
);
5524 if (strings
== NULL
)
5526 strings
= _bfd_coff_read_string_table (input_bfd
);
5527 if (strings
== NULL
)
5530 if ((bfd_size_type
) aux
.x_file
.x_n
.x_n
.x_offset
>= obj_coff_strings_len (input_bfd
))
5531 filename
= _("<corrupt>");
5533 filename
= strings
+ aux
.x_file
.x_n
.x_n
.x_offset
;
5534 indx
= _bfd_stringtab_add (flinfo
->strtab
, filename
,
5536 if (indx
== (bfd_size_type
) -1)
5538 aux
.x_file
.x_n
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
5541 else if (CSECT_SYM_P (isymp
->n_sclass
)
5542 && i
+ 1 == isymp
->n_numaux
)
5545 /* We don't support type checking. I don't know if
5547 aux
.x_csect
.x_parmhash
= 0;
5548 /* I don't think anybody uses these fields, but we'd
5549 better clobber them just in case. */
5550 aux
.x_csect
.x_stab
= 0;
5551 aux
.x_csect
.x_snstab
= 0;
5553 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_LD
)
5557 indx
= aux
.x_csect
.x_scnlen
.l
;
5558 if (indx
< obj_raw_syment_count (input_bfd
))
5562 symindx
= flinfo
->sym_indices
[indx
];
5565 aux
.x_csect
.x_scnlen
.l
= 0;
5569 aux
.x_csect
.x_scnlen
.l
= symindx
;
5574 else if (isymp
->n_sclass
!= C_STAT
|| isymp
->n_type
!= T_NULL
)
5578 if (ISFCN (isymp
->n_type
)
5579 || ISTAG (isymp
->n_sclass
)
5580 || isymp
->n_sclass
== C_BLOCK
5581 || isymp
->n_sclass
== C_FCN
)
5583 indx
= aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
5585 && indx
< obj_raw_syment_count (input_bfd
))
5587 /* We look forward through the symbol for
5588 the index of the next symbol we are going
5589 to include. I don't know if this is
5591 while (flinfo
->sym_indices
[indx
] < 0
5592 && indx
< obj_raw_syment_count (input_bfd
))
5594 if (indx
>= obj_raw_syment_count (input_bfd
))
5595 indx
= output_index
;
5597 indx
= flinfo
->sym_indices
[indx
];
5598 aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= indx
;
5603 indx
= aux
.x_sym
.x_tagndx
.l
;
5604 if (indx
> 0 && indx
< obj_raw_syment_count (input_bfd
))
5608 symindx
= flinfo
->sym_indices
[indx
];
5610 aux
.x_sym
.x_tagndx
.l
= 0;
5612 aux
.x_sym
.x_tagndx
.l
= symindx
;
5617 /* Copy over the line numbers, unless we are stripping
5618 them. We do this on a symbol by symbol basis in
5619 order to more easily handle garbage collection. */
5620 if (CSECT_SYM_P (isymp
->n_sclass
)
5622 && isymp
->n_numaux
> 1
5623 && ISFCN (isymp
->n_type
)
5624 && aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
5626 if (*lineno_counts
== 0)
5627 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
5630 asection
*enclosing
;
5631 unsigned int enc_count
;
5632 bfd_signed_vma linoff
;
5633 struct internal_lineno lin
;
5640 /* Read in the enclosing section's line-number
5641 information, if we haven't already. */
5643 enclosing
= xcoff_section_data (abfd
, o
)->enclosing
;
5644 enc_count
= xcoff_section_data (abfd
, o
)->lineno_count
;
5645 if (oline
!= enclosing
)
5647 pos
= enclosing
->line_filepos
;
5648 amt
= linesz
* enc_count
;
5649 if (bfd_seek (input_bfd
, pos
, SEEK_SET
) != 0
5650 || (bfd_bread (flinfo
->linenos
, amt
, input_bfd
)
5656 /* Copy across the first entry, adjusting its
5658 linoff
= (aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
5659 - enclosing
->line_filepos
);
5660 linp
= flinfo
->linenos
+ linoff
;
5661 bfd_coff_swap_lineno_in (input_bfd
, linp
, &lin
);
5662 lin
.l_addr
.l_symndx
= *indexp
;
5663 bfd_coff_swap_lineno_out (output_bfd
, &lin
, linp
);
5665 /* Copy the other entries, adjusting their addresses. */
5666 linpend
= linp
+ *lineno_counts
* linesz
;
5667 offset
= (o
->output_section
->vma
5670 for (linp
+= linesz
; linp
< linpend
; linp
+= linesz
)
5672 bfd_coff_swap_lineno_in (input_bfd
, linp
, &lin
);
5673 lin
.l_addr
.l_paddr
+= offset
;
5674 bfd_coff_swap_lineno_out (output_bfd
, &lin
, linp
);
5677 /* Write out the entries we've just processed. */
5678 pos
= (o
->output_section
->line_filepos
5679 + o
->output_section
->lineno_count
* linesz
);
5680 amt
= linesz
* *lineno_counts
;
5681 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5682 || bfd_bwrite (flinfo
->linenos
+ linoff
,
5683 amt
, output_bfd
) != amt
)
5685 o
->output_section
->lineno_count
+= *lineno_counts
;
5687 /* Record the offset of the symbol's line numbers
5688 in the output file. */
5689 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= pos
;
5693 struct internal_syment
*iisp
, *iispend
;
5696 bfd_vma range_start
, range_end
;
5699 /* Update any C_BINCL or C_EINCL symbols
5700 that refer to a line number in the
5701 range we just output. */
5702 iisp
= flinfo
->internal_syms
;
5703 iispend
= iisp
+ obj_raw_syment_count (input_bfd
);
5704 iindp
= flinfo
->sym_indices
;
5705 oos
= flinfo
->outsyms
;
5706 range_start
= enclosing
->line_filepos
+ linoff
;
5707 range_end
= range_start
+ *lineno_counts
* linesz
;
5708 while (iisp
< iispend
)
5711 && (iisp
->n_sclass
== C_BINCL
5712 || iisp
->n_sclass
== C_EINCL
)
5713 && iisp
->n_value
>= range_start
5714 && iisp
->n_value
< range_end
)
5716 struct internal_syment iis
;
5718 bfd_coff_swap_sym_in (output_bfd
, oos
, &iis
);
5719 iis
.n_value
= (iisp
->n_value
5722 bfd_coff_swap_sym_out (output_bfd
,
5727 iiadd
= 1 + iisp
->n_numaux
;
5729 oos
+= iiadd
* osymesz
;
5737 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, isymp
->n_type
,
5738 isymp
->n_sclass
, i
, isymp
->n_numaux
,
5749 lineno_counts
+= add
;
5753 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
5754 symbol will be the first symbol in the next input file. In the
5755 normal case, this will save us from writing out the C_FILE symbol
5757 if (flinfo
->last_file_index
!= -1
5758 && (bfd_size_type
) flinfo
->last_file_index
>= syment_base
)
5760 flinfo
->last_file
.n_value
= output_index
;
5761 bfd_coff_swap_sym_out (output_bfd
, (void *) &flinfo
->last_file
,
5762 (void *) (flinfo
->outsyms
5763 + ((flinfo
->last_file_index
- syment_base
)
5767 /* Write the modified symbols to the output file. */
5768 if (outsym
> flinfo
->outsyms
)
5770 file_ptr pos
= obj_sym_filepos (output_bfd
) + syment_base
* osymesz
;
5771 bfd_size_type amt
= outsym
- flinfo
->outsyms
;
5772 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5773 || bfd_bwrite (flinfo
->outsyms
, amt
, output_bfd
) != amt
)
5776 BFD_ASSERT ((obj_raw_syment_count (output_bfd
)
5777 + (outsym
- flinfo
->outsyms
) / osymesz
)
5780 obj_raw_syment_count (output_bfd
) = output_index
;
5783 /* Don't let the linker relocation routines discard the symbols. */
5784 keep_syms
= obj_coff_keep_syms (input_bfd
);
5785 obj_coff_keep_syms (input_bfd
) = true;
5787 /* Relocate the contents of each section. */
5788 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5792 if (! o
->linker_mark
)
5793 /* This section was omitted from the link. */
5796 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5798 || (o
->flags
& SEC_IN_MEMORY
) != 0)
5801 /* We have set filepos correctly for the sections we created to
5802 represent csects, so bfd_get_section_contents should work. */
5803 if (coff_section_data (input_bfd
, o
) != NULL
5804 && coff_section_data (input_bfd
, o
)->contents
!= NULL
)
5805 contents
= coff_section_data (input_bfd
, o
)->contents
;
5808 bfd_size_type sz
= o
->rawsize
? o
->rawsize
: o
->size
;
5809 if (!bfd_get_section_contents (input_bfd
, o
, flinfo
->contents
, 0, sz
))
5811 contents
= flinfo
->contents
;
5814 if ((o
->flags
& SEC_RELOC
) != 0)
5817 struct internal_reloc
*internal_relocs
;
5818 struct internal_reloc
*irel
;
5820 struct internal_reloc
*irelend
;
5821 struct xcoff_link_hash_entry
**rel_hash
;
5824 /* Read in the relocs. */
5825 target_index
= o
->output_section
->target_index
;
5826 internal_relocs
= (xcoff_read_internal_relocs
5827 (input_bfd
, o
, false, flinfo
->external_relocs
,
5829 (flinfo
->section_info
[target_index
].relocs
5830 + o
->output_section
->reloc_count
)));
5831 if (internal_relocs
== NULL
)
5834 /* Call processor specific code to relocate the section
5836 if (! bfd_coff_relocate_section (output_bfd
, flinfo
->info
,
5840 flinfo
->internal_syms
,
5841 xcoff_data (input_bfd
)->csects
))
5844 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
5845 irel
= internal_relocs
;
5846 irelend
= irel
+ o
->reloc_count
;
5847 rel_hash
= (flinfo
->section_info
[target_index
].rel_hashes
5848 + o
->output_section
->reloc_count
);
5849 for (; irel
< irelend
; irel
++, rel_hash
++)
5851 struct xcoff_link_hash_entry
*h
= NULL
;
5855 /* Adjust the reloc address and symbol index. */
5857 r_symndx
= irel
->r_symndx
;
5862 h
= obj_xcoff_sym_hashes (input_bfd
)[r_symndx
];
5864 /* In case of a R_BR or R_RBR, change the target if
5865 a stub is being called. */
5867 && (irel
->r_type
== R_BR
5868 || irel
->r_type
== R_RBR
))
5872 struct xcoff_stub_hash_entry
*hstub
= NULL
;
5873 enum xcoff_stub_type stub_type
;
5875 if (h
->root
.type
== bfd_link_hash_defined
5876 || h
->root
.type
== bfd_link_hash_defweak
)
5878 sym_sec
= h
->root
.u
.def
.section
;
5879 dest
= (h
->root
.u
.def
.value
5880 + sym_sec
->output_section
->vma
5881 + sym_sec
->output_offset
);
5889 stub_type
= bfd_xcoff_type_of_stub (o
, irel
, dest
, h
);
5890 if (stub_type
!= xcoff_stub_none
)
5892 hstub
= bfd_xcoff_get_stub_entry (o
, h
, flinfo
->info
);
5901 irel
->r_vaddr
+= offset
;
5903 if (r_symndx
!= -1 && flinfo
->info
->strip
!= strip_all
)
5907 && h
->smclas
!= XMC_TD
5908 && (irel
->r_type
== R_TOC
5909 || irel
->r_type
== R_GL
5910 || irel
->r_type
== R_TCL
5911 || irel
->r_type
== R_TRL
5912 || irel
->r_type
== R_TRLA
))
5914 /* This is a TOC relative reloc with a symbol
5915 attached. The symbol should be the one which
5916 this reloc is for. We want to make this
5917 reloc against the TOC address of the symbol,
5918 not the symbol itself. */
5919 BFD_ASSERT (h
->toc_section
!= NULL
);
5920 BFD_ASSERT ((h
->flags
& XCOFF_SET_TOC
) == 0);
5921 if (h
->u
.toc_indx
!= -1)
5922 irel
->r_symndx
= h
->u
.toc_indx
;
5925 struct xcoff_toc_rel_hash
*n
;
5926 struct xcoff_link_section_info
*si
;
5930 n
= bfd_alloc (flinfo
->output_bfd
, amt
);
5933 si
= flinfo
->section_info
+ target_index
;
5934 n
->next
= si
->toc_rel_hashes
;
5937 si
->toc_rel_hashes
= n
;
5942 /* This is a global symbol. */
5944 irel
->r_symndx
= h
->indx
;
5947 /* This symbol is being written at the end
5948 of the file, and we do not yet know the
5949 symbol index. We save the pointer to the
5950 hash table entry in the rel_hash list.
5951 We set the indx field to -2 to indicate
5952 that this symbol must not be stripped. */
5961 indx
= flinfo
->sym_indices
[r_symndx
];
5965 struct internal_syment
*is
;
5967 /* Relocations against a TC0 TOC anchor are
5968 automatically transformed to be against
5969 the TOC anchor in the output file. */
5970 is
= flinfo
->internal_syms
+ r_symndx
;
5971 if (is
->n_sclass
== C_HIDEXT
5972 && is
->n_numaux
> 0)
5975 union internal_auxent aux
;
5979 obj_coff_external_syms (input_bfd
))
5980 + ((r_symndx
+ is
->n_numaux
)
5982 bfd_coff_swap_aux_in (input_bfd
, auxptr
,
5983 is
->n_type
, is
->n_sclass
,
5987 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_SD
5988 && aux
.x_csect
.x_smclas
== XMC_TC0
)
5989 indx
= flinfo
->toc_symindx
;
5994 irel
->r_symndx
= indx
;
5998 struct internal_syment
*is
;
6001 char buf
[SYMNMLEN
+ 1];
6003 /* This reloc is against a symbol we are
6004 stripping. It would be possible to handle
6005 this case, but I don't think it's worth it. */
6006 is
= flinfo
->internal_syms
+ r_symndx
;
6008 if (is
->n_sclass
!= C_DWARF
)
6010 name
= (_bfd_coff_internal_syment_name
6011 (input_bfd
, is
, buf
));
6016 (*flinfo
->info
->callbacks
->unattached_reloc
)
6017 (flinfo
->info
, name
,
6018 input_bfd
, o
, irel
->r_vaddr
);
6024 if ((o
->flags
& SEC_DEBUGGING
) == 0
6025 && xcoff_need_ldrel_p (flinfo
->info
, irel
, h
, o
))
6032 sec
= xcoff_data (input_bfd
)->csects
[r_symndx
];
6034 sec
= xcoff_symbol_section (h
);
6035 if (!xcoff_create_ldrel (output_bfd
, flinfo
,
6036 o
->output_section
, input_bfd
,
6042 o
->output_section
->reloc_count
+= o
->reloc_count
;
6045 /* Write out the modified section contents. */
6046 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
6047 contents
, (file_ptr
) o
->output_offset
,
6052 obj_coff_keep_syms (input_bfd
) = keep_syms
;
6054 if (! flinfo
->info
->keep_memory
)
6056 if (! _bfd_coff_free_symbols (input_bfd
))
6063 obj_coff_keep_syms (input_bfd
) = keep_syms
;
6070 /* Sort relocs by VMA. This is called via qsort. */
6073 xcoff_sort_relocs (const void * p1
, const void * p2
)
6075 const struct internal_reloc
*r1
= (const struct internal_reloc
*) p1
;
6076 const struct internal_reloc
*r2
= (const struct internal_reloc
*) p2
;
6078 if (r1
->r_vaddr
> r2
->r_vaddr
)
6080 else if (r1
->r_vaddr
< r2
->r_vaddr
)
6086 /* Return true if section SEC is a TOC section. */
6089 xcoff_toc_section_p (asection
*sec
)
6094 if (name
[0] == '.' && name
[1] == 't')
6098 if (name
[3] == '0' && name
[4] == 0)
6103 if (name
[2] == 'd' && name
[3] == 0)
6109 /* See if the link requires a TOC (it usually does!). If so, find a
6110 good place to put the TOC anchor csect, and write out the associated
6114 xcoff_find_tc0 (bfd
*output_bfd
, struct xcoff_final_link_info
*flinfo
)
6116 bfd_vma toc_start
, toc_end
, start
, end
, best_address
;
6120 struct internal_syment irsym
;
6121 union internal_auxent iraux
;
6125 /* Set [TOC_START, TOC_END) to the range of the TOC. Record the
6126 index of a csect at the beginning of the TOC. */
6127 toc_start
= ~(bfd_vma
) 0;
6130 for (input_bfd
= flinfo
->info
->input_bfds
;
6132 input_bfd
= input_bfd
->link
.next
)
6133 for (sec
= input_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6134 if (sec
->gc_mark
!= 0 && xcoff_toc_section_p (sec
))
6136 start
= sec
->output_section
->vma
+ sec
->output_offset
;
6137 if (toc_start
> start
)
6140 section_index
= sec
->output_section
->target_index
;
6143 end
= start
+ sec
->size
;
6148 /* There's no need for a TC0 symbol if we don't have a TOC. */
6149 if (toc_end
< toc_start
)
6151 xcoff_data (output_bfd
)->toc
= toc_start
;
6155 if (toc_end
- toc_start
< 0x8000)
6156 /* Every TOC csect can be accessed from TOC_START. */
6157 best_address
= toc_start
;
6160 /* Find the lowest TOC csect that is still within range of TOC_END. */
6161 best_address
= toc_end
;
6162 for (input_bfd
= flinfo
->info
->input_bfds
;
6164 input_bfd
= input_bfd
->link
.next
)
6165 for (sec
= input_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6166 if (sec
->gc_mark
!= 0 && xcoff_toc_section_p (sec
))
6168 start
= sec
->output_section
->vma
+ sec
->output_offset
;
6169 if (start
< best_address
6170 && start
+ 0x8000 >= toc_end
)
6172 best_address
= start
;
6173 section_index
= sec
->output_section
->target_index
;
6177 /* Make sure that the start of the TOC is also within range. */
6178 if (best_address
> toc_start
+ 0x8000)
6181 (_("TOC overflow: %#" PRIx64
" > 0x10000; try -mminimal-toc "
6183 (uint64_t) (toc_end
- toc_start
));
6184 bfd_set_error (bfd_error_file_too_big
);
6189 /* Record the chosen TOC value. */
6190 flinfo
->toc_symindx
= obj_raw_syment_count (output_bfd
);
6191 xcoff_data (output_bfd
)->toc
= best_address
;
6192 xcoff_data (output_bfd
)->sntoc
= section_index
;
6194 /* Fill out the TC0 symbol. */
6195 if (!bfd_xcoff_put_symbol_name (output_bfd
, flinfo
->info
, flinfo
->strtab
,
6198 irsym
.n_value
= best_address
;
6199 irsym
.n_scnum
= section_index
;
6200 irsym
.n_sclass
= C_HIDEXT
;
6201 irsym
.n_type
= T_NULL
;
6203 bfd_coff_swap_sym_out (output_bfd
, &irsym
, flinfo
->outsyms
);
6205 /* Fill out the auxiliary csect information. */
6206 memset (&iraux
, 0, sizeof iraux
);
6207 iraux
.x_csect
.x_smtyp
= XTY_SD
;
6208 iraux
.x_csect
.x_smclas
= XMC_TC0
;
6209 iraux
.x_csect
.x_scnlen
.l
= 0;
6210 bfd_coff_swap_aux_out (output_bfd
, &iraux
, T_NULL
, C_HIDEXT
, 0, 1,
6211 flinfo
->outsyms
+ bfd_coff_symesz (output_bfd
));
6213 /* Write the contents to the file. */
6214 pos
= obj_sym_filepos (output_bfd
);
6215 pos
+= obj_raw_syment_count (output_bfd
) * bfd_coff_symesz (output_bfd
);
6216 size
= 2 * bfd_coff_symesz (output_bfd
);
6217 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
6218 || bfd_bwrite (flinfo
->outsyms
, size
, output_bfd
) != size
)
6220 obj_raw_syment_count (output_bfd
) += 2;
6225 /* Write out a non-XCOFF global symbol. */
6228 xcoff_write_global_symbol (struct bfd_hash_entry
*bh
, void * inf
)
6230 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) bh
;
6231 struct xcoff_final_link_info
*flinfo
= (struct xcoff_final_link_info
*) inf
;
6234 struct internal_syment isym
;
6235 union internal_auxent aux
;
6240 output_bfd
= flinfo
->output_bfd
;
6241 outsym
= flinfo
->outsyms
;
6243 if (h
->root
.type
== bfd_link_hash_warning
)
6245 h
= (struct xcoff_link_hash_entry
*) h
->root
.u
.i
.link
;
6246 if (h
->root
.type
== bfd_link_hash_new
)
6250 /* If this symbol was garbage collected, just skip it. */
6251 if (xcoff_hash_table (flinfo
->info
)->gc
6252 && (h
->flags
& XCOFF_MARK
) == 0)
6255 /* If we need a .loader section entry, write it out. */
6256 if (h
->ldsym
!= NULL
)
6258 struct internal_ldsym
*ldsym
;
6263 if (h
->root
.type
== bfd_link_hash_undefined
6264 || h
->root
.type
== bfd_link_hash_undefweak
)
6268 ldsym
->l_scnum
= N_UNDEF
;
6269 ldsym
->l_smtype
= XTY_ER
;
6270 impbfd
= h
->root
.u
.undef
.abfd
;
6273 else if (h
->root
.type
== bfd_link_hash_defined
6274 || h
->root
.type
== bfd_link_hash_defweak
)
6278 sec
= h
->root
.u
.def
.section
;
6279 ldsym
->l_value
= (sec
->output_section
->vma
6280 + sec
->output_offset
6281 + h
->root
.u
.def
.value
);
6282 ldsym
->l_scnum
= sec
->output_section
->target_index
;
6283 ldsym
->l_smtype
= XTY_SD
;
6284 impbfd
= sec
->owner
;
6290 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
6291 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
6292 || (h
->flags
& XCOFF_IMPORT
) != 0)
6294 Import symbols are defined so the check above will make
6295 the l_smtype XTY_SD. But this is not correct, it should
6297 ldsym
->l_smtype
|= L_IMPORT
;
6299 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
6300 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
6301 || (h
->flags
& XCOFF_EXPORT
) != 0)
6302 ldsym
->l_smtype
|= L_EXPORT
;
6304 if ((h
->flags
& XCOFF_ENTRY
) != 0)
6305 ldsym
->l_smtype
|= L_ENTRY
;
6307 if ((h
->flags
& XCOFF_RTINIT
) != 0)
6308 ldsym
->l_smtype
= XTY_SD
;
6310 ldsym
->l_smclas
= h
->smclas
;
6312 if (ldsym
->l_smtype
& L_IMPORT
)
6314 if ((h
->root
.type
== bfd_link_hash_defined
6315 || h
->root
.type
== bfd_link_hash_defweak
)
6316 && (h
->root
.u
.def
.value
!= 0))
6317 ldsym
->l_smclas
= XMC_XO
;
6319 else if ((h
->flags
& (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
)) ==
6320 (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
))
6321 ldsym
->l_smclas
= XMC_SV3264
;
6323 else if (h
->flags
& XCOFF_SYSCALL32
)
6324 ldsym
->l_smclas
= XMC_SV
;
6326 else if (h
->flags
& XCOFF_SYSCALL64
)
6327 ldsym
->l_smclas
= XMC_SV64
;
6330 if (ldsym
->l_ifile
== -(bfd_size_type
) 1)
6334 else if (ldsym
->l_ifile
== 0)
6336 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
6338 else if (impbfd
== NULL
)
6342 BFD_ASSERT (impbfd
->xvec
== output_bfd
->xvec
);
6343 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
6349 BFD_ASSERT (h
->ldindx
>= 0);
6351 bfd_xcoff_swap_ldsym_out (output_bfd
, ldsym
,
6354 * bfd_xcoff_ldsymsz(flinfo
->output_bfd
)));
6358 /* If this symbol needs global linkage code, write it out. */
6359 if (h
->root
.type
== bfd_link_hash_defined
6360 && (h
->root
.u
.def
.section
6361 == xcoff_hash_table (flinfo
->info
)->linkage_section
))
6367 p
= h
->root
.u
.def
.section
->contents
+ h
->root
.u
.def
.value
;
6369 /* The first instruction in the global linkage code loads a
6370 specific TOC element. */
6371 tocoff
= (h
->descriptor
->toc_section
->output_section
->vma
6372 + h
->descriptor
->toc_section
->output_offset
6373 - xcoff_data (output_bfd
)->toc
);
6375 if ((h
->descriptor
->flags
& XCOFF_SET_TOC
) != 0)
6376 tocoff
+= h
->descriptor
->u
.toc_offset
;
6378 /* The first instruction in the glink code needs to be
6379 cooked to hold the correct offset in the toc. The
6380 rest are just output raw. */
6381 bfd_put_32 (output_bfd
,
6382 bfd_xcoff_glink_code(output_bfd
, 0) | (tocoff
& 0xffff), p
);
6384 /* Start with i == 1 to get past the first instruction done above
6385 The /4 is because the glink code is in bytes and we are going
6387 for (i
= 1; i
< bfd_xcoff_glink_code_size(output_bfd
) / 4; i
++)
6388 bfd_put_32 (output_bfd
,
6389 (bfd_vma
) bfd_xcoff_glink_code(output_bfd
, i
),
6393 /* If we created a TOC entry for this symbol, write out the required
6395 if ((h
->flags
& XCOFF_SET_TOC
) != 0)
6400 struct internal_reloc
*irel
;
6401 struct internal_syment irsym
;
6402 union internal_auxent iraux
;
6404 tocsec
= h
->toc_section
;
6405 osec
= tocsec
->output_section
;
6406 oindx
= osec
->target_index
;
6407 irel
= flinfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
6408 irel
->r_vaddr
= (osec
->vma
6409 + tocsec
->output_offset
6413 irel
->r_symndx
= h
->indx
;
6417 irel
->r_symndx
= obj_raw_syment_count (output_bfd
);
6420 /* Initialize the aux union here instead of closer to when it is
6421 written out below because the length of the csect depends on
6422 whether the output is 32 or 64 bit. */
6423 memset (&iraux
, 0, sizeof iraux
);
6424 iraux
.x_csect
.x_smtyp
= XTY_SD
;
6425 /* iraux.x_csect.x_scnlen.l = 4 or 8, see below. */
6426 iraux
.x_csect
.x_smclas
= XMC_TC
;
6428 /* 32 bit uses a 32 bit R_POS to do the relocations
6429 64 bit uses a 64 bit R_POS to do the relocations
6431 Also needs to change the csect size : 4 for 32 bit, 8 for 64 bit
6433 Which one is determined by the backend. */
6434 if (bfd_xcoff_is_xcoff64 (output_bfd
))
6437 iraux
.x_csect
.x_scnlen
.l
= 8;
6439 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
6442 iraux
.x_csect
.x_scnlen
.l
= 4;
6447 irel
->r_type
= R_POS
;
6448 flinfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
6449 ++osec
->reloc_count
;
6451 /* There are two kind of linker-created TOC entry.
6452 The ones importing their symbols from outside, made for the
6453 global linkage. These symbols have XCOFF_LDREL set and only
6454 requires a loader relocation on their imported symbol.
6455 On the other hand, symbols without XCOFF_LDREL are TOC entries
6456 of internal symbols (like function descriptors made for stubs).
6457 These symbols needs a loader relocation over .data and this
6458 relocation must be applied. */
6460 if ((h
->flags
& XCOFF_LDREL
) != 0
6463 if (!xcoff_create_ldrel (output_bfd
, flinfo
, osec
,
6464 output_bfd
, irel
, NULL
, h
))
6472 p
= tocsec
->contents
+ h
->u
.toc_offset
;
6473 val
= (h
->root
.u
.def
.value
6474 + h
->root
.u
.def
.section
->output_section
->vma
6475 + h
->root
.u
.def
.section
->output_offset
);
6477 if (bfd_xcoff_is_xcoff64 (output_bfd
))
6478 bfd_put_64 (output_bfd
, val
, p
);
6479 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
6480 bfd_put_32 (output_bfd
, val
, p
);
6484 if (!xcoff_create_ldrel (output_bfd
, flinfo
, osec
,
6485 output_bfd
, irel
, h
->root
.u
.def
.section
, h
))
6489 /* We need to emit a symbol to define a csect which holds
6491 if (flinfo
->info
->strip
!= strip_all
)
6493 result
= bfd_xcoff_put_symbol_name (output_bfd
, flinfo
->info
,
6495 &irsym
, h
->root
.root
.string
);
6499 irsym
.n_value
= irel
->r_vaddr
;
6500 irsym
.n_scnum
= osec
->target_index
;
6501 irsym
.n_sclass
= C_HIDEXT
;
6502 irsym
.n_type
= T_NULL
;
6505 bfd_coff_swap_sym_out (output_bfd
, (void *) &irsym
, (void *) outsym
);
6506 outsym
+= bfd_coff_symesz (output_bfd
);
6508 /* Note : iraux is initialized above. */
6509 bfd_coff_swap_aux_out (output_bfd
, (void *) &iraux
, T_NULL
, C_HIDEXT
,
6510 0, 1, (void *) outsym
);
6511 outsym
+= bfd_coff_auxesz (output_bfd
);
6515 /* We aren't going to write out the symbols below, so we
6516 need to write them out now. */
6517 pos
= obj_sym_filepos (output_bfd
);
6518 pos
+= (obj_raw_syment_count (output_bfd
)
6519 * bfd_coff_symesz (output_bfd
));
6520 amt
= outsym
- flinfo
->outsyms
;
6521 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
6522 || bfd_bwrite (flinfo
->outsyms
, amt
, output_bfd
) != amt
)
6524 obj_raw_syment_count (output_bfd
) +=
6525 (outsym
- flinfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
6527 outsym
= flinfo
->outsyms
;
6532 /* If this symbol is a specially defined function descriptor, write
6533 it out. The first word is the address of the function code
6534 itself, the second word is the address of the TOC, and the third
6538 The addresses for the 32 bit will take 4 bytes and the addresses
6539 for 64 bit will take 8 bytes. Similar for the relocs. This type
6540 of logic was also done above to create a TOC entry in
6541 xcoff_write_global_symbol. */
6542 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
6543 && h
->root
.type
== bfd_link_hash_defined
6544 && (h
->root
.u
.def
.section
6545 == xcoff_hash_table (flinfo
->info
)->descriptor_section
))
6551 struct xcoff_link_hash_entry
*hentry
;
6553 struct internal_reloc
*irel
;
6555 unsigned int reloc_size
, byte_size
;
6557 if (bfd_xcoff_is_xcoff64 (output_bfd
))
6562 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
6570 sec
= h
->root
.u
.def
.section
;
6571 osec
= sec
->output_section
;
6572 oindx
= osec
->target_index
;
6573 p
= sec
->contents
+ h
->root
.u
.def
.value
;
6575 hentry
= h
->descriptor
;
6576 BFD_ASSERT (hentry
!= NULL
6577 && (hentry
->root
.type
== bfd_link_hash_defined
6578 || hentry
->root
.type
== bfd_link_hash_defweak
));
6579 esec
= hentry
->root
.u
.def
.section
;
6581 irel
= flinfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
6582 irel
->r_vaddr
= (osec
->vma
6583 + sec
->output_offset
6584 + h
->root
.u
.def
.value
);
6585 irel
->r_symndx
= esec
->output_section
->target_index
;
6586 irel
->r_type
= R_POS
;
6587 irel
->r_size
= reloc_size
;
6588 flinfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
6589 ++osec
->reloc_count
;
6591 if (!xcoff_create_ldrel (output_bfd
, flinfo
, osec
,
6592 output_bfd
, irel
, esec
, NULL
))
6595 /* There are three items to write out,
6596 the address of the code
6597 the address of the toc anchor
6598 the environment pointer.
6599 We are ignoring the environment pointer. So set it to zero. */
6600 if (bfd_xcoff_is_xcoff64 (output_bfd
))
6602 bfd_put_64 (output_bfd
,
6603 (esec
->output_section
->vma
+ esec
->output_offset
6604 + hentry
->root
.u
.def
.value
),
6606 bfd_put_64 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 8);
6607 bfd_put_64 (output_bfd
, (bfd_vma
) 0, p
+ 16);
6612 This logic was already called above so the error case where
6613 the backend is neither has already been checked. */
6614 bfd_put_32 (output_bfd
,
6615 (esec
->output_section
->vma
+ esec
->output_offset
6616 + hentry
->root
.u
.def
.value
),
6618 bfd_put_32 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 4);
6619 bfd_put_32 (output_bfd
, (bfd_vma
) 0, p
+ 8);
6622 tsec
= coff_section_from_bfd_index (output_bfd
,
6623 xcoff_data (output_bfd
)->sntoc
);
6626 irel
->r_vaddr
= (osec
->vma
6627 + sec
->output_offset
6628 + h
->root
.u
.def
.value
6630 irel
->r_symndx
= tsec
->output_section
->target_index
;
6631 irel
->r_type
= R_POS
;
6632 irel
->r_size
= reloc_size
;
6633 flinfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
6634 ++osec
->reloc_count
;
6636 if (!xcoff_create_ldrel (output_bfd
, flinfo
, osec
,
6637 output_bfd
, irel
, tsec
, NULL
))
6641 if (h
->indx
>= 0 || flinfo
->info
->strip
== strip_all
)
6643 BFD_ASSERT (outsym
== flinfo
->outsyms
);
6648 && (flinfo
->info
->strip
== strip_all
6649 || (flinfo
->info
->strip
== strip_some
6650 && bfd_hash_lookup (flinfo
->info
->keep_hash
, h
->root
.root
.string
,
6651 false, false) == NULL
)))
6653 BFD_ASSERT (outsym
== flinfo
->outsyms
);
6658 && (h
->flags
& (XCOFF_REF_REGULAR
| XCOFF_DEF_REGULAR
)) == 0)
6660 BFD_ASSERT (outsym
== flinfo
->outsyms
);
6664 memset (&aux
, 0, sizeof aux
);
6666 h
->indx
= obj_raw_syment_count (output_bfd
);
6668 result
= bfd_xcoff_put_symbol_name (output_bfd
, flinfo
->info
, flinfo
->strtab
,
6669 &isym
, h
->root
.root
.string
);
6673 if (h
->root
.type
== bfd_link_hash_undefined
6674 || h
->root
.type
== bfd_link_hash_undefweak
)
6677 isym
.n_scnum
= N_UNDEF
;
6678 if (h
->root
.type
== bfd_link_hash_undefweak
6679 && C_WEAKEXT
== C_AIX_WEAKEXT
)
6680 isym
.n_sclass
= C_WEAKEXT
;
6682 isym
.n_sclass
= C_EXT
;
6683 aux
.x_csect
.x_smtyp
= XTY_ER
;
6685 else if ((h
->root
.type
== bfd_link_hash_defined
6686 || h
->root
.type
== bfd_link_hash_defweak
)
6687 && h
->smclas
== XMC_XO
)
6689 BFD_ASSERT (bfd_is_abs_symbol (&h
->root
));
6690 isym
.n_value
= h
->root
.u
.def
.value
;
6691 isym
.n_scnum
= N_UNDEF
;
6692 if (h
->root
.type
== bfd_link_hash_defweak
6693 && C_WEAKEXT
== C_AIX_WEAKEXT
)
6694 isym
.n_sclass
= C_WEAKEXT
;
6696 isym
.n_sclass
= C_EXT
;
6697 aux
.x_csect
.x_smtyp
= XTY_ER
;
6699 else if (h
->root
.type
== bfd_link_hash_defined
6700 || h
->root
.type
== bfd_link_hash_defweak
)
6702 struct xcoff_link_size_list
*l
;
6704 isym
.n_value
= (h
->root
.u
.def
.section
->output_section
->vma
6705 + h
->root
.u
.def
.section
->output_offset
6706 + h
->root
.u
.def
.value
);
6707 if (bfd_is_abs_section (h
->root
.u
.def
.section
->output_section
))
6708 isym
.n_scnum
= N_ABS
;
6710 isym
.n_scnum
= h
->root
.u
.def
.section
->output_section
->target_index
;
6711 isym
.n_sclass
= C_HIDEXT
;
6712 aux
.x_csect
.x_smtyp
= XTY_SD
;
6714 /* For stub symbols, the section already has its correct size. */
6715 if (h
->root
.u
.def
.section
->owner
== xcoff_hash_table (flinfo
->info
)->params
->stub_bfd
)
6717 aux
.x_csect
.x_scnlen
.l
= h
->root
.u
.def
.section
->size
;
6719 else if ((h
->flags
& XCOFF_HAS_SIZE
) != 0)
6721 for (l
= xcoff_hash_table (flinfo
->info
)->size_list
;
6727 aux
.x_csect
.x_scnlen
.l
= l
->size
;
6733 else if (h
->root
.type
== bfd_link_hash_common
)
6735 isym
.n_value
= (h
->root
.u
.c
.p
->section
->output_section
->vma
6736 + h
->root
.u
.c
.p
->section
->output_offset
);
6737 isym
.n_scnum
= h
->root
.u
.c
.p
->section
->output_section
->target_index
;
6738 isym
.n_sclass
= C_EXT
;
6739 aux
.x_csect
.x_smtyp
= XTY_CM
;
6740 aux
.x_csect
.x_scnlen
.l
= h
->root
.u
.c
.size
;
6745 isym
.n_type
= T_NULL
;
6748 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
6749 outsym
+= bfd_coff_symesz (output_bfd
);
6751 aux
.x_csect
.x_smclas
= h
->smclas
;
6752 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, T_NULL
, isym
.n_sclass
, 0, 1,
6754 outsym
+= bfd_coff_auxesz (output_bfd
);
6756 if ((h
->root
.type
== bfd_link_hash_defined
6757 || h
->root
.type
== bfd_link_hash_defweak
)
6758 && h
->smclas
!= XMC_XO
)
6760 /* We just output an SD symbol. Now output an LD symbol. */
6763 if (h
->root
.type
== bfd_link_hash_defweak
6764 && C_WEAKEXT
== C_AIX_WEAKEXT
)
6765 isym
.n_sclass
= C_WEAKEXT
;
6767 isym
.n_sclass
= C_EXT
;
6768 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
6769 outsym
+= bfd_coff_symesz (output_bfd
);
6771 aux
.x_csect
.x_smtyp
= XTY_LD
;
6772 aux
.x_csect
.x_scnlen
.l
= obj_raw_syment_count (output_bfd
);
6773 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, T_NULL
, C_EXT
, 0, 1,
6775 outsym
+= bfd_coff_auxesz (output_bfd
);
6778 pos
= obj_sym_filepos (output_bfd
);
6779 pos
+= obj_raw_syment_count (output_bfd
) * bfd_coff_symesz (output_bfd
);
6780 amt
= outsym
- flinfo
->outsyms
;
6781 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
6782 || bfd_bwrite (flinfo
->outsyms
, amt
, output_bfd
) != amt
)
6784 obj_raw_syment_count (output_bfd
) +=
6785 (outsym
- flinfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
6790 /* Handle a link order which is supposed to generate a reloc. */
6793 xcoff_reloc_link_order (bfd
*output_bfd
,
6794 struct xcoff_final_link_info
*flinfo
,
6795 asection
*output_section
,
6796 struct bfd_link_order
*link_order
)
6798 reloc_howto_type
*howto
;
6799 struct xcoff_link_hash_entry
*h
;
6803 struct internal_reloc
*irel
;
6804 struct xcoff_link_hash_entry
**rel_hash_ptr
;
6806 if (link_order
->type
== bfd_section_reloc_link_order
)
6807 /* We need to somehow locate a symbol in the right section. The
6808 symbol must either have a value of zero, or we must adjust
6809 the addend by the value of the symbol. FIXME: Write this
6810 when we need it. The old linker couldn't handle this anyhow. */
6813 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6816 bfd_set_error (bfd_error_bad_value
);
6820 h
= ((struct xcoff_link_hash_entry
*)
6821 bfd_wrapped_link_hash_lookup (output_bfd
, flinfo
->info
,
6822 link_order
->u
.reloc
.p
->u
.name
,
6823 false, false, true));
6826 (*flinfo
->info
->callbacks
->unattached_reloc
)
6827 (flinfo
->info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
6831 hsec
= xcoff_symbol_section (h
);
6832 if (h
->root
.type
== bfd_link_hash_defined
6833 || h
->root
.type
== bfd_link_hash_defweak
)
6834 hval
= h
->root
.u
.def
.value
;
6838 addend
= link_order
->u
.reloc
.p
->addend
;
6840 addend
+= (hsec
->output_section
->vma
6841 + hsec
->output_offset
6848 bfd_reloc_status_type rstat
;
6851 size
= bfd_get_reloc_size (howto
);
6852 buf
= bfd_zmalloc (size
);
6853 if (buf
== NULL
&& size
!= 0)
6856 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
6862 case bfd_reloc_outofrange
:
6864 case bfd_reloc_overflow
:
6865 (*flinfo
->info
->callbacks
->reloc_overflow
)
6866 (flinfo
->info
, NULL
, link_order
->u
.reloc
.p
->u
.name
,
6867 howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0);
6870 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
6871 (file_ptr
) link_order
->offset
, size
);
6877 /* Store the reloc information in the right place. It will get
6878 swapped and written out at the end of the final_link routine. */
6879 irel
= (flinfo
->section_info
[output_section
->target_index
].relocs
6880 + output_section
->reloc_count
);
6881 rel_hash_ptr
= (flinfo
->section_info
[output_section
->target_index
].rel_hashes
6882 + output_section
->reloc_count
);
6884 memset (irel
, 0, sizeof (struct internal_reloc
));
6885 *rel_hash_ptr
= NULL
;
6887 irel
->r_vaddr
= output_section
->vma
+ link_order
->offset
;
6890 irel
->r_symndx
= h
->indx
;
6893 /* Set the index to -2 to force this symbol to get written out. */
6899 irel
->r_type
= howto
->type
;
6900 irel
->r_size
= howto
->bitsize
- 1;
6901 if (howto
->complain_on_overflow
== complain_overflow_signed
)
6902 irel
->r_size
|= 0x80;
6904 ++output_section
->reloc_count
;
6906 /* Now output the reloc to the .loader section. */
6907 if (xcoff_hash_table (flinfo
->info
)->loader_section
)
6909 if (!xcoff_create_ldrel (output_bfd
, flinfo
, output_section
,
6910 output_bfd
, irel
, hsec
, h
))
6917 /* Do the final link step. */
6920 _bfd_xcoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
6922 bfd_size_type symesz
;
6923 struct xcoff_final_link_info flinfo
;
6925 struct bfd_link_order
*p
;
6926 bfd_size_type max_contents_size
;
6927 bfd_size_type max_sym_count
;
6928 bfd_size_type max_lineno_count
;
6929 bfd_size_type max_reloc_count
;
6930 bfd_size_type max_output_reloc_count
;
6931 file_ptr rel_filepos
;
6933 file_ptr line_filepos
;
6934 unsigned int linesz
;
6936 bfd_byte
*external_relocs
= NULL
;
6937 char strbuf
[STRING_SIZE_SIZE
];
6941 if (bfd_link_pic (info
))
6942 abfd
->flags
|= DYNAMIC
;
6944 symesz
= bfd_coff_symesz (abfd
);
6947 flinfo
.output_bfd
= abfd
;
6948 flinfo
.strtab
= NULL
;
6949 flinfo
.section_info
= NULL
;
6950 flinfo
.last_file_index
= -1;
6951 flinfo
.toc_symindx
= -1;
6952 flinfo
.internal_syms
= NULL
;
6953 flinfo
.sym_indices
= NULL
;
6954 flinfo
.outsyms
= NULL
;
6955 flinfo
.linenos
= NULL
;
6956 flinfo
.contents
= NULL
;
6957 flinfo
.external_relocs
= NULL
;
6959 if (xcoff_hash_table (info
)->loader_section
)
6961 flinfo
.ldsym
= (xcoff_hash_table (info
)->loader_section
->contents
6962 + bfd_xcoff_ldhdrsz (abfd
));
6963 flinfo
.ldrel
= (xcoff_hash_table (info
)->loader_section
->contents
6964 + bfd_xcoff_ldhdrsz (abfd
)
6965 + (xcoff_hash_table (info
)->ldhdr
.l_nsyms
6966 * bfd_xcoff_ldsymsz (abfd
)));
6970 flinfo
.ldsym
= NULL
;
6971 flinfo
.ldrel
= NULL
;
6974 xcoff_data (abfd
)->coff
.link_info
= info
;
6976 flinfo
.strtab
= _bfd_stringtab_init ();
6977 if (flinfo
.strtab
== NULL
)
6980 /* Count the relocation entries required for the output file.
6981 (We've already counted the line numbers.) Determine a few
6983 max_contents_size
= 0;
6984 max_lineno_count
= 0;
6985 max_reloc_count
= 0;
6986 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6989 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
6991 if (p
->type
== bfd_indirect_link_order
)
6995 sec
= p
->u
.indirect
.section
;
6997 /* Mark all sections which are to be included in the
6998 link. This will normally be every section. We need
6999 to do this so that we can identify any sections which
7000 the linker has decided to not include. */
7001 sec
->linker_mark
= true;
7003 o
->reloc_count
+= sec
->reloc_count
;
7005 if ((sec
->flags
& SEC_IN_MEMORY
) == 0)
7007 if (sec
->rawsize
> max_contents_size
)
7008 max_contents_size
= sec
->rawsize
;
7009 if (sec
->size
> max_contents_size
)
7010 max_contents_size
= sec
->size
;
7012 if (coff_section_data (sec
->owner
, sec
) != NULL
7013 && xcoff_section_data (sec
->owner
, sec
) != NULL
7014 && (xcoff_section_data (sec
->owner
, sec
)->lineno_count
7015 > max_lineno_count
))
7017 xcoff_section_data (sec
->owner
, sec
)->lineno_count
;
7018 if (sec
->reloc_count
> max_reloc_count
)
7019 max_reloc_count
= sec
->reloc_count
;
7021 else if (p
->type
== bfd_section_reloc_link_order
7022 || p
->type
== bfd_symbol_reloc_link_order
)
7027 /* Compute the file positions for all the sections. */
7028 if (abfd
->output_has_begun
)
7030 if (xcoff_hash_table (info
)->file_align
!= 0)
7037 file_align
= xcoff_hash_table (info
)->file_align
;
7038 if (file_align
!= 0)
7044 /* Insert .pad sections before every section which has
7045 contents and is loaded, if it is preceded by some other
7046 section which has contents and is loaded. */
7047 saw_contents
= true;
7048 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7050 if (strcmp (o
->name
, ".pad") == 0)
7051 saw_contents
= false;
7052 else if ((o
->flags
& SEC_HAS_CONTENTS
) != 0
7053 && (o
->flags
& SEC_LOAD
) != 0)
7056 saw_contents
= true;
7061 /* Create a pad section and place it before the section
7062 that needs padding. This requires unlinking and
7063 relinking the bfd's section list. */
7065 n
= bfd_make_section_anyway_with_flags (abfd
, ".pad",
7067 n
->alignment_power
= 0;
7069 bfd_section_list_remove (abfd
, n
);
7070 bfd_section_list_insert_before (abfd
, o
, n
);
7071 saw_contents
= false;
7076 /* Reset the section indices after inserting the new
7079 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7082 o
->target_index
= indx
;
7084 BFD_ASSERT ((unsigned int) indx
== abfd
->section_count
);
7086 /* Work out appropriate sizes for the .pad sections to force
7087 each section to land on a page boundary. This bit of
7088 code knows what compute_section_file_positions is going
7090 sofar
= bfd_coff_filhsz (abfd
);
7091 sofar
+= bfd_coff_aoutsz (abfd
);
7092 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
7093 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7094 if ((bfd_xcoff_is_reloc_count_overflow
7095 (abfd
, (bfd_vma
) o
->reloc_count
))
7096 || (bfd_xcoff_is_lineno_count_overflow
7097 (abfd
, (bfd_vma
) o
->lineno_count
)))
7098 /* 64 does not overflow, need to check if 32 does */
7099 sofar
+= bfd_coff_scnhsz (abfd
);
7101 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7103 if (strcmp (o
->name
, ".pad") == 0)
7107 BFD_ASSERT (o
->size
== 0);
7108 pageoff
= sofar
& (file_align
- 1);
7111 o
->size
= file_align
- pageoff
;
7112 sofar
+= file_align
- pageoff
;
7113 o
->flags
|= SEC_HAS_CONTENTS
;
7118 if ((o
->flags
& SEC_HAS_CONTENTS
) != 0)
7119 sofar
+= BFD_ALIGN (o
->size
,
7120 1 << o
->alignment_power
);
7125 if (! bfd_coff_compute_section_file_positions (abfd
))
7129 /* Allocate space for the pointers we need to keep for the relocs. */
7133 /* We use section_count + 1, rather than section_count, because
7134 the target_index fields are 1 based. */
7135 amt
= abfd
->section_count
+ 1;
7136 amt
*= sizeof (struct xcoff_link_section_info
);
7137 flinfo
.section_info
= bfd_malloc (amt
);
7138 if (flinfo
.section_info
== NULL
)
7140 for (i
= 0; i
<= abfd
->section_count
; i
++)
7142 flinfo
.section_info
[i
].relocs
= NULL
;
7143 flinfo
.section_info
[i
].rel_hashes
= NULL
;
7144 flinfo
.section_info
[i
].toc_rel_hashes
= NULL
;
7148 /* Set the file positions for the relocs. */
7149 rel_filepos
= obj_relocbase (abfd
);
7150 relsz
= bfd_coff_relsz (abfd
);
7151 max_output_reloc_count
= 0;
7152 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7154 if (o
->reloc_count
== 0)
7158 /* A stripped file has no relocs. However, we still
7159 allocate the buffers, so that later code doesn't have to
7160 worry about whether we are stripping or not. */
7161 if (info
->strip
== strip_all
)
7165 o
->flags
|= SEC_RELOC
;
7166 o
->rel_filepos
= rel_filepos
;
7167 rel_filepos
+= o
->reloc_count
* relsz
;
7170 /* We don't know the indices of global symbols until we have
7171 written out all the local symbols. For each section in
7172 the output file, we keep an array of pointers to hash
7173 table entries. Each entry in the array corresponds to a
7174 reloc. When we find a reloc against a global symbol, we
7175 set the corresponding entry in this array so that we can
7176 fix up the symbol index after we have written out all the
7179 Because of this problem, we also keep the relocs in
7180 memory until the end of the link. This wastes memory.
7181 We could backpatch the file later, I suppose, although it
7183 amt
= o
->reloc_count
;
7184 amt
*= sizeof (struct internal_reloc
);
7185 flinfo
.section_info
[o
->target_index
].relocs
= bfd_malloc (amt
);
7187 amt
= o
->reloc_count
;
7188 amt
*= sizeof (struct xcoff_link_hash_entry
*);
7189 flinfo
.section_info
[o
->target_index
].rel_hashes
= bfd_malloc (amt
);
7191 if (flinfo
.section_info
[o
->target_index
].relocs
== NULL
7192 || flinfo
.section_info
[o
->target_index
].rel_hashes
== NULL
)
7195 if (o
->reloc_count
> max_output_reloc_count
)
7196 max_output_reloc_count
= o
->reloc_count
;
7200 /* We now know the size of the relocs, so we can determine the file
7201 positions of the line numbers. */
7202 line_filepos
= rel_filepos
;
7203 flinfo
.line_filepos
= line_filepos
;
7204 linesz
= bfd_coff_linesz (abfd
);
7205 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7207 if (o
->lineno_count
== 0)
7208 o
->line_filepos
= 0;
7211 o
->line_filepos
= line_filepos
;
7212 line_filepos
+= o
->lineno_count
* linesz
;
7215 /* Reset the reloc and lineno counts, so that we can use them to
7216 count the number of entries we have output so far. */
7218 o
->lineno_count
= 0;
7221 obj_sym_filepos (abfd
) = line_filepos
;
7223 /* Figure out the largest number of symbols in an input BFD. Take
7224 the opportunity to clear the output_has_begun fields of all the
7225 input BFD's. We want at least 6 symbols, since that is the
7226 number which xcoff_write_global_symbol may need. */
7228 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
7232 sub
->output_has_begun
= false;
7233 sz
= obj_raw_syment_count (sub
);
7234 if (sz
> max_sym_count
)
7238 /* Allocate some buffers used while linking. */
7239 amt
= max_sym_count
* sizeof (struct internal_syment
);
7240 flinfo
.internal_syms
= bfd_malloc (amt
);
7242 amt
= max_sym_count
* sizeof (long);
7243 flinfo
.sym_indices
= bfd_malloc (amt
);
7245 amt
= (max_sym_count
+ 1) * symesz
;
7246 flinfo
.outsyms
= bfd_malloc (amt
);
7248 amt
= max_lineno_count
* bfd_coff_linesz (abfd
);
7249 flinfo
.linenos
= bfd_malloc (amt
);
7251 amt
= max_contents_size
;
7252 flinfo
.contents
= bfd_malloc (amt
);
7254 amt
= max_reloc_count
* relsz
;
7255 flinfo
.external_relocs
= bfd_malloc (amt
);
7257 if ((flinfo
.internal_syms
== NULL
&& max_sym_count
> 0)
7258 || (flinfo
.sym_indices
== NULL
&& max_sym_count
> 0)
7259 || flinfo
.outsyms
== NULL
7260 || (flinfo
.linenos
== NULL
&& max_lineno_count
> 0)
7261 || (flinfo
.contents
== NULL
&& max_contents_size
> 0)
7262 || (flinfo
.external_relocs
== NULL
&& max_reloc_count
> 0))
7265 obj_raw_syment_count (abfd
) = 0;
7267 /* Find a TOC symbol, if we need one. */
7268 if (!xcoff_find_tc0 (abfd
, &flinfo
))
7271 /* We now know the position of everything in the file, except that
7272 we don't know the size of the symbol table and therefore we don't
7273 know where the string table starts. We just build the string
7274 table in memory as we go along. We process all the relocations
7275 for a single input file at once. */
7276 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7278 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
7280 if (p
->type
== bfd_indirect_link_order
7281 && p
->u
.indirect
.section
->owner
->xvec
== abfd
->xvec
)
7283 sub
= p
->u
.indirect
.section
->owner
;
7284 if (! sub
->output_has_begun
)
7286 if (sub
== xcoff_hash_table (info
)->params
->stub_bfd
)
7292 if (! xcoff_link_input_bfd (&flinfo
, sub
))
7295 (_("Unable to link input file: %s"), sub
->filename
);
7296 bfd_set_error (bfd_error_sorry
);
7300 sub
->output_has_begun
= true;
7303 else if (p
->type
== bfd_section_reloc_link_order
7304 || p
->type
== bfd_symbol_reloc_link_order
)
7306 if (! xcoff_reloc_link_order (abfd
, &flinfo
, o
, p
))
7311 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
7317 /* Free up the buffers used by xcoff_link_input_bfd. */
7318 free (flinfo
.internal_syms
);
7319 flinfo
.internal_syms
= NULL
;
7320 free (flinfo
.sym_indices
);
7321 flinfo
.sym_indices
= NULL
;
7322 free (flinfo
.linenos
);
7323 flinfo
.linenos
= NULL
;
7324 free (flinfo
.contents
);
7325 flinfo
.contents
= NULL
;
7326 free (flinfo
.external_relocs
);
7327 flinfo
.external_relocs
= NULL
;
7329 /* The value of the last C_FILE symbol is supposed to be -1. Write
7331 if (flinfo
.last_file_index
!= -1)
7333 flinfo
.last_file
.n_value
= -(bfd_vma
) 1;
7334 bfd_coff_swap_sym_out (abfd
, (void *) &flinfo
.last_file
,
7335 (void *) flinfo
.outsyms
);
7336 pos
= obj_sym_filepos (abfd
) + flinfo
.last_file_index
* symesz
;
7337 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
7338 || bfd_bwrite (flinfo
.outsyms
, symesz
, abfd
) != symesz
)
7342 /* Write out all the global symbols which do not come from XCOFF
7344 bfd_hash_traverse (&info
->hash
->table
, xcoff_write_global_symbol
, &flinfo
);
7346 /* Write out the relocations created by stub entries. The symbols
7347 will have been already written by xcoff_write_global_symbol. */
7348 bfd_hash_traverse (&xcoff_hash_table(info
)->stub_hash_table
,
7349 xcoff_stub_create_relocations
,
7352 free (flinfo
.outsyms
);
7353 flinfo
.outsyms
= NULL
;
7355 /* Now that we have written out all the global symbols, we know the
7356 symbol indices to use for relocs against them, and we can finally
7357 write out the relocs. */
7358 amt
= max_output_reloc_count
* relsz
;
7359 external_relocs
= bfd_malloc (amt
);
7360 if (external_relocs
== NULL
&& max_output_reloc_count
!= 0)
7363 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7365 struct internal_reloc
*irel
;
7366 struct internal_reloc
*irelend
;
7367 struct xcoff_link_hash_entry
**rel_hash
;
7368 struct xcoff_toc_rel_hash
*toc_rel_hash
;
7370 bfd_size_type rel_size
;
7372 /* A stripped file has no relocs. */
7373 if (info
->strip
== strip_all
)
7379 if (o
->reloc_count
== 0)
7382 irel
= flinfo
.section_info
[o
->target_index
].relocs
;
7383 irelend
= irel
+ o
->reloc_count
;
7384 rel_hash
= flinfo
.section_info
[o
->target_index
].rel_hashes
;
7385 for (; irel
< irelend
; irel
++, rel_hash
++)
7387 if (*rel_hash
!= NULL
)
7389 if ((*rel_hash
)->indx
< 0)
7391 (*info
->callbacks
->unattached_reloc
)
7392 (info
, (*rel_hash
)->root
.root
.string
,
7393 NULL
, o
, irel
->r_vaddr
);
7394 (*rel_hash
)->indx
= 0;
7396 irel
->r_symndx
= (*rel_hash
)->indx
;
7400 for (toc_rel_hash
= flinfo
.section_info
[o
->target_index
].toc_rel_hashes
;
7401 toc_rel_hash
!= NULL
;
7402 toc_rel_hash
= toc_rel_hash
->next
)
7404 if (toc_rel_hash
->h
->u
.toc_indx
< 0)
7406 (*info
->callbacks
->unattached_reloc
)
7407 (info
, toc_rel_hash
->h
->root
.root
.string
,
7408 NULL
, o
, toc_rel_hash
->rel
->r_vaddr
);
7409 toc_rel_hash
->h
->u
.toc_indx
= 0;
7411 toc_rel_hash
->rel
->r_symndx
= toc_rel_hash
->h
->u
.toc_indx
;
7414 /* XCOFF requires that the relocs be sorted by address. We tend
7415 to produce them in the order in which their containing csects
7416 appear in the symbol table, which is not necessarily by
7417 address. So we sort them here. There may be a better way to
7419 qsort ((void *) flinfo
.section_info
[o
->target_index
].relocs
,
7420 o
->reloc_count
, sizeof (struct internal_reloc
),
7423 irel
= flinfo
.section_info
[o
->target_index
].relocs
;
7424 irelend
= irel
+ o
->reloc_count
;
7425 erel
= external_relocs
;
7426 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
7427 bfd_coff_swap_reloc_out (abfd
, (void *) irel
, (void *) erel
);
7429 rel_size
= relsz
* o
->reloc_count
;
7430 if (bfd_seek (abfd
, o
->rel_filepos
, SEEK_SET
) != 0
7431 || bfd_bwrite ((void *) external_relocs
, rel_size
, abfd
) != rel_size
)
7435 free (external_relocs
);
7436 external_relocs
= NULL
;
7438 /* Free up the section information. */
7439 if (flinfo
.section_info
!= NULL
)
7443 for (i
= 0; i
< abfd
->section_count
; i
++)
7445 free (flinfo
.section_info
[i
].relocs
);
7446 free (flinfo
.section_info
[i
].rel_hashes
);
7448 free (flinfo
.section_info
);
7449 flinfo
.section_info
= NULL
;
7452 /* Write out the stub sections. */
7453 for (o
= xcoff_hash_table (info
)->params
->stub_bfd
->sections
;
7454 o
!= NULL
; o
= o
->next
)
7456 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
7460 if (!bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
7461 (file_ptr
) o
->output_offset
, o
->size
))
7465 /* Write out the loader section contents. */
7466 o
= xcoff_hash_table (info
)->loader_section
;
7469 && o
->output_section
!= bfd_abs_section_ptr
)
7471 BFD_ASSERT ((bfd_byte
*) flinfo
.ldrel
7472 == (xcoff_hash_table (info
)->loader_section
->contents
7473 + xcoff_hash_table (info
)->ldhdr
.l_impoff
));
7474 if (!bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
7475 (file_ptr
) o
->output_offset
, o
->size
))
7479 /* Write out the magic sections. */
7480 o
= xcoff_hash_table (info
)->linkage_section
;
7483 && o
->output_section
!= bfd_abs_section_ptr
7484 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
7485 (file_ptr
) o
->output_offset
,
7488 o
= xcoff_hash_table (info
)->toc_section
;
7491 && o
->output_section
!= bfd_abs_section_ptr
7492 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
7493 (file_ptr
) o
->output_offset
,
7496 o
= xcoff_hash_table (info
)->descriptor_section
;
7499 && o
->output_section
!= bfd_abs_section_ptr
7500 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
7501 (file_ptr
) o
->output_offset
,
7505 /* Write out the string table. */
7506 pos
= obj_sym_filepos (abfd
) + obj_raw_syment_count (abfd
) * symesz
;
7507 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
7510 _bfd_stringtab_size (flinfo
.strtab
) + STRING_SIZE_SIZE
,
7512 amt
= STRING_SIZE_SIZE
;
7513 if (bfd_bwrite (strbuf
, amt
, abfd
) != amt
)
7515 if (! _bfd_stringtab_emit (abfd
, flinfo
.strtab
))
7518 _bfd_stringtab_free (flinfo
.strtab
);
7520 /* Write out the debugging string table. */
7521 o
= xcoff_hash_table (info
)->debug_section
;
7524 && o
->output_section
!= bfd_abs_section_ptr
)
7526 struct bfd_strtab_hash
*debug_strtab
;
7528 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
7529 BFD_ASSERT (o
->output_section
->size
- o
->output_offset
7530 >= _bfd_stringtab_size (debug_strtab
));
7531 pos
= o
->output_section
->filepos
+ o
->output_offset
;
7532 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
7534 if (! _bfd_stringtab_emit (abfd
, debug_strtab
))
7538 /* Setting symcount to 0 will cause write_object_contents to
7539 not try to write out the symbols. */
7545 if (flinfo
.strtab
!= NULL
)
7546 _bfd_stringtab_free (flinfo
.strtab
);
7548 if (flinfo
.section_info
!= NULL
)
7552 for (i
= 0; i
< abfd
->section_count
; i
++)
7554 free (flinfo
.section_info
[i
].relocs
);
7555 free (flinfo
.section_info
[i
].rel_hashes
);
7557 free (flinfo
.section_info
);
7560 free (flinfo
.internal_syms
);
7561 free (flinfo
.sym_indices
);
7562 free (flinfo
.outsyms
);
7563 free (flinfo
.linenos
);
7564 free (flinfo
.contents
);
7565 free (flinfo
.external_relocs
);
7566 free (external_relocs
);