1 /* POWER/PowerPC XCOFF linker support.
2 Copyright 1995, 1996, 1997 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>, Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "coff/internal.h"
28 /* This file holds the XCOFF linker code. */
30 #define STRING_SIZE_SIZE (4)
32 /* In order to support linking different object file formats into an
33 XCOFF format, we need to be able to determine whether a particular
34 bfd_target is an XCOFF vector. FIXME: We need to rethink this
36 #define XCOFF_XVECP(xv) \
37 (strcmp ((xv)->name, "aixcoff-rs6000") == 0 \
38 || strcmp ((xv)->name, "xcoff-powermac") == 0)
40 /* Get the XCOFF hash table entries for a BFD. */
41 #define obj_xcoff_sym_hashes(bfd) \
42 ((struct xcoff_link_hash_entry **) obj_coff_sym_hashes (bfd))
44 /* XCOFF relocation types. These probably belong in a header file
45 somewhere. The relocations are described in the function
46 _bfd_ppc_xcoff_relocate_section in this file. */
62 #define R_RRTBI (0x14)
63 #define R_RRTBA (0x15)
71 /* The first word of global linkage code. This must be modified by
72 filling in the correct TOC offset. */
74 #define XCOFF_GLINK_FIRST (0x81820000) /* lwz r12,0(r2) */
76 /* The remaining words of global linkage code. */
78 static unsigned long xcoff_glink_code
[] =
80 0x90410014, /* stw r2,20(r1) */
81 0x800c0000, /* lwz r0,0(r12) */
82 0x804c0004, /* lwz r2,4(r12) */
83 0x7c0903a6, /* mtctr r0 */
84 0x4e800420, /* bctr */
85 0x0, /* start of traceback table */
86 0x000c8000, /* traceback table */
87 0x0 /* traceback table */
90 #define XCOFF_GLINK_SIZE \
91 (((sizeof xcoff_glink_code / sizeof xcoff_glink_code[0]) * 4) + 4)
93 /* We reuse the SEC_ROM flag as a mark flag for garbage collection.
94 This flag will only be used on input sections. */
96 #define SEC_MARK (SEC_ROM)
98 /* The ldhdr structure. This appears at the start of the .loader
101 struct internal_ldhdr
103 /* The version number: currently always 1. */
104 unsigned long l_version
;
105 /* The number of symbol table entries. */
106 bfd_size_type l_nsyms
;
107 /* The number of relocation table entries. */
108 bfd_size_type l_nreloc
;
109 /* The length of the import file string table. */
110 bfd_size_type l_istlen
;
111 /* The number of import files. */
112 bfd_size_type l_nimpid
;
113 /* The offset from the start of the .loader section to the first
114 entry in the import file table. */
115 bfd_size_type l_impoff
;
116 /* The length of the string table. */
117 bfd_size_type l_stlen
;
118 /* The offset from the start of the .loader section to the first
119 entry in the string table. */
120 bfd_size_type l_stoff
;
123 struct external_ldhdr
125 bfd_byte l_version
[4];
127 bfd_byte l_nreloc
[4];
128 bfd_byte l_istlen
[4];
129 bfd_byte l_nimpid
[4];
130 bfd_byte l_impoff
[4];
135 #define LDHDRSZ (8 * 4)
137 /* The ldsym structure. This is used to represent a symbol in the
140 struct internal_ldsym
144 /* The symbol name if <= SYMNMLEN characters. */
145 char _l_name
[SYMNMLEN
];
148 /* Zero if the symbol name is more than SYMNMLEN characters. */
150 /* The offset in the string table if the symbol name is more
151 than SYMNMLEN characters. */
155 /* The symbol value. */
157 /* The symbol section number. */
159 /* The symbol type and flags. */
161 /* The symbol storage class. */
163 /* The import file ID. */
164 bfd_size_type l_ifile
;
165 /* Offset to the parameter type check string. */
166 bfd_size_type l_parm
;
169 struct external_ldsym
173 bfd_byte _l_name
[SYMNMLEN
];
176 bfd_byte _l_zeroes
[4];
177 bfd_byte _l_offset
[4];
182 bfd_byte l_smtype
[1];
183 bfd_byte l_smclas
[1];
188 #define LDSYMSZ (8 + 3 * 4 + 2 + 2)
190 /* These flags are for the l_smtype field (the lower three bits are an
193 /* Imported symbol. */
194 #define L_IMPORT (0x40)
196 #define L_ENTRY (0x20)
197 /* Exported symbol. */
198 #define L_EXPORT (0x10)
200 /* The ldrel structure. This is used to represent a reloc in the
203 struct internal_ldrel
205 /* The reloc address. */
207 /* The symbol table index in the .loader section symbol table. */
208 bfd_size_type l_symndx
;
209 /* The relocation type and size. */
211 /* The section number this relocation applies to. */
215 struct external_ldrel
218 bfd_byte l_symndx
[4];
220 bfd_byte l_rsecnm
[2];
223 #define LDRELSZ (2 * 4 + 2 * 2)
225 /* The list of import files. */
227 struct xcoff_import_file
229 /* The next entry in the list. */
230 struct xcoff_import_file
*next
;
235 /* The member name. */
239 /* An entry in the XCOFF linker hash table. */
241 struct xcoff_link_hash_entry
243 struct bfd_link_hash_entry root
;
245 /* Symbol index in output file. Set to -1 initially. Set to -2 if
246 there is a reloc against this symbol. */
249 /* If we have created a TOC entry for this symbol, this is the .tc
250 section which holds it. */
251 asection
*toc_section
;
255 /* If we have created a TOC entry (the XCOFF_SET_TOC flag is
256 set), this is the offset in toc_section. */
258 /* If the TOC entry comes from an input file, this is set to the
259 symbol index of the C_HIDEXT XMC_TC or XMC_TD symbol. */
263 /* If this symbol is a function entry point which is called, this
264 field holds a pointer to the function descriptor. If this symbol
265 is a function descriptor, this field holds a pointer to the
266 function entry point. */
267 struct xcoff_link_hash_entry
*descriptor
;
269 /* The .loader symbol table entry, if there is one. */
270 struct internal_ldsym
*ldsym
;
272 /* If XCOFF_BUILT_LDSYM is set, this is the .loader symbol table
273 index. If XCOFF_BUILD_LDSYM is clear, and XCOFF_IMPORT is set,
274 this is the l_ifile value. */
277 /* Some linker flags. */
278 unsigned short flags
;
279 /* Symbol is referenced by a regular object. */
280 #define XCOFF_REF_REGULAR (01)
281 /* Symbol is defined by a regular object. */
282 #define XCOFF_DEF_REGULAR (02)
283 /* Symbol is defined by a dynamic object. */
284 #define XCOFF_DEF_DYNAMIC (04)
285 /* Symbol is used in a reloc being copied into the .loader section. */
286 #define XCOFF_LDREL (010)
287 /* Symbol is the entry point. */
288 #define XCOFF_ENTRY (020)
289 /* Symbol is called; this is, it appears in a R_BR reloc. */
290 #define XCOFF_CALLED (040)
291 /* Symbol needs the TOC entry filled in. */
292 #define XCOFF_SET_TOC (0100)
293 /* Symbol is explicitly imported. */
294 #define XCOFF_IMPORT (0200)
295 /* Symbol is explicitly exported. */
296 #define XCOFF_EXPORT (0400)
297 /* Symbol has been processed by xcoff_build_ldsyms. */
298 #define XCOFF_BUILT_LDSYM (01000)
299 /* Symbol is mentioned by a section which was not garbage collected. */
300 #define XCOFF_MARK (02000)
301 /* Symbol size is recorded in size_list list from hash table. */
302 #define XCOFF_HAS_SIZE (04000)
303 /* Symbol is a function descriptor. */
304 #define XCOFF_DESCRIPTOR (010000)
305 /* Multiple definitions have been for the symbol. */
306 #define XCOFF_MULTIPLY_DEFINED (020000)
308 /* The storage mapping class. */
309 unsigned char smclas
;
312 /* The XCOFF linker hash table. */
314 struct xcoff_link_hash_table
316 struct bfd_link_hash_table root
;
318 /* The .debug string hash table. We need to compute this while
319 reading the input files, so that we know how large the .debug
320 section will be before we assign section positions. */
321 struct bfd_strtab_hash
*debug_strtab
;
323 /* The .debug section we will use for the final output. */
324 asection
*debug_section
;
326 /* The .loader section we will use for the final output. */
327 asection
*loader_section
;
329 /* A count of non TOC relative relocs which will need to be
330 allocated in the .loader section. */
333 /* The .loader section header. */
334 struct internal_ldhdr ldhdr
;
336 /* The .gl section we use to hold global linkage code. */
337 asection
*linkage_section
;
339 /* The .tc section we use to hold toc entries we build for global
341 asection
*toc_section
;
343 /* The .ds section we use to hold function descriptors which we
344 create for exported symbols. */
345 asection
*descriptor_section
;
347 /* The list of import files. */
348 struct xcoff_import_file
*imports
;
350 /* Required alignment of sections within the output file. */
351 unsigned long file_align
;
353 /* Whether the .text section must be read-only. */
356 /* Whether garbage collection was done. */
359 /* A linked list of symbols for which we have size information. */
360 struct xcoff_link_size_list
362 struct xcoff_link_size_list
*next
;
363 struct xcoff_link_hash_entry
*h
;
367 /* Magic sections: _text, _etext, _data, _edata, _end, end. */
368 asection
*special_sections
[6];
371 /* Information we keep for each section in the output file during the
374 struct xcoff_link_section_info
376 /* The relocs to be output. */
377 struct internal_reloc
*relocs
;
378 /* For each reloc against a global symbol whose index was not known
379 when the reloc was handled, the global hash table entry. */
380 struct xcoff_link_hash_entry
**rel_hashes
;
381 /* If there is a TOC relative reloc against a global symbol, and the
382 index of the TOC symbol is not known when the reloc was handled,
383 an entry is added to this linked list. This is not an array,
384 like rel_hashes, because this case is quite uncommon. */
385 struct xcoff_toc_rel_hash
387 struct xcoff_toc_rel_hash
*next
;
388 struct xcoff_link_hash_entry
*h
;
389 struct internal_reloc
*rel
;
393 /* Information that we pass around while doing the final link step. */
395 struct xcoff_final_link_info
397 /* General link information. */
398 struct bfd_link_info
*info
;
401 /* Hash table for long symbol names. */
402 struct bfd_strtab_hash
*strtab
;
403 /* Array of information kept for each output section, indexed by the
404 target_index field. */
405 struct xcoff_link_section_info
*section_info
;
406 /* Symbol index of last C_FILE symbol (-1 if none). */
407 long last_file_index
;
408 /* Contents of last C_FILE symbol. */
409 struct internal_syment last_file
;
410 /* Symbol index of TOC symbol. */
412 /* Start of .loader symbols. */
413 struct external_ldsym
*ldsym
;
414 /* Next .loader reloc to swap out. */
415 struct external_ldrel
*ldrel
;
416 /* File position of start of line numbers. */
417 file_ptr line_filepos
;
418 /* Buffer large enough to hold swapped symbols of any input file. */
419 struct internal_syment
*internal_syms
;
420 /* Buffer large enough to hold output indices of symbols of any
423 /* Buffer large enough to hold output symbols for any input file. */
425 /* Buffer large enough to hold external line numbers for any input
428 /* Buffer large enough to hold any input section. */
430 /* Buffer large enough to hold external relocs of any input section. */
431 bfd_byte
*external_relocs
;
434 static void xcoff_swap_ldhdr_in
435 PARAMS ((bfd
*, const struct external_ldhdr
*, struct internal_ldhdr
*));
436 static void xcoff_swap_ldhdr_out
437 PARAMS ((bfd
*, const struct internal_ldhdr
*, struct external_ldhdr
*));
438 static void xcoff_swap_ldsym_in
439 PARAMS ((bfd
*, const struct external_ldsym
*, struct internal_ldsym
*));
440 static void xcoff_swap_ldsym_out
441 PARAMS ((bfd
*, const struct internal_ldsym
*, struct external_ldsym
*));
442 static void xcoff_swap_ldrel_in
443 PARAMS ((bfd
*, const struct external_ldrel
*, struct internal_ldrel
*));
444 static void xcoff_swap_ldrel_out
445 PARAMS ((bfd
*, const struct internal_ldrel
*, struct external_ldrel
*));
446 static struct bfd_hash_entry
*xcoff_link_hash_newfunc
447 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
448 static struct internal_reloc
*xcoff_read_internal_relocs
449 PARAMS ((bfd
*, asection
*, boolean
, bfd_byte
*, boolean
,
450 struct internal_reloc
*));
451 static boolean xcoff_link_add_object_symbols
452 PARAMS ((bfd
*, struct bfd_link_info
*));
453 static boolean xcoff_link_check_archive_element
454 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*));
455 static boolean xcoff_link_check_ar_symbols
456 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*));
457 static boolean xcoff_link_check_dynamic_ar_symbols
458 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*));
459 static bfd_size_type xcoff_find_reloc
460 PARAMS ((struct internal_reloc
*, bfd_size_type
, bfd_vma
));
461 static boolean xcoff_link_add_symbols
PARAMS ((bfd
*, struct bfd_link_info
*));
462 static boolean xcoff_link_add_dynamic_symbols
463 PARAMS ((bfd
*, struct bfd_link_info
*));
464 static boolean xcoff_mark
PARAMS ((struct bfd_link_info
*, asection
*));
465 static void xcoff_sweep
PARAMS ((struct bfd_link_info
*));
466 static boolean xcoff_build_ldsyms
467 PARAMS ((struct xcoff_link_hash_entry
*, PTR
));
468 static boolean xcoff_link_input_bfd
469 PARAMS ((struct xcoff_final_link_info
*, bfd
*));
470 static boolean xcoff_write_global_symbol
471 PARAMS ((struct xcoff_link_hash_entry
*, PTR
));
472 static boolean xcoff_reloc_link_order
473 PARAMS ((bfd
*, struct xcoff_final_link_info
*, asection
*,
474 struct bfd_link_order
*));
475 static int xcoff_sort_relocs
PARAMS ((const PTR
, const PTR
));
477 /* Routines to swap information in the XCOFF .loader section. If we
478 ever need to write an XCOFF loader, this stuff will need to be
479 moved to another file shared by the linker (which XCOFF calls the
480 ``binder'') and the loader. */
482 /* Swap in the ldhdr structure. */
485 xcoff_swap_ldhdr_in (abfd
, src
, dst
)
487 const struct external_ldhdr
*src
;
488 struct internal_ldhdr
*dst
;
490 dst
->l_version
= bfd_get_32 (abfd
, src
->l_version
);
491 dst
->l_nsyms
= bfd_get_32 (abfd
, src
->l_nsyms
);
492 dst
->l_nreloc
= bfd_get_32 (abfd
, src
->l_nreloc
);
493 dst
->l_istlen
= bfd_get_32 (abfd
, src
->l_istlen
);
494 dst
->l_nimpid
= bfd_get_32 (abfd
, src
->l_nimpid
);
495 dst
->l_impoff
= bfd_get_32 (abfd
, src
->l_impoff
);
496 dst
->l_stlen
= bfd_get_32 (abfd
, src
->l_stlen
);
497 dst
->l_stoff
= bfd_get_32 (abfd
, src
->l_stoff
);
500 /* Swap out the ldhdr structure. */
503 xcoff_swap_ldhdr_out (abfd
, src
, dst
)
505 const struct internal_ldhdr
*src
;
506 struct external_ldhdr
*dst
;
508 bfd_put_32 (abfd
, src
->l_version
, dst
->l_version
);
509 bfd_put_32 (abfd
, src
->l_nsyms
, dst
->l_nsyms
);
510 bfd_put_32 (abfd
, src
->l_nreloc
, dst
->l_nreloc
);
511 bfd_put_32 (abfd
, src
->l_istlen
, dst
->l_istlen
);
512 bfd_put_32 (abfd
, src
->l_nimpid
, dst
->l_nimpid
);
513 bfd_put_32 (abfd
, src
->l_impoff
, dst
->l_impoff
);
514 bfd_put_32 (abfd
, src
->l_stlen
, dst
->l_stlen
);
515 bfd_put_32 (abfd
, src
->l_stoff
, dst
->l_stoff
);
518 /* Swap in the ldsym structure. */
521 xcoff_swap_ldsym_in (abfd
, src
, dst
)
523 const struct external_ldsym
*src
;
524 struct internal_ldsym
*dst
;
526 if (bfd_get_32 (abfd
, src
->_l
._l_l
._l_zeroes
) != 0)
527 memcpy (dst
->_l
._l_name
, src
->_l
._l_name
, SYMNMLEN
);
530 dst
->_l
._l_l
._l_zeroes
= 0;
531 dst
->_l
._l_l
._l_offset
= bfd_get_32 (abfd
, src
->_l
._l_l
._l_offset
);
533 dst
->l_value
= bfd_get_32 (abfd
, src
->l_value
);
534 dst
->l_scnum
= bfd_get_16 (abfd
, src
->l_scnum
);
535 dst
->l_smtype
= bfd_get_8 (abfd
, src
->l_smtype
);
536 dst
->l_smclas
= bfd_get_8 (abfd
, src
->l_smclas
);
537 dst
->l_ifile
= bfd_get_32 (abfd
, src
->l_ifile
);
538 dst
->l_parm
= bfd_get_32 (abfd
, src
->l_parm
);
541 /* Swap out the ldsym structure. */
544 xcoff_swap_ldsym_out (abfd
, src
, dst
)
546 const struct internal_ldsym
*src
;
547 struct external_ldsym
*dst
;
549 if (src
->_l
._l_l
._l_zeroes
!= 0)
550 memcpy (dst
->_l
._l_name
, src
->_l
._l_name
, SYMNMLEN
);
553 bfd_put_32 (abfd
, 0, dst
->_l
._l_l
._l_zeroes
);
554 bfd_put_32 (abfd
, src
->_l
._l_l
._l_offset
, dst
->_l
._l_l
._l_offset
);
556 bfd_put_32 (abfd
, src
->l_value
, dst
->l_value
);
557 bfd_put_16 (abfd
, src
->l_scnum
, dst
->l_scnum
);
558 bfd_put_8 (abfd
, src
->l_smtype
, dst
->l_smtype
);
559 bfd_put_8 (abfd
, src
->l_smclas
, dst
->l_smclas
);
560 bfd_put_32 (abfd
, src
->l_ifile
, dst
->l_ifile
);
561 bfd_put_32 (abfd
, src
->l_parm
, dst
->l_parm
);
564 /* Swap in the ldrel structure. */
567 xcoff_swap_ldrel_in (abfd
, src
, dst
)
569 const struct external_ldrel
*src
;
570 struct internal_ldrel
*dst
;
572 dst
->l_vaddr
= bfd_get_32 (abfd
, src
->l_vaddr
);
573 dst
->l_symndx
= bfd_get_32 (abfd
, src
->l_symndx
);
574 dst
->l_rtype
= bfd_get_16 (abfd
, src
->l_rtype
);
575 dst
->l_rsecnm
= bfd_get_16 (abfd
, src
->l_rsecnm
);
578 /* Swap out the ldrel structure. */
581 xcoff_swap_ldrel_out (abfd
, src
, dst
)
583 const struct internal_ldrel
*src
;
584 struct external_ldrel
*dst
;
586 bfd_put_32 (abfd
, src
->l_vaddr
, dst
->l_vaddr
);
587 bfd_put_32 (abfd
, src
->l_symndx
, dst
->l_symndx
);
588 bfd_put_16 (abfd
, src
->l_rtype
, dst
->l_rtype
);
589 bfd_put_16 (abfd
, src
->l_rsecnm
, dst
->l_rsecnm
);
592 /* Routines to read XCOFF dynamic information. This don't really
593 belong here, but we already have the ldsym manipulation routines
596 /* Read the contents of a section. */
599 xcoff_get_section_contents (abfd
, sec
)
603 if (coff_section_data (abfd
, sec
) == NULL
)
605 sec
->used_by_bfd
= bfd_zalloc (abfd
,
606 sizeof (struct coff_section_tdata
));
607 if (sec
->used_by_bfd
== NULL
)
611 if (coff_section_data (abfd
, sec
)->contents
== NULL
)
613 coff_section_data (abfd
, sec
)->contents
= bfd_malloc (sec
->_raw_size
);
614 if (coff_section_data (abfd
, sec
)->contents
== NULL
)
617 if (! bfd_get_section_contents (abfd
, sec
,
618 coff_section_data (abfd
, sec
)->contents
,
619 (file_ptr
) 0, sec
->_raw_size
))
626 /* Get the size required to hold the dynamic symbols. */
629 _bfd_xcoff_get_dynamic_symtab_upper_bound (abfd
)
634 struct internal_ldhdr ldhdr
;
636 if ((abfd
->flags
& DYNAMIC
) == 0)
638 bfd_set_error (bfd_error_invalid_operation
);
642 lsec
= bfd_get_section_by_name (abfd
, ".loader");
645 bfd_set_error (bfd_error_no_symbols
);
649 if (! xcoff_get_section_contents (abfd
, lsec
))
651 contents
= coff_section_data (abfd
, lsec
)->contents
;
653 xcoff_swap_ldhdr_in (abfd
, (struct external_ldhdr
*) contents
, &ldhdr
);
655 return (ldhdr
.l_nsyms
+ 1) * sizeof (asymbol
*);
658 /* Get the dynamic symbols. */
661 _bfd_xcoff_canonicalize_dynamic_symtab (abfd
, psyms
)
667 struct internal_ldhdr ldhdr
;
669 struct external_ldsym
*elsym
, *elsymend
;
670 coff_symbol_type
*symbuf
;
672 if ((abfd
->flags
& DYNAMIC
) == 0)
674 bfd_set_error (bfd_error_invalid_operation
);
678 lsec
= bfd_get_section_by_name (abfd
, ".loader");
681 bfd_set_error (bfd_error_no_symbols
);
685 if (! xcoff_get_section_contents (abfd
, lsec
))
687 contents
= coff_section_data (abfd
, lsec
)->contents
;
689 coff_section_data (abfd
, lsec
)->keep_contents
= true;
691 xcoff_swap_ldhdr_in (abfd
, (struct external_ldhdr
*) contents
, &ldhdr
);
693 strings
= (char *) contents
+ ldhdr
.l_stoff
;
695 symbuf
= ((coff_symbol_type
*)
696 bfd_zalloc (abfd
, ldhdr
.l_nsyms
* sizeof (coff_symbol_type
)));
700 elsym
= (struct external_ldsym
*) (contents
+ LDHDRSZ
);
701 elsymend
= elsym
+ ldhdr
.l_nsyms
;
702 for (; elsym
< elsymend
; elsym
++, symbuf
++, psyms
++)
704 struct internal_ldsym ldsym
;
706 xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
708 symbuf
->symbol
.the_bfd
= abfd
;
710 if (ldsym
._l
._l_l
._l_zeroes
== 0)
711 symbuf
->symbol
.name
= strings
+ ldsym
._l
._l_l
._l_offset
;
716 for (i
= 0; i
< SYMNMLEN
; i
++)
717 if (ldsym
._l
._l_name
[i
] == '\0')
720 symbuf
->symbol
.name
= elsym
->_l
._l_name
;
725 c
= bfd_alloc (abfd
, SYMNMLEN
+ 1);
728 memcpy (c
, ldsym
._l
._l_name
, SYMNMLEN
);
730 symbuf
->symbol
.name
= c
;
734 if (ldsym
.l_smclas
== XMC_XO
)
735 symbuf
->symbol
.section
= bfd_abs_section_ptr
;
737 symbuf
->symbol
.section
= coff_section_from_bfd_index (abfd
,
739 symbuf
->symbol
.value
= ldsym
.l_value
- symbuf
->symbol
.section
->vma
;
741 symbuf
->symbol
.flags
= BSF_NO_FLAGS
;
742 if ((ldsym
.l_smtype
& L_EXPORT
) != 0)
743 symbuf
->symbol
.flags
|= BSF_GLOBAL
;
745 /* FIXME: We have no way to record the other information stored
746 with the loader symbol. */
748 *psyms
= (asymbol
*) symbuf
;
753 return ldhdr
.l_nsyms
;
756 /* Get the size required to hold the dynamic relocs. */
759 _bfd_xcoff_get_dynamic_reloc_upper_bound (abfd
)
764 struct internal_ldhdr ldhdr
;
766 if ((abfd
->flags
& DYNAMIC
) == 0)
768 bfd_set_error (bfd_error_invalid_operation
);
772 lsec
= bfd_get_section_by_name (abfd
, ".loader");
775 bfd_set_error (bfd_error_no_symbols
);
779 if (! xcoff_get_section_contents (abfd
, lsec
))
781 contents
= coff_section_data (abfd
, lsec
)->contents
;
783 xcoff_swap_ldhdr_in (abfd
, (struct external_ldhdr
*) contents
, &ldhdr
);
785 return (ldhdr
.l_nreloc
+ 1) * sizeof (arelent
*);
788 /* The typical dynamic reloc. */
790 static reloc_howto_type xcoff_dynamic_reloc
=
793 2, /* size (0 = byte, 1 = short, 2 = long) */
795 false, /* pc_relative */
797 complain_overflow_bitfield
, /* complain_on_overflow */
798 0, /* special_function */
800 true, /* partial_inplace */
801 0xffffffff, /* src_mask */
802 0xffffffff, /* dst_mask */
803 false); /* pcrel_offset */
805 /* Get the dynamic relocs. */
808 _bfd_xcoff_canonicalize_dynamic_reloc (abfd
, prelocs
, syms
)
815 struct internal_ldhdr ldhdr
;
817 struct external_ldrel
*elrel
, *elrelend
;
819 if ((abfd
->flags
& DYNAMIC
) == 0)
821 bfd_set_error (bfd_error_invalid_operation
);
825 lsec
= bfd_get_section_by_name (abfd
, ".loader");
828 bfd_set_error (bfd_error_no_symbols
);
832 if (! xcoff_get_section_contents (abfd
, lsec
))
834 contents
= coff_section_data (abfd
, lsec
)->contents
;
836 xcoff_swap_ldhdr_in (abfd
, (struct external_ldhdr
*) contents
, &ldhdr
);
838 relbuf
= (arelent
*) bfd_alloc (abfd
, ldhdr
.l_nreloc
* sizeof (arelent
));
842 elrel
= ((struct external_ldrel
*)
843 (contents
+ LDHDRSZ
+ ldhdr
.l_nsyms
* LDSYMSZ
));
844 elrelend
= elrel
+ ldhdr
.l_nreloc
;
845 for (; elrel
< elrelend
; elrel
++, relbuf
++, prelocs
++)
847 struct internal_ldrel ldrel
;
849 xcoff_swap_ldrel_in (abfd
, elrel
, &ldrel
);
851 if (ldrel
.l_symndx
>= 3)
852 relbuf
->sym_ptr_ptr
= syms
+ (ldrel
.l_symndx
- 3);
858 switch (ldrel
.l_symndx
)
874 sec
= bfd_get_section_by_name (abfd
, name
);
877 bfd_set_error (bfd_error_bad_value
);
881 relbuf
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
884 relbuf
->address
= ldrel
.l_vaddr
;
887 /* Most dynamic relocs have the same type. FIXME: This is only
888 correct if ldrel.l_rtype == 0. In other cases, we should use
889 a different howto. */
890 relbuf
->howto
= &xcoff_dynamic_reloc
;
892 /* FIXME: We have no way to record the l_rsecnm field. */
899 return ldhdr
.l_nreloc
;
902 /* Routine to create an entry in an XCOFF link hash table. */
904 static struct bfd_hash_entry
*
905 xcoff_link_hash_newfunc (entry
, table
, string
)
906 struct bfd_hash_entry
*entry
;
907 struct bfd_hash_table
*table
;
910 struct xcoff_link_hash_entry
*ret
= (struct xcoff_link_hash_entry
*) entry
;
912 /* Allocate the structure if it has not already been allocated by a
914 if (ret
== (struct xcoff_link_hash_entry
*) NULL
)
915 ret
= ((struct xcoff_link_hash_entry
*)
916 bfd_hash_allocate (table
, sizeof (struct xcoff_link_hash_entry
)));
917 if (ret
== (struct xcoff_link_hash_entry
*) NULL
)
918 return (struct bfd_hash_entry
*) ret
;
920 /* Call the allocation method of the superclass. */
921 ret
= ((struct xcoff_link_hash_entry
*)
922 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
926 /* Set local fields. */
928 ret
->toc_section
= NULL
;
929 ret
->u
.toc_indx
= -1;
930 ret
->descriptor
= NULL
;
934 ret
->smclas
= XMC_UA
;
937 return (struct bfd_hash_entry
*) ret
;
940 /* Create a XCOFF link hash table. */
942 struct bfd_link_hash_table
*
943 _bfd_xcoff_bfd_link_hash_table_create (abfd
)
946 struct xcoff_link_hash_table
*ret
;
948 ret
= ((struct xcoff_link_hash_table
*)
949 bfd_alloc (abfd
, sizeof (struct xcoff_link_hash_table
)));
950 if (ret
== (struct xcoff_link_hash_table
*) NULL
)
951 return (struct bfd_link_hash_table
*) NULL
;
952 if (! _bfd_link_hash_table_init (&ret
->root
, abfd
, xcoff_link_hash_newfunc
))
954 bfd_release (abfd
, ret
);
955 return (struct bfd_link_hash_table
*) NULL
;
958 ret
->debug_strtab
= _bfd_xcoff_stringtab_init ();
959 ret
->debug_section
= NULL
;
960 ret
->loader_section
= NULL
;
961 ret
->ldrel_count
= 0;
962 memset (&ret
->ldhdr
, 0, sizeof (struct internal_ldhdr
));
963 ret
->linkage_section
= NULL
;
964 ret
->toc_section
= NULL
;
965 ret
->descriptor_section
= NULL
;
970 memset (ret
->special_sections
, 0, sizeof ret
->special_sections
);
972 /* The linker will always generate a full a.out header. We need to
973 record that fact now, before the sizeof_headers routine could be
975 xcoff_data (abfd
)->full_aouthdr
= true;
980 /* Look up an entry in an XCOFF link hash table. */
982 #define xcoff_link_hash_lookup(table, string, create, copy, follow) \
983 ((struct xcoff_link_hash_entry *) \
984 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy),\
987 /* Traverse an XCOFF link hash table. */
989 #define xcoff_link_hash_traverse(table, func, info) \
990 (bfd_link_hash_traverse \
992 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
995 /* Get the XCOFF link hash table from the info structure. This is
998 #define xcoff_hash_table(p) ((struct xcoff_link_hash_table *) ((p)->hash))
1000 /* Read internal relocs for an XCOFF csect. This is a wrapper around
1001 _bfd_coff_read_internal_relocs which tries to take advantage of any
1002 relocs which may have been cached for the enclosing section. */
1004 static struct internal_reloc
*
1005 xcoff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
1006 require_internal
, internal_relocs
)
1010 bfd_byte
*external_relocs
;
1011 boolean require_internal
;
1012 struct internal_reloc
*internal_relocs
;
1014 if (coff_section_data (abfd
, sec
) != NULL
1015 && coff_section_data (abfd
, sec
)->relocs
== NULL
1016 && xcoff_section_data (abfd
, sec
) != NULL
)
1018 asection
*enclosing
;
1020 enclosing
= xcoff_section_data (abfd
, sec
)->enclosing
;
1022 if (enclosing
!= NULL
1023 && (coff_section_data (abfd
, enclosing
) == NULL
1024 || coff_section_data (abfd
, enclosing
)->relocs
== NULL
)
1026 && enclosing
->reloc_count
> 0)
1028 if (_bfd_coff_read_internal_relocs (abfd
, enclosing
, true,
1029 external_relocs
, false,
1030 (struct internal_reloc
*) NULL
)
1035 if (enclosing
!= NULL
1036 && coff_section_data (abfd
, enclosing
) != NULL
1037 && coff_section_data (abfd
, enclosing
)->relocs
!= NULL
)
1041 off
= ((sec
->rel_filepos
- enclosing
->rel_filepos
)
1042 / bfd_coff_relsz (abfd
));
1043 if (! require_internal
)
1044 return coff_section_data (abfd
, enclosing
)->relocs
+ off
;
1045 memcpy (internal_relocs
,
1046 coff_section_data (abfd
, enclosing
)->relocs
+ off
,
1047 sec
->reloc_count
* sizeof (struct internal_reloc
));
1048 return internal_relocs
;
1052 return _bfd_coff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
1053 require_internal
, internal_relocs
);
1056 /* Given an XCOFF BFD, add symbols to the global hash table as
1060 _bfd_xcoff_bfd_link_add_symbols (abfd
, info
)
1062 struct bfd_link_info
*info
;
1064 switch (bfd_get_format (abfd
))
1067 return xcoff_link_add_object_symbols (abfd
, info
);
1070 /* If the archive has a map, do the usual search. We then need
1071 to check the archive for stripped dynamic objects, because
1072 they will not appear in the archive map even though they
1073 should, perhaps, be included. If the archive has no map, we
1074 just consider each object file in turn, since that apparently
1075 is what the AIX native linker does. */
1076 if (bfd_has_map (abfd
))
1078 if (! (_bfd_generic_link_add_archive_symbols
1079 (abfd
, info
, xcoff_link_check_archive_element
)))
1086 member
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
1087 while (member
!= NULL
)
1089 if (bfd_check_format (member
, bfd_object
)
1090 && (! bfd_has_map (abfd
)
1091 || ((member
->flags
& DYNAMIC
) != 0
1092 && (member
->flags
& HAS_SYMS
) == 0)))
1096 if (! xcoff_link_check_archive_element (member
, info
, &needed
))
1099 member
->archive_pass
= -1;
1101 member
= bfd_openr_next_archived_file (abfd
, member
);
1108 bfd_set_error (bfd_error_wrong_format
);
1113 /* Add symbols from an XCOFF object file. */
1116 xcoff_link_add_object_symbols (abfd
, info
)
1118 struct bfd_link_info
*info
;
1120 if (! _bfd_coff_get_external_symbols (abfd
))
1122 if (! xcoff_link_add_symbols (abfd
, info
))
1124 if (! info
->keep_memory
)
1126 if (! _bfd_coff_free_symbols (abfd
))
1132 /* Check a single archive element to see if we need to include it in
1133 the link. *PNEEDED is set according to whether this element is
1134 needed in the link or not. This is called via
1135 _bfd_generic_link_add_archive_symbols. */
1138 xcoff_link_check_archive_element (abfd
, info
, pneeded
)
1140 struct bfd_link_info
*info
;
1143 if (! _bfd_coff_get_external_symbols (abfd
))
1146 if (! xcoff_link_check_ar_symbols (abfd
, info
, pneeded
))
1151 if (! xcoff_link_add_symbols (abfd
, info
))
1155 if (! info
->keep_memory
|| ! *pneeded
)
1157 if (! _bfd_coff_free_symbols (abfd
))
1164 /* Look through the symbols to see if this object file should be
1165 included in the link. */
1168 xcoff_link_check_ar_symbols (abfd
, info
, pneeded
)
1170 struct bfd_link_info
*info
;
1173 bfd_size_type symesz
;
1179 if ((abfd
->flags
& DYNAMIC
) != 0
1180 && ! info
->static_link
1181 && info
->hash
->creator
== abfd
->xvec
)
1182 return xcoff_link_check_dynamic_ar_symbols (abfd
, info
, pneeded
);
1184 symesz
= bfd_coff_symesz (abfd
);
1185 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
1186 esym_end
= esym
+ obj_raw_syment_count (abfd
) * symesz
;
1187 while (esym
< esym_end
)
1189 struct internal_syment sym
;
1191 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &sym
);
1193 if (sym
.n_sclass
== C_EXT
&& sym
.n_scnum
!= N_UNDEF
)
1196 char buf
[SYMNMLEN
+ 1];
1197 struct bfd_link_hash_entry
*h
;
1199 /* This symbol is externally visible, and is defined by this
1202 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
1205 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
1207 /* We are only interested in symbols that are currently
1208 undefined. If a symbol is currently known to be common,
1209 XCOFF linkers do not bring in an object file which
1210 defines it. We also don't bring in symbols to satisfy
1211 undefined references in shared objects. */
1212 if (h
!= (struct bfd_link_hash_entry
*) NULL
1213 && h
->type
== bfd_link_hash_undefined
1214 && (info
->hash
->creator
!= abfd
->xvec
1215 || (((struct xcoff_link_hash_entry
*) h
)->flags
1216 & XCOFF_DEF_DYNAMIC
) == 0))
1218 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
1225 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1228 /* We do not need this object file. */
1232 /* Look through the loader symbols to see if this dynamic object
1233 should be included in the link. The native linker uses the loader
1234 symbols, not the normal symbol table, so we do too. */
1237 xcoff_link_check_dynamic_ar_symbols (abfd
, info
, pneeded
)
1239 struct bfd_link_info
*info
;
1244 struct internal_ldhdr ldhdr
;
1245 const char *strings
;
1246 struct external_ldsym
*elsym
, *elsymend
;
1250 lsec
= bfd_get_section_by_name (abfd
, ".loader");
1253 /* There are no symbols, so don't try to include it. */
1257 if (! xcoff_get_section_contents (abfd
, lsec
))
1259 buf
= coff_section_data (abfd
, lsec
)->contents
;
1261 xcoff_swap_ldhdr_in (abfd
, (struct external_ldhdr
*) buf
, &ldhdr
);
1263 strings
= (char *) buf
+ ldhdr
.l_stoff
;
1265 elsym
= (struct external_ldsym
*) (buf
+ LDHDRSZ
);
1266 elsymend
= elsym
+ ldhdr
.l_nsyms
;
1267 for (; elsym
< elsymend
; elsym
++)
1269 struct internal_ldsym ldsym
;
1270 char nambuf
[SYMNMLEN
+ 1];
1272 struct bfd_link_hash_entry
*h
;
1274 xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
1276 /* We are only interested in exported symbols. */
1277 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
1280 if (ldsym
._l
._l_l
._l_zeroes
== 0)
1281 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
1284 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
1285 nambuf
[SYMNMLEN
] = '\0';
1289 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
1291 /* We are only interested in symbols that are currently
1292 undefined. At this point we know that we are using an XCOFF
1295 && h
->type
== bfd_link_hash_undefined
1296 && (((struct xcoff_link_hash_entry
*) h
)->flags
1297 & XCOFF_DEF_DYNAMIC
) == 0)
1299 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
1306 /* We do not need this shared object. */
1308 if (buf
!= NULL
&& ! coff_section_data (abfd
, lsec
)->keep_contents
)
1310 free (coff_section_data (abfd
, lsec
)->contents
);
1311 coff_section_data (abfd
, lsec
)->contents
= NULL
;
1317 /* Returns the index of reloc in RELOCS with the least address greater
1318 than or equal to ADDRESS. The relocs are sorted by address. */
1320 static bfd_size_type
1321 xcoff_find_reloc (relocs
, count
, address
)
1322 struct internal_reloc
*relocs
;
1323 bfd_size_type count
;
1326 bfd_size_type min
, max
, this;
1330 if (count
== 1 && relocs
[0].r_vaddr
< address
)
1339 /* Do a binary search over (min,max]. */
1340 while (min
+ 1 < max
)
1344 this = (max
+ min
) / 2;
1345 raddr
= relocs
[this].r_vaddr
;
1346 if (raddr
> address
)
1348 else if (raddr
< address
)
1357 if (relocs
[min
].r_vaddr
< address
)
1361 && relocs
[min
- 1].r_vaddr
== address
)
1367 /* Add all the symbols from an object file to the hash table.
1369 XCOFF is a weird format. A normal XCOFF .o files will have three
1370 COFF sections--.text, .data, and .bss--but each COFF section will
1371 contain many csects. These csects are described in the symbol
1372 table. From the linker's point of view, each csect must be
1373 considered a section in its own right. For example, a TOC entry is
1374 handled as a small XMC_TC csect. The linker must be able to merge
1375 different TOC entries together, which means that it must be able to
1376 extract the XMC_TC csects from the .data section of the input .o
1379 From the point of view of our linker, this is, of course, a hideous
1380 nightmare. We cope by actually creating sections for each csect,
1381 and discarding the original sections. We then have to handle the
1382 relocation entries carefully, since the only way to tell which
1383 csect they belong to is to examine the address. */
1386 xcoff_link_add_symbols (abfd
, info
)
1388 struct bfd_link_info
*info
;
1390 unsigned int n_tmask
;
1391 unsigned int n_btshft
;
1392 boolean default_copy
;
1393 bfd_size_type symcount
;
1394 struct xcoff_link_hash_entry
**sym_hash
;
1395 asection
**csect_cache
;
1396 bfd_size_type linesz
;
1398 asection
*last_real
;
1401 unsigned int csect_index
;
1402 asection
*first_csect
;
1403 bfd_size_type symesz
;
1406 struct reloc_info_struct
1408 struct internal_reloc
*relocs
;
1411 } *reloc_info
= NULL
;
1413 keep_syms
= obj_coff_keep_syms (abfd
);
1415 if ((abfd
->flags
& DYNAMIC
) != 0
1416 && ! info
->static_link
)
1418 if (! xcoff_link_add_dynamic_symbols (abfd
, info
))
1422 if (info
->hash
->creator
== abfd
->xvec
)
1424 /* We need to build a .loader section, so we do it here. This
1425 won't work if we're producing an XCOFF output file with no
1426 XCOFF input files. FIXME. */
1427 if (xcoff_hash_table (info
)->loader_section
== NULL
)
1431 lsec
= bfd_make_section_anyway (abfd
, ".loader");
1434 xcoff_hash_table (info
)->loader_section
= lsec
;
1435 lsec
->flags
|= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
1437 /* Likewise for the linkage section. */
1438 if (xcoff_hash_table (info
)->linkage_section
== NULL
)
1442 lsec
= bfd_make_section_anyway (abfd
, ".gl");
1445 xcoff_hash_table (info
)->linkage_section
= lsec
;
1446 lsec
->flags
|= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1448 lsec
->alignment_power
= 2;
1450 /* Likewise for the TOC section. */
1451 if (xcoff_hash_table (info
)->toc_section
== NULL
)
1455 tsec
= bfd_make_section_anyway (abfd
, ".tc");
1458 xcoff_hash_table (info
)->toc_section
= tsec
;
1459 tsec
->flags
|= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1461 tsec
->alignment_power
= 2;
1463 /* Likewise for the descriptor section. */
1464 if (xcoff_hash_table (info
)->descriptor_section
== NULL
)
1468 dsec
= bfd_make_section_anyway (abfd
, ".ds");
1471 xcoff_hash_table (info
)->descriptor_section
= dsec
;
1472 dsec
->flags
|= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1474 dsec
->alignment_power
= 2;
1476 /* Likewise for the .debug section. */
1477 if (xcoff_hash_table (info
)->debug_section
== NULL
)
1481 dsec
= bfd_make_section_anyway (abfd
, ".debug");
1484 xcoff_hash_table (info
)->debug_section
= dsec
;
1485 dsec
->flags
|= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
1489 if ((abfd
->flags
& DYNAMIC
) != 0
1490 && ! info
->static_link
)
1493 n_tmask
= coff_data (abfd
)->local_n_tmask
;
1494 n_btshft
= coff_data (abfd
)->local_n_btshft
;
1496 /* Define macros so that ISFCN, et. al., macros work correctly. */
1497 #define N_TMASK n_tmask
1498 #define N_BTSHFT n_btshft
1500 if (info
->keep_memory
)
1501 default_copy
= false;
1503 default_copy
= true;
1505 symcount
= obj_raw_syment_count (abfd
);
1507 /* We keep a list of the linker hash table entries that correspond
1508 to each external symbol. */
1509 sym_hash
= ((struct xcoff_link_hash_entry
**)
1512 * sizeof (struct xcoff_link_hash_entry
*))));
1513 if (sym_hash
== NULL
&& symcount
!= 0)
1515 coff_data (abfd
)->sym_hashes
= (struct coff_link_hash_entry
**) sym_hash
;
1516 memset (sym_hash
, 0,
1517 (size_t) symcount
* sizeof (struct xcoff_link_hash_entry
*));
1519 /* Because of the weird stuff we are doing with XCOFF csects, we can
1520 not easily determine which section a symbol is in, so we store
1521 the information in the tdata for the input file. */
1522 csect_cache
= ((asection
**)
1523 bfd_alloc (abfd
, symcount
* sizeof (asection
*)));
1524 if (csect_cache
== NULL
&& symcount
!= 0)
1526 xcoff_data (abfd
)->csects
= csect_cache
;
1527 memset (csect_cache
, 0, (size_t) symcount
* sizeof (asection
*));
1529 /* While splitting sections into csects, we need to assign the
1530 relocs correctly. The relocs and the csects must both be in
1531 order by VMA within a given section, so we handle this by
1532 scanning along the relocs as we process the csects. We index
1533 into reloc_info using the section target_index. */
1534 reloc_info
= ((struct reloc_info_struct
*)
1535 bfd_malloc ((abfd
->section_count
+ 1)
1536 * sizeof (struct reloc_info_struct
)));
1537 if (reloc_info
== NULL
)
1539 memset ((PTR
) reloc_info
, 0,
1540 (abfd
->section_count
+ 1) * sizeof (struct reloc_info_struct
));
1542 /* Read in the relocs and line numbers for each section. */
1543 linesz
= bfd_coff_linesz (abfd
);
1545 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1548 if ((o
->flags
& SEC_RELOC
) != 0)
1550 reloc_info
[o
->target_index
].relocs
=
1551 xcoff_read_internal_relocs (abfd
, o
, true, (bfd_byte
*) NULL
,
1552 false, (struct internal_reloc
*) NULL
);
1553 reloc_info
[o
->target_index
].csects
=
1554 (asection
**) bfd_malloc (o
->reloc_count
* sizeof (asection
*));
1555 if (reloc_info
[o
->target_index
].csects
== NULL
)
1557 memset (reloc_info
[o
->target_index
].csects
, 0,
1558 o
->reloc_count
* sizeof (asection
*));
1561 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1562 && o
->lineno_count
> 0)
1566 linenos
= (bfd_byte
*) bfd_malloc (o
->lineno_count
* linesz
);
1567 if (linenos
== NULL
)
1569 reloc_info
[o
->target_index
].linenos
= linenos
;
1570 if (bfd_seek (abfd
, o
->line_filepos
, SEEK_SET
) != 0
1571 || (bfd_read (linenos
, linesz
, o
->lineno_count
, abfd
)
1572 != linesz
* o
->lineno_count
))
1577 /* Don't let the linker relocation routines discard the symbols. */
1578 obj_coff_keep_syms (abfd
) = true;
1584 symesz
= bfd_coff_symesz (abfd
);
1585 BFD_ASSERT (symesz
== bfd_coff_auxesz (abfd
));
1586 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
1587 esym_end
= esym
+ symcount
* symesz
;
1588 while (esym
< esym_end
)
1590 struct internal_syment sym
;
1591 union internal_auxent aux
;
1593 char buf
[SYMNMLEN
+ 1];
1598 struct xcoff_link_hash_entry
*set_toc
;
1600 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &sym
);
1602 /* In this pass we are only interested in symbols with csect
1604 if (sym
.n_sclass
!= C_EXT
&& sym
.n_sclass
!= C_HIDEXT
)
1606 if (sym
.n_sclass
== C_FILE
&& csect
!= NULL
)
1608 xcoff_section_data (abfd
, csect
)->last_symndx
=
1610 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1616 *csect_cache
= csect
;
1617 else if (first_csect
== NULL
|| sym
.n_sclass
== C_FILE
)
1618 *csect_cache
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1620 *csect_cache
= NULL
;
1621 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1622 sym_hash
+= sym
.n_numaux
+ 1;
1623 csect_cache
+= sym
.n_numaux
+ 1;
1627 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
1631 /* If this symbol has line number information attached to it,
1632 and we're not stripping it, count the number of entries and
1633 add them to the count for this csect. In the final link pass
1634 we are going to attach line number information by symbol,
1635 rather than by section, in order to more easily handle
1636 garbage collection. */
1637 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1640 && ISFCN (sym
.n_type
))
1642 union internal_auxent auxlin
;
1644 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ symesz
),
1645 sym
.n_type
, sym
.n_sclass
,
1646 0, sym
.n_numaux
, (PTR
) &auxlin
);
1647 if (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
1649 asection
*enclosing
;
1650 bfd_size_type linoff
;
1652 enclosing
= xcoff_section_data (abfd
, csect
)->enclosing
;
1653 if (enclosing
== NULL
)
1655 (*_bfd_error_handler
)
1656 ("%s: `%s' has line numbers but no enclosing section",
1657 bfd_get_filename (abfd
), name
);
1658 bfd_set_error (bfd_error_bad_value
);
1661 linoff
= (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
1662 - enclosing
->line_filepos
);
1663 if (linoff
< enclosing
->lineno_count
* linesz
)
1665 struct internal_lineno lin
;
1666 bfd_byte
*linpstart
;
1668 linpstart
= (reloc_info
[enclosing
->target_index
].linenos
1670 bfd_coff_swap_lineno_in (abfd
, (PTR
) linpstart
, (PTR
) &lin
);
1672 && ((bfd_size_type
) lin
.l_addr
.l_symndx
1674 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1677 bfd_byte
*linpend
, *linp
;
1679 linpend
= (reloc_info
[enclosing
->target_index
].linenos
1680 + enclosing
->lineno_count
* linesz
);
1681 for (linp
= linpstart
+ linesz
;
1685 bfd_coff_swap_lineno_in (abfd
, (PTR
) linp
,
1687 if (lin
.l_lnno
== 0)
1690 csect
->lineno_count
+= (linp
- linpstart
) / linesz
;
1691 /* The setting of line_filepos will only be
1692 useful if all the line number entries for a
1693 csect are contiguous; this only matters for
1695 if (csect
->line_filepos
== 0)
1696 csect
->line_filepos
=
1697 auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1703 /* Pick up the csect auxiliary information. */
1705 if (sym
.n_numaux
== 0)
1707 (*_bfd_error_handler
)
1708 ("%s: class %d symbol `%s' has no aux entries",
1709 bfd_get_filename (abfd
), sym
.n_sclass
, name
);
1710 bfd_set_error (bfd_error_bad_value
);
1714 bfd_coff_swap_aux_in (abfd
,
1715 (PTR
) (esym
+ symesz
* sym
.n_numaux
),
1716 sym
.n_type
, sym
.n_sclass
,
1717 sym
.n_numaux
- 1, sym
.n_numaux
,
1720 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
1730 (*_bfd_error_handler
)
1731 ("%s: symbol `%s' has unrecognized csect type %d",
1732 bfd_get_filename (abfd
), name
, smtyp
);
1733 bfd_set_error (bfd_error_bad_value
);
1737 /* This is an external reference. */
1738 if (sym
.n_sclass
== C_HIDEXT
1739 || sym
.n_scnum
!= N_UNDEF
1740 || aux
.x_csect
.x_scnlen
.l
!= 0)
1742 (*_bfd_error_handler
)
1743 ("%s: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d",
1744 bfd_get_filename (abfd
), name
, sym
.n_sclass
, sym
.n_scnum
,
1745 aux
.x_csect
.x_scnlen
.l
);
1746 bfd_set_error (bfd_error_bad_value
);
1750 /* An XMC_XO external reference is actually a reference to
1751 an absolute location. */
1752 if (aux
.x_csect
.x_smclas
!= XMC_XO
)
1753 section
= bfd_und_section_ptr
;
1756 section
= bfd_abs_section_ptr
;
1757 value
= sym
.n_value
;
1762 /* This is a csect definition. */
1766 xcoff_section_data (abfd
, csect
)->last_symndx
=
1768 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1775 /* When we see a TOC anchor, we record the TOC value. */
1776 if (aux
.x_csect
.x_smclas
== XMC_TC0
)
1778 if (sym
.n_sclass
!= C_HIDEXT
1779 || aux
.x_csect
.x_scnlen
.l
!= 0)
1781 (*_bfd_error_handler
)
1782 ("%s: XMC_TC0 symbol `%s' is class %d scnlen %d",
1783 bfd_get_filename (abfd
), name
, sym
.n_sclass
,
1784 aux
.x_csect
.x_scnlen
.l
);
1785 bfd_set_error (bfd_error_bad_value
);
1788 xcoff_data (abfd
)->toc
= sym
.n_value
;
1791 /* We must merge TOC entries for the same symbol. We can
1792 merge two TOC entries if they are both C_HIDEXT, they
1793 both have the same name, they are both 4 bytes long, and
1794 they both have a relocation table entry for an external
1795 symbol with the same name. Unfortunately, this means
1796 that we must look through the relocations. Ick. */
1797 if (aux
.x_csect
.x_smclas
== XMC_TC
1798 && sym
.n_sclass
== C_HIDEXT
1799 && aux
.x_csect
.x_scnlen
.l
== 4
1800 && info
->hash
->creator
== abfd
->xvec
)
1802 asection
*enclosing
;
1803 struct internal_reloc
*relocs
;
1804 bfd_size_type relindx
;
1805 struct internal_reloc
*rel
;
1807 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1808 if (enclosing
== NULL
)
1811 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1812 relindx
= xcoff_find_reloc (relocs
, enclosing
->reloc_count
,
1814 rel
= relocs
+ relindx
;
1815 if (relindx
< enclosing
->reloc_count
1816 && rel
->r_vaddr
== (bfd_vma
) sym
.n_value
1817 && rel
->r_size
== 31
1818 && rel
->r_type
== R_POS
)
1821 struct internal_syment relsym
;
1823 erelsym
= ((bfd_byte
*) obj_coff_external_syms (abfd
)
1824 + rel
->r_symndx
* symesz
);
1825 bfd_coff_swap_sym_in (abfd
, (PTR
) erelsym
, (PTR
) &relsym
);
1826 if (relsym
.n_sclass
== C_EXT
)
1828 const char *relname
;
1829 char relbuf
[SYMNMLEN
+ 1];
1831 struct xcoff_link_hash_entry
*h
;
1833 /* At this point we know that the TOC entry is
1834 for an externally visible symbol. */
1835 relname
= _bfd_coff_internal_syment_name (abfd
, &relsym
,
1837 if (relname
== NULL
)
1840 /* We only merge TOC entries if the TC name is
1841 the same as the symbol name. This handles
1842 the normal case, but not common cases like
1843 SYM.P4 which gcc generates to store SYM + 4
1844 in the TOC. FIXME. */
1845 if (strcmp (name
, relname
) == 0)
1847 copy
= (! info
->keep_memory
1848 || relsym
._n
._n_n
._n_zeroes
!= 0
1849 || relsym
._n
._n_n
._n_offset
== 0);
1850 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1851 relname
, true, copy
,
1856 /* At this point h->root.type could be
1857 bfd_link_hash_new. That should be OK,
1858 since we know for sure that we will come
1859 across this symbol as we step through the
1862 /* We store h in *sym_hash for the
1863 convenience of the relocate_section
1867 if (h
->toc_section
!= NULL
)
1869 asection
**rel_csects
;
1871 /* We already have a TOC entry for this
1872 symbol, so we can just ignore this
1875 reloc_info
[enclosing
->target_index
].csects
;
1876 rel_csects
[relindx
] = bfd_und_section_ptr
;
1880 /* We are about to create a TOC entry for
1888 /* We need to create a new section. We get the name from
1889 the csect storage mapping class, so that the linker can
1890 accumulate similar csects together. */
1892 static const char *csect_name_by_class
[] =
1894 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
1895 ".sv", ".bs", ".ds", ".uc", ".ti", ".tb", NULL
, ".tc0",
1898 const char *csect_name
;
1899 asection
*enclosing
;
1901 if ((aux
.x_csect
.x_smclas
>=
1902 sizeof csect_name_by_class
/ sizeof csect_name_by_class
[0])
1903 || csect_name_by_class
[aux
.x_csect
.x_smclas
] == NULL
)
1905 (*_bfd_error_handler
)
1906 ("%s: symbol `%s' has unrecognized smclas %d",
1907 bfd_get_filename (abfd
), name
, aux
.x_csect
.x_smclas
);
1908 bfd_set_error (bfd_error_bad_value
);
1912 csect_name
= csect_name_by_class
[aux
.x_csect
.x_smclas
];
1913 csect
= bfd_make_section_anyway (abfd
, csect_name
);
1916 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1917 if (enclosing
== NULL
)
1919 if (! bfd_is_abs_section (enclosing
)
1920 && ((bfd_vma
) sym
.n_value
< enclosing
->vma
1921 || ((bfd_vma
) sym
.n_value
+ aux
.x_csect
.x_scnlen
.l
1922 > enclosing
->vma
+ enclosing
->_raw_size
)))
1924 (*_bfd_error_handler
)
1925 ("%s: csect `%s' not in enclosing section",
1926 bfd_get_filename (abfd
), name
);
1927 bfd_set_error (bfd_error_bad_value
);
1930 csect
->vma
= sym
.n_value
;
1931 csect
->filepos
= (enclosing
->filepos
1934 csect
->_raw_size
= aux
.x_csect
.x_scnlen
.l
;
1935 csect
->flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
;
1936 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1938 /* Record the enclosing section in the tdata for this new
1940 csect
->used_by_bfd
=
1941 ((struct coff_section_tdata
*)
1942 bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
)));
1943 if (csect
->used_by_bfd
== NULL
)
1945 coff_section_data (abfd
, csect
)->tdata
=
1946 bfd_zalloc (abfd
, sizeof (struct xcoff_section_tdata
));
1947 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1949 xcoff_section_data (abfd
, csect
)->enclosing
= enclosing
;
1950 xcoff_section_data (abfd
, csect
)->lineno_count
=
1951 enclosing
->lineno_count
;
1953 if (enclosing
->owner
== abfd
)
1955 struct internal_reloc
*relocs
;
1956 bfd_size_type relindx
;
1957 struct internal_reloc
*rel
;
1958 asection
**rel_csect
;
1960 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1961 relindx
= xcoff_find_reloc (relocs
, enclosing
->reloc_count
,
1963 rel
= relocs
+ relindx
;
1964 rel_csect
= (reloc_info
[enclosing
->target_index
].csects
1966 csect
->rel_filepos
= (enclosing
->rel_filepos
1967 + relindx
* bfd_coff_relsz (abfd
));
1968 while (relindx
< enclosing
->reloc_count
1969 && *rel_csect
== NULL
1970 && rel
->r_vaddr
< csect
->vma
+ csect
->_raw_size
)
1973 csect
->flags
|= SEC_RELOC
;
1974 ++csect
->reloc_count
;
1981 /* There are a number of other fields and section flags
1982 which we do not bother to set. */
1984 csect_index
= ((esym
1985 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1988 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1990 if (first_csect
== NULL
)
1991 first_csect
= csect
;
1993 /* If this symbol is C_EXT, we treat it as starting at the
1994 beginning of the newly created section. */
1995 if (sym
.n_sclass
== C_EXT
)
2001 /* If this is a TOC section for a symbol, record it. */
2002 if (set_toc
!= NULL
)
2003 set_toc
->toc_section
= csect
;
2008 /* This is a label definition. The x_scnlen field is the
2009 symbol index of the csect. I believe that this must
2010 always follow the appropriate XTY_SD symbol, so I will
2016 if (aux
.x_csect
.x_scnlen
.l
< 0
2017 || (aux
.x_csect
.x_scnlen
.l
2018 >= esym
- (bfd_byte
*) obj_coff_external_syms (abfd
)))
2022 section
= xcoff_data (abfd
)->csects
[aux
.x_csect
.x_scnlen
.l
];
2024 || (section
->flags
& SEC_HAS_CONTENTS
) == 0)
2029 (*_bfd_error_handler
)
2030 ("%s: misplaced XTY_LD `%s'",
2031 bfd_get_filename (abfd
), name
);
2032 bfd_set_error (bfd_error_bad_value
);
2036 value
= sym
.n_value
- csect
->vma
;
2041 /* This is an unitialized csect. We could base the name on
2042 the storage mapping class, but we don't bother. If this
2043 csect is externally visible, it is a common symbol. */
2047 xcoff_section_data (abfd
, csect
)->last_symndx
=
2049 - (bfd_byte
*) obj_coff_external_syms (abfd
))
2053 csect
= bfd_make_section_anyway (abfd
, ".bss");
2056 csect
->vma
= sym
.n_value
;
2057 csect
->_raw_size
= aux
.x_csect
.x_scnlen
.l
;
2058 csect
->flags
|= SEC_ALLOC
;
2059 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
2060 /* There are a number of other fields and section flags
2061 which we do not bother to set. */
2063 csect_index
= ((esym
2064 - (bfd_byte
*) obj_coff_external_syms (abfd
))
2067 csect
->used_by_bfd
=
2068 ((struct coff_section_tdata
*)
2069 bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
)));
2070 if (csect
->used_by_bfd
== NULL
)
2072 coff_section_data (abfd
, csect
)->tdata
=
2073 bfd_zalloc (abfd
, sizeof (struct xcoff_section_tdata
));
2074 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
2076 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
2078 if (first_csect
== NULL
)
2079 first_csect
= csect
;
2081 if (sym
.n_sclass
== C_EXT
)
2083 csect
->flags
|= SEC_IS_COMMON
;
2084 csect
->_raw_size
= 0;
2086 value
= aux
.x_csect
.x_scnlen
.l
;
2092 /* Check for magic symbol names. */
2093 if ((smtyp
== XTY_SD
|| smtyp
== XTY_CM
)
2094 && aux
.x_csect
.x_smclas
!= XMC_TC
2095 && aux
.x_csect
.x_smclas
!= XMC_TD
)
2102 if (strcmp (name
, "_text") == 0)
2104 else if (strcmp (name
, "_etext") == 0)
2106 else if (strcmp (name
, "_data") == 0)
2108 else if (strcmp (name
, "_edata") == 0)
2110 else if (strcmp (name
, "_end") == 0)
2113 else if (name
[0] == 'e' && strcmp (name
, "end") == 0)
2117 xcoff_hash_table (info
)->special_sections
[i
] = csect
;
2120 /* Now we have enough information to add the symbol to the
2121 linker hash table. */
2123 if (sym
.n_sclass
== C_EXT
)
2127 BFD_ASSERT (section
!= NULL
);
2129 /* We must copy the name into memory if we got it from the
2130 syment itself, rather than the string table. */
2131 copy
= default_copy
;
2132 if (sym
._n
._n_n
._n_zeroes
!= 0
2133 || sym
._n
._n_n
._n_offset
== 0)
2136 /* The AIX linker appears to only detect multiple symbol
2137 definitions when there is a reference to the symbol. If
2138 a symbol is defined multiple times, and the only
2139 references are from the same object file, the AIX linker
2140 appears to permit it. It does not merge the different
2141 definitions, but handles them independently. On the
2142 other hand, if there is a reference, the linker reports
2145 This matters because the AIX <net/net_globals.h> header
2146 file actually defines an initialized array, so we have to
2147 actually permit that to work.
2149 We also have to handle the case of statically linking a
2150 shared object, which will cause symbol redefinitions,
2151 although this is an easier case to detect. */
2153 if (info
->hash
->creator
== abfd
->xvec
)
2155 if (! bfd_is_und_section (section
))
2156 *sym_hash
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2157 name
, true, copy
, false);
2159 *sym_hash
= ((struct xcoff_link_hash_entry
*)
2160 bfd_wrapped_link_hash_lookup (abfd
, info
, name
,
2161 true, copy
, false));
2162 if (*sym_hash
== NULL
)
2164 if (((*sym_hash
)->root
.type
== bfd_link_hash_defined
2165 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
2166 && ! bfd_is_und_section (section
)
2167 && ! bfd_is_com_section (section
))
2169 /* This is a second definition of a defined symbol. */
2170 if ((abfd
->flags
& DYNAMIC
) != 0
2171 && ((*sym_hash
)->smclas
!= XMC_GL
2172 || aux
.x_csect
.x_smclas
== XMC_GL
2173 || ((*sym_hash
)->root
.u
.def
.section
->owner
->flags
2176 /* The new symbol is from a shared library, and
2177 either the existing symbol is not global
2178 linkage code or this symbol is global linkage
2179 code. If the existing symbol is global
2180 linkage code and the new symbol is not, then
2181 we want to use the new symbol. */
2182 section
= bfd_und_section_ptr
;
2185 else if (((*sym_hash
)->root
.u
.def
.section
->owner
->flags
2188 /* The existing symbol is from a shared library.
2190 (*sym_hash
)->root
.type
= bfd_link_hash_undefined
;
2191 (*sym_hash
)->root
.u
.undef
.abfd
=
2192 (*sym_hash
)->root
.u
.def
.section
->owner
;
2194 else if ((*sym_hash
)->root
.next
!= NULL
2195 || info
->hash
->undefs_tail
== &(*sym_hash
)->root
)
2197 /* This symbol has been referenced. In this
2198 case, we just continue and permit the
2199 multiple definition error. See the comment
2200 above about the behaviour of the AIX linker. */
2202 else if ((*sym_hash
)->smclas
== aux
.x_csect
.x_smclas
)
2204 /* The symbols are both csects of the same
2205 class. There is at least a chance that this
2206 is a semi-legitimate redefinition. */
2207 section
= bfd_und_section_ptr
;
2209 (*sym_hash
)->flags
|= XCOFF_MULTIPLY_DEFINED
;
2212 else if (((*sym_hash
)->flags
& XCOFF_MULTIPLY_DEFINED
) != 0
2213 && ((*sym_hash
)->root
.type
== bfd_link_hash_defined
2214 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
2215 && (bfd_is_und_section (section
)
2216 || bfd_is_com_section (section
)))
2218 /* This is a reference to a multiply defined symbol.
2219 Report the error now. See the comment above
2220 about the behaviour of the AIX linker. We could
2221 also do this with warning symbols, but I'm not
2222 sure the XCOFF linker is wholly prepared to
2223 handle them, and that would only be a warning,
2225 if (! ((*info
->callbacks
->multiple_definition
)
2226 (info
, (*sym_hash
)->root
.root
.string
,
2227 (bfd
*) NULL
, (asection
*) NULL
, 0,
2228 (*sym_hash
)->root
.u
.def
.section
->owner
,
2229 (*sym_hash
)->root
.u
.def
.section
,
2230 (*sym_hash
)->root
.u
.def
.value
)))
2232 /* Try not to give this error too many times. */
2233 (*sym_hash
)->flags
&= ~XCOFF_MULTIPLY_DEFINED
;
2237 /* _bfd_generic_link_add_one_symbol may call the linker to
2238 generate an error message, and the linker may try to read
2239 the symbol table to give a good error. Right now, the
2240 line numbers are in an inconsistent state, since they are
2241 counted both in the real sections and in the new csects.
2242 We need to leave the count in the real sections so that
2243 the linker can report the line number of the error
2244 correctly, so temporarily clobber the link to the csects
2245 so that the linker will not try to read the line numbers
2246 a second time from the csects. */
2247 BFD_ASSERT (last_real
->next
== first_csect
);
2248 last_real
->next
= NULL
;
2249 if (! (_bfd_generic_link_add_one_symbol
2250 (info
, abfd
, name
, flags
, section
, value
,
2251 (const char *) NULL
, copy
, true,
2252 (struct bfd_link_hash_entry
**) sym_hash
)))
2254 last_real
->next
= first_csect
;
2256 if (smtyp
== XTY_CM
)
2258 if ((*sym_hash
)->root
.type
!= bfd_link_hash_common
2259 || (*sym_hash
)->root
.u
.c
.p
->section
!= csect
)
2261 /* We don't need the common csect we just created. */
2262 csect
->_raw_size
= 0;
2266 (*sym_hash
)->root
.u
.c
.p
->alignment_power
2267 = csect
->alignment_power
;
2271 if (info
->hash
->creator
== abfd
->xvec
)
2275 if (smtyp
== XTY_ER
|| smtyp
== XTY_CM
)
2276 flag
= XCOFF_REF_REGULAR
;
2278 flag
= XCOFF_DEF_REGULAR
;
2279 (*sym_hash
)->flags
|= flag
;
2281 if ((*sym_hash
)->smclas
== XMC_UA
2282 || flag
== XCOFF_DEF_REGULAR
)
2283 (*sym_hash
)->smclas
= aux
.x_csect
.x_smclas
;
2287 *csect_cache
= csect
;
2289 esym
+= (sym
.n_numaux
+ 1) * symesz
;
2290 sym_hash
+= sym
.n_numaux
+ 1;
2291 csect_cache
+= sym
.n_numaux
+ 1;
2294 BFD_ASSERT (last_real
== NULL
|| last_real
->next
== first_csect
);
2296 /* Make sure that we have seen all the relocs. */
2297 for (o
= abfd
->sections
; o
!= first_csect
; o
= o
->next
)
2299 /* Reset the section size and the line number count, since the
2300 data is now attached to the csects. Don't reset the size of
2301 the .debug section, since we need to read it below in
2302 bfd_xcoff_size_dynamic_sections. */
2303 if (strcmp (bfd_get_section_name (abfd
, o
), ".debug") != 0)
2305 o
->lineno_count
= 0;
2307 if ((o
->flags
& SEC_RELOC
) != 0)
2310 struct internal_reloc
*rel
;
2311 asection
**rel_csect
;
2313 rel
= reloc_info
[o
->target_index
].relocs
;
2314 rel_csect
= reloc_info
[o
->target_index
].csects
;
2315 for (i
= 0; i
< o
->reloc_count
; i
++, rel
++, rel_csect
++)
2317 if (*rel_csect
== NULL
)
2319 (*_bfd_error_handler
)
2320 ("%s: reloc %s:%d not in csect",
2321 bfd_get_filename (abfd
), o
->name
, i
);
2322 bfd_set_error (bfd_error_bad_value
);
2326 /* We identify all symbols which are called, so that we
2327 can create glue code for calls to functions imported
2328 from dynamic objects. */
2329 if (info
->hash
->creator
== abfd
->xvec
2330 && *rel_csect
!= bfd_und_section_ptr
2331 && (rel
->r_type
== R_BR
2332 || rel
->r_type
== R_RBR
)
2333 && obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
] != NULL
)
2335 struct xcoff_link_hash_entry
*h
;
2337 h
= obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
];
2338 h
->flags
|= XCOFF_CALLED
;
2339 /* If the symbol name starts with a period, it is
2340 the code of a function. If the symbol is
2341 currently undefined, then add an undefined symbol
2342 for the function descriptor. This should do no
2343 harm, because any regular object that defines the
2344 function should also define the function
2345 descriptor. It helps, because it means that we
2346 will identify the function descriptor with a
2347 dynamic object if a dynamic object defines it. */
2348 if (h
->root
.root
.string
[0] == '.'
2349 && h
->descriptor
== NULL
)
2351 struct xcoff_link_hash_entry
*hds
;
2353 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2354 h
->root
.root
.string
+ 1,
2358 if (hds
->root
.type
== bfd_link_hash_new
)
2360 if (! (_bfd_generic_link_add_one_symbol
2361 (info
, abfd
, hds
->root
.root
.string
,
2362 (flagword
) 0, bfd_und_section_ptr
,
2363 (bfd_vma
) 0, (const char *) NULL
, false,
2365 (struct bfd_link_hash_entry
**) &hds
)))
2368 hds
->flags
|= XCOFF_DESCRIPTOR
;
2369 BFD_ASSERT ((hds
->flags
& XCOFF_CALLED
) == 0
2370 && (h
->flags
& XCOFF_DESCRIPTOR
) == 0);
2371 hds
->descriptor
= h
;
2372 h
->descriptor
= hds
;
2377 free (reloc_info
[o
->target_index
].csects
);
2378 reloc_info
[o
->target_index
].csects
= NULL
;
2380 /* Reset SEC_RELOC and the reloc_count, since the reloc
2381 information is now attached to the csects. */
2382 o
->flags
&=~ SEC_RELOC
;
2385 /* If we are not keeping memory, free the reloc information. */
2386 if (! info
->keep_memory
2387 && coff_section_data (abfd
, o
) != NULL
2388 && coff_section_data (abfd
, o
)->relocs
!= NULL
2389 && ! coff_section_data (abfd
, o
)->keep_relocs
)
2391 free (coff_section_data (abfd
, o
)->relocs
);
2392 coff_section_data (abfd
, o
)->relocs
= NULL
;
2396 /* Free up the line numbers. FIXME: We could cache these
2397 somewhere for the final link, to avoid reading them again. */
2398 if (reloc_info
[o
->target_index
].linenos
!= NULL
)
2400 free (reloc_info
[o
->target_index
].linenos
);
2401 reloc_info
[o
->target_index
].linenos
= NULL
;
2407 obj_coff_keep_syms (abfd
) = keep_syms
;
2412 if (reloc_info
!= NULL
)
2414 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2416 if (reloc_info
[o
->target_index
].csects
!= NULL
)
2417 free (reloc_info
[o
->target_index
].csects
);
2418 if (reloc_info
[o
->target_index
].linenos
!= NULL
)
2419 free (reloc_info
[o
->target_index
].linenos
);
2423 obj_coff_keep_syms (abfd
) = keep_syms
;
2430 /* This function is used to add symbols from a dynamic object to the
2431 global symbol table. */
2434 xcoff_link_add_dynamic_symbols (abfd
, info
)
2436 struct bfd_link_info
*info
;
2440 struct internal_ldhdr ldhdr
;
2441 const char *strings
;
2442 struct external_ldsym
*elsym
, *elsymend
;
2443 struct xcoff_import_file
*n
;
2448 struct xcoff_import_file
**pp
;
2450 /* We can only handle a dynamic object if we are generating an XCOFF
2452 if (info
->hash
->creator
!= abfd
->xvec
)
2454 (*_bfd_error_handler
)
2455 ("%s: XCOFF shared object when not producing XCOFF output",
2456 bfd_get_filename (abfd
));
2457 bfd_set_error (bfd_error_invalid_operation
);
2461 /* The symbols we use from a dynamic object are not the symbols in
2462 the normal symbol table, but, rather, the symbols in the export
2463 table. If there is a global symbol in a dynamic object which is
2464 not in the export table, the loader will not be able to find it,
2465 so we don't want to find it either. Also, on AIX 4.1.3, shr.o in
2466 libc.a has symbols in the export table which are not in the
2469 /* Read in the .loader section. FIXME: We should really use the
2470 o_snloader field in the a.out header, rather than grabbing the
2472 lsec
= bfd_get_section_by_name (abfd
, ".loader");
2475 (*_bfd_error_handler
)
2476 ("%s: dynamic object with no .loader section",
2477 bfd_get_filename (abfd
));
2478 bfd_set_error (bfd_error_no_symbols
);
2482 if (! xcoff_get_section_contents (abfd
, lsec
))
2484 buf
= coff_section_data (abfd
, lsec
)->contents
;
2486 /* Remove the sections from this object, so that they do not get
2487 included in the link. */
2488 abfd
->sections
= NULL
;
2490 xcoff_swap_ldhdr_in (abfd
, (struct external_ldhdr
*) buf
, &ldhdr
);
2492 strings
= (char *) buf
+ ldhdr
.l_stoff
;
2494 elsym
= (struct external_ldsym
*) (buf
+ LDHDRSZ
);
2495 elsymend
= elsym
+ ldhdr
.l_nsyms
;
2496 BFD_ASSERT (sizeof (struct external_ldsym
) == LDSYMSZ
);
2497 for (; elsym
< elsymend
; elsym
++)
2499 struct internal_ldsym ldsym
;
2500 char nambuf
[SYMNMLEN
+ 1];
2502 struct xcoff_link_hash_entry
*h
;
2504 xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
2506 /* We are only interested in exported symbols. */
2507 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
2510 if (ldsym
._l
._l_l
._l_zeroes
== 0)
2511 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
2514 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
2515 nambuf
[SYMNMLEN
] = '\0';
2519 /* Normally we could not call xcoff_link_hash_lookup in an add
2520 symbols routine, since we might not be using an XCOFF hash
2521 table. However, we verified above that we are using an XCOFF
2524 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, true,
2529 h
->flags
|= XCOFF_DEF_DYNAMIC
;
2531 /* If the symbol is undefined, and the BFD it was found in is
2532 not a dynamic object, change the BFD to this dynamic object,
2533 so that we can get the correct import file ID. */
2534 if ((h
->root
.type
== bfd_link_hash_undefined
2535 || h
->root
.type
== bfd_link_hash_undefweak
)
2536 && (h
->root
.u
.undef
.abfd
== NULL
2537 || (h
->root
.u
.undef
.abfd
->flags
& DYNAMIC
) == 0))
2538 h
->root
.u
.undef
.abfd
= abfd
;
2540 if (h
->root
.type
== bfd_link_hash_new
)
2542 h
->root
.type
= bfd_link_hash_undefined
;
2543 h
->root
.u
.undef
.abfd
= abfd
;
2544 /* We do not want to add this to the undefined symbol list. */
2547 if (h
->smclas
== XMC_UA
2548 || h
->root
.type
== bfd_link_hash_undefined
2549 || h
->root
.type
== bfd_link_hash_undefweak
)
2550 h
->smclas
= ldsym
.l_smclas
;
2552 /* Unless this is an XMC_XO symbol, we don't bother to actually
2553 define it, since we don't have a section to put it in anyhow.
2554 Instead, the relocation routines handle the DEF_DYNAMIC flag
2557 if (h
->smclas
== XMC_XO
2558 && (h
->root
.type
== bfd_link_hash_undefined
2559 || h
->root
.type
== bfd_link_hash_undefweak
))
2561 /* This symbol has an absolute value. */
2562 h
->root
.type
= bfd_link_hash_defined
;
2563 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2564 h
->root
.u
.def
.value
= ldsym
.l_value
;
2567 /* If this symbol defines a function descriptor, then it
2568 implicitly defines the function code as well. */
2569 if (h
->smclas
== XMC_DS
2570 || (h
->smclas
== XMC_XO
&& name
[0] != '.'))
2571 h
->flags
|= XCOFF_DESCRIPTOR
;
2572 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
2574 struct xcoff_link_hash_entry
*hds
;
2576 hds
= h
->descriptor
;
2581 dsnm
= bfd_malloc (strlen (name
) + 2);
2585 strcpy (dsnm
+ 1, name
);
2586 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
), dsnm
,
2592 if (hds
->root
.type
== bfd_link_hash_new
)
2594 hds
->root
.type
= bfd_link_hash_undefined
;
2595 hds
->root
.u
.undef
.abfd
= abfd
;
2596 /* We do not want to add this to the undefined
2600 hds
->descriptor
= h
;
2601 h
->descriptor
= hds
;
2604 hds
->flags
|= XCOFF_DEF_DYNAMIC
;
2605 if (hds
->smclas
== XMC_UA
)
2606 hds
->smclas
= XMC_PR
;
2608 /* An absolute symbol appears to actually define code, not a
2609 function descriptor. This is how some math functions are
2610 implemented on AIX 4.1. */
2611 if (h
->smclas
== XMC_XO
2612 && (hds
->root
.type
== bfd_link_hash_undefined
2613 || hds
->root
.type
== bfd_link_hash_undefweak
))
2615 hds
->smclas
= XMC_XO
;
2616 hds
->root
.type
= bfd_link_hash_defined
;
2617 hds
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2618 hds
->root
.u
.def
.value
= ldsym
.l_value
;
2623 if (buf
!= NULL
&& ! coff_section_data (abfd
, lsec
)->keep_contents
)
2625 free (coff_section_data (abfd
, lsec
)->contents
);
2626 coff_section_data (abfd
, lsec
)->contents
= NULL
;
2629 /* Record this file in the import files. */
2631 n
= ((struct xcoff_import_file
*)
2632 bfd_alloc (abfd
, sizeof (struct xcoff_import_file
)));
2637 /* For some reason, the path entry in the import file list for a
2638 shared object appears to always be empty. The file name is the
2641 if (abfd
->my_archive
== NULL
)
2643 bname
= bfd_get_filename (abfd
);
2648 bname
= bfd_get_filename (abfd
->my_archive
);
2649 mname
= bfd_get_filename (abfd
);
2651 s
= strrchr (bname
, '/');
2657 /* We start c at 1 because the first import file number is reserved
2659 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
2661 pp
= &(*pp
)->next
, ++c
)
2665 xcoff_data (abfd
)->import_file_id
= c
;
2670 /* Routines that are called after all the input files have been
2671 handled, but before the sections are laid out in memory. */
2673 /* Mark a symbol as not being garbage, including the section in which
2676 static INLINE boolean
2677 xcoff_mark_symbol (info
, h
)
2678 struct bfd_link_info
*info
;
2679 struct xcoff_link_hash_entry
*h
;
2681 if ((h
->flags
& XCOFF_MARK
) != 0)
2684 h
->flags
|= XCOFF_MARK
;
2685 if (h
->root
.type
== bfd_link_hash_defined
2686 || h
->root
.type
== bfd_link_hash_defweak
)
2690 hsec
= h
->root
.u
.def
.section
;
2691 if ((hsec
->flags
& SEC_MARK
) == 0)
2693 if (! xcoff_mark (info
, hsec
))
2698 if (h
->toc_section
!= NULL
2699 && (h
->toc_section
->flags
& SEC_MARK
) == 0)
2701 if (! xcoff_mark (info
, h
->toc_section
))
2708 /* The mark phase of garbage collection. For a given section, mark
2709 it, and all the sections which define symbols to which it refers.
2710 Because this function needs to look at the relocs, we also count
2711 the number of relocs which need to be copied into the .loader
2715 xcoff_mark (info
, sec
)
2716 struct bfd_link_info
*info
;
2719 if ((sec
->flags
& SEC_MARK
) != 0)
2722 sec
->flags
|= SEC_MARK
;
2724 if (sec
->owner
->xvec
== info
->hash
->creator
2725 && coff_section_data (sec
->owner
, sec
) != NULL
2726 && xcoff_section_data (sec
->owner
, sec
) != NULL
)
2728 register struct xcoff_link_hash_entry
**hp
, **hpend
;
2729 struct internal_reloc
*rel
, *relend
;
2731 /* Mark all the symbols in this section. */
2733 hp
= (obj_xcoff_sym_hashes (sec
->owner
)
2734 + xcoff_section_data (sec
->owner
, sec
)->first_symndx
);
2735 hpend
= (obj_xcoff_sym_hashes (sec
->owner
)
2736 + xcoff_section_data (sec
->owner
, sec
)->last_symndx
);
2737 for (; hp
< hpend
; hp
++)
2739 register struct xcoff_link_hash_entry
*h
;
2743 && (h
->flags
& XCOFF_MARK
) == 0)
2745 if (! xcoff_mark_symbol (info
, h
))
2750 /* Look through the section relocs. */
2752 if ((sec
->flags
& SEC_RELOC
) != 0
2753 && sec
->reloc_count
> 0)
2755 rel
= xcoff_read_internal_relocs (sec
->owner
, sec
, true,
2756 (bfd_byte
*) NULL
, false,
2757 (struct internal_reloc
*) NULL
);
2760 relend
= rel
+ sec
->reloc_count
;
2761 for (; rel
< relend
; rel
++)
2764 struct xcoff_link_hash_entry
*h
;
2766 if ((unsigned int) rel
->r_symndx
2767 > obj_raw_syment_count (sec
->owner
))
2770 h
= obj_xcoff_sym_hashes (sec
->owner
)[rel
->r_symndx
];
2772 && (h
->flags
& XCOFF_MARK
) == 0)
2774 if (! xcoff_mark_symbol (info
, h
))
2778 rsec
= xcoff_data (sec
->owner
)->csects
[rel
->r_symndx
];
2780 && (rsec
->flags
& SEC_MARK
) == 0)
2782 if (! xcoff_mark (info
, rsec
))
2786 /* See if this reloc needs to be copied into the .loader
2788 switch (rel
->r_type
)
2792 || h
->root
.type
== bfd_link_hash_defined
2793 || h
->root
.type
== bfd_link_hash_defweak
2794 || h
->root
.type
== bfd_link_hash_common
2795 || ((h
->flags
& XCOFF_CALLED
) != 0
2796 && (h
->root
.type
== bfd_link_hash_undefined
2797 || h
->root
.type
== bfd_link_hash_undefweak
)
2798 && h
->root
.root
.string
[0] == '.'
2799 && h
->descriptor
!= NULL
2800 && ((h
->descriptor
->flags
& XCOFF_DEF_DYNAMIC
) != 0
2801 || ((h
->descriptor
->flags
& XCOFF_IMPORT
) != 0
2802 && (h
->descriptor
->flags
2803 & XCOFF_DEF_REGULAR
) == 0))))
2810 ++xcoff_hash_table (info
)->ldrel_count
;
2812 h
->flags
|= XCOFF_LDREL
;
2819 /* We should never need a .loader reloc for a TOC
2825 if (! info
->keep_memory
2826 && coff_section_data (sec
->owner
, sec
) != NULL
2827 && coff_section_data (sec
->owner
, sec
)->relocs
!= NULL
2828 && ! coff_section_data (sec
->owner
, sec
)->keep_relocs
)
2830 free (coff_section_data (sec
->owner
, sec
)->relocs
);
2831 coff_section_data (sec
->owner
, sec
)->relocs
= NULL
;
2839 /* The sweep phase of garbage collection. Remove all garbage
2844 struct bfd_link_info
*info
;
2848 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
2852 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
2854 if ((o
->flags
& SEC_MARK
) == 0)
2856 /* Keep all sections from non-XCOFF input files. Keep
2857 special sections. Keep .debug sections for the
2859 if (sub
->xvec
!= info
->hash
->creator
2860 || o
== xcoff_hash_table (info
)->debug_section
2861 || o
== xcoff_hash_table (info
)->loader_section
2862 || o
== xcoff_hash_table (info
)->linkage_section
2863 || o
== xcoff_hash_table (info
)->toc_section
2864 || o
== xcoff_hash_table (info
)->descriptor_section
2865 || strcmp (o
->name
, ".debug") == 0)
2866 o
->flags
|= SEC_MARK
;
2871 o
->lineno_count
= 0;
2878 /* Record the number of elements in a set. This is used to output the
2879 correct csect length. */
2882 bfd_xcoff_link_record_set (output_bfd
, info
, harg
, size
)
2884 struct bfd_link_info
*info
;
2885 struct bfd_link_hash_entry
*harg
;
2888 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2889 struct xcoff_link_size_list
*n
;
2891 if (! XCOFF_XVECP (output_bfd
->xvec
))
2894 /* This will hardly ever be called. I don't want to burn four bytes
2895 per global symbol, so instead the size is kept on a linked list
2896 attached to the hash table. */
2898 n
= ((struct xcoff_link_size_list
*)
2899 bfd_alloc (output_bfd
, sizeof (struct xcoff_link_size_list
)));
2902 n
->next
= xcoff_hash_table (info
)->size_list
;
2905 xcoff_hash_table (info
)->size_list
= n
;
2907 h
->flags
|= XCOFF_HAS_SIZE
;
2912 /* Import a symbol. */
2915 bfd_xcoff_import_symbol (output_bfd
, info
, harg
, val
, imppath
, impfile
,
2918 struct bfd_link_info
*info
;
2919 struct bfd_link_hash_entry
*harg
;
2921 const char *imppath
;
2922 const char *impfile
;
2923 const char *impmember
;
2925 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2927 if (! XCOFF_XVECP (output_bfd
->xvec
))
2930 h
->flags
|= XCOFF_IMPORT
;
2932 if (val
!= (bfd_vma
) -1)
2934 if (h
->root
.type
== bfd_link_hash_defined
2935 && (! bfd_is_abs_section (h
->root
.u
.def
.section
)
2936 || h
->root
.u
.def
.value
!= val
))
2938 if (! ((*info
->callbacks
->multiple_definition
)
2939 (info
, h
->root
.root
.string
, h
->root
.u
.def
.section
->owner
,
2940 h
->root
.u
.def
.section
, h
->root
.u
.def
.value
,
2941 output_bfd
, bfd_abs_section_ptr
, val
)))
2945 h
->root
.type
= bfd_link_hash_defined
;
2946 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2947 h
->root
.u
.def
.value
= val
;
2950 /* We overload the ldindx field to hold the l_ifile value for this
2952 BFD_ASSERT (h
->ldsym
== NULL
);
2953 BFD_ASSERT ((h
->flags
& XCOFF_BUILT_LDSYM
) == 0);
2954 if (imppath
== NULL
)
2959 struct xcoff_import_file
**pp
;
2961 /* We start c at 1 because the first entry in the import list is
2962 reserved for the library search path. */
2963 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
2965 pp
= &(*pp
)->next
, ++c
)
2967 if (strcmp ((*pp
)->path
, imppath
) == 0
2968 && strcmp ((*pp
)->file
, impfile
) == 0
2969 && strcmp ((*pp
)->member
, impmember
) == 0)
2975 struct xcoff_import_file
*n
;
2977 n
= ((struct xcoff_import_file
*)
2978 bfd_alloc (output_bfd
, sizeof (struct xcoff_import_file
)));
2984 n
->member
= impmember
;
2994 /* Export a symbol. */
2997 bfd_xcoff_export_symbol (output_bfd
, info
, harg
, syscall
)
2999 struct bfd_link_info
*info
;
3000 struct bfd_link_hash_entry
*harg
;
3003 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
3005 if (! XCOFF_XVECP (output_bfd
->xvec
))
3008 h
->flags
|= XCOFF_EXPORT
;
3010 /* FIXME: I'm not at all sure what syscall is supposed to mean, so
3011 I'm just going to ignore it until somebody explains it. */
3013 /* See if this is a function descriptor. It may be one even though
3014 it is not so marked. */
3015 if ((h
->flags
& XCOFF_DESCRIPTOR
) == 0
3016 && h
->root
.root
.string
[0] != '.')
3019 struct xcoff_link_hash_entry
*hfn
;
3021 fnname
= (char *) bfd_malloc (strlen (h
->root
.root
.string
) + 2);
3025 strcpy (fnname
+ 1, h
->root
.root
.string
);
3026 hfn
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
3027 fnname
, false, false, true);
3030 && hfn
->smclas
== XMC_PR
3031 && (hfn
->root
.type
== bfd_link_hash_defined
3032 || hfn
->root
.type
== bfd_link_hash_defweak
))
3034 h
->flags
|= XCOFF_DESCRIPTOR
;
3035 h
->descriptor
= hfn
;
3036 hfn
->descriptor
= h
;
3040 /* Make sure we don't garbage collect this symbol. */
3041 if (! xcoff_mark_symbol (info
, h
))
3044 /* If this is a function descriptor, make sure we don't garbage
3045 collect the associated function code. We normally don't have to
3046 worry about this, because the descriptor will be attached to a
3047 section with relocs, but if we are creating the descriptor
3048 ourselves those relocs will not be visible to the mark code. */
3049 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
3051 if (! xcoff_mark_symbol (info
, h
->descriptor
))
3058 /* Count a reloc against a symbol. This is called for relocs
3059 generated by the linker script, typically for global constructors
3063 bfd_xcoff_link_count_reloc (output_bfd
, info
, name
)
3065 struct bfd_link_info
*info
;
3068 struct xcoff_link_hash_entry
*h
;
3070 if (! XCOFF_XVECP (output_bfd
->xvec
))
3073 h
= ((struct xcoff_link_hash_entry
*)
3074 bfd_wrapped_link_hash_lookup (output_bfd
, info
, name
, false, false,
3078 (*_bfd_error_handler
) ("%s: no such symbol", name
);
3079 bfd_set_error (bfd_error_no_symbols
);
3083 h
->flags
|= XCOFF_REF_REGULAR
| XCOFF_LDREL
;
3084 ++xcoff_hash_table (info
)->ldrel_count
;
3086 /* Mark the symbol to avoid garbage collection. */
3087 if (! xcoff_mark_symbol (info
, h
))
3093 /* This function is called for each symbol to which the linker script
3097 bfd_xcoff_record_link_assignment (output_bfd
, info
, name
)
3099 struct bfd_link_info
*info
;
3102 struct xcoff_link_hash_entry
*h
;
3104 if (! XCOFF_XVECP (output_bfd
->xvec
))
3107 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, true, true,
3112 h
->flags
|= XCOFF_DEF_REGULAR
;
3117 /* This structure is used to pass information through
3118 xcoff_link_hash_traverse. */
3120 struct xcoff_loader_info
3122 /* Set if a problem occurred. */
3126 /* Link information structure. */
3127 struct bfd_link_info
*info
;
3128 /* Whether all defined symbols should be exported. */
3129 boolean export_defineds
;
3130 /* Number of ldsym structures. */
3132 /* Size of string table. */
3136 /* Allocated size of string table. */
3140 /* Build the .loader section. This is called by the XCOFF linker
3141 emulation before_allocation routine. We must set the size of the
3142 .loader section before the linker lays out the output file.
3143 LIBPATH is the library path to search for shared objects; this is
3144 normally built from the -L arguments passed to the linker. ENTRY
3145 is the name of the entry point symbol (the -e linker option).
3146 FILE_ALIGN is the alignment to use for sections within the file
3147 (the -H linker option). MAXSTACK is the maximum stack size (the
3148 -bmaxstack linker option). MAXDATA is the maximum data size (the
3149 -bmaxdata linker option). GC is whether to do garbage collection
3150 (the -bgc linker option). MODTYPE is the module type (the
3151 -bmodtype linker option). TEXTRO is whether the text section must
3152 be read only (the -btextro linker option). EXPORT_DEFINEDS is
3153 whether all defined symbols should be exported (the -unix linker
3154 option). SPECIAL_SECTIONS is set by this routine to csects with
3155 magic names like _end. */
3158 bfd_xcoff_size_dynamic_sections (output_bfd
, info
, libpath
, entry
,
3159 file_align
, maxstack
, maxdata
, gc
,
3160 modtype
, textro
, export_defineds
,
3163 struct bfd_link_info
*info
;
3164 const char *libpath
;
3166 unsigned long file_align
;
3167 unsigned long maxstack
;
3168 unsigned long maxdata
;
3172 boolean export_defineds
;
3173 asection
**special_sections
;
3175 struct xcoff_link_hash_entry
*hentry
;
3177 struct xcoff_loader_info ldinfo
;
3179 size_t impsize
, impcount
;
3180 struct xcoff_import_file
*fl
;
3181 struct internal_ldhdr
*ldhdr
;
3182 bfd_size_type stoff
;
3186 struct bfd_strtab_hash
*debug_strtab
;
3187 bfd_byte
*debug_contents
= NULL
;
3189 if (! XCOFF_XVECP (output_bfd
->xvec
))
3191 for (i
= 0; i
< 6; i
++)
3192 special_sections
[i
] = NULL
;
3196 ldinfo
.failed
= false;
3197 ldinfo
.output_bfd
= output_bfd
;
3199 ldinfo
.export_defineds
= export_defineds
;
3200 ldinfo
.ldsym_count
= 0;
3201 ldinfo
.string_size
= 0;
3202 ldinfo
.strings
= NULL
;
3203 ldinfo
.string_alc
= 0;
3205 xcoff_data (output_bfd
)->maxstack
= maxstack
;
3206 xcoff_data (output_bfd
)->maxdata
= maxdata
;
3207 xcoff_data (output_bfd
)->modtype
= modtype
;
3209 xcoff_hash_table (info
)->file_align
= file_align
;
3210 xcoff_hash_table (info
)->textro
= textro
;
3212 hentry
= xcoff_link_hash_lookup (xcoff_hash_table (info
), entry
,
3213 false, false, true);
3215 hentry
->flags
|= XCOFF_ENTRY
;
3217 /* Garbage collect unused sections. */
3218 if (info
->relocateable
3221 || (hentry
->root
.type
!= bfd_link_hash_defined
3222 && hentry
->root
.type
!= bfd_link_hash_defweak
))
3225 xcoff_hash_table (info
)->gc
= false;
3227 /* We still need to call xcoff_mark, in order to set ldrel_count
3229 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3233 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3235 if ((o
->flags
& SEC_MARK
) == 0)
3237 if (! xcoff_mark (info
, o
))
3245 if (! xcoff_mark (info
, hentry
->root
.u
.def
.section
))
3248 xcoff_hash_table (info
)->gc
= true;
3251 /* Return special sections to the caller. */
3252 for (i
= 0; i
< 6; i
++)
3256 sec
= xcoff_hash_table (info
)->special_sections
[i
];
3259 && (sec
->flags
& SEC_MARK
) == 0)
3261 special_sections
[i
] = sec
;
3264 if (info
->input_bfds
== NULL
)
3266 /* I'm not sure what to do in this bizarre case. */
3270 xcoff_link_hash_traverse (xcoff_hash_table (info
), xcoff_build_ldsyms
,
3275 /* Work out the size of the import file names. Each import file ID
3276 consists of three null terminated strings: the path, the file
3277 name, and the archive member name. The first entry in the list
3278 of names is the path to use to find objects, which the linker has
3279 passed in as the libpath argument. For some reason, the path
3280 entry in the other import file names appears to always be empty. */
3281 impsize
= strlen (libpath
) + 3;
3283 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
3286 impsize
+= (strlen (fl
->path
)
3288 + strlen (fl
->member
)
3292 /* Set up the .loader section header. */
3293 ldhdr
= &xcoff_hash_table (info
)->ldhdr
;
3294 ldhdr
->l_version
= 1;
3295 ldhdr
->l_nsyms
= ldinfo
.ldsym_count
;
3296 ldhdr
->l_nreloc
= xcoff_hash_table (info
)->ldrel_count
;
3297 ldhdr
->l_istlen
= impsize
;
3298 ldhdr
->l_nimpid
= impcount
;
3299 ldhdr
->l_impoff
= (LDHDRSZ
3300 + ldhdr
->l_nsyms
* LDSYMSZ
3301 + ldhdr
->l_nreloc
* LDRELSZ
);
3302 ldhdr
->l_stlen
= ldinfo
.string_size
;
3303 stoff
= ldhdr
->l_impoff
+ impsize
;
3304 if (ldinfo
.string_size
== 0)
3307 ldhdr
->l_stoff
= stoff
;
3309 /* We now know the final size of the .loader section. Allocate
3311 lsec
= xcoff_hash_table (info
)->loader_section
;
3312 lsec
->_raw_size
= stoff
+ ldhdr
->l_stlen
;
3313 lsec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, lsec
->_raw_size
);
3314 if (lsec
->contents
== NULL
)
3317 /* Set up the header. */
3318 xcoff_swap_ldhdr_out (output_bfd
, ldhdr
,
3319 (struct external_ldhdr
*) lsec
->contents
);
3321 /* Set up the import file names. */
3322 out
= (char *) lsec
->contents
+ ldhdr
->l_impoff
;
3323 strcpy (out
, libpath
);
3324 out
+= strlen (libpath
) + 1;
3327 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
3329 register const char *s
;
3332 while ((*out
++ = *s
++) != '\0')
3335 while ((*out
++ = *s
++) != '\0')
3338 while ((*out
++ = *s
++) != '\0')
3342 BFD_ASSERT ((bfd_size_type
) ((bfd_byte
*) out
- lsec
->contents
) == stoff
);
3344 /* Set up the symbol string table. */
3345 if (ldinfo
.string_size
> 0)
3347 memcpy (out
, ldinfo
.strings
, ldinfo
.string_size
);
3348 free (ldinfo
.strings
);
3349 ldinfo
.strings
= NULL
;
3352 /* We can't set up the symbol table or the relocs yet, because we
3353 don't yet know the final position of the various sections. The
3354 .loader symbols are written out when the corresponding normal
3355 symbols are written out in xcoff_link_input_bfd or
3356 xcoff_write_global_symbol. The .loader relocs are written out
3357 when the corresponding normal relocs are handled in
3358 xcoff_link_input_bfd. */
3360 /* Allocate space for the magic sections. */
3361 sec
= xcoff_hash_table (info
)->linkage_section
;
3362 if (sec
->_raw_size
> 0)
3364 sec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, sec
->_raw_size
);
3365 if (sec
->contents
== NULL
)
3368 sec
= xcoff_hash_table (info
)->toc_section
;
3369 if (sec
->_raw_size
> 0)
3371 sec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, sec
->_raw_size
);
3372 if (sec
->contents
== NULL
)
3375 sec
= xcoff_hash_table (info
)->descriptor_section
;
3376 if (sec
->_raw_size
> 0)
3378 sec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, sec
->_raw_size
);
3379 if (sec
->contents
== NULL
)
3383 /* Now that we've done garbage collection, figure out the contents
3384 of the .debug section. */
3385 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
3387 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3390 bfd_size_type symcount
;
3391 unsigned long *debug_index
;
3393 bfd_byte
*esym
, *esymend
;
3394 bfd_size_type symesz
;
3396 if (sub
->xvec
!= info
->hash
->creator
)
3398 subdeb
= bfd_get_section_by_name (sub
, ".debug");
3399 if (subdeb
== NULL
|| subdeb
->_raw_size
== 0)
3402 if (info
->strip
== strip_all
3403 || info
->strip
== strip_debugger
3404 || info
->discard
== discard_all
)
3406 subdeb
->_raw_size
= 0;
3410 if (! _bfd_coff_get_external_symbols (sub
))
3413 symcount
= obj_raw_syment_count (sub
);
3414 debug_index
= ((unsigned long *)
3415 bfd_zalloc (sub
, symcount
* sizeof (unsigned long)));
3416 if (debug_index
== NULL
)
3418 xcoff_data (sub
)->debug_indices
= debug_index
;
3420 /* Grab the contents of the .debug section. We use malloc and
3421 copy the names into the debug stringtab, rather than
3422 bfd_alloc, because I expect that, when linking many files
3423 together, many of the strings will be the same. Storing the
3424 strings in the hash table should save space in this case. */
3425 debug_contents
= (bfd_byte
*) bfd_malloc (subdeb
->_raw_size
);
3426 if (debug_contents
== NULL
)
3428 if (! bfd_get_section_contents (sub
, subdeb
, (PTR
) debug_contents
,
3429 (file_ptr
) 0, subdeb
->_raw_size
))
3432 csectpp
= xcoff_data (sub
)->csects
;
3434 symesz
= bfd_coff_symesz (sub
);
3435 esym
= (bfd_byte
*) obj_coff_external_syms (sub
);
3436 esymend
= esym
+ symcount
* symesz
;
3437 while (esym
< esymend
)
3439 struct internal_syment sym
;
3441 bfd_coff_swap_sym_in (sub
, (PTR
) esym
, (PTR
) &sym
);
3443 *debug_index
= (unsigned long) -1;
3445 if (sym
._n
._n_n
._n_zeroes
== 0
3448 || ((*csectpp
)->flags
& SEC_MARK
) != 0
3449 || *csectpp
== bfd_abs_section_ptr
)
3450 && bfd_coff_symname_in_debug (sub
, &sym
))
3455 name
= (char *) debug_contents
+ sym
._n
._n_n
._n_offset
;
3456 indx
= _bfd_stringtab_add (debug_strtab
, name
, true, true);
3457 if (indx
== (bfd_size_type
) -1)
3459 *debug_index
= indx
;
3462 esym
+= (sym
.n_numaux
+ 1) * symesz
;
3463 csectpp
+= sym
.n_numaux
+ 1;
3464 debug_index
+= sym
.n_numaux
+ 1;
3467 free (debug_contents
);
3468 debug_contents
= NULL
;
3470 /* Clear the size of subdeb, so that it is not included directly
3471 in the output file. */
3472 subdeb
->_raw_size
= 0;
3474 if (! info
->keep_memory
)
3476 if (! _bfd_coff_free_symbols (sub
))
3481 xcoff_hash_table (info
)->debug_section
->_raw_size
=
3482 _bfd_stringtab_size (debug_strtab
);
3487 if (ldinfo
.strings
!= NULL
)
3488 free (ldinfo
.strings
);
3489 if (debug_contents
!= NULL
)
3490 free (debug_contents
);
3494 /* Add a symbol to the .loader symbols, if necessary. */
3497 xcoff_build_ldsyms (h
, p
)
3498 struct xcoff_link_hash_entry
*h
;
3501 struct xcoff_loader_info
*ldinfo
= (struct xcoff_loader_info
*) p
;
3504 /* If this is a final link, and the symbol was defined as a common
3505 symbol in a regular object file, and there was no definition in
3506 any dynamic object, then the linker will have allocated space for
3507 the symbol in a common section but the XCOFF_DEF_REGULAR flag
3508 will not have been set. */
3509 if (h
->root
.type
== bfd_link_hash_defined
3510 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
3511 && (h
->flags
& XCOFF_REF_REGULAR
) != 0
3512 && (h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
3513 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
3514 h
->flags
|= XCOFF_DEF_REGULAR
;
3516 /* If all defined symbols should be exported, mark them now. We
3517 don't want to export the actual functions, just the function
3519 if (ldinfo
->export_defineds
3520 && (h
->flags
& XCOFF_DEF_REGULAR
) != 0
3521 && h
->root
.root
.string
[0] != '.')
3525 /* We don't export a symbol which is being defined by an object
3526 included from an archive which contains a shared object. The
3527 rationale is that if an archive contains both an unshared and
3528 a shared object, then there must be some reason that the
3529 unshared object is unshared, and we don't want to start
3530 providing a shared version of it. In particular, this solves
3531 a bug involving the _savefNN set of functions. gcc will call
3532 those functions without providing a slot to restore the TOC,
3533 so it is essential that these functions be linked in directly
3534 and not from a shared object, which means that a shared
3535 object which also happens to link them in must not export
3536 them. This is confusing, but I haven't been able to think of
3537 a different approach. Note that the symbols can, of course,
3538 be exported explicitly. */
3540 if ((h
->root
.type
== bfd_link_hash_defined
3541 || h
->root
.type
== bfd_link_hash_defweak
)
3542 && h
->root
.u
.def
.section
->owner
!= NULL
3543 && h
->root
.u
.def
.section
->owner
->my_archive
!= NULL
)
3545 bfd
*arbfd
, *member
;
3547 arbfd
= h
->root
.u
.def
.section
->owner
->my_archive
;
3548 member
= bfd_openr_next_archived_file (arbfd
, (bfd
*) NULL
);
3549 while (member
!= NULL
)
3551 if ((member
->flags
& DYNAMIC
) != 0)
3556 member
= bfd_openr_next_archived_file (arbfd
, member
);
3561 h
->flags
|= XCOFF_EXPORT
;
3564 /* We don't want to garbage collect symbols which are not defined in
3565 XCOFF files. This is a convenient place to mark them. */
3566 if (xcoff_hash_table (ldinfo
->info
)->gc
3567 && (h
->flags
& XCOFF_MARK
) == 0
3568 && (h
->root
.type
== bfd_link_hash_defined
3569 || h
->root
.type
== bfd_link_hash_defweak
)
3570 && (h
->root
.u
.def
.section
->owner
== NULL
3571 || (h
->root
.u
.def
.section
->owner
->xvec
3572 != ldinfo
->info
->hash
->creator
)))
3573 h
->flags
|= XCOFF_MARK
;
3575 /* If this symbol is called and defined in a dynamic object, or it
3576 is imported, then we need to set up global linkage code for it.
3577 (Unless we did garbage collection and we didn't need this
3579 if ((h
->flags
& XCOFF_CALLED
) != 0
3580 && (h
->root
.type
== bfd_link_hash_undefined
3581 || h
->root
.type
== bfd_link_hash_undefweak
)
3582 && h
->root
.root
.string
[0] == '.'
3583 && h
->descriptor
!= NULL
3584 && ((h
->descriptor
->flags
& XCOFF_DEF_DYNAMIC
) != 0
3585 || ((h
->descriptor
->flags
& XCOFF_IMPORT
) != 0
3586 && (h
->descriptor
->flags
& XCOFF_DEF_REGULAR
) == 0))
3587 && (! xcoff_hash_table (ldinfo
->info
)->gc
3588 || (h
->flags
& XCOFF_MARK
) != 0))
3591 struct xcoff_link_hash_entry
*hds
;
3593 sec
= xcoff_hash_table (ldinfo
->info
)->linkage_section
;
3594 h
->root
.type
= bfd_link_hash_defined
;
3595 h
->root
.u
.def
.section
= sec
;
3596 h
->root
.u
.def
.value
= sec
->_raw_size
;
3598 h
->flags
|= XCOFF_DEF_REGULAR
;
3599 sec
->_raw_size
+= XCOFF_GLINK_SIZE
;
3601 /* The global linkage code requires a TOC entry for the
3603 hds
= h
->descriptor
;
3604 BFD_ASSERT ((hds
->root
.type
== bfd_link_hash_undefined
3605 || hds
->root
.type
== bfd_link_hash_undefweak
)
3606 && (hds
->flags
& XCOFF_DEF_REGULAR
) == 0);
3607 hds
->flags
|= XCOFF_MARK
;
3608 if (hds
->toc_section
== NULL
)
3610 hds
->toc_section
= xcoff_hash_table (ldinfo
->info
)->toc_section
;
3611 hds
->u
.toc_offset
= hds
->toc_section
->_raw_size
;
3612 hds
->toc_section
->_raw_size
+= 4;
3613 ++xcoff_hash_table (ldinfo
->info
)->ldrel_count
;
3614 ++hds
->toc_section
->reloc_count
;
3616 hds
->flags
|= XCOFF_SET_TOC
| XCOFF_LDREL
;
3618 /* We need to call xcoff_build_ldsyms recursively here,
3619 because we may already have passed hds on the traversal. */
3620 xcoff_build_ldsyms (hds
, p
);
3624 /* If this symbol is exported, but not defined, we need to try to
3626 if ((h
->flags
& XCOFF_EXPORT
) != 0
3627 && (h
->flags
& XCOFF_IMPORT
) == 0
3628 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
3629 && (h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
3630 && (h
->root
.type
== bfd_link_hash_undefined
3631 || h
->root
.type
== bfd_link_hash_undefweak
))
3633 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
3634 && (h
->descriptor
->root
.type
== bfd_link_hash_defined
3635 || h
->descriptor
->root
.type
== bfd_link_hash_defweak
))
3639 /* This is an undefined function descriptor associated with
3640 a defined entry point. We can build up a function
3641 descriptor ourselves. Believe it or not, the AIX linker
3642 actually does this, and there are cases where we need to
3644 sec
= xcoff_hash_table (ldinfo
->info
)->descriptor_section
;
3645 h
->root
.type
= bfd_link_hash_defined
;
3646 h
->root
.u
.def
.section
= sec
;
3647 h
->root
.u
.def
.value
= sec
->_raw_size
;
3649 h
->flags
|= XCOFF_DEF_REGULAR
;
3650 sec
->_raw_size
+= 12;
3652 /* A function descriptor uses two relocs: one for the
3653 associated code, and one for the TOC address. */
3654 xcoff_hash_table (ldinfo
->info
)->ldrel_count
+= 2;
3655 sec
->reloc_count
+= 2;
3657 /* We handle writing out the contents of the descriptor in
3658 xcoff_write_global_symbol. */
3662 (*_bfd_error_handler
)
3663 ("warning: attempt to export undefined symbol `%s'",
3664 h
->root
.root
.string
);
3670 /* If this is still a common symbol, and it wasn't garbage
3671 collected, we need to actually allocate space for it in the .bss
3673 if (h
->root
.type
== bfd_link_hash_common
3674 && (! xcoff_hash_table (ldinfo
->info
)->gc
3675 || (h
->flags
& XCOFF_MARK
) != 0)
3676 && h
->root
.u
.c
.p
->section
->_raw_size
== 0)
3678 BFD_ASSERT (bfd_is_com_section (h
->root
.u
.c
.p
->section
));
3679 h
->root
.u
.c
.p
->section
->_raw_size
= h
->root
.u
.c
.size
;
3682 /* We need to add a symbol to the .loader section if it is mentioned
3683 in a reloc which we are copying to the .loader section and it was
3684 not defined or common, or if it is the entry point, or if it is
3687 if (((h
->flags
& XCOFF_LDREL
) == 0
3688 || h
->root
.type
== bfd_link_hash_defined
3689 || h
->root
.type
== bfd_link_hash_defweak
3690 || h
->root
.type
== bfd_link_hash_common
)
3691 && (h
->flags
& XCOFF_ENTRY
) == 0
3692 && (h
->flags
& XCOFF_EXPORT
) == 0)
3698 /* We don't need to add this symbol if we did garbage collection and
3699 we did not mark this symbol. */
3700 if (xcoff_hash_table (ldinfo
->info
)->gc
3701 && (h
->flags
& XCOFF_MARK
) == 0)
3707 /* We may have already processed this symbol due to the recursive
3709 if ((h
->flags
& XCOFF_BUILT_LDSYM
) != 0)
3712 /* We need to add this symbol to the .loader symbols. */
3714 BFD_ASSERT (h
->ldsym
== NULL
);
3715 h
->ldsym
= ((struct internal_ldsym
*)
3716 bfd_zalloc (ldinfo
->output_bfd
,
3717 sizeof (struct internal_ldsym
)));
3718 if (h
->ldsym
== NULL
)
3720 ldinfo
->failed
= true;
3724 if ((h
->flags
& XCOFF_IMPORT
) != 0)
3725 h
->ldsym
->l_ifile
= h
->ldindx
;
3727 /* The first 3 symbol table indices are reserved to indicate the
3729 h
->ldindx
= ldinfo
->ldsym_count
+ 3;
3731 ++ldinfo
->ldsym_count
;
3733 len
= strlen (h
->root
.root
.string
);
3734 if (len
<= SYMNMLEN
)
3735 strncpy (h
->ldsym
->_l
._l_name
, h
->root
.root
.string
, SYMNMLEN
);
3738 if (ldinfo
->string_size
+ len
+ 3 > ldinfo
->string_alc
)
3741 bfd_byte
*newstrings
;
3743 newalc
= ldinfo
->string_alc
* 2;
3746 while (ldinfo
->string_size
+ len
+ 3 > newalc
)
3749 newstrings
= ((bfd_byte
*)
3750 bfd_realloc ((PTR
) ldinfo
->strings
, newalc
));
3751 if (newstrings
== NULL
)
3753 ldinfo
->failed
= true;
3756 ldinfo
->string_alc
= newalc
;
3757 ldinfo
->strings
= newstrings
;
3760 bfd_put_16 (ldinfo
->output_bfd
, len
+ 1,
3761 ldinfo
->strings
+ ldinfo
->string_size
);
3762 strcpy (ldinfo
->strings
+ ldinfo
->string_size
+ 2, h
->root
.root
.string
);
3763 h
->ldsym
->_l
._l_l
._l_zeroes
= 0;
3764 h
->ldsym
->_l
._l_l
._l_offset
= ldinfo
->string_size
+ 2;
3765 ldinfo
->string_size
+= len
+ 3;
3768 h
->flags
|= XCOFF_BUILT_LDSYM
;
3773 /* Do the final link step. */
3776 _bfd_xcoff_bfd_final_link (abfd
, info
)
3778 struct bfd_link_info
*info
;
3780 bfd_size_type symesz
;
3781 struct xcoff_final_link_info finfo
;
3783 struct bfd_link_order
*p
;
3784 size_t max_contents_size
;
3785 size_t max_sym_count
;
3786 size_t max_lineno_count
;
3787 size_t max_reloc_count
;
3788 size_t max_output_reloc_count
;
3789 file_ptr rel_filepos
;
3791 file_ptr line_filepos
;
3792 unsigned int linesz
;
3794 bfd_byte
*external_relocs
= NULL
;
3795 char strbuf
[STRING_SIZE_SIZE
];
3798 abfd
->flags
|= DYNAMIC
;
3800 symesz
= bfd_coff_symesz (abfd
);
3803 finfo
.output_bfd
= abfd
;
3804 finfo
.strtab
= NULL
;
3805 finfo
.section_info
= NULL
;
3806 finfo
.last_file_index
= -1;
3807 finfo
.toc_symindx
= -1;
3808 finfo
.internal_syms
= NULL
;
3809 finfo
.sym_indices
= NULL
;
3810 finfo
.outsyms
= NULL
;
3811 finfo
.linenos
= NULL
;
3812 finfo
.contents
= NULL
;
3813 finfo
.external_relocs
= NULL
;
3815 finfo
.ldsym
= ((struct external_ldsym
*)
3816 (xcoff_hash_table (info
)->loader_section
->contents
3818 finfo
.ldrel
= ((struct external_ldrel
*)
3819 (xcoff_hash_table (info
)->loader_section
->contents
3821 + xcoff_hash_table (info
)->ldhdr
.l_nsyms
* LDSYMSZ
));
3823 xcoff_data (abfd
)->coff
.link_info
= info
;
3825 finfo
.strtab
= _bfd_stringtab_init ();
3826 if (finfo
.strtab
== NULL
)
3829 /* Count the line number and relocation entries required for the
3830 output file. Determine a few maximum sizes. */
3831 max_contents_size
= 0;
3832 max_lineno_count
= 0;
3833 max_reloc_count
= 0;
3834 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3837 o
->lineno_count
= 0;
3838 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3840 if (p
->type
== bfd_indirect_link_order
)
3844 sec
= p
->u
.indirect
.section
;
3846 /* Mark all sections which are to be included in the
3847 link. This will normally be every section. We need
3848 to do this so that we can identify any sections which
3849 the linker has decided to not include. */
3850 sec
->linker_mark
= true;
3852 if (info
->strip
== strip_none
3853 || info
->strip
== strip_some
)
3854 o
->lineno_count
+= sec
->lineno_count
;
3856 o
->reloc_count
+= sec
->reloc_count
;
3858 if (sec
->_raw_size
> max_contents_size
)
3859 max_contents_size
= sec
->_raw_size
;
3860 if (sec
->lineno_count
> max_lineno_count
)
3861 max_lineno_count
= sec
->lineno_count
;
3862 if (coff_section_data (sec
->owner
, sec
) != NULL
3863 && xcoff_section_data (sec
->owner
, sec
) != NULL
3864 && (xcoff_section_data (sec
->owner
, sec
)->lineno_count
3865 > max_lineno_count
))
3867 xcoff_section_data (sec
->owner
, sec
)->lineno_count
;
3868 if (sec
->reloc_count
> max_reloc_count
)
3869 max_reloc_count
= sec
->reloc_count
;
3871 else if (p
->type
== bfd_section_reloc_link_order
3872 || p
->type
== bfd_symbol_reloc_link_order
)
3877 /* Compute the file positions for all the sections. */
3878 if (abfd
->output_has_begun
)
3880 if (xcoff_hash_table (info
)->file_align
!= 0)
3887 file_align
= xcoff_hash_table (info
)->file_align
;
3888 if (file_align
!= 0)
3890 boolean saw_contents
;
3895 /* Insert .pad sections before every section which has
3896 contents and is loaded, if it is preceded by some other
3897 section which has contents and is loaded. */
3898 saw_contents
= true;
3899 for (op
= &abfd
->sections
; *op
!= NULL
; op
= &(*op
)->next
)
3901 if (strcmp ((*op
)->name
, ".pad") == 0)
3902 saw_contents
= false;
3903 else if (((*op
)->flags
& SEC_HAS_CONTENTS
) != 0
3904 && ((*op
)->flags
& SEC_LOAD
) != 0)
3907 saw_contents
= true;
3914 n
= bfd_make_section_anyway (abfd
, ".pad");
3915 BFD_ASSERT (*op
== n
);
3917 n
->flags
= SEC_HAS_CONTENTS
;
3918 n
->alignment_power
= 0;
3919 saw_contents
= false;
3924 /* Reset the section indices after inserting the new
3927 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3930 o
->target_index
= indx
;
3932 BFD_ASSERT ((unsigned int) indx
== abfd
->section_count
);
3934 /* Work out appropriate sizes for the .pad sections to force
3935 each section to land on a page boundary. This bit of
3936 code knows what compute_section_file_positions is going
3938 sofar
= bfd_coff_filhsz (abfd
);
3939 sofar
+= bfd_coff_aoutsz (abfd
);
3940 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3941 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3942 if (o
->reloc_count
>= 0xffff || o
->lineno_count
>= 0xffff)
3943 sofar
+= bfd_coff_scnhsz (abfd
);
3945 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3947 if (strcmp (o
->name
, ".pad") == 0)
3951 BFD_ASSERT (o
->_raw_size
== 0);
3952 pageoff
= sofar
& (file_align
- 1);
3955 o
->_raw_size
= file_align
- pageoff
;
3956 sofar
+= file_align
- pageoff
;
3957 o
->flags
|= SEC_HAS_CONTENTS
;
3962 if ((o
->flags
& SEC_HAS_CONTENTS
) != 0)
3963 sofar
+= BFD_ALIGN (o
->_raw_size
,
3964 1 << o
->alignment_power
);
3969 if (! bfd_coff_compute_section_file_positions (abfd
))
3973 /* Allocate space for the pointers we need to keep for the relocs. */
3977 /* We use section_count + 1, rather than section_count, because
3978 the target_index fields are 1 based. */
3979 finfo
.section_info
=
3980 ((struct xcoff_link_section_info
*)
3981 bfd_malloc ((abfd
->section_count
+ 1)
3982 * sizeof (struct xcoff_link_section_info
)));
3983 if (finfo
.section_info
== NULL
)
3985 for (i
= 0; i
<= abfd
->section_count
; i
++)
3987 finfo
.section_info
[i
].relocs
= NULL
;
3988 finfo
.section_info
[i
].rel_hashes
= NULL
;
3989 finfo
.section_info
[i
].toc_rel_hashes
= NULL
;
3993 /* Set the file positions for the relocs. */
3994 rel_filepos
= obj_relocbase (abfd
);
3995 relsz
= bfd_coff_relsz (abfd
);
3996 max_output_reloc_count
= 0;
3997 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3999 if (o
->reloc_count
== 0)
4003 o
->flags
|= SEC_RELOC
;
4004 o
->rel_filepos
= rel_filepos
;
4005 rel_filepos
+= o
->reloc_count
* relsz
;
4007 /* We don't know the indices of global symbols until we have
4008 written out all the local symbols. For each section in
4009 the output file, we keep an array of pointers to hash
4010 table entries. Each entry in the array corresponds to a
4011 reloc. When we find a reloc against a global symbol, we
4012 set the corresponding entry in this array so that we can
4013 fix up the symbol index after we have written out all the
4016 Because of this problem, we also keep the relocs in
4017 memory until the end of the link. This wastes memory.
4018 We could backpatch the file later, I suppose, although it
4020 finfo
.section_info
[o
->target_index
].relocs
=
4021 ((struct internal_reloc
*)
4022 bfd_malloc (o
->reloc_count
* sizeof (struct internal_reloc
)));
4023 finfo
.section_info
[o
->target_index
].rel_hashes
=
4024 ((struct xcoff_link_hash_entry
**)
4025 bfd_malloc (o
->reloc_count
4026 * sizeof (struct xcoff_link_hash_entry
*)));
4027 if (finfo
.section_info
[o
->target_index
].relocs
== NULL
4028 || finfo
.section_info
[o
->target_index
].rel_hashes
== NULL
)
4031 if (o
->reloc_count
> max_output_reloc_count
)
4032 max_output_reloc_count
= o
->reloc_count
;
4036 /* We now know the size of the relocs, so we can determine the file
4037 positions of the line numbers. */
4038 line_filepos
= rel_filepos
;
4039 finfo
.line_filepos
= line_filepos
;
4040 linesz
= bfd_coff_linesz (abfd
);
4041 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4043 if (o
->lineno_count
== 0)
4044 o
->line_filepos
= 0;
4047 o
->line_filepos
= line_filepos
;
4048 line_filepos
+= o
->lineno_count
* linesz
;
4051 /* Reset the reloc and lineno counts, so that we can use them to
4052 count the number of entries we have output so far. */
4054 o
->lineno_count
= 0;
4057 obj_sym_filepos (abfd
) = line_filepos
;
4059 /* Figure out the largest number of symbols in an input BFD. Take
4060 the opportunity to clear the output_has_begun fields of all the
4061 input BFD's. We want at least 6 symbols, since that is the
4062 number which xcoff_write_global_symbol may need. */
4064 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
4068 sub
->output_has_begun
= false;
4069 sz
= obj_raw_syment_count (sub
);
4070 if (sz
> max_sym_count
)
4074 /* Allocate some buffers used while linking. */
4075 finfo
.internal_syms
= ((struct internal_syment
*)
4076 bfd_malloc (max_sym_count
4077 * sizeof (struct internal_syment
)));
4078 finfo
.sym_indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
4079 finfo
.outsyms
= ((bfd_byte
*)
4080 bfd_malloc ((size_t) ((max_sym_count
+ 1) * symesz
)));
4081 finfo
.linenos
= (bfd_byte
*) bfd_malloc (max_lineno_count
4082 * bfd_coff_linesz (abfd
));
4083 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
4084 finfo
.external_relocs
= (bfd_byte
*) bfd_malloc (max_reloc_count
* relsz
);
4085 if ((finfo
.internal_syms
== NULL
&& max_sym_count
> 0)
4086 || (finfo
.sym_indices
== NULL
&& max_sym_count
> 0)
4087 || finfo
.outsyms
== NULL
4088 || (finfo
.linenos
== NULL
&& max_lineno_count
> 0)
4089 || (finfo
.contents
== NULL
&& max_contents_size
> 0)
4090 || (finfo
.external_relocs
== NULL
&& max_reloc_count
> 0))
4093 obj_raw_syment_count (abfd
) = 0;
4094 xcoff_data (abfd
)->toc
= (bfd_vma
) -1;
4096 /* We now know the position of everything in the file, except that
4097 we don't know the size of the symbol table and therefore we don't
4098 know where the string table starts. We just build the string
4099 table in memory as we go along. We process all the relocations
4100 for a single input file at once. */
4101 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4103 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
4105 if (p
->type
== bfd_indirect_link_order
4106 && p
->u
.indirect
.section
->owner
->xvec
== abfd
->xvec
)
4108 sub
= p
->u
.indirect
.section
->owner
;
4109 if (! sub
->output_has_begun
)
4111 if (! xcoff_link_input_bfd (&finfo
, sub
))
4113 sub
->output_has_begun
= true;
4116 else if (p
->type
== bfd_section_reloc_link_order
4117 || p
->type
== bfd_symbol_reloc_link_order
)
4119 if (! xcoff_reloc_link_order (abfd
, &finfo
, o
, p
))
4124 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4130 /* Free up the buffers used by xcoff_link_input_bfd. */
4132 if (finfo
.internal_syms
!= NULL
)
4134 free (finfo
.internal_syms
);
4135 finfo
.internal_syms
= NULL
;
4137 if (finfo
.sym_indices
!= NULL
)
4139 free (finfo
.sym_indices
);
4140 finfo
.sym_indices
= NULL
;
4142 if (finfo
.linenos
!= NULL
)
4144 free (finfo
.linenos
);
4145 finfo
.linenos
= NULL
;
4147 if (finfo
.contents
!= NULL
)
4149 free (finfo
.contents
);
4150 finfo
.contents
= NULL
;
4152 if (finfo
.external_relocs
!= NULL
)
4154 free (finfo
.external_relocs
);
4155 finfo
.external_relocs
= NULL
;
4158 /* The value of the last C_FILE symbol is supposed to be -1. Write
4160 if (finfo
.last_file_index
!= -1)
4162 finfo
.last_file
.n_value
= -1;
4163 bfd_coff_swap_sym_out (abfd
, (PTR
) &finfo
.last_file
,
4164 (PTR
) finfo
.outsyms
);
4166 (obj_sym_filepos (abfd
)
4167 + finfo
.last_file_index
* symesz
),
4169 || bfd_write (finfo
.outsyms
, symesz
, 1, abfd
) != symesz
)
4173 /* Write out all the global symbols which do not come from XCOFF
4175 xcoff_link_hash_traverse (xcoff_hash_table (info
),
4176 xcoff_write_global_symbol
,
4179 if (finfo
.outsyms
!= NULL
)
4181 free (finfo
.outsyms
);
4182 finfo
.outsyms
= NULL
;
4185 /* Now that we have written out all the global symbols, we know the
4186 symbol indices to use for relocs against them, and we can finally
4187 write out the relocs. */
4188 external_relocs
= (bfd_byte
*) bfd_malloc (max_output_reloc_count
* relsz
);
4189 if (external_relocs
== NULL
&& max_output_reloc_count
!= 0)
4192 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4194 struct internal_reloc
*irel
;
4195 struct internal_reloc
*irelend
;
4196 struct xcoff_link_hash_entry
**rel_hash
;
4197 struct xcoff_toc_rel_hash
*toc_rel_hash
;
4200 if (o
->reloc_count
== 0)
4203 irel
= finfo
.section_info
[o
->target_index
].relocs
;
4204 irelend
= irel
+ o
->reloc_count
;
4205 rel_hash
= finfo
.section_info
[o
->target_index
].rel_hashes
;
4206 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
4208 if (*rel_hash
!= NULL
)
4210 if ((*rel_hash
)->indx
< 0)
4212 if (! ((*info
->callbacks
->unattached_reloc
)
4213 (info
, (*rel_hash
)->root
.root
.string
,
4214 (bfd
*) NULL
, o
, irel
->r_vaddr
)))
4216 (*rel_hash
)->indx
= 0;
4218 irel
->r_symndx
= (*rel_hash
)->indx
;
4222 for (toc_rel_hash
= finfo
.section_info
[o
->target_index
].toc_rel_hashes
;
4223 toc_rel_hash
!= NULL
;
4224 toc_rel_hash
= toc_rel_hash
->next
)
4226 if (toc_rel_hash
->h
->u
.toc_indx
< 0)
4228 if (! ((*info
->callbacks
->unattached_reloc
)
4229 (info
, toc_rel_hash
->h
->root
.root
.string
,
4230 (bfd
*) NULL
, o
, toc_rel_hash
->rel
->r_vaddr
)))
4232 toc_rel_hash
->h
->u
.toc_indx
= 0;
4234 toc_rel_hash
->rel
->r_symndx
= toc_rel_hash
->h
->u
.toc_indx
;
4237 /* XCOFF requires that the relocs be sorted by address. We tend
4238 to produce them in the order in which their containing csects
4239 appear in the symbol table, which is not necessarily by
4240 address. So we sort them here. There may be a better way to
4242 qsort ((PTR
) finfo
.section_info
[o
->target_index
].relocs
,
4243 o
->reloc_count
, sizeof (struct internal_reloc
),
4246 irel
= finfo
.section_info
[o
->target_index
].relocs
;
4247 irelend
= irel
+ o
->reloc_count
;
4248 erel
= external_relocs
;
4249 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
4250 bfd_coff_swap_reloc_out (abfd
, (PTR
) irel
, (PTR
) erel
);
4252 if (bfd_seek (abfd
, o
->rel_filepos
, SEEK_SET
) != 0
4253 || bfd_write ((PTR
) external_relocs
, relsz
, o
->reloc_count
,
4254 abfd
) != relsz
* o
->reloc_count
)
4258 if (external_relocs
!= NULL
)
4260 free (external_relocs
);
4261 external_relocs
= NULL
;
4264 /* Free up the section information. */
4265 if (finfo
.section_info
!= NULL
)
4269 for (i
= 0; i
< abfd
->section_count
; i
++)
4271 if (finfo
.section_info
[i
].relocs
!= NULL
)
4272 free (finfo
.section_info
[i
].relocs
);
4273 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
4274 free (finfo
.section_info
[i
].rel_hashes
);
4276 free (finfo
.section_info
);
4277 finfo
.section_info
= NULL
;
4280 /* Write out the loader section contents. */
4281 BFD_ASSERT ((bfd_byte
*) finfo
.ldrel
4282 == (xcoff_hash_table (info
)->loader_section
->contents
4283 + xcoff_hash_table (info
)->ldhdr
.l_impoff
));
4284 o
= xcoff_hash_table (info
)->loader_section
;
4285 if (! bfd_set_section_contents (abfd
, o
->output_section
,
4286 o
->contents
, o
->output_offset
,
4290 /* Write out the magic sections. */
4291 o
= xcoff_hash_table (info
)->linkage_section
;
4292 if (o
->_raw_size
> 0
4293 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
4294 o
->output_offset
, o
->_raw_size
))
4296 o
= xcoff_hash_table (info
)->toc_section
;
4297 if (o
->_raw_size
> 0
4298 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
4299 o
->output_offset
, o
->_raw_size
))
4301 o
= xcoff_hash_table (info
)->descriptor_section
;
4302 if (o
->_raw_size
> 0
4303 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
4304 o
->output_offset
, o
->_raw_size
))
4307 /* Write out the string table. */
4309 (obj_sym_filepos (abfd
)
4310 + obj_raw_syment_count (abfd
) * symesz
),
4314 _bfd_stringtab_size (finfo
.strtab
) + STRING_SIZE_SIZE
,
4315 (bfd_byte
*) strbuf
);
4316 if (bfd_write (strbuf
, 1, STRING_SIZE_SIZE
, abfd
) != STRING_SIZE_SIZE
)
4318 if (! _bfd_stringtab_emit (abfd
, finfo
.strtab
))
4321 _bfd_stringtab_free (finfo
.strtab
);
4323 /* Write out the debugging string table. */
4324 o
= xcoff_hash_table (info
)->debug_section
;
4327 struct bfd_strtab_hash
*debug_strtab
;
4329 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
4330 BFD_ASSERT (o
->output_section
->_raw_size
- o
->output_offset
4331 >= _bfd_stringtab_size (debug_strtab
));
4333 o
->output_section
->filepos
+ o
->output_offset
,
4336 if (! _bfd_stringtab_emit (abfd
, debug_strtab
))
4340 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
4341 not try to write out the symbols. */
4342 bfd_get_symcount (abfd
) = 0;
4347 if (finfo
.strtab
!= NULL
)
4348 _bfd_stringtab_free (finfo
.strtab
);
4349 if (finfo
.section_info
!= NULL
)
4353 for (i
= 0; i
< abfd
->section_count
; i
++)
4355 if (finfo
.section_info
[i
].relocs
!= NULL
)
4356 free (finfo
.section_info
[i
].relocs
);
4357 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
4358 free (finfo
.section_info
[i
].rel_hashes
);
4360 free (finfo
.section_info
);
4362 if (finfo
.internal_syms
!= NULL
)
4363 free (finfo
.internal_syms
);
4364 if (finfo
.sym_indices
!= NULL
)
4365 free (finfo
.sym_indices
);
4366 if (finfo
.outsyms
!= NULL
)
4367 free (finfo
.outsyms
);
4368 if (finfo
.linenos
!= NULL
)
4369 free (finfo
.linenos
);
4370 if (finfo
.contents
!= NULL
)
4371 free (finfo
.contents
);
4372 if (finfo
.external_relocs
!= NULL
)
4373 free (finfo
.external_relocs
);
4374 if (external_relocs
!= NULL
)
4375 free (external_relocs
);
4379 /* Link an input file into the linker output file. This function
4380 handles all the sections and relocations of the input file at once. */
4383 xcoff_link_input_bfd (finfo
, input_bfd
)
4384 struct xcoff_final_link_info
*finfo
;
4388 const char *strings
;
4389 bfd_size_type syment_base
;
4390 unsigned int n_tmask
;
4391 unsigned int n_btshft
;
4393 bfd_size_type isymesz
;
4394 bfd_size_type osymesz
;
4395 bfd_size_type linesz
;
4398 struct xcoff_link_hash_entry
**sym_hash
;
4399 struct internal_syment
*isymp
;
4401 unsigned long *debug_index
;
4403 unsigned long output_index
;
4410 /* We can just skip DYNAMIC files, unless this is a static link. */
4411 if ((input_bfd
->flags
& DYNAMIC
) != 0
4412 && ! finfo
->info
->static_link
)
4415 /* Move all the symbols to the output file. */
4417 output_bfd
= finfo
->output_bfd
;
4419 syment_base
= obj_raw_syment_count (output_bfd
);
4420 isymesz
= bfd_coff_symesz (input_bfd
);
4421 osymesz
= bfd_coff_symesz (output_bfd
);
4422 linesz
= bfd_coff_linesz (input_bfd
);
4423 BFD_ASSERT (linesz
== bfd_coff_linesz (output_bfd
));
4425 n_tmask
= coff_data (input_bfd
)->local_n_tmask
;
4426 n_btshft
= coff_data (input_bfd
)->local_n_btshft
;
4428 /* Define macros so that ISFCN, et. al., macros work correctly. */
4429 #define N_TMASK n_tmask
4430 #define N_BTSHFT n_btshft
4433 if (! finfo
->info
->keep_memory
)
4436 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
4439 if (! _bfd_coff_get_external_symbols (input_bfd
))
4442 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
4443 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
4444 sym_hash
= obj_xcoff_sym_hashes (input_bfd
);
4445 csectpp
= xcoff_data (input_bfd
)->csects
;
4446 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
4447 isymp
= finfo
->internal_syms
;
4448 indexp
= finfo
->sym_indices
;
4449 output_index
= syment_base
;
4450 outsym
= finfo
->outsyms
;
4454 while (esym
< esym_end
)
4456 struct internal_syment isym
;
4457 union internal_auxent aux
;
4463 bfd_coff_swap_sym_in (input_bfd
, (PTR
) esym
, (PTR
) isymp
);
4465 /* If this is a C_EXT or C_HIDEXT symbol, we need the csect
4467 if (isymp
->n_sclass
== C_EXT
|| isymp
->n_sclass
== C_HIDEXT
)
4469 BFD_ASSERT (isymp
->n_numaux
> 0);
4470 bfd_coff_swap_aux_in (input_bfd
,
4471 (PTR
) (esym
+ isymesz
* isymp
->n_numaux
),
4472 isymp
->n_type
, isymp
->n_sclass
,
4473 isymp
->n_numaux
- 1, isymp
->n_numaux
,
4475 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
4478 /* Make a copy of *isymp so that the relocate_section function
4479 always sees the original values. This is more reliable than
4480 always recomputing the symbol value even if we are stripping
4484 /* If this symbol is in the .loader section, swap out the
4485 .loader symbol information. If this is an external symbol
4486 reference to a defined symbol, though, then wait until we get
4487 to the definition. */
4488 if (isym
.n_sclass
== C_EXT
4489 && *sym_hash
!= NULL
4490 && (*sym_hash
)->ldsym
!= NULL
4492 || (*sym_hash
)->root
.type
== bfd_link_hash_undefined
))
4494 struct xcoff_link_hash_entry
*h
;
4495 struct internal_ldsym
*ldsym
;
4499 if (isym
.n_scnum
> 0)
4501 ldsym
->l_scnum
= (*csectpp
)->output_section
->target_index
;
4502 ldsym
->l_value
= (isym
.n_value
4503 + (*csectpp
)->output_section
->vma
4504 + (*csectpp
)->output_offset
4509 ldsym
->l_scnum
= isym
.n_scnum
;
4510 ldsym
->l_value
= isym
.n_value
;
4513 ldsym
->l_smtype
= smtyp
;
4514 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
4515 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4516 || (h
->flags
& XCOFF_IMPORT
) != 0)
4517 ldsym
->l_smtype
|= L_IMPORT
;
4518 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
4519 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4520 || (h
->flags
& XCOFF_EXPORT
) != 0)
4521 ldsym
->l_smtype
|= L_EXPORT
;
4522 if ((h
->flags
& XCOFF_ENTRY
) != 0)
4523 ldsym
->l_smtype
|= L_ENTRY
;
4525 ldsym
->l_smclas
= aux
.x_csect
.x_smclas
;
4527 if (ldsym
->l_ifile
== (bfd_size_type
) -1)
4529 else if (ldsym
->l_ifile
== 0)
4531 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
4537 if (h
->root
.type
== bfd_link_hash_defined
4538 || h
->root
.type
== bfd_link_hash_defweak
)
4539 impbfd
= h
->root
.u
.def
.section
->owner
;
4540 else if (h
->root
.type
== bfd_link_hash_undefined
4541 || h
->root
.type
== bfd_link_hash_undefweak
)
4542 impbfd
= h
->root
.u
.undef
.abfd
;
4550 BFD_ASSERT (impbfd
->xvec
== finfo
->output_bfd
->xvec
);
4551 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
4558 BFD_ASSERT (h
->ldindx
>= 0);
4559 BFD_ASSERT (LDSYMSZ
== sizeof (struct external_ldsym
));
4560 xcoff_swap_ldsym_out (finfo
->output_bfd
, ldsym
,
4561 finfo
->ldsym
+ h
->ldindx
- 3);
4564 /* Fill in snentry now that we know the target_index. */
4565 if ((h
->flags
& XCOFF_ENTRY
) != 0
4566 && (h
->root
.type
== bfd_link_hash_defined
4567 || h
->root
.type
== bfd_link_hash_defweak
))
4568 xcoff_data (output_bfd
)->snentry
=
4569 h
->root
.u
.def
.section
->output_section
->target_index
;
4576 add
= 1 + isym
.n_numaux
;
4578 /* If we are skipping this csect, we want to skip this symbol. */
4579 if (*csectpp
== NULL
)
4582 /* If we garbage collected this csect, we want to skip this
4585 && xcoff_hash_table (finfo
->info
)->gc
4586 && ((*csectpp
)->flags
& SEC_MARK
) == 0
4587 && *csectpp
!= bfd_abs_section_ptr
)
4590 /* An XCOFF linker always skips C_STAT symbols. */
4592 && isymp
->n_sclass
== C_STAT
)
4595 /* We skip all but the first TOC anchor. */
4597 && isymp
->n_sclass
== C_HIDEXT
4598 && aux
.x_csect
.x_smclas
== XMC_TC0
)
4600 if (finfo
->toc_symindx
!= -1)
4604 bfd_vma tocval
, tocend
;
4606 tocval
= ((*csectpp
)->output_section
->vma
4607 + (*csectpp
)->output_offset
4610 /* We want to find out if tocval is a good value to use
4611 as the TOC anchor--that is, whether we can access all
4612 of the TOC using a 16 bit offset from tocval. This
4613 test assumes that the TOC comes at the end of the
4614 output section, as it does in the default linker
4617 tocend
= ((*csectpp
)->output_section
->vma
4618 + (*csectpp
)->output_section
->_raw_size
);
4620 if (tocval
+ 0x10000 < tocend
)
4622 (*_bfd_error_handler
)
4623 ("TOC overflow: 0x%lx > 0x10000; try -mminimal-toc when compiling",
4624 (unsigned long) (tocend
- tocval
));
4625 bfd_set_error (bfd_error_file_too_big
);
4629 if (tocval
+ 0x8000 < tocend
)
4633 tocadd
= tocend
- (tocval
+ 0x8000);
4635 isym
.n_value
+= tocadd
;
4638 finfo
->toc_symindx
= output_index
;
4639 xcoff_data (finfo
->output_bfd
)->toc
= tocval
;
4640 xcoff_data (finfo
->output_bfd
)->sntoc
=
4641 (*csectpp
)->output_section
->target_index
;
4646 /* If we are stripping all symbols, we want to skip this one. */
4648 && finfo
->info
->strip
== strip_all
)
4651 /* We can skip resolved external references. */
4653 && isym
.n_sclass
== C_EXT
4655 && (*sym_hash
)->root
.type
!= bfd_link_hash_undefined
)
4658 /* We can skip common symbols if they got defined somewhere
4661 && isym
.n_sclass
== C_EXT
4663 && ((*sym_hash
)->root
.type
!= bfd_link_hash_common
4664 || (*sym_hash
)->root
.u
.c
.p
->section
!= *csectpp
)
4665 && ((*sym_hash
)->root
.type
!= bfd_link_hash_defined
4666 || (*sym_hash
)->root
.u
.def
.section
!= *csectpp
))
4669 /* Skip local symbols if we are discarding them. */
4671 && finfo
->info
->discard
== discard_all
4672 && isym
.n_sclass
!= C_EXT
4673 && (isym
.n_sclass
!= C_HIDEXT
4674 || smtyp
!= XTY_SD
))
4677 /* If we stripping debugging symbols, and this is a debugging
4678 symbol, then skip it. */
4680 && finfo
->info
->strip
== strip_debugger
4681 && isym
.n_scnum
== N_DEBUG
)
4684 /* If some symbols are stripped based on the name, work out the
4685 name and decide whether to skip this symbol. We don't handle
4686 this correctly for symbols whose names are in the .debug
4687 section; to get it right we would need a new bfd_strtab_hash
4688 function to return the string given the index. */
4690 && (finfo
->info
->strip
== strip_some
4691 || finfo
->info
->discard
== discard_l
)
4692 && (debug_index
== NULL
|| *debug_index
== (unsigned long) -1))
4695 char buf
[SYMNMLEN
+ 1];
4697 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, buf
);
4701 if ((finfo
->info
->strip
== strip_some
4702 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false,
4704 || (finfo
->info
->discard
== discard_l
4705 && (isym
.n_sclass
!= C_EXT
4706 && (isym
.n_sclass
!= C_HIDEXT
4707 || smtyp
!= XTY_SD
))
4708 && bfd_is_local_label_name (input_bfd
, name
)))
4712 /* We can not skip the first TOC anchor. */
4715 && finfo
->info
->strip
!= strip_all
)
4718 /* We now know whether we are to skip this symbol or not. */
4721 /* Adjust the symbol in order to output it. */
4723 if (isym
._n
._n_n
._n_zeroes
== 0
4724 && isym
._n
._n_n
._n_offset
!= 0)
4726 /* This symbol has a long name. Enter it in the string
4727 table we are building. If *debug_index != -1, the
4728 name has already been entered in the .debug section. */
4729 if (debug_index
!= NULL
&& *debug_index
!= (unsigned long) -1)
4730 isym
._n
._n_n
._n_offset
= *debug_index
;
4736 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
,
4740 indx
= _bfd_stringtab_add (finfo
->strtab
, name
, hash
, copy
);
4741 if (indx
== (bfd_size_type
) -1)
4743 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
4747 if (isym
.n_sclass
!= C_BSTAT
4748 && isym
.n_sclass
!= C_ESTAT
4749 && isym
.n_sclass
!= C_DECL
4750 && isym
.n_scnum
> 0)
4752 isym
.n_scnum
= (*csectpp
)->output_section
->target_index
;
4753 isym
.n_value
+= ((*csectpp
)->output_section
->vma
4754 + (*csectpp
)->output_offset
4758 /* The value of a C_FILE symbol is the symbol index of the
4759 next C_FILE symbol. The value of the last C_FILE symbol
4760 is -1. We try to get this right, below, just before we
4761 write the symbols out, but in the general case we may
4762 have to write the symbol out twice. */
4763 if (isym
.n_sclass
== C_FILE
)
4765 if (finfo
->last_file_index
!= -1
4766 && finfo
->last_file
.n_value
!= (long) output_index
)
4768 /* We must correct the value of the last C_FILE entry. */
4769 finfo
->last_file
.n_value
= output_index
;
4770 if ((bfd_size_type
) finfo
->last_file_index
>= syment_base
)
4772 /* The last C_FILE symbol is in this input file. */
4773 bfd_coff_swap_sym_out (output_bfd
,
4774 (PTR
) &finfo
->last_file
,
4775 (PTR
) (finfo
->outsyms
4776 + ((finfo
->last_file_index
4782 /* We have already written out the last C_FILE
4783 symbol. We need to write it out again. We
4784 borrow *outsym temporarily. */
4785 bfd_coff_swap_sym_out (output_bfd
,
4786 (PTR
) &finfo
->last_file
,
4788 if (bfd_seek (output_bfd
,
4789 (obj_sym_filepos (output_bfd
)
4790 + finfo
->last_file_index
* osymesz
),
4792 || (bfd_write (outsym
, osymesz
, 1, output_bfd
)
4798 finfo
->last_file_index
= output_index
;
4799 finfo
->last_file
= isym
;
4802 /* The value of a C_BINCL or C_EINCL symbol is a file offset
4803 into the line numbers. We update the symbol values when
4804 we handle the line numbers. */
4805 if (isym
.n_sclass
== C_BINCL
4806 || isym
.n_sclass
== C_EINCL
)
4808 isym
.n_value
= finfo
->line_filepos
;
4812 /* Output the symbol. */
4814 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
, (PTR
) outsym
);
4816 *indexp
= output_index
;
4818 if (isym
.n_sclass
== C_EXT
)
4821 struct xcoff_link_hash_entry
*h
;
4823 indx
= ((esym
- (bfd_byte
*) obj_coff_external_syms (input_bfd
))
4825 h
= obj_xcoff_sym_hashes (input_bfd
)[indx
];
4826 BFD_ASSERT (h
!= NULL
);
4827 h
->indx
= output_index
;
4830 /* If this is a symbol in the TOC which we may have merged
4831 (class XMC_TC), remember the symbol index of the TOC
4833 if (isym
.n_sclass
== C_HIDEXT
4834 && aux
.x_csect
.x_smclas
== XMC_TC
4835 && *sym_hash
!= NULL
)
4837 BFD_ASSERT (((*sym_hash
)->flags
& XCOFF_SET_TOC
) == 0);
4838 BFD_ASSERT ((*sym_hash
)->toc_section
!= NULL
);
4839 (*sym_hash
)->u
.toc_indx
= output_index
;
4842 output_index
+= add
;
4843 outsym
+= add
* osymesz
;
4846 esym
+= add
* isymesz
;
4850 if (debug_index
!= NULL
)
4853 for (--add
; add
> 0; --add
)
4857 /* Fix up the aux entries and the C_BSTAT symbols. This must be
4858 done in a separate pass, because we don't know the correct symbol
4859 indices until we have already decided which symbols we are going
4862 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
4863 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
4864 isymp
= finfo
->internal_syms
;
4865 indexp
= finfo
->sym_indices
;
4866 csectpp
= xcoff_data (input_bfd
)->csects
;
4867 outsym
= finfo
->outsyms
;
4868 while (esym
< esym_end
)
4872 add
= 1 + isymp
->n_numaux
;
4875 esym
+= add
* isymesz
;
4880 if (isymp
->n_sclass
== C_BSTAT
)
4882 struct internal_syment isym
;
4885 /* The value of a C_BSTAT symbol is the symbol table
4886 index of the containing csect. */
4887 bfd_coff_swap_sym_in (output_bfd
, (PTR
) outsym
, (PTR
) &isym
);
4888 indx
= isym
.n_value
;
4889 if (indx
< obj_raw_syment_count (input_bfd
))
4893 symindx
= finfo
->sym_indices
[indx
];
4897 isym
.n_value
= symindx
;
4898 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
,
4906 for (i
= 0; i
< isymp
->n_numaux
&& esym
< esym_end
; i
++)
4908 union internal_auxent aux
;
4910 bfd_coff_swap_aux_in (input_bfd
, (PTR
) esym
, isymp
->n_type
,
4911 isymp
->n_sclass
, i
, isymp
->n_numaux
,
4914 if (isymp
->n_sclass
== C_FILE
)
4916 /* This is the file name (or some comment put in by
4917 the compiler). If it is long, we must put it in
4918 the string table. */
4919 if (aux
.x_file
.x_n
.x_zeroes
== 0
4920 && aux
.x_file
.x_n
.x_offset
!= 0)
4922 const char *filename
;
4925 BFD_ASSERT (aux
.x_file
.x_n
.x_offset
4926 >= STRING_SIZE_SIZE
);
4927 if (strings
== NULL
)
4929 strings
= _bfd_coff_read_string_table (input_bfd
);
4930 if (strings
== NULL
)
4933 filename
= strings
+ aux
.x_file
.x_n
.x_offset
;
4934 indx
= _bfd_stringtab_add (finfo
->strtab
, filename
,
4936 if (indx
== (bfd_size_type
) -1)
4938 aux
.x_file
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
4941 else if ((isymp
->n_sclass
== C_EXT
4942 || isymp
->n_sclass
== C_HIDEXT
)
4943 && i
+ 1 == isymp
->n_numaux
)
4945 /* We don't support type checking. I don't know if
4947 aux
.x_csect
.x_parmhash
= 0;
4948 /* I don't think anybody uses these fields, but we'd
4949 better clobber them just in case. */
4950 aux
.x_csect
.x_stab
= 0;
4951 aux
.x_csect
.x_snstab
= 0;
4952 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_LD
)
4956 indx
= aux
.x_csect
.x_scnlen
.l
;
4957 if (indx
< obj_raw_syment_count (input_bfd
))
4961 symindx
= finfo
->sym_indices
[indx
];
4963 aux
.x_sym
.x_tagndx
.l
= 0;
4965 aux
.x_sym
.x_tagndx
.l
= symindx
;
4969 else if (isymp
->n_sclass
!= C_STAT
|| isymp
->n_type
!= T_NULL
)
4973 if (ISFCN (isymp
->n_type
)
4974 || ISTAG (isymp
->n_sclass
)
4975 || isymp
->n_sclass
== C_BLOCK
4976 || isymp
->n_sclass
== C_FCN
)
4978 indx
= aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
4980 && indx
< obj_raw_syment_count (input_bfd
))
4982 /* We look forward through the symbol for
4983 the index of the next symbol we are going
4984 to include. I don't know if this is
4986 while (finfo
->sym_indices
[indx
] < 0
4987 && indx
< obj_raw_syment_count (input_bfd
))
4989 if (indx
>= obj_raw_syment_count (input_bfd
))
4990 indx
= output_index
;
4992 indx
= finfo
->sym_indices
[indx
];
4993 aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= indx
;
4997 indx
= aux
.x_sym
.x_tagndx
.l
;
4998 if (indx
> 0 && indx
< obj_raw_syment_count (input_bfd
))
5002 symindx
= finfo
->sym_indices
[indx
];
5004 aux
.x_sym
.x_tagndx
.l
= 0;
5006 aux
.x_sym
.x_tagndx
.l
= symindx
;
5010 /* Copy over the line numbers, unless we are stripping
5011 them. We do this on a symbol by symbol basis in
5012 order to more easily handle garbage collection. */
5013 if ((isymp
->n_sclass
== C_EXT
5014 || isymp
->n_sclass
== C_HIDEXT
)
5016 && isymp
->n_numaux
> 1
5017 && ISFCN (isymp
->n_type
)
5018 && aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
5020 if (finfo
->info
->strip
!= strip_none
5021 && finfo
->info
->strip
!= strip_some
)
5022 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
5025 asection
*enclosing
;
5026 unsigned int enc_count
;
5027 bfd_size_type linoff
;
5028 struct internal_lineno lin
;
5031 enclosing
= xcoff_section_data (abfd
, o
)->enclosing
;
5032 enc_count
= xcoff_section_data (abfd
, o
)->lineno_count
;
5033 if (oline
!= enclosing
)
5035 if (bfd_seek (input_bfd
,
5036 enclosing
->line_filepos
,
5038 || (bfd_read (finfo
->linenos
, linesz
,
5039 enc_count
, input_bfd
)
5040 != linesz
* enc_count
))
5045 linoff
= (aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
5046 - enclosing
->line_filepos
);
5048 bfd_coff_swap_lineno_in (input_bfd
,
5049 (PTR
) (finfo
->linenos
+ linoff
),
5052 || ((bfd_size_type
) lin
.l_addr
.l_symndx
5056 obj_coff_external_syms (input_bfd
)))
5058 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
5061 bfd_byte
*linpend
, *linp
;
5063 bfd_size_type count
;
5065 lin
.l_addr
.l_symndx
= *indexp
;
5066 bfd_coff_swap_lineno_out (output_bfd
, (PTR
) &lin
,
5067 (PTR
) (finfo
->linenos
5070 linpend
= (finfo
->linenos
5071 + enc_count
* linesz
);
5072 offset
= (o
->output_section
->vma
5075 for (linp
= finfo
->linenos
+ linoff
+ linesz
;
5079 bfd_coff_swap_lineno_in (input_bfd
, (PTR
) linp
,
5081 if (lin
.l_lnno
== 0)
5083 lin
.l_addr
.l_paddr
+= offset
;
5084 bfd_coff_swap_lineno_out (output_bfd
,
5089 count
= (linp
- (finfo
->linenos
+ linoff
)) / linesz
;
5091 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
5092 (o
->output_section
->line_filepos
5093 + o
->output_section
->lineno_count
* linesz
);
5095 if (bfd_seek (output_bfd
,
5096 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
,
5098 || (bfd_write (finfo
->linenos
+ linoff
,
5099 linesz
, count
, output_bfd
)
5103 o
->output_section
->lineno_count
+= count
;
5107 struct internal_syment
*iisp
, *iispend
;
5112 /* Update any C_BINCL or C_EINCL symbols
5113 that refer to a line number in the
5114 range we just output. */
5115 iisp
= finfo
->internal_syms
;
5117 + obj_raw_syment_count (input_bfd
));
5118 iindp
= finfo
->sym_indices
;
5119 oos
= finfo
->outsyms
;
5120 while (iisp
< iispend
)
5123 && (iisp
->n_sclass
== C_BINCL
5124 || iisp
->n_sclass
== C_EINCL
)
5125 && ((bfd_size_type
) iisp
->n_value
5126 >= enclosing
->line_filepos
+ linoff
)
5127 && ((bfd_size_type
) iisp
->n_value
5128 < (enclosing
->line_filepos
5129 + enc_count
* linesz
)))
5131 struct internal_syment iis
;
5133 bfd_coff_swap_sym_in (output_bfd
,
5138 - enclosing
->line_filepos
5140 + aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
);
5141 bfd_coff_swap_sym_out (output_bfd
,
5147 iiadd
= 1 + iisp
->n_numaux
;
5149 oos
+= iiadd
* osymesz
;
5158 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &aux
, isymp
->n_type
,
5159 isymp
->n_sclass
, i
, isymp
->n_numaux
,
5171 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
5172 symbol will be the first symbol in the next input file. In the
5173 normal case, this will save us from writing out the C_FILE symbol
5175 if (finfo
->last_file_index
!= -1
5176 && (bfd_size_type
) finfo
->last_file_index
>= syment_base
)
5178 finfo
->last_file
.n_value
= output_index
;
5179 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &finfo
->last_file
,
5180 (PTR
) (finfo
->outsyms
5181 + ((finfo
->last_file_index
- syment_base
)
5185 /* Write the modified symbols to the output file. */
5186 if (outsym
> finfo
->outsyms
)
5188 if (bfd_seek (output_bfd
,
5189 obj_sym_filepos (output_bfd
) + syment_base
* osymesz
,
5191 || (bfd_write (finfo
->outsyms
, outsym
- finfo
->outsyms
, 1,
5193 != (bfd_size_type
) (outsym
- finfo
->outsyms
)))
5196 BFD_ASSERT ((obj_raw_syment_count (output_bfd
)
5197 + (outsym
- finfo
->outsyms
) / osymesz
)
5200 obj_raw_syment_count (output_bfd
) = output_index
;
5203 /* Don't let the linker relocation routines discard the symbols. */
5204 keep_syms
= obj_coff_keep_syms (input_bfd
);
5205 obj_coff_keep_syms (input_bfd
) = true;
5207 /* Relocate the contents of each section. */
5208 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5212 if (! o
->linker_mark
)
5214 /* This section was omitted from the link. */
5218 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5219 || o
->_raw_size
== 0
5220 || (o
->flags
& SEC_IN_MEMORY
) != 0)
5223 /* We have set filepos correctly for the sections we created to
5224 represent csects, so bfd_get_section_contents should work. */
5225 if (coff_section_data (input_bfd
, o
) != NULL
5226 && coff_section_data (input_bfd
, o
)->contents
!= NULL
)
5227 contents
= coff_section_data (input_bfd
, o
)->contents
;
5230 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
5231 (file_ptr
) 0, o
->_raw_size
))
5233 contents
= finfo
->contents
;
5236 if ((o
->flags
& SEC_RELOC
) != 0)
5239 struct internal_reloc
*internal_relocs
;
5240 struct internal_reloc
*irel
;
5242 struct internal_reloc
*irelend
;
5243 struct xcoff_link_hash_entry
**rel_hash
;
5246 /* Read in the relocs. */
5247 target_index
= o
->output_section
->target_index
;
5248 internal_relocs
= (xcoff_read_internal_relocs
5249 (input_bfd
, o
, false, finfo
->external_relocs
,
5251 (finfo
->section_info
[target_index
].relocs
5252 + o
->output_section
->reloc_count
)));
5253 if (internal_relocs
== NULL
)
5256 /* Call processor specific code to relocate the section
5258 if (! bfd_coff_relocate_section (output_bfd
, finfo
->info
,
5262 finfo
->internal_syms
,
5263 xcoff_data (input_bfd
)->csects
))
5266 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
5267 irel
= internal_relocs
;
5268 irelend
= irel
+ o
->reloc_count
;
5269 rel_hash
= (finfo
->section_info
[target_index
].rel_hashes
5270 + o
->output_section
->reloc_count
);
5271 for (; irel
< irelend
; irel
++, rel_hash
++)
5273 struct xcoff_link_hash_entry
*h
= NULL
;
5274 struct internal_ldrel ldrel
;
5279 /* Adjust the reloc address and symbol index. */
5281 irel
->r_vaddr
+= offset
;
5283 r_symndx
= irel
->r_symndx
;
5287 h
= obj_xcoff_sym_hashes (input_bfd
)[r_symndx
];
5289 && h
->smclas
!= XMC_TD
5290 && (irel
->r_type
== R_TOC
5291 || irel
->r_type
== R_GL
5292 || irel
->r_type
== R_TCL
5293 || irel
->r_type
== R_TRL
5294 || irel
->r_type
== R_TRLA
))
5296 /* This is a TOC relative reloc with a symbol
5297 attached. The symbol should be the one which
5298 this reloc is for. We want to make this
5299 reloc against the TOC address of the symbol,
5300 not the symbol itself. */
5301 BFD_ASSERT (h
->toc_section
!= NULL
);
5302 BFD_ASSERT ((h
->flags
& XCOFF_SET_TOC
) == 0);
5303 if (h
->u
.toc_indx
!= -1)
5304 irel
->r_symndx
= h
->u
.toc_indx
;
5307 struct xcoff_toc_rel_hash
*n
;
5308 struct xcoff_link_section_info
*si
;
5310 n
= ((struct xcoff_toc_rel_hash
*)
5311 bfd_alloc (finfo
->output_bfd
,
5312 sizeof (struct xcoff_toc_rel_hash
)));
5315 si
= finfo
->section_info
+ target_index
;
5316 n
->next
= si
->toc_rel_hashes
;
5319 si
->toc_rel_hashes
= n
;
5324 /* This is a global symbol. */
5326 irel
->r_symndx
= h
->indx
;
5329 /* This symbol is being written at the end
5330 of the file, and we do not yet know the
5331 symbol index. We save the pointer to the
5332 hash table entry in the rel_hash list.
5333 We set the indx field to -2 to indicate
5334 that this symbol must not be stripped. */
5343 indx
= finfo
->sym_indices
[r_symndx
];
5347 struct internal_syment
*is
;
5349 /* Relocations against a TC0 TOC anchor are
5350 automatically transformed to be against
5351 the TOC anchor in the output file. */
5352 is
= finfo
->internal_syms
+ r_symndx
;
5353 if (is
->n_sclass
== C_HIDEXT
5354 && is
->n_numaux
> 0)
5357 union internal_auxent aux
;
5361 obj_coff_external_syms (input_bfd
))
5362 + ((r_symndx
+ is
->n_numaux
)
5364 bfd_coff_swap_aux_in (input_bfd
, auxptr
,
5365 is
->n_type
, is
->n_sclass
,
5369 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_SD
5370 && aux
.x_csect
.x_smclas
== XMC_TC0
)
5371 indx
= finfo
->toc_symindx
;
5376 irel
->r_symndx
= indx
;
5379 struct internal_syment
*is
;
5381 char buf
[SYMNMLEN
+ 1];
5383 /* This reloc is against a symbol we are
5384 stripping. It would be possible to handle
5385 this case, but I don't think it's worth it. */
5386 is
= finfo
->internal_syms
+ r_symndx
;
5388 name
= (_bfd_coff_internal_syment_name
5389 (input_bfd
, is
, buf
));
5393 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
5394 (finfo
->info
, name
, input_bfd
, o
,
5402 switch (irel
->r_type
)
5406 || h
->root
.type
== bfd_link_hash_defined
5407 || h
->root
.type
== bfd_link_hash_defweak
5408 || h
->root
.type
== bfd_link_hash_common
)
5415 /* This reloc needs to be copied into the .loader
5417 ldrel
.l_vaddr
= irel
->r_vaddr
;
5419 ldrel
.l_symndx
= -1;
5421 || (h
->root
.type
== bfd_link_hash_defined
5422 || h
->root
.type
== bfd_link_hash_defweak
5423 || h
->root
.type
== bfd_link_hash_common
))
5428 sec
= xcoff_data (input_bfd
)->csects
[r_symndx
];
5429 else if (h
->root
.type
== bfd_link_hash_common
)
5430 sec
= h
->root
.u
.c
.p
->section
;
5432 sec
= h
->root
.u
.def
.section
;
5433 sec
= sec
->output_section
;
5435 if (strcmp (sec
->name
, ".text") == 0)
5437 else if (strcmp (sec
->name
, ".data") == 0)
5439 else if (strcmp (sec
->name
, ".bss") == 0)
5443 (*_bfd_error_handler
)
5444 ("%s: loader reloc in unrecognized section `%s'",
5445 bfd_get_filename (input_bfd
),
5447 bfd_set_error (bfd_error_nonrepresentable_section
);
5453 if (! finfo
->info
->relocateable
5454 && (h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
5455 && (h
->flags
& XCOFF_IMPORT
) == 0)
5457 /* We already called the undefined_symbol
5458 callback for this relocation, in
5459 _bfd_ppc_xcoff_relocate_section. Don't
5460 issue any more warnings. */
5463 if (h
->ldindx
< 0 && ! quiet
)
5465 (*_bfd_error_handler
)
5466 ("%s: `%s' in loader reloc but not loader sym",
5467 bfd_get_filename (input_bfd
),
5468 h
->root
.root
.string
);
5469 bfd_set_error (bfd_error_bad_value
);
5472 ldrel
.l_symndx
= h
->ldindx
;
5474 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
5475 ldrel
.l_rsecnm
= o
->output_section
->target_index
;
5476 if (xcoff_hash_table (finfo
->info
)->textro
5477 && strcmp (o
->output_section
->name
, ".text") == 0
5480 (*_bfd_error_handler
)
5481 ("%s: loader reloc in read-only section %s",
5482 bfd_get_filename (input_bfd
),
5483 bfd_get_section_name (finfo
->output_bfd
,
5484 o
->output_section
));
5485 bfd_set_error (bfd_error_invalid_operation
);
5488 xcoff_swap_ldrel_out (output_bfd
, &ldrel
,
5490 BFD_ASSERT (sizeof (struct external_ldrel
) == LDRELSZ
);
5499 /* We should never need a .loader reloc for a TOC
5505 o
->output_section
->reloc_count
+= o
->reloc_count
;
5508 /* Write out the modified section contents. */
5509 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
5510 contents
, o
->output_offset
,
5511 (o
->_cooked_size
!= 0
5517 obj_coff_keep_syms (input_bfd
) = keep_syms
;
5519 if (! finfo
->info
->keep_memory
)
5521 if (! _bfd_coff_free_symbols (input_bfd
))
5531 /* Write out a non-XCOFF global symbol. */
5534 xcoff_write_global_symbol (h
, p
)
5535 struct xcoff_link_hash_entry
*h
;
5538 struct xcoff_final_link_info
*finfo
= (struct xcoff_final_link_info
*) p
;
5541 struct internal_syment isym
;
5542 union internal_auxent aux
;
5544 output_bfd
= finfo
->output_bfd
;
5545 outsym
= finfo
->outsyms
;
5547 /* If this symbol was garbage collected, just skip it. */
5548 if (xcoff_hash_table (finfo
->info
)->gc
5549 && (h
->flags
& XCOFF_MARK
) == 0)
5552 /* If we need a .loader section entry, write it out. */
5553 if (h
->ldsym
!= NULL
)
5555 struct internal_ldsym
*ldsym
;
5560 if (h
->root
.type
== bfd_link_hash_undefined
5561 || h
->root
.type
== bfd_link_hash_undefweak
)
5564 ldsym
->l_scnum
= N_UNDEF
;
5565 ldsym
->l_smtype
= XTY_ER
;
5566 impbfd
= h
->root
.u
.undef
.abfd
;
5568 else if (h
->root
.type
== bfd_link_hash_defined
5569 || h
->root
.type
== bfd_link_hash_defweak
)
5573 sec
= h
->root
.u
.def
.section
;
5574 ldsym
->l_value
= (sec
->output_section
->vma
5575 + sec
->output_offset
5576 + h
->root
.u
.def
.value
);
5577 ldsym
->l_scnum
= sec
->output_section
->target_index
;
5578 ldsym
->l_smtype
= XTY_SD
;
5579 impbfd
= sec
->owner
;
5584 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
5585 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
5586 || (h
->flags
& XCOFF_IMPORT
) != 0)
5587 ldsym
->l_smtype
|= L_IMPORT
;
5588 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
5589 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
5590 || (h
->flags
& XCOFF_EXPORT
) != 0)
5591 ldsym
->l_smtype
|= L_EXPORT
;
5592 if ((h
->flags
& XCOFF_ENTRY
) != 0)
5593 ldsym
->l_smtype
|= L_ENTRY
;
5595 ldsym
->l_smclas
= h
->smclas
;
5597 if (ldsym
->l_ifile
== (bfd_size_type
) -1)
5599 else if (ldsym
->l_ifile
== 0)
5601 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
5603 else if (impbfd
== NULL
)
5607 BFD_ASSERT (impbfd
->xvec
== output_bfd
->xvec
);
5608 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
5614 BFD_ASSERT (h
->ldindx
>= 0);
5615 BFD_ASSERT (LDSYMSZ
== sizeof (struct external_ldsym
));
5616 xcoff_swap_ldsym_out (output_bfd
, ldsym
, finfo
->ldsym
+ h
->ldindx
- 3);
5620 /* If this symbol needs global linkage code, write it out. */
5621 if (h
->root
.type
== bfd_link_hash_defined
5622 && (h
->root
.u
.def
.section
5623 == xcoff_hash_table (finfo
->info
)->linkage_section
))
5629 p
= h
->root
.u
.def
.section
->contents
+ h
->root
.u
.def
.value
;
5631 /* The first instruction in the global linkage code loads a
5632 specific TOC element. */
5633 tocoff
= (h
->descriptor
->toc_section
->output_section
->vma
5634 + h
->descriptor
->toc_section
->output_offset
5635 - xcoff_data (output_bfd
)->toc
);
5636 if ((h
->descriptor
->flags
& XCOFF_SET_TOC
) != 0)
5637 tocoff
+= h
->descriptor
->u
.toc_offset
;
5638 bfd_put_32 (output_bfd
, XCOFF_GLINK_FIRST
| (tocoff
& 0xffff), p
);
5640 i
< sizeof xcoff_glink_code
/ sizeof xcoff_glink_code
[0];
5642 bfd_put_32 (output_bfd
, xcoff_glink_code
[i
], p
);
5645 /* If we created a TOC entry for this symbol, write out the required
5647 if ((h
->flags
& XCOFF_SET_TOC
) != 0)
5652 struct internal_reloc
*irel
;
5653 struct internal_ldrel ldrel
;
5654 struct internal_syment irsym
;
5655 union internal_auxent iraux
;
5657 tocsec
= h
->toc_section
;
5658 osec
= tocsec
->output_section
;
5659 oindx
= osec
->target_index
;
5660 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
5661 irel
->r_vaddr
= (osec
->vma
5662 + tocsec
->output_offset
5665 irel
->r_symndx
= h
->indx
;
5669 irel
->r_symndx
= obj_raw_syment_count (output_bfd
);
5671 irel
->r_type
= R_POS
;
5673 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5674 ++osec
->reloc_count
;
5676 BFD_ASSERT (h
->ldindx
>= 0);
5677 ldrel
.l_vaddr
= irel
->r_vaddr
;
5678 ldrel
.l_symndx
= h
->ldindx
;
5679 ldrel
.l_rtype
= (31 << 8) | R_POS
;
5680 ldrel
.l_rsecnm
= oindx
;
5681 xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5684 /* We need to emit a symbol to define a csect which holds the
5686 if (strlen (h
->root
.root
.string
) <= SYMNMLEN
)
5687 strncpy (irsym
._n
._n_name
, h
->root
.root
.string
, SYMNMLEN
);
5694 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
5696 indx
= _bfd_stringtab_add (finfo
->strtab
, h
->root
.root
.string
, hash
,
5698 if (indx
== (bfd_size_type
) -1)
5700 irsym
._n
._n_n
._n_zeroes
= 0;
5701 irsym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
5704 irsym
.n_value
= irel
->r_vaddr
;
5705 irsym
.n_scnum
= osec
->target_index
;
5706 irsym
.n_sclass
= C_HIDEXT
;
5707 irsym
.n_type
= T_NULL
;
5710 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &irsym
, (PTR
) outsym
);
5711 outsym
+= bfd_coff_symesz (output_bfd
);
5713 memset (&iraux
, 0, sizeof iraux
);
5714 iraux
.x_csect
.x_smtyp
= XTY_SD
;
5715 iraux
.x_csect
.x_scnlen
.l
= 4;
5716 iraux
.x_csect
.x_smclas
= XMC_TC
;
5718 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &iraux
, T_NULL
, C_HIDEXT
, 0, 1,
5720 outsym
+= bfd_coff_auxesz (output_bfd
);
5724 /* We aren't going to write out the symbols below, so we
5725 need to write them out now. */
5726 if (bfd_seek (output_bfd
,
5727 (obj_sym_filepos (output_bfd
)
5728 + (obj_raw_syment_count (output_bfd
)
5729 * bfd_coff_symesz (output_bfd
))),
5731 || (bfd_write (finfo
->outsyms
, outsym
- finfo
->outsyms
, 1,
5733 != (bfd_size_type
) (outsym
- finfo
->outsyms
)))
5735 obj_raw_syment_count (output_bfd
) +=
5736 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
5738 outsym
= finfo
->outsyms
;
5742 /* If this symbol is a specially defined function descriptor, write
5743 it out. The first word is the address of the function code
5744 itself, the second word is the address of the TOC, and the third
5746 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
5747 && h
->root
.type
== bfd_link_hash_defined
5748 && (h
->root
.u
.def
.section
5749 == xcoff_hash_table (finfo
->info
)->descriptor_section
))
5755 struct xcoff_link_hash_entry
*hentry
;
5757 struct internal_reloc
*irel
;
5758 struct internal_ldrel ldrel
;
5761 sec
= h
->root
.u
.def
.section
;
5762 osec
= sec
->output_section
;
5763 oindx
= osec
->target_index
;
5764 p
= sec
->contents
+ h
->root
.u
.def
.value
;
5766 hentry
= h
->descriptor
;
5767 BFD_ASSERT (hentry
!= NULL
5768 && (hentry
->root
.type
== bfd_link_hash_defined
5769 || hentry
->root
.type
== bfd_link_hash_defweak
));
5770 esec
= hentry
->root
.u
.def
.section
;
5771 bfd_put_32 (output_bfd
,
5772 (esec
->output_section
->vma
5773 + esec
->output_offset
5774 + hentry
->root
.u
.def
.value
),
5777 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
5778 irel
->r_vaddr
= (osec
->vma
5779 + sec
->output_offset
5780 + h
->root
.u
.def
.value
);
5781 irel
->r_symndx
= esec
->output_section
->target_index
;
5782 irel
->r_type
= R_POS
;
5784 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5785 ++osec
->reloc_count
;
5787 ldrel
.l_vaddr
= irel
->r_vaddr
;
5788 if (strcmp (esec
->output_section
->name
, ".text") == 0)
5790 else if (strcmp (esec
->output_section
->name
, ".data") == 0)
5792 else if (strcmp (esec
->output_section
->name
, ".bss") == 0)
5796 (*_bfd_error_handler
)
5797 ("%s: loader reloc in unrecognized section `%s'",
5798 bfd_get_filename (output_bfd
),
5799 esec
->output_section
->name
);
5800 bfd_set_error (bfd_error_nonrepresentable_section
);
5803 ldrel
.l_rtype
= (31 << 8) | R_POS
;
5804 ldrel
.l_rsecnm
= oindx
;
5805 xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5808 bfd_put_32 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 4);
5810 tsec
= coff_section_from_bfd_index (output_bfd
,
5811 xcoff_data (output_bfd
)->sntoc
);
5814 irel
->r_vaddr
= (osec
->vma
5815 + sec
->output_offset
5816 + h
->root
.u
.def
.value
5818 irel
->r_symndx
= tsec
->output_section
->target_index
;
5819 irel
->r_type
= R_POS
;
5821 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5822 ++osec
->reloc_count
;
5824 ldrel
.l_vaddr
= irel
->r_vaddr
;
5825 if (strcmp (tsec
->output_section
->name
, ".text") == 0)
5827 else if (strcmp (tsec
->output_section
->name
, ".data") == 0)
5829 else if (strcmp (tsec
->output_section
->name
, ".bss") == 0)
5833 (*_bfd_error_handler
)
5834 ("%s: loader reloc in unrecognized section `%s'",
5835 bfd_get_filename (output_bfd
),
5836 tsec
->output_section
->name
);
5837 bfd_set_error (bfd_error_nonrepresentable_section
);
5840 ldrel
.l_rtype
= (31 << 8) | R_POS
;
5841 ldrel
.l_rsecnm
= oindx
;
5842 xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5848 BFD_ASSERT (outsym
== finfo
->outsyms
);
5853 && (finfo
->info
->strip
== strip_all
5854 || (finfo
->info
->strip
== strip_some
5855 && (bfd_hash_lookup (finfo
->info
->keep_hash
,
5856 h
->root
.root
.string
, false, false)
5859 BFD_ASSERT (outsym
== finfo
->outsyms
);
5864 && (h
->flags
& (XCOFF_REF_REGULAR
| XCOFF_DEF_REGULAR
)) == 0)
5866 BFD_ASSERT (outsym
== finfo
->outsyms
);
5870 memset (&aux
, 0, sizeof aux
);
5872 h
->indx
= obj_raw_syment_count (output_bfd
);
5874 if (strlen (h
->root
.root
.string
) <= SYMNMLEN
)
5875 strncpy (isym
._n
._n_name
, h
->root
.root
.string
, SYMNMLEN
);
5882 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
5884 indx
= _bfd_stringtab_add (finfo
->strtab
, h
->root
.root
.string
, hash
,
5886 if (indx
== (bfd_size_type
) -1)
5888 isym
._n
._n_n
._n_zeroes
= 0;
5889 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
5892 if (h
->root
.type
== bfd_link_hash_undefined
5893 || h
->root
.type
== bfd_link_hash_undefweak
)
5896 isym
.n_scnum
= N_UNDEF
;
5897 isym
.n_sclass
= C_EXT
;
5898 aux
.x_csect
.x_smtyp
= XTY_ER
;
5900 else if ((h
->root
.type
== bfd_link_hash_defined
5901 || h
->root
.type
== bfd_link_hash_defweak
)
5902 && h
->smclas
== XMC_XO
)
5904 BFD_ASSERT (bfd_is_abs_section (h
->root
.u
.def
.section
));
5905 isym
.n_value
= h
->root
.u
.def
.value
;
5906 isym
.n_scnum
= N_UNDEF
;
5907 isym
.n_sclass
= C_EXT
;
5908 aux
.x_csect
.x_smtyp
= XTY_ER
;
5910 else if (h
->root
.type
== bfd_link_hash_defined
5911 || h
->root
.type
== bfd_link_hash_defweak
)
5913 struct xcoff_link_size_list
*l
;
5915 isym
.n_value
= (h
->root
.u
.def
.section
->output_section
->vma
5916 + h
->root
.u
.def
.section
->output_offset
5917 + h
->root
.u
.def
.value
);
5918 isym
.n_scnum
= h
->root
.u
.def
.section
->output_section
->target_index
;
5919 isym
.n_sclass
= C_HIDEXT
;
5920 aux
.x_csect
.x_smtyp
= XTY_SD
;
5922 if ((h
->flags
& XCOFF_HAS_SIZE
) != 0)
5924 for (l
= xcoff_hash_table (finfo
->info
)->size_list
;
5930 aux
.x_csect
.x_scnlen
.l
= l
->size
;
5936 else if (h
->root
.type
== bfd_link_hash_common
)
5938 isym
.n_value
= (h
->root
.u
.c
.p
->section
->output_section
->vma
5939 + h
->root
.u
.c
.p
->section
->output_offset
);
5940 isym
.n_scnum
= h
->root
.u
.c
.p
->section
->output_section
->target_index
;
5941 isym
.n_sclass
= C_EXT
;
5942 aux
.x_csect
.x_smtyp
= XTY_CM
;
5943 aux
.x_csect
.x_scnlen
.l
= h
->root
.u
.c
.size
;
5948 isym
.n_type
= T_NULL
;
5951 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
, (PTR
) outsym
);
5952 outsym
+= bfd_coff_symesz (output_bfd
);
5954 aux
.x_csect
.x_smclas
= h
->smclas
;
5956 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &aux
, T_NULL
, isym
.n_sclass
, 0, 1,
5958 outsym
+= bfd_coff_auxesz (output_bfd
);
5960 if ((h
->root
.type
== bfd_link_hash_defined
5961 || h
->root
.type
== bfd_link_hash_defweak
)
5962 && h
->smclas
!= XMC_XO
)
5964 /* We just output an SD symbol. Now output an LD symbol. */
5968 isym
.n_sclass
= C_EXT
;
5969 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
, (PTR
) outsym
);
5970 outsym
+= bfd_coff_symesz (output_bfd
);
5972 aux
.x_csect
.x_smtyp
= XTY_LD
;
5973 aux
.x_csect
.x_scnlen
.l
= obj_raw_syment_count (output_bfd
);
5975 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &aux
, T_NULL
, C_EXT
, 0, 1,
5977 outsym
+= bfd_coff_auxesz (output_bfd
);
5980 if (bfd_seek (output_bfd
,
5981 (obj_sym_filepos (output_bfd
)
5982 + (obj_raw_syment_count (output_bfd
)
5983 * bfd_coff_symesz (output_bfd
))),
5985 || (bfd_write (finfo
->outsyms
, outsym
- finfo
->outsyms
, 1, output_bfd
)
5986 != (bfd_size_type
) (outsym
- finfo
->outsyms
)))
5988 obj_raw_syment_count (output_bfd
) +=
5989 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
5994 /* Handle a link order which is supposed to generate a reloc. */
5997 xcoff_reloc_link_order (output_bfd
, finfo
, output_section
, link_order
)
5999 struct xcoff_final_link_info
*finfo
;
6000 asection
*output_section
;
6001 struct bfd_link_order
*link_order
;
6003 reloc_howto_type
*howto
;
6004 struct xcoff_link_hash_entry
*h
;
6008 struct internal_reloc
*irel
;
6009 struct xcoff_link_hash_entry
**rel_hash_ptr
;
6010 struct internal_ldrel ldrel
;
6012 if (link_order
->type
== bfd_section_reloc_link_order
)
6014 /* We need to somehow locate a symbol in the right section. The
6015 symbol must either have a value of zero, or we must adjust
6016 the addend by the value of the symbol. FIXME: Write this
6017 when we need it. The old linker couldn't handle this anyhow. */
6021 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
6024 bfd_set_error (bfd_error_bad_value
);
6028 h
= ((struct xcoff_link_hash_entry
*)
6029 bfd_wrapped_link_hash_lookup (output_bfd
, finfo
->info
,
6030 link_order
->u
.reloc
.p
->u
.name
,
6031 false, false, true));
6034 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
6035 (finfo
->info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
6036 (asection
*) NULL
, (bfd_vma
) 0)))
6041 if (h
->root
.type
== bfd_link_hash_common
)
6043 hsec
= h
->root
.u
.c
.p
->section
;
6046 else if (h
->root
.type
== bfd_link_hash_defined
6047 || h
->root
.type
== bfd_link_hash_defweak
)
6049 hsec
= h
->root
.u
.def
.section
;
6050 hval
= h
->root
.u
.def
.value
;
6058 addend
= link_order
->u
.reloc
.p
->addend
;
6060 addend
+= (hsec
->output_section
->vma
6061 + hsec
->output_offset
6068 bfd_reloc_status_type rstat
;
6071 size
= bfd_get_reloc_size (howto
);
6072 buf
= (bfd_byte
*) bfd_zmalloc (size
);
6076 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
6082 case bfd_reloc_outofrange
:
6084 case bfd_reloc_overflow
:
6085 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
6086 (finfo
->info
, link_order
->u
.reloc
.p
->u
.name
,
6087 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
6095 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
6096 (file_ptr
) link_order
->offset
, size
);
6102 /* Store the reloc information in the right place. It will get
6103 swapped and written out at the end of the final_link routine. */
6105 irel
= (finfo
->section_info
[output_section
->target_index
].relocs
6106 + output_section
->reloc_count
);
6107 rel_hash_ptr
= (finfo
->section_info
[output_section
->target_index
].rel_hashes
6108 + output_section
->reloc_count
);
6110 memset (irel
, 0, sizeof (struct internal_reloc
));
6111 *rel_hash_ptr
= NULL
;
6113 irel
->r_vaddr
= output_section
->vma
+ link_order
->offset
;
6116 irel
->r_symndx
= h
->indx
;
6119 /* Set the index to -2 to force this symbol to get written out. */
6125 irel
->r_type
= howto
->type
;
6126 irel
->r_size
= howto
->bitsize
- 1;
6127 if (howto
->complain_on_overflow
== complain_overflow_signed
)
6128 irel
->r_size
|= 0x80;
6130 ++output_section
->reloc_count
;
6132 /* Now output the reloc to the .loader section. */
6134 ldrel
.l_vaddr
= irel
->r_vaddr
;
6138 const char *secname
;
6140 secname
= hsec
->output_section
->name
;
6142 if (strcmp (secname
, ".text") == 0)
6144 else if (strcmp (secname
, ".data") == 0)
6146 else if (strcmp (secname
, ".bss") == 0)
6150 (*_bfd_error_handler
)
6151 ("%s: loader reloc in unrecognized section `%s'",
6152 bfd_get_filename (output_bfd
), secname
);
6153 bfd_set_error (bfd_error_nonrepresentable_section
);
6161 (*_bfd_error_handler
)
6162 ("%s: `%s' in loader reloc but not loader sym",
6163 bfd_get_filename (output_bfd
),
6164 h
->root
.root
.string
);
6165 bfd_set_error (bfd_error_bad_value
);
6168 ldrel
.l_symndx
= h
->ldindx
;
6171 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
6172 ldrel
.l_rsecnm
= output_section
->target_index
;
6173 xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
6179 /* Sort relocs by VMA. This is called via qsort. */
6182 xcoff_sort_relocs (p1
, p2
)
6186 const struct internal_reloc
*r1
= (const struct internal_reloc
*) p1
;
6187 const struct internal_reloc
*r2
= (const struct internal_reloc
*) p2
;
6189 if (r1
->r_vaddr
> r2
->r_vaddr
)
6191 else if (r1
->r_vaddr
< r2
->r_vaddr
)
6197 /* This is the relocation function for the RS/6000/POWER/PowerPC.
6198 This is currently the only processor which uses XCOFF; I hope that
6199 will never change. */
6202 _bfd_ppc_xcoff_relocate_section (output_bfd
, info
, input_bfd
,
6203 input_section
, contents
, relocs
, syms
,
6206 struct bfd_link_info
*info
;
6208 asection
*input_section
;
6210 struct internal_reloc
*relocs
;
6211 struct internal_syment
*syms
;
6212 asection
**sections
;
6214 struct internal_reloc
*rel
;
6215 struct internal_reloc
*relend
;
6218 relend
= rel
+ input_section
->reloc_count
;
6219 for (; rel
< relend
; rel
++)
6222 struct xcoff_link_hash_entry
*h
;
6223 struct internal_syment
*sym
;
6226 struct reloc_howto_struct howto
;
6227 bfd_reloc_status_type rstat
;
6229 /* Relocation type R_REF is a special relocation type which is
6230 merely used to prevent garbage collection from occurring for
6231 the csect including the symbol which it references. */
6232 if (rel
->r_type
== R_REF
)
6235 symndx
= rel
->r_symndx
;
6245 h
= obj_xcoff_sym_hashes (input_bfd
)[symndx
];
6246 sym
= syms
+ symndx
;
6247 addend
= - sym
->n_value
;
6250 /* We build the howto information on the fly. */
6252 howto
.type
= rel
->r_type
;
6253 howto
.rightshift
= 0;
6255 howto
.bitsize
= (rel
->r_size
& 0x1f) + 1;
6256 howto
.pc_relative
= false;
6258 if ((rel
->r_size
& 0x80) != 0)
6259 howto
.complain_on_overflow
= complain_overflow_signed
;
6261 howto
.complain_on_overflow
= complain_overflow_bitfield
;
6262 howto
.special_function
= NULL
;
6263 howto
.name
= "internal";
6264 howto
.partial_inplace
= true;
6265 if (howto
.bitsize
== 32)
6266 howto
.src_mask
= howto
.dst_mask
= 0xffffffff;
6269 howto
.src_mask
= howto
.dst_mask
= (1 << howto
.bitsize
) - 1;
6270 if (howto
.bitsize
== 16)
6273 howto
.pcrel_offset
= false;
6283 sec
= bfd_abs_section_ptr
;
6288 sec
= sections
[symndx
];
6289 /* Hack to make sure we use the right TOC anchor value
6290 if this reloc is against the TOC anchor. */
6291 if (sec
->name
[3] == '0'
6292 && strcmp (sec
->name
, ".tc0") == 0)
6293 val
= xcoff_data (output_bfd
)->toc
;
6295 val
= (sec
->output_section
->vma
6296 + sec
->output_offset
6303 if (h
->root
.type
== bfd_link_hash_defined
6304 || h
->root
.type
== bfd_link_hash_defweak
)
6308 sec
= h
->root
.u
.def
.section
;
6309 val
= (h
->root
.u
.def
.value
6310 + sec
->output_section
->vma
6311 + sec
->output_offset
);
6313 else if (h
->root
.type
== bfd_link_hash_common
)
6317 sec
= h
->root
.u
.c
.p
->section
;
6318 val
= (sec
->output_section
->vma
6319 + sec
->output_offset
);
6321 else if ((h
->flags
& XCOFF_DEF_DYNAMIC
) != 0
6322 || (h
->flags
& XCOFF_IMPORT
) != 0)
6324 /* Every symbol in a shared object is defined somewhere. */
6327 else if (! info
->relocateable
)
6329 if (! ((*info
->callbacks
->undefined_symbol
)
6330 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
6331 rel
->r_vaddr
- input_section
->vma
)))
6334 /* Don't try to process the reloc. It can't help, and
6335 it may generate another error. */
6340 /* I took the relocation type definitions from two documents:
6341 the PowerPC AIX Version 4 Application Binary Interface, First
6342 Edition (April 1992), and the PowerOpen ABI, Big-Endian
6343 32-Bit Hardware Implementation (June 30, 1994). Differences
6344 between the documents are noted below. */
6346 switch (rel
->r_type
)
6351 /* These relocs are defined by the PowerPC ABI to be
6352 relative branches which use half of the difference
6353 between the symbol and the program counter. I can't
6354 quite figure out when this is useful. These relocs are
6355 not defined by the PowerOpen ABI. */
6357 (*_bfd_error_handler
)
6358 ("%s: unsupported relocation type 0x%02x",
6359 bfd_get_filename (input_bfd
), (unsigned int) rel
->r_type
);
6360 bfd_set_error (bfd_error_bad_value
);
6363 /* Simple positive relocation. */
6366 /* Simple negative relocation. */
6370 /* Simple PC relative relocation. */
6371 howto
.pc_relative
= true;
6374 /* TOC relative relocation. The value in the instruction in
6375 the input file is the offset from the input file TOC to
6376 the desired location. We want the offset from the final
6377 TOC to the desired location. We have:
6382 so we must change insn by on - in.
6385 /* Global linkage relocation. The value of this relocation
6386 is the address of the entry in the TOC section. */
6388 /* Local object TOC address. I can't figure out the
6389 difference between this and case R_GL. */
6391 /* TOC relative relocation. A TOC relative load instruction
6392 which may be changed to a load address instruction.
6393 FIXME: We don't currently implement this optimization. */
6395 /* TOC relative relocation. This is a TOC relative load
6396 address instruction which may be changed to a load
6397 instruction. FIXME: I don't know if this is the correct
6399 if (h
!= NULL
&& h
->smclas
!= XMC_TD
)
6401 if (h
->toc_section
== NULL
)
6403 (*_bfd_error_handler
)
6404 ("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry",
6405 bfd_get_filename (input_bfd
), rel
->r_vaddr
,
6406 h
->root
.root
.string
);
6407 bfd_set_error (bfd_error_bad_value
);
6411 BFD_ASSERT ((h
->flags
& XCOFF_SET_TOC
) == 0);
6412 val
= (h
->toc_section
->output_section
->vma
6413 + h
->toc_section
->output_offset
);
6416 val
= ((val
- xcoff_data (output_bfd
)->toc
)
6417 - (sym
->n_value
- xcoff_data (input_bfd
)->toc
));
6421 /* Absolute branch. We don't want to mess with the lower
6422 two bits of the instruction. */
6424 /* The PowerPC ABI defines this as an absolute call which
6425 may be modified to become a relative call. The PowerOpen
6426 ABI does not define this relocation type. */
6428 /* Absolute branch which may be modified to become a
6431 /* The PowerPC ABI defines this as an absolute branch to a
6432 fixed address which may be modified to an absolute branch
6433 to a symbol. The PowerOpen ABI does not define this
6436 /* The PowerPC ABI defines this as an absolute branch to a
6437 fixed address which may be modified to a relative branch.
6438 The PowerOpen ABI does not define this relocation type. */
6439 howto
.src_mask
&= ~3;
6440 howto
.dst_mask
= howto
.src_mask
;
6443 /* Relative branch. We don't want to mess with the lower
6444 two bits of the instruction. */
6446 /* The PowerPC ABI defines this as a relative call which may
6447 be modified to become an absolute call. The PowerOpen
6448 ABI does not define this relocation type. */
6450 /* A relative branch which may be modified to become an
6451 absolute branch. FIXME: We don't implement this,
6452 although we should for symbols of storage mapping class
6454 howto
.pc_relative
= true;
6455 howto
.src_mask
&= ~3;
6456 howto
.dst_mask
= howto
.src_mask
;
6459 /* The PowerPC AIX ABI describes this as a load which may be
6460 changed to a load address. The PowerOpen ABI says this
6461 is the same as case R_POS. */
6464 /* The PowerPC AIX ABI describes this as a load address
6465 which may be changed to a load. The PowerOpen ABI says
6466 this is the same as R_POS. */
6470 /* If we see an R_BR or R_RBR reloc which is jumping to global
6471 linkage code, and it is followed by an appropriate cror nop
6472 instruction, we replace the cror with lwz r2,20(r1). This
6473 restores the TOC after the glink code. Contrariwise, if the
6474 call is followed by a lwz r2,20(r1), but the call is not
6475 going to global linkage code, we can replace the load with a
6477 if ((rel
->r_type
== R_BR
|| rel
->r_type
== R_RBR
)
6479 && h
->root
.type
== bfd_link_hash_defined
6480 && (rel
->r_vaddr
- input_section
->vma
+ 8
6481 <= input_section
->_cooked_size
))
6486 pnext
= contents
+ (rel
->r_vaddr
- input_section
->vma
) + 4;
6487 next
= bfd_get_32 (input_bfd
, pnext
);
6489 /* The _ptrgl function is magic. It is used by the AIX
6490 compiler to call a function through a pointer. */
6491 if (h
->smclas
== XMC_GL
6492 || strcmp (h
->root
.root
.string
, "._ptrgl") == 0)
6494 if (next
== 0x4def7b82 /* cror 15,15,15 */
6495 || next
== 0x4ffffb82) /* cror 31,31,31 */
6496 bfd_put_32 (input_bfd
, 0x80410014, pnext
); /* lwz r1,20(r1) */
6500 if (next
== 0x80410014) /* lwz r1,20(r1) */
6501 bfd_put_32 (input_bfd
, 0x4ffffb82, pnext
); /* cror 31,31,31 */
6505 /* A PC relative reloc includes the section address. */
6506 if (howto
.pc_relative
)
6507 addend
+= input_section
->vma
;
6509 rstat
= _bfd_final_link_relocate (&howto
, input_bfd
, input_section
,
6511 rel
->r_vaddr
- input_section
->vma
,
6520 case bfd_reloc_overflow
:
6523 char buf
[SYMNMLEN
+ 1];
6524 char howto_name
[10];
6529 name
= h
->root
.root
.string
;
6532 name
= _bfd_coff_internal_syment_name (input_bfd
, sym
, buf
);
6536 sprintf (howto_name
, "0x%02x", rel
->r_type
);
6538 if (! ((*info
->callbacks
->reloc_overflow
)
6539 (info
, name
, howto_name
, (bfd_vma
) 0, input_bfd
,
6540 input_section
, rel
->r_vaddr
- input_section
->vma
)))