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