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;
1065 /* The setting of line_filepos will only be
1066 useful if all the line number entries for a
1067 csect are contiguous; this only matters for
1069 if (csect->line_filepos == 0)
1070 csect->line_filepos =
1071 auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr;
1077 /* Pick up the csect auxiliary information. */
1079 if (sym.n_numaux == 0)
1081 (*_bfd_error_handler)
1082 ("%s: class %d symbol `%s' has no aux entries",
1083 bfd_get_filename (abfd), sym.n_sclass, name);
1084 bfd_set_error (bfd_error_bad_value);
1088 bfd_coff_swap_aux_in (abfd,
1089 (PTR) (esym + symesz * sym.n_numaux),
1090 sym.n_type, sym.n_sclass,
1091 sym.n_numaux - 1, sym.n_numaux,
1094 smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
1104 (*_bfd_error_handler)
1105 ("%s: symbol `%s' has unrecognized csect type %d",
1106 bfd_get_filename (abfd), name, smtyp);
1107 bfd_set_error (bfd_error_bad_value);
1111 /* This is an external reference. */
1112 if (sym.n_sclass == C_HIDEXT
1113 || sym.n_scnum != N_UNDEF
1114 || aux.x_csect.x_scnlen.l != 0)
1116 (*_bfd_error_handler)
1117 ("%s: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d",
1118 bfd_get_filename (abfd), name, sym.n_sclass, sym.n_scnum,
1119 aux.x_csect.x_scnlen.l);
1120 bfd_set_error (bfd_error_bad_value);
1123 section = bfd_und_section_ptr;
1127 /* This is a csect definition. */
1131 xcoff_section_data (abfd, csect)->last_symndx =
1133 - (bfd_byte *) obj_coff_external_syms (abfd))
1140 /* When we see a TOC anchor, we record the TOC value. */
1141 if (aux.x_csect.x_smclas == XMC_TC0)
1143 if (sym.n_sclass != C_HIDEXT
1144 || aux.x_csect.x_scnlen.l != 0)
1146 (*_bfd_error_handler)
1147 ("%s: XMC_TC0 symbol `%s' is class %d scnlen %d",
1148 bfd_get_filename (abfd), name, sym.n_sclass,
1149 aux.x_csect.x_scnlen.l);
1150 bfd_set_error (bfd_error_bad_value);
1153 xcoff_data (abfd)->toc = sym.n_value;
1156 /* We must merge TOC entries for the same symbol. We can
1157 merge two TOC entries if they are both C_HIDEXT, they
1158 both have the same name, they are both 4 bytes long, and
1159 they both have a relocation table entry for an external
1160 symbol with the same name. Unfortunately, this means
1161 that we must look through the relocations. Ick. */
1162 if (aux.x_csect.x_smclas == XMC_TC
1163 && sym.n_sclass == C_HIDEXT
1164 && aux.x_csect.x_scnlen.l == 4
1165 && info->hash->creator == abfd->xvec)
1167 asection *enclosing;
1168 bfd_size_type relindx;
1169 struct internal_reloc *rel;
1170 asection **rel_csect;
1172 enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1173 if (enclosing == NULL)
1176 /* XCOFF requires that relocs be sorted by address, so
1177 we could do a binary search here. FIXME. */
1178 rel = reloc_info[enclosing->target_index].relocs;
1179 rel_csect = reloc_info[enclosing->target_index].csects;
1181 relindx < enclosing->reloc_count;
1182 relindx++, rel++, rel_csect++)
1184 if (*rel_csect == NULL
1185 && rel->r_vaddr == (bfd_vma) sym.n_value
1186 && rel->r_size == 31
1187 && rel->r_type == R_POS)
1190 if (relindx < enclosing->reloc_count)
1193 struct internal_syment relsym;
1195 erelsym = ((bfd_byte *) obj_coff_external_syms (abfd)
1196 + rel->r_symndx * symesz);
1197 bfd_coff_swap_sym_in (abfd, (PTR) erelsym, (PTR) &relsym);
1198 if (relsym.n_sclass == C_EXT)
1200 const char *relname;
1201 char relbuf[SYMNMLEN + 1];
1203 struct xcoff_link_hash_entry *h;
1205 /* At this point we know that the TOC entry is
1206 for an externally visible symbol. */
1207 relname = _bfd_coff_internal_syment_name (abfd, &relsym,
1209 if (relname == NULL)
1211 copy = (! info->keep_memory
1212 || relsym._n._n_n._n_zeroes != 0
1213 || relsym._n._n_n._n_offset == 0);
1214 h = xcoff_link_hash_lookup (xcoff_hash_table (info),
1215 relname, true, copy, false);
1219 /* At this point h->root.type could be
1220 bfd_link_hash_new. That should be OK, since
1221 we know for sure that we will come across
1222 this symbol as we step through the file. */
1224 /* We store h in *sym_hash for the convenience
1225 of the relocate_section function. */
1228 if (h->toc_section != NULL)
1230 /* We already have a TOC entry for this
1231 symbol, so we can just ignore this one. */
1232 *rel_csect = bfd_und_section_ptr;
1236 /* We are about to create a TOC entry for this
1243 /* We need to create a new section. We get the name from
1244 the csect storage mapping class, so that the linker can
1245 accumulate similar csects together. */
1247 static const char *csect_name_by_class[] =
1249 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
1250 ".sv", ".bs", ".ds", ".uc", ".ti", ".tb", NULL, ".tc0",
1253 const char *csect_name;
1254 asection *enclosing;
1255 struct internal_reloc *rel;
1256 bfd_size_type relindx;
1257 asection **rel_csect;
1259 if ((aux.x_csect.x_smclas >=
1260 sizeof csect_name_by_class / sizeof csect_name_by_class[0])
1261 || csect_name_by_class[aux.x_csect.x_smclas] == NULL)
1263 (*_bfd_error_handler)
1264 ("%s: symbol `%s' has unrecognized smclas %d",
1265 bfd_get_filename (abfd), name, aux.x_csect.x_smclas);
1266 bfd_set_error (bfd_error_bad_value);
1270 csect_name = csect_name_by_class[aux.x_csect.x_smclas];
1271 csect = bfd_make_section_anyway (abfd, csect_name);
1274 enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1275 if (enclosing == NULL)
1277 if ((bfd_vma) sym.n_value < enclosing->vma
1278 || ((bfd_vma) sym.n_value + aux.x_csect.x_scnlen.l
1279 > enclosing->vma + enclosing->_raw_size))
1281 (*_bfd_error_handler)
1282 ("%s: csect `%s' not in enclosing section",
1283 bfd_get_filename (abfd), name);
1284 bfd_set_error (bfd_error_bad_value);
1287 csect->vma = sym.n_value;
1288 csect->filepos = (enclosing->filepos
1291 csect->_raw_size = aux.x_csect.x_scnlen.l;
1292 csect->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
1293 csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
1295 /* Record the enclosing section in the tdata for this new
1297 csect->used_by_bfd =
1298 ((struct coff_section_tdata *)
1299 bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
1300 if (csect->used_by_bfd == NULL)
1302 bfd_set_error (bfd_error_no_memory);
1305 coff_section_data (abfd, csect)->tdata =
1306 bfd_zalloc (abfd, sizeof (struct xcoff_section_tdata));
1307 if (coff_section_data (abfd, csect)->tdata == NULL)
1309 bfd_set_error (bfd_error_no_memory);
1312 xcoff_section_data (abfd, csect)->enclosing = enclosing;
1314 /* XCOFF requires that relocs be sorted by address, so we
1315 could do a binary search here. FIXME. (XCOFF
1316 unfortunately does not require that symbols be sorted
1317 by address, or this would be a simple merge). */
1318 rel = reloc_info[enclosing->target_index].relocs;
1319 rel_csect = reloc_info[enclosing->target_index].csects;
1321 relindx < enclosing->reloc_count;
1322 relindx++, rel++, rel_csect++)
1324 if (*rel_csect == NULL
1325 && rel->r_vaddr >= csect->vma
1326 && rel->r_vaddr < csect->vma + csect->_raw_size)
1328 csect->rel_filepos = (enclosing->rel_filepos
1329 + relindx * bfd_coff_relsz (abfd));
1333 while (relindx < enclosing->reloc_count
1334 && *rel_csect == NULL
1335 && rel->r_vaddr >= csect->vma
1336 && rel->r_vaddr < csect->vma + csect->_raw_size)
1339 csect->flags |= SEC_RELOC;
1340 ++csect->reloc_count;
1346 /* There are a number of other fields and section flags
1347 which we do not bother to set. */
1349 csect_index = ((esym
1350 - (bfd_byte *) obj_coff_external_syms (abfd))
1353 xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1355 if (first_csect == NULL)
1356 first_csect = csect;
1358 /* If this symbol is C_EXT, we treat it as starting at the
1359 beginning of the newly created section. */
1360 if (sym.n_sclass == C_EXT)
1366 /* If this is a TOC section for a symbol, record it. */
1367 if (set_toc != NULL)
1369 set_toc->toc_section = csect;
1370 set_toc->toc_offset = 0;
1376 /* This is a label definition. The x_scnlen field is the
1377 symbol index of the csect. I believe that this must
1378 always follow the appropriate XTY_SD symbol, so I will
1384 if (aux.x_csect.x_scnlen.l < 0
1385 || (aux.x_csect.x_scnlen.l
1386 >= esym - (bfd_byte *) obj_coff_external_syms (abfd)))
1390 section = xcoff_data (abfd)->csects[aux.x_csect.x_scnlen.l];
1392 || (section->flags & SEC_HAS_CONTENTS) == 0)
1397 (*_bfd_error_handler)
1398 ("%s: misplaced XTY_LD `%s'",
1399 bfd_get_filename (abfd), name);
1400 bfd_set_error (bfd_error_bad_value);
1404 value = sym.n_value - csect->vma;
1409 /* This is an unitialized csect. We could base the name on
1410 the storage mapping class, but we don't bother. If this
1411 csect is externally visible, it is a common symbol. */
1415 xcoff_section_data (abfd, csect)->last_symndx =
1417 - (bfd_byte *) obj_coff_external_syms (abfd))
1421 csect = bfd_make_section_anyway (abfd, ".bss");
1425 csect->_raw_size = aux.x_csect.x_scnlen.l;
1426 csect->flags |= SEC_ALLOC;
1427 csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
1428 /* There are a number of other fields and section flags
1429 which we do not bother to set. */
1431 csect_index = ((esym
1432 - (bfd_byte *) obj_coff_external_syms (abfd))
1435 csect->used_by_bfd =
1436 ((struct coff_section_tdata *)
1437 bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
1438 if (csect->used_by_bfd == NULL)
1440 bfd_set_error (bfd_error_no_memory);
1443 coff_section_data (abfd, csect)->tdata =
1444 bfd_zalloc (abfd, sizeof (struct xcoff_section_tdata));
1445 if (coff_section_data (abfd, csect)->tdata == NULL)
1447 bfd_set_error (bfd_error_no_memory);
1450 xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1452 if (first_csect == NULL)
1453 first_csect = csect;
1455 if (sym.n_sclass == C_EXT)
1457 csect->flags |= SEC_IS_COMMON;
1459 value = aux.x_csect.x_scnlen.l;
1465 /* Now we have enough information to add the symbol to the
1466 linker hash table. */
1468 if (sym.n_sclass == C_EXT)
1472 BFD_ASSERT (section != NULL);
1474 /* We must copy the name into memory if we got it from the
1475 syment itself, rather than the string table. */
1476 copy = default_copy;
1477 if (sym._n._n_n._n_zeroes != 0
1478 || sym._n._n_n._n_offset == 0)
1481 if (info->hash->creator == abfd->xvec)
1483 /* If we are statically linking a shared object, it is
1484 OK for symbol redefinitions to occur. I can't figure
1485 out just what the XCOFF linker is doing, but
1486 something like this is required for -bnso to work. */
1487 *sym_hash = xcoff_link_hash_lookup (xcoff_hash_table (info),
1488 name, true, copy, false);
1489 if (*sym_hash == NULL)
1491 if (((*sym_hash)->root.type == bfd_link_hash_defined
1492 || (*sym_hash)->root.type == bfd_link_hash_defweak)
1493 && ! bfd_is_und_section (section)
1494 && ! bfd_is_com_section (section))
1496 if ((abfd->flags & DYNAMIC) != 0)
1498 section = bfd_und_section_ptr;
1501 else if (((*sym_hash)->root.u.def.section->owner->flags
1504 (*sym_hash)->root.type = bfd_link_hash_undefined;
1505 (*sym_hash)->root.u.undef.abfd =
1506 (*sym_hash)->root.u.def.section->owner;
1511 if (! (_bfd_generic_link_add_one_symbol
1512 (info, abfd, name, flags, section, value,
1513 (const char *) NULL, copy, false,
1514 (struct bfd_link_hash_entry **) sym_hash)))
1517 if (info->hash->creator == abfd->xvec)
1521 if (smtyp == XTY_ER || smtyp == XTY_CM)
1522 flag = XCOFF_REF_REGULAR;
1524 flag = XCOFF_DEF_REGULAR;
1525 (*sym_hash)->flags |= flag;
1527 if ((*sym_hash)->smclas == XMC_UA)
1528 (*sym_hash)->smclas = aux.x_csect.x_smclas;
1532 *csect_cache = csect;
1534 esym += (sym.n_numaux + 1) * symesz;
1535 sym_hash += sym.n_numaux + 1;
1536 csect_cache += sym.n_numaux + 1;
1539 /* Make sure that we have seen all the relocs. */
1540 for (sub = abfd->sections; sub != first_csect; sub = sub->next)
1542 /* Reset the section size, since the data is now attached to the
1543 csects. Don't reset the size of the .debug section, since we
1544 need to read it below in bfd_xcoff_size_dynamic_sections. */
1545 if (strcmp (bfd_get_section_name (abfd, sub), ".debug") != 0)
1548 if ((sub->flags & SEC_RELOC) != 0)
1551 struct internal_reloc *rel;
1552 asection **rel_csect;
1554 rel = reloc_info[sub->target_index].relocs;
1555 rel_csect = reloc_info[sub->target_index].csects;
1556 for (i = 0; i < sub->reloc_count; i++, rel++, rel_csect++)
1558 if (*rel_csect == NULL)
1560 (*_bfd_error_handler)
1561 ("%s: reloc %s:%d not in csect",
1562 bfd_get_filename (abfd), sub->name, i);
1563 bfd_set_error (bfd_error_bad_value);
1567 /* We need to copy all relocs which are not PC relative
1568 and not TOC relative into the .loader section.
1570 We also identify all symbols which are called, so
1571 that we can create glue code for calls to functions
1572 imported from dynamic objects. */
1574 if (info->hash->creator == abfd->xvec
1575 && *rel_csect != bfd_und_section_ptr)
1577 struct xcoff_link_hash_entry *h;
1579 switch (rel->r_type)
1587 ++xcoff_hash_table (info)->ldrel_count;
1588 ++xcoff_section_data (abfd, *rel_csect)->ldrel_count;
1589 h = obj_xcoff_sym_hashes (abfd)[rel->r_symndx];
1591 h->flags |= XCOFF_LDREL;
1595 h = obj_xcoff_sym_hashes (abfd)[rel->r_symndx];
1598 h->flags |= XCOFF_CALLED;
1599 /* If the symbol name starts with a period,
1600 it is the code of a function. If the
1601 symbol is currently undefined, then add
1602 an undefined symbol for the function
1603 descriptor. This should do no harm,
1604 because any regular object that defines
1605 the function should also define the
1606 function descriptor. It helps, because
1607 it means that we will identify the
1608 function descriptor with a dynamic object
1609 if a dynamic object defines it. */
1610 if (h->root.root.string[0] == '.'
1611 && h->descriptor == NULL)
1613 struct xcoff_link_hash_entry *hds;
1615 hds = (xcoff_link_hash_lookup
1616 (xcoff_hash_table (info),
1617 h->root.root.string + 1, true, false,
1621 if (hds->root.type == bfd_link_hash_new)
1623 if (! (_bfd_generic_link_add_one_symbol
1624 (info, abfd, hds->root.root.string,
1625 (flagword) 0, bfd_und_section_ptr,
1626 (bfd_vma) 0, (const char *) NULL,
1628 ((struct bfd_link_hash_entry **)
1632 h->descriptor = hds;
1640 free (reloc_info[sub->target_index].csects);
1641 reloc_info[sub->target_index].csects = NULL;
1643 /* Reset SEC_RELOC, the reloc_count, and the lineno_count,
1644 since the reloc and lineno information is now attached to
1646 sub->flags &=~ SEC_RELOC;
1647 sub->reloc_count = 0;
1648 sub->lineno_count = 0;
1650 /* If we are not keeping memory, free the reloc information. */
1651 if (! info->keep_memory
1652 && coff_section_data (abfd, sub) != NULL
1653 && coff_section_data (abfd, sub)->relocs != NULL
1654 && ! coff_section_data (abfd, sub)->keep_relocs)
1656 free (coff_section_data (abfd, sub)->relocs);
1657 coff_section_data (abfd, sub)->relocs = NULL;
1661 /* Free up the line numbers. FIXME: We could cache these
1662 somewhere for the final link, to avoid reading them again. */
1663 if (reloc_info[sub->target_index].linenos != NULL)
1665 free (reloc_info[sub->target_index].linenos);
1666 reloc_info[sub->target_index].linenos = NULL;
1672 obj_coff_keep_syms (abfd) = keep_syms;
1677 if (reloc_info != NULL)
1679 for (sub = abfd->sections; sub != NULL; sub = sub->next)
1681 if (reloc_info[sub->target_index].csects != NULL)
1682 free (reloc_info[sub->target_index].csects);
1683 if (reloc_info[sub->target_index].linenos != NULL)
1684 free (reloc_info[sub->target_index].linenos);
1688 obj_coff_keep_syms (abfd) = keep_syms;
1695 /* This function is used to add symbols from a dynamic object to the
1696 global symbol table. */
1699 xcoff_link_add_dynamic_symbols (abfd, info)
1701 struct bfd_link_info *info;
1703 bfd_size_type symesz;
1706 struct xcoff_import_file *n;
1711 struct xcoff_import_file **pp;
1713 /* We can only handle a dynamic object if we are generating an XCOFF
1715 if (info->hash->creator != abfd->xvec)
1717 (*_bfd_error_handler)
1718 ("%s: XCOFF shared object when not producing XCOFF output",
1719 bfd_get_filename (abfd));
1720 bfd_set_error (bfd_error_invalid_operation);
1724 /* Remove the sections from this object, so that they do not get
1725 included in the link. */
1726 abfd->sections = NULL;
1728 symesz = bfd_coff_symesz (abfd);
1729 esym = (bfd_byte *) obj_coff_external_syms (abfd);
1730 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
1731 while (esym < esym_end)
1733 struct internal_syment sym;
1735 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
1737 /* I think that every symbol mentioned in a dynamic object must
1738 be defined by that object, perhaps by importing it from
1739 another dynamic object. All we have to do is look up each
1740 external symbol. If we have already put it in the hash
1741 table, we simply set a flag indicating that it appears in a
1744 if (sym.n_sclass == C_EXT)
1747 char buf[SYMNMLEN + 1];
1748 struct xcoff_link_hash_entry *h;
1750 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
1754 /* Normally we could not xcoff_link_hash_lookup in an add
1755 symbols routine, since we might not be using an XCOFF
1756 hash table. However, we verified above that we are using
1757 an XCOFF hash table. */
1758 h = xcoff_link_hash_lookup (xcoff_hash_table (info), name,
1759 false, false, true);
1762 h->flags |= XCOFF_REF_DYNAMIC;
1764 /* If the symbol is undefined, and the current BFD is
1765 not a dynamic object, change the BFD to this dynamic
1766 object, so that we can get the import file ID
1768 if (h->root.u.undef.abfd == NULL
1769 || (h->root.u.undef.abfd->flags & DYNAMIC) == 0)
1770 h->root.u.undef.abfd = abfd;
1772 if (h->smclas == XMC_UA
1773 && sym.n_numaux > 0)
1775 union internal_auxent aux;
1777 bfd_coff_swap_aux_in (abfd,
1778 (PTR) (esym + symesz * sym.n_numaux),
1779 sym.n_type, sym.n_sclass,
1780 sym.n_numaux - 1, sym.n_numaux,
1782 h->smclas = aux.x_csect.x_smclas;
1787 esym += (sym.n_numaux + 1) * symesz;
1790 /* Record this file in the import files. */
1792 n = ((struct xcoff_import_file *)
1793 bfd_alloc (abfd, sizeof (struct xcoff_import_file)));
1796 bfd_set_error (bfd_error_no_memory);
1801 /* For some reason, the path entry in the import file list for a
1802 shared object appears to always be empty. The file name is the
1805 if (abfd->my_archive == NULL)
1807 bname = bfd_get_filename (abfd);
1812 bname = bfd_get_filename (abfd->my_archive);
1813 mname = bfd_get_filename (abfd);
1815 s = strrchr (bname, '/');
1821 /* We start c at 1 because the first import file number is reserved
1823 for (pp = &xcoff_hash_table (info)->imports, c = 1;
1825 pp = &(*pp)->next, ++c)
1829 xcoff_data (abfd)->import_file_id = c;
1834 /* Routines that are called after all the input files have been
1835 handled, but before the sections are laid out in memory. */
1837 /* Import a symbol. */
1840 bfd_xcoff_import_symbol (output_bfd, info, harg, val, imppath, impfile,
1843 struct bfd_link_info *info;
1844 struct bfd_link_hash_entry *harg;
1846 const char *imppath;
1847 const char *impfile;
1848 const char *impmember;
1850 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
1852 h->flags |= XCOFF_IMPORT;
1854 if (val != (bfd_vma) -1)
1856 if (h->root.type == bfd_link_hash_defined)
1858 if (! ((*info->callbacks->multiple_definition)
1859 (info, h->root.root.string, h->root.u.def.section->owner,
1860 h->root.u.def.section, h->root.u.def.value,
1861 output_bfd, bfd_abs_section_ptr, val)))
1865 h->root.type = bfd_link_hash_defined;
1866 h->root.u.def.section = bfd_abs_section_ptr;
1867 h->root.u.def.value = val;
1870 if (h->ldsym == NULL)
1872 h->ldsym = ((struct internal_ldsym *)
1873 bfd_zalloc (output_bfd, sizeof (struct internal_ldsym)));
1874 if (h->ldsym == NULL)
1876 bfd_set_error (bfd_error_no_memory);
1881 if (imppath == NULL)
1882 h->ldsym->l_ifile = (bfd_size_type) -1;
1886 struct xcoff_import_file **pp;
1888 /* We start c at 1 because the first entry in the import list is
1889 reserved for the library search path. */
1890 for (pp = &xcoff_hash_table (info)->imports, c = 1;
1892 pp = &(*pp)->next, ++c)
1894 if (strcmp ((*pp)->path, imppath) == 0
1895 && strcmp ((*pp)->file, impfile) == 0
1896 && strcmp ((*pp)->member, impmember) == 0)
1902 struct xcoff_import_file *n;
1904 n = ((struct xcoff_import_file *)
1905 bfd_alloc (output_bfd, sizeof (struct xcoff_import_file)));
1908 bfd_set_error (bfd_error_no_memory);
1914 n->member = impmember;
1918 h->ldsym->l_ifile = c;
1924 /* Export a symbol. */
1927 bfd_xcoff_export_symbol (output_bfd, info, harg, syscall)
1929 struct bfd_link_info *info;
1930 struct bfd_link_hash_entry *harg;
1933 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
1935 h->flags |= XCOFF_EXPORT;
1937 /* FIXME: I'm not at all sure what syscall is supposed to mean, so
1938 I'm just going to ignore it until somebody explains it. */
1943 /* This structure is used to pass information through
1944 xcoff_link_hash_traverse. */
1946 struct xcoff_loader_info
1948 /* Set if a problem occurred. */
1952 /* Link information structure. */
1953 struct bfd_link_info *info;
1954 /* Number of ldsym structures. */
1956 /* Size of string table. */
1960 /* Allocated size of string table. */
1964 /* Build the .loader section. This is called by the XCOFF linker
1965 emulation before_allocation routine. We must set the size of the
1966 .loader section before the linker lays out the output file.
1967 LIBPATH is the library path to search for shared objects; this is
1968 normally built from the -L arguments passed to the linker. ENTRY
1969 is the name of the entry point symbol. */
1972 bfd_xcoff_size_dynamic_sections (output_bfd, info, libpath, entry,
1973 file_align, maxstack, maxdata, gc,
1976 struct bfd_link_info *info;
1977 const char *libpath;
1979 unsigned long file_align;
1980 unsigned long maxstack;
1981 unsigned long maxdata;
1986 struct xcoff_link_hash_entry *hentry;
1988 struct xcoff_loader_info ldinfo;
1989 size_t impsize, impcount;
1990 struct xcoff_import_file *fl;
1991 struct internal_ldhdr *ldhdr;
1995 struct bfd_strtab_hash *debug_strtab;
1996 bfd_byte *debug_contents = NULL;
1998 ldinfo.failed = false;
1999 ldinfo.output_bfd = output_bfd;
2001 ldinfo.ldsym_count = 0;
2002 ldinfo.string_size = 0;
2003 ldinfo.strings = NULL;
2004 ldinfo.string_alc = 0;
2006 xcoff_data (output_bfd)->maxstack = maxstack;
2007 xcoff_data (output_bfd)->maxdata = maxdata;
2008 xcoff_data (output_bfd)->modtype = modtype;
2010 xcoff_hash_table (info)->file_align = file_align;
2011 xcoff_hash_table (info)->textro = textro;
2013 hentry = xcoff_link_hash_lookup (xcoff_hash_table (info), entry,
2014 false, false, true);
2016 hentry->flags |= XCOFF_ENTRY;
2018 /* Garbage collect unused sections. */
2019 if (info->relocateable
2022 || (hentry->root.type != bfd_link_hash_defined
2023 && hentry->root.type != bfd_link_hash_defweak))
2026 xcoff_hash_table (info)->gc = false;
2030 if (! xcoff_mark (info, hentry->root.u.def.section))
2033 xcoff_hash_table (info)->gc = true;
2036 if (info->input_bfds == NULL)
2038 /* I'm not sure what to do in this bizarre case. */
2042 xcoff_link_hash_traverse (xcoff_hash_table (info), xcoff_build_ldsyms,
2047 /* Work out the size of the import file names. Each import file ID
2048 consists of three null terminated strings: the path, the file
2049 name, and the archive member name. The first entry in the list
2050 of names is the path to use to find objects, which the linker has
2051 passed in as the libpath argument. For some reason, the path
2052 entry in the other import file names appears to always be empty. */
2053 impsize = strlen (libpath) + 3;
2055 for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
2058 impsize += (strlen (fl->path)
2060 + strlen (fl->member)
2064 /* Set up the .loader section header. */
2065 ldhdr = &xcoff_hash_table (info)->ldhdr;
2066 ldhdr->l_version = 1;
2067 ldhdr->l_nsyms = ldinfo.ldsym_count;
2068 ldhdr->l_nreloc = xcoff_hash_table (info)->ldrel_count;
2069 ldhdr->l_istlen = impsize;
2070 ldhdr->l_nimpid = impcount;
2071 ldhdr->l_impoff = (LDHDRSZ
2072 + ldhdr->l_nsyms * LDSYMSZ
2073 + ldhdr->l_nreloc * LDRELSZ);
2074 ldhdr->l_stlen = ldinfo.string_size;
2075 ldhdr->l_stoff = ldhdr->l_impoff + impsize;
2077 /* We now know the final size of the .loader section. Allocate
2079 lsec = xcoff_hash_table (info)->loader_section;
2080 lsec->_raw_size = ldhdr->l_stoff + ldhdr->l_stlen;
2081 lsec->contents = (bfd_byte *) bfd_zalloc (output_bfd, lsec->_raw_size);
2082 if (lsec->contents == NULL)
2084 bfd_set_error (bfd_error_no_memory);
2088 /* Set up the header. */
2089 xcoff_swap_ldhdr_out (output_bfd, ldhdr,
2090 (struct external_ldhdr *) lsec->contents);
2092 /* Set up the import file names. */
2093 out = (char *) lsec->contents + ldhdr->l_impoff;
2094 strcpy (out, libpath);
2095 out += strlen (libpath) + 1;
2098 for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
2100 register const char *s;
2103 while ((*out++ = *s++) != '\0')
2106 while ((*out++ = *s++) != '\0')
2109 while ((*out++ = *s++) != '\0')
2113 BFD_ASSERT ((bfd_size_type) ((bfd_byte *) out - lsec->contents)
2116 /* Set up the symbol string table. */
2117 if (ldinfo.string_size > 0)
2119 memcpy (out, ldinfo.strings, ldinfo.string_size);
2120 free (ldinfo.strings);
2121 ldinfo.strings = NULL;
2124 /* We can't set up the symbol table or the relocs yet, because we
2125 don't yet know the final position of the various sections. The
2126 .loader symbols are written out when the corresponding normal
2127 symbols are written out in xcoff_link_input_bfd or
2128 xcoff_write_global_symbol. The .loader relocs are written out
2129 when the corresponding normal relocs are handled in
2130 xcoff_link_input_bfd. */
2132 /* Allocate space for the global linkage section and the global toc
2134 sec = xcoff_hash_table (info)->linkage_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);
2144 sec = xcoff_hash_table (info)->toc_section;
2145 if (sec->_raw_size > 0)
2147 sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
2148 if (sec->contents == NULL)
2150 bfd_set_error (bfd_error_no_memory);
2155 /* Now that we've done garbage collection, figure out the contents
2156 of the .debug section. */
2157 debug_strtab = xcoff_hash_table (info)->debug_strtab;
2159 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2162 bfd_size_type symcount;
2163 unsigned long *debug_index;
2165 bfd_byte *esym, *esymend;
2166 bfd_size_type symesz;
2168 if (sub->xvec != info->hash->creator)
2170 subdeb = bfd_get_section_by_name (sub, ".debug");
2171 if (subdeb == NULL || subdeb->_raw_size == 0)
2174 if (info->strip == strip_all
2175 || info->strip == strip_debugger
2176 || info->discard == discard_all)
2178 subdeb->_raw_size = 0;
2182 if (! _bfd_coff_get_external_symbols (sub))
2185 symcount = obj_raw_syment_count (sub);
2186 debug_index = ((unsigned long *)
2187 bfd_zalloc (sub, symcount * sizeof (unsigned long)));
2188 if (debug_index == NULL)
2190 bfd_set_error (bfd_error_no_memory);
2193 xcoff_data (sub)->debug_indices = debug_index;
2195 /* Grab the contents of the .debug section. We use malloc and
2196 copy the neams into the debug stringtab, rather than
2197 bfd_alloc, because I expect that, when linking many files
2198 together, many of the strings will be the same. Storing the
2199 strings in the hash table should save space in this case. */
2200 debug_contents = (bfd_byte *) malloc (subdeb->_raw_size);
2201 if (debug_contents == NULL)
2203 bfd_set_error (bfd_error_no_memory);
2206 if (! bfd_get_section_contents (sub, subdeb, (PTR) debug_contents,
2207 (file_ptr) 0, subdeb->_raw_size))
2210 csectpp = xcoff_data (sub)->csects;
2212 symesz = bfd_coff_symesz (sub);
2213 esym = (bfd_byte *) obj_coff_external_syms (sub);
2214 esymend = esym + symcount * symesz;
2215 while (esym < esymend)
2217 struct internal_syment sym;
2219 bfd_coff_swap_sym_in (sub, (PTR) esym, (PTR) &sym);
2221 *debug_index = (unsigned long) -1;
2223 if (sym._n._n_n._n_zeroes == 0
2226 || ((*csectpp)->flags & SEC_MARK) != 0
2227 || *csectpp == bfd_abs_section_ptr)
2228 && bfd_coff_symname_in_debug (sub, &sym))
2233 name = (char *) debug_contents + sym._n._n_n._n_offset;
2234 indx = _bfd_stringtab_add (debug_strtab, name, true, true);
2235 if (indx == (bfd_size_type) -1)
2237 *debug_index = indx;
2240 esym += (sym.n_numaux + 1) * symesz;
2241 csectpp += sym.n_numaux + 1;
2242 debug_index += sym.n_numaux + 1;
2245 free (debug_contents);
2246 debug_contents = NULL;
2248 /* Clear the size of subdeb, so that it is not included directly
2249 in the output file. */
2250 subdeb->_raw_size = 0;
2252 if (! info->keep_memory)
2254 if (! _bfd_coff_free_symbols (sub))
2259 xcoff_hash_table (info)->debug_section->_raw_size =
2260 _bfd_stringtab_size (debug_strtab);
2265 if (ldinfo.strings != NULL)
2266 free (ldinfo.strings);
2267 if (debug_contents != NULL)
2268 free (debug_contents);
2272 /* The mark phase of garbage collection. For a given section, mark
2273 it, and all the sections which define symbols to which it refers. */
2276 xcoff_mark (info, sec)
2277 struct bfd_link_info *info;
2280 if ((sec->flags & SEC_MARK) != 0)
2283 sec->flags |= SEC_MARK;
2285 if (sec->owner->xvec == info->hash->creator
2286 && coff_section_data (sec->owner, sec) != NULL
2287 && xcoff_section_data (sec->owner, sec) != NULL)
2289 register struct xcoff_link_hash_entry **hp, **hpend;
2290 struct internal_reloc *rel, *relend;
2292 /* Mark all the symbols in this section. */
2294 hp = (obj_xcoff_sym_hashes (sec->owner)
2295 + xcoff_section_data (sec->owner, sec)->first_symndx);
2296 hpend = (obj_xcoff_sym_hashes (sec->owner)
2297 + xcoff_section_data (sec->owner, sec)->last_symndx);
2298 for (; hp < hpend; hp++)
2300 register struct xcoff_link_hash_entry *h;
2304 && (h->flags & XCOFF_MARK) == 0)
2306 h->flags |= XCOFF_MARK;
2307 if (h->root.type == bfd_link_hash_defined
2308 || h->root.type == bfd_link_hash_defweak)
2312 hsec = h->root.u.def.section;
2313 if ((hsec->flags & SEC_MARK) == 0)
2315 if (! xcoff_mark (info, hsec))
2320 if (h->toc_section != NULL
2321 && (h->toc_section->flags & SEC_MARK) == 0)
2323 if (! xcoff_mark (info, h->toc_section))
2329 /* Look through the section relocs. */
2331 rel = xcoff_read_internal_relocs (sec->owner, sec, true,
2332 (bfd_byte *) NULL, false,
2333 (struct internal_reloc *) NULL);
2336 relend = rel + sec->reloc_count;
2337 for (; rel < relend; rel++)
2340 struct xcoff_link_hash_entry *h;
2342 if ((unsigned int) rel->r_symndx
2343 > obj_raw_syment_count (sec->owner))
2346 h = obj_xcoff_sym_hashes (sec->owner)[rel->r_symndx];
2348 && (h->flags & XCOFF_MARK) == 0)
2350 h->flags |= XCOFF_MARK;
2351 if (h->root.type == bfd_link_hash_defined
2352 || h->root.type == bfd_link_hash_defweak)
2356 hsec = h->root.u.def.section;
2357 if ((hsec->flags & SEC_MARK) == 0)
2359 if (! xcoff_mark (info, hsec))
2364 if (h->toc_section != NULL
2365 && (h->toc_section->flags & SEC_MARK) == 0)
2367 if (! xcoff_mark (info, h->toc_section))
2372 rsec = xcoff_data (sec->owner)->csects[rel->r_symndx];
2374 && (rsec->flags & SEC_MARK) == 0)
2376 if (! xcoff_mark (info, rsec))
2381 if (! info->keep_memory
2382 && coff_section_data (sec->owner, sec) != NULL
2383 && coff_section_data (sec->owner, sec)->relocs != NULL
2384 && ! coff_section_data (sec->owner, sec)->keep_relocs)
2386 free (coff_section_data (sec->owner, sec)->relocs);
2387 coff_section_data (sec->owner, sec)->relocs = NULL;
2394 /* The sweep phase of garbage collection. Remove all garbage
2399 struct bfd_link_info *info;
2403 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2407 for (o = sub->sections; o != NULL; o = o->next)
2409 if ((o->flags & SEC_MARK) == 0)
2411 /* Keep all sections from non-XCOFF input files. Keep
2412 special sections. Keep .debug sections for the
2414 if (sub->xvec != info->hash->creator
2415 || o == xcoff_hash_table (info)->debug_section
2416 || o == xcoff_hash_table (info)->loader_section
2417 || o == xcoff_hash_table (info)->linkage_section
2418 || o == xcoff_hash_table (info)->toc_section
2419 || strcmp (o->name, ".debug") == 0)
2420 o->flags |= SEC_MARK;
2425 o->lineno_count = 0;
2426 if (coff_section_data (sub, o) != NULL
2427 && xcoff_section_data (sub, o) != NULL)
2428 xcoff_hash_table (info)->ldrel_count -=
2429 xcoff_section_data (sub, o)->ldrel_count;
2436 /* Add a symbol to the .loader symbols, if necessary. */
2439 xcoff_build_ldsyms (h, p)
2440 struct xcoff_link_hash_entry *h;
2443 struct xcoff_loader_info *ldinfo = (struct xcoff_loader_info *) p;
2446 /* We don't want to garbage collect symbols which are not defined in
2447 XCOFF files. This is a convenient place to mark them. */
2448 if (xcoff_hash_table (ldinfo->info)->gc
2449 && (h->flags & XCOFF_MARK) == 0
2450 && (h->root.type == bfd_link_hash_defined
2451 || h->root.type == bfd_link_hash_defweak)
2452 && (h->root.u.def.section->owner == NULL
2453 || (h->root.u.def.section->owner->xvec
2454 != ldinfo->info->hash->creator)))
2455 h->flags |= XCOFF_MARK;
2457 /* If this symbol is called, and it is defined in a dynamic object,
2458 then we need to set up global linkage code for it. (Unless we
2459 did garbage collection and we didn't need this symbol.) */
2460 if ((h->flags & XCOFF_CALLED) != 0
2461 && (h->flags & XCOFF_DEF_REGULAR) == 0
2462 && (h->flags & XCOFF_REF_DYNAMIC) != 0
2463 && (h->root.type == bfd_link_hash_undefined
2464 || h->root.type == bfd_link_hash_undefweak)
2465 && h->root.root.string[0] == '.'
2466 && (! xcoff_hash_table (ldinfo->info)->gc
2467 || (h->flags & XCOFF_MARK) != 0))
2470 struct xcoff_link_hash_entry *hds;
2472 sec = xcoff_hash_table (ldinfo->info)->linkage_section;
2473 h->root.type = bfd_link_hash_defined;
2474 h->root.u.def.section = sec;
2475 h->root.u.def.value = sec->_raw_size;
2477 sec->_raw_size += XCOFF_GLINK_SIZE;
2479 /* The global linkage code requires a TOC entry for the
2481 hds = h->descriptor;
2482 BFD_ASSERT ((hds->root.type == bfd_link_hash_undefined
2483 || hds->root.type == bfd_link_hash_undefweak)
2484 && (hds->flags & XCOFF_DEF_REGULAR) == 0
2485 && (hds->flags & XCOFF_REF_DYNAMIC) != 0);
2486 hds->flags |= XCOFF_MARK;
2487 if (hds->toc_section == NULL)
2489 hds->toc_section = xcoff_hash_table (ldinfo->info)->toc_section;
2490 hds->toc_offset = hds->toc_section->_raw_size;
2491 hds->toc_section->_raw_size += 4;
2492 ++xcoff_hash_table (ldinfo->info)->ldrel_count;
2493 ++hds->toc_section->reloc_count;
2495 hds->flags |= XCOFF_SET_TOC | XCOFF_LDREL;
2497 /* We need to call xcoff_build_ldsyms recursively here,
2498 because we may already have passed hds on the traversal. */
2499 xcoff_build_ldsyms (hds, p);
2503 /* We need to add a symbol to the .loader section if it is mentioned
2504 in a reloc which we are copying to the .loader section and it was
2505 not defined, or if it is the entry point. */
2507 if (((h->flags & XCOFF_LDREL) == 0
2508 || h->root.type == bfd_link_hash_defined
2509 || h->root.type == bfd_link_hash_defweak)
2510 && (h->flags & XCOFF_ENTRY) == 0)
2516 /* We don't need to add this symbol if we did garbage collection and
2517 we did not mark this symbol. */
2518 if (xcoff_hash_table (ldinfo->info)->gc
2519 && (h->flags & XCOFF_MARK) == 0)
2525 /* We may have already processed this symbol due to the recursive
2527 if ((h->flags & XCOFF_BUILT_LDSYM) != 0)
2530 /* We need to add this symbol to the .loader symbols. */
2532 /* h->ldsym will already have been allocated for an explicitly
2534 if (h->ldsym == NULL)
2536 h->ldsym = ((struct internal_ldsym *)
2537 bfd_zalloc (ldinfo->output_bfd,
2538 sizeof (struct internal_ldsym)));
2539 if (h->ldsym == NULL)
2541 ldinfo->failed = true;
2542 bfd_set_error (bfd_error_no_memory);
2547 /* The first 3 symbol table indices are reserved to indicate the
2549 h->ldindx = ldinfo->ldsym_count + 3;
2551 ++ldinfo->ldsym_count;
2553 len = strlen (h->root.root.string);
2554 if (len <= SYMNMLEN)
2555 strncpy (h->ldsym->_l._l_name, h->root.root.string, SYMNMLEN);
2558 if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
2561 bfd_byte *newstrings;
2563 newalc = ldinfo->string_alc * 2;
2566 while (ldinfo->string_size + len + 3 > newalc)
2569 if (ldinfo->strings == NULL)
2570 newstrings = (bfd_byte *) malloc (newalc);
2572 newstrings = ((bfd_byte *)
2573 realloc ((PTR) ldinfo->strings, newalc));
2574 if (newstrings == NULL)
2576 ldinfo->failed = true;
2577 bfd_set_error (bfd_error_no_memory);
2580 ldinfo->string_alc = newalc;
2581 ldinfo->strings = newstrings;
2584 bfd_put_16 (ldinfo->output_bfd, len + 1,
2585 ldinfo->strings + ldinfo->string_size);
2586 strcpy (ldinfo->strings + ldinfo->string_size + 2, h->root.root.string);
2587 h->ldsym->_l._l_l._l_zeroes = 0;
2588 h->ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
2589 ldinfo->string_size += len + 3;
2592 h->flags |= XCOFF_BUILT_LDSYM;
2597 /* Do the final link step. */
2600 _bfd_xcoff_bfd_final_link (abfd, info)
2602 struct bfd_link_info *info;
2604 bfd_size_type symesz;
2605 struct xcoff_final_link_info finfo;
2607 struct bfd_link_order *p;
2608 size_t max_contents_size;
2609 size_t max_sym_count;
2610 size_t max_lineno_count;
2611 size_t max_reloc_count;
2612 size_t max_output_reloc_count;
2613 file_ptr rel_filepos;
2615 file_ptr line_filepos;
2616 unsigned int linesz;
2618 bfd_byte *external_relocs = NULL;
2619 char strbuf[STRING_SIZE_SIZE];
2621 symesz = bfd_coff_symesz (abfd);
2624 finfo.output_bfd = abfd;
2625 finfo.strtab = NULL;
2626 finfo.section_info = NULL;
2627 finfo.last_file_index = -1;
2628 finfo.toc_symindx = -1;
2629 finfo.internal_syms = NULL;
2630 finfo.sym_indices = NULL;
2631 finfo.outsyms = NULL;
2632 finfo.linenos = NULL;
2633 finfo.contents = NULL;
2634 finfo.external_relocs = NULL;
2636 finfo.ldsym = ((struct external_ldsym *)
2637 (xcoff_hash_table (info)->loader_section->contents
2639 finfo.ldrel = ((struct external_ldrel *)
2640 (xcoff_hash_table (info)->loader_section->contents
2642 + xcoff_hash_table (info)->ldhdr.l_nsyms * LDSYMSZ));
2644 xcoff_data (abfd)->coff.link_info = info;
2646 finfo.strtab = _bfd_stringtab_init ();
2647 if (finfo.strtab == NULL)
2650 /* Compute the file positions for all the sections. */
2651 if (abfd->output_has_begun)
2653 if (xcoff_hash_table (info)->file_align != 0)
2660 file_align = xcoff_hash_table (info)->file_align;
2661 if (file_align != 0)
2663 boolean saw_contents;
2668 /* Insert .pad sections before every section which has
2669 contents and is loaded, if it is preceded by some other
2670 section which has contents and is loaded. */
2671 saw_contents = true;
2672 for (op = &abfd->sections; *op != NULL; op = &(*op)->next)
2674 (*op)->target_index = indx;
2675 if (strcmp ((*op)->name, ".pad") == 0)
2676 saw_contents = false;
2677 else if (((*op)->flags & SEC_HAS_CONTENTS) != 0
2678 && ((*op)->flags & SEC_LOAD) != 0)
2681 saw_contents = true;
2688 n = bfd_make_section_anyway (abfd, ".pad");
2689 BFD_ASSERT (*op == n);
2691 n->flags = SEC_HAS_CONTENTS;
2692 n->alignment_power = 0;
2693 saw_contents = false;
2698 /* Reset the section indices after inserting the new
2701 for (o = abfd->sections; o != NULL; o = o->next)
2704 o->target_index = indx;
2706 BFD_ASSERT ((unsigned int) indx == abfd->section_count);
2708 /* Work out appropriate sizes for the .pad sections to force
2709 each section to land on a page boundary. This bit of
2710 code knows what compute_section_file_positions is going
2712 sofar = bfd_coff_filhsz (abfd);
2713 if ((abfd->flags & EXEC_P) != 0)
2714 sofar += bfd_coff_aoutsz (abfd);
2720 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
2722 for (o = abfd->sections; o != NULL; o = o->next)
2724 if (strcmp (o->name, ".pad") == 0)
2728 BFD_ASSERT (o->_raw_size == 0);
2729 pageoff = sofar & (file_align - 1);
2732 o->_raw_size = file_align - pageoff;
2733 sofar += file_align - pageoff;
2734 o->flags |= SEC_HAS_CONTENTS;
2739 if ((o->flags & SEC_HAS_CONTENTS) != 0)
2740 sofar += BFD_ALIGN (o->_raw_size,
2741 1 << o->alignment_power);
2746 bfd_coff_compute_section_file_positions (abfd);
2749 /* Count the line numbers and relocation entries required for the
2750 output file. Set the file positions for the relocs. */
2751 rel_filepos = obj_relocbase (abfd);
2752 relsz = bfd_coff_relsz (abfd);
2753 max_contents_size = 0;
2754 max_lineno_count = 0;
2755 max_reloc_count = 0;
2756 for (o = abfd->sections; o != NULL; o = o->next)
2759 o->lineno_count = 0;
2760 for (p = o->link_order_head; p != NULL; p = p->next)
2762 if (p->type == bfd_indirect_link_order)
2766 sec = p->u.indirect.section;
2768 if (info->strip == strip_none
2769 || info->strip == strip_some)
2770 o->lineno_count += sec->lineno_count;
2772 o->reloc_count += sec->reloc_count;
2774 if (sec->_raw_size > max_contents_size)
2775 max_contents_size = sec->_raw_size;
2776 if (sec->lineno_count > max_lineno_count)
2777 max_lineno_count = sec->lineno_count;
2778 if (sec->reloc_count > max_reloc_count)
2779 max_reloc_count = sec->reloc_count;
2781 else if (p->type == bfd_section_reloc_link_order
2782 || p->type == bfd_symbol_reloc_link_order)
2785 if (o->reloc_count == 0)
2789 o->flags |= SEC_RELOC;
2790 o->rel_filepos = rel_filepos;
2791 rel_filepos += o->reloc_count * relsz;
2795 /* Allocate space for the pointers we need to keep for the relocs. */
2799 /* We use section_count + 1, rather than section_count, because
2800 the target_index fields are 1 based. */
2801 finfo.section_info = ((struct xcoff_link_section_info *)
2802 malloc ((abfd->section_count + 1)
2803 * sizeof (struct xcoff_link_section_info)));
2804 if (finfo.section_info == NULL)
2806 bfd_set_error (bfd_error_no_memory);
2809 for (i = 0; i <= abfd->section_count; i++)
2811 finfo.section_info[i].relocs = NULL;
2812 finfo.section_info[i].rel_hashes = NULL;
2816 /* We now know the size of the relocs, so we can determine the file
2817 positions of the line numbers. */
2818 line_filepos = rel_filepos;
2819 linesz = bfd_coff_linesz (abfd);
2820 max_output_reloc_count = 0;
2821 for (o = abfd->sections; o != NULL; o = o->next)
2823 if (o->lineno_count == 0)
2824 o->line_filepos = 0;
2827 o->line_filepos = line_filepos;
2828 line_filepos += o->lineno_count * linesz;
2831 if (o->reloc_count != 0)
2833 /* We don't know the indices of global symbols until we have
2834 written out all the local symbols. For each section in
2835 the output file, we keep an array of pointers to hash
2836 table entries. Each entry in the array corresponds to a
2837 reloc. When we find a reloc against a global symbol, we
2838 set the corresponding entry in this array so that we can
2839 fix up the symbol index after we have written out all the
2842 Because of this problem, we also keep the relocs in
2843 memory until the end of the link. This wastes memory.
2844 We could backpatch the file later, I suppose, although it
2846 finfo.section_info[o->target_index].relocs =
2847 ((struct internal_reloc *)
2848 malloc (o->reloc_count * sizeof (struct internal_reloc)));
2849 finfo.section_info[o->target_index].rel_hashes =
2850 ((struct xcoff_link_hash_entry **)
2851 malloc (o->reloc_count
2852 * sizeof (struct xcoff_link_hash_entry *)));
2853 if (finfo.section_info[o->target_index].relocs == NULL
2854 || finfo.section_info[o->target_index].rel_hashes == NULL)
2856 bfd_set_error (bfd_error_no_memory);
2860 if (o->reloc_count > max_output_reloc_count)
2861 max_output_reloc_count = o->reloc_count;
2864 /* Reset the reloc and lineno counts, so that we can use them to
2865 count the number of entries we have output so far. */
2867 o->lineno_count = 0;
2870 obj_sym_filepos (abfd) = line_filepos;
2872 /* Figure out the largest number of symbols in an input BFD. Take
2873 the opportunity to clear the output_has_begun fields of all the
2874 input BFD's. We want at least 4 symbols, since that is the
2875 number which xcoff_write_global_symbol may need. */
2877 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2881 sub->output_has_begun = false;
2882 sz = obj_raw_syment_count (sub);
2883 if (sz > max_sym_count)
2887 /* Allocate some buffers used while linking. */
2888 finfo.internal_syms = ((struct internal_syment *)
2889 malloc (max_sym_count
2890 * sizeof (struct internal_syment)));
2891 finfo.sym_indices = (long *) malloc (max_sym_count * sizeof (long));
2892 finfo.outsyms = ((bfd_byte *)
2893 malloc ((size_t) ((max_sym_count + 1) * symesz)));
2894 finfo.linenos = (bfd_byte *) malloc (max_lineno_count
2895 * bfd_coff_linesz (abfd));
2896 finfo.contents = (bfd_byte *) malloc (max_contents_size);
2897 finfo.external_relocs = (bfd_byte *) malloc (max_reloc_count * relsz);
2898 if ((finfo.internal_syms == NULL && max_sym_count > 0)
2899 || (finfo.sym_indices == NULL && max_sym_count > 0)
2900 || finfo.outsyms == NULL
2901 || (finfo.linenos == NULL && max_lineno_count > 0)
2902 || (finfo.contents == NULL && max_contents_size > 0)
2903 || (finfo.external_relocs == NULL && max_reloc_count > 0))
2905 bfd_set_error (bfd_error_no_memory);
2909 obj_raw_syment_count (abfd) = 0;
2910 xcoff_data (abfd)->toc = (bfd_vma) -1;
2912 /* We now know the position of everything in the file, except that
2913 we don't know the size of the symbol table and therefore we don't
2914 know where the string table starts. We just build the string
2915 table in memory as we go along. We process all the relocations
2916 for a single input file at once. */
2917 for (o = abfd->sections; o != NULL; o = o->next)
2919 for (p = o->link_order_head; p != NULL; p = p->next)
2921 if (p->type == bfd_indirect_link_order
2922 && p->u.indirect.section->owner->xvec == abfd->xvec)
2924 sub = p->u.indirect.section->owner;
2925 if (! sub->output_has_begun)
2927 if (! xcoff_link_input_bfd (&finfo, sub))
2929 sub->output_has_begun = true;
2932 else if (p->type == bfd_section_reloc_link_order
2933 || p->type == bfd_symbol_reloc_link_order)
2935 if (! xcoff_reloc_link_order (abfd, &finfo, o, p))
2940 if (! _bfd_default_link_order (abfd, info, o, p))
2946 /* Free up the buffers used by xcoff_link_input_bfd. */
2948 if (finfo.internal_syms != NULL)
2950 free (finfo.internal_syms);
2951 finfo.internal_syms = NULL;
2953 if (finfo.sym_indices != NULL)
2955 free (finfo.sym_indices);
2956 finfo.sym_indices = NULL;
2958 if (finfo.linenos != NULL)
2960 free (finfo.linenos);
2961 finfo.linenos = NULL;
2963 if (finfo.contents != NULL)
2965 free (finfo.contents);
2966 finfo.contents = NULL;
2968 if (finfo.external_relocs != NULL)
2970 free (finfo.external_relocs);
2971 finfo.external_relocs = NULL;
2974 /* The value of the last C_FILE symbol is supposed to be -1. Write
2976 if (finfo.last_file_index != -1)
2978 finfo.last_file.n_value = -1;
2979 bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
2980 (PTR) finfo.outsyms);
2982 (obj_sym_filepos (abfd)
2983 + finfo.last_file_index * symesz),
2985 || bfd_write (finfo.outsyms, symesz, 1, abfd) != symesz)
2989 /* Write out all the global symbols which do not come from XCOFF
2991 xcoff_link_hash_traverse (xcoff_hash_table (info),
2992 xcoff_write_global_symbol,
2995 if (finfo.outsyms != NULL)
2997 free (finfo.outsyms);
2998 finfo.outsyms = NULL;
3001 /* Now that we have written out all the global symbols, we know the
3002 symbol indices to use for relocs against them, and we can finally
3003 write out the relocs. */
3004 external_relocs = (bfd_byte *) malloc (max_output_reloc_count * relsz);
3005 if (external_relocs == NULL && max_output_reloc_count != 0)
3007 bfd_set_error (bfd_error_no_memory);
3011 for (o = abfd->sections; o != NULL; o = o->next)
3013 struct internal_reloc *irel;
3014 struct internal_reloc *irelend;
3015 struct xcoff_link_hash_entry **rel_hash;
3018 if (o->reloc_count == 0)
3021 irel = finfo.section_info[o->target_index].relocs;
3022 irelend = irel + o->reloc_count;
3023 rel_hash = finfo.section_info[o->target_index].rel_hashes;
3024 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
3026 if (*rel_hash != NULL)
3028 if ((*rel_hash)->indx < 0)
3030 if (! ((*info->callbacks->unattached_reloc)
3031 (info, (*rel_hash)->root.root.string,
3032 (bfd *) NULL, o, irel->r_vaddr)))
3034 (*rel_hash)->indx = 0;
3036 irel->r_symndx = (*rel_hash)->indx;
3040 /* XCOFF requires that the relocs be sorted by address. We tend
3041 to produce them in the order in which their containing csects
3042 appear in the symbol table, which is not necessarily by
3043 address. So we sort them here. There may be a better way to
3045 qsort ((PTR) finfo.section_info[o->target_index].relocs,
3046 o->reloc_count, sizeof (struct internal_reloc),
3049 irel = finfo.section_info[o->target_index].relocs;
3050 irelend = irel + o->reloc_count;
3051 erel = external_relocs;
3052 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
3053 bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
3055 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
3056 || bfd_write ((PTR) external_relocs, relsz, o->reloc_count,
3057 abfd) != relsz * o->reloc_count)
3061 if (external_relocs != NULL)
3063 free (external_relocs);
3064 external_relocs = NULL;
3067 /* Free up the section information. */
3068 if (finfo.section_info != NULL)
3072 for (i = 0; i < abfd->section_count; i++)
3074 if (finfo.section_info[i].relocs != NULL)
3075 free (finfo.section_info[i].relocs);
3076 if (finfo.section_info[i].rel_hashes != NULL)
3077 free (finfo.section_info[i].rel_hashes);
3079 free (finfo.section_info);
3080 finfo.section_info = NULL;
3083 /* Write out the loader section contents. */
3084 BFD_ASSERT ((bfd_byte *) finfo.ldrel
3085 == (xcoff_hash_table (info)->loader_section->contents
3086 + xcoff_hash_table (info)->ldhdr.l_impoff));
3087 o = xcoff_hash_table (info)->loader_section;
3088 if (! bfd_set_section_contents (abfd, o->output_section,
3089 o->contents, o->output_offset,
3093 /* Write out the global linkage section and the toc section. */
3094 o = xcoff_hash_table (info)->linkage_section;
3095 if (o->_raw_size > 0
3096 && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
3097 o->output_offset, o->_raw_size))
3099 o = xcoff_hash_table (info)->toc_section;
3100 if (o->_raw_size > 0
3101 && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
3102 o->output_offset, o->_raw_size))
3105 /* Write out the string table. */
3107 (obj_sym_filepos (abfd)
3108 + obj_raw_syment_count (abfd) * symesz),
3112 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
3113 (bfd_byte *) strbuf);
3114 if (bfd_write (strbuf, 1, STRING_SIZE_SIZE, abfd) != STRING_SIZE_SIZE)
3116 if (! _bfd_stringtab_emit (abfd, finfo.strtab))
3119 _bfd_stringtab_free (finfo.strtab);
3121 /* Write out the debugging string table. */
3122 o = xcoff_hash_table (info)->debug_section;
3125 struct bfd_strtab_hash *debug_strtab;
3127 debug_strtab = xcoff_hash_table (info)->debug_strtab;
3128 BFD_ASSERT (o->output_section->_raw_size - o->output_offset
3129 >= _bfd_stringtab_size (debug_strtab));
3131 o->output_section->filepos + o->output_offset,
3134 if (! _bfd_stringtab_emit (abfd, debug_strtab))
3138 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
3139 not try to write out the symbols. */
3140 bfd_get_symcount (abfd) = 0;
3145 if (finfo.strtab != NULL)
3146 _bfd_stringtab_free (finfo.strtab);
3147 if (finfo.section_info != NULL)
3151 for (i = 0; i < abfd->section_count; i++)
3153 if (finfo.section_info[i].relocs != NULL)
3154 free (finfo.section_info[i].relocs);
3155 if (finfo.section_info[i].rel_hashes != NULL)
3156 free (finfo.section_info[i].rel_hashes);
3158 free (finfo.section_info);
3160 if (finfo.internal_syms != NULL)
3161 free (finfo.internal_syms);
3162 if (finfo.sym_indices != NULL)
3163 free (finfo.sym_indices);
3164 if (finfo.outsyms != NULL)
3165 free (finfo.outsyms);
3166 if (finfo.linenos != NULL)
3167 free (finfo.linenos);
3168 if (finfo.contents != NULL)
3169 free (finfo.contents);
3170 if (finfo.external_relocs != NULL)
3171 free (finfo.external_relocs);
3172 if (external_relocs != NULL)
3173 free (external_relocs);
3177 /* Link an input file into the linker output file. This function
3178 handles all the sections and relocations of the input file at once. */
3181 xcoff_link_input_bfd (finfo, input_bfd)
3182 struct xcoff_final_link_info *finfo;
3186 const char *strings;
3187 bfd_size_type syment_base;
3188 unsigned int n_tmask;
3189 unsigned int n_btshft;
3191 bfd_size_type isymesz;
3192 bfd_size_type osymesz;
3193 bfd_size_type linesz;
3196 struct internal_syment *isymp;
3198 unsigned long *debug_index;
3200 unsigned long output_index;
3202 struct xcoff_link_hash_entry **sym_hash;
3206 /* We can just skip DYNAMIC files, unless this is a static link. */
3207 if ((input_bfd->flags & DYNAMIC) != 0
3208 && ! finfo->info->static_link)
3211 /* Move all the symbols to the output file. */
3213 output_bfd = finfo->output_bfd;
3215 syment_base = obj_raw_syment_count (output_bfd);
3216 isymesz = bfd_coff_symesz (input_bfd);
3217 osymesz = bfd_coff_symesz (output_bfd);
3218 linesz = bfd_coff_linesz (input_bfd);
3219 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
3221 n_tmask = coff_data (input_bfd)->local_n_tmask;
3222 n_btshft = coff_data (input_bfd)->local_n_btshft;
3224 /* Define macros so that ISFCN, et. al., macros work correctly. */
3225 #define N_TMASK n_tmask
3226 #define N_BTSHFT n_btshft
3229 if (! finfo->info->keep_memory)
3232 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
3235 if (! _bfd_coff_get_external_symbols (input_bfd))
3238 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
3239 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
3240 sym_hash = obj_xcoff_sym_hashes (input_bfd);
3241 csectpp = xcoff_data (input_bfd)->csects;
3242 debug_index = xcoff_data (input_bfd)->debug_indices;
3243 isymp = finfo->internal_syms;
3244 indexp = finfo->sym_indices;
3245 output_index = syment_base;
3246 outsym = finfo->outsyms;
3248 while (esym < esym_end)
3250 struct internal_syment isym;
3251 union internal_auxent aux;
3257 bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
3259 /* If this is a C_EXT or C_HIDEXT symbol, we need the csect
3261 if (isymp->n_sclass == C_EXT || isymp->n_sclass == C_HIDEXT)
3263 BFD_ASSERT (isymp->n_numaux > 0);
3264 bfd_coff_swap_aux_in (input_bfd,
3265 (PTR) (esym + isymesz * isymp->n_numaux),
3266 isymp->n_type, isymp->n_sclass,
3267 isymp->n_numaux - 1, isymp->n_numaux,
3269 smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
3272 /* Make a copy of *isymp so that the relocate_section function
3273 always sees the original values. This is more reliable than
3274 always recomputing the symbol value even if we are stripping
3278 /* If this symbol is in the .loader section, swap out the
3279 .loader symbol information. If this is an external symbol
3280 reference to a defined symbol, though, then wait until we get
3281 to the definition. */
3282 if (isym.n_sclass == C_EXT
3283 && *sym_hash != NULL
3284 && (*sym_hash)->ldsym != NULL
3286 || (*sym_hash)->root.type == bfd_link_hash_undefined))
3288 struct xcoff_link_hash_entry *h;
3289 struct internal_ldsym *ldsym;
3293 if (isym.n_scnum > 0)
3295 ldsym->l_scnum = (*csectpp)->output_section->target_index;
3296 ldsym->l_value = (isym.n_value
3297 + (*csectpp)->output_section->vma
3298 + (*csectpp)->output_offset
3303 ldsym->l_scnum = isym.n_scnum;
3304 ldsym->l_value = isym.n_value;
3307 ldsym->l_smtype = smtyp;
3308 if (((h->flags & XCOFF_DEF_REGULAR) == 0
3309 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
3310 || (h->flags & XCOFF_IMPORT) != 0)
3311 ldsym->l_smtype |= L_IMPORT;
3312 if (((h->flags & XCOFF_DEF_REGULAR) != 0
3313 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
3314 || (h->flags & XCOFF_EXPORT) != 0)
3315 ldsym->l_smtype |= L_EXPORT;
3316 if ((h->flags & XCOFF_ENTRY) != 0)
3317 ldsym->l_smtype |= L_ENTRY;
3319 ldsym->l_smclas = aux.x_csect.x_smclas;
3321 if (ldsym->l_ifile == (bfd_size_type) -1)
3323 else if (ldsym->l_ifile == 0)
3325 if ((ldsym->l_smtype & L_IMPORT) == 0)
3331 if (h->root.type == bfd_link_hash_defined
3332 || h->root.type == bfd_link_hash_defweak)
3333 impbfd = h->root.u.def.section->owner;
3334 else if (h->root.type == bfd_link_hash_undefined
3335 || h->root.type == bfd_link_hash_undefweak)
3336 impbfd = h->root.u.undef.abfd;
3344 BFD_ASSERT (impbfd->xvec == finfo->output_bfd->xvec);
3345 ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
3352 BFD_ASSERT (h->ldindx >= 0);
3353 BFD_ASSERT (LDSYMSZ == sizeof (struct external_ldsym));
3354 xcoff_swap_ldsym_out (finfo->output_bfd, ldsym,
3355 finfo->ldsym + h->ldindx - 3);
3363 add = 1 + isym.n_numaux;
3365 /* If we are skipping this csect, we want to skip this symbol. */
3366 if (*csectpp == NULL)
3369 /* If we garbage collected this csect, we want to skip this
3372 && xcoff_hash_table (finfo->info)->gc
3373 && ((*csectpp)->flags & SEC_MARK) == 0
3374 && *csectpp != bfd_abs_section_ptr)
3377 /* An XCOFF linker always skips C_STAT symbols. */
3379 && isymp->n_sclass == C_STAT)
3382 /* We skip all but the first TOC anchor. */
3384 && isymp->n_sclass == C_HIDEXT
3385 && aux.x_csect.x_smclas == XMC_TC0)
3387 if (finfo->toc_symindx != -1)
3391 finfo->toc_symindx = output_index;
3392 xcoff_data (finfo->output_bfd)->toc =
3393 ((*csectpp)->output_section->vma
3394 + (*csectpp)->output_offset
3401 /* If we are stripping all symbols, we want to skip this one. */
3403 && finfo->info->strip == strip_all)
3406 /* We can skip resolved external references. */
3408 && isym.n_sclass == C_EXT
3410 && (*sym_hash)->root.type != bfd_link_hash_undefined)
3413 /* We can skip common symbols if they got defined somewhere
3416 && isym.n_sclass == C_EXT
3418 && ((*sym_hash)->flags & XCOFF_DEF_REGULAR) != 0)
3421 /* Skip local symbols if we are discarding them. */
3423 && finfo->info->discard == discard_all
3424 && isym.n_sclass != C_EXT
3425 && (isym.n_sclass != C_HIDEXT
3426 || smtyp != XTY_SD))
3429 /* If we stripping debugging symbols, and this is a debugging
3430 symbol, then skip it. */
3432 && finfo->info->strip == strip_debugger
3433 && isym.n_scnum == N_DEBUG)
3436 /* If some symbols are stripped based on the name, work out the
3437 name and decide whether to skip this symbol. We don't handle
3438 this correctly for symbols whose names are in the .debug
3439 section; to get it right we would need a new bfd_strtab_hash
3440 function to return the string given the index. */
3442 && (finfo->info->strip == strip_some
3443 || finfo->info->discard == discard_l)
3444 && (debug_index == NULL || *debug_index == (unsigned long) -1))
3447 char buf[SYMNMLEN + 1];
3449 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
3453 if ((finfo->info->strip == strip_some
3454 && (bfd_hash_lookup (finfo->info->keep_hash, name, false,
3456 || (finfo->info->discard == discard_l
3457 && (isym.n_sclass != C_EXT
3458 && (isym.n_sclass != C_HIDEXT
3459 || smtyp != XTY_SD))
3460 && strncmp (name, finfo->info->lprefix,
3461 finfo->info->lprefix_len) == 0))
3465 /* On the other hand, we can't skip global symbols which have
3466 relocs against them. */
3468 && isym.n_sclass == C_EXT
3469 && (*sym_hash)->indx == -2
3470 && finfo->info->strip != strip_all)
3473 /* We can not skip the first TOC anchor. */
3476 && finfo->info->strip != strip_all)
3479 /* We now know whether we are to skip this symbol or not. */
3482 /* Adjust the symbol in order to output it. */
3484 if (isym._n._n_n._n_zeroes == 0
3485 && isym._n._n_n._n_offset != 0)
3487 /* This symbol has a long name. Enter it in the string
3488 table we are building. If *debug_index != -1, the
3489 name has already been entered in the .debug section. */
3490 if (debug_index != NULL && *debug_index != (unsigned long) -1)
3491 isym._n._n_n._n_offset = *debug_index;
3497 name = _bfd_coff_internal_syment_name (input_bfd, &isym,
3501 indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
3502 if (indx == (bfd_size_type) -1)
3504 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
3508 if (isym.n_sclass == C_BSTAT)
3512 /* The value of a C_BSTAT symbol is the symbol table
3513 index of the containing csect. */
3515 indx = isym.n_value;
3516 if (indx < obj_raw_syment_count (input_bfd))
3520 symindx = finfo->sym_indices[indx];
3524 isym.n_value = symindx;
3527 else if (isym.n_scnum > 0)
3529 isym.n_scnum = (*csectpp)->output_section->target_index;
3530 isym.n_value += ((*csectpp)->output_section->vma
3531 + (*csectpp)->output_offset
3535 /* The value of a C_FILE symbol is the symbol index of the
3536 next C_FILE symbol. The value of the last C_FILE symbol
3537 is -1. We try to get this right, below, just before we
3538 write the symbols out, but in the general case we may
3539 have to write the symbol out twice. */
3540 if (isym.n_sclass == C_FILE)
3542 if (finfo->last_file_index != -1
3543 && finfo->last_file.n_value != (long) output_index)
3545 /* We must correct the value of the last C_FILE entry. */
3546 finfo->last_file.n_value = output_index;
3547 if ((bfd_size_type) finfo->last_file_index >= syment_base)
3549 /* The last C_FILE symbol is in this input file. */
3550 bfd_coff_swap_sym_out (output_bfd,
3551 (PTR) &finfo->last_file,
3552 (PTR) (finfo->outsyms
3553 + ((finfo->last_file_index
3559 /* We have already written out the last C_FILE
3560 symbol. We need to write it out again. We
3561 borrow *outsym temporarily. */
3562 bfd_coff_swap_sym_out (output_bfd,
3563 (PTR) &finfo->last_file,
3565 if (bfd_seek (output_bfd,
3566 (obj_sym_filepos (output_bfd)
3567 + finfo->last_file_index * osymesz),
3569 || (bfd_write (outsym, osymesz, 1, output_bfd)
3575 finfo->last_file_index = output_index;
3576 finfo->last_file = isym;
3579 /* Output the symbol. */
3581 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
3583 *indexp = output_index;
3585 if (isym.n_sclass == C_EXT)
3588 struct xcoff_link_hash_entry *h;
3590 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
3592 h = obj_xcoff_sym_hashes (input_bfd)[indx];
3593 BFD_ASSERT (h != NULL);
3594 h->indx = output_index;
3597 output_index += add;
3598 outsym += add * osymesz;
3601 esym += add * isymesz;
3605 if (debug_index != NULL)
3608 for (--add; add > 0; --add)
3612 /* Fix up the aux entries. This must be done in a separate pass,
3613 because we don't know the correct symbol indices until we have
3614 already decided which symbols we are going to keep. */
3616 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
3617 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
3618 isymp = finfo->internal_syms;
3619 indexp = finfo->sym_indices;
3620 csectpp = xcoff_data (input_bfd)->csects;
3621 outsym = finfo->outsyms;
3622 while (esym < esym_end)
3626 add = 1 + isymp->n_numaux;
3629 esym += add * isymesz;
3637 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
3639 union internal_auxent aux;
3641 bfd_coff_swap_aux_in (input_bfd, (PTR) esym, isymp->n_type,
3642 isymp->n_sclass, i, isymp->n_numaux,
3645 if (isymp->n_sclass == C_FILE)
3647 /* This is the file name (or some comment put in by
3648 the compiler). If it is long, we must put it in
3649 the string table. */
3650 if (aux.x_file.x_n.x_zeroes == 0
3651 && aux.x_file.x_n.x_offset != 0)
3653 const char *filename;
3656 BFD_ASSERT (aux.x_file.x_n.x_offset
3657 >= STRING_SIZE_SIZE);
3658 if (strings == NULL)
3660 strings = _bfd_coff_read_string_table (input_bfd);
3661 if (strings == NULL)
3664 filename = strings + aux.x_file.x_n.x_offset;
3665 indx = _bfd_stringtab_add (finfo->strtab, filename,
3667 if (indx == (bfd_size_type) -1)
3669 aux.x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
3672 else if ((isymp->n_sclass == C_EXT
3673 || isymp->n_sclass == C_HIDEXT)
3674 && i + 1 == isymp->n_numaux)
3676 /* We don't support type checking. I don't know if
3678 aux.x_csect.x_parmhash = 0;
3679 /* I don't think anybody uses these fields, but we'd
3680 better clobber them just in case. */
3681 aux.x_csect.x_stab = 0;
3682 aux.x_csect.x_snstab = 0;
3683 if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_LD)
3687 indx = aux.x_csect.x_scnlen.l;
3688 if (indx < obj_raw_syment_count (input_bfd))
3692 symindx = finfo->sym_indices[indx];
3694 aux.x_sym.x_tagndx.l = 0;
3696 aux.x_sym.x_tagndx.l = symindx;
3700 else if (isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
3704 if (ISFCN (isymp->n_type)
3705 || ISTAG (isymp->n_sclass)
3706 || isymp->n_sclass == C_BLOCK)
3708 indx = aux.x_sym.x_fcnary.x_fcn.x_endndx.l;
3710 && indx < obj_raw_syment_count (input_bfd))
3712 /* We look forward through the symbol for
3713 the index of the next symbol we are going
3714 to include. I don't know if this is
3716 while (finfo->sym_indices[indx] < 0
3717 && indx < obj_raw_syment_count (input_bfd))
3719 if (indx >= obj_raw_syment_count (input_bfd))
3720 indx = output_index;
3722 indx = finfo->sym_indices[indx];
3723 aux.x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
3727 indx = aux.x_sym.x_tagndx.l;
3728 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
3732 symindx = finfo->sym_indices[indx];
3734 aux.x_sym.x_tagndx.l = 0;
3736 aux.x_sym.x_tagndx.l = symindx;
3740 /* Copy over the line numbers, unless we are stripping
3741 them. We do this on a symbol by symbol basis in
3742 order to more easily handle garbage collection. */
3743 if ((isymp->n_sclass == C_EXT
3744 || isymp->n_sclass == C_HIDEXT)
3746 && isymp->n_numaux > 1
3747 && ISFCN (isymp->n_type)
3748 && aux.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
3750 if (finfo->info->strip != strip_none
3751 && finfo->info->strip != strip_some)
3752 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
3755 asection *enclosing;
3756 bfd_size_type linoff;
3757 struct internal_lineno lin;
3760 enclosing = xcoff_section_data (abfd, o)->enclosing;
3761 linoff = (aux.x_sym.x_fcnary.x_fcn.x_lnnoptr
3762 - enclosing->line_filepos);
3764 if (bfd_seek (input_bfd,
3765 enclosing->line_filepos + linoff,
3767 || (bfd_read (finfo->linenos, linesz,
3768 o->lineno_count, input_bfd)
3769 != linesz * o->lineno_count))
3772 bfd_coff_swap_lineno_in (input_bfd,
3773 (PTR) finfo->linenos,
3776 || ((bfd_size_type) lin.l_addr.l_symndx
3780 obj_coff_external_syms (input_bfd)))
3782 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
3785 bfd_byte *linpend, *linp;
3787 bfd_size_type count;
3789 lin.l_addr.l_symndx = *indexp;
3790 bfd_coff_swap_lineno_out (output_bfd, (PTR) &lin,
3791 (PTR) finfo->linenos);
3793 linpend = (finfo->linenos
3794 + o->lineno_count * linesz);
3795 offset = (o->output_section->vma
3798 for (linp = finfo->linenos + linesz;
3802 bfd_coff_swap_lineno_in (input_bfd, (PTR) linp,
3804 if (lin.l_lnno == 0)
3806 lin.l_addr.l_paddr += offset;
3807 bfd_coff_swap_lineno_out (output_bfd,
3812 count = (linp - finfo->linenos) / linesz;
3814 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr =
3815 (o->output_section->line_filepos
3816 + o->output_section->lineno_count * linesz);
3818 if (bfd_seek (output_bfd,
3819 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr,
3821 || (bfd_write (finfo->linenos, linesz, count,
3826 o->output_section->lineno_count += count;
3831 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, isymp->n_type,
3832 isymp->n_sclass, i, isymp->n_numaux,
3844 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
3845 symbol will be the first symbol in the next input file. In the
3846 normal case, this will save us from writing out the C_FILE symbol
3848 if (finfo->last_file_index != -1
3849 && (bfd_size_type) finfo->last_file_index >= syment_base)
3851 finfo->last_file.n_value = output_index;
3852 bfd_coff_swap_sym_out (output_bfd, (PTR) &finfo->last_file,
3853 (PTR) (finfo->outsyms
3854 + ((finfo->last_file_index - syment_base)
3858 /* Write the modified symbols to the output file. */
3859 if (outsym > finfo->outsyms)
3861 if (bfd_seek (output_bfd,
3862 obj_sym_filepos (output_bfd) + syment_base * osymesz,
3864 || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1,
3866 != (bfd_size_type) (outsym - finfo->outsyms)))
3869 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
3870 + (outsym - finfo->outsyms) / osymesz)
3873 obj_raw_syment_count (output_bfd) = output_index;
3876 /* Don't let the linker relocation routines discard the symbols. */
3877 keep_syms = obj_coff_keep_syms (input_bfd);
3878 obj_coff_keep_syms (input_bfd) = true;
3880 /* Relocate the contents of each section. */
3881 for (o = input_bfd->sections; o != NULL; o = o->next)
3885 if ((o->flags & SEC_HAS_CONTENTS) == 0
3886 || o->_raw_size == 0
3887 || (o->flags & SEC_IN_MEMORY) != 0)
3890 /* We have set filepos correctly for the sections we created to
3891 represent csects, so bfd_get_section_contents should work. */
3892 if (coff_section_data (input_bfd, o) != NULL
3893 && coff_section_data (input_bfd, o)->contents != NULL)
3894 contents = coff_section_data (input_bfd, o)->contents;
3897 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
3898 (file_ptr) 0, o->_raw_size))
3900 contents = finfo->contents;
3903 if ((o->flags & SEC_RELOC) != 0)
3906 struct internal_reloc *internal_relocs;
3907 struct internal_reloc *irel;
3909 struct internal_reloc *irelend;
3910 struct xcoff_link_hash_entry **rel_hash;
3913 /* Read in the relocs. */
3914 target_index = o->output_section->target_index;
3915 internal_relocs = (xcoff_read_internal_relocs
3916 (input_bfd, o, false, finfo->external_relocs,
3918 (finfo->section_info[target_index].relocs
3919 + o->output_section->reloc_count)));
3920 if (internal_relocs == NULL)
3923 /* Call processor specific code to relocate the section
3925 if (! bfd_coff_relocate_section (output_bfd, finfo->info,
3929 finfo->internal_syms,
3930 xcoff_data (input_bfd)->csects))
3933 offset = o->output_section->vma + o->output_offset - o->vma;
3934 irel = internal_relocs;
3935 irelend = irel + o->reloc_count;
3936 rel_hash = (finfo->section_info[target_index].rel_hashes
3937 + o->output_section->reloc_count);
3938 for (; irel < irelend; irel++, rel_hash++)
3940 struct xcoff_link_hash_entry *h = NULL;
3941 struct internal_ldrel ldrel;
3945 /* Adjust the reloc address and symbol index. */
3947 irel->r_vaddr += offset;
3949 r_symndx = irel->r_symndx;
3953 h = obj_xcoff_sym_hashes (input_bfd)[r_symndx];
3956 /* This is a global symbol. */
3958 irel->r_symndx = h->indx;
3961 /* This symbol is being written at the end
3962 of the file, and we do not yet know the
3963 symbol index. We save the pointer to the
3964 hash table entry in the rel_hash list.
3965 We set the indx field to -2 to indicate
3966 that this symbol must not be stripped. */
3975 indx = finfo->sym_indices[r_symndx];
3979 struct internal_syment *is;
3981 /* Relocations against a TC0 TOC anchor are
3982 automatically transformed to be against
3983 the TOC anchor in the output file. */
3984 is = finfo->internal_syms + r_symndx;
3985 if (is->n_sclass == C_HIDEXT
3986 && is->n_numaux > 0)
3989 union internal_auxent aux;
3993 obj_coff_external_syms (input_bfd))
3994 + ((r_symndx + is->n_numaux)
3996 bfd_coff_swap_aux_in (input_bfd, auxptr,
3997 is->n_type, is->n_sclass,
4001 if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_SD
4002 && aux.x_csect.x_smclas == XMC_TC0)
4003 indx = finfo->toc_symindx;
4008 irel->r_symndx = indx;
4011 struct internal_syment *is;
4013 char buf[SYMNMLEN + 1];
4015 /* This reloc is against a symbol we are
4016 stripping. It would be possible to handle
4017 this case, but I don't think it's worth it. */
4018 is = finfo->internal_syms + r_symndx;
4020 name = (_bfd_coff_internal_syment_name
4021 (input_bfd, is, buf));
4025 if (! ((*finfo->info->callbacks->unattached_reloc)
4026 (finfo->info, name, input_bfd, o,
4033 switch (irel->r_type)
4041 /* This reloc needs to be copied into the .loader
4043 ldrel.l_vaddr = irel->r_vaddr;
4045 ldrel.l_symndx = -1;
4050 sec = xcoff_data (input_bfd)->csects[r_symndx];
4051 if ((sec->flags & SEC_CODE) != 0)
4053 else if ((sec->flags & SEC_HAS_CONTENTS) != 0)
4058 else if (h->root.type == bfd_link_hash_defined
4059 || h->root.type == bfd_link_hash_defweak)
4063 sec = h->root.u.def.section->output_section;
4064 if ((sec->flags & SEC_CODE) != 0)
4066 else if ((sec->flags & SEC_HAS_CONTENTS) != 0)
4075 (*_bfd_error_handler)
4076 ("%s: `%s' in loader reloc but not loader sym",
4077 bfd_get_filename (input_bfd),
4078 h->root.root.string);
4079 bfd_set_error (bfd_error_bad_value);
4082 ldrel.l_symndx = h->ldindx;
4084 ldrel.l_rtype = (irel->r_size << 8) | irel->r_type;
4085 ldrel.l_rsecnm = o->output_section->target_index;
4086 if (xcoff_hash_table (finfo->info)->textro
4087 && (o->output_section->flags & SEC_CODE) != 0)
4089 (*_bfd_error_handler)
4090 ("%s: loader reloc in read-only section %s",
4091 bfd_get_filename (input_bfd),
4092 bfd_get_section_name (finfo->output_bfd,
4093 o->output_section));
4094 bfd_set_error (bfd_error_invalid_operation);
4097 xcoff_swap_ldrel_out (output_bfd, &ldrel,
4099 BFD_ASSERT (sizeof (struct external_ldrel) == LDRELSZ);
4104 o->output_section->reloc_count += o->reloc_count;
4107 /* Write out the modified section contents. */
4108 if (! bfd_set_section_contents (output_bfd, o->output_section,
4109 contents, o->output_offset,
4110 (o->_cooked_size != 0
4116 obj_coff_keep_syms (input_bfd) = keep_syms;
4118 if (! finfo->info->keep_memory)
4120 if (! _bfd_coff_free_symbols (input_bfd))
4130 /* Write out a non-XCOFF global symbol. */
4133 xcoff_write_global_symbol (h, p)
4134 struct xcoff_link_hash_entry *h;
4137 struct xcoff_final_link_info *finfo = (struct xcoff_final_link_info *) p;
4140 struct internal_syment isym;
4141 union internal_auxent aux;
4143 output_bfd = finfo->output_bfd;
4145 /* If this symbol was garbage collected, just skip it. */
4146 if (xcoff_hash_table (finfo->info)->gc
4147 && (h->flags & XCOFF_MARK) == 0)
4150 /* If we need a .loader section entry, write it out. */
4151 if (h->ldsym != NULL)
4153 struct internal_ldsym *ldsym;
4158 if (h->root.type == bfd_link_hash_undefined
4159 || h->root.type == bfd_link_hash_undefweak)
4162 ldsym->l_scnum = N_UNDEF;
4163 ldsym->l_smtype = XTY_ER;
4164 impbfd = h->root.u.undef.abfd;
4166 else if (h->root.type == bfd_link_hash_defined
4167 || h->root.type == bfd_link_hash_defweak)
4171 sec = h->root.u.def.section;
4172 ldsym->l_value = (sec->output_section->vma
4173 + sec->output_offset
4174 + h->root.u.def.value);
4175 ldsym->l_scnum = sec->output_section->target_index;
4176 ldsym->l_smtype = XTY_SD;
4177 impbfd = sec->owner;
4182 if (((h->flags & XCOFF_DEF_REGULAR) == 0
4183 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
4184 || (h->flags & XCOFF_IMPORT) != 0)
4185 ldsym->l_smtype |= L_IMPORT;
4186 if (((h->flags & XCOFF_DEF_REGULAR) != 0
4187 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
4188 || (h->flags & XCOFF_EXPORT) != 0)
4189 ldsym->l_smtype |= L_EXPORT;
4190 if ((h->flags & XCOFF_ENTRY) != 0)
4191 ldsym->l_smtype |= L_ENTRY;
4193 ldsym->l_smclas = h->smclas;
4195 if (ldsym->l_ifile == (bfd_size_type) -1)
4197 else if (ldsym->l_ifile == 0)
4199 if ((ldsym->l_smtype & L_IMPORT) == 0)
4201 else if (impbfd == NULL)
4205 BFD_ASSERT (impbfd->xvec == output_bfd->xvec);
4206 ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
4212 BFD_ASSERT (h->ldindx >= 0);
4213 BFD_ASSERT (LDSYMSZ == sizeof (struct external_ldsym));
4214 xcoff_swap_ldsym_out (output_bfd, ldsym, finfo->ldsym + h->ldindx - 3);
4218 /* If this symbol needs global linkage code, write it out. */
4219 if (h->root.type == bfd_link_hash_defined
4220 && (h->root.u.def.section
4221 == xcoff_hash_table (finfo->info)->linkage_section))
4227 p = h->root.u.def.section->contents + h->root.u.def.value;
4229 /* The first instruction in the global linkage code loads a
4230 specific TOC element. */
4231 tocoff = (h->descriptor->toc_section->output_section->vma
4232 + h->descriptor->toc_section->output_offset
4233 + h->descriptor->toc_offset
4234 - xcoff_data (output_bfd)->toc);
4235 bfd_put_32 (output_bfd, XCOFF_GLINK_FIRST | tocoff, p);
4237 i < sizeof xcoff_glink_code / sizeof xcoff_glink_code[0];
4239 bfd_put_32 (output_bfd, xcoff_glink_code[i], p);
4242 /* If we created a TOC entry for this symbol, write out the required
4244 if ((h->flags & XCOFF_SET_TOC) != 0)
4249 struct internal_reloc *irel;
4250 struct internal_ldrel ldrel;
4252 tocsec = h->toc_section;
4253 osec = tocsec->output_section;
4254 oindx = osec->target_index;
4255 irel = finfo->section_info[oindx].relocs + osec->reloc_count;
4256 irel->r_vaddr = (osec->vma
4257 + tocsec->output_offset
4260 irel->r_symndx = h->indx;
4264 irel->r_symndx = obj_raw_syment_count (output_bfd);
4266 irel->r_type = R_POS;
4268 finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
4269 ++osec->reloc_count;
4271 BFD_ASSERT (h->ldindx >= 0);
4272 ldrel.l_vaddr = irel->r_vaddr;
4273 ldrel.l_symndx = h->ldindx;
4274 ldrel.l_rtype = (31 << 8) | R_POS;
4275 ldrel.l_rsecnm = oindx;
4276 xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
4284 && (finfo->info->strip == strip_all
4285 || (finfo->info->strip == strip_some
4286 && (bfd_hash_lookup (finfo->info->keep_hash,
4287 h->root.root.string, false, false)
4292 && (h->flags & (XCOFF_REF_REGULAR | XCOFF_DEF_REGULAR)) == 0)
4295 outsym = finfo->outsyms;
4297 memset (&aux, 0, sizeof aux);
4299 h->indx = obj_raw_syment_count (output_bfd);
4301 if (strlen (h->root.root.string) <= SYMNMLEN)
4302 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
4309 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
4311 indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
4313 if (indx == (bfd_size_type) -1)
4315 isym._n._n_n._n_zeroes = 0;
4316 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
4319 if (h->root.type == bfd_link_hash_undefined
4320 || h->root.type == bfd_link_hash_undefweak)
4323 isym.n_scnum = N_UNDEF;
4324 isym.n_sclass = C_EXT;
4325 aux.x_csect.x_smtyp = XTY_ER;
4327 else if (h->root.type == bfd_link_hash_defined
4328 || h->root.type == bfd_link_hash_defweak)
4330 isym.n_value = (h->root.u.def.section->output_section->vma
4331 + h->root.u.def.section->output_offset
4332 + h->root.u.def.value);
4333 isym.n_scnum = h->root.u.def.section->output_section->target_index;
4334 isym.n_sclass = C_HIDEXT;
4335 aux.x_csect.x_smtyp = XTY_SD;
4336 /* I don't know what the csect length should be in this case. */
4341 isym.n_type = T_NULL;
4344 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
4345 outsym += bfd_coff_symesz (output_bfd);
4347 aux.x_csect.x_smclas = h->smclas;
4349 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, isym.n_sclass, 0, 1,
4351 outsym += bfd_coff_auxesz (output_bfd);
4353 if (h->root.type == bfd_link_hash_defined
4354 || h->root.type == bfd_link_hash_defweak)
4356 /* We just output an SD symbol. Now output an LD symbol. */
4360 isym.n_sclass = C_EXT;
4361 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
4362 outsym += bfd_coff_symesz (output_bfd);
4364 aux.x_csect.x_smtyp = XTY_LD;
4365 aux.x_csect.x_scnlen.l = obj_raw_syment_count (output_bfd);
4367 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, C_EXT, 0, 1,
4369 outsym += bfd_coff_auxesz (output_bfd);
4372 if (bfd_seek (output_bfd,
4373 (obj_sym_filepos (output_bfd)
4374 + (obj_raw_syment_count (output_bfd)
4375 * bfd_coff_symesz (output_bfd))),
4377 || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1, output_bfd)
4378 != (bfd_size_type) (outsym - finfo->outsyms)))
4380 obj_raw_syment_count (output_bfd) +=
4381 (outsym - finfo->outsyms) / bfd_coff_symesz (output_bfd);
4386 /* Handle a link order which is supposed to generate a reloc. */
4389 xcoff_reloc_link_order (output_bfd, finfo, output_section, link_order)
4391 struct xcoff_final_link_info *finfo;
4392 asection *output_section;
4393 struct bfd_link_order *link_order;
4395 reloc_howto_type *howto;
4396 struct internal_reloc *irel;
4397 struct xcoff_link_hash_entry **rel_hash_ptr;
4399 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
4402 bfd_set_error (bfd_error_bad_value);
4406 if (link_order->u.reloc.p->addend != 0)
4410 bfd_reloc_status_type rstat;
4413 size = bfd_get_reloc_size (howto);
4414 buf = (bfd_byte *) bfd_zmalloc (size);
4417 bfd_set_error (bfd_error_no_memory);
4421 rstat = _bfd_relocate_contents (howto, output_bfd,
4422 link_order->u.reloc.p->addend, buf);
4428 case bfd_reloc_outofrange:
4430 case bfd_reloc_overflow:
4431 if (! ((*finfo->info->callbacks->reloc_overflow)
4433 (link_order->type == bfd_section_reloc_link_order
4434 ? bfd_section_name (output_bfd,
4435 link_order->u.reloc.p->u.section)
4436 : link_order->u.reloc.p->u.name),
4437 howto->name, link_order->u.reloc.p->addend,
4438 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
4445 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
4446 (file_ptr) link_order->offset, size);
4452 /* Store the reloc information in the right place. It will get
4453 swapped and written out at the end of the final_link routine. */
4455 irel = (finfo->section_info[output_section->target_index].relocs
4456 + output_section->reloc_count);
4457 rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
4458 + output_section->reloc_count);
4460 memset (irel, 0, sizeof (struct internal_reloc));
4461 *rel_hash_ptr = NULL;
4463 irel->r_vaddr = output_section->vma + link_order->offset;
4465 if (link_order->type == bfd_section_reloc_link_order)
4467 /* We need to somehow locate a symbol in the right section. The
4468 symbol must either have a value of zero, or we must adjust
4469 the addend by the value of the symbol. FIXME: Write this
4470 when we need it. The old linker couldn't handle this anyhow. */
4472 *rel_hash_ptr = NULL;
4477 struct xcoff_link_hash_entry *h;
4479 h = xcoff_link_hash_lookup (xcoff_hash_table (finfo->info),
4480 link_order->u.reloc.p->u.name,
4481 false, false, true);
4485 irel->r_symndx = h->indx;
4488 /* Set the index to -2 to force this symbol to get
4497 if (! ((*finfo->info->callbacks->unattached_reloc)
4498 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
4499 (asection *) NULL, (bfd_vma) 0)))
4505 irel->r_type = howto->type;
4506 irel->r_size = howto->bitsize - 1;
4507 if (howto->complain_on_overflow == complain_overflow_signed)
4508 irel->r_size |= 0x80;
4510 ++output_section->reloc_count;
4515 /* Sort relocs by VMA. This is called via qsort. */
4518 xcoff_sort_relocs (p1, p2)
4522 const struct internal_reloc *r1 = (const struct internal_reloc *) p1;
4523 const struct internal_reloc *r2 = (const struct internal_reloc *) p2;
4525 if (r1->r_vaddr > r2->r_vaddr)
4527 else if (r1->r_vaddr < r2->r_vaddr)
4533 /* This is the relocation function for the RS/6000/POWER/PowerPC.
4534 This is currently the only processor which uses XCOFF; I hope that
4535 will never change. */
4538 _bfd_ppc_xcoff_relocate_section (output_bfd, info, input_bfd,
4539 input_section, contents, relocs, syms,
4542 struct bfd_link_info *info;
4544 asection *input_section;
4546 struct internal_reloc *relocs;
4547 struct internal_syment *syms;
4548 asection **sections;
4550 struct internal_reloc *rel;
4551 struct internal_reloc *relend;
4554 relend = rel + input_section->reloc_count;
4555 for (; rel < relend; rel++)
4558 struct xcoff_link_hash_entry *h;
4559 struct internal_syment *sym;
4562 struct reloc_howto_struct howto;
4563 bfd_reloc_status_type rstat;
4565 /* Relocation type R_REF is a special relocation type which is
4566 merely used to prevent garbage collection from occurring for
4567 the csect including the symbol which it references. */
4568 if (rel->r_type == R_REF)
4571 symndx = rel->r_symndx;
4581 h = obj_xcoff_sym_hashes (input_bfd)[symndx];
4582 sym = syms + symndx;
4583 addend = - sym->n_value;
4586 /* We build the howto information on the fly. */
4588 howto.type = rel->r_type;
4589 howto.rightshift = 0;
4591 howto.bitsize = (rel->r_size & 0x1f) + 1;
4592 howto.pc_relative = false;
4594 if ((rel->r_size & 0x80) != 0)
4595 howto.complain_on_overflow = complain_overflow_signed;
4597 howto.complain_on_overflow = complain_overflow_bitfield;
4598 howto.special_function = NULL;
4599 howto.name = "internal";
4600 howto.partial_inplace = true;
4601 if (howto.bitsize == 32)
4602 howto.src_mask = howto.dst_mask = 0xffffffff;
4605 howto.src_mask = howto.dst_mask = (1 << howto.bitsize) - 1;
4606 if (howto.bitsize == 16)
4609 howto.pcrel_offset = false;
4619 sec = bfd_abs_section_ptr;
4624 sec = sections[symndx];
4625 val = (sec->output_section->vma
4626 + sec->output_offset
4633 if (h->root.type == bfd_link_hash_defined
4634 || h->root.type == bfd_link_hash_defweak)
4638 sec = h->root.u.def.section;
4639 val = (h->root.u.def.value
4640 + sec->output_section->vma
4641 + sec->output_offset);
4643 else if ((h->flags & XCOFF_REF_DYNAMIC) != 0
4644 || (h->flags & XCOFF_IMPORT) != 0)
4646 /* Every symbol in a shared object is defined somewhere. */
4649 else if (! info->relocateable)
4651 if (! ((*info->callbacks->undefined_symbol)
4652 (info, h->root.root.string, input_bfd, input_section,
4653 rel->r_vaddr - input_section->vma)))
4658 /* I took the relocation type definitions from two documents:
4659 the PowerPC AIX Version 4 Application Binary Interface, First
4660 Edition (April 1992), and the PowerOpen ABI, Big-Endian
4661 32-Bit Hardware Implementation (June 30, 1994). Differences
4662 between the documents are noted below. */
4664 switch (rel->r_type)
4669 /* These relocs are defined by the PowerPC ABI to be
4670 relative branches which use half of the difference
4671 between the symbol and the program counter. I can't
4672 quite figure out when this is useful. These relocs are
4673 not defined by the PowerOpen ABI. */
4675 (*_bfd_error_handler)
4676 ("%s: unsupported relocation type 0x%02x",
4677 bfd_get_filename (input_bfd), (unsigned int) rel->r_type);
4678 bfd_set_error (bfd_error_bad_value);
4681 /* Simple positive relocation. */
4684 /* Simple negative relocation. */
4688 /* Simple PC relative relocation. */
4689 howto.pc_relative = true;
4692 /* TOC relative relocation. The value in the instruction in
4693 the input file is the offset from the input file TOC to
4694 the desired location. We want the offset from the final
4695 TOC to the desired location. We have:
4700 so we must change insn by on - in.
4703 /* Global linkage relocation. The value of this relocation
4704 is the address of the entry in the TOC section. */
4706 /* Local object TOC address. I can't figure out the
4707 difference between this and case R_GL. */
4709 /* TOC relative relocation. A TOC relative load instruction
4710 which may be changed to a load address instruction.
4711 FIXME: We don't currently implement this optimization. */
4713 /* TOC relative relocation. This is a TOC relative load
4714 address instruction which may be changed to a load
4715 instruction. FIXME: I don't know if this is the correct
4717 if (h != NULL && h->toc_section == NULL)
4719 (*_bfd_error_handler)
4720 ("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry",
4721 bfd_get_filename (input_bfd), rel->r_vaddr,
4722 h->root.root.string);
4723 bfd_set_error (bfd_error_bad_value);
4727 val = (h->toc_section->output_section->vma
4728 + h->toc_section->output_offset
4730 val = ((val - xcoff_data (output_bfd)->toc)
4731 - (sym->n_value - xcoff_data (input_bfd)->toc));
4735 /* Absolute branch. We don't want to mess with the lower
4736 two bits of the instruction. */
4738 /* The PowerPC ABI defines this as an absolute call which
4739 may be modified to become a relative call. The PowerOpen
4740 ABI does not define this relocation type. */
4742 /* Absolute branch which may be modified to become a
4745 /* The PowerPC ABI defines this as an absolute branch to a
4746 fixed address which may be modified to an absolute branch
4747 to a symbol. The PowerOpen ABI does not define this
4750 /* The PowerPC ABI defines this as an absolute branch to a
4751 fixed address which may be modified to a relative branch.
4752 The PowerOpen ABI does not define this relocation type. */
4753 howto.src_mask &= ~3;
4754 howto.dst_mask = howto.src_mask;
4757 /* Relative branch. We don't want to mess with the lower
4758 two bits of the instruction. */
4760 /* The PowerPC ABI defines this as a relative call which may
4761 be modified to become an absolute call. The PowerOpen
4762 ABI does not define this relocation type. */
4764 /* A relative branch which may be modified to become an
4765 absolute branch. FIXME: We don't implement this,
4766 although we should for symbols of storage mapping class
4768 howto.pc_relative = true;
4769 howto.src_mask &= ~3;
4770 howto.dst_mask = howto.src_mask;
4773 /* The PowerPC AIX ABI describes this as a load which may be
4774 changed to a load address. The PowerOpen ABI says this
4775 is the same as case R_POS. */
4778 /* The PowerPC AIX ABI describes this as a load address
4779 which may be changed to a load. The PowerOpen ABI says
4780 this is the same as R_POS. */
4784 /* If we see an R_BR or R_RBR reloc which is jumping to global
4785 linkage code, and it is followed by an appropriate cror nop
4786 instruction, we replace the cror with lwz r2,20(r1). This
4787 restores the TOC after the glink code. Contrariwise, if the
4788 call is followed by a lwz r2,20(r1), but the call is not
4789 going to global linkage code, we can replace the load with a
4791 if ((rel->r_type == R_BR || rel->r_type == R_RBR)
4793 && h->root.type == bfd_link_hash_defined
4794 && (rel->r_vaddr - input_section->vma + 8
4795 <= input_section->_cooked_size))
4800 pnext = contents + (rel->r_vaddr - input_section->vma) + 4;
4801 next = bfd_get_32 (input_bfd, pnext);
4802 if (h->smclas == XMC_GL)
4804 if (next == 0x4def7b82 /* cror 15,15,15 */
4805 || next == 0x4ffffb82) /* cror 31,31,31 */
4806 bfd_put_32 (input_bfd, 0x80410014, pnext); /* lwz r1,20(r1) */
4810 if (next == 0x80410014) /* lwz r1,20(r1) */
4811 bfd_put_32 (input_bfd, 0x4ffffb82, pnext); /* cror 31,31,31 */
4815 /* A PC relative reloc includes the section address. */
4816 if (howto.pc_relative)
4817 addend += input_section->vma;
4819 rstat = _bfd_final_link_relocate (&howto, input_bfd, input_section,
4821 rel->r_vaddr - input_section->vma,
4830 case bfd_reloc_overflow:
4833 char buf[SYMNMLEN + 1];
4834 char howto_name[10];
4839 name = h->root.root.string;
4842 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
4846 sprintf (howto_name, "0x%02x", rel->r_type);
4848 if (! ((*info->callbacks->reloc_overflow)
4849 (info, name, howto_name, (bfd_vma) 0, input_bfd,
4850 input_section, rel->r_vaddr - input_section->vma)))