?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH 47/57][Arm][OBJDUMP] Add support for MVE instructions: vaddv, vmlaldav, vmlada...
[binutils-gdb.git] / bfd / coff64-rs6000.c
blob6f0e358f4acc6d3277257f20f22b051c10bd135b
1 /* BFD back-end for IBM RS/6000 "XCOFF64" files.
2 Copyright (C) 2000-2019 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 const bfd_target *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 bfd_boolean xcoff64_reloc_type_br
181 (XCOFF_RELOC_FUNCTION_ARGS);
182
183 bfd_boolean (*xcoff64_calculate_relocation[XCOFF_MAX_CALCULATE_RELOCATION])
184 (XCOFF_RELOC_FUNCTION_ARGS) =
185 {
186 xcoff_reloc_type_pos, /* R_POS (0x00) */
187 xcoff_reloc_type_neg, /* R_NEG (0x01) */
188 xcoff_reloc_type_rel, /* R_REL (0x02) */
189 xcoff_reloc_type_toc, /* R_TOC (0x03) */
190 xcoff_reloc_type_fail, /* R_RTB (0x04) */
191 xcoff_reloc_type_toc, /* R_GL (0x05) */
192 xcoff_reloc_type_toc, /* R_TCL (0x06) */
193 xcoff_reloc_type_fail, /* (0x07) */
194 xcoff_reloc_type_ba, /* R_BA (0x08) */
195 xcoff_reloc_type_fail, /* (0x09) */
196 xcoff64_reloc_type_br, /* R_BR (0x0a) */
197 xcoff_reloc_type_fail, /* (0x0b) */
198 xcoff_reloc_type_pos, /* R_RL (0x0c) */
199 xcoff_reloc_type_pos, /* R_RLA (0x0d) */
200 xcoff_reloc_type_fail, /* (0x0e) */
201 xcoff_reloc_type_noop, /* R_REF (0x0f) */
202 xcoff_reloc_type_fail, /* (0x10) */
203 xcoff_reloc_type_fail, /* (0x11) */
204 xcoff_reloc_type_toc, /* R_TRL (0x12) */
205 xcoff_reloc_type_toc, /* R_TRLA (0x13) */
206 xcoff_reloc_type_fail, /* R_RRTBI (0x14) */
207 xcoff_reloc_type_fail, /* R_RRTBA (0x15) */
208 xcoff_reloc_type_ba, /* R_CAI (0x16) */
209 xcoff_reloc_type_crel, /* R_CREL (0x17) */
210 xcoff_reloc_type_ba, /* R_RBA (0x18) */
211 xcoff_reloc_type_ba, /* R_RBAC (0x19) */
212 xcoff64_reloc_type_br, /* R_RBR (0x1a) */
213 xcoff_reloc_type_ba, /* R_RBRC (0x1b) */
214 };
215
216 /* coffcode.h needs these to be defined. */
217 /* Internalcoff.h and coffcode.h modify themselves based on these flags. */
218 #define XCOFF64
219 #define RS6000COFF_C 1
220
221 #define SELECT_RELOC(internal, howto) \
222 { \
223 internal.r_type = howto->type; \
224 internal.r_size = \
225 ((howto->complain_on_overflow == complain_overflow_signed \
226 ? 0x80 \
227 : 0) \
228 | (howto->bitsize - 1)); \
229 }
230
231 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
232 #define COFF_LONG_FILENAMES
233 #define NO_COFF_SYMBOLS
234 #define RTYPE2HOWTO(cache_ptr, dst) xcoff64_rtype2howto (cache_ptr, dst)
235 #define coff_mkobject _bfd_xcoff_mkobject
236 #define coff_bfd_copy_private_bfd_data _bfd_xcoff_copy_private_bfd_data
237 #define coff_bfd_is_local_label_name _bfd_xcoff_is_local_label_name
238 #define coff_bfd_reloc_type_lookup xcoff64_reloc_type_lookup
239 #define coff_bfd_reloc_name_lookup xcoff64_reloc_name_lookup
240 #ifdef AIX_CORE
241 extern const bfd_target * rs6000coff_core_p
242 (bfd *abfd);
243 extern bfd_boolean rs6000coff_core_file_matches_executable_p
244 (bfd *cbfd, bfd *ebfd);
245 extern char *rs6000coff_core_file_failing_command
246 (bfd *abfd);
247 extern int rs6000coff_core_file_failing_signal
248 (bfd *abfd);
249 #define CORE_FILE_P rs6000coff_core_p
250 #define coff_core_file_failing_command \
251 rs6000coff_core_file_failing_command
252 #define coff_core_file_failing_signal \
253 rs6000coff_core_file_failing_signal
254 #define coff_core_file_matches_executable_p \
255 rs6000coff_core_file_matches_executable_p
256 #define coff_core_file_pid \
257 _bfd_nocore_core_file_pid
258 #else
259 #define CORE_FILE_P _bfd_dummy_target
260 #define coff_core_file_failing_command \
261 _bfd_nocore_core_file_failing_command
262 #define coff_core_file_failing_signal \
263 _bfd_nocore_core_file_failing_signal
264 #define coff_core_file_matches_executable_p \
265 _bfd_nocore_core_file_matches_executable_p
266 #define coff_core_file_pid \
267 _bfd_nocore_core_file_pid
268 #endif
269 #define coff_SWAP_sym_in _bfd_xcoff64_swap_sym_in
270 #define coff_SWAP_sym_out _bfd_xcoff64_swap_sym_out
271 #define coff_SWAP_aux_in _bfd_xcoff64_swap_aux_in
272 #define coff_SWAP_aux_out _bfd_xcoff64_swap_aux_out
273 #define coff_swap_reloc_in xcoff64_swap_reloc_in
274 #define coff_swap_reloc_out xcoff64_swap_reloc_out
275 #define NO_COFF_RELOCS
276
277 #ifndef bfd_pe_print_pdata
278 #define bfd_pe_print_pdata NULL
279 #endif
280
281 #include "coffcode.h"
282
283 /* For XCOFF64, the effective width of symndx changes depending on
284 whether we are the first entry. Sigh. */
285 static void
286 _bfd_xcoff64_swap_lineno_in (bfd *abfd, void *ext1, void *in1)
287 {
288 LINENO *ext = (LINENO *) ext1;
289 struct internal_lineno *in = (struct internal_lineno *) in1;
290
291 in->l_lnno = H_GET_32 (abfd, (ext->l_lnno));
292 if (in->l_lnno == 0)
293 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
294 else
295 in->l_addr.l_paddr = H_GET_64 (abfd, ext->l_addr.l_paddr);
296 }
297
298 static unsigned int
299 _bfd_xcoff64_swap_lineno_out (bfd *abfd, void *inp, void *outp)
300 {
301 struct internal_lineno *in = (struct internal_lineno *) inp;
302 struct external_lineno *ext = (struct external_lineno *) outp;
303
304 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
305 H_PUT_32 (abfd, in->l_lnno, (ext->l_lnno));
306
307 if (in->l_lnno == 0)
308 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
309 else
310 H_PUT_64 (abfd, in->l_addr.l_paddr, ext->l_addr.l_paddr);
311
312 return bfd_coff_linesz (abfd);
313 }
314
315 static void
316 _bfd_xcoff64_swap_sym_in (bfd *abfd, void *ext1, void *in1)
317 {
318 struct external_syment *ext = (struct external_syment *) ext1;
319 struct internal_syment *in = (struct internal_syment *) in1;
320
321 in->_n._n_n._n_zeroes = 0;
322 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e_offset);
323 in->n_value = H_GET_64 (abfd, ext->e_value);
324 in->n_scnum = (short) H_GET_16 (abfd, ext->e_scnum);
325 in->n_type = H_GET_16 (abfd, ext->e_type);
326 in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
327 in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
328 }
329
330 static unsigned int
331 _bfd_xcoff64_swap_sym_out (bfd *abfd, void *inp, void *extp)
332 {
333 struct internal_syment *in = (struct internal_syment *) inp;
334 struct external_syment *ext = (struct external_syment *) extp;
335
336 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e_offset);
337 H_PUT_64 (abfd, in->n_value, ext->e_value);
338 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
339 H_PUT_16 (abfd, in->n_type, ext->e_type);
340 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
341 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
342 return bfd_coff_symesz (abfd);
343 }
344
345 static void
346 _bfd_xcoff64_swap_aux_in (bfd *abfd, void *ext1, int type, int in_class,
347 int indx, int numaux, void *in1)
348 {
349 union external_auxent *ext = (union external_auxent *) ext1;
350 union internal_auxent *in = (union internal_auxent *) in1;
351
352 switch (in_class)
353 {
354 case C_FILE:
355 if (ext->x_file.x_n.x_n.x_zeroes[0] == 0)
356 {
357 in->x_file.x_n.x_zeroes = 0;
358 in->x_file.x_n.x_offset =
359 H_GET_32 (abfd, ext->x_file.x_n.x_n.x_offset);
360 }
361 else
362 {
363 memcpy (in->x_file.x_fname, ext->x_file.x_n.x_fname, FILNMLEN);
364 }
365 goto end;
366
367 /* RS/6000 "csect" auxents */
368 case C_EXT:
369 case C_AIX_WEAKEXT:
370 case C_HIDEXT:
371 if (indx + 1 == numaux)
372 {
373 bfd_signed_vma h = 0;
374 bfd_vma l = 0;
375
376 h = H_GET_S32 (abfd, ext->x_csect.x_scnlen_hi);
377 l = H_GET_32 (abfd, ext->x_csect.x_scnlen_lo);
378
379 in->x_csect.x_scnlen.l = h << 32 | (l & 0xffffffff);
380
381 in->x_csect.x_parmhash = H_GET_32 (abfd, ext->x_csect.x_parmhash);
382 in->x_csect.x_snhash = H_GET_16 (abfd, ext->x_csect.x_snhash);
383 /* We don't have to hack bitfields in x_smtyp because it's
384 defined by shifts-and-ands, which are equivalent on all
385 byte orders. */
386 in->x_csect.x_smtyp = H_GET_8 (abfd, ext->x_csect.x_smtyp);
387 in->x_csect.x_smclas = H_GET_8 (abfd, ext->x_csect.x_smclas);
388 goto end;
389 }
390 break;
391
392 case C_STAT:
393 case C_LEAFSTAT:
394 case C_HIDDEN:
395 if (type == T_NULL)
396 {
397 /* PE defines some extra fields; we zero them out for
398 safety. */
399 in->x_scn.x_checksum = 0;
400 in->x_scn.x_associated = 0;
401 in->x_scn.x_comdat = 0;
402
403 goto end;
404 }
405 break;
406 }
407
408 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
409 || ISTAG (in_class))
410 {
411 in->x_sym.x_fcnary.x_fcn.x_lnnoptr
412 = H_GET_64 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
413 in->x_sym.x_fcnary.x_fcn.x_endndx.l
414 = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx);
415 }
416 if (ISFCN (type))
417 {
418 in->x_sym.x_misc.x_fsize
419 = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_fsize);
420 }
421 else
422 {
423 in->x_sym.x_misc.x_lnsz.x_lnno
424 = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_lnsz.x_lnno);
425 in->x_sym.x_misc.x_lnsz.x_size
426 = H_GET_16 (abfd, ext->x_sym.x_fcnary.x_lnsz.x_size);
427 }
428
429 end: ;
430 }
431
432 static unsigned int
433 _bfd_xcoff64_swap_aux_out (bfd *abfd, void *inp, int type, int in_class,
434 int indx ATTRIBUTE_UNUSED,
435 int numaux ATTRIBUTE_UNUSED,
436 void *extp)
437 {
438 union internal_auxent *in = (union internal_auxent *) inp;
439 union external_auxent *ext = (union external_auxent *) extp;
440
441 memset (ext, 0, bfd_coff_auxesz (abfd));
442 switch (in_class)
443 {
444 case C_FILE:
445 if (in->x_file.x_n.x_zeroes == 0)
446 {
447 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_n.x_zeroes);
448 H_PUT_32 (abfd, in->x_file.x_n.x_offset,
449 ext->x_file.x_n.x_n.x_offset);
450 }
451 else
452 {
453 memcpy (ext->x_file.x_n.x_fname, in->x_file.x_fname, FILNMLEN);
454 }
455 H_PUT_8 (abfd, _AUX_FILE, ext->x_auxtype.x_auxtype);
456 goto end;
457
458 /* RS/6000 "csect" auxents */
459 case C_EXT:
460 case C_AIX_WEAKEXT:
461 case C_HIDEXT:
462 if (indx + 1 == numaux)
463 {
464 bfd_vma temp;
465
466 temp = in->x_csect.x_scnlen.l & 0xffffffff;
467 H_PUT_32 (abfd, temp, ext->x_csect.x_scnlen_lo);
468 temp = in->x_csect.x_scnlen.l >> 32;
469 H_PUT_32 (abfd, temp, ext->x_csect.x_scnlen_hi);
470 H_PUT_32 (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash);
471 H_PUT_16 (abfd, in->x_csect.x_snhash, ext->x_csect.x_snhash);
472 /* We don't have to hack bitfields in x_smtyp because it's
473 defined by shifts-and-ands, which are equivalent on all
474 byte orders. */
475 H_PUT_8 (abfd, in->x_csect.x_smtyp, ext->x_csect.x_smtyp);
476 H_PUT_8 (abfd, in->x_csect.x_smclas, ext->x_csect.x_smclas);
477 H_PUT_8 (abfd, _AUX_CSECT, ext->x_auxtype.x_auxtype);
478 goto end;
479 }
480 break;
481
482 case C_STAT:
483 case C_LEAFSTAT:
484 case C_HIDDEN:
485 if (type == T_NULL)
486 {
487 goto end;
488 }
489 break;
490 }
491
492 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
493 || ISTAG (in_class))
494 {
495 H_PUT_64 (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,
496 ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
497 H_PUT_8 (abfd, _AUX_FCN,
498 ext->x_auxtype.x_auxtype);
499 H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l,
500 ext->x_sym.x_fcnary.x_fcn.x_endndx);
501 }
502 if (ISFCN (type))
503 {
504 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize,
505 ext->x_sym.x_fcnary.x_fcn.x_fsize);
506 }
507 else
508 {
509 H_PUT_32 (abfd, in->x_sym.x_misc.x_lnsz.x_lnno,
510 ext->x_sym.x_fcnary.x_lnsz.x_lnno);
511 H_PUT_16 (abfd, in->x_sym.x_misc.x_lnsz.x_size,
512 ext->x_sym.x_fcnary.x_lnsz.x_size);
513 }
514
515 end:
516
517 return bfd_coff_auxesz (abfd);
518 }
519
520 static bfd_boolean
521 _bfd_xcoff64_put_symbol_name (struct bfd_link_info *info,
522 struct bfd_strtab_hash *strtab,
523 struct internal_syment *sym,
524 const char *name)
525 {
526 bfd_boolean hash;
527 bfd_size_type indx;
528
529 hash = !info->traditional_format;
530 indx = _bfd_stringtab_add (strtab, name, hash, FALSE);
531
532 if (indx == (bfd_size_type) -1)
533 return FALSE;
534
535 sym->_n._n_n._n_zeroes = 0;
536 sym->_n._n_n._n_offset = STRING_SIZE_SIZE + indx;
537
538 return TRUE;
539 }
540
541 static bfd_boolean
542 _bfd_xcoff64_put_ldsymbol_name (bfd *abfd ATTRIBUTE_UNUSED,
543 struct xcoff_loader_info *ldinfo,
544 struct internal_ldsym *ldsym,
545 const char *name)
546 {
547 size_t len;
548 len = strlen (name);
549
550 if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
551 {
552 bfd_size_type newalc;
553 char *newstrings;
554
555 newalc = ldinfo->string_alc * 2;
556 if (newalc == 0)
557 newalc = 32;
558 while (ldinfo->string_size + len + 3 > newalc)
559 newalc *= 2;
560
561 newstrings = bfd_realloc (ldinfo->strings, newalc);
562 if (newstrings == NULL)
563 {
564 ldinfo->failed = TRUE;
565 return FALSE;
566 }
567 ldinfo->string_alc = newalc;
568 ldinfo->strings = newstrings;
569 }
570
571 bfd_put_16 (ldinfo->output_bfd, (bfd_vma) (len + 1),
572 ldinfo->strings + ldinfo->string_size);
573 strcpy (ldinfo->strings + ldinfo->string_size + 2, name);
574 ldsym->_l._l_l._l_zeroes = 0;
575 ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
576 ldinfo->string_size += len + 3;
577
578 return TRUE;
579 }
580
581 /* Routines to swap information in the XCOFF .loader section. If we
582 ever need to write an XCOFF loader, this stuff will need to be
583 moved to another file shared by the linker (which XCOFF calls the
584 ``binder'') and the loader. */
585
586 /* Swap in the ldhdr structure. */
587
588 static void
589 xcoff64_swap_ldhdr_in (bfd *abfd,
590 const void *s,
591 struct internal_ldhdr *dst)
592 {
593 const struct external_ldhdr *src = (const struct external_ldhdr *) s;
594
595 dst->l_version = bfd_get_32 (abfd, src->l_version);
596 dst->l_nsyms = bfd_get_32 (abfd, src->l_nsyms);
597 dst->l_nreloc = bfd_get_32 (abfd, src->l_nreloc);
598 dst->l_istlen = bfd_get_32 (abfd, src->l_istlen);
599 dst->l_nimpid = bfd_get_32 (abfd, src->l_nimpid);
600 dst->l_stlen = bfd_get_32 (abfd, src->l_stlen);
601 dst->l_impoff = bfd_get_64 (abfd, src->l_impoff);
602 dst->l_stoff = bfd_get_64 (abfd, src->l_stoff);
603 dst->l_symoff = bfd_get_64 (abfd, src->l_symoff);
604 dst->l_rldoff = bfd_get_64 (abfd, src->l_rldoff);
605 }
606
607 /* Swap out the ldhdr structure. */
608
609 static void
610 xcoff64_swap_ldhdr_out (bfd *abfd, const struct internal_ldhdr *src, void *d)
611 {
612 struct external_ldhdr *dst = (struct external_ldhdr *) d;
613
614 bfd_put_32 (abfd, (bfd_vma) src->l_version, dst->l_version);
615 bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
616 bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
617 bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
618 bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
619 bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
620 bfd_put_64 (abfd, src->l_impoff, dst->l_impoff);
621 bfd_put_64 (abfd, src->l_stoff, dst->l_stoff);
622 bfd_put_64 (abfd, src->l_symoff, dst->l_symoff);
623 bfd_put_64 (abfd, src->l_rldoff, dst->l_rldoff);
624 }
625
626 /* Swap in the ldsym structure. */
627
628 static void
629 xcoff64_swap_ldsym_in (bfd *abfd, const void *s, struct internal_ldsym *dst)
630 {
631 const struct external_ldsym *src = (const struct external_ldsym *) s;
632 /* XCOFF64 does not use l_zeroes like XCOFF32
633 Set the internal l_zeroes to 0 so the common 32/64 code uses l_value
634 as an offset into the loader symbol table. */
635 dst->_l._l_l._l_zeroes = 0;
636 dst->_l._l_l._l_offset = bfd_get_32 (abfd, src->l_offset);
637 dst->l_value = bfd_get_64 (abfd, src->l_value);
638 dst->l_scnum = bfd_get_16 (abfd, src->l_scnum);
639 dst->l_smtype = bfd_get_8 (abfd, src->l_smtype);
640 dst->l_smclas = bfd_get_8 (abfd, src->l_smclas);
641 dst->l_ifile = bfd_get_32 (abfd, src->l_ifile);
642 dst->l_parm = bfd_get_32 (abfd, src->l_parm);
643 }
644
645 /* Swap out the ldsym structure. */
646
647 static void
648 xcoff64_swap_ldsym_out (bfd *abfd, const struct internal_ldsym *src, void *d)
649 {
650 struct external_ldsym *dst = (struct external_ldsym *) d;
651
652 bfd_put_64 (abfd, src->l_value, dst->l_value);
653 bfd_put_32 (abfd, (bfd_vma) src->_l._l_l._l_offset, dst->l_offset);
654 bfd_put_16 (abfd, (bfd_vma) src->l_scnum, dst->l_scnum);
655 bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
656 bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
657 bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
658 bfd_put_32 (abfd, src->l_parm, dst->l_parm);
659 }
660
661 static void
662 xcoff64_swap_reloc_in (bfd *abfd, void *s, void *d)
663 {
664 struct external_reloc *src = (struct external_reloc *) s;
665 struct internal_reloc *dst = (struct internal_reloc *) d;
666
667 memset (dst, 0, sizeof (struct internal_reloc));
668
669 dst->r_vaddr = bfd_get_64 (abfd, src->r_vaddr);
670 dst->r_symndx = bfd_get_32 (abfd, src->r_symndx);
671 dst->r_size = bfd_get_8 (abfd, src->r_size);
672 dst->r_type = bfd_get_8 (abfd, src->r_type);
673 }
674
675 static unsigned int
676 xcoff64_swap_reloc_out (bfd *abfd, void *s, void *d)
677 {
678 struct internal_reloc *src = (struct internal_reloc *) s;
679 struct external_reloc *dst = (struct external_reloc *) d;
680
681 bfd_put_64 (abfd, src->r_vaddr, dst->r_vaddr);
682 bfd_put_32 (abfd, src->r_symndx, dst->r_symndx);
683 bfd_put_8 (abfd, src->r_type, dst->r_type);
684 bfd_put_8 (abfd, src->r_size, dst->r_size);
685
686 return bfd_coff_relsz (abfd);
687 }
688
689 /* Swap in the ldrel structure. */
690
691 static void
692 xcoff64_swap_ldrel_in (bfd *abfd, const void *s, struct internal_ldrel *dst)
693 {
694 const struct external_ldrel *src = (const struct external_ldrel *) s;
695
696 dst->l_vaddr = bfd_get_64 (abfd, src->l_vaddr);
697 dst->l_symndx = bfd_get_32 (abfd, src->l_symndx);
698 dst->l_rtype = bfd_get_16 (abfd, src->l_rtype);
699 dst->l_rsecnm = bfd_get_16 (abfd, src->l_rsecnm);
700 }
701
702 /* Swap out the ldrel structure. */
703
704 static void
705 xcoff64_swap_ldrel_out (bfd *abfd, const struct internal_ldrel *src, void *d)
706 {
707 struct external_ldrel *dst = (struct external_ldrel *) d;
708
709 bfd_put_64 (abfd, src->l_vaddr, dst->l_vaddr);
710 bfd_put_16 (abfd, (bfd_vma) src->l_rtype, dst->l_rtype);
711 bfd_put_16 (abfd, (bfd_vma) src->l_rsecnm, dst->l_rsecnm);
712 bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
713 }
714
715 static bfd_boolean
716 xcoff64_write_object_contents (bfd *abfd)
717 {
718 asection *current;
719 bfd_boolean hasrelocs = FALSE;
720 bfd_boolean haslinno = FALSE;
721 file_ptr scn_base;
722 file_ptr reloc_base;
723 file_ptr lineno_base;
724 file_ptr sym_base;
725 unsigned long reloc_size = 0;
726 unsigned long lnno_size = 0;
727 asection *text_sec = NULL;
728 asection *data_sec = NULL;
729 asection *bss_sec = NULL;
730 struct internal_filehdr internal_f;
731 struct internal_aouthdr internal_a;
732
733 bfd_set_error (bfd_error_system_call);
734
735 if (! abfd->output_has_begun)
736 {
737 if (! bfd_coff_compute_section_file_positions (abfd))
738 return FALSE;
739 }
740
741 /* Work out the size of the reloc and linno areas. */
742 reloc_base = obj_relocbase (abfd);
743
744 for (current = abfd->sections; current != NULL; current = current->next)
745 reloc_size += current->reloc_count * bfd_coff_relsz (abfd);
746
747 lineno_base = reloc_base + reloc_size;
748
749 /* Make a pass through the symbol table to count line number entries and
750 put them into the correct asections. */
751 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
752
753 sym_base = lineno_base + lnno_size;
754
755 /* Indicate in each section->line_filepos its actual file address. */
756 for (current = abfd->sections; current != NULL; current = current->next)
757 {
758 if (current->lineno_count)
759 {
760 current->line_filepos = lineno_base;
761 current->moving_line_filepos = lineno_base;
762 lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
763 }
764 else
765 {
766 current->line_filepos = 0;
767 }
768
769 if (current->reloc_count)
770 {
771 current->rel_filepos = reloc_base;
772 reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
773 }
774 else
775 {
776 current->rel_filepos = 0;
777 }
778 }
779
780 if ((abfd->flags & EXEC_P) != 0)
781 {
782 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
783 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
784 }
785 else
786 {
787 scn_base = bfd_coff_filhsz (abfd);
788 internal_f.f_opthdr = 0;
789 }
790
791 internal_f.f_nscns = 0;
792
793 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
794 return FALSE;
795
796 for (current = abfd->sections; current != NULL; current = current->next)
797 {
798 struct internal_scnhdr section;
799 struct external_scnhdr buff;
800 bfd_size_type amount;
801
802 internal_f.f_nscns++;
803
804 strncpy (section.s_name, current->name, SCNNMLEN);
805
806 section.s_vaddr = current->vma;
807 section.s_paddr = current->lma;
808 section.s_size = current->size;
809
810 /* If this section has no size or is unloadable then the scnptr
811 will be 0 too. */
812 if (current->size == 0
813 || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
814 {
815 section.s_scnptr = 0;
816 }
817 else
818 {
819 section.s_scnptr = current->filepos;
820 }
821
822 section.s_relptr = current->rel_filepos;
823 section.s_lnnoptr = current->line_filepos;
824 section.s_nreloc = current->reloc_count;
825
826 section.s_nlnno = current->lineno_count;
827 if (current->reloc_count != 0)
828 hasrelocs = TRUE;
829 if (current->lineno_count != 0)
830 haslinno = TRUE;
831
832 section.s_flags = sec_to_styp_flags (current->name, current->flags);
833
834 if (!strcmp (current->name, _TEXT))
835 {
836 text_sec = current;
837 }
838 else if (!strcmp (current->name, _DATA))
839 {
840 data_sec = current;
841 }
842 else if (!strcmp (current->name, _BSS))
843 {
844 bss_sec = current;
845 }
846
847 amount = bfd_coff_scnhsz (abfd);
848 if (bfd_coff_swap_scnhdr_out (abfd, &section, &buff) == 0
849 || bfd_bwrite (&buff, amount, abfd) != amount)
850 return FALSE;
851 }
852
853 internal_f.f_timdat = 0;
854
855 internal_f.f_flags = 0;
856
857 if (!hasrelocs)
858 internal_f.f_flags |= F_RELFLG;
859 if (!haslinno)
860 internal_f.f_flags |= F_LNNO;
861 if (abfd->flags & EXEC_P)
862 internal_f.f_flags |= F_EXEC;
863
864 /* FIXME: this is wrong for PPC_PE! */
865 if (bfd_little_endian (abfd))
866 internal_f.f_flags |= F_AR32WR;
867 else
868 internal_f.f_flags |= F_AR32W;
869
870 if ((abfd->flags & DYNAMIC) != 0)
871 internal_f.f_flags |= F_SHROBJ;
872 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
873 internal_f.f_flags |= F_DYNLOAD;
874
875 memset (&internal_a, 0, sizeof internal_a);
876
877 internal_f.f_magic = bfd_xcoff_magic_number (abfd);
878 internal_a.magic = (abfd->flags & D_PAGED
879 ? RS6K_AOUTHDR_ZMAGIC
880 : (abfd->flags & WP_TEXT
881 ? RS6K_AOUTHDR_NMAGIC
882 : RS6K_AOUTHDR_OMAGIC));
883
884 /* FIXME: Does anybody ever set this to another value? */
885 internal_a.vstamp = 0;
886
887 /* Now should write relocs, strings, syms. */
888 obj_sym_filepos (abfd) = sym_base;
889
890 internal_f.f_symptr = 0;
891 internal_f.f_nsyms = 0;
892
893 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
894 backend linker, and obj_raw_syment_count is not valid until after
895 coff_write_symbols is called. */
896 if (bfd_get_symcount (abfd) != 0)
897 {
898 int firstundef;
899
900 if (!coff_renumber_symbols (abfd, &firstundef))
901 return FALSE;
902 coff_mangle_symbols (abfd);
903 if (! coff_write_symbols (abfd))
904 return FALSE;
905 if (! coff_write_linenumbers (abfd))
906 return FALSE;
907 if (! coff_write_relocs (abfd, firstundef))
908 return FALSE;
909
910 internal_f.f_symptr = sym_base;
911 internal_f.f_nsyms = bfd_get_symcount (abfd);
912 }
913 else if (obj_raw_syment_count (abfd) != 0)
914 {
915 internal_f.f_symptr = sym_base;
916
917 /* AIX appears to require that F_RELFLG not be set if there are
918 local symbols but no relocations. */
919 internal_f.f_flags &=~ F_RELFLG;
920 }
921 else
922 {
923 internal_f.f_flags |= F_LSYMS;
924 }
925
926 if (text_sec)
927 {
928 internal_a.tsize = text_sec->size;
929 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
930 }
931
932 if (data_sec)
933 {
934 internal_a.dsize = data_sec->size;
935 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
936 }
937
938 if (bss_sec)
939 {
940 internal_a.bsize = bss_sec->size;
941 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
942 internal_a.data_start = bss_sec->vma;
943 }
944
945 internal_a.entry = bfd_get_start_address (abfd);
946 internal_f.f_nsyms = obj_raw_syment_count (abfd);
947
948 if (xcoff_data (abfd)->full_aouthdr)
949 {
950 bfd_vma toc;
951 asection *loader_sec;
952
953 internal_a.vstamp = 1;
954
955 internal_a.o_snentry = xcoff_data (abfd)->snentry;
956 if (internal_a.o_snentry == 0)
957 internal_a.entry = (bfd_vma) -1;
958
959 if (text_sec != NULL)
960 {
961 internal_a.o_sntext = text_sec->target_index;
962 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
963 }
964 else
965 {
966 internal_a.o_sntext = 0;
967 internal_a.o_algntext = 0;
968 }
969
970 if (data_sec != NULL)
971 {
972 internal_a.o_sndata = data_sec->target_index;
973 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
974 }
975 else
976 {
977 internal_a.o_sndata = 0;
978 internal_a.o_algndata = 0;
979 }
980
981 loader_sec = bfd_get_section_by_name (abfd, ".loader");
982 if (loader_sec != NULL)
983 internal_a.o_snloader = loader_sec->target_index;
984 else
985 internal_a.o_snloader = 0;
986 if (bss_sec != NULL)
987 internal_a.o_snbss = bss_sec->target_index;
988 else
989 internal_a.o_snbss = 0;
990
991 toc = xcoff_data (abfd)->toc;
992 internal_a.o_toc = toc;
993 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
994
995 internal_a.o_modtype = xcoff_data (abfd)->modtype;
996 if (xcoff_data (abfd)->cputype != -1)
997 internal_a.o_cputype = xcoff_data (abfd)->cputype;
998 else
999 {
1000 switch (bfd_get_arch (abfd))
1001 {
1002 case bfd_arch_rs6000:
1003 internal_a.o_cputype = 4;
1004 break;
1005 case bfd_arch_powerpc:
1006 if (bfd_get_mach (abfd) == bfd_mach_ppc)
1007 internal_a.o_cputype = 3;
1008 else if (bfd_get_mach (abfd) == bfd_mach_ppc_620)
1009 internal_a.o_cputype = 2;
1010 else
1011 internal_a.o_cputype = 1;
1012 break;
1013 default:
1014 abort ();
1015 }
1016 }
1017 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
1018 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
1019 }
1020
1021 if (bfd_seek (abfd, (file_ptr) 0, 0) != 0)
1022 return FALSE;
1023
1024 {
1025 char * buff;
1026 bfd_size_type amount = bfd_coff_filhsz (abfd);
1027
1028 buff = bfd_malloc (amount);
1029 if (buff == NULL)
1030 return FALSE;
1031
1032 bfd_coff_swap_filehdr_out (abfd, &internal_f, buff);
1033 amount = bfd_bwrite (buff, amount, abfd);
1034
1035 free (buff);
1036
1037 if (amount != bfd_coff_filhsz (abfd))
1038 return FALSE;
1039 }
1040
1041 if (abfd->flags & EXEC_P)
1042 {
1043 char * buff;
1044 bfd_size_type amount = bfd_coff_aoutsz (abfd);
1045
1046 buff = bfd_malloc (amount);
1047 if (buff == NULL)
1048 return FALSE;
1049
1050 bfd_coff_swap_aouthdr_out (abfd, &internal_a, buff);
1051 amount = bfd_bwrite (buff, amount, abfd);
1052
1053 free (buff);
1054
1055 if (amount != bfd_coff_aoutsz (abfd))
1056 return FALSE;
1057 }
1058
1059 return TRUE;
1060 }
1061
1062 static bfd_boolean
1063 xcoff64_reloc_type_br (bfd *input_bfd,
1064 asection *input_section,
1065 bfd *output_bfd ATTRIBUTE_UNUSED,
1066 struct internal_reloc *rel,
1067 struct internal_syment *sym ATTRIBUTE_UNUSED,
1068 struct reloc_howto_struct *howto,
1069 bfd_vma val,
1070 bfd_vma addend,
1071 bfd_vma *relocation,
1072 bfd_byte *contents)
1073 {
1074 struct xcoff_link_hash_entry *h;
1075 bfd_vma section_offset;
1076
1077 if (0 > rel->r_symndx)
1078 return FALSE;
1079
1080 h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
1081 section_offset = rel->r_vaddr - input_section->vma;
1082
1083 /* If we see an R_BR or R_RBR reloc which is jumping to global
1084 linkage code, and it is followed by an appropriate cror nop
1085 instruction, we replace the cror with ld r2,40(r1). This
1086 restores the TOC after the glink code. Contrariwise, if the
1087 call is followed by a ld r2,40(r1), but the call is not
1088 going to global linkage code, we can replace the load with a
1089 cror. */
1090 if (NULL != h
1091 && (bfd_link_hash_defined == h->root.type
1092 || bfd_link_hash_defweak == h->root.type)
1093 && section_offset + 8 <= input_section->size)
1094 {
1095 bfd_byte *pnext;
1096 unsigned long next;
1097
1098 pnext = contents + section_offset + 4;
1099 next = bfd_get_32 (input_bfd, pnext);
1100
1101 /* The _ptrgl function is magic. It is used by the AIX compiler to call
1102 a function through a pointer. */
1103 if (h->smclas == XMC_GL || strcmp (h->root.root.string, "._ptrgl") == 0)
1104 {
1105 if (next == 0x4def7b82 /* cror 15,15,15 */
1106 || next == 0x4ffffb82 /* cror 31,31,31 */
1107 || next == 0x60000000) /* ori r0,r0,0 */
1108 bfd_put_32 (input_bfd, 0xe8410028, pnext); /* ld r2,40(r1) */
1109 }
1110 else
1111 {
1112 if (next == 0xe8410028) /* ld r2,40(r1) */
1113 bfd_put_32 (input_bfd, 0x60000000, pnext); /* ori r0,r0,0 */
1114 }
1115 }
1116 else if (NULL != h && bfd_link_hash_undefined == h->root.type)
1117 {
1118 /* Normally, this relocation is against a defined symbol. In the
1119 case where this is a partial link and the output section offset
1120 is greater than 2^25, the linker will return an invalid error
1121 message that the relocation has been truncated. Yes it has been
1122 truncated but no it not important. For this case, disable the
1123 overflow checking. */
1124 howto->complain_on_overflow = complain_overflow_dont;
1125 }
1126
1127 /* The original PC-relative relocation is biased by -r_vaddr, so adding
1128 the value below will give the absolute target address. */
1129 *relocation = val + addend + rel->r_vaddr;
1130
1131 howto->src_mask &= ~3;
1132 howto->dst_mask = howto->src_mask;
1133
1134 if (h != NULL
1135 && (h->root.type == bfd_link_hash_defined
1136 || h->root.type == bfd_link_hash_defweak)
1137 && bfd_is_abs_section (h->root.u.def.section)
1138 && section_offset + 4 <= input_section->size)
1139 {
1140 bfd_byte *ptr;
1141 bfd_vma insn;
1142
1143 /* Turn the relative branch into an absolute one by setting the
1144 AA bit. */
1145 ptr = contents + section_offset;
1146 insn = bfd_get_32 (input_bfd, ptr);
1147 insn |= 2;
1148 bfd_put_32 (input_bfd, insn, ptr);
1149
1150 /* Make the howto absolute too. */
1151 howto->pc_relative = FALSE;
1152 howto->complain_on_overflow = complain_overflow_bitfield;
1153 }
1154 else
1155 {
1156 /* Use a PC-relative howto and subtract the instruction's address
1157 from the target address we calculated above. */
1158 howto->pc_relative = TRUE;
1159 *relocation -= (input_section->output_section->vma
1160 + input_section->output_offset
1161 + section_offset);
1162 }
1163 return TRUE;
1164 }
1165
1166 /* This is the relocation function for the PowerPC64.
1167 See xcoff_ppc_relocation_section for more information. */
1168
1169 bfd_boolean
1170 xcoff64_ppc_relocate_section (bfd *output_bfd,
1171 struct bfd_link_info *info,
1172 bfd *input_bfd,
1173 asection *input_section,
1174 bfd_byte *contents,
1175 struct internal_reloc *relocs,
1176 struct internal_syment *syms,
1177 asection **sections)
1178 {
1179 struct internal_reloc *rel;
1180 struct internal_reloc *relend;
1181
1182 rel = relocs;
1183 relend = rel + input_section->reloc_count;
1184 for (; rel < relend; rel++)
1185 {
1186 long symndx;
1187 struct xcoff_link_hash_entry *h;
1188 struct internal_syment *sym;
1189 bfd_vma addend;
1190 bfd_vma val;
1191 struct reloc_howto_struct howto;
1192 bfd_vma relocation;
1193 bfd_vma value_to_relocate;
1194 bfd_vma address;
1195 bfd_byte *location;
1196
1197 /* Relocation type R_REF is a special relocation type which is
1198 merely used to prevent garbage collection from occurring for
1199 the csect including the symbol which it references. */
1200 if (rel->r_type == R_REF)
1201 continue;
1202
1203 /* howto */
1204 howto.type = rel->r_type;
1205 howto.rightshift = 0;
1206 howto.bitsize = (rel->r_size & 0x3f) + 1;
1207 howto.size = howto.bitsize > 16 ? (howto.bitsize > 32 ? 4 : 2) : 1;
1208 howto.pc_relative = FALSE;
1209 howto.bitpos = 0;
1210 howto.complain_on_overflow = (rel->r_size & 0x80
1211 ? complain_overflow_signed
1212 : complain_overflow_bitfield);
1213 howto.special_function = NULL;
1214 howto.name = "internal";
1215 howto.partial_inplace = TRUE;
1216 howto.src_mask = howto.dst_mask = N_ONES (howto.bitsize);
1217 howto.pcrel_offset = FALSE;
1218
1219 /* symbol */
1220 val = 0;
1221 addend = 0;
1222 h = NULL;
1223 sym = NULL;
1224 symndx = rel->r_symndx;
1225
1226 if (-1 != symndx)
1227 {
1228 asection *sec;
1229
1230 h = obj_xcoff_sym_hashes (input_bfd)[symndx];
1231 sym = syms + symndx;
1232 addend = - sym->n_value;
1233
1234 if (NULL == h)
1235 {
1236 sec = sections[symndx];
1237 /* Hack to make sure we use the right TOC anchor value
1238 if this reloc is against the TOC anchor. */
1239 if (sec->name[3] == '0'
1240 && strcmp (sec->name, ".tc0") == 0)
1241 val = xcoff_data (output_bfd)->toc;
1242 else
1243 val = (sec->output_section->vma
1244 + sec->output_offset
1245 + sym->n_value
1246 - sec->vma);
1247 }
1248 else
1249 {
1250 if (info->unresolved_syms_in_objects != RM_IGNORE
1251 && (h->flags & XCOFF_WAS_UNDEFINED) != 0)
1252 (*info->callbacks->undefined_symbol)
1253 (info, h->root.root.string, input_bfd, input_section,
1254 rel->r_vaddr - input_section->vma,
1255 info->unresolved_syms_in_objects == RM_GENERATE_ERROR);
1256
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 bfd_has_map (abfd) = 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 bfd_has_map (abfd) = 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
1937 /* Read in the entire symbol table. */
1938 contents = (bfd_byte *) bfd_alloc (abfd, sz);
1939 if (contents == NULL)
1940 return FALSE;
1941 if (bfd_bread (contents, sz, abfd) != sz)
1942 return FALSE;
1943
1944 /* The symbol table starts with an eight byte count. */
1945 c = H_GET_64 (abfd, contents);
1946
1947 if (c * 8 >= sz)
1948 {
1949 bfd_set_error (bfd_error_bad_value);
1950 return FALSE;
1951 }
1952 amt = c;
1953 amt *= sizeof (carsym);
1954 bfd_ardata (abfd)->symdefs = (carsym *) bfd_alloc (abfd, amt);
1955 if (bfd_ardata (abfd)->symdefs == NULL)
1956 return FALSE;
1957
1958 /* After the count comes a list of eight byte file offsets. */
1959 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 8;
1960 i < c;
1961 ++i, ++arsym, p += 8)
1962 arsym->file_offset = H_GET_64 (abfd, p);
1963
1964 /* After the file offsets come null terminated symbol names. */
1965 cend = contents + sz;
1966 for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
1967 i < c;
1968 ++i, ++arsym, p += strlen ((char *) p) + 1)
1969 {
1970 if (p >= cend)
1971 {
1972 bfd_set_error (bfd_error_bad_value);
1973 return FALSE;
1974 }
1975 arsym->name = (char *) p;
1976 }
1977
1978 bfd_ardata (abfd)->symdef_count = c;
1979 bfd_has_map (abfd) = TRUE;
1980
1981 return TRUE;
1982 }
1983
1984
1985 /* See if this is an NEW XCOFF archive. */
1986
1987 static const bfd_target *
1988 xcoff64_archive_p (bfd *abfd)
1989 {
1990 struct artdata *tdata_hold;
1991 char magic[SXCOFFARMAG];
1992 /* This is the new format. */
1993 struct xcoff_ar_file_hdr_big hdr;
1994 bfd_size_type amt = SXCOFFARMAG;
1995
1996 if (bfd_bread (magic, amt, abfd) != amt)
1997 {
1998 if (bfd_get_error () != bfd_error_system_call)
1999 bfd_set_error (bfd_error_wrong_format);
2000 return NULL;
2001 }
2002
2003 if (strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0)
2004 {
2005 bfd_set_error (bfd_error_wrong_format);
2006 return NULL;
2007 }
2008
2009 /* Copy over the magic string. */
2010 memcpy (hdr.magic, magic, SXCOFFARMAG);
2011
2012 /* Now read the rest of the file header. */
2013 amt = SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG;
2014 if (bfd_bread (&hdr.memoff, amt, abfd) != amt)
2015 {
2016 if (bfd_get_error () != bfd_error_system_call)
2017 bfd_set_error (bfd_error_wrong_format);
2018 return NULL;
2019 }
2020
2021 tdata_hold = bfd_ardata (abfd);
2022
2023 amt = sizeof (struct artdata);
2024 bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
2025 if (bfd_ardata (abfd) == (struct artdata *) NULL)
2026 goto error_ret_restore;
2027
2028 /* Already cleared by bfd_zalloc above.
2029 bfd_ardata (abfd)->cache = NULL;
2030 bfd_ardata (abfd)->archive_head = NULL;
2031 bfd_ardata (abfd)->symdefs = NULL;
2032 bfd_ardata (abfd)->extended_names = NULL;
2033 bfd_ardata (abfd)->extended_names_size = 0; */
2034 bfd_ardata (abfd)->first_file_filepos = bfd_scan_vma (hdr.firstmemoff,
2035 (const char **) NULL,
2036 10);
2037
2038 amt = SIZEOF_AR_FILE_HDR_BIG;
2039 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
2040 if (bfd_ardata (abfd)->tdata == NULL)
2041 goto error_ret;
2042
2043 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
2044
2045 if (! xcoff64_slurp_armap (abfd))
2046 {
2047 error_ret:
2048 bfd_release (abfd, bfd_ardata (abfd));
2049 error_ret_restore:
2050 bfd_ardata (abfd) = tdata_hold;
2051 return NULL;
2052 }
2053
2054 return abfd->xvec;
2055 }
2056
2057
2058 /* Open the next element in an XCOFF archive. */
2059
2060 static bfd *
2061 xcoff64_openr_next_archived_file (bfd *archive, bfd *last_file)
2062 {
2063 bfd_vma filestart;
2064
2065 if ((xcoff_ardata (archive) == NULL)
2066 || ! xcoff_big_format_p (archive))
2067 {
2068 bfd_set_error (bfd_error_invalid_operation);
2069 return NULL;
2070 }
2071
2072 if (last_file == NULL)
2073 {
2074 filestart = bfd_ardata (archive)->first_file_filepos;
2075 }
2076 else
2077 {
2078 filestart = bfd_scan_vma (arch_xhdr_big (last_file)->nextoff,
2079 (const char **) NULL, 10);
2080 }
2081
2082 if (filestart == 0
2083 || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->memoff,
2084 (const char **) NULL, 10)
2085 || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->symoff,
2086 (const char **) NULL, 10))
2087 {
2088 bfd_set_error (bfd_error_no_more_archived_files);
2089 return NULL;
2090 }
2091
2092 return _bfd_get_elt_at_filepos (archive, (file_ptr) filestart);
2093 }
2094
2095 /* We can't use the usual coff_sizeof_headers routine, because AIX
2096 always uses an a.out header. */
2097
2098 static int
2099 xcoff64_sizeof_headers (bfd *abfd,
2100 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2101 {
2102 int size;
2103
2104 size = bfd_coff_filhsz (abfd);
2105
2106 /* Don't think the small aout header can be used since some of the
2107 old elements have been reordered past the end of the old coff
2108 small aout size. */
2109
2110 if (xcoff_data (abfd)->full_aouthdr)
2111 size += bfd_coff_aoutsz (abfd);
2112
2113 size += abfd->section_count * bfd_coff_scnhsz (abfd);
2114 return size;
2115 }
2116
2117 static asection *
2118 xcoff64_create_csect_from_smclas (bfd *abfd, union internal_auxent *aux,
2119 const char *symbol_name)
2120 {
2121 asection *return_value = NULL;
2122
2123 /* Changes from 32 :
2124 .sv == 8, is only for 32 bit programs
2125 .ti == 12 and .tb == 13 are now reserved. */
2126 static const char *names[19] =
2127 {
2128 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
2129 NULL, ".bs", ".ds", ".uc", NULL, NULL, NULL, ".tc0",
2130 ".td", ".sv64", ".sv3264"
2131 };
2132
2133 if ((19 >= aux->x_csect.x_smclas)
2134 && (NULL != names[aux->x_csect.x_smclas]))
2135 {
2136
2137 return_value = bfd_make_section_anyway
2138 (abfd, names[aux->x_csect.x_smclas]);
2139
2140 }
2141 else
2142 {
2143 _bfd_error_handler
2144 /* xgettext: c-format */
2145 (_("%pB: symbol `%s' has unrecognized smclas %d"),
2146 abfd, symbol_name, aux->x_csect.x_smclas);
2147 bfd_set_error (bfd_error_bad_value);
2148 }
2149
2150 return return_value;
2151 }
2152
2153 static bfd_boolean
2154 xcoff64_is_lineno_count_overflow (bfd *abfd ATTRIBUTE_UNUSED,
2155 bfd_vma value ATTRIBUTE_UNUSED)
2156 {
2157 return FALSE;
2158 }
2159
2160 static bfd_boolean
2161 xcoff64_is_reloc_count_overflow (bfd *abfd ATTRIBUTE_UNUSED,
2162 bfd_vma value ATTRIBUTE_UNUSED)
2163 {
2164 return FALSE;
2165 }
2166
2167 static bfd_vma
2168 xcoff64_loader_symbol_offset (bfd *abfd ATTRIBUTE_UNUSED,
2169 struct internal_ldhdr *ldhdr)
2170 {
2171 return (ldhdr->l_symoff);
2172 }
2173
2174 static bfd_vma
2175 xcoff64_loader_reloc_offset (bfd *abfd ATTRIBUTE_UNUSED,
2176 struct internal_ldhdr *ldhdr)
2177 {
2178 return (ldhdr->l_rldoff);
2179 }
2180
2181 static bfd_boolean
2182 xcoff64_bad_format_hook (bfd * abfd, void *filehdr)
2183 {
2184 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
2185
2186 /* Check flavor first. */
2187 if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
2188 return FALSE;
2189
2190 if (bfd_xcoff_magic_number (abfd) != internal_f->f_magic)
2191 return FALSE;
2192
2193 return TRUE;
2194 }
2195
2196 static bfd_boolean
2197 xcoff64_generate_rtinit (bfd *abfd, const char *init, const char *fini,
2198 bfd_boolean rtld)
2199 {
2200 bfd_byte filehdr_ext[FILHSZ];
2201 bfd_byte scnhdr_ext[SCNHSZ * 3];
2202 bfd_byte syment_ext[SYMESZ * 10];
2203 bfd_byte reloc_ext[RELSZ * 3];
2204 bfd_byte *data_buffer;
2205 bfd_size_type data_buffer_size;
2206 bfd_byte *string_table, *st_tmp;
2207 bfd_size_type string_table_size;
2208 bfd_vma val;
2209 size_t initsz, finisz;
2210 struct internal_filehdr filehdr;
2211 struct internal_scnhdr text_scnhdr;
2212 struct internal_scnhdr data_scnhdr;
2213 struct internal_scnhdr bss_scnhdr;
2214 struct internal_syment syment;
2215 union internal_auxent auxent;
2216 struct internal_reloc reloc;
2217
2218 char *text_name = ".text";
2219 char *data_name = ".data";
2220 char *bss_name = ".bss";
2221 char *rtinit_name = "__rtinit";
2222 char *rtld_name = "__rtld";
2223
2224 if (! bfd_xcoff_rtinit_size (abfd))
2225 return FALSE;
2226
2227 initsz = (init == NULL ? 0 : 1 + strlen (init));
2228 finisz = (fini == NULL ? 0 : 1 + strlen (fini));
2229
2230 /* File header. */
2231 memset (filehdr_ext, 0, FILHSZ);
2232 memset (&filehdr, 0, sizeof (struct internal_filehdr));
2233 filehdr.f_magic = bfd_xcoff_magic_number (abfd);
2234 filehdr.f_nscns = 3;
2235 filehdr.f_timdat = 0;
2236 filehdr.f_nsyms = 0; /* at least 6, no more than 8 */
2237 filehdr.f_symptr = 0; /* set below */
2238 filehdr.f_opthdr = 0;
2239 filehdr.f_flags = 0;
2240
2241 /* Section headers. */
2242 memset (scnhdr_ext, 0, 3 * SCNHSZ);
2243
2244 /* Text. */
2245 memset (&text_scnhdr, 0, sizeof (struct internal_scnhdr));
2246 memcpy (text_scnhdr.s_name, text_name, strlen (text_name));
2247 text_scnhdr.s_paddr = 0;
2248 text_scnhdr.s_vaddr = 0;
2249 text_scnhdr.s_size = 0;
2250 text_scnhdr.s_scnptr = 0;
2251 text_scnhdr.s_relptr = 0;
2252 text_scnhdr.s_lnnoptr = 0;
2253 text_scnhdr.s_nreloc = 0;
2254 text_scnhdr.s_nlnno = 0;
2255 text_scnhdr.s_flags = STYP_TEXT;
2256
2257 /* Data. */
2258 memset (&data_scnhdr, 0, sizeof (struct internal_scnhdr));
2259 memcpy (data_scnhdr.s_name, data_name, strlen (data_name));
2260 data_scnhdr.s_paddr = 0;
2261 data_scnhdr.s_vaddr = 0;
2262 data_scnhdr.s_size = 0; /* set below */
2263 data_scnhdr.s_scnptr = FILHSZ + 3 * SCNHSZ;
2264 data_scnhdr.s_relptr = 0; /* set below */
2265 data_scnhdr.s_lnnoptr = 0;
2266 data_scnhdr.s_nreloc = 0; /* either 1 or 2 */
2267 data_scnhdr.s_nlnno = 0;
2268 data_scnhdr.s_flags = STYP_DATA;
2269
2270 /* Bss. */
2271 memset (&bss_scnhdr, 0, sizeof (struct internal_scnhdr));
2272 memcpy (bss_scnhdr.s_name, bss_name, strlen (bss_name));
2273 bss_scnhdr.s_paddr = 0; /* set below */
2274 bss_scnhdr.s_vaddr = 0; /* set below */
2275 bss_scnhdr.s_size = 0; /* set below */
2276 bss_scnhdr.s_scnptr = 0;
2277 bss_scnhdr.s_relptr = 0;
2278 bss_scnhdr.s_lnnoptr = 0;
2279 bss_scnhdr.s_nreloc = 0;
2280 bss_scnhdr.s_nlnno = 0;
2281 bss_scnhdr.s_flags = STYP_BSS;
2282
2283 /* .data
2284 0x0000 0x00000000 : rtl
2285 0x0004 0x00000000 :
2286 0x0008 0x00000018 : offset to init, or 0
2287 0x000C 0x00000038 : offset to fini, or 0
2288 0x0010 0x00000010 : size of descriptor
2289 0x0014 0x00000000 : pad
2290 0x0018 0x00000000 : init, needs a reloc
2291 0x001C 0x00000000 :
2292 0x0020 0x00000058 : offset to init name
2293 0x0024 0x00000000 : flags, padded to a word
2294 0x0028 0x00000000 : empty init
2295 0x002C 0x00000000 :
2296 0x0030 0x00000000 :
2297 0x0034 0x00000000 :
2298 0x0038 0x00000000 : fini, needs a reloc
2299 0x003C 0x00000000 :
2300 0x0040 0x00000??? : offset to fini name
2301 0x0044 0x00000000 : flags, padded to a word
2302 0x0048 0x00000000 : empty fini
2303 0x004C 0x00000000 :
2304 0x0050 0x00000000 :
2305 0x0054 0x00000000 :
2306 0x0058 init name
2307 0x0058 + initsz fini name */
2308
2309 data_buffer_size = 0x0058 + initsz + finisz;
2310 data_buffer_size = (data_buffer_size + 7) &~ (bfd_size_type) 7;
2311 data_buffer = NULL;
2312 data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size);
2313 if (data_buffer == NULL)
2314 return FALSE;
2315
2316 if (initsz)
2317 {
2318 val = 0x18;
2319 bfd_put_32 (abfd, val, &data_buffer[0x08]);
2320 val = 0x58;
2321 bfd_put_32 (abfd, val, &data_buffer[0x20]);
2322 memcpy (&data_buffer[val], init, initsz);
2323 }
2324
2325 if (finisz)
2326 {
2327 val = 0x38;
2328 bfd_put_32 (abfd, val, &data_buffer[0x0C]);
2329 val = 0x58 + initsz;
2330 bfd_put_32 (abfd, val, &data_buffer[0x40]);
2331 memcpy (&data_buffer[val], fini, finisz);
2332 }
2333
2334 val = 0x10;
2335 bfd_put_32 (abfd, val, &data_buffer[0x10]);
2336 data_scnhdr.s_size = data_buffer_size;
2337 bss_scnhdr.s_paddr = bss_scnhdr.s_vaddr = data_scnhdr.s_size;
2338
2339 /* String table. */
2340 string_table_size = 4;
2341 string_table_size += strlen (data_name) + 1;
2342 string_table_size += strlen (rtinit_name) + 1;
2343 string_table_size += initsz;
2344 string_table_size += finisz;
2345 if (rtld)
2346 string_table_size += strlen (rtld_name) + 1;
2347
2348 string_table = (bfd_byte *) bfd_zmalloc (string_table_size);
2349 if (string_table == NULL)
2350 return FALSE;
2351
2352 val = string_table_size;
2353 bfd_put_32 (abfd, val, &string_table[0]);
2354 st_tmp = string_table + 4;
2355
2356 /* symbols
2357 0. .data csect
2358 2. __rtinit
2359 4. init function
2360 6. fini function
2361 8. __rtld */
2362 memset (syment_ext, 0, 10 * SYMESZ);
2363 memset (reloc_ext, 0, 3 * RELSZ);
2364
2365 /* .data csect */
2366 memset (&syment, 0, sizeof (struct internal_syment));
2367 memset (&auxent, 0, sizeof (union internal_auxent));
2368
2369 syment._n._n_n._n_offset = st_tmp - string_table;
2370 memcpy (st_tmp, data_name, strlen (data_name));
2371 st_tmp += strlen (data_name) + 1;
2372
2373 syment.n_scnum = 2;
2374 syment.n_sclass = C_HIDEXT;
2375 syment.n_numaux = 1;
2376 auxent.x_csect.x_scnlen.l = data_buffer_size;
2377 auxent.x_csect.x_smtyp = 3 << 3 | XTY_SD;
2378 auxent.x_csect.x_smclas = XMC_RW;
2379 bfd_coff_swap_sym_out (abfd, &syment,
2380 &syment_ext[filehdr.f_nsyms * SYMESZ]);
2381 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2382 syment.n_numaux,
2383 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2384 filehdr.f_nsyms += 2;
2385
2386 /* __rtinit */
2387 memset (&syment, 0, sizeof (struct internal_syment));
2388 memset (&auxent, 0, sizeof (union internal_auxent));
2389 syment._n._n_n._n_offset = st_tmp - string_table;
2390 memcpy (st_tmp, rtinit_name, strlen (rtinit_name));
2391 st_tmp += strlen (rtinit_name) + 1;
2392
2393 syment.n_scnum = 2;
2394 syment.n_sclass = C_EXT;
2395 syment.n_numaux = 1;
2396 auxent.x_csect.x_smtyp = XTY_LD;
2397 auxent.x_csect.x_smclas = XMC_RW;
2398 bfd_coff_swap_sym_out (abfd, &syment,
2399 &syment_ext[filehdr.f_nsyms * SYMESZ]);
2400 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2401 syment.n_numaux,
2402 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2403 filehdr.f_nsyms += 2;
2404
2405 /* Init. */
2406 if (initsz)
2407 {
2408 memset (&syment, 0, sizeof (struct internal_syment));
2409 memset (&auxent, 0, sizeof (union internal_auxent));
2410
2411 syment._n._n_n._n_offset = st_tmp - string_table;
2412 memcpy (st_tmp, init, initsz);
2413 st_tmp += initsz;
2414
2415 syment.n_sclass = C_EXT;
2416 syment.n_numaux = 1;
2417 bfd_coff_swap_sym_out (abfd, &syment,
2418 &syment_ext[filehdr.f_nsyms * SYMESZ]);
2419 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2420 syment.n_numaux,
2421 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2422 /* Reloc. */
2423 memset (&reloc, 0, sizeof (struct internal_reloc));
2424 reloc.r_vaddr = 0x0018;
2425 reloc.r_symndx = filehdr.f_nsyms;
2426 reloc.r_type = R_POS;
2427 reloc.r_size = 63;
2428 bfd_coff_swap_reloc_out (abfd, &reloc, &reloc_ext[0]);
2429
2430 filehdr.f_nsyms += 2;
2431 data_scnhdr.s_nreloc += 1;
2432 }
2433
2434 /* Finit. */
2435 if (finisz)
2436 {
2437 memset (&syment, 0, sizeof (struct internal_syment));
2438 memset (&auxent, 0, sizeof (union internal_auxent));
2439
2440 syment._n._n_n._n_offset = st_tmp - string_table;
2441 memcpy (st_tmp, fini, finisz);
2442 st_tmp += finisz;
2443
2444 syment.n_sclass = C_EXT;
2445 syment.n_numaux = 1;
2446 bfd_coff_swap_sym_out (abfd, &syment,
2447 &syment_ext[filehdr.f_nsyms * SYMESZ]);
2448 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2449 syment.n_numaux,
2450 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2451
2452 /* Reloc. */
2453 memset (&reloc, 0, sizeof (struct internal_reloc));
2454 reloc.r_vaddr = 0x0038;
2455 reloc.r_symndx = filehdr.f_nsyms;
2456 reloc.r_type = R_POS;
2457 reloc.r_size = 63;
2458 bfd_coff_swap_reloc_out (abfd, &reloc,
2459 &reloc_ext[data_scnhdr.s_nreloc * RELSZ]);
2460
2461 filehdr.f_nsyms += 2;
2462 data_scnhdr.s_nreloc += 1;
2463 }
2464
2465 if (rtld)
2466 {
2467 memset (&syment, 0, sizeof (struct internal_syment));
2468 memset (&auxent, 0, sizeof (union internal_auxent));
2469
2470 syment._n._n_n._n_offset = st_tmp - string_table;
2471 memcpy (st_tmp, rtld_name, strlen (rtld_name));
2472 st_tmp += strlen (rtld_name) + 1;
2473
2474 syment.n_sclass = C_EXT;
2475 syment.n_numaux = 1;
2476 bfd_coff_swap_sym_out (abfd, &syment,
2477 &syment_ext[filehdr.f_nsyms * SYMESZ]);
2478 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2479 syment.n_numaux,
2480 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2481
2482 /* Reloc. */
2483 memset (&reloc, 0, sizeof (struct internal_reloc));
2484 reloc.r_vaddr = 0x0000;
2485 reloc.r_symndx = filehdr.f_nsyms;
2486 reloc.r_type = R_POS;
2487 reloc.r_size = 63;
2488 bfd_coff_swap_reloc_out (abfd, &reloc,
2489 &reloc_ext[data_scnhdr.s_nreloc * RELSZ]);
2490
2491 filehdr.f_nsyms += 2;
2492 data_scnhdr.s_nreloc += 1;
2493
2494 bss_scnhdr.s_size = 0;
2495 }
2496
2497 data_scnhdr.s_relptr = data_scnhdr.s_scnptr + data_buffer_size;
2498 filehdr.f_symptr = data_scnhdr.s_relptr + data_scnhdr.s_nreloc * RELSZ;
2499
2500 bfd_coff_swap_filehdr_out (abfd, &filehdr, filehdr_ext);
2501 bfd_bwrite (filehdr_ext, FILHSZ, abfd);
2502 bfd_coff_swap_scnhdr_out (abfd, &text_scnhdr, &scnhdr_ext[SCNHSZ * 0]);
2503 bfd_coff_swap_scnhdr_out (abfd, &data_scnhdr, &scnhdr_ext[SCNHSZ * 1]);
2504 bfd_coff_swap_scnhdr_out (abfd, &bss_scnhdr, &scnhdr_ext[SCNHSZ * 2]);
2505 bfd_bwrite (scnhdr_ext, 3 * SCNHSZ, abfd);
2506 bfd_bwrite (data_buffer, data_buffer_size, abfd);
2507 bfd_bwrite (reloc_ext, data_scnhdr.s_nreloc * RELSZ, abfd);
2508 bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd);
2509 bfd_bwrite (string_table, string_table_size, abfd);
2510
2511 free (data_buffer);
2512 data_buffer = NULL;
2513
2514 return TRUE;
2515 }
2516
2517 /* The typical dynamic reloc. */
2518
2519 static reloc_howto_type xcoff64_dynamic_reloc =
2520 HOWTO (0, /* type */
2521 0, /* rightshift */
2522 4, /* size (0 = byte, 1 = short, 2 = long) */
2523 64, /* bitsize */
2524 FALSE, /* pc_relative */
2525 0, /* bitpos */
2526 complain_overflow_bitfield, /* complain_on_overflow */
2527 0, /* special_function */
2528 "R_POS", /* name */
2529 TRUE, /* partial_inplace */
2530 MINUS_ONE, /* src_mask */
2531 MINUS_ONE, /* dst_mask */
2532 FALSE); /* pcrel_offset */
2533
2534 static unsigned long xcoff64_glink_code[10] =
2535 {
2536 0xe9820000, /* ld r12,0(r2) */
2537 0xf8410028, /* std r2,40(r1) */
2538 0xe80c0000, /* ld r0,0(r12) */
2539 0xe84c0008, /* ld r0,8(r12) */
2540 0x7c0903a6, /* mtctr r0 */
2541 0x4e800420, /* bctr */
2542 0x00000000, /* start of traceback table */
2543 0x000ca000, /* traceback table */
2544 0x00000000, /* traceback table */
2545 0x00000018, /* ??? */
2546 };
2547
2548 static const struct xcoff_backend_data_rec bfd_xcoff_backend_data =
2549 {
2550 { /* COFF backend, defined in libcoff.h. */
2551 _bfd_xcoff64_swap_aux_in,
2552 _bfd_xcoff64_swap_sym_in,
2553 _bfd_xcoff64_swap_lineno_in,
2554 _bfd_xcoff64_swap_aux_out,
2555 _bfd_xcoff64_swap_sym_out,
2556 _bfd_xcoff64_swap_lineno_out,
2557 xcoff64_swap_reloc_out,
2558 coff_swap_filehdr_out,
2559 coff_swap_aouthdr_out,
2560 coff_swap_scnhdr_out,
2561 FILHSZ,
2562 AOUTSZ,
2563 SCNHSZ,
2564 SYMESZ,
2565 AUXESZ,
2566 RELSZ,
2567 LINESZ,
2568 FILNMLEN,
2569 TRUE, /* _bfd_coff_long_filenames */
2570 XCOFF_NO_LONG_SECTION_NAMES, /* _bfd_coff_long_section_names */
2571 3, /* _bfd_coff_default_section_alignment_power */
2572 TRUE, /* _bfd_coff_force_symnames_in_strings */
2573 4, /* _bfd_coff_debug_string_prefix_length */
2574 32768, /* _bfd_coff_max_nscns */
2575 coff_swap_filehdr_in,
2576 coff_swap_aouthdr_in,
2577 coff_swap_scnhdr_in,
2578 xcoff64_swap_reloc_in,
2579 xcoff64_bad_format_hook,
2580 coff_set_arch_mach_hook,
2581 coff_mkobject_hook,
2582 styp_to_sec_flags,
2583 coff_set_alignment_hook,
2584 coff_slurp_symbol_table,
2585 symname_in_debug_hook,
2586 coff_pointerize_aux_hook,
2587 coff_print_aux,
2588 dummy_reloc16_extra_cases,
2589 dummy_reloc16_estimate,
2590 NULL, /* bfd_coff_symbol_classification */
2591 coff_compute_section_file_positions,
2592 NULL, /* _bfd_coff_start_final_link */
2593 xcoff64_ppc_relocate_section,
2594 coff_rtype_to_howto,
2595 NULL, /* _bfd_coff_adjust_symndx */
2596 _bfd_generic_link_add_one_symbol,
2597 coff_link_output_has_begun,
2598 coff_final_link_postscript,
2599 NULL /* print_pdata. */
2600 },
2601
2602 0x01EF, /* magic number */
2603 bfd_arch_powerpc,
2604 bfd_mach_ppc_620,
2605
2606 /* Function pointers to xcoff specific swap routines. */
2607 xcoff64_swap_ldhdr_in,
2608 xcoff64_swap_ldhdr_out,
2609 xcoff64_swap_ldsym_in,
2610 xcoff64_swap_ldsym_out,
2611 xcoff64_swap_ldrel_in,
2612 xcoff64_swap_ldrel_out,
2613
2614 /* Sizes. */
2615 LDHDRSZ,
2616 LDSYMSZ,
2617 LDRELSZ,
2618 24, /* _xcoff_function_descriptor_size */
2619 0, /* _xcoff_small_aout_header_size */
2620
2621 /* Versions. */
2622 2, /* _xcoff_ldhdr_version */
2623
2624 _bfd_xcoff64_put_symbol_name,
2625 _bfd_xcoff64_put_ldsymbol_name,
2626 &xcoff64_dynamic_reloc,
2627 xcoff64_create_csect_from_smclas,
2628
2629 /* Lineno and reloc count overflow. */
2630 xcoff64_is_lineno_count_overflow,
2631 xcoff64_is_reloc_count_overflow,
2632
2633 xcoff64_loader_symbol_offset,
2634 xcoff64_loader_reloc_offset,
2635
2636 /* glink. */
2637 &xcoff64_glink_code[0],
2638 40, /* _xcoff_glink_size */
2639
2640 /* rtinit. */
2641 88, /* _xcoff_rtinit_size */
2642 xcoff64_generate_rtinit,
2643 };
2644
2645 /* The transfer vector that leads the outside world to all of the above. */
2646 const bfd_target rs6000_xcoff64_vec =
2647 {
2648 "aixcoff64-rs6000",
2649 bfd_target_xcoff_flavour,
2650 BFD_ENDIAN_BIG, /* data byte order is big */
2651 BFD_ENDIAN_BIG, /* header byte order is big */
2652
2653 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
2654 | HAS_SYMS | HAS_LOCALS | WP_TEXT),
2655
2656 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
2657 0, /* leading char */
2658 '/', /* ar_pad_char */
2659 15, /* ar_max_namelen */
2660 0, /* match priority. */
2661
2662 /* data */
2663 bfd_getb64,
2664 bfd_getb_signed_64,
2665 bfd_putb64,
2666 bfd_getb32,
2667 bfd_getb_signed_32,
2668 bfd_putb32,
2669 bfd_getb16,
2670 bfd_getb_signed_16,
2671 bfd_putb16,
2672
2673 /* hdrs */
2674 bfd_getb64,
2675 bfd_getb_signed_64,
2676 bfd_putb64,
2677 bfd_getb32,
2678 bfd_getb_signed_32,
2679 bfd_putb32,
2680 bfd_getb16,
2681 bfd_getb_signed_16,
2682 bfd_putb16,
2683
2684 { /* bfd_check_format */
2685 _bfd_dummy_target,
2686 coff_object_p,
2687 xcoff64_archive_p,
2688 CORE_FILE_P
2689 },
2690
2691 { /* bfd_set_format */
2692 _bfd_bool_bfd_false_error,
2693 coff_mkobject,
2694 _bfd_generic_mkarchive,
2695 _bfd_bool_bfd_false_error
2696 },
2697
2698 {/* bfd_write_contents */
2699 _bfd_bool_bfd_false_error,
2700 xcoff64_write_object_contents,
2701 _bfd_xcoff_write_archive_contents,
2702 _bfd_bool_bfd_false_error
2703 },
2704
2705 /* Generic */
2706 _bfd_archive_close_and_cleanup,
2707 _bfd_bool_bfd_true,
2708 coff_new_section_hook,
2709 _bfd_generic_get_section_contents,
2710 _bfd_generic_get_section_contents_in_window,
2711
2712 /* Copy */
2713 _bfd_xcoff_copy_private_bfd_data,
2714 _bfd_generic_bfd_merge_private_bfd_data,
2715 _bfd_generic_init_private_section_data,
2716 _bfd_generic_bfd_copy_private_section_data,
2717 _bfd_generic_bfd_copy_private_symbol_data,
2718 _bfd_generic_bfd_copy_private_header_data,
2719 _bfd_generic_bfd_set_private_flags,
2720 _bfd_generic_bfd_print_private_bfd_data,
2721
2722 /* Core */
2723 BFD_JUMP_TABLE_CORE (coff),
2724
2725 /* Archive */
2726 xcoff64_slurp_armap,
2727 _bfd_noarchive_slurp_extended_name_table,
2728 _bfd_noarchive_construct_extended_name_table,
2729 bfd_dont_truncate_arname,
2730 _bfd_xcoff_write_armap,
2731 _bfd_xcoff_read_ar_hdr,
2732 _bfd_generic_write_ar_hdr,
2733 xcoff64_openr_next_archived_file,
2734 _bfd_generic_get_elt_at_index,
2735 _bfd_xcoff_stat_arch_elt,
2736 _bfd_bool_bfd_true,
2737
2738 /* Symbols */
2739 coff_get_symtab_upper_bound,
2740 coff_canonicalize_symtab,
2741 coff_make_empty_symbol,
2742 coff_print_symbol,
2743 coff_get_symbol_info,
2744 coff_get_symbol_version_string,
2745 _bfd_xcoff_is_local_label_name,
2746 coff_bfd_is_target_special_symbol,
2747 coff_get_lineno,
2748 coff_find_nearest_line,
2749 coff_find_line,
2750 coff_find_inliner_info,
2751 coff_bfd_make_debug_symbol,
2752 _bfd_generic_read_minisymbols,
2753 _bfd_generic_minisymbol_to_symbol,
2754
2755 /* Reloc */
2756 coff_get_reloc_upper_bound,
2757 coff_canonicalize_reloc,
2758 _bfd_generic_set_reloc,
2759 xcoff64_reloc_type_lookup,
2760 xcoff64_reloc_name_lookup,
2761
2762 /* Write */
2763 coff_set_arch_mach,
2764 coff_set_section_contents,
2765
2766 /* Link */
2767 xcoff64_sizeof_headers,
2768 bfd_generic_get_relocated_section_contents,
2769 bfd_generic_relax_section,
2770 _bfd_xcoff_bfd_link_hash_table_create,
2771 _bfd_xcoff_bfd_link_add_symbols,
2772 _bfd_generic_link_just_syms,
2773 _bfd_generic_copy_link_hash_symbol_type,
2774 _bfd_xcoff_bfd_final_link,
2775 _bfd_generic_link_split_section,
2776 _bfd_generic_link_check_relocs,
2777 bfd_generic_gc_sections,
2778 bfd_generic_lookup_section_flags,
2779 bfd_generic_merge_sections,
2780 bfd_generic_is_group_section,
2781 bfd_generic_discard_group,
2782 _bfd_generic_section_already_linked,
2783 _bfd_xcoff_define_common_symbol,
2784 _bfd_generic_link_hide_symbol,
2785 bfd_generic_define_start_stop,
2786
2787 /* Dynamic */
2788 _bfd_xcoff_get_dynamic_symtab_upper_bound,
2789 _bfd_xcoff_canonicalize_dynamic_symtab,
2790 _bfd_nodynamic_get_synthetic_symtab,
2791 _bfd_xcoff_get_dynamic_reloc_upper_bound,
2792 _bfd_xcoff_canonicalize_dynamic_reloc,
2793
2794 /* Opposite endian version, none exists */
2795 NULL,
2796
2797 &bfd_xcoff_backend_data,
2798 };
2799
2800 extern const bfd_target *xcoff64_core_p
2801 (bfd *);
2802 extern bfd_boolean xcoff64_core_file_matches_executable_p
2803 (bfd *, bfd *);
2804 extern char *xcoff64_core_file_failing_command
2805 (bfd *);
2806 extern int xcoff64_core_file_failing_signal
2807 (bfd *);
2808 #define xcoff64_core_file_pid _bfd_nocore_core_file_pid
2809
2810 /* AIX 5 */
2811 static const struct xcoff_backend_data_rec bfd_xcoff_aix5_backend_data =
2812 {
2813 { /* COFF backend, defined in libcoff.h. */
2814 _bfd_xcoff64_swap_aux_in,
2815 _bfd_xcoff64_swap_sym_in,
2816 _bfd_xcoff64_swap_lineno_in,
2817 _bfd_xcoff64_swap_aux_out,
2818 _bfd_xcoff64_swap_sym_out,
2819 _bfd_xcoff64_swap_lineno_out,
2820 xcoff64_swap_reloc_out,
2821 coff_swap_filehdr_out,
2822 coff_swap_aouthdr_out,
2823 coff_swap_scnhdr_out,
2824 FILHSZ,
2825 AOUTSZ,
2826 SCNHSZ,
2827 SYMESZ,
2828 AUXESZ,
2829 RELSZ,
2830 LINESZ,
2831 FILNMLEN,
2832 TRUE, /* _bfd_coff_long_filenames */
2833 XCOFF_NO_LONG_SECTION_NAMES, /* _bfd_coff_long_section_names */
2834 3, /* _bfd_coff_default_section_alignment_power */
2835 TRUE, /* _bfd_coff_force_symnames_in_strings */
2836 4, /* _bfd_coff_debug_string_prefix_length */
2837 32768, /* _bfd_coff_max_nscns */
2838 coff_swap_filehdr_in,
2839 coff_swap_aouthdr_in,
2840 coff_swap_scnhdr_in,
2841 xcoff64_swap_reloc_in,
2842 xcoff64_bad_format_hook,
2843 coff_set_arch_mach_hook,
2844 coff_mkobject_hook,
2845 styp_to_sec_flags,
2846 coff_set_alignment_hook,
2847 coff_slurp_symbol_table,
2848 symname_in_debug_hook,
2849 coff_pointerize_aux_hook,
2850 coff_print_aux,
2851 dummy_reloc16_extra_cases,
2852 dummy_reloc16_estimate,
2853 NULL, /* bfd_coff_sym_is_global */
2854 coff_compute_section_file_positions,
2855 NULL, /* _bfd_coff_start_final_link */
2856 xcoff64_ppc_relocate_section,
2857 coff_rtype_to_howto,
2858 NULL, /* _bfd_coff_adjust_symndx */
2859 _bfd_generic_link_add_one_symbol,
2860 coff_link_output_has_begun,
2861 coff_final_link_postscript,
2862 NULL /* print_pdata. */
2863 },
2864
2865 U64_TOCMAGIC, /* magic number */
2866 bfd_arch_powerpc,
2867 bfd_mach_ppc_620,
2868
2869 /* Function pointers to xcoff specific swap routines. */
2870 xcoff64_swap_ldhdr_in,
2871 xcoff64_swap_ldhdr_out,
2872 xcoff64_swap_ldsym_in,
2873 xcoff64_swap_ldsym_out,
2874 xcoff64_swap_ldrel_in,
2875 xcoff64_swap_ldrel_out,
2876
2877 /* Sizes. */
2878 LDHDRSZ,
2879 LDSYMSZ,
2880 LDRELSZ,
2881 24, /* _xcoff_function_descriptor_size */
2882 0, /* _xcoff_small_aout_header_size */
2883 /* Versions. */
2884 2, /* _xcoff_ldhdr_version */
2885
2886 _bfd_xcoff64_put_symbol_name,
2887 _bfd_xcoff64_put_ldsymbol_name,
2888 &xcoff64_dynamic_reloc,
2889 xcoff64_create_csect_from_smclas,
2890
2891 /* Lineno and reloc count overflow. */
2892 xcoff64_is_lineno_count_overflow,
2893 xcoff64_is_reloc_count_overflow,
2894
2895 xcoff64_loader_symbol_offset,
2896 xcoff64_loader_reloc_offset,
2897
2898 /* glink. */
2899 &xcoff64_glink_code[0],
2900 40, /* _xcoff_glink_size */
2901
2902 /* rtinit. */
2903 88, /* _xcoff_rtinit_size */
2904 xcoff64_generate_rtinit,
2905 };
2906
2907 /* The transfer vector that leads the outside world to all of the above. */
2908 const bfd_target rs6000_xcoff64_aix_vec =
2909 {
2910 "aix5coff64-rs6000",
2911 bfd_target_xcoff_flavour,
2912 BFD_ENDIAN_BIG, /* data byte order is big */
2913 BFD_ENDIAN_BIG, /* header byte order is big */
2914
2915 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
2916 | HAS_SYMS | HAS_LOCALS | WP_TEXT),
2917
2918 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
2919 0, /* leading char */
2920 '/', /* ar_pad_char */
2921 15, /* ar_max_namelen */
2922 0, /* match priority. */
2923
2924 /* data */
2925 bfd_getb64,
2926 bfd_getb_signed_64,
2927 bfd_putb64,
2928 bfd_getb32,
2929 bfd_getb_signed_32,
2930 bfd_putb32,
2931 bfd_getb16,
2932 bfd_getb_signed_16,
2933 bfd_putb16,
2934
2935 /* hdrs */
2936 bfd_getb64,
2937 bfd_getb_signed_64,
2938 bfd_putb64,
2939 bfd_getb32,
2940 bfd_getb_signed_32,
2941 bfd_putb32,
2942 bfd_getb16,
2943 bfd_getb_signed_16,
2944 bfd_putb16,
2945
2946 { /* bfd_check_format */
2947 _bfd_dummy_target,
2948 coff_object_p,
2949 xcoff64_archive_p,
2950 xcoff64_core_p
2951 },
2952
2953 { /* bfd_set_format */
2954 _bfd_bool_bfd_false_error,
2955 coff_mkobject,
2956 _bfd_generic_mkarchive,
2957 _bfd_bool_bfd_false_error
2958 },
2959
2960 {/* bfd_write_contents */
2961 _bfd_bool_bfd_false_error,
2962 xcoff64_write_object_contents,
2963 _bfd_xcoff_write_archive_contents,
2964 _bfd_bool_bfd_false_error
2965 },
2966
2967 /* Generic */
2968 _bfd_archive_close_and_cleanup,
2969 _bfd_bool_bfd_true,
2970 coff_new_section_hook,
2971 _bfd_generic_get_section_contents,
2972 _bfd_generic_get_section_contents_in_window,
2973
2974 /* Copy */
2975 _bfd_xcoff_copy_private_bfd_data,
2976 _bfd_generic_bfd_merge_private_bfd_data,
2977 _bfd_generic_init_private_section_data,
2978 _bfd_generic_bfd_copy_private_section_data,
2979 _bfd_generic_bfd_copy_private_symbol_data,
2980 _bfd_generic_bfd_copy_private_header_data,
2981 _bfd_generic_bfd_set_private_flags,
2982 _bfd_generic_bfd_print_private_bfd_data,
2983
2984 /* Core */
2985 BFD_JUMP_TABLE_CORE (xcoff64),
2986
2987 /* Archive */
2988 xcoff64_slurp_armap,
2989 _bfd_noarchive_slurp_extended_name_table,
2990 _bfd_noarchive_construct_extended_name_table,
2991 bfd_dont_truncate_arname,
2992 _bfd_xcoff_write_armap,
2993 _bfd_xcoff_read_ar_hdr,
2994 _bfd_generic_write_ar_hdr,
2995 xcoff64_openr_next_archived_file,
2996 _bfd_generic_get_elt_at_index,
2997 _bfd_xcoff_stat_arch_elt,
2998 _bfd_bool_bfd_true,
2999
3000 /* Symbols */
3001 coff_get_symtab_upper_bound,
3002 coff_canonicalize_symtab,
3003 coff_make_empty_symbol,
3004 coff_print_symbol,
3005 coff_get_symbol_info,
3006 coff_get_symbol_version_string,
3007 _bfd_xcoff_is_local_label_name,
3008 coff_bfd_is_target_special_symbol,
3009 coff_get_lineno,
3010 coff_find_nearest_line,
3011 coff_find_line,
3012 coff_find_inliner_info,
3013 coff_bfd_make_debug_symbol,
3014 _bfd_generic_read_minisymbols,
3015 _bfd_generic_minisymbol_to_symbol,
3016
3017 /* Reloc */
3018 coff_get_reloc_upper_bound,
3019 coff_canonicalize_reloc,
3020 _bfd_generic_set_reloc,
3021 xcoff64_reloc_type_lookup,
3022 xcoff64_reloc_name_lookup,
3023
3024 /* Write */
3025 coff_set_arch_mach,
3026 coff_set_section_contents,
3027
3028 /* Link */
3029 xcoff64_sizeof_headers,
3030 bfd_generic_get_relocated_section_contents,
3031 bfd_generic_relax_section,
3032 _bfd_xcoff_bfd_link_hash_table_create,
3033 _bfd_xcoff_bfd_link_add_symbols,
3034 _bfd_generic_link_just_syms,
3035 _bfd_generic_copy_link_hash_symbol_type,
3036 _bfd_xcoff_bfd_final_link,
3037 _bfd_generic_link_split_section,
3038 _bfd_generic_link_check_relocs,
3039 bfd_generic_gc_sections,
3040 bfd_generic_lookup_section_flags,
3041 bfd_generic_merge_sections,
3042 bfd_generic_is_group_section,
3043 bfd_generic_discard_group,
3044 _bfd_generic_section_already_linked,
3045 _bfd_xcoff_define_common_symbol,
3046 _bfd_generic_link_hide_symbol,
3047 bfd_generic_define_start_stop,
3048
3049 /* Dynamic */
3050 _bfd_xcoff_get_dynamic_symtab_upper_bound,
3051 _bfd_xcoff_canonicalize_dynamic_symtab,
3052 _bfd_nodynamic_get_synthetic_symtab,
3053 _bfd_xcoff_get_dynamic_reloc_upper_bound,
3054 _bfd_xcoff_canonicalize_dynamic_reloc,
3055
3056 /* Opposite endian version, none exists. */
3057 NULL,
3058
3059 & bfd_xcoff_aix5_backend_data,
3060 };
The GNU Binutils are a collection of binary tools.