]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - contrib/gdb/bfd/xcofflink.c
This commit was generated by cvs2svn to compensate for changes in r26236,
[FreeBSD/FreeBSD.git] / contrib / gdb / bfd / xcofflink.c
1 /* POWER/PowerPC XCOFF linker support.
2    Copyright 1995, 1996 Free Software Foundation, Inc.
3    Written by Ian Lance Taylor <ian@cygnus.com>, Cygnus Support.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "bfdlink.h"
24 #include "libbfd.h"
25 #include "coff/internal.h"
26 #include "libcoff.h"
27
28 /* This file holds the XCOFF linker code.  */
29
30 #define STRING_SIZE_SIZE (4)
31
32 /* In order to support linking different object file formats into an
33    XCOFF format, we need to be able to determine whether a particular
34    bfd_target is an XCOFF vector.  FIXME: We need to rethink this
35    whole approach.  */
36 #define XCOFF_XVECP(xv) \
37   (strcmp ((xv)->name, "aixcoff-rs6000") == 0 \
38    || strcmp ((xv)->name, "xcoff-powermac") == 0)
39
40 /* Get the XCOFF hash table entries for a BFD.  */
41 #define obj_xcoff_sym_hashes(bfd) \
42   ((struct xcoff_link_hash_entry **) obj_coff_sym_hashes (bfd))
43
44 /* XCOFF relocation types.  These probably belong in a header file
45    somewhere.  The relocations are described in the function
46    _bfd_ppc_xcoff_relocate_section in this file.  */
47
48 #define R_POS   (0x00)
49 #define R_NEG   (0x01)
50 #define R_REL   (0x02)
51 #define R_TOC   (0x03)
52 #define R_RTB   (0x04)
53 #define R_GL    (0x05)
54 #define R_TCL   (0x06)
55 #define R_BA    (0x08)
56 #define R_BR    (0x0a)
57 #define R_RL    (0x0c)
58 #define R_RLA   (0x0d)
59 #define R_REF   (0x0f)
60 #define R_TRL   (0x12)
61 #define R_TRLA  (0x13)
62 #define R_RRTBI (0x14)
63 #define R_RRTBA (0x15)
64 #define R_CAI   (0x16)
65 #define R_CREL  (0x17)
66 #define R_RBA   (0x18)
67 #define R_RBAC  (0x19)
68 #define R_RBR   (0x1a)
69 #define R_RBRC  (0x1b)
70
71 /* The first word of global linkage code.  This must be modified by
72    filling in the correct TOC offset.  */
73
74 #define XCOFF_GLINK_FIRST (0x81820000)  /* lwz r12,0(r2) */
75
76 /* The remaining words of global linkage code.  */
77
78 static unsigned long xcoff_glink_code[] =
79 {
80   0x90410014,   /* stw r2,20(r1) */
81   0x800c0000,   /* lwz r0,0(r12) */
82   0x804c0004,   /* lwz r2,4(r12) */
83   0x7c0903a6,   /* mtctr r0 */
84   0x4e800420,   /* bctr */
85   0x0,          /* start of traceback table */
86   0x000c8000,   /* traceback table */
87   0x0           /* traceback table */
88 };
89
90 #define XCOFF_GLINK_SIZE \
91   (((sizeof xcoff_glink_code / sizeof xcoff_glink_code[0]) * 4) + 4)
92
93 /* We reuse the SEC_ROM flag as a mark flag for garbage collection.
94    This flag will only be used on input sections.  */
95
96 #define SEC_MARK (SEC_ROM)
97
98 /* The ldhdr structure.  This appears at the start of the .loader
99    section.  */
100
101 struct internal_ldhdr
102 {
103   /* The version number: currently always 1.  */
104   unsigned long l_version;
105   /* The number of symbol table entries.  */
106   bfd_size_type l_nsyms;
107   /* The number of relocation table entries.  */
108   bfd_size_type l_nreloc;
109   /* The length of the import file string table.  */
110   bfd_size_type l_istlen;
111   /* The number of import files.  */
112   bfd_size_type l_nimpid;
113   /* The offset from the start of the .loader section to the first
114      entry in the import file table.  */
115   bfd_size_type l_impoff;
116   /* The length of the string table.  */
117   bfd_size_type l_stlen;
118   /* The offset from the start of the .loader section to the first
119      entry in the string table.  */
120   bfd_size_type l_stoff;
121 };
122
123 struct external_ldhdr
124 {
125   bfd_byte l_version[4];
126   bfd_byte l_nsyms[4];
127   bfd_byte l_nreloc[4];
128   bfd_byte l_istlen[4];
129   bfd_byte l_nimpid[4];
130   bfd_byte l_impoff[4];
131   bfd_byte l_stlen[4];
132   bfd_byte l_stoff[4];
133 };
134
135 #define LDHDRSZ (8 * 4)
136
137 /* The ldsym structure.  This is used to represent a symbol in the
138    .loader section.  */
139
140 struct internal_ldsym
141 {
142   union
143     {
144       /* The symbol name if <= SYMNMLEN characters.  */
145       char _l_name[SYMNMLEN];
146       struct
147         {
148           /* Zero if the symbol name is more than SYMNMLEN characters.  */
149           long _l_zeroes;
150           /* The offset in the string table if the symbol name is more
151              than SYMNMLEN characters.  */
152           long _l_offset;
153         } _l_l;
154     } _l;
155   /* The symbol value.  */
156   bfd_vma l_value;
157   /* The symbol section number.  */
158   short l_scnum;
159   /* The symbol type and flags.  */
160   char l_smtype;
161   /* The symbol storage class.  */
162   char l_smclas;
163   /* The import file ID.  */
164   bfd_size_type l_ifile;
165   /* Offset to the parameter type check string.  */
166   bfd_size_type l_parm;
167 };
168
169 struct external_ldsym
170 {
171   union
172     {
173       bfd_byte _l_name[SYMNMLEN];
174       struct
175         {
176           bfd_byte _l_zeroes[4];
177           bfd_byte _l_offset[4];
178         } _l_l;
179     } _l;
180   bfd_byte l_value[4];
181   bfd_byte l_scnum[2];
182   bfd_byte l_smtype[1];
183   bfd_byte l_smclas[1];
184   bfd_byte l_ifile[4];
185   bfd_byte l_parm[4];
186 };
187
188 #define LDSYMSZ (8 + 3 * 4 + 2 + 2)
189
190 /* These flags are for the l_smtype field (the lower three bits are an
191    XTY_* value).  */
192
193 /* Imported symbol.  */
194 #define L_IMPORT (0x40)
195 /* Entry point.  */
196 #define L_ENTRY (0x20)
197 /* Exported symbol.  */
198 #define L_EXPORT (0x10)
199
200 /* The ldrel structure.  This is used to represent a reloc in the
201    .loader section.  */
202
203 struct internal_ldrel
204 {
205   /* The reloc address.  */
206   bfd_vma l_vaddr;
207   /* The symbol table index in the .loader section symbol table.  */
208   bfd_size_type l_symndx;
209   /* The relocation type and size.  */
210   short l_rtype;
211   /* The section number this relocation applies to.  */
212   short l_rsecnm;
213 };
214
215 struct external_ldrel
216 {
217   bfd_byte l_vaddr[4];
218   bfd_byte l_symndx[4];
219   bfd_byte l_rtype[2];
220   bfd_byte l_rsecnm[2];
221 };
222
223 #define LDRELSZ (2 * 4 + 2 * 2)
224
225 /* The list of import files.  */
226
227 struct xcoff_import_file
228 {
229   /* The next entry in the list.  */
230   struct xcoff_import_file *next;
231   /* The path.  */
232   const char *path;
233   /* The file name.  */
234   const char *file;
235   /* The member name.  */
236   const char *member;
237 };
238
239 /* An entry in the XCOFF linker hash table.  */
240
241 struct xcoff_link_hash_entry
242 {
243   struct bfd_link_hash_entry root;
244
245   /* Symbol index in output file.  Set to -1 initially.  Set to -2 if
246      there is a reloc against this symbol.  */
247   long indx;
248
249   /* If we have created a TOC entry for this symbol, this is the .tc
250      section which holds it.  */
251   asection *toc_section;
252
253   union
254     {
255       /* If we have created a TOC entry (the XCOFF_SET_TOC flag is
256          set), this is the offset in toc_section.  */
257       bfd_vma toc_offset;
258       /* If the TOC entry comes from an input file, this is set to the
259          symbo lindex of the C_HIDEXT XMC_TC symbol.  */
260       long toc_indx;
261     } u;
262
263   /* If this symbol is a function entry point which is called, this
264      field holds a pointer to the function descriptor.  If this symbol
265      is a function descriptor, this field holds a pointer to the
266      function entry point.  */
267   struct xcoff_link_hash_entry *descriptor;
268
269   /* The .loader symbol table entry, if there is one.  */
270   struct internal_ldsym *ldsym;
271
272   /* The .loader symbol table index.  */
273   long ldindx;
274
275   /* Some linker flags.  */
276   unsigned short flags;
277   /* Symbol is referenced by a regular object.  */
278 #define XCOFF_REF_REGULAR (01)
279   /* Symbol is defined by a regular object.  */
280 #define XCOFF_DEF_REGULAR (02)
281   /* Symbol is defined by a dynamic object.  */
282 #define XCOFF_DEF_DYNAMIC (04)
283   /* Symbol is used in a reloc being copied into the .loader section.  */
284 #define XCOFF_LDREL (010)
285   /* Symbol is the entry point.  */
286 #define XCOFF_ENTRY (020)
287   /* Symbol is called; this is, it appears in a R_BR reloc.  */
288 #define XCOFF_CALLED (040)
289   /* Symbol needs the TOC entry filled in.  */
290 #define XCOFF_SET_TOC (0100)
291   /* Symbol is explicitly imported.  */
292 #define XCOFF_IMPORT (0200)
293   /* Symbol is explicitly exported.  */
294 #define XCOFF_EXPORT (0400)
295   /* Symbol has been processed by xcoff_build_ldsyms.  */
296 #define XCOFF_BUILT_LDSYM (01000)
297   /* Symbol is mentioned by a section which was not garbage collected.  */
298 #define XCOFF_MARK (02000)
299   /* Symbol size is recorded in size_list list from hash table.  */
300 #define XCOFF_HAS_SIZE (04000)
301   /* Symbol is a function descriptor.  */
302 #define XCOFF_DESCRIPTOR (010000)
303
304   /* The storage mapping class.  */
305   unsigned char smclas;
306 };
307
308 /* The XCOFF linker hash table.  */
309
310 struct xcoff_link_hash_table
311 {
312   struct bfd_link_hash_table root;
313
314   /* The .debug string hash table.  We need to compute this while
315      reading the input files, so that we know how large the .debug
316      section will be before we assign section positions.  */
317   struct bfd_strtab_hash *debug_strtab;
318
319   /* The .debug section we will use for the final output.  */
320   asection *debug_section;
321
322   /* The .loader section we will use for the final output.  */
323   asection *loader_section;
324
325   /* A count of non TOC relative relocs which will need to be
326      allocated in the .loader section.  */
327   size_t ldrel_count;
328
329   /* The .loader section header.  */
330   struct internal_ldhdr ldhdr;
331
332   /* The .gl section we use to hold global linkage code.  */
333   asection *linkage_section;
334
335   /* The .tc section we use to hold toc entries we build for global
336      linkage code.  */
337   asection *toc_section;
338
339   /* The .ds section we use to hold function descriptors which we
340      create for exported symbols.  */
341   asection *descriptor_section;
342
343   /* The list of import files.  */
344   struct xcoff_import_file *imports;
345
346   /* Required alignment of sections within the output file.  */
347   unsigned long file_align;
348
349   /* Whether the .text section must be read-only.  */
350   boolean textro;
351
352   /* Whether garbage collection was done.  */
353   boolean gc;
354
355   /* A linked list of symbols for which we have size information.  */
356   struct xcoff_link_size_list
357     {
358       struct xcoff_link_size_list *next;
359       struct xcoff_link_hash_entry *h;
360       bfd_size_type size;
361     } *size_list;
362
363   /* Magic sections: _text, _etext, _data, _edata, _end, end.  */
364   asection *special_sections[6];
365 };
366
367 /* Information we keep for each section in the output file during the
368    final link phase.  */
369
370 struct xcoff_link_section_info
371 {
372   /* The relocs to be output.  */
373   struct internal_reloc *relocs;
374   /* For each reloc against a global symbol whose index was not known
375      when the reloc was handled, the global hash table entry.  */
376   struct xcoff_link_hash_entry **rel_hashes;
377   /* If there is a TOC relative reloc against a global symbol, and the
378      index of the TOC symbol is not known when the reloc was handled,
379      an entry is added to this linked list.  This is not an array,
380      like rel_hashes, because this case is quite uncommon.  */
381   struct xcoff_toc_rel_hash
382     {
383       struct xcoff_toc_rel_hash *next;
384       struct xcoff_link_hash_entry *h;
385       struct internal_reloc *rel;
386     } *toc_rel_hashes;
387 };
388
389 /* Information that we pass around while doing the final link step.  */
390
391 struct xcoff_final_link_info
392 {
393   /* General link information.  */
394   struct bfd_link_info *info;
395   /* Output BFD.  */
396   bfd *output_bfd;
397   /* Hash table for long symbol names.  */
398   struct bfd_strtab_hash *strtab;
399   /* Array of information kept for each output section, indexed by the
400      target_index field.  */
401   struct xcoff_link_section_info *section_info;
402   /* Symbol index of last C_FILE symbol (-1 if none).  */
403   long last_file_index;
404   /* Contents of last C_FILE symbol.  */
405   struct internal_syment last_file;
406   /* Symbol index of TOC symbol.  */
407   long toc_symindx;
408   /* Start of .loader symbols.  */
409   struct external_ldsym *ldsym;
410   /* Next .loader reloc to swap out.  */
411   struct external_ldrel *ldrel;
412   /* File position of start of line numbers.  */
413   file_ptr line_filepos;
414   /* Buffer large enough to hold swapped symbols of any input file.  */
415   struct internal_syment *internal_syms;
416   /* Buffer large enough to hold output indices of symbols of any
417      input file.  */
418   long *sym_indices;
419   /* Buffer large enough to hold output symbols for any input file.  */
420   bfd_byte *outsyms;
421   /* Buffer large enough to hold external line numbers for any input
422      section.  */
423   bfd_byte *linenos;
424   /* Buffer large enough to hold any input section.  */
425   bfd_byte *contents;
426   /* Buffer large enough to hold external relocs of any input section.  */
427   bfd_byte *external_relocs;
428 };
429
430 static void xcoff_swap_ldhdr_in
431   PARAMS ((bfd *, const struct external_ldhdr *, struct internal_ldhdr *));
432 static void xcoff_swap_ldhdr_out
433   PARAMS ((bfd *, const struct internal_ldhdr *, struct external_ldhdr *));
434 static void xcoff_swap_ldsym_in
435   PARAMS ((bfd *, const struct external_ldsym *, struct internal_ldsym *));
436 static void xcoff_swap_ldsym_out
437   PARAMS ((bfd *, const struct internal_ldsym *, struct external_ldsym *));
438 static void xcoff_swap_ldrel_out
439   PARAMS ((bfd *, const struct internal_ldrel *, struct external_ldrel *));
440 static struct bfd_hash_entry *xcoff_link_hash_newfunc
441   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
442 static struct internal_reloc *xcoff_read_internal_relocs
443   PARAMS ((bfd *, asection *, boolean, bfd_byte *, boolean,
444            struct internal_reloc *));
445 static boolean xcoff_link_add_object_symbols
446   PARAMS ((bfd *, struct bfd_link_info *));
447 static boolean xcoff_link_check_archive_element
448   PARAMS ((bfd *, struct bfd_link_info *, boolean *));
449 static boolean xcoff_link_check_ar_symbols
450   PARAMS ((bfd *, struct bfd_link_info *, boolean *));
451 static bfd_size_type xcoff_find_reloc
452   PARAMS ((struct internal_reloc *, bfd_size_type, bfd_vma));
453 static boolean xcoff_link_add_symbols PARAMS ((bfd *, struct bfd_link_info *));
454 static boolean xcoff_link_add_dynamic_symbols
455   PARAMS ((bfd *, struct bfd_link_info *));
456 static boolean xcoff_mark PARAMS ((struct bfd_link_info *, asection *));
457 static void xcoff_sweep PARAMS ((struct bfd_link_info *));
458 static boolean xcoff_build_ldsyms
459   PARAMS ((struct xcoff_link_hash_entry *, PTR));
460 static boolean xcoff_link_input_bfd
461   PARAMS ((struct xcoff_final_link_info *, bfd *));
462 static boolean xcoff_write_global_symbol
463   PARAMS ((struct xcoff_link_hash_entry *, PTR));
464 static boolean xcoff_reloc_link_order
465   PARAMS ((bfd *, struct xcoff_final_link_info *, asection *,
466            struct bfd_link_order *));
467 static int xcoff_sort_relocs PARAMS ((const PTR, const PTR));
468 \f
469 /* Routines to swap information in the XCOFF .loader section.  If we
470    ever need to write an XCOFF loader, this stuff will need to be
471    moved to another file shared by the linker (which XCOFF calls the
472    ``binder'') and the loader.  */
473
474 /* Swap in the ldhdr structure.  */
475
476 static void
477 xcoff_swap_ldhdr_in (abfd, src, dst)
478      bfd *abfd;
479      const struct external_ldhdr *src;
480      struct internal_ldhdr *dst;
481 {
482   dst->l_version = bfd_get_32 (abfd, src->l_version);
483   dst->l_nsyms = bfd_get_32 (abfd, src->l_nsyms);
484   dst->l_nreloc = bfd_get_32 (abfd, src->l_nreloc);
485   dst->l_istlen = bfd_get_32 (abfd, src->l_istlen);
486   dst->l_nimpid = bfd_get_32 (abfd, src->l_nimpid);
487   dst->l_impoff = bfd_get_32 (abfd, src->l_impoff);
488   dst->l_stlen = bfd_get_32 (abfd, src->l_stlen);
489   dst->l_stoff = bfd_get_32 (abfd, src->l_stoff);
490 }
491
492 /* Swap out the ldhdr structure.  */
493
494 static void
495 xcoff_swap_ldhdr_out (abfd, src, dst)
496      bfd *abfd;
497      const struct internal_ldhdr *src;
498      struct external_ldhdr *dst;
499 {
500   bfd_put_32 (abfd, src->l_version, dst->l_version);
501   bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
502   bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
503   bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
504   bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
505   bfd_put_32 (abfd, src->l_impoff, dst->l_impoff);
506   bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
507   bfd_put_32 (abfd, src->l_stoff, dst->l_stoff);
508 }
509
510 /* Swap in the ldsym structure.  */
511
512 static void
513 xcoff_swap_ldsym_in (abfd, src, dst)
514      bfd *abfd;
515      const struct external_ldsym *src;
516      struct internal_ldsym *dst;
517 {
518   if (bfd_get_32 (abfd, src->_l._l_l._l_zeroes) != 0)
519     memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
520   else
521     {
522       dst->_l._l_l._l_zeroes = 0;
523       dst->_l._l_l._l_offset = bfd_get_32 (abfd, src->_l._l_l._l_offset);
524     }
525   dst->l_value = bfd_get_32 (abfd, src->l_value);
526   dst->l_scnum = bfd_get_16 (abfd, src->l_scnum);
527   dst->l_smtype = bfd_get_8 (abfd, src->l_smtype);
528   dst->l_smclas = bfd_get_8 (abfd, src->l_smclas);
529   dst->l_ifile = bfd_get_32 (abfd, src->l_ifile);
530   dst->l_parm = bfd_get_32 (abfd, src->l_parm);
531 }
532
533 /* Swap out the ldsym structure.  */
534
535 static void
536 xcoff_swap_ldsym_out (abfd, src, dst)
537      bfd *abfd;
538      const struct internal_ldsym *src;
539      struct external_ldsym *dst;
540 {
541   if (src->_l._l_l._l_zeroes != 0)
542     memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
543   else
544     {
545       bfd_put_32 (abfd, 0, dst->_l._l_l._l_zeroes);
546       bfd_put_32 (abfd, src->_l._l_l._l_offset, dst->_l._l_l._l_offset);
547     }
548   bfd_put_32 (abfd, src->l_value, dst->l_value);
549   bfd_put_16 (abfd, src->l_scnum, dst->l_scnum);
550   bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
551   bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
552   bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
553   bfd_put_32 (abfd, src->l_parm, dst->l_parm);
554 }
555
556 /* As it happens, we never need to swap in the ldrel structure.  */
557
558 /* Swap out the ldrel structure.  */
559
560 static void
561 xcoff_swap_ldrel_out (abfd, src, dst)
562      bfd *abfd;
563      const struct internal_ldrel *src;
564      struct external_ldrel *dst;
565 {
566   bfd_put_32 (abfd, src->l_vaddr, dst->l_vaddr);
567   bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
568   bfd_put_16 (abfd, src->l_rtype, dst->l_rtype);
569   bfd_put_16 (abfd, src->l_rsecnm, dst->l_rsecnm);
570 }
571 \f
572 /* Routine to create an entry in an XCOFF link hash table.  */
573
574 static struct bfd_hash_entry *
575 xcoff_link_hash_newfunc (entry, table, string)
576      struct bfd_hash_entry *entry;
577      struct bfd_hash_table *table;
578      const char *string;
579 {
580   struct xcoff_link_hash_entry *ret = (struct xcoff_link_hash_entry *) entry;
581
582   /* Allocate the structure if it has not already been allocated by a
583      subclass.  */
584   if (ret == (struct xcoff_link_hash_entry *) NULL)
585     ret = ((struct xcoff_link_hash_entry *)
586            bfd_hash_allocate (table, sizeof (struct xcoff_link_hash_entry)));
587   if (ret == (struct xcoff_link_hash_entry *) NULL)
588     return (struct bfd_hash_entry *) ret;
589
590   /* Call the allocation method of the superclass.  */
591   ret = ((struct xcoff_link_hash_entry *)
592          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
593                                  table, string));
594   if (ret != NULL)
595     {
596       /* Set local fields.  */
597       ret->indx = -1;
598       ret->toc_section = NULL;
599       ret->u.toc_indx = -1;
600       ret->descriptor = NULL;
601       ret->ldsym = NULL;
602       ret->ldindx = -1;
603       ret->flags = 0;
604       ret->smclas = XMC_UA;
605     }
606
607   return (struct bfd_hash_entry *) ret;
608 }
609
610 /* Create a XCOFF link hash table.  */
611
612 struct bfd_link_hash_table *
613 _bfd_xcoff_bfd_link_hash_table_create (abfd)
614      bfd *abfd;
615 {
616   struct xcoff_link_hash_table *ret;
617
618   ret = ((struct xcoff_link_hash_table *)
619          bfd_alloc (abfd, sizeof (struct xcoff_link_hash_table)));
620   if (ret == (struct xcoff_link_hash_table *) NULL)
621     return (struct bfd_link_hash_table *) NULL;
622   if (! _bfd_link_hash_table_init (&ret->root, abfd, xcoff_link_hash_newfunc))
623     {
624       bfd_release (abfd, ret);
625       return (struct bfd_link_hash_table *) NULL;
626     }
627
628   ret->debug_strtab = _bfd_xcoff_stringtab_init ();
629   ret->debug_section = NULL;
630   ret->loader_section = NULL;
631   ret->ldrel_count = 0;
632   memset (&ret->ldhdr, 0, sizeof (struct internal_ldhdr));
633   ret->linkage_section = NULL;
634   ret->toc_section = NULL;
635   ret->descriptor_section = NULL;
636   ret->imports = NULL;
637   ret->file_align = 0;
638   ret->textro = false;
639   ret->gc = false;
640   memset (ret->special_sections, 0, sizeof ret->special_sections);
641
642   /* The linker will always generate a full a.out header.  We need to
643      record that fact now, before the sizeof_headers routine could be
644      called.  */
645   xcoff_data (abfd)->full_aouthdr = true;
646
647   return &ret->root;
648 }
649
650 /* Look up an entry in an XCOFF link hash table.  */
651
652 #define xcoff_link_hash_lookup(table, string, create, copy, follow) \
653   ((struct xcoff_link_hash_entry *) \
654    bfd_link_hash_lookup (&(table)->root, (string), (create), (copy),\
655                          (follow)))
656
657 /* Traverse an XCOFF link hash table.  */
658
659 #define xcoff_link_hash_traverse(table, func, info)                     \
660   (bfd_link_hash_traverse                                               \
661    (&(table)->root,                                                     \
662     (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func),  \
663     (info)))
664
665 /* Get the XCOFF link hash table from the info structure.  This is
666    just a cast.  */
667
668 #define xcoff_hash_table(p) ((struct xcoff_link_hash_table *) ((p)->hash))
669 \f
670 /* Read internal relocs for an XCOFF csect.  This is a wrapper around
671    _bfd_coff_read_internal_relocs which tries to take advantage of any
672    relocs which may have been cached for the enclosing section.  */
673
674 static struct internal_reloc *
675 xcoff_read_internal_relocs (abfd, sec, cache, external_relocs,
676                             require_internal, internal_relocs)
677      bfd *abfd;
678      asection *sec;
679      boolean cache;
680      bfd_byte *external_relocs;
681      boolean require_internal;
682      struct internal_reloc *internal_relocs;
683 {
684   if (coff_section_data (abfd, sec) != NULL
685       && coff_section_data (abfd, sec)->relocs == NULL
686       && xcoff_section_data (abfd, sec) != NULL)
687     {
688       asection *enclosing;
689
690       enclosing = xcoff_section_data (abfd, sec)->enclosing;
691
692       if (enclosing != NULL
693           && (coff_section_data (abfd, enclosing) == NULL
694               || coff_section_data (abfd, enclosing)->relocs == NULL)
695           && cache
696           && enclosing->reloc_count > 0)
697         {
698           if (_bfd_coff_read_internal_relocs (abfd, enclosing, true,
699                                               external_relocs, false,
700                                               (struct internal_reloc *) NULL)
701               == NULL)
702             return NULL;
703         }
704
705       if (enclosing != NULL
706           && coff_section_data (abfd, enclosing) != NULL
707           && coff_section_data (abfd, enclosing)->relocs != NULL)
708         {
709           size_t off;
710
711           off = ((sec->rel_filepos - enclosing->rel_filepos)
712                  / bfd_coff_relsz (abfd));
713           if (! require_internal)
714             return coff_section_data (abfd, enclosing)->relocs + off;
715           memcpy (internal_relocs,
716                   coff_section_data (abfd, enclosing)->relocs + off,
717                   sec->reloc_count * sizeof (struct internal_reloc));
718           return internal_relocs;
719         }
720     }
721
722   return _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
723                                          require_internal, internal_relocs);
724 }
725 \f
726 /* Given an XCOFF BFD, add symbols to the global hash table as
727    appropriate.  */
728
729 boolean
730 _bfd_xcoff_bfd_link_add_symbols (abfd, info)
731      bfd *abfd;
732      struct bfd_link_info *info;
733 {
734   switch (bfd_get_format (abfd))
735     {
736     case bfd_object:
737       return xcoff_link_add_object_symbols (abfd, info);
738     case bfd_archive:
739       return (_bfd_generic_link_add_archive_symbols
740               (abfd, info, xcoff_link_check_archive_element));
741     default:
742       bfd_set_error (bfd_error_wrong_format);
743       return false;
744     }
745 }
746
747 /* Add symbols from an XCOFF object file.  */
748
749 static boolean
750 xcoff_link_add_object_symbols (abfd, info)
751      bfd *abfd;
752      struct bfd_link_info *info;
753 {
754   if (! _bfd_coff_get_external_symbols (abfd))
755     return false;
756   if (! xcoff_link_add_symbols (abfd, info))
757     return false;
758   if (! info->keep_memory)
759     {
760       if (! _bfd_coff_free_symbols (abfd))
761         return false;
762     }
763   return true;
764 }
765
766 /* Check a single archive element to see if we need to include it in
767    the link.  *PNEEDED is set according to whether this element is
768    needed in the link or not.  This is called via
769    _bfd_generic_link_add_archive_symbols.  */
770
771 static boolean
772 xcoff_link_check_archive_element (abfd, info, pneeded)
773      bfd *abfd;
774      struct bfd_link_info *info;
775      boolean *pneeded;
776 {
777   if (! _bfd_coff_get_external_symbols (abfd))
778     return false;
779
780   if (! xcoff_link_check_ar_symbols (abfd, info, pneeded))
781     return false;
782
783   if (*pneeded)
784     {
785       if (! xcoff_link_add_symbols (abfd, info))
786         return false;
787     }
788
789   if (! info->keep_memory || ! *pneeded)
790     {
791       if (! _bfd_coff_free_symbols (abfd))
792         return false;
793     }
794
795   return true;
796 }
797
798 /* Look through the symbols to see if this object file should be
799    included in the link.  */
800
801 static boolean
802 xcoff_link_check_ar_symbols (abfd, info, pneeded)
803      bfd *abfd;
804      struct bfd_link_info *info;
805      boolean *pneeded;
806 {
807   bfd_size_type symesz;
808   bfd_byte *esym;
809   bfd_byte *esym_end;
810
811   *pneeded = false;
812
813   symesz = bfd_coff_symesz (abfd);
814   esym = (bfd_byte *) obj_coff_external_syms (abfd);
815   esym_end = esym + obj_raw_syment_count (abfd) * symesz;
816   while (esym < esym_end)
817     {
818       struct internal_syment sym;
819
820       bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
821
822       if (sym.n_sclass == C_EXT && sym.n_scnum != N_UNDEF)
823         {
824           const char *name;
825           char buf[SYMNMLEN + 1];
826           struct bfd_link_hash_entry *h;
827
828           /* This symbol is externally visible, and is defined by this
829              object file.  */
830
831           name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
832           if (name == NULL)
833             return false;
834           h = bfd_link_hash_lookup (info->hash, name, false, false, true);
835
836           /* We are only interested in symbols that are currently
837              undefined.  If a symbol is currently known to be common,
838              XCOFF linkers do not bring in an object file which
839              defines it.  We also don't bring in symbols to satisfy
840              undefined references in shared objects.  */
841           if (h != (struct bfd_link_hash_entry *) NULL
842               && h->type == bfd_link_hash_undefined)
843             {
844               if (! (*info->callbacks->add_archive_element) (info, abfd, name))
845                 return false;
846               *pneeded = true;
847               return true;
848             }
849         }
850
851       esym += (sym.n_numaux + 1) * symesz;
852     }
853
854   /* We do not need this object file.  */
855   return true;
856 }
857
858 /* Returns the index of reloc in RELOCS with the least address greater
859    than or equal to ADDRESS.  The relocs are sorted by address.  */
860
861 static bfd_size_type
862 xcoff_find_reloc (relocs, count, address)
863      struct internal_reloc *relocs;
864      bfd_size_type count;
865      bfd_vma address;
866 {
867   bfd_size_type min, max, this;
868
869   if (count < 2)
870     {
871       if (count == 1 && relocs[0].r_vaddr < address)
872         return 1;
873       else
874         return 0;
875     }
876
877   min = 0;
878   max = count;
879
880   /* Do a binary search over (min,max].  */
881   while (min + 1 < max)
882     {
883       bfd_vma raddr;
884
885       this = (max + min) / 2;
886       raddr = relocs[this].r_vaddr;
887       if (raddr > address)
888         max = this;
889       else if (raddr < address)
890         min = this;
891       else
892         {
893           min = this;
894           break;
895         }
896     }
897
898   if (relocs[min].r_vaddr < address)
899     return min + 1;
900
901   while (min > 0
902          && relocs[min - 1].r_vaddr == address)
903     --min;
904
905   return min;
906 }
907
908 /* Add all the symbols from an object file to the hash table.
909
910    XCOFF is a weird format.  A normal XCOFF .o files will have three
911    COFF sections--.text, .data, and .bss--but each COFF section will
912    contain many csects.  These csects are described in the symbol
913    table.  From the linker's point of view, each csect must be
914    considered a section in its own right.  For example, a TOC entry is
915    handled as a small XMC_TC csect.  The linker must be able to merge
916    different TOC entries together, which means that it must be able to
917    extract the XMC_TC csects from the .data section of the input .o
918    file.
919
920    From the point of view of our linker, this is, of course, a hideous
921    nightmare.  We cope by actually creating sections for each csect,
922    and discarding the original sections.  We then have to handle the
923    relocation entries carefully, since the only way to tell which
924    csect they belong to is to examine the address.  */
925
926 static boolean
927 xcoff_link_add_symbols (abfd, info)
928      bfd *abfd;
929      struct bfd_link_info *info;
930 {
931   unsigned int n_tmask;
932   unsigned int n_btshft;
933   boolean default_copy;
934   bfd_size_type symcount;
935   struct xcoff_link_hash_entry **sym_hash;
936   asection **csect_cache;
937   bfd_size_type linesz;
938   asection *o;
939   asection *last_real;
940   boolean keep_syms;
941   asection *csect;
942   unsigned int csect_index;
943   asection *first_csect;
944   bfd_size_type symesz;
945   bfd_byte *esym;
946   bfd_byte *esym_end;
947   struct reloc_info_struct
948     {
949       struct internal_reloc *relocs;
950       asection **csects;
951       bfd_byte *linenos;
952     } *reloc_info = NULL;
953
954   if ((abfd->flags & DYNAMIC) != 0
955       && ! info->static_link)
956     {
957       if (! xcoff_link_add_dynamic_symbols (abfd, info))
958         return false;
959     }
960
961   /* We need to build a .loader section, so we do it here.  This won't
962      work if we're producing an XCOFF output file with no XCOFF input
963      files.  FIXME.  */
964   if (xcoff_hash_table (info)->loader_section == NULL)
965     {
966       asection *lsec;
967
968       lsec = bfd_make_section_anyway (abfd, ".loader");
969       if (lsec == NULL)
970         goto error_return;
971       xcoff_hash_table (info)->loader_section = lsec;
972       lsec->flags |= SEC_HAS_CONTENTS | SEC_IN_MEMORY;
973     }
974   /* Likewise for the linkage section.  */
975   if (xcoff_hash_table (info)->linkage_section == NULL)
976     {
977       asection *lsec;
978
979       lsec = bfd_make_section_anyway (abfd, ".gl");
980       if (lsec == NULL)
981         goto error_return;
982       xcoff_hash_table (info)->linkage_section = lsec;
983       lsec->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
984       lsec->alignment_power = 2;
985     }
986   /* Likewise for the TOC section.  */
987   if (xcoff_hash_table (info)->toc_section == NULL)
988     {
989       asection *tsec;
990
991       tsec = bfd_make_section_anyway (abfd, ".tc");
992       if (tsec == NULL)
993         goto error_return;
994       xcoff_hash_table (info)->toc_section = tsec;
995       tsec->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
996       tsec->alignment_power = 2;
997     }
998   /* Likewise for the descriptor section.  */
999   if (xcoff_hash_table (info)->descriptor_section == NULL)
1000     {
1001       asection *dsec;
1002
1003       dsec = bfd_make_section_anyway (abfd, ".ds");
1004       if (dsec == NULL)
1005         goto error_return;
1006       xcoff_hash_table (info)->descriptor_section = dsec;
1007       dsec->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
1008       dsec->alignment_power = 2;
1009     }
1010   /* Likewise for the .debug section.  */
1011   if (xcoff_hash_table (info)->debug_section == NULL)
1012     {
1013       asection *dsec;
1014
1015       dsec = bfd_make_section_anyway (abfd, ".debug");
1016       if (dsec == NULL)
1017         goto error_return;
1018       xcoff_hash_table (info)->debug_section = dsec;
1019       dsec->flags |= SEC_HAS_CONTENTS | SEC_IN_MEMORY;
1020     }
1021
1022   if ((abfd->flags & DYNAMIC) != 0
1023       && ! info->static_link)
1024     return true;
1025
1026   n_tmask = coff_data (abfd)->local_n_tmask;
1027   n_btshft = coff_data (abfd)->local_n_btshft;
1028
1029   /* Define macros so that ISFCN, et. al., macros work correctly.  */
1030 #define N_TMASK n_tmask
1031 #define N_BTSHFT n_btshft
1032
1033   if (info->keep_memory)
1034     default_copy = false;
1035   else
1036     default_copy = true;
1037
1038   symcount = obj_raw_syment_count (abfd);
1039
1040   /* We keep a list of the linker hash table entries that correspond
1041      to each external symbol.  */
1042   sym_hash = ((struct xcoff_link_hash_entry **)
1043               bfd_alloc (abfd,
1044                          (symcount
1045                           * sizeof (struct xcoff_link_hash_entry *))));
1046   if (sym_hash == NULL && symcount != 0)
1047     goto error_return;
1048   coff_data (abfd)->sym_hashes = (struct coff_link_hash_entry **) sym_hash;
1049   memset (sym_hash, 0,
1050           (size_t) symcount * sizeof (struct xcoff_link_hash_entry *));
1051
1052   /* Because of the weird stuff we are doing with XCOFF csects, we can
1053      not easily determine which section a symbol is in, so we store
1054      the information in the tdata for the input file.  */
1055   csect_cache = ((asection **)
1056                  bfd_alloc (abfd, symcount * sizeof (asection *)));
1057   if (csect_cache == NULL && symcount != 0)
1058     goto error_return;
1059   xcoff_data (abfd)->csects = csect_cache;
1060   memset (csect_cache, 0, (size_t) symcount * sizeof (asection *));
1061
1062   /* While splitting sections into csects, we need to assign the
1063      relocs correctly.  The relocs and the csects must both be in
1064      order by VMA within a given section, so we handle this by
1065      scanning along the relocs as we process the csects.  We index
1066      into reloc_info using the section target_index.  */
1067   reloc_info = ((struct reloc_info_struct *)
1068                 bfd_malloc ((abfd->section_count + 1)
1069                             * sizeof (struct reloc_info_struct)));
1070   if (reloc_info == NULL)
1071     goto error_return;
1072   memset ((PTR) reloc_info, 0,
1073           (abfd->section_count + 1) * sizeof (struct reloc_info_struct));
1074
1075   /* Read in the relocs and line numbers for each section.  */
1076   linesz = bfd_coff_linesz (abfd);
1077   last_real = NULL;
1078   for (o = abfd->sections; o != NULL; o = o->next)
1079     {
1080       last_real = o;
1081       if ((o->flags & SEC_RELOC) != 0)
1082         {
1083           reloc_info[o->target_index].relocs =
1084             xcoff_read_internal_relocs (abfd, o, true, (bfd_byte *) NULL,
1085                                         false, (struct internal_reloc *) NULL);
1086           reloc_info[o->target_index].csects =
1087             (asection **) bfd_malloc (o->reloc_count * sizeof (asection *));
1088           if (reloc_info[o->target_index].csects == NULL)
1089             goto error_return;
1090           memset (reloc_info[o->target_index].csects, 0,
1091                   o->reloc_count * sizeof (asection *));
1092         }
1093
1094       if ((info->strip == strip_none || info->strip == strip_some)
1095           && o->lineno_count > 0)
1096         {
1097           bfd_byte *linenos;
1098
1099           linenos = (bfd_byte *) bfd_malloc (o->lineno_count * linesz);
1100           if (linenos == NULL)
1101             goto error_return;
1102           reloc_info[o->target_index].linenos = linenos;
1103           if (bfd_seek (abfd, o->line_filepos, SEEK_SET) != 0
1104               || (bfd_read (linenos, linesz, o->lineno_count, abfd)
1105                   != linesz * o->lineno_count))
1106             goto error_return;
1107         }
1108     }
1109
1110   /* Don't let the linker relocation routines discard the symbols.  */
1111   keep_syms = obj_coff_keep_syms (abfd);
1112   obj_coff_keep_syms (abfd) = true;
1113
1114   csect = NULL;
1115   csect_index = 0;
1116   first_csect = NULL;
1117
1118   symesz = bfd_coff_symesz (abfd);
1119   BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
1120   esym = (bfd_byte *) obj_coff_external_syms (abfd);
1121   esym_end = esym + symcount * symesz;
1122   while (esym < esym_end)
1123     {
1124       struct internal_syment sym;
1125       union internal_auxent aux;
1126       const char *name;
1127       char buf[SYMNMLEN + 1];
1128       int smtyp;
1129       flagword flags;
1130       asection *section;
1131       bfd_vma value;
1132       struct xcoff_link_hash_entry *set_toc;
1133
1134       bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
1135
1136       /* In this pass we are only interested in symbols with csect
1137          information.  */
1138       if (sym.n_sclass != C_EXT && sym.n_sclass != C_HIDEXT)
1139         {
1140           if (sym.n_sclass == C_FILE && csect != NULL)
1141             {
1142               xcoff_section_data (abfd, csect)->last_symndx =
1143                 ((esym
1144                   - (bfd_byte *) obj_coff_external_syms (abfd))
1145                  / symesz);
1146               csect = NULL;
1147             }
1148
1149           if (csect != NULL)
1150             *csect_cache = csect;
1151           else if (first_csect == NULL || sym.n_sclass == C_FILE)
1152             *csect_cache = coff_section_from_bfd_index (abfd, sym.n_scnum);
1153           else
1154             *csect_cache = NULL;
1155           esym += (sym.n_numaux + 1) * symesz;
1156           sym_hash += sym.n_numaux + 1;
1157           csect_cache += sym.n_numaux + 1;
1158           continue;
1159         }
1160
1161       name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
1162       if (name == NULL)
1163         goto error_return;
1164
1165       /* If this symbol has line number information attached to it,
1166          and we're not stripping it, count the number of entries and
1167          add them to the count for this csect.  In the final link pass
1168          we are going to attach line number information by symbol,
1169          rather than by section, in order to more easily handle
1170          garbage collection.  */
1171       if ((info->strip == strip_none || info->strip == strip_some)
1172           && sym.n_numaux > 1
1173           && csect != NULL
1174           && ISFCN (sym.n_type))
1175         {
1176           union internal_auxent auxlin;
1177
1178           bfd_coff_swap_aux_in (abfd, (PTR) (esym + symesz),
1179                                 sym.n_type, sym.n_sclass,
1180                                 0, sym.n_numaux, (PTR) &auxlin);
1181           if (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
1182             {
1183               asection *enclosing;
1184               bfd_size_type linoff;
1185
1186               enclosing = xcoff_section_data (abfd, csect)->enclosing;
1187               if (enclosing == NULL)
1188                 {
1189                   (*_bfd_error_handler)
1190                     ("%s: `%s' has line numbers but no enclosing section",
1191                      bfd_get_filename (abfd), name);
1192                   bfd_set_error (bfd_error_bad_value);
1193                   goto error_return;
1194                 }
1195               linoff = (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr
1196                         - enclosing->line_filepos);
1197               if (linoff < enclosing->lineno_count * linesz)
1198                 {
1199                   struct internal_lineno lin;
1200                   bfd_byte *linpstart;
1201
1202                   linpstart = (reloc_info[enclosing->target_index].linenos
1203                                + linoff);
1204                   bfd_coff_swap_lineno_in (abfd, (PTR) linpstart, (PTR) &lin);
1205                   if (lin.l_lnno == 0
1206                       && ((bfd_size_type) lin.l_addr.l_symndx
1207                           == ((esym
1208                                - (bfd_byte *) obj_coff_external_syms (abfd))
1209                               / symesz)))
1210                     {
1211                       bfd_byte *linpend, *linp;
1212
1213                       linpend = (reloc_info[enclosing->target_index].linenos
1214                                  + enclosing->lineno_count * linesz);
1215                       for (linp = linpstart + linesz;
1216                            linp < linpend;
1217                            linp += linesz)
1218                         {
1219                           bfd_coff_swap_lineno_in (abfd, (PTR) linp,
1220                                                    (PTR) &lin);
1221                           if (lin.l_lnno == 0)
1222                             break;
1223                         }
1224                       csect->lineno_count += (linp - linpstart) / linesz;
1225                       /* The setting of line_filepos will only be
1226                          useful if all the line number entries for a
1227                          csect are contiguous; this only matters for
1228                          error reporting.  */
1229                       if (csect->line_filepos == 0)
1230                         csect->line_filepos =
1231                           auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr;
1232                     }
1233                 }
1234             }
1235         }
1236
1237       /* Pick up the csect auxiliary information.  */
1238
1239       if (sym.n_numaux == 0)
1240         {
1241           (*_bfd_error_handler)
1242             ("%s: class %d symbol `%s' has no aux entries",
1243              bfd_get_filename (abfd), sym.n_sclass, name);
1244           bfd_set_error (bfd_error_bad_value);
1245           goto error_return;
1246         }
1247
1248       bfd_coff_swap_aux_in (abfd,
1249                             (PTR) (esym + symesz * sym.n_numaux),
1250                             sym.n_type, sym.n_sclass,
1251                             sym.n_numaux - 1, sym.n_numaux,
1252                             (PTR) &aux);
1253
1254       smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
1255
1256       flags = BSF_GLOBAL;
1257       section = NULL;
1258       value = 0;
1259       set_toc = NULL;
1260
1261       switch (smtyp)
1262         {
1263         default:
1264           (*_bfd_error_handler)
1265             ("%s: symbol `%s' has unrecognized csect type %d",
1266              bfd_get_filename (abfd), name, smtyp);
1267           bfd_set_error (bfd_error_bad_value);
1268           goto error_return;
1269
1270         case XTY_ER:
1271           /* This is an external reference.  */
1272           if (sym.n_sclass == C_HIDEXT
1273               || sym.n_scnum != N_UNDEF
1274               || aux.x_csect.x_scnlen.l != 0)
1275             {
1276               (*_bfd_error_handler)
1277                 ("%s: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d",
1278                  bfd_get_filename (abfd), name, sym.n_sclass, sym.n_scnum,
1279                  aux.x_csect.x_scnlen.l);
1280               bfd_set_error (bfd_error_bad_value);
1281               goto error_return;
1282             }
1283
1284           /* An XMC_XO external reference is actually a reference to
1285              an absolute location.  */
1286           if (aux.x_csect.x_smclas != XMC_XO)
1287             section = bfd_und_section_ptr;
1288           else
1289             {
1290               section = bfd_abs_section_ptr;
1291               value = sym.n_value;
1292             }
1293           break;
1294
1295         case XTY_SD:
1296           /* This is a csect definition.  */
1297
1298           if (csect != NULL)
1299             {
1300               xcoff_section_data (abfd, csect)->last_symndx =
1301                 ((esym
1302                   - (bfd_byte *) obj_coff_external_syms (abfd))
1303                  / symesz);
1304             }
1305
1306           csect = NULL;
1307           csect_index = -1;
1308
1309           /* When we see a TOC anchor, we record the TOC value.  */
1310           if (aux.x_csect.x_smclas == XMC_TC0)
1311             {
1312               if (sym.n_sclass != C_HIDEXT
1313                   || aux.x_csect.x_scnlen.l != 0)
1314                 {
1315                   (*_bfd_error_handler)
1316                     ("%s: XMC_TC0 symbol `%s' is class %d scnlen %d",
1317                      bfd_get_filename (abfd), name, sym.n_sclass,
1318                      aux.x_csect.x_scnlen.l);
1319                   bfd_set_error (bfd_error_bad_value);
1320                   goto error_return;
1321                 }
1322               xcoff_data (abfd)->toc = sym.n_value;
1323             }
1324
1325           /* We must merge TOC entries for the same symbol.  We can
1326              merge two TOC entries if they are both C_HIDEXT, they
1327              both have the same name, they are both 4 bytes long, and
1328              they both have a relocation table entry for an external
1329              symbol with the same name.  Unfortunately, this means
1330              that we must look through the relocations.  Ick.  */
1331           if (aux.x_csect.x_smclas == XMC_TC
1332               && sym.n_sclass == C_HIDEXT
1333               && aux.x_csect.x_scnlen.l == 4
1334               && info->hash->creator == abfd->xvec)
1335             {
1336               asection *enclosing;
1337               struct internal_reloc *relocs;
1338               bfd_size_type relindx;
1339               struct internal_reloc *rel;
1340
1341               enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1342               if (enclosing == NULL)
1343                 goto error_return;
1344
1345               relocs = reloc_info[enclosing->target_index].relocs;
1346               relindx = xcoff_find_reloc (relocs, enclosing->reloc_count,
1347                                           sym.n_value);
1348               rel = relocs + relindx;
1349               if (relindx < enclosing->reloc_count
1350                   && rel->r_vaddr == (bfd_vma) sym.n_value
1351                   && rel->r_size == 31
1352                   && rel->r_type == R_POS)
1353                 {
1354                   bfd_byte *erelsym;
1355                   struct internal_syment relsym;
1356
1357                   erelsym = ((bfd_byte *) obj_coff_external_syms (abfd)
1358                              + rel->r_symndx * symesz);
1359                   bfd_coff_swap_sym_in (abfd, (PTR) erelsym, (PTR) &relsym);
1360                   if (relsym.n_sclass == C_EXT)
1361                     {
1362                       const char *relname;
1363                       char relbuf[SYMNMLEN + 1];
1364                       boolean copy;
1365                       struct xcoff_link_hash_entry *h;
1366
1367                       /* At this point we know that the TOC entry is
1368                          for an externally visible symbol.  */
1369                       relname = _bfd_coff_internal_syment_name (abfd, &relsym,
1370                                                                 relbuf);
1371                       if (relname == NULL)
1372                         goto error_return;
1373
1374                       /* We only merge TOC entries if the TC name is
1375                          the same as the symbol name.  This handles
1376                          the normal case, but not common cases like
1377                          SYM.P4 which gcc generates to store SYM + 4
1378                          in the TOC.  FIXME.  */
1379                       if (strcmp (name, relname) == 0)
1380                         {
1381                           copy = (! info->keep_memory
1382                                   || relsym._n._n_n._n_zeroes != 0
1383                                   || relsym._n._n_n._n_offset == 0);
1384                           h = xcoff_link_hash_lookup (xcoff_hash_table (info),
1385                                                       relname, true, copy,
1386                                                       false);
1387                           if (h == NULL)
1388                             goto error_return;
1389
1390                           /* At this point h->root.type could be
1391                              bfd_link_hash_new.  That should be OK,
1392                              since we know for sure that we will come
1393                              across this symbol as we step through the
1394                              file.  */
1395
1396                           /* We store h in *sym_hash for the
1397                              convenience of the relocate_section
1398                              function.  */
1399                           *sym_hash = h;
1400
1401                           if (h->toc_section != NULL)
1402                             {
1403                               asection **rel_csects;
1404
1405                               /* We already have a TOC entry for this
1406                                  symbol, so we can just ignore this
1407                                  one.  */
1408                               rel_csects =
1409                                 reloc_info[enclosing->target_index].csects;
1410                               rel_csects[relindx] = bfd_und_section_ptr;
1411                               break;
1412                             }
1413
1414                           /* We are about to create a TOC entry for
1415                              this symbol.  */
1416                           set_toc = h;
1417                         }
1418                     }
1419                 }
1420             }
1421
1422           /* We need to create a new section.  We get the name from
1423              the csect storage mapping class, so that the linker can
1424              accumulate similar csects together.  */
1425           {
1426             static const char *csect_name_by_class[] =
1427               {
1428                 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
1429                 ".sv", ".bs", ".ds", ".uc", ".ti", ".tb", NULL, ".tc0",
1430                 ".td"
1431               };
1432             const char *csect_name;
1433             asection *enclosing;
1434
1435             if ((aux.x_csect.x_smclas >=
1436                  sizeof csect_name_by_class / sizeof csect_name_by_class[0])
1437                 || csect_name_by_class[aux.x_csect.x_smclas] == NULL)
1438               {
1439                 (*_bfd_error_handler)
1440                   ("%s: symbol `%s' has unrecognized smclas %d",
1441                    bfd_get_filename (abfd), name, aux.x_csect.x_smclas);
1442                 bfd_set_error (bfd_error_bad_value);
1443                 goto error_return;
1444               }
1445
1446             csect_name = csect_name_by_class[aux.x_csect.x_smclas];
1447             csect = bfd_make_section_anyway (abfd, csect_name);
1448             if (csect == NULL)
1449               goto error_return;
1450             enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1451             if (enclosing == NULL)
1452               goto error_return;
1453             if (! bfd_is_abs_section (enclosing)
1454                 && ((bfd_vma) sym.n_value < enclosing->vma
1455                     || ((bfd_vma) sym.n_value + aux.x_csect.x_scnlen.l
1456                         > enclosing->vma + enclosing->_raw_size)))
1457               {
1458                 (*_bfd_error_handler)
1459                   ("%s: csect `%s' not in enclosing section",
1460                    bfd_get_filename (abfd), name);
1461                 bfd_set_error (bfd_error_bad_value);
1462                 goto error_return;
1463               }
1464             csect->vma = sym.n_value;
1465             csect->filepos = (enclosing->filepos
1466                               + sym.n_value
1467                               - enclosing->vma);
1468             csect->_raw_size = aux.x_csect.x_scnlen.l;
1469             csect->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
1470             csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
1471
1472             /* Record the enclosing section in the tdata for this new
1473                section.  */
1474             csect->used_by_bfd =
1475               ((struct coff_section_tdata *)
1476                bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
1477             if (csect->used_by_bfd == NULL)
1478               goto error_return;
1479             coff_section_data (abfd, csect)->tdata =
1480               bfd_zalloc (abfd, sizeof (struct xcoff_section_tdata));
1481             if (coff_section_data (abfd, csect)->tdata == NULL)
1482               goto error_return;
1483             xcoff_section_data (abfd, csect)->enclosing = enclosing;
1484             xcoff_section_data (abfd, csect)->lineno_count =
1485               enclosing->lineno_count;
1486
1487             if (enclosing->owner == abfd)
1488               {
1489                 struct internal_reloc *relocs;
1490                 bfd_size_type relindx;
1491                 struct internal_reloc *rel;
1492                 asection **rel_csect;
1493
1494                 relocs = reloc_info[enclosing->target_index].relocs;
1495                 relindx = xcoff_find_reloc (relocs, enclosing->reloc_count,
1496                                             csect->vma);
1497                 rel = relocs + relindx;
1498                 rel_csect = (reloc_info[enclosing->target_index].csects
1499                              + relindx);
1500                 csect->rel_filepos = (enclosing->rel_filepos
1501                                       + relindx * bfd_coff_relsz (abfd));
1502                 while (relindx < enclosing->reloc_count
1503                        && *rel_csect == NULL
1504                        && rel->r_vaddr < csect->vma + csect->_raw_size)
1505                   {
1506                     *rel_csect = csect;
1507                     csect->flags |= SEC_RELOC;
1508                     ++csect->reloc_count;
1509                     ++relindx;
1510                     ++rel;
1511                     ++rel_csect;
1512                   }
1513               }
1514
1515             /* There are a number of other fields and section flags
1516                which we do not bother to set.  */
1517
1518             csect_index = ((esym
1519                             - (bfd_byte *) obj_coff_external_syms (abfd))
1520                            / symesz);
1521
1522             xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1523
1524             if (first_csect == NULL)
1525               first_csect = csect;
1526
1527             /* If this symbol is C_EXT, we treat it as starting at the
1528                beginning of the newly created section.  */
1529             if (sym.n_sclass == C_EXT)
1530               {
1531                 section = csect;
1532                 value = 0;
1533               }
1534
1535             /* If this is a TOC section for a symbol, record it.  */
1536             if (set_toc != NULL)
1537               set_toc->toc_section = csect;
1538           }
1539           break;
1540
1541         case XTY_LD:
1542           /* This is a label definition.  The x_scnlen field is the
1543              symbol index of the csect.  I believe that this must
1544              always follow the appropriate XTY_SD symbol, so I will
1545              insist on it.  */
1546           {
1547             boolean bad;
1548
1549             bad = false;
1550             if (aux.x_csect.x_scnlen.l < 0
1551                 || (aux.x_csect.x_scnlen.l
1552                     >= esym - (bfd_byte *) obj_coff_external_syms (abfd)))
1553               bad = true;
1554             if (! bad)
1555               {
1556                 section = xcoff_data (abfd)->csects[aux.x_csect.x_scnlen.l];
1557                 if (section == NULL
1558                     || (section->flags & SEC_HAS_CONTENTS) == 0)
1559                   bad = true;
1560               }
1561             if (bad)
1562               {
1563                 (*_bfd_error_handler)
1564                   ("%s: misplaced XTY_LD `%s'",
1565                    bfd_get_filename (abfd), name);
1566                 bfd_set_error (bfd_error_bad_value);
1567                 goto error_return;
1568               }
1569
1570             value = sym.n_value - csect->vma;
1571           }
1572           break;
1573
1574         case XTY_CM:
1575           /* This is an unitialized csect.  We could base the name on
1576              the storage mapping class, but we don't bother.  If this
1577              csect is externally visible, it is a common symbol.  */
1578
1579           if (csect != NULL)
1580             {
1581               xcoff_section_data (abfd, csect)->last_symndx =
1582                 ((esym
1583                   - (bfd_byte *) obj_coff_external_syms (abfd))
1584                  / symesz);
1585             }
1586
1587           csect = bfd_make_section_anyway (abfd, ".bss");
1588           if (csect == NULL)
1589             goto error_return;
1590           csect->vma = sym.n_value;
1591           csect->_raw_size = aux.x_csect.x_scnlen.l;
1592           csect->flags |= SEC_ALLOC;
1593           csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
1594           /* There are a number of other fields and section flags
1595              which we do not bother to set.  */
1596
1597           csect_index = ((esym
1598                           - (bfd_byte *) obj_coff_external_syms (abfd))
1599                          / symesz);
1600
1601           csect->used_by_bfd =
1602             ((struct coff_section_tdata *)
1603              bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
1604           if (csect->used_by_bfd == NULL)
1605             goto error_return;
1606           coff_section_data (abfd, csect)->tdata =
1607             bfd_zalloc (abfd, sizeof (struct xcoff_section_tdata));
1608           if (coff_section_data (abfd, csect)->tdata == NULL)
1609             goto error_return;
1610           xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1611
1612           if (first_csect == NULL)
1613             first_csect = csect;
1614
1615           if (sym.n_sclass == C_EXT)
1616             {
1617               csect->flags |= SEC_IS_COMMON;
1618               csect->_raw_size = 0;
1619               section = csect;
1620               value = aux.x_csect.x_scnlen.l;
1621             }
1622
1623           break;
1624         }
1625
1626       /* Check for magic symbol names.  */
1627       if ((smtyp == XTY_SD || smtyp == XTY_CM)
1628           && aux.x_csect.x_smclas != XMC_TC)
1629         {
1630           int i;
1631
1632           i = -1;
1633           if (name[0] == '_')
1634             {
1635               if (strcmp (name, "_text") == 0)
1636                 i = 0;
1637               else if (strcmp (name, "_etext") == 0)
1638                 i = 1;
1639               else if (strcmp (name, "_data") == 0)
1640                 i = 2;
1641               else if (strcmp (name, "_edata") == 0)
1642                 i = 3;
1643               else if (strcmp (name, "_end") == 0)
1644                 i = 4;
1645             }
1646           else if (name[0] == 'e' && strcmp (name, "end") == 0)
1647             i = 5;
1648
1649           if (i != -1)
1650             xcoff_hash_table (info)->special_sections[i] = csect;
1651         }
1652
1653       /* Now we have enough information to add the symbol to the
1654          linker hash table.  */
1655
1656       if (sym.n_sclass == C_EXT)
1657         {
1658           boolean copy;
1659
1660           BFD_ASSERT (section != NULL);
1661
1662           /* We must copy the name into memory if we got it from the
1663              syment itself, rather than the string table.  */
1664           copy = default_copy;
1665           if (sym._n._n_n._n_zeroes != 0
1666               || sym._n._n_n._n_offset == 0)
1667             copy = true;
1668
1669           if (info->hash->creator == abfd->xvec)
1670             {
1671               /* If we are statically linking a shared object, it is
1672                  OK for symbol redefinitions to occur.  I can't figure
1673                  out just what the XCOFF linker is doing, but
1674                  something like this is required for -bnso to work.  */
1675               if (! bfd_is_und_section (section))
1676                 *sym_hash = xcoff_link_hash_lookup (xcoff_hash_table (info),
1677                                                     name, true, copy, false);
1678               else
1679                 *sym_hash = ((struct xcoff_link_hash_entry *)
1680                              bfd_wrapped_link_hash_lookup (abfd, info, name,
1681                                                            true, copy, false));
1682               if (*sym_hash == NULL)
1683                 goto error_return;
1684               if (((*sym_hash)->root.type == bfd_link_hash_defined
1685                    || (*sym_hash)->root.type == bfd_link_hash_defweak)
1686                   && ! bfd_is_und_section (section)
1687                   && ! bfd_is_com_section (section))
1688                 {
1689                   if ((abfd->flags & DYNAMIC) != 0)
1690                     {
1691                       section = bfd_und_section_ptr;
1692                       value = 0;
1693                     }
1694                   else if (((*sym_hash)->root.u.def.section->owner->flags
1695                             & DYNAMIC) != 0)
1696                     {
1697                       (*sym_hash)->root.type = bfd_link_hash_undefined;
1698                       (*sym_hash)->root.u.undef.abfd =
1699                         (*sym_hash)->root.u.def.section->owner;
1700                     }
1701                 }
1702             }
1703
1704           /* _bfd_generic_link_add_one_symbol may call the linker to
1705              generate an error message, and the linker may try to read
1706              the symbol table to give a good error.  Right now, the
1707              line numbers are in an inconsistent state, since they are
1708              counted both in the real sections and in the new csects.
1709              We need to leave the count in the real sections so that
1710              the linker can report the line number of the error
1711              correctly, so temporarily clobber the link to the csects
1712              so that the linker will not try to read the line numbers
1713              a second time from the csects.  */
1714           BFD_ASSERT (last_real->next == first_csect);
1715           last_real->next = NULL;
1716           if (! (_bfd_generic_link_add_one_symbol
1717                  (info, abfd, name, flags, section, value,
1718                   (const char *) NULL, copy, true,
1719                   (struct bfd_link_hash_entry **) sym_hash)))
1720             goto error_return;
1721           last_real->next = first_csect;
1722
1723           if (smtyp == XTY_CM)
1724             {
1725               if ((*sym_hash)->root.type != bfd_link_hash_common
1726                   || (*sym_hash)->root.u.c.p->section != csect)
1727                 {
1728                   /* We don't need the common csect we just created.  */
1729                   csect->_raw_size = 0;
1730                 }
1731               else
1732                 {
1733                   (*sym_hash)->root.u.c.p->alignment_power
1734                      = csect->alignment_power;
1735                 }
1736             }
1737
1738           if (info->hash->creator == abfd->xvec)
1739             {
1740               int flag;
1741
1742               if (smtyp == XTY_ER || smtyp == XTY_CM)
1743                 flag = XCOFF_REF_REGULAR;
1744               else
1745                 flag = XCOFF_DEF_REGULAR;
1746               (*sym_hash)->flags |= flag;
1747
1748               if ((*sym_hash)->smclas == XMC_UA
1749                   || flag == XCOFF_DEF_REGULAR)
1750                 (*sym_hash)->smclas = aux.x_csect.x_smclas;
1751             }
1752         }
1753
1754       *csect_cache = csect;
1755
1756       esym += (sym.n_numaux + 1) * symesz;
1757       sym_hash += sym.n_numaux + 1;
1758       csect_cache += sym.n_numaux + 1;
1759     }
1760
1761   BFD_ASSERT (last_real == NULL || last_real->next == first_csect);
1762
1763   /* Make sure that we have seen all the relocs.  */
1764   for (o = abfd->sections; o != first_csect; o = o->next)
1765     {
1766       /* Reset the section size and the line numebr count, since the
1767          data is now attached to the csects.  Don't reset the size of
1768          the .debug section, since we need to read it below in
1769          bfd_xcoff_size_dynamic_sections.  */
1770       if (strcmp (bfd_get_section_name (abfd, o), ".debug") != 0)
1771         o->_raw_size = 0;
1772       o->lineno_count = 0;
1773
1774       if ((o->flags & SEC_RELOC) != 0)
1775         {
1776           bfd_size_type i;
1777           struct internal_reloc *rel;
1778           asection **rel_csect;
1779
1780           rel = reloc_info[o->target_index].relocs;
1781           rel_csect = reloc_info[o->target_index].csects;
1782           for (i = 0; i < o->reloc_count; i++, rel++, rel_csect++)
1783             {
1784               if (*rel_csect == NULL)
1785                 {
1786                   (*_bfd_error_handler)
1787                     ("%s: reloc %s:%d not in csect",
1788                      bfd_get_filename (abfd), o->name, i);
1789                   bfd_set_error (bfd_error_bad_value);
1790                   goto error_return;
1791                 }
1792
1793               /* We identify all symbols which are called, so that we
1794                  can create glue code for calls to functions imported
1795                  from dynamic objects.  */
1796               if (info->hash->creator == abfd->xvec
1797                   && *rel_csect != bfd_und_section_ptr
1798                   && (rel->r_type == R_BR
1799                       || rel->r_type == R_RBR)
1800                   && obj_xcoff_sym_hashes (abfd)[rel->r_symndx] != NULL)
1801                 {
1802                   struct xcoff_link_hash_entry *h;
1803
1804                   h = obj_xcoff_sym_hashes (abfd)[rel->r_symndx];
1805                   h->flags |= XCOFF_CALLED;
1806                   /* If the symbol name starts with a period, it is
1807                      the code of a function.  If the symbol is
1808                      currently undefined, then add an undefined symbol
1809                      for the function descriptor.  This should do no
1810                      harm, because any regular object that defines the
1811                      function should also define the function
1812                      descriptor.  It helps, because it means that we
1813                      will identify the function descriptor with a
1814                      dynamic object if a dynamic object defines it.  */
1815                   if (h->root.root.string[0] == '.'
1816                       && h->descriptor == NULL)
1817                     {
1818                       struct xcoff_link_hash_entry *hds;
1819
1820                       hds = xcoff_link_hash_lookup (xcoff_hash_table (info),
1821                                                     h->root.root.string + 1,
1822                                                     true, false, true);
1823                       if (hds == NULL)
1824                         goto error_return;
1825                       if (hds->root.type == bfd_link_hash_new)
1826                         {
1827                           if (! (_bfd_generic_link_add_one_symbol
1828                                  (info, abfd, hds->root.root.string,
1829                                   (flagword) 0, bfd_und_section_ptr,
1830                                   (bfd_vma) 0, (const char *) NULL, false,
1831                                   true,
1832                                   (struct bfd_link_hash_entry **) &hds)))
1833                             goto error_return;
1834                         }
1835                       hds->flags |= XCOFF_DESCRIPTOR;
1836                       BFD_ASSERT ((hds->flags & XCOFF_CALLED) == 0
1837                                   && (h->flags & XCOFF_DESCRIPTOR) == 0);
1838                       hds->descriptor = h;
1839                       h->descriptor = hds;
1840                     }
1841                 }
1842             }
1843
1844           free (reloc_info[o->target_index].csects);
1845           reloc_info[o->target_index].csects = NULL;
1846
1847           /* Reset SEC_RELOC and the reloc_count, since the reloc
1848              information is now attached to the csects.  */
1849           o->flags &=~ SEC_RELOC;
1850           o->reloc_count = 0;
1851
1852           /* If we are not keeping memory, free the reloc information.  */
1853           if (! info->keep_memory
1854               && coff_section_data (abfd, o) != NULL
1855               && coff_section_data (abfd, o)->relocs != NULL
1856               && ! coff_section_data (abfd, o)->keep_relocs)
1857             {
1858               free (coff_section_data (abfd, o)->relocs);
1859               coff_section_data (abfd, o)->relocs = NULL;
1860             }
1861         }
1862
1863       /* Free up the line numbers.  FIXME: We could cache these
1864          somewhere for the final link, to avoid reading them again.  */
1865       if (reloc_info[o->target_index].linenos != NULL)
1866         {
1867           free (reloc_info[o->target_index].linenos);
1868           reloc_info[o->target_index].linenos = NULL;
1869         }
1870     }
1871
1872   free (reloc_info);
1873
1874   obj_coff_keep_syms (abfd) = keep_syms;
1875
1876   return true;
1877
1878  error_return:
1879   if (reloc_info != NULL)
1880     {
1881       for (o = abfd->sections; o != NULL; o = o->next)
1882         {
1883           if (reloc_info[o->target_index].csects != NULL)
1884             free (reloc_info[o->target_index].csects);
1885           if (reloc_info[o->target_index].linenos != NULL)
1886             free (reloc_info[o->target_index].linenos);
1887         }
1888     free (reloc_info);
1889     }
1890   obj_coff_keep_syms (abfd) = keep_syms;
1891   return false;
1892 }
1893
1894 #undef N_TMASK
1895 #undef N_BTSHFT
1896
1897 /* This function is used to add symbols from a dynamic object to the
1898    global symbol table.  */
1899
1900 static boolean
1901 xcoff_link_add_dynamic_symbols (abfd, info)
1902      bfd *abfd;
1903      struct bfd_link_info *info;
1904 {
1905   asection *lsec;
1906   bfd_byte *buf = NULL;
1907   struct internal_ldhdr ldhdr;
1908   const char *strings;
1909   struct external_ldsym *elsym, *elsymend;
1910   struct xcoff_import_file *n;
1911   const char *bname;
1912   const char *mname;
1913   const char *s;
1914   unsigned int c;
1915   struct xcoff_import_file **pp;
1916
1917   /* We can only handle a dynamic object if we are generating an XCOFF
1918      output file.  */
1919   if (info->hash->creator != abfd->xvec)
1920     {
1921       (*_bfd_error_handler)
1922         ("%s: XCOFF shared object when not producing XCOFF output",
1923          bfd_get_filename (abfd));
1924       bfd_set_error (bfd_error_invalid_operation);
1925       goto error_return;
1926     }
1927
1928   /* The symbols we use from a dynamic object are not the symbols in
1929      the normal symbol table, but, rather, the symbols in the export
1930      table.  If there is a global symbol in a dynamic object which is
1931      not in the export table, the loader will not be able to find it,
1932      so we don't want to find it either.  Also, on AIX 4.1.3, shr.o in
1933      libc.a has symbols in the export table which are not in the
1934      symbol table.  */
1935
1936   /* Read in the .loader section.  FIXME: We should really use the
1937      o_snloader field in the a.out header, rather than grabbing the
1938      section by name.  */
1939   lsec = bfd_get_section_by_name (abfd, ".loader");
1940   if (lsec == NULL)
1941     {
1942       (*_bfd_error_handler)
1943         ("%s: dynamic object with no .loader section",
1944          bfd_get_filename (abfd));
1945       bfd_set_error (bfd_error_no_symbols);
1946       goto error_return;
1947     }
1948
1949   buf = (bfd_byte *) bfd_malloc (lsec->_raw_size);
1950   if (buf == NULL && lsec->_raw_size > 0)
1951     goto error_return;
1952
1953   if (! bfd_get_section_contents (abfd, lsec, (PTR) buf, (file_ptr) 0,
1954                                   lsec->_raw_size))
1955     goto error_return;
1956
1957   /* Remove the sections from this object, so that they do not get
1958      included in the link.  */
1959   abfd->sections = NULL;
1960
1961   xcoff_swap_ldhdr_in (abfd, (struct external_ldhdr *) buf, &ldhdr);
1962
1963   strings = (char *) buf + ldhdr.l_stoff;
1964
1965   elsym = (struct external_ldsym *) (buf + LDHDRSZ);
1966   elsymend = elsym + ldhdr.l_nsyms;
1967   BFD_ASSERT (sizeof (struct external_ldsym) == LDSYMSZ);
1968   for (; elsym < elsymend; elsym++)
1969     {
1970       struct internal_ldsym ldsym;
1971       char nambuf[SYMNMLEN + 1];
1972       const char *name;
1973       struct xcoff_link_hash_entry *h;
1974
1975       xcoff_swap_ldsym_in (abfd, elsym, &ldsym);
1976
1977       /* We are only interested in exported symbols.  */
1978       if ((ldsym.l_smtype & L_EXPORT) == 0)
1979         continue;
1980
1981       if (ldsym._l._l_l._l_zeroes == 0)
1982         name = strings + ldsym._l._l_l._l_offset;
1983       else
1984         {
1985           memcpy (nambuf, ldsym._l._l_name, SYMNMLEN);
1986           nambuf[SYMNMLEN] = '\0';
1987           name = nambuf;
1988         }
1989
1990       /* Normally we could not call xcoff_link_hash_lookup in an add
1991          symbols routine, since we might not be using an XCOFF hash
1992          table.  However, we verified above that we are using an XCOFF
1993          hash table.  */
1994
1995       h = xcoff_link_hash_lookup (xcoff_hash_table (info), name, true,
1996                                   true, true);
1997       if (h == NULL)
1998         goto error_return;
1999
2000       h->flags |= XCOFF_DEF_DYNAMIC;
2001
2002       /* If the symbol is undefined, and the BFD it was found in is
2003          not a dynamic object, change the BFD to this dynamic object,
2004          so that we can get the correct import file ID.  */
2005       if ((h->root.type == bfd_link_hash_undefined
2006            || h->root.type == bfd_link_hash_undefweak)
2007           && (h->root.u.undef.abfd == NULL
2008               || (h->root.u.undef.abfd->flags & DYNAMIC) == 0))
2009         h->root.u.undef.abfd = abfd;
2010
2011       if (h->root.type == bfd_link_hash_new)
2012         {
2013           h->root.type = bfd_link_hash_undefined;
2014           h->root.u.undef.abfd = abfd;
2015           /* We do not want to add this to the undefined symbol list.  */
2016         }
2017
2018       if (h->smclas == XMC_UA
2019           || h->root.type == bfd_link_hash_undefined
2020           || h->root.type == bfd_link_hash_undefweak)
2021         h->smclas = ldsym.l_smclas;
2022
2023       /* Unless this is an XMC_XO symbol, we don't bother to actually
2024          define it, since we don't have a section to put it in anyhow.
2025          Instead, the relocation routines handle the DEF_DYNAMIC flag
2026          correctly.  */
2027
2028       if (h->smclas == XMC_XO
2029           && (h->root.type == bfd_link_hash_undefined
2030               || h->root.type == bfd_link_hash_undefweak))
2031         {
2032           /* This symbol has an absolute value.  */
2033           h->root.type = bfd_link_hash_defined;
2034           h->root.u.def.section = bfd_abs_section_ptr;
2035           h->root.u.def.value = ldsym.l_value;
2036         }
2037     }
2038
2039   if (buf != NULL)
2040     {
2041       free (buf);
2042       buf = NULL;
2043     }
2044
2045   /* Record this file in the import files.  */
2046
2047   n = ((struct xcoff_import_file *)
2048        bfd_alloc (abfd, sizeof (struct xcoff_import_file)));
2049   if (n == NULL)
2050     goto error_return;
2051   n->next = NULL;
2052
2053   /* For some reason, the path entry in the import file list for a
2054      shared object appears to always be empty.  The file name is the
2055      base name.  */
2056   n->path = "";
2057   if (abfd->my_archive == NULL)
2058     {
2059       bname = bfd_get_filename (abfd);
2060       mname = "";
2061     }
2062   else
2063     {
2064       bname = bfd_get_filename (abfd->my_archive);
2065       mname = bfd_get_filename (abfd);
2066     }
2067   s = strrchr (bname, '/');
2068   if (s != NULL)
2069     bname = s + 1;
2070   n->file = bname;
2071   n->member = mname;
2072
2073   /* We start c at 1 because the first import file number is reserved
2074      for LIBPATH.  */
2075   for (pp = &xcoff_hash_table (info)->imports, c = 1;
2076        *pp != NULL;
2077        pp = &(*pp)->next, ++c)
2078     ;
2079   *pp = n;
2080
2081   xcoff_data (abfd)->import_file_id = c;
2082
2083   return true;
2084
2085  error_return:
2086   if (buf != NULL)
2087     free (buf);
2088   return false;
2089 }
2090 \f
2091 /* Routines that are called after all the input files have been
2092    handled, but before the sections are laid out in memory.  */
2093
2094 /* Mark a symbol as not being garbage, including the section in which
2095    it is defined.  */
2096
2097 static INLINE boolean
2098 xcoff_mark_symbol (info, h)
2099      struct bfd_link_info *info;
2100      struct xcoff_link_hash_entry *h;
2101 {
2102   if ((h->flags & XCOFF_MARK) != 0)
2103     return true;
2104
2105   h->flags |= XCOFF_MARK;
2106   if (h->root.type == bfd_link_hash_defined
2107       || h->root.type == bfd_link_hash_defweak)
2108     {
2109       asection *hsec;
2110
2111       hsec = h->root.u.def.section;
2112       if ((hsec->flags & SEC_MARK) == 0)
2113         {
2114           if (! xcoff_mark (info, hsec))
2115             return false;
2116         }
2117     }
2118
2119   if (h->toc_section != NULL
2120       && (h->toc_section->flags & SEC_MARK) == 0)
2121     {
2122       if (! xcoff_mark (info, h->toc_section))
2123         return false;
2124     }
2125
2126   return true;
2127 }
2128
2129 /* The mark phase of garbage collection.  For a given section, mark
2130    it, and all the sections which define symbols to which it refers.
2131    Because this function needs to look at the relocs, we also count
2132    the number of relocs which need to be copied into the .loader
2133    section.  */
2134
2135 static boolean
2136 xcoff_mark (info, sec)
2137      struct bfd_link_info *info;
2138      asection *sec;
2139 {
2140   if ((sec->flags & SEC_MARK) != 0)
2141     return true;
2142
2143   sec->flags |= SEC_MARK;
2144
2145   if (sec->owner->xvec == info->hash->creator
2146       && coff_section_data (sec->owner, sec) != NULL
2147       && xcoff_section_data (sec->owner, sec) != NULL)
2148     {
2149       register struct xcoff_link_hash_entry **hp, **hpend;
2150       struct internal_reloc *rel, *relend;
2151
2152       /* Mark all the symbols in this section.  */
2153
2154       hp = (obj_xcoff_sym_hashes (sec->owner)
2155             + xcoff_section_data (sec->owner, sec)->first_symndx);
2156       hpend = (obj_xcoff_sym_hashes (sec->owner)
2157                + xcoff_section_data (sec->owner, sec)->last_symndx);
2158       for (; hp < hpend; hp++)
2159         {
2160           register struct xcoff_link_hash_entry *h;
2161
2162           h = *hp;
2163           if (h != NULL
2164               && (h->flags & XCOFF_MARK) == 0)
2165             {
2166               if (! xcoff_mark_symbol (info, h))
2167                 return false;
2168             }
2169         }
2170
2171       /* Look through the section relocs.  */
2172
2173       if ((sec->flags & SEC_RELOC) != 0
2174           && sec->reloc_count > 0)
2175         {
2176           rel = xcoff_read_internal_relocs (sec->owner, sec, true,
2177                                             (bfd_byte *) NULL, false,
2178                                             (struct internal_reloc *) NULL);
2179           if (rel == NULL)
2180             return false;
2181           relend = rel + sec->reloc_count;
2182           for (; rel < relend; rel++)
2183             {
2184               asection *rsec;
2185               struct xcoff_link_hash_entry *h;
2186
2187               if ((unsigned int) rel->r_symndx
2188                   > obj_raw_syment_count (sec->owner))
2189                 continue;
2190
2191               h = obj_xcoff_sym_hashes (sec->owner)[rel->r_symndx];
2192               if (h != NULL
2193                   && (h->flags & XCOFF_MARK) == 0)
2194                 {
2195                   if (! xcoff_mark_symbol (info, h))
2196                     return false;
2197                 }
2198
2199               rsec = xcoff_data (sec->owner)->csects[rel->r_symndx];
2200               if (rsec != NULL
2201                   && (rsec->flags & SEC_MARK) == 0)
2202                 {
2203                   if (! xcoff_mark (info, rsec))
2204                     return false;
2205                 }
2206
2207               /* See if this reloc needs to be copied into the .loader
2208                  section.  */
2209               switch (rel->r_type)
2210                 {
2211                 default:
2212                   if (h == NULL
2213                       || h->root.type == bfd_link_hash_defined
2214                       || h->root.type == bfd_link_hash_defweak
2215                       || h->root.type == bfd_link_hash_common
2216                       || ((h->flags & XCOFF_CALLED) != 0
2217                           && (h->root.type == bfd_link_hash_undefined
2218                               || h->root.type == bfd_link_hash_undefweak)
2219                           && h->root.root.string[0] == '.'
2220                           && h->descriptor != NULL
2221                           && ((h->descriptor->flags & XCOFF_DEF_DYNAMIC) != 0
2222                               || info->shared
2223                               || ((h->descriptor->flags & XCOFF_IMPORT) != 0
2224                                   && (h->descriptor->flags
2225                                       & XCOFF_DEF_REGULAR) == 0))))
2226                     break;
2227                   /* Fall through.  */
2228                 case R_POS:
2229                 case R_NEG:
2230                 case R_RL:
2231                 case R_RLA:
2232                   ++xcoff_hash_table (info)->ldrel_count;
2233                   if (h != NULL)
2234                     h->flags |= XCOFF_LDREL;
2235                   break;
2236                 case R_TOC:
2237                 case R_GL:
2238                 case R_TCL:
2239                 case R_TRL:
2240                 case R_TRLA:
2241                   /* We should never need a .loader reloc for a TOC
2242                      relative reloc.  */
2243                   break;
2244                 }
2245             }
2246
2247           if (! info->keep_memory
2248               && coff_section_data (sec->owner, sec) != NULL
2249               && coff_section_data (sec->owner, sec)->relocs != NULL
2250               && ! coff_section_data (sec->owner, sec)->keep_relocs)
2251             {
2252               free (coff_section_data (sec->owner, sec)->relocs);
2253               coff_section_data (sec->owner, sec)->relocs = NULL;
2254             }
2255         }
2256     }
2257
2258   return true;
2259 }
2260
2261 /* The sweep phase of garbage collection.  Remove all garbage
2262    sections.  */
2263
2264 static void
2265 xcoff_sweep (info)
2266      struct bfd_link_info *info;
2267 {
2268   bfd *sub;
2269
2270   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2271     {
2272       asection *o;
2273
2274       for (o = sub->sections; o != NULL; o = o->next)
2275         {
2276           if ((o->flags & SEC_MARK) == 0)
2277             {
2278               /* Keep all sections from non-XCOFF input files.  Keep
2279                  special sections.  Keep .debug sections for the
2280                  moment.  */
2281               if (sub->xvec != info->hash->creator
2282                   || o == xcoff_hash_table (info)->debug_section
2283                   || o == xcoff_hash_table (info)->loader_section
2284                   || o == xcoff_hash_table (info)->linkage_section
2285                   || o == xcoff_hash_table (info)->toc_section
2286                   || o == xcoff_hash_table (info)->descriptor_section
2287                   || strcmp (o->name, ".debug") == 0)
2288                 o->flags |= SEC_MARK;
2289               else
2290                 {
2291                   o->_raw_size = 0;
2292                   o->reloc_count = 0;
2293                   o->lineno_count = 0;
2294                 }
2295             }
2296         }
2297     }
2298 }
2299
2300 /* Record the number of elements in a set.  This is used to output the
2301    correct csect length.  */
2302
2303 boolean
2304 bfd_xcoff_link_record_set (output_bfd, info, harg, size)
2305      bfd *output_bfd;
2306      struct bfd_link_info *info;
2307      struct bfd_link_hash_entry *harg;
2308      bfd_size_type size;
2309 {
2310   struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
2311   struct xcoff_link_size_list *n;
2312
2313   if (! XCOFF_XVECP (output_bfd->xvec))
2314     return true;
2315
2316   /* This will hardly ever be called.  I don't want to burn four bytes
2317      per global symbol, so instead the size is kept on a linked list
2318      attached to the hash table.  */
2319
2320   n = ((struct xcoff_link_size_list *)
2321        bfd_alloc (output_bfd, sizeof (struct xcoff_link_size_list)));
2322   if (n == NULL)
2323     return false;
2324   n->next = xcoff_hash_table (info)->size_list;
2325   n->h = h;
2326   n->size = size;
2327   xcoff_hash_table (info)->size_list = n;
2328
2329   h->flags |= XCOFF_HAS_SIZE;
2330
2331   return true;
2332 }
2333
2334 /* Import a symbol.  */
2335
2336 boolean
2337 bfd_xcoff_import_symbol (output_bfd, info, harg, val, imppath, impfile,
2338                          impmember)
2339      bfd *output_bfd;
2340      struct bfd_link_info *info;
2341      struct bfd_link_hash_entry *harg;
2342      bfd_vma val;
2343      const char *imppath;
2344      const char *impfile;
2345      const char *impmember;
2346 {
2347   struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
2348
2349   if (! XCOFF_XVECP (output_bfd->xvec))
2350     return true;
2351
2352   h->flags |= XCOFF_IMPORT;
2353
2354   if (val != (bfd_vma) -1)
2355     {
2356       if (h->root.type == bfd_link_hash_defined
2357           && (! bfd_is_abs_section (h->root.u.def.section)
2358               || h->root.u.def.value != val))
2359         {
2360           if (! ((*info->callbacks->multiple_definition)
2361                  (info, h->root.root.string, h->root.u.def.section->owner,
2362                   h->root.u.def.section, h->root.u.def.value,
2363                   output_bfd, bfd_abs_section_ptr, val)))
2364             return false;
2365         }
2366
2367       h->root.type = bfd_link_hash_defined;
2368       h->root.u.def.section = bfd_abs_section_ptr;
2369       h->root.u.def.value = val;
2370     }
2371
2372   if (h->ldsym == NULL)
2373     {
2374       h->ldsym = ((struct internal_ldsym *)
2375                   bfd_zalloc (output_bfd, sizeof (struct internal_ldsym)));
2376       if (h->ldsym == NULL)
2377         return false;
2378     }
2379
2380   if (imppath == NULL)
2381     h->ldsym->l_ifile = (bfd_size_type) -1;
2382   else
2383     {
2384       unsigned int c;
2385       struct xcoff_import_file **pp;
2386
2387       /* We start c at 1 because the first entry in the import list is
2388          reserved for the library search path.  */
2389       for (pp = &xcoff_hash_table (info)->imports, c = 1;
2390            *pp != NULL;
2391            pp = &(*pp)->next, ++c)
2392         {
2393           if (strcmp ((*pp)->path, imppath) == 0
2394               && strcmp ((*pp)->file, impfile) == 0
2395               && strcmp ((*pp)->member, impmember) == 0)
2396             break;
2397         }
2398
2399       if (*pp == NULL)
2400         {
2401           struct xcoff_import_file *n;
2402
2403           n = ((struct xcoff_import_file *)
2404                bfd_alloc (output_bfd, sizeof (struct xcoff_import_file)));
2405           if (n == NULL)
2406             return false;
2407           n->next = NULL;
2408           n->path = imppath;
2409           n->file = impfile;
2410           n->member = impmember;
2411           *pp = n;
2412         }
2413
2414       h->ldsym->l_ifile = c;
2415     }
2416
2417   return true;
2418 }
2419
2420 /* Export a symbol.  */
2421
2422 boolean
2423 bfd_xcoff_export_symbol (output_bfd, info, harg, syscall)
2424      bfd *output_bfd;
2425      struct bfd_link_info *info;
2426      struct bfd_link_hash_entry *harg;
2427      boolean syscall;
2428 {
2429   struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
2430
2431   if (! XCOFF_XVECP (output_bfd->xvec))
2432     return true;
2433
2434   h->flags |= XCOFF_EXPORT;
2435
2436   /* FIXME: I'm not at all sure what syscall is supposed to mean, so
2437      I'm just going to ignore it until somebody explains it.  */
2438
2439   /* See if this is a function descriptor.  It may be one even though
2440      it is not so marked.  */
2441   if ((h->flags & XCOFF_DESCRIPTOR) == 0
2442       && h->root.root.string[0] != '.')
2443     {
2444       char *fnname;
2445       struct xcoff_link_hash_entry *hfn;
2446
2447       fnname = (char *) bfd_malloc (strlen (h->root.root.string) + 2);
2448       if (fnname == NULL)
2449         return false;
2450       fnname[0] = '.';
2451       strcpy (fnname + 1, h->root.root.string);
2452       hfn = xcoff_link_hash_lookup (xcoff_hash_table (info),
2453                                     fnname, false, false, true);
2454       free (fnname);
2455       if (hfn != NULL
2456           && hfn->smclas == XMC_PR
2457           && (hfn->root.type == bfd_link_hash_defined
2458               || hfn->root.type == bfd_link_hash_defweak))
2459         {
2460           h->flags |= XCOFF_DESCRIPTOR;
2461           h->descriptor = hfn;
2462           hfn->descriptor = h;
2463         }
2464     }
2465
2466   /* Make sure we don't garbage collect this symbol.  */
2467   if (! xcoff_mark_symbol (info, h))
2468     return false;
2469
2470   /* If this is a function descriptor, make sure we don't garbage
2471      collect the associated function code.  We normally don't have to
2472      worry about this, because the descriptor will be attached to a
2473      section with relocs, but if we are creating the descriptor
2474      ourselves those relocs will not be visible to the mark code.  */
2475   if ((h->flags & XCOFF_DESCRIPTOR) != 0)
2476     {
2477       if (! xcoff_mark_symbol (info, h->descriptor))
2478         return false;
2479     }
2480
2481   return true;
2482 }
2483
2484 /* Count a reloc against a symbol.  This is called for relocs
2485    generated by the linker script, typically for global constructors
2486    and destructors.  */
2487
2488 boolean
2489 bfd_xcoff_link_count_reloc (output_bfd, info, name)
2490      bfd *output_bfd;
2491      struct bfd_link_info *info;
2492      const char *name;
2493 {
2494   struct xcoff_link_hash_entry *h;
2495
2496   if (! XCOFF_XVECP (output_bfd->xvec))
2497     return true;
2498
2499   h = ((struct xcoff_link_hash_entry *)
2500        bfd_wrapped_link_hash_lookup (output_bfd, info, name, false, false,
2501                                      false));
2502   if (h == NULL)
2503     {
2504       (*_bfd_error_handler) ("%s: no such symbol", name);
2505       bfd_set_error (bfd_error_no_symbols);
2506       return false;
2507     }
2508
2509   h->flags |= XCOFF_REF_REGULAR | XCOFF_LDREL;
2510   ++xcoff_hash_table (info)->ldrel_count;
2511   
2512   /* Mark the symbol to avoid garbage collection.  */
2513   if (! xcoff_mark_symbol (info, h))
2514     return false;
2515
2516   return true;
2517 }
2518
2519 /* This function is called for each symbol to which the linker script
2520    assigns a value.  */
2521
2522 boolean
2523 bfd_xcoff_record_link_assignment (output_bfd, info, name)
2524      bfd *output_bfd;
2525      struct bfd_link_info *info;
2526      const char *name;
2527 {
2528   struct xcoff_link_hash_entry *h;
2529
2530   if (! XCOFF_XVECP (output_bfd->xvec))
2531     return true;
2532
2533   h = xcoff_link_hash_lookup (xcoff_hash_table (info), name, true, true,
2534                               false);
2535   if (h == NULL)
2536     return false;
2537
2538   h->flags |= XCOFF_DEF_REGULAR;
2539
2540   return true;
2541 }
2542
2543 /* This structure is used to pass information through
2544    xcoff_link_hash_traverse.  */
2545
2546 struct xcoff_loader_info
2547 {
2548   /* Set if a problem occurred.  */
2549   boolean failed;
2550   /* Output BFD.  */
2551   bfd *output_bfd;
2552   /* Link information structure.  */
2553   struct bfd_link_info *info;
2554   /* Whether all defined symbols should be exported.  */
2555   boolean export_defineds;
2556   /* Number of ldsym structures.  */
2557   size_t ldsym_count;
2558   /* Size of string table.  */
2559   size_t string_size;
2560   /* String table.  */
2561   bfd_byte *strings;
2562   /* Allocated size of string table.  */
2563   size_t string_alc;
2564 };
2565
2566 /* Build the .loader section.  This is called by the XCOFF linker
2567    emulation before_allocation routine.  We must set the size of the
2568    .loader section before the linker lays out the output file.
2569    LIBPATH is the library path to search for shared objects; this is
2570    normally built from the -L arguments passed to the linker.  ENTRY
2571    is the name of the entry point symbol (the -e linker option).
2572    FILE_ALIGN is the alignment to use for sections within the file
2573    (the -H linker option).  MAXSTACK is the maximum stack size (the
2574    -bmaxstack linker option).  MAXDATA is the maximum data size (the
2575    -bmaxdata linker option).  GC is whether to do garbage collection
2576    (the -bgc linker option).  MODTYPE is the module type (the
2577    -bmodtype linker option).  TEXTRO is whether the text section must
2578    be read only (the -btextro linker option).  EXPORT_DEFINEDS is
2579    whether all defined symbols should be exported (the -unix linker
2580    option).  SPECIAL_SECTIONS is set by this routine to csects with
2581    magic names like _end.  */
2582
2583 boolean
2584 bfd_xcoff_size_dynamic_sections (output_bfd, info, libpath, entry,
2585                                  file_align, maxstack, maxdata, gc,
2586                                  modtype, textro, export_defineds,
2587                                  special_sections)
2588      bfd *output_bfd;
2589      struct bfd_link_info *info;
2590      const char *libpath;
2591      const char *entry;
2592      unsigned long file_align;
2593      unsigned long maxstack;
2594      unsigned long maxdata;
2595      boolean gc;
2596      int modtype;
2597      boolean textro;
2598      boolean export_defineds;
2599      asection **special_sections;
2600 {
2601   struct xcoff_link_hash_entry *hentry;
2602   asection *lsec;
2603   struct xcoff_loader_info ldinfo;
2604   int i;
2605   size_t impsize, impcount;
2606   struct xcoff_import_file *fl;
2607   struct internal_ldhdr *ldhdr;
2608   bfd_size_type stoff;
2609   register char *out;
2610   asection *sec;
2611   bfd *sub;
2612   struct bfd_strtab_hash *debug_strtab;
2613   bfd_byte *debug_contents = NULL;
2614
2615   if (! XCOFF_XVECP (output_bfd->xvec))
2616     {
2617       for (i = 0; i < 6; i++)
2618         special_sections[i] = NULL;
2619       return true;
2620     }
2621
2622   ldinfo.failed = false;
2623   ldinfo.output_bfd = output_bfd;
2624   ldinfo.info = info;
2625   ldinfo.export_defineds = export_defineds;
2626   ldinfo.ldsym_count = 0;
2627   ldinfo.string_size = 0;
2628   ldinfo.strings = NULL;
2629   ldinfo.string_alc = 0;
2630
2631   xcoff_data (output_bfd)->maxstack = maxstack;
2632   xcoff_data (output_bfd)->maxdata = maxdata;
2633   xcoff_data (output_bfd)->modtype = modtype;
2634
2635   xcoff_hash_table (info)->file_align = file_align;
2636   xcoff_hash_table (info)->textro = textro;
2637
2638   hentry = xcoff_link_hash_lookup (xcoff_hash_table (info), entry,
2639                                    false, false, true);
2640   if (hentry != NULL)
2641     hentry->flags |= XCOFF_ENTRY;
2642
2643   /* Garbage collect unused sections.  */
2644   if (info->relocateable
2645       || ! gc
2646       || hentry == NULL
2647       || (hentry->root.type != bfd_link_hash_defined
2648           && hentry->root.type != bfd_link_hash_defweak))
2649     {
2650       gc = false;
2651       xcoff_hash_table (info)->gc = false;
2652
2653       /* We still need to call xcoff_mark, in order to set ldrel_count
2654          correctly.  */
2655       for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2656         {
2657           asection *o;
2658
2659           for (o = sub->sections; o != NULL; o = o->next)
2660             {
2661               if ((o->flags & SEC_MARK) == 0)
2662                 {
2663                   if (! xcoff_mark (info, o))
2664                     goto error_return;
2665                 }
2666             }
2667         }
2668     }
2669   else
2670     {
2671       if (! xcoff_mark (info, hentry->root.u.def.section))
2672         goto error_return;
2673       xcoff_sweep (info);
2674       xcoff_hash_table (info)->gc = true;
2675     }
2676
2677   /* Return special sections to the caller.  */
2678   for (i = 0; i < 6; i++)
2679     {
2680       asection *sec;
2681
2682       sec = xcoff_hash_table (info)->special_sections[i];
2683       if (sec != NULL
2684           && gc
2685           && (sec->flags & SEC_MARK) == 0)
2686         sec = NULL;
2687       special_sections[i] = sec;
2688     }
2689
2690   if (info->input_bfds == NULL)
2691     {
2692       /* I'm not sure what to do in this bizarre case.  */
2693       return true;
2694     }
2695
2696   xcoff_link_hash_traverse (xcoff_hash_table (info), xcoff_build_ldsyms,
2697                             (PTR) &ldinfo);
2698   if (ldinfo.failed)
2699     goto error_return;
2700
2701   /* Work out the size of the import file names.  Each import file ID
2702      consists of three null terminated strings: the path, the file
2703      name, and the archive member name.  The first entry in the list
2704      of names is the path to use to find objects, which the linker has
2705      passed in as the libpath argument.  For some reason, the path
2706      entry in the other import file names appears to always be empty.  */
2707   impsize = strlen (libpath) + 3;
2708   impcount = 1;
2709   for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
2710     {
2711       ++impcount;
2712       impsize += (strlen (fl->path)
2713                   + strlen (fl->file)
2714                   + strlen (fl->member)
2715                   + 3);
2716     }
2717
2718   /* Set up the .loader section header.  */
2719   ldhdr = &xcoff_hash_table (info)->ldhdr;
2720   ldhdr->l_version = 1;
2721   ldhdr->l_nsyms = ldinfo.ldsym_count;
2722   ldhdr->l_nreloc = xcoff_hash_table (info)->ldrel_count;
2723   ldhdr->l_istlen = impsize;
2724   ldhdr->l_nimpid = impcount;
2725   ldhdr->l_impoff = (LDHDRSZ
2726                      + ldhdr->l_nsyms * LDSYMSZ
2727                      + ldhdr->l_nreloc * LDRELSZ);
2728   ldhdr->l_stlen = ldinfo.string_size;
2729   stoff = ldhdr->l_impoff + impsize;
2730   if (ldinfo.string_size == 0)
2731     ldhdr->l_stoff = 0;
2732   else
2733     ldhdr->l_stoff = stoff;
2734
2735   /* We now know the final size of the .loader section.  Allocate
2736      space for it.  */
2737   lsec = xcoff_hash_table (info)->loader_section;
2738   lsec->_raw_size = stoff + ldhdr->l_stlen;
2739   lsec->contents = (bfd_byte *) bfd_zalloc (output_bfd, lsec->_raw_size);
2740   if (lsec->contents == NULL)
2741     goto error_return;
2742
2743   /* Set up the header.  */
2744   xcoff_swap_ldhdr_out (output_bfd, ldhdr,
2745                         (struct external_ldhdr *) lsec->contents);
2746
2747   /* Set up the import file names.  */
2748   out = (char *) lsec->contents + ldhdr->l_impoff;
2749   strcpy (out, libpath);
2750   out += strlen (libpath) + 1;
2751   *out++ = '\0';
2752   *out++ = '\0';
2753   for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
2754     {
2755       register const char *s;
2756
2757       s = fl->path;
2758       while ((*out++ = *s++) != '\0')
2759         ;
2760       s = fl->file;
2761       while ((*out++ = *s++) != '\0')
2762         ;
2763       s = fl->member;
2764       while ((*out++ = *s++) != '\0')
2765         ;
2766     }
2767
2768   BFD_ASSERT ((bfd_size_type) ((bfd_byte *) out - lsec->contents) == stoff);
2769
2770   /* Set up the symbol string table.  */
2771   if (ldinfo.string_size > 0)
2772     {
2773       memcpy (out, ldinfo.strings, ldinfo.string_size);
2774       free (ldinfo.strings);
2775       ldinfo.strings = NULL;
2776     }
2777
2778   /* We can't set up the symbol table or the relocs yet, because we
2779      don't yet know the final position of the various sections.  The
2780      .loader symbols are written out when the corresponding normal
2781      symbols are written out in xcoff_link_input_bfd or
2782      xcoff_write_global_symbol.  The .loader relocs are written out
2783      when the corresponding normal relocs are handled in
2784      xcoff_link_input_bfd.  */
2785
2786   /* Allocate space for the magic sections.  */
2787   sec = xcoff_hash_table (info)->linkage_section;
2788   if (sec->_raw_size > 0)
2789     {
2790       sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
2791       if (sec->contents == NULL)
2792         goto error_return;
2793     }
2794   sec = xcoff_hash_table (info)->toc_section;
2795   if (sec->_raw_size > 0)
2796     {
2797       sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
2798       if (sec->contents == NULL)
2799         goto error_return;
2800     }
2801   sec = xcoff_hash_table (info)->descriptor_section;
2802   if (sec->_raw_size > 0)
2803     {
2804       sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
2805       if (sec->contents == NULL)
2806         goto error_return;
2807     }
2808
2809   /* Now that we've done garbage collection, figure out the contents
2810      of the .debug section.  */
2811   debug_strtab = xcoff_hash_table (info)->debug_strtab;
2812
2813   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2814     {
2815       asection *subdeb;
2816       bfd_size_type symcount;
2817       unsigned long *debug_index;
2818       asection **csectpp;
2819       bfd_byte *esym, *esymend;
2820       bfd_size_type symesz;
2821
2822       if (sub->xvec != info->hash->creator)
2823         continue;
2824       subdeb = bfd_get_section_by_name (sub, ".debug");
2825       if (subdeb == NULL || subdeb->_raw_size == 0)
2826         continue;
2827
2828       if (info->strip == strip_all
2829           || info->strip == strip_debugger
2830           || info->discard == discard_all)
2831         {
2832           subdeb->_raw_size = 0;
2833           continue;
2834         }
2835
2836       if (! _bfd_coff_get_external_symbols (sub))
2837         goto error_return;
2838
2839       symcount = obj_raw_syment_count (sub);
2840       debug_index = ((unsigned long *)
2841                      bfd_zalloc (sub, symcount * sizeof (unsigned long)));
2842       if (debug_index == NULL)
2843         goto error_return;
2844       xcoff_data (sub)->debug_indices = debug_index;
2845
2846       /* Grab the contents of the .debug section.  We use malloc and
2847          copy the neams into the debug stringtab, rather than
2848          bfd_alloc, because I expect that, when linking many files
2849          together, many of the strings will be the same.  Storing the
2850          strings in the hash table should save space in this case.  */
2851       debug_contents = (bfd_byte *) bfd_malloc (subdeb->_raw_size);
2852       if (debug_contents == NULL)
2853         goto error_return;
2854       if (! bfd_get_section_contents (sub, subdeb, (PTR) debug_contents,
2855                                       (file_ptr) 0, subdeb->_raw_size))
2856         goto error_return;
2857
2858       csectpp = xcoff_data (sub)->csects;
2859
2860       symesz = bfd_coff_symesz (sub);
2861       esym = (bfd_byte *) obj_coff_external_syms (sub);
2862       esymend = esym + symcount * symesz;
2863       while (esym < esymend)
2864         {
2865           struct internal_syment sym;
2866
2867           bfd_coff_swap_sym_in (sub, (PTR) esym, (PTR) &sym);
2868
2869           *debug_index = (unsigned long) -1;
2870
2871           if (sym._n._n_n._n_zeroes == 0
2872               && *csectpp != NULL
2873               && (! gc
2874                   || ((*csectpp)->flags & SEC_MARK) != 0
2875                   || *csectpp == bfd_abs_section_ptr)
2876               && bfd_coff_symname_in_debug (sub, &sym))
2877             {
2878               char *name;
2879               bfd_size_type indx;
2880
2881               name = (char *) debug_contents + sym._n._n_n._n_offset;
2882               indx = _bfd_stringtab_add (debug_strtab, name, true, true);
2883               if (indx == (bfd_size_type) -1)
2884                 goto error_return;
2885               *debug_index = indx;
2886             }
2887
2888           esym += (sym.n_numaux + 1) * symesz;
2889           csectpp += sym.n_numaux + 1;
2890           debug_index += sym.n_numaux + 1;
2891         }
2892
2893       free (debug_contents);
2894       debug_contents = NULL;
2895
2896       /* Clear the size of subdeb, so that it is not included directly
2897          in the output file.  */
2898       subdeb->_raw_size = 0;
2899
2900       if (! info->keep_memory)
2901         {
2902           if (! _bfd_coff_free_symbols (sub))
2903             goto error_return;
2904         }
2905     }
2906
2907   xcoff_hash_table (info)->debug_section->_raw_size =
2908     _bfd_stringtab_size (debug_strtab);
2909
2910   return true;
2911
2912  error_return:
2913   if (ldinfo.strings != NULL)
2914     free (ldinfo.strings);
2915   if (debug_contents != NULL)
2916     free (debug_contents);
2917   return false;
2918 }
2919
2920 /* Add a symbol to the .loader symbols, if necessary.  */
2921
2922 static boolean
2923 xcoff_build_ldsyms (h, p)
2924      struct xcoff_link_hash_entry *h;
2925      PTR p;
2926 {
2927   struct xcoff_loader_info *ldinfo = (struct xcoff_loader_info *) p;
2928   size_t len;
2929
2930   /* If all defined symbols should be exported, mark them now.  */
2931   if (ldinfo->export_defineds
2932       && (h->flags & XCOFF_DEF_REGULAR) != 0)
2933     h->flags |= XCOFF_EXPORT;
2934
2935   /* We don't want to garbage collect symbols which are not defined in
2936      XCOFF files.  This is a convenient place to mark them.  */
2937   if (xcoff_hash_table (ldinfo->info)->gc
2938       && (h->flags & XCOFF_MARK) == 0
2939       && (h->root.type == bfd_link_hash_defined
2940           || h->root.type == bfd_link_hash_defweak)
2941       && (h->root.u.def.section->owner == NULL
2942           || (h->root.u.def.section->owner->xvec
2943               != ldinfo->info->hash->creator)))
2944     h->flags |= XCOFF_MARK;
2945
2946   /* If this symbol is called and defined in a dynamic object, or not
2947      defined at all when building a shared object, or imported, then
2948      we need to set up global linkage code for it.  (Unless we did
2949      garbage collection and we didn't need this symbol.)  */
2950   if ((h->flags & XCOFF_CALLED) != 0
2951       && (h->root.type == bfd_link_hash_undefined
2952           || h->root.type == bfd_link_hash_undefweak)
2953       && h->root.root.string[0] == '.'
2954       && h->descriptor != NULL
2955       && ((h->descriptor->flags & XCOFF_DEF_DYNAMIC) != 0
2956           || ldinfo->info->shared
2957           || ((h->descriptor->flags & XCOFF_IMPORT) != 0
2958               && (h->descriptor->flags & XCOFF_DEF_REGULAR) == 0))
2959       && (! xcoff_hash_table (ldinfo->info)->gc
2960           || (h->flags & XCOFF_MARK) != 0))
2961     {
2962       asection *sec;
2963       struct xcoff_link_hash_entry *hds;
2964
2965       sec = xcoff_hash_table (ldinfo->info)->linkage_section;
2966       h->root.type = bfd_link_hash_defined;
2967       h->root.u.def.section = sec;
2968       h->root.u.def.value = sec->_raw_size;
2969       h->smclas = XMC_GL;
2970       h->flags |= XCOFF_DEF_REGULAR;
2971       sec->_raw_size += XCOFF_GLINK_SIZE;
2972
2973       /* The global linkage code requires a TOC entry for the
2974          descriptor.  */
2975       hds = h->descriptor;
2976       BFD_ASSERT ((hds->root.type == bfd_link_hash_undefined
2977                    || hds->root.type == bfd_link_hash_undefweak)
2978                   && (hds->flags & XCOFF_DEF_REGULAR) == 0);
2979       hds->flags |= XCOFF_MARK;
2980       if (hds->toc_section == NULL)
2981         {
2982           hds->toc_section = xcoff_hash_table (ldinfo->info)->toc_section;
2983           hds->u.toc_offset = hds->toc_section->_raw_size;
2984           hds->toc_section->_raw_size += 4;
2985           ++xcoff_hash_table (ldinfo->info)->ldrel_count;
2986           ++hds->toc_section->reloc_count;
2987           hds->indx = -2;
2988           hds->flags |= XCOFF_SET_TOC | XCOFF_LDREL;
2989
2990           /* We need to call xcoff_build_ldsyms recursively here,
2991              because we may already have passed hds on the traversal.  */
2992           xcoff_build_ldsyms (hds, p);
2993         }
2994     }
2995
2996   /* If this symbol is exported, but not defined, we need to try to
2997      define it.  */
2998   if ((h->flags & XCOFF_EXPORT) != 0
2999       && (h->flags & XCOFF_IMPORT) == 0
3000       && (h->flags & XCOFF_DEF_REGULAR) == 0
3001       && (h->flags & XCOFF_DEF_DYNAMIC) == 0
3002       && (h->root.type == bfd_link_hash_undefined
3003           || h->root.type == bfd_link_hash_undefweak))
3004     {
3005       if ((h->flags & XCOFF_DESCRIPTOR) != 0
3006           && (h->descriptor->root.type == bfd_link_hash_defined
3007               || h->descriptor->root.type == bfd_link_hash_defweak))
3008         {
3009           asection *sec;
3010
3011           /* This is an undefined function descriptor associated with
3012              a defined entry point.  We can build up a function
3013              descriptor ourselves.  Believe it or not, the AIX linker
3014              actually does this, and there are cases where we need to
3015              do it as well.  */
3016           sec = xcoff_hash_table (ldinfo->info)->descriptor_section;
3017           h->root.type = bfd_link_hash_defined;
3018           h->root.u.def.section = sec;
3019           h->root.u.def.value = sec->_raw_size;
3020           h->smclas = XMC_DS;
3021           h->flags |= XCOFF_DEF_REGULAR;
3022           sec->_raw_size += 12;
3023
3024           /* A function descriptor uses two relocs: one for the
3025              associated code, and one for the TOC address.  */
3026           xcoff_hash_table (ldinfo->info)->ldrel_count += 2;
3027           sec->reloc_count += 2;
3028
3029           /* We handle writing out the contents of the descriptor in
3030              xcoff_write_global_symbol.  */
3031         }
3032       else
3033         {
3034           (*_bfd_error_handler)
3035             ("attempt to export undefined symbol `%s'",
3036              h->root.root.string);
3037           ldinfo->failed = true;
3038           bfd_set_error (bfd_error_invalid_operation);
3039           return false;
3040         }
3041     }
3042
3043   /* If this is still a common symbol, and it wasn't garbage
3044      collected, we need to actually allocate space for it in the .bss
3045      section.  */
3046   if (h->root.type == bfd_link_hash_common
3047       && (! xcoff_hash_table (ldinfo->info)->gc
3048           || (h->flags & XCOFF_MARK) != 0)
3049       && h->root.u.c.p->section->_raw_size == 0)
3050     {
3051       BFD_ASSERT (bfd_is_com_section (h->root.u.c.p->section));
3052       h->root.u.c.p->section->_raw_size = h->root.u.c.size;
3053     }
3054
3055   /* We need to add a symbol to the .loader section if it is mentioned
3056      in a reloc which we are copying to the .loader section and it was
3057      not defined or common, or if it is the entry point, or if it is
3058      being exported.  */
3059
3060   if (((h->flags & XCOFF_LDREL) == 0
3061        || h->root.type == bfd_link_hash_defined
3062        || h->root.type == bfd_link_hash_defweak
3063        || h->root.type == bfd_link_hash_common)
3064       && (h->flags & XCOFF_ENTRY) == 0
3065       && (h->flags & XCOFF_EXPORT) == 0)
3066     {
3067       h->ldsym = NULL;
3068       return true;
3069     }
3070
3071   /* We don't need to add this symbol if we did garbage collection and
3072      we did not mark this symbol.  */
3073   if (xcoff_hash_table (ldinfo->info)->gc
3074       && (h->flags & XCOFF_MARK) == 0)
3075     {
3076       h->ldsym = NULL;
3077       return true;
3078     }
3079
3080   /* We may have already processed this symbol due to the recursive
3081      call above.  */
3082   if ((h->flags & XCOFF_BUILT_LDSYM) != 0)
3083     return true;
3084
3085   /* We need to add this symbol to the .loader symbols.  */
3086
3087   /* h->ldsym will already have been allocated for an explicitly
3088      imported symbol.  */
3089   if (h->ldsym == NULL)
3090     {
3091       h->ldsym = ((struct internal_ldsym *)
3092                   bfd_zalloc (ldinfo->output_bfd,
3093                               sizeof (struct internal_ldsym)));
3094       if (h->ldsym == NULL)
3095         {
3096           ldinfo->failed = true;
3097           return false;
3098         }
3099     }
3100
3101   /* The first 3 symbol table indices are reserved to indicate the
3102      sections.  */
3103   h->ldindx = ldinfo->ldsym_count + 3;
3104
3105   ++ldinfo->ldsym_count;
3106
3107   len = strlen (h->root.root.string);
3108   if (len <= SYMNMLEN)
3109     strncpy (h->ldsym->_l._l_name, h->root.root.string, SYMNMLEN);
3110   else
3111     {
3112       if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
3113         {
3114           size_t newalc;
3115           bfd_byte *newstrings;
3116
3117           newalc = ldinfo->string_alc * 2;
3118           if (newalc == 0)
3119             newalc = 32;
3120           while (ldinfo->string_size + len + 3 > newalc)
3121             newalc *= 2;
3122
3123           newstrings = ((bfd_byte *)
3124                         bfd_realloc ((PTR) ldinfo->strings, newalc));
3125           if (newstrings == NULL)
3126             {
3127               ldinfo->failed = true;
3128               return false;
3129             }
3130           ldinfo->string_alc = newalc;
3131           ldinfo->strings = newstrings;
3132         }
3133
3134       bfd_put_16 (ldinfo->output_bfd, len + 1,
3135                   ldinfo->strings + ldinfo->string_size);
3136       strcpy (ldinfo->strings + ldinfo->string_size + 2, h->root.root.string);
3137       h->ldsym->_l._l_l._l_zeroes = 0;
3138       h->ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
3139       ldinfo->string_size += len + 3;
3140     }
3141
3142   h->flags |= XCOFF_BUILT_LDSYM;
3143
3144   return true;
3145 }
3146 \f
3147 /* Do the final link step.  */
3148
3149 boolean
3150 _bfd_xcoff_bfd_final_link (abfd, info)
3151      bfd *abfd;
3152      struct bfd_link_info *info;
3153 {
3154   bfd_size_type symesz;
3155   struct xcoff_final_link_info finfo;
3156   asection *o;
3157   struct bfd_link_order *p;
3158   size_t max_contents_size;
3159   size_t max_sym_count;
3160   size_t max_lineno_count;
3161   size_t max_reloc_count;
3162   size_t max_output_reloc_count;
3163   file_ptr rel_filepos;
3164   unsigned int relsz;
3165   file_ptr line_filepos;
3166   unsigned int linesz;
3167   bfd *sub;
3168   bfd_byte *external_relocs = NULL;
3169   char strbuf[STRING_SIZE_SIZE];
3170
3171   if (info->shared)
3172     abfd->flags |= DYNAMIC;
3173
3174   symesz = bfd_coff_symesz (abfd);
3175
3176   finfo.info = info;
3177   finfo.output_bfd = abfd;
3178   finfo.strtab = NULL;
3179   finfo.section_info = NULL;
3180   finfo.last_file_index = -1;
3181   finfo.toc_symindx = -1;
3182   finfo.internal_syms = NULL;
3183   finfo.sym_indices = NULL;
3184   finfo.outsyms = NULL;
3185   finfo.linenos = NULL;
3186   finfo.contents = NULL;
3187   finfo.external_relocs = NULL;
3188
3189   finfo.ldsym = ((struct external_ldsym *)
3190                  (xcoff_hash_table (info)->loader_section->contents
3191                   + LDHDRSZ));
3192   finfo.ldrel = ((struct external_ldrel *)
3193                  (xcoff_hash_table (info)->loader_section->contents
3194                   + LDHDRSZ
3195                   + xcoff_hash_table (info)->ldhdr.l_nsyms * LDSYMSZ));
3196
3197   xcoff_data (abfd)->coff.link_info = info;
3198
3199   finfo.strtab = _bfd_stringtab_init ();
3200   if (finfo.strtab == NULL)
3201     goto error_return;
3202
3203   /* Count the line number and relocation entries required for the
3204      output file.  Determine a few maximum sizes.  */
3205   max_contents_size = 0;
3206   max_lineno_count = 0;
3207   max_reloc_count = 0;
3208   for (o = abfd->sections; o != NULL; o = o->next)
3209     {
3210       o->reloc_count = 0;
3211       o->lineno_count = 0;
3212       for (p = o->link_order_head; p != NULL; p = p->next)
3213         {
3214           if (p->type == bfd_indirect_link_order)
3215             {
3216               asection *sec;
3217
3218               sec = p->u.indirect.section;
3219
3220               if (info->strip == strip_none
3221                   || info->strip == strip_some)
3222                 o->lineno_count += sec->lineno_count;
3223
3224               o->reloc_count += sec->reloc_count;
3225
3226               if (sec->_raw_size > max_contents_size)
3227                 max_contents_size = sec->_raw_size;
3228               if (sec->lineno_count > max_lineno_count)
3229                 max_lineno_count = sec->lineno_count;
3230               if (coff_section_data (sec->owner, sec) != NULL
3231                   && xcoff_section_data (sec->owner, sec) != NULL
3232                   && (xcoff_section_data (sec->owner, sec)->lineno_count
3233                       > max_lineno_count))
3234                 max_lineno_count =
3235                   xcoff_section_data (sec->owner, sec)->lineno_count;
3236               if (sec->reloc_count > max_reloc_count)
3237                 max_reloc_count = sec->reloc_count;
3238             }
3239           else if (p->type == bfd_section_reloc_link_order
3240                    || p->type == bfd_symbol_reloc_link_order)
3241             ++o->reloc_count;
3242         }
3243     }
3244
3245   /* Compute the file positions for all the sections.  */
3246   if (abfd->output_has_begun)
3247     {
3248       if (xcoff_hash_table (info)->file_align != 0)
3249         abort ();
3250     }
3251   else
3252     {
3253       bfd_vma file_align;
3254
3255       file_align = xcoff_hash_table (info)->file_align;
3256       if (file_align != 0)
3257         {
3258           boolean saw_contents;
3259           int indx;
3260           asection **op;
3261           file_ptr sofar;
3262
3263           /* Insert .pad sections before every section which has
3264              contents and is loaded, if it is preceded by some other
3265              section which has contents and is loaded.  */
3266           saw_contents = true;
3267           for (op = &abfd->sections; *op != NULL; op = &(*op)->next)
3268             {
3269               (*op)->target_index = indx;
3270               if (strcmp ((*op)->name, ".pad") == 0)
3271                 saw_contents = false;
3272               else if (((*op)->flags & SEC_HAS_CONTENTS) != 0
3273                        && ((*op)->flags & SEC_LOAD) != 0)
3274                 {
3275                   if (! saw_contents)
3276                     saw_contents = true;
3277                   else
3278                     {
3279                       asection *n, *hold;
3280
3281                       hold = *op;
3282                       *op = NULL;
3283                       n = bfd_make_section_anyway (abfd, ".pad");
3284                       BFD_ASSERT (*op == n);
3285                       n->next = hold;
3286                       n->flags = SEC_HAS_CONTENTS;
3287                       n->alignment_power = 0;
3288                       saw_contents = false;
3289                     }
3290                 }
3291             }
3292
3293           /* Reset the section indices after inserting the new
3294              sections.  */
3295           indx = 0;
3296           for (o = abfd->sections; o != NULL; o = o->next)
3297             {
3298               ++indx;
3299               o->target_index = indx;
3300             }
3301           BFD_ASSERT ((unsigned int) indx == abfd->section_count);
3302
3303           /* Work out appropriate sizes for the .pad sections to force
3304              each section to land on a page boundary.  This bit of
3305              code knows what compute_section_file_positions is going
3306              to do.  */
3307           sofar = bfd_coff_filhsz (abfd);
3308           sofar += bfd_coff_aoutsz (abfd);
3309           sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
3310           for (o = abfd->sections; o != NULL; o = o->next)
3311             if (o->reloc_count >= 0xffff || o->lineno_count >= 0xffff)
3312               sofar += bfd_coff_scnhsz (abfd);
3313
3314           for (o = abfd->sections; o != NULL; o = o->next)
3315             {
3316               if (strcmp (o->name, ".pad") == 0)
3317                 {
3318                   bfd_vma pageoff;
3319
3320                   BFD_ASSERT (o->_raw_size == 0);
3321                   pageoff = sofar & (file_align - 1);
3322                   if (pageoff != 0)
3323                     {
3324                       o->_raw_size = file_align - pageoff;
3325                       sofar += file_align - pageoff;
3326                       o->flags |= SEC_HAS_CONTENTS;
3327                     }
3328                 }
3329               else
3330                 {
3331                   if ((o->flags & SEC_HAS_CONTENTS) != 0)
3332                     sofar += BFD_ALIGN (o->_raw_size,
3333                                         1 << o->alignment_power);
3334                 }
3335             }
3336         }
3337
3338       bfd_coff_compute_section_file_positions (abfd);
3339     }
3340
3341   /* Allocate space for the pointers we need to keep for the relocs.  */
3342   {
3343     unsigned int i;
3344
3345     /* We use section_count + 1, rather than section_count, because
3346        the target_index fields are 1 based.  */
3347     finfo.section_info =
3348       ((struct xcoff_link_section_info *)
3349        bfd_malloc ((abfd->section_count + 1)
3350                    * sizeof (struct xcoff_link_section_info)));
3351     if (finfo.section_info == NULL)
3352       goto error_return;
3353     for (i = 0; i <= abfd->section_count; i++)
3354       {
3355         finfo.section_info[i].relocs = NULL;
3356         finfo.section_info[i].rel_hashes = NULL;
3357         finfo.section_info[i].toc_rel_hashes = NULL;
3358       }
3359   }
3360
3361   /* Set the file positions for the relocs.  */
3362   rel_filepos = obj_relocbase (abfd);
3363   relsz = bfd_coff_relsz (abfd);
3364   max_output_reloc_count = 0;
3365   for (o = abfd->sections; o != NULL; o = o->next)
3366     {
3367       if (o->reloc_count == 0)
3368         o->rel_filepos = 0;
3369       else
3370         {
3371           o->flags |= SEC_RELOC;
3372           o->rel_filepos = rel_filepos;
3373           rel_filepos += o->reloc_count * relsz;
3374
3375           /* We don't know the indices of global symbols until we have
3376              written out all the local symbols.  For each section in
3377              the output file, we keep an array of pointers to hash
3378              table entries.  Each entry in the array corresponds to a
3379              reloc.  When we find a reloc against a global symbol, we
3380              set the corresponding entry in this array so that we can
3381              fix up the symbol index after we have written out all the
3382              local symbols.
3383
3384              Because of this problem, we also keep the relocs in
3385              memory until the end of the link.  This wastes memory.
3386              We could backpatch the file later, I suppose, although it
3387              would be slow.  */
3388           finfo.section_info[o->target_index].relocs =
3389             ((struct internal_reloc *)
3390              bfd_malloc (o->reloc_count * sizeof (struct internal_reloc)));
3391           finfo.section_info[o->target_index].rel_hashes =
3392             ((struct xcoff_link_hash_entry **)
3393              bfd_malloc (o->reloc_count
3394                      * sizeof (struct xcoff_link_hash_entry *)));
3395           if (finfo.section_info[o->target_index].relocs == NULL
3396               || finfo.section_info[o->target_index].rel_hashes == NULL)
3397             goto error_return;
3398
3399           if (o->reloc_count > max_output_reloc_count)
3400             max_output_reloc_count = o->reloc_count;
3401         }
3402     }
3403
3404   /* We now know the size of the relocs, so we can determine the file
3405      positions of the line numbers.  */
3406   line_filepos = rel_filepos;
3407   finfo.line_filepos = line_filepos;
3408   linesz = bfd_coff_linesz (abfd);
3409   for (o = abfd->sections; o != NULL; o = o->next)
3410     {
3411       if (o->lineno_count == 0)
3412         o->line_filepos = 0;
3413       else
3414         {
3415           o->line_filepos = line_filepos;
3416           line_filepos += o->lineno_count * linesz;
3417         }
3418
3419       /* Reset the reloc and lineno counts, so that we can use them to
3420          count the number of entries we have output so far.  */
3421       o->reloc_count = 0;
3422       o->lineno_count = 0;
3423     }
3424
3425   obj_sym_filepos (abfd) = line_filepos;
3426
3427   /* Figure out the largest number of symbols in an input BFD.  Take
3428      the opportunity to clear the output_has_begun fields of all the
3429      input BFD's.  We want at least 4 symbols, since that is the
3430      number which xcoff_write_global_symbol may need.  */
3431   max_sym_count = 4;
3432   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3433     {
3434       size_t sz;
3435
3436       sub->output_has_begun = false;
3437       sz = obj_raw_syment_count (sub);
3438       if (sz > max_sym_count)
3439         max_sym_count = sz;
3440     }
3441
3442   /* Allocate some buffers used while linking.  */
3443   finfo.internal_syms = ((struct internal_syment *)
3444                          bfd_malloc (max_sym_count
3445                                      * sizeof (struct internal_syment)));
3446   finfo.sym_indices = (long *) bfd_malloc (max_sym_count * sizeof (long));
3447   finfo.outsyms = ((bfd_byte *)
3448                    bfd_malloc ((size_t) ((max_sym_count + 1) * symesz)));
3449   finfo.linenos = (bfd_byte *) bfd_malloc (max_lineno_count
3450                                            * bfd_coff_linesz (abfd));
3451   finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
3452   finfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
3453   if ((finfo.internal_syms == NULL && max_sym_count > 0)
3454       || (finfo.sym_indices == NULL && max_sym_count > 0)
3455       || finfo.outsyms == NULL
3456       || (finfo.linenos == NULL && max_lineno_count > 0)
3457       || (finfo.contents == NULL && max_contents_size > 0)
3458       || (finfo.external_relocs == NULL && max_reloc_count > 0))
3459     goto error_return;
3460
3461   obj_raw_syment_count (abfd) = 0;
3462   xcoff_data (abfd)->toc = (bfd_vma) -1;
3463
3464   /* We now know the position of everything in the file, except that
3465      we don't know the size of the symbol table and therefore we don't
3466      know where the string table starts.  We just build the string
3467      table in memory as we go along.  We process all the relocations
3468      for a single input file at once.  */
3469   for (o = abfd->sections; o != NULL; o = o->next)
3470     {
3471       for (p = o->link_order_head; p != NULL; p = p->next)
3472         {
3473           if (p->type == bfd_indirect_link_order
3474               && p->u.indirect.section->owner->xvec == abfd->xvec)
3475             {
3476               sub = p->u.indirect.section->owner;
3477               if (! sub->output_has_begun)
3478                 {
3479                   if (! xcoff_link_input_bfd (&finfo, sub))
3480                     goto error_return;
3481                   sub->output_has_begun = true;
3482                 }
3483             }
3484           else if (p->type == bfd_section_reloc_link_order
3485                    || p->type == bfd_symbol_reloc_link_order)
3486             {
3487               if (! xcoff_reloc_link_order (abfd, &finfo, o, p))
3488                 goto error_return;
3489             }
3490           else
3491             {
3492               if (! _bfd_default_link_order (abfd, info, o, p))
3493                 goto error_return;
3494             }
3495         }
3496     }
3497
3498   /* Free up the buffers used by xcoff_link_input_bfd.  */
3499
3500   if (finfo.internal_syms != NULL)
3501     {
3502       free (finfo.internal_syms);
3503       finfo.internal_syms = NULL;
3504     }
3505   if (finfo.sym_indices != NULL)
3506     {
3507       free (finfo.sym_indices);
3508       finfo.sym_indices = NULL;
3509     }
3510   if (finfo.linenos != NULL)
3511     {
3512       free (finfo.linenos);
3513       finfo.linenos = NULL;
3514     }
3515   if (finfo.contents != NULL)
3516     {
3517       free (finfo.contents);
3518       finfo.contents = NULL;
3519     }
3520   if (finfo.external_relocs != NULL)
3521     {
3522       free (finfo.external_relocs);
3523       finfo.external_relocs = NULL;
3524     }
3525
3526   /* The value of the last C_FILE symbol is supposed to be -1.  Write
3527      it out again.  */
3528   if (finfo.last_file_index != -1)
3529     {
3530       finfo.last_file.n_value = -1;
3531       bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
3532                              (PTR) finfo.outsyms);
3533       if (bfd_seek (abfd,
3534                     (obj_sym_filepos (abfd)
3535                      + finfo.last_file_index * symesz),
3536                     SEEK_SET) != 0
3537           || bfd_write (finfo.outsyms, symesz, 1, abfd) != symesz)
3538         goto error_return;
3539     }
3540
3541   /* Write out all the global symbols which do not come from XCOFF
3542      input files.  */
3543   xcoff_link_hash_traverse (xcoff_hash_table (info),
3544                             xcoff_write_global_symbol,
3545                             (PTR) &finfo);
3546
3547   if (finfo.outsyms != NULL)
3548     {
3549       free (finfo.outsyms);
3550       finfo.outsyms = NULL;
3551     }
3552
3553   /* Now that we have written out all the global symbols, we know the
3554      symbol indices to use for relocs against them, and we can finally
3555      write out the relocs.  */
3556   external_relocs = (bfd_byte *) malloc (max_output_reloc_count * relsz);
3557   if (external_relocs == NULL && max_output_reloc_count != 0)
3558     {
3559       bfd_set_error (bfd_error_no_memory);
3560       goto error_return;
3561     }
3562
3563   for (o = abfd->sections; o != NULL; o = o->next)
3564     {
3565       struct internal_reloc *irel;
3566       struct internal_reloc *irelend;
3567       struct xcoff_link_hash_entry **rel_hash;
3568       struct xcoff_toc_rel_hash *toc_rel_hash;
3569       bfd_byte *erel;
3570
3571       if (o->reloc_count == 0)
3572         continue;
3573
3574       irel = finfo.section_info[o->target_index].relocs;
3575       irelend = irel + o->reloc_count;
3576       rel_hash = finfo.section_info[o->target_index].rel_hashes;
3577       for (; irel < irelend; irel++, rel_hash++, erel += relsz)
3578         {
3579           if (*rel_hash != NULL)
3580             {
3581               if ((*rel_hash)->indx < 0)
3582                 {
3583                   if (! ((*info->callbacks->unattached_reloc)
3584                          (info, (*rel_hash)->root.root.string,
3585                           (bfd *) NULL, o, irel->r_vaddr)))
3586                     goto error_return;
3587                   (*rel_hash)->indx = 0;
3588                 }
3589               irel->r_symndx = (*rel_hash)->indx;
3590             }
3591         }
3592
3593       for (toc_rel_hash = finfo.section_info[o->target_index].toc_rel_hashes;
3594            toc_rel_hash != NULL;
3595            toc_rel_hash = toc_rel_hash->next)
3596         {
3597           if (toc_rel_hash->h->u.toc_indx < 0)
3598             {
3599               if (! ((*info->callbacks->unattached_reloc)
3600                      (info, toc_rel_hash->h->root.root.string,
3601                       (bfd *) NULL, o, toc_rel_hash->rel->r_vaddr)))
3602                 goto error_return;
3603               toc_rel_hash->h->u.toc_indx = 0;
3604             }
3605           toc_rel_hash->rel->r_symndx = toc_rel_hash->h->u.toc_indx;
3606         }
3607
3608       /* XCOFF requires that the relocs be sorted by address.  We tend
3609          to produce them in the order in which their containing csects
3610          appear in the symbol table, which is not necessarily by
3611          address.  So we sort them here.  There may be a better way to
3612          do this.  */
3613       qsort ((PTR) finfo.section_info[o->target_index].relocs,
3614              o->reloc_count, sizeof (struct internal_reloc),
3615              xcoff_sort_relocs);
3616
3617       irel = finfo.section_info[o->target_index].relocs;
3618       irelend = irel + o->reloc_count;
3619       erel = external_relocs;
3620       for (; irel < irelend; irel++, rel_hash++, erel += relsz)
3621         bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
3622
3623       if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
3624           || bfd_write ((PTR) external_relocs, relsz, o->reloc_count,
3625                         abfd) != relsz * o->reloc_count)
3626         goto error_return;
3627     }
3628
3629   if (external_relocs != NULL)
3630     {
3631       free (external_relocs);
3632       external_relocs = NULL;
3633     }
3634
3635   /* Free up the section information.  */
3636   if (finfo.section_info != NULL)
3637     {
3638       unsigned int i;
3639
3640       for (i = 0; i < abfd->section_count; i++)
3641         {
3642           if (finfo.section_info[i].relocs != NULL)
3643             free (finfo.section_info[i].relocs);
3644           if (finfo.section_info[i].rel_hashes != NULL)
3645             free (finfo.section_info[i].rel_hashes);
3646         }
3647       free (finfo.section_info);
3648       finfo.section_info = NULL;
3649     }
3650
3651   /* Write out the loader section contents.  */
3652   BFD_ASSERT ((bfd_byte *) finfo.ldrel
3653               == (xcoff_hash_table (info)->loader_section->contents
3654                   + xcoff_hash_table (info)->ldhdr.l_impoff));
3655   o = xcoff_hash_table (info)->loader_section;
3656   if (! bfd_set_section_contents (abfd, o->output_section,
3657                                   o->contents, o->output_offset,
3658                                   o->_raw_size))
3659     goto error_return;
3660
3661   /* Write out the magic sections.  */
3662   o = xcoff_hash_table (info)->linkage_section;
3663   if (o->_raw_size > 0
3664       && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
3665                                      o->output_offset, o->_raw_size))
3666     goto error_return;
3667   o = xcoff_hash_table (info)->toc_section;
3668   if (o->_raw_size > 0
3669       && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
3670                                      o->output_offset, o->_raw_size))
3671     goto error_return;
3672   o = xcoff_hash_table (info)->descriptor_section;
3673   if (o->_raw_size > 0
3674       && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
3675                                      o->output_offset, o->_raw_size))
3676     goto error_return;
3677
3678   /* Write out the string table.  */
3679   if (bfd_seek (abfd,
3680                 (obj_sym_filepos (abfd)
3681                  + obj_raw_syment_count (abfd) * symesz),
3682                 SEEK_SET) != 0)
3683     goto error_return;
3684   bfd_h_put_32 (abfd,
3685                 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
3686                 (bfd_byte *) strbuf);
3687   if (bfd_write (strbuf, 1, STRING_SIZE_SIZE, abfd) != STRING_SIZE_SIZE)
3688     goto error_return;
3689   if (! _bfd_stringtab_emit (abfd, finfo.strtab))
3690     goto error_return;
3691
3692   _bfd_stringtab_free (finfo.strtab);
3693
3694   /* Write out the debugging string table.  */
3695   o = xcoff_hash_table (info)->debug_section;
3696   if (o != NULL)
3697     {
3698       struct bfd_strtab_hash *debug_strtab;
3699
3700       debug_strtab = xcoff_hash_table (info)->debug_strtab;
3701       BFD_ASSERT (o->output_section->_raw_size - o->output_offset
3702                   >= _bfd_stringtab_size (debug_strtab));
3703       if (bfd_seek (abfd,
3704                     o->output_section->filepos + o->output_offset,
3705                     SEEK_SET) != 0)
3706         goto error_return;
3707       if (! _bfd_stringtab_emit (abfd, debug_strtab))
3708         goto error_return;
3709     }
3710
3711   /* Setting bfd_get_symcount to 0 will cause write_object_contents to
3712      not try to write out the symbols.  */
3713   bfd_get_symcount (abfd) = 0;
3714
3715   return true;
3716
3717  error_return:
3718   if (finfo.strtab != NULL)
3719     _bfd_stringtab_free (finfo.strtab);
3720   if (finfo.section_info != NULL)
3721     {
3722       unsigned int i;
3723
3724       for (i = 0; i < abfd->section_count; i++)
3725         {
3726           if (finfo.section_info[i].relocs != NULL)
3727             free (finfo.section_info[i].relocs);
3728           if (finfo.section_info[i].rel_hashes != NULL)
3729             free (finfo.section_info[i].rel_hashes);
3730         }
3731       free (finfo.section_info);
3732     }
3733   if (finfo.internal_syms != NULL)
3734     free (finfo.internal_syms);
3735   if (finfo.sym_indices != NULL)
3736     free (finfo.sym_indices);
3737   if (finfo.outsyms != NULL)
3738     free (finfo.outsyms);
3739   if (finfo.linenos != NULL)
3740     free (finfo.linenos);
3741   if (finfo.contents != NULL)
3742     free (finfo.contents);
3743   if (finfo.external_relocs != NULL)
3744     free (finfo.external_relocs);
3745   if (external_relocs != NULL)
3746     free (external_relocs);
3747   return false;
3748 }
3749
3750 /* Link an input file into the linker output file.  This function
3751    handles all the sections and relocations of the input file at once.  */
3752
3753 static boolean
3754 xcoff_link_input_bfd (finfo, input_bfd)
3755      struct xcoff_final_link_info *finfo;
3756      bfd *input_bfd;
3757 {
3758   bfd *output_bfd;
3759   const char *strings;
3760   bfd_size_type syment_base;
3761   unsigned int n_tmask;
3762   unsigned int n_btshft;
3763   boolean copy, hash;
3764   bfd_size_type isymesz;
3765   bfd_size_type osymesz;
3766   bfd_size_type linesz;
3767   bfd_byte *esym;
3768   bfd_byte *esym_end;
3769   struct xcoff_link_hash_entry **sym_hash;
3770   struct internal_syment *isymp;
3771   asection **csectpp;
3772   unsigned long *debug_index;
3773   long *indexp;
3774   unsigned long output_index;
3775   bfd_byte *outsym;
3776   unsigned int incls;
3777   asection *oline;
3778   boolean keep_syms;
3779   asection *o;
3780
3781   /* We can just skip DYNAMIC files, unless this is a static link.  */
3782   if ((input_bfd->flags & DYNAMIC) != 0
3783       && ! finfo->info->static_link)
3784     return true;
3785
3786   /* Move all the symbols to the output file.  */
3787
3788   output_bfd = finfo->output_bfd;
3789   strings = NULL;
3790   syment_base = obj_raw_syment_count (output_bfd);
3791   isymesz = bfd_coff_symesz (input_bfd);
3792   osymesz = bfd_coff_symesz (output_bfd);
3793   linesz = bfd_coff_linesz (input_bfd);
3794   BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
3795
3796   n_tmask = coff_data (input_bfd)->local_n_tmask;
3797   n_btshft = coff_data (input_bfd)->local_n_btshft;
3798
3799   /* Define macros so that ISFCN, et. al., macros work correctly.  */
3800 #define N_TMASK n_tmask
3801 #define N_BTSHFT n_btshft
3802
3803   copy = false;
3804   if (! finfo->info->keep_memory)
3805     copy = true;
3806   hash = true;
3807   if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
3808     hash = false;
3809
3810   if (! _bfd_coff_get_external_symbols (input_bfd))
3811     return false;
3812
3813   esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
3814   esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
3815   sym_hash = obj_xcoff_sym_hashes (input_bfd);
3816   csectpp = xcoff_data (input_bfd)->csects;
3817   debug_index = xcoff_data (input_bfd)->debug_indices;
3818   isymp = finfo->internal_syms;
3819   indexp = finfo->sym_indices;
3820   output_index = syment_base;
3821   outsym = finfo->outsyms;
3822   incls = 0;
3823   oline = NULL;
3824
3825   while (esym < esym_end)
3826     {
3827       struct internal_syment isym;
3828       union internal_auxent aux;
3829       int smtyp = 0;
3830       boolean skip;
3831       boolean require;
3832       int add;
3833
3834       bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
3835
3836       /* If this is a C_EXT or C_HIDEXT symbol, we need the csect
3837          information.  */
3838       if (isymp->n_sclass == C_EXT || isymp->n_sclass == C_HIDEXT)
3839         {
3840           BFD_ASSERT (isymp->n_numaux > 0);
3841           bfd_coff_swap_aux_in (input_bfd,
3842                                 (PTR) (esym + isymesz * isymp->n_numaux),
3843                                 isymp->n_type, isymp->n_sclass,
3844                                 isymp->n_numaux - 1, isymp->n_numaux,
3845                                 (PTR) &aux);
3846           smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
3847         }
3848
3849       /* Make a copy of *isymp so that the relocate_section function
3850          always sees the original values.  This is more reliable than
3851          always recomputing the symbol value even if we are stripping
3852          the symbol.  */
3853       isym = *isymp;
3854
3855       /* If this symbol is in the .loader section, swap out the
3856          .loader symbol information.  If this is an external symbol
3857          reference to a defined symbol, though, then wait until we get
3858          to the definition.  */
3859       if (isym.n_sclass == C_EXT
3860           && *sym_hash != NULL
3861           && (*sym_hash)->ldsym != NULL
3862           && (smtyp != XTY_ER
3863               || (*sym_hash)->root.type == bfd_link_hash_undefined))
3864         {
3865           struct xcoff_link_hash_entry *h;
3866           struct internal_ldsym *ldsym;
3867
3868           h = *sym_hash;
3869           ldsym = h->ldsym;
3870           if (isym.n_scnum > 0)
3871             {
3872               ldsym->l_scnum = (*csectpp)->output_section->target_index;
3873               ldsym->l_value = (isym.n_value
3874                                 + (*csectpp)->output_section->vma
3875                                 + (*csectpp)->output_offset
3876                                 - (*csectpp)->vma);
3877             }
3878           else
3879             {
3880               ldsym->l_scnum = isym.n_scnum;
3881               ldsym->l_value = isym.n_value;
3882             }
3883
3884           ldsym->l_smtype = smtyp;
3885           if (((h->flags & XCOFF_DEF_REGULAR) == 0
3886                && (h->flags & XCOFF_DEF_DYNAMIC) != 0)
3887               || (h->flags & XCOFF_IMPORT) != 0)
3888             ldsym->l_smtype |= L_IMPORT;
3889           if (((h->flags & XCOFF_DEF_REGULAR) != 0
3890                && (h->flags & XCOFF_DEF_DYNAMIC) != 0)
3891               || (h->flags & XCOFF_EXPORT) != 0)
3892             ldsym->l_smtype |= L_EXPORT;
3893           if ((h->flags & XCOFF_ENTRY) != 0)
3894             ldsym->l_smtype |= L_ENTRY;
3895
3896           ldsym->l_smclas = aux.x_csect.x_smclas;
3897
3898           if (ldsym->l_ifile == (bfd_size_type) -1)
3899             ldsym->l_ifile = 0;
3900           else if (ldsym->l_ifile == 0)
3901             {
3902               if ((ldsym->l_smtype & L_IMPORT) == 0)
3903                 ldsym->l_ifile = 0;
3904               else
3905                 {
3906                   bfd *impbfd;
3907
3908                   if (h->root.type == bfd_link_hash_defined
3909                       || h->root.type == bfd_link_hash_defweak)
3910                     impbfd = h->root.u.def.section->owner;
3911                   else if (h->root.type == bfd_link_hash_undefined
3912                            || h->root.type == bfd_link_hash_undefweak)
3913                     impbfd = h->root.u.undef.abfd;
3914                   else
3915                     impbfd = NULL;
3916
3917                   if (impbfd == NULL)
3918                     ldsym->l_ifile = 0;
3919                   else
3920                     {
3921                       BFD_ASSERT (impbfd->xvec == finfo->output_bfd->xvec);
3922                       ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
3923                     }
3924                 }
3925             }
3926
3927           ldsym->l_parm = 0;
3928
3929           BFD_ASSERT (h->ldindx >= 0);
3930           BFD_ASSERT (LDSYMSZ == sizeof (struct external_ldsym));
3931           xcoff_swap_ldsym_out (finfo->output_bfd, ldsym,
3932                                 finfo->ldsym + h->ldindx - 3);
3933           h->ldsym = NULL;
3934
3935           /* Fill in snentry now that we know the target_index.  */
3936           if ((h->flags & XCOFF_ENTRY) != 0
3937               && (h->root.type == bfd_link_hash_defined
3938                   || h->root.type == bfd_link_hash_defweak))
3939             xcoff_data (output_bfd)->snentry =
3940               h->root.u.def.section->output_section->target_index;
3941         }
3942
3943       *indexp = -1;
3944
3945       skip = false;
3946       require = false;
3947       add = 1 + isym.n_numaux;
3948
3949       /* If we are skipping this csect, we want to skip this symbol.  */
3950       if (*csectpp == NULL)
3951         skip = true;
3952
3953       /* If we garbage collected this csect, we want to skip this
3954          symbol.  */
3955       if (! skip
3956           && xcoff_hash_table (finfo->info)->gc
3957           && ((*csectpp)->flags & SEC_MARK) == 0
3958           && *csectpp != bfd_abs_section_ptr)
3959         skip = true;
3960
3961       /* An XCOFF linker always skips C_STAT symbols.  */
3962       if (! skip
3963           && isymp->n_sclass == C_STAT)
3964         skip = true;
3965
3966       /* We skip all but the first TOC anchor.  */
3967       if (! skip
3968           && isymp->n_sclass == C_HIDEXT
3969           && aux.x_csect.x_smclas == XMC_TC0)
3970         {
3971           if (finfo->toc_symindx != -1)
3972             skip = true;
3973           else
3974             {
3975               bfd_vma tocval, tocend;
3976
3977               tocval = ((*csectpp)->output_section->vma
3978                         + (*csectpp)->output_offset
3979                         + isym.n_value
3980                         - (*csectpp)->vma);
3981               /* We want to find out if tocval is a good value to use
3982                  as the TOC anchor--that is, whether we can access all
3983                  of the TOC using a 16 bit offset from tocval.  This
3984                  test assumes that the TOC comes at the end of the
3985                  output section, as it does in the default linker
3986                  script.  If the TOC anchor is too far into the .toc
3987                  section, the relocation routine will report
3988                  overflows.  */
3989               tocend = ((*csectpp)->output_section->vma
3990                         + (*csectpp)->output_section->_raw_size);
3991               if (tocval + 0x8000 < tocend)
3992                 {
3993                   bfd_vma tocadd;
3994
3995                   tocadd = tocend - (tocval + 0x8000);
3996                   tocval += tocadd;
3997                   isym.n_value += tocadd;
3998                 }
3999
4000               finfo->toc_symindx = output_index;
4001               xcoff_data (finfo->output_bfd)->toc = tocval;
4002               xcoff_data (finfo->output_bfd)->sntoc =
4003                 (*csectpp)->output_section->target_index;
4004               require = true;
4005             }
4006         }
4007
4008       /* If we are stripping all symbols, we want to skip this one.  */
4009       if (! skip
4010           && finfo->info->strip == strip_all)
4011         skip = true;
4012
4013       /* We can skip resolved external references.  */
4014       if (! skip
4015           && isym.n_sclass == C_EXT
4016           && smtyp == XTY_ER
4017           && (*sym_hash)->root.type != bfd_link_hash_undefined)
4018         skip = true;
4019
4020       /* We can skip common symbols if they got defined somewhere
4021          else.  */
4022       if (! skip
4023           && isym.n_sclass == C_EXT
4024           && smtyp == XTY_CM
4025           && ((*sym_hash)->root.type != bfd_link_hash_common
4026               || (*sym_hash)->root.u.c.p->section != *csectpp)
4027           && ((*sym_hash)->root.type != bfd_link_hash_defined
4028               || (*sym_hash)->root.u.def.section != *csectpp))
4029         skip = true;
4030
4031       /* Skip local symbols if we are discarding them.  */
4032       if (! skip
4033           && finfo->info->discard == discard_all
4034           && isym.n_sclass != C_EXT
4035           && (isym.n_sclass != C_HIDEXT
4036               || smtyp != XTY_SD))
4037         skip = true;
4038
4039       /* If we stripping debugging symbols, and this is a debugging
4040          symbol, then skip it.  */
4041       if (! skip
4042           && finfo->info->strip == strip_debugger
4043           && isym.n_scnum == N_DEBUG)
4044         skip = true;
4045
4046       /* If some symbols are stripped based on the name, work out the
4047          name and decide whether to skip this symbol.  We don't handle
4048          this correctly for symbols whose names are in the .debug
4049          section; to get it right we would need a new bfd_strtab_hash
4050          function to return the string given the index.  */
4051       if (! skip
4052           && (finfo->info->strip == strip_some
4053               || finfo->info->discard == discard_l)
4054           && (debug_index == NULL || *debug_index == (unsigned long) -1))
4055         {
4056           const char *name;
4057           char buf[SYMNMLEN + 1];
4058
4059           name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
4060           if (name == NULL)
4061             return false;
4062
4063           if ((finfo->info->strip == strip_some
4064                && (bfd_hash_lookup (finfo->info->keep_hash, name, false,
4065                                     false) == NULL))
4066               || (finfo->info->discard == discard_l
4067                   && (isym.n_sclass != C_EXT
4068                       && (isym.n_sclass != C_HIDEXT
4069                           || smtyp != XTY_SD))
4070                   && strncmp (name, finfo->info->lprefix,
4071                               finfo->info->lprefix_len) == 0))
4072             skip = true;
4073         }
4074
4075       /* We can not skip the first TOC anchor.  */
4076       if (skip
4077           && require
4078           && finfo->info->strip != strip_all)
4079         skip = false;
4080
4081       /* We now know whether we are to skip this symbol or not.  */
4082       if (! skip)
4083         {
4084           /* Adjust the symbol in order to output it.  */
4085
4086           if (isym._n._n_n._n_zeroes == 0
4087               && isym._n._n_n._n_offset != 0)
4088             {
4089               /* This symbol has a long name.  Enter it in the string
4090                  table we are building.  If *debug_index != -1, the
4091                  name has already been entered in the .debug section.  */
4092               if (debug_index != NULL && *debug_index != (unsigned long) -1)
4093                 isym._n._n_n._n_offset = *debug_index;
4094               else
4095                 {
4096                   const char *name;
4097                   bfd_size_type indx;
4098
4099                   name = _bfd_coff_internal_syment_name (input_bfd, &isym,
4100                                                          (char *) NULL);
4101                   if (name == NULL)
4102                     return false;
4103                   indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
4104                   if (indx == (bfd_size_type) -1)
4105                     return false;
4106                   isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
4107                 }
4108             }
4109
4110           if (isym.n_sclass != C_BSTAT
4111               && isym.n_sclass != C_ESTAT
4112               && isym.n_sclass != C_DECL
4113               && isym.n_scnum > 0)
4114             {
4115               isym.n_scnum = (*csectpp)->output_section->target_index;
4116               isym.n_value += ((*csectpp)->output_section->vma
4117                                + (*csectpp)->output_offset
4118                                - (*csectpp)->vma);
4119             }
4120
4121           /* The value of a C_FILE symbol is the symbol index of the
4122              next C_FILE symbol.  The value of the last C_FILE symbol
4123              is -1.  We try to get this right, below, just before we
4124              write the symbols out, but in the general case we may
4125              have to write the symbol out twice.  */
4126           if (isym.n_sclass == C_FILE)
4127             {
4128               if (finfo->last_file_index != -1
4129                   && finfo->last_file.n_value != (long) output_index)
4130                 {
4131                   /* We must correct the value of the last C_FILE entry.  */
4132                   finfo->last_file.n_value = output_index;
4133                   if ((bfd_size_type) finfo->last_file_index >= syment_base)
4134                     {
4135                       /* The last C_FILE symbol is in this input file.  */
4136                       bfd_coff_swap_sym_out (output_bfd,
4137                                              (PTR) &finfo->last_file,
4138                                              (PTR) (finfo->outsyms
4139                                                     + ((finfo->last_file_index
4140                                                         - syment_base)
4141                                                        * osymesz)));
4142                     }
4143                   else
4144                     {
4145                       /* We have already written out the last C_FILE
4146                          symbol.  We need to write it out again.  We
4147                          borrow *outsym temporarily.  */
4148                       bfd_coff_swap_sym_out (output_bfd,
4149                                              (PTR) &finfo->last_file,
4150                                              (PTR) outsym);
4151                       if (bfd_seek (output_bfd,
4152                                     (obj_sym_filepos (output_bfd)
4153                                      + finfo->last_file_index * osymesz),
4154                                     SEEK_SET) != 0
4155                           || (bfd_write (outsym, osymesz, 1, output_bfd)
4156                               != osymesz))
4157                         return false;
4158                     }
4159                 }
4160
4161               finfo->last_file_index = output_index;
4162               finfo->last_file = isym;
4163             }
4164
4165           /* The value of a C_BINCL or C_EINCL symbol is a file offset
4166              into the line numbers.  We update the symbol values when
4167              we handle the line numbers.  */
4168           if (isym.n_sclass == C_BINCL
4169               || isym.n_sclass == C_EINCL)
4170             {
4171               isym.n_value = finfo->line_filepos;
4172               ++incls;
4173             }
4174
4175           /* Output the symbol.  */
4176
4177           bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
4178
4179           *indexp = output_index;
4180
4181           if (isym.n_sclass == C_EXT)
4182             {
4183               long indx;
4184               struct xcoff_link_hash_entry *h;
4185
4186               indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
4187                       / isymesz);
4188               h = obj_xcoff_sym_hashes (input_bfd)[indx];
4189               BFD_ASSERT (h != NULL);
4190               h->indx = output_index;
4191             }
4192
4193           /* If this is a symbol in the TOC which we may have merged
4194              (class XMC_TC), remember the symbol index of the TOC
4195              symbol.  */
4196           if (isym.n_sclass == C_HIDEXT
4197               && aux.x_csect.x_smclas == XMC_TC
4198               && *sym_hash != NULL)
4199             {
4200               BFD_ASSERT (((*sym_hash)->flags & XCOFF_SET_TOC) == 0);
4201               BFD_ASSERT ((*sym_hash)->toc_section != NULL);
4202               (*sym_hash)->u.toc_indx = output_index;
4203             }
4204
4205           output_index += add;
4206           outsym += add * osymesz;
4207         }
4208
4209       esym += add * isymesz;
4210       isymp += add;
4211       csectpp += add;
4212       sym_hash += add;
4213       if (debug_index != NULL)
4214         debug_index += add;
4215       ++indexp;
4216       for (--add; add > 0; --add)
4217         *indexp++ = -1;
4218     }
4219
4220   /* Fix up the aux entries and the C_BSTAT symbols.  This must be
4221      done in a separate pass, because we don't know the correct symbol
4222      indices until we have already decided which symbols we are going
4223      to keep.  */
4224
4225   esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
4226   esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
4227   isymp = finfo->internal_syms;
4228   indexp = finfo->sym_indices;
4229   csectpp = xcoff_data (input_bfd)->csects;
4230   outsym = finfo->outsyms;
4231   while (esym < esym_end)
4232     {
4233       int add;
4234
4235       add = 1 + isymp->n_numaux;
4236
4237       if (*indexp < 0)
4238         esym += add * isymesz;
4239       else
4240         {
4241           int i;
4242
4243           if (isymp->n_sclass == C_BSTAT)
4244             {
4245               struct internal_syment isym;
4246               unsigned long indx;
4247
4248               /* The value of a C_BSTAT symbol is the symbol table
4249                  index of the containing csect.  */
4250               bfd_coff_swap_sym_in (output_bfd, (PTR) outsym, (PTR) &isym);
4251               indx = isym.n_value;
4252               if (indx < obj_raw_syment_count (input_bfd))
4253                 {
4254                   long symindx;
4255
4256                   symindx = finfo->sym_indices[indx];
4257                   if (symindx < 0)
4258                     isym.n_value = 0;
4259                   else
4260                     isym.n_value = symindx;
4261                   bfd_coff_swap_sym_out (output_bfd, (PTR) &isym,
4262                                          (PTR) outsym);
4263                 }
4264             }
4265
4266           esym += isymesz;
4267           outsym += osymesz;
4268
4269           for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
4270             {
4271               union internal_auxent aux;
4272
4273               bfd_coff_swap_aux_in (input_bfd, (PTR) esym, isymp->n_type,
4274                                     isymp->n_sclass, i, isymp->n_numaux,
4275                                     (PTR) &aux);
4276
4277               if (isymp->n_sclass == C_FILE)
4278                 {
4279                   /* This is the file name (or some comment put in by
4280                      the compiler).  If it is long, we must put it in
4281                      the string table.  */
4282                   if (aux.x_file.x_n.x_zeroes == 0
4283                       && aux.x_file.x_n.x_offset != 0)
4284                     {
4285                       const char *filename;
4286                       bfd_size_type indx;
4287
4288                       BFD_ASSERT (aux.x_file.x_n.x_offset
4289                                   >= STRING_SIZE_SIZE);
4290                       if (strings == NULL)
4291                         {
4292                           strings = _bfd_coff_read_string_table (input_bfd);
4293                           if (strings == NULL)
4294                             return false;
4295                         }
4296                       filename = strings + aux.x_file.x_n.x_offset;
4297                       indx = _bfd_stringtab_add (finfo->strtab, filename,
4298                                                  hash, copy);
4299                       if (indx == (bfd_size_type) -1)
4300                         return false;
4301                       aux.x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
4302                     }
4303                 }
4304               else if ((isymp->n_sclass == C_EXT
4305                         || isymp->n_sclass == C_HIDEXT)
4306                        && i + 1 == isymp->n_numaux)
4307                 {
4308                   /* We don't support type checking.  I don't know if
4309                      anybody does.  */
4310                   aux.x_csect.x_parmhash = 0;
4311                   /* I don't think anybody uses these fields, but we'd
4312                      better clobber them just in case.  */
4313                   aux.x_csect.x_stab = 0;
4314                   aux.x_csect.x_snstab = 0;
4315                   if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_LD)
4316                     {
4317                       unsigned long indx;
4318
4319                       indx = aux.x_csect.x_scnlen.l;
4320                       if (indx < obj_raw_syment_count (input_bfd))
4321                         {
4322                           long symindx;
4323
4324                           symindx = finfo->sym_indices[indx];
4325                           if (symindx < 0)
4326                             aux.x_sym.x_tagndx.l = 0;
4327                           else
4328                             aux.x_sym.x_tagndx.l = symindx;
4329                         }
4330                     }
4331                 }
4332               else if (isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
4333                 {
4334                   unsigned long indx;
4335
4336                   if (ISFCN (isymp->n_type)
4337                       || ISTAG (isymp->n_sclass)
4338                       || isymp->n_sclass == C_BLOCK)
4339                     {
4340                       indx = aux.x_sym.x_fcnary.x_fcn.x_endndx.l;
4341                       if (indx > 0
4342                           && indx < obj_raw_syment_count (input_bfd))
4343                         {
4344                           /* We look forward through the symbol for
4345                              the index of the next symbol we are going
4346                              to include.  I don't know if this is
4347                              entirely right.  */
4348                           while (finfo->sym_indices[indx] < 0
4349                                  && indx < obj_raw_syment_count (input_bfd))
4350                             ++indx;
4351                           if (indx >= obj_raw_syment_count (input_bfd))
4352                             indx = output_index;
4353                           else
4354                             indx = finfo->sym_indices[indx];
4355                           aux.x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
4356                         }
4357                     }
4358
4359                   indx = aux.x_sym.x_tagndx.l;
4360                   if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
4361                     {
4362                       long symindx;
4363
4364                       symindx = finfo->sym_indices[indx];
4365                       if (symindx < 0)
4366                         aux.x_sym.x_tagndx.l = 0;
4367                       else
4368                         aux.x_sym.x_tagndx.l = symindx;
4369                     }
4370                 }
4371
4372               /* Copy over the line numbers, unless we are stripping
4373                  them.  We do this on a symbol by symbol basis in
4374                  order to more easily handle garbage collection.  */
4375               if ((isymp->n_sclass == C_EXT
4376                    || isymp->n_sclass == C_HIDEXT)
4377                   && i == 0
4378                   && isymp->n_numaux > 1
4379                   && ISFCN (isymp->n_type)
4380                   && aux.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
4381                 {
4382                   if (finfo->info->strip != strip_none
4383                       && finfo->info->strip != strip_some)
4384                     aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
4385                   else
4386                     {
4387                       asection *enclosing;
4388                       unsigned int enc_count;
4389                       bfd_size_type linoff;
4390                       struct internal_lineno lin;
4391
4392                       o = *csectpp;
4393                       enclosing = xcoff_section_data (abfd, o)->enclosing;
4394                       enc_count = xcoff_section_data (abfd, o)->lineno_count;
4395                       if (oline != enclosing)
4396                         {
4397                           if (bfd_seek (input_bfd,
4398                                         enclosing->line_filepos,
4399                                         SEEK_SET) != 0
4400                               || (bfd_read (finfo->linenos, linesz,
4401                                             enc_count, input_bfd)
4402                                   != linesz * enc_count))
4403                             return false;
4404                           oline = enclosing;
4405                         }
4406
4407                       linoff = (aux.x_sym.x_fcnary.x_fcn.x_lnnoptr
4408                                 - enclosing->line_filepos);
4409
4410                       bfd_coff_swap_lineno_in (input_bfd,
4411                                                (PTR) (finfo->linenos + linoff),
4412                                                (PTR) &lin);
4413                       if (lin.l_lnno != 0
4414                           || ((bfd_size_type) lin.l_addr.l_symndx
4415                               != ((esym
4416                                    - isymesz
4417                                    - ((bfd_byte *)
4418                                       obj_coff_external_syms (input_bfd)))
4419                                   / isymesz)))
4420                         aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
4421                       else
4422                         {
4423                           bfd_byte *linpend, *linp;
4424                           bfd_vma offset;
4425                           bfd_size_type count;
4426
4427                           lin.l_addr.l_symndx = *indexp;
4428                           bfd_coff_swap_lineno_out (output_bfd, (PTR) &lin,
4429                                                     (PTR) (finfo->linenos
4430                                                            + linoff));
4431
4432                           linpend = (finfo->linenos
4433                                      + enc_count * linesz);
4434                           offset = (o->output_section->vma
4435                                     + o->output_offset
4436                                     - o->vma);
4437                           for (linp = finfo->linenos + linoff + linesz;
4438                                linp < linpend;
4439                                linp += linesz)
4440                             {
4441                               bfd_coff_swap_lineno_in (input_bfd, (PTR) linp,
4442                                                        (PTR) &lin);
4443                               if (lin.l_lnno == 0)
4444                                 break;
4445                               lin.l_addr.l_paddr += offset;
4446                               bfd_coff_swap_lineno_out (output_bfd,
4447                                                         (PTR) &lin,
4448                                                         (PTR) linp);
4449                             }
4450
4451                           count = (linp - (finfo->linenos + linoff)) / linesz;
4452
4453                           aux.x_sym.x_fcnary.x_fcn.x_lnnoptr =
4454                             (o->output_section->line_filepos
4455                              + o->output_section->lineno_count * linesz);
4456
4457                           if (bfd_seek (output_bfd,
4458                                         aux.x_sym.x_fcnary.x_fcn.x_lnnoptr,
4459                                         SEEK_SET) != 0
4460                               || (bfd_write (finfo->linenos + linoff,
4461                                              linesz, count, output_bfd)
4462                                   != linesz * count))
4463                             return false;
4464
4465                           o->output_section->lineno_count += count;
4466
4467                           if (incls > 0)
4468                             {
4469                               struct internal_syment *iisp, *iispend;
4470                               long *iindp;
4471                               bfd_byte *oos;
4472
4473                               /* Update any C_BINCL or C_EINCL symbols
4474                                  that refer to a line number in the
4475                                  range we just output.  */
4476                               iisp = finfo->internal_syms;
4477                               iispend = (iisp
4478                                          + obj_raw_syment_count (input_bfd));
4479                               iindp = finfo->sym_indices;
4480                               oos = finfo->outsyms;
4481                               while (iisp < iispend)
4482                                 {
4483                                   if ((iisp->n_sclass == C_BINCL
4484                                        || iisp->n_sclass == C_EINCL)
4485                                       && ((bfd_size_type) iisp->n_value
4486                                           >= enclosing->line_filepos + linoff)
4487                                       && ((bfd_size_type) iisp->n_value
4488                                           < (enclosing->line_filepos
4489                                              + enc_count * linesz)))
4490                                     {
4491                                       struct internal_syment iis;
4492
4493                                       bfd_coff_swap_sym_in (output_bfd,
4494                                                             (PTR) oos,
4495                                                             (PTR) &iis);
4496                                       iis.n_value =
4497                                         (iisp->n_value
4498                                          - enclosing->line_filepos
4499                                          - linoff
4500                                          + aux.x_sym.x_fcnary.x_fcn.x_lnnoptr);
4501                                       bfd_coff_swap_sym_out (output_bfd,
4502                                                              (PTR) &iis,
4503                                                              (PTR) oos);
4504                                       --incls;
4505                                     }
4506
4507                                   iisp += iisp->n_numaux + 1;
4508                                   iindp += iisp->n_numaux + 1;
4509                                   oos += (iisp->n_numaux + 1) * osymesz;
4510                                 }
4511                             }
4512                         }
4513                     }
4514                 }
4515
4516               bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, isymp->n_type,
4517                                      isymp->n_sclass, i, isymp->n_numaux,
4518                                      (PTR) outsym);
4519               outsym += osymesz;
4520               esym += isymesz;
4521             }
4522         }
4523
4524       indexp += add;
4525       isymp += add;
4526       csectpp += add;
4527     }
4528
4529   /* If we swapped out a C_FILE symbol, guess that the next C_FILE
4530      symbol will be the first symbol in the next input file.  In the
4531      normal case, this will save us from writing out the C_FILE symbol
4532      again.  */
4533   if (finfo->last_file_index != -1
4534       && (bfd_size_type) finfo->last_file_index >= syment_base)
4535     {
4536       finfo->last_file.n_value = output_index;
4537       bfd_coff_swap_sym_out (output_bfd, (PTR) &finfo->last_file,
4538                              (PTR) (finfo->outsyms
4539                                     + ((finfo->last_file_index - syment_base)
4540                                        * osymesz)));
4541     }
4542
4543   /* Write the modified symbols to the output file.  */
4544   if (outsym > finfo->outsyms)
4545     {
4546       if (bfd_seek (output_bfd,
4547                     obj_sym_filepos (output_bfd) + syment_base * osymesz,
4548                     SEEK_SET) != 0
4549           || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1,
4550                         output_bfd)
4551               != (bfd_size_type) (outsym - finfo->outsyms)))
4552         return false;
4553
4554       BFD_ASSERT ((obj_raw_syment_count (output_bfd)
4555                    + (outsym - finfo->outsyms) / osymesz)
4556                   == output_index);
4557
4558       obj_raw_syment_count (output_bfd) = output_index;
4559     }
4560
4561   /* Don't let the linker relocation routines discard the symbols.  */
4562   keep_syms = obj_coff_keep_syms (input_bfd);
4563   obj_coff_keep_syms (input_bfd) = true;
4564
4565   /* Relocate the contents of each section.  */
4566   for (o = input_bfd->sections; o != NULL; o = o->next)
4567     {
4568       bfd_byte *contents;
4569
4570       if ((o->flags & SEC_HAS_CONTENTS) == 0
4571           || o->_raw_size == 0
4572           || (o->flags & SEC_IN_MEMORY) != 0)
4573         continue;
4574
4575       /* We have set filepos correctly for the sections we created to
4576          represent csects, so bfd_get_section_contents should work.  */
4577       if (coff_section_data (input_bfd, o) != NULL
4578           && coff_section_data (input_bfd, o)->contents != NULL)
4579         contents = coff_section_data (input_bfd, o)->contents;
4580       else
4581         {
4582           if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
4583                                           (file_ptr) 0, o->_raw_size))
4584             return false;
4585           contents = finfo->contents;
4586         }
4587
4588       if ((o->flags & SEC_RELOC) != 0)
4589         {
4590           int target_index;
4591           struct internal_reloc *internal_relocs;
4592           struct internal_reloc *irel;
4593           bfd_vma offset;
4594           struct internal_reloc *irelend;
4595           struct xcoff_link_hash_entry **rel_hash;
4596           long r_symndx;
4597
4598           /* Read in the relocs.  */
4599           target_index = o->output_section->target_index;
4600           internal_relocs = (xcoff_read_internal_relocs
4601                              (input_bfd, o, false, finfo->external_relocs,
4602                               true,
4603                               (finfo->section_info[target_index].relocs
4604                                + o->output_section->reloc_count)));
4605           if (internal_relocs == NULL)
4606             return false;
4607
4608           /* Call processor specific code to relocate the section
4609              contents.  */
4610           if (! bfd_coff_relocate_section (output_bfd, finfo->info,
4611                                            input_bfd, o,
4612                                            contents,
4613                                            internal_relocs,
4614                                            finfo->internal_syms,
4615                                            xcoff_data (input_bfd)->csects))
4616             return false;
4617
4618           offset = o->output_section->vma + o->output_offset - o->vma;
4619           irel = internal_relocs;
4620           irelend = irel + o->reloc_count;
4621           rel_hash = (finfo->section_info[target_index].rel_hashes
4622                       + o->output_section->reloc_count);
4623           for (; irel < irelend; irel++, rel_hash++)
4624             {
4625               struct xcoff_link_hash_entry *h = NULL;
4626               struct internal_ldrel ldrel;
4627
4628               *rel_hash = NULL;
4629
4630               /* Adjust the reloc address and symbol index.  */
4631
4632               irel->r_vaddr += offset;
4633
4634               r_symndx = irel->r_symndx;
4635
4636               if (r_symndx != -1)
4637                 {
4638                   h = obj_xcoff_sym_hashes (input_bfd)[r_symndx];
4639                   if  (h != NULL
4640                        && (irel->r_type == R_TOC
4641                            || irel->r_type == R_GL
4642                            || irel->r_type == R_TCL
4643                            || irel->r_type == R_TRL
4644                            || irel->r_type == R_TRLA))
4645                     {
4646                       /* This is a TOC relative reloc with a symbol
4647                          attached.  The symbol should be the one which
4648                          this reloc is for.  We want to make this
4649                          reloc against the TOC address of the symbol,
4650                          not the symbol itself.  */
4651                       BFD_ASSERT (h->toc_section != NULL);
4652                       BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
4653                       if (h->u.toc_indx != -1)
4654                         irel->r_symndx = h->u.toc_indx;
4655                       else
4656                         {
4657                           struct xcoff_toc_rel_hash *n;
4658                           struct xcoff_link_section_info *si;
4659
4660                           n = ((struct xcoff_toc_rel_hash *)
4661                                bfd_alloc (finfo->output_bfd,
4662                                           sizeof (struct xcoff_toc_rel_hash)));
4663                           if (n == NULL)
4664                             return false;
4665                           si = finfo->section_info + target_index;
4666                           n->next = si->toc_rel_hashes;
4667                           n->h = h;
4668                           n->rel = irel;
4669                           si->toc_rel_hashes = n;
4670                         }
4671                     }
4672                   else if (h != NULL)
4673                     {
4674                       /* This is a global symbol.  */
4675                       if (h->indx >= 0)
4676                         irel->r_symndx = h->indx;
4677                       else
4678                         {
4679                           /* This symbol is being written at the end
4680                              of the file, and we do not yet know the
4681                              symbol index.  We save the pointer to the
4682                              hash table entry in the rel_hash list.
4683                              We set the indx field to -2 to indicate
4684                              that this symbol must not be stripped.  */
4685                           *rel_hash = h;
4686                           h->indx = -2;
4687                         }
4688                     }
4689                   else
4690                     {
4691                       long indx;
4692
4693                       indx = finfo->sym_indices[r_symndx];
4694
4695                       if (indx == -1)
4696                         {
4697                           struct internal_syment *is;
4698
4699                           /* Relocations against a TC0 TOC anchor are
4700                              automatically transformed to be against
4701                              the TOC anchor in the output file.  */
4702                           is = finfo->internal_syms + r_symndx;
4703                           if (is->n_sclass == C_HIDEXT
4704                               && is->n_numaux > 0)
4705                             {
4706                               PTR auxptr;
4707                               union internal_auxent aux;
4708
4709                               auxptr = ((PTR)
4710                                         (((bfd_byte *)
4711                                           obj_coff_external_syms (input_bfd))
4712                                          + ((r_symndx + is->n_numaux)
4713                                             * isymesz)));
4714                               bfd_coff_swap_aux_in (input_bfd, auxptr,
4715                                                     is->n_type, is->n_sclass,
4716                                                     is->n_numaux - 1,
4717                                                     is->n_numaux,
4718                                                     (PTR) &aux);
4719                               if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_SD
4720                                   && aux.x_csect.x_smclas == XMC_TC0)
4721                                 indx = finfo->toc_symindx;
4722                             }
4723                         }
4724
4725                       if (indx != -1)
4726                         irel->r_symndx = indx;
4727                       else
4728                         {
4729                           struct internal_syment *is;
4730                           const char *name;
4731                           char buf[SYMNMLEN + 1];
4732
4733                           /* This reloc is against a symbol we are
4734                              stripping.  It would be possible to handle
4735                              this case, but I don't think it's worth it.  */
4736                           is = finfo->internal_syms + r_symndx;
4737
4738                           name = (_bfd_coff_internal_syment_name
4739                                   (input_bfd, is, buf));
4740                           if (name == NULL)
4741                             return false;
4742
4743                           if (! ((*finfo->info->callbacks->unattached_reloc)
4744                                  (finfo->info, name, input_bfd, o,
4745                                   irel->r_vaddr)))
4746                             return false;
4747                         }
4748                     }
4749                 }
4750
4751               switch (irel->r_type)
4752                 {
4753                 default:
4754                   if (h == NULL
4755                       || h->root.type == bfd_link_hash_defined
4756                       || h->root.type == bfd_link_hash_defweak
4757                       || h->root.type == bfd_link_hash_common)
4758                     break;
4759                   /* Fall through.  */
4760                 case R_POS:
4761                 case R_NEG:
4762                 case R_RL:
4763                 case R_RLA:
4764                   /* This reloc needs to be copied into the .loader
4765                      section.  */
4766                   ldrel.l_vaddr = irel->r_vaddr;
4767                   if (r_symndx == -1)
4768                     ldrel.l_symndx = -1;
4769                   else if (h == NULL
4770                            || (h->root.type == bfd_link_hash_defined
4771                                || h->root.type == bfd_link_hash_defweak
4772                                || h->root.type == bfd_link_hash_common))
4773                     {
4774                       asection *sec;
4775
4776                       if (h == NULL)
4777                         sec = xcoff_data (input_bfd)->csects[r_symndx];
4778                       else if (h->root.type == bfd_link_hash_common)
4779                         sec = h->root.u.c.p->section;
4780                       else
4781                         sec = h->root.u.def.section;
4782                       sec = sec->output_section;
4783
4784                       if (strcmp (sec->name, ".text") == 0)
4785                         ldrel.l_symndx = 0;
4786                       else if (strcmp (sec->name, ".data") == 0)
4787                         ldrel.l_symndx = 1;
4788                       else if (strcmp (sec->name, ".bss") == 0)
4789                         ldrel.l_symndx = 2;
4790                       else
4791                         {
4792                           (*_bfd_error_handler)
4793                             ("%s: loader reloc in unrecognized section `%s'",
4794                              bfd_get_filename (input_bfd),
4795                              sec->name);
4796                           bfd_set_error (bfd_error_nonrepresentable_section);
4797                           return false;
4798                         }
4799                     }
4800                   else
4801                     {
4802                       if (h->ldindx < 0)
4803                         {
4804                           (*_bfd_error_handler)
4805                             ("%s: `%s' in loader reloc but not loader sym",
4806                              bfd_get_filename (input_bfd),
4807                              h->root.root.string);
4808                           bfd_set_error (bfd_error_bad_value);
4809                           return false;
4810                         }
4811                       ldrel.l_symndx = h->ldindx;
4812                     }
4813                   ldrel.l_rtype = (irel->r_size << 8) | irel->r_type;
4814                   ldrel.l_rsecnm = o->output_section->target_index;
4815                   if (xcoff_hash_table (finfo->info)->textro
4816                       && strcmp (o->output_section->name, ".text") == 0)
4817                     {
4818                       (*_bfd_error_handler)
4819                         ("%s: loader reloc in read-only section %s",
4820                          bfd_get_filename (input_bfd),
4821                          bfd_get_section_name (finfo->output_bfd,
4822                                                o->output_section));
4823                       bfd_set_error (bfd_error_invalid_operation);
4824                       return false;
4825                     }
4826                   xcoff_swap_ldrel_out (output_bfd, &ldrel,
4827                                         finfo->ldrel);
4828                   BFD_ASSERT (sizeof (struct external_ldrel) == LDRELSZ);
4829                   ++finfo->ldrel;
4830                   break;
4831
4832                 case R_TOC:
4833                 case R_GL:
4834                 case R_TCL:
4835                 case R_TRL:
4836                 case R_TRLA:
4837                   /* We should never need a .loader reloc for a TOC
4838                      relative reloc.  */
4839                   break;
4840                 }
4841             }
4842
4843           o->output_section->reloc_count += o->reloc_count;
4844         }
4845
4846       /* Write out the modified section contents.  */
4847       if (! bfd_set_section_contents (output_bfd, o->output_section,
4848                                       contents, o->output_offset,
4849                                       (o->_cooked_size != 0
4850                                        ? o->_cooked_size
4851                                        : o->_raw_size)))
4852         return false;
4853     }
4854
4855   obj_coff_keep_syms (input_bfd) = keep_syms;
4856
4857   if (! finfo->info->keep_memory)
4858     {
4859       if (! _bfd_coff_free_symbols (input_bfd))
4860         return false;
4861     }
4862
4863   return true;
4864 }
4865
4866 #undef N_TMASK
4867 #undef N_BTSHFT
4868
4869 /* Write out a non-XCOFF global symbol.  */
4870
4871 static boolean
4872 xcoff_write_global_symbol (h, p)
4873      struct xcoff_link_hash_entry *h;
4874      PTR p;
4875 {
4876   struct xcoff_final_link_info *finfo = (struct xcoff_final_link_info *) p;
4877   bfd *output_bfd;
4878   bfd_byte *outsym;
4879   struct internal_syment isym;
4880   union internal_auxent aux;
4881
4882   output_bfd = finfo->output_bfd;
4883
4884   /* If this symbol was garbage collected, just skip it.  */
4885   if (xcoff_hash_table (finfo->info)->gc
4886       && (h->flags & XCOFF_MARK) == 0)
4887     return true;
4888
4889   /* If we need a .loader section entry, write it out.  */
4890   if (h->ldsym != NULL)
4891     {
4892       struct internal_ldsym *ldsym;
4893       bfd *impbfd;
4894
4895       ldsym = h->ldsym;
4896
4897       if (h->root.type == bfd_link_hash_undefined
4898           || h->root.type == bfd_link_hash_undefweak)
4899         {
4900           ldsym->l_value = 0;
4901           ldsym->l_scnum = N_UNDEF;
4902           ldsym->l_smtype = XTY_ER;
4903           impbfd = h->root.u.undef.abfd;
4904         }
4905       else if (h->root.type == bfd_link_hash_defined
4906                || h->root.type == bfd_link_hash_defweak)
4907         {
4908           asection *sec;
4909
4910           sec = h->root.u.def.section;
4911           ldsym->l_value = (sec->output_section->vma
4912                             + sec->output_offset
4913                             + h->root.u.def.value);
4914           ldsym->l_scnum = sec->output_section->target_index;
4915           ldsym->l_smtype = XTY_SD;
4916           impbfd = sec->owner;
4917         }
4918       else
4919         abort ();
4920
4921       if (((h->flags & XCOFF_DEF_REGULAR) == 0
4922            && (h->flags & XCOFF_DEF_DYNAMIC) != 0)
4923           || (h->flags & XCOFF_IMPORT) != 0)
4924         ldsym->l_smtype |= L_IMPORT;
4925       if (((h->flags & XCOFF_DEF_REGULAR) != 0
4926            && (h->flags & XCOFF_DEF_DYNAMIC) != 0)
4927           || (h->flags & XCOFF_EXPORT) != 0)
4928         ldsym->l_smtype |= L_EXPORT;
4929       if ((h->flags & XCOFF_ENTRY) != 0)
4930         ldsym->l_smtype |= L_ENTRY;
4931
4932       ldsym->l_smclas = h->smclas;
4933
4934       if (ldsym->l_ifile == (bfd_size_type) -1)
4935         ldsym->l_ifile = 0;
4936       else if (ldsym->l_ifile == 0)
4937         {
4938           if ((ldsym->l_smtype & L_IMPORT) == 0)
4939             ldsym->l_ifile = 0;
4940           else if (impbfd == NULL)
4941             ldsym->l_ifile = 0;
4942           else
4943             {
4944               BFD_ASSERT (impbfd->xvec == output_bfd->xvec);
4945               ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
4946             }
4947         }
4948
4949       ldsym->l_parm = 0;
4950
4951       BFD_ASSERT (h->ldindx >= 0);
4952       BFD_ASSERT (LDSYMSZ == sizeof (struct external_ldsym));
4953       xcoff_swap_ldsym_out (output_bfd, ldsym, finfo->ldsym + h->ldindx - 3);
4954       h->ldsym = NULL;
4955     }
4956
4957   /* If this symbol needs global linkage code, write it out.  */
4958   if (h->root.type == bfd_link_hash_defined
4959       && (h->root.u.def.section
4960           == xcoff_hash_table (finfo->info)->linkage_section))
4961     {
4962       bfd_byte *p;
4963       bfd_vma tocoff;
4964       unsigned int i;
4965
4966       p = h->root.u.def.section->contents + h->root.u.def.value;
4967
4968       /* The first instruction in the global linkage code loads a
4969          specific TOC element.  */
4970       tocoff = (h->descriptor->toc_section->output_section->vma
4971                 + h->descriptor->toc_section->output_offset
4972                 - xcoff_data (output_bfd)->toc);
4973       if ((h->descriptor->flags & XCOFF_SET_TOC) != 0)
4974         tocoff += h->descriptor->u.toc_offset;
4975       bfd_put_32 (output_bfd, XCOFF_GLINK_FIRST | (tocoff & 0xffff), p);
4976       for (i = 0, p += 4;
4977            i < sizeof xcoff_glink_code / sizeof xcoff_glink_code[0];
4978            i++, p += 4)
4979         bfd_put_32 (output_bfd, xcoff_glink_code[i], p);
4980     }
4981
4982   /* If we created a TOC entry for this symbol, write out the required
4983      relocs.  */
4984   if ((h->flags & XCOFF_SET_TOC) != 0)
4985     {
4986       asection *tocsec;
4987       asection *osec;
4988       int oindx;
4989       struct internal_reloc *irel;
4990       struct internal_ldrel ldrel;
4991
4992       tocsec = h->toc_section;
4993       osec = tocsec->output_section;
4994       oindx = osec->target_index;
4995       irel = finfo->section_info[oindx].relocs + osec->reloc_count;
4996       irel->r_vaddr = (osec->vma
4997                        + tocsec->output_offset
4998                        + h->u.toc_offset);
4999       if (h->indx >= 0)
5000         irel->r_symndx = h->indx;
5001       else
5002         {
5003           h->indx = -2;
5004           irel->r_symndx = obj_raw_syment_count (output_bfd);
5005         }
5006       irel->r_type = R_POS;
5007       irel->r_size = 31;
5008       finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
5009       ++osec->reloc_count;
5010
5011       BFD_ASSERT (h->ldindx >= 0);
5012       ldrel.l_vaddr = irel->r_vaddr;
5013       ldrel.l_symndx = h->ldindx;
5014       ldrel.l_rtype = (31 << 8) | R_POS;
5015       ldrel.l_rsecnm = oindx;
5016       xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5017       ++finfo->ldrel;
5018     }
5019
5020   /* If this symbol is a specially defined function descriptor, write
5021      it out.  The first word is the address of the function code
5022      itself, the second word is the address of the TOC, and the third
5023      word is zero.  */
5024   if ((h->flags & XCOFF_DESCRIPTOR) != 0
5025       && h->root.type == bfd_link_hash_defined
5026       && (h->root.u.def.section
5027           == xcoff_hash_table (finfo->info)->descriptor_section))
5028     {
5029       asection *sec;
5030       asection *osec;
5031       int oindx;
5032       bfd_byte *p;
5033       struct xcoff_link_hash_entry *hentry;
5034       asection *esec;
5035       struct internal_reloc *irel;
5036       struct internal_ldrel ldrel;
5037       asection *tsec;
5038
5039       sec = h->root.u.def.section;
5040       osec = sec->output_section;
5041       oindx = osec->target_index;
5042       p = sec->contents + h->root.u.def.value;
5043
5044       hentry = h->descriptor;
5045       BFD_ASSERT (hentry != NULL
5046                   && (hentry->root.type == bfd_link_hash_defined
5047                       || hentry->root.type == bfd_link_hash_defweak));
5048       esec = hentry->root.u.def.section;
5049       bfd_put_32 (output_bfd,
5050                   (esec->output_section->vma
5051                    + esec->output_offset
5052                    + hentry->root.u.def.value),
5053                   p);
5054
5055       irel = finfo->section_info[oindx].relocs + osec->reloc_count;
5056       irel->r_vaddr = (osec->vma
5057                        + sec->output_offset
5058                        + h->root.u.def.value);
5059       irel->r_symndx = esec->output_section->target_index;
5060       irel->r_type = R_POS;
5061       irel->r_size = 31;
5062       finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
5063       ++osec->reloc_count;
5064
5065       ldrel.l_vaddr = irel->r_vaddr;
5066       if (strcmp (esec->output_section->name, ".text") == 0)
5067         ldrel.l_symndx = 0;
5068       else if (strcmp (esec->output_section->name, ".data") == 0)
5069         ldrel.l_symndx = 1;
5070       else if (strcmp (esec->output_section->name, ".bss") == 0)
5071         ldrel.l_symndx = 2;
5072       else
5073         {
5074           (*_bfd_error_handler)
5075             ("%s: loader reloc in unrecognized section `%s'",
5076              bfd_get_filename (output_bfd),
5077              esec->output_section->name);
5078           bfd_set_error (bfd_error_nonrepresentable_section);
5079           return false;
5080         }
5081       ldrel.l_rtype = (31 << 8) | R_POS;
5082       ldrel.l_rsecnm = oindx;
5083       xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5084       ++finfo->ldrel;
5085
5086       bfd_put_32 (output_bfd, xcoff_data (output_bfd)->toc, p + 4);
5087
5088       tsec = coff_section_from_bfd_index (output_bfd,
5089                                           xcoff_data (output_bfd)->sntoc);
5090
5091       ++irel;
5092       irel->r_vaddr = (osec->vma
5093                        + sec->output_offset
5094                        + h->root.u.def.value
5095                        + 4);
5096       irel->r_symndx = tsec->output_section->target_index;
5097       irel->r_type = R_POS;
5098       irel->r_size = 31;
5099       finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
5100       ++osec->reloc_count;
5101
5102       ldrel.l_vaddr = irel->r_vaddr;
5103       if (strcmp (tsec->output_section->name, ".text") == 0)
5104         ldrel.l_symndx = 0;
5105       else if (strcmp (tsec->output_section->name, ".data") == 0)
5106         ldrel.l_symndx = 1;
5107       else if (strcmp (tsec->output_section->name, ".bss") == 0)
5108         ldrel.l_symndx = 2;
5109       else
5110         {
5111           (*_bfd_error_handler)
5112             ("%s: loader reloc in unrecognized section `%s'",
5113              bfd_get_filename (output_bfd),
5114              tsec->output_section->name);
5115           bfd_set_error (bfd_error_nonrepresentable_section);
5116           return false;
5117         }
5118       ldrel.l_rtype = (31 << 8) | R_POS;
5119       ldrel.l_rsecnm = oindx;
5120       xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5121       ++finfo->ldrel;
5122     }
5123
5124   if (h->indx >= 0)
5125     return true;
5126
5127   if (h->indx != -2
5128       && (finfo->info->strip == strip_all
5129           || (finfo->info->strip == strip_some
5130               && (bfd_hash_lookup (finfo->info->keep_hash,
5131                                    h->root.root.string, false, false)
5132                   == NULL))))
5133     return true;
5134
5135   if (h->indx != -2
5136       && (h->flags & (XCOFF_REF_REGULAR | XCOFF_DEF_REGULAR)) == 0)
5137     return true;
5138
5139   outsym = finfo->outsyms;
5140
5141   memset (&aux, 0, sizeof aux);
5142
5143   h->indx = obj_raw_syment_count (output_bfd);
5144
5145   if (strlen (h->root.root.string) <= SYMNMLEN)
5146     strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
5147   else
5148     {
5149       boolean hash;
5150       bfd_size_type indx;
5151
5152       hash = true;
5153       if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
5154         hash = false;
5155       indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
5156                                  false);
5157       if (indx == (bfd_size_type) -1)
5158         return false;
5159       isym._n._n_n._n_zeroes = 0;
5160       isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
5161     }
5162
5163   if (h->root.type == bfd_link_hash_undefined
5164       || h->root.type == bfd_link_hash_undefweak)
5165     {
5166       isym.n_value = 0;
5167       isym.n_scnum = N_UNDEF;
5168       isym.n_sclass = C_EXT;
5169       aux.x_csect.x_smtyp = XTY_ER;
5170     }
5171   else if (h->root.type == bfd_link_hash_defined
5172            || h->root.type == bfd_link_hash_defweak)
5173     {
5174       struct xcoff_link_size_list *l;
5175
5176       isym.n_value = (h->root.u.def.section->output_section->vma
5177                       + h->root.u.def.section->output_offset
5178                       + h->root.u.def.value);
5179       isym.n_scnum = h->root.u.def.section->output_section->target_index;
5180       isym.n_sclass = C_HIDEXT;
5181       aux.x_csect.x_smtyp = XTY_SD;
5182
5183       if ((h->flags & XCOFF_HAS_SIZE) != 0)
5184         {
5185           for (l = xcoff_hash_table (finfo->info)->size_list;
5186                l != NULL;
5187                l = l->next)
5188             {
5189               if (l->h == h)
5190                 {
5191                   aux.x_csect.x_scnlen.l = l->size;
5192                   break;
5193                 }
5194             }
5195         }
5196     }
5197   else if (h->root.type == bfd_link_hash_common)
5198     {
5199       isym.n_value = (h->root.u.c.p->section->output_section->vma
5200                       + h->root.u.c.p->section->output_offset);
5201       isym.n_scnum = h->root.u.c.p->section->output_section->target_index;
5202       isym.n_sclass = C_EXT;
5203       aux.x_csect.x_smtyp = XTY_CM;
5204       aux.x_csect.x_scnlen.l = h->root.u.c.size;
5205     }
5206   else
5207     abort ();
5208
5209   isym.n_type = T_NULL;
5210   isym.n_numaux = 1;
5211
5212   bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
5213   outsym += bfd_coff_symesz (output_bfd);
5214
5215   aux.x_csect.x_smclas = h->smclas;
5216
5217   bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, isym.n_sclass, 0, 1,
5218                          (PTR) outsym);
5219   outsym += bfd_coff_auxesz (output_bfd);
5220
5221   if (h->root.type == bfd_link_hash_defined
5222       || h->root.type == bfd_link_hash_defweak)
5223     {
5224       /* We just output an SD symbol.  Now output an LD symbol.  */
5225
5226       h->indx += 2;
5227
5228       isym.n_sclass = C_EXT;
5229       bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
5230       outsym += bfd_coff_symesz (output_bfd);
5231
5232       aux.x_csect.x_smtyp = XTY_LD;
5233       aux.x_csect.x_scnlen.l = obj_raw_syment_count (output_bfd);
5234
5235       bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, C_EXT, 0, 1,
5236                              (PTR) outsym);
5237       outsym += bfd_coff_auxesz (output_bfd);
5238     }
5239
5240   if (bfd_seek (output_bfd,
5241                 (obj_sym_filepos (output_bfd)
5242                  + (obj_raw_syment_count (output_bfd)
5243                     * bfd_coff_symesz (output_bfd))),
5244                 SEEK_SET) != 0
5245       || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1, output_bfd)
5246           != (bfd_size_type) (outsym - finfo->outsyms)))
5247     return false;
5248   obj_raw_syment_count (output_bfd) +=
5249     (outsym - finfo->outsyms) / bfd_coff_symesz (output_bfd);
5250
5251   return true;
5252 }
5253
5254 /* Handle a link order which is supposed to generate a reloc.  */
5255
5256 static boolean
5257 xcoff_reloc_link_order (output_bfd, finfo, output_section, link_order)
5258      bfd *output_bfd;
5259      struct xcoff_final_link_info *finfo;
5260      asection *output_section;
5261      struct bfd_link_order *link_order;
5262 {
5263   reloc_howto_type *howto;
5264   struct xcoff_link_hash_entry *h;
5265   asection *hsec;
5266   bfd_vma hval;
5267   bfd_vma addend;
5268   struct internal_reloc *irel;
5269   struct xcoff_link_hash_entry **rel_hash_ptr;
5270   struct internal_ldrel ldrel;
5271
5272   if (link_order->type == bfd_section_reloc_link_order)
5273     {
5274       /* We need to somehow locate a symbol in the right section.  The
5275          symbol must either have a value of zero, or we must adjust
5276          the addend by the value of the symbol.  FIXME: Write this
5277          when we need it.  The old linker couldn't handle this anyhow.  */
5278       abort ();
5279     }
5280
5281   howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
5282   if (howto == NULL)
5283     {
5284       bfd_set_error (bfd_error_bad_value);
5285       return false;
5286     }
5287
5288   h = ((struct xcoff_link_hash_entry *)
5289        bfd_wrapped_link_hash_lookup (output_bfd, finfo->info,
5290                                      link_order->u.reloc.p->u.name,
5291                                      false, false, true));
5292   if (h == NULL)
5293     {
5294       if (! ((*finfo->info->callbacks->unattached_reloc)
5295              (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
5296               (asection *) NULL, (bfd_vma) 0)))
5297         return false;
5298       return true;
5299     }
5300
5301   if (h->root.type == bfd_link_hash_common)
5302     {
5303       hsec = h->root.u.c.p->section;
5304       hval = 0;
5305     }
5306   else if (h->root.type == bfd_link_hash_defined
5307            || h->root.type == bfd_link_hash_defweak)
5308     {
5309       hsec = h->root.u.def.section;
5310       hval = h->root.u.def.value;
5311     }
5312   else
5313     {
5314       hsec = NULL;
5315       hval = 0;
5316     }
5317
5318   addend = link_order->u.reloc.p->addend;
5319   if (hsec != NULL)
5320     addend += (hsec->output_section->vma
5321                + hsec->output_offset
5322                + hval);
5323
5324   if (addend != 0)
5325     {
5326       bfd_size_type size;
5327       bfd_byte *buf;
5328       bfd_reloc_status_type rstat;
5329       boolean ok;
5330
5331       size = bfd_get_reloc_size (howto);
5332       buf = (bfd_byte *) bfd_zmalloc (size);
5333       if (buf == NULL)
5334         return false;
5335
5336       rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
5337       switch (rstat)
5338         {
5339         case bfd_reloc_ok:
5340           break;
5341         default:
5342         case bfd_reloc_outofrange:
5343           abort ();
5344         case bfd_reloc_overflow:
5345           if (! ((*finfo->info->callbacks->reloc_overflow)
5346                  (finfo->info, link_order->u.reloc.p->u.name,
5347                   howto->name, addend, (bfd *) NULL, (asection *) NULL,
5348                   (bfd_vma) 0)))
5349             {
5350               free (buf);
5351               return false;
5352             }
5353           break;
5354         }
5355       ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
5356                                      (file_ptr) link_order->offset, size);
5357       free (buf);
5358       if (! ok)
5359         return false;
5360     }
5361
5362   /* Store the reloc information in the right place.  It will get
5363      swapped and written out at the end of the final_link routine.  */
5364
5365   irel = (finfo->section_info[output_section->target_index].relocs
5366           + output_section->reloc_count);
5367   rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
5368                   + output_section->reloc_count);
5369
5370   memset (irel, 0, sizeof (struct internal_reloc));
5371   *rel_hash_ptr = NULL;
5372
5373   irel->r_vaddr = output_section->vma + link_order->offset;
5374
5375   if (h->indx >= 0)
5376     irel->r_symndx = h->indx;
5377   else
5378     {
5379       /* Set the index to -2 to force this symbol to get written out.  */
5380       h->indx = -2;
5381       *rel_hash_ptr = h;
5382       irel->r_symndx = 0;
5383     }
5384
5385   irel->r_type = howto->type;
5386   irel->r_size = howto->bitsize - 1;
5387   if (howto->complain_on_overflow == complain_overflow_signed)
5388     irel->r_size |= 0x80;
5389
5390   ++output_section->reloc_count;
5391
5392   /* Now output the reloc to the .loader section.  */
5393
5394   ldrel.l_vaddr = irel->r_vaddr;
5395
5396   if (hsec != NULL)
5397     {
5398       const char *secname;
5399
5400       secname = hsec->output_section->name;
5401
5402       if (strcmp (secname, ".text") == 0)
5403         ldrel.l_symndx = 0;
5404       else if (strcmp (secname, ".data") == 0)
5405         ldrel.l_symndx = 1;
5406       else if (strcmp (secname, ".bss") == 0)
5407         ldrel.l_symndx = 2;
5408       else
5409         {
5410           (*_bfd_error_handler)
5411             ("%s: loader reloc in unrecognized section `%s'",
5412              bfd_get_filename (output_bfd), secname);
5413           bfd_set_error (bfd_error_nonrepresentable_section);
5414           return false;
5415         }
5416     }
5417   else
5418     {
5419       if (h->ldindx < 0)
5420         {
5421           (*_bfd_error_handler)
5422             ("%s: `%s' in loader reloc but not loader sym",
5423              bfd_get_filename (output_bfd),
5424              h->root.root.string);
5425           bfd_set_error (bfd_error_bad_value);
5426           return false;
5427         }
5428       ldrel.l_symndx = h->ldindx;
5429     }
5430
5431   ldrel.l_rtype = (irel->r_size << 8) | irel->r_type;
5432   ldrel.l_rsecnm = output_section->target_index;
5433   xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5434   ++finfo->ldrel;
5435
5436   return true;
5437 }
5438
5439 /* Sort relocs by VMA.  This is called via qsort.  */
5440
5441 static int
5442 xcoff_sort_relocs (p1, p2)
5443      const PTR p1;
5444      const PTR p2;
5445 {
5446   const struct internal_reloc *r1 = (const struct internal_reloc *) p1;
5447   const struct internal_reloc *r2 = (const struct internal_reloc *) p2;
5448
5449   if (r1->r_vaddr > r2->r_vaddr)
5450     return 1;
5451   else if (r1->r_vaddr < r2->r_vaddr)
5452     return -1;
5453   else
5454     return 0;
5455 }
5456
5457 /* This is the relocation function for the RS/6000/POWER/PowerPC.
5458    This is currently the only processor which uses XCOFF; I hope that
5459    will never change.  */
5460
5461 boolean
5462 _bfd_ppc_xcoff_relocate_section (output_bfd, info, input_bfd,
5463                                  input_section, contents, relocs, syms,
5464                                  sections)
5465      bfd *output_bfd;
5466      struct bfd_link_info *info;
5467      bfd *input_bfd;
5468      asection *input_section;
5469      bfd_byte *contents;
5470      struct internal_reloc *relocs;
5471      struct internal_syment *syms;
5472      asection **sections;
5473 {
5474   struct internal_reloc *rel;
5475   struct internal_reloc *relend;
5476
5477   rel = relocs;
5478   relend = rel + input_section->reloc_count;
5479   for (; rel < relend; rel++)
5480     {
5481       long symndx;
5482       struct xcoff_link_hash_entry *h;
5483       struct internal_syment *sym;
5484       bfd_vma addend;
5485       bfd_vma val;
5486       struct reloc_howto_struct howto;
5487       bfd_reloc_status_type rstat;
5488
5489       /* Relocation type R_REF is a special relocation type which is
5490          merely used to prevent garbage collection from occurring for
5491          the csect including the symbol which it references.  */
5492       if (rel->r_type == R_REF)
5493         continue;
5494
5495       symndx = rel->r_symndx;
5496
5497       if (symndx == -1)
5498         {
5499           h = NULL;
5500           sym = NULL;
5501           addend = 0;
5502         }
5503       else
5504         {    
5505           h = obj_xcoff_sym_hashes (input_bfd)[symndx];
5506           sym = syms + symndx;
5507           addend = - sym->n_value;
5508         }
5509
5510       /* We build the howto information on the fly.  */
5511
5512       howto.type = rel->r_type;
5513       howto.rightshift = 0;
5514       howto.size = 2;
5515       howto.bitsize = (rel->r_size & 0x1f) + 1;
5516       howto.pc_relative = false;
5517       howto.bitpos = 0;
5518       if ((rel->r_size & 0x80) != 0)
5519         howto.complain_on_overflow = complain_overflow_signed;
5520       else
5521         howto.complain_on_overflow = complain_overflow_bitfield;
5522       howto.special_function = NULL;
5523       howto.name = "internal";
5524       howto.partial_inplace = true;
5525       if (howto.bitsize == 32)
5526         howto.src_mask = howto.dst_mask = 0xffffffff;
5527       else
5528         {
5529           howto.src_mask = howto.dst_mask = (1 << howto.bitsize) - 1;
5530           if (howto.bitsize == 16)
5531             howto.size = 1;
5532         }
5533       howto.pcrel_offset = false;
5534
5535       val = 0;
5536
5537       if (h == NULL)
5538         {
5539           asection *sec;
5540
5541           if (symndx == -1)
5542             {
5543               sec = bfd_abs_section_ptr;
5544               val = 0;
5545             }
5546           else
5547             {
5548               sec = sections[symndx];
5549               /* Hack to make sure we use the right TOC anchor value
5550                  if this reloc is against the TOC anchor.  */
5551               if (sec->name[3] == '0'
5552                   && strcmp (sec->name, ".tc0") == 0)
5553                 val = xcoff_data (output_bfd)->toc;
5554               else
5555                 val = (sec->output_section->vma
5556                        + sec->output_offset
5557                        + sym->n_value
5558                        - sec->vma);
5559             }
5560         }
5561       else
5562         {
5563           if (h->root.type == bfd_link_hash_defined
5564               || h->root.type == bfd_link_hash_defweak)
5565             {
5566               asection *sec;
5567
5568               sec = h->root.u.def.section;
5569               val = (h->root.u.def.value
5570                      + sec->output_section->vma
5571                      + sec->output_offset);
5572             }
5573           else if (h->root.type == bfd_link_hash_common)
5574             {
5575               asection *sec;
5576
5577               sec = h->root.u.c.p->section;
5578               val = (sec->output_section->vma
5579                      + sec->output_offset);
5580             }
5581           else if ((h->flags & XCOFF_DEF_DYNAMIC) != 0
5582                    || (h->flags & XCOFF_IMPORT) != 0)
5583             {
5584               /* Every symbol in a shared object is defined somewhere.  */
5585               val = 0;
5586             }
5587           else if (! info->relocateable
5588                    && ! info->shared)
5589             {
5590               if (! ((*info->callbacks->undefined_symbol)
5591                      (info, h->root.root.string, input_bfd, input_section,
5592                       rel->r_vaddr - input_section->vma)))
5593                 return false;
5594             }
5595         }
5596
5597       /* I took the relocation type definitions from two documents:
5598          the PowerPC AIX Version 4 Application Binary Interface, First
5599          Edition (April 1992), and the PowerOpen ABI, Big-Endian
5600          32-Bit Hardware Implementation (June 30, 1994).  Differences
5601          between the documents are noted below.  */
5602
5603       switch (rel->r_type)
5604         {
5605         case R_RTB:
5606         case R_RRTBI:
5607         case R_RRTBA:
5608           /* These relocs are defined by the PowerPC ABI to be
5609              relative branches which use half of the difference
5610              between the symbol and the program counter.  I can't
5611              quite figure out when this is useful.  These relocs are
5612              not defined by the PowerOpen ABI.  */
5613         default:
5614           (*_bfd_error_handler)
5615             ("%s: unsupported relocation type 0x%02x",
5616              bfd_get_filename (input_bfd), (unsigned int) rel->r_type);
5617           bfd_set_error (bfd_error_bad_value);
5618           return false;
5619         case R_POS:
5620           /* Simple positive relocation.  */
5621           break;
5622         case R_NEG:
5623           /* Simple negative relocation.  */
5624           val = - val;
5625           break;
5626         case R_REL:
5627           /* Simple PC relative relocation.  */
5628           howto.pc_relative = true;
5629           break;
5630         case R_TOC:
5631           /* TOC relative relocation.  The value in the instruction in
5632              the input file is the offset from the input file TOC to
5633              the desired location.  We want the offset from the final
5634              TOC to the desired location.  We have:
5635                  isym = iTOC + in
5636                  iinsn = in + o
5637                  osym = oTOC + on
5638                  oinsn = on + o
5639              so we must change insn by on - in.
5640              */
5641         case R_GL:
5642           /* Global linkage relocation.  The value of this relocation
5643              is the address of the entry in the TOC section.  */
5644         case R_TCL:
5645           /* Local object TOC address.  I can't figure out the
5646              difference between this and case R_GL.  */
5647         case R_TRL:
5648           /* TOC relative relocation.  A TOC relative load instruction
5649              which may be changed to a load address instruction.
5650              FIXME: We don't currently implement this optimization.  */
5651         case R_TRLA:
5652           /* TOC relative relocation.  This is a TOC relative load
5653              address instruction which may be changed to a load
5654              instruction.  FIXME: I don't know if this is the correct
5655              implementation.  */
5656           if (h != NULL && h->toc_section == NULL)
5657             {
5658               (*_bfd_error_handler)
5659                 ("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry",
5660                  bfd_get_filename (input_bfd), rel->r_vaddr,
5661                  h->root.root.string);
5662               bfd_set_error (bfd_error_bad_value);
5663               return false;
5664             }
5665           if (h != NULL)
5666             {
5667               BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
5668               val = (h->toc_section->output_section->vma
5669                      + h->toc_section->output_offset);
5670             }
5671           val = ((val - xcoff_data (output_bfd)->toc)
5672                  - (sym->n_value - xcoff_data (input_bfd)->toc));
5673           addend = 0;
5674           break;
5675         case R_BA:
5676           /* Absolute branch.  We don't want to mess with the lower
5677              two bits of the instruction.  */
5678         case R_CAI:
5679           /* The PowerPC ABI defines this as an absolute call which
5680              may be modified to become a relative call.  The PowerOpen
5681              ABI does not define this relocation type.  */
5682         case R_RBA:
5683           /* Absolute branch which may be modified to become a
5684              relative branch.  */
5685         case R_RBAC:
5686           /* The PowerPC ABI defines this as an absolute branch to a
5687              fixed address which may be modified to an absolute branch
5688              to a symbol.  The PowerOpen ABI does not define this
5689              relocation type.  */
5690         case R_RBRC:
5691           /* The PowerPC ABI defines this as an absolute branch to a
5692              fixed address which may be modified to a relative branch.
5693              The PowerOpen ABI does not define this relocation type.  */
5694           howto.src_mask &= ~3;
5695           howto.dst_mask = howto.src_mask;
5696           break;
5697         case R_BR:
5698           /* Relative branch.  We don't want to mess with the lower
5699              two bits of the instruction.  */
5700         case R_CREL:
5701           /* The PowerPC ABI defines this as a relative call which may
5702              be modified to become an absolute call.  The PowerOpen
5703              ABI does not define this relocation type.  */
5704         case R_RBR:
5705           /* A relative branch which may be modified to become an
5706              absolute branch.  FIXME: We don't implement this,
5707              although we should for symbols of storage mapping class
5708              XMC_XO.  */
5709           howto.pc_relative = true;
5710           howto.src_mask &= ~3;
5711           howto.dst_mask = howto.src_mask;
5712           break;
5713         case R_RL:
5714           /* The PowerPC AIX ABI describes this as a load which may be
5715              changed to a load address.  The PowerOpen ABI says this
5716              is the same as case R_POS.  */
5717           break;
5718         case R_RLA:
5719           /* The PowerPC AIX ABI describes this as a load address
5720              which may be changed to a load.  The PowerOpen ABI says
5721              this is the same as R_POS.  */
5722           break;
5723         }
5724
5725       /* If we see an R_BR or R_RBR reloc which is jumping to global
5726          linkage code, and it is followed by an appropriate cror nop
5727          instruction, we replace the cror with lwz r2,20(r1).  This
5728          restores the TOC after the glink code.  Contrariwise, if the
5729          call is followed by a lwz r2,20(r1), but the call is not
5730          going to global linkage code, we can replace the load with a
5731          cror.  */
5732       if ((rel->r_type == R_BR || rel->r_type == R_RBR)
5733           && h != NULL
5734           && h->root.type == bfd_link_hash_defined
5735           && (rel->r_vaddr - input_section->vma + 8
5736               <= input_section->_cooked_size))
5737         {
5738           bfd_byte *pnext;
5739           unsigned long next;
5740
5741           pnext = contents + (rel->r_vaddr - input_section->vma) + 4;
5742           next = bfd_get_32 (input_bfd, pnext);
5743           if (h->smclas == XMC_GL)
5744             {
5745               if (next == 0x4def7b82            /* cror 15,15,15 */
5746                   || next == 0x4ffffb82)        /* cror 31,31,31 */
5747                 bfd_put_32 (input_bfd, 0x80410014, pnext); /* lwz r1,20(r1) */
5748             }
5749           else
5750             {
5751               if (next == 0x80410014)           /* lwz r1,20(r1) */
5752                 bfd_put_32 (input_bfd, 0x4ffffb82, pnext); /* cror 31,31,31 */
5753             }
5754         }
5755
5756       /* A PC relative reloc includes the section address.  */
5757       if (howto.pc_relative)
5758         addend += input_section->vma;
5759
5760       rstat = _bfd_final_link_relocate (&howto, input_bfd, input_section,
5761                                         contents,
5762                                         rel->r_vaddr - input_section->vma,
5763                                         val, addend);
5764
5765       switch (rstat)
5766         {
5767         default:
5768           abort ();
5769         case bfd_reloc_ok:
5770           break;
5771         case bfd_reloc_overflow:
5772           {
5773             const char *name;
5774             char buf[SYMNMLEN + 1];
5775             char howto_name[10];
5776
5777             if (symndx == -1)
5778               name = "*ABS*";
5779             else if (h != NULL)
5780               name = h->root.root.string;
5781             else
5782               {
5783                 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
5784                 if (name == NULL)
5785                   return false;
5786               }
5787             sprintf (howto_name, "0x%02x", rel->r_type);
5788
5789             if (! ((*info->callbacks->reloc_overflow)
5790                    (info, name, howto_name, (bfd_vma) 0, input_bfd,
5791                     input_section, rel->r_vaddr - input_section->vma)))
5792               return false;
5793           }
5794         }
5795     }
5796
5797   return true;
5798 }