projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PowerPC64 --plt-align
[deliverable/binutils-gdb.git] / bfd / coff64-rs6000.c
CommitLineData
7f6d05e8 1/* BFD back-end for IBM RS/6000 "XCOFF64" files.
4b95cf5c 2 Copyright (C) 2000-2014 Free Software Foundation, Inc.
7f6d05e8
CP		 3 Written Clinton Popetz.
4 Contributed by Cygnus Support.
5
eb1e0e80 6 This file is part of BFD, the Binary File Descriptor library.
7f6d05e8 7
eb1e0e80
NC		 8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
cd123cb7 10 the Free Software Foundation; either version 3 of the License, or
eb1e0e80 11 (at your option) any later version.
7f6d05e8 12
eb1e0e80
NC		 13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
7f6d05e8 17
eb1e0e80
NC		 18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
cd123cb7
NC		 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
7f6d05e8 22
7f6d05e8 23#include "sysdep.h"
3db64b00 24#include "bfd.h"
beb1bf64 25#include "bfdlink.h"
7f6d05e8
CP		 26#include "libbfd.h"
27#include "coff/internal.h"
beb1bf64 28#include "coff/xcoff.h"
7f6d05e8 29#include "coff/rs6k64.h"
dc810e39 30#include "libcoff.h"
beb1bf64 31#include "libxcoff.h"
7f6d05e8 32
dc810e39
AM		 33#define GET_FILEHDR_SYMPTR H_GET_64
34#define PUT_FILEHDR_SYMPTR H_PUT_64
35#define GET_AOUTHDR_DATA_START H_GET_64
36#define PUT_AOUTHDR_DATA_START H_PUT_64
37#define GET_AOUTHDR_TEXT_START H_GET_64
38#define PUT_AOUTHDR_TEXT_START H_PUT_64
39#define GET_AOUTHDR_TSIZE H_GET_64
40#define PUT_AOUTHDR_TSIZE H_PUT_64
41#define GET_AOUTHDR_DSIZE H_GET_64
42#define PUT_AOUTHDR_DSIZE H_PUT_64
43#define GET_AOUTHDR_BSIZE H_GET_64
44#define PUT_AOUTHDR_BSIZE H_PUT_64
45#define GET_AOUTHDR_ENTRY H_GET_64
46#define PUT_AOUTHDR_ENTRY H_PUT_64
47#define GET_SCNHDR_PADDR H_GET_64
48#define PUT_SCNHDR_PADDR H_PUT_64
49#define GET_SCNHDR_VADDR H_GET_64
50#define PUT_SCNHDR_VADDR H_PUT_64
51#define GET_SCNHDR_SIZE H_GET_64
52#define PUT_SCNHDR_SIZE H_PUT_64
53#define GET_SCNHDR_SCNPTR H_GET_64
54#define PUT_SCNHDR_SCNPTR H_PUT_64
55#define GET_SCNHDR_RELPTR H_GET_64
56#define PUT_SCNHDR_RELPTR H_PUT_64
57#define GET_SCNHDR_LNNOPTR H_GET_64
58#define PUT_SCNHDR_LNNOPTR H_PUT_64
59#define GET_SCNHDR_NRELOC H_GET_32
7f6d05e8 60#define MAX_SCNHDR_NRELOC 0xffffffff
dc810e39
AM		 61#define PUT_SCNHDR_NRELOC H_PUT_32
62#define GET_SCNHDR_NLNNO H_GET_32
7f6d05e8 63#define MAX_SCNHDR_NLNNO 0xffffffff
dc810e39
AM		 64#define PUT_SCNHDR_NLNNO H_PUT_32
65#define GET_RELOC_VADDR H_GET_64
66#define PUT_RELOC_VADDR H_PUT_64
7f6d05e8
CP		 67
68#define COFF_FORCE_SYMBOLS_IN_STRINGS
69#define COFF_DEBUG_STRING_WIDE_PREFIX
70
beb1bf64 71
dc810e39
AM		 72#define COFF_ADJUST_SCNHDR_OUT_POST(ABFD, INT, EXT) \
73 do \
74 { \
75 memset (((SCNHDR *) EXT)->s_pad, 0, \
76 sizeof (((SCNHDR *) EXT)->s_pad)); \
77 } \
78 while (0)
7f6d05e8
CP		 79
80#define NO_COFF_LINENOS
81
beb1bf64
TR		 82#define coff_SWAP_lineno_in _bfd_xcoff64_swap_lineno_in
83#define coff_SWAP_lineno_out _bfd_xcoff64_swap_lineno_out
7f6d05e8 84
b34976b6 85static void _bfd_xcoff64_swap_lineno_in
4964e065 86 (bfd *, void *, void *);
b34976b6 87static unsigned int _bfd_xcoff64_swap_lineno_out
4964e065 88 (bfd *, void *, void *);
b34976b6 89static bfd_boolean _bfd_xcoff64_put_symbol_name
4964e065 90 (bfd *, struct bfd_strtab_hash *, struct internal_syment *, const char *);
b34976b6 91static bfd_boolean _bfd_xcoff64_put_ldsymbol_name
4964e065 92 (bfd *, struct xcoff_loader_info *, struct internal_ldsym *, const char *);
b34976b6 93static void _bfd_xcoff64_swap_sym_in
4964e065 94 (bfd *, void *, void *);
b34976b6 95static unsigned int _bfd_xcoff64_swap_sym_out
4964e065 96 (bfd *, void *, void *);
dc810e39 97static void _bfd_xcoff64_swap_aux_in
4964e065 98 (bfd *, void *, int, int, int, int, void *);
dc810e39 99static unsigned int _bfd_xcoff64_swap_aux_out
4964e065 100 (bfd *, void *, int, int, int, int, void *);
b34976b6 101static void xcoff64_swap_reloc_in
4964e065 102 (bfd *, void *, void *);
b34976b6 103static unsigned int xcoff64_swap_reloc_out
4964e065 104 (bfd *, void *, void *);
b34976b6 105extern bfd_boolean _bfd_xcoff_mkobject
4964e065 106 (bfd *);
b34976b6 107extern bfd_boolean _bfd_xcoff_copy_private_bfd_data
4964e065 108 (bfd *, bfd *);
b34976b6 109extern bfd_boolean _bfd_xcoff_is_local_label_name
4964e065 110 (bfd *, const char *);
dc810e39 111extern void xcoff64_rtype2howto
4964e065 112 (arelent *, struct internal_reloc *);
dc810e39 113extern reloc_howto_type * xcoff64_reloc_type_lookup
4964e065 114 (bfd *, bfd_reloc_code_real_type);
b34976b6 115extern bfd_boolean _bfd_xcoff_slurp_armap
4964e065
TG		 116 (bfd *);
117extern void *_bfd_xcoff_read_ar_hdr
118 (bfd *);
b34976b6 119extern bfd *_bfd_xcoff_openr_next_archived_file
4964e065 120 (bfd *, bfd *);
b34976b6 121extern int _bfd_xcoff_stat_arch_elt
4964e065 122 (bfd *, struct stat *);
b34976b6 123extern bfd_boolean _bfd_xcoff_write_armap
4964e065 124 (bfd *, unsigned int, struct orl *, unsigned int, int);
b34976b6 125extern bfd_boolean _bfd_xcoff_write_archive_contents
4964e065 126 (bfd *);
b34976b6 127extern int _bfd_xcoff_sizeof_headers
4964e065 128 (bfd *, struct bfd_link_info *);
b34976b6 129extern void _bfd_xcoff_swap_sym_in
4964e065 130 (bfd *, void *, void *);
b34976b6 131extern unsigned int _bfd_xcoff_swap_sym_out
4964e065 132 (bfd *, void *, void *);
dc810e39 133extern void _bfd_xcoff_swap_aux_in
4964e065 134 (bfd *, void *, int, int, int, int, void *);
dc810e39 135extern unsigned int _bfd_xcoff_swap_aux_out
4964e065 136 (bfd *, void *, int, int, int, int, void *);
dc810e39 137static void xcoff64_swap_ldhdr_in
4964e065 138 (bfd *, const void *, struct internal_ldhdr *);
dc810e39 139static void xcoff64_swap_ldhdr_out
4964e065 140 (bfd *, const struct internal_ldhdr *, void *d);
dc810e39 141static void xcoff64_swap_ldsym_in
4964e065 142 (bfd *, const void *, struct internal_ldsym *);
dc810e39 143static void xcoff64_swap_ldsym_out
4964e065 144 (bfd *, const struct internal_ldsym *, void *d);
dc810e39 145static void xcoff64_swap_ldrel_in
4964e065 146 (bfd *, const void *, struct internal_ldrel *);
dc810e39 147static void xcoff64_swap_ldrel_out
4964e065 148 (bfd *, const struct internal_ldrel *, void *d);
b34976b6 149static bfd_boolean xcoff64_write_object_contents
4964e065 150 (bfd *);
b34976b6 151static bfd_boolean xcoff64_ppc_relocate_section
4964e065
TG		 152 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
153 struct internal_reloc *, struct internal_syment *,
154 asection **);
b34976b6 155static bfd_boolean xcoff64_slurp_armap
4964e065 156 (bfd *);
b34976b6 157static const bfd_target *xcoff64_archive_p
4964e065 158 (bfd *);
b34976b6 159static bfd *xcoff64_openr_next_archived_file
4964e065 160 (bfd *, bfd *);
b34976b6 161static int xcoff64_sizeof_headers
4964e065 162 (bfd *, struct bfd_link_info *);
dc810e39 163static asection *xcoff64_create_csect_from_smclas
4964e065 164 (bfd *, union internal_auxent *, const char *);
b34976b6 165static bfd_boolean xcoff64_is_lineno_count_overflow
4964e065 166 (bfd *, bfd_vma);
b34976b6 167static bfd_boolean xcoff64_is_reloc_count_overflow
4964e065 168 (bfd *, bfd_vma);
dc810e39 169static bfd_vma xcoff64_loader_symbol_offset
4964e065 170 (bfd *, struct internal_ldhdr *);
dc810e39 171static bfd_vma xcoff64_loader_reloc_offset
4964e065 172 (bfd *, struct internal_ldhdr *);
b34976b6 173static bfd_boolean xcoff64_generate_rtinit
4964e065 174 (bfd *, const char *, const char *, bfd_boolean);
b34976b6 175static bfd_boolean xcoff64_bad_format_hook
4964e065 176 (bfd *, void *);
dc810e39 177
f1f0d9ab 178/* Relocation functions */
b34976b6 179static bfd_boolean xcoff64_reloc_type_br
4964e065 180 (XCOFF_RELOC_FUNCTION_ARGS);
f1f0d9ab 181
b34976b6 182bfd_boolean (*xcoff64_calculate_relocation[XCOFF_MAX_CALCULATE_RELOCATION])
4964e065 183 (XCOFF_RELOC_FUNCTION_ARGS) =
f1f0d9ab 184{
cf9ab45b
AM		 185 xcoff_reloc_type_pos, /* R_POS (0x00) */
186 xcoff_reloc_type_neg, /* R_NEG (0x01) */
187 xcoff_reloc_type_rel, /* R_REL (0x02) */
188 xcoff_reloc_type_toc, /* R_TOC (0x03) */
f1f0d9ab 189 xcoff_reloc_type_fail, /* R_RTB (0x04) */
cf9ab45b
AM		 190 xcoff_reloc_type_toc, /* R_GL (0x05) */
191 xcoff_reloc_type_toc, /* R_TCL (0x06) */
192 xcoff_reloc_type_fail, /* (0x07) */
193 xcoff_reloc_type_ba, /* R_BA (0x08) */
194 xcoff_reloc_type_fail, /* (0x09) */
f1f0d9ab 195 xcoff64_reloc_type_br, /* R_BR (0x0a) */
cf9ab45b
AM		 196 xcoff_reloc_type_fail, /* (0x0b) */
197 xcoff_reloc_type_pos, /* R_RL (0x0c) */
198 xcoff_reloc_type_pos, /* R_RLA (0x0d) */
199 xcoff_reloc_type_fail, /* (0x0e) */
f1f0d9ab 200 xcoff_reloc_type_noop, /* R_REF (0x0f) */
cf9ab45b
AM		 201 xcoff_reloc_type_fail, /* (0x10) */
202 xcoff_reloc_type_fail, /* (0x11) */
203 xcoff_reloc_type_toc, /* R_TRL (0x12) */
204 xcoff_reloc_type_toc, /* R_TRLA (0x13) */
f1f0d9ab
TR		 205 xcoff_reloc_type_fail, /* R_RRTBI (0x14) */
206 xcoff_reloc_type_fail, /* R_RRTBA (0x15) */
cf9ab45b 207 xcoff_reloc_type_ba, /* R_CAI (0x16) */
f1f0d9ab 208 xcoff_reloc_type_crel, /* R_CREL (0x17) */
cf9ab45b
AM		 209 xcoff_reloc_type_ba, /* R_RBA (0x18) */
210 xcoff_reloc_type_ba, /* R_RBAC (0x19) */
f1f0d9ab 211 xcoff64_reloc_type_br, /* R_RBR (0x1a) */
cf9ab45b 212 xcoff_reloc_type_ba, /* R_RBRC (0x1b) */
f1f0d9ab
TR		 213};
214
eb1e0e80 215/* coffcode.h needs these to be defined. */
dc810e39
AM		 216/* Internalcoff.h and coffcode.h modify themselves based on these flags. */
217#define XCOFF64
218#define RS6000COFF_C 1
219
220#define SELECT_RELOC(internal, howto) \
221 { \
222 internal.r_type = howto->type; \
223 internal.r_size = \
224 ((howto->complain_on_overflow == complain_overflow_signed \
225 ? 0x80 \
226 : 0) \
227 | (howto->bitsize - 1)); \
228 }
814fa6ab 229
dc810e39
AM		 230#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
231#define COFF_LONG_FILENAMES
232#define NO_COFF_SYMBOLS
233#define RTYPE2HOWTO(cache_ptr, dst) xcoff64_rtype2howto (cache_ptr, dst)
234#define coff_mkobject _bfd_xcoff_mkobject
235#define coff_bfd_copy_private_bfd_data _bfd_xcoff_copy_private_bfd_data
236#define coff_bfd_is_local_label_name _bfd_xcoff_is_local_label_name
237#define coff_bfd_reloc_type_lookup xcoff64_reloc_type_lookup
157090f7 238#define coff_bfd_reloc_name_lookup xcoff64_reloc_name_lookup
dc810e39 239#ifdef AIX_CORE
b34976b6 240extern const bfd_target * rs6000coff_core_p
4964e065 241 (bfd *abfd);
b34976b6 242extern bfd_boolean rs6000coff_core_file_matches_executable_p
4964e065 243 (bfd *cbfd, bfd *ebfd);
b34976b6 244extern char *rs6000coff_core_file_failing_command
4964e065 245 (bfd *abfd);
b34976b6 246extern int rs6000coff_core_file_failing_signal
4964e065 247 (bfd *abfd);
dc810e39
AM		 248#define CORE_FILE_P rs6000coff_core_p
249#define coff_core_file_failing_command \
250 rs6000coff_core_file_failing_command
251#define coff_core_file_failing_signal \
252 rs6000coff_core_file_failing_signal
253#define coff_core_file_matches_executable_p \
254 rs6000coff_core_file_matches_executable_p
261b8d08
PA		 255#define coff_core_file_pid \
256 _bfd_nocore_core_file_pid
dc810e39
AM		 257#else
258#define CORE_FILE_P _bfd_dummy_target
259#define coff_core_file_failing_command \
260 _bfd_nocore_core_file_failing_command
261#define coff_core_file_failing_signal \
262 _bfd_nocore_core_file_failing_signal
263#define coff_core_file_matches_executable_p \
264 _bfd_nocore_core_file_matches_executable_p
261b8d08
PA		 265#define coff_core_file_pid \
266 _bfd_nocore_core_file_pid
dc810e39
AM		 267#endif
268#define coff_SWAP_sym_in _bfd_xcoff64_swap_sym_in
269#define coff_SWAP_sym_out _bfd_xcoff64_swap_sym_out
270#define coff_SWAP_aux_in _bfd_xcoff64_swap_aux_in
271#define coff_SWAP_aux_out _bfd_xcoff64_swap_aux_out
59862849
TR		 272#define coff_swap_reloc_in xcoff64_swap_reloc_in
273#define coff_swap_reloc_out xcoff64_swap_reloc_out
274#define NO_COFF_RELOCS
dc810e39 275
2b5c217d
NC		 276#ifndef bfd_pe_print_pdata
277#define bfd_pe_print_pdata NULL
278#endif
279
3c865fca 280#include <stdint.h>
dc810e39
AM		 281#include "coffcode.h"
282
283/* For XCOFF64, the effective width of symndx changes depending on
7f6d05e8
CP		 284 whether we are the first entry. Sigh. */
285static void
4964e065 286_bfd_xcoff64_swap_lineno_in (bfd *abfd, void *ext1, void *in1)
7f6d05e8 287{
dc810e39
AM		 288 LINENO *ext = (LINENO *) ext1;
289 struct internal_lineno *in = (struct internal_lineno *) in1;
7f6d05e8 290
dc810e39 291 in->l_lnno = H_GET_32 (abfd, (ext->l_lnno));
7f6d05e8 292 if (in->l_lnno == 0)
dc810e39 293 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
7f6d05e8 294 else
dc810e39 295 in->l_addr.l_paddr = H_GET_64 (abfd, ext->l_addr.l_paddr);
7f6d05e8
CP		 296}
297
298static unsigned int
4964e065 299_bfd_xcoff64_swap_lineno_out (bfd *abfd, void *inp, void *outp)
7f6d05e8 300{
dc810e39
AM		 301 struct internal_lineno *in = (struct internal_lineno *) inp;
302 struct external_lineno *ext = (struct external_lineno *) outp;
303
304 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
305 H_PUT_32 (abfd, in->l_lnno, (ext->l_lnno));
7f6d05e8 306
7f6d05e8 307 if (in->l_lnno == 0)
dc810e39 308 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
7f6d05e8 309 else
dc810e39 310 H_PUT_64 (abfd, in->l_addr.l_paddr, ext->l_addr.l_paddr);
7f6d05e8
CP		 311
312 return bfd_coff_linesz (abfd);
313}
314
7f6d05e8 315static void
4964e065 316_bfd_xcoff64_swap_sym_in (bfd *abfd, void *ext1, void *in1)
7f6d05e8 317{
dc810e39
AM		 318 struct external_syment *ext = (struct external_syment *) ext1;
319 struct internal_syment *in = (struct internal_syment *) in1;
7f6d05e8 320
7f6d05e8 321 in->_n._n_n._n_zeroes = 0;
dc810e39
AM		 322 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e_offset);
323 in->n_value = H_GET_64 (abfd, ext->e_value);
324 in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
325 in->n_type = H_GET_16 (abfd, ext->e_type);
326 in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
327 in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
7f6d05e8
CP		 328}
329
330static unsigned int
4964e065 331_bfd_xcoff64_swap_sym_out (bfd *abfd, void *inp, void *extp)
7f6d05e8 332{
dc810e39
AM		 333 struct internal_syment *in = (struct internal_syment *) inp;
334 struct external_syment *ext = (struct external_syment *) extp;
335
336 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e_offset);
337 H_PUT_64 (abfd, in->n_value, ext->e_value);
338 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
339 H_PUT_16 (abfd, in->n_type, ext->e_type);
340 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
341 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
7f6d05e8
CP		 342 return bfd_coff_symesz (abfd);
343}
344
345static void
4964e065
TG		 346_bfd_xcoff64_swap_aux_in (bfd *abfd, void *ext1, int type, int in_class,
347 int indx, int numaux, void *in1)
7f6d05e8 348{
dc810e39
AM		 349 union external_auxent *ext = (union external_auxent *) ext1;
350 union internal_auxent *in = (union internal_auxent *) in1;
7f6d05e8 351
96d56e9f 352 switch (in_class)
dc810e39 353 {
7f6d05e8 354 case C_FILE:
7f41df2e 355 if (ext->x_file.x_n.x_n.x_zeroes[0] == 0)
dc810e39 356 {
7f6d05e8 357 in->x_file.x_n.x_zeroes = 0;
7f41df2e
TG		 358 in->x_file.x_n.x_offset =
359 H_GET_32 (abfd, ext->x_file.x_n.x_n.x_offset);
dc810e39
AM		 360 }
361 else
362 {
7f41df2e 363 memcpy (in->x_file.x_fname, ext->x_file.x_n.x_fname, FILNMLEN);
beb1bf64 364 }
7f6d05e8
CP		 365 goto end;
366
367 /* RS/6000 "csect" auxents */
368 case C_EXT:
8602d4fe 369 case C_AIX_WEAKEXT:
7f6d05e8
CP		 370 case C_HIDEXT:
371 if (indx + 1 == numaux)
372 {
beb1bf64
TR		 373 bfd_signed_vma h = 0;
374 bfd_vma l = 0;
375
dc810e39
AM		 376 h = H_GET_S32 (abfd, ext->x_csect.x_scnlen_hi);
377 l = H_GET_32 (abfd, ext->x_csect.x_scnlen_lo);
beb1bf64
TR		 378
379 in->x_csect.x_scnlen.l = h << 32 | (l & 0xffffffff);
380
dc810e39
AM		 381 in->x_csect.x_parmhash = H_GET_32 (abfd, ext->x_csect.x_parmhash);
382 in->x_csect.x_snhash = H_GET_16 (abfd, ext->x_csect.x_snhash);
7f6d05e8
CP		 383 /* We don't have to hack bitfields in x_smtyp because it's
384 defined by shifts-and-ands, which are equivalent on all
385 byte orders. */
dc810e39
AM		 386 in->x_csect.x_smtyp = H_GET_8 (abfd, ext->x_csect.x_smtyp);
387 in->x_csect.x_smclas = H_GET_8 (abfd, ext->x_csect.x_smclas);
7f6d05e8
CP		 388 goto end;
389 }
390 break;
391
392 case C_STAT:
393 case C_LEAFSTAT:
394 case C_HIDDEN:
dc810e39
AM		 395 if (type == T_NULL)
396 {
7f6d05e8 397 /* PE defines some extra fields; we zero them out for
dc810e39 398 safety. */
7f6d05e8
CP		 399 in->x_scn.x_checksum = 0;
400 in->x_scn.x_associated = 0;
401 in->x_scn.x_comdat = 0;
402
403 goto end;
404 }
405 break;
406 }
407
96d56e9f
NC		 408 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
409 || ISTAG (in_class))
7f6d05e8 410 {
dc810e39
AM		 411 in->x_sym.x_fcnary.x_fcn.x_lnnoptr
412 = H_GET_64 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
413 in->x_sym.x_fcnary.x_fcn.x_endndx.l
414 = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx);
415 }
416 if (ISFCN (type))
417 {
418 in->x_sym.x_misc.x_fsize
419 = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_fsize);
420 }
421 else
422 {
423 in->x_sym.x_misc.x_lnsz.x_lnno
424 = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_lnsz.x_lnno);
425 in->x_sym.x_misc.x_lnsz.x_size
426 = H_GET_16 (abfd, ext->x_sym.x_fcnary.x_lnsz.x_size);
7f6d05e8 427 }
7f6d05e8 428
dc810e39 429 end: ;
7f6d05e8
CP		 430}
431
7f6d05e8 432static unsigned int
4964e065
TG		 433_bfd_xcoff64_swap_aux_out (bfd *abfd, void *inp, int type, int in_class,
434 int indx ATTRIBUTE_UNUSED,
435 int numaux ATTRIBUTE_UNUSED,
436 void *extp)
7f6d05e8 437{
dc810e39
AM		 438 union internal_auxent *in = (union internal_auxent *) inp;
439 union external_auxent *ext = (union external_auxent *) extp;
7f6d05e8 440
4964e065 441 memset (ext, 0, bfd_coff_auxesz (abfd));
96d56e9f 442 switch (in_class)
7f6d05e8 443 {
dc810e39 444 case C_FILE:
a58d9c34 445 if (in->x_file.x_n.x_zeroes == 0)
dc810e39 446 {
7f41df2e
TG		 447 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_n.x_zeroes);
448 H_PUT_32 (abfd, in->x_file.x_n.x_offset,
449 ext->x_file.x_n.x_n.x_offset);
dc810e39
AM		 450 }
451 else
452 {
7f41df2e 453 memcpy (ext->x_file.x_n.x_fname, in->x_file.x_fname, FILNMLEN);
dc810e39
AM		 454 }
455 H_PUT_8 (abfd, _AUX_FILE, ext->x_auxtype.x_auxtype);
7f6d05e8 456 goto end;
dc810e39
AM		 457
458 /* RS/6000 "csect" auxents */
459 case C_EXT:
8602d4fe 460 case C_AIX_WEAKEXT:
dc810e39
AM		 461 case C_HIDEXT:
462 if (indx + 1 == numaux)
463 {
464 bfd_vma temp;
465
466 temp = in->x_csect.x_scnlen.l & 0xffffffff;
467 H_PUT_32 (abfd, temp, ext->x_csect.x_scnlen_lo);
468 temp = in->x_csect.x_scnlen.l >> 32;
469 H_PUT_32 (abfd, temp, ext->x_csect.x_scnlen_hi);
470 H_PUT_32 (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash);
471 H_PUT_16 (abfd, in->x_csect.x_snhash, ext->x_csect.x_snhash);
472 /* We don't have to hack bitfields in x_smtyp because it's
473 defined by shifts-and-ands, which are equivalent on all
474 byte orders. */
475 H_PUT_8 (abfd, in->x_csect.x_smtyp, ext->x_csect.x_smtyp);
476 H_PUT_8 (abfd, in->x_csect.x_smclas, ext->x_csect.x_smclas);
477 H_PUT_8 (abfd, _AUX_CSECT, ext->x_auxtype.x_auxtype);
478 goto end;
479 }
480 break;
481
482 case C_STAT:
483 case C_LEAFSTAT:
484 case C_HIDDEN:
485 if (type == T_NULL)
486 {
487 goto end;
488 }
489 break;
7f6d05e8 490 }
7f6d05e8 491
96d56e9f
NC		 492 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
493 || ISTAG (in_class))
7f6d05e8 494 {
dc810e39
AM		 495 H_PUT_64 (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,
496 ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
497 H_PUT_8 (abfd, _AUX_FCN,
498 ext->x_auxtype.x_auxtype);
499 H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l,
500 ext->x_sym.x_fcnary.x_fcn.x_endndx);
7f6d05e8
CP		 501 }
502 if (ISFCN (type))
dc810e39
AM		 503 {
504 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize,
505 ext->x_sym.x_fcnary.x_fcn.x_fsize);
506 }
7f6d05e8
CP		 507 else
508 {
dc810e39
AM		 509 H_PUT_32 (abfd, in->x_sym.x_misc.x_lnsz.x_lnno,
510 ext->x_sym.x_fcnary.x_lnsz.x_lnno);
511 H_PUT_16 (abfd, in->x_sym.x_misc.x_lnsz.x_size,
512 ext->x_sym.x_fcnary.x_lnsz.x_size);
7f6d05e8
CP		 513 }
514
dc810e39 515 end:
beb1bf64 516
7f6d05e8
CP		 517 return bfd_coff_auxesz (abfd);
518}
519
b34976b6 520static bfd_boolean
4964e065
TG		 521_bfd_xcoff64_put_symbol_name (bfd *abfd, struct bfd_strtab_hash *strtab,
522 struct internal_syment *sym,
523 const char *name)
eb1e0e80 524{
b34976b6 525 bfd_boolean hash;
beb1bf64 526 bfd_size_type indx;
dc810e39 527
b34976b6 528 hash = TRUE;
dc810e39 529
beb1bf64 530 if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
b34976b6 531 hash = FALSE;
dc810e39 532
b34976b6 533 indx = _bfd_stringtab_add (strtab, name, hash, FALSE);
dc810e39 534
beb1bf64 535 if (indx == (bfd_size_type) -1)
b34976b6 536 return FALSE;
dc810e39 537
beb1bf64
TR		 538 sym->_n._n_n._n_zeroes = 0;
539 sym->_n._n_n._n_offset = STRING_SIZE_SIZE + indx;
dc810e39 540
b34976b6 541 return TRUE;
beb1bf64
TR		 542}
543
b34976b6 544static bfd_boolean
4964e065
TG		 545_bfd_xcoff64_put_ldsymbol_name (bfd *abfd ATTRIBUTE_UNUSED,
546 struct xcoff_loader_info *ldinfo,
547 struct internal_ldsym *ldsym,
548 const char *name)
beb1bf64 549{
beb1bf64
TR		 550 size_t len;
551 len = strlen (name);
552
dc810e39
AM		 553 if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
554 {
555 bfd_size_type newalc;
f075ee0c 556 char *newstrings;
dc810e39
AM		 557
558 newalc = ldinfo->string_alc * 2;
559 if (newalc == 0)
560 newalc = 32;
561 while (ldinfo->string_size + len + 3 > newalc)
562 newalc *= 2;
563
f075ee0c 564 newstrings = bfd_realloc (ldinfo->strings, newalc);
dc810e39
AM		 565 if (newstrings == NULL)
566 {
b34976b6
AM		 567 ldinfo->failed = TRUE;
568 return FALSE;
dc810e39
AM		 569 }
570 ldinfo->string_alc = newalc;
571 ldinfo->strings = newstrings;
beb1bf64 572 }
dc810e39
AM		 573
574 bfd_put_16 (ldinfo->output_bfd, (bfd_vma) (len + 1),
beb1bf64
TR		 575 ldinfo->strings + ldinfo->string_size);
576 strcpy (ldinfo->strings + ldinfo->string_size + 2, name);
577 ldsym->_l._l_l._l_zeroes = 0;
578 ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
579 ldinfo->string_size += len + 3;
dc810e39 580
b34976b6 581 return TRUE;
beb1bf64
TR		 582}
583
beb1bf64
TR		 584/* Routines to swap information in the XCOFF .loader section. If we
585 ever need to write an XCOFF loader, this stuff will need to be
586 moved to another file shared by the linker (which XCOFF calls the
587 ``binder'') and the loader. */
588
589/* Swap in the ldhdr structure. */
590
591static void
4964e065
TG		 592xcoff64_swap_ldhdr_in (bfd *abfd,
593 const void *s,
594 struct internal_ldhdr *dst)
814fa6ab
AM		 595{
596 const struct external_ldhdr *src = (const struct external_ldhdr *) s;
597
beb1bf64
TR		 598 dst->l_version = bfd_get_32 (abfd, src->l_version);
599 dst->l_nsyms = bfd_get_32 (abfd, src->l_nsyms);
600 dst->l_nreloc = bfd_get_32 (abfd, src->l_nreloc);
601 dst->l_istlen = bfd_get_32 (abfd, src->l_istlen);
602 dst->l_nimpid = bfd_get_32 (abfd, src->l_nimpid);
603 dst->l_stlen = bfd_get_32 (abfd, src->l_stlen);
604 dst->l_impoff = bfd_get_64 (abfd, src->l_impoff);
605 dst->l_stoff = bfd_get_64 (abfd, src->l_stoff);
606 dst->l_symoff = bfd_get_64 (abfd, src->l_symoff);
607 dst->l_rldoff = bfd_get_64 (abfd, src->l_rldoff);
608}
609
610/* Swap out the ldhdr structure. */
611
612static void
4964e065 613xcoff64_swap_ldhdr_out (bfd *abfd, const struct internal_ldhdr *src, void *d)
beb1bf64 614{
814fa6ab
AM		 615 struct external_ldhdr *dst = (struct external_ldhdr *) d;
616
dc810e39 617 bfd_put_32 (abfd, (bfd_vma) src->l_version, dst->l_version);
beb1bf64
TR		 618 bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
619 bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
620 bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
621 bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
622 bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
623 bfd_put_64 (abfd, src->l_impoff, dst->l_impoff);
624 bfd_put_64 (abfd, src->l_stoff, dst->l_stoff);
625 bfd_put_64 (abfd, src->l_symoff, dst->l_symoff);
626 bfd_put_64 (abfd, src->l_rldoff, dst->l_rldoff);
627}
628
629/* Swap in the ldsym structure. */
630
631static void
4964e065 632xcoff64_swap_ldsym_in (bfd *abfd, const void *s, struct internal_ldsym *dst)
beb1bf64 633{
814fa6ab 634 const struct external_ldsym *src = (const struct external_ldsym *) s;
dc810e39
AM		 635 /* XCOFF64 does not use l_zeroes like XCOFF32
636 Set the internal l_zeroes to 0 so the common 32/64 code uses l_value
637 as an offset into the loader symbol table. */
beb1bf64
TR		 638 dst->_l._l_l._l_zeroes = 0;
639 dst->_l._l_l._l_offset = bfd_get_32 (abfd, src->l_offset);
640 dst->l_value = bfd_get_64 (abfd, src->l_value);
641 dst->l_scnum = bfd_get_16 (abfd, src->l_scnum);
642 dst->l_smtype = bfd_get_8 (abfd, src->l_smtype);
643 dst->l_smclas = bfd_get_8 (abfd, src->l_smclas);
644 dst->l_ifile = bfd_get_32 (abfd, src->l_ifile);
645 dst->l_parm = bfd_get_32 (abfd, src->l_parm);
646}
647
648/* Swap out the ldsym structure. */
649
650static void
4964e065 651xcoff64_swap_ldsym_out (bfd *abfd, const struct internal_ldsym *src, void *d)
beb1bf64 652{
814fa6ab
AM		 653 struct external_ldsym *dst = (struct external_ldsym *) d;
654
beb1bf64 655 bfd_put_64 (abfd, src->l_value, dst->l_value);
dc810e39
AM		 656 bfd_put_32 (abfd, (bfd_vma) src->_l._l_l._l_offset, dst->l_offset);
657 bfd_put_16 (abfd, (bfd_vma) src->l_scnum, dst->l_scnum);
beb1bf64
TR		 658 bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
659 bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
660 bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
661 bfd_put_32 (abfd, src->l_parm, dst->l_parm);
662}
663
59862849 664static void
4964e065 665xcoff64_swap_reloc_in (bfd *abfd, void *s, void *d)
59862849
TR		 666{
667 struct external_reloc *src = (struct external_reloc *) s;
668 struct internal_reloc *dst = (struct internal_reloc *) d;
669
670 memset (dst, 0, sizeof (struct internal_reloc));
671
672 dst->r_vaddr = bfd_get_64 (abfd, src->r_vaddr);
673 dst->r_symndx = bfd_get_32 (abfd, src->r_symndx);
674 dst->r_size = bfd_get_8 (abfd, src->r_size);
675 dst->r_type = bfd_get_8 (abfd, src->r_type);
676}
677
678static unsigned int
4964e065 679xcoff64_swap_reloc_out (bfd *abfd, void *s, void *d)
59862849
TR		 680{
681 struct internal_reloc *src = (struct internal_reloc *) s;
682 struct external_reloc *dst = (struct external_reloc *) d;
683
684 bfd_put_64 (abfd, src->r_vaddr, dst->r_vaddr);
685 bfd_put_32 (abfd, src->r_symndx, dst->r_symndx);
686 bfd_put_8 (abfd, src->r_type, dst->r_type);
687 bfd_put_8 (abfd, src->r_size, dst->r_size);
688
689 return bfd_coff_relsz (abfd);
690}
691
beb1bf64
TR		 692/* Swap in the ldrel structure. */
693
694static void
4964e065 695xcoff64_swap_ldrel_in (bfd *abfd, const void *s, struct internal_ldrel *dst)
beb1bf64 696{
814fa6ab
AM		 697 const struct external_ldrel *src = (const struct external_ldrel *) s;
698
beb1bf64
TR		 699 dst->l_vaddr = bfd_get_64 (abfd, src->l_vaddr);
700 dst->l_symndx = bfd_get_32 (abfd, src->l_symndx);
701 dst->l_rtype = bfd_get_16 (abfd, src->l_rtype);
702 dst->l_rsecnm = bfd_get_16 (abfd, src->l_rsecnm);
703}
704
705/* Swap out the ldrel structure. */
706
707static void
4964e065 708xcoff64_swap_ldrel_out (bfd *abfd, const struct internal_ldrel *src, void *d)
beb1bf64 709{
814fa6ab
AM		 710 struct external_ldrel *dst = (struct external_ldrel *) d;
711
beb1bf64 712 bfd_put_64 (abfd, src->l_vaddr, dst->l_vaddr);
dc810e39
AM		 713 bfd_put_16 (abfd, (bfd_vma) src->l_rtype, dst->l_rtype);
714 bfd_put_16 (abfd, (bfd_vma) src->l_rsecnm, dst->l_rsecnm);
beb1bf64
TR		 715 bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
716}
717
b34976b6 718static bfd_boolean
4964e065 719xcoff64_write_object_contents (bfd *abfd)
beb1bf64
TR		 720{
721 asection *current;
b34976b6
AM		 722 bfd_boolean hasrelocs = FALSE;
723 bfd_boolean haslinno = FALSE;
beb1bf64
TR		 724 file_ptr scn_base;
725 file_ptr reloc_base;
726 file_ptr lineno_base;
727 file_ptr sym_base;
728 unsigned long reloc_size = 0;
729 unsigned long lnno_size = 0;
4964e065
TG		 730 asection *text_sec = NULL;
731 asection *data_sec = NULL;
732 asection *bss_sec = NULL;
beb1bf64
TR		 733 struct internal_filehdr internal_f;
734 struct internal_aouthdr internal_a;
735
736 bfd_set_error (bfd_error_system_call);
737
82e51918 738 if (! abfd->output_has_begun)
dc810e39
AM		 739 {
740 if (! bfd_coff_compute_section_file_positions (abfd))
b34976b6 741 return FALSE;
dc810e39 742 }
beb1bf64 743
eb1e0e80 744 /* Work out the size of the reloc and linno areas. */
beb1bf64
TR		 745 reloc_base = obj_relocbase (abfd);
746
dc810e39 747 for (current = abfd->sections; current != NULL; current = current->next)
beb1bf64 748 reloc_size += current->reloc_count * bfd_coff_relsz (abfd);
beb1bf64
TR		 749
750 lineno_base = reloc_base + reloc_size;
751
752 /* Make a pass through the symbol table to count line number entries and
eb1e0e80 753 put them into the correct asections. */
beb1bf64
TR		 754 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
755
756 sym_base = lineno_base + lnno_size;
757
eb1e0e80 758 /* Indicate in each section->line_filepos its actual file address. */
dc810e39
AM		 759 for (current = abfd->sections; current != NULL; current = current->next)
760 {
761 if (current->lineno_count)
762 {
763 current->line_filepos = lineno_base;
764 current->moving_line_filepos = lineno_base;
765 lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
766 }
767 else
768 {
769 current->line_filepos = 0;
770 }
771
772 if (current->reloc_count)
773 {
774 current->rel_filepos = reloc_base;
775 reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
776 }
777 else
778 {
779 current->rel_filepos = 0;
780 }
781 }
782
783 if ((abfd->flags & EXEC_P) != 0)
784 {
785 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
786 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
beb1bf64 787 }
dc810e39
AM		 788 else
789 {
790 scn_base = bfd_coff_filhsz (abfd);
791 internal_f.f_opthdr = 0;
beb1bf64 792 }
beb1bf64
TR		 793
794 internal_f.f_nscns = 0;
795
796 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
b34976b6 797 return FALSE;
beb1bf64 798
dc810e39
AM		 799 for (current = abfd->sections; current != NULL; current = current->next)
800 {
801 struct internal_scnhdr section;
802 struct external_scnhdr buff;
803 bfd_size_type amount;
beb1bf64 804
dc810e39 805 internal_f.f_nscns++;
beb1bf64 806
dc810e39 807 strncpy (section.s_name, current->name, SCNNMLEN);
beb1bf64 808
dc810e39
AM		 809 section.s_vaddr = current->vma;
810 section.s_paddr = current->lma;
eea6121a 811 section.s_size = current->size;
beb1bf64 812
dc810e39
AM		 813 /* If this section has no size or is unloadable then the scnptr
814 will be 0 too. */
eea6121a 815 if (current->size == 0
dc810e39
AM		 816 || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
817 {
818 section.s_scnptr = 0;
819 }
820 else
821 {
822 section.s_scnptr = current->filepos;
823 }
824
825 section.s_relptr = current->rel_filepos;
826 section.s_lnnoptr = current->line_filepos;
827 section.s_nreloc = current->reloc_count;
828
829 section.s_nlnno = current->lineno_count;
830 if (current->reloc_count != 0)
b34976b6 831 hasrelocs = TRUE;
dc810e39 832 if (current->lineno_count != 0)
b34976b6 833 haslinno = TRUE;
beb1bf64 834
dc810e39
AM		 835 section.s_flags = sec_to_styp_flags (current->name, current->flags);
836
837 if (!strcmp (current->name, _TEXT))
838 {
839 text_sec = current;
840 }
841 else if (!strcmp (current->name, _DATA))
842 {
843 data_sec = current;
844 }
845 else if (!strcmp (current->name, _BSS))
846 {
847 bss_sec = current;
848 }
849
850 amount = bfd_coff_scnhsz (abfd);
851 if (bfd_coff_swap_scnhdr_out (abfd, &section, &buff) == 0
4964e065 852 || bfd_bwrite (&buff, amount, abfd) != amount)
b34976b6 853 return FALSE;
dc810e39 854 }
beb1bf64
TR		 855
856 internal_f.f_timdat = 0;
857
858 internal_f.f_flags = 0;
859
860 if (!hasrelocs)
861 internal_f.f_flags |= F_RELFLG;
862 if (!haslinno)
863 internal_f.f_flags |= F_LNNO;
864 if (abfd->flags & EXEC_P)
865 internal_f.f_flags |= F_EXEC;
866
eb1e0e80 867 /* FIXME: this is wrong for PPC_PE! */
beb1bf64
TR		 868 if (bfd_little_endian (abfd))
869 internal_f.f_flags |= F_AR32WR;
870 else
871 internal_f.f_flags |= F_AR32W;
872
873 if ((abfd->flags & DYNAMIC) != 0)
874 internal_f.f_flags |= F_SHROBJ;
875 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
876 internal_f.f_flags |= F_DYNLOAD;
877
878 memset (&internal_a, 0, sizeof internal_a);
879
eb1e0e80 880 internal_f.f_magic = bfd_xcoff_magic_number (abfd);
cf9ab45b
AM		 881 internal_a.magic = (abfd->flags & D_PAGED
882 ? RS6K_AOUTHDR_ZMAGIC
883 : (abfd->flags & WP_TEXT
884 ? RS6K_AOUTHDR_NMAGIC
885 : RS6K_AOUTHDR_OMAGIC));
beb1bf64
TR		 886
887 /* FIXME: Does anybody ever set this to another value? */
888 internal_a.vstamp = 0;
889
eb1e0e80 890 /* Now should write relocs, strings, syms. */
beb1bf64
TR		 891 obj_sym_filepos (abfd) = sym_base;
892
893 internal_f.f_symptr = 0;
894 internal_f.f_nsyms = 0;
895
dc810e39
AM		 896 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
897 backend linker, and obj_raw_syment_count is not valid until after
898 coff_write_symbols is called. */
899 if (bfd_get_symcount (abfd) != 0)
900 {
901 int firstundef;
beb1bf64 902
dc810e39 903 if (!coff_renumber_symbols (abfd, &firstundef))
b34976b6 904 return FALSE;
dc810e39
AM		 905 coff_mangle_symbols (abfd);
906 if (! coff_write_symbols (abfd))
b34976b6 907 return FALSE;
dc810e39 908 if (! coff_write_linenumbers (abfd))
b34976b6 909 return FALSE;
dc810e39 910 if (! coff_write_relocs (abfd, firstundef))
b34976b6 911 return FALSE;
beb1bf64 912
dc810e39
AM		 913 internal_f.f_symptr = sym_base;
914 internal_f.f_nsyms = bfd_get_symcount (abfd);
915 }
916 else if (obj_raw_syment_count (abfd) != 0)
917 {
918 internal_f.f_symptr = sym_base;
919
920 /* AIX appears to require that F_RELFLG not be set if there are
921 local symbols but no relocations. */
922 internal_f.f_flags &=~ F_RELFLG;
923 }
924 else
925 {
926 internal_f.f_flags |= F_LSYMS;
927 }
beb1bf64 928
dc810e39
AM		 929 if (text_sec)
930 {
eea6121a 931 internal_a.tsize = text_sec->size;
beb1bf64 932 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
dc810e39 933 }
beb1bf64 934
dc810e39
AM		 935 if (data_sec)
936 {
eea6121a 937 internal_a.dsize = data_sec->size;
dc810e39
AM		 938 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
939 }
beb1bf64 940
dc810e39
AM		 941 if (bss_sec)
942 {
eea6121a 943 internal_a.bsize = bss_sec->size;
dc810e39
AM		 944 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
945 internal_a.data_start = bss_sec->vma;
946 }
beb1bf64
TR		 947
948 internal_a.entry = bfd_get_start_address (abfd);
949 internal_f.f_nsyms = obj_raw_syment_count (abfd);
950
dc810e39
AM		 951 if (xcoff_data (abfd)->full_aouthdr)
952 {
beb1bf64
TR		 953 bfd_vma toc;
954 asection *loader_sec;
955
956 internal_a.vstamp = 1;
957
958 internal_a.o_snentry = xcoff_data (abfd)->snentry;
959 if (internal_a.o_snentry == 0)
960 internal_a.entry = (bfd_vma) -1;
961
dc810e39
AM		 962 if (text_sec != NULL)
963 {
beb1bf64
TR		 964 internal_a.o_sntext = text_sec->target_index;
965 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
dc810e39
AM		 966 }
967 else
968 {
969 internal_a.o_sntext = 0;
970 internal_a.o_algntext = 0;
971 }
972
973 if (data_sec != NULL)
974 {
975 internal_a.o_sndata = data_sec->target_index;
976 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
977 }
978 else
979 {
980 internal_a.o_sndata = 0;
981 internal_a.o_algndata = 0;
982 }
beb1bf64
TR		 983
984 loader_sec = bfd_get_section_by_name (abfd, ".loader");
985 if (loader_sec != NULL)
986 internal_a.o_snloader = loader_sec->target_index;
987 else
988 internal_a.o_snloader = 0;
989 if (bss_sec != NULL)
990 internal_a.o_snbss = bss_sec->target_index;
991 else
992 internal_a.o_snbss = 0;
993
994 toc = xcoff_data (abfd)->toc;
995 internal_a.o_toc = toc;
996 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
997
998 internal_a.o_modtype = xcoff_data (abfd)->modtype;
999 if (xcoff_data (abfd)->cputype != -1)
1000 internal_a.o_cputype = xcoff_data (abfd)->cputype;
1001 else
1002 {
1003 switch (bfd_get_arch (abfd))
1004 {
1005 case bfd_arch_rs6000:
1006 internal_a.o_cputype = 4;
1007 break;
1008 case bfd_arch_powerpc:
250d94fd 1009 if (bfd_get_mach (abfd) == bfd_mach_ppc)
beb1bf64 1010 internal_a.o_cputype = 3;
d19d97e9
RS		 1011 else if (bfd_get_mach (abfd) == bfd_mach_ppc_620)
1012 internal_a.o_cputype = 2;
beb1bf64
TR		 1013 else
1014 internal_a.o_cputype = 1;
1015 break;
1016 default:
1017 abort ();
1018 }
1019 }
1020 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
1021 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
dc810e39
AM		 1022 }
1023
1024 if (bfd_seek (abfd, (file_ptr) 0, 0) != 0)
b34976b6 1025 return FALSE;
dc810e39 1026
beb1bf64
TR		 1027 {
1028 char * buff;
dc810e39
AM		 1029 bfd_size_type amount = bfd_coff_filhsz (abfd);
1030
1031 buff = bfd_malloc (amount);
1032 if (buff == NULL)
b34976b6 1033 return FALSE;
dc810e39 1034
4964e065
TG		 1035 bfd_coff_swap_filehdr_out (abfd, &internal_f, buff);
1036 amount = bfd_bwrite (buff, amount, abfd);
dc810e39 1037
beb1bf64 1038 free (buff);
dc810e39 1039
beb1bf64 1040 if (amount != bfd_coff_filhsz (abfd))
b34976b6 1041 return FALSE;
beb1bf64 1042 }
beb1bf64 1043
dc810e39
AM		 1044 if (abfd->flags & EXEC_P)
1045 {
1046 char * buff;
1047 bfd_size_type amount = bfd_coff_aoutsz (abfd);
beb1bf64 1048
dc810e39
AM		 1049 buff = bfd_malloc (amount);
1050 if (buff == NULL)
b34976b6 1051 return FALSE;
beb1bf64 1052
4964e065
TG		 1053 bfd_coff_swap_aouthdr_out (abfd, &internal_a, buff);
1054 amount = bfd_bwrite (buff, amount, abfd);
dc810e39
AM		 1055
1056 free (buff);
beb1bf64 1057
dc810e39 1058 if (amount != bfd_coff_aoutsz (abfd))
b34976b6 1059 return FALSE;
dc810e39 1060 }
beb1bf64 1061
b34976b6 1062 return TRUE;
beb1bf64
TR		 1063}
1064
b34976b6 1065static bfd_boolean
4964e065
TG		 1066xcoff64_reloc_type_br (bfd *input_bfd,
1067 asection *input_section,
1068 bfd *output_bfd ATTRIBUTE_UNUSED,
1069 struct internal_reloc *rel,
1070 struct internal_syment *sym ATTRIBUTE_UNUSED,
1071 struct reloc_howto_struct *howto,
1072 bfd_vma val,
1073 bfd_vma addend,
1074 bfd_vma *relocation,
1075 bfd_byte *contents)
f1f0d9ab
TR		 1076{
1077 struct xcoff_link_hash_entry *h;
12b2cce9 1078 bfd_vma section_offset;
f1f0d9ab 1079
cf9ab45b 1080 if (0 > rel->r_symndx)
b34976b6 1081 return FALSE;
f1f0d9ab
TR		 1082
1083 h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
12b2cce9 1084 section_offset = rel->r_vaddr - input_section->vma;
f1f0d9ab
TR		 1085
1086 /* If we see an R_BR or R_RBR reloc which is jumping to global
1087 linkage code, and it is followed by an appropriate cror nop
1088 instruction, we replace the cror with ld r2,40(r1). This
1089 restores the TOC after the glink code. Contrariwise, if the
1090 call is followed by a ld r2,40(r1), but the call is not
1091 going to global linkage code, we can replace the load with a
1092 cror. */
cf9ab45b 1093 if (NULL != h
8602d4fe
RS		 1094 && (bfd_link_hash_defined == h->root.type
1095 || bfd_link_hash_defweak == h->root.type)
12b2cce9 1096 && section_offset + 8 <= input_section->size)
f1f0d9ab
TR		 1097 {
1098 bfd_byte *pnext;
1099 unsigned long next;
cf9ab45b 1100
12b2cce9 1101 pnext = contents + section_offset + 4;
f1f0d9ab 1102 next = bfd_get_32 (input_bfd, pnext);
cf9ab45b
AM		 1103
1104 /* The _ptrgl function is magic. It is used by the AIX compiler to call
f1f0d9ab 1105 a function through a pointer. */
cf9ab45b 1106 if (h->smclas == XMC_GL || strcmp (h->root.root.string, "._ptrgl") == 0)
f1f0d9ab 1107 {
cf9ab45b
AM		 1108 if (next == 0x4def7b82 /* cror 15,15,15 */
1109 || next == 0x4ffffb82 /* cror 31,31,31 */
1110 || next == 0x60000000) /* ori r0,r0,0 */
1111 bfd_put_32 (input_bfd, 0xe8410028, pnext); /* ld r2,40(r1) */
1112 }
1113 else
f1f0d9ab 1114 {
cf9ab45b
AM		 1115 if (next == 0xe8410028) /* ld r2,40(r1) */
1116 bfd_put_32 (input_bfd, 0x60000000, pnext); /* ori r0,r0,0 */
f1f0d9ab 1117 }
cf9ab45b
AM		 1118 }
1119 else if (NULL != h && bfd_link_hash_undefined == h->root.type)
f1f0d9ab
TR		 1120 {
1121 /* Normally, this relocation is against a defined symbol. In the
1122 case where this is a partial link and the output section offset
cf9ab45b 1123 is greater than 2^25, the linker will return an invalid error
f1f0d9ab 1124 message that the relocation has been truncated. Yes it has been
cf9ab45b 1125 truncated but no it not important. For this case, disable the
f1f0d9ab
TR		 1126 overflow checking. */
1127 howto->complain_on_overflow = complain_overflow_dont;
1128 }
cf9ab45b 1129
12b2cce9
RS		 1130 /* The original PC-relative relocation is biased by -r_vaddr, so adding
1131 the value below will give the absolute target address. */
1132 *relocation = val + addend + rel->r_vaddr;
1133
a78eab4e
AM		 1134 howto->src_mask &= ~3;
1135 howto->dst_mask = howto->src_mask;
cf9ab45b 1136
12b2cce9 1137 if (h != NULL
8602d4fe
RS		 1138 && (h->root.type == bfd_link_hash_defined
1139 || h->root.type == bfd_link_hash_defweak)
12b2cce9
RS		 1140 && bfd_is_abs_section (h->root.u.def.section)
1141 && section_offset + 4 <= input_section->size)
1142 {
1143 bfd_byte *ptr;
1144 bfd_vma insn;
1145
1146 /* Turn the relative branch into an absolute one by setting the
1147 AA bit. */
1148 ptr = contents + section_offset;
1149 insn = bfd_get_32 (input_bfd, ptr);
1150 insn |= 2;
1151 bfd_put_32 (input_bfd, insn, ptr);
1152
1153 /* Make the howto absolute too. */
1154 howto->pc_relative = FALSE;
1155 howto->complain_on_overflow = complain_overflow_bitfield;
1156 }
1157 else
1158 {
1159 /* Use a PC-relative howto and subtract the instruction's address
1160 from the target address we calculated above. */
1161 howto->pc_relative = TRUE;
1162 *relocation -= (input_section->output_section->vma
1163 + input_section->output_offset
1164 + section_offset);
1165 }
b34976b6 1166 return TRUE;
f1f0d9ab
TR		 1167}
1168
dbe341c6
TR		 1169/* This is the relocation function for the PowerPC64.
1170 See xcoff_ppc_relocation_section for more information. */
beb1bf64 1171
b34976b6 1172bfd_boolean
4964e065
TG		 1173xcoff64_ppc_relocate_section (bfd *output_bfd,
1174 struct bfd_link_info *info,
1175 bfd *input_bfd,
1176 asection *input_section,
1177 bfd_byte *contents,
1178 struct internal_reloc *relocs,
1179 struct internal_syment *syms,
1180 asection **sections)
beb1bf64
TR		 1181{
1182 struct internal_reloc *rel;
1183 struct internal_reloc *relend;
1184
1185 rel = relocs;
1186 relend = rel + input_section->reloc_count;
1187 for (; rel < relend; rel++)
1188 {
1189 long symndx;
1190 struct xcoff_link_hash_entry *h;
1191 struct internal_syment *sym;
1192 bfd_vma addend;
1193 bfd_vma val;
1194 struct reloc_howto_struct howto;
dbe341c6
TR		 1195 bfd_vma relocation;
1196 bfd_vma value_to_relocate;
1197 bfd_vma address;
1198 bfd_byte *location;
beb1bf64
TR		 1199
1200 /* Relocation type R_REF is a special relocation type which is
cf9ab45b
AM		 1201 merely used to prevent garbage collection from occurring for
1202 the csect including the symbol which it references. */
beb1bf64
TR		 1203 if (rel->r_type == R_REF)
1204 continue;
1205
dbe341c6 1206 /* howto */
beb1bf64
TR		 1207 howto.type = rel->r_type;
1208 howto.rightshift = 0;
beb1bf64 1209 howto.bitsize = (rel->r_size & 0x3f) + 1;
dbe341c6 1210 howto.size = howto.bitsize > 16 ? (howto.bitsize > 32 ? 4 : 2) : 1;
b34976b6 1211 howto.pc_relative = FALSE;
beb1bf64 1212 howto.bitpos = 0;
cf9ab45b
AM		 1213 howto.complain_on_overflow = (rel->r_size & 0x80
1214 ? complain_overflow_signed
1215 : complain_overflow_bitfield);
beb1bf64
TR		 1216 howto.special_function = NULL;
1217 howto.name = "internal";
b34976b6 1218 howto.partial_inplace = TRUE;
cf9ab45b 1219 howto.src_mask = howto.dst_mask = N_ONES (howto.bitsize);
b34976b6 1220 howto.pcrel_offset = FALSE;
beb1bf64 1221
dbe341c6 1222 /* symbol */
beb1bf64 1223 val = 0;
dbe341c6
TR		 1224 addend = 0;
1225 h = NULL;
1226 sym = NULL;
cf9ab45b 1227 symndx = rel->r_symndx;
beb1bf64 1228
cf9ab45b 1229 if (-1 != symndx)
dc810e39
AM		 1230 {
1231 asection *sec;
cf9ab45b 1232
dbe341c6
TR		 1233 h = obj_xcoff_sym_hashes (input_bfd)[symndx];
1234 sym = syms + symndx;
1235 addend = - sym->n_value;
cf9ab45b
AM		 1236
1237 if (NULL == h)
dc810e39
AM		 1238 {
1239 sec = sections[symndx];
1240 /* Hack to make sure we use the right TOC anchor value
1241 if this reloc is against the TOC anchor. */
1242 if (sec->name[3] == '0'
1243 && strcmp (sec->name, ".tc0") == 0)
1244 val = xcoff_data (output_bfd)->toc;
1245 else
1246 val = (sec->output_section->vma
1247 + sec->output_offset
1248 + sym->n_value
1249 - sec->vma);
cf9ab45b
AM		 1250 }
1251 else
dc810e39 1252 {
858ef0ce
RS		 1253 if (info->unresolved_syms_in_objects != RM_IGNORE
1254 && (h->flags & XCOFF_WAS_UNDEFINED) != 0)
1255 {
1256 if (! ((*info->callbacks->undefined_symbol)
1257 (info, h->root.root.string,
1258 input_bfd, input_section,
1259 rel->r_vaddr - input_section->vma,
1260 (info->unresolved_syms_in_objects
1261 == RM_GENERATE_ERROR))))
1262 return FALSE;
1263 }
cf9ab45b
AM		 1264 if (h->root.type == bfd_link_hash_defined
1265 || h->root.type == bfd_link_hash_defweak)
dc810e39 1266 {
dbe341c6
TR		 1267 sec = h->root.u.def.section;
1268 val = (h->root.u.def.value
1269 + sec->output_section->vma
1270 + sec->output_offset);
cf9ab45b
AM		 1271 }
1272 else if (h->root.type == bfd_link_hash_common)
dbe341c6
TR		 1273 {
1274 sec = h->root.u.c.p->section;
1275 val = (sec->output_section->vma
1276 + sec->output_offset);
cf9ab45b 1277 }
858ef0ce 1278 else
dbe341c6 1279 {
858ef0ce
RS		 1280 BFD_ASSERT (info->relocatable
1281 || (h->flags & XCOFF_DEF_DYNAMIC) != 0
1282 || (h->flags & XCOFF_IMPORT) != 0);
dc810e39 1283 }
dc810e39 1284 }
dc810e39 1285 }
cf9ab45b
AM		 1286
1287 if (rel->r_type >= XCOFF_MAX_CALCULATE_RELOCATION
213e90f4 1288 || !((*xcoff64_calculate_relocation[rel->r_type])
cf9ab45b
AM		 1289 (input_bfd, input_section, output_bfd, rel, sym, &howto, val,
1290 addend, &relocation, contents)))
b34976b6 1291 return FALSE;
cf9ab45b 1292
dbe341c6
TR		 1293 /* address */
1294 address = rel->r_vaddr - input_section->vma;
1295 location = contents + address;
cf9ab45b 1296
eea6121a 1297 if (address > input_section->size)
cf9ab45b
AM		 1298 abort ();
1299
dbe341c6
TR		 1300 /* Get the value we are going to relocate. */
1301 if (1 == howto.size)
1302 value_to_relocate = bfd_get_16 (input_bfd, location);
1303 else if (2 == howto.size)
1304 value_to_relocate = bfd_get_32 (input_bfd, location);
cf9ab45b 1305 else
dbe341c6 1306 value_to_relocate = bfd_get_64 (input_bfd, location);
cf9ab45b
AM		 1307
1308 /* overflow.
1309
dbe341c6
TR		 1310 FIXME: We may drop bits during the addition
1311 which we don't check for. We must either check at every single
1312 operation, which would be tedious, or we must do the computations
1313 in a type larger than bfd_vma, which would be inefficient. */
cf9ab45b
AM		 1314
1315 if ((unsigned int) howto.complain_on_overflow
1316 >= XCOFF_MAX_COMPLAIN_OVERFLOW)
1317 abort ();
1318
1319 if (((*xcoff_complain_overflow[howto.complain_on_overflow])
1320 (input_bfd, value_to_relocate, relocation, &howto)))
dc810e39 1321 {
dbe341c6
TR		 1322 const char *name;
1323 char buf[SYMNMLEN + 1];
1324 char reloc_type_name[10];
cf9ab45b
AM		 1325
1326 if (symndx == -1)
beb1bf64 1327 {
dbe341c6 1328 name = "*ABS*";
cf9ab45b
AM		 1329 }
1330 else if (h != NULL)
dbe341c6 1331 {
dfeffb9f 1332 name = NULL;
cf9ab45b
AM		 1333 }
1334 else
beb1bf64 1335 {
dbe341c6
TR		 1336 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
1337 if (name == NULL)
1338 name = "UNKNOWN";
beb1bf64 1339 }
dbe341c6 1340 sprintf (reloc_type_name, "0x%02x", rel->r_type);
cf9ab45b 1341
dbe341c6 1342 if (! ((*info->callbacks->reloc_overflow)
dfeffb9f
L		 1343 (info, (h ? &h->root : NULL), name, reloc_type_name,
1344 (bfd_vma) 0, input_bfd, input_section,
1345 rel->r_vaddr - input_section->vma)))
b34976b6 1346 return FALSE;
beb1bf64
TR		 1347 }
1348
dbe341c6 1349 /* Add RELOCATION to the right bits of VALUE_TO_RELOCATE. */
cf9ab45b
AM		 1350 value_to_relocate = ((value_to_relocate & ~howto.dst_mask)
1351 | (((value_to_relocate & howto.src_mask)
1352 + relocation) & howto.dst_mask));
1353
dbe341c6
TR		 1354 /* Put the value back in the object file. */
1355 if (1 == howto.size)
1356 bfd_put_16 (input_bfd, value_to_relocate, location);
1357 else if (2 == howto.size)
1358 bfd_put_32 (input_bfd, value_to_relocate, location);
1359 else
1360 bfd_put_64 (input_bfd, value_to_relocate, location);
cf9ab45b 1361
beb1bf64 1362 }
b34976b6 1363 return TRUE;
beb1bf64
TR		 1364}
1365
beb1bf64
TR		 1366\f
1367/* The XCOFF reloc table. Actually, XCOFF relocations specify the
1368 bitsize and whether they are signed or not, along with a
1369 conventional type. This table is for the types, which are used for
1370 different algorithms for putting in the reloc. Many of these
1371 relocs need special_function entries, which I have not written. */
1372
beb1bf64
TR		 1373reloc_howto_type xcoff64_howto_table[] =
1374{
7fa9fcb6 1375 /* 0x00: Standard 64 bit relocation. */
38487e5e 1376 HOWTO (R_POS, /* type */
dc810e39
AM		 1377 0, /* rightshift */
1378 4, /* size (0 = byte, 1 = short, 2 = long) */
1379 64, /* bitsize */
b34976b6 1380 FALSE, /* pc_relative */
dc810e39 1381 0, /* bitpos */
beb1bf64 1382 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39 1383 0, /* special_function */
59862849 1384 "R_POS_64", /* name */
b34976b6 1385 TRUE, /* partial_inplace */
a78eab4e 1386 MINUS_ONE, /* src_mask */
dc810e39 1387 MINUS_ONE, /* dst_mask */
b34976b6 1388 FALSE), /* pcrel_offset */
beb1bf64 1389
7fa9fcb6 1390 /* 0x01: 64 bit relocation, but store negative value. */
38487e5e 1391 HOWTO (R_NEG, /* type */
dc810e39
AM		 1392 0, /* rightshift */
1393 -4, /* size (0 = byte, 1 = short, 2 = long) */
1394 64, /* bitsize */
b34976b6 1395 FALSE, /* pc_relative */
dc810e39 1396 0, /* bitpos */
beb1bf64 1397 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1398 0, /* special_function */
1399 "R_NEG", /* name */
b34976b6 1400 TRUE, /* partial_inplace */
a78eab4e 1401 MINUS_ONE, /* src_mask */
dc810e39 1402 MINUS_ONE, /* dst_mask */
b34976b6 1403 FALSE), /* pcrel_offset */
beb1bf64 1404
7fa9fcb6 1405 /* 0x02: 32 bit PC relative relocation. */
38487e5e 1406 HOWTO (R_REL, /* type */
dc810e39
AM		 1407 0, /* rightshift */
1408 2, /* size (0 = byte, 1 = short, 2 = long) */
1409 32, /* bitsize */
b34976b6 1410 TRUE, /* pc_relative */
dc810e39 1411 0, /* bitpos */
beb1bf64 1412 complain_overflow_signed, /* complain_on_overflow */
dc810e39
AM		 1413 0, /* special_function */
1414 "R_REL", /* name */
b34976b6 1415 TRUE, /* partial_inplace */
a78eab4e 1416 0xffffffff, /* src_mask */
dc810e39 1417 0xffffffff, /* dst_mask */
b34976b6 1418 FALSE), /* pcrel_offset */
beb1bf64 1419
7fa9fcb6 1420 /* 0x03: 16 bit TOC relative relocation. */
38487e5e 1421 HOWTO (R_TOC, /* type */
dc810e39
AM		 1422 0, /* rightshift */
1423 1, /* size (0 = byte, 1 = short, 2 = long) */
1424 16, /* bitsize */
b34976b6 1425 FALSE, /* pc_relative */
dc810e39 1426 0, /* bitpos */
beb1bf64 1427 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1428 0, /* special_function */
1429 "R_TOC", /* name */
b34976b6 1430 TRUE, /* partial_inplace */
a78eab4e 1431 0xffff, /* src_mask */
dc810e39 1432 0xffff, /* dst_mask */
b34976b6 1433 FALSE), /* pcrel_offset */
dc810e39 1434
7fa9fcb6 1435 /* 0x04: I don't really know what this is. */
38487e5e 1436 HOWTO (R_RTB, /* type */
dc810e39
AM		 1437 1, /* rightshift */
1438 2, /* size (0 = byte, 1 = short, 2 = long) */
1439 32, /* bitsize */
b34976b6 1440 FALSE, /* pc_relative */
dc810e39 1441 0, /* bitpos */
beb1bf64 1442 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1443 0, /* special_function */
1444 "R_RTB", /* name */
b34976b6 1445 TRUE, /* partial_inplace */
a78eab4e 1446 0xffffffff, /* src_mask */
dc810e39 1447 0xffffffff, /* dst_mask */
b34976b6 1448 FALSE), /* pcrel_offset */
beb1bf64 1449
7fa9fcb6 1450 /* 0x05: External TOC relative symbol. */
38487e5e 1451 HOWTO (R_GL, /* type */
dc810e39 1452 0, /* rightshift */
48bfecdd 1453 1, /* size (0 = byte, 1 = short, 2 = long) */
dc810e39 1454 16, /* bitsize */
b34976b6 1455 FALSE, /* pc_relative */
dc810e39 1456 0, /* bitpos */
beb1bf64 1457 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1458 0, /* special_function */
1459 "R_GL", /* name */
b34976b6 1460 TRUE, /* partial_inplace */
a78eab4e 1461 0xffff, /* src_mask */
dc810e39 1462 0xffff, /* dst_mask */
b34976b6 1463 FALSE), /* pcrel_offset */
dc810e39 1464
7fa9fcb6 1465 /* 0x06: Local TOC relative symbol. */
38487e5e 1466 HOWTO (R_TCL, /* type */
dc810e39 1467 0, /* rightshift */
48bfecdd 1468 1, /* size (0 = byte, 1 = short, 2 = long) */
dc810e39 1469 16, /* bitsize */
b34976b6 1470 FALSE, /* pc_relative */
dc810e39 1471 0, /* bitpos */
beb1bf64 1472 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1473 0, /* special_function */
1474 "R_TCL", /* name */
b34976b6 1475 TRUE, /* partial_inplace */
a78eab4e 1476 0xffff, /* src_mask */
dc810e39 1477 0xffff, /* dst_mask */
b34976b6 1478 FALSE), /* pcrel_offset */
beb1bf64
TR		 1479
1480 EMPTY_HOWTO (7),
1481
7fa9fcb6 1482 /* 0x08: Non modifiable absolute branch. */
38487e5e 1483 HOWTO (R_BA, /* type */
dc810e39
AM		 1484 0, /* rightshift */
1485 2, /* size (0 = byte, 1 = short, 2 = long) */
1486 26, /* bitsize */
b34976b6 1487 FALSE, /* pc_relative */
dc810e39 1488 0, /* bitpos */
beb1bf64 1489 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39 1490 0, /* special_function */
59862849 1491 "R_BA_26", /* name */
b34976b6 1492 TRUE, /* partial_inplace */
a78eab4e 1493 0x03fffffc, /* src_mask */
48bfecdd 1494 0x03fffffc, /* dst_mask */
b34976b6 1495 FALSE), /* pcrel_offset */
beb1bf64
TR		 1496
1497 EMPTY_HOWTO (9),
1498
7fa9fcb6 1499 /* 0x0a: Non modifiable relative branch. */
38487e5e 1500 HOWTO (R_BR, /* type */
dc810e39
AM		 1501 0, /* rightshift */
1502 2, /* size (0 = byte, 1 = short, 2 = long) */
1503 26, /* bitsize */
b34976b6 1504 TRUE, /* pc_relative */
dc810e39 1505 0, /* bitpos */
beb1bf64 1506 complain_overflow_signed, /* complain_on_overflow */
dc810e39
AM		 1507 0, /* special_function */
1508 "R_BR", /* name */
b34976b6 1509 TRUE, /* partial_inplace */
a78eab4e 1510 0x03fffffc, /* src_mask */
48bfecdd 1511 0x03fffffc, /* dst_mask */
b34976b6 1512 FALSE), /* pcrel_offset */
beb1bf64
TR		 1513
1514 EMPTY_HOWTO (0xb),
1515
7fa9fcb6 1516 /* 0x0c: Indirect load. */
38487e5e 1517 HOWTO (R_RL, /* type */
dc810e39 1518 0, /* rightshift */
48bfecdd 1519 1, /* size (0 = byte, 1 = short, 2 = long) */
dc810e39 1520 16, /* bitsize */
b34976b6 1521 FALSE, /* pc_relative */
dc810e39 1522 0, /* bitpos */
beb1bf64 1523 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1524 0, /* special_function */
1525 "R_RL", /* name */
b34976b6 1526 TRUE, /* partial_inplace */
a78eab4e 1527 0xffff, /* src_mask */
dc810e39 1528 0xffff, /* dst_mask */
b34976b6 1529 FALSE), /* pcrel_offset */
beb1bf64 1530
7fa9fcb6 1531 /* 0x0d: Load address. */
38487e5e 1532 HOWTO (R_RLA, /* type */
dc810e39 1533 0, /* rightshift */
48bfecdd 1534 1, /* size (0 = byte, 1 = short, 2 = long) */
dc810e39 1535 16, /* bitsize */
b34976b6 1536 FALSE, /* pc_relative */
dc810e39 1537 0, /* bitpos */
beb1bf64 1538 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1539 0, /* special_function */
1540 "R_RLA", /* name */
b34976b6 1541 TRUE, /* partial_inplace */
a78eab4e 1542 0xffff, /* src_mask */
dc810e39 1543 0xffff, /* dst_mask */
b34976b6 1544 FALSE), /* pcrel_offset */
beb1bf64
TR		 1545
1546 EMPTY_HOWTO (0xe),
1547
7fa9fcb6 1548 /* 0x0f: Non-relocating reference. Bitsize is 1 so that r_rsize is 0. */
38487e5e 1549 HOWTO (R_REF, /* type */
dc810e39 1550 0, /* rightshift */
c865e45b
RS		 1551 0, /* size (0 = byte, 1 = short, 2 = long) */
1552 1, /* bitsize */
b34976b6 1553 FALSE, /* pc_relative */
dc810e39 1554 0, /* bitpos */
a78eab4e 1555 complain_overflow_dont, /* complain_on_overflow */
dc810e39
AM		 1556 0, /* special_function */
1557 "R_REF", /* name */
b34976b6 1558 FALSE, /* partial_inplace */
dc810e39
AM		 1559 0, /* src_mask */
1560 0, /* dst_mask */
b34976b6 1561 FALSE), /* pcrel_offset */
beb1bf64
TR		 1562
1563 EMPTY_HOWTO (0x10),
1564 EMPTY_HOWTO (0x11),
1565
7fa9fcb6 1566 /* 0x12: TOC relative indirect load. */
38487e5e 1567 HOWTO (R_TRL, /* type */
dc810e39 1568 0, /* rightshift */
48bfecdd 1569 1, /* size (0 = byte, 1 = short, 2 = long) */
dc810e39 1570 16, /* bitsize */
b34976b6 1571 FALSE, /* pc_relative */
dc810e39 1572 0, /* bitpos */
beb1bf64 1573 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1574 0, /* special_function */
1575 "R_TRL", /* name */
b34976b6 1576 TRUE, /* partial_inplace */
a78eab4e 1577 0xffff, /* src_mask */
dc810e39 1578 0xffff, /* dst_mask */
b34976b6 1579 FALSE), /* pcrel_offset */
dc810e39 1580
7fa9fcb6 1581 /* 0x13: TOC relative load address. */
38487e5e 1582 HOWTO (R_TRLA, /* type */
dc810e39 1583 0, /* rightshift */
48bfecdd 1584 1, /* size (0 = byte, 1 = short, 2 = long) */
dc810e39 1585 16, /* bitsize */
b34976b6 1586 FALSE, /* pc_relative */
dc810e39 1587 0, /* bitpos */
beb1bf64 1588 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1589 0, /* special_function */
1590 "R_TRLA", /* name */
b34976b6 1591 TRUE, /* partial_inplace */
a78eab4e 1592 0xffff, /* src_mask */
dc810e39 1593 0xffff, /* dst_mask */
b34976b6 1594 FALSE), /* pcrel_offset */
beb1bf64 1595
7fa9fcb6 1596 /* 0x14: Modifiable relative branch. */
38487e5e 1597 HOWTO (R_RRTBI, /* type */
dc810e39
AM		 1598 1, /* rightshift */
1599 2, /* size (0 = byte, 1 = short, 2 = long) */
1600 32, /* bitsize */
b34976b6 1601 FALSE, /* pc_relative */
dc810e39 1602 0, /* bitpos */
beb1bf64 1603 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1604 0, /* special_function */
1605 "R_RRTBI", /* name */
b34976b6 1606 TRUE, /* partial_inplace */
a78eab4e 1607 0xffffffff, /* src_mask */
dc810e39 1608 0xffffffff, /* dst_mask */
b34976b6 1609 FALSE), /* pcrel_offset */
beb1bf64 1610
7fa9fcb6 1611 /* 0x15: Modifiable absolute branch. */
38487e5e 1612 HOWTO (R_RRTBA, /* type */
dc810e39
AM		 1613 1, /* rightshift */
1614 2, /* size (0 = byte, 1 = short, 2 = long) */
1615 32, /* bitsize */
b34976b6 1616 FALSE, /* pc_relative */
dc810e39 1617 0, /* bitpos */
beb1bf64 1618 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1619 0, /* special_function */
1620 "R_RRTBA", /* name */
b34976b6 1621 TRUE, /* partial_inplace */
a78eab4e 1622 0xffffffff, /* src_mask */
dc810e39 1623 0xffffffff, /* dst_mask */
b34976b6 1624 FALSE), /* pcrel_offset */
dc810e39 1625
7fa9fcb6 1626 /* 0x16: Modifiable call absolute indirect. */
38487e5e 1627 HOWTO (R_CAI, /* type */
dc810e39 1628 0, /* rightshift */
48bfecdd 1629 1, /* size (0 = byte, 1 = short, 2 = long) */
dc810e39 1630 16, /* bitsize */
b34976b6 1631 FALSE, /* pc_relative */
dc810e39 1632 0, /* bitpos */
beb1bf64 1633 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1634 0, /* special_function */
1635 "R_CAI", /* name */
b34976b6 1636 TRUE, /* partial_inplace */
a78eab4e 1637 0xffff, /* src_mask */
dc810e39 1638 0xffff, /* dst_mask */
b34976b6 1639 FALSE), /* pcrel_offset */
dc810e39 1640
7fa9fcb6 1641 /* 0x17: Modifiable call relative. */
38487e5e 1642 HOWTO (R_CREL, /* type */
dc810e39 1643 0, /* rightshift */
48bfecdd 1644 1, /* size (0 = byte, 1 = short, 2 = long) */
dc810e39 1645 16, /* bitsize */
b34976b6 1646 FALSE, /* pc_relative */
dc810e39 1647 0, /* bitpos */
beb1bf64 1648 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1649 0, /* special_function */
1650 "R_CREL", /* name */
b34976b6 1651 TRUE, /* partial_inplace */
a78eab4e 1652 0xffff, /* src_mask */
dc810e39 1653 0xffff, /* dst_mask */
b34976b6 1654 FALSE), /* pcrel_offset */
beb1bf64 1655
7fa9fcb6 1656 /* 0x18: Modifiable branch absolute. */
38487e5e 1657 HOWTO (R_RBA, /* type */
dc810e39
AM		 1658 0, /* rightshift */
1659 2, /* size (0 = byte, 1 = short, 2 = long) */
1660 26, /* bitsize */
b34976b6 1661 FALSE, /* pc_relative */
dc810e39 1662 0, /* bitpos */
beb1bf64 1663 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1664 0, /* special_function */
1665 "R_RBA", /* name */
b34976b6 1666 TRUE, /* partial_inplace */
a78eab4e 1667 0x03fffffc, /* src_mask */
48bfecdd 1668 0x03fffffc, /* dst_mask */
b34976b6 1669 FALSE), /* pcrel_offset */
beb1bf64 1670
7fa9fcb6 1671 /* 0x19: Modifiable branch absolute. */
38487e5e 1672 HOWTO (R_RBAC, /* type */
dc810e39
AM		 1673 0, /* rightshift */
1674 2, /* size (0 = byte, 1 = short, 2 = long) */
1675 32, /* bitsize */
b34976b6 1676 FALSE, /* pc_relative */
dc810e39 1677 0, /* bitpos */
beb1bf64 1678 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1679 0, /* special_function */
1680 "R_RBAC", /* name */
b34976b6 1681 TRUE, /* partial_inplace */
a78eab4e 1682 0xffffffff, /* src_mask */
48bfecdd 1683 0xffffffff, /* dst_mask */
b34976b6 1684 FALSE), /* pcrel_offset */
beb1bf64 1685
7fa9fcb6 1686 /* 0x1a: Modifiable branch relative. */
38487e5e 1687 HOWTO (R_RBR, /* type */
dc810e39
AM		 1688 0, /* rightshift */
1689 2, /* size (0 = byte, 1 = short, 2 = long) */
1690 26, /* bitsize */
b34976b6 1691 FALSE, /* pc_relative */
dc810e39 1692 0, /* bitpos */
beb1bf64 1693 complain_overflow_signed, /* complain_on_overflow */
dc810e39 1694 0, /* special_function */
59862849 1695 "R_RBR_26", /* name */
b34976b6 1696 TRUE, /* partial_inplace */
a78eab4e 1697 0x03fffffc, /* src_mask */
48bfecdd 1698 0x03fffffc, /* dst_mask */
b34976b6 1699 FALSE), /* pcrel_offset */
beb1bf64 1700
7fa9fcb6 1701 /* 0x1b: Modifiable branch absolute. */
38487e5e 1702 HOWTO (R_RBRC, /* type */
dc810e39 1703 0, /* rightshift */
48bfecdd 1704 1, /* size (0 = byte, 1 = short, 2 = long) */
dc810e39 1705 16, /* bitsize */
b34976b6 1706 FALSE, /* pc_relative */
dc810e39 1707 0, /* bitpos */
beb1bf64 1708 complain_overflow_bitfield, /* complain_on_overflow */
dc810e39
AM		 1709 0, /* special_function */
1710 "R_RBRC", /* name */
b34976b6 1711 TRUE, /* partial_inplace */
a78eab4e 1712 0xffff, /* src_mask */
dc810e39 1713 0xffff, /* dst_mask */
b34976b6 1714 FALSE), /* pcrel_offset */
dc810e39 1715
7fa9fcb6 1716 /* 0x1c: Standard 32 bit relocation. */
38487e5e 1717 HOWTO (R_POS, /* type */
dc810e39 1718 0, /* rightshift */
59862849
TR		 1719 2, /* size (0 = byte, 1 = short, 2 = long) */
1720 32, /* bitsize */
b34976b6 1721 FALSE, /* pc_relative */
dc810e39
AM		 1722 0, /* bitpos */
1723 complain_overflow_bitfield, /* complain_on_overflow */
1724 0, /* special_function */
59862849 1725 "R_POS_32", /* name */
b34976b6 1726 TRUE, /* partial_inplace */
a78eab4e 1727 0xffffffff, /* src_mask */
59862849 1728 0xffffffff, /* dst_mask */
b34976b6 1729 FALSE), /* pcrel_offset */
ff3a6ee3 1730
7fa9fcb6 1731 /* 0x1d: 16 bit Non modifiable absolute branch. */
54327882
AM		 1732 HOWTO (R_BA, /* type */
1733 0, /* rightshift */
59862849 1734 1, /* size (0 = byte, 1 = short, 2 = long) */
54327882 1735 16, /* bitsize */
b34976b6 1736 FALSE, /* pc_relative */
54327882 1737 0, /* bitpos */
ff3a6ee3 1738 complain_overflow_bitfield, /* complain_on_overflow */
54327882 1739 0, /* special_function */
59862849 1740 "R_BA_16", /* name */
b34976b6 1741 TRUE, /* partial_inplace */
a78eab4e 1742 0xfffc, /* src_mask */
54327882 1743 0xfffc, /* dst_mask */
b34976b6 1744 FALSE), /* pcrel_offset */
59862849 1745
7fa9fcb6 1746 /* 0x1e: Modifiable branch relative. */
cf9ab45b
AM		 1747 HOWTO (R_RBR, /* type */
1748 0, /* rightshift */
1749 1, /* size (0 = byte, 1 = short, 2 = long) */
1750 16, /* bitsize */
7fa9fcb6 1751 TRUE, /* pc_relative */
cf9ab45b 1752 0, /* bitpos */
59862849 1753 complain_overflow_signed, /* complain_on_overflow */
cf9ab45b
AM		 1754 0, /* special_function */
1755 "R_RBR_16", /* name */
b34976b6 1756 TRUE, /* partial_inplace */
7fa9fcb6
TG		 1757 0xfffc, /* src_mask */
1758 0xfffc, /* dst_mask */
b34976b6 1759 FALSE), /* pcrel_offset */
1b164155 1760
7fa9fcb6 1761 /* 0x1f: Modifiable branch absolute. */
1b164155
TR		 1762 HOWTO (R_RBA, /* type */
1763 0, /* rightshift */
1764 1, /* size (0 = byte, 1 = short, 2 = long) */
1765 16, /* bitsize */
b34976b6 1766 FALSE, /* pc_relative */
1b164155
TR		 1767 0, /* bitpos */
1768 complain_overflow_bitfield, /* complain_on_overflow */
1769 0, /* special_function */
1770 "R_RBA_16", /* name */
b34976b6 1771 TRUE, /* partial_inplace */
a78eab4e 1772 0xffff, /* src_mask */
1b164155 1773 0xffff, /* dst_mask */
b34976b6 1774 FALSE), /* pcrel_offset */
1b164155 1775
beb1bf64
TR		 1776};
1777
1778void
4964e065 1779xcoff64_rtype2howto (arelent *relent, struct internal_reloc *internal)
beb1bf64 1780{
59862849 1781 if (internal->r_type > R_RBRC)
beb1bf64
TR		 1782 abort ();
1783
59862849
TR		 1784 /* Default howto layout works most of the time */
1785 relent->howto = &xcoff64_howto_table[internal->r_type];
cf9ab45b 1786
5c4491d3 1787 /* Special case some 16 bit reloc */
59862849
TR		 1788 if (15 == (internal->r_size & 0x3f))
1789 {
cf9ab45b 1790 if (R_BA == internal->r_type)
59862849 1791 relent->howto = &xcoff64_howto_table[0x1d];
cf9ab45b 1792 else if (R_RBR == internal->r_type)
59862849 1793 relent->howto = &xcoff64_howto_table[0x1e];
cf9ab45b 1794 else if (R_RBA == internal->r_type)
1b164155 1795 relent->howto = &xcoff64_howto_table[0x1f];
59862849
TR		 1796 }
1797 /* Special case 32 bit */
1798 else if (31 == (internal->r_size & 0x3f))
1799 {
cf9ab45b 1800 if (R_POS == internal->r_type)
59862849
TR		 1801 relent->howto = &xcoff64_howto_table[0x1c];
1802 }
cf9ab45b 1803
beb1bf64
TR		 1804 /* The r_size field of an XCOFF reloc encodes the bitsize of the
1805 relocation, as well as indicating whether it is signed or not.
1806 Doublecheck that the relocation information gathered from the
1807 type matches this information. The bitsize is not significant
1808 for R_REF relocs. */
1809 if (relent->howto->dst_mask != 0
dc810e39 1810 && (relent->howto->bitsize
beb1bf64
TR		 1811 != ((unsigned int) internal->r_size & 0x3f) + 1))
1812 abort ();
beb1bf64
TR		 1813}
1814
1815reloc_howto_type *
4964e065
TG		 1816xcoff64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1817 bfd_reloc_code_real_type code)
beb1bf64
TR		 1818{
1819 switch (code)
1820 {
1821 case BFD_RELOC_PPC_B26:
1822 return &xcoff64_howto_table[0xa];
ff3a6ee3
TR		 1823 case BFD_RELOC_PPC_BA16:
1824 return &xcoff64_howto_table[0x1d];
beb1bf64
TR		 1825 case BFD_RELOC_PPC_BA26:
1826 return &xcoff64_howto_table[8];
1827 case BFD_RELOC_PPC_TOC16:
1828 return &xcoff64_howto_table[3];
9f6e76f4
TG		 1829 case BFD_RELOC_16:
1830 /* Note that this relocation is only internally used by gas. */
1831 return &xcoff64_howto_table[0xc];
7fa9fcb6
TG		 1832 case BFD_RELOC_PPC_B16:
1833 return &xcoff64_howto_table[0x1e];
beb1bf64
TR		 1834 case BFD_RELOC_32:
1835 case BFD_RELOC_CTOR:
beb1bf64 1836 return &xcoff64_howto_table[0x1c];
59862849
TR		 1837 case BFD_RELOC_64:
1838 return &xcoff64_howto_table[0];
c865e45b
RS		 1839 case BFD_RELOC_NONE:
1840 return &xcoff64_howto_table[0xf];
beb1bf64
TR		 1841 default:
1842 return NULL;
1843 }
1844}
1845
157090f7
AM		 1846static reloc_howto_type *
1847xcoff64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1848 const char *r_name)
1849{
1850 unsigned int i;
1851
1852 for (i = 0;
1853 i < sizeof (xcoff64_howto_table) / sizeof (xcoff64_howto_table[0]);
1854 i++)
1855 if (xcoff64_howto_table[i].name != NULL
1856 && strcasecmp (xcoff64_howto_table[i].name, r_name) == 0)
1857 return &xcoff64_howto_table[i];
1858
1859 return NULL;
1860}
1861
beb1bf64
TR		 1862/* Read in the armap of an XCOFF archive. */
1863
b34976b6 1864static bfd_boolean
4964e065 1865xcoff64_slurp_armap (bfd *abfd)
beb1bf64
TR		 1866{
1867 file_ptr off;
1868 size_t namlen;
dc810e39 1869 bfd_size_type sz, amt;
beb1bf64
TR		 1870 bfd_byte *contents, *cend;
1871 bfd_vma c, i;
1872 carsym *arsym;
1873 bfd_byte *p;
dc810e39 1874 file_ptr pos;
beb1bf64
TR		 1875
1876 /* This is for the new format. */
1877 struct xcoff_ar_hdr_big hdr;
1878
dc810e39
AM		 1879 if (xcoff_ardata (abfd) == NULL)
1880 {
b34976b6
AM		 1881 bfd_has_map (abfd) = FALSE;
1882 return TRUE;
dc810e39 1883 }
beb1bf64 1884
487e54f2
AM		 1885 off = bfd_scan_vma (xcoff_ardata_big (abfd)->symoff64,
1886 (const char **) NULL, 10);
dc810e39
AM		 1887 if (off == 0)
1888 {
b34976b6
AM		 1889 bfd_has_map (abfd) = FALSE;
1890 return TRUE;
dc810e39 1891 }
beb1bf64
TR		 1892
1893 if (bfd_seek (abfd, off, SEEK_SET) != 0)
b34976b6 1894 return FALSE;
beb1bf64
TR		 1895
1896 /* The symbol table starts with a normal archive header. */
4964e065 1897 if (bfd_bread (&hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
dc810e39 1898 != SIZEOF_AR_HDR_BIG)
b34976b6 1899 return FALSE;
beb1bf64
TR		 1900
1901 /* Skip the name (normally empty). */
1902 namlen = strtol (hdr.namlen, (char **) NULL, 10);
dc810e39
AM		 1903 pos = ((namlen + 1) & ~(size_t) 1) + SXCOFFARFMAG;
1904 if (bfd_seek (abfd, pos, SEEK_CUR) != 0)
b34976b6 1905 return FALSE;
beb1bf64 1906
487e54f2 1907 sz = bfd_scan_vma (hdr.size, (const char **) NULL, 10);
beb1bf64
TR		 1908
1909 /* Read in the entire symbol table. */
1910 contents = (bfd_byte *) bfd_alloc (abfd, sz);
1911 if (contents == NULL)
b34976b6 1912 return FALSE;
4964e065 1913 if (bfd_bread (contents, sz, abfd) != sz)
b34976b6 1914 return FALSE;
beb1bf64
TR		 1915
1916 /* The symbol table starts with an eight byte count. */
dc810e39 1917 c = H_GET_64 (abfd, contents);
beb1bf64 1918
dc810e39
AM		 1919 if (c * 8 >= sz)
1920 {
1921 bfd_set_error (bfd_error_bad_value);
b34976b6 1922 return FALSE;
dc810e39
AM		 1923 }
1924 amt = c;
1925 amt *= sizeof (carsym);
1926 bfd_ardata (abfd)->symdefs = (carsym *) bfd_alloc (abfd, amt);
beb1bf64 1927 if (bfd_ardata (abfd)->symdefs == NULL)
b34976b6 1928 return FALSE;
dc810e39 1929
beb1bf64
TR		 1930 /* After the count comes a list of eight byte file offsets. */
1931 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 8;
1932 i < c;
1933 ++i, ++arsym, p += 8)
dc810e39 1934 arsym->file_offset = H_GET_64 (abfd, p);
beb1bf64
TR		 1935
1936 /* After the file offsets come null terminated symbol names. */
1937 cend = contents + sz;
1938 for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
1939 i < c;
1940 ++i, ++arsym, p += strlen ((char *) p) + 1)
1941 {
1942 if (p >= cend)
1943 {
1944 bfd_set_error (bfd_error_bad_value);
b34976b6 1945 return FALSE;
beb1bf64
TR		 1946 }
1947 arsym->name = (char *) p;
1948 }
1949
1950 bfd_ardata (abfd)->symdef_count = c;
b34976b6 1951 bfd_has_map (abfd) = TRUE;
beb1bf64 1952
b34976b6 1953 return TRUE;
beb1bf64
TR		 1954}
1955
1956
beb1bf64
TR		 1957/* See if this is an NEW XCOFF archive. */
1958
814fa6ab 1959static const bfd_target *
4964e065 1960xcoff64_archive_p (bfd *abfd)
beb1bf64 1961{
487e54f2 1962 struct artdata *tdata_hold;
beb1bf64
TR		 1963 char magic[SXCOFFARMAG];
1964 /* This is the new format. */
1965 struct xcoff_ar_file_hdr_big hdr;
dc810e39 1966 bfd_size_type amt = SXCOFFARMAG;
beb1bf64 1967
4964e065 1968 if (bfd_bread (magic, amt, abfd) != amt)
dc810e39
AM		 1969 {
1970 if (bfd_get_error () != bfd_error_system_call)
1971 bfd_set_error (bfd_error_wrong_format);
1972 return NULL;
1973 }
1974
1975 if (strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0)
1976 {
1977 bfd_set_error (bfd_error_wrong_format);
1978 return NULL;
1979 }
beb1bf64 1980
beb1bf64
TR		 1981 /* Copy over the magic string. */
1982 memcpy (hdr.magic, magic, SXCOFFARMAG);
1983
1984 /* Now read the rest of the file header. */
487e54f2 1985 amt = SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG;
4964e065 1986 if (bfd_bread (&hdr.memoff, amt, abfd) != amt)
dc810e39
AM		 1987 {
1988 if (bfd_get_error () != bfd_error_system_call)
1989 bfd_set_error (bfd_error_wrong_format);
1990 return NULL;
1991 }
beb1bf64 1992
487e54f2
AM		 1993 tdata_hold = bfd_ardata (abfd);
1994
1995 amt = sizeof (struct artdata);
1996 bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
1997 if (bfd_ardata (abfd) == (struct artdata *) NULL)
1998 goto error_ret_restore;
1999
9e492e05
JJ		 2000 /* Already cleared by bfd_zalloc above.
2001 bfd_ardata (abfd)->cache = NULL;
2002 bfd_ardata (abfd)->archive_head = NULL;
2003 bfd_ardata (abfd)->symdefs = NULL;
2004 bfd_ardata (abfd)->extended_names = NULL;
2005 bfd_ardata (abfd)->extended_names_size = 0; */
487e54f2
AM		 2006 bfd_ardata (abfd)->first_file_filepos = bfd_scan_vma (hdr.firstmemoff,
2007 (const char **) NULL,
2008 10);
beb1bf64 2009
dc810e39
AM		 2010 amt = SIZEOF_AR_FILE_HDR_BIG;
2011 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
beb1bf64 2012 if (bfd_ardata (abfd)->tdata == NULL)
487e54f2 2013 goto error_ret;
dc810e39 2014
beb1bf64
TR		 2015 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
2016
dc810e39
AM		 2017 if (! xcoff64_slurp_armap (abfd))
2018 {
487e54f2 2019 error_ret:
dc810e39 2020 bfd_release (abfd, bfd_ardata (abfd));
487e54f2
AM		 2021 error_ret_restore:
2022 bfd_ardata (abfd) = tdata_hold;
dc810e39
AM		 2023 return NULL;
2024 }
beb1bf64
TR		 2025
2026 return abfd->xvec;
2027}
2028
2029
2030/* Open the next element in an XCOFF archive. */
2031
814fa6ab 2032static bfd *
4964e065 2033xcoff64_openr_next_archived_file (bfd *archive, bfd *last_file)
beb1bf64 2034{
cf3d882d 2035 bfd_vma filestart;
beb1bf64 2036
dc810e39
AM		 2037 if ((xcoff_ardata (archive) == NULL)
2038 || ! xcoff_big_format_p (archive))
2039 {
2040 bfd_set_error (bfd_error_invalid_operation);
2041 return NULL;
2042 }
beb1bf64 2043
dc810e39
AM		 2044 if (last_file == NULL)
2045 {
beb1bf64 2046 filestart = bfd_ardata (archive)->first_file_filepos;
dc810e39
AM		 2047 }
2048 else
2049 {
487e54f2
AM		 2050 filestart = bfd_scan_vma (arch_xhdr_big (last_file)->nextoff,
2051 (const char **) NULL, 10);
dc810e39 2052 }
487e54f2 2053
beb1bf64 2054 if (filestart == 0
487e54f2
AM		 2055 || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->memoff,
2056 (const char **) NULL, 10)
2057 || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->symoff,
2058 (const char **) NULL, 10))
dc810e39
AM		 2059 {
2060 bfd_set_error (bfd_error_no_more_archived_files);
2061 return NULL;
2062 }
beb1bf64 2063
cf3d882d 2064 return _bfd_get_elt_at_filepos (archive, (file_ptr) filestart);
beb1bf64
TR		 2065}
2066
2067/* We can't use the usual coff_sizeof_headers routine, because AIX
2068 always uses an a.out header. */
2069
814fa6ab 2070static int
a6b96beb
AM		 2071xcoff64_sizeof_headers (bfd *abfd,
2072 struct bfd_link_info *info ATTRIBUTE_UNUSED)
beb1bf64
TR		 2073{
2074 int size;
2075
dc810e39 2076 size = bfd_coff_filhsz (abfd);
beb1bf64 2077
08da05b0 2078 /* Don't think the small aout header can be used since some of the
dc810e39
AM		 2079 old elements have been reordered past the end of the old coff
2080 small aout size. */
beb1bf64
TR		 2081
2082 if (xcoff_data (abfd)->full_aouthdr)
dc810e39 2083 size += bfd_coff_aoutsz (abfd);
beb1bf64 2084
dc810e39 2085 size += abfd->section_count * bfd_coff_scnhsz (abfd);
beb1bf64
TR		 2086 return size;
2087}
2088
beb1bf64 2089static asection *
4964e065
TG		 2090xcoff64_create_csect_from_smclas (bfd *abfd, union internal_auxent *aux,
2091 const char *symbol_name)
beb1bf64
TR		 2092{
2093 asection *return_value = NULL;
2094
dc810e39
AM		 2095 /* Changes from 32 :
2096 .sv == 8, is only for 32 bit programs
2097 .ti == 12 and .tb == 13 are now reserved. */
2098 static const char *names[19] =
2099 {
beb1bf64
TR		 2100 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
2101 NULL, ".bs", ".ds", ".uc", NULL, NULL, NULL, ".tc0",
dc810e39 2102 ".td", ".sv64", ".sv3264"
beb1bf64
TR		 2103 };
2104
dc810e39
AM		 2105 if ((19 >= aux->x_csect.x_smclas)
2106 && (NULL != names[aux->x_csect.x_smclas]))
2107 {
beb1bf64 2108
dc810e39
AM		 2109 return_value = bfd_make_section_anyway
2110 (abfd, names[aux->x_csect.x_smclas]);
beb1bf64 2111
dc810e39
AM		 2112 }
2113 else
2114 {
2115 (*_bfd_error_handler)
d003868e
AM		 2116 (_("%B: symbol `%s' has unrecognized smclas %d"),
2117 abfd, symbol_name, aux->x_csect.x_smclas);
dc810e39
AM		 2118 bfd_set_error (bfd_error_bad_value);
2119 }
beb1bf64
TR		 2120
2121 return return_value;
2122}
2123
b34976b6 2124static bfd_boolean
4964e065
TG		 2125xcoff64_is_lineno_count_overflow (bfd *abfd ATTRIBUTE_UNUSED,
2126 bfd_vma value ATTRIBUTE_UNUSED)
beb1bf64 2127{
b34976b6 2128 return FALSE;
beb1bf64
TR		 2129}
2130
b34976b6 2131static bfd_boolean
4964e065
TG		 2132xcoff64_is_reloc_count_overflow (bfd *abfd ATTRIBUTE_UNUSED,
2133 bfd_vma value ATTRIBUTE_UNUSED)
beb1bf64 2134{
b34976b6 2135 return FALSE;
beb1bf64
TR		 2136}
2137
814fa6ab 2138static bfd_vma
4964e065
TG		 2139xcoff64_loader_symbol_offset (bfd *abfd ATTRIBUTE_UNUSED,
2140 struct internal_ldhdr *ldhdr)
beb1bf64
TR		 2141{
2142 return (ldhdr->l_symoff);
2143}
2144
814fa6ab 2145static bfd_vma
4964e065
TG		 2146xcoff64_loader_reloc_offset (bfd *abfd ATTRIBUTE_UNUSED,
2147 struct internal_ldhdr *ldhdr)
beb1bf64
TR		 2148{
2149 return (ldhdr->l_rldoff);
2150}
2151
b34976b6 2152static bfd_boolean
4964e065 2153xcoff64_bad_format_hook (bfd * abfd, void *filehdr)
eb1e0e80
NC		 2154{
2155 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
2156
2157 /* Check flavor first. */
2158 if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
b34976b6 2159 return FALSE;
eb1e0e80
NC		 2160
2161 if (bfd_xcoff_magic_number (abfd) != internal_f->f_magic)
b34976b6 2162 return FALSE;
eb1e0e80 2163
b34976b6 2164 return TRUE;
eb1e0e80
NC		 2165}
2166
b34976b6 2167static bfd_boolean
4964e065
TG		 2168xcoff64_generate_rtinit (bfd *abfd, const char *init, const char *fini,
2169 bfd_boolean rtld)
9a4c7f16
TR		 2170{
2171 bfd_byte filehdr_ext[FILHSZ];
69f284c7
TR		 2172 bfd_byte scnhdr_ext[SCNHSZ * 3];
2173 bfd_byte syment_ext[SYMESZ * 10];
2174 bfd_byte reloc_ext[RELSZ * 3];
9a4c7f16
TR		 2175 bfd_byte *data_buffer;
2176 bfd_size_type data_buffer_size;
2177 bfd_byte *string_table, *st_tmp;
2178 bfd_size_type string_table_size;
2179 bfd_vma val;
2180 size_t initsz, finisz;
2181 struct internal_filehdr filehdr;
69f284c7
TR		 2182 struct internal_scnhdr text_scnhdr;
2183 struct internal_scnhdr data_scnhdr;
2184 struct internal_scnhdr bss_scnhdr;
9a4c7f16
TR		 2185 struct internal_syment syment;
2186 union internal_auxent auxent;
2187 struct internal_reloc reloc;
54327882 2188
69f284c7 2189 char *text_name = ".text";
9a4c7f16 2190 char *data_name = ".data";
69f284c7 2191 char *bss_name = ".bss";
9a4c7f16 2192 char *rtinit_name = "__rtinit";
69f284c7 2193 char *rtld_name = "__rtld";
54327882 2194
69f284c7 2195 if (! bfd_xcoff_rtinit_size (abfd))
b34976b6 2196 return FALSE;
9a4c7f16
TR		 2197
2198 initsz = (init == NULL ? 0 : 1 + strlen (init));
2199 finisz = (fini == NULL ? 0 : 1 + strlen (fini));
2200
eb1e0e80 2201 /* File header. */
9a4c7f16
TR		 2202 memset (filehdr_ext, 0, FILHSZ);
2203 memset (&filehdr, 0, sizeof (struct internal_filehdr));
2204 filehdr.f_magic = bfd_xcoff_magic_number (abfd);
54327882 2205 filehdr.f_nscns = 3;
9a4c7f16
TR		 2206 filehdr.f_timdat = 0;
2207 filehdr.f_nsyms = 0; /* at least 6, no more than 8 */
2208 filehdr.f_symptr = 0; /* set below */
2209 filehdr.f_opthdr = 0;
2210 filehdr.f_flags = 0;
2211
eb1e0e80 2212 /* Section headers. */
69f284c7
TR		 2213 memset (scnhdr_ext, 0, 3 * SCNHSZ);
2214
eb1e0e80 2215 /* Text. */
69f284c7
TR		 2216 memset (&text_scnhdr, 0, sizeof (struct internal_scnhdr));
2217 memcpy (text_scnhdr.s_name, text_name, strlen (text_name));
2218 text_scnhdr.s_paddr = 0;
2219 text_scnhdr.s_vaddr = 0;
2220 text_scnhdr.s_size = 0;
2221 text_scnhdr.s_scnptr = 0;
2222 text_scnhdr.s_relptr = 0;
2223 text_scnhdr.s_lnnoptr = 0;
2224 text_scnhdr.s_nreloc = 0;
2225 text_scnhdr.s_nlnno = 0;
2226 text_scnhdr.s_flags = STYP_TEXT;
2227
eb1e0e80 2228 /* Data. */
69f284c7
TR		 2229 memset (&data_scnhdr, 0, sizeof (struct internal_scnhdr));
2230 memcpy (data_scnhdr.s_name, data_name, strlen (data_name));
2231 data_scnhdr.s_paddr = 0;
2232 data_scnhdr.s_vaddr = 0;
2233 data_scnhdr.s_size = 0; /* set below */
2234 data_scnhdr.s_scnptr = FILHSZ + 3 * SCNHSZ;
2235 data_scnhdr.s_relptr = 0; /* set below */
2236 data_scnhdr.s_lnnoptr = 0;
2237 data_scnhdr.s_nreloc = 0; /* either 1 or 2 */
2238 data_scnhdr.s_nlnno = 0;
2239 data_scnhdr.s_flags = STYP_DATA;
2240
eb1e0e80 2241 /* Bss. */
69f284c7
TR		 2242 memset (&bss_scnhdr, 0, sizeof (struct internal_scnhdr));
2243 memcpy (bss_scnhdr.s_name, bss_name, strlen (bss_name));
2244 bss_scnhdr.s_paddr = 0; /* set below */
2245 bss_scnhdr.s_vaddr = 0; /* set below */
2246 bss_scnhdr.s_size = 0; /* set below */
2247 bss_scnhdr.s_scnptr = 0;
54327882 2248 bss_scnhdr.s_relptr = 0;
69f284c7
TR		 2249 bss_scnhdr.s_lnnoptr = 0;
2250 bss_scnhdr.s_nreloc = 0;
2251 bss_scnhdr.s_nlnno = 0;
2252 bss_scnhdr.s_flags = STYP_BSS;
9a4c7f16 2253
54327882 2254 /* .data
cf9ab45b
AM		 2255 0x0000 0x00000000 : rtl
2256 0x0004 0x00000000 :
2257 0x0008 0x00000018 : offset to init, or 0
2258 0x000C 0x00000038 : offset to fini, or 0
2259 0x0010 0x00000010 : size of descriptor
2260 0x0014 0x00000000 : pad
2261 0x0018 0x00000000 : init, needs a reloc
2262 0x001C 0x00000000 :
2263 0x0020 0x00000058 : offset to init name
2264 0x0024 0x00000000 : flags, padded to a word
2265 0x0028 0x00000000 : empty init
2266 0x002C 0x00000000 :
2267 0x0030 0x00000000 :
2268 0x0034 0x00000000 :
2269 0x0038 0x00000000 : fini, needs a reloc
2270 0x003C 0x00000000 :
2271 0x0040 0x00000??? : offset to fini name
2272 0x0044 0x00000000 : flags, padded to a word
2273 0x0048 0x00000000 : empty fini
2274 0x004C 0x00000000 :
2275 0x0050 0x00000000 :
2276 0x0054 0x00000000 :
2277 0x0058 init name
9a4c7f16
TR		 2278 0x0058 + initsz fini name */
2279
2280 data_buffer_size = 0x0058 + initsz + finisz;
2a52da53 2281 data_buffer_size = (data_buffer_size + 7) &~ (bfd_size_type) 7;
330693f5 2282 data_buffer = NULL;
9bab7074 2283 data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size);
330693f5 2284 if (data_buffer == NULL)
b34976b6 2285 return FALSE;
54327882 2286
54327882 2287 if (initsz)
9a4c7f16
TR		 2288 {
2289 val = 0x18;
2290 bfd_put_32 (abfd, val, &data_buffer[0x08]);
2291 val = 0x58;
2292 bfd_put_32 (abfd, val, &data_buffer[0x20]);
2293 memcpy (&data_buffer[val], init, initsz);
2294 }
2295
54327882 2296 if (finisz)
9a4c7f16
TR		 2297 {
2298 val = 0x38;
2299 bfd_put_32 (abfd, val, &data_buffer[0x0C]);
2300 val = 0x58 + initsz;
2301 bfd_put_32 (abfd, val, &data_buffer[0x40]);
2302 memcpy (&data_buffer[val], fini, finisz);
2303 }
2304
2305 val = 0x10;
2306 bfd_put_32 (abfd, val, &data_buffer[0x10]);
69f284c7
TR		 2307 data_scnhdr.s_size = data_buffer_size;
2308 bss_scnhdr.s_paddr = bss_scnhdr.s_vaddr = data_scnhdr.s_size;
9a4c7f16 2309
eb1e0e80 2310 /* String table. */
9a4c7f16
TR		 2311 string_table_size = 4;
2312 string_table_size += strlen (data_name) + 1;
2313 string_table_size += strlen (rtinit_name) + 1;
2314 string_table_size += initsz;
2315 string_table_size += finisz;
cf9ab45b 2316 if (rtld)
69f284c7 2317 string_table_size += strlen (rtld_name) + 1;
9a4c7f16 2318
9bab7074
AM		 2319 string_table = (bfd_byte *) bfd_zmalloc (string_table_size);
2320 if (string_table == NULL)
b34976b6 2321 return FALSE;
9bab7074 2322
9a4c7f16
TR		 2323 val = string_table_size;
2324 bfd_put_32 (abfd, val, &string_table[0]);
2325 st_tmp = string_table + 4;
54327882
AM		 2326
2327 /* symbols
9a4c7f16
TR		 2328 0. .data csect
2329 2. __rtinit
54327882
AM		 2330 4. init function
2331 6. fini function
69f284c7
TR		 2332 8. __rtld */
2333 memset (syment_ext, 0, 10 * SYMESZ);
2334 memset (reloc_ext, 0, 3 * RELSZ);
9a4c7f16
TR		 2335
2336 /* .data csect */
2337 memset (&syment, 0, sizeof (struct internal_syment));
2338 memset (&auxent, 0, sizeof (union internal_auxent));
2339
2340 syment._n._n_n._n_offset = st_tmp - string_table;
2341 memcpy (st_tmp, data_name, strlen (data_name));
2342 st_tmp += strlen (data_name) + 1;
2343
69f284c7 2344 syment.n_scnum = 2;
9a4c7f16
TR		 2345 syment.n_sclass = C_HIDEXT;
2346 syment.n_numaux = 1;
2347 auxent.x_csect.x_scnlen.l = data_buffer_size;
2348 auxent.x_csect.x_smtyp = 3 << 3 | XTY_SD;
2349 auxent.x_csect.x_smclas = XMC_RW;
54327882 2350 bfd_coff_swap_sym_out (abfd, &syment,
9a4c7f16 2351 &syment_ext[filehdr.f_nsyms * SYMESZ]);
54327882
AM		 2352 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2353 syment.n_numaux,
9a4c7f16
TR		 2354 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2355 filehdr.f_nsyms += 2;
2356
2357 /* __rtinit */
2358 memset (&syment, 0, sizeof (struct internal_syment));
2359 memset (&auxent, 0, sizeof (union internal_auxent));
2360 syment._n._n_n._n_offset = st_tmp - string_table;
2361 memcpy (st_tmp, rtinit_name, strlen (rtinit_name));
2362 st_tmp += strlen (rtinit_name) + 1;
54327882 2363
69f284c7 2364 syment.n_scnum = 2;
9a4c7f16
TR		 2365 syment.n_sclass = C_EXT;
2366 syment.n_numaux = 1;
2367 auxent.x_csect.x_smtyp = XTY_LD;
2368 auxent.x_csect.x_smclas = XMC_RW;
54327882 2369 bfd_coff_swap_sym_out (abfd, &syment,
9a4c7f16 2370 &syment_ext[filehdr.f_nsyms * SYMESZ]);
54327882
AM		 2371 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2372 syment.n_numaux,
9a4c7f16
TR		 2373 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2374 filehdr.f_nsyms += 2;
2375
eb1e0e80 2376 /* Init. */
54327882 2377 if (initsz)
9a4c7f16
TR		 2378 {
2379 memset (&syment, 0, sizeof (struct internal_syment));
2380 memset (&auxent, 0, sizeof (union internal_auxent));
2381
2382 syment._n._n_n._n_offset = st_tmp - string_table;
2383 memcpy (st_tmp, init, initsz);
2384 st_tmp += initsz;
2385
2386 syment.n_sclass = C_EXT;
2387 syment.n_numaux = 1;
54327882 2388 bfd_coff_swap_sym_out (abfd, &syment,
9a4c7f16 2389 &syment_ext[filehdr.f_nsyms * SYMESZ]);
54327882
AM		 2390 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2391 syment.n_numaux,
9a4c7f16 2392 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
eb1e0e80 2393 /* Reloc. */
9a4c7f16
TR		 2394 memset (&reloc, 0, sizeof (struct internal_reloc));
2395 reloc.r_vaddr = 0x0018;
2396 reloc.r_symndx = filehdr.f_nsyms;
2397 reloc.r_type = R_POS;
2398 reloc.r_size = 63;
2399 bfd_coff_swap_reloc_out (abfd, &reloc, &reloc_ext[0]);
2400
2401 filehdr.f_nsyms += 2;
69f284c7 2402 data_scnhdr.s_nreloc += 1;
9a4c7f16
TR		 2403 }
2404
eb1e0e80 2405 /* Finit. */
54327882 2406 if (finisz)
9a4c7f16
TR		 2407 {
2408 memset (&syment, 0, sizeof (struct internal_syment));
2409 memset (&auxent, 0, sizeof (union internal_auxent));
2410
2411 syment._n._n_n._n_offset = st_tmp - string_table;
2412 memcpy (st_tmp, fini, finisz);
2413 st_tmp += finisz;
2414
2415 syment.n_sclass = C_EXT;
2416 syment.n_numaux = 1;
54327882 2417 bfd_coff_swap_sym_out (abfd, &syment,
9a4c7f16 2418 &syment_ext[filehdr.f_nsyms * SYMESZ]);
54327882
AM		 2419 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2420 syment.n_numaux,
9a4c7f16
TR		 2421 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2422
eb1e0e80 2423 /* Reloc. */
9a4c7f16
TR		 2424 memset (&reloc, 0, sizeof (struct internal_reloc));
2425 reloc.r_vaddr = 0x0038;
2426 reloc.r_symndx = filehdr.f_nsyms;
2427 reloc.r_type = R_POS;
2428 reloc.r_size = 63;
54327882 2429 bfd_coff_swap_reloc_out (abfd, &reloc,
69f284c7 2430 &reloc_ext[data_scnhdr.s_nreloc * RELSZ]);
9a4c7f16
TR		 2431
2432 filehdr.f_nsyms += 2;
69f284c7 2433 data_scnhdr.s_nreloc += 1;
9a4c7f16
TR		 2434 }
2435
69f284c7
TR		 2436 if (rtld)
2437 {
2438 memset (&syment, 0, sizeof (struct internal_syment));
2439 memset (&auxent, 0, sizeof (union internal_auxent));
2440
2441 syment._n._n_n._n_offset = st_tmp - string_table;
2442 memcpy (st_tmp, rtld_name, strlen (rtld_name));
2443 st_tmp += strlen (rtld_name) + 1;
2444
2445 syment.n_sclass = C_EXT;
2446 syment.n_numaux = 1;
54327882 2447 bfd_coff_swap_sym_out (abfd, &syment,
69f284c7 2448 &syment_ext[filehdr.f_nsyms * SYMESZ]);
54327882
AM		 2449 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2450 syment.n_numaux,
69f284c7
TR		 2451 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2452
eb1e0e80 2453 /* Reloc. */
69f284c7
TR		 2454 memset (&reloc, 0, sizeof (struct internal_reloc));
2455 reloc.r_vaddr = 0x0000;
2456 reloc.r_symndx = filehdr.f_nsyms;
2457 reloc.r_type = R_POS;
2458 reloc.r_size = 63;
54327882 2459 bfd_coff_swap_reloc_out (abfd, &reloc,
69f284c7
TR		 2460 &reloc_ext[data_scnhdr.s_nreloc * RELSZ]);
2461
2462 filehdr.f_nsyms += 2;
2463 data_scnhdr.s_nreloc += 1;
2464
2465 bss_scnhdr.s_size = 0;
2466 }
2467
2468 data_scnhdr.s_relptr = data_scnhdr.s_scnptr + data_buffer_size;
2469 filehdr.f_symptr = data_scnhdr.s_relptr + data_scnhdr.s_nreloc * RELSZ;
9a4c7f16
TR		 2470
2471 bfd_coff_swap_filehdr_out (abfd, &filehdr, filehdr_ext);
2472 bfd_bwrite (filehdr_ext, FILHSZ, abfd);
69f284c7
TR		 2473 bfd_coff_swap_scnhdr_out (abfd, &text_scnhdr, &scnhdr_ext[SCNHSZ * 0]);
2474 bfd_coff_swap_scnhdr_out (abfd, &data_scnhdr, &scnhdr_ext[SCNHSZ * 1]);
2475 bfd_coff_swap_scnhdr_out (abfd, &bss_scnhdr, &scnhdr_ext[SCNHSZ * 2]);
2476 bfd_bwrite (scnhdr_ext, 3 * SCNHSZ, abfd);
9a4c7f16 2477 bfd_bwrite (data_buffer, data_buffer_size, abfd);
69f284c7 2478 bfd_bwrite (reloc_ext, data_scnhdr.s_nreloc * RELSZ, abfd);
9a4c7f16
TR		 2479 bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd);
2480 bfd_bwrite (string_table, string_table_size, abfd);
2481
330693f5
TR		 2482 free (data_buffer);
2483 data_buffer = NULL;
2484
b34976b6 2485 return TRUE;
9a4c7f16
TR		 2486}
2487
beb1bf64
TR		 2488/* The typical dynamic reloc. */
2489
2490static reloc_howto_type xcoff64_dynamic_reloc =
dc810e39
AM		 2491HOWTO (0, /* type */
2492 0, /* rightshift */
2493 4, /* size (0 = byte, 1 = short, 2 = long) */
2494 64, /* bitsize */
b34976b6 2495 FALSE, /* pc_relative */
dc810e39
AM		 2496 0, /* bitpos */
2497 complain_overflow_bitfield, /* complain_on_overflow */
2498 0, /* special_function */
2499 "R_POS", /* name */
b34976b6 2500 TRUE, /* partial_inplace */
dc810e39
AM		 2501 MINUS_ONE, /* src_mask */
2502 MINUS_ONE, /* dst_mask */
b34976b6 2503 FALSE); /* pcrel_offset */
beb1bf64
TR		 2504
2505static unsigned long xcoff64_glink_code[10] =
2506{
54327882
AM		 2507 0xe9820000, /* ld r12,0(r2) */
2508 0xf8410028, /* std r2,40(r1) */
2509 0xe80c0000, /* ld r0,0(r12) */
2510 0xe84c0008, /* ld r0,8(r12) */
2511 0x7c0903a6, /* mtctr r0 */
2512 0x4e800420, /* bctr */
2513 0x00000000, /* start of traceback table */
2514 0x000ca000, /* traceback table */
2515 0x00000000, /* traceback table */
2516 0x00000018, /* ??? */
beb1bf64
TR		 2517};
2518
dc810e39 2519static const struct xcoff_backend_data_rec bfd_xcoff_backend_data =
cf9ab45b
AM		 2520 {
2521 { /* COFF backend, defined in libcoff.h. */
2522 _bfd_xcoff64_swap_aux_in,
2523 _bfd_xcoff64_swap_sym_in,
2524 _bfd_xcoff64_swap_lineno_in,
2525 _bfd_xcoff64_swap_aux_out,
2526 _bfd_xcoff64_swap_sym_out,
2527 _bfd_xcoff64_swap_lineno_out,
2528 xcoff64_swap_reloc_out,
2529 coff_swap_filehdr_out,
2530 coff_swap_aouthdr_out,
2531 coff_swap_scnhdr_out,
2532 FILHSZ,
2533 AOUTSZ,
2534 SCNHSZ,
2535 SYMESZ,
2536 AUXESZ,
2537 RELSZ,
2538 LINESZ,
2539 FILNMLEN,
b34976b6 2540 TRUE, /* _bfd_coff_long_filenames */
88183869 2541 XCOFF_NO_LONG_SECTION_NAMES, /* _bfd_coff_long_section_names */
cf9ab45b 2542 3, /* _bfd_coff_default_section_alignment_power */
b34976b6 2543 TRUE, /* _bfd_coff_force_symnames_in_strings */
cf9ab45b 2544 4, /* _bfd_coff_debug_string_prefix_length */
167ad85b 2545 32768, /* _bfd_coff_max_nscns */
cf9ab45b
AM		 2546 coff_swap_filehdr_in,
2547 coff_swap_aouthdr_in,
2548 coff_swap_scnhdr_in,
2549 xcoff64_swap_reloc_in,
2550 xcoff64_bad_format_hook,
2551 coff_set_arch_mach_hook,
2552 coff_mkobject_hook,
2553 styp_to_sec_flags,
2554 coff_set_alignment_hook,
2555 coff_slurp_symbol_table,
2556 symname_in_debug_hook,
2557 coff_pointerize_aux_hook,
2558 coff_print_aux,
2559 dummy_reloc16_extra_cases,
2560 dummy_reloc16_estimate,
e144674a 2561 NULL, /* bfd_coff_symbol_classification */
cf9ab45b
AM		 2562 coff_compute_section_file_positions,
2563 NULL, /* _bfd_coff_start_final_link */
2564 xcoff64_ppc_relocate_section,
2565 coff_rtype_to_howto,
2566 NULL, /* _bfd_coff_adjust_symndx */
2567 _bfd_generic_link_add_one_symbol,
2568 coff_link_output_has_begun,
2b5c217d
NC		 2569 coff_final_link_postscript,
2570 NULL /* print_pdata. */
cf9ab45b
AM		 2571 },
2572
2573 0x01EF, /* magic number */
2574 bfd_arch_powerpc,
2575 bfd_mach_ppc_620,
2576
2577 /* Function pointers to xcoff specific swap routines. */
2578 xcoff64_swap_ldhdr_in,
2579 xcoff64_swap_ldhdr_out,
2580 xcoff64_swap_ldsym_in,
2581 xcoff64_swap_ldsym_out,
2582 xcoff64_swap_ldrel_in,
2583 xcoff64_swap_ldrel_out,
2584
2585 /* Sizes. */
2586 LDHDRSZ,
2587 LDSYMSZ,
2588 LDRELSZ,
2589 24, /* _xcoff_function_descriptor_size */
2590 0, /* _xcoff_small_aout_header_size */
2591
2592 /* Versions. */
2593 2, /* _xcoff_ldhdr_version */
2594
2595 _bfd_xcoff64_put_symbol_name,
2596 _bfd_xcoff64_put_ldsymbol_name,
2597 &xcoff64_dynamic_reloc,
2598 xcoff64_create_csect_from_smclas,
2599
2600 /* Lineno and reloc count overflow. */
2601 xcoff64_is_lineno_count_overflow,
2602 xcoff64_is_reloc_count_overflow,
2603
2604 xcoff64_loader_symbol_offset,
2605 xcoff64_loader_reloc_offset,
2606
2607 /* glink. */
2608 &xcoff64_glink_code[0],
2609 40, /* _xcoff_glink_size */
2610
2611 /* rtinit. */
2612 88, /* _xcoff_rtinit_size */
2613 xcoff64_generate_rtinit,
2614 };
beb1bf64 2615
eb1e0e80 2616/* The transfer vector that leads the outside world to all of the above. */
6d00b590 2617const bfd_target rs6000_xcoff64_vec =
cf9ab45b
AM		 2618 {
2619 "aixcoff64-rs6000",
2620 bfd_target_xcoff_flavour,
2621 BFD_ENDIAN_BIG, /* data byte order is big */
2622 BFD_ENDIAN_BIG, /* header byte order is big */
2623
2624 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
2625 | HAS_SYMS | HAS_LOCALS | WP_TEXT),
2626
a7c71b0c 2627 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
cf9ab45b
AM		 2628 0, /* leading char */
2629 '/', /* ar_pad_char */
2630 15, /* ar_max_namelen */
0aabe54e 2631 0, /* match priority. */
cf9ab45b
AM		 2632
2633 /* data */
2634 bfd_getb64,
2635 bfd_getb_signed_64,
2636 bfd_putb64,
2637 bfd_getb32,
2638 bfd_getb_signed_32,
2639 bfd_putb32,
2640 bfd_getb16,
2641 bfd_getb_signed_16,
2642 bfd_putb16,
2643
2644 /* hdrs */
2645 bfd_getb64,
2646 bfd_getb_signed_64,
2647 bfd_putb64,
2648 bfd_getb32,
2649 bfd_getb_signed_32,
2650 bfd_putb32,
2651 bfd_getb16,
2652 bfd_getb_signed_16,
2653 bfd_putb16,
2654
2655 { /* bfd_check_format */
2656 _bfd_dummy_target,
2657 coff_object_p,
2658 xcoff64_archive_p,
2659 CORE_FILE_P
2660 },
2661
2662 { /* bfd_set_format */
2663 bfd_false,
2664 coff_mkobject,
2665 _bfd_generic_mkarchive,
2666 bfd_false
2667 },
2668
2669 {/* bfd_write_contents */
2670 bfd_false,
2671 xcoff64_write_object_contents,
2672 _bfd_xcoff_write_archive_contents,
2673 bfd_false
2674 },
2675
2676 /* Generic */
329e5cac 2677 _bfd_archive_close_and_cleanup,
cf9ab45b
AM		 2678 bfd_true,
2679 coff_new_section_hook,
2680 _bfd_generic_get_section_contents,
2681 _bfd_generic_get_section_contents_in_window,
2682
2683 /* Copy */
2684 _bfd_xcoff_copy_private_bfd_data,
ac96f0c7 2685 _bfd_generic_bfd_merge_private_bfd_data,
60b48850 2686 _bfd_generic_init_private_section_data,
ac96f0c7
TG		 2687 _bfd_generic_bfd_copy_private_section_data,
2688 _bfd_generic_bfd_copy_private_symbol_data,
2689 _bfd_generic_bfd_copy_private_header_data,
2690 _bfd_generic_bfd_set_private_flags,
2691 _bfd_generic_bfd_print_private_bfd_data,
cf9ab45b
AM		 2692
2693 /* Core */
261b8d08 2694 BFD_JUMP_TABLE_CORE (coff),
cf9ab45b
AM		 2695
2696 /* Archive */
2697 xcoff64_slurp_armap,
ac96f0c7
TG		 2698 _bfd_noarchive_slurp_extended_name_table,
2699 _bfd_noarchive_construct_extended_name_table,
cf9ab45b
AM		 2700 bfd_dont_truncate_arname,
2701 _bfd_xcoff_write_armap,
2702 _bfd_xcoff_read_ar_hdr,
8f95b6e4 2703 _bfd_generic_write_ar_hdr,
cf9ab45b
AM		 2704 xcoff64_openr_next_archived_file,
2705 _bfd_generic_get_elt_at_index,
2706 _bfd_xcoff_stat_arch_elt,
2707 bfd_true,
2708
2709 /* Symbols */
2710 coff_get_symtab_upper_bound,
6cee3f79 2711 coff_canonicalize_symtab,
cf9ab45b
AM		 2712 coff_make_empty_symbol,
2713 coff_print_symbol,
2714 coff_get_symbol_info,
2715 _bfd_xcoff_is_local_label_name,
7db6994f 2716 coff_bfd_is_target_special_symbol,
cf9ab45b
AM		 2717 coff_get_lineno,
2718 coff_find_nearest_line,
9c461f7d 2719 coff_find_line,
4ab527b0 2720 coff_find_inliner_info,
cf9ab45b
AM		 2721 coff_bfd_make_debug_symbol,
2722 _bfd_generic_read_minisymbols,
2723 _bfd_generic_minisymbol_to_symbol,
2724
2725 /* Reloc */
2726 coff_get_reloc_upper_bound,
2727 coff_canonicalize_reloc,
2728 xcoff64_reloc_type_lookup,
157090f7 2729 xcoff64_reloc_name_lookup,
cf9ab45b
AM		 2730
2731 /* Write */
2732 coff_set_arch_mach,
2733 coff_set_section_contents,
2734
2735 /* Link */
2736 xcoff64_sizeof_headers,
2737 bfd_generic_get_relocated_section_contents,
2738 bfd_generic_relax_section,
2739 _bfd_xcoff_bfd_link_hash_table_create,
cf9ab45b
AM		 2740 _bfd_xcoff_bfd_link_add_symbols,
2741 _bfd_generic_link_just_syms,
1338dd10 2742 _bfd_generic_copy_link_hash_symbol_type,
cf9ab45b
AM		 2743 _bfd_xcoff_bfd_final_link,
2744 _bfd_generic_link_split_section,
2745 bfd_generic_gc_sections,
ae17ab41 2746 bfd_generic_lookup_section_flags,
cf9ab45b 2747 bfd_generic_merge_sections,
72adc230 2748 bfd_generic_is_group_section,
cf9ab45b 2749 bfd_generic_discard_group,
082b7297 2750 _bfd_generic_section_already_linked,
3023e3f6 2751 _bfd_xcoff_define_common_symbol,
cf9ab45b
AM		 2752
2753 /* Dynamic */
2754 _bfd_xcoff_get_dynamic_symtab_upper_bound,
2755 _bfd_xcoff_canonicalize_dynamic_symtab,
4c45e5c9 2756 _bfd_nodynamic_get_synthetic_symtab,
cf9ab45b
AM		 2757 _bfd_xcoff_get_dynamic_reloc_upper_bound,
2758 _bfd_xcoff_canonicalize_dynamic_reloc,
2759
2760 /* Opposite endian version, none exists */
2761 NULL,
2762
4964e065 2763 &bfd_xcoff_backend_data,
cf9ab45b 2764 };
eb1e0e80 2765
b34976b6 2766extern const bfd_target *xcoff64_core_p
4964e065 2767 (bfd *);
b34976b6 2768extern bfd_boolean xcoff64_core_file_matches_executable_p
4964e065 2769 (bfd *, bfd *);
b34976b6 2770extern char *xcoff64_core_file_failing_command
4964e065 2771 (bfd *);
b34976b6 2772extern int xcoff64_core_file_failing_signal
4964e065
TG		 2773 (bfd *);
2774#define xcoff64_core_file_pid _bfd_nocore_core_file_pid
eb1e0e80
NC		 2775
2776/* AIX 5 */
54327882 2777static const struct xcoff_backend_data_rec bfd_xcoff_aix5_backend_data =
cf9ab45b
AM		 2778 {
2779 { /* COFF backend, defined in libcoff.h. */
2780 _bfd_xcoff64_swap_aux_in,
2781 _bfd_xcoff64_swap_sym_in,
2782 _bfd_xcoff64_swap_lineno_in,
2783 _bfd_xcoff64_swap_aux_out,
2784 _bfd_xcoff64_swap_sym_out,
2785 _bfd_xcoff64_swap_lineno_out,
2786 xcoff64_swap_reloc_out,
2787 coff_swap_filehdr_out,
2788 coff_swap_aouthdr_out,
2789 coff_swap_scnhdr_out,
2790 FILHSZ,
2791 AOUTSZ,
2792 SCNHSZ,
2793 SYMESZ,
2794 AUXESZ,
2795 RELSZ,
2796 LINESZ,
2797 FILNMLEN,
b34976b6 2798 TRUE, /* _bfd_coff_long_filenames */
88183869 2799 XCOFF_NO_LONG_SECTION_NAMES, /* _bfd_coff_long_section_names */
cf9ab45b 2800 3, /* _bfd_coff_default_section_alignment_power */
b34976b6 2801 TRUE, /* _bfd_coff_force_symnames_in_strings */
cf9ab45b 2802 4, /* _bfd_coff_debug_string_prefix_length */
167ad85b 2803 32768, /* _bfd_coff_max_nscns */
cf9ab45b
AM		 2804 coff_swap_filehdr_in,
2805 coff_swap_aouthdr_in,
2806 coff_swap_scnhdr_in,
2807 xcoff64_swap_reloc_in,
2808 xcoff64_bad_format_hook,
2809 coff_set_arch_mach_hook,
2810 coff_mkobject_hook,
2811 styp_to_sec_flags,
2812 coff_set_alignment_hook,
2813 coff_slurp_symbol_table,
2814 symname_in_debug_hook,
2815 coff_pointerize_aux_hook,
2816 coff_print_aux,
2817 dummy_reloc16_extra_cases,
2818 dummy_reloc16_estimate,
2819 NULL, /* bfd_coff_sym_is_global */
2820 coff_compute_section_file_positions,
2821 NULL, /* _bfd_coff_start_final_link */
2822 xcoff64_ppc_relocate_section,
2823 coff_rtype_to_howto,
2824 NULL, /* _bfd_coff_adjust_symndx */
2825 _bfd_generic_link_add_one_symbol,
2826 coff_link_output_has_begun,
2b5c217d
NC		 2827 coff_final_link_postscript,
2828 NULL /* print_pdata. */
cf9ab45b
AM		 2829 },
2830
2831 U64_TOCMAGIC, /* magic number */
2832 bfd_arch_powerpc,
2833 bfd_mach_ppc_620,
2834
2835 /* Function pointers to xcoff specific swap routines. */
2836 xcoff64_swap_ldhdr_in,
2837 xcoff64_swap_ldhdr_out,
2838 xcoff64_swap_ldsym_in,
2839 xcoff64_swap_ldsym_out,
2840 xcoff64_swap_ldrel_in,
2841 xcoff64_swap_ldrel_out,
2842
2843 /* Sizes. */
2844 LDHDRSZ,
2845 LDSYMSZ,
2846 LDRELSZ,
2847 24, /* _xcoff_function_descriptor_size */
2848 0, /* _xcoff_small_aout_header_size */
2849 /* Versions. */
2850 2, /* _xcoff_ldhdr_version */
2851
2852 _bfd_xcoff64_put_symbol_name,
2853 _bfd_xcoff64_put_ldsymbol_name,
2854 &xcoff64_dynamic_reloc,
2855 xcoff64_create_csect_from_smclas,
2856
2857 /* Lineno and reloc count overflow. */
2858 xcoff64_is_lineno_count_overflow,
2859 xcoff64_is_reloc_count_overflow,
2860
2861 xcoff64_loader_symbol_offset,
2862 xcoff64_loader_reloc_offset,
2863
2864 /* glink. */
2865 &xcoff64_glink_code[0],
2866 40, /* _xcoff_glink_size */
2867
2868 /* rtinit. */
2869 88, /* _xcoff_rtinit_size */
2870 xcoff64_generate_rtinit,
2871 };
eb1e0e80
NC		 2872
2873/* The transfer vector that leads the outside world to all of the above. */
6d00b590 2874const bfd_target rs6000_xcoff64_aix_vec =
cf9ab45b
AM		 2875 {
2876 "aix5coff64-rs6000",
2877 bfd_target_xcoff_flavour,
2878 BFD_ENDIAN_BIG, /* data byte order is big */
2879 BFD_ENDIAN_BIG, /* header byte order is big */
2880
2881 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
2882 | HAS_SYMS | HAS_LOCALS | WP_TEXT),
2883
a7c71b0c 2884 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
cf9ab45b
AM		 2885 0, /* leading char */
2886 '/', /* ar_pad_char */
2887 15, /* ar_max_namelen */
0aabe54e 2888 0, /* match priority. */
cf9ab45b
AM		 2889
2890 /* data */
2891 bfd_getb64,
2892 bfd_getb_signed_64,
2893 bfd_putb64,
2894 bfd_getb32,
2895 bfd_getb_signed_32,
2896 bfd_putb32,
2897 bfd_getb16,
2898 bfd_getb_signed_16,
2899 bfd_putb16,
2900
2901 /* hdrs */
2902 bfd_getb64,
2903 bfd_getb_signed_64,
2904 bfd_putb64,
2905 bfd_getb32,
2906 bfd_getb_signed_32,
2907 bfd_putb32,
2908 bfd_getb16,
2909 bfd_getb_signed_16,
2910 bfd_putb16,
2911
2912 { /* bfd_check_format */
2913 _bfd_dummy_target,
2914 coff_object_p,
2915 xcoff64_archive_p,
2916 xcoff64_core_p
2917 },
2918
2919 { /* bfd_set_format */
2920 bfd_false,
2921 coff_mkobject,
2922 _bfd_generic_mkarchive,
2923 bfd_false
2924 },
2925
2926 {/* bfd_write_contents */
2927 bfd_false,
2928 xcoff64_write_object_contents,
2929 _bfd_xcoff_write_archive_contents,
2930 bfd_false
2931 },
2932
2933 /* Generic */
329e5cac 2934 _bfd_archive_close_and_cleanup,
cf9ab45b
AM		 2935 bfd_true,
2936 coff_new_section_hook,
2937 _bfd_generic_get_section_contents,
2938 _bfd_generic_get_section_contents_in_window,
2939
2940 /* Copy */
2941 _bfd_xcoff_copy_private_bfd_data,
ac96f0c7 2942 _bfd_generic_bfd_merge_private_bfd_data,
60b48850 2943 _bfd_generic_init_private_section_data,
ac96f0c7
TG		 2944 _bfd_generic_bfd_copy_private_section_data,
2945 _bfd_generic_bfd_copy_private_symbol_data,
2946 _bfd_generic_bfd_copy_private_header_data,
2947 _bfd_generic_bfd_set_private_flags,
2948 _bfd_generic_bfd_print_private_bfd_data,
cf9ab45b
AM		 2949
2950 /* Core */
261b8d08 2951 BFD_JUMP_TABLE_CORE (xcoff64),
cf9ab45b
AM		 2952
2953 /* Archive */
2954 xcoff64_slurp_armap,
ac96f0c7
TG		 2955 _bfd_noarchive_slurp_extended_name_table,
2956 _bfd_noarchive_construct_extended_name_table,
cf9ab45b
AM		 2957 bfd_dont_truncate_arname,
2958 _bfd_xcoff_write_armap,
2959 _bfd_xcoff_read_ar_hdr,
8f95b6e4 2960 _bfd_generic_write_ar_hdr,
cf9ab45b
AM		 2961 xcoff64_openr_next_archived_file,
2962 _bfd_generic_get_elt_at_index,
2963 _bfd_xcoff_stat_arch_elt,
2964 bfd_true,
2965
2966 /* Symbols */
2967 coff_get_symtab_upper_bound,
6cee3f79 2968 coff_canonicalize_symtab,
cf9ab45b
AM		 2969 coff_make_empty_symbol,
2970 coff_print_symbol,
2971 coff_get_symbol_info,
2972 _bfd_xcoff_is_local_label_name,
7db6994f 2973 coff_bfd_is_target_special_symbol,
cf9ab45b
AM		 2974 coff_get_lineno,
2975 coff_find_nearest_line,
9c461f7d 2976 coff_find_line,
4ab527b0 2977 coff_find_inliner_info,
cf9ab45b
AM		 2978 coff_bfd_make_debug_symbol,
2979 _bfd_generic_read_minisymbols,
2980 _bfd_generic_minisymbol_to_symbol,
2981
2982 /* Reloc */
2983 coff_get_reloc_upper_bound,
2984 coff_canonicalize_reloc,
2985 xcoff64_reloc_type_lookup,
157090f7 2986 xcoff64_reloc_name_lookup,
cf9ab45b
AM		 2987
2988 /* Write */
2989 coff_set_arch_mach,
2990 coff_set_section_contents,
2991
2992 /* Link */
2993 xcoff64_sizeof_headers,
2994 bfd_generic_get_relocated_section_contents,
2995 bfd_generic_relax_section,
2996 _bfd_xcoff_bfd_link_hash_table_create,
cf9ab45b
AM		 2997 _bfd_xcoff_bfd_link_add_symbols,
2998 _bfd_generic_link_just_syms,
1338dd10 2999 _bfd_generic_copy_link_hash_symbol_type,
cf9ab45b
AM		 3000 _bfd_xcoff_bfd_final_link,
3001 _bfd_generic_link_split_section,
3002 bfd_generic_gc_sections,
ae17ab41 3003 bfd_generic_lookup_section_flags,
cf9ab45b 3004 bfd_generic_merge_sections,
72adc230 3005 bfd_generic_is_group_section,
cf9ab45b 3006 bfd_generic_discard_group,
082b7297 3007 _bfd_generic_section_already_linked,
3023e3f6 3008 _bfd_xcoff_define_common_symbol,
cf9ab45b
AM		 3009
3010 /* Dynamic */
3011 _bfd_xcoff_get_dynamic_symtab_upper_bound,
3012 _bfd_xcoff_canonicalize_dynamic_symtab,
4c45e5c9 3013 _bfd_nodynamic_get_synthetic_symtab,
cf9ab45b
AM		 3014 _bfd_xcoff_get_dynamic_reloc_upper_bound,
3015 _bfd_xcoff_canonicalize_dynamic_reloc,
3016
3017 /* Opposite endian version, none exists. */
3018 NULL,
3019
4964e065 3020 & bfd_xcoff_aix5_backend_data,
cf9ab45b 3021 };
GDB Binutils - Deliverables
This page took 0.801943 seconds and 4 git commands to generate.