daily update
[binutils.git] / bfd / xcofflink.c
blobccd82befdac005dd0cd6ec120670154d3edce466
1 /* POWER/PowerPC XCOFF linker support.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@cygnus.com>, Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #include "bfd.h"
23 #include "sysdep.h"
24 #include "bfdlink.h"
25 #include "libbfd.h"
26 #include "coff/internal.h"
27 #include "coff/xcoff.h"
28 #include "libcoff.h"
29 #include "libxcoff.h"
31 /* This file holds the XCOFF linker code. */
33 #define STRING_SIZE_SIZE (4)
35 /* We reuse the SEC_ROM flag as a mark flag for garbage collection.
36 This flag will only be used on input sections. */
38 #define SEC_MARK (SEC_ROM)
40 /* The list of import files. */
42 struct xcoff_import_file
44 /* The next entry in the list. */
45 struct xcoff_import_file *next;
46 /* The path. */
47 const char *path;
48 /* The file name. */
49 const char *file;
50 /* The member name. */
51 const char *member;
54 /* Information we keep for each section in the output file during the
55 final link phase. */
57 struct xcoff_link_section_info
59 /* The relocs to be output. */
60 struct internal_reloc *relocs;
61 /* For each reloc against a global symbol whose index was not known
62 when the reloc was handled, the global hash table entry. */
63 struct xcoff_link_hash_entry **rel_hashes;
64 /* If there is a TOC relative reloc against a global symbol, and the
65 index of the TOC symbol is not known when the reloc was handled,
66 an entry is added to this linked list. This is not an array,
67 like rel_hashes, because this case is quite uncommon. */
68 struct xcoff_toc_rel_hash {
69 struct xcoff_toc_rel_hash *next;
70 struct xcoff_link_hash_entry *h;
71 struct internal_reloc *rel;
72 } *toc_rel_hashes;
75 /* Information that we pass around while doing the final link step. */
77 struct xcoff_final_link_info
79 /* General link information. */
80 struct bfd_link_info *info;
81 /* Output BFD. */
82 bfd *output_bfd;
83 /* Hash table for long symbol names. */
84 struct bfd_strtab_hash *strtab;
85 /* Array of information kept for each output section, indexed by the
86 target_index field. */
87 struct xcoff_link_section_info *section_info;
88 /* Symbol index of last C_FILE symbol (-1 if none). */
89 long last_file_index;
90 /* Contents of last C_FILE symbol. */
91 struct internal_syment last_file;
92 /* Symbol index of TOC symbol. */
93 long toc_symindx;
94 /* Start of .loader symbols. */
95 bfd_byte *ldsym;
96 /* Next .loader reloc to swap out. */
97 bfd_byte *ldrel;
98 /* File position of start of line numbers. */
99 file_ptr line_filepos;
100 /* Buffer large enough to hold swapped symbols of any input file. */
101 struct internal_syment *internal_syms;
102 /* Buffer large enough to hold output indices of symbols of any
103 input file. */
104 long *sym_indices;
105 /* Buffer large enough to hold output symbols for any input file. */
106 bfd_byte *outsyms;
107 /* Buffer large enough to hold external line numbers for any input
108 section. */
109 bfd_byte *linenos;
110 /* Buffer large enough to hold any input section. */
111 bfd_byte *contents;
112 /* Buffer large enough to hold external relocs of any input section. */
113 bfd_byte *external_relocs;
116 static struct bfd_hash_entry *xcoff_link_hash_newfunc
117 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
118 static bfd_boolean xcoff_get_section_contents PARAMS ((bfd *, asection *));
119 static struct internal_reloc *xcoff_read_internal_relocs
120 PARAMS ((bfd *, asection *, bfd_boolean, bfd_byte *, bfd_boolean,
121 struct internal_reloc *));
122 static bfd_boolean xcoff_link_add_object_symbols
123 PARAMS ((bfd *, struct bfd_link_info *));
124 static bfd_boolean xcoff_link_check_archive_element
125 PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean *));
126 static bfd_boolean xcoff_link_check_ar_symbols
127 PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean *));
128 static bfd_boolean xcoff_link_check_dynamic_ar_symbols
129 PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean *));
130 static bfd_size_type xcoff_find_reloc
131 PARAMS ((struct internal_reloc *, bfd_size_type, bfd_vma));
132 static bfd_boolean xcoff_link_add_symbols
133 PARAMS ((bfd *, struct bfd_link_info *));
134 static bfd_boolean xcoff_link_add_dynamic_symbols
135 PARAMS ((bfd *, struct bfd_link_info *));
136 static bfd_boolean xcoff_mark_symbol
137 PARAMS ((struct bfd_link_info *, struct xcoff_link_hash_entry *));
138 static bfd_boolean xcoff_mark PARAMS ((struct bfd_link_info *, asection *));
139 static void xcoff_sweep PARAMS ((struct bfd_link_info *));
140 static bfd_boolean xcoff_build_ldsyms
141 PARAMS ((struct xcoff_link_hash_entry *, PTR));
142 static bfd_boolean xcoff_link_input_bfd
143 PARAMS ((struct xcoff_final_link_info *, bfd *));
144 static bfd_boolean xcoff_write_global_symbol
145 PARAMS ((struct xcoff_link_hash_entry *, PTR));
146 static bfd_boolean xcoff_reloc_link_order
147 PARAMS ((bfd *, struct xcoff_final_link_info *, asection *,
148 struct bfd_link_order *));
149 static int xcoff_sort_relocs PARAMS ((const PTR, const PTR));
152 /* Routines to read XCOFF dynamic information. This don't really
153 belong here, but we already have the ldsym manipulation routines
154 here. */
156 /* Read the contents of a section. */
158 static bfd_boolean
159 xcoff_get_section_contents (abfd, sec)
160 bfd *abfd;
161 asection *sec;
164 if (coff_section_data (abfd, sec) == NULL)
166 bfd_size_type amt = sizeof (struct coff_section_tdata);
167 sec->used_by_bfd = bfd_zalloc (abfd, amt);
168 if (sec->used_by_bfd == NULL)
169 return FALSE;
172 if (coff_section_data (abfd, sec)->contents == NULL)
174 coff_section_data (abfd, sec)->contents = ((bfd_byte *)
175 bfd_malloc (sec->_raw_size));
176 if (coff_section_data (abfd, sec)->contents == NULL)
177 return FALSE;
179 if (! bfd_get_section_contents (abfd, sec,
180 coff_section_data (abfd, sec)->contents,
181 (file_ptr) 0, sec->_raw_size))
182 return FALSE;
185 return TRUE;
188 /* Get the size required to hold the dynamic symbols. */
190 long
191 _bfd_xcoff_get_dynamic_symtab_upper_bound (abfd)
192 bfd *abfd;
194 asection *lsec;
195 bfd_byte *contents;
196 struct internal_ldhdr ldhdr;
198 if ((abfd->flags & DYNAMIC) == 0)
200 bfd_set_error (bfd_error_invalid_operation);
201 return -1;
204 lsec = bfd_get_section_by_name (abfd, ".loader");
205 if (lsec == NULL)
207 bfd_set_error (bfd_error_no_symbols);
208 return -1;
211 if (! xcoff_get_section_contents (abfd, lsec))
212 return -1;
213 contents = coff_section_data (abfd, lsec)->contents;
215 bfd_xcoff_swap_ldhdr_in (abfd, (PTR) contents, &ldhdr);
217 return (ldhdr.l_nsyms + 1) * sizeof (asymbol *);
220 /* Get the dynamic symbols. */
222 long
223 _bfd_xcoff_canonicalize_dynamic_symtab (abfd, psyms)
224 bfd *abfd;
225 asymbol **psyms;
227 asection *lsec;
228 bfd_byte *contents;
229 struct internal_ldhdr ldhdr;
230 const char *strings;
231 bfd_byte *elsym, *elsymend;
232 coff_symbol_type *symbuf;
234 if ((abfd->flags & DYNAMIC) == 0)
236 bfd_set_error (bfd_error_invalid_operation);
237 return -1;
240 lsec = bfd_get_section_by_name (abfd, ".loader");
241 if (lsec == NULL)
243 bfd_set_error (bfd_error_no_symbols);
244 return -1;
247 if (! xcoff_get_section_contents (abfd, lsec))
248 return -1;
249 contents = coff_section_data (abfd, lsec)->contents;
251 coff_section_data (abfd, lsec)->keep_contents = TRUE;
253 bfd_xcoff_swap_ldhdr_in (abfd, contents, &ldhdr);
255 strings = (char *) contents + ldhdr.l_stoff;
257 symbuf = ((coff_symbol_type *)
258 bfd_zalloc (abfd, ldhdr.l_nsyms * sizeof (coff_symbol_type)));
259 if (symbuf == NULL)
260 return -1;
262 elsym = contents + bfd_xcoff_loader_symbol_offset(abfd, &ldhdr);
264 elsymend = elsym + ldhdr.l_nsyms * bfd_xcoff_ldsymsz(abfd);
265 for (; elsym < elsymend; elsym += bfd_xcoff_ldsymsz(abfd), symbuf++, psyms++)
267 struct internal_ldsym ldsym;
269 bfd_xcoff_swap_ldsym_in (abfd, elsym, &ldsym);
271 symbuf->symbol.the_bfd = abfd;
273 if (ldsym._l._l_l._l_zeroes == 0)
274 symbuf->symbol.name = strings + ldsym._l._l_l._l_offset;
275 else
277 char *c;
279 c = bfd_alloc (abfd, (bfd_size_type) SYMNMLEN + 1);
280 if (c == NULL)
281 return -1;
282 memcpy (c, ldsym._l._l_name, SYMNMLEN);
283 c[SYMNMLEN] = '\0';
284 symbuf->symbol.name = c;
287 if (ldsym.l_smclas == XMC_XO)
288 symbuf->symbol.section = bfd_abs_section_ptr;
289 else
290 symbuf->symbol.section = coff_section_from_bfd_index (abfd,
291 ldsym.l_scnum);
292 symbuf->symbol.value = ldsym.l_value - symbuf->symbol.section->vma;
294 symbuf->symbol.flags = BSF_NO_FLAGS;
295 if ((ldsym.l_smtype & L_EXPORT) != 0)
296 symbuf->symbol.flags |= BSF_GLOBAL;
298 /* FIXME: We have no way to record the other information stored
299 with the loader symbol. */
301 *psyms = (asymbol *) symbuf;
304 *psyms = NULL;
306 return ldhdr.l_nsyms;
309 /* Get the size required to hold the dynamic relocs. */
311 long
312 _bfd_xcoff_get_dynamic_reloc_upper_bound (abfd)
313 bfd *abfd;
315 asection *lsec;
316 bfd_byte *contents;
317 struct internal_ldhdr ldhdr;
319 if ((abfd->flags & DYNAMIC) == 0)
321 bfd_set_error (bfd_error_invalid_operation);
322 return -1;
325 lsec = bfd_get_section_by_name (abfd, ".loader");
326 if (lsec == NULL)
328 bfd_set_error (bfd_error_no_symbols);
329 return -1;
332 if (! xcoff_get_section_contents (abfd, lsec))
333 return -1;
334 contents = coff_section_data (abfd, lsec)->contents;
336 bfd_xcoff_swap_ldhdr_in (abfd, (struct external_ldhdr *) contents, &ldhdr);
338 return (ldhdr.l_nreloc + 1) * sizeof (arelent *);
341 /* Get the dynamic relocs. */
343 long
344 _bfd_xcoff_canonicalize_dynamic_reloc (abfd, prelocs, syms)
345 bfd *abfd;
346 arelent **prelocs;
347 asymbol **syms;
349 asection *lsec;
350 bfd_byte *contents;
351 struct internal_ldhdr ldhdr;
352 arelent *relbuf;
353 bfd_byte *elrel, *elrelend;
355 if ((abfd->flags & DYNAMIC) == 0)
357 bfd_set_error (bfd_error_invalid_operation);
358 return -1;
361 lsec = bfd_get_section_by_name (abfd, ".loader");
362 if (lsec == NULL)
364 bfd_set_error (bfd_error_no_symbols);
365 return -1;
368 if (! xcoff_get_section_contents (abfd, lsec))
369 return -1;
370 contents = coff_section_data (abfd, lsec)->contents;
372 bfd_xcoff_swap_ldhdr_in (abfd, contents, &ldhdr);
374 relbuf = (arelent *) bfd_alloc (abfd, ldhdr.l_nreloc * sizeof (arelent));
375 if (relbuf == NULL)
376 return -1;
378 elrel = contents + bfd_xcoff_loader_reloc_offset(abfd, &ldhdr);
380 elrelend = elrel + ldhdr.l_nreloc * bfd_xcoff_ldrelsz(abfd);
381 for (; elrel < elrelend; elrel += bfd_xcoff_ldrelsz(abfd), relbuf++,
382 prelocs++)
384 struct internal_ldrel ldrel;
386 bfd_xcoff_swap_ldrel_in (abfd, elrel, &ldrel);
388 if (ldrel.l_symndx >= 3)
389 relbuf->sym_ptr_ptr = syms + (ldrel.l_symndx - 3);
390 else
392 const char *name;
393 asection *sec;
395 switch (ldrel.l_symndx)
397 case 0:
398 name = ".text";
399 break;
400 case 1:
401 name = ".data";
402 break;
403 case 2:
404 name = ".bss";
405 break;
406 default:
407 abort ();
408 break;
411 sec = bfd_get_section_by_name (abfd, name);
412 if (sec == NULL)
414 bfd_set_error (bfd_error_bad_value);
415 return -1;
418 relbuf->sym_ptr_ptr = sec->symbol_ptr_ptr;
421 relbuf->address = ldrel.l_vaddr;
422 relbuf->addend = 0;
424 /* Most dynamic relocs have the same type. FIXME: This is only
425 correct if ldrel.l_rtype == 0. In other cases, we should use
426 a different howto. */
427 relbuf->howto = bfd_xcoff_dynamic_reloc_howto(abfd);
429 /* FIXME: We have no way to record the l_rsecnm field. */
431 *prelocs = relbuf;
434 *prelocs = NULL;
436 return ldhdr.l_nreloc;
439 /* Routine to create an entry in an XCOFF link hash table. */
441 static struct bfd_hash_entry *
442 xcoff_link_hash_newfunc (entry, table, string)
443 struct bfd_hash_entry *entry;
444 struct bfd_hash_table *table;
445 const char *string;
447 struct xcoff_link_hash_entry *ret = (struct xcoff_link_hash_entry *) entry;
449 /* Allocate the structure if it has not already been allocated by a
450 subclass. */
451 if (ret == (struct xcoff_link_hash_entry *) NULL)
452 ret = ((struct xcoff_link_hash_entry *)
453 bfd_hash_allocate (table, sizeof (struct xcoff_link_hash_entry)));
454 if (ret == (struct xcoff_link_hash_entry *) NULL)
455 return (struct bfd_hash_entry *) ret;
457 /* Call the allocation method of the superclass. */
458 ret = ((struct xcoff_link_hash_entry *)
459 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
460 table, string));
461 if (ret != NULL)
463 /* Set local fields. */
464 ret->indx = -1;
465 ret->toc_section = NULL;
466 ret->u.toc_indx = -1;
467 ret->descriptor = NULL;
468 ret->ldsym = NULL;
469 ret->ldindx = -1;
470 ret->flags = 0;
471 ret->smclas = XMC_UA;
474 return (struct bfd_hash_entry *) ret;
477 /* Create a XCOFF link hash table. */
479 struct bfd_link_hash_table *
480 _bfd_xcoff_bfd_link_hash_table_create (abfd)
481 bfd *abfd;
483 struct xcoff_link_hash_table *ret;
484 bfd_size_type amt = sizeof (struct xcoff_link_hash_table);
486 ret = (struct xcoff_link_hash_table *) bfd_malloc (amt);
487 if (ret == (struct xcoff_link_hash_table *) NULL)
488 return (struct bfd_link_hash_table *) NULL;
489 if (! _bfd_link_hash_table_init (&ret->root, abfd, xcoff_link_hash_newfunc))
491 free (ret);
492 return (struct bfd_link_hash_table *) NULL;
495 ret->debug_strtab = _bfd_xcoff_stringtab_init ();
496 ret->debug_section = NULL;
497 ret->loader_section = NULL;
498 ret->ldrel_count = 0;
499 memset (&ret->ldhdr, 0, sizeof (struct internal_ldhdr));
500 ret->linkage_section = NULL;
501 ret->toc_section = NULL;
502 ret->descriptor_section = NULL;
503 ret->imports = NULL;
504 ret->file_align = 0;
505 ret->textro = FALSE;
506 ret->gc = FALSE;
507 memset (ret->special_sections, 0, sizeof ret->special_sections);
509 /* The linker will always generate a full a.out header. We need to
510 record that fact now, before the sizeof_headers routine could be
511 called. */
512 xcoff_data (abfd)->full_aouthdr = TRUE;
514 return &ret->root;
517 /* Free a XCOFF link hash table. */
519 void
520 _bfd_xcoff_bfd_link_hash_table_free (hash)
521 struct bfd_link_hash_table *hash;
523 struct xcoff_link_hash_table *ret = (struct xcoff_link_hash_table *) hash;
525 _bfd_stringtab_free (ret->debug_strtab);
526 bfd_hash_table_free (&ret->root.table);
527 free (ret);
530 /* Read internal relocs for an XCOFF csect. This is a wrapper around
531 _bfd_coff_read_internal_relocs which tries to take advantage of any
532 relocs which may have been cached for the enclosing section. */
534 static struct internal_reloc *
535 xcoff_read_internal_relocs (abfd, sec, cache, external_relocs,
536 require_internal, internal_relocs)
537 bfd *abfd;
538 asection *sec;
539 bfd_boolean cache;
540 bfd_byte *external_relocs;
541 bfd_boolean require_internal;
542 struct internal_reloc *internal_relocs;
545 if (coff_section_data (abfd, sec) != NULL
546 && coff_section_data (abfd, sec)->relocs == NULL
547 && xcoff_section_data (abfd, sec) != NULL)
549 asection *enclosing;
551 enclosing = xcoff_section_data (abfd, sec)->enclosing;
553 if (enclosing != NULL
554 && (coff_section_data (abfd, enclosing) == NULL
555 || coff_section_data (abfd, enclosing)->relocs == NULL)
556 && cache
557 && enclosing->reloc_count > 0)
559 if (_bfd_coff_read_internal_relocs (abfd, enclosing, TRUE,
560 external_relocs, FALSE,
561 (struct internal_reloc *) NULL)
562 == NULL)
563 return NULL;
566 if (enclosing != NULL
567 && coff_section_data (abfd, enclosing) != NULL
568 && coff_section_data (abfd, enclosing)->relocs != NULL)
570 size_t off;
572 off = ((sec->rel_filepos - enclosing->rel_filepos)
573 / bfd_coff_relsz (abfd));
575 if (! require_internal)
576 return coff_section_data (abfd, enclosing)->relocs + off;
577 memcpy (internal_relocs,
578 coff_section_data (abfd, enclosing)->relocs + off,
579 sec->reloc_count * sizeof (struct internal_reloc));
580 return internal_relocs;
584 return _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
585 require_internal, internal_relocs);
588 /* Given an XCOFF BFD, add symbols to the global hash table as
589 appropriate. */
591 bfd_boolean
592 _bfd_xcoff_bfd_link_add_symbols (abfd, info)
593 bfd *abfd;
594 struct bfd_link_info *info;
597 switch (bfd_get_format (abfd))
599 case bfd_object:
600 return xcoff_link_add_object_symbols (abfd, info);
602 case bfd_archive:
603 /* If the archive has a map, do the usual search. We then need
604 to check the archive for dynamic objects, because they may not
605 appear in the archive map even though they should, perhaps, be
606 included. If the archive has no map, we just consider each object
607 file in turn, since that apparently is what the AIX native linker
608 does. */
609 if (bfd_has_map (abfd))
611 if (! (_bfd_generic_link_add_archive_symbols
612 (abfd, info, xcoff_link_check_archive_element)))
613 return FALSE;
617 bfd *member;
619 member = bfd_openr_next_archived_file (abfd, (bfd *) NULL);
620 while (member != NULL)
622 if (bfd_check_format (member, bfd_object)
623 && (info->hash->creator == member->xvec)
624 && (! bfd_has_map (abfd) || (member->flags & DYNAMIC) != 0))
626 bfd_boolean needed;
628 if (! xcoff_link_check_archive_element (member, info,
629 &needed))
630 return FALSE;
631 if (needed)
632 member->archive_pass = -1;
634 member = bfd_openr_next_archived_file (abfd, member);
638 return TRUE;
640 default:
641 bfd_set_error (bfd_error_wrong_format);
642 return FALSE;
646 /* Add symbols from an XCOFF object file. */
648 static bfd_boolean
649 xcoff_link_add_object_symbols (abfd, info)
650 bfd *abfd;
651 struct bfd_link_info *info;
654 if (! _bfd_coff_get_external_symbols (abfd))
655 return FALSE;
656 if (! xcoff_link_add_symbols (abfd, info))
657 return FALSE;
658 if (! info->keep_memory)
660 if (! _bfd_coff_free_symbols (abfd))
661 return FALSE;
663 return TRUE;
666 /* Check a single archive element to see if we need to include it in
667 the link. *PNEEDED is set according to whether this element is
668 needed in the link or not. This is called via
669 _bfd_generic_link_add_archive_symbols. */
671 static bfd_boolean
672 xcoff_link_check_archive_element (abfd, info, pneeded)
673 bfd *abfd;
674 struct bfd_link_info *info;
675 bfd_boolean *pneeded;
678 if (! _bfd_coff_get_external_symbols (abfd))
679 return FALSE;
681 if (! xcoff_link_check_ar_symbols (abfd, info, pneeded))
682 return FALSE;
684 if (*pneeded)
686 if (! xcoff_link_add_symbols (abfd, info))
687 return FALSE;
690 if (! info->keep_memory || ! *pneeded)
692 if (! _bfd_coff_free_symbols (abfd))
693 return FALSE;
696 return TRUE;
699 /* Look through the symbols to see if this object file should be
700 included in the link. */
702 static bfd_boolean
703 xcoff_link_check_ar_symbols (abfd, info, pneeded)
704 bfd *abfd;
705 struct bfd_link_info *info;
706 bfd_boolean *pneeded;
708 bfd_size_type symesz;
709 bfd_byte *esym;
710 bfd_byte *esym_end;
712 *pneeded = FALSE;
714 if ((abfd->flags & DYNAMIC) != 0
715 && ! info->static_link
716 && info->hash->creator == abfd->xvec)
717 return xcoff_link_check_dynamic_ar_symbols (abfd, info, pneeded);
719 symesz = bfd_coff_symesz (abfd);
720 esym = (bfd_byte *) obj_coff_external_syms (abfd);
721 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
722 while (esym < esym_end)
724 struct internal_syment sym;
726 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
728 if (sym.n_sclass == C_EXT && sym.n_scnum != N_UNDEF)
730 const char *name;
731 char buf[SYMNMLEN + 1];
732 struct bfd_link_hash_entry *h;
734 /* This symbol is externally visible, and is defined by this
735 object file. */
737 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
739 if (name == NULL)
740 return FALSE;
741 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
743 /* We are only interested in symbols that are currently
744 undefined. If a symbol is currently known to be common,
745 XCOFF linkers do not bring in an object file which
746 defines it. We also don't bring in symbols to satisfy
747 undefined references in shared objects. */
748 if (h != (struct bfd_link_hash_entry *) NULL
749 && h->type == bfd_link_hash_undefined
750 && (info->hash->creator != abfd->xvec
751 || (((struct xcoff_link_hash_entry *) h)->flags
752 & XCOFF_DEF_DYNAMIC) == 0))
754 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
755 return FALSE;
756 *pneeded = TRUE;
757 return TRUE;
761 esym += (sym.n_numaux + 1) * symesz;
764 /* We do not need this object file. */
765 return TRUE;
768 /* Look through the loader symbols to see if this dynamic object
769 should be included in the link. The native linker uses the loader
770 symbols, not the normal symbol table, so we do too. */
772 static bfd_boolean
773 xcoff_link_check_dynamic_ar_symbols (abfd, info, pneeded)
774 bfd *abfd;
775 struct bfd_link_info *info;
776 bfd_boolean *pneeded;
778 asection *lsec;
779 bfd_byte *contents;
780 struct internal_ldhdr ldhdr;
781 const char *strings;
782 bfd_byte *elsym, *elsymend;
784 *pneeded = FALSE;
786 lsec = bfd_get_section_by_name (abfd, ".loader");
787 if (lsec == NULL)
789 /* There are no symbols, so don't try to include it. */
790 return TRUE;
793 if (! xcoff_get_section_contents (abfd, lsec))
794 return FALSE;
795 contents = coff_section_data (abfd, lsec)->contents;
797 bfd_xcoff_swap_ldhdr_in (abfd, contents, &ldhdr);
799 strings = (char *) contents + ldhdr.l_stoff;
801 elsym = contents + bfd_xcoff_loader_symbol_offset(abfd, &ldhdr);
803 elsymend = elsym + ldhdr.l_nsyms * bfd_xcoff_ldsymsz(abfd);
804 for (; elsym < elsymend; elsym += bfd_xcoff_ldsymsz(abfd))
806 struct internal_ldsym ldsym;
807 char nambuf[SYMNMLEN + 1];
808 const char *name;
809 struct bfd_link_hash_entry *h;
811 bfd_xcoff_swap_ldsym_in (abfd, elsym, &ldsym);
813 /* We are only interested in exported symbols. */
814 if ((ldsym.l_smtype & L_EXPORT) == 0)
815 continue;
817 if (ldsym._l._l_l._l_zeroes == 0)
818 name = strings + ldsym._l._l_l._l_offset;
819 else
821 memcpy (nambuf, ldsym._l._l_name, SYMNMLEN);
822 nambuf[SYMNMLEN] = '\0';
823 name = nambuf;
826 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
828 /* We are only interested in symbols that are currently
829 undefined. At this point we know that we are using an XCOFF
830 hash table. */
831 if (h != NULL
832 && h->type == bfd_link_hash_undefined
833 && (((struct xcoff_link_hash_entry *) h)->flags
834 & XCOFF_DEF_DYNAMIC) == 0)
836 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
837 return FALSE;
838 *pneeded = TRUE;
839 return TRUE;
843 /* We do not need this shared object. */
845 if (contents != NULL && ! coff_section_data (abfd, lsec)->keep_contents)
847 free (coff_section_data (abfd, lsec)->contents);
848 coff_section_data (abfd, lsec)->contents = NULL;
851 return TRUE;
854 /* Returns the index of reloc in RELOCS with the least address greater
855 than or equal to ADDRESS. The relocs are sorted by address. */
857 static bfd_size_type
858 xcoff_find_reloc (relocs, count, address)
859 struct internal_reloc *relocs;
860 bfd_size_type count;
861 bfd_vma address;
863 bfd_size_type min, max, this;
865 if (count < 2)
867 if (count == 1 && relocs[0].r_vaddr < address)
868 return 1;
869 else
870 return 0;
873 min = 0;
874 max = count;
876 /* Do a binary search over (min,max]. */
877 while (min + 1 < max)
879 bfd_vma raddr;
881 this = (max + min) / 2;
882 raddr = relocs[this].r_vaddr;
883 if (raddr > address)
884 max = this;
885 else if (raddr < address)
886 min = this;
887 else
889 min = this;
890 break;
894 if (relocs[min].r_vaddr < address)
895 return min + 1;
897 while (min > 0
898 && relocs[min - 1].r_vaddr == address)
899 --min;
901 return min;
905 /* xcoff_link_create_extra_sections
907 Takes care of creating the .loader, .gl, .ds, .debug and sections. */
909 static bfd_boolean
910 xcoff_link_create_extra_sections(bfd * abfd, struct bfd_link_info *info)
913 bfd_boolean return_value = FALSE;
915 if (info->hash->creator == abfd->xvec)
918 /* We need to build a .loader section, so we do it here. This
919 won't work if we're producing an XCOFF output file with no
920 XCOFF input files. FIXME. */
922 if (xcoff_hash_table (info)->loader_section == NULL)
924 asection *lsec;
926 lsec = bfd_make_section_anyway (abfd, ".loader");
927 if (lsec == NULL)
929 goto end_return;
931 xcoff_hash_table (info)->loader_section = lsec;
932 lsec->flags |= SEC_HAS_CONTENTS | SEC_IN_MEMORY;
935 /* Likewise for the linkage section. */
936 if (xcoff_hash_table (info)->linkage_section == NULL)
938 asection *lsec;
940 lsec = bfd_make_section_anyway (abfd, ".gl");
941 if (lsec == NULL)
943 goto end_return;
946 xcoff_hash_table (info)->linkage_section = lsec;
947 lsec->flags |= (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
948 | SEC_IN_MEMORY);
949 lsec->alignment_power = 2;
952 /* Likewise for the TOC section. */
953 if (xcoff_hash_table (info)->toc_section == NULL)
955 asection *tsec;
957 tsec = bfd_make_section_anyway (abfd, ".tc");
958 if (tsec == NULL)
960 goto end_return;
963 xcoff_hash_table (info)->toc_section = tsec;
964 tsec->flags |= (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
965 | SEC_IN_MEMORY);
966 tsec->alignment_power = 2;
969 /* Likewise for the descriptor section. */
970 if (xcoff_hash_table (info)->descriptor_section == NULL)
972 asection *dsec;
974 dsec = bfd_make_section_anyway (abfd, ".ds");
975 if (dsec == NULL)
977 goto end_return;
980 xcoff_hash_table (info)->descriptor_section = dsec;
981 dsec->flags |= (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
982 | SEC_IN_MEMORY);
983 dsec->alignment_power = 2;
986 /* Likewise for the .debug section. */
987 if (xcoff_hash_table (info)->debug_section == NULL
988 && info->strip != strip_all)
990 asection *dsec;
992 dsec = bfd_make_section_anyway (abfd, ".debug");
993 if (dsec == NULL)
995 goto end_return;
997 xcoff_hash_table (info)->debug_section = dsec;
998 dsec->flags |= SEC_HAS_CONTENTS | SEC_IN_MEMORY;
1002 return_value = TRUE;
1004 end_return:
1006 return return_value;
1009 /* Add all the symbols from an object file to the hash table.
1011 XCOFF is a weird format. A normal XCOFF .o files will have three
1012 COFF sections--.text, .data, and .bss--but each COFF section will
1013 contain many csects. These csects are described in the symbol
1014 table. From the linker's point of view, each csect must be
1015 considered a section in its own right. For example, a TOC entry is
1016 handled as a small XMC_TC csect. The linker must be able to merge
1017 different TOC entries together, which means that it must be able to
1018 extract the XMC_TC csects from the .data section of the input .o
1019 file.
1021 From the point of view of our linker, this is, of course, a hideous
1022 nightmare. We cope by actually creating sections for each csect,
1023 and discarding the original sections. We then have to handle the
1024 relocation entries carefully, since the only way to tell which
1025 csect they belong to is to examine the address. */
1027 static bfd_boolean
1028 xcoff_link_add_symbols (abfd, info)
1029 bfd *abfd;
1030 struct bfd_link_info *info;
1032 unsigned int n_tmask;
1033 unsigned int n_btshft;
1034 bfd_boolean default_copy;
1035 bfd_size_type symcount;
1036 struct xcoff_link_hash_entry **sym_hash;
1037 asection **csect_cache;
1038 bfd_size_type linesz;
1039 asection *o;
1040 asection *last_real;
1041 bfd_boolean keep_syms;
1042 asection *csect;
1043 unsigned int csect_index;
1044 asection *first_csect;
1045 bfd_size_type symesz;
1046 bfd_byte *esym;
1047 bfd_byte *esym_end;
1048 struct reloc_info_struct
1050 struct internal_reloc *relocs;
1051 asection **csects;
1052 bfd_byte *linenos;
1053 } *reloc_info = NULL;
1054 bfd_size_type amt;
1056 keep_syms = obj_coff_keep_syms (abfd);
1058 if ((abfd->flags & DYNAMIC) != 0
1059 && ! info->static_link)
1061 if (! xcoff_link_add_dynamic_symbols (abfd, info))
1062 return FALSE;
1065 /* create the loader, toc, gl, ds and debug sections, if needed */
1066 if (! xcoff_link_create_extra_sections (abfd, info))
1067 goto error_return;
1069 if ((abfd->flags & DYNAMIC) != 0
1070 && ! info->static_link)
1071 return TRUE;
1073 n_tmask = coff_data (abfd)->local_n_tmask;
1074 n_btshft = coff_data (abfd)->local_n_btshft;
1076 /* Define macros so that ISFCN, et. al., macros work correctly. */
1077 #define N_TMASK n_tmask
1078 #define N_BTSHFT n_btshft
1080 if (info->keep_memory)
1081 default_copy = FALSE;
1082 else
1083 default_copy = TRUE;
1085 symcount = obj_raw_syment_count (abfd);
1087 /* We keep a list of the linker hash table entries that correspond
1088 to each external symbol. */
1089 amt = symcount * sizeof (struct xcoff_link_hash_entry *);
1090 sym_hash = (struct xcoff_link_hash_entry **) bfd_zalloc (abfd, amt);
1091 if (sym_hash == NULL && symcount != 0)
1092 goto error_return;
1093 coff_data (abfd)->sym_hashes = (struct coff_link_hash_entry **) sym_hash;
1095 /* Because of the weird stuff we are doing with XCOFF csects, we can
1096 not easily determine which section a symbol is in, so we store
1097 the information in the tdata for the input file. */
1098 amt = symcount * sizeof (asection *);
1099 csect_cache = (asection **) bfd_zalloc (abfd, amt);
1100 if (csect_cache == NULL && symcount != 0)
1101 goto error_return;
1102 xcoff_data (abfd)->csects = csect_cache;
1104 /* While splitting sections into csects, we need to assign the
1105 relocs correctly. The relocs and the csects must both be in
1106 order by VMA within a given section, so we handle this by
1107 scanning along the relocs as we process the csects. We index
1108 into reloc_info using the section target_index. */
1109 amt = abfd->section_count + 1;
1110 amt *= sizeof (struct reloc_info_struct);
1111 reloc_info = (struct reloc_info_struct *) bfd_zmalloc (amt);
1112 if (reloc_info == NULL)
1113 goto error_return;
1115 /* Read in the relocs and line numbers for each section. */
1116 linesz = bfd_coff_linesz (abfd);
1117 last_real = NULL;
1118 for (o = abfd->sections; o != NULL; o = o->next)
1121 last_real = o;
1122 if ((o->flags & SEC_RELOC) != 0)
1125 reloc_info[o->target_index].relocs =
1126 xcoff_read_internal_relocs (abfd, o, TRUE, (bfd_byte *) NULL,
1127 FALSE, (struct internal_reloc *) NULL);
1128 amt = o->reloc_count;
1129 amt *= sizeof (asection *);
1130 reloc_info[o->target_index].csects = (asection **) bfd_zmalloc (amt);
1131 if (reloc_info[o->target_index].csects == NULL)
1132 goto error_return;
1135 if ((info->strip == strip_none || info->strip == strip_some)
1136 && o->lineno_count > 0)
1139 bfd_byte *linenos;
1141 amt = linesz * o->lineno_count;
1142 linenos = (bfd_byte *) bfd_malloc (amt);
1143 if (linenos == NULL)
1144 goto error_return;
1145 reloc_info[o->target_index].linenos = linenos;
1146 if (bfd_seek (abfd, o->line_filepos, SEEK_SET) != 0
1147 || bfd_bread (linenos, amt, abfd) != amt)
1148 goto error_return;
1153 /* Don't let the linker relocation routines discard the symbols. */
1154 obj_coff_keep_syms (abfd) = TRUE;
1156 csect = NULL;
1157 csect_index = 0;
1158 first_csect = NULL;
1160 symesz = bfd_coff_symesz (abfd);
1161 BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
1162 esym = (bfd_byte *) obj_coff_external_syms (abfd);
1163 esym_end = esym + symcount * symesz;
1165 while (esym < esym_end)
1167 struct internal_syment sym;
1168 union internal_auxent aux;
1169 const char *name;
1170 char buf[SYMNMLEN + 1];
1171 int smtyp;
1172 flagword flags;
1173 asection *section;
1174 bfd_vma value;
1175 struct xcoff_link_hash_entry *set_toc;
1177 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
1179 /* In this pass we are only interested in symbols with csect
1180 information. */
1181 if (sym.n_sclass != C_EXT && sym.n_sclass != C_HIDEXT)
1184 /* Set csect_cache,
1185 Normally csect is a .pr, .rw etc. created in the loop
1186 If C_FILE or first time, handle special
1188 Advance esym, sym_hash, csect_hash ptr's
1189 Keep track of the last_symndx for the current file. */
1190 if (sym.n_sclass == C_FILE && csect != NULL)
1192 xcoff_section_data (abfd, csect)->last_symndx =
1193 ((esym
1194 - (bfd_byte *) obj_coff_external_syms (abfd))
1195 / symesz);
1196 csect = NULL;
1199 if (csect != NULL)
1200 *csect_cache = csect;
1201 else if (first_csect == NULL || sym.n_sclass == C_FILE)
1202 *csect_cache = coff_section_from_bfd_index (abfd, sym.n_scnum);
1203 else
1204 *csect_cache = NULL;
1205 esym += (sym.n_numaux + 1) * symesz;
1206 sym_hash += sym.n_numaux + 1;
1207 csect_cache += sym.n_numaux + 1;
1209 continue;
1212 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
1214 if (name == NULL)
1215 goto error_return;
1217 /* If this symbol has line number information attached to it,
1218 and we're not stripping it, count the number of entries and
1219 add them to the count for this csect. In the final link pass
1220 we are going to attach line number information by symbol,
1221 rather than by section, in order to more easily handle
1222 garbage collection. */
1223 if ((info->strip == strip_none || info->strip == strip_some)
1224 && sym.n_numaux > 1
1225 && csect != NULL
1226 && ISFCN (sym.n_type))
1229 union internal_auxent auxlin;
1231 bfd_coff_swap_aux_in (abfd, (PTR) (esym + symesz),
1232 sym.n_type, sym.n_sclass,
1233 0, sym.n_numaux, (PTR) &auxlin);
1235 if (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
1237 asection *enclosing;
1238 bfd_signed_vma linoff;
1240 enclosing = xcoff_section_data (abfd, csect)->enclosing;
1241 if (enclosing == NULL)
1243 (*_bfd_error_handler)
1244 (_("%s: `%s' has line numbers but no enclosing section"),
1245 bfd_archive_filename (abfd), name);
1246 bfd_set_error (bfd_error_bad_value);
1247 goto error_return;
1249 linoff = (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr
1250 - enclosing->line_filepos);
1251 /* explicit cast to bfd_signed_vma for compiler */
1252 if (linoff < (bfd_signed_vma) (enclosing->lineno_count * linesz))
1254 struct internal_lineno lin;
1255 bfd_byte *linpstart;
1257 linpstart = (reloc_info[enclosing->target_index].linenos
1258 + linoff);
1259 bfd_coff_swap_lineno_in (abfd, (PTR) linpstart, (PTR) &lin);
1260 if (lin.l_lnno == 0
1261 && ((bfd_size_type) lin.l_addr.l_symndx
1262 == ((esym
1263 - (bfd_byte *) obj_coff_external_syms (abfd))
1264 / symesz)))
1266 bfd_byte *linpend, *linp;
1268 linpend = (reloc_info[enclosing->target_index].linenos
1269 + enclosing->lineno_count * linesz);
1270 for (linp = linpstart + linesz;
1271 linp < linpend;
1272 linp += linesz)
1274 bfd_coff_swap_lineno_in (abfd, (PTR) linp,
1275 (PTR) &lin);
1276 if (lin.l_lnno == 0)
1277 break;
1279 csect->lineno_count += (linp - linpstart) / linesz;
1280 /* The setting of line_filepos will only be
1281 useful if all the line number entries for a
1282 csect are contiguous; this only matters for
1283 error reporting. */
1284 if (csect->line_filepos == 0)
1285 csect->line_filepos =
1286 auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr;
1292 /* Pick up the csect auxiliary information. */
1294 if (sym.n_numaux == 0)
1296 (*_bfd_error_handler)
1297 (_("%s: class %d symbol `%s' has no aux entries"),
1298 bfd_archive_filename (abfd), sym.n_sclass, name);
1299 bfd_set_error (bfd_error_bad_value);
1300 goto error_return;
1303 bfd_coff_swap_aux_in (abfd,
1304 (PTR) (esym + symesz * sym.n_numaux),
1305 sym.n_type, sym.n_sclass,
1306 sym.n_numaux - 1, sym.n_numaux,
1307 (PTR) &aux);
1309 smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
1311 flags = BSF_GLOBAL;
1312 section = NULL;
1313 value = 0;
1314 set_toc = NULL;
1316 switch (smtyp)
1318 default:
1319 (*_bfd_error_handler)
1320 (_("%s: symbol `%s' has unrecognized csect type %d"),
1321 bfd_archive_filename (abfd), name, smtyp);
1322 bfd_set_error (bfd_error_bad_value);
1323 goto error_return;
1325 case XTY_ER:
1326 /* This is an external reference. */
1327 if (sym.n_sclass == C_HIDEXT
1328 || sym.n_scnum != N_UNDEF
1329 || aux.x_csect.x_scnlen.l != 0)
1331 (*_bfd_error_handler)
1332 (_("%s: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d"),
1333 bfd_archive_filename (abfd), name, sym.n_sclass, sym.n_scnum,
1334 aux.x_csect.x_scnlen.l);
1335 bfd_set_error (bfd_error_bad_value);
1336 goto error_return;
1339 /* An XMC_XO external reference is actually a reference to
1340 an absolute location. */
1341 if (aux.x_csect.x_smclas != XMC_XO)
1342 section = bfd_und_section_ptr;
1343 else
1345 section = bfd_abs_section_ptr;
1346 value = sym.n_value;
1348 break;
1350 case XTY_SD:
1351 /* This is a csect definition. */
1352 if (csect != NULL)
1354 xcoff_section_data (abfd, csect)->last_symndx =
1355 ((esym - (bfd_byte *) obj_coff_external_syms (abfd)) / symesz);
1358 csect = NULL;
1359 csect_index = -(unsigned) 1;
1361 /* When we see a TOC anchor, we record the TOC value. */
1362 if (aux.x_csect.x_smclas == XMC_TC0)
1364 if (sym.n_sclass != C_HIDEXT
1365 || aux.x_csect.x_scnlen.l != 0)
1367 (*_bfd_error_handler)
1368 (_("%s: XMC_TC0 symbol `%s' is class %d scnlen %d"),
1369 bfd_archive_filename (abfd), name, sym.n_sclass,
1370 aux.x_csect.x_scnlen.l);
1371 bfd_set_error (bfd_error_bad_value);
1372 goto error_return;
1374 xcoff_data (abfd)->toc = sym.n_value;
1377 /* We must merge TOC entries for the same symbol. We can
1378 merge two TOC entries if they are both C_HIDEXT, they
1379 both have the same name, they are both 4 or 8 bytes long, and
1380 they both have a relocation table entry for an external
1381 symbol with the same name. Unfortunately, this means
1382 that we must look through the relocations. Ick.
1384 Logic for 32 bit vs 64 bit.
1385 32 bit has a csect length of 4 for TOC
1386 64 bit has a csect length of 8 for TOC
1388 The conditions to get past the if-check are not that bad.
1389 They are what is used to create the TOC csects in the first
1390 place. */
1391 if (aux.x_csect.x_smclas == XMC_TC
1392 && sym.n_sclass == C_HIDEXT
1393 && info->hash->creator == abfd->xvec
1394 && ((bfd_xcoff_is_xcoff32 (abfd)
1395 && aux.x_csect.x_scnlen.l == 4)
1396 || (bfd_xcoff_is_xcoff64 (abfd)
1397 && aux.x_csect.x_scnlen.l == 8)))
1399 asection *enclosing;
1400 struct internal_reloc *relocs;
1401 bfd_size_type relindx;
1402 struct internal_reloc *rel;
1404 enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1405 if (enclosing == NULL)
1406 goto error_return;
1408 relocs = reloc_info[enclosing->target_index].relocs;
1409 amt = enclosing->reloc_count;
1410 relindx = xcoff_find_reloc (relocs, amt, sym.n_value);
1411 rel = relocs + relindx;
1413 /* 32 bit R_POS r_size is 31
1414 64 bit R_POS r_size is 63 */
1415 if (relindx < enclosing->reloc_count
1416 && rel->r_vaddr == (bfd_vma) sym.n_value
1417 && rel->r_type == R_POS
1418 && ((bfd_xcoff_is_xcoff32 (abfd)
1419 && rel->r_size == 31)
1420 || (bfd_xcoff_is_xcoff64 (abfd)
1421 && rel->r_size == 63)))
1423 bfd_byte *erelsym;
1425 struct internal_syment relsym;
1427 erelsym = ((bfd_byte *) obj_coff_external_syms (abfd)
1428 + rel->r_symndx * symesz);
1429 bfd_coff_swap_sym_in (abfd, (PTR) erelsym, (PTR) &relsym);
1430 if (relsym.n_sclass == C_EXT)
1432 const char *relname;
1433 char relbuf[SYMNMLEN + 1];
1434 bfd_boolean copy;
1435 struct xcoff_link_hash_entry *h;
1437 /* At this point we know that the TOC entry is
1438 for an externally visible symbol. */
1440 relname = _bfd_coff_internal_syment_name (abfd, &relsym,
1441 relbuf);
1442 if (relname == NULL)
1443 goto error_return;
1445 /* We only merge TOC entries if the TC name is
1446 the same as the symbol name. This handles
1447 the normal case, but not common cases like
1448 SYM.P4 which gcc generates to store SYM + 4
1449 in the TOC. FIXME. */
1451 if (strcmp (name, relname) == 0)
1453 copy = (! info->keep_memory
1454 || relsym._n._n_n._n_zeroes != 0
1455 || relsym._n._n_n._n_offset == 0);
1456 h = xcoff_link_hash_lookup (xcoff_hash_table (info),
1457 relname, TRUE, copy,
1458 FALSE);
1459 if (h == NULL)
1460 goto error_return;
1462 /* At this point h->root.type could be
1463 bfd_link_hash_new. That should be OK,
1464 since we know for sure that we will come
1465 across this symbol as we step through the
1466 file. */
1468 /* We store h in *sym_hash for the
1469 convenience of the relocate_section
1470 function. */
1471 *sym_hash = h;
1473 if (h->toc_section != NULL)
1475 asection **rel_csects;
1477 /* We already have a TOC entry for this
1478 symbol, so we can just ignore this
1479 one. */
1480 rel_csects =
1481 reloc_info[enclosing->target_index].csects;
1482 rel_csects[relindx] = bfd_und_section_ptr;
1483 break;
1486 /* We are about to create a TOC entry for
1487 this symbol. */
1488 set_toc = h;
1489 } /* merge toc reloc */
1490 } /* c_ext */
1491 } /* reloc */
1492 } /* merge toc */
1496 asection *enclosing;
1498 /* We need to create a new section. We get the name from
1499 the csect storage mapping class, so that the linker can
1500 accumulate similar csects together. */
1502 csect = bfd_xcoff_create_csect_from_smclas(abfd, &aux, name);
1503 if (NULL == csect)
1505 goto error_return;
1508 /* The enclosing section is the main section : .data, .text
1509 or .bss that the csect is coming from. */
1510 enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1511 if (enclosing == NULL)
1512 goto error_return;
1514 if (! bfd_is_abs_section (enclosing)
1515 && ((bfd_vma) sym.n_value < enclosing->vma
1516 || ((bfd_vma) sym.n_value + aux.x_csect.x_scnlen.l
1517 > enclosing->vma + enclosing->_raw_size)))
1519 (*_bfd_error_handler)
1520 (_("%s: csect `%s' not in enclosing section"),
1521 bfd_archive_filename (abfd), name);
1522 bfd_set_error (bfd_error_bad_value);
1523 goto error_return;
1525 csect->vma = sym.n_value;
1526 csect->filepos = (enclosing->filepos
1527 + sym.n_value
1528 - enclosing->vma);
1529 csect->_raw_size = aux.x_csect.x_scnlen.l;
1530 csect->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
1531 csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
1533 /* Record the enclosing section in the tdata for this new
1534 section. */
1535 amt = sizeof (struct coff_section_tdata);
1536 csect->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
1537 if (csect->used_by_bfd == NULL)
1538 goto error_return;
1539 amt = sizeof (struct xcoff_section_tdata);
1540 coff_section_data (abfd, csect)->tdata = bfd_zalloc (abfd, amt);
1541 if (coff_section_data (abfd, csect)->tdata == NULL)
1542 goto error_return;
1543 xcoff_section_data (abfd, csect)->enclosing = enclosing;
1544 xcoff_section_data (abfd, csect)->lineno_count =
1545 enclosing->lineno_count;
1547 if (enclosing->owner == abfd)
1549 struct internal_reloc *relocs;
1550 bfd_size_type relindx;
1551 struct internal_reloc *rel;
1552 asection **rel_csect;
1554 relocs = reloc_info[enclosing->target_index].relocs;
1555 amt = enclosing->reloc_count;
1556 relindx = xcoff_find_reloc (relocs, amt, csect->vma);
1558 rel = relocs + relindx;
1559 rel_csect = (reloc_info[enclosing->target_index].csects
1560 + relindx);
1562 csect->rel_filepos = (enclosing->rel_filepos
1563 + relindx * bfd_coff_relsz (abfd));
1564 while (relindx < enclosing->reloc_count
1565 && *rel_csect == NULL
1566 && rel->r_vaddr < csect->vma + csect->_raw_size)
1569 *rel_csect = csect;
1570 csect->flags |= SEC_RELOC;
1571 ++csect->reloc_count;
1572 ++relindx;
1573 ++rel;
1574 ++rel_csect;
1578 /* There are a number of other fields and section flags
1579 which we do not bother to set. */
1581 csect_index = ((esym
1582 - (bfd_byte *) obj_coff_external_syms (abfd))
1583 / symesz);
1585 xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1587 if (first_csect == NULL)
1588 first_csect = csect;
1590 /* If this symbol is C_EXT, we treat it as starting at the
1591 beginning of the newly created section. */
1592 if (sym.n_sclass == C_EXT)
1594 section = csect;
1595 value = 0;
1598 /* If this is a TOC section for a symbol, record it. */
1599 if (set_toc != NULL)
1600 set_toc->toc_section = csect;
1602 break;
1604 case XTY_LD:
1605 /* This is a label definition. The x_scnlen field is the
1606 symbol index of the csect. Usually the XTY_LD symbol will
1607 follow its appropriate XTY_SD symbol. The .set pseudo op can
1608 cause the XTY_LD to not follow the XTY_SD symbol. */
1610 bfd_boolean bad;
1612 bad = FALSE;
1613 if (aux.x_csect.x_scnlen.l < 0
1614 || (aux.x_csect.x_scnlen.l
1615 >= esym - (bfd_byte *) obj_coff_external_syms (abfd)))
1616 bad = TRUE;
1617 if (! bad)
1619 section = xcoff_data (abfd)->csects[aux.x_csect.x_scnlen.l];
1620 if (section == NULL
1621 || (section->flags & SEC_HAS_CONTENTS) == 0)
1622 bad = TRUE;
1624 if (bad)
1626 (*_bfd_error_handler)
1627 (_("%s: misplaced XTY_LD `%s'"),
1628 bfd_archive_filename (abfd), name);
1629 bfd_set_error (bfd_error_bad_value);
1630 goto error_return;
1632 csect = section;
1633 value = sym.n_value - csect->vma;
1635 break;
1637 case XTY_CM:
1638 /* This is an unitialized csect. We could base the name on
1639 the storage mapping class, but we don't bother except for
1640 an XMC_TD symbol. If this csect is externally visible,
1641 it is a common symbol. We put XMC_TD symbols in sections
1642 named .tocbss, and rely on the linker script to put that
1643 in the TOC area. */
1645 if (csect != NULL)
1647 xcoff_section_data (abfd, csect)->last_symndx =
1648 ((esym
1649 - (bfd_byte *) obj_coff_external_syms (abfd))
1650 / symesz);
1653 if (aux.x_csect.x_smclas == XMC_TD)
1655 /* The linker script puts the .td section in the data
1656 section after the .tc section. */
1657 csect = bfd_make_section_anyway (abfd, ".td");
1660 else
1662 csect = bfd_make_section_anyway (abfd, ".bss");
1664 if (csect == NULL)
1665 goto error_return;
1666 csect->vma = sym.n_value;
1667 csect->_raw_size = aux.x_csect.x_scnlen.l;
1668 csect->flags |= SEC_ALLOC;
1669 csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
1670 /* There are a number of other fields and section flags
1671 which we do not bother to set. */
1673 csect_index = ((esym
1674 - (bfd_byte *) obj_coff_external_syms (abfd))
1675 / symesz);
1677 amt = sizeof (struct coff_section_tdata);
1678 csect->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
1679 if (csect->used_by_bfd == NULL)
1680 goto error_return;
1681 amt = sizeof (struct xcoff_section_tdata);
1682 coff_section_data (abfd, csect)->tdata = bfd_zalloc (abfd, amt);
1683 if (coff_section_data (abfd, csect)->tdata == NULL)
1684 goto error_return;
1685 xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1687 if (first_csect == NULL)
1688 first_csect = csect;
1690 if (sym.n_sclass == C_EXT)
1692 csect->flags |= SEC_IS_COMMON;
1693 csect->_raw_size = 0;
1694 section = csect;
1695 value = aux.x_csect.x_scnlen.l;
1698 break;
1701 /* Check for magic symbol names. */
1702 if ((smtyp == XTY_SD || smtyp == XTY_CM)
1703 && aux.x_csect.x_smclas != XMC_TC
1704 && aux.x_csect.x_smclas != XMC_TD)
1707 int i = -1;
1709 if (name[0] == '_')
1711 if (strcmp (name, "_text") == 0)
1712 i = XCOFF_SPECIAL_SECTION_TEXT;
1713 else if (strcmp (name, "_etext") == 0)
1714 i = XCOFF_SPECIAL_SECTION_ETEXT;
1715 else if (strcmp (name, "_data") == 0)
1716 i = XCOFF_SPECIAL_SECTION_DATA;
1717 else if (strcmp (name, "_edata") == 0)
1718 i = XCOFF_SPECIAL_SECTION_EDATA;
1719 else if (strcmp (name, "_end") == 0)
1720 i = XCOFF_SPECIAL_SECTION_END;
1722 else if (name[0] == 'e' && strcmp (name, "end") == 0)
1724 i = XCOFF_SPECIAL_SECTION_END2;
1727 if (i != -1)
1729 xcoff_hash_table (info)->special_sections[i] = csect;
1733 /* Now we have enough information to add the symbol to the
1734 linker hash table. */
1736 if (sym.n_sclass == C_EXT)
1738 bfd_boolean copy;
1740 BFD_ASSERT (section != NULL);
1742 /* We must copy the name into memory if we got it from the
1743 syment itself, rather than the string table. */
1744 copy = default_copy;
1745 if (sym._n._n_n._n_zeroes != 0
1746 || sym._n._n_n._n_offset == 0)
1747 copy = TRUE;
1749 /* The AIX linker appears to only detect multiple symbol
1750 definitions when there is a reference to the symbol. If
1751 a symbol is defined multiple times, and the only
1752 references are from the same object file, the AIX linker
1753 appears to permit it. It does not merge the different
1754 definitions, but handles them independently. On the
1755 other hand, if there is a reference, the linker reports
1756 an error.
1758 This matters because the AIX <net/net_globals.h> header
1759 file actually defines an initialized array, so we have to
1760 actually permit that to work.
1762 Just to make matters even more confusing, the AIX linker
1763 appears to permit multiple symbol definitions whenever
1764 the second definition is in an archive rather than an
1765 object file. This may be a consequence of the manner in
1766 which it handles archives: I think it may load the entire
1767 archive in as separate csects, and then let garbage
1768 collection discard symbols.
1770 We also have to handle the case of statically linking a
1771 shared object, which will cause symbol redefinitions,
1772 although this is an easier case to detect. */
1774 if (info->hash->creator == abfd->xvec)
1776 if (! bfd_is_und_section (section))
1778 *sym_hash = xcoff_link_hash_lookup (xcoff_hash_table (info),
1779 name, TRUE, copy, FALSE);
1781 else
1783 /* Make a copy of the symbol name to prevent problems with
1784 merging symbols. */
1785 *sym_hash = ((struct xcoff_link_hash_entry *)
1786 bfd_wrapped_link_hash_lookup (abfd, info, name,
1787 TRUE, TRUE,
1788 FALSE));
1790 if (*sym_hash == NULL)
1791 goto error_return;
1792 if (((*sym_hash)->root.type == bfd_link_hash_defined
1793 || (*sym_hash)->root.type == bfd_link_hash_defweak)
1794 && ! bfd_is_und_section (section)
1795 && ! bfd_is_com_section (section))
1797 /* This is a second definition of a defined symbol. */
1798 if ((abfd->flags & DYNAMIC) != 0
1799 && ((*sym_hash)->smclas != XMC_GL
1800 || aux.x_csect.x_smclas == XMC_GL
1801 || ((*sym_hash)->root.u.def.section->owner->flags
1802 & DYNAMIC) == 0))
1804 /* The new symbol is from a shared library, and
1805 either the existing symbol is not global
1806 linkage code or this symbol is global linkage
1807 code. If the existing symbol is global
1808 linkage code and the new symbol is not, then
1809 we want to use the new symbol. */
1810 section = bfd_und_section_ptr;
1811 value = 0;
1813 else if (((*sym_hash)->root.u.def.section->owner->flags
1814 & DYNAMIC) != 0)
1816 /* The existing symbol is from a shared library.
1817 Replace it. */
1818 (*sym_hash)->root.type = bfd_link_hash_undefined;
1819 (*sym_hash)->root.u.undef.abfd =
1820 (*sym_hash)->root.u.def.section->owner;
1822 else if (abfd->my_archive != NULL)
1824 /* This is a redefinition in an object contained
1825 in an archive. Just ignore it. See the
1826 comment above. */
1827 section = bfd_und_section_ptr;
1828 value = 0;
1830 else if ((*sym_hash)->root.und_next != NULL
1831 || info->hash->undefs_tail == &(*sym_hash)->root)
1833 /* This symbol has been referenced. In this
1834 case, we just continue and permit the
1835 multiple definition error. See the comment
1836 above about the behaviour of the AIX linker. */
1838 else if ((*sym_hash)->smclas == aux.x_csect.x_smclas)
1840 /* The symbols are both csects of the same
1841 class. There is at least a chance that this
1842 is a semi-legitimate redefinition. */
1843 section = bfd_und_section_ptr;
1844 value = 0;
1845 (*sym_hash)->flags |= XCOFF_MULTIPLY_DEFINED;
1848 else if (((*sym_hash)->flags & XCOFF_MULTIPLY_DEFINED) != 0
1849 && ((*sym_hash)->root.type == bfd_link_hash_defined
1850 || (*sym_hash)->root.type == bfd_link_hash_defweak)
1851 && (bfd_is_und_section (section)
1852 || bfd_is_com_section (section)))
1854 /* This is a reference to a multiply defined symbol.
1855 Report the error now. See the comment above
1856 about the behaviour of the AIX linker. We could
1857 also do this with warning symbols, but I'm not
1858 sure the XCOFF linker is wholly prepared to
1859 handle them, and that would only be a warning,
1860 not an error. */
1861 if (! ((*info->callbacks->multiple_definition)
1862 (info, (*sym_hash)->root.root.string,
1863 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0,
1864 (*sym_hash)->root.u.def.section->owner,
1865 (*sym_hash)->root.u.def.section,
1866 (*sym_hash)->root.u.def.value)))
1867 goto error_return;
1868 /* Try not to give this error too many times. */
1869 (*sym_hash)->flags &= ~XCOFF_MULTIPLY_DEFINED;
1873 /* _bfd_generic_link_add_one_symbol may call the linker to
1874 generate an error message, and the linker may try to read
1875 the symbol table to give a good error. Right now, the
1876 line numbers are in an inconsistent state, since they are
1877 counted both in the real sections and in the new csects.
1878 We need to leave the count in the real sections so that
1879 the linker can report the line number of the error
1880 correctly, so temporarily clobber the link to the csects
1881 so that the linker will not try to read the line numbers
1882 a second time from the csects. */
1883 BFD_ASSERT (last_real->next == first_csect);
1884 last_real->next = NULL;
1885 if (! (_bfd_generic_link_add_one_symbol
1886 (info, abfd, name, flags, section, value,
1887 (const char *) NULL, copy, TRUE,
1888 (struct bfd_link_hash_entry **) sym_hash)))
1889 goto error_return;
1890 last_real->next = first_csect;
1892 if (smtyp == XTY_CM)
1894 if ((*sym_hash)->root.type != bfd_link_hash_common
1895 || (*sym_hash)->root.u.c.p->section != csect)
1897 /* We don't need the common csect we just created. */
1898 csect->_raw_size = 0;
1900 else
1902 (*sym_hash)->root.u.c.p->alignment_power
1903 = csect->alignment_power;
1907 if (info->hash->creator == abfd->xvec)
1909 int flag;
1911 if (smtyp == XTY_ER || smtyp == XTY_CM)
1912 flag = XCOFF_REF_REGULAR;
1913 else
1914 flag = XCOFF_DEF_REGULAR;
1915 (*sym_hash)->flags |= flag;
1917 if ((*sym_hash)->smclas == XMC_UA
1918 || flag == XCOFF_DEF_REGULAR)
1919 (*sym_hash)->smclas = aux.x_csect.x_smclas;
1923 *csect_cache = csect;
1925 esym += (sym.n_numaux + 1) * symesz;
1926 sym_hash += sym.n_numaux + 1;
1927 csect_cache += sym.n_numaux + 1;
1930 BFD_ASSERT (last_real == NULL || last_real->next == first_csect);
1932 /* Make sure that we have seen all the relocs. */
1933 for (o = abfd->sections; o != first_csect; o = o->next)
1935 /* Reset the section size and the line number count, since the
1936 data is now attached to the csects. Don't reset the size of
1937 the .debug section, since we need to read it below in
1938 bfd_xcoff_size_dynamic_sections. */
1939 if (strcmp (bfd_get_section_name (abfd, o), ".debug") != 0)
1940 o->_raw_size = 0;
1941 o->lineno_count = 0;
1943 if ((o->flags & SEC_RELOC) != 0)
1945 bfd_size_type i;
1946 struct internal_reloc *rel;
1947 asection **rel_csect;
1949 rel = reloc_info[o->target_index].relocs;
1950 rel_csect = reloc_info[o->target_index].csects;
1952 for (i = 0; i < o->reloc_count; i++, rel++, rel_csect++)
1955 if (*rel_csect == NULL)
1957 (*_bfd_error_handler)
1958 (_("%s: reloc %s:%d not in csect"),
1959 bfd_archive_filename (abfd), o->name, i);
1960 bfd_set_error (bfd_error_bad_value);
1961 goto error_return;
1964 /* We identify all symbols which are called, so that we
1965 can create glue code for calls to functions imported
1966 from dynamic objects. */
1967 if (info->hash->creator == abfd->xvec
1968 && *rel_csect != bfd_und_section_ptr
1969 && (rel->r_type == R_BR
1970 || rel->r_type == R_RBR)
1971 && obj_xcoff_sym_hashes (abfd)[rel->r_symndx] != NULL)
1973 struct xcoff_link_hash_entry *h;
1975 h = obj_xcoff_sym_hashes (abfd)[rel->r_symndx];
1976 h->flags |= XCOFF_CALLED;
1977 /* If the symbol name starts with a period, it is
1978 the code of a function. If the symbol is
1979 currently undefined, then add an undefined symbol
1980 for the function descriptor. This should do no
1981 harm, because any regular object that defines the
1982 function should also define the function
1983 descriptor. It helps, because it means that we
1984 will identify the function descriptor with a
1985 dynamic object if a dynamic object defines it. */
1986 if (h->root.root.string[0] == '.'
1987 && h->descriptor == NULL)
1989 struct xcoff_link_hash_entry *hds;
1990 struct bfd_link_hash_entry *bh;
1992 hds = xcoff_link_hash_lookup (xcoff_hash_table (info),
1993 h->root.root.string + 1,
1994 TRUE, FALSE, TRUE);
1995 if (hds == NULL)
1996 goto error_return;
1997 if (hds->root.type == bfd_link_hash_new)
1999 bh = &hds->root;
2000 if (! (_bfd_generic_link_add_one_symbol
2001 (info, abfd, hds->root.root.string,
2002 (flagword) 0, bfd_und_section_ptr,
2003 (bfd_vma) 0, (const char *) NULL, FALSE,
2004 TRUE, &bh)))
2005 goto error_return;
2006 hds = (struct xcoff_link_hash_entry *) bh;
2008 hds->flags |= XCOFF_DESCRIPTOR;
2009 BFD_ASSERT ((hds->flags & XCOFF_CALLED) == 0
2010 && (h->flags & XCOFF_DESCRIPTOR) == 0);
2011 hds->descriptor = h;
2012 h->descriptor = hds;
2017 free (reloc_info[o->target_index].csects);
2018 reloc_info[o->target_index].csects = NULL;
2020 /* Reset SEC_RELOC and the reloc_count, since the reloc
2021 information is now attached to the csects. */
2022 o->flags &=~ SEC_RELOC;
2023 o->reloc_count = 0;
2025 /* If we are not keeping memory, free the reloc information. */
2026 if (! info->keep_memory
2027 && coff_section_data (abfd, o) != NULL
2028 && coff_section_data (abfd, o)->relocs != NULL
2029 && ! coff_section_data (abfd, o)->keep_relocs)
2031 free (coff_section_data (abfd, o)->relocs);
2032 coff_section_data (abfd, o)->relocs = NULL;
2036 /* Free up the line numbers. FIXME: We could cache these
2037 somewhere for the final link, to avoid reading them again. */
2038 if (reloc_info[o->target_index].linenos != NULL)
2040 free (reloc_info[o->target_index].linenos);
2041 reloc_info[o->target_index].linenos = NULL;
2045 free (reloc_info);
2047 obj_coff_keep_syms (abfd) = keep_syms;
2049 return TRUE;
2051 error_return:
2052 if (reloc_info != NULL)
2054 for (o = abfd->sections; o != NULL; o = o->next)
2056 if (reloc_info[o->target_index].csects != NULL)
2057 free (reloc_info[o->target_index].csects);
2058 if (reloc_info[o->target_index].linenos != NULL)
2059 free (reloc_info[o->target_index].linenos);
2061 free (reloc_info);
2063 obj_coff_keep_syms (abfd) = keep_syms;
2064 return FALSE;
2067 #undef N_TMASK
2068 #undef N_BTSHFT
2070 /* This function is used to add symbols from a dynamic object to the
2071 global symbol table. */
2073 static bfd_boolean
2074 xcoff_link_add_dynamic_symbols (abfd, info)
2075 bfd *abfd;
2076 struct bfd_link_info *info;
2078 asection *lsec;
2079 bfd_byte *contents;
2080 struct internal_ldhdr ldhdr;
2081 const char *strings;
2082 bfd_byte *elsym, *elsymend;
2083 struct xcoff_import_file *n;
2084 const char *bname;
2085 const char *mname;
2086 const char *s;
2087 unsigned int c;
2088 struct xcoff_import_file **pp;
2090 /* We can only handle a dynamic object if we are generating an XCOFF
2091 output file. */
2092 if (info->hash->creator != abfd->xvec)
2094 (*_bfd_error_handler)
2095 (_("%s: XCOFF shared object when not producing XCOFF output"),
2096 bfd_get_filename (abfd));
2097 bfd_set_error (bfd_error_invalid_operation);
2098 return FALSE;
2101 /* The symbols we use from a dynamic object are not the symbols in
2102 the normal symbol table, but, rather, the symbols in the export
2103 table. If there is a global symbol in a dynamic object which is
2104 not in the export table, the loader will not be able to find it,
2105 so we don't want to find it either. Also, on AIX 4.1.3, shr.o in
2106 libc.a has symbols in the export table which are not in the
2107 symbol table. */
2109 /* Read in the .loader section. FIXME: We should really use the
2110 o_snloader field in the a.out header, rather than grabbing the
2111 section by name. */
2112 lsec = bfd_get_section_by_name (abfd, ".loader");
2113 if (lsec == NULL)
2115 (*_bfd_error_handler)
2116 (_("%s: dynamic object with no .loader section"),
2117 bfd_get_filename (abfd));
2118 bfd_set_error (bfd_error_no_symbols);
2119 return FALSE;
2123 if (! xcoff_get_section_contents (abfd, lsec))
2124 return FALSE;
2125 contents = coff_section_data (abfd, lsec)->contents;
2127 /* Remove the sections from this object, so that they do not get
2128 included in the link. */
2129 bfd_section_list_clear (abfd);
2131 bfd_xcoff_swap_ldhdr_in (abfd, contents, &ldhdr);
2133 strings = (char *) contents + ldhdr.l_stoff;
2135 elsym = contents + bfd_xcoff_loader_symbol_offset(abfd, &ldhdr);
2137 elsymend = elsym + ldhdr.l_nsyms * bfd_xcoff_ldsymsz(abfd);
2139 for (; elsym < elsymend; elsym += bfd_xcoff_ldsymsz(abfd))
2141 struct internal_ldsym ldsym;
2142 char nambuf[SYMNMLEN + 1];
2143 const char *name;
2144 struct xcoff_link_hash_entry *h;
2146 bfd_xcoff_swap_ldsym_in (abfd, elsym, &ldsym);
2148 /* We are only interested in exported symbols. */
2149 if ((ldsym.l_smtype & L_EXPORT) == 0)
2150 continue;
2152 if (ldsym._l._l_l._l_zeroes == 0)
2153 name = strings + ldsym._l._l_l._l_offset;
2154 else
2156 memcpy (nambuf, ldsym._l._l_name, SYMNMLEN);
2157 nambuf[SYMNMLEN] = '\0';
2158 name = nambuf;
2161 /* Normally we could not call xcoff_link_hash_lookup in an add
2162 symbols routine, since we might not be using an XCOFF hash
2163 table. However, we verified above that we are using an XCOFF
2164 hash table. */
2166 h = xcoff_link_hash_lookup (xcoff_hash_table (info), name, TRUE,
2167 TRUE, TRUE);
2168 if (h == NULL)
2169 return FALSE;
2171 h->flags |= XCOFF_DEF_DYNAMIC;
2173 /* If the symbol is undefined, and the BFD it was found in is
2174 not a dynamic object, change the BFD to this dynamic object,
2175 so that we can get the correct import file ID. */
2176 if ((h->root.type == bfd_link_hash_undefined
2177 || h->root.type == bfd_link_hash_undefweak)
2178 && (h->root.u.undef.abfd == NULL
2179 || (h->root.u.undef.abfd->flags & DYNAMIC) == 0))
2180 h->root.u.undef.abfd = abfd;
2182 if (h->root.type == bfd_link_hash_new)
2184 h->root.type = bfd_link_hash_undefined;
2185 h->root.u.undef.abfd = abfd;
2186 /* We do not want to add this to the undefined symbol list. */
2189 if (h->smclas == XMC_UA
2190 || h->root.type == bfd_link_hash_undefined
2191 || h->root.type == bfd_link_hash_undefweak)
2192 h->smclas = ldsym.l_smclas;
2194 /* Unless this is an XMC_XO symbol, we don't bother to actually
2195 define it, since we don't have a section to put it in anyhow.
2196 Instead, the relocation routines handle the DEF_DYNAMIC flag
2197 correctly. */
2199 if (h->smclas == XMC_XO
2200 && (h->root.type == bfd_link_hash_undefined
2201 || h->root.type == bfd_link_hash_undefweak))
2203 /* This symbol has an absolute value. */
2204 h->root.type = bfd_link_hash_defined;
2205 h->root.u.def.section = bfd_abs_section_ptr;
2206 h->root.u.def.value = ldsym.l_value;
2209 /* If this symbol defines a function descriptor, then it
2210 implicitly defines the function code as well. */
2211 if (h->smclas == XMC_DS
2212 || (h->smclas == XMC_XO && name[0] != '.'))
2213 h->flags |= XCOFF_DESCRIPTOR;
2214 if ((h->flags & XCOFF_DESCRIPTOR) != 0)
2216 struct xcoff_link_hash_entry *hds;
2218 hds = h->descriptor;
2219 if (hds == NULL)
2221 char *dsnm;
2223 dsnm = bfd_malloc ((bfd_size_type) strlen (name) + 2);
2224 if (dsnm == NULL)
2225 return FALSE;
2226 dsnm[0] = '.';
2227 strcpy (dsnm + 1, name);
2228 hds = xcoff_link_hash_lookup (xcoff_hash_table (info), dsnm,
2229 TRUE, TRUE, TRUE);
2230 free (dsnm);
2231 if (hds == NULL)
2232 return FALSE;
2234 if (hds->root.type == bfd_link_hash_new)
2236 hds->root.type = bfd_link_hash_undefined;
2237 hds->root.u.undef.abfd = abfd;
2238 /* We do not want to add this to the undefined
2239 symbol list. */
2242 hds->descriptor = h;
2243 h->descriptor = hds;
2246 hds->flags |= XCOFF_DEF_DYNAMIC;
2247 if (hds->smclas == XMC_UA)
2248 hds->smclas = XMC_PR;
2250 /* An absolute symbol appears to actually define code, not a
2251 function descriptor. This is how some math functions are
2252 implemented on AIX 4.1. */
2253 if (h->smclas == XMC_XO
2254 && (hds->root.type == bfd_link_hash_undefined
2255 || hds->root.type == bfd_link_hash_undefweak))
2257 hds->smclas = XMC_XO;
2258 hds->root.type = bfd_link_hash_defined;
2259 hds->root.u.def.section = bfd_abs_section_ptr;
2260 hds->root.u.def.value = ldsym.l_value;
2265 if (contents != NULL && ! coff_section_data (abfd, lsec)->keep_contents)
2267 free (coff_section_data (abfd, lsec)->contents);
2268 coff_section_data (abfd, lsec)->contents = NULL;
2271 /* Record this file in the import files. */
2273 n = ((struct xcoff_import_file *)
2274 bfd_alloc (abfd, (bfd_size_type) sizeof (struct xcoff_import_file)));
2275 if (n == NULL)
2276 return FALSE;
2277 n->next = NULL;
2279 /* For some reason, the path entry in the import file list for a
2280 shared object appears to always be empty. The file name is the
2281 base name. */
2282 n->path = "";
2283 if (abfd->my_archive == NULL)
2285 bname = bfd_get_filename (abfd);
2286 mname = "";
2288 else
2290 bname = bfd_get_filename (abfd->my_archive);
2291 mname = bfd_get_filename (abfd);
2293 s = strrchr (bname, '/');
2294 if (s != NULL)
2295 bname = s + 1;
2296 n->file = bname;
2297 n->member = mname;
2299 /* We start c at 1 because the first import file number is reserved
2300 for LIBPATH. */
2301 for (pp = &xcoff_hash_table (info)->imports, c = 1;
2302 *pp != NULL;
2303 pp = &(*pp)->next, ++c)
2305 *pp = n;
2307 xcoff_data (abfd)->import_file_id = c;
2309 return TRUE;
2312 /* Routines that are called after all the input files have been
2313 handled, but before the sections are laid out in memory. */
2315 /* Mark a symbol as not being garbage, including the section in which
2316 it is defined. */
2318 static INLINE bfd_boolean
2319 xcoff_mark_symbol (info, h)
2320 struct bfd_link_info *info;
2321 struct xcoff_link_hash_entry *h;
2324 if ((h->flags & XCOFF_MARK) != 0)
2325 return TRUE;
2327 h->flags |= XCOFF_MARK;
2328 if (h->root.type == bfd_link_hash_defined
2329 || h->root.type == bfd_link_hash_defweak)
2331 asection *hsec;
2333 hsec = h->root.u.def.section;
2334 if (! bfd_is_abs_section (hsec)
2335 && (hsec->flags & SEC_MARK) == 0)
2337 if (! xcoff_mark (info, hsec))
2338 return FALSE;
2342 if (h->toc_section != NULL
2343 && (h->toc_section->flags & SEC_MARK) == 0)
2345 if (! xcoff_mark (info, h->toc_section))
2346 return FALSE;
2349 return TRUE;
2352 /* The mark phase of garbage collection. For a given section, mark
2353 it, and all the sections which define symbols to which it refers.
2354 Because this function needs to look at the relocs, we also count
2355 the number of relocs which need to be copied into the .loader
2356 section. */
2358 static bfd_boolean
2359 xcoff_mark (info, sec)
2360 struct bfd_link_info *info;
2361 asection *sec;
2363 if (bfd_is_abs_section (sec)
2364 || (sec->flags & SEC_MARK) != 0)
2365 return TRUE;
2367 sec->flags |= SEC_MARK;
2369 if (sec->owner->xvec == info->hash->creator
2370 && coff_section_data (sec->owner, sec) != NULL
2371 && xcoff_section_data (sec->owner, sec) != NULL)
2373 register struct xcoff_link_hash_entry **hp, **hpend;
2374 struct internal_reloc *rel, *relend;
2376 /* Mark all the symbols in this section. */
2378 hp = (obj_xcoff_sym_hashes (sec->owner)
2379 + xcoff_section_data (sec->owner, sec)->first_symndx);
2380 hpend = (obj_xcoff_sym_hashes (sec->owner)
2381 + xcoff_section_data (sec->owner, sec)->last_symndx);
2382 for (; hp < hpend; hp++)
2384 register struct xcoff_link_hash_entry *h;
2386 h = *hp;
2387 if (h != NULL
2388 && (h->flags & XCOFF_MARK) == 0)
2390 if (! xcoff_mark_symbol (info, h))
2391 return FALSE;
2395 /* Look through the section relocs. */
2397 if ((sec->flags & SEC_RELOC) != 0
2398 && sec->reloc_count > 0)
2400 rel = xcoff_read_internal_relocs (sec->owner, sec, TRUE,
2401 (bfd_byte *) NULL, FALSE,
2402 (struct internal_reloc *) NULL);
2403 if (rel == NULL)
2404 return FALSE;
2405 relend = rel + sec->reloc_count;
2406 for (; rel < relend; rel++)
2408 asection *rsec;
2409 struct xcoff_link_hash_entry *h;
2411 if ((unsigned int) rel->r_symndx
2412 > obj_raw_syment_count (sec->owner))
2413 continue;
2415 h = obj_xcoff_sym_hashes (sec->owner)[rel->r_symndx];
2416 if (h != NULL
2417 && (h->flags & XCOFF_MARK) == 0)
2419 if (! xcoff_mark_symbol (info, h))
2420 return FALSE;
2423 rsec = xcoff_data (sec->owner)->csects[rel->r_symndx];
2424 if (rsec != NULL
2425 && (rsec->flags & SEC_MARK) == 0)
2427 if (! xcoff_mark (info, rsec))
2428 return FALSE;
2431 /* See if this reloc needs to be copied into the .loader
2432 section. */
2433 switch (rel->r_type)
2435 default:
2436 if (h == NULL
2437 || h->root.type == bfd_link_hash_defined
2438 || h->root.type == bfd_link_hash_defweak
2439 || h->root.type == bfd_link_hash_common
2440 || ((h->flags & XCOFF_CALLED) != 0
2441 && (h->root.type == bfd_link_hash_undefined
2442 || h->root.type == bfd_link_hash_undefweak)
2443 && h->root.root.string[0] == '.'
2444 && h->descriptor != NULL
2445 && ((h->descriptor->flags & XCOFF_DEF_DYNAMIC) != 0
2446 || ((h->descriptor->flags & XCOFF_IMPORT) != 0
2447 && (h->descriptor->flags
2448 & XCOFF_DEF_REGULAR) == 0))))
2449 break;
2450 /* Fall through. */
2451 case R_POS:
2452 case R_NEG:
2453 case R_RL:
2454 case R_RLA:
2455 ++xcoff_hash_table (info)->ldrel_count;
2456 if (h != NULL)
2457 h->flags |= XCOFF_LDREL;
2458 break;
2459 case R_TOC:
2460 case R_GL:
2461 case R_TCL:
2462 case R_TRL:
2463 case R_TRLA:
2464 /* We should never need a .loader reloc for a TOC
2465 relative reloc. */
2466 break;
2470 if (! info->keep_memory
2471 && coff_section_data (sec->owner, sec) != NULL
2472 && coff_section_data (sec->owner, sec)->relocs != NULL
2473 && ! coff_section_data (sec->owner, sec)->keep_relocs)
2475 free (coff_section_data (sec->owner, sec)->relocs);
2476 coff_section_data (sec->owner, sec)->relocs = NULL;
2481 return TRUE;
2484 /* The sweep phase of garbage collection. Remove all garbage
2485 sections. */
2487 static void
2488 xcoff_sweep (info)
2489 struct bfd_link_info *info;
2491 bfd *sub;
2493 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2495 asection *o;
2497 for (o = sub->sections; o != NULL; o = o->next)
2499 if ((o->flags & SEC_MARK) == 0)
2501 /* Keep all sections from non-XCOFF input files. Keep
2502 special sections. Keep .debug sections for the
2503 moment. */
2504 if (sub->xvec != info->hash->creator
2505 || o == xcoff_hash_table (info)->debug_section
2506 || o == xcoff_hash_table (info)->loader_section
2507 || o == xcoff_hash_table (info)->linkage_section
2508 || o == xcoff_hash_table (info)->toc_section
2509 || o == xcoff_hash_table (info)->descriptor_section
2510 || strcmp (o->name, ".debug") == 0)
2511 o->flags |= SEC_MARK;
2512 else
2514 o->_raw_size = 0;
2515 o->reloc_count = 0;
2516 o->lineno_count = 0;
2523 /* Record the number of elements in a set. This is used to output the
2524 correct csect length. */
2526 bfd_boolean
2527 bfd_xcoff_link_record_set (output_bfd, info, harg, size)
2528 bfd *output_bfd;
2529 struct bfd_link_info *info;
2530 struct bfd_link_hash_entry *harg;
2531 bfd_size_type size;
2533 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
2534 struct xcoff_link_size_list *n;
2535 bfd_size_type amt;
2537 if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour)
2538 return TRUE;
2540 /* This will hardly ever be called. I don't want to burn four bytes
2541 per global symbol, so instead the size is kept on a linked list
2542 attached to the hash table. */
2544 amt = sizeof (struct xcoff_link_size_list);
2545 n = (struct xcoff_link_size_list *) bfd_alloc (output_bfd, amt);
2546 if (n == NULL)
2547 return FALSE;
2548 n->next = xcoff_hash_table (info)->size_list;
2549 n->h = h;
2550 n->size = size;
2551 xcoff_hash_table (info)->size_list = n;
2553 h->flags |= XCOFF_HAS_SIZE;
2555 return TRUE;
2558 /* Import a symbol. */
2560 bfd_boolean
2561 bfd_xcoff_import_symbol (output_bfd, info, harg, val, imppath, impfile,
2562 impmember, syscall_flag)
2563 bfd *output_bfd;
2564 struct bfd_link_info *info;
2565 struct bfd_link_hash_entry *harg;
2566 bfd_vma val;
2567 const char *imppath;
2568 const char *impfile;
2569 const char *impmember;
2570 unsigned int syscall_flag;
2572 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
2574 if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour)
2575 return TRUE;
2577 /* A symbol name which starts with a period is the code for a
2578 function. If the symbol is undefined, then add an undefined
2579 symbol for the function descriptor, and import that instead. */
2580 if (h->root.root.string[0] == '.'
2581 && h->root.type == bfd_link_hash_undefined
2582 && val == (bfd_vma) -1)
2584 struct xcoff_link_hash_entry *hds;
2586 hds = h->descriptor;
2587 if (hds == NULL)
2589 hds = xcoff_link_hash_lookup (xcoff_hash_table (info),
2590 h->root.root.string + 1,
2591 TRUE, FALSE, TRUE);
2592 if (hds == NULL)
2593 return FALSE;
2594 if (hds->root.type == bfd_link_hash_new)
2596 hds->root.type = bfd_link_hash_undefined;
2597 hds->root.u.undef.abfd = h->root.u.undef.abfd;
2599 hds->flags |= XCOFF_DESCRIPTOR;
2600 BFD_ASSERT ((hds->flags & XCOFF_CALLED) == 0
2601 && (h->flags & XCOFF_DESCRIPTOR) == 0);
2602 hds->descriptor = h;
2603 h->descriptor = hds;
2606 /* Now, if the descriptor is undefined, import the descriptor
2607 rather than the symbol we were told to import. FIXME: Is
2608 this correct in all cases? */
2609 if (hds->root.type == bfd_link_hash_undefined)
2610 h = hds;
2613 h->flags |= (XCOFF_IMPORT | syscall_flag);
2615 if (val != (bfd_vma) -1)
2617 if (h->root.type == bfd_link_hash_defined
2618 && (! bfd_is_abs_section (h->root.u.def.section)
2619 || h->root.u.def.value != val))
2621 if (! ((*info->callbacks->multiple_definition)
2622 (info, h->root.root.string, h->root.u.def.section->owner,
2623 h->root.u.def.section, h->root.u.def.value,
2624 output_bfd, bfd_abs_section_ptr, val)))
2625 return FALSE;
2628 h->root.type = bfd_link_hash_defined;
2629 h->root.u.def.section = bfd_abs_section_ptr;
2630 h->root.u.def.value = val;
2633 /* We overload the ldindx field to hold the l_ifile value for this
2634 symbol. */
2635 BFD_ASSERT (h->ldsym == NULL);
2636 BFD_ASSERT ((h->flags & XCOFF_BUILT_LDSYM) == 0);
2637 if (imppath == NULL)
2638 h->ldindx = -1;
2639 else
2641 unsigned int c;
2642 struct xcoff_import_file **pp;
2644 /* We start c at 1 because the first entry in the import list is
2645 reserved for the library search path. */
2646 for (pp = &xcoff_hash_table (info)->imports, c = 1;
2647 *pp != NULL;
2648 pp = &(*pp)->next, ++c)
2650 if (strcmp ((*pp)->path, imppath) == 0
2651 && strcmp ((*pp)->file, impfile) == 0
2652 && strcmp ((*pp)->member, impmember) == 0)
2653 break;
2656 if (*pp == NULL)
2658 struct xcoff_import_file *n;
2659 bfd_size_type amt = sizeof (struct xcoff_import_file);
2661 n = (struct xcoff_import_file *) bfd_alloc (output_bfd, amt);
2662 if (n == NULL)
2663 return FALSE;
2664 n->next = NULL;
2665 n->path = imppath;
2666 n->file = impfile;
2667 n->member = impmember;
2668 *pp = n;
2671 h->ldindx = c;
2674 return TRUE;
2677 /* Export a symbol. */
2679 bfd_boolean
2680 bfd_xcoff_export_symbol (output_bfd, info, harg)
2681 bfd *output_bfd;
2682 struct bfd_link_info *info;
2683 struct bfd_link_hash_entry *harg;
2685 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
2687 if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour)
2688 return TRUE;
2690 h->flags |= XCOFF_EXPORT;
2692 /* FIXME: I'm not at all sure what syscall is supposed to mean, so
2693 I'm just going to ignore it until somebody explains it. */
2695 /* See if this is a function descriptor. It may be one even though
2696 it is not so marked. */
2697 if ((h->flags & XCOFF_DESCRIPTOR) == 0
2698 && h->root.root.string[0] != '.')
2700 char *fnname;
2701 struct xcoff_link_hash_entry *hfn;
2702 bfd_size_type amt = strlen (h->root.root.string) + 2;
2704 fnname = (char *) bfd_malloc (amt);
2705 if (fnname == NULL)
2706 return FALSE;
2707 fnname[0] = '.';
2708 strcpy (fnname + 1, h->root.root.string);
2709 hfn = xcoff_link_hash_lookup (xcoff_hash_table (info),
2710 fnname, FALSE, FALSE, TRUE);
2711 free (fnname);
2712 if (hfn != NULL
2713 && hfn->smclas == XMC_PR
2714 && (hfn->root.type == bfd_link_hash_defined
2715 || hfn->root.type == bfd_link_hash_defweak))
2717 h->flags |= XCOFF_DESCRIPTOR;
2718 h->descriptor = hfn;
2719 hfn->descriptor = h;
2723 /* Make sure we don't garbage collect this symbol. */
2724 if (! xcoff_mark_symbol (info, h))
2725 return FALSE;
2727 /* If this is a function descriptor, make sure we don't garbage
2728 collect the associated function code. We normally don't have to
2729 worry about this, because the descriptor will be attached to a
2730 section with relocs, but if we are creating the descriptor
2731 ourselves those relocs will not be visible to the mark code. */
2732 if ((h->flags & XCOFF_DESCRIPTOR) != 0)
2734 if (! xcoff_mark_symbol (info, h->descriptor))
2735 return FALSE;
2738 return TRUE;
2741 /* Count a reloc against a symbol. This is called for relocs
2742 generated by the linker script, typically for global constructors
2743 and destructors. */
2745 bfd_boolean
2746 bfd_xcoff_link_count_reloc (output_bfd, info, name)
2747 bfd *output_bfd;
2748 struct bfd_link_info *info;
2749 const char *name;
2751 struct xcoff_link_hash_entry *h;
2753 if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour)
2754 return TRUE;
2756 h = ((struct xcoff_link_hash_entry *)
2757 bfd_wrapped_link_hash_lookup (output_bfd, info, name, FALSE, FALSE,
2758 FALSE));
2759 if (h == NULL)
2761 (*_bfd_error_handler) (_("%s: no such symbol"), name);
2762 bfd_set_error (bfd_error_no_symbols);
2763 return FALSE;
2766 h->flags |= XCOFF_REF_REGULAR | XCOFF_LDREL;
2767 ++xcoff_hash_table (info)->ldrel_count;
2769 /* Mark the symbol to avoid garbage collection. */
2770 if (! xcoff_mark_symbol (info, h))
2771 return FALSE;
2773 return TRUE;
2776 /* This function is called for each symbol to which the linker script
2777 assigns a value. */
2779 bfd_boolean
2780 bfd_xcoff_record_link_assignment (output_bfd, info, name)
2781 bfd *output_bfd;
2782 struct bfd_link_info *info;
2783 const char *name;
2785 struct xcoff_link_hash_entry *h;
2787 if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour)
2788 return TRUE;
2790 h = xcoff_link_hash_lookup (xcoff_hash_table (info), name, TRUE, TRUE,
2791 FALSE);
2792 if (h == NULL)
2793 return FALSE;
2795 h->flags |= XCOFF_DEF_REGULAR;
2797 return TRUE;
2800 /* Build the .loader section. This is called by the XCOFF linker
2801 emulation before_allocation routine. We must set the size of the
2802 .loader section before the linker lays out the output file.
2803 LIBPATH is the library path to search for shared objects; this is
2804 normally built from the -L arguments passed to the linker. ENTRY
2805 is the name of the entry point symbol (the -e linker option).
2806 FILE_ALIGN is the alignment to use for sections within the file
2807 (the -H linker option). MAXSTACK is the maximum stack size (the
2808 -bmaxstack linker option). MAXDATA is the maximum data size (the
2809 -bmaxdata linker option). GC is whether to do garbage collection
2810 (the -bgc linker option). MODTYPE is the module type (the
2811 -bmodtype linker option). TEXTRO is whether the text section must
2812 be read only (the -btextro linker option). EXPORT_DEFINEDS is
2813 whether all defined symbols should be exported (the -unix linker
2814 option). SPECIAL_SECTIONS is set by this routine to csects with
2815 magic names like _end. */
2817 bfd_boolean
2818 bfd_xcoff_size_dynamic_sections (output_bfd, info, libpath, entry,
2819 file_align, maxstack, maxdata, gc,
2820 modtype, textro, export_defineds,
2821 special_sections, rtld)
2822 bfd *output_bfd;
2823 struct bfd_link_info *info;
2824 const char *libpath;
2825 const char *entry;
2826 unsigned long file_align;
2827 unsigned long maxstack;
2828 unsigned long maxdata;
2829 bfd_boolean gc;
2830 int modtype;
2831 bfd_boolean textro;
2832 bfd_boolean export_defineds;
2833 asection **special_sections;
2834 bfd_boolean rtld;
2836 struct xcoff_link_hash_entry *hentry;
2837 asection *lsec;
2838 struct xcoff_loader_info ldinfo;
2839 int i;
2840 size_t impsize, impcount;
2841 struct xcoff_import_file *fl;
2842 struct internal_ldhdr *ldhdr;
2843 bfd_size_type stoff;
2844 register char *out;
2845 asection *sec;
2846 bfd *sub;
2847 struct bfd_strtab_hash *debug_strtab;
2848 bfd_byte *debug_contents = NULL;
2849 bfd_size_type amt;
2851 if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour)
2853 for (i = 0; i < XCOFF_NUMBER_OF_SPECIAL_SECTIONS; i++)
2854 special_sections[i] = NULL;
2855 return TRUE;
2858 ldinfo.failed = FALSE;
2859 ldinfo.output_bfd = output_bfd;
2860 ldinfo.info = info;
2861 ldinfo.export_defineds = export_defineds;
2862 ldinfo.ldsym_count = 0;
2863 ldinfo.string_size = 0;
2864 ldinfo.strings = NULL;
2865 ldinfo.string_alc = 0;
2867 xcoff_data (output_bfd)->maxstack = maxstack;
2868 xcoff_data (output_bfd)->maxdata = maxdata;
2869 xcoff_data (output_bfd)->modtype = modtype;
2871 xcoff_hash_table (info)->file_align = file_align;
2872 xcoff_hash_table (info)->textro = textro;
2874 hentry = NULL;
2875 if (entry != NULL)
2877 hentry = xcoff_link_hash_lookup (xcoff_hash_table (info), entry,
2878 FALSE, FALSE, TRUE);
2879 if (hentry != NULL)
2880 hentry->flags |= XCOFF_ENTRY;
2883 /* __rtinit */
2884 if (info->init_function || info->fini_function || rtld)
2886 struct xcoff_link_hash_entry *hsym;
2887 struct internal_ldsym *ldsym;
2889 hsym = xcoff_link_hash_lookup (xcoff_hash_table (info),
2890 "__rtinit", FALSE, FALSE, TRUE);
2891 if (hsym == NULL)
2893 (*_bfd_error_handler)
2894 (_("error: undefined symbol __rtinit"));
2895 return FALSE;
2898 xcoff_mark_symbol (info, hsym);
2899 hsym->flags |= (XCOFF_DEF_REGULAR | XCOFF_RTINIT);
2901 /* __rtinit initialized */
2902 amt = sizeof (struct internal_ldsym);
2903 ldsym = (struct internal_ldsym *) bfd_malloc (amt);
2905 ldsym->l_value = 0; /* will be filled in later */
2906 ldsym->l_scnum = 2; /* data section */
2907 ldsym->l_smtype = XTY_SD; /* csect section definition */
2908 ldsym->l_smclas = 5; /* .rw */
2909 ldsym->l_ifile = 0; /* special system loader symbol */
2910 ldsym->l_parm = 0; /* NA */
2912 /* Force __rtinit to be the first symbol in the loader symbol table
2913 See xcoff_build_ldsyms
2915 The first 3 symbol table indices are reserved to indicate the data,
2916 text and bss sections. */
2917 BFD_ASSERT (0 == ldinfo.ldsym_count);
2919 hsym->ldindx = 3;
2920 ldinfo.ldsym_count = 1;
2921 hsym->ldsym = ldsym;
2923 if (! bfd_xcoff_put_ldsymbol_name (ldinfo.output_bfd, &ldinfo,
2924 hsym->ldsym, hsym->root.root.string))
2925 return FALSE;
2927 /* This symbol is written out by xcoff_write_global_symbol
2928 Set stuff up so xcoff_write_global_symbol logic works. */
2929 hsym->flags |= XCOFF_DEF_REGULAR | XCOFF_MARK;
2930 hsym->root.type = bfd_link_hash_defined;
2931 hsym->root.u.def.value = 0;
2934 /* Garbage collect unused sections. */
2935 if (info->relocatable
2936 || ! gc
2937 || hentry == NULL
2938 || (hentry->root.type != bfd_link_hash_defined
2939 && hentry->root.type != bfd_link_hash_defweak))
2941 gc = FALSE;
2942 xcoff_hash_table (info)->gc = FALSE;
2944 /* We still need to call xcoff_mark, in order to set ldrel_count
2945 correctly. */
2946 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2948 asection *o;
2950 for (o = sub->sections; o != NULL; o = o->next)
2952 if ((o->flags & SEC_MARK) == 0)
2954 if (! xcoff_mark (info, o))
2955 goto error_return;
2960 else
2962 if (! xcoff_mark (info, hentry->root.u.def.section))
2963 goto error_return;
2964 xcoff_sweep (info);
2965 xcoff_hash_table (info)->gc = TRUE;
2968 /* Return special sections to the caller. */
2969 for (i = 0; i < XCOFF_NUMBER_OF_SPECIAL_SECTIONS; i++)
2971 sec = xcoff_hash_table (info)->special_sections[i];
2973 if (sec != NULL
2974 && gc
2975 && (sec->flags & SEC_MARK) == 0)
2977 sec = NULL;
2979 special_sections[i] = sec;
2982 if (info->input_bfds == NULL)
2984 /* I'm not sure what to do in this bizarre case. */
2985 return TRUE;
2988 xcoff_link_hash_traverse (xcoff_hash_table (info), xcoff_build_ldsyms,
2989 (PTR) &ldinfo);
2990 if (ldinfo.failed)
2991 goto error_return;
2993 /* Work out the size of the import file names. Each import file ID
2994 consists of three null terminated strings: the path, the file
2995 name, and the archive member name. The first entry in the list
2996 of names is the path to use to find objects, which the linker has
2997 passed in as the libpath argument. For some reason, the path
2998 entry in the other import file names appears to always be empty. */
2999 impsize = strlen (libpath) + 3;
3000 impcount = 1;
3001 for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
3003 ++impcount;
3004 impsize += (strlen (fl->path)
3005 + strlen (fl->file)
3006 + strlen (fl->member)
3007 + 3);
3010 /* Set up the .loader section header. */
3011 ldhdr = &xcoff_hash_table (info)->ldhdr;
3012 ldhdr->l_version = bfd_xcoff_ldhdr_version(output_bfd);
3013 ldhdr->l_nsyms = ldinfo.ldsym_count;
3014 ldhdr->l_nreloc = xcoff_hash_table (info)->ldrel_count;
3015 ldhdr->l_istlen = impsize;
3016 ldhdr->l_nimpid = impcount;
3017 ldhdr->l_impoff = (bfd_xcoff_ldhdrsz(output_bfd)
3018 + ldhdr->l_nsyms * bfd_xcoff_ldsymsz(output_bfd)
3019 + ldhdr->l_nreloc * bfd_xcoff_ldrelsz(output_bfd));
3020 ldhdr->l_stlen = ldinfo.string_size;
3021 stoff = ldhdr->l_impoff + impsize;
3022 if (ldinfo.string_size == 0)
3023 ldhdr->l_stoff = 0;
3024 else
3025 ldhdr->l_stoff = stoff;
3027 /* 64 bit elements to ldhdr
3028 The swap out routine for 32 bit will ignore them.
3029 Nothing fancy, symbols come after the header and relocs come
3030 after symbols. */
3031 ldhdr->l_symoff = bfd_xcoff_ldhdrsz (output_bfd);
3032 ldhdr->l_rldoff = (bfd_xcoff_ldhdrsz (output_bfd)
3033 + ldhdr->l_nsyms * bfd_xcoff_ldsymsz (output_bfd));
3035 /* We now know the final size of the .loader section. Allocate
3036 space for it. */
3037 lsec = xcoff_hash_table (info)->loader_section;
3038 lsec->_raw_size = stoff + ldhdr->l_stlen;
3039 lsec->contents = (bfd_byte *) bfd_zalloc (output_bfd, lsec->_raw_size);
3040 if (lsec->contents == NULL)
3041 goto error_return;
3043 /* Set up the header. */
3044 bfd_xcoff_swap_ldhdr_out (output_bfd, ldhdr, lsec->contents);
3046 /* Set up the import file names. */
3047 out = (char *) lsec->contents + ldhdr->l_impoff;
3048 strcpy (out, libpath);
3049 out += strlen (libpath) + 1;
3050 *out++ = '\0';
3051 *out++ = '\0';
3052 for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
3054 register const char *s;
3056 s = fl->path;
3057 while ((*out++ = *s++) != '\0')
3059 s = fl->file;
3060 while ((*out++ = *s++) != '\0')
3062 s = fl->member;
3063 while ((*out++ = *s++) != '\0')
3067 BFD_ASSERT ((bfd_size_type) ((bfd_byte *) out - lsec->contents) == stoff);
3069 /* Set up the symbol string table. */
3070 if (ldinfo.string_size > 0)
3072 memcpy (out, ldinfo.strings, ldinfo.string_size);
3073 free (ldinfo.strings);
3074 ldinfo.strings = NULL;
3077 /* We can't set up the symbol table or the relocs yet, because we
3078 don't yet know the final position of the various sections. The
3079 .loader symbols are written out when the corresponding normal
3080 symbols are written out in xcoff_link_input_bfd or
3081 xcoff_write_global_symbol. The .loader relocs are written out
3082 when the corresponding normal relocs are handled in
3083 xcoff_link_input_bfd.
3086 /* Allocate space for the magic sections. */
3087 sec = xcoff_hash_table (info)->linkage_section;
3088 if (sec->_raw_size > 0)
3090 sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
3091 if (sec->contents == NULL)
3092 goto error_return;
3094 sec = xcoff_hash_table (info)->toc_section;
3095 if (sec->_raw_size > 0)
3097 sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
3098 if (sec->contents == NULL)
3099 goto error_return;
3101 sec = xcoff_hash_table (info)->descriptor_section;
3102 if (sec->_raw_size > 0)
3104 sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
3105 if (sec->contents == NULL)
3106 goto error_return;
3109 /* Now that we've done garbage collection, figure out the contents
3110 of the .debug section. */
3111 debug_strtab = xcoff_hash_table (info)->debug_strtab;
3113 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3115 asection *subdeb;
3116 bfd_size_type symcount;
3117 unsigned long *debug_index;
3118 asection **csectpp;
3119 bfd_byte *esym, *esymend;
3120 bfd_size_type symesz;
3122 if (sub->xvec != info->hash->creator)
3123 continue;
3124 subdeb = bfd_get_section_by_name (sub, ".debug");
3125 if (subdeb == NULL || subdeb->_raw_size == 0)
3126 continue;
3128 if (info->strip == strip_all
3129 || info->strip == strip_debugger
3130 || info->discard == discard_all)
3132 subdeb->_raw_size = 0;
3133 continue;
3136 if (! _bfd_coff_get_external_symbols (sub))
3137 goto error_return;
3139 symcount = obj_raw_syment_count (sub);
3140 debug_index = ((unsigned long *)
3141 bfd_zalloc (sub, symcount * sizeof (unsigned long)));
3142 if (debug_index == NULL)
3143 goto error_return;
3144 xcoff_data (sub)->debug_indices = debug_index;
3146 /* Grab the contents of the .debug section. We use malloc and
3147 copy the names into the debug stringtab, rather than
3148 bfd_alloc, because I expect that, when linking many files
3149 together, many of the strings will be the same. Storing the
3150 strings in the hash table should save space in this case. */
3151 debug_contents = (bfd_byte *) bfd_malloc (subdeb->_raw_size);
3152 if (debug_contents == NULL)
3153 goto error_return;
3154 if (! bfd_get_section_contents (sub, subdeb, (PTR) debug_contents,
3155 (file_ptr) 0, subdeb->_raw_size))
3156 goto error_return;
3158 csectpp = xcoff_data (sub)->csects;
3160 /* Dynamic object do not have csectpp's. */
3161 if (NULL != csectpp)
3163 symesz = bfd_coff_symesz (sub);
3164 esym = (bfd_byte *) obj_coff_external_syms (sub);
3165 esymend = esym + symcount * symesz;
3167 while (esym < esymend)
3169 struct internal_syment sym;
3171 bfd_coff_swap_sym_in (sub, (PTR) esym, (PTR) &sym);
3173 *debug_index = (unsigned long) -1;
3175 if (sym._n._n_n._n_zeroes == 0
3176 && *csectpp != NULL
3177 && (! gc
3178 || ((*csectpp)->flags & SEC_MARK) != 0
3179 || *csectpp == bfd_abs_section_ptr)
3180 && bfd_coff_symname_in_debug (sub, &sym))
3182 char *name;
3183 bfd_size_type indx;
3185 name = (char *) debug_contents + sym._n._n_n._n_offset;
3186 indx = _bfd_stringtab_add (debug_strtab, name, TRUE, TRUE);
3187 if (indx == (bfd_size_type) -1)
3188 goto error_return;
3189 *debug_index = indx;
3192 esym += (sym.n_numaux + 1) * symesz;
3193 csectpp += sym.n_numaux + 1;
3194 debug_index += sym.n_numaux + 1;
3198 free (debug_contents);
3199 debug_contents = NULL;
3201 /* Clear the size of subdeb, so that it is not included directly
3202 in the output file. */
3203 subdeb->_raw_size = 0;
3205 if (! info->keep_memory)
3207 if (! _bfd_coff_free_symbols (sub))
3208 goto error_return;
3212 if (info->strip != strip_all)
3213 xcoff_hash_table (info)->debug_section->_raw_size =
3214 _bfd_stringtab_size (debug_strtab);
3216 return TRUE;
3218 error_return:
3219 if (ldinfo.strings != NULL)
3220 free (ldinfo.strings);
3221 if (debug_contents != NULL)
3222 free (debug_contents);
3223 return FALSE;
3226 bfd_boolean
3227 bfd_xcoff_link_generate_rtinit (abfd, init, fini, rtld)
3228 bfd *abfd;
3229 const char *init;
3230 const char *fini;
3231 bfd_boolean rtld;
3233 struct bfd_in_memory *bim;
3235 bim = ((struct bfd_in_memory *)
3236 bfd_malloc ((bfd_size_type) sizeof (struct bfd_in_memory)));
3237 if (bim == NULL)
3238 return FALSE;
3240 bim->size = 0;
3241 bim->buffer = 0;
3243 abfd->link_next = 0;
3244 abfd->format = bfd_object;
3245 abfd->iostream = (PTR) bim;
3246 abfd->flags = BFD_IN_MEMORY;
3247 abfd->direction = write_direction;
3248 abfd->where = 0;
3250 if (! bfd_xcoff_generate_rtinit (abfd, init, fini, rtld))
3251 return FALSE;
3253 /* need to reset to unknown or it will not be read back in correctly */
3254 abfd->format = bfd_unknown;
3255 abfd->direction = read_direction;
3256 abfd->where = 0;
3258 return TRUE;
3262 /* Add a symbol to the .loader symbols, if necessary. */
3264 static bfd_boolean
3265 xcoff_build_ldsyms (h, p)
3266 struct xcoff_link_hash_entry *h;
3267 PTR p;
3269 struct xcoff_loader_info *ldinfo = (struct xcoff_loader_info *) p;
3270 bfd_size_type amt;
3272 if (h->root.type == bfd_link_hash_warning)
3273 h = (struct xcoff_link_hash_entry *) h->root.u.i.link;
3275 /* __rtinit, this symbol has special handling. */
3276 if (h->flags & XCOFF_RTINIT)
3277 return TRUE;
3279 /* If this is a final link, and the symbol was defined as a common
3280 symbol in a regular object file, and there was no definition in
3281 any dynamic object, then the linker will have allocated space for
3282 the symbol in a common section but the XCOFF_DEF_REGULAR flag
3283 will not have been set. */
3284 if (h->root.type == bfd_link_hash_defined
3285 && (h->flags & XCOFF_DEF_REGULAR) == 0
3286 && (h->flags & XCOFF_REF_REGULAR) != 0
3287 && (h->flags & XCOFF_DEF_DYNAMIC) == 0
3288 && (bfd_is_abs_section (h->root.u.def.section)
3289 || (h->root.u.def.section->owner->flags & DYNAMIC) == 0))
3290 h->flags |= XCOFF_DEF_REGULAR;
3292 /* If all defined symbols should be exported, mark them now. We
3293 don't want to export the actual functions, just the function
3294 descriptors. */
3295 if (ldinfo->export_defineds
3296 && (h->flags & XCOFF_DEF_REGULAR) != 0
3297 && h->root.root.string[0] != '.')
3299 bfd_boolean export;
3301 /* We don't export a symbol which is being defined by an object
3302 included from an archive which contains a shared object. The
3303 rationale is that if an archive contains both an unshared and
3304 a shared object, then there must be some reason that the
3305 unshared object is unshared, and we don't want to start
3306 providing a shared version of it. In particular, this solves
3307 a bug involving the _savefNN set of functions. gcc will call
3308 those functions without providing a slot to restore the TOC,
3309 so it is essential that these functions be linked in directly
3310 and not from a shared object, which means that a shared
3311 object which also happens to link them in must not export
3312 them. This is confusing, but I haven't been able to think of
3313 a different approach. Note that the symbols can, of course,
3314 be exported explicitly. */
3315 export = TRUE;
3316 if ((h->root.type == bfd_link_hash_defined
3317 || h->root.type == bfd_link_hash_defweak)
3318 && h->root.u.def.section->owner != NULL
3319 && h->root.u.def.section->owner->my_archive != NULL)
3321 bfd *arbfd, *member;
3323 arbfd = h->root.u.def.section->owner->my_archive;
3324 member = bfd_openr_next_archived_file (arbfd, (bfd *) NULL);
3325 while (member != NULL)
3327 if ((member->flags & DYNAMIC) != 0)
3329 export = FALSE;
3330 break;
3332 member = bfd_openr_next_archived_file (arbfd, member);
3336 if (export)
3337 h->flags |= XCOFF_EXPORT;
3340 /* We don't want to garbage collect symbols which are not defined in
3341 XCOFF files. This is a convenient place to mark them. */
3342 if (xcoff_hash_table (ldinfo->info)->gc
3343 && (h->flags & XCOFF_MARK) == 0
3344 && (h->root.type == bfd_link_hash_defined
3345 || h->root.type == bfd_link_hash_defweak)
3346 && (h->root.u.def.section->owner == NULL
3347 || (h->root.u.def.section->owner->xvec
3348 != ldinfo->info->hash->creator)))
3349 h->flags |= XCOFF_MARK;
3351 /* If this symbol is called and defined in a dynamic object, or it
3352 is imported, then we need to set up global linkage code for it.
3353 (Unless we did garbage collection and we didn't need this
3354 symbol.) */
3355 if ((h->flags & XCOFF_CALLED) != 0
3356 && (h->root.type == bfd_link_hash_undefined
3357 || h->root.type == bfd_link_hash_undefweak)
3358 && h->root.root.string[0] == '.'
3359 && h->descriptor != NULL
3360 && ((h->descriptor->flags & XCOFF_DEF_DYNAMIC) != 0
3361 || ((h->descriptor->flags & XCOFF_IMPORT) != 0
3362 && (h->descriptor->flags & XCOFF_DEF_REGULAR) == 0))
3363 && (! xcoff_hash_table (ldinfo->info)->gc
3364 || (h->flags & XCOFF_MARK) != 0))
3366 asection *sec;
3367 struct xcoff_link_hash_entry *hds;
3369 sec = xcoff_hash_table (ldinfo->info)->linkage_section;
3370 h->root.type = bfd_link_hash_defined;
3371 h->root.u.def.section = sec;
3372 h->root.u.def.value = sec->_raw_size;
3373 h->smclas = XMC_GL;
3374 h->flags |= XCOFF_DEF_REGULAR;
3375 sec->_raw_size += bfd_xcoff_glink_code_size(ldinfo->output_bfd);
3377 /* The global linkage code requires a TOC entry for the
3378 descriptor. */
3379 hds = h->descriptor;
3380 BFD_ASSERT ((hds->root.type == bfd_link_hash_undefined
3381 || hds->root.type == bfd_link_hash_undefweak)
3382 && (hds->flags & XCOFF_DEF_REGULAR) == 0);
3383 hds->flags |= XCOFF_MARK;
3384 if (hds->toc_section == NULL)
3386 int byte_size;
3388 /* 32 vs 64
3389 xcoff32 uses 4 bytes in the toc.
3390 xcoff64 uses 8 bytes in the toc. */
3391 if (bfd_xcoff_is_xcoff64 (ldinfo->output_bfd))
3392 byte_size = 8;
3393 else if (bfd_xcoff_is_xcoff32 (ldinfo->output_bfd))
3394 byte_size = 4;
3395 else
3396 return FALSE;
3398 hds->toc_section = xcoff_hash_table (ldinfo->info)->toc_section;
3399 hds->u.toc_offset = hds->toc_section->_raw_size;
3400 hds->toc_section->_raw_size += byte_size;
3401 ++xcoff_hash_table (ldinfo->info)->ldrel_count;
3402 ++hds->toc_section->reloc_count;
3403 hds->indx = -2;
3404 hds->flags |= XCOFF_SET_TOC | XCOFF_LDREL;
3406 /* We need to call xcoff_build_ldsyms recursively here,
3407 because we may already have passed hds on the traversal. */
3408 xcoff_build_ldsyms (hds, p);
3412 /* If this symbol is exported, but not defined, we need to try to
3413 define it. */
3414 if ((h->flags & XCOFF_EXPORT) != 0
3415 && (h->flags & XCOFF_IMPORT) == 0
3416 && (h->flags & XCOFF_DEF_REGULAR) == 0
3417 && (h->flags & XCOFF_DEF_DYNAMIC) == 0
3418 && (h->root.type == bfd_link_hash_undefined
3419 || h->root.type == bfd_link_hash_undefweak))
3421 if ((h->flags & XCOFF_DESCRIPTOR) != 0
3422 && (h->descriptor->root.type == bfd_link_hash_defined
3423 || h->descriptor->root.type == bfd_link_hash_defweak))
3425 asection *sec;
3427 /* This is an undefined function descriptor associated with
3428 a defined entry point. We can build up a function
3429 descriptor ourselves. Believe it or not, the AIX linker
3430 actually does this, and there are cases where we need to
3431 do it as well. */
3432 sec = xcoff_hash_table (ldinfo->info)->descriptor_section;
3433 h->root.type = bfd_link_hash_defined;
3434 h->root.u.def.section = sec;
3435 h->root.u.def.value = sec->_raw_size;
3436 h->smclas = XMC_DS;
3437 h->flags |= XCOFF_DEF_REGULAR;
3439 /* The size of the function descriptor depends if this is an
3440 xcoff32 (12) or xcoff64 (24). */
3441 sec->_raw_size +=
3442 bfd_xcoff_function_descriptor_size(ldinfo->output_bfd);
3444 /* A function descriptor uses two relocs: one for the
3445 associated code, and one for the TOC address. */
3446 xcoff_hash_table (ldinfo->info)->ldrel_count += 2;
3447 sec->reloc_count += 2;
3449 /* We handle writing out the contents of the descriptor in
3450 xcoff_write_global_symbol. */
3452 else
3454 (*_bfd_error_handler)
3455 (_("warning: attempt to export undefined symbol `%s'"),
3456 h->root.root.string);
3457 h->ldsym = NULL;
3458 return TRUE;
3462 /* If this is still a common symbol, and it wasn't garbage
3463 collected, we need to actually allocate space for it in the .bss
3464 section. */
3465 if (h->root.type == bfd_link_hash_common
3466 && (! xcoff_hash_table (ldinfo->info)->gc
3467 || (h->flags & XCOFF_MARK) != 0)
3468 && h->root.u.c.p->section->_raw_size == 0)
3470 BFD_ASSERT (bfd_is_com_section (h->root.u.c.p->section));
3471 h->root.u.c.p->section->_raw_size = h->root.u.c.size;
3474 /* We need to add a symbol to the .loader section if it is mentioned
3475 in a reloc which we are copying to the .loader section and it was
3476 not defined or common, or if it is the entry point, or if it is
3477 being exported. */
3479 if (((h->flags & XCOFF_LDREL) == 0
3480 || h->root.type == bfd_link_hash_defined
3481 || h->root.type == bfd_link_hash_defweak
3482 || h->root.type == bfd_link_hash_common)
3483 && (h->flags & XCOFF_ENTRY) == 0
3484 && (h->flags & XCOFF_EXPORT) == 0)
3486 h->ldsym = NULL;
3487 return TRUE;
3490 /* We don't need to add this symbol if we did garbage collection and
3491 we did not mark this symbol. */
3492 if (xcoff_hash_table (ldinfo->info)->gc
3493 && (h->flags & XCOFF_MARK) == 0)
3495 h->ldsym = NULL;
3496 return TRUE;
3499 /* We may have already processed this symbol due to the recursive
3500 call above. */
3501 if ((h->flags & XCOFF_BUILT_LDSYM) != 0)
3502 return TRUE;
3504 /* We need to add this symbol to the .loader symbols. */
3506 BFD_ASSERT (h->ldsym == NULL);
3507 amt = sizeof (struct internal_ldsym);
3508 h->ldsym = (struct internal_ldsym *) bfd_zalloc (ldinfo->output_bfd, amt);
3509 if (h->ldsym == NULL)
3511 ldinfo->failed = TRUE;
3512 return FALSE;
3515 if ((h->flags & XCOFF_IMPORT) != 0)
3516 h->ldsym->l_ifile = h->ldindx;
3518 /* The first 3 symbol table indices are reserved to indicate the
3519 data, text and bss sections. */
3520 h->ldindx = ldinfo->ldsym_count + 3;
3522 ++ldinfo->ldsym_count;
3524 if (! bfd_xcoff_put_ldsymbol_name (ldinfo->output_bfd, ldinfo,
3525 h->ldsym, h->root.root.string))
3527 return FALSE;
3530 h->flags |= XCOFF_BUILT_LDSYM;
3532 return TRUE;
3535 /* Do the final link step. */
3537 bfd_boolean
3538 _bfd_xcoff_bfd_final_link (abfd, info)
3539 bfd *abfd;
3540 struct bfd_link_info *info;
3542 bfd_size_type symesz;
3543 struct xcoff_final_link_info finfo;
3544 asection *o;
3545 struct bfd_link_order *p;
3546 bfd_size_type max_contents_size;
3547 bfd_size_type max_sym_count;
3548 bfd_size_type max_lineno_count;
3549 bfd_size_type max_reloc_count;
3550 bfd_size_type max_output_reloc_count;
3551 file_ptr rel_filepos;
3552 unsigned int relsz;
3553 file_ptr line_filepos;
3554 unsigned int linesz;
3555 bfd *sub;
3556 bfd_byte *external_relocs = NULL;
3557 char strbuf[STRING_SIZE_SIZE];
3558 file_ptr pos;
3559 bfd_size_type amt;
3561 if (info->shared)
3562 abfd->flags |= DYNAMIC;
3564 symesz = bfd_coff_symesz (abfd);
3566 finfo.info = info;
3567 finfo.output_bfd = abfd;
3568 finfo.strtab = NULL;
3569 finfo.section_info = NULL;
3570 finfo.last_file_index = -1;
3571 finfo.toc_symindx = -1;
3572 finfo.internal_syms = NULL;
3573 finfo.sym_indices = NULL;
3574 finfo.outsyms = NULL;
3575 finfo.linenos = NULL;
3576 finfo.contents = NULL;
3577 finfo.external_relocs = NULL;
3579 finfo.ldsym = (xcoff_hash_table (info)->loader_section->contents
3580 + bfd_xcoff_ldhdrsz (abfd));
3581 finfo.ldrel = (xcoff_hash_table (info)->loader_section->contents
3582 + bfd_xcoff_ldhdrsz(abfd)
3583 + (xcoff_hash_table (info)->ldhdr.l_nsyms
3584 * bfd_xcoff_ldsymsz(abfd)));
3586 xcoff_data (abfd)->coff.link_info = info;
3588 finfo.strtab = _bfd_stringtab_init ();
3589 if (finfo.strtab == NULL)
3590 goto error_return;
3592 /* Count the line number and relocation entries required for the
3593 output file. Determine a few maximum sizes. */
3594 max_contents_size = 0;
3595 max_lineno_count = 0;
3596 max_reloc_count = 0;
3597 for (o = abfd->sections; o != NULL; o = o->next)
3599 o->reloc_count = 0;
3600 o->lineno_count = 0;
3601 for (p = o->link_order_head; p != NULL; p = p->next)
3603 if (p->type == bfd_indirect_link_order)
3605 asection *sec;
3607 sec = p->u.indirect.section;
3609 /* Mark all sections which are to be included in the
3610 link. This will normally be every section. We need
3611 to do this so that we can identify any sections which
3612 the linker has decided to not include. */
3613 sec->linker_mark = TRUE;
3615 if (info->strip == strip_none
3616 || info->strip == strip_some)
3617 o->lineno_count += sec->lineno_count;
3619 o->reloc_count += sec->reloc_count;
3621 if (sec->_raw_size > max_contents_size)
3622 max_contents_size = sec->_raw_size;
3623 if (sec->lineno_count > max_lineno_count)
3624 max_lineno_count = sec->lineno_count;
3625 if (coff_section_data (sec->owner, sec) != NULL
3626 && xcoff_section_data (sec->owner, sec) != NULL
3627 && (xcoff_section_data (sec->owner, sec)->lineno_count
3628 > max_lineno_count))
3629 max_lineno_count =
3630 xcoff_section_data (sec->owner, sec)->lineno_count;
3631 if (sec->reloc_count > max_reloc_count)
3632 max_reloc_count = sec->reloc_count;
3634 else if (p->type == bfd_section_reloc_link_order
3635 || p->type == bfd_symbol_reloc_link_order)
3636 ++o->reloc_count;
3640 /* Compute the file positions for all the sections. */
3641 if (abfd->output_has_begun)
3643 if (xcoff_hash_table (info)->file_align != 0)
3644 abort ();
3646 else
3648 bfd_vma file_align;
3650 file_align = xcoff_hash_table (info)->file_align;
3651 if (file_align != 0)
3653 bfd_boolean saw_contents;
3654 int indx;
3655 asection **op;
3656 file_ptr sofar;
3658 /* Insert .pad sections before every section which has
3659 contents and is loaded, if it is preceded by some other
3660 section which has contents and is loaded. */
3661 saw_contents = TRUE;
3662 for (op = &abfd->sections; *op != NULL; op = &(*op)->next)
3664 if (strcmp ((*op)->name, ".pad") == 0)
3665 saw_contents = FALSE;
3666 else if (((*op)->flags & SEC_HAS_CONTENTS) != 0
3667 && ((*op)->flags & SEC_LOAD) != 0)
3669 if (! saw_contents)
3670 saw_contents = TRUE;
3671 else
3673 asection *n, **st;
3675 /* Create a pad section and place it before the section
3676 that needs padding. This requires unlinking and
3677 relinking the bfd's section list. */
3679 st = abfd->section_tail;
3680 n = bfd_make_section_anyway (abfd, ".pad");
3681 n->flags = SEC_HAS_CONTENTS;
3682 n->alignment_power = 0;
3684 BFD_ASSERT (*st == n);
3685 bfd_section_list_remove (abfd, st);
3686 bfd_section_list_insert (abfd, op, n);
3688 op = &n->next;
3689 saw_contents = FALSE;
3694 /* Reset the section indices after inserting the new
3695 sections. */
3696 indx = 0;
3697 for (o = abfd->sections; o != NULL; o = o->next)
3699 ++indx;
3700 o->target_index = indx;
3702 BFD_ASSERT ((unsigned int) indx == abfd->section_count);
3704 /* Work out appropriate sizes for the .pad sections to force
3705 each section to land on a page boundary. This bit of
3706 code knows what compute_section_file_positions is going
3707 to do. */
3708 sofar = bfd_coff_filhsz (abfd);
3709 sofar += bfd_coff_aoutsz (abfd);
3710 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
3711 for (o = abfd->sections; o != NULL; o = o->next)
3712 if ((bfd_xcoff_is_reloc_count_overflow
3713 (abfd, (bfd_vma) o->reloc_count))
3714 || (bfd_xcoff_is_lineno_count_overflow
3715 (abfd, (bfd_vma) o->lineno_count)))
3716 /* 64 does not overflow, need to check if 32 does */
3717 sofar += bfd_coff_scnhsz (abfd);
3719 for (o = abfd->sections; o != NULL; o = o->next)
3721 if (strcmp (o->name, ".pad") == 0)
3723 bfd_vma pageoff;
3725 BFD_ASSERT (o->_raw_size == 0);
3726 pageoff = sofar & (file_align - 1);
3727 if (pageoff != 0)
3729 o->_raw_size = file_align - pageoff;
3730 sofar += file_align - pageoff;
3731 o->flags |= SEC_HAS_CONTENTS;
3734 else
3736 if ((o->flags & SEC_HAS_CONTENTS) != 0)
3737 sofar += BFD_ALIGN (o->_raw_size,
3738 1 << o->alignment_power);
3743 if (! bfd_coff_compute_section_file_positions (abfd))
3744 goto error_return;
3747 /* Allocate space for the pointers we need to keep for the relocs. */
3749 unsigned int i;
3751 /* We use section_count + 1, rather than section_count, because
3752 the target_index fields are 1 based. */
3753 amt = abfd->section_count + 1;
3754 amt *= sizeof (struct xcoff_link_section_info);
3755 finfo.section_info = (struct xcoff_link_section_info *) bfd_malloc (amt);
3756 if (finfo.section_info == NULL)
3757 goto error_return;
3758 for (i = 0; i <= abfd->section_count; i++)
3760 finfo.section_info[i].relocs = NULL;
3761 finfo.section_info[i].rel_hashes = NULL;
3762 finfo.section_info[i].toc_rel_hashes = NULL;
3766 /* Set the file positions for the relocs. */
3767 rel_filepos = obj_relocbase (abfd);
3768 relsz = bfd_coff_relsz (abfd);
3769 max_output_reloc_count = 0;
3770 for (o = abfd->sections; o != NULL; o = o->next)
3772 if (o->reloc_count == 0)
3773 o->rel_filepos = 0;
3774 else
3776 /* A stripped file has no relocs. However, we still
3777 allocate the buffers, so that later code doesn't have to
3778 worry about whether we are stripping or not. */
3779 if (info->strip == strip_all)
3780 o->rel_filepos = 0;
3781 else
3783 o->flags |= SEC_RELOC;
3784 o->rel_filepos = rel_filepos;
3785 rel_filepos += o->reloc_count * relsz;
3788 /* We don't know the indices of global symbols until we have
3789 written out all the local symbols. For each section in
3790 the output file, we keep an array of pointers to hash
3791 table entries. Each entry in the array corresponds to a
3792 reloc. When we find a reloc against a global symbol, we
3793 set the corresponding entry in this array so that we can
3794 fix up the symbol index after we have written out all the
3795 local symbols.
3797 Because of this problem, we also keep the relocs in
3798 memory until the end of the link. This wastes memory.
3799 We could backpatch the file later, I suppose, although it
3800 would be slow. */
3801 amt = o->reloc_count;
3802 amt *= sizeof (struct internal_reloc);
3803 finfo.section_info[o->target_index].relocs =
3804 (struct internal_reloc *) bfd_malloc (amt);
3806 amt = o->reloc_count;
3807 amt *= sizeof (struct xcoff_link_hash_entry *);
3808 finfo.section_info[o->target_index].rel_hashes =
3809 (struct xcoff_link_hash_entry **) bfd_malloc (amt);
3811 if (finfo.section_info[o->target_index].relocs == NULL
3812 || finfo.section_info[o->target_index].rel_hashes == NULL)
3813 goto error_return;
3815 if (o->reloc_count > max_output_reloc_count)
3816 max_output_reloc_count = o->reloc_count;
3820 /* We now know the size of the relocs, so we can determine the file
3821 positions of the line numbers. */
3822 line_filepos = rel_filepos;
3823 finfo.line_filepos = line_filepos;
3824 linesz = bfd_coff_linesz (abfd);
3825 for (o = abfd->sections; o != NULL; o = o->next)
3827 if (o->lineno_count == 0)
3828 o->line_filepos = 0;
3829 else
3831 o->line_filepos = line_filepos;
3832 line_filepos += o->lineno_count * linesz;
3835 /* Reset the reloc and lineno counts, so that we can use them to
3836 count the number of entries we have output so far. */
3837 o->reloc_count = 0;
3838 o->lineno_count = 0;
3841 obj_sym_filepos (abfd) = line_filepos;
3843 /* Figure out the largest number of symbols in an input BFD. Take
3844 the opportunity to clear the output_has_begun fields of all the
3845 input BFD's. We want at least 6 symbols, since that is the
3846 number which xcoff_write_global_symbol may need. */
3847 max_sym_count = 6;
3848 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3850 bfd_size_type sz;
3852 sub->output_has_begun = FALSE;
3853 sz = obj_raw_syment_count (sub);
3854 if (sz > max_sym_count)
3855 max_sym_count = sz;
3858 /* Allocate some buffers used while linking. */
3859 amt = max_sym_count * sizeof (struct internal_syment);
3860 finfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
3862 amt = max_sym_count * sizeof (long);
3863 finfo.sym_indices = (long *) bfd_malloc (amt);
3865 amt = (max_sym_count + 1) * symesz;
3866 finfo.outsyms = (bfd_byte *) bfd_malloc (amt);
3868 amt = max_lineno_count * bfd_coff_linesz (abfd);
3869 finfo.linenos = (bfd_byte *) bfd_malloc (amt);
3871 amt = max_contents_size;
3872 finfo.contents = (bfd_byte *) bfd_malloc (amt);
3874 amt = max_reloc_count * relsz;
3875 finfo.external_relocs = (bfd_byte *) bfd_malloc (amt);
3877 if ((finfo.internal_syms == NULL && max_sym_count > 0)
3878 || (finfo.sym_indices == NULL && max_sym_count > 0)
3879 || finfo.outsyms == NULL
3880 || (finfo.linenos == NULL && max_lineno_count > 0)
3881 || (finfo.contents == NULL && max_contents_size > 0)
3882 || (finfo.external_relocs == NULL && max_reloc_count > 0))
3883 goto error_return;
3885 obj_raw_syment_count (abfd) = 0;
3886 xcoff_data (abfd)->toc = (bfd_vma) -1;
3888 /* We now know the position of everything in the file, except that
3889 we don't know the size of the symbol table and therefore we don't
3890 know where the string table starts. We just build the string
3891 table in memory as we go along. We process all the relocations
3892 for a single input file at once. */
3893 for (o = abfd->sections; o != NULL; o = o->next)
3895 for (p = o->link_order_head; p != NULL; p = p->next)
3897 if (p->type == bfd_indirect_link_order
3898 && p->u.indirect.section->owner->xvec == abfd->xvec)
3900 sub = p->u.indirect.section->owner;
3901 if (! sub->output_has_begun)
3903 if (! xcoff_link_input_bfd (&finfo, sub))
3904 goto error_return;
3905 sub->output_has_begun = TRUE;
3908 else if (p->type == bfd_section_reloc_link_order
3909 || p->type == bfd_symbol_reloc_link_order)
3911 if (! xcoff_reloc_link_order (abfd, &finfo, o, p))
3912 goto error_return;
3914 else
3916 if (! _bfd_default_link_order (abfd, info, o, p))
3917 goto error_return;
3923 /* Free up the buffers used by xcoff_link_input_bfd. */
3925 if (finfo.internal_syms != NULL)
3927 free (finfo.internal_syms);
3928 finfo.internal_syms = NULL;
3930 if (finfo.sym_indices != NULL)
3932 free (finfo.sym_indices);
3933 finfo.sym_indices = NULL;
3935 if (finfo.linenos != NULL)
3937 free (finfo.linenos);
3938 finfo.linenos = NULL;
3940 if (finfo.contents != NULL)
3942 free (finfo.contents);
3943 finfo.contents = NULL;
3945 if (finfo.external_relocs != NULL)
3947 free (finfo.external_relocs);
3948 finfo.external_relocs = NULL;
3951 /* The value of the last C_FILE symbol is supposed to be -1. Write
3952 it out again. */
3953 if (finfo.last_file_index != -1)
3955 finfo.last_file.n_value = -(bfd_vma) 1;
3956 bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
3957 (PTR) finfo.outsyms);
3958 pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
3959 if (bfd_seek (abfd, pos, SEEK_SET) != 0
3960 || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
3961 goto error_return;
3964 /* Write out all the global symbols which do not come from XCOFF
3965 input files. */
3966 xcoff_link_hash_traverse (xcoff_hash_table (info),
3967 xcoff_write_global_symbol,
3968 (PTR) &finfo);
3970 if (finfo.outsyms != NULL)
3972 free (finfo.outsyms);
3973 finfo.outsyms = NULL;
3976 /* Now that we have written out all the global symbols, we know the
3977 symbol indices to use for relocs against them, and we can finally
3978 write out the relocs. */
3979 amt = max_output_reloc_count * relsz;
3980 external_relocs = (bfd_byte *) bfd_malloc (amt);
3981 if (external_relocs == NULL && max_output_reloc_count != 0)
3982 goto error_return;
3984 for (o = abfd->sections; o != NULL; o = o->next)
3986 struct internal_reloc *irel;
3987 struct internal_reloc *irelend;
3988 struct xcoff_link_hash_entry **rel_hash;
3989 struct xcoff_toc_rel_hash *toc_rel_hash;
3990 bfd_byte *erel;
3991 bfd_size_type rel_size;
3993 /* A stripped file has no relocs. */
3994 if (info->strip == strip_all)
3996 o->reloc_count = 0;
3997 continue;
4000 if (o->reloc_count == 0)
4001 continue;
4003 irel = finfo.section_info[o->target_index].relocs;
4004 irelend = irel + o->reloc_count;
4005 rel_hash = finfo.section_info[o->target_index].rel_hashes;
4006 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
4008 if (*rel_hash != NULL)
4010 if ((*rel_hash)->indx < 0)
4012 if (! ((*info->callbacks->unattached_reloc)
4013 (info, (*rel_hash)->root.root.string,
4014 (bfd *) NULL, o, irel->r_vaddr)))
4015 goto error_return;
4016 (*rel_hash)->indx = 0;
4018 irel->r_symndx = (*rel_hash)->indx;
4022 for (toc_rel_hash = finfo.section_info[o->target_index].toc_rel_hashes;
4023 toc_rel_hash != NULL;
4024 toc_rel_hash = toc_rel_hash->next)
4026 if (toc_rel_hash->h->u.toc_indx < 0)
4028 if (! ((*info->callbacks->unattached_reloc)
4029 (info, toc_rel_hash->h->root.root.string,
4030 (bfd *) NULL, o, toc_rel_hash->rel->r_vaddr)))
4031 goto error_return;
4032 toc_rel_hash->h->u.toc_indx = 0;
4034 toc_rel_hash->rel->r_symndx = toc_rel_hash->h->u.toc_indx;
4037 /* XCOFF requires that the relocs be sorted by address. We tend
4038 to produce them in the order in which their containing csects
4039 appear in the symbol table, which is not necessarily by
4040 address. So we sort them here. There may be a better way to
4041 do this. */
4042 qsort ((PTR) finfo.section_info[o->target_index].relocs,
4043 o->reloc_count, sizeof (struct internal_reloc),
4044 xcoff_sort_relocs);
4046 irel = finfo.section_info[o->target_index].relocs;
4047 irelend = irel + o->reloc_count;
4048 erel = external_relocs;
4049 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
4050 bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
4052 rel_size = relsz * o->reloc_count;
4053 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
4054 || bfd_bwrite ((PTR) external_relocs, rel_size, abfd) != rel_size)
4055 goto error_return;
4058 if (external_relocs != NULL)
4060 free (external_relocs);
4061 external_relocs = NULL;
4064 /* Free up the section information. */
4065 if (finfo.section_info != NULL)
4067 unsigned int i;
4069 for (i = 0; i < abfd->section_count; i++)
4071 if (finfo.section_info[i].relocs != NULL)
4072 free (finfo.section_info[i].relocs);
4073 if (finfo.section_info[i].rel_hashes != NULL)
4074 free (finfo.section_info[i].rel_hashes);
4076 free (finfo.section_info);
4077 finfo.section_info = NULL;
4080 /* Write out the loader section contents. */
4081 BFD_ASSERT ((bfd_byte *) finfo.ldrel
4082 == (xcoff_hash_table (info)->loader_section->contents
4083 + xcoff_hash_table (info)->ldhdr.l_impoff));
4084 o = xcoff_hash_table (info)->loader_section;
4085 if (! bfd_set_section_contents (abfd, o->output_section, o->contents,
4086 (file_ptr) o->output_offset, o->_raw_size))
4087 goto error_return;
4089 /* Write out the magic sections. */
4090 o = xcoff_hash_table (info)->linkage_section;
4091 if (o->_raw_size > 0
4092 && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
4093 (file_ptr) o->output_offset,
4094 o->_raw_size))
4095 goto error_return;
4096 o = xcoff_hash_table (info)->toc_section;
4097 if (o->_raw_size > 0
4098 && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
4099 (file_ptr) o->output_offset,
4100 o->_raw_size))
4101 goto error_return;
4102 o = xcoff_hash_table (info)->descriptor_section;
4103 if (o->_raw_size > 0
4104 && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
4105 (file_ptr) o->output_offset,
4106 o->_raw_size))
4107 goto error_return;
4109 /* Write out the string table. */
4110 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
4111 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
4112 goto error_return;
4113 H_PUT_32 (abfd,
4114 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
4115 strbuf);
4116 amt = STRING_SIZE_SIZE;
4117 if (bfd_bwrite (strbuf, amt, abfd) != amt)
4118 goto error_return;
4119 if (! _bfd_stringtab_emit (abfd, finfo.strtab))
4120 goto error_return;
4122 _bfd_stringtab_free (finfo.strtab);
4124 /* Write out the debugging string table. */
4125 o = xcoff_hash_table (info)->debug_section;
4126 if (o != NULL)
4128 struct bfd_strtab_hash *debug_strtab;
4130 debug_strtab = xcoff_hash_table (info)->debug_strtab;
4131 BFD_ASSERT (o->output_section->_raw_size - o->output_offset
4132 >= _bfd_stringtab_size (debug_strtab));
4133 pos = o->output_section->filepos + o->output_offset;
4134 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
4135 goto error_return;
4136 if (! _bfd_stringtab_emit (abfd, debug_strtab))
4137 goto error_return;
4140 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
4141 not try to write out the symbols. */
4142 bfd_get_symcount (abfd) = 0;
4144 return TRUE;
4146 error_return:
4147 if (finfo.strtab != NULL)
4148 _bfd_stringtab_free (finfo.strtab);
4150 if (finfo.section_info != NULL)
4152 unsigned int i;
4154 for (i = 0; i < abfd->section_count; i++)
4156 if (finfo.section_info[i].relocs != NULL)
4157 free (finfo.section_info[i].relocs);
4158 if (finfo.section_info[i].rel_hashes != NULL)
4159 free (finfo.section_info[i].rel_hashes);
4161 free (finfo.section_info);
4164 if (finfo.internal_syms != NULL)
4165 free (finfo.internal_syms);
4166 if (finfo.sym_indices != NULL)
4167 free (finfo.sym_indices);
4168 if (finfo.outsyms != NULL)
4169 free (finfo.outsyms);
4170 if (finfo.linenos != NULL)
4171 free (finfo.linenos);
4172 if (finfo.contents != NULL)
4173 free (finfo.contents);
4174 if (finfo.external_relocs != NULL)
4175 free (finfo.external_relocs);
4176 if (external_relocs != NULL)
4177 free (external_relocs);
4178 return FALSE;
4181 /* Link an input file into the linker output file. This function
4182 handles all the sections and relocations of the input file at once. */
4184 static bfd_boolean
4185 xcoff_link_input_bfd (finfo, input_bfd)
4186 struct xcoff_final_link_info *finfo;
4187 bfd *input_bfd;
4189 bfd *output_bfd;
4190 const char *strings;
4191 bfd_size_type syment_base;
4192 unsigned int n_tmask;
4193 unsigned int n_btshft;
4194 bfd_boolean copy, hash;
4195 bfd_size_type isymesz;
4196 bfd_size_type osymesz;
4197 bfd_size_type linesz;
4198 bfd_byte *esym;
4199 bfd_byte *esym_end;
4200 struct xcoff_link_hash_entry **sym_hash;
4201 struct internal_syment *isymp;
4202 asection **csectpp;
4203 unsigned long *debug_index;
4204 long *indexp;
4205 unsigned long output_index;
4206 bfd_byte *outsym;
4207 unsigned int incls;
4208 asection *oline;
4209 bfd_boolean keep_syms;
4210 asection *o;
4212 /* We can just skip DYNAMIC files, unless this is a static link. */
4213 if ((input_bfd->flags & DYNAMIC) != 0
4214 && ! finfo->info->static_link)
4215 return TRUE;
4217 /* Move all the symbols to the output file. */
4219 output_bfd = finfo->output_bfd;
4220 strings = NULL;
4221 syment_base = obj_raw_syment_count (output_bfd);
4222 isymesz = bfd_coff_symesz (input_bfd);
4223 osymesz = bfd_coff_symesz (output_bfd);
4224 linesz = bfd_coff_linesz (input_bfd);
4225 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
4227 n_tmask = coff_data (input_bfd)->local_n_tmask;
4228 n_btshft = coff_data (input_bfd)->local_n_btshft;
4230 /* Define macros so that ISFCN, et. al., macros work correctly. */
4231 #define N_TMASK n_tmask
4232 #define N_BTSHFT n_btshft
4234 copy = FALSE;
4235 if (! finfo->info->keep_memory)
4236 copy = TRUE;
4237 hash = TRUE;
4238 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
4239 hash = FALSE;
4241 if (! _bfd_coff_get_external_symbols (input_bfd))
4242 return FALSE;
4244 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
4245 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
4246 sym_hash = obj_xcoff_sym_hashes (input_bfd);
4247 csectpp = xcoff_data (input_bfd)->csects;
4248 debug_index = xcoff_data (input_bfd)->debug_indices;
4249 isymp = finfo->internal_syms;
4250 indexp = finfo->sym_indices;
4251 output_index = syment_base;
4252 outsym = finfo->outsyms;
4253 incls = 0;
4254 oline = NULL;
4256 while (esym < esym_end)
4259 struct internal_syment isym;
4260 union internal_auxent aux;
4261 int smtyp = 0;
4262 bfd_boolean skip;
4263 bfd_boolean require;
4264 int add;
4266 bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
4268 /* If this is a C_EXT or C_HIDEXT symbol, we need the csect
4269 information. */
4270 if (isymp->n_sclass == C_EXT || isymp->n_sclass == C_HIDEXT)
4272 BFD_ASSERT (isymp->n_numaux > 0);
4273 bfd_coff_swap_aux_in (input_bfd,
4274 (PTR) (esym + isymesz * isymp->n_numaux),
4275 isymp->n_type, isymp->n_sclass,
4276 isymp->n_numaux - 1, isymp->n_numaux,
4277 (PTR) &aux);
4279 smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
4282 /* Make a copy of *isymp so that the relocate_section function
4283 always sees the original values. This is more reliable than
4284 always recomputing the symbol value even if we are stripping
4285 the symbol. */
4286 isym = *isymp;
4288 /* If this symbol is in the .loader section, swap out the
4289 .loader symbol information. If this is an external symbol
4290 reference to a defined symbol, though, then wait until we get
4291 to the definition. */
4292 if (isym.n_sclass == C_EXT
4293 && *sym_hash != NULL
4294 && (*sym_hash)->ldsym != NULL
4295 && (smtyp != XTY_ER
4296 || (*sym_hash)->root.type == bfd_link_hash_undefined))
4298 struct xcoff_link_hash_entry *h;
4299 struct internal_ldsym *ldsym;
4301 h = *sym_hash;
4302 ldsym = h->ldsym;
4303 if (isym.n_scnum > 0)
4305 ldsym->l_scnum = (*csectpp)->output_section->target_index;
4306 ldsym->l_value = (isym.n_value
4307 + (*csectpp)->output_section->vma
4308 + (*csectpp)->output_offset
4309 - (*csectpp)->vma);
4311 else
4313 ldsym->l_scnum = isym.n_scnum;
4314 ldsym->l_value = isym.n_value;
4317 ldsym->l_smtype = smtyp;
4318 if (((h->flags & XCOFF_DEF_REGULAR) == 0
4319 && (h->flags & XCOFF_DEF_DYNAMIC) != 0)
4320 || (h->flags & XCOFF_IMPORT) != 0)
4321 ldsym->l_smtype |= L_IMPORT;
4322 if (((h->flags & XCOFF_DEF_REGULAR) != 0
4323 && (h->flags & XCOFF_DEF_DYNAMIC) != 0)
4324 || (h->flags & XCOFF_EXPORT) != 0)
4325 ldsym->l_smtype |= L_EXPORT;
4326 if ((h->flags & XCOFF_ENTRY) != 0)
4327 ldsym->l_smtype |= L_ENTRY;
4329 ldsym->l_smclas = aux.x_csect.x_smclas;
4331 if (ldsym->l_ifile == (bfd_size_type) -1)
4332 ldsym->l_ifile = 0;
4333 else if (ldsym->l_ifile == 0)
4335 if ((ldsym->l_smtype & L_IMPORT) == 0)
4336 ldsym->l_ifile = 0;
4337 else
4339 bfd *impbfd;
4341 if (h->root.type == bfd_link_hash_defined
4342 || h->root.type == bfd_link_hash_defweak)
4343 impbfd = h->root.u.def.section->owner;
4344 else if (h->root.type == bfd_link_hash_undefined
4345 || h->root.type == bfd_link_hash_undefweak)
4346 impbfd = h->root.u.undef.abfd;
4347 else
4348 impbfd = NULL;
4350 if (impbfd == NULL)
4351 ldsym->l_ifile = 0;
4352 else
4354 BFD_ASSERT (impbfd->xvec == finfo->output_bfd->xvec);
4355 ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
4360 ldsym->l_parm = 0;
4362 BFD_ASSERT (h->ldindx >= 0);
4363 bfd_xcoff_swap_ldsym_out (finfo->output_bfd, ldsym,
4364 (finfo->ldsym
4365 + ((h->ldindx - 3)
4366 * bfd_xcoff_ldsymsz (finfo->output_bfd))));
4367 h->ldsym = NULL;
4369 /* Fill in snentry now that we know the target_index. */
4370 if ((h->flags & XCOFF_ENTRY) != 0
4371 && (h->root.type == bfd_link_hash_defined
4372 || h->root.type == bfd_link_hash_defweak))
4374 xcoff_data (output_bfd)->snentry =
4375 h->root.u.def.section->output_section->target_index;
4379 *indexp = -1;
4381 skip = FALSE;
4382 require = FALSE;
4383 add = 1 + isym.n_numaux;
4385 /* If we are skipping this csect, we want to skip this symbol. */
4386 if (*csectpp == NULL)
4387 skip = TRUE;
4389 /* If we garbage collected this csect, we want to skip this
4390 symbol. */
4391 if (! skip
4392 && xcoff_hash_table (finfo->info)->gc
4393 && ((*csectpp)->flags & SEC_MARK) == 0
4394 && *csectpp != bfd_abs_section_ptr)
4395 skip = TRUE;
4397 /* An XCOFF linker always skips C_STAT symbols. */
4398 if (! skip
4399 && isymp->n_sclass == C_STAT)
4400 skip = TRUE;
4402 /* We skip all but the first TOC anchor. */
4403 if (! skip
4404 && isymp->n_sclass == C_HIDEXT
4405 && aux.x_csect.x_smclas == XMC_TC0)
4407 if (finfo->toc_symindx != -1)
4408 skip = TRUE;
4409 else
4411 bfd_vma tocval, tocend;
4412 bfd *inp;
4414 tocval = ((*csectpp)->output_section->vma
4415 + (*csectpp)->output_offset
4416 + isym.n_value
4417 - (*csectpp)->vma);
4419 /* We want to find out if tocval is a good value to use
4420 as the TOC anchor--that is, whether we can access all
4421 of the TOC using a 16 bit offset from tocval. This
4422 test assumes that the TOC comes at the end of the
4423 output section, as it does in the default linker
4424 script. */
4425 tocend = ((*csectpp)->output_section->vma
4426 + (*csectpp)->output_section->_raw_size);
4427 for (inp = finfo->info->input_bfds;
4428 inp != NULL;
4429 inp = inp->link_next)
4432 for (o = inp->sections; o != NULL; o = o->next)
4433 if (strcmp (o->name, ".tocbss") == 0)
4435 bfd_vma new_toc_end;
4436 new_toc_end = (o->output_section->vma
4437 + o->output_offset
4438 + o->_cooked_size);
4439 if (new_toc_end > tocend)
4440 tocend = new_toc_end;
4445 if (tocval + 0x10000 < tocend)
4447 (*_bfd_error_handler)
4448 (_("TOC overflow: 0x%lx > 0x10000; try -mminimal-toc when compiling"),
4449 (unsigned long) (tocend - tocval));
4450 bfd_set_error (bfd_error_file_too_big);
4451 return FALSE;
4454 if (tocval + 0x8000 < tocend)
4456 bfd_vma tocadd;
4458 tocadd = tocend - (tocval + 0x8000);
4459 tocval += tocadd;
4460 isym.n_value += tocadd;
4463 finfo->toc_symindx = output_index;
4464 xcoff_data (finfo->output_bfd)->toc = tocval;
4465 xcoff_data (finfo->output_bfd)->sntoc =
4466 (*csectpp)->output_section->target_index;
4467 require = TRUE;
4472 /* If we are stripping all symbols, we want to skip this one. */
4473 if (! skip
4474 && finfo->info->strip == strip_all)
4475 skip = TRUE;
4477 /* We can skip resolved external references. */
4478 if (! skip
4479 && isym.n_sclass == C_EXT
4480 && smtyp == XTY_ER
4481 && (*sym_hash)->root.type != bfd_link_hash_undefined)
4482 skip = TRUE;
4484 /* We can skip common symbols if they got defined somewhere
4485 else. */
4486 if (! skip
4487 && isym.n_sclass == C_EXT
4488 && smtyp == XTY_CM
4489 && ((*sym_hash)->root.type != bfd_link_hash_common
4490 || (*sym_hash)->root.u.c.p->section != *csectpp)
4491 && ((*sym_hash)->root.type != bfd_link_hash_defined
4492 || (*sym_hash)->root.u.def.section != *csectpp))
4493 skip = TRUE;
4495 /* Skip local symbols if we are discarding them. */
4496 if (! skip
4497 && finfo->info->discard == discard_all
4498 && isym.n_sclass != C_EXT
4499 && (isym.n_sclass != C_HIDEXT
4500 || smtyp != XTY_SD))
4501 skip = TRUE;
4503 /* If we stripping debugging symbols, and this is a debugging
4504 symbol, then skip it. */
4505 if (! skip
4506 && finfo->info->strip == strip_debugger
4507 && isym.n_scnum == N_DEBUG)
4508 skip = TRUE;
4510 /* If some symbols are stripped based on the name, work out the
4511 name and decide whether to skip this symbol. We don't handle
4512 this correctly for symbols whose names are in the .debug
4513 section; to get it right we would need a new bfd_strtab_hash
4514 function to return the string given the index. */
4515 if (! skip
4516 && (finfo->info->strip == strip_some
4517 || finfo->info->discard == discard_l)
4518 && (debug_index == NULL || *debug_index == (unsigned long) -1))
4520 const char *name;
4521 char buf[SYMNMLEN + 1];
4523 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
4525 if (name == NULL)
4526 return FALSE;
4528 if ((finfo->info->strip == strip_some
4529 && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE,
4530 FALSE) == NULL))
4531 || (finfo->info->discard == discard_l
4532 && (isym.n_sclass != C_EXT
4533 && (isym.n_sclass != C_HIDEXT
4534 || smtyp != XTY_SD))
4535 && bfd_is_local_label_name (input_bfd, name)))
4536 skip = TRUE;
4539 /* We can not skip the first TOC anchor. */
4540 if (skip
4541 && require
4542 && finfo->info->strip != strip_all)
4543 skip = FALSE;
4545 /* We now know whether we are to skip this symbol or not. */
4546 if (! skip)
4548 /* Adjust the symbol in order to output it. */
4550 if (isym._n._n_n._n_zeroes == 0
4551 && isym._n._n_n._n_offset != 0)
4553 /* This symbol has a long name. Enter it in the string
4554 table we are building. If *debug_index != -1, the
4555 name has already been entered in the .debug section. */
4556 if (debug_index != NULL && *debug_index != (unsigned long) -1)
4557 isym._n._n_n._n_offset = *debug_index;
4558 else
4560 const char *name;
4561 bfd_size_type indx;
4563 name = _bfd_coff_internal_syment_name (input_bfd, &isym,
4564 (char *) NULL);
4566 if (name == NULL)
4567 return FALSE;
4568 indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
4569 if (indx == (bfd_size_type) -1)
4570 return FALSE;
4571 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
4575 if (isym.n_sclass != C_BSTAT
4576 && isym.n_sclass != C_ESTAT
4577 && isym.n_sclass != C_DECL
4578 && isym.n_scnum > 0)
4580 isym.n_scnum = (*csectpp)->output_section->target_index;
4581 isym.n_value += ((*csectpp)->output_section->vma
4582 + (*csectpp)->output_offset
4583 - (*csectpp)->vma);
4586 /* The value of a C_FILE symbol is the symbol index of the
4587 next C_FILE symbol. The value of the last C_FILE symbol
4588 is -1. We try to get this right, below, just before we
4589 write the symbols out, but in the general case we may
4590 have to write the symbol out twice. */
4591 if (isym.n_sclass == C_FILE)
4593 if (finfo->last_file_index != -1
4594 && finfo->last_file.n_value != (bfd_vma) output_index)
4596 /* We must correct the value of the last C_FILE entry. */
4597 finfo->last_file.n_value = output_index;
4598 if ((bfd_size_type) finfo->last_file_index >= syment_base)
4600 /* The last C_FILE symbol is in this input file. */
4601 bfd_coff_swap_sym_out (output_bfd,
4602 (PTR) &finfo->last_file,
4603 (PTR) (finfo->outsyms
4604 + ((finfo->last_file_index
4605 - syment_base)
4606 * osymesz)));
4608 else
4610 /* We have already written out the last C_FILE
4611 symbol. We need to write it out again. We
4612 borrow *outsym temporarily. */
4613 file_ptr pos;
4615 bfd_coff_swap_sym_out (output_bfd,
4616 (PTR) &finfo->last_file,
4617 (PTR) outsym);
4619 pos = obj_sym_filepos (output_bfd);
4620 pos += finfo->last_file_index * osymesz;
4621 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
4622 || (bfd_bwrite (outsym, osymesz, output_bfd)
4623 != osymesz))
4624 return FALSE;
4628 finfo->last_file_index = output_index;
4629 finfo->last_file = isym;
4632 /* The value of a C_BINCL or C_EINCL symbol is a file offset
4633 into the line numbers. We update the symbol values when
4634 we handle the line numbers. */
4635 if (isym.n_sclass == C_BINCL
4636 || isym.n_sclass == C_EINCL)
4638 isym.n_value = finfo->line_filepos;
4639 ++incls;
4642 /* Output the symbol. */
4644 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
4646 *indexp = output_index;
4648 if (isym.n_sclass == C_EXT)
4650 long indx;
4651 struct xcoff_link_hash_entry *h;
4653 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
4654 / isymesz);
4655 h = obj_xcoff_sym_hashes (input_bfd)[indx];
4656 BFD_ASSERT (h != NULL);
4657 h->indx = output_index;
4660 /* If this is a symbol in the TOC which we may have merged
4661 (class XMC_TC), remember the symbol index of the TOC
4662 symbol. */
4663 if (isym.n_sclass == C_HIDEXT
4664 && aux.x_csect.x_smclas == XMC_TC
4665 && *sym_hash != NULL)
4667 BFD_ASSERT (((*sym_hash)->flags & XCOFF_SET_TOC) == 0);
4668 BFD_ASSERT ((*sym_hash)->toc_section != NULL);
4669 (*sym_hash)->u.toc_indx = output_index;
4672 output_index += add;
4673 outsym += add * osymesz;
4676 esym += add * isymesz;
4677 isymp += add;
4678 csectpp += add;
4679 sym_hash += add;
4680 if (debug_index != NULL)
4681 debug_index += add;
4682 ++indexp;
4683 for (--add; add > 0; --add)
4684 *indexp++ = -1;
4687 /* Fix up the aux entries and the C_BSTAT symbols. This must be
4688 done in a separate pass, because we don't know the correct symbol
4689 indices until we have already decided which symbols we are going
4690 to keep. */
4692 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
4693 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
4694 isymp = finfo->internal_syms;
4695 indexp = finfo->sym_indices;
4696 csectpp = xcoff_data (input_bfd)->csects;
4697 outsym = finfo->outsyms;
4698 while (esym < esym_end)
4700 int add;
4702 add = 1 + isymp->n_numaux;
4704 if (*indexp < 0)
4705 esym += add * isymesz;
4706 else
4708 int i;
4710 if (isymp->n_sclass == C_BSTAT)
4712 struct internal_syment isym;
4714 bfd_vma indx;
4716 /* The value of a C_BSTAT symbol is the symbol table
4717 index of the containing csect. */
4718 bfd_coff_swap_sym_in (output_bfd, (PTR) outsym, (PTR) &isym);
4719 indx = isym.n_value;
4720 if (indx < obj_raw_syment_count (input_bfd))
4722 long symindx;
4724 symindx = finfo->sym_indices[indx];
4725 if (symindx < 0)
4726 isym.n_value = 0;
4727 else
4728 isym.n_value = symindx;
4729 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym,
4730 (PTR) outsym);
4734 esym += isymesz;
4735 outsym += osymesz;
4737 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
4739 union internal_auxent aux;
4741 bfd_coff_swap_aux_in (input_bfd, (PTR) esym, isymp->n_type,
4742 isymp->n_sclass, i, isymp->n_numaux,
4743 (PTR) &aux);
4745 if (isymp->n_sclass == C_FILE)
4747 /* This is the file name (or some comment put in by
4748 the compiler). If it is long, we must put it in
4749 the string table. */
4750 if (aux.x_file.x_n.x_zeroes == 0
4751 && aux.x_file.x_n.x_offset != 0)
4753 const char *filename;
4754 bfd_size_type indx;
4756 BFD_ASSERT (aux.x_file.x_n.x_offset
4757 >= STRING_SIZE_SIZE);
4758 if (strings == NULL)
4760 strings = _bfd_coff_read_string_table (input_bfd);
4761 if (strings == NULL)
4762 return FALSE;
4764 filename = strings + aux.x_file.x_n.x_offset;
4765 indx = _bfd_stringtab_add (finfo->strtab, filename,
4766 hash, copy);
4767 if (indx == (bfd_size_type) -1)
4768 return FALSE;
4769 aux.x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
4772 else if ((isymp->n_sclass == C_EXT
4773 || isymp->n_sclass == C_HIDEXT)
4774 && i + 1 == isymp->n_numaux)
4777 /* We don't support type checking. I don't know if
4778 anybody does. */
4779 aux.x_csect.x_parmhash = 0;
4780 /* I don't think anybody uses these fields, but we'd
4781 better clobber them just in case. */
4782 aux.x_csect.x_stab = 0;
4783 aux.x_csect.x_snstab = 0;
4785 if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_LD)
4787 unsigned long indx;
4789 indx = aux.x_csect.x_scnlen.l;
4790 if (indx < obj_raw_syment_count (input_bfd))
4792 long symindx;
4794 symindx = finfo->sym_indices[indx];
4795 if (symindx < 0)
4797 aux.x_csect.x_scnlen.l = 0;
4799 else
4801 aux.x_csect.x_scnlen.l = symindx;
4806 else if (isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
4808 unsigned long indx;
4810 if (ISFCN (isymp->n_type)
4811 || ISTAG (isymp->n_sclass)
4812 || isymp->n_sclass == C_BLOCK
4813 || isymp->n_sclass == C_FCN)
4815 indx = aux.x_sym.x_fcnary.x_fcn.x_endndx.l;
4816 if (indx > 0
4817 && indx < obj_raw_syment_count (input_bfd))
4819 /* We look forward through the symbol for
4820 the index of the next symbol we are going
4821 to include. I don't know if this is
4822 entirely right. */
4823 while (finfo->sym_indices[indx] < 0
4824 && indx < obj_raw_syment_count (input_bfd))
4825 ++indx;
4826 if (indx >= obj_raw_syment_count (input_bfd))
4827 indx = output_index;
4828 else
4829 indx = finfo->sym_indices[indx];
4830 aux.x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
4835 indx = aux.x_sym.x_tagndx.l;
4836 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
4838 long symindx;
4840 symindx = finfo->sym_indices[indx];
4841 if (symindx < 0)
4842 aux.x_sym.x_tagndx.l = 0;
4843 else
4844 aux.x_sym.x_tagndx.l = symindx;
4849 /* Copy over the line numbers, unless we are stripping
4850 them. We do this on a symbol by symbol basis in
4851 order to more easily handle garbage collection. */
4852 if ((isymp->n_sclass == C_EXT
4853 || isymp->n_sclass == C_HIDEXT)
4854 && i == 0
4855 && isymp->n_numaux > 1
4856 && ISFCN (isymp->n_type)
4857 && aux.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
4859 if (finfo->info->strip != strip_none
4860 && finfo->info->strip != strip_some)
4861 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
4862 else
4864 asection *enclosing;
4865 unsigned int enc_count;
4866 bfd_signed_vma linoff;
4867 struct internal_lineno lin;
4869 o = *csectpp;
4870 enclosing = xcoff_section_data (abfd, o)->enclosing;
4871 enc_count = xcoff_section_data (abfd, o)->lineno_count;
4872 if (oline != enclosing)
4874 file_ptr pos = enclosing->line_filepos;
4875 bfd_size_type amt = linesz * enc_count;
4876 if (bfd_seek (input_bfd, pos, SEEK_SET) != 0
4877 || (bfd_bread (finfo->linenos, amt, input_bfd)
4878 != amt))
4879 return FALSE;
4880 oline = enclosing;
4883 linoff = (aux.x_sym.x_fcnary.x_fcn.x_lnnoptr
4884 - enclosing->line_filepos);
4886 bfd_coff_swap_lineno_in (input_bfd,
4887 (PTR) (finfo->linenos + linoff),
4888 (PTR) &lin);
4889 if (lin.l_lnno != 0
4890 || ((bfd_size_type) lin.l_addr.l_symndx
4891 != ((esym
4892 - isymesz
4893 - ((bfd_byte *)
4894 obj_coff_external_syms (input_bfd)))
4895 / isymesz)))
4896 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
4897 else
4899 bfd_byte *linpend, *linp;
4900 bfd_vma offset;
4901 bfd_size_type count;
4903 lin.l_addr.l_symndx = *indexp;
4904 bfd_coff_swap_lineno_out (output_bfd, (PTR) &lin,
4905 (PTR) (finfo->linenos
4906 + linoff));
4908 linpend = (finfo->linenos
4909 + enc_count * linesz);
4910 offset = (o->output_section->vma
4911 + o->output_offset
4912 - o->vma);
4913 for (linp = finfo->linenos + linoff + linesz;
4914 linp < linpend;
4915 linp += linesz)
4917 bfd_coff_swap_lineno_in (input_bfd, (PTR) linp,
4918 (PTR) &lin);
4919 if (lin.l_lnno == 0)
4920 break;
4921 lin.l_addr.l_paddr += offset;
4922 bfd_coff_swap_lineno_out (output_bfd,
4923 (PTR) &lin,
4924 (PTR) linp);
4927 count = (linp - (finfo->linenos + linoff)) / linesz;
4929 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr =
4930 (o->output_section->line_filepos
4931 + o->output_section->lineno_count * linesz);
4933 if (bfd_seek (output_bfd,
4934 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr,
4935 SEEK_SET) != 0
4936 || (bfd_bwrite (finfo->linenos + linoff,
4937 linesz * count, output_bfd)
4938 != linesz * count))
4939 return FALSE;
4941 o->output_section->lineno_count += count;
4943 if (incls > 0)
4945 struct internal_syment *iisp, *iispend;
4946 long *iindp;
4947 bfd_byte *oos;
4948 int iiadd;
4950 /* Update any C_BINCL or C_EINCL symbols
4951 that refer to a line number in the
4952 range we just output. */
4953 iisp = finfo->internal_syms;
4954 iispend = (iisp
4955 + obj_raw_syment_count (input_bfd));
4956 iindp = finfo->sym_indices;
4957 oos = finfo->outsyms;
4958 while (iisp < iispend)
4960 if (*iindp >= 0
4961 && (iisp->n_sclass == C_BINCL
4962 || iisp->n_sclass == C_EINCL)
4963 && ((bfd_size_type) iisp->n_value
4964 >= (bfd_size_type)(enclosing->line_filepos + linoff))
4965 && ((bfd_size_type) iisp->n_value
4966 < (enclosing->line_filepos
4967 + enc_count * linesz)))
4969 struct internal_syment iis;
4971 bfd_coff_swap_sym_in (output_bfd,
4972 (PTR) oos,
4973 (PTR) &iis);
4974 iis.n_value =
4975 (iisp->n_value
4976 - enclosing->line_filepos
4977 - linoff
4978 + aux.x_sym.x_fcnary.x_fcn.x_lnnoptr);
4979 bfd_coff_swap_sym_out (output_bfd,
4980 (PTR) &iis,
4981 (PTR) oos);
4982 --incls;
4985 iiadd = 1 + iisp->n_numaux;
4986 if (*iindp >= 0)
4987 oos += iiadd * osymesz;
4988 iisp += iiadd;
4989 iindp += iiadd;
4996 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, isymp->n_type,
4997 isymp->n_sclass, i, isymp->n_numaux,
4998 (PTR) outsym);
4999 outsym += osymesz;
5000 esym += isymesz;
5004 indexp += add;
5005 isymp += add;
5006 csectpp += add;
5009 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
5010 symbol will be the first symbol in the next input file. In the
5011 normal case, this will save us from writing out the C_FILE symbol
5012 again. */
5013 if (finfo->last_file_index != -1
5014 && (bfd_size_type) finfo->last_file_index >= syment_base)
5016 finfo->last_file.n_value = output_index;
5017 bfd_coff_swap_sym_out (output_bfd, (PTR) &finfo->last_file,
5018 (PTR) (finfo->outsyms
5019 + ((finfo->last_file_index - syment_base)
5020 * osymesz)));
5023 /* Write the modified symbols to the output file. */
5024 if (outsym > finfo->outsyms)
5026 file_ptr pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
5027 bfd_size_type amt = outsym - finfo->outsyms;
5028 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
5029 || bfd_bwrite (finfo->outsyms, amt, output_bfd) != amt)
5030 return FALSE;
5032 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
5033 + (outsym - finfo->outsyms) / osymesz)
5034 == output_index);
5036 obj_raw_syment_count (output_bfd) = output_index;
5039 /* Don't let the linker relocation routines discard the symbols. */
5040 keep_syms = obj_coff_keep_syms (input_bfd);
5041 obj_coff_keep_syms (input_bfd) = TRUE;
5043 /* Relocate the contents of each section. */
5044 for (o = input_bfd->sections; o != NULL; o = o->next)
5047 bfd_byte *contents;
5049 if (! o->linker_mark)
5051 /* This section was omitted from the link. */
5052 continue;
5055 if ((o->flags & SEC_HAS_CONTENTS) == 0
5056 || o->_raw_size == 0
5057 || (o->flags & SEC_IN_MEMORY) != 0)
5058 continue;
5060 /* We have set filepos correctly for the sections we created to
5061 represent csects, so bfd_get_section_contents should work. */
5062 if (coff_section_data (input_bfd, o) != NULL
5063 && coff_section_data (input_bfd, o)->contents != NULL)
5064 contents = coff_section_data (input_bfd, o)->contents;
5065 else {
5066 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
5067 (file_ptr) 0, o->_raw_size))
5068 return FALSE;
5069 contents = finfo->contents;
5072 if ((o->flags & SEC_RELOC) != 0)
5074 int target_index;
5075 struct internal_reloc *internal_relocs;
5076 struct internal_reloc *irel;
5077 bfd_vma offset;
5078 struct internal_reloc *irelend;
5079 struct xcoff_link_hash_entry **rel_hash;
5080 long r_symndx;
5082 /* Read in the relocs. */
5083 target_index = o->output_section->target_index;
5084 internal_relocs = (xcoff_read_internal_relocs
5085 (input_bfd, o, FALSE, finfo->external_relocs,
5086 TRUE,
5087 (finfo->section_info[target_index].relocs
5088 + o->output_section->reloc_count)));
5089 if (internal_relocs == NULL)
5090 return FALSE;
5092 /* Call processor specific code to relocate the section
5093 contents. */
5094 if (! bfd_coff_relocate_section (output_bfd, finfo->info,
5095 input_bfd, o,
5096 contents,
5097 internal_relocs,
5098 finfo->internal_syms,
5099 xcoff_data (input_bfd)->csects))
5100 return FALSE;
5102 offset = o->output_section->vma + o->output_offset - o->vma;
5103 irel = internal_relocs;
5104 irelend = irel + o->reloc_count;
5105 rel_hash = (finfo->section_info[target_index].rel_hashes
5106 + o->output_section->reloc_count);
5107 for (; irel < irelend; irel++, rel_hash++)
5109 struct xcoff_link_hash_entry *h = NULL;
5110 struct internal_ldrel ldrel;
5111 bfd_boolean quiet;
5113 *rel_hash = NULL;
5115 /* Adjust the reloc address and symbol index. */
5117 irel->r_vaddr += offset;
5119 r_symndx = irel->r_symndx;
5121 if (r_symndx == -1)
5122 h = NULL;
5123 else
5124 h = obj_xcoff_sym_hashes (input_bfd)[r_symndx];
5126 if (r_symndx != -1 && finfo->info->strip != strip_all)
5128 if (h != NULL
5129 && h->smclas != XMC_TD
5130 && (irel->r_type == R_TOC
5131 || irel->r_type == R_GL
5132 || irel->r_type == R_TCL
5133 || irel->r_type == R_TRL
5134 || irel->r_type == R_TRLA))
5136 /* This is a TOC relative reloc with a symbol
5137 attached. The symbol should be the one which
5138 this reloc is for. We want to make this
5139 reloc against the TOC address of the symbol,
5140 not the symbol itself. */
5141 BFD_ASSERT (h->toc_section != NULL);
5142 BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
5143 if (h->u.toc_indx != -1)
5144 irel->r_symndx = h->u.toc_indx;
5145 else
5147 struct xcoff_toc_rel_hash *n;
5148 struct xcoff_link_section_info *si;
5149 bfd_size_type amt;
5151 amt = sizeof (struct xcoff_toc_rel_hash);
5152 n = ((struct xcoff_toc_rel_hash *)
5153 bfd_alloc (finfo->output_bfd, amt));
5154 if (n == NULL)
5155 return FALSE;
5156 si = finfo->section_info + target_index;
5157 n->next = si->toc_rel_hashes;
5158 n->h = h;
5159 n->rel = irel;
5160 si->toc_rel_hashes = n;
5163 else if (h != NULL)
5165 /* This is a global symbol. */
5166 if (h->indx >= 0)
5167 irel->r_symndx = h->indx;
5168 else
5170 /* This symbol is being written at the end
5171 of the file, and we do not yet know the
5172 symbol index. We save the pointer to the
5173 hash table entry in the rel_hash list.
5174 We set the indx field to -2 to indicate
5175 that this symbol must not be stripped. */
5176 *rel_hash = h;
5177 h->indx = -2;
5180 else
5182 long indx;
5184 indx = finfo->sym_indices[r_symndx];
5186 if (indx == -1)
5188 struct internal_syment *is;
5190 /* Relocations against a TC0 TOC anchor are
5191 automatically transformed to be against
5192 the TOC anchor in the output file. */
5193 is = finfo->internal_syms + r_symndx;
5194 if (is->n_sclass == C_HIDEXT
5195 && is->n_numaux > 0)
5197 PTR auxptr;
5198 union internal_auxent aux;
5200 auxptr = ((PTR)
5201 (((bfd_byte *)
5202 obj_coff_external_syms (input_bfd))
5203 + ((r_symndx + is->n_numaux)
5204 * isymesz)));
5205 bfd_coff_swap_aux_in (input_bfd, auxptr,
5206 is->n_type, is->n_sclass,
5207 is->n_numaux - 1,
5208 is->n_numaux,
5209 (PTR) &aux);
5210 if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_SD
5211 && aux.x_csect.x_smclas == XMC_TC0)
5212 indx = finfo->toc_symindx;
5216 if (indx != -1)
5217 irel->r_symndx = indx;
5218 else
5221 struct internal_syment *is;
5223 const char *name;
5224 char buf[SYMNMLEN + 1];
5226 /* This reloc is against a symbol we are
5227 stripping. It would be possible to handle
5228 this case, but I don't think it's worth it. */
5229 is = finfo->internal_syms + r_symndx;
5231 name = (_bfd_coff_internal_syment_name
5232 (input_bfd, is, buf));
5234 if (name == NULL)
5235 return FALSE;
5237 if (! ((*finfo->info->callbacks->unattached_reloc)
5238 (finfo->info, name, input_bfd, o,
5239 irel->r_vaddr)))
5240 return FALSE;
5245 quiet = FALSE;
5246 switch (irel->r_type)
5248 default:
5249 if (h == NULL
5250 || h->root.type == bfd_link_hash_defined
5251 || h->root.type == bfd_link_hash_defweak
5252 || h->root.type == bfd_link_hash_common)
5253 break;
5254 /* Fall through. */
5255 case R_POS:
5256 case R_NEG:
5257 case R_RL:
5258 case R_RLA:
5259 /* This reloc needs to be copied into the .loader
5260 section. */
5261 ldrel.l_vaddr = irel->r_vaddr;
5262 if (r_symndx == -1)
5263 ldrel.l_symndx = -(bfd_size_type ) 1;
5264 else if (h == NULL
5265 || (h->root.type == bfd_link_hash_defined
5266 || h->root.type == bfd_link_hash_defweak
5267 || h->root.type == bfd_link_hash_common))
5269 asection *sec;
5271 if (h == NULL)
5272 sec = xcoff_data (input_bfd)->csects[r_symndx];
5273 else if (h->root.type == bfd_link_hash_common)
5274 sec = h->root.u.c.p->section;
5275 else
5276 sec = h->root.u.def.section;
5277 sec = sec->output_section;
5279 if (strcmp (sec->name, ".text") == 0)
5280 ldrel.l_symndx = 0;
5281 else if (strcmp (sec->name, ".data") == 0)
5282 ldrel.l_symndx = 1;
5283 else if (strcmp (sec->name, ".bss") == 0)
5284 ldrel.l_symndx = 2;
5285 else
5287 (*_bfd_error_handler)
5288 (_("%s: loader reloc in unrecognized section `%s'"),
5289 bfd_archive_filename (input_bfd),
5290 sec->name);
5291 bfd_set_error (bfd_error_nonrepresentable_section);
5292 return FALSE;
5295 else
5297 if (! finfo->info->relocatable
5298 && (h->flags & XCOFF_DEF_DYNAMIC) == 0
5299 && (h->flags & XCOFF_IMPORT) == 0)
5301 /* We already called the undefined_symbol
5302 callback for this relocation, in
5303 _bfd_ppc_xcoff_relocate_section. Don't
5304 issue any more warnings. */
5305 quiet = TRUE;
5307 if (h->ldindx < 0 && ! quiet)
5309 (*_bfd_error_handler)
5310 (_("%s: `%s' in loader reloc but not loader sym"),
5311 bfd_archive_filename (input_bfd),
5312 h->root.root.string);
5313 bfd_set_error (bfd_error_bad_value);
5314 return FALSE;
5316 ldrel.l_symndx = h->ldindx;
5318 ldrel.l_rtype = (irel->r_size << 8) | irel->r_type;
5319 ldrel.l_rsecnm = o->output_section->target_index;
5320 if (xcoff_hash_table (finfo->info)->textro
5321 && strcmp (o->output_section->name, ".text") == 0
5322 && ! quiet)
5324 (*_bfd_error_handler)
5325 (_("%s: loader reloc in read-only section %s"),
5326 bfd_archive_filename (input_bfd),
5327 bfd_get_section_name (finfo->output_bfd,
5328 o->output_section));
5329 bfd_set_error (bfd_error_invalid_operation);
5330 return FALSE;
5332 bfd_xcoff_swap_ldrel_out (output_bfd, &ldrel,
5333 finfo->ldrel);
5335 finfo->ldrel += bfd_xcoff_ldrelsz(output_bfd);
5336 break;
5338 case R_TOC:
5339 case R_GL:
5340 case R_TCL:
5341 case R_TRL:
5342 case R_TRLA:
5343 /* We should never need a .loader reloc for a TOC
5344 relative reloc. */
5345 break;
5349 o->output_section->reloc_count += o->reloc_count;
5352 /* Write out the modified section contents. */
5353 if (! bfd_set_section_contents (output_bfd, o->output_section,
5354 contents, (file_ptr) o->output_offset,
5355 (o->_cooked_size != 0
5356 ? o->_cooked_size
5357 : o->_raw_size)))
5358 return FALSE;
5361 obj_coff_keep_syms (input_bfd) = keep_syms;
5363 if (! finfo->info->keep_memory)
5365 if (! _bfd_coff_free_symbols (input_bfd))
5366 return FALSE;
5369 return TRUE;
5372 #undef N_TMASK
5373 #undef N_BTSHFT
5375 /* Write out a non-XCOFF global symbol. */
5378 static bfd_boolean
5379 xcoff_write_global_symbol (h, inf)
5380 struct xcoff_link_hash_entry *h;
5381 PTR inf;
5383 struct xcoff_final_link_info *finfo = (struct xcoff_final_link_info *) inf;
5384 bfd *output_bfd;
5385 bfd_byte *outsym;
5386 struct internal_syment isym;
5387 union internal_auxent aux;
5388 bfd_boolean result;
5389 file_ptr pos;
5390 bfd_size_type amt;
5392 output_bfd = finfo->output_bfd;
5393 outsym = finfo->outsyms;
5395 if (h->root.type == bfd_link_hash_warning)
5397 h = (struct xcoff_link_hash_entry *) h->root.u.i.link;
5398 if (h->root.type == bfd_link_hash_new)
5399 return TRUE;
5402 /* If this symbol was garbage collected, just skip it. */
5403 if (xcoff_hash_table (finfo->info)->gc
5404 && (h->flags & XCOFF_MARK) == 0)
5405 return TRUE;
5407 /* If we need a .loader section entry, write it out. */
5408 if (h->ldsym != NULL)
5410 struct internal_ldsym *ldsym;
5411 bfd *impbfd;
5413 ldsym = h->ldsym;
5415 if (h->root.type == bfd_link_hash_undefined
5416 || h->root.type == bfd_link_hash_undefweak)
5419 ldsym->l_value = 0;
5420 ldsym->l_scnum = N_UNDEF;
5421 ldsym->l_smtype = XTY_ER;
5422 impbfd = h->root.u.undef.abfd;
5425 else if (h->root.type == bfd_link_hash_defined
5426 || h->root.type == bfd_link_hash_defweak)
5429 asection *sec;
5431 sec = h->root.u.def.section;
5432 ldsym->l_value = (sec->output_section->vma
5433 + sec->output_offset
5434 + h->root.u.def.value);
5435 ldsym->l_scnum = sec->output_section->target_index;
5436 ldsym->l_smtype = XTY_SD;
5437 impbfd = sec->owner;
5440 else
5441 abort ();
5443 if (((h->flags & XCOFF_DEF_REGULAR) == 0
5444 && (h->flags & XCOFF_DEF_DYNAMIC) != 0)
5445 || (h->flags & XCOFF_IMPORT) != 0)
5447 /* Clear l_smtype
5448 Import symbols are defined so the check above will make
5449 the l_smtype XTY_SD. But this is not correct, it should
5450 be cleared. */
5451 ldsym->l_smtype |= L_IMPORT;
5454 if (((h->flags & XCOFF_DEF_REGULAR) != 0
5455 && (h->flags & XCOFF_DEF_DYNAMIC) != 0)
5456 || (h->flags & XCOFF_EXPORT) != 0)
5458 ldsym->l_smtype |= L_EXPORT;
5461 if ((h->flags & XCOFF_ENTRY) != 0)
5463 ldsym->l_smtype |= L_ENTRY;
5466 if ((h->flags & XCOFF_RTINIT) != 0)
5468 ldsym->l_smtype = XTY_SD;
5471 ldsym->l_smclas = h->smclas;
5473 if (ldsym->l_smtype & L_IMPORT)
5475 if ((h->root.type == bfd_link_hash_defined
5476 || h->root.type == bfd_link_hash_defweak)
5477 && (h->root.u.def.value != 0))
5479 ldsym->l_smclas = XMC_XO;
5481 else if ((h->flags & (XCOFF_SYSCALL32 | XCOFF_SYSCALL64)) ==
5482 (XCOFF_SYSCALL32 | XCOFF_SYSCALL64))
5484 ldsym->l_smclas = XMC_SV3264;
5486 else if (h->flags & XCOFF_SYSCALL32)
5488 ldsym->l_smclas = XMC_SV;
5490 else if (h->flags & XCOFF_SYSCALL64)
5492 ldsym->l_smclas = XMC_SV64;
5496 if (ldsym->l_ifile == -(bfd_size_type) 1)
5498 ldsym->l_ifile = 0;
5500 else if (ldsym->l_ifile == 0)
5502 if ((ldsym->l_smtype & L_IMPORT) == 0)
5504 ldsym->l_ifile = 0;
5506 else if (impbfd == NULL)
5508 ldsym->l_ifile = 0;
5510 else
5512 BFD_ASSERT (impbfd->xvec == output_bfd->xvec);
5513 ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
5517 ldsym->l_parm = 0;
5519 BFD_ASSERT (h->ldindx >= 0);
5521 bfd_xcoff_swap_ldsym_out (output_bfd, ldsym,
5522 (finfo->ldsym +
5523 (h->ldindx - 3)
5524 * bfd_xcoff_ldsymsz(finfo->output_bfd)));
5525 h->ldsym = NULL;
5528 /* If this symbol needs global linkage code, write it out. */
5529 if (h->root.type == bfd_link_hash_defined
5530 && (h->root.u.def.section
5531 == xcoff_hash_table (finfo->info)->linkage_section))
5533 bfd_byte *p;
5534 bfd_vma tocoff;
5535 unsigned int i;
5537 p = h->root.u.def.section->contents + h->root.u.def.value;
5539 /* The first instruction in the global linkage code loads a
5540 specific TOC element. */
5541 tocoff = (h->descriptor->toc_section->output_section->vma
5542 + h->descriptor->toc_section->output_offset
5543 - xcoff_data (output_bfd)->toc);
5545 if ((h->descriptor->flags & XCOFF_SET_TOC) != 0)
5547 tocoff += h->descriptor->u.toc_offset;
5551 /* The first instruction in the glink code needs to be
5552 cooked to to hold the correct offset in the toc. The
5553 rest are just output raw. */
5554 bfd_put_32 (output_bfd,
5555 bfd_xcoff_glink_code(output_bfd, 0) | (tocoff & 0xffff), p);
5557 /* Start with i == 1 to get past the first instruction done above
5558 The /4 is because the glink code is in bytes and we are going
5559 4 at a pop. */
5560 for (i = 1; i < bfd_xcoff_glink_code_size(output_bfd) / 4; i++)
5562 bfd_put_32 (output_bfd,
5563 (bfd_vma) bfd_xcoff_glink_code(output_bfd, i),
5564 &p[4 * i]);
5568 /* If we created a TOC entry for this symbol, write out the required
5569 relocs. */
5570 if ((h->flags & XCOFF_SET_TOC) != 0)
5572 asection *tocsec;
5573 asection *osec;
5574 int oindx;
5575 struct internal_reloc *irel;
5576 struct internal_ldrel ldrel;
5577 struct internal_syment irsym;
5578 union internal_auxent iraux;
5580 tocsec = h->toc_section;
5581 osec = tocsec->output_section;
5582 oindx = osec->target_index;
5583 irel = finfo->section_info[oindx].relocs + osec->reloc_count;
5584 irel->r_vaddr = (osec->vma
5585 + tocsec->output_offset
5586 + h->u.toc_offset);
5589 if (h->indx >= 0)
5591 irel->r_symndx = h->indx;
5593 else
5595 h->indx = -2;
5596 irel->r_symndx = obj_raw_syment_count (output_bfd);
5599 BFD_ASSERT (h->ldindx >= 0);
5601 /* Initialize the aux union here instead of closer to when it is
5602 written out below because the length of the csect depends on
5603 whether the output is 32 or 64 bit. */
5604 memset (&iraux, 0, sizeof iraux);
5605 iraux.x_csect.x_smtyp = XTY_SD;
5606 /* iraux.x_csect.x_scnlen.l = 4 or 8, see below */
5607 iraux.x_csect.x_smclas = XMC_TC;
5609 /* 32 bit uses a 32 bit R_POS to do the relocations
5610 64 bit uses a 64 bit R_POS to do the relocations
5612 Also needs to change the csect size : 4 for 32 bit, 8 for 64 bit
5614 Which one is determined by the backend. */
5615 if (bfd_xcoff_is_xcoff64 (output_bfd))
5617 irel->r_size = 63;
5618 iraux.x_csect.x_scnlen.l = 8;
5620 else if (bfd_xcoff_is_xcoff32 (output_bfd))
5622 irel->r_size = 31;
5623 iraux.x_csect.x_scnlen.l = 4;
5625 else
5627 return FALSE;
5629 irel->r_type = R_POS;
5630 finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
5631 ++osec->reloc_count;
5633 ldrel.l_vaddr = irel->r_vaddr;
5634 ldrel.l_symndx = h->ldindx;
5635 ldrel.l_rtype = (irel->r_size << 8) | R_POS;
5636 ldrel.l_rsecnm = oindx;
5637 bfd_xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5638 finfo->ldrel += bfd_xcoff_ldrelsz(output_bfd);
5640 /* We need to emit a symbol to define a csect which holds
5641 the reloc. */
5642 if (finfo->info->strip != strip_all)
5645 result = bfd_xcoff_put_symbol_name (output_bfd, finfo->strtab,
5646 &irsym, h->root.root.string);
5647 if (!result)
5648 return FALSE;
5650 irsym.n_value = irel->r_vaddr;
5651 irsym.n_scnum = osec->target_index;
5652 irsym.n_sclass = C_HIDEXT;
5653 irsym.n_type = T_NULL;
5654 irsym.n_numaux = 1;
5656 bfd_coff_swap_sym_out (output_bfd, (PTR) &irsym, (PTR) outsym);
5657 outsym += bfd_coff_symesz (output_bfd);
5659 /* note : iraux is initialized above */
5660 bfd_coff_swap_aux_out (output_bfd, (PTR) &iraux, T_NULL, C_HIDEXT,
5661 0, 1, (PTR) outsym);
5662 outsym += bfd_coff_auxesz (output_bfd);
5664 if (h->indx >= 0)
5666 /* We aren't going to write out the symbols below, so we
5667 need to write them out now. */
5668 pos = obj_sym_filepos (output_bfd);
5669 pos += (obj_raw_syment_count (output_bfd)
5670 * bfd_coff_symesz (output_bfd));
5671 amt = outsym - finfo->outsyms;
5672 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
5673 || bfd_bwrite (finfo->outsyms, amt, output_bfd) != amt)
5674 return FALSE;
5675 obj_raw_syment_count (output_bfd) +=
5676 (outsym - finfo->outsyms) / bfd_coff_symesz (output_bfd);
5678 outsym = finfo->outsyms;
5683 /* If this symbol is a specially defined function descriptor, write
5684 it out. The first word is the address of the function code
5685 itself, the second word is the address of the TOC, and the third
5686 word is zero.
5688 32 bit vs 64 bit
5689 The addresses for the 32 bit will take 4 bytes and the addresses
5690 for 64 bit will take 8 bytes. Similar for the relocs. This type
5691 of logic was also done above to create a TOC entry in
5692 xcoff_write_global_symbol. */
5693 if ((h->flags & XCOFF_DESCRIPTOR) != 0
5694 && h->root.type == bfd_link_hash_defined
5695 && (h->root.u.def.section
5696 == xcoff_hash_table (finfo->info)->descriptor_section))
5698 asection *sec;
5699 asection *osec;
5700 int oindx;
5701 bfd_byte *p;
5702 struct xcoff_link_hash_entry *hentry;
5703 asection *esec;
5704 struct internal_reloc *irel;
5705 struct internal_ldrel ldrel;
5706 asection *tsec;
5707 unsigned int reloc_size, byte_size;
5709 if (bfd_xcoff_is_xcoff64 (output_bfd))
5711 reloc_size = 63;
5712 byte_size = 8;
5714 else if (bfd_xcoff_is_xcoff32 (output_bfd))
5716 reloc_size = 31;
5717 byte_size = 4;
5719 else
5721 return FALSE;
5724 sec = h->root.u.def.section;
5725 osec = sec->output_section;
5726 oindx = osec->target_index;
5727 p = sec->contents + h->root.u.def.value;
5729 hentry = h->descriptor;
5730 BFD_ASSERT (hentry != NULL
5731 && (hentry->root.type == bfd_link_hash_defined
5732 || hentry->root.type == bfd_link_hash_defweak));
5733 esec = hentry->root.u.def.section;
5735 irel = finfo->section_info[oindx].relocs + osec->reloc_count;
5736 irel->r_vaddr = (osec->vma
5737 + sec->output_offset
5738 + h->root.u.def.value);
5739 irel->r_symndx = esec->output_section->target_index;
5740 irel->r_type = R_POS;
5741 irel->r_size = reloc_size;
5742 finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
5743 ++osec->reloc_count;
5745 ldrel.l_vaddr = irel->r_vaddr;
5746 if (strcmp (esec->output_section->name, ".text") == 0)
5747 ldrel.l_symndx = 0;
5748 else if (strcmp (esec->output_section->name, ".data") == 0)
5749 ldrel.l_symndx = 1;
5750 else if (strcmp (esec->output_section->name, ".bss") == 0)
5751 ldrel.l_symndx = 2;
5752 else
5754 (*_bfd_error_handler)
5755 (_("%s: loader reloc in unrecognized section `%s'"),
5756 bfd_get_filename (output_bfd),
5757 esec->output_section->name);
5758 bfd_set_error (bfd_error_nonrepresentable_section);
5759 return FALSE;
5761 ldrel.l_rtype = (reloc_size << 8) | R_POS;
5762 ldrel.l_rsecnm = oindx;
5763 bfd_xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5764 finfo->ldrel += bfd_xcoff_ldrelsz(output_bfd);
5766 /* There are three items to write out,
5767 the address of the code
5768 the address of the toc anchor
5769 the environment pointer.
5770 We are ignoring the environment pointer. So set it to zero. */
5771 if (bfd_xcoff_is_xcoff64 (output_bfd))
5773 bfd_put_64 (output_bfd,
5774 (esec->output_section->vma + esec->output_offset
5775 + hentry->root.u.def.value),
5777 bfd_put_64 (output_bfd, xcoff_data (output_bfd)->toc, p + 8);
5778 bfd_put_64 (output_bfd, (bfd_vma) 0, p + 16);
5780 else
5782 /* 32 bit backend
5783 This logic was already called above so the error case where
5784 the backend is neither has already been checked. */
5785 bfd_put_32 (output_bfd,
5786 (esec->output_section->vma + esec->output_offset
5787 + hentry->root.u.def.value),
5789 bfd_put_32 (output_bfd, xcoff_data (output_bfd)->toc, p + 4);
5790 bfd_put_32 (output_bfd, (bfd_vma) 0, p + 8);
5793 tsec = coff_section_from_bfd_index (output_bfd,
5794 xcoff_data (output_bfd)->sntoc);
5796 ++irel;
5797 irel->r_vaddr = (osec->vma
5798 + sec->output_offset
5799 + h->root.u.def.value
5800 + byte_size);
5801 irel->r_symndx = tsec->output_section->target_index;
5802 irel->r_type = R_POS;
5803 irel->r_size = reloc_size;
5804 finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
5805 ++osec->reloc_count;
5807 ldrel.l_vaddr = irel->r_vaddr;
5808 if (strcmp (tsec->output_section->name, ".text") == 0)
5809 ldrel.l_symndx = 0;
5810 else if (strcmp (tsec->output_section->name, ".data") == 0)
5811 ldrel.l_symndx = 1;
5812 else if (strcmp (tsec->output_section->name, ".bss") == 0)
5813 ldrel.l_symndx = 2;
5814 else
5816 (*_bfd_error_handler)
5817 (_("%s: loader reloc in unrecognized section `%s'"),
5818 bfd_get_filename (output_bfd),
5819 tsec->output_section->name);
5820 bfd_set_error (bfd_error_nonrepresentable_section);
5821 return FALSE;
5823 ldrel.l_rtype = (reloc_size << 8) | R_POS;
5824 ldrel.l_rsecnm = oindx;
5825 bfd_xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5826 finfo->ldrel += bfd_xcoff_ldrelsz(output_bfd);
5829 if (h->indx >= 0 || finfo->info->strip == strip_all)
5831 BFD_ASSERT (outsym == finfo->outsyms);
5832 return TRUE;
5835 if (h->indx != -2
5836 && (finfo->info->strip == strip_all
5837 || (finfo->info->strip == strip_some
5838 && bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
5839 FALSE, FALSE) == NULL)))
5841 BFD_ASSERT (outsym == finfo->outsyms);
5842 return TRUE;
5845 if (h->indx != -2
5846 && (h->flags & (XCOFF_REF_REGULAR | XCOFF_DEF_REGULAR)) == 0)
5848 BFD_ASSERT (outsym == finfo->outsyms);
5849 return TRUE;
5852 memset (&aux, 0, sizeof aux);
5854 h->indx = obj_raw_syment_count (output_bfd);
5856 result = bfd_xcoff_put_symbol_name (output_bfd, finfo->strtab, &isym,
5857 h->root.root.string);
5858 if (!result)
5859 return FALSE;
5861 if (h->root.type == bfd_link_hash_undefined
5862 || h->root.type == bfd_link_hash_undefweak)
5864 isym.n_value = 0;
5865 isym.n_scnum = N_UNDEF;
5866 isym.n_sclass = C_EXT;
5867 aux.x_csect.x_smtyp = XTY_ER;
5869 else if ((h->root.type == bfd_link_hash_defined
5870 || h->root.type == bfd_link_hash_defweak)
5871 && h->smclas == XMC_XO)
5873 BFD_ASSERT (bfd_is_abs_section (h->root.u.def.section));
5874 isym.n_value = h->root.u.def.value;
5875 isym.n_scnum = N_UNDEF;
5876 isym.n_sclass = C_EXT;
5877 aux.x_csect.x_smtyp = XTY_ER;
5879 else if (h->root.type == bfd_link_hash_defined
5880 || h->root.type == bfd_link_hash_defweak)
5882 struct xcoff_link_size_list *l;
5884 isym.n_value = (h->root.u.def.section->output_section->vma
5885 + h->root.u.def.section->output_offset
5886 + h->root.u.def.value);
5887 if (bfd_is_abs_section (h->root.u.def.section->output_section))
5888 isym.n_scnum = N_ABS;
5889 else
5890 isym.n_scnum = h->root.u.def.section->output_section->target_index;
5891 isym.n_sclass = C_HIDEXT;
5892 aux.x_csect.x_smtyp = XTY_SD;
5894 if ((h->flags & XCOFF_HAS_SIZE) != 0)
5896 for (l = xcoff_hash_table (finfo->info)->size_list;
5897 l != NULL;
5898 l = l->next)
5900 if (l->h == h)
5902 aux.x_csect.x_scnlen.l = l->size;
5903 break;
5908 else if (h->root.type == bfd_link_hash_common)
5910 isym.n_value = (h->root.u.c.p->section->output_section->vma
5911 + h->root.u.c.p->section->output_offset);
5912 isym.n_scnum = h->root.u.c.p->section->output_section->target_index;
5913 isym.n_sclass = C_EXT;
5914 aux.x_csect.x_smtyp = XTY_CM;
5915 aux.x_csect.x_scnlen.l = h->root.u.c.size;
5917 else
5918 abort ();
5920 isym.n_type = T_NULL;
5921 isym.n_numaux = 1;
5923 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
5924 outsym += bfd_coff_symesz (output_bfd);
5926 aux.x_csect.x_smclas = h->smclas;
5927 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, isym.n_sclass, 0, 1,
5928 (PTR) outsym);
5929 outsym += bfd_coff_auxesz (output_bfd);
5931 if ((h->root.type == bfd_link_hash_defined
5932 || h->root.type == bfd_link_hash_defweak)
5933 && h->smclas != XMC_XO)
5935 /* We just output an SD symbol. Now output an LD symbol. */
5937 h->indx += 2;
5939 isym.n_sclass = C_EXT;
5940 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
5941 outsym += bfd_coff_symesz (output_bfd);
5943 aux.x_csect.x_smtyp = XTY_LD;
5944 aux.x_csect.x_scnlen.l = obj_raw_syment_count (output_bfd);
5945 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, C_EXT, 0, 1,
5946 (PTR) outsym);
5947 outsym += bfd_coff_auxesz (output_bfd);
5950 pos = obj_sym_filepos (output_bfd);
5951 pos += obj_raw_syment_count (output_bfd) * bfd_coff_symesz (output_bfd);
5952 amt = outsym - finfo->outsyms;
5953 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
5954 || bfd_bwrite (finfo->outsyms, amt, output_bfd) != amt)
5955 return FALSE;
5956 obj_raw_syment_count (output_bfd) +=
5957 (outsym - finfo->outsyms) / bfd_coff_symesz (output_bfd);
5959 return TRUE;
5962 /* Handle a link order which is supposed to generate a reloc. */
5964 static bfd_boolean
5965 xcoff_reloc_link_order (output_bfd, finfo, output_section, link_order)
5966 bfd *output_bfd;
5967 struct xcoff_final_link_info *finfo;
5968 asection *output_section;
5969 struct bfd_link_order *link_order;
5971 reloc_howto_type *howto;
5972 struct xcoff_link_hash_entry *h;
5973 asection *hsec;
5974 bfd_vma hval;
5975 bfd_vma addend;
5976 struct internal_reloc *irel;
5977 struct xcoff_link_hash_entry **rel_hash_ptr;
5978 struct internal_ldrel ldrel;
5980 if (link_order->type == bfd_section_reloc_link_order)
5982 /* We need to somehow locate a symbol in the right section. The
5983 symbol must either have a value of zero, or we must adjust
5984 the addend by the value of the symbol. FIXME: Write this
5985 when we need it. The old linker couldn't handle this anyhow. */
5986 abort ();
5989 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
5990 if (howto == NULL)
5992 bfd_set_error (bfd_error_bad_value);
5993 return FALSE;
5996 h = ((struct xcoff_link_hash_entry *)
5997 bfd_wrapped_link_hash_lookup (output_bfd, finfo->info,
5998 link_order->u.reloc.p->u.name,
5999 FALSE, FALSE, TRUE));
6000 if (h == NULL)
6002 if (! ((*finfo->info->callbacks->unattached_reloc)
6003 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
6004 (asection *) NULL, (bfd_vma) 0)))
6005 return FALSE;
6006 return TRUE;
6009 if (h->root.type == bfd_link_hash_common)
6011 hsec = h->root.u.c.p->section;
6012 hval = 0;
6014 else if (h->root.type == bfd_link_hash_defined
6015 || h->root.type == bfd_link_hash_defweak)
6017 hsec = h->root.u.def.section;
6018 hval = h->root.u.def.value;
6020 else
6022 hsec = NULL;
6023 hval = 0;
6026 addend = link_order->u.reloc.p->addend;
6027 if (hsec != NULL)
6028 addend += (hsec->output_section->vma
6029 + hsec->output_offset
6030 + hval);
6032 if (addend != 0)
6034 bfd_size_type size;
6035 bfd_byte *buf;
6036 bfd_reloc_status_type rstat;
6037 bfd_boolean ok;
6039 size = bfd_get_reloc_size (howto);
6040 buf = (bfd_byte *) bfd_zmalloc (size);
6041 if (buf == NULL)
6042 return FALSE;
6044 rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
6045 switch (rstat)
6047 case bfd_reloc_ok:
6048 break;
6049 default:
6050 case bfd_reloc_outofrange:
6051 abort ();
6052 case bfd_reloc_overflow:
6053 if (! ((*finfo->info->callbacks->reloc_overflow)
6054 (finfo->info, link_order->u.reloc.p->u.name,
6055 howto->name, addend, (bfd *) NULL, (asection *) NULL,
6056 (bfd_vma) 0)))
6058 free (buf);
6059 return FALSE;
6061 break;
6063 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
6064 (file_ptr) link_order->offset, size);
6065 free (buf);
6066 if (! ok)
6067 return FALSE;
6070 /* Store the reloc information in the right place. It will get
6071 swapped and written out at the end of the final_link routine. */
6073 irel = (finfo->section_info[output_section->target_index].relocs
6074 + output_section->reloc_count);
6075 rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
6076 + output_section->reloc_count);
6078 memset (irel, 0, sizeof (struct internal_reloc));
6079 *rel_hash_ptr = NULL;
6081 irel->r_vaddr = output_section->vma + link_order->offset;
6083 if (h->indx >= 0)
6084 irel->r_symndx = h->indx;
6085 else
6087 /* Set the index to -2 to force this symbol to get written out. */
6088 h->indx = -2;
6089 *rel_hash_ptr = h;
6090 irel->r_symndx = 0;
6093 irel->r_type = howto->type;
6094 irel->r_size = howto->bitsize - 1;
6095 if (howto->complain_on_overflow == complain_overflow_signed)
6096 irel->r_size |= 0x80;
6098 ++output_section->reloc_count;
6100 /* Now output the reloc to the .loader section. */
6102 ldrel.l_vaddr = irel->r_vaddr;
6104 if (hsec != NULL)
6106 const char *secname;
6108 secname = hsec->output_section->name;
6110 if (strcmp (secname, ".text") == 0)
6111 ldrel.l_symndx = 0;
6112 else if (strcmp (secname, ".data") == 0)
6113 ldrel.l_symndx = 1;
6114 else if (strcmp (secname, ".bss") == 0)
6115 ldrel.l_symndx = 2;
6116 else
6118 (*_bfd_error_handler)
6119 (_("%s: loader reloc in unrecognized section `%s'"),
6120 bfd_get_filename (output_bfd), secname);
6121 bfd_set_error (bfd_error_nonrepresentable_section);
6122 return FALSE;
6125 else
6127 if (h->ldindx < 0)
6129 (*_bfd_error_handler)
6130 (_("%s: `%s' in loader reloc but not loader sym"),
6131 bfd_get_filename (output_bfd),
6132 h->root.root.string);
6133 bfd_set_error (bfd_error_bad_value);
6134 return FALSE;
6136 ldrel.l_symndx = h->ldindx;
6139 ldrel.l_rtype = (irel->r_size << 8) | irel->r_type;
6140 ldrel.l_rsecnm = output_section->target_index;
6141 bfd_xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
6142 finfo->ldrel += bfd_xcoff_ldrelsz(output_bfd);
6144 return TRUE;
6147 /* Sort relocs by VMA. This is called via qsort. */
6149 static int
6150 xcoff_sort_relocs (p1, p2)
6151 const PTR p1;
6152 const PTR p2;
6154 const struct internal_reloc *r1 = (const struct internal_reloc *) p1;
6155 const struct internal_reloc *r2 = (const struct internal_reloc *) p2;
6157 if (r1->r_vaddr > r2->r_vaddr)
6158 return 1;
6159 else if (r1->r_vaddr < r2->r_vaddr)
6160 return -1;
6161 else
6162 return 0;