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_malloc (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
))
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;
516 /* Free a XCOFF link hash table. */
519 _bfd_xcoff_bfd_link_hash_table_free (hash
)
520 struct bfd_link_hash_table
*hash
;
522 struct xcoff_link_hash_table
*ret
= (struct xcoff_link_hash_table
*) hash
;
524 _bfd_stringtab_free (ret
->debug_strtab
);
525 bfd_hash_table_free (&ret
->root
.table
);
529 /* Read internal relocs for an XCOFF csect. This is a wrapper around
530 _bfd_coff_read_internal_relocs which tries to take advantage of any
531 relocs which may have been cached for the enclosing section. */
533 static struct internal_reloc
*
534 xcoff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
535 require_internal
, internal_relocs
)
539 bfd_byte
*external_relocs
;
540 boolean require_internal
;
541 struct internal_reloc
*internal_relocs
;
544 if (coff_section_data (abfd
, sec
) != NULL
545 && coff_section_data (abfd
, sec
)->relocs
== NULL
546 && xcoff_section_data (abfd
, sec
) != NULL
)
550 enclosing
= xcoff_section_data (abfd
, sec
)->enclosing
;
552 if (enclosing
!= NULL
553 && (coff_section_data (abfd
, enclosing
) == NULL
554 || coff_section_data (abfd
, enclosing
)->relocs
== NULL
)
556 && enclosing
->reloc_count
> 0)
558 if (_bfd_coff_read_internal_relocs (abfd
, enclosing
, true,
559 external_relocs
, false,
560 (struct internal_reloc
*) NULL
)
565 if (enclosing
!= NULL
566 && coff_section_data (abfd
, enclosing
) != NULL
567 && coff_section_data (abfd
, enclosing
)->relocs
!= NULL
)
571 off
= ((sec
->rel_filepos
- enclosing
->rel_filepos
)
572 / bfd_coff_relsz (abfd
));
574 if (! require_internal
)
575 return coff_section_data (abfd
, enclosing
)->relocs
+ off
;
576 memcpy (internal_relocs
,
577 coff_section_data (abfd
, enclosing
)->relocs
+ off
,
578 sec
->reloc_count
* sizeof (struct internal_reloc
));
579 return internal_relocs
;
583 return _bfd_coff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
584 require_internal
, internal_relocs
);
587 /* Given an XCOFF BFD, add symbols to the global hash table as
591 _bfd_xcoff_bfd_link_add_symbols (abfd
, info
)
593 struct bfd_link_info
*info
;
596 switch (bfd_get_format (abfd
))
599 return xcoff_link_add_object_symbols (abfd
, info
);
602 /* If the archive has a map, do the usual search. We then need
603 to check the archive for dynamic objects, because they may not
604 appear in the archive map even though they should, perhaps, be
605 included. If the archive has no map, we just consider each object
606 file in turn, since that apparently is what the AIX native linker
608 if (bfd_has_map (abfd
))
610 if (! (_bfd_generic_link_add_archive_symbols
611 (abfd
, info
, xcoff_link_check_archive_element
)))
618 member
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
619 while (member
!= NULL
)
621 if (bfd_check_format (member
, bfd_object
)
622 && (info
->hash
->creator
== member
->xvec
)
623 && (! bfd_has_map (abfd
) || (member
->flags
& DYNAMIC
) != 0))
627 if (! xcoff_link_check_archive_element (member
, info
,
631 member
->archive_pass
= -1;
633 member
= bfd_openr_next_archived_file (abfd
, member
);
640 bfd_set_error (bfd_error_wrong_format
);
645 /* Add symbols from an XCOFF object file. */
648 xcoff_link_add_object_symbols (abfd
, info
)
650 struct bfd_link_info
*info
;
653 if (! _bfd_coff_get_external_symbols (abfd
))
655 if (! xcoff_link_add_symbols (abfd
, info
))
657 if (! info
->keep_memory
)
659 if (! _bfd_coff_free_symbols (abfd
))
665 /* Check a single archive element to see if we need to include it in
666 the link. *PNEEDED is set according to whether this element is
667 needed in the link or not. This is called via
668 _bfd_generic_link_add_archive_symbols. */
671 xcoff_link_check_archive_element (abfd
, info
, pneeded
)
673 struct bfd_link_info
*info
;
677 if (! _bfd_coff_get_external_symbols (abfd
))
680 if (! xcoff_link_check_ar_symbols (abfd
, info
, pneeded
))
685 if (! xcoff_link_add_symbols (abfd
, info
))
689 if (! info
->keep_memory
|| ! *pneeded
)
691 if (! _bfd_coff_free_symbols (abfd
))
698 /* Look through the symbols to see if this object file should be
699 included in the link. */
702 xcoff_link_check_ar_symbols (abfd
, info
, pneeded
)
704 struct bfd_link_info
*info
;
707 bfd_size_type symesz
;
713 if ((abfd
->flags
& DYNAMIC
) != 0
714 && ! info
->static_link
715 && info
->hash
->creator
== abfd
->xvec
)
716 return xcoff_link_check_dynamic_ar_symbols (abfd
, info
, pneeded
);
718 symesz
= bfd_coff_symesz (abfd
);
719 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
720 esym_end
= esym
+ obj_raw_syment_count (abfd
) * symesz
;
721 while (esym
< esym_end
)
723 struct internal_syment sym
;
725 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &sym
);
727 if (sym
.n_sclass
== C_EXT
&& sym
.n_scnum
!= N_UNDEF
)
730 char buf
[SYMNMLEN
+ 1];
731 struct bfd_link_hash_entry
*h
;
733 /* This symbol is externally visible, and is defined by this
736 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
740 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
742 /* We are only interested in symbols that are currently
743 undefined. If a symbol is currently known to be common,
744 XCOFF linkers do not bring in an object file which
745 defines it. We also don't bring in symbols to satisfy
746 undefined references in shared objects. */
747 if (h
!= (struct bfd_link_hash_entry
*) NULL
748 && h
->type
== bfd_link_hash_undefined
749 && (info
->hash
->creator
!= abfd
->xvec
750 || (((struct xcoff_link_hash_entry
*) h
)->flags
751 & XCOFF_DEF_DYNAMIC
) == 0))
753 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
760 esym
+= (sym
.n_numaux
+ 1) * symesz
;
763 /* We do not need this object file. */
767 /* Look through the loader symbols to see if this dynamic object
768 should be included in the link. The native linker uses the loader
769 symbols, not the normal symbol table, so we do too. */
772 xcoff_link_check_dynamic_ar_symbols (abfd
, info
, pneeded
)
774 struct bfd_link_info
*info
;
779 struct internal_ldhdr ldhdr
;
781 bfd_byte
*elsym
, *elsymend
;
785 lsec
= bfd_get_section_by_name (abfd
, ".loader");
788 /* There are no symbols, so don't try to include it. */
792 if (! xcoff_get_section_contents (abfd
, lsec
))
794 contents
= coff_section_data (abfd
, lsec
)->contents
;
796 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
798 strings
= (char *) contents
+ ldhdr
.l_stoff
;
800 elsym
= contents
+ bfd_xcoff_loader_symbol_offset(abfd
, &ldhdr
);
802 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz(abfd
);
803 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz(abfd
))
805 struct internal_ldsym ldsym
;
806 char nambuf
[SYMNMLEN
+ 1];
808 struct bfd_link_hash_entry
*h
;
810 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
812 /* We are only interested in exported symbols. */
813 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
816 if (ldsym
._l
._l_l
._l_zeroes
== 0)
817 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
820 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
821 nambuf
[SYMNMLEN
] = '\0';
825 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
827 /* We are only interested in symbols that are currently
828 undefined. At this point we know that we are using an XCOFF
831 && h
->type
== bfd_link_hash_undefined
832 && (((struct xcoff_link_hash_entry
*) h
)->flags
833 & XCOFF_DEF_DYNAMIC
) == 0)
835 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
842 /* We do not need this shared object. */
844 if (contents
!= NULL
&& ! coff_section_data (abfd
, lsec
)->keep_contents
)
846 free (coff_section_data (abfd
, lsec
)->contents
);
847 coff_section_data (abfd
, lsec
)->contents
= NULL
;
853 /* Returns the index of reloc in RELOCS with the least address greater
854 than or equal to ADDRESS. The relocs are sorted by address. */
857 xcoff_find_reloc (relocs
, count
, address
)
858 struct internal_reloc
*relocs
;
862 bfd_size_type min
, max
, this;
866 if (count
== 1 && relocs
[0].r_vaddr
< address
)
875 /* Do a binary search over (min,max]. */
876 while (min
+ 1 < max
)
880 this = (max
+ min
) / 2;
881 raddr
= relocs
[this].r_vaddr
;
884 else if (raddr
< address
)
893 if (relocs
[min
].r_vaddr
< address
)
897 && relocs
[min
- 1].r_vaddr
== address
)
904 /* xcoff_link_create_extra_sections
906 Takes care of creating the .loader, .gl, .ds, .debug and sections. */
909 xcoff_link_create_extra_sections(bfd
* abfd
, struct bfd_link_info
*info
)
912 boolean return_value
= false;
914 if (info
->hash
->creator
== abfd
->xvec
)
917 /* We need to build a .loader section, so we do it here. This
918 won't work if we're producing an XCOFF output file with no
919 XCOFF input files. FIXME. */
921 if (xcoff_hash_table (info
)->loader_section
== NULL
)
925 lsec
= bfd_make_section_anyway (abfd
, ".loader");
930 xcoff_hash_table (info
)->loader_section
= lsec
;
931 lsec
->flags
|= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
934 /* Likewise for the linkage section. */
935 if (xcoff_hash_table (info
)->linkage_section
== NULL
)
939 lsec
= bfd_make_section_anyway (abfd
, ".gl");
945 xcoff_hash_table (info
)->linkage_section
= lsec
;
946 lsec
->flags
|= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
948 lsec
->alignment_power
= 2;
951 /* Likewise for the TOC section. */
952 if (xcoff_hash_table (info
)->toc_section
== NULL
)
956 tsec
= bfd_make_section_anyway (abfd
, ".tc");
962 xcoff_hash_table (info
)->toc_section
= tsec
;
963 tsec
->flags
|= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
965 tsec
->alignment_power
= 2;
968 /* Likewise for the descriptor section. */
969 if (xcoff_hash_table (info
)->descriptor_section
== NULL
)
973 dsec
= bfd_make_section_anyway (abfd
, ".ds");
979 xcoff_hash_table (info
)->descriptor_section
= dsec
;
980 dsec
->flags
|= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
982 dsec
->alignment_power
= 2;
985 /* Likewise for the .debug section. */
986 if (xcoff_hash_table (info
)->debug_section
== NULL
987 && info
->strip
!= strip_all
)
991 dsec
= bfd_make_section_anyway (abfd
, ".debug");
996 xcoff_hash_table (info
)->debug_section
= dsec
;
997 dsec
->flags
|= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
1001 return_value
= true;
1005 return return_value
;
1008 /* Add all the symbols from an object file to the hash table.
1010 XCOFF is a weird format. A normal XCOFF .o files will have three
1011 COFF sections--.text, .data, and .bss--but each COFF section will
1012 contain many csects. These csects are described in the symbol
1013 table. From the linker's point of view, each csect must be
1014 considered a section in its own right. For example, a TOC entry is
1015 handled as a small XMC_TC csect. The linker must be able to merge
1016 different TOC entries together, which means that it must be able to
1017 extract the XMC_TC csects from the .data section of the input .o
1020 From the point of view of our linker, this is, of course, a hideous
1021 nightmare. We cope by actually creating sections for each csect,
1022 and discarding the original sections. We then have to handle the
1023 relocation entries carefully, since the only way to tell which
1024 csect they belong to is to examine the address. */
1027 xcoff_link_add_symbols (abfd
, info
)
1029 struct bfd_link_info
*info
;
1031 unsigned int n_tmask
;
1032 unsigned int n_btshft
;
1033 boolean default_copy
;
1034 bfd_size_type symcount
;
1035 struct xcoff_link_hash_entry
**sym_hash
;
1036 asection
**csect_cache
;
1037 bfd_size_type linesz
;
1039 asection
*last_real
;
1042 unsigned int csect_index
;
1043 asection
*first_csect
;
1044 bfd_size_type symesz
;
1047 struct reloc_info_struct
1049 struct internal_reloc
*relocs
;
1052 } *reloc_info
= NULL
;
1055 keep_syms
= obj_coff_keep_syms (abfd
);
1057 if ((abfd
->flags
& DYNAMIC
) != 0
1058 && ! info
->static_link
)
1060 if (! xcoff_link_add_dynamic_symbols (abfd
, info
))
1064 /* create the loader, toc, gl, ds and debug sections, if needed */
1065 if (false == xcoff_link_create_extra_sections(abfd
, info
))
1068 if ((abfd
->flags
& DYNAMIC
) != 0
1069 && ! info
->static_link
)
1072 n_tmask
= coff_data (abfd
)->local_n_tmask
;
1073 n_btshft
= coff_data (abfd
)->local_n_btshft
;
1075 /* Define macros so that ISFCN, et. al., macros work correctly. */
1076 #define N_TMASK n_tmask
1077 #define N_BTSHFT n_btshft
1079 if (info
->keep_memory
)
1080 default_copy
= false;
1082 default_copy
= true;
1084 symcount
= obj_raw_syment_count (abfd
);
1086 /* We keep a list of the linker hash table entries that correspond
1087 to each external symbol. */
1088 amt
= symcount
* sizeof (struct xcoff_link_hash_entry
*);
1089 sym_hash
= (struct xcoff_link_hash_entry
**) bfd_alloc (abfd
, amt
);
1090 if (sym_hash
== NULL
&& symcount
!= 0)
1092 coff_data (abfd
)->sym_hashes
= (struct coff_link_hash_entry
**) sym_hash
;
1093 memset (sym_hash
, 0, (size_t) amt
);
1095 /* Because of the weird stuff we are doing with XCOFF csects, we can
1096 not easily determine which section a symbol is in, so we store
1097 the information in the tdata for the input file. */
1098 amt
= symcount
* sizeof (asection
*);
1099 csect_cache
= (asection
**) bfd_alloc (abfd
, amt
);
1100 if (csect_cache
== NULL
&& symcount
!= 0)
1102 xcoff_data (abfd
)->csects
= csect_cache
;
1103 memset (csect_cache
, 0, (size_t) amt
);
1105 /* While splitting sections into csects, we need to assign the
1106 relocs correctly. The relocs and the csects must both be in
1107 order by VMA within a given section, so we handle this by
1108 scanning along the relocs as we process the csects. We index
1109 into reloc_info using the section target_index. */
1110 amt
= abfd
->section_count
+ 1;
1111 amt
*= sizeof (struct reloc_info_struct
);
1112 reloc_info
= (struct reloc_info_struct
*) bfd_malloc (amt
);
1113 if (reloc_info
== NULL
)
1115 memset ((PTR
) reloc_info
, 0, (size_t) amt
);
1117 /* Read in the relocs and line numbers for each section. */
1118 linesz
= bfd_coff_linesz (abfd
);
1120 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1124 if ((o
->flags
& SEC_RELOC
) != 0)
1127 reloc_info
[o
->target_index
].relocs
=
1128 xcoff_read_internal_relocs (abfd
, o
, true, (bfd_byte
*) NULL
,
1129 false, (struct internal_reloc
*) NULL
);
1130 amt
= o
->reloc_count
;
1131 amt
*= sizeof (asection
*);
1132 reloc_info
[o
->target_index
].csects
= (asection
**) bfd_malloc (amt
);
1133 if (reloc_info
[o
->target_index
].csects
== NULL
)
1135 memset (reloc_info
[o
->target_index
].csects
, 0, (size_t) amt
);
1139 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1140 && o
->lineno_count
> 0)
1145 amt
= linesz
* o
->lineno_count
;
1146 linenos
= (bfd_byte
*) bfd_malloc (amt
);
1147 if (linenos
== NULL
)
1149 reloc_info
[o
->target_index
].linenos
= linenos
;
1150 if (bfd_seek (abfd
, o
->line_filepos
, SEEK_SET
) != 0
1151 || bfd_bread (linenos
, amt
, abfd
) != amt
)
1157 /* Don't let the linker relocation routines discard the symbols. */
1158 obj_coff_keep_syms (abfd
) = true;
1164 symesz
= bfd_coff_symesz (abfd
);
1165 BFD_ASSERT (symesz
== bfd_coff_auxesz (abfd
));
1166 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
1167 esym_end
= esym
+ symcount
* symesz
;
1169 while (esym
< esym_end
)
1171 struct internal_syment sym
;
1172 union internal_auxent aux
;
1174 char buf
[SYMNMLEN
+ 1];
1179 struct xcoff_link_hash_entry
*set_toc
;
1181 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &sym
);
1183 /* In this pass we are only interested in symbols with csect
1185 if (sym
.n_sclass
!= C_EXT
&& sym
.n_sclass
!= C_HIDEXT
)
1189 Normally csect is a .pr, .rw etc. created in the loop
1190 If C_FILE or first time, handle special
1192 Advance esym, sym_hash, csect_hash ptr's
1193 Keep track of the last_symndx for the current file. */
1194 if (sym
.n_sclass
== C_FILE
&& csect
!= NULL
)
1196 xcoff_section_data (abfd
, csect
)->last_symndx
=
1198 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1204 *csect_cache
= csect
;
1205 else if (first_csect
== NULL
|| sym
.n_sclass
== C_FILE
)
1206 *csect_cache
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1208 *csect_cache
= NULL
;
1209 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1210 sym_hash
+= sym
.n_numaux
+ 1;
1211 csect_cache
+= sym
.n_numaux
+ 1;
1216 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
1221 /* If this symbol has line number information attached to it,
1222 and we're not stripping it, count the number of entries and
1223 add them to the count for this csect. In the final link pass
1224 we are going to attach line number information by symbol,
1225 rather than by section, in order to more easily handle
1226 garbage collection. */
1227 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1230 && ISFCN (sym
.n_type
))
1233 union internal_auxent auxlin
;
1235 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ symesz
),
1236 sym
.n_type
, sym
.n_sclass
,
1237 0, sym
.n_numaux
, (PTR
) &auxlin
);
1239 if (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
1241 asection
*enclosing
;
1242 bfd_signed_vma linoff
;
1244 enclosing
= xcoff_section_data (abfd
, csect
)->enclosing
;
1245 if (enclosing
== NULL
)
1247 (*_bfd_error_handler
)
1248 (_("%s: `%s' has line numbers but no enclosing section"),
1249 bfd_archive_filename (abfd
), name
);
1250 bfd_set_error (bfd_error_bad_value
);
1253 linoff
= (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
1254 - enclosing
->line_filepos
);
1255 /* explict cast to bfd_signed_vma for compiler */
1256 if (linoff
< (bfd_signed_vma
) (enclosing
->lineno_count
* linesz
))
1258 struct internal_lineno lin
;
1259 bfd_byte
*linpstart
;
1261 linpstart
= (reloc_info
[enclosing
->target_index
].linenos
1263 bfd_coff_swap_lineno_in (abfd
, (PTR
) linpstart
, (PTR
) &lin
);
1265 && ((bfd_size_type
) lin
.l_addr
.l_symndx
1267 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1270 bfd_byte
*linpend
, *linp
;
1272 linpend
= (reloc_info
[enclosing
->target_index
].linenos
1273 + enclosing
->lineno_count
* linesz
);
1274 for (linp
= linpstart
+ linesz
;
1278 bfd_coff_swap_lineno_in (abfd
, (PTR
) linp
,
1280 if (lin
.l_lnno
== 0)
1283 csect
->lineno_count
+= (linp
- linpstart
) / linesz
;
1284 /* The setting of line_filepos will only be
1285 useful if all the line number entries for a
1286 csect are contiguous; this only matters for
1288 if (csect
->line_filepos
== 0)
1289 csect
->line_filepos
=
1290 auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1296 /* Pick up the csect auxiliary information. */
1298 if (sym
.n_numaux
== 0)
1300 (*_bfd_error_handler
)
1301 (_("%s: class %d symbol `%s' has no aux entries"),
1302 bfd_archive_filename (abfd
), sym
.n_sclass
, name
);
1303 bfd_set_error (bfd_error_bad_value
);
1307 bfd_coff_swap_aux_in (abfd
,
1308 (PTR
) (esym
+ symesz
* sym
.n_numaux
),
1309 sym
.n_type
, sym
.n_sclass
,
1310 sym
.n_numaux
- 1, sym
.n_numaux
,
1313 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
1323 (*_bfd_error_handler
)
1324 (_("%s: symbol `%s' has unrecognized csect type %d"),
1325 bfd_archive_filename (abfd
), name
, smtyp
);
1326 bfd_set_error (bfd_error_bad_value
);
1330 /* This is an external reference. */
1331 if (sym
.n_sclass
== C_HIDEXT
1332 || sym
.n_scnum
!= N_UNDEF
1333 || aux
.x_csect
.x_scnlen
.l
!= 0)
1335 (*_bfd_error_handler
)
1336 (_("%s: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d"),
1337 bfd_archive_filename (abfd
), name
, sym
.n_sclass
, sym
.n_scnum
,
1338 aux
.x_csect
.x_scnlen
.l
);
1339 bfd_set_error (bfd_error_bad_value
);
1343 /* An XMC_XO external reference is actually a reference to
1344 an absolute location. */
1345 if (aux
.x_csect
.x_smclas
!= XMC_XO
)
1346 section
= bfd_und_section_ptr
;
1349 section
= bfd_abs_section_ptr
;
1350 value
= sym
.n_value
;
1355 /* This is a csect definition. */
1358 xcoff_section_data (abfd
, csect
)->last_symndx
=
1359 ((esym
- (bfd_byte
*) obj_coff_external_syms (abfd
)) / symesz
);
1363 csect_index
= -(unsigned) 1;
1365 /* When we see a TOC anchor, we record the TOC value. */
1366 if (aux
.x_csect
.x_smclas
== XMC_TC0
)
1368 if (sym
.n_sclass
!= C_HIDEXT
1369 || aux
.x_csect
.x_scnlen
.l
!= 0)
1371 (*_bfd_error_handler
)
1372 (_("%s: XMC_TC0 symbol `%s' is class %d scnlen %d"),
1373 bfd_archive_filename (abfd
), name
, sym
.n_sclass
,
1374 aux
.x_csect
.x_scnlen
.l
);
1375 bfd_set_error (bfd_error_bad_value
);
1378 xcoff_data (abfd
)->toc
= sym
.n_value
;
1381 /* We must merge TOC entries for the same symbol. We can
1382 merge two TOC entries if they are both C_HIDEXT, they
1383 both have the same name, they are both 4 or 8 bytes long, and
1384 they both have a relocation table entry for an external
1385 symbol with the same name. Unfortunately, this means
1386 that we must look through the relocations. Ick.
1388 Logic for 32 bit vs 64 bit.
1389 32 bit has a csect length of 4 for TOC
1390 64 bit has a csect length of 8 for TOC
1392 The conditions to get past the if-check are not that bad.
1393 They are what is used to create the TOC csects in the first
1395 if (aux
.x_csect
.x_smclas
== XMC_TC
1396 && sym
.n_sclass
== C_HIDEXT
1397 && info
->hash
->creator
== abfd
->xvec
1398 && ((bfd_xcoff_is_xcoff32 (abfd
)
1399 && aux
.x_csect
.x_scnlen
.l
== 4)
1400 || (bfd_xcoff_is_xcoff64 (abfd
)
1401 && aux
.x_csect
.x_scnlen
.l
== 8)))
1403 asection
*enclosing
;
1404 struct internal_reloc
*relocs
;
1405 bfd_size_type relindx
;
1406 struct internal_reloc
*rel
;
1408 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1409 if (enclosing
== NULL
)
1412 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1413 amt
= enclosing
->reloc_count
;
1414 relindx
= xcoff_find_reloc (relocs
, amt
, sym
.n_value
);
1415 rel
= relocs
+ relindx
;
1417 /* 32 bit R_POS r_size is 31
1418 64 bit R_POS r_size is 63 */
1419 if (relindx
< enclosing
->reloc_count
1420 && rel
->r_vaddr
== (bfd_vma
) sym
.n_value
1421 && rel
->r_type
== R_POS
1422 && ((bfd_xcoff_is_xcoff32 (abfd
)
1423 && rel
->r_size
== 31)
1424 || (bfd_xcoff_is_xcoff64 (abfd
)
1425 && rel
->r_size
== 63)))
1429 struct internal_syment relsym
;
1431 erelsym
= ((bfd_byte
*) obj_coff_external_syms (abfd
)
1432 + rel
->r_symndx
* symesz
);
1433 bfd_coff_swap_sym_in (abfd
, (PTR
) erelsym
, (PTR
) &relsym
);
1434 if (relsym
.n_sclass
== C_EXT
)
1436 const char *relname
;
1437 char relbuf
[SYMNMLEN
+ 1];
1439 struct xcoff_link_hash_entry
*h
;
1441 /* At this point we know that the TOC entry is
1442 for an externally visible symbol. */
1444 relname
= _bfd_coff_internal_syment_name (abfd
, &relsym
,
1446 if (relname
== NULL
)
1449 /* We only merge TOC entries if the TC name is
1450 the same as the symbol name. This handles
1451 the normal case, but not common cases like
1452 SYM.P4 which gcc generates to store SYM + 4
1453 in the TOC. FIXME. */
1455 if (strcmp (name
, relname
) == 0)
1457 copy
= (! info
->keep_memory
1458 || relsym
._n
._n_n
._n_zeroes
!= 0
1459 || relsym
._n
._n_n
._n_offset
== 0);
1460 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1461 relname
, true, copy
,
1466 /* At this point h->root.type could be
1467 bfd_link_hash_new. That should be OK,
1468 since we know for sure that we will come
1469 across this symbol as we step through the
1472 /* We store h in *sym_hash for the
1473 convenience of the relocate_section
1477 if (h
->toc_section
!= NULL
)
1479 asection
**rel_csects
;
1481 /* We already have a TOC entry for this
1482 symbol, so we can just ignore this
1485 reloc_info
[enclosing
->target_index
].csects
;
1486 rel_csects
[relindx
] = bfd_und_section_ptr
;
1490 /* We are about to create a TOC entry for
1493 } /* merge toc reloc */
1500 asection
*enclosing
;
1502 /* We need to create a new section. We get the name from
1503 the csect storage mapping class, so that the linker can
1504 accumulate similar csects together. */
1506 csect
= bfd_xcoff_create_csect_from_smclas(abfd
, &aux
, name
);
1512 /* The enclosing section is the main section : .data, .text
1513 or .bss that the csect is coming from. */
1514 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1515 if (enclosing
== NULL
)
1518 if (! bfd_is_abs_section (enclosing
)
1519 && ((bfd_vma
) sym
.n_value
< enclosing
->vma
1520 || ((bfd_vma
) sym
.n_value
+ aux
.x_csect
.x_scnlen
.l
1521 > enclosing
->vma
+ enclosing
->_raw_size
)))
1523 (*_bfd_error_handler
)
1524 (_("%s: csect `%s' not in enclosing section"),
1525 bfd_archive_filename (abfd
), name
);
1526 bfd_set_error (bfd_error_bad_value
);
1529 csect
->vma
= sym
.n_value
;
1530 csect
->filepos
= (enclosing
->filepos
1533 csect
->_raw_size
= aux
.x_csect
.x_scnlen
.l
;
1534 csect
->flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
;
1535 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1537 /* Record the enclosing section in the tdata for this new
1539 amt
= sizeof (struct coff_section_tdata
);
1540 csect
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
1541 if (csect
->used_by_bfd
== NULL
)
1543 amt
= sizeof (struct xcoff_section_tdata
);
1544 coff_section_data (abfd
, csect
)->tdata
= bfd_zalloc (abfd
, amt
);
1545 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1547 xcoff_section_data (abfd
, csect
)->enclosing
= enclosing
;
1548 xcoff_section_data (abfd
, csect
)->lineno_count
=
1549 enclosing
->lineno_count
;
1551 if (enclosing
->owner
== abfd
)
1553 struct internal_reloc
*relocs
;
1554 bfd_size_type relindx
;
1555 struct internal_reloc
*rel
;
1556 asection
**rel_csect
;
1558 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1559 amt
= enclosing
->reloc_count
;
1560 relindx
= xcoff_find_reloc (relocs
, amt
, csect
->vma
);
1562 rel
= relocs
+ relindx
;
1563 rel_csect
= (reloc_info
[enclosing
->target_index
].csects
1566 csect
->rel_filepos
= (enclosing
->rel_filepos
1567 + relindx
* bfd_coff_relsz (abfd
));
1568 while (relindx
< enclosing
->reloc_count
1569 && *rel_csect
== NULL
1570 && rel
->r_vaddr
< csect
->vma
+ csect
->_raw_size
)
1574 csect
->flags
|= SEC_RELOC
;
1575 ++csect
->reloc_count
;
1582 /* There are a number of other fields and section flags
1583 which we do not bother to set. */
1585 csect_index
= ((esym
1586 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1589 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1591 if (first_csect
== NULL
)
1592 first_csect
= csect
;
1594 /* If this symbol is C_EXT, we treat it as starting at the
1595 beginning of the newly created section. */
1596 if (sym
.n_sclass
== C_EXT
)
1602 /* If this is a TOC section for a symbol, record it. */
1603 if (set_toc
!= NULL
)
1604 set_toc
->toc_section
= csect
;
1609 /* This is a label definition. The x_scnlen field is the
1610 symbol index of the csect. Usually the XTY_LD symbol will
1611 follow its appropriate XTY_SD symbol. The .set pseudo op can
1612 cause the XTY_LD to not follow the XTY_SD symbol. */
1617 if (aux
.x_csect
.x_scnlen
.l
< 0
1618 || (aux
.x_csect
.x_scnlen
.l
1619 >= esym
- (bfd_byte
*) obj_coff_external_syms (abfd
)))
1623 section
= xcoff_data (abfd
)->csects
[aux
.x_csect
.x_scnlen
.l
];
1625 || (section
->flags
& SEC_HAS_CONTENTS
) == 0)
1630 (*_bfd_error_handler
)
1631 (_("%s: misplaced XTY_LD `%s'"),
1632 bfd_archive_filename (abfd
), name
);
1633 bfd_set_error (bfd_error_bad_value
);
1637 value
= sym
.n_value
- csect
->vma
;
1642 /* This is an unitialized csect. We could base the name on
1643 the storage mapping class, but we don't bother except for
1644 an XMC_TD symbol. If this csect is externally visible,
1645 it is a common symbol. We put XMC_TD symbols in sections
1646 named .tocbss, and rely on the linker script to put that
1651 xcoff_section_data (abfd
, csect
)->last_symndx
=
1653 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1657 if (aux
.x_csect
.x_smclas
== XMC_TD
)
1659 /* The linker script puts the .td section in the data
1660 section after the .tc section. */
1661 csect
= bfd_make_section_anyway (abfd
, ".td");
1666 csect
= bfd_make_section_anyway (abfd
, ".bss");
1670 csect
->vma
= sym
.n_value
;
1671 csect
->_raw_size
= aux
.x_csect
.x_scnlen
.l
;
1672 csect
->flags
|= SEC_ALLOC
;
1673 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1674 /* There are a number of other fields and section flags
1675 which we do not bother to set. */
1677 csect_index
= ((esym
1678 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1681 amt
= sizeof (struct coff_section_tdata
);
1682 csect
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
1683 if (csect
->used_by_bfd
== NULL
)
1685 amt
= sizeof (struct xcoff_section_tdata
);
1686 coff_section_data (abfd
, csect
)->tdata
= bfd_zalloc (abfd
, amt
);
1687 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1689 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1691 if (first_csect
== NULL
)
1692 first_csect
= csect
;
1694 if (sym
.n_sclass
== C_EXT
)
1696 csect
->flags
|= SEC_IS_COMMON
;
1697 csect
->_raw_size
= 0;
1699 value
= aux
.x_csect
.x_scnlen
.l
;
1705 /* Check for magic symbol names. */
1706 if ((smtyp
== XTY_SD
|| smtyp
== XTY_CM
)
1707 && aux
.x_csect
.x_smclas
!= XMC_TC
1708 && aux
.x_csect
.x_smclas
!= XMC_TD
)
1715 if (strcmp (name
, "_text") == 0)
1716 i
= XCOFF_SPECIAL_SECTION_TEXT
;
1717 else if (strcmp (name
, "_etext") == 0)
1718 i
= XCOFF_SPECIAL_SECTION_ETEXT
;
1719 else if (strcmp (name
, "_data") == 0)
1720 i
= XCOFF_SPECIAL_SECTION_DATA
;
1721 else if (strcmp (name
, "_edata") == 0)
1722 i
= XCOFF_SPECIAL_SECTION_EDATA
;
1723 else if (strcmp (name
, "_end") == 0)
1724 i
= XCOFF_SPECIAL_SECTION_END
;
1726 else if (name
[0] == 'e' && strcmp (name
, "end") == 0)
1728 i
= XCOFF_SPECIAL_SECTION_END2
;
1733 xcoff_hash_table (info
)->special_sections
[i
] = csect
;
1737 /* Now we have enough information to add the symbol to the
1738 linker hash table. */
1740 if (sym
.n_sclass
== C_EXT
)
1744 BFD_ASSERT (section
!= NULL
);
1746 /* We must copy the name into memory if we got it from the
1747 syment itself, rather than the string table. */
1748 copy
= default_copy
;
1749 if (sym
._n
._n_n
._n_zeroes
!= 0
1750 || sym
._n
._n_n
._n_offset
== 0)
1753 /* The AIX linker appears to only detect multiple symbol
1754 definitions when there is a reference to the symbol. If
1755 a symbol is defined multiple times, and the only
1756 references are from the same object file, the AIX linker
1757 appears to permit it. It does not merge the different
1758 definitions, but handles them independently. On the
1759 other hand, if there is a reference, the linker reports
1762 This matters because the AIX <net/net_globals.h> header
1763 file actually defines an initialized array, so we have to
1764 actually permit that to work.
1766 Just to make matters even more confusing, the AIX linker
1767 appears to permit multiple symbol definitions whenever
1768 the second definition is in an archive rather than an
1769 object file. This may be a consequence of the manner in
1770 which it handles archives: I think it may load the entire
1771 archive in as separate csects, and then let garbage
1772 collection discard symbols.
1774 We also have to handle the case of statically linking a
1775 shared object, which will cause symbol redefinitions,
1776 although this is an easier case to detect. */
1778 if (info
->hash
->creator
== abfd
->xvec
)
1780 if (! bfd_is_und_section (section
))
1781 *sym_hash
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1782 name
, true, copy
, false);
1784 *sym_hash
= ((struct xcoff_link_hash_entry
*)
1785 bfd_wrapped_link_hash_lookup (abfd
, info
, name
,
1786 true, copy
, false));
1787 if (*sym_hash
== NULL
)
1789 if (((*sym_hash
)->root
.type
== bfd_link_hash_defined
1790 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
1791 && ! bfd_is_und_section (section
)
1792 && ! bfd_is_com_section (section
))
1794 /* This is a second definition of a defined symbol. */
1795 if ((abfd
->flags
& DYNAMIC
) != 0
1796 && ((*sym_hash
)->smclas
!= XMC_GL
1797 || aux
.x_csect
.x_smclas
== XMC_GL
1798 || ((*sym_hash
)->root
.u
.def
.section
->owner
->flags
1801 /* The new symbol is from a shared library, and
1802 either the existing symbol is not global
1803 linkage code or this symbol is global linkage
1804 code. If the existing symbol is global
1805 linkage code and the new symbol is not, then
1806 we want to use the new symbol. */
1807 section
= bfd_und_section_ptr
;
1810 else if (((*sym_hash
)->root
.u
.def
.section
->owner
->flags
1813 /* The existing symbol is from a shared library.
1815 (*sym_hash
)->root
.type
= bfd_link_hash_undefined
;
1816 (*sym_hash
)->root
.u
.undef
.abfd
=
1817 (*sym_hash
)->root
.u
.def
.section
->owner
;
1819 else if (abfd
->my_archive
!= NULL
)
1821 /* This is a redefinition in an object contained
1822 in an archive. Just ignore it. See the
1824 section
= bfd_und_section_ptr
;
1827 else if ((*sym_hash
)->root
.next
!= NULL
1828 || info
->hash
->undefs_tail
== &(*sym_hash
)->root
)
1830 /* This symbol has been referenced. In this
1831 case, we just continue and permit the
1832 multiple definition error. See the comment
1833 above about the behaviour of the AIX linker. */
1835 else if ((*sym_hash
)->smclas
== aux
.x_csect
.x_smclas
)
1837 /* The symbols are both csects of the same
1838 class. There is at least a chance that this
1839 is a semi-legitimate redefinition. */
1840 section
= bfd_und_section_ptr
;
1842 (*sym_hash
)->flags
|= XCOFF_MULTIPLY_DEFINED
;
1845 else if (((*sym_hash
)->flags
& XCOFF_MULTIPLY_DEFINED
) != 0
1846 && ((*sym_hash
)->root
.type
== bfd_link_hash_defined
1847 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
1848 && (bfd_is_und_section (section
)
1849 || bfd_is_com_section (section
)))
1851 /* This is a reference to a multiply defined symbol.
1852 Report the error now. See the comment above
1853 about the behaviour of the AIX linker. We could
1854 also do this with warning symbols, but I'm not
1855 sure the XCOFF linker is wholly prepared to
1856 handle them, and that would only be a warning,
1858 if (! ((*info
->callbacks
->multiple_definition
)
1859 (info
, (*sym_hash
)->root
.root
.string
,
1860 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0,
1861 (*sym_hash
)->root
.u
.def
.section
->owner
,
1862 (*sym_hash
)->root
.u
.def
.section
,
1863 (*sym_hash
)->root
.u
.def
.value
)))
1865 /* Try not to give this error too many times. */
1866 (*sym_hash
)->flags
&= ~XCOFF_MULTIPLY_DEFINED
;
1870 /* _bfd_generic_link_add_one_symbol may call the linker to
1871 generate an error message, and the linker may try to read
1872 the symbol table to give a good error. Right now, the
1873 line numbers are in an inconsistent state, since they are
1874 counted both in the real sections and in the new csects.
1875 We need to leave the count in the real sections so that
1876 the linker can report the line number of the error
1877 correctly, so temporarily clobber the link to the csects
1878 so that the linker will not try to read the line numbers
1879 a second time from the csects. */
1880 BFD_ASSERT (last_real
->next
== first_csect
);
1881 last_real
->next
= NULL
;
1882 if (! (_bfd_generic_link_add_one_symbol
1883 (info
, abfd
, name
, flags
, section
, value
,
1884 (const char *) NULL
, copy
, true,
1885 (struct bfd_link_hash_entry
**) sym_hash
)))
1887 last_real
->next
= first_csect
;
1889 if (smtyp
== XTY_CM
)
1891 if ((*sym_hash
)->root
.type
!= bfd_link_hash_common
1892 || (*sym_hash
)->root
.u
.c
.p
->section
!= csect
)
1894 /* We don't need the common csect we just created. */
1895 csect
->_raw_size
= 0;
1899 (*sym_hash
)->root
.u
.c
.p
->alignment_power
1900 = csect
->alignment_power
;
1904 if (info
->hash
->creator
== abfd
->xvec
)
1908 if (smtyp
== XTY_ER
|| smtyp
== XTY_CM
)
1909 flag
= XCOFF_REF_REGULAR
;
1911 flag
= XCOFF_DEF_REGULAR
;
1912 (*sym_hash
)->flags
|= flag
;
1914 if ((*sym_hash
)->smclas
== XMC_UA
1915 || flag
== XCOFF_DEF_REGULAR
)
1916 (*sym_hash
)->smclas
= aux
.x_csect
.x_smclas
;
1920 *csect_cache
= csect
;
1922 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1923 sym_hash
+= sym
.n_numaux
+ 1;
1924 csect_cache
+= sym
.n_numaux
+ 1;
1927 BFD_ASSERT (last_real
== NULL
|| last_real
->next
== first_csect
);
1929 /* Make sure that we have seen all the relocs. */
1930 for (o
= abfd
->sections
; o
!= first_csect
; o
= o
->next
)
1932 /* Reset the section size and the line number count, since the
1933 data is now attached to the csects. Don't reset the size of
1934 the .debug section, since we need to read it below in
1935 bfd_xcoff_size_dynamic_sections. */
1936 if (strcmp (bfd_get_section_name (abfd
, o
), ".debug") != 0)
1938 o
->lineno_count
= 0;
1940 if ((o
->flags
& SEC_RELOC
) != 0)
1943 struct internal_reloc
*rel
;
1944 asection
**rel_csect
;
1946 rel
= reloc_info
[o
->target_index
].relocs
;
1947 rel_csect
= reloc_info
[o
->target_index
].csects
;
1949 for (i
= 0; i
< o
->reloc_count
; i
++, rel
++, rel_csect
++)
1952 if (*rel_csect
== NULL
)
1954 (*_bfd_error_handler
)
1955 (_("%s: reloc %s:%d not in csect"),
1956 bfd_archive_filename (abfd
), o
->name
, i
);
1957 bfd_set_error (bfd_error_bad_value
);
1961 /* We identify all symbols which are called, so that we
1962 can create glue code for calls to functions imported
1963 from dynamic objects. */
1964 if (info
->hash
->creator
== abfd
->xvec
1965 && *rel_csect
!= bfd_und_section_ptr
1966 && (rel
->r_type
== R_BR
1967 || rel
->r_type
== R_RBR
)
1968 && obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
] != NULL
)
1970 struct xcoff_link_hash_entry
*h
;
1972 h
= obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
];
1973 h
->flags
|= XCOFF_CALLED
;
1974 /* If the symbol name starts with a period, it is
1975 the code of a function. If the symbol is
1976 currently undefined, then add an undefined symbol
1977 for the function descriptor. This should do no
1978 harm, because any regular object that defines the
1979 function should also define the function
1980 descriptor. It helps, because it means that we
1981 will identify the function descriptor with a
1982 dynamic object if a dynamic object defines it. */
1983 if (h
->root
.root
.string
[0] == '.'
1984 && h
->descriptor
== NULL
)
1986 struct xcoff_link_hash_entry
*hds
;
1988 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1989 h
->root
.root
.string
+ 1,
1993 if (hds
->root
.type
== bfd_link_hash_new
)
1995 if (! (_bfd_generic_link_add_one_symbol
1996 (info
, abfd
, hds
->root
.root
.string
,
1997 (flagword
) 0, bfd_und_section_ptr
,
1998 (bfd_vma
) 0, (const char *) NULL
, false,
2000 (struct bfd_link_hash_entry
**) &hds
)))
2003 hds
->flags
|= XCOFF_DESCRIPTOR
;
2004 BFD_ASSERT ((hds
->flags
& XCOFF_CALLED
) == 0
2005 && (h
->flags
& XCOFF_DESCRIPTOR
) == 0);
2006 hds
->descriptor
= h
;
2007 h
->descriptor
= hds
;
2012 free (reloc_info
[o
->target_index
].csects
);
2013 reloc_info
[o
->target_index
].csects
= NULL
;
2015 /* Reset SEC_RELOC and the reloc_count, since the reloc
2016 information is now attached to the csects. */
2017 o
->flags
&=~ SEC_RELOC
;
2020 /* If we are not keeping memory, free the reloc information. */
2021 if (! info
->keep_memory
2022 && coff_section_data (abfd
, o
) != NULL
2023 && coff_section_data (abfd
, o
)->relocs
!= NULL
2024 && ! coff_section_data (abfd
, o
)->keep_relocs
)
2026 free (coff_section_data (abfd
, o
)->relocs
);
2027 coff_section_data (abfd
, o
)->relocs
= NULL
;
2031 /* Free up the line numbers. FIXME: We could cache these
2032 somewhere for the final link, to avoid reading them again. */
2033 if (reloc_info
[o
->target_index
].linenos
!= NULL
)
2035 free (reloc_info
[o
->target_index
].linenos
);
2036 reloc_info
[o
->target_index
].linenos
= NULL
;
2042 obj_coff_keep_syms (abfd
) = keep_syms
;
2047 if (reloc_info
!= NULL
)
2049 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2051 if (reloc_info
[o
->target_index
].csects
!= NULL
)
2052 free (reloc_info
[o
->target_index
].csects
);
2053 if (reloc_info
[o
->target_index
].linenos
!= NULL
)
2054 free (reloc_info
[o
->target_index
].linenos
);
2058 obj_coff_keep_syms (abfd
) = keep_syms
;
2065 /* This function is used to add symbols from a dynamic object to the
2066 global symbol table. */
2069 xcoff_link_add_dynamic_symbols (abfd
, info
)
2071 struct bfd_link_info
*info
;
2075 struct internal_ldhdr ldhdr
;
2076 const char *strings
;
2077 bfd_byte
*elsym
, *elsymend
;
2078 struct xcoff_import_file
*n
;
2083 struct xcoff_import_file
**pp
;
2085 /* We can only handle a dynamic object if we are generating an XCOFF
2087 if (info
->hash
->creator
!= abfd
->xvec
)
2089 (*_bfd_error_handler
)
2090 (_("%s: XCOFF shared object when not producing XCOFF output"),
2091 bfd_get_filename (abfd
));
2092 bfd_set_error (bfd_error_invalid_operation
);
2096 /* The symbols we use from a dynamic object are not the symbols in
2097 the normal symbol table, but, rather, the symbols in the export
2098 table. If there is a global symbol in a dynamic object which is
2099 not in the export table, the loader will not be able to find it,
2100 so we don't want to find it either. Also, on AIX 4.1.3, shr.o in
2101 libc.a has symbols in the export table which are not in the
2104 /* Read in the .loader section. FIXME: We should really use the
2105 o_snloader field in the a.out header, rather than grabbing the
2107 lsec
= bfd_get_section_by_name (abfd
, ".loader");
2110 (*_bfd_error_handler
)
2111 (_("%s: dynamic object with no .loader section"),
2112 bfd_get_filename (abfd
));
2113 bfd_set_error (bfd_error_no_symbols
);
2118 if (! xcoff_get_section_contents (abfd
, lsec
))
2120 contents
= coff_section_data (abfd
, lsec
)->contents
;
2122 /* Remove the sections from this object, so that they do not get
2123 included in the link. */
2124 abfd
->sections
= NULL
;
2126 bfd_xcoff_swap_ldhdr_in (abfd
, contents
, &ldhdr
);
2128 strings
= (char *) contents
+ ldhdr
.l_stoff
;
2130 elsym
= contents
+ bfd_xcoff_loader_symbol_offset(abfd
, &ldhdr
);
2132 elsymend
= elsym
+ ldhdr
.l_nsyms
* bfd_xcoff_ldsymsz(abfd
);
2134 for (; elsym
< elsymend
; elsym
+= bfd_xcoff_ldsymsz(abfd
))
2136 struct internal_ldsym ldsym
;
2137 char nambuf
[SYMNMLEN
+ 1];
2139 struct xcoff_link_hash_entry
*h
;
2141 bfd_xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
2143 /* We are only interested in exported symbols. */
2144 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
2147 if (ldsym
._l
._l_l
._l_zeroes
== 0)
2148 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
2151 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
2152 nambuf
[SYMNMLEN
] = '\0';
2156 /* Normally we could not call xcoff_link_hash_lookup in an add
2157 symbols routine, since we might not be using an XCOFF hash
2158 table. However, we verified above that we are using an XCOFF
2161 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, true,
2166 h
->flags
|= XCOFF_DEF_DYNAMIC
;
2168 /* If the symbol is undefined, and the BFD it was found in is
2169 not a dynamic object, change the BFD to this dynamic object,
2170 so that we can get the correct import file ID. */
2171 if ((h
->root
.type
== bfd_link_hash_undefined
2172 || h
->root
.type
== bfd_link_hash_undefweak
)
2173 && (h
->root
.u
.undef
.abfd
== NULL
2174 || (h
->root
.u
.undef
.abfd
->flags
& DYNAMIC
) == 0))
2175 h
->root
.u
.undef
.abfd
= abfd
;
2177 if (h
->root
.type
== bfd_link_hash_new
)
2179 h
->root
.type
= bfd_link_hash_undefined
;
2180 h
->root
.u
.undef
.abfd
= abfd
;
2181 /* We do not want to add this to the undefined symbol list. */
2184 if (h
->smclas
== XMC_UA
2185 || h
->root
.type
== bfd_link_hash_undefined
2186 || h
->root
.type
== bfd_link_hash_undefweak
)
2187 h
->smclas
= ldsym
.l_smclas
;
2189 /* Unless this is an XMC_XO symbol, we don't bother to actually
2190 define it, since we don't have a section to put it in anyhow.
2191 Instead, the relocation routines handle the DEF_DYNAMIC flag
2194 if (h
->smclas
== XMC_XO
2195 && (h
->root
.type
== bfd_link_hash_undefined
2196 || h
->root
.type
== bfd_link_hash_undefweak
))
2198 /* This symbol has an absolute value. */
2199 h
->root
.type
= bfd_link_hash_defined
;
2200 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2201 h
->root
.u
.def
.value
= ldsym
.l_value
;
2204 /* If this symbol defines a function descriptor, then it
2205 implicitly defines the function code as well. */
2206 if (h
->smclas
== XMC_DS
2207 || (h
->smclas
== XMC_XO
&& name
[0] != '.'))
2208 h
->flags
|= XCOFF_DESCRIPTOR
;
2209 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
2211 struct xcoff_link_hash_entry
*hds
;
2213 hds
= h
->descriptor
;
2218 dsnm
= bfd_malloc ((bfd_size_type
) strlen (name
) + 2);
2222 strcpy (dsnm
+ 1, name
);
2223 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
), dsnm
,
2229 if (hds
->root
.type
== bfd_link_hash_new
)
2231 hds
->root
.type
= bfd_link_hash_undefined
;
2232 hds
->root
.u
.undef
.abfd
= abfd
;
2233 /* We do not want to add this to the undefined
2237 hds
->descriptor
= h
;
2238 h
->descriptor
= hds
;
2241 hds
->flags
|= XCOFF_DEF_DYNAMIC
;
2242 if (hds
->smclas
== XMC_UA
)
2243 hds
->smclas
= XMC_PR
;
2245 /* An absolute symbol appears to actually define code, not a
2246 function descriptor. This is how some math functions are
2247 implemented on AIX 4.1. */
2248 if (h
->smclas
== XMC_XO
2249 && (hds
->root
.type
== bfd_link_hash_undefined
2250 || hds
->root
.type
== bfd_link_hash_undefweak
))
2252 hds
->smclas
= XMC_XO
;
2253 hds
->root
.type
= bfd_link_hash_defined
;
2254 hds
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2255 hds
->root
.u
.def
.value
= ldsym
.l_value
;
2260 if (contents
!= NULL
&& ! coff_section_data (abfd
, lsec
)->keep_contents
)
2262 free (coff_section_data (abfd
, lsec
)->contents
);
2263 coff_section_data (abfd
, lsec
)->contents
= NULL
;
2266 /* Record this file in the import files. */
2268 n
= ((struct xcoff_import_file
*)
2269 bfd_alloc (abfd
, (bfd_size_type
) sizeof (struct xcoff_import_file
)));
2274 /* For some reason, the path entry in the import file list for a
2275 shared object appears to always be empty. The file name is the
2278 if (abfd
->my_archive
== NULL
)
2280 bname
= bfd_get_filename (abfd
);
2285 bname
= bfd_get_filename (abfd
->my_archive
);
2286 mname
= bfd_get_filename (abfd
);
2288 s
= strrchr (bname
, '/');
2294 /* We start c at 1 because the first import file number is reserved
2296 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
2298 pp
= &(*pp
)->next
, ++c
)
2302 xcoff_data (abfd
)->import_file_id
= c
;
2307 /* Routines that are called after all the input files have been
2308 handled, but before the sections are laid out in memory. */
2310 /* Mark a symbol as not being garbage, including the section in which
2313 static INLINE boolean
2314 xcoff_mark_symbol (info
, h
)
2315 struct bfd_link_info
*info
;
2316 struct xcoff_link_hash_entry
*h
;
2319 if ((h
->flags
& XCOFF_MARK
) != 0)
2322 h
->flags
|= XCOFF_MARK
;
2323 if (h
->root
.type
== bfd_link_hash_defined
2324 || h
->root
.type
== bfd_link_hash_defweak
)
2328 hsec
= h
->root
.u
.def
.section
;
2329 if (! bfd_is_abs_section (hsec
)
2330 && (hsec
->flags
& SEC_MARK
) == 0)
2332 if (! xcoff_mark (info
, hsec
))
2337 if (h
->toc_section
!= NULL
2338 && (h
->toc_section
->flags
& SEC_MARK
) == 0)
2340 if (! xcoff_mark (info
, h
->toc_section
))
2347 /* The mark phase of garbage collection. For a given section, mark
2348 it, and all the sections which define symbols to which it refers.
2349 Because this function needs to look at the relocs, we also count
2350 the number of relocs which need to be copied into the .loader
2354 xcoff_mark (info
, sec
)
2355 struct bfd_link_info
*info
;
2358 if (bfd_is_abs_section (sec
)
2359 || (sec
->flags
& SEC_MARK
) != 0)
2362 sec
->flags
|= SEC_MARK
;
2364 if (sec
->owner
->xvec
== info
->hash
->creator
2365 && coff_section_data (sec
->owner
, sec
) != NULL
2366 && xcoff_section_data (sec
->owner
, sec
) != NULL
)
2368 register struct xcoff_link_hash_entry
**hp
, **hpend
;
2369 struct internal_reloc
*rel
, *relend
;
2371 /* Mark all the symbols in this section. */
2373 hp
= (obj_xcoff_sym_hashes (sec
->owner
)
2374 + xcoff_section_data (sec
->owner
, sec
)->first_symndx
);
2375 hpend
= (obj_xcoff_sym_hashes (sec
->owner
)
2376 + xcoff_section_data (sec
->owner
, sec
)->last_symndx
);
2377 for (; hp
< hpend
; hp
++)
2379 register struct xcoff_link_hash_entry
*h
;
2383 && (h
->flags
& XCOFF_MARK
) == 0)
2385 if (! xcoff_mark_symbol (info
, h
))
2390 /* Look through the section relocs. */
2392 if ((sec
->flags
& SEC_RELOC
) != 0
2393 && sec
->reloc_count
> 0)
2395 rel
= xcoff_read_internal_relocs (sec
->owner
, sec
, true,
2396 (bfd_byte
*) NULL
, false,
2397 (struct internal_reloc
*) NULL
);
2400 relend
= rel
+ sec
->reloc_count
;
2401 for (; rel
< relend
; rel
++)
2404 struct xcoff_link_hash_entry
*h
;
2406 if ((unsigned int) rel
->r_symndx
2407 > obj_raw_syment_count (sec
->owner
))
2410 h
= obj_xcoff_sym_hashes (sec
->owner
)[rel
->r_symndx
];
2412 && (h
->flags
& XCOFF_MARK
) == 0)
2414 if (! xcoff_mark_symbol (info
, h
))
2418 rsec
= xcoff_data (sec
->owner
)->csects
[rel
->r_symndx
];
2420 && (rsec
->flags
& SEC_MARK
) == 0)
2422 if (! xcoff_mark (info
, rsec
))
2426 /* See if this reloc needs to be copied into the .loader
2428 switch (rel
->r_type
)
2432 || h
->root
.type
== bfd_link_hash_defined
2433 || h
->root
.type
== bfd_link_hash_defweak
2434 || h
->root
.type
== bfd_link_hash_common
2435 || ((h
->flags
& XCOFF_CALLED
) != 0
2436 && (h
->root
.type
== bfd_link_hash_undefined
2437 || h
->root
.type
== bfd_link_hash_undefweak
)
2438 && h
->root
.root
.string
[0] == '.'
2439 && h
->descriptor
!= NULL
2440 && ((h
->descriptor
->flags
& XCOFF_DEF_DYNAMIC
) != 0
2441 || ((h
->descriptor
->flags
& XCOFF_IMPORT
) != 0
2442 && (h
->descriptor
->flags
2443 & XCOFF_DEF_REGULAR
) == 0))))
2450 ++xcoff_hash_table (info
)->ldrel_count
;
2452 h
->flags
|= XCOFF_LDREL
;
2459 /* We should never need a .loader reloc for a TOC
2465 if (! info
->keep_memory
2466 && coff_section_data (sec
->owner
, sec
) != NULL
2467 && coff_section_data (sec
->owner
, sec
)->relocs
!= NULL
2468 && ! coff_section_data (sec
->owner
, sec
)->keep_relocs
)
2470 free (coff_section_data (sec
->owner
, sec
)->relocs
);
2471 coff_section_data (sec
->owner
, sec
)->relocs
= NULL
;
2479 /* The sweep phase of garbage collection. Remove all garbage
2484 struct bfd_link_info
*info
;
2488 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
2492 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
2494 if ((o
->flags
& SEC_MARK
) == 0)
2496 /* Keep all sections from non-XCOFF input files. Keep
2497 special sections. Keep .debug sections for the
2499 if (sub
->xvec
!= info
->hash
->creator
2500 || o
== xcoff_hash_table (info
)->debug_section
2501 || o
== xcoff_hash_table (info
)->loader_section
2502 || o
== xcoff_hash_table (info
)->linkage_section
2503 || o
== xcoff_hash_table (info
)->toc_section
2504 || o
== xcoff_hash_table (info
)->descriptor_section
2505 || strcmp (o
->name
, ".debug") == 0)
2506 o
->flags
|= SEC_MARK
;
2511 o
->lineno_count
= 0;
2518 /* Record the number of elements in a set. This is used to output the
2519 correct csect length. */
2522 bfd_xcoff_link_record_set (output_bfd
, info
, harg
, size
)
2524 struct bfd_link_info
*info
;
2525 struct bfd_link_hash_entry
*harg
;
2528 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2529 struct xcoff_link_size_list
*n
;
2532 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2535 /* This will hardly ever be called. I don't want to burn four bytes
2536 per global symbol, so instead the size is kept on a linked list
2537 attached to the hash table. */
2539 amt
= sizeof (struct xcoff_link_size_list
);
2540 n
= (struct xcoff_link_size_list
*) bfd_alloc (output_bfd
, amt
);
2543 n
->next
= xcoff_hash_table (info
)->size_list
;
2546 xcoff_hash_table (info
)->size_list
= n
;
2548 h
->flags
|= XCOFF_HAS_SIZE
;
2553 /* Import a symbol. */
2556 bfd_xcoff_import_symbol (output_bfd
, info
, harg
, val
, imppath
, impfile
,
2557 impmember
, syscall_flag
)
2559 struct bfd_link_info
*info
;
2560 struct bfd_link_hash_entry
*harg
;
2562 const char *imppath
;
2563 const char *impfile
;
2564 const char *impmember
;
2565 unsigned int syscall_flag
;
2567 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2569 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2572 /* A symbol name which starts with a period is the code for a
2573 function. If the symbol is undefined, then add an undefined
2574 symbol for the function descriptor, and import that instead. */
2575 if (h
->root
.root
.string
[0] == '.'
2576 && h
->root
.type
== bfd_link_hash_undefined
2577 && val
== (bfd_vma
) -1)
2579 struct xcoff_link_hash_entry
*hds
;
2581 hds
= h
->descriptor
;
2584 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2585 h
->root
.root
.string
+ 1,
2589 if (hds
->root
.type
== bfd_link_hash_new
)
2591 hds
->root
.type
= bfd_link_hash_undefined
;
2592 hds
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
2594 hds
->flags
|= XCOFF_DESCRIPTOR
;
2595 BFD_ASSERT ((hds
->flags
& XCOFF_CALLED
) == 0
2596 && (h
->flags
& XCOFF_DESCRIPTOR
) == 0);
2597 hds
->descriptor
= h
;
2598 h
->descriptor
= hds
;
2601 /* Now, if the descriptor is undefined, import the descriptor
2602 rather than the symbol we were told to import. FIXME: Is
2603 this correct in all cases? */
2604 if (hds
->root
.type
== bfd_link_hash_undefined
)
2608 h
->flags
|= (XCOFF_IMPORT
| syscall_flag
);
2610 if (val
!= (bfd_vma
) -1)
2612 if (h
->root
.type
== bfd_link_hash_defined
2613 && (! bfd_is_abs_section (h
->root
.u
.def
.section
)
2614 || h
->root
.u
.def
.value
!= val
))
2616 if (! ((*info
->callbacks
->multiple_definition
)
2617 (info
, h
->root
.root
.string
, h
->root
.u
.def
.section
->owner
,
2618 h
->root
.u
.def
.section
, h
->root
.u
.def
.value
,
2619 output_bfd
, bfd_abs_section_ptr
, val
)))
2623 h
->root
.type
= bfd_link_hash_defined
;
2624 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2625 h
->root
.u
.def
.value
= val
;
2628 /* We overload the ldindx field to hold the l_ifile value for this
2630 BFD_ASSERT (h
->ldsym
== NULL
);
2631 BFD_ASSERT ((h
->flags
& XCOFF_BUILT_LDSYM
) == 0);
2632 if (imppath
== NULL
)
2637 struct xcoff_import_file
**pp
;
2639 /* We start c at 1 because the first entry in the import list is
2640 reserved for the library search path. */
2641 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
2643 pp
= &(*pp
)->next
, ++c
)
2645 if (strcmp ((*pp
)->path
, imppath
) == 0
2646 && strcmp ((*pp
)->file
, impfile
) == 0
2647 && strcmp ((*pp
)->member
, impmember
) == 0)
2653 struct xcoff_import_file
*n
;
2654 bfd_size_type amt
= sizeof (struct xcoff_import_file
);
2656 n
= (struct xcoff_import_file
*) bfd_alloc (output_bfd
, amt
);
2662 n
->member
= impmember
;
2672 /* Export a symbol. */
2675 bfd_xcoff_export_symbol (output_bfd
, info
, harg
)
2677 struct bfd_link_info
*info
;
2678 struct bfd_link_hash_entry
*harg
;
2680 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2682 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2685 h
->flags
|= XCOFF_EXPORT
;
2687 /* FIXME: I'm not at all sure what syscall is supposed to mean, so
2688 I'm just going to ignore it until somebody explains it. */
2690 /* See if this is a function descriptor. It may be one even though
2691 it is not so marked. */
2692 if ((h
->flags
& XCOFF_DESCRIPTOR
) == 0
2693 && h
->root
.root
.string
[0] != '.')
2696 struct xcoff_link_hash_entry
*hfn
;
2697 bfd_size_type amt
= strlen (h
->root
.root
.string
) + 2;
2699 fnname
= (char *) bfd_malloc (amt
);
2703 strcpy (fnname
+ 1, h
->root
.root
.string
);
2704 hfn
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2705 fnname
, false, false, true);
2708 && hfn
->smclas
== XMC_PR
2709 && (hfn
->root
.type
== bfd_link_hash_defined
2710 || hfn
->root
.type
== bfd_link_hash_defweak
))
2712 h
->flags
|= XCOFF_DESCRIPTOR
;
2713 h
->descriptor
= hfn
;
2714 hfn
->descriptor
= h
;
2718 /* Make sure we don't garbage collect this symbol. */
2719 if (! xcoff_mark_symbol (info
, h
))
2722 /* If this is a function descriptor, make sure we don't garbage
2723 collect the associated function code. We normally don't have to
2724 worry about this, because the descriptor will be attached to a
2725 section with relocs, but if we are creating the descriptor
2726 ourselves those relocs will not be visible to the mark code. */
2727 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
2729 if (! xcoff_mark_symbol (info
, h
->descriptor
))
2736 /* Count a reloc against a symbol. This is called for relocs
2737 generated by the linker script, typically for global constructors
2741 bfd_xcoff_link_count_reloc (output_bfd
, info
, name
)
2743 struct bfd_link_info
*info
;
2746 struct xcoff_link_hash_entry
*h
;
2748 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2751 h
= ((struct xcoff_link_hash_entry
*)
2752 bfd_wrapped_link_hash_lookup (output_bfd
, info
, name
, false, false,
2756 (*_bfd_error_handler
) (_("%s: no such symbol"), name
);
2757 bfd_set_error (bfd_error_no_symbols
);
2761 h
->flags
|= XCOFF_REF_REGULAR
| XCOFF_LDREL
;
2762 ++xcoff_hash_table (info
)->ldrel_count
;
2764 /* Mark the symbol to avoid garbage collection. */
2765 if (! xcoff_mark_symbol (info
, h
))
2771 /* This function is called for each symbol to which the linker script
2775 bfd_xcoff_record_link_assignment (output_bfd
, info
, name
)
2777 struct bfd_link_info
*info
;
2780 struct xcoff_link_hash_entry
*h
;
2782 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2785 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, true, true,
2790 h
->flags
|= XCOFF_DEF_REGULAR
;
2795 /* Build the .loader section. This is called by the XCOFF linker
2796 emulation before_allocation routine. We must set the size of the
2797 .loader section before the linker lays out the output file.
2798 LIBPATH is the library path to search for shared objects; this is
2799 normally built from the -L arguments passed to the linker. ENTRY
2800 is the name of the entry point symbol (the -e linker option).
2801 FILE_ALIGN is the alignment to use for sections within the file
2802 (the -H linker option). MAXSTACK is the maximum stack size (the
2803 -bmaxstack linker option). MAXDATA is the maximum data size (the
2804 -bmaxdata linker option). GC is whether to do garbage collection
2805 (the -bgc linker option). MODTYPE is the module type (the
2806 -bmodtype linker option). TEXTRO is whether the text section must
2807 be read only (the -btextro linker option). EXPORT_DEFINEDS is
2808 whether all defined symbols should be exported (the -unix linker
2809 option). SPECIAL_SECTIONS is set by this routine to csects with
2810 magic names like _end. */
2813 bfd_xcoff_size_dynamic_sections (output_bfd
, info
, libpath
, entry
,
2814 file_align
, maxstack
, maxdata
, gc
,
2815 modtype
, textro
, export_defineds
,
2816 special_sections
, rtld
)
2818 struct bfd_link_info
*info
;
2819 const char *libpath
;
2821 unsigned long file_align
;
2822 unsigned long maxstack
;
2823 unsigned long maxdata
;
2827 boolean export_defineds
;
2828 asection
**special_sections
;
2831 struct xcoff_link_hash_entry
*hentry
;
2833 struct xcoff_loader_info ldinfo
;
2835 size_t impsize
, impcount
;
2836 struct xcoff_import_file
*fl
;
2837 struct internal_ldhdr
*ldhdr
;
2838 bfd_size_type stoff
;
2842 struct bfd_strtab_hash
*debug_strtab
;
2843 bfd_byte
*debug_contents
= NULL
;
2846 if (bfd_get_flavour (output_bfd
) != bfd_target_xcoff_flavour
)
2848 for (i
= 0; i
< XCOFF_NUMBER_OF_SPECIAL_SECTIONS
; i
++)
2849 special_sections
[i
] = NULL
;
2853 ldinfo
.failed
= false;
2854 ldinfo
.output_bfd
= output_bfd
;
2856 ldinfo
.export_defineds
= export_defineds
;
2857 ldinfo
.ldsym_count
= 0;
2858 ldinfo
.string_size
= 0;
2859 ldinfo
.strings
= NULL
;
2860 ldinfo
.string_alc
= 0;
2862 xcoff_data (output_bfd
)->maxstack
= maxstack
;
2863 xcoff_data (output_bfd
)->maxdata
= maxdata
;
2864 xcoff_data (output_bfd
)->modtype
= modtype
;
2866 xcoff_hash_table (info
)->file_align
= file_align
;
2867 xcoff_hash_table (info
)->textro
= textro
;
2872 hentry
= xcoff_link_hash_lookup (xcoff_hash_table (info
), entry
,
2873 false, false, true);
2875 hentry
->flags
|= XCOFF_ENTRY
;
2879 if (info
->init_function
|| info
->fini_function
|| rtld
== true)
2881 struct xcoff_link_hash_entry
*hsym
;
2882 struct internal_ldsym
*ldsym
;
2884 hsym
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2885 "__rtinit", false, false, true);
2888 (*_bfd_error_handler
)
2889 (_("error: undefined symbol __rtinit"));
2893 xcoff_mark_symbol (info
, hsym
);
2894 hsym
->flags
|= (XCOFF_DEF_REGULAR
| XCOFF_RTINIT
);
2896 /* __rtinit initalized */
2897 amt
= sizeof (struct internal_ldsym
);
2898 ldsym
= (struct internal_ldsym
*) bfd_malloc (amt
);
2900 ldsym
->l_value
= 0; /* will be filled in later */
2901 ldsym
->l_scnum
= 2; /* data section */
2902 ldsym
->l_smtype
= XTY_SD
; /* csect section definition */
2903 ldsym
->l_smclas
= 5; /* .rw */
2904 ldsym
->l_ifile
= 0; /* special system loader symbol */
2905 ldsym
->l_parm
= 0; /* NA */
2907 /* Force __rtinit to be the first symbol in the loader symbol table
2908 See xcoff_build_ldsyms
2910 The first 3 symbol table indices are reserved to indicate the data,
2911 text and bss sections. */
2912 BFD_ASSERT (0 == ldinfo
.ldsym_count
);
2915 ldinfo
.ldsym_count
= 1;
2916 hsym
->ldsym
= ldsym
;
2918 if (false == bfd_xcoff_put_ldsymbol_name (ldinfo
.output_bfd
, &ldinfo
,
2920 hsym
->root
.root
.string
))
2923 /* This symbol is written out by xcoff_write_global_symbol
2924 Set stuff up so xcoff_write_global_symbol logic works. */
2925 hsym
->flags
|= XCOFF_DEF_REGULAR
| XCOFF_MARK
;
2926 hsym
->root
.type
= bfd_link_hash_defined
;
2927 hsym
->root
.u
.def
.value
= 0;
2930 /* Garbage collect unused sections. */
2931 if (info
->relocateable
2934 || (hentry
->root
.type
!= bfd_link_hash_defined
2935 && hentry
->root
.type
!= bfd_link_hash_defweak
))
2938 xcoff_hash_table (info
)->gc
= false;
2940 /* We still need to call xcoff_mark, in order to set ldrel_count
2942 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
2946 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
2948 if ((o
->flags
& SEC_MARK
) == 0)
2950 if (! xcoff_mark (info
, o
))
2958 if (! xcoff_mark (info
, hentry
->root
.u
.def
.section
))
2961 xcoff_hash_table (info
)->gc
= true;
2964 /* Return special sections to the caller. */
2965 for (i
= 0; i
< XCOFF_NUMBER_OF_SPECIAL_SECTIONS
; i
++)
2967 sec
= xcoff_hash_table (info
)->special_sections
[i
];
2971 && (sec
->flags
& SEC_MARK
) == 0)
2975 special_sections
[i
] = sec
;
2978 if (info
->input_bfds
== NULL
)
2980 /* I'm not sure what to do in this bizarre case. */
2984 xcoff_link_hash_traverse (xcoff_hash_table (info
), xcoff_build_ldsyms
,
2989 /* Work out the size of the import file names. Each import file ID
2990 consists of three null terminated strings: the path, the file
2991 name, and the archive member name. The first entry in the list
2992 of names is the path to use to find objects, which the linker has
2993 passed in as the libpath argument. For some reason, the path
2994 entry in the other import file names appears to always be empty. */
2995 impsize
= strlen (libpath
) + 3;
2997 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
3000 impsize
+= (strlen (fl
->path
)
3002 + strlen (fl
->member
)
3006 /* Set up the .loader section header. */
3007 ldhdr
= &xcoff_hash_table (info
)->ldhdr
;
3008 ldhdr
->l_version
= bfd_xcoff_ldhdr_version(output_bfd
);
3009 ldhdr
->l_nsyms
= ldinfo
.ldsym_count
;
3010 ldhdr
->l_nreloc
= xcoff_hash_table (info
)->ldrel_count
;
3011 ldhdr
->l_istlen
= impsize
;
3012 ldhdr
->l_nimpid
= impcount
;
3013 ldhdr
->l_impoff
= (bfd_xcoff_ldhdrsz(output_bfd
)
3014 + ldhdr
->l_nsyms
* bfd_xcoff_ldsymsz(output_bfd
)
3015 + ldhdr
->l_nreloc
* bfd_xcoff_ldrelsz(output_bfd
));
3016 ldhdr
->l_stlen
= ldinfo
.string_size
;
3017 stoff
= ldhdr
->l_impoff
+ impsize
;
3018 if (ldinfo
.string_size
== 0)
3021 ldhdr
->l_stoff
= stoff
;
3023 /* 64 bit elements to ldhdr
3024 The swap out routine for 32 bit will ignore them.
3025 Nothing fancy, symbols come after the header and relocs come
3027 ldhdr
->l_symoff
= bfd_xcoff_ldhdrsz (output_bfd
);
3028 ldhdr
->l_rldoff
= (bfd_xcoff_ldhdrsz (output_bfd
)
3029 + ldhdr
->l_nsyms
* bfd_xcoff_ldsymsz (output_bfd
));
3031 /* We now know the final size of the .loader section. Allocate
3033 lsec
= xcoff_hash_table (info
)->loader_section
;
3034 lsec
->_raw_size
= stoff
+ ldhdr
->l_stlen
;
3035 lsec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, lsec
->_raw_size
);
3036 if (lsec
->contents
== NULL
)
3039 /* Set up the header. */
3040 bfd_xcoff_swap_ldhdr_out (output_bfd
, ldhdr
, lsec
->contents
);
3042 /* Set up the import file names. */
3043 out
= (char *) lsec
->contents
+ ldhdr
->l_impoff
;
3044 strcpy (out
, libpath
);
3045 out
+= strlen (libpath
) + 1;
3048 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
3050 register const char *s
;
3053 while ((*out
++ = *s
++) != '\0')
3056 while ((*out
++ = *s
++) != '\0')
3059 while ((*out
++ = *s
++) != '\0')
3063 BFD_ASSERT ((bfd_size_type
) ((bfd_byte
*) out
- lsec
->contents
) == stoff
);
3065 /* Set up the symbol string table. */
3066 if (ldinfo
.string_size
> 0)
3068 memcpy (out
, ldinfo
.strings
, ldinfo
.string_size
);
3069 free (ldinfo
.strings
);
3070 ldinfo
.strings
= NULL
;
3073 /* We can't set up the symbol table or the relocs yet, because we
3074 don't yet know the final position of the various sections. The
3075 .loader symbols are written out when the corresponding normal
3076 symbols are written out in xcoff_link_input_bfd or
3077 xcoff_write_global_symbol. The .loader relocs are written out
3078 when the corresponding normal relocs are handled in
3079 xcoff_link_input_bfd.
3082 /* Allocate space for the magic sections. */
3083 sec
= xcoff_hash_table (info
)->linkage_section
;
3084 if (sec
->_raw_size
> 0)
3086 sec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, sec
->_raw_size
);
3087 if (sec
->contents
== NULL
)
3090 sec
= xcoff_hash_table (info
)->toc_section
;
3091 if (sec
->_raw_size
> 0)
3093 sec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, sec
->_raw_size
);
3094 if (sec
->contents
== NULL
)
3097 sec
= xcoff_hash_table (info
)->descriptor_section
;
3098 if (sec
->_raw_size
> 0)
3100 sec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, sec
->_raw_size
);
3101 if (sec
->contents
== NULL
)
3105 /* Now that we've done garbage collection, figure out the contents
3106 of the .debug section. */
3107 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
3109 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3112 bfd_size_type symcount
;
3113 unsigned long *debug_index
;
3115 bfd_byte
*esym
, *esymend
;
3116 bfd_size_type symesz
;
3118 if (sub
->xvec
!= info
->hash
->creator
)
3120 subdeb
= bfd_get_section_by_name (sub
, ".debug");
3121 if (subdeb
== NULL
|| subdeb
->_raw_size
== 0)
3124 if (info
->strip
== strip_all
3125 || info
->strip
== strip_debugger
3126 || info
->discard
== discard_all
)
3128 subdeb
->_raw_size
= 0;
3132 if (! _bfd_coff_get_external_symbols (sub
))
3135 symcount
= obj_raw_syment_count (sub
);
3136 debug_index
= ((unsigned long *)
3137 bfd_zalloc (sub
, symcount
* sizeof (unsigned long)));
3138 if (debug_index
== NULL
)
3140 xcoff_data (sub
)->debug_indices
= debug_index
;
3142 /* Grab the contents of the .debug section. We use malloc and
3143 copy the names into the debug stringtab, rather than
3144 bfd_alloc, because I expect that, when linking many files
3145 together, many of the strings will be the same. Storing the
3146 strings in the hash table should save space in this case. */
3147 debug_contents
= (bfd_byte
*) bfd_malloc (subdeb
->_raw_size
);
3148 if (debug_contents
== NULL
)
3150 if (! bfd_get_section_contents (sub
, subdeb
, (PTR
) debug_contents
,
3151 (file_ptr
) 0, subdeb
->_raw_size
))
3154 csectpp
= xcoff_data (sub
)->csects
;
3156 /* Dynamic object do not have csectpp's. */
3157 if (NULL
!= csectpp
)
3159 symesz
= bfd_coff_symesz (sub
);
3160 esym
= (bfd_byte
*) obj_coff_external_syms (sub
);
3161 esymend
= esym
+ symcount
* symesz
;
3163 while (esym
< esymend
)
3165 struct internal_syment sym
;
3167 bfd_coff_swap_sym_in (sub
, (PTR
) esym
, (PTR
) &sym
);
3169 *debug_index
= (unsigned long) -1;
3171 if (sym
._n
._n_n
._n_zeroes
== 0
3174 || ((*csectpp
)->flags
& SEC_MARK
) != 0
3175 || *csectpp
== bfd_abs_section_ptr
)
3176 && bfd_coff_symname_in_debug (sub
, &sym
))
3181 name
= (char *) debug_contents
+ sym
._n
._n_n
._n_offset
;
3182 indx
= _bfd_stringtab_add (debug_strtab
, name
, true, true);
3183 if (indx
== (bfd_size_type
) -1)
3185 *debug_index
= indx
;
3188 esym
+= (sym
.n_numaux
+ 1) * symesz
;
3189 csectpp
+= sym
.n_numaux
+ 1;
3190 debug_index
+= sym
.n_numaux
+ 1;
3194 free (debug_contents
);
3195 debug_contents
= NULL
;
3197 /* Clear the size of subdeb, so that it is not included directly
3198 in the output file. */
3199 subdeb
->_raw_size
= 0;
3201 if (! info
->keep_memory
)
3203 if (! _bfd_coff_free_symbols (sub
))
3208 if (info
->strip
!= strip_all
)
3209 xcoff_hash_table (info
)->debug_section
->_raw_size
=
3210 _bfd_stringtab_size (debug_strtab
);
3215 if (ldinfo
.strings
!= NULL
)
3216 free (ldinfo
.strings
);
3217 if (debug_contents
!= NULL
)
3218 free (debug_contents
);
3223 bfd_xcoff_link_generate_rtinit (abfd
, init
, fini
, rtld
)
3229 struct bfd_in_memory
*bim
;
3231 bim
= ((struct bfd_in_memory
*)
3232 bfd_malloc ((bfd_size_type
) sizeof (struct bfd_in_memory
)));
3239 abfd
->link_next
= 0;
3240 abfd
->format
= bfd_object
;
3241 abfd
->iostream
= (PTR
) bim
;
3242 abfd
->flags
= BFD_IN_MEMORY
;
3243 abfd
->direction
= write_direction
;
3246 if (false == bfd_xcoff_generate_rtinit (abfd
, init
, fini
, rtld
))
3249 /* need to reset to unknown or it will not be read back in correctly */
3250 abfd
->format
= bfd_unknown
;
3251 abfd
->direction
= read_direction
;
3258 /* Add a symbol to the .loader symbols, if necessary. */
3261 xcoff_build_ldsyms (h
, p
)
3262 struct xcoff_link_hash_entry
*h
;
3265 struct xcoff_loader_info
*ldinfo
= (struct xcoff_loader_info
*) p
;
3268 if (h
->root
.type
== bfd_link_hash_warning
)
3269 h
= (struct xcoff_link_hash_entry
*) h
->root
.u
.i
.link
;
3271 /* __rtinit, this symbol has special handling. */
3272 if (h
->flags
& XCOFF_RTINIT
)
3275 /* If this is a final link, and the symbol was defined as a common
3276 symbol in a regular object file, and there was no definition in
3277 any dynamic object, then the linker will have allocated space for
3278 the symbol in a common section but the XCOFF_DEF_REGULAR flag
3279 will not have been set. */
3280 if (h
->root
.type
== bfd_link_hash_defined
3281 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
3282 && (h
->flags
& XCOFF_REF_REGULAR
) != 0
3283 && (h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
3284 && (bfd_is_abs_section (h
->root
.u
.def
.section
)
3285 || (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0))
3286 h
->flags
|= XCOFF_DEF_REGULAR
;
3288 /* If all defined symbols should be exported, mark them now. We
3289 don't want to export the actual functions, just the function
3291 if (ldinfo
->export_defineds
3292 && (h
->flags
& XCOFF_DEF_REGULAR
) != 0
3293 && h
->root
.root
.string
[0] != '.')
3297 /* We don't export a symbol which is being defined by an object
3298 included from an archive which contains a shared object. The
3299 rationale is that if an archive contains both an unshared and
3300 a shared object, then there must be some reason that the
3301 unshared object is unshared, and we don't want to start
3302 providing a shared version of it. In particular, this solves
3303 a bug involving the _savefNN set of functions. gcc will call
3304 those functions without providing a slot to restore the TOC,
3305 so it is essential that these functions be linked in directly
3306 and not from a shared object, which means that a shared
3307 object which also happens to link them in must not export
3308 them. This is confusing, but I haven't been able to think of
3309 a different approach. Note that the symbols can, of course,
3310 be exported explicitly. */
3312 if ((h
->root
.type
== bfd_link_hash_defined
3313 || h
->root
.type
== bfd_link_hash_defweak
)
3314 && h
->root
.u
.def
.section
->owner
!= NULL
3315 && h
->root
.u
.def
.section
->owner
->my_archive
!= NULL
)
3317 bfd
*arbfd
, *member
;
3319 arbfd
= h
->root
.u
.def
.section
->owner
->my_archive
;
3320 member
= bfd_openr_next_archived_file (arbfd
, (bfd
*) NULL
);
3321 while (member
!= NULL
)
3323 if ((member
->flags
& DYNAMIC
) != 0)
3328 member
= bfd_openr_next_archived_file (arbfd
, member
);
3333 h
->flags
|= XCOFF_EXPORT
;
3336 /* We don't want to garbage collect symbols which are not defined in
3337 XCOFF files. This is a convenient place to mark them. */
3338 if (xcoff_hash_table (ldinfo
->info
)->gc
3339 && (h
->flags
& XCOFF_MARK
) == 0
3340 && (h
->root
.type
== bfd_link_hash_defined
3341 || h
->root
.type
== bfd_link_hash_defweak
)
3342 && (h
->root
.u
.def
.section
->owner
== NULL
3343 || (h
->root
.u
.def
.section
->owner
->xvec
3344 != ldinfo
->info
->hash
->creator
)))
3345 h
->flags
|= XCOFF_MARK
;
3347 /* If this symbol is called and defined in a dynamic object, or it
3348 is imported, then we need to set up global linkage code for it.
3349 (Unless we did garbage collection and we didn't need this
3351 if ((h
->flags
& XCOFF_CALLED
) != 0
3352 && (h
->root
.type
== bfd_link_hash_undefined
3353 || h
->root
.type
== bfd_link_hash_undefweak
)
3354 && h
->root
.root
.string
[0] == '.'
3355 && h
->descriptor
!= NULL
3356 && ((h
->descriptor
->flags
& XCOFF_DEF_DYNAMIC
) != 0
3357 || ((h
->descriptor
->flags
& XCOFF_IMPORT
) != 0
3358 && (h
->descriptor
->flags
& XCOFF_DEF_REGULAR
) == 0))
3359 && (! xcoff_hash_table (ldinfo
->info
)->gc
3360 || (h
->flags
& XCOFF_MARK
) != 0))
3363 struct xcoff_link_hash_entry
*hds
;
3365 sec
= xcoff_hash_table (ldinfo
->info
)->linkage_section
;
3366 h
->root
.type
= bfd_link_hash_defined
;
3367 h
->root
.u
.def
.section
= sec
;
3368 h
->root
.u
.def
.value
= sec
->_raw_size
;
3370 h
->flags
|= XCOFF_DEF_REGULAR
;
3371 sec
->_raw_size
+= bfd_xcoff_glink_code_size(ldinfo
->output_bfd
);
3373 /* The global linkage code requires a TOC entry for the
3375 hds
= h
->descriptor
;
3376 BFD_ASSERT ((hds
->root
.type
== bfd_link_hash_undefined
3377 || hds
->root
.type
== bfd_link_hash_undefweak
)
3378 && (hds
->flags
& XCOFF_DEF_REGULAR
) == 0);
3379 hds
->flags
|= XCOFF_MARK
;
3380 if (hds
->toc_section
== NULL
)
3385 xcoff32 uses 4 bytes in the toc.
3386 xcoff64 uses 8 bytes in the toc. */
3387 if (bfd_xcoff_is_xcoff64 (ldinfo
->output_bfd
))
3389 else if (bfd_xcoff_is_xcoff32 (ldinfo
->output_bfd
))
3394 hds
->toc_section
= xcoff_hash_table (ldinfo
->info
)->toc_section
;
3395 hds
->u
.toc_offset
= hds
->toc_section
->_raw_size
;
3396 hds
->toc_section
->_raw_size
+= byte_size
;
3397 ++xcoff_hash_table (ldinfo
->info
)->ldrel_count
;
3398 ++hds
->toc_section
->reloc_count
;
3400 hds
->flags
|= XCOFF_SET_TOC
| XCOFF_LDREL
;
3402 /* We need to call xcoff_build_ldsyms recursively here,
3403 because we may already have passed hds on the traversal. */
3404 xcoff_build_ldsyms (hds
, p
);
3408 /* If this symbol is exported, but not defined, we need to try to
3410 if ((h
->flags
& XCOFF_EXPORT
) != 0
3411 && (h
->flags
& XCOFF_IMPORT
) == 0
3412 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
3413 && (h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
3414 && (h
->root
.type
== bfd_link_hash_undefined
3415 || h
->root
.type
== bfd_link_hash_undefweak
))
3417 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
3418 && (h
->descriptor
->root
.type
== bfd_link_hash_defined
3419 || h
->descriptor
->root
.type
== bfd_link_hash_defweak
))
3423 /* This is an undefined function descriptor associated with
3424 a defined entry point. We can build up a function
3425 descriptor ourselves. Believe it or not, the AIX linker
3426 actually does this, and there are cases where we need to
3428 sec
= xcoff_hash_table (ldinfo
->info
)->descriptor_section
;
3429 h
->root
.type
= bfd_link_hash_defined
;
3430 h
->root
.u
.def
.section
= sec
;
3431 h
->root
.u
.def
.value
= sec
->_raw_size
;
3433 h
->flags
|= XCOFF_DEF_REGULAR
;
3435 /* The size of the function descriptor depends if this is an
3436 xcoff32 (12) or xcoff64 (24). */
3438 bfd_xcoff_function_descriptor_size(ldinfo
->output_bfd
);
3440 /* A function descriptor uses two relocs: one for the
3441 associated code, and one for the TOC address. */
3442 xcoff_hash_table (ldinfo
->info
)->ldrel_count
+= 2;
3443 sec
->reloc_count
+= 2;
3445 /* We handle writing out the contents of the descriptor in
3446 xcoff_write_global_symbol. */
3450 (*_bfd_error_handler
)
3451 (_("warning: attempt to export undefined symbol `%s'"),
3452 h
->root
.root
.string
);
3458 /* If this is still a common symbol, and it wasn't garbage
3459 collected, we need to actually allocate space for it in the .bss
3461 if (h
->root
.type
== bfd_link_hash_common
3462 && (! xcoff_hash_table (ldinfo
->info
)->gc
3463 || (h
->flags
& XCOFF_MARK
) != 0)
3464 && h
->root
.u
.c
.p
->section
->_raw_size
== 0)
3466 BFD_ASSERT (bfd_is_com_section (h
->root
.u
.c
.p
->section
));
3467 h
->root
.u
.c
.p
->section
->_raw_size
= h
->root
.u
.c
.size
;
3470 /* We need to add a symbol to the .loader section if it is mentioned
3471 in a reloc which we are copying to the .loader section and it was
3472 not defined or common, or if it is the entry point, or if it is
3475 if (((h
->flags
& XCOFF_LDREL
) == 0
3476 || h
->root
.type
== bfd_link_hash_defined
3477 || h
->root
.type
== bfd_link_hash_defweak
3478 || h
->root
.type
== bfd_link_hash_common
)
3479 && (h
->flags
& XCOFF_ENTRY
) == 0
3480 && (h
->flags
& XCOFF_EXPORT
) == 0)
3486 /* We don't need to add this symbol if we did garbage collection and
3487 we did not mark this symbol. */
3488 if (xcoff_hash_table (ldinfo
->info
)->gc
3489 && (h
->flags
& XCOFF_MARK
) == 0)
3495 /* We may have already processed this symbol due to the recursive
3497 if ((h
->flags
& XCOFF_BUILT_LDSYM
) != 0)
3500 /* We need to add this symbol to the .loader symbols. */
3502 BFD_ASSERT (h
->ldsym
== NULL
);
3503 amt
= sizeof (struct internal_ldsym
);
3504 h
->ldsym
= (struct internal_ldsym
*) bfd_zalloc (ldinfo
->output_bfd
, amt
);
3505 if (h
->ldsym
== NULL
)
3507 ldinfo
->failed
= true;
3511 if ((h
->flags
& XCOFF_IMPORT
) != 0)
3512 h
->ldsym
->l_ifile
= h
->ldindx
;
3514 /* The first 3 symbol table indices are reserved to indicate the
3515 data, text and bss sections. */
3516 h
->ldindx
= ldinfo
->ldsym_count
+ 3;
3518 ++ldinfo
->ldsym_count
;
3520 if (false == bfd_xcoff_put_ldsymbol_name (ldinfo
->output_bfd
, ldinfo
,
3522 h
->root
.root
.string
))
3527 h
->flags
|= XCOFF_BUILT_LDSYM
;
3532 /* Do the final link step. */
3535 _bfd_xcoff_bfd_final_link (abfd
, info
)
3537 struct bfd_link_info
*info
;
3539 bfd_size_type symesz
;
3540 struct xcoff_final_link_info finfo
;
3542 struct bfd_link_order
*p
;
3543 bfd_size_type max_contents_size
;
3544 bfd_size_type max_sym_count
;
3545 bfd_size_type max_lineno_count
;
3546 bfd_size_type max_reloc_count
;
3547 bfd_size_type max_output_reloc_count
;
3548 file_ptr rel_filepos
;
3550 file_ptr line_filepos
;
3551 unsigned int linesz
;
3553 bfd_byte
*external_relocs
= NULL
;
3554 char strbuf
[STRING_SIZE_SIZE
];
3559 abfd
->flags
|= DYNAMIC
;
3561 symesz
= bfd_coff_symesz (abfd
);
3564 finfo
.output_bfd
= abfd
;
3565 finfo
.strtab
= NULL
;
3566 finfo
.section_info
= NULL
;
3567 finfo
.last_file_index
= -1;
3568 finfo
.toc_symindx
= -1;
3569 finfo
.internal_syms
= NULL
;
3570 finfo
.sym_indices
= NULL
;
3571 finfo
.outsyms
= NULL
;
3572 finfo
.linenos
= NULL
;
3573 finfo
.contents
= NULL
;
3574 finfo
.external_relocs
= NULL
;
3576 finfo
.ldsym
= (xcoff_hash_table (info
)->loader_section
->contents
3577 + bfd_xcoff_ldhdrsz (abfd
));
3578 finfo
.ldrel
= (xcoff_hash_table (info
)->loader_section
->contents
3579 + bfd_xcoff_ldhdrsz(abfd
)
3580 + (xcoff_hash_table (info
)->ldhdr
.l_nsyms
3581 * bfd_xcoff_ldsymsz(abfd
)));
3583 xcoff_data (abfd
)->coff
.link_info
= info
;
3585 finfo
.strtab
= _bfd_stringtab_init ();
3586 if (finfo
.strtab
== NULL
)
3589 /* Count the line number and relocation entries required for the
3590 output file. Determine a few maximum sizes. */
3591 max_contents_size
= 0;
3592 max_lineno_count
= 0;
3593 max_reloc_count
= 0;
3594 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3597 o
->lineno_count
= 0;
3598 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3600 if (p
->type
== bfd_indirect_link_order
)
3604 sec
= p
->u
.indirect
.section
;
3606 /* Mark all sections which are to be included in the
3607 link. This will normally be every section. We need
3608 to do this so that we can identify any sections which
3609 the linker has decided to not include. */
3610 sec
->linker_mark
= true;
3612 if (info
->strip
== strip_none
3613 || info
->strip
== strip_some
)
3614 o
->lineno_count
+= sec
->lineno_count
;
3616 o
->reloc_count
+= sec
->reloc_count
;
3618 if (sec
->_raw_size
> max_contents_size
)
3619 max_contents_size
= sec
->_raw_size
;
3620 if (sec
->lineno_count
> max_lineno_count
)
3621 max_lineno_count
= sec
->lineno_count
;
3622 if (coff_section_data (sec
->owner
, sec
) != NULL
3623 && xcoff_section_data (sec
->owner
, sec
) != NULL
3624 && (xcoff_section_data (sec
->owner
, sec
)->lineno_count
3625 > max_lineno_count
))
3627 xcoff_section_data (sec
->owner
, sec
)->lineno_count
;
3628 if (sec
->reloc_count
> max_reloc_count
)
3629 max_reloc_count
= sec
->reloc_count
;
3631 else if (p
->type
== bfd_section_reloc_link_order
3632 || p
->type
== bfd_symbol_reloc_link_order
)
3637 /* Compute the file positions for all the sections. */
3638 if (abfd
->output_has_begun
)
3640 if (xcoff_hash_table (info
)->file_align
!= 0)
3647 file_align
= xcoff_hash_table (info
)->file_align
;
3648 if (file_align
!= 0)
3650 boolean saw_contents
;
3655 /* Insert .pad sections before every section which has
3656 contents and is loaded, if it is preceded by some other
3657 section which has contents and is loaded. */
3658 saw_contents
= true;
3659 for (op
= &abfd
->sections
; *op
!= NULL
; op
= &(*op
)->next
)
3661 if (strcmp ((*op
)->name
, ".pad") == 0)
3662 saw_contents
= false;
3663 else if (((*op
)->flags
& SEC_HAS_CONTENTS
) != 0
3664 && ((*op
)->flags
& SEC_LOAD
) != 0)
3667 saw_contents
= true;
3672 /* Create a pad section and place it before the section
3673 that needs padding. This requires unlinking and
3674 relinking the bfd's section list. */
3676 st
= abfd
->section_tail
;
3677 n
= bfd_make_section_anyway (abfd
, ".pad");
3678 n
->flags
= SEC_HAS_CONTENTS
;
3679 n
->alignment_power
= 0;
3681 BFD_ASSERT (*st
== n
);
3682 bfd_section_list_remove (abfd
, st
);
3683 bfd_section_list_insert (abfd
, op
, n
);
3686 saw_contents
= false;
3691 /* Reset the section indices after inserting the new
3694 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3697 o
->target_index
= indx
;
3699 BFD_ASSERT ((unsigned int) indx
== abfd
->section_count
);
3701 /* Work out appropriate sizes for the .pad sections to force
3702 each section to land on a page boundary. This bit of
3703 code knows what compute_section_file_positions is going
3705 sofar
= bfd_coff_filhsz (abfd
);
3706 sofar
+= bfd_coff_aoutsz (abfd
);
3707 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3708 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3709 if ((bfd_xcoff_is_reloc_count_overflow
3710 (abfd
, (bfd_vma
) o
->reloc_count
))
3711 || (bfd_xcoff_is_lineno_count_overflow
3712 (abfd
, (bfd_vma
) o
->lineno_count
)))
3713 /* 64 does not overflow, need to check if 32 does */
3714 sofar
+= bfd_coff_scnhsz (abfd
);
3716 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3718 if (strcmp (o
->name
, ".pad") == 0)
3722 BFD_ASSERT (o
->_raw_size
== 0);
3723 pageoff
= sofar
& (file_align
- 1);
3726 o
->_raw_size
= file_align
- pageoff
;
3727 sofar
+= file_align
- pageoff
;
3728 o
->flags
|= SEC_HAS_CONTENTS
;
3733 if ((o
->flags
& SEC_HAS_CONTENTS
) != 0)
3734 sofar
+= BFD_ALIGN (o
->_raw_size
,
3735 1 << o
->alignment_power
);
3740 if (! bfd_coff_compute_section_file_positions (abfd
))
3744 /* Allocate space for the pointers we need to keep for the relocs. */
3748 /* We use section_count + 1, rather than section_count, because
3749 the target_index fields are 1 based. */
3750 amt
= abfd
->section_count
+ 1;
3751 amt
*= sizeof (struct xcoff_link_section_info
);
3752 finfo
.section_info
= (struct xcoff_link_section_info
*) bfd_malloc (amt
);
3753 if (finfo
.section_info
== NULL
)
3755 for (i
= 0; i
<= abfd
->section_count
; i
++)
3757 finfo
.section_info
[i
].relocs
= NULL
;
3758 finfo
.section_info
[i
].rel_hashes
= NULL
;
3759 finfo
.section_info
[i
].toc_rel_hashes
= NULL
;
3763 /* Set the file positions for the relocs. */
3764 rel_filepos
= obj_relocbase (abfd
);
3765 relsz
= bfd_coff_relsz (abfd
);
3766 max_output_reloc_count
= 0;
3767 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3769 if (o
->reloc_count
== 0)
3773 /* A stripped file has no relocs. However, we still
3774 allocate the buffers, so that later code doesn't have to
3775 worry about whether we are stripping or not. */
3776 if (info
->strip
== strip_all
)
3780 o
->flags
|= SEC_RELOC
;
3781 o
->rel_filepos
= rel_filepos
;
3782 rel_filepos
+= o
->reloc_count
* relsz
;
3785 /* We don't know the indices of global symbols until we have
3786 written out all the local symbols. For each section in
3787 the output file, we keep an array of pointers to hash
3788 table entries. Each entry in the array corresponds to a
3789 reloc. When we find a reloc against a global symbol, we
3790 set the corresponding entry in this array so that we can
3791 fix up the symbol index after we have written out all the
3794 Because of this problem, we also keep the relocs in
3795 memory until the end of the link. This wastes memory.
3796 We could backpatch the file later, I suppose, although it
3798 amt
= o
->reloc_count
;
3799 amt
*= sizeof (struct internal_reloc
);
3800 finfo
.section_info
[o
->target_index
].relocs
=
3801 (struct internal_reloc
*) bfd_malloc (amt
);
3803 amt
= o
->reloc_count
;
3804 amt
*= sizeof (struct xcoff_link_hash_entry
*);
3805 finfo
.section_info
[o
->target_index
].rel_hashes
=
3806 (struct xcoff_link_hash_entry
**) bfd_malloc (amt
);
3808 if (finfo
.section_info
[o
->target_index
].relocs
== NULL
3809 || finfo
.section_info
[o
->target_index
].rel_hashes
== NULL
)
3812 if (o
->reloc_count
> max_output_reloc_count
)
3813 max_output_reloc_count
= o
->reloc_count
;
3817 /* We now know the size of the relocs, so we can determine the file
3818 positions of the line numbers. */
3819 line_filepos
= rel_filepos
;
3820 finfo
.line_filepos
= line_filepos
;
3821 linesz
= bfd_coff_linesz (abfd
);
3822 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3824 if (o
->lineno_count
== 0)
3825 o
->line_filepos
= 0;
3828 o
->line_filepos
= line_filepos
;
3829 line_filepos
+= o
->lineno_count
* linesz
;
3832 /* Reset the reloc and lineno counts, so that we can use them to
3833 count the number of entries we have output so far. */
3835 o
->lineno_count
= 0;
3838 obj_sym_filepos (abfd
) = line_filepos
;
3840 /* Figure out the largest number of symbols in an input BFD. Take
3841 the opportunity to clear the output_has_begun fields of all the
3842 input BFD's. We want at least 6 symbols, since that is the
3843 number which xcoff_write_global_symbol may need. */
3845 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3849 sub
->output_has_begun
= false;
3850 sz
= obj_raw_syment_count (sub
);
3851 if (sz
> max_sym_count
)
3855 /* Allocate some buffers used while linking. */
3856 amt
= max_sym_count
* sizeof (struct internal_syment
);
3857 finfo
.internal_syms
= (struct internal_syment
*) bfd_malloc (amt
);
3859 amt
= max_sym_count
* sizeof (long);
3860 finfo
.sym_indices
= (long *) bfd_malloc (amt
);
3862 amt
= (max_sym_count
+ 1) * symesz
;
3863 finfo
.outsyms
= (bfd_byte
*) bfd_malloc (amt
);
3865 amt
= max_lineno_count
* bfd_coff_linesz (abfd
);
3866 finfo
.linenos
= (bfd_byte
*) bfd_malloc (amt
);
3868 amt
= max_contents_size
;
3869 finfo
.contents
= (bfd_byte
*) bfd_malloc (amt
);
3871 amt
= max_reloc_count
* relsz
;
3872 finfo
.external_relocs
= (bfd_byte
*) bfd_malloc (amt
);
3874 if ((finfo
.internal_syms
== NULL
&& max_sym_count
> 0)
3875 || (finfo
.sym_indices
== NULL
&& max_sym_count
> 0)
3876 || finfo
.outsyms
== NULL
3877 || (finfo
.linenos
== NULL
&& max_lineno_count
> 0)
3878 || (finfo
.contents
== NULL
&& max_contents_size
> 0)
3879 || (finfo
.external_relocs
== NULL
&& max_reloc_count
> 0))
3882 obj_raw_syment_count (abfd
) = 0;
3883 xcoff_data (abfd
)->toc
= (bfd_vma
) -1;
3885 /* We now know the position of everything in the file, except that
3886 we don't know the size of the symbol table and therefore we don't
3887 know where the string table starts. We just build the string
3888 table in memory as we go along. We process all the relocations
3889 for a single input file at once. */
3890 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3892 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3894 if (p
->type
== bfd_indirect_link_order
3895 && p
->u
.indirect
.section
->owner
->xvec
== abfd
->xvec
)
3897 sub
= p
->u
.indirect
.section
->owner
;
3898 if (! sub
->output_has_begun
)
3900 if (! xcoff_link_input_bfd (&finfo
, sub
))
3902 sub
->output_has_begun
= true;
3905 else if (p
->type
== bfd_section_reloc_link_order
3906 || p
->type
== bfd_symbol_reloc_link_order
)
3908 if (! xcoff_reloc_link_order (abfd
, &finfo
, o
, p
))
3913 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3920 /* Free up the buffers used by xcoff_link_input_bfd. */
3922 if (finfo
.internal_syms
!= NULL
)
3924 free (finfo
.internal_syms
);
3925 finfo
.internal_syms
= NULL
;
3927 if (finfo
.sym_indices
!= NULL
)
3929 free (finfo
.sym_indices
);
3930 finfo
.sym_indices
= NULL
;
3932 if (finfo
.linenos
!= NULL
)
3934 free (finfo
.linenos
);
3935 finfo
.linenos
= NULL
;
3937 if (finfo
.contents
!= NULL
)
3939 free (finfo
.contents
);
3940 finfo
.contents
= NULL
;
3942 if (finfo
.external_relocs
!= NULL
)
3944 free (finfo
.external_relocs
);
3945 finfo
.external_relocs
= NULL
;
3948 /* The value of the last C_FILE symbol is supposed to be -1. Write
3950 if (finfo
.last_file_index
!= -1)
3952 finfo
.last_file
.n_value
= -(bfd_vma
) 1;
3953 bfd_coff_swap_sym_out (abfd
, (PTR
) &finfo
.last_file
,
3954 (PTR
) finfo
.outsyms
);
3955 pos
= obj_sym_filepos (abfd
) + finfo
.last_file_index
* symesz
;
3956 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
3957 || bfd_bwrite (finfo
.outsyms
, symesz
, abfd
) != symesz
)
3961 /* Write out all the global symbols which do not come from XCOFF
3963 xcoff_link_hash_traverse (xcoff_hash_table (info
),
3964 xcoff_write_global_symbol
,
3967 if (finfo
.outsyms
!= NULL
)
3969 free (finfo
.outsyms
);
3970 finfo
.outsyms
= NULL
;
3973 /* Now that we have written out all the global symbols, we know the
3974 symbol indices to use for relocs against them, and we can finally
3975 write out the relocs. */
3976 amt
= max_output_reloc_count
* relsz
;
3977 external_relocs
= (bfd_byte
*) bfd_malloc (amt
);
3978 if (external_relocs
== NULL
&& max_output_reloc_count
!= 0)
3981 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3983 struct internal_reloc
*irel
;
3984 struct internal_reloc
*irelend
;
3985 struct xcoff_link_hash_entry
**rel_hash
;
3986 struct xcoff_toc_rel_hash
*toc_rel_hash
;
3988 bfd_size_type rel_size
;
3990 /* A stripped file has no relocs. */
3991 if (info
->strip
== strip_all
)
3997 if (o
->reloc_count
== 0)
4000 irel
= finfo
.section_info
[o
->target_index
].relocs
;
4001 irelend
= irel
+ o
->reloc_count
;
4002 rel_hash
= finfo
.section_info
[o
->target_index
].rel_hashes
;
4003 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
4005 if (*rel_hash
!= NULL
)
4007 if ((*rel_hash
)->indx
< 0)
4009 if (! ((*info
->callbacks
->unattached_reloc
)
4010 (info
, (*rel_hash
)->root
.root
.string
,
4011 (bfd
*) NULL
, o
, irel
->r_vaddr
)))
4013 (*rel_hash
)->indx
= 0;
4015 irel
->r_symndx
= (*rel_hash
)->indx
;
4019 for (toc_rel_hash
= finfo
.section_info
[o
->target_index
].toc_rel_hashes
;
4020 toc_rel_hash
!= NULL
;
4021 toc_rel_hash
= toc_rel_hash
->next
)
4023 if (toc_rel_hash
->h
->u
.toc_indx
< 0)
4025 if (! ((*info
->callbacks
->unattached_reloc
)
4026 (info
, toc_rel_hash
->h
->root
.root
.string
,
4027 (bfd
*) NULL
, o
, toc_rel_hash
->rel
->r_vaddr
)))
4029 toc_rel_hash
->h
->u
.toc_indx
= 0;
4031 toc_rel_hash
->rel
->r_symndx
= toc_rel_hash
->h
->u
.toc_indx
;
4034 /* XCOFF requires that the relocs be sorted by address. We tend
4035 to produce them in the order in which their containing csects
4036 appear in the symbol table, which is not necessarily by
4037 address. So we sort them here. There may be a better way to
4039 qsort ((PTR
) finfo
.section_info
[o
->target_index
].relocs
,
4040 o
->reloc_count
, sizeof (struct internal_reloc
),
4043 irel
= finfo
.section_info
[o
->target_index
].relocs
;
4044 irelend
= irel
+ o
->reloc_count
;
4045 erel
= external_relocs
;
4046 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
4047 bfd_coff_swap_reloc_out (abfd
, (PTR
) irel
, (PTR
) erel
);
4049 rel_size
= relsz
* o
->reloc_count
;
4050 if (bfd_seek (abfd
, o
->rel_filepos
, SEEK_SET
) != 0
4051 || bfd_bwrite ((PTR
) external_relocs
, rel_size
, abfd
) != rel_size
)
4055 if (external_relocs
!= NULL
)
4057 free (external_relocs
);
4058 external_relocs
= NULL
;
4061 /* Free up the section information. */
4062 if (finfo
.section_info
!= NULL
)
4066 for (i
= 0; i
< abfd
->section_count
; i
++)
4068 if (finfo
.section_info
[i
].relocs
!= NULL
)
4069 free (finfo
.section_info
[i
].relocs
);
4070 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
4071 free (finfo
.section_info
[i
].rel_hashes
);
4073 free (finfo
.section_info
);
4074 finfo
.section_info
= NULL
;
4077 /* Write out the loader section contents. */
4078 BFD_ASSERT ((bfd_byte
*) finfo
.ldrel
4079 == (xcoff_hash_table (info
)->loader_section
->contents
4080 + xcoff_hash_table (info
)->ldhdr
.l_impoff
));
4081 o
= xcoff_hash_table (info
)->loader_section
;
4082 if (! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
4083 (file_ptr
) o
->output_offset
, o
->_raw_size
))
4086 /* Write out the magic sections. */
4087 o
= xcoff_hash_table (info
)->linkage_section
;
4088 if (o
->_raw_size
> 0
4089 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
4090 (file_ptr
) o
->output_offset
,
4093 o
= xcoff_hash_table (info
)->toc_section
;
4094 if (o
->_raw_size
> 0
4095 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
4096 (file_ptr
) o
->output_offset
,
4099 o
= xcoff_hash_table (info
)->descriptor_section
;
4100 if (o
->_raw_size
> 0
4101 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
4102 (file_ptr
) o
->output_offset
,
4106 /* Write out the string table. */
4107 pos
= obj_sym_filepos (abfd
) + obj_raw_syment_count (abfd
) * symesz
;
4108 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
4111 _bfd_stringtab_size (finfo
.strtab
) + STRING_SIZE_SIZE
,
4113 amt
= STRING_SIZE_SIZE
;
4114 if (bfd_bwrite (strbuf
, amt
, abfd
) != amt
)
4116 if (! _bfd_stringtab_emit (abfd
, finfo
.strtab
))
4119 _bfd_stringtab_free (finfo
.strtab
);
4121 /* Write out the debugging string table. */
4122 o
= xcoff_hash_table (info
)->debug_section
;
4125 struct bfd_strtab_hash
*debug_strtab
;
4127 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
4128 BFD_ASSERT (o
->output_section
->_raw_size
- o
->output_offset
4129 >= _bfd_stringtab_size (debug_strtab
));
4130 pos
= o
->output_section
->filepos
+ o
->output_offset
;
4131 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
4133 if (! _bfd_stringtab_emit (abfd
, debug_strtab
))
4137 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
4138 not try to write out the symbols. */
4139 bfd_get_symcount (abfd
) = 0;
4144 if (finfo
.strtab
!= NULL
)
4145 _bfd_stringtab_free (finfo
.strtab
);
4147 if (finfo
.section_info
!= NULL
)
4151 for (i
= 0; i
< abfd
->section_count
; i
++)
4153 if (finfo
.section_info
[i
].relocs
!= NULL
)
4154 free (finfo
.section_info
[i
].relocs
);
4155 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
4156 free (finfo
.section_info
[i
].rel_hashes
);
4158 free (finfo
.section_info
);
4161 if (finfo
.internal_syms
!= NULL
)
4162 free (finfo
.internal_syms
);
4163 if (finfo
.sym_indices
!= NULL
)
4164 free (finfo
.sym_indices
);
4165 if (finfo
.outsyms
!= NULL
)
4166 free (finfo
.outsyms
);
4167 if (finfo
.linenos
!= NULL
)
4168 free (finfo
.linenos
);
4169 if (finfo
.contents
!= NULL
)
4170 free (finfo
.contents
);
4171 if (finfo
.external_relocs
!= NULL
)
4172 free (finfo
.external_relocs
);
4173 if (external_relocs
!= NULL
)
4174 free (external_relocs
);
4178 /* Link an input file into the linker output file. This function
4179 handles all the sections and relocations of the input file at once. */
4182 xcoff_link_input_bfd (finfo
, input_bfd
)
4183 struct xcoff_final_link_info
*finfo
;
4187 const char *strings
;
4188 bfd_size_type syment_base
;
4189 unsigned int n_tmask
;
4190 unsigned int n_btshft
;
4192 bfd_size_type isymesz
;
4193 bfd_size_type osymesz
;
4194 bfd_size_type linesz
;
4197 struct xcoff_link_hash_entry
**sym_hash
;
4198 struct internal_syment
*isymp
;
4200 unsigned long *debug_index
;
4202 unsigned long output_index
;
4209 /* We can just skip DYNAMIC files, unless this is a static link. */
4210 if ((input_bfd
->flags
& DYNAMIC
) != 0
4211 && ! finfo
->info
->static_link
)
4214 /* Move all the symbols to the output file. */
4216 output_bfd
= finfo
->output_bfd
;
4218 syment_base
= obj_raw_syment_count (output_bfd
);
4219 isymesz
= bfd_coff_symesz (input_bfd
);
4220 osymesz
= bfd_coff_symesz (output_bfd
);
4221 linesz
= bfd_coff_linesz (input_bfd
);
4222 BFD_ASSERT (linesz
== bfd_coff_linesz (output_bfd
));
4224 n_tmask
= coff_data (input_bfd
)->local_n_tmask
;
4225 n_btshft
= coff_data (input_bfd
)->local_n_btshft
;
4227 /* Define macros so that ISFCN, et. al., macros work correctly. */
4228 #define N_TMASK n_tmask
4229 #define N_BTSHFT n_btshft
4232 if (! finfo
->info
->keep_memory
)
4235 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
4238 if (! _bfd_coff_get_external_symbols (input_bfd
))
4241 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
4242 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
4243 sym_hash
= obj_xcoff_sym_hashes (input_bfd
);
4244 csectpp
= xcoff_data (input_bfd
)->csects
;
4245 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
4246 isymp
= finfo
->internal_syms
;
4247 indexp
= finfo
->sym_indices
;
4248 output_index
= syment_base
;
4249 outsym
= finfo
->outsyms
;
4253 while (esym
< esym_end
)
4256 struct internal_syment isym
;
4257 union internal_auxent aux
;
4263 bfd_coff_swap_sym_in (input_bfd
, (PTR
) esym
, (PTR
) isymp
);
4265 /* If this is a C_EXT or C_HIDEXT symbol, we need the csect
4267 if (isymp
->n_sclass
== C_EXT
|| isymp
->n_sclass
== C_HIDEXT
)
4269 BFD_ASSERT (isymp
->n_numaux
> 0);
4270 bfd_coff_swap_aux_in (input_bfd
,
4271 (PTR
) (esym
+ isymesz
* isymp
->n_numaux
),
4272 isymp
->n_type
, isymp
->n_sclass
,
4273 isymp
->n_numaux
- 1, isymp
->n_numaux
,
4276 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
4279 /* Make a copy of *isymp so that the relocate_section function
4280 always sees the original values. This is more reliable than
4281 always recomputing the symbol value even if we are stripping
4285 /* If this symbol is in the .loader section, swap out the
4286 .loader symbol information. If this is an external symbol
4287 reference to a defined symbol, though, then wait until we get
4288 to the definition. */
4289 if (isym
.n_sclass
== C_EXT
4290 && *sym_hash
!= NULL
4291 && (*sym_hash
)->ldsym
!= NULL
4293 || (*sym_hash
)->root
.type
== bfd_link_hash_undefined
))
4295 struct xcoff_link_hash_entry
*h
;
4296 struct internal_ldsym
*ldsym
;
4300 if (isym
.n_scnum
> 0)
4302 ldsym
->l_scnum
= (*csectpp
)->output_section
->target_index
;
4303 ldsym
->l_value
= (isym
.n_value
4304 + (*csectpp
)->output_section
->vma
4305 + (*csectpp
)->output_offset
4310 ldsym
->l_scnum
= isym
.n_scnum
;
4311 ldsym
->l_value
= isym
.n_value
;
4314 ldsym
->l_smtype
= smtyp
;
4315 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
4316 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4317 || (h
->flags
& XCOFF_IMPORT
) != 0)
4318 ldsym
->l_smtype
|= L_IMPORT
;
4319 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
4320 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4321 || (h
->flags
& XCOFF_EXPORT
) != 0)
4322 ldsym
->l_smtype
|= L_EXPORT
;
4323 if ((h
->flags
& XCOFF_ENTRY
) != 0)
4324 ldsym
->l_smtype
|= L_ENTRY
;
4326 ldsym
->l_smclas
= aux
.x_csect
.x_smclas
;
4328 if (ldsym
->l_ifile
== (bfd_size_type
) -1)
4330 else if (ldsym
->l_ifile
== 0)
4332 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
4338 if (h
->root
.type
== bfd_link_hash_defined
4339 || h
->root
.type
== bfd_link_hash_defweak
)
4340 impbfd
= h
->root
.u
.def
.section
->owner
;
4341 else if (h
->root
.type
== bfd_link_hash_undefined
4342 || h
->root
.type
== bfd_link_hash_undefweak
)
4343 impbfd
= h
->root
.u
.undef
.abfd
;
4351 BFD_ASSERT (impbfd
->xvec
== finfo
->output_bfd
->xvec
);
4352 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
4359 BFD_ASSERT (h
->ldindx
>= 0);
4360 bfd_xcoff_swap_ldsym_out (finfo
->output_bfd
, ldsym
,
4363 * bfd_xcoff_ldsymsz (finfo
->output_bfd
))));
4366 /* Fill in snentry now that we know the target_index. */
4367 if ((h
->flags
& XCOFF_ENTRY
) != 0
4368 && (h
->root
.type
== bfd_link_hash_defined
4369 || h
->root
.type
== bfd_link_hash_defweak
))
4371 xcoff_data (output_bfd
)->snentry
=
4372 h
->root
.u
.def
.section
->output_section
->target_index
;
4380 add
= 1 + isym
.n_numaux
;
4382 /* If we are skipping this csect, we want to skip this symbol. */
4383 if (*csectpp
== NULL
)
4386 /* If we garbage collected this csect, we want to skip this
4389 && xcoff_hash_table (finfo
->info
)->gc
4390 && ((*csectpp
)->flags
& SEC_MARK
) == 0
4391 && *csectpp
!= bfd_abs_section_ptr
)
4394 /* An XCOFF linker always skips C_STAT symbols. */
4396 && isymp
->n_sclass
== C_STAT
)
4399 /* We skip all but the first TOC anchor. */
4401 && isymp
->n_sclass
== C_HIDEXT
4402 && aux
.x_csect
.x_smclas
== XMC_TC0
)
4404 if (finfo
->toc_symindx
!= -1)
4408 bfd_vma tocval
, tocend
;
4411 tocval
= ((*csectpp
)->output_section
->vma
4412 + (*csectpp
)->output_offset
4416 /* We want to find out if tocval is a good value to use
4417 as the TOC anchor--that is, whether we can access all
4418 of the TOC using a 16 bit offset from tocval. This
4419 test assumes that the TOC comes at the end of the
4420 output section, as it does in the default linker
4422 tocend
= ((*csectpp
)->output_section
->vma
4423 + (*csectpp
)->output_section
->_raw_size
);
4424 for (inp
= finfo
->info
->input_bfds
;
4426 inp
= inp
->link_next
)
4429 for (o
= inp
->sections
; o
!= NULL
; o
= o
->next
)
4430 if (strcmp (o
->name
, ".tocbss") == 0)
4432 bfd_vma new_toc_end
;
4433 new_toc_end
= (o
->output_section
->vma
4436 if (new_toc_end
> tocend
)
4437 tocend
= new_toc_end
;
4442 if (tocval
+ 0x10000 < tocend
)
4444 (*_bfd_error_handler
)
4445 (_("TOC overflow: 0x%lx > 0x10000; try -mminimal-toc when compiling"),
4446 (unsigned long) (tocend
- tocval
));
4447 bfd_set_error (bfd_error_file_too_big
);
4451 if (tocval
+ 0x8000 < tocend
)
4455 tocadd
= tocend
- (tocval
+ 0x8000);
4457 isym
.n_value
+= tocadd
;
4460 finfo
->toc_symindx
= output_index
;
4461 xcoff_data (finfo
->output_bfd
)->toc
= tocval
;
4462 xcoff_data (finfo
->output_bfd
)->sntoc
=
4463 (*csectpp
)->output_section
->target_index
;
4469 /* If we are stripping all symbols, we want to skip this one. */
4471 && finfo
->info
->strip
== strip_all
)
4474 /* We can skip resolved external references. */
4476 && isym
.n_sclass
== C_EXT
4478 && (*sym_hash
)->root
.type
!= bfd_link_hash_undefined
)
4481 /* We can skip common symbols if they got defined somewhere
4484 && isym
.n_sclass
== C_EXT
4486 && ((*sym_hash
)->root
.type
!= bfd_link_hash_common
4487 || (*sym_hash
)->root
.u
.c
.p
->section
!= *csectpp
)
4488 && ((*sym_hash
)->root
.type
!= bfd_link_hash_defined
4489 || (*sym_hash
)->root
.u
.def
.section
!= *csectpp
))
4492 /* Skip local symbols if we are discarding them. */
4494 && finfo
->info
->discard
== discard_all
4495 && isym
.n_sclass
!= C_EXT
4496 && (isym
.n_sclass
!= C_HIDEXT
4497 || smtyp
!= XTY_SD
))
4500 /* If we stripping debugging symbols, and this is a debugging
4501 symbol, then skip it. */
4503 && finfo
->info
->strip
== strip_debugger
4504 && isym
.n_scnum
== N_DEBUG
)
4507 /* If some symbols are stripped based on the name, work out the
4508 name and decide whether to skip this symbol. We don't handle
4509 this correctly for symbols whose names are in the .debug
4510 section; to get it right we would need a new bfd_strtab_hash
4511 function to return the string given the index. */
4513 && (finfo
->info
->strip
== strip_some
4514 || finfo
->info
->discard
== discard_l
)
4515 && (debug_index
== NULL
|| *debug_index
== (unsigned long) -1))
4518 char buf
[SYMNMLEN
+ 1];
4520 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, buf
);
4525 if ((finfo
->info
->strip
== strip_some
4526 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false,
4528 || (finfo
->info
->discard
== discard_l
4529 && (isym
.n_sclass
!= C_EXT
4530 && (isym
.n_sclass
!= C_HIDEXT
4531 || smtyp
!= XTY_SD
))
4532 && bfd_is_local_label_name (input_bfd
, name
)))
4536 /* We can not skip the first TOC anchor. */
4539 && finfo
->info
->strip
!= strip_all
)
4542 /* We now know whether we are to skip this symbol or not. */
4545 /* Adjust the symbol in order to output it. */
4547 if (isym
._n
._n_n
._n_zeroes
== 0
4548 && isym
._n
._n_n
._n_offset
!= 0)
4550 /* This symbol has a long name. Enter it in the string
4551 table we are building. If *debug_index != -1, the
4552 name has already been entered in the .debug section. */
4553 if (debug_index
!= NULL
&& *debug_index
!= (unsigned long) -1)
4554 isym
._n
._n_n
._n_offset
= *debug_index
;
4560 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
,
4565 indx
= _bfd_stringtab_add (finfo
->strtab
, name
, hash
, copy
);
4566 if (indx
== (bfd_size_type
) -1)
4568 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
4572 if (isym
.n_sclass
!= C_BSTAT
4573 && isym
.n_sclass
!= C_ESTAT
4574 && isym
.n_sclass
!= C_DECL
4575 && isym
.n_scnum
> 0)
4577 isym
.n_scnum
= (*csectpp
)->output_section
->target_index
;
4578 isym
.n_value
+= ((*csectpp
)->output_section
->vma
4579 + (*csectpp
)->output_offset
4583 /* The value of a C_FILE symbol is the symbol index of the
4584 next C_FILE symbol. The value of the last C_FILE symbol
4585 is -1. We try to get this right, below, just before we
4586 write the symbols out, but in the general case we may
4587 have to write the symbol out twice. */
4588 if (isym
.n_sclass
== C_FILE
)
4590 if (finfo
->last_file_index
!= -1
4591 && finfo
->last_file
.n_value
!= (bfd_vma
) output_index
)
4593 /* We must correct the value of the last C_FILE entry. */
4594 finfo
->last_file
.n_value
= output_index
;
4595 if ((bfd_size_type
) finfo
->last_file_index
>= syment_base
)
4597 /* The last C_FILE symbol is in this input file. */
4598 bfd_coff_swap_sym_out (output_bfd
,
4599 (PTR
) &finfo
->last_file
,
4600 (PTR
) (finfo
->outsyms
4601 + ((finfo
->last_file_index
4607 /* We have already written out the last C_FILE
4608 symbol. We need to write it out again. We
4609 borrow *outsym temporarily. */
4612 bfd_coff_swap_sym_out (output_bfd
,
4613 (PTR
) &finfo
->last_file
,
4616 pos
= obj_sym_filepos (output_bfd
);
4617 pos
+= finfo
->last_file_index
* osymesz
;
4618 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4619 || (bfd_bwrite (outsym
, osymesz
, output_bfd
)
4625 finfo
->last_file_index
= output_index
;
4626 finfo
->last_file
= isym
;
4629 /* The value of a C_BINCL or C_EINCL symbol is a file offset
4630 into the line numbers. We update the symbol values when
4631 we handle the line numbers. */
4632 if (isym
.n_sclass
== C_BINCL
4633 || isym
.n_sclass
== C_EINCL
)
4635 isym
.n_value
= finfo
->line_filepos
;
4639 /* Output the symbol. */
4641 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
, (PTR
) outsym
);
4643 *indexp
= output_index
;
4645 if (isym
.n_sclass
== C_EXT
)
4648 struct xcoff_link_hash_entry
*h
;
4650 indx
= ((esym
- (bfd_byte
*) obj_coff_external_syms (input_bfd
))
4652 h
= obj_xcoff_sym_hashes (input_bfd
)[indx
];
4653 BFD_ASSERT (h
!= NULL
);
4654 h
->indx
= output_index
;
4657 /* If this is a symbol in the TOC which we may have merged
4658 (class XMC_TC), remember the symbol index of the TOC
4660 if (isym
.n_sclass
== C_HIDEXT
4661 && aux
.x_csect
.x_smclas
== XMC_TC
4662 && *sym_hash
!= NULL
)
4664 BFD_ASSERT (((*sym_hash
)->flags
& XCOFF_SET_TOC
) == 0);
4665 BFD_ASSERT ((*sym_hash
)->toc_section
!= NULL
);
4666 (*sym_hash
)->u
.toc_indx
= output_index
;
4669 output_index
+= add
;
4670 outsym
+= add
* osymesz
;
4673 esym
+= add
* isymesz
;
4677 if (debug_index
!= NULL
)
4680 for (--add
; add
> 0; --add
)
4684 /* Fix up the aux entries and the C_BSTAT symbols. This must be
4685 done in a separate pass, because we don't know the correct symbol
4686 indices until we have already decided which symbols we are going
4689 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
4690 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
4691 isymp
= finfo
->internal_syms
;
4692 indexp
= finfo
->sym_indices
;
4693 csectpp
= xcoff_data (input_bfd
)->csects
;
4694 outsym
= finfo
->outsyms
;
4695 while (esym
< esym_end
)
4699 add
= 1 + isymp
->n_numaux
;
4702 esym
+= add
* isymesz
;
4707 if (isymp
->n_sclass
== C_BSTAT
)
4709 struct internal_syment isym
;
4713 /* The value of a C_BSTAT symbol is the symbol table
4714 index of the containing csect. */
4715 bfd_coff_swap_sym_in (output_bfd
, (PTR
) outsym
, (PTR
) &isym
);
4716 indx
= isym
.n_value
;
4717 if (indx
< obj_raw_syment_count (input_bfd
))
4721 symindx
= finfo
->sym_indices
[indx
];
4725 isym
.n_value
= symindx
;
4726 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
,
4734 for (i
= 0; i
< isymp
->n_numaux
&& esym
< esym_end
; i
++)
4736 union internal_auxent aux
;
4738 bfd_coff_swap_aux_in (input_bfd
, (PTR
) esym
, isymp
->n_type
,
4739 isymp
->n_sclass
, i
, isymp
->n_numaux
,
4742 if (isymp
->n_sclass
== C_FILE
)
4744 /* This is the file name (or some comment put in by
4745 the compiler). If it is long, we must put it in
4746 the string table. */
4747 if (aux
.x_file
.x_n
.x_zeroes
== 0
4748 && aux
.x_file
.x_n
.x_offset
!= 0)
4750 const char *filename
;
4753 BFD_ASSERT (aux
.x_file
.x_n
.x_offset
4754 >= STRING_SIZE_SIZE
);
4755 if (strings
== NULL
)
4757 strings
= _bfd_coff_read_string_table (input_bfd
);
4758 if (strings
== NULL
)
4761 filename
= strings
+ aux
.x_file
.x_n
.x_offset
;
4762 indx
= _bfd_stringtab_add (finfo
->strtab
, filename
,
4764 if (indx
== (bfd_size_type
) -1)
4766 aux
.x_file
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
4769 else if ((isymp
->n_sclass
== C_EXT
4770 || isymp
->n_sclass
== C_HIDEXT
)
4771 && i
+ 1 == isymp
->n_numaux
)
4774 /* We don't support type checking. I don't know if
4776 aux
.x_csect
.x_parmhash
= 0;
4777 /* I don't think anybody uses these fields, but we'd
4778 better clobber them just in case. */
4779 aux
.x_csect
.x_stab
= 0;
4780 aux
.x_csect
.x_snstab
= 0;
4782 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_LD
)
4786 indx
= aux
.x_csect
.x_scnlen
.l
;
4787 if (indx
< obj_raw_syment_count (input_bfd
))
4791 symindx
= finfo
->sym_indices
[indx
];
4794 aux
.x_csect
.x_scnlen
.l
= 0;
4798 aux
.x_csect
.x_scnlen
.l
= symindx
;
4803 else if (isymp
->n_sclass
!= C_STAT
|| isymp
->n_type
!= T_NULL
)
4807 if (ISFCN (isymp
->n_type
)
4808 || ISTAG (isymp
->n_sclass
)
4809 || isymp
->n_sclass
== C_BLOCK
4810 || isymp
->n_sclass
== C_FCN
)
4812 indx
= aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
4814 && indx
< obj_raw_syment_count (input_bfd
))
4816 /* We look forward through the symbol for
4817 the index of the next symbol we are going
4818 to include. I don't know if this is
4820 while (finfo
->sym_indices
[indx
] < 0
4821 && indx
< obj_raw_syment_count (input_bfd
))
4823 if (indx
>= obj_raw_syment_count (input_bfd
))
4824 indx
= output_index
;
4826 indx
= finfo
->sym_indices
[indx
];
4827 aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= indx
;
4832 indx
= aux
.x_sym
.x_tagndx
.l
;
4833 if (indx
> 0 && indx
< obj_raw_syment_count (input_bfd
))
4837 symindx
= finfo
->sym_indices
[indx
];
4839 aux
.x_sym
.x_tagndx
.l
= 0;
4841 aux
.x_sym
.x_tagndx
.l
= symindx
;
4846 /* Copy over the line numbers, unless we are stripping
4847 them. We do this on a symbol by symbol basis in
4848 order to more easily handle garbage collection. */
4849 if ((isymp
->n_sclass
== C_EXT
4850 || isymp
->n_sclass
== C_HIDEXT
)
4852 && isymp
->n_numaux
> 1
4853 && ISFCN (isymp
->n_type
)
4854 && aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
4856 if (finfo
->info
->strip
!= strip_none
4857 && finfo
->info
->strip
!= strip_some
)
4858 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
4861 asection
*enclosing
;
4862 unsigned int enc_count
;
4863 bfd_signed_vma linoff
;
4864 struct internal_lineno lin
;
4867 enclosing
= xcoff_section_data (abfd
, o
)->enclosing
;
4868 enc_count
= xcoff_section_data (abfd
, o
)->lineno_count
;
4869 if (oline
!= enclosing
)
4871 file_ptr pos
= enclosing
->line_filepos
;
4872 bfd_size_type amt
= linesz
* enc_count
;
4873 if (bfd_seek (input_bfd
, pos
, SEEK_SET
) != 0
4874 || (bfd_bread (finfo
->linenos
, amt
, input_bfd
)
4880 linoff
= (aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
4881 - enclosing
->line_filepos
);
4883 bfd_coff_swap_lineno_in (input_bfd
,
4884 (PTR
) (finfo
->linenos
+ linoff
),
4887 || ((bfd_size_type
) lin
.l_addr
.l_symndx
4891 obj_coff_external_syms (input_bfd
)))
4893 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
4896 bfd_byte
*linpend
, *linp
;
4898 bfd_size_type count
;
4900 lin
.l_addr
.l_symndx
= *indexp
;
4901 bfd_coff_swap_lineno_out (output_bfd
, (PTR
) &lin
,
4902 (PTR
) (finfo
->linenos
4905 linpend
= (finfo
->linenos
4906 + enc_count
* linesz
);
4907 offset
= (o
->output_section
->vma
4910 for (linp
= finfo
->linenos
+ linoff
+ linesz
;
4914 bfd_coff_swap_lineno_in (input_bfd
, (PTR
) linp
,
4916 if (lin
.l_lnno
== 0)
4918 lin
.l_addr
.l_paddr
+= offset
;
4919 bfd_coff_swap_lineno_out (output_bfd
,
4924 count
= (linp
- (finfo
->linenos
+ linoff
)) / linesz
;
4926 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
4927 (o
->output_section
->line_filepos
4928 + o
->output_section
->lineno_count
* linesz
);
4930 if (bfd_seek (output_bfd
,
4931 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
,
4933 || (bfd_bwrite (finfo
->linenos
+ linoff
,
4934 linesz
* count
, output_bfd
)
4938 o
->output_section
->lineno_count
+= count
;
4942 struct internal_syment
*iisp
, *iispend
;
4947 /* Update any C_BINCL or C_EINCL symbols
4948 that refer to a line number in the
4949 range we just output. */
4950 iisp
= finfo
->internal_syms
;
4952 + obj_raw_syment_count (input_bfd
));
4953 iindp
= finfo
->sym_indices
;
4954 oos
= finfo
->outsyms
;
4955 while (iisp
< iispend
)
4958 && (iisp
->n_sclass
== C_BINCL
4959 || iisp
->n_sclass
== C_EINCL
)
4960 && ((bfd_size_type
) iisp
->n_value
4961 >= (bfd_size_type
)(enclosing
->line_filepos
+ linoff
))
4962 && ((bfd_size_type
) iisp
->n_value
4963 < (enclosing
->line_filepos
4964 + enc_count
* linesz
)))
4966 struct internal_syment iis
;
4968 bfd_coff_swap_sym_in (output_bfd
,
4973 - enclosing
->line_filepos
4975 + aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
);
4976 bfd_coff_swap_sym_out (output_bfd
,
4982 iiadd
= 1 + iisp
->n_numaux
;
4984 oos
+= iiadd
* osymesz
;
4993 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &aux
, isymp
->n_type
,
4994 isymp
->n_sclass
, i
, isymp
->n_numaux
,
5006 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
5007 symbol will be the first symbol in the next input file. In the
5008 normal case, this will save us from writing out the C_FILE symbol
5010 if (finfo
->last_file_index
!= -1
5011 && (bfd_size_type
) finfo
->last_file_index
>= syment_base
)
5013 finfo
->last_file
.n_value
= output_index
;
5014 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &finfo
->last_file
,
5015 (PTR
) (finfo
->outsyms
5016 + ((finfo
->last_file_index
- syment_base
)
5020 /* Write the modified symbols to the output file. */
5021 if (outsym
> finfo
->outsyms
)
5023 file_ptr pos
= obj_sym_filepos (output_bfd
) + syment_base
* osymesz
;
5024 bfd_size_type amt
= outsym
- finfo
->outsyms
;
5025 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5026 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
5029 BFD_ASSERT ((obj_raw_syment_count (output_bfd
)
5030 + (outsym
- finfo
->outsyms
) / osymesz
)
5033 obj_raw_syment_count (output_bfd
) = output_index
;
5036 /* Don't let the linker relocation routines discard the symbols. */
5037 keep_syms
= obj_coff_keep_syms (input_bfd
);
5038 obj_coff_keep_syms (input_bfd
) = true;
5040 /* Relocate the contents of each section. */
5041 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5046 if (! o
->linker_mark
)
5048 /* This section was omitted from the link. */
5052 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5053 || o
->_raw_size
== 0
5054 || (o
->flags
& SEC_IN_MEMORY
) != 0)
5057 /* We have set filepos correctly for the sections we created to
5058 represent csects, so bfd_get_section_contents should work. */
5059 if (coff_section_data (input_bfd
, o
) != NULL
5060 && coff_section_data (input_bfd
, o
)->contents
!= NULL
)
5061 contents
= coff_section_data (input_bfd
, o
)->contents
;
5063 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
5064 (file_ptr
) 0, o
->_raw_size
))
5066 contents
= finfo
->contents
;
5069 if ((o
->flags
& SEC_RELOC
) != 0)
5072 struct internal_reloc
*internal_relocs
;
5073 struct internal_reloc
*irel
;
5075 struct internal_reloc
*irelend
;
5076 struct xcoff_link_hash_entry
**rel_hash
;
5079 /* Read in the relocs. */
5080 target_index
= o
->output_section
->target_index
;
5081 internal_relocs
= (xcoff_read_internal_relocs
5082 (input_bfd
, o
, false, finfo
->external_relocs
,
5084 (finfo
->section_info
[target_index
].relocs
5085 + o
->output_section
->reloc_count
)));
5086 if (internal_relocs
== NULL
)
5089 /* Call processor specific code to relocate the section
5091 if (! bfd_coff_relocate_section (output_bfd
, finfo
->info
,
5095 finfo
->internal_syms
,
5096 xcoff_data (input_bfd
)->csects
))
5099 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
5100 irel
= internal_relocs
;
5101 irelend
= irel
+ o
->reloc_count
;
5102 rel_hash
= (finfo
->section_info
[target_index
].rel_hashes
5103 + o
->output_section
->reloc_count
);
5104 for (; irel
< irelend
; irel
++, rel_hash
++)
5106 struct xcoff_link_hash_entry
*h
= NULL
;
5107 struct internal_ldrel ldrel
;
5112 /* Adjust the reloc address and symbol index. */
5114 irel
->r_vaddr
+= offset
;
5116 r_symndx
= irel
->r_symndx
;
5121 h
= obj_xcoff_sym_hashes (input_bfd
)[r_symndx
];
5123 if (r_symndx
!= -1 && finfo
->info
->strip
!= strip_all
)
5126 && h
->smclas
!= XMC_TD
5127 && (irel
->r_type
== R_TOC
5128 || irel
->r_type
== R_GL
5129 || irel
->r_type
== R_TCL
5130 || irel
->r_type
== R_TRL
5131 || irel
->r_type
== R_TRLA
))
5133 /* This is a TOC relative reloc with a symbol
5134 attached. The symbol should be the one which
5135 this reloc is for. We want to make this
5136 reloc against the TOC address of the symbol,
5137 not the symbol itself. */
5138 BFD_ASSERT (h
->toc_section
!= NULL
);
5139 BFD_ASSERT ((h
->flags
& XCOFF_SET_TOC
) == 0);
5140 if (h
->u
.toc_indx
!= -1)
5141 irel
->r_symndx
= h
->u
.toc_indx
;
5144 struct xcoff_toc_rel_hash
*n
;
5145 struct xcoff_link_section_info
*si
;
5148 amt
= sizeof (struct xcoff_toc_rel_hash
);
5149 n
= ((struct xcoff_toc_rel_hash
*)
5150 bfd_alloc (finfo
->output_bfd
, amt
));
5153 si
= finfo
->section_info
+ target_index
;
5154 n
->next
= si
->toc_rel_hashes
;
5157 si
->toc_rel_hashes
= n
;
5162 /* This is a global symbol. */
5164 irel
->r_symndx
= h
->indx
;
5167 /* This symbol is being written at the end
5168 of the file, and we do not yet know the
5169 symbol index. We save the pointer to the
5170 hash table entry in the rel_hash list.
5171 We set the indx field to -2 to indicate
5172 that this symbol must not be stripped. */
5181 indx
= finfo
->sym_indices
[r_symndx
];
5185 struct internal_syment
*is
;
5187 /* Relocations against a TC0 TOC anchor are
5188 automatically transformed to be against
5189 the TOC anchor in the output file. */
5190 is
= finfo
->internal_syms
+ r_symndx
;
5191 if (is
->n_sclass
== C_HIDEXT
5192 && is
->n_numaux
> 0)
5195 union internal_auxent aux
;
5199 obj_coff_external_syms (input_bfd
))
5200 + ((r_symndx
+ is
->n_numaux
)
5202 bfd_coff_swap_aux_in (input_bfd
, auxptr
,
5203 is
->n_type
, is
->n_sclass
,
5207 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_SD
5208 && aux
.x_csect
.x_smclas
== XMC_TC0
)
5209 indx
= finfo
->toc_symindx
;
5214 irel
->r_symndx
= indx
;
5218 struct internal_syment
*is
;
5221 char buf
[SYMNMLEN
+ 1];
5223 /* This reloc is against a symbol we are
5224 stripping. It would be possible to handle
5225 this case, but I don't think it's worth it. */
5226 is
= finfo
->internal_syms
+ r_symndx
;
5228 name
= (_bfd_coff_internal_syment_name
5229 (input_bfd
, is
, buf
));
5234 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
5235 (finfo
->info
, name
, input_bfd
, o
,
5243 switch (irel
->r_type
)
5247 || h
->root
.type
== bfd_link_hash_defined
5248 || h
->root
.type
== bfd_link_hash_defweak
5249 || h
->root
.type
== bfd_link_hash_common
)
5256 /* This reloc needs to be copied into the .loader
5258 ldrel
.l_vaddr
= irel
->r_vaddr
;
5260 ldrel
.l_symndx
= -(bfd_size_type
) 1;
5262 || (h
->root
.type
== bfd_link_hash_defined
5263 || h
->root
.type
== bfd_link_hash_defweak
5264 || h
->root
.type
== bfd_link_hash_common
))
5269 sec
= xcoff_data (input_bfd
)->csects
[r_symndx
];
5270 else if (h
->root
.type
== bfd_link_hash_common
)
5271 sec
= h
->root
.u
.c
.p
->section
;
5273 sec
= h
->root
.u
.def
.section
;
5274 sec
= sec
->output_section
;
5276 if (strcmp (sec
->name
, ".text") == 0)
5278 else if (strcmp (sec
->name
, ".data") == 0)
5280 else if (strcmp (sec
->name
, ".bss") == 0)
5284 (*_bfd_error_handler
)
5285 (_("%s: loader reloc in unrecognized section `%s'"),
5286 bfd_archive_filename (input_bfd
),
5288 bfd_set_error (bfd_error_nonrepresentable_section
);
5294 if (! finfo
->info
->relocateable
5295 && (h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
5296 && (h
->flags
& XCOFF_IMPORT
) == 0)
5298 /* We already called the undefined_symbol
5299 callback for this relocation, in
5300 _bfd_ppc_xcoff_relocate_section. Don't
5301 issue any more warnings. */
5304 if (h
->ldindx
< 0 && ! quiet
)
5306 (*_bfd_error_handler
)
5307 (_("%s: `%s' in loader reloc but not loader sym"),
5308 bfd_archive_filename (input_bfd
),
5309 h
->root
.root
.string
);
5310 bfd_set_error (bfd_error_bad_value
);
5313 ldrel
.l_symndx
= h
->ldindx
;
5315 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
5316 ldrel
.l_rsecnm
= o
->output_section
->target_index
;
5317 if (xcoff_hash_table (finfo
->info
)->textro
5318 && strcmp (o
->output_section
->name
, ".text") == 0
5321 (*_bfd_error_handler
)
5322 (_("%s: loader reloc in read-only section %s"),
5323 bfd_archive_filename (input_bfd
),
5324 bfd_get_section_name (finfo
->output_bfd
,
5325 o
->output_section
));
5326 bfd_set_error (bfd_error_invalid_operation
);
5329 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
,
5332 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5340 /* We should never need a .loader reloc for a TOC
5346 o
->output_section
->reloc_count
+= o
->reloc_count
;
5349 /* Write out the modified section contents. */
5350 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
5351 contents
, (file_ptr
) o
->output_offset
,
5352 (o
->_cooked_size
!= 0
5358 obj_coff_keep_syms (input_bfd
) = keep_syms
;
5360 if (! finfo
->info
->keep_memory
)
5362 if (! _bfd_coff_free_symbols (input_bfd
))
5372 /* Write out a non-XCOFF global symbol. */
5376 xcoff_write_global_symbol (h
, inf
)
5377 struct xcoff_link_hash_entry
*h
;
5380 struct xcoff_final_link_info
*finfo
= (struct xcoff_final_link_info
*) inf
;
5383 struct internal_syment isym
;
5384 union internal_auxent aux
;
5389 output_bfd
= finfo
->output_bfd
;
5390 outsym
= finfo
->outsyms
;
5392 if (h
->root
.type
== bfd_link_hash_warning
)
5394 h
= (struct xcoff_link_hash_entry
*) h
->root
.u
.i
.link
;
5395 if (h
->root
.type
== bfd_link_hash_new
)
5399 /* If this symbol was garbage collected, just skip it. */
5400 if (xcoff_hash_table (finfo
->info
)->gc
5401 && (h
->flags
& XCOFF_MARK
) == 0)
5404 /* If we need a .loader section entry, write it out. */
5405 if (h
->ldsym
!= NULL
)
5407 struct internal_ldsym
*ldsym
;
5412 if (h
->root
.type
== bfd_link_hash_undefined
5413 || h
->root
.type
== bfd_link_hash_undefweak
)
5417 ldsym
->l_scnum
= N_UNDEF
;
5418 ldsym
->l_smtype
= XTY_ER
;
5419 impbfd
= h
->root
.u
.undef
.abfd
;
5422 else if (h
->root
.type
== bfd_link_hash_defined
5423 || h
->root
.type
== bfd_link_hash_defweak
)
5428 sec
= h
->root
.u
.def
.section
;
5429 ldsym
->l_value
= (sec
->output_section
->vma
5430 + sec
->output_offset
5431 + h
->root
.u
.def
.value
);
5432 ldsym
->l_scnum
= sec
->output_section
->target_index
;
5433 ldsym
->l_smtype
= XTY_SD
;
5434 impbfd
= sec
->owner
;
5440 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
5441 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
5442 || (h
->flags
& XCOFF_IMPORT
) != 0)
5445 Import symbols are defined so the check above will make
5446 the l_smtype XTY_SD. But this is not correct, it should
5448 ldsym
->l_smtype
|= L_IMPORT
;
5451 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
5452 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
5453 || (h
->flags
& XCOFF_EXPORT
) != 0)
5455 ldsym
->l_smtype
|= L_EXPORT
;
5458 if ((h
->flags
& XCOFF_ENTRY
) != 0)
5460 ldsym
->l_smtype
|= L_ENTRY
;
5463 if ((h
->flags
& XCOFF_RTINIT
) != 0)
5465 ldsym
->l_smtype
= XTY_SD
;
5468 ldsym
->l_smclas
= h
->smclas
;
5470 if (ldsym
->l_smtype
& L_IMPORT
)
5472 if ((h
->root
.type
== bfd_link_hash_defined
5473 || h
->root
.type
== bfd_link_hash_defweak
)
5474 && (h
->root
.u
.def
.value
!= 0))
5476 ldsym
->l_smclas
= XMC_XO
;
5478 else if ((h
->flags
& (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
)) ==
5479 (XCOFF_SYSCALL32
| XCOFF_SYSCALL64
))
5481 ldsym
->l_smclas
= XMC_SV3264
;
5483 else if (h
->flags
& XCOFF_SYSCALL32
)
5485 ldsym
->l_smclas
= XMC_SV
;
5487 else if (h
->flags
& XCOFF_SYSCALL64
)
5489 ldsym
->l_smclas
= XMC_SV64
;
5493 if (ldsym
->l_ifile
== -(bfd_size_type
) 1)
5497 else if (ldsym
->l_ifile
== 0)
5499 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
5503 else if (impbfd
== NULL
)
5509 BFD_ASSERT (impbfd
->xvec
== output_bfd
->xvec
);
5510 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
5516 BFD_ASSERT (h
->ldindx
>= 0);
5518 bfd_xcoff_swap_ldsym_out (output_bfd
, ldsym
,
5521 * bfd_xcoff_ldsymsz(finfo
->output_bfd
)));
5525 /* If this symbol needs global linkage code, write it out. */
5526 if (h
->root
.type
== bfd_link_hash_defined
5527 && (h
->root
.u
.def
.section
5528 == xcoff_hash_table (finfo
->info
)->linkage_section
))
5534 p
= h
->root
.u
.def
.section
->contents
+ h
->root
.u
.def
.value
;
5536 /* The first instruction in the global linkage code loads a
5537 specific TOC element. */
5538 tocoff
= (h
->descriptor
->toc_section
->output_section
->vma
5539 + h
->descriptor
->toc_section
->output_offset
5540 - xcoff_data (output_bfd
)->toc
);
5542 if ((h
->descriptor
->flags
& XCOFF_SET_TOC
) != 0)
5544 tocoff
+= h
->descriptor
->u
.toc_offset
;
5548 /* The first instruction in the glink code needs to be
5549 cooked to to hold the correct offset in the toc. The
5550 rest are just output raw. */
5551 bfd_put_32 (output_bfd
,
5552 bfd_xcoff_glink_code(output_bfd
, 0) | (tocoff
& 0xffff), p
);
5554 /* Start with i == 1 to get past the first instruction done above
5555 The /4 is because the glink code is in bytes and we are going
5557 for (i
= 1; i
< bfd_xcoff_glink_code_size(output_bfd
) / 4; i
++)
5559 bfd_put_32 (output_bfd
,
5560 (bfd_vma
) bfd_xcoff_glink_code(output_bfd
, i
),
5565 /* If we created a TOC entry for this symbol, write out the required
5567 if ((h
->flags
& XCOFF_SET_TOC
) != 0)
5572 struct internal_reloc
*irel
;
5573 struct internal_ldrel ldrel
;
5574 struct internal_syment irsym
;
5575 union internal_auxent iraux
;
5577 tocsec
= h
->toc_section
;
5578 osec
= tocsec
->output_section
;
5579 oindx
= osec
->target_index
;
5580 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
5581 irel
->r_vaddr
= (osec
->vma
5582 + tocsec
->output_offset
5588 irel
->r_symndx
= h
->indx
;
5593 irel
->r_symndx
= obj_raw_syment_count (output_bfd
);
5596 BFD_ASSERT (h
->ldindx
>= 0);
5598 /* Initialize the aux union here instead of closer to when it is
5599 written out below because the length of the csect depends on
5600 whether the output is 32 or 64 bit. */
5601 memset (&iraux
, 0, sizeof iraux
);
5602 iraux
.x_csect
.x_smtyp
= XTY_SD
;
5603 /* iraux.x_csect.x_scnlen.l = 4 or 8, see below */
5604 iraux
.x_csect
.x_smclas
= XMC_TC
;
5606 /* 32 bit uses a 32 bit R_POS to do the relocations
5607 64 bit uses a 64 bit R_POS to do the relocations
5609 Also needs to change the csect size : 4 for 32 bit, 8 for 64 bit
5611 Which one is determined by the backend. */
5612 if (bfd_xcoff_is_xcoff64 (output_bfd
))
5615 iraux
.x_csect
.x_scnlen
.l
= 8;
5617 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
5620 iraux
.x_csect
.x_scnlen
.l
= 4;
5626 irel
->r_type
= R_POS
;
5627 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5628 ++osec
->reloc_count
;
5630 ldrel
.l_vaddr
= irel
->r_vaddr
;
5631 ldrel
.l_symndx
= h
->ldindx
;
5632 ldrel
.l_rtype
= (irel
->r_size
<< 8) | R_POS
;
5633 ldrel
.l_rsecnm
= oindx
;
5634 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5635 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5637 /* We need to emit a symbol to define a csect which holds
5639 if (finfo
->info
->strip
!= strip_all
)
5642 result
= bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
,
5643 &irsym
, h
->root
.root
.string
);
5644 if (false == result
)
5649 irsym
.n_value
= irel
->r_vaddr
;
5650 irsym
.n_scnum
= osec
->target_index
;
5651 irsym
.n_sclass
= C_HIDEXT
;
5652 irsym
.n_type
= T_NULL
;
5655 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &irsym
, (PTR
) outsym
);
5656 outsym
+= bfd_coff_symesz (output_bfd
);
5658 /* note : iraux is initialized above */
5659 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &iraux
, T_NULL
, C_HIDEXT
,
5660 0, 1, (PTR
) outsym
);
5661 outsym
+= bfd_coff_auxesz (output_bfd
);
5665 /* We aren't going to write out the symbols below, so we
5666 need to write them out now. */
5667 pos
= obj_sym_filepos (output_bfd
);
5668 pos
+= (obj_raw_syment_count (output_bfd
)
5669 * bfd_coff_symesz (output_bfd
));
5670 amt
= outsym
- finfo
->outsyms
;
5671 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5672 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
5674 obj_raw_syment_count (output_bfd
) +=
5675 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
5677 outsym
= finfo
->outsyms
;
5682 /* If this symbol is a specially defined function descriptor, write
5683 it out. The first word is the address of the function code
5684 itself, the second word is the address of the TOC, and the third
5688 The addresses for the 32 bit will take 4 bytes and the addresses
5689 for 64 bit will take 8 bytes. Similar for the relocs. This type
5690 of logic was also done above to create a TOC entry in
5691 xcoff_write_global_symbol. */
5692 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
5693 && h
->root
.type
== bfd_link_hash_defined
5694 && (h
->root
.u
.def
.section
5695 == xcoff_hash_table (finfo
->info
)->descriptor_section
))
5701 struct xcoff_link_hash_entry
*hentry
;
5703 struct internal_reloc
*irel
;
5704 struct internal_ldrel ldrel
;
5706 unsigned int reloc_size
, byte_size
;
5708 if (bfd_xcoff_is_xcoff64 (output_bfd
))
5713 else if (bfd_xcoff_is_xcoff32 (output_bfd
))
5723 sec
= h
->root
.u
.def
.section
;
5724 osec
= sec
->output_section
;
5725 oindx
= osec
->target_index
;
5726 p
= sec
->contents
+ h
->root
.u
.def
.value
;
5728 hentry
= h
->descriptor
;
5729 BFD_ASSERT (hentry
!= NULL
5730 && (hentry
->root
.type
== bfd_link_hash_defined
5731 || hentry
->root
.type
== bfd_link_hash_defweak
));
5732 esec
= hentry
->root
.u
.def
.section
;
5734 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
5735 irel
->r_vaddr
= (osec
->vma
5736 + sec
->output_offset
5737 + h
->root
.u
.def
.value
);
5738 irel
->r_symndx
= esec
->output_section
->target_index
;
5739 irel
->r_type
= R_POS
;
5740 irel
->r_size
= reloc_size
;
5741 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5742 ++osec
->reloc_count
;
5744 ldrel
.l_vaddr
= irel
->r_vaddr
;
5745 if (strcmp (esec
->output_section
->name
, ".text") == 0)
5747 else if (strcmp (esec
->output_section
->name
, ".data") == 0)
5749 else if (strcmp (esec
->output_section
->name
, ".bss") == 0)
5753 (*_bfd_error_handler
)
5754 (_("%s: loader reloc in unrecognized section `%s'"),
5755 bfd_get_filename (output_bfd
),
5756 esec
->output_section
->name
);
5757 bfd_set_error (bfd_error_nonrepresentable_section
);
5760 ldrel
.l_rtype
= (reloc_size
<< 8) | R_POS
;
5761 ldrel
.l_rsecnm
= oindx
;
5762 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5763 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5765 /* There are three items to write out,
5766 the address of the code
5767 the address of the toc anchor
5768 the environment pointer.
5769 We are ignoring the environment pointer. So set it to zero. */
5770 if (bfd_xcoff_is_xcoff64 (output_bfd
))
5772 bfd_put_64 (output_bfd
,
5773 (esec
->output_section
->vma
+ esec
->output_offset
5774 + hentry
->root
.u
.def
.value
),
5776 bfd_put_64 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 8);
5777 bfd_put_64 (output_bfd
, (bfd_vma
) 0, p
+ 16);
5782 This logic was already called above so the error case where
5783 the backend is neither has already been checked. */
5784 bfd_put_32 (output_bfd
,
5785 (esec
->output_section
->vma
+ esec
->output_offset
5786 + hentry
->root
.u
.def
.value
),
5788 bfd_put_32 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 4);
5789 bfd_put_32 (output_bfd
, (bfd_vma
) 0, p
+ 8);
5792 tsec
= coff_section_from_bfd_index (output_bfd
,
5793 xcoff_data (output_bfd
)->sntoc
);
5796 irel
->r_vaddr
= (osec
->vma
5797 + sec
->output_offset
5798 + h
->root
.u
.def
.value
5800 irel
->r_symndx
= tsec
->output_section
->target_index
;
5801 irel
->r_type
= R_POS
;
5802 irel
->r_size
= reloc_size
;
5803 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5804 ++osec
->reloc_count
;
5806 ldrel
.l_vaddr
= irel
->r_vaddr
;
5807 if (strcmp (tsec
->output_section
->name
, ".text") == 0)
5809 else if (strcmp (tsec
->output_section
->name
, ".data") == 0)
5811 else if (strcmp (tsec
->output_section
->name
, ".bss") == 0)
5815 (*_bfd_error_handler
)
5816 (_("%s: loader reloc in unrecognized section `%s'"),
5817 bfd_get_filename (output_bfd
),
5818 tsec
->output_section
->name
);
5819 bfd_set_error (bfd_error_nonrepresentable_section
);
5822 ldrel
.l_rtype
= (reloc_size
<< 8) | R_POS
;
5823 ldrel
.l_rsecnm
= oindx
;
5824 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5825 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
5828 if (h
->indx
>= 0 || finfo
->info
->strip
== strip_all
)
5830 BFD_ASSERT (outsym
== finfo
->outsyms
);
5835 && (finfo
->info
->strip
== strip_all
5836 || (finfo
->info
->strip
== strip_some
5837 && bfd_hash_lookup (finfo
->info
->keep_hash
, h
->root
.root
.string
,
5838 false, false) == NULL
)))
5840 BFD_ASSERT (outsym
== finfo
->outsyms
);
5845 && (h
->flags
& (XCOFF_REF_REGULAR
| XCOFF_DEF_REGULAR
)) == 0)
5847 BFD_ASSERT (outsym
== finfo
->outsyms
);
5851 memset (&aux
, 0, sizeof aux
);
5853 h
->indx
= obj_raw_syment_count (output_bfd
);
5855 result
= bfd_xcoff_put_symbol_name (output_bfd
, finfo
->strtab
, &isym
,
5856 h
->root
.root
.string
);
5857 if (false == result
)
5862 if (h
->root
.type
== bfd_link_hash_undefined
5863 || h
->root
.type
== bfd_link_hash_undefweak
)
5866 isym
.n_scnum
= N_UNDEF
;
5867 isym
.n_sclass
= C_EXT
;
5868 aux
.x_csect
.x_smtyp
= XTY_ER
;
5870 else if ((h
->root
.type
== bfd_link_hash_defined
5871 || h
->root
.type
== bfd_link_hash_defweak
)
5872 && h
->smclas
== XMC_XO
)
5874 BFD_ASSERT (bfd_is_abs_section (h
->root
.u
.def
.section
));
5875 isym
.n_value
= h
->root
.u
.def
.value
;
5876 isym
.n_scnum
= N_UNDEF
;
5877 isym
.n_sclass
= C_EXT
;
5878 aux
.x_csect
.x_smtyp
= XTY_ER
;
5880 else if (h
->root
.type
== bfd_link_hash_defined
5881 || h
->root
.type
== bfd_link_hash_defweak
)
5883 struct xcoff_link_size_list
*l
;
5885 isym
.n_value
= (h
->root
.u
.def
.section
->output_section
->vma
5886 + h
->root
.u
.def
.section
->output_offset
5887 + h
->root
.u
.def
.value
);
5888 isym
.n_scnum
= h
->root
.u
.def
.section
->output_section
->target_index
;
5889 isym
.n_sclass
= C_HIDEXT
;
5890 aux
.x_csect
.x_smtyp
= XTY_SD
;
5892 if ((h
->flags
& XCOFF_HAS_SIZE
) != 0)
5894 for (l
= xcoff_hash_table (finfo
->info
)->size_list
;
5900 aux
.x_csect
.x_scnlen
.l
= l
->size
;
5906 else if (h
->root
.type
== bfd_link_hash_common
)
5908 isym
.n_value
= (h
->root
.u
.c
.p
->section
->output_section
->vma
5909 + h
->root
.u
.c
.p
->section
->output_offset
);
5910 isym
.n_scnum
= h
->root
.u
.c
.p
->section
->output_section
->target_index
;
5911 isym
.n_sclass
= C_EXT
;
5912 aux
.x_csect
.x_smtyp
= XTY_CM
;
5913 aux
.x_csect
.x_scnlen
.l
= h
->root
.u
.c
.size
;
5918 isym
.n_type
= T_NULL
;
5921 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
, (PTR
) outsym
);
5922 outsym
+= bfd_coff_symesz (output_bfd
);
5924 aux
.x_csect
.x_smclas
= h
->smclas
;
5925 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &aux
, T_NULL
, isym
.n_sclass
, 0, 1,
5927 outsym
+= bfd_coff_auxesz (output_bfd
);
5929 if ((h
->root
.type
== bfd_link_hash_defined
5930 || h
->root
.type
== bfd_link_hash_defweak
)
5931 && h
->smclas
!= XMC_XO
)
5933 /* We just output an SD symbol. Now output an LD symbol. */
5937 isym
.n_sclass
= C_EXT
;
5938 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
, (PTR
) outsym
);
5939 outsym
+= bfd_coff_symesz (output_bfd
);
5941 aux
.x_csect
.x_smtyp
= XTY_LD
;
5942 aux
.x_csect
.x_scnlen
.l
= obj_raw_syment_count (output_bfd
);
5943 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &aux
, T_NULL
, C_EXT
, 0, 1,
5945 outsym
+= bfd_coff_auxesz (output_bfd
);
5948 pos
= obj_sym_filepos (output_bfd
);
5949 pos
+= obj_raw_syment_count (output_bfd
) * bfd_coff_symesz (output_bfd
);
5950 amt
= outsym
- finfo
->outsyms
;
5951 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
5952 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
5954 obj_raw_syment_count (output_bfd
) +=
5955 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
5960 /* Handle a link order which is supposed to generate a reloc. */
5963 xcoff_reloc_link_order (output_bfd
, finfo
, output_section
, link_order
)
5965 struct xcoff_final_link_info
*finfo
;
5966 asection
*output_section
;
5967 struct bfd_link_order
*link_order
;
5969 reloc_howto_type
*howto
;
5970 struct xcoff_link_hash_entry
*h
;
5974 struct internal_reloc
*irel
;
5975 struct xcoff_link_hash_entry
**rel_hash_ptr
;
5976 struct internal_ldrel ldrel
;
5978 if (link_order
->type
== bfd_section_reloc_link_order
)
5980 /* We need to somehow locate a symbol in the right section. The
5981 symbol must either have a value of zero, or we must adjust
5982 the addend by the value of the symbol. FIXME: Write this
5983 when we need it. The old linker couldn't handle this anyhow. */
5987 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
5990 bfd_set_error (bfd_error_bad_value
);
5994 h
= ((struct xcoff_link_hash_entry
*)
5995 bfd_wrapped_link_hash_lookup (output_bfd
, finfo
->info
,
5996 link_order
->u
.reloc
.p
->u
.name
,
5997 false, false, true));
6000 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
6001 (finfo
->info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6002 (asection
*) NULL
, (bfd_vma
) 0)))
6007 if (h
->root
.type
== bfd_link_hash_common
)
6009 hsec
= h
->root
.u
.c
.p
->section
;
6012 else if (h
->root
.type
== bfd_link_hash_defined
6013 || h
->root
.type
== bfd_link_hash_defweak
)
6015 hsec
= h
->root
.u
.def
.section
;
6016 hval
= h
->root
.u
.def
.value
;
6024 addend
= link_order
->u
.reloc
.p
->addend
;
6026 addend
+= (hsec
->output_section
->vma
6027 + hsec
->output_offset
6034 bfd_reloc_status_type rstat
;
6037 size
= bfd_get_reloc_size (howto
);
6038 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6042 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
6048 case bfd_reloc_outofrange
:
6050 case bfd_reloc_overflow
:
6051 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
6052 (finfo
->info
, link_order
->u
.reloc
.p
->u
.name
,
6053 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
6061 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6062 (file_ptr
) link_order
->offset
, size
);
6068 /* Store the reloc information in the right place. It will get
6069 swapped and written out at the end of the final_link routine. */
6071 irel
= (finfo
->section_info
[output_section
->target_index
].relocs
6072 + output_section
->reloc_count
);
6073 rel_hash_ptr
= (finfo
->section_info
[output_section
->target_index
].rel_hashes
6074 + output_section
->reloc_count
);
6076 memset (irel
, 0, sizeof (struct internal_reloc
));
6077 *rel_hash_ptr
= NULL
;
6079 irel
->r_vaddr
= output_section
->vma
+ link_order
->offset
;
6082 irel
->r_symndx
= h
->indx
;
6085 /* Set the index to -2 to force this symbol to get written out. */
6091 irel
->r_type
= howto
->type
;
6092 irel
->r_size
= howto
->bitsize
- 1;
6093 if (howto
->complain_on_overflow
== complain_overflow_signed
)
6094 irel
->r_size
|= 0x80;
6096 ++output_section
->reloc_count
;
6098 /* Now output the reloc to the .loader section. */
6100 ldrel
.l_vaddr
= irel
->r_vaddr
;
6104 const char *secname
;
6106 secname
= hsec
->output_section
->name
;
6108 if (strcmp (secname
, ".text") == 0)
6110 else if (strcmp (secname
, ".data") == 0)
6112 else if (strcmp (secname
, ".bss") == 0)
6116 (*_bfd_error_handler
)
6117 (_("%s: loader reloc in unrecognized section `%s'"),
6118 bfd_get_filename (output_bfd
), secname
);
6119 bfd_set_error (bfd_error_nonrepresentable_section
);
6127 (*_bfd_error_handler
)
6128 (_("%s: `%s' in loader reloc but not loader sym"),
6129 bfd_get_filename (output_bfd
),
6130 h
->root
.root
.string
);
6131 bfd_set_error (bfd_error_bad_value
);
6134 ldrel
.l_symndx
= h
->ldindx
;
6137 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
6138 ldrel
.l_rsecnm
= output_section
->target_index
;
6139 bfd_xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
6140 finfo
->ldrel
+= bfd_xcoff_ldrelsz(output_bfd
);
6145 /* Sort relocs by VMA. This is called via qsort. */
6148 xcoff_sort_relocs (p1
, p2
)
6152 const struct internal_reloc
*r1
= (const struct internal_reloc
*) p1
;
6153 const struct internal_reloc
*r2
= (const struct internal_reloc
*) p2
;
6155 if (r1
->r_vaddr
> r2
->r_vaddr
)
6157 else if (r1
->r_vaddr
< r2
->r_vaddr
)