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