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