1 /* POWER/PowerPC XCOFF linker support.
2 Copyright 1995, 1996 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>, Cygnus Support.
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 symbo lindex of the C_HIDEXT XMC_TC 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 /* The .loader symbol table index. */
275 /* Some linker flags. */
276 unsigned short flags
;
277 /* Symbol is referenced by a regular object. */
278 #define XCOFF_REF_REGULAR (01)
279 /* Symbol is defined by a regular object. */
280 #define XCOFF_DEF_REGULAR (02)
281 /* Symbol is defined by a dynamic object. */
282 #define XCOFF_DEF_DYNAMIC (04)
283 /* Symbol is used in a reloc being copied into the .loader section. */
284 #define XCOFF_LDREL (010)
285 /* Symbol is the entry point. */
286 #define XCOFF_ENTRY (020)
287 /* Symbol is called; this is, it appears in a R_BR reloc. */
288 #define XCOFF_CALLED (040)
289 /* Symbol needs the TOC entry filled in. */
290 #define XCOFF_SET_TOC (0100)
291 /* Symbol is explicitly imported. */
292 #define XCOFF_IMPORT (0200)
293 /* Symbol is explicitly exported. */
294 #define XCOFF_EXPORT (0400)
295 /* Symbol has been processed by xcoff_build_ldsyms. */
296 #define XCOFF_BUILT_LDSYM (01000)
297 /* Symbol is mentioned by a section which was not garbage collected. */
298 #define XCOFF_MARK (02000)
299 /* Symbol size is recorded in size_list list from hash table. */
300 #define XCOFF_HAS_SIZE (04000)
301 /* Symbol is a function descriptor. */
302 #define XCOFF_DESCRIPTOR (010000)
304 /* The storage mapping class. */
305 unsigned char smclas
;
308 /* The XCOFF linker hash table. */
310 struct xcoff_link_hash_table
312 struct bfd_link_hash_table root
;
314 /* The .debug string hash table. We need to compute this while
315 reading the input files, so that we know how large the .debug
316 section will be before we assign section positions. */
317 struct bfd_strtab_hash
*debug_strtab
;
319 /* The .debug section we will use for the final output. */
320 asection
*debug_section
;
322 /* The .loader section we will use for the final output. */
323 asection
*loader_section
;
325 /* A count of non TOC relative relocs which will need to be
326 allocated in the .loader section. */
329 /* The .loader section header. */
330 struct internal_ldhdr ldhdr
;
332 /* The .gl section we use to hold global linkage code. */
333 asection
*linkage_section
;
335 /* The .tc section we use to hold toc entries we build for global
337 asection
*toc_section
;
339 /* The .ds section we use to hold function descriptors which we
340 create for exported symbols. */
341 asection
*descriptor_section
;
343 /* The list of import files. */
344 struct xcoff_import_file
*imports
;
346 /* Required alignment of sections within the output file. */
347 unsigned long file_align
;
349 /* Whether the .text section must be read-only. */
352 /* Whether garbage collection was done. */
355 /* A linked list of symbols for which we have size information. */
356 struct xcoff_link_size_list
358 struct xcoff_link_size_list
*next
;
359 struct xcoff_link_hash_entry
*h
;
363 /* Magic sections: _text, _etext, _data, _edata, _end, end. */
364 asection
*special_sections
[6];
367 /* Information we keep for each section in the output file during the
370 struct xcoff_link_section_info
372 /* The relocs to be output. */
373 struct internal_reloc
*relocs
;
374 /* For each reloc against a global symbol whose index was not known
375 when the reloc was handled, the global hash table entry. */
376 struct xcoff_link_hash_entry
**rel_hashes
;
377 /* If there is a TOC relative reloc against a global symbol, and the
378 index of the TOC symbol is not known when the reloc was handled,
379 an entry is added to this linked list. This is not an array,
380 like rel_hashes, because this case is quite uncommon. */
381 struct xcoff_toc_rel_hash
383 struct xcoff_toc_rel_hash
*next
;
384 struct xcoff_link_hash_entry
*h
;
385 struct internal_reloc
*rel
;
389 /* Information that we pass around while doing the final link step. */
391 struct xcoff_final_link_info
393 /* General link information. */
394 struct bfd_link_info
*info
;
397 /* Hash table for long symbol names. */
398 struct bfd_strtab_hash
*strtab
;
399 /* Array of information kept for each output section, indexed by the
400 target_index field. */
401 struct xcoff_link_section_info
*section_info
;
402 /* Symbol index of last C_FILE symbol (-1 if none). */
403 long last_file_index
;
404 /* Contents of last C_FILE symbol. */
405 struct internal_syment last_file
;
406 /* Symbol index of TOC symbol. */
408 /* Start of .loader symbols. */
409 struct external_ldsym
*ldsym
;
410 /* Next .loader reloc to swap out. */
411 struct external_ldrel
*ldrel
;
412 /* File position of start of line numbers. */
413 file_ptr line_filepos
;
414 /* Buffer large enough to hold swapped symbols of any input file. */
415 struct internal_syment
*internal_syms
;
416 /* Buffer large enough to hold output indices of symbols of any
419 /* Buffer large enough to hold output symbols for any input file. */
421 /* Buffer large enough to hold external line numbers for any input
424 /* Buffer large enough to hold any input section. */
426 /* Buffer large enough to hold external relocs of any input section. */
427 bfd_byte
*external_relocs
;
430 static void xcoff_swap_ldhdr_in
431 PARAMS ((bfd
*, const struct external_ldhdr
*, struct internal_ldhdr
*));
432 static void xcoff_swap_ldhdr_out
433 PARAMS ((bfd
*, const struct internal_ldhdr
*, struct external_ldhdr
*));
434 static void xcoff_swap_ldsym_in
435 PARAMS ((bfd
*, const struct external_ldsym
*, struct internal_ldsym
*));
436 static void xcoff_swap_ldsym_out
437 PARAMS ((bfd
*, const struct internal_ldsym
*, struct external_ldsym
*));
438 static void xcoff_swap_ldrel_out
439 PARAMS ((bfd
*, const struct internal_ldrel
*, struct external_ldrel
*));
440 static struct bfd_hash_entry
*xcoff_link_hash_newfunc
441 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
442 static struct internal_reloc
*xcoff_read_internal_relocs
443 PARAMS ((bfd
*, asection
*, boolean
, bfd_byte
*, boolean
,
444 struct internal_reloc
*));
445 static boolean xcoff_link_add_object_symbols
446 PARAMS ((bfd
*, struct bfd_link_info
*));
447 static boolean xcoff_link_check_archive_element
448 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*));
449 static boolean xcoff_link_check_ar_symbols
450 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*));
451 static bfd_size_type xcoff_find_reloc
452 PARAMS ((struct internal_reloc
*, bfd_size_type
, bfd_vma
));
453 static boolean xcoff_link_add_symbols
PARAMS ((bfd
*, struct bfd_link_info
*));
454 static boolean xcoff_link_add_dynamic_symbols
455 PARAMS ((bfd
*, struct bfd_link_info
*));
456 static boolean xcoff_mark
PARAMS ((struct bfd_link_info
*, asection
*));
457 static void xcoff_sweep
PARAMS ((struct bfd_link_info
*));
458 static boolean xcoff_build_ldsyms
459 PARAMS ((struct xcoff_link_hash_entry
*, PTR
));
460 static boolean xcoff_link_input_bfd
461 PARAMS ((struct xcoff_final_link_info
*, bfd
*));
462 static boolean xcoff_write_global_symbol
463 PARAMS ((struct xcoff_link_hash_entry
*, PTR
));
464 static boolean xcoff_reloc_link_order
465 PARAMS ((bfd
*, struct xcoff_final_link_info
*, asection
*,
466 struct bfd_link_order
*));
467 static int xcoff_sort_relocs
PARAMS ((const PTR
, const PTR
));
469 /* Routines to swap information in the XCOFF .loader section. If we
470 ever need to write an XCOFF loader, this stuff will need to be
471 moved to another file shared by the linker (which XCOFF calls the
472 ``binder'') and the loader. */
474 /* Swap in the ldhdr structure. */
477 xcoff_swap_ldhdr_in (abfd
, src
, dst
)
479 const struct external_ldhdr
*src
;
480 struct internal_ldhdr
*dst
;
482 dst
->l_version
= bfd_get_32 (abfd
, src
->l_version
);
483 dst
->l_nsyms
= bfd_get_32 (abfd
, src
->l_nsyms
);
484 dst
->l_nreloc
= bfd_get_32 (abfd
, src
->l_nreloc
);
485 dst
->l_istlen
= bfd_get_32 (abfd
, src
->l_istlen
);
486 dst
->l_nimpid
= bfd_get_32 (abfd
, src
->l_nimpid
);
487 dst
->l_impoff
= bfd_get_32 (abfd
, src
->l_impoff
);
488 dst
->l_stlen
= bfd_get_32 (abfd
, src
->l_stlen
);
489 dst
->l_stoff
= bfd_get_32 (abfd
, src
->l_stoff
);
492 /* Swap out the ldhdr structure. */
495 xcoff_swap_ldhdr_out (abfd
, src
, dst
)
497 const struct internal_ldhdr
*src
;
498 struct external_ldhdr
*dst
;
500 bfd_put_32 (abfd
, src
->l_version
, dst
->l_version
);
501 bfd_put_32 (abfd
, src
->l_nsyms
, dst
->l_nsyms
);
502 bfd_put_32 (abfd
, src
->l_nreloc
, dst
->l_nreloc
);
503 bfd_put_32 (abfd
, src
->l_istlen
, dst
->l_istlen
);
504 bfd_put_32 (abfd
, src
->l_nimpid
, dst
->l_nimpid
);
505 bfd_put_32 (abfd
, src
->l_impoff
, dst
->l_impoff
);
506 bfd_put_32 (abfd
, src
->l_stlen
, dst
->l_stlen
);
507 bfd_put_32 (abfd
, src
->l_stoff
, dst
->l_stoff
);
510 /* Swap in the ldsym structure. */
513 xcoff_swap_ldsym_in (abfd
, src
, dst
)
515 const struct external_ldsym
*src
;
516 struct internal_ldsym
*dst
;
518 if (bfd_get_32 (abfd
, src
->_l
._l_l
._l_zeroes
) != 0)
519 memcpy (dst
->_l
._l_name
, src
->_l
._l_name
, SYMNMLEN
);
522 dst
->_l
._l_l
._l_zeroes
= 0;
523 dst
->_l
._l_l
._l_offset
= bfd_get_32 (abfd
, src
->_l
._l_l
._l_offset
);
525 dst
->l_value
= bfd_get_32 (abfd
, src
->l_value
);
526 dst
->l_scnum
= bfd_get_16 (abfd
, src
->l_scnum
);
527 dst
->l_smtype
= bfd_get_8 (abfd
, src
->l_smtype
);
528 dst
->l_smclas
= bfd_get_8 (abfd
, src
->l_smclas
);
529 dst
->l_ifile
= bfd_get_32 (abfd
, src
->l_ifile
);
530 dst
->l_parm
= bfd_get_32 (abfd
, src
->l_parm
);
533 /* Swap out the ldsym structure. */
536 xcoff_swap_ldsym_out (abfd
, src
, dst
)
538 const struct internal_ldsym
*src
;
539 struct external_ldsym
*dst
;
541 if (src
->_l
._l_l
._l_zeroes
!= 0)
542 memcpy (dst
->_l
._l_name
, src
->_l
._l_name
, SYMNMLEN
);
545 bfd_put_32 (abfd
, 0, dst
->_l
._l_l
._l_zeroes
);
546 bfd_put_32 (abfd
, src
->_l
._l_l
._l_offset
, dst
->_l
._l_l
._l_offset
);
548 bfd_put_32 (abfd
, src
->l_value
, dst
->l_value
);
549 bfd_put_16 (abfd
, src
->l_scnum
, dst
->l_scnum
);
550 bfd_put_8 (abfd
, src
->l_smtype
, dst
->l_smtype
);
551 bfd_put_8 (abfd
, src
->l_smclas
, dst
->l_smclas
);
552 bfd_put_32 (abfd
, src
->l_ifile
, dst
->l_ifile
);
553 bfd_put_32 (abfd
, src
->l_parm
, dst
->l_parm
);
556 /* As it happens, we never need to swap in the ldrel structure. */
558 /* Swap out the ldrel structure. */
561 xcoff_swap_ldrel_out (abfd
, src
, dst
)
563 const struct internal_ldrel
*src
;
564 struct external_ldrel
*dst
;
566 bfd_put_32 (abfd
, src
->l_vaddr
, dst
->l_vaddr
);
567 bfd_put_32 (abfd
, src
->l_symndx
, dst
->l_symndx
);
568 bfd_put_16 (abfd
, src
->l_rtype
, dst
->l_rtype
);
569 bfd_put_16 (abfd
, src
->l_rsecnm
, dst
->l_rsecnm
);
572 /* Routine to create an entry in an XCOFF link hash table. */
574 static struct bfd_hash_entry
*
575 xcoff_link_hash_newfunc (entry
, table
, string
)
576 struct bfd_hash_entry
*entry
;
577 struct bfd_hash_table
*table
;
580 struct xcoff_link_hash_entry
*ret
= (struct xcoff_link_hash_entry
*) entry
;
582 /* Allocate the structure if it has not already been allocated by a
584 if (ret
== (struct xcoff_link_hash_entry
*) NULL
)
585 ret
= ((struct xcoff_link_hash_entry
*)
586 bfd_hash_allocate (table
, sizeof (struct xcoff_link_hash_entry
)));
587 if (ret
== (struct xcoff_link_hash_entry
*) NULL
)
588 return (struct bfd_hash_entry
*) ret
;
590 /* Call the allocation method of the superclass. */
591 ret
= ((struct xcoff_link_hash_entry
*)
592 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
596 /* Set local fields. */
598 ret
->toc_section
= NULL
;
599 ret
->u
.toc_indx
= -1;
600 ret
->descriptor
= NULL
;
604 ret
->smclas
= XMC_UA
;
607 return (struct bfd_hash_entry
*) ret
;
610 /* Create a XCOFF link hash table. */
612 struct bfd_link_hash_table
*
613 _bfd_xcoff_bfd_link_hash_table_create (abfd
)
616 struct xcoff_link_hash_table
*ret
;
618 ret
= ((struct xcoff_link_hash_table
*)
619 bfd_alloc (abfd
, sizeof (struct xcoff_link_hash_table
)));
620 if (ret
== (struct xcoff_link_hash_table
*) NULL
)
621 return (struct bfd_link_hash_table
*) NULL
;
622 if (! _bfd_link_hash_table_init (&ret
->root
, abfd
, xcoff_link_hash_newfunc
))
624 bfd_release (abfd
, ret
);
625 return (struct bfd_link_hash_table
*) NULL
;
628 ret
->debug_strtab
= _bfd_xcoff_stringtab_init ();
629 ret
->debug_section
= NULL
;
630 ret
->loader_section
= NULL
;
631 ret
->ldrel_count
= 0;
632 memset (&ret
->ldhdr
, 0, sizeof (struct internal_ldhdr
));
633 ret
->linkage_section
= NULL
;
634 ret
->toc_section
= NULL
;
635 ret
->descriptor_section
= NULL
;
640 memset (ret
->special_sections
, 0, sizeof ret
->special_sections
);
642 /* The linker will always generate a full a.out header. We need to
643 record that fact now, before the sizeof_headers routine could be
645 xcoff_data (abfd
)->full_aouthdr
= true;
650 /* Look up an entry in an XCOFF link hash table. */
652 #define xcoff_link_hash_lookup(table, string, create, copy, follow) \
653 ((struct xcoff_link_hash_entry *) \
654 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy),\
657 /* Traverse an XCOFF link hash table. */
659 #define xcoff_link_hash_traverse(table, func, info) \
660 (bfd_link_hash_traverse \
662 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
665 /* Get the XCOFF link hash table from the info structure. This is
668 #define xcoff_hash_table(p) ((struct xcoff_link_hash_table *) ((p)->hash))
670 /* Read internal relocs for an XCOFF csect. This is a wrapper around
671 _bfd_coff_read_internal_relocs which tries to take advantage of any
672 relocs which may have been cached for the enclosing section. */
674 static struct internal_reloc
*
675 xcoff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
676 require_internal
, internal_relocs
)
680 bfd_byte
*external_relocs
;
681 boolean require_internal
;
682 struct internal_reloc
*internal_relocs
;
684 if (coff_section_data (abfd
, sec
) != NULL
685 && coff_section_data (abfd
, sec
)->relocs
== NULL
686 && xcoff_section_data (abfd
, sec
) != NULL
)
690 enclosing
= xcoff_section_data (abfd
, sec
)->enclosing
;
692 if (enclosing
!= NULL
693 && (coff_section_data (abfd
, enclosing
) == NULL
694 || coff_section_data (abfd
, enclosing
)->relocs
== NULL
)
696 && enclosing
->reloc_count
> 0)
698 if (_bfd_coff_read_internal_relocs (abfd
, enclosing
, true,
699 external_relocs
, false,
700 (struct internal_reloc
*) NULL
)
705 if (enclosing
!= NULL
706 && coff_section_data (abfd
, enclosing
) != NULL
707 && coff_section_data (abfd
, enclosing
)->relocs
!= NULL
)
711 off
= ((sec
->rel_filepos
- enclosing
->rel_filepos
)
712 / bfd_coff_relsz (abfd
));
713 if (! require_internal
)
714 return coff_section_data (abfd
, enclosing
)->relocs
+ off
;
715 memcpy (internal_relocs
,
716 coff_section_data (abfd
, enclosing
)->relocs
+ off
,
717 sec
->reloc_count
* sizeof (struct internal_reloc
));
718 return internal_relocs
;
722 return _bfd_coff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
723 require_internal
, internal_relocs
);
726 /* Given an XCOFF BFD, add symbols to the global hash table as
730 _bfd_xcoff_bfd_link_add_symbols (abfd
, info
)
732 struct bfd_link_info
*info
;
734 switch (bfd_get_format (abfd
))
737 return xcoff_link_add_object_symbols (abfd
, info
);
739 return (_bfd_generic_link_add_archive_symbols
740 (abfd
, info
, xcoff_link_check_archive_element
));
742 bfd_set_error (bfd_error_wrong_format
);
747 /* Add symbols from an XCOFF object file. */
750 xcoff_link_add_object_symbols (abfd
, info
)
752 struct bfd_link_info
*info
;
754 if (! _bfd_coff_get_external_symbols (abfd
))
756 if (! xcoff_link_add_symbols (abfd
, info
))
758 if (! info
->keep_memory
)
760 if (! _bfd_coff_free_symbols (abfd
))
766 /* Check a single archive element to see if we need to include it in
767 the link. *PNEEDED is set according to whether this element is
768 needed in the link or not. This is called via
769 _bfd_generic_link_add_archive_symbols. */
772 xcoff_link_check_archive_element (abfd
, info
, pneeded
)
774 struct bfd_link_info
*info
;
777 if (! _bfd_coff_get_external_symbols (abfd
))
780 if (! xcoff_link_check_ar_symbols (abfd
, info
, pneeded
))
785 if (! xcoff_link_add_symbols (abfd
, info
))
789 if (! info
->keep_memory
|| ! *pneeded
)
791 if (! _bfd_coff_free_symbols (abfd
))
798 /* Look through the symbols to see if this object file should be
799 included in the link. */
802 xcoff_link_check_ar_symbols (abfd
, info
, pneeded
)
804 struct bfd_link_info
*info
;
807 bfd_size_type symesz
;
813 symesz
= bfd_coff_symesz (abfd
);
814 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
815 esym_end
= esym
+ obj_raw_syment_count (abfd
) * symesz
;
816 while (esym
< esym_end
)
818 struct internal_syment sym
;
820 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &sym
);
822 if (sym
.n_sclass
== C_EXT
&& sym
.n_scnum
!= N_UNDEF
)
825 char buf
[SYMNMLEN
+ 1];
826 struct bfd_link_hash_entry
*h
;
828 /* This symbol is externally visible, and is defined by this
831 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
834 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
836 /* We are only interested in symbols that are currently
837 undefined. If a symbol is currently known to be common,
838 XCOFF linkers do not bring in an object file which
839 defines it. We also don't bring in symbols to satisfy
840 undefined references in shared objects. */
841 if (h
!= (struct bfd_link_hash_entry
*) NULL
842 && h
->type
== bfd_link_hash_undefined
)
844 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
851 esym
+= (sym
.n_numaux
+ 1) * symesz
;
854 /* We do not need this object file. */
858 /* Returns the index of reloc in RELOCS with the least address greater
859 than or equal to ADDRESS. The relocs are sorted by address. */
862 xcoff_find_reloc (relocs
, count
, address
)
863 struct internal_reloc
*relocs
;
867 bfd_size_type min
, max
, this;
871 if (count
== 1 && relocs
[0].r_vaddr
< address
)
880 /* Do a binary search over (min,max]. */
881 while (min
+ 1 < max
)
885 this = (max
+ min
) / 2;
886 raddr
= relocs
[this].r_vaddr
;
889 else if (raddr
< address
)
898 if (relocs
[min
].r_vaddr
< address
)
902 && relocs
[min
- 1].r_vaddr
== address
)
908 /* Add all the symbols from an object file to the hash table.
910 XCOFF is a weird format. A normal XCOFF .o files will have three
911 COFF sections--.text, .data, and .bss--but each COFF section will
912 contain many csects. These csects are described in the symbol
913 table. From the linker's point of view, each csect must be
914 considered a section in its own right. For example, a TOC entry is
915 handled as a small XMC_TC csect. The linker must be able to merge
916 different TOC entries together, which means that it must be able to
917 extract the XMC_TC csects from the .data section of the input .o
920 From the point of view of our linker, this is, of course, a hideous
921 nightmare. We cope by actually creating sections for each csect,
922 and discarding the original sections. We then have to handle the
923 relocation entries carefully, since the only way to tell which
924 csect they belong to is to examine the address. */
927 xcoff_link_add_symbols (abfd
, info
)
929 struct bfd_link_info
*info
;
931 unsigned int n_tmask
;
932 unsigned int n_btshft
;
933 boolean default_copy
;
934 bfd_size_type symcount
;
935 struct xcoff_link_hash_entry
**sym_hash
;
936 asection
**csect_cache
;
937 bfd_size_type linesz
;
942 unsigned int csect_index
;
943 asection
*first_csect
;
944 bfd_size_type symesz
;
947 struct reloc_info_struct
949 struct internal_reloc
*relocs
;
952 } *reloc_info
= NULL
;
954 if ((abfd
->flags
& DYNAMIC
) != 0
955 && ! info
->static_link
)
957 if (! xcoff_link_add_dynamic_symbols (abfd
, info
))
961 /* We need to build a .loader section, so we do it here. This won't
962 work if we're producing an XCOFF output file with no XCOFF input
964 if (xcoff_hash_table (info
)->loader_section
== NULL
)
968 lsec
= bfd_make_section_anyway (abfd
, ".loader");
971 xcoff_hash_table (info
)->loader_section
= lsec
;
972 lsec
->flags
|= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
974 /* Likewise for the linkage section. */
975 if (xcoff_hash_table (info
)->linkage_section
== NULL
)
979 lsec
= bfd_make_section_anyway (abfd
, ".gl");
982 xcoff_hash_table (info
)->linkage_section
= lsec
;
983 lsec
->flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
984 lsec
->alignment_power
= 2;
986 /* Likewise for the TOC section. */
987 if (xcoff_hash_table (info
)->toc_section
== NULL
)
991 tsec
= bfd_make_section_anyway (abfd
, ".tc");
994 xcoff_hash_table (info
)->toc_section
= tsec
;
995 tsec
->flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
996 tsec
->alignment_power
= 2;
998 /* Likewise for the descriptor section. */
999 if (xcoff_hash_table (info
)->descriptor_section
== NULL
)
1003 dsec
= bfd_make_section_anyway (abfd
, ".ds");
1006 xcoff_hash_table (info
)->descriptor_section
= dsec
;
1007 dsec
->flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
1008 dsec
->alignment_power
= 2;
1010 /* Likewise for the .debug section. */
1011 if (xcoff_hash_table (info
)->debug_section
== NULL
)
1015 dsec
= bfd_make_section_anyway (abfd
, ".debug");
1018 xcoff_hash_table (info
)->debug_section
= dsec
;
1019 dsec
->flags
|= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
1022 if ((abfd
->flags
& DYNAMIC
) != 0
1023 && ! info
->static_link
)
1026 n_tmask
= coff_data (abfd
)->local_n_tmask
;
1027 n_btshft
= coff_data (abfd
)->local_n_btshft
;
1029 /* Define macros so that ISFCN, et. al., macros work correctly. */
1030 #define N_TMASK n_tmask
1031 #define N_BTSHFT n_btshft
1033 if (info
->keep_memory
)
1034 default_copy
= false;
1036 default_copy
= true;
1038 symcount
= obj_raw_syment_count (abfd
);
1040 /* We keep a list of the linker hash table entries that correspond
1041 to each external symbol. */
1042 sym_hash
= ((struct xcoff_link_hash_entry
**)
1045 * sizeof (struct xcoff_link_hash_entry
*))));
1046 if (sym_hash
== NULL
&& symcount
!= 0)
1048 coff_data (abfd
)->sym_hashes
= (struct coff_link_hash_entry
**) sym_hash
;
1049 memset (sym_hash
, 0,
1050 (size_t) symcount
* sizeof (struct xcoff_link_hash_entry
*));
1052 /* Because of the weird stuff we are doing with XCOFF csects, we can
1053 not easily determine which section a symbol is in, so we store
1054 the information in the tdata for the input file. */
1055 csect_cache
= ((asection
**)
1056 bfd_alloc (abfd
, symcount
* sizeof (asection
*)));
1057 if (csect_cache
== NULL
&& symcount
!= 0)
1059 xcoff_data (abfd
)->csects
= csect_cache
;
1060 memset (csect_cache
, 0, (size_t) symcount
* sizeof (asection
*));
1062 /* While splitting sections into csects, we need to assign the
1063 relocs correctly. The relocs and the csects must both be in
1064 order by VMA within a given section, so we handle this by
1065 scanning along the relocs as we process the csects. We index
1066 into reloc_info using the section target_index. */
1067 reloc_info
= ((struct reloc_info_struct
*)
1068 bfd_malloc ((abfd
->section_count
+ 1)
1069 * sizeof (struct reloc_info_struct
)));
1070 if (reloc_info
== NULL
)
1072 memset ((PTR
) reloc_info
, 0,
1073 (abfd
->section_count
+ 1) * sizeof (struct reloc_info_struct
));
1075 /* Read in the relocs and line numbers for each section. */
1076 linesz
= bfd_coff_linesz (abfd
);
1078 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1081 if ((o
->flags
& SEC_RELOC
) != 0)
1083 reloc_info
[o
->target_index
].relocs
=
1084 xcoff_read_internal_relocs (abfd
, o
, true, (bfd_byte
*) NULL
,
1085 false, (struct internal_reloc
*) NULL
);
1086 reloc_info
[o
->target_index
].csects
=
1087 (asection
**) bfd_malloc (o
->reloc_count
* sizeof (asection
*));
1088 if (reloc_info
[o
->target_index
].csects
== NULL
)
1090 memset (reloc_info
[o
->target_index
].csects
, 0,
1091 o
->reloc_count
* sizeof (asection
*));
1094 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1095 && o
->lineno_count
> 0)
1099 linenos
= (bfd_byte
*) bfd_malloc (o
->lineno_count
* linesz
);
1100 if (linenos
== NULL
)
1102 reloc_info
[o
->target_index
].linenos
= linenos
;
1103 if (bfd_seek (abfd
, o
->line_filepos
, SEEK_SET
) != 0
1104 || (bfd_read (linenos
, linesz
, o
->lineno_count
, abfd
)
1105 != linesz
* o
->lineno_count
))
1110 /* Don't let the linker relocation routines discard the symbols. */
1111 keep_syms
= obj_coff_keep_syms (abfd
);
1112 obj_coff_keep_syms (abfd
) = true;
1118 symesz
= bfd_coff_symesz (abfd
);
1119 BFD_ASSERT (symesz
== bfd_coff_auxesz (abfd
));
1120 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
1121 esym_end
= esym
+ symcount
* symesz
;
1122 while (esym
< esym_end
)
1124 struct internal_syment sym
;
1125 union internal_auxent aux
;
1127 char buf
[SYMNMLEN
+ 1];
1132 struct xcoff_link_hash_entry
*set_toc
;
1134 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &sym
);
1136 /* In this pass we are only interested in symbols with csect
1138 if (sym
.n_sclass
!= C_EXT
&& sym
.n_sclass
!= C_HIDEXT
)
1140 if (sym
.n_sclass
== C_FILE
&& csect
!= NULL
)
1142 xcoff_section_data (abfd
, csect
)->last_symndx
=
1144 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1150 *csect_cache
= csect
;
1151 else if (first_csect
== NULL
|| sym
.n_sclass
== C_FILE
)
1152 *csect_cache
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1154 *csect_cache
= NULL
;
1155 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1156 sym_hash
+= sym
.n_numaux
+ 1;
1157 csect_cache
+= sym
.n_numaux
+ 1;
1161 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
1165 /* If this symbol has line number information attached to it,
1166 and we're not stripping it, count the number of entries and
1167 add them to the count for this csect. In the final link pass
1168 we are going to attach line number information by symbol,
1169 rather than by section, in order to more easily handle
1170 garbage collection. */
1171 if ((info
->strip
== strip_none
|| info
->strip
== strip_some
)
1174 && ISFCN (sym
.n_type
))
1176 union internal_auxent auxlin
;
1178 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ symesz
),
1179 sym
.n_type
, sym
.n_sclass
,
1180 0, sym
.n_numaux
, (PTR
) &auxlin
);
1181 if (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
1183 asection
*enclosing
;
1184 bfd_size_type linoff
;
1186 enclosing
= xcoff_section_data (abfd
, csect
)->enclosing
;
1187 if (enclosing
== NULL
)
1189 (*_bfd_error_handler
)
1190 ("%s: `%s' has line numbers but no enclosing section",
1191 bfd_get_filename (abfd
), name
);
1192 bfd_set_error (bfd_error_bad_value
);
1195 linoff
= (auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
1196 - enclosing
->line_filepos
);
1197 if (linoff
< enclosing
->lineno_count
* linesz
)
1199 struct internal_lineno lin
;
1200 bfd_byte
*linpstart
;
1202 linpstart
= (reloc_info
[enclosing
->target_index
].linenos
1204 bfd_coff_swap_lineno_in (abfd
, (PTR
) linpstart
, (PTR
) &lin
);
1206 && ((bfd_size_type
) lin
.l_addr
.l_symndx
1208 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1211 bfd_byte
*linpend
, *linp
;
1213 linpend
= (reloc_info
[enclosing
->target_index
].linenos
1214 + enclosing
->lineno_count
* linesz
);
1215 for (linp
= linpstart
+ linesz
;
1219 bfd_coff_swap_lineno_in (abfd
, (PTR
) linp
,
1221 if (lin
.l_lnno
== 0)
1224 csect
->lineno_count
+= (linp
- linpstart
) / linesz
;
1225 /* The setting of line_filepos will only be
1226 useful if all the line number entries for a
1227 csect are contiguous; this only matters for
1229 if (csect
->line_filepos
== 0)
1230 csect
->line_filepos
=
1231 auxlin
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1237 /* Pick up the csect auxiliary information. */
1239 if (sym
.n_numaux
== 0)
1241 (*_bfd_error_handler
)
1242 ("%s: class %d symbol `%s' has no aux entries",
1243 bfd_get_filename (abfd
), sym
.n_sclass
, name
);
1244 bfd_set_error (bfd_error_bad_value
);
1248 bfd_coff_swap_aux_in (abfd
,
1249 (PTR
) (esym
+ symesz
* sym
.n_numaux
),
1250 sym
.n_type
, sym
.n_sclass
,
1251 sym
.n_numaux
- 1, sym
.n_numaux
,
1254 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
1264 (*_bfd_error_handler
)
1265 ("%s: symbol `%s' has unrecognized csect type %d",
1266 bfd_get_filename (abfd
), name
, smtyp
);
1267 bfd_set_error (bfd_error_bad_value
);
1271 /* This is an external reference. */
1272 if (sym
.n_sclass
== C_HIDEXT
1273 || sym
.n_scnum
!= N_UNDEF
1274 || aux
.x_csect
.x_scnlen
.l
!= 0)
1276 (*_bfd_error_handler
)
1277 ("%s: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d",
1278 bfd_get_filename (abfd
), name
, sym
.n_sclass
, sym
.n_scnum
,
1279 aux
.x_csect
.x_scnlen
.l
);
1280 bfd_set_error (bfd_error_bad_value
);
1284 /* An XMC_XO external reference is actually a reference to
1285 an absolute location. */
1286 if (aux
.x_csect
.x_smclas
!= XMC_XO
)
1287 section
= bfd_und_section_ptr
;
1290 section
= bfd_abs_section_ptr
;
1291 value
= sym
.n_value
;
1296 /* This is a csect definition. */
1300 xcoff_section_data (abfd
, csect
)->last_symndx
=
1302 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1309 /* When we see a TOC anchor, we record the TOC value. */
1310 if (aux
.x_csect
.x_smclas
== XMC_TC0
)
1312 if (sym
.n_sclass
!= C_HIDEXT
1313 || aux
.x_csect
.x_scnlen
.l
!= 0)
1315 (*_bfd_error_handler
)
1316 ("%s: XMC_TC0 symbol `%s' is class %d scnlen %d",
1317 bfd_get_filename (abfd
), name
, sym
.n_sclass
,
1318 aux
.x_csect
.x_scnlen
.l
);
1319 bfd_set_error (bfd_error_bad_value
);
1322 xcoff_data (abfd
)->toc
= sym
.n_value
;
1325 /* We must merge TOC entries for the same symbol. We can
1326 merge two TOC entries if they are both C_HIDEXT, they
1327 both have the same name, they are both 4 bytes long, and
1328 they both have a relocation table entry for an external
1329 symbol with the same name. Unfortunately, this means
1330 that we must look through the relocations. Ick. */
1331 if (aux
.x_csect
.x_smclas
== XMC_TC
1332 && sym
.n_sclass
== C_HIDEXT
1333 && aux
.x_csect
.x_scnlen
.l
== 4
1334 && info
->hash
->creator
== abfd
->xvec
)
1336 asection
*enclosing
;
1337 struct internal_reloc
*relocs
;
1338 bfd_size_type relindx
;
1339 struct internal_reloc
*rel
;
1341 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1342 if (enclosing
== NULL
)
1345 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1346 relindx
= xcoff_find_reloc (relocs
, enclosing
->reloc_count
,
1348 rel
= relocs
+ relindx
;
1349 if (relindx
< enclosing
->reloc_count
1350 && rel
->r_vaddr
== (bfd_vma
) sym
.n_value
1351 && rel
->r_size
== 31
1352 && rel
->r_type
== R_POS
)
1355 struct internal_syment relsym
;
1357 erelsym
= ((bfd_byte
*) obj_coff_external_syms (abfd
)
1358 + rel
->r_symndx
* symesz
);
1359 bfd_coff_swap_sym_in (abfd
, (PTR
) erelsym
, (PTR
) &relsym
);
1360 if (relsym
.n_sclass
== C_EXT
)
1362 const char *relname
;
1363 char relbuf
[SYMNMLEN
+ 1];
1365 struct xcoff_link_hash_entry
*h
;
1367 /* At this point we know that the TOC entry is
1368 for an externally visible symbol. */
1369 relname
= _bfd_coff_internal_syment_name (abfd
, &relsym
,
1371 if (relname
== NULL
)
1374 /* We only merge TOC entries if the TC name is
1375 the same as the symbol name. This handles
1376 the normal case, but not common cases like
1377 SYM.P4 which gcc generates to store SYM + 4
1378 in the TOC. FIXME. */
1379 if (strcmp (name
, relname
) == 0)
1381 copy
= (! info
->keep_memory
1382 || relsym
._n
._n_n
._n_zeroes
!= 0
1383 || relsym
._n
._n_n
._n_offset
== 0);
1384 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1385 relname
, true, copy
,
1390 /* At this point h->root.type could be
1391 bfd_link_hash_new. That should be OK,
1392 since we know for sure that we will come
1393 across this symbol as we step through the
1396 /* We store h in *sym_hash for the
1397 convenience of the relocate_section
1401 if (h
->toc_section
!= NULL
)
1403 asection
**rel_csects
;
1405 /* We already have a TOC entry for this
1406 symbol, so we can just ignore this
1409 reloc_info
[enclosing
->target_index
].csects
;
1410 rel_csects
[relindx
] = bfd_und_section_ptr
;
1414 /* We are about to create a TOC entry for
1422 /* We need to create a new section. We get the name from
1423 the csect storage mapping class, so that the linker can
1424 accumulate similar csects together. */
1426 static const char *csect_name_by_class
[] =
1428 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
1429 ".sv", ".bs", ".ds", ".uc", ".ti", ".tb", NULL
, ".tc0",
1432 const char *csect_name
;
1433 asection
*enclosing
;
1435 if ((aux
.x_csect
.x_smclas
>=
1436 sizeof csect_name_by_class
/ sizeof csect_name_by_class
[0])
1437 || csect_name_by_class
[aux
.x_csect
.x_smclas
] == NULL
)
1439 (*_bfd_error_handler
)
1440 ("%s: symbol `%s' has unrecognized smclas %d",
1441 bfd_get_filename (abfd
), name
, aux
.x_csect
.x_smclas
);
1442 bfd_set_error (bfd_error_bad_value
);
1446 csect_name
= csect_name_by_class
[aux
.x_csect
.x_smclas
];
1447 csect
= bfd_make_section_anyway (abfd
, csect_name
);
1450 enclosing
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
1451 if (enclosing
== NULL
)
1453 if (! bfd_is_abs_section (enclosing
)
1454 && ((bfd_vma
) sym
.n_value
< enclosing
->vma
1455 || ((bfd_vma
) sym
.n_value
+ aux
.x_csect
.x_scnlen
.l
1456 > enclosing
->vma
+ enclosing
->_raw_size
)))
1458 (*_bfd_error_handler
)
1459 ("%s: csect `%s' not in enclosing section",
1460 bfd_get_filename (abfd
), name
);
1461 bfd_set_error (bfd_error_bad_value
);
1464 csect
->vma
= sym
.n_value
;
1465 csect
->filepos
= (enclosing
->filepos
1468 csect
->_raw_size
= aux
.x_csect
.x_scnlen
.l
;
1469 csect
->flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
;
1470 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1472 /* Record the enclosing section in the tdata for this new
1474 csect
->used_by_bfd
=
1475 ((struct coff_section_tdata
*)
1476 bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
)));
1477 if (csect
->used_by_bfd
== NULL
)
1479 coff_section_data (abfd
, csect
)->tdata
=
1480 bfd_zalloc (abfd
, sizeof (struct xcoff_section_tdata
));
1481 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1483 xcoff_section_data (abfd
, csect
)->enclosing
= enclosing
;
1484 xcoff_section_data (abfd
, csect
)->lineno_count
=
1485 enclosing
->lineno_count
;
1487 if (enclosing
->owner
== abfd
)
1489 struct internal_reloc
*relocs
;
1490 bfd_size_type relindx
;
1491 struct internal_reloc
*rel
;
1492 asection
**rel_csect
;
1494 relocs
= reloc_info
[enclosing
->target_index
].relocs
;
1495 relindx
= xcoff_find_reloc (relocs
, enclosing
->reloc_count
,
1497 rel
= relocs
+ relindx
;
1498 rel_csect
= (reloc_info
[enclosing
->target_index
].csects
1500 csect
->rel_filepos
= (enclosing
->rel_filepos
1501 + relindx
* bfd_coff_relsz (abfd
));
1502 while (relindx
< enclosing
->reloc_count
1503 && *rel_csect
== NULL
1504 && rel
->r_vaddr
< csect
->vma
+ csect
->_raw_size
)
1507 csect
->flags
|= SEC_RELOC
;
1508 ++csect
->reloc_count
;
1515 /* There are a number of other fields and section flags
1516 which we do not bother to set. */
1518 csect_index
= ((esym
1519 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1522 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1524 if (first_csect
== NULL
)
1525 first_csect
= csect
;
1527 /* If this symbol is C_EXT, we treat it as starting at the
1528 beginning of the newly created section. */
1529 if (sym
.n_sclass
== C_EXT
)
1535 /* If this is a TOC section for a symbol, record it. */
1536 if (set_toc
!= NULL
)
1537 set_toc
->toc_section
= csect
;
1542 /* This is a label definition. The x_scnlen field is the
1543 symbol index of the csect. I believe that this must
1544 always follow the appropriate XTY_SD symbol, so I will
1550 if (aux
.x_csect
.x_scnlen
.l
< 0
1551 || (aux
.x_csect
.x_scnlen
.l
1552 >= esym
- (bfd_byte
*) obj_coff_external_syms (abfd
)))
1556 section
= xcoff_data (abfd
)->csects
[aux
.x_csect
.x_scnlen
.l
];
1558 || (section
->flags
& SEC_HAS_CONTENTS
) == 0)
1563 (*_bfd_error_handler
)
1564 ("%s: misplaced XTY_LD `%s'",
1565 bfd_get_filename (abfd
), name
);
1566 bfd_set_error (bfd_error_bad_value
);
1570 value
= sym
.n_value
- csect
->vma
;
1575 /* This is an unitialized csect. We could base the name on
1576 the storage mapping class, but we don't bother. If this
1577 csect is externally visible, it is a common symbol. */
1581 xcoff_section_data (abfd
, csect
)->last_symndx
=
1583 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1587 csect
= bfd_make_section_anyway (abfd
, ".bss");
1590 csect
->vma
= sym
.n_value
;
1591 csect
->_raw_size
= aux
.x_csect
.x_scnlen
.l
;
1592 csect
->flags
|= SEC_ALLOC
;
1593 csect
->alignment_power
= SMTYP_ALIGN (aux
.x_csect
.x_smtyp
);
1594 /* There are a number of other fields and section flags
1595 which we do not bother to set. */
1597 csect_index
= ((esym
1598 - (bfd_byte
*) obj_coff_external_syms (abfd
))
1601 csect
->used_by_bfd
=
1602 ((struct coff_section_tdata
*)
1603 bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
)));
1604 if (csect
->used_by_bfd
== NULL
)
1606 coff_section_data (abfd
, csect
)->tdata
=
1607 bfd_zalloc (abfd
, sizeof (struct xcoff_section_tdata
));
1608 if (coff_section_data (abfd
, csect
)->tdata
== NULL
)
1610 xcoff_section_data (abfd
, csect
)->first_symndx
= csect_index
;
1612 if (first_csect
== NULL
)
1613 first_csect
= csect
;
1615 if (sym
.n_sclass
== C_EXT
)
1617 csect
->flags
|= SEC_IS_COMMON
;
1618 csect
->_raw_size
= 0;
1620 value
= aux
.x_csect
.x_scnlen
.l
;
1626 /* Check for magic symbol names. */
1627 if ((smtyp
== XTY_SD
|| smtyp
== XTY_CM
)
1628 && aux
.x_csect
.x_smclas
!= XMC_TC
)
1635 if (strcmp (name
, "_text") == 0)
1637 else if (strcmp (name
, "_etext") == 0)
1639 else if (strcmp (name
, "_data") == 0)
1641 else if (strcmp (name
, "_edata") == 0)
1643 else if (strcmp (name
, "_end") == 0)
1646 else if (name
[0] == 'e' && strcmp (name
, "end") == 0)
1650 xcoff_hash_table (info
)->special_sections
[i
] = csect
;
1653 /* Now we have enough information to add the symbol to the
1654 linker hash table. */
1656 if (sym
.n_sclass
== C_EXT
)
1660 BFD_ASSERT (section
!= NULL
);
1662 /* We must copy the name into memory if we got it from the
1663 syment itself, rather than the string table. */
1664 copy
= default_copy
;
1665 if (sym
._n
._n_n
._n_zeroes
!= 0
1666 || sym
._n
._n_n
._n_offset
== 0)
1669 if (info
->hash
->creator
== abfd
->xvec
)
1671 /* If we are statically linking a shared object, it is
1672 OK for symbol redefinitions to occur. I can't figure
1673 out just what the XCOFF linker is doing, but
1674 something like this is required for -bnso to work. */
1675 if (! bfd_is_und_section (section
))
1676 *sym_hash
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1677 name
, true, copy
, false);
1679 *sym_hash
= ((struct xcoff_link_hash_entry
*)
1680 bfd_wrapped_link_hash_lookup (abfd
, info
, name
,
1681 true, copy
, false));
1682 if (*sym_hash
== NULL
)
1684 if (((*sym_hash
)->root
.type
== bfd_link_hash_defined
1685 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
)
1686 && ! bfd_is_und_section (section
)
1687 && ! bfd_is_com_section (section
))
1689 if ((abfd
->flags
& DYNAMIC
) != 0)
1691 section
= bfd_und_section_ptr
;
1694 else if (((*sym_hash
)->root
.u
.def
.section
->owner
->flags
1697 (*sym_hash
)->root
.type
= bfd_link_hash_undefined
;
1698 (*sym_hash
)->root
.u
.undef
.abfd
=
1699 (*sym_hash
)->root
.u
.def
.section
->owner
;
1704 /* _bfd_generic_link_add_one_symbol may call the linker to
1705 generate an error message, and the linker may try to read
1706 the symbol table to give a good error. Right now, the
1707 line numbers are in an inconsistent state, since they are
1708 counted both in the real sections and in the new csects.
1709 We need to leave the count in the real sections so that
1710 the linker can report the line number of the error
1711 correctly, so temporarily clobber the link to the csects
1712 so that the linker will not try to read the line numbers
1713 a second time from the csects. */
1714 BFD_ASSERT (last_real
->next
== first_csect
);
1715 last_real
->next
= NULL
;
1716 if (! (_bfd_generic_link_add_one_symbol
1717 (info
, abfd
, name
, flags
, section
, value
,
1718 (const char *) NULL
, copy
, true,
1719 (struct bfd_link_hash_entry
**) sym_hash
)))
1721 last_real
->next
= first_csect
;
1723 if (smtyp
== XTY_CM
)
1725 if ((*sym_hash
)->root
.type
!= bfd_link_hash_common
1726 || (*sym_hash
)->root
.u
.c
.p
->section
!= csect
)
1728 /* We don't need the common csect we just created. */
1729 csect
->_raw_size
= 0;
1733 (*sym_hash
)->root
.u
.c
.p
->alignment_power
1734 = csect
->alignment_power
;
1738 if (info
->hash
->creator
== abfd
->xvec
)
1742 if (smtyp
== XTY_ER
|| smtyp
== XTY_CM
)
1743 flag
= XCOFF_REF_REGULAR
;
1745 flag
= XCOFF_DEF_REGULAR
;
1746 (*sym_hash
)->flags
|= flag
;
1748 if ((*sym_hash
)->smclas
== XMC_UA
1749 || flag
== XCOFF_DEF_REGULAR
)
1750 (*sym_hash
)->smclas
= aux
.x_csect
.x_smclas
;
1754 *csect_cache
= csect
;
1756 esym
+= (sym
.n_numaux
+ 1) * symesz
;
1757 sym_hash
+= sym
.n_numaux
+ 1;
1758 csect_cache
+= sym
.n_numaux
+ 1;
1761 BFD_ASSERT (last_real
== NULL
|| last_real
->next
== first_csect
);
1763 /* Make sure that we have seen all the relocs. */
1764 for (o
= abfd
->sections
; o
!= first_csect
; o
= o
->next
)
1766 /* Reset the section size and the line numebr count, since the
1767 data is now attached to the csects. Don't reset the size of
1768 the .debug section, since we need to read it below in
1769 bfd_xcoff_size_dynamic_sections. */
1770 if (strcmp (bfd_get_section_name (abfd
, o
), ".debug") != 0)
1772 o
->lineno_count
= 0;
1774 if ((o
->flags
& SEC_RELOC
) != 0)
1777 struct internal_reloc
*rel
;
1778 asection
**rel_csect
;
1780 rel
= reloc_info
[o
->target_index
].relocs
;
1781 rel_csect
= reloc_info
[o
->target_index
].csects
;
1782 for (i
= 0; i
< o
->reloc_count
; i
++, rel
++, rel_csect
++)
1784 if (*rel_csect
== NULL
)
1786 (*_bfd_error_handler
)
1787 ("%s: reloc %s:%d not in csect",
1788 bfd_get_filename (abfd
), o
->name
, i
);
1789 bfd_set_error (bfd_error_bad_value
);
1793 /* We identify all symbols which are called, so that we
1794 can create glue code for calls to functions imported
1795 from dynamic objects. */
1796 if (info
->hash
->creator
== abfd
->xvec
1797 && *rel_csect
!= bfd_und_section_ptr
1798 && (rel
->r_type
== R_BR
1799 || rel
->r_type
== R_RBR
)
1800 && obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
] != NULL
)
1802 struct xcoff_link_hash_entry
*h
;
1804 h
= obj_xcoff_sym_hashes (abfd
)[rel
->r_symndx
];
1805 h
->flags
|= XCOFF_CALLED
;
1806 /* If the symbol name starts with a period, it is
1807 the code of a function. If the symbol is
1808 currently undefined, then add an undefined symbol
1809 for the function descriptor. This should do no
1810 harm, because any regular object that defines the
1811 function should also define the function
1812 descriptor. It helps, because it means that we
1813 will identify the function descriptor with a
1814 dynamic object if a dynamic object defines it. */
1815 if (h
->root
.root
.string
[0] == '.'
1816 && h
->descriptor
== NULL
)
1818 struct xcoff_link_hash_entry
*hds
;
1820 hds
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
1821 h
->root
.root
.string
+ 1,
1825 if (hds
->root
.type
== bfd_link_hash_new
)
1827 if (! (_bfd_generic_link_add_one_symbol
1828 (info
, abfd
, hds
->root
.root
.string
,
1829 (flagword
) 0, bfd_und_section_ptr
,
1830 (bfd_vma
) 0, (const char *) NULL
, false,
1832 (struct bfd_link_hash_entry
**) &hds
)))
1835 hds
->flags
|= XCOFF_DESCRIPTOR
;
1836 BFD_ASSERT ((hds
->flags
& XCOFF_CALLED
) == 0
1837 && (h
->flags
& XCOFF_DESCRIPTOR
) == 0);
1838 hds
->descriptor
= h
;
1839 h
->descriptor
= hds
;
1844 free (reloc_info
[o
->target_index
].csects
);
1845 reloc_info
[o
->target_index
].csects
= NULL
;
1847 /* Reset SEC_RELOC and the reloc_count, since the reloc
1848 information is now attached to the csects. */
1849 o
->flags
&=~ SEC_RELOC
;
1852 /* If we are not keeping memory, free the reloc information. */
1853 if (! info
->keep_memory
1854 && coff_section_data (abfd
, o
) != NULL
1855 && coff_section_data (abfd
, o
)->relocs
!= NULL
1856 && ! coff_section_data (abfd
, o
)->keep_relocs
)
1858 free (coff_section_data (abfd
, o
)->relocs
);
1859 coff_section_data (abfd
, o
)->relocs
= NULL
;
1863 /* Free up the line numbers. FIXME: We could cache these
1864 somewhere for the final link, to avoid reading them again. */
1865 if (reloc_info
[o
->target_index
].linenos
!= NULL
)
1867 free (reloc_info
[o
->target_index
].linenos
);
1868 reloc_info
[o
->target_index
].linenos
= NULL
;
1874 obj_coff_keep_syms (abfd
) = keep_syms
;
1879 if (reloc_info
!= NULL
)
1881 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1883 if (reloc_info
[o
->target_index
].csects
!= NULL
)
1884 free (reloc_info
[o
->target_index
].csects
);
1885 if (reloc_info
[o
->target_index
].linenos
!= NULL
)
1886 free (reloc_info
[o
->target_index
].linenos
);
1890 obj_coff_keep_syms (abfd
) = keep_syms
;
1897 /* This function is used to add symbols from a dynamic object to the
1898 global symbol table. */
1901 xcoff_link_add_dynamic_symbols (abfd
, info
)
1903 struct bfd_link_info
*info
;
1906 bfd_byte
*buf
= NULL
;
1907 struct internal_ldhdr ldhdr
;
1908 const char *strings
;
1909 struct external_ldsym
*elsym
, *elsymend
;
1910 struct xcoff_import_file
*n
;
1915 struct xcoff_import_file
**pp
;
1917 /* We can only handle a dynamic object if we are generating an XCOFF
1919 if (info
->hash
->creator
!= abfd
->xvec
)
1921 (*_bfd_error_handler
)
1922 ("%s: XCOFF shared object when not producing XCOFF output",
1923 bfd_get_filename (abfd
));
1924 bfd_set_error (bfd_error_invalid_operation
);
1928 /* The symbols we use from a dynamic object are not the symbols in
1929 the normal symbol table, but, rather, the symbols in the export
1930 table. If there is a global symbol in a dynamic object which is
1931 not in the export table, the loader will not be able to find it,
1932 so we don't want to find it either. Also, on AIX 4.1.3, shr.o in
1933 libc.a has symbols in the export table which are not in the
1936 /* Read in the .loader section. FIXME: We should really use the
1937 o_snloader field in the a.out header, rather than grabbing the
1939 lsec
= bfd_get_section_by_name (abfd
, ".loader");
1942 (*_bfd_error_handler
)
1943 ("%s: dynamic object with no .loader section",
1944 bfd_get_filename (abfd
));
1945 bfd_set_error (bfd_error_no_symbols
);
1949 buf
= (bfd_byte
*) bfd_malloc (lsec
->_raw_size
);
1950 if (buf
== NULL
&& lsec
->_raw_size
> 0)
1953 if (! bfd_get_section_contents (abfd
, lsec
, (PTR
) buf
, (file_ptr
) 0,
1957 /* Remove the sections from this object, so that they do not get
1958 included in the link. */
1959 abfd
->sections
= NULL
;
1961 xcoff_swap_ldhdr_in (abfd
, (struct external_ldhdr
*) buf
, &ldhdr
);
1963 strings
= (char *) buf
+ ldhdr
.l_stoff
;
1965 elsym
= (struct external_ldsym
*) (buf
+ LDHDRSZ
);
1966 elsymend
= elsym
+ ldhdr
.l_nsyms
;
1967 BFD_ASSERT (sizeof (struct external_ldsym
) == LDSYMSZ
);
1968 for (; elsym
< elsymend
; elsym
++)
1970 struct internal_ldsym ldsym
;
1971 char nambuf
[SYMNMLEN
+ 1];
1973 struct xcoff_link_hash_entry
*h
;
1975 xcoff_swap_ldsym_in (abfd
, elsym
, &ldsym
);
1977 /* We are only interested in exported symbols. */
1978 if ((ldsym
.l_smtype
& L_EXPORT
) == 0)
1981 if (ldsym
._l
._l_l
._l_zeroes
== 0)
1982 name
= strings
+ ldsym
._l
._l_l
._l_offset
;
1985 memcpy (nambuf
, ldsym
._l
._l_name
, SYMNMLEN
);
1986 nambuf
[SYMNMLEN
] = '\0';
1990 /* Normally we could not call xcoff_link_hash_lookup in an add
1991 symbols routine, since we might not be using an XCOFF hash
1992 table. However, we verified above that we are using an XCOFF
1995 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, true,
2000 h
->flags
|= XCOFF_DEF_DYNAMIC
;
2002 /* If the symbol is undefined, and the BFD it was found in is
2003 not a dynamic object, change the BFD to this dynamic object,
2004 so that we can get the correct import file ID. */
2005 if ((h
->root
.type
== bfd_link_hash_undefined
2006 || h
->root
.type
== bfd_link_hash_undefweak
)
2007 && (h
->root
.u
.undef
.abfd
== NULL
2008 || (h
->root
.u
.undef
.abfd
->flags
& DYNAMIC
) == 0))
2009 h
->root
.u
.undef
.abfd
= abfd
;
2011 if (h
->root
.type
== bfd_link_hash_new
)
2013 h
->root
.type
= bfd_link_hash_undefined
;
2014 h
->root
.u
.undef
.abfd
= abfd
;
2015 /* We do not want to add this to the undefined symbol list. */
2018 if (h
->smclas
== XMC_UA
2019 || h
->root
.type
== bfd_link_hash_undefined
2020 || h
->root
.type
== bfd_link_hash_undefweak
)
2021 h
->smclas
= ldsym
.l_smclas
;
2023 /* Unless this is an XMC_XO symbol, we don't bother to actually
2024 define it, since we don't have a section to put it in anyhow.
2025 Instead, the relocation routines handle the DEF_DYNAMIC flag
2028 if (h
->smclas
== XMC_XO
2029 && (h
->root
.type
== bfd_link_hash_undefined
2030 || h
->root
.type
== bfd_link_hash_undefweak
))
2032 /* This symbol has an absolute value. */
2033 h
->root
.type
= bfd_link_hash_defined
;
2034 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2035 h
->root
.u
.def
.value
= ldsym
.l_value
;
2045 /* Record this file in the import files. */
2047 n
= ((struct xcoff_import_file
*)
2048 bfd_alloc (abfd
, sizeof (struct xcoff_import_file
)));
2053 /* For some reason, the path entry in the import file list for a
2054 shared object appears to always be empty. The file name is the
2057 if (abfd
->my_archive
== NULL
)
2059 bname
= bfd_get_filename (abfd
);
2064 bname
= bfd_get_filename (abfd
->my_archive
);
2065 mname
= bfd_get_filename (abfd
);
2067 s
= strrchr (bname
, '/');
2073 /* We start c at 1 because the first import file number is reserved
2075 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
2077 pp
= &(*pp
)->next
, ++c
)
2081 xcoff_data (abfd
)->import_file_id
= c
;
2091 /* Routines that are called after all the input files have been
2092 handled, but before the sections are laid out in memory. */
2094 /* Mark a symbol as not being garbage, including the section in which
2097 static INLINE boolean
2098 xcoff_mark_symbol (info
, h
)
2099 struct bfd_link_info
*info
;
2100 struct xcoff_link_hash_entry
*h
;
2102 if ((h
->flags
& XCOFF_MARK
) != 0)
2105 h
->flags
|= XCOFF_MARK
;
2106 if (h
->root
.type
== bfd_link_hash_defined
2107 || h
->root
.type
== bfd_link_hash_defweak
)
2111 hsec
= h
->root
.u
.def
.section
;
2112 if ((hsec
->flags
& SEC_MARK
) == 0)
2114 if (! xcoff_mark (info
, hsec
))
2119 if (h
->toc_section
!= NULL
2120 && (h
->toc_section
->flags
& SEC_MARK
) == 0)
2122 if (! xcoff_mark (info
, h
->toc_section
))
2129 /* The mark phase of garbage collection. For a given section, mark
2130 it, and all the sections which define symbols to which it refers.
2131 Because this function needs to look at the relocs, we also count
2132 the number of relocs which need to be copied into the .loader
2136 xcoff_mark (info
, sec
)
2137 struct bfd_link_info
*info
;
2140 if ((sec
->flags
& SEC_MARK
) != 0)
2143 sec
->flags
|= SEC_MARK
;
2145 if (sec
->owner
->xvec
== info
->hash
->creator
2146 && coff_section_data (sec
->owner
, sec
) != NULL
2147 && xcoff_section_data (sec
->owner
, sec
) != NULL
)
2149 register struct xcoff_link_hash_entry
**hp
, **hpend
;
2150 struct internal_reloc
*rel
, *relend
;
2152 /* Mark all the symbols in this section. */
2154 hp
= (obj_xcoff_sym_hashes (sec
->owner
)
2155 + xcoff_section_data (sec
->owner
, sec
)->first_symndx
);
2156 hpend
= (obj_xcoff_sym_hashes (sec
->owner
)
2157 + xcoff_section_data (sec
->owner
, sec
)->last_symndx
);
2158 for (; hp
< hpend
; hp
++)
2160 register struct xcoff_link_hash_entry
*h
;
2164 && (h
->flags
& XCOFF_MARK
) == 0)
2166 if (! xcoff_mark_symbol (info
, h
))
2171 /* Look through the section relocs. */
2173 if ((sec
->flags
& SEC_RELOC
) != 0
2174 && sec
->reloc_count
> 0)
2176 rel
= xcoff_read_internal_relocs (sec
->owner
, sec
, true,
2177 (bfd_byte
*) NULL
, false,
2178 (struct internal_reloc
*) NULL
);
2181 relend
= rel
+ sec
->reloc_count
;
2182 for (; rel
< relend
; rel
++)
2185 struct xcoff_link_hash_entry
*h
;
2187 if ((unsigned int) rel
->r_symndx
2188 > obj_raw_syment_count (sec
->owner
))
2191 h
= obj_xcoff_sym_hashes (sec
->owner
)[rel
->r_symndx
];
2193 && (h
->flags
& XCOFF_MARK
) == 0)
2195 if (! xcoff_mark_symbol (info
, h
))
2199 rsec
= xcoff_data (sec
->owner
)->csects
[rel
->r_symndx
];
2201 && (rsec
->flags
& SEC_MARK
) == 0)
2203 if (! xcoff_mark (info
, rsec
))
2207 /* See if this reloc needs to be copied into the .loader
2209 switch (rel
->r_type
)
2213 || h
->root
.type
== bfd_link_hash_defined
2214 || h
->root
.type
== bfd_link_hash_defweak
2215 || h
->root
.type
== bfd_link_hash_common
2216 || ((h
->flags
& XCOFF_CALLED
) != 0
2217 && (h
->root
.type
== bfd_link_hash_undefined
2218 || h
->root
.type
== bfd_link_hash_undefweak
)
2219 && h
->root
.root
.string
[0] == '.'
2220 && h
->descriptor
!= NULL
2221 && ((h
->descriptor
->flags
& XCOFF_DEF_DYNAMIC
) != 0
2223 || ((h
->descriptor
->flags
& XCOFF_IMPORT
) != 0
2224 && (h
->descriptor
->flags
2225 & XCOFF_DEF_REGULAR
) == 0))))
2232 ++xcoff_hash_table (info
)->ldrel_count
;
2234 h
->flags
|= XCOFF_LDREL
;
2241 /* We should never need a .loader reloc for a TOC
2247 if (! info
->keep_memory
2248 && coff_section_data (sec
->owner
, sec
) != NULL
2249 && coff_section_data (sec
->owner
, sec
)->relocs
!= NULL
2250 && ! coff_section_data (sec
->owner
, sec
)->keep_relocs
)
2252 free (coff_section_data (sec
->owner
, sec
)->relocs
);
2253 coff_section_data (sec
->owner
, sec
)->relocs
= NULL
;
2261 /* The sweep phase of garbage collection. Remove all garbage
2266 struct bfd_link_info
*info
;
2270 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
2274 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
2276 if ((o
->flags
& SEC_MARK
) == 0)
2278 /* Keep all sections from non-XCOFF input files. Keep
2279 special sections. Keep .debug sections for the
2281 if (sub
->xvec
!= info
->hash
->creator
2282 || o
== xcoff_hash_table (info
)->debug_section
2283 || o
== xcoff_hash_table (info
)->loader_section
2284 || o
== xcoff_hash_table (info
)->linkage_section
2285 || o
== xcoff_hash_table (info
)->toc_section
2286 || o
== xcoff_hash_table (info
)->descriptor_section
2287 || strcmp (o
->name
, ".debug") == 0)
2288 o
->flags
|= SEC_MARK
;
2293 o
->lineno_count
= 0;
2300 /* Record the number of elements in a set. This is used to output the
2301 correct csect length. */
2304 bfd_xcoff_link_record_set (output_bfd
, info
, harg
, size
)
2306 struct bfd_link_info
*info
;
2307 struct bfd_link_hash_entry
*harg
;
2310 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2311 struct xcoff_link_size_list
*n
;
2313 if (! XCOFF_XVECP (output_bfd
->xvec
))
2316 /* This will hardly ever be called. I don't want to burn four bytes
2317 per global symbol, so instead the size is kept on a linked list
2318 attached to the hash table. */
2320 n
= ((struct xcoff_link_size_list
*)
2321 bfd_alloc (output_bfd
, sizeof (struct xcoff_link_size_list
)));
2324 n
->next
= xcoff_hash_table (info
)->size_list
;
2327 xcoff_hash_table (info
)->size_list
= n
;
2329 h
->flags
|= XCOFF_HAS_SIZE
;
2334 /* Import a symbol. */
2337 bfd_xcoff_import_symbol (output_bfd
, info
, harg
, val
, imppath
, impfile
,
2340 struct bfd_link_info
*info
;
2341 struct bfd_link_hash_entry
*harg
;
2343 const char *imppath
;
2344 const char *impfile
;
2345 const char *impmember
;
2347 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2349 if (! XCOFF_XVECP (output_bfd
->xvec
))
2352 h
->flags
|= XCOFF_IMPORT
;
2354 if (val
!= (bfd_vma
) -1)
2356 if (h
->root
.type
== bfd_link_hash_defined
2357 && (! bfd_is_abs_section (h
->root
.u
.def
.section
)
2358 || h
->root
.u
.def
.value
!= val
))
2360 if (! ((*info
->callbacks
->multiple_definition
)
2361 (info
, h
->root
.root
.string
, h
->root
.u
.def
.section
->owner
,
2362 h
->root
.u
.def
.section
, h
->root
.u
.def
.value
,
2363 output_bfd
, bfd_abs_section_ptr
, val
)))
2367 h
->root
.type
= bfd_link_hash_defined
;
2368 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2369 h
->root
.u
.def
.value
= val
;
2372 if (h
->ldsym
== NULL
)
2374 h
->ldsym
= ((struct internal_ldsym
*)
2375 bfd_zalloc (output_bfd
, sizeof (struct internal_ldsym
)));
2376 if (h
->ldsym
== NULL
)
2380 if (imppath
== NULL
)
2381 h
->ldsym
->l_ifile
= (bfd_size_type
) -1;
2385 struct xcoff_import_file
**pp
;
2387 /* We start c at 1 because the first entry in the import list is
2388 reserved for the library search path. */
2389 for (pp
= &xcoff_hash_table (info
)->imports
, c
= 1;
2391 pp
= &(*pp
)->next
, ++c
)
2393 if (strcmp ((*pp
)->path
, imppath
) == 0
2394 && strcmp ((*pp
)->file
, impfile
) == 0
2395 && strcmp ((*pp
)->member
, impmember
) == 0)
2401 struct xcoff_import_file
*n
;
2403 n
= ((struct xcoff_import_file
*)
2404 bfd_alloc (output_bfd
, sizeof (struct xcoff_import_file
)));
2410 n
->member
= impmember
;
2414 h
->ldsym
->l_ifile
= c
;
2420 /* Export a symbol. */
2423 bfd_xcoff_export_symbol (output_bfd
, info
, harg
, syscall
)
2425 struct bfd_link_info
*info
;
2426 struct bfd_link_hash_entry
*harg
;
2429 struct xcoff_link_hash_entry
*h
= (struct xcoff_link_hash_entry
*) harg
;
2431 if (! XCOFF_XVECP (output_bfd
->xvec
))
2434 h
->flags
|= XCOFF_EXPORT
;
2436 /* FIXME: I'm not at all sure what syscall is supposed to mean, so
2437 I'm just going to ignore it until somebody explains it. */
2439 /* See if this is a function descriptor. It may be one even though
2440 it is not so marked. */
2441 if ((h
->flags
& XCOFF_DESCRIPTOR
) == 0
2442 && h
->root
.root
.string
[0] != '.')
2445 struct xcoff_link_hash_entry
*hfn
;
2447 fnname
= (char *) bfd_malloc (strlen (h
->root
.root
.string
) + 2);
2451 strcpy (fnname
+ 1, h
->root
.root
.string
);
2452 hfn
= xcoff_link_hash_lookup (xcoff_hash_table (info
),
2453 fnname
, false, false, true);
2456 && hfn
->smclas
== XMC_PR
2457 && (hfn
->root
.type
== bfd_link_hash_defined
2458 || hfn
->root
.type
== bfd_link_hash_defweak
))
2460 h
->flags
|= XCOFF_DESCRIPTOR
;
2461 h
->descriptor
= hfn
;
2462 hfn
->descriptor
= h
;
2466 /* Make sure we don't garbage collect this symbol. */
2467 if (! xcoff_mark_symbol (info
, h
))
2470 /* If this is a function descriptor, make sure we don't garbage
2471 collect the associated function code. We normally don't have to
2472 worry about this, because the descriptor will be attached to a
2473 section with relocs, but if we are creating the descriptor
2474 ourselves those relocs will not be visible to the mark code. */
2475 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0)
2477 if (! xcoff_mark_symbol (info
, h
->descriptor
))
2484 /* Count a reloc against a symbol. This is called for relocs
2485 generated by the linker script, typically for global constructors
2489 bfd_xcoff_link_count_reloc (output_bfd
, info
, name
)
2491 struct bfd_link_info
*info
;
2494 struct xcoff_link_hash_entry
*h
;
2496 if (! XCOFF_XVECP (output_bfd
->xvec
))
2499 h
= ((struct xcoff_link_hash_entry
*)
2500 bfd_wrapped_link_hash_lookup (output_bfd
, info
, name
, false, false,
2504 (*_bfd_error_handler
) ("%s: no such symbol", name
);
2505 bfd_set_error (bfd_error_no_symbols
);
2509 h
->flags
|= XCOFF_REF_REGULAR
| XCOFF_LDREL
;
2510 ++xcoff_hash_table (info
)->ldrel_count
;
2512 /* Mark the symbol to avoid garbage collection. */
2513 if (! xcoff_mark_symbol (info
, h
))
2519 /* This function is called for each symbol to which the linker script
2523 bfd_xcoff_record_link_assignment (output_bfd
, info
, name
)
2525 struct bfd_link_info
*info
;
2528 struct xcoff_link_hash_entry
*h
;
2530 if (! XCOFF_XVECP (output_bfd
->xvec
))
2533 h
= xcoff_link_hash_lookup (xcoff_hash_table (info
), name
, true, true,
2538 h
->flags
|= XCOFF_DEF_REGULAR
;
2543 /* This structure is used to pass information through
2544 xcoff_link_hash_traverse. */
2546 struct xcoff_loader_info
2548 /* Set if a problem occurred. */
2552 /* Link information structure. */
2553 struct bfd_link_info
*info
;
2554 /* Whether all defined symbols should be exported. */
2555 boolean export_defineds
;
2556 /* Number of ldsym structures. */
2558 /* Size of string table. */
2562 /* Allocated size of string table. */
2566 /* Build the .loader section. This is called by the XCOFF linker
2567 emulation before_allocation routine. We must set the size of the
2568 .loader section before the linker lays out the output file.
2569 LIBPATH is the library path to search for shared objects; this is
2570 normally built from the -L arguments passed to the linker. ENTRY
2571 is the name of the entry point symbol (the -e linker option).
2572 FILE_ALIGN is the alignment to use for sections within the file
2573 (the -H linker option). MAXSTACK is the maximum stack size (the
2574 -bmaxstack linker option). MAXDATA is the maximum data size (the
2575 -bmaxdata linker option). GC is whether to do garbage collection
2576 (the -bgc linker option). MODTYPE is the module type (the
2577 -bmodtype linker option). TEXTRO is whether the text section must
2578 be read only (the -btextro linker option). EXPORT_DEFINEDS is
2579 whether all defined symbols should be exported (the -unix linker
2580 option). SPECIAL_SECTIONS is set by this routine to csects with
2581 magic names like _end. */
2584 bfd_xcoff_size_dynamic_sections (output_bfd
, info
, libpath
, entry
,
2585 file_align
, maxstack
, maxdata
, gc
,
2586 modtype
, textro
, export_defineds
,
2589 struct bfd_link_info
*info
;
2590 const char *libpath
;
2592 unsigned long file_align
;
2593 unsigned long maxstack
;
2594 unsigned long maxdata
;
2598 boolean export_defineds
;
2599 asection
**special_sections
;
2601 struct xcoff_link_hash_entry
*hentry
;
2603 struct xcoff_loader_info ldinfo
;
2605 size_t impsize
, impcount
;
2606 struct xcoff_import_file
*fl
;
2607 struct internal_ldhdr
*ldhdr
;
2608 bfd_size_type stoff
;
2612 struct bfd_strtab_hash
*debug_strtab
;
2613 bfd_byte
*debug_contents
= NULL
;
2615 if (! XCOFF_XVECP (output_bfd
->xvec
))
2617 for (i
= 0; i
< 6; i
++)
2618 special_sections
[i
] = NULL
;
2622 ldinfo
.failed
= false;
2623 ldinfo
.output_bfd
= output_bfd
;
2625 ldinfo
.export_defineds
= export_defineds
;
2626 ldinfo
.ldsym_count
= 0;
2627 ldinfo
.string_size
= 0;
2628 ldinfo
.strings
= NULL
;
2629 ldinfo
.string_alc
= 0;
2631 xcoff_data (output_bfd
)->maxstack
= maxstack
;
2632 xcoff_data (output_bfd
)->maxdata
= maxdata
;
2633 xcoff_data (output_bfd
)->modtype
= modtype
;
2635 xcoff_hash_table (info
)->file_align
= file_align
;
2636 xcoff_hash_table (info
)->textro
= textro
;
2638 hentry
= xcoff_link_hash_lookup (xcoff_hash_table (info
), entry
,
2639 false, false, true);
2641 hentry
->flags
|= XCOFF_ENTRY
;
2643 /* Garbage collect unused sections. */
2644 if (info
->relocateable
2647 || (hentry
->root
.type
!= bfd_link_hash_defined
2648 && hentry
->root
.type
!= bfd_link_hash_defweak
))
2651 xcoff_hash_table (info
)->gc
= false;
2653 /* We still need to call xcoff_mark, in order to set ldrel_count
2655 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
2659 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
2661 if ((o
->flags
& SEC_MARK
) == 0)
2663 if (! xcoff_mark (info
, o
))
2671 if (! xcoff_mark (info
, hentry
->root
.u
.def
.section
))
2674 xcoff_hash_table (info
)->gc
= true;
2677 /* Return special sections to the caller. */
2678 for (i
= 0; i
< 6; i
++)
2682 sec
= xcoff_hash_table (info
)->special_sections
[i
];
2685 && (sec
->flags
& SEC_MARK
) == 0)
2687 special_sections
[i
] = sec
;
2690 if (info
->input_bfds
== NULL
)
2692 /* I'm not sure what to do in this bizarre case. */
2696 xcoff_link_hash_traverse (xcoff_hash_table (info
), xcoff_build_ldsyms
,
2701 /* Work out the size of the import file names. Each import file ID
2702 consists of three null terminated strings: the path, the file
2703 name, and the archive member name. The first entry in the list
2704 of names is the path to use to find objects, which the linker has
2705 passed in as the libpath argument. For some reason, the path
2706 entry in the other import file names appears to always be empty. */
2707 impsize
= strlen (libpath
) + 3;
2709 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
2712 impsize
+= (strlen (fl
->path
)
2714 + strlen (fl
->member
)
2718 /* Set up the .loader section header. */
2719 ldhdr
= &xcoff_hash_table (info
)->ldhdr
;
2720 ldhdr
->l_version
= 1;
2721 ldhdr
->l_nsyms
= ldinfo
.ldsym_count
;
2722 ldhdr
->l_nreloc
= xcoff_hash_table (info
)->ldrel_count
;
2723 ldhdr
->l_istlen
= impsize
;
2724 ldhdr
->l_nimpid
= impcount
;
2725 ldhdr
->l_impoff
= (LDHDRSZ
2726 + ldhdr
->l_nsyms
* LDSYMSZ
2727 + ldhdr
->l_nreloc
* LDRELSZ
);
2728 ldhdr
->l_stlen
= ldinfo
.string_size
;
2729 stoff
= ldhdr
->l_impoff
+ impsize
;
2730 if (ldinfo
.string_size
== 0)
2733 ldhdr
->l_stoff
= stoff
;
2735 /* We now know the final size of the .loader section. Allocate
2737 lsec
= xcoff_hash_table (info
)->loader_section
;
2738 lsec
->_raw_size
= stoff
+ ldhdr
->l_stlen
;
2739 lsec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, lsec
->_raw_size
);
2740 if (lsec
->contents
== NULL
)
2743 /* Set up the header. */
2744 xcoff_swap_ldhdr_out (output_bfd
, ldhdr
,
2745 (struct external_ldhdr
*) lsec
->contents
);
2747 /* Set up the import file names. */
2748 out
= (char *) lsec
->contents
+ ldhdr
->l_impoff
;
2749 strcpy (out
, libpath
);
2750 out
+= strlen (libpath
) + 1;
2753 for (fl
= xcoff_hash_table (info
)->imports
; fl
!= NULL
; fl
= fl
->next
)
2755 register const char *s
;
2758 while ((*out
++ = *s
++) != '\0')
2761 while ((*out
++ = *s
++) != '\0')
2764 while ((*out
++ = *s
++) != '\0')
2768 BFD_ASSERT ((bfd_size_type
) ((bfd_byte
*) out
- lsec
->contents
) == stoff
);
2770 /* Set up the symbol string table. */
2771 if (ldinfo
.string_size
> 0)
2773 memcpy (out
, ldinfo
.strings
, ldinfo
.string_size
);
2774 free (ldinfo
.strings
);
2775 ldinfo
.strings
= NULL
;
2778 /* We can't set up the symbol table or the relocs yet, because we
2779 don't yet know the final position of the various sections. The
2780 .loader symbols are written out when the corresponding normal
2781 symbols are written out in xcoff_link_input_bfd or
2782 xcoff_write_global_symbol. The .loader relocs are written out
2783 when the corresponding normal relocs are handled in
2784 xcoff_link_input_bfd. */
2786 /* Allocate space for the magic sections. */
2787 sec
= xcoff_hash_table (info
)->linkage_section
;
2788 if (sec
->_raw_size
> 0)
2790 sec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, sec
->_raw_size
);
2791 if (sec
->contents
== NULL
)
2794 sec
= xcoff_hash_table (info
)->toc_section
;
2795 if (sec
->_raw_size
> 0)
2797 sec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, sec
->_raw_size
);
2798 if (sec
->contents
== NULL
)
2801 sec
= xcoff_hash_table (info
)->descriptor_section
;
2802 if (sec
->_raw_size
> 0)
2804 sec
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, sec
->_raw_size
);
2805 if (sec
->contents
== NULL
)
2809 /* Now that we've done garbage collection, figure out the contents
2810 of the .debug section. */
2811 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
2813 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
2816 bfd_size_type symcount
;
2817 unsigned long *debug_index
;
2819 bfd_byte
*esym
, *esymend
;
2820 bfd_size_type symesz
;
2822 if (sub
->xvec
!= info
->hash
->creator
)
2824 subdeb
= bfd_get_section_by_name (sub
, ".debug");
2825 if (subdeb
== NULL
|| subdeb
->_raw_size
== 0)
2828 if (info
->strip
== strip_all
2829 || info
->strip
== strip_debugger
2830 || info
->discard
== discard_all
)
2832 subdeb
->_raw_size
= 0;
2836 if (! _bfd_coff_get_external_symbols (sub
))
2839 symcount
= obj_raw_syment_count (sub
);
2840 debug_index
= ((unsigned long *)
2841 bfd_zalloc (sub
, symcount
* sizeof (unsigned long)));
2842 if (debug_index
== NULL
)
2844 xcoff_data (sub
)->debug_indices
= debug_index
;
2846 /* Grab the contents of the .debug section. We use malloc and
2847 copy the neams into the debug stringtab, rather than
2848 bfd_alloc, because I expect that, when linking many files
2849 together, many of the strings will be the same. Storing the
2850 strings in the hash table should save space in this case. */
2851 debug_contents
= (bfd_byte
*) bfd_malloc (subdeb
->_raw_size
);
2852 if (debug_contents
== NULL
)
2854 if (! bfd_get_section_contents (sub
, subdeb
, (PTR
) debug_contents
,
2855 (file_ptr
) 0, subdeb
->_raw_size
))
2858 csectpp
= xcoff_data (sub
)->csects
;
2860 symesz
= bfd_coff_symesz (sub
);
2861 esym
= (bfd_byte
*) obj_coff_external_syms (sub
);
2862 esymend
= esym
+ symcount
* symesz
;
2863 while (esym
< esymend
)
2865 struct internal_syment sym
;
2867 bfd_coff_swap_sym_in (sub
, (PTR
) esym
, (PTR
) &sym
);
2869 *debug_index
= (unsigned long) -1;
2871 if (sym
._n
._n_n
._n_zeroes
== 0
2874 || ((*csectpp
)->flags
& SEC_MARK
) != 0
2875 || *csectpp
== bfd_abs_section_ptr
)
2876 && bfd_coff_symname_in_debug (sub
, &sym
))
2881 name
= (char *) debug_contents
+ sym
._n
._n_n
._n_offset
;
2882 indx
= _bfd_stringtab_add (debug_strtab
, name
, true, true);
2883 if (indx
== (bfd_size_type
) -1)
2885 *debug_index
= indx
;
2888 esym
+= (sym
.n_numaux
+ 1) * symesz
;
2889 csectpp
+= sym
.n_numaux
+ 1;
2890 debug_index
+= sym
.n_numaux
+ 1;
2893 free (debug_contents
);
2894 debug_contents
= NULL
;
2896 /* Clear the size of subdeb, so that it is not included directly
2897 in the output file. */
2898 subdeb
->_raw_size
= 0;
2900 if (! info
->keep_memory
)
2902 if (! _bfd_coff_free_symbols (sub
))
2907 xcoff_hash_table (info
)->debug_section
->_raw_size
=
2908 _bfd_stringtab_size (debug_strtab
);
2913 if (ldinfo
.strings
!= NULL
)
2914 free (ldinfo
.strings
);
2915 if (debug_contents
!= NULL
)
2916 free (debug_contents
);
2920 /* Add a symbol to the .loader symbols, if necessary. */
2923 xcoff_build_ldsyms (h
, p
)
2924 struct xcoff_link_hash_entry
*h
;
2927 struct xcoff_loader_info
*ldinfo
= (struct xcoff_loader_info
*) p
;
2930 /* If all defined symbols should be exported, mark them now. */
2931 if (ldinfo
->export_defineds
2932 && (h
->flags
& XCOFF_DEF_REGULAR
) != 0)
2933 h
->flags
|= XCOFF_EXPORT
;
2935 /* We don't want to garbage collect symbols which are not defined in
2936 XCOFF files. This is a convenient place to mark them. */
2937 if (xcoff_hash_table (ldinfo
->info
)->gc
2938 && (h
->flags
& XCOFF_MARK
) == 0
2939 && (h
->root
.type
== bfd_link_hash_defined
2940 || h
->root
.type
== bfd_link_hash_defweak
)
2941 && (h
->root
.u
.def
.section
->owner
== NULL
2942 || (h
->root
.u
.def
.section
->owner
->xvec
2943 != ldinfo
->info
->hash
->creator
)))
2944 h
->flags
|= XCOFF_MARK
;
2946 /* If this symbol is called and defined in a dynamic object, or not
2947 defined at all when building a shared object, or imported, then
2948 we need to set up global linkage code for it. (Unless we did
2949 garbage collection and we didn't need this symbol.) */
2950 if ((h
->flags
& XCOFF_CALLED
) != 0
2951 && (h
->root
.type
== bfd_link_hash_undefined
2952 || h
->root
.type
== bfd_link_hash_undefweak
)
2953 && h
->root
.root
.string
[0] == '.'
2954 && h
->descriptor
!= NULL
2955 && ((h
->descriptor
->flags
& XCOFF_DEF_DYNAMIC
) != 0
2956 || ldinfo
->info
->shared
2957 || ((h
->descriptor
->flags
& XCOFF_IMPORT
) != 0
2958 && (h
->descriptor
->flags
& XCOFF_DEF_REGULAR
) == 0))
2959 && (! xcoff_hash_table (ldinfo
->info
)->gc
2960 || (h
->flags
& XCOFF_MARK
) != 0))
2963 struct xcoff_link_hash_entry
*hds
;
2965 sec
= xcoff_hash_table (ldinfo
->info
)->linkage_section
;
2966 h
->root
.type
= bfd_link_hash_defined
;
2967 h
->root
.u
.def
.section
= sec
;
2968 h
->root
.u
.def
.value
= sec
->_raw_size
;
2970 h
->flags
|= XCOFF_DEF_REGULAR
;
2971 sec
->_raw_size
+= XCOFF_GLINK_SIZE
;
2973 /* The global linkage code requires a TOC entry for the
2975 hds
= h
->descriptor
;
2976 BFD_ASSERT ((hds
->root
.type
== bfd_link_hash_undefined
2977 || hds
->root
.type
== bfd_link_hash_undefweak
)
2978 && (hds
->flags
& XCOFF_DEF_REGULAR
) == 0);
2979 hds
->flags
|= XCOFF_MARK
;
2980 if (hds
->toc_section
== NULL
)
2982 hds
->toc_section
= xcoff_hash_table (ldinfo
->info
)->toc_section
;
2983 hds
->u
.toc_offset
= hds
->toc_section
->_raw_size
;
2984 hds
->toc_section
->_raw_size
+= 4;
2985 ++xcoff_hash_table (ldinfo
->info
)->ldrel_count
;
2986 ++hds
->toc_section
->reloc_count
;
2988 hds
->flags
|= XCOFF_SET_TOC
| XCOFF_LDREL
;
2990 /* We need to call xcoff_build_ldsyms recursively here,
2991 because we may already have passed hds on the traversal. */
2992 xcoff_build_ldsyms (hds
, p
);
2996 /* If this symbol is exported, but not defined, we need to try to
2998 if ((h
->flags
& XCOFF_EXPORT
) != 0
2999 && (h
->flags
& XCOFF_IMPORT
) == 0
3000 && (h
->flags
& XCOFF_DEF_REGULAR
) == 0
3001 && (h
->flags
& XCOFF_DEF_DYNAMIC
) == 0
3002 && (h
->root
.type
== bfd_link_hash_undefined
3003 || h
->root
.type
== bfd_link_hash_undefweak
))
3005 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
3006 && (h
->descriptor
->root
.type
== bfd_link_hash_defined
3007 || h
->descriptor
->root
.type
== bfd_link_hash_defweak
))
3011 /* This is an undefined function descriptor associated with
3012 a defined entry point. We can build up a function
3013 descriptor ourselves. Believe it or not, the AIX linker
3014 actually does this, and there are cases where we need to
3016 sec
= xcoff_hash_table (ldinfo
->info
)->descriptor_section
;
3017 h
->root
.type
= bfd_link_hash_defined
;
3018 h
->root
.u
.def
.section
= sec
;
3019 h
->root
.u
.def
.value
= sec
->_raw_size
;
3021 h
->flags
|= XCOFF_DEF_REGULAR
;
3022 sec
->_raw_size
+= 12;
3024 /* A function descriptor uses two relocs: one for the
3025 associated code, and one for the TOC address. */
3026 xcoff_hash_table (ldinfo
->info
)->ldrel_count
+= 2;
3027 sec
->reloc_count
+= 2;
3029 /* We handle writing out the contents of the descriptor in
3030 xcoff_write_global_symbol. */
3034 (*_bfd_error_handler
)
3035 ("attempt to export undefined symbol `%s'",
3036 h
->root
.root
.string
);
3037 ldinfo
->failed
= true;
3038 bfd_set_error (bfd_error_invalid_operation
);
3043 /* If this is still a common symbol, and it wasn't garbage
3044 collected, we need to actually allocate space for it in the .bss
3046 if (h
->root
.type
== bfd_link_hash_common
3047 && (! xcoff_hash_table (ldinfo
->info
)->gc
3048 || (h
->flags
& XCOFF_MARK
) != 0)
3049 && h
->root
.u
.c
.p
->section
->_raw_size
== 0)
3051 BFD_ASSERT (bfd_is_com_section (h
->root
.u
.c
.p
->section
));
3052 h
->root
.u
.c
.p
->section
->_raw_size
= h
->root
.u
.c
.size
;
3055 /* We need to add a symbol to the .loader section if it is mentioned
3056 in a reloc which we are copying to the .loader section and it was
3057 not defined or common, or if it is the entry point, or if it is
3060 if (((h
->flags
& XCOFF_LDREL
) == 0
3061 || h
->root
.type
== bfd_link_hash_defined
3062 || h
->root
.type
== bfd_link_hash_defweak
3063 || h
->root
.type
== bfd_link_hash_common
)
3064 && (h
->flags
& XCOFF_ENTRY
) == 0
3065 && (h
->flags
& XCOFF_EXPORT
) == 0)
3071 /* We don't need to add this symbol if we did garbage collection and
3072 we did not mark this symbol. */
3073 if (xcoff_hash_table (ldinfo
->info
)->gc
3074 && (h
->flags
& XCOFF_MARK
) == 0)
3080 /* We may have already processed this symbol due to the recursive
3082 if ((h
->flags
& XCOFF_BUILT_LDSYM
) != 0)
3085 /* We need to add this symbol to the .loader symbols. */
3087 /* h->ldsym will already have been allocated for an explicitly
3089 if (h
->ldsym
== NULL
)
3091 h
->ldsym
= ((struct internal_ldsym
*)
3092 bfd_zalloc (ldinfo
->output_bfd
,
3093 sizeof (struct internal_ldsym
)));
3094 if (h
->ldsym
== NULL
)
3096 ldinfo
->failed
= true;
3101 /* The first 3 symbol table indices are reserved to indicate the
3103 h
->ldindx
= ldinfo
->ldsym_count
+ 3;
3105 ++ldinfo
->ldsym_count
;
3107 len
= strlen (h
->root
.root
.string
);
3108 if (len
<= SYMNMLEN
)
3109 strncpy (h
->ldsym
->_l
._l_name
, h
->root
.root
.string
, SYMNMLEN
);
3112 if (ldinfo
->string_size
+ len
+ 3 > ldinfo
->string_alc
)
3115 bfd_byte
*newstrings
;
3117 newalc
= ldinfo
->string_alc
* 2;
3120 while (ldinfo
->string_size
+ len
+ 3 > newalc
)
3123 newstrings
= ((bfd_byte
*)
3124 bfd_realloc ((PTR
) ldinfo
->strings
, newalc
));
3125 if (newstrings
== NULL
)
3127 ldinfo
->failed
= true;
3130 ldinfo
->string_alc
= newalc
;
3131 ldinfo
->strings
= newstrings
;
3134 bfd_put_16 (ldinfo
->output_bfd
, len
+ 1,
3135 ldinfo
->strings
+ ldinfo
->string_size
);
3136 strcpy (ldinfo
->strings
+ ldinfo
->string_size
+ 2, h
->root
.root
.string
);
3137 h
->ldsym
->_l
._l_l
._l_zeroes
= 0;
3138 h
->ldsym
->_l
._l_l
._l_offset
= ldinfo
->string_size
+ 2;
3139 ldinfo
->string_size
+= len
+ 3;
3142 h
->flags
|= XCOFF_BUILT_LDSYM
;
3147 /* Do the final link step. */
3150 _bfd_xcoff_bfd_final_link (abfd
, info
)
3152 struct bfd_link_info
*info
;
3154 bfd_size_type symesz
;
3155 struct xcoff_final_link_info finfo
;
3157 struct bfd_link_order
*p
;
3158 size_t max_contents_size
;
3159 size_t max_sym_count
;
3160 size_t max_lineno_count
;
3161 size_t max_reloc_count
;
3162 size_t max_output_reloc_count
;
3163 file_ptr rel_filepos
;
3165 file_ptr line_filepos
;
3166 unsigned int linesz
;
3168 bfd_byte
*external_relocs
= NULL
;
3169 char strbuf
[STRING_SIZE_SIZE
];
3172 abfd
->flags
|= DYNAMIC
;
3174 symesz
= bfd_coff_symesz (abfd
);
3177 finfo
.output_bfd
= abfd
;
3178 finfo
.strtab
= NULL
;
3179 finfo
.section_info
= NULL
;
3180 finfo
.last_file_index
= -1;
3181 finfo
.toc_symindx
= -1;
3182 finfo
.internal_syms
= NULL
;
3183 finfo
.sym_indices
= NULL
;
3184 finfo
.outsyms
= NULL
;
3185 finfo
.linenos
= NULL
;
3186 finfo
.contents
= NULL
;
3187 finfo
.external_relocs
= NULL
;
3189 finfo
.ldsym
= ((struct external_ldsym
*)
3190 (xcoff_hash_table (info
)->loader_section
->contents
3192 finfo
.ldrel
= ((struct external_ldrel
*)
3193 (xcoff_hash_table (info
)->loader_section
->contents
3195 + xcoff_hash_table (info
)->ldhdr
.l_nsyms
* LDSYMSZ
));
3197 xcoff_data (abfd
)->coff
.link_info
= info
;
3199 finfo
.strtab
= _bfd_stringtab_init ();
3200 if (finfo
.strtab
== NULL
)
3203 /* Count the line number and relocation entries required for the
3204 output file. Determine a few maximum sizes. */
3205 max_contents_size
= 0;
3206 max_lineno_count
= 0;
3207 max_reloc_count
= 0;
3208 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3211 o
->lineno_count
= 0;
3212 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3214 if (p
->type
== bfd_indirect_link_order
)
3218 sec
= p
->u
.indirect
.section
;
3220 /* Mark all sections which are to be included in the
3221 link. This will normally be every section. We need
3222 to do this so that we can identify any sections which
3223 the linker has decided to not include. */
3224 sec
->linker_mark
= true;
3226 if (info
->strip
== strip_none
3227 || info
->strip
== strip_some
)
3228 o
->lineno_count
+= sec
->lineno_count
;
3230 o
->reloc_count
+= sec
->reloc_count
;
3232 if (sec
->_raw_size
> max_contents_size
)
3233 max_contents_size
= sec
->_raw_size
;
3234 if (sec
->lineno_count
> max_lineno_count
)
3235 max_lineno_count
= sec
->lineno_count
;
3236 if (coff_section_data (sec
->owner
, sec
) != NULL
3237 && xcoff_section_data (sec
->owner
, sec
) != NULL
3238 && (xcoff_section_data (sec
->owner
, sec
)->lineno_count
3239 > max_lineno_count
))
3241 xcoff_section_data (sec
->owner
, sec
)->lineno_count
;
3242 if (sec
->reloc_count
> max_reloc_count
)
3243 max_reloc_count
= sec
->reloc_count
;
3245 else if (p
->type
== bfd_section_reloc_link_order
3246 || p
->type
== bfd_symbol_reloc_link_order
)
3251 /* Compute the file positions for all the sections. */
3252 if (abfd
->output_has_begun
)
3254 if (xcoff_hash_table (info
)->file_align
!= 0)
3261 file_align
= xcoff_hash_table (info
)->file_align
;
3262 if (file_align
!= 0)
3264 boolean saw_contents
;
3269 /* Insert .pad sections before every section which has
3270 contents and is loaded, if it is preceded by some other
3271 section which has contents and is loaded. */
3272 saw_contents
= true;
3273 for (op
= &abfd
->sections
; *op
!= NULL
; op
= &(*op
)->next
)
3275 (*op
)->target_index
= indx
;
3276 if (strcmp ((*op
)->name
, ".pad") == 0)
3277 saw_contents
= false;
3278 else if (((*op
)->flags
& SEC_HAS_CONTENTS
) != 0
3279 && ((*op
)->flags
& SEC_LOAD
) != 0)
3282 saw_contents
= true;
3289 n
= bfd_make_section_anyway (abfd
, ".pad");
3290 BFD_ASSERT (*op
== n
);
3292 n
->flags
= SEC_HAS_CONTENTS
;
3293 n
->alignment_power
= 0;
3294 saw_contents
= false;
3299 /* Reset the section indices after inserting the new
3302 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3305 o
->target_index
= indx
;
3307 BFD_ASSERT ((unsigned int) indx
== abfd
->section_count
);
3309 /* Work out appropriate sizes for the .pad sections to force
3310 each section to land on a page boundary. This bit of
3311 code knows what compute_section_file_positions is going
3313 sofar
= bfd_coff_filhsz (abfd
);
3314 sofar
+= bfd_coff_aoutsz (abfd
);
3315 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3316 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3317 if (o
->reloc_count
>= 0xffff || o
->lineno_count
>= 0xffff)
3318 sofar
+= bfd_coff_scnhsz (abfd
);
3320 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3322 if (strcmp (o
->name
, ".pad") == 0)
3326 BFD_ASSERT (o
->_raw_size
== 0);
3327 pageoff
= sofar
& (file_align
- 1);
3330 o
->_raw_size
= file_align
- pageoff
;
3331 sofar
+= file_align
- pageoff
;
3332 o
->flags
|= SEC_HAS_CONTENTS
;
3337 if ((o
->flags
& SEC_HAS_CONTENTS
) != 0)
3338 sofar
+= BFD_ALIGN (o
->_raw_size
,
3339 1 << o
->alignment_power
);
3344 bfd_coff_compute_section_file_positions (abfd
);
3347 /* Allocate space for the pointers we need to keep for the relocs. */
3351 /* We use section_count + 1, rather than section_count, because
3352 the target_index fields are 1 based. */
3353 finfo
.section_info
=
3354 ((struct xcoff_link_section_info
*)
3355 bfd_malloc ((abfd
->section_count
+ 1)
3356 * sizeof (struct xcoff_link_section_info
)));
3357 if (finfo
.section_info
== NULL
)
3359 for (i
= 0; i
<= abfd
->section_count
; i
++)
3361 finfo
.section_info
[i
].relocs
= NULL
;
3362 finfo
.section_info
[i
].rel_hashes
= NULL
;
3363 finfo
.section_info
[i
].toc_rel_hashes
= NULL
;
3367 /* Set the file positions for the relocs. */
3368 rel_filepos
= obj_relocbase (abfd
);
3369 relsz
= bfd_coff_relsz (abfd
);
3370 max_output_reloc_count
= 0;
3371 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3373 if (o
->reloc_count
== 0)
3377 o
->flags
|= SEC_RELOC
;
3378 o
->rel_filepos
= rel_filepos
;
3379 rel_filepos
+= o
->reloc_count
* relsz
;
3381 /* We don't know the indices of global symbols until we have
3382 written out all the local symbols. For each section in
3383 the output file, we keep an array of pointers to hash
3384 table entries. Each entry in the array corresponds to a
3385 reloc. When we find a reloc against a global symbol, we
3386 set the corresponding entry in this array so that we can
3387 fix up the symbol index after we have written out all the
3390 Because of this problem, we also keep the relocs in
3391 memory until the end of the link. This wastes memory.
3392 We could backpatch the file later, I suppose, although it
3394 finfo
.section_info
[o
->target_index
].relocs
=
3395 ((struct internal_reloc
*)
3396 bfd_malloc (o
->reloc_count
* sizeof (struct internal_reloc
)));
3397 finfo
.section_info
[o
->target_index
].rel_hashes
=
3398 ((struct xcoff_link_hash_entry
**)
3399 bfd_malloc (o
->reloc_count
3400 * sizeof (struct xcoff_link_hash_entry
*)));
3401 if (finfo
.section_info
[o
->target_index
].relocs
== NULL
3402 || finfo
.section_info
[o
->target_index
].rel_hashes
== NULL
)
3405 if (o
->reloc_count
> max_output_reloc_count
)
3406 max_output_reloc_count
= o
->reloc_count
;
3410 /* We now know the size of the relocs, so we can determine the file
3411 positions of the line numbers. */
3412 line_filepos
= rel_filepos
;
3413 finfo
.line_filepos
= line_filepos
;
3414 linesz
= bfd_coff_linesz (abfd
);
3415 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3417 if (o
->lineno_count
== 0)
3418 o
->line_filepos
= 0;
3421 o
->line_filepos
= line_filepos
;
3422 line_filepos
+= o
->lineno_count
* linesz
;
3425 /* Reset the reloc and lineno counts, so that we can use them to
3426 count the number of entries we have output so far. */
3428 o
->lineno_count
= 0;
3431 obj_sym_filepos (abfd
) = line_filepos
;
3433 /* Figure out the largest number of symbols in an input BFD. Take
3434 the opportunity to clear the output_has_begun fields of all the
3435 input BFD's. We want at least 4 symbols, since that is the
3436 number which xcoff_write_global_symbol may need. */
3438 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3442 sub
->output_has_begun
= false;
3443 sz
= obj_raw_syment_count (sub
);
3444 if (sz
> max_sym_count
)
3448 /* Allocate some buffers used while linking. */
3449 finfo
.internal_syms
= ((struct internal_syment
*)
3450 bfd_malloc (max_sym_count
3451 * sizeof (struct internal_syment
)));
3452 finfo
.sym_indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
3453 finfo
.outsyms
= ((bfd_byte
*)
3454 bfd_malloc ((size_t) ((max_sym_count
+ 1) * symesz
)));
3455 finfo
.linenos
= (bfd_byte
*) bfd_malloc (max_lineno_count
3456 * bfd_coff_linesz (abfd
));
3457 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
3458 finfo
.external_relocs
= (bfd_byte
*) bfd_malloc (max_reloc_count
* relsz
);
3459 if ((finfo
.internal_syms
== NULL
&& max_sym_count
> 0)
3460 || (finfo
.sym_indices
== NULL
&& max_sym_count
> 0)
3461 || finfo
.outsyms
== NULL
3462 || (finfo
.linenos
== NULL
&& max_lineno_count
> 0)
3463 || (finfo
.contents
== NULL
&& max_contents_size
> 0)
3464 || (finfo
.external_relocs
== NULL
&& max_reloc_count
> 0))
3467 obj_raw_syment_count (abfd
) = 0;
3468 xcoff_data (abfd
)->toc
= (bfd_vma
) -1;
3470 /* We now know the position of everything in the file, except that
3471 we don't know the size of the symbol table and therefore we don't
3472 know where the string table starts. We just build the string
3473 table in memory as we go along. We process all the relocations
3474 for a single input file at once. */
3475 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3477 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3479 if (p
->type
== bfd_indirect_link_order
3480 && p
->u
.indirect
.section
->owner
->xvec
== abfd
->xvec
)
3482 sub
= p
->u
.indirect
.section
->owner
;
3483 if (! sub
->output_has_begun
)
3485 if (! xcoff_link_input_bfd (&finfo
, sub
))
3487 sub
->output_has_begun
= true;
3490 else if (p
->type
== bfd_section_reloc_link_order
3491 || p
->type
== bfd_symbol_reloc_link_order
)
3493 if (! xcoff_reloc_link_order (abfd
, &finfo
, o
, p
))
3498 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3504 /* Free up the buffers used by xcoff_link_input_bfd. */
3506 if (finfo
.internal_syms
!= NULL
)
3508 free (finfo
.internal_syms
);
3509 finfo
.internal_syms
= NULL
;
3511 if (finfo
.sym_indices
!= NULL
)
3513 free (finfo
.sym_indices
);
3514 finfo
.sym_indices
= NULL
;
3516 if (finfo
.linenos
!= NULL
)
3518 free (finfo
.linenos
);
3519 finfo
.linenos
= NULL
;
3521 if (finfo
.contents
!= NULL
)
3523 free (finfo
.contents
);
3524 finfo
.contents
= NULL
;
3526 if (finfo
.external_relocs
!= NULL
)
3528 free (finfo
.external_relocs
);
3529 finfo
.external_relocs
= NULL
;
3532 /* The value of the last C_FILE symbol is supposed to be -1. Write
3534 if (finfo
.last_file_index
!= -1)
3536 finfo
.last_file
.n_value
= -1;
3537 bfd_coff_swap_sym_out (abfd
, (PTR
) &finfo
.last_file
,
3538 (PTR
) finfo
.outsyms
);
3540 (obj_sym_filepos (abfd
)
3541 + finfo
.last_file_index
* symesz
),
3543 || bfd_write (finfo
.outsyms
, symesz
, 1, abfd
) != symesz
)
3547 /* Write out all the global symbols which do not come from XCOFF
3549 xcoff_link_hash_traverse (xcoff_hash_table (info
),
3550 xcoff_write_global_symbol
,
3553 if (finfo
.outsyms
!= NULL
)
3555 free (finfo
.outsyms
);
3556 finfo
.outsyms
= NULL
;
3559 /* Now that we have written out all the global symbols, we know the
3560 symbol indices to use for relocs against them, and we can finally
3561 write out the relocs. */
3562 external_relocs
= (bfd_byte
*) malloc (max_output_reloc_count
* relsz
);
3563 if (external_relocs
== NULL
&& max_output_reloc_count
!= 0)
3565 bfd_set_error (bfd_error_no_memory
);
3569 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3571 struct internal_reloc
*irel
;
3572 struct internal_reloc
*irelend
;
3573 struct xcoff_link_hash_entry
**rel_hash
;
3574 struct xcoff_toc_rel_hash
*toc_rel_hash
;
3577 if (o
->reloc_count
== 0)
3580 irel
= finfo
.section_info
[o
->target_index
].relocs
;
3581 irelend
= irel
+ o
->reloc_count
;
3582 rel_hash
= finfo
.section_info
[o
->target_index
].rel_hashes
;
3583 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
3585 if (*rel_hash
!= NULL
)
3587 if ((*rel_hash
)->indx
< 0)
3589 if (! ((*info
->callbacks
->unattached_reloc
)
3590 (info
, (*rel_hash
)->root
.root
.string
,
3591 (bfd
*) NULL
, o
, irel
->r_vaddr
)))
3593 (*rel_hash
)->indx
= 0;
3595 irel
->r_symndx
= (*rel_hash
)->indx
;
3599 for (toc_rel_hash
= finfo
.section_info
[o
->target_index
].toc_rel_hashes
;
3600 toc_rel_hash
!= NULL
;
3601 toc_rel_hash
= toc_rel_hash
->next
)
3603 if (toc_rel_hash
->h
->u
.toc_indx
< 0)
3605 if (! ((*info
->callbacks
->unattached_reloc
)
3606 (info
, toc_rel_hash
->h
->root
.root
.string
,
3607 (bfd
*) NULL
, o
, toc_rel_hash
->rel
->r_vaddr
)))
3609 toc_rel_hash
->h
->u
.toc_indx
= 0;
3611 toc_rel_hash
->rel
->r_symndx
= toc_rel_hash
->h
->u
.toc_indx
;
3614 /* XCOFF requires that the relocs be sorted by address. We tend
3615 to produce them in the order in which their containing csects
3616 appear in the symbol table, which is not necessarily by
3617 address. So we sort them here. There may be a better way to
3619 qsort ((PTR
) finfo
.section_info
[o
->target_index
].relocs
,
3620 o
->reloc_count
, sizeof (struct internal_reloc
),
3623 irel
= finfo
.section_info
[o
->target_index
].relocs
;
3624 irelend
= irel
+ o
->reloc_count
;
3625 erel
= external_relocs
;
3626 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
3627 bfd_coff_swap_reloc_out (abfd
, (PTR
) irel
, (PTR
) erel
);
3629 if (bfd_seek (abfd
, o
->rel_filepos
, SEEK_SET
) != 0
3630 || bfd_write ((PTR
) external_relocs
, relsz
, o
->reloc_count
,
3631 abfd
) != relsz
* o
->reloc_count
)
3635 if (external_relocs
!= NULL
)
3637 free (external_relocs
);
3638 external_relocs
= NULL
;
3641 /* Free up the section information. */
3642 if (finfo
.section_info
!= NULL
)
3646 for (i
= 0; i
< abfd
->section_count
; i
++)
3648 if (finfo
.section_info
[i
].relocs
!= NULL
)
3649 free (finfo
.section_info
[i
].relocs
);
3650 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
3651 free (finfo
.section_info
[i
].rel_hashes
);
3653 free (finfo
.section_info
);
3654 finfo
.section_info
= NULL
;
3657 /* Write out the loader section contents. */
3658 BFD_ASSERT ((bfd_byte
*) finfo
.ldrel
3659 == (xcoff_hash_table (info
)->loader_section
->contents
3660 + xcoff_hash_table (info
)->ldhdr
.l_impoff
));
3661 o
= xcoff_hash_table (info
)->loader_section
;
3662 if (! bfd_set_section_contents (abfd
, o
->output_section
,
3663 o
->contents
, o
->output_offset
,
3667 /* Write out the magic sections. */
3668 o
= xcoff_hash_table (info
)->linkage_section
;
3669 if (o
->_raw_size
> 0
3670 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
3671 o
->output_offset
, o
->_raw_size
))
3673 o
= xcoff_hash_table (info
)->toc_section
;
3674 if (o
->_raw_size
> 0
3675 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
3676 o
->output_offset
, o
->_raw_size
))
3678 o
= xcoff_hash_table (info
)->descriptor_section
;
3679 if (o
->_raw_size
> 0
3680 && ! bfd_set_section_contents (abfd
, o
->output_section
, o
->contents
,
3681 o
->output_offset
, o
->_raw_size
))
3684 /* Write out the string table. */
3686 (obj_sym_filepos (abfd
)
3687 + obj_raw_syment_count (abfd
) * symesz
),
3691 _bfd_stringtab_size (finfo
.strtab
) + STRING_SIZE_SIZE
,
3692 (bfd_byte
*) strbuf
);
3693 if (bfd_write (strbuf
, 1, STRING_SIZE_SIZE
, abfd
) != STRING_SIZE_SIZE
)
3695 if (! _bfd_stringtab_emit (abfd
, finfo
.strtab
))
3698 _bfd_stringtab_free (finfo
.strtab
);
3700 /* Write out the debugging string table. */
3701 o
= xcoff_hash_table (info
)->debug_section
;
3704 struct bfd_strtab_hash
*debug_strtab
;
3706 debug_strtab
= xcoff_hash_table (info
)->debug_strtab
;
3707 BFD_ASSERT (o
->output_section
->_raw_size
- o
->output_offset
3708 >= _bfd_stringtab_size (debug_strtab
));
3710 o
->output_section
->filepos
+ o
->output_offset
,
3713 if (! _bfd_stringtab_emit (abfd
, debug_strtab
))
3717 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
3718 not try to write out the symbols. */
3719 bfd_get_symcount (abfd
) = 0;
3724 if (finfo
.strtab
!= NULL
)
3725 _bfd_stringtab_free (finfo
.strtab
);
3726 if (finfo
.section_info
!= NULL
)
3730 for (i
= 0; i
< abfd
->section_count
; i
++)
3732 if (finfo
.section_info
[i
].relocs
!= NULL
)
3733 free (finfo
.section_info
[i
].relocs
);
3734 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
3735 free (finfo
.section_info
[i
].rel_hashes
);
3737 free (finfo
.section_info
);
3739 if (finfo
.internal_syms
!= NULL
)
3740 free (finfo
.internal_syms
);
3741 if (finfo
.sym_indices
!= NULL
)
3742 free (finfo
.sym_indices
);
3743 if (finfo
.outsyms
!= NULL
)
3744 free (finfo
.outsyms
);
3745 if (finfo
.linenos
!= NULL
)
3746 free (finfo
.linenos
);
3747 if (finfo
.contents
!= NULL
)
3748 free (finfo
.contents
);
3749 if (finfo
.external_relocs
!= NULL
)
3750 free (finfo
.external_relocs
);
3751 if (external_relocs
!= NULL
)
3752 free (external_relocs
);
3756 /* Link an input file into the linker output file. This function
3757 handles all the sections and relocations of the input file at once. */
3760 xcoff_link_input_bfd (finfo
, input_bfd
)
3761 struct xcoff_final_link_info
*finfo
;
3765 const char *strings
;
3766 bfd_size_type syment_base
;
3767 unsigned int n_tmask
;
3768 unsigned int n_btshft
;
3770 bfd_size_type isymesz
;
3771 bfd_size_type osymesz
;
3772 bfd_size_type linesz
;
3775 struct xcoff_link_hash_entry
**sym_hash
;
3776 struct internal_syment
*isymp
;
3778 unsigned long *debug_index
;
3780 unsigned long output_index
;
3787 /* We can just skip DYNAMIC files, unless this is a static link. */
3788 if ((input_bfd
->flags
& DYNAMIC
) != 0
3789 && ! finfo
->info
->static_link
)
3792 /* Move all the symbols to the output file. */
3794 output_bfd
= finfo
->output_bfd
;
3796 syment_base
= obj_raw_syment_count (output_bfd
);
3797 isymesz
= bfd_coff_symesz (input_bfd
);
3798 osymesz
= bfd_coff_symesz (output_bfd
);
3799 linesz
= bfd_coff_linesz (input_bfd
);
3800 BFD_ASSERT (linesz
== bfd_coff_linesz (output_bfd
));
3802 n_tmask
= coff_data (input_bfd
)->local_n_tmask
;
3803 n_btshft
= coff_data (input_bfd
)->local_n_btshft
;
3805 /* Define macros so that ISFCN, et. al., macros work correctly. */
3806 #define N_TMASK n_tmask
3807 #define N_BTSHFT n_btshft
3810 if (! finfo
->info
->keep_memory
)
3813 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
3816 if (! _bfd_coff_get_external_symbols (input_bfd
))
3819 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
3820 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
3821 sym_hash
= obj_xcoff_sym_hashes (input_bfd
);
3822 csectpp
= xcoff_data (input_bfd
)->csects
;
3823 debug_index
= xcoff_data (input_bfd
)->debug_indices
;
3824 isymp
= finfo
->internal_syms
;
3825 indexp
= finfo
->sym_indices
;
3826 output_index
= syment_base
;
3827 outsym
= finfo
->outsyms
;
3831 while (esym
< esym_end
)
3833 struct internal_syment isym
;
3834 union internal_auxent aux
;
3840 bfd_coff_swap_sym_in (input_bfd
, (PTR
) esym
, (PTR
) isymp
);
3842 /* If this is a C_EXT or C_HIDEXT symbol, we need the csect
3844 if (isymp
->n_sclass
== C_EXT
|| isymp
->n_sclass
== C_HIDEXT
)
3846 BFD_ASSERT (isymp
->n_numaux
> 0);
3847 bfd_coff_swap_aux_in (input_bfd
,
3848 (PTR
) (esym
+ isymesz
* isymp
->n_numaux
),
3849 isymp
->n_type
, isymp
->n_sclass
,
3850 isymp
->n_numaux
- 1, isymp
->n_numaux
,
3852 smtyp
= SMTYP_SMTYP (aux
.x_csect
.x_smtyp
);
3855 /* Make a copy of *isymp so that the relocate_section function
3856 always sees the original values. This is more reliable than
3857 always recomputing the symbol value even if we are stripping
3861 /* If this symbol is in the .loader section, swap out the
3862 .loader symbol information. If this is an external symbol
3863 reference to a defined symbol, though, then wait until we get
3864 to the definition. */
3865 if (isym
.n_sclass
== C_EXT
3866 && *sym_hash
!= NULL
3867 && (*sym_hash
)->ldsym
!= NULL
3869 || (*sym_hash
)->root
.type
== bfd_link_hash_undefined
))
3871 struct xcoff_link_hash_entry
*h
;
3872 struct internal_ldsym
*ldsym
;
3876 if (isym
.n_scnum
> 0)
3878 ldsym
->l_scnum
= (*csectpp
)->output_section
->target_index
;
3879 ldsym
->l_value
= (isym
.n_value
3880 + (*csectpp
)->output_section
->vma
3881 + (*csectpp
)->output_offset
3886 ldsym
->l_scnum
= isym
.n_scnum
;
3887 ldsym
->l_value
= isym
.n_value
;
3890 ldsym
->l_smtype
= smtyp
;
3891 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
3892 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
3893 || (h
->flags
& XCOFF_IMPORT
) != 0)
3894 ldsym
->l_smtype
|= L_IMPORT
;
3895 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
3896 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
3897 || (h
->flags
& XCOFF_EXPORT
) != 0)
3898 ldsym
->l_smtype
|= L_EXPORT
;
3899 if ((h
->flags
& XCOFF_ENTRY
) != 0)
3900 ldsym
->l_smtype
|= L_ENTRY
;
3902 ldsym
->l_smclas
= aux
.x_csect
.x_smclas
;
3904 if (ldsym
->l_ifile
== (bfd_size_type
) -1)
3906 else if (ldsym
->l_ifile
== 0)
3908 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
3914 if (h
->root
.type
== bfd_link_hash_defined
3915 || h
->root
.type
== bfd_link_hash_defweak
)
3916 impbfd
= h
->root
.u
.def
.section
->owner
;
3917 else if (h
->root
.type
== bfd_link_hash_undefined
3918 || h
->root
.type
== bfd_link_hash_undefweak
)
3919 impbfd
= h
->root
.u
.undef
.abfd
;
3927 BFD_ASSERT (impbfd
->xvec
== finfo
->output_bfd
->xvec
);
3928 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
3935 BFD_ASSERT (h
->ldindx
>= 0);
3936 BFD_ASSERT (LDSYMSZ
== sizeof (struct external_ldsym
));
3937 xcoff_swap_ldsym_out (finfo
->output_bfd
, ldsym
,
3938 finfo
->ldsym
+ h
->ldindx
- 3);
3941 /* Fill in snentry now that we know the target_index. */
3942 if ((h
->flags
& XCOFF_ENTRY
) != 0
3943 && (h
->root
.type
== bfd_link_hash_defined
3944 || h
->root
.type
== bfd_link_hash_defweak
))
3945 xcoff_data (output_bfd
)->snentry
=
3946 h
->root
.u
.def
.section
->output_section
->target_index
;
3953 add
= 1 + isym
.n_numaux
;
3955 /* If we are skipping this csect, we want to skip this symbol. */
3956 if (*csectpp
== NULL
)
3959 /* If we garbage collected this csect, we want to skip this
3962 && xcoff_hash_table (finfo
->info
)->gc
3963 && ((*csectpp
)->flags
& SEC_MARK
) == 0
3964 && *csectpp
!= bfd_abs_section_ptr
)
3967 /* An XCOFF linker always skips C_STAT symbols. */
3969 && isymp
->n_sclass
== C_STAT
)
3972 /* We skip all but the first TOC anchor. */
3974 && isymp
->n_sclass
== C_HIDEXT
3975 && aux
.x_csect
.x_smclas
== XMC_TC0
)
3977 if (finfo
->toc_symindx
!= -1)
3981 bfd_vma tocval
, tocend
;
3983 tocval
= ((*csectpp
)->output_section
->vma
3984 + (*csectpp
)->output_offset
3987 /* We want to find out if tocval is a good value to use
3988 as the TOC anchor--that is, whether we can access all
3989 of the TOC using a 16 bit offset from tocval. This
3990 test assumes that the TOC comes at the end of the
3991 output section, as it does in the default linker
3992 script. If the TOC anchor is too far into the .toc
3993 section, the relocation routine will report
3995 tocend
= ((*csectpp
)->output_section
->vma
3996 + (*csectpp
)->output_section
->_raw_size
);
3997 if (tocval
+ 0x8000 < tocend
)
4001 tocadd
= tocend
- (tocval
+ 0x8000);
4003 isym
.n_value
+= tocadd
;
4006 finfo
->toc_symindx
= output_index
;
4007 xcoff_data (finfo
->output_bfd
)->toc
= tocval
;
4008 xcoff_data (finfo
->output_bfd
)->sntoc
=
4009 (*csectpp
)->output_section
->target_index
;
4014 /* If we are stripping all symbols, we want to skip this one. */
4016 && finfo
->info
->strip
== strip_all
)
4019 /* We can skip resolved external references. */
4021 && isym
.n_sclass
== C_EXT
4023 && (*sym_hash
)->root
.type
!= bfd_link_hash_undefined
)
4026 /* We can skip common symbols if they got defined somewhere
4029 && isym
.n_sclass
== C_EXT
4031 && ((*sym_hash
)->root
.type
!= bfd_link_hash_common
4032 || (*sym_hash
)->root
.u
.c
.p
->section
!= *csectpp
)
4033 && ((*sym_hash
)->root
.type
!= bfd_link_hash_defined
4034 || (*sym_hash
)->root
.u
.def
.section
!= *csectpp
))
4037 /* Skip local symbols if we are discarding them. */
4039 && finfo
->info
->discard
== discard_all
4040 && isym
.n_sclass
!= C_EXT
4041 && (isym
.n_sclass
!= C_HIDEXT
4042 || smtyp
!= XTY_SD
))
4045 /* If we stripping debugging symbols, and this is a debugging
4046 symbol, then skip it. */
4048 && finfo
->info
->strip
== strip_debugger
4049 && isym
.n_scnum
== N_DEBUG
)
4052 /* If some symbols are stripped based on the name, work out the
4053 name and decide whether to skip this symbol. We don't handle
4054 this correctly for symbols whose names are in the .debug
4055 section; to get it right we would need a new bfd_strtab_hash
4056 function to return the string given the index. */
4058 && (finfo
->info
->strip
== strip_some
4059 || finfo
->info
->discard
== discard_l
)
4060 && (debug_index
== NULL
|| *debug_index
== (unsigned long) -1))
4063 char buf
[SYMNMLEN
+ 1];
4065 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, buf
);
4069 if ((finfo
->info
->strip
== strip_some
4070 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false,
4072 || (finfo
->info
->discard
== discard_l
4073 && (isym
.n_sclass
!= C_EXT
4074 && (isym
.n_sclass
!= C_HIDEXT
4075 || smtyp
!= XTY_SD
))
4076 && strncmp (name
, finfo
->info
->lprefix
,
4077 finfo
->info
->lprefix_len
) == 0))
4081 /* We can not skip the first TOC anchor. */
4084 && finfo
->info
->strip
!= strip_all
)
4087 /* We now know whether we are to skip this symbol or not. */
4090 /* Adjust the symbol in order to output it. */
4092 if (isym
._n
._n_n
._n_zeroes
== 0
4093 && isym
._n
._n_n
._n_offset
!= 0)
4095 /* This symbol has a long name. Enter it in the string
4096 table we are building. If *debug_index != -1, the
4097 name has already been entered in the .debug section. */
4098 if (debug_index
!= NULL
&& *debug_index
!= (unsigned long) -1)
4099 isym
._n
._n_n
._n_offset
= *debug_index
;
4105 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
,
4109 indx
= _bfd_stringtab_add (finfo
->strtab
, name
, hash
, copy
);
4110 if (indx
== (bfd_size_type
) -1)
4112 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
4116 if (isym
.n_sclass
!= C_BSTAT
4117 && isym
.n_sclass
!= C_ESTAT
4118 && isym
.n_sclass
!= C_DECL
4119 && isym
.n_scnum
> 0)
4121 isym
.n_scnum
= (*csectpp
)->output_section
->target_index
;
4122 isym
.n_value
+= ((*csectpp
)->output_section
->vma
4123 + (*csectpp
)->output_offset
4127 /* The value of a C_FILE symbol is the symbol index of the
4128 next C_FILE symbol. The value of the last C_FILE symbol
4129 is -1. We try to get this right, below, just before we
4130 write the symbols out, but in the general case we may
4131 have to write the symbol out twice. */
4132 if (isym
.n_sclass
== C_FILE
)
4134 if (finfo
->last_file_index
!= -1
4135 && finfo
->last_file
.n_value
!= (long) output_index
)
4137 /* We must correct the value of the last C_FILE entry. */
4138 finfo
->last_file
.n_value
= output_index
;
4139 if ((bfd_size_type
) finfo
->last_file_index
>= syment_base
)
4141 /* The last C_FILE symbol is in this input file. */
4142 bfd_coff_swap_sym_out (output_bfd
,
4143 (PTR
) &finfo
->last_file
,
4144 (PTR
) (finfo
->outsyms
4145 + ((finfo
->last_file_index
4151 /* We have already written out the last C_FILE
4152 symbol. We need to write it out again. We
4153 borrow *outsym temporarily. */
4154 bfd_coff_swap_sym_out (output_bfd
,
4155 (PTR
) &finfo
->last_file
,
4157 if (bfd_seek (output_bfd
,
4158 (obj_sym_filepos (output_bfd
)
4159 + finfo
->last_file_index
* osymesz
),
4161 || (bfd_write (outsym
, osymesz
, 1, output_bfd
)
4167 finfo
->last_file_index
= output_index
;
4168 finfo
->last_file
= isym
;
4171 /* The value of a C_BINCL or C_EINCL symbol is a file offset
4172 into the line numbers. We update the symbol values when
4173 we handle the line numbers. */
4174 if (isym
.n_sclass
== C_BINCL
4175 || isym
.n_sclass
== C_EINCL
)
4177 isym
.n_value
= finfo
->line_filepos
;
4181 /* Output the symbol. */
4183 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
, (PTR
) outsym
);
4185 *indexp
= output_index
;
4187 if (isym
.n_sclass
== C_EXT
)
4190 struct xcoff_link_hash_entry
*h
;
4192 indx
= ((esym
- (bfd_byte
*) obj_coff_external_syms (input_bfd
))
4194 h
= obj_xcoff_sym_hashes (input_bfd
)[indx
];
4195 BFD_ASSERT (h
!= NULL
);
4196 h
->indx
= output_index
;
4199 /* If this is a symbol in the TOC which we may have merged
4200 (class XMC_TC), remember the symbol index of the TOC
4202 if (isym
.n_sclass
== C_HIDEXT
4203 && aux
.x_csect
.x_smclas
== XMC_TC
4204 && *sym_hash
!= NULL
)
4206 BFD_ASSERT (((*sym_hash
)->flags
& XCOFF_SET_TOC
) == 0);
4207 BFD_ASSERT ((*sym_hash
)->toc_section
!= NULL
);
4208 (*sym_hash
)->u
.toc_indx
= output_index
;
4211 output_index
+= add
;
4212 outsym
+= add
* osymesz
;
4215 esym
+= add
* isymesz
;
4219 if (debug_index
!= NULL
)
4222 for (--add
; add
> 0; --add
)
4226 /* Fix up the aux entries and the C_BSTAT symbols. This must be
4227 done in a separate pass, because we don't know the correct symbol
4228 indices until we have already decided which symbols we are going
4231 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
4232 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
4233 isymp
= finfo
->internal_syms
;
4234 indexp
= finfo
->sym_indices
;
4235 csectpp
= xcoff_data (input_bfd
)->csects
;
4236 outsym
= finfo
->outsyms
;
4237 while (esym
< esym_end
)
4241 add
= 1 + isymp
->n_numaux
;
4244 esym
+= add
* isymesz
;
4249 if (isymp
->n_sclass
== C_BSTAT
)
4251 struct internal_syment isym
;
4254 /* The value of a C_BSTAT symbol is the symbol table
4255 index of the containing csect. */
4256 bfd_coff_swap_sym_in (output_bfd
, (PTR
) outsym
, (PTR
) &isym
);
4257 indx
= isym
.n_value
;
4258 if (indx
< obj_raw_syment_count (input_bfd
))
4262 symindx
= finfo
->sym_indices
[indx
];
4266 isym
.n_value
= symindx
;
4267 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
,
4275 for (i
= 0; i
< isymp
->n_numaux
&& esym
< esym_end
; i
++)
4277 union internal_auxent aux
;
4279 bfd_coff_swap_aux_in (input_bfd
, (PTR
) esym
, isymp
->n_type
,
4280 isymp
->n_sclass
, i
, isymp
->n_numaux
,
4283 if (isymp
->n_sclass
== C_FILE
)
4285 /* This is the file name (or some comment put in by
4286 the compiler). If it is long, we must put it in
4287 the string table. */
4288 if (aux
.x_file
.x_n
.x_zeroes
== 0
4289 && aux
.x_file
.x_n
.x_offset
!= 0)
4291 const char *filename
;
4294 BFD_ASSERT (aux
.x_file
.x_n
.x_offset
4295 >= STRING_SIZE_SIZE
);
4296 if (strings
== NULL
)
4298 strings
= _bfd_coff_read_string_table (input_bfd
);
4299 if (strings
== NULL
)
4302 filename
= strings
+ aux
.x_file
.x_n
.x_offset
;
4303 indx
= _bfd_stringtab_add (finfo
->strtab
, filename
,
4305 if (indx
== (bfd_size_type
) -1)
4307 aux
.x_file
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
4310 else if ((isymp
->n_sclass
== C_EXT
4311 || isymp
->n_sclass
== C_HIDEXT
)
4312 && i
+ 1 == isymp
->n_numaux
)
4314 /* We don't support type checking. I don't know if
4316 aux
.x_csect
.x_parmhash
= 0;
4317 /* I don't think anybody uses these fields, but we'd
4318 better clobber them just in case. */
4319 aux
.x_csect
.x_stab
= 0;
4320 aux
.x_csect
.x_snstab
= 0;
4321 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_LD
)
4325 indx
= aux
.x_csect
.x_scnlen
.l
;
4326 if (indx
< obj_raw_syment_count (input_bfd
))
4330 symindx
= finfo
->sym_indices
[indx
];
4332 aux
.x_sym
.x_tagndx
.l
= 0;
4334 aux
.x_sym
.x_tagndx
.l
= symindx
;
4338 else if (isymp
->n_sclass
!= C_STAT
|| isymp
->n_type
!= T_NULL
)
4342 if (ISFCN (isymp
->n_type
)
4343 || ISTAG (isymp
->n_sclass
)
4344 || isymp
->n_sclass
== C_BLOCK
)
4346 indx
= aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
4348 && indx
< obj_raw_syment_count (input_bfd
))
4350 /* We look forward through the symbol for
4351 the index of the next symbol we are going
4352 to include. I don't know if this is
4354 while (finfo
->sym_indices
[indx
] < 0
4355 && indx
< obj_raw_syment_count (input_bfd
))
4357 if (indx
>= obj_raw_syment_count (input_bfd
))
4358 indx
= output_index
;
4360 indx
= finfo
->sym_indices
[indx
];
4361 aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= indx
;
4365 indx
= aux
.x_sym
.x_tagndx
.l
;
4366 if (indx
> 0 && indx
< obj_raw_syment_count (input_bfd
))
4370 symindx
= finfo
->sym_indices
[indx
];
4372 aux
.x_sym
.x_tagndx
.l
= 0;
4374 aux
.x_sym
.x_tagndx
.l
= symindx
;
4378 /* Copy over the line numbers, unless we are stripping
4379 them. We do this on a symbol by symbol basis in
4380 order to more easily handle garbage collection. */
4381 if ((isymp
->n_sclass
== C_EXT
4382 || isymp
->n_sclass
== C_HIDEXT
)
4384 && isymp
->n_numaux
> 1
4385 && ISFCN (isymp
->n_type
)
4386 && aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
!= 0)
4388 if (finfo
->info
->strip
!= strip_none
4389 && finfo
->info
->strip
!= strip_some
)
4390 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
4393 asection
*enclosing
;
4394 unsigned int enc_count
;
4395 bfd_size_type linoff
;
4396 struct internal_lineno lin
;
4399 enclosing
= xcoff_section_data (abfd
, o
)->enclosing
;
4400 enc_count
= xcoff_section_data (abfd
, o
)->lineno_count
;
4401 if (oline
!= enclosing
)
4403 if (bfd_seek (input_bfd
,
4404 enclosing
->line_filepos
,
4406 || (bfd_read (finfo
->linenos
, linesz
,
4407 enc_count
, input_bfd
)
4408 != linesz
* enc_count
))
4413 linoff
= (aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
4414 - enclosing
->line_filepos
);
4416 bfd_coff_swap_lineno_in (input_bfd
,
4417 (PTR
) (finfo
->linenos
+ linoff
),
4420 || ((bfd_size_type
) lin
.l_addr
.l_symndx
4424 obj_coff_external_syms (input_bfd
)))
4426 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= 0;
4429 bfd_byte
*linpend
, *linp
;
4431 bfd_size_type count
;
4433 lin
.l_addr
.l_symndx
= *indexp
;
4434 bfd_coff_swap_lineno_out (output_bfd
, (PTR
) &lin
,
4435 (PTR
) (finfo
->linenos
4438 linpend
= (finfo
->linenos
4439 + enc_count
* linesz
);
4440 offset
= (o
->output_section
->vma
4443 for (linp
= finfo
->linenos
+ linoff
+ linesz
;
4447 bfd_coff_swap_lineno_in (input_bfd
, (PTR
) linp
,
4449 if (lin
.l_lnno
== 0)
4451 lin
.l_addr
.l_paddr
+= offset
;
4452 bfd_coff_swap_lineno_out (output_bfd
,
4457 count
= (linp
- (finfo
->linenos
+ linoff
)) / linesz
;
4459 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
4460 (o
->output_section
->line_filepos
4461 + o
->output_section
->lineno_count
* linesz
);
4463 if (bfd_seek (output_bfd
,
4464 aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
,
4466 || (bfd_write (finfo
->linenos
+ linoff
,
4467 linesz
, count
, output_bfd
)
4471 o
->output_section
->lineno_count
+= count
;
4475 struct internal_syment
*iisp
, *iispend
;
4480 /* Update any C_BINCL or C_EINCL symbols
4481 that refer to a line number in the
4482 range we just output. */
4483 iisp
= finfo
->internal_syms
;
4485 + obj_raw_syment_count (input_bfd
));
4486 iindp
= finfo
->sym_indices
;
4487 oos
= finfo
->outsyms
;
4488 while (iisp
< iispend
)
4491 && (iisp
->n_sclass
== C_BINCL
4492 || iisp
->n_sclass
== C_EINCL
)
4493 && ((bfd_size_type
) iisp
->n_value
4494 >= enclosing
->line_filepos
+ linoff
)
4495 && ((bfd_size_type
) iisp
->n_value
4496 < (enclosing
->line_filepos
4497 + enc_count
* linesz
)))
4499 struct internal_syment iis
;
4501 bfd_coff_swap_sym_in (output_bfd
,
4506 - enclosing
->line_filepos
4508 + aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
);
4509 bfd_coff_swap_sym_out (output_bfd
,
4515 iiadd
= 1 + iisp
->n_numaux
;
4517 oos
+= iiadd
* osymesz
;
4526 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &aux
, isymp
->n_type
,
4527 isymp
->n_sclass
, i
, isymp
->n_numaux
,
4539 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
4540 symbol will be the first symbol in the next input file. In the
4541 normal case, this will save us from writing out the C_FILE symbol
4543 if (finfo
->last_file_index
!= -1
4544 && (bfd_size_type
) finfo
->last_file_index
>= syment_base
)
4546 finfo
->last_file
.n_value
= output_index
;
4547 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &finfo
->last_file
,
4548 (PTR
) (finfo
->outsyms
4549 + ((finfo
->last_file_index
- syment_base
)
4553 /* Write the modified symbols to the output file. */
4554 if (outsym
> finfo
->outsyms
)
4556 if (bfd_seek (output_bfd
,
4557 obj_sym_filepos (output_bfd
) + syment_base
* osymesz
,
4559 || (bfd_write (finfo
->outsyms
, outsym
- finfo
->outsyms
, 1,
4561 != (bfd_size_type
) (outsym
- finfo
->outsyms
)))
4564 BFD_ASSERT ((obj_raw_syment_count (output_bfd
)
4565 + (outsym
- finfo
->outsyms
) / osymesz
)
4568 obj_raw_syment_count (output_bfd
) = output_index
;
4571 /* Don't let the linker relocation routines discard the symbols. */
4572 keep_syms
= obj_coff_keep_syms (input_bfd
);
4573 obj_coff_keep_syms (input_bfd
) = true;
4575 /* Relocate the contents of each section. */
4576 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4580 if (! o
->linker_mark
)
4582 /* This section was omitted from the link. */
4586 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
4587 || o
->_raw_size
== 0
4588 || (o
->flags
& SEC_IN_MEMORY
) != 0)
4591 /* We have set filepos correctly for the sections we created to
4592 represent csects, so bfd_get_section_contents should work. */
4593 if (coff_section_data (input_bfd
, o
) != NULL
4594 && coff_section_data (input_bfd
, o
)->contents
!= NULL
)
4595 contents
= coff_section_data (input_bfd
, o
)->contents
;
4598 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
4599 (file_ptr
) 0, o
->_raw_size
))
4601 contents
= finfo
->contents
;
4604 if ((o
->flags
& SEC_RELOC
) != 0)
4607 struct internal_reloc
*internal_relocs
;
4608 struct internal_reloc
*irel
;
4610 struct internal_reloc
*irelend
;
4611 struct xcoff_link_hash_entry
**rel_hash
;
4614 /* Read in the relocs. */
4615 target_index
= o
->output_section
->target_index
;
4616 internal_relocs
= (xcoff_read_internal_relocs
4617 (input_bfd
, o
, false, finfo
->external_relocs
,
4619 (finfo
->section_info
[target_index
].relocs
4620 + o
->output_section
->reloc_count
)));
4621 if (internal_relocs
== NULL
)
4624 /* Call processor specific code to relocate the section
4626 if (! bfd_coff_relocate_section (output_bfd
, finfo
->info
,
4630 finfo
->internal_syms
,
4631 xcoff_data (input_bfd
)->csects
))
4634 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
4635 irel
= internal_relocs
;
4636 irelend
= irel
+ o
->reloc_count
;
4637 rel_hash
= (finfo
->section_info
[target_index
].rel_hashes
4638 + o
->output_section
->reloc_count
);
4639 for (; irel
< irelend
; irel
++, rel_hash
++)
4641 struct xcoff_link_hash_entry
*h
= NULL
;
4642 struct internal_ldrel ldrel
;
4646 /* Adjust the reloc address and symbol index. */
4648 irel
->r_vaddr
+= offset
;
4650 r_symndx
= irel
->r_symndx
;
4654 h
= obj_xcoff_sym_hashes (input_bfd
)[r_symndx
];
4656 && (irel
->r_type
== R_TOC
4657 || irel
->r_type
== R_GL
4658 || irel
->r_type
== R_TCL
4659 || irel
->r_type
== R_TRL
4660 || irel
->r_type
== R_TRLA
))
4662 /* This is a TOC relative reloc with a symbol
4663 attached. The symbol should be the one which
4664 this reloc is for. We want to make this
4665 reloc against the TOC address of the symbol,
4666 not the symbol itself. */
4667 BFD_ASSERT (h
->toc_section
!= NULL
);
4668 BFD_ASSERT ((h
->flags
& XCOFF_SET_TOC
) == 0);
4669 if (h
->u
.toc_indx
!= -1)
4670 irel
->r_symndx
= h
->u
.toc_indx
;
4673 struct xcoff_toc_rel_hash
*n
;
4674 struct xcoff_link_section_info
*si
;
4676 n
= ((struct xcoff_toc_rel_hash
*)
4677 bfd_alloc (finfo
->output_bfd
,
4678 sizeof (struct xcoff_toc_rel_hash
)));
4681 si
= finfo
->section_info
+ target_index
;
4682 n
->next
= si
->toc_rel_hashes
;
4685 si
->toc_rel_hashes
= n
;
4690 /* This is a global symbol. */
4692 irel
->r_symndx
= h
->indx
;
4695 /* This symbol is being written at the end
4696 of the file, and we do not yet know the
4697 symbol index. We save the pointer to the
4698 hash table entry in the rel_hash list.
4699 We set the indx field to -2 to indicate
4700 that this symbol must not be stripped. */
4709 indx
= finfo
->sym_indices
[r_symndx
];
4713 struct internal_syment
*is
;
4715 /* Relocations against a TC0 TOC anchor are
4716 automatically transformed to be against
4717 the TOC anchor in the output file. */
4718 is
= finfo
->internal_syms
+ r_symndx
;
4719 if (is
->n_sclass
== C_HIDEXT
4720 && is
->n_numaux
> 0)
4723 union internal_auxent aux
;
4727 obj_coff_external_syms (input_bfd
))
4728 + ((r_symndx
+ is
->n_numaux
)
4730 bfd_coff_swap_aux_in (input_bfd
, auxptr
,
4731 is
->n_type
, is
->n_sclass
,
4735 if (SMTYP_SMTYP (aux
.x_csect
.x_smtyp
) == XTY_SD
4736 && aux
.x_csect
.x_smclas
== XMC_TC0
)
4737 indx
= finfo
->toc_symindx
;
4742 irel
->r_symndx
= indx
;
4745 struct internal_syment
*is
;
4747 char buf
[SYMNMLEN
+ 1];
4749 /* This reloc is against a symbol we are
4750 stripping. It would be possible to handle
4751 this case, but I don't think it's worth it. */
4752 is
= finfo
->internal_syms
+ r_symndx
;
4754 name
= (_bfd_coff_internal_syment_name
4755 (input_bfd
, is
, buf
));
4759 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
4760 (finfo
->info
, name
, input_bfd
, o
,
4767 switch (irel
->r_type
)
4771 || h
->root
.type
== bfd_link_hash_defined
4772 || h
->root
.type
== bfd_link_hash_defweak
4773 || h
->root
.type
== bfd_link_hash_common
)
4780 /* This reloc needs to be copied into the .loader
4782 ldrel
.l_vaddr
= irel
->r_vaddr
;
4784 ldrel
.l_symndx
= -1;
4786 || (h
->root
.type
== bfd_link_hash_defined
4787 || h
->root
.type
== bfd_link_hash_defweak
4788 || h
->root
.type
== bfd_link_hash_common
))
4793 sec
= xcoff_data (input_bfd
)->csects
[r_symndx
];
4794 else if (h
->root
.type
== bfd_link_hash_common
)
4795 sec
= h
->root
.u
.c
.p
->section
;
4797 sec
= h
->root
.u
.def
.section
;
4798 sec
= sec
->output_section
;
4800 if (strcmp (sec
->name
, ".text") == 0)
4802 else if (strcmp (sec
->name
, ".data") == 0)
4804 else if (strcmp (sec
->name
, ".bss") == 0)
4808 (*_bfd_error_handler
)
4809 ("%s: loader reloc in unrecognized section `%s'",
4810 bfd_get_filename (input_bfd
),
4812 bfd_set_error (bfd_error_nonrepresentable_section
);
4820 (*_bfd_error_handler
)
4821 ("%s: `%s' in loader reloc but not loader sym",
4822 bfd_get_filename (input_bfd
),
4823 h
->root
.root
.string
);
4824 bfd_set_error (bfd_error_bad_value
);
4827 ldrel
.l_symndx
= h
->ldindx
;
4829 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
4830 ldrel
.l_rsecnm
= o
->output_section
->target_index
;
4831 if (xcoff_hash_table (finfo
->info
)->textro
4832 && strcmp (o
->output_section
->name
, ".text") == 0)
4834 (*_bfd_error_handler
)
4835 ("%s: loader reloc in read-only section %s",
4836 bfd_get_filename (input_bfd
),
4837 bfd_get_section_name (finfo
->output_bfd
,
4838 o
->output_section
));
4839 bfd_set_error (bfd_error_invalid_operation
);
4842 xcoff_swap_ldrel_out (output_bfd
, &ldrel
,
4844 BFD_ASSERT (sizeof (struct external_ldrel
) == LDRELSZ
);
4853 /* We should never need a .loader reloc for a TOC
4859 o
->output_section
->reloc_count
+= o
->reloc_count
;
4862 /* Write out the modified section contents. */
4863 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
4864 contents
, o
->output_offset
,
4865 (o
->_cooked_size
!= 0
4871 obj_coff_keep_syms (input_bfd
) = keep_syms
;
4873 if (! finfo
->info
->keep_memory
)
4875 if (! _bfd_coff_free_symbols (input_bfd
))
4885 /* Write out a non-XCOFF global symbol. */
4888 xcoff_write_global_symbol (h
, p
)
4889 struct xcoff_link_hash_entry
*h
;
4892 struct xcoff_final_link_info
*finfo
= (struct xcoff_final_link_info
*) p
;
4895 struct internal_syment isym
;
4896 union internal_auxent aux
;
4898 output_bfd
= finfo
->output_bfd
;
4900 /* If this symbol was garbage collected, just skip it. */
4901 if (xcoff_hash_table (finfo
->info
)->gc
4902 && (h
->flags
& XCOFF_MARK
) == 0)
4905 /* If we need a .loader section entry, write it out. */
4906 if (h
->ldsym
!= NULL
)
4908 struct internal_ldsym
*ldsym
;
4913 if (h
->root
.type
== bfd_link_hash_undefined
4914 || h
->root
.type
== bfd_link_hash_undefweak
)
4917 ldsym
->l_scnum
= N_UNDEF
;
4918 ldsym
->l_smtype
= XTY_ER
;
4919 impbfd
= h
->root
.u
.undef
.abfd
;
4921 else if (h
->root
.type
== bfd_link_hash_defined
4922 || h
->root
.type
== bfd_link_hash_defweak
)
4926 sec
= h
->root
.u
.def
.section
;
4927 ldsym
->l_value
= (sec
->output_section
->vma
4928 + sec
->output_offset
4929 + h
->root
.u
.def
.value
);
4930 ldsym
->l_scnum
= sec
->output_section
->target_index
;
4931 ldsym
->l_smtype
= XTY_SD
;
4932 impbfd
= sec
->owner
;
4937 if (((h
->flags
& XCOFF_DEF_REGULAR
) == 0
4938 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4939 || (h
->flags
& XCOFF_IMPORT
) != 0)
4940 ldsym
->l_smtype
|= L_IMPORT
;
4941 if (((h
->flags
& XCOFF_DEF_REGULAR
) != 0
4942 && (h
->flags
& XCOFF_DEF_DYNAMIC
) != 0)
4943 || (h
->flags
& XCOFF_EXPORT
) != 0)
4944 ldsym
->l_smtype
|= L_EXPORT
;
4945 if ((h
->flags
& XCOFF_ENTRY
) != 0)
4946 ldsym
->l_smtype
|= L_ENTRY
;
4948 ldsym
->l_smclas
= h
->smclas
;
4950 if (ldsym
->l_ifile
== (bfd_size_type
) -1)
4952 else if (ldsym
->l_ifile
== 0)
4954 if ((ldsym
->l_smtype
& L_IMPORT
) == 0)
4956 else if (impbfd
== NULL
)
4960 BFD_ASSERT (impbfd
->xvec
== output_bfd
->xvec
);
4961 ldsym
->l_ifile
= xcoff_data (impbfd
)->import_file_id
;
4967 BFD_ASSERT (h
->ldindx
>= 0);
4968 BFD_ASSERT (LDSYMSZ
== sizeof (struct external_ldsym
));
4969 xcoff_swap_ldsym_out (output_bfd
, ldsym
, finfo
->ldsym
+ h
->ldindx
- 3);
4973 /* If this symbol needs global linkage code, write it out. */
4974 if (h
->root
.type
== bfd_link_hash_defined
4975 && (h
->root
.u
.def
.section
4976 == xcoff_hash_table (finfo
->info
)->linkage_section
))
4982 p
= h
->root
.u
.def
.section
->contents
+ h
->root
.u
.def
.value
;
4984 /* The first instruction in the global linkage code loads a
4985 specific TOC element. */
4986 tocoff
= (h
->descriptor
->toc_section
->output_section
->vma
4987 + h
->descriptor
->toc_section
->output_offset
4988 - xcoff_data (output_bfd
)->toc
);
4989 if ((h
->descriptor
->flags
& XCOFF_SET_TOC
) != 0)
4990 tocoff
+= h
->descriptor
->u
.toc_offset
;
4991 bfd_put_32 (output_bfd
, XCOFF_GLINK_FIRST
| (tocoff
& 0xffff), p
);
4993 i
< sizeof xcoff_glink_code
/ sizeof xcoff_glink_code
[0];
4995 bfd_put_32 (output_bfd
, xcoff_glink_code
[i
], p
);
4998 /* If we created a TOC entry for this symbol, write out the required
5000 if ((h
->flags
& XCOFF_SET_TOC
) != 0)
5005 struct internal_reloc
*irel
;
5006 struct internal_ldrel ldrel
;
5008 tocsec
= h
->toc_section
;
5009 osec
= tocsec
->output_section
;
5010 oindx
= osec
->target_index
;
5011 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
5012 irel
->r_vaddr
= (osec
->vma
5013 + tocsec
->output_offset
5016 irel
->r_symndx
= h
->indx
;
5020 irel
->r_symndx
= obj_raw_syment_count (output_bfd
);
5022 irel
->r_type
= R_POS
;
5024 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5025 ++osec
->reloc_count
;
5027 BFD_ASSERT (h
->ldindx
>= 0);
5028 ldrel
.l_vaddr
= irel
->r_vaddr
;
5029 ldrel
.l_symndx
= h
->ldindx
;
5030 ldrel
.l_rtype
= (31 << 8) | R_POS
;
5031 ldrel
.l_rsecnm
= oindx
;
5032 xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5036 /* If this symbol is a specially defined function descriptor, write
5037 it out. The first word is the address of the function code
5038 itself, the second word is the address of the TOC, and the third
5040 if ((h
->flags
& XCOFF_DESCRIPTOR
) != 0
5041 && h
->root
.type
== bfd_link_hash_defined
5042 && (h
->root
.u
.def
.section
5043 == xcoff_hash_table (finfo
->info
)->descriptor_section
))
5049 struct xcoff_link_hash_entry
*hentry
;
5051 struct internal_reloc
*irel
;
5052 struct internal_ldrel ldrel
;
5055 sec
= h
->root
.u
.def
.section
;
5056 osec
= sec
->output_section
;
5057 oindx
= osec
->target_index
;
5058 p
= sec
->contents
+ h
->root
.u
.def
.value
;
5060 hentry
= h
->descriptor
;
5061 BFD_ASSERT (hentry
!= NULL
5062 && (hentry
->root
.type
== bfd_link_hash_defined
5063 || hentry
->root
.type
== bfd_link_hash_defweak
));
5064 esec
= hentry
->root
.u
.def
.section
;
5065 bfd_put_32 (output_bfd
,
5066 (esec
->output_section
->vma
5067 + esec
->output_offset
5068 + hentry
->root
.u
.def
.value
),
5071 irel
= finfo
->section_info
[oindx
].relocs
+ osec
->reloc_count
;
5072 irel
->r_vaddr
= (osec
->vma
5073 + sec
->output_offset
5074 + h
->root
.u
.def
.value
);
5075 irel
->r_symndx
= esec
->output_section
->target_index
;
5076 irel
->r_type
= R_POS
;
5078 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5079 ++osec
->reloc_count
;
5081 ldrel
.l_vaddr
= irel
->r_vaddr
;
5082 if (strcmp (esec
->output_section
->name
, ".text") == 0)
5084 else if (strcmp (esec
->output_section
->name
, ".data") == 0)
5086 else if (strcmp (esec
->output_section
->name
, ".bss") == 0)
5090 (*_bfd_error_handler
)
5091 ("%s: loader reloc in unrecognized section `%s'",
5092 bfd_get_filename (output_bfd
),
5093 esec
->output_section
->name
);
5094 bfd_set_error (bfd_error_nonrepresentable_section
);
5097 ldrel
.l_rtype
= (31 << 8) | R_POS
;
5098 ldrel
.l_rsecnm
= oindx
;
5099 xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5102 bfd_put_32 (output_bfd
, xcoff_data (output_bfd
)->toc
, p
+ 4);
5104 tsec
= coff_section_from_bfd_index (output_bfd
,
5105 xcoff_data (output_bfd
)->sntoc
);
5108 irel
->r_vaddr
= (osec
->vma
5109 + sec
->output_offset
5110 + h
->root
.u
.def
.value
5112 irel
->r_symndx
= tsec
->output_section
->target_index
;
5113 irel
->r_type
= R_POS
;
5115 finfo
->section_info
[oindx
].rel_hashes
[osec
->reloc_count
] = NULL
;
5116 ++osec
->reloc_count
;
5118 ldrel
.l_vaddr
= irel
->r_vaddr
;
5119 if (strcmp (tsec
->output_section
->name
, ".text") == 0)
5121 else if (strcmp (tsec
->output_section
->name
, ".data") == 0)
5123 else if (strcmp (tsec
->output_section
->name
, ".bss") == 0)
5127 (*_bfd_error_handler
)
5128 ("%s: loader reloc in unrecognized section `%s'",
5129 bfd_get_filename (output_bfd
),
5130 tsec
->output_section
->name
);
5131 bfd_set_error (bfd_error_nonrepresentable_section
);
5134 ldrel
.l_rtype
= (31 << 8) | R_POS
;
5135 ldrel
.l_rsecnm
= oindx
;
5136 xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5144 && (finfo
->info
->strip
== strip_all
5145 || (finfo
->info
->strip
== strip_some
5146 && (bfd_hash_lookup (finfo
->info
->keep_hash
,
5147 h
->root
.root
.string
, false, false)
5152 && (h
->flags
& (XCOFF_REF_REGULAR
| XCOFF_DEF_REGULAR
)) == 0)
5155 outsym
= finfo
->outsyms
;
5157 memset (&aux
, 0, sizeof aux
);
5159 h
->indx
= obj_raw_syment_count (output_bfd
);
5161 if (strlen (h
->root
.root
.string
) <= SYMNMLEN
)
5162 strncpy (isym
._n
._n_name
, h
->root
.root
.string
, SYMNMLEN
);
5169 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
5171 indx
= _bfd_stringtab_add (finfo
->strtab
, h
->root
.root
.string
, hash
,
5173 if (indx
== (bfd_size_type
) -1)
5175 isym
._n
._n_n
._n_zeroes
= 0;
5176 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
5179 if (h
->root
.type
== bfd_link_hash_undefined
5180 || h
->root
.type
== bfd_link_hash_undefweak
)
5183 isym
.n_scnum
= N_UNDEF
;
5184 isym
.n_sclass
= C_EXT
;
5185 aux
.x_csect
.x_smtyp
= XTY_ER
;
5187 else if (h
->root
.type
== bfd_link_hash_defined
5188 || h
->root
.type
== bfd_link_hash_defweak
)
5190 struct xcoff_link_size_list
*l
;
5192 isym
.n_value
= (h
->root
.u
.def
.section
->output_section
->vma
5193 + h
->root
.u
.def
.section
->output_offset
5194 + h
->root
.u
.def
.value
);
5195 isym
.n_scnum
= h
->root
.u
.def
.section
->output_section
->target_index
;
5196 isym
.n_sclass
= C_HIDEXT
;
5197 aux
.x_csect
.x_smtyp
= XTY_SD
;
5199 if ((h
->flags
& XCOFF_HAS_SIZE
) != 0)
5201 for (l
= xcoff_hash_table (finfo
->info
)->size_list
;
5207 aux
.x_csect
.x_scnlen
.l
= l
->size
;
5213 else if (h
->root
.type
== bfd_link_hash_common
)
5215 isym
.n_value
= (h
->root
.u
.c
.p
->section
->output_section
->vma
5216 + h
->root
.u
.c
.p
->section
->output_offset
);
5217 isym
.n_scnum
= h
->root
.u
.c
.p
->section
->output_section
->target_index
;
5218 isym
.n_sclass
= C_EXT
;
5219 aux
.x_csect
.x_smtyp
= XTY_CM
;
5220 aux
.x_csect
.x_scnlen
.l
= h
->root
.u
.c
.size
;
5225 isym
.n_type
= T_NULL
;
5228 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
, (PTR
) outsym
);
5229 outsym
+= bfd_coff_symesz (output_bfd
);
5231 aux
.x_csect
.x_smclas
= h
->smclas
;
5233 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &aux
, T_NULL
, isym
.n_sclass
, 0, 1,
5235 outsym
+= bfd_coff_auxesz (output_bfd
);
5237 if (h
->root
.type
== bfd_link_hash_defined
5238 || h
->root
.type
== bfd_link_hash_defweak
)
5240 /* We just output an SD symbol. Now output an LD symbol. */
5244 isym
.n_sclass
= C_EXT
;
5245 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
, (PTR
) outsym
);
5246 outsym
+= bfd_coff_symesz (output_bfd
);
5248 aux
.x_csect
.x_smtyp
= XTY_LD
;
5249 aux
.x_csect
.x_scnlen
.l
= obj_raw_syment_count (output_bfd
);
5251 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &aux
, T_NULL
, C_EXT
, 0, 1,
5253 outsym
+= bfd_coff_auxesz (output_bfd
);
5256 if (bfd_seek (output_bfd
,
5257 (obj_sym_filepos (output_bfd
)
5258 + (obj_raw_syment_count (output_bfd
)
5259 * bfd_coff_symesz (output_bfd
))),
5261 || (bfd_write (finfo
->outsyms
, outsym
- finfo
->outsyms
, 1, output_bfd
)
5262 != (bfd_size_type
) (outsym
- finfo
->outsyms
)))
5264 obj_raw_syment_count (output_bfd
) +=
5265 (outsym
- finfo
->outsyms
) / bfd_coff_symesz (output_bfd
);
5270 /* Handle a link order which is supposed to generate a reloc. */
5273 xcoff_reloc_link_order (output_bfd
, finfo
, output_section
, link_order
)
5275 struct xcoff_final_link_info
*finfo
;
5276 asection
*output_section
;
5277 struct bfd_link_order
*link_order
;
5279 reloc_howto_type
*howto
;
5280 struct xcoff_link_hash_entry
*h
;
5284 struct internal_reloc
*irel
;
5285 struct xcoff_link_hash_entry
**rel_hash_ptr
;
5286 struct internal_ldrel ldrel
;
5288 if (link_order
->type
== bfd_section_reloc_link_order
)
5290 /* We need to somehow locate a symbol in the right section. The
5291 symbol must either have a value of zero, or we must adjust
5292 the addend by the value of the symbol. FIXME: Write this
5293 when we need it. The old linker couldn't handle this anyhow. */
5297 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
5300 bfd_set_error (bfd_error_bad_value
);
5304 h
= ((struct xcoff_link_hash_entry
*)
5305 bfd_wrapped_link_hash_lookup (output_bfd
, finfo
->info
,
5306 link_order
->u
.reloc
.p
->u
.name
,
5307 false, false, true));
5310 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
5311 (finfo
->info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
5312 (asection
*) NULL
, (bfd_vma
) 0)))
5317 if (h
->root
.type
== bfd_link_hash_common
)
5319 hsec
= h
->root
.u
.c
.p
->section
;
5322 else if (h
->root
.type
== bfd_link_hash_defined
5323 || h
->root
.type
== bfd_link_hash_defweak
)
5325 hsec
= h
->root
.u
.def
.section
;
5326 hval
= h
->root
.u
.def
.value
;
5334 addend
= link_order
->u
.reloc
.p
->addend
;
5336 addend
+= (hsec
->output_section
->vma
5337 + hsec
->output_offset
5344 bfd_reloc_status_type rstat
;
5347 size
= bfd_get_reloc_size (howto
);
5348 buf
= (bfd_byte
*) bfd_zmalloc (size
);
5352 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
5358 case bfd_reloc_outofrange
:
5360 case bfd_reloc_overflow
:
5361 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
5362 (finfo
->info
, link_order
->u
.reloc
.p
->u
.name
,
5363 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
5371 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
5372 (file_ptr
) link_order
->offset
, size
);
5378 /* Store the reloc information in the right place. It will get
5379 swapped and written out at the end of the final_link routine. */
5381 irel
= (finfo
->section_info
[output_section
->target_index
].relocs
5382 + output_section
->reloc_count
);
5383 rel_hash_ptr
= (finfo
->section_info
[output_section
->target_index
].rel_hashes
5384 + output_section
->reloc_count
);
5386 memset (irel
, 0, sizeof (struct internal_reloc
));
5387 *rel_hash_ptr
= NULL
;
5389 irel
->r_vaddr
= output_section
->vma
+ link_order
->offset
;
5392 irel
->r_symndx
= h
->indx
;
5395 /* Set the index to -2 to force this symbol to get written out. */
5401 irel
->r_type
= howto
->type
;
5402 irel
->r_size
= howto
->bitsize
- 1;
5403 if (howto
->complain_on_overflow
== complain_overflow_signed
)
5404 irel
->r_size
|= 0x80;
5406 ++output_section
->reloc_count
;
5408 /* Now output the reloc to the .loader section. */
5410 ldrel
.l_vaddr
= irel
->r_vaddr
;
5414 const char *secname
;
5416 secname
= hsec
->output_section
->name
;
5418 if (strcmp (secname
, ".text") == 0)
5420 else if (strcmp (secname
, ".data") == 0)
5422 else if (strcmp (secname
, ".bss") == 0)
5426 (*_bfd_error_handler
)
5427 ("%s: loader reloc in unrecognized section `%s'",
5428 bfd_get_filename (output_bfd
), secname
);
5429 bfd_set_error (bfd_error_nonrepresentable_section
);
5437 (*_bfd_error_handler
)
5438 ("%s: `%s' in loader reloc but not loader sym",
5439 bfd_get_filename (output_bfd
),
5440 h
->root
.root
.string
);
5441 bfd_set_error (bfd_error_bad_value
);
5444 ldrel
.l_symndx
= h
->ldindx
;
5447 ldrel
.l_rtype
= (irel
->r_size
<< 8) | irel
->r_type
;
5448 ldrel
.l_rsecnm
= output_section
->target_index
;
5449 xcoff_swap_ldrel_out (output_bfd
, &ldrel
, finfo
->ldrel
);
5455 /* Sort relocs by VMA. This is called via qsort. */
5458 xcoff_sort_relocs (p1
, p2
)
5462 const struct internal_reloc
*r1
= (const struct internal_reloc
*) p1
;
5463 const struct internal_reloc
*r2
= (const struct internal_reloc
*) p2
;
5465 if (r1
->r_vaddr
> r2
->r_vaddr
)
5467 else if (r1
->r_vaddr
< r2
->r_vaddr
)
5473 /* This is the relocation function for the RS/6000/POWER/PowerPC.
5474 This is currently the only processor which uses XCOFF; I hope that
5475 will never change. */
5478 _bfd_ppc_xcoff_relocate_section (output_bfd
, info
, input_bfd
,
5479 input_section
, contents
, relocs
, syms
,
5482 struct bfd_link_info
*info
;
5484 asection
*input_section
;
5486 struct internal_reloc
*relocs
;
5487 struct internal_syment
*syms
;
5488 asection
**sections
;
5490 struct internal_reloc
*rel
;
5491 struct internal_reloc
*relend
;
5494 relend
= rel
+ input_section
->reloc_count
;
5495 for (; rel
< relend
; rel
++)
5498 struct xcoff_link_hash_entry
*h
;
5499 struct internal_syment
*sym
;
5502 struct reloc_howto_struct howto
;
5503 bfd_reloc_status_type rstat
;
5505 /* Relocation type R_REF is a special relocation type which is
5506 merely used to prevent garbage collection from occurring for
5507 the csect including the symbol which it references. */
5508 if (rel
->r_type
== R_REF
)
5511 symndx
= rel
->r_symndx
;
5521 h
= obj_xcoff_sym_hashes (input_bfd
)[symndx
];
5522 sym
= syms
+ symndx
;
5523 addend
= - sym
->n_value
;
5526 /* We build the howto information on the fly. */
5528 howto
.type
= rel
->r_type
;
5529 howto
.rightshift
= 0;
5531 howto
.bitsize
= (rel
->r_size
& 0x1f) + 1;
5532 howto
.pc_relative
= false;
5534 if ((rel
->r_size
& 0x80) != 0)
5535 howto
.complain_on_overflow
= complain_overflow_signed
;
5537 howto
.complain_on_overflow
= complain_overflow_bitfield
;
5538 howto
.special_function
= NULL
;
5539 howto
.name
= "internal";
5540 howto
.partial_inplace
= true;
5541 if (howto
.bitsize
== 32)
5542 howto
.src_mask
= howto
.dst_mask
= 0xffffffff;
5545 howto
.src_mask
= howto
.dst_mask
= (1 << howto
.bitsize
) - 1;
5546 if (howto
.bitsize
== 16)
5549 howto
.pcrel_offset
= false;
5559 sec
= bfd_abs_section_ptr
;
5564 sec
= sections
[symndx
];
5565 /* Hack to make sure we use the right TOC anchor value
5566 if this reloc is against the TOC anchor. */
5567 if (sec
->name
[3] == '0'
5568 && strcmp (sec
->name
, ".tc0") == 0)
5569 val
= xcoff_data (output_bfd
)->toc
;
5571 val
= (sec
->output_section
->vma
5572 + sec
->output_offset
5579 if (h
->root
.type
== bfd_link_hash_defined
5580 || h
->root
.type
== bfd_link_hash_defweak
)
5584 sec
= h
->root
.u
.def
.section
;
5585 val
= (h
->root
.u
.def
.value
5586 + sec
->output_section
->vma
5587 + sec
->output_offset
);
5589 else if (h
->root
.type
== bfd_link_hash_common
)
5593 sec
= h
->root
.u
.c
.p
->section
;
5594 val
= (sec
->output_section
->vma
5595 + sec
->output_offset
);
5597 else if ((h
->flags
& XCOFF_DEF_DYNAMIC
) != 0
5598 || (h
->flags
& XCOFF_IMPORT
) != 0)
5600 /* Every symbol in a shared object is defined somewhere. */
5603 else if (! info
->relocateable
5606 if (! ((*info
->callbacks
->undefined_symbol
)
5607 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
5608 rel
->r_vaddr
- input_section
->vma
)))
5613 /* I took the relocation type definitions from two documents:
5614 the PowerPC AIX Version 4 Application Binary Interface, First
5615 Edition (April 1992), and the PowerOpen ABI, Big-Endian
5616 32-Bit Hardware Implementation (June 30, 1994). Differences
5617 between the documents are noted below. */
5619 switch (rel
->r_type
)
5624 /* These relocs are defined by the PowerPC ABI to be
5625 relative branches which use half of the difference
5626 between the symbol and the program counter. I can't
5627 quite figure out when this is useful. These relocs are
5628 not defined by the PowerOpen ABI. */
5630 (*_bfd_error_handler
)
5631 ("%s: unsupported relocation type 0x%02x",
5632 bfd_get_filename (input_bfd
), (unsigned int) rel
->r_type
);
5633 bfd_set_error (bfd_error_bad_value
);
5636 /* Simple positive relocation. */
5639 /* Simple negative relocation. */
5643 /* Simple PC relative relocation. */
5644 howto
.pc_relative
= true;
5647 /* TOC relative relocation. The value in the instruction in
5648 the input file is the offset from the input file TOC to
5649 the desired location. We want the offset from the final
5650 TOC to the desired location. We have:
5655 so we must change insn by on - in.
5658 /* Global linkage relocation. The value of this relocation
5659 is the address of the entry in the TOC section. */
5661 /* Local object TOC address. I can't figure out the
5662 difference between this and case R_GL. */
5664 /* TOC relative relocation. A TOC relative load instruction
5665 which may be changed to a load address instruction.
5666 FIXME: We don't currently implement this optimization. */
5668 /* TOC relative relocation. This is a TOC relative load
5669 address instruction which may be changed to a load
5670 instruction. FIXME: I don't know if this is the correct
5672 if (h
!= NULL
&& h
->toc_section
== NULL
)
5674 (*_bfd_error_handler
)
5675 ("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry",
5676 bfd_get_filename (input_bfd
), rel
->r_vaddr
,
5677 h
->root
.root
.string
);
5678 bfd_set_error (bfd_error_bad_value
);
5683 BFD_ASSERT ((h
->flags
& XCOFF_SET_TOC
) == 0);
5684 val
= (h
->toc_section
->output_section
->vma
5685 + h
->toc_section
->output_offset
);
5687 val
= ((val
- xcoff_data (output_bfd
)->toc
)
5688 - (sym
->n_value
- xcoff_data (input_bfd
)->toc
));
5692 /* Absolute branch. We don't want to mess with the lower
5693 two bits of the instruction. */
5695 /* The PowerPC ABI defines this as an absolute call which
5696 may be modified to become a relative call. The PowerOpen
5697 ABI does not define this relocation type. */
5699 /* Absolute branch which may be modified to become a
5702 /* The PowerPC ABI defines this as an absolute branch to a
5703 fixed address which may be modified to an absolute branch
5704 to a symbol. The PowerOpen ABI does not define this
5707 /* The PowerPC ABI defines this as an absolute branch to a
5708 fixed address which may be modified to a relative branch.
5709 The PowerOpen ABI does not define this relocation type. */
5710 howto
.src_mask
&= ~3;
5711 howto
.dst_mask
= howto
.src_mask
;
5714 /* Relative branch. We don't want to mess with the lower
5715 two bits of the instruction. */
5717 /* The PowerPC ABI defines this as a relative call which may
5718 be modified to become an absolute call. The PowerOpen
5719 ABI does not define this relocation type. */
5721 /* A relative branch which may be modified to become an
5722 absolute branch. FIXME: We don't implement this,
5723 although we should for symbols of storage mapping class
5725 howto
.pc_relative
= true;
5726 howto
.src_mask
&= ~3;
5727 howto
.dst_mask
= howto
.src_mask
;
5730 /* The PowerPC AIX ABI describes this as a load which may be
5731 changed to a load address. The PowerOpen ABI says this
5732 is the same as case R_POS. */
5735 /* The PowerPC AIX ABI describes this as a load address
5736 which may be changed to a load. The PowerOpen ABI says
5737 this is the same as R_POS. */
5741 /* If we see an R_BR or R_RBR reloc which is jumping to global
5742 linkage code, and it is followed by an appropriate cror nop
5743 instruction, we replace the cror with lwz r2,20(r1). This
5744 restores the TOC after the glink code. Contrariwise, if the
5745 call is followed by a lwz r2,20(r1), but the call is not
5746 going to global linkage code, we can replace the load with a
5748 if ((rel
->r_type
== R_BR
|| rel
->r_type
== R_RBR
)
5750 && h
->root
.type
== bfd_link_hash_defined
5751 && (rel
->r_vaddr
- input_section
->vma
+ 8
5752 <= input_section
->_cooked_size
))
5757 pnext
= contents
+ (rel
->r_vaddr
- input_section
->vma
) + 4;
5758 next
= bfd_get_32 (input_bfd
, pnext
);
5759 if (h
->smclas
== XMC_GL
)
5761 if (next
== 0x4def7b82 /* cror 15,15,15 */
5762 || next
== 0x4ffffb82) /* cror 31,31,31 */
5763 bfd_put_32 (input_bfd
, 0x80410014, pnext
); /* lwz r1,20(r1) */
5767 if (next
== 0x80410014) /* lwz r1,20(r1) */
5768 bfd_put_32 (input_bfd
, 0x4ffffb82, pnext
); /* cror 31,31,31 */
5772 /* A PC relative reloc includes the section address. */
5773 if (howto
.pc_relative
)
5774 addend
+= input_section
->vma
;
5776 rstat
= _bfd_final_link_relocate (&howto
, input_bfd
, input_section
,
5778 rel
->r_vaddr
- input_section
->vma
,
5787 case bfd_reloc_overflow
:
5790 char buf
[SYMNMLEN
+ 1];
5791 char howto_name
[10];
5796 name
= h
->root
.root
.string
;
5799 name
= _bfd_coff_internal_syment_name (input_bfd
, sym
, buf
);
5803 sprintf (howto_name
, "0x%02x", rel
->r_type
);
5805 if (! ((*info
->callbacks
->reloc_overflow
)
5806 (info
, name
, howto_name
, (bfd_vma
) 0, input_bfd
,
5807 input_section
, rel
->r_vaddr
- input_section
->vma
)))