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