1 /* POWER/PowerPC XCOFF linker support.
2 Copyright 1995 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>, Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "coff/internal.h"
28 /* This file holds the XCOFF linker code. */
30 #define STRING_SIZE_SIZE (4)
32 /* Get the XCOFF hash table entries for a BFD. */
33 #define obj_xcoff_sym_hashes(bfd) \
34 ((struct xcoff_link_hash_entry **) obj_coff_sym_hashes (bfd))
36 /* XCOFF relocation types. These probably belong in a header file
37 somewhere. The relocations are described in the function
38 _bfd_ppc_xcoff_relocate_section in this file. */
54 #define R_RRTBI (0x14)
55 #define R_RRTBA (0x15)
63 /* The first word of global linkage code. This must be modified by
64 filling in the correct TOC offset. */
66 #define XCOFF_GLINK_FIRST (0x81820000) /* lwz r12,0(r2) */
68 /* The remaining words of global linkage code. */
70 static unsigned long xcoff_glink_code[] =
72 0x90410014, /* stw r2,20(r1) */
73 0x800c0000, /* lwz r0,0(r12) */
74 0x804c0004, /* lwz r2,4(r12) */
75 0x7c0903a6, /* mtctr r0 */
76 0x4e800420, /* bctr */
77 0x0, /* start of traceback table */
78 0x000c8000, /* traceback table */
79 0x0 /* traceback table */
82 #define XCOFF_GLINK_SIZE \
83 (((sizeof xcoff_glink_code / sizeof xcoff_glink_code[0]) * 4) + 4)
85 /* We reuse the SEC_ROM flag as a mark flag for garbage collection.
86 This flag will only be used on input sections. */
88 #define SEC_MARK (SEC_ROM)
90 /* The ldhdr structure. This appears at the start of the .loader
95 /* The version number: currently always 1. */
96 unsigned long l_version;
97 /* The number of symbol table entries. */
98 bfd_size_type l_nsyms;
99 /* The number of relocation table entries. */
100 bfd_size_type l_nreloc;
101 /* The length of the import file string table. */
102 bfd_size_type l_istlen;
103 /* The number of import files. */
104 bfd_size_type l_nimpid;
105 /* The offset from the start of the .loader section to the first
106 entry in the import file table. */
107 bfd_size_type l_impoff;
108 /* The length of the string table. */
109 bfd_size_type l_stlen;
110 /* The offset from the start of the .loader section to the first
111 entry in the string table. */
112 bfd_size_type l_stoff;
115 struct external_ldhdr
117 bfd_byte l_version[4];
119 bfd_byte l_nreloc[4];
120 bfd_byte l_istlen[4];
121 bfd_byte l_nimpid[4];
122 bfd_byte l_impoff[4];
127 #define LDHDRSZ (8 * 4)
129 /* The ldsym structure. This is used to represent a symbol in the
132 struct internal_ldsym
136 /* The symbol name if <= SYMNMLEN characters. */
137 char _l_name[SYMNMLEN];
140 /* Zero if the symbol name is more than SYMNMLEN characters. */
142 /* The offset in the string table if the symbol name is more
143 than SYMNMLEN characters. */
147 /* The symbol value. */
149 /* The symbol section number. */
151 /* The symbol type and flags. */
153 /* The symbol storage class. */
155 /* The import file ID. */
156 bfd_size_type l_ifile;
157 /* Offset to the parameter type check string. */
158 bfd_size_type l_parm;
161 struct external_ldsym
165 bfd_byte _l_name[SYMNMLEN];
168 bfd_byte _l_zeroes[4];
169 bfd_byte _l_offset[4];
174 bfd_byte l_smtype[1];
175 bfd_byte l_smclas[1];
180 #define LDSYMSZ (8 + 3 * 4 + 2 + 2)
182 /* These flags are for the l_smtype field (the lower three bits are an
185 /* Imported symbol. */
186 #define L_IMPORT (0x40)
188 #define L_ENTRY (0x20)
189 /* Exported symbol. */
190 #define L_EXPORT (0x10)
192 /* The ldrel structure. This is used to represent a reloc in the
195 struct internal_ldrel
197 /* The reloc address. */
199 /* The symbol table index in the .loader section symbol table. */
200 bfd_size_type l_symndx;
201 /* The relocation type and size. */
203 /* The section number this relocation applies to. */
207 struct external_ldrel
210 bfd_byte l_symndx[4];
212 bfd_byte l_rsecnm[2];
215 #define LDRELSZ (2 * 4 + 2 * 2)
217 /* The list of import files. */
219 struct xcoff_import_file
221 /* The next entry in the list. */
222 struct xcoff_import_file *next;
227 /* The member name. */
231 /* An entry in the XCOFF linker hash table. */
233 struct xcoff_link_hash_entry
235 struct bfd_link_hash_entry root;
237 /* Symbol index in output file. Set to -1 initially. Set to -2 if
238 there is a reloc against this symbol. */
241 /* If we have created a TOC entry for this symbol, this is the .tc
242 section which holds it. */
243 asection *toc_section;
247 /* If we have created a TOC entry (the XCOFF_SET_TOC flag is
248 set), this is the offset in toc_section. */
250 /* If the TOC entry comes from an input file, this is set to the
251 symbo lindex of the C_HIDEXT XMC_TC symbol. */
255 /* If this symbol is a function entry point which is called, this
256 field holds a pointer to the function descriptor. */
257 struct xcoff_link_hash_entry *descriptor;
259 /* The .loader symbol table entry, if there is one. */
260 struct internal_ldsym *ldsym;
262 /* The .loader symbol table index. */
265 /* Some linker flags. */
266 unsigned short flags;
267 /* Symbol is referenced by a regular object. */
268 #define XCOFF_REF_REGULAR (01)
269 /* Symbol is defined by a regular object. */
270 #define XCOFF_DEF_REGULAR (02)
271 /* Symbol is referenced by a dynamic object. */
272 #define XCOFF_REF_DYNAMIC (04)
273 /* Symbol is used in a reloc being copied into the .loader section. */
274 #define XCOFF_LDREL (010)
275 /* Symbol is the entry point. */
276 #define XCOFF_ENTRY (020)
277 /* Symbol is called; this is, it appears in a R_BR reloc. */
278 #define XCOFF_CALLED (040)
279 /* Symbol needs the TOC entry filled in. */
280 #define XCOFF_SET_TOC (0100)
281 /* Symbol is explicitly imported. */
282 #define XCOFF_IMPORT (0200)
283 /* Symbol is explicitly exported. */
284 #define XCOFF_EXPORT (0400)
285 /* Symbol has been processed by xcoff_build_ldsyms. */
286 #define XCOFF_BUILT_LDSYM (01000)
287 /* Symbol is mentioned by a section which was not garbage collected. */
288 #define XCOFF_MARK (02000)
289 /* Symbol size is recorded in size_list list from hash table. */
290 #define XCOFF_HAS_SIZE (04000)
292 /* The storage mapping class. */
293 unsigned char smclas;
296 /* The XCOFF linker hash table. */
298 struct xcoff_link_hash_table
300 struct bfd_link_hash_table root;
302 /* The .debug string hash table. We need to compute this while
303 reading the input files, so that we know how large the .debug
304 section will be before we assign section positions. */
305 struct bfd_strtab_hash *debug_strtab;
307 /* The .debug section we will use for the final output. */
308 asection *debug_section;
310 /* The .loader section we will use for the final output. */
311 asection *loader_section;
313 /* A count of non TOC relative relocs which will need to be
314 allocated in the .loader section. */
317 /* The .loader section header. */
318 struct internal_ldhdr ldhdr;
320 /* The .gl section we use to hold global linkage code. */
321 asection *linkage_section;
323 /* The .tc section we use to hold toc entries we build for global
325 asection *toc_section;
327 /* The list of import files. */
328 struct xcoff_import_file *imports;
330 /* Required alignment of sections within the output file. */
331 unsigned long file_align;
333 /* Whether the .text section must be read-only. */
336 /* Whether garbage collection was done. */
339 /* A linked list of symbols for which we have size information. */
340 struct xcoff_link_size_list
342 struct xcoff_link_size_list *next;
343 struct xcoff_link_hash_entry *h;
348 /* Information we keep for each section in the output file during the
351 struct xcoff_link_section_info
353 /* The relocs to be output. */
354 struct internal_reloc *relocs;
355 /* For each reloc against a global symbol whose index was not known
356 when the reloc was handled, the global hash table entry. */
357 struct xcoff_link_hash_entry **rel_hashes;
358 /* If there is a TOC relative reloc against a global symbol, and the
359 index of the TOC symbol is not known when the reloc was handled,
360 an entry is added to this linked list. This is not an array,
361 like rel_hashes, because this case is quite uncommon. */
362 struct xcoff_toc_rel_hash
364 struct xcoff_toc_rel_hash *next;
365 struct xcoff_link_hash_entry *h;
366 struct internal_reloc *rel;
370 /* Information that we pass around while doing the final link step. */
372 struct xcoff_final_link_info
374 /* General link information. */
375 struct bfd_link_info *info;
378 /* Hash table for long symbol names. */
379 struct bfd_strtab_hash *strtab;
380 /* Array of information kept for each output section, indexed by the
381 target_index field. */
382 struct xcoff_link_section_info *section_info;
383 /* Symbol index of last C_FILE symbol (-1 if none). */
384 long last_file_index;
385 /* Contents of last C_FILE symbol. */
386 struct internal_syment last_file;
387 /* Symbol index of TOC symbol. */
389 /* Start of .loader symbols. */
390 struct external_ldsym *ldsym;
391 /* Next .loader reloc to swap out. */
392 struct external_ldrel *ldrel;
393 /* File position of start of line numbers. */
394 file_ptr line_filepos;
395 /* Buffer large enough to hold swapped symbols of any input file. */
396 struct internal_syment *internal_syms;
397 /* Buffer large enough to hold output indices of symbols of any
400 /* Buffer large enough to hold output symbols for any input file. */
402 /* Buffer large enough to hold external line numbers for any input
405 /* Buffer large enough to hold any input section. */
407 /* Buffer large enough to hold external relocs of any input section. */
408 bfd_byte *external_relocs;
411 static void xcoff_swap_ldhdr_out
412 PARAMS ((bfd *, const struct internal_ldhdr *, struct external_ldhdr *));
413 static void xcoff_swap_ldsym_out
414 PARAMS ((bfd *, const struct internal_ldsym *, struct external_ldsym *));
415 static void xcoff_swap_ldrel_out
416 PARAMS ((bfd *, const struct internal_ldrel *, struct external_ldrel *));
417 static struct bfd_hash_entry *xcoff_link_hash_newfunc
418 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
419 static struct internal_reloc *xcoff_read_internal_relocs
420 PARAMS ((bfd *, asection *, boolean, bfd_byte *, boolean,
421 struct internal_reloc *));
422 static boolean xcoff_link_add_object_symbols
423 PARAMS ((bfd *, struct bfd_link_info *));
424 static boolean xcoff_link_check_archive_element
425 PARAMS ((bfd *, struct bfd_link_info *, boolean *));
426 static boolean xcoff_link_check_ar_symbols
427 PARAMS ((bfd *, struct bfd_link_info *, boolean *));
428 static bfd_size_type xcoff_find_reloc
429 PARAMS ((struct internal_reloc *, bfd_size_type, bfd_vma));
430 static boolean xcoff_link_add_symbols PARAMS ((bfd *, struct bfd_link_info *));
431 static boolean xcoff_link_add_dynamic_symbols
432 PARAMS ((bfd *, struct bfd_link_info *));
433 static boolean xcoff_mark PARAMS ((struct bfd_link_info *, asection *));
434 static void xcoff_sweep PARAMS ((struct bfd_link_info *));
435 static boolean xcoff_build_ldsyms
436 PARAMS ((struct xcoff_link_hash_entry *, PTR));
437 static boolean xcoff_link_input_bfd
438 PARAMS ((struct xcoff_final_link_info *, bfd *));
439 static boolean xcoff_write_global_symbol
440 PARAMS ((struct xcoff_link_hash_entry *, PTR));
441 static boolean xcoff_reloc_link_order
442 PARAMS ((bfd *, struct xcoff_final_link_info *, asection *,
443 struct bfd_link_order *));
444 static int xcoff_sort_relocs PARAMS ((const PTR, const PTR));
446 /* Routines to swap information in the XCOFF .loader section. We only
447 need to swap this information out, not in. I believe that only the
448 loader needs to swap this information in. If we ever need to write
449 an XCOFF loader, this stuff will need to be moved to another file
450 shared by the linker (which XCOFF calls the ``binder'') and the
453 /* Swap out the ldhdr structure. */
456 xcoff_swap_ldhdr_out (abfd, src, dst)
458 const struct internal_ldhdr *src;
459 struct external_ldhdr *dst;
461 bfd_put_32 (abfd, src->l_version, dst->l_version);
462 bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
463 bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
464 bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
465 bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
466 bfd_put_32 (abfd, src->l_impoff, dst->l_impoff);
467 bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
468 bfd_put_32 (abfd, src->l_stoff, dst->l_stoff);
471 /* Swap out the ldsym structure. */
474 xcoff_swap_ldsym_out (abfd, src, dst)
476 const struct internal_ldsym *src;
477 struct external_ldsym *dst;
479 if (src->_l._l_l._l_zeroes != 0)
480 memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
483 bfd_put_32 (abfd, 0, dst->_l._l_l._l_zeroes);
484 bfd_put_32 (abfd, src->_l._l_l._l_offset, dst->_l._l_l._l_offset);
486 bfd_put_32 (abfd, src->l_value, dst->l_value);
487 bfd_put_16 (abfd, src->l_scnum, dst->l_scnum);
488 bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
489 bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
490 bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
491 bfd_put_32 (abfd, src->l_parm, dst->l_parm);
494 /* Swap out the ldrel structure. */
497 xcoff_swap_ldrel_out (abfd, src, dst)
499 const struct internal_ldrel *src;
500 struct external_ldrel *dst;
502 bfd_put_32 (abfd, src->l_vaddr, dst->l_vaddr);
503 bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
504 bfd_put_16 (abfd, src->l_rtype, dst->l_rtype);
505 bfd_put_16 (abfd, src->l_rsecnm, dst->l_rsecnm);
508 /* Routine to create an entry in an XCOFF link hash table. */
510 static struct bfd_hash_entry *
511 xcoff_link_hash_newfunc (entry, table, string)
512 struct bfd_hash_entry *entry;
513 struct bfd_hash_table *table;
516 struct xcoff_link_hash_entry *ret = (struct xcoff_link_hash_entry *) entry;
518 /* Allocate the structure if it has not already been allocated by a
520 if (ret == (struct xcoff_link_hash_entry *) NULL)
521 ret = ((struct xcoff_link_hash_entry *)
522 bfd_hash_allocate (table, sizeof (struct xcoff_link_hash_entry)));
523 if (ret == (struct xcoff_link_hash_entry *) NULL)
525 bfd_set_error (bfd_error_no_memory);
526 return (struct bfd_hash_entry *) ret;
529 /* Call the allocation method of the superclass. */
530 ret = ((struct xcoff_link_hash_entry *)
531 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
535 /* Set local fields. */
537 ret->toc_section = NULL;
538 ret->u.toc_indx = -1;
539 ret->descriptor = NULL;
543 ret->smclas = XMC_UA;
546 return (struct bfd_hash_entry *) ret;
549 /* Create a XCOFF link hash table. */
551 struct bfd_link_hash_table *
552 _bfd_xcoff_bfd_link_hash_table_create (abfd)
555 struct xcoff_link_hash_table *ret;
557 ret = ((struct xcoff_link_hash_table *)
558 bfd_alloc (abfd, sizeof (struct xcoff_link_hash_table)));
559 if (ret == (struct xcoff_link_hash_table *) NULL)
561 bfd_set_error (bfd_error_no_memory);
562 return (struct bfd_link_hash_table *) NULL;
564 if (! _bfd_link_hash_table_init (&ret->root, abfd, xcoff_link_hash_newfunc))
566 bfd_release (abfd, ret);
567 return (struct bfd_link_hash_table *) NULL;
570 ret->debug_strtab = _bfd_xcoff_stringtab_init ();
571 ret->debug_section = NULL;
572 ret->loader_section = NULL;
573 ret->ldrel_count = 0;
574 memset (&ret->ldhdr, 0, sizeof (struct internal_ldhdr));
575 ret->linkage_section = NULL;
576 ret->toc_section = NULL;
585 /* Look up an entry in an XCOFF link hash table. */
587 #define xcoff_link_hash_lookup(table, string, create, copy, follow) \
588 ((struct xcoff_link_hash_entry *) \
589 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy),\
592 /* Traverse an XCOFF link hash table. */
594 #define xcoff_link_hash_traverse(table, func, info) \
595 (bfd_link_hash_traverse \
597 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
600 /* Get the XCOFF link hash table from the info structure. This is
603 #define xcoff_hash_table(p) ((struct xcoff_link_hash_table *) ((p)->hash))
605 /* Read internal relocs for an XCOFF csect. This is a wrapper around
606 _bfd_coff_read_internal_relocs which tries to take advantage of any
607 relocs which may have been cached for the enclosing section. */
609 static struct internal_reloc *
610 xcoff_read_internal_relocs (abfd, sec, cache, external_relocs,
611 require_internal, internal_relocs)
615 bfd_byte *external_relocs;
616 boolean require_internal;
617 struct internal_reloc *internal_relocs;
619 if (coff_section_data (abfd, sec) != NULL
620 && coff_section_data (abfd, sec)->relocs == NULL
621 && xcoff_section_data (abfd, sec) != NULL)
625 enclosing = xcoff_section_data (abfd, sec)->enclosing;
627 if (enclosing != NULL
628 && (coff_section_data (abfd, enclosing) == NULL
629 || coff_section_data (abfd, enclosing)->relocs == NULL)
631 && enclosing->reloc_count > 0)
633 if (_bfd_coff_read_internal_relocs (abfd, enclosing, true,
634 external_relocs, false,
635 (struct internal_reloc *) NULL)
640 if (enclosing != NULL
641 && coff_section_data (abfd, enclosing) != NULL
642 && coff_section_data (abfd, enclosing)->relocs != NULL)
646 off = ((sec->rel_filepos - enclosing->rel_filepos)
647 / bfd_coff_relsz (abfd));
648 if (! require_internal)
649 return coff_section_data (abfd, enclosing)->relocs + off;
650 memcpy (internal_relocs,
651 coff_section_data (abfd, enclosing)->relocs + off,
652 sec->reloc_count * sizeof (struct internal_reloc));
653 return internal_relocs;
657 return _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
658 require_internal, internal_relocs);
661 /* Given an XCOFF BFD, add symbols to the global hash table as
665 _bfd_xcoff_bfd_link_add_symbols (abfd, info)
667 struct bfd_link_info *info;
669 switch (bfd_get_format (abfd))
672 return xcoff_link_add_object_symbols (abfd, info);
674 return (_bfd_generic_link_add_archive_symbols
675 (abfd, info, xcoff_link_check_archive_element));
677 bfd_set_error (bfd_error_wrong_format);
682 /* Add symbols from an XCOFF object file. */
685 xcoff_link_add_object_symbols (abfd, info)
687 struct bfd_link_info *info;
689 if (! _bfd_coff_get_external_symbols (abfd))
691 if (! xcoff_link_add_symbols (abfd, info))
693 if (! info->keep_memory)
695 if (! _bfd_coff_free_symbols (abfd))
701 /* Check a single archive element to see if we need to include it in
702 the link. *PNEEDED is set according to whether this element is
703 needed in the link or not. This is called via
704 _bfd_generic_link_add_archive_symbols. */
707 xcoff_link_check_archive_element (abfd, info, pneeded)
709 struct bfd_link_info *info;
712 if (! _bfd_coff_get_external_symbols (abfd))
715 if (! xcoff_link_check_ar_symbols (abfd, info, pneeded))
720 if (! xcoff_link_add_symbols (abfd, info))
724 if (! info->keep_memory || ! *pneeded)
726 if (! _bfd_coff_free_symbols (abfd))
733 /* Look through the symbols to see if this object file should be
734 included in the link. */
737 xcoff_link_check_ar_symbols (abfd, info, pneeded)
739 struct bfd_link_info *info;
742 bfd_size_type symesz;
748 symesz = bfd_coff_symesz (abfd);
749 esym = (bfd_byte *) obj_coff_external_syms (abfd);
750 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
751 while (esym < esym_end)
753 struct internal_syment sym;
755 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
757 if (sym.n_sclass == C_EXT && sym.n_scnum != N_UNDEF)
760 char buf[SYMNMLEN + 1];
761 struct bfd_link_hash_entry *h;
763 /* This symbol is externally visible, and is defined by this
766 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
769 h = bfd_link_hash_lookup (info->hash, name, false, false, true);
771 /* We are only interested in symbols that are currently
772 undefined. If a symbol is currently known to be common,
773 XCOFF linkers do not bring in an object file which
774 defines it. We also don't bring in symbols to satisfy
775 undefined references in shared objects. */
776 if (h != (struct bfd_link_hash_entry *) NULL
777 && h->type == bfd_link_hash_undefined)
779 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
786 esym += (sym.n_numaux + 1) * symesz;
789 /* We do not need this object file. */
793 /* Returns the index of reloc in RELOCS with the least address greater
794 than or equal to ADDRESS. The relocs are sorted by address. */
797 xcoff_find_reloc (relocs, count, address)
798 struct internal_reloc *relocs;
802 bfd_size_type min, max, this;
810 /* Do a binary search over (min,max]. */
811 while (min + 1 < max)
815 this = (max + min) / 2;
816 raddr = relocs[this].r_vaddr;
819 else if (raddr < address)
828 if (relocs[min].r_vaddr < address)
832 && relocs[min - 1].r_vaddr == address)
838 /* Add all the symbols from an object file to the hash table.
840 XCOFF is a weird format. A normal XCOFF .o files will have three
841 COFF sections--.text, .data, and .bss--but each COFF section will
842 contain many csects. These csects are described in the symbol
843 table. From the linker's point of view, each csect must be
844 considered a section in its own right. For example, a TOC entry is
845 handled as a small XMC_TC csect. The linker must be able to merge
846 different TOC entries together, which means that it must be able to
847 extract the XMC_TC csects from the .data section of the input .o
850 From the point of view of our linker, this is, of course, a hideous
851 nightmare. We cope by actually creating sections for each csect,
852 and discarding the original sections. We then have to handle the
853 relocation entries carefully, since the only way to tell which
854 csect they belong to is to examine the address. */
857 xcoff_link_add_symbols (abfd, info)
859 struct bfd_link_info *info;
861 unsigned int n_tmask;
862 unsigned int n_btshft;
863 boolean default_copy;
864 bfd_size_type symcount;
865 struct xcoff_link_hash_entry **sym_hash;
866 asection **csect_cache;
867 bfd_size_type linesz;
871 unsigned int csect_index;
872 asection *first_csect;
873 bfd_size_type symesz;
876 struct reloc_info_struct
878 struct internal_reloc *relocs;
881 } *reloc_info = NULL;
883 if ((abfd->flags & DYNAMIC) != 0
884 && ! info->static_link)
885 return xcoff_link_add_dynamic_symbols (abfd, info);
887 n_tmask = coff_data (abfd)->local_n_tmask;
888 n_btshft = coff_data (abfd)->local_n_btshft;
890 /* Define macros so that ISFCN, et. al., macros work correctly. */
891 #define N_TMASK n_tmask
892 #define N_BTSHFT n_btshft
894 /* We need to build a .loader section, so we do it here. This won't
895 work if we're producing an XCOFF output file with no non dynamic
896 XCOFF input files. FIXME. */
897 if (xcoff_hash_table (info)->loader_section == NULL)
901 lsec = bfd_make_section_anyway (abfd, ".loader");
904 xcoff_hash_table (info)->loader_section = lsec;
905 lsec->flags |= SEC_HAS_CONTENTS | SEC_IN_MEMORY;
907 /* Likewise for the linkage section. */
908 if (xcoff_hash_table (info)->linkage_section == NULL)
912 lsec = bfd_make_section_anyway (abfd, ".gl");
915 xcoff_hash_table (info)->linkage_section = lsec;
916 lsec->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
918 /* Likewise for the TOC section. */
919 if (xcoff_hash_table (info)->toc_section == NULL)
923 tsec = bfd_make_section_anyway (abfd, ".tc");
926 xcoff_hash_table (info)->toc_section = tsec;
927 tsec->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
929 /* Likewise for the .debug section. */
930 if (xcoff_hash_table (info)->debug_section == NULL)
934 dsec = bfd_make_section_anyway (abfd, ".debug");
937 xcoff_hash_table (info)->debug_section = dsec;
938 dsec->flags |= SEC_HAS_CONTENTS | SEC_IN_MEMORY;
941 if (info->keep_memory)
942 default_copy = false;
946 symcount = obj_raw_syment_count (abfd);
948 /* We keep a list of the linker hash table entries that correspond
949 to each external symbol. */
950 sym_hash = ((struct xcoff_link_hash_entry **)
953 * sizeof (struct xcoff_link_hash_entry *))));
954 if (sym_hash == NULL && symcount != 0)
956 bfd_set_error (bfd_error_no_memory);
959 coff_data (abfd)->sym_hashes = (struct coff_link_hash_entry **) sym_hash;
961 (size_t) symcount * sizeof (struct xcoff_link_hash_entry *));
963 /* Because of the weird stuff we are doing with XCOFF csects, we can
964 not easily determine which section a symbol is in, so we store
965 the information in the tdata for the input file. */
966 csect_cache = ((asection **)
967 bfd_alloc (abfd, symcount * sizeof (asection *)));
968 if (csect_cache == NULL && symcount != 0)
970 bfd_set_error (bfd_error_no_memory);
973 xcoff_data (abfd)->csects = csect_cache;
974 memset (csect_cache, 0, (size_t) symcount * sizeof (asection *));
976 /* While splitting sections into csects, we need to assign the
977 relocs correctly. The relocs and the csects must both be in
978 order by VMA within a given section, so we handle this by
979 scanning along the relocs as we process the csects. We index
980 into reloc_info using the section target_index. */
981 reloc_info = ((struct reloc_info_struct *)
982 malloc ((abfd->section_count + 1)
983 * sizeof (struct reloc_info_struct)));
984 if (reloc_info == NULL)
986 bfd_set_error (bfd_error_no_memory);
989 memset ((PTR) reloc_info, 0,
990 (abfd->section_count + 1) * sizeof (struct reloc_info_struct));
992 /* Read in the relocs and line numbers for each section. */
993 linesz = bfd_coff_linesz (abfd);
994 for (sub = abfd->sections; sub != NULL; sub = sub->next)
996 if ((sub->flags & SEC_RELOC) != 0)
998 reloc_info[sub->target_index].relocs =
999 xcoff_read_internal_relocs (abfd, sub, true, (bfd_byte *) NULL,
1000 false, (struct internal_reloc *) NULL);
1001 reloc_info[sub->target_index].csects =
1002 (asection **) malloc (sub->reloc_count * sizeof (asection *));
1003 if (reloc_info[sub->target_index].csects == NULL)
1005 bfd_set_error (bfd_error_no_memory);
1008 memset (reloc_info[sub->target_index].csects, 0,
1009 sub->reloc_count * sizeof (asection *));
1012 if ((info->strip == strip_none || info->strip == strip_some)
1013 && sub->lineno_count > 0)
1017 linenos = (bfd_byte *) malloc (sub->lineno_count * linesz);
1018 if (linenos == NULL)
1020 bfd_set_error (bfd_error_no_memory);
1023 reloc_info[sub->target_index].linenos = linenos;
1024 if (bfd_seek (abfd, sub->line_filepos, SEEK_SET) != 0
1025 || (bfd_read (linenos, linesz, sub->lineno_count, abfd)
1026 != linesz * sub->lineno_count))
1031 /* Don't let the linker relocation routines discard the symbols. */
1032 keep_syms = obj_coff_keep_syms (abfd);
1033 obj_coff_keep_syms (abfd) = true;
1039 symesz = bfd_coff_symesz (abfd);
1040 BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
1041 esym = (bfd_byte *) obj_coff_external_syms (abfd);
1042 esym_end = esym + symcount * symesz;
1043 while (esym < esym_end)
1045 struct internal_syment sym;
1046 union internal_auxent aux;
1048 char buf[SYMNMLEN + 1];
1053 struct xcoff_link_hash_entry *set_toc;
1055 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
1057 /* In this pass we are only interested in symbols with csect
1059 if (sym.n_sclass != C_EXT && sym.n_sclass != C_HIDEXT)
1061 if (sym.n_sclass == C_FILE && csect != NULL)
1063 xcoff_section_data (abfd, csect)->last_symndx =
1065 - (bfd_byte *) obj_coff_external_syms (abfd))
1071 *csect_cache = csect;
1072 else if (first_csect == NULL || sym.n_sclass == C_FILE)
1073 *csect_cache = coff_section_from_bfd_index (abfd, sym.n_scnum);
1075 *csect_cache = NULL;
1076 esym += (sym.n_numaux + 1) * symesz;
1077 sym_hash += sym.n_numaux + 1;
1078 csect_cache += sym.n_numaux + 1;
1082 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
1086 /* If this symbol has line number information attached to it,
1087 and we're not stripping it, count the number of entries and
1088 add them to the count for this csect. In the final link pass
1089 we are going to attach line number information by symbol,
1090 rather than by section, in order to more easily handle
1091 garbage collection. */
1092 if ((info->strip == strip_none || info->strip == strip_some)
1095 && ISFCN (sym.n_type))
1097 union internal_auxent auxlin;
1099 bfd_coff_swap_aux_in (abfd, (PTR) (esym + symesz),
1100 sym.n_type, sym.n_sclass,
1101 0, sym.n_numaux, (PTR) &auxlin);
1102 if (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
1104 asection *enclosing;
1105 bfd_size_type linoff;
1107 enclosing = xcoff_section_data (abfd, csect)->enclosing;
1108 if (enclosing == NULL)
1110 (*_bfd_error_handler)
1111 ("%s: `%s' has line numbers but no enclosing section",
1112 bfd_get_filename (abfd), name);
1113 bfd_set_error (bfd_error_bad_value);
1116 linoff = (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr
1117 - enclosing->line_filepos);
1118 if (linoff < enclosing->lineno_count * linesz)
1120 struct internal_lineno lin;
1121 bfd_byte *linpstart;
1123 linpstart = (reloc_info[enclosing->target_index].linenos
1125 bfd_coff_swap_lineno_in (abfd, (PTR) linpstart, (PTR) &lin);
1127 && ((bfd_size_type) lin.l_addr.l_symndx
1129 - (bfd_byte *) obj_coff_external_syms (abfd))
1132 bfd_byte *linpend, *linp;
1134 linpend = (reloc_info[enclosing->target_index].linenos
1135 + enclosing->lineno_count * linesz);
1136 for (linp = linpstart + linesz;
1140 bfd_coff_swap_lineno_in (abfd, (PTR) linp,
1142 if (lin.l_lnno == 0)
1145 csect->lineno_count += (linp - linpstart) / linesz;
1146 /* The setting of line_filepos will only be
1147 useful if all the line number entries for a
1148 csect are contiguous; this only matters for
1150 if (csect->line_filepos == 0)
1151 csect->line_filepos =
1152 auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr;
1158 /* Pick up the csect auxiliary information. */
1160 if (sym.n_numaux == 0)
1162 (*_bfd_error_handler)
1163 ("%s: class %d symbol `%s' has no aux entries",
1164 bfd_get_filename (abfd), sym.n_sclass, name);
1165 bfd_set_error (bfd_error_bad_value);
1169 bfd_coff_swap_aux_in (abfd,
1170 (PTR) (esym + symesz * sym.n_numaux),
1171 sym.n_type, sym.n_sclass,
1172 sym.n_numaux - 1, sym.n_numaux,
1175 smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
1185 (*_bfd_error_handler)
1186 ("%s: symbol `%s' has unrecognized csect type %d",
1187 bfd_get_filename (abfd), name, smtyp);
1188 bfd_set_error (bfd_error_bad_value);
1192 /* This is an external reference. */
1193 if (sym.n_sclass == C_HIDEXT
1194 || sym.n_scnum != N_UNDEF
1195 || aux.x_csect.x_scnlen.l != 0)
1197 (*_bfd_error_handler)
1198 ("%s: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d",
1199 bfd_get_filename (abfd), name, sym.n_sclass, sym.n_scnum,
1200 aux.x_csect.x_scnlen.l);
1201 bfd_set_error (bfd_error_bad_value);
1204 section = bfd_und_section_ptr;
1208 /* This is a csect definition. */
1212 xcoff_section_data (abfd, csect)->last_symndx =
1214 - (bfd_byte *) obj_coff_external_syms (abfd))
1221 /* When we see a TOC anchor, we record the TOC value. */
1222 if (aux.x_csect.x_smclas == XMC_TC0)
1224 if (sym.n_sclass != C_HIDEXT
1225 || aux.x_csect.x_scnlen.l != 0)
1227 (*_bfd_error_handler)
1228 ("%s: XMC_TC0 symbol `%s' is class %d scnlen %d",
1229 bfd_get_filename (abfd), name, sym.n_sclass,
1230 aux.x_csect.x_scnlen.l);
1231 bfd_set_error (bfd_error_bad_value);
1234 xcoff_data (abfd)->toc = sym.n_value;
1237 /* We must merge TOC entries for the same symbol. We can
1238 merge two TOC entries if they are both C_HIDEXT, they
1239 both have the same name, they are both 4 bytes long, and
1240 they both have a relocation table entry for an external
1241 symbol with the same name. Unfortunately, this means
1242 that we must look through the relocations. Ick. */
1243 if (aux.x_csect.x_smclas == XMC_TC
1244 && sym.n_sclass == C_HIDEXT
1245 && aux.x_csect.x_scnlen.l == 4
1246 && info->hash->creator == abfd->xvec)
1248 asection *enclosing;
1249 struct internal_reloc *relocs;
1250 bfd_size_type relindx;
1251 struct internal_reloc *rel;
1253 enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1254 if (enclosing == NULL)
1257 relocs = reloc_info[enclosing->target_index].relocs;
1258 relindx = xcoff_find_reloc (relocs, enclosing->reloc_count,
1260 rel = relocs + relindx;
1261 if (relindx < enclosing->reloc_count
1262 && rel->r_vaddr == (bfd_vma) sym.n_value
1263 && rel->r_size == 31
1264 && rel->r_type == R_POS)
1267 struct internal_syment relsym;
1269 erelsym = ((bfd_byte *) obj_coff_external_syms (abfd)
1270 + rel->r_symndx * symesz);
1271 bfd_coff_swap_sym_in (abfd, (PTR) erelsym, (PTR) &relsym);
1272 if (relsym.n_sclass == C_EXT)
1274 const char *relname;
1275 char relbuf[SYMNMLEN + 1];
1277 struct xcoff_link_hash_entry *h;
1279 /* At this point we know that the TOC entry is
1280 for an externally visible symbol. */
1281 relname = _bfd_coff_internal_syment_name (abfd, &relsym,
1283 if (relname == NULL)
1286 /* We only merge TOC entries if the TC name is
1287 the same as the symbol name. This handles
1288 the normal case, but not common cases like
1289 SYM.P4 which gcc generates to store SYM + 4
1290 in the TOC. FIXME. */
1291 if (strcmp (name, relname) == 0)
1293 copy = (! info->keep_memory
1294 || relsym._n._n_n._n_zeroes != 0
1295 || relsym._n._n_n._n_offset == 0);
1296 h = xcoff_link_hash_lookup (xcoff_hash_table (info),
1297 relname, true, copy,
1302 /* At this point h->root.type could be
1303 bfd_link_hash_new. That should be OK,
1304 since we know for sure that we will come
1305 across this symbol as we step through the
1308 /* We store h in *sym_hash for the
1309 convenience of the relocate_section
1313 if (h->toc_section != NULL)
1315 asection **rel_csects;
1317 /* We already have a TOC entry for this
1318 symbol, so we can just ignore this
1321 reloc_info[enclosing->target_index].csects;
1322 rel_csects[relindx] = bfd_und_section_ptr;
1326 /* We are about to create a TOC entry for
1334 /* We need to create a new section. We get the name from
1335 the csect storage mapping class, so that the linker can
1336 accumulate similar csects together. */
1338 static const char *csect_name_by_class[] =
1340 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
1341 ".sv", ".bs", ".ds", ".uc", ".ti", ".tb", NULL, ".tc0",
1344 const char *csect_name;
1345 asection *enclosing;
1347 if ((aux.x_csect.x_smclas >=
1348 sizeof csect_name_by_class / sizeof csect_name_by_class[0])
1349 || csect_name_by_class[aux.x_csect.x_smclas] == NULL)
1351 (*_bfd_error_handler)
1352 ("%s: symbol `%s' has unrecognized smclas %d",
1353 bfd_get_filename (abfd), name, aux.x_csect.x_smclas);
1354 bfd_set_error (bfd_error_bad_value);
1358 csect_name = csect_name_by_class[aux.x_csect.x_smclas];
1359 csect = bfd_make_section_anyway (abfd, csect_name);
1362 enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1363 if (enclosing == NULL)
1365 if (! bfd_is_abs_section (enclosing)
1366 && ((bfd_vma) sym.n_value < enclosing->vma
1367 || ((bfd_vma) sym.n_value + aux.x_csect.x_scnlen.l
1368 > enclosing->vma + enclosing->_raw_size)))
1370 (*_bfd_error_handler)
1371 ("%s: csect `%s' not in enclosing section",
1372 bfd_get_filename (abfd), name);
1373 bfd_set_error (bfd_error_bad_value);
1376 csect->vma = sym.n_value;
1377 csect->filepos = (enclosing->filepos
1380 csect->_raw_size = aux.x_csect.x_scnlen.l;
1381 csect->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
1382 csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
1384 /* Record the enclosing section in the tdata for this new
1386 csect->used_by_bfd =
1387 ((struct coff_section_tdata *)
1388 bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
1389 if (csect->used_by_bfd == NULL)
1391 bfd_set_error (bfd_error_no_memory);
1394 coff_section_data (abfd, csect)->tdata =
1395 bfd_zalloc (abfd, sizeof (struct xcoff_section_tdata));
1396 if (coff_section_data (abfd, csect)->tdata == NULL)
1398 bfd_set_error (bfd_error_no_memory);
1401 xcoff_section_data (abfd, csect)->enclosing = enclosing;
1402 xcoff_section_data (abfd, csect)->lineno_count =
1403 enclosing->lineno_count;
1405 if (enclosing->owner == abfd)
1407 struct internal_reloc *relocs;
1408 bfd_size_type relindx;
1409 struct internal_reloc *rel;
1410 asection **rel_csect;
1412 relocs = reloc_info[enclosing->target_index].relocs;
1413 relindx = xcoff_find_reloc (relocs, enclosing->reloc_count,
1415 rel = relocs + relindx;
1416 rel_csect = (reloc_info[enclosing->target_index].csects
1418 csect->rel_filepos = (enclosing->rel_filepos
1419 + relindx * bfd_coff_relsz (abfd));
1420 while (relindx < enclosing->reloc_count
1421 && *rel_csect == NULL
1422 && rel->r_vaddr < csect->vma + csect->_raw_size)
1425 csect->flags |= SEC_RELOC;
1426 ++csect->reloc_count;
1433 /* There are a number of other fields and section flags
1434 which we do not bother to set. */
1436 csect_index = ((esym
1437 - (bfd_byte *) obj_coff_external_syms (abfd))
1440 xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1442 if (first_csect == NULL)
1443 first_csect = csect;
1445 /* If this symbol is C_EXT, we treat it as starting at the
1446 beginning of the newly created section. */
1447 if (sym.n_sclass == C_EXT)
1453 /* If this is a TOC section for a symbol, record it. */
1454 if (set_toc != NULL)
1455 set_toc->toc_section = csect;
1460 /* This is a label definition. The x_scnlen field is the
1461 symbol index of the csect. I believe that this must
1462 always follow the appropriate XTY_SD symbol, so I will
1468 if (aux.x_csect.x_scnlen.l < 0
1469 || (aux.x_csect.x_scnlen.l
1470 >= esym - (bfd_byte *) obj_coff_external_syms (abfd)))
1474 section = xcoff_data (abfd)->csects[aux.x_csect.x_scnlen.l];
1476 || (section->flags & SEC_HAS_CONTENTS) == 0)
1481 (*_bfd_error_handler)
1482 ("%s: misplaced XTY_LD `%s'",
1483 bfd_get_filename (abfd), name);
1484 bfd_set_error (bfd_error_bad_value);
1488 value = sym.n_value - csect->vma;
1493 /* This is an unitialized csect. We could base the name on
1494 the storage mapping class, but we don't bother. If this
1495 csect is externally visible, it is a common symbol. */
1499 xcoff_section_data (abfd, csect)->last_symndx =
1501 - (bfd_byte *) obj_coff_external_syms (abfd))
1505 csect = bfd_make_section_anyway (abfd, ".bss");
1508 csect->vma = sym.n_value;
1509 csect->_raw_size = aux.x_csect.x_scnlen.l;
1510 csect->flags |= SEC_ALLOC;
1511 csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
1512 /* There are a number of other fields and section flags
1513 which we do not bother to set. */
1515 csect_index = ((esym
1516 - (bfd_byte *) obj_coff_external_syms (abfd))
1519 csect->used_by_bfd =
1520 ((struct coff_section_tdata *)
1521 bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
1522 if (csect->used_by_bfd == NULL)
1524 bfd_set_error (bfd_error_no_memory);
1527 coff_section_data (abfd, csect)->tdata =
1528 bfd_zalloc (abfd, sizeof (struct xcoff_section_tdata));
1529 if (coff_section_data (abfd, csect)->tdata == NULL)
1531 bfd_set_error (bfd_error_no_memory);
1534 xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1536 if (first_csect == NULL)
1537 first_csect = csect;
1539 if (sym.n_sclass == C_EXT)
1541 csect->flags |= SEC_IS_COMMON;
1542 csect->_raw_size = 0;
1544 value = aux.x_csect.x_scnlen.l;
1550 /* Now we have enough information to add the symbol to the
1551 linker hash table. */
1553 if (sym.n_sclass == C_EXT)
1557 BFD_ASSERT (section != NULL);
1559 /* We must copy the name into memory if we got it from the
1560 syment itself, rather than the string table. */
1561 copy = default_copy;
1562 if (sym._n._n_n._n_zeroes != 0
1563 || sym._n._n_n._n_offset == 0)
1566 if (info->hash->creator == abfd->xvec)
1568 /* If we are statically linking a shared object, it is
1569 OK for symbol redefinitions to occur. I can't figure
1570 out just what the XCOFF linker is doing, but
1571 something like this is required for -bnso to work. */
1572 *sym_hash = xcoff_link_hash_lookup (xcoff_hash_table (info),
1573 name, true, copy, false);
1574 if (*sym_hash == NULL)
1576 if (((*sym_hash)->root.type == bfd_link_hash_defined
1577 || (*sym_hash)->root.type == bfd_link_hash_defweak)
1578 && ! bfd_is_und_section (section)
1579 && ! bfd_is_com_section (section))
1581 if ((abfd->flags & DYNAMIC) != 0)
1583 section = bfd_und_section_ptr;
1586 else if (((*sym_hash)->root.u.def.section->owner->flags
1589 (*sym_hash)->root.type = bfd_link_hash_undefined;
1590 (*sym_hash)->root.u.undef.abfd =
1591 (*sym_hash)->root.u.def.section->owner;
1596 if (! (_bfd_generic_link_add_one_symbol
1597 (info, abfd, name, flags, section, value,
1598 (const char *) NULL, copy, true,
1599 (struct bfd_link_hash_entry **) sym_hash)))
1602 if (smtyp == XTY_CM)
1604 if ((*sym_hash)->root.type != bfd_link_hash_common
1605 || (*sym_hash)->root.u.c.p->section != csect)
1607 /* We don't need the common csect we just created. */
1608 csect->_raw_size = 0;
1612 (*sym_hash)->root.u.c.p->alignment_power
1613 = csect->alignment_power;
1617 if (info->hash->creator == abfd->xvec)
1621 if (smtyp == XTY_ER || smtyp == XTY_CM)
1622 flag = XCOFF_REF_REGULAR;
1624 flag = XCOFF_DEF_REGULAR;
1625 (*sym_hash)->flags |= flag;
1627 if ((*sym_hash)->smclas == XMC_UA
1628 || flag == XCOFF_DEF_REGULAR)
1629 (*sym_hash)->smclas = aux.x_csect.x_smclas;
1633 *csect_cache = csect;
1635 esym += (sym.n_numaux + 1) * symesz;
1636 sym_hash += sym.n_numaux + 1;
1637 csect_cache += sym.n_numaux + 1;
1640 /* Make sure that we have seen all the relocs. */
1641 for (sub = abfd->sections; sub != first_csect; sub = sub->next)
1643 /* Reset the section size, since the data is now attached to the
1644 csects. Don't reset the size of the .debug section, since we
1645 need to read it below in bfd_xcoff_size_dynamic_sections. */
1646 if (strcmp (bfd_get_section_name (abfd, sub), ".debug") != 0)
1649 if ((sub->flags & SEC_RELOC) != 0)
1652 struct internal_reloc *rel;
1653 asection **rel_csect;
1655 rel = reloc_info[sub->target_index].relocs;
1656 rel_csect = reloc_info[sub->target_index].csects;
1657 for (i = 0; i < sub->reloc_count; i++, rel++, rel_csect++)
1659 if (*rel_csect == NULL)
1661 (*_bfd_error_handler)
1662 ("%s: reloc %s:%d not in csect",
1663 bfd_get_filename (abfd), sub->name, i);
1664 bfd_set_error (bfd_error_bad_value);
1668 /* We identify all symbols which are called, so that we
1669 can create glue code for calls to functions imported
1670 from dynamic objects. */
1671 if (info->hash->creator == abfd->xvec
1672 && *rel_csect != bfd_und_section_ptr
1673 && (rel->r_type == R_BR
1674 || rel->r_type == R_RBR)
1675 && obj_xcoff_sym_hashes (abfd)[rel->r_symndx] != NULL)
1677 struct xcoff_link_hash_entry *h;
1679 h = obj_xcoff_sym_hashes (abfd)[rel->r_symndx];
1680 h->flags |= XCOFF_CALLED;
1681 /* If the symbol name starts with a period, it is
1682 the code of a function. If the symbol is
1683 currently undefined, then add an undefined symbol
1684 for the function descriptor. This should do no
1685 harm, because any regular object that defines the
1686 function should also define the function
1687 descriptor. It helps, because it means that we
1688 will identify the function descriptor with a
1689 dynamic object if a dynamic object defines it. */
1690 if (h->root.root.string[0] == '.'
1691 && h->descriptor == NULL)
1693 struct xcoff_link_hash_entry *hds;
1695 hds = xcoff_link_hash_lookup (xcoff_hash_table (info),
1696 h->root.root.string + 1,
1700 if (hds->root.type == bfd_link_hash_new)
1702 if (! (_bfd_generic_link_add_one_symbol
1703 (info, abfd, hds->root.root.string,
1704 (flagword) 0, bfd_und_section_ptr,
1705 (bfd_vma) 0, (const char *) NULL, false,
1707 (struct bfd_link_hash_entry **) NULL)))
1710 h->descriptor = hds;
1715 free (reloc_info[sub->target_index].csects);
1716 reloc_info[sub->target_index].csects = NULL;
1718 /* Reset SEC_RELOC, the reloc_count, and the lineno_count,
1719 since the reloc and lineno information is now attached to
1721 sub->flags &=~ SEC_RELOC;
1722 sub->reloc_count = 0;
1723 sub->lineno_count = 0;
1725 /* If we are not keeping memory, free the reloc information. */
1726 if (! info->keep_memory
1727 && coff_section_data (abfd, sub) != NULL
1728 && coff_section_data (abfd, sub)->relocs != NULL
1729 && ! coff_section_data (abfd, sub)->keep_relocs)
1731 free (coff_section_data (abfd, sub)->relocs);
1732 coff_section_data (abfd, sub)->relocs = NULL;
1736 /* Free up the line numbers. FIXME: We could cache these
1737 somewhere for the final link, to avoid reading them again. */
1738 if (reloc_info[sub->target_index].linenos != NULL)
1740 free (reloc_info[sub->target_index].linenos);
1741 reloc_info[sub->target_index].linenos = NULL;
1747 obj_coff_keep_syms (abfd) = keep_syms;
1752 if (reloc_info != NULL)
1754 for (sub = abfd->sections; sub != NULL; sub = sub->next)
1756 if (reloc_info[sub->target_index].csects != NULL)
1757 free (reloc_info[sub->target_index].csects);
1758 if (reloc_info[sub->target_index].linenos != NULL)
1759 free (reloc_info[sub->target_index].linenos);
1763 obj_coff_keep_syms (abfd) = keep_syms;
1770 /* This function is used to add symbols from a dynamic object to the
1771 global symbol table. */
1774 xcoff_link_add_dynamic_symbols (abfd, info)
1776 struct bfd_link_info *info;
1778 bfd_size_type symesz;
1781 struct xcoff_import_file *n;
1786 struct xcoff_import_file **pp;
1788 /* We can only handle a dynamic object if we are generating an XCOFF
1790 if (info->hash->creator != abfd->xvec)
1792 (*_bfd_error_handler)
1793 ("%s: XCOFF shared object when not producing XCOFF output",
1794 bfd_get_filename (abfd));
1795 bfd_set_error (bfd_error_invalid_operation);
1799 /* Remove the sections from this object, so that they do not get
1800 included in the link. */
1801 abfd->sections = NULL;
1803 symesz = bfd_coff_symesz (abfd);
1804 esym = (bfd_byte *) obj_coff_external_syms (abfd);
1805 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
1806 while (esym < esym_end)
1808 struct internal_syment sym;
1810 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
1812 /* I think that every symbol mentioned in a dynamic object must
1813 be defined by that object, perhaps by importing it from
1814 another dynamic object. All we have to do is look up each
1815 external symbol. If we have already put it in the hash
1816 table, we simply set a flag indicating that it appears in a
1819 if (sym.n_sclass == C_EXT)
1822 char buf[SYMNMLEN + 1];
1823 struct xcoff_link_hash_entry *h;
1825 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
1829 /* Normally we could not xcoff_link_hash_lookup in an add
1830 symbols routine, since we might not be using an XCOFF
1831 hash table. However, we verified above that we are using
1832 an XCOFF hash table. */
1833 h = xcoff_link_hash_lookup (xcoff_hash_table (info), name,
1834 false, false, true);
1837 h->flags |= XCOFF_REF_DYNAMIC;
1839 /* If the symbol is undefined, and the current BFD is
1840 not a dynamic object, change the BFD to this dynamic
1841 object, so that we can get the correct import file
1843 if ((h->root.type == bfd_link_hash_undefined
1844 || h->root.type == bfd_link_hash_undefweak)
1845 && (h->root.u.undef.abfd == NULL
1846 || (h->root.u.undef.abfd->flags & DYNAMIC) == 0))
1847 h->root.u.undef.abfd = abfd;
1849 if (h->smclas == XMC_UA
1850 && sym.n_numaux > 0)
1852 union internal_auxent aux;
1854 bfd_coff_swap_aux_in (abfd,
1855 (PTR) (esym + symesz * sym.n_numaux),
1856 sym.n_type, sym.n_sclass,
1857 sym.n_numaux - 1, sym.n_numaux,
1859 h->smclas = aux.x_csect.x_smclas;
1864 esym += (sym.n_numaux + 1) * symesz;
1867 /* Record this file in the import files. */
1869 n = ((struct xcoff_import_file *)
1870 bfd_alloc (abfd, sizeof (struct xcoff_import_file)));
1873 bfd_set_error (bfd_error_no_memory);
1878 /* For some reason, the path entry in the import file list for a
1879 shared object appears to always be empty. The file name is the
1882 if (abfd->my_archive == NULL)
1884 bname = bfd_get_filename (abfd);
1889 bname = bfd_get_filename (abfd->my_archive);
1890 mname = bfd_get_filename (abfd);
1892 s = strrchr (bname, '/');
1898 /* We start c at 1 because the first import file number is reserved
1900 for (pp = &xcoff_hash_table (info)->imports, c = 1;
1902 pp = &(*pp)->next, ++c)
1906 xcoff_data (abfd)->import_file_id = c;
1911 /* Routines that are called after all the input files have been
1912 handled, but before the sections are laid out in memory. */
1914 /* Mark a symbol as not being garbage, including the section in which
1917 static INLINE boolean
1918 xcoff_mark_symbol (info, h)
1919 struct bfd_link_info *info;
1920 struct xcoff_link_hash_entry *h;
1922 if ((h->flags & XCOFF_MARK) != 0)
1925 h->flags |= XCOFF_MARK;
1926 if (h->root.type == bfd_link_hash_defined
1927 || h->root.type == bfd_link_hash_defweak)
1931 hsec = h->root.u.def.section;
1932 if ((hsec->flags & SEC_MARK) == 0)
1934 if (! xcoff_mark (info, hsec))
1939 if (h->toc_section != NULL
1940 && (h->toc_section->flags & SEC_MARK) == 0)
1942 if (! xcoff_mark (info, h->toc_section))
1949 /* The mark phase of garbage collection. For a given section, mark
1950 it, and all the sections which define symbols to which it refers.
1951 Because this function needs to look at the relocs, we also count
1952 the number of relocs which need to be copied into the .loader
1956 xcoff_mark (info, sec)
1957 struct bfd_link_info *info;
1960 if ((sec->flags & SEC_MARK) != 0)
1963 sec->flags |= SEC_MARK;
1965 if (sec->owner->xvec == info->hash->creator
1966 && coff_section_data (sec->owner, sec) != NULL
1967 && xcoff_section_data (sec->owner, sec) != NULL)
1969 register struct xcoff_link_hash_entry **hp, **hpend;
1970 struct internal_reloc *rel, *relend;
1972 /* Mark all the symbols in this section. */
1974 hp = (obj_xcoff_sym_hashes (sec->owner)
1975 + xcoff_section_data (sec->owner, sec)->first_symndx);
1976 hpend = (obj_xcoff_sym_hashes (sec->owner)
1977 + xcoff_section_data (sec->owner, sec)->last_symndx);
1978 for (; hp < hpend; hp++)
1980 register struct xcoff_link_hash_entry *h;
1984 && (h->flags & XCOFF_MARK) == 0)
1986 if (! xcoff_mark_symbol (info, h))
1991 /* Look through the section relocs. */
1993 if ((sec->flags & SEC_RELOC) != 0
1994 && sec->reloc_count > 0)
1996 rel = xcoff_read_internal_relocs (sec->owner, sec, true,
1997 (bfd_byte *) NULL, false,
1998 (struct internal_reloc *) NULL);
2001 relend = rel + sec->reloc_count;
2002 for (; rel < relend; rel++)
2005 struct xcoff_link_hash_entry *h;
2007 if ((unsigned int) rel->r_symndx
2008 > obj_raw_syment_count (sec->owner))
2011 h = obj_xcoff_sym_hashes (sec->owner)[rel->r_symndx];
2013 && (h->flags & XCOFF_MARK) == 0)
2015 if (! xcoff_mark_symbol (info, h))
2019 rsec = xcoff_data (sec->owner)->csects[rel->r_symndx];
2021 && (rsec->flags & SEC_MARK) == 0)
2023 if (! xcoff_mark (info, rsec))
2027 /* See if this reloc needs to be copied into the .loader
2029 switch (rel->r_type)
2033 || h->root.type == bfd_link_hash_defined
2034 || h->root.type == bfd_link_hash_defweak
2035 || h->root.type == bfd_link_hash_common
2036 || ((h->flags & XCOFF_CALLED) != 0
2037 && (h->flags & XCOFF_DEF_REGULAR) == 0
2038 && (h->flags & XCOFF_REF_DYNAMIC) != 0
2039 && (h->root.type == bfd_link_hash_undefined
2040 || h->root.type == bfd_link_hash_undefweak)
2041 && h->root.root.string[0] == '.'))
2048 ++xcoff_hash_table (info)->ldrel_count;
2050 h->flags |= XCOFF_LDREL;
2057 /* We should never need a .loader reloc for a TOC
2063 if (! info->keep_memory
2064 && coff_section_data (sec->owner, sec) != NULL
2065 && coff_section_data (sec->owner, sec)->relocs != NULL
2066 && ! coff_section_data (sec->owner, sec)->keep_relocs)
2068 free (coff_section_data (sec->owner, sec)->relocs);
2069 coff_section_data (sec->owner, sec)->relocs = NULL;
2077 /* The sweep phase of garbage collection. Remove all garbage
2082 struct bfd_link_info *info;
2086 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2090 for (o = sub->sections; o != NULL; o = o->next)
2092 if ((o->flags & SEC_MARK) == 0)
2094 /* Keep all sections from non-XCOFF input files. Keep
2095 special sections. Keep .debug sections for the
2097 if (sub->xvec != info->hash->creator
2098 || o == xcoff_hash_table (info)->debug_section
2099 || o == xcoff_hash_table (info)->loader_section
2100 || o == xcoff_hash_table (info)->linkage_section
2101 || o == xcoff_hash_table (info)->toc_section
2102 || strcmp (o->name, ".debug") == 0)
2103 o->flags |= SEC_MARK;
2108 o->lineno_count = 0;
2115 /* Record the number of elements in a set. This is used to output the
2116 correct csect length. */
2119 bfd_xcoff_link_record_set (output_bfd, info, harg, size)
2121 struct bfd_link_info *info;
2122 struct bfd_link_hash_entry *harg;
2125 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
2126 struct xcoff_link_size_list *n;
2128 /* This will hardly ever be called. I don't want to burn four bytes
2129 per global symbol, so instead the size is kept on a linked list
2130 attached to the hash table. */
2132 n = ((struct xcoff_link_size_list *)
2133 bfd_alloc (output_bfd, sizeof (struct xcoff_link_size_list)));
2136 bfd_set_error (bfd_error_no_memory);
2139 n->next = xcoff_hash_table (info)->size_list;
2142 xcoff_hash_table (info)->size_list = n;
2144 h->flags |= XCOFF_HAS_SIZE;
2149 /* Import a symbol. */
2152 bfd_xcoff_import_symbol (output_bfd, info, harg, val, imppath, impfile,
2155 struct bfd_link_info *info;
2156 struct bfd_link_hash_entry *harg;
2158 const char *imppath;
2159 const char *impfile;
2160 const char *impmember;
2162 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
2164 h->flags |= XCOFF_IMPORT;
2166 if (val != (bfd_vma) -1)
2168 if (h->root.type == bfd_link_hash_defined)
2170 if (! ((*info->callbacks->multiple_definition)
2171 (info, h->root.root.string, h->root.u.def.section->owner,
2172 h->root.u.def.section, h->root.u.def.value,
2173 output_bfd, bfd_abs_section_ptr, val)))
2177 h->root.type = bfd_link_hash_defined;
2178 h->root.u.def.section = bfd_abs_section_ptr;
2179 h->root.u.def.value = val;
2182 if (h->ldsym == NULL)
2184 h->ldsym = ((struct internal_ldsym *)
2185 bfd_zalloc (output_bfd, sizeof (struct internal_ldsym)));
2186 if (h->ldsym == NULL)
2188 bfd_set_error (bfd_error_no_memory);
2193 if (imppath == NULL)
2194 h->ldsym->l_ifile = (bfd_size_type) -1;
2198 struct xcoff_import_file **pp;
2200 /* We start c at 1 because the first entry in the import list is
2201 reserved for the library search path. */
2202 for (pp = &xcoff_hash_table (info)->imports, c = 1;
2204 pp = &(*pp)->next, ++c)
2206 if (strcmp ((*pp)->path, imppath) == 0
2207 && strcmp ((*pp)->file, impfile) == 0
2208 && strcmp ((*pp)->member, impmember) == 0)
2214 struct xcoff_import_file *n;
2216 n = ((struct xcoff_import_file *)
2217 bfd_alloc (output_bfd, sizeof (struct xcoff_import_file)));
2220 bfd_set_error (bfd_error_no_memory);
2226 n->member = impmember;
2230 h->ldsym->l_ifile = c;
2236 /* Export a symbol. */
2239 bfd_xcoff_export_symbol (output_bfd, info, harg, syscall)
2241 struct bfd_link_info *info;
2242 struct bfd_link_hash_entry *harg;
2245 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
2247 h->flags |= XCOFF_EXPORT;
2249 /* FIXME: I'm not at all sure what syscall is supposed to mean, so
2250 I'm just going to ignore it until somebody explains it. */
2252 /* Make sure we don't garbage collect this symbol. */
2253 if (! xcoff_mark_symbol (info, h))
2259 /* Count a reloc against a symbol. This is called for relocs
2260 generated by the linker script, typically for global constructors
2264 bfd_xcoff_link_count_reloc (output_bfd, info, name)
2266 struct bfd_link_info *info;
2269 struct xcoff_link_hash_entry *h;
2271 h = xcoff_link_hash_lookup (xcoff_hash_table (info), name, false, false,
2275 (*_bfd_error_handler) ("%s: no such symbol", name);
2276 bfd_set_error (bfd_error_no_symbols);
2280 h->flags |= XCOFF_REF_REGULAR | XCOFF_LDREL;
2281 ++xcoff_hash_table (info)->ldrel_count;
2283 /* Mark the symbol to avoid garbage collection. */
2284 if (! xcoff_mark_symbol (info, h))
2290 /* This function is called for each symbol to which the linker script
2294 bfd_xcoff_record_link_assignment (output_bfd, info, name)
2296 struct bfd_link_info *info;
2299 struct xcoff_link_hash_entry *h;
2301 h = xcoff_link_hash_lookup (xcoff_hash_table (info), name, true, true,
2306 h->flags |= XCOFF_DEF_REGULAR;
2311 /* This structure is used to pass information through
2312 xcoff_link_hash_traverse. */
2314 struct xcoff_loader_info
2316 /* Set if a problem occurred. */
2320 /* Link information structure. */
2321 struct bfd_link_info *info;
2322 /* Number of ldsym structures. */
2324 /* Size of string table. */
2328 /* Allocated size of string table. */
2332 /* Build the .loader section. This is called by the XCOFF linker
2333 emulation before_allocation routine. We must set the size of the
2334 .loader section before the linker lays out the output file.
2335 LIBPATH is the library path to search for shared objects; this is
2336 normally built from the -L arguments passed to the linker. ENTRY
2337 is the name of the entry point symbol. */
2340 bfd_xcoff_size_dynamic_sections (output_bfd, info, libpath, entry,
2341 file_align, maxstack, maxdata, gc,
2344 struct bfd_link_info *info;
2345 const char *libpath;
2347 unsigned long file_align;
2348 unsigned long maxstack;
2349 unsigned long maxdata;
2354 struct xcoff_link_hash_entry *hentry;
2356 struct xcoff_loader_info ldinfo;
2357 size_t impsize, impcount;
2358 struct xcoff_import_file *fl;
2359 struct internal_ldhdr *ldhdr;
2360 bfd_size_type stoff;
2364 struct bfd_strtab_hash *debug_strtab;
2365 bfd_byte *debug_contents = NULL;
2367 ldinfo.failed = false;
2368 ldinfo.output_bfd = output_bfd;
2370 ldinfo.ldsym_count = 0;
2371 ldinfo.string_size = 0;
2372 ldinfo.strings = NULL;
2373 ldinfo.string_alc = 0;
2375 xcoff_data (output_bfd)->maxstack = maxstack;
2376 xcoff_data (output_bfd)->maxdata = maxdata;
2377 xcoff_data (output_bfd)->modtype = modtype;
2379 xcoff_hash_table (info)->file_align = file_align;
2380 xcoff_hash_table (info)->textro = textro;
2382 hentry = xcoff_link_hash_lookup (xcoff_hash_table (info), entry,
2383 false, false, true);
2386 hentry->flags |= XCOFF_ENTRY;
2387 if (hentry->root.type == bfd_link_hash_defined
2388 || hentry->root.type == bfd_link_hash_defweak)
2389 xcoff_data (output_bfd)->entry_section =
2390 hentry->root.u.def.section->output_section;
2393 /* Garbage collect unused sections. */
2394 if (info->relocateable
2397 || (hentry->root.type != bfd_link_hash_defined
2398 && hentry->root.type != bfd_link_hash_defweak))
2401 xcoff_hash_table (info)->gc = false;
2403 /* We still need to call xcoff_mark, in order to set ldrel_count
2405 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2409 for (o = sub->sections; o != NULL; o = o->next)
2411 if ((o->flags & SEC_MARK) == 0)
2413 if (! xcoff_mark (info, o))
2421 if (! xcoff_mark (info, hentry->root.u.def.section))
2424 xcoff_hash_table (info)->gc = true;
2427 if (info->input_bfds == NULL)
2429 /* I'm not sure what to do in this bizarre case. */
2433 xcoff_link_hash_traverse (xcoff_hash_table (info), xcoff_build_ldsyms,
2438 /* Work out the size of the import file names. Each import file ID
2439 consists of three null terminated strings: the path, the file
2440 name, and the archive member name. The first entry in the list
2441 of names is the path to use to find objects, which the linker has
2442 passed in as the libpath argument. For some reason, the path
2443 entry in the other import file names appears to always be empty. */
2444 impsize = strlen (libpath) + 3;
2446 for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
2449 impsize += (strlen (fl->path)
2451 + strlen (fl->member)
2455 /* Set up the .loader section header. */
2456 ldhdr = &xcoff_hash_table (info)->ldhdr;
2457 ldhdr->l_version = 1;
2458 ldhdr->l_nsyms = ldinfo.ldsym_count;
2459 ldhdr->l_nreloc = xcoff_hash_table (info)->ldrel_count;
2460 ldhdr->l_istlen = impsize;
2461 ldhdr->l_nimpid = impcount;
2462 ldhdr->l_impoff = (LDHDRSZ
2463 + ldhdr->l_nsyms * LDSYMSZ
2464 + ldhdr->l_nreloc * LDRELSZ);
2465 ldhdr->l_stlen = ldinfo.string_size;
2466 stoff = ldhdr->l_impoff + impsize;
2467 if (ldinfo.string_size == 0)
2470 ldhdr->l_stoff = stoff;
2472 /* We now know the final size of the .loader section. Allocate
2474 lsec = xcoff_hash_table (info)->loader_section;
2475 lsec->_raw_size = stoff + ldhdr->l_stlen;
2476 lsec->contents = (bfd_byte *) bfd_zalloc (output_bfd, lsec->_raw_size);
2477 if (lsec->contents == NULL)
2479 bfd_set_error (bfd_error_no_memory);
2483 /* Set up the header. */
2484 xcoff_swap_ldhdr_out (output_bfd, ldhdr,
2485 (struct external_ldhdr *) lsec->contents);
2487 /* Set up the import file names. */
2488 out = (char *) lsec->contents + ldhdr->l_impoff;
2489 strcpy (out, libpath);
2490 out += strlen (libpath) + 1;
2493 for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
2495 register const char *s;
2498 while ((*out++ = *s++) != '\0')
2501 while ((*out++ = *s++) != '\0')
2504 while ((*out++ = *s++) != '\0')
2508 BFD_ASSERT ((bfd_size_type) ((bfd_byte *) out - lsec->contents) == stoff);
2510 /* Set up the symbol string table. */
2511 if (ldinfo.string_size > 0)
2513 memcpy (out, ldinfo.strings, ldinfo.string_size);
2514 free (ldinfo.strings);
2515 ldinfo.strings = NULL;
2518 /* We can't set up the symbol table or the relocs yet, because we
2519 don't yet know the final position of the various sections. The
2520 .loader symbols are written out when the corresponding normal
2521 symbols are written out in xcoff_link_input_bfd or
2522 xcoff_write_global_symbol. The .loader relocs are written out
2523 when the corresponding normal relocs are handled in
2524 xcoff_link_input_bfd. */
2526 /* Allocate space for the global linkage section and the global toc
2528 sec = xcoff_hash_table (info)->linkage_section;
2529 if (sec->_raw_size > 0)
2531 sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
2532 if (sec->contents == NULL)
2534 bfd_set_error (bfd_error_no_memory);
2538 sec = xcoff_hash_table (info)->toc_section;
2539 if (sec->_raw_size > 0)
2541 sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
2542 if (sec->contents == NULL)
2544 bfd_set_error (bfd_error_no_memory);
2549 /* Now that we've done garbage collection, figure out the contents
2550 of the .debug section. */
2551 debug_strtab = xcoff_hash_table (info)->debug_strtab;
2553 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2556 bfd_size_type symcount;
2557 unsigned long *debug_index;
2559 bfd_byte *esym, *esymend;
2560 bfd_size_type symesz;
2562 if (sub->xvec != info->hash->creator)
2564 subdeb = bfd_get_section_by_name (sub, ".debug");
2565 if (subdeb == NULL || subdeb->_raw_size == 0)
2568 if (info->strip == strip_all
2569 || info->strip == strip_debugger
2570 || info->discard == discard_all)
2572 subdeb->_raw_size = 0;
2576 if (! _bfd_coff_get_external_symbols (sub))
2579 symcount = obj_raw_syment_count (sub);
2580 debug_index = ((unsigned long *)
2581 bfd_zalloc (sub, symcount * sizeof (unsigned long)));
2582 if (debug_index == NULL)
2584 bfd_set_error (bfd_error_no_memory);
2587 xcoff_data (sub)->debug_indices = debug_index;
2589 /* Grab the contents of the .debug section. We use malloc and
2590 copy the neams into the debug stringtab, rather than
2591 bfd_alloc, because I expect that, when linking many files
2592 together, many of the strings will be the same. Storing the
2593 strings in the hash table should save space in this case. */
2594 debug_contents = (bfd_byte *) malloc (subdeb->_raw_size);
2595 if (debug_contents == NULL)
2597 bfd_set_error (bfd_error_no_memory);
2600 if (! bfd_get_section_contents (sub, subdeb, (PTR) debug_contents,
2601 (file_ptr) 0, subdeb->_raw_size))
2604 csectpp = xcoff_data (sub)->csects;
2606 symesz = bfd_coff_symesz (sub);
2607 esym = (bfd_byte *) obj_coff_external_syms (sub);
2608 esymend = esym + symcount * symesz;
2609 while (esym < esymend)
2611 struct internal_syment sym;
2613 bfd_coff_swap_sym_in (sub, (PTR) esym, (PTR) &sym);
2615 *debug_index = (unsigned long) -1;
2617 if (sym._n._n_n._n_zeroes == 0
2620 || ((*csectpp)->flags & SEC_MARK) != 0
2621 || *csectpp == bfd_abs_section_ptr)
2622 && bfd_coff_symname_in_debug (sub, &sym))
2627 name = (char *) debug_contents + sym._n._n_n._n_offset;
2628 indx = _bfd_stringtab_add (debug_strtab, name, true, true);
2629 if (indx == (bfd_size_type) -1)
2631 *debug_index = indx;
2634 esym += (sym.n_numaux + 1) * symesz;
2635 csectpp += sym.n_numaux + 1;
2636 debug_index += sym.n_numaux + 1;
2639 free (debug_contents);
2640 debug_contents = NULL;
2642 /* Clear the size of subdeb, so that it is not included directly
2643 in the output file. */
2644 subdeb->_raw_size = 0;
2646 if (! info->keep_memory)
2648 if (! _bfd_coff_free_symbols (sub))
2653 xcoff_hash_table (info)->debug_section->_raw_size =
2654 _bfd_stringtab_size (debug_strtab);
2659 if (ldinfo.strings != NULL)
2660 free (ldinfo.strings);
2661 if (debug_contents != NULL)
2662 free (debug_contents);
2666 /* Add a symbol to the .loader symbols, if necessary. */
2669 xcoff_build_ldsyms (h, p)
2670 struct xcoff_link_hash_entry *h;
2673 struct xcoff_loader_info *ldinfo = (struct xcoff_loader_info *) p;
2676 /* We don't want to garbage collect symbols which are not defined in
2677 XCOFF files. This is a convenient place to mark them. */
2678 if (xcoff_hash_table (ldinfo->info)->gc
2679 && (h->flags & XCOFF_MARK) == 0
2680 && (h->root.type == bfd_link_hash_defined
2681 || h->root.type == bfd_link_hash_defweak)
2682 && (h->root.u.def.section->owner == NULL
2683 || (h->root.u.def.section->owner->xvec
2684 != ldinfo->info->hash->creator)))
2685 h->flags |= XCOFF_MARK;
2687 /* If this symbol is called, and it is defined in a dynamic object,
2688 then we need to set up global linkage code for it. (Unless we
2689 did garbage collection and we didn't need this symbol.) */
2690 if ((h->flags & XCOFF_CALLED) != 0
2691 && (h->flags & XCOFF_DEF_REGULAR) == 0
2692 && (h->flags & XCOFF_REF_DYNAMIC) != 0
2693 && (h->root.type == bfd_link_hash_undefined
2694 || h->root.type == bfd_link_hash_undefweak)
2695 && h->root.root.string[0] == '.'
2696 && (! xcoff_hash_table (ldinfo->info)->gc
2697 || (h->flags & XCOFF_MARK) != 0))
2700 struct xcoff_link_hash_entry *hds;
2702 sec = xcoff_hash_table (ldinfo->info)->linkage_section;
2703 h->root.type = bfd_link_hash_defined;
2704 h->root.u.def.section = sec;
2705 h->root.u.def.value = sec->_raw_size;
2707 sec->_raw_size += XCOFF_GLINK_SIZE;
2709 /* The global linkage code requires a TOC entry for the
2711 hds = h->descriptor;
2712 BFD_ASSERT ((hds->root.type == bfd_link_hash_undefined
2713 || hds->root.type == bfd_link_hash_undefweak)
2714 && (hds->flags & XCOFF_DEF_REGULAR) == 0
2715 && (hds->flags & XCOFF_REF_DYNAMIC) != 0);
2716 hds->flags |= XCOFF_MARK;
2717 if (hds->toc_section == NULL)
2719 hds->toc_section = xcoff_hash_table (ldinfo->info)->toc_section;
2720 hds->u.toc_offset = hds->toc_section->_raw_size;
2721 hds->toc_section->_raw_size += 4;
2722 ++xcoff_hash_table (ldinfo->info)->ldrel_count;
2723 ++hds->toc_section->reloc_count;
2725 hds->flags |= XCOFF_SET_TOC | XCOFF_LDREL;
2727 /* We need to call xcoff_build_ldsyms recursively here,
2728 because we may already have passed hds on the traversal. */
2729 xcoff_build_ldsyms (hds, p);
2733 /* If this is still a common symbol, and it wasn't garbage
2734 collected, we need to actually allocate space for it in the .bss
2736 if (h->root.type == bfd_link_hash_common
2737 && (! xcoff_hash_table (ldinfo->info)->gc
2738 || (h->flags & XCOFF_MARK) != 0)
2739 && h->root.u.c.p->section->_raw_size == 0)
2741 BFD_ASSERT (bfd_is_com_section (h->root.u.c.p->section));
2742 h->root.u.c.p->section->_raw_size = h->root.u.c.size;
2745 /* We need to add a symbol to the .loader section if it is mentioned
2746 in a reloc which we are copying to the .loader section and it was
2747 not defined or common, or if it is the entry point, or if it is
2750 if (((h->flags & XCOFF_LDREL) == 0
2751 || h->root.type == bfd_link_hash_defined
2752 || h->root.type == bfd_link_hash_defweak
2753 || h->root.type == bfd_link_hash_common)
2754 && (h->flags & XCOFF_ENTRY) == 0
2755 && (h->flags & XCOFF_EXPORT) == 0)
2761 /* We don't need to add this symbol if we did garbage collection and
2762 we did not mark this symbol. */
2763 if (xcoff_hash_table (ldinfo->info)->gc
2764 && (h->flags & XCOFF_MARK) == 0)
2770 /* We may have already processed this symbol due to the recursive
2772 if ((h->flags & XCOFF_BUILT_LDSYM) != 0)
2775 /* We need to add this symbol to the .loader symbols. */
2777 /* h->ldsym will already have been allocated for an explicitly
2779 if (h->ldsym == NULL)
2781 h->ldsym = ((struct internal_ldsym *)
2782 bfd_zalloc (ldinfo->output_bfd,
2783 sizeof (struct internal_ldsym)));
2784 if (h->ldsym == NULL)
2786 ldinfo->failed = true;
2787 bfd_set_error (bfd_error_no_memory);
2792 /* The first 3 symbol table indices are reserved to indicate the
2794 h->ldindx = ldinfo->ldsym_count + 3;
2796 ++ldinfo->ldsym_count;
2798 len = strlen (h->root.root.string);
2799 if (len <= SYMNMLEN)
2800 strncpy (h->ldsym->_l._l_name, h->root.root.string, SYMNMLEN);
2803 if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
2806 bfd_byte *newstrings;
2808 newalc = ldinfo->string_alc * 2;
2811 while (ldinfo->string_size + len + 3 > newalc)
2814 if (ldinfo->strings == NULL)
2815 newstrings = (bfd_byte *) malloc (newalc);
2817 newstrings = ((bfd_byte *)
2818 realloc ((PTR) ldinfo->strings, newalc));
2819 if (newstrings == NULL)
2821 ldinfo->failed = true;
2822 bfd_set_error (bfd_error_no_memory);
2825 ldinfo->string_alc = newalc;
2826 ldinfo->strings = newstrings;
2829 bfd_put_16 (ldinfo->output_bfd, len + 1,
2830 ldinfo->strings + ldinfo->string_size);
2831 strcpy (ldinfo->strings + ldinfo->string_size + 2, h->root.root.string);
2832 h->ldsym->_l._l_l._l_zeroes = 0;
2833 h->ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
2834 ldinfo->string_size += len + 3;
2837 h->flags |= XCOFF_BUILT_LDSYM;
2842 /* Do the final link step. */
2845 _bfd_xcoff_bfd_final_link (abfd, info)
2847 struct bfd_link_info *info;
2849 bfd_size_type symesz;
2850 struct xcoff_final_link_info finfo;
2852 struct bfd_link_order *p;
2853 size_t max_contents_size;
2854 size_t max_sym_count;
2855 size_t max_lineno_count;
2856 size_t max_reloc_count;
2857 size_t max_output_reloc_count;
2858 file_ptr rel_filepos;
2860 file_ptr line_filepos;
2861 unsigned int linesz;
2863 bfd_byte *external_relocs = NULL;
2864 char strbuf[STRING_SIZE_SIZE];
2866 symesz = bfd_coff_symesz (abfd);
2869 finfo.output_bfd = abfd;
2870 finfo.strtab = NULL;
2871 finfo.section_info = NULL;
2872 finfo.last_file_index = -1;
2873 finfo.toc_symindx = -1;
2874 finfo.internal_syms = NULL;
2875 finfo.sym_indices = NULL;
2876 finfo.outsyms = NULL;
2877 finfo.linenos = NULL;
2878 finfo.contents = NULL;
2879 finfo.external_relocs = NULL;
2881 finfo.ldsym = ((struct external_ldsym *)
2882 (xcoff_hash_table (info)->loader_section->contents
2884 finfo.ldrel = ((struct external_ldrel *)
2885 (xcoff_hash_table (info)->loader_section->contents
2887 + xcoff_hash_table (info)->ldhdr.l_nsyms * LDSYMSZ));
2889 xcoff_data (abfd)->coff.link_info = info;
2890 xcoff_data (abfd)->full_aouthdr = true;
2892 finfo.strtab = _bfd_stringtab_init ();
2893 if (finfo.strtab == NULL)
2896 /* Compute the file positions for all the sections. */
2897 if (abfd->output_has_begun)
2899 if (xcoff_hash_table (info)->file_align != 0)
2906 file_align = xcoff_hash_table (info)->file_align;
2907 if (file_align != 0)
2909 boolean saw_contents;
2914 /* Insert .pad sections before every section which has
2915 contents and is loaded, if it is preceded by some other
2916 section which has contents and is loaded. */
2917 saw_contents = true;
2918 for (op = &abfd->sections; *op != NULL; op = &(*op)->next)
2920 (*op)->target_index = indx;
2921 if (strcmp ((*op)->name, ".pad") == 0)
2922 saw_contents = false;
2923 else if (((*op)->flags & SEC_HAS_CONTENTS) != 0
2924 && ((*op)->flags & SEC_LOAD) != 0)
2927 saw_contents = true;
2934 n = bfd_make_section_anyway (abfd, ".pad");
2935 BFD_ASSERT (*op == n);
2937 n->flags = SEC_HAS_CONTENTS;
2938 n->alignment_power = 0;
2939 saw_contents = false;
2944 /* Reset the section indices after inserting the new
2947 for (o = abfd->sections; o != NULL; o = o->next)
2950 o->target_index = indx;
2952 BFD_ASSERT ((unsigned int) indx == abfd->section_count);
2954 /* Work out appropriate sizes for the .pad sections to force
2955 each section to land on a page boundary. This bit of
2956 code knows what compute_section_file_positions is going
2958 sofar = bfd_coff_filhsz (abfd);
2959 sofar += bfd_coff_aoutsz (abfd);
2960 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
2962 for (o = abfd->sections; o != NULL; o = o->next)
2964 if (strcmp (o->name, ".pad") == 0)
2968 BFD_ASSERT (o->_raw_size == 0);
2969 pageoff = sofar & (file_align - 1);
2972 o->_raw_size = file_align - pageoff;
2973 sofar += file_align - pageoff;
2974 o->flags |= SEC_HAS_CONTENTS;
2979 if ((o->flags & SEC_HAS_CONTENTS) != 0)
2980 sofar += BFD_ALIGN (o->_raw_size,
2981 1 << o->alignment_power);
2986 bfd_coff_compute_section_file_positions (abfd);
2989 /* Count the line numbers and relocation entries required for the
2990 output file. Set the file positions for the relocs. */
2991 rel_filepos = obj_relocbase (abfd);
2992 relsz = bfd_coff_relsz (abfd);
2993 max_contents_size = 0;
2994 max_lineno_count = 0;
2995 max_reloc_count = 0;
2996 for (o = abfd->sections; o != NULL; o = o->next)
2999 o->lineno_count = 0;
3000 for (p = o->link_order_head; p != NULL; p = p->next)
3002 if (p->type == bfd_indirect_link_order)
3006 sec = p->u.indirect.section;
3008 if (info->strip == strip_none
3009 || info->strip == strip_some)
3010 o->lineno_count += sec->lineno_count;
3012 o->reloc_count += sec->reloc_count;
3014 if (sec->_raw_size > max_contents_size)
3015 max_contents_size = sec->_raw_size;
3016 if (sec->lineno_count > max_lineno_count)
3017 max_lineno_count = sec->lineno_count;
3018 if (coff_section_data (sec->owner, sec) != NULL
3019 && xcoff_section_data (sec->owner, sec) != NULL
3020 && (xcoff_section_data (sec->owner, sec)->lineno_count
3021 > max_lineno_count))
3023 xcoff_section_data (sec->owner, sec)->lineno_count;
3024 if (sec->reloc_count > max_reloc_count)
3025 max_reloc_count = sec->reloc_count;
3027 else if (p->type == bfd_section_reloc_link_order
3028 || p->type == bfd_symbol_reloc_link_order)
3031 if (o->reloc_count == 0)
3035 o->flags |= SEC_RELOC;
3036 o->rel_filepos = rel_filepos;
3037 rel_filepos += o->reloc_count * relsz;
3041 /* Allocate space for the pointers we need to keep for the relocs. */
3045 /* We use section_count + 1, rather than section_count, because
3046 the target_index fields are 1 based. */
3047 finfo.section_info = ((struct xcoff_link_section_info *)
3048 malloc ((abfd->section_count + 1)
3049 * sizeof (struct xcoff_link_section_info)));
3050 if (finfo.section_info == NULL)
3052 bfd_set_error (bfd_error_no_memory);
3055 for (i = 0; i <= abfd->section_count; i++)
3057 finfo.section_info[i].relocs = NULL;
3058 finfo.section_info[i].rel_hashes = NULL;
3059 finfo.section_info[i].toc_rel_hashes = NULL;
3063 /* We now know the size of the relocs, so we can determine the file
3064 positions of the line numbers. */
3065 line_filepos = rel_filepos;
3066 finfo.line_filepos = line_filepos;
3067 linesz = bfd_coff_linesz (abfd);
3068 max_output_reloc_count = 0;
3069 for (o = abfd->sections; o != NULL; o = o->next)
3071 if (o->lineno_count == 0)
3072 o->line_filepos = 0;
3075 o->line_filepos = line_filepos;
3076 line_filepos += o->lineno_count * linesz;
3079 if (o->reloc_count != 0)
3081 /* We don't know the indices of global symbols until we have
3082 written out all the local symbols. For each section in
3083 the output file, we keep an array of pointers to hash
3084 table entries. Each entry in the array corresponds to a
3085 reloc. When we find a reloc against a global symbol, we
3086 set the corresponding entry in this array so that we can
3087 fix up the symbol index after we have written out all the
3090 Because of this problem, we also keep the relocs in
3091 memory until the end of the link. This wastes memory.
3092 We could backpatch the file later, I suppose, although it
3094 finfo.section_info[o->target_index].relocs =
3095 ((struct internal_reloc *)
3096 malloc (o->reloc_count * sizeof (struct internal_reloc)));
3097 finfo.section_info[o->target_index].rel_hashes =
3098 ((struct xcoff_link_hash_entry **)
3099 malloc (o->reloc_count
3100 * sizeof (struct xcoff_link_hash_entry *)));
3101 if (finfo.section_info[o->target_index].relocs == NULL
3102 || finfo.section_info[o->target_index].rel_hashes == NULL)
3104 bfd_set_error (bfd_error_no_memory);
3108 if (o->reloc_count > max_output_reloc_count)
3109 max_output_reloc_count = o->reloc_count;
3112 /* Reset the reloc and lineno counts, so that we can use them to
3113 count the number of entries we have output so far. */
3115 o->lineno_count = 0;
3118 obj_sym_filepos (abfd) = line_filepos;
3120 /* Figure out the largest number of symbols in an input BFD. Take
3121 the opportunity to clear the output_has_begun fields of all the
3122 input BFD's. We want at least 4 symbols, since that is the
3123 number which xcoff_write_global_symbol may need. */
3125 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3129 sub->output_has_begun = false;
3130 sz = obj_raw_syment_count (sub);
3131 if (sz > max_sym_count)
3135 /* Allocate some buffers used while linking. */
3136 finfo.internal_syms = ((struct internal_syment *)
3137 malloc (max_sym_count
3138 * sizeof (struct internal_syment)));
3139 finfo.sym_indices = (long *) malloc (max_sym_count * sizeof (long));
3140 finfo.outsyms = ((bfd_byte *)
3141 malloc ((size_t) ((max_sym_count + 1) * symesz)));
3142 finfo.linenos = (bfd_byte *) malloc (max_lineno_count
3143 * bfd_coff_linesz (abfd));
3144 finfo.contents = (bfd_byte *) malloc (max_contents_size);
3145 finfo.external_relocs = (bfd_byte *) malloc (max_reloc_count * relsz);
3146 if ((finfo.internal_syms == NULL && max_sym_count > 0)
3147 || (finfo.sym_indices == NULL && max_sym_count > 0)
3148 || finfo.outsyms == NULL
3149 || (finfo.linenos == NULL && max_lineno_count > 0)
3150 || (finfo.contents == NULL && max_contents_size > 0)
3151 || (finfo.external_relocs == NULL && max_reloc_count > 0))
3153 bfd_set_error (bfd_error_no_memory);
3157 obj_raw_syment_count (abfd) = 0;
3158 xcoff_data (abfd)->toc = (bfd_vma) -1;
3160 /* We now know the position of everything in the file, except that
3161 we don't know the size of the symbol table and therefore we don't
3162 know where the string table starts. We just build the string
3163 table in memory as we go along. We process all the relocations
3164 for a single input file at once. */
3165 for (o = abfd->sections; o != NULL; o = o->next)
3167 for (p = o->link_order_head; p != NULL; p = p->next)
3169 if (p->type == bfd_indirect_link_order
3170 && p->u.indirect.section->owner->xvec == abfd->xvec)
3172 sub = p->u.indirect.section->owner;
3173 if (! sub->output_has_begun)
3175 if (! xcoff_link_input_bfd (&finfo, sub))
3177 sub->output_has_begun = true;
3180 else if (p->type == bfd_section_reloc_link_order
3181 || p->type == bfd_symbol_reloc_link_order)
3183 if (! xcoff_reloc_link_order (abfd, &finfo, o, p))
3188 if (! _bfd_default_link_order (abfd, info, o, p))
3194 /* Free up the buffers used by xcoff_link_input_bfd. */
3196 if (finfo.internal_syms != NULL)
3198 free (finfo.internal_syms);
3199 finfo.internal_syms = NULL;
3201 if (finfo.sym_indices != NULL)
3203 free (finfo.sym_indices);
3204 finfo.sym_indices = NULL;
3206 if (finfo.linenos != NULL)
3208 free (finfo.linenos);
3209 finfo.linenos = NULL;
3211 if (finfo.contents != NULL)
3213 free (finfo.contents);
3214 finfo.contents = NULL;
3216 if (finfo.external_relocs != NULL)
3218 free (finfo.external_relocs);
3219 finfo.external_relocs = NULL;
3222 /* The value of the last C_FILE symbol is supposed to be -1. Write
3224 if (finfo.last_file_index != -1)
3226 finfo.last_file.n_value = -1;
3227 bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
3228 (PTR) finfo.outsyms);
3230 (obj_sym_filepos (abfd)
3231 + finfo.last_file_index * symesz),
3233 || bfd_write (finfo.outsyms, symesz, 1, abfd) != symesz)
3237 /* Write out all the global symbols which do not come from XCOFF
3239 xcoff_link_hash_traverse (xcoff_hash_table (info),
3240 xcoff_write_global_symbol,
3243 if (finfo.outsyms != NULL)
3245 free (finfo.outsyms);
3246 finfo.outsyms = NULL;
3249 /* Now that we have written out all the global symbols, we know the
3250 symbol indices to use for relocs against them, and we can finally
3251 write out the relocs. */
3252 external_relocs = (bfd_byte *) malloc (max_output_reloc_count * relsz);
3253 if (external_relocs == NULL && max_output_reloc_count != 0)
3255 bfd_set_error (bfd_error_no_memory);
3259 for (o = abfd->sections; o != NULL; o = o->next)
3261 struct internal_reloc *irel;
3262 struct internal_reloc *irelend;
3263 struct xcoff_link_hash_entry **rel_hash;
3264 struct xcoff_toc_rel_hash *toc_rel_hash;
3267 if (o->reloc_count == 0)
3270 irel = finfo.section_info[o->target_index].relocs;
3271 irelend = irel + o->reloc_count;
3272 rel_hash = finfo.section_info[o->target_index].rel_hashes;
3273 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
3275 if (*rel_hash != NULL)
3277 if ((*rel_hash)->indx < 0)
3279 if (! ((*info->callbacks->unattached_reloc)
3280 (info, (*rel_hash)->root.root.string,
3281 (bfd *) NULL, o, irel->r_vaddr)))
3283 (*rel_hash)->indx = 0;
3285 irel->r_symndx = (*rel_hash)->indx;
3289 for (toc_rel_hash = finfo.section_info[o->target_index].toc_rel_hashes;
3290 toc_rel_hash != NULL;
3291 toc_rel_hash = toc_rel_hash->next)
3293 if (toc_rel_hash->h->u.toc_indx < 0)
3295 if (! ((*info->callbacks->unattached_reloc)
3296 (info, toc_rel_hash->h->root.root.string,
3297 (bfd *) NULL, o, toc_rel_hash->rel->r_vaddr)))
3299 toc_rel_hash->h->u.toc_indx = 0;
3301 toc_rel_hash->rel->r_symndx = toc_rel_hash->h->u.toc_indx;
3304 /* XCOFF requires that the relocs be sorted by address. We tend
3305 to produce them in the order in which their containing csects
3306 appear in the symbol table, which is not necessarily by
3307 address. So we sort them here. There may be a better way to
3309 qsort ((PTR) finfo.section_info[o->target_index].relocs,
3310 o->reloc_count, sizeof (struct internal_reloc),
3313 irel = finfo.section_info[o->target_index].relocs;
3314 irelend = irel + o->reloc_count;
3315 erel = external_relocs;
3316 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
3317 bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
3319 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
3320 || bfd_write ((PTR) external_relocs, relsz, o->reloc_count,
3321 abfd) != relsz * o->reloc_count)
3325 if (external_relocs != NULL)
3327 free (external_relocs);
3328 external_relocs = NULL;
3331 /* Free up the section information. */
3332 if (finfo.section_info != NULL)
3336 for (i = 0; i < abfd->section_count; i++)
3338 if (finfo.section_info[i].relocs != NULL)
3339 free (finfo.section_info[i].relocs);
3340 if (finfo.section_info[i].rel_hashes != NULL)
3341 free (finfo.section_info[i].rel_hashes);
3343 free (finfo.section_info);
3344 finfo.section_info = NULL;
3347 /* Write out the loader section contents. */
3348 BFD_ASSERT ((bfd_byte *) finfo.ldrel
3349 == (xcoff_hash_table (info)->loader_section->contents
3350 + xcoff_hash_table (info)->ldhdr.l_impoff));
3351 o = xcoff_hash_table (info)->loader_section;
3352 if (! bfd_set_section_contents (abfd, o->output_section,
3353 o->contents, o->output_offset,
3357 /* Write out the global linkage section and the toc section. */
3358 o = xcoff_hash_table (info)->linkage_section;
3359 if (o->_raw_size > 0
3360 && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
3361 o->output_offset, o->_raw_size))
3363 o = xcoff_hash_table (info)->toc_section;
3364 if (o->_raw_size > 0
3365 && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
3366 o->output_offset, o->_raw_size))
3369 /* Write out the string table. */
3371 (obj_sym_filepos (abfd)
3372 + obj_raw_syment_count (abfd) * symesz),
3376 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
3377 (bfd_byte *) strbuf);
3378 if (bfd_write (strbuf, 1, STRING_SIZE_SIZE, abfd) != STRING_SIZE_SIZE)
3380 if (! _bfd_stringtab_emit (abfd, finfo.strtab))
3383 _bfd_stringtab_free (finfo.strtab);
3385 /* Write out the debugging string table. */
3386 o = xcoff_hash_table (info)->debug_section;
3389 struct bfd_strtab_hash *debug_strtab;
3391 debug_strtab = xcoff_hash_table (info)->debug_strtab;
3392 BFD_ASSERT (o->output_section->_raw_size - o->output_offset
3393 >= _bfd_stringtab_size (debug_strtab));
3395 o->output_section->filepos + o->output_offset,
3398 if (! _bfd_stringtab_emit (abfd, debug_strtab))
3402 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
3403 not try to write out the symbols. */
3404 bfd_get_symcount (abfd) = 0;
3409 if (finfo.strtab != NULL)
3410 _bfd_stringtab_free (finfo.strtab);
3411 if (finfo.section_info != NULL)
3415 for (i = 0; i < abfd->section_count; i++)
3417 if (finfo.section_info[i].relocs != NULL)
3418 free (finfo.section_info[i].relocs);
3419 if (finfo.section_info[i].rel_hashes != NULL)
3420 free (finfo.section_info[i].rel_hashes);
3422 free (finfo.section_info);
3424 if (finfo.internal_syms != NULL)
3425 free (finfo.internal_syms);
3426 if (finfo.sym_indices != NULL)
3427 free (finfo.sym_indices);
3428 if (finfo.outsyms != NULL)
3429 free (finfo.outsyms);
3430 if (finfo.linenos != NULL)
3431 free (finfo.linenos);
3432 if (finfo.contents != NULL)
3433 free (finfo.contents);
3434 if (finfo.external_relocs != NULL)
3435 free (finfo.external_relocs);
3436 if (external_relocs != NULL)
3437 free (external_relocs);
3441 /* Link an input file into the linker output file. This function
3442 handles all the sections and relocations of the input file at once. */
3445 xcoff_link_input_bfd (finfo, input_bfd)
3446 struct xcoff_final_link_info *finfo;
3450 const char *strings;
3451 bfd_size_type syment_base;
3452 unsigned int n_tmask;
3453 unsigned int n_btshft;
3455 bfd_size_type isymesz;
3456 bfd_size_type osymesz;
3457 bfd_size_type linesz;
3460 struct xcoff_link_hash_entry **sym_hash;
3461 struct internal_syment *isymp;
3463 unsigned long *debug_index;
3465 unsigned long output_index;
3472 /* We can just skip DYNAMIC files, unless this is a static link. */
3473 if ((input_bfd->flags & DYNAMIC) != 0
3474 && ! finfo->info->static_link)
3477 /* Move all the symbols to the output file. */
3479 output_bfd = finfo->output_bfd;
3481 syment_base = obj_raw_syment_count (output_bfd);
3482 isymesz = bfd_coff_symesz (input_bfd);
3483 osymesz = bfd_coff_symesz (output_bfd);
3484 linesz = bfd_coff_linesz (input_bfd);
3485 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
3487 n_tmask = coff_data (input_bfd)->local_n_tmask;
3488 n_btshft = coff_data (input_bfd)->local_n_btshft;
3490 /* Define macros so that ISFCN, et. al., macros work correctly. */
3491 #define N_TMASK n_tmask
3492 #define N_BTSHFT n_btshft
3495 if (! finfo->info->keep_memory)
3498 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
3501 if (! _bfd_coff_get_external_symbols (input_bfd))
3504 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
3505 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
3506 sym_hash = obj_xcoff_sym_hashes (input_bfd);
3507 csectpp = xcoff_data (input_bfd)->csects;
3508 debug_index = xcoff_data (input_bfd)->debug_indices;
3509 isymp = finfo->internal_syms;
3510 indexp = finfo->sym_indices;
3511 output_index = syment_base;
3512 outsym = finfo->outsyms;
3516 while (esym < esym_end)
3518 struct internal_syment isym;
3519 union internal_auxent aux;
3525 bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
3527 /* If this is a C_EXT or C_HIDEXT symbol, we need the csect
3529 if (isymp->n_sclass == C_EXT || isymp->n_sclass == C_HIDEXT)
3531 BFD_ASSERT (isymp->n_numaux > 0);
3532 bfd_coff_swap_aux_in (input_bfd,
3533 (PTR) (esym + isymesz * isymp->n_numaux),
3534 isymp->n_type, isymp->n_sclass,
3535 isymp->n_numaux - 1, isymp->n_numaux,
3537 smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
3540 /* Make a copy of *isymp so that the relocate_section function
3541 always sees the original values. This is more reliable than
3542 always recomputing the symbol value even if we are stripping
3546 /* If this symbol is in the .loader section, swap out the
3547 .loader symbol information. If this is an external symbol
3548 reference to a defined symbol, though, then wait until we get
3549 to the definition. */
3550 if (isym.n_sclass == C_EXT
3551 && *sym_hash != NULL
3552 && (*sym_hash)->ldsym != NULL
3554 || (*sym_hash)->root.type == bfd_link_hash_undefined))
3556 struct xcoff_link_hash_entry *h;
3557 struct internal_ldsym *ldsym;
3561 if (isym.n_scnum > 0)
3563 ldsym->l_scnum = (*csectpp)->output_section->target_index;
3564 ldsym->l_value = (isym.n_value
3565 + (*csectpp)->output_section->vma
3566 + (*csectpp)->output_offset
3571 ldsym->l_scnum = isym.n_scnum;
3572 ldsym->l_value = isym.n_value;
3575 ldsym->l_smtype = smtyp;
3576 if (((h->flags & XCOFF_DEF_REGULAR) == 0
3577 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
3578 || (h->flags & XCOFF_IMPORT) != 0)
3579 ldsym->l_smtype |= L_IMPORT;
3580 if (((h->flags & XCOFF_DEF_REGULAR) != 0
3581 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
3582 || (h->flags & XCOFF_EXPORT) != 0)
3583 ldsym->l_smtype |= L_EXPORT;
3584 if ((h->flags & XCOFF_ENTRY) != 0)
3585 ldsym->l_smtype |= L_ENTRY;
3587 ldsym->l_smclas = aux.x_csect.x_smclas;
3589 if (ldsym->l_ifile == (bfd_size_type) -1)
3591 else if (ldsym->l_ifile == 0)
3593 if ((ldsym->l_smtype & L_IMPORT) == 0)
3599 if (h->root.type == bfd_link_hash_defined
3600 || h->root.type == bfd_link_hash_defweak)
3601 impbfd = h->root.u.def.section->owner;
3602 else if (h->root.type == bfd_link_hash_undefined
3603 || h->root.type == bfd_link_hash_undefweak)
3604 impbfd = h->root.u.undef.abfd;
3612 BFD_ASSERT (impbfd->xvec == finfo->output_bfd->xvec);
3613 ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
3620 BFD_ASSERT (h->ldindx >= 0);
3621 BFD_ASSERT (LDSYMSZ == sizeof (struct external_ldsym));
3622 xcoff_swap_ldsym_out (finfo->output_bfd, ldsym,
3623 finfo->ldsym + h->ldindx - 3);
3631 add = 1 + isym.n_numaux;
3633 /* If we are skipping this csect, we want to skip this symbol. */
3634 if (*csectpp == NULL)
3637 /* If we garbage collected this csect, we want to skip this
3640 && xcoff_hash_table (finfo->info)->gc
3641 && ((*csectpp)->flags & SEC_MARK) == 0
3642 && *csectpp != bfd_abs_section_ptr)
3645 /* An XCOFF linker always skips C_STAT symbols. */
3647 && isymp->n_sclass == C_STAT)
3650 /* We skip all but the first TOC anchor. */
3652 && isymp->n_sclass == C_HIDEXT
3653 && aux.x_csect.x_smclas == XMC_TC0)
3655 if (finfo->toc_symindx != -1)
3659 finfo->toc_symindx = output_index;
3660 xcoff_data (finfo->output_bfd)->toc =
3661 ((*csectpp)->output_section->vma
3662 + (*csectpp)->output_offset
3665 xcoff_data (finfo->output_bfd)->toc_section =
3666 (*csectpp)->output_section;
3671 /* If we are stripping all symbols, we want to skip this one. */
3673 && finfo->info->strip == strip_all)
3676 /* We can skip resolved external references. */
3678 && isym.n_sclass == C_EXT
3680 && (*sym_hash)->root.type != bfd_link_hash_undefined)
3683 /* We can skip common symbols if they got defined somewhere
3686 && isym.n_sclass == C_EXT
3688 && ((*sym_hash)->root.type != bfd_link_hash_common
3689 || (*sym_hash)->root.u.c.p->section != *csectpp)
3690 && ((*sym_hash)->root.type != bfd_link_hash_defined
3691 || (*sym_hash)->root.u.def.section != *csectpp))
3694 /* Skip local symbols if we are discarding them. */
3696 && finfo->info->discard == discard_all
3697 && isym.n_sclass != C_EXT
3698 && (isym.n_sclass != C_HIDEXT
3699 || smtyp != XTY_SD))
3702 /* If we stripping debugging symbols, and this is a debugging
3703 symbol, then skip it. */
3705 && finfo->info->strip == strip_debugger
3706 && isym.n_scnum == N_DEBUG)
3709 /* If some symbols are stripped based on the name, work out the
3710 name and decide whether to skip this symbol. We don't handle
3711 this correctly for symbols whose names are in the .debug
3712 section; to get it right we would need a new bfd_strtab_hash
3713 function to return the string given the index. */
3715 && (finfo->info->strip == strip_some
3716 || finfo->info->discard == discard_l)
3717 && (debug_index == NULL || *debug_index == (unsigned long) -1))
3720 char buf[SYMNMLEN + 1];
3722 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
3726 if ((finfo->info->strip == strip_some
3727 && (bfd_hash_lookup (finfo->info->keep_hash, name, false,
3729 || (finfo->info->discard == discard_l
3730 && (isym.n_sclass != C_EXT
3731 && (isym.n_sclass != C_HIDEXT
3732 || smtyp != XTY_SD))
3733 && strncmp (name, finfo->info->lprefix,
3734 finfo->info->lprefix_len) == 0))
3738 /* We can not skip the first TOC anchor. */
3741 && finfo->info->strip != strip_all)
3744 /* We now know whether we are to skip this symbol or not. */
3747 /* Adjust the symbol in order to output it. */
3749 if (isym._n._n_n._n_zeroes == 0
3750 && isym._n._n_n._n_offset != 0)
3752 /* This symbol has a long name. Enter it in the string
3753 table we are building. If *debug_index != -1, the
3754 name has already been entered in the .debug section. */
3755 if (debug_index != NULL && *debug_index != (unsigned long) -1)
3756 isym._n._n_n._n_offset = *debug_index;
3762 name = _bfd_coff_internal_syment_name (input_bfd, &isym,
3766 indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
3767 if (indx == (bfd_size_type) -1)
3769 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
3773 if (isym.n_sclass != C_BSTAT
3774 && isym.n_sclass != C_ESTAT
3775 && isym.n_sclass != C_DECL
3776 && isym.n_scnum > 0)
3778 isym.n_scnum = (*csectpp)->output_section->target_index;
3779 isym.n_value += ((*csectpp)->output_section->vma
3780 + (*csectpp)->output_offset
3784 /* The value of a C_FILE symbol is the symbol index of the
3785 next C_FILE symbol. The value of the last C_FILE symbol
3786 is -1. We try to get this right, below, just before we
3787 write the symbols out, but in the general case we may
3788 have to write the symbol out twice. */
3789 if (isym.n_sclass == C_FILE)
3791 if (finfo->last_file_index != -1
3792 && finfo->last_file.n_value != (long) output_index)
3794 /* We must correct the value of the last C_FILE entry. */
3795 finfo->last_file.n_value = output_index;
3796 if ((bfd_size_type) finfo->last_file_index >= syment_base)
3798 /* The last C_FILE symbol is in this input file. */
3799 bfd_coff_swap_sym_out (output_bfd,
3800 (PTR) &finfo->last_file,
3801 (PTR) (finfo->outsyms
3802 + ((finfo->last_file_index
3808 /* We have already written out the last C_FILE
3809 symbol. We need to write it out again. We
3810 borrow *outsym temporarily. */
3811 bfd_coff_swap_sym_out (output_bfd,
3812 (PTR) &finfo->last_file,
3814 if (bfd_seek (output_bfd,
3815 (obj_sym_filepos (output_bfd)
3816 + finfo->last_file_index * osymesz),
3818 || (bfd_write (outsym, osymesz, 1, output_bfd)
3824 finfo->last_file_index = output_index;
3825 finfo->last_file = isym;
3828 /* The value of a C_BINCL or C_EINCL symbol is a file offset
3829 into the line numbers. We update the symbol values when
3830 we handle the line numbers. */
3831 if (isym.n_sclass == C_BINCL
3832 || isym.n_sclass == C_EINCL)
3834 isym.n_value = finfo->line_filepos;
3838 /* Output the symbol. */
3840 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
3842 *indexp = output_index;
3844 if (isym.n_sclass == C_EXT)
3847 struct xcoff_link_hash_entry *h;
3849 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
3851 h = obj_xcoff_sym_hashes (input_bfd)[indx];
3852 BFD_ASSERT (h != NULL);
3853 h->indx = output_index;
3856 /* If this is a symbol in the TOC which we may have merged
3857 (class XMC_TC), remember the symbol index of the TOC
3859 if (isym.n_sclass == C_HIDEXT
3860 && aux.x_csect.x_smclas == XMC_TC
3861 && *sym_hash != NULL)
3863 BFD_ASSERT (((*sym_hash)->flags & XCOFF_SET_TOC) == 0);
3864 BFD_ASSERT ((*sym_hash)->toc_section != NULL);
3865 (*sym_hash)->u.toc_indx = output_index;
3868 output_index += add;
3869 outsym += add * osymesz;
3872 esym += add * isymesz;
3876 if (debug_index != NULL)
3879 for (--add; add > 0; --add)
3883 /* Fix up the aux entries and the C_BSTAT symbols. This must be
3884 done in a separate pass, because we don't know the correct symbol
3885 indices until we have already decided which symbols we are going
3888 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
3889 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
3890 isymp = finfo->internal_syms;
3891 indexp = finfo->sym_indices;
3892 csectpp = xcoff_data (input_bfd)->csects;
3893 outsym = finfo->outsyms;
3894 while (esym < esym_end)
3898 add = 1 + isymp->n_numaux;
3901 esym += add * isymesz;
3906 if (isymp->n_sclass == C_BSTAT)
3908 struct internal_syment isym;
3911 /* The value of a C_BSTAT symbol is the symbol table
3912 index of the containing csect. */
3913 bfd_coff_swap_sym_in (output_bfd, (PTR) outsym, (PTR) &isym);
3914 indx = isym.n_value;
3915 if (indx < obj_raw_syment_count (input_bfd))
3919 symindx = finfo->sym_indices[indx];
3923 isym.n_value = symindx;
3924 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym,
3932 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
3934 union internal_auxent aux;
3936 bfd_coff_swap_aux_in (input_bfd, (PTR) esym, isymp->n_type,
3937 isymp->n_sclass, i, isymp->n_numaux,
3940 if (isymp->n_sclass == C_FILE)
3942 /* This is the file name (or some comment put in by
3943 the compiler). If it is long, we must put it in
3944 the string table. */
3945 if (aux.x_file.x_n.x_zeroes == 0
3946 && aux.x_file.x_n.x_offset != 0)
3948 const char *filename;
3951 BFD_ASSERT (aux.x_file.x_n.x_offset
3952 >= STRING_SIZE_SIZE);
3953 if (strings == NULL)
3955 strings = _bfd_coff_read_string_table (input_bfd);
3956 if (strings == NULL)
3959 filename = strings + aux.x_file.x_n.x_offset;
3960 indx = _bfd_stringtab_add (finfo->strtab, filename,
3962 if (indx == (bfd_size_type) -1)
3964 aux.x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
3967 else if ((isymp->n_sclass == C_EXT
3968 || isymp->n_sclass == C_HIDEXT)
3969 && i + 1 == isymp->n_numaux)
3971 /* We don't support type checking. I don't know if
3973 aux.x_csect.x_parmhash = 0;
3974 /* I don't think anybody uses these fields, but we'd
3975 better clobber them just in case. */
3976 aux.x_csect.x_stab = 0;
3977 aux.x_csect.x_snstab = 0;
3978 if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_LD)
3982 indx = aux.x_csect.x_scnlen.l;
3983 if (indx < obj_raw_syment_count (input_bfd))
3987 symindx = finfo->sym_indices[indx];
3989 aux.x_sym.x_tagndx.l = 0;
3991 aux.x_sym.x_tagndx.l = symindx;
3995 else if (isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
3999 if (ISFCN (isymp->n_type)
4000 || ISTAG (isymp->n_sclass)
4001 || isymp->n_sclass == C_BLOCK)
4003 indx = aux.x_sym.x_fcnary.x_fcn.x_endndx.l;
4005 && indx < obj_raw_syment_count (input_bfd))
4007 /* We look forward through the symbol for
4008 the index of the next symbol we are going
4009 to include. I don't know if this is
4011 while (finfo->sym_indices[indx] < 0
4012 && indx < obj_raw_syment_count (input_bfd))
4014 if (indx >= obj_raw_syment_count (input_bfd))
4015 indx = output_index;
4017 indx = finfo->sym_indices[indx];
4018 aux.x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
4022 indx = aux.x_sym.x_tagndx.l;
4023 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
4027 symindx = finfo->sym_indices[indx];
4029 aux.x_sym.x_tagndx.l = 0;
4031 aux.x_sym.x_tagndx.l = symindx;
4035 /* Copy over the line numbers, unless we are stripping
4036 them. We do this on a symbol by symbol basis in
4037 order to more easily handle garbage collection. */
4038 if ((isymp->n_sclass == C_EXT
4039 || isymp->n_sclass == C_HIDEXT)
4041 && isymp->n_numaux > 1
4042 && ISFCN (isymp->n_type)
4043 && aux.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
4045 if (finfo->info->strip != strip_none
4046 && finfo->info->strip != strip_some)
4047 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
4050 asection *enclosing;
4051 unsigned int enc_count;
4052 bfd_size_type linoff;
4053 struct internal_lineno lin;
4056 enclosing = xcoff_section_data (abfd, o)->enclosing;
4057 enc_count = xcoff_section_data (abfd, o)->lineno_count;
4058 if (oline != enclosing)
4060 if (bfd_seek (input_bfd,
4061 enclosing->line_filepos,
4063 || (bfd_read (finfo->linenos, linesz,
4064 enc_count, input_bfd)
4065 != linesz * enc_count))
4070 linoff = (aux.x_sym.x_fcnary.x_fcn.x_lnnoptr
4071 - enclosing->line_filepos);
4073 bfd_coff_swap_lineno_in (input_bfd,
4074 (PTR) (finfo->linenos + linoff),
4077 || ((bfd_size_type) lin.l_addr.l_symndx
4081 obj_coff_external_syms (input_bfd)))
4083 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
4086 bfd_byte *linpend, *linp;
4088 bfd_size_type count;
4090 lin.l_addr.l_symndx = *indexp;
4091 bfd_coff_swap_lineno_out (output_bfd, (PTR) &lin,
4092 (PTR) (finfo->linenos
4095 linpend = (finfo->linenos
4096 + enc_count * linesz);
4097 offset = (o->output_section->vma
4100 for (linp = finfo->linenos + linoff + linesz;
4104 bfd_coff_swap_lineno_in (input_bfd, (PTR) linp,
4106 if (lin.l_lnno == 0)
4108 lin.l_addr.l_paddr += offset;
4109 bfd_coff_swap_lineno_out (output_bfd,
4114 count = (linp - (finfo->linenos + linoff)) / linesz;
4116 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr =
4117 (o->output_section->line_filepos
4118 + o->output_section->lineno_count * linesz);
4120 if (bfd_seek (output_bfd,
4121 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr,
4123 || (bfd_write (finfo->linenos + linoff,
4124 linesz, count, output_bfd)
4128 o->output_section->lineno_count += count;
4132 struct internal_syment *iisp, *iispend;
4136 /* Update any C_BINCL or C_EINCL symbols
4137 that refer to a line number in the
4138 range we just output. */
4139 iisp = finfo->internal_syms;
4141 + obj_raw_syment_count (input_bfd));
4142 iindp = finfo->sym_indices;
4143 oos = finfo->outsyms;
4144 while (iisp < iispend)
4146 if ((iisp->n_sclass == C_BINCL
4147 || iisp->n_sclass == C_EINCL)
4148 && ((bfd_size_type) iisp->n_value
4149 >= enclosing->line_filepos + linoff)
4150 && ((bfd_size_type) iisp->n_value
4151 < (enclosing->line_filepos
4152 + enc_count * linesz)))
4154 struct internal_syment iis;
4156 bfd_coff_swap_sym_in (output_bfd,
4161 - enclosing->line_filepos
4163 + aux.x_sym.x_fcnary.x_fcn.x_lnnoptr);
4164 bfd_coff_swap_sym_out (output_bfd,
4170 iisp += iisp->n_numaux + 1;
4171 iindp += iisp->n_numaux + 1;
4172 oos += (iisp->n_numaux + 1) * osymesz;
4179 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, isymp->n_type,
4180 isymp->n_sclass, i, isymp->n_numaux,
4192 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
4193 symbol will be the first symbol in the next input file. In the
4194 normal case, this will save us from writing out the C_FILE symbol
4196 if (finfo->last_file_index != -1
4197 && (bfd_size_type) finfo->last_file_index >= syment_base)
4199 finfo->last_file.n_value = output_index;
4200 bfd_coff_swap_sym_out (output_bfd, (PTR) &finfo->last_file,
4201 (PTR) (finfo->outsyms
4202 + ((finfo->last_file_index - syment_base)
4206 /* Write the modified symbols to the output file. */
4207 if (outsym > finfo->outsyms)
4209 if (bfd_seek (output_bfd,
4210 obj_sym_filepos (output_bfd) + syment_base * osymesz,
4212 || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1,
4214 != (bfd_size_type) (outsym - finfo->outsyms)))
4217 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
4218 + (outsym - finfo->outsyms) / osymesz)
4221 obj_raw_syment_count (output_bfd) = output_index;
4224 /* Don't let the linker relocation routines discard the symbols. */
4225 keep_syms = obj_coff_keep_syms (input_bfd);
4226 obj_coff_keep_syms (input_bfd) = true;
4228 /* Relocate the contents of each section. */
4229 for (o = input_bfd->sections; o != NULL; o = o->next)
4233 if ((o->flags & SEC_HAS_CONTENTS) == 0
4234 || o->_raw_size == 0
4235 || (o->flags & SEC_IN_MEMORY) != 0)
4238 /* We have set filepos correctly for the sections we created to
4239 represent csects, so bfd_get_section_contents should work. */
4240 if (coff_section_data (input_bfd, o) != NULL
4241 && coff_section_data (input_bfd, o)->contents != NULL)
4242 contents = coff_section_data (input_bfd, o)->contents;
4245 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
4246 (file_ptr) 0, o->_raw_size))
4248 contents = finfo->contents;
4251 if ((o->flags & SEC_RELOC) != 0)
4254 struct internal_reloc *internal_relocs;
4255 struct internal_reloc *irel;
4257 struct internal_reloc *irelend;
4258 struct xcoff_link_hash_entry **rel_hash;
4261 /* Read in the relocs. */
4262 target_index = o->output_section->target_index;
4263 internal_relocs = (xcoff_read_internal_relocs
4264 (input_bfd, o, false, finfo->external_relocs,
4266 (finfo->section_info[target_index].relocs
4267 + o->output_section->reloc_count)));
4268 if (internal_relocs == NULL)
4271 /* Call processor specific code to relocate the section
4273 if (! bfd_coff_relocate_section (output_bfd, finfo->info,
4277 finfo->internal_syms,
4278 xcoff_data (input_bfd)->csects))
4281 offset = o->output_section->vma + o->output_offset - o->vma;
4282 irel = internal_relocs;
4283 irelend = irel + o->reloc_count;
4284 rel_hash = (finfo->section_info[target_index].rel_hashes
4285 + o->output_section->reloc_count);
4286 for (; irel < irelend; irel++, rel_hash++)
4288 struct xcoff_link_hash_entry *h = NULL;
4289 struct internal_ldrel ldrel;
4293 /* Adjust the reloc address and symbol index. */
4295 irel->r_vaddr += offset;
4297 r_symndx = irel->r_symndx;
4301 h = obj_xcoff_sym_hashes (input_bfd)[r_symndx];
4303 && (irel->r_type == R_TOC
4304 || irel->r_type == R_GL
4305 || irel->r_type == R_TCL
4306 || irel->r_type == R_TRL
4307 || irel->r_type == R_TRLA))
4309 /* This is a TOC relative reloc with a symbol
4310 attached. The symbol should be the one which
4311 this reloc is for. We want to make this
4312 reloc against the TOC address of the symbol,
4313 not the symbol itself. */
4314 BFD_ASSERT (h->toc_section != NULL);
4315 BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
4316 if (h->u.toc_indx != -1)
4317 irel->r_symndx = h->u.toc_indx;
4320 struct xcoff_toc_rel_hash *n;
4321 struct xcoff_link_section_info *si;
4323 n = ((struct xcoff_toc_rel_hash *)
4324 bfd_alloc (finfo->output_bfd,
4325 sizeof (struct xcoff_toc_rel_hash)));
4328 bfd_set_error (bfd_error_no_memory);
4331 si = finfo->section_info + target_index;
4332 n->next = si->toc_rel_hashes;
4335 si->toc_rel_hashes = n;
4340 /* This is a global symbol. */
4342 irel->r_symndx = h->indx;
4345 /* This symbol is being written at the end
4346 of the file, and we do not yet know the
4347 symbol index. We save the pointer to the
4348 hash table entry in the rel_hash list.
4349 We set the indx field to -2 to indicate
4350 that this symbol must not be stripped. */
4359 indx = finfo->sym_indices[r_symndx];
4363 struct internal_syment *is;
4365 /* Relocations against a TC0 TOC anchor are
4366 automatically transformed to be against
4367 the TOC anchor in the output file. */
4368 is = finfo->internal_syms + r_symndx;
4369 if (is->n_sclass == C_HIDEXT
4370 && is->n_numaux > 0)
4373 union internal_auxent aux;
4377 obj_coff_external_syms (input_bfd))
4378 + ((r_symndx + is->n_numaux)
4380 bfd_coff_swap_aux_in (input_bfd, auxptr,
4381 is->n_type, is->n_sclass,
4385 if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_SD
4386 && aux.x_csect.x_smclas == XMC_TC0)
4387 indx = finfo->toc_symindx;
4392 irel->r_symndx = indx;
4395 struct internal_syment *is;
4397 char buf[SYMNMLEN + 1];
4399 /* This reloc is against a symbol we are
4400 stripping. It would be possible to handle
4401 this case, but I don't think it's worth it. */
4402 is = finfo->internal_syms + r_symndx;
4404 name = (_bfd_coff_internal_syment_name
4405 (input_bfd, is, buf));
4409 if (! ((*finfo->info->callbacks->unattached_reloc)
4410 (finfo->info, name, input_bfd, o,
4417 switch (irel->r_type)
4421 || h->root.type == bfd_link_hash_defined
4422 || h->root.type == bfd_link_hash_defweak
4423 || h->root.type == bfd_link_hash_common)
4430 /* This reloc needs to be copied into the .loader
4432 ldrel.l_vaddr = irel->r_vaddr;
4434 ldrel.l_symndx = -1;
4436 || (h->root.type == bfd_link_hash_defined
4437 || h->root.type == bfd_link_hash_defweak
4438 || h->root.type == bfd_link_hash_common))
4443 sec = xcoff_data (input_bfd)->csects[r_symndx];
4444 else if (h->root.type == bfd_link_hash_common)
4445 sec = h->root.u.c.p->section;
4447 sec = h->root.u.def.section;
4448 sec = sec->output_section;
4450 if (strcmp (sec->name, ".text") == 0)
4452 else if (strcmp (sec->name, ".data") == 0)
4454 else if (strcmp (sec->name, ".bss") == 0)
4458 (*_bfd_error_handler)
4459 ("%s: loader reloc in unrecognized section `%s'",
4460 bfd_get_filename (input_bfd),
4462 bfd_set_error (bfd_error_nonrepresentable_section);
4470 (*_bfd_error_handler)
4471 ("%s: `%s' in loader reloc but not loader sym",
4472 bfd_get_filename (input_bfd),
4473 h->root.root.string);
4474 bfd_set_error (bfd_error_bad_value);
4477 ldrel.l_symndx = h->ldindx;
4479 ldrel.l_rtype = (irel->r_size << 8) | irel->r_type;
4480 ldrel.l_rsecnm = o->output_section->target_index;
4481 if (xcoff_hash_table (finfo->info)->textro
4482 && strcmp (o->output_section->name, ".text") == 0)
4484 (*_bfd_error_handler)
4485 ("%s: loader reloc in read-only section %s",
4486 bfd_get_filename (input_bfd),
4487 bfd_get_section_name (finfo->output_bfd,
4488 o->output_section));
4489 bfd_set_error (bfd_error_invalid_operation);
4492 xcoff_swap_ldrel_out (output_bfd, &ldrel,
4494 BFD_ASSERT (sizeof (struct external_ldrel) == LDRELSZ);
4503 /* We should never need a .loader reloc for a TOC
4509 o->output_section->reloc_count += o->reloc_count;
4512 /* Write out the modified section contents. */
4513 if (! bfd_set_section_contents (output_bfd, o->output_section,
4514 contents, o->output_offset,
4515 (o->_cooked_size != 0
4521 obj_coff_keep_syms (input_bfd) = keep_syms;
4523 if (! finfo->info->keep_memory)
4525 if (! _bfd_coff_free_symbols (input_bfd))
4535 /* Write out a non-XCOFF global symbol. */
4538 xcoff_write_global_symbol (h, p)
4539 struct xcoff_link_hash_entry *h;
4542 struct xcoff_final_link_info *finfo = (struct xcoff_final_link_info *) p;
4545 struct internal_syment isym;
4546 union internal_auxent aux;
4548 output_bfd = finfo->output_bfd;
4550 /* If this symbol was garbage collected, just skip it. */
4551 if (xcoff_hash_table (finfo->info)->gc
4552 && (h->flags & XCOFF_MARK) == 0)
4555 /* If we need a .loader section entry, write it out. */
4556 if (h->ldsym != NULL)
4558 struct internal_ldsym *ldsym;
4563 if (h->root.type == bfd_link_hash_undefined
4564 || h->root.type == bfd_link_hash_undefweak)
4567 ldsym->l_scnum = N_UNDEF;
4568 ldsym->l_smtype = XTY_ER;
4569 impbfd = h->root.u.undef.abfd;
4571 else if (h->root.type == bfd_link_hash_defined
4572 || h->root.type == bfd_link_hash_defweak)
4576 sec = h->root.u.def.section;
4577 ldsym->l_value = (sec->output_section->vma
4578 + sec->output_offset
4579 + h->root.u.def.value);
4580 ldsym->l_scnum = sec->output_section->target_index;
4581 ldsym->l_smtype = XTY_SD;
4582 impbfd = sec->owner;
4587 if (((h->flags & XCOFF_DEF_REGULAR) == 0
4588 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
4589 || (h->flags & XCOFF_IMPORT) != 0)
4590 ldsym->l_smtype |= L_IMPORT;
4591 if (((h->flags & XCOFF_DEF_REGULAR) != 0
4592 && (h->flags & XCOFF_REF_DYNAMIC) != 0)
4593 || (h->flags & XCOFF_EXPORT) != 0)
4594 ldsym->l_smtype |= L_EXPORT;
4595 if ((h->flags & XCOFF_ENTRY) != 0)
4596 ldsym->l_smtype |= L_ENTRY;
4598 ldsym->l_smclas = h->smclas;
4600 if (ldsym->l_ifile == (bfd_size_type) -1)
4602 else if (ldsym->l_ifile == 0)
4604 if ((ldsym->l_smtype & L_IMPORT) == 0)
4606 else if (impbfd == NULL)
4610 BFD_ASSERT (impbfd->xvec == output_bfd->xvec);
4611 ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
4617 BFD_ASSERT (h->ldindx >= 0);
4618 BFD_ASSERT (LDSYMSZ == sizeof (struct external_ldsym));
4619 xcoff_swap_ldsym_out (output_bfd, ldsym, finfo->ldsym + h->ldindx - 3);
4623 /* If this symbol needs global linkage code, write it out. */
4624 if (h->root.type == bfd_link_hash_defined
4625 && (h->root.u.def.section
4626 == xcoff_hash_table (finfo->info)->linkage_section))
4632 p = h->root.u.def.section->contents + h->root.u.def.value;
4634 /* The first instruction in the global linkage code loads a
4635 specific TOC element. */
4636 tocoff = (h->descriptor->toc_section->output_section->vma
4637 + h->descriptor->toc_section->output_offset
4638 - xcoff_data (output_bfd)->toc);
4639 if ((h->descriptor->flags & XCOFF_SET_TOC) != 0)
4640 tocoff += h->descriptor->u.toc_offset;
4641 bfd_put_32 (output_bfd, XCOFF_GLINK_FIRST | tocoff, p);
4643 i < sizeof xcoff_glink_code / sizeof xcoff_glink_code[0];
4645 bfd_put_32 (output_bfd, xcoff_glink_code[i], p);
4648 /* If we created a TOC entry for this symbol, write out the required
4650 if ((h->flags & XCOFF_SET_TOC) != 0)
4655 struct internal_reloc *irel;
4656 struct internal_ldrel ldrel;
4658 tocsec = h->toc_section;
4659 osec = tocsec->output_section;
4660 oindx = osec->target_index;
4661 irel = finfo->section_info[oindx].relocs + osec->reloc_count;
4662 irel->r_vaddr = (osec->vma
4663 + tocsec->output_offset
4666 irel->r_symndx = h->indx;
4670 irel->r_symndx = obj_raw_syment_count (output_bfd);
4672 irel->r_type = R_POS;
4674 finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
4675 ++osec->reloc_count;
4677 BFD_ASSERT (h->ldindx >= 0);
4678 ldrel.l_vaddr = irel->r_vaddr;
4679 ldrel.l_symndx = h->ldindx;
4680 ldrel.l_rtype = (31 << 8) | R_POS;
4681 ldrel.l_rsecnm = oindx;
4682 xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
4690 && (finfo->info->strip == strip_all
4691 || (finfo->info->strip == strip_some
4692 && (bfd_hash_lookup (finfo->info->keep_hash,
4693 h->root.root.string, false, false)
4698 && (h->flags & (XCOFF_REF_REGULAR | XCOFF_DEF_REGULAR)) == 0)
4701 outsym = finfo->outsyms;
4703 memset (&aux, 0, sizeof aux);
4705 h->indx = obj_raw_syment_count (output_bfd);
4707 if (strlen (h->root.root.string) <= SYMNMLEN)
4708 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
4715 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
4717 indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
4719 if (indx == (bfd_size_type) -1)
4721 isym._n._n_n._n_zeroes = 0;
4722 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
4725 if (h->root.type == bfd_link_hash_undefined
4726 || h->root.type == bfd_link_hash_undefweak)
4729 isym.n_scnum = N_UNDEF;
4730 isym.n_sclass = C_EXT;
4731 aux.x_csect.x_smtyp = XTY_ER;
4733 else if (h->root.type == bfd_link_hash_defined
4734 || h->root.type == bfd_link_hash_defweak)
4736 struct xcoff_link_size_list *l;
4738 isym.n_value = (h->root.u.def.section->output_section->vma
4739 + h->root.u.def.section->output_offset
4740 + h->root.u.def.value);
4741 isym.n_scnum = h->root.u.def.section->output_section->target_index;
4742 isym.n_sclass = C_HIDEXT;
4743 aux.x_csect.x_smtyp = XTY_SD;
4745 if ((h->flags & XCOFF_HAS_SIZE) != 0)
4747 for (l = xcoff_hash_table (finfo->info)->size_list;
4753 aux.x_csect.x_scnlen.l = l->size;
4759 else if (h->root.type == bfd_link_hash_common)
4761 isym.n_value = (h->root.u.c.p->section->output_section->vma
4762 + h->root.u.c.p->section->output_offset);
4763 isym.n_scnum = h->root.u.c.p->section->output_section->target_index;
4764 isym.n_sclass = C_EXT;
4765 aux.x_csect.x_smtyp = XTY_CM;
4766 aux.x_csect.x_scnlen.l = h->root.u.c.size;
4771 isym.n_type = T_NULL;
4774 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
4775 outsym += bfd_coff_symesz (output_bfd);
4777 aux.x_csect.x_smclas = h->smclas;
4779 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, isym.n_sclass, 0, 1,
4781 outsym += bfd_coff_auxesz (output_bfd);
4783 if (h->root.type == bfd_link_hash_defined
4784 || h->root.type == bfd_link_hash_defweak)
4786 /* We just output an SD symbol. Now output an LD symbol. */
4790 isym.n_sclass = C_EXT;
4791 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
4792 outsym += bfd_coff_symesz (output_bfd);
4794 aux.x_csect.x_smtyp = XTY_LD;
4795 aux.x_csect.x_scnlen.l = obj_raw_syment_count (output_bfd);
4797 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, C_EXT, 0, 1,
4799 outsym += bfd_coff_auxesz (output_bfd);
4802 if (bfd_seek (output_bfd,
4803 (obj_sym_filepos (output_bfd)
4804 + (obj_raw_syment_count (output_bfd)
4805 * bfd_coff_symesz (output_bfd))),
4807 || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1, output_bfd)
4808 != (bfd_size_type) (outsym - finfo->outsyms)))
4810 obj_raw_syment_count (output_bfd) +=
4811 (outsym - finfo->outsyms) / bfd_coff_symesz (output_bfd);
4816 /* Handle a link order which is supposed to generate a reloc. */
4819 xcoff_reloc_link_order (output_bfd, finfo, output_section, link_order)
4821 struct xcoff_final_link_info *finfo;
4822 asection *output_section;
4823 struct bfd_link_order *link_order;
4825 reloc_howto_type *howto;
4826 struct xcoff_link_hash_entry *h;
4830 struct internal_reloc *irel;
4831 struct xcoff_link_hash_entry **rel_hash_ptr;
4832 struct internal_ldrel ldrel;
4834 if (link_order->type == bfd_section_reloc_link_order)
4836 /* We need to somehow locate a symbol in the right section. The
4837 symbol must either have a value of zero, or we must adjust
4838 the addend by the value of the symbol. FIXME: Write this
4839 when we need it. The old linker couldn't handle this anyhow. */
4843 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
4846 bfd_set_error (bfd_error_bad_value);
4850 h = xcoff_link_hash_lookup (xcoff_hash_table (finfo->info),
4851 link_order->u.reloc.p->u.name,
4852 false, false, true);
4855 if (! ((*finfo->info->callbacks->unattached_reloc)
4856 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
4857 (asection *) NULL, (bfd_vma) 0)))
4862 if (h->root.type == bfd_link_hash_common)
4864 hsec = h->root.u.c.p->section;
4867 else if (h->root.type == bfd_link_hash_defined
4868 || h->root.type == bfd_link_hash_defweak)
4870 hsec = h->root.u.def.section;
4871 hval = h->root.u.def.value;
4879 addend = link_order->u.reloc.p->addend;
4881 addend += (hsec->output_section->vma
4882 + hsec->output_offset
4889 bfd_reloc_status_type rstat;
4892 size = bfd_get_reloc_size (howto);
4893 buf = (bfd_byte *) bfd_zmalloc (size);
4896 bfd_set_error (bfd_error_no_memory);
4900 rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
4906 case bfd_reloc_outofrange:
4908 case bfd_reloc_overflow:
4909 if (! ((*finfo->info->callbacks->reloc_overflow)
4910 (finfo->info, link_order->u.reloc.p->u.name,
4911 howto->name, addend, (bfd *) NULL, (asection *) NULL,
4919 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
4920 (file_ptr) link_order->offset, size);
4926 /* Store the reloc information in the right place. It will get
4927 swapped and written out at the end of the final_link routine. */
4929 irel = (finfo->section_info[output_section->target_index].relocs
4930 + output_section->reloc_count);
4931 rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
4932 + output_section->reloc_count);
4934 memset (irel, 0, sizeof (struct internal_reloc));
4935 *rel_hash_ptr = NULL;
4937 irel->r_vaddr = output_section->vma + link_order->offset;
4940 irel->r_symndx = h->indx;
4943 /* Set the index to -2 to force this symbol to get written out. */
4949 irel->r_type = howto->type;
4950 irel->r_size = howto->bitsize - 1;
4951 if (howto->complain_on_overflow == complain_overflow_signed)
4952 irel->r_size |= 0x80;
4954 ++output_section->reloc_count;
4956 /* Now output the reloc to the .loader section. */
4958 ldrel.l_vaddr = irel->r_vaddr;
4962 const char *secname;
4964 secname = hsec->output_section->name;
4966 if (strcmp (secname, ".text") == 0)
4968 else if (strcmp (secname, ".data") == 0)
4970 else if (strcmp (secname, ".bss") == 0)
4974 (*_bfd_error_handler)
4975 ("%s: loader reloc in unrecognized section `%s'",
4976 bfd_get_filename (output_bfd), secname);
4977 bfd_set_error (bfd_error_nonrepresentable_section);
4985 (*_bfd_error_handler)
4986 ("%s: `%s' in loader reloc but not loader sym",
4987 bfd_get_filename (output_bfd),
4988 h->root.root.string);
4989 bfd_set_error (bfd_error_bad_value);
4992 ldrel.l_symndx = h->ldindx;
4995 ldrel.l_rtype = (irel->r_size << 8) | irel->r_type;
4996 ldrel.l_rsecnm = output_section->target_index;
4997 xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5003 /* Sort relocs by VMA. This is called via qsort. */
5006 xcoff_sort_relocs (p1, p2)
5010 const struct internal_reloc *r1 = (const struct internal_reloc *) p1;
5011 const struct internal_reloc *r2 = (const struct internal_reloc *) p2;
5013 if (r1->r_vaddr > r2->r_vaddr)
5015 else if (r1->r_vaddr < r2->r_vaddr)
5021 /* This is the relocation function for the RS/6000/POWER/PowerPC.
5022 This is currently the only processor which uses XCOFF; I hope that
5023 will never change. */
5026 _bfd_ppc_xcoff_relocate_section (output_bfd, info, input_bfd,
5027 input_section, contents, relocs, syms,
5030 struct bfd_link_info *info;
5032 asection *input_section;
5034 struct internal_reloc *relocs;
5035 struct internal_syment *syms;
5036 asection **sections;
5038 struct internal_reloc *rel;
5039 struct internal_reloc *relend;
5042 relend = rel + input_section->reloc_count;
5043 for (; rel < relend; rel++)
5046 struct xcoff_link_hash_entry *h;
5047 struct internal_syment *sym;
5050 struct reloc_howto_struct howto;
5051 bfd_reloc_status_type rstat;
5053 /* Relocation type R_REF is a special relocation type which is
5054 merely used to prevent garbage collection from occurring for
5055 the csect including the symbol which it references. */
5056 if (rel->r_type == R_REF)
5059 symndx = rel->r_symndx;
5069 h = obj_xcoff_sym_hashes (input_bfd)[symndx];
5070 sym = syms + symndx;
5071 addend = - sym->n_value;
5074 /* We build the howto information on the fly. */
5076 howto.type = rel->r_type;
5077 howto.rightshift = 0;
5079 howto.bitsize = (rel->r_size & 0x1f) + 1;
5080 howto.pc_relative = false;
5082 if ((rel->r_size & 0x80) != 0)
5083 howto.complain_on_overflow = complain_overflow_signed;
5085 howto.complain_on_overflow = complain_overflow_bitfield;
5086 howto.special_function = NULL;
5087 howto.name = "internal";
5088 howto.partial_inplace = true;
5089 if (howto.bitsize == 32)
5090 howto.src_mask = howto.dst_mask = 0xffffffff;
5093 howto.src_mask = howto.dst_mask = (1 << howto.bitsize) - 1;
5094 if (howto.bitsize == 16)
5097 howto.pcrel_offset = false;
5107 sec = bfd_abs_section_ptr;
5112 sec = sections[symndx];
5113 val = (sec->output_section->vma
5114 + sec->output_offset
5121 if (h->root.type == bfd_link_hash_defined
5122 || h->root.type == bfd_link_hash_defweak)
5126 sec = h->root.u.def.section;
5127 val = (h->root.u.def.value
5128 + sec->output_section->vma
5129 + sec->output_offset);
5131 else if (h->root.type == bfd_link_hash_common)
5135 sec = h->root.u.c.p->section;
5136 val = (sec->output_section->vma
5137 + sec->output_offset);
5139 else if ((h->flags & XCOFF_REF_DYNAMIC) != 0
5140 || (h->flags & XCOFF_IMPORT) != 0)
5142 /* Every symbol in a shared object is defined somewhere. */
5145 else if (! info->relocateable)
5147 if (! ((*info->callbacks->undefined_symbol)
5148 (info, h->root.root.string, input_bfd, input_section,
5149 rel->r_vaddr - input_section->vma)))
5154 /* I took the relocation type definitions from two documents:
5155 the PowerPC AIX Version 4 Application Binary Interface, First
5156 Edition (April 1992), and the PowerOpen ABI, Big-Endian
5157 32-Bit Hardware Implementation (June 30, 1994). Differences
5158 between the documents are noted below. */
5160 switch (rel->r_type)
5165 /* These relocs are defined by the PowerPC ABI to be
5166 relative branches which use half of the difference
5167 between the symbol and the program counter. I can't
5168 quite figure out when this is useful. These relocs are
5169 not defined by the PowerOpen ABI. */
5171 (*_bfd_error_handler)
5172 ("%s: unsupported relocation type 0x%02x",
5173 bfd_get_filename (input_bfd), (unsigned int) rel->r_type);
5174 bfd_set_error (bfd_error_bad_value);
5177 /* Simple positive relocation. */
5180 /* Simple negative relocation. */
5184 /* Simple PC relative relocation. */
5185 howto.pc_relative = true;
5188 /* TOC relative relocation. The value in the instruction in
5189 the input file is the offset from the input file TOC to
5190 the desired location. We want the offset from the final
5191 TOC to the desired location. We have:
5196 so we must change insn by on - in.
5199 /* Global linkage relocation. The value of this relocation
5200 is the address of the entry in the TOC section. */
5202 /* Local object TOC address. I can't figure out the
5203 difference between this and case R_GL. */
5205 /* TOC relative relocation. A TOC relative load instruction
5206 which may be changed to a load address instruction.
5207 FIXME: We don't currently implement this optimization. */
5209 /* TOC relative relocation. This is a TOC relative load
5210 address instruction which may be changed to a load
5211 instruction. FIXME: I don't know if this is the correct
5213 if (h != NULL && h->toc_section == NULL)
5215 (*_bfd_error_handler)
5216 ("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry",
5217 bfd_get_filename (input_bfd), rel->r_vaddr,
5218 h->root.root.string);
5219 bfd_set_error (bfd_error_bad_value);
5224 BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
5225 val = (h->toc_section->output_section->vma
5226 + h->toc_section->output_offset);
5228 val = ((val - xcoff_data (output_bfd)->toc)
5229 - (sym->n_value - xcoff_data (input_bfd)->toc));
5233 /* Absolute branch. We don't want to mess with the lower
5234 two bits of the instruction. */
5236 /* The PowerPC ABI defines this as an absolute call which
5237 may be modified to become a relative call. The PowerOpen
5238 ABI does not define this relocation type. */
5240 /* Absolute branch which may be modified to become a
5243 /* The PowerPC ABI defines this as an absolute branch to a
5244 fixed address which may be modified to an absolute branch
5245 to a symbol. The PowerOpen ABI does not define this
5248 /* The PowerPC ABI defines this as an absolute branch to a
5249 fixed address which may be modified to a relative branch.
5250 The PowerOpen ABI does not define this relocation type. */
5251 howto.src_mask &= ~3;
5252 howto.dst_mask = howto.src_mask;
5255 /* Relative branch. We don't want to mess with the lower
5256 two bits of the instruction. */
5258 /* The PowerPC ABI defines this as a relative call which may
5259 be modified to become an absolute call. The PowerOpen
5260 ABI does not define this relocation type. */
5262 /* A relative branch which may be modified to become an
5263 absolute branch. FIXME: We don't implement this,
5264 although we should for symbols of storage mapping class
5266 howto.pc_relative = true;
5267 howto.src_mask &= ~3;
5268 howto.dst_mask = howto.src_mask;
5271 /* The PowerPC AIX ABI describes this as a load which may be
5272 changed to a load address. The PowerOpen ABI says this
5273 is the same as case R_POS. */
5276 /* The PowerPC AIX ABI describes this as a load address
5277 which may be changed to a load. The PowerOpen ABI says
5278 this is the same as R_POS. */
5282 /* If we see an R_BR or R_RBR reloc which is jumping to global
5283 linkage code, and it is followed by an appropriate cror nop
5284 instruction, we replace the cror with lwz r2,20(r1). This
5285 restores the TOC after the glink code. Contrariwise, if the
5286 call is followed by a lwz r2,20(r1), but the call is not
5287 going to global linkage code, we can replace the load with a
5289 if ((rel->r_type == R_BR || rel->r_type == R_RBR)
5291 && h->root.type == bfd_link_hash_defined
5292 && (rel->r_vaddr - input_section->vma + 8
5293 <= input_section->_cooked_size))
5298 pnext = contents + (rel->r_vaddr - input_section->vma) + 4;
5299 next = bfd_get_32 (input_bfd, pnext);
5300 if (h->smclas == XMC_GL)
5302 if (next == 0x4def7b82 /* cror 15,15,15 */
5303 || next == 0x4ffffb82) /* cror 31,31,31 */
5304 bfd_put_32 (input_bfd, 0x80410014, pnext); /* lwz r1,20(r1) */
5308 if (next == 0x80410014) /* lwz r1,20(r1) */
5309 bfd_put_32 (input_bfd, 0x4ffffb82, pnext); /* cror 31,31,31 */
5313 /* A PC relative reloc includes the section address. */
5314 if (howto.pc_relative)
5315 addend += input_section->vma;
5317 rstat = _bfd_final_link_relocate (&howto, input_bfd, input_section,
5319 rel->r_vaddr - input_section->vma,
5328 case bfd_reloc_overflow:
5331 char buf[SYMNMLEN + 1];
5332 char howto_name[10];
5337 name = h->root.root.string;
5340 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
5344 sprintf (howto_name, "0x%02x", rel->r_type);
5346 if (! ((*info->callbacks->reloc_overflow)
5347 (info, name, howto_name, (bfd_vma) 0, input_bfd,
5348 input_section, rel->r_vaddr - input_section->vma)))