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