1
/* POWER/PowerPC XCOFF linker support.
2
Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
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. */
26
#include "coff/internal.h"
27
#include "coff/xcoff.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;
50
/* The member name. */
54
/* Information we keep for each section in the output file during the
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;
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;
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). */
90
/* Contents of last C_FILE symbol. */
91
struct internal_syment last_file;
92
/* Symbol index of TOC symbol. */
94
/* Start of .loader symbols. */
96
/* Next .loader reloc to swap out. */
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
105
/* Buffer large enough to hold output symbols for any input file. */
107
/* Buffer large enough to hold external line numbers for any input
110
/* Buffer large enough to hold any input section. */
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 boolean xcoff_get_section_contents PARAMS ((bfd *, asection *));
119
static struct internal_reloc *xcoff_read_internal_relocs
120
PARAMS ((bfd *, asection *, boolean, bfd_byte *, boolean,
121
struct internal_reloc *));
122
static boolean xcoff_link_add_object_symbols
123
PARAMS ((bfd *, struct bfd_link_info *));
124
static boolean xcoff_link_check_archive_element
125
PARAMS ((bfd *, struct bfd_link_info *, boolean *));
126
static boolean xcoff_link_check_ar_symbols
127
PARAMS ((bfd *, struct bfd_link_info *, boolean *));
128
static boolean xcoff_link_check_dynamic_ar_symbols
129
PARAMS ((bfd *, struct bfd_link_info *, boolean *));
130
static bfd_size_type xcoff_find_reloc
131
PARAMS ((struct internal_reloc *, bfd_size_type, bfd_vma));
132
static boolean xcoff_link_add_symbols PARAMS ((bfd *, struct bfd_link_info *));
133
static boolean xcoff_link_add_dynamic_symbols
134
PARAMS ((bfd *, struct bfd_link_info *));
135
static boolean xcoff_mark_symbol
136
PARAMS ((struct bfd_link_info *, struct xcoff_link_hash_entry *));
137
static boolean xcoff_mark PARAMS ((struct bfd_link_info *, asection *));
138
static void xcoff_sweep PARAMS ((struct bfd_link_info *));
139
static boolean xcoff_build_ldsyms
140
PARAMS ((struct xcoff_link_hash_entry *, PTR));
141
static boolean xcoff_link_input_bfd
142
PARAMS ((struct xcoff_final_link_info *, bfd *));
143
static boolean xcoff_write_global_symbol
144
PARAMS ((struct xcoff_link_hash_entry *, PTR));
145
static boolean xcoff_reloc_link_order
146
PARAMS ((bfd *, struct xcoff_final_link_info *, asection *,
147
struct bfd_link_order *));
148
static int xcoff_sort_relocs PARAMS ((const PTR, const PTR));
151
/* Routines to read XCOFF dynamic information. This don't really
152
belong here, but we already have the ldsym manipulation routines
155
/* Read the contents of a section. */
158
xcoff_get_section_contents (abfd, sec)
163
if (coff_section_data (abfd, sec) == NULL)
165
bfd_size_type amt = sizeof (struct coff_section_tdata);
166
sec->used_by_bfd = bfd_zalloc (abfd, amt);
167
if (sec->used_by_bfd == NULL)
171
if (coff_section_data (abfd, sec)->contents == NULL)
173
coff_section_data (abfd, sec)->contents = ((bfd_byte *)
174
bfd_malloc (sec->_raw_size));
175
if (coff_section_data (abfd, sec)->contents == NULL)
178
if (! bfd_get_section_contents (abfd, sec,
179
coff_section_data (abfd, sec)->contents,
180
(file_ptr) 0, sec->_raw_size))
187
/* Get the size required to hold the dynamic symbols. */
190
_bfd_xcoff_get_dynamic_symtab_upper_bound (abfd)
195
struct internal_ldhdr ldhdr;
197
if ((abfd->flags & DYNAMIC) == 0)
199
bfd_set_error (bfd_error_invalid_operation);
203
lsec = bfd_get_section_by_name (abfd, ".loader");
206
bfd_set_error (bfd_error_no_symbols);
210
if (! xcoff_get_section_contents (abfd, lsec))
212
contents = coff_section_data (abfd, lsec)->contents;
214
bfd_xcoff_swap_ldhdr_in (abfd, (PTR) contents, &ldhdr);
216
return (ldhdr.l_nsyms + 1) * sizeof (asymbol *);
219
/* Get the dynamic symbols. */
222
_bfd_xcoff_canonicalize_dynamic_symtab (abfd, psyms)
228
struct internal_ldhdr ldhdr;
230
bfd_byte *elsym, *elsymend;
231
coff_symbol_type *symbuf;
233
if ((abfd->flags & DYNAMIC) == 0)
235
bfd_set_error (bfd_error_invalid_operation);
239
lsec = bfd_get_section_by_name (abfd, ".loader");
242
bfd_set_error (bfd_error_no_symbols);
246
if (! xcoff_get_section_contents (abfd, lsec))
248
contents = coff_section_data (abfd, lsec)->contents;
250
coff_section_data (abfd, lsec)->keep_contents = true;
252
bfd_xcoff_swap_ldhdr_in (abfd, contents, &ldhdr);
254
strings = (char *) contents + ldhdr.l_stoff;
256
symbuf = ((coff_symbol_type *)
257
bfd_zalloc (abfd, ldhdr.l_nsyms * sizeof (coff_symbol_type)));
261
elsym = contents + bfd_xcoff_loader_symbol_offset(abfd, &ldhdr);
263
elsymend = elsym + ldhdr.l_nsyms * bfd_xcoff_ldsymsz(abfd);
264
for (; elsym < elsymend; elsym += bfd_xcoff_ldsymsz(abfd), symbuf++, psyms++)
266
struct internal_ldsym ldsym;
268
bfd_xcoff_swap_ldsym_in (abfd, elsym, &ldsym);
270
symbuf->symbol.the_bfd = abfd;
272
if (ldsym._l._l_l._l_zeroes == 0)
273
symbuf->symbol.name = strings + ldsym._l._l_l._l_offset;
278
c = bfd_alloc (abfd, (bfd_size_type) SYMNMLEN + 1);
281
memcpy (c, ldsym._l._l_name, SYMNMLEN);
283
symbuf->symbol.name = c;
286
if (ldsym.l_smclas == XMC_XO)
287
symbuf->symbol.section = bfd_abs_section_ptr;
289
symbuf->symbol.section = coff_section_from_bfd_index (abfd,
291
symbuf->symbol.value = ldsym.l_value - symbuf->symbol.section->vma;
293
symbuf->symbol.flags = BSF_NO_FLAGS;
294
if ((ldsym.l_smtype & L_EXPORT) != 0)
295
symbuf->symbol.flags |= BSF_GLOBAL;
297
/* FIXME: We have no way to record the other information stored
298
with the loader symbol. */
300
*psyms = (asymbol *) symbuf;
305
return ldhdr.l_nsyms;
308
/* Get the size required to hold the dynamic relocs. */
311
_bfd_xcoff_get_dynamic_reloc_upper_bound (abfd)
316
struct internal_ldhdr ldhdr;
318
if ((abfd->flags & DYNAMIC) == 0)
320
bfd_set_error (bfd_error_invalid_operation);
324
lsec = bfd_get_section_by_name (abfd, ".loader");
327
bfd_set_error (bfd_error_no_symbols);
331
if (! xcoff_get_section_contents (abfd, lsec))
333
contents = coff_section_data (abfd, lsec)->contents;
335
bfd_xcoff_swap_ldhdr_in (abfd, (struct external_ldhdr *) contents, &ldhdr);
337
return (ldhdr.l_nreloc + 1) * sizeof (arelent *);
340
/* Get the dynamic relocs. */
343
_bfd_xcoff_canonicalize_dynamic_reloc (abfd, prelocs, syms)
350
struct internal_ldhdr ldhdr;
352
bfd_byte *elrel, *elrelend;
354
if ((abfd->flags & DYNAMIC) == 0)
356
bfd_set_error (bfd_error_invalid_operation);
360
lsec = bfd_get_section_by_name (abfd, ".loader");
363
bfd_set_error (bfd_error_no_symbols);
367
if (! xcoff_get_section_contents (abfd, lsec))
369
contents = coff_section_data (abfd, lsec)->contents;
371
bfd_xcoff_swap_ldhdr_in (abfd, contents, &ldhdr);
373
relbuf = (arelent *) bfd_alloc (abfd, ldhdr.l_nreloc * sizeof (arelent));
377
elrel = contents + bfd_xcoff_loader_reloc_offset(abfd, &ldhdr);
379
elrelend = elrel + ldhdr.l_nreloc * bfd_xcoff_ldrelsz(abfd);
380
for (; elrel < elrelend; elrel += bfd_xcoff_ldrelsz(abfd), relbuf++,
383
struct internal_ldrel ldrel;
385
bfd_xcoff_swap_ldrel_in (abfd, elrel, &ldrel);
387
if (ldrel.l_symndx >= 3)
388
relbuf->sym_ptr_ptr = syms + (ldrel.l_symndx - 3);
394
switch (ldrel.l_symndx)
410
sec = bfd_get_section_by_name (abfd, name);
413
bfd_set_error (bfd_error_bad_value);
417
relbuf->sym_ptr_ptr = sec->symbol_ptr_ptr;
420
relbuf->address = ldrel.l_vaddr;
423
/* Most dynamic relocs have the same type. FIXME: This is only
424
correct if ldrel.l_rtype == 0. In other cases, we should use
425
a different howto. */
426
relbuf->howto = bfd_xcoff_dynamic_reloc_howto(abfd);
428
/* FIXME: We have no way to record the l_rsecnm field. */
435
return ldhdr.l_nreloc;
438
/* Routine to create an entry in an XCOFF link hash table. */
440
static struct bfd_hash_entry *
441
xcoff_link_hash_newfunc (entry, table, string)
442
struct bfd_hash_entry *entry;
443
struct bfd_hash_table *table;
446
struct xcoff_link_hash_entry *ret = (struct xcoff_link_hash_entry *) entry;
448
/* Allocate the structure if it has not already been allocated by a
450
if (ret == (struct xcoff_link_hash_entry *) NULL)
451
ret = ((struct xcoff_link_hash_entry *)
452
bfd_hash_allocate (table, sizeof (struct xcoff_link_hash_entry)));
453
if (ret == (struct xcoff_link_hash_entry *) NULL)
454
return (struct bfd_hash_entry *) ret;
456
/* Call the allocation method of the superclass. */
457
ret = ((struct xcoff_link_hash_entry *)
458
_bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
462
/* Set local fields. */
464
ret->toc_section = NULL;
465
ret->u.toc_indx = -1;
466
ret->descriptor = NULL;
470
ret->smclas = XMC_UA;
473
return (struct bfd_hash_entry *) ret;
476
/* Create a XCOFF link hash table. */
478
struct bfd_link_hash_table *
479
_bfd_xcoff_bfd_link_hash_table_create (abfd)
482
struct xcoff_link_hash_table *ret;
483
bfd_size_type amt = sizeof (struct xcoff_link_hash_table);
485
ret = (struct xcoff_link_hash_table *) bfd_malloc (amt);
486
if (ret == (struct xcoff_link_hash_table *) NULL)
487
return (struct bfd_link_hash_table *) NULL;
488
if (! _bfd_link_hash_table_init (&ret->root, abfd, xcoff_link_hash_newfunc))
491
return (struct bfd_link_hash_table *) NULL;
494
ret->debug_strtab = _bfd_xcoff_stringtab_init ();
495
ret->debug_section = NULL;
496
ret->loader_section = NULL;
497
ret->ldrel_count = 0;
498
memset (&ret->ldhdr, 0, sizeof (struct internal_ldhdr));
499
ret->linkage_section = NULL;
500
ret->toc_section = NULL;
501
ret->descriptor_section = NULL;
506
memset (ret->special_sections, 0, sizeof ret->special_sections);
508
/* The linker will always generate a full a.out header. We need to
509
record that fact now, before the sizeof_headers routine could be
511
xcoff_data (abfd)->full_aouthdr = true;
516
/* Free a XCOFF link hash table. */
519
_bfd_xcoff_bfd_link_hash_table_free (hash)
520
struct bfd_link_hash_table *hash;
522
struct xcoff_link_hash_table *ret = (struct xcoff_link_hash_table *) hash;
524
_bfd_stringtab_free (ret->debug_strtab);
525
bfd_hash_table_free (&ret->root.table);
529
/* Read internal relocs for an XCOFF csect. This is a wrapper around
530
_bfd_coff_read_internal_relocs which tries to take advantage of any
531
relocs which may have been cached for the enclosing section. */
533
static struct internal_reloc *
534
xcoff_read_internal_relocs (abfd, sec, cache, external_relocs,
535
require_internal, internal_relocs)
539
bfd_byte *external_relocs;
540
boolean require_internal;
541
struct internal_reloc *internal_relocs;
544
if (coff_section_data (abfd, sec) != NULL
545
&& coff_section_data (abfd, sec)->relocs == NULL
546
&& xcoff_section_data (abfd, sec) != NULL)
550
enclosing = xcoff_section_data (abfd, sec)->enclosing;
552
if (enclosing != NULL
553
&& (coff_section_data (abfd, enclosing) == NULL
554
|| coff_section_data (abfd, enclosing)->relocs == NULL)
556
&& enclosing->reloc_count > 0)
558
if (_bfd_coff_read_internal_relocs (abfd, enclosing, true,
559
external_relocs, false,
560
(struct internal_reloc *) NULL)
565
if (enclosing != NULL
566
&& coff_section_data (abfd, enclosing) != NULL
567
&& coff_section_data (abfd, enclosing)->relocs != NULL)
571
off = ((sec->rel_filepos - enclosing->rel_filepos)
572
/ bfd_coff_relsz (abfd));
574
if (! require_internal)
575
return coff_section_data (abfd, enclosing)->relocs + off;
576
memcpy (internal_relocs,
577
coff_section_data (abfd, enclosing)->relocs + off,
578
sec->reloc_count * sizeof (struct internal_reloc));
579
return internal_relocs;
583
return _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
584
require_internal, internal_relocs);
587
/* Given an XCOFF BFD, add symbols to the global hash table as
591
_bfd_xcoff_bfd_link_add_symbols (abfd, info)
593
struct bfd_link_info *info;
596
switch (bfd_get_format (abfd))
599
return xcoff_link_add_object_symbols (abfd, info);
602
/* If the archive has a map, do the usual search. We then need
603
to check the archive for dynamic objects, because they may not
604
appear in the archive map even though they should, perhaps, be
605
included. If the archive has no map, we just consider each object
606
file in turn, since that apparently is what the AIX native linker
608
if (bfd_has_map (abfd))
610
if (! (_bfd_generic_link_add_archive_symbols
611
(abfd, info, xcoff_link_check_archive_element)))
618
member = bfd_openr_next_archived_file (abfd, (bfd *) NULL);
619
while (member != NULL)
621
if (bfd_check_format (member, bfd_object)
622
&& (info->hash->creator == member->xvec)
623
&& (! bfd_has_map (abfd) || (member->flags & DYNAMIC) != 0))
627
if (! xcoff_link_check_archive_element (member, info,
631
member->archive_pass = -1;
633
member = bfd_openr_next_archived_file (abfd, member);
640
bfd_set_error (bfd_error_wrong_format);
645
/* Add symbols from an XCOFF object file. */
648
xcoff_link_add_object_symbols (abfd, info)
650
struct bfd_link_info *info;
653
if (! _bfd_coff_get_external_symbols (abfd))
655
if (! xcoff_link_add_symbols (abfd, info))
657
if (! info->keep_memory)
659
if (! _bfd_coff_free_symbols (abfd))
665
/* Check a single archive element to see if we need to include it in
666
the link. *PNEEDED is set according to whether this element is
667
needed in the link or not. This is called via
668
_bfd_generic_link_add_archive_symbols. */
671
xcoff_link_check_archive_element (abfd, info, pneeded)
673
struct bfd_link_info *info;
677
if (! _bfd_coff_get_external_symbols (abfd))
680
if (! xcoff_link_check_ar_symbols (abfd, info, pneeded))
685
if (! xcoff_link_add_symbols (abfd, info))
689
if (! info->keep_memory || ! *pneeded)
691
if (! _bfd_coff_free_symbols (abfd))
698
/* Look through the symbols to see if this object file should be
699
included in the link. */
702
xcoff_link_check_ar_symbols (abfd, info, pneeded)
704
struct bfd_link_info *info;
707
bfd_size_type symesz;
713
if ((abfd->flags & DYNAMIC) != 0
714
&& ! info->static_link
715
&& info->hash->creator == abfd->xvec)
716
return xcoff_link_check_dynamic_ar_symbols (abfd, info, pneeded);
718
symesz = bfd_coff_symesz (abfd);
719
esym = (bfd_byte *) obj_coff_external_syms (abfd);
720
esym_end = esym + obj_raw_syment_count (abfd) * symesz;
721
while (esym < esym_end)
723
struct internal_syment sym;
725
bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
727
if (sym.n_sclass == C_EXT && sym.n_scnum != N_UNDEF)
730
char buf[SYMNMLEN + 1];
731
struct bfd_link_hash_entry *h;
733
/* This symbol is externally visible, and is defined by this
736
name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
740
h = bfd_link_hash_lookup (info->hash, name, false, false, true);
742
/* We are only interested in symbols that are currently
743
undefined. If a symbol is currently known to be common,
744
XCOFF linkers do not bring in an object file which
745
defines it. We also don't bring in symbols to satisfy
746
undefined references in shared objects. */
747
if (h != (struct bfd_link_hash_entry *) NULL
748
&& h->type == bfd_link_hash_undefined
749
&& (info->hash->creator != abfd->xvec
750
|| (((struct xcoff_link_hash_entry *) h)->flags
751
& XCOFF_DEF_DYNAMIC) == 0))
753
if (! (*info->callbacks->add_archive_element) (info, abfd, name))
760
esym += (sym.n_numaux + 1) * symesz;
763
/* We do not need this object file. */
767
/* Look through the loader symbols to see if this dynamic object
768
should be included in the link. The native linker uses the loader
769
symbols, not the normal symbol table, so we do too. */
772
xcoff_link_check_dynamic_ar_symbols (abfd, info, pneeded)
774
struct bfd_link_info *info;
779
struct internal_ldhdr ldhdr;
781
bfd_byte *elsym, *elsymend;
785
lsec = bfd_get_section_by_name (abfd, ".loader");
788
/* There are no symbols, so don't try to include it. */
792
if (! xcoff_get_section_contents (abfd, lsec))
794
contents = coff_section_data (abfd, lsec)->contents;
796
bfd_xcoff_swap_ldhdr_in (abfd, contents, &ldhdr);
798
strings = (char *) contents + ldhdr.l_stoff;
800
elsym = contents + bfd_xcoff_loader_symbol_offset(abfd, &ldhdr);
802
elsymend = elsym + ldhdr.l_nsyms * bfd_xcoff_ldsymsz(abfd);
803
for (; elsym < elsymend; elsym += bfd_xcoff_ldsymsz(abfd))
805
struct internal_ldsym ldsym;
806
char nambuf[SYMNMLEN + 1];
808
struct bfd_link_hash_entry *h;
810
bfd_xcoff_swap_ldsym_in (abfd, elsym, &ldsym);
812
/* We are only interested in exported symbols. */
813
if ((ldsym.l_smtype & L_EXPORT) == 0)
816
if (ldsym._l._l_l._l_zeroes == 0)
817
name = strings + ldsym._l._l_l._l_offset;
820
memcpy (nambuf, ldsym._l._l_name, SYMNMLEN);
821
nambuf[SYMNMLEN] = '\0';
825
h = bfd_link_hash_lookup (info->hash, name, false, false, true);
827
/* We are only interested in symbols that are currently
828
undefined. At this point we know that we are using an XCOFF
831
&& h->type == bfd_link_hash_undefined
832
&& (((struct xcoff_link_hash_entry *) h)->flags
833
& XCOFF_DEF_DYNAMIC) == 0)
835
if (! (*info->callbacks->add_archive_element) (info, abfd, name))
842
/* We do not need this shared object. */
844
if (contents != NULL && ! coff_section_data (abfd, lsec)->keep_contents)
846
free (coff_section_data (abfd, lsec)->contents);
847
coff_section_data (abfd, lsec)->contents = NULL;
853
/* Returns the index of reloc in RELOCS with the least address greater
854
than or equal to ADDRESS. The relocs are sorted by address. */
857
xcoff_find_reloc (relocs, count, address)
858
struct internal_reloc *relocs;
862
bfd_size_type min, max, this;
866
if (count == 1 && relocs[0].r_vaddr < address)
875
/* Do a binary search over (min,max]. */
876
while (min + 1 < max)
880
this = (max + min) / 2;
881
raddr = relocs[this].r_vaddr;
884
else if (raddr < address)
893
if (relocs[min].r_vaddr < address)
897
&& relocs[min - 1].r_vaddr == address)
904
/* xcoff_link_create_extra_sections
906
Takes care of creating the .loader, .gl, .ds, .debug and sections. */
909
xcoff_link_create_extra_sections(bfd * abfd, struct bfd_link_info *info)
912
boolean return_value = false;
914
if (info->hash->creator == abfd->xvec)
917
/* We need to build a .loader section, so we do it here. This
918
won't work if we're producing an XCOFF output file with no
919
XCOFF input files. FIXME. */
921
if (xcoff_hash_table (info)->loader_section == NULL)
925
lsec = bfd_make_section_anyway (abfd, ".loader");
930
xcoff_hash_table (info)->loader_section = lsec;
931
lsec->flags |= SEC_HAS_CONTENTS | SEC_IN_MEMORY;
934
/* Likewise for the linkage section. */
935
if (xcoff_hash_table (info)->linkage_section == NULL)
939
lsec = bfd_make_section_anyway (abfd, ".gl");
945
xcoff_hash_table (info)->linkage_section = lsec;
946
lsec->flags |= (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
948
lsec->alignment_power = 2;
951
/* Likewise for the TOC section. */
952
if (xcoff_hash_table (info)->toc_section == NULL)
956
tsec = bfd_make_section_anyway (abfd, ".tc");
962
xcoff_hash_table (info)->toc_section = tsec;
963
tsec->flags |= (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
965
tsec->alignment_power = 2;
968
/* Likewise for the descriptor section. */
969
if (xcoff_hash_table (info)->descriptor_section == NULL)
973
dsec = bfd_make_section_anyway (abfd, ".ds");
979
xcoff_hash_table (info)->descriptor_section = dsec;
980
dsec->flags |= (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
982
dsec->alignment_power = 2;
985
/* Likewise for the .debug section. */
986
if (xcoff_hash_table (info)->debug_section == NULL
987
&& info->strip != strip_all)
991
dsec = bfd_make_section_anyway (abfd, ".debug");
996
xcoff_hash_table (info)->debug_section = dsec;
997
dsec->flags |= SEC_HAS_CONTENTS | SEC_IN_MEMORY;
1001
return_value = true;
1005
return return_value;
1008
/* Add all the symbols from an object file to the hash table.
1010
XCOFF is a weird format. A normal XCOFF .o files will have three
1011
COFF sections--.text, .data, and .bss--but each COFF section will
1012
contain many csects. These csects are described in the symbol
1013
table. From the linker's point of view, each csect must be
1014
considered a section in its own right. For example, a TOC entry is
1015
handled as a small XMC_TC csect. The linker must be able to merge
1016
different TOC entries together, which means that it must be able to
1017
extract the XMC_TC csects from the .data section of the input .o
1020
From the point of view of our linker, this is, of course, a hideous
1021
nightmare. We cope by actually creating sections for each csect,
1022
and discarding the original sections. We then have to handle the
1023
relocation entries carefully, since the only way to tell which
1024
csect they belong to is to examine the address. */
1027
xcoff_link_add_symbols (abfd, info)
1029
struct bfd_link_info *info;
1031
unsigned int n_tmask;
1032
unsigned int n_btshft;
1033
boolean default_copy;
1034
bfd_size_type symcount;
1035
struct xcoff_link_hash_entry **sym_hash;
1036
asection **csect_cache;
1037
bfd_size_type linesz;
1039
asection *last_real;
1042
unsigned int csect_index;
1043
asection *first_csect;
1044
bfd_size_type symesz;
1047
struct reloc_info_struct
1049
struct internal_reloc *relocs;
1052
} *reloc_info = NULL;
1055
keep_syms = obj_coff_keep_syms (abfd);
1057
if ((abfd->flags & DYNAMIC) != 0
1058
&& ! info->static_link)
1060
if (! xcoff_link_add_dynamic_symbols (abfd, info))
1064
/* create the loader, toc, gl, ds and debug sections, if needed */
1065
if (false == xcoff_link_create_extra_sections(abfd, info))
1068
if ((abfd->flags & DYNAMIC) != 0
1069
&& ! info->static_link)
1072
n_tmask = coff_data (abfd)->local_n_tmask;
1073
n_btshft = coff_data (abfd)->local_n_btshft;
1075
/* Define macros so that ISFCN, et. al., macros work correctly. */
1076
#define N_TMASK n_tmask
1077
#define N_BTSHFT n_btshft
1079
if (info->keep_memory)
1080
default_copy = false;
1082
default_copy = true;
1084
symcount = obj_raw_syment_count (abfd);
1086
/* We keep a list of the linker hash table entries that correspond
1087
to each external symbol. */
1088
amt = symcount * sizeof (struct xcoff_link_hash_entry *);
1089
sym_hash = (struct xcoff_link_hash_entry **) bfd_zalloc (abfd, amt);
1090
if (sym_hash == NULL && symcount != 0)
1092
coff_data (abfd)->sym_hashes = (struct coff_link_hash_entry **) sym_hash;
1094
/* Because of the weird stuff we are doing with XCOFF csects, we can
1095
not easily determine which section a symbol is in, so we store
1096
the information in the tdata for the input file. */
1097
amt = symcount * sizeof (asection *);
1098
csect_cache = (asection **) bfd_zalloc (abfd, amt);
1099
if (csect_cache == NULL && symcount != 0)
1101
xcoff_data (abfd)->csects = csect_cache;
1103
/* While splitting sections into csects, we need to assign the
1104
relocs correctly. The relocs and the csects must both be in
1105
order by VMA within a given section, so we handle this by
1106
scanning along the relocs as we process the csects. We index
1107
into reloc_info using the section target_index. */
1108
amt = abfd->section_count + 1;
1109
amt *= sizeof (struct reloc_info_struct);
1110
reloc_info = (struct reloc_info_struct *) bfd_zmalloc (amt);
1111
if (reloc_info == NULL)
1114
/* Read in the relocs and line numbers for each section. */
1115
linesz = bfd_coff_linesz (abfd);
1117
for (o = abfd->sections; o != NULL; o = o->next)
1121
if ((o->flags & SEC_RELOC) != 0)
1124
reloc_info[o->target_index].relocs =
1125
xcoff_read_internal_relocs (abfd, o, true, (bfd_byte *) NULL,
1126
false, (struct internal_reloc *) NULL);
1127
amt = o->reloc_count;
1128
amt *= sizeof (asection *);
1129
reloc_info[o->target_index].csects = (asection **) bfd_zmalloc (amt);
1130
if (reloc_info[o->target_index].csects == NULL)
1134
if ((info->strip == strip_none || info->strip == strip_some)
1135
&& o->lineno_count > 0)
1140
amt = linesz * o->lineno_count;
1141
linenos = (bfd_byte *) bfd_malloc (amt);
1142
if (linenos == NULL)
1144
reloc_info[o->target_index].linenos = linenos;
1145
if (bfd_seek (abfd, o->line_filepos, SEEK_SET) != 0
1146
|| bfd_bread (linenos, amt, abfd) != amt)
1152
/* Don't let the linker relocation routines discard the symbols. */
1153
obj_coff_keep_syms (abfd) = true;
1159
symesz = bfd_coff_symesz (abfd);
1160
BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
1161
esym = (bfd_byte *) obj_coff_external_syms (abfd);
1162
esym_end = esym + symcount * symesz;
1164
while (esym < esym_end)
1166
struct internal_syment sym;
1167
union internal_auxent aux;
1169
char buf[SYMNMLEN + 1];
1174
struct xcoff_link_hash_entry *set_toc;
1176
bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
1178
/* In this pass we are only interested in symbols with csect
1180
if (sym.n_sclass != C_EXT && sym.n_sclass != C_HIDEXT)
1184
Normally csect is a .pr, .rw etc. created in the loop
1185
If C_FILE or first time, handle special
1187
Advance esym, sym_hash, csect_hash ptr's
1188
Keep track of the last_symndx for the current file. */
1189
if (sym.n_sclass == C_FILE && csect != NULL)
1191
xcoff_section_data (abfd, csect)->last_symndx =
1193
- (bfd_byte *) obj_coff_external_syms (abfd))
1199
*csect_cache = csect;
1200
else if (first_csect == NULL || sym.n_sclass == C_FILE)
1201
*csect_cache = coff_section_from_bfd_index (abfd, sym.n_scnum);
1203
*csect_cache = NULL;
1204
esym += (sym.n_numaux + 1) * symesz;
1205
sym_hash += sym.n_numaux + 1;
1206
csect_cache += sym.n_numaux + 1;
1211
name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
1216
/* If this symbol has line number information attached to it,
1217
and we're not stripping it, count the number of entries and
1218
add them to the count for this csect. In the final link pass
1219
we are going to attach line number information by symbol,
1220
rather than by section, in order to more easily handle
1221
garbage collection. */
1222
if ((info->strip == strip_none || info->strip == strip_some)
1225
&& ISFCN (sym.n_type))
1228
union internal_auxent auxlin;
1230
bfd_coff_swap_aux_in (abfd, (PTR) (esym + symesz),
1231
sym.n_type, sym.n_sclass,
1232
0, sym.n_numaux, (PTR) &auxlin);
1234
if (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
1236
asection *enclosing;
1237
bfd_signed_vma linoff;
1239
enclosing = xcoff_section_data (abfd, csect)->enclosing;
1240
if (enclosing == NULL)
1242
(*_bfd_error_handler)
1243
(_("%s: `%s' has line numbers but no enclosing section"),
1244
bfd_archive_filename (abfd), name);
1245
bfd_set_error (bfd_error_bad_value);
1248
linoff = (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr
1249
- enclosing->line_filepos);
1250
/* explict cast to bfd_signed_vma for compiler */
1251
if (linoff < (bfd_signed_vma) (enclosing->lineno_count * linesz))
1253
struct internal_lineno lin;
1254
bfd_byte *linpstart;
1256
linpstart = (reloc_info[enclosing->target_index].linenos
1258
bfd_coff_swap_lineno_in (abfd, (PTR) linpstart, (PTR) &lin);
1260
&& ((bfd_size_type) lin.l_addr.l_symndx
1262
- (bfd_byte *) obj_coff_external_syms (abfd))
1265
bfd_byte *linpend, *linp;
1267
linpend = (reloc_info[enclosing->target_index].linenos
1268
+ enclosing->lineno_count * linesz);
1269
for (linp = linpstart + linesz;
1273
bfd_coff_swap_lineno_in (abfd, (PTR) linp,
1275
if (lin.l_lnno == 0)
1278
csect->lineno_count += (linp - linpstart) / linesz;
1279
/* The setting of line_filepos will only be
1280
useful if all the line number entries for a
1281
csect are contiguous; this only matters for
1283
if (csect->line_filepos == 0)
1284
csect->line_filepos =
1285
auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr;
1291
/* Pick up the csect auxiliary information. */
1293
if (sym.n_numaux == 0)
1295
(*_bfd_error_handler)
1296
(_("%s: class %d symbol `%s' has no aux entries"),
1297
bfd_archive_filename (abfd), sym.n_sclass, name);
1298
bfd_set_error (bfd_error_bad_value);
1302
bfd_coff_swap_aux_in (abfd,
1303
(PTR) (esym + symesz * sym.n_numaux),
1304
sym.n_type, sym.n_sclass,
1305
sym.n_numaux - 1, sym.n_numaux,
1308
smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
1318
(*_bfd_error_handler)
1319
(_("%s: symbol `%s' has unrecognized csect type %d"),
1320
bfd_archive_filename (abfd), name, smtyp);
1321
bfd_set_error (bfd_error_bad_value);
1325
/* This is an external reference. */
1326
if (sym.n_sclass == C_HIDEXT
1327
|| sym.n_scnum != N_UNDEF
1328
|| aux.x_csect.x_scnlen.l != 0)
1330
(*_bfd_error_handler)
1331
(_("%s: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d"),
1332
bfd_archive_filename (abfd), name, sym.n_sclass, sym.n_scnum,
1333
aux.x_csect.x_scnlen.l);
1334
bfd_set_error (bfd_error_bad_value);
1338
/* An XMC_XO external reference is actually a reference to
1339
an absolute location. */
1340
if (aux.x_csect.x_smclas != XMC_XO)
1341
section = bfd_und_section_ptr;
1344
section = bfd_abs_section_ptr;
1345
value = sym.n_value;
1350
/* This is a csect definition. */
1353
xcoff_section_data (abfd, csect)->last_symndx =
1354
((esym - (bfd_byte *) obj_coff_external_syms (abfd)) / symesz);
1358
csect_index = -(unsigned) 1;
1360
/* When we see a TOC anchor, we record the TOC value. */
1361
if (aux.x_csect.x_smclas == XMC_TC0)
1363
if (sym.n_sclass != C_HIDEXT
1364
|| aux.x_csect.x_scnlen.l != 0)
1366
(*_bfd_error_handler)
1367
(_("%s: XMC_TC0 symbol `%s' is class %d scnlen %d"),
1368
bfd_archive_filename (abfd), name, sym.n_sclass,
1369
aux.x_csect.x_scnlen.l);
1370
bfd_set_error (bfd_error_bad_value);
1373
xcoff_data (abfd)->toc = sym.n_value;
1376
/* We must merge TOC entries for the same symbol. We can
1377
merge two TOC entries if they are both C_HIDEXT, they
1378
both have the same name, they are both 4 or 8 bytes long, and
1379
they both have a relocation table entry for an external
1380
symbol with the same name. Unfortunately, this means
1381
that we must look through the relocations. Ick.
1383
Logic for 32 bit vs 64 bit.
1384
32 bit has a csect length of 4 for TOC
1385
64 bit has a csect length of 8 for TOC
1387
The conditions to get past the if-check are not that bad.
1388
They are what is used to create the TOC csects in the first
1390
if (aux.x_csect.x_smclas == XMC_TC
1391
&& sym.n_sclass == C_HIDEXT
1392
&& info->hash->creator == abfd->xvec
1393
&& ((bfd_xcoff_is_xcoff32 (abfd)
1394
&& aux.x_csect.x_scnlen.l == 4)
1395
|| (bfd_xcoff_is_xcoff64 (abfd)
1396
&& aux.x_csect.x_scnlen.l == 8)))
1398
asection *enclosing;
1399
struct internal_reloc *relocs;
1400
bfd_size_type relindx;
1401
struct internal_reloc *rel;
1403
enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1404
if (enclosing == NULL)
1407
relocs = reloc_info[enclosing->target_index].relocs;
1408
amt = enclosing->reloc_count;
1409
relindx = xcoff_find_reloc (relocs, amt, sym.n_value);
1410
rel = relocs + relindx;
1412
/* 32 bit R_POS r_size is 31
1413
64 bit R_POS r_size is 63 */
1414
if (relindx < enclosing->reloc_count
1415
&& rel->r_vaddr == (bfd_vma) sym.n_value
1416
&& rel->r_type == R_POS
1417
&& ((bfd_xcoff_is_xcoff32 (abfd)
1418
&& rel->r_size == 31)
1419
|| (bfd_xcoff_is_xcoff64 (abfd)
1420
&& rel->r_size == 63)))
1424
struct internal_syment relsym;
1426
erelsym = ((bfd_byte *) obj_coff_external_syms (abfd)
1427
+ rel->r_symndx * symesz);
1428
bfd_coff_swap_sym_in (abfd, (PTR) erelsym, (PTR) &relsym);
1429
if (relsym.n_sclass == C_EXT)
1431
const char *relname;
1432
char relbuf[SYMNMLEN + 1];
1434
struct xcoff_link_hash_entry *h;
1436
/* At this point we know that the TOC entry is
1437
for an externally visible symbol. */
1439
relname = _bfd_coff_internal_syment_name (abfd, &relsym,
1441
if (relname == NULL)
1444
/* We only merge TOC entries if the TC name is
1445
the same as the symbol name. This handles
1446
the normal case, but not common cases like
1447
SYM.P4 which gcc generates to store SYM + 4
1448
in the TOC. FIXME. */
1450
if (strcmp (name, relname) == 0)
1452
copy = (! info->keep_memory
1453
|| relsym._n._n_n._n_zeroes != 0
1454
|| relsym._n._n_n._n_offset == 0);
1455
h = xcoff_link_hash_lookup (xcoff_hash_table (info),
1456
relname, true, copy,
1461
/* At this point h->root.type could be
1462
bfd_link_hash_new. That should be OK,
1463
since we know for sure that we will come
1464
across this symbol as we step through the
1467
/* We store h in *sym_hash for the
1468
convenience of the relocate_section
1472
if (h->toc_section != NULL)
1474
asection **rel_csects;
1476
/* We already have a TOC entry for this
1477
symbol, so we can just ignore this
1480
reloc_info[enclosing->target_index].csects;
1481
rel_csects[relindx] = bfd_und_section_ptr;
1485
/* We are about to create a TOC entry for
1488
} /* merge toc reloc */
1495
asection *enclosing;
1497
/* We need to create a new section. We get the name from
1498
the csect storage mapping class, so that the linker can
1499
accumulate similar csects together. */
1501
csect = bfd_xcoff_create_csect_from_smclas(abfd, &aux, name);
1507
/* The enclosing section is the main section : .data, .text
1508
or .bss that the csect is coming from. */
1509
enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1510
if (enclosing == NULL)
1513
if (! bfd_is_abs_section (enclosing)
1514
&& ((bfd_vma) sym.n_value < enclosing->vma
1515
|| ((bfd_vma) sym.n_value + aux.x_csect.x_scnlen.l
1516
> enclosing->vma + enclosing->_raw_size)))
1518
(*_bfd_error_handler)
1519
(_("%s: csect `%s' not in enclosing section"),
1520
bfd_archive_filename (abfd), name);
1521
bfd_set_error (bfd_error_bad_value);
1524
csect->vma = sym.n_value;
1525
csect->filepos = (enclosing->filepos
1528
csect->_raw_size = aux.x_csect.x_scnlen.l;
1529
csect->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
1530
csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
1532
/* Record the enclosing section in the tdata for this new
1534
amt = sizeof (struct coff_section_tdata);
1535
csect->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
1536
if (csect->used_by_bfd == NULL)
1538
amt = sizeof (struct xcoff_section_tdata);
1539
coff_section_data (abfd, csect)->tdata = bfd_zalloc (abfd, amt);
1540
if (coff_section_data (abfd, csect)->tdata == NULL)
1542
xcoff_section_data (abfd, csect)->enclosing = enclosing;
1543
xcoff_section_data (abfd, csect)->lineno_count =
1544
enclosing->lineno_count;
1546
if (enclosing->owner == abfd)
1548
struct internal_reloc *relocs;
1549
bfd_size_type relindx;
1550
struct internal_reloc *rel;
1551
asection **rel_csect;
1553
relocs = reloc_info[enclosing->target_index].relocs;
1554
amt = enclosing->reloc_count;
1555
relindx = xcoff_find_reloc (relocs, amt, csect->vma);
1557
rel = relocs + relindx;
1558
rel_csect = (reloc_info[enclosing->target_index].csects
1561
csect->rel_filepos = (enclosing->rel_filepos
1562
+ relindx * bfd_coff_relsz (abfd));
1563
while (relindx < enclosing->reloc_count
1564
&& *rel_csect == NULL
1565
&& rel->r_vaddr < csect->vma + csect->_raw_size)
1569
csect->flags |= SEC_RELOC;
1570
++csect->reloc_count;
1577
/* There are a number of other fields and section flags
1578
which we do not bother to set. */
1580
csect_index = ((esym
1581
- (bfd_byte *) obj_coff_external_syms (abfd))
1584
xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1586
if (first_csect == NULL)
1587
first_csect = csect;
1589
/* If this symbol is C_EXT, we treat it as starting at the
1590
beginning of the newly created section. */
1591
if (sym.n_sclass == C_EXT)
1597
/* If this is a TOC section for a symbol, record it. */
1598
if (set_toc != NULL)
1599
set_toc->toc_section = csect;
1604
/* This is a label definition. The x_scnlen field is the
1605
symbol index of the csect. Usually the XTY_LD symbol will
1606
follow its appropriate XTY_SD symbol. The .set pseudo op can
1607
cause the XTY_LD to not follow the XTY_SD symbol. */
1612
if (aux.x_csect.x_scnlen.l < 0
1613
|| (aux.x_csect.x_scnlen.l
1614
>= esym - (bfd_byte *) obj_coff_external_syms (abfd)))
1618
section = xcoff_data (abfd)->csects[aux.x_csect.x_scnlen.l];
1620
|| (section->flags & SEC_HAS_CONTENTS) == 0)
1625
(*_bfd_error_handler)
1626
(_("%s: misplaced XTY_LD `%s'"),
1627
bfd_archive_filename (abfd), name);
1628
bfd_set_error (bfd_error_bad_value);
1632
value = sym.n_value - csect->vma;
1637
/* This is an unitialized csect. We could base the name on
1638
the storage mapping class, but we don't bother except for
1639
an XMC_TD symbol. If this csect is externally visible,
1640
it is a common symbol. We put XMC_TD symbols in sections
1641
named .tocbss, and rely on the linker script to put that
1646
xcoff_section_data (abfd, csect)->last_symndx =
1648
- (bfd_byte *) obj_coff_external_syms (abfd))
1652
if (aux.x_csect.x_smclas == XMC_TD)
1654
/* The linker script puts the .td section in the data
1655
section after the .tc section. */
1656
csect = bfd_make_section_anyway (abfd, ".td");
1661
csect = bfd_make_section_anyway (abfd, ".bss");
1665
csect->vma = sym.n_value;
1666
csect->_raw_size = aux.x_csect.x_scnlen.l;
1667
csect->flags |= SEC_ALLOC;
1668
csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
1669
/* There are a number of other fields and section flags
1670
which we do not bother to set. */
1672
csect_index = ((esym
1673
- (bfd_byte *) obj_coff_external_syms (abfd))
1676
amt = sizeof (struct coff_section_tdata);
1677
csect->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
1678
if (csect->used_by_bfd == NULL)
1680
amt = sizeof (struct xcoff_section_tdata);
1681
coff_section_data (abfd, csect)->tdata = bfd_zalloc (abfd, amt);
1682
if (coff_section_data (abfd, csect)->tdata == NULL)
1684
xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1686
if (first_csect == NULL)
1687
first_csect = csect;
1689
if (sym.n_sclass == C_EXT)
1691
csect->flags |= SEC_IS_COMMON;
1692
csect->_raw_size = 0;
1694
value = aux.x_csect.x_scnlen.l;
1700
/* Check for magic symbol names. */
1701
if ((smtyp == XTY_SD || smtyp == XTY_CM)
1702
&& aux.x_csect.x_smclas != XMC_TC
1703
&& aux.x_csect.x_smclas != XMC_TD)
1710
if (strcmp (name, "_text") == 0)
1711
i = XCOFF_SPECIAL_SECTION_TEXT;
1712
else if (strcmp (name, "_etext") == 0)
1713
i = XCOFF_SPECIAL_SECTION_ETEXT;
1714
else if (strcmp (name, "_data") == 0)
1715
i = XCOFF_SPECIAL_SECTION_DATA;
1716
else if (strcmp (name, "_edata") == 0)
1717
i = XCOFF_SPECIAL_SECTION_EDATA;
1718
else if (strcmp (name, "_end") == 0)
1719
i = XCOFF_SPECIAL_SECTION_END;
1721
else if (name[0] == 'e' && strcmp (name, "end") == 0)
1723
i = XCOFF_SPECIAL_SECTION_END2;
1728
xcoff_hash_table (info)->special_sections[i] = csect;
1732
/* Now we have enough information to add the symbol to the
1733
linker hash table. */
1735
if (sym.n_sclass == C_EXT)
1739
BFD_ASSERT (section != NULL);
1741
/* We must copy the name into memory if we got it from the
1742
syment itself, rather than the string table. */
1743
copy = default_copy;
1744
if (sym._n._n_n._n_zeroes != 0
1745
|| sym._n._n_n._n_offset == 0)
1748
/* The AIX linker appears to only detect multiple symbol
1749
definitions when there is a reference to the symbol. If
1750
a symbol is defined multiple times, and the only
1751
references are from the same object file, the AIX linker
1752
appears to permit it. It does not merge the different
1753
definitions, but handles them independently. On the
1754
other hand, if there is a reference, the linker reports
1757
This matters because the AIX <net/net_globals.h> header
1758
file actually defines an initialized array, so we have to
1759
actually permit that to work.
1761
Just to make matters even more confusing, the AIX linker
1762
appears to permit multiple symbol definitions whenever
1763
the second definition is in an archive rather than an
1764
object file. This may be a consequence of the manner in
1765
which it handles archives: I think it may load the entire
1766
archive in as separate csects, and then let garbage
1767
collection discard symbols.
1769
We also have to handle the case of statically linking a
1770
shared object, which will cause symbol redefinitions,
1771
although this is an easier case to detect. */
1773
if (info->hash->creator == abfd->xvec)
1775
if (! bfd_is_und_section (section))
1777
*sym_hash = xcoff_link_hash_lookup (xcoff_hash_table (info),
1778
name, true, copy, false);
1782
/* Make a copy of the symbol name to prevent problems with
1784
*sym_hash = ((struct xcoff_link_hash_entry *)
1785
bfd_wrapped_link_hash_lookup (abfd, info, name,
1789
if (*sym_hash == NULL)
1791
if (((*sym_hash)->root.type == bfd_link_hash_defined
1792
|| (*sym_hash)->root.type == bfd_link_hash_defweak)
1793
&& ! bfd_is_und_section (section)
1794
&& ! bfd_is_com_section (section))
1796
/* This is a second definition of a defined symbol. */
1797
if ((abfd->flags & DYNAMIC) != 0
1798
&& ((*sym_hash)->smclas != XMC_GL
1799
|| aux.x_csect.x_smclas == XMC_GL
1800
|| ((*sym_hash)->root.u.def.section->owner->flags
1803
/* The new symbol is from a shared library, and
1804
either the existing symbol is not global
1805
linkage code or this symbol is global linkage
1806
code. If the existing symbol is global
1807
linkage code and the new symbol is not, then
1808
we want to use the new symbol. */
1809
section = bfd_und_section_ptr;
1812
else if (((*sym_hash)->root.u.def.section->owner->flags
1815
/* The existing symbol is from a shared library.
1817
(*sym_hash)->root.type = bfd_link_hash_undefined;
1818
(*sym_hash)->root.u.undef.abfd =
1819
(*sym_hash)->root.u.def.section->owner;
1821
else if (abfd->my_archive != NULL)
1823
/* This is a redefinition in an object contained
1824
in an archive. Just ignore it. See the
1826
section = bfd_und_section_ptr;
1829
else if ((*sym_hash)->root.next != NULL
1830
|| info->hash->undefs_tail == &(*sym_hash)->root)
1832
/* This symbol has been referenced. In this
1833
case, we just continue and permit the
1834
multiple definition error. See the comment
1835
above about the behaviour of the AIX linker. */
1837
else if ((*sym_hash)->smclas == aux.x_csect.x_smclas)
1839
/* The symbols are both csects of the same
1840
class. There is at least a chance that this
1841
is a semi-legitimate redefinition. */
1842
section = bfd_und_section_ptr;
1844
(*sym_hash)->flags |= XCOFF_MULTIPLY_DEFINED;
1847
else if (((*sym_hash)->flags & XCOFF_MULTIPLY_DEFINED) != 0
1848
&& ((*sym_hash)->root.type == bfd_link_hash_defined
1849
|| (*sym_hash)->root.type == bfd_link_hash_defweak)
1850
&& (bfd_is_und_section (section)
1851
|| bfd_is_com_section (section)))
1853
/* This is a reference to a multiply defined symbol.
1854
Report the error now. See the comment above
1855
about the behaviour of the AIX linker. We could
1856
also do this with warning symbols, but I'm not
1857
sure the XCOFF linker is wholly prepared to
1858
handle them, and that would only be a warning,
1860
if (! ((*info->callbacks->multiple_definition)
1861
(info, (*sym_hash)->root.root.string,
1862
(bfd *) NULL, (asection *) NULL, (bfd_vma) 0,
1863
(*sym_hash)->root.u.def.section->owner,
1864
(*sym_hash)->root.u.def.section,
1865
(*sym_hash)->root.u.def.value)))
1867
/* Try not to give this error too many times. */
1868
(*sym_hash)->flags &= ~XCOFF_MULTIPLY_DEFINED;
1872
/* _bfd_generic_link_add_one_symbol may call the linker to
1873
generate an error message, and the linker may try to read
1874
the symbol table to give a good error. Right now, the
1875
line numbers are in an inconsistent state, since they are
1876
counted both in the real sections and in the new csects.
1877
We need to leave the count in the real sections so that
1878
the linker can report the line number of the error
1879
correctly, so temporarily clobber the link to the csects
1880
so that the linker will not try to read the line numbers
1881
a second time from the csects. */
1882
BFD_ASSERT (last_real->next == first_csect);
1883
last_real->next = NULL;
1884
if (! (_bfd_generic_link_add_one_symbol
1885
(info, abfd, name, flags, section, value,
1886
(const char *) NULL, copy, true,
1887
(struct bfd_link_hash_entry **) sym_hash)))
1889
last_real->next = first_csect;
1891
if (smtyp == XTY_CM)
1893
if ((*sym_hash)->root.type != bfd_link_hash_common
1894
|| (*sym_hash)->root.u.c.p->section != csect)
1896
/* We don't need the common csect we just created. */
1897
csect->_raw_size = 0;
1901
(*sym_hash)->root.u.c.p->alignment_power
1902
= csect->alignment_power;
1906
if (info->hash->creator == abfd->xvec)
1910
if (smtyp == XTY_ER || smtyp == XTY_CM)
1911
flag = XCOFF_REF_REGULAR;
1913
flag = XCOFF_DEF_REGULAR;
1914
(*sym_hash)->flags |= flag;
1916
if ((*sym_hash)->smclas == XMC_UA
1917
|| flag == XCOFF_DEF_REGULAR)
1918
(*sym_hash)->smclas = aux.x_csect.x_smclas;
1922
*csect_cache = csect;
1924
esym += (sym.n_numaux + 1) * symesz;
1925
sym_hash += sym.n_numaux + 1;
1926
csect_cache += sym.n_numaux + 1;
1929
BFD_ASSERT (last_real == NULL || last_real->next == first_csect);
1931
/* Make sure that we have seen all the relocs. */
1932
for (o = abfd->sections; o != first_csect; o = o->next)
1934
/* Reset the section size and the line number count, since the
1935
data is now attached to the csects. Don't reset the size of
1936
the .debug section, since we need to read it below in
1937
bfd_xcoff_size_dynamic_sections. */
1938
if (strcmp (bfd_get_section_name (abfd, o), ".debug") != 0)
1940
o->lineno_count = 0;
1942
if ((o->flags & SEC_RELOC) != 0)
1945
struct internal_reloc *rel;
1946
asection **rel_csect;
1948
rel = reloc_info[o->target_index].relocs;
1949
rel_csect = reloc_info[o->target_index].csects;
1951
for (i = 0; i < o->reloc_count; i++, rel++, rel_csect++)
1954
if (*rel_csect == NULL)
1956
(*_bfd_error_handler)
1957
(_("%s: reloc %s:%d not in csect"),
1958
bfd_archive_filename (abfd), o->name, i);
1959
bfd_set_error (bfd_error_bad_value);
1963
/* We identify all symbols which are called, so that we
1964
can create glue code for calls to functions imported
1965
from dynamic objects. */
1966
if (info->hash->creator == abfd->xvec
1967
&& *rel_csect != bfd_und_section_ptr
1968
&& (rel->r_type == R_BR
1969
|| rel->r_type == R_RBR)
1970
&& obj_xcoff_sym_hashes (abfd)[rel->r_symndx] != NULL)
1972
struct xcoff_link_hash_entry *h;
1974
h = obj_xcoff_sym_hashes (abfd)[rel->r_symndx];
1975
h->flags |= XCOFF_CALLED;
1976
/* If the symbol name starts with a period, it is
1977
the code of a function. If the symbol is
1978
currently undefined, then add an undefined symbol
1979
for the function descriptor. This should do no
1980
harm, because any regular object that defines the
1981
function should also define the function
1982
descriptor. It helps, because it means that we
1983
will identify the function descriptor with a
1984
dynamic object if a dynamic object defines it. */
1985
if (h->root.root.string[0] == '.'
1986
&& h->descriptor == NULL)
1988
struct xcoff_link_hash_entry *hds;
1990
hds = xcoff_link_hash_lookup (xcoff_hash_table (info),
1991
h->root.root.string + 1,
1995
if (hds->root.type == bfd_link_hash_new)
1997
if (! (_bfd_generic_link_add_one_symbol
1998
(info, abfd, hds->root.root.string,
1999
(flagword) 0, bfd_und_section_ptr,
2000
(bfd_vma) 0, (const char *) NULL, false,
2002
(struct bfd_link_hash_entry **) &hds)))
2005
hds->flags |= XCOFF_DESCRIPTOR;
2006
BFD_ASSERT ((hds->flags & XCOFF_CALLED) == 0
2007
&& (h->flags & XCOFF_DESCRIPTOR) == 0);
2008
hds->descriptor = h;
2009
h->descriptor = hds;
2014
free (reloc_info[o->target_index].csects);
2015
reloc_info[o->target_index].csects = NULL;
2017
/* Reset SEC_RELOC and the reloc_count, since the reloc
2018
information is now attached to the csects. */
2019
o->flags &=~ SEC_RELOC;
2022
/* If we are not keeping memory, free the reloc information. */
2023
if (! info->keep_memory
2024
&& coff_section_data (abfd, o) != NULL
2025
&& coff_section_data (abfd, o)->relocs != NULL
2026
&& ! coff_section_data (abfd, o)->keep_relocs)
2028
free (coff_section_data (abfd, o)->relocs);
2029
coff_section_data (abfd, o)->relocs = NULL;
2033
/* Free up the line numbers. FIXME: We could cache these
2034
somewhere for the final link, to avoid reading them again. */
2035
if (reloc_info[o->target_index].linenos != NULL)
2037
free (reloc_info[o->target_index].linenos);
2038
reloc_info[o->target_index].linenos = NULL;
2044
obj_coff_keep_syms (abfd) = keep_syms;
2049
if (reloc_info != NULL)
2051
for (o = abfd->sections; o != NULL; o = o->next)
2053
if (reloc_info[o->target_index].csects != NULL)
2054
free (reloc_info[o->target_index].csects);
2055
if (reloc_info[o->target_index].linenos != NULL)
2056
free (reloc_info[o->target_index].linenos);
2060
obj_coff_keep_syms (abfd) = keep_syms;
2067
/* This function is used to add symbols from a dynamic object to the
2068
global symbol table. */
2071
xcoff_link_add_dynamic_symbols (abfd, info)
2073
struct bfd_link_info *info;
2077
struct internal_ldhdr ldhdr;
2078
const char *strings;
2079
bfd_byte *elsym, *elsymend;
2080
struct xcoff_import_file *n;
2085
struct xcoff_import_file **pp;
2087
/* We can only handle a dynamic object if we are generating an XCOFF
2089
if (info->hash->creator != abfd->xvec)
2091
(*_bfd_error_handler)
2092
(_("%s: XCOFF shared object when not producing XCOFF output"),
2093
bfd_get_filename (abfd));
2094
bfd_set_error (bfd_error_invalid_operation);
2098
/* The symbols we use from a dynamic object are not the symbols in
2099
the normal symbol table, but, rather, the symbols in the export
2100
table. If there is a global symbol in a dynamic object which is
2101
not in the export table, the loader will not be able to find it,
2102
so we don't want to find it either. Also, on AIX 4.1.3, shr.o in
2103
libc.a has symbols in the export table which are not in the
2106
/* Read in the .loader section. FIXME: We should really use the
2107
o_snloader field in the a.out header, rather than grabbing the
2109
lsec = bfd_get_section_by_name (abfd, ".loader");
2112
(*_bfd_error_handler)
2113
(_("%s: dynamic object with no .loader section"),
2114
bfd_get_filename (abfd));
2115
bfd_set_error (bfd_error_no_symbols);
2120
if (! xcoff_get_section_contents (abfd, lsec))
2122
contents = coff_section_data (abfd, lsec)->contents;
2124
/* Remove the sections from this object, so that they do not get
2125
included in the link. */
2126
bfd_section_list_clear (abfd);
2128
bfd_xcoff_swap_ldhdr_in (abfd, contents, &ldhdr);
2130
strings = (char *) contents + ldhdr.l_stoff;
2132
elsym = contents + bfd_xcoff_loader_symbol_offset(abfd, &ldhdr);
2134
elsymend = elsym + ldhdr.l_nsyms * bfd_xcoff_ldsymsz(abfd);
2136
for (; elsym < elsymend; elsym += bfd_xcoff_ldsymsz(abfd))
2138
struct internal_ldsym ldsym;
2139
char nambuf[SYMNMLEN + 1];
2141
struct xcoff_link_hash_entry *h;
2143
bfd_xcoff_swap_ldsym_in (abfd, elsym, &ldsym);
2145
/* We are only interested in exported symbols. */
2146
if ((ldsym.l_smtype & L_EXPORT) == 0)
2149
if (ldsym._l._l_l._l_zeroes == 0)
2150
name = strings + ldsym._l._l_l._l_offset;
2153
memcpy (nambuf, ldsym._l._l_name, SYMNMLEN);
2154
nambuf[SYMNMLEN] = '\0';
2158
/* Normally we could not call xcoff_link_hash_lookup in an add
2159
symbols routine, since we might not be using an XCOFF hash
2160
table. However, we verified above that we are using an XCOFF
2163
h = xcoff_link_hash_lookup (xcoff_hash_table (info), name, true,
2168
h->flags |= XCOFF_DEF_DYNAMIC;
2170
/* If the symbol is undefined, and the BFD it was found in is
2171
not a dynamic object, change the BFD to this dynamic object,
2172
so that we can get the correct import file ID. */
2173
if ((h->root.type == bfd_link_hash_undefined
2174
|| h->root.type == bfd_link_hash_undefweak)
2175
&& (h->root.u.undef.abfd == NULL
2176
|| (h->root.u.undef.abfd->flags & DYNAMIC) == 0))
2177
h->root.u.undef.abfd = abfd;
2179
if (h->root.type == bfd_link_hash_new)
2181
h->root.type = bfd_link_hash_undefined;
2182
h->root.u.undef.abfd = abfd;
2183
/* We do not want to add this to the undefined symbol list. */
2186
if (h->smclas == XMC_UA
2187
|| h->root.type == bfd_link_hash_undefined
2188
|| h->root.type == bfd_link_hash_undefweak)
2189
h->smclas = ldsym.l_smclas;
2191
/* Unless this is an XMC_XO symbol, we don't bother to actually
2192
define it, since we don't have a section to put it in anyhow.
2193
Instead, the relocation routines handle the DEF_DYNAMIC flag
2196
if (h->smclas == XMC_XO
2197
&& (h->root.type == bfd_link_hash_undefined
2198
|| h->root.type == bfd_link_hash_undefweak))
2200
/* This symbol has an absolute value. */
2201
h->root.type = bfd_link_hash_defined;
2202
h->root.u.def.section = bfd_abs_section_ptr;
2203
h->root.u.def.value = ldsym.l_value;
2206
/* If this symbol defines a function descriptor, then it
2207
implicitly defines the function code as well. */
2208
if (h->smclas == XMC_DS
2209
|| (h->smclas == XMC_XO && name[0] != '.'))
2210
h->flags |= XCOFF_DESCRIPTOR;
2211
if ((h->flags & XCOFF_DESCRIPTOR) != 0)
2213
struct xcoff_link_hash_entry *hds;
2215
hds = h->descriptor;
2220
dsnm = bfd_malloc ((bfd_size_type) strlen (name) + 2);
2224
strcpy (dsnm + 1, name);
2225
hds = xcoff_link_hash_lookup (xcoff_hash_table (info), dsnm,
2231
if (hds->root.type == bfd_link_hash_new)
2233
hds->root.type = bfd_link_hash_undefined;
2234
hds->root.u.undef.abfd = abfd;
2235
/* We do not want to add this to the undefined
2239
hds->descriptor = h;
2240
h->descriptor = hds;
2243
hds->flags |= XCOFF_DEF_DYNAMIC;
2244
if (hds->smclas == XMC_UA)
2245
hds->smclas = XMC_PR;
2247
/* An absolute symbol appears to actually define code, not a
2248
function descriptor. This is how some math functions are
2249
implemented on AIX 4.1. */
2250
if (h->smclas == XMC_XO
2251
&& (hds->root.type == bfd_link_hash_undefined
2252
|| hds->root.type == bfd_link_hash_undefweak))
2254
hds->smclas = XMC_XO;
2255
hds->root.type = bfd_link_hash_defined;
2256
hds->root.u.def.section = bfd_abs_section_ptr;
2257
hds->root.u.def.value = ldsym.l_value;
2262
if (contents != NULL && ! coff_section_data (abfd, lsec)->keep_contents)
2264
free (coff_section_data (abfd, lsec)->contents);
2265
coff_section_data (abfd, lsec)->contents = NULL;
2268
/* Record this file in the import files. */
2270
n = ((struct xcoff_import_file *)
2271
bfd_alloc (abfd, (bfd_size_type) sizeof (struct xcoff_import_file)));
2276
/* For some reason, the path entry in the import file list for a
2277
shared object appears to always be empty. The file name is the
2280
if (abfd->my_archive == NULL)
2282
bname = bfd_get_filename (abfd);
2287
bname = bfd_get_filename (abfd->my_archive);
2288
mname = bfd_get_filename (abfd);
2290
s = strrchr (bname, '/');
2296
/* We start c at 1 because the first import file number is reserved
2298
for (pp = &xcoff_hash_table (info)->imports, c = 1;
2300
pp = &(*pp)->next, ++c)
2304
xcoff_data (abfd)->import_file_id = c;
2309
/* Routines that are called after all the input files have been
2310
handled, but before the sections are laid out in memory. */
2312
/* Mark a symbol as not being garbage, including the section in which
2315
static INLINE boolean
2316
xcoff_mark_symbol (info, h)
2317
struct bfd_link_info *info;
2318
struct xcoff_link_hash_entry *h;
2321
if ((h->flags & XCOFF_MARK) != 0)
2324
h->flags |= XCOFF_MARK;
2325
if (h->root.type == bfd_link_hash_defined
2326
|| h->root.type == bfd_link_hash_defweak)
2330
hsec = h->root.u.def.section;
2331
if (! bfd_is_abs_section (hsec)
2332
&& (hsec->flags & SEC_MARK) == 0)
2334
if (! xcoff_mark (info, hsec))
2339
if (h->toc_section != NULL
2340
&& (h->toc_section->flags & SEC_MARK) == 0)
2342
if (! xcoff_mark (info, h->toc_section))
2349
/* The mark phase of garbage collection. For a given section, mark
2350
it, and all the sections which define symbols to which it refers.
2351
Because this function needs to look at the relocs, we also count
2352
the number of relocs which need to be copied into the .loader
2356
xcoff_mark (info, sec)
2357
struct bfd_link_info *info;
2360
if (bfd_is_abs_section (sec)
2361
|| (sec->flags & SEC_MARK) != 0)
2364
sec->flags |= SEC_MARK;
2366
if (sec->owner->xvec == info->hash->creator
2367
&& coff_section_data (sec->owner, sec) != NULL
2368
&& xcoff_section_data (sec->owner, sec) != NULL)
2370
register struct xcoff_link_hash_entry **hp, **hpend;
2371
struct internal_reloc *rel, *relend;
2373
/* Mark all the symbols in this section. */
2375
hp = (obj_xcoff_sym_hashes (sec->owner)
2376
+ xcoff_section_data (sec->owner, sec)->first_symndx);
2377
hpend = (obj_xcoff_sym_hashes (sec->owner)
2378
+ xcoff_section_data (sec->owner, sec)->last_symndx);
2379
for (; hp < hpend; hp++)
2381
register struct xcoff_link_hash_entry *h;
2385
&& (h->flags & XCOFF_MARK) == 0)
2387
if (! xcoff_mark_symbol (info, h))
2392
/* Look through the section relocs. */
2394
if ((sec->flags & SEC_RELOC) != 0
2395
&& sec->reloc_count > 0)
2397
rel = xcoff_read_internal_relocs (sec->owner, sec, true,
2398
(bfd_byte *) NULL, false,
2399
(struct internal_reloc *) NULL);
2402
relend = rel + sec->reloc_count;
2403
for (; rel < relend; rel++)
2406
struct xcoff_link_hash_entry *h;
2408
if ((unsigned int) rel->r_symndx
2409
> obj_raw_syment_count (sec->owner))
2412
h = obj_xcoff_sym_hashes (sec->owner)[rel->r_symndx];
2414
&& (h->flags & XCOFF_MARK) == 0)
2416
if (! xcoff_mark_symbol (info, h))
2420
rsec = xcoff_data (sec->owner)->csects[rel->r_symndx];
2422
&& (rsec->flags & SEC_MARK) == 0)
2424
if (! xcoff_mark (info, rsec))
2428
/* See if this reloc needs to be copied into the .loader
2430
switch (rel->r_type)
2434
|| h->root.type == bfd_link_hash_defined
2435
|| h->root.type == bfd_link_hash_defweak
2436
|| h->root.type == bfd_link_hash_common
2437
|| ((h->flags & XCOFF_CALLED) != 0
2438
&& (h->root.type == bfd_link_hash_undefined
2439
|| h->root.type == bfd_link_hash_undefweak)
2440
&& h->root.root.string[0] == '.'
2441
&& h->descriptor != NULL
2442
&& ((h->descriptor->flags & XCOFF_DEF_DYNAMIC) != 0
2443
|| ((h->descriptor->flags & XCOFF_IMPORT) != 0
2444
&& (h->descriptor->flags
2445
& XCOFF_DEF_REGULAR) == 0))))
2452
++xcoff_hash_table (info)->ldrel_count;
2454
h->flags |= XCOFF_LDREL;
2461
/* We should never need a .loader reloc for a TOC
2467
if (! info->keep_memory
2468
&& coff_section_data (sec->owner, sec) != NULL
2469
&& coff_section_data (sec->owner, sec)->relocs != NULL
2470
&& ! coff_section_data (sec->owner, sec)->keep_relocs)
2472
free (coff_section_data (sec->owner, sec)->relocs);
2473
coff_section_data (sec->owner, sec)->relocs = NULL;
2481
/* The sweep phase of garbage collection. Remove all garbage
2486
struct bfd_link_info *info;
2490
for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2494
for (o = sub->sections; o != NULL; o = o->next)
2496
if ((o->flags & SEC_MARK) == 0)
2498
/* Keep all sections from non-XCOFF input files. Keep
2499
special sections. Keep .debug sections for the
2501
if (sub->xvec != info->hash->creator
2502
|| o == xcoff_hash_table (info)->debug_section
2503
|| o == xcoff_hash_table (info)->loader_section
2504
|| o == xcoff_hash_table (info)->linkage_section
2505
|| o == xcoff_hash_table (info)->toc_section
2506
|| o == xcoff_hash_table (info)->descriptor_section
2507
|| strcmp (o->name, ".debug") == 0)
2508
o->flags |= SEC_MARK;
2513
o->lineno_count = 0;
2520
/* Record the number of elements in a set. This is used to output the
2521
correct csect length. */
2524
bfd_xcoff_link_record_set (output_bfd, info, harg, size)
2526
struct bfd_link_info *info;
2527
struct bfd_link_hash_entry *harg;
2530
struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
2531
struct xcoff_link_size_list *n;
2534
if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour)
2537
/* This will hardly ever be called. I don't want to burn four bytes
2538
per global symbol, so instead the size is kept on a linked list
2539
attached to the hash table. */
2541
amt = sizeof (struct xcoff_link_size_list);
2542
n = (struct xcoff_link_size_list *) bfd_alloc (output_bfd, amt);
2545
n->next = xcoff_hash_table (info)->size_list;
2548
xcoff_hash_table (info)->size_list = n;
2550
h->flags |= XCOFF_HAS_SIZE;
2555
/* Import a symbol. */
2558
bfd_xcoff_import_symbol (output_bfd, info, harg, val, imppath, impfile,
2559
impmember, syscall_flag)
2561
struct bfd_link_info *info;
2562
struct bfd_link_hash_entry *harg;
2564
const char *imppath;
2565
const char *impfile;
2566
const char *impmember;
2567
unsigned int syscall_flag;
2569
struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
2571
if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour)
2574
/* A symbol name which starts with a period is the code for a
2575
function. If the symbol is undefined, then add an undefined
2576
symbol for the function descriptor, and import that instead. */
2577
if (h->root.root.string[0] == '.'
2578
&& h->root.type == bfd_link_hash_undefined
2579
&& val == (bfd_vma) -1)
2581
struct xcoff_link_hash_entry *hds;
2583
hds = h->descriptor;
2586
hds = xcoff_link_hash_lookup (xcoff_hash_table (info),
2587
h->root.root.string + 1,
2591
if (hds->root.type == bfd_link_hash_new)
2593
hds->root.type = bfd_link_hash_undefined;
2594
hds->root.u.undef.abfd = h->root.u.undef.abfd;
2596
hds->flags |= XCOFF_DESCRIPTOR;
2597
BFD_ASSERT ((hds->flags & XCOFF_CALLED) == 0
2598
&& (h->flags & XCOFF_DESCRIPTOR) == 0);
2599
hds->descriptor = h;
2600
h->descriptor = hds;
2603
/* Now, if the descriptor is undefined, import the descriptor
2604
rather than the symbol we were told to import. FIXME: Is
2605
this correct in all cases? */
2606
if (hds->root.type == bfd_link_hash_undefined)
2610
h->flags |= (XCOFF_IMPORT | syscall_flag);
2612
if (val != (bfd_vma) -1)
2614
if (h->root.type == bfd_link_hash_defined
2615
&& (! bfd_is_abs_section (h->root.u.def.section)
2616
|| h->root.u.def.value != val))
2618
if (! ((*info->callbacks->multiple_definition)
2619
(info, h->root.root.string, h->root.u.def.section->owner,
2620
h->root.u.def.section, h->root.u.def.value,
2621
output_bfd, bfd_abs_section_ptr, val)))
2625
h->root.type = bfd_link_hash_defined;
2626
h->root.u.def.section = bfd_abs_section_ptr;
2627
h->root.u.def.value = val;
2630
/* We overload the ldindx field to hold the l_ifile value for this
2632
BFD_ASSERT (h->ldsym == NULL);
2633
BFD_ASSERT ((h->flags & XCOFF_BUILT_LDSYM) == 0);
2634
if (imppath == NULL)
2639
struct xcoff_import_file **pp;
2641
/* We start c at 1 because the first entry in the import list is
2642
reserved for the library search path. */
2643
for (pp = &xcoff_hash_table (info)->imports, c = 1;
2645
pp = &(*pp)->next, ++c)
2647
if (strcmp ((*pp)->path, imppath) == 0
2648
&& strcmp ((*pp)->file, impfile) == 0
2649
&& strcmp ((*pp)->member, impmember) == 0)
2655
struct xcoff_import_file *n;
2656
bfd_size_type amt = sizeof (struct xcoff_import_file);
2658
n = (struct xcoff_import_file *) bfd_alloc (output_bfd, amt);
2664
n->member = impmember;
2674
/* Export a symbol. */
2677
bfd_xcoff_export_symbol (output_bfd, info, harg)
2679
struct bfd_link_info *info;
2680
struct bfd_link_hash_entry *harg;
2682
struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
2684
if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour)
2687
h->flags |= XCOFF_EXPORT;
2689
/* FIXME: I'm not at all sure what syscall is supposed to mean, so
2690
I'm just going to ignore it until somebody explains it. */
2692
/* See if this is a function descriptor. It may be one even though
2693
it is not so marked. */
2694
if ((h->flags & XCOFF_DESCRIPTOR) == 0
2695
&& h->root.root.string[0] != '.')
2698
struct xcoff_link_hash_entry *hfn;
2699
bfd_size_type amt = strlen (h->root.root.string) + 2;
2701
fnname = (char *) bfd_malloc (amt);
2705
strcpy (fnname + 1, h->root.root.string);
2706
hfn = xcoff_link_hash_lookup (xcoff_hash_table (info),
2707
fnname, false, false, true);
2710
&& hfn->smclas == XMC_PR
2711
&& (hfn->root.type == bfd_link_hash_defined
2712
|| hfn->root.type == bfd_link_hash_defweak))
2714
h->flags |= XCOFF_DESCRIPTOR;
2715
h->descriptor = hfn;
2716
hfn->descriptor = h;
2720
/* Make sure we don't garbage collect this symbol. */
2721
if (! xcoff_mark_symbol (info, h))
2724
/* If this is a function descriptor, make sure we don't garbage
2725
collect the associated function code. We normally don't have to
2726
worry about this, because the descriptor will be attached to a
2727
section with relocs, but if we are creating the descriptor
2728
ourselves those relocs will not be visible to the mark code. */
2729
if ((h->flags & XCOFF_DESCRIPTOR) != 0)
2731
if (! xcoff_mark_symbol (info, h->descriptor))
2738
/* Count a reloc against a symbol. This is called for relocs
2739
generated by the linker script, typically for global constructors
2743
bfd_xcoff_link_count_reloc (output_bfd, info, name)
2745
struct bfd_link_info *info;
2748
struct xcoff_link_hash_entry *h;
2750
if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour)
2753
h = ((struct xcoff_link_hash_entry *)
2754
bfd_wrapped_link_hash_lookup (output_bfd, info, name, false, false,
2758
(*_bfd_error_handler) (_("%s: no such symbol"), name);
2759
bfd_set_error (bfd_error_no_symbols);
2763
h->flags |= XCOFF_REF_REGULAR | XCOFF_LDREL;
2764
++xcoff_hash_table (info)->ldrel_count;
2766
/* Mark the symbol to avoid garbage collection. */
2767
if (! xcoff_mark_symbol (info, h))
2773
/* This function is called for each symbol to which the linker script
2777
bfd_xcoff_record_link_assignment (output_bfd, info, name)
2779
struct bfd_link_info *info;
2782
struct xcoff_link_hash_entry *h;
2784
if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour)
2787
h = xcoff_link_hash_lookup (xcoff_hash_table (info), name, true, true,
2792
h->flags |= XCOFF_DEF_REGULAR;
2797
/* Build the .loader section. This is called by the XCOFF linker
2798
emulation before_allocation routine. We must set the size of the
2799
.loader section before the linker lays out the output file.
2800
LIBPATH is the library path to search for shared objects; this is
2801
normally built from the -L arguments passed to the linker. ENTRY
2802
is the name of the entry point symbol (the -e linker option).
2803
FILE_ALIGN is the alignment to use for sections within the file
2804
(the -H linker option). MAXSTACK is the maximum stack size (the
2805
-bmaxstack linker option). MAXDATA is the maximum data size (the
2806
-bmaxdata linker option). GC is whether to do garbage collection
2807
(the -bgc linker option). MODTYPE is the module type (the
2808
-bmodtype linker option). TEXTRO is whether the text section must
2809
be read only (the -btextro linker option). EXPORT_DEFINEDS is
2810
whether all defined symbols should be exported (the -unix linker
2811
option). SPECIAL_SECTIONS is set by this routine to csects with
2812
magic names like _end. */
2815
bfd_xcoff_size_dynamic_sections (output_bfd, info, libpath, entry,
2816
file_align, maxstack, maxdata, gc,
2817
modtype, textro, export_defineds,
2818
special_sections, rtld)
2820
struct bfd_link_info *info;
2821
const char *libpath;
2823
unsigned long file_align;
2824
unsigned long maxstack;
2825
unsigned long maxdata;
2829
boolean export_defineds;
2830
asection **special_sections;
2833
struct xcoff_link_hash_entry *hentry;
2835
struct xcoff_loader_info ldinfo;
2837
size_t impsize, impcount;
2838
struct xcoff_import_file *fl;
2839
struct internal_ldhdr *ldhdr;
2840
bfd_size_type stoff;
2844
struct bfd_strtab_hash *debug_strtab;
2845
bfd_byte *debug_contents = NULL;
2848
if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour)
2850
for (i = 0; i < XCOFF_NUMBER_OF_SPECIAL_SECTIONS; i++)
2851
special_sections[i] = NULL;
2855
ldinfo.failed = false;
2856
ldinfo.output_bfd = output_bfd;
2858
ldinfo.export_defineds = export_defineds;
2859
ldinfo.ldsym_count = 0;
2860
ldinfo.string_size = 0;
2861
ldinfo.strings = NULL;
2862
ldinfo.string_alc = 0;
2864
xcoff_data (output_bfd)->maxstack = maxstack;
2865
xcoff_data (output_bfd)->maxdata = maxdata;
2866
xcoff_data (output_bfd)->modtype = modtype;
2868
xcoff_hash_table (info)->file_align = file_align;
2869
xcoff_hash_table (info)->textro = textro;
2874
hentry = xcoff_link_hash_lookup (xcoff_hash_table (info), entry,
2875
false, false, true);
2877
hentry->flags |= XCOFF_ENTRY;
2881
if (info->init_function || info->fini_function || rtld)
2883
struct xcoff_link_hash_entry *hsym;
2884
struct internal_ldsym *ldsym;
2886
hsym = xcoff_link_hash_lookup (xcoff_hash_table (info),
2887
"__rtinit", false, false, true);
2890
(*_bfd_error_handler)
2891
(_("error: undefined symbol __rtinit"));
2895
xcoff_mark_symbol (info, hsym);
2896
hsym->flags |= (XCOFF_DEF_REGULAR | XCOFF_RTINIT);
2898
/* __rtinit initalized */
2899
amt = sizeof (struct internal_ldsym);
2900
ldsym = (struct internal_ldsym *) bfd_malloc (amt);
2902
ldsym->l_value = 0; /* will be filled in later */
2903
ldsym->l_scnum = 2; /* data section */
2904
ldsym->l_smtype = XTY_SD; /* csect section definition */
2905
ldsym->l_smclas = 5; /* .rw */
2906
ldsym->l_ifile = 0; /* special system loader symbol */
2907
ldsym->l_parm = 0; /* NA */
2909
/* Force __rtinit to be the first symbol in the loader symbol table
2910
See xcoff_build_ldsyms
2912
The first 3 symbol table indices are reserved to indicate the data,
2913
text and bss sections. */
2914
BFD_ASSERT (0 == ldinfo.ldsym_count);
2917
ldinfo.ldsym_count = 1;
2918
hsym->ldsym = ldsym;
2920
if (false == bfd_xcoff_put_ldsymbol_name (ldinfo.output_bfd, &ldinfo,
2922
hsym->root.root.string))
2925
/* This symbol is written out by xcoff_write_global_symbol
2926
Set stuff up so xcoff_write_global_symbol logic works. */
2927
hsym->flags |= XCOFF_DEF_REGULAR | XCOFF_MARK;
2928
hsym->root.type = bfd_link_hash_defined;
2929
hsym->root.u.def.value = 0;
2932
/* Garbage collect unused sections. */
2933
if (info->relocateable
2936
|| (hentry->root.type != bfd_link_hash_defined
2937
&& hentry->root.type != bfd_link_hash_defweak))
2940
xcoff_hash_table (info)->gc = false;
2942
/* We still need to call xcoff_mark, in order to set ldrel_count
2944
for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2948
for (o = sub->sections; o != NULL; o = o->next)
2950
if ((o->flags & SEC_MARK) == 0)
2952
if (! xcoff_mark (info, o))
2960
if (! xcoff_mark (info, hentry->root.u.def.section))
2963
xcoff_hash_table (info)->gc = true;
2966
/* Return special sections to the caller. */
2967
for (i = 0; i < XCOFF_NUMBER_OF_SPECIAL_SECTIONS; i++)
2969
sec = xcoff_hash_table (info)->special_sections[i];
2973
&& (sec->flags & SEC_MARK) == 0)
2977
special_sections[i] = sec;
2980
if (info->input_bfds == NULL)
2982
/* I'm not sure what to do in this bizarre case. */
2986
xcoff_link_hash_traverse (xcoff_hash_table (info), xcoff_build_ldsyms,
2991
/* Work out the size of the import file names. Each import file ID
2992
consists of three null terminated strings: the path, the file
2993
name, and the archive member name. The first entry in the list
2994
of names is the path to use to find objects, which the linker has
2995
passed in as the libpath argument. For some reason, the path
2996
entry in the other import file names appears to always be empty. */
2997
impsize = strlen (libpath) + 3;
2999
for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
3002
impsize += (strlen (fl->path)
3004
+ strlen (fl->member)
3008
/* Set up the .loader section header. */
3009
ldhdr = &xcoff_hash_table (info)->ldhdr;
3010
ldhdr->l_version = bfd_xcoff_ldhdr_version(output_bfd);
3011
ldhdr->l_nsyms = ldinfo.ldsym_count;
3012
ldhdr->l_nreloc = xcoff_hash_table (info)->ldrel_count;
3013
ldhdr->l_istlen = impsize;
3014
ldhdr->l_nimpid = impcount;
3015
ldhdr->l_impoff = (bfd_xcoff_ldhdrsz(output_bfd)
3016
+ ldhdr->l_nsyms * bfd_xcoff_ldsymsz(output_bfd)
3017
+ ldhdr->l_nreloc * bfd_xcoff_ldrelsz(output_bfd));
3018
ldhdr->l_stlen = ldinfo.string_size;
3019
stoff = ldhdr->l_impoff + impsize;
3020
if (ldinfo.string_size == 0)
3023
ldhdr->l_stoff = stoff;
3025
/* 64 bit elements to ldhdr
3026
The swap out routine for 32 bit will ignore them.
3027
Nothing fancy, symbols come after the header and relocs come
3029
ldhdr->l_symoff = bfd_xcoff_ldhdrsz (output_bfd);
3030
ldhdr->l_rldoff = (bfd_xcoff_ldhdrsz (output_bfd)
3031
+ ldhdr->l_nsyms * bfd_xcoff_ldsymsz (output_bfd));
3033
/* We now know the final size of the .loader section. Allocate
3035
lsec = xcoff_hash_table (info)->loader_section;
3036
lsec->_raw_size = stoff + ldhdr->l_stlen;
3037
lsec->contents = (bfd_byte *) bfd_zalloc (output_bfd, lsec->_raw_size);
3038
if (lsec->contents == NULL)
3041
/* Set up the header. */
3042
bfd_xcoff_swap_ldhdr_out (output_bfd, ldhdr, lsec->contents);
3044
/* Set up the import file names. */
3045
out = (char *) lsec->contents + ldhdr->l_impoff;
3046
strcpy (out, libpath);
3047
out += strlen (libpath) + 1;
3050
for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
3052
register const char *s;
3055
while ((*out++ = *s++) != '\0')
3058
while ((*out++ = *s++) != '\0')
3061
while ((*out++ = *s++) != '\0')
3065
BFD_ASSERT ((bfd_size_type) ((bfd_byte *) out - lsec->contents) == stoff);
3067
/* Set up the symbol string table. */
3068
if (ldinfo.string_size > 0)
3070
memcpy (out, ldinfo.strings, ldinfo.string_size);
3071
free (ldinfo.strings);
3072
ldinfo.strings = NULL;
3075
/* We can't set up the symbol table or the relocs yet, because we
3076
don't yet know the final position of the various sections. The
3077
.loader symbols are written out when the corresponding normal
3078
symbols are written out in xcoff_link_input_bfd or
3079
xcoff_write_global_symbol. The .loader relocs are written out
3080
when the corresponding normal relocs are handled in
3081
xcoff_link_input_bfd.
3084
/* Allocate space for the magic sections. */
3085
sec = xcoff_hash_table (info)->linkage_section;
3086
if (sec->_raw_size > 0)
3088
sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
3089
if (sec->contents == NULL)
3092
sec = xcoff_hash_table (info)->toc_section;
3093
if (sec->_raw_size > 0)
3095
sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
3096
if (sec->contents == NULL)
3099
sec = xcoff_hash_table (info)->descriptor_section;
3100
if (sec->_raw_size > 0)
3102
sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
3103
if (sec->contents == NULL)
3107
/* Now that we've done garbage collection, figure out the contents
3108
of the .debug section. */
3109
debug_strtab = xcoff_hash_table (info)->debug_strtab;
3111
for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3114
bfd_size_type symcount;
3115
unsigned long *debug_index;
3117
bfd_byte *esym, *esymend;
3118
bfd_size_type symesz;
3120
if (sub->xvec != info->hash->creator)
3122
subdeb = bfd_get_section_by_name (sub, ".debug");
3123
if (subdeb == NULL || subdeb->_raw_size == 0)
3126
if (info->strip == strip_all
3127
|| info->strip == strip_debugger
3128
|| info->discard == discard_all)
3130
subdeb->_raw_size = 0;
3134
if (! _bfd_coff_get_external_symbols (sub))
3137
symcount = obj_raw_syment_count (sub);
3138
debug_index = ((unsigned long *)
3139
bfd_zalloc (sub, symcount * sizeof (unsigned long)));
3140
if (debug_index == NULL)
3142
xcoff_data (sub)->debug_indices = debug_index;
3144
/* Grab the contents of the .debug section. We use malloc and
3145
copy the names into the debug stringtab, rather than
3146
bfd_alloc, because I expect that, when linking many files
3147
together, many of the strings will be the same. Storing the
3148
strings in the hash table should save space in this case. */
3149
debug_contents = (bfd_byte *) bfd_malloc (subdeb->_raw_size);
3150
if (debug_contents == NULL)
3152
if (! bfd_get_section_contents (sub, subdeb, (PTR) debug_contents,
3153
(file_ptr) 0, subdeb->_raw_size))
3156
csectpp = xcoff_data (sub)->csects;
3158
/* Dynamic object do not have csectpp's. */
3159
if (NULL != csectpp)
3161
symesz = bfd_coff_symesz (sub);
3162
esym = (bfd_byte *) obj_coff_external_syms (sub);
3163
esymend = esym + symcount * symesz;
3165
while (esym < esymend)
3167
struct internal_syment sym;
3169
bfd_coff_swap_sym_in (sub, (PTR) esym, (PTR) &sym);
3171
*debug_index = (unsigned long) -1;
3173
if (sym._n._n_n._n_zeroes == 0
3176
|| ((*csectpp)->flags & SEC_MARK) != 0
3177
|| *csectpp == bfd_abs_section_ptr)
3178
&& bfd_coff_symname_in_debug (sub, &sym))
3183
name = (char *) debug_contents + sym._n._n_n._n_offset;
3184
indx = _bfd_stringtab_add (debug_strtab, name, true, true);
3185
if (indx == (bfd_size_type) -1)
3187
*debug_index = indx;
3190
esym += (sym.n_numaux + 1) * symesz;
3191
csectpp += sym.n_numaux + 1;
3192
debug_index += sym.n_numaux + 1;
3196
free (debug_contents);
3197
debug_contents = NULL;
3199
/* Clear the size of subdeb, so that it is not included directly
3200
in the output file. */
3201
subdeb->_raw_size = 0;
3203
if (! info->keep_memory)
3205
if (! _bfd_coff_free_symbols (sub))
3210
if (info->strip != strip_all)
3211
xcoff_hash_table (info)->debug_section->_raw_size =
3212
_bfd_stringtab_size (debug_strtab);
3217
if (ldinfo.strings != NULL)
3218
free (ldinfo.strings);
3219
if (debug_contents != NULL)
3220
free (debug_contents);
3225
bfd_xcoff_link_generate_rtinit (abfd, init, fini, rtld)
3231
struct bfd_in_memory *bim;
3233
bim = ((struct bfd_in_memory *)
3234
bfd_malloc ((bfd_size_type) sizeof (struct bfd_in_memory)));
3241
abfd->link_next = 0;
3242
abfd->format = bfd_object;
3243
abfd->iostream = (PTR) bim;
3244
abfd->flags = BFD_IN_MEMORY;
3245
abfd->direction = write_direction;
3248
if (false == bfd_xcoff_generate_rtinit (abfd, init, fini, rtld))
3251
/* need to reset to unknown or it will not be read back in correctly */
3252
abfd->format = bfd_unknown;
3253
abfd->direction = read_direction;
3260
/* Add a symbol to the .loader symbols, if necessary. */
3263
xcoff_build_ldsyms (h, p)
3264
struct xcoff_link_hash_entry *h;
3267
struct xcoff_loader_info *ldinfo = (struct xcoff_loader_info *) p;
3270
if (h->root.type == bfd_link_hash_warning)
3271
h = (struct xcoff_link_hash_entry *) h->root.u.i.link;
3273
/* __rtinit, this symbol has special handling. */
3274
if (h->flags & XCOFF_RTINIT)
3277
/* If this is a final link, and the symbol was defined as a common
3278
symbol in a regular object file, and there was no definition in
3279
any dynamic object, then the linker will have allocated space for
3280
the symbol in a common section but the XCOFF_DEF_REGULAR flag
3281
will not have been set. */
3282
if (h->root.type == bfd_link_hash_defined
3283
&& (h->flags & XCOFF_DEF_REGULAR) == 0
3284
&& (h->flags & XCOFF_REF_REGULAR) != 0
3285
&& (h->flags & XCOFF_DEF_DYNAMIC) == 0
3286
&& (bfd_is_abs_section (h->root.u.def.section)
3287
|| (h->root.u.def.section->owner->flags & DYNAMIC) == 0))
3288
h->flags |= XCOFF_DEF_REGULAR;
3290
/* If all defined symbols should be exported, mark them now. We
3291
don't want to export the actual functions, just the function
3293
if (ldinfo->export_defineds
3294
&& (h->flags & XCOFF_DEF_REGULAR) != 0
3295
&& h->root.root.string[0] != '.')
3299
/* We don't export a symbol which is being defined by an object
3300
included from an archive which contains a shared object. The
3301
rationale is that if an archive contains both an unshared and
3302
a shared object, then there must be some reason that the
3303
unshared object is unshared, and we don't want to start
3304
providing a shared version of it. In particular, this solves
3305
a bug involving the _savefNN set of functions. gcc will call
3306
those functions without providing a slot to restore the TOC,
3307
so it is essential that these functions be linked in directly
3308
and not from a shared object, which means that a shared
3309
object which also happens to link them in must not export
3310
them. This is confusing, but I haven't been able to think of
3311
a different approach. Note that the symbols can, of course,
3312
be exported explicitly. */
3314
if ((h->root.type == bfd_link_hash_defined
3315
|| h->root.type == bfd_link_hash_defweak)
3316
&& h->root.u.def.section->owner != NULL
3317
&& h->root.u.def.section->owner->my_archive != NULL)
3319
bfd *arbfd, *member;
3321
arbfd = h->root.u.def.section->owner->my_archive;
3322
member = bfd_openr_next_archived_file (arbfd, (bfd *) NULL);
3323
while (member != NULL)
3325
if ((member->flags & DYNAMIC) != 0)
3330
member = bfd_openr_next_archived_file (arbfd, member);
3335
h->flags |= XCOFF_EXPORT;
3338
/* We don't want to garbage collect symbols which are not defined in
3339
XCOFF files. This is a convenient place to mark them. */
3340
if (xcoff_hash_table (ldinfo->info)->gc
3341
&& (h->flags & XCOFF_MARK) == 0
3342
&& (h->root.type == bfd_link_hash_defined
3343
|| h->root.type == bfd_link_hash_defweak)
3344
&& (h->root.u.def.section->owner == NULL
3345
|| (h->root.u.def.section->owner->xvec
3346
!= ldinfo->info->hash->creator)))
3347
h->flags |= XCOFF_MARK;
3349
/* If this symbol is called and defined in a dynamic object, or it
3350
is imported, then we need to set up global linkage code for it.
3351
(Unless we did garbage collection and we didn't need this
3353
if ((h->flags & XCOFF_CALLED) != 0
3354
&& (h->root.type == bfd_link_hash_undefined
3355
|| h->root.type == bfd_link_hash_undefweak)
3356
&& h->root.root.string[0] == '.'
3357
&& h->descriptor != NULL
3358
&& ((h->descriptor->flags & XCOFF_DEF_DYNAMIC) != 0
3359
|| ((h->descriptor->flags & XCOFF_IMPORT) != 0
3360
&& (h->descriptor->flags & XCOFF_DEF_REGULAR) == 0))
3361
&& (! xcoff_hash_table (ldinfo->info)->gc
3362
|| (h->flags & XCOFF_MARK) != 0))
3365
struct xcoff_link_hash_entry *hds;
3367
sec = xcoff_hash_table (ldinfo->info)->linkage_section;
3368
h->root.type = bfd_link_hash_defined;
3369
h->root.u.def.section = sec;
3370
h->root.u.def.value = sec->_raw_size;
3372
h->flags |= XCOFF_DEF_REGULAR;
3373
sec->_raw_size += bfd_xcoff_glink_code_size(ldinfo->output_bfd);
3375
/* The global linkage code requires a TOC entry for the
3377
hds = h->descriptor;
3378
BFD_ASSERT ((hds->root.type == bfd_link_hash_undefined
3379
|| hds->root.type == bfd_link_hash_undefweak)
3380
&& (hds->flags & XCOFF_DEF_REGULAR) == 0);
3381
hds->flags |= XCOFF_MARK;
3382
if (hds->toc_section == NULL)
3387
xcoff32 uses 4 bytes in the toc.
3388
xcoff64 uses 8 bytes in the toc. */
3389
if (bfd_xcoff_is_xcoff64 (ldinfo->output_bfd))
3391
else if (bfd_xcoff_is_xcoff32 (ldinfo->output_bfd))
3396
hds->toc_section = xcoff_hash_table (ldinfo->info)->toc_section;
3397
hds->u.toc_offset = hds->toc_section->_raw_size;
3398
hds->toc_section->_raw_size += byte_size;
3399
++xcoff_hash_table (ldinfo->info)->ldrel_count;
3400
++hds->toc_section->reloc_count;
3402
hds->flags |= XCOFF_SET_TOC | XCOFF_LDREL;
3404
/* We need to call xcoff_build_ldsyms recursively here,
3405
because we may already have passed hds on the traversal. */
3406
xcoff_build_ldsyms (hds, p);
3410
/* If this symbol is exported, but not defined, we need to try to
3412
if ((h->flags & XCOFF_EXPORT) != 0
3413
&& (h->flags & XCOFF_IMPORT) == 0
3414
&& (h->flags & XCOFF_DEF_REGULAR) == 0
3415
&& (h->flags & XCOFF_DEF_DYNAMIC) == 0
3416
&& (h->root.type == bfd_link_hash_undefined
3417
|| h->root.type == bfd_link_hash_undefweak))
3419
if ((h->flags & XCOFF_DESCRIPTOR) != 0
3420
&& (h->descriptor->root.type == bfd_link_hash_defined
3421
|| h->descriptor->root.type == bfd_link_hash_defweak))
3425
/* This is an undefined function descriptor associated with
3426
a defined entry point. We can build up a function
3427
descriptor ourselves. Believe it or not, the AIX linker
3428
actually does this, and there are cases where we need to
3430
sec = xcoff_hash_table (ldinfo->info)->descriptor_section;
3431
h->root.type = bfd_link_hash_defined;
3432
h->root.u.def.section = sec;
3433
h->root.u.def.value = sec->_raw_size;
3435
h->flags |= XCOFF_DEF_REGULAR;
3437
/* The size of the function descriptor depends if this is an
3438
xcoff32 (12) or xcoff64 (24). */
3440
bfd_xcoff_function_descriptor_size(ldinfo->output_bfd);
3442
/* A function descriptor uses two relocs: one for the
3443
associated code, and one for the TOC address. */
3444
xcoff_hash_table (ldinfo->info)->ldrel_count += 2;
3445
sec->reloc_count += 2;
3447
/* We handle writing out the contents of the descriptor in
3448
xcoff_write_global_symbol. */
3452
(*_bfd_error_handler)
3453
(_("warning: attempt to export undefined symbol `%s'"),
3454
h->root.root.string);
3460
/* If this is still a common symbol, and it wasn't garbage
3461
collected, we need to actually allocate space for it in the .bss
3463
if (h->root.type == bfd_link_hash_common
3464
&& (! xcoff_hash_table (ldinfo->info)->gc
3465
|| (h->flags & XCOFF_MARK) != 0)
3466
&& h->root.u.c.p->section->_raw_size == 0)
3468
BFD_ASSERT (bfd_is_com_section (h->root.u.c.p->section));
3469
h->root.u.c.p->section->_raw_size = h->root.u.c.size;
3472
/* We need to add a symbol to the .loader section if it is mentioned
3473
in a reloc which we are copying to the .loader section and it was
3474
not defined or common, or if it is the entry point, or if it is
3477
if (((h->flags & XCOFF_LDREL) == 0
3478
|| h->root.type == bfd_link_hash_defined
3479
|| h->root.type == bfd_link_hash_defweak
3480
|| h->root.type == bfd_link_hash_common)
3481
&& (h->flags & XCOFF_ENTRY) == 0
3482
&& (h->flags & XCOFF_EXPORT) == 0)
3488
/* We don't need to add this symbol if we did garbage collection and
3489
we did not mark this symbol. */
3490
if (xcoff_hash_table (ldinfo->info)->gc
3491
&& (h->flags & XCOFF_MARK) == 0)
3497
/* We may have already processed this symbol due to the recursive
3499
if ((h->flags & XCOFF_BUILT_LDSYM) != 0)
3502
/* We need to add this symbol to the .loader symbols. */
3504
BFD_ASSERT (h->ldsym == NULL);
3505
amt = sizeof (struct internal_ldsym);
3506
h->ldsym = (struct internal_ldsym *) bfd_zalloc (ldinfo->output_bfd, amt);
3507
if (h->ldsym == NULL)
3509
ldinfo->failed = true;
3513
if ((h->flags & XCOFF_IMPORT) != 0)
3514
h->ldsym->l_ifile = h->ldindx;
3516
/* The first 3 symbol table indices are reserved to indicate the
3517
data, text and bss sections. */
3518
h->ldindx = ldinfo->ldsym_count + 3;
3520
++ldinfo->ldsym_count;
3522
if (false == bfd_xcoff_put_ldsymbol_name (ldinfo->output_bfd, ldinfo,
3524
h->root.root.string))
3529
h->flags |= XCOFF_BUILT_LDSYM;
3534
/* Do the final link step. */
3537
_bfd_xcoff_bfd_final_link (abfd, info)
3539
struct bfd_link_info *info;
3541
bfd_size_type symesz;
3542
struct xcoff_final_link_info finfo;
3544
struct bfd_link_order *p;
3545
bfd_size_type max_contents_size;
3546
bfd_size_type max_sym_count;
3547
bfd_size_type max_lineno_count;
3548
bfd_size_type max_reloc_count;
3549
bfd_size_type max_output_reloc_count;
3550
file_ptr rel_filepos;
3552
file_ptr line_filepos;
3553
unsigned int linesz;
3555
bfd_byte *external_relocs = NULL;
3556
char strbuf[STRING_SIZE_SIZE];
3561
abfd->flags |= DYNAMIC;
3563
symesz = bfd_coff_symesz (abfd);
3566
finfo.output_bfd = abfd;
3567
finfo.strtab = NULL;
3568
finfo.section_info = NULL;
3569
finfo.last_file_index = -1;
3570
finfo.toc_symindx = -1;
3571
finfo.internal_syms = NULL;
3572
finfo.sym_indices = NULL;
3573
finfo.outsyms = NULL;
3574
finfo.linenos = NULL;
3575
finfo.contents = NULL;
3576
finfo.external_relocs = NULL;
3578
finfo.ldsym = (xcoff_hash_table (info)->loader_section->contents
3579
+ bfd_xcoff_ldhdrsz (abfd));
3580
finfo.ldrel = (xcoff_hash_table (info)->loader_section->contents
3581
+ bfd_xcoff_ldhdrsz(abfd)
3582
+ (xcoff_hash_table (info)->ldhdr.l_nsyms
3583
* bfd_xcoff_ldsymsz(abfd)));
3585
xcoff_data (abfd)->coff.link_info = info;
3587
finfo.strtab = _bfd_stringtab_init ();
3588
if (finfo.strtab == NULL)
3591
/* Count the line number and relocation entries required for the
3592
output file. Determine a few maximum sizes. */
3593
max_contents_size = 0;
3594
max_lineno_count = 0;
3595
max_reloc_count = 0;
3596
for (o = abfd->sections; o != NULL; o = o->next)
3599
o->lineno_count = 0;
3600
for (p = o->link_order_head; p != NULL; p = p->next)
3602
if (p->type == bfd_indirect_link_order)
3606
sec = p->u.indirect.section;
3608
/* Mark all sections which are to be included in the
3609
link. This will normally be every section. We need
3610
to do this so that we can identify any sections which
3611
the linker has decided to not include. */
3612
sec->linker_mark = true;
3614
if (info->strip == strip_none
3615
|| info->strip == strip_some)
3616
o->lineno_count += sec->lineno_count;
3618
o->reloc_count += sec->reloc_count;
3620
if (sec->_raw_size > max_contents_size)
3621
max_contents_size = sec->_raw_size;
3622
if (sec->lineno_count > max_lineno_count)
3623
max_lineno_count = sec->lineno_count;
3624
if (coff_section_data (sec->owner, sec) != NULL
3625
&& xcoff_section_data (sec->owner, sec) != NULL
3626
&& (xcoff_section_data (sec->owner, sec)->lineno_count
3627
> max_lineno_count))
3629
xcoff_section_data (sec->owner, sec)->lineno_count;
3630
if (sec->reloc_count > max_reloc_count)
3631
max_reloc_count = sec->reloc_count;
3633
else if (p->type == bfd_section_reloc_link_order
3634
|| p->type == bfd_symbol_reloc_link_order)
3639
/* Compute the file positions for all the sections. */
3640
if (abfd->output_has_begun)
3642
if (xcoff_hash_table (info)->file_align != 0)
3649
file_align = xcoff_hash_table (info)->file_align;
3650
if (file_align != 0)
3652
boolean saw_contents;
3657
/* Insert .pad sections before every section which has
3658
contents and is loaded, if it is preceded by some other
3659
section which has contents and is loaded. */
3660
saw_contents = true;
3661
for (op = &abfd->sections; *op != NULL; op = &(*op)->next)
3663
if (strcmp ((*op)->name, ".pad") == 0)
3664
saw_contents = false;
3665
else if (((*op)->flags & SEC_HAS_CONTENTS) != 0
3666
&& ((*op)->flags & SEC_LOAD) != 0)
3669
saw_contents = true;
3674
/* Create a pad section and place it before the section
3675
that needs padding. This requires unlinking and
3676
relinking the bfd's section list. */
3678
st = abfd->section_tail;
3679
n = bfd_make_section_anyway (abfd, ".pad");
3680
n->flags = SEC_HAS_CONTENTS;
3681
n->alignment_power = 0;
3683
BFD_ASSERT (*st == n);
3684
bfd_section_list_remove (abfd, st);
3685
bfd_section_list_insert (abfd, op, n);
3688
saw_contents = false;
3693
/* Reset the section indices after inserting the new
3696
for (o = abfd->sections; o != NULL; o = o->next)
3699
o->target_index = indx;
3701
BFD_ASSERT ((unsigned int) indx == abfd->section_count);
3703
/* Work out appropriate sizes for the .pad sections to force
3704
each section to land on a page boundary. This bit of
3705
code knows what compute_section_file_positions is going
3707
sofar = bfd_coff_filhsz (abfd);
3708
sofar += bfd_coff_aoutsz (abfd);
3709
sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
3710
for (o = abfd->sections; o != NULL; o = o->next)
3711
if ((bfd_xcoff_is_reloc_count_overflow
3712
(abfd, (bfd_vma) o->reloc_count))
3713
|| (bfd_xcoff_is_lineno_count_overflow
3714
(abfd, (bfd_vma) o->lineno_count)))
3715
/* 64 does not overflow, need to check if 32 does */
3716
sofar += bfd_coff_scnhsz (abfd);
3718
for (o = abfd->sections; o != NULL; o = o->next)
3720
if (strcmp (o->name, ".pad") == 0)
3724
BFD_ASSERT (o->_raw_size == 0);
3725
pageoff = sofar & (file_align - 1);
3728
o->_raw_size = file_align - pageoff;
3729
sofar += file_align - pageoff;
3730
o->flags |= SEC_HAS_CONTENTS;
3735
if ((o->flags & SEC_HAS_CONTENTS) != 0)
3736
sofar += BFD_ALIGN (o->_raw_size,
3737
1 << o->alignment_power);
3742
if (! bfd_coff_compute_section_file_positions (abfd))
3746
/* Allocate space for the pointers we need to keep for the relocs. */
3750
/* We use section_count + 1, rather than section_count, because
3751
the target_index fields are 1 based. */
3752
amt = abfd->section_count + 1;
3753
amt *= sizeof (struct xcoff_link_section_info);
3754
finfo.section_info = (struct xcoff_link_section_info *) bfd_malloc (amt);
3755
if (finfo.section_info == NULL)
3757
for (i = 0; i <= abfd->section_count; i++)
3759
finfo.section_info[i].relocs = NULL;
3760
finfo.section_info[i].rel_hashes = NULL;
3761
finfo.section_info[i].toc_rel_hashes = NULL;
3765
/* Set the file positions for the relocs. */
3766
rel_filepos = obj_relocbase (abfd);
3767
relsz = bfd_coff_relsz (abfd);
3768
max_output_reloc_count = 0;
3769
for (o = abfd->sections; o != NULL; o = o->next)
3771
if (o->reloc_count == 0)
3775
/* A stripped file has no relocs. However, we still
3776
allocate the buffers, so that later code doesn't have to
3777
worry about whether we are stripping or not. */
3778
if (info->strip == strip_all)
3782
o->flags |= SEC_RELOC;
3783
o->rel_filepos = rel_filepos;
3784
rel_filepos += o->reloc_count * relsz;
3787
/* We don't know the indices of global symbols until we have
3788
written out all the local symbols. For each section in
3789
the output file, we keep an array of pointers to hash
3790
table entries. Each entry in the array corresponds to a
3791
reloc. When we find a reloc against a global symbol, we
3792
set the corresponding entry in this array so that we can
3793
fix up the symbol index after we have written out all the
3796
Because of this problem, we also keep the relocs in
3797
memory until the end of the link. This wastes memory.
3798
We could backpatch the file later, I suppose, although it
3800
amt = o->reloc_count;
3801
amt *= sizeof (struct internal_reloc);
3802
finfo.section_info[o->target_index].relocs =
3803
(struct internal_reloc *) bfd_malloc (amt);
3805
amt = o->reloc_count;
3806
amt *= sizeof (struct xcoff_link_hash_entry *);
3807
finfo.section_info[o->target_index].rel_hashes =
3808
(struct xcoff_link_hash_entry **) bfd_malloc (amt);
3810
if (finfo.section_info[o->target_index].relocs == NULL
3811
|| finfo.section_info[o->target_index].rel_hashes == NULL)
3814
if (o->reloc_count > max_output_reloc_count)
3815
max_output_reloc_count = o->reloc_count;
3819
/* We now know the size of the relocs, so we can determine the file
3820
positions of the line numbers. */
3821
line_filepos = rel_filepos;
3822
finfo.line_filepos = line_filepos;
3823
linesz = bfd_coff_linesz (abfd);
3824
for (o = abfd->sections; o != NULL; o = o->next)
3826
if (o->lineno_count == 0)
3827
o->line_filepos = 0;
3830
o->line_filepos = line_filepos;
3831
line_filepos += o->lineno_count * linesz;
3834
/* Reset the reloc and lineno counts, so that we can use them to
3835
count the number of entries we have output so far. */
3837
o->lineno_count = 0;
3840
obj_sym_filepos (abfd) = line_filepos;
3842
/* Figure out the largest number of symbols in an input BFD. Take
3843
the opportunity to clear the output_has_begun fields of all the
3844
input BFD's. We want at least 6 symbols, since that is the
3845
number which xcoff_write_global_symbol may need. */
3847
for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3851
sub->output_has_begun = false;
3852
sz = obj_raw_syment_count (sub);
3853
if (sz > max_sym_count)
3857
/* Allocate some buffers used while linking. */
3858
amt = max_sym_count * sizeof (struct internal_syment);
3859
finfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
3861
amt = max_sym_count * sizeof (long);
3862
finfo.sym_indices = (long *) bfd_malloc (amt);
3864
amt = (max_sym_count + 1) * symesz;
3865
finfo.outsyms = (bfd_byte *) bfd_malloc (amt);
3867
amt = max_lineno_count * bfd_coff_linesz (abfd);
3868
finfo.linenos = (bfd_byte *) bfd_malloc (amt);
3870
amt = max_contents_size;
3871
finfo.contents = (bfd_byte *) bfd_malloc (amt);
3873
amt = max_reloc_count * relsz;
3874
finfo.external_relocs = (bfd_byte *) bfd_malloc (amt);
3876
if ((finfo.internal_syms == NULL && max_sym_count > 0)
3877
|| (finfo.sym_indices == NULL && max_sym_count > 0)
3878
|| finfo.outsyms == NULL
3879
|| (finfo.linenos == NULL && max_lineno_count > 0)
3880
|| (finfo.contents == NULL && max_contents_size > 0)
3881
|| (finfo.external_relocs == NULL && max_reloc_count > 0))
3884
obj_raw_syment_count (abfd) = 0;
3885
xcoff_data (abfd)->toc = (bfd_vma) -1;
3887
/* We now know the position of everything in the file, except that
3888
we don't know the size of the symbol table and therefore we don't
3889
know where the string table starts. We just build the string
3890
table in memory as we go along. We process all the relocations
3891
for a single input file at once. */
3892
for (o = abfd->sections; o != NULL; o = o->next)
3894
for (p = o->link_order_head; p != NULL; p = p->next)
3896
if (p->type == bfd_indirect_link_order
3897
&& p->u.indirect.section->owner->xvec == abfd->xvec)
3899
sub = p->u.indirect.section->owner;
3900
if (! sub->output_has_begun)
3902
if (! xcoff_link_input_bfd (&finfo, sub))
3904
sub->output_has_begun = true;
3907
else if (p->type == bfd_section_reloc_link_order
3908
|| p->type == bfd_symbol_reloc_link_order)
3910
if (! xcoff_reloc_link_order (abfd, &finfo, o, p))
3915
if (! _bfd_default_link_order (abfd, info, o, p))
3922
/* Free up the buffers used by xcoff_link_input_bfd. */
3924
if (finfo.internal_syms != NULL)
3926
free (finfo.internal_syms);
3927
finfo.internal_syms = NULL;
3929
if (finfo.sym_indices != NULL)
3931
free (finfo.sym_indices);
3932
finfo.sym_indices = NULL;
3934
if (finfo.linenos != NULL)
3936
free (finfo.linenos);
3937
finfo.linenos = NULL;
3939
if (finfo.contents != NULL)
3941
free (finfo.contents);
3942
finfo.contents = NULL;
3944
if (finfo.external_relocs != NULL)
3946
free (finfo.external_relocs);
3947
finfo.external_relocs = NULL;
3950
/* The value of the last C_FILE symbol is supposed to be -1. Write
3952
if (finfo.last_file_index != -1)
3954
finfo.last_file.n_value = -(bfd_vma) 1;
3955
bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
3956
(PTR) finfo.outsyms);
3957
pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
3958
if (bfd_seek (abfd, pos, SEEK_SET) != 0
3959
|| bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
3963
/* Write out all the global symbols which do not come from XCOFF
3965
xcoff_link_hash_traverse (xcoff_hash_table (info),
3966
xcoff_write_global_symbol,
3969
if (finfo.outsyms != NULL)
3971
free (finfo.outsyms);
3972
finfo.outsyms = NULL;
3975
/* Now that we have written out all the global symbols, we know the
3976
symbol indices to use for relocs against them, and we can finally
3977
write out the relocs. */
3978
amt = max_output_reloc_count * relsz;
3979
external_relocs = (bfd_byte *) bfd_malloc (amt);
3980
if (external_relocs == NULL && max_output_reloc_count != 0)
3983
for (o = abfd->sections; o != NULL; o = o->next)
3985
struct internal_reloc *irel;
3986
struct internal_reloc *irelend;
3987
struct xcoff_link_hash_entry **rel_hash;
3988
struct xcoff_toc_rel_hash *toc_rel_hash;
3990
bfd_size_type rel_size;
3992
/* A stripped file has no relocs. */
3993
if (info->strip == strip_all)
3999
if (o->reloc_count == 0)
4002
irel = finfo.section_info[o->target_index].relocs;
4003
irelend = irel + o->reloc_count;
4004
rel_hash = finfo.section_info[o->target_index].rel_hashes;
4005
for (; irel < irelend; irel++, rel_hash++, erel += relsz)
4007
if (*rel_hash != NULL)
4009
if ((*rel_hash)->indx < 0)
4011
if (! ((*info->callbacks->unattached_reloc)
4012
(info, (*rel_hash)->root.root.string,
4013
(bfd *) NULL, o, irel->r_vaddr)))
4015
(*rel_hash)->indx = 0;
4017
irel->r_symndx = (*rel_hash)->indx;
4021
for (toc_rel_hash = finfo.section_info[o->target_index].toc_rel_hashes;
4022
toc_rel_hash != NULL;
4023
toc_rel_hash = toc_rel_hash->next)
4025
if (toc_rel_hash->h->u.toc_indx < 0)
4027
if (! ((*info->callbacks->unattached_reloc)
4028
(info, toc_rel_hash->h->root.root.string,
4029
(bfd *) NULL, o, toc_rel_hash->rel->r_vaddr)))
4031
toc_rel_hash->h->u.toc_indx = 0;
4033
toc_rel_hash->rel->r_symndx = toc_rel_hash->h->u.toc_indx;
4036
/* XCOFF requires that the relocs be sorted by address. We tend
4037
to produce them in the order in which their containing csects
4038
appear in the symbol table, which is not necessarily by
4039
address. So we sort them here. There may be a better way to
4041
qsort ((PTR) finfo.section_info[o->target_index].relocs,
4042
o->reloc_count, sizeof (struct internal_reloc),
4045
irel = finfo.section_info[o->target_index].relocs;
4046
irelend = irel + o->reloc_count;
4047
erel = external_relocs;
4048
for (; irel < irelend; irel++, rel_hash++, erel += relsz)
4049
bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
4051
rel_size = relsz * o->reloc_count;
4052
if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
4053
|| bfd_bwrite ((PTR) external_relocs, rel_size, abfd) != rel_size)
4057
if (external_relocs != NULL)
4059
free (external_relocs);
4060
external_relocs = NULL;
4063
/* Free up the section information. */
4064
if (finfo.section_info != NULL)
4068
for (i = 0; i < abfd->section_count; i++)
4070
if (finfo.section_info[i].relocs != NULL)
4071
free (finfo.section_info[i].relocs);
4072
if (finfo.section_info[i].rel_hashes != NULL)
4073
free (finfo.section_info[i].rel_hashes);
4075
free (finfo.section_info);
4076
finfo.section_info = NULL;
4079
/* Write out the loader section contents. */
4080
BFD_ASSERT ((bfd_byte *) finfo.ldrel
4081
== (xcoff_hash_table (info)->loader_section->contents
4082
+ xcoff_hash_table (info)->ldhdr.l_impoff));
4083
o = xcoff_hash_table (info)->loader_section;
4084
if (! bfd_set_section_contents (abfd, o->output_section, o->contents,
4085
(file_ptr) o->output_offset, o->_raw_size))
4088
/* Write out the magic sections. */
4089
o = xcoff_hash_table (info)->linkage_section;
4090
if (o->_raw_size > 0
4091
&& ! bfd_set_section_contents (abfd, o->output_section, o->contents,
4092
(file_ptr) o->output_offset,
4095
o = xcoff_hash_table (info)->toc_section;
4096
if (o->_raw_size > 0
4097
&& ! bfd_set_section_contents (abfd, o->output_section, o->contents,
4098
(file_ptr) o->output_offset,
4101
o = xcoff_hash_table (info)->descriptor_section;
4102
if (o->_raw_size > 0
4103
&& ! bfd_set_section_contents (abfd, o->output_section, o->contents,
4104
(file_ptr) o->output_offset,
4108
/* Write out the string table. */
4109
pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
4110
if (bfd_seek (abfd, pos, SEEK_SET) != 0)
4113
_bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
4115
amt = STRING_SIZE_SIZE;
4116
if (bfd_bwrite (strbuf, amt, abfd) != amt)
4118
if (! _bfd_stringtab_emit (abfd, finfo.strtab))
4121
_bfd_stringtab_free (finfo.strtab);
4123
/* Write out the debugging string table. */
4124
o = xcoff_hash_table (info)->debug_section;
4127
struct bfd_strtab_hash *debug_strtab;
4129
debug_strtab = xcoff_hash_table (info)->debug_strtab;
4130
BFD_ASSERT (o->output_section->_raw_size - o->output_offset
4131
>= _bfd_stringtab_size (debug_strtab));
4132
pos = o->output_section->filepos + o->output_offset;
4133
if (bfd_seek (abfd, pos, SEEK_SET) != 0)
4135
if (! _bfd_stringtab_emit (abfd, debug_strtab))
4139
/* Setting bfd_get_symcount to 0 will cause write_object_contents to
4140
not try to write out the symbols. */
4141
bfd_get_symcount (abfd) = 0;
4146
if (finfo.strtab != NULL)
4147
_bfd_stringtab_free (finfo.strtab);
4149
if (finfo.section_info != NULL)
4153
for (i = 0; i < abfd->section_count; i++)
4155
if (finfo.section_info[i].relocs != NULL)
4156
free (finfo.section_info[i].relocs);
4157
if (finfo.section_info[i].rel_hashes != NULL)
4158
free (finfo.section_info[i].rel_hashes);
4160
free (finfo.section_info);
4163
if (finfo.internal_syms != NULL)
4164
free (finfo.internal_syms);
4165
if (finfo.sym_indices != NULL)
4166
free (finfo.sym_indices);
4167
if (finfo.outsyms != NULL)
4168
free (finfo.outsyms);
4169
if (finfo.linenos != NULL)
4170
free (finfo.linenos);
4171
if (finfo.contents != NULL)
4172
free (finfo.contents);
4173
if (finfo.external_relocs != NULL)
4174
free (finfo.external_relocs);
4175
if (external_relocs != NULL)
4176
free (external_relocs);
4180
/* Link an input file into the linker output file. This function
4181
handles all the sections and relocations of the input file at once. */
4184
xcoff_link_input_bfd (finfo, input_bfd)
4185
struct xcoff_final_link_info *finfo;
4189
const char *strings;
4190
bfd_size_type syment_base;
4191
unsigned int n_tmask;
4192
unsigned int n_btshft;
4194
bfd_size_type isymesz;
4195
bfd_size_type osymesz;
4196
bfd_size_type linesz;
4199
struct xcoff_link_hash_entry **sym_hash;
4200
struct internal_syment *isymp;
4202
unsigned long *debug_index;
4204
unsigned long output_index;
4211
/* We can just skip DYNAMIC files, unless this is a static link. */
4212
if ((input_bfd->flags & DYNAMIC) != 0
4213
&& ! finfo->info->static_link)
4216
/* Move all the symbols to the output file. */
4218
output_bfd = finfo->output_bfd;
4220
syment_base = obj_raw_syment_count (output_bfd);
4221
isymesz = bfd_coff_symesz (input_bfd);
4222
osymesz = bfd_coff_symesz (output_bfd);
4223
linesz = bfd_coff_linesz (input_bfd);
4224
BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
4226
n_tmask = coff_data (input_bfd)->local_n_tmask;
4227
n_btshft = coff_data (input_bfd)->local_n_btshft;
4229
/* Define macros so that ISFCN, et. al., macros work correctly. */
4230
#define N_TMASK n_tmask
4231
#define N_BTSHFT n_btshft
4234
if (! finfo->info->keep_memory)
4237
if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
4240
if (! _bfd_coff_get_external_symbols (input_bfd))
4243
esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
4244
esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
4245
sym_hash = obj_xcoff_sym_hashes (input_bfd);
4246
csectpp = xcoff_data (input_bfd)->csects;
4247
debug_index = xcoff_data (input_bfd)->debug_indices;
4248
isymp = finfo->internal_syms;
4249
indexp = finfo->sym_indices;
4250
output_index = syment_base;
4251
outsym = finfo->outsyms;
4255
while (esym < esym_end)
4258
struct internal_syment isym;
4259
union internal_auxent aux;
4265
bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
4267
/* If this is a C_EXT or C_HIDEXT symbol, we need the csect
4269
if (isymp->n_sclass == C_EXT || isymp->n_sclass == C_HIDEXT)
4271
BFD_ASSERT (isymp->n_numaux > 0);
4272
bfd_coff_swap_aux_in (input_bfd,
4273
(PTR) (esym + isymesz * isymp->n_numaux),
4274
isymp->n_type, isymp->n_sclass,
4275
isymp->n_numaux - 1, isymp->n_numaux,
4278
smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
4281
/* Make a copy of *isymp so that the relocate_section function
4282
always sees the original values. This is more reliable than
4283
always recomputing the symbol value even if we are stripping
4287
/* If this symbol is in the .loader section, swap out the
4288
.loader symbol information. If this is an external symbol
4289
reference to a defined symbol, though, then wait until we get
4290
to the definition. */
4291
if (isym.n_sclass == C_EXT
4292
&& *sym_hash != NULL
4293
&& (*sym_hash)->ldsym != NULL
4295
|| (*sym_hash)->root.type == bfd_link_hash_undefined))
4297
struct xcoff_link_hash_entry *h;
4298
struct internal_ldsym *ldsym;
4302
if (isym.n_scnum > 0)
4304
ldsym->l_scnum = (*csectpp)->output_section->target_index;
4305
ldsym->l_value = (isym.n_value
4306
+ (*csectpp)->output_section->vma
4307
+ (*csectpp)->output_offset
4312
ldsym->l_scnum = isym.n_scnum;
4313
ldsym->l_value = isym.n_value;
4316
ldsym->l_smtype = smtyp;
4317
if (((h->flags & XCOFF_DEF_REGULAR) == 0
4318
&& (h->flags & XCOFF_DEF_DYNAMIC) != 0)
4319
|| (h->flags & XCOFF_IMPORT) != 0)
4320
ldsym->l_smtype |= L_IMPORT;
4321
if (((h->flags & XCOFF_DEF_REGULAR) != 0
4322
&& (h->flags & XCOFF_DEF_DYNAMIC) != 0)
4323
|| (h->flags & XCOFF_EXPORT) != 0)
4324
ldsym->l_smtype |= L_EXPORT;
4325
if ((h->flags & XCOFF_ENTRY) != 0)
4326
ldsym->l_smtype |= L_ENTRY;
4328
ldsym->l_smclas = aux.x_csect.x_smclas;
4330
if (ldsym->l_ifile == (bfd_size_type) -1)
4332
else if (ldsym->l_ifile == 0)
4334
if ((ldsym->l_smtype & L_IMPORT) == 0)
4340
if (h->root.type == bfd_link_hash_defined
4341
|| h->root.type == bfd_link_hash_defweak)
4342
impbfd = h->root.u.def.section->owner;
4343
else if (h->root.type == bfd_link_hash_undefined
4344
|| h->root.type == bfd_link_hash_undefweak)
4345
impbfd = h->root.u.undef.abfd;
4353
BFD_ASSERT (impbfd->xvec == finfo->output_bfd->xvec);
4354
ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
4361
BFD_ASSERT (h->ldindx >= 0);
4362
bfd_xcoff_swap_ldsym_out (finfo->output_bfd, ldsym,
4365
* bfd_xcoff_ldsymsz (finfo->output_bfd))));
4368
/* Fill in snentry now that we know the target_index. */
4369
if ((h->flags & XCOFF_ENTRY) != 0
4370
&& (h->root.type == bfd_link_hash_defined
4371
|| h->root.type == bfd_link_hash_defweak))
4373
xcoff_data (output_bfd)->snentry =
4374
h->root.u.def.section->output_section->target_index;
4382
add = 1 + isym.n_numaux;
4384
/* If we are skipping this csect, we want to skip this symbol. */
4385
if (*csectpp == NULL)
4388
/* If we garbage collected this csect, we want to skip this
4391
&& xcoff_hash_table (finfo->info)->gc
4392
&& ((*csectpp)->flags & SEC_MARK) == 0
4393
&& *csectpp != bfd_abs_section_ptr)
4396
/* An XCOFF linker always skips C_STAT symbols. */
4398
&& isymp->n_sclass == C_STAT)
4401
/* We skip all but the first TOC anchor. */
4403
&& isymp->n_sclass == C_HIDEXT
4404
&& aux.x_csect.x_smclas == XMC_TC0)
4406
if (finfo->toc_symindx != -1)
4410
bfd_vma tocval, tocend;
4413
tocval = ((*csectpp)->output_section->vma
4414
+ (*csectpp)->output_offset
4418
/* We want to find out if tocval is a good value to use
4419
as the TOC anchor--that is, whether we can access all
4420
of the TOC using a 16 bit offset from tocval. This
4421
test assumes that the TOC comes at the end of the
4422
output section, as it does in the default linker
4424
tocend = ((*csectpp)->output_section->vma
4425
+ (*csectpp)->output_section->_raw_size);
4426
for (inp = finfo->info->input_bfds;
4428
inp = inp->link_next)
4431
for (o = inp->sections; o != NULL; o = o->next)
4432
if (strcmp (o->name, ".tocbss") == 0)
4434
bfd_vma new_toc_end;
4435
new_toc_end = (o->output_section->vma
4438
if (new_toc_end > tocend)
4439
tocend = new_toc_end;
4444
if (tocval + 0x10000 < tocend)
4446
(*_bfd_error_handler)
4447
(_("TOC overflow: 0x%lx > 0x10000; try -mminimal-toc when compiling"),
4448
(unsigned long) (tocend - tocval));
4449
bfd_set_error (bfd_error_file_too_big);
4453
if (tocval + 0x8000 < tocend)
4457
tocadd = tocend - (tocval + 0x8000);
4459
isym.n_value += tocadd;
4462
finfo->toc_symindx = output_index;
4463
xcoff_data (finfo->output_bfd)->toc = tocval;
4464
xcoff_data (finfo->output_bfd)->sntoc =
4465
(*csectpp)->output_section->target_index;
4471
/* If we are stripping all symbols, we want to skip this one. */
4473
&& finfo->info->strip == strip_all)
4476
/* We can skip resolved external references. */
4478
&& isym.n_sclass == C_EXT
4480
&& (*sym_hash)->root.type != bfd_link_hash_undefined)
4483
/* We can skip common symbols if they got defined somewhere
4486
&& isym.n_sclass == C_EXT
4488
&& ((*sym_hash)->root.type != bfd_link_hash_common
4489
|| (*sym_hash)->root.u.c.p->section != *csectpp)
4490
&& ((*sym_hash)->root.type != bfd_link_hash_defined
4491
|| (*sym_hash)->root.u.def.section != *csectpp))
4494
/* Skip local symbols if we are discarding them. */
4496
&& finfo->info->discard == discard_all
4497
&& isym.n_sclass != C_EXT
4498
&& (isym.n_sclass != C_HIDEXT
4499
|| smtyp != XTY_SD))
4502
/* If we stripping debugging symbols, and this is a debugging
4503
symbol, then skip it. */
4505
&& finfo->info->strip == strip_debugger
4506
&& isym.n_scnum == N_DEBUG)
4509
/* If some symbols are stripped based on the name, work out the
4510
name and decide whether to skip this symbol. We don't handle
4511
this correctly for symbols whose names are in the .debug
4512
section; to get it right we would need a new bfd_strtab_hash
4513
function to return the string given the index. */
4515
&& (finfo->info->strip == strip_some
4516
|| finfo->info->discard == discard_l)
4517
&& (debug_index == NULL || *debug_index == (unsigned long) -1))
4520
char buf[SYMNMLEN + 1];
4522
name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
4527
if ((finfo->info->strip == strip_some
4528
&& (bfd_hash_lookup (finfo->info->keep_hash, name, false,
4530
|| (finfo->info->discard == discard_l
4531
&& (isym.n_sclass != C_EXT
4532
&& (isym.n_sclass != C_HIDEXT
4533
|| smtyp != XTY_SD))
4534
&& bfd_is_local_label_name (input_bfd, name)))
4538
/* We can not skip the first TOC anchor. */
4541
&& finfo->info->strip != strip_all)
4544
/* We now know whether we are to skip this symbol or not. */
4547
/* Adjust the symbol in order to output it. */
4549
if (isym._n._n_n._n_zeroes == 0
4550
&& isym._n._n_n._n_offset != 0)
4552
/* This symbol has a long name. Enter it in the string
4553
table we are building. If *debug_index != -1, the
4554
name has already been entered in the .debug section. */
4555
if (debug_index != NULL && *debug_index != (unsigned long) -1)
4556
isym._n._n_n._n_offset = *debug_index;
4562
name = _bfd_coff_internal_syment_name (input_bfd, &isym,
4567
indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
4568
if (indx == (bfd_size_type) -1)
4570
isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
4574
if (isym.n_sclass != C_BSTAT
4575
&& isym.n_sclass != C_ESTAT
4576
&& isym.n_sclass != C_DECL
4577
&& isym.n_scnum > 0)
4579
isym.n_scnum = (*csectpp)->output_section->target_index;
4580
isym.n_value += ((*csectpp)->output_section->vma
4581
+ (*csectpp)->output_offset
4585
/* The value of a C_FILE symbol is the symbol index of the
4586
next C_FILE symbol. The value of the last C_FILE symbol
4587
is -1. We try to get this right, below, just before we
4588
write the symbols out, but in the general case we may
4589
have to write the symbol out twice. */
4590
if (isym.n_sclass == C_FILE)
4592
if (finfo->last_file_index != -1
4593
&& finfo->last_file.n_value != (bfd_vma) output_index)
4595
/* We must correct the value of the last C_FILE entry. */
4596
finfo->last_file.n_value = output_index;
4597
if ((bfd_size_type) finfo->last_file_index >= syment_base)
4599
/* The last C_FILE symbol is in this input file. */
4600
bfd_coff_swap_sym_out (output_bfd,
4601
(PTR) &finfo->last_file,
4602
(PTR) (finfo->outsyms
4603
+ ((finfo->last_file_index
4609
/* We have already written out the last C_FILE
4610
symbol. We need to write it out again. We
4611
borrow *outsym temporarily. */
4614
bfd_coff_swap_sym_out (output_bfd,
4615
(PTR) &finfo->last_file,
4618
pos = obj_sym_filepos (output_bfd);
4619
pos += finfo->last_file_index * osymesz;
4620
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
4621
|| (bfd_bwrite (outsym, osymesz, output_bfd)
4627
finfo->last_file_index = output_index;
4628
finfo->last_file = isym;
4631
/* The value of a C_BINCL or C_EINCL symbol is a file offset
4632
into the line numbers. We update the symbol values when
4633
we handle the line numbers. */
4634
if (isym.n_sclass == C_BINCL
4635
|| isym.n_sclass == C_EINCL)
4637
isym.n_value = finfo->line_filepos;
4641
/* Output the symbol. */
4643
bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
4645
*indexp = output_index;
4647
if (isym.n_sclass == C_EXT)
4650
struct xcoff_link_hash_entry *h;
4652
indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
4654
h = obj_xcoff_sym_hashes (input_bfd)[indx];
4655
BFD_ASSERT (h != NULL);
4656
h->indx = output_index;
4659
/* If this is a symbol in the TOC which we may have merged
4660
(class XMC_TC), remember the symbol index of the TOC
4662
if (isym.n_sclass == C_HIDEXT
4663
&& aux.x_csect.x_smclas == XMC_TC
4664
&& *sym_hash != NULL)
4666
BFD_ASSERT (((*sym_hash)->flags & XCOFF_SET_TOC) == 0);
4667
BFD_ASSERT ((*sym_hash)->toc_section != NULL);
4668
(*sym_hash)->u.toc_indx = output_index;
4671
output_index += add;
4672
outsym += add * osymesz;
4675
esym += add * isymesz;
4679
if (debug_index != NULL)
4682
for (--add; add > 0; --add)
4686
/* Fix up the aux entries and the C_BSTAT symbols. This must be
4687
done in a separate pass, because we don't know the correct symbol
4688
indices until we have already decided which symbols we are going
4691
esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
4692
esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
4693
isymp = finfo->internal_syms;
4694
indexp = finfo->sym_indices;
4695
csectpp = xcoff_data (input_bfd)->csects;
4696
outsym = finfo->outsyms;
4697
while (esym < esym_end)
4701
add = 1 + isymp->n_numaux;
4704
esym += add * isymesz;
4709
if (isymp->n_sclass == C_BSTAT)
4711
struct internal_syment isym;
4715
/* The value of a C_BSTAT symbol is the symbol table
4716
index of the containing csect. */
4717
bfd_coff_swap_sym_in (output_bfd, (PTR) outsym, (PTR) &isym);
4718
indx = isym.n_value;
4719
if (indx < obj_raw_syment_count (input_bfd))
4723
symindx = finfo->sym_indices[indx];
4727
isym.n_value = symindx;
4728
bfd_coff_swap_sym_out (output_bfd, (PTR) &isym,
4736
for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
4738
union internal_auxent aux;
4740
bfd_coff_swap_aux_in (input_bfd, (PTR) esym, isymp->n_type,
4741
isymp->n_sclass, i, isymp->n_numaux,
4744
if (isymp->n_sclass == C_FILE)
4746
/* This is the file name (or some comment put in by
4747
the compiler). If it is long, we must put it in
4748
the string table. */
4749
if (aux.x_file.x_n.x_zeroes == 0
4750
&& aux.x_file.x_n.x_offset != 0)
4752
const char *filename;
4755
BFD_ASSERT (aux.x_file.x_n.x_offset
4756
>= STRING_SIZE_SIZE);
4757
if (strings == NULL)
4759
strings = _bfd_coff_read_string_table (input_bfd);
4760
if (strings == NULL)
4763
filename = strings + aux.x_file.x_n.x_offset;
4764
indx = _bfd_stringtab_add (finfo->strtab, filename,
4766
if (indx == (bfd_size_type) -1)
4768
aux.x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
4771
else if ((isymp->n_sclass == C_EXT
4772
|| isymp->n_sclass == C_HIDEXT)
4773
&& i + 1 == isymp->n_numaux)
4776
/* We don't support type checking. I don't know if
4778
aux.x_csect.x_parmhash = 0;
4779
/* I don't think anybody uses these fields, but we'd
4780
better clobber them just in case. */
4781
aux.x_csect.x_stab = 0;
4782
aux.x_csect.x_snstab = 0;
4784
if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_LD)
4788
indx = aux.x_csect.x_scnlen.l;
4789
if (indx < obj_raw_syment_count (input_bfd))
4793
symindx = finfo->sym_indices[indx];
4796
aux.x_csect.x_scnlen.l = 0;
4800
aux.x_csect.x_scnlen.l = symindx;
4805
else if (isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
4809
if (ISFCN (isymp->n_type)
4810
|| ISTAG (isymp->n_sclass)
4811
|| isymp->n_sclass == C_BLOCK
4812
|| isymp->n_sclass == C_FCN)
4814
indx = aux.x_sym.x_fcnary.x_fcn.x_endndx.l;
4816
&& indx < obj_raw_syment_count (input_bfd))
4818
/* We look forward through the symbol for
4819
the index of the next symbol we are going
4820
to include. I don't know if this is
4822
while (finfo->sym_indices[indx] < 0
4823
&& indx < obj_raw_syment_count (input_bfd))
4825
if (indx >= obj_raw_syment_count (input_bfd))
4826
indx = output_index;
4828
indx = finfo->sym_indices[indx];
4829
aux.x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
4834
indx = aux.x_sym.x_tagndx.l;
4835
if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
4839
symindx = finfo->sym_indices[indx];
4841
aux.x_sym.x_tagndx.l = 0;
4843
aux.x_sym.x_tagndx.l = symindx;
4848
/* Copy over the line numbers, unless we are stripping
4849
them. We do this on a symbol by symbol basis in
4850
order to more easily handle garbage collection. */
4851
if ((isymp->n_sclass == C_EXT
4852
|| isymp->n_sclass == C_HIDEXT)
4854
&& isymp->n_numaux > 1
4855
&& ISFCN (isymp->n_type)
4856
&& aux.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
4858
if (finfo->info->strip != strip_none
4859
&& finfo->info->strip != strip_some)
4860
aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
4863
asection *enclosing;
4864
unsigned int enc_count;
4865
bfd_signed_vma linoff;
4866
struct internal_lineno lin;
4869
enclosing = xcoff_section_data (abfd, o)->enclosing;
4870
enc_count = xcoff_section_data (abfd, o)->lineno_count;
4871
if (oline != enclosing)
4873
file_ptr pos = enclosing->line_filepos;
4874
bfd_size_type amt = linesz * enc_count;
4875
if (bfd_seek (input_bfd, pos, SEEK_SET) != 0
4876
|| (bfd_bread (finfo->linenos, amt, input_bfd)
4882
linoff = (aux.x_sym.x_fcnary.x_fcn.x_lnnoptr
4883
- enclosing->line_filepos);
4885
bfd_coff_swap_lineno_in (input_bfd,
4886
(PTR) (finfo->linenos + linoff),
4889
|| ((bfd_size_type) lin.l_addr.l_symndx
4893
obj_coff_external_syms (input_bfd)))
4895
aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
4898
bfd_byte *linpend, *linp;
4900
bfd_size_type count;
4902
lin.l_addr.l_symndx = *indexp;
4903
bfd_coff_swap_lineno_out (output_bfd, (PTR) &lin,
4904
(PTR) (finfo->linenos
4907
linpend = (finfo->linenos
4908
+ enc_count * linesz);
4909
offset = (o->output_section->vma
4912
for (linp = finfo->linenos + linoff + linesz;
4916
bfd_coff_swap_lineno_in (input_bfd, (PTR) linp,
4918
if (lin.l_lnno == 0)
4920
lin.l_addr.l_paddr += offset;
4921
bfd_coff_swap_lineno_out (output_bfd,
4926
count = (linp - (finfo->linenos + linoff)) / linesz;
4928
aux.x_sym.x_fcnary.x_fcn.x_lnnoptr =
4929
(o->output_section->line_filepos
4930
+ o->output_section->lineno_count * linesz);
4932
if (bfd_seek (output_bfd,
4933
aux.x_sym.x_fcnary.x_fcn.x_lnnoptr,
4935
|| (bfd_bwrite (finfo->linenos + linoff,
4936
linesz * count, output_bfd)
4940
o->output_section->lineno_count += count;
4944
struct internal_syment *iisp, *iispend;
4949
/* Update any C_BINCL or C_EINCL symbols
4950
that refer to a line number in the
4951
range we just output. */
4952
iisp = finfo->internal_syms;
4954
+ obj_raw_syment_count (input_bfd));
4955
iindp = finfo->sym_indices;
4956
oos = finfo->outsyms;
4957
while (iisp < iispend)
4960
&& (iisp->n_sclass == C_BINCL
4961
|| iisp->n_sclass == C_EINCL)
4962
&& ((bfd_size_type) iisp->n_value
4963
>= (bfd_size_type)(enclosing->line_filepos + linoff))
4964
&& ((bfd_size_type) iisp->n_value
4965
< (enclosing->line_filepos
4966
+ enc_count * linesz)))
4968
struct internal_syment iis;
4970
bfd_coff_swap_sym_in (output_bfd,
4975
- enclosing->line_filepos
4977
+ aux.x_sym.x_fcnary.x_fcn.x_lnnoptr);
4978
bfd_coff_swap_sym_out (output_bfd,
4984
iiadd = 1 + iisp->n_numaux;
4986
oos += iiadd * osymesz;
4995
bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, isymp->n_type,
4996
isymp->n_sclass, i, isymp->n_numaux,
5008
/* If we swapped out a C_FILE symbol, guess that the next C_FILE
5009
symbol will be the first symbol in the next input file. In the
5010
normal case, this will save us from writing out the C_FILE symbol
5012
if (finfo->last_file_index != -1
5013
&& (bfd_size_type) finfo->last_file_index >= syment_base)
5015
finfo->last_file.n_value = output_index;
5016
bfd_coff_swap_sym_out (output_bfd, (PTR) &finfo->last_file,
5017
(PTR) (finfo->outsyms
5018
+ ((finfo->last_file_index - syment_base)
5022
/* Write the modified symbols to the output file. */
5023
if (outsym > finfo->outsyms)
5025
file_ptr pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
5026
bfd_size_type amt = outsym - finfo->outsyms;
5027
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
5028
|| bfd_bwrite (finfo->outsyms, amt, output_bfd) != amt)
5031
BFD_ASSERT ((obj_raw_syment_count (output_bfd)
5032
+ (outsym - finfo->outsyms) / osymesz)
5035
obj_raw_syment_count (output_bfd) = output_index;
5038
/* Don't let the linker relocation routines discard the symbols. */
5039
keep_syms = obj_coff_keep_syms (input_bfd);
5040
obj_coff_keep_syms (input_bfd) = true;
5042
/* Relocate the contents of each section. */
5043
for (o = input_bfd->sections; o != NULL; o = o->next)
5048
if (! o->linker_mark)
5050
/* This section was omitted from the link. */
5054
if ((o->flags & SEC_HAS_CONTENTS) == 0
5055
|| o->_raw_size == 0
5056
|| (o->flags & SEC_IN_MEMORY) != 0)
5059
/* We have set filepos correctly for the sections we created to
5060
represent csects, so bfd_get_section_contents should work. */
5061
if (coff_section_data (input_bfd, o) != NULL
5062
&& coff_section_data (input_bfd, o)->contents != NULL)
5063
contents = coff_section_data (input_bfd, o)->contents;
5065
if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
5066
(file_ptr) 0, o->_raw_size))
5068
contents = finfo->contents;
5071
if ((o->flags & SEC_RELOC) != 0)
5074
struct internal_reloc *internal_relocs;
5075
struct internal_reloc *irel;
5077
struct internal_reloc *irelend;
5078
struct xcoff_link_hash_entry **rel_hash;
5081
/* Read in the relocs. */
5082
target_index = o->output_section->target_index;
5083
internal_relocs = (xcoff_read_internal_relocs
5084
(input_bfd, o, false, finfo->external_relocs,
5086
(finfo->section_info[target_index].relocs
5087
+ o->output_section->reloc_count)));
5088
if (internal_relocs == NULL)
5091
/* Call processor specific code to relocate the section
5093
if (! bfd_coff_relocate_section (output_bfd, finfo->info,
5097
finfo->internal_syms,
5098
xcoff_data (input_bfd)->csects))
5101
offset = o->output_section->vma + o->output_offset - o->vma;
5102
irel = internal_relocs;
5103
irelend = irel + o->reloc_count;
5104
rel_hash = (finfo->section_info[target_index].rel_hashes
5105
+ o->output_section->reloc_count);
5106
for (; irel < irelend; irel++, rel_hash++)
5108
struct xcoff_link_hash_entry *h = NULL;
5109
struct internal_ldrel ldrel;
5114
/* Adjust the reloc address and symbol index. */
5116
irel->r_vaddr += offset;
5118
r_symndx = irel->r_symndx;
5123
h = obj_xcoff_sym_hashes (input_bfd)[r_symndx];
5125
if (r_symndx != -1 && finfo->info->strip != strip_all)
5128
&& h->smclas != XMC_TD
5129
&& (irel->r_type == R_TOC
5130
|| irel->r_type == R_GL
5131
|| irel->r_type == R_TCL
5132
|| irel->r_type == R_TRL
5133
|| irel->r_type == R_TRLA))
5135
/* This is a TOC relative reloc with a symbol
5136
attached. The symbol should be the one which
5137
this reloc is for. We want to make this
5138
reloc against the TOC address of the symbol,
5139
not the symbol itself. */
5140
BFD_ASSERT (h->toc_section != NULL);
5141
BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
5142
if (h->u.toc_indx != -1)
5143
irel->r_symndx = h->u.toc_indx;
5146
struct xcoff_toc_rel_hash *n;
5147
struct xcoff_link_section_info *si;
5150
amt = sizeof (struct xcoff_toc_rel_hash);
5151
n = ((struct xcoff_toc_rel_hash *)
5152
bfd_alloc (finfo->output_bfd, amt));
5155
si = finfo->section_info + target_index;
5156
n->next = si->toc_rel_hashes;
5159
si->toc_rel_hashes = n;
5164
/* This is a global symbol. */
5166
irel->r_symndx = h->indx;
5169
/* This symbol is being written at the end
5170
of the file, and we do not yet know the
5171
symbol index. We save the pointer to the
5172
hash table entry in the rel_hash list.
5173
We set the indx field to -2 to indicate
5174
that this symbol must not be stripped. */
5183
indx = finfo->sym_indices[r_symndx];
5187
struct internal_syment *is;
5189
/* Relocations against a TC0 TOC anchor are
5190
automatically transformed to be against
5191
the TOC anchor in the output file. */
5192
is = finfo->internal_syms + r_symndx;
5193
if (is->n_sclass == C_HIDEXT
5194
&& is->n_numaux > 0)
5197
union internal_auxent aux;
5201
obj_coff_external_syms (input_bfd))
5202
+ ((r_symndx + is->n_numaux)
5204
bfd_coff_swap_aux_in (input_bfd, auxptr,
5205
is->n_type, is->n_sclass,
5209
if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_SD
5210
&& aux.x_csect.x_smclas == XMC_TC0)
5211
indx = finfo->toc_symindx;
5216
irel->r_symndx = indx;
5220
struct internal_syment *is;
5223
char buf[SYMNMLEN + 1];
5225
/* This reloc is against a symbol we are
5226
stripping. It would be possible to handle
5227
this case, but I don't think it's worth it. */
5228
is = finfo->internal_syms + r_symndx;
5230
name = (_bfd_coff_internal_syment_name
5231
(input_bfd, is, buf));
5236
if (! ((*finfo->info->callbacks->unattached_reloc)
5237
(finfo->info, name, input_bfd, o,
5245
switch (irel->r_type)
5249
|| h->root.type == bfd_link_hash_defined
5250
|| h->root.type == bfd_link_hash_defweak
5251
|| h->root.type == bfd_link_hash_common)
5258
/* This reloc needs to be copied into the .loader
5260
ldrel.l_vaddr = irel->r_vaddr;
5262
ldrel.l_symndx = -(bfd_size_type ) 1;
5264
|| (h->root.type == bfd_link_hash_defined
5265
|| h->root.type == bfd_link_hash_defweak
5266
|| h->root.type == bfd_link_hash_common))
5271
sec = xcoff_data (input_bfd)->csects[r_symndx];
5272
else if (h->root.type == bfd_link_hash_common)
5273
sec = h->root.u.c.p->section;
5275
sec = h->root.u.def.section;
5276
sec = sec->output_section;
5278
if (strcmp (sec->name, ".text") == 0)
5280
else if (strcmp (sec->name, ".data") == 0)
5282
else if (strcmp (sec->name, ".bss") == 0)
5286
(*_bfd_error_handler)
5287
(_("%s: loader reloc in unrecognized section `%s'"),
5288
bfd_archive_filename (input_bfd),
5290
bfd_set_error (bfd_error_nonrepresentable_section);
5296
if (! finfo->info->relocateable
5297
&& (h->flags & XCOFF_DEF_DYNAMIC) == 0
5298
&& (h->flags & XCOFF_IMPORT) == 0)
5300
/* We already called the undefined_symbol
5301
callback for this relocation, in
5302
_bfd_ppc_xcoff_relocate_section. Don't
5303
issue any more warnings. */
5306
if (h->ldindx < 0 && ! quiet)
5308
(*_bfd_error_handler)
5309
(_("%s: `%s' in loader reloc but not loader sym"),
5310
bfd_archive_filename (input_bfd),
5311
h->root.root.string);
5312
bfd_set_error (bfd_error_bad_value);
5315
ldrel.l_symndx = h->ldindx;
5317
ldrel.l_rtype = (irel->r_size << 8) | irel->r_type;
5318
ldrel.l_rsecnm = o->output_section->target_index;
5319
if (xcoff_hash_table (finfo->info)->textro
5320
&& strcmp (o->output_section->name, ".text") == 0
5323
(*_bfd_error_handler)
5324
(_("%s: loader reloc in read-only section %s"),
5325
bfd_archive_filename (input_bfd),
5326
bfd_get_section_name (finfo->output_bfd,
5327
o->output_section));
5328
bfd_set_error (bfd_error_invalid_operation);
5331
bfd_xcoff_swap_ldrel_out (output_bfd, &ldrel,
5334
finfo->ldrel += bfd_xcoff_ldrelsz(output_bfd);
5342
/* We should never need a .loader reloc for a TOC
5348
o->output_section->reloc_count += o->reloc_count;
5351
/* Write out the modified section contents. */
5352
if (! bfd_set_section_contents (output_bfd, o->output_section,
5353
contents, (file_ptr) o->output_offset,
5354
(o->_cooked_size != 0
5360
obj_coff_keep_syms (input_bfd) = keep_syms;
5362
if (! finfo->info->keep_memory)
5364
if (! _bfd_coff_free_symbols (input_bfd))
5374
/* Write out a non-XCOFF global symbol. */
5378
xcoff_write_global_symbol (h, inf)
5379
struct xcoff_link_hash_entry *h;
5382
struct xcoff_final_link_info *finfo = (struct xcoff_final_link_info *) inf;
5385
struct internal_syment isym;
5386
union internal_auxent aux;
5391
output_bfd = finfo->output_bfd;
5392
outsym = finfo->outsyms;
5394
if (h->root.type == bfd_link_hash_warning)
5396
h = (struct xcoff_link_hash_entry *) h->root.u.i.link;
5397
if (h->root.type == bfd_link_hash_new)
5401
/* If this symbol was garbage collected, just skip it. */
5402
if (xcoff_hash_table (finfo->info)->gc
5403
&& (h->flags & XCOFF_MARK) == 0)
5406
/* If we need a .loader section entry, write it out. */
5407
if (h->ldsym != NULL)
5409
struct internal_ldsym *ldsym;
5414
if (h->root.type == bfd_link_hash_undefined
5415
|| h->root.type == bfd_link_hash_undefweak)
5419
ldsym->l_scnum = N_UNDEF;
5420
ldsym->l_smtype = XTY_ER;
5421
impbfd = h->root.u.undef.abfd;
5424
else if (h->root.type == bfd_link_hash_defined
5425
|| h->root.type == bfd_link_hash_defweak)
5430
sec = h->root.u.def.section;
5431
ldsym->l_value = (sec->output_section->vma
5432
+ sec->output_offset
5433
+ h->root.u.def.value);
5434
ldsym->l_scnum = sec->output_section->target_index;
5435
ldsym->l_smtype = XTY_SD;
5436
impbfd = sec->owner;
5442
if (((h->flags & XCOFF_DEF_REGULAR) == 0
5443
&& (h->flags & XCOFF_DEF_DYNAMIC) != 0)
5444
|| (h->flags & XCOFF_IMPORT) != 0)
5447
Import symbols are defined so the check above will make
5448
the l_smtype XTY_SD. But this is not correct, it should
5450
ldsym->l_smtype |= L_IMPORT;
5453
if (((h->flags & XCOFF_DEF_REGULAR) != 0
5454
&& (h->flags & XCOFF_DEF_DYNAMIC) != 0)
5455
|| (h->flags & XCOFF_EXPORT) != 0)
5457
ldsym->l_smtype |= L_EXPORT;
5460
if ((h->flags & XCOFF_ENTRY) != 0)
5462
ldsym->l_smtype |= L_ENTRY;
5465
if ((h->flags & XCOFF_RTINIT) != 0)
5467
ldsym->l_smtype = XTY_SD;
5470
ldsym->l_smclas = h->smclas;
5472
if (ldsym->l_smtype & L_IMPORT)
5474
if ((h->root.type == bfd_link_hash_defined
5475
|| h->root.type == bfd_link_hash_defweak)
5476
&& (h->root.u.def.value != 0))
5478
ldsym->l_smclas = XMC_XO;
5480
else if ((h->flags & (XCOFF_SYSCALL32 | XCOFF_SYSCALL64)) ==
5481
(XCOFF_SYSCALL32 | XCOFF_SYSCALL64))
5483
ldsym->l_smclas = XMC_SV3264;
5485
else if (h->flags & XCOFF_SYSCALL32)
5487
ldsym->l_smclas = XMC_SV;
5489
else if (h->flags & XCOFF_SYSCALL64)
5491
ldsym->l_smclas = XMC_SV64;
5495
if (ldsym->l_ifile == -(bfd_size_type) 1)
5499
else if (ldsym->l_ifile == 0)
5501
if ((ldsym->l_smtype & L_IMPORT) == 0)
5505
else if (impbfd == NULL)
5511
BFD_ASSERT (impbfd->xvec == output_bfd->xvec);
5512
ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
5518
BFD_ASSERT (h->ldindx >= 0);
5520
bfd_xcoff_swap_ldsym_out (output_bfd, ldsym,
5523
* bfd_xcoff_ldsymsz(finfo->output_bfd)));
5527
/* If this symbol needs global linkage code, write it out. */
5528
if (h->root.type == bfd_link_hash_defined
5529
&& (h->root.u.def.section
5530
== xcoff_hash_table (finfo->info)->linkage_section))
5536
p = h->root.u.def.section->contents + h->root.u.def.value;
5538
/* The first instruction in the global linkage code loads a
5539
specific TOC element. */
5540
tocoff = (h->descriptor->toc_section->output_section->vma
5541
+ h->descriptor->toc_section->output_offset
5542
- xcoff_data (output_bfd)->toc);
5544
if ((h->descriptor->flags & XCOFF_SET_TOC) != 0)
5546
tocoff += h->descriptor->u.toc_offset;
5550
/* The first instruction in the glink code needs to be
5551
cooked to to hold the correct offset in the toc. The
5552
rest are just output raw. */
5553
bfd_put_32 (output_bfd,
5554
bfd_xcoff_glink_code(output_bfd, 0) | (tocoff & 0xffff), p);
5556
/* Start with i == 1 to get past the first instruction done above
5557
The /4 is because the glink code is in bytes and we are going
5559
for (i = 1; i < bfd_xcoff_glink_code_size(output_bfd) / 4; i++)
5561
bfd_put_32 (output_bfd,
5562
(bfd_vma) bfd_xcoff_glink_code(output_bfd, i),
5567
/* If we created a TOC entry for this symbol, write out the required
5569
if ((h->flags & XCOFF_SET_TOC) != 0)
5574
struct internal_reloc *irel;
5575
struct internal_ldrel ldrel;
5576
struct internal_syment irsym;
5577
union internal_auxent iraux;
5579
tocsec = h->toc_section;
5580
osec = tocsec->output_section;
5581
oindx = osec->target_index;
5582
irel = finfo->section_info[oindx].relocs + osec->reloc_count;
5583
irel->r_vaddr = (osec->vma
5584
+ tocsec->output_offset
5590
irel->r_symndx = h->indx;
5595
irel->r_symndx = obj_raw_syment_count (output_bfd);
5598
BFD_ASSERT (h->ldindx >= 0);
5600
/* Initialize the aux union here instead of closer to when it is
5601
written out below because the length of the csect depends on
5602
whether the output is 32 or 64 bit. */
5603
memset (&iraux, 0, sizeof iraux);
5604
iraux.x_csect.x_smtyp = XTY_SD;
5605
/* iraux.x_csect.x_scnlen.l = 4 or 8, see below */
5606
iraux.x_csect.x_smclas = XMC_TC;
5608
/* 32 bit uses a 32 bit R_POS to do the relocations
5609
64 bit uses a 64 bit R_POS to do the relocations
5611
Also needs to change the csect size : 4 for 32 bit, 8 for 64 bit
5613
Which one is determined by the backend. */
5614
if (bfd_xcoff_is_xcoff64 (output_bfd))
5617
iraux.x_csect.x_scnlen.l = 8;
5619
else if (bfd_xcoff_is_xcoff32 (output_bfd))
5622
iraux.x_csect.x_scnlen.l = 4;
5628
irel->r_type = R_POS;
5629
finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
5630
++osec->reloc_count;
5632
ldrel.l_vaddr = irel->r_vaddr;
5633
ldrel.l_symndx = h->ldindx;
5634
ldrel.l_rtype = (irel->r_size << 8) | R_POS;
5635
ldrel.l_rsecnm = oindx;
5636
bfd_xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5637
finfo->ldrel += bfd_xcoff_ldrelsz(output_bfd);
5639
/* We need to emit a symbol to define a csect which holds
5641
if (finfo->info->strip != strip_all)
5644
result = bfd_xcoff_put_symbol_name (output_bfd, finfo->strtab,
5645
&irsym, h->root.root.string);
5646
if (false == result)
5651
irsym.n_value = irel->r_vaddr;
5652
irsym.n_scnum = osec->target_index;
5653
irsym.n_sclass = C_HIDEXT;
5654
irsym.n_type = T_NULL;
5657
bfd_coff_swap_sym_out (output_bfd, (PTR) &irsym, (PTR) outsym);
5658
outsym += bfd_coff_symesz (output_bfd);
5660
/* note : iraux is initialized above */
5661
bfd_coff_swap_aux_out (output_bfd, (PTR) &iraux, T_NULL, C_HIDEXT,
5662
0, 1, (PTR) outsym);
5663
outsym += bfd_coff_auxesz (output_bfd);
5667
/* We aren't going to write out the symbols below, so we
5668
need to write them out now. */
5669
pos = obj_sym_filepos (output_bfd);
5670
pos += (obj_raw_syment_count (output_bfd)
5671
* bfd_coff_symesz (output_bfd));
5672
amt = outsym - finfo->outsyms;
5673
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
5674
|| bfd_bwrite (finfo->outsyms, amt, output_bfd) != amt)
5676
obj_raw_syment_count (output_bfd) +=
5677
(outsym - finfo->outsyms) / bfd_coff_symesz (output_bfd);
5679
outsym = finfo->outsyms;
5684
/* If this symbol is a specially defined function descriptor, write
5685
it out. The first word is the address of the function code
5686
itself, the second word is the address of the TOC, and the third
5690
The addresses for the 32 bit will take 4 bytes and the addresses
5691
for 64 bit will take 8 bytes. Similar for the relocs. This type
5692
of logic was also done above to create a TOC entry in
5693
xcoff_write_global_symbol. */
5694
if ((h->flags & XCOFF_DESCRIPTOR) != 0
5695
&& h->root.type == bfd_link_hash_defined
5696
&& (h->root.u.def.section
5697
== xcoff_hash_table (finfo->info)->descriptor_section))
5703
struct xcoff_link_hash_entry *hentry;
5705
struct internal_reloc *irel;
5706
struct internal_ldrel ldrel;
5708
unsigned int reloc_size, byte_size;
5710
if (bfd_xcoff_is_xcoff64 (output_bfd))
5715
else if (bfd_xcoff_is_xcoff32 (output_bfd))
5725
sec = h->root.u.def.section;
5726
osec = sec->output_section;
5727
oindx = osec->target_index;
5728
p = sec->contents + h->root.u.def.value;
5730
hentry = h->descriptor;
5731
BFD_ASSERT (hentry != NULL
5732
&& (hentry->root.type == bfd_link_hash_defined
5733
|| hentry->root.type == bfd_link_hash_defweak));
5734
esec = hentry->root.u.def.section;
5736
irel = finfo->section_info[oindx].relocs + osec->reloc_count;
5737
irel->r_vaddr = (osec->vma
5738
+ sec->output_offset
5739
+ h->root.u.def.value);
5740
irel->r_symndx = esec->output_section->target_index;
5741
irel->r_type = R_POS;
5742
irel->r_size = reloc_size;
5743
finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
5744
++osec->reloc_count;
5746
ldrel.l_vaddr = irel->r_vaddr;
5747
if (strcmp (esec->output_section->name, ".text") == 0)
5749
else if (strcmp (esec->output_section->name, ".data") == 0)
5751
else if (strcmp (esec->output_section->name, ".bss") == 0)
5755
(*_bfd_error_handler)
5756
(_("%s: loader reloc in unrecognized section `%s'"),
5757
bfd_get_filename (output_bfd),
5758
esec->output_section->name);
5759
bfd_set_error (bfd_error_nonrepresentable_section);
5762
ldrel.l_rtype = (reloc_size << 8) | R_POS;
5763
ldrel.l_rsecnm = oindx;
5764
bfd_xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5765
finfo->ldrel += bfd_xcoff_ldrelsz(output_bfd);
5767
/* There are three items to write out,
5768
the address of the code
5769
the address of the toc anchor
5770
the environment pointer.
5771
We are ignoring the environment pointer. So set it to zero. */
5772
if (bfd_xcoff_is_xcoff64 (output_bfd))
5774
bfd_put_64 (output_bfd,
5775
(esec->output_section->vma + esec->output_offset
5776
+ hentry->root.u.def.value),
5778
bfd_put_64 (output_bfd, xcoff_data (output_bfd)->toc, p + 8);
5779
bfd_put_64 (output_bfd, (bfd_vma) 0, p + 16);
5784
This logic was already called above so the error case where
5785
the backend is neither has already been checked. */
5786
bfd_put_32 (output_bfd,
5787
(esec->output_section->vma + esec->output_offset
5788
+ hentry->root.u.def.value),
5790
bfd_put_32 (output_bfd, xcoff_data (output_bfd)->toc, p + 4);
5791
bfd_put_32 (output_bfd, (bfd_vma) 0, p + 8);
5794
tsec = coff_section_from_bfd_index (output_bfd,
5795
xcoff_data (output_bfd)->sntoc);
5798
irel->r_vaddr = (osec->vma
5799
+ sec->output_offset
5800
+ h->root.u.def.value
5802
irel->r_symndx = tsec->output_section->target_index;
5803
irel->r_type = R_POS;
5804
irel->r_size = reloc_size;
5805
finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
5806
++osec->reloc_count;
5808
ldrel.l_vaddr = irel->r_vaddr;
5809
if (strcmp (tsec->output_section->name, ".text") == 0)
5811
else if (strcmp (tsec->output_section->name, ".data") == 0)
5813
else if (strcmp (tsec->output_section->name, ".bss") == 0)
5817
(*_bfd_error_handler)
5818
(_("%s: loader reloc in unrecognized section `%s'"),
5819
bfd_get_filename (output_bfd),
5820
tsec->output_section->name);
5821
bfd_set_error (bfd_error_nonrepresentable_section);
5824
ldrel.l_rtype = (reloc_size << 8) | R_POS;
5825
ldrel.l_rsecnm = oindx;
5826
bfd_xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5827
finfo->ldrel += bfd_xcoff_ldrelsz(output_bfd);
5830
if (h->indx >= 0 || finfo->info->strip == strip_all)
5832
BFD_ASSERT (outsym == finfo->outsyms);
5837
&& (finfo->info->strip == strip_all
5838
|| (finfo->info->strip == strip_some
5839
&& bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
5840
false, false) == NULL)))
5842
BFD_ASSERT (outsym == finfo->outsyms);
5847
&& (h->flags & (XCOFF_REF_REGULAR | XCOFF_DEF_REGULAR)) == 0)
5849
BFD_ASSERT (outsym == finfo->outsyms);
5853
memset (&aux, 0, sizeof aux);
5855
h->indx = obj_raw_syment_count (output_bfd);
5857
result = bfd_xcoff_put_symbol_name (output_bfd, finfo->strtab, &isym,
5858
h->root.root.string);
5859
if (false == result)
5864
if (h->root.type == bfd_link_hash_undefined
5865
|| h->root.type == bfd_link_hash_undefweak)
5868
isym.n_scnum = N_UNDEF;
5869
isym.n_sclass = C_EXT;
5870
aux.x_csect.x_smtyp = XTY_ER;
5872
else if ((h->root.type == bfd_link_hash_defined
5873
|| h->root.type == bfd_link_hash_defweak)
5874
&& h->smclas == XMC_XO)
5876
BFD_ASSERT (bfd_is_abs_section (h->root.u.def.section));
5877
isym.n_value = h->root.u.def.value;
5878
isym.n_scnum = N_UNDEF;
5879
isym.n_sclass = C_EXT;
5880
aux.x_csect.x_smtyp = XTY_ER;
5882
else if (h->root.type == bfd_link_hash_defined
5883
|| h->root.type == bfd_link_hash_defweak)
5885
struct xcoff_link_size_list *l;
5887
isym.n_value = (h->root.u.def.section->output_section->vma
5888
+ h->root.u.def.section->output_offset
5889
+ h->root.u.def.value);
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;
5902
aux.x_csect.x_scnlen.l = l->size;
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;
5920
isym.n_type = T_NULL;
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,
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. */
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,
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)
5956
obj_raw_syment_count (output_bfd) +=
5957
(outsym - finfo->outsyms) / bfd_coff_symesz (output_bfd);
5962
/* Handle a link order which is supposed to generate a reloc. */
5965
xcoff_reloc_link_order (output_bfd, finfo, output_section, link_order)
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;
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. */
5989
howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
5992
bfd_set_error (bfd_error_bad_value);
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));
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)))
6009
if (h->root.type == bfd_link_hash_common)
6011
hsec = h->root.u.c.p->section;
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;
6026
addend = link_order->u.reloc.p->addend;
6028
addend += (hsec->output_section->vma
6029
+ hsec->output_offset
6036
bfd_reloc_status_type rstat;
6039
size = bfd_get_reloc_size (howto);
6040
buf = (bfd_byte *) bfd_zmalloc (size);
6044
rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
6050
case bfd_reloc_outofrange:
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,
6063
ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
6064
(file_ptr) link_order->offset, size);
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;
6084
irel->r_symndx = h->indx;
6087
/* Set the index to -2 to force this symbol to get written out. */
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;
6106
const char *secname;
6108
secname = hsec->output_section->name;
6110
if (strcmp (secname, ".text") == 0)
6112
else if (strcmp (secname, ".data") == 0)
6114
else if (strcmp (secname, ".bss") == 0)
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);
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);
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);
6147
/* Sort relocs by VMA. This is called via qsort. */
6150
xcoff_sort_relocs (p1, 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)
6159
else if (r1->r_vaddr < r2->r_vaddr)
added
removed
binutils/bfd/xcofflink.c
