1 /* POWER/PowerPC XCOFF linker support.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 #include "coff/internal.h"
27 #include "coff/xcoff.h"
31 /* This file holds the XCOFF linker code. */
33 #define STRING_SIZE_SIZE (4)
35 /* We reuse the SEC_ROM flag as a mark flag for garbage collection.
36 This flag will only be used on input sections. */
38 #define SEC_MARK (SEC_ROM)
40 /* The list of import files. */
42 struct xcoff_import_file
44 /* The next entry in the list. */
45 struct xcoff_import_file
*next
;
50 /* The member name. */
54 /* Information we keep for each section in the output file during the
57 struct xcoff_link_section_info
59 /* The relocs to be output. */
60 struct internal_reloc
*relocs
;
61 /* For each reloc against a global symbol whose index was not known
62 when the reloc was handled, the global hash table entry. */
63 struct xcoff_link_hash_entry
**rel_hashes
;
64 /* If there is a TOC relative reloc against a global symbol, and the
65 index of the TOC symbol is not known when the reloc was handled,
66 an entry is added to this linked list. This is not an array,
67 like rel_hashes, because this case is quite uncommon. */
68 struct xcoff_toc_rel_hash
{
69 struct xcoff_toc_rel_hash
*next
;
70 struct xcoff_link_hash_entry
*h
;
71 struct internal_reloc
*rel
;
75 /* Information that we pass around while doing the final link step. */
77 struct xcoff_final_link_info
79 /* General link information. */
80 struct bfd_link_info
*info
;
83 /* Hash table for long symbol names. */
84 struct bfd_strtab_hash
*strtab
;
85 /* Array of information kept for each output section, indexed by the
86 target_index field. */
87 struct xcoff_link_section_info
*section_info
;
88 /* Symbol index of last C_FILE symbol (-1 if none). */
90 /* Contents of last C_FILE symbol. */
91 struct internal_syment last_file
;
92 /* Symbol index of TOC symbol. */
94 /* Start of .loader symbols. */
96 /* Next .loader reloc to swap out. */
98 /* File position of start of line numbers. */
99 file_ptr line_filepos
;
100 /* Buffer large enough to hold swapped symbols of any input file. */
101 struct internal_syment
*internal_syms
;
102 /* Buffer large enough to hold output indices of symbols of any
105 /* Buffer large enough to hold output symbols for any input file. */
107 /* Buffer large enough to hold external line numbers for any input
110 /* Buffer large enough to hold any input section. */
112 /* Buffer large enough to hold external relocs of any input section. */
113 bfd_byte
*external_relocs
;
116 static struct bfd_hash_entry
*xcoff_link_hash_newfunc
117 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
118 static boolean xcoff_get_section_contents
PARAMS ((bfd
*, asection
*));
119 static struct internal_reloc
*xcoff_read_internal_relocs
120 PARAMS ((bfd
*, asection
*, boolean
, bfd_byte
*, boolean
,
121 struct internal_reloc
*));
122 static boolean xcoff_link_add_object_symbols
123 PARAMS ((bfd
*, struct bfd_link_info
*));
124 static boolean xcoff_link_check_archive_element
125 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*));
126 static boolean xcoff_link_check_ar_symbols
127 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*));
128 static boolean xcoff_link_check_dynamic_ar_symbols
129 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*));
130 static bfd_size_type xcoff_find_reloc
131 PARAMS ((struct internal_reloc
*, bfd_size_type
, bfd_vma
));
132 static boolean xcoff_link_add_symbols
PARAMS ((bfd
*, struct bfd_link_info
*));
133 static boolean xcoff_link_add_dynamic_symbols
134 PARAMS ((bfd
*, struct bfd_link_info
*));
135 static boolean xcoff_mark_symbol
136 PARAMS ((struct bfd_link_info
*, struct xcoff_link_hash_entry
*));
137 static boolean xcoff_mark
PARAMS ((struct bfd_link_info
*, asection
*));
138 static void xcoff_sweep
PARAMS ((struct bfd_link_info
*));
139 static boolean xcoff_build_ldsyms
140 PARAMS ((struct xcoff_link_hash_entry
*, PTR
));
141 static boolean xcoff_link_input_bfd
142 PARAMS ((struct xcoff_final_link_info
*, bfd
*));
143 static boolean xcoff_write_global_symbol
144 PARAMS ((struct xcoff_link_hash_entry
*, PTR
));
145 static boolean xcoff_reloc_link_order
146 PARAMS ((bfd
*, struct xcoff_final_link_info
*, asection
*,
147 struct bfd_link_order
*));
148 static int xcoff_sort_relocs
PARAMS ((const PTR
, const PTR
));
151 /* Routines to read XCOFF dynamic information. This don't really
152 belong here, but we already have the ldsym manipulation routines
155 /* Read the contents of a section. */
158 xcoff_get_section_contents (abfd
, sec
)
163 if (coff_section_data (abfd
, sec
) == NULL
)
165 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
166 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
167 if (sec
->used_by_bfd
== NULL
)
171 if (coff_section_data (abfd
, sec
)->contents
== NULL
)
173 coff_section_data (abfd
, sec
)->contents
= ((bfd_byte
*)
174 bfd_malloc (sec
->_raw_size
));
175 if (coff_section_data (abfd
, sec
)->contents
== NULL
)
178 if (! bfd_get_section_contents (abfd
, sec
,
179 coff_section_data (abfd
, sec
)->contents
,
180 (file_ptr
) 0, sec
->_raw_size
))
187 /* Get the size required to hold the dynamic symbols. */
190 _bfd_xcoff_get_dynamic_symtab_upper_bound (abfd
)
195 struct internal_ldhdr ldhdr
;
197 if ((abfd
->flags
& DYNAMIC
) == 0)
199 bfd_set_error (bfd_error_invalid_operation
);
203 lsec
= bfd_get_section_by_name (abfd
, ".loader");
206 bfd_set_error (bfd_error_no_symbols
);
210 if (! xcoff_get_section_contents (abfd
, lsec
))
212 contents
= coff_section_data (abfd
, lsec
)->contents
;
214 bfd_xcoff_swap_ldhdr_in (abfd
, (PTR
) contents
, &ldhdr
);
216 return (ldhdr
.l_nsyms
+ 1) * sizeof (asymbol
*);
219 /* Get the dynamic symbols. */
222 _bfd_xcoff_canonicalize_dynamic_symtab (abfd
, psyms
)
228 struct internal_ldhdr ldhdr
;
230 bfd_byte
*elsym
, *elsymend
;
231 coff_symbol_type
*symbuf
;
233 if ((abfd
->flags
& DYNAMIC
) == 0)
235 bfd_set_error (bfd_error_invalid_operation
);
239 lsec
= bfd_get_section_by_name (abfd
, ".loader");
242 bfd_set_error (bfd_error_no_symbols
);
246 if (! xcoff_get_section_contents (abfd
, lsec
))
248 contents
= coff_section_data (abfd
, lsec
)->contents
;
250 coff_section_data (abfd
, lsec
)->keep_contents
= true;
252 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
254 strings
= (char *) contents
+ ldhdr
.l_stoff
;
256 symbuf
= ((coff_symbol_type
*)
257 bfd_zalloc (abfd
, ldhdr
.l_nsyms
* sizeof (coff_symbol_type
)));
261 elsym
= contents
+ bfd_xcoff_loader_symbol_offset(abfd
, &ldhdr
);
263 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz(abfd
);
264 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz(abfd
), symbuf
++, psyms
++)
266 struct internal_ldsym ldsym
;
268 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
270 symbuf
->symbol
.the_bfd
= abfd
;
272 if (ldsym
._l
._l_l
._l_zeroes
== 0)
273 symbuf
->symbol
.name
= strings
+ ldsym
._l
._l_l
._l_offset
;
278 c
= bfd_alloc (abfd
, (bfd_size_type
) SYMNMLEN
+ 1);
281 memcpy (c
, ldsym
._l
._l_name
, SYMNMLEN
);
283 symbuf
->symbol
.name
= c
;
286 if (ldsym
.l_smclas
== XMC_XO
)
287 symbuf
->symbol
.section
= bfd_abs_section_ptr
;
289 symbuf
->symbol
.section
= coff_section_from_bfd_index (abfd
,
291 symbuf
->symbol
.value
= ldsym
.l_value
- symbuf
->symbol
.section
->vma
;
293 symbuf
->symbol
.flags
= BSF_NO_FLAGS
;
294 if ((ldsym
.l_smtype
& L_EXPORT
) != 0)
295 symbuf
->symbol
.flags
|= BSF_GLOBAL
;
297 /* FIXME: We have no way to record the other information stored
298 with the loader symbol. */
300 *psyms
= (asymbol
*) symbuf
;
305 return ldhdr
.l_nsyms
;
308 /* Get the size required to hold the dynamic relocs. */
311 _bfd_xcoff_get_dynamic_reloc_upper_bound (abfd
)
316 struct internal_ldhdr ldhdr
;
318 if ((abfd
->flags
& DYNAMIC
) == 0)
320 bfd_set_error (bfd_error_invalid_operation
);
324 lsec
= bfd_get_section_by_name (abfd
, ".loader");
327 bfd_set_error (bfd_error_no_symbols
);
331 if (! xcoff_get_section_contents (abfd
, lsec
))
333 contents
= coff_section_data (abfd
, lsec
)->contents
;
335 bfd_xcoff_swap_ldhdr_in (abfd
, (struct external_ldhdr
*) contents
, &ldhdr
);
337 return (ldhdr
.l_nreloc
+ 1) * sizeof (arelent
*);
340 /* Get the dynamic relocs. */
343 _bfd_xcoff_canonicalize_dynamic_reloc (abfd
, prelocs
, syms
)
350 struct internal_ldhdr ldhdr
;
352 bfd_byte
*elrel
, *elrelend
;
354 if ((abfd
->flags
& DYNAMIC
) == 0)
356 bfd_set_error (bfd_error_invalid_operation
);
360 lsec
= bfd_get_section_by_name (abfd
, ".loader");
363 bfd_set_error (bfd_error_no_symbols
);
367 if (! xcoff_get_section_contents (abfd
, lsec
))
369 contents
= coff_section_data (abfd
, lsec
)->contents
;
371 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
373 relbuf
= (arelent
*) bfd_alloc (abfd
, ldhdr
.l_nreloc
* sizeof (arelent
));
377 elrel
= contents
+ bfd_xcoff_loader_reloc_offset(abfd
, &ldhdr
);
379 elrelend
= elrel
+ ldhdr
.l_nreloc
* bfd_xcoff_ldrelsz(abfd
);
380 for (; elrel
< elrelend
; elrel
+= bfd_xcoff_ldrelsz(abfd
), relbuf
++,
383 struct internal_ldrel ldrel
;
385 bfd_xcoff_swap_ldrel_in (abfd
, elrel
, &ldrel
);
387 if (ldrel
.l_symndx
>= 3)
388 relbuf
->sym_ptr_ptr
= syms
+ (ldrel
.l_symndx
- 3);
394 switch (ldrel
.l_symndx
)
410 sec
= bfd_get_section_by_name (abfd
, name
);
413 bfd_set_error (bfd_error_bad_value
);
417 relbuf
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
420 relbuf
->address
= ldrel
.l_vaddr
;
423 /* Most dynamic relocs have the same type. FIXME: This is only
424 correct if ldrel.l_rtype == 0. In other cases, we should use
425 a different howto. */
426 relbuf
->howto
= bfd_xcoff_dynamic_reloc_howto(abfd
);
428 /* FIXME: We have no way to record the l_rsecnm field. */
435 return ldhdr
.l_nreloc
;
438 /* Routine to create an entry in an XCOFF link hash table. */
440 static struct bfd_hash_entry
*
441 xcoff_link_hash_newfunc (entry
, table
, string
)
442 struct bfd_hash_entry
*entry
;
443 struct bfd_hash_table
*table
;
446 struct xcoff_link_hash_entry
*ret
= (struct xcoff_link_hash_entry
*) entry
;
448 /* Allocate the structure if it has not already been allocated by a
450 if (ret
== (struct xcoff_link_hash_entry
*) NULL
)
451 ret
= ((struct xcoff_link_hash_entry
*)
452 bfd_hash_allocate (table
, sizeof (struct xcoff_link_hash_entry
)));
453 if (ret
== (struct xcoff_link_hash_entry
*) NULL
)
454 return (struct bfd_hash_entry
*) ret
;
456 /* Call the allocation method of the superclass. */
457 ret
= ((struct xcoff_link_hash_entry
*)
458 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
462 /* Set local fields. */
464 ret
->toc_section
= NULL
;
465 ret
->u
.toc_indx
= -1;
466 ret
->descriptor
= NULL
;
470 ret
->smclas
= XMC_UA
;
473 return (struct bfd_hash_entry
*) ret
;
476 /* Create a XCOFF link hash table. */
478 struct bfd_link_hash_table
*
479 _bfd_xcoff_bfd_link_hash_table_create (abfd
)
482 struct xcoff_link_hash_table
*ret
;
483 bfd_size_type amt
= sizeof (struct xcoff_link_hash_table
);
485 ret
= (struct xcoff_link_hash_table
*) bfd_alloc (abfd
, amt
);
486 if (ret
== (struct xcoff_link_hash_table
*) NULL
)
487 return (struct bfd_link_hash_table
*) NULL
;
488 if (! _bfd_link_hash_table_init (&ret
->root
, abfd
, xcoff_link_hash_newfunc
))
490 bfd_release (abfd
, ret
);
491 return (struct bfd_link_hash_table
*) NULL
;
494 ret
->debug_strtab
= _bfd_xcoff_stringtab_init ();
495 ret
->debug_section
= NULL
;
496 ret
->loader_section
= NULL
;
497 ret
->ldrel_count
= 0;
498 memset (&ret
->ldhdr
, 0, sizeof (struct internal_ldhdr
));
499 ret
->linkage_section
= NULL
;
500 ret
->toc_section
= NULL
;
501 ret
->descriptor_section
= NULL
;
506 memset (ret
->special_sections
, 0, sizeof ret
->special_sections
);
508 /* The linker will always generate a full a.out header. We need to
509 record that fact now, before the sizeof_headers routine could be
511 xcoff_data (abfd
)->full_aouthdr
= true;
517 /* Read internal relocs for an XCOFF csect. This is a wrapper around
518 _bfd_coff_read_internal_relocs which tries to take advantage of any
519 relocs which may have been cached for the enclosing section. */
521 static struct internal_reloc
*
522 xcoff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
523 require_internal
, internal_relocs
)
527 bfd_byte
*external_relocs
;
528 boolean require_internal
;
529 struct internal_reloc
*internal_relocs
;
532 if (coff_section_data (abfd
, sec
) != NULL
533 && coff_section_data (abfd
, sec
)->relocs
== NULL
534 && xcoff_section_data (abfd
, sec
) != NULL
)
538 enclosing
= xcoff_section_data (abfd
, sec
)->enclosing
;
540 if (enclosing
!= NULL
541 && (coff_section_data (abfd
, enclosing
) == NULL
542 || coff_section_data (abfd
, enclosing
)->relocs
== NULL
)
544 && enclosing
->reloc_count
> 0)
546 if (_bfd_coff_read_internal_relocs (abfd
, enclosing
, true,
547 external_relocs
, false,
548 (struct internal_reloc
*) NULL
)
553 if (enclosing
!= NULL
554 && coff_section_data (abfd
, enclosing
) != NULL
555 && coff_section_data (abfd
, enclosing
)->relocs
!= NULL
)
559 off
= ((sec
->rel_filepos
- enclosing
->rel_filepos
)
560 / bfd_coff_relsz (abfd
));
562 if (! require_internal
)
563 return coff_section_data (abfd
, enclosing
)->relocs
+ off
;
564 memcpy (internal_relocs
,
565 coff_section_data (abfd
, enclosing
)->relocs
+ off
,
566 sec
->reloc_count
* sizeof (struct internal_reloc
));
567 return internal_relocs
;
571 return _bfd_coff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
572 require_internal
, internal_relocs
);
575 /* Given an XCOFF BFD, add symbols to the global hash table as
579 _bfd_xcoff_bfd_link_add_symbols (abfd
, info
)
581 struct bfd_link_info
*info
;
584 switch (bfd_get_format (abfd
))
587 return xcoff_link_add_object_symbols (abfd
, info
);
590 /* If the archive has a map, do the usual search. We then need
591 to check the archive for stripped dynamic objects, because
592 they will not appear in the archive map even though they
593 should, perhaps, be included. If the archive has no map, we
594 just consider each object file in turn, since that apparently
595 is what the AIX native linker does. */
596 if (bfd_has_map (abfd
))
598 if (! (_bfd_generic_link_add_archive_symbols
599 (abfd
, info
, xcoff_link_check_archive_element
)))
606 member
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
607 while (member
!= NULL
)
609 if (bfd_check_format (member
, bfd_object
)
610 && (! bfd_has_map (abfd
)
611 || ((member
->flags
& DYNAMIC
) != 0
612 && (member
->flags
& HAS_SYMS
) == 0)))
616 if (! xcoff_link_check_archive_element (member
, info
, &needed
))
619 member
->archive_pass
= -1;
621 member
= bfd_openr_next_archived_file (abfd
, member
);
628 bfd_set_error (bfd_error_wrong_format
);
633 /* Add symbols from an XCOFF object file. */
636 xcoff_link_add_object_symbols (abfd
, info
)
638 struct bfd_link_info
*info
;
641 if (! _bfd_coff_get_external_symbols (abfd
))
643 if (! xcoff_link_add_symbols (abfd
, info
))
645 if (! info
->keep_memory
)
647 if (! _bfd_coff_free_symbols (abfd
))
653 /* Check a single archive element to see if we need to include it in
654 the link. *PNEEDED is set according to whether this element is
655 needed in the link or not. This is called via
656 _bfd_generic_link_add_archive_symbols. */
659 xcoff_link_check_archive_element (abfd
, info
, pneeded
)
661 struct bfd_link_info
*info
;
665 if (! _bfd_coff_get_external_symbols (abfd
))
668 if (! xcoff_link_check_ar_symbols (abfd
, info
, pneeded
))
673 if (! xcoff_link_add_symbols (abfd
, info
))
677 if (! info
->keep_memory
|| ! *pneeded
)
679 if (! _bfd_coff_free_symbols (abfd
))
686 /* Look through the symbols to see if this object file should be
687 included in the link. */
690 xcoff_link_check_ar_symbols (abfd
, info
, pneeded
)
692 struct bfd_link_info
*info
;
695 bfd_size_type symesz
;
701 if ((abfd
->flags
& DYNAMIC
) != 0
702 && ! info
->static_link
703 && info
->hash
->creator
== abfd
->xvec
)
704 return xcoff_link_check_dynamic_ar_symbols (abfd
, info
, pneeded
);
706 symesz
= bfd_coff_symesz (abfd
);
707 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
708 esym_end
= esym
+ obj_raw_syment_count (abfd
) * symesz
;
709 while (esym
< esym_end
)
711 struct internal_syment sym
;
713 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &sym
);
715 if (sym
.n_sclass
== C_EXT
&& sym
.n_scnum
!= N_UNDEF
)
718 char buf
[SYMNMLEN
+ 1];
719 struct bfd_link_hash_entry
*h
;
721 /* This symbol is externally visible, and is defined by this
724 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
728 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
730 /* We are only interested in symbols that are currently
731 undefined. If a symbol is currently known to be common,
732 XCOFF linkers do not bring in an object file which
733 defines it. We also don't bring in symbols to satisfy
734 undefined references in shared objects. */
735 if (h
!= (struct bfd_link_hash_entry
*) NULL
736 && h
->type
== bfd_link_hash_undefined
737 && (info
->hash
->creator
!= abfd
->xvec
738 || (((struct xcoff_link_hash_entry
*) h
)->flags
739 & XCOFF_DEF_DYNAMIC
) == 0))
741 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
748 esym
+= (sym
.n_numaux
+ 1) * symesz
;
751 /* We do not need this object file. */
755 /* Look through the loader symbols to see if this dynamic object
756 should be included in the link. The native linker uses the loader
757 symbols, not the normal symbol table, so we do too. */
760 xcoff_link_check_dynamic_ar_symbols (abfd
, info
, pneeded
)
762 struct bfd_link_info
*info
;
767 struct internal_ldhdr ldhdr
;
769 bfd_byte
*elsym
, *elsymend
;
773 lsec
= bfd_get_section_by_name (abfd
, ".loader");
776 /* There are no symbols, so don't try to include it. */
780 if (! xcoff_get_section_contents (abfd
, lsec
))
782 contents
= coff_section_data (abfd
, lsec
)->contents
;
784 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
786 strings
= (char *) contents
+ ldhdr
.l_stoff
;
788 elsym
= contents
+ bfd_xcoff_loader_symbol_offset(abfd
, &ldhdr
);
790 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz(abfd
);
791 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz(abfd
))
793 struct internal_ldsym ldsym
;
794 char nambuf
[SYMNMLEN
+ 1];
796 struct bfd_link_hash_entry
*h
;
798 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
800 /* We are only interested in exported symbols. */
801 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
804 if (ldsym
._l
._l_l
._l_zeroes
== 0)
805 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
808 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
809 nambuf
[SYMNMLEN
] = '\0';
813 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
815 /* We are only interested in symbols that are currently
816 undefined. At this point we know that we are using an XCOFF
819 && h
->type
== bfd_link_hash_undefined
820 && (((struct xcoff_link_hash_entry
*) h
)->flags
821 & XCOFF_DEF_DYNAMIC
) == 0)
823 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
830 /* We do not need this shared object. */
832 if (contents
!= NULL
&& ! coff_section_data (abfd
, lsec
)->keep_contents
)
834 free (coff_section_data (abfd
, lsec
)->contents
);
835 coff_section_data (abfd
, lsec
)->contents
= NULL
;
841 /* Returns the index of reloc in RELOCS with the least address greater
842 than or equal to ADDRESS. The relocs are sorted by address. */
845 xcoff_find_reloc (relocs
, count
, address
)
846 struct internal_reloc
*relocs
;
850 bfd_size_type min
, max
, this;
854 if (count
== 1 && relocs
[0].r_vaddr
< address
)
863 /* Do a binary search over (min,max]. */
864 while (min
+ 1 < max
)
868 this = (max
+ min
) / 2;
869 raddr
= relocs
[this].r_vaddr
;
872 else if (raddr
< address
)
881 if (relocs
[min
].r_vaddr
< address
)
885 && relocs
[min
- 1].r_vaddr
== address
)
892 /* xcoff_link_create_extra_sections
894 Takes care of creating the .loader, .gl, .ds, .debug and sections. */
897 xcoff_link_create_extra_sections(bfd
* abfd
, struct bfd_link_info
*info
)
900 boolean return_value
= false;
902 if (info
->hash
->creator
== abfd
->xvec
)
905 /* We need to build a .loader section, so we do it here. This
906 won't work if we're producing an XCOFF output file with no
907 XCOFF input files. FIXME. */
909 if (xcoff_hash_table (info
)->loader_section
== NULL
)
913 lsec
= bfd_make_section_anyway (abfd
, ".loader");
918 xcoff_hash_table (info
)->loader_section
= lsec
;
919 lsec
->flags
|= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
922 /* Likewise for the linkage section. */
923 if (xcoff_hash_table (info
)->linkage_section
== NULL
)
927 lsec
= bfd_make_section_anyway (abfd
, ".gl");
933 xcoff_hash_table (info
)->linkage_section
= lsec
;
934 lsec
->flags
|= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
936 lsec
->alignment_power
= 2;
939 /* Likewise for the TOC section. */
940 if (xcoff_hash_table (info
)->toc_section
== NULL
)
944 tsec
= bfd_make_section_anyway (abfd
, ".tc");
950 xcoff_hash_table (info
)->toc_section
= tsec
;
951 tsec
->flags
|= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
953 tsec
->alignment_power
= 2;
956 /* Likewise for the descriptor section. */
957 if (xcoff_hash_table (info
)->descriptor_section
== NULL
)
961 dsec
= bfd_make_section_anyway (abfd
, ".ds");
967 xcoff_hash_table (info
)->descriptor_section
= dsec
;
968 dsec
->flags
|= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
970 dsec
->alignment_power
= 2;
973 /* Likewise for the .debug section. */
974 if (xcoff_hash_table (info
)->debug_section
== NULL
975 && info
->strip
!= strip_all
)
979 dsec
= bfd_make_section_anyway (abfd
, ".debug");
984 xcoff_hash_table (info
)->debug_section
= dsec
;
985 dsec
->flags
|= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
996 /* Add all the symbols from an object file to the hash table.
998 XCOFF is a weird format. A normal XCOFF .o files will have three
999 COFF sections--.text, .data, and .bss--but each COFF section will
1000 contain many csects. These csects are described in the symbol
1001 table. From the linker's point of view, each csect must be
1002 considered a section in its own right. For example, a TOC entry is
1003 handled as a small XMC_TC csect. The linker must be able to merge
1004 different TOC entries together, which means that it must be able to
1005 extract the XMC_TC csects from the .data section of the input .o
1008 From the point of view of our linker, this is, of course, a hideous
1009 nightmare. We cope by actually creating sections for each csect,
1010 and discarding the original sections. We then have to handle the
1011 relocation entries carefully, since the only way to tell which
1012 csect they belong to is to examine the address. */
1015 xcoff_link_add_symbols (abfd
, info
)
1017 struct bfd_link_info
*info
;
1019 unsigned int n_tmask
;
1020 unsigned int n_btshft
;
1021 boolean default_copy
;
1022 bfd_size_type symcount
;
1023 struct xcoff_link_hash_entry
**sym_hash
;
1024 asection
**csect_cache
;
1025 bfd_size_type linesz
;
1027 asection
*last_real
;
1030 unsigned int csect_index
;
1031 asection
*first_csect
;
1032 bfd_size_type symesz
;
1035 struct reloc_info_struct
1037 struct internal_reloc
*relocs
;
1040 } *reloc_info
= NULL
;
1043 keep_syms
= obj_coff_keep_syms (abfd
);
1045 if ((abfd
->flags
& DYNAMIC
) != 0
1046 && ! info
->static_link
)
1048 if (! xcoff_link_add_dynamic_symbols (abfd
, info
))
1052 /* create the loader, toc, gl, ds and debug sections, if needed */
1053 if (false == xcoff_link_create_extra_sections(abfd
, info
))
1056 if ((abfd
->flags
& DYNAMIC
) != 0
1057 && ! info
->static_link
)
1060 n_tmask
= coff_data (abfd
)->local_n_tmask
;
1061 n_btshft
= coff_data (abfd
)->local_n_btshft
;
1063 /* Define macros so that ISFCN, et. al., macros work correctly. */
1064 #define N_TMASK n_tmask
1065 #define N_BTSHFT n_btshft
1067 if (info
->keep_memory
)
1068 default_copy
= false;
1070 default_copy
= true;
1072 symcount
= obj_raw_syment_count (abfd
);
1074 /* We keep a list of the linker hash table entries that correspond
1075 to each external symbol. */
1076 amt
= symcount
* sizeof (struct xcoff_link_hash_entry
*);
1077 sym_hash
= (struct xcoff_link_hash_entry
**) bfd_alloc (abfd
, amt
);
1078 if (sym_hash
== NULL
&& symcount
!= 0)
1080 coff_data (abfd
)->sym_hashes
= (struct coff_link_hash_entry
**) sym_hash
;
1081 memset (sym_hash
, 0, (size_t) amt
);
1083 /* Because of the weird stuff we are doing with XCOFF csects, we can
1084 not easily determine which section a symbol is in, so we store
1085 the information in the tdata for the input file. */
1086 amt
= symcount
* sizeof (asection
*);
1087 csect_cache
= (asection
**) bfd_alloc (abfd
, amt
);
1088 if (csect_cache
== NULL
&& symcount
!= 0)
1090 xcoff_data (abfd
)->csects
= csect_cache
;
1091 memset (csect_cache
, 0, (size_t) amt
);
1093 /* While splitting sections into csects, we need to assign the
1094 relocs correctly. The relocs and the csects must both be in
1095 order by VMA within a given section, so we handle this by
1096 scanning along the relocs as we process the csects. We index
1097 into reloc_info using the section target_index. */
1098 amt
= abfd
->section_count
+ 1;
1099 amt
*= sizeof (struct reloc_info_struct
);
1100 reloc_info
= (struct reloc_info_struct
*) bfd_malloc (amt
);
1101 if (reloc_info
== NULL
)
1103 memset ((PTR
) reloc_info
, 0, (size_t) amt
);
1105 /* Read in the relocs and line numbers for each section. */
1106 linesz
= bfd_coff_linesz (abfd
);
1108 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1112 if ((o
->flags
& SEC_RELOC
) != 0)
1115 reloc_info
[o
->target_index
].relocs
=
1116 xcoff_read_internal_relocs (abfd
, o
, true, (bfd_byte
*) NULL
,
1117 false, (struct internal_reloc
*) NULL
);
1118 amt
= o
->reloc_count
;
1119 amt
*= sizeof (asection
*);
1120 reloc_info
[o
->target_index
].csects
= (asection
**) bfd_malloc (amt
);
1121 if (reloc_info
[o
->target_index
].csects
== NULL
)
1123 memset (reloc_info
[o
->target_index
].csects
, 0, (size_t) amt
);
1127 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1128 && o
->lineno_count
> 0)
1133 amt
= linesz
* o
->lineno_count
;
1134 linenos
= (bfd_byte
*) bfd_malloc (amt
);
1135 if (linenos
== NULL
)
1137 reloc_info
[o
->target_index
].linenos
= linenos
;
1138 if (bfd_seek (abfd
, o
->line_filepos
, SEEK_SET
) != 0
1139 || bfd_bread (linenos
, amt
, abfd
) != amt
)
1145 /* Don't let the linker relocation routines discard the symbols. */
1146 obj_coff_keep_syms (abfd
) = true;
1152 symesz
= bfd_coff_symesz (abfd
);
1153 BFD_ASSERT (symesz
== bfd_coff_auxesz (abfd
));
1154 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
1155 esym_end
= esym
+ symcount
* symesz
;
1157 while (esym
< esym_end
)
1159 struct internal_syment sym
;
1160 union internal_auxent aux
;
1162 char buf
[SYMNMLEN
+ 1];
1167 struct xcoff_link_hash_entry
*set_toc
;
1169 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &sym
);
1171 /* In this pass we are only interested in symbols with csect
1173 if (sym
.n_sclass
!= C_EXT
&& sym
.n_sclass
!= C_HIDEXT
)
1177 Normally csect is a .pr, .rw etc. created in the loop
1178 If C_FILE or first time, handle special
1180 Advance esym, sym_hash, csect_hash ptr's
1181 Keep track of the last_symndx for the current file. */
1182 if (sym
.n_sclass
== C_FILE
&& csect
!= NULL
)
1184 xcoff_section_data (abfd
, csect
)->last_symndx
=
1186 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1192 *csect_cache
= csect
;
1193 else if (first_csect
== NULL
|| sym
.n_sclass
== C_FILE
)
1194 *csect_cache
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1196 *csect_cache
= NULL
;
1197 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1198 sym_hash
+= sym
.n_numaux
+ 1;
1199 csect_cache
+= sym
.n_numaux
+ 1;
1204 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
1209 /* If this symbol has line number information attached to it,
1210 and we're not stripping it, count the number of entries and
1211 add them to the count for this csect. In the final link pass
1212 we are going to attach line number information by symbol,
1213 rather than by section, in order to more easily handle
1214 garbage collection. */
1215 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1218 && ISFCN (sym
.n_type
))
1221 union internal_auxent auxlin
;
1223 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ symesz
),
1224 sym
.n_type
, sym
.n_sclass
,
1225 0, sym
.n_numaux
, (PTR
) &auxlin
);
1227 if (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
1229 asection
*enclosing
;
1230 bfd_signed_vma linoff
;
1232 enclosing
= xcoff_section_data (abfd
, csect
)->enclosing
;
1233 if (enclosing
== NULL
)
1235 (*_bfd_error_handler
)
1236 (_("%s: `%s' has line numbers but no enclosing section"),
1237 bfd_archive_filename (abfd
), name
);
1238 bfd_set_error (bfd_error_bad_value
);
1241 linoff
= (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
1242 - enclosing
->line_filepos
);
1243 /* explict cast to bfd_signed_vma for compiler */
1244 if (linoff
< (bfd_signed_vma
) (enclosing
->lineno_count
* linesz
))
1246 struct internal_lineno lin
;
1247 bfd_byte
*linpstart
;
1249 linpstart
= (reloc_info
[enclosing
->target_index
].linenos
1251 bfd_coff_swap_lineno_in (abfd
, (PTR
) linpstart
, (PTR
) &lin
);
1253 && ((bfd_size_type
) lin
.l_addr
.l_symndx
1255 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1258 bfd_byte
*linpend
, *linp
;
1260 linpend
= (reloc_info
[enclosing
->target_index
].linenos
1261 + enclosing
->lineno_count
* linesz
);
1262 for (linp
= linpstart
+ linesz
;
1266 bfd_coff_swap_lineno_in (abfd
, (PTR
) linp
,
1268 if (lin
.l_lnno
== 0)
1271 csect
->lineno_count
+= (linp
- linpstart
) / linesz
;
1272 /* The setting of line_filepos will only be
1273 useful if all the line number entries for a
1274 csect are contiguous; this only matters for
1276 if (csect
->line_filepos
== 0)
1277 csect
->line_filepos
=
1278 auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1284 /* Pick up the csect auxiliary information. */
1286 if (sym
.n_numaux
== 0)
1288 (*_bfd_error_handler
)
1289 (_("%s: class %d symbol `%s' has no aux entries"),
1290 bfd_archive_filename (abfd
), sym
.n_sclass
, name
);
1291 bfd_set_error (bfd_error_bad_value
);
1295 bfd_coff_swap_aux_in (abfd
,
1296 (PTR
) (esym
+ symesz
* sym
.n_numaux
),
1297 sym
.n_type
, sym
.n_sclass
,
1298 sym
.n_numaux
- 1, sym
.n_numaux
,
1301 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
1311 (*_bfd_error_handler
)
1312 (_("%s: symbol `%s' has unrecognized csect type %d"),
1313 bfd_archive_filename (abfd
), name
, smtyp
);
1314 bfd_set_error (bfd_error_bad_value
);
1318 /* This is an external reference. */
1319 if (sym
.n_sclass
== C_HIDEXT
1320 || sym
.n_scnum
!= N_UNDEF
1321 || aux
.x_csect
.x_scnlen
.l
!= 0)
1323 (*_bfd_error_handler
)
1324 (_("%s: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d"),
1325 bfd_archive_filename (abfd
), name
, sym
.n_sclass
, sym
.n_scnum
,
1326 aux
.x_csect
.x_scnlen
.l
);
1327 bfd_set_error (bfd_error_bad_value
);
1331 /* An XMC_XO external reference is actually a reference to
1332 an absolute location. */
1333 if (aux
.x_csect
.x_smclas
!= XMC_XO
)
1334 section
= bfd_und_section_ptr
;
1337 section
= bfd_abs_section_ptr
;
1338 value
= sym
.n_value
;
1343 /* This is a csect definition. */
1346 xcoff_section_data (abfd
, csect
)->last_symndx
=
1347 ((esym
- (bfd_byte
*) obj_coff_external_syms (abfd
)) / symesz
);
1351 csect_index
= -(unsigned) 1;
1353 /* When we see a TOC anchor, we record the TOC value. */
1354 if (aux
.x_csect
.x_smclas
== XMC_TC0
)
1356 if (sym
.n_sclass
!= C_HIDEXT
1357 || aux
.x_csect
.x_scnlen
.l
!= 0)
1359 (*_bfd_error_handler
)
1360 (_("%s: XMC_TC0 symbol `%s' is class %d scnlen %d"),
1361 bfd_archive_filename (abfd
), name
, sym
.n_sclass
,
1362 aux
.x_csect
.x_scnlen
.l
);
1363 bfd_set_error (bfd_error_bad_value
);
1366 xcoff_data (abfd
)->toc
= sym
.n_value
;
1369 /* We must merge TOC entries for the same symbol. We can
1370 merge two TOC entries if they are both C_HIDEXT, they
1371 both have the same name, they are both 4 or 8 bytes long, and
1372 they both have a relocation table entry for an external
1373 symbol with the same name. Unfortunately, this means
1374 that we must look through the relocations. Ick.
1376 Logic for 32 bit vs 64 bit.
1377 32 bit has a csect length of 4 for TOC
1378 64 bit has a csect length of 8 for TOC
1380 The conditions to get past the if-check are not that bad.
1381 They are what is used to create the TOC csects in the first
1383 if (aux
.x_csect
.x_smclas
== XMC_TC
1384 && sym
.n_sclass
== C_HIDEXT
1385 && info
->hash
->creator
== abfd
->xvec
1386 && ((bfd_xcoff_is_xcoff32 (abfd
)
1387 && aux
.x_csect
.x_scnlen
.l
== 4)
1388 || (bfd_xcoff_is_xcoff64 (abfd
)
1389 && aux
.x_csect
.x_scnlen
.l
== 8)))
1391 asection
*enclosing
;
1392 struct internal_reloc
*relocs
;
1393 bfd_size_type relindx
;
1394 struct internal_reloc
*rel
;
1396 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1397 if (enclosing
== NULL
)
1400 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1401 amt
= enclosing
->reloc_count
;
1402 relindx
= xcoff_find_reloc (relocs
, amt
, sym
.n_value
);
1403 rel
= relocs
+ relindx
;
1405 /* 32 bit R_POS r_size is 31
1406 64 bit R_POS r_size is 63 */
1407 if (relindx
< enclosing
->reloc_count
1408 && rel
->r_vaddr
== (bfd_vma
) sym
.n_value
1409 && rel
->r_type
== R_POS
1410 && ((bfd_xcoff_is_xcoff32 (abfd
)
1411 && rel
->r_size
== 31)
1412 || (bfd_xcoff_is_xcoff64 (abfd
)
1413 && rel
->r_size
== 63)))
1417 struct internal_syment relsym
;
1419 erelsym
= ((bfd_byte
*) obj_coff_external_syms (abfd
)
1420 + rel
->r_symndx
* symesz
);
1421 bfd_coff_swap_sym_in (abfd
, (PTR
) erelsym
, (PTR
) &relsym
);
1422 if (relsym
.n_sclass
== C_EXT
)
1424 const char *relname
;
1425 char relbuf
[SYMNMLEN
+ 1];
1427 struct xcoff_link_hash_entry
*h
;
1429 /* At this point we know that the TOC entry is
1430 for an externally visible symbol. */
1432 relname
= _bfd_coff_internal_syment_name (abfd
, &relsym
,
1434 if (relname
== NULL
)
1437 /* We only merge TOC entries if the TC name is
1438 the same as the symbol name. This handles
1439 the normal case, but not common cases like
1440 SYM.P4 which gcc generates to store SYM + 4
1441 in the TOC. FIXME. */
1443 if (strcmp (name
, relname
) == 0)
1445 copy
= (! info
->keep_memory
1446 || relsym
._n
._n_n
._n_zeroes
!= 0
1447 || relsym
._n
._n_n
._n_offset
== 0);
1448 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1449 relname
, true, copy
,
1454 /* At this point h->root.type could be
1455 bfd_link_hash_new. That should be OK,
1456 since we know for sure that we will come
1457 across this symbol as we step through the
1460 /* We store h in *sym_hash for the
1461 convenience of the relocate_section
1465 if (h
->toc_section
!= NULL
)
1467 asection
**rel_csects
;
1469 /* We already have a TOC entry for this
1470 symbol, so we can just ignore this
1473 reloc_info
[enclosing
->target_index
].csects
;
1474 rel_csects
[relindx
] = bfd_und_section_ptr
;
1478 /* We are about to create a TOC entry for
1481 } /* merge toc reloc */
1488 asection
*enclosing
;
1490 /* We need to create a new section. We get the name from
1491 the csect storage mapping class, so that the linker can
1492 accumulate similar csects together. */
1494 csect
= bfd_xcoff_create_csect_from_smclas(abfd
, &aux
, name
);
1500 /* The enclosing section is the main section : .data, .text
1501 or .bss that the csect is coming from. */
1502 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1503 if (enclosing
== NULL
)
1506 if (! bfd_is_abs_section (enclosing
)
1507 && ((bfd_vma
) sym
.n_value
< enclosing
->vma
1508 || ((bfd_vma
) sym
.n_value
+ aux
.x_csect
.x_scnlen
.l
1509 > enclosing
->vma
+ enclosing
->_raw_size
)))
1511 (*_bfd_error_handler
)
1512 (_("%s: csect `%s' not in enclosing section"),
1513 bfd_archive_filename (abfd
), name
);
1514 bfd_set_error (bfd_error_bad_value
);
1517 csect
->vma
= sym
.n_value
;
1518 csect
->filepos
= (enclosing
->filepos
1521 csect
->_raw_size
= aux
.x_csect
.x_scnlen
.l
;
1522 csect
->flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
;
1523 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1525 /* Record the enclosing section in the tdata for this new
1527 amt
= sizeof (struct coff_section_tdata
);
1528 csect
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
1529 if (csect
->used_by_bfd
== NULL
)
1531 amt
= sizeof (struct xcoff_section_tdata
);
1532 coff_section_data (abfd
, csect
)->tdata
= bfd_zalloc (abfd
, amt
);
1533 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1535 xcoff_section_data (abfd
, csect
)->enclosing
= enclosing
;
1536 xcoff_section_data (abfd
, csect
)->lineno_count
=
1537 enclosing
->lineno_count
;
1539 if (enclosing
->owner
== abfd
)
1541 struct internal_reloc
*relocs
;
1542 bfd_size_type relindx
;
1543 struct internal_reloc
*rel
;
1544 asection
**rel_csect
;
1546 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1547 amt
= enclosing
->reloc_count
;
1548 relindx
= xcoff_find_reloc (relocs
, amt
, csect
->vma
);
1550 rel
= relocs
+ relindx
;
1551 rel_csect
= (reloc_info
[enclosing
->target_index
].csects
1554 csect
->rel_filepos
= (enclosing
->rel_filepos
1555 + relindx
* bfd_coff_relsz (abfd
));
1556 while (relindx
< enclosing
->reloc_count
1557 && *rel_csect
== NULL
1558 && rel
->r_vaddr
< csect
->vma
+ csect
->_raw_size
)
1562 csect
->flags
|= SEC_RELOC
;
1563 ++csect
->reloc_count
;
1570 /* There are a number of other fields and section flags
1571 which we do not bother to set. */
1573 csect_index
= ((esym
1574 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1577 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1579 if (first_csect
== NULL
)
1580 first_csect
= csect
;
1582 /* If this symbol is C_EXT, we treat it as starting at the
1583 beginning of the newly created section. */
1584 if (sym
.n_sclass
== C_EXT
)
1590 /* If this is a TOC section for a symbol, record it. */
1591 if (set_toc
!= NULL
)
1592 set_toc
->toc_section
= csect
;
1597 /* This is a label definition. The x_scnlen field is the
1598 symbol index of the csect. Usually the XTY_LD symbol will
1599 follow its appropriate XTY_SD symbol. The .set pseudo op can
1600 cause the XTY_LD to not follow the XTY_SD symbol. */
1605 if (aux
.x_csect
.x_scnlen
.l
< 0
1606 || (aux
.x_csect
.x_scnlen
.l
1607 >= esym
- (bfd_byte
*) obj_coff_external_syms (abfd
)))
1611 section
= xcoff_data (abfd
)->csects
[aux
.x_csect
.x_scnlen
.l
];
1613 || (section
->flags
& SEC_HAS_CONTENTS
) == 0)
1618 (*_bfd_error_handler
)
1619 (_("%s: misplaced XTY_LD `%s'"),
1620 bfd_archive_filename (abfd
), name
);
1621 bfd_set_error (bfd_error_bad_value
);
1625 value
= sym
.n_value
- csect
->vma
;
1630 /* This is an unitialized csect. We could base the name on
1631 the storage mapping class, but we don't bother except for
1632 an XMC_TD symbol. If this csect is externally visible,
1633 it is a common symbol. We put XMC_TD symbols in sections
1634 named .tocbss, and rely on the linker script to put that
1639 xcoff_section_data (abfd
, csect
)->last_symndx
=
1641 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1645 if (aux
.x_csect
.x_smclas
== XMC_TD
)
1647 /* The linker script puts the .td section in the data
1648 section after the .tc section. */
1649 csect
= bfd_make_section_anyway (abfd
, ".td");
1654 csect
= bfd_make_section_anyway (abfd
, ".bss");
1658 csect
->vma
= sym
.n_value
;
1659 csect
->_raw_size
= aux
.x_csect
.x_scnlen
.l
;
1660 csect
->flags
|= SEC_ALLOC
;
1661 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1662 /* There are a number of other fields and section flags
1663 which we do not bother to set. */
1665 csect_index
= ((esym
1666 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1669 amt
= sizeof (struct coff_section_tdata
);
1670 csect
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
1671 if (csect
->used_by_bfd
== NULL
)
1673 amt
= sizeof (struct xcoff_section_tdata
);
1674 coff_section_data (abfd
, csect
)->tdata
= bfd_zalloc (abfd
, amt
);
1675 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1677 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1679 if (first_csect
== NULL
)
1680 first_csect
= csect
;
1682 if (sym
.n_sclass
== C_EXT
)
1684 csect
->flags
|= SEC_IS_COMMON
;
1685 csect
->_raw_size
= 0;
1687 value
= aux
.x_csect
.x_scnlen
.l
;
1693 /* Check for magic symbol names. */
1694 if ((smtyp
== XTY_SD
|| smtyp
== XTY_CM
)
1695 && aux
.x_csect
.x_smclas
!= XMC_TC
1696 && aux
.x_csect
.x_smclas
!= XMC_TD
)
1703 if (strcmp (name
, "_text") == 0)
1704 i
= XCOFF_SPECIAL_SECTION_TEXT
;
1705 else if (strcmp (name
, "_etext") == 0)
1706 i
= XCOFF_SPECIAL_SECTION_ETEXT
;
1707 else if (strcmp (name
, "_data") == 0)
1708 i
= XCOFF_SPECIAL_SECTION_DATA
;
1709 else if (strcmp (name
, "_edata") == 0)
1710 i
= XCOFF_SPECIAL_SECTION_EDATA
;
1711 else if (strcmp (name
, "_end") == 0)
1712 i
= XCOFF_SPECIAL_SECTION_END
;
1714 else if (name
[0] == 'e' && strcmp (name
, "end") == 0)
1716 i
= XCOFF_SPECIAL_SECTION_END2
;
1721 xcoff_hash_table (info
)->special_sections
[i
] = csect
;
1725 /* Now we have enough information to add the symbol to the
1726 linker hash table. */
1728 if (sym
.n_sclass
== C_EXT
)
1732 BFD_ASSERT (section
!= NULL
);
1734 /* We must copy the name into memory if we got it from the
1735 syment itself, rather than the string table. */
1736 copy
= default_copy
;
1737 if (sym
._n
._n_n
._n_zeroes
!= 0
1738 || sym
._n
._n_n
._n_offset
== 0)
1741 /* The AIX linker appears to only detect multiple symbol
1742 definitions when there is a reference to the symbol. If
1743 a symbol is defined multiple times, and the only
1744 references are from the same object file, the AIX linker
1745 appears to permit it. It does not merge the different
1746 definitions, but handles them independently. On the
1747 other hand, if there is a reference, the linker reports
1750 This matters because the AIX <net/net_globals.h> header
1751 file actually defines an initialized array, so we have to
1752 actually permit that to work.
1754 Just to make matters even more confusing, the AIX linker
1755 appears to permit multiple symbol definitions whenever
1756 the second definition is in an archive rather than an
1757 object file. This may be a consequence of the manner in
1758 which it handles archives: I think it may load the entire
1759 archive in as separate csects, and then let garbage
1760 collection discard symbols.
1762 We also have to handle the case of statically linking a
1763 shared object, which will cause symbol redefinitions,
1764 although this is an easier case to detect. */
1766 if (info
->hash
->creator
== abfd
->xvec
)
1768 if (! bfd_is_und_section (section
))
1769 *sym_hash
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1770 name
, true, copy
, false);
1772 *sym_hash
= ((struct xcoff_link_hash_entry
*)
1773 bfd_wrapped_link_hash_lookup (abfd
, info
, name
,
1774 true, copy
, false));
1775 if (*sym_hash
== NULL
)
1777 if (((*sym_hash
)->root
.type
== bfd_link_hash_defined
1778 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
1779 && ! bfd_is_und_section (section
)
1780 && ! bfd_is_com_section (section
))
1782 /* This is a second definition of a defined symbol. */
1783 if ((abfd
->flags
& DYNAMIC
) != 0
1784 && ((*sym_hash
)->smclas
!= XMC_GL
1785 || aux
.x_csect
.x_smclas
== XMC_GL
1786 || ((*sym_hash
)->root
.u
.def
.section
->owner
->flags
1789 /* The new symbol is from a shared library, and
1790 either the existing symbol is not global
1791 linkage code or this symbol is global linkage
1792 code. If the existing symbol is global
1793 linkage code and the new symbol is not, then
1794 we want to use the new symbol. */
1795 section
= bfd_und_section_ptr
;
1798 else if (((*sym_hash
)->root
.u
.def
.section
->owner
->flags
1801 /* The existing symbol is from a shared library.
1803 (*sym_hash
)->root
.type
= bfd_link_hash_undefined
;
1804 (*sym_hash
)->root
.u
.undef
.abfd
=
1805 (*sym_hash
)->root
.u
.def
.section
->owner
;
1807 else if (abfd
->my_archive
!= NULL
)
1809 /* This is a redefinition in an object contained
1810 in an archive. Just ignore it. See the
1812 section
= bfd_und_section_ptr
;
1815 else if ((*sym_hash
)->root
.next
!= NULL
1816 || info
->hash
->undefs_tail
== &(*sym_hash
)->root
)
1818 /* This symbol has been referenced. In this
1819 case, we just continue and permit the
1820 multiple definition error. See the comment
1821 above about the behaviour of the AIX linker. */
1823 else if ((*sym_hash
)->smclas
== aux
.x_csect
.x_smclas
)
1825 /* The symbols are both csects of the same
1826 class. There is at least a chance that this
1827 is a semi-legitimate redefinition. */
1828 section
= bfd_und_section_ptr
;
1830 (*sym_hash
)->flags
|= XCOFF_MULTIPLY_DEFINED
;
1833 else if (((*sym_hash
)->flags
& XCOFF_MULTIPLY_DEFINED
) != 0
1834 && ((*sym_hash
)->root
.type
== bfd_link_hash_defined
1835 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
1836 && (bfd_is_und_section (section
)
1837 || bfd_is_com_section (section
)))
1839 /* This is a reference to a multiply defined symbol.
1840 Report the error now. See the comment above
1841 about the behaviour of the AIX linker. We could
1842 also do this with warning symbols, but I'm not
1843 sure the XCOFF linker is wholly prepared to
1844 handle them, and that would only be a warning,
1846 if (! ((*info
->callbacks
->multiple_definition
)
1847 (info
, (*sym_hash
)->root
.root
.string
,
1848 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0,
1849 (*sym_hash
)->root
.u
.def
.section
->owner
,
1850 (*sym_hash
)->root
.u
.def
.section
,
1851 (*sym_hash
)->root
.u
.def
.value
)))
1853 /* Try not to give this error too many times. */
1854 (*sym_hash
)->flags
&= ~XCOFF_MULTIPLY_DEFINED
;
1858 /* _bfd_generic_link_add_one_symbol may call the linker to
1859 generate an error message, and the linker may try to read
1860 the symbol table to give a good error. Right now, the
1861 line numbers are in an inconsistent state, since they are
1862 counted both in the real sections and in the new csects.
1863 We need to leave the count in the real sections so that
1864 the linker can report the line number of the error
1865 correctly, so temporarily clobber the link to the csects
1866 so that the linker will not try to read the line numbers
1867 a second time from the csects. */
1868 BFD_ASSERT (last_real
->next
== first_csect
);
1869 last_real
->next
= NULL
;
1870 if (! (_bfd_generic_link_add_one_symbol
1871 (info
, abfd
, name
, flags
, section
, value
,
1872 (const char *) NULL
, copy
, true,
1873 (struct bfd_link_hash_entry
**) sym_hash
)))
1875 last_real
->next
= first_csect
;
1877 if (smtyp
== XTY_CM
)
1879 if ((*sym_hash
)->root
.type
!= bfd_link_hash_common
1880 || (*sym_hash
)->root
.u
.c
.p
->section
!= csect
)
1882 /* We don't need the common csect we just created. */
1883 csect
->_raw_size
= 0;
1887 (*sym_hash
)->root
.u
.c
.p
->alignment_power
1888 = csect
->alignment_power
;
1892 if (info
->hash
->creator
== abfd
->xvec
)
1896 if (smtyp
== XTY_ER
|| smtyp
== XTY_CM
)
1897 flag
= XCOFF_REF_REGULAR
;
1899 flag
= XCOFF_DEF_REGULAR
;
1900 (*sym_hash
)->flags
|= flag
;
1902 if ((*sym_hash
)->smclas
== XMC_UA
1903 || flag
== XCOFF_DEF_REGULAR
)
1904 (*sym_hash
)->smclas
= aux
.x_csect
.x_smclas
;
1908 *csect_cache
= csect
;
1910 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1911 sym_hash
+= sym
.n_numaux
+ 1;
1912 csect_cache
+= sym
.n_numaux
+ 1;
1915 BFD_ASSERT (last_real
== NULL
|| last_real
->next
== first_csect
);
1917 /* Make sure that we have seen all the relocs. */
1918 for (o
= abfd
->sections
; o
!= first_csect
; o
= o
->next
)
1920 /* Reset the section size and the line number count, since the
1921 data is now attached to the csects. Don't reset the size of
1922 the .debug section, since we need to read it below in
1923 bfd_xcoff_size_dynamic_sections. */
1924 if (strcmp (bfd_get_section_name (abfd
, o
), ".debug") != 0)
1926 o
->lineno_count
= 0;
1928 if ((o
->flags
& SEC_RELOC
) != 0)
1931 struct internal_reloc
*rel
;
1932 asection
**rel_csect
;
1934 rel
= reloc_info
[o
->target_index
].relocs
;
1935 rel_csect
= reloc_info
[o
->target_index
].csects
;
1937 for (i
= 0; i
< o
->reloc_count
; i
++, rel
++, rel_csect
++)
1940 if (*rel_csect
== NULL
)
1942 (*_bfd_error_handler
)
1943 (_("%s: reloc %s:%d not in csect"),
1944 bfd_archive_filename (abfd
), o
->name
, i
);
1945 bfd_set_error (bfd_error_bad_value
);
1949 /* We identify all symbols which are called, so that we
1950 can create glue code for calls to functions imported
1951 from dynamic objects. */
1952 if (info
->hash
->creator
== abfd
->xvec
1953 && *rel_csect
!= bfd_und_section_ptr
1954 && (rel
->r_type
== R_BR
1955 || rel
->r_type
== R_RBR
)
1956 && obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
] != NULL
)
1958 struct xcoff_link_hash_entry
*h
;
1960 h
= obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
];
1961 h
->flags
|= XCOFF_CALLED
;
1962 /* If the symbol name starts with a period, it is
1963 the code of a function. If the symbol is
1964 currently undefined, then add an undefined symbol
1965 for the function descriptor. This should do no
1966 harm, because any regular object that defines the
1967 function should also define the function
1968 descriptor. It helps, because it means that we
1969 will identify the function descriptor with a
1970 dynamic object if a dynamic object defines it. */
1971 if (h
->root
.root
.string
[0] == '.'
1972 && h
->descriptor
== NULL
)
1974 struct xcoff_link_hash_entry
*hds
;
1976 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1977 h
->root
.root
.string
+ 1,
1981 if (hds
->root
.type
== bfd_link_hash_new
)
1983 if (! (_bfd_generic_link_add_one_symbol
1984 (info
, abfd
, hds
->root
.root
.string
,
1985 (flagword
) 0, bfd_und_section_ptr
,
1986 (bfd_vma
) 0, (const char *) NULL
, false,
1988 (struct bfd_link_hash_entry
**) &hds
)))
1991 hds
->flags
|= XCOFF_DESCRIPTOR
;
1992 BFD_ASSERT ((hds
->flags
& XCOFF_CALLED
) == 0
1993 && (h
->flags
& XCOFF_DESCRIPTOR
) == 0);
1994 hds
->descriptor
= h
;
1995 h
->descriptor
= hds
;
2000 free (reloc_info
[o
->target_index
].csects
);
2001 reloc_info
[o
->target_index
].csects
= NULL
;
2003 /* Reset SEC_RELOC and the reloc_count, since the reloc
2004 information is now attached to the csects. */
2005 o
->flags
&=~ SEC_RELOC
;
2008 /* If we are not keeping memory, free the reloc information. */
2009 if (! info
->keep_memory
2010 && coff_section_data (abfd
, o
) != NULL
2011 && coff_section_data (abfd
, o
)->relocs
!= NULL
2012 && ! coff_section_data (abfd
, o
)->keep_relocs
)
2014 free (coff_section_data (abfd
, o
)->relocs
);
2015 coff_section_data (abfd
, o
)->relocs
= NULL
;
2019 /* Free up the line numbers. FIXME: We could cache these
2020 somewhere for the final link, to avoid reading them again. */
2021 if (reloc_info
[o
->target_index
].linenos
!= NULL
)
2023 free (reloc_info
[o
->target_index
].linenos
);
2024 reloc_info
[o
->target_index
].linenos
= NULL
;
2030 obj_coff_keep_syms (abfd
) = keep_syms
;
2035 if (reloc_info
!= NULL
)
2037 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2039 if (reloc_info
[o
->target_index
].csects
!= NULL
)
2040 free (reloc_info
[o
->target_index
].csects
);
2041 if (reloc_info
[o
->target_index
].linenos
!= NULL
)
2042 free (reloc_info
[o
->target_index
].linenos
);
2046 obj_coff_keep_syms (abfd
) = keep_syms
;
2053 /* This function is used to add symbols from a dynamic object to the
2054 global symbol table. */
2057 xcoff_link_add_dynamic_symbols (abfd
, info
)
2059 struct bfd_link_info
*info
;
2063 struct internal_ldhdr ldhdr
;
2064 const char *strings
;
2065 bfd_byte
*elsym
, *elsymend
;
2066 struct xcoff_import_file
*n
;
2071 struct xcoff_import_file
**pp
;
2073 /* We can only handle a dynamic object if we are generating an XCOFF
2075 if (info
->hash
->creator
!= abfd
->xvec
)
2077 (*_bfd_error_handler
)
2078 (_("%s: XCOFF shared object when not producing XCOFF output"),
2079 bfd_get_filename (abfd
));
2080 bfd_set_error (bfd_error_invalid_operation
);
2084 /* The symbols we use from a dynamic object are not the symbols in
2085 the normal symbol table, but, rather, the symbols in the export
2086 table. If there is a global symbol in a dynamic object which is
2087 not in the export table, the loader will not be able to find it,
2088 so we don't want to find it either. Also, on AIX 4.1.3, shr.o in
2089 libc.a has symbols in the export table which are not in the
2092 /* Read in the .loader section. FIXME: We should really use the
2093 o_snloader field in the a.out header, rather than grabbing the
2095 lsec
= bfd_get_section_by_name (abfd
, ".loader");
2098 (*_bfd_error_handler
)
2099 (_("%s: dynamic object with no .loader section"),
2100 bfd_get_filename (abfd
));
2101 bfd_set_error (bfd_error_no_symbols
);
2106 if (! xcoff_get_section_contents (abfd
, lsec
))
2108 contents
= coff_section_data (abfd
, lsec
)->contents
;
2110 /* Remove the sections from this object, so that they do not get
2111 included in the link. */
2112 abfd
->sections
= NULL
;
2114 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
2116 strings
= (char *) contents
+ ldhdr
.l_stoff
;
2118 elsym
= contents
+ bfd_xcoff_loader_symbol_offset(abfd
, &ldhdr
);
2120 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz(abfd
);
2122 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz(abfd
))
2124 struct internal_ldsym ldsym
;
2125 char nambuf
[SYMNMLEN
+ 1];
2127 struct xcoff_link_hash_entry
*h
;
2129 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
2131 /* We are only interested in exported symbols. */
2132 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
2135 if (ldsym
._l
._l_l
._l_zeroes
== 0)
2136 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
2139 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
2140 nambuf
[SYMNMLEN
] = '\0';
2144 /* Normally we could not call xcoff_link_hash_lookup in an add
2145 symbols routine, since we might not be using an XCOFF hash
2146 table. However, we verified above that we are using an XCOFF
2149 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, true,
2154 h
->flags
|= XCOFF_DEF_DYNAMIC
;
2156 /* If the symbol is undefined, and the BFD it was found in is
2157 not a dynamic object, change the BFD to this dynamic object,
2158 so that we can get the correct import file ID. */
2159 if ((h
->root
.type
== bfd_link_hash_undefined
2160 || h
->root
.type
== bfd_link_hash_undefweak
)
2161 && (h
->root
.u
.undef
.abfd
== NULL
2162 || (h
->root
.u
.undef
.abfd
->flags
& DYNAMIC
) == 0))
2163 h
->root
.u
.undef
.abfd
= abfd
;
2165 if (h
->root
.type
== bfd_link_hash_new
)
2167 h
->root
.type
= bfd_link_hash_undefined
;
2168 h
->root
.u
.undef
.abfd
= abfd
;
2169 /* We do not want to add this to the undefined symbol list. */
2172 if (h
->smclas
== XMC_UA
2173 || h
->root
.type
== bfd_link_hash_undefined
2174 || h
->root
.type
== bfd_link_hash_undefweak
)
2175 h
->smclas
= ldsym
.l_smclas
;
2177 /* Unless this is an XMC_XO symbol, we don't bother to actually
2178 define it, since we don't have a section to put it in anyhow.
2179 Instead, the relocation routines handle the DEF_DYNAMIC flag
2182 if (h
->smclas
== XMC_XO
2183 && (h
->root
.type
== bfd_link_hash_undefined
2184 || h
->root
.type
== bfd_link_hash_undefweak
))
2186 /* This symbol has an absolute value. */
2187 h
->root
.type
= bfd_link_hash_defined
;
2188 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2189 h
->root
.u
.def
.value
= ldsym
.l_value
;
2192 /* If this symbol defines a function descriptor, then it
2193 implicitly defines the function code as well. */
2194 if (h
->smclas
== XMC_DS
2195 || (h
->smclas
== XMC_XO
&& name
[0] != '.'))
2196 h
->flags
|= XCOFF_DESCRIPTOR
;
2197 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
2199 struct xcoff_link_hash_entry
*hds
;
2201 hds
= h
->descriptor
;
2206 dsnm
= bfd_malloc ((bfd_size_type
) strlen (name
) + 2);
2210 strcpy (dsnm
+ 1, name
);
2211 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
), dsnm
,
2217 if (hds
->root
.type
== bfd_link_hash_new
)
2219 hds
->root
.type
= bfd_link_hash_undefined
;
2220 hds
->root
.u
.undef
.abfd
= abfd
;
2221 /* We do not want to add this to the undefined
2225 hds
->descriptor
= h
;
2226 h
->descriptor
= hds
;
2229 hds
->flags
|= XCOFF_DEF_DYNAMIC
;
2230 if (hds
->smclas
== XMC_UA
)
2231 hds
->smclas
= XMC_PR
;
2233 /* An absolute symbol appears to actually define code, not a
2234 function descriptor. This is how some math functions are
2235 implemented on AIX 4.1. */
2236 if (h
->smclas
== XMC_XO
2237 && (hds
->root
.type
== bfd_link_hash_undefined
2238 || hds
->root
.type
== bfd_link_hash_undefweak
))
2240 hds
->smclas
= XMC_XO
;
2241 hds
->root
.type
= bfd_link_hash_defined
;
2242 hds
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2243 hds
->root
.u
.def
.value
= ldsym
.l_value
;
2248 if (contents
!= NULL
&& ! coff_section_data (abfd
, lsec
)->keep_contents
)
2250 free (coff_section_data (abfd
, lsec
)->contents
);
2251 coff_section_data (abfd
, lsec
)->contents
= NULL
;
2254 /* Record this file in the import files. */
2256 n
= ((struct xcoff_import_file
*)
2257 bfd_alloc (abfd
, (bfd_size_type
) sizeof (struct xcoff_import_file
)));
2262 /* For some reason, the path entry in the import file list for a
2263 shared object appears to always be empty. The file name is the
2266 if (abfd
->my_archive
== NULL
)
2268 bname
= bfd_get_filename (abfd
);
2273 bname
= bfd_get_filename (abfd
->my_archive
);
2274 mname
= bfd_get_filename (abfd
);
2276 s
= strrchr (bname
, '/');
2282 /* We start c at 1 because the first import file number is reserved
2284 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
2286 pp
= &(*pp
)->next
, ++c
)
2290 xcoff_data (abfd
)->import_file_id
= c
;
2295 /* Routines that are called after all the input files have been
2296 handled, but before the sections are laid out in memory. */
2298 /* Mark a symbol as not being garbage, including the section in which
2301 static INLINE boolean
2302 xcoff_mark_symbol (info
, h
)
2303 struct bfd_link_info
*info
;
2304 struct xcoff_link_hash_entry
*h
;
2307 if ((h
->flags
& XCOFF_MARK
) != 0)
2310 h
->flags
|= XCOFF_MARK
;
2311 if (h
->root
.type
== bfd_link_hash_defined
2312 || h
->root
.type
== bfd_link_hash_defweak
)
2316 hsec
= h
->root
.u
.def
.section
;
2317 if (! bfd_is_abs_section (hsec
)
2318 && (hsec
->flags
& SEC_MARK
) == 0)
2320 if (! xcoff_mark (info
, hsec
))
2325 if (h
->toc_section
!= NULL
2326 && (h
->toc_section
->flags
& SEC_MARK
) == 0)
2328 if (! xcoff_mark (info
, h
->toc_section
))
2335 /* The mark phase of garbage collection. For a given section, mark
2336 it, and all the sections which define symbols to which it refers.
2337 Because this function needs to look at the relocs, we also count
2338 the number of relocs which need to be copied into the .loader
2342 xcoff_mark (info
, sec
)
2343 struct bfd_link_info
*info
;
2346 if (bfd_is_abs_section (sec
)
2347 || (sec
->flags
& SEC_MARK
) != 0)
2350 sec
->flags
|= SEC_MARK
;
2352 if (sec
->owner
->xvec
== info
->hash
->creator
2353 && coff_section_data (sec
->owner
, sec
) != NULL
2354 && xcoff_section_data (sec
->owner
, sec
) != NULL
)
2356 register struct xcoff_link_hash_entry
**hp
, **hpend
;
2357 struct internal_reloc
*rel
, *relend
;
2359 /* Mark all the symbols in this section. */
2361 hp
= (obj_xcoff_sym_hashes (sec
->owner
)
2362 + xcoff_section_data (sec
->owner
, sec
)->first_symndx
);
2363 hpend
= (obj_xcoff_sym_hashes (sec
->owner
)
2364 + xcoff_section_data (sec
->owner
, sec
)->last_symndx
);
2365 for (; hp
< hpend
; hp
++)
2367 register struct xcoff_link_hash_entry
*h
;
2371 && (h
->flags
& XCOFF_MARK
) == 0)
2373 if (! xcoff_mark_symbol (info
, h
))
2378 /* Look through the section relocs. */
2380 if ((sec
->flags
& SEC_RELOC
) != 0
2381 && sec
->reloc_count
> 0)
2383 rel
= xcoff_read_internal_relocs (sec
->owner
, sec
, true,
2384 (bfd_byte
*) NULL
, false,
2385 (struct internal_reloc
*) NULL
);
2388 relend
= rel
+ sec
->reloc_count
;
2389 for (; rel
< relend
; rel
++)
2392 struct xcoff_link_hash_entry
*h
;
2394 if ((unsigned int) rel
->r_symndx
2395 > obj_raw_syment_count (sec
->owner
))
2398 h
= obj_xcoff_sym_hashes (sec
->owner
)[rel
->r_symndx
];
2400 && (h
->flags
& XCOFF_MARK
) == 0)
2402 if (! xcoff_mark_symbol (info
, h
))
2406 rsec
= xcoff_data (sec
->owner
)->csects
[rel
->r_symndx
];
2408 && (rsec
->flags
& SEC_MARK
) == 0)
2410 if (! xcoff_mark (info
, rsec
))
2414 /* See if this reloc needs to be copied into the .loader
2416 switch (rel
->r_type
)
2420 || h
->root
.type
== bfd_link_hash_defined
2421 || h
->root
.type
== bfd_link_hash_defweak
2422 || h
->root
.type
== bfd_link_hash_common
2423 || ((h
->flags
& XCOFF_CALLED
) != 0
2424 && (h
->root
.type
== bfd_link_hash_undefined
2425 || h
->root
.type
== bfd_link_hash_undefweak
)
2426 && h
->root
.root
.string
[0] == '.'
2427 && h
->descriptor
!= NULL
2428 && ((h
->descriptor
->flags
& XCOFF_DEF_DYNAMIC
) != 0
2429 || ((h
->descriptor
->flags
& XCOFF_IMPORT
) != 0
2430 && (h
->descriptor
->flags
2431 & XCOFF_DEF_REGULAR
) == 0))))
2438 ++xcoff_hash_table (info
)->ldrel_count
;
2440 h
->flags
|= XCOFF_LDREL
;
2447 /* We should never need a .loader reloc for a TOC
2453 if (! info
->keep_memory
2454 && coff_section_data (sec
->owner
, sec
) != NULL
2455 && coff_section_data (sec
->owner
, sec
)->relocs
!= NULL
2456 && ! coff_section_data (sec
->owner
, sec
)->keep_relocs
)
2458 free (coff_section_data (sec
->owner
, sec
)->relocs
);
2459 coff_section_data (sec
->owner
, sec
)->relocs
= NULL
;
2467 /* The sweep phase of garbage collection. Remove all garbage
2472 struct bfd_link_info
*info
;
2476 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
2480 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
2482 if ((o
->flags
& SEC_MARK
) == 0)
2484 /* Keep all sections from non-XCOFF input files. Keep
2485 special sections. Keep .debug sections for the
2487 if (sub
->xvec
!= info
->hash
->creator
2488 || o
== xcoff_hash_table (info
)->debug_section
2489 || o
== xcoff_hash_table (info
)->loader_section
2490 || o
== xcoff_hash_table (info
)->linkage_section
2491 || o
== xcoff_hash_table (info
)->toc_section
2492 || o
== xcoff_hash_table (info
)->descriptor_section
2493 || strcmp (o
->name
, ".debug") == 0)
2494 o
->flags
|= SEC_MARK
;
2499 o
->lineno_count
= 0;
2506 /* Record the number of elements in a set. This is used to output the
2507 correct csect length. */
2510 bfd_xcoff_link_record_set (output_bfd
, info
, harg
, size
)
2512 struct bfd_link_info
*info
;
2513 struct bfd_link_hash_entry
*harg
;
2516 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2517 struct xcoff_link_size_list
*n
;
2520 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2523 /* This will hardly ever be called. I don't want to burn four bytes
2524 per global symbol, so instead the size is kept on a linked list
2525 attached to the hash table. */
2527 amt
= sizeof (struct xcoff_link_size_list
);
2528 n
= (struct xcoff_link_size_list
*) bfd_alloc (output_bfd
, amt
);
2531 n
->next
= xcoff_hash_table (info
)->size_list
;
2534 xcoff_hash_table (info
)->size_list
= n
;
2536 h
->flags
|= XCOFF_HAS_SIZE
;
2541 /* Import a symbol. */
2544 bfd_xcoff_import_symbol (output_bfd
, info
, harg
, val
, imppath
, impfile
,
2545 impmember
, syscall_flag
)
2547 struct bfd_link_info
*info
;
2548 struct bfd_link_hash_entry
*harg
;
2550 const char *imppath
;
2551 const char *impfile
;
2552 const char *impmember
;
2553 unsigned int syscall_flag
;
2555 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2557 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2560 /* A symbol name which starts with a period is the code for a
2561 function. If the symbol is undefined, then add an undefined
2562 symbol for the function descriptor, and import that instead. */
2563 if (h
->root
.root
.string
[0] == '.'
2564 && h
->root
.type
== bfd_link_hash_undefined
2565 && val
== (bfd_vma
) -1)
2567 struct xcoff_link_hash_entry
*hds
;
2569 hds
= h
->descriptor
;
2572 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2573 h
->root
.root
.string
+ 1,
2577 if (hds
->root
.type
== bfd_link_hash_new
)
2579 hds
->root
.type
= bfd_link_hash_undefined
;
2580 hds
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
2582 hds
->flags
|= XCOFF_DESCRIPTOR
;
2583 BFD_ASSERT ((hds
->flags
& XCOFF_CALLED
) == 0
2584 && (h
->flags
& XCOFF_DESCRIPTOR
) == 0);
2585 hds
->descriptor
= h
;
2586 h
->descriptor
= hds
;
2589 /* Now, if the descriptor is undefined, import the descriptor
2590 rather than the symbol we were told to import. FIXME: Is
2591 this correct in all cases? */
2592 if (hds
->root
.type
== bfd_link_hash_undefined
)
2596 h
->flags
|= (XCOFF_IMPORT
| syscall_flag
);
2598 if (val
!= (bfd_vma
) -1)
2600 if (h
->root
.type
== bfd_link_hash_defined
2601 && (! bfd_is_abs_section (h
->root
.u
.def
.section
)
2602 || h
->root
.u
.def
.value
!= val
))
2604 if (! ((*info
->callbacks
->multiple_definition
)
2605 (info
, h
->root
.root
.string
, h
->root
.u
.def
.section
->owner
,
2606 h
->root
.u
.def
.section
, h
->root
.u
.def
.value
,
2607 output_bfd
, bfd_abs_section_ptr
, val
)))
2611 h
->root
.type
= bfd_link_hash_defined
;
2612 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2613 h
->root
.u
.def
.value
= val
;
2616 /* We overload the ldindx field to hold the l_ifile value for this
2618 BFD_ASSERT (h
->ldsym
== NULL
);
2619 BFD_ASSERT ((h
->flags
& XCOFF_BUILT_LDSYM
) == 0);
2620 if (imppath
== NULL
)
2625 struct xcoff_import_file
**pp
;
2627 /* We start c at 1 because the first entry in the import list is
2628 reserved for the library search path. */
2629 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
2631 pp
= &(*pp
)->next
, ++c
)
2633 if (strcmp ((*pp
)->path
, imppath
) == 0
2634 && strcmp ((*pp
)->file
, impfile
) == 0
2635 && strcmp ((*pp
)->member
, impmember
) == 0)
2641 struct xcoff_import_file
*n
;
2642 bfd_size_type amt
= sizeof (struct xcoff_import_file
);
2644 n
= (struct xcoff_import_file
*) bfd_alloc (output_bfd
, amt
);
2650 n
->member
= impmember
;
2660 /* Export a symbol. */
2663 bfd_xcoff_export_symbol (output_bfd
, info
, harg
)
2665 struct bfd_link_info
*info
;
2666 struct bfd_link_hash_entry
*harg
;
2668 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2670 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2673 h
->flags
|= XCOFF_EXPORT
;
2675 /* FIXME: I'm not at all sure what syscall is supposed to mean, so
2676 I'm just going to ignore it until somebody explains it. */
2678 /* See if this is a function descriptor. It may be one even though
2679 it is not so marked. */
2680 if ((h
->flags
& XCOFF_DESCRIPTOR
) == 0
2681 && h
->root
.root
.string
[0] != '.')
2684 struct xcoff_link_hash_entry
*hfn
;
2685 bfd_size_type amt
= strlen (h
->root
.root
.string
) + 2;
2687 fnname
= (char *) bfd_malloc (amt
);
2691 strcpy (fnname
+ 1, h
->root
.root
.string
);
2692 hfn
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2693 fnname
, false, false, true);
2696 && hfn
->smclas
== XMC_PR
2697 && (hfn
->root
.type
== bfd_link_hash_defined
2698 || hfn
->root
.type
== bfd_link_hash_defweak
))
2700 h
->flags
|= XCOFF_DESCRIPTOR
;
2701 h
->descriptor
= hfn
;
2702 hfn
->descriptor
= h
;
2706 /* Make sure we don't garbage collect this symbol. */
2707 if (! xcoff_mark_symbol (info
, h
))
2710 /* If this is a function descriptor, make sure we don't garbage
2711 collect the associated function code. We normally don't have to
2712 worry about this, because the descriptor will be attached to a
2713 section with relocs, but if we are creating the descriptor
2714 ourselves those relocs will not be visible to the mark code. */
2715 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
2717 if (! xcoff_mark_symbol (info
, h
->descriptor
))
2724 /* Count a reloc against a symbol. This is called for relocs
2725 generated by the linker script, typically for global constructors
2729 bfd_xcoff_link_count_reloc (output_bfd
, info
, name
)
2731 struct bfd_link_info
*info
;
2734 struct xcoff_link_hash_entry
*h
;
2736 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2739 h
= ((struct xcoff_link_hash_entry
*)
2740 bfd_wrapped_link_hash_lookup (output_bfd
, info
, name
, false, false,
2744 (*_bfd_error_handler
) (_("%s: no such symbol"), name
);
2745 bfd_set_error (bfd_error_no_symbols
);
2749 h
->flags
|= XCOFF_REF_REGULAR
| XCOFF_LDREL
;
2750 ++xcoff_hash_table (info
)->ldrel_count
;
2752 /* Mark the symbol to avoid garbage collection. */
2753 if (! xcoff_mark_symbol (info
, h
))
2759 /* This function is called for each symbol to which the linker script
2763 bfd_xcoff_record_link_assignment (output_bfd
, info
, name
)
2765 struct bfd_link_info
*info
;
2768 struct xcoff_link_hash_entry
*h
;
2770 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2773 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, true, true,
2778 h
->flags
|= XCOFF_DEF_REGULAR
;
2783 /* Build the .loader section. This is called by the XCOFF linker
2784 emulation before_allocation routine. We must set the size of the
2785 .loader section before the linker lays out the output file.
2786 LIBPATH is the library path to search for shared objects; this is
2787 normally built from the -L arguments passed to the linker. ENTRY
2788 is the name of the entry point symbol (the -e linker option).
2789 FILE_ALIGN is the alignment to use for sections within the file
2790 (the -H linker option). MAXSTACK is the maximum stack size (the
2791 -bmaxstack linker option). MAXDATA is the maximum data size (the
2792 -bmaxdata linker option). GC is whether to do garbage collection
2793 (the -bgc linker option). MODTYPE is the module type (the
2794 -bmodtype linker option). TEXTRO is whether the text section must
2795 be read only (the -btextro linker option). EXPORT_DEFINEDS is
2796 whether all defined symbols should be exported (the -unix linker
2797 option). SPECIAL_SECTIONS is set by this routine to csects with
2798 magic names like _end. */
2801 bfd_xcoff_size_dynamic_sections (output_bfd
, info
, libpath
, entry
,
2802 file_align
, maxstack
, maxdata
, gc
,
2803 modtype
, textro
, export_defineds
,
2804 special_sections
, rtld
)
2806 struct bfd_link_info
*info
;
2807 const char *libpath
;
2809 unsigned long file_align
;
2810 unsigned long maxstack
;
2811 unsigned long maxdata
;
2815 boolean export_defineds
;
2816 asection
**special_sections
;
2819 struct xcoff_link_hash_entry
*hentry
;
2821 struct xcoff_loader_info ldinfo
;
2823 size_t impsize
, impcount
;
2824 struct xcoff_import_file
*fl
;
2825 struct internal_ldhdr
*ldhdr
;
2826 bfd_size_type stoff
;
2830 struct bfd_strtab_hash
*debug_strtab
;
2831 bfd_byte
*debug_contents
= NULL
;
2834 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2836 for (i
= 0; i
< XCOFF_NUMBER_OF_SPECIAL_SECTIONS
; i
++)
2837 special_sections
[i
] = NULL
;
2841 ldinfo
.failed
= false;
2842 ldinfo
.output_bfd
= output_bfd
;
2844 ldinfo
.export_defineds
= export_defineds
;
2845 ldinfo
.ldsym_count
= 0;
2846 ldinfo
.string_size
= 0;
2847 ldinfo
.strings
= NULL
;
2848 ldinfo
.string_alc
= 0;
2850 xcoff_data (output_bfd
)->maxstack
= maxstack
;
2851 xcoff_data (output_bfd
)->maxdata
= maxdata
;
2852 xcoff_data (output_bfd
)->modtype
= modtype
;
2854 xcoff_hash_table (info
)->file_align
= file_align
;
2855 xcoff_hash_table (info
)->textro
= textro
;
2860 hentry
= xcoff_link_hash_lookup (xcoff_hash_table (info
), entry
,
2861 false, false, true);
2863 hentry
->flags
|= XCOFF_ENTRY
;
2867 if (info
->init_function
|| info
->fini_function
|| rtld
== true)
2869 struct xcoff_link_hash_entry
*hsym
;
2870 struct internal_ldsym
*ldsym
;
2872 hsym
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2873 "__rtinit", false, false, true);
2876 (*_bfd_error_handler
)
2877 (_("error: undefined symbol __rtinit"));
2881 xcoff_mark_symbol (info
, hsym
);
2882 hsym
->flags
|= (XCOFF_DEF_REGULAR
| XCOFF_RTINIT
);
2884 /* __rtinit initalized */
2885 amt
= sizeof (struct internal_ldsym
);
2886 ldsym
= (struct internal_ldsym
*) bfd_malloc (amt
);
2888 ldsym
->l_value
= 0; /* will be filled in later */
2889 ldsym
->l_scnum
= 2; /* data section */
2890 ldsym
->l_smtype
= XTY_SD
; /* csect section definition */
2891 ldsym
->l_smclas
= 5; /* .rw */
2892 ldsym
->l_ifile
= 0; /* special system loader symbol */
2893 ldsym
->l_parm
= 0; /* NA */
2895 /* Force __rtinit to be the first symbol in the loader symbol table
2896 See xcoff_build_ldsyms
2898 The first 3 symbol table indices are reserved to indicate the data,
2899 text and bss sections. */
2900 BFD_ASSERT (0 == ldinfo
.ldsym_count
);
2903 ldinfo
.ldsym_count
= 1;
2904 hsym
->ldsym
= ldsym
;
2906 if (false == bfd_xcoff_put_ldsymbol_name (ldinfo
.output_bfd
, &ldinfo
,
2908 hsym
->root
.root
.string
))
2911 /* This symbol is written out by xcoff_write_global_symbol
2912 Set stuff up so xcoff_write_global_symbol logic works. */
2913 hsym
->flags
|= XCOFF_DEF_REGULAR
| XCOFF_MARK
;
2914 hsym
->root
.type
= bfd_link_hash_defined
;
2915 hsym
->root
.u
.def
.value
= 0;
2918 /* Garbage collect unused sections. */
2919 if (info
->relocateable
2922 || (hentry
->root
.type
!= bfd_link_hash_defined
2923 && hentry
->root
.type
!= bfd_link_hash_defweak
))
2926 xcoff_hash_table (info
)->gc
= false;
2928 /* We still need to call xcoff_mark, in order to set ldrel_count
2930 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
2934 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
2936 if ((o
->flags
& SEC_MARK
) == 0)
2938 if (! xcoff_mark (info
, o
))
2946 if (! xcoff_mark (info
, hentry
->root
.u
.def
.section
))
2949 xcoff_hash_table (info
)->gc
= true;
2952 /* Return special sections to the caller. */
2953 for (i
= 0; i
< XCOFF_NUMBER_OF_SPECIAL_SECTIONS
; i
++)
2955 sec
= xcoff_hash_table (info
)->special_sections
[i
];
2959 && (sec
->flags
& SEC_MARK
) == 0)
2963 special_sections
[i
] = sec
;
2966 if (info
->input_bfds
== NULL
)
2968 /* I'm not sure what to do in this bizarre case. */
2972 xcoff_link_hash_traverse (xcoff_hash_table (info
), xcoff_build_ldsyms
,
2977 /* Work out the size of the import file names. Each import file ID
2978 consists of three null terminated strings: the path, the file
2979 name, and the archive member name. The first entry in the list
2980 of names is the path to use to find objects, which the linker has
2981 passed in as the libpath argument. For some reason, the path
2982 entry in the other import file names appears to always be empty. */
2983 impsize
= strlen (libpath
) + 3;
2985 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
2988 impsize
+= (strlen (fl
->path
)
2990 + strlen (fl
->member
)
2994 /* Set up the .loader section header. */
2995 ldhdr
= &xcoff_hash_table (info
)->ldhdr
;
2996 ldhdr
->l_version
= bfd_xcoff_ldhdr_version(output_bfd
);
2997 ldhdr
->l_nsyms
= ldinfo
.ldsym_count
;
2998 ldhdr
->l_nreloc
= xcoff_hash_table (info
)->ldrel_count
;
2999 ldhdr
->l_istlen
= impsize
;
3000 ldhdr
->l_nimpid
= impcount
;
3001 ldhdr
->l_impoff
= (bfd_xcoff_ldhdrsz(output_bfd
)
3002 + ldhdr
->l_nsyms
* bfd_xcoff_ldsymsz(output_bfd
)
3003 + ldhdr
->l_nreloc
* bfd_xcoff_ldrelsz(output_bfd
));
3004 ldhdr
->l_stlen
= ldinfo
.string_size
;
3005 stoff
= ldhdr
->l_impoff
+ impsize
;
3006 if (ldinfo
.string_size
== 0)
3009 ldhdr
->l_stoff
= stoff
;
3011 /* 64 bit elements to ldhdr
3012 The swap out routine for 32 bit will ignore them.
3013 Nothing fancy, symbols come after the header and relocs come
3015 ldhdr
->l_symoff
= bfd_xcoff_ldhdrsz (output_bfd
);
3016 ldhdr
->l_rldoff
= (bfd_xcoff_ldhdrsz (output_bfd
)
3017 + ldhdr
->l_nsyms
* bfd_xcoff_ldsymsz (output_bfd
));
3019 /* We now know the final size of the .loader section. Allocate
3021 lsec
= xcoff_hash_table (info
)->loader_section
;
3022 lsec
->_raw_size
= stoff
+ ldhdr
->l_stlen
;
3023 lsec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, lsec
->_raw_size
);
3024 if (lsec
->contents
== NULL
)
3027 /* Set up the header. */
3028 bfd_xcoff_swap_ldhdr_out (output_bfd
, ldhdr
, lsec
->contents
);
3030 /* Set up the import file names. */
3031 out
= (char *) lsec
->contents
+ ldhdr
->l_impoff
;
3032 strcpy (out
, libpath
);
3033 out
+= strlen (libpath
) + 1;
3036 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
3038 register const char *s
;
3041 while ((*out
++ = *s
++) != '\0')
3044 while ((*out
++ = *s
++) != '\0')
3047 while ((*out
++ = *s
++) != '\0')
3051 BFD_ASSERT ((bfd_size_type
) ((bfd_byte
*) out
- lsec
->contents
) == stoff
);
3053 /* Set up the symbol string table. */
3054 if (ldinfo
.string_size
> 0)
3056 memcpy (out
, ldinfo
.strings
, ldinfo
.string_size
);
3057 free (ldinfo
.strings
);
3058 ldinfo
.strings
= NULL
;
3061 /* We can't set up the symbol table or the relocs yet, because we
3062 don't yet know the final position of the various sections. The
3063 .loader symbols are written out when the corresponding normal
3064 symbols are written out in xcoff_link_input_bfd or
3065 xcoff_write_global_symbol. The .loader relocs are written out
3066 when the corresponding normal relocs are handled in
3067 xcoff_link_input_bfd.
3070 /* Allocate space for the magic sections. */
3071 sec
= xcoff_hash_table (info
)->linkage_section
;
3072 if (sec
->_raw_size
> 0)
3074 sec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, sec
->_raw_size
);
3075 if (sec
->contents
== NULL
)
3078 sec
= xcoff_hash_table (info
)->toc_section
;
3079 if (sec
->_raw_size
> 0)
3081 sec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, sec
->_raw_size
);
3082 if (sec
->contents
== NULL
)
3085 sec
= xcoff_hash_table (info
)->descriptor_section
;
3086 if (sec
->_raw_size
> 0)
3088 sec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, sec
->_raw_size
);
3089 if (sec
->contents
== NULL
)
3093 /* Now that we've done garbage collection, figure out the contents
3094 of the .debug section. */
3095 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
3097 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3100 bfd_size_type symcount
;
3101 unsigned long *debug_index
;
3103 bfd_byte
*esym
, *esymend
;
3104 bfd_size_type symesz
;
3106 if (sub
->xvec
!= info
->hash
->creator
)
3108 subdeb
= bfd_get_section_by_name (sub
, ".debug");
3109 if (subdeb
== NULL
|| subdeb
->_raw_size
== 0)
3112 if (info
->strip
== strip_all
3113 || info
->strip
== strip_debugger
3114 || info
->discard
== discard_all
)
3116 subdeb
->_raw_size
= 0;
3120 if (! _bfd_coff_get_external_symbols (sub
))
3123 symcount
= obj_raw_syment_count (sub
);
3124 debug_index
= ((unsigned long *)
3125 bfd_zalloc (sub
, symcount
* sizeof (unsigned long)));
3126 if (debug_index
== NULL
)
3128 xcoff_data (sub
)->debug_indices
= debug_index
;
3130 /* Grab the contents of the .debug section. We use malloc and
3131 copy the names into the debug stringtab, rather than
3132 bfd_alloc, because I expect that, when linking many files
3133 together, many of the strings will be the same. Storing the
3134 strings in the hash table should save space in this case. */
3135 debug_contents
= (bfd_byte
*) bfd_malloc (subdeb
->_raw_size
);
3136 if (debug_contents
== NULL
)
3138 if (! bfd_get_section_contents (sub
, subdeb
, (PTR
) debug_contents
,
3139 (file_ptr
) 0, subdeb
->_raw_size
))
3142 csectpp
= xcoff_data (sub
)->csects
;
3144 symesz
= bfd_coff_symesz (sub
);
3145 esym
= (bfd_byte
*) obj_coff_external_syms (sub
);
3146 esymend
= esym
+ symcount
* symesz
;
3147 while (esym
< esymend
)
3149 struct internal_syment sym
;
3151 bfd_coff_swap_sym_in (sub
, (PTR
) esym
, (PTR
) &sym
);
3153 *debug_index
= (unsigned long) -1;
3155 if (sym
._n
._n_n
._n_zeroes
== 0
3158 || ((*csectpp
)->flags
& SEC_MARK
) != 0
3159 || *csectpp
== bfd_abs_section_ptr
)
3160 && bfd_coff_symname_in_debug (sub
, &sym
))
3165 name
= (char *) debug_contents
+ sym
._n
._n_n
._n_offset
;
3166 indx
= _bfd_stringtab_add (debug_strtab
, name
, true, true);
3167 if (indx
== (bfd_size_type
) -1)
3169 *debug_index
= indx
;
3172 esym
+= (sym
.n_numaux
+ 1) * symesz
;
3173 csectpp
+= sym
.n_numaux
+ 1;
3174 debug_index
+= sym
.n_numaux
+ 1;
3177 free (debug_contents
);
3178 debug_contents
= NULL
;
3180 /* Clear the size of subdeb, so that it is not included directly
3181 in the output file. */
3182 subdeb
->_raw_size
= 0;
3184 if (! info
->keep_memory
)
3186 if (! _bfd_coff_free_symbols (sub
))
3191 if (info
->strip
!= strip_all
)
3192 xcoff_hash_table (info
)->debug_section
->_raw_size
=
3193 _bfd_stringtab_size (debug_strtab
);
3198 if (ldinfo
.strings
!= NULL
)
3199 free (ldinfo
.strings
);
3200 if (debug_contents
!= NULL
)
3201 free (debug_contents
);
3206 bfd_xcoff_link_generate_rtinit (abfd
, init
, fini
, rtld
)
3212 struct bfd_in_memory
*bim
;
3214 bim
= ((struct bfd_in_memory
*)
3215 bfd_malloc ((bfd_size_type
) sizeof (struct bfd_in_memory
)));
3222 abfd
->link_next
= 0;
3223 abfd
->format
= bfd_object
;
3224 abfd
->iostream
= (PTR
) bim
;
3225 abfd
->flags
= BFD_IN_MEMORY
;
3226 abfd
->direction
= write_direction
;
3229 if (false == bfd_xcoff_generate_rtinit (abfd
, init
, fini
, rtld
))
3232 /* need to reset to unknown or it will not be read back in correctly */
3233 abfd
->format
= bfd_unknown
;
3234 abfd
->direction
= read_direction
;
3241 /* Add a symbol to the .loader symbols, if necessary. */
3244 xcoff_build_ldsyms (h
, p
)
3245 struct xcoff_link_hash_entry
*h
;
3248 struct xcoff_loader_info
*ldinfo
= (struct xcoff_loader_info
*) p
;
3251 /* __rtinit, this symbol has special handling. */
3252 if (h
->flags
& XCOFF_RTINIT
)
3255 /* If this is a final link, and the symbol was defined as a common
3256 symbol in a regular object file, and there was no definition in
3257 any dynamic object, then the linker will have allocated space for
3258 the symbol in a common section but the XCOFF_DEF_REGULAR flag
3259 will not have been set. */
3260 if (h
->root
.type
== bfd_link_hash_defined
3261 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
3262 && (h
->flags
& XCOFF_REF_REGULAR
) != 0
3263 && (h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
3264 && (bfd_is_abs_section (h
->root
.u
.def
.section
)
3265 || (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0))
3266 h
->flags
|= XCOFF_DEF_REGULAR
;
3268 /* If all defined symbols should be exported, mark them now. We
3269 don't want to export the actual functions, just the function
3271 if (ldinfo
->export_defineds
3272 && (h
->flags
& XCOFF_DEF_REGULAR
) != 0
3273 && h
->root
.root
.string
[0] != '.')
3277 /* We don't export a symbol which is being defined by an object
3278 included from an archive which contains a shared object. The
3279 rationale is that if an archive contains both an unshared and
3280 a shared object, then there must be some reason that the
3281 unshared object is unshared, and we don't want to start
3282 providing a shared version of it. In particular, this solves
3283 a bug involving the _savefNN set of functions. gcc will call
3284 those functions without providing a slot to restore the TOC,
3285 so it is essential that these functions be linked in directly
3286 and not from a shared object, which means that a shared
3287 object which also happens to link them in must not export
3288 them. This is confusing, but I haven't been able to think of
3289 a different approach. Note that the symbols can, of course,
3290 be exported explicitly. */
3292 if ((h
->root
.type
== bfd_link_hash_defined
3293 || h
->root
.type
== bfd_link_hash_defweak
)
3294 && h
->root
.u
.def
.section
->owner
!= NULL
3295 && h
->root
.u
.def
.section
->owner
->my_archive
!= NULL
)
3297 bfd
*arbfd
, *member
;
3299 arbfd
= h
->root
.u
.def
.section
->owner
->my_archive
;
3300 member
= bfd_openr_next_archived_file (arbfd
, (bfd
*) NULL
);
3301 while (member
!= NULL
)
3303 if ((member
->flags
& DYNAMIC
) != 0)
3308 member
= bfd_openr_next_archived_file (arbfd
, member
);
3313 h
->flags
|= XCOFF_EXPORT
;
3316 /* We don't want to garbage collect symbols which are not defined in
3317 XCOFF files. This is a convenient place to mark them. */
3318 if (xcoff_hash_table (ldinfo
->info
)->gc
3319 && (h
->flags
& XCOFF_MARK
) == 0
3320 && (h
->root
.type
== bfd_link_hash_defined
3321 || h
->root
.type
== bfd_link_hash_defweak
)
3322 && (h
->root
.u
.def
.section
->owner
== NULL
3323 || (h
->root
.u
.def
.section
->owner
->xvec
3324 != ldinfo
->info
->hash
->creator
)))
3325 h
->flags
|= XCOFF_MARK
;
3327 /* If this symbol is called and defined in a dynamic object, or it
3328 is imported, then we need to set up global linkage code for it.
3329 (Unless we did garbage collection and we didn't need this
3331 if ((h
->flags
& XCOFF_CALLED
) != 0
3332 && (h
->root
.type
== bfd_link_hash_undefined
3333 || h
->root
.type
== bfd_link_hash_undefweak
)
3334 && h
->root
.root
.string
[0] == '.'
3335 && h
->descriptor
!= NULL
3336 && ((h
->descriptor
->flags
& XCOFF_DEF_DYNAMIC
) != 0
3337 || ((h
->descriptor
->flags
& XCOFF_IMPORT
) != 0
3338 && (h
->descriptor
->flags
& XCOFF_DEF_REGULAR
) == 0))
3339 && (! xcoff_hash_table (ldinfo
->info
)->gc
3340 || (h
->flags
& XCOFF_MARK
) != 0))
3343 struct xcoff_link_hash_entry
*hds
;
3345 sec
= xcoff_hash_table (ldinfo
->info
)->linkage_section
;
3346 h
->root
.type
= bfd_link_hash_defined
;
3347 h
->root
.u
.def
.section
= sec
;
3348 h
->root
.u
.def
.value
= sec
->_raw_size
;
3350 h
->flags
|= XCOFF_DEF_REGULAR
;
3351 sec
->_raw_size
+= bfd_xcoff_glink_code_size(ldinfo
->output_bfd
);
3353 /* The global linkage code requires a TOC entry for the
3355 hds
= h
->descriptor
;
3356 BFD_ASSERT ((hds
->root
.type
== bfd_link_hash_undefined
3357 || hds
->root
.type
== bfd_link_hash_undefweak
)
3358 && (hds
->flags
& XCOFF_DEF_REGULAR
) == 0);
3359 hds
->flags
|= XCOFF_MARK
;
3360 if (hds
->toc_section
== NULL
)
3365 xcoff32 uses 4 bytes in the toc.
3366 xcoff64 uses 8 bytes in the toc. */
3367 if (bfd_xcoff_is_xcoff64 (ldinfo
->output_bfd
))
3369 else if (bfd_xcoff_is_xcoff32 (ldinfo
->output_bfd
))
3374 hds
->toc_section
= xcoff_hash_table (ldinfo
->info
)->toc_section
;
3375 hds
->u
.toc_offset
= hds
->toc_section
->_raw_size
;
3376 hds
->toc_section
->_raw_size
+= byte_size
;
3377 ++xcoff_hash_table (ldinfo
->info
)->ldrel_count
;
3378 ++hds
->toc_section
->reloc_count
;
3380 hds
->flags
|= XCOFF_SET_TOC
| XCOFF_LDREL
;
3382 /* We need to call xcoff_build_ldsyms recursively here,
3383 because we may already have passed hds on the traversal. */
3384 xcoff_build_ldsyms (hds
, p
);
3388 /* If this symbol is exported, but not defined, we need to try to
3390 if ((h
->flags
& XCOFF_EXPORT
) != 0
3391 && (h
->flags
& XCOFF_IMPORT
) == 0
3392 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
3393 && (h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
3394 && (h
->root
.type
== bfd_link_hash_undefined
3395 || h
->root
.type
== bfd_link_hash_undefweak
))
3397 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
3398 && (h
->descriptor
->root
.type
== bfd_link_hash_defined
3399 || h
->descriptor
->root
.type
== bfd_link_hash_defweak
))
3403 /* This is an undefined function descriptor associated with
3404 a defined entry point. We can build up a function
3405 descriptor ourselves. Believe it or not, the AIX linker
3406 actually does this, and there are cases where we need to
3408 sec
= xcoff_hash_table (ldinfo
->info
)->descriptor_section
;
3409 h
->root
.type
= bfd_link_hash_defined
;
3410 h
->root
.u
.def
.section
= sec
;
3411 h
->root
.u
.def
.value
= sec
->_raw_size
;
3413 h
->flags
|= XCOFF_DEF_REGULAR
;
3415 /* The size of the function descriptor depends if this is an
3416 xcoff32 (12) or xcoff64 (24). */
3418 bfd_xcoff_function_descriptor_size(ldinfo
->output_bfd
);
3420 /* A function descriptor uses two relocs: one for the
3421 associated code, and one for the TOC address. */
3422 xcoff_hash_table (ldinfo
->info
)->ldrel_count
+= 2;
3423 sec
->reloc_count
+= 2;
3425 /* We handle writing out the contents of the descriptor in
3426 xcoff_write_global_symbol. */
3430 (*_bfd_error_handler
)
3431 (_("warning: attempt to export undefined symbol `%s'"),
3432 h
->root
.root
.string
);
3438 /* If this is still a common symbol, and it wasn't garbage
3439 collected, we need to actually allocate space for it in the .bss
3441 if (h
->root
.type
== bfd_link_hash_common
3442 && (! xcoff_hash_table (ldinfo
->info
)->gc
3443 || (h
->flags
& XCOFF_MARK
) != 0)
3444 && h
->root
.u
.c
.p
->section
->_raw_size
== 0)
3446 BFD_ASSERT (bfd_is_com_section (h
->root
.u
.c
.p
->section
));
3447 h
->root
.u
.c
.p
->section
->_raw_size
= h
->root
.u
.c
.size
;
3450 /* We need to add a symbol to the .loader section if it is mentioned
3451 in a reloc which we are copying to the .loader section and it was
3452 not defined or common, or if it is the entry point, or if it is
3455 if (((h
->flags
& XCOFF_LDREL
) == 0
3456 || h
->root
.type
== bfd_link_hash_defined
3457 || h
->root
.type
== bfd_link_hash_defweak
3458 || h
->root
.type
== bfd_link_hash_common
)
3459 && (h
->flags
& XCOFF_ENTRY
) == 0
3460 && (h
->flags
& XCOFF_EXPORT
) == 0)
3466 /* We don't need to add this symbol if we did garbage collection and
3467 we did not mark this symbol. */
3468 if (xcoff_hash_table (ldinfo
->info
)->gc
3469 && (h
->flags
& XCOFF_MARK
) == 0)
3475 /* We may have already processed this symbol due to the recursive
3477 if ((h
->flags
& XCOFF_BUILT_LDSYM
) != 0)
3480 /* We need to add this symbol to the .loader symbols. */
3482 BFD_ASSERT (h
->ldsym
== NULL
);
3483 amt
= sizeof (struct internal_ldsym
);
3484 h
->ldsym
= (struct internal_ldsym
*) bfd_zalloc (ldinfo
->output_bfd
, amt
);
3485 if (h
->ldsym
== NULL
)
3487 ldinfo
->failed
= true;
3491 if ((h
->flags
& XCOFF_IMPORT
) != 0)
3492 h
->ldsym
->l_ifile
= h
->ldindx
;
3494 /* The first 3 symbol table indices are reserved to indicate the
3495 data, text and bss sections. */
3496 h
->ldindx
= ldinfo
->ldsym_count
+ 3;
3498 ++ldinfo
->ldsym_count
;
3500 if (false == bfd_xcoff_put_ldsymbol_name (ldinfo
->output_bfd
, ldinfo
,
3502 h
->root
.root
.string
))
3507 h
->flags
|= XCOFF_BUILT_LDSYM
;
3512 /* Do the final link step. */
3515 _bfd_xcoff_bfd_final_link (abfd
, info
)
3517 struct bfd_link_info
*info
;
3519 bfd_size_type symesz
;
3520 struct xcoff_final_link_info finfo
;
3522 struct bfd_link_order
*p
;
3523 bfd_size_type max_contents_size
;
3524 bfd_size_type max_sym_count
;
3525 bfd_size_type max_lineno_count
;
3526 bfd_size_type max_reloc_count
;
3527 bfd_size_type max_output_reloc_count
;
3528 file_ptr rel_filepos
;
3530 file_ptr line_filepos
;
3531 unsigned int linesz
;
3533 bfd_byte
*external_relocs
= NULL
;
3534 char strbuf
[STRING_SIZE_SIZE
];
3539 abfd
->flags
|= DYNAMIC
;
3541 symesz
= bfd_coff_symesz (abfd
);
3544 finfo
.output_bfd
= abfd
;
3545 finfo
.strtab
= NULL
;
3546 finfo
.section_info
= NULL
;
3547 finfo
.last_file_index
= -1;
3548 finfo
.toc_symindx
= -1;
3549 finfo
.internal_syms
= NULL
;
3550 finfo
.sym_indices
= NULL
;
3551 finfo
.outsyms
= NULL
;
3552 finfo
.linenos
= NULL
;
3553 finfo
.contents
= NULL
;
3554 finfo
.external_relocs
= NULL
;
3556 finfo
.ldsym
= (xcoff_hash_table (info
)->loader_section
->contents
3557 + bfd_xcoff_ldhdrsz (abfd
));
3558 finfo
.ldrel
= (xcoff_hash_table (info
)->loader_section
->contents
3559 + bfd_xcoff_ldhdrsz(abfd
)
3560 + (xcoff_hash_table (info
)->ldhdr
.l_nsyms
3561 * bfd_xcoff_ldsymsz(abfd
)));
3563 xcoff_data (abfd
)->coff
.link_info
= info
;
3565 finfo
.strtab
= _bfd_stringtab_init ();
3566 if (finfo
.strtab
== NULL
)
3569 /* Count the line number and relocation entries required for the
3570 output file. Determine a few maximum sizes. */
3571 max_contents_size
= 0;
3572 max_lineno_count
= 0;
3573 max_reloc_count
= 0;
3574 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3577 o
->lineno_count
= 0;
3578 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3580 if (p
->type
== bfd_indirect_link_order
)
3584 sec
= p
->u
.indirect
.section
;
3586 /* Mark all sections which are to be included in the
3587 link. This will normally be every section. We need
3588 to do this so that we can identify any sections which
3589 the linker has decided to not include. */
3590 sec
->linker_mark
= true;
3592 if (info
->strip
== strip_none
3593 || info
->strip
== strip_some
)
3594 o
->lineno_count
+= sec
->lineno_count
;
3596 o
->reloc_count
+= sec
->reloc_count
;
3598 if (sec
->_raw_size
> max_contents_size
)
3599 max_contents_size
= sec
->_raw_size
;
3600 if (sec
->lineno_count
> max_lineno_count
)
3601 max_lineno_count
= sec
->lineno_count
;
3602 if (coff_section_data (sec
->owner
, sec
) != NULL
3603 && xcoff_section_data (sec
->owner
, sec
) != NULL
3604 && (xcoff_section_data (sec
->owner
, sec
)->lineno_count
3605 > max_lineno_count
))
3607 xcoff_section_data (sec
->owner
, sec
)->lineno_count
;
3608 if (sec
->reloc_count
> max_reloc_count
)
3609 max_reloc_count
= sec
->reloc_count
;
3611 else if (p
->type
== bfd_section_reloc_link_order
3612 || p
->type
== bfd_symbol_reloc_link_order
)
3617 /* Compute the file positions for all the sections. */
3618 if (abfd
->output_has_begun
)
3620 if (xcoff_hash_table (info
)->file_align
!= 0)
3627 file_align
= xcoff_hash_table (info
)->file_align
;
3628 if (file_align
!= 0)
3630 boolean saw_contents
;
3635 /* Insert .pad sections before every section which has
3636 contents and is loaded, if it is preceded by some other
3637 section which has contents and is loaded. */
3638 saw_contents
= true;
3639 for (op
= &abfd
->sections
; *op
!= NULL
; op
= &(*op
)->next
)
3641 if (strcmp ((*op
)->name
, ".pad") == 0)
3642 saw_contents
= false;
3643 else if (((*op
)->flags
& SEC_HAS_CONTENTS
) != 0
3644 && ((*op
)->flags
& SEC_LOAD
) != 0)
3647 saw_contents
= true;
3652 /* Create a pad section and place it before the section
3653 that needs padding. This requires unlinking and
3654 relinking the bfd's section list. */
3656 st
= abfd
->section_tail
;
3657 n
= bfd_make_section_anyway (abfd
, ".pad");
3658 n
->flags
= SEC_HAS_CONTENTS
;
3659 n
->alignment_power
= 0;
3661 BFD_ASSERT (*st
== n
);
3662 bfd_section_list_remove (abfd
, st
);
3663 bfd_section_list_insert (abfd
, op
, n
);
3666 saw_contents
= false;
3671 /* Reset the section indices after inserting the new
3674 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3677 o
->target_index
= indx
;
3679 BFD_ASSERT ((unsigned int) indx
== abfd
->section_count
);
3681 /* Work out appropriate sizes for the .pad sections to force
3682 each section to land on a page boundary. This bit of
3683 code knows what compute_section_file_positions is going
3685 sofar
= bfd_coff_filhsz (abfd
);
3686 sofar
+= bfd_coff_aoutsz (abfd
);
3687 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3688 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3689 if ((bfd_xcoff_is_reloc_count_overflow
3690 (abfd
, (bfd_vma
) o
->reloc_count
))
3691 || (bfd_xcoff_is_lineno_count_overflow
3692 (abfd
, (bfd_vma
) o
->lineno_count
)))
3693 /* 64 does not overflow, need to check if 32 does */
3694 sofar
+= bfd_coff_scnhsz (abfd
);
3696 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3698 if (strcmp (o
->name
, ".pad") == 0)
3702 BFD_ASSERT (o
->_raw_size
== 0);
3703 pageoff
= sofar
& (file_align
- 1);
3706 o
->_raw_size
= file_align
- pageoff
;
3707 sofar
+= file_align
- pageoff
;
3708 o
->flags
|= SEC_HAS_CONTENTS
;
3713 if ((o
->flags
& SEC_HAS_CONTENTS
) != 0)
3714 sofar
+= BFD_ALIGN (o
->_raw_size
,
3715 1 << o
->alignment_power
);
3720 if (! bfd_coff_compute_section_file_positions (abfd
))
3724 /* Allocate space for the pointers we need to keep for the relocs. */
3728 /* We use section_count + 1, rather than section_count, because
3729 the target_index fields are 1 based. */
3730 amt
= abfd
->section_count
+ 1;
3731 amt
*= sizeof (struct xcoff_link_section_info
);
3732 finfo
.section_info
= (struct xcoff_link_section_info
*) bfd_malloc (amt
);
3733 if (finfo
.section_info
== NULL
)
3735 for (i
= 0; i
<= abfd
->section_count
; i
++)
3737 finfo
.section_info
[i
].relocs
= NULL
;
3738 finfo
.section_info
[i
].rel_hashes
= NULL
;
3739 finfo
.section_info
[i
].toc_rel_hashes
= NULL
;
3743 /* Set the file positions for the relocs. */
3744 rel_filepos
= obj_relocbase (abfd
);
3745 relsz
= bfd_coff_relsz (abfd
);
3746 max_output_reloc_count
= 0;
3747 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3749 if (o
->reloc_count
== 0)
3753 /* A stripped file has no relocs. However, we still
3754 allocate the buffers, so that later code doesn't have to
3755 worry about whether we are stripping or not. */
3756 if (info
->strip
== strip_all
)
3760 o
->flags
|= SEC_RELOC
;
3761 o
->rel_filepos
= rel_filepos
;
3762 rel_filepos
+= o
->reloc_count
* relsz
;
3765 /* We don't know the indices of global symbols until we have
3766 written out all the local symbols. For each section in
3767 the output file, we keep an array of pointers to hash
3768 table entries. Each entry in the array corresponds to a
3769 reloc. When we find a reloc against a global symbol, we
3770 set the corresponding entry in this array so that we can
3771 fix up the symbol index after we have written out all the
3774 Because of this problem, we also keep the relocs in
3775 memory until the end of the link. This wastes memory.
3776 We could backpatch the file later, I suppose, although it
3778 amt
= o
->reloc_count
;
3779 amt
*= sizeof (struct internal_reloc
);
3780 finfo
.section_info
[o
->target_index
].relocs
=
3781 (struct internal_reloc
*) bfd_malloc (amt
);
3783 amt
= o
->reloc_count
;
3784 amt
*= sizeof (struct xcoff_link_hash_entry
*);
3785 finfo
.section_info
[o
->target_index
].rel_hashes
=
3786 (struct xcoff_link_hash_entry
**) bfd_malloc (amt
);
3788 if (finfo
.section_info
[o
->target_index
].relocs
== NULL
3789 || finfo
.section_info
[o
->target_index
].rel_hashes
== NULL
)
3792 if (o
->reloc_count
> max_output_reloc_count
)
3793 max_output_reloc_count
= o
->reloc_count
;
3797 /* We now know the size of the relocs, so we can determine the file
3798 positions of the line numbers. */
3799 line_filepos
= rel_filepos
;
3800 finfo
.line_filepos
= line_filepos
;
3801 linesz
= bfd_coff_linesz (abfd
);
3802 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3804 if (o
->lineno_count
== 0)
3805 o
->line_filepos
= 0;
3808 o
->line_filepos
= line_filepos
;
3809 line_filepos
+= o
->lineno_count
* linesz
;
3812 /* Reset the reloc and lineno counts, so that we can use them to
3813 count the number of entries we have output so far. */
3815 o
->lineno_count
= 0;
3818 obj_sym_filepos (abfd
) = line_filepos
;
3820 /* Figure out the largest number of symbols in an input BFD. Take
3821 the opportunity to clear the output_has_begun fields of all the
3822 input BFD's. We want at least 6 symbols, since that is the
3823 number which xcoff_write_global_symbol may need. */
3825 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3829 sub
->output_has_begun
= false;
3830 sz
= obj_raw_syment_count (sub
);
3831 if (sz
> max_sym_count
)
3835 /* Allocate some buffers used while linking. */
3836 amt
= max_sym_count
* sizeof (struct internal_syment
);
3837 finfo
.internal_syms
= (struct internal_syment
*) bfd_malloc (amt
);
3839 amt
= max_sym_count
* sizeof (long);
3840 finfo
.sym_indices
= (long *) bfd_malloc (amt
);
3842 amt
= (max_sym_count
+ 1) * symesz
;
3843 finfo
.outsyms
= (bfd_byte
*) bfd_malloc (amt
);
3845 amt
= max_lineno_count
* bfd_coff_linesz (abfd
);
3846 finfo
.linenos
= (bfd_byte
*) bfd_malloc (amt
);
3848 amt
= max_contents_size
;
3849 finfo
.contents
= (bfd_byte
*) bfd_malloc (amt
);
3851 amt
= max_reloc_count
* relsz
;
3852 finfo
.external_relocs
= (bfd_byte
*) bfd_malloc (amt
);
3854 if ((finfo
.internal_syms
== NULL
&& max_sym_count
> 0)
3855 || (finfo
.sym_indices
== NULL
&& max_sym_count
> 0)
3856 || finfo
.outsyms
== NULL
3857 || (finfo
.linenos
== NULL
&& max_lineno_count
> 0)
3858 || (finfo
.contents
== NULL
&& max_contents_size
> 0)
3859 || (finfo
.external_relocs
== NULL
&& max_reloc_count
> 0))
3862 obj_raw_syment_count (abfd
) = 0;
3863 xcoff_data (abfd
)->toc
= (bfd_vma
) -1;
3865 /* We now know the position of everything in the file, except that
3866 we don't know the size of the symbol table and therefore we don't
3867 know where the string table starts. We just build the string
3868 table in memory as we go along. We process all the relocations
3869 for a single input file at once. */
3870 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3872 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3874 if (p
->type
== bfd_indirect_link_order
3875 && p
->u
.indirect
.section
->owner
->xvec
== abfd
->xvec
)
3877 sub
= p
->u
.indirect
.section
->owner
;
3878 if (! sub
->output_has_begun
)
3880 if (! xcoff_link_input_bfd (&finfo
, sub
))
3882 sub
->output_has_begun
= true;
3885 else if (p
->type
== bfd_section_reloc_link_order
3886 || p
->type
== bfd_symbol_reloc_link_order
)
3888 if (! xcoff_reloc_link_order (abfd
, &finfo
, o
, p
))
3893 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3900 /* Free up the buffers used by xcoff_link_input_bfd. */
3902 if (finfo
.internal_syms
!= NULL
)
3904 free (finfo
.internal_syms
);
3905 finfo
.internal_syms
= NULL
;
3907 if (finfo
.sym_indices
!= NULL
)
3909 free (finfo
.sym_indices
);
3910 finfo
.sym_indices
= NULL
;
3912 if (finfo
.linenos
!= NULL
)
3914 free (finfo
.linenos
);
3915 finfo
.linenos
= NULL
;
3917 if (finfo
.contents
!= NULL
)
3919 free (finfo
.contents
);
3920 finfo
.contents
= NULL
;
3922 if (finfo
.external_relocs
!= NULL
)
3924 free (finfo
.external_relocs
);
3925 finfo
.external_relocs
= NULL
;
3928 /* The value of the last C_FILE symbol is supposed to be -1. Write
3930 if (finfo
.last_file_index
!= -1)
3932 finfo
.last_file
.n_value
= -(bfd_vma
) 1;
3933 bfd_coff_swap_sym_out (abfd
, (PTR
) &finfo
.last_file
,
3934 (PTR
) finfo
.outsyms
);
3935 pos
= obj_sym_filepos (abfd
) + finfo
.last_file_index
* symesz
;
3936 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
3937 || bfd_bwrite (finfo
.outsyms
, symesz
, abfd
) != symesz
)
3941 /* Write out all the global symbols which do not come from XCOFF
3943 xcoff_link_hash_traverse (xcoff_hash_table (info
),
3944 xcoff_write_global_symbol
,
3947 if (finfo
.outsyms
!= NULL
)
3949 free (finfo
.outsyms
);
3950 finfo
.outsyms
= NULL
;
3953 /* Now that we have written out all the global symbols, we know the
3954 symbol indices to use for relocs against them, and we can finally
3955 write out the relocs. */
3956 amt
= max_output_reloc_count
* relsz
;
3957 external_relocs
= (bfd_byte
*) bfd_malloc (amt
);
3958 if (external_relocs
== NULL
&& max_output_reloc_count
!= 0)
3961 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3963 struct internal_reloc
*irel
;
3964 struct internal_reloc
*irelend
;
3965 struct xcoff_link_hash_entry
**rel_hash
;
3966 struct xcoff_toc_rel_hash
*toc_rel_hash
;
3968 bfd_size_type rel_size
;
3970 /* A stripped file has no relocs. */
3971 if (info
->strip
== strip_all
)
3977 if (o
->reloc_count
== 0)
3980 irel
= finfo
.section_info
[o
->target_index
].relocs
;
3981 irelend
= irel
+ o
->reloc_count
;
3982 rel_hash
= finfo
.section_info
[o
->target_index
].rel_hashes
;
3983 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
3985 if (*rel_hash
!= NULL
)
3987 if ((*rel_hash
)->indx
< 0)
3989 if (! ((*info
->callbacks
->unattached_reloc
)
3990 (info
, (*rel_hash
)->root
.root
.string
,
3991 (bfd
*) NULL
, o
, irel
->r_vaddr
)))
3993 (*rel_hash
)->indx
= 0;
3995 irel
->r_symndx
= (*rel_hash
)->indx
;
3999 for (toc_rel_hash
= finfo
.section_info
[o
->target_index
].toc_rel_hashes
;
4000 toc_rel_hash
!= NULL
;
4001 toc_rel_hash
= toc_rel_hash
->next
)
4003 if (toc_rel_hash
->h
->u
.toc_indx
< 0)
4005 if (! ((*info
->callbacks
->unattached_reloc
)
4006 (info
, toc_rel_hash
->h
->root
.root
.string
,
4007 (bfd
*) NULL
, o
, toc_rel_hash
->rel
->r_vaddr
)))
4009 toc_rel_hash
->h
->u
.toc_indx
= 0;
4011 toc_rel_hash
->rel
->r_symndx
= toc_rel_hash
->h
->u
.toc_indx
;
4014 /* XCOFF requires that the relocs be sorted by address. We tend
4015 to produce them in the order in which their containing csects
4016 appear in the symbol table, which is not necessarily by
4017 address. So we sort them here. There may be a better way to
4019 qsort ((PTR
) finfo
.section_info
[o
->target_index
].relocs
,
4020 o
->reloc_count
, sizeof (struct internal_reloc
),
4023 irel
= finfo
.section_info
[o
->target_index
].relocs
;
4024 irelend
= irel
+ o
->reloc_count
;
4025 erel
= external_relocs
;
4026 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
4027 bfd_coff_swap_reloc_out (abfd
, (PTR
) irel
, (PTR
) erel
);
4029 rel_size
= relsz
* o
->reloc_count
;
4030 if (bfd_seek (abfd
, o
->rel_filepos
, SEEK_SET
) != 0
4031 || bfd_bwrite ((PTR
) external_relocs
, rel_size
, abfd
) != rel_size
)
4035 if (external_relocs
!= NULL
)
4037 free (external_relocs
);
4038 external_relocs
= NULL
;
4041 /* Free up the section information. */
4042 if (finfo
.section_info
!= NULL
)
4046 for (i
= 0; i
< abfd
->section_count
; i
++)
4048 if (finfo
.section_info
[i
].relocs
!= NULL
)
4049 free (finfo
.section_info
[i
].relocs
);
4050 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
4051 free (finfo
.section_info
[i
].rel_hashes
);
4053 free (finfo
.section_info
);
4054 finfo
.section_info
= NULL
;
4057 /* Write out the loader section contents. */
4058 BFD_ASSERT ((bfd_byte
*) finfo
.ldrel
4059 == (xcoff_hash_table (info
)->loader_section
->contents
4060 + xcoff_hash_table (info
)->ldhdr
.l_impoff
));
4061 o
= xcoff_hash_table (info
)->loader_section
;
4062 if (! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
4063 (file_ptr
) o
->output_offset
, o
->_raw_size
))
4066 /* Write out the magic sections. */
4067 o
= xcoff_hash_table (info
)->linkage_section
;
4068 if (o
->_raw_size
> 0
4069 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
4070 (file_ptr
) o
->output_offset
,
4073 o
= xcoff_hash_table (info
)->toc_section
;
4074 if (o
->_raw_size
> 0
4075 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
4076 (file_ptr
) o
->output_offset
,
4079 o
= xcoff_hash_table (info
)->descriptor_section
;
4080 if (o
->_raw_size
> 0
4081 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
4082 (file_ptr
) o
->output_offset
,
4086 /* Write out the string table. */
4087 pos
= obj_sym_filepos (abfd
) + obj_raw_syment_count (abfd
) * symesz
;
4088 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
4091 _bfd_stringtab_size (finfo
.strtab
) + STRING_SIZE_SIZE
,
4093 amt
= STRING_SIZE_SIZE
;
4094 if (bfd_bwrite (strbuf
, amt
, abfd
) != amt
)
4096 if (! _bfd_stringtab_emit (abfd
, finfo
.strtab
))
4099 _bfd_stringtab_free (finfo
.strtab
);
4101 /* Write out the debugging string table. */
4102 o
= xcoff_hash_table (info
)->debug_section
;
4105 struct bfd_strtab_hash
*debug_strtab
;
4107 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
4108 BFD_ASSERT (o
->output_section
->_raw_size
- o
->output_offset
4109 >= _bfd_stringtab_size (debug_strtab
));
4110 pos
= o
->output_section
->filepos
+ o
->output_offset
;
4111 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
4113 if (! _bfd_stringtab_emit (abfd
, debug_strtab
))
4117 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
4118 not try to write out the symbols. */
4119 bfd_get_symcount (abfd
) = 0;
4124 if (finfo
.strtab
!= NULL
)
4125 _bfd_stringtab_free (finfo
.strtab
);
4127 if (finfo
.section_info
!= NULL
)
4131 for (i
= 0; i
< abfd
->section_count
; i
++)
4133 if (finfo
.section_info
[i
].relocs
!= NULL
)
4134 free (finfo
.section_info
[i
].relocs
);
4135 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
4136 free (finfo
.section_info
[i
].rel_hashes
);
4138 free (finfo
.section_info
);
4141 if (finfo
.internal_syms
!= NULL
)
4142 free (finfo
.internal_syms
);
4143 if (finfo
.sym_indices
!= NULL
)
4144 free (finfo
.sym_indices
);
4145 if (finfo
.outsyms
!= NULL
)
4146 free (finfo
.outsyms
);
4147 if (finfo
.linenos
!= NULL
)
4148 free (finfo
.linenos
);
4149 if (finfo
.contents
!= NULL
)
4150 free (finfo
.contents
);
4151 if (finfo
.external_relocs
!= NULL
)
4152 free (finfo
.external_relocs
);
4153 if (external_relocs
!= NULL
)
4154 free (external_relocs
);
4158 /* Link an input file into the linker output file. This function
4159 handles all the sections and relocations of the input file at once. */
4162 xcoff_link_input_bfd (finfo
, input_bfd
)
4163 struct xcoff_final_link_info
*finfo
;
4167 const char *strings
;
4168 bfd_size_type syment_base
;
4169 unsigned int n_tmask
;
4170 unsigned int n_btshft
;
4172 bfd_size_type isymesz
;
4173 bfd_size_type osymesz
;
4174 bfd_size_type linesz
;
4177 struct xcoff_link_hash_entry
**sym_hash
;
4178 struct internal_syment
*isymp
;
4180 unsigned long *debug_index
;
4182 unsigned long output_index
;
4189 /* We can just skip DYNAMIC files, unless this is a static link. */
4190 if ((input_bfd
->flags
& DYNAMIC
) != 0
4191 && ! finfo
->info
->static_link
)
4194 /* Move all the symbols to the output file. */
4196 output_bfd
= finfo
->output_bfd
;
4198 syment_base
= obj_raw_syment_count (output_bfd
);
4199 isymesz
= bfd_coff_symesz (input_bfd
);
4200 osymesz
= bfd_coff_symesz (output_bfd
);
4201 linesz
= bfd_coff_linesz (input_bfd
);
4202 BFD_ASSERT (linesz
== bfd_coff_linesz (output_bfd
));
4204 n_tmask
= coff_data (input_bfd
)->local_n_tmask
;
4205 n_btshft
= coff_data (input_bfd
)->local_n_btshft
;
4207 /* Define macros so that ISFCN, et. al., macros work correctly. */
4208 #define N_TMASK n_tmask
4209 #define N_BTSHFT n_btshft
4212 if (! finfo
->info
->keep_memory
)
4215 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
4218 if (! _bfd_coff_get_external_symbols (input_bfd
))
4221 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
4222 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
4223 sym_hash
= obj_xcoff_sym_hashes (input_bfd
);
4224 csectpp
= xcoff_data (input_bfd
)->csects
;
4225 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
4226 isymp
= finfo
->internal_syms
;
4227 indexp
= finfo
->sym_indices
;
4228 output_index
= syment_base
;
4229 outsym
= finfo
->outsyms
;
4233 while (esym
< esym_end
)
4236 struct internal_syment isym
;
4237 union internal_auxent aux
;
4243 bfd_coff_swap_sym_in (input_bfd
, (PTR
) esym
, (PTR
) isymp
);
4245 /* If this is a C_EXT or C_HIDEXT symbol, we need the csect
4247 if (isymp
->n_sclass
== C_EXT
|| isymp
->n_sclass
== C_HIDEXT
)
4249 BFD_ASSERT (isymp
->n_numaux
> 0);
4250 bfd_coff_swap_aux_in (input_bfd
,
4251 (PTR
) (esym
+ isymesz
* isymp
->n_numaux
),
4252 isymp
->n_type
, isymp
->n_sclass
,
4253 isymp
->n_numaux
- 1, isymp
->n_numaux
,
4256 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
4259 /* Make a copy of *isymp so that the relocate_section function
4260 always sees the original values. This is more reliable than
4261 always recomputing the symbol value even if we are stripping
4265 /* If this symbol is in the .loader section, swap out the
4266 .loader symbol information. If this is an external symbol
4267 reference to a defined symbol, though, then wait until we get
4268 to the definition. */
4269 if (isym
.n_sclass
== C_EXT
4270 && *sym_hash
!= NULL
4271 && (*sym_hash
)->ldsym
!= NULL
4273 || (*sym_hash
)->root
.type
== bfd_link_hash_undefined
))
4275 struct xcoff_link_hash_entry
*h
;
4276 struct internal_ldsym
*ldsym
;
4280 if (isym
.n_scnum
> 0)
4282 ldsym
->l_scnum
= (*csectpp
)->output_section
->target_index
;
4283 ldsym
->l_value
= (isym
.n_value
4284 + (*csectpp
)->output_section
->vma
4285 + (*csectpp
)->output_offset
4290 ldsym
->l_scnum
= isym
.n_scnum
;
4291 ldsym
->l_value
= isym
.n_value
;
4294 ldsym
->l_smtype
= smtyp
;
4295 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
4296 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4297 || (h
->flags
& XCOFF_IMPORT
) != 0)
4298 ldsym
->l_smtype
|= L_IMPORT
;
4299 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
4300 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4301 || (h
->flags
& XCOFF_EXPORT
) != 0)
4302 ldsym
->l_smtype
|= L_EXPORT
;
4303 if ((h
->flags
& XCOFF_ENTRY
) != 0)
4304 ldsym
->l_smtype
|= L_ENTRY
;
4306 ldsym
->l_smclas
= aux
.x_csect
.x_smclas
;
4308 if (ldsym
->l_ifile
== (bfd_size_type
) -1)
4310 else if (ldsym
->l_ifile
== 0)
4312 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
4318 if (h
->root
.type
== bfd_link_hash_defined
4319 || h
->root
.type
== bfd_link_hash_defweak
)
4320 impbfd
= h
->root
.u
.def
.section
->owner
;
4321 else if (h
->root
.type
== bfd_link_hash_undefined
4322 || h
->root
.type
== bfd_link_hash_undefweak
)
4323 impbfd
= h
->root
.u
.undef
.abfd
;
4331 BFD_ASSERT (impbfd
->xvec
== finfo
->output_bfd
->xvec
);
4332 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
4339 BFD_ASSERT (h
->ldindx
>= 0);
4340 bfd_xcoff_swap_ldsym_out (finfo
->output_bfd
, ldsym
,
4343 * bfd_xcoff_ldsymsz (finfo
->output_bfd
))));
4346 /* Fill in snentry now that we know the target_index. */
4347 if ((h
->flags
& XCOFF_ENTRY
) != 0
4348 && (h
->root
.type
== bfd_link_hash_defined
4349 || h
->root
.type
== bfd_link_hash_defweak
))
4351 xcoff_data (output_bfd
)->snentry
=
4352 h
->root
.u
.def
.section
->output_section
->target_index
;
4360 add
= 1 + isym
.n_numaux
;
4362 /* If we are skipping this csect, we want to skip this symbol. */
4363 if (*csectpp
== NULL
)
4366 /* If we garbage collected this csect, we want to skip this
4369 && xcoff_hash_table (finfo
->info
)->gc
4370 && ((*csectpp
)->flags
& SEC_MARK
) == 0
4371 && *csectpp
!= bfd_abs_section_ptr
)
4374 /* An XCOFF linker always skips C_STAT symbols. */
4376 && isymp
->n_sclass
== C_STAT
)
4379 /* We skip all but the first TOC anchor. */
4381 && isymp
->n_sclass
== C_HIDEXT
4382 && aux
.x_csect
.x_smclas
== XMC_TC0
)
4384 if (finfo
->toc_symindx
!= -1)
4388 bfd_vma tocval
, tocend
;
4391 tocval
= ((*csectpp
)->output_section
->vma
4392 + (*csectpp
)->output_offset
4396 /* We want to find out if tocval is a good value to use
4397 as the TOC anchor--that is, whether we can access all
4398 of the TOC using a 16 bit offset from tocval. This
4399 test assumes that the TOC comes at the end of the
4400 output section, as it does in the default linker
4402 tocend
= ((*csectpp
)->output_section
->vma
4403 + (*csectpp
)->output_section
->_raw_size
);
4404 for (inp
= finfo
->info
->input_bfds
;
4406 inp
= inp
->link_next
)
4409 for (o
= inp
->sections
; o
!= NULL
; o
= o
->next
)
4410 if (strcmp (o
->name
, ".tocbss") == 0)
4412 bfd_vma new_toc_end
;
4413 new_toc_end
= (o
->output_section
->vma
4416 if (new_toc_end
> tocend
)
4417 tocend
= new_toc_end
;
4422 if (tocval
+ 0x10000 < tocend
)
4424 (*_bfd_error_handler
)
4425 (_("TOC overflow: 0x%lx > 0x10000; try -mminimal-toc when compiling"),
4426 (unsigned long) (tocend
- tocval
));
4427 bfd_set_error (bfd_error_file_too_big
);
4431 if (tocval
+ 0x8000 < tocend
)
4435 tocadd
= tocend
- (tocval
+ 0x8000);
4437 isym
.n_value
+= tocadd
;
4440 finfo
->toc_symindx
= output_index
;
4441 xcoff_data (finfo
->output_bfd
)->toc
= tocval
;
4442 xcoff_data (finfo
->output_bfd
)->sntoc
=
4443 (*csectpp
)->output_section
->target_index
;
4449 /* If we are stripping all symbols, we want to skip this one. */
4451 && finfo
->info
->strip
== strip_all
)
4454 /* We can skip resolved external references. */
4456 && isym
.n_sclass
== C_EXT
4458 && (*sym_hash
)->root
.type
!= bfd_link_hash_undefined
)
4461 /* We can skip common symbols if they got defined somewhere
4464 && isym
.n_sclass
== C_EXT
4466 && ((*sym_hash
)->root
.type
!= bfd_link_hash_common
4467 || (*sym_hash
)->root
.u
.c
.p
->section
!= *csectpp
)
4468 && ((*sym_hash
)->root
.type
!= bfd_link_hash_defined
4469 || (*sym_hash
)->root
.u
.def
.section
!= *csectpp
))
4472 /* Skip local symbols if we are discarding them. */
4474 && finfo
->info
->discard
== discard_all
4475 && isym
.n_sclass
!= C_EXT
4476 && (isym
.n_sclass
!= C_HIDEXT
4477 || smtyp
!= XTY_SD
))
4480 /* If we stripping debugging symbols, and this is a debugging
4481 symbol, then skip it. */
4483 && finfo
->info
->strip
== strip_debugger
4484 && isym
.n_scnum
== N_DEBUG
)
4487 /* If some symbols are stripped based on the name, work out the
4488 name and decide whether to skip this symbol. We don't handle
4489 this correctly for symbols whose names are in the .debug
4490 section; to get it right we would need a new bfd_strtab_hash
4491 function to return the string given the index. */
4493 && (finfo
->info
->strip
== strip_some
4494 || finfo
->info
->discard
== discard_l
)
4495 && (debug_index
== NULL
|| *debug_index
== (unsigned long) -1))
4498 char buf
[SYMNMLEN
+ 1];
4500 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, buf
);
4505 if ((finfo
->info
->strip
== strip_some
4506 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false,
4508 || (finfo
->info
->discard
== discard_l
4509 && (isym
.n_sclass
!= C_EXT
4510 && (isym
.n_sclass
!= C_HIDEXT
4511 || smtyp
!= XTY_SD
))
4512 && bfd_is_local_label_name (input_bfd
, name
)))
4516 /* We can not skip the first TOC anchor. */
4519 && finfo
->info
->strip
!= strip_all
)
4522 /* We now know whether we are to skip this symbol or not. */
4525 /* Adjust the symbol in order to output it. */
4527 if (isym
._n
._n_n
._n_zeroes
== 0
4528 && isym
._n
._n_n
._n_offset
!= 0)
4530 /* This symbol has a long name. Enter it in the string
4531 table we are building. If *debug_index != -1, the
4532 name has already been entered in the .debug section. */
4533 if (debug_index
!= NULL
&& *debug_index
!= (unsigned long) -1)
4534 isym
._n
._n_n
._n_offset
= *debug_index
;
4540 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
,
4545 indx
= _bfd_stringtab_add (finfo
->strtab
, name
, hash
, copy
);
4546 if (indx
== (bfd_size_type
) -1)
4548 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
4552 if (isym
.n_sclass
!= C_BSTAT
4553 && isym
.n_sclass
!= C_ESTAT
4554 && isym
.n_sclass
!= C_DECL
4555 && isym
.n_scnum
> 0)
4557 isym
.n_scnum
= (*csectpp
)->output_section
->target_index
;
4558 isym
.n_value
+= ((*csectpp
)->output_section
->vma
4559 + (*csectpp
)->output_offset
4563 /* The value of a C_FILE symbol is the symbol index of the
4564 next C_FILE symbol. The value of the last C_FILE symbol
4565 is -1. We try to get this right, below, just before we
4566 write the symbols out, but in the general case we may
4567 have to write the symbol out twice. */
4568 if (isym
.n_sclass
== C_FILE
)
4570 if (finfo
->last_file_index
!= -1
4571 && finfo
->last_file
.n_value
!= (bfd_vma
) output_index
)
4573 /* We must correct the value of the last C_FILE entry. */
4574 finfo
->last_file
.n_value
= output_index
;
4575 if ((bfd_size_type
) finfo
->last_file_index
>= syment_base
)
4577 /* The last C_FILE symbol is in this input file. */
4578 bfd_coff_swap_sym_out (output_bfd
,
4579 (PTR
) &finfo
->last_file
,
4580 (PTR
) (finfo
->outsyms
4581 + ((finfo
->last_file_index
4587 /* We have already written out the last C_FILE
4588 symbol. We need to write it out again. We
4589 borrow *outsym temporarily. */
4592 bfd_coff_swap_sym_out (output_bfd
,
4593 (PTR
) &finfo
->last_file
,
4596 pos
= obj_sym_filepos (output_bfd
);
4597 pos
+= finfo
->last_file_index
* osymesz
;
4598 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4599 || (bfd_bwrite (outsym
, osymesz
, output_bfd
)
4605 finfo
->last_file_index
= output_index
;
4606 finfo
->last_file
= isym
;
4609 /* The value of a C_BINCL or C_EINCL symbol is a file offset
4610 into the line numbers. We update the symbol values when
4611 we handle the line numbers. */
4612 if (isym
.n_sclass
== C_BINCL
4613 || isym
.n_sclass
== C_EINCL
)
4615 isym
.n_value
= finfo
->line_filepos
;
4619 /* Output the symbol. */
4621 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
, (PTR
) outsym
);
4623 *indexp
= output_index
;
4625 if (isym
.n_sclass
== C_EXT
)
4628 struct xcoff_link_hash_entry
*h
;
4630 indx
= ((esym
- (bfd_byte
*) obj_coff_external_syms (input_bfd
))
4632 h
= obj_xcoff_sym_hashes (input_bfd
)[indx
];
4633 BFD_ASSERT (h
!= NULL
);
4634 h
->indx
= output_index
;
4637 /* If this is a symbol in the TOC which we may have merged
4638 (class XMC_TC), remember the symbol index of the TOC
4640 if (isym
.n_sclass
== C_HIDEXT
4641 && aux
.x_csect
.x_smclas
== XMC_TC
4642 && *sym_hash
!= NULL
)
4644 BFD_ASSERT (((*sym_hash
)->flags
& XCOFF_SET_TOC
) == 0);
4645 BFD_ASSERT ((*sym_hash
)->toc_section
!= NULL
);
4646 (*sym_hash
)->u
.toc_indx
= output_index
;
4649 output_index
+= add
;
4650 outsym
+= add
* osymesz
;
4653 esym
+= add
* isymesz
;
4657 if (debug_index
!= NULL
)
4660 for (--add
; add
> 0; --add
)
4664 /* Fix up the aux entries and the C_BSTAT symbols. This must be
4665 done in a separate pass, because we don't know the correct symbol
4666 indices until we have already decided which symbols we are going
4669 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
4670 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
4671 isymp
= finfo
->internal_syms
;
4672 indexp
= finfo
->sym_indices
;
4673 csectpp
= xcoff_data (input_bfd
)->csects
;
4674 outsym
= finfo
->outsyms
;
4675 while (esym
< esym_end
)
4679 add
= 1 + isymp
->n_numaux
;
4682 esym
+= add
* isymesz
;
4687 if (isymp
->n_sclass
== C_BSTAT
)
4689 struct internal_syment isym
;
4693 /* The value of a C_BSTAT symbol is the symbol table
4694 index of the containing csect. */
4695 bfd_coff_swap_sym_in (output_bfd
, (PTR
) outsym
, (PTR
) &isym
);
4696 indx
= isym
.n_value
;
4697 if (indx
< obj_raw_syment_count (input_bfd
))
4701 symindx
= finfo
->sym_indices
[indx
];
4705 isym
.n_value
= symindx
;
4706 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
,
4714 for (i
= 0; i
< isymp
->n_numaux
&& esym
< esym_end
; i
++)
4716 union internal_auxent aux
;
4718 bfd_coff_swap_aux_in (input_bfd
, (PTR
) esym
, isymp
->n_type
,
4719 isymp
->n_sclass
, i
, isymp
->n_numaux
,
4722 if (isymp
->n_sclass
== C_FILE
)
4724 /* This is the file name (or some comment put in by
4725 the compiler). If it is long, we must put it in
4726 the string table. */
4727 if (aux
.x_file
.x_n
.x_zeroes
== 0
4728 && aux
.x_file
.x_n
.x_offset
!= 0)
4730 const char *filename
;
4733 BFD_ASSERT (aux
.x_file
.x_n
.x_offset
4734 >= STRING_SIZE_SIZE
);
4735 if (strings
== NULL
)
4737 strings
= _bfd_coff_read_string_table (input_bfd
);
4738 if (strings
== NULL
)
4741 filename
= strings
+ aux
.x_file
.x_n
.x_offset
;
4742 indx
= _bfd_stringtab_add (finfo
->strtab
, filename
,
4744 if (indx
== (bfd_size_type
) -1)
4746 aux
.x_file
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
4749 else if ((isymp
->n_sclass
== C_EXT
4750 || isymp
->n_sclass
== C_HIDEXT
)
4751 && i
+ 1 == isymp
->n_numaux
)
4754 /* We don't support type checking. I don't know if
4756 aux
.x_csect
.x_parmhash
= 0;
4757 /* I don't think anybody uses these fields, but we'd
4758 better clobber them just in case. */
4759 aux
.x_csect
.x_stab
= 0;
4760 aux
.x_csect
.x_snstab
= 0;
4762 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_LD
)
4766 indx
= aux
.x_csect
.x_scnlen
.l
;
4767 if (indx
< obj_raw_syment_count (input_bfd
))
4771 symindx
= finfo
->sym_indices
[indx
];
4774 aux
.x_csect
.x_scnlen
.l
= 0;
4778 aux
.x_csect
.x_scnlen
.l
= symindx
;
4783 else if (isymp
->n_sclass
!= C_STAT
|| isymp
->n_type
!= T_NULL
)
4787 if (ISFCN (isymp
->n_type
)
4788 || ISTAG (isymp
->n_sclass
)
4789 || isymp
->n_sclass
== C_BLOCK
4790 || isymp
->n_sclass
== C_FCN
)
4792 indx
= aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
4794 && indx
< obj_raw_syment_count (input_bfd
))
4796 /* We look forward through the symbol for
4797 the index of the next symbol we are going
4798 to include. I don't know if this is
4800 while (finfo
->sym_indices
[indx
] < 0
4801 && indx
< obj_raw_syment_count (input_bfd
))
4803 if (indx
>= obj_raw_syment_count (input_bfd
))
4804 indx
= output_index
;
4806 indx
= finfo
->sym_indices
[indx
];
4807 aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= indx
;
4812 indx
= aux
.x_sym
.x_tagndx
.l
;
4813 if (indx
> 0 && indx
< obj_raw_syment_count (input_bfd
))
4817 symindx
= finfo
->sym_indices
[indx
];
4819 aux
.x_sym
.x_tagndx
.l
= 0;
4821 aux
.x_sym
.x_tagndx
.l
= symindx
;
4826 /* Copy over the line numbers, unless we are stripping
4827 them. We do this on a symbol by symbol basis in
4828 order to more easily handle garbage collection. */
4829 if ((isymp
->n_sclass
== C_EXT
4830 || isymp
->n_sclass
== C_HIDEXT
)
4832 && isymp
->n_numaux
> 1
4833 && ISFCN (isymp
->n_type
)
4834 && aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
4836 if (finfo
->info
->strip
!= strip_none
4837 && finfo
->info
->strip
!= strip_some
)
4838 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
4841 asection
*enclosing
;
4842 unsigned int enc_count
;
4843 bfd_signed_vma linoff
;
4844 struct internal_lineno lin
;
4847 enclosing
= xcoff_section_data (abfd
, o
)->enclosing
;
4848 enc_count
= xcoff_section_data (abfd
, o
)->lineno_count
;
4849 if (oline
!= enclosing
)
4851 file_ptr pos
= enclosing
->line_filepos
;
4852 bfd_size_type amt
= linesz
* enc_count
;
4853 if (bfd_seek (input_bfd
, pos
, SEEK_SET
) != 0
4854 || (bfd_bread (finfo
->linenos
, amt
, input_bfd
)
4860 linoff
= (aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
4861 - enclosing
->line_filepos
);
4863 bfd_coff_swap_lineno_in (input_bfd
,
4864 (PTR
) (finfo
->linenos
+ linoff
),
4867 || ((bfd_size_type
) lin
.l_addr
.l_symndx
4871 obj_coff_external_syms (input_bfd
)))
4873 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
4876 bfd_byte
*linpend
, *linp
;
4878 bfd_size_type count
;
4880 lin
.l_addr
.l_symndx
= *indexp
;
4881 bfd_coff_swap_lineno_out (output_bfd
, (PTR
) &lin
,
4882 (PTR
) (finfo
->linenos
4885 linpend
= (finfo
->linenos
4886 + enc_count
* linesz
);
4887 offset
= (o
->output_section
->vma
4890 for (linp
= finfo
->linenos
+ linoff
+ linesz
;
4894 bfd_coff_swap_lineno_in (input_bfd
, (PTR
) linp
,
4896 if (lin
.l_lnno
== 0)
4898 lin
.l_addr
.l_paddr
+= offset
;
4899 bfd_coff_swap_lineno_out (output_bfd
,
4904 count
= (linp
- (finfo
->linenos
+ linoff
)) / linesz
;
4906 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
4907 (o
->output_section
->line_filepos
4908 + o
->output_section
->lineno_count
* linesz
);
4910 if (bfd_seek (output_bfd
,
4911 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
,
4913 || (bfd_bwrite (finfo
->linenos
+ linoff
,
4914 linesz
* count
, output_bfd
)
4918 o
->output_section
->lineno_count
+= count
;
4922 struct internal_syment
*iisp
, *iispend
;
4927 /* Update any C_BINCL or C_EINCL symbols
4928 that refer to a line number in the
4929 range we just output. */
4930 iisp
= finfo
->internal_syms
;
4932 + obj_raw_syment_count (input_bfd
));
4933 iindp
= finfo
->sym_indices
;
4934 oos
= finfo
->outsyms
;
4935 while (iisp
< iispend
)
4938 && (iisp
->n_sclass
== C_BINCL
4939 || iisp
->n_sclass
== C_EINCL
)
4940 && ((bfd_size_type
) iisp
->n_value
4941 >= (bfd_size_type
)(enclosing
->line_filepos
+ linoff
))
4942 && ((bfd_size_type
) iisp
->n_value
4943 < (enclosing
->line_filepos
4944 + enc_count
* linesz
)))
4946 struct internal_syment iis
;
4948 bfd_coff_swap_sym_in (output_bfd
,
4953 - enclosing
->line_filepos
4955 + aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
);
4956 bfd_coff_swap_sym_out (output_bfd
,
4962 iiadd
= 1 + iisp
->n_numaux
;
4964 oos
+= iiadd
* osymesz
;
4973 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &aux
, isymp
->n_type
,
4974 isymp
->n_sclass
, i
, isymp
->n_numaux
,
4986 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
4987 symbol will be the first symbol in the next input file. In the
4988 normal case, this will save us from writing out the C_FILE symbol
4990 if (finfo
->last_file_index
!= -1
4991 && (bfd_size_type
) finfo
->last_file_index
>= syment_base
)
4993 finfo
->last_file
.n_value
= output_index
;
4994 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &finfo
->last_file
,
4995 (PTR
) (finfo
->outsyms
4996 + ((finfo
->last_file_index
- syment_base
)
5000 /* Write the modified symbols to the output file. */
5001 if (outsym
> finfo
->outsyms
)
5003 file_ptr pos
= obj_sym_filepos (output_bfd
) + syment_base
* osymesz
;
5004 bfd_size_type amt
= outsym
- finfo
->outsyms
;
5005 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5006 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
5009 BFD_ASSERT ((obj_raw_syment_count (output_bfd
)
5010 + (outsym
- finfo
->outsyms
) / osymesz
)
5013 obj_raw_syment_count (output_bfd
) = output_index
;
5016 /* Don't let the linker relocation routines discard the symbols. */
5017 keep_syms
= obj_coff_keep_syms (input_bfd
);
5018 obj_coff_keep_syms (input_bfd
) = true;
5020 /* Relocate the contents of each section. */
5021 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5026 if (! o
->linker_mark
)
5028 /* This section was omitted from the link. */
5032 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5033 || o
->_raw_size
== 0
5034 || (o
->flags
& SEC_IN_MEMORY
) != 0)
5037 /* We have set filepos correctly for the sections we created to
5038 represent csects, so bfd_get_section_contents should work. */
5039 if (coff_section_data (input_bfd
, o
) != NULL
5040 && coff_section_data (input_bfd
, o
)->contents
!= NULL
)
5041 contents
= coff_section_data (input_bfd
, o
)->contents
;
5043 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
5044 (file_ptr
) 0, o
->_raw_size
))
5046 contents
= finfo
->contents
;
5049 if ((o
->flags
& SEC_RELOC
) != 0)
5052 struct internal_reloc
*internal_relocs
;
5053 struct internal_reloc
*irel
;
5055 struct internal_reloc
*irelend
;
5056 struct xcoff_link_hash_entry
**rel_hash
;
5059 /* Read in the relocs. */
5060 target_index
= o
->output_section
->target_index
;
5061 internal_relocs
= (xcoff_read_internal_relocs
5062 (input_bfd
, o
, false, finfo
->external_relocs
,
5064 (finfo
->section_info
[target_index
].relocs
5065 + o
->output_section
->reloc_count
)));
5066 if (internal_relocs
== NULL
)
5069 /* Call processor specific code to relocate the section
5071 if (! bfd_coff_relocate_section (output_bfd
, finfo
->info
,
5075 finfo
->internal_syms
,
5076 xcoff_data (input_bfd
)->csects
))
5079 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
5080 irel
= internal_relocs
;
5081 irelend
= irel
+ o
->reloc_count
;
5082 rel_hash
= (finfo
->section_info
[target_index
].rel_hashes
5083 + o
->output_section
->reloc_count
);
5084 for (; irel
< irelend
; irel
++, rel_hash
++)
5086 struct xcoff_link_hash_entry
*h
= NULL
;
5087 struct internal_ldrel ldrel
;
5092 /* Adjust the reloc address and symbol index. */
5094 irel
->r_vaddr
+= offset
;
5096 r_symndx
= irel
->r_symndx
;
5101 h
= obj_xcoff_sym_hashes (input_bfd
)[r_symndx
];
5103 if (r_symndx
!= -1 && finfo
->info
->strip
!= strip_all
)
5106 && h
->smclas
!= XMC_TD
5107 && (irel
->r_type
== R_TOC
5108 || irel
->r_type
== R_GL
5109 || irel
->r_type
== R_TCL
5110 || irel
->r_type
== R_TRL
5111 || irel
->r_type
== R_TRLA
))
5113 /* This is a TOC relative reloc with a symbol
5114 attached. The symbol should be the one which
5115 this reloc is for. We want to make this
5116 reloc against the TOC address of the symbol,
5117 not the symbol itself. */
5118 BFD_ASSERT (h
->toc_section
!= NULL
);
5119 BFD_ASSERT ((h
->flags
& XCOFF_SET_TOC
) == 0);
5120 if (h
->u
.toc_indx
!= -1)
5121 irel
->r_symndx
= h
->u
.toc_indx
;
5124 struct xcoff_toc_rel_hash
*n
;
5125 struct xcoff_link_section_info
*si
;
5128 amt
= sizeof (struct xcoff_toc_rel_hash
);
5129 n
= ((struct xcoff_toc_rel_hash
*)
5130 bfd_alloc (finfo
->output_bfd
, amt
));
5133 si
= finfo
->section_info
+ target_index
;
5134 n
->next
= si
->toc_rel_hashes
;
5137 si
->toc_rel_hashes
= n
;
5142 /* This is a global symbol. */
5144 irel
->r_symndx
= h
->indx
;
5147 /* This symbol is being written at the end
5148 of the file, and we do not yet know the
5149 symbol index. We save the pointer to the
5150 hash table entry in the rel_hash list.
5151 We set the indx field to -2 to indicate
5152 that this symbol must not be stripped. */
5161 indx
= finfo
->sym_indices
[r_symndx
];
5165 struct internal_syment
*is
;
5167 /* Relocations against a TC0 TOC anchor are
5168 automatically transformed to be against
5169 the TOC anchor in the output file. */
5170 is
= finfo
->internal_syms
+ r_symndx
;
5171 if (is
->n_sclass
== C_HIDEXT
5172 && is
->n_numaux
> 0)
5175 union internal_auxent aux
;
5179 obj_coff_external_syms (input_bfd
))
5180 + ((r_symndx
+ is
->n_numaux
)
5182 bfd_coff_swap_aux_in (input_bfd
, auxptr
,
5183 is
->n_type
, is
->n_sclass
,
5187 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_SD
5188 && aux
.x_csect
.x_smclas
== XMC_TC0
)
5189 indx
= finfo
->toc_symindx
;
5194 irel
->r_symndx
= indx
;
5198 struct internal_syment
*is
;
5201 char buf
[SYMNMLEN
+ 1];
5203 /* This reloc is against a symbol we are
5204 stripping. It would be possible to handle
5205 this case, but I don't think it's worth it. */
5206 is
= finfo
->internal_syms
+ r_symndx
;
5208 name
= (_bfd_coff_internal_syment_name
5209 (input_bfd
, is
, buf
));
5214 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
5215 (finfo
->info
, name
, input_bfd
, o
,
5223 switch (irel
->r_type
)
5227 || h
->root
.type
== bfd_link_hash_defined
5228 || h
->root
.type
== bfd_link_hash_defweak
5229 || h
->root
.type
== bfd_link_hash_common
)
5236 /* This reloc needs to be copied into the .loader
5238 ldrel
.l_vaddr
= irel
->r_vaddr
;
5240 ldrel
.l_symndx
= -(bfd_size_type
) 1;
5242 || (h
->root
.type
== bfd_link_hash_defined
5243 || h
->root
.type
== bfd_link_hash_defweak
5244 || h
->root
.type
== bfd_link_hash_common
))
5249 sec
= xcoff_data (input_bfd
)->csects
[r_symndx
];
5250 else if (h
->root
.type
== bfd_link_hash_common
)
5251 sec
= h
->root
.u
.c
.p
->section
;
5253 sec
= h
->root
.u
.def
.section
;
5254 sec
= sec
->output_section
;
5256 if (strcmp (sec
->name
, ".text") == 0)
5258 else if (strcmp (sec
->name
, ".data") == 0)
5260 else if (strcmp (sec
->name
, ".bss") == 0)
5264 (*_bfd_error_handler
)
5265 (_("%s: loader reloc in unrecognized section `%s'"),
5266 bfd_archive_filename (input_bfd
),
5268 bfd_set_error (bfd_error_nonrepresentable_section
);
5274 if (! finfo
->info
->relocateable
5275 && (h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
5276 && (h
->flags
& XCOFF_IMPORT
) == 0)
5278 /* We already called the undefined_symbol
5279 callback for this relocation, in
5280 _bfd_ppc_xcoff_relocate_section. Don't
5281 issue any more warnings. */
5284 if (h
->ldindx
< 0 && ! quiet
)
5286 (*_bfd_error_handler
)
5287 (_("%s: `%s' in loader reloc but not loader sym"),
5288 bfd_archive_filename (input_bfd
),
5289 h
->root
.root
.string
);
5290 bfd_set_error (bfd_error_bad_value
);
5293 ldrel
.l_symndx
= h
->ldindx
;
5295 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
5296 ldrel
.l_rsecnm
= o
->output_section
->target_index
;
5297 if (xcoff_hash_table (finfo
->info
)->textro
5298 && strcmp (o
->output_section
->name
, ".text") == 0
5301 (*_bfd_error_handler
)
5302 (_("%s: loader reloc in read-only section %s"),
5303 bfd_archive_filename (input_bfd
),
5304 bfd_get_section_name (finfo
->output_bfd
,
5305 o
->output_section
));
5306 bfd_set_error (bfd_error_invalid_operation
);
5309 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
,
5312 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5320 /* We should never need a .loader reloc for a TOC
5326 o
->output_section
->reloc_count
+= o
->reloc_count
;
5329 /* Write out the modified section contents. */
5330 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
5331 contents
, (file_ptr
) o
->output_offset
,
5332 (o
->_cooked_size
!= 0
5338 obj_coff_keep_syms (input_bfd
) = keep_syms
;
5340 if (! finfo
->info
->keep_memory
)
5342 if (! _bfd_coff_free_symbols (input_bfd
))
5352 /* Write out a non-XCOFF global symbol. */
5356 xcoff_write_global_symbol (h
, inf
)
5357 struct xcoff_link_hash_entry
*h
;
5360 struct xcoff_final_link_info
*finfo
= (struct xcoff_final_link_info
*) inf
;
5363 struct internal_syment isym
;
5364 union internal_auxent aux
;
5369 output_bfd
= finfo
->output_bfd
;
5370 outsym
= finfo
->outsyms
;
5372 /* If this symbol was garbage collected, just skip it. */
5373 if (xcoff_hash_table (finfo
->info
)->gc
5374 && (h
->flags
& XCOFF_MARK
) == 0)
5377 /* If we need a .loader section entry, write it out. */
5378 if (h
->ldsym
!= NULL
)
5380 struct internal_ldsym
*ldsym
;
5385 if (h
->root
.type
== bfd_link_hash_undefined
5386 || h
->root
.type
== bfd_link_hash_undefweak
)
5390 ldsym
->l_scnum
= N_UNDEF
;
5391 ldsym
->l_smtype
= XTY_ER
;
5392 impbfd
= h
->root
.u
.undef
.abfd
;
5395 else if (h
->root
.type
== bfd_link_hash_defined
5396 || h
->root
.type
== bfd_link_hash_defweak
)
5401 sec
= h
->root
.u
.def
.section
;
5402 ldsym
->l_value
= (sec
->output_section
->vma
5403 + sec
->output_offset
5404 + h
->root
.u
.def
.value
);
5405 ldsym
->l_scnum
= sec
->output_section
->target_index
;
5406 ldsym
->l_smtype
= XTY_SD
;
5407 impbfd
= sec
->owner
;
5413 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
5414 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
5415 || (h
->flags
& XCOFF_IMPORT
) != 0)
5418 Import symbols are defined so the check above will make
5419 the l_smtype XTY_SD. But this is not correct, it should
5421 ldsym
->l_smtype
|= L_IMPORT
;
5424 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
5425 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
5426 || (h
->flags
& XCOFF_EXPORT
) != 0)
5428 ldsym
->l_smtype
|= L_EXPORT
;
5431 if ((h
->flags
& XCOFF_ENTRY
) != 0)
5433 ldsym
->l_smtype
|= L_ENTRY
;
5436 if ((h
->flags
& XCOFF_RTINIT
) != 0)
5438 ldsym
->l_smtype
= XTY_SD
;
5441 ldsym
->l_smclas
= h
->smclas
;
5443 if (ldsym
->l_smtype
& L_IMPORT
)
5445 if ((h
->root
.type
== bfd_link_hash_defined
5446 || h
->root
.type
== bfd_link_hash_defweak
)
5447 && (h
->root
.u
.def
.value
!= 0))
5449 ldsym
->l_smclas
= XMC_XO
;
5451 else if ((h
->flags
& (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
)) ==
5452 (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
))
5454 ldsym
->l_smclas
= XMC_SV3264
;
5456 else if (h
->flags
& XCOFF_SYSCALL32
)
5458 ldsym
->l_smclas
= XMC_SV
;
5460 else if (h
->flags
& XCOFF_SYSCALL64
)
5462 ldsym
->l_smclas
= XMC_SV64
;
5466 if (ldsym
->l_ifile
== -(bfd_size_type
) 1)
5470 else if (ldsym
->l_ifile
== 0)
5472 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
5476 else if (impbfd
== NULL
)
5482 BFD_ASSERT (impbfd
->xvec
== output_bfd
->xvec
);
5483 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
5489 BFD_ASSERT (h
->ldindx
>= 0);
5491 bfd_xcoff_swap_ldsym_out (output_bfd
, ldsym
,
5494 * bfd_xcoff_ldsymsz(finfo
->output_bfd
)));
5498 /* If this symbol needs global linkage code, write it out. */
5499 if (h
->root
.type
== bfd_link_hash_defined
5500 && (h
->root
.u
.def
.section
5501 == xcoff_hash_table (finfo
->info
)->linkage_section
))
5507 p
= h
->root
.u
.def
.section
->contents
+ h
->root
.u
.def
.value
;
5509 /* The first instruction in the global linkage code loads a
5510 specific TOC element. */
5511 tocoff
= (h
->descriptor
->toc_section
->output_section
->vma
5512 + h
->descriptor
->toc_section
->output_offset
5513 - xcoff_data (output_bfd
)->toc
);
5515 if ((h
->descriptor
->flags
& XCOFF_SET_TOC
) != 0)
5517 tocoff
+= h
->descriptor
->u
.toc_offset
;
5521 /* The first instruction in the glink code needs to be
5522 cooked to to hold the correct offset in the toc. The
5523 rest are just output raw. */
5524 bfd_put_32 (output_bfd
,
5525 bfd_xcoff_glink_code(output_bfd
, 0) | (tocoff
& 0xffff), p
);
5527 /* Start with i == 1 to get past the first instruction done above
5528 The /4 is because the glink code is in bytes and we are going
5530 for (i
= 1; i
< bfd_xcoff_glink_code_size(output_bfd
) / 4; i
++)
5532 bfd_put_32 (output_bfd
,
5533 (bfd_vma
) bfd_xcoff_glink_code(output_bfd
, i
),
5538 /* If we created a TOC entry for this symbol, write out the required
5540 if ((h
->flags
& XCOFF_SET_TOC
) != 0)
5545 struct internal_reloc
*irel
;
5546 struct internal_ldrel ldrel
;
5547 struct internal_syment irsym
;
5548 union internal_auxent iraux
;
5550 tocsec
= h
->toc_section
;
5551 osec
= tocsec
->output_section
;
5552 oindx
= osec
->target_index
;
5553 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
5554 irel
->r_vaddr
= (osec
->vma
5555 + tocsec
->output_offset
5561 irel
->r_symndx
= h
->indx
;
5566 irel
->r_symndx
= obj_raw_syment_count (output_bfd
);
5569 BFD_ASSERT (h
->ldindx
>= 0);
5571 /* Initialize the aux union here instead of closer to when it is
5572 written out below because the length of the csect depends on
5573 whether the output is 32 or 64 bit. */
5574 memset (&iraux
, 0, sizeof iraux
);
5575 iraux
.x_csect
.x_smtyp
= XTY_SD
;
5576 /* iraux.x_csect.x_scnlen.l = 4 or 8, see below */
5577 iraux
.x_csect
.x_smclas
= XMC_TC
;
5579 /* 32 bit uses a 32 bit R_POS to do the relocations
5580 64 bit uses a 64 bit R_POS to do the relocations
5582 Also needs to change the csect size : 4 for 32 bit, 8 for 64 bit
5584 Which one is determined by the backend. */
5585 if (bfd_xcoff_is_xcoff64 (output_bfd
))
5588 iraux
.x_csect
.x_scnlen
.l
= 8;
5590 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
5593 iraux
.x_csect
.x_scnlen
.l
= 4;
5599 irel
->r_type
= R_POS
;
5600 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5601 ++osec
->reloc_count
;
5603 ldrel
.l_vaddr
= irel
->r_vaddr
;
5604 ldrel
.l_symndx
= h
->ldindx
;
5605 ldrel
.l_rtype
= (irel
->r_size
<< 8) | R_POS
;
5606 ldrel
.l_rsecnm
= oindx
;
5607 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5608 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5610 /* We need to emit a symbol to define a csect which holds
5612 if (finfo
->info
->strip
!= strip_all
)
5615 result
= bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
,
5616 &irsym
, h
->root
.root
.string
);
5617 if (false == result
)
5622 irsym
.n_value
= irel
->r_vaddr
;
5623 irsym
.n_scnum
= osec
->target_index
;
5624 irsym
.n_sclass
= C_HIDEXT
;
5625 irsym
.n_type
= T_NULL
;
5628 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &irsym
, (PTR
) outsym
);
5629 outsym
+= bfd_coff_symesz (output_bfd
);
5631 /* note : iraux is initialized above */
5632 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &iraux
, T_NULL
, C_HIDEXT
,
5633 0, 1, (PTR
) outsym
);
5634 outsym
+= bfd_coff_auxesz (output_bfd
);
5638 /* We aren't going to write out the symbols below, so we
5639 need to write them out now. */
5640 pos
= obj_sym_filepos (output_bfd
);
5641 pos
+= (obj_raw_syment_count (output_bfd
)
5642 * bfd_coff_symesz (output_bfd
));
5643 amt
= outsym
- finfo
->outsyms
;
5644 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5645 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
5647 obj_raw_syment_count (output_bfd
) +=
5648 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
5650 outsym
= finfo
->outsyms
;
5655 /* If this symbol is a specially defined function descriptor, write
5656 it out. The first word is the address of the function code
5657 itself, the second word is the address of the TOC, and the third
5661 The addresses for the 32 bit will take 4 bytes and the addresses
5662 for 64 bit will take 8 bytes. Similar for the relocs. This type
5663 of logic was also done above to create a TOC entry in
5664 xcoff_write_global_symbol. */
5665 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
5666 && h
->root
.type
== bfd_link_hash_defined
5667 && (h
->root
.u
.def
.section
5668 == xcoff_hash_table (finfo
->info
)->descriptor_section
))
5674 struct xcoff_link_hash_entry
*hentry
;
5676 struct internal_reloc
*irel
;
5677 struct internal_ldrel ldrel
;
5679 unsigned int reloc_size
, byte_size
;
5681 if (bfd_xcoff_is_xcoff64 (output_bfd
))
5686 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
5696 sec
= h
->root
.u
.def
.section
;
5697 osec
= sec
->output_section
;
5698 oindx
= osec
->target_index
;
5699 p
= sec
->contents
+ h
->root
.u
.def
.value
;
5701 hentry
= h
->descriptor
;
5702 BFD_ASSERT (hentry
!= NULL
5703 && (hentry
->root
.type
== bfd_link_hash_defined
5704 || hentry
->root
.type
== bfd_link_hash_defweak
));
5705 esec
= hentry
->root
.u
.def
.section
;
5707 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
5708 irel
->r_vaddr
= (osec
->vma
5709 + sec
->output_offset
5710 + h
->root
.u
.def
.value
);
5711 irel
->r_symndx
= esec
->output_section
->target_index
;
5712 irel
->r_type
= R_POS
;
5713 irel
->r_size
= reloc_size
;
5714 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5715 ++osec
->reloc_count
;
5717 ldrel
.l_vaddr
= irel
->r_vaddr
;
5718 if (strcmp (esec
->output_section
->name
, ".text") == 0)
5720 else if (strcmp (esec
->output_section
->name
, ".data") == 0)
5722 else if (strcmp (esec
->output_section
->name
, ".bss") == 0)
5726 (*_bfd_error_handler
)
5727 (_("%s: loader reloc in unrecognized section `%s'"),
5728 bfd_get_filename (output_bfd
),
5729 esec
->output_section
->name
);
5730 bfd_set_error (bfd_error_nonrepresentable_section
);
5733 ldrel
.l_rtype
= (reloc_size
<< 8) | R_POS
;
5734 ldrel
.l_rsecnm
= oindx
;
5735 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5736 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5738 /* There are three items to write out,
5739 the address of the code
5740 the address of the toc anchor
5741 the environment pointer.
5742 We are ignoring the environment pointer. So set it to zero. */
5743 if (bfd_xcoff_is_xcoff64 (output_bfd
))
5745 bfd_put_64 (output_bfd
,
5746 (esec
->output_section
->vma
+ esec
->output_offset
5747 + hentry
->root
.u
.def
.value
),
5749 bfd_put_64 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 8);
5750 bfd_put_64 (output_bfd
, (bfd_vma
) 0, p
+ 16);
5755 This logic was already called above so the error case where
5756 the backend is neither has already been checked. */
5757 bfd_put_32 (output_bfd
,
5758 (esec
->output_section
->vma
+ esec
->output_offset
5759 + hentry
->root
.u
.def
.value
),
5761 bfd_put_32 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 4);
5762 bfd_put_32 (output_bfd
, (bfd_vma
) 0, p
+ 8);
5765 tsec
= coff_section_from_bfd_index (output_bfd
,
5766 xcoff_data (output_bfd
)->sntoc
);
5769 irel
->r_vaddr
= (osec
->vma
5770 + sec
->output_offset
5771 + h
->root
.u
.def
.value
5773 irel
->r_symndx
= tsec
->output_section
->target_index
;
5774 irel
->r_type
= R_POS
;
5775 irel
->r_size
= reloc_size
;
5776 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5777 ++osec
->reloc_count
;
5779 ldrel
.l_vaddr
= irel
->r_vaddr
;
5780 if (strcmp (tsec
->output_section
->name
, ".text") == 0)
5782 else if (strcmp (tsec
->output_section
->name
, ".data") == 0)
5784 else if (strcmp (tsec
->output_section
->name
, ".bss") == 0)
5788 (*_bfd_error_handler
)
5789 (_("%s: loader reloc in unrecognized section `%s'"),
5790 bfd_get_filename (output_bfd
),
5791 tsec
->output_section
->name
);
5792 bfd_set_error (bfd_error_nonrepresentable_section
);
5795 ldrel
.l_rtype
= (reloc_size
<< 8) | R_POS
;
5796 ldrel
.l_rsecnm
= oindx
;
5797 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5798 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5801 if (h
->indx
>= 0 || finfo
->info
->strip
== strip_all
)
5803 BFD_ASSERT (outsym
== finfo
->outsyms
);
5808 && (finfo
->info
->strip
== strip_all
5809 || (finfo
->info
->strip
== strip_some
5810 && bfd_hash_lookup (finfo
->info
->keep_hash
, h
->root
.root
.string
,
5811 false, false) == NULL
)))
5813 BFD_ASSERT (outsym
== finfo
->outsyms
);
5818 && (h
->flags
& (XCOFF_REF_REGULAR
| XCOFF_DEF_REGULAR
)) == 0)
5820 BFD_ASSERT (outsym
== finfo
->outsyms
);
5824 memset (&aux
, 0, sizeof aux
);
5826 h
->indx
= obj_raw_syment_count (output_bfd
);
5828 result
= bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
, &isym
,
5829 h
->root
.root
.string
);
5830 if (false == result
)
5835 if (h
->root
.type
== bfd_link_hash_undefined
5836 || h
->root
.type
== bfd_link_hash_undefweak
)
5839 isym
.n_scnum
= N_UNDEF
;
5840 isym
.n_sclass
= C_EXT
;
5841 aux
.x_csect
.x_smtyp
= XTY_ER
;
5843 else if ((h
->root
.type
== bfd_link_hash_defined
5844 || h
->root
.type
== bfd_link_hash_defweak
)
5845 && h
->smclas
== XMC_XO
)
5847 BFD_ASSERT (bfd_is_abs_section (h
->root
.u
.def
.section
));
5848 isym
.n_value
= h
->root
.u
.def
.value
;
5849 isym
.n_scnum
= N_UNDEF
;
5850 isym
.n_sclass
= C_EXT
;
5851 aux
.x_csect
.x_smtyp
= XTY_ER
;
5853 else if (h
->root
.type
== bfd_link_hash_defined
5854 || h
->root
.type
== bfd_link_hash_defweak
)
5856 struct xcoff_link_size_list
*l
;
5858 isym
.n_value
= (h
->root
.u
.def
.section
->output_section
->vma
5859 + h
->root
.u
.def
.section
->output_offset
5860 + h
->root
.u
.def
.value
);
5861 isym
.n_scnum
= h
->root
.u
.def
.section
->output_section
->target_index
;
5862 isym
.n_sclass
= C_HIDEXT
;
5863 aux
.x_csect
.x_smtyp
= XTY_SD
;
5865 if ((h
->flags
& XCOFF_HAS_SIZE
) != 0)
5867 for (l
= xcoff_hash_table (finfo
->info
)->size_list
;
5873 aux
.x_csect
.x_scnlen
.l
= l
->size
;
5879 else if (h
->root
.type
== bfd_link_hash_common
)
5881 isym
.n_value
= (h
->root
.u
.c
.p
->section
->output_section
->vma
5882 + h
->root
.u
.c
.p
->section
->output_offset
);
5883 isym
.n_scnum
= h
->root
.u
.c
.p
->section
->output_section
->target_index
;
5884 isym
.n_sclass
= C_EXT
;
5885 aux
.x_csect
.x_smtyp
= XTY_CM
;
5886 aux
.x_csect
.x_scnlen
.l
= h
->root
.u
.c
.size
;
5891 isym
.n_type
= T_NULL
;
5894 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
, (PTR
) outsym
);
5895 outsym
+= bfd_coff_symesz (output_bfd
);
5897 aux
.x_csect
.x_smclas
= h
->smclas
;
5898 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &aux
, T_NULL
, isym
.n_sclass
, 0, 1,
5900 outsym
+= bfd_coff_auxesz (output_bfd
);
5902 if ((h
->root
.type
== bfd_link_hash_defined
5903 || h
->root
.type
== bfd_link_hash_defweak
)
5904 && h
->smclas
!= XMC_XO
)
5906 /* We just output an SD symbol. Now output an LD symbol. */
5910 isym
.n_sclass
= C_EXT
;
5911 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
, (PTR
) outsym
);
5912 outsym
+= bfd_coff_symesz (output_bfd
);
5914 aux
.x_csect
.x_smtyp
= XTY_LD
;
5915 aux
.x_csect
.x_scnlen
.l
= obj_raw_syment_count (output_bfd
);
5916 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &aux
, T_NULL
, C_EXT
, 0, 1,
5918 outsym
+= bfd_coff_auxesz (output_bfd
);
5921 pos
= obj_sym_filepos (output_bfd
);
5922 pos
+= obj_raw_syment_count (output_bfd
) * bfd_coff_symesz (output_bfd
);
5923 amt
= outsym
- finfo
->outsyms
;
5924 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5925 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
5927 obj_raw_syment_count (output_bfd
) +=
5928 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
5933 /* Handle a link order which is supposed to generate a reloc. */
5936 xcoff_reloc_link_order (output_bfd
, finfo
, output_section
, link_order
)
5938 struct xcoff_final_link_info
*finfo
;
5939 asection
*output_section
;
5940 struct bfd_link_order
*link_order
;
5942 reloc_howto_type
*howto
;
5943 struct xcoff_link_hash_entry
*h
;
5947 struct internal_reloc
*irel
;
5948 struct xcoff_link_hash_entry
**rel_hash_ptr
;
5949 struct internal_ldrel ldrel
;
5951 if (link_order
->type
== bfd_section_reloc_link_order
)
5953 /* We need to somehow locate a symbol in the right section. The
5954 symbol must either have a value of zero, or we must adjust
5955 the addend by the value of the symbol. FIXME: Write this
5956 when we need it. The old linker couldn't handle this anyhow. */
5960 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
5963 bfd_set_error (bfd_error_bad_value
);
5967 h
= ((struct xcoff_link_hash_entry
*)
5968 bfd_wrapped_link_hash_lookup (output_bfd
, finfo
->info
,
5969 link_order
->u
.reloc
.p
->u
.name
,
5970 false, false, true));
5973 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
5974 (finfo
->info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
5975 (asection
*) NULL
, (bfd_vma
) 0)))
5980 if (h
->root
.type
== bfd_link_hash_common
)
5982 hsec
= h
->root
.u
.c
.p
->section
;
5985 else if (h
->root
.type
== bfd_link_hash_defined
5986 || h
->root
.type
== bfd_link_hash_defweak
)
5988 hsec
= h
->root
.u
.def
.section
;
5989 hval
= h
->root
.u
.def
.value
;
5997 addend
= link_order
->u
.reloc
.p
->addend
;
5999 addend
+= (hsec
->output_section
->vma
6000 + hsec
->output_offset
6007 bfd_reloc_status_type rstat
;
6010 size
= bfd_get_reloc_size (howto
);
6011 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6015 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
6021 case bfd_reloc_outofrange
:
6023 case bfd_reloc_overflow
:
6024 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
6025 (finfo
->info
, link_order
->u
.reloc
.p
->u
.name
,
6026 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
6034 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6035 (file_ptr
) link_order
->offset
, size
);
6041 /* Store the reloc information in the right place. It will get
6042 swapped and written out at the end of the final_link routine. */
6044 irel
= (finfo
->section_info
[output_section
->target_index
].relocs
6045 + output_section
->reloc_count
);
6046 rel_hash_ptr
= (finfo
->section_info
[output_section
->target_index
].rel_hashes
6047 + output_section
->reloc_count
);
6049 memset (irel
, 0, sizeof (struct internal_reloc
));
6050 *rel_hash_ptr
= NULL
;
6052 irel
->r_vaddr
= output_section
->vma
+ link_order
->offset
;
6055 irel
->r_symndx
= h
->indx
;
6058 /* Set the index to -2 to force this symbol to get written out. */
6064 irel
->r_type
= howto
->type
;
6065 irel
->r_size
= howto
->bitsize
- 1;
6066 if (howto
->complain_on_overflow
== complain_overflow_signed
)
6067 irel
->r_size
|= 0x80;
6069 ++output_section
->reloc_count
;
6071 /* Now output the reloc to the .loader section. */
6073 ldrel
.l_vaddr
= irel
->r_vaddr
;
6077 const char *secname
;
6079 secname
= hsec
->output_section
->name
;
6081 if (strcmp (secname
, ".text") == 0)
6083 else if (strcmp (secname
, ".data") == 0)
6085 else if (strcmp (secname
, ".bss") == 0)
6089 (*_bfd_error_handler
)
6090 (_("%s: loader reloc in unrecognized section `%s'"),
6091 bfd_get_filename (output_bfd
), secname
);
6092 bfd_set_error (bfd_error_nonrepresentable_section
);
6100 (*_bfd_error_handler
)
6101 (_("%s: `%s' in loader reloc but not loader sym"),
6102 bfd_get_filename (output_bfd
),
6103 h
->root
.root
.string
);
6104 bfd_set_error (bfd_error_bad_value
);
6107 ldrel
.l_symndx
= h
->ldindx
;
6110 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
6111 ldrel
.l_rsecnm
= output_section
->target_index
;
6112 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
6113 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
6118 /* Sort relocs by VMA. This is called via qsort. */
6121 xcoff_sort_relocs (p1
, p2
)
6125 const struct internal_reloc
*r1
= (const struct internal_reloc
*) p1
;
6126 const struct internal_reloc
*r2
= (const struct internal_reloc
*) p2
;
6128 if (r1
->r_vaddr
> r2
->r_vaddr
)
6130 else if (r1
->r_vaddr
< r2
->r_vaddr
)