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. A lot of it is very similar
29 to the COFF linker code. However, it is different enough that I
30 chose to avoid trying to hack up the COFF code to support XCOFF.
31 That leads to a certain amount of duplicated code, alas. */
33 #define STRING_SIZE_SIZE (4)
35 /* Get the XCOFF hash table entries for a BFD. */
36 #define obj_xcoff_sym_hashes(bfd) \
37 ((struct xcoff_link_hash_entry **) obj_coff_sym_hashes (bfd))
39 /* XCOFF relocation types. These probably belong in a header file
40 somewhere. The relocations are described in the function
41 _bfd_ppc_xcoff_relocate_section in this file. */
57 #define R_RRTBI (0x14)
58 #define R_RRTBA (0x15)
66 /* The first word of global linkage code. This must be modified by
67 filling in the correct TOC offset. */
69 #define XCOFF_GLINK_FIRST (0x81820000) /* lwz r12,0(r2) */
71 /* The remaining words of global linkage code. */
73 static unsigned long xcoff_glink_code[] =
75 0x90410014, /* stw r2,20(r1) */
76 0x800c0000, /* lwz r0,0(r12) */
77 0x804c0004, /* lwz r2,4(r12) */
78 0x7c0903a6, /* mtctr r0 */
79 0x4e800420, /* bctr */
80 0x0, /* start of traceback table */
81 0x000c8000, /* traceback table */
82 0x0 /* traceback table */
85 #define XCOFF_GLINK_SIZE \
86 (((sizeof xcoff_glink_code / sizeof xcoff_glink_code[0]) * 4) + 4)
88 /* We reuse the SEC_ROM flag as a mark flag for garbage collection.
89 This flag will only be used on input sections. */
91 #define SEC_MARK (SEC_ROM)
93 /* The ldhdr structure. This appears at the start of the .loader
98 /* The version number: currently always 1. */
99 unsigned long l_version;
100 /* The number of symbol table entries. */
101 bfd_size_type l_nsyms;
102 /* The number of relocation table entries. */
103 bfd_size_type l_nreloc;
104 /* The length of the import file string table. */
105 bfd_size_type l_istlen;
106 /* The number of import files. */
107 bfd_size_type l_nimpid;
108 /* The offset from the start of the .loader section to the first
109 entry in the import file table. */
110 bfd_size_type l_impoff;
111 /* The length of the string table. */
112 bfd_size_type l_stlen;
113 /* The offset from the start of the .loader section to the first
114 entry in the string table. */
115 bfd_size_type l_stoff;
118 struct external_ldhdr
120 bfd_byte l_version[4];
122 bfd_byte l_nreloc[4];
123 bfd_byte l_istlen[4];
124 bfd_byte l_nimpid[4];
125 bfd_byte l_impoff[4];
130 #define LDHDRSZ (8 * 4)
132 /* The ldsym structure. This is used to represent a symbol in the
135 struct internal_ldsym
139 /* The symbol name if <= SYMNMLEN characters. */
140 char _l_name[SYMNMLEN];
143 /* Zero if the symbol name is more than SYMNMLEN characters. */
145 /* The offset in the string table if the symbol name is more
146 than SYMNMLEN characters. */
150 /* The symbol value. */
152 /* The symbol section number. */
154 /* The symbol type and flags. */
156 /* The symbol storage class. */
158 /* The import file ID. */
159 bfd_size_type l_ifile;
160 /* Offset to the parameter type check string. */
161 bfd_size_type l_parm;
164 struct external_ldsym
168 bfd_byte _l_name[SYMNMLEN];
171 bfd_byte _l_zeroes[4];
172 bfd_byte _l_offset[4];
177 bfd_byte l_smtype[1];
178 bfd_byte l_smclas[1];
183 #define LDSYMSZ (8 + 3 * 4 + 2 + 2)
185 /* These flags are for the l_smtype field (the lower three bits are an
188 /* Imported symbol. */
189 #define L_IMPORT (0x40)
191 #define L_ENTRY (0x20)
192 /* Exported symbol. */
193 #define L_EXPORT (0x10)
195 /* The ldrel structure. This is used to represent a reloc in the
198 struct internal_ldrel
200 /* The reloc address. */
202 /* The symbol table index in the .loader section symbol table. */
203 bfd_size_type l_symndx;
204 /* The relocation type and size. */
206 /* The section number this relocation applies to. */
210 struct external_ldrel
213 bfd_byte l_symndx[4];
215 bfd_byte l_rsecnm[2];
218 #define LDRELSZ (2 * 4 + 2 * 2)
220 /* The list of import files. */
222 struct xcoff_import_file
224 /* The next entry in the list. */
225 struct xcoff_import_file *next;
230 /* The member name. */
234 /* An entry in the XCOFF linker hash table. */
236 struct xcoff_link_hash_entry
238 struct bfd_link_hash_entry root;
240 /* Symbol index in output file. Set to -1 initially. Set to -2 if
241 there is a reloc against this symbol. */
244 /* If we have created a TOC entry for this symbol, this is the .tc
245 section which holds it. */
246 asection *toc_section;
248 /* If we have created a TOC entry, this is the offset in
252 /* If this symbol is a function entry point which is called, this
253 field holds a pointer to the function descriptor. */
254 struct xcoff_link_hash_entry *descriptor;
256 /* The .loader symbol table entry, if there is one. */
257 struct internal_ldsym *ldsym;
259 /* The .loader symbol table index. */
262 /* Some linker flags. */
263 unsigned short flags;
264 /* Symbol is referenced by a regular object. */
265 #define XCOFF_REF_REGULAR (01)
266 /* Symbol is defined by a regular object. */
267 #define XCOFF_DEF_REGULAR (02)
268 /* Symbol is referenced by a dynamic object. */
269 #define XCOFF_REF_DYNAMIC (04)
270 /* Symbol is used in a reloc being copied into the .loader section. */
271 #define XCOFF_LDREL (010)
272 /* Symbol is the entry point. */
273 #define XCOFF_ENTRY (020)
274 /* Symbol is called; this is, it appears in a R_BR reloc. */
275 #define XCOFF_CALLED (040)
276 /* Symbol needs the TOC entry filled in. */
277 #define XCOFF_SET_TOC (0100)
278 /* Symbol is explicitly imported. */
279 #define XCOFF_IMPORT (0200)
280 /* Symbol is explicitly exported. */
281 #define XCOFF_EXPORT (0400)
282 /* Symbol has been processed by xcoff_build_ldsyms. */
283 #define XCOFF_BUILT_LDSYM (01000)
284 /* Symbol is mentioned by a section which was not garbage collected. */
285 #define XCOFF_MARK (02000)
287 /* The storage mapping class. */
288 unsigned char smclas;
291 /* The XCOFF linker hash table. */
293 struct xcoff_link_hash_table
295 struct bfd_link_hash_table root;
297 /* The .debug string hash table. We need to compute this while
298 reading the input files, so that we know how large the .debug
299 section will be before we assign section positions. */
300 struct bfd_strtab_hash *debug_strtab;
302 /* The .debug section we will use for the final output. */
303 asection *debug_section;
305 /* The .loader section we will use for the final output. */
306 asection *loader_section;
308 /* A count of non TOC relative relocs which will need to be
309 allocated in the .loader section. */
312 /* The .loader section header. */
313 struct internal_ldhdr ldhdr;
315 /* The .gl section we use to hold global linkage code. */
316 asection *linkage_section;
318 /* The .tc section we use to hold toc entries we build for global
320 asection *toc_section;
322 /* The list of import files. */
323 struct xcoff_import_file *imports;
325 /* Required alignment of sections within the output file. */
326 unsigned long file_align;
328 /* Whether the .text section must be read-only. */
331 /* Whether garbage collection was done. */
335 /* Information we keep for each section in the output file during the
338 struct xcoff_link_section_info
340 /* The relocs to be output. */
341 struct internal_reloc *relocs;
342 /* For each reloc against a global symbol whose index was not known
343 when the reloc was handled, the global hash table entry. */
344 struct xcoff_link_hash_entry **rel_hashes;
347 /* Information that we pass around while doing the final link step. */
349 struct xcoff_final_link_info
351 /* General link information. */
352 struct bfd_link_info *info;
355 /* Hash table for long symbol names. */
356 struct bfd_strtab_hash *strtab;
357 /* Array of information kept for each output section, indexed by the
358 target_index field. */
359 struct xcoff_link_section_info *section_info;
360 /* Symbol index of last C_FILE symbol (-1 if none). */
361 long last_file_index;
362 /* Contents of last C_FILE symbol. */
363 struct internal_syment last_file;
364 /* Symbol index of TOC symbol. */
366 /* Start of .loader symbols. */
367 struct external_ldsym *ldsym;
368 /* Next .loader reloc to swap out. */
369 struct external_ldrel *ldrel;
370 /* Buffer large enough to hold swapped symbols of any input file. */
371 struct internal_syment *internal_syms;
372 /* Buffer large enough to hold output indices of symbols of any
375 /* Buffer large enough to hold output symbols for any input file. */
377 /* Buffer large enough to hold external line numbers for any input
380 /* Buffer large enough to hold any input section. */
382 /* Buffer large enough to hold external relocs of any input section. */
383 bfd_byte *external_relocs;
386 static void xcoff_swap_ldhdr_out
387 PARAMS ((bfd *, const struct internal_ldhdr *, struct external_ldhdr *));
388 static void xcoff_swap_ldsym_out
389 PARAMS ((bfd *, const struct internal_ldsym *, struct external_ldsym *));
390 static void xcoff_swap_ldrel_out
391 PARAMS ((bfd *, const struct internal_ldrel *, struct external_ldrel *));
392 static struct bfd_hash_entry *xcoff_link_hash_newfunc
393 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
394 static struct internal_reloc *xcoff_read_internal_relocs
395 PARAMS ((bfd *, asection *, boolean, bfd_byte *, boolean,
396 struct internal_reloc *));
397 static boolean xcoff_link_add_object_symbols
398 PARAMS ((bfd *, struct bfd_link_info *));
399 static boolean xcoff_link_check_archive_element
400 PARAMS ((bfd *, struct bfd_link_info *, boolean *));
401 static boolean xcoff_link_check_ar_symbols
402 PARAMS ((bfd *, struct bfd_link_info *, boolean *));
403 static boolean xcoff_link_add_symbols PARAMS ((bfd *, struct bfd_link_info *));
404 static boolean xcoff_link_add_dynamic_symbols
405 PARAMS ((bfd *, struct bfd_link_info *));
406 static boolean xcoff_mark PARAMS ((struct bfd_link_info *, asection *));
407 static void xcoff_sweep PARAMS ((struct bfd_link_info *));
408 static boolean xcoff_build_ldsyms
409 PARAMS ((struct xcoff_link_hash_entry *, PTR));
410 static boolean xcoff_link_input_bfd
411 PARAMS ((struct xcoff_final_link_info *, bfd *));
412 static boolean xcoff_write_global_symbol
413 PARAMS ((struct xcoff_link_hash_entry *, PTR));
414 static boolean xcoff_reloc_link_order
415 PARAMS ((bfd *, struct xcoff_final_link_info *, asection *,
416 struct bfd_link_order *));
417 static int xcoff_sort_relocs PARAMS ((const PTR, const PTR));
419 /* Routines to swap information in the XCOFF .loader section. We only
420 need to swap this information out, not in. I believe that only the
421 loader needs to swap this information in. If we ever need to write
422 an XCOFF loader, this stuff will need to be moved to another file
423 shared by the linker (which XCOFF calls the ``binder'') and the
426 /* Swap out the ldhdr structure. */
429 xcoff_swap_ldhdr_out (abfd, src, dst)
431 const struct internal_ldhdr *src;
432 struct external_ldhdr *dst;
434 bfd_put_32 (abfd, src->l_version, dst->l_version);
435 bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
436 bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
437 bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
438 bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
439 bfd_put_32 (abfd, src->l_impoff, dst->l_impoff);
440 bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
441 bfd_put_32 (abfd, src->l_stoff, dst->l_stoff);
444 /* Swap out the ldsym structure. */
447 xcoff_swap_ldsym_out (abfd, src, dst)
449 const struct internal_ldsym *src;
450 struct external_ldsym *dst;
452 if (src->_l._l_l._l_zeroes != 0)
453 memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
456 bfd_put_32 (abfd, 0, dst->_l._l_l._l_zeroes);
457 bfd_put_32 (abfd, src->_l._l_l._l_offset, dst->_l._l_l._l_offset);
459 bfd_put_32 (abfd, src->l_value, dst->l_value);
460 bfd_put_16 (abfd, src->l_scnum, dst->l_scnum);
461 bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
462 bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
463 bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
464 bfd_put_32 (abfd, src->l_parm, dst->l_parm);
467 /* Swap out the ldrel structure. */
470 xcoff_swap_ldrel_out (abfd, src, dst)
472 const struct internal_ldrel *src;
473 struct external_ldrel *dst;
475 bfd_put_32 (abfd, src->l_vaddr, dst->l_vaddr);
476 bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
477 bfd_put_16 (abfd, src->l_rtype, dst->l_rtype);
478 bfd_put_16 (abfd, src->l_rsecnm, dst->l_rsecnm);
481 /* Routine to create an entry in an XCOFF link hash table. */
483 static struct bfd_hash_entry *
484 xcoff_link_hash_newfunc (entry, table, string)
485 struct bfd_hash_entry *entry;
486 struct bfd_hash_table *table;
489 struct xcoff_link_hash_entry *ret = (struct xcoff_link_hash_entry *) entry;
491 /* Allocate the structure if it has not already been allocated by a
493 if (ret == (struct xcoff_link_hash_entry *) NULL)
494 ret = ((struct xcoff_link_hash_entry *)
495 bfd_hash_allocate (table, sizeof (struct xcoff_link_hash_entry)));
496 if (ret == (struct xcoff_link_hash_entry *) NULL)
498 bfd_set_error (bfd_error_no_memory);
499 return (struct bfd_hash_entry *) ret;
502 /* Call the allocation method of the superclass. */
503 ret = ((struct xcoff_link_hash_entry *)
504 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
508 /* Set local fields. */
510 ret->toc_section = NULL;
512 ret->descriptor = NULL;
516 ret->smclas = XMC_UA;
519 return (struct bfd_hash_entry *) ret;
522 /* Create a XCOFF link hash table. */
524 struct bfd_link_hash_table *
525 _bfd_xcoff_bfd_link_hash_table_create (abfd)
528 struct xcoff_link_hash_table *ret;
530 ret = ((struct xcoff_link_hash_table *)
531 bfd_alloc (abfd, sizeof (struct xcoff_link_hash_table)));
532 if (ret == (struct xcoff_link_hash_table *) NULL)
534 bfd_set_error (bfd_error_no_memory);
535 return (struct bfd_link_hash_table *) NULL;
537 if (! _bfd_link_hash_table_init (&ret->root, abfd, xcoff_link_hash_newfunc))
539 bfd_release (abfd, ret);
540 return (struct bfd_link_hash_table *) NULL;
543 ret->debug_strtab = _bfd_xcoff_stringtab_init ();
544 ret->debug_section = NULL;
545 ret->loader_section = NULL;
546 ret->ldrel_count = 0;
547 memset (&ret->ldhdr, 0, sizeof (struct internal_ldhdr));
548 ret->linkage_section = NULL;
549 ret->toc_section = NULL;
558 /* Look up an entry in an XCOFF link hash table. */
560 #define xcoff_link_hash_lookup(table, string, create, copy, follow) \
561 ((struct xcoff_link_hash_entry *) \
562 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy),\
565 /* Traverse an XCOFF link hash table. */
567 #define xcoff_link_hash_traverse(table, func, info) \
568 (bfd_link_hash_traverse \
570 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
573 /* Get the XCOFF link hash table from the info structure. This is
576 #define xcoff_hash_table(p) ((struct xcoff_link_hash_table *) ((p)->hash))
578 /* Read internal relocs for an XCOFF csect. This is a wrapper around
579 _bfd_coff_read_internal_relocs which tries to take advantage of any
580 relocs which may have been cached for the enclosing section. */
582 static struct internal_reloc *
583 xcoff_read_internal_relocs (abfd, sec, cache, external_relocs,
584 require_internal, internal_relocs)
588 bfd_byte *external_relocs;
589 boolean require_internal;
590 struct internal_reloc *internal_relocs;
592 if (coff_section_data (abfd, sec) != NULL
593 && coff_section_data (abfd, sec)->relocs == NULL
594 && xcoff_section_data (abfd, sec) != NULL)
598 enclosing = xcoff_section_data (abfd, sec)->enclosing;
600 if (enclosing != NULL
601 && (coff_section_data (abfd, enclosing) == NULL
602 || coff_section_data (abfd, enclosing)->relocs == NULL)
605 if (_bfd_coff_read_internal_relocs (abfd, enclosing, true,
606 external_relocs, false,
607 (struct internal_reloc *) NULL)
612 if (enclosing != NULL
613 && coff_section_data (abfd, enclosing) != NULL
614 && coff_section_data (abfd, enclosing)->relocs != NULL)
618 off = ((sec->rel_filepos - enclosing->rel_filepos)
619 / bfd_coff_relsz (abfd));
620 if (! require_internal)
621 return coff_section_data (abfd, enclosing)->relocs + off;
622 memcpy (internal_relocs,
623 coff_section_data (abfd, enclosing)->relocs + off,
624 sec->reloc_count * sizeof (struct internal_reloc));
625 return internal_relocs;
629 return _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
630 require_internal, internal_relocs);
633 /* Given an XCOFF BFD, add symbols to the global hash table as
637 _bfd_xcoff_bfd_link_add_symbols (abfd, info)
639 struct bfd_link_info *info;
641 switch (bfd_get_format (abfd))
644 return xcoff_link_add_object_symbols (abfd, info);
646 return (_bfd_generic_link_add_archive_symbols
647 (abfd, info, xcoff_link_check_archive_element));
649 bfd_set_error (bfd_error_wrong_format);
654 /* Add symbols from an XCOFF object file. */
657 xcoff_link_add_object_symbols (abfd, info)
659 struct bfd_link_info *info;
661 if (! _bfd_coff_get_external_symbols (abfd))
663 if (! xcoff_link_add_symbols (abfd, info))
665 if (! info->keep_memory)
667 if (! _bfd_coff_free_symbols (abfd))
673 /* Check a single archive element to see if we need to include it in
674 the link. *PNEEDED is set according to whether this element is
675 needed in the link or not. This is called via
676 _bfd_generic_link_add_archive_symbols. */
679 xcoff_link_check_archive_element (abfd, info, pneeded)
681 struct bfd_link_info *info;
684 if (! _bfd_coff_get_external_symbols (abfd))
687 if (! xcoff_link_check_ar_symbols (abfd, info, pneeded))
692 if (! xcoff_link_add_symbols (abfd, info))
696 if (! info->keep_memory || ! *pneeded)
698 if (! _bfd_coff_free_symbols (abfd))
705 /* Look through the symbols to see if this object file should be
706 included in the link. */
709 xcoff_link_check_ar_symbols (abfd, info, pneeded)
711 struct bfd_link_info *info;
714 bfd_size_type symesz;
720 symesz = bfd_coff_symesz (abfd);
721 esym = (bfd_byte *) obj_coff_external_syms (abfd);
722 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
723 while (esym < esym_end)
725 struct internal_syment sym;
727 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
729 if (sym.n_sclass == C_EXT && sym.n_scnum != N_UNDEF)
732 char buf[SYMNMLEN + 1];
733 struct bfd_link_hash_entry *h;
735 /* This symbol is externally visible, and is defined by this
738 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
741 h = bfd_link_hash_lookup (info->hash, name, false, false, true);
743 /* We are only interested in symbols that are currently
744 undefined. If a symbol is currently known to be common,
745 XCOFF linkers do not bring in an object file which
746 defines it. We also don't bring in symbols to satisfy
747 undefined references in shared objects. */
748 if (h != (struct bfd_link_hash_entry *) NULL
749 && h->type == bfd_link_hash_undefined)
751 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
758 esym += (sym.n_numaux + 1) * symesz;
761 /* We do not need this object file. */
765 /* Add all the symbols from an object file to the hash table.
767 XCOFF is a weird format. A normal XCOFF .o files will have three
768 COFF sections--.text, .data, and .bss--but each COFF section will
769 contain many csects. These csects are described in the symbol
770 table. From the linker's point of view, each csect must be
771 considered a section in its own right. For example, a TOC entry is
772 handled as a small XMC_TC csect. The linker must be able to merge
773 different TOC entries together, which means that it must be able to
774 extract the XMC_TC csects from the .data section of the input .o
777 From the point of view of our linker, this is, of course, a hideous
778 nightmare. We cope by actually creating sections for each csect,
779 and discarding the original sections. We then have to handle the
780 relocation entries carefully, since the only way to tell which
781 csect they belong to is to examine the address. */
784 xcoff_link_add_symbols (abfd, info)
786 struct bfd_link_info *info;
788 unsigned int n_tmask;
789 unsigned int n_btshft;
790 boolean default_copy;
791 bfd_size_type symcount;
792 struct xcoff_link_hash_entry **sym_hash;
793 asection **csect_cache;
794 bfd_size_type linesz;
798 unsigned int csect_index;
799 asection *first_csect;
800 bfd_size_type symesz;
803 struct reloc_info_struct
805 struct internal_reloc *relocs;
808 } *reloc_info = NULL;
810 if ((abfd->flags & DYNAMIC) != 0
811 && ! info->static_link)
812 return xcoff_link_add_dynamic_symbols (abfd, info);
814 n_tmask = coff_data (abfd)->local_n_tmask;
815 n_btshft = coff_data (abfd)->local_n_btshft;
817 /* Define macros so that ISFCN, et. al., macros work correctly. */
818 #define N_TMASK n_tmask
819 #define N_BTSHFT n_btshft
821 /* We need to build a .loader section, so we do it here. This won't
822 work if we're producing an XCOFF output file with no non dynamic
823 XCOFF input files. FIXME. */
824 if (xcoff_hash_table (info)->loader_section == NULL)
828 lsec = bfd_make_section_anyway (abfd, ".loader");
831 xcoff_hash_table (info)->loader_section = lsec;
832 lsec->flags |= SEC_HAS_CONTENTS | SEC_IN_MEMORY;
834 /* Likewise for the linkage section. */
835 if (xcoff_hash_table (info)->linkage_section == NULL)
839 lsec = bfd_make_section_anyway (abfd, ".gl");
842 xcoff_hash_table (info)->linkage_section = lsec;
843 lsec->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
845 /* Likewise for the TOC section. */
846 if (xcoff_hash_table (info)->toc_section == NULL)
850 tsec = bfd_make_section_anyway (abfd, ".tc");
853 xcoff_hash_table (info)->toc_section = tsec;
854 tsec->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
856 /* Likewise for the .debug section. */
857 if (xcoff_hash_table (info)->debug_section == NULL)
861 dsec = bfd_make_section_anyway (abfd, ".debug");
864 xcoff_hash_table (info)->debug_section = dsec;
865 dsec->flags |= SEC_HAS_CONTENTS | SEC_IN_MEMORY;
868 if (info->keep_memory)
869 default_copy = false;
873 symcount = obj_raw_syment_count (abfd);
875 /* We keep a list of the linker hash table entries that correspond
876 to each external symbol. */
877 sym_hash = ((struct xcoff_link_hash_entry **)
880 * sizeof (struct xcoff_link_hash_entry *))));
881 if (sym_hash == NULL && symcount != 0)
883 bfd_set_error (bfd_error_no_memory);
886 coff_data (abfd)->sym_hashes = (struct coff_link_hash_entry **) sym_hash;
888 (size_t) symcount * sizeof (struct xcoff_link_hash_entry *));
890 /* Because of the weird stuff we are doing with XCOFF csects, we can
891 not easily determine which section a symbol is in, so we store
892 the information in the tdata for the input file. */
893 csect_cache = ((asection **)
894 bfd_alloc (abfd, symcount * sizeof (asection *)));
895 if (csect_cache == NULL && symcount != 0)
897 bfd_set_error (bfd_error_no_memory);
900 xcoff_data (abfd)->csects = csect_cache;
901 memset (csect_cache, 0, (size_t) symcount * sizeof (asection *));
903 /* While splitting sections into csects, we need to assign the
904 relocs correctly. The relocs and the csects must both be in
905 order by VMA within a given section, so we handle this by
906 scanning along the relocs as we process the csects. We index
907 into reloc_info using the section target_index. */
908 reloc_info = ((struct reloc_info_struct *)
909 malloc ((abfd->section_count + 1)
910 * sizeof (struct reloc_info_struct)));
911 if (reloc_info == NULL)
913 bfd_set_error (bfd_error_no_memory);
916 memset ((PTR) reloc_info, 0,
917 (abfd->section_count + 1) * sizeof (struct reloc_info_struct));
919 /* Read in the relocs and line numbers for each section. */
920 linesz = bfd_coff_linesz (abfd);
921 for (sub = abfd->sections; sub != NULL; sub = sub->next)
923 if ((sub->flags & SEC_RELOC) != 0)
925 reloc_info[sub->target_index].relocs =
926 xcoff_read_internal_relocs (abfd, sub, true, (bfd_byte *) NULL,
927 false, (struct internal_reloc *) NULL);
928 reloc_info[sub->target_index].csects =
929 (asection **) malloc (sub->reloc_count * sizeof (asection *));
930 if (reloc_info[sub->target_index].csects == NULL)
932 bfd_set_error (bfd_error_no_memory);
935 memset (reloc_info[sub->target_index].csects, 0,
936 sub->reloc_count * sizeof (asection *));
939 if ((info->strip == strip_none || info->strip == strip_some)
940 && sub->lineno_count > 0)
944 linenos = (bfd_byte *) malloc (sub->lineno_count * linesz);
947 bfd_set_error (bfd_error_no_memory);
950 reloc_info[sub->target_index].linenos = linenos;
951 if (bfd_seek (abfd, sub->line_filepos, SEEK_SET) != 0
952 || (bfd_read (linenos, linesz, sub->lineno_count, abfd)
953 != linesz * sub->lineno_count))
958 /* Don't let the linker relocation routines discard the symbols. */
959 keep_syms = obj_coff_keep_syms (abfd);
960 obj_coff_keep_syms (abfd) = true;
966 symesz = bfd_coff_symesz (abfd);
967 BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
968 esym = (bfd_byte *) obj_coff_external_syms (abfd);
969 esym_end = esym + symcount * symesz;
970 while (esym < esym_end)
972 struct internal_syment sym;
973 union internal_auxent aux;
975 char buf[SYMNMLEN + 1];
980 struct xcoff_link_hash_entry *set_toc;
982 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
984 /* In this pass we are only interested in symbols with csect
986 if (sym.n_sclass != C_EXT && sym.n_sclass != C_HIDEXT)
988 if (sym.n_sclass == C_FILE && csect != NULL)
990 xcoff_section_data (abfd, csect)->last_symndx =
992 - (bfd_byte *) obj_coff_external_syms (abfd))
998 *csect_cache = csect;
999 else if (first_csect == NULL || sym.n_sclass == C_FILE)
1000 *csect_cache = coff_section_from_bfd_index (abfd, sym.n_scnum);
1002 *csect_cache = NULL;
1003 esym += (sym.n_numaux + 1) * symesz;
1004 sym_hash += sym.n_numaux + 1;
1005 csect_cache += sym.n_numaux + 1;
1009 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
1013 /* If this symbol has line number information attached to it,
1014 and we're not stripping it, count the number of entries and
1015 add them to the count for this csect. In the final link pass
1016 we are going to attach line number information by symbol,
1017 rather than by section, in order to more easily handle
1018 garbage collection. */
1019 if ((info->strip == strip_none || info->strip == strip_some)
1022 && ISFCN (sym.n_type))
1024 union internal_auxent auxlin;
1026 bfd_coff_swap_aux_in (abfd, (PTR) (esym + symesz),
1027 sym.n_type, sym.n_sclass,
1028 0, sym.n_numaux, (PTR) &auxlin);
1029 if (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
1031 asection *enclosing;
1032 bfd_size_type linoff;
1034 enclosing = xcoff_section_data (abfd, csect)->enclosing;
1035 linoff = (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr
1036 - enclosing->line_filepos);
1037 if (linoff < enclosing->lineno_count * linesz)
1039 struct internal_lineno lin;
1040 bfd_byte *linpstart;
1042 linpstart = (reloc_info[enclosing->target_index].linenos
1044 bfd_coff_swap_lineno_in (abfd, (PTR) linpstart, (PTR) &lin);
1046 && ((bfd_size_type) lin.l_addr.l_symndx
1048 - (bfd_byte *) obj_coff_external_syms (abfd))
1051 bfd_byte *linpend, *linp;
1053 linpend = (reloc_info[enclosing->target_index].linenos
1054 + enclosing->lineno_count * linesz);
1055 for (linp = linpstart + linesz;
1059 bfd_coff_swap_lineno_in (abfd, (PTR) linp,
1061 if (lin.l_lnno == 0)
1064 csect->lineno_count += (linp - linpstart) / linesz;
1070 /* Pick up the csect auxiliary information. */
1072 if (sym.n_numaux == 0)
1074 (*_bfd_error_handler)
1075 ("%s: class %d symbol `%s' has no aux entries",
1076 bfd_get_filename (abfd), sym.n_sclass, name);
1077 bfd_set_error (bfd_error_bad_value);
1081 bfd_coff_swap_aux_in (abfd,
1082 (PTR) (esym + symesz * sym.n_numaux),
1083 sym.n_type, sym.n_sclass,
1084 sym.n_numaux - 1, sym.n_numaux,
1087 smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
1097 (*_bfd_error_handler)
1098 ("%s: symbol `%s' has unrecognized csect type %d",
1099 bfd_get_filename (abfd), name, smtyp);
1100 bfd_set_error (bfd_error_bad_value);
1104 /* This is an external reference. */
1105 if (sym.n_sclass == C_HIDEXT
1106 || sym.n_scnum != N_UNDEF
1107 || aux.x_csect.x_scnlen.l != 0)
1109 (*_bfd_error_handler)
1110 ("%s: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d",
1111 bfd_get_filename (abfd), name, sym.n_sclass, sym.n_scnum,
1112 aux.x_csect.x_scnlen.l);
1113 bfd_set_error (bfd_error_bad_value);
1116 section = bfd_und_section_ptr;
1120 /* This is a csect definition. */
1124 xcoff_section_data (abfd, csect)->last_symndx =
1126 - (bfd_byte *) obj_coff_external_syms (abfd))
1133 /* When we see a TOC anchor, we record the TOC value. */
1134 if (aux.x_csect.x_smclas == XMC_TC0)
1136 if (sym.n_sclass != C_HIDEXT
1137 || aux.x_csect.x_scnlen.l != 0)
1139 (*_bfd_error_handler)
1140 ("%s: XMC_TC0 symbol `%s' is class %d scnlen %d",
1141 bfd_get_filename (abfd), name, sym.n_sclass,
1142 aux.x_csect.x_scnlen.l);
1143 bfd_set_error (bfd_error_bad_value);
1146 xcoff_data (abfd)->toc = sym.n_value;
1149 /* We must merge TOC entries for the same symbol. We can
1150 merge two TOC entries if they are both C_HIDEXT, they
1151 both have the same name, they are both 4 bytes long, and
1152 they both have a relocation table entry for an external
1153 symbol with the same name. Unfortunately, this means
1154 that we must look through the relocations. Ick. */
1155 if (aux.x_csect.x_smclas == XMC_TC
1156 && sym.n_sclass == C_HIDEXT
1157 && aux.x_csect.x_scnlen.l == 4
1158 && info->hash->creator == abfd->xvec)
1160 asection *enclosing;
1161 bfd_size_type relindx;
1162 struct internal_reloc *rel;
1163 asection **rel_csect;
1165 enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1166 if (enclosing == NULL)
1169 /* XCOFF requires that relocs be sorted by address, so
1170 we could do a binary search here. FIXME. */
1171 rel = reloc_info[enclosing->target_index].relocs;
1172 rel_csect = reloc_info[enclosing->target_index].csects;
1174 relindx < enclosing->reloc_count;
1175 relindx++, rel++, rel_csect++)
1177 if (*rel_csect == NULL
1178 && rel->r_vaddr == (bfd_vma) sym.n_value
1179 && rel->r_size == 31
1180 && rel->r_type == R_POS)
1183 if (relindx < enclosing->reloc_count)
1186 struct internal_syment relsym;
1188 erelsym = ((bfd_byte *) obj_coff_external_syms (abfd)
1189 + rel->r_symndx * symesz);
1190 bfd_coff_swap_sym_in (abfd, (PTR) erelsym, (PTR) &relsym);
1191 if (relsym.n_sclass == C_EXT)
1193 const char *relname;
1194 char relbuf[SYMNMLEN + 1];
1196 struct xcoff_link_hash_entry *h;
1198 /* At this point we know that the TOC entry is
1199 for an externally visible symbol. */
1200 relname = _bfd_coff_internal_syment_name (abfd, &relsym,
1202 if (relname == NULL)
1204 copy = (! info->keep_memory
1205 || relsym._n._n_n._n_zeroes != 0
1206 || relsym._n._n_n._n_offset == 0);
1207 h = xcoff_link_hash_lookup (xcoff_hash_table (info),
1208 relname, true, copy, false);
1212 /* At this point h->root.type could be
1213 bfd_link_hash_new. That should be OK, since
1214 we know for sure that we will come across
1215 this symbol as we step through the file. */
1217 /* We store h in *sym_hash for the convenience
1218 of the relocate_section function. */
1221 if (h->toc_section != NULL)
1223 /* We already have a TOC entry for this
1224 symbol, so we can just ignore this one. */
1225 *rel_csect = bfd_und_section_ptr;
1229 /* We are about to create a TOC entry for this
1236 /* We need to create a new section. We get the name from
1237 the csect storage mapping class, so that the linker can
1238 accumulate similar csects together. */
1240 static const char *csect_name_by_class[] =
1242 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
1243 ".sv", ".bs", ".ds", ".uc", ".ti", ".tb", NULL, ".tc0",
1246 const char *csect_name;
1247 asection *enclosing;
1248 struct internal_reloc *rel;
1249 bfd_size_type relindx;
1250 asection **rel_csect;
1252 if ((aux.x_csect.x_smclas >=
1253 sizeof csect_name_by_class / sizeof csect_name_by_class[0])
1254 || csect_name_by_class[aux.x_csect.x_smclas] == NULL)
1256 (*_bfd_error_handler)
1257 ("%s: symbol `%s' has unrecognized smclas %d",
1258 bfd_get_filename (abfd), name, aux.x_csect.x_smclas);
1259 bfd_set_error (bfd_error_bad_value);
1263 csect_name = csect_name_by_class[aux.x_csect.x_smclas];
1264 csect = bfd_make_section_anyway (abfd, csect_name);
1267 enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1268 if (enclosing == NULL)
1270 if ((bfd_vma) sym.n_value < enclosing->vma
1271 || ((bfd_vma) sym.n_value + aux.x_csect.x_scnlen.l
1272 > enclosing->vma + enclosing->_raw_size))
1274 (*_bfd_error_handler)
1275 ("%s: csect `%s' not in enclosing section",
1276 bfd_get_filename (abfd), name);
1277 bfd_set_error (bfd_error_bad_value);
1280 csect->vma = sym.n_value;
1281 csect->filepos = (enclosing->filepos
1284 csect->_raw_size = aux.x_csect.x_scnlen.l;
1285 csect->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
1286 csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
1288 /* Record the enclosing section in the tdata for this new
1290 csect->used_by_bfd =
1291 ((struct coff_section_tdata *)
1292 bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
1293 if (csect->used_by_bfd == NULL)
1295 bfd_set_error (bfd_error_no_memory);
1298 coff_section_data (abfd, csect)->tdata =
1299 bfd_zalloc (abfd, sizeof (struct xcoff_section_tdata));
1300 if (coff_section_data (abfd, csect)->tdata == NULL)
1302 bfd_set_error (bfd_error_no_memory);
1305 xcoff_section_data (abfd, csect)->enclosing = enclosing;
1307 /* XCOFF requires that relocs be sorted by address, so we
1308 could do a binary search here. FIXME. (XCOFF
1309 unfortunately does not require that symbols be sorted
1310 by address, or this would be a simple merge). */
1311 rel = reloc_info[enclosing->target_index].relocs;
1312 rel_csect = reloc_info[enclosing->target_index].csects;
1314 relindx < enclosing->reloc_count;
1315 relindx++, rel++, rel_csect++)
1317 if (*rel_csect == NULL
1318 && rel->r_vaddr >= csect->vma
1319 && rel->r_vaddr < csect->vma + csect->_raw_size)
1321 csect->rel_filepos = (enclosing->rel_filepos
1322 + relindx * bfd_coff_relsz (abfd));
1326 while (relindx < enclosing->reloc_count
1327 && *rel_csect == NULL
1328 && rel->r_vaddr >= csect->vma
1329 && rel->r_vaddr < csect->vma + csect->_raw_size)
1332 csect->flags |= SEC_RELOC;
1333 ++csect->reloc_count;
1339 /* There are a number of other fields and section flags
1340 which we do not bother to set. */
1342 csect_index = ((esym
1343 - (bfd_byte *) obj_coff_external_syms (abfd))
1346 xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1348 if (first_csect == NULL)
1349 first_csect = csect;
1351 /* If this symbol is C_EXT, we treat it as starting at the
1352 beginning of the newly created section. */
1353 if (sym.n_sclass == C_EXT)
1359 /* If this is a TOC section for a symbol, record it. */
1360 if (set_toc != NULL)
1362 set_toc->toc_section = csect;
1363 set_toc->toc_offset = 0;
1369 /* This is a label definition. The x_scnlen field is the
1370 symbol index of the csect. I believe that this must
1371 always follow the appropriate XTY_SD symbol, so I will
1377 if (aux.x_csect.x_scnlen.l < 0
1378 || (aux.x_csect.x_scnlen.l
1379 >= esym - (bfd_byte *) obj_coff_external_syms (abfd)))
1383 section = xcoff_data (abfd)->csects[aux.x_csect.x_scnlen.l];
1385 || (section->flags & SEC_HAS_CONTENTS) == 0)
1390 (*_bfd_error_handler)
1391 ("%s: misplaced XTY_LD `%s'",
1392 bfd_get_filename (abfd), name);
1393 bfd_set_error (bfd_error_bad_value);
1397 value = sym.n_value - csect->vma;
1402 /* This is an unitialized csect. We could base the name on
1403 the storage mapping class, but we don't bother. If this
1404 csect is externally visible, it is a common symbol. */
1408 xcoff_section_data (abfd, csect)->last_symndx =
1410 - (bfd_byte *) obj_coff_external_syms (abfd))
1414 csect = bfd_make_section_anyway (abfd, ".bss");
1418 csect->_raw_size = aux.x_csect.x_scnlen.l;
1419 csect->flags |= SEC_ALLOC;
1420 csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
1421 /* There are a number of other fields and section flags
1422 which we do not bother to set. */
1424 csect_index = ((esym
1425 - (bfd_byte *) obj_coff_external_syms (abfd))
1428 csect->used_by_bfd =
1429 ((struct coff_section_tdata *)
1430 bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
1431 if (csect->used_by_bfd == NULL)
1433 bfd_set_error (bfd_error_no_memory);
1436 coff_section_data (abfd, csect)->tdata =
1437 bfd_zalloc (abfd, sizeof (struct xcoff_section_tdata));
1438 if (coff_section_data (abfd, csect)->tdata == NULL)
1440 bfd_set_error (bfd_error_no_memory);
1443 xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1445 if (first_csect == NULL)
1446 first_csect = csect;
1448 if (sym.n_sclass == C_EXT)
1450 csect->flags |= SEC_IS_COMMON;
1452 value = aux.x_csect.x_scnlen.l;
1458 /* Now we have enough information to add the symbol to the
1459 linker hash table. */
1461 if (sym.n_sclass == C_EXT)
1465 BFD_ASSERT (section != NULL);
1467 /* We must copy the name into memory if we got it from the
1468 syment itself, rather than the string table. */
1469 copy = default_copy;
1470 if (sym._n._n_n._n_zeroes != 0
1471 || sym._n._n_n._n_offset == 0)
1474 if (info->hash->creator == abfd->xvec)
1476 /* If we are statically linking a shared object, it is
1477 OK for symbol redefinitions to occur. I can't figure
1478 out just what the XCOFF linker is doing, but
1479 something like this is required for -bnso to work. */
1480 *sym_hash = xcoff_link_hash_lookup (xcoff_hash_table (info),
1481 name, true, copy, false);
1482 if (*sym_hash == NULL)
1484 if (((*sym_hash)->root.type == bfd_link_hash_defined
1485 || (*sym_hash)->root.type == bfd_link_hash_defweak)
1486 && ! bfd_is_und_section (section)
1487 && ! bfd_is_com_section (section))
1489 if ((abfd->flags & DYNAMIC) != 0)
1491 section = bfd_und_section_ptr;
1494 else if (((*sym_hash)->root.u.def.section->owner->flags
1497 (*sym_hash)->root.type = bfd_link_hash_undefined;
1498 (*sym_hash)->root.u.undef.abfd =
1499 (*sym_hash)->root.u.def.section->owner;
1504 if (! (_bfd_generic_link_add_one_symbol
1505 (info, abfd, name, flags, section, value,
1506 (const char *) NULL, copy, false,
1507 (struct bfd_link_hash_entry **) sym_hash)))
1510 if (info->hash->creator == abfd->xvec)
1514 if (smtyp == XTY_ER || smtyp == XTY_CM)
1515 flag = XCOFF_REF_REGULAR;
1517 flag = XCOFF_DEF_REGULAR;
1518 (*sym_hash)->flags |= flag;
1520 if ((*sym_hash)->smclas == XMC_UA)
1521 (*sym_hash)->smclas = aux.x_csect.x_smclas;
1525 *csect_cache = csect;
1527 esym += (sym.n_numaux + 1) * symesz;
1528 sym_hash += sym.n_numaux + 1;
1529 csect_cache += sym.n_numaux + 1;
1532 /* Make sure that we have seen all the relocs. */
1533 for (sub = abfd->sections; sub != first_csect; sub = sub->next)
1535 /* Reset the section size, since the data is now attached to the
1536 csects. Don't reset the size of the .debug section, since we
1537 need to read it below in bfd_xcoff_size_dynamic_sections. */
1538 if (strcmp (bfd_get_section_name (abfd, sub), ".debug") != 0)
1541 if ((sub->flags & SEC_RELOC) != 0)
1544 struct internal_reloc *rel;
1545 asection **rel_csect;
1547 rel = reloc_info[sub->target_index].relocs;
1548 rel_csect = reloc_info[sub->target_index].csects;
1549 for (i = 0; i < sub->reloc_count; i++, rel++, rel_csect++)
1551 if (*rel_csect == NULL)
1553 (*_bfd_error_handler)
1554 ("%s: reloc %s:%d not in csect",
1555 bfd_get_filename (abfd), sub->name, i);
1556 bfd_set_error (bfd_error_bad_value);
1560 /* We need to copy all relocs which are not PC relative
1561 and not TOC relative into the .loader section.
1563 We also identify all symbols which are called, so
1564 that we can create glue code for calls to functions
1565 imported from dynamic objects. */
1567 if (info->hash->creator == abfd->xvec
1568 && *rel_csect != bfd_und_section_ptr)
1570 struct xcoff_link_hash_entry *h;
1572 switch (rel->r_type)
1580 ++xcoff_hash_table (info)->ldrel_count;
1581 ++xcoff_section_data (abfd, *rel_csect)->ldrel_count;
1582 h = obj_xcoff_sym_hashes (abfd)[rel->r_symndx];
1584 h->flags |= XCOFF_LDREL;
1588 h = obj_xcoff_sym_hashes (abfd)[rel->r_symndx];
1591 h->flags |= XCOFF_CALLED;
1592 /* If the symbol name starts with a period,
1593 it is the code of a function. If the
1594 symbol is currently undefined, then add
1595 an undefined symbol for the function
1596 descriptor. This should do no harm,
1597 because any regular object that defines
1598 the function should also define the
1599 function descriptor. It helps, because
1600 it means that we will identify the
1601 function descriptor with a dynamic object
1602 if a dynamic object defines it. */
1603 if (h->root.root.string[0] == '.'
1604 && h->descriptor == NULL)
1606 struct xcoff_link_hash_entry *hds;
1608 hds = (xcoff_link_hash_lookup
1609 (xcoff_hash_table (info),
1610 h->root.root.string + 1, true, false,
1614 if (hds->root.type == bfd_link_hash_new)
1616 if (! (_bfd_generic_link_add_one_symbol
1617 (info, abfd, hds->root.root.string,
1618 (flagword) 0, bfd_und_section_ptr,
1619 (bfd_vma) 0, (const char *) NULL,
1621 ((struct bfd_link_hash_entry **)
1625 h->descriptor = hds;
1633 free (reloc_info[sub->target_index].csects);
1634 reloc_info[sub->target_index].csects = NULL;
1636 /* Reset SEC_RELOC, the reloc_count, and the lineno_count,
1637 since the reloc and lineno information is now attached to
1639 sub->flags &=~ SEC_RELOC;
1640 sub->reloc_count = 0;
1641 sub->lineno_count = 0;
1643 /* If we are not keeping memory, free the reloc information. */
1644 if (! info->keep_memory
1645 && coff_section_data (abfd, sub) != NULL
1646 && coff_section_data (abfd, sub)->relocs != NULL
1647 && ! coff_section_data (abfd, sub)->keep_relocs)
1649 free (coff_section_data (abfd, sub)->relocs);
1650 coff_section_data (abfd, sub)->relocs = NULL;
1654 /* Free up the line numbers. FIXME: We could cache these
1655 somewhere for the final link, to avoid reading them again. */
1656 if (reloc_info[sub->target_index].linenos != NULL)
1658 free (reloc_info[sub->target_index].linenos);
1659 reloc_info[sub->target_index].linenos = NULL;
1665 obj_coff_keep_syms (abfd) = keep_syms;
1670 if (reloc_info != NULL)
1672 for (sub = abfd->sections; sub != NULL; sub = sub->next)
1674 if (reloc_info[sub->target_index].csects != NULL)
1675 free (reloc_info[sub->target_index].csects);
1676 if (reloc_info[sub->target_index].linenos != NULL)
1677 free (reloc_info[sub->target_index].linenos);
1681 obj_coff_keep_syms (abfd) = keep_syms;
1688 /* This function is used to add symbols from a dynamic object to the
1689 global symbol table. */
1692 xcoff_link_add_dynamic_symbols (abfd, info)
1694 struct bfd_link_info *info;
1696 bfd_size_type symesz;
1699 struct xcoff_import_file *n;
1704 struct xcoff_import_file **pp;
1706 /* We can only handle a dynamic object if we are generating an XCOFF
1708 if (info->hash->creator != abfd->xvec)
1710 (*_bfd_error_handler)
1711 ("%s: XCOFF shared object when not producing XCOFF output",
1712 bfd_get_filename (abfd));
1713 bfd_set_error (bfd_error_invalid_operation);
1717 /* Remove the sections from this object, so that they do not get
1718 included in the link. */
1719 abfd->sections = NULL;
1721 symesz = bfd_coff_symesz (abfd);
1722 esym = (bfd_byte *) obj_coff_external_syms (abfd);
1723 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
1724 while (esym < esym_end)
1726 struct internal_syment sym;
1728 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
1730 /* I think that every symbol mentioned in a dynamic object must
1731 be defined by that object, perhaps by importing it from
1732 another dynamic object. All we have to do is look up each
1733 external symbol. If we have already put it in the hash
1734 table, we simply set a flag indicating that it appears in a
1737 if (sym.n_sclass == C_EXT)
1740 char buf[SYMNMLEN + 1];
1741 struct xcoff_link_hash_entry *h;
1743 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
1747 /* Normally we could not xcoff_link_hash_lookup in an add
1748 symbols routine, since we might not be using an XCOFF
1749 hash table. However, we verified above that we are using
1750 an XCOFF hash table. */
1751 h = xcoff_link_hash_lookup (xcoff_hash_table (info), name,
1752 false, false, true);
1755 h->flags |= XCOFF_REF_DYNAMIC;
1757 /* If the symbol is undefined, and the current BFD is
1758 not a dynamic object, change the BFD to this dynamic
1759 object, so that we can get the import file ID
1761 if (h->root.u.undef.abfd == NULL
1762 || (h->root.u.undef.abfd->flags & DYNAMIC) == 0)
1763 h->root.u.undef.abfd = abfd;
1765 if (h->smclas == XMC_UA
1766 && sym.n_numaux > 0)
1768 union internal_auxent aux;
1770 bfd_coff_swap_aux_in (abfd,
1771 (PTR) (esym + symesz * sym.n_numaux),
1772 sym.n_type, sym.n_sclass,
1773 sym.n_numaux - 1, sym.n_numaux,
1775 h->smclas = aux.x_csect.x_smclas;
1780 esym += (sym.n_numaux + 1) * symesz;
1783 /* Record this file in the import files. */
1785 n = ((struct xcoff_import_file *)
1786 bfd_alloc (abfd, sizeof (struct xcoff_import_file)));
1789 bfd_set_error (bfd_error_no_memory);
1794 /* For some reason, the path entry in the import file list for a
1795 shared object appears to always be empty. The file name is the
1798 if (abfd->my_archive == NULL)
1800 bname = bfd_get_filename (abfd);
1805 bname = bfd_get_filename (abfd->my_archive);
1806 mname = bfd_get_filename (abfd);
1808 s = strrchr (bname, '/');
1814 /* We start c at 1 because the first import file number is reserved
1816 for (pp = &xcoff_hash_table (info)->imports, c = 1;
1818 pp = &(*pp)->next, ++c)
1822 xcoff_data (abfd)->import_file_id = c;
1827 /* Routines that are called after all the input files have been
1828 handled, but before the sections are laid out in memory. */
1830 /* Import a symbol. */
1833 bfd_xcoff_import_symbol (output_bfd, info, harg, val, imppath, impfile,
1836 struct bfd_link_info *info;
1837 struct bfd_link_hash_entry *harg;
1839 const char *imppath;
1840 const char *impfile;
1841 const char *impmember;
1843 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
1845 h->flags |= XCOFF_IMPORT;
1847 if (val != (bfd_vma) -1)
1849 if (h->root.type == bfd_link_hash_defined)
1851 if (! ((*info->callbacks->multiple_definition)
1852 (info, h->root.root.string, h->root.u.def.section->owner,
1853 h->root.u.def.section, h->root.u.def.value,
1854 output_bfd, bfd_abs_section_ptr, val)))
1858 h->root.type = bfd_link_hash_defined;
1859 h->root.u.def.section = bfd_abs_section_ptr;
1860 h->root.u.def.value = val;
1863 if (h->ldsym == NULL)
1865 h->ldsym = ((struct internal_ldsym *)
1866 bfd_zalloc (output_bfd, sizeof (struct internal_ldsym)));
1867 if (h->ldsym == NULL)
1869 bfd_set_error (bfd_error_no_memory);
1874 if (imppath == NULL)
1875 h->ldsym->l_ifile = (bfd_size_type) -1;
1879 struct xcoff_import_file **pp;
1881 /* We start c at 1 because the first entry in the import list is
1882 reserved for the library search path. */
1883 for (pp = &xcoff_hash_table (info)->imports, c = 1;
1885 pp = &(*pp)->next, ++c)
1887 if (strcmp ((*pp)->path, imppath) == 0
1888 && strcmp ((*pp)->file, impfile) == 0
1889 && strcmp ((*pp)->member, impmember) == 0)
1895 struct xcoff_import_file *n;
1897 n = ((struct xcoff_import_file *)
1898 bfd_alloc (output_bfd, sizeof (struct xcoff_import_file)));
1901 bfd_set_error (bfd_error_no_memory);
1907 n->member = impmember;
1911 h->ldsym->l_ifile = c;
1917 /* Export a symbol. */
1920 bfd_xcoff_export_symbol (output_bfd, info, harg, syscall)
1922 struct bfd_link_info *info;
1923 struct bfd_link_hash_entry *harg;
1926 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
1928 h->flags |= XCOFF_EXPORT;
1930 /* FIXME: I'm not at all sure what syscall is supposed to mean, so
1931 I'm just going to ignore it until somebody explains it. */
1936 /* This structure is used to pass information through
1937 xcoff_link_hash_traverse. */
1939 struct xcoff_loader_info
1941 /* Set if a problem occurred. */
1945 /* Link information structure. */
1946 struct bfd_link_info *info;
1947 /* Number of ldsym structures. */
1949 /* Size of string table. */
1953 /* Allocated size of string table. */
1957 /* Build the .loader section. This is called by the XCOFF linker
1958 emulation before_allocation routine. We must set the size of the
1959 .loader section before the linker lays out the output file.
1960 LIBPATH is the library path to search for shared objects; this is
1961 normally built from the -L arguments passed to the linker. ENTRY
1962 is the name of the entry point symbol. */
1965 bfd_xcoff_size_dynamic_sections (output_bfd, info, libpath, entry,
1966 file_align, maxstack, maxdata, gc,
1969 struct bfd_link_info *info;
1970 const char *libpath;
1972 unsigned long file_align;
1973 unsigned long maxstack;
1974 unsigned long maxdata;
1979 struct xcoff_link_hash_entry *hentry;
1981 struct xcoff_loader_info ldinfo;
1982 size_t impsize, impcount;
1983 struct xcoff_import_file *fl;
1984 struct internal_ldhdr *ldhdr;
1988 struct bfd_strtab_hash *debug_strtab;
1989 bfd_byte *debug_contents = NULL;
1991 ldinfo.failed = false;
1992 ldinfo.output_bfd = output_bfd;
1994 ldinfo.ldsym_count = 0;
1995 ldinfo.string_size = 0;
1996 ldinfo.strings = NULL;
1997 ldinfo.string_alc = 0;
1999 xcoff_data (output_bfd)->maxstack = maxstack;
2000 xcoff_data (output_bfd)->maxdata = maxdata;
2001 xcoff_data (output_bfd)->modtype = modtype;
2003 xcoff_hash_table (info)->file_align = file_align;
2004 xcoff_hash_table (info)->textro = textro;
2006 hentry = xcoff_link_hash_lookup (xcoff_hash_table (info), entry,
2007 false, false, true);
2009 hentry->flags |= XCOFF_ENTRY;
2011 /* Garbage collect unused sections. */
2012 if (info->relocateable
2015 || (hentry->root.type != bfd_link_hash_defined
2016 && hentry->root.type != bfd_link_hash_defweak))
2017 xcoff_hash_table (info)->gc = false;
2020 if (! xcoff_mark (info, hentry->root.u.def.section))
2023 xcoff_hash_table (info)->gc = true;
2026 if (info->input_bfds == NULL)
2028 /* I'm not sure what to do in this bizarre case. */
2032 xcoff_link_hash_traverse (xcoff_hash_table (info), xcoff_build_ldsyms,
2037 /* Work out the size of the import file names. Each import file ID
2038 consists of three null terminated strings: the path, the file
2039 name, and the archive member name. The first entry in the list
2040 of names is the path to use to find objects, which the linker has
2041 passed in as the libpath argument. For some reason, the path
2042 entry in the other import file names appears to always be empty. */
2043 impsize = strlen (libpath) + 3;
2045 for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
2048 impsize += (strlen (fl->path)
2050 + strlen (fl->member)
2054 /* Set up the .loader section header. */
2055 ldhdr = &xcoff_hash_table (info)->ldhdr;
2056 ldhdr->l_version = 1;
2057 ldhdr->l_nsyms = ldinfo.ldsym_count;
2058 ldhdr->l_nreloc = xcoff_hash_table (info)->ldrel_count;
2059 ldhdr->l_istlen = impsize;
2060 ldhdr->l_nimpid = impcount;
2061 ldhdr->l_impoff = (LDHDRSZ
2062 + ldhdr->l_nsyms * LDSYMSZ
2063 + ldhdr->l_nreloc * LDRELSZ);
2064 ldhdr->l_stlen = ldinfo.string_size;
2065 ldhdr->l_stoff = ldhdr->l_impoff + impsize;
2067 /* We now know the final size of the .loader section. Allocate
2069 lsec = xcoff_hash_table (info)->loader_section;
2070 lsec->_raw_size = ldhdr->l_stoff + ldhdr->l_stlen;
2071 lsec->contents = (bfd_byte *) bfd_zalloc (output_bfd, lsec->_raw_size);
2072 if (lsec->contents == NULL)
2074 bfd_set_error (bfd_error_no_memory);
2078 /* Set up the header. */
2079 xcoff_swap_ldhdr_out (output_bfd, ldhdr,
2080 (struct external_ldhdr *) lsec->contents);
2082 /* Set up the import file names. */
2083 out = (char *) lsec->contents + ldhdr->l_impoff;
2084 strcpy (out, libpath);
2085 out += strlen (libpath) + 1;
2088 for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
2090 register const char *s;
2093 while ((*out++ = *s++) != '\0')
2096 while ((*out++ = *s++) != '\0')
2099 while ((*out++ = *s++) != '\0')
2103 BFD_ASSERT ((bfd_size_type) ((bfd_byte *) out - lsec->contents)
2106 /* Set up the symbol string table. */
2107 if (ldinfo.string_size > 0)
2109 memcpy (out, ldinfo.strings, ldinfo.string_size);
2110 free (ldinfo.strings);
2111 ldinfo.strings = NULL;
2114 /* We can't set up the symbol table or the relocs yet, because we
2115 don't yet know the final position of the various sections. The
2116 .loader symbols are written out when the corresponding normal
2117 symbols are written out in xcoff_link_input_bfd or
2118 xcoff_write_global_symbol. The .loader relocs are written out
2119 when the corresponding normal relocs are handled in
2120 xcoff_link_input_bfd. */
2122 /* Allocate space for the global linkage section and the global toc
2124 sec = xcoff_hash_table (info)->linkage_section;
2125 if (sec->_raw_size > 0)
2127 sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
2128 if (sec->contents == NULL)
2130 bfd_set_error (bfd_error_no_memory);
2134 sec = xcoff_hash_table (info)->toc_section;
2135 if (sec->_raw_size > 0)
2137 sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
2138 if (sec->contents == NULL)
2140 bfd_set_error (bfd_error_no_memory);
2145 /* Now that we've done garbage collection, figure out the contents
2146 of the .debug section. */
2147 debug_strtab = xcoff_hash_table (info)->debug_strtab;
2149 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2152 bfd_size_type symcount;
2153 unsigned long *debug_index;
2155 bfd_byte *esym, *esymend;
2156 bfd_size_type symesz;
2158 if (sub->xvec != info->hash->creator)
2160 subdeb = bfd_get_section_by_name (sub, ".debug");
2161 if (subdeb == NULL || subdeb->_raw_size == 0)
2164 if (info->strip == strip_all
2165 || info->strip == strip_debugger
2166 || info->discard == discard_all)
2168 subdeb->_raw_size = 0;
2172 if (! _bfd_coff_get_external_symbols (sub))
2175 symcount = obj_raw_syment_count (sub);
2176 debug_index = ((unsigned long *)
2177 bfd_zalloc (sub, symcount * sizeof (unsigned long)));
2178 if (debug_index == NULL)
2180 bfd_set_error (bfd_error_no_memory);
2183 xcoff_data (sub)->debug_indices = debug_index;
2185 /* Grab the contents of the .debug section. We use malloc and
2186 copy the neams into the debug stringtab, rather than
2187 bfd_alloc, because I expect that, when linking many files
2188 together, many of the strings will be the same. Storing the
2189 strings in the hash table should save space in this case. */
2190 debug_contents = (bfd_byte *) malloc (subdeb->_raw_size);
2191 if (debug_contents == NULL)
2193 bfd_set_error (bfd_error_no_memory);
2196 if (! bfd_get_section_contents (sub, subdeb, (PTR) debug_contents,
2197 (file_ptr) 0, subdeb->_raw_size))
2200 csectpp = xcoff_data (sub)->csects;
2202 symesz = bfd_coff_symesz (sub);
2203 esym = (bfd_byte *) obj_coff_external_syms (sub);
2204 esymend = esym + symcount * symesz;
2205 while (esym < esymend)
2207 struct internal_syment sym;
2209 bfd_coff_swap_sym_in (sub, (PTR) esym, (PTR) &sym);
2211 *debug_index = (unsigned long) -1;
2213 if (sym._n._n_n._n_zeroes == 0
2216 || ((*csectpp)->flags & SEC_MARK) != 0
2217 || *csectpp == bfd_abs_section_ptr)
2218 && bfd_coff_symname_in_debug (sub, &sym))
2223 name = (char *) debug_contents + sym._n._n_n._n_offset;
2224 indx = _bfd_stringtab_add (debug_strtab, name, true, true);
2225 if (indx == (bfd_size_type) -1)
2227 *debug_index = indx;
2230 esym += (sym.n_numaux + 1) * symesz;
2231 csectpp += sym.n_numaux + 1;
2232 debug_index += sym.n_numaux + 1;
2235 free (debug_contents);
2236 debug_contents = NULL;
2238 /* Clear the size of subdeb, so that it is not included directly
2239 in the output file. */
2240 subdeb->_raw_size = 0;
2242 if (! info->keep_memory)
2244 if (! _bfd_coff_free_symbols (sub))
2249 xcoff_hash_table (info)->debug_section->_raw_size =
2250 _bfd_stringtab_size (debug_strtab);
2255 if (ldinfo.strings != NULL)
2256 free (ldinfo.strings);
2257 if (debug_contents != NULL)
2258 free (debug_contents);
2262 /* The mark phase of garbage collection. For a given section, mark
2263 it, and all the sections which define symbols to which it refers. */
2266 xcoff_mark (info, sec)
2267 struct bfd_link_info *info;
2270 if ((sec->flags & SEC_MARK) != 0)
2273 sec->flags |= SEC_MARK;
2275 if (sec->owner->xvec == info->hash->creator
2276 && coff_section_data (sec->owner, sec) != NULL
2277 && xcoff_section_data (sec->owner, sec) != NULL)
2279 register struct xcoff_link_hash_entry **hp, **hpend;
2280 struct internal_reloc *rel, *relend;
2282 /* Mark all the symbols in this section. */
2284 hp = (obj_xcoff_sym_hashes (sec->owner)
2285 + xcoff_section_data (sec->owner, sec)->first_symndx);
2286 hpend = (obj_xcoff_sym_hashes (sec->owner)
2287 + xcoff_section_data (sec->owner, sec)->last_symndx);
2288 for (; hp < hpend; hp++)
2290 register struct xcoff_link_hash_entry *h;
2294 && (h->flags & XCOFF_MARK) == 0)
2296 h->flags |= XCOFF_MARK;
2297 if (h->root.type == bfd_link_hash_defined
2298 || h->root.type == bfd_link_hash_defweak)
2302 hsec = h->root.u.def.section;
2303 if ((hsec->flags & SEC_MARK) == 0)
2305 if (! xcoff_mark (info, hsec))
2310 if (h->toc_section != NULL
2311 && (h->toc_section->flags & SEC_MARK) == 0)
2313 if (! xcoff_mark (info, h->toc_section))
2319 /* Look through the section relocs. */
2321 rel = xcoff_read_internal_relocs (sec->owner, sec, true,
2322 (bfd_byte *) NULL, false,
2323 (struct internal_reloc *) NULL);
2326 relend = rel + sec->reloc_count;
2327 for (; rel < relend; rel++)
2330 struct xcoff_link_hash_entry *h;
2332 if ((unsigned int) rel->r_symndx
2333 > obj_raw_syment_count (sec->owner))
2336 h = obj_xcoff_sym_hashes (sec->owner)[rel->r_symndx];
2338 && (h->flags & XCOFF_MARK) == 0)
2340 h->flags |= XCOFF_MARK;
2341 if (h->root.type == bfd_link_hash_defined
2342 || h->root.type == bfd_link_hash_defweak)
2346 hsec = h->root.u.def.section;
2347 if ((hsec->flags & SEC_MARK) == 0)
2349 if (! xcoff_mark (info, hsec))
2354 if (h->toc_section != NULL
2355 && (h->toc_section->flags & SEC_MARK) == 0)
2357 if (! xcoff_mark (info, h->toc_section))
2362 rsec = xcoff_data (sec->owner)->csects[rel->r_symndx];
2364 && (rsec->flags & SEC_MARK) == 0)
2366 if (! xcoff_mark (info, rsec))
2371 if (! info->keep_memory
2372 && coff_section_data (sec->owner, sec) != NULL
2373 && coff_section_data (sec->owner, sec)->relocs != NULL
2374 && ! coff_section_data (sec->owner, sec)->keep_relocs)
2376 free (coff_section_data (sec->owner, sec)->relocs);
2377 coff_section_data (sec->owner, sec)->relocs = NULL;
2384 /* The sweep phase of garbage collection. Remove all garbage
2389 struct bfd_link_info *info;
2393 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2397 for (o = sub->sections; o != NULL; o = o->next)
2399 if ((o->flags & SEC_MARK) == 0)
2401 /* Keep all sections from non-XCOFF input files. Keep
2402 special sections. Keep .debug sections for the
2404 if (sub->xvec != info->hash->creator
2405 || o == xcoff_hash_table (info)->debug_section
2406 || o == xcoff_hash_table (info)->loader_section
2407 || o == xcoff_hash_table (info)->linkage_section
2408 || o == xcoff_hash_table (info)->toc_section
2409 || strcmp (o->name, ".debug") == 0)
2410 o->flags |= SEC_MARK;
2415 o->lineno_count = 0;
2416 if (coff_section_data (sub, o) != NULL
2417 && xcoff_section_data (sub, o) != NULL)
2418 xcoff_hash_table (info)->ldrel_count -=
2419 xcoff_section_data (sub, o)->ldrel_count;
2426 /* Add a symbol to the .loader symbols, if necessary. */
2429 xcoff_build_ldsyms (h, p)
2430 struct xcoff_link_hash_entry *h;
2433 struct xcoff_loader_info *ldinfo = (struct xcoff_loader_info *) p;
2436 /* We don't want to garbage collect symbols which are not defined in
2437 XCOFF files. This is a convenient place to mark them. */
2438 if (xcoff_hash_table (ldinfo->info)->gc
2439 && (h->flags & XCOFF_MARK) == 0
2440 && (h->root.type == bfd_link_hash_defined
2441 || h->root.type == bfd_link_hash_defweak)
2442 && (h->root.u.def.section->owner == NULL
2443 || (h->root.u.def.section->owner->xvec
2444 != ldinfo->info->hash->creator)))
2445 h->flags |= XCOFF_MARK;
2447 /* If this symbol is called, and it is defined in a dynamic object,
2448 then we need to set up global linkage code for it. (Unless we
2449 did garbage collection and we didn't need this symbol.) */
2450 if ((h->flags & XCOFF_CALLED) != 0
2451 && (h->flags & XCOFF_DEF_REGULAR) == 0
2452 && (h->flags & XCOFF_REF_DYNAMIC) != 0
2453 && (h->root.type == bfd_link_hash_undefined
2454 || h->root.type == bfd_link_hash_undefweak)
2455 && h->root.root.string[0] == '.'
2456 && (! xcoff_hash_table (ldinfo->info)->gc
2457 || (h->flags & XCOFF_MARK) != 0))
2460 struct xcoff_link_hash_entry *hds;
2462 sec = xcoff_hash_table (ldinfo->info)->linkage_section;
2463 h->root.type = bfd_link_hash_defined;
2464 h->root.u.def.section = sec;
2465 h->root.u.def.value = sec->_raw_size;
2467 sec->_raw_size += XCOFF_GLINK_SIZE;
2469 /* The global linkage code requires a TOC entry for the
2471 hds = h->descriptor;
2472 BFD_ASSERT ((hds->root.type == bfd_link_hash_undefined
2473 || hds->root.type == bfd_link_hash_undefweak)
2474 && (hds->flags & XCOFF_DEF_REGULAR) == 0
2475 && (hds->flags & XCOFF_REF_DYNAMIC) != 0);
2476 hds->flags |= XCOFF_MARK;
2477 if (hds->toc_section == NULL)
2479 hds->toc_section = xcoff_hash_table (ldinfo->info)->toc_section;
2480 hds->toc_offset = hds->toc_section->_raw_size;
2481 hds->toc_section->_raw_size += 4;
2482 ++xcoff_hash_table (ldinfo->info)->ldrel_count;
2483 ++hds->toc_section->reloc_count;
2485 hds->flags |= XCOFF_SET_TOC | XCOFF_LDREL;
2487 /* We need to call xcoff_build_ldsyms recursively here,
2488 because we may already have passed hds on the traversal. */
2489 xcoff_build_ldsyms (hds, p);
2493 /* We need to add a symbol to the .loader section if it is mentioned
2494 in a reloc which we are copying to the .loader section and it was
2495 not defined, or if it is the entry point. */
2497 if (((h->flags & XCOFF_LDREL) == 0
2498 || h->root.type == bfd_link_hash_defined
2499 || h->root.type == bfd_link_hash_defweak)
2500 && (h->flags & XCOFF_ENTRY) == 0)
2506 /* We don't need to add this symbol if we did garbage collection and
2507 we did not mark this symbol. */
2508 if (xcoff_hash_table (ldinfo->info)->gc
2509 && (h->flags & XCOFF_MARK) == 0)
2515 /* We may have already processed this symbol due to the recursive
2517 if ((h->flags & XCOFF_BUILT_LDSYM) != 0)
2520 /* We need to add this symbol to the .loader symbols. */
2522 /* h->ldsym will already have been allocated for an explicitly
2524 if (h->ldsym == NULL)
2526 h->ldsym = ((struct internal_ldsym *)
2527 bfd_zalloc (ldinfo->output_bfd,
2528 sizeof (struct internal_ldsym)));
2529 if (h->ldsym == NULL)
2531 ldinfo->failed = true;
2532 bfd_set_error (bfd_error_no_memory);
2537 /* The first 3 symbol table indices are reserved to indicate the
2539 h->ldindx = ldinfo->ldsym_count + 3;
2541 ++ldinfo->ldsym_count;
2543 len = strlen (h->root.root.string);
2544 if (len <= SYMNMLEN)
2545 strncpy (h->ldsym->_l._l_name, h->root.root.string, SYMNMLEN);
2548 if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
2551 bfd_byte *newstrings;
2553 newalc = ldinfo->string_alc * 2;
2556 while (ldinfo->string_size + len + 3 > newalc)
2559 if (ldinfo->strings == NULL)
2560 newstrings = (bfd_byte *) malloc (newalc);
2562 newstrings = ((bfd_byte *)
2563 realloc ((PTR) ldinfo->strings, newalc));
2564 if (newstrings == NULL)
2566 ldinfo->failed = true;
2567 bfd_set_error (bfd_error_no_memory);
2570 ldinfo->string_alc = newalc;
2571 ldinfo->strings = newstrings;
2574 bfd_put_16 (ldinfo->output_bfd, len + 1,
2575 ldinfo->strings + ldinfo->string_size);
2576 strcpy (ldinfo->strings + ldinfo->string_size + 2, h->root.root.string);
2577 h->ldsym->_l._l_l._l_zeroes = 0;
2578 h->ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
2579 ldinfo->string_size += len + 3;
2582 h->flags |= XCOFF_BUILT_LDSYM;
2587 /* Do the final link step. */
2590 _bfd_xcoff_bfd_final_link (abfd, info)
2592 struct bfd_link_info *info;
2594 bfd_size_type symesz;
2595 struct xcoff_final_link_info finfo;
2597 struct bfd_link_order *p;
2598 size_t max_contents_size;
2599 size_t max_sym_count;
2600 size_t max_lineno_count;
2601 size_t max_reloc_count;
2602 size_t max_output_reloc_count;
2603 file_ptr rel_filepos;
2605 file_ptr line_filepos;
2606 unsigned int linesz;
2608 bfd_byte *external_relocs = NULL;
2609 char strbuf[STRING_SIZE_SIZE];
2611 symesz = bfd_coff_symesz (abfd);
2614 finfo.output_bfd = abfd;
2615 finfo.strtab = NULL;
2616 finfo.section_info = NULL;
2617 finfo.last_file_index = -1;
2618 finfo.toc_symindx = -1;
2619 finfo.internal_syms = NULL;
2620 finfo.sym_indices = NULL;
2621 finfo.outsyms = NULL;
2622 finfo.linenos = NULL;
2623 finfo.contents = NULL;
2624 finfo.external_relocs = NULL;
2626 finfo.ldsym = ((struct external_ldsym *)
2627 (xcoff_hash_table (info)->loader_section->contents
2629 finfo.ldrel = ((struct external_ldrel *)
2630 (xcoff_hash_table (info)->loader_section->contents
2632 + xcoff_hash_table (info)->ldhdr.l_nsyms * LDSYMSZ));
2634 xcoff_data (abfd)->coff.link_info = info;
2636 finfo.strtab = _bfd_stringtab_init ();
2637 if (finfo.strtab == NULL)
2640 /* Compute the file positions for all the sections. */
2641 if (abfd->output_has_begun)
2643 if (xcoff_hash_table (info)->file_align != 0)
2650 file_align = xcoff_hash_table (info)->file_align;
2651 if (file_align != 0)
2653 boolean saw_contents;
2658 /* Insert .pad sections before every section which has
2659 contents and is loaded, if it is preceded by some other
2660 section which has contents and is loaded. */
2661 saw_contents = true;
2662 for (op = &abfd->sections; *op != NULL; op = &(*op)->next)
2664 (*op)->target_index = indx;
2665 if (strcmp ((*op)->name, ".pad") == 0)
2666 saw_contents = false;
2667 else if (((*op)->flags & SEC_HAS_CONTENTS) != 0
2668 && ((*op)->flags & SEC_LOAD) != 0)
2671 saw_contents = true;
2678 n = bfd_make_section_anyway (abfd, ".pad");
2679 BFD_ASSERT (*op == n);
2681 n->flags = SEC_HAS_CONTENTS;
2682 n->alignment_power = 0;
2683 saw_contents = false;
2688 /* Reset the section indices after inserting the new
2691 for (o = abfd->sections; o != NULL; o = o->next)
2694 o->target_index = indx;
2696 BFD_ASSERT ((unsigned int) indx == abfd->section_count);
2698 /* Work out appropriate sizes for the .pad sections to force
2699 each section to land on a page boundary. This bit of
2700 code knows what compute_section_file_positions is going
2702 sofar = bfd_coff_filhsz (abfd);
2703 if ((abfd->flags & EXEC_P) != 0)
2704 sofar += bfd_coff_aoutsz (abfd);
2710 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
2712 for (o = abfd->sections; o != NULL; o = o->next)
2714 if (strcmp (o->name, ".pad") == 0)
2718 BFD_ASSERT (o->_raw_size == 0);
2719 pageoff = sofar & (file_align - 1);
2722 o->_raw_size = file_align - pageoff;
2723 sofar += file_align - pageoff;
2724 o->flags |= SEC_HAS_CONTENTS;
2729 if ((o->flags & SEC_HAS_CONTENTS) != 0)
2730 sofar += BFD_ALIGN (o->_raw_size,
2731 1 << o->alignment_power);
2736 bfd_coff_compute_section_file_positions (abfd);
2739 /* Count the line numbers and relocation entries required for the
2740 output file. Set the file positions for the relocs. */
2741 rel_filepos = obj_relocbase (abfd);
2742 relsz = bfd_coff_relsz (abfd);
2743 max_contents_size = 0;
2744 max_lineno_count = 0;
2745 max_reloc_count = 0;
2746 for (o = abfd->sections; o != NULL; o = o->next)
2749 o->lineno_count = 0;
2750 for (p = o->link_order_head; p != NULL; p = p->next)
2752 if (p->type == bfd_indirect_link_order)
2756 sec = p->u.indirect.section;
2758 if (info->strip == strip_none
2759 || info->strip == strip_some)
2760 o->lineno_count += sec->lineno_count;
2762 o->reloc_count += sec->reloc_count;
2764 if (sec->_raw_size > max_contents_size)
2765 max_contents_size = sec->_raw_size;
2766 if (sec->lineno_count > max_lineno_count)
2767 max_lineno_count = sec->lineno_count;
2768 if (sec->reloc_count > max_reloc_count)
2769 max_reloc_count = sec->reloc_count;
2771 else if (p->type == bfd_section_reloc_link_order
2772 || p->type == bfd_symbol_reloc_link_order)
2775 if (o->reloc_count == 0)
2779 o->flags |= SEC_RELOC;
2780 o->rel_filepos = rel_filepos;
2781 rel_filepos += o->reloc_count * relsz;
2785 /* Allocate space for the pointers we need to keep for the relocs. */
2789 /* We use section_count + 1, rather than section_count, because
2790 the target_index fields are 1 based. */
2791 finfo.section_info = ((struct xcoff_link_section_info *)
2792 malloc ((abfd->section_count + 1)
2793 * sizeof (struct xcoff_link_section_info)));
2794 if (finfo.section_info == NULL)
2796 bfd_set_error (bfd_error_no_memory);
2799 for (i = 0; i <= abfd->section_count; i++)
2801 finfo.section_info[i].relocs = NULL;
2802 finfo.section_info[i].rel_hashes = NULL;
2806 /* We now know the size of the relocs, so we can determine the file
2807 positions of the line numbers. */
2808 line_filepos = rel_filepos;
2809 linesz = bfd_coff_linesz (abfd);
2810 max_output_reloc_count = 0;
2811 for (o = abfd->sections; o != NULL; o = o->next)
2813 if (o->lineno_count == 0)
2814 o->line_filepos = 0;
2817 o->line_filepos = line_filepos;
2818 line_filepos += o->lineno_count * linesz;
2821 if (o->reloc_count != 0)
2823 /* We don't know the indices of global symbols until we have
2824 written out all the local symbols. For each section in
2825 the output file, we keep an array of pointers to hash
2826 table entries. Each entry in the array corresponds to a
2827 reloc. When we find a reloc against a global symbol, we
2828 set the corresponding entry in this array so that we can
2829 fix up the symbol index after we have written out all the
2832 Because of this problem, we also keep the relocs in
2833 memory until the end of the link. This wastes memory.
2834 We could backpatch the file later, I suppose, although it
2836 finfo.section_info[o->target_index].relocs =
2837 ((struct internal_reloc *)
2838 malloc (o->reloc_count * sizeof (struct internal_reloc)));
2839 finfo.section_info[o->target_index].rel_hashes =
2840 ((struct xcoff_link_hash_entry **)
2841 malloc (o->reloc_count
2842 * sizeof (struct xcoff_link_hash_entry *)));
2843 if (finfo.section_info[o->target_index].relocs == NULL
2844 || finfo.section_info[o->target_index].rel_hashes == NULL)
2846 bfd_set_error (bfd_error_no_memory);
2850 if (o->reloc_count > max_output_reloc_count)
2851 max_output_reloc_count = o->reloc_count;
2854 /* Reset the reloc and lineno counts, so that we can use them to
2855 count the number of entries we have output so far. */
2857 o->lineno_count = 0;
2860 obj_sym_filepos (abfd) = line_filepos;
2862 /* Figure out the largest number of symbols in an input BFD. Take
2863 the opportunity to clear the output_has_begun fields of all the
2864 input BFD's. We want at least 4 symbols, since that is the
2865 number which xcoff_write_global_symbol may need. */
2867 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2871 sub->output_has_begun = false;
2872 sz = obj_raw_syment_count (sub);
2873 if (sz > max_sym_count)
2877 /* Allocate some buffers used while linking. */
2878 finfo.internal_syms = ((struct internal_syment *)
2879 malloc (max_sym_count
2880 * sizeof (struct internal_syment)));
2881 finfo.sym_indices = (long *) malloc (max_sym_count * sizeof (long));
2882 finfo.outsyms = ((bfd_byte *)
2883 malloc ((size_t) ((max_sym_count + 1) * symesz)));
2884 finfo.linenos = (bfd_byte *) malloc (max_lineno_count
2885 * bfd_coff_linesz (abfd));
2886 finfo.contents = (bfd_byte *) malloc (max_contents_size);
2887 finfo.external_relocs = (bfd_byte *) malloc (max_reloc_count * relsz);
2888 if ((finfo.internal_syms == NULL && max_sym_count > 0)
2889 || (finfo.sym_indices == NULL && max_sym_count > 0)
2890 || finfo.outsyms == NULL
2891 || (finfo.linenos == NULL && max_lineno_count > 0)
2892 || (finfo.contents == NULL && max_contents_size > 0)
2893 || (finfo.external_relocs == NULL && max_reloc_count > 0))
2895 bfd_set_error (bfd_error_no_memory);
2899 obj_raw_syment_count (abfd) = 0;
2900 xcoff_data (abfd)->toc = (bfd_vma) -1;
2902 /* We now know the position of everything in the file, except that
2903 we don't know the size of the symbol table and therefore we don't
2904 know where the string table starts. We just build the string
2905 table in memory as we go along. We process all the relocations
2906 for a single input file at once. */
2907 for (o = abfd->sections; o != NULL; o = o->next)
2909 for (p = o->link_order_head; p != NULL; p = p->next)
2911 if (p->type == bfd_indirect_link_order
2912 && p->u.indirect.section->owner->xvec == abfd->xvec)
2914 sub = p->u.indirect.section->owner;
2915 if (! sub->output_has_begun)
2917 if (! xcoff_link_input_bfd (&finfo, sub))
2919 sub->output_has_begun = true;
2922 else if (p->type == bfd_section_reloc_link_order
2923 || p->type == bfd_symbol_reloc_link_order)
2925 if (! xcoff_reloc_link_order (abfd, &finfo, o, p))
2930 if (! _bfd_default_link_order (abfd, info, o, p))
2936 /* Free up the buffers used by xcoff_link_input_bfd. */
2938 if (finfo.internal_syms != NULL)
2940 free (finfo.internal_syms);
2941 finfo.internal_syms = NULL;
2943 if (finfo.sym_indices != NULL)
2945 free (finfo.sym_indices);
2946 finfo.sym_indices = NULL;
2948 if (finfo.linenos != NULL)
2950 free (finfo.linenos);
2951 finfo.linenos = NULL;
2953 if (finfo.contents != NULL)
2955 free (finfo.contents);
2956 finfo.contents = NULL;
2958 if (finfo.external_relocs != NULL)
2960 free (finfo.external_relocs);
2961 finfo.external_relocs = NULL;
2964 /* The value of the last C_FILE symbol is supposed to be -1. Write
2966 if (finfo.last_file_index != -1)
2968 finfo.last_file.n_value = -1;
2969 bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
2970 (PTR) finfo.outsyms);
2972 (obj_sym_filepos (abfd)
2973 + finfo.last_file_index * symesz),
2975 || bfd_write (finfo.outsyms, symesz, 1, abfd) != symesz)
2979 /* Write out all the global symbols which do not come from XCOFF
2981 xcoff_link_hash_traverse (xcoff_hash_table (info),
2982 xcoff_write_global_symbol,
2985 if (finfo.outsyms != NULL)
2987 free (finfo.outsyms);
2988 finfo.outsyms = NULL;
2991 /* Now that we have written out all the global symbols, we know the
2992 symbol indices to use for relocs against them, and we can finally
2993 write out the relocs. */
2994 external_relocs = (bfd_byte *) malloc (max_output_reloc_count * relsz);
2995 if (external_relocs == NULL && max_output_reloc_count != 0)
2997 bfd_set_error (bfd_error_no_memory);
3001 for (o = abfd->sections; o != NULL; o = o->next)
3003 struct internal_reloc *irel;
3004 struct internal_reloc *irelend;
3005 struct xcoff_link_hash_entry **rel_hash;
3008 if (o->reloc_count == 0)
3011 irel = finfo.section_info[o->target_index].relocs;
3012 irelend = irel + o->reloc_count;
3013 rel_hash = finfo.section_info[o->target_index].rel_hashes;
3014 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
3016 if (*rel_hash != NULL)
3018 if ((*rel_hash)->indx < 0)
3020 if (! ((*info->callbacks->unattached_reloc)
3021 (info, (*rel_hash)->root.root.string,
3022 (bfd *) NULL, o, irel->r_vaddr)))
3024 (*rel_hash)->indx = 0;
3026 irel->r_symndx = (*rel_hash)->indx;
3030 /* XCOFF requires that the relocs be sorted by address. We tend
3031 to produce them in the order in which their containing csects
3032 appear in the symbol table, which is not necessarily by
3033 address. So we sort them here. There may be a better way to
3035 qsort ((PTR) finfo.section_info[o->target_index].relocs,
3036 o->reloc_count, sizeof (struct internal_reloc),
3039 irel = finfo.section_info[o->target_index].relocs;
3040 irelend = irel + o->reloc_count;
3041 erel = external_relocs;
3042 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
3043 bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
3045 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
3046 || bfd_write ((PTR) external_relocs, relsz, o->reloc_count,
3047 abfd) != relsz * o->reloc_count)
3051 if (external_relocs != NULL)
3053 free (external_relocs);
3054 external_relocs = NULL;
3057 /* Free up the section information. */
3058 if (finfo.section_info != NULL)
3062 for (i = 0; i < abfd->section_count; i++)
3064 if (finfo.section_info[i].relocs != NULL)
3065 free (finfo.section_info[i].relocs);
3066 if (finfo.section_info[i].rel_hashes != NULL)
3067 free (finfo.section_info[i].rel_hashes);
3069 free (finfo.section_info);
3070 finfo.section_info = NULL;
3073 /* Write out the loader section contents. */
3074 BFD_ASSERT ((bfd_byte *) finfo.ldrel
3075 == (xcoff_hash_table (info)->loader_section->contents
3076 + xcoff_hash_table (info)->ldhdr.l_impoff));
3077 o = xcoff_hash_table (info)->loader_section;
3078 if (! bfd_set_section_contents (abfd, o->output_section,
3079 o->contents, o->output_offset,
3083 /* Write out the global linkage section and the toc section. */
3084 o = xcoff_hash_table (info)->linkage_section;
3085 if (o->_raw_size > 0
3086 && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
3087 o->output_offset, o->_raw_size))
3089 o = xcoff_hash_table (info)->toc_section;
3090 if (o->_raw_size > 0
3091 && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
3092 o->output_offset, o->_raw_size))
3095 /* Write out the string table. */
3097 (obj_sym_filepos (abfd)
3098 + obj_raw_syment_count (abfd) * symesz),
3102 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
3103 (bfd_byte *) strbuf);
3104 if (bfd_write (strbuf, 1, STRING_SIZE_SIZE, abfd) != STRING_SIZE_SIZE)
3106 if (! _bfd_stringtab_emit (abfd, finfo.strtab))
3109 _bfd_stringtab_free (finfo.strtab);
3111 /* Write out the debugging string table. */
3112 o = xcoff_hash_table (info)->debug_section;
3115 struct bfd_strtab_hash *debug_strtab;
3117 debug_strtab = xcoff_hash_table (info)->debug_strtab;
3118 BFD_ASSERT (o->output_section->_raw_size - o->output_offset
3119 >= _bfd_stringtab_size (debug_strtab));
3121 o->output_section->filepos + o->output_offset,
3124 if (! _bfd_stringtab_emit (abfd, debug_strtab))
3128 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
3129 not try to write out the symbols. */
3130 bfd_get_symcount (abfd) = 0;
3135 if (finfo.strtab != NULL)
3136 _bfd_stringtab_free (finfo.strtab);
3137 if (finfo.section_info != NULL)
3141 for (i = 0; i < abfd->section_count; i++)
3143 if (finfo.section_info[i].relocs != NULL)
3144 free (finfo.section_info[i].relocs);
3145 if (finfo.section_info[i].rel_hashes != NULL)
3146 free (finfo.section_info[i].rel_hashes);
3148 free (finfo.section_info);
3150 if (finfo.internal_syms != NULL)
3151 free (finfo.internal_syms);
3152 if (finfo.sym_indices != NULL)
3153 free (finfo.sym_indices);
3154 if (finfo.outsyms != NULL)
3155 free (finfo.outsyms);
3156 if (finfo.linenos != NULL)
3157 free (finfo.linenos);
3158 if (finfo.contents != NULL)
3159 free (finfo.contents);
3160 if (finfo.external_relocs != NULL)
3161 free (finfo.external_relocs);
3162 if (external_relocs != NULL)
3163 free (external_relocs);
3167 /* Link an input file into the linker output file. This function
3168 handles all the sections and relocations of the input file at once. */
3171 xcoff_link_input_bfd (finfo, input_bfd)
3172 struct xcoff_final_link_info *finfo;
3176 const char *strings;
3177 bfd_size_type syment_base;
3178 unsigned int n_tmask;
3179 unsigned int n_btshft;
3181 bfd_size_type isymesz;
3182 bfd_size_type osymesz;
3183 bfd_size_type linesz;
3186 struct internal_syment *isymp;
3188 unsigned long *debug_index;
3190 unsigned long output_index;
3192 struct xcoff_link_hash_entry **sym_hash;
3196 /* We can just skip DYNAMIC files, unless this is a static link. */
3197 if ((input_bfd->flags & DYNAMIC) != 0
3198 && ! finfo->info->static_link)
3201 /* Move all the symbols to the output file. */
3203 output_bfd = finfo->output_bfd;
3205 syment_base = obj_raw_syment_count (output_bfd);
3206 isymesz = bfd_coff_symesz (input_bfd);
3207 osymesz = bfd_coff_symesz (output_bfd);
3208 linesz = bfd_coff_linesz (input_bfd);
3209 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
3211 n_tmask = coff_data (input_bfd)->local_n_tmask;
3212 n_btshft = coff_data (input_bfd)->local_n_btshft;
3214 /* Define macros so that ISFCN, et. al., macros work correctly. */
3215 #define N_TMASK n_tmask
3216 #define N_BTSHFT n_btshft
3219 if (! finfo->info->keep_memory)
3222 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
3225 if (! _bfd_coff_get_external_symbols (input_bfd))
3228 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
3229 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
3230 sym_hash = obj_xcoff_sym_hashes (input_bfd);
3231 csectpp = xcoff_data (input_bfd)->csects;
3232 debug_index = xcoff_data (input_bfd)->debug_indices;
3233 isymp = finfo->internal_syms;
3234 indexp = finfo->sym_indices;
3235 output_index = syment_base;
3236 outsym = finfo->outsyms;
3238 while (esym < esym_end)
3240 struct internal_syment isym;
3241 union internal_auxent aux;
3247 bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
3249 /* If this is a C_EXT or C_HIDEXT symbol, we need the csect
3251 if (isymp->n_sclass == C_EXT || isymp->n_sclass == C_HIDEXT)
3253 BFD_ASSERT (isymp->n_numaux > 0);
3254 bfd_coff_swap_aux_in (input_bfd,
3255 (PTR) (esym + isymesz * isymp->n_numaux),
3256 isymp->n_type, isymp->n_sclass,
3257 isymp->n_numaux - 1, isymp->n_numaux,
3259 smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
3262 /* Make a copy of *isymp so that the relocate_section function
3263 always sees the original values. This is more reliable than
3264 always recomputing the symbol value even if we are stripping
3268 /* If this symbol is in the .loader section, swap out the
3269 .loader symbol information. If this is an external symbol
3270 reference to a defined symbol, though, then wait until we get
3271 to the definition. */
3272 if (isym.n_sclass == C_EXT
3273 && *sym_hash != NULL
3274 && (*sym_hash)->ldsym != NULL
3276 || (*sym_hash)->root.type == bfd_link_hash_undefined))
3278 struct xcoff_link_hash_entry *h;
3279 struct internal_ldsym *ldsym;
3283 if (isym.n_scnum > 0)
3285 ldsym->l_scnum = (*csectpp)->output_section->target_index;
3286 ldsym->l_value = (isym.n_value
3287 + (*csectpp)->output_section->vma
3288 + (*csectpp)->output_offset
3293 ldsym->l_scnum = isym.n_scnum;
3294 ldsym->l_value = isym.n_value;
3297 ldsym->l_smtype = smtyp;
3298 if (((h->flags & XCOFF_DEF_REGULAR) == 0
3299 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
3300 || (h->flags & XCOFF_IMPORT) != 0)
3301 ldsym->l_smtype |= L_IMPORT;
3302 if (((h->flags & XCOFF_DEF_REGULAR) != 0
3303 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
3304 || (h->flags & XCOFF_EXPORT) != 0)
3305 ldsym->l_smtype |= L_EXPORT;
3306 if ((h->flags & XCOFF_ENTRY) != 0)
3307 ldsym->l_smtype |= L_ENTRY;
3309 ldsym->l_smclas = aux.x_csect.x_smclas;
3311 if (ldsym->l_ifile == (bfd_size_type) -1)
3313 else if (ldsym->l_ifile == 0)
3315 if ((ldsym->l_smtype & L_IMPORT) == 0)
3321 if (h->root.type == bfd_link_hash_defined
3322 || h->root.type == bfd_link_hash_defweak)
3323 impbfd = h->root.u.def.section->owner;
3324 else if (h->root.type == bfd_link_hash_undefined
3325 || h->root.type == bfd_link_hash_undefweak)
3326 impbfd = h->root.u.undef.abfd;
3334 BFD_ASSERT (impbfd->xvec == finfo->output_bfd->xvec);
3335 ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
3342 BFD_ASSERT (h->ldindx >= 0);
3343 BFD_ASSERT (LDSYMSZ == sizeof (struct external_ldsym));
3344 xcoff_swap_ldsym_out (finfo->output_bfd, ldsym,
3345 finfo->ldsym + h->ldindx - 3);
3353 add = 1 + isym.n_numaux;
3355 /* If we are skipping this csect, we want to skip this symbol. */
3356 if (*csectpp == NULL)
3359 /* If we garbage collected this csect, we want to skip this
3362 && xcoff_hash_table (finfo->info)->gc
3363 && ((*csectpp)->flags & SEC_MARK) == 0
3364 && *csectpp != bfd_abs_section_ptr)
3367 /* An XCOFF linker always skips C_STAT symbols. */
3369 && isymp->n_sclass == C_STAT)
3372 /* We skip all but the first TOC anchor. */
3374 && isymp->n_sclass == C_HIDEXT
3375 && aux.x_csect.x_smclas == XMC_TC0)
3377 if (finfo->toc_symindx != -1)
3381 finfo->toc_symindx = output_index;
3382 xcoff_data (finfo->output_bfd)->toc =
3383 ((*csectpp)->output_section->vma
3384 + (*csectpp)->output_offset
3391 /* If we are stripping all symbols, we want to skip this one. */
3393 && finfo->info->strip == strip_all)
3396 /* We can skip resolved external references. */
3398 && isym.n_sclass == C_EXT
3400 && (*sym_hash)->root.type != bfd_link_hash_undefined)
3403 /* We can skip common symbols if they got defined somewhere
3406 && isym.n_sclass == C_EXT
3408 && ((*sym_hash)->flags & XCOFF_DEF_REGULAR) != 0)
3411 /* Skip local symbols if we are discarding them. */
3413 && finfo->info->discard == discard_all
3414 && isym.n_sclass != C_EXT
3415 && (isym.n_sclass != C_HIDEXT
3416 || smtyp != XTY_SD))
3419 /* If we stripping debugging symbols, and this is a debugging
3420 symbol, then skip it. */
3422 && finfo->info->strip == strip_debugger
3423 && isym.n_scnum == N_DEBUG)
3426 /* If some symbols are stripped based on the name, work out the
3427 name and decide whether to skip this symbol. We don't handle
3428 this correctly for symbols whose names are in the .debug
3429 section; to get it right we would need a new bfd_strtab_hash
3430 function to return the string given the index. */
3432 && (finfo->info->strip == strip_some
3433 || finfo->info->discard == discard_l)
3434 && (debug_index == NULL || *debug_index == (unsigned long) -1))
3437 char buf[SYMNMLEN + 1];
3439 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
3443 if ((finfo->info->strip == strip_some
3444 && (bfd_hash_lookup (finfo->info->keep_hash, name, false,
3446 || (finfo->info->discard == discard_l
3447 && (isym.n_sclass != C_EXT
3448 && (isym.n_sclass != C_HIDEXT
3449 || smtyp != XTY_SD))
3450 && strncmp (name, finfo->info->lprefix,
3451 finfo->info->lprefix_len) == 0))
3455 /* On the other hand, we can't skip global symbols which have
3456 relocs against them. */
3458 && isym.n_sclass == C_EXT
3459 && (*sym_hash)->indx == -2
3460 && finfo->info->strip != strip_all)
3463 /* We can not skip the first TOC anchor. */
3466 && finfo->info->strip != strip_all)
3469 /* We now know whether we are to skip this symbol or not. */
3472 /* Adjust the symbol in order to output it. */
3474 if (isym._n._n_n._n_zeroes == 0
3475 && isym._n._n_n._n_offset != 0)
3477 /* This symbol has a long name. Enter it in the string
3478 table we are building. If *debug_index != -1, the
3479 name has already been entered in the .debug section. */
3480 if (debug_index != NULL && *debug_index != (unsigned long) -1)
3481 isym._n._n_n._n_offset = *debug_index;
3487 name = _bfd_coff_internal_syment_name (input_bfd, &isym,
3491 indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
3492 if (indx == (bfd_size_type) -1)
3494 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
3498 if (isym.n_sclass == C_BSTAT)
3502 /* The value of a C_BSTAT symbol is the symbol table
3503 index of the containing csect. */
3505 indx = isym.n_value;
3506 if (indx < obj_raw_syment_count (input_bfd))
3510 symindx = finfo->sym_indices[indx];
3514 isym.n_value = symindx;
3517 else if (isym.n_scnum > 0)
3519 isym.n_scnum = (*csectpp)->output_section->target_index;
3520 isym.n_value += ((*csectpp)->output_section->vma
3521 + (*csectpp)->output_offset
3525 /* The value of a C_FILE symbol is the symbol index of the
3526 next C_FILE symbol. The value of the last C_FILE symbol
3527 is -1. We try to get this right, below, just before we
3528 write the symbols out, but in the general case we may
3529 have to write the symbol out twice. */
3530 if (isym.n_sclass == C_FILE)
3532 if (finfo->last_file_index != -1
3533 && finfo->last_file.n_value != (long) output_index)
3535 /* We must correct the value of the last C_FILE entry. */
3536 finfo->last_file.n_value = output_index;
3537 if ((bfd_size_type) finfo->last_file_index >= syment_base)
3539 /* The last C_FILE symbol is in this input file. */
3540 bfd_coff_swap_sym_out (output_bfd,
3541 (PTR) &finfo->last_file,
3542 (PTR) (finfo->outsyms
3543 + ((finfo->last_file_index
3549 /* We have already written out the last C_FILE
3550 symbol. We need to write it out again. We
3551 borrow *outsym temporarily. */
3552 bfd_coff_swap_sym_out (output_bfd,
3553 (PTR) &finfo->last_file,
3555 if (bfd_seek (output_bfd,
3556 (obj_sym_filepos (output_bfd)
3557 + finfo->last_file_index * osymesz),
3559 || (bfd_write (outsym, osymesz, 1, output_bfd)
3565 finfo->last_file_index = output_index;
3566 finfo->last_file = isym;
3569 /* Output the symbol. */
3571 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
3573 *indexp = output_index;
3575 if (isym.n_sclass == C_EXT)
3578 struct xcoff_link_hash_entry *h;
3580 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
3582 h = obj_xcoff_sym_hashes (input_bfd)[indx];
3583 BFD_ASSERT (h != NULL);
3584 h->indx = output_index;
3587 output_index += add;
3588 outsym += add * osymesz;
3591 esym += add * isymesz;
3595 if (debug_index != NULL)
3598 for (--add; add > 0; --add)
3602 /* Fix up the aux entries. This must be done in a separate pass,
3603 because we don't know the correct symbol indices until we have
3604 already decided which symbols we are going to keep. */
3606 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
3607 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
3608 isymp = finfo->internal_syms;
3609 indexp = finfo->sym_indices;
3610 csectpp = xcoff_data (input_bfd)->csects;
3611 outsym = finfo->outsyms;
3612 while (esym < esym_end)
3616 add = 1 + isymp->n_numaux;
3619 esym += add * isymesz;
3627 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
3629 union internal_auxent aux;
3631 bfd_coff_swap_aux_in (input_bfd, (PTR) esym, isymp->n_type,
3632 isymp->n_sclass, i, isymp->n_numaux,
3635 if (isymp->n_sclass == C_FILE)
3637 /* This is the file name (or some comment put in by
3638 the compiler). If it is long, we must put it in
3639 the string table. */
3640 if (aux.x_file.x_n.x_zeroes == 0
3641 && aux.x_file.x_n.x_offset != 0)
3643 const char *filename;
3646 BFD_ASSERT (aux.x_file.x_n.x_offset
3647 >= STRING_SIZE_SIZE);
3648 if (strings == NULL)
3650 strings = _bfd_coff_read_string_table (input_bfd);
3651 if (strings == NULL)
3654 filename = strings + aux.x_file.x_n.x_offset;
3655 indx = _bfd_stringtab_add (finfo->strtab, filename,
3657 if (indx == (bfd_size_type) -1)
3659 aux.x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
3662 else if ((isymp->n_sclass == C_EXT
3663 || isymp->n_sclass == C_HIDEXT)
3664 && i + 1 == isymp->n_numaux)
3666 /* We don't support type checking. I don't know if
3668 aux.x_csect.x_parmhash = 0;
3669 /* I don't think anybody uses these fields, but we'd
3670 better clobber them just in case. */
3671 aux.x_csect.x_stab = 0;
3672 aux.x_csect.x_snstab = 0;
3673 if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_LD)
3677 indx = aux.x_csect.x_scnlen.l;
3678 if (indx < obj_raw_syment_count (input_bfd))
3682 symindx = finfo->sym_indices[indx];
3684 aux.x_sym.x_tagndx.l = 0;
3686 aux.x_sym.x_tagndx.l = symindx;
3690 else if (isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
3694 if (ISFCN (isymp->n_type)
3695 || ISTAG (isymp->n_sclass)
3696 || isymp->n_sclass == C_BLOCK)
3698 indx = aux.x_sym.x_fcnary.x_fcn.x_endndx.l;
3700 && indx < obj_raw_syment_count (input_bfd))
3702 /* We look forward through the symbol for
3703 the index of the next symbol we are going
3704 to include. I don't know if this is
3706 while (finfo->sym_indices[indx] < 0
3707 && indx < obj_raw_syment_count (input_bfd))
3709 if (indx >= obj_raw_syment_count (input_bfd))
3710 indx = output_index;
3712 indx = finfo->sym_indices[indx];
3713 aux.x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
3717 indx = aux.x_sym.x_tagndx.l;
3718 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
3722 symindx = finfo->sym_indices[indx];
3724 aux.x_sym.x_tagndx.l = 0;
3726 aux.x_sym.x_tagndx.l = symindx;
3730 /* Copy over the line numbers, unless we are stripping
3731 them. We do this on a symbol by symbol basis in
3732 order to more easily handle garbage collection. */
3733 if ((isymp->n_sclass == C_EXT
3734 || isymp->n_sclass == C_HIDEXT)
3736 && isymp->n_numaux > 1
3737 && ISFCN (isymp->n_type)
3738 && aux.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
3740 if (finfo->info->strip != strip_none
3741 && finfo->info->strip != strip_some)
3742 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
3745 asection *enclosing;
3746 bfd_size_type linoff;
3747 struct internal_lineno lin;
3750 enclosing = xcoff_section_data (abfd, o)->enclosing;
3751 linoff = (aux.x_sym.x_fcnary.x_fcn.x_lnnoptr
3752 - enclosing->line_filepos);
3754 if (bfd_seek (input_bfd,
3755 enclosing->line_filepos + linoff,
3757 || (bfd_read (finfo->linenos, linesz,
3758 o->lineno_count, input_bfd)
3759 != linesz * o->lineno_count))
3762 bfd_coff_swap_lineno_in (input_bfd,
3763 (PTR) finfo->linenos,
3766 || ((bfd_size_type) lin.l_addr.l_symndx
3770 obj_coff_external_syms (input_bfd)))
3772 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
3775 bfd_byte *linpend, *linp;
3777 bfd_size_type count;
3779 lin.l_addr.l_symndx = *indexp;
3780 bfd_coff_swap_lineno_out (output_bfd, (PTR) &lin,
3781 (PTR) finfo->linenos);
3783 linpend = (finfo->linenos
3784 + o->lineno_count * linesz);
3785 offset = (o->output_section->vma
3788 for (linp = finfo->linenos + linesz;
3792 bfd_coff_swap_lineno_in (input_bfd, (PTR) linp,
3794 if (lin.l_lnno == 0)
3796 lin.l_addr.l_paddr += offset;
3797 bfd_coff_swap_lineno_out (output_bfd,
3802 count = (linp - finfo->linenos) / linesz;
3804 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr =
3805 (o->output_section->line_filepos
3806 + o->output_section->lineno_count * linesz);
3808 if (bfd_seek (output_bfd,
3809 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr,
3811 || (bfd_write (finfo->linenos, linesz, count,
3816 o->output_section->lineno_count += count;
3821 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, isymp->n_type,
3822 isymp->n_sclass, i, isymp->n_numaux,
3834 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
3835 symbol will be the first symbol in the next input file. In the
3836 normal case, this will save us from writing out the C_FILE symbol
3838 if (finfo->last_file_index != -1
3839 && (bfd_size_type) finfo->last_file_index >= syment_base)
3841 finfo->last_file.n_value = output_index;
3842 bfd_coff_swap_sym_out (output_bfd, (PTR) &finfo->last_file,
3843 (PTR) (finfo->outsyms
3844 + ((finfo->last_file_index - syment_base)
3848 /* Write the modified symbols to the output file. */
3849 if (outsym > finfo->outsyms)
3851 if (bfd_seek (output_bfd,
3852 obj_sym_filepos (output_bfd) + syment_base * osymesz,
3854 || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1,
3856 != (bfd_size_type) (outsym - finfo->outsyms)))
3859 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
3860 + (outsym - finfo->outsyms) / osymesz)
3863 obj_raw_syment_count (output_bfd) = output_index;
3866 /* Don't let the linker relocation routines discard the symbols. */
3867 keep_syms = obj_coff_keep_syms (input_bfd);
3868 obj_coff_keep_syms (input_bfd) = true;
3870 /* Relocate the contents of each section. */
3871 for (o = input_bfd->sections; o != NULL; o = o->next)
3875 if ((o->flags & SEC_HAS_CONTENTS) == 0
3876 || o->_raw_size == 0
3877 || (o->flags & SEC_IN_MEMORY) != 0)
3880 /* We have set filepos correctly for the sections we created to
3881 represent csects, so bfd_get_section_contents should work. */
3882 if (coff_section_data (input_bfd, o) != NULL
3883 && coff_section_data (input_bfd, o)->contents != NULL)
3884 contents = coff_section_data (input_bfd, o)->contents;
3887 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
3888 (file_ptr) 0, o->_raw_size))
3890 contents = finfo->contents;
3893 if ((o->flags & SEC_RELOC) != 0)
3896 struct internal_reloc *internal_relocs;
3897 struct internal_reloc *irel;
3899 struct internal_reloc *irelend;
3900 struct xcoff_link_hash_entry **rel_hash;
3903 /* Read in the relocs. */
3904 target_index = o->output_section->target_index;
3905 internal_relocs = (xcoff_read_internal_relocs
3906 (input_bfd, o, false, finfo->external_relocs,
3908 (finfo->section_info[target_index].relocs
3909 + o->output_section->reloc_count)));
3910 if (internal_relocs == NULL)
3913 /* Call processor specific code to relocate the section
3915 if (! bfd_coff_relocate_section (output_bfd, finfo->info,
3919 finfo->internal_syms,
3920 xcoff_data (input_bfd)->csects))
3923 offset = o->output_section->vma + o->output_offset - o->vma;
3924 irel = internal_relocs;
3925 irelend = irel + o->reloc_count;
3926 rel_hash = (finfo->section_info[target_index].rel_hashes
3927 + o->output_section->reloc_count);
3928 for (; irel < irelend; irel++, rel_hash++)
3930 struct xcoff_link_hash_entry *h = NULL;
3931 struct internal_ldrel ldrel;
3935 /* Adjust the reloc address and symbol index. */
3937 irel->r_vaddr += offset;
3939 r_symndx = irel->r_symndx;
3943 h = obj_xcoff_sym_hashes (input_bfd)[r_symndx];
3946 /* This is a global symbol. */
3948 irel->r_symndx = h->indx;
3951 /* This symbol is being written at the end
3952 of the file, and we do not yet know the
3953 symbol index. We save the pointer to the
3954 hash table entry in the rel_hash list.
3955 We set the indx field to -2 to indicate
3956 that this symbol must not be stripped. */
3965 indx = finfo->sym_indices[r_symndx];
3969 struct internal_syment *is;
3971 /* Relocations against a TC0 TOC anchor are
3972 automatically transformed to be against
3973 the TOC anchor in the output file. */
3974 is = finfo->internal_syms + r_symndx;
3975 if (is->n_sclass == C_HIDEXT
3976 && is->n_numaux > 0)
3979 union internal_auxent aux;
3983 obj_coff_external_syms (input_bfd))
3984 + ((r_symndx + is->n_numaux)
3986 bfd_coff_swap_aux_in (input_bfd, auxptr,
3987 is->n_type, is->n_sclass,
3991 if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_SD
3992 && aux.x_csect.x_smclas == XMC_TC0)
3993 indx = finfo->toc_symindx;
3998 irel->r_symndx = indx;
4001 struct internal_syment *is;
4003 char buf[SYMNMLEN + 1];
4005 /* This reloc is against a symbol we are
4006 stripping. It would be possible to handle
4007 this case, but I don't think it's worth it. */
4008 is = finfo->internal_syms + r_symndx;
4010 name = (_bfd_coff_internal_syment_name
4011 (input_bfd, is, buf));
4015 if (! ((*finfo->info->callbacks->unattached_reloc)
4016 (finfo->info, name, input_bfd, o,
4023 switch (irel->r_type)
4031 /* This reloc needs to be copied into the .loader
4033 ldrel.l_vaddr = irel->r_vaddr;
4035 ldrel.l_symndx = -1;
4040 sec = xcoff_data (input_bfd)->csects[r_symndx];
4041 if ((sec->flags & SEC_CODE) != 0)
4043 else if ((sec->flags & SEC_HAS_CONTENTS) != 0)
4048 else if (h->root.type == bfd_link_hash_defined
4049 || h->root.type == bfd_link_hash_defweak)
4053 sec = h->root.u.def.section->output_section;
4054 if ((sec->flags & SEC_CODE) != 0)
4056 else if ((sec->flags & SEC_HAS_CONTENTS) != 0)
4065 (*_bfd_error_handler)
4066 ("%s: `%s' in loader reloc but not loader sym",
4067 bfd_get_filename (input_bfd),
4068 h->root.root.string);
4069 bfd_set_error (bfd_error_bad_value);
4072 ldrel.l_symndx = h->ldindx;
4074 ldrel.l_rtype = (irel->r_size << 8) | irel->r_type;
4075 ldrel.l_rsecnm = o->output_section->target_index;
4076 if (xcoff_hash_table (finfo->info)->textro
4077 && (o->output_section->flags & SEC_CODE) != 0)
4079 (*_bfd_error_handler)
4080 ("%s: loader reloc in read-only section %s",
4081 bfd_get_filename (input_bfd),
4082 bfd_get_section_name (finfo->output_bfd,
4083 o->output_section));
4084 bfd_set_error (bfd_error_invalid_operation);
4087 xcoff_swap_ldrel_out (output_bfd, &ldrel,
4089 BFD_ASSERT (sizeof (struct external_ldrel) == LDRELSZ);
4094 o->output_section->reloc_count += o->reloc_count;
4097 /* Write out the modified section contents. */
4098 if (! bfd_set_section_contents (output_bfd, o->output_section,
4099 contents, o->output_offset,
4100 (o->_cooked_size != 0
4106 obj_coff_keep_syms (input_bfd) = keep_syms;
4108 if (! finfo->info->keep_memory)
4110 if (! _bfd_coff_free_symbols (input_bfd))
4120 /* Write out a non-XCOFF global symbol. */
4123 xcoff_write_global_symbol (h, p)
4124 struct xcoff_link_hash_entry *h;
4127 struct xcoff_final_link_info *finfo = (struct xcoff_final_link_info *) p;
4130 struct internal_syment isym;
4131 union internal_auxent aux;
4133 output_bfd = finfo->output_bfd;
4135 /* If this symbol was garbage collected, just skip it. */
4136 if (xcoff_hash_table (finfo->info)->gc
4137 && (h->flags & XCOFF_MARK) == 0)
4140 /* If we need a .loader section entry, write it out. */
4141 if (h->ldsym != NULL)
4143 struct internal_ldsym *ldsym;
4148 if (h->root.type == bfd_link_hash_undefined
4149 || h->root.type == bfd_link_hash_undefweak)
4152 ldsym->l_scnum = N_UNDEF;
4153 ldsym->l_smtype = XTY_ER;
4154 impbfd = h->root.u.undef.abfd;
4156 else if (h->root.type == bfd_link_hash_defined
4157 || h->root.type == bfd_link_hash_defweak)
4161 sec = h->root.u.def.section;
4162 ldsym->l_value = (sec->output_section->vma
4163 + sec->output_offset
4164 + h->root.u.def.value);
4165 ldsym->l_scnum = sec->output_section->target_index;
4166 ldsym->l_smtype = XTY_SD;
4167 impbfd = sec->owner;
4172 if (((h->flags & XCOFF_DEF_REGULAR) == 0
4173 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
4174 || (h->flags & XCOFF_IMPORT) != 0)
4175 ldsym->l_smtype |= L_IMPORT;
4176 if (((h->flags & XCOFF_DEF_REGULAR) != 0
4177 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
4178 || (h->flags & XCOFF_EXPORT) != 0)
4179 ldsym->l_smtype |= L_EXPORT;
4180 if ((h->flags & XCOFF_ENTRY) != 0)
4181 ldsym->l_smtype |= L_ENTRY;
4183 ldsym->l_smclas = h->smclas;
4185 if (ldsym->l_ifile == (bfd_size_type) -1)
4187 else if (ldsym->l_ifile == 0)
4189 if ((ldsym->l_smtype & L_IMPORT) == 0)
4191 else if (impbfd == NULL)
4195 BFD_ASSERT (impbfd->xvec == output_bfd->xvec);
4196 ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
4202 BFD_ASSERT (h->ldindx >= 0);
4203 BFD_ASSERT (LDSYMSZ == sizeof (struct external_ldsym));
4204 xcoff_swap_ldsym_out (output_bfd, ldsym, finfo->ldsym + h->ldindx - 3);
4208 /* If this symbol needs global linkage code, write it out. */
4209 if (h->root.type == bfd_link_hash_defined
4210 && (h->root.u.def.section
4211 == xcoff_hash_table (finfo->info)->linkage_section))
4217 p = h->root.u.def.section->contents + h->root.u.def.value;
4219 /* The first instruction in the global linkage code loads a
4220 specific TOC element. */
4221 tocoff = (h->descriptor->toc_section->output_section->vma
4222 + h->descriptor->toc_section->output_offset
4223 + h->descriptor->toc_offset
4224 - xcoff_data (output_bfd)->toc);
4225 bfd_put_32 (output_bfd, XCOFF_GLINK_FIRST | tocoff, p);
4227 i < sizeof xcoff_glink_code / sizeof xcoff_glink_code[0];
4229 bfd_put_32 (output_bfd, xcoff_glink_code[i], p);
4232 /* If we created a TOC entry for this symbol, write out the required
4234 if ((h->flags & XCOFF_SET_TOC) != 0)
4239 struct internal_reloc *irel;
4240 struct internal_ldrel ldrel;
4242 tocsec = h->toc_section;
4243 osec = tocsec->output_section;
4244 oindx = osec->target_index;
4245 irel = finfo->section_info[oindx].relocs + osec->reloc_count;
4246 irel->r_vaddr = (osec->vma
4247 + tocsec->output_offset
4250 irel->r_symndx = h->indx;
4254 irel->r_symndx = obj_raw_syment_count (output_bfd);
4256 irel->r_type = R_POS;
4258 finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
4259 ++osec->reloc_count;
4261 BFD_ASSERT (h->ldindx >= 0);
4262 ldrel.l_vaddr = irel->r_vaddr;
4263 ldrel.l_symndx = h->ldindx;
4264 ldrel.l_rtype = (31 << 8) | R_POS;
4265 ldrel.l_rsecnm = oindx;
4266 xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
4274 && (finfo->info->strip == strip_all
4275 || (finfo->info->strip == strip_some
4276 && (bfd_hash_lookup (finfo->info->keep_hash,
4277 h->root.root.string, false, false)
4282 && (h->flags & (XCOFF_REF_REGULAR | XCOFF_DEF_REGULAR)) == 0)
4285 outsym = finfo->outsyms;
4287 memset (&aux, 0, sizeof aux);
4289 h->indx = obj_raw_syment_count (output_bfd);
4291 if (strlen (h->root.root.string) <= SYMNMLEN)
4292 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
4299 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
4301 indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
4303 if (indx == (bfd_size_type) -1)
4305 isym._n._n_n._n_zeroes = 0;
4306 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
4309 if (h->root.type == bfd_link_hash_undefined
4310 || h->root.type == bfd_link_hash_undefweak)
4313 isym.n_scnum = N_UNDEF;
4314 isym.n_sclass = C_EXT;
4315 aux.x_csect.x_smtyp = XTY_ER;
4317 else if (h->root.type == bfd_link_hash_defined
4318 || h->root.type == bfd_link_hash_defweak)
4320 isym.n_value = (h->root.u.def.section->output_section->vma
4321 + h->root.u.def.section->output_offset
4322 + h->root.u.def.value);
4323 isym.n_scnum = h->root.u.def.section->output_section->target_index;
4324 isym.n_sclass = C_HIDEXT;
4325 aux.x_csect.x_smtyp = XTY_SD;
4326 /* I don't know what the csect length should be in this case. */
4331 isym.n_type = T_NULL;
4334 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
4335 outsym += bfd_coff_symesz (output_bfd);
4337 aux.x_csect.x_smclas = h->smclas;
4339 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, isym.n_sclass, 0, 1,
4341 outsym += bfd_coff_auxesz (output_bfd);
4343 if (h->root.type == bfd_link_hash_defined
4344 || h->root.type == bfd_link_hash_defweak)
4346 /* We just output an SD symbol. Now output an LD symbol. */
4350 isym.n_sclass = C_EXT;
4351 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
4352 outsym += bfd_coff_symesz (output_bfd);
4354 aux.x_csect.x_smtyp = XTY_LD;
4355 aux.x_csect.x_scnlen.l = obj_raw_syment_count (output_bfd);
4357 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, C_EXT, 0, 1,
4359 outsym += bfd_coff_auxesz (output_bfd);
4362 if (bfd_seek (output_bfd,
4363 (obj_sym_filepos (output_bfd)
4364 + (obj_raw_syment_count (output_bfd)
4365 * bfd_coff_symesz (output_bfd))),
4367 || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1, output_bfd)
4368 != (bfd_size_type) (outsym - finfo->outsyms)))
4370 obj_raw_syment_count (output_bfd) +=
4371 (outsym - finfo->outsyms) / bfd_coff_symesz (output_bfd);
4376 /* Handle a link order which is supposed to generate a reloc. */
4379 xcoff_reloc_link_order (output_bfd, finfo, output_section, link_order)
4381 struct xcoff_final_link_info *finfo;
4382 asection *output_section;
4383 struct bfd_link_order *link_order;
4385 reloc_howto_type *howto;
4386 struct internal_reloc *irel;
4387 struct xcoff_link_hash_entry **rel_hash_ptr;
4389 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
4392 bfd_set_error (bfd_error_bad_value);
4396 if (link_order->u.reloc.p->addend != 0)
4400 bfd_reloc_status_type rstat;
4403 size = bfd_get_reloc_size (howto);
4404 buf = (bfd_byte *) bfd_zmalloc (size);
4407 bfd_set_error (bfd_error_no_memory);
4411 rstat = _bfd_relocate_contents (howto, output_bfd,
4412 link_order->u.reloc.p->addend, buf);
4418 case bfd_reloc_outofrange:
4420 case bfd_reloc_overflow:
4421 if (! ((*finfo->info->callbacks->reloc_overflow)
4423 (link_order->type == bfd_section_reloc_link_order
4424 ? bfd_section_name (output_bfd,
4425 link_order->u.reloc.p->u.section)
4426 : link_order->u.reloc.p->u.name),
4427 howto->name, link_order->u.reloc.p->addend,
4428 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
4435 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
4436 (file_ptr) link_order->offset, size);
4442 /* Store the reloc information in the right place. It will get
4443 swapped and written out at the end of the final_link routine. */
4445 irel = (finfo->section_info[output_section->target_index].relocs
4446 + output_section->reloc_count);
4447 rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
4448 + output_section->reloc_count);
4450 memset (irel, 0, sizeof (struct internal_reloc));
4451 *rel_hash_ptr = NULL;
4453 irel->r_vaddr = output_section->vma + link_order->offset;
4455 if (link_order->type == bfd_section_reloc_link_order)
4457 /* We need to somehow locate a symbol in the right section. The
4458 symbol must either have a value of zero, or we must adjust
4459 the addend by the value of the symbol. FIXME: Write this
4460 when we need it. The old linker couldn't handle this anyhow. */
4462 *rel_hash_ptr = NULL;
4467 struct xcoff_link_hash_entry *h;
4469 h = xcoff_link_hash_lookup (xcoff_hash_table (finfo->info),
4470 link_order->u.reloc.p->u.name,
4471 false, false, true);
4475 irel->r_symndx = h->indx;
4478 /* Set the index to -2 to force this symbol to get
4487 if (! ((*finfo->info->callbacks->unattached_reloc)
4488 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
4489 (asection *) NULL, (bfd_vma) 0)))
4495 irel->r_type = howto->type;
4496 irel->r_size = howto->bitsize - 1;
4497 if (howto->complain_on_overflow == complain_overflow_signed)
4498 irel->r_size |= 0x80;
4500 ++output_section->reloc_count;
4505 /* Sort relocs by VMA. This is called via qsort. */
4508 xcoff_sort_relocs (p1, p2)
4512 const struct internal_reloc *r1 = (const struct internal_reloc *) p1;
4513 const struct internal_reloc *r2 = (const struct internal_reloc *) p2;
4515 if (r1->r_vaddr > r2->r_vaddr)
4517 else if (r1->r_vaddr < r2->r_vaddr)
4523 /* This is the relocation function for the RS/6000/POWER/PowerPC.
4524 This is currently the only processor which uses XCOFF; I hope that
4525 will never change. */
4528 _bfd_ppc_xcoff_relocate_section (output_bfd, info, input_bfd,
4529 input_section, contents, relocs, syms,
4532 struct bfd_link_info *info;
4534 asection *input_section;
4536 struct internal_reloc *relocs;
4537 struct internal_syment *syms;
4538 asection **sections;
4540 struct internal_reloc *rel;
4541 struct internal_reloc *relend;
4544 relend = rel + input_section->reloc_count;
4545 for (; rel < relend; rel++)
4548 struct xcoff_link_hash_entry *h;
4549 struct internal_syment *sym;
4552 struct reloc_howto_struct howto;
4553 bfd_reloc_status_type rstat;
4555 /* Relocation type R_REF is a special relocation type which is
4556 merely used to prevent garbage collection from occurring for
4557 the csect including the symbol which it references. */
4558 if (rel->r_type == R_REF)
4561 symndx = rel->r_symndx;
4571 h = obj_xcoff_sym_hashes (input_bfd)[symndx];
4572 sym = syms + symndx;
4573 addend = - sym->n_value;
4576 /* We build the howto information on the fly. */
4578 howto.type = rel->r_type;
4579 howto.rightshift = 0;
4581 howto.bitsize = (rel->r_size & 0x1f) + 1;
4582 howto.pc_relative = false;
4584 if ((rel->r_size & 0x80) != 0)
4585 howto.complain_on_overflow = complain_overflow_signed;
4587 howto.complain_on_overflow = complain_overflow_bitfield;
4588 howto.special_function = NULL;
4589 howto.name = "internal";
4590 howto.partial_inplace = true;
4591 if (howto.bitsize == 32)
4592 howto.src_mask = howto.dst_mask = 0xffffffff;
4595 howto.src_mask = howto.dst_mask = (1 << howto.bitsize) - 1;
4596 if (howto.bitsize == 16)
4599 howto.pcrel_offset = false;
4609 sec = bfd_abs_section_ptr;
4614 sec = sections[symndx];
4615 val = (sec->output_section->vma
4616 + sec->output_offset
4623 if (h->root.type == bfd_link_hash_defined
4624 || h->root.type == bfd_link_hash_defweak)
4628 sec = h->root.u.def.section;
4629 val = (h->root.u.def.value
4630 + sec->output_section->vma
4631 + sec->output_offset);
4633 else if ((h->flags & XCOFF_REF_DYNAMIC) != 0
4634 || (h->flags & XCOFF_IMPORT) != 0)
4636 /* Every symbol in a shared object is defined somewhere. */
4639 else if (! info->relocateable)
4641 if (! ((*info->callbacks->undefined_symbol)
4642 (info, h->root.root.string, input_bfd, input_section,
4643 rel->r_vaddr - input_section->vma)))
4648 /* I took the relocation type definitions from two documents:
4649 the PowerPC AIX Version 4 Application Binary Interface, First
4650 Edition (April 1992), and the PowerOpen ABI, Big-Endian
4651 32-Bit Hardware Implementation (June 30, 1994). Differences
4652 between the documents are noted below. */
4654 switch (rel->r_type)
4659 /* These relocs are defined by the PowerPC ABI to be
4660 relative branches which use half of the difference
4661 between the symbol and the program counter. I can't
4662 quite figure out when this is useful. These relocs are
4663 not defined by the PowerOpen ABI. */
4665 (*_bfd_error_handler)
4666 ("%s: unsupported relocation type 0x%02x",
4667 bfd_get_filename (input_bfd), (unsigned int) rel->r_type);
4668 bfd_set_error (bfd_error_bad_value);
4671 /* Simple positive relocation. */
4674 /* Simple negative relocation. */
4678 /* Simple PC relative relocation. */
4679 howto.pc_relative = true;
4682 /* TOC relative relocation. The value in the instruction in
4683 the input file is the offset from the input file TOC to
4684 the desired location. We want the offset from the final
4685 TOC to the desired location. We have:
4690 so we must change insn by on - in.
4693 /* Global linkage relocation. The value of this relocation
4694 is the address of the entry in the TOC section. */
4696 /* Local object TOC address. I can't figure out the
4697 difference between this and case R_GL. */
4699 /* TOC relative relocation. A TOC relative load instruction
4700 which may be changed to a load address instruction.
4701 FIXME: We don't currently implement this optimization. */
4703 /* TOC relative relocation. This is a TOC relative load
4704 address instruction which may be changed to a load
4705 instruction. FIXME: I don't know if this is the correct
4707 if (h != NULL && h->toc_section == NULL)
4709 (*_bfd_error_handler)
4710 ("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry",
4711 bfd_get_filename (input_bfd), rel->r_vaddr,
4712 h->root.root.string);
4713 bfd_set_error (bfd_error_bad_value);
4717 val = (h->toc_section->output_section->vma
4718 + h->toc_section->output_offset
4720 val = ((val - xcoff_data (output_bfd)->toc)
4721 - (sym->n_value - xcoff_data (input_bfd)->toc));
4725 /* Absolute branch. We don't want to mess with the lower
4726 two bits of the instruction. */
4728 /* The PowerPC ABI defines this as an absolute call which
4729 may be modified to become a relative call. The PowerOpen
4730 ABI does not define this relocation type. */
4732 /* Absolute branch which may be modified to become a
4735 /* The PowerPC ABI defines this as an absolute branch to a
4736 fixed address which may be modified to an absolute branch
4737 to a symbol. The PowerOpen ABI does not define this
4740 /* The PowerPC ABI defines this as an absolute branch to a
4741 fixed address which may be modified to a relative branch.
4742 The PowerOpen ABI does not define this relocation type. */
4743 howto.src_mask &= ~3;
4744 howto.dst_mask = howto.src_mask;
4747 /* Relative branch. We don't want to mess with the lower
4748 two bits of the instruction. */
4750 /* The PowerPC ABI defines this as a relative call which may
4751 be modified to become an absolute call. The PowerOpen
4752 ABI does not define this relocation type. */
4754 /* A relative branch which may be modified to become an
4755 absolute branch. FIXME: We don't implement this,
4756 although we should for symbols of storage mapping class
4758 howto.pc_relative = true;
4759 howto.src_mask &= ~3;
4760 howto.dst_mask = howto.src_mask;
4763 /* The PowerPC AIX ABI describes this as a load which may be
4764 changed to a load address. The PowerOpen ABI says this
4765 is the same as case R_POS. */
4768 /* The PowerPC AIX ABI describes this as a load address
4769 which may be changed to a load. The PowerOpen ABI says
4770 this is the same as R_POS. */
4774 /* If we see an R_BR or R_RBR reloc which is jumping to global
4775 linkage code, and it is followed by an appropriate cror nop
4776 instruction, we replace the cror with lwz r2,20(r1). This
4777 restores the TOC after the glink code. Contrariwise, if the
4778 call is followed by a lwz r2,20(r1), but the call is not
4779 going to global linkage code, we can replace the load with a
4781 if ((rel->r_type == R_BR || rel->r_type == R_RBR)
4783 && h->root.type == bfd_link_hash_defined
4784 && (rel->r_vaddr - input_section->vma + 8
4785 <= input_section->_cooked_size))
4790 pnext = contents + (rel->r_vaddr - input_section->vma) + 4;
4791 next = bfd_get_32 (input_bfd, pnext);
4792 if (h->smclas == XMC_GL)
4794 if (next == 0x4def7b82 /* cror 15,15,15 */
4795 || next == 0x4ffffb82) /* cror 31,31,31 */
4796 bfd_put_32 (input_bfd, 0x80410014, pnext); /* lwz r1,20(r1) */
4800 if (next == 0x80410014) /* lwz r1,20(r1) */
4801 bfd_put_32 (input_bfd, 0x4ffffb82, pnext); /* cror 31,31,31 */
4805 /* A PC relative reloc includes the section address. */
4806 if (howto.pc_relative)
4807 addend += input_section->vma;
4809 rstat = _bfd_final_link_relocate (&howto, input_bfd, input_section,
4811 rel->r_vaddr - input_section->vma,
4820 case bfd_reloc_overflow:
4823 char buf[SYMNMLEN + 1];
4824 char howto_name[10];
4829 name = h->root.root.string;
4832 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
4836 sprintf (howto_name, "0x%02x", rel->r_type);
4838 if (! ((*info->callbacks->reloc_overflow)
4839 (info, name, howto_name, (bfd_vma) 0, input_bfd,
4840 input_section, rel->r_vaddr - input_section->vma)))