projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
update from Andrew
[deliverable/binutils-gdb.git] / bfd / xcofflink.c
CommitLineData
aadf04f7 1/* POWER/PowerPC XCOFF linker support.
6014cea7 2 Copyright 1995, 1996 Free Software Foundation, Inc.
aadf04f7
SS		 3 Written by Ian Lance Taylor <ian@cygnus.com>, Cygnus Support.
4
5This file is part of BFD, the Binary File Descriptor library.
6
7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, 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
867d923d 28/* This file holds the XCOFF linker code. */
aadf04f7
SS		 29
30#define STRING_SIZE_SIZE (4)
31
b2193cc5
ILT		 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
aadf04f7
SS		 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
28a0c103
ILT		 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
78static 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
101struct 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
123struct 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
140struct 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
169struct 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
203struct 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
215struct 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
227struct 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
aadf04f7
SS		 239/* An entry in the XCOFF linker hash table. */
240
241struct xcoff_link_hash_entry
242{
243 struct bfd_link_hash_entry root;
244
aadf04f7
SS		 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
28a0c103
ILT		 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
230de6b8
ILT		 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;
28a0c103
ILT		 262
263 /* If this symbol is a function entry point which is called, this
ee174815
ILT		 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. */
28a0c103
ILT		 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)
0634a431
ILT		 281 /* Symbol is defined by a dynamic object. */
282#define XCOFF_DEF_DYNAMIC (04)
28a0c103
ILT		 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)
2d7de17d
ILT		 299 /* Symbol size is recorded in size_list list from hash table. */
300#define XCOFF_HAS_SIZE (04000)
ee174815
ILT		 301 /* Symbol is a function descriptor. */
302#define XCOFF_DESCRIPTOR (010000)
28a0c103
ILT		 303
304 /* The storage mapping class. */
305 unsigned char smclas;
aadf04f7
SS		 306};
307
308/* The XCOFF linker hash table. */
309
310struct 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;
28a0c103
ILT		 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
ee174815
ILT		 339 /* The .ds section we use to hold function descriptors which we
340 create for exported symbols. */
341 asection *descriptor_section;
342
28a0c103
ILT		 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;
2d7de17d
ILT		 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;
ee174815
ILT		 362
363 /* Magic sections: _text, _etext, _data, _edata, _end, end. */
364 asection *special_sections[6];
aadf04f7
SS		 365};
366
28a0c103
ILT		 367/* Information we keep for each section in the output file during the
368 final link phase. */
aadf04f7
SS		 369
370struct 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;
2d7de17d
ILT		 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;
aadf04f7
SS		 387};
388
389/* Information that we pass around while doing the final link step. */
390
391struct 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;
28a0c103
ILT		 408 /* Start of .loader symbols. */
409 struct external_ldsym *ldsym;
410 /* Next .loader reloc to swap out. */
411 struct external_ldrel *ldrel;
f630a0a4
ILT		 412 /* File position of start of line numbers. */
413 file_ptr line_filepos;
aadf04f7
SS		 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
0634a431
ILT		 430static void xcoff_swap_ldhdr_in
431 PARAMS ((bfd *, const struct external_ldhdr *, struct internal_ldhdr *));
28a0c103
ILT		 432static void xcoff_swap_ldhdr_out
433 PARAMS ((bfd *, const struct internal_ldhdr *, struct external_ldhdr *));
0634a431
ILT		 434static void xcoff_swap_ldsym_in
435 PARAMS ((bfd *, const struct external_ldsym *, struct internal_ldsym *));
28a0c103
ILT		 436static void xcoff_swap_ldsym_out
437 PARAMS ((bfd *, const struct internal_ldsym *, struct external_ldsym *));
438static void xcoff_swap_ldrel_out
439 PARAMS ((bfd *, const struct internal_ldrel *, struct external_ldrel *));
aadf04f7
SS		 440static struct bfd_hash_entry *xcoff_link_hash_newfunc
441 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
28a0c103
ILT		 442static struct internal_reloc *xcoff_read_internal_relocs
443 PARAMS ((bfd *, asection *, boolean, bfd_byte *, boolean,
444 struct internal_reloc *));
aadf04f7
SS		 445static boolean xcoff_link_add_object_symbols
446 PARAMS ((bfd *, struct bfd_link_info *));
447static boolean xcoff_link_check_archive_element
448 PARAMS ((bfd *, struct bfd_link_info *, boolean *));
449static boolean xcoff_link_check_ar_symbols
450 PARAMS ((bfd *, struct bfd_link_info *, boolean *));
f630a0a4
ILT		 451static bfd_size_type xcoff_find_reloc
452 PARAMS ((struct internal_reloc *, bfd_size_type, bfd_vma));
aadf04f7 453static boolean xcoff_link_add_symbols PARAMS ((bfd *, struct bfd_link_info *));
28a0c103
ILT		 454static boolean xcoff_link_add_dynamic_symbols
455 PARAMS ((bfd *, struct bfd_link_info *));
456static boolean xcoff_mark PARAMS ((struct bfd_link_info *, asection *));
457static void xcoff_sweep PARAMS ((struct bfd_link_info *));
458static boolean xcoff_build_ldsyms
459 PARAMS ((struct xcoff_link_hash_entry *, PTR));
aadf04f7
SS		 460static boolean xcoff_link_input_bfd
461 PARAMS ((struct xcoff_final_link_info *, bfd *));
462static boolean xcoff_write_global_symbol
463 PARAMS ((struct xcoff_link_hash_entry *, PTR));
464static boolean xcoff_reloc_link_order
465 PARAMS ((bfd *, struct xcoff_final_link_info *, asection *,
466 struct bfd_link_order *));
467static int xcoff_sort_relocs PARAMS ((const PTR, const PTR));
28a0c103 468\f
0634a431
ILT		 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
476static void
477xcoff_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}
28a0c103
ILT		 491
492/* Swap out the ldhdr structure. */
493
494static void
495xcoff_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
0634a431
ILT		 510/* Swap in the ldsym structure. */
511
512static void
513xcoff_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
28a0c103
ILT		 533/* Swap out the ldsym structure. */
534
535static void
536xcoff_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}
aadf04f7 555
0634a431
ILT		 556/* As it happens, we never need to swap in the ldrel structure. */
557
28a0c103
ILT		 558/* Swap out the ldrel structure. */
559
560static void
561xcoff_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
aadf04f7
SS		 572/* Routine to create an entry in an XCOFF link hash table. */
573
574static struct bfd_hash_entry *
575xcoff_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)
a9713b91 588 return (struct bfd_hash_entry *) ret;
aadf04f7
SS		 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. */
aadf04f7 597 ret->indx = -1;
28a0c103 598 ret->toc_section = NULL;
230de6b8 599 ret->u.toc_indx = -1;
28a0c103
ILT		 600 ret->descriptor = NULL;
601 ret->ldsym = NULL;
602 ret->ldindx = -1;
603 ret->flags = 0;
604 ret->smclas = XMC_UA;
aadf04f7
SS		 605 }
606
607 return (struct bfd_hash_entry *) ret;
608}
609
610/* Create a XCOFF link hash table. */
611
612struct 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)
a9713b91 621 return (struct bfd_link_hash_table *) NULL;
aadf04f7
SS		 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;
28a0c103
ILT		 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;
ee174815 635 ret->descriptor_section = NULL;
28a0c103
ILT		 636 ret->imports = NULL;
637 ret->file_align = 0;
638 ret->textro = false;
639 ret->gc = false;
ee174815 640 memset (ret->special_sections, 0, sizeof ret->special_sections);
aadf04f7 641
73246ff8
ILT		 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
aadf04f7
SS		 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))
28a0c103
ILT		 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
674static struct internal_reloc *
675xcoff_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)
aad2c618
ILT		 695 && cache
696 && enclosing->reloc_count > 0)
28a0c103
ILT		 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 }
aadf04f7 704
28a0c103
ILT		 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
aadf04f7
SS		 726/* Given an XCOFF BFD, add symbols to the global hash table as
727 appropriate. */
728
729boolean
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
749static boolean
750xcoff_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
771static boolean
772xcoff_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
801static boolean
802xcoff_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
28a0c103
ILT		 839 defines it. We also don't bring in symbols to satisfy
840 undefined references in shared objects. */
aadf04f7
SS		 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
f630a0a4
ILT		 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
861static bfd_size_type
862xcoff_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)
7812bf9c
ILT		 870 {
871 if (count == 1 && relocs[0].r_vaddr < address)
872 return 1;
873 else
874 return 0;
875 }
f630a0a4
ILT		 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
aadf04f7
SS		 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
926static boolean
927xcoff_link_add_symbols (abfd, info)
928 bfd *abfd;
929 struct bfd_link_info *info;
930{
28a0c103
ILT		 931 unsigned int n_tmask;
932 unsigned int n_btshft;
aadf04f7
SS		 933 boolean default_copy;
934 bfd_size_type symcount;
935 struct xcoff_link_hash_entry **sym_hash;
936 asection **csect_cache;
28a0c103 937 bfd_size_type linesz;
583db7a8
ILT		 938 asection *o;
939 asection *last_real;
28a0c103 940 boolean keep_syms;
aadf04f7
SS		 941 asection *csect;
942 unsigned int csect_index;
943 asection *first_csect;
aadf04f7
SS		 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;
28a0c103
ILT		 950 asection **csects;
951 bfd_byte *linenos;
aadf04f7
SS		 952 } *reloc_info = NULL;
953
28a0c103
ILT		 954 if ((abfd->flags & DYNAMIC) != 0
955 && ! info->static_link)
c9746fb6
ILT		 956 {
957 if (! xcoff_link_add_dynamic_symbols (abfd, info))
958 return false;
959 }
28a0c103
ILT		 960
961 /* We need to build a .loader section, so we do it here. This won't
c9746fb6
ILT		 962 work if we're producing an XCOFF output file with no XCOFF input
963 files. FIXME. */
28a0c103
ILT		 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;
ee174815 984 lsec->alignment_power = 2;
28a0c103
ILT		 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;
83c23fca 996 tsec->alignment_power = 2;
28a0c103 997 }
ee174815
ILT		 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 }
28a0c103
ILT		 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
c9746fb6
ILT		 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
aadf04f7
SS		 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)
a9713b91 1047 goto error_return;
aadf04f7
SS		 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)
a9713b91 1058 goto error_return;
aadf04f7
SS		 1059 xcoff_data (abfd)->csects = csect_cache;
1060 memset (csect_cache, 0, (size_t) symcount * sizeof (asection *));
1061
aadf04f7
SS		 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 *)
58142f10
ILT		 1068 bfd_malloc ((abfd->section_count + 1)
1069 * sizeof (struct reloc_info_struct)));
aadf04f7 1070 if (reloc_info == NULL)
58142f10 1071 goto error_return;
aadf04f7
SS		 1072 memset ((PTR) reloc_info, 0,
1073 (abfd->section_count + 1) * sizeof (struct reloc_info_struct));
1074
28a0c103
ILT		 1075 /* Read in the relocs and line numbers for each section. */
1076 linesz = bfd_coff_linesz (abfd);
583db7a8
ILT		 1077 last_real = NULL;
1078 for (o = abfd->sections; o != NULL; o = o->next)
aadf04f7 1079 {
583db7a8
ILT		 1080 last_real = o;
1081 if ((o->flags & SEC_RELOC) != 0)
aadf04f7 1082 {
583db7a8
ILT		 1083 reloc_info[o->target_index].relocs =
1084 xcoff_read_internal_relocs (abfd, o, true, (bfd_byte *) NULL,
28a0c103 1085 false, (struct internal_reloc *) NULL);
583db7a8 1086 reloc_info[o->target_index].csects =
58142f10 1087 (asection **) bfd_malloc (o->reloc_count * sizeof (asection *));
583db7a8 1088 if (reloc_info[o->target_index].csects == NULL)
58142f10 1089 goto error_return;
583db7a8
ILT		 1090 memset (reloc_info[o->target_index].csects, 0,
1091 o->reloc_count * sizeof (asection *));
28a0c103
ILT		 1092 }
1093
1094 if ((info->strip == strip_none || info->strip == strip_some)
583db7a8 1095 && o->lineno_count > 0)
28a0c103
ILT		 1096 {
1097 bfd_byte *linenos;
1098
58142f10 1099 linenos = (bfd_byte *) bfd_malloc (o->lineno_count * linesz);
28a0c103 1100 if (linenos == NULL)
58142f10 1101 goto error_return;
583db7a8
ILT		 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))
28a0c103 1106 goto error_return;
aadf04f7
SS		 1107 }
1108 }
1109
28a0c103
ILT		 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
aadf04f7
SS		 1114 csect = NULL;
1115 csect_index = 0;
1116 first_csect = NULL;
aadf04f7
SS		 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;
28a0c103 1126 const char *name;
aadf04f7
SS		 1127 char buf[SYMNMLEN + 1];
1128 int smtyp;
1129 flagword flags;
1130 asection *section;
1131 bfd_vma value;
28a0c103 1132 struct xcoff_link_hash_entry *set_toc;
aadf04f7
SS		 1133
1134 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
1135
aadf04f7
SS		 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 {
28a0c103
ILT		 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
aadf04f7
SS		 1149 if (csect != NULL)
1150 *csect_cache = csect;
28a0c103 1151 else if (first_csect == NULL || sym.n_sclass == C_FILE)
aadf04f7
SS		 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;
aadf04f7
SS		 1158 continue;
1159 }
1160
1161 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
1162 if (name == NULL)
1163 goto error_return;
1164
28a0c103
ILT		 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;
b73322d9
ILT		 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 }
28a0c103
ILT		 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;
f78195df
ILT		 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;
28a0c103
ILT		 1232 }
1233 }
1234 }
1235 }
1236
aadf04f7
SS		 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;
28a0c103 1259 set_toc = NULL;
aadf04f7
SS		 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 }
417acf22
ILT		 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 }
aadf04f7
SS		 1293 break;
1294
1295 case XTY_SD:
1296 /* This is a csect definition. */
1297
28a0c103
ILT		 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
aadf04f7
SS		 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
28a0c103
ILT		 1333 && aux.x_csect.x_scnlen.l == 4
1334 && info->hash->creator == abfd->xvec)
aadf04f7
SS		 1335 {
1336 asection *enclosing;
f630a0a4 1337 struct internal_reloc *relocs;
aadf04f7
SS		 1338 bfd_size_type relindx;
1339 struct internal_reloc *rel;
aadf04f7
SS		 1340
1341 enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
1342 if (enclosing == NULL)
28a0c103 1343 goto error_return;
aadf04f7 1344
f630a0a4
ILT		 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)
aadf04f7
SS		 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)
28a0c103 1372 goto error_return;
aadf04f7 1373
867d923d
ILT		 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)
aadf04f7 1380 {
867d923d
ILT		 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 {
f630a0a4
ILT		 1403 asection **rel_csects;
1404
867d923d
ILT		 1405 /* We already have a TOC entry for this
1406 symbol, so we can just ignore this
1407 one. */
f630a0a4
ILT		 1408 rel_csects =
1409 reloc_info[enclosing->target_index].csects;
1410 rel_csects[relindx] = bfd_und_section_ptr;
867d923d
ILT		 1411 break;
1412 }
aadf04f7 1413
867d923d
ILT		 1414 /* We are about to create a TOC entry for
1415 this symbol. */
1416 set_toc = h;
1417 }
aadf04f7
SS		 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;
aadf04f7
SS		 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;
697a8fe8
ILT		 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)))
aadf04f7
SS		 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
28a0c103
ILT		 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)
a9713b91 1478 goto error_return;
28a0c103
ILT		 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)
a9713b91 1482 goto error_return;
28a0c103 1483 xcoff_section_data (abfd, csect)->enclosing = enclosing;
b73322d9
ILT		 1484 xcoff_section_data (abfd, csect)->lineno_count =
1485 enclosing->lineno_count;
28a0c103 1486
697a8fe8 1487 if (enclosing->owner == abfd)
aadf04f7 1488 {
f630a0a4
ILT		 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));
697a8fe8
ILT		 1502 while (relindx < enclosing->reloc_count
1503 && *rel_csect == NULL
697a8fe8
ILT		 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;
aadf04f7 1512 }
aadf04f7
SS		 1513 }
1514
1515 /* There are a number of other fields and section flags
1516 which we do not bother to set. */
1517
aadf04f7
SS		 1518 csect_index = ((esym
1519 - (bfd_byte *) obj_coff_external_syms (abfd))
1520 / symesz);
1521
28a0c103
ILT		 1522 xcoff_section_data (abfd, csect)->first_symndx = csect_index;
1523
aadf04f7
SS		 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 }
28a0c103
ILT		 1534
1535 /* If this is a TOC section for a symbol, record it. */
1536 if (set_toc != NULL)
230de6b8 1537 set_toc->toc_section = csect;
aadf04f7
SS		 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;
28a0c103 1550 if (aux.x_csect.x_scnlen.l < 0
aadf04f7
SS		 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. */
28a0c103
ILT		 1578
1579 if (csect != NULL)
aadf04f7 1580 {
28a0c103
ILT		 1581 xcoff_section_data (abfd, csect)->last_symndx =
1582 ((esym
1583 - (bfd_byte *) obj_coff_external_syms (abfd))
1584 / symesz);
aadf04f7 1585 }
28a0c103
ILT		 1586
1587 csect = bfd_make_section_anyway (abfd, ".bss");
1588 if (csect == NULL)
1589 goto error_return;
867d923d 1590 csect->vma = sym.n_value;
28a0c103
ILT		 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)
a9713b91 1605 goto error_return;
28a0c103
ILT		 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)
a9713b91 1609 goto error_return;
28a0c103
ILT		 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;
aad2c618 1618 csect->_raw_size = 0;
28a0c103
ILT		 1619 section = csect;
1620 value = aux.x_csect.x_scnlen.l;
aadf04f7 1621 }
28a0c103 1622
aadf04f7
SS		 1623 break;
1624 }
1625
ee174815
ILT		 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
aadf04f7
SS		 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
28a0c103
ILT		 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. */
c3dffbd7
ILT		 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));
28a0c103
ILT		 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
583db7a8
ILT		 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;
aadf04f7
SS		 1716 if (! (_bfd_generic_link_add_one_symbol
1717 (info, abfd, name, flags, section, value,
aad2c618 1718 (const char *) NULL, copy, true,
aadf04f7
SS		 1719 (struct bfd_link_hash_entry **) sym_hash)))
1720 goto error_return;
583db7a8 1721 last_real->next = first_csect;
aadf04f7 1722
867d923d
ILT		 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
aadf04f7 1738 if (info->hash->creator == abfd->xvec)
28a0c103
ILT		 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
2d7de17d
ILT		 1748 if ((*sym_hash)->smclas == XMC_UA
1749 || flag == XCOFF_DEF_REGULAR)
28a0c103
ILT		 1750 (*sym_hash)->smclas = aux.x_csect.x_smclas;
1751 }
aadf04f7
SS		 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;
aadf04f7
SS		 1759 }
1760
583db7a8
ILT		 1761 BFD_ASSERT (last_real == NULL || last_real->next == first_csect);
1762
28a0c103 1763 /* Make sure that we have seen all the relocs. */
583db7a8 1764 for (o = abfd->sections; o != first_csect; o = o->next)
aadf04f7 1765 {
583db7a8
ILT		 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)
aadf04f7
SS		 1775 {
1776 bfd_size_type i;
28a0c103
ILT		 1777 struct internal_reloc *rel;
1778 asection **rel_csect;
aadf04f7 1779
583db7a8
ILT		 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++)
aadf04f7 1783 {
28a0c103 1784 if (*rel_csect == NULL)
aadf04f7
SS		 1785 {
1786 (*_bfd_error_handler)
1787 ("%s: reloc %s:%d not in csect",
583db7a8 1788 bfd_get_filename (abfd), o->name, i);
aadf04f7
SS		 1789 bfd_set_error (bfd_error_bad_value);
1790 goto error_return;
1791 }
28a0c103 1792
867d923d
ILT		 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. */
28a0c103 1796 if (info->hash->creator == abfd->xvec
867d923d
ILT		 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)
28a0c103
ILT		 1801 {
1802 struct xcoff_link_hash_entry *h;
1803
867d923d
ILT		 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)
28a0c103 1817 {
867d923d
ILT		 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)
28a0c103 1826 {
867d923d
ILT		 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,
aad2c618 1831 true,
0634a431 1832 (struct bfd_link_hash_entry **) &hds)))
867d923d 1833 goto error_return;
28a0c103 1834 }
ee174815
ILT		 1835 hds->flags |= XCOFF_DESCRIPTOR;
1836 BFD_ASSERT ((hds->flags & XCOFF_CALLED) == 0
1837 && (h->flags & XCOFF_DESCRIPTOR) == 0);
1838 hds->descriptor = h;
867d923d 1839 h->descriptor = hds;
28a0c103
ILT		 1840 }
1841 }
aadf04f7
SS		 1842 }
1843
583db7a8
ILT		 1844 free (reloc_info[o->target_index].csects);
1845 reloc_info[o->target_index].csects = NULL;
aadf04f7 1846
583db7a8
ILT		 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;
aadf04f7
SS		 1851
1852 /* If we are not keeping memory, free the reloc information. */
1853 if (! info->keep_memory
583db7a8
ILT		 1854 && coff_section_data (abfd, o) != NULL
1855 && coff_section_data (abfd, o)->relocs != NULL
1856 && ! coff_section_data (abfd, o)->keep_relocs)
aadf04f7 1857 {
583db7a8
ILT		 1858 free (coff_section_data (abfd, o)->relocs);
1859 coff_section_data (abfd, o)->relocs = NULL;
aadf04f7
SS		 1860 }
1861 }
28a0c103
ILT		 1862
1863 /* Free up the line numbers. FIXME: We could cache these
1864 somewhere for the final link, to avoid reading them again. */
583db7a8 1865 if (reloc_info[o->target_index].linenos != NULL)
28a0c103 1866 {
583db7a8
ILT		 1867 free (reloc_info[o->target_index].linenos);
1868 reloc_info[o->target_index].linenos = NULL;
28a0c103 1869 }
aadf04f7
SS		 1870 }
1871
1872 free (reloc_info);
1873
28a0c103
ILT		 1874 obj_coff_keep_syms (abfd) = keep_syms;
1875
1876 return true;
1877
1878 error_return:
1879 if (reloc_info != NULL)
1880 {
583db7a8 1881 for (o = abfd->sections; o != NULL; o = o->next)
28a0c103 1882 {
583db7a8
ILT		 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);
28a0c103
ILT		 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
1900static boolean
1901xcoff_link_add_dynamic_symbols (abfd, info)
1902 bfd *abfd;
1903 struct bfd_link_info *info;
1904{
0634a431
ILT		 1905 asection *lsec;
1906 bfd_byte *buf = NULL;
1907 struct internal_ldhdr ldhdr;
1908 const char *strings;
1909 struct external_ldsym *elsym, *elsymend;
28a0c103
ILT		 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);
0634a431 1925 goto error_return;
28a0c103
ILT		 1926 }
1927
0634a431
ILT		 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
58142f10 1949 buf = (bfd_byte *) bfd_malloc (lsec->_raw_size);
0634a431 1950 if (buf == NULL && lsec->_raw_size > 0)
58142f10 1951 goto error_return;
0634a431
ILT		 1952
1953 if (! bfd_get_section_contents (abfd, lsec, (PTR) buf, (file_ptr) 0,
1954 lsec->_raw_size))
1955 goto error_return;
1956
28a0c103
ILT		 1957 /* Remove the sections from this object, so that they do not get
1958 included in the link. */
1959 abfd->sections = NULL;
1960
0634a431
ILT		 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++)
28a0c103 1969 {
0634a431
ILT		 1970 struct internal_ldsym ldsym;
1971 char nambuf[SYMNMLEN + 1];
1972 const char *name;
1973 struct xcoff_link_hash_entry *h;
28a0c103 1974
0634a431 1975 xcoff_swap_ldsym_in (abfd, elsym, &ldsym);
28a0c103 1976
0634a431
ILT		 1977 /* We are only interested in exported symbols. */
1978 if ((ldsym.l_smtype & L_EXPORT) == 0)
1979 continue;
28a0c103 1980
0634a431
ILT		 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 }
28a0c103 1989
c3dffbd7 1990 /* Normally we could not call xcoff_link_hash_lookup in an add
417acf22
ILT		 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))
0634a431 2031 {
417acf22
ILT		 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;
28a0c103 2036 }
0634a431 2037 }
28a0c103 2038
0634a431
ILT		 2039 if (buf != NULL)
2040 {
2041 free (buf);
2042 buf = NULL;
28a0c103
ILT		 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)
a9713b91 2050 goto error_return;
28a0c103
ILT		 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;
0634a431
ILT		 2084
2085 error_return:
2086 if (buf != NULL)
2087 free (buf);
2088 return false;
28a0c103
ILT		 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
e6080520
ILT		 2094/* Mark a symbol as not being garbage, including the section in which
2095 it is defined. */
2096
2097static INLINE boolean
2098xcoff_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
2135static boolean
2136xcoff_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
e6080520
ILT		 2217 && (h->root.type == bfd_link_hash_undefined
2218 || h->root.type == bfd_link_hash_undefweak)
0634a431
ILT		 2219 && h->root.root.string[0] == '.'
2220 && h->descriptor != NULL
2221 && ((h->descriptor->flags & XCOFF_DEF_DYNAMIC) != 0
c3dffbd7
ILT		 2222 || info->shared
2223 || ((h->descriptor->flags & XCOFF_IMPORT) != 0
2224 && (h->descriptor->flags
2225 & XCOFF_DEF_REGULAR) == 0))))
e6080520
ILT		 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
2264static void
2265xcoff_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
ee174815 2286 || o == xcoff_hash_table (info)->descriptor_section
e6080520
ILT		 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
2d7de17d
ILT		 2300/* Record the number of elements in a set. This is used to output the
2301 correct csect length. */
2302
2303boolean
2304bfd_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
b2193cc5
ILT		 2313 if (! XCOFF_XVECP (output_bfd->xvec))
2314 return true;
2315
2d7de17d
ILT		 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)
a9713b91 2323 return false;
2d7de17d
ILT		 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
28a0c103
ILT		 2334/* Import a symbol. */
2335
2336boolean
2337bfd_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
b2193cc5
ILT		 2349 if (! XCOFF_XVECP (output_bfd->xvec))
2350 return true;
2351
28a0c103
ILT		 2352 h->flags |= XCOFF_IMPORT;
2353
2354 if (val != (bfd_vma) -1)
2355 {
417acf22
ILT		 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))
28a0c103
ILT		 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)
a9713b91 2377 return false;
28a0c103
ILT		 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)
a9713b91 2406 return false;
28a0c103
ILT		 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
2422boolean
2423bfd_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
b2193cc5
ILT		 2431 if (! XCOFF_XVECP (output_bfd->xvec))
2432 return true;
2433
28a0c103
ILT		 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
ee174815
ILT		 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
58142f10 2447 fnname = (char *) bfd_malloc (strlen (h->root.root.string) + 2);
ee174815 2448 if (fnname == NULL)
58142f10 2449 return false;
ee174815
ILT		 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
e6080520
ILT		 2466 /* Make sure we don't garbage collect this symbol. */
2467 if (! xcoff_mark_symbol (info, h))
2468 return false;
2469
ee174815
ILT		 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
28a0c103
ILT		 2481 return true;
2482}
2483
2d7de17d
ILT		 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
2488boolean
2489bfd_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
b2193cc5
ILT		 2496 if (! XCOFF_XVECP (output_bfd->xvec))
2497 return true;
2498
c3dffbd7
ILT		 2499 h = ((struct xcoff_link_hash_entry *)
2500 bfd_wrapped_link_hash_lookup (output_bfd, info, name, false, false,
2501 false));
2d7de17d
ILT		 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. */
e6080520
ILT		 2513 if (! xcoff_mark_symbol (info, h))
2514 return false;
2d7de17d
ILT		 2515
2516 return true;
2517}
2518
2519/* This function is called for each symbol to which the linker script
2520 assigns a value. */
2521
2522boolean
2523bfd_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
b2193cc5
ILT		 2530 if (! XCOFF_XVECP (output_bfd->xvec))
2531 return true;
2532
2d7de17d
ILT		 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
28a0c103
ILT		 2543/* This structure is used to pass information through
2544 xcoff_link_hash_traverse. */
2545
2546struct 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;
c9746fb6
ILT		 2554 /* Whether all defined symbols should be exported. */
2555 boolean export_defineds;
28a0c103
ILT		 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
c9746fb6
ILT		 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. */
28a0c103
ILT		 2582
2583boolean
2584bfd_xcoff_size_dynamic_sections (output_bfd, info, libpath, entry,
2585 file_align, maxstack, maxdata, gc,
c9746fb6
ILT		 2586 modtype, textro, export_defineds,
2587 special_sections)
28a0c103
ILT		 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;
c9746fb6 2598 boolean export_defineds;
ee174815 2599 asection **special_sections;
28a0c103
ILT		 2600{
2601 struct xcoff_link_hash_entry *hentry;
2602 asection *lsec;
2603 struct xcoff_loader_info ldinfo;
ee174815 2604 int i;
28a0c103
ILT		 2605 size_t impsize, impcount;
2606 struct xcoff_import_file *fl;
2607 struct internal_ldhdr *ldhdr;
9c234e29 2608 bfd_size_type stoff;
28a0c103
ILT		 2609 register char *out;
2610 asection *sec;
2611 bfd *sub;
2612 struct bfd_strtab_hash *debug_strtab;
2613 bfd_byte *debug_contents = NULL;
2614
b2193cc5 2615 if (! XCOFF_XVECP (output_bfd->xvec))
83dcdc61
ILT		 2616 {
2617 for (i = 0; i < 6; i++)
2618 special_sections[i] = NULL;
2619 return true;
2620 }
b2193cc5 2621
28a0c103
ILT		 2622 ldinfo.failed = false;
2623 ldinfo.output_bfd = output_bfd;
2624 ldinfo.info = info;
c9746fb6 2625 ldinfo.export_defineds = export_defineds;
28a0c103
ILT		 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)
c3dffbd7 2641 hentry->flags |= XCOFF_ENTRY;
28a0c103
ILT		 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))
f78195df
ILT		 2649 {
2650 gc = false;
2651 xcoff_hash_table (info)->gc = false;
867d923d
ILT		 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 }
f78195df 2668 }
28a0c103
ILT		 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
ee174815
ILT		 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
28a0c103
ILT		 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;
9c234e29
ILT		 2729 stoff = ldhdr->l_impoff + impsize;
2730 if (ldinfo.string_size == 0)
2731 ldhdr->l_stoff = 0;
2732 else
2733 ldhdr->l_stoff = stoff;
28a0c103
ILT		 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;
9c234e29 2738 lsec->_raw_size = stoff + ldhdr->l_stlen;
28a0c103
ILT		 2739 lsec->contents = (bfd_byte *) bfd_zalloc (output_bfd, lsec->_raw_size);
2740 if (lsec->contents == NULL)
a9713b91 2741 goto error_return;
28a0c103
ILT		 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
9c234e29 2768 BFD_ASSERT ((bfd_size_type) ((bfd_byte *) out - lsec->contents) == stoff);
28a0c103
ILT		 2769
2770 /* Set up the symbol string table. */
2771 if (ldinfo.string_size > 0)
aadf04f7 2772 {
28a0c103
ILT		 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
ee174815 2786 /* Allocate space for the magic sections. */
28a0c103
ILT		 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)
a9713b91 2792 goto error_return;
28a0c103
ILT		 2793 }
2794 sec = xcoff_hash_table (info)->toc_section;
ee174815
ILT		 2795 if (sec->_raw_size > 0)
2796 {
2797 sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
2798 if (sec->contents == NULL)
a9713b91 2799 goto error_return;
ee174815
ILT		 2800 }
2801 sec = xcoff_hash_table (info)->descriptor_section;
28a0c103
ILT		 2802 if (sec->_raw_size > 0)
2803 {
2804 sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
2805 if (sec->contents == NULL)
a9713b91 2806 goto error_return;
28a0c103
ILT		 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)
a9713b91 2843 goto error_return;
28a0c103
ILT		 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. */
58142f10 2851 debug_contents = (bfd_byte *) bfd_malloc (subdeb->_raw_size);
28a0c103 2852 if (debug_contents == NULL)
58142f10 2853 goto error_return;
28a0c103
ILT		 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
aadf04f7
SS		 2893 free (debug_contents);
2894 debug_contents = NULL;
28a0c103
ILT		 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 }
aadf04f7
SS		 2905 }
2906
28a0c103
ILT		 2907 xcoff_hash_table (info)->debug_section->_raw_size =
2908 _bfd_stringtab_size (debug_strtab);
2909
aadf04f7
SS		 2910 return true;
2911
2912 error_return:
28a0c103
ILT		 2913 if (ldinfo.strings != NULL)
2914 free (ldinfo.strings);
aadf04f7
SS		 2915 if (debug_contents != NULL)
2916 free (debug_contents);
28a0c103
ILT		 2917 return false;
2918}
2919
28a0c103
ILT		 2920/* Add a symbol to the .loader symbols, if necessary. */
2921
2922static boolean
2923xcoff_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
c9746fb6
ILT		 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
28a0c103
ILT		 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
0634a431 2946 /* If this symbol is called and defined in a dynamic object, or not
c3dffbd7
ILT		 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.) */
28a0c103 2950 if ((h->flags & XCOFF_CALLED) != 0
28a0c103
ILT		 2951 && (h->root.type == bfd_link_hash_undefined
2952 || h->root.type == bfd_link_hash_undefweak)
2953 && h->root.root.string[0] == '.'
0634a431
ILT		 2954 && h->descriptor != NULL
2955 && ((h->descriptor->flags & XCOFF_DEF_DYNAMIC) != 0
c3dffbd7
ILT		 2956 || ldinfo->info->shared
2957 || ((h->descriptor->flags & XCOFF_IMPORT) != 0
2958 && (h->descriptor->flags & XCOFF_DEF_REGULAR) == 0))
28a0c103
ILT		 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;
ee174815 2970 h->flags |= XCOFF_DEF_REGULAR;
28a0c103
ILT		 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)
0634a431 2978 && (hds->flags & XCOFF_DEF_REGULAR) == 0);
28a0c103
ILT		 2979 hds->flags |= XCOFF_MARK;
2980 if (hds->toc_section == NULL)
2981 {
2982 hds->toc_section = xcoff_hash_table (ldinfo->info)->toc_section;
230de6b8 2983 hds->u.toc_offset = hds->toc_section->_raw_size;
28a0c103
ILT		 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
ee174815
ILT		 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
aad2c618
ILT		 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
28a0c103
ILT		 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
e6080520
ILT		 3057 not defined or common, or if it is the entry point, or if it is
3058 being exported. */
28a0c103
ILT		 3059
3060 if (((h->flags & XCOFF_LDREL) == 0
3061 || h->root.type == bfd_link_hash_defined
867d923d
ILT		 3062 || h->root.type == bfd_link_hash_defweak
3063 || h->root.type == bfd_link_hash_common)
e6080520
ILT		 3064 && (h->flags & XCOFF_ENTRY) == 0
3065 && (h->flags & XCOFF_EXPORT) == 0)
28a0c103
ILT		 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;
28a0c103
ILT		 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
58142f10
ILT		 3123 newstrings = ((bfd_byte *)
3124 bfd_realloc ((PTR) ldinfo->strings, newalc));
28a0c103
ILT		 3125 if (newstrings == NULL)
3126 {
3127 ldinfo->failed = true;
28a0c103
ILT		 3128 return false;
3129 }
3130 ldinfo->string_alc = newalc;
3131 ldinfo->strings = newstrings;
aadf04f7 3132 }
28a0c103
ILT		 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;
aadf04f7 3140 }
28a0c103
ILT		 3141
3142 h->flags |= XCOFF_BUILT_LDSYM;
3143
3144 return true;
aadf04f7
SS		 3145}
3146\f
3147/* Do the final link step. */
3148
3149boolean
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
583db7a8
ILT		 3171 if (info->shared)
3172 abfd->flags |= DYNAMIC;
3173
aadf04f7
SS		 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
28a0c103
ILT		 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
aadf04f7
SS		 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
4a378b13
ILT		 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
7ec49f91
ILT		 3220 /* Mark all sections which are to be included in the
3221 link. This will normally be every section. We need
3222 to do this so that we can identify any sections which
3223 the linker has decided to not include. */
ff0e4a93 3224 sec->linker_mark = true;
7ec49f91 3225
4a378b13
ILT		 3226 if (info->strip == strip_none
3227 || info->strip == strip_some)
3228 o->lineno_count += sec->lineno_count;
3229
3230 o->reloc_count += sec->reloc_count;
3231
3232 if (sec->_raw_size > max_contents_size)
3233 max_contents_size = sec->_raw_size;
3234 if (sec->lineno_count > max_lineno_count)
3235 max_lineno_count = sec->lineno_count;
3236 if (coff_section_data (sec->owner, sec) != NULL
3237 && xcoff_section_data (sec->owner, sec) != NULL
3238 && (xcoff_section_data (sec->owner, sec)->lineno_count
3239 > max_lineno_count))
3240 max_lineno_count =
3241 xcoff_section_data (sec->owner, sec)->lineno_count;
3242 if (sec->reloc_count > max_reloc_count)
3243 max_reloc_count = sec->reloc_count;
3244 }
3245 else if (p->type == bfd_section_reloc_link_order
3246 || p->type == bfd_symbol_reloc_link_order)
3247 ++o->reloc_count;
3248 }
3249 }
3250
aadf04f7 3251 /* Compute the file positions for all the sections. */
28a0c103
ILT		 3252 if (abfd->output_has_begun)
3253 {
3254 if (xcoff_hash_table (info)->file_align != 0)
3255 abort ();
3256 }
3257 else
3258 {
3259 bfd_vma file_align;
3260
3261 file_align = xcoff_hash_table (info)->file_align;
3262 if (file_align != 0)
3263 {
3264 boolean saw_contents;
3265 int indx;
3266 asection **op;
3267 file_ptr sofar;
3268
3269 /* Insert .pad sections before every section which has
3270 contents and is loaded, if it is preceded by some other
3271 section which has contents and is loaded. */
3272 saw_contents = true;
3273 for (op = &abfd->sections; *op != NULL; op = &(*op)->next)
3274 {
3275 (*op)->target_index = indx;
3276 if (strcmp ((*op)->name, ".pad") == 0)
3277 saw_contents = false;
3278 else if (((*op)->flags & SEC_HAS_CONTENTS) != 0
3279 && ((*op)->flags & SEC_LOAD) != 0)
3280 {
3281 if (! saw_contents)
3282 saw_contents = true;
3283 else
3284 {
3285 asection *n, *hold;
3286
3287 hold = *op;
3288 *op = NULL;
3289 n = bfd_make_section_anyway (abfd, ".pad");
3290 BFD_ASSERT (*op == n);
3291 n->next = hold;
3292 n->flags = SEC_HAS_CONTENTS;
3293 n->alignment_power = 0;
3294 saw_contents = false;
3295 }
3296 }
3297 }
3298
3299 /* Reset the section indices after inserting the new
3300 sections. */
3301 indx = 0;
3302 for (o = abfd->sections; o != NULL; o = o->next)
3303 {
3304 ++indx;
3305 o->target_index = indx;
3306 }
3307 BFD_ASSERT ((unsigned int) indx == abfd->section_count);
3308
3309 /* Work out appropriate sizes for the .pad sections to force
3310 each section to land on a page boundary. This bit of
3311 code knows what compute_section_file_positions is going
3312 to do. */
3313 sofar = bfd_coff_filhsz (abfd);
867d923d 3314 sofar += bfd_coff_aoutsz (abfd);
28a0c103 3315 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
4a378b13
ILT		 3316 for (o = abfd->sections; o != NULL; o = o->next)
3317 if (o->reloc_count >= 0xffff || o->lineno_count >= 0xffff)
3318 sofar += bfd_coff_scnhsz (abfd);
28a0c103
ILT		 3319
3320 for (o = abfd->sections; o != NULL; o = o->next)
3321 {
3322 if (strcmp (o->name, ".pad") == 0)
3323 {
3324 bfd_vma pageoff;
3325
3326 BFD_ASSERT (o->_raw_size == 0);
3327 pageoff = sofar & (file_align - 1);
3328 if (pageoff != 0)
3329 {
3330 o->_raw_size = file_align - pageoff;
3331 sofar += file_align - pageoff;
3332 o->flags |= SEC_HAS_CONTENTS;
3333 }
3334 }
3335 else
3336 {
3337 if ((o->flags & SEC_HAS_CONTENTS) != 0)
3338 sofar += BFD_ALIGN (o->_raw_size,
3339 1 << o->alignment_power);
3340 }
3341 }
3342 }
3343
3344 bfd_coff_compute_section_file_positions (abfd);
3345 }
aadf04f7 3346
aadf04f7
SS		 3347 /* Allocate space for the pointers we need to keep for the relocs. */
3348 {
3349 unsigned int i;
3350
3351 /* We use section_count + 1, rather than section_count, because
3352 the target_index fields are 1 based. */
58142f10
ILT		 3353 finfo.section_info =
3354 ((struct xcoff_link_section_info *)
3355 bfd_malloc ((abfd->section_count + 1)
3356 * sizeof (struct xcoff_link_section_info)));
aadf04f7 3357 if (finfo.section_info == NULL)
58142f10 3358 goto error_return;
aadf04f7
SS		 3359 for (i = 0; i <= abfd->section_count; i++)
3360 {
3361 finfo.section_info[i].relocs = NULL;
3362 finfo.section_info[i].rel_hashes = NULL;
2d7de17d 3363 finfo.section_info[i].toc_rel_hashes = NULL;
aadf04f7
SS		 3364 }
3365 }
3366
4a378b13
ILT		 3367 /* Set the file positions for the relocs. */
3368 rel_filepos = obj_relocbase (abfd);
3369 relsz = bfd_coff_relsz (abfd);
aadf04f7
SS		 3370 max_output_reloc_count = 0;
3371 for (o = abfd->sections; o != NULL; o = o->next)
3372 {
4a378b13
ILT		 3373 if (o->reloc_count == 0)
3374 o->rel_filepos = 0;
aadf04f7
SS		 3375 else
3376 {
4a378b13
ILT		 3377 o->flags |= SEC_RELOC;
3378 o->rel_filepos = rel_filepos;
3379 rel_filepos += o->reloc_count * relsz;
aadf04f7 3380
aadf04f7
SS		 3381 /* We don't know the indices of global symbols until we have
3382 written out all the local symbols. For each section in
3383 the output file, we keep an array of pointers to hash
3384 table entries. Each entry in the array corresponds to a
3385 reloc. When we find a reloc against a global symbol, we
3386 set the corresponding entry in this array so that we can
3387 fix up the symbol index after we have written out all the
3388 local symbols.
3389
3390 Because of this problem, we also keep the relocs in
3391 memory until the end of the link. This wastes memory.
3392 We could backpatch the file later, I suppose, although it
3393 would be slow. */
3394 finfo.section_info[o->target_index].relocs =
3395 ((struct internal_reloc *)
58142f10 3396 bfd_malloc (o->reloc_count * sizeof (struct internal_reloc)));
aadf04f7
SS		 3397 finfo.section_info[o->target_index].rel_hashes =
3398 ((struct xcoff_link_hash_entry **)
58142f10 3399 bfd_malloc (o->reloc_count
aadf04f7
SS		 3400 * sizeof (struct xcoff_link_hash_entry *)));
3401 if (finfo.section_info[o->target_index].relocs == NULL
3402 || finfo.section_info[o->target_index].rel_hashes == NULL)
58142f10 3403 goto error_return;
aadf04f7
SS		 3404
3405 if (o->reloc_count > max_output_reloc_count)
3406 max_output_reloc_count = o->reloc_count;
3407 }
4a378b13
ILT		 3408 }
3409
3410 /* We now know the size of the relocs, so we can determine the file
3411 positions of the line numbers. */
3412 line_filepos = rel_filepos;
3413 finfo.line_filepos = line_filepos;
3414 linesz = bfd_coff_linesz (abfd);
3415 for (o = abfd->sections; o != NULL; o = o->next)
3416 {
3417 if (o->lineno_count == 0)
3418 o->line_filepos = 0;
3419 else
3420 {
3421 o->line_filepos = line_filepos;
3422 line_filepos += o->lineno_count * linesz;
3423 }
aadf04f7
SS		 3424
3425 /* Reset the reloc and lineno counts, so that we can use them to
3426 count the number of entries we have output so far. */
3427 o->reloc_count = 0;
3428 o->lineno_count = 0;
3429 }
3430
3431 obj_sym_filepos (abfd) = line_filepos;
3432
3433 /* Figure out the largest number of symbols in an input BFD. Take
3434 the opportunity to clear the output_has_begun fields of all the
3435 input BFD's. We want at least 4 symbols, since that is the
3436 number which xcoff_write_global_symbol may need. */
3437 max_sym_count = 4;
3438 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3439 {
3440 size_t sz;
3441
3442 sub->output_has_begun = false;
3443 sz = obj_raw_syment_count (sub);
3444 if (sz > max_sym_count)
3445 max_sym_count = sz;
3446 }
3447
3448 /* Allocate some buffers used while linking. */
3449 finfo.internal_syms = ((struct internal_syment *)
58142f10
ILT		 3450 bfd_malloc (max_sym_count
3451 * sizeof (struct internal_syment)));
3452 finfo.sym_indices = (long *) bfd_malloc (max_sym_count * sizeof (long));
aadf04f7 3453 finfo.outsyms = ((bfd_byte *)
58142f10
ILT		 3454 bfd_malloc ((size_t) ((max_sym_count + 1) * symesz)));
3455 finfo.linenos = (bfd_byte *) bfd_malloc (max_lineno_count
3456 * bfd_coff_linesz (abfd));
3457 finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
3458 finfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
aadf04f7
SS		 3459 if ((finfo.internal_syms == NULL && max_sym_count > 0)
3460 || (finfo.sym_indices == NULL && max_sym_count > 0)
3461 || finfo.outsyms == NULL
3462 || (finfo.linenos == NULL && max_lineno_count > 0)
3463 || (finfo.contents == NULL && max_contents_size > 0)
3464 || (finfo.external_relocs == NULL && max_reloc_count > 0))
58142f10 3465 goto error_return;
aadf04f7
SS		 3466
3467 obj_raw_syment_count (abfd) = 0;
3468 xcoff_data (abfd)->toc = (bfd_vma) -1;
3469
aadf04f7
SS		 3470 /* We now know the position of everything in the file, except that
3471 we don't know the size of the symbol table and therefore we don't
3472 know where the string table starts. We just build the string
3473 table in memory as we go along. We process all the relocations
3474 for a single input file at once. */
3475 for (o = abfd->sections; o != NULL; o = o->next)
3476 {
3477 for (p = o->link_order_head; p != NULL; p = p->next)
3478 {
3479 if (p->type == bfd_indirect_link_order
3480 && p->u.indirect.section->owner->xvec == abfd->xvec)
3481 {
3482 sub = p->u.indirect.section->owner;
3483 if (! sub->output_has_begun)
3484 {
3485 if (! xcoff_link_input_bfd (&finfo, sub))
3486 goto error_return;
3487 sub->output_has_begun = true;
3488 }
3489 }
3490 else if (p->type == bfd_section_reloc_link_order
3491 || p->type == bfd_symbol_reloc_link_order)
3492 {
3493 if (! xcoff_reloc_link_order (abfd, &finfo, o, p))
3494 goto error_return;
3495 }
3496 else
3497 {
3498 if (! _bfd_default_link_order (abfd, info, o, p))
3499 goto error_return;
3500 }
3501 }
3502 }
3503
3504 /* Free up the buffers used by xcoff_link_input_bfd. */
3505
3506 if (finfo.internal_syms != NULL)
3507 {
3508 free (finfo.internal_syms);
3509 finfo.internal_syms = NULL;
3510 }
3511 if (finfo.sym_indices != NULL)
3512 {
3513 free (finfo.sym_indices);
3514 finfo.sym_indices = NULL;
3515 }
3516 if (finfo.linenos != NULL)
3517 {
3518 free (finfo.linenos);
3519 finfo.linenos = NULL;
3520 }
3521 if (finfo.contents != NULL)
3522 {
3523 free (finfo.contents);
3524 finfo.contents = NULL;
3525 }
3526 if (finfo.external_relocs != NULL)
3527 {
3528 free (finfo.external_relocs);
3529 finfo.external_relocs = NULL;
3530 }
3531
3532 /* The value of the last C_FILE symbol is supposed to be -1. Write
3533 it out again. */
3534 if (finfo.last_file_index != -1)
3535 {
3536 finfo.last_file.n_value = -1;
3537 bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
3538 (PTR) finfo.outsyms);
3539 if (bfd_seek (abfd,
3540 (obj_sym_filepos (abfd)
3541 + finfo.last_file_index * symesz),
3542 SEEK_SET) != 0
3543 || bfd_write (finfo.outsyms, symesz, 1, abfd) != symesz)
3544 goto error_return;
3545 }
3546
28a0c103
ILT		 3547 /* Write out all the global symbols which do not come from XCOFF
3548 input files. */
3549 xcoff_link_hash_traverse (xcoff_hash_table (info),
3550 xcoff_write_global_symbol,
3551 (PTR) &finfo);
3552
aadf04f7
SS		 3553 if (finfo.outsyms != NULL)
3554 {
3555 free (finfo.outsyms);
3556 finfo.outsyms = NULL;
3557 }
3558
3559 /* Now that we have written out all the global symbols, we know the
3560 symbol indices to use for relocs against them, and we can finally
3561 write out the relocs. */
3562 external_relocs = (bfd_byte *) malloc (max_output_reloc_count * relsz);
3563 if (external_relocs == NULL && max_output_reloc_count != 0)
3564 {
3565 bfd_set_error (bfd_error_no_memory);
3566 goto error_return;
3567 }
3568
3569 for (o = abfd->sections; o != NULL; o = o->next)
3570 {
3571 struct internal_reloc *irel;
3572 struct internal_reloc *irelend;
3573 struct xcoff_link_hash_entry **rel_hash;
2d7de17d 3574 struct xcoff_toc_rel_hash *toc_rel_hash;
aadf04f7
SS		 3575 bfd_byte *erel;
3576
3577 if (o->reloc_count == 0)
3578 continue;
3579
aadf04f7
SS		 3580 irel = finfo.section_info[o->target_index].relocs;
3581 irelend = irel + o->reloc_count;
3582 rel_hash = finfo.section_info[o->target_index].rel_hashes;
aadf04f7
SS		 3583 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
3584 {
3585 if (*rel_hash != NULL)
3586 {
3587 if ((*rel_hash)->indx < 0)
3588 {
3589 if (! ((*info->callbacks->unattached_reloc)
28a0c103
ILT		 3590 (info, (*rel_hash)->root.root.string,
3591 (bfd *) NULL, o, irel->r_vaddr)))
aadf04f7
SS		 3592 goto error_return;
3593 (*rel_hash)->indx = 0;
3594 }
3595 irel->r_symndx = (*rel_hash)->indx;
3596 }
aadf04f7
SS		 3597 }
3598
2d7de17d
ILT		 3599 for (toc_rel_hash = finfo.section_info[o->target_index].toc_rel_hashes;
3600 toc_rel_hash != NULL;
3601 toc_rel_hash = toc_rel_hash->next)
3602 {
3603 if (toc_rel_hash->h->u.toc_indx < 0)
3604 {
3605 if (! ((*info->callbacks->unattached_reloc)
3606 (info, toc_rel_hash->h->root.root.string,
3607 (bfd *) NULL, o, toc_rel_hash->rel->r_vaddr)))
3608 goto error_return;
3609 toc_rel_hash->h->u.toc_indx = 0;
3610 }
3611 toc_rel_hash->rel->r_symndx = toc_rel_hash->h->u.toc_indx;
3612 }
3613
28a0c103
ILT		 3614 /* XCOFF requires that the relocs be sorted by address. We tend
3615 to produce them in the order in which their containing csects
3616 appear in the symbol table, which is not necessarily by
3617 address. So we sort them here. There may be a better way to
3618 do this. */
3619 qsort ((PTR) finfo.section_info[o->target_index].relocs,
3620 o->reloc_count, sizeof (struct internal_reloc),
3621 xcoff_sort_relocs);
3622
3623 irel = finfo.section_info[o->target_index].relocs;
3624 irelend = irel + o->reloc_count;
3625 erel = external_relocs;
3626 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
3627 bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
3628
aadf04f7
SS		 3629 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
3630 || bfd_write ((PTR) external_relocs, relsz, o->reloc_count,
3631 abfd) != relsz * o->reloc_count)
3632 goto error_return;
3633 }
3634
3635 if (external_relocs != NULL)
3636 {
3637 free (external_relocs);
3638 external_relocs = NULL;
3639 }
3640
3641 /* Free up the section information. */
3642 if (finfo.section_info != NULL)
3643 {
3644 unsigned int i;
3645
3646 for (i = 0; i < abfd->section_count; i++)
3647 {
3648 if (finfo.section_info[i].relocs != NULL)
3649 free (finfo.section_info[i].relocs);
3650 if (finfo.section_info[i].rel_hashes != NULL)
3651 free (finfo.section_info[i].rel_hashes);
3652 }
3653 free (finfo.section_info);
3654 finfo.section_info = NULL;
3655 }
3656
28a0c103
ILT		 3657 /* Write out the loader section contents. */
3658 BFD_ASSERT ((bfd_byte *) finfo.ldrel
3659 == (xcoff_hash_table (info)->loader_section->contents
3660 + xcoff_hash_table (info)->ldhdr.l_impoff));
3661 o = xcoff_hash_table (info)->loader_section;
3662 if (! bfd_set_section_contents (abfd, o->output_section,
3663 o->contents, o->output_offset,
3664 o->_raw_size))
3665 goto error_return;
3666
ee174815 3667 /* Write out the magic sections. */
28a0c103
ILT		 3668 o = xcoff_hash_table (info)->linkage_section;
3669 if (o->_raw_size > 0
3670 && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
3671 o->output_offset, o->_raw_size))
3672 goto error_return;
3673 o = xcoff_hash_table (info)->toc_section;
ee174815
ILT		 3674 if (o->_raw_size > 0
3675 && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
3676 o->output_offset, o->_raw_size))
3677 goto error_return;
3678 o = xcoff_hash_table (info)->descriptor_section;
28a0c103
ILT		 3679 if (o->_raw_size > 0
3680 && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
3681 o->output_offset, o->_raw_size))
3682 goto error_return;
3683
aadf04f7
SS		 3684 /* Write out the string table. */
3685 if (bfd_seek (abfd,
3686 (obj_sym_filepos (abfd)
3687 + obj_raw_syment_count (abfd) * symesz),
3688 SEEK_SET) != 0)
3689 goto error_return;
3690 bfd_h_put_32 (abfd,
3691 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
3692 (bfd_byte *) strbuf);
3693 if (bfd_write (strbuf, 1, STRING_SIZE_SIZE, abfd) != STRING_SIZE_SIZE)
3694 goto error_return;
3695 if (! _bfd_stringtab_emit (abfd, finfo.strtab))
3696 goto error_return;
3697
3698 _bfd_stringtab_free (finfo.strtab);
3699
3700 /* Write out the debugging string table. */
3701 o = xcoff_hash_table (info)->debug_section;
3702 if (o != NULL)
3703 {
3704 struct bfd_strtab_hash *debug_strtab;
3705
3706 debug_strtab = xcoff_hash_table (info)->debug_strtab;
3707 BFD_ASSERT (o->output_section->_raw_size - o->output_offset
3708 >= _bfd_stringtab_size (debug_strtab));
3709 if (bfd_seek (abfd,
3710 o->output_section->filepos + o->output_offset,
3711 SEEK_SET) != 0)
3712 goto error_return;
3713 if (! _bfd_stringtab_emit (abfd, debug_strtab))
3714 goto error_return;
3715 }
3716
3717 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
3718 not try to write out the symbols. */
3719 bfd_get_symcount (abfd) = 0;
3720
3721 return true;
3722
3723 error_return:
3724 if (finfo.strtab != NULL)
3725 _bfd_stringtab_free (finfo.strtab);
3726 if (finfo.section_info != NULL)
3727 {
3728 unsigned int i;
3729
3730 for (i = 0; i < abfd->section_count; i++)
3731 {
3732 if (finfo.section_info[i].relocs != NULL)
3733 free (finfo.section_info[i].relocs);
3734 if (finfo.section_info[i].rel_hashes != NULL)
3735 free (finfo.section_info[i].rel_hashes);
3736 }
3737 free (finfo.section_info);
3738 }
3739 if (finfo.internal_syms != NULL)
3740 free (finfo.internal_syms);
3741 if (finfo.sym_indices != NULL)
3742 free (finfo.sym_indices);
3743 if (finfo.outsyms != NULL)
3744 free (finfo.outsyms);
3745 if (finfo.linenos != NULL)
3746 free (finfo.linenos);
3747 if (finfo.contents != NULL)
3748 free (finfo.contents);
3749 if (finfo.external_relocs != NULL)
3750 free (finfo.external_relocs);
3751 if (external_relocs != NULL)
3752 free (external_relocs);
3753 return false;
3754}
3755
3756/* Link an input file into the linker output file. This function
3757 handles all the sections and relocations of the input file at once. */
3758
3759static boolean
3760xcoff_link_input_bfd (finfo, input_bfd)
3761 struct xcoff_final_link_info *finfo;
3762 bfd *input_bfd;
3763{
3764 bfd *output_bfd;
3765 const char *strings;
3766 bfd_size_type syment_base;
3767 unsigned int n_tmask;
3768 unsigned int n_btshft;
3769 boolean copy, hash;
3770 bfd_size_type isymesz;
3771 bfd_size_type osymesz;
3772 bfd_size_type linesz;
3773 bfd_byte *esym;
3774 bfd_byte *esym_end;
b73322d9 3775 struct xcoff_link_hash_entry **sym_hash;
aadf04f7
SS		 3776 struct internal_syment *isymp;
3777 asection **csectpp;
3778 unsigned long *debug_index;
3779 long *indexp;
3780 unsigned long output_index;
3781 bfd_byte *outsym;
f630a0a4 3782 unsigned int incls;
b73322d9 3783 asection *oline;
aadf04f7
SS		 3784 boolean keep_syms;
3785 asection *o;
3786
28a0c103
ILT		 3787 /* We can just skip DYNAMIC files, unless this is a static link. */
3788 if ((input_bfd->flags & DYNAMIC) != 0
3789 && ! finfo->info->static_link)
3790 return true;
3791
aadf04f7
SS		 3792 /* Move all the symbols to the output file. */
3793
3794 output_bfd = finfo->output_bfd;
3795 strings = NULL;
3796 syment_base = obj_raw_syment_count (output_bfd);
3797 isymesz = bfd_coff_symesz (input_bfd);
3798 osymesz = bfd_coff_symesz (output_bfd);
3799 linesz = bfd_coff_linesz (input_bfd);
3800 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
3801
3802 n_tmask = coff_data (input_bfd)->local_n_tmask;
3803 n_btshft = coff_data (input_bfd)->local_n_btshft;
3804
3805 /* Define macros so that ISFCN, et. al., macros work correctly. */
3806#define N_TMASK n_tmask
3807#define N_BTSHFT n_btshft
3808
3809 copy = false;
3810 if (! finfo->info->keep_memory)
3811 copy = true;
3812 hash = true;
3813 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
3814 hash = false;
3815
3816 if (! _bfd_coff_get_external_symbols (input_bfd))
3817 return false;
3818
3819 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
3820 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
3821 sym_hash = obj_xcoff_sym_hashes (input_bfd);
3822 csectpp = xcoff_data (input_bfd)->csects;
3823 debug_index = xcoff_data (input_bfd)->debug_indices;
3824 isymp = finfo->internal_syms;
3825 indexp = finfo->sym_indices;
3826 output_index = syment_base;
3827 outsym = finfo->outsyms;
f630a0a4 3828 incls = 0;
b73322d9 3829 oline = NULL;
aadf04f7
SS		 3830
3831 while (esym < esym_end)
3832 {
3833 struct internal_syment isym;
3834 union internal_auxent aux;
3835 int smtyp = 0;
3836 boolean skip;
3837 boolean require;
3838 int add;
3839
3840 bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
3841
3842 /* If this is a C_EXT or C_HIDEXT symbol, we need the csect
3843 information. */
3844 if (isymp->n_sclass == C_EXT || isymp->n_sclass == C_HIDEXT)
3845 {
3846 BFD_ASSERT (isymp->n_numaux > 0);
3847 bfd_coff_swap_aux_in (input_bfd,
3848 (PTR) (esym + isymesz * isymp->n_numaux),
3849 isymp->n_type, isymp->n_sclass,
3850 isymp->n_numaux - 1, isymp->n_numaux,
3851 (PTR) &aux);
3852 smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp);
3853 }
3854
3855 /* Make a copy of *isymp so that the relocate_section function
3856 always sees the original values. This is more reliable than
3857 always recomputing the symbol value even if we are stripping
3858 the symbol. */
3859 isym = *isymp;
3860
28a0c103
ILT		 3861 /* If this symbol is in the .loader section, swap out the
3862 .loader symbol information. If this is an external symbol
3863 reference to a defined symbol, though, then wait until we get
3864 to the definition. */
3865 if (isym.n_sclass == C_EXT
3866 && *sym_hash != NULL
3867 && (*sym_hash)->ldsym != NULL
3868 && (smtyp != XTY_ER
3869 || (*sym_hash)->root.type == bfd_link_hash_undefined))
3870 {
3871 struct xcoff_link_hash_entry *h;
3872 struct internal_ldsym *ldsym;
3873
3874 h = *sym_hash;
3875 ldsym = h->ldsym;
3876 if (isym.n_scnum > 0)
3877 {
3878 ldsym->l_scnum = (*csectpp)->output_section->target_index;
3879 ldsym->l_value = (isym.n_value
3880 + (*csectpp)->output_section->vma
3881 + (*csectpp)->output_offset
3882 - (*csectpp)->vma);
3883 }
3884 else
3885 {
3886 ldsym->l_scnum = isym.n_scnum;
3887 ldsym->l_value = isym.n_value;
3888 }
3889
3890 ldsym->l_smtype = smtyp;
3891 if (((h->flags & XCOFF_DEF_REGULAR) == 0
0634a431 3892 && (h->flags & XCOFF_DEF_DYNAMIC) != 0)
28a0c103
ILT		 3893 || (h->flags & XCOFF_IMPORT) != 0)
3894 ldsym->l_smtype |= L_IMPORT;
3895 if (((h->flags & XCOFF_DEF_REGULAR) != 0
0634a431 3896 && (h->flags & XCOFF_DEF_DYNAMIC) != 0)
28a0c103
ILT		 3897 || (h->flags & XCOFF_EXPORT) != 0)
3898 ldsym->l_smtype |= L_EXPORT;
3899 if ((h->flags & XCOFF_ENTRY) != 0)
3900 ldsym->l_smtype |= L_ENTRY;
3901
3902 ldsym->l_smclas = aux.x_csect.x_smclas;
3903
3904 if (ldsym->l_ifile == (bfd_size_type) -1)
3905 ldsym->l_ifile = 0;
3906 else if (ldsym->l_ifile == 0)
3907 {
3908 if ((ldsym->l_smtype & L_IMPORT) == 0)
3909 ldsym->l_ifile = 0;
3910 else
3911 {
3912 bfd *impbfd;
3913
3914 if (h->root.type == bfd_link_hash_defined
3915 || h->root.type == bfd_link_hash_defweak)
3916 impbfd = h->root.u.def.section->owner;
3917 else if (h->root.type == bfd_link_hash_undefined
3918 || h->root.type == bfd_link_hash_undefweak)
3919 impbfd = h->root.u.undef.abfd;
3920 else
3921 impbfd = NULL;
3922
3923 if (impbfd == NULL)
3924 ldsym->l_ifile = 0;
3925 else
3926 {
3927 BFD_ASSERT (impbfd->xvec == finfo->output_bfd->xvec);
3928 ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
3929 }
3930 }
3931 }
3932
3933 ldsym->l_parm = 0;
3934
3935 BFD_ASSERT (h->ldindx >= 0);
3936 BFD_ASSERT (LDSYMSZ == sizeof (struct external_ldsym));
3937 xcoff_swap_ldsym_out (finfo->output_bfd, ldsym,
3938 finfo->ldsym + h->ldindx - 3);
3939 h->ldsym = NULL;
c3dffbd7
ILT		 3940
3941 /* Fill in snentry now that we know the target_index. */
3942 if ((h->flags & XCOFF_ENTRY) != 0
3943 && (h->root.type == bfd_link_hash_defined
3944 || h->root.type == bfd_link_hash_defweak))
3945 xcoff_data (output_bfd)->snentry =
3946 h->root.u.def.section->output_section->target_index;
28a0c103
ILT		 3947 }
3948
aadf04f7
SS		 3949 *indexp = -1;
3950
3951 skip = false;
3952 require = false;
3953 add = 1 + isym.n_numaux;
3954
3955 /* If we are skipping this csect, we want to skip this symbol. */
3956 if (*csectpp == NULL)
3957 skip = true;
3958
28a0c103
ILT		 3959 /* If we garbage collected this csect, we want to skip this
3960 symbol. */
3961 if (! skip
3962 && xcoff_hash_table (finfo->info)->gc
3963 && ((*csectpp)->flags & SEC_MARK) == 0
3964 && *csectpp != bfd_abs_section_ptr)
3965 skip = true;
3966
aadf04f7
SS		 3967 /* An XCOFF linker always skips C_STAT symbols. */
3968 if (! skip
3969 && isymp->n_sclass == C_STAT)
3970 skip = true;
3971
3972 /* We skip all but the first TOC anchor. */
3973 if (! skip
3974 && isymp->n_sclass == C_HIDEXT
3975 && aux.x_csect.x_smclas == XMC_TC0)
3976 {
3977 if (finfo->toc_symindx != -1)
3978 skip = true;
3979 else
3980 {
b5403ad7
ILT		 3981 bfd_vma tocval, tocend;
3982
3983 tocval = ((*csectpp)->output_section->vma
3984 + (*csectpp)->output_offset
3985 + isym.n_value
3986 - (*csectpp)->vma);
3987 /* We want to find out if tocval is a good value to use
3988 as the TOC anchor--that is, whether we can access all
3989 of the TOC using a 16 bit offset from tocval. This
3990 test assumes that the TOC comes at the end of the
3991 output section, as it does in the default linker
3992 script. If the TOC anchor is too far into the .toc
3993 section, the relocation routine will report
3994 overflows. */
3995 tocend = ((*csectpp)->output_section->vma
3996 + (*csectpp)->output_section->_raw_size);
3997 if (tocval + 0x8000 < tocend)
3998 {
3999 bfd_vma tocadd;
4000
4001 tocadd = tocend - (tocval + 0x8000);
4002 tocval += tocadd;
4003 isym.n_value += tocadd;
4004 }
4005
aadf04f7 4006 finfo->toc_symindx = output_index;
b5403ad7 4007 xcoff_data (finfo->output_bfd)->toc = tocval;
c3dffbd7
ILT		 4008 xcoff_data (finfo->output_bfd)->sntoc =
4009 (*csectpp)->output_section->target_index;
aadf04f7
SS		 4010 require = true;
4011 }
4012 }
4013
4014 /* If we are stripping all symbols, we want to skip this one. */
4015 if (! skip
4016 && finfo->info->strip == strip_all)
4017 skip = true;
4018
4019 /* We can skip resolved external references. */
4020 if (! skip
4021 && isym.n_sclass == C_EXT
4022 && smtyp == XTY_ER
4023 && (*sym_hash)->root.type != bfd_link_hash_undefined)
4024 skip = true;
4025
28a0c103
ILT		 4026 /* We can skip common symbols if they got defined somewhere
4027 else. */
4028 if (! skip
4029 && isym.n_sclass == C_EXT
4030 && smtyp == XTY_CM
1d04caa1
ILT		 4031 && ((*sym_hash)->root.type != bfd_link_hash_common
4032 || (*sym_hash)->root.u.c.p->section != *csectpp)
4033 && ((*sym_hash)->root.type != bfd_link_hash_defined
4034 || (*sym_hash)->root.u.def.section != *csectpp))
28a0c103
ILT		 4035 skip = true;
4036
aadf04f7
SS		 4037 /* Skip local symbols if we are discarding them. */
4038 if (! skip
4039 && finfo->info->discard == discard_all
4040 && isym.n_sclass != C_EXT
4041 && (isym.n_sclass != C_HIDEXT
4042 || smtyp != XTY_SD))
4043 skip = true;
4044
4045 /* If we stripping debugging symbols, and this is a debugging
4046 symbol, then skip it. */
4047 if (! skip
4048 && finfo->info->strip == strip_debugger
4049 && isym.n_scnum == N_DEBUG)
4050 skip = true;
4051
4052 /* If some symbols are stripped based on the name, work out the
4053 name and decide whether to skip this symbol. We don't handle
4054 this correctly for symbols whose names are in the .debug
4055 section; to get it right we would need a new bfd_strtab_hash
4056 function to return the string given the index. */
4057 if (! skip
4058 && (finfo->info->strip == strip_some
4059 || finfo->info->discard == discard_l)
4060 && (debug_index == NULL || *debug_index == (unsigned long) -1))
4061 {
4062 const char *name;
4063 char buf[SYMNMLEN + 1];
4064
4065 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
4066 if (name == NULL)
4067 return false;
4068
4069 if ((finfo->info->strip == strip_some
4070 && (bfd_hash_lookup (finfo->info->keep_hash, name, false,
4071 false) == NULL))
4072 || (finfo->info->discard == discard_l
4073 && (isym.n_sclass != C_EXT
4074 && (isym.n_sclass != C_HIDEXT
4075 || smtyp != XTY_SD))
4076 && strncmp (name, finfo->info->lprefix,
4077 finfo->info->lprefix_len) == 0))
4078 skip = true;
4079 }
4080
aadf04f7
SS		 4081 /* We can not skip the first TOC anchor. */
4082 if (skip
4083 && require
4084 && finfo->info->strip != strip_all)
4085 skip = false;
4086
4087 /* We now know whether we are to skip this symbol or not. */
4088 if (! skip)
4089 {
4090 /* Adjust the symbol in order to output it. */
4091
4092 if (isym._n._n_n._n_zeroes == 0
4093 && isym._n._n_n._n_offset != 0)
4094 {
4095 /* This symbol has a long name. Enter it in the string
4096 table we are building. If *debug_index != -1, the
4097 name has already been entered in the .debug section. */
4098 if (debug_index != NULL && *debug_index != (unsigned long) -1)
4099 isym._n._n_n._n_offset = *debug_index;
4100 else
4101 {
4102 const char *name;
4103 bfd_size_type indx;
4104
4105 name = _bfd_coff_internal_syment_name (input_bfd, &isym,
4106 (char *) NULL);
4107 if (name == NULL)
4108 return false;
4109 indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
4110 if (indx == (bfd_size_type) -1)
4111 return false;
4112 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
4113 }
4114 }
4115
867d923d
ILT		 4116 if (isym.n_sclass != C_BSTAT
4117 && isym.n_sclass != C_ESTAT
f630a0a4 4118 && isym.n_sclass != C_DECL
867d923d 4119 && isym.n_scnum > 0)
aadf04f7
SS		 4120 {
4121 isym.n_scnum = (*csectpp)->output_section->target_index;
4122 isym.n_value += ((*csectpp)->output_section->vma
4123 + (*csectpp)->output_offset
4124 - (*csectpp)->vma);
4125 }
4126
4127 /* The value of a C_FILE symbol is the symbol index of the
4128 next C_FILE symbol. The value of the last C_FILE symbol
4129 is -1. We try to get this right, below, just before we
4130 write the symbols out, but in the general case we may
4131 have to write the symbol out twice. */
4132 if (isym.n_sclass == C_FILE)
4133 {
4134 if (finfo->last_file_index != -1
4135 && finfo->last_file.n_value != (long) output_index)
4136 {
4137 /* We must correct the value of the last C_FILE entry. */
4138 finfo->last_file.n_value = output_index;
4139 if ((bfd_size_type) finfo->last_file_index >= syment_base)
4140 {
4141 /* The last C_FILE symbol is in this input file. */
4142 bfd_coff_swap_sym_out (output_bfd,
4143 (PTR) &finfo->last_file,
4144 (PTR) (finfo->outsyms
4145 + ((finfo->last_file_index
4146 - syment_base)
4147 * osymesz)));
4148 }
4149 else
4150 {
4151 /* We have already written out the last C_FILE
4152 symbol. We need to write it out again. We
4153 borrow *outsym temporarily. */
4154 bfd_coff_swap_sym_out (output_bfd,
4155 (PTR) &finfo->last_file,
4156 (PTR) outsym);
4157 if (bfd_seek (output_bfd,
4158 (obj_sym_filepos (output_bfd)
4159 + finfo->last_file_index * osymesz),
4160 SEEK_SET) != 0
4161 || (bfd_write (outsym, osymesz, 1, output_bfd)
4162 != osymesz))
4163 return false;
4164 }
4165 }
4166
4167 finfo->last_file_index = output_index;
4168 finfo->last_file = isym;
4169 }
4170
f630a0a4
ILT		 4171 /* The value of a C_BINCL or C_EINCL symbol is a file offset
4172 into the line numbers. We update the symbol values when
4173 we handle the line numbers. */
4174 if (isym.n_sclass == C_BINCL
4175 || isym.n_sclass == C_EINCL)
4176 {
4177 isym.n_value = finfo->line_filepos;
4178 ++incls;
4179 }
4180
aadf04f7
SS		 4181 /* Output the symbol. */
4182
4183 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
4184
4185 *indexp = output_index;
4186
4187 if (isym.n_sclass == C_EXT)
4188 {
4189 long indx;
4190 struct xcoff_link_hash_entry *h;
4191
4192 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
4193 / isymesz);
4194 h = obj_xcoff_sym_hashes (input_bfd)[indx];
4195 BFD_ASSERT (h != NULL);
4196 h->indx = output_index;
4197 }
4198
230de6b8
ILT		 4199 /* If this is a symbol in the TOC which we may have merged
4200 (class XMC_TC), remember the symbol index of the TOC
4201 symbol. */
4202 if (isym.n_sclass == C_HIDEXT
4203 && aux.x_csect.x_smclas == XMC_TC
4204 && *sym_hash != NULL)
4205 {
4206 BFD_ASSERT (((*sym_hash)->flags & XCOFF_SET_TOC) == 0);
4207 BFD_ASSERT ((*sym_hash)->toc_section != NULL);
4208 (*sym_hash)->u.toc_indx = output_index;
4209 }
4210
aadf04f7
SS		 4211 output_index += add;
4212 outsym += add * osymesz;
4213 }
4214
4215 esym += add * isymesz;
4216 isymp += add;
4217 csectpp += add;
4218 sym_hash += add;
4219 if (debug_index != NULL)
4220 debug_index += add;
4221 ++indexp;
4222 for (--add; add > 0; --add)
4223 *indexp++ = -1;
4224 }
4225
867d923d
ILT		 4226 /* Fix up the aux entries and the C_BSTAT symbols. This must be
4227 done in a separate pass, because we don't know the correct symbol
4228 indices until we have already decided which symbols we are going
4229 to keep. */
aadf04f7
SS		 4230
4231 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
4232 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
4233 isymp = finfo->internal_syms;
4234 indexp = finfo->sym_indices;
28a0c103 4235 csectpp = xcoff_data (input_bfd)->csects;
aadf04f7
SS		 4236 outsym = finfo->outsyms;
4237 while (esym < esym_end)
4238 {
4239 int add;
4240
4241 add = 1 + isymp->n_numaux;
4242
4243 if (*indexp < 0)
4244 esym += add * isymesz;
4245 else
4246 {
4247 int i;
4248
867d923d
ILT		 4249 if (isymp->n_sclass == C_BSTAT)
4250 {
f630a0a4 4251 struct internal_syment isym;
867d923d
ILT		 4252 unsigned long indx;
4253
4254 /* The value of a C_BSTAT symbol is the symbol table
4255 index of the containing csect. */
f630a0a4
ILT		 4256 bfd_coff_swap_sym_in (output_bfd, (PTR) outsym, (PTR) &isym);
4257 indx = isym.n_value;
867d923d
ILT		 4258 if (indx < obj_raw_syment_count (input_bfd))
4259 {
4260 long symindx;
4261
4262 symindx = finfo->sym_indices[indx];
4263 if (symindx < 0)
f630a0a4 4264 isym.n_value = 0;
867d923d 4265 else
f630a0a4
ILT		 4266 isym.n_value = symindx;
4267 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym,
867d923d
ILT		 4268 (PTR) outsym);
4269 }
4270 }
4271
aadf04f7
SS		 4272 esym += isymesz;
4273 outsym += osymesz;
4274
4275 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
4276 {
4277 union internal_auxent aux;
4278
4279 bfd_coff_swap_aux_in (input_bfd, (PTR) esym, isymp->n_type,
4280 isymp->n_sclass, i, isymp->n_numaux,
4281 (PTR) &aux);
4282
4283 if (isymp->n_sclass == C_FILE)
4284 {
4285 /* This is the file name (or some comment put in by
4286 the compiler). If it is long, we must put it in
4287 the string table. */
4288 if (aux.x_file.x_n.x_zeroes == 0
4289 && aux.x_file.x_n.x_offset != 0)
4290 {
4291 const char *filename;
4292 bfd_size_type indx;
4293
4294 BFD_ASSERT (aux.x_file.x_n.x_offset
4295 >= STRING_SIZE_SIZE);
4296 if (strings == NULL)
4297 {
4298 strings = _bfd_coff_read_string_table (input_bfd);
4299 if (strings == NULL)
4300 return false;
4301 }
4302 filename = strings + aux.x_file.x_n.x_offset;
4303 indx = _bfd_stringtab_add (finfo->strtab, filename,
4304 hash, copy);
4305 if (indx == (bfd_size_type) -1)
4306 return false;
4307 aux.x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
4308 }
4309 }
4310 else if ((isymp->n_sclass == C_EXT
4311 || isymp->n_sclass == C_HIDEXT)
4312 && i + 1 == isymp->n_numaux)
4313 {
4314 /* We don't support type checking. I don't know if
4315 anybody does. */
4316 aux.x_csect.x_parmhash = 0;
4317 /* I don't think anybody uses these fields, but we'd
4318 better clobber them just in case. */
4319 aux.x_csect.x_stab = 0;
4320 aux.x_csect.x_snstab = 0;
4321 if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_LD)
4322 {
4323 unsigned long indx;
4324
4325 indx = aux.x_csect.x_scnlen.l;
4326 if (indx < obj_raw_syment_count (input_bfd))
4327 {
4328 long symindx;
4329
4330 symindx = finfo->sym_indices[indx];
4331 if (symindx < 0)
4332 aux.x_sym.x_tagndx.l = 0;
4333 else
4334 aux.x_sym.x_tagndx.l = symindx;
4335 }
4336 }
4337 }
4338 else if (isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
4339 {
4340 unsigned long indx;
4341
4342 if (ISFCN (isymp->n_type)
4343 || ISTAG (isymp->n_sclass)
4344 || isymp->n_sclass == C_BLOCK)
4345 {
4346 indx = aux.x_sym.x_fcnary.x_fcn.x_endndx.l;
4347 if (indx > 0
4348 && indx < obj_raw_syment_count (input_bfd))
4349 {
4350 /* We look forward through the symbol for
4351 the index of the next symbol we are going
4352 to include. I don't know if this is
4353 entirely right. */
4354 while (finfo->sym_indices[indx] < 0
4355 && indx < obj_raw_syment_count (input_bfd))
4356 ++indx;
4357 if (indx >= obj_raw_syment_count (input_bfd))
4358 indx = output_index;
4359 else
4360 indx = finfo->sym_indices[indx];
4361 aux.x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
4362 }
4363 }
4364
4365 indx = aux.x_sym.x_tagndx.l;
4366 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
4367 {
4368 long symindx;
4369
4370 symindx = finfo->sym_indices[indx];
4371 if (symindx < 0)
4372 aux.x_sym.x_tagndx.l = 0;
4373 else
4374 aux.x_sym.x_tagndx.l = symindx;
4375 }
4376 }
4377
28a0c103
ILT		 4378 /* Copy over the line numbers, unless we are stripping
4379 them. We do this on a symbol by symbol basis in
4380 order to more easily handle garbage collection. */
4381 if ((isymp->n_sclass == C_EXT
4382 || isymp->n_sclass == C_HIDEXT)
4383 && i == 0
4384 && isymp->n_numaux > 1
4385 && ISFCN (isymp->n_type)
4386 && aux.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
aadf04f7 4387 {
28a0c103
ILT		 4388 if (finfo->info->strip != strip_none
4389 && finfo->info->strip != strip_some)
4390 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
aadf04f7
SS		 4391 else
4392 {
28a0c103 4393 asection *enclosing;
b73322d9 4394 unsigned int enc_count;
28a0c103
ILT		 4395 bfd_size_type linoff;
4396 struct internal_lineno lin;
4397
4398 o = *csectpp;
4399 enclosing = xcoff_section_data (abfd, o)->enclosing;
b73322d9
ILT		 4400 enc_count = xcoff_section_data (abfd, o)->lineno_count;
4401 if (oline != enclosing)
4402 {
4403 if (bfd_seek (input_bfd,
4404 enclosing->line_filepos,
4405 SEEK_SET) != 0
4406 || (bfd_read (finfo->linenos, linesz,
4407 enc_count, input_bfd)
4408 != linesz * enc_count))
4409 return false;
4410 oline = enclosing;
4411 }
4412
28a0c103
ILT		 4413 linoff = (aux.x_sym.x_fcnary.x_fcn.x_lnnoptr
4414 - enclosing->line_filepos);
4415
28a0c103 4416 bfd_coff_swap_lineno_in (input_bfd,
b73322d9 4417 (PTR) (finfo->linenos + linoff),
28a0c103
ILT		 4418 (PTR) &lin);
4419 if (lin.l_lnno != 0
4420 || ((bfd_size_type) lin.l_addr.l_symndx
4421 != ((esym
4422 - isymesz
4423 - ((bfd_byte *)
4424 obj_coff_external_syms (input_bfd)))
4425 / isymesz)))
4426 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
4427 else
aadf04f7 4428 {
28a0c103
ILT		 4429 bfd_byte *linpend, *linp;
4430 bfd_vma offset;
4431 bfd_size_type count;
4432
4433 lin.l_addr.l_symndx = *indexp;
4434 bfd_coff_swap_lineno_out (output_bfd, (PTR) &lin,
b73322d9
ILT		 4435 (PTR) (finfo->linenos
4436 + linoff));
28a0c103
ILT		 4437
4438 linpend = (finfo->linenos
b73322d9 4439 + enc_count * linesz);
28a0c103
ILT		 4440 offset = (o->output_section->vma
4441 + o->output_offset
4442 - o->vma);
b73322d9 4443 for (linp = finfo->linenos + linoff + linesz;
28a0c103
ILT		 4444 linp < linpend;
4445 linp += linesz)
4446 {
4447 bfd_coff_swap_lineno_in (input_bfd, (PTR) linp,
4448 (PTR) &lin);
4449 if (lin.l_lnno == 0)
4450 break;
4451 lin.l_addr.l_paddr += offset;
4452 bfd_coff_swap_lineno_out (output_bfd,
4453 (PTR) &lin,
4454 (PTR) linp);
4455 }
4456
b73322d9 4457 count = (linp - (finfo->linenos + linoff)) / linesz;
28a0c103
ILT		 4458
4459 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr =
aadf04f7 4460 (o->output_section->line_filepos
28a0c103
ILT		 4461 + o->output_section->lineno_count * linesz);
4462
4463 if (bfd_seek (output_bfd,
4464 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr,
4465 SEEK_SET) != 0
b73322d9
ILT		 4466 || (bfd_write (finfo->linenos + linoff,
4467 linesz, count, output_bfd)
28a0c103
ILT		 4468 != linesz * count))
4469 return false;
4470
4471 o->output_section->lineno_count += count;
f630a0a4
ILT		 4472
4473 if (incls > 0)
4474 {
4475 struct internal_syment *iisp, *iispend;
4476 long *iindp;
4477 bfd_byte *oos;
c3dffbd7 4478 int iiadd;
f630a0a4
ILT		 4479
4480 /* Update any C_BINCL or C_EINCL symbols
4481 that refer to a line number in the
4482 range we just output. */
4483 iisp = finfo->internal_syms;
4484 iispend = (iisp
4485 + obj_raw_syment_count (input_bfd));
4486 iindp = finfo->sym_indices;
4487 oos = finfo->outsyms;
4488 while (iisp < iispend)
4489 {
c3dffbd7
ILT		 4490 if (*iindp >= 0
4491 && (iisp->n_sclass == C_BINCL
4492 || iisp->n_sclass == C_EINCL)
f630a0a4
ILT		 4493 && ((bfd_size_type) iisp->n_value
4494 >= enclosing->line_filepos + linoff)
4495 && ((bfd_size_type) iisp->n_value
4496 < (enclosing->line_filepos
4497 + enc_count * linesz)))
4498 {
4499 struct internal_syment iis;
4500
4501 bfd_coff_swap_sym_in (output_bfd,
4502 (PTR) oos,
4503 (PTR) &iis);
4504 iis.n_value =
4505 (iisp->n_value
4506 - enclosing->line_filepos
4507 - linoff
4508 + aux.x_sym.x_fcnary.x_fcn.x_lnnoptr);
4509 bfd_coff_swap_sym_out (output_bfd,
4510 (PTR) &iis,
4511 (PTR) oos);
4512 --incls;
4513 }
4514
c3dffbd7
ILT		 4515 iiadd = 1 + iisp->n_numaux;
4516 if (*iindp >= 0)
4517 oos += iiadd * osymesz;
4518 iisp += iiadd;
4519 iindp += iiadd;
f630a0a4
ILT		 4520 }
4521 }
aadf04f7
SS		 4522 }
4523 }
aadf04f7
SS		 4524 }
4525
28a0c103
ILT		 4526 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, isymp->n_type,
4527 isymp->n_sclass, i, isymp->n_numaux,
4528 (PTR) outsym);
4529 outsym += osymesz;
4530 esym += isymesz;
aadf04f7 4531 }
aadf04f7 4532 }
28a0c103
ILT		 4533
4534 indexp += add;
4535 isymp += add;
4536 csectpp += add;
aadf04f7
SS		 4537 }
4538
4539 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
4540 symbol will be the first symbol in the next input file. In the
4541 normal case, this will save us from writing out the C_FILE symbol
4542 again. */
4543 if (finfo->last_file_index != -1
4544 && (bfd_size_type) finfo->last_file_index >= syment_base)
4545 {
4546 finfo->last_file.n_value = output_index;
4547 bfd_coff_swap_sym_out (output_bfd, (PTR) &finfo->last_file,
4548 (PTR) (finfo->outsyms
4549 + ((finfo->last_file_index - syment_base)
4550 * osymesz)));
4551 }
4552
4553 /* Write the modified symbols to the output file. */
4554 if (outsym > finfo->outsyms)
4555 {
4556 if (bfd_seek (output_bfd,
4557 obj_sym_filepos (output_bfd) + syment_base * osymesz,
4558 SEEK_SET) != 0
4559 || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1,
4560 output_bfd)
4561 != (bfd_size_type) (outsym - finfo->outsyms)))
4562 return false;
4563
4564 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
4565 + (outsym - finfo->outsyms) / osymesz)
4566 == output_index);
4567
4568 obj_raw_syment_count (output_bfd) = output_index;
4569 }
4570
4571 /* Don't let the linker relocation routines discard the symbols. */
4572 keep_syms = obj_coff_keep_syms (input_bfd);
4573 obj_coff_keep_syms (input_bfd) = true;
4574
4575 /* Relocate the contents of each section. */
4576 for (o = input_bfd->sections; o != NULL; o = o->next)
4577 {
4578 bfd_byte *contents;
4579
ff0e4a93 4580 if (! o->linker_mark)
7ec49f91
ILT		 4581 {
4582 /* This section was omitted from the link. */
4583 continue;
4584 }
4585
aadf04f7 4586 if ((o->flags & SEC_HAS_CONTENTS) == 0
28a0c103
ILT		 4587 || o->_raw_size == 0
4588 || (o->flags & SEC_IN_MEMORY) != 0)
aadf04f7
SS		 4589 continue;
4590
4591 /* We have set filepos correctly for the sections we created to
4592 represent csects, so bfd_get_section_contents should work. */
4593 if (coff_section_data (input_bfd, o) != NULL
4594 && coff_section_data (input_bfd, o)->contents != NULL)
4595 contents = coff_section_data (input_bfd, o)->contents;
4596 else
4597 {
4598 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
4599 (file_ptr) 0, o->_raw_size))
4600 return false;
4601 contents = finfo->contents;
4602 }
4603
4604 if ((o->flags & SEC_RELOC) != 0)
4605 {
4606 int target_index;
4607 struct internal_reloc *internal_relocs;
4608 struct internal_reloc *irel;
4609 bfd_vma offset;
4610 struct internal_reloc *irelend;
4611 struct xcoff_link_hash_entry **rel_hash;
28a0c103 4612 long r_symndx;
aadf04f7 4613
28a0c103 4614 /* Read in the relocs. */
aadf04f7 4615 target_index = o->output_section->target_index;
28a0c103 4616 internal_relocs = (xcoff_read_internal_relocs
aadf04f7
SS		 4617 (input_bfd, o, false, finfo->external_relocs,
4618 true,
4619 (finfo->section_info[target_index].relocs
4620 + o->output_section->reloc_count)));
4621 if (internal_relocs == NULL)
4622 return false;
4623
4624 /* Call processor specific code to relocate the section
4625 contents. */
4626 if (! bfd_coff_relocate_section (output_bfd, finfo->info,
4627 input_bfd, o,
4628 contents,
4629 internal_relocs,
4630 finfo->internal_syms,
4631 xcoff_data (input_bfd)->csects))
4632 return false;
4633
4634 offset = o->output_section->vma + o->output_offset - o->vma;
4635 irel = internal_relocs;
4636 irelend = irel + o->reloc_count;
4637 rel_hash = (finfo->section_info[target_index].rel_hashes
4638 + o->output_section->reloc_count);
4639 for (; irel < irelend; irel++, rel_hash++)
4640 {
28a0c103
ILT		 4641 struct xcoff_link_hash_entry *h = NULL;
4642 struct internal_ldrel ldrel;
aadf04f7
SS		 4643
4644 *rel_hash = NULL;
4645
4646 /* Adjust the reloc address and symbol index. */
4647
4648 irel->r_vaddr += offset;
4649
28a0c103 4650 r_symndx = irel->r_symndx;
aadf04f7 4651
28a0c103 4652 if (r_symndx != -1)
aadf04f7 4653 {
28a0c103 4654 h = obj_xcoff_sym_hashes (input_bfd)[r_symndx];
230de6b8
ILT		 4655 if (h != NULL
4656 && (irel->r_type == R_TOC
4657 || irel->r_type == R_GL
4658 || irel->r_type == R_TCL
4659 || irel->r_type == R_TRL
4660 || irel->r_type == R_TRLA))
4661 {
4662 /* This is a TOC relative reloc with a symbol
4663 attached. The symbol should be the one which
4664 this reloc is for. We want to make this
4665 reloc against the TOC address of the symbol,
4666 not the symbol itself. */
4667 BFD_ASSERT (h->toc_section != NULL);
4668 BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
2d7de17d
ILT		 4669 if (h->u.toc_indx != -1)
4670 irel->r_symndx = h->u.toc_indx;
4671 else
230de6b8 4672 {
2d7de17d
ILT		 4673 struct xcoff_toc_rel_hash *n;
4674 struct xcoff_link_section_info *si;
4675
4676 n = ((struct xcoff_toc_rel_hash *)
4677 bfd_alloc (finfo->output_bfd,
4678 sizeof (struct xcoff_toc_rel_hash)));
4679 if (n == NULL)
a9713b91 4680 return false;
2d7de17d
ILT		 4681 si = finfo->section_info + target_index;
4682 n->next = si->toc_rel_hashes;
4683 n->h = h;
4684 n->rel = irel;
4685 si->toc_rel_hashes = n;
230de6b8 4686 }
230de6b8
ILT		 4687 }
4688 else if (h != NULL)
28a0c103
ILT		 4689 {
4690 /* This is a global symbol. */
4691 if (h->indx >= 0)
4692 irel->r_symndx = h->indx;
4693 else
4694 {
4695 /* This symbol is being written at the end
4696 of the file, and we do not yet know the
4697 symbol index. We save the pointer to the
4698 hash table entry in the rel_hash list.
4699 We set the indx field to -2 to indicate
4700 that this symbol must not be stripped. */
4701 *rel_hash = h;
4702 h->indx = -2;
4703 }
4704 }
aadf04f7
SS		 4705 else
4706 {
28a0c103
ILT		 4707 long indx;
4708
4709 indx = finfo->sym_indices[r_symndx];
4710
4711 if (indx == -1)
4712 {
4713 struct internal_syment *is;
4714
4715 /* Relocations against a TC0 TOC anchor are
4716 automatically transformed to be against
4717 the TOC anchor in the output file. */
4718 is = finfo->internal_syms + r_symndx;
4719 if (is->n_sclass == C_HIDEXT
4720 && is->n_numaux > 0)
4721 {
4722 PTR auxptr;
4723 union internal_auxent aux;
4724
4725 auxptr = ((PTR)
4726 (((bfd_byte *)
4727 obj_coff_external_syms (input_bfd))
4728 + ((r_symndx + is->n_numaux)
4729 * isymesz)));
4730 bfd_coff_swap_aux_in (input_bfd, auxptr,
4731 is->n_type, is->n_sclass,
4732 is->n_numaux - 1,
4733 is->n_numaux,
4734 (PTR) &aux);
4735 if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_SD
4736 && aux.x_csect.x_smclas == XMC_TC0)
4737 indx = finfo->toc_symindx;
4738 }
4739 }
4740
4741 if (indx != -1)
4742 irel->r_symndx = indx;
4743 else
4744 {
4745 struct internal_syment *is;
4746 const char *name;
4747 char buf[SYMNMLEN + 1];
4748
4749 /* This reloc is against a symbol we are
4750 stripping. It would be possible to handle
4751 this case, but I don't think it's worth it. */
4752 is = finfo->internal_syms + r_symndx;
4753
4754 name = (_bfd_coff_internal_syment_name
4755 (input_bfd, is, buf));
4756 if (name == NULL)
4757 return false;
4758
4759 if (! ((*finfo->info->callbacks->unattached_reloc)
4760 (finfo->info, name, input_bfd, o,
4761 irel->r_vaddr)))
4762 return false;
4763 }
aadf04f7
SS		 4764 }
4765 }
28a0c103
ILT		 4766
4767 switch (irel->r_type)
aadf04f7 4768 {
28a0c103 4769 default:
867d923d
ILT		 4770 if (h == NULL
4771 || h->root.type == bfd_link_hash_defined
4772 || h->root.type == bfd_link_hash_defweak
4773 || h->root.type == bfd_link_hash_common)
4774 break;
4775 /* Fall through. */
28a0c103
ILT		 4776 case R_POS:
4777 case R_NEG:
4778 case R_RL:
4779 case R_RLA:
4780 /* This reloc needs to be copied into the .loader
4781 section. */
4782 ldrel.l_vaddr = irel->r_vaddr;
4783 if (r_symndx == -1)
4784 ldrel.l_symndx = -1;
867d923d
ILT		 4785 else if (h == NULL
4786 || (h->root.type == bfd_link_hash_defined
4787 || h->root.type == bfd_link_hash_defweak
4788 || h->root.type == bfd_link_hash_common))
28a0c103
ILT		 4789 {
4790 asection *sec;
aadf04f7 4791
867d923d
ILT		 4792 if (h == NULL)
4793 sec = xcoff_data (input_bfd)->csects[r_symndx];
4794 else if (h->root.type == bfd_link_hash_common)
4795 sec = h->root.u.c.p->section;
28a0c103 4796 else
867d923d
ILT		 4797 sec = h->root.u.def.section;
4798 sec = sec->output_section;
aadf04f7 4799
867d923d 4800 if (strcmp (sec->name, ".text") == 0)
28a0c103 4801 ldrel.l_symndx = 0;
867d923d 4802 else if (strcmp (sec->name, ".data") == 0)
28a0c103 4803 ldrel.l_symndx = 1;
867d923d 4804 else if (strcmp (sec->name, ".bss") == 0)
28a0c103 4805 ldrel.l_symndx = 2;
867d923d
ILT		 4806 else
4807 {
4808 (*_bfd_error_handler)
4809 ("%s: loader reloc in unrecognized section `%s'",
4810 bfd_get_filename (input_bfd),
4811 sec->name);
4812 bfd_set_error (bfd_error_nonrepresentable_section);
4813 return false;
4814 }
28a0c103
ILT		 4815 }
4816 else
aadf04f7 4817 {
28a0c103 4818 if (h->ldindx < 0)
aadf04f7 4819 {
28a0c103
ILT		 4820 (*_bfd_error_handler)
4821 ("%s: `%s' in loader reloc but not loader sym",
4822 bfd_get_filename (input_bfd),
4823 h->root.root.string);
4824 bfd_set_error (bfd_error_bad_value);
4825 return false;
aadf04f7 4826 }
28a0c103 4827 ldrel.l_symndx = h->ldindx;
aadf04f7 4828 }
28a0c103
ILT		 4829 ldrel.l_rtype = (irel->r_size << 8) | irel->r_type;
4830 ldrel.l_rsecnm = o->output_section->target_index;
4831 if (xcoff_hash_table (finfo->info)->textro
867d923d 4832 && strcmp (o->output_section->name, ".text") == 0)
aadf04f7 4833 {
28a0c103
ILT		 4834 (*_bfd_error_handler)
4835 ("%s: loader reloc in read-only section %s",
4836 bfd_get_filename (input_bfd),
4837 bfd_get_section_name (finfo->output_bfd,
4838 o->output_section));
4839 bfd_set_error (bfd_error_invalid_operation);
4840 return false;
aadf04f7 4841 }
28a0c103
ILT		 4842 xcoff_swap_ldrel_out (output_bfd, &ldrel,
4843 finfo->ldrel);
4844 BFD_ASSERT (sizeof (struct external_ldrel) == LDRELSZ);
4845 ++finfo->ldrel;
867d923d
ILT		 4846 break;
4847
4848 case R_TOC:
4849 case R_GL:
4850 case R_TCL:
4851 case R_TRL:
4852 case R_TRLA:
4853 /* We should never need a .loader reloc for a TOC
4854 relative reloc. */
4855 break;
aadf04f7
SS		 4856 }
4857 }
4858
4859 o->output_section->reloc_count += o->reloc_count;
4860 }
4861
4862 /* Write out the modified section contents. */
4863 if (! bfd_set_section_contents (output_bfd, o->output_section,
4864 contents, o->output_offset,
4865 (o->_cooked_size != 0
4866 ? o->_cooked_size
4867 : o->_raw_size)))
4868 return false;
4869 }
4870
4871 obj_coff_keep_syms (input_bfd) = keep_syms;
4872
4873 if (! finfo->info->keep_memory)
4874 {
4875 if (! _bfd_coff_free_symbols (input_bfd))
4876 return false;
4877 }
4878
4879 return true;
4880}
4881
28a0c103
ILT		 4882#undef N_TMASK
4883#undef N_BTSHFT
4884
aadf04f7
SS		 4885/* Write out a non-XCOFF global symbol. */
4886
4887static boolean
4888xcoff_write_global_symbol (h, p)
4889 struct xcoff_link_hash_entry *h;
4890 PTR p;
4891{
4892 struct xcoff_final_link_info *finfo = (struct xcoff_final_link_info *) p;
4893 bfd *output_bfd;
4894 bfd_byte *outsym;
4895 struct internal_syment isym;
4896 union internal_auxent aux;
4897
28a0c103
ILT		 4898 output_bfd = finfo->output_bfd;
4899
4900 /* If this symbol was garbage collected, just skip it. */
4901 if (xcoff_hash_table (finfo->info)->gc
4902 && (h->flags & XCOFF_MARK) == 0)
4903 return true;
4904
4905 /* If we need a .loader section entry, write it out. */
4906 if (h->ldsym != NULL)
4907 {
4908 struct internal_ldsym *ldsym;
4909 bfd *impbfd;
4910
4911 ldsym = h->ldsym;
4912
4913 if (h->root.type == bfd_link_hash_undefined
4914 || h->root.type == bfd_link_hash_undefweak)
4915 {
4916 ldsym->l_value = 0;
4917 ldsym->l_scnum = N_UNDEF;
4918 ldsym->l_smtype = XTY_ER;
4919 impbfd = h->root.u.undef.abfd;
4920 }
4921 else if (h->root.type == bfd_link_hash_defined
4922 || h->root.type == bfd_link_hash_defweak)
4923 {
4924 asection *sec;
4925
4926 sec = h->root.u.def.section;
4927 ldsym->l_value = (sec->output_section->vma
4928 + sec->output_offset
4929 + h->root.u.def.value);
4930 ldsym->l_scnum = sec->output_section->target_index;
4931 ldsym->l_smtype = XTY_SD;
4932 impbfd = sec->owner;
4933 }
4934 else
4935 abort ();
4936
4937 if (((h->flags & XCOFF_DEF_REGULAR) == 0
0634a431 4938 && (h->flags & XCOFF_DEF_DYNAMIC) != 0)
28a0c103
ILT		 4939 || (h->flags & XCOFF_IMPORT) != 0)
4940 ldsym->l_smtype |= L_IMPORT;
4941 if (((h->flags & XCOFF_DEF_REGULAR) != 0
0634a431 4942 && (h->flags & XCOFF_DEF_DYNAMIC) != 0)
28a0c103
ILT		 4943 || (h->flags & XCOFF_EXPORT) != 0)
4944 ldsym->l_smtype |= L_EXPORT;
4945 if ((h->flags & XCOFF_ENTRY) != 0)
4946 ldsym->l_smtype |= L_ENTRY;
4947
4948 ldsym->l_smclas = h->smclas;
4949
4950 if (ldsym->l_ifile == (bfd_size_type) -1)
4951 ldsym->l_ifile = 0;
4952 else if (ldsym->l_ifile == 0)
4953 {
4954 if ((ldsym->l_smtype & L_IMPORT) == 0)
4955 ldsym->l_ifile = 0;
4956 else if (impbfd == NULL)
4957 ldsym->l_ifile = 0;
4958 else
4959 {
4960 BFD_ASSERT (impbfd->xvec == output_bfd->xvec);
4961 ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
4962 }
4963 }
4964
4965 ldsym->l_parm = 0;
4966
4967 BFD_ASSERT (h->ldindx >= 0);
4968 BFD_ASSERT (LDSYMSZ == sizeof (struct external_ldsym));
4969 xcoff_swap_ldsym_out (output_bfd, ldsym, finfo->ldsym + h->ldindx - 3);
4970 h->ldsym = NULL;
4971 }
4972
4973 /* If this symbol needs global linkage code, write it out. */
4974 if (h->root.type == bfd_link_hash_defined
4975 && (h->root.u.def.section
4976 == xcoff_hash_table (finfo->info)->linkage_section))
4977 {
4978 bfd_byte *p;
4979 bfd_vma tocoff;
4980 unsigned int i;
4981
4982 p = h->root.u.def.section->contents + h->root.u.def.value;
4983
4984 /* The first instruction in the global linkage code loads a
4985 specific TOC element. */
4986 tocoff = (h->descriptor->toc_section->output_section->vma
4987 + h->descriptor->toc_section->output_offset
28a0c103 4988 - xcoff_data (output_bfd)->toc);
230de6b8
ILT		 4989 if ((h->descriptor->flags & XCOFF_SET_TOC) != 0)
4990 tocoff += h->descriptor->u.toc_offset;
b5403ad7 4991 bfd_put_32 (output_bfd, XCOFF_GLINK_FIRST | (tocoff & 0xffff), p);
28a0c103
ILT		 4992 for (i = 0, p += 4;
4993 i < sizeof xcoff_glink_code / sizeof xcoff_glink_code[0];
4994 i++, p += 4)
4995 bfd_put_32 (output_bfd, xcoff_glink_code[i], p);
4996 }
4997
4998 /* If we created a TOC entry for this symbol, write out the required
4999 relocs. */
5000 if ((h->flags & XCOFF_SET_TOC) != 0)
5001 {
5002 asection *tocsec;
5003 asection *osec;
5004 int oindx;
5005 struct internal_reloc *irel;
5006 struct internal_ldrel ldrel;
5007
5008 tocsec = h->toc_section;
5009 osec = tocsec->output_section;
5010 oindx = osec->target_index;
5011 irel = finfo->section_info[oindx].relocs + osec->reloc_count;
5012 irel->r_vaddr = (osec->vma
5013 + tocsec->output_offset
230de6b8 5014 + h->u.toc_offset);
28a0c103
ILT		 5015 if (h->indx >= 0)
5016 irel->r_symndx = h->indx;
5017 else
5018 {
5019 h->indx = -2;
5020 irel->r_symndx = obj_raw_syment_count (output_bfd);
5021 }
5022 irel->r_type = R_POS;
5023 irel->r_size = 31;
5024 finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
5025 ++osec->reloc_count;
5026
5027 BFD_ASSERT (h->ldindx >= 0);
5028 ldrel.l_vaddr = irel->r_vaddr;
5029 ldrel.l_symndx = h->ldindx;
5030 ldrel.l_rtype = (31 << 8) | R_POS;
5031 ldrel.l_rsecnm = oindx;
5032 xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5033 ++finfo->ldrel;
5034 }
5035
ee174815
ILT		 5036 /* If this symbol is a specially defined function descriptor, write
5037 it out. The first word is the address of the function code
5038 itself, the second word is the address of the TOC, and the third
5039 word is zero. */
5040 if ((h->flags & XCOFF_DESCRIPTOR) != 0
5041 && h->root.type == bfd_link_hash_defined
5042 && (h->root.u.def.section
5043 == xcoff_hash_table (finfo->info)->descriptor_section))
5044 {
5045 asection *sec;
5046 asection *osec;
5047 int oindx;
5048 bfd_byte *p;
5049 struct xcoff_link_hash_entry *hentry;
5050 asection *esec;
5051 struct internal_reloc *irel;
5052 struct internal_ldrel ldrel;
5053 asection *tsec;
5054
5055 sec = h->root.u.def.section;
5056 osec = sec->output_section;
5057 oindx = osec->target_index;
5058 p = sec->contents + h->root.u.def.value;
5059
5060 hentry = h->descriptor;
5061 BFD_ASSERT (hentry != NULL
5062 && (hentry->root.type == bfd_link_hash_defined
5063 || hentry->root.type == bfd_link_hash_defweak));
5064 esec = hentry->root.u.def.section;
5065 bfd_put_32 (output_bfd,
5066 (esec->output_section->vma
5067 + esec->output_offset
5068 + hentry->root.u.def.value),
5069 p);
5070
5071 irel = finfo->section_info[oindx].relocs + osec->reloc_count;
5072 irel->r_vaddr = (osec->vma
5073 + sec->output_offset
5074 + h->root.u.def.value);
5075 irel->r_symndx = esec->output_section->target_index;
5076 irel->r_type = R_POS;
5077 irel->r_size = 31;
5078 finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
5079 ++osec->reloc_count;
5080
5081 ldrel.l_vaddr = irel->r_vaddr;
5082 if (strcmp (esec->output_section->name, ".text") == 0)
5083 ldrel.l_symndx = 0;
5084 else if (strcmp (esec->output_section->name, ".data") == 0)
5085 ldrel.l_symndx = 1;
5086 else if (strcmp (esec->output_section->name, ".bss") == 0)
5087 ldrel.l_symndx = 2;
5088 else
5089 {
5090 (*_bfd_error_handler)
5091 ("%s: loader reloc in unrecognized section `%s'",
5092 bfd_get_filename (output_bfd),
5093 esec->output_section->name);
5094 bfd_set_error (bfd_error_nonrepresentable_section);
5095 return false;
5096 }
5097 ldrel.l_rtype = (31 << 8) | R_POS;
5098 ldrel.l_rsecnm = oindx;
5099 xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5100 ++finfo->ldrel;
5101
5102 bfd_put_32 (output_bfd, xcoff_data (output_bfd)->toc, p + 4);
5103
c3dffbd7
ILT		 5104 tsec = coff_section_from_bfd_index (output_bfd,
5105 xcoff_data (output_bfd)->sntoc);
ee174815
ILT		 5106
5107 ++irel;
5108 irel->r_vaddr = (osec->vma
5109 + sec->output_offset
5110 + h->root.u.def.value
5111 + 4);
5112 irel->r_symndx = tsec->output_section->target_index;
5113 irel->r_type = R_POS;
5114 irel->r_size = 31;
5115 finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
5116 ++osec->reloc_count;
5117
5118 ldrel.l_vaddr = irel->r_vaddr;
5119 if (strcmp (tsec->output_section->name, ".text") == 0)
5120 ldrel.l_symndx = 0;
5121 else if (strcmp (tsec->output_section->name, ".data") == 0)
5122 ldrel.l_symndx = 1;
5123 else if (strcmp (tsec->output_section->name, ".bss") == 0)
5124 ldrel.l_symndx = 2;
5125 else
5126 {
5127 (*_bfd_error_handler)
5128 ("%s: loader reloc in unrecognized section `%s'",
5129 bfd_get_filename (output_bfd),
5130 tsec->output_section->name);
5131 bfd_set_error (bfd_error_nonrepresentable_section);
5132 return false;
5133 }
5134 ldrel.l_rtype = (31 << 8) | R_POS;
5135 ldrel.l_rsecnm = oindx;
5136 xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5137 ++finfo->ldrel;
5138 }
5139
28a0c103
ILT		 5140 if (h->indx >= 0)
5141 return true;
5142
5143 if (h->indx != -2
5144 && (finfo->info->strip == strip_all
5145 || (finfo->info->strip == strip_some
5146 && (bfd_hash_lookup (finfo->info->keep_hash,
5147 h->root.root.string, false, false)
5148 == NULL))))
5149 return true;
5150
5151 if (h->indx != -2
5152 && (h->flags & (XCOFF_REF_REGULAR | XCOFF_DEF_REGULAR)) == 0)
aadf04f7
SS		 5153 return true;
5154
aadf04f7
SS		 5155 outsym = finfo->outsyms;
5156
5157 memset (&aux, 0, sizeof aux);
5158
5159 h->indx = obj_raw_syment_count (output_bfd);
5160
5161 if (strlen (h->root.root.string) <= SYMNMLEN)
5162 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
5163 else
5164 {
5165 boolean hash;
5166 bfd_size_type indx;
5167
5168 hash = true;
5169 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
5170 hash = false;
5171 indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
5172 false);
5173 if (indx == (bfd_size_type) -1)
5174 return false;
5175 isym._n._n_n._n_zeroes = 0;
5176 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
5177 }
5178
5179 if (h->root.type == bfd_link_hash_undefined
5180 || h->root.type == bfd_link_hash_undefweak)
5181 {
5182 isym.n_value = 0;
5183 isym.n_scnum = N_UNDEF;
5184 isym.n_sclass = C_EXT;
5185 aux.x_csect.x_smtyp = XTY_ER;
5186 }
5187 else if (h->root.type == bfd_link_hash_defined
5188 || h->root.type == bfd_link_hash_defweak)
5189 {
2d7de17d
ILT		 5190 struct xcoff_link_size_list *l;
5191
aadf04f7
SS		 5192 isym.n_value = (h->root.u.def.section->output_section->vma
5193 + h->root.u.def.section->output_offset
5194 + h->root.u.def.value);
5195 isym.n_scnum = h->root.u.def.section->output_section->target_index;
5196 isym.n_sclass = C_HIDEXT;
5197 aux.x_csect.x_smtyp = XTY_SD;
2d7de17d
ILT		 5198
5199 if ((h->flags & XCOFF_HAS_SIZE) != 0)
5200 {
5201 for (l = xcoff_hash_table (finfo->info)->size_list;
5202 l != NULL;
5203 l = l->next)
5204 {
5205 if (l->h == h)
5206 {
5207 aux.x_csect.x_scnlen.l = l->size;
5208 break;
5209 }
5210 }
5211 }
5212 }
5213 else if (h->root.type == bfd_link_hash_common)
5214 {
5215 isym.n_value = (h->root.u.c.p->section->output_section->vma
5216 + h->root.u.c.p->section->output_offset);
5217 isym.n_scnum = h->root.u.c.p->section->output_section->target_index;
5218 isym.n_sclass = C_EXT;
5219 aux.x_csect.x_smtyp = XTY_CM;
5220 aux.x_csect.x_scnlen.l = h->root.u.c.size;
aadf04f7
SS		 5221 }
5222 else
5223 abort ();
5224
5225 isym.n_type = T_NULL;
5226 isym.n_numaux = 1;
5227
5228 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
5229 outsym += bfd_coff_symesz (output_bfd);
5230
28a0c103 5231 aux.x_csect.x_smclas = h->smclas;
aadf04f7
SS		 5232
5233 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, isym.n_sclass, 0, 1,
5234 (PTR) outsym);
5235 outsym += bfd_coff_auxesz (output_bfd);
5236
28a0c103
ILT		 5237 if (h->root.type == bfd_link_hash_defined
5238 || h->root.type == bfd_link_hash_defweak)
aadf04f7
SS		 5239 {
5240 /* We just output an SD symbol. Now output an LD symbol. */
5241
5242 h->indx += 2;
5243
5244 isym.n_sclass = C_EXT;
5245 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
5246 outsym += bfd_coff_symesz (output_bfd);
5247
5248 aux.x_csect.x_smtyp = XTY_LD;
5249 aux.x_csect.x_scnlen.l = obj_raw_syment_count (output_bfd);
5250
5251 bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, C_EXT, 0, 1,
5252 (PTR) outsym);
5253 outsym += bfd_coff_auxesz (output_bfd);
5254 }
5255
5256 if (bfd_seek (output_bfd,
5257 (obj_sym_filepos (output_bfd)
5258 + (obj_raw_syment_count (output_bfd)
5259 * bfd_coff_symesz (output_bfd))),
5260 SEEK_SET) != 0
5261 || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1, output_bfd)
5262 != (bfd_size_type) (outsym - finfo->outsyms)))
5263 return false;
5264 obj_raw_syment_count (output_bfd) +=
5265 (outsym - finfo->outsyms) / bfd_coff_symesz (output_bfd);
5266
5267 return true;
5268}
5269
5270/* Handle a link order which is supposed to generate a reloc. */
5271
5272static boolean
5273xcoff_reloc_link_order (output_bfd, finfo, output_section, link_order)
5274 bfd *output_bfd;
5275 struct xcoff_final_link_info *finfo;
5276 asection *output_section;
5277 struct bfd_link_order *link_order;
5278{
5279 reloc_howto_type *howto;
2d7de17d
ILT		 5280 struct xcoff_link_hash_entry *h;
5281 asection *hsec;
5282 bfd_vma hval;
5283 bfd_vma addend;
aadf04f7
SS		 5284 struct internal_reloc *irel;
5285 struct xcoff_link_hash_entry **rel_hash_ptr;
2d7de17d
ILT		 5286 struct internal_ldrel ldrel;
5287
5288 if (link_order->type == bfd_section_reloc_link_order)
5289 {
5290 /* We need to somehow locate a symbol in the right section. The
5291 symbol must either have a value of zero, or we must adjust
5292 the addend by the value of the symbol. FIXME: Write this
5293 when we need it. The old linker couldn't handle this anyhow. */
5294 abort ();
5295 }
aadf04f7
SS		 5296
5297 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
5298 if (howto == NULL)
5299 {
5300 bfd_set_error (bfd_error_bad_value);
5301 return false;
5302 }
5303
c3dffbd7
ILT		 5304 h = ((struct xcoff_link_hash_entry *)
5305 bfd_wrapped_link_hash_lookup (output_bfd, finfo->info,
5306 link_order->u.reloc.p->u.name,
5307 false, false, true));
2d7de17d
ILT		 5308 if (h == NULL)
5309 {
5310 if (! ((*finfo->info->callbacks->unattached_reloc)
5311 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
5312 (asection *) NULL, (bfd_vma) 0)))
5313 return false;
5314 return true;
5315 }
5316
5317 if (h->root.type == bfd_link_hash_common)
5318 {
5319 hsec = h->root.u.c.p->section;
5320 hval = 0;
5321 }
5322 else if (h->root.type == bfd_link_hash_defined
5323 || h->root.type == bfd_link_hash_defweak)
5324 {
5325 hsec = h->root.u.def.section;
5326 hval = h->root.u.def.value;
5327 }
5328 else
5329 {
5330 hsec = NULL;
5331 hval = 0;
5332 }
5333
5334 addend = link_order->u.reloc.p->addend;
5335 if (hsec != NULL)
5336 addend += (hsec->output_section->vma
5337 + hsec->output_offset
5338 + hval);
5339
5340 if (addend != 0)
aadf04f7
SS		 5341 {
5342 bfd_size_type size;
5343 bfd_byte *buf;
5344 bfd_reloc_status_type rstat;
5345 boolean ok;
5346
5347 size = bfd_get_reloc_size (howto);
5348 buf = (bfd_byte *) bfd_zmalloc (size);
5349 if (buf == NULL)
a9713b91 5350 return false;
aadf04f7 5351
2d7de17d 5352 rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
aadf04f7
SS		 5353 switch (rstat)
5354 {
5355 case bfd_reloc_ok:
5356 break;
5357 default:
5358 case bfd_reloc_outofrange:
5359 abort ();
5360 case bfd_reloc_overflow:
5361 if (! ((*finfo->info->callbacks->reloc_overflow)
2d7de17d
ILT		 5362 (finfo->info, link_order->u.reloc.p->u.name,
5363 howto->name, addend, (bfd *) NULL, (asection *) NULL,
5364 (bfd_vma) 0)))
aadf04f7
SS		 5365 {
5366 free (buf);
5367 return false;
5368 }
5369 break;
5370 }
5371 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
5372 (file_ptr) link_order->offset, size);
5373 free (buf);
5374 if (! ok)
5375 return false;
5376 }
5377
5378 /* Store the reloc information in the right place. It will get
5379 swapped and written out at the end of the final_link routine. */
5380
5381 irel = (finfo->section_info[output_section->target_index].relocs
5382 + output_section->reloc_count);
5383 rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
5384 + output_section->reloc_count);
5385
5386 memset (irel, 0, sizeof (struct internal_reloc));
5387 *rel_hash_ptr = NULL;
5388
5389 irel->r_vaddr = output_section->vma + link_order->offset;
5390
2d7de17d
ILT		 5391 if (h->indx >= 0)
5392 irel->r_symndx = h->indx;
5393 else
aadf04f7 5394 {
2d7de17d
ILT		 5395 /* Set the index to -2 to force this symbol to get written out. */
5396 h->indx = -2;
5397 *rel_hash_ptr = h;
aadf04f7
SS		 5398 irel->r_symndx = 0;
5399 }
2d7de17d
ILT		 5400
5401 irel->r_type = howto->type;
5402 irel->r_size = howto->bitsize - 1;
5403 if (howto->complain_on_overflow == complain_overflow_signed)
5404 irel->r_size |= 0x80;
5405
5406 ++output_section->reloc_count;
5407
5408 /* Now output the reloc to the .loader section. */
5409
5410 ldrel.l_vaddr = irel->r_vaddr;
5411
5412 if (hsec != NULL)
aadf04f7 5413 {
2d7de17d
ILT		 5414 const char *secname;
5415
5416 secname = hsec->output_section->name;
aadf04f7 5417
2d7de17d
ILT		 5418 if (strcmp (secname, ".text") == 0)
5419 ldrel.l_symndx = 0;
5420 else if (strcmp (secname, ".data") == 0)
5421 ldrel.l_symndx = 1;
5422 else if (strcmp (secname, ".bss") == 0)
5423 ldrel.l_symndx = 2;
5424 else
aadf04f7 5425 {
2d7de17d
ILT		 5426 (*_bfd_error_handler)
5427 ("%s: loader reloc in unrecognized section `%s'",
5428 bfd_get_filename (output_bfd), secname);
5429 bfd_set_error (bfd_error_nonrepresentable_section);
5430 return false;
aadf04f7 5431 }
2d7de17d
ILT		 5432 }
5433 else
5434 {
5435 if (h->ldindx < 0)
aadf04f7 5436 {
2d7de17d
ILT		 5437 (*_bfd_error_handler)
5438 ("%s: `%s' in loader reloc but not loader sym",
5439 bfd_get_filename (output_bfd),
5440 h->root.root.string);
5441 bfd_set_error (bfd_error_bad_value);
5442 return false;
aadf04f7 5443 }
2d7de17d 5444 ldrel.l_symndx = h->ldindx;
aadf04f7
SS		 5445 }
5446
2d7de17d
ILT		 5447 ldrel.l_rtype = (irel->r_size << 8) | irel->r_type;
5448 ldrel.l_rsecnm = output_section->target_index;
5449 xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
5450 ++finfo->ldrel;
aadf04f7
SS		 5451
5452 return true;
5453}
5454
5455/* Sort relocs by VMA. This is called via qsort. */
5456
5457static int
5458xcoff_sort_relocs (p1, p2)
5459 const PTR p1;
5460 const PTR p2;
5461{
5462 const struct internal_reloc *r1 = (const struct internal_reloc *) p1;
5463 const struct internal_reloc *r2 = (const struct internal_reloc *) p2;
5464
5465 if (r1->r_vaddr > r2->r_vaddr)
5466 return 1;
5467 else if (r1->r_vaddr < r2->r_vaddr)
5468 return -1;
5469 else
5470 return 0;
5471}
5472
5473/* This is the relocation function for the RS/6000/POWER/PowerPC.
5474 This is currently the only processor which uses XCOFF; I hope that
5475 will never change. */
5476
5477boolean
5478_bfd_ppc_xcoff_relocate_section (output_bfd, info, input_bfd,
5479 input_section, contents, relocs, syms,
5480 sections)
5481 bfd *output_bfd;
5482 struct bfd_link_info *info;
5483 bfd *input_bfd;
5484 asection *input_section;
5485 bfd_byte *contents;
5486 struct internal_reloc *relocs;
5487 struct internal_syment *syms;
5488 asection **sections;
5489{
5490 struct internal_reloc *rel;
5491 struct internal_reloc *relend;
5492
5493 rel = relocs;
5494 relend = rel + input_section->reloc_count;
5495 for (; rel < relend; rel++)
5496 {
5497 long symndx;
5498 struct xcoff_link_hash_entry *h;
5499 struct internal_syment *sym;
5500 bfd_vma addend;
5501 bfd_vma val;
5502 struct reloc_howto_struct howto;
5503 bfd_reloc_status_type rstat;
5504
28a0c103 5505 /* Relocation type R_REF is a special relocation type which is
aadf04f7
SS		 5506 merely used to prevent garbage collection from occurring for
5507 the csect including the symbol which it references. */
28a0c103 5508 if (rel->r_type == R_REF)
aadf04f7
SS		 5509 continue;
5510
5511 symndx = rel->r_symndx;
5512
5513 if (symndx == -1)
5514 {
5515 h = NULL;
5516 sym = NULL;
5517 addend = 0;
5518 }
5519 else
5520 {
5521 h = obj_xcoff_sym_hashes (input_bfd)[symndx];
5522 sym = syms + symndx;
5523 addend = - sym->n_value;
5524 }
5525
5526 /* We build the howto information on the fly. */
5527
5528 howto.type = rel->r_type;
5529 howto.rightshift = 0;
5530 howto.size = 2;
5531 howto.bitsize = (rel->r_size & 0x1f) + 1;
5532 howto.pc_relative = false;
5533 howto.bitpos = 0;
5534 if ((rel->r_size & 0x80) != 0)
5535 howto.complain_on_overflow = complain_overflow_signed;
5536 else
5537 howto.complain_on_overflow = complain_overflow_bitfield;
5538 howto.special_function = NULL;
5539 howto.name = "internal";
5540 howto.partial_inplace = true;
5541 if (howto.bitsize == 32)
5542 howto.src_mask = howto.dst_mask = 0xffffffff;
5543 else
5544 {
5545 howto.src_mask = howto.dst_mask = (1 << howto.bitsize) - 1;
5546 if (howto.bitsize == 16)
5547 howto.size = 1;
5548 }
5549 howto.pcrel_offset = false;
5550
5551 val = 0;
5552
5553 if (h == NULL)
5554 {
5555 asection *sec;
5556
5557 if (symndx == -1)
5558 {
5559 sec = bfd_abs_section_ptr;
5560 val = 0;
5561 }
5562 else
5563 {
5564 sec = sections[symndx];
b5403ad7
ILT		 5565 /* Hack to make sure we use the right TOC anchor value
5566 if this reloc is against the TOC anchor. */
5567 if (sec->name[3] == '0'
5568 && strcmp (sec->name, ".tc0") == 0)
5569 val = xcoff_data (output_bfd)->toc;
5570 else
5571 val = (sec->output_section->vma
5572 + sec->output_offset
5573 + sym->n_value
5574 - sec->vma);
aadf04f7
SS		 5575 }
5576 }
5577 else
5578 {
5579 if (h->root.type == bfd_link_hash_defined
5580 || h->root.type == bfd_link_hash_defweak)
5581 {
5582 asection *sec;
5583
5584 sec = h->root.u.def.section;
5585 val = (h->root.u.def.value
5586 + sec->output_section->vma
5587 + sec->output_offset);
5588 }
aad2c618
ILT		 5589 else if (h->root.type == bfd_link_hash_common)
5590 {
5591 asection *sec;
5592
5593 sec = h->root.u.c.p->section;
5594 val = (sec->output_section->vma
5595 + sec->output_offset);
5596 }
0634a431 5597 else if ((h->flags & XCOFF_DEF_DYNAMIC) != 0
28a0c103
ILT		 5598 || (h->flags & XCOFF_IMPORT) != 0)
5599 {
5600 /* Every symbol in a shared object is defined somewhere. */
5601 val = 0;
5602 }
18a9609c
ILT		 5603 else if (! info->relocateable
5604 && ! info->shared)
aadf04f7
SS		 5605 {
5606 if (! ((*info->callbacks->undefined_symbol)
5607 (info, h->root.root.string, input_bfd, input_section,
5608 rel->r_vaddr - input_section->vma)))
5609 return false;
5610 }
5611 }
5612
5613 /* I took the relocation type definitions from two documents:
5614 the PowerPC AIX Version 4 Application Binary Interface, First
5615 Edition (April 1992), and the PowerOpen ABI, Big-Endian
5616 32-Bit Hardware Implementation (June 30, 1994). Differences
5617 between the documents are noted below. */
5618
5619 switch (rel->r_type)
5620 {
28a0c103
ILT		 5621 case R_RTB:
5622 case R_RRTBI:
5623 case R_RRTBA:
aadf04f7
SS		 5624 /* These relocs are defined by the PowerPC ABI to be
5625 relative branches which use half of the difference
5626 between the symbol and the program counter. I can't
5627 quite figure out when this is useful. These relocs are
5628 not defined by the PowerOpen ABI. */
5629 default:
5630 (*_bfd_error_handler)
5631 ("%s: unsupported relocation type 0x%02x",
5632 bfd_get_filename (input_bfd), (unsigned int) rel->r_type);
5633 bfd_set_error (bfd_error_bad_value);
5634 return false;
28a0c103 5635 case R_POS:
aadf04f7
SS		 5636 /* Simple positive relocation. */
5637 break;
28a0c103 5638 case R_NEG:
aadf04f7
SS		 5639 /* Simple negative relocation. */
5640 val = - val;
5641 break;
28a0c103 5642 case R_REL:
aadf04f7
SS		 5643 /* Simple PC relative relocation. */
5644 howto.pc_relative = true;
5645 break;
28a0c103 5646 case R_TOC:
aadf04f7
SS		 5647 /* TOC relative relocation. The value in the instruction in
5648 the input file is the offset from the input file TOC to
5649 the desired location. We want the offset from the final
5650 TOC to the desired location. We have:
5651 isym = iTOC + in
5652 iinsn = in + o
5653 osym = oTOC + on
5654 oinsn = on + o
5655 so we must change insn by on - in.
5656 */
28a0c103 5657 case R_GL:
aadf04f7
SS		 5658 /* Global linkage relocation. The value of this relocation
5659 is the address of the entry in the TOC section. */
28a0c103 5660 case R_TCL:
aadf04f7 5661 /* Local object TOC address. I can't figure out the
28a0c103
ILT		 5662 difference between this and case R_GL. */
5663 case R_TRL:
aadf04f7
SS		 5664 /* TOC relative relocation. A TOC relative load instruction
5665 which may be changed to a load address instruction.
5666 FIXME: We don't currently implement this optimization. */
28a0c103 5667 case R_TRLA:
aadf04f7
SS		 5668 /* TOC relative relocation. This is a TOC relative load
5669 address instruction which may be changed to a load
5670 instruction. FIXME: I don't know if this is the correct
5671 implementation. */
28a0c103
ILT		 5672 if (h != NULL && h->toc_section == NULL)
5673 {
5674 (*_bfd_error_handler)
5675 ("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry",
5676 bfd_get_filename (input_bfd), rel->r_vaddr,
5677 h->root.root.string);
5678 bfd_set_error (bfd_error_bad_value);
5679 return false;
5680 }
5681 if (h != NULL)
230de6b8
ILT		 5682 {
5683 BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
5684 val = (h->toc_section->output_section->vma
5685 + h->toc_section->output_offset);
5686 }
aadf04f7
SS		 5687 val = ((val - xcoff_data (output_bfd)->toc)
5688 - (sym->n_value - xcoff_data (input_bfd)->toc));
5689 addend = 0;
5690 break;
28a0c103 5691 case R_BA:
aadf04f7
SS		 5692 /* Absolute branch. We don't want to mess with the lower
5693 two bits of the instruction. */
28a0c103 5694 case R_CAI:
aadf04f7
SS		 5695 /* The PowerPC ABI defines this as an absolute call which
5696 may be modified to become a relative call. The PowerOpen
5697 ABI does not define this relocation type. */
28a0c103 5698 case R_RBA:
aadf04f7
SS		 5699 /* Absolute branch which may be modified to become a
5700 relative branch. */
28a0c103 5701 case R_RBAC:
aadf04f7
SS		 5702 /* The PowerPC ABI defines this as an absolute branch to a
5703 fixed address which may be modified to an absolute branch
5704 to a symbol. The PowerOpen ABI does not define this
5705 relocation type. */
28a0c103 5706 case R_RBRC:
aadf04f7
SS		 5707 /* The PowerPC ABI defines this as an absolute branch to a
5708 fixed address which may be modified to a relative branch.
5709 The PowerOpen ABI does not define this relocation type. */
5710 howto.src_mask &= ~3;
5711 howto.dst_mask = howto.src_mask;
5712 break;
28a0c103 5713 case R_BR:
aadf04f7
SS		 5714 /* Relative branch. We don't want to mess with the lower
5715 two bits of the instruction. */
28a0c103 5716 case R_CREL:
aadf04f7
SS		 5717 /* The PowerPC ABI defines this as a relative call which may
5718 be modified to become an absolute call. The PowerOpen
5719 ABI does not define this relocation type. */
28a0c103 5720 case R_RBR:
aadf04f7
SS		 5721 /* A relative branch which may be modified to become an
5722 absolute branch. FIXME: We don't implement this,
5723 although we should for symbols of storage mapping class
5724 XMC_XO. */
5725 howto.pc_relative = true;
5726 howto.src_mask &= ~3;
5727 howto.dst_mask = howto.src_mask;
5728 break;
28a0c103 5729 case R_RL:
aadf04f7
SS		 5730 /* The PowerPC AIX ABI describes this as a load which may be
5731 changed to a load address. The PowerOpen ABI says this
28a0c103 5732 is the same as case R_POS. */
aadf04f7 5733 break;
28a0c103 5734 case R_RLA:
aadf04f7
SS		 5735 /* The PowerPC AIX ABI describes this as a load address
5736 which may be changed to a load. The PowerOpen ABI says
28a0c103 5737 this is the same as R_POS. */
aadf04f7
SS		 5738 break;
5739 }
5740
28a0c103
ILT		 5741 /* If we see an R_BR or R_RBR reloc which is jumping to global
5742 linkage code, and it is followed by an appropriate cror nop
5743 instruction, we replace the cror with lwz r2,20(r1). This
5744 restores the TOC after the glink code. Contrariwise, if the
5745 call is followed by a lwz r2,20(r1), but the call is not
5746 going to global linkage code, we can replace the load with a
5747 cror. */
5748 if ((rel->r_type == R_BR || rel->r_type == R_RBR)
5749 && h != NULL
5750 && h->root.type == bfd_link_hash_defined
5751 && (rel->r_vaddr - input_section->vma + 8
5752 <= input_section->_cooked_size))
5753 {
5754 bfd_byte *pnext;
5755 unsigned long next;
5756
5757 pnext = contents + (rel->r_vaddr - input_section->vma) + 4;
5758 next = bfd_get_32 (input_bfd, pnext);
5759 if (h->smclas == XMC_GL)
5760 {
5761 if (next == 0x4def7b82 /* cror 15,15,15 */
5762 || next == 0x4ffffb82) /* cror 31,31,31 */
5763 bfd_put_32 (input_bfd, 0x80410014, pnext); /* lwz r1,20(r1) */
5764 }
5765 else
5766 {
5767 if (next == 0x80410014) /* lwz r1,20(r1) */
5768 bfd_put_32 (input_bfd, 0x4ffffb82, pnext); /* cror 31,31,31 */
5769 }
5770 }
5771
5772 /* A PC relative reloc includes the section address. */
5773 if (howto.pc_relative)
5774 addend += input_section->vma;
5775
aadf04f7
SS		 5776 rstat = _bfd_final_link_relocate (&howto, input_bfd, input_section,
5777 contents,
5778 rel->r_vaddr - input_section->vma,
5779 val, addend);
5780
5781 switch (rstat)
5782 {
5783 default:
5784 abort ();
5785 case bfd_reloc_ok:
5786 break;
5787 case bfd_reloc_overflow:
5788 {
5789 const char *name;
5790 char buf[SYMNMLEN + 1];
5791 char howto_name[10];
5792
5793 if (symndx == -1)
5794 name = "*ABS*";
5795 else if (h != NULL)
5796 name = h->root.root.string;
5797 else
5798 {
5799 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
5800 if (name == NULL)
5801 return false;
5802 }
5803 sprintf (howto_name, "0x%02x", rel->r_type);
5804
5805 if (! ((*info->callbacks->reloc_overflow)
5806 (info, name, howto_name, (bfd_vma) 0, input_bfd,
5807 input_section, rel->r_vaddr - input_section->vma)))
5808 return false;
5809 }
5810 }
5811 }
5812
5813 return true;
5814}
GDB Binutils - Deliverables
This page took 0.292233 seconds and 4 git commands to generate.