1 /* POWER/PowerPC XCOFF linker support.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@cygnus.com>, Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "coff/internal.h"
28 #include "coff/xcoff.h"
32 /* This file holds the XCOFF linker code. */
34 #undef STRING_SIZE_SIZE
35 #define STRING_SIZE_SIZE 4
37 /* We reuse the SEC_ROM flag as a mark flag for garbage collection.
38 This flag will only be used on input sections. */
40 #define SEC_MARK (SEC_ROM)
42 /* The list of import files. */
44 struct xcoff_import_file
46 /* The next entry in the list. */
47 struct xcoff_import_file
*next
;
52 /* The member name. */
56 /* Information we keep for each section in the output file during the
59 struct xcoff_link_section_info
61 /* The relocs to be output. */
62 struct internal_reloc
*relocs
;
63 /* For each reloc against a global symbol whose index was not known
64 when the reloc was handled, the global hash table entry. */
65 struct xcoff_link_hash_entry
**rel_hashes
;
66 /* If there is a TOC relative reloc against a global symbol, and the
67 index of the TOC symbol is not known when the reloc was handled,
68 an entry is added to this linked list. This is not an array,
69 like rel_hashes, because this case is quite uncommon. */
70 struct xcoff_toc_rel_hash
72 struct xcoff_toc_rel_hash
*next
;
73 struct xcoff_link_hash_entry
*h
;
74 struct internal_reloc
*rel
;
78 /* Information that we pass around while doing the final link step. */
80 struct xcoff_final_link_info
82 /* General link information. */
83 struct bfd_link_info
*info
;
86 /* Hash table for long symbol names. */
87 struct bfd_strtab_hash
*strtab
;
88 /* Array of information kept for each output section, indexed by the
89 target_index field. */
90 struct xcoff_link_section_info
*section_info
;
91 /* Symbol index of last C_FILE symbol (-1 if none). */
93 /* Contents of last C_FILE symbol. */
94 struct internal_syment last_file
;
95 /* Symbol index of TOC symbol. */
97 /* Start of .loader symbols. */
99 /* Next .loader reloc to swap out. */
101 /* File position of start of line numbers. */
102 file_ptr line_filepos
;
103 /* Buffer large enough to hold swapped symbols of any input file. */
104 struct internal_syment
*internal_syms
;
105 /* Buffer large enough to hold output indices of symbols of any
108 /* Buffer large enough to hold output symbols for any input file. */
110 /* Buffer large enough to hold external line numbers for any input
113 /* Buffer large enough to hold any input section. */
115 /* Buffer large enough to hold external relocs of any input section. */
116 bfd_byte
*external_relocs
;
119 static bfd_boolean
xcoff_mark (struct bfd_link_info
*, asection
*);
123 /* Routines to read XCOFF dynamic information. This don't really
124 belong here, but we already have the ldsym manipulation routines
127 /* Read the contents of a section. */
130 xcoff_get_section_contents (bfd
*abfd
, asection
*sec
)
132 if (coff_section_data (abfd
, sec
) == NULL
)
134 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
136 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
137 if (sec
->used_by_bfd
== NULL
)
141 if (coff_section_data (abfd
, sec
)->contents
== NULL
)
145 if (! bfd_malloc_and_get_section (abfd
, sec
, &contents
))
147 if (contents
!= NULL
)
151 coff_section_data (abfd
, sec
)->contents
= contents
;
157 /* Get the size required to hold the dynamic symbols. */
160 _bfd_xcoff_get_dynamic_symtab_upper_bound (bfd
*abfd
)
164 struct internal_ldhdr ldhdr
;
166 if ((abfd
->flags
& DYNAMIC
) == 0)
168 bfd_set_error (bfd_error_invalid_operation
);
172 lsec
= bfd_get_section_by_name (abfd
, ".loader");
175 bfd_set_error (bfd_error_no_symbols
);
179 if (! xcoff_get_section_contents (abfd
, lsec
))
181 contents
= coff_section_data (abfd
, lsec
)->contents
;
183 bfd_xcoff_swap_ldhdr_in (abfd
, (void *) contents
, &ldhdr
);
185 return (ldhdr
.l_nsyms
+ 1) * sizeof (asymbol
*);
188 /* Get the dynamic symbols. */
191 _bfd_xcoff_canonicalize_dynamic_symtab (bfd
*abfd
, asymbol
**psyms
)
195 struct internal_ldhdr ldhdr
;
197 bfd_byte
*elsym
, *elsymend
;
198 coff_symbol_type
*symbuf
;
200 if ((abfd
->flags
& DYNAMIC
) == 0)
202 bfd_set_error (bfd_error_invalid_operation
);
206 lsec
= bfd_get_section_by_name (abfd
, ".loader");
209 bfd_set_error (bfd_error_no_symbols
);
213 if (! xcoff_get_section_contents (abfd
, lsec
))
215 contents
= coff_section_data (abfd
, lsec
)->contents
;
217 coff_section_data (abfd
, lsec
)->keep_contents
= TRUE
;
219 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
221 strings
= (char *) contents
+ ldhdr
.l_stoff
;
223 symbuf
= bfd_zalloc (abfd
, ldhdr
.l_nsyms
* sizeof (* symbuf
));
227 elsym
= contents
+ bfd_xcoff_loader_symbol_offset(abfd
, &ldhdr
);
229 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz(abfd
);
230 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz(abfd
), symbuf
++, psyms
++)
232 struct internal_ldsym ldsym
;
234 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
236 symbuf
->symbol
.the_bfd
= abfd
;
238 if (ldsym
._l
._l_l
._l_zeroes
== 0)
239 symbuf
->symbol
.name
= strings
+ ldsym
._l
._l_l
._l_offset
;
244 c
= bfd_alloc (abfd
, (bfd_size_type
) SYMNMLEN
+ 1);
247 memcpy (c
, ldsym
._l
._l_name
, SYMNMLEN
);
249 symbuf
->symbol
.name
= c
;
252 if (ldsym
.l_smclas
== XMC_XO
)
253 symbuf
->symbol
.section
= bfd_abs_section_ptr
;
255 symbuf
->symbol
.section
= coff_section_from_bfd_index (abfd
,
257 symbuf
->symbol
.value
= ldsym
.l_value
- symbuf
->symbol
.section
->vma
;
259 symbuf
->symbol
.flags
= BSF_NO_FLAGS
;
260 if ((ldsym
.l_smtype
& L_EXPORT
) != 0)
261 symbuf
->symbol
.flags
|= BSF_GLOBAL
;
263 /* FIXME: We have no way to record the other information stored
264 with the loader symbol. */
265 *psyms
= (asymbol
*) symbuf
;
270 return ldhdr
.l_nsyms
;
273 /* Get the size required to hold the dynamic relocs. */
276 _bfd_xcoff_get_dynamic_reloc_upper_bound (bfd
*abfd
)
280 struct internal_ldhdr ldhdr
;
282 if ((abfd
->flags
& DYNAMIC
) == 0)
284 bfd_set_error (bfd_error_invalid_operation
);
288 lsec
= bfd_get_section_by_name (abfd
, ".loader");
291 bfd_set_error (bfd_error_no_symbols
);
295 if (! xcoff_get_section_contents (abfd
, lsec
))
297 contents
= coff_section_data (abfd
, lsec
)->contents
;
299 bfd_xcoff_swap_ldhdr_in (abfd
, (struct external_ldhdr
*) contents
, &ldhdr
);
301 return (ldhdr
.l_nreloc
+ 1) * sizeof (arelent
*);
304 /* Get the dynamic relocs. */
307 _bfd_xcoff_canonicalize_dynamic_reloc (bfd
*abfd
,
313 struct internal_ldhdr ldhdr
;
315 bfd_byte
*elrel
, *elrelend
;
317 if ((abfd
->flags
& DYNAMIC
) == 0)
319 bfd_set_error (bfd_error_invalid_operation
);
323 lsec
= bfd_get_section_by_name (abfd
, ".loader");
326 bfd_set_error (bfd_error_no_symbols
);
330 if (! xcoff_get_section_contents (abfd
, lsec
))
332 contents
= coff_section_data (abfd
, lsec
)->contents
;
334 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
336 relbuf
= bfd_alloc (abfd
, ldhdr
.l_nreloc
* sizeof (arelent
));
340 elrel
= contents
+ bfd_xcoff_loader_reloc_offset(abfd
, &ldhdr
);
342 elrelend
= elrel
+ ldhdr
.l_nreloc
* bfd_xcoff_ldrelsz(abfd
);
343 for (; elrel
< elrelend
; elrel
+= bfd_xcoff_ldrelsz(abfd
), relbuf
++,
346 struct internal_ldrel ldrel
;
348 bfd_xcoff_swap_ldrel_in (abfd
, elrel
, &ldrel
);
350 if (ldrel
.l_symndx
>= 3)
351 relbuf
->sym_ptr_ptr
= syms
+ (ldrel
.l_symndx
- 3);
357 switch (ldrel
.l_symndx
)
373 sec
= bfd_get_section_by_name (abfd
, name
);
376 bfd_set_error (bfd_error_bad_value
);
380 relbuf
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
383 relbuf
->address
= ldrel
.l_vaddr
;
386 /* Most dynamic relocs have the same type. FIXME: This is only
387 correct if ldrel.l_rtype == 0. In other cases, we should use
388 a different howto. */
389 relbuf
->howto
= bfd_xcoff_dynamic_reloc_howto(abfd
);
391 /* FIXME: We have no way to record the l_rsecnm field. */
398 return ldhdr
.l_nreloc
;
401 /* Routine to create an entry in an XCOFF link hash table. */
403 static struct bfd_hash_entry
*
404 xcoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
405 struct bfd_hash_table
*table
,
408 struct xcoff_link_hash_entry
*ret
= (struct xcoff_link_hash_entry
*) entry
;
410 /* Allocate the structure if it has not already been allocated by a
413 ret
= bfd_hash_allocate (table
, sizeof (* ret
));
417 /* Call the allocation method of the superclass. */
418 ret
= ((struct xcoff_link_hash_entry
*)
419 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
423 /* Set local fields. */
425 ret
->toc_section
= NULL
;
426 ret
->u
.toc_indx
= -1;
427 ret
->descriptor
= NULL
;
431 ret
->smclas
= XMC_UA
;
434 return (struct bfd_hash_entry
*) ret
;
437 /* Create a XCOFF link hash table. */
439 struct bfd_link_hash_table
*
440 _bfd_xcoff_bfd_link_hash_table_create (bfd
*abfd
)
442 struct xcoff_link_hash_table
*ret
;
443 bfd_size_type amt
= sizeof (* ret
);
445 ret
= bfd_malloc (amt
);
448 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
, xcoff_link_hash_newfunc
,
449 sizeof (struct xcoff_link_hash_entry
)))
455 ret
->debug_strtab
= _bfd_xcoff_stringtab_init ();
456 ret
->debug_section
= NULL
;
457 ret
->loader_section
= NULL
;
458 ret
->ldrel_count
= 0;
459 memset (&ret
->ldhdr
, 0, sizeof (struct internal_ldhdr
));
460 ret
->linkage_section
= NULL
;
461 ret
->toc_section
= NULL
;
462 ret
->descriptor_section
= NULL
;
467 memset (ret
->special_sections
, 0, sizeof ret
->special_sections
);
469 /* The linker will always generate a full a.out header. We need to
470 record that fact now, before the sizeof_headers routine could be
472 xcoff_data (abfd
)->full_aouthdr
= TRUE
;
477 /* Free a XCOFF link hash table. */
480 _bfd_xcoff_bfd_link_hash_table_free (struct bfd_link_hash_table
*hash
)
482 struct xcoff_link_hash_table
*ret
= (struct xcoff_link_hash_table
*) hash
;
484 _bfd_stringtab_free (ret
->debug_strtab
);
485 bfd_hash_table_free (&ret
->root
.table
);
489 /* Read internal relocs for an XCOFF csect. This is a wrapper around
490 _bfd_coff_read_internal_relocs which tries to take advantage of any
491 relocs which may have been cached for the enclosing section. */
493 static struct internal_reloc
*
494 xcoff_read_internal_relocs (bfd
*abfd
,
497 bfd_byte
*external_relocs
,
498 bfd_boolean require_internal
,
499 struct internal_reloc
*internal_relocs
)
501 if (coff_section_data (abfd
, sec
) != NULL
502 && coff_section_data (abfd
, sec
)->relocs
== NULL
503 && xcoff_section_data (abfd
, sec
) != NULL
)
507 enclosing
= xcoff_section_data (abfd
, sec
)->enclosing
;
509 if (enclosing
!= NULL
510 && (coff_section_data (abfd
, enclosing
) == NULL
511 || coff_section_data (abfd
, enclosing
)->relocs
== NULL
)
513 && enclosing
->reloc_count
> 0)
515 if (_bfd_coff_read_internal_relocs (abfd
, enclosing
, TRUE
,
516 external_relocs
, FALSE
, NULL
)
521 if (enclosing
!= NULL
522 && coff_section_data (abfd
, enclosing
) != NULL
523 && coff_section_data (abfd
, enclosing
)->relocs
!= NULL
)
527 off
= ((sec
->rel_filepos
- enclosing
->rel_filepos
)
528 / bfd_coff_relsz (abfd
));
530 if (! require_internal
)
531 return coff_section_data (abfd
, enclosing
)->relocs
+ off
;
532 memcpy (internal_relocs
,
533 coff_section_data (abfd
, enclosing
)->relocs
+ off
,
534 sec
->reloc_count
* sizeof (struct internal_reloc
));
535 return internal_relocs
;
539 return _bfd_coff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
540 require_internal
, internal_relocs
);
543 /* This function is used to add symbols from a dynamic object to the
544 global symbol table. */
547 xcoff_link_add_dynamic_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
551 struct internal_ldhdr ldhdr
;
553 bfd_byte
*elsym
, *elsymend
;
554 struct xcoff_import_file
*n
;
559 struct xcoff_import_file
**pp
;
561 /* We can only handle a dynamic object if we are generating an XCOFF
563 if (info
->output_bfd
->xvec
!= abfd
->xvec
)
565 (*_bfd_error_handler
)
566 (_("%s: XCOFF shared object when not producing XCOFF output"),
567 bfd_get_filename (abfd
));
568 bfd_set_error (bfd_error_invalid_operation
);
572 /* The symbols we use from a dynamic object are not the symbols in
573 the normal symbol table, but, rather, the symbols in the export
574 table. If there is a global symbol in a dynamic object which is
575 not in the export table, the loader will not be able to find it,
576 so we don't want to find it either. Also, on AIX 4.1.3, shr.o in
577 libc.a has symbols in the export table which are not in the
580 /* Read in the .loader section. FIXME: We should really use the
581 o_snloader field in the a.out header, rather than grabbing the
583 lsec
= bfd_get_section_by_name (abfd
, ".loader");
586 (*_bfd_error_handler
)
587 (_("%s: dynamic object with no .loader section"),
588 bfd_get_filename (abfd
));
589 bfd_set_error (bfd_error_no_symbols
);
593 if (! xcoff_get_section_contents (abfd
, lsec
))
595 contents
= coff_section_data (abfd
, lsec
)->contents
;
597 /* Remove the sections from this object, so that they do not get
598 included in the link. */
599 bfd_section_list_clear (abfd
);
601 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
603 strings
= (char *) contents
+ ldhdr
.l_stoff
;
605 elsym
= contents
+ bfd_xcoff_loader_symbol_offset(abfd
, &ldhdr
);
607 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz(abfd
);
609 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz(abfd
))
611 struct internal_ldsym ldsym
;
612 char nambuf
[SYMNMLEN
+ 1];
614 struct xcoff_link_hash_entry
*h
;
616 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
618 /* We are only interested in exported symbols. */
619 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
622 if (ldsym
._l
._l_l
._l_zeroes
== 0)
623 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
626 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
627 nambuf
[SYMNMLEN
] = '\0';
631 /* Normally we could not call xcoff_link_hash_lookup in an add
632 symbols routine, since we might not be using an XCOFF hash
633 table. However, we verified above that we are using an XCOFF
636 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, TRUE
,
641 h
->flags
|= XCOFF_DEF_DYNAMIC
;
643 /* If the symbol is undefined, and the BFD it was found in is
644 not a dynamic object, change the BFD to this dynamic object,
645 so that we can get the correct import file ID. */
646 if ((h
->root
.type
== bfd_link_hash_undefined
647 || h
->root
.type
== bfd_link_hash_undefweak
)
648 && (h
->root
.u
.undef
.abfd
== NULL
649 || (h
->root
.u
.undef
.abfd
->flags
& DYNAMIC
) == 0))
650 h
->root
.u
.undef
.abfd
= abfd
;
652 if (h
->root
.type
== bfd_link_hash_new
)
654 h
->root
.type
= bfd_link_hash_undefined
;
655 h
->root
.u
.undef
.abfd
= abfd
;
656 /* We do not want to add this to the undefined symbol list. */
659 if (h
->smclas
== XMC_UA
660 || h
->root
.type
== bfd_link_hash_undefined
661 || h
->root
.type
== bfd_link_hash_undefweak
)
662 h
->smclas
= ldsym
.l_smclas
;
664 /* Unless this is an XMC_XO symbol, we don't bother to actually
665 define it, since we don't have a section to put it in anyhow.
666 Instead, the relocation routines handle the DEF_DYNAMIC flag
669 if (h
->smclas
== XMC_XO
670 && (h
->root
.type
== bfd_link_hash_undefined
671 || h
->root
.type
== bfd_link_hash_undefweak
))
673 /* This symbol has an absolute value. */
674 h
->root
.type
= bfd_link_hash_defined
;
675 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
676 h
->root
.u
.def
.value
= ldsym
.l_value
;
679 /* If this symbol defines a function descriptor, then it
680 implicitly defines the function code as well. */
681 if (h
->smclas
== XMC_DS
682 || (h
->smclas
== XMC_XO
&& name
[0] != '.'))
683 h
->flags
|= XCOFF_DESCRIPTOR
;
684 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
686 struct xcoff_link_hash_entry
*hds
;
693 dsnm
= bfd_malloc ((bfd_size_type
) strlen (name
) + 2);
697 strcpy (dsnm
+ 1, name
);
698 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
), dsnm
,
704 if (hds
->root
.type
== bfd_link_hash_new
)
706 hds
->root
.type
= bfd_link_hash_undefined
;
707 hds
->root
.u
.undef
.abfd
= abfd
;
708 /* We do not want to add this to the undefined
716 hds
->flags
|= XCOFF_DEF_DYNAMIC
;
717 if (hds
->smclas
== XMC_UA
)
718 hds
->smclas
= XMC_PR
;
720 /* An absolute symbol appears to actually define code, not a
721 function descriptor. This is how some math functions are
722 implemented on AIX 4.1. */
723 if (h
->smclas
== XMC_XO
724 && (hds
->root
.type
== bfd_link_hash_undefined
725 || hds
->root
.type
== bfd_link_hash_undefweak
))
727 hds
->smclas
= XMC_XO
;
728 hds
->root
.type
= bfd_link_hash_defined
;
729 hds
->root
.u
.def
.section
= bfd_abs_section_ptr
;
730 hds
->root
.u
.def
.value
= ldsym
.l_value
;
735 if (contents
!= NULL
&& ! coff_section_data (abfd
, lsec
)->keep_contents
)
737 free (coff_section_data (abfd
, lsec
)->contents
);
738 coff_section_data (abfd
, lsec
)->contents
= NULL
;
741 /* Record this file in the import files. */
742 n
= bfd_alloc (abfd
, (bfd_size_type
) sizeof (struct xcoff_import_file
));
747 /* For some reason, the path entry in the import file list for a
748 shared object appears to always be empty. The file name is the
751 if (abfd
->my_archive
== NULL
)
753 bname
= bfd_get_filename (abfd
);
758 bname
= bfd_get_filename (abfd
->my_archive
);
759 mname
= bfd_get_filename (abfd
);
761 s
= strrchr (bname
, '/');
767 /* We start c at 1 because the first import file number is reserved
769 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
771 pp
= &(*pp
)->next
, ++c
)
775 xcoff_data (abfd
)->import_file_id
= c
;
780 /* xcoff_link_create_extra_sections
782 Takes care of creating the .loader, .gl, .ds, .debug and sections. */
785 xcoff_link_create_extra_sections (bfd
* abfd
, struct bfd_link_info
*info
)
787 bfd_boolean return_value
= FALSE
;
789 if (info
->output_bfd
->xvec
== abfd
->xvec
)
791 /* We need to build a .loader section, so we do it here. This
792 won't work if we're producing an XCOFF output file with no
793 XCOFF input files. FIXME. */
795 if (xcoff_hash_table (info
)->loader_section
== NULL
)
798 flagword flags
= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
800 lsec
= bfd_make_section_anyway_with_flags (abfd
, ".loader", flags
);
804 xcoff_hash_table (info
)->loader_section
= lsec
;
807 /* Likewise for the linkage section. */
808 if (xcoff_hash_table (info
)->linkage_section
== NULL
)
811 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
814 lsec
= bfd_make_section_anyway_with_flags (abfd
, ".gl", flags
);
818 xcoff_hash_table (info
)->linkage_section
= lsec
;
819 lsec
->alignment_power
= 2;
822 /* Likewise for the TOC section. */
823 if (xcoff_hash_table (info
)->toc_section
== NULL
)
826 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
829 tsec
= bfd_make_section_anyway_with_flags (abfd
, ".tc", flags
);
833 xcoff_hash_table (info
)->toc_section
= tsec
;
834 tsec
->alignment_power
= 2;
837 /* Likewise for the descriptor section. */
838 if (xcoff_hash_table (info
)->descriptor_section
== NULL
)
841 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
844 dsec
= bfd_make_section_anyway_with_flags (abfd
, ".ds", flags
);
848 xcoff_hash_table (info
)->descriptor_section
= dsec
;
849 dsec
->alignment_power
= 2;
852 /* Likewise for the .debug section. */
853 if (xcoff_hash_table (info
)->debug_section
== NULL
854 && info
->strip
!= strip_all
)
857 flagword flags
= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
859 dsec
= bfd_make_section_anyway_with_flags (abfd
, ".debug", flags
);
863 xcoff_hash_table (info
)->debug_section
= dsec
;
874 /* Returns the index of reloc in RELOCS with the least address greater
875 than or equal to ADDRESS. The relocs are sorted by address. */
878 xcoff_find_reloc (struct internal_reloc
*relocs
,
882 bfd_size_type min
, max
, this;
886 if (count
== 1 && relocs
[0].r_vaddr
< address
)
895 /* Do a binary search over (min,max]. */
896 while (min
+ 1 < max
)
900 this = (max
+ min
) / 2;
901 raddr
= relocs
[this].r_vaddr
;
904 else if (raddr
< address
)
913 if (relocs
[min
].r_vaddr
< address
)
917 && relocs
[min
- 1].r_vaddr
== address
)
923 /* Add all the symbols from an object file to the hash table.
925 XCOFF is a weird format. A normal XCOFF .o files will have three
926 COFF sections--.text, .data, and .bss--but each COFF section will
927 contain many csects. These csects are described in the symbol
928 table. From the linker's point of view, each csect must be
929 considered a section in its own right. For example, a TOC entry is
930 handled as a small XMC_TC csect. The linker must be able to merge
931 different TOC entries together, which means that it must be able to
932 extract the XMC_TC csects from the .data section of the input .o
935 From the point of view of our linker, this is, of course, a hideous
936 nightmare. We cope by actually creating sections for each csect,
937 and discarding the original sections. We then have to handle the
938 relocation entries carefully, since the only way to tell which
939 csect they belong to is to examine the address. */
942 xcoff_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
944 unsigned int n_tmask
;
945 unsigned int n_btshft
;
946 bfd_boolean default_copy
;
947 bfd_size_type symcount
;
948 struct xcoff_link_hash_entry
**sym_hash
;
949 asection
**csect_cache
;
950 bfd_size_type linesz
;
953 bfd_boolean keep_syms
;
955 unsigned int csect_index
;
956 asection
*first_csect
;
957 bfd_size_type symesz
;
960 struct reloc_info_struct
962 struct internal_reloc
*relocs
;
965 } *reloc_info
= NULL
;
968 keep_syms
= obj_coff_keep_syms (abfd
);
970 if ((abfd
->flags
& DYNAMIC
) != 0
971 && ! info
->static_link
)
973 if (! xcoff_link_add_dynamic_symbols (abfd
, info
))
977 /* Create the loader, toc, gl, ds and debug sections, if needed. */
978 if (! xcoff_link_create_extra_sections (abfd
, info
))
981 if ((abfd
->flags
& DYNAMIC
) != 0
982 && ! info
->static_link
)
985 n_tmask
= coff_data (abfd
)->local_n_tmask
;
986 n_btshft
= coff_data (abfd
)->local_n_btshft
;
988 /* Define macros so that ISFCN, et. al., macros work correctly. */
989 #define N_TMASK n_tmask
990 #define N_BTSHFT n_btshft
992 if (info
->keep_memory
)
993 default_copy
= FALSE
;
997 symcount
= obj_raw_syment_count (abfd
);
999 /* We keep a list of the linker hash table entries that correspond
1000 to each external symbol. */
1001 amt
= symcount
* sizeof (struct xcoff_link_hash_entry
*);
1002 sym_hash
= bfd_zalloc (abfd
, amt
);
1003 if (sym_hash
== NULL
&& symcount
!= 0)
1005 coff_data (abfd
)->sym_hashes
= (struct coff_link_hash_entry
**) sym_hash
;
1007 /* Because of the weird stuff we are doing with XCOFF csects, we can
1008 not easily determine which section a symbol is in, so we store
1009 the information in the tdata for the input file. */
1010 amt
= symcount
* sizeof (asection
*);
1011 csect_cache
= bfd_zalloc (abfd
, amt
);
1012 if (csect_cache
== NULL
&& symcount
!= 0)
1014 xcoff_data (abfd
)->csects
= csect_cache
;
1016 /* While splitting sections into csects, we need to assign the
1017 relocs correctly. The relocs and the csects must both be in
1018 order by VMA within a given section, so we handle this by
1019 scanning along the relocs as we process the csects. We index
1020 into reloc_info using the section target_index. */
1021 amt
= abfd
->section_count
+ 1;
1022 amt
*= sizeof (struct reloc_info_struct
);
1023 reloc_info
= bfd_zmalloc (amt
);
1024 if (reloc_info
== NULL
)
1027 /* Read in the relocs and line numbers for each section. */
1028 linesz
= bfd_coff_linesz (abfd
);
1030 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1034 if ((o
->flags
& SEC_RELOC
) != 0)
1036 reloc_info
[o
->target_index
].relocs
=
1037 xcoff_read_internal_relocs (abfd
, o
, TRUE
, NULL
, FALSE
, NULL
);
1038 amt
= o
->reloc_count
;
1039 amt
*= sizeof (asection
*);
1040 reloc_info
[o
->target_index
].csects
= bfd_zmalloc (amt
);
1041 if (reloc_info
[o
->target_index
].csects
== NULL
)
1045 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1046 && o
->lineno_count
> 0)
1050 amt
= linesz
* o
->lineno_count
;
1051 linenos
= bfd_malloc (amt
);
1052 if (linenos
== NULL
)
1054 reloc_info
[o
->target_index
].linenos
= linenos
;
1055 if (bfd_seek (abfd
, o
->line_filepos
, SEEK_SET
) != 0
1056 || bfd_bread (linenos
, amt
, abfd
) != amt
)
1061 /* Don't let the linker relocation routines discard the symbols. */
1062 obj_coff_keep_syms (abfd
) = TRUE
;
1068 symesz
= bfd_coff_symesz (abfd
);
1069 BFD_ASSERT (symesz
== bfd_coff_auxesz (abfd
));
1070 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
1071 esym_end
= esym
+ symcount
* symesz
;
1073 while (esym
< esym_end
)
1075 struct internal_syment sym
;
1076 union internal_auxent aux
;
1078 char buf
[SYMNMLEN
+ 1];
1083 struct xcoff_link_hash_entry
*set_toc
;
1085 bfd_coff_swap_sym_in (abfd
, (void *) esym
, (void *) &sym
);
1087 /* In this pass we are only interested in symbols with csect
1089 if (sym
.n_sclass
!= C_EXT
&& sym
.n_sclass
!= C_HIDEXT
)
1092 Normally csect is a .pr, .rw etc. created in the loop
1093 If C_FILE or first time, handle special
1095 Advance esym, sym_hash, csect_hash ptr's
1096 Keep track of the last_symndx for the current file. */
1097 if (sym
.n_sclass
== C_FILE
&& csect
!= NULL
)
1099 xcoff_section_data (abfd
, csect
)->last_symndx
=
1101 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1107 *csect_cache
= csect
;
1108 else if (first_csect
== NULL
|| sym
.n_sclass
== C_FILE
)
1109 *csect_cache
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1111 *csect_cache
= NULL
;
1112 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1113 sym_hash
+= sym
.n_numaux
+ 1;
1114 csect_cache
+= sym
.n_numaux
+ 1;
1119 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
1124 /* If this symbol has line number information attached to it,
1125 and we're not stripping it, count the number of entries and
1126 add them to the count for this csect. In the final link pass
1127 we are going to attach line number information by symbol,
1128 rather than by section, in order to more easily handle
1129 garbage collection. */
1130 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1133 && ISFCN (sym
.n_type
))
1135 union internal_auxent auxlin
;
1137 bfd_coff_swap_aux_in (abfd
, (void *) (esym
+ symesz
),
1138 sym
.n_type
, sym
.n_sclass
,
1139 0, sym
.n_numaux
, (void *) &auxlin
);
1141 if (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
1143 asection
*enclosing
;
1144 bfd_signed_vma linoff
;
1146 enclosing
= xcoff_section_data (abfd
, csect
)->enclosing
;
1147 if (enclosing
== NULL
)
1149 (*_bfd_error_handler
)
1150 (_("%B: `%s' has line numbers but no enclosing section"),
1152 bfd_set_error (bfd_error_bad_value
);
1155 linoff
= (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
1156 - enclosing
->line_filepos
);
1157 /* Explicit cast to bfd_signed_vma for compiler. */
1158 if (linoff
< (bfd_signed_vma
) (enclosing
->lineno_count
* linesz
))
1160 struct internal_lineno lin
;
1161 bfd_byte
*linpstart
;
1163 linpstart
= (reloc_info
[enclosing
->target_index
].linenos
1165 bfd_coff_swap_lineno_in (abfd
, (void *) linpstart
, (void *) &lin
);
1167 && ((bfd_size_type
) lin
.l_addr
.l_symndx
1169 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1172 bfd_byte
*linpend
, *linp
;
1174 linpend
= (reloc_info
[enclosing
->target_index
].linenos
1175 + enclosing
->lineno_count
* linesz
);
1176 for (linp
= linpstart
+ linesz
;
1180 bfd_coff_swap_lineno_in (abfd
, (void *) linp
,
1182 if (lin
.l_lnno
== 0)
1185 csect
->lineno_count
+= (linp
- linpstart
) / linesz
;
1186 /* The setting of line_filepos will only be
1187 useful if all the line number entries for a
1188 csect are contiguous; this only matters for
1190 if (csect
->line_filepos
== 0)
1191 csect
->line_filepos
=
1192 auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1198 /* Pick up the csect auxiliary information. */
1199 if (sym
.n_numaux
== 0)
1201 (*_bfd_error_handler
)
1202 (_("%B: class %d symbol `%s' has no aux entries"),
1203 abfd
, sym
.n_sclass
, name
);
1204 bfd_set_error (bfd_error_bad_value
);
1208 bfd_coff_swap_aux_in (abfd
,
1209 (void *) (esym
+ symesz
* sym
.n_numaux
),
1210 sym
.n_type
, sym
.n_sclass
,
1211 sym
.n_numaux
- 1, sym
.n_numaux
,
1214 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
1224 (*_bfd_error_handler
)
1225 (_("%B: symbol `%s' has unrecognized csect type %d"),
1227 bfd_set_error (bfd_error_bad_value
);
1231 /* This is an external reference. */
1232 if (sym
.n_sclass
== C_HIDEXT
1233 || sym
.n_scnum
!= N_UNDEF
1234 || aux
.x_csect
.x_scnlen
.l
!= 0)
1236 (*_bfd_error_handler
)
1237 (_("%B: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d"),
1238 abfd
, name
, sym
.n_sclass
, sym
.n_scnum
,
1239 aux
.x_csect
.x_scnlen
.l
);
1240 bfd_set_error (bfd_error_bad_value
);
1244 /* An XMC_XO external reference is actually a reference to
1245 an absolute location. */
1246 if (aux
.x_csect
.x_smclas
!= XMC_XO
)
1247 section
= bfd_und_section_ptr
;
1250 section
= bfd_abs_section_ptr
;
1251 value
= sym
.n_value
;
1256 /* This is a csect definition. */
1259 xcoff_section_data (abfd
, csect
)->last_symndx
=
1260 ((esym
- (bfd_byte
*) obj_coff_external_syms (abfd
)) / symesz
);
1264 csect_index
= -(unsigned) 1;
1266 /* When we see a TOC anchor, we record the TOC value. */
1267 if (aux
.x_csect
.x_smclas
== XMC_TC0
)
1269 if (sym
.n_sclass
!= C_HIDEXT
1270 || aux
.x_csect
.x_scnlen
.l
!= 0)
1272 (*_bfd_error_handler
)
1273 (_("%B: XMC_TC0 symbol `%s' is class %d scnlen %d"),
1274 abfd
, name
, sym
.n_sclass
, aux
.x_csect
.x_scnlen
.l
);
1275 bfd_set_error (bfd_error_bad_value
);
1278 xcoff_data (abfd
)->toc
= sym
.n_value
;
1281 /* We must merge TOC entries for the same symbol. We can
1282 merge two TOC entries if they are both C_HIDEXT, they
1283 both have the same name, they are both 4 or 8 bytes long, and
1284 they both have a relocation table entry for an external
1285 symbol with the same name. Unfortunately, this means
1286 that we must look through the relocations. Ick.
1288 Logic for 32 bit vs 64 bit.
1289 32 bit has a csect length of 4 for TOC
1290 64 bit has a csect length of 8 for TOC
1292 The conditions to get past the if-check are not that bad.
1293 They are what is used to create the TOC csects in the first
1295 if (aux
.x_csect
.x_smclas
== XMC_TC
1296 && sym
.n_sclass
== C_HIDEXT
1297 && info
->output_bfd
->xvec
== abfd
->xvec
1298 && ((bfd_xcoff_is_xcoff32 (abfd
)
1299 && aux
.x_csect
.x_scnlen
.l
== 4)
1300 || (bfd_xcoff_is_xcoff64 (abfd
)
1301 && aux
.x_csect
.x_scnlen
.l
== 8)))
1303 asection
*enclosing
;
1304 struct internal_reloc
*relocs
;
1305 bfd_size_type relindx
;
1306 struct internal_reloc
*rel
;
1308 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1309 if (enclosing
== NULL
)
1312 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1313 amt
= enclosing
->reloc_count
;
1314 relindx
= xcoff_find_reloc (relocs
, amt
, sym
.n_value
);
1315 rel
= relocs
+ relindx
;
1317 /* 32 bit R_POS r_size is 31
1318 64 bit R_POS r_size is 63 */
1319 if (relindx
< enclosing
->reloc_count
1320 && rel
->r_vaddr
== (bfd_vma
) sym
.n_value
1321 && rel
->r_type
== R_POS
1322 && ((bfd_xcoff_is_xcoff32 (abfd
)
1323 && rel
->r_size
== 31)
1324 || (bfd_xcoff_is_xcoff64 (abfd
)
1325 && rel
->r_size
== 63)))
1329 struct internal_syment relsym
;
1331 erelsym
= ((bfd_byte
*) obj_coff_external_syms (abfd
)
1332 + rel
->r_symndx
* symesz
);
1333 bfd_coff_swap_sym_in (abfd
, (void *) erelsym
, (void *) &relsym
);
1334 if (relsym
.n_sclass
== C_EXT
)
1336 const char *relname
;
1337 char relbuf
[SYMNMLEN
+ 1];
1339 struct xcoff_link_hash_entry
*h
;
1341 /* At this point we know that the TOC entry is
1342 for an externally visible symbol. */
1343 relname
= _bfd_coff_internal_syment_name (abfd
, &relsym
,
1345 if (relname
== NULL
)
1348 /* We only merge TOC entries if the TC name is
1349 the same as the symbol name. This handles
1350 the normal case, but not common cases like
1351 SYM.P4 which gcc generates to store SYM + 4
1352 in the TOC. FIXME. */
1353 if (strcmp (name
, relname
) == 0)
1355 copy
= (! info
->keep_memory
1356 || relsym
._n
._n_n
._n_zeroes
!= 0
1357 || relsym
._n
._n_n
._n_offset
== 0);
1358 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1359 relname
, TRUE
, copy
,
1364 /* At this point h->root.type could be
1365 bfd_link_hash_new. That should be OK,
1366 since we know for sure that we will come
1367 across this symbol as we step through the
1370 /* We store h in *sym_hash for the
1371 convenience of the relocate_section
1375 if (h
->toc_section
!= NULL
)
1377 asection
**rel_csects
;
1379 /* We already have a TOC entry for this
1380 symbol, so we can just ignore this
1383 reloc_info
[enclosing
->target_index
].csects
;
1384 rel_csects
[relindx
] = bfd_und_section_ptr
;
1388 /* We are about to create a TOC entry for
1397 asection
*enclosing
;
1399 /* We need to create a new section. We get the name from
1400 the csect storage mapping class, so that the linker can
1401 accumulate similar csects together. */
1403 csect
= bfd_xcoff_create_csect_from_smclas(abfd
, &aux
, name
);
1407 /* The enclosing section is the main section : .data, .text
1408 or .bss that the csect is coming from. */
1409 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1410 if (enclosing
== NULL
)
1413 if (! bfd_is_abs_section (enclosing
)
1414 && ((bfd_vma
) sym
.n_value
< enclosing
->vma
1415 || ((bfd_vma
) sym
.n_value
+ aux
.x_csect
.x_scnlen
.l
1416 > enclosing
->vma
+ enclosing
->size
)))
1418 (*_bfd_error_handler
)
1419 (_("%B: csect `%s' not in enclosing section"),
1421 bfd_set_error (bfd_error_bad_value
);
1424 csect
->vma
= sym
.n_value
;
1425 csect
->filepos
= (enclosing
->filepos
1428 csect
->size
= aux
.x_csect
.x_scnlen
.l
;
1429 csect
->flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
;
1430 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1432 /* Record the enclosing section in the tdata for this new
1434 amt
= sizeof (struct coff_section_tdata
);
1435 csect
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1436 if (csect
->used_by_bfd
== NULL
)
1438 amt
= sizeof (struct xcoff_section_tdata
);
1439 coff_section_data (abfd
, csect
)->tdata
= bfd_zalloc (abfd
, amt
);
1440 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1442 xcoff_section_data (abfd
, csect
)->enclosing
= enclosing
;
1443 xcoff_section_data (abfd
, csect
)->lineno_count
=
1444 enclosing
->lineno_count
;
1446 if (enclosing
->owner
== abfd
)
1448 struct internal_reloc
*relocs
;
1449 bfd_size_type relindx
;
1450 struct internal_reloc
*rel
;
1451 asection
**rel_csect
;
1453 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1454 amt
= enclosing
->reloc_count
;
1455 relindx
= xcoff_find_reloc (relocs
, amt
, csect
->vma
);
1457 rel
= relocs
+ relindx
;
1458 rel_csect
= (reloc_info
[enclosing
->target_index
].csects
1461 csect
->rel_filepos
= (enclosing
->rel_filepos
1462 + relindx
* bfd_coff_relsz (abfd
));
1463 while (relindx
< enclosing
->reloc_count
1464 && *rel_csect
== NULL
1465 && rel
->r_vaddr
< csect
->vma
+ csect
->size
)
1469 csect
->flags
|= SEC_RELOC
;
1470 ++csect
->reloc_count
;
1477 /* There are a number of other fields and section flags
1478 which we do not bother to set. */
1480 csect_index
= ((esym
1481 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1484 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1486 if (first_csect
== NULL
)
1487 first_csect
= csect
;
1489 /* If this symbol is C_EXT, we treat it as starting at the
1490 beginning of the newly created section. */
1491 if (sym
.n_sclass
== C_EXT
)
1497 /* If this is a TOC section for a symbol, record it. */
1498 if (set_toc
!= NULL
)
1499 set_toc
->toc_section
= csect
;
1504 /* This is a label definition. The x_scnlen field is the
1505 symbol index of the csect. Usually the XTY_LD symbol will
1506 follow its appropriate XTY_SD symbol. The .set pseudo op can
1507 cause the XTY_LD to not follow the XTY_SD symbol. */
1512 if (aux
.x_csect
.x_scnlen
.l
< 0
1513 || (aux
.x_csect
.x_scnlen
.l
1514 >= esym
- (bfd_byte
*) obj_coff_external_syms (abfd
)))
1518 section
= xcoff_data (abfd
)->csects
[aux
.x_csect
.x_scnlen
.l
];
1520 || (section
->flags
& SEC_HAS_CONTENTS
) == 0)
1525 (*_bfd_error_handler
)
1526 (_("%B: misplaced XTY_LD `%s'"),
1528 bfd_set_error (bfd_error_bad_value
);
1532 value
= sym
.n_value
- csect
->vma
;
1537 /* This is an unitialized csect. We could base the name on
1538 the storage mapping class, but we don't bother except for
1539 an XMC_TD symbol. If this csect is externally visible,
1540 it is a common symbol. We put XMC_TD symbols in sections
1541 named .tocbss, and rely on the linker script to put that
1546 xcoff_section_data (abfd
, csect
)->last_symndx
=
1548 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1552 if (aux
.x_csect
.x_smclas
== XMC_TD
)
1554 /* The linker script puts the .td section in the data
1555 section after the .tc section. */
1556 csect
= bfd_make_section_anyway_with_flags (abfd
, ".td",
1560 csect
= bfd_make_section_anyway_with_flags (abfd
, ".bss",
1565 csect
->vma
= sym
.n_value
;
1566 csect
->size
= aux
.x_csect
.x_scnlen
.l
;
1567 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1568 /* There are a number of other fields and section flags
1569 which we do not bother to set. */
1571 csect_index
= ((esym
1572 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1575 amt
= sizeof (struct coff_section_tdata
);
1576 csect
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1577 if (csect
->used_by_bfd
== NULL
)
1579 amt
= sizeof (struct xcoff_section_tdata
);
1580 coff_section_data (abfd
, csect
)->tdata
= bfd_zalloc (abfd
, amt
);
1581 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1583 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1585 if (first_csect
== NULL
)
1586 first_csect
= csect
;
1588 if (sym
.n_sclass
== C_EXT
)
1590 csect
->flags
|= SEC_IS_COMMON
;
1593 value
= aux
.x_csect
.x_scnlen
.l
;
1599 /* Check for magic symbol names. */
1600 if ((smtyp
== XTY_SD
|| smtyp
== XTY_CM
)
1601 && aux
.x_csect
.x_smclas
!= XMC_TC
1602 && aux
.x_csect
.x_smclas
!= XMC_TD
)
1608 if (strcmp (name
, "_text") == 0)
1609 i
= XCOFF_SPECIAL_SECTION_TEXT
;
1610 else if (strcmp (name
, "_etext") == 0)
1611 i
= XCOFF_SPECIAL_SECTION_ETEXT
;
1612 else if (strcmp (name
, "_data") == 0)
1613 i
= XCOFF_SPECIAL_SECTION_DATA
;
1614 else if (strcmp (name
, "_edata") == 0)
1615 i
= XCOFF_SPECIAL_SECTION_EDATA
;
1616 else if (strcmp (name
, "_end") == 0)
1617 i
= XCOFF_SPECIAL_SECTION_END
;
1619 else if (name
[0] == 'e' && strcmp (name
, "end") == 0)
1620 i
= XCOFF_SPECIAL_SECTION_END2
;
1623 xcoff_hash_table (info
)->special_sections
[i
] = csect
;
1626 /* Now we have enough information to add the symbol to the
1627 linker hash table. */
1629 if (sym
.n_sclass
== C_EXT
)
1633 BFD_ASSERT (section
!= NULL
);
1635 /* We must copy the name into memory if we got it from the
1636 syment itself, rather than the string table. */
1637 copy
= default_copy
;
1638 if (sym
._n
._n_n
._n_zeroes
!= 0
1639 || sym
._n
._n_n
._n_offset
== 0)
1642 /* The AIX linker appears to only detect multiple symbol
1643 definitions when there is a reference to the symbol. If
1644 a symbol is defined multiple times, and the only
1645 references are from the same object file, the AIX linker
1646 appears to permit it. It does not merge the different
1647 definitions, but handles them independently. On the
1648 other hand, if there is a reference, the linker reports
1651 This matters because the AIX <net/net_globals.h> header
1652 file actually defines an initialized array, so we have to
1653 actually permit that to work.
1655 Just to make matters even more confusing, the AIX linker
1656 appears to permit multiple symbol definitions whenever
1657 the second definition is in an archive rather than an
1658 object file. This may be a consequence of the manner in
1659 which it handles archives: I think it may load the entire
1660 archive in as separate csects, and then let garbage
1661 collection discard symbols.
1663 We also have to handle the case of statically linking a
1664 shared object, which will cause symbol redefinitions,
1665 although this is an easier case to detect. */
1667 if (info
->output_bfd
->xvec
== abfd
->xvec
)
1669 if (! bfd_is_und_section (section
))
1670 *sym_hash
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1671 name
, TRUE
, copy
, FALSE
);
1673 /* Make a copy of the symbol name to prevent problems with
1675 *sym_hash
= ((struct xcoff_link_hash_entry
*)
1676 bfd_wrapped_link_hash_lookup (abfd
, info
, name
,
1677 TRUE
, TRUE
, FALSE
));
1679 if (*sym_hash
== NULL
)
1681 if (((*sym_hash
)->root
.type
== bfd_link_hash_defined
1682 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
1683 && ! bfd_is_und_section (section
)
1684 && ! bfd_is_com_section (section
))
1686 /* This is a second definition of a defined symbol. */
1687 if ((abfd
->flags
& DYNAMIC
) != 0
1688 && ((*sym_hash
)->smclas
!= XMC_GL
1689 || aux
.x_csect
.x_smclas
== XMC_GL
1690 || ((*sym_hash
)->root
.u
.def
.section
->owner
->flags
1693 /* The new symbol is from a shared library, and
1694 either the existing symbol is not global
1695 linkage code or this symbol is global linkage
1696 code. If the existing symbol is global
1697 linkage code and the new symbol is not, then
1698 we want to use the new symbol. */
1699 section
= bfd_und_section_ptr
;
1702 else if (((*sym_hash
)->root
.u
.def
.section
->owner
->flags
1705 /* The existing symbol is from a shared library.
1707 (*sym_hash
)->root
.type
= bfd_link_hash_undefined
;
1708 (*sym_hash
)->root
.u
.undef
.abfd
=
1709 (*sym_hash
)->root
.u
.def
.section
->owner
;
1711 else if (abfd
->my_archive
!= NULL
)
1713 /* This is a redefinition in an object contained
1714 in an archive. Just ignore it. See the
1716 section
= bfd_und_section_ptr
;
1719 else if ((*sym_hash
)->root
.u
.undef
.next
!= NULL
1720 || info
->hash
->undefs_tail
== &(*sym_hash
)->root
)
1722 /* This symbol has been referenced. In this
1723 case, we just continue and permit the
1724 multiple definition error. See the comment
1725 above about the behaviour of the AIX linker. */
1727 else if ((*sym_hash
)->smclas
== aux
.x_csect
.x_smclas
)
1729 /* The symbols are both csects of the same
1730 class. There is at least a chance that this
1731 is a semi-legitimate redefinition. */
1732 section
= bfd_und_section_ptr
;
1734 (*sym_hash
)->flags
|= XCOFF_MULTIPLY_DEFINED
;
1737 else if (((*sym_hash
)->flags
& XCOFF_MULTIPLY_DEFINED
) != 0
1738 && ((*sym_hash
)->root
.type
== bfd_link_hash_defined
1739 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
1740 && (bfd_is_und_section (section
)
1741 || bfd_is_com_section (section
)))
1743 /* This is a reference to a multiply defined symbol.
1744 Report the error now. See the comment above
1745 about the behaviour of the AIX linker. We could
1746 also do this with warning symbols, but I'm not
1747 sure the XCOFF linker is wholly prepared to
1748 handle them, and that would only be a warning,
1750 if (! ((*info
->callbacks
->multiple_definition
)
1751 (info
, (*sym_hash
)->root
.root
.string
,
1752 NULL
, NULL
, (bfd_vma
) 0,
1753 (*sym_hash
)->root
.u
.def
.section
->owner
,
1754 (*sym_hash
)->root
.u
.def
.section
,
1755 (*sym_hash
)->root
.u
.def
.value
)))
1757 /* Try not to give this error too many times. */
1758 (*sym_hash
)->flags
&= ~XCOFF_MULTIPLY_DEFINED
;
1762 /* _bfd_generic_link_add_one_symbol may call the linker to
1763 generate an error message, and the linker may try to read
1764 the symbol table to give a good error. Right now, the
1765 line numbers are in an inconsistent state, since they are
1766 counted both in the real sections and in the new csects.
1767 We need to leave the count in the real sections so that
1768 the linker can report the line number of the error
1769 correctly, so temporarily clobber the link to the csects
1770 so that the linker will not try to read the line numbers
1771 a second time from the csects. */
1772 BFD_ASSERT (last_real
->next
== first_csect
);
1773 last_real
->next
= NULL
;
1774 if (! (_bfd_generic_link_add_one_symbol
1775 (info
, abfd
, name
, flags
, section
, value
,
1777 (struct bfd_link_hash_entry
**) sym_hash
)))
1779 last_real
->next
= first_csect
;
1781 if (smtyp
== XTY_CM
)
1783 if ((*sym_hash
)->root
.type
!= bfd_link_hash_common
1784 || (*sym_hash
)->root
.u
.c
.p
->section
!= csect
)
1785 /* We don't need the common csect we just created. */
1788 (*sym_hash
)->root
.u
.c
.p
->alignment_power
1789 = csect
->alignment_power
;
1792 if (info
->output_bfd
->xvec
== abfd
->xvec
)
1796 if (smtyp
== XTY_ER
|| smtyp
== XTY_CM
)
1797 flag
= XCOFF_REF_REGULAR
;
1799 flag
= XCOFF_DEF_REGULAR
;
1800 (*sym_hash
)->flags
|= flag
;
1802 if ((*sym_hash
)->smclas
== XMC_UA
1803 || flag
== XCOFF_DEF_REGULAR
)
1804 (*sym_hash
)->smclas
= aux
.x_csect
.x_smclas
;
1808 *csect_cache
= csect
;
1810 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1811 sym_hash
+= sym
.n_numaux
+ 1;
1812 csect_cache
+= sym
.n_numaux
+ 1;
1815 BFD_ASSERT (last_real
== NULL
|| last_real
->next
== first_csect
);
1817 /* Make sure that we have seen all the relocs. */
1818 for (o
= abfd
->sections
; o
!= first_csect
; o
= o
->next
)
1820 /* Reset the section size and the line number count, since the
1821 data is now attached to the csects. Don't reset the size of
1822 the .debug section, since we need to read it below in
1823 bfd_xcoff_size_dynamic_sections. */
1824 if (strcmp (bfd_get_section_name (abfd
, o
), ".debug") != 0)
1826 o
->lineno_count
= 0;
1828 if ((o
->flags
& SEC_RELOC
) != 0)
1831 struct internal_reloc
*rel
;
1832 asection
**rel_csect
;
1834 rel
= reloc_info
[o
->target_index
].relocs
;
1835 rel_csect
= reloc_info
[o
->target_index
].csects
;
1837 for (i
= 0; i
< o
->reloc_count
; i
++, rel
++, rel_csect
++)
1839 if (*rel_csect
== NULL
)
1841 (*_bfd_error_handler
)
1842 (_("%B: reloc %s:%d not in csect"),
1844 bfd_set_error (bfd_error_bad_value
);
1848 /* We identify all function symbols that are the target
1849 of a relocation, so that we can create glue code for
1850 functions imported from dynamic objects. */
1851 if (info
->output_bfd
->xvec
== abfd
->xvec
1852 && *rel_csect
!= bfd_und_section_ptr
1853 && obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
] != NULL
)
1855 struct xcoff_link_hash_entry
*h
;
1857 h
= obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
];
1858 /* If the symbol name starts with a period, it is
1859 the code of a function. If the symbol is
1860 currently undefined, then add an undefined symbol
1861 for the function descriptor. This should do no
1862 harm, because any regular object that defines the
1863 function should also define the function
1864 descriptor. It helps, because it means that we
1865 will identify the function descriptor with a
1866 dynamic object if a dynamic object defines it. */
1867 if (h
->root
.root
.string
[0] == '.'
1868 && h
->descriptor
== NULL
)
1870 struct xcoff_link_hash_entry
*hds
;
1871 struct bfd_link_hash_entry
*bh
;
1873 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1874 h
->root
.root
.string
+ 1,
1878 if (hds
->root
.type
== bfd_link_hash_new
)
1881 if (! (_bfd_generic_link_add_one_symbol
1882 (info
, abfd
, hds
->root
.root
.string
,
1883 (flagword
) 0, bfd_und_section_ptr
,
1884 (bfd_vma
) 0, NULL
, FALSE
,
1887 hds
= (struct xcoff_link_hash_entry
*) bh
;
1889 hds
->flags
|= XCOFF_DESCRIPTOR
;
1890 BFD_ASSERT ((h
->flags
& XCOFF_DESCRIPTOR
) == 0);
1891 hds
->descriptor
= h
;
1892 h
->descriptor
= hds
;
1894 if (h
->root
.root
.string
[0] == '.')
1895 h
->flags
|= XCOFF_CALLED
;
1899 free (reloc_info
[o
->target_index
].csects
);
1900 reloc_info
[o
->target_index
].csects
= NULL
;
1902 /* Reset SEC_RELOC and the reloc_count, since the reloc
1903 information is now attached to the csects. */
1904 o
->flags
&=~ SEC_RELOC
;
1907 /* If we are not keeping memory, free the reloc information. */
1908 if (! info
->keep_memory
1909 && coff_section_data (abfd
, o
) != NULL
1910 && coff_section_data (abfd
, o
)->relocs
!= NULL
1911 && ! coff_section_data (abfd
, o
)->keep_relocs
)
1913 free (coff_section_data (abfd
, o
)->relocs
);
1914 coff_section_data (abfd
, o
)->relocs
= NULL
;
1918 /* Free up the line numbers. FIXME: We could cache these
1919 somewhere for the final link, to avoid reading them again. */
1920 if (reloc_info
[o
->target_index
].linenos
!= NULL
)
1922 free (reloc_info
[o
->target_index
].linenos
);
1923 reloc_info
[o
->target_index
].linenos
= NULL
;
1929 obj_coff_keep_syms (abfd
) = keep_syms
;
1934 if (reloc_info
!= NULL
)
1936 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1938 if (reloc_info
[o
->target_index
].csects
!= NULL
)
1939 free (reloc_info
[o
->target_index
].csects
);
1940 if (reloc_info
[o
->target_index
].linenos
!= NULL
)
1941 free (reloc_info
[o
->target_index
].linenos
);
1945 obj_coff_keep_syms (abfd
) = keep_syms
;
1952 /* Add symbols from an XCOFF object file. */
1955 xcoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
1957 if (! _bfd_coff_get_external_symbols (abfd
))
1959 if (! xcoff_link_add_symbols (abfd
, info
))
1961 if (! info
->keep_memory
)
1963 if (! _bfd_coff_free_symbols (abfd
))
1969 /* Look through the loader symbols to see if this dynamic object
1970 should be included in the link. The native linker uses the loader
1971 symbols, not the normal symbol table, so we do too. */
1974 xcoff_link_check_dynamic_ar_symbols (bfd
*abfd
,
1975 struct bfd_link_info
*info
,
1976 bfd_boolean
*pneeded
)
1980 struct internal_ldhdr ldhdr
;
1981 const char *strings
;
1982 bfd_byte
*elsym
, *elsymend
;
1986 lsec
= bfd_get_section_by_name (abfd
, ".loader");
1988 /* There are no symbols, so don't try to include it. */
1991 if (! xcoff_get_section_contents (abfd
, lsec
))
1993 contents
= coff_section_data (abfd
, lsec
)->contents
;
1995 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
1997 strings
= (char *) contents
+ ldhdr
.l_stoff
;
1999 elsym
= contents
+ bfd_xcoff_loader_symbol_offset (abfd
, &ldhdr
);
2001 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz (abfd
);
2002 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz (abfd
))
2004 struct internal_ldsym ldsym
;
2005 char nambuf
[SYMNMLEN
+ 1];
2007 struct bfd_link_hash_entry
*h
;
2009 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
2011 /* We are only interested in exported symbols. */
2012 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
2015 if (ldsym
._l
._l_l
._l_zeroes
== 0)
2016 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
2019 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
2020 nambuf
[SYMNMLEN
] = '\0';
2024 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
2026 /* We are only interested in symbols that are currently
2027 undefined. At this point we know that we are using an XCOFF
2030 && h
->type
== bfd_link_hash_undefined
2031 && (((struct xcoff_link_hash_entry
*) h
)->flags
2032 & XCOFF_DEF_DYNAMIC
) == 0)
2034 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
2041 /* We do not need this shared object. */
2042 if (contents
!= NULL
&& ! coff_section_data (abfd
, lsec
)->keep_contents
)
2044 free (coff_section_data (abfd
, lsec
)->contents
);
2045 coff_section_data (abfd
, lsec
)->contents
= NULL
;
2051 /* Look through the symbols to see if this object file should be
2052 included in the link. */
2055 xcoff_link_check_ar_symbols (bfd
*abfd
,
2056 struct bfd_link_info
*info
,
2057 bfd_boolean
*pneeded
)
2059 bfd_size_type symesz
;
2065 if ((abfd
->flags
& DYNAMIC
) != 0
2066 && ! info
->static_link
2067 && info
->output_bfd
->xvec
== abfd
->xvec
)
2068 return xcoff_link_check_dynamic_ar_symbols (abfd
, info
, pneeded
);
2070 symesz
= bfd_coff_symesz (abfd
);
2071 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
2072 esym_end
= esym
+ obj_raw_syment_count (abfd
) * symesz
;
2073 while (esym
< esym_end
)
2075 struct internal_syment sym
;
2077 bfd_coff_swap_sym_in (abfd
, (void *) esym
, (void *) &sym
);
2079 if (sym
.n_sclass
== C_EXT
&& sym
.n_scnum
!= N_UNDEF
)
2082 char buf
[SYMNMLEN
+ 1];
2083 struct bfd_link_hash_entry
*h
;
2085 /* This symbol is externally visible, and is defined by this
2087 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
2091 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
2093 /* We are only interested in symbols that are currently
2094 undefined. If a symbol is currently known to be common,
2095 XCOFF linkers do not bring in an object file which
2096 defines it. We also don't bring in symbols to satisfy
2097 undefined references in shared objects. */
2099 && h
->type
== bfd_link_hash_undefined
2100 && (info
->output_bfd
->xvec
!= abfd
->xvec
2101 || (((struct xcoff_link_hash_entry
*) h
)->flags
2102 & XCOFF_DEF_DYNAMIC
) == 0))
2104 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
2111 esym
+= (sym
.n_numaux
+ 1) * symesz
;
2114 /* We do not need this object file. */
2118 /* Check a single archive element to see if we need to include it in
2119 the link. *PNEEDED is set according to whether this element is
2120 needed in the link or not. This is called via
2121 _bfd_generic_link_add_archive_symbols. */
2124 xcoff_link_check_archive_element (bfd
*abfd
,
2125 struct bfd_link_info
*info
,
2126 bfd_boolean
*pneeded
)
2128 if (! _bfd_coff_get_external_symbols (abfd
))
2131 if (! xcoff_link_check_ar_symbols (abfd
, info
, pneeded
))
2136 if (! xcoff_link_add_symbols (abfd
, info
))
2140 if (! info
->keep_memory
|| ! *pneeded
)
2142 if (! _bfd_coff_free_symbols (abfd
))
2149 /* Given an XCOFF BFD, add symbols to the global hash table as
2153 _bfd_xcoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2155 switch (bfd_get_format (abfd
))
2158 return xcoff_link_add_object_symbols (abfd
, info
);
2161 /* If the archive has a map, do the usual search. We then need
2162 to check the archive for dynamic objects, because they may not
2163 appear in the archive map even though they should, perhaps, be
2164 included. If the archive has no map, we just consider each object
2165 file in turn, since that apparently is what the AIX native linker
2167 if (bfd_has_map (abfd
))
2169 if (! (_bfd_generic_link_add_archive_symbols
2170 (abfd
, info
, xcoff_link_check_archive_element
)))
2177 member
= bfd_openr_next_archived_file (abfd
, NULL
);
2178 while (member
!= NULL
)
2180 if (bfd_check_format (member
, bfd_object
)
2181 && (info
->output_bfd
->xvec
== member
->xvec
)
2182 && (! bfd_has_map (abfd
) || (member
->flags
& DYNAMIC
) != 0))
2186 if (! xcoff_link_check_archive_element (member
, info
,
2190 member
->archive_pass
= -1;
2192 member
= bfd_openr_next_archived_file (abfd
, member
);
2199 bfd_set_error (bfd_error_wrong_format
);
2204 /* If symbol H has not been interpreted as a function descriptor,
2205 see whether it should be. Set up its descriptor information if so. */
2208 xcoff_find_function (struct bfd_link_info
*info
,
2209 struct xcoff_link_hash_entry
*h
)
2211 if ((h
->flags
& XCOFF_DESCRIPTOR
) == 0
2212 && h
->root
.root
.string
[0] != '.')
2215 struct xcoff_link_hash_entry
*hfn
;
2218 amt
= strlen (h
->root
.root
.string
) + 2;
2219 fnname
= bfd_malloc (amt
);
2223 strcpy (fnname
+ 1, h
->root
.root
.string
);
2224 hfn
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2225 fnname
, FALSE
, FALSE
, TRUE
);
2228 && hfn
->smclas
== XMC_PR
2229 && (hfn
->root
.type
== bfd_link_hash_defined
2230 || hfn
->root
.type
== bfd_link_hash_defweak
))
2232 h
->flags
|= XCOFF_DESCRIPTOR
;
2233 h
->descriptor
= hfn
;
2234 hfn
->descriptor
= h
;
2240 /* H is an imported symbol. Set the import module's path, file and member
2241 to IMPATH, IMPFILE and IMPMEMBER respectively. All three are null if
2242 no specific import module is specified. */
2245 xcoff_set_import_path (struct bfd_link_info
*info
,
2246 struct xcoff_link_hash_entry
*h
,
2247 const char *imppath
, const char *impfile
,
2248 const char *impmember
)
2251 struct xcoff_import_file
**pp
;
2253 /* We overload the ldindx field to hold the l_ifile value for this
2255 BFD_ASSERT (h
->ldsym
== NULL
);
2256 BFD_ASSERT ((h
->flags
& XCOFF_BUILT_LDSYM
) == 0);
2257 if (imppath
== NULL
)
2261 /* We start c at 1 because the first entry in the import list is
2262 reserved for the library search path. */
2263 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
2265 pp
= &(*pp
)->next
, ++c
)
2267 if (strcmp ((*pp
)->path
, imppath
) == 0
2268 && strcmp ((*pp
)->file
, impfile
) == 0
2269 && strcmp ((*pp
)->member
, impmember
) == 0)
2275 struct xcoff_import_file
*n
;
2276 bfd_size_type amt
= sizeof (* n
);
2278 n
= bfd_alloc (info
->output_bfd
, amt
);
2284 n
->member
= impmember
;
2292 /* Mark a symbol as not being garbage, including the section in which
2295 static inline bfd_boolean
2296 xcoff_mark_symbol (struct bfd_link_info
*info
, struct xcoff_link_hash_entry
*h
)
2298 if ((h
->flags
& XCOFF_MARK
) != 0)
2301 h
->flags
|= XCOFF_MARK
;
2303 /* If we're marking an undefined symbol, try find some way of
2305 if (!info
->relocatable
2306 && (h
->flags
& XCOFF_IMPORT
) == 0
2307 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
2308 && (h
->root
.type
== bfd_link_hash_undefined
2309 || h
->root
.type
== bfd_link_hash_undefweak
))
2311 /* First check whether this symbol can be interpreted as an
2312 undefined function descriptor for a defined function symbol. */
2313 if (!xcoff_find_function (info
, h
))
2316 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
2317 && (h
->descriptor
->root
.type
== bfd_link_hash_defined
2318 || h
->descriptor
->root
.type
== bfd_link_hash_defweak
))
2320 /* This is a descriptor for a defined symbol, but the input
2321 objects have not defined the descriptor itself. Fill in
2322 the definition automatically.
2324 Note that we do this even if we found a dynamic definition
2325 of H. The local function definition logically overrides
2329 sec
= xcoff_hash_table (info
)->descriptor_section
;
2330 h
->root
.type
= bfd_link_hash_defined
;
2331 h
->root
.u
.def
.section
= sec
;
2332 h
->root
.u
.def
.value
= sec
->size
;
2334 h
->flags
|= XCOFF_DEF_REGULAR
;
2336 /* The size of the function descriptor depends on whether this
2337 is xcoff32 (12) or xcoff64 (24). */
2338 sec
->size
+= bfd_xcoff_function_descriptor_size (sec
->owner
);
2340 /* A function descriptor uses two relocs: one for the
2341 associated code, and one for the TOC address. */
2342 xcoff_hash_table (info
)->ldrel_count
+= 2;
2343 sec
->reloc_count
+= 2;
2345 /* Mark the function itself. */
2346 if (!xcoff_mark_symbol (info
, h
->descriptor
))
2349 /* We handle writing out the contents of the descriptor in
2350 xcoff_write_global_symbol. */
2352 else if ((h
->flags
& XCOFF_CALLED
) != 0)
2354 /* This is a function symbol for which we need to create
2357 struct xcoff_link_hash_entry
*hds
;
2359 /* Mark the descriptor (and its TOC section). */
2360 hds
= h
->descriptor
;
2361 BFD_ASSERT ((hds
->root
.type
== bfd_link_hash_undefined
2362 || hds
->root
.type
== bfd_link_hash_undefweak
)
2363 && (hds
->flags
& XCOFF_DEF_REGULAR
) == 0);
2364 if (!xcoff_mark_symbol (info
, hds
))
2367 /* Treat this symbol as undefined if the descriptor was. */
2368 if ((hds
->flags
& XCOFF_WAS_UNDEFINED
) != 0)
2369 h
->flags
|= XCOFF_WAS_UNDEFINED
;
2371 /* Allocate room for the global linkage code itself. */
2372 sec
= xcoff_hash_table (info
)->linkage_section
;
2373 h
->root
.type
= bfd_link_hash_defined
;
2374 h
->root
.u
.def
.section
= sec
;
2375 h
->root
.u
.def
.value
= sec
->size
;
2377 h
->flags
|= XCOFF_DEF_REGULAR
;
2378 sec
->size
+= bfd_xcoff_glink_code_size (info
->output_bfd
);
2380 /* The global linkage code requires a TOC entry for the
2382 if (hds
->toc_section
== NULL
)
2387 xcoff32 uses 4 bytes in the toc.
2388 xcoff64 uses 8 bytes in the toc. */
2389 if (bfd_xcoff_is_xcoff64 (info
->output_bfd
))
2391 else if (bfd_xcoff_is_xcoff32 (info
->output_bfd
))
2396 /* Allocate room in the fallback TOC section. */
2397 hds
->toc_section
= xcoff_hash_table (info
)->toc_section
;
2398 hds
->u
.toc_offset
= hds
->toc_section
->size
;
2399 hds
->toc_section
->size
+= byte_size
;
2400 if (!xcoff_mark (info
, hds
->toc_section
))
2403 /* Allocate room for a static and dynamic R_TOC
2405 ++xcoff_hash_table (info
)->ldrel_count
;
2406 ++hds
->toc_section
->reloc_count
;
2408 /* Set the index to -2 to force this symbol to
2411 hds
->flags
|= XCOFF_SET_TOC
| XCOFF_LDREL
;
2414 else if ((h
->flags
& XCOFF_DEF_DYNAMIC
) == 0)
2416 /* Record that the symbol was undefined, then import it.
2417 -brtl links use a special fake import file. */
2418 h
->flags
|= XCOFF_WAS_UNDEFINED
| XCOFF_IMPORT
;
2419 if (xcoff_hash_table (info
)->rtld
)
2421 if (!xcoff_set_import_path (info
, h
, "", "..", ""))
2426 if (!xcoff_set_import_path (info
, h
, NULL
, NULL
, NULL
))
2432 if (h
->root
.type
== bfd_link_hash_defined
2433 || h
->root
.type
== bfd_link_hash_defweak
)
2437 hsec
= h
->root
.u
.def
.section
;
2438 if (! bfd_is_abs_section (hsec
)
2439 && (hsec
->flags
& SEC_MARK
) == 0)
2441 if (! xcoff_mark (info
, hsec
))
2446 if (h
->toc_section
!= NULL
2447 && (h
->toc_section
->flags
& SEC_MARK
) == 0)
2449 if (! xcoff_mark (info
, h
->toc_section
))
2456 /* The mark phase of garbage collection. For a given section, mark
2457 it, and all the sections which define symbols to which it refers.
2458 Because this function needs to look at the relocs, we also count
2459 the number of relocs which need to be copied into the .loader
2463 xcoff_mark (struct bfd_link_info
*info
, asection
*sec
)
2465 if (bfd_is_abs_section (sec
)
2466 || (sec
->flags
& SEC_MARK
) != 0)
2469 sec
->flags
|= SEC_MARK
;
2471 if (sec
->owner
->xvec
== info
->output_bfd
->xvec
2472 && coff_section_data (sec
->owner
, sec
) != NULL
2473 && xcoff_section_data (sec
->owner
, sec
) != NULL
)
2475 struct xcoff_link_hash_entry
**hp
, **hpend
;
2476 struct internal_reloc
*rel
, *relend
;
2478 /* Mark all the symbols in this section. */
2479 hp
= (obj_xcoff_sym_hashes (sec
->owner
)
2480 + xcoff_section_data (sec
->owner
, sec
)->first_symndx
);
2481 hpend
= (obj_xcoff_sym_hashes (sec
->owner
)
2482 + xcoff_section_data (sec
->owner
, sec
)->last_symndx
);
2483 for (; hp
< hpend
; hp
++)
2485 struct xcoff_link_hash_entry
*h
;
2489 && (h
->flags
& XCOFF_MARK
) == 0)
2491 if (! xcoff_mark_symbol (info
, h
))
2496 /* Look through the section relocs. */
2497 if ((sec
->flags
& SEC_RELOC
) != 0
2498 && sec
->reloc_count
> 0)
2500 rel
= xcoff_read_internal_relocs (sec
->owner
, sec
, TRUE
,
2504 relend
= rel
+ sec
->reloc_count
;
2505 for (; rel
< relend
; rel
++)
2508 struct xcoff_link_hash_entry
*h
;
2510 if ((unsigned int) rel
->r_symndx
2511 > obj_raw_syment_count (sec
->owner
))
2514 h
= obj_xcoff_sym_hashes (sec
->owner
)[rel
->r_symndx
];
2516 && (h
->flags
& XCOFF_MARK
) == 0)
2518 if (! xcoff_mark_symbol (info
, h
))
2522 rsec
= xcoff_data (sec
->owner
)->csects
[rel
->r_symndx
];
2524 && (rsec
->flags
& SEC_MARK
) == 0)
2526 if (! xcoff_mark (info
, rsec
))
2530 /* See if this reloc needs to be copied into the .loader
2532 switch (rel
->r_type
)
2536 || h
->root
.type
== bfd_link_hash_defined
2537 || h
->root
.type
== bfd_link_hash_defweak
2538 || h
->root
.type
== bfd_link_hash_common
2539 /* We will always provide a local definition of
2540 function symbols. */
2541 || (h
->flags
& XCOFF_CALLED
) != 0)
2549 && (h
->root
.type
== bfd_link_hash_defined
2550 || h
->root
.type
== bfd_link_hash_defweak
)
2551 && bfd_is_abs_section (h
->root
.u
.def
.section
))
2553 ++xcoff_hash_table (info
)->ldrel_count
;
2555 h
->flags
|= XCOFF_LDREL
;
2562 /* We should never need a .loader reloc for a TOC
2568 if (! info
->keep_memory
2569 && coff_section_data (sec
->owner
, sec
) != NULL
2570 && coff_section_data (sec
->owner
, sec
)->relocs
!= NULL
2571 && ! coff_section_data (sec
->owner
, sec
)->keep_relocs
)
2573 free (coff_section_data (sec
->owner
, sec
)->relocs
);
2574 coff_section_data (sec
->owner
, sec
)->relocs
= NULL
;
2582 /* Routines that are called after all the input files have been
2583 handled, but before the sections are laid out in memory. */
2585 /* The sweep phase of garbage collection. Remove all garbage
2589 xcoff_sweep (struct bfd_link_info
*info
)
2593 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
2597 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
2599 if ((o
->flags
& SEC_MARK
) == 0)
2601 /* Keep all sections from non-XCOFF input files. Keep
2602 special sections. Keep .debug sections for the
2604 if (sub
->xvec
!= info
->output_bfd
->xvec
2605 || o
== xcoff_hash_table (info
)->debug_section
2606 || o
== xcoff_hash_table (info
)->loader_section
2607 || o
== xcoff_hash_table (info
)->linkage_section
2608 || o
== xcoff_hash_table (info
)->toc_section
2609 || o
== xcoff_hash_table (info
)->descriptor_section
2610 || strcmp (o
->name
, ".debug") == 0)
2611 o
->flags
|= SEC_MARK
;
2616 o
->lineno_count
= 0;
2623 /* Record the number of elements in a set. This is used to output the
2624 correct csect length. */
2627 bfd_xcoff_link_record_set (bfd
*output_bfd
,
2628 struct bfd_link_info
*info
,
2629 struct bfd_link_hash_entry
*harg
,
2632 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2633 struct xcoff_link_size_list
*n
;
2636 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2639 /* This will hardly ever be called. I don't want to burn four bytes
2640 per global symbol, so instead the size is kept on a linked list
2641 attached to the hash table. */
2643 n
= bfd_alloc (output_bfd
, amt
);
2646 n
->next
= xcoff_hash_table (info
)->size_list
;
2649 xcoff_hash_table (info
)->size_list
= n
;
2651 h
->flags
|= XCOFF_HAS_SIZE
;
2656 /* Import a symbol. */
2659 bfd_xcoff_import_symbol (bfd
*output_bfd
,
2660 struct bfd_link_info
*info
,
2661 struct bfd_link_hash_entry
*harg
,
2663 const char *imppath
,
2664 const char *impfile
,
2665 const char *impmember
,
2666 unsigned int syscall_flag
)
2668 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2670 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2673 /* A symbol name which starts with a period is the code for a
2674 function. If the symbol is undefined, then add an undefined
2675 symbol for the function descriptor, and import that instead. */
2676 if (h
->root
.root
.string
[0] == '.'
2677 && h
->root
.type
== bfd_link_hash_undefined
2678 && val
== (bfd_vma
) -1)
2680 struct xcoff_link_hash_entry
*hds
;
2682 hds
= h
->descriptor
;
2685 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2686 h
->root
.root
.string
+ 1,
2690 if (hds
->root
.type
== bfd_link_hash_new
)
2692 hds
->root
.type
= bfd_link_hash_undefined
;
2693 hds
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
2695 hds
->flags
|= XCOFF_DESCRIPTOR
;
2696 BFD_ASSERT ((h
->flags
& XCOFF_DESCRIPTOR
) == 0);
2697 hds
->descriptor
= h
;
2698 h
->descriptor
= hds
;
2701 /* Now, if the descriptor is undefined, import the descriptor
2702 rather than the symbol we were told to import. FIXME: Is
2703 this correct in all cases? */
2704 if (hds
->root
.type
== bfd_link_hash_undefined
)
2708 h
->flags
|= (XCOFF_IMPORT
| syscall_flag
);
2710 if (val
!= (bfd_vma
) -1)
2712 if (h
->root
.type
== bfd_link_hash_defined
2713 && (! bfd_is_abs_section (h
->root
.u
.def
.section
)
2714 || h
->root
.u
.def
.value
!= val
))
2716 if (! ((*info
->callbacks
->multiple_definition
)
2717 (info
, h
->root
.root
.string
, h
->root
.u
.def
.section
->owner
,
2718 h
->root
.u
.def
.section
, h
->root
.u
.def
.value
,
2719 output_bfd
, bfd_abs_section_ptr
, val
)))
2723 h
->root
.type
= bfd_link_hash_defined
;
2724 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2725 h
->root
.u
.def
.value
= val
;
2728 if (!xcoff_set_import_path (info
, h
, imppath
, impfile
, impmember
))
2734 /* Export a symbol. */
2737 bfd_xcoff_export_symbol (bfd
*output_bfd
,
2738 struct bfd_link_info
*info
,
2739 struct bfd_link_hash_entry
*harg
)
2741 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2743 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2746 h
->flags
|= XCOFF_EXPORT
;
2748 /* FIXME: I'm not at all sure what syscall is supposed to mean, so
2749 I'm just going to ignore it until somebody explains it. */
2751 /* Make sure we don't garbage collect this symbol. */
2752 if (! xcoff_mark_symbol (info
, h
))
2755 /* If this is a function descriptor, make sure we don't garbage
2756 collect the associated function code. We normally don't have to
2757 worry about this, because the descriptor will be attached to a
2758 section with relocs, but if we are creating the descriptor
2759 ourselves those relocs will not be visible to the mark code. */
2760 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
2762 if (! xcoff_mark_symbol (info
, h
->descriptor
))
2769 /* Count a reloc against a symbol. This is called for relocs
2770 generated by the linker script, typically for global constructors
2774 bfd_xcoff_link_count_reloc (bfd
*output_bfd
,
2775 struct bfd_link_info
*info
,
2778 struct xcoff_link_hash_entry
*h
;
2780 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2783 h
= ((struct xcoff_link_hash_entry
*)
2784 bfd_wrapped_link_hash_lookup (output_bfd
, info
, name
, FALSE
, FALSE
,
2788 (*_bfd_error_handler
) (_("%s: no such symbol"), name
);
2789 bfd_set_error (bfd_error_no_symbols
);
2793 h
->flags
|= XCOFF_REF_REGULAR
| XCOFF_LDREL
;
2794 ++xcoff_hash_table (info
)->ldrel_count
;
2796 /* Mark the symbol to avoid garbage collection. */
2797 if (! xcoff_mark_symbol (info
, h
))
2803 /* This function is called for each symbol to which the linker script
2807 bfd_xcoff_record_link_assignment (bfd
*output_bfd
,
2808 struct bfd_link_info
*info
,
2811 struct xcoff_link_hash_entry
*h
;
2813 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2816 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, TRUE
, TRUE
,
2821 h
->flags
|= XCOFF_DEF_REGULAR
;
2826 /* Add a symbol to the .loader symbols, if necessary. */
2829 xcoff_build_ldsyms (struct xcoff_link_hash_entry
*h
, void * p
)
2831 struct xcoff_loader_info
*ldinfo
= (struct xcoff_loader_info
*) p
;
2834 if (h
->root
.type
== bfd_link_hash_warning
)
2835 h
= (struct xcoff_link_hash_entry
*) h
->root
.u
.i
.link
;
2837 /* __rtinit, this symbol has special handling. */
2838 if (h
->flags
& XCOFF_RTINIT
)
2841 /* If this is a final link, and the symbol was defined as a common
2842 symbol in a regular object file, and there was no definition in
2843 any dynamic object, then the linker will have allocated space for
2844 the symbol in a common section but the XCOFF_DEF_REGULAR flag
2845 will not have been set. */
2846 if (h
->root
.type
== bfd_link_hash_defined
2847 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
2848 && (h
->flags
& XCOFF_REF_REGULAR
) != 0
2849 && (h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
2850 && (bfd_is_abs_section (h
->root
.u
.def
.section
)
2851 || (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0))
2852 h
->flags
|= XCOFF_DEF_REGULAR
;
2854 /* If all defined symbols should be exported, mark them now. We
2855 don't want to export the actual functions, just the function
2857 if (ldinfo
->export_defineds
2858 && (h
->flags
& XCOFF_DEF_REGULAR
) != 0
2859 && h
->root
.root
.string
[0] != '.')
2863 /* We don't export a symbol which is being defined by an object
2864 included from an archive which contains a shared object. The
2865 rationale is that if an archive contains both an unshared and
2866 a shared object, then there must be some reason that the
2867 unshared object is unshared, and we don't want to start
2868 providing a shared version of it. In particular, this solves
2869 a bug involving the _savefNN set of functions. gcc will call
2870 those functions without providing a slot to restore the TOC,
2871 so it is essential that these functions be linked in directly
2872 and not from a shared object, which means that a shared
2873 object which also happens to link them in must not export
2874 them. This is confusing, but I haven't been able to think of
2875 a different approach. Note that the symbols can, of course,
2876 be exported explicitly. */
2878 if ((h
->root
.type
== bfd_link_hash_defined
2879 || h
->root
.type
== bfd_link_hash_defweak
)
2880 && h
->root
.u
.def
.section
->owner
!= NULL
2881 && h
->root
.u
.def
.section
->owner
->my_archive
!= NULL
)
2883 bfd
*arbfd
, *member
;
2885 arbfd
= h
->root
.u
.def
.section
->owner
->my_archive
;
2886 member
= bfd_openr_next_archived_file (arbfd
, NULL
);
2887 while (member
!= NULL
)
2889 if ((member
->flags
& DYNAMIC
) != 0)
2894 member
= bfd_openr_next_archived_file (arbfd
, member
);
2899 h
->flags
|= XCOFF_EXPORT
;
2902 /* We don't want to garbage collect symbols which are not defined in
2903 XCOFF files. This is a convenient place to mark them. */
2904 if (xcoff_hash_table (ldinfo
->info
)->gc
2905 && (h
->flags
& XCOFF_MARK
) == 0
2906 && (h
->root
.type
== bfd_link_hash_defined
2907 || h
->root
.type
== bfd_link_hash_defweak
)
2908 && (h
->root
.u
.def
.section
->owner
== NULL
2909 || (h
->root
.u
.def
.section
->owner
->xvec
2910 != ldinfo
->info
->output_bfd
->xvec
)))
2911 h
->flags
|= XCOFF_MARK
;
2913 /* If this symbol is exported, but not defined, we need to try to
2915 if ((h
->flags
& XCOFF_EXPORT
) != 0
2916 && (h
->flags
& XCOFF_WAS_UNDEFINED
) != 0)
2918 (*_bfd_error_handler
)
2919 (_("warning: attempt to export undefined symbol `%s'"),
2920 h
->root
.root
.string
);
2925 /* If this is still a common symbol, and it wasn't garbage
2926 collected, we need to actually allocate space for it in the .bss
2928 if (h
->root
.type
== bfd_link_hash_common
2929 && (! xcoff_hash_table (ldinfo
->info
)->gc
2930 || (h
->flags
& XCOFF_MARK
) != 0)
2931 && h
->root
.u
.c
.p
->section
->size
== 0)
2933 BFD_ASSERT (bfd_is_com_section (h
->root
.u
.c
.p
->section
));
2934 h
->root
.u
.c
.p
->section
->size
= h
->root
.u
.c
.size
;
2937 /* We need to add a symbol to the .loader section if it is mentioned
2938 in a reloc which we are copying to the .loader section and it was
2939 not defined or common, or if it is the entry point, or if it is
2942 if (((h
->flags
& XCOFF_LDREL
) == 0
2943 || h
->root
.type
== bfd_link_hash_defined
2944 || h
->root
.type
== bfd_link_hash_defweak
2945 || h
->root
.type
== bfd_link_hash_common
)
2946 && (h
->flags
& XCOFF_ENTRY
) == 0
2947 && (h
->flags
& XCOFF_EXPORT
) == 0)
2953 /* We don't need to add this symbol if we did garbage collection and
2954 we did not mark this symbol. */
2955 if (xcoff_hash_table (ldinfo
->info
)->gc
2956 && (h
->flags
& XCOFF_MARK
) == 0)
2962 /* We may have already processed this symbol due to the recursive
2964 if ((h
->flags
& XCOFF_BUILT_LDSYM
) != 0)
2967 /* We need to add this symbol to the .loader symbols. */
2969 BFD_ASSERT (h
->ldsym
== NULL
);
2970 amt
= sizeof (struct internal_ldsym
);
2971 h
->ldsym
= bfd_zalloc (ldinfo
->output_bfd
, amt
);
2972 if (h
->ldsym
== NULL
)
2974 ldinfo
->failed
= TRUE
;
2978 if ((h
->flags
& XCOFF_IMPORT
) != 0)
2979 h
->ldsym
->l_ifile
= h
->ldindx
;
2981 /* The first 3 symbol table indices are reserved to indicate the
2982 data, text and bss sections. */
2983 h
->ldindx
= ldinfo
->ldsym_count
+ 3;
2985 ++ldinfo
->ldsym_count
;
2987 if (! bfd_xcoff_put_ldsymbol_name (ldinfo
->output_bfd
, ldinfo
,
2988 h
->ldsym
, h
->root
.root
.string
))
2991 h
->flags
|= XCOFF_BUILT_LDSYM
;
2995 /* Build the .loader section. This is called by the XCOFF linker
2996 emulation before_allocation routine. We must set the size of the
2997 .loader section before the linker lays out the output file.
2998 LIBPATH is the library path to search for shared objects; this is
2999 normally built from the -L arguments passed to the linker. ENTRY
3000 is the name of the entry point symbol (the -e linker option).
3001 FILE_ALIGN is the alignment to use for sections within the file
3002 (the -H linker option). MAXSTACK is the maximum stack size (the
3003 -bmaxstack linker option). MAXDATA is the maximum data size (the
3004 -bmaxdata linker option). GC is whether to do garbage collection
3005 (the -bgc linker option). MODTYPE is the module type (the
3006 -bmodtype linker option). TEXTRO is whether the text section must
3007 be read only (the -btextro linker option). EXPORT_DEFINEDS is
3008 whether all defined symbols should be exported (the -unix linker
3009 option). SPECIAL_SECTIONS is set by this routine to csects with
3010 magic names like _end. */
3013 bfd_xcoff_size_dynamic_sections (bfd
*output_bfd
,
3014 struct bfd_link_info
*info
,
3015 const char *libpath
,
3017 unsigned long file_align
,
3018 unsigned long maxstack
,
3019 unsigned long maxdata
,
3023 bfd_boolean export_defineds
,
3024 asection
**special_sections
,
3027 struct xcoff_link_hash_entry
*hentry
;
3029 struct xcoff_loader_info ldinfo
;
3031 size_t impsize
, impcount
;
3032 struct xcoff_import_file
*fl
;
3033 struct internal_ldhdr
*ldhdr
;
3034 bfd_size_type stoff
;
3038 struct bfd_strtab_hash
*debug_strtab
;
3039 bfd_byte
*debug_contents
= NULL
;
3042 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
3044 for (i
= 0; i
< XCOFF_NUMBER_OF_SPECIAL_SECTIONS
; i
++)
3045 special_sections
[i
] = NULL
;
3049 ldinfo
.failed
= FALSE
;
3050 ldinfo
.output_bfd
= output_bfd
;
3052 ldinfo
.export_defineds
= export_defineds
;
3053 ldinfo
.ldsym_count
= 0;
3054 ldinfo
.string_size
= 0;
3055 ldinfo
.strings
= NULL
;
3056 ldinfo
.string_alc
= 0;
3058 xcoff_data (output_bfd
)->maxstack
= maxstack
;
3059 xcoff_data (output_bfd
)->maxdata
= maxdata
;
3060 xcoff_data (output_bfd
)->modtype
= modtype
;
3062 xcoff_hash_table (info
)->file_align
= file_align
;
3063 xcoff_hash_table (info
)->textro
= textro
;
3064 xcoff_hash_table (info
)->rtld
= rtld
;
3069 hentry
= xcoff_link_hash_lookup (xcoff_hash_table (info
), entry
,
3070 FALSE
, FALSE
, TRUE
);
3072 hentry
->flags
|= XCOFF_ENTRY
;
3076 if (info
->init_function
|| info
->fini_function
|| rtld
)
3078 struct xcoff_link_hash_entry
*hsym
;
3079 struct internal_ldsym
*ldsym
;
3081 hsym
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
3082 "__rtinit", FALSE
, FALSE
, TRUE
);
3085 (*_bfd_error_handler
)
3086 (_("error: undefined symbol __rtinit"));
3090 xcoff_mark_symbol (info
, hsym
);
3091 hsym
->flags
|= (XCOFF_DEF_REGULAR
| XCOFF_RTINIT
);
3093 /* __rtinit initialized. */
3094 amt
= sizeof (* ldsym
);
3095 ldsym
= bfd_malloc (amt
);
3097 ldsym
->l_value
= 0; /* Will be filled in later. */
3098 ldsym
->l_scnum
= 2; /* Data section. */
3099 ldsym
->l_smtype
= XTY_SD
; /* Csect section definition. */
3100 ldsym
->l_smclas
= 5; /* .rw. */
3101 ldsym
->l_ifile
= 0; /* Special system loader symbol. */
3102 ldsym
->l_parm
= 0; /* NA. */
3104 /* Force __rtinit to be the first symbol in the loader symbol table
3105 See xcoff_build_ldsyms
3107 The first 3 symbol table indices are reserved to indicate the data,
3108 text and bss sections. */
3109 BFD_ASSERT (0 == ldinfo
.ldsym_count
);
3112 ldinfo
.ldsym_count
= 1;
3113 hsym
->ldsym
= ldsym
;
3115 if (! bfd_xcoff_put_ldsymbol_name (ldinfo
.output_bfd
, &ldinfo
,
3116 hsym
->ldsym
, hsym
->root
.root
.string
))
3119 /* This symbol is written out by xcoff_write_global_symbol
3120 Set stuff up so xcoff_write_global_symbol logic works. */
3121 hsym
->flags
|= XCOFF_DEF_REGULAR
| XCOFF_MARK
;
3122 hsym
->root
.type
= bfd_link_hash_defined
;
3123 hsym
->root
.u
.def
.value
= 0;
3126 /* Garbage collect unused sections. */
3127 if (info
->relocatable
3130 || (hentry
->root
.type
!= bfd_link_hash_defined
3131 && hentry
->root
.type
!= bfd_link_hash_defweak
))
3134 xcoff_hash_table (info
)->gc
= FALSE
;
3136 /* We still need to call xcoff_mark, in order to set ldrel_count
3138 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3142 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3144 if ((o
->flags
& SEC_MARK
) == 0)
3146 if (! xcoff_mark (info
, o
))
3154 if (! xcoff_mark (info
, hentry
->root
.u
.def
.section
))
3157 xcoff_hash_table (info
)->gc
= TRUE
;
3160 /* Return special sections to the caller. */
3161 for (i
= 0; i
< XCOFF_NUMBER_OF_SPECIAL_SECTIONS
; i
++)
3163 sec
= xcoff_hash_table (info
)->special_sections
[i
];
3167 && (sec
->flags
& SEC_MARK
) == 0)
3170 special_sections
[i
] = sec
;
3173 if (info
->input_bfds
== NULL
)
3174 /* I'm not sure what to do in this bizarre case. */
3177 xcoff_link_hash_traverse (xcoff_hash_table (info
), xcoff_build_ldsyms
,
3182 /* Work out the size of the import file names. Each import file ID
3183 consists of three null terminated strings: the path, the file
3184 name, and the archive member name. The first entry in the list
3185 of names is the path to use to find objects, which the linker has
3186 passed in as the libpath argument. For some reason, the path
3187 entry in the other import file names appears to always be empty. */
3188 impsize
= strlen (libpath
) + 3;
3190 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
3193 impsize
+= (strlen (fl
->path
)
3195 + strlen (fl
->member
)
3199 /* Set up the .loader section header. */
3200 ldhdr
= &xcoff_hash_table (info
)->ldhdr
;
3201 ldhdr
->l_version
= bfd_xcoff_ldhdr_version(output_bfd
);
3202 ldhdr
->l_nsyms
= ldinfo
.ldsym_count
;
3203 ldhdr
->l_nreloc
= xcoff_hash_table (info
)->ldrel_count
;
3204 ldhdr
->l_istlen
= impsize
;
3205 ldhdr
->l_nimpid
= impcount
;
3206 ldhdr
->l_impoff
= (bfd_xcoff_ldhdrsz(output_bfd
)
3207 + ldhdr
->l_nsyms
* bfd_xcoff_ldsymsz(output_bfd
)
3208 + ldhdr
->l_nreloc
* bfd_xcoff_ldrelsz(output_bfd
));
3209 ldhdr
->l_stlen
= ldinfo
.string_size
;
3210 stoff
= ldhdr
->l_impoff
+ impsize
;
3211 if (ldinfo
.string_size
== 0)
3214 ldhdr
->l_stoff
= stoff
;
3216 /* 64 bit elements to ldhdr
3217 The swap out routine for 32 bit will ignore them.
3218 Nothing fancy, symbols come after the header and relocs come
3220 ldhdr
->l_symoff
= bfd_xcoff_ldhdrsz (output_bfd
);
3221 ldhdr
->l_rldoff
= (bfd_xcoff_ldhdrsz (output_bfd
)
3222 + ldhdr
->l_nsyms
* bfd_xcoff_ldsymsz (output_bfd
));
3224 /* We now know the final size of the .loader section. Allocate
3226 lsec
= xcoff_hash_table (info
)->loader_section
;
3227 lsec
->size
= stoff
+ ldhdr
->l_stlen
;
3228 lsec
->contents
= bfd_zalloc (output_bfd
, lsec
->size
);
3229 if (lsec
->contents
== NULL
)
3232 /* Set up the header. */
3233 bfd_xcoff_swap_ldhdr_out (output_bfd
, ldhdr
, lsec
->contents
);
3235 /* Set up the import file names. */
3236 out
= (char *) lsec
->contents
+ ldhdr
->l_impoff
;
3237 strcpy (out
, libpath
);
3238 out
+= strlen (libpath
) + 1;
3241 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
3246 while ((*out
++ = *s
++) != '\0')
3249 while ((*out
++ = *s
++) != '\0')
3252 while ((*out
++ = *s
++) != '\0')
3256 BFD_ASSERT ((bfd_size_type
) ((bfd_byte
*) out
- lsec
->contents
) == stoff
);
3258 /* Set up the symbol string table. */
3259 if (ldinfo
.string_size
> 0)
3261 memcpy (out
, ldinfo
.strings
, ldinfo
.string_size
);
3262 free (ldinfo
.strings
);
3263 ldinfo
.strings
= NULL
;
3266 /* We can't set up the symbol table or the relocs yet, because we
3267 don't yet know the final position of the various sections. The
3268 .loader symbols are written out when the corresponding normal
3269 symbols are written out in xcoff_link_input_bfd or
3270 xcoff_write_global_symbol. The .loader relocs are written out
3271 when the corresponding normal relocs are handled in
3272 xcoff_link_input_bfd. */
3274 /* Allocate space for the magic sections. */
3275 sec
= xcoff_hash_table (info
)->linkage_section
;
3278 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
3279 if (sec
->contents
== NULL
)
3282 sec
= xcoff_hash_table (info
)->toc_section
;
3285 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
3286 if (sec
->contents
== NULL
)
3289 sec
= xcoff_hash_table (info
)->descriptor_section
;
3292 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
3293 if (sec
->contents
== NULL
)
3297 /* Now that we've done garbage collection, figure out the contents
3298 of the .debug section. */
3299 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
3301 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3304 bfd_size_type symcount
;
3305 unsigned long *debug_index
;
3307 bfd_byte
*esym
, *esymend
;
3308 bfd_size_type symesz
;
3310 if (sub
->xvec
!= info
->output_bfd
->xvec
)
3312 subdeb
= bfd_get_section_by_name (sub
, ".debug");
3313 if (subdeb
== NULL
|| subdeb
->size
== 0)
3316 if (info
->strip
== strip_all
3317 || info
->strip
== strip_debugger
3318 || info
->discard
== discard_all
)
3324 if (! _bfd_coff_get_external_symbols (sub
))
3327 symcount
= obj_raw_syment_count (sub
);
3328 debug_index
= bfd_zalloc (sub
, symcount
* sizeof (unsigned long));
3329 if (debug_index
== NULL
)
3331 xcoff_data (sub
)->debug_indices
= debug_index
;
3333 /* Grab the contents of the .debug section. We use malloc and
3334 copy the names into the debug stringtab, rather than
3335 bfd_alloc, because I expect that, when linking many files
3336 together, many of the strings will be the same. Storing the
3337 strings in the hash table should save space in this case. */
3338 if (! bfd_malloc_and_get_section (sub
, subdeb
, &debug_contents
))
3341 csectpp
= xcoff_data (sub
)->csects
;
3343 /* Dynamic object do not have csectpp's. */
3344 if (NULL
!= csectpp
)
3346 symesz
= bfd_coff_symesz (sub
);
3347 esym
= (bfd_byte
*) obj_coff_external_syms (sub
);
3348 esymend
= esym
+ symcount
* symesz
;
3350 while (esym
< esymend
)
3352 struct internal_syment sym
;
3354 bfd_coff_swap_sym_in (sub
, (void *) esym
, (void *) &sym
);
3356 *debug_index
= (unsigned long) -1;
3358 if (sym
._n
._n_n
._n_zeroes
== 0
3361 || ((*csectpp
)->flags
& SEC_MARK
) != 0
3362 || *csectpp
== bfd_abs_section_ptr
)
3363 && bfd_coff_symname_in_debug (sub
, &sym
))
3368 name
= (char *) debug_contents
+ sym
._n
._n_n
._n_offset
;
3369 indx
= _bfd_stringtab_add (debug_strtab
, name
, TRUE
, TRUE
);
3370 if (indx
== (bfd_size_type
) -1)
3372 *debug_index
= indx
;
3375 esym
+= (sym
.n_numaux
+ 1) * symesz
;
3376 csectpp
+= sym
.n_numaux
+ 1;
3377 debug_index
+= sym
.n_numaux
+ 1;
3381 free (debug_contents
);
3382 debug_contents
= NULL
;
3384 /* Clear the size of subdeb, so that it is not included directly
3385 in the output file. */
3388 if (! info
->keep_memory
)
3390 if (! _bfd_coff_free_symbols (sub
))
3395 if (info
->strip
!= strip_all
)
3396 xcoff_hash_table (info
)->debug_section
->size
=
3397 _bfd_stringtab_size (debug_strtab
);
3402 if (ldinfo
.strings
!= NULL
)
3403 free (ldinfo
.strings
);
3404 if (debug_contents
!= NULL
)
3405 free (debug_contents
);
3410 bfd_xcoff_link_generate_rtinit (bfd
*abfd
,
3415 struct bfd_in_memory
*bim
;
3417 bim
= bfd_malloc ((bfd_size_type
) sizeof (* bim
));
3424 abfd
->link_next
= 0;
3425 abfd
->format
= bfd_object
;
3426 abfd
->iostream
= (void *) bim
;
3427 abfd
->flags
= BFD_IN_MEMORY
;
3428 abfd
->direction
= write_direction
;
3431 if (! bfd_xcoff_generate_rtinit (abfd
, init
, fini
, rtld
))
3434 /* need to reset to unknown or it will not be read back in correctly */
3435 abfd
->format
= bfd_unknown
;
3436 abfd
->direction
= read_direction
;
3442 /* Link an input file into the linker output file. This function
3443 handles all the sections and relocations of the input file at once. */
3446 xcoff_link_input_bfd (struct xcoff_final_link_info
*finfo
,
3450 const char *strings
;
3451 bfd_size_type syment_base
;
3452 unsigned int n_tmask
;
3453 unsigned int n_btshft
;
3454 bfd_boolean copy
, hash
;
3455 bfd_size_type isymesz
;
3456 bfd_size_type osymesz
;
3457 bfd_size_type linesz
;
3460 struct xcoff_link_hash_entry
**sym_hash
;
3461 struct internal_syment
*isymp
;
3463 unsigned long *debug_index
;
3465 unsigned long output_index
;
3469 bfd_boolean keep_syms
;
3472 /* We can just skip DYNAMIC files, unless this is a static link. */
3473 if ((input_bfd
->flags
& DYNAMIC
) != 0
3474 && ! finfo
->info
->static_link
)
3477 /* Move all the symbols to the output file. */
3478 output_bfd
= finfo
->output_bfd
;
3480 syment_base
= obj_raw_syment_count (output_bfd
);
3481 isymesz
= bfd_coff_symesz (input_bfd
);
3482 osymesz
= bfd_coff_symesz (output_bfd
);
3483 linesz
= bfd_coff_linesz (input_bfd
);
3484 BFD_ASSERT (linesz
== bfd_coff_linesz (output_bfd
));
3486 n_tmask
= coff_data (input_bfd
)->local_n_tmask
;
3487 n_btshft
= coff_data (input_bfd
)->local_n_btshft
;
3489 /* Define macros so that ISFCN, et. al., macros work correctly. */
3490 #define N_TMASK n_tmask
3491 #define N_BTSHFT n_btshft
3494 if (! finfo
->info
->keep_memory
)
3497 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
3500 if (! _bfd_coff_get_external_symbols (input_bfd
))
3503 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
3504 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
3505 sym_hash
= obj_xcoff_sym_hashes (input_bfd
);
3506 csectpp
= xcoff_data (input_bfd
)->csects
;
3507 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
3508 isymp
= finfo
->internal_syms
;
3509 indexp
= finfo
->sym_indices
;
3510 output_index
= syment_base
;
3511 outsym
= finfo
->outsyms
;
3515 while (esym
< esym_end
)
3517 struct internal_syment isym
;
3518 union internal_auxent aux
;
3521 bfd_boolean require
;
3524 bfd_coff_swap_sym_in (input_bfd
, (void *) esym
, (void *) isymp
);
3526 /* If this is a C_EXT or C_HIDEXT symbol, we need the csect
3528 if (isymp
->n_sclass
== C_EXT
|| isymp
->n_sclass
== C_HIDEXT
)
3530 BFD_ASSERT (isymp
->n_numaux
> 0);
3531 bfd_coff_swap_aux_in (input_bfd
,
3532 (void *) (esym
+ isymesz
* isymp
->n_numaux
),
3533 isymp
->n_type
, isymp
->n_sclass
,
3534 isymp
->n_numaux
- 1, isymp
->n_numaux
,
3537 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
3540 /* Make a copy of *isymp so that the relocate_section function
3541 always sees the original values. This is more reliable than
3542 always recomputing the symbol value even if we are stripping
3546 /* If this symbol is in the .loader section, swap out the
3547 .loader symbol information. If this is an external symbol
3548 reference to a defined symbol, though, then wait until we get
3549 to the definition. */
3550 if (isym
.n_sclass
== C_EXT
3551 && *sym_hash
!= NULL
3552 && (*sym_hash
)->ldsym
!= NULL
3554 || (*sym_hash
)->root
.type
== bfd_link_hash_undefined
))
3556 struct xcoff_link_hash_entry
*h
;
3557 struct internal_ldsym
*ldsym
;
3561 if (isym
.n_scnum
> 0)
3563 ldsym
->l_scnum
= (*csectpp
)->output_section
->target_index
;
3564 ldsym
->l_value
= (isym
.n_value
3565 + (*csectpp
)->output_section
->vma
3566 + (*csectpp
)->output_offset
3571 ldsym
->l_scnum
= isym
.n_scnum
;
3572 ldsym
->l_value
= isym
.n_value
;
3575 ldsym
->l_smtype
= smtyp
;
3576 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
3577 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
3578 || (h
->flags
& XCOFF_IMPORT
) != 0)
3579 ldsym
->l_smtype
|= L_IMPORT
;
3580 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
3581 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
3582 || (h
->flags
& XCOFF_EXPORT
) != 0)
3583 ldsym
->l_smtype
|= L_EXPORT
;
3584 if ((h
->flags
& XCOFF_ENTRY
) != 0)
3585 ldsym
->l_smtype
|= L_ENTRY
;
3587 ldsym
->l_smclas
= aux
.x_csect
.x_smclas
;
3589 if (ldsym
->l_ifile
== (bfd_size_type
) -1)
3591 else if (ldsym
->l_ifile
== 0)
3593 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
3599 if (h
->root
.type
== bfd_link_hash_defined
3600 || h
->root
.type
== bfd_link_hash_defweak
)
3601 impbfd
= h
->root
.u
.def
.section
->owner
;
3602 else if (h
->root
.type
== bfd_link_hash_undefined
3603 || h
->root
.type
== bfd_link_hash_undefweak
)
3604 impbfd
= h
->root
.u
.undef
.abfd
;
3612 BFD_ASSERT (impbfd
->xvec
== finfo
->output_bfd
->xvec
);
3613 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
3620 BFD_ASSERT (h
->ldindx
>= 0);
3621 bfd_xcoff_swap_ldsym_out (finfo
->output_bfd
, ldsym
,
3624 * bfd_xcoff_ldsymsz (finfo
->output_bfd
))));
3627 /* Fill in snentry now that we know the target_index. */
3628 if ((h
->flags
& XCOFF_ENTRY
) != 0
3629 && (h
->root
.type
== bfd_link_hash_defined
3630 || h
->root
.type
== bfd_link_hash_defweak
))
3632 xcoff_data (output_bfd
)->snentry
=
3633 h
->root
.u
.def
.section
->output_section
->target_index
;
3641 add
= 1 + isym
.n_numaux
;
3643 /* If we are skipping this csect, we want to skip this symbol. */
3644 if (*csectpp
== NULL
)
3647 /* If we garbage collected this csect, we want to skip this
3650 && xcoff_hash_table (finfo
->info
)->gc
3651 && ((*csectpp
)->flags
& SEC_MARK
) == 0
3652 && *csectpp
!= bfd_abs_section_ptr
)
3655 /* An XCOFF linker always skips C_STAT symbols. */
3657 && isymp
->n_sclass
== C_STAT
)
3660 /* We skip all but the first TOC anchor. */
3662 && isymp
->n_sclass
== C_HIDEXT
3663 && aux
.x_csect
.x_smclas
== XMC_TC0
)
3665 if (finfo
->toc_symindx
!= -1)
3669 bfd_vma tocval
, tocend
;
3672 tocval
= ((*csectpp
)->output_section
->vma
3673 + (*csectpp
)->output_offset
3677 /* We want to find out if tocval is a good value to use
3678 as the TOC anchor--that is, whether we can access all
3679 of the TOC using a 16 bit offset from tocval. This
3680 test assumes that the TOC comes at the end of the
3681 output section, as it does in the default linker
3683 tocend
= ((*csectpp
)->output_section
->vma
3684 + (*csectpp
)->output_section
->size
);
3685 for (inp
= finfo
->info
->input_bfds
;
3687 inp
= inp
->link_next
)
3690 for (o
= inp
->sections
; o
!= NULL
; o
= o
->next
)
3691 if (strcmp (o
->name
, ".tocbss") == 0)
3693 bfd_vma new_toc_end
;
3694 new_toc_end
= (o
->output_section
->vma
3697 if (new_toc_end
> tocend
)
3698 tocend
= new_toc_end
;
3703 if (tocval
+ 0x10000 < tocend
)
3705 (*_bfd_error_handler
)
3706 (_("TOC overflow: 0x%lx > 0x10000; try -mminimal-toc when compiling"),
3707 (unsigned long) (tocend
- tocval
));
3708 bfd_set_error (bfd_error_file_too_big
);
3712 if (tocval
+ 0x8000 < tocend
)
3716 tocadd
= tocend
- (tocval
+ 0x8000);
3718 isym
.n_value
+= tocadd
;
3721 finfo
->toc_symindx
= output_index
;
3722 xcoff_data (finfo
->output_bfd
)->toc
= tocval
;
3723 xcoff_data (finfo
->output_bfd
)->sntoc
=
3724 (*csectpp
)->output_section
->target_index
;
3730 /* If we are stripping all symbols, we want to skip this one. */
3732 && finfo
->info
->strip
== strip_all
)
3735 /* We can skip resolved external references. */
3737 && isym
.n_sclass
== C_EXT
3739 && (*sym_hash
)->root
.type
!= bfd_link_hash_undefined
)
3742 /* We can skip common symbols if they got defined somewhere
3745 && isym
.n_sclass
== C_EXT
3747 && ((*sym_hash
)->root
.type
!= bfd_link_hash_common
3748 || (*sym_hash
)->root
.u
.c
.p
->section
!= *csectpp
)
3749 && ((*sym_hash
)->root
.type
!= bfd_link_hash_defined
3750 || (*sym_hash
)->root
.u
.def
.section
!= *csectpp
))
3753 /* Skip local symbols if we are discarding them. */
3755 && finfo
->info
->discard
== discard_all
3756 && isym
.n_sclass
!= C_EXT
3757 && (isym
.n_sclass
!= C_HIDEXT
3758 || smtyp
!= XTY_SD
))
3761 /* If we stripping debugging symbols, and this is a debugging
3762 symbol, then skip it. */
3764 && finfo
->info
->strip
== strip_debugger
3765 && isym
.n_scnum
== N_DEBUG
)
3768 /* If some symbols are stripped based on the name, work out the
3769 name and decide whether to skip this symbol. We don't handle
3770 this correctly for symbols whose names are in the .debug
3771 section; to get it right we would need a new bfd_strtab_hash
3772 function to return the string given the index. */
3774 && (finfo
->info
->strip
== strip_some
3775 || finfo
->info
->discard
== discard_l
)
3776 && (debug_index
== NULL
|| *debug_index
== (unsigned long) -1))
3779 char buf
[SYMNMLEN
+ 1];
3781 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, buf
);
3786 if ((finfo
->info
->strip
== strip_some
3787 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, FALSE
,
3789 || (finfo
->info
->discard
== discard_l
3790 && (isym
.n_sclass
!= C_EXT
3791 && (isym
.n_sclass
!= C_HIDEXT
3792 || smtyp
!= XTY_SD
))
3793 && bfd_is_local_label_name (input_bfd
, name
)))
3797 /* We can not skip the first TOC anchor. */
3800 && finfo
->info
->strip
!= strip_all
)
3803 /* We now know whether we are to skip this symbol or not. */
3806 /* Adjust the symbol in order to output it. */
3808 if (isym
._n
._n_n
._n_zeroes
== 0
3809 && isym
._n
._n_n
._n_offset
!= 0)
3811 /* This symbol has a long name. Enter it in the string
3812 table we are building. If *debug_index != -1, the
3813 name has already been entered in the .debug section. */
3814 if (debug_index
!= NULL
&& *debug_index
!= (unsigned long) -1)
3815 isym
._n
._n_n
._n_offset
= *debug_index
;
3821 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, NULL
);
3825 indx
= _bfd_stringtab_add (finfo
->strtab
, name
, hash
, copy
);
3826 if (indx
== (bfd_size_type
) -1)
3828 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
3832 if (isym
.n_sclass
!= C_BSTAT
3833 && isym
.n_sclass
!= C_ESTAT
3834 && isym
.n_sclass
!= C_DECL
3835 && isym
.n_scnum
> 0)
3837 isym
.n_scnum
= (*csectpp
)->output_section
->target_index
;
3838 isym
.n_value
+= ((*csectpp
)->output_section
->vma
3839 + (*csectpp
)->output_offset
3843 /* The value of a C_FILE symbol is the symbol index of the
3844 next C_FILE symbol. The value of the last C_FILE symbol
3845 is -1. We try to get this right, below, just before we
3846 write the symbols out, but in the general case we may
3847 have to write the symbol out twice. */
3848 if (isym
.n_sclass
== C_FILE
)
3850 if (finfo
->last_file_index
!= -1
3851 && finfo
->last_file
.n_value
!= (bfd_vma
) output_index
)
3853 /* We must correct the value of the last C_FILE entry. */
3854 finfo
->last_file
.n_value
= output_index
;
3855 if ((bfd_size_type
) finfo
->last_file_index
>= syment_base
)
3857 /* The last C_FILE symbol is in this input file. */
3858 bfd_coff_swap_sym_out (output_bfd
,
3859 (void *) &finfo
->last_file
,
3860 (void *) (finfo
->outsyms
3861 + ((finfo
->last_file_index
3867 /* We have already written out the last C_FILE
3868 symbol. We need to write it out again. We
3869 borrow *outsym temporarily. */
3872 bfd_coff_swap_sym_out (output_bfd
,
3873 (void *) &finfo
->last_file
,
3876 pos
= obj_sym_filepos (output_bfd
);
3877 pos
+= finfo
->last_file_index
* osymesz
;
3878 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
3879 || (bfd_bwrite (outsym
, osymesz
, output_bfd
)
3885 finfo
->last_file_index
= output_index
;
3886 finfo
->last_file
= isym
;
3889 /* The value of a C_BINCL or C_EINCL symbol is a file offset
3890 into the line numbers. We update the symbol values when
3891 we handle the line numbers. */
3892 if (isym
.n_sclass
== C_BINCL
3893 || isym
.n_sclass
== C_EINCL
)
3895 isym
.n_value
= finfo
->line_filepos
;
3899 /* Output the symbol. */
3901 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
3903 *indexp
= output_index
;
3905 if (isym
.n_sclass
== C_EXT
)
3908 struct xcoff_link_hash_entry
*h
;
3910 indx
= ((esym
- (bfd_byte
*) obj_coff_external_syms (input_bfd
))
3912 h
= obj_xcoff_sym_hashes (input_bfd
)[indx
];
3913 BFD_ASSERT (h
!= NULL
);
3914 h
->indx
= output_index
;
3917 /* If this is a symbol in the TOC which we may have merged
3918 (class XMC_TC), remember the symbol index of the TOC
3920 if (isym
.n_sclass
== C_HIDEXT
3921 && aux
.x_csect
.x_smclas
== XMC_TC
3922 && *sym_hash
!= NULL
)
3924 BFD_ASSERT (((*sym_hash
)->flags
& XCOFF_SET_TOC
) == 0);
3925 BFD_ASSERT ((*sym_hash
)->toc_section
!= NULL
);
3926 (*sym_hash
)->u
.toc_indx
= output_index
;
3929 output_index
+= add
;
3930 outsym
+= add
* osymesz
;
3933 esym
+= add
* isymesz
;
3937 if (debug_index
!= NULL
)
3940 for (--add
; add
> 0; --add
)
3944 /* Fix up the aux entries and the C_BSTAT symbols. This must be
3945 done in a separate pass, because we don't know the correct symbol
3946 indices until we have already decided which symbols we are going
3949 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
3950 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
3951 isymp
= finfo
->internal_syms
;
3952 indexp
= finfo
->sym_indices
;
3953 csectpp
= xcoff_data (input_bfd
)->csects
;
3954 outsym
= finfo
->outsyms
;
3955 while (esym
< esym_end
)
3959 add
= 1 + isymp
->n_numaux
;
3962 esym
+= add
* isymesz
;
3967 if (isymp
->n_sclass
== C_BSTAT
)
3969 struct internal_syment isym
;
3973 /* The value of a C_BSTAT symbol is the symbol table
3974 index of the containing csect. */
3975 bfd_coff_swap_sym_in (output_bfd
, (void *) outsym
, (void *) &isym
);
3976 indx
= isym
.n_value
;
3977 if (indx
< obj_raw_syment_count (input_bfd
))
3981 symindx
= finfo
->sym_indices
[indx
];
3985 isym
.n_value
= symindx
;
3986 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
,
3994 for (i
= 0; i
< isymp
->n_numaux
&& esym
< esym_end
; i
++)
3996 union internal_auxent aux
;
3998 bfd_coff_swap_aux_in (input_bfd
, (void *) esym
, isymp
->n_type
,
3999 isymp
->n_sclass
, i
, isymp
->n_numaux
,
4002 if (isymp
->n_sclass
== C_FILE
)
4004 /* This is the file name (or some comment put in by
4005 the compiler). If it is long, we must put it in
4006 the string table. */
4007 if (aux
.x_file
.x_n
.x_zeroes
== 0
4008 && aux
.x_file
.x_n
.x_offset
!= 0)
4010 const char *filename
;
4013 BFD_ASSERT (aux
.x_file
.x_n
.x_offset
4014 >= STRING_SIZE_SIZE
);
4015 if (strings
== NULL
)
4017 strings
= _bfd_coff_read_string_table (input_bfd
);
4018 if (strings
== NULL
)
4021 filename
= strings
+ aux
.x_file
.x_n
.x_offset
;
4022 indx
= _bfd_stringtab_add (finfo
->strtab
, filename
,
4024 if (indx
== (bfd_size_type
) -1)
4026 aux
.x_file
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
4029 else if ((isymp
->n_sclass
== C_EXT
4030 || isymp
->n_sclass
== C_HIDEXT
)
4031 && i
+ 1 == isymp
->n_numaux
)
4034 /* We don't support type checking. I don't know if
4036 aux
.x_csect
.x_parmhash
= 0;
4037 /* I don't think anybody uses these fields, but we'd
4038 better clobber them just in case. */
4039 aux
.x_csect
.x_stab
= 0;
4040 aux
.x_csect
.x_snstab
= 0;
4042 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_LD
)
4046 indx
= aux
.x_csect
.x_scnlen
.l
;
4047 if (indx
< obj_raw_syment_count (input_bfd
))
4051 symindx
= finfo
->sym_indices
[indx
];
4054 aux
.x_csect
.x_scnlen
.l
= 0;
4058 aux
.x_csect
.x_scnlen
.l
= symindx
;
4063 else if (isymp
->n_sclass
!= C_STAT
|| isymp
->n_type
!= T_NULL
)
4067 if (ISFCN (isymp
->n_type
)
4068 || ISTAG (isymp
->n_sclass
)
4069 || isymp
->n_sclass
== C_BLOCK
4070 || isymp
->n_sclass
== C_FCN
)
4072 indx
= aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
4074 && indx
< obj_raw_syment_count (input_bfd
))
4076 /* We look forward through the symbol for
4077 the index of the next symbol we are going
4078 to include. I don't know if this is
4080 while (finfo
->sym_indices
[indx
] < 0
4081 && indx
< obj_raw_syment_count (input_bfd
))
4083 if (indx
>= obj_raw_syment_count (input_bfd
))
4084 indx
= output_index
;
4086 indx
= finfo
->sym_indices
[indx
];
4087 aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= indx
;
4092 indx
= aux
.x_sym
.x_tagndx
.l
;
4093 if (indx
> 0 && indx
< obj_raw_syment_count (input_bfd
))
4097 symindx
= finfo
->sym_indices
[indx
];
4099 aux
.x_sym
.x_tagndx
.l
= 0;
4101 aux
.x_sym
.x_tagndx
.l
= symindx
;
4106 /* Copy over the line numbers, unless we are stripping
4107 them. We do this on a symbol by symbol basis in
4108 order to more easily handle garbage collection. */
4109 if ((isymp
->n_sclass
== C_EXT
4110 || isymp
->n_sclass
== C_HIDEXT
)
4112 && isymp
->n_numaux
> 1
4113 && ISFCN (isymp
->n_type
)
4114 && aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
4116 if (finfo
->info
->strip
!= strip_none
4117 && finfo
->info
->strip
!= strip_some
)
4118 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
4121 asection
*enclosing
;
4122 unsigned int enc_count
;
4123 bfd_signed_vma linoff
;
4124 struct internal_lineno lin
;
4127 enclosing
= xcoff_section_data (abfd
, o
)->enclosing
;
4128 enc_count
= xcoff_section_data (abfd
, o
)->lineno_count
;
4129 if (oline
!= enclosing
)
4131 file_ptr pos
= enclosing
->line_filepos
;
4132 bfd_size_type amt
= linesz
* enc_count
;
4133 if (bfd_seek (input_bfd
, pos
, SEEK_SET
) != 0
4134 || (bfd_bread (finfo
->linenos
, amt
, input_bfd
)
4140 linoff
= (aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
4141 - enclosing
->line_filepos
);
4143 bfd_coff_swap_lineno_in (input_bfd
,
4144 (void *) (finfo
->linenos
+ linoff
),
4147 || ((bfd_size_type
) lin
.l_addr
.l_symndx
4151 obj_coff_external_syms (input_bfd
)))
4153 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
4156 bfd_byte
*linpend
, *linp
;
4158 bfd_size_type count
;
4160 lin
.l_addr
.l_symndx
= *indexp
;
4161 bfd_coff_swap_lineno_out (output_bfd
, (void *) &lin
,
4162 (void *) (finfo
->linenos
4165 linpend
= (finfo
->linenos
4166 + enc_count
* linesz
);
4167 offset
= (o
->output_section
->vma
4170 for (linp
= finfo
->linenos
+ linoff
+ linesz
;
4174 bfd_coff_swap_lineno_in (input_bfd
, (void *) linp
,
4176 if (lin
.l_lnno
== 0)
4178 lin
.l_addr
.l_paddr
+= offset
;
4179 bfd_coff_swap_lineno_out (output_bfd
,
4184 count
= (linp
- (finfo
->linenos
+ linoff
)) / linesz
;
4186 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
4187 (o
->output_section
->line_filepos
4188 + o
->output_section
->lineno_count
* linesz
);
4190 if (bfd_seek (output_bfd
,
4191 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
,
4193 || (bfd_bwrite (finfo
->linenos
+ linoff
,
4194 linesz
* count
, output_bfd
)
4198 o
->output_section
->lineno_count
+= count
;
4202 struct internal_syment
*iisp
, *iispend
;
4207 /* Update any C_BINCL or C_EINCL symbols
4208 that refer to a line number in the
4209 range we just output. */
4210 iisp
= finfo
->internal_syms
;
4212 + obj_raw_syment_count (input_bfd
));
4213 iindp
= finfo
->sym_indices
;
4214 oos
= finfo
->outsyms
;
4215 while (iisp
< iispend
)
4218 && (iisp
->n_sclass
== C_BINCL
4219 || iisp
->n_sclass
== C_EINCL
)
4220 && ((bfd_size_type
) iisp
->n_value
4221 >= (bfd_size_type
)(enclosing
->line_filepos
+ linoff
))
4222 && ((bfd_size_type
) iisp
->n_value
4223 < (enclosing
->line_filepos
4224 + enc_count
* linesz
)))
4226 struct internal_syment iis
;
4228 bfd_coff_swap_sym_in (output_bfd
,
4233 - enclosing
->line_filepos
4235 + aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
);
4236 bfd_coff_swap_sym_out (output_bfd
,
4242 iiadd
= 1 + iisp
->n_numaux
;
4244 oos
+= iiadd
* osymesz
;
4253 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, isymp
->n_type
,
4254 isymp
->n_sclass
, i
, isymp
->n_numaux
,
4266 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
4267 symbol will be the first symbol in the next input file. In the
4268 normal case, this will save us from writing out the C_FILE symbol
4270 if (finfo
->last_file_index
!= -1
4271 && (bfd_size_type
) finfo
->last_file_index
>= syment_base
)
4273 finfo
->last_file
.n_value
= output_index
;
4274 bfd_coff_swap_sym_out (output_bfd
, (void *) &finfo
->last_file
,
4275 (void *) (finfo
->outsyms
4276 + ((finfo
->last_file_index
- syment_base
)
4280 /* Write the modified symbols to the output file. */
4281 if (outsym
> finfo
->outsyms
)
4283 file_ptr pos
= obj_sym_filepos (output_bfd
) + syment_base
* osymesz
;
4284 bfd_size_type amt
= outsym
- finfo
->outsyms
;
4285 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4286 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
4289 BFD_ASSERT ((obj_raw_syment_count (output_bfd
)
4290 + (outsym
- finfo
->outsyms
) / osymesz
)
4293 obj_raw_syment_count (output_bfd
) = output_index
;
4296 /* Don't let the linker relocation routines discard the symbols. */
4297 keep_syms
= obj_coff_keep_syms (input_bfd
);
4298 obj_coff_keep_syms (input_bfd
) = TRUE
;
4300 /* Relocate the contents of each section. */
4301 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4305 if (! o
->linker_mark
)
4306 /* This section was omitted from the link. */
4309 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
4311 || (o
->flags
& SEC_IN_MEMORY
) != 0)
4314 /* We have set filepos correctly for the sections we created to
4315 represent csects, so bfd_get_section_contents should work. */
4316 if (coff_section_data (input_bfd
, o
) != NULL
4317 && coff_section_data (input_bfd
, o
)->contents
!= NULL
)
4318 contents
= coff_section_data (input_bfd
, o
)->contents
;
4321 bfd_size_type sz
= o
->rawsize
? o
->rawsize
: o
->size
;
4322 if (!bfd_get_section_contents (input_bfd
, o
, finfo
->contents
, 0, sz
))
4324 contents
= finfo
->contents
;
4327 if ((o
->flags
& SEC_RELOC
) != 0)
4330 struct internal_reloc
*internal_relocs
;
4331 struct internal_reloc
*irel
;
4333 struct internal_reloc
*irelend
;
4334 struct xcoff_link_hash_entry
**rel_hash
;
4337 /* Read in the relocs. */
4338 target_index
= o
->output_section
->target_index
;
4339 internal_relocs
= (xcoff_read_internal_relocs
4340 (input_bfd
, o
, FALSE
, finfo
->external_relocs
,
4342 (finfo
->section_info
[target_index
].relocs
4343 + o
->output_section
->reloc_count
)));
4344 if (internal_relocs
== NULL
)
4347 /* Call processor specific code to relocate the section
4349 if (! bfd_coff_relocate_section (output_bfd
, finfo
->info
,
4353 finfo
->internal_syms
,
4354 xcoff_data (input_bfd
)->csects
))
4357 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
4358 irel
= internal_relocs
;
4359 irelend
= irel
+ o
->reloc_count
;
4360 rel_hash
= (finfo
->section_info
[target_index
].rel_hashes
4361 + o
->output_section
->reloc_count
);
4362 for (; irel
< irelend
; irel
++, rel_hash
++)
4364 struct xcoff_link_hash_entry
*h
= NULL
;
4365 struct internal_ldrel ldrel
;
4369 /* Adjust the reloc address and symbol index. */
4371 irel
->r_vaddr
+= offset
;
4373 r_symndx
= irel
->r_symndx
;
4378 h
= obj_xcoff_sym_hashes (input_bfd
)[r_symndx
];
4380 if (r_symndx
!= -1 && finfo
->info
->strip
!= strip_all
)
4383 && h
->smclas
!= XMC_TD
4384 && (irel
->r_type
== R_TOC
4385 || irel
->r_type
== R_GL
4386 || irel
->r_type
== R_TCL
4387 || irel
->r_type
== R_TRL
4388 || irel
->r_type
== R_TRLA
))
4390 /* This is a TOC relative reloc with a symbol
4391 attached. The symbol should be the one which
4392 this reloc is for. We want to make this
4393 reloc against the TOC address of the symbol,
4394 not the symbol itself. */
4395 BFD_ASSERT (h
->toc_section
!= NULL
);
4396 BFD_ASSERT ((h
->flags
& XCOFF_SET_TOC
) == 0);
4397 if (h
->u
.toc_indx
!= -1)
4398 irel
->r_symndx
= h
->u
.toc_indx
;
4401 struct xcoff_toc_rel_hash
*n
;
4402 struct xcoff_link_section_info
*si
;
4406 n
= bfd_alloc (finfo
->output_bfd
, amt
);
4409 si
= finfo
->section_info
+ target_index
;
4410 n
->next
= si
->toc_rel_hashes
;
4413 si
->toc_rel_hashes
= n
;
4418 /* This is a global symbol. */
4420 irel
->r_symndx
= h
->indx
;
4423 /* This symbol is being written at the end
4424 of the file, and we do not yet know the
4425 symbol index. We save the pointer to the
4426 hash table entry in the rel_hash list.
4427 We set the indx field to -2 to indicate
4428 that this symbol must not be stripped. */
4437 indx
= finfo
->sym_indices
[r_symndx
];
4441 struct internal_syment
*is
;
4443 /* Relocations against a TC0 TOC anchor are
4444 automatically transformed to be against
4445 the TOC anchor in the output file. */
4446 is
= finfo
->internal_syms
+ r_symndx
;
4447 if (is
->n_sclass
== C_HIDEXT
4448 && is
->n_numaux
> 0)
4451 union internal_auxent aux
;
4455 obj_coff_external_syms (input_bfd
))
4456 + ((r_symndx
+ is
->n_numaux
)
4458 bfd_coff_swap_aux_in (input_bfd
, auxptr
,
4459 is
->n_type
, is
->n_sclass
,
4463 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_SD
4464 && aux
.x_csect
.x_smclas
== XMC_TC0
)
4465 indx
= finfo
->toc_symindx
;
4470 irel
->r_symndx
= indx
;
4474 struct internal_syment
*is
;
4477 char buf
[SYMNMLEN
+ 1];
4479 /* This reloc is against a symbol we are
4480 stripping. It would be possible to handle
4481 this case, but I don't think it's worth it. */
4482 is
= finfo
->internal_syms
+ r_symndx
;
4484 name
= (_bfd_coff_internal_syment_name
4485 (input_bfd
, is
, buf
));
4490 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
4491 (finfo
->info
, name
, input_bfd
, o
,
4498 switch (irel
->r_type
)
4502 || h
->root
.type
== bfd_link_hash_defined
4503 || h
->root
.type
== bfd_link_hash_defweak
4504 || h
->root
.type
== bfd_link_hash_common
)
4512 && (h
->root
.type
== bfd_link_hash_defined
4513 || h
->root
.type
== bfd_link_hash_defweak
)
4514 && bfd_is_abs_section (h
->root
.u
.def
.section
))
4516 /* This reloc needs to be copied into the .loader
4518 ldrel
.l_vaddr
= irel
->r_vaddr
;
4520 ldrel
.l_symndx
= -(bfd_size_type
) 1;
4522 || (h
->root
.type
== bfd_link_hash_defined
4523 || h
->root
.type
== bfd_link_hash_defweak
4524 || h
->root
.type
== bfd_link_hash_common
))
4529 sec
= xcoff_data (input_bfd
)->csects
[r_symndx
];
4530 else if (h
->root
.type
== bfd_link_hash_common
)
4531 sec
= h
->root
.u
.c
.p
->section
;
4533 sec
= h
->root
.u
.def
.section
;
4534 sec
= sec
->output_section
;
4536 if (strcmp (sec
->name
, ".text") == 0)
4538 else if (strcmp (sec
->name
, ".data") == 0)
4540 else if (strcmp (sec
->name
, ".bss") == 0)
4544 (*_bfd_error_handler
)
4545 (_("%B: loader reloc in unrecognized section `%A'"),
4547 bfd_set_error (bfd_error_nonrepresentable_section
);
4555 (*_bfd_error_handler
)
4556 (_("%B: `%s' in loader reloc but not loader sym"),
4558 h
->root
.root
.string
);
4559 bfd_set_error (bfd_error_bad_value
);
4562 ldrel
.l_symndx
= h
->ldindx
;
4564 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
4565 ldrel
.l_rsecnm
= o
->output_section
->target_index
;
4566 if (xcoff_hash_table (finfo
->info
)->textro
4567 && strcmp (o
->output_section
->name
, ".text") == 0)
4569 (*_bfd_error_handler
)
4570 (_("%B: loader reloc in read-only section %A"),
4571 input_bfd
, o
->output_section
);
4572 bfd_set_error (bfd_error_invalid_operation
);
4575 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
,
4578 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
4586 /* We should never need a .loader reloc for a TOC
4592 o
->output_section
->reloc_count
+= o
->reloc_count
;
4595 /* Write out the modified section contents. */
4596 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
4597 contents
, (file_ptr
) o
->output_offset
,
4602 obj_coff_keep_syms (input_bfd
) = keep_syms
;
4604 if (! finfo
->info
->keep_memory
)
4606 if (! _bfd_coff_free_symbols (input_bfd
))
4616 /* Sort relocs by VMA. This is called via qsort. */
4619 xcoff_sort_relocs (const void * p1
, const void * p2
)
4621 const struct internal_reloc
*r1
= (const struct internal_reloc
*) p1
;
4622 const struct internal_reloc
*r2
= (const struct internal_reloc
*) p2
;
4624 if (r1
->r_vaddr
> r2
->r_vaddr
)
4626 else if (r1
->r_vaddr
< r2
->r_vaddr
)
4632 /* Write out a non-XCOFF global symbol. */
4635 xcoff_write_global_symbol (struct xcoff_link_hash_entry
*h
, void * inf
)
4637 struct xcoff_final_link_info
*finfo
= (struct xcoff_final_link_info
*) inf
;
4640 struct internal_syment isym
;
4641 union internal_auxent aux
;
4646 output_bfd
= finfo
->output_bfd
;
4647 outsym
= finfo
->outsyms
;
4649 if (h
->root
.type
== bfd_link_hash_warning
)
4651 h
= (struct xcoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4652 if (h
->root
.type
== bfd_link_hash_new
)
4656 /* If this symbol was garbage collected, just skip it. */
4657 if (xcoff_hash_table (finfo
->info
)->gc
4658 && (h
->flags
& XCOFF_MARK
) == 0)
4661 /* If we need a .loader section entry, write it out. */
4662 if (h
->ldsym
!= NULL
)
4664 struct internal_ldsym
*ldsym
;
4669 if (h
->root
.type
== bfd_link_hash_undefined
4670 || h
->root
.type
== bfd_link_hash_undefweak
)
4674 ldsym
->l_scnum
= N_UNDEF
;
4675 ldsym
->l_smtype
= XTY_ER
;
4676 impbfd
= h
->root
.u
.undef
.abfd
;
4679 else if (h
->root
.type
== bfd_link_hash_defined
4680 || h
->root
.type
== bfd_link_hash_defweak
)
4684 sec
= h
->root
.u
.def
.section
;
4685 ldsym
->l_value
= (sec
->output_section
->vma
4686 + sec
->output_offset
4687 + h
->root
.u
.def
.value
);
4688 ldsym
->l_scnum
= sec
->output_section
->target_index
;
4689 ldsym
->l_smtype
= XTY_SD
;
4690 impbfd
= sec
->owner
;
4696 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
4697 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4698 || (h
->flags
& XCOFF_IMPORT
) != 0)
4700 Import symbols are defined so the check above will make
4701 the l_smtype XTY_SD. But this is not correct, it should
4703 ldsym
->l_smtype
|= L_IMPORT
;
4705 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
4706 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4707 || (h
->flags
& XCOFF_EXPORT
) != 0)
4708 ldsym
->l_smtype
|= L_EXPORT
;
4710 if ((h
->flags
& XCOFF_ENTRY
) != 0)
4711 ldsym
->l_smtype
|= L_ENTRY
;
4713 if ((h
->flags
& XCOFF_RTINIT
) != 0)
4714 ldsym
->l_smtype
= XTY_SD
;
4716 ldsym
->l_smclas
= h
->smclas
;
4718 if (ldsym
->l_smtype
& L_IMPORT
)
4720 if ((h
->root
.type
== bfd_link_hash_defined
4721 || h
->root
.type
== bfd_link_hash_defweak
)
4722 && (h
->root
.u
.def
.value
!= 0))
4723 ldsym
->l_smclas
= XMC_XO
;
4725 else if ((h
->flags
& (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
)) ==
4726 (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
))
4727 ldsym
->l_smclas
= XMC_SV3264
;
4729 else if (h
->flags
& XCOFF_SYSCALL32
)
4730 ldsym
->l_smclas
= XMC_SV
;
4732 else if (h
->flags
& XCOFF_SYSCALL64
)
4733 ldsym
->l_smclas
= XMC_SV64
;
4736 if (ldsym
->l_ifile
== -(bfd_size_type
) 1)
4740 else if (ldsym
->l_ifile
== 0)
4742 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
4744 else if (impbfd
== NULL
)
4748 BFD_ASSERT (impbfd
->xvec
== output_bfd
->xvec
);
4749 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
4755 BFD_ASSERT (h
->ldindx
>= 0);
4757 bfd_xcoff_swap_ldsym_out (output_bfd
, ldsym
,
4760 * bfd_xcoff_ldsymsz(finfo
->output_bfd
)));
4764 /* If this symbol needs global linkage code, write it out. */
4765 if (h
->root
.type
== bfd_link_hash_defined
4766 && (h
->root
.u
.def
.section
4767 == xcoff_hash_table (finfo
->info
)->linkage_section
))
4773 p
= h
->root
.u
.def
.section
->contents
+ h
->root
.u
.def
.value
;
4775 /* The first instruction in the global linkage code loads a
4776 specific TOC element. */
4777 tocoff
= (h
->descriptor
->toc_section
->output_section
->vma
4778 + h
->descriptor
->toc_section
->output_offset
4779 - xcoff_data (output_bfd
)->toc
);
4781 if ((h
->descriptor
->flags
& XCOFF_SET_TOC
) != 0)
4782 tocoff
+= h
->descriptor
->u
.toc_offset
;
4784 /* The first instruction in the glink code needs to be
4785 cooked to to hold the correct offset in the toc. The
4786 rest are just output raw. */
4787 bfd_put_32 (output_bfd
,
4788 bfd_xcoff_glink_code(output_bfd
, 0) | (tocoff
& 0xffff), p
);
4790 /* Start with i == 1 to get past the first instruction done above
4791 The /4 is because the glink code is in bytes and we are going
4793 for (i
= 1; i
< bfd_xcoff_glink_code_size(output_bfd
) / 4; i
++)
4794 bfd_put_32 (output_bfd
,
4795 (bfd_vma
) bfd_xcoff_glink_code(output_bfd
, i
),
4799 /* If we created a TOC entry for this symbol, write out the required
4801 if ((h
->flags
& XCOFF_SET_TOC
) != 0)
4806 struct internal_reloc
*irel
;
4807 struct internal_ldrel ldrel
;
4808 struct internal_syment irsym
;
4809 union internal_auxent iraux
;
4811 tocsec
= h
->toc_section
;
4812 osec
= tocsec
->output_section
;
4813 oindx
= osec
->target_index
;
4814 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
4815 irel
->r_vaddr
= (osec
->vma
4816 + tocsec
->output_offset
4820 irel
->r_symndx
= h
->indx
;
4824 irel
->r_symndx
= obj_raw_syment_count (output_bfd
);
4827 BFD_ASSERT (h
->ldindx
>= 0);
4829 /* Initialize the aux union here instead of closer to when it is
4830 written out below because the length of the csect depends on
4831 whether the output is 32 or 64 bit. */
4832 memset (&iraux
, 0, sizeof iraux
);
4833 iraux
.x_csect
.x_smtyp
= XTY_SD
;
4834 /* iraux.x_csect.x_scnlen.l = 4 or 8, see below. */
4835 iraux
.x_csect
.x_smclas
= XMC_TC
;
4837 /* 32 bit uses a 32 bit R_POS to do the relocations
4838 64 bit uses a 64 bit R_POS to do the relocations
4840 Also needs to change the csect size : 4 for 32 bit, 8 for 64 bit
4842 Which one is determined by the backend. */
4843 if (bfd_xcoff_is_xcoff64 (output_bfd
))
4846 iraux
.x_csect
.x_scnlen
.l
= 8;
4848 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
4851 iraux
.x_csect
.x_scnlen
.l
= 4;
4856 irel
->r_type
= R_POS
;
4857 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
4858 ++osec
->reloc_count
;
4860 ldrel
.l_vaddr
= irel
->r_vaddr
;
4861 ldrel
.l_symndx
= h
->ldindx
;
4862 ldrel
.l_rtype
= (irel
->r_size
<< 8) | R_POS
;
4863 ldrel
.l_rsecnm
= oindx
;
4864 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
4865 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
4867 /* We need to emit a symbol to define a csect which holds
4869 if (finfo
->info
->strip
!= strip_all
)
4871 result
= bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
,
4872 &irsym
, h
->root
.root
.string
);
4876 irsym
.n_value
= irel
->r_vaddr
;
4877 irsym
.n_scnum
= osec
->target_index
;
4878 irsym
.n_sclass
= C_HIDEXT
;
4879 irsym
.n_type
= T_NULL
;
4882 bfd_coff_swap_sym_out (output_bfd
, (void *) &irsym
, (void *) outsym
);
4883 outsym
+= bfd_coff_symesz (output_bfd
);
4885 /* Note : iraux is initialized above. */
4886 bfd_coff_swap_aux_out (output_bfd
, (void *) &iraux
, T_NULL
, C_HIDEXT
,
4887 0, 1, (void *) outsym
);
4888 outsym
+= bfd_coff_auxesz (output_bfd
);
4892 /* We aren't going to write out the symbols below, so we
4893 need to write them out now. */
4894 pos
= obj_sym_filepos (output_bfd
);
4895 pos
+= (obj_raw_syment_count (output_bfd
)
4896 * bfd_coff_symesz (output_bfd
));
4897 amt
= outsym
- finfo
->outsyms
;
4898 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4899 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
4901 obj_raw_syment_count (output_bfd
) +=
4902 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
4904 outsym
= finfo
->outsyms
;
4909 /* If this symbol is a specially defined function descriptor, write
4910 it out. The first word is the address of the function code
4911 itself, the second word is the address of the TOC, and the third
4915 The addresses for the 32 bit will take 4 bytes and the addresses
4916 for 64 bit will take 8 bytes. Similar for the relocs. This type
4917 of logic was also done above to create a TOC entry in
4918 xcoff_write_global_symbol. */
4919 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
4920 && h
->root
.type
== bfd_link_hash_defined
4921 && (h
->root
.u
.def
.section
4922 == xcoff_hash_table (finfo
->info
)->descriptor_section
))
4928 struct xcoff_link_hash_entry
*hentry
;
4930 struct internal_reloc
*irel
;
4931 struct internal_ldrel ldrel
;
4933 unsigned int reloc_size
, byte_size
;
4935 if (bfd_xcoff_is_xcoff64 (output_bfd
))
4940 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
4948 sec
= h
->root
.u
.def
.section
;
4949 osec
= sec
->output_section
;
4950 oindx
= osec
->target_index
;
4951 p
= sec
->contents
+ h
->root
.u
.def
.value
;
4953 hentry
= h
->descriptor
;
4954 BFD_ASSERT (hentry
!= NULL
4955 && (hentry
->root
.type
== bfd_link_hash_defined
4956 || hentry
->root
.type
== bfd_link_hash_defweak
));
4957 esec
= hentry
->root
.u
.def
.section
;
4959 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
4960 irel
->r_vaddr
= (osec
->vma
4961 + sec
->output_offset
4962 + h
->root
.u
.def
.value
);
4963 irel
->r_symndx
= esec
->output_section
->target_index
;
4964 irel
->r_type
= R_POS
;
4965 irel
->r_size
= reloc_size
;
4966 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
4967 ++osec
->reloc_count
;
4969 ldrel
.l_vaddr
= irel
->r_vaddr
;
4970 if (strcmp (esec
->output_section
->name
, ".text") == 0)
4972 else if (strcmp (esec
->output_section
->name
, ".data") == 0)
4974 else if (strcmp (esec
->output_section
->name
, ".bss") == 0)
4978 (*_bfd_error_handler
)
4979 (_("%s: loader reloc in unrecognized section `%s'"),
4980 bfd_get_filename (output_bfd
),
4981 esec
->output_section
->name
);
4982 bfd_set_error (bfd_error_nonrepresentable_section
);
4985 ldrel
.l_rtype
= (reloc_size
<< 8) | R_POS
;
4986 ldrel
.l_rsecnm
= oindx
;
4987 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
4988 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
4990 /* There are three items to write out,
4991 the address of the code
4992 the address of the toc anchor
4993 the environment pointer.
4994 We are ignoring the environment pointer. So set it to zero. */
4995 if (bfd_xcoff_is_xcoff64 (output_bfd
))
4997 bfd_put_64 (output_bfd
,
4998 (esec
->output_section
->vma
+ esec
->output_offset
4999 + hentry
->root
.u
.def
.value
),
5001 bfd_put_64 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 8);
5002 bfd_put_64 (output_bfd
, (bfd_vma
) 0, p
+ 16);
5007 This logic was already called above so the error case where
5008 the backend is neither has already been checked. */
5009 bfd_put_32 (output_bfd
,
5010 (esec
->output_section
->vma
+ esec
->output_offset
5011 + hentry
->root
.u
.def
.value
),
5013 bfd_put_32 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 4);
5014 bfd_put_32 (output_bfd
, (bfd_vma
) 0, p
+ 8);
5017 tsec
= coff_section_from_bfd_index (output_bfd
,
5018 xcoff_data (output_bfd
)->sntoc
);
5021 irel
->r_vaddr
= (osec
->vma
5022 + sec
->output_offset
5023 + h
->root
.u
.def
.value
5025 irel
->r_symndx
= tsec
->output_section
->target_index
;
5026 irel
->r_type
= R_POS
;
5027 irel
->r_size
= reloc_size
;
5028 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5029 ++osec
->reloc_count
;
5031 ldrel
.l_vaddr
= irel
->r_vaddr
;
5032 if (strcmp (tsec
->output_section
->name
, ".text") == 0)
5034 else if (strcmp (tsec
->output_section
->name
, ".data") == 0)
5036 else if (strcmp (tsec
->output_section
->name
, ".bss") == 0)
5040 (*_bfd_error_handler
)
5041 (_("%s: loader reloc in unrecognized section `%s'"),
5042 bfd_get_filename (output_bfd
),
5043 tsec
->output_section
->name
);
5044 bfd_set_error (bfd_error_nonrepresentable_section
);
5047 ldrel
.l_rtype
= (reloc_size
<< 8) | R_POS
;
5048 ldrel
.l_rsecnm
= oindx
;
5049 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5050 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5053 if (h
->indx
>= 0 || finfo
->info
->strip
== strip_all
)
5055 BFD_ASSERT (outsym
== finfo
->outsyms
);
5060 && (finfo
->info
->strip
== strip_all
5061 || (finfo
->info
->strip
== strip_some
5062 && bfd_hash_lookup (finfo
->info
->keep_hash
, h
->root
.root
.string
,
5063 FALSE
, FALSE
) == NULL
)))
5065 BFD_ASSERT (outsym
== finfo
->outsyms
);
5070 && (h
->flags
& (XCOFF_REF_REGULAR
| XCOFF_DEF_REGULAR
)) == 0)
5072 BFD_ASSERT (outsym
== finfo
->outsyms
);
5076 memset (&aux
, 0, sizeof aux
);
5078 h
->indx
= obj_raw_syment_count (output_bfd
);
5080 result
= bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
, &isym
,
5081 h
->root
.root
.string
);
5085 if (h
->root
.type
== bfd_link_hash_undefined
5086 || h
->root
.type
== bfd_link_hash_undefweak
)
5089 isym
.n_scnum
= N_UNDEF
;
5090 isym
.n_sclass
= C_EXT
;
5091 aux
.x_csect
.x_smtyp
= XTY_ER
;
5093 else if ((h
->root
.type
== bfd_link_hash_defined
5094 || h
->root
.type
== bfd_link_hash_defweak
)
5095 && h
->smclas
== XMC_XO
)
5097 BFD_ASSERT (bfd_is_abs_section (h
->root
.u
.def
.section
));
5098 isym
.n_value
= h
->root
.u
.def
.value
;
5099 isym
.n_scnum
= N_UNDEF
;
5100 isym
.n_sclass
= C_EXT
;
5101 aux
.x_csect
.x_smtyp
= XTY_ER
;
5103 else if (h
->root
.type
== bfd_link_hash_defined
5104 || h
->root
.type
== bfd_link_hash_defweak
)
5106 struct xcoff_link_size_list
*l
;
5108 isym
.n_value
= (h
->root
.u
.def
.section
->output_section
->vma
5109 + h
->root
.u
.def
.section
->output_offset
5110 + h
->root
.u
.def
.value
);
5111 if (bfd_is_abs_section (h
->root
.u
.def
.section
->output_section
))
5112 isym
.n_scnum
= N_ABS
;
5114 isym
.n_scnum
= h
->root
.u
.def
.section
->output_section
->target_index
;
5115 isym
.n_sclass
= C_HIDEXT
;
5116 aux
.x_csect
.x_smtyp
= XTY_SD
;
5118 if ((h
->flags
& XCOFF_HAS_SIZE
) != 0)
5120 for (l
= xcoff_hash_table (finfo
->info
)->size_list
;
5126 aux
.x_csect
.x_scnlen
.l
= l
->size
;
5132 else if (h
->root
.type
== bfd_link_hash_common
)
5134 isym
.n_value
= (h
->root
.u
.c
.p
->section
->output_section
->vma
5135 + h
->root
.u
.c
.p
->section
->output_offset
);
5136 isym
.n_scnum
= h
->root
.u
.c
.p
->section
->output_section
->target_index
;
5137 isym
.n_sclass
= C_EXT
;
5138 aux
.x_csect
.x_smtyp
= XTY_CM
;
5139 aux
.x_csect
.x_scnlen
.l
= h
->root
.u
.c
.size
;
5144 isym
.n_type
= T_NULL
;
5147 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
5148 outsym
+= bfd_coff_symesz (output_bfd
);
5150 aux
.x_csect
.x_smclas
= h
->smclas
;
5151 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, T_NULL
, isym
.n_sclass
, 0, 1,
5153 outsym
+= bfd_coff_auxesz (output_bfd
);
5155 if ((h
->root
.type
== bfd_link_hash_defined
5156 || h
->root
.type
== bfd_link_hash_defweak
)
5157 && h
->smclas
!= XMC_XO
)
5159 /* We just output an SD symbol. Now output an LD symbol. */
5162 isym
.n_sclass
= C_EXT
;
5163 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
5164 outsym
+= bfd_coff_symesz (output_bfd
);
5166 aux
.x_csect
.x_smtyp
= XTY_LD
;
5167 aux
.x_csect
.x_scnlen
.l
= obj_raw_syment_count (output_bfd
);
5168 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, T_NULL
, C_EXT
, 0, 1,
5170 outsym
+= bfd_coff_auxesz (output_bfd
);
5173 pos
= obj_sym_filepos (output_bfd
);
5174 pos
+= obj_raw_syment_count (output_bfd
) * bfd_coff_symesz (output_bfd
);
5175 amt
= outsym
- finfo
->outsyms
;
5176 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5177 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
5179 obj_raw_syment_count (output_bfd
) +=
5180 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
5185 /* Handle a link order which is supposed to generate a reloc. */
5188 xcoff_reloc_link_order (bfd
*output_bfd
,
5189 struct xcoff_final_link_info
*finfo
,
5190 asection
*output_section
,
5191 struct bfd_link_order
*link_order
)
5193 reloc_howto_type
*howto
;
5194 struct xcoff_link_hash_entry
*h
;
5198 struct internal_reloc
*irel
;
5199 struct xcoff_link_hash_entry
**rel_hash_ptr
;
5200 struct internal_ldrel ldrel
;
5202 if (link_order
->type
== bfd_section_reloc_link_order
)
5203 /* We need to somehow locate a symbol in the right section. The
5204 symbol must either have a value of zero, or we must adjust
5205 the addend by the value of the symbol. FIXME: Write this
5206 when we need it. The old linker couldn't handle this anyhow. */
5209 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
5212 bfd_set_error (bfd_error_bad_value
);
5216 h
= ((struct xcoff_link_hash_entry
*)
5217 bfd_wrapped_link_hash_lookup (output_bfd
, finfo
->info
,
5218 link_order
->u
.reloc
.p
->u
.name
,
5219 FALSE
, FALSE
, TRUE
));
5222 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
5223 (finfo
->info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0)))
5228 if (h
->root
.type
== bfd_link_hash_common
)
5230 hsec
= h
->root
.u
.c
.p
->section
;
5233 else if (h
->root
.type
== bfd_link_hash_defined
5234 || h
->root
.type
== bfd_link_hash_defweak
)
5236 hsec
= h
->root
.u
.def
.section
;
5237 hval
= h
->root
.u
.def
.value
;
5245 addend
= link_order
->u
.reloc
.p
->addend
;
5247 addend
+= (hsec
->output_section
->vma
5248 + hsec
->output_offset
5255 bfd_reloc_status_type rstat
;
5258 size
= bfd_get_reloc_size (howto
);
5259 buf
= bfd_zmalloc (size
);
5263 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
5269 case bfd_reloc_outofrange
:
5271 case bfd_reloc_overflow
:
5272 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
5273 (finfo
->info
, NULL
, link_order
->u
.reloc
.p
->u
.name
,
5274 howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0)))
5281 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
5282 (file_ptr
) link_order
->offset
, size
);
5288 /* Store the reloc information in the right place. It will get
5289 swapped and written out at the end of the final_link routine. */
5290 irel
= (finfo
->section_info
[output_section
->target_index
].relocs
5291 + output_section
->reloc_count
);
5292 rel_hash_ptr
= (finfo
->section_info
[output_section
->target_index
].rel_hashes
5293 + output_section
->reloc_count
);
5295 memset (irel
, 0, sizeof (struct internal_reloc
));
5296 *rel_hash_ptr
= NULL
;
5298 irel
->r_vaddr
= output_section
->vma
+ link_order
->offset
;
5301 irel
->r_symndx
= h
->indx
;
5304 /* Set the index to -2 to force this symbol to get written out. */
5310 irel
->r_type
= howto
->type
;
5311 irel
->r_size
= howto
->bitsize
- 1;
5312 if (howto
->complain_on_overflow
== complain_overflow_signed
)
5313 irel
->r_size
|= 0x80;
5315 ++output_section
->reloc_count
;
5317 /* Now output the reloc to the .loader section. */
5319 ldrel
.l_vaddr
= irel
->r_vaddr
;
5323 const char *secname
;
5325 secname
= hsec
->output_section
->name
;
5327 if (strcmp (secname
, ".text") == 0)
5329 else if (strcmp (secname
, ".data") == 0)
5331 else if (strcmp (secname
, ".bss") == 0)
5335 (*_bfd_error_handler
)
5336 (_("%s: loader reloc in unrecognized section `%s'"),
5337 bfd_get_filename (output_bfd
), secname
);
5338 bfd_set_error (bfd_error_nonrepresentable_section
);
5346 (*_bfd_error_handler
)
5347 (_("%s: `%s' in loader reloc but not loader sym"),
5348 bfd_get_filename (output_bfd
),
5349 h
->root
.root
.string
);
5350 bfd_set_error (bfd_error_bad_value
);
5353 ldrel
.l_symndx
= h
->ldindx
;
5356 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
5357 ldrel
.l_rsecnm
= output_section
->target_index
;
5358 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5359 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5364 /* Do the final link step. */
5367 _bfd_xcoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
5369 bfd_size_type symesz
;
5370 struct xcoff_final_link_info finfo
;
5372 struct bfd_link_order
*p
;
5373 bfd_size_type max_contents_size
;
5374 bfd_size_type max_sym_count
;
5375 bfd_size_type max_lineno_count
;
5376 bfd_size_type max_reloc_count
;
5377 bfd_size_type max_output_reloc_count
;
5378 file_ptr rel_filepos
;
5380 file_ptr line_filepos
;
5381 unsigned int linesz
;
5383 bfd_byte
*external_relocs
= NULL
;
5384 char strbuf
[STRING_SIZE_SIZE
];
5389 abfd
->flags
|= DYNAMIC
;
5391 symesz
= bfd_coff_symesz (abfd
);
5394 finfo
.output_bfd
= abfd
;
5395 finfo
.strtab
= NULL
;
5396 finfo
.section_info
= NULL
;
5397 finfo
.last_file_index
= -1;
5398 finfo
.toc_symindx
= -1;
5399 finfo
.internal_syms
= NULL
;
5400 finfo
.sym_indices
= NULL
;
5401 finfo
.outsyms
= NULL
;
5402 finfo
.linenos
= NULL
;
5403 finfo
.contents
= NULL
;
5404 finfo
.external_relocs
= NULL
;
5406 finfo
.ldsym
= (xcoff_hash_table (info
)->loader_section
->contents
5407 + bfd_xcoff_ldhdrsz (abfd
));
5408 finfo
.ldrel
= (xcoff_hash_table (info
)->loader_section
->contents
5409 + bfd_xcoff_ldhdrsz(abfd
)
5410 + (xcoff_hash_table (info
)->ldhdr
.l_nsyms
5411 * bfd_xcoff_ldsymsz(abfd
)));
5413 xcoff_data (abfd
)->coff
.link_info
= info
;
5415 finfo
.strtab
= _bfd_stringtab_init ();
5416 if (finfo
.strtab
== NULL
)
5419 /* Count the line number and relocation entries required for the
5420 output file. Determine a few maximum sizes. */
5421 max_contents_size
= 0;
5422 max_lineno_count
= 0;
5423 max_reloc_count
= 0;
5424 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5427 o
->lineno_count
= 0;
5428 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
5430 if (p
->type
== bfd_indirect_link_order
)
5434 sec
= p
->u
.indirect
.section
;
5436 /* Mark all sections which are to be included in the
5437 link. This will normally be every section. We need
5438 to do this so that we can identify any sections which
5439 the linker has decided to not include. */
5440 sec
->linker_mark
= TRUE
;
5442 if (info
->strip
== strip_none
5443 || info
->strip
== strip_some
)
5444 o
->lineno_count
+= sec
->lineno_count
;
5446 o
->reloc_count
+= sec
->reloc_count
;
5448 if (sec
->rawsize
> max_contents_size
)
5449 max_contents_size
= sec
->rawsize
;
5450 if (sec
->size
> max_contents_size
)
5451 max_contents_size
= sec
->size
;
5452 if (sec
->lineno_count
> max_lineno_count
)
5453 max_lineno_count
= sec
->lineno_count
;
5454 if (coff_section_data (sec
->owner
, sec
) != NULL
5455 && xcoff_section_data (sec
->owner
, sec
) != NULL
5456 && (xcoff_section_data (sec
->owner
, sec
)->lineno_count
5457 > max_lineno_count
))
5459 xcoff_section_data (sec
->owner
, sec
)->lineno_count
;
5460 if (sec
->reloc_count
> max_reloc_count
)
5461 max_reloc_count
= sec
->reloc_count
;
5463 else if (p
->type
== bfd_section_reloc_link_order
5464 || p
->type
== bfd_symbol_reloc_link_order
)
5469 /* Compute the file positions for all the sections. */
5470 if (abfd
->output_has_begun
)
5472 if (xcoff_hash_table (info
)->file_align
!= 0)
5479 file_align
= xcoff_hash_table (info
)->file_align
;
5480 if (file_align
!= 0)
5482 bfd_boolean saw_contents
;
5486 /* Insert .pad sections before every section which has
5487 contents and is loaded, if it is preceded by some other
5488 section which has contents and is loaded. */
5489 saw_contents
= TRUE
;
5490 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5492 if (strcmp (o
->name
, ".pad") == 0)
5493 saw_contents
= FALSE
;
5494 else if ((o
->flags
& SEC_HAS_CONTENTS
) != 0
5495 && (o
->flags
& SEC_LOAD
) != 0)
5498 saw_contents
= TRUE
;
5503 /* Create a pad section and place it before the section
5504 that needs padding. This requires unlinking and
5505 relinking the bfd's section list. */
5507 n
= bfd_make_section_anyway_with_flags (abfd
, ".pad",
5509 n
->alignment_power
= 0;
5511 bfd_section_list_remove (abfd
, n
);
5512 bfd_section_list_insert_before (abfd
, o
, n
);
5513 saw_contents
= FALSE
;
5518 /* Reset the section indices after inserting the new
5521 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5524 o
->target_index
= indx
;
5526 BFD_ASSERT ((unsigned int) indx
== abfd
->section_count
);
5528 /* Work out appropriate sizes for the .pad sections to force
5529 each section to land on a page boundary. This bit of
5530 code knows what compute_section_file_positions is going
5532 sofar
= bfd_coff_filhsz (abfd
);
5533 sofar
+= bfd_coff_aoutsz (abfd
);
5534 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
5535 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5536 if ((bfd_xcoff_is_reloc_count_overflow
5537 (abfd
, (bfd_vma
) o
->reloc_count
))
5538 || (bfd_xcoff_is_lineno_count_overflow
5539 (abfd
, (bfd_vma
) o
->lineno_count
)))
5540 /* 64 does not overflow, need to check if 32 does */
5541 sofar
+= bfd_coff_scnhsz (abfd
);
5543 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5545 if (strcmp (o
->name
, ".pad") == 0)
5549 BFD_ASSERT (o
->size
== 0);
5550 pageoff
= sofar
& (file_align
- 1);
5553 o
->size
= file_align
- pageoff
;
5554 sofar
+= file_align
- pageoff
;
5555 o
->flags
|= SEC_HAS_CONTENTS
;
5560 if ((o
->flags
& SEC_HAS_CONTENTS
) != 0)
5561 sofar
+= BFD_ALIGN (o
->size
,
5562 1 << o
->alignment_power
);
5567 if (! bfd_coff_compute_section_file_positions (abfd
))
5571 /* Allocate space for the pointers we need to keep for the relocs. */
5575 /* We use section_count + 1, rather than section_count, because
5576 the target_index fields are 1 based. */
5577 amt
= abfd
->section_count
+ 1;
5578 amt
*= sizeof (struct xcoff_link_section_info
);
5579 finfo
.section_info
= bfd_malloc (amt
);
5580 if (finfo
.section_info
== NULL
)
5582 for (i
= 0; i
<= abfd
->section_count
; i
++)
5584 finfo
.section_info
[i
].relocs
= NULL
;
5585 finfo
.section_info
[i
].rel_hashes
= NULL
;
5586 finfo
.section_info
[i
].toc_rel_hashes
= NULL
;
5590 /* Set the file positions for the relocs. */
5591 rel_filepos
= obj_relocbase (abfd
);
5592 relsz
= bfd_coff_relsz (abfd
);
5593 max_output_reloc_count
= 0;
5594 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5596 if (o
->reloc_count
== 0)
5600 /* A stripped file has no relocs. However, we still
5601 allocate the buffers, so that later code doesn't have to
5602 worry about whether we are stripping or not. */
5603 if (info
->strip
== strip_all
)
5607 o
->flags
|= SEC_RELOC
;
5608 o
->rel_filepos
= rel_filepos
;
5609 rel_filepos
+= o
->reloc_count
* relsz
;
5612 /* We don't know the indices of global symbols until we have
5613 written out all the local symbols. For each section in
5614 the output file, we keep an array of pointers to hash
5615 table entries. Each entry in the array corresponds to a
5616 reloc. When we find a reloc against a global symbol, we
5617 set the corresponding entry in this array so that we can
5618 fix up the symbol index after we have written out all the
5621 Because of this problem, we also keep the relocs in
5622 memory until the end of the link. This wastes memory.
5623 We could backpatch the file later, I suppose, although it
5625 amt
= o
->reloc_count
;
5626 amt
*= sizeof (struct internal_reloc
);
5627 finfo
.section_info
[o
->target_index
].relocs
= bfd_malloc (amt
);
5629 amt
= o
->reloc_count
;
5630 amt
*= sizeof (struct xcoff_link_hash_entry
*);
5631 finfo
.section_info
[o
->target_index
].rel_hashes
= bfd_malloc (amt
);
5633 if (finfo
.section_info
[o
->target_index
].relocs
== NULL
5634 || finfo
.section_info
[o
->target_index
].rel_hashes
== NULL
)
5637 if (o
->reloc_count
> max_output_reloc_count
)
5638 max_output_reloc_count
= o
->reloc_count
;
5642 /* We now know the size of the relocs, so we can determine the file
5643 positions of the line numbers. */
5644 line_filepos
= rel_filepos
;
5645 finfo
.line_filepos
= line_filepos
;
5646 linesz
= bfd_coff_linesz (abfd
);
5647 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5649 if (o
->lineno_count
== 0)
5650 o
->line_filepos
= 0;
5653 o
->line_filepos
= line_filepos
;
5654 line_filepos
+= o
->lineno_count
* linesz
;
5657 /* Reset the reloc and lineno counts, so that we can use them to
5658 count the number of entries we have output so far. */
5660 o
->lineno_count
= 0;
5663 obj_sym_filepos (abfd
) = line_filepos
;
5665 /* Figure out the largest number of symbols in an input BFD. Take
5666 the opportunity to clear the output_has_begun fields of all the
5667 input BFD's. We want at least 6 symbols, since that is the
5668 number which xcoff_write_global_symbol may need. */
5670 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
5674 sub
->output_has_begun
= FALSE
;
5675 sz
= obj_raw_syment_count (sub
);
5676 if (sz
> max_sym_count
)
5680 /* Allocate some buffers used while linking. */
5681 amt
= max_sym_count
* sizeof (struct internal_syment
);
5682 finfo
.internal_syms
= bfd_malloc (amt
);
5684 amt
= max_sym_count
* sizeof (long);
5685 finfo
.sym_indices
= bfd_malloc (amt
);
5687 amt
= (max_sym_count
+ 1) * symesz
;
5688 finfo
.outsyms
= bfd_malloc (amt
);
5690 amt
= max_lineno_count
* bfd_coff_linesz (abfd
);
5691 finfo
.linenos
= bfd_malloc (amt
);
5693 amt
= max_contents_size
;
5694 finfo
.contents
= bfd_malloc (amt
);
5696 amt
= max_reloc_count
* relsz
;
5697 finfo
.external_relocs
= bfd_malloc (amt
);
5699 if ((finfo
.internal_syms
== NULL
&& max_sym_count
> 0)
5700 || (finfo
.sym_indices
== NULL
&& max_sym_count
> 0)
5701 || finfo
.outsyms
== NULL
5702 || (finfo
.linenos
== NULL
&& max_lineno_count
> 0)
5703 || (finfo
.contents
== NULL
&& max_contents_size
> 0)
5704 || (finfo
.external_relocs
== NULL
&& max_reloc_count
> 0))
5707 obj_raw_syment_count (abfd
) = 0;
5708 xcoff_data (abfd
)->toc
= (bfd_vma
) -1;
5710 /* We now know the position of everything in the file, except that
5711 we don't know the size of the symbol table and therefore we don't
5712 know where the string table starts. We just build the string
5713 table in memory as we go along. We process all the relocations
5714 for a single input file at once. */
5715 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5717 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
5719 if (p
->type
== bfd_indirect_link_order
5720 && p
->u
.indirect
.section
->owner
->xvec
== abfd
->xvec
)
5722 sub
= p
->u
.indirect
.section
->owner
;
5723 if (! sub
->output_has_begun
)
5725 if (! xcoff_link_input_bfd (&finfo
, sub
))
5727 sub
->output_has_begun
= TRUE
;
5730 else if (p
->type
== bfd_section_reloc_link_order
5731 || p
->type
== bfd_symbol_reloc_link_order
)
5733 if (! xcoff_reloc_link_order (abfd
, &finfo
, o
, p
))
5738 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5744 /* Free up the buffers used by xcoff_link_input_bfd. */
5745 if (finfo
.internal_syms
!= NULL
)
5747 free (finfo
.internal_syms
);
5748 finfo
.internal_syms
= NULL
;
5750 if (finfo
.sym_indices
!= NULL
)
5752 free (finfo
.sym_indices
);
5753 finfo
.sym_indices
= NULL
;
5755 if (finfo
.linenos
!= NULL
)
5757 free (finfo
.linenos
);
5758 finfo
.linenos
= NULL
;
5760 if (finfo
.contents
!= NULL
)
5762 free (finfo
.contents
);
5763 finfo
.contents
= NULL
;
5765 if (finfo
.external_relocs
!= NULL
)
5767 free (finfo
.external_relocs
);
5768 finfo
.external_relocs
= NULL
;
5771 /* The value of the last C_FILE symbol is supposed to be -1. Write
5773 if (finfo
.last_file_index
!= -1)
5775 finfo
.last_file
.n_value
= -(bfd_vma
) 1;
5776 bfd_coff_swap_sym_out (abfd
, (void *) &finfo
.last_file
,
5777 (void *) finfo
.outsyms
);
5778 pos
= obj_sym_filepos (abfd
) + finfo
.last_file_index
* symesz
;
5779 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
5780 || bfd_bwrite (finfo
.outsyms
, symesz
, abfd
) != symesz
)
5784 /* Write out all the global symbols which do not come from XCOFF
5786 xcoff_link_hash_traverse (xcoff_hash_table (info
),
5787 xcoff_write_global_symbol
,
5790 if (finfo
.outsyms
!= NULL
)
5792 free (finfo
.outsyms
);
5793 finfo
.outsyms
= NULL
;
5796 /* Now that we have written out all the global symbols, we know the
5797 symbol indices to use for relocs against them, and we can finally
5798 write out the relocs. */
5799 amt
= max_output_reloc_count
* relsz
;
5800 external_relocs
= bfd_malloc (amt
);
5801 if (external_relocs
== NULL
&& max_output_reloc_count
!= 0)
5804 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5806 struct internal_reloc
*irel
;
5807 struct internal_reloc
*irelend
;
5808 struct xcoff_link_hash_entry
**rel_hash
;
5809 struct xcoff_toc_rel_hash
*toc_rel_hash
;
5811 bfd_size_type rel_size
;
5813 /* A stripped file has no relocs. */
5814 if (info
->strip
== strip_all
)
5820 if (o
->reloc_count
== 0)
5823 irel
= finfo
.section_info
[o
->target_index
].relocs
;
5824 irelend
= irel
+ o
->reloc_count
;
5825 rel_hash
= finfo
.section_info
[o
->target_index
].rel_hashes
;
5826 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
5828 if (*rel_hash
!= NULL
)
5830 if ((*rel_hash
)->indx
< 0)
5832 if (! ((*info
->callbacks
->unattached_reloc
)
5833 (info
, (*rel_hash
)->root
.root
.string
,
5834 NULL
, o
, irel
->r_vaddr
)))
5836 (*rel_hash
)->indx
= 0;
5838 irel
->r_symndx
= (*rel_hash
)->indx
;
5842 for (toc_rel_hash
= finfo
.section_info
[o
->target_index
].toc_rel_hashes
;
5843 toc_rel_hash
!= NULL
;
5844 toc_rel_hash
= toc_rel_hash
->next
)
5846 if (toc_rel_hash
->h
->u
.toc_indx
< 0)
5848 if (! ((*info
->callbacks
->unattached_reloc
)
5849 (info
, toc_rel_hash
->h
->root
.root
.string
,
5850 NULL
, o
, toc_rel_hash
->rel
->r_vaddr
)))
5852 toc_rel_hash
->h
->u
.toc_indx
= 0;
5854 toc_rel_hash
->rel
->r_symndx
= toc_rel_hash
->h
->u
.toc_indx
;
5857 /* XCOFF requires that the relocs be sorted by address. We tend
5858 to produce them in the order in which their containing csects
5859 appear in the symbol table, which is not necessarily by
5860 address. So we sort them here. There may be a better way to
5862 qsort ((void *) finfo
.section_info
[o
->target_index
].relocs
,
5863 o
->reloc_count
, sizeof (struct internal_reloc
),
5866 irel
= finfo
.section_info
[o
->target_index
].relocs
;
5867 irelend
= irel
+ o
->reloc_count
;
5868 erel
= external_relocs
;
5869 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
5870 bfd_coff_swap_reloc_out (abfd
, (void *) irel
, (void *) erel
);
5872 rel_size
= relsz
* o
->reloc_count
;
5873 if (bfd_seek (abfd
, o
->rel_filepos
, SEEK_SET
) != 0
5874 || bfd_bwrite ((void *) external_relocs
, rel_size
, abfd
) != rel_size
)
5878 if (external_relocs
!= NULL
)
5880 free (external_relocs
);
5881 external_relocs
= NULL
;
5884 /* Free up the section information. */
5885 if (finfo
.section_info
!= NULL
)
5889 for (i
= 0; i
< abfd
->section_count
; i
++)
5891 if (finfo
.section_info
[i
].relocs
!= NULL
)
5892 free (finfo
.section_info
[i
].relocs
);
5893 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
5894 free (finfo
.section_info
[i
].rel_hashes
);
5896 free (finfo
.section_info
);
5897 finfo
.section_info
= NULL
;
5900 /* Write out the loader section contents. */
5901 BFD_ASSERT ((bfd_byte
*) finfo
.ldrel
5902 == (xcoff_hash_table (info
)->loader_section
->contents
5903 + xcoff_hash_table (info
)->ldhdr
.l_impoff
));
5904 o
= xcoff_hash_table (info
)->loader_section
;
5905 if (! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
5906 (file_ptr
) o
->output_offset
, o
->size
))
5909 /* Write out the magic sections. */
5910 o
= xcoff_hash_table (info
)->linkage_section
;
5912 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
5913 (file_ptr
) o
->output_offset
,
5916 o
= xcoff_hash_table (info
)->toc_section
;
5918 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
5919 (file_ptr
) o
->output_offset
,
5922 o
= xcoff_hash_table (info
)->descriptor_section
;
5924 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
5925 (file_ptr
) o
->output_offset
,
5929 /* Write out the string table. */
5930 pos
= obj_sym_filepos (abfd
) + obj_raw_syment_count (abfd
) * symesz
;
5931 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
5934 _bfd_stringtab_size (finfo
.strtab
) + STRING_SIZE_SIZE
,
5936 amt
= STRING_SIZE_SIZE
;
5937 if (bfd_bwrite (strbuf
, amt
, abfd
) != amt
)
5939 if (! _bfd_stringtab_emit (abfd
, finfo
.strtab
))
5942 _bfd_stringtab_free (finfo
.strtab
);
5944 /* Write out the debugging string table. */
5945 o
= xcoff_hash_table (info
)->debug_section
;
5948 struct bfd_strtab_hash
*debug_strtab
;
5950 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
5951 BFD_ASSERT (o
->output_section
->size
- o
->output_offset
5952 >= _bfd_stringtab_size (debug_strtab
));
5953 pos
= o
->output_section
->filepos
+ o
->output_offset
;
5954 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
5956 if (! _bfd_stringtab_emit (abfd
, debug_strtab
))
5960 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
5961 not try to write out the symbols. */
5962 bfd_get_symcount (abfd
) = 0;
5967 if (finfo
.strtab
!= NULL
)
5968 _bfd_stringtab_free (finfo
.strtab
);
5970 if (finfo
.section_info
!= NULL
)
5974 for (i
= 0; i
< abfd
->section_count
; i
++)
5976 if (finfo
.section_info
[i
].relocs
!= NULL
)
5977 free (finfo
.section_info
[i
].relocs
);
5978 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
5979 free (finfo
.section_info
[i
].rel_hashes
);
5981 free (finfo
.section_info
);
5984 if (finfo
.internal_syms
!= NULL
)
5985 free (finfo
.internal_syms
);
5986 if (finfo
.sym_indices
!= NULL
)
5987 free (finfo
.sym_indices
);
5988 if (finfo
.outsyms
!= NULL
)
5989 free (finfo
.outsyms
);
5990 if (finfo
.linenos
!= NULL
)
5991 free (finfo
.linenos
);
5992 if (finfo
.contents
!= NULL
)
5993 free (finfo
.contents
);
5994 if (finfo
.external_relocs
!= NULL
)
5995 free (finfo
.external_relocs
);
5996 if (external_relocs
!= NULL
)
5997 free (external_relocs
);