1 /* POWER/PowerPC XCOFF linker support.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@cygnus.com>, Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "coff/internal.h"
28 #include "coff/xcoff.h"
32 /* This file holds the XCOFF linker code. */
34 #undef STRING_SIZE_SIZE
35 #define STRING_SIZE_SIZE 4
37 /* We reuse the SEC_ROM flag as a mark flag for garbage collection.
38 This flag will only be used on input sections. */
40 #define SEC_MARK (SEC_ROM)
42 /* The list of import files. */
44 struct xcoff_import_file
46 /* The next entry in the list. */
47 struct xcoff_import_file
*next
;
52 /* The member name. */
56 /* Information we keep for each section in the output file during the
59 struct xcoff_link_section_info
61 /* The relocs to be output. */
62 struct internal_reloc
*relocs
;
63 /* For each reloc against a global symbol whose index was not known
64 when the reloc was handled, the global hash table entry. */
65 struct xcoff_link_hash_entry
**rel_hashes
;
66 /* If there is a TOC relative reloc against a global symbol, and the
67 index of the TOC symbol is not known when the reloc was handled,
68 an entry is added to this linked list. This is not an array,
69 like rel_hashes, because this case is quite uncommon. */
70 struct xcoff_toc_rel_hash
72 struct xcoff_toc_rel_hash
*next
;
73 struct xcoff_link_hash_entry
*h
;
74 struct internal_reloc
*rel
;
78 /* Information that we pass around while doing the final link step. */
80 struct xcoff_final_link_info
82 /* General link information. */
83 struct bfd_link_info
*info
;
86 /* Hash table for long symbol names. */
87 struct bfd_strtab_hash
*strtab
;
88 /* Array of information kept for each output section, indexed by the
89 target_index field. */
90 struct xcoff_link_section_info
*section_info
;
91 /* Symbol index of last C_FILE symbol (-1 if none). */
93 /* Contents of last C_FILE symbol. */
94 struct internal_syment last_file
;
95 /* Symbol index of TOC symbol. */
97 /* Start of .loader symbols. */
99 /* Next .loader reloc to swap out. */
101 /* File position of start of line numbers. */
102 file_ptr line_filepos
;
103 /* Buffer large enough to hold swapped symbols of any input file. */
104 struct internal_syment
*internal_syms
;
105 /* Buffer large enough to hold output indices of symbols of any
108 /* Buffer large enough to hold output symbols for any input file. */
110 /* Buffer large enough to hold external line numbers for any input
113 /* Buffer large enough to hold any input section. */
115 /* Buffer large enough to hold external relocs of any input section. */
116 bfd_byte
*external_relocs
;
119 static bfd_boolean
xcoff_mark (struct bfd_link_info
*, asection
*);
123 /* Routines to read XCOFF dynamic information. This don't really
124 belong here, but we already have the ldsym manipulation routines
127 /* Read the contents of a section. */
130 xcoff_get_section_contents (bfd
*abfd
, asection
*sec
)
132 if (coff_section_data (abfd
, sec
) == NULL
)
134 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
136 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
137 if (sec
->used_by_bfd
== NULL
)
141 if (coff_section_data (abfd
, sec
)->contents
== NULL
)
145 if (! bfd_malloc_and_get_section (abfd
, sec
, &contents
))
147 if (contents
!= NULL
)
151 coff_section_data (abfd
, sec
)->contents
= contents
;
157 /* Get the size required to hold the dynamic symbols. */
160 _bfd_xcoff_get_dynamic_symtab_upper_bound (bfd
*abfd
)
164 struct internal_ldhdr ldhdr
;
166 if ((abfd
->flags
& DYNAMIC
) == 0)
168 bfd_set_error (bfd_error_invalid_operation
);
172 lsec
= bfd_get_section_by_name (abfd
, ".loader");
175 bfd_set_error (bfd_error_no_symbols
);
179 if (! xcoff_get_section_contents (abfd
, lsec
))
181 contents
= coff_section_data (abfd
, lsec
)->contents
;
183 bfd_xcoff_swap_ldhdr_in (abfd
, (void *) contents
, &ldhdr
);
185 return (ldhdr
.l_nsyms
+ 1) * sizeof (asymbol
*);
188 /* Get the dynamic symbols. */
191 _bfd_xcoff_canonicalize_dynamic_symtab (bfd
*abfd
, asymbol
**psyms
)
195 struct internal_ldhdr ldhdr
;
197 bfd_byte
*elsym
, *elsymend
;
198 coff_symbol_type
*symbuf
;
200 if ((abfd
->flags
& DYNAMIC
) == 0)
202 bfd_set_error (bfd_error_invalid_operation
);
206 lsec
= bfd_get_section_by_name (abfd
, ".loader");
209 bfd_set_error (bfd_error_no_symbols
);
213 if (! xcoff_get_section_contents (abfd
, lsec
))
215 contents
= coff_section_data (abfd
, lsec
)->contents
;
217 coff_section_data (abfd
, lsec
)->keep_contents
= TRUE
;
219 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
221 strings
= (char *) contents
+ ldhdr
.l_stoff
;
223 symbuf
= bfd_zalloc (abfd
, ldhdr
.l_nsyms
* sizeof (* symbuf
));
227 elsym
= contents
+ bfd_xcoff_loader_symbol_offset(abfd
, &ldhdr
);
229 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz(abfd
);
230 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz(abfd
), symbuf
++, psyms
++)
232 struct internal_ldsym ldsym
;
234 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
236 symbuf
->symbol
.the_bfd
= abfd
;
238 if (ldsym
._l
._l_l
._l_zeroes
== 0)
239 symbuf
->symbol
.name
= strings
+ ldsym
._l
._l_l
._l_offset
;
244 c
= bfd_alloc (abfd
, (bfd_size_type
) SYMNMLEN
+ 1);
247 memcpy (c
, ldsym
._l
._l_name
, SYMNMLEN
);
249 symbuf
->symbol
.name
= c
;
252 if (ldsym
.l_smclas
== XMC_XO
)
253 symbuf
->symbol
.section
= bfd_abs_section_ptr
;
255 symbuf
->symbol
.section
= coff_section_from_bfd_index (abfd
,
257 symbuf
->symbol
.value
= ldsym
.l_value
- symbuf
->symbol
.section
->vma
;
259 symbuf
->symbol
.flags
= BSF_NO_FLAGS
;
260 if ((ldsym
.l_smtype
& L_EXPORT
) != 0)
262 if ((ldsym
.l_smtype
& L_WEAK
) != 0)
263 symbuf
->symbol
.flags
|= BSF_WEAK
;
265 symbuf
->symbol
.flags
|= BSF_GLOBAL
;
268 /* FIXME: We have no way to record the other information stored
269 with the loader symbol. */
270 *psyms
= (asymbol
*) symbuf
;
275 return ldhdr
.l_nsyms
;
278 /* Get the size required to hold the dynamic relocs. */
281 _bfd_xcoff_get_dynamic_reloc_upper_bound (bfd
*abfd
)
285 struct internal_ldhdr ldhdr
;
287 if ((abfd
->flags
& DYNAMIC
) == 0)
289 bfd_set_error (bfd_error_invalid_operation
);
293 lsec
= bfd_get_section_by_name (abfd
, ".loader");
296 bfd_set_error (bfd_error_no_symbols
);
300 if (! xcoff_get_section_contents (abfd
, lsec
))
302 contents
= coff_section_data (abfd
, lsec
)->contents
;
304 bfd_xcoff_swap_ldhdr_in (abfd
, (struct external_ldhdr
*) contents
, &ldhdr
);
306 return (ldhdr
.l_nreloc
+ 1) * sizeof (arelent
*);
309 /* Get the dynamic relocs. */
312 _bfd_xcoff_canonicalize_dynamic_reloc (bfd
*abfd
,
318 struct internal_ldhdr ldhdr
;
320 bfd_byte
*elrel
, *elrelend
;
322 if ((abfd
->flags
& DYNAMIC
) == 0)
324 bfd_set_error (bfd_error_invalid_operation
);
328 lsec
= bfd_get_section_by_name (abfd
, ".loader");
331 bfd_set_error (bfd_error_no_symbols
);
335 if (! xcoff_get_section_contents (abfd
, lsec
))
337 contents
= coff_section_data (abfd
, lsec
)->contents
;
339 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
341 relbuf
= bfd_alloc (abfd
, ldhdr
.l_nreloc
* sizeof (arelent
));
345 elrel
= contents
+ bfd_xcoff_loader_reloc_offset(abfd
, &ldhdr
);
347 elrelend
= elrel
+ ldhdr
.l_nreloc
* bfd_xcoff_ldrelsz(abfd
);
348 for (; elrel
< elrelend
; elrel
+= bfd_xcoff_ldrelsz(abfd
), relbuf
++,
351 struct internal_ldrel ldrel
;
353 bfd_xcoff_swap_ldrel_in (abfd
, elrel
, &ldrel
);
355 if (ldrel
.l_symndx
>= 3)
356 relbuf
->sym_ptr_ptr
= syms
+ (ldrel
.l_symndx
- 3);
362 switch (ldrel
.l_symndx
)
378 sec
= bfd_get_section_by_name (abfd
, name
);
381 bfd_set_error (bfd_error_bad_value
);
385 relbuf
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
388 relbuf
->address
= ldrel
.l_vaddr
;
391 /* Most dynamic relocs have the same type. FIXME: This is only
392 correct if ldrel.l_rtype == 0. In other cases, we should use
393 a different howto. */
394 relbuf
->howto
= bfd_xcoff_dynamic_reloc_howto(abfd
);
396 /* FIXME: We have no way to record the l_rsecnm field. */
403 return ldhdr
.l_nreloc
;
406 /* Routine to create an entry in an XCOFF link hash table. */
408 static struct bfd_hash_entry
*
409 xcoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
410 struct bfd_hash_table
*table
,
413 struct xcoff_link_hash_entry
*ret
= (struct xcoff_link_hash_entry
*) entry
;
415 /* Allocate the structure if it has not already been allocated by a
418 ret
= bfd_hash_allocate (table
, sizeof (* ret
));
422 /* Call the allocation method of the superclass. */
423 ret
= ((struct xcoff_link_hash_entry
*)
424 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
428 /* Set local fields. */
430 ret
->toc_section
= NULL
;
431 ret
->u
.toc_indx
= -1;
432 ret
->descriptor
= NULL
;
436 ret
->smclas
= XMC_UA
;
439 return (struct bfd_hash_entry
*) ret
;
442 /* Create a XCOFF link hash table. */
444 struct bfd_link_hash_table
*
445 _bfd_xcoff_bfd_link_hash_table_create (bfd
*abfd
)
447 struct xcoff_link_hash_table
*ret
;
448 bfd_size_type amt
= sizeof (* ret
);
450 ret
= bfd_malloc (amt
);
453 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
, xcoff_link_hash_newfunc
,
454 sizeof (struct xcoff_link_hash_entry
)))
460 ret
->debug_strtab
= _bfd_xcoff_stringtab_init ();
461 ret
->debug_section
= NULL
;
462 ret
->loader_section
= NULL
;
463 ret
->ldrel_count
= 0;
464 memset (&ret
->ldhdr
, 0, sizeof (struct internal_ldhdr
));
465 ret
->linkage_section
= NULL
;
466 ret
->toc_section
= NULL
;
467 ret
->descriptor_section
= NULL
;
472 memset (ret
->special_sections
, 0, sizeof ret
->special_sections
);
474 /* The linker will always generate a full a.out header. We need to
475 record that fact now, before the sizeof_headers routine could be
477 xcoff_data (abfd
)->full_aouthdr
= TRUE
;
482 /* Free a XCOFF link hash table. */
485 _bfd_xcoff_bfd_link_hash_table_free (struct bfd_link_hash_table
*hash
)
487 struct xcoff_link_hash_table
*ret
= (struct xcoff_link_hash_table
*) hash
;
489 _bfd_stringtab_free (ret
->debug_strtab
);
490 bfd_hash_table_free (&ret
->root
.table
);
494 /* Read internal relocs for an XCOFF csect. This is a wrapper around
495 _bfd_coff_read_internal_relocs which tries to take advantage of any
496 relocs which may have been cached for the enclosing section. */
498 static struct internal_reloc
*
499 xcoff_read_internal_relocs (bfd
*abfd
,
502 bfd_byte
*external_relocs
,
503 bfd_boolean require_internal
,
504 struct internal_reloc
*internal_relocs
)
506 if (coff_section_data (abfd
, sec
) != NULL
507 && coff_section_data (abfd
, sec
)->relocs
== NULL
508 && xcoff_section_data (abfd
, sec
) != NULL
)
512 enclosing
= xcoff_section_data (abfd
, sec
)->enclosing
;
514 if (enclosing
!= NULL
515 && (coff_section_data (abfd
, enclosing
) == NULL
516 || coff_section_data (abfd
, enclosing
)->relocs
== NULL
)
518 && enclosing
->reloc_count
> 0)
520 if (_bfd_coff_read_internal_relocs (abfd
, enclosing
, TRUE
,
521 external_relocs
, FALSE
, NULL
)
526 if (enclosing
!= NULL
527 && coff_section_data (abfd
, enclosing
) != NULL
528 && coff_section_data (abfd
, enclosing
)->relocs
!= NULL
)
532 off
= ((sec
->rel_filepos
- enclosing
->rel_filepos
)
533 / bfd_coff_relsz (abfd
));
535 if (! require_internal
)
536 return coff_section_data (abfd
, enclosing
)->relocs
+ off
;
537 memcpy (internal_relocs
,
538 coff_section_data (abfd
, enclosing
)->relocs
+ off
,
539 sec
->reloc_count
* sizeof (struct internal_reloc
));
540 return internal_relocs
;
544 return _bfd_coff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
545 require_internal
, internal_relocs
);
548 /* H is the bfd symbol associated with exported .loader symbol LDSYM.
549 Return true if LDSYM defines H. */
552 xcoff_dynamic_definition_p (struct xcoff_link_hash_entry
*h
,
553 struct internal_ldsym
*ldsym
)
555 /* If we didn't know about H before processing LDSYM, LDSYM
556 definitely defines H. */
557 if (h
->root
.type
== bfd_link_hash_new
)
560 /* If H is currently a weak dynamic symbol, and if LDSYM is a strong
561 dynamic symbol, LDSYM trumps the current definition of H. */
562 if ((ldsym
->l_smtype
& L_WEAK
) == 0
563 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0
564 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
565 && (h
->root
.type
== bfd_link_hash_defweak
566 || h
->root
.type
== bfd_link_hash_undefweak
))
569 /* If H is currently undefined, LDSYM defines it. */
570 if ((h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
571 && (h
->root
.type
== bfd_link_hash_undefined
572 || h
->root
.type
== bfd_link_hash_undefweak
))
578 /* This function is used to add symbols from a dynamic object to the
579 global symbol table. */
582 xcoff_link_add_dynamic_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
586 struct internal_ldhdr ldhdr
;
588 bfd_byte
*elsym
, *elsymend
;
589 struct xcoff_import_file
*n
;
594 struct xcoff_import_file
**pp
;
596 /* We can only handle a dynamic object if we are generating an XCOFF
598 if (info
->output_bfd
->xvec
!= abfd
->xvec
)
600 (*_bfd_error_handler
)
601 (_("%s: XCOFF shared object when not producing XCOFF output"),
602 bfd_get_filename (abfd
));
603 bfd_set_error (bfd_error_invalid_operation
);
607 /* The symbols we use from a dynamic object are not the symbols in
608 the normal symbol table, but, rather, the symbols in the export
609 table. If there is a global symbol in a dynamic object which is
610 not in the export table, the loader will not be able to find it,
611 so we don't want to find it either. Also, on AIX 4.1.3, shr.o in
612 libc.a has symbols in the export table which are not in the
615 /* Read in the .loader section. FIXME: We should really use the
616 o_snloader field in the a.out header, rather than grabbing the
618 lsec
= bfd_get_section_by_name (abfd
, ".loader");
621 (*_bfd_error_handler
)
622 (_("%s: dynamic object with no .loader section"),
623 bfd_get_filename (abfd
));
624 bfd_set_error (bfd_error_no_symbols
);
628 if (! xcoff_get_section_contents (abfd
, lsec
))
630 contents
= coff_section_data (abfd
, lsec
)->contents
;
632 /* Remove the sections from this object, so that they do not get
633 included in the link. */
634 bfd_section_list_clear (abfd
);
636 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
638 strings
= (char *) contents
+ ldhdr
.l_stoff
;
640 elsym
= contents
+ bfd_xcoff_loader_symbol_offset(abfd
, &ldhdr
);
642 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz(abfd
);
644 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz(abfd
))
646 struct internal_ldsym ldsym
;
647 char nambuf
[SYMNMLEN
+ 1];
649 struct xcoff_link_hash_entry
*h
;
651 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
653 /* We are only interested in exported symbols. */
654 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
657 if (ldsym
._l
._l_l
._l_zeroes
== 0)
658 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
661 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
662 nambuf
[SYMNMLEN
] = '\0';
666 /* Normally we could not call xcoff_link_hash_lookup in an add
667 symbols routine, since we might not be using an XCOFF hash
668 table. However, we verified above that we are using an XCOFF
671 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, TRUE
,
676 if (!xcoff_dynamic_definition_p (h
, &ldsym
))
679 h
->flags
|= XCOFF_DEF_DYNAMIC
;
680 h
->smclas
= ldsym
.l_smclas
;
681 if (h
->smclas
== XMC_XO
)
683 /* This symbol has an absolute value. */
684 if ((ldsym
.l_smtype
& L_WEAK
) != 0)
685 h
->root
.type
= bfd_link_hash_defweak
;
687 h
->root
.type
= bfd_link_hash_defined
;
688 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
689 h
->root
.u
.def
.value
= ldsym
.l_value
;
693 /* Otherwise, we don't bother to actually define the symbol,
694 since we don't have a section to put it in anyhow.
695 We assume instead that an undefined XCOFF_DEF_DYNAMIC symbol
696 should be imported from the symbol's undef.abfd. */
697 if ((ldsym
.l_smtype
& L_WEAK
) != 0)
698 h
->root
.type
= bfd_link_hash_undefweak
;
700 h
->root
.type
= bfd_link_hash_undefined
;
701 h
->root
.u
.undef
.abfd
= abfd
;
704 /* If this symbol defines a function descriptor, then it
705 implicitly defines the function code as well. */
706 if (h
->smclas
== XMC_DS
707 || (h
->smclas
== XMC_XO
&& name
[0] != '.'))
708 h
->flags
|= XCOFF_DESCRIPTOR
;
709 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
711 struct xcoff_link_hash_entry
*hds
;
718 dsnm
= bfd_malloc ((bfd_size_type
) strlen (name
) + 2);
722 strcpy (dsnm
+ 1, name
);
723 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
), dsnm
,
733 if (xcoff_dynamic_definition_p (hds
, &ldsym
))
735 hds
->root
.type
= h
->root
.type
;
736 hds
->flags
|= XCOFF_DEF_DYNAMIC
;
737 if (h
->smclas
== XMC_XO
)
739 /* An absolute symbol appears to actually define code, not a
740 function descriptor. This is how some math functions are
741 implemented on AIX 4.1. */
742 hds
->smclas
= XMC_XO
;
743 hds
->root
.u
.def
.section
= bfd_abs_section_ptr
;
744 hds
->root
.u
.def
.value
= ldsym
.l_value
;
748 hds
->smclas
= XMC_PR
;
749 hds
->root
.u
.undef
.abfd
= abfd
;
750 /* We do not want to add this to the undefined
757 if (contents
!= NULL
&& ! coff_section_data (abfd
, lsec
)->keep_contents
)
759 free (coff_section_data (abfd
, lsec
)->contents
);
760 coff_section_data (abfd
, lsec
)->contents
= NULL
;
763 /* Record this file in the import files. */
764 n
= bfd_alloc (abfd
, (bfd_size_type
) sizeof (struct xcoff_import_file
));
769 /* For some reason, the path entry in the import file list for a
770 shared object appears to always be empty. The file name is the
773 if (abfd
->my_archive
== NULL
)
775 bname
= bfd_get_filename (abfd
);
780 bname
= bfd_get_filename (abfd
->my_archive
);
781 mname
= bfd_get_filename (abfd
);
783 s
= strrchr (bname
, '/');
789 /* We start c at 1 because the first import file number is reserved
791 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
793 pp
= &(*pp
)->next
, ++c
)
797 xcoff_data (abfd
)->import_file_id
= c
;
802 /* xcoff_link_create_extra_sections
804 Takes care of creating the .loader, .gl, .ds, .debug and sections. */
807 xcoff_link_create_extra_sections (bfd
* abfd
, struct bfd_link_info
*info
)
809 bfd_boolean return_value
= FALSE
;
811 if (info
->output_bfd
->xvec
== abfd
->xvec
)
813 /* We need to build a .loader section, so we do it here. This
814 won't work if we're producing an XCOFF output file with no
815 XCOFF input files. FIXME. */
817 if (xcoff_hash_table (info
)->loader_section
== NULL
)
820 flagword flags
= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
822 lsec
= bfd_make_section_anyway_with_flags (abfd
, ".loader", flags
);
826 xcoff_hash_table (info
)->loader_section
= lsec
;
829 /* Likewise for the linkage section. */
830 if (xcoff_hash_table (info
)->linkage_section
== NULL
)
833 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
836 lsec
= bfd_make_section_anyway_with_flags (abfd
, ".gl", flags
);
840 xcoff_hash_table (info
)->linkage_section
= lsec
;
841 lsec
->alignment_power
= 2;
844 /* Likewise for the TOC section. */
845 if (xcoff_hash_table (info
)->toc_section
== NULL
)
848 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
851 tsec
= bfd_make_section_anyway_with_flags (abfd
, ".tc", flags
);
855 xcoff_hash_table (info
)->toc_section
= tsec
;
856 tsec
->alignment_power
= 2;
859 /* Likewise for the descriptor section. */
860 if (xcoff_hash_table (info
)->descriptor_section
== NULL
)
863 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
866 dsec
= bfd_make_section_anyway_with_flags (abfd
, ".ds", flags
);
870 xcoff_hash_table (info
)->descriptor_section
= dsec
;
871 dsec
->alignment_power
= 2;
874 /* Likewise for the .debug section. */
875 if (xcoff_hash_table (info
)->debug_section
== NULL
876 && info
->strip
!= strip_all
)
879 flagword flags
= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
881 dsec
= bfd_make_section_anyway_with_flags (abfd
, ".debug", flags
);
885 xcoff_hash_table (info
)->debug_section
= dsec
;
896 /* Returns the index of reloc in RELOCS with the least address greater
897 than or equal to ADDRESS. The relocs are sorted by address. */
900 xcoff_find_reloc (struct internal_reloc
*relocs
,
904 bfd_size_type min
, max
, this;
908 if (count
== 1 && relocs
[0].r_vaddr
< address
)
917 /* Do a binary search over (min,max]. */
918 while (min
+ 1 < max
)
922 this = (max
+ min
) / 2;
923 raddr
= relocs
[this].r_vaddr
;
926 else if (raddr
< address
)
935 if (relocs
[min
].r_vaddr
< address
)
939 && relocs
[min
- 1].r_vaddr
== address
)
945 /* Add all the symbols from an object file to the hash table.
947 XCOFF is a weird format. A normal XCOFF .o files will have three
948 COFF sections--.text, .data, and .bss--but each COFF section will
949 contain many csects. These csects are described in the symbol
950 table. From the linker's point of view, each csect must be
951 considered a section in its own right. For example, a TOC entry is
952 handled as a small XMC_TC csect. The linker must be able to merge
953 different TOC entries together, which means that it must be able to
954 extract the XMC_TC csects from the .data section of the input .o
957 From the point of view of our linker, this is, of course, a hideous
958 nightmare. We cope by actually creating sections for each csect,
959 and discarding the original sections. We then have to handle the
960 relocation entries carefully, since the only way to tell which
961 csect they belong to is to examine the address. */
964 xcoff_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
966 unsigned int n_tmask
;
967 unsigned int n_btshft
;
968 bfd_boolean default_copy
;
969 bfd_size_type symcount
;
970 struct xcoff_link_hash_entry
**sym_hash
;
971 asection
**csect_cache
;
972 unsigned int *lineno_counts
;
973 bfd_size_type linesz
;
976 bfd_boolean keep_syms
;
978 unsigned int csect_index
;
979 asection
*first_csect
;
980 bfd_size_type symesz
;
983 struct reloc_info_struct
985 struct internal_reloc
*relocs
;
988 } *reloc_info
= NULL
;
991 keep_syms
= obj_coff_keep_syms (abfd
);
993 if ((abfd
->flags
& DYNAMIC
) != 0
994 && ! info
->static_link
)
996 if (! xcoff_link_add_dynamic_symbols (abfd
, info
))
1000 /* Create the loader, toc, gl, ds and debug sections, if needed. */
1001 if (! xcoff_link_create_extra_sections (abfd
, info
))
1004 if ((abfd
->flags
& DYNAMIC
) != 0
1005 && ! info
->static_link
)
1008 n_tmask
= coff_data (abfd
)->local_n_tmask
;
1009 n_btshft
= coff_data (abfd
)->local_n_btshft
;
1011 /* Define macros so that ISFCN, et. al., macros work correctly. */
1012 #define N_TMASK n_tmask
1013 #define N_BTSHFT n_btshft
1015 if (info
->keep_memory
)
1016 default_copy
= FALSE
;
1018 default_copy
= TRUE
;
1020 symcount
= obj_raw_syment_count (abfd
);
1022 /* We keep a list of the linker hash table entries that correspond
1023 to each external symbol. */
1024 amt
= symcount
* sizeof (struct xcoff_link_hash_entry
*);
1025 sym_hash
= bfd_zalloc (abfd
, amt
);
1026 if (sym_hash
== NULL
&& symcount
!= 0)
1028 coff_data (abfd
)->sym_hashes
= (struct coff_link_hash_entry
**) sym_hash
;
1030 /* Because of the weird stuff we are doing with XCOFF csects, we can
1031 not easily determine which section a symbol is in, so we store
1032 the information in the tdata for the input file. */
1033 amt
= symcount
* sizeof (asection
*);
1034 csect_cache
= bfd_zalloc (abfd
, amt
);
1035 if (csect_cache
== NULL
&& symcount
!= 0)
1037 xcoff_data (abfd
)->csects
= csect_cache
;
1039 /* We garbage-collect line-number information on a symbol-by-symbol
1040 basis, so we need to have quick access to the number of entries
1042 amt
= symcount
* sizeof (unsigned int);
1043 lineno_counts
= bfd_zalloc (abfd
, amt
);
1044 if (lineno_counts
== NULL
&& symcount
!= 0)
1046 xcoff_data (abfd
)->lineno_counts
= lineno_counts
;
1048 /* While splitting sections into csects, we need to assign the
1049 relocs correctly. The relocs and the csects must both be in
1050 order by VMA within a given section, so we handle this by
1051 scanning along the relocs as we process the csects. We index
1052 into reloc_info using the section target_index. */
1053 amt
= abfd
->section_count
+ 1;
1054 amt
*= sizeof (struct reloc_info_struct
);
1055 reloc_info
= bfd_zmalloc (amt
);
1056 if (reloc_info
== NULL
)
1059 /* Read in the relocs and line numbers for each section. */
1060 linesz
= bfd_coff_linesz (abfd
);
1062 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1066 if ((o
->flags
& SEC_RELOC
) != 0)
1068 reloc_info
[o
->target_index
].relocs
=
1069 xcoff_read_internal_relocs (abfd
, o
, TRUE
, NULL
, FALSE
, NULL
);
1070 amt
= o
->reloc_count
;
1071 amt
*= sizeof (asection
*);
1072 reloc_info
[o
->target_index
].csects
= bfd_zmalloc (amt
);
1073 if (reloc_info
[o
->target_index
].csects
== NULL
)
1077 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1078 && o
->lineno_count
> 0)
1082 amt
= linesz
* o
->lineno_count
;
1083 linenos
= bfd_malloc (amt
);
1084 if (linenos
== NULL
)
1086 reloc_info
[o
->target_index
].linenos
= linenos
;
1087 if (bfd_seek (abfd
, o
->line_filepos
, SEEK_SET
) != 0
1088 || bfd_bread (linenos
, amt
, abfd
) != amt
)
1093 /* Don't let the linker relocation routines discard the symbols. */
1094 obj_coff_keep_syms (abfd
) = TRUE
;
1100 symesz
= bfd_coff_symesz (abfd
);
1101 BFD_ASSERT (symesz
== bfd_coff_auxesz (abfd
));
1102 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
1103 esym_end
= esym
+ symcount
* symesz
;
1105 while (esym
< esym_end
)
1107 struct internal_syment sym
;
1108 union internal_auxent aux
;
1110 char buf
[SYMNMLEN
+ 1];
1114 struct xcoff_link_hash_entry
*set_toc
;
1116 bfd_coff_swap_sym_in (abfd
, (void *) esym
, (void *) &sym
);
1118 /* In this pass we are only interested in symbols with csect
1120 if (!CSECT_SYM_P (sym
.n_sclass
))
1123 Normally csect is a .pr, .rw etc. created in the loop
1124 If C_FILE or first time, handle special
1126 Advance esym, sym_hash, csect_hash ptrs. */
1127 if (sym
.n_sclass
== C_FILE
)
1130 *csect_cache
= csect
;
1131 else if (first_csect
== NULL
|| sym
.n_sclass
== C_FILE
)
1132 *csect_cache
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1134 *csect_cache
= NULL
;
1135 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1136 sym_hash
+= sym
.n_numaux
+ 1;
1137 csect_cache
+= sym
.n_numaux
+ 1;
1138 lineno_counts
+= sym
.n_numaux
+ 1;
1143 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
1148 /* If this symbol has line number information attached to it,
1149 and we're not stripping it, count the number of entries and
1150 add them to the count for this csect. In the final link pass
1151 we are going to attach line number information by symbol,
1152 rather than by section, in order to more easily handle
1153 garbage collection. */
1154 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1157 && ISFCN (sym
.n_type
))
1159 union internal_auxent auxlin
;
1161 bfd_coff_swap_aux_in (abfd
, (void *) (esym
+ symesz
),
1162 sym
.n_type
, sym
.n_sclass
,
1163 0, sym
.n_numaux
, (void *) &auxlin
);
1165 if (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
1167 asection
*enclosing
;
1168 bfd_signed_vma linoff
;
1170 enclosing
= xcoff_section_data (abfd
, csect
)->enclosing
;
1171 if (enclosing
== NULL
)
1173 (*_bfd_error_handler
)
1174 (_("%B: `%s' has line numbers but no enclosing section"),
1176 bfd_set_error (bfd_error_bad_value
);
1179 linoff
= (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
1180 - enclosing
->line_filepos
);
1181 /* Explicit cast to bfd_signed_vma for compiler. */
1182 if (linoff
< (bfd_signed_vma
) (enclosing
->lineno_count
* linesz
))
1184 struct internal_lineno lin
;
1185 bfd_byte
*linpstart
;
1187 linpstart
= (reloc_info
[enclosing
->target_index
].linenos
1189 bfd_coff_swap_lineno_in (abfd
, (void *) linpstart
, (void *) &lin
);
1191 && ((bfd_size_type
) lin
.l_addr
.l_symndx
1193 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1196 bfd_byte
*linpend
, *linp
;
1198 linpend
= (reloc_info
[enclosing
->target_index
].linenos
1199 + enclosing
->lineno_count
* linesz
);
1200 for (linp
= linpstart
+ linesz
;
1204 bfd_coff_swap_lineno_in (abfd
, (void *) linp
,
1206 if (lin
.l_lnno
== 0)
1209 *lineno_counts
= (linp
- linpstart
) / linesz
;
1210 /* The setting of line_filepos will only be
1211 useful if all the line number entries for a
1212 csect are contiguous; this only matters for
1214 if (csect
->line_filepos
== 0)
1215 csect
->line_filepos
=
1216 auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1222 /* Pick up the csect auxiliary information. */
1223 if (sym
.n_numaux
== 0)
1225 (*_bfd_error_handler
)
1226 (_("%B: class %d symbol `%s' has no aux entries"),
1227 abfd
, sym
.n_sclass
, name
);
1228 bfd_set_error (bfd_error_bad_value
);
1232 bfd_coff_swap_aux_in (abfd
,
1233 (void *) (esym
+ symesz
* sym
.n_numaux
),
1234 sym
.n_type
, sym
.n_sclass
,
1235 sym
.n_numaux
- 1, sym
.n_numaux
,
1238 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
1247 (*_bfd_error_handler
)
1248 (_("%B: symbol `%s' has unrecognized csect type %d"),
1250 bfd_set_error (bfd_error_bad_value
);
1254 /* This is an external reference. */
1255 if (sym
.n_sclass
== C_HIDEXT
1256 || sym
.n_scnum
!= N_UNDEF
1257 || aux
.x_csect
.x_scnlen
.l
!= 0)
1259 (*_bfd_error_handler
)
1260 (_("%B: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d"),
1261 abfd
, name
, sym
.n_sclass
, sym
.n_scnum
,
1262 aux
.x_csect
.x_scnlen
.l
);
1263 bfd_set_error (bfd_error_bad_value
);
1267 /* An XMC_XO external reference is actually a reference to
1268 an absolute location. */
1269 if (aux
.x_csect
.x_smclas
!= XMC_XO
)
1270 section
= bfd_und_section_ptr
;
1273 section
= bfd_abs_section_ptr
;
1274 value
= sym
.n_value
;
1280 csect_index
= -(unsigned) 1;
1282 /* When we see a TOC anchor, we record the TOC value. */
1283 if (aux
.x_csect
.x_smclas
== XMC_TC0
)
1285 if (sym
.n_sclass
!= C_HIDEXT
1286 || aux
.x_csect
.x_scnlen
.l
!= 0)
1288 (*_bfd_error_handler
)
1289 (_("%B: XMC_TC0 symbol `%s' is class %d scnlen %d"),
1290 abfd
, name
, sym
.n_sclass
, aux
.x_csect
.x_scnlen
.l
);
1291 bfd_set_error (bfd_error_bad_value
);
1294 xcoff_data (abfd
)->toc
= sym
.n_value
;
1297 /* We must merge TOC entries for the same symbol. We can
1298 merge two TOC entries if they are both C_HIDEXT, they
1299 both have the same name, they are both 4 or 8 bytes long, and
1300 they both have a relocation table entry for an external
1301 symbol with the same name. Unfortunately, this means
1302 that we must look through the relocations. Ick.
1304 Logic for 32 bit vs 64 bit.
1305 32 bit has a csect length of 4 for TOC
1306 64 bit has a csect length of 8 for TOC
1308 The conditions to get past the if-check are not that bad.
1309 They are what is used to create the TOC csects in the first
1311 if (aux
.x_csect
.x_smclas
== XMC_TC
1312 && sym
.n_sclass
== C_HIDEXT
1313 && info
->output_bfd
->xvec
== abfd
->xvec
1314 && ((bfd_xcoff_is_xcoff32 (abfd
)
1315 && aux
.x_csect
.x_scnlen
.l
== 4)
1316 || (bfd_xcoff_is_xcoff64 (abfd
)
1317 && aux
.x_csect
.x_scnlen
.l
== 8)))
1319 asection
*enclosing
;
1320 struct internal_reloc
*relocs
;
1321 bfd_size_type relindx
;
1322 struct internal_reloc
*rel
;
1324 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1325 if (enclosing
== NULL
)
1328 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1329 amt
= enclosing
->reloc_count
;
1330 relindx
= xcoff_find_reloc (relocs
, amt
, sym
.n_value
);
1331 rel
= relocs
+ relindx
;
1333 /* 32 bit R_POS r_size is 31
1334 64 bit R_POS r_size is 63 */
1335 if (relindx
< enclosing
->reloc_count
1336 && rel
->r_vaddr
== (bfd_vma
) sym
.n_value
1337 && rel
->r_type
== R_POS
1338 && ((bfd_xcoff_is_xcoff32 (abfd
)
1339 && rel
->r_size
== 31)
1340 || (bfd_xcoff_is_xcoff64 (abfd
)
1341 && rel
->r_size
== 63)))
1345 struct internal_syment relsym
;
1347 erelsym
= ((bfd_byte
*) obj_coff_external_syms (abfd
)
1348 + rel
->r_symndx
* symesz
);
1349 bfd_coff_swap_sym_in (abfd
, (void *) erelsym
, (void *) &relsym
);
1350 if (EXTERN_SYM_P (relsym
.n_sclass
))
1352 const char *relname
;
1353 char relbuf
[SYMNMLEN
+ 1];
1355 struct xcoff_link_hash_entry
*h
;
1357 /* At this point we know that the TOC entry is
1358 for an externally visible symbol. */
1359 relname
= _bfd_coff_internal_syment_name (abfd
, &relsym
,
1361 if (relname
== NULL
)
1364 /* We only merge TOC entries if the TC name is
1365 the same as the symbol name. This handles
1366 the normal case, but not common cases like
1367 SYM.P4 which gcc generates to store SYM + 4
1368 in the TOC. FIXME. */
1369 if (strcmp (name
, relname
) == 0)
1371 copy
= (! info
->keep_memory
1372 || relsym
._n
._n_n
._n_zeroes
!= 0
1373 || relsym
._n
._n_n
._n_offset
== 0);
1374 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1375 relname
, TRUE
, copy
,
1380 /* At this point h->root.type could be
1381 bfd_link_hash_new. That should be OK,
1382 since we know for sure that we will come
1383 across this symbol as we step through the
1386 /* We store h in *sym_hash for the
1387 convenience of the relocate_section
1391 if (h
->toc_section
!= NULL
)
1393 asection
**rel_csects
;
1395 /* We already have a TOC entry for this
1396 symbol, so we can just ignore this
1399 reloc_info
[enclosing
->target_index
].csects
;
1400 rel_csects
[relindx
] = bfd_und_section_ptr
;
1404 /* We are about to create a TOC entry for
1413 asection
*enclosing
;
1415 /* We need to create a new section. We get the name from
1416 the csect storage mapping class, so that the linker can
1417 accumulate similar csects together. */
1419 csect
= bfd_xcoff_create_csect_from_smclas(abfd
, &aux
, name
);
1423 /* The enclosing section is the main section : .data, .text
1424 or .bss that the csect is coming from. */
1425 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1426 if (enclosing
== NULL
)
1429 if (! bfd_is_abs_section (enclosing
)
1430 && ((bfd_vma
) sym
.n_value
< enclosing
->vma
1431 || ((bfd_vma
) sym
.n_value
+ aux
.x_csect
.x_scnlen
.l
1432 > enclosing
->vma
+ enclosing
->size
)))
1434 (*_bfd_error_handler
)
1435 (_("%B: csect `%s' not in enclosing section"),
1437 bfd_set_error (bfd_error_bad_value
);
1440 csect
->vma
= sym
.n_value
;
1441 csect
->filepos
= (enclosing
->filepos
1444 csect
->size
= aux
.x_csect
.x_scnlen
.l
;
1445 csect
->flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
;
1446 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1448 /* Record the enclosing section in the tdata for this new
1450 amt
= sizeof (struct coff_section_tdata
);
1451 csect
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1452 if (csect
->used_by_bfd
== NULL
)
1454 amt
= sizeof (struct xcoff_section_tdata
);
1455 coff_section_data (abfd
, csect
)->tdata
= bfd_zalloc (abfd
, amt
);
1456 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1458 xcoff_section_data (abfd
, csect
)->enclosing
= enclosing
;
1459 xcoff_section_data (abfd
, csect
)->lineno_count
=
1460 enclosing
->lineno_count
;
1462 if (enclosing
->owner
== abfd
)
1464 struct internal_reloc
*relocs
;
1465 bfd_size_type relindx
;
1466 struct internal_reloc
*rel
;
1467 asection
**rel_csect
;
1469 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1470 amt
= enclosing
->reloc_count
;
1471 relindx
= xcoff_find_reloc (relocs
, amt
, csect
->vma
);
1473 rel
= relocs
+ relindx
;
1474 rel_csect
= (reloc_info
[enclosing
->target_index
].csects
1477 csect
->rel_filepos
= (enclosing
->rel_filepos
1478 + relindx
* bfd_coff_relsz (abfd
));
1479 while (relindx
< enclosing
->reloc_count
1480 && *rel_csect
== NULL
1481 && rel
->r_vaddr
< csect
->vma
+ csect
->size
)
1485 csect
->flags
|= SEC_RELOC
;
1486 ++csect
->reloc_count
;
1493 /* There are a number of other fields and section flags
1494 which we do not bother to set. */
1496 csect_index
= ((esym
1497 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1500 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1502 if (first_csect
== NULL
)
1503 first_csect
= csect
;
1505 /* If this symbol is external, we treat it as starting at the
1506 beginning of the newly created section. */
1507 if (EXTERN_SYM_P (sym
.n_sclass
))
1513 /* If this is a TOC section for a symbol, record it. */
1514 if (set_toc
!= NULL
)
1515 set_toc
->toc_section
= csect
;
1520 /* This is a label definition. The x_scnlen field is the
1521 symbol index of the csect. Usually the XTY_LD symbol will
1522 follow its appropriate XTY_SD symbol. The .set pseudo op can
1523 cause the XTY_LD to not follow the XTY_SD symbol. */
1528 if (aux
.x_csect
.x_scnlen
.l
< 0
1529 || (aux
.x_csect
.x_scnlen
.l
1530 >= esym
- (bfd_byte
*) obj_coff_external_syms (abfd
)))
1534 section
= xcoff_data (abfd
)->csects
[aux
.x_csect
.x_scnlen
.l
];
1536 || (section
->flags
& SEC_HAS_CONTENTS
) == 0)
1541 (*_bfd_error_handler
)
1542 (_("%B: misplaced XTY_LD `%s'"),
1544 bfd_set_error (bfd_error_bad_value
);
1548 value
= sym
.n_value
- csect
->vma
;
1553 /* This is an unitialized csect. We could base the name on
1554 the storage mapping class, but we don't bother except for
1555 an XMC_TD symbol. If this csect is externally visible,
1556 it is a common symbol. We put XMC_TD symbols in sections
1557 named .tocbss, and rely on the linker script to put that
1560 if (aux
.x_csect
.x_smclas
== XMC_TD
)
1562 /* The linker script puts the .td section in the data
1563 section after the .tc section. */
1564 csect
= bfd_make_section_anyway_with_flags (abfd
, ".td",
1568 csect
= bfd_make_section_anyway_with_flags (abfd
, ".bss",
1573 csect
->vma
= sym
.n_value
;
1574 csect
->size
= aux
.x_csect
.x_scnlen
.l
;
1575 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1576 /* There are a number of other fields and section flags
1577 which we do not bother to set. */
1579 csect_index
= ((esym
1580 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1583 amt
= sizeof (struct coff_section_tdata
);
1584 csect
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1585 if (csect
->used_by_bfd
== NULL
)
1587 amt
= sizeof (struct xcoff_section_tdata
);
1588 coff_section_data (abfd
, csect
)->tdata
= bfd_zalloc (abfd
, amt
);
1589 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1591 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1593 if (first_csect
== NULL
)
1594 first_csect
= csect
;
1596 if (EXTERN_SYM_P (sym
.n_sclass
))
1598 csect
->flags
|= SEC_IS_COMMON
;
1601 value
= aux
.x_csect
.x_scnlen
.l
;
1607 /* Check for magic symbol names. */
1608 if ((smtyp
== XTY_SD
|| smtyp
== XTY_CM
)
1609 && aux
.x_csect
.x_smclas
!= XMC_TC
1610 && aux
.x_csect
.x_smclas
!= XMC_TD
)
1616 if (strcmp (name
, "_text") == 0)
1617 i
= XCOFF_SPECIAL_SECTION_TEXT
;
1618 else if (strcmp (name
, "_etext") == 0)
1619 i
= XCOFF_SPECIAL_SECTION_ETEXT
;
1620 else if (strcmp (name
, "_data") == 0)
1621 i
= XCOFF_SPECIAL_SECTION_DATA
;
1622 else if (strcmp (name
, "_edata") == 0)
1623 i
= XCOFF_SPECIAL_SECTION_EDATA
;
1624 else if (strcmp (name
, "_end") == 0)
1625 i
= XCOFF_SPECIAL_SECTION_END
;
1627 else if (name
[0] == 'e' && strcmp (name
, "end") == 0)
1628 i
= XCOFF_SPECIAL_SECTION_END2
;
1631 xcoff_hash_table (info
)->special_sections
[i
] = csect
;
1634 /* Now we have enough information to add the symbol to the
1635 linker hash table. */
1637 if (EXTERN_SYM_P (sym
.n_sclass
))
1642 BFD_ASSERT (section
!= NULL
);
1644 /* We must copy the name into memory if we got it from the
1645 syment itself, rather than the string table. */
1646 copy
= default_copy
;
1647 if (sym
._n
._n_n
._n_zeroes
!= 0
1648 || sym
._n
._n_n
._n_offset
== 0)
1651 /* The AIX linker appears to only detect multiple symbol
1652 definitions when there is a reference to the symbol. If
1653 a symbol is defined multiple times, and the only
1654 references are from the same object file, the AIX linker
1655 appears to permit it. It does not merge the different
1656 definitions, but handles them independently. On the
1657 other hand, if there is a reference, the linker reports
1660 This matters because the AIX <net/net_globals.h> header
1661 file actually defines an initialized array, so we have to
1662 actually permit that to work.
1664 Just to make matters even more confusing, the AIX linker
1665 appears to permit multiple symbol definitions whenever
1666 the second definition is in an archive rather than an
1667 object file. This may be a consequence of the manner in
1668 which it handles archives: I think it may load the entire
1669 archive in as separate csects, and then let garbage
1670 collection discard symbols.
1672 We also have to handle the case of statically linking a
1673 shared object, which will cause symbol redefinitions,
1674 although this is an easier case to detect. */
1676 if (info
->output_bfd
->xvec
== abfd
->xvec
)
1678 if (! bfd_is_und_section (section
))
1679 *sym_hash
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1680 name
, TRUE
, copy
, FALSE
);
1682 /* Make a copy of the symbol name to prevent problems with
1684 *sym_hash
= ((struct xcoff_link_hash_entry
*)
1685 bfd_wrapped_link_hash_lookup (abfd
, info
, name
,
1686 TRUE
, TRUE
, FALSE
));
1688 if (*sym_hash
== NULL
)
1690 if (((*sym_hash
)->root
.type
== bfd_link_hash_defined
1691 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
1692 && ! bfd_is_und_section (section
)
1693 && ! bfd_is_com_section (section
))
1695 /* This is a second definition of a defined symbol. */
1696 if ((abfd
->flags
& DYNAMIC
) != 0
1697 && ((*sym_hash
)->smclas
!= XMC_GL
1698 || aux
.x_csect
.x_smclas
== XMC_GL
1699 || ((*sym_hash
)->root
.u
.def
.section
->owner
->flags
1702 /* The new symbol is from a shared library, and
1703 either the existing symbol is not global
1704 linkage code or this symbol is global linkage
1705 code. If the existing symbol is global
1706 linkage code and the new symbol is not, then
1707 we want to use the new symbol. */
1708 section
= bfd_und_section_ptr
;
1711 else if (((*sym_hash
)->flags
& XCOFF_DEF_REGULAR
) == 0
1712 && ((*sym_hash
)->flags
& XCOFF_DEF_DYNAMIC
) != 0)
1714 /* The existing symbol is from a shared library.
1716 (*sym_hash
)->root
.type
= bfd_link_hash_undefined
;
1717 (*sym_hash
)->root
.u
.undef
.abfd
=
1718 (*sym_hash
)->root
.u
.def
.section
->owner
;
1720 else if (abfd
->my_archive
!= NULL
)
1722 /* This is a redefinition in an object contained
1723 in an archive. Just ignore it. See the
1725 section
= bfd_und_section_ptr
;
1728 else if (sym
.n_sclass
== C_AIX_WEAKEXT
1729 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
1731 /* At least one of the definitions is weak.
1732 Allow the normal rules to take effect. */
1734 else if ((*sym_hash
)->root
.u
.undef
.next
!= NULL
1735 || info
->hash
->undefs_tail
== &(*sym_hash
)->root
)
1737 /* This symbol has been referenced. In this
1738 case, we just continue and permit the
1739 multiple definition error. See the comment
1740 above about the behaviour of the AIX linker. */
1742 else if ((*sym_hash
)->smclas
== aux
.x_csect
.x_smclas
)
1744 /* The symbols are both csects of the same
1745 class. There is at least a chance that this
1746 is a semi-legitimate redefinition. */
1747 section
= bfd_und_section_ptr
;
1749 (*sym_hash
)->flags
|= XCOFF_MULTIPLY_DEFINED
;
1752 else if (((*sym_hash
)->flags
& XCOFF_MULTIPLY_DEFINED
) != 0
1753 && (*sym_hash
)->root
.type
== bfd_link_hash_defined
1754 && (bfd_is_und_section (section
)
1755 || bfd_is_com_section (section
)))
1757 /* This is a reference to a multiply defined symbol.
1758 Report the error now. See the comment above
1759 about the behaviour of the AIX linker. We could
1760 also do this with warning symbols, but I'm not
1761 sure the XCOFF linker is wholly prepared to
1762 handle them, and that would only be a warning,
1764 if (! ((*info
->callbacks
->multiple_definition
)
1765 (info
, (*sym_hash
)->root
.root
.string
,
1766 NULL
, NULL
, (bfd_vma
) 0,
1767 (*sym_hash
)->root
.u
.def
.section
->owner
,
1768 (*sym_hash
)->root
.u
.def
.section
,
1769 (*sym_hash
)->root
.u
.def
.value
)))
1771 /* Try not to give this error too many times. */
1772 (*sym_hash
)->flags
&= ~XCOFF_MULTIPLY_DEFINED
;
1776 /* _bfd_generic_link_add_one_symbol may call the linker to
1777 generate an error message, and the linker may try to read
1778 the symbol table to give a good error. Right now, the
1779 line numbers are in an inconsistent state, since they are
1780 counted both in the real sections and in the new csects.
1781 We need to leave the count in the real sections so that
1782 the linker can report the line number of the error
1783 correctly, so temporarily clobber the link to the csects
1784 so that the linker will not try to read the line numbers
1785 a second time from the csects. */
1786 BFD_ASSERT (last_real
->next
== first_csect
);
1787 last_real
->next
= NULL
;
1788 flags
= (sym
.n_sclass
== C_EXT
? BSF_GLOBAL
: BSF_WEAK
);
1789 if (! (_bfd_generic_link_add_one_symbol
1790 (info
, abfd
, name
, flags
, section
, value
,
1792 (struct bfd_link_hash_entry
**) sym_hash
)))
1794 last_real
->next
= first_csect
;
1796 if (smtyp
== XTY_CM
)
1798 if ((*sym_hash
)->root
.type
!= bfd_link_hash_common
1799 || (*sym_hash
)->root
.u
.c
.p
->section
!= csect
)
1800 /* We don't need the common csect we just created. */
1803 (*sym_hash
)->root
.u
.c
.p
->alignment_power
1804 = csect
->alignment_power
;
1807 if (info
->output_bfd
->xvec
== abfd
->xvec
)
1811 if (smtyp
== XTY_ER
|| smtyp
== XTY_CM
)
1812 flag
= XCOFF_REF_REGULAR
;
1814 flag
= XCOFF_DEF_REGULAR
;
1815 (*sym_hash
)->flags
|= flag
;
1817 if ((*sym_hash
)->smclas
== XMC_UA
1818 || flag
== XCOFF_DEF_REGULAR
)
1819 (*sym_hash
)->smclas
= aux
.x_csect
.x_smclas
;
1823 if (smtyp
== XTY_ER
)
1824 *csect_cache
= section
;
1827 *csect_cache
= csect
;
1829 xcoff_section_data (abfd
, csect
)->last_symndx
1830 = (esym
- (bfd_byte
*) obj_coff_external_syms (abfd
)) / symesz
;
1833 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1834 sym_hash
+= sym
.n_numaux
+ 1;
1835 csect_cache
+= sym
.n_numaux
+ 1;
1836 lineno_counts
+= sym
.n_numaux
+ 1;
1839 BFD_ASSERT (last_real
== NULL
|| last_real
->next
== first_csect
);
1841 /* Make sure that we have seen all the relocs. */
1842 for (o
= abfd
->sections
; o
!= first_csect
; o
= o
->next
)
1844 /* Reset the section size and the line number count, since the
1845 data is now attached to the csects. Don't reset the size of
1846 the .debug section, since we need to read it below in
1847 bfd_xcoff_size_dynamic_sections. */
1848 if (strcmp (bfd_get_section_name (abfd
, o
), ".debug") != 0)
1850 o
->lineno_count
= 0;
1852 if ((o
->flags
& SEC_RELOC
) != 0)
1855 struct internal_reloc
*rel
;
1856 asection
**rel_csect
;
1858 rel
= reloc_info
[o
->target_index
].relocs
;
1859 rel_csect
= reloc_info
[o
->target_index
].csects
;
1861 for (i
= 0; i
< o
->reloc_count
; i
++, rel
++, rel_csect
++)
1863 if (*rel_csect
== NULL
)
1865 (*_bfd_error_handler
)
1866 (_("%B: reloc %s:%d not in csect"),
1868 bfd_set_error (bfd_error_bad_value
);
1872 /* We identify all function symbols that are the target
1873 of a relocation, so that we can create glue code for
1874 functions imported from dynamic objects. */
1875 if (info
->output_bfd
->xvec
== abfd
->xvec
1876 && *rel_csect
!= bfd_und_section_ptr
1877 && obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
] != NULL
)
1879 struct xcoff_link_hash_entry
*h
;
1881 h
= obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
];
1882 /* If the symbol name starts with a period, it is
1883 the code of a function. If the symbol is
1884 currently undefined, then add an undefined symbol
1885 for the function descriptor. This should do no
1886 harm, because any regular object that defines the
1887 function should also define the function
1888 descriptor. It helps, because it means that we
1889 will identify the function descriptor with a
1890 dynamic object if a dynamic object defines it. */
1891 if (h
->root
.root
.string
[0] == '.'
1892 && h
->descriptor
== NULL
)
1894 struct xcoff_link_hash_entry
*hds
;
1895 struct bfd_link_hash_entry
*bh
;
1897 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1898 h
->root
.root
.string
+ 1,
1902 if (hds
->root
.type
== bfd_link_hash_new
)
1905 if (! (_bfd_generic_link_add_one_symbol
1906 (info
, abfd
, hds
->root
.root
.string
,
1907 (flagword
) 0, bfd_und_section_ptr
,
1908 (bfd_vma
) 0, NULL
, FALSE
,
1911 hds
= (struct xcoff_link_hash_entry
*) bh
;
1913 hds
->flags
|= XCOFF_DESCRIPTOR
;
1914 BFD_ASSERT ((h
->flags
& XCOFF_DESCRIPTOR
) == 0);
1915 hds
->descriptor
= h
;
1916 h
->descriptor
= hds
;
1918 if (h
->root
.root
.string
[0] == '.')
1919 h
->flags
|= XCOFF_CALLED
;
1923 free (reloc_info
[o
->target_index
].csects
);
1924 reloc_info
[o
->target_index
].csects
= NULL
;
1926 /* Reset SEC_RELOC and the reloc_count, since the reloc
1927 information is now attached to the csects. */
1928 o
->flags
&=~ SEC_RELOC
;
1931 /* If we are not keeping memory, free the reloc information. */
1932 if (! info
->keep_memory
1933 && coff_section_data (abfd
, o
) != NULL
1934 && coff_section_data (abfd
, o
)->relocs
!= NULL
1935 && ! coff_section_data (abfd
, o
)->keep_relocs
)
1937 free (coff_section_data (abfd
, o
)->relocs
);
1938 coff_section_data (abfd
, o
)->relocs
= NULL
;
1942 /* Free up the line numbers. FIXME: We could cache these
1943 somewhere for the final link, to avoid reading them again. */
1944 if (reloc_info
[o
->target_index
].linenos
!= NULL
)
1946 free (reloc_info
[o
->target_index
].linenos
);
1947 reloc_info
[o
->target_index
].linenos
= NULL
;
1953 obj_coff_keep_syms (abfd
) = keep_syms
;
1958 if (reloc_info
!= NULL
)
1960 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1962 if (reloc_info
[o
->target_index
].csects
!= NULL
)
1963 free (reloc_info
[o
->target_index
].csects
);
1964 if (reloc_info
[o
->target_index
].linenos
!= NULL
)
1965 free (reloc_info
[o
->target_index
].linenos
);
1969 obj_coff_keep_syms (abfd
) = keep_syms
;
1976 /* Add symbols from an XCOFF object file. */
1979 xcoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
1981 if (! _bfd_coff_get_external_symbols (abfd
))
1983 if (! xcoff_link_add_symbols (abfd
, info
))
1985 if (! info
->keep_memory
)
1987 if (! _bfd_coff_free_symbols (abfd
))
1993 /* Look through the loader symbols to see if this dynamic object
1994 should be included in the link. The native linker uses the loader
1995 symbols, not the normal symbol table, so we do too. */
1998 xcoff_link_check_dynamic_ar_symbols (bfd
*abfd
,
1999 struct bfd_link_info
*info
,
2000 bfd_boolean
*pneeded
)
2004 struct internal_ldhdr ldhdr
;
2005 const char *strings
;
2006 bfd_byte
*elsym
, *elsymend
;
2010 lsec
= bfd_get_section_by_name (abfd
, ".loader");
2012 /* There are no symbols, so don't try to include it. */
2015 if (! xcoff_get_section_contents (abfd
, lsec
))
2017 contents
= coff_section_data (abfd
, lsec
)->contents
;
2019 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
2021 strings
= (char *) contents
+ ldhdr
.l_stoff
;
2023 elsym
= contents
+ bfd_xcoff_loader_symbol_offset (abfd
, &ldhdr
);
2025 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz (abfd
);
2026 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz (abfd
))
2028 struct internal_ldsym ldsym
;
2029 char nambuf
[SYMNMLEN
+ 1];
2031 struct bfd_link_hash_entry
*h
;
2033 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
2035 /* We are only interested in exported symbols. */
2036 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
2039 if (ldsym
._l
._l_l
._l_zeroes
== 0)
2040 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
2043 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
2044 nambuf
[SYMNMLEN
] = '\0';
2048 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
2050 /* We are only interested in symbols that are currently
2051 undefined. At this point we know that we are using an XCOFF
2054 && h
->type
== bfd_link_hash_undefined
2055 && (((struct xcoff_link_hash_entry
*) h
)->flags
2056 & XCOFF_DEF_DYNAMIC
) == 0)
2058 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
2065 /* We do not need this shared object. */
2066 if (contents
!= NULL
&& ! coff_section_data (abfd
, lsec
)->keep_contents
)
2068 free (coff_section_data (abfd
, lsec
)->contents
);
2069 coff_section_data (abfd
, lsec
)->contents
= NULL
;
2075 /* Look through the symbols to see if this object file should be
2076 included in the link. */
2079 xcoff_link_check_ar_symbols (bfd
*abfd
,
2080 struct bfd_link_info
*info
,
2081 bfd_boolean
*pneeded
)
2083 bfd_size_type symesz
;
2089 if ((abfd
->flags
& DYNAMIC
) != 0
2090 && ! info
->static_link
2091 && info
->output_bfd
->xvec
== abfd
->xvec
)
2092 return xcoff_link_check_dynamic_ar_symbols (abfd
, info
, pneeded
);
2094 symesz
= bfd_coff_symesz (abfd
);
2095 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
2096 esym_end
= esym
+ obj_raw_syment_count (abfd
) * symesz
;
2097 while (esym
< esym_end
)
2099 struct internal_syment sym
;
2101 bfd_coff_swap_sym_in (abfd
, (void *) esym
, (void *) &sym
);
2103 if (EXTERN_SYM_P (sym
.n_sclass
) && sym
.n_scnum
!= N_UNDEF
)
2106 char buf
[SYMNMLEN
+ 1];
2107 struct bfd_link_hash_entry
*h
;
2109 /* This symbol is externally visible, and is defined by this
2111 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
2115 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
2117 /* We are only interested in symbols that are currently
2118 undefined. If a symbol is currently known to be common,
2119 XCOFF linkers do not bring in an object file which
2120 defines it. We also don't bring in symbols to satisfy
2121 undefined references in shared objects. */
2123 && h
->type
== bfd_link_hash_undefined
2124 && (info
->output_bfd
->xvec
!= abfd
->xvec
2125 || (((struct xcoff_link_hash_entry
*) h
)->flags
2126 & XCOFF_DEF_DYNAMIC
) == 0))
2128 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
2135 esym
+= (sym
.n_numaux
+ 1) * symesz
;
2138 /* We do not need this object file. */
2142 /* Check a single archive element to see if we need to include it in
2143 the link. *PNEEDED is set according to whether this element is
2144 needed in the link or not. This is called via
2145 _bfd_generic_link_add_archive_symbols. */
2148 xcoff_link_check_archive_element (bfd
*abfd
,
2149 struct bfd_link_info
*info
,
2150 bfd_boolean
*pneeded
)
2152 if (! _bfd_coff_get_external_symbols (abfd
))
2155 if (! xcoff_link_check_ar_symbols (abfd
, info
, pneeded
))
2160 if (! xcoff_link_add_symbols (abfd
, info
))
2164 if (! info
->keep_memory
|| ! *pneeded
)
2166 if (! _bfd_coff_free_symbols (abfd
))
2173 /* Given an XCOFF BFD, add symbols to the global hash table as
2177 _bfd_xcoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
2179 switch (bfd_get_format (abfd
))
2182 return xcoff_link_add_object_symbols (abfd
, info
);
2185 /* If the archive has a map, do the usual search. We then need
2186 to check the archive for dynamic objects, because they may not
2187 appear in the archive map even though they should, perhaps, be
2188 included. If the archive has no map, we just consider each object
2189 file in turn, since that apparently is what the AIX native linker
2191 if (bfd_has_map (abfd
))
2193 if (! (_bfd_generic_link_add_archive_symbols
2194 (abfd
, info
, xcoff_link_check_archive_element
)))
2201 member
= bfd_openr_next_archived_file (abfd
, NULL
);
2202 while (member
!= NULL
)
2204 if (bfd_check_format (member
, bfd_object
)
2205 && (info
->output_bfd
->xvec
== member
->xvec
)
2206 && (! bfd_has_map (abfd
) || (member
->flags
& DYNAMIC
) != 0))
2210 if (! xcoff_link_check_archive_element (member
, info
,
2214 member
->archive_pass
= -1;
2216 member
= bfd_openr_next_archived_file (abfd
, member
);
2223 bfd_set_error (bfd_error_wrong_format
);
2228 /* If symbol H has not been interpreted as a function descriptor,
2229 see whether it should be. Set up its descriptor information if so. */
2232 xcoff_find_function (struct bfd_link_info
*info
,
2233 struct xcoff_link_hash_entry
*h
)
2235 if ((h
->flags
& XCOFF_DESCRIPTOR
) == 0
2236 && h
->root
.root
.string
[0] != '.')
2239 struct xcoff_link_hash_entry
*hfn
;
2242 amt
= strlen (h
->root
.root
.string
) + 2;
2243 fnname
= bfd_malloc (amt
);
2247 strcpy (fnname
+ 1, h
->root
.root
.string
);
2248 hfn
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2249 fnname
, FALSE
, FALSE
, TRUE
);
2252 && hfn
->smclas
== XMC_PR
2253 && (hfn
->root
.type
== bfd_link_hash_defined
2254 || hfn
->root
.type
== bfd_link_hash_defweak
))
2256 h
->flags
|= XCOFF_DESCRIPTOR
;
2257 h
->descriptor
= hfn
;
2258 hfn
->descriptor
= h
;
2264 /* H is an imported symbol. Set the import module's path, file and member
2265 to IMPATH, IMPFILE and IMPMEMBER respectively. All three are null if
2266 no specific import module is specified. */
2269 xcoff_set_import_path (struct bfd_link_info
*info
,
2270 struct xcoff_link_hash_entry
*h
,
2271 const char *imppath
, const char *impfile
,
2272 const char *impmember
)
2275 struct xcoff_import_file
**pp
;
2277 /* We overload the ldindx field to hold the l_ifile value for this
2279 BFD_ASSERT (h
->ldsym
== NULL
);
2280 BFD_ASSERT ((h
->flags
& XCOFF_BUILT_LDSYM
) == 0);
2281 if (imppath
== NULL
)
2285 /* We start c at 1 because the first entry in the import list is
2286 reserved for the library search path. */
2287 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
2289 pp
= &(*pp
)->next
, ++c
)
2291 if (strcmp ((*pp
)->path
, imppath
) == 0
2292 && strcmp ((*pp
)->file
, impfile
) == 0
2293 && strcmp ((*pp
)->member
, impmember
) == 0)
2299 struct xcoff_import_file
*n
;
2300 bfd_size_type amt
= sizeof (* n
);
2302 n
= bfd_alloc (info
->output_bfd
, amt
);
2308 n
->member
= impmember
;
2316 /* Return true if the given bfd contains at least one shared object. */
2319 xcoff_archive_contains_shared_object_p (bfd
*archive
)
2323 member
= bfd_openr_next_archived_file (archive
, NULL
);
2324 while (member
!= NULL
&& (member
->flags
& DYNAMIC
) == 0)
2325 member
= bfd_openr_next_archived_file (archive
, member
);
2326 return member
!= NULL
;
2329 /* Symbol H qualifies for export by -bexpfull. Return true if it also
2330 qualifies for export by -bexpall. */
2333 xcoff_covered_by_expall_p (struct xcoff_link_hash_entry
*h
)
2335 /* Exclude symbols beginning with '_'. */
2336 if (h
->root
.root
.string
[0] == '_')
2339 /* Exclude archive members that would otherwise be unreferenced. */
2340 if ((h
->flags
& XCOFF_MARK
) == 0
2341 && (h
->root
.type
== bfd_link_hash_defined
2342 || h
->root
.type
== bfd_link_hash_defweak
)
2343 && h
->root
.u
.def
.section
->owner
!= NULL
2344 && h
->root
.u
.def
.section
->owner
->my_archive
!= NULL
)
2350 /* Return true if symbol H qualifies for the forms of automatic export
2351 specified by AUTO_EXPORT_FLAGS. */
2354 xcoff_auto_export_p (struct xcoff_link_hash_entry
*h
,
2355 unsigned int auto_export_flags
)
2357 /* Don't automatically export things that were explicitly exported. */
2358 if ((h
->flags
& XCOFF_EXPORT
) != 0)
2361 /* Don't export things that we don't define. */
2362 if ((h
->flags
& XCOFF_DEF_REGULAR
) == 0)
2365 /* Don't export functions; export their descriptors instead. */
2366 if (h
->root
.root
.string
[0] == '.')
2369 /* We don't export a symbol which is being defined by an object
2370 included from an archive which contains a shared object. The
2371 rationale is that if an archive contains both an unshared and
2372 a shared object, then there must be some reason that the
2373 unshared object is unshared, and we don't want to start
2374 providing a shared version of it. In particular, this solves
2375 a bug involving the _savefNN set of functions. gcc will call
2376 those functions without providing a slot to restore the TOC,
2377 so it is essential that these functions be linked in directly
2378 and not from a shared object, which means that a shared
2379 object which also happens to link them in must not export
2380 them. This is confusing, but I haven't been able to think of
2381 a different approach. Note that the symbols can, of course,
2382 be exported explicitly. */
2383 if (h
->root
.type
== bfd_link_hash_defined
2384 || h
->root
.type
== bfd_link_hash_defweak
)
2388 owner
= h
->root
.u
.def
.section
->owner
;
2390 && owner
->my_archive
!= NULL
2391 && xcoff_archive_contains_shared_object_p (owner
->my_archive
))
2395 /* Otherwise, all symbols are exported by -bexpfull. */
2396 if ((auto_export_flags
& XCOFF_EXPFULL
) != 0)
2399 /* Despite its name, -bexpall exports most but not all symbols. */
2400 if ((auto_export_flags
& XCOFF_EXPALL
) != 0
2401 && xcoff_covered_by_expall_p (h
))
2407 /* Mark a symbol as not being garbage, including the section in which
2410 static inline bfd_boolean
2411 xcoff_mark_symbol (struct bfd_link_info
*info
, struct xcoff_link_hash_entry
*h
)
2413 if ((h
->flags
& XCOFF_MARK
) != 0)
2416 h
->flags
|= XCOFF_MARK
;
2418 /* If we're marking an undefined symbol, try find some way of
2420 if (!info
->relocatable
2421 && (h
->flags
& XCOFF_IMPORT
) == 0
2422 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
2423 && (h
->root
.type
== bfd_link_hash_undefined
2424 || h
->root
.type
== bfd_link_hash_undefweak
))
2426 /* First check whether this symbol can be interpreted as an
2427 undefined function descriptor for a defined function symbol. */
2428 if (!xcoff_find_function (info
, h
))
2431 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
2432 && (h
->descriptor
->root
.type
== bfd_link_hash_defined
2433 || h
->descriptor
->root
.type
== bfd_link_hash_defweak
))
2435 /* This is a descriptor for a defined symbol, but the input
2436 objects have not defined the descriptor itself. Fill in
2437 the definition automatically.
2439 Note that we do this even if we found a dynamic definition
2440 of H. The local function definition logically overrides
2444 sec
= xcoff_hash_table (info
)->descriptor_section
;
2445 h
->root
.type
= bfd_link_hash_defined
;
2446 h
->root
.u
.def
.section
= sec
;
2447 h
->root
.u
.def
.value
= sec
->size
;
2449 h
->flags
|= XCOFF_DEF_REGULAR
;
2451 /* The size of the function descriptor depends on whether this
2452 is xcoff32 (12) or xcoff64 (24). */
2453 sec
->size
+= bfd_xcoff_function_descriptor_size (sec
->owner
);
2455 /* A function descriptor uses two relocs: one for the
2456 associated code, and one for the TOC address. */
2457 xcoff_hash_table (info
)->ldrel_count
+= 2;
2458 sec
->reloc_count
+= 2;
2460 /* Mark the function itself. */
2461 if (!xcoff_mark_symbol (info
, h
->descriptor
))
2464 /* Mark the TOC section, so that we get an anchor
2465 to relocate against. */
2466 if (!xcoff_mark (info
, xcoff_hash_table (info
)->toc_section
))
2469 /* We handle writing out the contents of the descriptor in
2470 xcoff_write_global_symbol. */
2472 else if ((h
->flags
& XCOFF_CALLED
) != 0)
2474 /* This is a function symbol for which we need to create
2477 struct xcoff_link_hash_entry
*hds
;
2479 /* Mark the descriptor (and its TOC section). */
2480 hds
= h
->descriptor
;
2481 BFD_ASSERT ((hds
->root
.type
== bfd_link_hash_undefined
2482 || hds
->root
.type
== bfd_link_hash_undefweak
)
2483 && (hds
->flags
& XCOFF_DEF_REGULAR
) == 0);
2484 if (!xcoff_mark_symbol (info
, hds
))
2487 /* Treat this symbol as undefined if the descriptor was. */
2488 if ((hds
->flags
& XCOFF_WAS_UNDEFINED
) != 0)
2489 h
->flags
|= XCOFF_WAS_UNDEFINED
;
2491 /* Allocate room for the global linkage code itself. */
2492 sec
= xcoff_hash_table (info
)->linkage_section
;
2493 h
->root
.type
= bfd_link_hash_defined
;
2494 h
->root
.u
.def
.section
= sec
;
2495 h
->root
.u
.def
.value
= sec
->size
;
2497 h
->flags
|= XCOFF_DEF_REGULAR
;
2498 sec
->size
+= bfd_xcoff_glink_code_size (info
->output_bfd
);
2500 /* The global linkage code requires a TOC entry for the
2502 if (hds
->toc_section
== NULL
)
2507 xcoff32 uses 4 bytes in the toc.
2508 xcoff64 uses 8 bytes in the toc. */
2509 if (bfd_xcoff_is_xcoff64 (info
->output_bfd
))
2511 else if (bfd_xcoff_is_xcoff32 (info
->output_bfd
))
2516 /* Allocate room in the fallback TOC section. */
2517 hds
->toc_section
= xcoff_hash_table (info
)->toc_section
;
2518 hds
->u
.toc_offset
= hds
->toc_section
->size
;
2519 hds
->toc_section
->size
+= byte_size
;
2520 if (!xcoff_mark (info
, hds
->toc_section
))
2523 /* Allocate room for a static and dynamic R_TOC
2525 ++xcoff_hash_table (info
)->ldrel_count
;
2526 ++hds
->toc_section
->reloc_count
;
2528 /* Set the index to -2 to force this symbol to
2531 hds
->flags
|= XCOFF_SET_TOC
| XCOFF_LDREL
;
2534 else if ((h
->flags
& XCOFF_DEF_DYNAMIC
) == 0)
2536 /* Record that the symbol was undefined, then import it.
2537 -brtl links use a special fake import file. */
2538 h
->flags
|= XCOFF_WAS_UNDEFINED
| XCOFF_IMPORT
;
2539 if (xcoff_hash_table (info
)->rtld
)
2541 if (!xcoff_set_import_path (info
, h
, "", "..", ""))
2546 if (!xcoff_set_import_path (info
, h
, NULL
, NULL
, NULL
))
2552 if (h
->root
.type
== bfd_link_hash_defined
2553 || h
->root
.type
== bfd_link_hash_defweak
)
2557 hsec
= h
->root
.u
.def
.section
;
2558 if (! bfd_is_abs_section (hsec
)
2559 && (hsec
->flags
& SEC_MARK
) == 0)
2561 if (! xcoff_mark (info
, hsec
))
2566 if (h
->toc_section
!= NULL
2567 && (h
->toc_section
->flags
& SEC_MARK
) == 0)
2569 if (! xcoff_mark (info
, h
->toc_section
))
2576 /* Look for a symbol called NAME. If the symbol is defined, mark it.
2577 If the symbol exists, set FLAGS. */
2580 xcoff_mark_symbol_by_name (struct bfd_link_info
*info
,
2581 const char *name
, unsigned int flags
)
2583 struct xcoff_link_hash_entry
*h
;
2585 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
,
2586 FALSE
, FALSE
, TRUE
);
2590 if (h
->root
.type
== bfd_link_hash_defined
2591 || h
->root
.type
== bfd_link_hash_defweak
)
2593 if (!xcoff_mark (info
, h
->root
.u
.def
.section
))
2600 /* The mark phase of garbage collection. For a given section, mark
2601 it, and all the sections which define symbols to which it refers.
2602 Because this function needs to look at the relocs, we also count
2603 the number of relocs which need to be copied into the .loader
2607 xcoff_mark (struct bfd_link_info
*info
, asection
*sec
)
2609 if (bfd_is_abs_section (sec
)
2610 || (sec
->flags
& SEC_MARK
) != 0)
2613 sec
->flags
|= SEC_MARK
;
2615 if (sec
->owner
->xvec
== info
->output_bfd
->xvec
2616 && coff_section_data (sec
->owner
, sec
) != NULL
2617 && xcoff_section_data (sec
->owner
, sec
) != NULL
)
2619 struct xcoff_link_hash_entry
**syms
;
2620 struct internal_reloc
*rel
, *relend
;
2622 unsigned long i
, first
, last
;
2624 /* Mark all the symbols in this section. */
2625 syms
= obj_xcoff_sym_hashes (sec
->owner
);
2626 csects
= xcoff_data (sec
->owner
)->csects
;
2627 first
= xcoff_section_data (sec
->owner
, sec
)->first_symndx
;
2628 last
= xcoff_section_data (sec
->owner
, sec
)->last_symndx
;
2629 for (i
= first
; i
<= last
; i
++)
2630 if (csects
[i
] == sec
2632 && (syms
[i
]->flags
& XCOFF_MARK
) == 0)
2634 if (!xcoff_mark_symbol (info
, syms
[i
]))
2638 /* Look through the section relocs. */
2639 if ((sec
->flags
& SEC_RELOC
) != 0
2640 && sec
->reloc_count
> 0)
2642 rel
= xcoff_read_internal_relocs (sec
->owner
, sec
, TRUE
,
2646 relend
= rel
+ sec
->reloc_count
;
2647 for (; rel
< relend
; rel
++)
2649 struct xcoff_link_hash_entry
*h
;
2651 if ((unsigned int) rel
->r_symndx
2652 > obj_raw_syment_count (sec
->owner
))
2655 h
= obj_xcoff_sym_hashes (sec
->owner
)[rel
->r_symndx
];
2658 if ((h
->flags
& XCOFF_MARK
) == 0)
2660 if (!xcoff_mark_symbol (info
, h
))
2668 rsec
= xcoff_data (sec
->owner
)->csects
[rel
->r_symndx
];
2670 && (rsec
->flags
& SEC_MARK
) == 0)
2672 if (!xcoff_mark (info
, rsec
))
2677 /* See if this reloc needs to be copied into the .loader
2679 switch (rel
->r_type
)
2683 || h
->root
.type
== bfd_link_hash_defined
2684 || h
->root
.type
== bfd_link_hash_defweak
2685 || h
->root
.type
== bfd_link_hash_common
2686 /* We will always provide a local definition of
2687 function symbols. */
2688 || (h
->flags
& XCOFF_CALLED
) != 0)
2696 && (h
->root
.type
== bfd_link_hash_defined
2697 || h
->root
.type
== bfd_link_hash_defweak
)
2698 && bfd_is_abs_section (h
->root
.u
.def
.section
))
2700 ++xcoff_hash_table (info
)->ldrel_count
;
2702 h
->flags
|= XCOFF_LDREL
;
2709 /* We should never need a .loader reloc for a TOC
2715 if (! info
->keep_memory
2716 && coff_section_data (sec
->owner
, sec
) != NULL
2717 && coff_section_data (sec
->owner
, sec
)->relocs
!= NULL
2718 && ! coff_section_data (sec
->owner
, sec
)->keep_relocs
)
2720 free (coff_section_data (sec
->owner
, sec
)->relocs
);
2721 coff_section_data (sec
->owner
, sec
)->relocs
= NULL
;
2729 /* Routines that are called after all the input files have been
2730 handled, but before the sections are laid out in memory. */
2732 /* The sweep phase of garbage collection. Remove all garbage
2736 xcoff_sweep (struct bfd_link_info
*info
)
2740 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
2744 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
2746 if ((o
->flags
& SEC_MARK
) == 0)
2748 /* Keep all sections from non-XCOFF input files. Keep
2749 special sections. Keep .debug sections for the
2751 if (sub
->xvec
!= info
->output_bfd
->xvec
2752 || o
== xcoff_hash_table (info
)->debug_section
2753 || o
== xcoff_hash_table (info
)->loader_section
2754 || o
== xcoff_hash_table (info
)->linkage_section
2755 || o
== xcoff_hash_table (info
)->descriptor_section
2756 || strcmp (o
->name
, ".debug") == 0)
2757 o
->flags
|= SEC_MARK
;
2768 /* Record the number of elements in a set. This is used to output the
2769 correct csect length. */
2772 bfd_xcoff_link_record_set (bfd
*output_bfd
,
2773 struct bfd_link_info
*info
,
2774 struct bfd_link_hash_entry
*harg
,
2777 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2778 struct xcoff_link_size_list
*n
;
2781 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2784 /* This will hardly ever be called. I don't want to burn four bytes
2785 per global symbol, so instead the size is kept on a linked list
2786 attached to the hash table. */
2788 n
= bfd_alloc (output_bfd
, amt
);
2791 n
->next
= xcoff_hash_table (info
)->size_list
;
2794 xcoff_hash_table (info
)->size_list
= n
;
2796 h
->flags
|= XCOFF_HAS_SIZE
;
2801 /* Import a symbol. */
2804 bfd_xcoff_import_symbol (bfd
*output_bfd
,
2805 struct bfd_link_info
*info
,
2806 struct bfd_link_hash_entry
*harg
,
2808 const char *imppath
,
2809 const char *impfile
,
2810 const char *impmember
,
2811 unsigned int syscall_flag
)
2813 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2815 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2818 /* A symbol name which starts with a period is the code for a
2819 function. If the symbol is undefined, then add an undefined
2820 symbol for the function descriptor, and import that instead. */
2821 if (h
->root
.root
.string
[0] == '.'
2822 && h
->root
.type
== bfd_link_hash_undefined
2823 && val
== (bfd_vma
) -1)
2825 struct xcoff_link_hash_entry
*hds
;
2827 hds
= h
->descriptor
;
2830 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2831 h
->root
.root
.string
+ 1,
2835 if (hds
->root
.type
== bfd_link_hash_new
)
2837 hds
->root
.type
= bfd_link_hash_undefined
;
2838 hds
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
2840 hds
->flags
|= XCOFF_DESCRIPTOR
;
2841 BFD_ASSERT ((h
->flags
& XCOFF_DESCRIPTOR
) == 0);
2842 hds
->descriptor
= h
;
2843 h
->descriptor
= hds
;
2846 /* Now, if the descriptor is undefined, import the descriptor
2847 rather than the symbol we were told to import. FIXME: Is
2848 this correct in all cases? */
2849 if (hds
->root
.type
== bfd_link_hash_undefined
)
2853 h
->flags
|= (XCOFF_IMPORT
| syscall_flag
);
2855 if (val
!= (bfd_vma
) -1)
2857 if (h
->root
.type
== bfd_link_hash_defined
2858 && (! bfd_is_abs_section (h
->root
.u
.def
.section
)
2859 || h
->root
.u
.def
.value
!= val
))
2861 if (! ((*info
->callbacks
->multiple_definition
)
2862 (info
, h
->root
.root
.string
, h
->root
.u
.def
.section
->owner
,
2863 h
->root
.u
.def
.section
, h
->root
.u
.def
.value
,
2864 output_bfd
, bfd_abs_section_ptr
, val
)))
2868 h
->root
.type
= bfd_link_hash_defined
;
2869 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2870 h
->root
.u
.def
.value
= val
;
2874 if (!xcoff_set_import_path (info
, h
, imppath
, impfile
, impmember
))
2880 /* Export a symbol. */
2883 bfd_xcoff_export_symbol (bfd
*output_bfd
,
2884 struct bfd_link_info
*info
,
2885 struct bfd_link_hash_entry
*harg
)
2887 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2889 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2892 h
->flags
|= XCOFF_EXPORT
;
2894 /* FIXME: I'm not at all sure what syscall is supposed to mean, so
2895 I'm just going to ignore it until somebody explains it. */
2897 /* Make sure we don't garbage collect this symbol. */
2898 if (! xcoff_mark_symbol (info
, h
))
2901 /* If this is a function descriptor, make sure we don't garbage
2902 collect the associated function code. We normally don't have to
2903 worry about this, because the descriptor will be attached to a
2904 section with relocs, but if we are creating the descriptor
2905 ourselves those relocs will not be visible to the mark code. */
2906 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
2908 if (! xcoff_mark_symbol (info
, h
->descriptor
))
2915 /* Count a reloc against a symbol. This is called for relocs
2916 generated by the linker script, typically for global constructors
2920 bfd_xcoff_link_count_reloc (bfd
*output_bfd
,
2921 struct bfd_link_info
*info
,
2924 struct xcoff_link_hash_entry
*h
;
2926 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2929 h
= ((struct xcoff_link_hash_entry
*)
2930 bfd_wrapped_link_hash_lookup (output_bfd
, info
, name
, FALSE
, FALSE
,
2934 (*_bfd_error_handler
) (_("%s: no such symbol"), name
);
2935 bfd_set_error (bfd_error_no_symbols
);
2939 h
->flags
|= XCOFF_REF_REGULAR
| XCOFF_LDREL
;
2940 ++xcoff_hash_table (info
)->ldrel_count
;
2942 /* Mark the symbol to avoid garbage collection. */
2943 if (! xcoff_mark_symbol (info
, h
))
2949 /* This function is called for each symbol to which the linker script
2953 bfd_xcoff_record_link_assignment (bfd
*output_bfd
,
2954 struct bfd_link_info
*info
,
2957 struct xcoff_link_hash_entry
*h
;
2959 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2962 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, TRUE
, TRUE
,
2967 h
->flags
|= XCOFF_DEF_REGULAR
;
2972 /* An xcoff_link_hash_traverse callback for which DATA points to an
2973 xcoff_loader_info. Mark all symbols that should be automatically
2977 xcoff_mark_auto_exports (struct xcoff_link_hash_entry
*h
, void *data
)
2979 struct xcoff_loader_info
*ldinfo
;
2981 ldinfo
= (struct xcoff_loader_info
*) data
;
2982 if (xcoff_auto_export_p (h
, ldinfo
->auto_export_flags
))
2984 if (!xcoff_mark_symbol (ldinfo
->info
, h
))
2985 ldinfo
->failed
= TRUE
;
2990 /* Add a symbol to the .loader symbols, if necessary. */
2992 /* INPUT_BFD has an external symbol associated with hash table entry H
2993 and csect CSECT. Return true if INPUT_BFD defines H. */
2996 xcoff_final_definition_p (bfd
*input_bfd
, struct xcoff_link_hash_entry
*h
,
2999 switch (h
->root
.type
)
3001 case bfd_link_hash_defined
:
3002 case bfd_link_hash_defweak
:
3003 /* No input bfd owns absolute symbols. They are written by
3004 xcoff_write_global_symbol instead. */
3005 return (!bfd_is_abs_section (csect
)
3006 && h
->root
.u
.def
.section
== csect
);
3008 case bfd_link_hash_common
:
3009 return h
->root
.u
.c
.p
->section
->owner
== input_bfd
;
3011 case bfd_link_hash_undefined
:
3012 case bfd_link_hash_undefweak
:
3013 /* We can't treat undef.abfd as the owner because that bfd
3014 might be a dynamic object. Allow any bfd to claim it. */
3023 xcoff_build_ldsyms (struct xcoff_link_hash_entry
*h
, void * p
)
3025 struct xcoff_loader_info
*ldinfo
= (struct xcoff_loader_info
*) p
;
3028 if (h
->root
.type
== bfd_link_hash_warning
)
3029 h
= (struct xcoff_link_hash_entry
*) h
->root
.u
.i
.link
;
3031 /* __rtinit, this symbol has special handling. */
3032 if (h
->flags
& XCOFF_RTINIT
)
3035 /* If this is a final link, and the symbol was defined as a common
3036 symbol in a regular object file, and there was no definition in
3037 any dynamic object, then the linker will have allocated space for
3038 the symbol in a common section but the XCOFF_DEF_REGULAR flag
3039 will not have been set. */
3040 if (h
->root
.type
== bfd_link_hash_defined
3041 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
3042 && (h
->flags
& XCOFF_REF_REGULAR
) != 0
3043 && (h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
3044 && (bfd_is_abs_section (h
->root
.u
.def
.section
)
3045 || (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0))
3046 h
->flags
|= XCOFF_DEF_REGULAR
;
3048 /* If all defined symbols should be exported, mark them now. We
3049 don't want to export the actual functions, just the function
3051 if (xcoff_auto_export_p (h
, ldinfo
->auto_export_flags
))
3052 h
->flags
|= XCOFF_EXPORT
;
3054 /* We don't want to garbage collect symbols which are not defined in
3055 XCOFF files. This is a convenient place to mark them. */
3056 if (xcoff_hash_table (ldinfo
->info
)->gc
3057 && (h
->flags
& XCOFF_MARK
) == 0
3058 && (h
->root
.type
== bfd_link_hash_defined
3059 || h
->root
.type
== bfd_link_hash_defweak
)
3060 && (h
->root
.u
.def
.section
->owner
== NULL
3061 || (h
->root
.u
.def
.section
->owner
->xvec
3062 != ldinfo
->info
->output_bfd
->xvec
)))
3063 h
->flags
|= XCOFF_MARK
;
3065 /* If this symbol is exported, but not defined, we need to try to
3067 if ((h
->flags
& XCOFF_EXPORT
) != 0
3068 && (h
->flags
& XCOFF_WAS_UNDEFINED
) != 0)
3070 (*_bfd_error_handler
)
3071 (_("warning: attempt to export undefined symbol `%s'"),
3072 h
->root
.root
.string
);
3077 /* If this is still a common symbol, and it wasn't garbage
3078 collected, we need to actually allocate space for it in the .bss
3080 if (h
->root
.type
== bfd_link_hash_common
3081 && (! xcoff_hash_table (ldinfo
->info
)->gc
3082 || (h
->flags
& XCOFF_MARK
) != 0)
3083 && h
->root
.u
.c
.p
->section
->size
== 0)
3085 BFD_ASSERT (bfd_is_com_section (h
->root
.u
.c
.p
->section
));
3086 h
->root
.u
.c
.p
->section
->size
= h
->root
.u
.c
.size
;
3089 /* We need to add a symbol to the .loader section if it is mentioned
3090 in a reloc which we are copying to the .loader section and it was
3091 not defined or common, or if it is the entry point, or if it is
3094 if (((h
->flags
& XCOFF_LDREL
) == 0
3095 || h
->root
.type
== bfd_link_hash_defined
3096 || h
->root
.type
== bfd_link_hash_defweak
3097 || h
->root
.type
== bfd_link_hash_common
)
3098 && (h
->flags
& XCOFF_ENTRY
) == 0
3099 && (h
->flags
& XCOFF_EXPORT
) == 0)
3105 /* We don't need to add this symbol if we did garbage collection and
3106 we did not mark this symbol. */
3107 if (xcoff_hash_table (ldinfo
->info
)->gc
3108 && (h
->flags
& XCOFF_MARK
) == 0)
3114 /* We may have already processed this symbol due to the recursive
3116 if ((h
->flags
& XCOFF_BUILT_LDSYM
) != 0)
3119 /* We need to add this symbol to the .loader symbols. */
3121 BFD_ASSERT (h
->ldsym
== NULL
);
3122 amt
= sizeof (struct internal_ldsym
);
3123 h
->ldsym
= bfd_zalloc (ldinfo
->output_bfd
, amt
);
3124 if (h
->ldsym
== NULL
)
3126 ldinfo
->failed
= TRUE
;
3130 if ((h
->flags
& XCOFF_IMPORT
) != 0)
3132 /* Give imported descriptors class XMC_DS rather than XMC_UA. */
3133 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
3135 h
->ldsym
->l_ifile
= h
->ldindx
;
3138 /* The first 3 symbol table indices are reserved to indicate the
3139 data, text and bss sections. */
3140 h
->ldindx
= ldinfo
->ldsym_count
+ 3;
3142 ++ldinfo
->ldsym_count
;
3144 if (! bfd_xcoff_put_ldsymbol_name (ldinfo
->output_bfd
, ldinfo
,
3145 h
->ldsym
, h
->root
.root
.string
))
3148 h
->flags
|= XCOFF_BUILT_LDSYM
;
3153 /* INPUT_BFD includes XCOFF symbol ISYM, which is associated with linker
3154 hash table entry H and csect CSECT. AUX contains ISYM's auxillary
3155 csect information, if any. NAME is the function's name if the name
3156 is stored in the .debug section, otherwise it is null.
3158 Return 1 if we should include an appropriately-adjusted ISYM
3159 in the output file, 0 if we should discard ISYM, or -1 if an
3163 xcoff_keep_symbol_p (struct bfd_link_info
*info
, bfd
*input_bfd
,
3164 struct internal_syment
*isym
,
3165 union internal_auxent
*aux
,
3166 struct xcoff_link_hash_entry
*h
,
3167 asection
*csect
, const char *name
)
3171 /* If we are skipping this csect, we want to strip the symbol too. */
3175 /* Likewise if we garbage-collected the csect. */
3176 if (xcoff_hash_table (info
)->gc
3177 && !bfd_is_abs_section (csect
)
3178 && !bfd_is_und_section (csect
)
3179 && (csect
->flags
& SEC_MARK
) == 0)
3182 /* An XCOFF linker always removes C_STAT symbols. */
3183 if (isym
->n_sclass
== C_STAT
)
3186 /* We generate the TOC anchor separately. */
3187 if (isym
->n_sclass
== C_HIDEXT
3188 && aux
->x_csect
.x_smclas
== XMC_TC0
)
3191 /* If we are stripping all symbols, we want to discard this one. */
3192 if (info
->strip
== strip_all
)
3195 /* Discard symbols that are defined elsewhere. */
3196 if (EXTERN_SYM_P (isym
->n_sclass
))
3198 if ((h
->flags
& XCOFF_ALLOCATED
) != 0)
3200 if (!xcoff_final_definition_p (input_bfd
, h
, csect
))
3204 /* If we're discarding local symbols, check whether ISYM is local. */
3205 smtyp
= SMTYP_SMTYP (aux
->x_csect
.x_smtyp
);
3206 if (info
->discard
== discard_all
3207 && !EXTERN_SYM_P (isym
->n_sclass
)
3208 && (isym
->n_sclass
!= C_HIDEXT
|| smtyp
!= XTY_SD
))
3211 /* If we're stripping debugging symbols, check whether ISYM is one. */
3212 if (info
->strip
== strip_debugger
3213 && isym
->n_scnum
== N_DEBUG
)
3216 /* If we are stripping symbols based on name, check how ISYM's
3217 name should be handled. */
3218 if (info
->strip
== strip_some
3219 || info
->discard
== discard_l
)
3221 char buf
[SYMNMLEN
+ 1];
3225 name
= _bfd_coff_internal_syment_name (input_bfd
, isym
, buf
);
3230 if (info
->strip
== strip_some
3231 && bfd_hash_lookup (info
->keep_hash
, name
, FALSE
, FALSE
) == NULL
)
3234 if (info
->discard
== discard_l
3235 && !EXTERN_SYM_P (isym
->n_sclass
)
3236 && (isym
->n_sclass
!= C_HIDEXT
|| smtyp
!= XTY_SD
)
3237 && bfd_is_local_label_name (input_bfd
, name
))
3244 /* Build the .loader section. This is called by the XCOFF linker
3245 emulation before_allocation routine. We must set the size of the
3246 .loader section before the linker lays out the output file.
3247 LIBPATH is the library path to search for shared objects; this is
3248 normally built from the -L arguments passed to the linker. ENTRY
3249 is the name of the entry point symbol (the -e linker option).
3250 FILE_ALIGN is the alignment to use for sections within the file
3251 (the -H linker option). MAXSTACK is the maximum stack size (the
3252 -bmaxstack linker option). MAXDATA is the maximum data size (the
3253 -bmaxdata linker option). GC is whether to do garbage collection
3254 (the -bgc linker option). MODTYPE is the module type (the
3255 -bmodtype linker option). TEXTRO is whether the text section must
3256 be read only (the -btextro linker option). AUTO_EXPORT_FLAGS
3257 is a mask of XCOFF_EXPALL and XCOFF_EXPFULL. SPECIAL_SECTIONS
3258 is set by this routine to csects with magic names like _end. */
3261 bfd_xcoff_size_dynamic_sections (bfd
*output_bfd
,
3262 struct bfd_link_info
*info
,
3263 const char *libpath
,
3265 unsigned long file_align
,
3266 unsigned long maxstack
,
3267 unsigned long maxdata
,
3271 unsigned int auto_export_flags
,
3272 asection
**special_sections
,
3276 struct xcoff_loader_info ldinfo
;
3278 size_t impsize
, impcount
;
3279 struct xcoff_import_file
*fl
;
3280 struct internal_ldhdr
*ldhdr
;
3281 bfd_size_type stoff
;
3285 struct bfd_strtab_hash
*debug_strtab
;
3286 bfd_byte
*debug_contents
= NULL
;
3289 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
3291 for (i
= 0; i
< XCOFF_NUMBER_OF_SPECIAL_SECTIONS
; i
++)
3292 special_sections
[i
] = NULL
;
3296 ldinfo
.failed
= FALSE
;
3297 ldinfo
.output_bfd
= output_bfd
;
3299 ldinfo
.auto_export_flags
= auto_export_flags
;
3300 ldinfo
.ldsym_count
= 0;
3301 ldinfo
.string_size
= 0;
3302 ldinfo
.strings
= NULL
;
3303 ldinfo
.string_alc
= 0;
3305 xcoff_data (output_bfd
)->maxstack
= maxstack
;
3306 xcoff_data (output_bfd
)->maxdata
= maxdata
;
3307 xcoff_data (output_bfd
)->modtype
= modtype
;
3309 xcoff_hash_table (info
)->file_align
= file_align
;
3310 xcoff_hash_table (info
)->textro
= textro
;
3311 xcoff_hash_table (info
)->rtld
= rtld
;
3314 if (info
->init_function
|| info
->fini_function
|| rtld
)
3316 struct xcoff_link_hash_entry
*hsym
;
3317 struct internal_ldsym
*ldsym
;
3319 hsym
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
3320 "__rtinit", FALSE
, FALSE
, TRUE
);
3323 (*_bfd_error_handler
)
3324 (_("error: undefined symbol __rtinit"));
3328 xcoff_mark_symbol (info
, hsym
);
3329 hsym
->flags
|= (XCOFF_DEF_REGULAR
| XCOFF_RTINIT
);
3331 /* __rtinit initialized. */
3332 amt
= sizeof (* ldsym
);
3333 ldsym
= bfd_malloc (amt
);
3335 ldsym
->l_value
= 0; /* Will be filled in later. */
3336 ldsym
->l_scnum
= 2; /* Data section. */
3337 ldsym
->l_smtype
= XTY_SD
; /* Csect section definition. */
3338 ldsym
->l_smclas
= 5; /* .rw. */
3339 ldsym
->l_ifile
= 0; /* Special system loader symbol. */
3340 ldsym
->l_parm
= 0; /* NA. */
3342 /* Force __rtinit to be the first symbol in the loader symbol table
3343 See xcoff_build_ldsyms
3345 The first 3 symbol table indices are reserved to indicate the data,
3346 text and bss sections. */
3347 BFD_ASSERT (0 == ldinfo
.ldsym_count
);
3350 ldinfo
.ldsym_count
= 1;
3351 hsym
->ldsym
= ldsym
;
3353 if (! bfd_xcoff_put_ldsymbol_name (ldinfo
.output_bfd
, &ldinfo
,
3354 hsym
->ldsym
, hsym
->root
.root
.string
))
3357 /* This symbol is written out by xcoff_write_global_symbol
3358 Set stuff up so xcoff_write_global_symbol logic works. */
3359 hsym
->flags
|= XCOFF_DEF_REGULAR
| XCOFF_MARK
;
3360 hsym
->root
.type
= bfd_link_hash_defined
;
3361 hsym
->root
.u
.def
.value
= 0;
3364 /* Garbage collect unused sections. */
3365 if (info
->relocatable
|| !gc
)
3368 xcoff_hash_table (info
)->gc
= FALSE
;
3370 /* We still need to call xcoff_mark, in order to set ldrel_count
3372 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3376 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3378 /* We shouldn't unconditionaly mark the TOC section.
3379 The output file should only have a TOC if either
3380 (a) one of the input files did or (b) we end up
3381 creating TOC references as part of the link process. */
3382 if (o
!= xcoff_hash_table (info
)->toc_section
3383 && (o
->flags
& SEC_MARK
) == 0)
3385 if (! xcoff_mark (info
, o
))
3394 && !xcoff_mark_symbol_by_name (info
, entry
, XCOFF_ENTRY
))
3396 if (info
->init_function
!= NULL
3397 && !xcoff_mark_symbol_by_name (info
, info
->init_function
, 0))
3399 if (info
->fini_function
!= NULL
3400 && !xcoff_mark_symbol_by_name (info
, info
->fini_function
, 0))
3402 if (auto_export_flags
!= 0)
3404 xcoff_link_hash_traverse (xcoff_hash_table (info
),
3405 xcoff_mark_auto_exports
, &ldinfo
);
3410 xcoff_hash_table (info
)->gc
= TRUE
;
3413 /* Return special sections to the caller. */
3414 for (i
= 0; i
< XCOFF_NUMBER_OF_SPECIAL_SECTIONS
; i
++)
3416 sec
= xcoff_hash_table (info
)->special_sections
[i
];
3420 && (sec
->flags
& SEC_MARK
) == 0)
3423 special_sections
[i
] = sec
;
3426 if (info
->input_bfds
== NULL
)
3427 /* I'm not sure what to do in this bizarre case. */
3430 xcoff_link_hash_traverse (xcoff_hash_table (info
), xcoff_build_ldsyms
,
3435 /* Work out the size of the import file names. Each import file ID
3436 consists of three null terminated strings: the path, the file
3437 name, and the archive member name. The first entry in the list
3438 of names is the path to use to find objects, which the linker has
3439 passed in as the libpath argument. For some reason, the path
3440 entry in the other import file names appears to always be empty. */
3441 impsize
= strlen (libpath
) + 3;
3443 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
3446 impsize
+= (strlen (fl
->path
)
3448 + strlen (fl
->member
)
3452 /* Set up the .loader section header. */
3453 ldhdr
= &xcoff_hash_table (info
)->ldhdr
;
3454 ldhdr
->l_version
= bfd_xcoff_ldhdr_version(output_bfd
);
3455 ldhdr
->l_nsyms
= ldinfo
.ldsym_count
;
3456 ldhdr
->l_nreloc
= xcoff_hash_table (info
)->ldrel_count
;
3457 ldhdr
->l_istlen
= impsize
;
3458 ldhdr
->l_nimpid
= impcount
;
3459 ldhdr
->l_impoff
= (bfd_xcoff_ldhdrsz(output_bfd
)
3460 + ldhdr
->l_nsyms
* bfd_xcoff_ldsymsz(output_bfd
)
3461 + ldhdr
->l_nreloc
* bfd_xcoff_ldrelsz(output_bfd
));
3462 ldhdr
->l_stlen
= ldinfo
.string_size
;
3463 stoff
= ldhdr
->l_impoff
+ impsize
;
3464 if (ldinfo
.string_size
== 0)
3467 ldhdr
->l_stoff
= stoff
;
3469 /* 64 bit elements to ldhdr
3470 The swap out routine for 32 bit will ignore them.
3471 Nothing fancy, symbols come after the header and relocs come
3473 ldhdr
->l_symoff
= bfd_xcoff_ldhdrsz (output_bfd
);
3474 ldhdr
->l_rldoff
= (bfd_xcoff_ldhdrsz (output_bfd
)
3475 + ldhdr
->l_nsyms
* bfd_xcoff_ldsymsz (output_bfd
));
3477 /* We now know the final size of the .loader section. Allocate
3479 lsec
= xcoff_hash_table (info
)->loader_section
;
3480 lsec
->size
= stoff
+ ldhdr
->l_stlen
;
3481 lsec
->contents
= bfd_zalloc (output_bfd
, lsec
->size
);
3482 if (lsec
->contents
== NULL
)
3485 /* Set up the header. */
3486 bfd_xcoff_swap_ldhdr_out (output_bfd
, ldhdr
, lsec
->contents
);
3488 /* Set up the import file names. */
3489 out
= (char *) lsec
->contents
+ ldhdr
->l_impoff
;
3490 strcpy (out
, libpath
);
3491 out
+= strlen (libpath
) + 1;
3494 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
3499 while ((*out
++ = *s
++) != '\0')
3502 while ((*out
++ = *s
++) != '\0')
3505 while ((*out
++ = *s
++) != '\0')
3509 BFD_ASSERT ((bfd_size_type
) ((bfd_byte
*) out
- lsec
->contents
) == stoff
);
3511 /* Set up the symbol string table. */
3512 if (ldinfo
.string_size
> 0)
3514 memcpy (out
, ldinfo
.strings
, ldinfo
.string_size
);
3515 free (ldinfo
.strings
);
3516 ldinfo
.strings
= NULL
;
3519 /* We can't set up the symbol table or the relocs yet, because we
3520 don't yet know the final position of the various sections. The
3521 .loader symbols are written out when the corresponding normal
3522 symbols are written out in xcoff_link_input_bfd or
3523 xcoff_write_global_symbol. The .loader relocs are written out
3524 when the corresponding normal relocs are handled in
3525 xcoff_link_input_bfd. */
3527 /* Allocate space for the magic sections. */
3528 sec
= xcoff_hash_table (info
)->linkage_section
;
3531 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
3532 if (sec
->contents
== NULL
)
3535 sec
= xcoff_hash_table (info
)->toc_section
;
3538 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
3539 if (sec
->contents
== NULL
)
3542 sec
= xcoff_hash_table (info
)->descriptor_section
;
3545 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
3546 if (sec
->contents
== NULL
)
3550 /* Now that we've done garbage collection, decide which symbols to keep,
3551 and figure out the contents of the .debug section. */
3552 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
3554 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3557 bfd_size_type symcount
;
3560 unsigned int *lineno_counts
;
3561 struct xcoff_link_hash_entry
**sym_hash
;
3562 bfd_byte
*esym
, *esymend
;
3563 bfd_size_type symesz
;
3565 if (sub
->xvec
!= info
->output_bfd
->xvec
)
3568 if ((sub
->flags
& DYNAMIC
) != 0
3569 && !info
->static_link
)
3572 if (! _bfd_coff_get_external_symbols (sub
))
3575 symcount
= obj_raw_syment_count (sub
);
3576 debug_index
= bfd_zalloc (sub
, symcount
* sizeof (long));
3577 if (debug_index
== NULL
)
3579 xcoff_data (sub
)->debug_indices
= debug_index
;
3581 if (info
->strip
== strip_all
3582 || info
->strip
== strip_debugger
3583 || info
->discard
== discard_all
)
3584 /* We're stripping all debugging information, so there's no need
3585 to read SUB's .debug section. */
3589 /* Grab the contents of SUB's .debug section, if any. */
3590 subdeb
= bfd_get_section_by_name (sub
, ".debug");
3591 if (subdeb
!= NULL
&& subdeb
->size
> 0)
3593 /* We use malloc and copy the names into the debug
3594 stringtab, rather than bfd_alloc, because I expect
3595 that, when linking many files together, many of the
3596 strings will be the same. Storing the strings in the
3597 hash table should save space in this case. */
3598 if (!bfd_malloc_and_get_section (sub
, subdeb
, &debug_contents
))
3603 csectpp
= xcoff_data (sub
)->csects
;
3604 lineno_counts
= xcoff_data (sub
)->lineno_counts
;
3605 sym_hash
= obj_xcoff_sym_hashes (sub
);
3606 symesz
= bfd_coff_symesz (sub
);
3607 esym
= (bfd_byte
*) obj_coff_external_syms (sub
);
3608 esymend
= esym
+ symcount
* symesz
;
3610 while (esym
< esymend
)
3612 struct internal_syment sym
;
3613 union internal_auxent aux
;
3618 bfd_coff_swap_sym_in (sub
, esym
, &sym
);
3620 /* Read in the csect information, if any. */
3621 if (CSECT_SYM_P (sym
.n_sclass
))
3623 BFD_ASSERT (sym
.n_numaux
> 0);
3624 bfd_coff_swap_aux_in (sub
, esym
+ symesz
* sym
.n_numaux
,
3625 sym
.n_type
, sym
.n_sclass
,
3626 sym
.n_numaux
- 1, sym
.n_numaux
, &aux
);
3629 /* If this symbol's name is stored in the debug section,
3630 get a pointer to it. */
3631 if (debug_contents
!= NULL
3632 && sym
._n
._n_n
._n_zeroes
== 0
3633 && bfd_coff_symname_in_debug (sub
, &sym
))
3634 name
= (const char *) debug_contents
+ sym
._n
._n_n
._n_offset
;
3638 /* Decide whether to copy this symbol to the output file. */
3640 keep_p
= xcoff_keep_symbol_p (info
, sub
, &sym
, &aux
,
3641 *sym_hash
, csect
, name
);
3646 /* Use a debug_index of -2 to record that a symbol should
3651 /* See whether we should store the symbol name in the
3652 output .debug section. */
3657 indx
= _bfd_stringtab_add (debug_strtab
, name
, TRUE
, TRUE
);
3658 if (indx
== (bfd_size_type
) -1)
3660 *debug_index
= indx
;
3665 (*sym_hash
)->flags
|= XCOFF_ALLOCATED
;
3666 if (*lineno_counts
> 0)
3667 csect
->output_section
->lineno_count
+= *lineno_counts
;
3670 esym
+= (sym
.n_numaux
+ 1) * symesz
;
3671 csectpp
+= sym
.n_numaux
+ 1;
3672 sym_hash
+= sym
.n_numaux
+ 1;
3673 lineno_counts
+= sym
.n_numaux
+ 1;
3674 debug_index
+= sym
.n_numaux
+ 1;
3679 free (debug_contents
);
3680 debug_contents
= NULL
;
3682 /* Clear the size of subdeb, so that it is not included directly
3683 in the output file. */
3687 if (! info
->keep_memory
)
3689 if (! _bfd_coff_free_symbols (sub
))
3694 if (info
->strip
!= strip_all
)
3695 xcoff_hash_table (info
)->debug_section
->size
=
3696 _bfd_stringtab_size (debug_strtab
);
3701 if (ldinfo
.strings
!= NULL
)
3702 free (ldinfo
.strings
);
3703 if (debug_contents
!= NULL
)
3704 free (debug_contents
);
3709 bfd_xcoff_link_generate_rtinit (bfd
*abfd
,
3714 struct bfd_in_memory
*bim
;
3716 bim
= bfd_malloc ((bfd_size_type
) sizeof (* bim
));
3723 abfd
->link_next
= 0;
3724 abfd
->format
= bfd_object
;
3725 abfd
->iostream
= (void *) bim
;
3726 abfd
->flags
= BFD_IN_MEMORY
;
3727 abfd
->direction
= write_direction
;
3730 if (! bfd_xcoff_generate_rtinit (abfd
, init
, fini
, rtld
))
3733 /* need to reset to unknown or it will not be read back in correctly */
3734 abfd
->format
= bfd_unknown
;
3735 abfd
->direction
= read_direction
;
3741 /* Link an input file into the linker output file. This function
3742 handles all the sections and relocations of the input file at once. */
3745 xcoff_link_input_bfd (struct xcoff_final_link_info
*finfo
,
3749 const char *strings
;
3750 bfd_size_type syment_base
;
3751 unsigned int n_tmask
;
3752 unsigned int n_btshft
;
3753 bfd_boolean copy
, hash
;
3754 bfd_size_type isymesz
;
3755 bfd_size_type osymesz
;
3756 bfd_size_type linesz
;
3759 struct xcoff_link_hash_entry
**sym_hash
;
3760 struct internal_syment
*isymp
;
3762 unsigned int *lineno_counts
;
3765 unsigned long output_index
;
3769 bfd_boolean keep_syms
;
3772 /* We can just skip DYNAMIC files, unless this is a static link. */
3773 if ((input_bfd
->flags
& DYNAMIC
) != 0
3774 && ! finfo
->info
->static_link
)
3777 /* Move all the symbols to the output file. */
3778 output_bfd
= finfo
->output_bfd
;
3780 syment_base
= obj_raw_syment_count (output_bfd
);
3781 isymesz
= bfd_coff_symesz (input_bfd
);
3782 osymesz
= bfd_coff_symesz (output_bfd
);
3783 linesz
= bfd_coff_linesz (input_bfd
);
3784 BFD_ASSERT (linesz
== bfd_coff_linesz (output_bfd
));
3786 n_tmask
= coff_data (input_bfd
)->local_n_tmask
;
3787 n_btshft
= coff_data (input_bfd
)->local_n_btshft
;
3789 /* Define macros so that ISFCN, et. al., macros work correctly. */
3790 #define N_TMASK n_tmask
3791 #define N_BTSHFT n_btshft
3794 if (! finfo
->info
->keep_memory
)
3797 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
3800 if (! _bfd_coff_get_external_symbols (input_bfd
))
3803 /* Make one pass over the symbols and assign indices to symbols that
3804 we have decided to keep. Also use create .loader symbol information
3805 and update information in hash table entries. */
3806 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
3807 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
3808 sym_hash
= obj_xcoff_sym_hashes (input_bfd
);
3809 csectpp
= xcoff_data (input_bfd
)->csects
;
3810 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
3811 isymp
= finfo
->internal_syms
;
3812 indexp
= finfo
->sym_indices
;
3813 output_index
= syment_base
;
3814 while (esym
< esym_end
)
3816 union internal_auxent aux
;
3820 bfd_coff_swap_sym_in (input_bfd
, (void *) esym
, (void *) isymp
);
3822 /* Read in the csect information, if any. */
3823 if (CSECT_SYM_P (isymp
->n_sclass
))
3825 BFD_ASSERT (isymp
->n_numaux
> 0);
3826 bfd_coff_swap_aux_in (input_bfd
,
3827 (void *) (esym
+ isymesz
* isymp
->n_numaux
),
3828 isymp
->n_type
, isymp
->n_sclass
,
3829 isymp
->n_numaux
- 1, isymp
->n_numaux
,
3832 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
3835 /* If this symbol is in the .loader section, swap out the
3836 .loader symbol information. If this is an external symbol
3837 reference to a defined symbol, though, then wait until we get
3838 to the definition. */
3839 if (EXTERN_SYM_P (isymp
->n_sclass
)
3840 && *sym_hash
!= NULL
3841 && (*sym_hash
)->ldsym
!= NULL
3842 && xcoff_final_definition_p (input_bfd
, *sym_hash
, *csectpp
))
3844 struct xcoff_link_hash_entry
*h
;
3845 struct internal_ldsym
*ldsym
;
3849 if (isymp
->n_scnum
> 0)
3851 ldsym
->l_scnum
= (*csectpp
)->output_section
->target_index
;
3852 ldsym
->l_value
= (isymp
->n_value
3853 + (*csectpp
)->output_section
->vma
3854 + (*csectpp
)->output_offset
3859 ldsym
->l_scnum
= isymp
->n_scnum
;
3860 ldsym
->l_value
= isymp
->n_value
;
3863 ldsym
->l_smtype
= smtyp
;
3864 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
3865 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
3866 || (h
->flags
& XCOFF_IMPORT
) != 0)
3867 ldsym
->l_smtype
|= L_IMPORT
;
3868 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
3869 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
3870 || (h
->flags
& XCOFF_EXPORT
) != 0)
3871 ldsym
->l_smtype
|= L_EXPORT
;
3872 if ((h
->flags
& XCOFF_ENTRY
) != 0)
3873 ldsym
->l_smtype
|= L_ENTRY
;
3874 if (isymp
->n_sclass
== C_AIX_WEAKEXT
)
3875 ldsym
->l_smtype
|= L_WEAK
;
3877 ldsym
->l_smclas
= aux
.x_csect
.x_smclas
;
3879 if (ldsym
->l_ifile
== (bfd_size_type
) -1)
3881 else if (ldsym
->l_ifile
== 0)
3883 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
3889 if (h
->root
.type
== bfd_link_hash_defined
3890 || h
->root
.type
== bfd_link_hash_defweak
)
3891 impbfd
= h
->root
.u
.def
.section
->owner
;
3892 else if (h
->root
.type
== bfd_link_hash_undefined
3893 || h
->root
.type
== bfd_link_hash_undefweak
)
3894 impbfd
= h
->root
.u
.undef
.abfd
;
3902 BFD_ASSERT (impbfd
->xvec
== finfo
->output_bfd
->xvec
);
3903 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
3910 BFD_ASSERT (h
->ldindx
>= 0);
3911 bfd_xcoff_swap_ldsym_out (finfo
->output_bfd
, ldsym
,
3914 * bfd_xcoff_ldsymsz (finfo
->output_bfd
))));
3917 /* Fill in snentry now that we know the target_index. */
3918 if ((h
->flags
& XCOFF_ENTRY
) != 0
3919 && (h
->root
.type
== bfd_link_hash_defined
3920 || h
->root
.type
== bfd_link_hash_defweak
))
3922 xcoff_data (output_bfd
)->snentry
=
3923 h
->root
.u
.def
.section
->output_section
->target_index
;
3927 add
= 1 + isymp
->n_numaux
;
3929 if (*debug_index
== -2)
3930 /* We've decided to strip this symbol. */
3934 /* Assign the next unused index to this symbol. */
3935 *indexp
= output_index
;
3937 if (EXTERN_SYM_P (isymp
->n_sclass
))
3939 BFD_ASSERT (*sym_hash
!= NULL
);
3940 (*sym_hash
)->indx
= output_index
;
3943 /* If this is a symbol in the TOC which we may have merged
3944 (class XMC_TC), remember the symbol index of the TOC
3946 if (isymp
->n_sclass
== C_HIDEXT
3947 && aux
.x_csect
.x_smclas
== XMC_TC
3948 && *sym_hash
!= NULL
)
3950 BFD_ASSERT (((*sym_hash
)->flags
& XCOFF_SET_TOC
) == 0);
3951 BFD_ASSERT ((*sym_hash
)->toc_section
!= NULL
);
3952 (*sym_hash
)->u
.toc_indx
= output_index
;
3955 output_index
+= add
;
3958 esym
+= add
* isymesz
;
3964 for (--add
; add
> 0; --add
)
3968 /* Now write out the symbols that we decided to keep. */
3970 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
3971 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
3972 isymp
= finfo
->internal_syms
;
3973 indexp
= finfo
->sym_indices
;
3974 csectpp
= xcoff_data (input_bfd
)->csects
;
3975 lineno_counts
= xcoff_data (input_bfd
)->lineno_counts
;
3976 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
3977 outsym
= finfo
->outsyms
;
3980 while (esym
< esym_end
)
3984 add
= 1 + isymp
->n_numaux
;
3987 esym
+= add
* isymesz
;
3990 struct internal_syment isym
;
3993 /* Adjust the symbol in order to output it. */
3995 if (isym
._n
._n_n
._n_zeroes
== 0
3996 && isym
._n
._n_n
._n_offset
!= 0)
3998 /* This symbol has a long name. Enter it in the string
3999 table we are building. If *debug_index != -1, the
4000 name has already been entered in the .debug section. */
4001 if (*debug_index
>= 0)
4002 isym
._n
._n_n
._n_offset
= *debug_index
;
4008 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, NULL
);
4012 indx
= _bfd_stringtab_add (finfo
->strtab
, name
, hash
, copy
);
4013 if (indx
== (bfd_size_type
) -1)
4015 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
4019 /* The value of a C_FILE symbol is the symbol index of the
4020 next C_FILE symbol. The value of the last C_FILE symbol
4021 is -1. We try to get this right, below, just before we
4022 write the symbols out, but in the general case we may
4023 have to write the symbol out twice. */
4024 if (isym
.n_sclass
== C_FILE
)
4026 if (finfo
->last_file_index
!= -1
4027 && finfo
->last_file
.n_value
!= (bfd_vma
) *indexp
)
4029 /* We must correct the value of the last C_FILE entry. */
4030 finfo
->last_file
.n_value
= *indexp
;
4031 if ((bfd_size_type
) finfo
->last_file_index
>= syment_base
)
4033 /* The last C_FILE symbol is in this input file. */
4034 bfd_coff_swap_sym_out (output_bfd
,
4035 (void *) &finfo
->last_file
,
4036 (void *) (finfo
->outsyms
4037 + ((finfo
->last_file_index
4043 /* We have already written out the last C_FILE
4044 symbol. We need to write it out again. We
4045 borrow *outsym temporarily. */
4048 bfd_coff_swap_sym_out (output_bfd
,
4049 (void *) &finfo
->last_file
,
4052 pos
= obj_sym_filepos (output_bfd
);
4053 pos
+= finfo
->last_file_index
* osymesz
;
4054 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4055 || (bfd_bwrite (outsym
, osymesz
, output_bfd
)
4061 finfo
->last_file_index
= *indexp
;
4062 finfo
->last_file
= isym
;
4065 /* The value of a C_BINCL or C_EINCL symbol is a file offset
4066 into the line numbers. We update the symbol values when
4067 we handle the line numbers. */
4068 if (isym
.n_sclass
== C_BINCL
4069 || isym
.n_sclass
== C_EINCL
)
4071 isym
.n_value
= finfo
->line_filepos
;
4074 /* The value of a C_BSTAT symbol is the symbol table
4075 index of the containing csect. */
4076 else if (isym
.n_sclass
== C_BSTAT
)
4080 indx
= isym
.n_value
;
4081 if (indx
< obj_raw_syment_count (input_bfd
))
4085 symindx
= finfo
->sym_indices
[indx
];
4089 isym
.n_value
= symindx
;
4092 else if (isym
.n_sclass
!= C_ESTAT
4093 && isym
.n_sclass
!= C_DECL
4094 && isym
.n_scnum
> 0)
4096 isym
.n_scnum
= (*csectpp
)->output_section
->target_index
;
4097 isym
.n_value
+= ((*csectpp
)->output_section
->vma
4098 + (*csectpp
)->output_offset
4102 /* Output the symbol. */
4103 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
4108 for (i
= 0; i
< isymp
->n_numaux
&& esym
< esym_end
; i
++)
4110 union internal_auxent aux
;
4112 bfd_coff_swap_aux_in (input_bfd
, (void *) esym
, isymp
->n_type
,
4113 isymp
->n_sclass
, i
, isymp
->n_numaux
,
4116 if (isymp
->n_sclass
== C_FILE
)
4118 /* This is the file name (or some comment put in by
4119 the compiler). If it is long, we must put it in
4120 the string table. */
4121 if (aux
.x_file
.x_n
.x_zeroes
== 0
4122 && aux
.x_file
.x_n
.x_offset
!= 0)
4124 const char *filename
;
4127 BFD_ASSERT (aux
.x_file
.x_n
.x_offset
4128 >= STRING_SIZE_SIZE
);
4129 if (strings
== NULL
)
4131 strings
= _bfd_coff_read_string_table (input_bfd
);
4132 if (strings
== NULL
)
4135 filename
= strings
+ aux
.x_file
.x_n
.x_offset
;
4136 indx
= _bfd_stringtab_add (finfo
->strtab
, filename
,
4138 if (indx
== (bfd_size_type
) -1)
4140 aux
.x_file
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
4143 else if (CSECT_SYM_P (isymp
->n_sclass
)
4144 && i
+ 1 == isymp
->n_numaux
)
4147 /* We don't support type checking. I don't know if
4149 aux
.x_csect
.x_parmhash
= 0;
4150 /* I don't think anybody uses these fields, but we'd
4151 better clobber them just in case. */
4152 aux
.x_csect
.x_stab
= 0;
4153 aux
.x_csect
.x_snstab
= 0;
4155 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_LD
)
4159 indx
= aux
.x_csect
.x_scnlen
.l
;
4160 if (indx
< obj_raw_syment_count (input_bfd
))
4164 symindx
= finfo
->sym_indices
[indx
];
4167 aux
.x_csect
.x_scnlen
.l
= 0;
4171 aux
.x_csect
.x_scnlen
.l
= symindx
;
4176 else if (isymp
->n_sclass
!= C_STAT
|| isymp
->n_type
!= T_NULL
)
4180 if (ISFCN (isymp
->n_type
)
4181 || ISTAG (isymp
->n_sclass
)
4182 || isymp
->n_sclass
== C_BLOCK
4183 || isymp
->n_sclass
== C_FCN
)
4185 indx
= aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
4187 && indx
< obj_raw_syment_count (input_bfd
))
4189 /* We look forward through the symbol for
4190 the index of the next symbol we are going
4191 to include. I don't know if this is
4193 while (finfo
->sym_indices
[indx
] < 0
4194 && indx
< obj_raw_syment_count (input_bfd
))
4196 if (indx
>= obj_raw_syment_count (input_bfd
))
4197 indx
= output_index
;
4199 indx
= finfo
->sym_indices
[indx
];
4200 aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= indx
;
4205 indx
= aux
.x_sym
.x_tagndx
.l
;
4206 if (indx
> 0 && indx
< obj_raw_syment_count (input_bfd
))
4210 symindx
= finfo
->sym_indices
[indx
];
4212 aux
.x_sym
.x_tagndx
.l
= 0;
4214 aux
.x_sym
.x_tagndx
.l
= symindx
;
4219 /* Copy over the line numbers, unless we are stripping
4220 them. We do this on a symbol by symbol basis in
4221 order to more easily handle garbage collection. */
4222 if (CSECT_SYM_P (isymp
->n_sclass
)
4224 && isymp
->n_numaux
> 1
4225 && ISFCN (isymp
->n_type
)
4226 && aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
4228 if (*lineno_counts
== 0)
4229 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
4232 asection
*enclosing
;
4233 unsigned int enc_count
;
4234 bfd_signed_vma linoff
;
4235 struct internal_lineno lin
;
4242 /* Read in the enclosing section's line-number
4243 information, if we haven't already. */
4245 enclosing
= xcoff_section_data (abfd
, o
)->enclosing
;
4246 enc_count
= xcoff_section_data (abfd
, o
)->lineno_count
;
4247 if (oline
!= enclosing
)
4249 pos
= enclosing
->line_filepos
;
4250 amt
= linesz
* enc_count
;
4251 if (bfd_seek (input_bfd
, pos
, SEEK_SET
) != 0
4252 || (bfd_bread (finfo
->linenos
, amt
, input_bfd
)
4258 /* Copy across the first entry, adjusting its
4260 linoff
= (aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
4261 - enclosing
->line_filepos
);
4262 linp
= finfo
->linenos
+ linoff
;
4263 bfd_coff_swap_lineno_in (input_bfd
, linp
, &lin
);
4264 lin
.l_addr
.l_symndx
= *indexp
;
4265 bfd_coff_swap_lineno_out (output_bfd
, &lin
, linp
);
4268 /* Copy the other entries, adjusting their addresses. */
4269 linpend
= linp
+ *lineno_counts
* linesz
;
4270 offset
= (o
->output_section
->vma
4273 for (; linp
< linpend
; linp
+= linesz
)
4275 bfd_coff_swap_lineno_in (input_bfd
, linp
, &lin
);
4276 lin
.l_addr
.l_paddr
+= offset
;
4277 bfd_coff_swap_lineno_out (output_bfd
, &lin
, linp
);
4280 /* Write out the entries we've just processed. */
4281 pos
= (o
->output_section
->line_filepos
4282 + o
->output_section
->lineno_count
* linesz
);
4283 amt
= linesz
* *lineno_counts
;
4284 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4285 || bfd_bwrite (finfo
->linenos
+ linoff
,
4286 amt
, output_bfd
) != amt
)
4288 o
->output_section
->lineno_count
+= *lineno_counts
;
4290 /* Record the offset of the symbol's line numbers
4291 in the output file. */
4292 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= pos
;
4296 struct internal_syment
*iisp
, *iispend
;
4299 bfd_vma range_start
, range_end
;
4302 /* Update any C_BINCL or C_EINCL symbols
4303 that refer to a line number in the
4304 range we just output. */
4305 iisp
= finfo
->internal_syms
;
4306 iispend
= iisp
+ obj_raw_syment_count (input_bfd
);
4307 iindp
= finfo
->sym_indices
;
4308 oos
= finfo
->outsyms
;
4309 range_start
= enclosing
->line_filepos
+ linoff
;
4310 range_end
= range_start
+ *lineno_counts
* linesz
;
4311 while (iisp
< iispend
)
4314 && (iisp
->n_sclass
== C_BINCL
4315 || iisp
->n_sclass
== C_EINCL
)
4316 && iisp
->n_value
>= range_start
4317 && iisp
->n_value
< range_end
)
4319 struct internal_syment iis
;
4321 bfd_coff_swap_sym_in (output_bfd
, oos
, &iis
);
4322 iis
.n_value
= (iisp
->n_value
4325 bfd_coff_swap_sym_out (output_bfd
,
4330 iiadd
= 1 + iisp
->n_numaux
;
4332 oos
+= iiadd
* osymesz
;
4340 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, isymp
->n_type
,
4341 isymp
->n_sclass
, i
, isymp
->n_numaux
,
4351 lineno_counts
+= add
;
4355 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
4356 symbol will be the first symbol in the next input file. In the
4357 normal case, this will save us from writing out the C_FILE symbol
4359 if (finfo
->last_file_index
!= -1
4360 && (bfd_size_type
) finfo
->last_file_index
>= syment_base
)
4362 finfo
->last_file
.n_value
= output_index
;
4363 bfd_coff_swap_sym_out (output_bfd
, (void *) &finfo
->last_file
,
4364 (void *) (finfo
->outsyms
4365 + ((finfo
->last_file_index
- syment_base
)
4369 /* Write the modified symbols to the output file. */
4370 if (outsym
> finfo
->outsyms
)
4372 file_ptr pos
= obj_sym_filepos (output_bfd
) + syment_base
* osymesz
;
4373 bfd_size_type amt
= outsym
- finfo
->outsyms
;
4374 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4375 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
4378 BFD_ASSERT ((obj_raw_syment_count (output_bfd
)
4379 + (outsym
- finfo
->outsyms
) / osymesz
)
4382 obj_raw_syment_count (output_bfd
) = output_index
;
4385 /* Don't let the linker relocation routines discard the symbols. */
4386 keep_syms
= obj_coff_keep_syms (input_bfd
);
4387 obj_coff_keep_syms (input_bfd
) = TRUE
;
4389 /* Relocate the contents of each section. */
4390 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4394 if (! o
->linker_mark
)
4395 /* This section was omitted from the link. */
4398 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
4400 || (o
->flags
& SEC_IN_MEMORY
) != 0)
4403 /* We have set filepos correctly for the sections we created to
4404 represent csects, so bfd_get_section_contents should work. */
4405 if (coff_section_data (input_bfd
, o
) != NULL
4406 && coff_section_data (input_bfd
, o
)->contents
!= NULL
)
4407 contents
= coff_section_data (input_bfd
, o
)->contents
;
4410 bfd_size_type sz
= o
->rawsize
? o
->rawsize
: o
->size
;
4411 if (!bfd_get_section_contents (input_bfd
, o
, finfo
->contents
, 0, sz
))
4413 contents
= finfo
->contents
;
4416 if ((o
->flags
& SEC_RELOC
) != 0)
4419 struct internal_reloc
*internal_relocs
;
4420 struct internal_reloc
*irel
;
4422 struct internal_reloc
*irelend
;
4423 struct xcoff_link_hash_entry
**rel_hash
;
4426 /* Read in the relocs. */
4427 target_index
= o
->output_section
->target_index
;
4428 internal_relocs
= (xcoff_read_internal_relocs
4429 (input_bfd
, o
, FALSE
, finfo
->external_relocs
,
4431 (finfo
->section_info
[target_index
].relocs
4432 + o
->output_section
->reloc_count
)));
4433 if (internal_relocs
== NULL
)
4436 /* Call processor specific code to relocate the section
4438 if (! bfd_coff_relocate_section (output_bfd
, finfo
->info
,
4442 finfo
->internal_syms
,
4443 xcoff_data (input_bfd
)->csects
))
4446 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
4447 irel
= internal_relocs
;
4448 irelend
= irel
+ o
->reloc_count
;
4449 rel_hash
= (finfo
->section_info
[target_index
].rel_hashes
4450 + o
->output_section
->reloc_count
);
4451 for (; irel
< irelend
; irel
++, rel_hash
++)
4453 struct xcoff_link_hash_entry
*h
= NULL
;
4454 struct internal_ldrel ldrel
;
4458 /* Adjust the reloc address and symbol index. */
4460 irel
->r_vaddr
+= offset
;
4462 r_symndx
= irel
->r_symndx
;
4467 h
= obj_xcoff_sym_hashes (input_bfd
)[r_symndx
];
4469 if (r_symndx
!= -1 && finfo
->info
->strip
!= strip_all
)
4472 && h
->smclas
!= XMC_TD
4473 && (irel
->r_type
== R_TOC
4474 || irel
->r_type
== R_GL
4475 || irel
->r_type
== R_TCL
4476 || irel
->r_type
== R_TRL
4477 || irel
->r_type
== R_TRLA
))
4479 /* This is a TOC relative reloc with a symbol
4480 attached. The symbol should be the one which
4481 this reloc is for. We want to make this
4482 reloc against the TOC address of the symbol,
4483 not the symbol itself. */
4484 BFD_ASSERT (h
->toc_section
!= NULL
);
4485 BFD_ASSERT ((h
->flags
& XCOFF_SET_TOC
) == 0);
4486 if (h
->u
.toc_indx
!= -1)
4487 irel
->r_symndx
= h
->u
.toc_indx
;
4490 struct xcoff_toc_rel_hash
*n
;
4491 struct xcoff_link_section_info
*si
;
4495 n
= bfd_alloc (finfo
->output_bfd
, amt
);
4498 si
= finfo
->section_info
+ target_index
;
4499 n
->next
= si
->toc_rel_hashes
;
4502 si
->toc_rel_hashes
= n
;
4507 /* This is a global symbol. */
4509 irel
->r_symndx
= h
->indx
;
4512 /* This symbol is being written at the end
4513 of the file, and we do not yet know the
4514 symbol index. We save the pointer to the
4515 hash table entry in the rel_hash list.
4516 We set the indx field to -2 to indicate
4517 that this symbol must not be stripped. */
4526 indx
= finfo
->sym_indices
[r_symndx
];
4530 struct internal_syment
*is
;
4532 /* Relocations against a TC0 TOC anchor are
4533 automatically transformed to be against
4534 the TOC anchor in the output file. */
4535 is
= finfo
->internal_syms
+ r_symndx
;
4536 if (is
->n_sclass
== C_HIDEXT
4537 && is
->n_numaux
> 0)
4540 union internal_auxent aux
;
4544 obj_coff_external_syms (input_bfd
))
4545 + ((r_symndx
+ is
->n_numaux
)
4547 bfd_coff_swap_aux_in (input_bfd
, auxptr
,
4548 is
->n_type
, is
->n_sclass
,
4552 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_SD
4553 && aux
.x_csect
.x_smclas
== XMC_TC0
)
4554 indx
= finfo
->toc_symindx
;
4559 irel
->r_symndx
= indx
;
4563 struct internal_syment
*is
;
4566 char buf
[SYMNMLEN
+ 1];
4568 /* This reloc is against a symbol we are
4569 stripping. It would be possible to handle
4570 this case, but I don't think it's worth it. */
4571 is
= finfo
->internal_syms
+ r_symndx
;
4573 name
= (_bfd_coff_internal_syment_name
4574 (input_bfd
, is
, buf
));
4579 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
4580 (finfo
->info
, name
, input_bfd
, o
,
4587 switch (irel
->r_type
)
4591 || h
->root
.type
== bfd_link_hash_defined
4592 || h
->root
.type
== bfd_link_hash_defweak
4593 || h
->root
.type
== bfd_link_hash_common
)
4601 && (h
->root
.type
== bfd_link_hash_defined
4602 || h
->root
.type
== bfd_link_hash_defweak
)
4603 && bfd_is_abs_section (h
->root
.u
.def
.section
))
4605 /* This reloc needs to be copied into the .loader
4607 ldrel
.l_vaddr
= irel
->r_vaddr
;
4609 ldrel
.l_symndx
= -(bfd_size_type
) 1;
4611 || (h
->root
.type
== bfd_link_hash_defined
4612 || h
->root
.type
== bfd_link_hash_defweak
4613 || h
->root
.type
== bfd_link_hash_common
))
4618 sec
= xcoff_data (input_bfd
)->csects
[r_symndx
];
4619 else if (h
->root
.type
== bfd_link_hash_common
)
4620 sec
= h
->root
.u
.c
.p
->section
;
4622 sec
= h
->root
.u
.def
.section
;
4623 sec
= sec
->output_section
;
4625 if (strcmp (sec
->name
, ".text") == 0)
4627 else if (strcmp (sec
->name
, ".data") == 0)
4629 else if (strcmp (sec
->name
, ".bss") == 0)
4633 (*_bfd_error_handler
)
4634 (_("%B: loader reloc in unrecognized section `%A'"),
4636 bfd_set_error (bfd_error_nonrepresentable_section
);
4644 (*_bfd_error_handler
)
4645 (_("%B: `%s' in loader reloc but not loader sym"),
4647 h
->root
.root
.string
);
4648 bfd_set_error (bfd_error_bad_value
);
4651 ldrel
.l_symndx
= h
->ldindx
;
4653 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
4654 ldrel
.l_rsecnm
= o
->output_section
->target_index
;
4655 if (xcoff_hash_table (finfo
->info
)->textro
4656 && strcmp (o
->output_section
->name
, ".text") == 0)
4658 (*_bfd_error_handler
)
4659 (_("%B: loader reloc in read-only section %A"),
4660 input_bfd
, o
->output_section
);
4661 bfd_set_error (bfd_error_invalid_operation
);
4664 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
,
4667 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
4675 /* We should never need a .loader reloc for a TOC
4681 o
->output_section
->reloc_count
+= o
->reloc_count
;
4684 /* Write out the modified section contents. */
4685 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
4686 contents
, (file_ptr
) o
->output_offset
,
4691 obj_coff_keep_syms (input_bfd
) = keep_syms
;
4693 if (! finfo
->info
->keep_memory
)
4695 if (! _bfd_coff_free_symbols (input_bfd
))
4705 /* Sort relocs by VMA. This is called via qsort. */
4708 xcoff_sort_relocs (const void * p1
, const void * p2
)
4710 const struct internal_reloc
*r1
= (const struct internal_reloc
*) p1
;
4711 const struct internal_reloc
*r2
= (const struct internal_reloc
*) p2
;
4713 if (r1
->r_vaddr
> r2
->r_vaddr
)
4715 else if (r1
->r_vaddr
< r2
->r_vaddr
)
4721 /* Return true if section SEC is a TOC section. */
4723 static inline bfd_boolean
4724 xcoff_toc_section_p (asection
*sec
)
4729 if (name
[0] == '.' && name
[1] == 't')
4733 if (name
[3] == '0' && name
[4] == 0)
4738 if (name
[2] == 'd' && name
[3] == 0)
4744 /* See if the link requires a TOC (it usually does!). If so, find a
4745 good place to put the TOC anchor csect, and write out the associated
4749 xcoff_find_tc0 (bfd
*output_bfd
, struct xcoff_final_link_info
*finfo
)
4751 bfd_vma toc_start
, toc_end
, start
, end
, best_address
;
4755 struct internal_syment irsym
;
4756 union internal_auxent iraux
;
4760 /* Set [TOC_START, TOC_END) to the range of the TOC. Record the
4761 index of a csect at the beginning of the TOC. */
4762 toc_start
= ~(bfd_vma
) 0;
4765 for (input_bfd
= finfo
->info
->input_bfds
;
4767 input_bfd
= input_bfd
->link_next
)
4768 for (sec
= input_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4769 if ((sec
->flags
& SEC_MARK
) != 0 && xcoff_toc_section_p (sec
))
4771 start
= sec
->output_section
->vma
+ sec
->output_offset
;
4772 if (toc_start
> start
)
4775 section_index
= sec
->output_section
->target_index
;
4778 end
= start
+ sec
->size
;
4783 /* There's no need for a TC0 symbol if we don't have a TOC. */
4784 if (toc_end
< toc_start
)
4786 xcoff_data (output_bfd
)->toc
= toc_start
;
4790 if (toc_end
- toc_start
< 0x8000)
4791 /* Every TOC csect can be accessed from TOC_START. */
4792 best_address
= toc_start
;
4795 /* Find the lowest TOC csect that is still within range of TOC_END. */
4796 best_address
= toc_end
;
4797 for (input_bfd
= finfo
->info
->input_bfds
;
4799 input_bfd
= input_bfd
->link_next
)
4800 for (sec
= input_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4801 if ((sec
->flags
& SEC_MARK
) != 0 && xcoff_toc_section_p (sec
))
4803 start
= sec
->output_section
->vma
+ sec
->output_offset
;
4804 if (start
< best_address
4805 && start
+ 0x8000 >= toc_end
)
4807 best_address
= start
;
4808 section_index
= sec
->output_section
->target_index
;
4812 /* Make sure that the start of the TOC is also within range. */
4813 if (best_address
> toc_start
+ 0x8000)
4815 (*_bfd_error_handler
)
4816 (_("TOC overflow: 0x%lx > 0x10000; try -mminimal-toc "
4818 (unsigned long) (toc_end
- toc_start
));
4819 bfd_set_error (bfd_error_file_too_big
);
4824 /* Record the chosen TOC value. */
4825 finfo
->toc_symindx
= obj_raw_syment_count (output_bfd
);
4826 xcoff_data (output_bfd
)->toc
= best_address
;
4827 xcoff_data (output_bfd
)->sntoc
= section_index
;
4829 /* Fill out the TC0 symbol. */
4830 if (!bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
, &irsym
, "TOC"))
4832 irsym
.n_value
= best_address
;
4833 irsym
.n_scnum
= section_index
;
4834 irsym
.n_sclass
= C_HIDEXT
;
4835 irsym
.n_type
= T_NULL
;
4837 bfd_coff_swap_sym_out (output_bfd
, &irsym
, finfo
->outsyms
);
4839 /* Fill out the auxillary csect information. */
4840 memset (&iraux
, 0, sizeof iraux
);
4841 iraux
.x_csect
.x_smtyp
= XTY_SD
;
4842 iraux
.x_csect
.x_smclas
= XMC_TC0
;
4843 iraux
.x_csect
.x_scnlen
.l
= 0;
4844 bfd_coff_swap_aux_out (output_bfd
, &iraux
, T_NULL
, C_HIDEXT
, 0, 1,
4845 finfo
->outsyms
+ bfd_coff_symesz (output_bfd
));
4847 /* Write the contents to the file. */
4848 pos
= obj_sym_filepos (output_bfd
);
4849 pos
+= obj_raw_syment_count (output_bfd
) * bfd_coff_symesz (output_bfd
);
4850 size
= 2 * bfd_coff_symesz (output_bfd
);
4851 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4852 || bfd_bwrite (finfo
->outsyms
, size
, output_bfd
) != size
)
4854 obj_raw_syment_count (output_bfd
) += 2;
4859 /* Write out a non-XCOFF global symbol. */
4862 xcoff_write_global_symbol (struct xcoff_link_hash_entry
*h
, void * inf
)
4864 struct xcoff_final_link_info
*finfo
= (struct xcoff_final_link_info
*) inf
;
4867 struct internal_syment isym
;
4868 union internal_auxent aux
;
4873 output_bfd
= finfo
->output_bfd
;
4874 outsym
= finfo
->outsyms
;
4876 if (h
->root
.type
== bfd_link_hash_warning
)
4878 h
= (struct xcoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4879 if (h
->root
.type
== bfd_link_hash_new
)
4883 /* If this symbol was garbage collected, just skip it. */
4884 if (xcoff_hash_table (finfo
->info
)->gc
4885 && (h
->flags
& XCOFF_MARK
) == 0)
4888 /* If we need a .loader section entry, write it out. */
4889 if (h
->ldsym
!= NULL
)
4891 struct internal_ldsym
*ldsym
;
4896 if (h
->root
.type
== bfd_link_hash_undefined
4897 || h
->root
.type
== bfd_link_hash_undefweak
)
4901 ldsym
->l_scnum
= N_UNDEF
;
4902 ldsym
->l_smtype
= XTY_ER
;
4903 impbfd
= h
->root
.u
.undef
.abfd
;
4906 else if (h
->root
.type
== bfd_link_hash_defined
4907 || h
->root
.type
== bfd_link_hash_defweak
)
4911 sec
= h
->root
.u
.def
.section
;
4912 ldsym
->l_value
= (sec
->output_section
->vma
4913 + sec
->output_offset
4914 + h
->root
.u
.def
.value
);
4915 ldsym
->l_scnum
= sec
->output_section
->target_index
;
4916 ldsym
->l_smtype
= XTY_SD
;
4917 impbfd
= sec
->owner
;
4923 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
4924 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4925 || (h
->flags
& XCOFF_IMPORT
) != 0)
4927 Import symbols are defined so the check above will make
4928 the l_smtype XTY_SD. But this is not correct, it should
4930 ldsym
->l_smtype
|= L_IMPORT
;
4932 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
4933 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4934 || (h
->flags
& XCOFF_EXPORT
) != 0)
4935 ldsym
->l_smtype
|= L_EXPORT
;
4937 if ((h
->flags
& XCOFF_ENTRY
) != 0)
4938 ldsym
->l_smtype
|= L_ENTRY
;
4940 if ((h
->flags
& XCOFF_RTINIT
) != 0)
4941 ldsym
->l_smtype
= XTY_SD
;
4943 ldsym
->l_smclas
= h
->smclas
;
4945 if (ldsym
->l_smtype
& L_IMPORT
)
4947 if ((h
->root
.type
== bfd_link_hash_defined
4948 || h
->root
.type
== bfd_link_hash_defweak
)
4949 && (h
->root
.u
.def
.value
!= 0))
4950 ldsym
->l_smclas
= XMC_XO
;
4952 else if ((h
->flags
& (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
)) ==
4953 (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
))
4954 ldsym
->l_smclas
= XMC_SV3264
;
4956 else if (h
->flags
& XCOFF_SYSCALL32
)
4957 ldsym
->l_smclas
= XMC_SV
;
4959 else if (h
->flags
& XCOFF_SYSCALL64
)
4960 ldsym
->l_smclas
= XMC_SV64
;
4963 if (ldsym
->l_ifile
== -(bfd_size_type
) 1)
4967 else if (ldsym
->l_ifile
== 0)
4969 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
4971 else if (impbfd
== NULL
)
4975 BFD_ASSERT (impbfd
->xvec
== output_bfd
->xvec
);
4976 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
4982 BFD_ASSERT (h
->ldindx
>= 0);
4984 bfd_xcoff_swap_ldsym_out (output_bfd
, ldsym
,
4987 * bfd_xcoff_ldsymsz(finfo
->output_bfd
)));
4991 /* If this symbol needs global linkage code, write it out. */
4992 if (h
->root
.type
== bfd_link_hash_defined
4993 && (h
->root
.u
.def
.section
4994 == xcoff_hash_table (finfo
->info
)->linkage_section
))
5000 p
= h
->root
.u
.def
.section
->contents
+ h
->root
.u
.def
.value
;
5002 /* The first instruction in the global linkage code loads a
5003 specific TOC element. */
5004 tocoff
= (h
->descriptor
->toc_section
->output_section
->vma
5005 + h
->descriptor
->toc_section
->output_offset
5006 - xcoff_data (output_bfd
)->toc
);
5008 if ((h
->descriptor
->flags
& XCOFF_SET_TOC
) != 0)
5009 tocoff
+= h
->descriptor
->u
.toc_offset
;
5011 /* The first instruction in the glink code needs to be
5012 cooked to to hold the correct offset in the toc. The
5013 rest are just output raw. */
5014 bfd_put_32 (output_bfd
,
5015 bfd_xcoff_glink_code(output_bfd
, 0) | (tocoff
& 0xffff), p
);
5017 /* Start with i == 1 to get past the first instruction done above
5018 The /4 is because the glink code is in bytes and we are going
5020 for (i
= 1; i
< bfd_xcoff_glink_code_size(output_bfd
) / 4; i
++)
5021 bfd_put_32 (output_bfd
,
5022 (bfd_vma
) bfd_xcoff_glink_code(output_bfd
, i
),
5026 /* If we created a TOC entry for this symbol, write out the required
5028 if ((h
->flags
& XCOFF_SET_TOC
) != 0)
5033 struct internal_reloc
*irel
;
5034 struct internal_ldrel ldrel
;
5035 struct internal_syment irsym
;
5036 union internal_auxent iraux
;
5038 tocsec
= h
->toc_section
;
5039 osec
= tocsec
->output_section
;
5040 oindx
= osec
->target_index
;
5041 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
5042 irel
->r_vaddr
= (osec
->vma
5043 + tocsec
->output_offset
5047 irel
->r_symndx
= h
->indx
;
5051 irel
->r_symndx
= obj_raw_syment_count (output_bfd
);
5054 BFD_ASSERT (h
->ldindx
>= 0);
5056 /* Initialize the aux union here instead of closer to when it is
5057 written out below because the length of the csect depends on
5058 whether the output is 32 or 64 bit. */
5059 memset (&iraux
, 0, sizeof iraux
);
5060 iraux
.x_csect
.x_smtyp
= XTY_SD
;
5061 /* iraux.x_csect.x_scnlen.l = 4 or 8, see below. */
5062 iraux
.x_csect
.x_smclas
= XMC_TC
;
5064 /* 32 bit uses a 32 bit R_POS to do the relocations
5065 64 bit uses a 64 bit R_POS to do the relocations
5067 Also needs to change the csect size : 4 for 32 bit, 8 for 64 bit
5069 Which one is determined by the backend. */
5070 if (bfd_xcoff_is_xcoff64 (output_bfd
))
5073 iraux
.x_csect
.x_scnlen
.l
= 8;
5075 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
5078 iraux
.x_csect
.x_scnlen
.l
= 4;
5083 irel
->r_type
= R_POS
;
5084 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5085 ++osec
->reloc_count
;
5087 ldrel
.l_vaddr
= irel
->r_vaddr
;
5088 ldrel
.l_symndx
= h
->ldindx
;
5089 ldrel
.l_rtype
= (irel
->r_size
<< 8) | R_POS
;
5090 ldrel
.l_rsecnm
= oindx
;
5091 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5092 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5094 /* We need to emit a symbol to define a csect which holds
5096 if (finfo
->info
->strip
!= strip_all
)
5098 result
= bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
,
5099 &irsym
, h
->root
.root
.string
);
5103 irsym
.n_value
= irel
->r_vaddr
;
5104 irsym
.n_scnum
= osec
->target_index
;
5105 irsym
.n_sclass
= C_HIDEXT
;
5106 irsym
.n_type
= T_NULL
;
5109 bfd_coff_swap_sym_out (output_bfd
, (void *) &irsym
, (void *) outsym
);
5110 outsym
+= bfd_coff_symesz (output_bfd
);
5112 /* Note : iraux is initialized above. */
5113 bfd_coff_swap_aux_out (output_bfd
, (void *) &iraux
, T_NULL
, C_HIDEXT
,
5114 0, 1, (void *) outsym
);
5115 outsym
+= bfd_coff_auxesz (output_bfd
);
5119 /* We aren't going to write out the symbols below, so we
5120 need to write them out now. */
5121 pos
= obj_sym_filepos (output_bfd
);
5122 pos
+= (obj_raw_syment_count (output_bfd
)
5123 * bfd_coff_symesz (output_bfd
));
5124 amt
= outsym
- finfo
->outsyms
;
5125 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5126 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
5128 obj_raw_syment_count (output_bfd
) +=
5129 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
5131 outsym
= finfo
->outsyms
;
5136 /* If this symbol is a specially defined function descriptor, write
5137 it out. The first word is the address of the function code
5138 itself, the second word is the address of the TOC, and the third
5142 The addresses for the 32 bit will take 4 bytes and the addresses
5143 for 64 bit will take 8 bytes. Similar for the relocs. This type
5144 of logic was also done above to create a TOC entry in
5145 xcoff_write_global_symbol. */
5146 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
5147 && h
->root
.type
== bfd_link_hash_defined
5148 && (h
->root
.u
.def
.section
5149 == xcoff_hash_table (finfo
->info
)->descriptor_section
))
5155 struct xcoff_link_hash_entry
*hentry
;
5157 struct internal_reloc
*irel
;
5158 struct internal_ldrel ldrel
;
5160 unsigned int reloc_size
, byte_size
;
5162 if (bfd_xcoff_is_xcoff64 (output_bfd
))
5167 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
5175 sec
= h
->root
.u
.def
.section
;
5176 osec
= sec
->output_section
;
5177 oindx
= osec
->target_index
;
5178 p
= sec
->contents
+ h
->root
.u
.def
.value
;
5180 hentry
= h
->descriptor
;
5181 BFD_ASSERT (hentry
!= NULL
5182 && (hentry
->root
.type
== bfd_link_hash_defined
5183 || hentry
->root
.type
== bfd_link_hash_defweak
));
5184 esec
= hentry
->root
.u
.def
.section
;
5186 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
5187 irel
->r_vaddr
= (osec
->vma
5188 + sec
->output_offset
5189 + h
->root
.u
.def
.value
);
5190 irel
->r_symndx
= esec
->output_section
->target_index
;
5191 irel
->r_type
= R_POS
;
5192 irel
->r_size
= reloc_size
;
5193 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5194 ++osec
->reloc_count
;
5196 ldrel
.l_vaddr
= irel
->r_vaddr
;
5197 if (strcmp (esec
->output_section
->name
, ".text") == 0)
5199 else if (strcmp (esec
->output_section
->name
, ".data") == 0)
5201 else if (strcmp (esec
->output_section
->name
, ".bss") == 0)
5205 (*_bfd_error_handler
)
5206 (_("%s: loader reloc in unrecognized section `%s'"),
5207 bfd_get_filename (output_bfd
),
5208 esec
->output_section
->name
);
5209 bfd_set_error (bfd_error_nonrepresentable_section
);
5212 ldrel
.l_rtype
= (reloc_size
<< 8) | R_POS
;
5213 ldrel
.l_rsecnm
= oindx
;
5214 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5215 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5217 /* There are three items to write out,
5218 the address of the code
5219 the address of the toc anchor
5220 the environment pointer.
5221 We are ignoring the environment pointer. So set it to zero. */
5222 if (bfd_xcoff_is_xcoff64 (output_bfd
))
5224 bfd_put_64 (output_bfd
,
5225 (esec
->output_section
->vma
+ esec
->output_offset
5226 + hentry
->root
.u
.def
.value
),
5228 bfd_put_64 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 8);
5229 bfd_put_64 (output_bfd
, (bfd_vma
) 0, p
+ 16);
5234 This logic was already called above so the error case where
5235 the backend is neither has already been checked. */
5236 bfd_put_32 (output_bfd
,
5237 (esec
->output_section
->vma
+ esec
->output_offset
5238 + hentry
->root
.u
.def
.value
),
5240 bfd_put_32 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 4);
5241 bfd_put_32 (output_bfd
, (bfd_vma
) 0, p
+ 8);
5244 tsec
= coff_section_from_bfd_index (output_bfd
,
5245 xcoff_data (output_bfd
)->sntoc
);
5248 irel
->r_vaddr
= (osec
->vma
5249 + sec
->output_offset
5250 + h
->root
.u
.def
.value
5252 irel
->r_symndx
= tsec
->output_section
->target_index
;
5253 irel
->r_type
= R_POS
;
5254 irel
->r_size
= reloc_size
;
5255 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5256 ++osec
->reloc_count
;
5258 ldrel
.l_vaddr
= irel
->r_vaddr
;
5259 if (strcmp (tsec
->output_section
->name
, ".text") == 0)
5261 else if (strcmp (tsec
->output_section
->name
, ".data") == 0)
5263 else if (strcmp (tsec
->output_section
->name
, ".bss") == 0)
5267 (*_bfd_error_handler
)
5268 (_("%s: loader reloc in unrecognized section `%s'"),
5269 bfd_get_filename (output_bfd
),
5270 tsec
->output_section
->name
);
5271 bfd_set_error (bfd_error_nonrepresentable_section
);
5274 ldrel
.l_rtype
= (reloc_size
<< 8) | R_POS
;
5275 ldrel
.l_rsecnm
= oindx
;
5276 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5277 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5280 if (h
->indx
>= 0 || finfo
->info
->strip
== strip_all
)
5282 BFD_ASSERT (outsym
== finfo
->outsyms
);
5287 && (finfo
->info
->strip
== strip_all
5288 || (finfo
->info
->strip
== strip_some
5289 && bfd_hash_lookup (finfo
->info
->keep_hash
, h
->root
.root
.string
,
5290 FALSE
, FALSE
) == NULL
)))
5292 BFD_ASSERT (outsym
== finfo
->outsyms
);
5297 && (h
->flags
& (XCOFF_REF_REGULAR
| XCOFF_DEF_REGULAR
)) == 0)
5299 BFD_ASSERT (outsym
== finfo
->outsyms
);
5303 memset (&aux
, 0, sizeof aux
);
5305 h
->indx
= obj_raw_syment_count (output_bfd
);
5307 result
= bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
, &isym
,
5308 h
->root
.root
.string
);
5312 if (h
->root
.type
== bfd_link_hash_undefined
5313 || h
->root
.type
== bfd_link_hash_undefweak
)
5316 isym
.n_scnum
= N_UNDEF
;
5317 if (h
->root
.type
== bfd_link_hash_undefweak
5318 && C_WEAKEXT
== C_AIX_WEAKEXT
)
5319 isym
.n_sclass
= C_WEAKEXT
;
5321 isym
.n_sclass
= C_EXT
;
5322 aux
.x_csect
.x_smtyp
= XTY_ER
;
5324 else if ((h
->root
.type
== bfd_link_hash_defined
5325 || h
->root
.type
== bfd_link_hash_defweak
)
5326 && h
->smclas
== XMC_XO
)
5328 BFD_ASSERT (bfd_is_abs_section (h
->root
.u
.def
.section
));
5329 isym
.n_value
= h
->root
.u
.def
.value
;
5330 isym
.n_scnum
= N_UNDEF
;
5331 if (h
->root
.type
== bfd_link_hash_undefweak
5332 && C_WEAKEXT
== C_AIX_WEAKEXT
)
5333 isym
.n_sclass
= C_WEAKEXT
;
5335 isym
.n_sclass
= C_EXT
;
5336 aux
.x_csect
.x_smtyp
= XTY_ER
;
5338 else if (h
->root
.type
== bfd_link_hash_defined
5339 || h
->root
.type
== bfd_link_hash_defweak
)
5341 struct xcoff_link_size_list
*l
;
5343 isym
.n_value
= (h
->root
.u
.def
.section
->output_section
->vma
5344 + h
->root
.u
.def
.section
->output_offset
5345 + h
->root
.u
.def
.value
);
5346 if (bfd_is_abs_section (h
->root
.u
.def
.section
->output_section
))
5347 isym
.n_scnum
= N_ABS
;
5349 isym
.n_scnum
= h
->root
.u
.def
.section
->output_section
->target_index
;
5350 isym
.n_sclass
= C_HIDEXT
;
5351 aux
.x_csect
.x_smtyp
= XTY_SD
;
5353 if ((h
->flags
& XCOFF_HAS_SIZE
) != 0)
5355 for (l
= xcoff_hash_table (finfo
->info
)->size_list
;
5361 aux
.x_csect
.x_scnlen
.l
= l
->size
;
5367 else if (h
->root
.type
== bfd_link_hash_common
)
5369 isym
.n_value
= (h
->root
.u
.c
.p
->section
->output_section
->vma
5370 + h
->root
.u
.c
.p
->section
->output_offset
);
5371 isym
.n_scnum
= h
->root
.u
.c
.p
->section
->output_section
->target_index
;
5372 isym
.n_sclass
= C_EXT
;
5373 aux
.x_csect
.x_smtyp
= XTY_CM
;
5374 aux
.x_csect
.x_scnlen
.l
= h
->root
.u
.c
.size
;
5379 isym
.n_type
= T_NULL
;
5382 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
5383 outsym
+= bfd_coff_symesz (output_bfd
);
5385 aux
.x_csect
.x_smclas
= h
->smclas
;
5386 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, T_NULL
, isym
.n_sclass
, 0, 1,
5388 outsym
+= bfd_coff_auxesz (output_bfd
);
5390 if ((h
->root
.type
== bfd_link_hash_defined
5391 || h
->root
.type
== bfd_link_hash_defweak
)
5392 && h
->smclas
!= XMC_XO
)
5394 /* We just output an SD symbol. Now output an LD symbol. */
5397 if (h
->root
.type
== bfd_link_hash_undefweak
5398 && C_WEAKEXT
== C_AIX_WEAKEXT
)
5399 isym
.n_sclass
= C_WEAKEXT
;
5401 isym
.n_sclass
= C_EXT
;
5402 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
5403 outsym
+= bfd_coff_symesz (output_bfd
);
5405 aux
.x_csect
.x_smtyp
= XTY_LD
;
5406 aux
.x_csect
.x_scnlen
.l
= obj_raw_syment_count (output_bfd
);
5407 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, T_NULL
, C_EXT
, 0, 1,
5409 outsym
+= bfd_coff_auxesz (output_bfd
);
5412 pos
= obj_sym_filepos (output_bfd
);
5413 pos
+= obj_raw_syment_count (output_bfd
) * bfd_coff_symesz (output_bfd
);
5414 amt
= outsym
- finfo
->outsyms
;
5415 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5416 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
5418 obj_raw_syment_count (output_bfd
) +=
5419 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
5424 /* Handle a link order which is supposed to generate a reloc. */
5427 xcoff_reloc_link_order (bfd
*output_bfd
,
5428 struct xcoff_final_link_info
*finfo
,
5429 asection
*output_section
,
5430 struct bfd_link_order
*link_order
)
5432 reloc_howto_type
*howto
;
5433 struct xcoff_link_hash_entry
*h
;
5437 struct internal_reloc
*irel
;
5438 struct xcoff_link_hash_entry
**rel_hash_ptr
;
5439 struct internal_ldrel ldrel
;
5441 if (link_order
->type
== bfd_section_reloc_link_order
)
5442 /* We need to somehow locate a symbol in the right section. The
5443 symbol must either have a value of zero, or we must adjust
5444 the addend by the value of the symbol. FIXME: Write this
5445 when we need it. The old linker couldn't handle this anyhow. */
5448 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
5451 bfd_set_error (bfd_error_bad_value
);
5455 h
= ((struct xcoff_link_hash_entry
*)
5456 bfd_wrapped_link_hash_lookup (output_bfd
, finfo
->info
,
5457 link_order
->u
.reloc
.p
->u
.name
,
5458 FALSE
, FALSE
, TRUE
));
5461 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
5462 (finfo
->info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0)))
5467 if (h
->root
.type
== bfd_link_hash_common
)
5469 hsec
= h
->root
.u
.c
.p
->section
;
5472 else if (h
->root
.type
== bfd_link_hash_defined
5473 || h
->root
.type
== bfd_link_hash_defweak
)
5475 hsec
= h
->root
.u
.def
.section
;
5476 hval
= h
->root
.u
.def
.value
;
5484 addend
= link_order
->u
.reloc
.p
->addend
;
5486 addend
+= (hsec
->output_section
->vma
5487 + hsec
->output_offset
5494 bfd_reloc_status_type rstat
;
5497 size
= bfd_get_reloc_size (howto
);
5498 buf
= bfd_zmalloc (size
);
5502 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
5508 case bfd_reloc_outofrange
:
5510 case bfd_reloc_overflow
:
5511 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
5512 (finfo
->info
, NULL
, link_order
->u
.reloc
.p
->u
.name
,
5513 howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0)))
5520 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
5521 (file_ptr
) link_order
->offset
, size
);
5527 /* Store the reloc information in the right place. It will get
5528 swapped and written out at the end of the final_link routine. */
5529 irel
= (finfo
->section_info
[output_section
->target_index
].relocs
5530 + output_section
->reloc_count
);
5531 rel_hash_ptr
= (finfo
->section_info
[output_section
->target_index
].rel_hashes
5532 + output_section
->reloc_count
);
5534 memset (irel
, 0, sizeof (struct internal_reloc
));
5535 *rel_hash_ptr
= NULL
;
5537 irel
->r_vaddr
= output_section
->vma
+ link_order
->offset
;
5540 irel
->r_symndx
= h
->indx
;
5543 /* Set the index to -2 to force this symbol to get written out. */
5549 irel
->r_type
= howto
->type
;
5550 irel
->r_size
= howto
->bitsize
- 1;
5551 if (howto
->complain_on_overflow
== complain_overflow_signed
)
5552 irel
->r_size
|= 0x80;
5554 ++output_section
->reloc_count
;
5556 /* Now output the reloc to the .loader section. */
5558 ldrel
.l_vaddr
= irel
->r_vaddr
;
5562 const char *secname
;
5564 secname
= hsec
->output_section
->name
;
5566 if (strcmp (secname
, ".text") == 0)
5568 else if (strcmp (secname
, ".data") == 0)
5570 else if (strcmp (secname
, ".bss") == 0)
5574 (*_bfd_error_handler
)
5575 (_("%s: loader reloc in unrecognized section `%s'"),
5576 bfd_get_filename (output_bfd
), secname
);
5577 bfd_set_error (bfd_error_nonrepresentable_section
);
5585 (*_bfd_error_handler
)
5586 (_("%s: `%s' in loader reloc but not loader sym"),
5587 bfd_get_filename (output_bfd
),
5588 h
->root
.root
.string
);
5589 bfd_set_error (bfd_error_bad_value
);
5592 ldrel
.l_symndx
= h
->ldindx
;
5595 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
5596 ldrel
.l_rsecnm
= output_section
->target_index
;
5597 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5598 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5603 /* Do the final link step. */
5606 _bfd_xcoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
5608 bfd_size_type symesz
;
5609 struct xcoff_final_link_info finfo
;
5611 struct bfd_link_order
*p
;
5612 bfd_size_type max_contents_size
;
5613 bfd_size_type max_sym_count
;
5614 bfd_size_type max_lineno_count
;
5615 bfd_size_type max_reloc_count
;
5616 bfd_size_type max_output_reloc_count
;
5617 file_ptr rel_filepos
;
5619 file_ptr line_filepos
;
5620 unsigned int linesz
;
5622 bfd_byte
*external_relocs
= NULL
;
5623 char strbuf
[STRING_SIZE_SIZE
];
5628 abfd
->flags
|= DYNAMIC
;
5630 symesz
= bfd_coff_symesz (abfd
);
5633 finfo
.output_bfd
= abfd
;
5634 finfo
.strtab
= NULL
;
5635 finfo
.section_info
= NULL
;
5636 finfo
.last_file_index
= -1;
5637 finfo
.toc_symindx
= -1;
5638 finfo
.internal_syms
= NULL
;
5639 finfo
.sym_indices
= NULL
;
5640 finfo
.outsyms
= NULL
;
5641 finfo
.linenos
= NULL
;
5642 finfo
.contents
= NULL
;
5643 finfo
.external_relocs
= NULL
;
5645 finfo
.ldsym
= (xcoff_hash_table (info
)->loader_section
->contents
5646 + bfd_xcoff_ldhdrsz (abfd
));
5647 finfo
.ldrel
= (xcoff_hash_table (info
)->loader_section
->contents
5648 + bfd_xcoff_ldhdrsz(abfd
)
5649 + (xcoff_hash_table (info
)->ldhdr
.l_nsyms
5650 * bfd_xcoff_ldsymsz(abfd
)));
5652 xcoff_data (abfd
)->coff
.link_info
= info
;
5654 finfo
.strtab
= _bfd_stringtab_init ();
5655 if (finfo
.strtab
== NULL
)
5658 /* Count the relocation entries required for the output file.
5659 (We've already counted the line numbers.) Determine a few
5661 max_contents_size
= 0;
5662 max_lineno_count
= 0;
5663 max_reloc_count
= 0;
5664 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5667 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
5669 if (p
->type
== bfd_indirect_link_order
)
5673 sec
= p
->u
.indirect
.section
;
5675 /* Mark all sections which are to be included in the
5676 link. This will normally be every section. We need
5677 to do this so that we can identify any sections which
5678 the linker has decided to not include. */
5679 sec
->linker_mark
= TRUE
;
5681 o
->reloc_count
+= sec
->reloc_count
;
5683 if (sec
->rawsize
> max_contents_size
)
5684 max_contents_size
= sec
->rawsize
;
5685 if (sec
->size
> max_contents_size
)
5686 max_contents_size
= sec
->size
;
5687 if (coff_section_data (sec
->owner
, sec
) != NULL
5688 && xcoff_section_data (sec
->owner
, sec
) != NULL
5689 && (xcoff_section_data (sec
->owner
, sec
)->lineno_count
5690 > max_lineno_count
))
5692 xcoff_section_data (sec
->owner
, sec
)->lineno_count
;
5693 if (sec
->reloc_count
> max_reloc_count
)
5694 max_reloc_count
= sec
->reloc_count
;
5696 else if (p
->type
== bfd_section_reloc_link_order
5697 || p
->type
== bfd_symbol_reloc_link_order
)
5702 /* Compute the file positions for all the sections. */
5703 if (abfd
->output_has_begun
)
5705 if (xcoff_hash_table (info
)->file_align
!= 0)
5712 file_align
= xcoff_hash_table (info
)->file_align
;
5713 if (file_align
!= 0)
5715 bfd_boolean saw_contents
;
5719 /* Insert .pad sections before every section which has
5720 contents and is loaded, if it is preceded by some other
5721 section which has contents and is loaded. */
5722 saw_contents
= TRUE
;
5723 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5725 if (strcmp (o
->name
, ".pad") == 0)
5726 saw_contents
= FALSE
;
5727 else if ((o
->flags
& SEC_HAS_CONTENTS
) != 0
5728 && (o
->flags
& SEC_LOAD
) != 0)
5731 saw_contents
= TRUE
;
5736 /* Create a pad section and place it before the section
5737 that needs padding. This requires unlinking and
5738 relinking the bfd's section list. */
5740 n
= bfd_make_section_anyway_with_flags (abfd
, ".pad",
5742 n
->alignment_power
= 0;
5744 bfd_section_list_remove (abfd
, n
);
5745 bfd_section_list_insert_before (abfd
, o
, n
);
5746 saw_contents
= FALSE
;
5751 /* Reset the section indices after inserting the new
5754 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5757 o
->target_index
= indx
;
5759 BFD_ASSERT ((unsigned int) indx
== abfd
->section_count
);
5761 /* Work out appropriate sizes for the .pad sections to force
5762 each section to land on a page boundary. This bit of
5763 code knows what compute_section_file_positions is going
5765 sofar
= bfd_coff_filhsz (abfd
);
5766 sofar
+= bfd_coff_aoutsz (abfd
);
5767 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
5768 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5769 if ((bfd_xcoff_is_reloc_count_overflow
5770 (abfd
, (bfd_vma
) o
->reloc_count
))
5771 || (bfd_xcoff_is_lineno_count_overflow
5772 (abfd
, (bfd_vma
) o
->lineno_count
)))
5773 /* 64 does not overflow, need to check if 32 does */
5774 sofar
+= bfd_coff_scnhsz (abfd
);
5776 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5778 if (strcmp (o
->name
, ".pad") == 0)
5782 BFD_ASSERT (o
->size
== 0);
5783 pageoff
= sofar
& (file_align
- 1);
5786 o
->size
= file_align
- pageoff
;
5787 sofar
+= file_align
- pageoff
;
5788 o
->flags
|= SEC_HAS_CONTENTS
;
5793 if ((o
->flags
& SEC_HAS_CONTENTS
) != 0)
5794 sofar
+= BFD_ALIGN (o
->size
,
5795 1 << o
->alignment_power
);
5800 if (! bfd_coff_compute_section_file_positions (abfd
))
5804 /* Allocate space for the pointers we need to keep for the relocs. */
5808 /* We use section_count + 1, rather than section_count, because
5809 the target_index fields are 1 based. */
5810 amt
= abfd
->section_count
+ 1;
5811 amt
*= sizeof (struct xcoff_link_section_info
);
5812 finfo
.section_info
= bfd_malloc (amt
);
5813 if (finfo
.section_info
== NULL
)
5815 for (i
= 0; i
<= abfd
->section_count
; i
++)
5817 finfo
.section_info
[i
].relocs
= NULL
;
5818 finfo
.section_info
[i
].rel_hashes
= NULL
;
5819 finfo
.section_info
[i
].toc_rel_hashes
= NULL
;
5823 /* Set the file positions for the relocs. */
5824 rel_filepos
= obj_relocbase (abfd
);
5825 relsz
= bfd_coff_relsz (abfd
);
5826 max_output_reloc_count
= 0;
5827 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5829 if (o
->reloc_count
== 0)
5833 /* A stripped file has no relocs. However, we still
5834 allocate the buffers, so that later code doesn't have to
5835 worry about whether we are stripping or not. */
5836 if (info
->strip
== strip_all
)
5840 o
->flags
|= SEC_RELOC
;
5841 o
->rel_filepos
= rel_filepos
;
5842 rel_filepos
+= o
->reloc_count
* relsz
;
5845 /* We don't know the indices of global symbols until we have
5846 written out all the local symbols. For each section in
5847 the output file, we keep an array of pointers to hash
5848 table entries. Each entry in the array corresponds to a
5849 reloc. When we find a reloc against a global symbol, we
5850 set the corresponding entry in this array so that we can
5851 fix up the symbol index after we have written out all the
5854 Because of this problem, we also keep the relocs in
5855 memory until the end of the link. This wastes memory.
5856 We could backpatch the file later, I suppose, although it
5858 amt
= o
->reloc_count
;
5859 amt
*= sizeof (struct internal_reloc
);
5860 finfo
.section_info
[o
->target_index
].relocs
= bfd_malloc (amt
);
5862 amt
= o
->reloc_count
;
5863 amt
*= sizeof (struct xcoff_link_hash_entry
*);
5864 finfo
.section_info
[o
->target_index
].rel_hashes
= bfd_malloc (amt
);
5866 if (finfo
.section_info
[o
->target_index
].relocs
== NULL
5867 || finfo
.section_info
[o
->target_index
].rel_hashes
== NULL
)
5870 if (o
->reloc_count
> max_output_reloc_count
)
5871 max_output_reloc_count
= o
->reloc_count
;
5875 /* We now know the size of the relocs, so we can determine the file
5876 positions of the line numbers. */
5877 line_filepos
= rel_filepos
;
5878 finfo
.line_filepos
= line_filepos
;
5879 linesz
= bfd_coff_linesz (abfd
);
5880 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5882 if (o
->lineno_count
== 0)
5883 o
->line_filepos
= 0;
5886 o
->line_filepos
= line_filepos
;
5887 line_filepos
+= o
->lineno_count
* linesz
;
5890 /* Reset the reloc and lineno counts, so that we can use them to
5891 count the number of entries we have output so far. */
5893 o
->lineno_count
= 0;
5896 obj_sym_filepos (abfd
) = line_filepos
;
5898 /* Figure out the largest number of symbols in an input BFD. Take
5899 the opportunity to clear the output_has_begun fields of all the
5900 input BFD's. We want at least 6 symbols, since that is the
5901 number which xcoff_write_global_symbol may need. */
5903 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
5907 sub
->output_has_begun
= FALSE
;
5908 sz
= obj_raw_syment_count (sub
);
5909 if (sz
> max_sym_count
)
5913 /* Allocate some buffers used while linking. */
5914 amt
= max_sym_count
* sizeof (struct internal_syment
);
5915 finfo
.internal_syms
= bfd_malloc (amt
);
5917 amt
= max_sym_count
* sizeof (long);
5918 finfo
.sym_indices
= bfd_malloc (amt
);
5920 amt
= (max_sym_count
+ 1) * symesz
;
5921 finfo
.outsyms
= bfd_malloc (amt
);
5923 amt
= max_lineno_count
* bfd_coff_linesz (abfd
);
5924 finfo
.linenos
= bfd_malloc (amt
);
5926 amt
= max_contents_size
;
5927 finfo
.contents
= bfd_malloc (amt
);
5929 amt
= max_reloc_count
* relsz
;
5930 finfo
.external_relocs
= bfd_malloc (amt
);
5932 if ((finfo
.internal_syms
== NULL
&& max_sym_count
> 0)
5933 || (finfo
.sym_indices
== NULL
&& max_sym_count
> 0)
5934 || finfo
.outsyms
== NULL
5935 || (finfo
.linenos
== NULL
&& max_lineno_count
> 0)
5936 || (finfo
.contents
== NULL
&& max_contents_size
> 0)
5937 || (finfo
.external_relocs
== NULL
&& max_reloc_count
> 0))
5940 obj_raw_syment_count (abfd
) = 0;
5942 /* Find a TOC symbol, if we need one. */
5943 if (!xcoff_find_tc0 (abfd
, &finfo
))
5946 /* We now know the position of everything in the file, except that
5947 we don't know the size of the symbol table and therefore we don't
5948 know where the string table starts. We just build the string
5949 table in memory as we go along. We process all the relocations
5950 for a single input file at once. */
5951 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5953 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
5955 if (p
->type
== bfd_indirect_link_order
5956 && p
->u
.indirect
.section
->owner
->xvec
== abfd
->xvec
)
5958 sub
= p
->u
.indirect
.section
->owner
;
5959 if (! sub
->output_has_begun
)
5961 if (! xcoff_link_input_bfd (&finfo
, sub
))
5963 sub
->output_has_begun
= TRUE
;
5966 else if (p
->type
== bfd_section_reloc_link_order
5967 || p
->type
== bfd_symbol_reloc_link_order
)
5969 if (! xcoff_reloc_link_order (abfd
, &finfo
, o
, p
))
5974 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5980 /* Free up the buffers used by xcoff_link_input_bfd. */
5981 if (finfo
.internal_syms
!= NULL
)
5983 free (finfo
.internal_syms
);
5984 finfo
.internal_syms
= NULL
;
5986 if (finfo
.sym_indices
!= NULL
)
5988 free (finfo
.sym_indices
);
5989 finfo
.sym_indices
= NULL
;
5991 if (finfo
.linenos
!= NULL
)
5993 free (finfo
.linenos
);
5994 finfo
.linenos
= NULL
;
5996 if (finfo
.contents
!= NULL
)
5998 free (finfo
.contents
);
5999 finfo
.contents
= NULL
;
6001 if (finfo
.external_relocs
!= NULL
)
6003 free (finfo
.external_relocs
);
6004 finfo
.external_relocs
= NULL
;
6007 /* The value of the last C_FILE symbol is supposed to be -1. Write
6009 if (finfo
.last_file_index
!= -1)
6011 finfo
.last_file
.n_value
= -(bfd_vma
) 1;
6012 bfd_coff_swap_sym_out (abfd
, (void *) &finfo
.last_file
,
6013 (void *) finfo
.outsyms
);
6014 pos
= obj_sym_filepos (abfd
) + finfo
.last_file_index
* symesz
;
6015 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
6016 || bfd_bwrite (finfo
.outsyms
, symesz
, abfd
) != symesz
)
6020 /* Write out all the global symbols which do not come from XCOFF
6022 xcoff_link_hash_traverse (xcoff_hash_table (info
),
6023 xcoff_write_global_symbol
,
6026 if (finfo
.outsyms
!= NULL
)
6028 free (finfo
.outsyms
);
6029 finfo
.outsyms
= NULL
;
6032 /* Now that we have written out all the global symbols, we know the
6033 symbol indices to use for relocs against them, and we can finally
6034 write out the relocs. */
6035 amt
= max_output_reloc_count
* relsz
;
6036 external_relocs
= bfd_malloc (amt
);
6037 if (external_relocs
== NULL
&& max_output_reloc_count
!= 0)
6040 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6042 struct internal_reloc
*irel
;
6043 struct internal_reloc
*irelend
;
6044 struct xcoff_link_hash_entry
**rel_hash
;
6045 struct xcoff_toc_rel_hash
*toc_rel_hash
;
6047 bfd_size_type rel_size
;
6049 /* A stripped file has no relocs. */
6050 if (info
->strip
== strip_all
)
6056 if (o
->reloc_count
== 0)
6059 irel
= finfo
.section_info
[o
->target_index
].relocs
;
6060 irelend
= irel
+ o
->reloc_count
;
6061 rel_hash
= finfo
.section_info
[o
->target_index
].rel_hashes
;
6062 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
6064 if (*rel_hash
!= NULL
)
6066 if ((*rel_hash
)->indx
< 0)
6068 if (! ((*info
->callbacks
->unattached_reloc
)
6069 (info
, (*rel_hash
)->root
.root
.string
,
6070 NULL
, o
, irel
->r_vaddr
)))
6072 (*rel_hash
)->indx
= 0;
6074 irel
->r_symndx
= (*rel_hash
)->indx
;
6078 for (toc_rel_hash
= finfo
.section_info
[o
->target_index
].toc_rel_hashes
;
6079 toc_rel_hash
!= NULL
;
6080 toc_rel_hash
= toc_rel_hash
->next
)
6082 if (toc_rel_hash
->h
->u
.toc_indx
< 0)
6084 if (! ((*info
->callbacks
->unattached_reloc
)
6085 (info
, toc_rel_hash
->h
->root
.root
.string
,
6086 NULL
, o
, toc_rel_hash
->rel
->r_vaddr
)))
6088 toc_rel_hash
->h
->u
.toc_indx
= 0;
6090 toc_rel_hash
->rel
->r_symndx
= toc_rel_hash
->h
->u
.toc_indx
;
6093 /* XCOFF requires that the relocs be sorted by address. We tend
6094 to produce them in the order in which their containing csects
6095 appear in the symbol table, which is not necessarily by
6096 address. So we sort them here. There may be a better way to
6098 qsort ((void *) finfo
.section_info
[o
->target_index
].relocs
,
6099 o
->reloc_count
, sizeof (struct internal_reloc
),
6102 irel
= finfo
.section_info
[o
->target_index
].relocs
;
6103 irelend
= irel
+ o
->reloc_count
;
6104 erel
= external_relocs
;
6105 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
6106 bfd_coff_swap_reloc_out (abfd
, (void *) irel
, (void *) erel
);
6108 rel_size
= relsz
* o
->reloc_count
;
6109 if (bfd_seek (abfd
, o
->rel_filepos
, SEEK_SET
) != 0
6110 || bfd_bwrite ((void *) external_relocs
, rel_size
, abfd
) != rel_size
)
6114 if (external_relocs
!= NULL
)
6116 free (external_relocs
);
6117 external_relocs
= NULL
;
6120 /* Free up the section information. */
6121 if (finfo
.section_info
!= NULL
)
6125 for (i
= 0; i
< abfd
->section_count
; i
++)
6127 if (finfo
.section_info
[i
].relocs
!= NULL
)
6128 free (finfo
.section_info
[i
].relocs
);
6129 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
6130 free (finfo
.section_info
[i
].rel_hashes
);
6132 free (finfo
.section_info
);
6133 finfo
.section_info
= NULL
;
6136 /* Write out the loader section contents. */
6137 BFD_ASSERT ((bfd_byte
*) finfo
.ldrel
6138 == (xcoff_hash_table (info
)->loader_section
->contents
6139 + xcoff_hash_table (info
)->ldhdr
.l_impoff
));
6140 o
= xcoff_hash_table (info
)->loader_section
;
6141 if (! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
6142 (file_ptr
) o
->output_offset
, o
->size
))
6145 /* Write out the magic sections. */
6146 o
= xcoff_hash_table (info
)->linkage_section
;
6148 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
6149 (file_ptr
) o
->output_offset
,
6152 o
= xcoff_hash_table (info
)->toc_section
;
6154 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
6155 (file_ptr
) o
->output_offset
,
6158 o
= xcoff_hash_table (info
)->descriptor_section
;
6160 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
6161 (file_ptr
) o
->output_offset
,
6165 /* Write out the string table. */
6166 pos
= obj_sym_filepos (abfd
) + obj_raw_syment_count (abfd
) * symesz
;
6167 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
6170 _bfd_stringtab_size (finfo
.strtab
) + STRING_SIZE_SIZE
,
6172 amt
= STRING_SIZE_SIZE
;
6173 if (bfd_bwrite (strbuf
, amt
, abfd
) != amt
)
6175 if (! _bfd_stringtab_emit (abfd
, finfo
.strtab
))
6178 _bfd_stringtab_free (finfo
.strtab
);
6180 /* Write out the debugging string table. */
6181 o
= xcoff_hash_table (info
)->debug_section
;
6184 struct bfd_strtab_hash
*debug_strtab
;
6186 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
6187 BFD_ASSERT (o
->output_section
->size
- o
->output_offset
6188 >= _bfd_stringtab_size (debug_strtab
));
6189 pos
= o
->output_section
->filepos
+ o
->output_offset
;
6190 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
6192 if (! _bfd_stringtab_emit (abfd
, debug_strtab
))
6196 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
6197 not try to write out the symbols. */
6198 bfd_get_symcount (abfd
) = 0;
6203 if (finfo
.strtab
!= NULL
)
6204 _bfd_stringtab_free (finfo
.strtab
);
6206 if (finfo
.section_info
!= NULL
)
6210 for (i
= 0; i
< abfd
->section_count
; i
++)
6212 if (finfo
.section_info
[i
].relocs
!= NULL
)
6213 free (finfo
.section_info
[i
].relocs
);
6214 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
6215 free (finfo
.section_info
[i
].rel_hashes
);
6217 free (finfo
.section_info
);
6220 if (finfo
.internal_syms
!= NULL
)
6221 free (finfo
.internal_syms
);
6222 if (finfo
.sym_indices
!= NULL
)
6223 free (finfo
.sym_indices
);
6224 if (finfo
.outsyms
!= NULL
)
6225 free (finfo
.outsyms
);
6226 if (finfo
.linenos
!= NULL
)
6227 free (finfo
.linenos
);
6228 if (finfo
.contents
!= NULL
)
6229 free (finfo
.contents
);
6230 if (finfo
.external_relocs
!= NULL
)
6231 free (finfo
.external_relocs
);
6232 if (external_relocs
!= NULL
)
6233 free (external_relocs
);