1 /* POWER/PowerPC XCOFF linker support.
2 Copyright 1995 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>, Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "coff/internal.h"
28 /* This file holds the XCOFF linker code. */
30 #define STRING_SIZE_SIZE (4)
32 /* Get the XCOFF hash table entries for a BFD. */
33 #define obj_xcoff_sym_hashes(bfd) \
34 ((struct xcoff_link_hash_entry **) obj_coff_sym_hashes (bfd))
36 /* XCOFF relocation types. These probably belong in a header file
37 somewhere. The relocations are described in the function
38 _bfd_ppc_xcoff_relocate_section in this file. */
54 #define R_RRTBI (0x14)
55 #define R_RRTBA (0x15)
63 /* The first word of global linkage code. This must be modified by
64 filling in the correct TOC offset. */
66 #define XCOFF_GLINK_FIRST (0x81820000) /* lwz r12,0(r2) */
68 /* The remaining words of global linkage code. */
70 static unsigned long xcoff_glink_code[] =
72 0x90410014, /* stw r2,20(r1) */
73 0x800c0000, /* lwz r0,0(r12) */
74 0x804c0004, /* lwz r2,4(r12) */
75 0x7c0903a6, /* mtctr r0 */
76 0x4e800420, /* bctr */
77 0x0, /* start of traceback table */
78 0x000c8000, /* traceback table */
79 0x0 /* traceback table */
82 #define XCOFF_GLINK_SIZE \
83 (((sizeof xcoff_glink_code / sizeof xcoff_glink_code[0]) * 4) + 4)
85 /* We reuse the SEC_ROM flag as a mark flag for garbage collection.
86 This flag will only be used on input sections. */
88 #define SEC_MARK (SEC_ROM)
90 /* The ldhdr structure. This appears at the start of the .loader
95 /* The version number: currently always 1. */
96 unsigned long l_version;
97 /* The number of symbol table entries. */
98 bfd_size_type l_nsyms;
99 /* The number of relocation table entries. */
100 bfd_size_type l_nreloc;
101 /* The length of the import file string table. */
102 bfd_size_type l_istlen;
103 /* The number of import files. */
104 bfd_size_type l_nimpid;
105 /* The offset from the start of the .loader section to the first
106 entry in the import file table. */
107 bfd_size_type l_impoff;
108 /* The length of the string table. */
109 bfd_size_type l_stlen;
110 /* The offset from the start of the .loader section to the first
111 entry in the string table. */
112 bfd_size_type l_stoff;
115 struct external_ldhdr
117 bfd_byte l_version[4];
119 bfd_byte l_nreloc[4];
120 bfd_byte l_istlen[4];
121 bfd_byte l_nimpid[4];
122 bfd_byte l_impoff[4];
127 #define LDHDRSZ (8 * 4)
129 /* The ldsym structure. This is used to represent a symbol in the
132 struct internal_ldsym
136 /* The symbol name if <= SYMNMLEN characters. */
137 char _l_name[SYMNMLEN];
140 /* Zero if the symbol name is more than SYMNMLEN characters. */
142 /* The offset in the string table if the symbol name is more
143 than SYMNMLEN characters. */
147 /* The symbol value. */
149 /* The symbol section number. */
151 /* The symbol type and flags. */
153 /* The symbol storage class. */
155 /* The import file ID. */
156 bfd_size_type l_ifile;
157 /* Offset to the parameter type check string. */
158 bfd_size_type l_parm;
161 struct external_ldsym
165 bfd_byte _l_name[SYMNMLEN];
168 bfd_byte _l_zeroes[4];
169 bfd_byte _l_offset[4];
174 bfd_byte l_smtype[1];
175 bfd_byte l_smclas[1];
180 #define LDSYMSZ (8 + 3 * 4 + 2 + 2)
182 /* These flags are for the l_smtype field (the lower three bits are an
185 /* Imported symbol. */
186 #define L_IMPORT (0x40)
188 #define L_ENTRY (0x20)
189 /* Exported symbol. */
190 #define L_EXPORT (0x10)
192 /* The ldrel structure. This is used to represent a reloc in the
195 struct internal_ldrel
197 /* The reloc address. */
199 /* The symbol table index in the .loader section symbol table. */
200 bfd_size_type l_symndx;
201 /* The relocation type and size. */
203 /* The section number this relocation applies to. */
207 struct external_ldrel
210 bfd_byte l_symndx[4];
212 bfd_byte l_rsecnm[2];
215 #define LDRELSZ (2 * 4 + 2 * 2)
217 /* The list of import files. */
219 struct xcoff_import_file
221 /* The next entry in the list. */
222 struct xcoff_import_file *next;
227 /* The member name. */
231 /* An entry in the XCOFF linker hash table. */
233 struct xcoff_link_hash_entry
235 struct bfd_link_hash_entry root;
237 /* Symbol index in output file. Set to -1 initially. Set to -2 if
238 there is a reloc against this symbol. */
241 /* If we have created a TOC entry for this symbol, this is the .tc
242 section which holds it. */
243 asection *toc_section;
247 /* If we have created a TOC entry (the XCOFF_SET_TOC flag is
248 set), this is the offset in toc_section. */
250 /* If the TOC entry comes from an input file, this is set to the
251 symbo lindex of the C_HIDEXT XMC_TC symbol. */
255 /* If this symbol is a function entry point which is called, this
256 field holds a pointer to the function descriptor. */
257 struct xcoff_link_hash_entry *descriptor;
259 /* The .loader symbol table entry, if there is one. */
260 struct internal_ldsym *ldsym;
262 /* The .loader symbol table index. */
265 /* Some linker flags. */
266 unsigned short flags;
267 /* Symbol is referenced by a regular object. */
268 #define XCOFF_REF_REGULAR (01)
269 /* Symbol is defined by a regular object. */
270 #define XCOFF_DEF_REGULAR (02)
271 /* Symbol is referenced by a dynamic object. */
272 #define XCOFF_REF_DYNAMIC (04)
273 /* Symbol is used in a reloc being copied into the .loader section. */
274 #define XCOFF_LDREL (010)
275 /* Symbol is the entry point. */
276 #define XCOFF_ENTRY (020)
277 /* Symbol is called; this is, it appears in a R_BR reloc. */
278 #define XCOFF_CALLED (040)
279 /* Symbol needs the TOC entry filled in. */
280 #define XCOFF_SET_TOC (0100)
281 /* Symbol is explicitly imported. */
282 #define XCOFF_IMPORT (0200)
283 /* Symbol is explicitly exported. */
284 #define XCOFF_EXPORT (0400)
285 /* Symbol has been processed by xcoff_build_ldsyms. */
286 #define XCOFF_BUILT_LDSYM (01000)
287 /* Symbol is mentioned by a section which was not garbage collected. */
288 #define XCOFF_MARK (02000)
290 /* The storage mapping class. */
291 unsigned char smclas;
294 /* The XCOFF linker hash table. */
296 struct xcoff_link_hash_table
298 struct bfd_link_hash_table root;
300 /* The .debug string hash table. We need to compute this while
301 reading the input files, so that we know how large the .debug
302 section will be before we assign section positions. */
303 struct bfd_strtab_hash *debug_strtab;
305 /* The .debug section we will use for the final output. */
306 asection *debug_section;
308 /* The .loader section we will use for the final output. */
309 asection *loader_section;
311 /* A count of non TOC relative relocs which will need to be
312 allocated in the .loader section. */
315 /* The .loader section header. */
316 struct internal_ldhdr ldhdr;
318 /* The .gl section we use to hold global linkage code. */
319 asection *linkage_section;
321 /* The .tc section we use to hold toc entries we build for global
323 asection *toc_section;
325 /* The list of import files. */
326 struct xcoff_import_file *imports;
328 /* Required alignment of sections within the output file. */
329 unsigned long file_align;
331 /* Whether the .text section must be read-only. */
334 /* Whether garbage collection was done. */
338 /* Information we keep for each section in the output file during the
341 struct xcoff_link_section_info
343 /* The relocs to be output. */
344 struct internal_reloc *relocs;
345 /* For each reloc against a global symbol whose index was not known
346 when the reloc was handled, the global hash table entry. */
347 struct xcoff_link_hash_entry **rel_hashes;
350 /* Information that we pass around while doing the final link step. */
352 struct xcoff_final_link_info
354 /* General link information. */
355 struct bfd_link_info *info;
358 /* Hash table for long symbol names. */
359 struct bfd_strtab_hash *strtab;
360 /* Array of information kept for each output section, indexed by the
361 target_index field. */
362 struct xcoff_link_section_info *section_info;
363 /* Symbol index of last C_FILE symbol (-1 if none). */
364 long last_file_index;
365 /* Contents of last C_FILE symbol. */
366 struct internal_syment last_file;
367 /* Symbol index of TOC symbol. */
369 /* Start of .loader symbols. */
370 struct external_ldsym *ldsym;
371 /* Next .loader reloc to swap out. */
372 struct external_ldrel *ldrel;
373 /* Buffer large enough to hold swapped symbols of any input file. */
374 struct internal_syment *internal_syms;
375 /* Buffer large enough to hold output indices of symbols of any
378 /* Buffer large enough to hold output symbols for any input file. */
380 /* Buffer large enough to hold external line numbers for any input
383 /* Buffer large enough to hold any input section. */
385 /* Buffer large enough to hold external relocs of any input section. */
386 bfd_byte *external_relocs;
389 static void xcoff_swap_ldhdr_out
390 PARAMS ((bfd *, const struct internal_ldhdr *, struct external_ldhdr *));
391 static void xcoff_swap_ldsym_out
392 PARAMS ((bfd *, const struct internal_ldsym *, struct external_ldsym *));
393 static void xcoff_swap_ldrel_out
394 PARAMS ((bfd *, const struct internal_ldrel *, struct external_ldrel *));
395 static struct bfd_hash_entry *xcoff_link_hash_newfunc
396 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
397 static struct internal_reloc *xcoff_read_internal_relocs
398 PARAMS ((bfd *, asection *, boolean, bfd_byte *, boolean,
399 struct internal_reloc *));
400 static boolean xcoff_link_add_object_symbols
401 PARAMS ((bfd *, struct bfd_link_info *));
402 static boolean xcoff_link_check_archive_element
403 PARAMS ((bfd *, struct bfd_link_info *, boolean *));
404 static boolean xcoff_link_check_ar_symbols
405 PARAMS ((bfd *, struct bfd_link_info *, boolean *));
406 static boolean xcoff_link_add_symbols PARAMS ((bfd *, struct bfd_link_info *));
407 static boolean xcoff_link_add_dynamic_symbols
408 PARAMS ((bfd *, struct bfd_link_info *));
409 static boolean xcoff_mark PARAMS ((struct bfd_link_info *, asection *));
410 static void xcoff_sweep PARAMS ((struct bfd_link_info *));
411 static boolean xcoff_build_ldsyms
412 PARAMS ((struct xcoff_link_hash_entry *, PTR));
413 static boolean xcoff_link_input_bfd
414 PARAMS ((struct xcoff_final_link_info *, bfd *));
415 static boolean xcoff_write_global_symbol
416 PARAMS ((struct xcoff_link_hash_entry *, PTR));
417 static boolean xcoff_reloc_link_order
418 PARAMS ((bfd *, struct xcoff_final_link_info *, asection *,
419 struct bfd_link_order *));
420 static int xcoff_sort_relocs PARAMS ((const PTR, const PTR));
422 /* Routines to swap information in the XCOFF .loader section. We only
423 need to swap this information out, not in. I believe that only the
424 loader needs to swap this information in. If we ever need to write
425 an XCOFF loader, this stuff will need to be moved to another file
426 shared by the linker (which XCOFF calls the ``binder'') and the
429 /* Swap out the ldhdr structure. */
432 xcoff_swap_ldhdr_out (abfd, src, dst)
434 const struct internal_ldhdr *src;
435 struct external_ldhdr *dst;
437 bfd_put_32 (abfd, src->l_version, dst->l_version);
438 bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
439 bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
440 bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
441 bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
442 bfd_put_32 (abfd, src->l_impoff, dst->l_impoff);
443 bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
444 bfd_put_32 (abfd, src->l_stoff, dst->l_stoff);
447 /* Swap out the ldsym structure. */
450 xcoff_swap_ldsym_out (abfd, src, dst)
452 const struct internal_ldsym *src;
453 struct external_ldsym *dst;
455 if (src->_l._l_l._l_zeroes != 0)
456 memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
459 bfd_put_32 (abfd, 0, dst->_l._l_l._l_zeroes);
460 bfd_put_32 (abfd, src->_l._l_l._l_offset, dst->_l._l_l._l_offset);
462 bfd_put_32 (abfd, src->l_value, dst->l_value);
463 bfd_put_16 (abfd, src->l_scnum, dst->l_scnum);
464 bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
465 bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
466 bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
467 bfd_put_32 (abfd, src->l_parm, dst->l_parm);
470 /* Swap out the ldrel structure. */
473 xcoff_swap_ldrel_out (abfd, src, dst)
475 const struct internal_ldrel *src;
476 struct external_ldrel *dst;
478 bfd_put_32 (abfd, src->l_vaddr, dst->l_vaddr);
479 bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
480 bfd_put_16 (abfd, src->l_rtype, dst->l_rtype);
481 bfd_put_16 (abfd, src->l_rsecnm, dst->l_rsecnm);
484 /* Routine to create an entry in an XCOFF link hash table. */
486 static struct bfd_hash_entry *
487 xcoff_link_hash_newfunc (entry, table, string)
488 struct bfd_hash_entry *entry;
489 struct bfd_hash_table *table;
492 struct xcoff_link_hash_entry *ret = (struct xcoff_link_hash_entry *) entry;
494 /* Allocate the structure if it has not already been allocated by a
496 if (ret == (struct xcoff_link_hash_entry *) NULL)
497 ret = ((struct xcoff_link_hash_entry *)
498 bfd_hash_allocate (table, sizeof (struct xcoff_link_hash_entry)));
499 if (ret == (struct xcoff_link_hash_entry *) NULL)
501 bfd_set_error (bfd_error_no_memory);
502 return (struct bfd_hash_entry *) ret;
505 /* Call the allocation method of the superclass. */
506 ret = ((struct xcoff_link_hash_entry *)
507 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
511 /* Set local fields. */
513 ret->toc_section = NULL;
514 ret->u.toc_indx = -1;
515 ret->descriptor = NULL;
519 ret->smclas = XMC_UA;
522 return (struct bfd_hash_entry *) ret;
525 /* Create a XCOFF link hash table. */
527 struct bfd_link_hash_table *
528 _bfd_xcoff_bfd_link_hash_table_create (abfd)
531 struct xcoff_link_hash_table *ret;
533 ret = ((struct xcoff_link_hash_table *)
534 bfd_alloc (abfd, sizeof (struct xcoff_link_hash_table)));
535 if (ret == (struct xcoff_link_hash_table *) NULL)
537 bfd_set_error (bfd_error_no_memory);
538 return (struct bfd_link_hash_table *) NULL;
540 if (! _bfd_link_hash_table_init (&ret->root, abfd, xcoff_link_hash_newfunc))
542 bfd_release (abfd, ret);
543 return (struct bfd_link_hash_table *) NULL;
546 ret->debug_strtab = _bfd_xcoff_stringtab_init ();
547 ret->debug_section = NULL;
548 ret->loader_section = NULL;
549 ret->ldrel_count = 0;
550 memset (&ret->ldhdr, 0, sizeof (struct internal_ldhdr));
551 ret->linkage_section = NULL;
552 ret->toc_section = NULL;
561 /* Look up an entry in an XCOFF link hash table. */
563 #define xcoff_link_hash_lookup(table, string, create, copy, follow) \
564 ((struct xcoff_link_hash_entry *) \
565 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy),\
568 /* Traverse an XCOFF link hash table. */
570 #define xcoff_link_hash_traverse(table, func, info) \
571 (bfd_link_hash_traverse \
573 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
576 /* Get the XCOFF link hash table from the info structure. This is
579 #define xcoff_hash_table(p) ((struct xcoff_link_hash_table *) ((p)->hash))
581 /* Read internal relocs for an XCOFF csect. This is a wrapper around
582 _bfd_coff_read_internal_relocs which tries to take advantage of any
583 relocs which may have been cached for the enclosing section. */
585 static struct internal_reloc *
586 xcoff_read_internal_relocs (abfd, sec, cache, external_relocs,
587 require_internal, internal_relocs)
591 bfd_byte *external_relocs;
592 boolean require_internal;
593 struct internal_reloc *internal_relocs;
595 if (coff_section_data (abfd, sec) != NULL
596 && coff_section_data (abfd, sec)->relocs == NULL
597 && xcoff_section_data (abfd, sec) != NULL)
601 enclosing = xcoff_section_data (abfd, sec)->enclosing;
603 if (enclosing != NULL
604 && (coff_section_data (abfd, enclosing) == NULL
605 || coff_section_data (abfd, enclosing)->relocs == NULL)
608 if (_bfd_coff_read_internal_relocs (abfd, enclosing, true,
609 external_relocs, false,
610 (struct internal_reloc *) NULL)
615 if (enclosing != NULL
616 && coff_section_data (abfd, enclosing) != NULL
617 && coff_section_data (abfd, enclosing)->relocs != NULL)
621 off = ((sec->rel_filepos - enclosing->rel_filepos)
622 / bfd_coff_relsz (abfd));
623 if (! require_internal)
624 return coff_section_data (abfd, enclosing)->relocs + off;
625 memcpy (internal_relocs,
626 coff_section_data (abfd, enclosing)->relocs + off,
627 sec->reloc_count * sizeof (struct internal_reloc));
628 return internal_relocs;
632 return _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
633 require_internal, internal_relocs);
636 /* Given an XCOFF BFD, add symbols to the global hash table as
640 _bfd_xcoff_bfd_link_add_symbols (abfd, info)
642 struct bfd_link_info *info;
644 switch (bfd_get_format (abfd))
647 return xcoff_link_add_object_symbols (abfd, info);
649 return (_bfd_generic_link_add_archive_symbols
650 (abfd, info, xcoff_link_check_archive_element));
652 bfd_set_error (bfd_error_wrong_format);
657 /* Add symbols from an XCOFF object file. */
660 xcoff_link_add_object_symbols (abfd, info)
662 struct bfd_link_info *info;
664 if (! _bfd_coff_get_external_symbols (abfd))
666 if (! xcoff_link_add_symbols (abfd, info))
668 if (! info->keep_memory)
670 if (! _bfd_coff_free_symbols (abfd))
676 /* Check a single archive element to see if we need to include it in
677 the link. *PNEEDED is set according to whether this element is
678 needed in the link or not. This is called via
679 _bfd_generic_link_add_archive_symbols. */
682 xcoff_link_check_archive_element (abfd, info, pneeded)
684 struct bfd_link_info *info;
687 if (! _bfd_coff_get_external_symbols (abfd))
690 if (! xcoff_link_check_ar_symbols (abfd, info, pneeded))
695 if (! xcoff_link_add_symbols (abfd, info))
699 if (! info->keep_memory || ! *pneeded)
701 if (! _bfd_coff_free_symbols (abfd))
708 /* Look through the symbols to see if this object file should be
709 included in the link. */
712 xcoff_link_check_ar_symbols (abfd, info, pneeded)
714 struct bfd_link_info *info;
717 bfd_size_type symesz;
723 symesz = bfd_coff_symesz (abfd);
724 esym = (bfd_byte *) obj_coff_external_syms (abfd);
725 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
726 while (esym < esym_end)
728 struct internal_syment sym;
730 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
732 if (sym.n_sclass == C_EXT && sym.n_scnum != N_UNDEF)
735 char buf[SYMNMLEN + 1];
736 struct bfd_link_hash_entry *h;
738 /* This symbol is externally visible, and is defined by this
741 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
744 h = bfd_link_hash_lookup (info->hash, name, false, false, true);
746 /* We are only interested in symbols that are currently
747 undefined. If a symbol is currently known to be common,
748 XCOFF linkers do not bring in an object file which
749 defines it. We also don't bring in symbols to satisfy
750 undefined references in shared objects. */
751 if (h != (struct bfd_link_hash_entry *) NULL
752 && h->type == bfd_link_hash_undefined)
754 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
761 esym += (sym.n_numaux + 1) * symesz;
764 /* We do not need this object file. */
768 /* Add all the symbols from an object file to the hash table.
770 XCOFF is a weird format. A normal XCOFF .o files will have three
771 COFF sections--.text, .data, and .bss--but each COFF section will
772 contain many csects. These csects are described in the symbol
773 table. From the linker's point of view, each csect must be
774 considered a section in its own right. For example, a TOC entry is
775 handled as a small XMC_TC csect. The linker must be able to merge
776 different TOC entries together, which means that it must be able to
777 extract the XMC_TC csects from the .data section of the input .o
780 From the point of view of our linker, this is, of course, a hideous
781 nightmare. We cope by actually creating sections for each csect,
782 and discarding the original sections. We then have to handle the
783 relocation entries carefully, since the only way to tell which
784 csect they belong to is to examine the address. */
787 xcoff_link_add_symbols (abfd, info)
789 struct bfd_link_info *info;
791 unsigned int n_tmask;
792 unsigned int n_btshft;
793 boolean default_copy;
794 bfd_size_type symcount;
795 struct xcoff_link_hash_entry **sym_hash;
796 asection **csect_cache;
797 bfd_size_type linesz;
801 unsigned int csect_index;
802 asection *first_csect;
803 bfd_size_type symesz;
806 struct reloc_info_struct
808 struct internal_reloc *relocs;
811 } *reloc_info = NULL;
813 if ((abfd->flags & DYNAMIC) != 0
814 && ! info->static_link)
815 return xcoff_link_add_dynamic_symbols (abfd, info);
817 n_tmask = coff_data (abfd)->local_n_tmask;
818 n_btshft = coff_data (abfd)->local_n_btshft;
820 /* Define macros so that ISFCN, et. al., macros work correctly. */
821 #define N_TMASK n_tmask
822 #define N_BTSHFT n_btshft
824 /* We need to build a .loader section, so we do it here. This won't
825 work if we're producing an XCOFF output file with no non dynamic
826 XCOFF input files. FIXME. */
827 if (xcoff_hash_table (info)->loader_section == NULL)
831 lsec = bfd_make_section_anyway (abfd, ".loader");
834 xcoff_hash_table (info)->loader_section = lsec;
835 lsec->flags |= SEC_HAS_CONTENTS | SEC_IN_MEMORY;
837 /* Likewise for the linkage section. */
838 if (xcoff_hash_table (info)->linkage_section == NULL)
842 lsec = bfd_make_section_anyway (abfd, ".gl");
845 xcoff_hash_table (info)->linkage_section = lsec;
846 lsec->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
848 /* Likewise for the TOC section. */
849 if (xcoff_hash_table (info)->toc_section == NULL)
853 tsec = bfd_make_section_anyway (abfd, ".tc");
856 xcoff_hash_table (info)->toc_section = tsec;
857 tsec->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
859 /* Likewise for the .debug section. */
860 if (xcoff_hash_table (info)->debug_section == NULL)
864 dsec = bfd_make_section_anyway (abfd, ".debug");
867 xcoff_hash_table (info)->debug_section = dsec;
868 dsec->flags |= SEC_HAS_CONTENTS | SEC_IN_MEMORY;
871 if (info->keep_memory)
872 default_copy = false;
876 symcount = obj_raw_syment_count (abfd);
878 /* We keep a list of the linker hash table entries that correspond
879 to each external symbol. */
880 sym_hash = ((struct xcoff_link_hash_entry **)
883 * sizeof (struct xcoff_link_hash_entry *))));
884 if (sym_hash == NULL && symcount != 0)
886 bfd_set_error (bfd_error_no_memory);
889 coff_data (abfd)->sym_hashes = (struct coff_link_hash_entry **) sym_hash;
891 (size_t) symcount * sizeof (struct xcoff_link_hash_entry *));
893 /* Because of the weird stuff we are doing with XCOFF csects, we can
894 not easily determine which section a symbol is in, so we store
895 the information in the tdata for the input file. */
896 csect_cache = ((asection **)
897 bfd_alloc (abfd, symcount * sizeof (asection *)));
898 if (csect_cache == NULL && symcount != 0)
900 bfd_set_error (bfd_error_no_memory);
903 xcoff_data (abfd)->csects = csect_cache;
904 memset (csect_cache, 0, (size_t) symcount * sizeof (asection *));
906 /* While splitting sections into csects, we need to assign the
907 relocs correctly. The relocs and the csects must both be in
908 order by VMA within a given section, so we handle this by
909 scanning along the relocs as we process the csects. We index
910 into reloc_info using the section target_index. */
911 reloc_info = ((struct reloc_info_struct *)
912 malloc ((abfd->section_count + 1)
913 * sizeof (struct reloc_info_struct)));
914 if (reloc_info == NULL)
916 bfd_set_error (bfd_error_no_memory);
919 memset ((PTR) reloc_info, 0,
920 (abfd->section_count + 1) * sizeof (struct reloc_info_struct));
922 /* Read in the relocs and line numbers for each section. */
923 linesz = bfd_coff_linesz (abfd);
924 for (sub = abfd->sections; sub != NULL; sub = sub->next)
926 if ((sub->flags & SEC_RELOC) != 0)
928 reloc_info[sub->target_index].relocs =
929 xcoff_read_internal_relocs (abfd, sub, true, (bfd_byte *) NULL,
930 false, (struct internal_reloc *) NULL);
931 reloc_info[sub->target_index].csects =
932 (asection **) malloc (sub->reloc_count * sizeof (asection *));
933 if (reloc_info[sub->target_index].csects == NULL)
935 bfd_set_error (bfd_error_no_memory);
938 memset (reloc_info[sub->target_index].csects, 0,
939 sub->reloc_count * sizeof (asection *));
942 if ((info->strip == strip_none || info->strip == strip_some)
943 && sub->lineno_count > 0)
947 linenos = (bfd_byte *) malloc (sub->lineno_count * linesz);
950 bfd_set_error (bfd_error_no_memory);
953 reloc_info[sub->target_index].linenos = linenos;
954 if (bfd_seek (abfd, sub->line_filepos, SEEK_SET) != 0
955 || (bfd_read (linenos, linesz, sub->lineno_count, abfd)
956 != linesz * sub->lineno_count))
961 /* Don't let the linker relocation routines discard the symbols. */
962 keep_syms = obj_coff_keep_syms (abfd);
963 obj_coff_keep_syms (abfd) = true;
969 symesz = bfd_coff_symesz (abfd);
970 BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
971 esym = (bfd_byte *) obj_coff_external_syms (abfd);
972 esym_end = esym + symcount * symesz;
973 while (esym < esym_end)
975 struct internal_syment sym;
976 union internal_auxent aux;
978 char buf[SYMNMLEN + 1];
983 struct xcoff_link_hash_entry *set_toc;
985 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
987 /* In this pass we are only interested in symbols with csect
989 if (sym.n_sclass != C_EXT && sym.n_sclass != C_HIDEXT)
991 if (sym.n_sclass == C_FILE && csect != NULL)
993 xcoff_section_data (abfd, csect)->last_symndx =
995 - (bfd_byte *) obj_coff_external_syms (abfd))
1001 *csect_cache = csect;
1002 else if (first_csect == NULL || sym.n_sclass == C_FILE)
1003 *csect_cache = coff_section_from_bfd_index (abfd, sym.n_scnum);
1005 *csect_cache = NULL;
1006 esym += (sym.n_numaux + 1) * symesz;
1007 sym_hash += sym.n_numaux + 1;
1008 csect_cache += sym.n_numaux + 1;
1012 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
1016 /* If this symbol has line number information attached to it,
1017 and we're not stripping it, count the number of entries and
1018 add them to the count for this csect. In the final link pass
1019 we are going to attach line number information by symbol,
1020 rather than by section, in order to more easily handle
1021 garbage collection. */
1022 if ((info->strip == strip_none || info->strip == strip_some)
1025 && ISFCN (sym.n_type))
1027 union internal_auxent auxlin;
1029 bfd_coff_swap_aux_in (abfd, (PTR) (esym + symesz),
1030 sym.n_type, sym.n_sclass,
1031 0, sym.n_numaux, (PTR) &auxlin);
1032 if (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
1034 asection *enclosing;
1035 bfd_size_type linoff;
1037 enclosing = xcoff_section_data (abfd, csect)->enclosing;
1038 if (enclosing == NULL)
1040 (*_bfd_error_handler)
1041 ("%s: `%s' has line numbers but no enclosing section",
1042 bfd_get_filename (abfd), name);
1043 bfd_set_error (bfd_error_bad_value);
1046 linoff = (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr
1047 - enclosing->line_filepos);
1048 if (linoff < enclosing->lineno_count * linesz)
1050 struct internal_lineno lin;
1051 bfd_byte *linpstart;
1053 linpstart = (reloc_info[enclosing->target_index].linenos
1055 bfd_coff_swap_lineno_in (abfd, (PTR) linpstart, (PTR) &lin);
1057 && ((bfd_size_type) lin.l_addr.l_symndx
1059 - (bfd_byte *) obj_coff_external_syms (abfd))
1062 bfd_byte *linpend, *linp;
1064 linpend = (reloc_info[enclosing->target_index].linenos
1065 + enclosing->lineno_count * linesz);
1066 for (linp = linpstart + linesz;
1070 bfd_coff_swap_lineno_in (abfd, (PTR) linp,
1072 if (lin.l_lnno == 0)
1075 csect->lineno_count += (linp - linpstart) / linesz;
1076 /* The setting of line_filepos will only be
1077 useful if all the line number entries for a
1078 csect are contiguous; this only matters for
1080 if (csect->line_filepos == 0)
1081 csect->line_filepos =
1082 auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr;
1088 /* Pick up the csect auxiliary information. */
1090 if (sym.n_numaux == 0)
1092 (*_bfd_error_handler)
1093 ("%s: class %d symbol `%s' has no aux entries",
1094 bfd_get_filename (abfd), sym.n_sclass, name);
1095 bfd_set_error (bfd_error_bad_value);
1099 bfd_coff_swap_aux_in (abfd,
1100 (PTR) (esym + symesz * sym.n_numaux),
1101 sym.n_type, sym.n_sclass,
1102 sym.n_numaux - 1, sym.n_numaux,
1105 smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
1115 (*_bfd_error_handler)
1116 ("%s: symbol `%s' has unrecognized csect type %d",
1117 bfd_get_filename (abfd), name, smtyp);
1118 bfd_set_error (bfd_error_bad_value);
1122 /* This is an external reference. */
1123 if (sym.n_sclass == C_HIDEXT
1124 || sym.n_scnum != N_UNDEF
1125 || aux.x_csect.x_scnlen.l != 0)
1127 (*_bfd_error_handler)
1128 ("%s: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d",
1129 bfd_get_filename (abfd), name, sym.n_sclass, sym.n_scnum,
1130 aux.x_csect.x_scnlen.l);
1131 bfd_set_error (bfd_error_bad_value);
1134 section = bfd_und_section_ptr;
1138 /* This is a csect definition. */
1142 xcoff_section_data (abfd, csect)->last_symndx =
1144 - (bfd_byte *) obj_coff_external_syms (abfd))
1151 /* When we see a TOC anchor, we record the TOC value. */
1152 if (aux.x_csect.x_smclas == XMC_TC0)
1154 if (sym.n_sclass != C_HIDEXT
1155 || aux.x_csect.x_scnlen.l != 0)
1157 (*_bfd_error_handler)
1158 ("%s: XMC_TC0 symbol `%s' is class %d scnlen %d",
1159 bfd_get_filename (abfd), name, sym.n_sclass,
1160 aux.x_csect.x_scnlen.l);
1161 bfd_set_error (bfd_error_bad_value);
1164 xcoff_data (abfd)->toc = sym.n_value;
1167 /* We must merge TOC entries for the same symbol. We can
1168 merge two TOC entries if they are both C_HIDEXT, they
1169 both have the same name, they are both 4 bytes long, and
1170 they both have a relocation table entry for an external
1171 symbol with the same name. Unfortunately, this means
1172 that we must look through the relocations. Ick. */
1173 if (aux.x_csect.x_smclas == XMC_TC
1174 && sym.n_sclass == C_HIDEXT
1175 && aux.x_csect.x_scnlen.l == 4
1176 && info->hash->creator == abfd->xvec)
1178 asection *enclosing;
1179 bfd_size_type relindx;
1180 struct internal_reloc *rel;
1181 asection **rel_csect;
1183 enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1184 if (enclosing == NULL)
1187 /* XCOFF requires that relocs be sorted by address, so
1188 we could do a binary search here. FIXME. */
1189 rel = reloc_info[enclosing->target_index].relocs;
1190 rel_csect = reloc_info[enclosing->target_index].csects;
1192 relindx < enclosing->reloc_count;
1193 relindx++, rel++, rel_csect++)
1195 if (*rel_csect == NULL
1196 && rel->r_vaddr == (bfd_vma) sym.n_value
1197 && rel->r_size == 31
1198 && rel->r_type == R_POS)
1201 if (relindx < enclosing->reloc_count)
1204 struct internal_syment relsym;
1206 erelsym = ((bfd_byte *) obj_coff_external_syms (abfd)
1207 + rel->r_symndx * symesz);
1208 bfd_coff_swap_sym_in (abfd, (PTR) erelsym, (PTR) &relsym);
1209 if (relsym.n_sclass == C_EXT)
1211 const char *relname;
1212 char relbuf[SYMNMLEN + 1];
1214 struct xcoff_link_hash_entry *h;
1216 /* At this point we know that the TOC entry is
1217 for an externally visible symbol. */
1218 relname = _bfd_coff_internal_syment_name (abfd, &relsym,
1220 if (relname == NULL)
1223 /* We only merge TOC entries if the TC name is
1224 the same as the symbol name. This handles
1225 the normal case, but not common cases like
1226 SYM.P4 which gcc generates to store SYM + 4
1227 in the TOC. FIXME. */
1228 if (strcmp (name, relname) == 0)
1230 copy = (! info->keep_memory
1231 || relsym._n._n_n._n_zeroes != 0
1232 || relsym._n._n_n._n_offset == 0);
1233 h = xcoff_link_hash_lookup (xcoff_hash_table (info),
1234 relname, true, copy,
1239 /* At this point h->root.type could be
1240 bfd_link_hash_new. That should be OK,
1241 since we know for sure that we will come
1242 across this symbol as we step through the
1245 /* We store h in *sym_hash for the
1246 convenience of the relocate_section
1250 if (h->toc_section != NULL)
1252 /* We already have a TOC entry for this
1253 symbol, so we can just ignore this
1255 *rel_csect = bfd_und_section_ptr;
1259 /* We are about to create a TOC entry for
1267 /* We need to create a new section. We get the name from
1268 the csect storage mapping class, so that the linker can
1269 accumulate similar csects together. */
1271 static const char *csect_name_by_class[] =
1273 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
1274 ".sv", ".bs", ".ds", ".uc", ".ti", ".tb", NULL, ".tc0",
1277 const char *csect_name;
1278 asection *enclosing;
1279 struct internal_reloc *rel;
1280 bfd_size_type relindx;
1281 asection **rel_csect;
1283 if ((aux.x_csect.x_smclas >=
1284 sizeof csect_name_by_class / sizeof csect_name_by_class[0])
1285 || csect_name_by_class[aux.x_csect.x_smclas] == NULL)
1287 (*_bfd_error_handler)
1288 ("%s: symbol `%s' has unrecognized smclas %d",
1289 bfd_get_filename (abfd), name, aux.x_csect.x_smclas);
1290 bfd_set_error (bfd_error_bad_value);
1294 csect_name = csect_name_by_class[aux.x_csect.x_smclas];
1295 csect = bfd_make_section_anyway (abfd, csect_name);
1298 enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1299 if (enclosing == NULL)
1301 if ((bfd_vma) sym.n_value < enclosing->vma
1302 || ((bfd_vma) sym.n_value + aux.x_csect.x_scnlen.l
1303 > enclosing->vma + enclosing->_raw_size))
1305 (*_bfd_error_handler)
1306 ("%s: csect `%s' not in enclosing section",
1307 bfd_get_filename (abfd), name);
1308 bfd_set_error (bfd_error_bad_value);
1311 csect->vma = sym.n_value;
1312 csect->filepos = (enclosing->filepos
1315 csect->_raw_size = aux.x_csect.x_scnlen.l;
1316 csect->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
1317 csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
1319 /* Record the enclosing section in the tdata for this new
1321 csect->used_by_bfd =
1322 ((struct coff_section_tdata *)
1323 bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
1324 if (csect->used_by_bfd == NULL)
1326 bfd_set_error (bfd_error_no_memory);
1329 coff_section_data (abfd, csect)->tdata =
1330 bfd_zalloc (abfd, sizeof (struct xcoff_section_tdata));
1331 if (coff_section_data (abfd, csect)->tdata == NULL)
1333 bfd_set_error (bfd_error_no_memory);
1336 xcoff_section_data (abfd, csect)->enclosing = enclosing;
1337 xcoff_section_data (abfd, csect)->lineno_count =
1338 enclosing->lineno_count;
1340 /* XCOFF requires that relocs be sorted by address, so we
1341 could do a binary search here. FIXME. (XCOFF
1342 unfortunately does not require that symbols be sorted
1343 by address, or this would be a simple merge). */
1344 rel = reloc_info[enclosing->target_index].relocs;
1345 rel_csect = reloc_info[enclosing->target_index].csects;
1347 relindx < enclosing->reloc_count;
1348 relindx++, rel++, rel_csect++)
1350 if (*rel_csect == NULL
1351 && rel->r_vaddr >= csect->vma
1352 && rel->r_vaddr < csect->vma + csect->_raw_size)
1354 csect->rel_filepos = (enclosing->rel_filepos
1355 + relindx * bfd_coff_relsz (abfd));
1359 while (relindx < enclosing->reloc_count
1360 && *rel_csect == NULL
1361 && rel->r_vaddr >= csect->vma
1362 && rel->r_vaddr < csect->vma + csect->_raw_size)
1365 csect->flags |= SEC_RELOC;
1366 ++csect->reloc_count;
1372 /* There are a number of other fields and section flags
1373 which we do not bother to set. */
1375 csect_index = ((esym
1376 - (bfd_byte *) obj_coff_external_syms (abfd))
1379 xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1381 if (first_csect == NULL)
1382 first_csect = csect;
1384 /* If this symbol is C_EXT, we treat it as starting at the
1385 beginning of the newly created section. */
1386 if (sym.n_sclass == C_EXT)
1392 /* If this is a TOC section for a symbol, record it. */
1393 if (set_toc != NULL)
1394 set_toc->toc_section = csect;
1399 /* This is a label definition. The x_scnlen field is the
1400 symbol index of the csect. I believe that this must
1401 always follow the appropriate XTY_SD symbol, so I will
1407 if (aux.x_csect.x_scnlen.l < 0
1408 || (aux.x_csect.x_scnlen.l
1409 >= esym - (bfd_byte *) obj_coff_external_syms (abfd)))
1413 section = xcoff_data (abfd)->csects[aux.x_csect.x_scnlen.l];
1415 || (section->flags & SEC_HAS_CONTENTS) == 0)
1420 (*_bfd_error_handler)
1421 ("%s: misplaced XTY_LD `%s'",
1422 bfd_get_filename (abfd), name);
1423 bfd_set_error (bfd_error_bad_value);
1427 value = sym.n_value - csect->vma;
1432 /* This is an unitialized csect. We could base the name on
1433 the storage mapping class, but we don't bother. If this
1434 csect is externally visible, it is a common symbol. */
1438 xcoff_section_data (abfd, csect)->last_symndx =
1440 - (bfd_byte *) obj_coff_external_syms (abfd))
1444 csect = bfd_make_section_anyway (abfd, ".bss");
1447 csect->vma = sym.n_value;
1448 csect->_raw_size = aux.x_csect.x_scnlen.l;
1449 csect->flags |= SEC_ALLOC;
1450 csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
1451 /* There are a number of other fields and section flags
1452 which we do not bother to set. */
1454 csect_index = ((esym
1455 - (bfd_byte *) obj_coff_external_syms (abfd))
1458 csect->used_by_bfd =
1459 ((struct coff_section_tdata *)
1460 bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
1461 if (csect->used_by_bfd == NULL)
1463 bfd_set_error (bfd_error_no_memory);
1466 coff_section_data (abfd, csect)->tdata =
1467 bfd_zalloc (abfd, sizeof (struct xcoff_section_tdata));
1468 if (coff_section_data (abfd, csect)->tdata == NULL)
1470 bfd_set_error (bfd_error_no_memory);
1473 xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1475 if (first_csect == NULL)
1476 first_csect = csect;
1478 if (sym.n_sclass == C_EXT)
1480 csect->flags |= SEC_IS_COMMON;
1482 value = aux.x_csect.x_scnlen.l;
1488 /* Now we have enough information to add the symbol to the
1489 linker hash table. */
1491 if (sym.n_sclass == C_EXT)
1495 BFD_ASSERT (section != NULL);
1497 /* We must copy the name into memory if we got it from the
1498 syment itself, rather than the string table. */
1499 copy = default_copy;
1500 if (sym._n._n_n._n_zeroes != 0
1501 || sym._n._n_n._n_offset == 0)
1504 if (info->hash->creator == abfd->xvec)
1506 /* If we are statically linking a shared object, it is
1507 OK for symbol redefinitions to occur. I can't figure
1508 out just what the XCOFF linker is doing, but
1509 something like this is required for -bnso to work. */
1510 *sym_hash = xcoff_link_hash_lookup (xcoff_hash_table (info),
1511 name, true, copy, false);
1512 if (*sym_hash == NULL)
1514 if (((*sym_hash)->root.type == bfd_link_hash_defined
1515 || (*sym_hash)->root.type == bfd_link_hash_defweak)
1516 && ! bfd_is_und_section (section)
1517 && ! bfd_is_com_section (section))
1519 if ((abfd->flags & DYNAMIC) != 0)
1521 section = bfd_und_section_ptr;
1524 else if (((*sym_hash)->root.u.def.section->owner->flags
1527 (*sym_hash)->root.type = bfd_link_hash_undefined;
1528 (*sym_hash)->root.u.undef.abfd =
1529 (*sym_hash)->root.u.def.section->owner;
1534 if (! (_bfd_generic_link_add_one_symbol
1535 (info, abfd, name, flags, section, value,
1536 (const char *) NULL, copy, false,
1537 (struct bfd_link_hash_entry **) sym_hash)))
1540 if (smtyp == XTY_CM)
1542 if ((*sym_hash)->root.type != bfd_link_hash_common
1543 || (*sym_hash)->root.u.c.p->section != csect)
1545 /* We don't need the common csect we just created. */
1546 csect->_raw_size = 0;
1550 (*sym_hash)->root.u.c.p->alignment_power
1551 = csect->alignment_power;
1555 if (info->hash->creator == abfd->xvec)
1559 if (smtyp == XTY_ER || smtyp == XTY_CM)
1560 flag = XCOFF_REF_REGULAR;
1562 flag = XCOFF_DEF_REGULAR;
1563 (*sym_hash)->flags |= flag;
1565 if ((*sym_hash)->smclas == XMC_UA)
1566 (*sym_hash)->smclas = aux.x_csect.x_smclas;
1570 *csect_cache = csect;
1572 esym += (sym.n_numaux + 1) * symesz;
1573 sym_hash += sym.n_numaux + 1;
1574 csect_cache += sym.n_numaux + 1;
1577 /* Make sure that we have seen all the relocs. */
1578 for (sub = abfd->sections; sub != first_csect; sub = sub->next)
1580 /* Reset the section size, since the data is now attached to the
1581 csects. Don't reset the size of the .debug section, since we
1582 need to read it below in bfd_xcoff_size_dynamic_sections. */
1583 if (strcmp (bfd_get_section_name (abfd, sub), ".debug") != 0)
1586 if ((sub->flags & SEC_RELOC) != 0)
1589 struct internal_reloc *rel;
1590 asection **rel_csect;
1592 rel = reloc_info[sub->target_index].relocs;
1593 rel_csect = reloc_info[sub->target_index].csects;
1594 for (i = 0; i < sub->reloc_count; i++, rel++, rel_csect++)
1596 if (*rel_csect == NULL)
1598 (*_bfd_error_handler)
1599 ("%s: reloc %s:%d not in csect",
1600 bfd_get_filename (abfd), sub->name, i);
1601 bfd_set_error (bfd_error_bad_value);
1605 /* We identify all symbols which are called, so that we
1606 can create glue code for calls to functions imported
1607 from dynamic objects. */
1608 if (info->hash->creator == abfd->xvec
1609 && *rel_csect != bfd_und_section_ptr
1610 && (rel->r_type == R_BR
1611 || rel->r_type == R_RBR)
1612 && obj_xcoff_sym_hashes (abfd)[rel->r_symndx] != NULL)
1614 struct xcoff_link_hash_entry *h;
1616 h = obj_xcoff_sym_hashes (abfd)[rel->r_symndx];
1617 h->flags |= XCOFF_CALLED;
1618 /* If the symbol name starts with a period, it is
1619 the code of a function. If the symbol is
1620 currently undefined, then add an undefined symbol
1621 for the function descriptor. This should do no
1622 harm, because any regular object that defines the
1623 function should also define the function
1624 descriptor. It helps, because it means that we
1625 will identify the function descriptor with a
1626 dynamic object if a dynamic object defines it. */
1627 if (h->root.root.string[0] == '.'
1628 && h->descriptor == NULL)
1630 struct xcoff_link_hash_entry *hds;
1632 hds = xcoff_link_hash_lookup (xcoff_hash_table (info),
1633 h->root.root.string + 1,
1637 if (hds->root.type == bfd_link_hash_new)
1639 if (! (_bfd_generic_link_add_one_symbol
1640 (info, abfd, hds->root.root.string,
1641 (flagword) 0, bfd_und_section_ptr,
1642 (bfd_vma) 0, (const char *) NULL, false,
1644 (struct bfd_link_hash_entry **) NULL)))
1647 h->descriptor = hds;
1652 free (reloc_info[sub->target_index].csects);
1653 reloc_info[sub->target_index].csects = NULL;
1655 /* Reset SEC_RELOC, the reloc_count, and the lineno_count,
1656 since the reloc and lineno information is now attached to
1658 sub->flags &=~ SEC_RELOC;
1659 sub->reloc_count = 0;
1660 sub->lineno_count = 0;
1662 /* If we are not keeping memory, free the reloc information. */
1663 if (! info->keep_memory
1664 && coff_section_data (abfd, sub) != NULL
1665 && coff_section_data (abfd, sub)->relocs != NULL
1666 && ! coff_section_data (abfd, sub)->keep_relocs)
1668 free (coff_section_data (abfd, sub)->relocs);
1669 coff_section_data (abfd, sub)->relocs = NULL;
1673 /* Free up the line numbers. FIXME: We could cache these
1674 somewhere for the final link, to avoid reading them again. */
1675 if (reloc_info[sub->target_index].linenos != NULL)
1677 free (reloc_info[sub->target_index].linenos);
1678 reloc_info[sub->target_index].linenos = NULL;
1684 obj_coff_keep_syms (abfd) = keep_syms;
1689 if (reloc_info != NULL)
1691 for (sub = abfd->sections; sub != NULL; sub = sub->next)
1693 if (reloc_info[sub->target_index].csects != NULL)
1694 free (reloc_info[sub->target_index].csects);
1695 if (reloc_info[sub->target_index].linenos != NULL)
1696 free (reloc_info[sub->target_index].linenos);
1700 obj_coff_keep_syms (abfd) = keep_syms;
1707 /* This function is used to add symbols from a dynamic object to the
1708 global symbol table. */
1711 xcoff_link_add_dynamic_symbols (abfd, info)
1713 struct bfd_link_info *info;
1715 bfd_size_type symesz;
1718 struct xcoff_import_file *n;
1723 struct xcoff_import_file **pp;
1725 /* We can only handle a dynamic object if we are generating an XCOFF
1727 if (info->hash->creator != abfd->xvec)
1729 (*_bfd_error_handler)
1730 ("%s: XCOFF shared object when not producing XCOFF output",
1731 bfd_get_filename (abfd));
1732 bfd_set_error (bfd_error_invalid_operation);
1736 /* Remove the sections from this object, so that they do not get
1737 included in the link. */
1738 abfd->sections = NULL;
1740 symesz = bfd_coff_symesz (abfd);
1741 esym = (bfd_byte *) obj_coff_external_syms (abfd);
1742 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
1743 while (esym < esym_end)
1745 struct internal_syment sym;
1747 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
1749 /* I think that every symbol mentioned in a dynamic object must
1750 be defined by that object, perhaps by importing it from
1751 another dynamic object. All we have to do is look up each
1752 external symbol. If we have already put it in the hash
1753 table, we simply set a flag indicating that it appears in a
1756 if (sym.n_sclass == C_EXT)
1759 char buf[SYMNMLEN + 1];
1760 struct xcoff_link_hash_entry *h;
1762 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
1766 /* Normally we could not xcoff_link_hash_lookup in an add
1767 symbols routine, since we might not be using an XCOFF
1768 hash table. However, we verified above that we are using
1769 an XCOFF hash table. */
1770 h = xcoff_link_hash_lookup (xcoff_hash_table (info), name,
1771 false, false, true);
1774 h->flags |= XCOFF_REF_DYNAMIC;
1776 /* If the symbol is undefined, and the current BFD is
1777 not a dynamic object, change the BFD to this dynamic
1778 object, so that we can get the correct import file
1780 if ((h->root.type == bfd_link_hash_undefined
1781 || h->root.type == bfd_link_hash_undefweak)
1782 && (h->root.u.undef.abfd == NULL
1783 || (h->root.u.undef.abfd->flags & DYNAMIC) == 0))
1784 h->root.u.undef.abfd = abfd;
1786 if (h->smclas == XMC_UA
1787 && sym.n_numaux > 0)
1789 union internal_auxent aux;
1791 bfd_coff_swap_aux_in (abfd,
1792 (PTR) (esym + symesz * sym.n_numaux),
1793 sym.n_type, sym.n_sclass,
1794 sym.n_numaux - 1, sym.n_numaux,
1796 h->smclas = aux.x_csect.x_smclas;
1801 esym += (sym.n_numaux + 1) * symesz;
1804 /* Record this file in the import files. */
1806 n = ((struct xcoff_import_file *)
1807 bfd_alloc (abfd, sizeof (struct xcoff_import_file)));
1810 bfd_set_error (bfd_error_no_memory);
1815 /* For some reason, the path entry in the import file list for a
1816 shared object appears to always be empty. The file name is the
1819 if (abfd->my_archive == NULL)
1821 bname = bfd_get_filename (abfd);
1826 bname = bfd_get_filename (abfd->my_archive);
1827 mname = bfd_get_filename (abfd);
1829 s = strrchr (bname, '/');
1835 /* We start c at 1 because the first import file number is reserved
1837 for (pp = &xcoff_hash_table (info)->imports, c = 1;
1839 pp = &(*pp)->next, ++c)
1843 xcoff_data (abfd)->import_file_id = c;
1848 /* Routines that are called after all the input files have been
1849 handled, but before the sections are laid out in memory. */
1851 /* Import a symbol. */
1854 bfd_xcoff_import_symbol (output_bfd, info, harg, val, imppath, impfile,
1857 struct bfd_link_info *info;
1858 struct bfd_link_hash_entry *harg;
1860 const char *imppath;
1861 const char *impfile;
1862 const char *impmember;
1864 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
1866 h->flags |= XCOFF_IMPORT;
1868 if (val != (bfd_vma) -1)
1870 if (h->root.type == bfd_link_hash_defined)
1872 if (! ((*info->callbacks->multiple_definition)
1873 (info, h->root.root.string, h->root.u.def.section->owner,
1874 h->root.u.def.section, h->root.u.def.value,
1875 output_bfd, bfd_abs_section_ptr, val)))
1879 h->root.type = bfd_link_hash_defined;
1880 h->root.u.def.section = bfd_abs_section_ptr;
1881 h->root.u.def.value = val;
1884 if (h->ldsym == NULL)
1886 h->ldsym = ((struct internal_ldsym *)
1887 bfd_zalloc (output_bfd, sizeof (struct internal_ldsym)));
1888 if (h->ldsym == NULL)
1890 bfd_set_error (bfd_error_no_memory);
1895 if (imppath == NULL)
1896 h->ldsym->l_ifile = (bfd_size_type) -1;
1900 struct xcoff_import_file **pp;
1902 /* We start c at 1 because the first entry in the import list is
1903 reserved for the library search path. */
1904 for (pp = &xcoff_hash_table (info)->imports, c = 1;
1906 pp = &(*pp)->next, ++c)
1908 if (strcmp ((*pp)->path, imppath) == 0
1909 && strcmp ((*pp)->file, impfile) == 0
1910 && strcmp ((*pp)->member, impmember) == 0)
1916 struct xcoff_import_file *n;
1918 n = ((struct xcoff_import_file *)
1919 bfd_alloc (output_bfd, sizeof (struct xcoff_import_file)));
1922 bfd_set_error (bfd_error_no_memory);
1928 n->member = impmember;
1932 h->ldsym->l_ifile = c;
1938 /* Export a symbol. */
1941 bfd_xcoff_export_symbol (output_bfd, info, harg, syscall)
1943 struct bfd_link_info *info;
1944 struct bfd_link_hash_entry *harg;
1947 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
1949 h->flags |= XCOFF_EXPORT;
1951 /* FIXME: I'm not at all sure what syscall is supposed to mean, so
1952 I'm just going to ignore it until somebody explains it. */
1957 /* This structure is used to pass information through
1958 xcoff_link_hash_traverse. */
1960 struct xcoff_loader_info
1962 /* Set if a problem occurred. */
1966 /* Link information structure. */
1967 struct bfd_link_info *info;
1968 /* Number of ldsym structures. */
1970 /* Size of string table. */
1974 /* Allocated size of string table. */
1978 /* Build the .loader section. This is called by the XCOFF linker
1979 emulation before_allocation routine. We must set the size of the
1980 .loader section before the linker lays out the output file.
1981 LIBPATH is the library path to search for shared objects; this is
1982 normally built from the -L arguments passed to the linker. ENTRY
1983 is the name of the entry point symbol. */
1986 bfd_xcoff_size_dynamic_sections (output_bfd, info, libpath, entry,
1987 file_align, maxstack, maxdata, gc,
1990 struct bfd_link_info *info;
1991 const char *libpath;
1993 unsigned long file_align;
1994 unsigned long maxstack;
1995 unsigned long maxdata;
2000 struct xcoff_link_hash_entry *hentry;
2002 struct xcoff_loader_info ldinfo;
2003 size_t impsize, impcount;
2004 struct xcoff_import_file *fl;
2005 struct internal_ldhdr *ldhdr;
2006 bfd_size_type stoff;
2010 struct bfd_strtab_hash *debug_strtab;
2011 bfd_byte *debug_contents = NULL;
2013 ldinfo.failed = false;
2014 ldinfo.output_bfd = output_bfd;
2016 ldinfo.ldsym_count = 0;
2017 ldinfo.string_size = 0;
2018 ldinfo.strings = NULL;
2019 ldinfo.string_alc = 0;
2021 xcoff_data (output_bfd)->maxstack = maxstack;
2022 xcoff_data (output_bfd)->maxdata = maxdata;
2023 xcoff_data (output_bfd)->modtype = modtype;
2025 xcoff_hash_table (info)->file_align = file_align;
2026 xcoff_hash_table (info)->textro = textro;
2028 hentry = xcoff_link_hash_lookup (xcoff_hash_table (info), entry,
2029 false, false, true);
2032 hentry->flags |= XCOFF_ENTRY;
2033 if (hentry->root.type == bfd_link_hash_defined
2034 || hentry->root.type == bfd_link_hash_defweak)
2035 xcoff_data (output_bfd)->entry_section =
2036 hentry->root.u.def.section->output_section;
2039 /* Garbage collect unused sections. */
2040 if (info->relocateable
2043 || (hentry->root.type != bfd_link_hash_defined
2044 && hentry->root.type != bfd_link_hash_defweak))
2047 xcoff_hash_table (info)->gc = false;
2049 /* We still need to call xcoff_mark, in order to set ldrel_count
2051 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2055 for (o = sub->sections; o != NULL; o = o->next)
2057 if ((o->flags & SEC_MARK) == 0)
2059 if (! xcoff_mark (info, o))
2067 if (! xcoff_mark (info, hentry->root.u.def.section))
2070 xcoff_hash_table (info)->gc = true;
2073 if (info->input_bfds == NULL)
2075 /* I'm not sure what to do in this bizarre case. */
2079 xcoff_link_hash_traverse (xcoff_hash_table (info), xcoff_build_ldsyms,
2084 /* Work out the size of the import file names. Each import file ID
2085 consists of three null terminated strings: the path, the file
2086 name, and the archive member name. The first entry in the list
2087 of names is the path to use to find objects, which the linker has
2088 passed in as the libpath argument. For some reason, the path
2089 entry in the other import file names appears to always be empty. */
2090 impsize = strlen (libpath) + 3;
2092 for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
2095 impsize += (strlen (fl->path)
2097 + strlen (fl->member)
2101 /* Set up the .loader section header. */
2102 ldhdr = &xcoff_hash_table (info)->ldhdr;
2103 ldhdr->l_version = 1;
2104 ldhdr->l_nsyms = ldinfo.ldsym_count;
2105 ldhdr->l_nreloc = xcoff_hash_table (info)->ldrel_count;
2106 ldhdr->l_istlen = impsize;
2107 ldhdr->l_nimpid = impcount;
2108 ldhdr->l_impoff = (LDHDRSZ
2109 + ldhdr->l_nsyms * LDSYMSZ
2110 + ldhdr->l_nreloc * LDRELSZ);
2111 ldhdr->l_stlen = ldinfo.string_size;
2112 stoff = ldhdr->l_impoff + impsize;
2113 if (ldinfo.string_size == 0)
2116 ldhdr->l_stoff = stoff;
2118 /* We now know the final size of the .loader section. Allocate
2120 lsec = xcoff_hash_table (info)->loader_section;
2121 lsec->_raw_size = stoff + ldhdr->l_stlen;
2122 lsec->contents = (bfd_byte *) bfd_zalloc (output_bfd, lsec->_raw_size);
2123 if (lsec->contents == NULL)
2125 bfd_set_error (bfd_error_no_memory);
2129 /* Set up the header. */
2130 xcoff_swap_ldhdr_out (output_bfd, ldhdr,
2131 (struct external_ldhdr *) lsec->contents);
2133 /* Set up the import file names. */
2134 out = (char *) lsec->contents + ldhdr->l_impoff;
2135 strcpy (out, libpath);
2136 out += strlen (libpath) + 1;
2139 for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
2141 register const char *s;
2144 while ((*out++ = *s++) != '\0')
2147 while ((*out++ = *s++) != '\0')
2150 while ((*out++ = *s++) != '\0')
2154 BFD_ASSERT ((bfd_size_type) ((bfd_byte *) out - lsec->contents) == stoff);
2156 /* Set up the symbol string table. */
2157 if (ldinfo.string_size > 0)
2159 memcpy (out, ldinfo.strings, ldinfo.string_size);
2160 free (ldinfo.strings);
2161 ldinfo.strings = NULL;
2164 /* We can't set up the symbol table or the relocs yet, because we
2165 don't yet know the final position of the various sections. The
2166 .loader symbols are written out when the corresponding normal
2167 symbols are written out in xcoff_link_input_bfd or
2168 xcoff_write_global_symbol. The .loader relocs are written out
2169 when the corresponding normal relocs are handled in
2170 xcoff_link_input_bfd. */
2172 /* Allocate space for the global linkage section and the global toc
2174 sec = xcoff_hash_table (info)->linkage_section;
2175 if (sec->_raw_size > 0)
2177 sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
2178 if (sec->contents == NULL)
2180 bfd_set_error (bfd_error_no_memory);
2184 sec = xcoff_hash_table (info)->toc_section;
2185 if (sec->_raw_size > 0)
2187 sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
2188 if (sec->contents == NULL)
2190 bfd_set_error (bfd_error_no_memory);
2195 /* Now that we've done garbage collection, figure out the contents
2196 of the .debug section. */
2197 debug_strtab = xcoff_hash_table (info)->debug_strtab;
2199 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2202 bfd_size_type symcount;
2203 unsigned long *debug_index;
2205 bfd_byte *esym, *esymend;
2206 bfd_size_type symesz;
2208 if (sub->xvec != info->hash->creator)
2210 subdeb = bfd_get_section_by_name (sub, ".debug");
2211 if (subdeb == NULL || subdeb->_raw_size == 0)
2214 if (info->strip == strip_all
2215 || info->strip == strip_debugger
2216 || info->discard == discard_all)
2218 subdeb->_raw_size = 0;
2222 if (! _bfd_coff_get_external_symbols (sub))
2225 symcount = obj_raw_syment_count (sub);
2226 debug_index = ((unsigned long *)
2227 bfd_zalloc (sub, symcount * sizeof (unsigned long)));
2228 if (debug_index == NULL)
2230 bfd_set_error (bfd_error_no_memory);
2233 xcoff_data (sub)->debug_indices = debug_index;
2235 /* Grab the contents of the .debug section. We use malloc and
2236 copy the neams into the debug stringtab, rather than
2237 bfd_alloc, because I expect that, when linking many files
2238 together, many of the strings will be the same. Storing the
2239 strings in the hash table should save space in this case. */
2240 debug_contents = (bfd_byte *) malloc (subdeb->_raw_size);
2241 if (debug_contents == NULL)
2243 bfd_set_error (bfd_error_no_memory);
2246 if (! bfd_get_section_contents (sub, subdeb, (PTR) debug_contents,
2247 (file_ptr) 0, subdeb->_raw_size))
2250 csectpp = xcoff_data (sub)->csects;
2252 symesz = bfd_coff_symesz (sub);
2253 esym = (bfd_byte *) obj_coff_external_syms (sub);
2254 esymend = esym + symcount * symesz;
2255 while (esym < esymend)
2257 struct internal_syment sym;
2259 bfd_coff_swap_sym_in (sub, (PTR) esym, (PTR) &sym);
2261 *debug_index = (unsigned long) -1;
2263 if (sym._n._n_n._n_zeroes == 0
2266 || ((*csectpp)->flags & SEC_MARK) != 0
2267 || *csectpp == bfd_abs_section_ptr)
2268 && bfd_coff_symname_in_debug (sub, &sym))
2273 name = (char *) debug_contents + sym._n._n_n._n_offset;
2274 indx = _bfd_stringtab_add (debug_strtab, name, true, true);
2275 if (indx == (bfd_size_type) -1)
2277 *debug_index = indx;
2280 esym += (sym.n_numaux + 1) * symesz;
2281 csectpp += sym.n_numaux + 1;
2282 debug_index += sym.n_numaux + 1;
2285 free (debug_contents);
2286 debug_contents = NULL;
2288 /* Clear the size of subdeb, so that it is not included directly
2289 in the output file. */
2290 subdeb->_raw_size = 0;
2292 if (! info->keep_memory)
2294 if (! _bfd_coff_free_symbols (sub))
2299 xcoff_hash_table (info)->debug_section->_raw_size =
2300 _bfd_stringtab_size (debug_strtab);
2305 if (ldinfo.strings != NULL)
2306 free (ldinfo.strings);
2307 if (debug_contents != NULL)
2308 free (debug_contents);
2312 /* The mark phase of garbage collection. For a given section, mark
2313 it, and all the sections which define symbols to which it refers.
2314 Because this function needs to look at the relocs, we also count
2315 the number of relocs which need to be copied into the .loader
2319 xcoff_mark (info, sec)
2320 struct bfd_link_info *info;
2323 if ((sec->flags & SEC_MARK) != 0)
2326 sec->flags |= SEC_MARK;
2328 if (sec->owner->xvec == info->hash->creator
2329 && coff_section_data (sec->owner, sec) != NULL
2330 && xcoff_section_data (sec->owner, sec) != NULL)
2332 register struct xcoff_link_hash_entry **hp, **hpend;
2333 struct internal_reloc *rel, *relend;
2335 /* Mark all the symbols in this section. */
2337 hp = (obj_xcoff_sym_hashes (sec->owner)
2338 + xcoff_section_data (sec->owner, sec)->first_symndx);
2339 hpend = (obj_xcoff_sym_hashes (sec->owner)
2340 + xcoff_section_data (sec->owner, sec)->last_symndx);
2341 for (; hp < hpend; hp++)
2343 register struct xcoff_link_hash_entry *h;
2347 && (h->flags & XCOFF_MARK) == 0)
2349 h->flags |= XCOFF_MARK;
2350 if (h->root.type == bfd_link_hash_defined
2351 || h->root.type == bfd_link_hash_defweak)
2355 hsec = h->root.u.def.section;
2356 if ((hsec->flags & SEC_MARK) == 0)
2358 if (! xcoff_mark (info, hsec))
2363 if (h->toc_section != NULL
2364 && (h->toc_section->flags & SEC_MARK) == 0)
2366 if (! xcoff_mark (info, h->toc_section))
2372 /* Look through the section relocs. */
2374 if ((sec->flags & SEC_RELOC) != 0
2375 && sec->reloc_count > 0)
2377 rel = xcoff_read_internal_relocs (sec->owner, sec, true,
2378 (bfd_byte *) NULL, false,
2379 (struct internal_reloc *) NULL);
2382 relend = rel + sec->reloc_count;
2383 for (; rel < relend; rel++)
2386 struct xcoff_link_hash_entry *h;
2388 if ((unsigned int) rel->r_symndx
2389 > obj_raw_syment_count (sec->owner))
2392 h = obj_xcoff_sym_hashes (sec->owner)[rel->r_symndx];
2394 && (h->flags & XCOFF_MARK) == 0)
2396 h->flags |= XCOFF_MARK;
2397 if (h->root.type == bfd_link_hash_defined
2398 || h->root.type == bfd_link_hash_defweak)
2402 hsec = h->root.u.def.section;
2403 if ((hsec->flags & SEC_MARK) == 0)
2405 if (! xcoff_mark (info, hsec))
2410 if (h->toc_section != NULL
2411 && (h->toc_section->flags & SEC_MARK) == 0)
2413 if (! xcoff_mark (info, h->toc_section))
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->flags & XCOFF_DEF_REGULAR) == 0
2437 && (h->flags & XCOFF_REF_DYNAMIC) != 0
2438 && (h->root.type == bfd_link_hash_undefined
2439 || h->root.type == bfd_link_hash_undefweak)
2440 && h->root.root.string[0] == '.'))
2447 ++xcoff_hash_table (info)->ldrel_count;
2449 h->flags |= XCOFF_LDREL;
2456 /* We should never need a .loader reloc for a TOC
2462 if (! info->keep_memory
2463 && coff_section_data (sec->owner, sec) != NULL
2464 && coff_section_data (sec->owner, sec)->relocs != NULL
2465 && ! coff_section_data (sec->owner, sec)->keep_relocs)
2467 free (coff_section_data (sec->owner, sec)->relocs);
2468 coff_section_data (sec->owner, sec)->relocs = NULL;
2476 /* The sweep phase of garbage collection. Remove all garbage
2481 struct bfd_link_info *info;
2485 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2489 for (o = sub->sections; o != NULL; o = o->next)
2491 if ((o->flags & SEC_MARK) == 0)
2493 /* Keep all sections from non-XCOFF input files. Keep
2494 special sections. Keep .debug sections for the
2496 if (sub->xvec != info->hash->creator
2497 || o == xcoff_hash_table (info)->debug_section
2498 || o == xcoff_hash_table (info)->loader_section
2499 || o == xcoff_hash_table (info)->linkage_section
2500 || o == xcoff_hash_table (info)->toc_section
2501 || strcmp (o->name, ".debug") == 0)
2502 o->flags |= SEC_MARK;
2507 o->lineno_count = 0;
2514 /* Add a symbol to the .loader symbols, if necessary. */
2517 xcoff_build_ldsyms (h, p)
2518 struct xcoff_link_hash_entry *h;
2521 struct xcoff_loader_info *ldinfo = (struct xcoff_loader_info *) p;
2524 /* We don't want to garbage collect symbols which are not defined in
2525 XCOFF files. This is a convenient place to mark them. */
2526 if (xcoff_hash_table (ldinfo->info)->gc
2527 && (h->flags & XCOFF_MARK) == 0
2528 && (h->root.type == bfd_link_hash_defined
2529 || h->root.type == bfd_link_hash_defweak)
2530 && (h->root.u.def.section->owner == NULL
2531 || (h->root.u.def.section->owner->xvec
2532 != ldinfo->info->hash->creator)))
2533 h->flags |= XCOFF_MARK;
2535 /* If this symbol is called, and it is defined in a dynamic object,
2536 then we need to set up global linkage code for it. (Unless we
2537 did garbage collection and we didn't need this symbol.) */
2538 if ((h->flags & XCOFF_CALLED) != 0
2539 && (h->flags & XCOFF_DEF_REGULAR) == 0
2540 && (h->flags & XCOFF_REF_DYNAMIC) != 0
2541 && (h->root.type == bfd_link_hash_undefined
2542 || h->root.type == bfd_link_hash_undefweak)
2543 && h->root.root.string[0] == '.'
2544 && (! xcoff_hash_table (ldinfo->info)->gc
2545 || (h->flags & XCOFF_MARK) != 0))
2548 struct xcoff_link_hash_entry *hds;
2550 sec = xcoff_hash_table (ldinfo->info)->linkage_section;
2551 h->root.type = bfd_link_hash_defined;
2552 h->root.u.def.section = sec;
2553 h->root.u.def.value = sec->_raw_size;
2555 sec->_raw_size += XCOFF_GLINK_SIZE;
2557 /* The global linkage code requires a TOC entry for the
2559 hds = h->descriptor;
2560 BFD_ASSERT ((hds->root.type == bfd_link_hash_undefined
2561 || hds->root.type == bfd_link_hash_undefweak)
2562 && (hds->flags & XCOFF_DEF_REGULAR) == 0
2563 && (hds->flags & XCOFF_REF_DYNAMIC) != 0);
2564 hds->flags |= XCOFF_MARK;
2565 if (hds->toc_section == NULL)
2567 hds->toc_section = xcoff_hash_table (ldinfo->info)->toc_section;
2568 hds->u.toc_offset = hds->toc_section->_raw_size;
2569 hds->toc_section->_raw_size += 4;
2570 ++xcoff_hash_table (ldinfo->info)->ldrel_count;
2571 ++hds->toc_section->reloc_count;
2573 hds->flags |= XCOFF_SET_TOC | XCOFF_LDREL;
2575 /* We need to call xcoff_build_ldsyms recursively here,
2576 because we may already have passed hds on the traversal. */
2577 xcoff_build_ldsyms (hds, p);
2581 /* We need to add a symbol to the .loader section if it is mentioned
2582 in a reloc which we are copying to the .loader section and it was
2583 not defined or common, or if it is the entry point. */
2585 if (((h->flags & XCOFF_LDREL) == 0
2586 || h->root.type == bfd_link_hash_defined
2587 || h->root.type == bfd_link_hash_defweak
2588 || h->root.type == bfd_link_hash_common)
2589 && (h->flags & XCOFF_ENTRY) == 0)
2595 /* We don't need to add this symbol if we did garbage collection and
2596 we did not mark this symbol. */
2597 if (xcoff_hash_table (ldinfo->info)->gc
2598 && (h->flags & XCOFF_MARK) == 0)
2604 /* We may have already processed this symbol due to the recursive
2606 if ((h->flags & XCOFF_BUILT_LDSYM) != 0)
2609 /* We need to add this symbol to the .loader symbols. */
2611 /* h->ldsym will already have been allocated for an explicitly
2613 if (h->ldsym == NULL)
2615 h->ldsym = ((struct internal_ldsym *)
2616 bfd_zalloc (ldinfo->output_bfd,
2617 sizeof (struct internal_ldsym)));
2618 if (h->ldsym == NULL)
2620 ldinfo->failed = true;
2621 bfd_set_error (bfd_error_no_memory);
2626 /* The first 3 symbol table indices are reserved to indicate the
2628 h->ldindx = ldinfo->ldsym_count + 3;
2630 ++ldinfo->ldsym_count;
2632 len = strlen (h->root.root.string);
2633 if (len <= SYMNMLEN)
2634 strncpy (h->ldsym->_l._l_name, h->root.root.string, SYMNMLEN);
2637 if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
2640 bfd_byte *newstrings;
2642 newalc = ldinfo->string_alc * 2;
2645 while (ldinfo->string_size + len + 3 > newalc)
2648 if (ldinfo->strings == NULL)
2649 newstrings = (bfd_byte *) malloc (newalc);
2651 newstrings = ((bfd_byte *)
2652 realloc ((PTR) ldinfo->strings, newalc));
2653 if (newstrings == NULL)
2655 ldinfo->failed = true;
2656 bfd_set_error (bfd_error_no_memory);
2659 ldinfo->string_alc = newalc;
2660 ldinfo->strings = newstrings;
2663 bfd_put_16 (ldinfo->output_bfd, len + 1,
2664 ldinfo->strings + ldinfo->string_size);
2665 strcpy (ldinfo->strings + ldinfo->string_size + 2, h->root.root.string);
2666 h->ldsym->_l._l_l._l_zeroes = 0;
2667 h->ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
2668 ldinfo->string_size += len + 3;
2671 h->flags |= XCOFF_BUILT_LDSYM;
2676 /* Do the final link step. */
2679 _bfd_xcoff_bfd_final_link (abfd, info)
2681 struct bfd_link_info *info;
2683 bfd_size_type symesz;
2684 struct xcoff_final_link_info finfo;
2686 struct bfd_link_order *p;
2687 size_t max_contents_size;
2688 size_t max_sym_count;
2689 size_t max_lineno_count;
2690 size_t max_reloc_count;
2691 size_t max_output_reloc_count;
2692 file_ptr rel_filepos;
2694 file_ptr line_filepos;
2695 unsigned int linesz;
2697 bfd_byte *external_relocs = NULL;
2698 char strbuf[STRING_SIZE_SIZE];
2700 symesz = bfd_coff_symesz (abfd);
2703 finfo.output_bfd = abfd;
2704 finfo.strtab = NULL;
2705 finfo.section_info = NULL;
2706 finfo.last_file_index = -1;
2707 finfo.toc_symindx = -1;
2708 finfo.internal_syms = NULL;
2709 finfo.sym_indices = NULL;
2710 finfo.outsyms = NULL;
2711 finfo.linenos = NULL;
2712 finfo.contents = NULL;
2713 finfo.external_relocs = NULL;
2715 finfo.ldsym = ((struct external_ldsym *)
2716 (xcoff_hash_table (info)->loader_section->contents
2718 finfo.ldrel = ((struct external_ldrel *)
2719 (xcoff_hash_table (info)->loader_section->contents
2721 + xcoff_hash_table (info)->ldhdr.l_nsyms * LDSYMSZ));
2723 xcoff_data (abfd)->coff.link_info = info;
2724 xcoff_data (abfd)->full_aouthdr = true;
2726 finfo.strtab = _bfd_stringtab_init ();
2727 if (finfo.strtab == NULL)
2730 /* Compute the file positions for all the sections. */
2731 if (abfd->output_has_begun)
2733 if (xcoff_hash_table (info)->file_align != 0)
2740 file_align = xcoff_hash_table (info)->file_align;
2741 if (file_align != 0)
2743 boolean saw_contents;
2748 /* Insert .pad sections before every section which has
2749 contents and is loaded, if it is preceded by some other
2750 section which has contents and is loaded. */
2751 saw_contents = true;
2752 for (op = &abfd->sections; *op != NULL; op = &(*op)->next)
2754 (*op)->target_index = indx;
2755 if (strcmp ((*op)->name, ".pad") == 0)
2756 saw_contents = false;
2757 else if (((*op)->flags & SEC_HAS_CONTENTS) != 0
2758 && ((*op)->flags & SEC_LOAD) != 0)
2761 saw_contents = true;
2768 n = bfd_make_section_anyway (abfd, ".pad");
2769 BFD_ASSERT (*op == n);
2771 n->flags = SEC_HAS_CONTENTS;
2772 n->alignment_power = 0;
2773 saw_contents = false;
2778 /* Reset the section indices after inserting the new
2781 for (o = abfd->sections; o != NULL; o = o->next)
2784 o->target_index = indx;
2786 BFD_ASSERT ((unsigned int) indx == abfd->section_count);
2788 /* Work out appropriate sizes for the .pad sections to force
2789 each section to land on a page boundary. This bit of
2790 code knows what compute_section_file_positions is going
2792 sofar = bfd_coff_filhsz (abfd);
2793 sofar += bfd_coff_aoutsz (abfd);
2794 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
2796 for (o = abfd->sections; o != NULL; o = o->next)
2798 if (strcmp (o->name, ".pad") == 0)
2802 BFD_ASSERT (o->_raw_size == 0);
2803 pageoff = sofar & (file_align - 1);
2806 o->_raw_size = file_align - pageoff;
2807 sofar += file_align - pageoff;
2808 o->flags |= SEC_HAS_CONTENTS;
2813 if ((o->flags & SEC_HAS_CONTENTS) != 0)
2814 sofar += BFD_ALIGN (o->_raw_size,
2815 1 << o->alignment_power);
2820 bfd_coff_compute_section_file_positions (abfd);
2823 /* Count the line numbers and relocation entries required for the
2824 output file. Set the file positions for the relocs. */
2825 rel_filepos = obj_relocbase (abfd);
2826 relsz = bfd_coff_relsz (abfd);
2827 max_contents_size = 0;
2828 max_lineno_count = 0;
2829 max_reloc_count = 0;
2830 for (o = abfd->sections; o != NULL; o = o->next)
2833 o->lineno_count = 0;
2834 for (p = o->link_order_head; p != NULL; p = p->next)
2836 if (p->type == bfd_indirect_link_order)
2840 sec = p->u.indirect.section;
2842 if (info->strip == strip_none
2843 || info->strip == strip_some)
2844 o->lineno_count += sec->lineno_count;
2846 o->reloc_count += sec->reloc_count;
2848 if (sec->_raw_size > max_contents_size)
2849 max_contents_size = sec->_raw_size;
2850 if (sec->lineno_count > max_lineno_count)
2851 max_lineno_count = sec->lineno_count;
2852 if (coff_section_data (sec->owner, sec) != NULL
2853 && xcoff_section_data (sec->owner, sec) != NULL
2854 && (xcoff_section_data (sec->owner, sec)->lineno_count
2855 > max_lineno_count))
2857 xcoff_section_data (sec->owner, sec)->lineno_count;
2858 if (sec->reloc_count > max_reloc_count)
2859 max_reloc_count = sec->reloc_count;
2861 else if (p->type == bfd_section_reloc_link_order
2862 || p->type == bfd_symbol_reloc_link_order)
2865 if (o->reloc_count == 0)
2869 o->flags |= SEC_RELOC;
2870 o->rel_filepos = rel_filepos;
2871 rel_filepos += o->reloc_count * relsz;
2875 /* Allocate space for the pointers we need to keep for the relocs. */
2879 /* We use section_count + 1, rather than section_count, because
2880 the target_index fields are 1 based. */
2881 finfo.section_info = ((struct xcoff_link_section_info *)
2882 malloc ((abfd->section_count + 1)
2883 * sizeof (struct xcoff_link_section_info)));
2884 if (finfo.section_info == NULL)
2886 bfd_set_error (bfd_error_no_memory);
2889 for (i = 0; i <= abfd->section_count; i++)
2891 finfo.section_info[i].relocs = NULL;
2892 finfo.section_info[i].rel_hashes = NULL;
2896 /* We now know the size of the relocs, so we can determine the file
2897 positions of the line numbers. */
2898 line_filepos = rel_filepos;
2899 linesz = bfd_coff_linesz (abfd);
2900 max_output_reloc_count = 0;
2901 for (o = abfd->sections; o != NULL; o = o->next)
2903 if (o->lineno_count == 0)
2904 o->line_filepos = 0;
2907 o->line_filepos = line_filepos;
2908 line_filepos += o->lineno_count * linesz;
2911 if (o->reloc_count != 0)
2913 /* We don't know the indices of global symbols until we have
2914 written out all the local symbols. For each section in
2915 the output file, we keep an array of pointers to hash
2916 table entries. Each entry in the array corresponds to a
2917 reloc. When we find a reloc against a global symbol, we
2918 set the corresponding entry in this array so that we can
2919 fix up the symbol index after we have written out all the
2922 Because of this problem, we also keep the relocs in
2923 memory until the end of the link. This wastes memory.
2924 We could backpatch the file later, I suppose, although it
2926 finfo.section_info[o->target_index].relocs =
2927 ((struct internal_reloc *)
2928 malloc (o->reloc_count * sizeof (struct internal_reloc)));
2929 finfo.section_info[o->target_index].rel_hashes =
2930 ((struct xcoff_link_hash_entry **)
2931 malloc (o->reloc_count
2932 * sizeof (struct xcoff_link_hash_entry *)));
2933 if (finfo.section_info[o->target_index].relocs == NULL
2934 || finfo.section_info[o->target_index].rel_hashes == NULL)
2936 bfd_set_error (bfd_error_no_memory);
2940 if (o->reloc_count > max_output_reloc_count)
2941 max_output_reloc_count = o->reloc_count;
2944 /* Reset the reloc and lineno counts, so that we can use them to
2945 count the number of entries we have output so far. */
2947 o->lineno_count = 0;
2950 obj_sym_filepos (abfd) = line_filepos;
2952 /* Figure out the largest number of symbols in an input BFD. Take
2953 the opportunity to clear the output_has_begun fields of all the
2954 input BFD's. We want at least 4 symbols, since that is the
2955 number which xcoff_write_global_symbol may need. */
2957 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2961 sub->output_has_begun = false;
2962 sz = obj_raw_syment_count (sub);
2963 if (sz > max_sym_count)
2967 /* Allocate some buffers used while linking. */
2968 finfo.internal_syms = ((struct internal_syment *)
2969 malloc (max_sym_count
2970 * sizeof (struct internal_syment)));
2971 finfo.sym_indices = (long *) malloc (max_sym_count * sizeof (long));
2972 finfo.outsyms = ((bfd_byte *)
2973 malloc ((size_t) ((max_sym_count + 1) * symesz)));
2974 finfo.linenos = (bfd_byte *) malloc (max_lineno_count
2975 * bfd_coff_linesz (abfd));
2976 finfo.contents = (bfd_byte *) malloc (max_contents_size);
2977 finfo.external_relocs = (bfd_byte *) malloc (max_reloc_count * relsz);
2978 if ((finfo.internal_syms == NULL && max_sym_count > 0)
2979 || (finfo.sym_indices == NULL && max_sym_count > 0)
2980 || finfo.outsyms == NULL
2981 || (finfo.linenos == NULL && max_lineno_count > 0)
2982 || (finfo.contents == NULL && max_contents_size > 0)
2983 || (finfo.external_relocs == NULL && max_reloc_count > 0))
2985 bfd_set_error (bfd_error_no_memory);
2989 obj_raw_syment_count (abfd) = 0;
2990 xcoff_data (abfd)->toc = (bfd_vma) -1;
2992 /* We now know the position of everything in the file, except that
2993 we don't know the size of the symbol table and therefore we don't
2994 know where the string table starts. We just build the string
2995 table in memory as we go along. We process all the relocations
2996 for a single input file at once. */
2997 for (o = abfd->sections; o != NULL; o = o->next)
2999 for (p = o->link_order_head; p != NULL; p = p->next)
3001 if (p->type == bfd_indirect_link_order
3002 && p->u.indirect.section->owner->xvec == abfd->xvec)
3004 sub = p->u.indirect.section->owner;
3005 if (! sub->output_has_begun)
3007 if (! xcoff_link_input_bfd (&finfo, sub))
3009 sub->output_has_begun = true;
3012 else if (p->type == bfd_section_reloc_link_order
3013 || p->type == bfd_symbol_reloc_link_order)
3015 if (! xcoff_reloc_link_order (abfd, &finfo, o, p))
3020 if (! _bfd_default_link_order (abfd, info, o, p))
3026 /* Free up the buffers used by xcoff_link_input_bfd. */
3028 if (finfo.internal_syms != NULL)
3030 free (finfo.internal_syms);
3031 finfo.internal_syms = NULL;
3033 if (finfo.sym_indices != NULL)
3035 free (finfo.sym_indices);
3036 finfo.sym_indices = NULL;
3038 if (finfo.linenos != NULL)
3040 free (finfo.linenos);
3041 finfo.linenos = NULL;
3043 if (finfo.contents != NULL)
3045 free (finfo.contents);
3046 finfo.contents = NULL;
3048 if (finfo.external_relocs != NULL)
3050 free (finfo.external_relocs);
3051 finfo.external_relocs = NULL;
3054 /* The value of the last C_FILE symbol is supposed to be -1. Write
3056 if (finfo.last_file_index != -1)
3058 finfo.last_file.n_value = -1;
3059 bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
3060 (PTR) finfo.outsyms);
3062 (obj_sym_filepos (abfd)
3063 + finfo.last_file_index * symesz),
3065 || bfd_write (finfo.outsyms, symesz, 1, abfd) != symesz)
3069 /* Write out all the global symbols which do not come from XCOFF
3071 xcoff_link_hash_traverse (xcoff_hash_table (info),
3072 xcoff_write_global_symbol,
3075 if (finfo.outsyms != NULL)
3077 free (finfo.outsyms);
3078 finfo.outsyms = NULL;
3081 /* Now that we have written out all the global symbols, we know the
3082 symbol indices to use for relocs against them, and we can finally
3083 write out the relocs. */
3084 external_relocs = (bfd_byte *) malloc (max_output_reloc_count * relsz);
3085 if (external_relocs == NULL && max_output_reloc_count != 0)
3087 bfd_set_error (bfd_error_no_memory);
3091 for (o = abfd->sections; o != NULL; o = o->next)
3093 struct internal_reloc *irel;
3094 struct internal_reloc *irelend;
3095 struct xcoff_link_hash_entry **rel_hash;
3098 if (o->reloc_count == 0)
3101 irel = finfo.section_info[o->target_index].relocs;
3102 irelend = irel + o->reloc_count;
3103 rel_hash = finfo.section_info[o->target_index].rel_hashes;
3104 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
3106 if (*rel_hash != NULL)
3108 if ((*rel_hash)->indx < 0)
3110 if (! ((*info->callbacks->unattached_reloc)
3111 (info, (*rel_hash)->root.root.string,
3112 (bfd *) NULL, o, irel->r_vaddr)))
3114 (*rel_hash)->indx = 0;
3116 irel->r_symndx = (*rel_hash)->indx;
3120 /* XCOFF requires that the relocs be sorted by address. We tend
3121 to produce them in the order in which their containing csects
3122 appear in the symbol table, which is not necessarily by
3123 address. So we sort them here. There may be a better way to
3125 qsort ((PTR) finfo.section_info[o->target_index].relocs,
3126 o->reloc_count, sizeof (struct internal_reloc),
3129 irel = finfo.section_info[o->target_index].relocs;
3130 irelend = irel + o->reloc_count;
3131 erel = external_relocs;
3132 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
3133 bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
3135 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
3136 || bfd_write ((PTR) external_relocs, relsz, o->reloc_count,
3137 abfd) != relsz * o->reloc_count)
3141 if (external_relocs != NULL)
3143 free (external_relocs);
3144 external_relocs = NULL;
3147 /* Free up the section information. */
3148 if (finfo.section_info != NULL)
3152 for (i = 0; i < abfd->section_count; i++)
3154 if (finfo.section_info[i].relocs != NULL)
3155 free (finfo.section_info[i].relocs);
3156 if (finfo.section_info[i].rel_hashes != NULL)
3157 free (finfo.section_info[i].rel_hashes);
3159 free (finfo.section_info);
3160 finfo.section_info = NULL;
3163 /* Write out the loader section contents. */
3164 BFD_ASSERT ((bfd_byte *) finfo.ldrel
3165 == (xcoff_hash_table (info)->loader_section->contents
3166 + xcoff_hash_table (info)->ldhdr.l_impoff));
3167 o = xcoff_hash_table (info)->loader_section;
3168 if (! bfd_set_section_contents (abfd, o->output_section,
3169 o->contents, o->output_offset,
3173 /* Write out the global linkage section and the toc section. */
3174 o = xcoff_hash_table (info)->linkage_section;
3175 if (o->_raw_size > 0
3176 && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
3177 o->output_offset, o->_raw_size))
3179 o = xcoff_hash_table (info)->toc_section;
3180 if (o->_raw_size > 0
3181 && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
3182 o->output_offset, o->_raw_size))
3185 /* Write out the string table. */
3187 (obj_sym_filepos (abfd)
3188 + obj_raw_syment_count (abfd) * symesz),
3192 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
3193 (bfd_byte *) strbuf);
3194 if (bfd_write (strbuf, 1, STRING_SIZE_SIZE, abfd) != STRING_SIZE_SIZE)
3196 if (! _bfd_stringtab_emit (abfd, finfo.strtab))
3199 _bfd_stringtab_free (finfo.strtab);
3201 /* Write out the debugging string table. */
3202 o = xcoff_hash_table (info)->debug_section;
3205 struct bfd_strtab_hash *debug_strtab;
3207 debug_strtab = xcoff_hash_table (info)->debug_strtab;
3208 BFD_ASSERT (o->output_section->_raw_size - o->output_offset
3209 >= _bfd_stringtab_size (debug_strtab));
3211 o->output_section->filepos + o->output_offset,
3214 if (! _bfd_stringtab_emit (abfd, debug_strtab))
3218 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
3219 not try to write out the symbols. */
3220 bfd_get_symcount (abfd) = 0;
3225 if (finfo.strtab != NULL)
3226 _bfd_stringtab_free (finfo.strtab);
3227 if (finfo.section_info != NULL)
3231 for (i = 0; i < abfd->section_count; i++)
3233 if (finfo.section_info[i].relocs != NULL)
3234 free (finfo.section_info[i].relocs);
3235 if (finfo.section_info[i].rel_hashes != NULL)
3236 free (finfo.section_info[i].rel_hashes);
3238 free (finfo.section_info);
3240 if (finfo.internal_syms != NULL)
3241 free (finfo.internal_syms);
3242 if (finfo.sym_indices != NULL)
3243 free (finfo.sym_indices);
3244 if (finfo.outsyms != NULL)
3245 free (finfo.outsyms);
3246 if (finfo.linenos != NULL)
3247 free (finfo.linenos);
3248 if (finfo.contents != NULL)
3249 free (finfo.contents);
3250 if (finfo.external_relocs != NULL)
3251 free (finfo.external_relocs);
3252 if (external_relocs != NULL)
3253 free (external_relocs);
3257 /* Link an input file into the linker output file. This function
3258 handles all the sections and relocations of the input file at once. */
3261 xcoff_link_input_bfd (finfo, input_bfd)
3262 struct xcoff_final_link_info *finfo;
3266 const char *strings;
3267 bfd_size_type syment_base;
3268 unsigned int n_tmask;
3269 unsigned int n_btshft;
3271 bfd_size_type isymesz;
3272 bfd_size_type osymesz;
3273 bfd_size_type linesz;
3276 struct xcoff_link_hash_entry **sym_hash;
3277 struct internal_syment *isymp;
3279 unsigned long *debug_index;
3281 unsigned long output_index;
3287 /* We can just skip DYNAMIC files, unless this is a static link. */
3288 if ((input_bfd->flags & DYNAMIC) != 0
3289 && ! finfo->info->static_link)
3292 /* Move all the symbols to the output file. */
3294 output_bfd = finfo->output_bfd;
3296 syment_base = obj_raw_syment_count (output_bfd);
3297 isymesz = bfd_coff_symesz (input_bfd);
3298 osymesz = bfd_coff_symesz (output_bfd);
3299 linesz = bfd_coff_linesz (input_bfd);
3300 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
3302 n_tmask = coff_data (input_bfd)->local_n_tmask;
3303 n_btshft = coff_data (input_bfd)->local_n_btshft;
3305 /* Define macros so that ISFCN, et. al., macros work correctly. */
3306 #define N_TMASK n_tmask
3307 #define N_BTSHFT n_btshft
3310 if (! finfo->info->keep_memory)
3313 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
3316 if (! _bfd_coff_get_external_symbols (input_bfd))
3319 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
3320 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
3321 sym_hash = obj_xcoff_sym_hashes (input_bfd);
3322 csectpp = xcoff_data (input_bfd)->csects;
3323 debug_index = xcoff_data (input_bfd)->debug_indices;
3324 isymp = finfo->internal_syms;
3325 indexp = finfo->sym_indices;
3326 output_index = syment_base;
3327 outsym = finfo->outsyms;
3330 while (esym < esym_end)
3332 struct internal_syment isym;
3333 union internal_auxent aux;
3339 bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
3341 /* If this is a C_EXT or C_HIDEXT symbol, we need the csect
3343 if (isymp->n_sclass == C_EXT || isymp->n_sclass == C_HIDEXT)
3345 BFD_ASSERT (isymp->n_numaux > 0);
3346 bfd_coff_swap_aux_in (input_bfd,
3347 (PTR) (esym + isymesz * isymp->n_numaux),
3348 isymp->n_type, isymp->n_sclass,
3349 isymp->n_numaux - 1, isymp->n_numaux,
3351 smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
3354 /* Make a copy of *isymp so that the relocate_section function
3355 always sees the original values. This is more reliable than
3356 always recomputing the symbol value even if we are stripping
3360 /* If this symbol is in the .loader section, swap out the
3361 .loader symbol information. If this is an external symbol
3362 reference to a defined symbol, though, then wait until we get
3363 to the definition. */
3364 if (isym.n_sclass == C_EXT
3365 && *sym_hash != NULL
3366 && (*sym_hash)->ldsym != NULL
3368 || (*sym_hash)->root.type == bfd_link_hash_undefined))
3370 struct xcoff_link_hash_entry *h;
3371 struct internal_ldsym *ldsym;
3375 if (isym.n_scnum > 0)
3377 ldsym->l_scnum = (*csectpp)->output_section->target_index;
3378 ldsym->l_value = (isym.n_value
3379 + (*csectpp)->output_section->vma
3380 + (*csectpp)->output_offset
3385 ldsym->l_scnum = isym.n_scnum;
3386 ldsym->l_value = isym.n_value;
3389 ldsym->l_smtype = smtyp;
3390 if (((h->flags & XCOFF_DEF_REGULAR) == 0
3391 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
3392 || (h->flags & XCOFF_IMPORT) != 0)
3393 ldsym->l_smtype |= L_IMPORT;
3394 if (((h->flags & XCOFF_DEF_REGULAR) != 0
3395 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
3396 || (h->flags & XCOFF_EXPORT) != 0)
3397 ldsym->l_smtype |= L_EXPORT;
3398 if ((h->flags & XCOFF_ENTRY) != 0)
3399 ldsym->l_smtype |= L_ENTRY;
3401 ldsym->l_smclas = aux.x_csect.x_smclas;
3403 if (ldsym->l_ifile == (bfd_size_type) -1)
3405 else if (ldsym->l_ifile == 0)
3407 if ((ldsym->l_smtype & L_IMPORT) == 0)
3413 if (h->root.type == bfd_link_hash_defined
3414 || h->root.type == bfd_link_hash_defweak)
3415 impbfd = h->root.u.def.section->owner;
3416 else if (h->root.type == bfd_link_hash_undefined
3417 || h->root.type == bfd_link_hash_undefweak)
3418 impbfd = h->root.u.undef.abfd;
3426 BFD_ASSERT (impbfd->xvec == finfo->output_bfd->xvec);
3427 ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
3434 BFD_ASSERT (h->ldindx >= 0);
3435 BFD_ASSERT (LDSYMSZ == sizeof (struct external_ldsym));
3436 xcoff_swap_ldsym_out (finfo->output_bfd, ldsym,
3437 finfo->ldsym + h->ldindx - 3);
3445 add = 1 + isym.n_numaux;
3447 /* If we are skipping this csect, we want to skip this symbol. */
3448 if (*csectpp == NULL)
3451 /* If we garbage collected this csect, we want to skip this
3454 && xcoff_hash_table (finfo->info)->gc
3455 && ((*csectpp)->flags & SEC_MARK) == 0
3456 && *csectpp != bfd_abs_section_ptr)
3459 /* An XCOFF linker always skips C_STAT symbols. */
3461 && isymp->n_sclass == C_STAT)
3464 /* We skip all but the first TOC anchor. */
3466 && isymp->n_sclass == C_HIDEXT
3467 && aux.x_csect.x_smclas == XMC_TC0)
3469 if (finfo->toc_symindx != -1)
3473 finfo->toc_symindx = output_index;
3474 xcoff_data (finfo->output_bfd)->toc =
3475 ((*csectpp)->output_section->vma
3476 + (*csectpp)->output_offset
3479 xcoff_data (finfo->output_bfd)->toc_section =
3480 (*csectpp)->output_section;
3485 /* If we are stripping all symbols, we want to skip this one. */
3487 && finfo->info->strip == strip_all)
3490 /* We can skip resolved external references. */
3492 && isym.n_sclass == C_EXT
3494 && (*sym_hash)->root.type != bfd_link_hash_undefined)
3497 /* We can skip common symbols if they got defined somewhere
3500 && isym.n_sclass == C_EXT
3502 && (*sym_hash)->root.type != bfd_link_hash_common)
3505 /* Skip local symbols if we are discarding them. */
3507 && finfo->info->discard == discard_all
3508 && isym.n_sclass != C_EXT
3509 && (isym.n_sclass != C_HIDEXT
3510 || smtyp != XTY_SD))
3513 /* If we stripping debugging symbols, and this is a debugging
3514 symbol, then skip it. */
3516 && finfo->info->strip == strip_debugger
3517 && isym.n_scnum == N_DEBUG)
3520 /* If some symbols are stripped based on the name, work out the
3521 name and decide whether to skip this symbol. We don't handle
3522 this correctly for symbols whose names are in the .debug
3523 section; to get it right we would need a new bfd_strtab_hash
3524 function to return the string given the index. */
3526 && (finfo->info->strip == strip_some
3527 || finfo->info->discard == discard_l)
3528 && (debug_index == NULL || *debug_index == (unsigned long) -1))
3531 char buf[SYMNMLEN + 1];
3533 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
3537 if ((finfo->info->strip == strip_some
3538 && (bfd_hash_lookup (finfo->info->keep_hash, name, false,
3540 || (finfo->info->discard == discard_l
3541 && (isym.n_sclass != C_EXT
3542 && (isym.n_sclass != C_HIDEXT
3543 || smtyp != XTY_SD))
3544 && strncmp (name, finfo->info->lprefix,
3545 finfo->info->lprefix_len) == 0))
3549 /* On the other hand, we can't skip global symbols which have
3550 relocs against them. */
3552 && isym.n_sclass == C_EXT
3553 && (*sym_hash)->indx == -2
3554 && finfo->info->strip != strip_all)
3557 /* We can not skip the first TOC anchor. */
3560 && finfo->info->strip != strip_all)
3563 /* We now know whether we are to skip this symbol or not. */
3566 /* Adjust the symbol in order to output it. */
3568 if (isym._n._n_n._n_zeroes == 0
3569 && isym._n._n_n._n_offset != 0)
3571 /* This symbol has a long name. Enter it in the string
3572 table we are building. If *debug_index != -1, the
3573 name has already been entered in the .debug section. */
3574 if (debug_index != NULL && *debug_index != (unsigned long) -1)
3575 isym._n._n_n._n_offset = *debug_index;
3581 name = _bfd_coff_internal_syment_name (input_bfd, &isym,
3585 indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
3586 if (indx == (bfd_size_type) -1)
3588 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
3592 if (isym.n_sclass != C_BSTAT
3593 && isym.n_sclass != C_ESTAT
3594 && isym.n_scnum > 0)
3596 isym.n_scnum = (*csectpp)->output_section->target_index;
3597 isym.n_value += ((*csectpp)->output_section->vma
3598 + (*csectpp)->output_offset
3602 /* The value of a C_FILE symbol is the symbol index of the
3603 next C_FILE symbol. The value of the last C_FILE symbol
3604 is -1. We try to get this right, below, just before we
3605 write the symbols out, but in the general case we may
3606 have to write the symbol out twice. */
3607 if (isym.n_sclass == C_FILE)
3609 if (finfo->last_file_index != -1
3610 && finfo->last_file.n_value != (long) output_index)
3612 /* We must correct the value of the last C_FILE entry. */
3613 finfo->last_file.n_value = output_index;
3614 if ((bfd_size_type) finfo->last_file_index >= syment_base)
3616 /* The last C_FILE symbol is in this input file. */
3617 bfd_coff_swap_sym_out (output_bfd,
3618 (PTR) &finfo->last_file,
3619 (PTR) (finfo->outsyms
3620 + ((finfo->last_file_index
3626 /* We have already written out the last C_FILE
3627 symbol. We need to write it out again. We
3628 borrow *outsym temporarily. */
3629 bfd_coff_swap_sym_out (output_bfd,
3630 (PTR) &finfo->last_file,
3632 if (bfd_seek (output_bfd,
3633 (obj_sym_filepos (output_bfd)
3634 + finfo->last_file_index * osymesz),
3636 || (bfd_write (outsym, osymesz, 1, output_bfd)
3642 finfo->last_file_index = output_index;
3643 finfo->last_file = isym;
3646 /* Output the symbol. */
3648 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
3650 *indexp = output_index;
3652 if (isym.n_sclass == C_EXT)
3655 struct xcoff_link_hash_entry *h;
3657 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
3659 h = obj_xcoff_sym_hashes (input_bfd)[indx];
3660 BFD_ASSERT (h != NULL);
3661 h->indx = output_index;
3664 /* If this is a symbol in the TOC which we may have merged
3665 (class XMC_TC), remember the symbol index of the TOC
3667 if (isym.n_sclass == C_HIDEXT
3668 && aux.x_csect.x_smclas == XMC_TC
3669 && *sym_hash != NULL)
3671 BFD_ASSERT (((*sym_hash)->flags & XCOFF_SET_TOC) == 0);
3672 BFD_ASSERT ((*sym_hash)->toc_section != NULL);
3673 (*sym_hash)->u.toc_indx = output_index;
3676 output_index += add;
3677 outsym += add * osymesz;
3680 esym += add * isymesz;
3684 if (debug_index != NULL)
3687 for (--add; add > 0; --add)
3691 /* Fix up the aux entries and the C_BSTAT symbols. This must be
3692 done in a separate pass, because we don't know the correct symbol
3693 indices until we have already decided which symbols we are going
3696 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
3697 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
3698 isymp = finfo->internal_syms;
3699 indexp = finfo->sym_indices;
3700 csectpp = xcoff_data (input_bfd)->csects;
3701 outsym = finfo->outsyms;
3702 while (esym < esym_end)
3706 add = 1 + isymp->n_numaux;
3709 esym += add * isymesz;
3714 if (isymp->n_sclass == C_BSTAT)
3718 /* The value of a C_BSTAT symbol is the symbol table
3719 index of the containing csect. */
3720 indx = isymp->n_value;
3721 if (indx < obj_raw_syment_count (input_bfd))
3725 symindx = finfo->sym_indices[indx];
3729 isymp->n_value = symindx;
3730 bfd_coff_swap_sym_out (output_bfd, (PTR) isymp,
3738 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
3740 union internal_auxent aux;
3742 bfd_coff_swap_aux_in (input_bfd, (PTR) esym, isymp->n_type,
3743 isymp->n_sclass, i, isymp->n_numaux,
3746 if (isymp->n_sclass == C_FILE)
3748 /* This is the file name (or some comment put in by
3749 the compiler). If it is long, we must put it in
3750 the string table. */
3751 if (aux.x_file.x_n.x_zeroes == 0
3752 && aux.x_file.x_n.x_offset != 0)
3754 const char *filename;
3757 BFD_ASSERT (aux.x_file.x_n.x_offset
3758 >= STRING_SIZE_SIZE);
3759 if (strings == NULL)
3761 strings = _bfd_coff_read_string_table (input_bfd);
3762 if (strings == NULL)
3765 filename = strings + aux.x_file.x_n.x_offset;
3766 indx = _bfd_stringtab_add (finfo->strtab, filename,
3768 if (indx == (bfd_size_type) -1)
3770 aux.x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
3773 else if ((isymp->n_sclass == C_EXT
3774 || isymp->n_sclass == C_HIDEXT)
3775 && i + 1 == isymp->n_numaux)
3777 /* We don't support type checking. I don't know if
3779 aux.x_csect.x_parmhash = 0;
3780 /* I don't think anybody uses these fields, but we'd
3781 better clobber them just in case. */
3782 aux.x_csect.x_stab = 0;
3783 aux.x_csect.x_snstab = 0;
3784 if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_LD)
3788 indx = aux.x_csect.x_scnlen.l;
3789 if (indx < obj_raw_syment_count (input_bfd))
3793 symindx = finfo->sym_indices[indx];
3795 aux.x_sym.x_tagndx.l = 0;
3797 aux.x_sym.x_tagndx.l = symindx;
3801 else if (isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
3805 if (ISFCN (isymp->n_type)
3806 || ISTAG (isymp->n_sclass)
3807 || isymp->n_sclass == C_BLOCK)
3809 indx = aux.x_sym.x_fcnary.x_fcn.x_endndx.l;
3811 && indx < obj_raw_syment_count (input_bfd))
3813 /* We look forward through the symbol for
3814 the index of the next symbol we are going
3815 to include. I don't know if this is
3817 while (finfo->sym_indices[indx] < 0
3818 && indx < obj_raw_syment_count (input_bfd))
3820 if (indx >= obj_raw_syment_count (input_bfd))
3821 indx = output_index;
3823 indx = finfo->sym_indices[indx];
3824 aux.x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
3828 indx = aux.x_sym.x_tagndx.l;
3829 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
3833 symindx = finfo->sym_indices[indx];
3835 aux.x_sym.x_tagndx.l = 0;
3837 aux.x_sym.x_tagndx.l = symindx;
3841 /* Copy over the line numbers, unless we are stripping
3842 them. We do this on a symbol by symbol basis in
3843 order to more easily handle garbage collection. */
3844 if ((isymp->n_sclass == C_EXT
3845 || isymp->n_sclass == C_HIDEXT)
3847 && isymp->n_numaux > 1
3848 && ISFCN (isymp->n_type)
3849 && aux.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
3851 if (finfo->info->strip != strip_none
3852 && finfo->info->strip != strip_some)
3853 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
3856 asection *enclosing;
3857 unsigned int enc_count;
3858 bfd_size_type linoff;
3859 struct internal_lineno lin;
3862 enclosing = xcoff_section_data (abfd, o)->enclosing;
3863 enc_count = xcoff_section_data (abfd, o)->lineno_count;
3864 if (oline != enclosing)
3866 if (bfd_seek (input_bfd,
3867 enclosing->line_filepos,
3869 || (bfd_read (finfo->linenos, linesz,
3870 enc_count, input_bfd)
3871 != linesz * enc_count))
3876 linoff = (aux.x_sym.x_fcnary.x_fcn.x_lnnoptr
3877 - enclosing->line_filepos);
3879 bfd_coff_swap_lineno_in (input_bfd,
3880 (PTR) (finfo->linenos + linoff),
3883 || ((bfd_size_type) lin.l_addr.l_symndx
3887 obj_coff_external_syms (input_bfd)))
3889 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
3892 bfd_byte *linpend, *linp;
3894 bfd_size_type count;
3896 lin.l_addr.l_symndx = *indexp;
3897 bfd_coff_swap_lineno_out (output_bfd, (PTR) &lin,
3898 (PTR) (finfo->linenos
3901 linpend = (finfo->linenos
3902 + enc_count * linesz);
3903 offset = (o->output_section->vma
3906 for (linp = finfo->linenos + linoff + linesz;
3910 bfd_coff_swap_lineno_in (input_bfd, (PTR) linp,
3912 if (lin.l_lnno == 0)
3914 lin.l_addr.l_paddr += offset;
3915 bfd_coff_swap_lineno_out (output_bfd,
3920 count = (linp - (finfo->linenos + linoff)) / linesz;
3922 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr =
3923 (o->output_section->line_filepos
3924 + o->output_section->lineno_count * linesz);
3926 if (bfd_seek (output_bfd,
3927 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr,
3929 || (bfd_write (finfo->linenos + linoff,
3930 linesz, count, output_bfd)
3934 o->output_section->lineno_count += count;
3939 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, isymp->n_type,
3940 isymp->n_sclass, i, isymp->n_numaux,
3952 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
3953 symbol will be the first symbol in the next input file. In the
3954 normal case, this will save us from writing out the C_FILE symbol
3956 if (finfo->last_file_index != -1
3957 && (bfd_size_type) finfo->last_file_index >= syment_base)
3959 finfo->last_file.n_value = output_index;
3960 bfd_coff_swap_sym_out (output_bfd, (PTR) &finfo->last_file,
3961 (PTR) (finfo->outsyms
3962 + ((finfo->last_file_index - syment_base)
3966 /* Write the modified symbols to the output file. */
3967 if (outsym > finfo->outsyms)
3969 if (bfd_seek (output_bfd,
3970 obj_sym_filepos (output_bfd) + syment_base * osymesz,
3972 || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1,
3974 != (bfd_size_type) (outsym - finfo->outsyms)))
3977 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
3978 + (outsym - finfo->outsyms) / osymesz)
3981 obj_raw_syment_count (output_bfd) = output_index;
3984 /* Don't let the linker relocation routines discard the symbols. */
3985 keep_syms = obj_coff_keep_syms (input_bfd);
3986 obj_coff_keep_syms (input_bfd) = true;
3988 /* Relocate the contents of each section. */
3989 for (o = input_bfd->sections; o != NULL; o = o->next)
3993 if ((o->flags & SEC_HAS_CONTENTS) == 0
3994 || o->_raw_size == 0
3995 || (o->flags & SEC_IN_MEMORY) != 0)
3998 /* We have set filepos correctly for the sections we created to
3999 represent csects, so bfd_get_section_contents should work. */
4000 if (coff_section_data (input_bfd, o) != NULL
4001 && coff_section_data (input_bfd, o)->contents != NULL)
4002 contents = coff_section_data (input_bfd, o)->contents;
4005 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
4006 (file_ptr) 0, o->_raw_size))
4008 contents = finfo->contents;
4011 if ((o->flags & SEC_RELOC) != 0)
4014 struct internal_reloc *internal_relocs;
4015 struct internal_reloc *irel;
4017 struct internal_reloc *irelend;
4018 struct xcoff_link_hash_entry **rel_hash;
4021 /* Read in the relocs. */
4022 target_index = o->output_section->target_index;
4023 internal_relocs = (xcoff_read_internal_relocs
4024 (input_bfd, o, false, finfo->external_relocs,
4026 (finfo->section_info[target_index].relocs
4027 + o->output_section->reloc_count)));
4028 if (internal_relocs == NULL)
4031 /* Call processor specific code to relocate the section
4033 if (! bfd_coff_relocate_section (output_bfd, finfo->info,
4037 finfo->internal_syms,
4038 xcoff_data (input_bfd)->csects))
4041 offset = o->output_section->vma + o->output_offset - o->vma;
4042 irel = internal_relocs;
4043 irelend = irel + o->reloc_count;
4044 rel_hash = (finfo->section_info[target_index].rel_hashes
4045 + o->output_section->reloc_count);
4046 for (; irel < irelend; irel++, rel_hash++)
4048 struct xcoff_link_hash_entry *h = NULL;
4049 struct internal_ldrel ldrel;
4053 /* Adjust the reloc address and symbol index. */
4055 irel->r_vaddr += offset;
4057 r_symndx = irel->r_symndx;
4061 h = obj_xcoff_sym_hashes (input_bfd)[r_symndx];
4063 && (irel->r_type == R_TOC
4064 || irel->r_type == R_GL
4065 || irel->r_type == R_TCL
4066 || irel->r_type == R_TRL
4067 || irel->r_type == R_TRLA))
4069 /* This is a TOC relative reloc with a symbol
4070 attached. The symbol should be the one which
4071 this reloc is for. We want to make this
4072 reloc against the TOC address of the symbol,
4073 not the symbol itself. */
4074 BFD_ASSERT (h->toc_section != NULL);
4075 BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
4076 if (h->u.toc_indx == -1)
4078 /* We could handle this case if we had to,
4079 but I don't think it can arise. */
4080 (*_bfd_error_handler)
4081 ("%s: unattached TOC reloc against `%s'",
4082 bfd_get_filename (input_bfd),
4083 h->root.root.string);
4084 bfd_set_error (bfd_error_bad_value);
4087 irel->r_symndx = h->u.toc_indx;
4091 /* This is a global symbol. */
4093 irel->r_symndx = h->indx;
4096 /* This symbol is being written at the end
4097 of the file, and we do not yet know the
4098 symbol index. We save the pointer to the
4099 hash table entry in the rel_hash list.
4100 We set the indx field to -2 to indicate
4101 that this symbol must not be stripped. */
4110 indx = finfo->sym_indices[r_symndx];
4114 struct internal_syment *is;
4116 /* Relocations against a TC0 TOC anchor are
4117 automatically transformed to be against
4118 the TOC anchor in the output file. */
4119 is = finfo->internal_syms + r_symndx;
4120 if (is->n_sclass == C_HIDEXT
4121 && is->n_numaux > 0)
4124 union internal_auxent aux;
4128 obj_coff_external_syms (input_bfd))
4129 + ((r_symndx + is->n_numaux)
4131 bfd_coff_swap_aux_in (input_bfd, auxptr,
4132 is->n_type, is->n_sclass,
4136 if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_SD
4137 && aux.x_csect.x_smclas == XMC_TC0)
4138 indx = finfo->toc_symindx;
4143 irel->r_symndx = indx;
4146 struct internal_syment *is;
4148 char buf[SYMNMLEN + 1];
4150 /* This reloc is against a symbol we are
4151 stripping. It would be possible to handle
4152 this case, but I don't think it's worth it. */
4153 is = finfo->internal_syms + r_symndx;
4155 name = (_bfd_coff_internal_syment_name
4156 (input_bfd, is, buf));
4160 if (! ((*finfo->info->callbacks->unattached_reloc)
4161 (finfo->info, name, input_bfd, o,
4168 switch (irel->r_type)
4172 || h->root.type == bfd_link_hash_defined
4173 || h->root.type == bfd_link_hash_defweak
4174 || h->root.type == bfd_link_hash_common)
4181 /* This reloc needs to be copied into the .loader
4183 ldrel.l_vaddr = irel->r_vaddr;
4185 ldrel.l_symndx = -1;
4187 || (h->root.type == bfd_link_hash_defined
4188 || h->root.type == bfd_link_hash_defweak
4189 || h->root.type == bfd_link_hash_common))
4194 sec = xcoff_data (input_bfd)->csects[r_symndx];
4195 else if (h->root.type == bfd_link_hash_common)
4196 sec = h->root.u.c.p->section;
4198 sec = h->root.u.def.section;
4199 sec = sec->output_section;
4201 if (strcmp (sec->name, ".text") == 0)
4203 else if (strcmp (sec->name, ".data") == 0)
4205 else if (strcmp (sec->name, ".bss") == 0)
4209 (*_bfd_error_handler)
4210 ("%s: loader reloc in unrecognized section `%s'",
4211 bfd_get_filename (input_bfd),
4213 bfd_set_error (bfd_error_nonrepresentable_section);
4221 (*_bfd_error_handler)
4222 ("%s: `%s' in loader reloc but not loader sym",
4223 bfd_get_filename (input_bfd),
4224 h->root.root.string);
4225 bfd_set_error (bfd_error_bad_value);
4228 ldrel.l_symndx = h->ldindx;
4230 ldrel.l_rtype = (irel->r_size << 8) | irel->r_type;
4231 ldrel.l_rsecnm = o->output_section->target_index;
4232 if (xcoff_hash_table (finfo->info)->textro
4233 && strcmp (o->output_section->name, ".text") == 0)
4235 (*_bfd_error_handler)
4236 ("%s: loader reloc in read-only section %s",
4237 bfd_get_filename (input_bfd),
4238 bfd_get_section_name (finfo->output_bfd,
4239 o->output_section));
4240 bfd_set_error (bfd_error_invalid_operation);
4243 xcoff_swap_ldrel_out (output_bfd, &ldrel,
4245 BFD_ASSERT (sizeof (struct external_ldrel) == LDRELSZ);
4254 /* We should never need a .loader reloc for a TOC
4260 o->output_section->reloc_count += o->reloc_count;
4263 /* Write out the modified section contents. */
4264 if (! bfd_set_section_contents (output_bfd, o->output_section,
4265 contents, o->output_offset,
4266 (o->_cooked_size != 0
4272 obj_coff_keep_syms (input_bfd) = keep_syms;
4274 if (! finfo->info->keep_memory)
4276 if (! _bfd_coff_free_symbols (input_bfd))
4286 /* Write out a non-XCOFF global symbol. */
4289 xcoff_write_global_symbol (h, p)
4290 struct xcoff_link_hash_entry *h;
4293 struct xcoff_final_link_info *finfo = (struct xcoff_final_link_info *) p;
4296 struct internal_syment isym;
4297 union internal_auxent aux;
4299 output_bfd = finfo->output_bfd;
4301 /* If this symbol was garbage collected, just skip it. */
4302 if (xcoff_hash_table (finfo->info)->gc
4303 && (h->flags & XCOFF_MARK) == 0)
4306 /* If we need a .loader section entry, write it out. */
4307 if (h->ldsym != NULL)
4309 struct internal_ldsym *ldsym;
4314 if (h->root.type == bfd_link_hash_undefined
4315 || h->root.type == bfd_link_hash_undefweak)
4318 ldsym->l_scnum = N_UNDEF;
4319 ldsym->l_smtype = XTY_ER;
4320 impbfd = h->root.u.undef.abfd;
4322 else if (h->root.type == bfd_link_hash_defined
4323 || h->root.type == bfd_link_hash_defweak)
4327 sec = h->root.u.def.section;
4328 ldsym->l_value = (sec->output_section->vma
4329 + sec->output_offset
4330 + h->root.u.def.value);
4331 ldsym->l_scnum = sec->output_section->target_index;
4332 ldsym->l_smtype = XTY_SD;
4333 impbfd = sec->owner;
4338 if (((h->flags & XCOFF_DEF_REGULAR) == 0
4339 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
4340 || (h->flags & XCOFF_IMPORT) != 0)
4341 ldsym->l_smtype |= L_IMPORT;
4342 if (((h->flags & XCOFF_DEF_REGULAR) != 0
4343 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
4344 || (h->flags & XCOFF_EXPORT) != 0)
4345 ldsym->l_smtype |= L_EXPORT;
4346 if ((h->flags & XCOFF_ENTRY) != 0)
4347 ldsym->l_smtype |= L_ENTRY;
4349 ldsym->l_smclas = h->smclas;
4351 if (ldsym->l_ifile == (bfd_size_type) -1)
4353 else if (ldsym->l_ifile == 0)
4355 if ((ldsym->l_smtype & L_IMPORT) == 0)
4357 else if (impbfd == NULL)
4361 BFD_ASSERT (impbfd->xvec == output_bfd->xvec);
4362 ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
4368 BFD_ASSERT (h->ldindx >= 0);
4369 BFD_ASSERT (LDSYMSZ == sizeof (struct external_ldsym));
4370 xcoff_swap_ldsym_out (output_bfd, ldsym, finfo->ldsym + h->ldindx - 3);
4374 /* If this symbol needs global linkage code, write it out. */
4375 if (h->root.type == bfd_link_hash_defined
4376 && (h->root.u.def.section
4377 == xcoff_hash_table (finfo->info)->linkage_section))
4383 p = h->root.u.def.section->contents + h->root.u.def.value;
4385 /* The first instruction in the global linkage code loads a
4386 specific TOC element. */
4387 tocoff = (h->descriptor->toc_section->output_section->vma
4388 + h->descriptor->toc_section->output_offset
4389 - xcoff_data (output_bfd)->toc);
4390 if ((h->descriptor->flags & XCOFF_SET_TOC) != 0)
4391 tocoff += h->descriptor->u.toc_offset;
4392 bfd_put_32 (output_bfd, XCOFF_GLINK_FIRST | tocoff, p);
4394 i < sizeof xcoff_glink_code / sizeof xcoff_glink_code[0];
4396 bfd_put_32 (output_bfd, xcoff_glink_code[i], p);
4399 /* If we created a TOC entry for this symbol, write out the required
4401 if ((h->flags & XCOFF_SET_TOC) != 0)
4406 struct internal_reloc *irel;
4407 struct internal_ldrel ldrel;
4409 tocsec = h->toc_section;
4410 osec = tocsec->output_section;
4411 oindx = osec->target_index;
4412 irel = finfo->section_info[oindx].relocs + osec->reloc_count;
4413 irel->r_vaddr = (osec->vma
4414 + tocsec->output_offset
4417 irel->r_symndx = h->indx;
4421 irel->r_symndx = obj_raw_syment_count (output_bfd);
4423 irel->r_type = R_POS;
4425 finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
4426 ++osec->reloc_count;
4428 BFD_ASSERT (h->ldindx >= 0);
4429 ldrel.l_vaddr = irel->r_vaddr;
4430 ldrel.l_symndx = h->ldindx;
4431 ldrel.l_rtype = (31 << 8) | R_POS;
4432 ldrel.l_rsecnm = oindx;
4433 xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
4441 && (finfo->info->strip == strip_all
4442 || (finfo->info->strip == strip_some
4443 && (bfd_hash_lookup (finfo->info->keep_hash,
4444 h->root.root.string, false, false)
4449 && (h->flags & (XCOFF_REF_REGULAR | XCOFF_DEF_REGULAR)) == 0)
4452 outsym = finfo->outsyms;
4454 memset (&aux, 0, sizeof aux);
4456 h->indx = obj_raw_syment_count (output_bfd);
4458 if (strlen (h->root.root.string) <= SYMNMLEN)
4459 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
4466 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
4468 indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
4470 if (indx == (bfd_size_type) -1)
4472 isym._n._n_n._n_zeroes = 0;
4473 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
4476 if (h->root.type == bfd_link_hash_undefined
4477 || h->root.type == bfd_link_hash_undefweak)
4480 isym.n_scnum = N_UNDEF;
4481 isym.n_sclass = C_EXT;
4482 aux.x_csect.x_smtyp = XTY_ER;
4484 else if (h->root.type == bfd_link_hash_defined
4485 || h->root.type == bfd_link_hash_defweak)
4487 isym.n_value = (h->root.u.def.section->output_section->vma
4488 + h->root.u.def.section->output_offset
4489 + h->root.u.def.value);
4490 isym.n_scnum = h->root.u.def.section->output_section->target_index;
4491 isym.n_sclass = C_HIDEXT;
4492 aux.x_csect.x_smtyp = XTY_SD;
4493 /* I don't know what the csect length should be in this case. */
4498 isym.n_type = T_NULL;
4501 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
4502 outsym += bfd_coff_symesz (output_bfd);
4504 aux.x_csect.x_smclas = h->smclas;
4506 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, isym.n_sclass, 0, 1,
4508 outsym += bfd_coff_auxesz (output_bfd);
4510 if (h->root.type == bfd_link_hash_defined
4511 || h->root.type == bfd_link_hash_defweak)
4513 /* We just output an SD symbol. Now output an LD symbol. */
4517 isym.n_sclass = C_EXT;
4518 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
4519 outsym += bfd_coff_symesz (output_bfd);
4521 aux.x_csect.x_smtyp = XTY_LD;
4522 aux.x_csect.x_scnlen.l = obj_raw_syment_count (output_bfd);
4524 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, C_EXT, 0, 1,
4526 outsym += bfd_coff_auxesz (output_bfd);
4529 if (bfd_seek (output_bfd,
4530 (obj_sym_filepos (output_bfd)
4531 + (obj_raw_syment_count (output_bfd)
4532 * bfd_coff_symesz (output_bfd))),
4534 || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1, output_bfd)
4535 != (bfd_size_type) (outsym - finfo->outsyms)))
4537 obj_raw_syment_count (output_bfd) +=
4538 (outsym - finfo->outsyms) / bfd_coff_symesz (output_bfd);
4543 /* Handle a link order which is supposed to generate a reloc. */
4546 xcoff_reloc_link_order (output_bfd, finfo, output_section, link_order)
4548 struct xcoff_final_link_info *finfo;
4549 asection *output_section;
4550 struct bfd_link_order *link_order;
4552 reloc_howto_type *howto;
4553 struct internal_reloc *irel;
4554 struct xcoff_link_hash_entry **rel_hash_ptr;
4556 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
4559 bfd_set_error (bfd_error_bad_value);
4563 if (link_order->u.reloc.p->addend != 0)
4567 bfd_reloc_status_type rstat;
4570 size = bfd_get_reloc_size (howto);
4571 buf = (bfd_byte *) bfd_zmalloc (size);
4574 bfd_set_error (bfd_error_no_memory);
4578 rstat = _bfd_relocate_contents (howto, output_bfd,
4579 link_order->u.reloc.p->addend, buf);
4585 case bfd_reloc_outofrange:
4587 case bfd_reloc_overflow:
4588 if (! ((*finfo->info->callbacks->reloc_overflow)
4590 (link_order->type == bfd_section_reloc_link_order
4591 ? bfd_section_name (output_bfd,
4592 link_order->u.reloc.p->u.section)
4593 : link_order->u.reloc.p->u.name),
4594 howto->name, link_order->u.reloc.p->addend,
4595 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
4602 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
4603 (file_ptr) link_order->offset, size);
4609 /* Store the reloc information in the right place. It will get
4610 swapped and written out at the end of the final_link routine. */
4612 irel = (finfo->section_info[output_section->target_index].relocs
4613 + output_section->reloc_count);
4614 rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
4615 + output_section->reloc_count);
4617 memset (irel, 0, sizeof (struct internal_reloc));
4618 *rel_hash_ptr = NULL;
4620 irel->r_vaddr = output_section->vma + link_order->offset;
4622 if (link_order->type == bfd_section_reloc_link_order)
4624 /* We need to somehow locate a symbol in the right section. The
4625 symbol must either have a value of zero, or we must adjust
4626 the addend by the value of the symbol. FIXME: Write this
4627 when we need it. The old linker couldn't handle this anyhow. */
4629 *rel_hash_ptr = NULL;
4634 struct xcoff_link_hash_entry *h;
4636 h = xcoff_link_hash_lookup (xcoff_hash_table (finfo->info),
4637 link_order->u.reloc.p->u.name,
4638 false, false, true);
4642 irel->r_symndx = h->indx;
4645 /* Set the index to -2 to force this symbol to get
4654 if (! ((*finfo->info->callbacks->unattached_reloc)
4655 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
4656 (asection *) NULL, (bfd_vma) 0)))
4662 irel->r_type = howto->type;
4663 irel->r_size = howto->bitsize - 1;
4664 if (howto->complain_on_overflow == complain_overflow_signed)
4665 irel->r_size |= 0x80;
4667 ++output_section->reloc_count;
4672 /* Sort relocs by VMA. This is called via qsort. */
4675 xcoff_sort_relocs (p1, p2)
4679 const struct internal_reloc *r1 = (const struct internal_reloc *) p1;
4680 const struct internal_reloc *r2 = (const struct internal_reloc *) p2;
4682 if (r1->r_vaddr > r2->r_vaddr)
4684 else if (r1->r_vaddr < r2->r_vaddr)
4690 /* This is the relocation function for the RS/6000/POWER/PowerPC.
4691 This is currently the only processor which uses XCOFF; I hope that
4692 will never change. */
4695 _bfd_ppc_xcoff_relocate_section (output_bfd, info, input_bfd,
4696 input_section, contents, relocs, syms,
4699 struct bfd_link_info *info;
4701 asection *input_section;
4703 struct internal_reloc *relocs;
4704 struct internal_syment *syms;
4705 asection **sections;
4707 struct internal_reloc *rel;
4708 struct internal_reloc *relend;
4711 relend = rel + input_section->reloc_count;
4712 for (; rel < relend; rel++)
4715 struct xcoff_link_hash_entry *h;
4716 struct internal_syment *sym;
4719 struct reloc_howto_struct howto;
4720 bfd_reloc_status_type rstat;
4722 /* Relocation type R_REF is a special relocation type which is
4723 merely used to prevent garbage collection from occurring for
4724 the csect including the symbol which it references. */
4725 if (rel->r_type == R_REF)
4728 symndx = rel->r_symndx;
4738 h = obj_xcoff_sym_hashes (input_bfd)[symndx];
4739 sym = syms + symndx;
4740 addend = - sym->n_value;
4743 /* We build the howto information on the fly. */
4745 howto.type = rel->r_type;
4746 howto.rightshift = 0;
4748 howto.bitsize = (rel->r_size & 0x1f) + 1;
4749 howto.pc_relative = false;
4751 if ((rel->r_size & 0x80) != 0)
4752 howto.complain_on_overflow = complain_overflow_signed;
4754 howto.complain_on_overflow = complain_overflow_bitfield;
4755 howto.special_function = NULL;
4756 howto.name = "internal";
4757 howto.partial_inplace = true;
4758 if (howto.bitsize == 32)
4759 howto.src_mask = howto.dst_mask = 0xffffffff;
4762 howto.src_mask = howto.dst_mask = (1 << howto.bitsize) - 1;
4763 if (howto.bitsize == 16)
4766 howto.pcrel_offset = false;
4776 sec = bfd_abs_section_ptr;
4781 sec = sections[symndx];
4782 val = (sec->output_section->vma
4783 + sec->output_offset
4790 if (h->root.type == bfd_link_hash_defined
4791 || h->root.type == bfd_link_hash_defweak)
4795 sec = h->root.u.def.section;
4796 val = (h->root.u.def.value
4797 + sec->output_section->vma
4798 + sec->output_offset);
4800 else if ((h->flags & XCOFF_REF_DYNAMIC) != 0
4801 || (h->flags & XCOFF_IMPORT) != 0)
4803 /* Every symbol in a shared object is defined somewhere. */
4806 else if (! info->relocateable)
4808 if (! ((*info->callbacks->undefined_symbol)
4809 (info, h->root.root.string, input_bfd, input_section,
4810 rel->r_vaddr - input_section->vma)))
4815 /* I took the relocation type definitions from two documents:
4816 the PowerPC AIX Version 4 Application Binary Interface, First
4817 Edition (April 1992), and the PowerOpen ABI, Big-Endian
4818 32-Bit Hardware Implementation (June 30, 1994). Differences
4819 between the documents are noted below. */
4821 switch (rel->r_type)
4826 /* These relocs are defined by the PowerPC ABI to be
4827 relative branches which use half of the difference
4828 between the symbol and the program counter. I can't
4829 quite figure out when this is useful. These relocs are
4830 not defined by the PowerOpen ABI. */
4832 (*_bfd_error_handler)
4833 ("%s: unsupported relocation type 0x%02x",
4834 bfd_get_filename (input_bfd), (unsigned int) rel->r_type);
4835 bfd_set_error (bfd_error_bad_value);
4838 /* Simple positive relocation. */
4841 /* Simple negative relocation. */
4845 /* Simple PC relative relocation. */
4846 howto.pc_relative = true;
4849 /* TOC relative relocation. The value in the instruction in
4850 the input file is the offset from the input file TOC to
4851 the desired location. We want the offset from the final
4852 TOC to the desired location. We have:
4857 so we must change insn by on - in.
4860 /* Global linkage relocation. The value of this relocation
4861 is the address of the entry in the TOC section. */
4863 /* Local object TOC address. I can't figure out the
4864 difference between this and case R_GL. */
4866 /* TOC relative relocation. A TOC relative load instruction
4867 which may be changed to a load address instruction.
4868 FIXME: We don't currently implement this optimization. */
4870 /* TOC relative relocation. This is a TOC relative load
4871 address instruction which may be changed to a load
4872 instruction. FIXME: I don't know if this is the correct
4874 if (h != NULL && h->toc_section == NULL)
4876 (*_bfd_error_handler)
4877 ("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry",
4878 bfd_get_filename (input_bfd), rel->r_vaddr,
4879 h->root.root.string);
4880 bfd_set_error (bfd_error_bad_value);
4885 BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
4886 val = (h->toc_section->output_section->vma
4887 + h->toc_section->output_offset);
4889 val = ((val - xcoff_data (output_bfd)->toc)
4890 - (sym->n_value - xcoff_data (input_bfd)->toc));
4894 /* Absolute branch. We don't want to mess with the lower
4895 two bits of the instruction. */
4897 /* The PowerPC ABI defines this as an absolute call which
4898 may be modified to become a relative call. The PowerOpen
4899 ABI does not define this relocation type. */
4901 /* Absolute branch which may be modified to become a
4904 /* The PowerPC ABI defines this as an absolute branch to a
4905 fixed address which may be modified to an absolute branch
4906 to a symbol. The PowerOpen ABI does not define this
4909 /* The PowerPC ABI defines this as an absolute branch to a
4910 fixed address which may be modified to a relative branch.
4911 The PowerOpen ABI does not define this relocation type. */
4912 howto.src_mask &= ~3;
4913 howto.dst_mask = howto.src_mask;
4916 /* Relative branch. We don't want to mess with the lower
4917 two bits of the instruction. */
4919 /* The PowerPC ABI defines this as a relative call which may
4920 be modified to become an absolute call. The PowerOpen
4921 ABI does not define this relocation type. */
4923 /* A relative branch which may be modified to become an
4924 absolute branch. FIXME: We don't implement this,
4925 although we should for symbols of storage mapping class
4927 howto.pc_relative = true;
4928 howto.src_mask &= ~3;
4929 howto.dst_mask = howto.src_mask;
4932 /* The PowerPC AIX ABI describes this as a load which may be
4933 changed to a load address. The PowerOpen ABI says this
4934 is the same as case R_POS. */
4937 /* The PowerPC AIX ABI describes this as a load address
4938 which may be changed to a load. The PowerOpen ABI says
4939 this is the same as R_POS. */
4943 /* If we see an R_BR or R_RBR reloc which is jumping to global
4944 linkage code, and it is followed by an appropriate cror nop
4945 instruction, we replace the cror with lwz r2,20(r1). This
4946 restores the TOC after the glink code. Contrariwise, if the
4947 call is followed by a lwz r2,20(r1), but the call is not
4948 going to global linkage code, we can replace the load with a
4950 if ((rel->r_type == R_BR || rel->r_type == R_RBR)
4952 && h->root.type == bfd_link_hash_defined
4953 && (rel->r_vaddr - input_section->vma + 8
4954 <= input_section->_cooked_size))
4959 pnext = contents + (rel->r_vaddr - input_section->vma) + 4;
4960 next = bfd_get_32 (input_bfd, pnext);
4961 if (h->smclas == XMC_GL)
4963 if (next == 0x4def7b82 /* cror 15,15,15 */
4964 || next == 0x4ffffb82) /* cror 31,31,31 */
4965 bfd_put_32 (input_bfd, 0x80410014, pnext); /* lwz r1,20(r1) */
4969 if (next == 0x80410014) /* lwz r1,20(r1) */
4970 bfd_put_32 (input_bfd, 0x4ffffb82, pnext); /* cror 31,31,31 */
4974 /* A PC relative reloc includes the section address. */
4975 if (howto.pc_relative)
4976 addend += input_section->vma;
4978 rstat = _bfd_final_link_relocate (&howto, input_bfd, input_section,
4980 rel->r_vaddr - input_section->vma,
4989 case bfd_reloc_overflow:
4992 char buf[SYMNMLEN + 1];
4993 char howto_name[10];
4998 name = h->root.root.string;
5001 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
5005 sprintf (howto_name, "0x%02x", rel->r_type);
5007 if (! ((*info->callbacks->reloc_overflow)
5008 (info, name, howto_name, (bfd_vma) 0, input_bfd,
5009 input_section, rel->r_vaddr - input_section->vma)))