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