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)
3131 h
->ldsym
->l_ifile
= h
->ldindx
;
3133 /* The first 3 symbol table indices are reserved to indicate the
3134 data, text and bss sections. */
3135 h
->ldindx
= ldinfo
->ldsym_count
+ 3;
3137 ++ldinfo
->ldsym_count
;
3139 if (! bfd_xcoff_put_ldsymbol_name (ldinfo
->output_bfd
, ldinfo
,
3140 h
->ldsym
, h
->root
.root
.string
))
3143 h
->flags
|= XCOFF_BUILT_LDSYM
;
3148 /* INPUT_BFD includes XCOFF symbol ISYM, which is associated with linker
3149 hash table entry H and csect CSECT. AUX contains ISYM's auxillary
3150 csect information, if any. NAME is the function's name if the name
3151 is stored in the .debug section, otherwise it is null.
3153 Return 1 if we should include an appropriately-adjusted ISYM
3154 in the output file, 0 if we should discard ISYM, or -1 if an
3158 xcoff_keep_symbol_p (struct bfd_link_info
*info
, bfd
*input_bfd
,
3159 struct internal_syment
*isym
,
3160 union internal_auxent
*aux
,
3161 struct xcoff_link_hash_entry
*h
,
3162 asection
*csect
, const char *name
)
3166 /* If we are skipping this csect, we want to strip the symbol too. */
3170 /* Likewise if we garbage-collected the csect. */
3171 if (xcoff_hash_table (info
)->gc
3172 && !bfd_is_abs_section (csect
)
3173 && !bfd_is_und_section (csect
)
3174 && (csect
->flags
& SEC_MARK
) == 0)
3177 /* An XCOFF linker always removes C_STAT symbols. */
3178 if (isym
->n_sclass
== C_STAT
)
3181 /* We generate the TOC anchor separately. */
3182 if (isym
->n_sclass
== C_HIDEXT
3183 && aux
->x_csect
.x_smclas
== XMC_TC0
)
3186 /* If we are stripping all symbols, we want to discard this one. */
3187 if (info
->strip
== strip_all
)
3190 /* Discard symbols that are defined elsewhere. */
3191 if (EXTERN_SYM_P (isym
->n_sclass
))
3193 if ((h
->flags
& XCOFF_ALLOCATED
) != 0)
3195 if (!xcoff_final_definition_p (input_bfd
, h
, csect
))
3199 /* If we're discarding local symbols, check whether ISYM is local. */
3200 smtyp
= SMTYP_SMTYP (aux
->x_csect
.x_smtyp
);
3201 if (info
->discard
== discard_all
3202 && !EXTERN_SYM_P (isym
->n_sclass
)
3203 && (isym
->n_sclass
!= C_HIDEXT
|| smtyp
!= XTY_SD
))
3206 /* If we're stripping debugging symbols, check whether ISYM is one. */
3207 if (info
->strip
== strip_debugger
3208 && isym
->n_scnum
== N_DEBUG
)
3211 /* If we are stripping symbols based on name, check how ISYM's
3212 name should be handled. */
3213 if (info
->strip
== strip_some
3214 || info
->discard
== discard_l
)
3216 char buf
[SYMNMLEN
+ 1];
3220 name
= _bfd_coff_internal_syment_name (input_bfd
, isym
, buf
);
3225 if (info
->strip
== strip_some
3226 && bfd_hash_lookup (info
->keep_hash
, name
, FALSE
, FALSE
) == NULL
)
3229 if (info
->discard
== discard_l
3230 && !EXTERN_SYM_P (isym
->n_sclass
)
3231 && (isym
->n_sclass
!= C_HIDEXT
|| smtyp
!= XTY_SD
)
3232 && bfd_is_local_label_name (input_bfd
, name
))
3239 /* Build the .loader section. This is called by the XCOFF linker
3240 emulation before_allocation routine. We must set the size of the
3241 .loader section before the linker lays out the output file.
3242 LIBPATH is the library path to search for shared objects; this is
3243 normally built from the -L arguments passed to the linker. ENTRY
3244 is the name of the entry point symbol (the -e linker option).
3245 FILE_ALIGN is the alignment to use for sections within the file
3246 (the -H linker option). MAXSTACK is the maximum stack size (the
3247 -bmaxstack linker option). MAXDATA is the maximum data size (the
3248 -bmaxdata linker option). GC is whether to do garbage collection
3249 (the -bgc linker option). MODTYPE is the module type (the
3250 -bmodtype linker option). TEXTRO is whether the text section must
3251 be read only (the -btextro linker option). AUTO_EXPORT_FLAGS
3252 is a mask of XCOFF_EXPALL and XCOFF_EXPFULL. SPECIAL_SECTIONS
3253 is set by this routine to csects with magic names like _end. */
3256 bfd_xcoff_size_dynamic_sections (bfd
*output_bfd
,
3257 struct bfd_link_info
*info
,
3258 const char *libpath
,
3260 unsigned long file_align
,
3261 unsigned long maxstack
,
3262 unsigned long maxdata
,
3266 unsigned int auto_export_flags
,
3267 asection
**special_sections
,
3271 struct xcoff_loader_info ldinfo
;
3273 size_t impsize
, impcount
;
3274 struct xcoff_import_file
*fl
;
3275 struct internal_ldhdr
*ldhdr
;
3276 bfd_size_type stoff
;
3280 struct bfd_strtab_hash
*debug_strtab
;
3281 bfd_byte
*debug_contents
= NULL
;
3284 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
3286 for (i
= 0; i
< XCOFF_NUMBER_OF_SPECIAL_SECTIONS
; i
++)
3287 special_sections
[i
] = NULL
;
3291 ldinfo
.failed
= FALSE
;
3292 ldinfo
.output_bfd
= output_bfd
;
3294 ldinfo
.auto_export_flags
= auto_export_flags
;
3295 ldinfo
.ldsym_count
= 0;
3296 ldinfo
.string_size
= 0;
3297 ldinfo
.strings
= NULL
;
3298 ldinfo
.string_alc
= 0;
3300 xcoff_data (output_bfd
)->maxstack
= maxstack
;
3301 xcoff_data (output_bfd
)->maxdata
= maxdata
;
3302 xcoff_data (output_bfd
)->modtype
= modtype
;
3304 xcoff_hash_table (info
)->file_align
= file_align
;
3305 xcoff_hash_table (info
)->textro
= textro
;
3306 xcoff_hash_table (info
)->rtld
= rtld
;
3309 if (info
->init_function
|| info
->fini_function
|| rtld
)
3311 struct xcoff_link_hash_entry
*hsym
;
3312 struct internal_ldsym
*ldsym
;
3314 hsym
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
3315 "__rtinit", FALSE
, FALSE
, TRUE
);
3318 (*_bfd_error_handler
)
3319 (_("error: undefined symbol __rtinit"));
3323 xcoff_mark_symbol (info
, hsym
);
3324 hsym
->flags
|= (XCOFF_DEF_REGULAR
| XCOFF_RTINIT
);
3326 /* __rtinit initialized. */
3327 amt
= sizeof (* ldsym
);
3328 ldsym
= bfd_malloc (amt
);
3330 ldsym
->l_value
= 0; /* Will be filled in later. */
3331 ldsym
->l_scnum
= 2; /* Data section. */
3332 ldsym
->l_smtype
= XTY_SD
; /* Csect section definition. */
3333 ldsym
->l_smclas
= 5; /* .rw. */
3334 ldsym
->l_ifile
= 0; /* Special system loader symbol. */
3335 ldsym
->l_parm
= 0; /* NA. */
3337 /* Force __rtinit to be the first symbol in the loader symbol table
3338 See xcoff_build_ldsyms
3340 The first 3 symbol table indices are reserved to indicate the data,
3341 text and bss sections. */
3342 BFD_ASSERT (0 == ldinfo
.ldsym_count
);
3345 ldinfo
.ldsym_count
= 1;
3346 hsym
->ldsym
= ldsym
;
3348 if (! bfd_xcoff_put_ldsymbol_name (ldinfo
.output_bfd
, &ldinfo
,
3349 hsym
->ldsym
, hsym
->root
.root
.string
))
3352 /* This symbol is written out by xcoff_write_global_symbol
3353 Set stuff up so xcoff_write_global_symbol logic works. */
3354 hsym
->flags
|= XCOFF_DEF_REGULAR
| XCOFF_MARK
;
3355 hsym
->root
.type
= bfd_link_hash_defined
;
3356 hsym
->root
.u
.def
.value
= 0;
3359 /* Garbage collect unused sections. */
3360 if (info
->relocatable
|| !gc
)
3363 xcoff_hash_table (info
)->gc
= FALSE
;
3365 /* We still need to call xcoff_mark, in order to set ldrel_count
3367 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3371 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3373 /* We shouldn't unconditionaly mark the TOC section.
3374 The output file should only have a TOC if either
3375 (a) one of the input files did or (b) we end up
3376 creating TOC references as part of the link process. */
3377 if (o
!= xcoff_hash_table (info
)->toc_section
3378 && (o
->flags
& SEC_MARK
) == 0)
3380 if (! xcoff_mark (info
, o
))
3389 && !xcoff_mark_symbol_by_name (info
, entry
, XCOFF_ENTRY
))
3391 if (info
->init_function
!= NULL
3392 && !xcoff_mark_symbol_by_name (info
, info
->init_function
, 0))
3394 if (info
->fini_function
!= NULL
3395 && !xcoff_mark_symbol_by_name (info
, info
->fini_function
, 0))
3397 if (auto_export_flags
!= 0)
3399 xcoff_link_hash_traverse (xcoff_hash_table (info
),
3400 xcoff_mark_auto_exports
, &ldinfo
);
3405 xcoff_hash_table (info
)->gc
= TRUE
;
3408 /* Return special sections to the caller. */
3409 for (i
= 0; i
< XCOFF_NUMBER_OF_SPECIAL_SECTIONS
; i
++)
3411 sec
= xcoff_hash_table (info
)->special_sections
[i
];
3415 && (sec
->flags
& SEC_MARK
) == 0)
3418 special_sections
[i
] = sec
;
3421 if (info
->input_bfds
== NULL
)
3422 /* I'm not sure what to do in this bizarre case. */
3425 xcoff_link_hash_traverse (xcoff_hash_table (info
), xcoff_build_ldsyms
,
3430 /* Work out the size of the import file names. Each import file ID
3431 consists of three null terminated strings: the path, the file
3432 name, and the archive member name. The first entry in the list
3433 of names is the path to use to find objects, which the linker has
3434 passed in as the libpath argument. For some reason, the path
3435 entry in the other import file names appears to always be empty. */
3436 impsize
= strlen (libpath
) + 3;
3438 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
3441 impsize
+= (strlen (fl
->path
)
3443 + strlen (fl
->member
)
3447 /* Set up the .loader section header. */
3448 ldhdr
= &xcoff_hash_table (info
)->ldhdr
;
3449 ldhdr
->l_version
= bfd_xcoff_ldhdr_version(output_bfd
);
3450 ldhdr
->l_nsyms
= ldinfo
.ldsym_count
;
3451 ldhdr
->l_nreloc
= xcoff_hash_table (info
)->ldrel_count
;
3452 ldhdr
->l_istlen
= impsize
;
3453 ldhdr
->l_nimpid
= impcount
;
3454 ldhdr
->l_impoff
= (bfd_xcoff_ldhdrsz(output_bfd
)
3455 + ldhdr
->l_nsyms
* bfd_xcoff_ldsymsz(output_bfd
)
3456 + ldhdr
->l_nreloc
* bfd_xcoff_ldrelsz(output_bfd
));
3457 ldhdr
->l_stlen
= ldinfo
.string_size
;
3458 stoff
= ldhdr
->l_impoff
+ impsize
;
3459 if (ldinfo
.string_size
== 0)
3462 ldhdr
->l_stoff
= stoff
;
3464 /* 64 bit elements to ldhdr
3465 The swap out routine for 32 bit will ignore them.
3466 Nothing fancy, symbols come after the header and relocs come
3468 ldhdr
->l_symoff
= bfd_xcoff_ldhdrsz (output_bfd
);
3469 ldhdr
->l_rldoff
= (bfd_xcoff_ldhdrsz (output_bfd
)
3470 + ldhdr
->l_nsyms
* bfd_xcoff_ldsymsz (output_bfd
));
3472 /* We now know the final size of the .loader section. Allocate
3474 lsec
= xcoff_hash_table (info
)->loader_section
;
3475 lsec
->size
= stoff
+ ldhdr
->l_stlen
;
3476 lsec
->contents
= bfd_zalloc (output_bfd
, lsec
->size
);
3477 if (lsec
->contents
== NULL
)
3480 /* Set up the header. */
3481 bfd_xcoff_swap_ldhdr_out (output_bfd
, ldhdr
, lsec
->contents
);
3483 /* Set up the import file names. */
3484 out
= (char *) lsec
->contents
+ ldhdr
->l_impoff
;
3485 strcpy (out
, libpath
);
3486 out
+= strlen (libpath
) + 1;
3489 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
3494 while ((*out
++ = *s
++) != '\0')
3497 while ((*out
++ = *s
++) != '\0')
3500 while ((*out
++ = *s
++) != '\0')
3504 BFD_ASSERT ((bfd_size_type
) ((bfd_byte
*) out
- lsec
->contents
) == stoff
);
3506 /* Set up the symbol string table. */
3507 if (ldinfo
.string_size
> 0)
3509 memcpy (out
, ldinfo
.strings
, ldinfo
.string_size
);
3510 free (ldinfo
.strings
);
3511 ldinfo
.strings
= NULL
;
3514 /* We can't set up the symbol table or the relocs yet, because we
3515 don't yet know the final position of the various sections. The
3516 .loader symbols are written out when the corresponding normal
3517 symbols are written out in xcoff_link_input_bfd or
3518 xcoff_write_global_symbol. The .loader relocs are written out
3519 when the corresponding normal relocs are handled in
3520 xcoff_link_input_bfd. */
3522 /* Allocate space for the magic sections. */
3523 sec
= xcoff_hash_table (info
)->linkage_section
;
3526 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
3527 if (sec
->contents
== NULL
)
3530 sec
= xcoff_hash_table (info
)->toc_section
;
3533 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
3534 if (sec
->contents
== NULL
)
3537 sec
= xcoff_hash_table (info
)->descriptor_section
;
3540 sec
->contents
= bfd_zalloc (output_bfd
, sec
->size
);
3541 if (sec
->contents
== NULL
)
3545 /* Now that we've done garbage collection, decide which symbols to keep,
3546 and figure out the contents of the .debug section. */
3547 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
3549 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3552 bfd_size_type symcount
;
3555 unsigned int *lineno_counts
;
3556 struct xcoff_link_hash_entry
**sym_hash
;
3557 bfd_byte
*esym
, *esymend
;
3558 bfd_size_type symesz
;
3560 if (sub
->xvec
!= info
->output_bfd
->xvec
)
3563 if ((sub
->flags
& DYNAMIC
) != 0
3564 && !info
->static_link
)
3567 if (! _bfd_coff_get_external_symbols (sub
))
3570 symcount
= obj_raw_syment_count (sub
);
3571 debug_index
= bfd_zalloc (sub
, symcount
* sizeof (long));
3572 if (debug_index
== NULL
)
3574 xcoff_data (sub
)->debug_indices
= debug_index
;
3576 if (info
->strip
== strip_all
3577 || info
->strip
== strip_debugger
3578 || info
->discard
== discard_all
)
3579 /* We're stripping all debugging information, so there's no need
3580 to read SUB's .debug section. */
3584 /* Grab the contents of SUB's .debug section, if any. */
3585 subdeb
= bfd_get_section_by_name (sub
, ".debug");
3586 if (subdeb
!= NULL
&& subdeb
->size
> 0)
3588 /* We use malloc and copy the names into the debug
3589 stringtab, rather than bfd_alloc, because I expect
3590 that, when linking many files together, many of the
3591 strings will be the same. Storing the strings in the
3592 hash table should save space in this case. */
3593 if (!bfd_malloc_and_get_section (sub
, subdeb
, &debug_contents
))
3598 csectpp
= xcoff_data (sub
)->csects
;
3599 lineno_counts
= xcoff_data (sub
)->lineno_counts
;
3600 sym_hash
= obj_xcoff_sym_hashes (sub
);
3601 symesz
= bfd_coff_symesz (sub
);
3602 esym
= (bfd_byte
*) obj_coff_external_syms (sub
);
3603 esymend
= esym
+ symcount
* symesz
;
3605 while (esym
< esymend
)
3607 struct internal_syment sym
;
3608 union internal_auxent aux
;
3613 bfd_coff_swap_sym_in (sub
, esym
, &sym
);
3615 /* Read in the csect information, if any. */
3616 if (CSECT_SYM_P (sym
.n_sclass
))
3618 BFD_ASSERT (sym
.n_numaux
> 0);
3619 bfd_coff_swap_aux_in (sub
, esym
+ symesz
* sym
.n_numaux
,
3620 sym
.n_type
, sym
.n_sclass
,
3621 sym
.n_numaux
- 1, sym
.n_numaux
, &aux
);
3624 /* If this symbol's name is stored in the debug section,
3625 get a pointer to it. */
3626 if (debug_contents
!= NULL
3627 && sym
._n
._n_n
._n_zeroes
== 0
3628 && bfd_coff_symname_in_debug (sub
, &sym
))
3629 name
= (const char *) debug_contents
+ sym
._n
._n_n
._n_offset
;
3633 /* Decide whether to copy this symbol to the output file. */
3635 keep_p
= xcoff_keep_symbol_p (info
, sub
, &sym
, &aux
,
3636 *sym_hash
, csect
, name
);
3641 /* Use a debug_index of -2 to record that a symbol should
3646 /* See whether we should store the symbol name in the
3647 output .debug section. */
3652 indx
= _bfd_stringtab_add (debug_strtab
, name
, TRUE
, TRUE
);
3653 if (indx
== (bfd_size_type
) -1)
3655 *debug_index
= indx
;
3660 (*sym_hash
)->flags
|= XCOFF_ALLOCATED
;
3661 if (*lineno_counts
> 0)
3662 csect
->output_section
->lineno_count
+= *lineno_counts
;
3665 esym
+= (sym
.n_numaux
+ 1) * symesz
;
3666 csectpp
+= sym
.n_numaux
+ 1;
3667 sym_hash
+= sym
.n_numaux
+ 1;
3668 lineno_counts
+= sym
.n_numaux
+ 1;
3669 debug_index
+= sym
.n_numaux
+ 1;
3674 free (debug_contents
);
3675 debug_contents
= NULL
;
3677 /* Clear the size of subdeb, so that it is not included directly
3678 in the output file. */
3682 if (! info
->keep_memory
)
3684 if (! _bfd_coff_free_symbols (sub
))
3689 if (info
->strip
!= strip_all
)
3690 xcoff_hash_table (info
)->debug_section
->size
=
3691 _bfd_stringtab_size (debug_strtab
);
3696 if (ldinfo
.strings
!= NULL
)
3697 free (ldinfo
.strings
);
3698 if (debug_contents
!= NULL
)
3699 free (debug_contents
);
3704 bfd_xcoff_link_generate_rtinit (bfd
*abfd
,
3709 struct bfd_in_memory
*bim
;
3711 bim
= bfd_malloc ((bfd_size_type
) sizeof (* bim
));
3718 abfd
->link_next
= 0;
3719 abfd
->format
= bfd_object
;
3720 abfd
->iostream
= (void *) bim
;
3721 abfd
->flags
= BFD_IN_MEMORY
;
3722 abfd
->direction
= write_direction
;
3725 if (! bfd_xcoff_generate_rtinit (abfd
, init
, fini
, rtld
))
3728 /* need to reset to unknown or it will not be read back in correctly */
3729 abfd
->format
= bfd_unknown
;
3730 abfd
->direction
= read_direction
;
3736 /* Link an input file into the linker output file. This function
3737 handles all the sections and relocations of the input file at once. */
3740 xcoff_link_input_bfd (struct xcoff_final_link_info
*finfo
,
3744 const char *strings
;
3745 bfd_size_type syment_base
;
3746 unsigned int n_tmask
;
3747 unsigned int n_btshft
;
3748 bfd_boolean copy
, hash
;
3749 bfd_size_type isymesz
;
3750 bfd_size_type osymesz
;
3751 bfd_size_type linesz
;
3754 struct xcoff_link_hash_entry
**sym_hash
;
3755 struct internal_syment
*isymp
;
3757 unsigned int *lineno_counts
;
3760 unsigned long output_index
;
3764 bfd_boolean keep_syms
;
3767 /* We can just skip DYNAMIC files, unless this is a static link. */
3768 if ((input_bfd
->flags
& DYNAMIC
) != 0
3769 && ! finfo
->info
->static_link
)
3772 /* Move all the symbols to the output file. */
3773 output_bfd
= finfo
->output_bfd
;
3775 syment_base
= obj_raw_syment_count (output_bfd
);
3776 isymesz
= bfd_coff_symesz (input_bfd
);
3777 osymesz
= bfd_coff_symesz (output_bfd
);
3778 linesz
= bfd_coff_linesz (input_bfd
);
3779 BFD_ASSERT (linesz
== bfd_coff_linesz (output_bfd
));
3781 n_tmask
= coff_data (input_bfd
)->local_n_tmask
;
3782 n_btshft
= coff_data (input_bfd
)->local_n_btshft
;
3784 /* Define macros so that ISFCN, et. al., macros work correctly. */
3785 #define N_TMASK n_tmask
3786 #define N_BTSHFT n_btshft
3789 if (! finfo
->info
->keep_memory
)
3792 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
3795 if (! _bfd_coff_get_external_symbols (input_bfd
))
3798 /* Make one pass over the symbols and assign indices to symbols that
3799 we have decided to keep. Also use create .loader symbol information
3800 and update information in hash table entries. */
3801 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
3802 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
3803 sym_hash
= obj_xcoff_sym_hashes (input_bfd
);
3804 csectpp
= xcoff_data (input_bfd
)->csects
;
3805 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
3806 isymp
= finfo
->internal_syms
;
3807 indexp
= finfo
->sym_indices
;
3808 output_index
= syment_base
;
3809 while (esym
< esym_end
)
3811 union internal_auxent aux
;
3815 bfd_coff_swap_sym_in (input_bfd
, (void *) esym
, (void *) isymp
);
3817 /* Read in the csect information, if any. */
3818 if (CSECT_SYM_P (isymp
->n_sclass
))
3820 BFD_ASSERT (isymp
->n_numaux
> 0);
3821 bfd_coff_swap_aux_in (input_bfd
,
3822 (void *) (esym
+ isymesz
* isymp
->n_numaux
),
3823 isymp
->n_type
, isymp
->n_sclass
,
3824 isymp
->n_numaux
- 1, isymp
->n_numaux
,
3827 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
3830 /* If this symbol is in the .loader section, swap out the
3831 .loader symbol information. If this is an external symbol
3832 reference to a defined symbol, though, then wait until we get
3833 to the definition. */
3834 if (EXTERN_SYM_P (isymp
->n_sclass
)
3835 && *sym_hash
!= NULL
3836 && (*sym_hash
)->ldsym
!= NULL
3837 && xcoff_final_definition_p (input_bfd
, *sym_hash
, *csectpp
))
3839 struct xcoff_link_hash_entry
*h
;
3840 struct internal_ldsym
*ldsym
;
3844 if (isymp
->n_scnum
> 0)
3846 ldsym
->l_scnum
= (*csectpp
)->output_section
->target_index
;
3847 ldsym
->l_value
= (isymp
->n_value
3848 + (*csectpp
)->output_section
->vma
3849 + (*csectpp
)->output_offset
3854 ldsym
->l_scnum
= isymp
->n_scnum
;
3855 ldsym
->l_value
= isymp
->n_value
;
3858 ldsym
->l_smtype
= smtyp
;
3859 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
3860 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
3861 || (h
->flags
& XCOFF_IMPORT
) != 0)
3862 ldsym
->l_smtype
|= L_IMPORT
;
3863 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
3864 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
3865 || (h
->flags
& XCOFF_EXPORT
) != 0)
3866 ldsym
->l_smtype
|= L_EXPORT
;
3867 if ((h
->flags
& XCOFF_ENTRY
) != 0)
3868 ldsym
->l_smtype
|= L_ENTRY
;
3869 if (isymp
->n_sclass
== C_AIX_WEAKEXT
)
3870 ldsym
->l_smtype
|= L_WEAK
;
3872 ldsym
->l_smclas
= aux
.x_csect
.x_smclas
;
3874 if (ldsym
->l_ifile
== (bfd_size_type
) -1)
3876 else if (ldsym
->l_ifile
== 0)
3878 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
3884 if (h
->root
.type
== bfd_link_hash_defined
3885 || h
->root
.type
== bfd_link_hash_defweak
)
3886 impbfd
= h
->root
.u
.def
.section
->owner
;
3887 else if (h
->root
.type
== bfd_link_hash_undefined
3888 || h
->root
.type
== bfd_link_hash_undefweak
)
3889 impbfd
= h
->root
.u
.undef
.abfd
;
3897 BFD_ASSERT (impbfd
->xvec
== finfo
->output_bfd
->xvec
);
3898 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
3905 BFD_ASSERT (h
->ldindx
>= 0);
3906 bfd_xcoff_swap_ldsym_out (finfo
->output_bfd
, ldsym
,
3909 * bfd_xcoff_ldsymsz (finfo
->output_bfd
))));
3912 /* Fill in snentry now that we know the target_index. */
3913 if ((h
->flags
& XCOFF_ENTRY
) != 0
3914 && (h
->root
.type
== bfd_link_hash_defined
3915 || h
->root
.type
== bfd_link_hash_defweak
))
3917 xcoff_data (output_bfd
)->snentry
=
3918 h
->root
.u
.def
.section
->output_section
->target_index
;
3922 add
= 1 + isymp
->n_numaux
;
3924 if (*debug_index
== -2)
3925 /* We've decided to strip this symbol. */
3929 /* Assign the next unused index to this symbol. */
3930 *indexp
= output_index
;
3932 if (EXTERN_SYM_P (isymp
->n_sclass
))
3934 BFD_ASSERT (*sym_hash
!= NULL
);
3935 (*sym_hash
)->indx
= output_index
;
3938 /* If this is a symbol in the TOC which we may have merged
3939 (class XMC_TC), remember the symbol index of the TOC
3941 if (isymp
->n_sclass
== C_HIDEXT
3942 && aux
.x_csect
.x_smclas
== XMC_TC
3943 && *sym_hash
!= NULL
)
3945 BFD_ASSERT (((*sym_hash
)->flags
& XCOFF_SET_TOC
) == 0);
3946 BFD_ASSERT ((*sym_hash
)->toc_section
!= NULL
);
3947 (*sym_hash
)->u
.toc_indx
= output_index
;
3950 output_index
+= add
;
3953 esym
+= add
* isymesz
;
3959 for (--add
; add
> 0; --add
)
3963 /* Now write out the symbols that we decided to keep. */
3965 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
3966 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
3967 isymp
= finfo
->internal_syms
;
3968 indexp
= finfo
->sym_indices
;
3969 csectpp
= xcoff_data (input_bfd
)->csects
;
3970 lineno_counts
= xcoff_data (input_bfd
)->lineno_counts
;
3971 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
3972 outsym
= finfo
->outsyms
;
3975 while (esym
< esym_end
)
3979 add
= 1 + isymp
->n_numaux
;
3982 esym
+= add
* isymesz
;
3985 struct internal_syment isym
;
3988 /* Adjust the symbol in order to output it. */
3990 if (isym
._n
._n_n
._n_zeroes
== 0
3991 && isym
._n
._n_n
._n_offset
!= 0)
3993 /* This symbol has a long name. Enter it in the string
3994 table we are building. If *debug_index != -1, the
3995 name has already been entered in the .debug section. */
3996 if (*debug_index
>= 0)
3997 isym
._n
._n_n
._n_offset
= *debug_index
;
4003 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, NULL
);
4007 indx
= _bfd_stringtab_add (finfo
->strtab
, name
, hash
, copy
);
4008 if (indx
== (bfd_size_type
) -1)
4010 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
4014 /* The value of a C_FILE symbol is the symbol index of the
4015 next C_FILE symbol. The value of the last C_FILE symbol
4016 is -1. We try to get this right, below, just before we
4017 write the symbols out, but in the general case we may
4018 have to write the symbol out twice. */
4019 if (isym
.n_sclass
== C_FILE
)
4021 if (finfo
->last_file_index
!= -1
4022 && finfo
->last_file
.n_value
!= (bfd_vma
) *indexp
)
4024 /* We must correct the value of the last C_FILE entry. */
4025 finfo
->last_file
.n_value
= *indexp
;
4026 if ((bfd_size_type
) finfo
->last_file_index
>= syment_base
)
4028 /* The last C_FILE symbol is in this input file. */
4029 bfd_coff_swap_sym_out (output_bfd
,
4030 (void *) &finfo
->last_file
,
4031 (void *) (finfo
->outsyms
4032 + ((finfo
->last_file_index
4038 /* We have already written out the last C_FILE
4039 symbol. We need to write it out again. We
4040 borrow *outsym temporarily. */
4043 bfd_coff_swap_sym_out (output_bfd
,
4044 (void *) &finfo
->last_file
,
4047 pos
= obj_sym_filepos (output_bfd
);
4048 pos
+= finfo
->last_file_index
* osymesz
;
4049 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4050 || (bfd_bwrite (outsym
, osymesz
, output_bfd
)
4056 finfo
->last_file_index
= *indexp
;
4057 finfo
->last_file
= isym
;
4060 /* The value of a C_BINCL or C_EINCL symbol is a file offset
4061 into the line numbers. We update the symbol values when
4062 we handle the line numbers. */
4063 if (isym
.n_sclass
== C_BINCL
4064 || isym
.n_sclass
== C_EINCL
)
4066 isym
.n_value
= finfo
->line_filepos
;
4069 /* The value of a C_BSTAT symbol is the symbol table
4070 index of the containing csect. */
4071 else if (isym
.n_sclass
== C_BSTAT
)
4075 indx
= isym
.n_value
;
4076 if (indx
< obj_raw_syment_count (input_bfd
))
4080 symindx
= finfo
->sym_indices
[indx
];
4084 isym
.n_value
= symindx
;
4087 else if (isym
.n_sclass
!= C_ESTAT
4088 && isym
.n_sclass
!= C_DECL
4089 && isym
.n_scnum
> 0)
4091 isym
.n_scnum
= (*csectpp
)->output_section
->target_index
;
4092 isym
.n_value
+= ((*csectpp
)->output_section
->vma
4093 + (*csectpp
)->output_offset
4097 /* Output the symbol. */
4098 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
4103 for (i
= 0; i
< isymp
->n_numaux
&& esym
< esym_end
; i
++)
4105 union internal_auxent aux
;
4107 bfd_coff_swap_aux_in (input_bfd
, (void *) esym
, isymp
->n_type
,
4108 isymp
->n_sclass
, i
, isymp
->n_numaux
,
4111 if (isymp
->n_sclass
== C_FILE
)
4113 /* This is the file name (or some comment put in by
4114 the compiler). If it is long, we must put it in
4115 the string table. */
4116 if (aux
.x_file
.x_n
.x_zeroes
== 0
4117 && aux
.x_file
.x_n
.x_offset
!= 0)
4119 const char *filename
;
4122 BFD_ASSERT (aux
.x_file
.x_n
.x_offset
4123 >= STRING_SIZE_SIZE
);
4124 if (strings
== NULL
)
4126 strings
= _bfd_coff_read_string_table (input_bfd
);
4127 if (strings
== NULL
)
4130 filename
= strings
+ aux
.x_file
.x_n
.x_offset
;
4131 indx
= _bfd_stringtab_add (finfo
->strtab
, filename
,
4133 if (indx
== (bfd_size_type
) -1)
4135 aux
.x_file
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
4138 else if (CSECT_SYM_P (isymp
->n_sclass
)
4139 && i
+ 1 == isymp
->n_numaux
)
4142 /* We don't support type checking. I don't know if
4144 aux
.x_csect
.x_parmhash
= 0;
4145 /* I don't think anybody uses these fields, but we'd
4146 better clobber them just in case. */
4147 aux
.x_csect
.x_stab
= 0;
4148 aux
.x_csect
.x_snstab
= 0;
4150 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_LD
)
4154 indx
= aux
.x_csect
.x_scnlen
.l
;
4155 if (indx
< obj_raw_syment_count (input_bfd
))
4159 symindx
= finfo
->sym_indices
[indx
];
4162 aux
.x_csect
.x_scnlen
.l
= 0;
4166 aux
.x_csect
.x_scnlen
.l
= symindx
;
4171 else if (isymp
->n_sclass
!= C_STAT
|| isymp
->n_type
!= T_NULL
)
4175 if (ISFCN (isymp
->n_type
)
4176 || ISTAG (isymp
->n_sclass
)
4177 || isymp
->n_sclass
== C_BLOCK
4178 || isymp
->n_sclass
== C_FCN
)
4180 indx
= aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
4182 && indx
< obj_raw_syment_count (input_bfd
))
4184 /* We look forward through the symbol for
4185 the index of the next symbol we are going
4186 to include. I don't know if this is
4188 while (finfo
->sym_indices
[indx
] < 0
4189 && indx
< obj_raw_syment_count (input_bfd
))
4191 if (indx
>= obj_raw_syment_count (input_bfd
))
4192 indx
= output_index
;
4194 indx
= finfo
->sym_indices
[indx
];
4195 aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= indx
;
4200 indx
= aux
.x_sym
.x_tagndx
.l
;
4201 if (indx
> 0 && indx
< obj_raw_syment_count (input_bfd
))
4205 symindx
= finfo
->sym_indices
[indx
];
4207 aux
.x_sym
.x_tagndx
.l
= 0;
4209 aux
.x_sym
.x_tagndx
.l
= symindx
;
4214 /* Copy over the line numbers, unless we are stripping
4215 them. We do this on a symbol by symbol basis in
4216 order to more easily handle garbage collection. */
4217 if (CSECT_SYM_P (isymp
->n_sclass
)
4219 && isymp
->n_numaux
> 1
4220 && ISFCN (isymp
->n_type
)
4221 && aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
4223 if (*lineno_counts
== 0)
4224 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
4227 asection
*enclosing
;
4228 unsigned int enc_count
;
4229 bfd_signed_vma linoff
;
4230 struct internal_lineno lin
;
4237 /* Read in the enclosing section's line-number
4238 information, if we haven't already. */
4240 enclosing
= xcoff_section_data (abfd
, o
)->enclosing
;
4241 enc_count
= xcoff_section_data (abfd
, o
)->lineno_count
;
4242 if (oline
!= enclosing
)
4244 pos
= enclosing
->line_filepos
;
4245 amt
= linesz
* enc_count
;
4246 if (bfd_seek (input_bfd
, pos
, SEEK_SET
) != 0
4247 || (bfd_bread (finfo
->linenos
, amt
, input_bfd
)
4253 /* Copy across the first entry, adjusting its
4255 linoff
= (aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
4256 - enclosing
->line_filepos
);
4257 linp
= finfo
->linenos
+ linoff
;
4258 bfd_coff_swap_lineno_in (input_bfd
, linp
, &lin
);
4259 lin
.l_addr
.l_symndx
= *indexp
;
4260 bfd_coff_swap_lineno_out (output_bfd
, &lin
, linp
);
4263 /* Copy the other entries, adjusting their addresses. */
4264 linpend
= linp
+ *lineno_counts
* linesz
;
4265 offset
= (o
->output_section
->vma
4268 for (; linp
< linpend
; linp
+= linesz
)
4270 bfd_coff_swap_lineno_in (input_bfd
, linp
, &lin
);
4271 lin
.l_addr
.l_paddr
+= offset
;
4272 bfd_coff_swap_lineno_out (output_bfd
, &lin
, linp
);
4275 /* Write out the entries we've just processed. */
4276 pos
= (o
->output_section
->line_filepos
4277 + o
->output_section
->lineno_count
* linesz
);
4278 amt
= linesz
* *lineno_counts
;
4279 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4280 || bfd_bwrite (finfo
->linenos
+ linoff
,
4281 amt
, output_bfd
) != amt
)
4283 o
->output_section
->lineno_count
+= *lineno_counts
;
4285 /* Record the offset of the symbol's line numbers
4286 in the output file. */
4287 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= pos
;
4291 struct internal_syment
*iisp
, *iispend
;
4294 bfd_vma range_start
, range_end
;
4297 /* Update any C_BINCL or C_EINCL symbols
4298 that refer to a line number in the
4299 range we just output. */
4300 iisp
= finfo
->internal_syms
;
4301 iispend
= iisp
+ obj_raw_syment_count (input_bfd
);
4302 iindp
= finfo
->sym_indices
;
4303 oos
= finfo
->outsyms
;
4304 range_start
= enclosing
->line_filepos
+ linoff
;
4305 range_end
= range_start
+ *lineno_counts
* linesz
;
4306 while (iisp
< iispend
)
4309 && (iisp
->n_sclass
== C_BINCL
4310 || iisp
->n_sclass
== C_EINCL
)
4311 && iisp
->n_value
>= range_start
4312 && iisp
->n_value
< range_end
)
4314 struct internal_syment iis
;
4316 bfd_coff_swap_sym_in (output_bfd
, oos
, &iis
);
4317 iis
.n_value
= (iisp
->n_value
4320 bfd_coff_swap_sym_out (output_bfd
,
4325 iiadd
= 1 + iisp
->n_numaux
;
4327 oos
+= iiadd
* osymesz
;
4335 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, isymp
->n_type
,
4336 isymp
->n_sclass
, i
, isymp
->n_numaux
,
4346 lineno_counts
+= add
;
4350 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
4351 symbol will be the first symbol in the next input file. In the
4352 normal case, this will save us from writing out the C_FILE symbol
4354 if (finfo
->last_file_index
!= -1
4355 && (bfd_size_type
) finfo
->last_file_index
>= syment_base
)
4357 finfo
->last_file
.n_value
= output_index
;
4358 bfd_coff_swap_sym_out (output_bfd
, (void *) &finfo
->last_file
,
4359 (void *) (finfo
->outsyms
4360 + ((finfo
->last_file_index
- syment_base
)
4364 /* Write the modified symbols to the output file. */
4365 if (outsym
> finfo
->outsyms
)
4367 file_ptr pos
= obj_sym_filepos (output_bfd
) + syment_base
* osymesz
;
4368 bfd_size_type amt
= outsym
- finfo
->outsyms
;
4369 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4370 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
4373 BFD_ASSERT ((obj_raw_syment_count (output_bfd
)
4374 + (outsym
- finfo
->outsyms
) / osymesz
)
4377 obj_raw_syment_count (output_bfd
) = output_index
;
4380 /* Don't let the linker relocation routines discard the symbols. */
4381 keep_syms
= obj_coff_keep_syms (input_bfd
);
4382 obj_coff_keep_syms (input_bfd
) = TRUE
;
4384 /* Relocate the contents of each section. */
4385 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4389 if (! o
->linker_mark
)
4390 /* This section was omitted from the link. */
4393 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
4395 || (o
->flags
& SEC_IN_MEMORY
) != 0)
4398 /* We have set filepos correctly for the sections we created to
4399 represent csects, so bfd_get_section_contents should work. */
4400 if (coff_section_data (input_bfd
, o
) != NULL
4401 && coff_section_data (input_bfd
, o
)->contents
!= NULL
)
4402 contents
= coff_section_data (input_bfd
, o
)->contents
;
4405 bfd_size_type sz
= o
->rawsize
? o
->rawsize
: o
->size
;
4406 if (!bfd_get_section_contents (input_bfd
, o
, finfo
->contents
, 0, sz
))
4408 contents
= finfo
->contents
;
4411 if ((o
->flags
& SEC_RELOC
) != 0)
4414 struct internal_reloc
*internal_relocs
;
4415 struct internal_reloc
*irel
;
4417 struct internal_reloc
*irelend
;
4418 struct xcoff_link_hash_entry
**rel_hash
;
4421 /* Read in the relocs. */
4422 target_index
= o
->output_section
->target_index
;
4423 internal_relocs
= (xcoff_read_internal_relocs
4424 (input_bfd
, o
, FALSE
, finfo
->external_relocs
,
4426 (finfo
->section_info
[target_index
].relocs
4427 + o
->output_section
->reloc_count
)));
4428 if (internal_relocs
== NULL
)
4431 /* Call processor specific code to relocate the section
4433 if (! bfd_coff_relocate_section (output_bfd
, finfo
->info
,
4437 finfo
->internal_syms
,
4438 xcoff_data (input_bfd
)->csects
))
4441 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
4442 irel
= internal_relocs
;
4443 irelend
= irel
+ o
->reloc_count
;
4444 rel_hash
= (finfo
->section_info
[target_index
].rel_hashes
4445 + o
->output_section
->reloc_count
);
4446 for (; irel
< irelend
; irel
++, rel_hash
++)
4448 struct xcoff_link_hash_entry
*h
= NULL
;
4449 struct internal_ldrel ldrel
;
4453 /* Adjust the reloc address and symbol index. */
4455 irel
->r_vaddr
+= offset
;
4457 r_symndx
= irel
->r_symndx
;
4462 h
= obj_xcoff_sym_hashes (input_bfd
)[r_symndx
];
4464 if (r_symndx
!= -1 && finfo
->info
->strip
!= strip_all
)
4467 && h
->smclas
!= XMC_TD
4468 && (irel
->r_type
== R_TOC
4469 || irel
->r_type
== R_GL
4470 || irel
->r_type
== R_TCL
4471 || irel
->r_type
== R_TRL
4472 || irel
->r_type
== R_TRLA
))
4474 /* This is a TOC relative reloc with a symbol
4475 attached. The symbol should be the one which
4476 this reloc is for. We want to make this
4477 reloc against the TOC address of the symbol,
4478 not the symbol itself. */
4479 BFD_ASSERT (h
->toc_section
!= NULL
);
4480 BFD_ASSERT ((h
->flags
& XCOFF_SET_TOC
) == 0);
4481 if (h
->u
.toc_indx
!= -1)
4482 irel
->r_symndx
= h
->u
.toc_indx
;
4485 struct xcoff_toc_rel_hash
*n
;
4486 struct xcoff_link_section_info
*si
;
4490 n
= bfd_alloc (finfo
->output_bfd
, amt
);
4493 si
= finfo
->section_info
+ target_index
;
4494 n
->next
= si
->toc_rel_hashes
;
4497 si
->toc_rel_hashes
= n
;
4502 /* This is a global symbol. */
4504 irel
->r_symndx
= h
->indx
;
4507 /* This symbol is being written at the end
4508 of the file, and we do not yet know the
4509 symbol index. We save the pointer to the
4510 hash table entry in the rel_hash list.
4511 We set the indx field to -2 to indicate
4512 that this symbol must not be stripped. */
4521 indx
= finfo
->sym_indices
[r_symndx
];
4525 struct internal_syment
*is
;
4527 /* Relocations against a TC0 TOC anchor are
4528 automatically transformed to be against
4529 the TOC anchor in the output file. */
4530 is
= finfo
->internal_syms
+ r_symndx
;
4531 if (is
->n_sclass
== C_HIDEXT
4532 && is
->n_numaux
> 0)
4535 union internal_auxent aux
;
4539 obj_coff_external_syms (input_bfd
))
4540 + ((r_symndx
+ is
->n_numaux
)
4542 bfd_coff_swap_aux_in (input_bfd
, auxptr
,
4543 is
->n_type
, is
->n_sclass
,
4547 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_SD
4548 && aux
.x_csect
.x_smclas
== XMC_TC0
)
4549 indx
= finfo
->toc_symindx
;
4554 irel
->r_symndx
= indx
;
4558 struct internal_syment
*is
;
4561 char buf
[SYMNMLEN
+ 1];
4563 /* This reloc is against a symbol we are
4564 stripping. It would be possible to handle
4565 this case, but I don't think it's worth it. */
4566 is
= finfo
->internal_syms
+ r_symndx
;
4568 name
= (_bfd_coff_internal_syment_name
4569 (input_bfd
, is
, buf
));
4574 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
4575 (finfo
->info
, name
, input_bfd
, o
,
4582 switch (irel
->r_type
)
4586 || h
->root
.type
== bfd_link_hash_defined
4587 || h
->root
.type
== bfd_link_hash_defweak
4588 || h
->root
.type
== bfd_link_hash_common
)
4596 && (h
->root
.type
== bfd_link_hash_defined
4597 || h
->root
.type
== bfd_link_hash_defweak
)
4598 && bfd_is_abs_section (h
->root
.u
.def
.section
))
4600 /* This reloc needs to be copied into the .loader
4602 ldrel
.l_vaddr
= irel
->r_vaddr
;
4604 ldrel
.l_symndx
= -(bfd_size_type
) 1;
4606 || (h
->root
.type
== bfd_link_hash_defined
4607 || h
->root
.type
== bfd_link_hash_defweak
4608 || h
->root
.type
== bfd_link_hash_common
))
4613 sec
= xcoff_data (input_bfd
)->csects
[r_symndx
];
4614 else if (h
->root
.type
== bfd_link_hash_common
)
4615 sec
= h
->root
.u
.c
.p
->section
;
4617 sec
= h
->root
.u
.def
.section
;
4618 sec
= sec
->output_section
;
4620 if (strcmp (sec
->name
, ".text") == 0)
4622 else if (strcmp (sec
->name
, ".data") == 0)
4624 else if (strcmp (sec
->name
, ".bss") == 0)
4628 (*_bfd_error_handler
)
4629 (_("%B: loader reloc in unrecognized section `%A'"),
4631 bfd_set_error (bfd_error_nonrepresentable_section
);
4639 (*_bfd_error_handler
)
4640 (_("%B: `%s' in loader reloc but not loader sym"),
4642 h
->root
.root
.string
);
4643 bfd_set_error (bfd_error_bad_value
);
4646 ldrel
.l_symndx
= h
->ldindx
;
4648 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
4649 ldrel
.l_rsecnm
= o
->output_section
->target_index
;
4650 if (xcoff_hash_table (finfo
->info
)->textro
4651 && strcmp (o
->output_section
->name
, ".text") == 0)
4653 (*_bfd_error_handler
)
4654 (_("%B: loader reloc in read-only section %A"),
4655 input_bfd
, o
->output_section
);
4656 bfd_set_error (bfd_error_invalid_operation
);
4659 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
,
4662 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
4670 /* We should never need a .loader reloc for a TOC
4676 o
->output_section
->reloc_count
+= o
->reloc_count
;
4679 /* Write out the modified section contents. */
4680 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
4681 contents
, (file_ptr
) o
->output_offset
,
4686 obj_coff_keep_syms (input_bfd
) = keep_syms
;
4688 if (! finfo
->info
->keep_memory
)
4690 if (! _bfd_coff_free_symbols (input_bfd
))
4700 /* Sort relocs by VMA. This is called via qsort. */
4703 xcoff_sort_relocs (const void * p1
, const void * p2
)
4705 const struct internal_reloc
*r1
= (const struct internal_reloc
*) p1
;
4706 const struct internal_reloc
*r2
= (const struct internal_reloc
*) p2
;
4708 if (r1
->r_vaddr
> r2
->r_vaddr
)
4710 else if (r1
->r_vaddr
< r2
->r_vaddr
)
4716 /* Return true if section SEC is a TOC section. */
4718 static inline bfd_boolean
4719 xcoff_toc_section_p (asection
*sec
)
4724 if (name
[0] == '.' && name
[1] == 't')
4728 if (name
[3] == '0' && name
[4] == 0)
4733 if (name
[2] == 'd' && name
[3] == 0)
4739 /* See if the link requires a TOC (it usually does!). If so, find a
4740 good place to put the TOC anchor csect, and write out the associated
4744 xcoff_find_tc0 (bfd
*output_bfd
, struct xcoff_final_link_info
*finfo
)
4746 bfd_vma toc_start
, toc_end
, start
, end
, best_address
;
4750 struct internal_syment irsym
;
4751 union internal_auxent iraux
;
4755 /* Set [TOC_START, TOC_END) to the range of the TOC. Record the
4756 index of a csect at the beginning of the TOC. */
4757 toc_start
= ~(bfd_vma
) 0;
4760 for (input_bfd
= finfo
->info
->input_bfds
;
4762 input_bfd
= input_bfd
->link_next
)
4763 for (sec
= input_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4764 if ((sec
->flags
& SEC_MARK
) != 0 && xcoff_toc_section_p (sec
))
4766 start
= sec
->output_section
->vma
+ sec
->output_offset
;
4767 if (toc_start
> start
)
4770 section_index
= sec
->output_section
->target_index
;
4773 end
= start
+ sec
->size
;
4778 /* There's no need for a TC0 symbol if we don't have a TOC. */
4779 if (toc_end
< toc_start
)
4781 xcoff_data (output_bfd
)->toc
= toc_start
;
4785 if (toc_end
- toc_start
< 0x8000)
4786 /* Every TOC csect can be accessed from TOC_START. */
4787 best_address
= toc_start
;
4790 /* Find the lowest TOC csect that is still within range of TOC_END. */
4791 best_address
= toc_end
;
4792 for (input_bfd
= finfo
->info
->input_bfds
;
4794 input_bfd
= input_bfd
->link_next
)
4795 for (sec
= input_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4796 if ((sec
->flags
& SEC_MARK
) != 0 && xcoff_toc_section_p (sec
))
4798 start
= sec
->output_section
->vma
+ sec
->output_offset
;
4799 if (start
< best_address
4800 && start
+ 0x8000 >= toc_end
)
4802 best_address
= start
;
4803 section_index
= sec
->output_section
->target_index
;
4807 /* Make sure that the start of the TOC is also within range. */
4808 if (best_address
> toc_start
+ 0x8000)
4810 (*_bfd_error_handler
)
4811 (_("TOC overflow: 0x%lx > 0x10000; try -mminimal-toc "
4813 (unsigned long) (toc_end
- toc_start
));
4814 bfd_set_error (bfd_error_file_too_big
);
4819 /* Record the chosen TOC value. */
4820 finfo
->toc_symindx
= obj_raw_syment_count (output_bfd
);
4821 xcoff_data (output_bfd
)->toc
= best_address
;
4822 xcoff_data (output_bfd
)->sntoc
= section_index
;
4824 /* Fill out the TC0 symbol. */
4825 if (!bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
, &irsym
, "TOC"))
4827 irsym
.n_value
= best_address
;
4828 irsym
.n_scnum
= section_index
;
4829 irsym
.n_sclass
= C_HIDEXT
;
4830 irsym
.n_type
= T_NULL
;
4832 bfd_coff_swap_sym_out (output_bfd
, &irsym
, finfo
->outsyms
);
4834 /* Fill out the auxillary csect information. */
4835 memset (&iraux
, 0, sizeof iraux
);
4836 iraux
.x_csect
.x_smtyp
= XTY_SD
;
4837 iraux
.x_csect
.x_smclas
= XMC_TC0
;
4838 iraux
.x_csect
.x_scnlen
.l
= 0;
4839 bfd_coff_swap_aux_out (output_bfd
, &iraux
, T_NULL
, C_HIDEXT
, 0, 1,
4840 finfo
->outsyms
+ bfd_coff_symesz (output_bfd
));
4842 /* Write the contents to the file. */
4843 pos
= obj_sym_filepos (output_bfd
);
4844 pos
+= obj_raw_syment_count (output_bfd
) * bfd_coff_symesz (output_bfd
);
4845 size
= 2 * bfd_coff_symesz (output_bfd
);
4846 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4847 || bfd_bwrite (finfo
->outsyms
, size
, output_bfd
) != size
)
4849 obj_raw_syment_count (output_bfd
) += 2;
4854 /* Write out a non-XCOFF global symbol. */
4857 xcoff_write_global_symbol (struct xcoff_link_hash_entry
*h
, void * inf
)
4859 struct xcoff_final_link_info
*finfo
= (struct xcoff_final_link_info
*) inf
;
4862 struct internal_syment isym
;
4863 union internal_auxent aux
;
4868 output_bfd
= finfo
->output_bfd
;
4869 outsym
= finfo
->outsyms
;
4871 if (h
->root
.type
== bfd_link_hash_warning
)
4873 h
= (struct xcoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4874 if (h
->root
.type
== bfd_link_hash_new
)
4878 /* If this symbol was garbage collected, just skip it. */
4879 if (xcoff_hash_table (finfo
->info
)->gc
4880 && (h
->flags
& XCOFF_MARK
) == 0)
4883 /* If we need a .loader section entry, write it out. */
4884 if (h
->ldsym
!= NULL
)
4886 struct internal_ldsym
*ldsym
;
4891 if (h
->root
.type
== bfd_link_hash_undefined
4892 || h
->root
.type
== bfd_link_hash_undefweak
)
4896 ldsym
->l_scnum
= N_UNDEF
;
4897 ldsym
->l_smtype
= XTY_ER
;
4898 impbfd
= h
->root
.u
.undef
.abfd
;
4901 else if (h
->root
.type
== bfd_link_hash_defined
4902 || h
->root
.type
== bfd_link_hash_defweak
)
4906 sec
= h
->root
.u
.def
.section
;
4907 ldsym
->l_value
= (sec
->output_section
->vma
4908 + sec
->output_offset
4909 + h
->root
.u
.def
.value
);
4910 ldsym
->l_scnum
= sec
->output_section
->target_index
;
4911 ldsym
->l_smtype
= XTY_SD
;
4912 impbfd
= sec
->owner
;
4918 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
4919 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4920 || (h
->flags
& XCOFF_IMPORT
) != 0)
4922 Import symbols are defined so the check above will make
4923 the l_smtype XTY_SD. But this is not correct, it should
4925 ldsym
->l_smtype
|= L_IMPORT
;
4927 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
4928 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4929 || (h
->flags
& XCOFF_EXPORT
) != 0)
4930 ldsym
->l_smtype
|= L_EXPORT
;
4932 if ((h
->flags
& XCOFF_ENTRY
) != 0)
4933 ldsym
->l_smtype
|= L_ENTRY
;
4935 if ((h
->flags
& XCOFF_RTINIT
) != 0)
4936 ldsym
->l_smtype
= XTY_SD
;
4938 ldsym
->l_smclas
= h
->smclas
;
4940 if (ldsym
->l_smtype
& L_IMPORT
)
4942 if ((h
->root
.type
== bfd_link_hash_defined
4943 || h
->root
.type
== bfd_link_hash_defweak
)
4944 && (h
->root
.u
.def
.value
!= 0))
4945 ldsym
->l_smclas
= XMC_XO
;
4947 else if ((h
->flags
& (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
)) ==
4948 (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
))
4949 ldsym
->l_smclas
= XMC_SV3264
;
4951 else if (h
->flags
& XCOFF_SYSCALL32
)
4952 ldsym
->l_smclas
= XMC_SV
;
4954 else if (h
->flags
& XCOFF_SYSCALL64
)
4955 ldsym
->l_smclas
= XMC_SV64
;
4958 if (ldsym
->l_ifile
== -(bfd_size_type
) 1)
4962 else if (ldsym
->l_ifile
== 0)
4964 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
4966 else if (impbfd
== NULL
)
4970 BFD_ASSERT (impbfd
->xvec
== output_bfd
->xvec
);
4971 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
4977 BFD_ASSERT (h
->ldindx
>= 0);
4979 bfd_xcoff_swap_ldsym_out (output_bfd
, ldsym
,
4982 * bfd_xcoff_ldsymsz(finfo
->output_bfd
)));
4986 /* If this symbol needs global linkage code, write it out. */
4987 if (h
->root
.type
== bfd_link_hash_defined
4988 && (h
->root
.u
.def
.section
4989 == xcoff_hash_table (finfo
->info
)->linkage_section
))
4995 p
= h
->root
.u
.def
.section
->contents
+ h
->root
.u
.def
.value
;
4997 /* The first instruction in the global linkage code loads a
4998 specific TOC element. */
4999 tocoff
= (h
->descriptor
->toc_section
->output_section
->vma
5000 + h
->descriptor
->toc_section
->output_offset
5001 - xcoff_data (output_bfd
)->toc
);
5003 if ((h
->descriptor
->flags
& XCOFF_SET_TOC
) != 0)
5004 tocoff
+= h
->descriptor
->u
.toc_offset
;
5006 /* The first instruction in the glink code needs to be
5007 cooked to to hold the correct offset in the toc. The
5008 rest are just output raw. */
5009 bfd_put_32 (output_bfd
,
5010 bfd_xcoff_glink_code(output_bfd
, 0) | (tocoff
& 0xffff), p
);
5012 /* Start with i == 1 to get past the first instruction done above
5013 The /4 is because the glink code is in bytes and we are going
5015 for (i
= 1; i
< bfd_xcoff_glink_code_size(output_bfd
) / 4; i
++)
5016 bfd_put_32 (output_bfd
,
5017 (bfd_vma
) bfd_xcoff_glink_code(output_bfd
, i
),
5021 /* If we created a TOC entry for this symbol, write out the required
5023 if ((h
->flags
& XCOFF_SET_TOC
) != 0)
5028 struct internal_reloc
*irel
;
5029 struct internal_ldrel ldrel
;
5030 struct internal_syment irsym
;
5031 union internal_auxent iraux
;
5033 tocsec
= h
->toc_section
;
5034 osec
= tocsec
->output_section
;
5035 oindx
= osec
->target_index
;
5036 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
5037 irel
->r_vaddr
= (osec
->vma
5038 + tocsec
->output_offset
5042 irel
->r_symndx
= h
->indx
;
5046 irel
->r_symndx
= obj_raw_syment_count (output_bfd
);
5049 BFD_ASSERT (h
->ldindx
>= 0);
5051 /* Initialize the aux union here instead of closer to when it is
5052 written out below because the length of the csect depends on
5053 whether the output is 32 or 64 bit. */
5054 memset (&iraux
, 0, sizeof iraux
);
5055 iraux
.x_csect
.x_smtyp
= XTY_SD
;
5056 /* iraux.x_csect.x_scnlen.l = 4 or 8, see below. */
5057 iraux
.x_csect
.x_smclas
= XMC_TC
;
5059 /* 32 bit uses a 32 bit R_POS to do the relocations
5060 64 bit uses a 64 bit R_POS to do the relocations
5062 Also needs to change the csect size : 4 for 32 bit, 8 for 64 bit
5064 Which one is determined by the backend. */
5065 if (bfd_xcoff_is_xcoff64 (output_bfd
))
5068 iraux
.x_csect
.x_scnlen
.l
= 8;
5070 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
5073 iraux
.x_csect
.x_scnlen
.l
= 4;
5078 irel
->r_type
= R_POS
;
5079 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5080 ++osec
->reloc_count
;
5082 ldrel
.l_vaddr
= irel
->r_vaddr
;
5083 ldrel
.l_symndx
= h
->ldindx
;
5084 ldrel
.l_rtype
= (irel
->r_size
<< 8) | R_POS
;
5085 ldrel
.l_rsecnm
= oindx
;
5086 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5087 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5089 /* We need to emit a symbol to define a csect which holds
5091 if (finfo
->info
->strip
!= strip_all
)
5093 result
= bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
,
5094 &irsym
, h
->root
.root
.string
);
5098 irsym
.n_value
= irel
->r_vaddr
;
5099 irsym
.n_scnum
= osec
->target_index
;
5100 irsym
.n_sclass
= C_HIDEXT
;
5101 irsym
.n_type
= T_NULL
;
5104 bfd_coff_swap_sym_out (output_bfd
, (void *) &irsym
, (void *) outsym
);
5105 outsym
+= bfd_coff_symesz (output_bfd
);
5107 /* Note : iraux is initialized above. */
5108 bfd_coff_swap_aux_out (output_bfd
, (void *) &iraux
, T_NULL
, C_HIDEXT
,
5109 0, 1, (void *) outsym
);
5110 outsym
+= bfd_coff_auxesz (output_bfd
);
5114 /* We aren't going to write out the symbols below, so we
5115 need to write them out now. */
5116 pos
= obj_sym_filepos (output_bfd
);
5117 pos
+= (obj_raw_syment_count (output_bfd
)
5118 * bfd_coff_symesz (output_bfd
));
5119 amt
= outsym
- finfo
->outsyms
;
5120 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5121 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
5123 obj_raw_syment_count (output_bfd
) +=
5124 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
5126 outsym
= finfo
->outsyms
;
5131 /* If this symbol is a specially defined function descriptor, write
5132 it out. The first word is the address of the function code
5133 itself, the second word is the address of the TOC, and the third
5137 The addresses for the 32 bit will take 4 bytes and the addresses
5138 for 64 bit will take 8 bytes. Similar for the relocs. This type
5139 of logic was also done above to create a TOC entry in
5140 xcoff_write_global_symbol. */
5141 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
5142 && h
->root
.type
== bfd_link_hash_defined
5143 && (h
->root
.u
.def
.section
5144 == xcoff_hash_table (finfo
->info
)->descriptor_section
))
5150 struct xcoff_link_hash_entry
*hentry
;
5152 struct internal_reloc
*irel
;
5153 struct internal_ldrel ldrel
;
5155 unsigned int reloc_size
, byte_size
;
5157 if (bfd_xcoff_is_xcoff64 (output_bfd
))
5162 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
5170 sec
= h
->root
.u
.def
.section
;
5171 osec
= sec
->output_section
;
5172 oindx
= osec
->target_index
;
5173 p
= sec
->contents
+ h
->root
.u
.def
.value
;
5175 hentry
= h
->descriptor
;
5176 BFD_ASSERT (hentry
!= NULL
5177 && (hentry
->root
.type
== bfd_link_hash_defined
5178 || hentry
->root
.type
== bfd_link_hash_defweak
));
5179 esec
= hentry
->root
.u
.def
.section
;
5181 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
5182 irel
->r_vaddr
= (osec
->vma
5183 + sec
->output_offset
5184 + h
->root
.u
.def
.value
);
5185 irel
->r_symndx
= esec
->output_section
->target_index
;
5186 irel
->r_type
= R_POS
;
5187 irel
->r_size
= reloc_size
;
5188 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5189 ++osec
->reloc_count
;
5191 ldrel
.l_vaddr
= irel
->r_vaddr
;
5192 if (strcmp (esec
->output_section
->name
, ".text") == 0)
5194 else if (strcmp (esec
->output_section
->name
, ".data") == 0)
5196 else if (strcmp (esec
->output_section
->name
, ".bss") == 0)
5200 (*_bfd_error_handler
)
5201 (_("%s: loader reloc in unrecognized section `%s'"),
5202 bfd_get_filename (output_bfd
),
5203 esec
->output_section
->name
);
5204 bfd_set_error (bfd_error_nonrepresentable_section
);
5207 ldrel
.l_rtype
= (reloc_size
<< 8) | R_POS
;
5208 ldrel
.l_rsecnm
= oindx
;
5209 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5210 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5212 /* There are three items to write out,
5213 the address of the code
5214 the address of the toc anchor
5215 the environment pointer.
5216 We are ignoring the environment pointer. So set it to zero. */
5217 if (bfd_xcoff_is_xcoff64 (output_bfd
))
5219 bfd_put_64 (output_bfd
,
5220 (esec
->output_section
->vma
+ esec
->output_offset
5221 + hentry
->root
.u
.def
.value
),
5223 bfd_put_64 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 8);
5224 bfd_put_64 (output_bfd
, (bfd_vma
) 0, p
+ 16);
5229 This logic was already called above so the error case where
5230 the backend is neither has already been checked. */
5231 bfd_put_32 (output_bfd
,
5232 (esec
->output_section
->vma
+ esec
->output_offset
5233 + hentry
->root
.u
.def
.value
),
5235 bfd_put_32 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 4);
5236 bfd_put_32 (output_bfd
, (bfd_vma
) 0, p
+ 8);
5239 tsec
= coff_section_from_bfd_index (output_bfd
,
5240 xcoff_data (output_bfd
)->sntoc
);
5243 irel
->r_vaddr
= (osec
->vma
5244 + sec
->output_offset
5245 + h
->root
.u
.def
.value
5247 irel
->r_symndx
= tsec
->output_section
->target_index
;
5248 irel
->r_type
= R_POS
;
5249 irel
->r_size
= reloc_size
;
5250 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5251 ++osec
->reloc_count
;
5253 ldrel
.l_vaddr
= irel
->r_vaddr
;
5254 if (strcmp (tsec
->output_section
->name
, ".text") == 0)
5256 else if (strcmp (tsec
->output_section
->name
, ".data") == 0)
5258 else if (strcmp (tsec
->output_section
->name
, ".bss") == 0)
5262 (*_bfd_error_handler
)
5263 (_("%s: loader reloc in unrecognized section `%s'"),
5264 bfd_get_filename (output_bfd
),
5265 tsec
->output_section
->name
);
5266 bfd_set_error (bfd_error_nonrepresentable_section
);
5269 ldrel
.l_rtype
= (reloc_size
<< 8) | R_POS
;
5270 ldrel
.l_rsecnm
= oindx
;
5271 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5272 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5275 if (h
->indx
>= 0 || finfo
->info
->strip
== strip_all
)
5277 BFD_ASSERT (outsym
== finfo
->outsyms
);
5282 && (finfo
->info
->strip
== strip_all
5283 || (finfo
->info
->strip
== strip_some
5284 && bfd_hash_lookup (finfo
->info
->keep_hash
, h
->root
.root
.string
,
5285 FALSE
, FALSE
) == NULL
)))
5287 BFD_ASSERT (outsym
== finfo
->outsyms
);
5292 && (h
->flags
& (XCOFF_REF_REGULAR
| XCOFF_DEF_REGULAR
)) == 0)
5294 BFD_ASSERT (outsym
== finfo
->outsyms
);
5298 memset (&aux
, 0, sizeof aux
);
5300 h
->indx
= obj_raw_syment_count (output_bfd
);
5302 result
= bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
, &isym
,
5303 h
->root
.root
.string
);
5307 if (h
->root
.type
== bfd_link_hash_undefined
5308 || h
->root
.type
== bfd_link_hash_undefweak
)
5311 isym
.n_scnum
= N_UNDEF
;
5312 if (h
->root
.type
== bfd_link_hash_undefweak
5313 && C_WEAKEXT
== C_AIX_WEAKEXT
)
5314 isym
.n_sclass
= C_WEAKEXT
;
5316 isym
.n_sclass
= C_EXT
;
5317 aux
.x_csect
.x_smtyp
= XTY_ER
;
5319 else if ((h
->root
.type
== bfd_link_hash_defined
5320 || h
->root
.type
== bfd_link_hash_defweak
)
5321 && h
->smclas
== XMC_XO
)
5323 BFD_ASSERT (bfd_is_abs_section (h
->root
.u
.def
.section
));
5324 isym
.n_value
= h
->root
.u
.def
.value
;
5325 isym
.n_scnum
= N_UNDEF
;
5326 if (h
->root
.type
== bfd_link_hash_undefweak
5327 && C_WEAKEXT
== C_AIX_WEAKEXT
)
5328 isym
.n_sclass
= C_WEAKEXT
;
5330 isym
.n_sclass
= C_EXT
;
5331 aux
.x_csect
.x_smtyp
= XTY_ER
;
5333 else if (h
->root
.type
== bfd_link_hash_defined
5334 || h
->root
.type
== bfd_link_hash_defweak
)
5336 struct xcoff_link_size_list
*l
;
5338 isym
.n_value
= (h
->root
.u
.def
.section
->output_section
->vma
5339 + h
->root
.u
.def
.section
->output_offset
5340 + h
->root
.u
.def
.value
);
5341 if (bfd_is_abs_section (h
->root
.u
.def
.section
->output_section
))
5342 isym
.n_scnum
= N_ABS
;
5344 isym
.n_scnum
= h
->root
.u
.def
.section
->output_section
->target_index
;
5345 isym
.n_sclass
= C_HIDEXT
;
5346 aux
.x_csect
.x_smtyp
= XTY_SD
;
5348 if ((h
->flags
& XCOFF_HAS_SIZE
) != 0)
5350 for (l
= xcoff_hash_table (finfo
->info
)->size_list
;
5356 aux
.x_csect
.x_scnlen
.l
= l
->size
;
5362 else if (h
->root
.type
== bfd_link_hash_common
)
5364 isym
.n_value
= (h
->root
.u
.c
.p
->section
->output_section
->vma
5365 + h
->root
.u
.c
.p
->section
->output_offset
);
5366 isym
.n_scnum
= h
->root
.u
.c
.p
->section
->output_section
->target_index
;
5367 isym
.n_sclass
= C_EXT
;
5368 aux
.x_csect
.x_smtyp
= XTY_CM
;
5369 aux
.x_csect
.x_scnlen
.l
= h
->root
.u
.c
.size
;
5374 isym
.n_type
= T_NULL
;
5377 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
5378 outsym
+= bfd_coff_symesz (output_bfd
);
5380 aux
.x_csect
.x_smclas
= h
->smclas
;
5381 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, T_NULL
, isym
.n_sclass
, 0, 1,
5383 outsym
+= bfd_coff_auxesz (output_bfd
);
5385 if ((h
->root
.type
== bfd_link_hash_defined
5386 || h
->root
.type
== bfd_link_hash_defweak
)
5387 && h
->smclas
!= XMC_XO
)
5389 /* We just output an SD symbol. Now output an LD symbol. */
5392 if (h
->root
.type
== bfd_link_hash_undefweak
5393 && C_WEAKEXT
== C_AIX_WEAKEXT
)
5394 isym
.n_sclass
= C_WEAKEXT
;
5396 isym
.n_sclass
= C_EXT
;
5397 bfd_coff_swap_sym_out (output_bfd
, (void *) &isym
, (void *) outsym
);
5398 outsym
+= bfd_coff_symesz (output_bfd
);
5400 aux
.x_csect
.x_smtyp
= XTY_LD
;
5401 aux
.x_csect
.x_scnlen
.l
= obj_raw_syment_count (output_bfd
);
5402 bfd_coff_swap_aux_out (output_bfd
, (void *) &aux
, T_NULL
, C_EXT
, 0, 1,
5404 outsym
+= bfd_coff_auxesz (output_bfd
);
5407 pos
= obj_sym_filepos (output_bfd
);
5408 pos
+= obj_raw_syment_count (output_bfd
) * bfd_coff_symesz (output_bfd
);
5409 amt
= outsym
- finfo
->outsyms
;
5410 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5411 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
5413 obj_raw_syment_count (output_bfd
) +=
5414 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
5419 /* Handle a link order which is supposed to generate a reloc. */
5422 xcoff_reloc_link_order (bfd
*output_bfd
,
5423 struct xcoff_final_link_info
*finfo
,
5424 asection
*output_section
,
5425 struct bfd_link_order
*link_order
)
5427 reloc_howto_type
*howto
;
5428 struct xcoff_link_hash_entry
*h
;
5432 struct internal_reloc
*irel
;
5433 struct xcoff_link_hash_entry
**rel_hash_ptr
;
5434 struct internal_ldrel ldrel
;
5436 if (link_order
->type
== bfd_section_reloc_link_order
)
5437 /* We need to somehow locate a symbol in the right section. The
5438 symbol must either have a value of zero, or we must adjust
5439 the addend by the value of the symbol. FIXME: Write this
5440 when we need it. The old linker couldn't handle this anyhow. */
5443 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
5446 bfd_set_error (bfd_error_bad_value
);
5450 h
= ((struct xcoff_link_hash_entry
*)
5451 bfd_wrapped_link_hash_lookup (output_bfd
, finfo
->info
,
5452 link_order
->u
.reloc
.p
->u
.name
,
5453 FALSE
, FALSE
, TRUE
));
5456 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
5457 (finfo
->info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0)))
5462 if (h
->root
.type
== bfd_link_hash_common
)
5464 hsec
= h
->root
.u
.c
.p
->section
;
5467 else if (h
->root
.type
== bfd_link_hash_defined
5468 || h
->root
.type
== bfd_link_hash_defweak
)
5470 hsec
= h
->root
.u
.def
.section
;
5471 hval
= h
->root
.u
.def
.value
;
5479 addend
= link_order
->u
.reloc
.p
->addend
;
5481 addend
+= (hsec
->output_section
->vma
5482 + hsec
->output_offset
5489 bfd_reloc_status_type rstat
;
5492 size
= bfd_get_reloc_size (howto
);
5493 buf
= bfd_zmalloc (size
);
5497 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
5503 case bfd_reloc_outofrange
:
5505 case bfd_reloc_overflow
:
5506 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
5507 (finfo
->info
, NULL
, link_order
->u
.reloc
.p
->u
.name
,
5508 howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0)))
5515 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
5516 (file_ptr
) link_order
->offset
, size
);
5522 /* Store the reloc information in the right place. It will get
5523 swapped and written out at the end of the final_link routine. */
5524 irel
= (finfo
->section_info
[output_section
->target_index
].relocs
5525 + output_section
->reloc_count
);
5526 rel_hash_ptr
= (finfo
->section_info
[output_section
->target_index
].rel_hashes
5527 + output_section
->reloc_count
);
5529 memset (irel
, 0, sizeof (struct internal_reloc
));
5530 *rel_hash_ptr
= NULL
;
5532 irel
->r_vaddr
= output_section
->vma
+ link_order
->offset
;
5535 irel
->r_symndx
= h
->indx
;
5538 /* Set the index to -2 to force this symbol to get written out. */
5544 irel
->r_type
= howto
->type
;
5545 irel
->r_size
= howto
->bitsize
- 1;
5546 if (howto
->complain_on_overflow
== complain_overflow_signed
)
5547 irel
->r_size
|= 0x80;
5549 ++output_section
->reloc_count
;
5551 /* Now output the reloc to the .loader section. */
5553 ldrel
.l_vaddr
= irel
->r_vaddr
;
5557 const char *secname
;
5559 secname
= hsec
->output_section
->name
;
5561 if (strcmp (secname
, ".text") == 0)
5563 else if (strcmp (secname
, ".data") == 0)
5565 else if (strcmp (secname
, ".bss") == 0)
5569 (*_bfd_error_handler
)
5570 (_("%s: loader reloc in unrecognized section `%s'"),
5571 bfd_get_filename (output_bfd
), secname
);
5572 bfd_set_error (bfd_error_nonrepresentable_section
);
5580 (*_bfd_error_handler
)
5581 (_("%s: `%s' in loader reloc but not loader sym"),
5582 bfd_get_filename (output_bfd
),
5583 h
->root
.root
.string
);
5584 bfd_set_error (bfd_error_bad_value
);
5587 ldrel
.l_symndx
= h
->ldindx
;
5590 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
5591 ldrel
.l_rsecnm
= output_section
->target_index
;
5592 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5593 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5598 /* Do the final link step. */
5601 _bfd_xcoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
5603 bfd_size_type symesz
;
5604 struct xcoff_final_link_info finfo
;
5606 struct bfd_link_order
*p
;
5607 bfd_size_type max_contents_size
;
5608 bfd_size_type max_sym_count
;
5609 bfd_size_type max_lineno_count
;
5610 bfd_size_type max_reloc_count
;
5611 bfd_size_type max_output_reloc_count
;
5612 file_ptr rel_filepos
;
5614 file_ptr line_filepos
;
5615 unsigned int linesz
;
5617 bfd_byte
*external_relocs
= NULL
;
5618 char strbuf
[STRING_SIZE_SIZE
];
5623 abfd
->flags
|= DYNAMIC
;
5625 symesz
= bfd_coff_symesz (abfd
);
5628 finfo
.output_bfd
= abfd
;
5629 finfo
.strtab
= NULL
;
5630 finfo
.section_info
= NULL
;
5631 finfo
.last_file_index
= -1;
5632 finfo
.toc_symindx
= -1;
5633 finfo
.internal_syms
= NULL
;
5634 finfo
.sym_indices
= NULL
;
5635 finfo
.outsyms
= NULL
;
5636 finfo
.linenos
= NULL
;
5637 finfo
.contents
= NULL
;
5638 finfo
.external_relocs
= NULL
;
5640 finfo
.ldsym
= (xcoff_hash_table (info
)->loader_section
->contents
5641 + bfd_xcoff_ldhdrsz (abfd
));
5642 finfo
.ldrel
= (xcoff_hash_table (info
)->loader_section
->contents
5643 + bfd_xcoff_ldhdrsz(abfd
)
5644 + (xcoff_hash_table (info
)->ldhdr
.l_nsyms
5645 * bfd_xcoff_ldsymsz(abfd
)));
5647 xcoff_data (abfd
)->coff
.link_info
= info
;
5649 finfo
.strtab
= _bfd_stringtab_init ();
5650 if (finfo
.strtab
== NULL
)
5653 /* Count the relocation entries required for the output file.
5654 (We've already counted the line numbers.) Determine a few
5656 max_contents_size
= 0;
5657 max_lineno_count
= 0;
5658 max_reloc_count
= 0;
5659 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5662 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
5664 if (p
->type
== bfd_indirect_link_order
)
5668 sec
= p
->u
.indirect
.section
;
5670 /* Mark all sections which are to be included in the
5671 link. This will normally be every section. We need
5672 to do this so that we can identify any sections which
5673 the linker has decided to not include. */
5674 sec
->linker_mark
= TRUE
;
5676 o
->reloc_count
+= sec
->reloc_count
;
5678 if (sec
->rawsize
> max_contents_size
)
5679 max_contents_size
= sec
->rawsize
;
5680 if (sec
->size
> max_contents_size
)
5681 max_contents_size
= sec
->size
;
5682 if (coff_section_data (sec
->owner
, sec
) != NULL
5683 && xcoff_section_data (sec
->owner
, sec
) != NULL
5684 && (xcoff_section_data (sec
->owner
, sec
)->lineno_count
5685 > max_lineno_count
))
5687 xcoff_section_data (sec
->owner
, sec
)->lineno_count
;
5688 if (sec
->reloc_count
> max_reloc_count
)
5689 max_reloc_count
= sec
->reloc_count
;
5691 else if (p
->type
== bfd_section_reloc_link_order
5692 || p
->type
== bfd_symbol_reloc_link_order
)
5697 /* Compute the file positions for all the sections. */
5698 if (abfd
->output_has_begun
)
5700 if (xcoff_hash_table (info
)->file_align
!= 0)
5707 file_align
= xcoff_hash_table (info
)->file_align
;
5708 if (file_align
!= 0)
5710 bfd_boolean saw_contents
;
5714 /* Insert .pad sections before every section which has
5715 contents and is loaded, if it is preceded by some other
5716 section which has contents and is loaded. */
5717 saw_contents
= TRUE
;
5718 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5720 if (strcmp (o
->name
, ".pad") == 0)
5721 saw_contents
= FALSE
;
5722 else if ((o
->flags
& SEC_HAS_CONTENTS
) != 0
5723 && (o
->flags
& SEC_LOAD
) != 0)
5726 saw_contents
= TRUE
;
5731 /* Create a pad section and place it before the section
5732 that needs padding. This requires unlinking and
5733 relinking the bfd's section list. */
5735 n
= bfd_make_section_anyway_with_flags (abfd
, ".pad",
5737 n
->alignment_power
= 0;
5739 bfd_section_list_remove (abfd
, n
);
5740 bfd_section_list_insert_before (abfd
, o
, n
);
5741 saw_contents
= FALSE
;
5746 /* Reset the section indices after inserting the new
5749 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5752 o
->target_index
= indx
;
5754 BFD_ASSERT ((unsigned int) indx
== abfd
->section_count
);
5756 /* Work out appropriate sizes for the .pad sections to force
5757 each section to land on a page boundary. This bit of
5758 code knows what compute_section_file_positions is going
5760 sofar
= bfd_coff_filhsz (abfd
);
5761 sofar
+= bfd_coff_aoutsz (abfd
);
5762 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
5763 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5764 if ((bfd_xcoff_is_reloc_count_overflow
5765 (abfd
, (bfd_vma
) o
->reloc_count
))
5766 || (bfd_xcoff_is_lineno_count_overflow
5767 (abfd
, (bfd_vma
) o
->lineno_count
)))
5768 /* 64 does not overflow, need to check if 32 does */
5769 sofar
+= bfd_coff_scnhsz (abfd
);
5771 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5773 if (strcmp (o
->name
, ".pad") == 0)
5777 BFD_ASSERT (o
->size
== 0);
5778 pageoff
= sofar
& (file_align
- 1);
5781 o
->size
= file_align
- pageoff
;
5782 sofar
+= file_align
- pageoff
;
5783 o
->flags
|= SEC_HAS_CONTENTS
;
5788 if ((o
->flags
& SEC_HAS_CONTENTS
) != 0)
5789 sofar
+= BFD_ALIGN (o
->size
,
5790 1 << o
->alignment_power
);
5795 if (! bfd_coff_compute_section_file_positions (abfd
))
5799 /* Allocate space for the pointers we need to keep for the relocs. */
5803 /* We use section_count + 1, rather than section_count, because
5804 the target_index fields are 1 based. */
5805 amt
= abfd
->section_count
+ 1;
5806 amt
*= sizeof (struct xcoff_link_section_info
);
5807 finfo
.section_info
= bfd_malloc (amt
);
5808 if (finfo
.section_info
== NULL
)
5810 for (i
= 0; i
<= abfd
->section_count
; i
++)
5812 finfo
.section_info
[i
].relocs
= NULL
;
5813 finfo
.section_info
[i
].rel_hashes
= NULL
;
5814 finfo
.section_info
[i
].toc_rel_hashes
= NULL
;
5818 /* Set the file positions for the relocs. */
5819 rel_filepos
= obj_relocbase (abfd
);
5820 relsz
= bfd_coff_relsz (abfd
);
5821 max_output_reloc_count
= 0;
5822 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5824 if (o
->reloc_count
== 0)
5828 /* A stripped file has no relocs. However, we still
5829 allocate the buffers, so that later code doesn't have to
5830 worry about whether we are stripping or not. */
5831 if (info
->strip
== strip_all
)
5835 o
->flags
|= SEC_RELOC
;
5836 o
->rel_filepos
= rel_filepos
;
5837 rel_filepos
+= o
->reloc_count
* relsz
;
5840 /* We don't know the indices of global symbols until we have
5841 written out all the local symbols. For each section in
5842 the output file, we keep an array of pointers to hash
5843 table entries. Each entry in the array corresponds to a
5844 reloc. When we find a reloc against a global symbol, we
5845 set the corresponding entry in this array so that we can
5846 fix up the symbol index after we have written out all the
5849 Because of this problem, we also keep the relocs in
5850 memory until the end of the link. This wastes memory.
5851 We could backpatch the file later, I suppose, although it
5853 amt
= o
->reloc_count
;
5854 amt
*= sizeof (struct internal_reloc
);
5855 finfo
.section_info
[o
->target_index
].relocs
= bfd_malloc (amt
);
5857 amt
= o
->reloc_count
;
5858 amt
*= sizeof (struct xcoff_link_hash_entry
*);
5859 finfo
.section_info
[o
->target_index
].rel_hashes
= bfd_malloc (amt
);
5861 if (finfo
.section_info
[o
->target_index
].relocs
== NULL
5862 || finfo
.section_info
[o
->target_index
].rel_hashes
== NULL
)
5865 if (o
->reloc_count
> max_output_reloc_count
)
5866 max_output_reloc_count
= o
->reloc_count
;
5870 /* We now know the size of the relocs, so we can determine the file
5871 positions of the line numbers. */
5872 line_filepos
= rel_filepos
;
5873 finfo
.line_filepos
= line_filepos
;
5874 linesz
= bfd_coff_linesz (abfd
);
5875 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5877 if (o
->lineno_count
== 0)
5878 o
->line_filepos
= 0;
5881 o
->line_filepos
= line_filepos
;
5882 line_filepos
+= o
->lineno_count
* linesz
;
5885 /* Reset the reloc and lineno counts, so that we can use them to
5886 count the number of entries we have output so far. */
5888 o
->lineno_count
= 0;
5891 obj_sym_filepos (abfd
) = line_filepos
;
5893 /* Figure out the largest number of symbols in an input BFD. Take
5894 the opportunity to clear the output_has_begun fields of all the
5895 input BFD's. We want at least 6 symbols, since that is the
5896 number which xcoff_write_global_symbol may need. */
5898 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
5902 sub
->output_has_begun
= FALSE
;
5903 sz
= obj_raw_syment_count (sub
);
5904 if (sz
> max_sym_count
)
5908 /* Allocate some buffers used while linking. */
5909 amt
= max_sym_count
* sizeof (struct internal_syment
);
5910 finfo
.internal_syms
= bfd_malloc (amt
);
5912 amt
= max_sym_count
* sizeof (long);
5913 finfo
.sym_indices
= bfd_malloc (amt
);
5915 amt
= (max_sym_count
+ 1) * symesz
;
5916 finfo
.outsyms
= bfd_malloc (amt
);
5918 amt
= max_lineno_count
* bfd_coff_linesz (abfd
);
5919 finfo
.linenos
= bfd_malloc (amt
);
5921 amt
= max_contents_size
;
5922 finfo
.contents
= bfd_malloc (amt
);
5924 amt
= max_reloc_count
* relsz
;
5925 finfo
.external_relocs
= bfd_malloc (amt
);
5927 if ((finfo
.internal_syms
== NULL
&& max_sym_count
> 0)
5928 || (finfo
.sym_indices
== NULL
&& max_sym_count
> 0)
5929 || finfo
.outsyms
== NULL
5930 || (finfo
.linenos
== NULL
&& max_lineno_count
> 0)
5931 || (finfo
.contents
== NULL
&& max_contents_size
> 0)
5932 || (finfo
.external_relocs
== NULL
&& max_reloc_count
> 0))
5935 obj_raw_syment_count (abfd
) = 0;
5937 /* Find a TOC symbol, if we need one. */
5938 if (!xcoff_find_tc0 (abfd
, &finfo
))
5941 /* We now know the position of everything in the file, except that
5942 we don't know the size of the symbol table and therefore we don't
5943 know where the string table starts. We just build the string
5944 table in memory as we go along. We process all the relocations
5945 for a single input file at once. */
5946 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5948 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
5950 if (p
->type
== bfd_indirect_link_order
5951 && p
->u
.indirect
.section
->owner
->xvec
== abfd
->xvec
)
5953 sub
= p
->u
.indirect
.section
->owner
;
5954 if (! sub
->output_has_begun
)
5956 if (! xcoff_link_input_bfd (&finfo
, sub
))
5958 sub
->output_has_begun
= TRUE
;
5961 else if (p
->type
== bfd_section_reloc_link_order
5962 || p
->type
== bfd_symbol_reloc_link_order
)
5964 if (! xcoff_reloc_link_order (abfd
, &finfo
, o
, p
))
5969 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
5975 /* Free up the buffers used by xcoff_link_input_bfd. */
5976 if (finfo
.internal_syms
!= NULL
)
5978 free (finfo
.internal_syms
);
5979 finfo
.internal_syms
= NULL
;
5981 if (finfo
.sym_indices
!= NULL
)
5983 free (finfo
.sym_indices
);
5984 finfo
.sym_indices
= NULL
;
5986 if (finfo
.linenos
!= NULL
)
5988 free (finfo
.linenos
);
5989 finfo
.linenos
= NULL
;
5991 if (finfo
.contents
!= NULL
)
5993 free (finfo
.contents
);
5994 finfo
.contents
= NULL
;
5996 if (finfo
.external_relocs
!= NULL
)
5998 free (finfo
.external_relocs
);
5999 finfo
.external_relocs
= NULL
;
6002 /* The value of the last C_FILE symbol is supposed to be -1. Write
6004 if (finfo
.last_file_index
!= -1)
6006 finfo
.last_file
.n_value
= -(bfd_vma
) 1;
6007 bfd_coff_swap_sym_out (abfd
, (void *) &finfo
.last_file
,
6008 (void *) finfo
.outsyms
);
6009 pos
= obj_sym_filepos (abfd
) + finfo
.last_file_index
* symesz
;
6010 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
6011 || bfd_bwrite (finfo
.outsyms
, symesz
, abfd
) != symesz
)
6015 /* Write out all the global symbols which do not come from XCOFF
6017 xcoff_link_hash_traverse (xcoff_hash_table (info
),
6018 xcoff_write_global_symbol
,
6021 if (finfo
.outsyms
!= NULL
)
6023 free (finfo
.outsyms
);
6024 finfo
.outsyms
= NULL
;
6027 /* Now that we have written out all the global symbols, we know the
6028 symbol indices to use for relocs against them, and we can finally
6029 write out the relocs. */
6030 amt
= max_output_reloc_count
* relsz
;
6031 external_relocs
= bfd_malloc (amt
);
6032 if (external_relocs
== NULL
&& max_output_reloc_count
!= 0)
6035 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6037 struct internal_reloc
*irel
;
6038 struct internal_reloc
*irelend
;
6039 struct xcoff_link_hash_entry
**rel_hash
;
6040 struct xcoff_toc_rel_hash
*toc_rel_hash
;
6042 bfd_size_type rel_size
;
6044 /* A stripped file has no relocs. */
6045 if (info
->strip
== strip_all
)
6051 if (o
->reloc_count
== 0)
6054 irel
= finfo
.section_info
[o
->target_index
].relocs
;
6055 irelend
= irel
+ o
->reloc_count
;
6056 rel_hash
= finfo
.section_info
[o
->target_index
].rel_hashes
;
6057 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
6059 if (*rel_hash
!= NULL
)
6061 if ((*rel_hash
)->indx
< 0)
6063 if (! ((*info
->callbacks
->unattached_reloc
)
6064 (info
, (*rel_hash
)->root
.root
.string
,
6065 NULL
, o
, irel
->r_vaddr
)))
6067 (*rel_hash
)->indx
= 0;
6069 irel
->r_symndx
= (*rel_hash
)->indx
;
6073 for (toc_rel_hash
= finfo
.section_info
[o
->target_index
].toc_rel_hashes
;
6074 toc_rel_hash
!= NULL
;
6075 toc_rel_hash
= toc_rel_hash
->next
)
6077 if (toc_rel_hash
->h
->u
.toc_indx
< 0)
6079 if (! ((*info
->callbacks
->unattached_reloc
)
6080 (info
, toc_rel_hash
->h
->root
.root
.string
,
6081 NULL
, o
, toc_rel_hash
->rel
->r_vaddr
)))
6083 toc_rel_hash
->h
->u
.toc_indx
= 0;
6085 toc_rel_hash
->rel
->r_symndx
= toc_rel_hash
->h
->u
.toc_indx
;
6088 /* XCOFF requires that the relocs be sorted by address. We tend
6089 to produce them in the order in which their containing csects
6090 appear in the symbol table, which is not necessarily by
6091 address. So we sort them here. There may be a better way to
6093 qsort ((void *) finfo
.section_info
[o
->target_index
].relocs
,
6094 o
->reloc_count
, sizeof (struct internal_reloc
),
6097 irel
= finfo
.section_info
[o
->target_index
].relocs
;
6098 irelend
= irel
+ o
->reloc_count
;
6099 erel
= external_relocs
;
6100 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
6101 bfd_coff_swap_reloc_out (abfd
, (void *) irel
, (void *) erel
);
6103 rel_size
= relsz
* o
->reloc_count
;
6104 if (bfd_seek (abfd
, o
->rel_filepos
, SEEK_SET
) != 0
6105 || bfd_bwrite ((void *) external_relocs
, rel_size
, abfd
) != rel_size
)
6109 if (external_relocs
!= NULL
)
6111 free (external_relocs
);
6112 external_relocs
= NULL
;
6115 /* Free up the section information. */
6116 if (finfo
.section_info
!= NULL
)
6120 for (i
= 0; i
< abfd
->section_count
; i
++)
6122 if (finfo
.section_info
[i
].relocs
!= NULL
)
6123 free (finfo
.section_info
[i
].relocs
);
6124 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
6125 free (finfo
.section_info
[i
].rel_hashes
);
6127 free (finfo
.section_info
);
6128 finfo
.section_info
= NULL
;
6131 /* Write out the loader section contents. */
6132 BFD_ASSERT ((bfd_byte
*) finfo
.ldrel
6133 == (xcoff_hash_table (info
)->loader_section
->contents
6134 + xcoff_hash_table (info
)->ldhdr
.l_impoff
));
6135 o
= xcoff_hash_table (info
)->loader_section
;
6136 if (! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
6137 (file_ptr
) o
->output_offset
, o
->size
))
6140 /* Write out the magic sections. */
6141 o
= xcoff_hash_table (info
)->linkage_section
;
6143 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
6144 (file_ptr
) o
->output_offset
,
6147 o
= xcoff_hash_table (info
)->toc_section
;
6149 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
6150 (file_ptr
) o
->output_offset
,
6153 o
= xcoff_hash_table (info
)->descriptor_section
;
6155 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
6156 (file_ptr
) o
->output_offset
,
6160 /* Write out the string table. */
6161 pos
= obj_sym_filepos (abfd
) + obj_raw_syment_count (abfd
) * symesz
;
6162 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
6165 _bfd_stringtab_size (finfo
.strtab
) + STRING_SIZE_SIZE
,
6167 amt
= STRING_SIZE_SIZE
;
6168 if (bfd_bwrite (strbuf
, amt
, abfd
) != amt
)
6170 if (! _bfd_stringtab_emit (abfd
, finfo
.strtab
))
6173 _bfd_stringtab_free (finfo
.strtab
);
6175 /* Write out the debugging string table. */
6176 o
= xcoff_hash_table (info
)->debug_section
;
6179 struct bfd_strtab_hash
*debug_strtab
;
6181 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
6182 BFD_ASSERT (o
->output_section
->size
- o
->output_offset
6183 >= _bfd_stringtab_size (debug_strtab
));
6184 pos
= o
->output_section
->filepos
+ o
->output_offset
;
6185 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
6187 if (! _bfd_stringtab_emit (abfd
, debug_strtab
))
6191 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
6192 not try to write out the symbols. */
6193 bfd_get_symcount (abfd
) = 0;
6198 if (finfo
.strtab
!= NULL
)
6199 _bfd_stringtab_free (finfo
.strtab
);
6201 if (finfo
.section_info
!= NULL
)
6205 for (i
= 0; i
< abfd
->section_count
; i
++)
6207 if (finfo
.section_info
[i
].relocs
!= NULL
)
6208 free (finfo
.section_info
[i
].relocs
);
6209 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
6210 free (finfo
.section_info
[i
].rel_hashes
);
6212 free (finfo
.section_info
);
6215 if (finfo
.internal_syms
!= NULL
)
6216 free (finfo
.internal_syms
);
6217 if (finfo
.sym_indices
!= NULL
)
6218 free (finfo
.sym_indices
);
6219 if (finfo
.outsyms
!= NULL
)
6220 free (finfo
.outsyms
);
6221 if (finfo
.linenos
!= NULL
)
6222 free (finfo
.linenos
);
6223 if (finfo
.contents
!= NULL
)
6224 free (finfo
.contents
);
6225 if (finfo
.external_relocs
!= NULL
)
6226 free (finfo
.external_relocs
);
6227 if (external_relocs
!= NULL
)
6228 free (external_relocs
);