projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
XCOFF: use bfd_coff_close_and_cleanup
[binutils-gdb.git] / bfd / coff-rs6000.c
1 /* BFD back-end for IBM RS/6000 "XCOFF" files.
2 Copyright (C) 1990-2023 Free Software Foundation, Inc.
3 Written by Metin G. Ozisik, Mimi Phuong-Thao Vo, and John Gilmore.
4 Archive support from Damon A. Permezel.
5 Contributed by IBM Corporation and Cygnus Support.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
23
24 #include "sysdep.h"
25 #include "libiberty.h"
26 #include "bfd.h"
27 #include "bfdlink.h"
28 #include "libbfd.h"
29 #include "coff/internal.h"
30 #include "coff/xcoff.h"
31 #include "coff/rs6000.h"
32 #include "libcoff.h"
33 #include "libxcoff.h"
34
35 extern bool _bfd_xcoff_mkobject (bfd *);
36 extern bool _bfd_xcoff_copy_private_bfd_data (bfd *, bfd *);
37 extern bool _bfd_xcoff_is_local_label_name (bfd *, const char *);
38 extern reloc_howto_type *_bfd_xcoff_reloc_type_lookup
39 (bfd *, bfd_reloc_code_real_type);
40 extern bool _bfd_xcoff_slurp_armap (bfd *);
41 extern bfd_cleanup _bfd_xcoff_archive_p (bfd *);
42 extern void * _bfd_xcoff_read_ar_hdr (bfd *);
43 extern bfd *_bfd_xcoff_openr_next_archived_file (bfd *, bfd *);
44 extern int _bfd_xcoff_stat_arch_elt (bfd *, struct stat *);
45 extern bool _bfd_xcoff_write_armap
46 (bfd *, unsigned int, struct orl *, unsigned int, int);
47 extern bool _bfd_xcoff_write_archive_contents (bfd *);
48 extern int _bfd_xcoff_sizeof_headers (bfd *, struct bfd_link_info *);
49 extern void _bfd_xcoff_swap_sym_in (bfd *, void *, void *);
50 extern unsigned int _bfd_xcoff_swap_sym_out (bfd *, void *, void *);
51 extern void _bfd_xcoff_swap_aux_in (bfd *, void *, int, int, int, int, void *);
52 extern unsigned int _bfd_xcoff_swap_aux_out
53 (bfd *, void *, int, int, int, int, void *);
54 static void xcoff_swap_reloc_in (bfd *, void *, void *);
55 static unsigned int xcoff_swap_reloc_out (bfd *, void *, void *);
56
57 /* Forward declare xcoff_rtype2howto for coffcode.h macro. */
58 void xcoff_rtype2howto (arelent *, struct internal_reloc *);
59
60 /* coffcode.h needs these to be defined. */
61 #define RS6000COFF_C 1
62
63 #define SELECT_RELOC(internal, howto) \
64 { \
65 internal.r_type = howto->type; \
66 internal.r_size = \
67 ((howto->complain_on_overflow == complain_overflow_signed \
68 ? 0x80 \
69 : 0) \
70 | (howto->bitsize - 1)); \
71 }
72
73 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
74 #define COFF_LONG_FILENAMES
75 #define NO_COFF_SYMBOLS
76 #define RTYPE2HOWTO(cache_ptr, dst) xcoff_rtype2howto (cache_ptr, dst)
77 #define coff_mkobject _bfd_xcoff_mkobject
78 #define coff_bfd_is_local_label_name _bfd_xcoff_is_local_label_name
79 #ifdef AIX_CORE
80 extern bfd_cleanup rs6000coff_core_p (bfd *abfd);
81 extern bool rs6000coff_core_file_matches_executable_p
82 (bfd *cbfd, bfd *ebfd);
83 extern char *rs6000coff_core_file_failing_command (bfd *abfd);
84 extern int rs6000coff_core_file_failing_signal (bfd *abfd);
85 #define CORE_FILE_P rs6000coff_core_p
86 #define coff_core_file_failing_command \
87 rs6000coff_core_file_failing_command
88 #define coff_core_file_failing_signal \
89 rs6000coff_core_file_failing_signal
90 #define coff_core_file_matches_executable_p \
91 rs6000coff_core_file_matches_executable_p
92 #define coff_core_file_pid \
93 _bfd_nocore_core_file_pid
94 #else
95 #define CORE_FILE_P _bfd_dummy_target
96 #define coff_core_file_failing_command \
97 _bfd_nocore_core_file_failing_command
98 #define coff_core_file_failing_signal \
99 _bfd_nocore_core_file_failing_signal
100 #define coff_core_file_matches_executable_p \
101 _bfd_nocore_core_file_matches_executable_p
102 #define coff_core_file_pid \
103 _bfd_nocore_core_file_pid
104 #endif
105 #define coff_SWAP_sym_in _bfd_xcoff_swap_sym_in
106 #define coff_SWAP_sym_out _bfd_xcoff_swap_sym_out
107 #define coff_SWAP_aux_in _bfd_xcoff_swap_aux_in
108 #define coff_SWAP_aux_out _bfd_xcoff_swap_aux_out
109 #define coff_swap_reloc_in xcoff_swap_reloc_in
110 #define coff_swap_reloc_out xcoff_swap_reloc_out
111 #define NO_COFF_RELOCS
112
113 #ifndef bfd_pe_print_pdata
114 #define bfd_pe_print_pdata NULL
115 #endif
116
117 #include "coffcode.h"
118
119 /* The main body of code is in coffcode.h. */
120
121 static const char *normalize_filename (bfd *);
122 static bool xcoff_write_armap_old
123 (bfd *, unsigned int, struct orl *, unsigned int, int);
124 static bool xcoff_write_armap_big
125 (bfd *, unsigned int, struct orl *, unsigned int, int);
126 static bool xcoff_write_archive_contents_old (bfd *);
127 static bool xcoff_write_archive_contents_big (bfd *);
128 static void xcoff_swap_ldhdr_in (bfd *, const void *, struct internal_ldhdr *);
129 static void xcoff_swap_ldhdr_out (bfd *, const struct internal_ldhdr *, void *);
130 static void xcoff_swap_ldsym_in (bfd *, const void *, struct internal_ldsym *);
131 static void xcoff_swap_ldsym_out (bfd *, const struct internal_ldsym *, void *);
132 static void xcoff_swap_ldrel_in (bfd *, const void *, struct internal_ldrel *);
133 static void xcoff_swap_ldrel_out (bfd *, const struct internal_ldrel *, void *);
134 static bool xcoff_ppc_relocate_section
135 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
136 struct internal_reloc *, struct internal_syment *, asection **);
137 static bool _bfd_xcoff_put_ldsymbol_name
138 (bfd *, struct xcoff_loader_info *, struct internal_ldsym *, const char *);
139 static asection *xcoff_create_csect_from_smclas
140 (bfd *, union internal_auxent *, const char *);
141 static bool xcoff_is_lineno_count_overflow (bfd *, bfd_vma);
142 static bool xcoff_is_reloc_count_overflow (bfd *, bfd_vma);
143 static bfd_vma xcoff_loader_symbol_offset (bfd *, struct internal_ldhdr *);
144 static bfd_vma xcoff_loader_reloc_offset (bfd *, struct internal_ldhdr *);
145 static bool xcoff_generate_rtinit
146 (bfd *, const char *, const char *, bool);
147 static bool do_pad (bfd *, unsigned int);
148 static bool do_copy (bfd *, bfd *);
149
150 /* Relocation functions */
151 static xcoff_reloc_function xcoff_reloc_type_br;
152
153 static xcoff_complain_function xcoff_complain_overflow_dont_func;
154 static xcoff_complain_function xcoff_complain_overflow_bitfield_func;
155 static xcoff_complain_function xcoff_complain_overflow_signed_func;
156 static xcoff_complain_function xcoff_complain_overflow_unsigned_func;
157
158 xcoff_reloc_function *const
159 xcoff_calculate_relocation[XCOFF_MAX_CALCULATE_RELOCATION] =
160 {
161 xcoff_reloc_type_pos, /* R_POS (0x00) */
162 xcoff_reloc_type_neg, /* R_NEG (0x01) */
163 xcoff_reloc_type_rel, /* R_REL (0x02) */
164 xcoff_reloc_type_toc, /* R_TOC (0x03) */
165 xcoff_reloc_type_toc, /* R_TRL (0x04) */
166 xcoff_reloc_type_toc, /* R_GL (0x05) */
167 xcoff_reloc_type_toc, /* R_TCL (0x06) */
168 xcoff_reloc_type_fail, /* (0x07) */
169 xcoff_reloc_type_ba, /* R_BA (0x08) */
170 xcoff_reloc_type_fail, /* (0x09) */
171 xcoff_reloc_type_br, /* R_BR (0x0a) */
172 xcoff_reloc_type_fail, /* (0x0b) */
173 xcoff_reloc_type_pos, /* R_RL (0x0c) */
174 xcoff_reloc_type_pos, /* R_RLA (0x0d) */
175 xcoff_reloc_type_fail, /* (0x0e) */
176 xcoff_reloc_type_noop, /* R_REF (0x0f) */
177 xcoff_reloc_type_fail, /* (0x10) */
178 xcoff_reloc_type_fail, /* (0x11) */
179 xcoff_reloc_type_fail, /* (0x12) */
180 xcoff_reloc_type_toc, /* R_TRLA (0x13) */
181 xcoff_reloc_type_fail, /* R_RRTBI (0x14) */
182 xcoff_reloc_type_fail, /* R_RRTBA (0x15) */
183 xcoff_reloc_type_ba, /* R_CAI (0x16) */
184 xcoff_reloc_type_crel, /* R_CREL (0x17) */
185 xcoff_reloc_type_ba, /* R_RBA (0x18) */
186 xcoff_reloc_type_ba, /* R_RBAC (0x19) */
187 xcoff_reloc_type_br, /* R_RBR (0x1a) */
188 xcoff_reloc_type_ba, /* R_RBRC (0x1b) */
189 xcoff_reloc_type_fail, /* (0x1c) */
190 xcoff_reloc_type_fail, /* (0x1d) */
191 xcoff_reloc_type_fail, /* (0x1e) */
192 xcoff_reloc_type_fail, /* (0x1f) */
193 xcoff_reloc_type_tls, /* R_TLS (0x20) */
194 xcoff_reloc_type_tls, /* R_TLS_IE (0x21) */
195 xcoff_reloc_type_tls, /* R_TLS_LD (0x22) */
196 xcoff_reloc_type_tls, /* R_TLS_LE (0x23) */
197 xcoff_reloc_type_tls, /* R_TLSM (0x24) */
198 xcoff_reloc_type_tls, /* R_TLSML (0x25) */
199 xcoff_reloc_type_fail, /* (0x26) */
200 xcoff_reloc_type_fail, /* (0x27) */
201 xcoff_reloc_type_fail, /* (0x28) */
202 xcoff_reloc_type_fail, /* (0x29) */
203 xcoff_reloc_type_fail, /* (0x2a) */
204 xcoff_reloc_type_fail, /* (0x2b) */
205 xcoff_reloc_type_fail, /* (0x2c) */
206 xcoff_reloc_type_fail, /* (0x2d) */
207 xcoff_reloc_type_fail, /* (0x2e) */
208 xcoff_reloc_type_fail, /* (0x2f) */
209 xcoff_reloc_type_toc, /* R_TOCU (0x30) */
210 xcoff_reloc_type_toc, /* R_TOCL (0x31) */
211 };
212
213 xcoff_complain_function *const
214 xcoff_complain_overflow[XCOFF_MAX_COMPLAIN_OVERFLOW] =
215 {
216 xcoff_complain_overflow_dont_func,
217 xcoff_complain_overflow_bitfield_func,
218 xcoff_complain_overflow_signed_func,
219 xcoff_complain_overflow_unsigned_func,
220 };
221
222 /* Information about one member of an archive. */
223 struct member_layout
224 {
225 /* The archive member that this structure describes. */
226 bfd *member;
227
228 /* The number of bytes of padding that must be inserted before the
229 start of the member in order to ensure that the section contents
230 are correctly aligned. */
231 unsigned int leading_padding;
232
233 /* The offset of MEMBER from the start of the archive (i.e. the end
234 of the leading padding). */
235 file_ptr offset;
236
237 /* The normalized name of MEMBER. */
238 const char *name;
239
240 /* The length of NAME, without padding. */
241 bfd_size_type namlen;
242
243 /* The length of NAME, with padding. */
244 bfd_size_type padded_namlen;
245
246 /* The size of MEMBER's header, including the name and magic sequence. */
247 bfd_size_type header_size;
248
249 /* The size of the MEMBER's contents. */
250 bfd_size_type contents_size;
251
252 /* The number of bytes of padding that must be inserted after MEMBER
253 in order to preserve even alignment. */
254 bfd_size_type trailing_padding;
255 };
256
257 /* A structure used for iterating over the members of an archive. */
258 struct archive_iterator
259 {
260 /* The archive itself. */
261 bfd *archive;
262
263 /* Information about the current archive member. */
264 struct member_layout current;
265
266 /* Information about the next archive member. MEMBER is null if there
267 are no more archive members, in which case OFFSET is the offset of
268 the first unused byte. */
269 struct member_layout next;
270 };
271
272 /* Initialize INFO so that it describes member MEMBER of archive ARCHIVE.
273 OFFSET is the even-padded offset of MEMBER, not including any leading
274 padding needed for section alignment. */
275
276 static void
277 member_layout_init (struct member_layout *info, bfd *archive,
278 bfd *member, file_ptr offset)
279 {
280 info->member = member;
281 info->leading_padding = 0;
282 if (member)
283 {
284 info->name = normalize_filename (member);
285 info->namlen = strlen (info->name);
286 info->padded_namlen = info->namlen + (info->namlen & 1);
287 if (xcoff_big_format_p (archive))
288 info->header_size = SIZEOF_AR_HDR_BIG;
289 else
290 info->header_size = SIZEOF_AR_HDR;
291 info->header_size += info->padded_namlen + SXCOFFARFMAG;
292 info->contents_size = arelt_size (member);
293 info->trailing_padding = info->contents_size & 1;
294
295 if (bfd_check_format (member, bfd_object)
296 && bfd_get_flavour (member) == bfd_target_xcoff_flavour
297 && (member->flags & DYNAMIC) != 0)
298 info->leading_padding
299 = (-(offset + info->header_size)
300 & ((1 << bfd_xcoff_text_align_power (member)) - 1));
301 }
302 info->offset = offset + info->leading_padding;
303 }
304
305 /* Set up ITERATOR to iterate through archive ARCHIVE. */
306
307 static void
308 archive_iterator_begin (struct archive_iterator *iterator,
309 bfd *archive)
310 {
311 iterator->archive = archive;
312 member_layout_init (&iterator->next, archive, archive->archive_head,
313 xcoff_big_format_p (archive)
314 ? SIZEOF_AR_FILE_HDR_BIG
315 : SIZEOF_AR_FILE_HDR);
316 }
317
318 /* Make ITERATOR visit the first unvisited archive member. Return true
319 on success; return false if all members have been visited. */
320
321 static bool
322 archive_iterator_next (struct archive_iterator *iterator)
323 {
324 if (!iterator->next.member)
325 return false;
326
327 iterator->current = iterator->next;
328 member_layout_init (&iterator->next, iterator->archive,
329 iterator->current.member->archive_next,
330 iterator->current.offset
331 + iterator->current.header_size
332 + iterator->current.contents_size
333 + iterator->current.trailing_padding);
334 return true;
335 }
336
337 /* We use our own tdata type. Its first field is the COFF tdata type,
338 so the COFF routines are compatible. */
339
340 bool
341 _bfd_xcoff_mkobject (bfd *abfd)
342 {
343 coff_data_type *coff;
344 size_t amt = sizeof (struct xcoff_tdata);
345
346 abfd->tdata.xcoff_obj_data = (struct xcoff_tdata *) bfd_zalloc (abfd, amt);
347 if (abfd->tdata.xcoff_obj_data == NULL)
348 return false;
349 coff = coff_data (abfd);
350 coff->symbols = (coff_symbol_type *) NULL;
351 coff->conversion_table = (unsigned int *) NULL;
352 coff->raw_syments = (struct coff_ptr_struct *) NULL;
353 coff->relocbase = 0;
354
355 xcoff_data (abfd)->modtype = ('1' << 8) | 'L';
356
357 /* We set cputype to -1 to indicate that it has not been
358 initialized. */
359 xcoff_data (abfd)->cputype = -1;
360
361 xcoff_data (abfd)->csects = NULL;
362 xcoff_data (abfd)->debug_indices = NULL;
363
364 /* text section alignment is different than the default */
365 bfd_xcoff_text_align_power (abfd) = 2;
366
367 return true;
368 }
369
370 /* Copy XCOFF data from one BFD to another. */
371
372 bool
373 _bfd_xcoff_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
374 {
375 struct xcoff_tdata *ix, *ox;
376 asection *sec;
377
378 if (ibfd->xvec != obfd->xvec)
379 return true;
380 ix = xcoff_data (ibfd);
381 ox = xcoff_data (obfd);
382 ox->full_aouthdr = ix->full_aouthdr;
383 ox->toc = ix->toc;
384 if (ix->sntoc == 0)
385 ox->sntoc = 0;
386 else
387 {
388 sec = coff_section_from_bfd_index (ibfd, ix->sntoc);
389 if (sec == NULL || sec->output_section == NULL)
390 ox->sntoc = 0;
391 else
392 ox->sntoc = sec->output_section->target_index;
393 }
394 if (ix->snentry == 0)
395 ox->snentry = 0;
396 else
397 {
398 sec = coff_section_from_bfd_index (ibfd, ix->snentry);
399 if (sec == NULL || sec->output_section == NULL)
400 ox->snentry = 0;
401 else
402 ox->snentry = sec->output_section->target_index;
403 }
404 bfd_xcoff_text_align_power (obfd) = bfd_xcoff_text_align_power (ibfd);
405 bfd_xcoff_data_align_power (obfd) = bfd_xcoff_data_align_power (ibfd);
406 ox->modtype = ix->modtype;
407 ox->cputype = ix->cputype;
408 ox->maxdata = ix->maxdata;
409 ox->maxstack = ix->maxstack;
410 return true;
411 }
412
413 /* I don't think XCOFF really has a notion of local labels based on
414 name. This will mean that ld -X doesn't actually strip anything.
415 The AIX native linker does not have a -X option, and it ignores the
416 -x option. */
417
418 bool
419 _bfd_xcoff_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
420 const char *name ATTRIBUTE_UNUSED)
421 {
422 return false;
423 }
424 \f
425 void
426 _bfd_xcoff_swap_sym_in (bfd *abfd, void * ext1, void * in1)
427 {
428 SYMENT *ext = (SYMENT *)ext1;
429 struct internal_syment * in = (struct internal_syment *)in1;
430
431 if (ext->e.e_name[0] != 0)
432 {
433 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
434 }
435 else
436 {
437 in->_n._n_n._n_zeroes = 0;
438 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
439 }
440
441 in->n_value = H_GET_32 (abfd, ext->e_value);
442 in->n_scnum = (short) H_GET_16 (abfd, ext->e_scnum);
443 in->n_type = H_GET_16 (abfd, ext->e_type);
444 in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
445 in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
446 }
447
448 unsigned int
449 _bfd_xcoff_swap_sym_out (bfd *abfd, void * inp, void * extp)
450 {
451 struct internal_syment *in = (struct internal_syment *)inp;
452 SYMENT *ext =(SYMENT *)extp;
453
454 if (in->_n._n_name[0] != 0)
455 {
456 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
457 }
458 else
459 {
460 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
461 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
462 }
463
464 H_PUT_32 (abfd, in->n_value, ext->e_value);
465 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
466 H_PUT_16 (abfd, in->n_type, ext->e_type);
467 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
468 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
469 return bfd_coff_symesz (abfd);
470 }
471
472 void
473 _bfd_xcoff_swap_aux_in (bfd *abfd, void * ext1, int type ATTRIBUTE_UNUSED,
474 int in_class, int indx, int numaux, void * in1)
475 {
476 AUXENT * ext = (AUXENT *)ext1;
477 union internal_auxent *in = (union internal_auxent *)in1;
478
479 switch (in_class)
480 {
481 default:
482 _bfd_error_handler
483 /* xgettext: c-format */
484 (_("%pB: unsupported swap_aux_in for storage class %#x"),
485 abfd, (unsigned int) in_class);
486 bfd_set_error (bfd_error_bad_value);
487 break;
488
489 case C_FILE:
490 if (ext->x_file.x_n.x_fname[0] == 0)
491 {
492 in->x_file.x_n.x_n.x_zeroes = 0;
493 in->x_file.x_n.x_n.x_offset =
494 H_GET_32 (abfd, ext->x_file.x_n.x_n.x_offset);
495 }
496 else
497 memcpy (in->x_file.x_n.x_fname, ext->x_file.x_n.x_fname, FILNMLEN);
498 in->x_file.x_ftype = H_GET_8 (abfd, ext->x_file.x_ftype);
499 break;
500
501 /* RS/6000 "csect" auxents.
502 There is always a CSECT auxiliary entry. But functions can
503 have FCN ones too. In this case, CSECT is always the last
504 one. */
505 case C_EXT:
506 case C_AIX_WEAKEXT:
507 case C_HIDEXT:
508 if (indx + 1 == numaux)
509 {
510 in->x_csect.x_scnlen.l = H_GET_32 (abfd, ext->x_csect.x_scnlen);
511 in->x_csect.x_parmhash = H_GET_32 (abfd, ext->x_csect.x_parmhash);
512 in->x_csect.x_snhash = H_GET_16 (abfd, ext->x_csect.x_snhash);
513 /* We don't have to hack bitfields in x_smtyp because it's
514 defined by shifts-and-ands, which are equivalent on all
515 byte orders. */
516 in->x_csect.x_smtyp = H_GET_8 (abfd, ext->x_csect.x_smtyp);
517 in->x_csect.x_smclas = H_GET_8 (abfd, ext->x_csect.x_smclas);
518 in->x_csect.x_stab = H_GET_32 (abfd, ext->x_csect.x_stab);
519 in->x_csect.x_snstab = H_GET_16 (abfd, ext->x_csect.x_snstab);
520 }
521 else
522 {
523 /* x_exptr isn't supported. */
524 in->x_sym.x_misc.x_fsize
525 = H_GET_32 (abfd, ext->x_fcn.x_fsize);
526 in->x_sym.x_fcnary.x_fcn.x_lnnoptr
527 = H_GET_32 (abfd, ext->x_fcn.x_lnnoptr);
528 in->x_sym.x_fcnary.x_fcn.x_endndx.l
529 = H_GET_32 (abfd, ext->x_fcn.x_endndx);
530 }
531 break;
532
533 case C_STAT:
534 in->x_scn.x_scnlen = H_GET_32 (abfd, ext->x_scn.x_scnlen);
535 in->x_scn.x_nreloc = H_GET_16 (abfd, ext->x_scn.x_nreloc);
536 in->x_scn.x_nlinno = H_GET_16 (abfd, ext->x_scn.x_nlinno);
537 /* PE defines some extra fields; we zero them out for
538 safety. */
539 in->x_scn.x_checksum = 0;
540 in->x_scn.x_associated = 0;
541 in->x_scn.x_comdat = 0;
542 break;
543
544 case C_BLOCK:
545 case C_FCN:
546 in->x_sym.x_misc.x_lnsz.x_lnno
547 = H_GET_32 (abfd, ext->x_sym.x_lnno);
548 break;
549
550 case C_DWARF:
551 in->x_sect.x_scnlen = H_GET_32 (abfd, ext->x_sect.x_scnlen);
552 in->x_sect.x_nreloc = H_GET_32 (abfd, ext->x_sect.x_nreloc);
553 break;
554
555 }
556 }
557
558 unsigned int
559 _bfd_xcoff_swap_aux_out (bfd *abfd, void * inp, int type ATTRIBUTE_UNUSED,
560 int in_class, int indx, int numaux, void * extp)
561 {
562 union internal_auxent *in = (union internal_auxent *)inp;
563 AUXENT *ext = (AUXENT *)extp;
564
565 memset (ext, 0, bfd_coff_auxesz (abfd));
566 switch (in_class)
567 {
568 default:
569 _bfd_error_handler
570 /* xgettext: c-format */
571 (_("%pB: unsupported swap_aux_out for storage class %#x"),
572 abfd, (unsigned int) in_class);
573 bfd_set_error (bfd_error_bad_value);
574 break;
575
576 case C_FILE:
577 if (in->x_file.x_n.x_fname[0] == 0)
578 {
579 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_n.x_zeroes);
580 H_PUT_32 (abfd, in->x_file.x_n.x_n.x_offset,
581 ext->x_file.x_n.x_n.x_offset);
582 }
583 else
584 memcpy (ext->x_file.x_n.x_fname, in->x_file.x_n.x_fname, FILNMLEN);
585 H_PUT_8 (abfd, in->x_file.x_ftype, ext->x_file.x_ftype);
586 break;
587
588 /* RS/6000 "csect" auxents */
589 case C_EXT:
590 case C_AIX_WEAKEXT:
591 case C_HIDEXT:
592 if (indx + 1 == numaux)
593 {
594 H_PUT_32 (abfd, in->x_csect.x_scnlen.l, ext->x_csect.x_scnlen);
595 H_PUT_32 (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash);
596 H_PUT_16 (abfd, in->x_csect.x_snhash, ext->x_csect.x_snhash);
597 /* We don't have to hack bitfields in x_smtyp because it's
598 defined by shifts-and-ands, which are equivalent on all
599 byte orders. */
600 H_PUT_8 (abfd, in->x_csect.x_smtyp, ext->x_csect.x_smtyp);
601 H_PUT_8 (abfd, in->x_csect.x_smclas, ext->x_csect.x_smclas);
602 H_PUT_32 (abfd, in->x_csect.x_stab, ext->x_csect.x_stab);
603 H_PUT_16 (abfd, in->x_csect.x_snstab, ext->x_csect.x_snstab);
604 }
605 else
606 {
607 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_fcn.x_fsize);
608 H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,
609 ext->x_fcn.x_lnnoptr);
610 H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l,
611 ext->x_fcn.x_endndx);
612 }
613 break;
614
615 case C_STAT:
616 H_PUT_32 (abfd, in->x_scn.x_scnlen, ext->x_scn.x_scnlen);
617 H_PUT_16 (abfd, in->x_scn.x_nreloc, ext->x_scn.x_nreloc);
618 H_PUT_16 (abfd, in->x_scn.x_nlinno, ext->x_scn.x_nlinno);
619 break;
620
621 case C_BLOCK:
622 case C_FCN:
623 H_PUT_32 (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext->x_sym.x_lnno);
624 break;
625
626 case C_DWARF:
627 H_PUT_32 (abfd, in->x_sect.x_scnlen, ext->x_sect.x_scnlen);
628 H_PUT_32 (abfd, in->x_sect.x_nreloc, ext->x_sect.x_nreloc);
629 break;
630 }
631
632 return bfd_coff_auxesz (abfd);
633 }
634 \f
635 /* The XCOFF reloc table.
636 XCOFF relocations aren't defined only by the type field r_type.
637 The bitsize and whether they are signed or not, are defined by
638 r_size field. Thus, it's complicated to create a constant
639 table reference every possible relocation.
640 This table contains the "default" relocation and few modified
641 relocations what were already there. It's enough when
642 xcoff_rtype2howto is called.
643 For relocations from an input bfd to an output bfd, the default
644 relocation is retrieved and when manually adapted.
645
646 For now, it seems to be enought. */
647
648 reloc_howto_type xcoff_howto_table[] =
649 {
650 /* 0x00: Standard 32 bit relocation. */
651 HOWTO (R_POS, /* type */
652 0, /* rightshift */
653 4, /* size */
654 32, /* bitsize */
655 false, /* pc_relative */
656 0, /* bitpos */
657 complain_overflow_bitfield, /* complain_on_overflow */
658 0, /* special_function */
659 "R_POS", /* name */
660 true, /* partial_inplace */
661 0xffffffff, /* src_mask */
662 0xffffffff, /* dst_mask */
663 false), /* pcrel_offset */
664
665 /* 0x01: 32 bit relocation, but store negative value. */
666 HOWTO (R_NEG, /* type */
667 0, /* rightshift */
668 -4, /* size */
669 32, /* bitsize */
670 false, /* pc_relative */
671 0, /* bitpos */
672 complain_overflow_bitfield, /* complain_on_overflow */
673 0, /* special_function */
674 "R_NEG", /* name */
675 true, /* partial_inplace */
676 0xffffffff, /* src_mask */
677 0xffffffff, /* dst_mask */
678 false), /* pcrel_offset */
679
680 /* 0x02: 32 bit PC relative relocation. */
681 HOWTO (R_REL, /* type */
682 0, /* rightshift */
683 4, /* size */
684 32, /* bitsize */
685 true, /* pc_relative */
686 0, /* bitpos */
687 complain_overflow_signed, /* complain_on_overflow */
688 0, /* special_function */
689 "R_REL", /* name */
690 true, /* partial_inplace */
691 0xffffffff, /* src_mask */
692 0xffffffff, /* dst_mask */
693 false), /* pcrel_offset */
694
695 /* 0x03: 16 bit TOC relative relocation. */
696 HOWTO (R_TOC, /* type */
697 0, /* rightshift */
698 2, /* size */
699 16, /* bitsize */
700 false, /* pc_relative */
701 0, /* bitpos */
702 complain_overflow_bitfield, /* complain_on_overflow */
703 0, /* special_function */
704 "R_TOC", /* name */
705 true, /* partial_inplace */
706 0, /* src_mask */
707 0xffff, /* dst_mask */
708 false), /* pcrel_offset */
709
710 /* 0x04: Same as R_TOC */
711 HOWTO (R_TRL, /* type */
712 0, /* rightshift */
713 2, /* size */
714 16, /* bitsize */
715 false, /* pc_relative */
716 0, /* bitpos */
717 complain_overflow_bitfield, /* complain_on_overflow */
718 0, /* special_function */
719 "R_TRL", /* name */
720 true, /* partial_inplace */
721 0, /* src_mask */
722 0xffff, /* dst_mask */
723 false), /* pcrel_offset */
724
725 /* 0x05: External TOC relative symbol. */
726 HOWTO (R_GL, /* type */
727 0, /* rightshift */
728 2, /* size */
729 16, /* bitsize */
730 false, /* pc_relative */
731 0, /* bitpos */
732 complain_overflow_bitfield, /* complain_on_overflow */
733 0, /* special_function */
734 "R_GL", /* name */
735 true, /* partial_inplace */
736 0, /* src_mask */
737 0xffff, /* dst_mask */
738 false), /* pcrel_offset */
739
740 /* 0x06: Local TOC relative symbol. */
741 HOWTO (R_TCL, /* type */
742 0, /* rightshift */
743 2, /* size */
744 16, /* bitsize */
745 false, /* pc_relative */
746 0, /* bitpos */
747 complain_overflow_bitfield, /* complain_on_overflow */
748 0, /* special_function */
749 "R_TCL", /* name */
750 true, /* partial_inplace */
751 0, /* src_mask */
752 0xffff, /* dst_mask */
753 false), /* pcrel_offset */
754
755 EMPTY_HOWTO (7),
756
757 /* 0x08: Same as R_RBA. */
758 HOWTO (R_BA, /* type */
759 0, /* rightshift */
760 4, /* size */
761 26, /* bitsize */
762 false, /* pc_relative */
763 0, /* bitpos */
764 complain_overflow_bitfield, /* complain_on_overflow */
765 0, /* special_function */
766 "R_BA_26", /* name */
767 true, /* partial_inplace */
768 0x03fffffc, /* src_mask */
769 0x03fffffc, /* dst_mask */
770 false), /* pcrel_offset */
771
772 EMPTY_HOWTO (9),
773
774 /* 0x0a: Same as R_RBR. */
775 HOWTO (R_BR, /* type */
776 0, /* rightshift */
777 4, /* size */
778 26, /* bitsize */
779 true, /* pc_relative */
780 0, /* bitpos */
781 complain_overflow_signed, /* complain_on_overflow */
782 0, /* special_function */
783 "R_BR", /* name */
784 true, /* partial_inplace */
785 0x03fffffc, /* src_mask */
786 0x03fffffc, /* dst_mask */
787 false), /* pcrel_offset */
788
789 EMPTY_HOWTO (0xb),
790
791 /* 0x0c: Same as R_POS. */
792 HOWTO (R_RL, /* type */
793 0, /* rightshift */
794 4, /* size */
795 32, /* bitsize */
796 false, /* pc_relative */
797 0, /* bitpos */
798 complain_overflow_bitfield, /* complain_on_overflow */
799 0, /* special_function */
800 "R_RL", /* name */
801 true, /* partial_inplace */
802 0xffffffff, /* src_mask */
803 0xffffffff, /* dst_mask */
804 false), /* pcrel_offset */
805
806 /* 0x0d: Same as R_POS. */
807 HOWTO (R_RLA, /* type */
808 0, /* rightshift */
809 4, /* size */
810 32, /* bitsize */
811 false, /* pc_relative */
812 0, /* bitpos */
813 complain_overflow_bitfield, /* complain_on_overflow */
814 0, /* special_function */
815 "R_RLA", /* name */
816 true, /* partial_inplace */
817 0xffffffff, /* src_mask */
818 0xffffffff, /* dst_mask */
819 false), /* pcrel_offset */
820
821 EMPTY_HOWTO (0xe),
822
823 /* 0x0f: Non-relocating reference. Bitsize is 1 so that r_rsize is 0. */
824 HOWTO (R_REF, /* type */
825 0, /* rightshift */
826 1, /* size */
827 1, /* bitsize */
828 false, /* pc_relative */
829 0, /* bitpos */
830 complain_overflow_dont, /* complain_on_overflow */
831 0, /* special_function */
832 "R_REF", /* name */
833 false, /* partial_inplace */
834 0, /* src_mask */
835 0, /* dst_mask */
836 false), /* pcrel_offset */
837
838 EMPTY_HOWTO (0x10),
839 EMPTY_HOWTO (0x11),
840 EMPTY_HOWTO (0x12),
841
842 /* 0x13: Same as R_TOC. */
843 HOWTO (R_TRLA, /* type */
844 0, /* rightshift */
845 2, /* size */
846 16, /* bitsize */
847 false, /* pc_relative */
848 0, /* bitpos */
849 complain_overflow_bitfield, /* complain_on_overflow */
850 0, /* special_function */
851 "R_TRLA", /* name */
852 true, /* partial_inplace */
853 0, /* src_mask */
854 0xffff, /* dst_mask */
855 false), /* pcrel_offset */
856
857 /* 0x14: Modifiable relative branch. */
858 HOWTO (R_RRTBI, /* type */
859 1, /* rightshift */
860 4, /* size */
861 32, /* bitsize */
862 false, /* pc_relative */
863 0, /* bitpos */
864 complain_overflow_bitfield, /* complain_on_overflow */
865 0, /* special_function */
866 "R_RRTBI", /* name */
867 true, /* partial_inplace */
868 0xffffffff, /* src_mask */
869 0xffffffff, /* dst_mask */
870 false), /* pcrel_offset */
871
872 /* 0x15: Modifiable absolute branch. */
873 HOWTO (R_RRTBA, /* type */
874 1, /* rightshift */
875 4, /* size */
876 32, /* bitsize */
877 false, /* pc_relative */
878 0, /* bitpos */
879 complain_overflow_bitfield, /* complain_on_overflow */
880 0, /* special_function */
881 "R_RRTBA", /* name */
882 true, /* partial_inplace */
883 0xffffffff, /* src_mask */
884 0xffffffff, /* dst_mask */
885 false), /* pcrel_offset */
886
887 /* 0x16: Modifiable call absolute indirect. */
888 HOWTO (R_CAI, /* type */
889 0, /* rightshift */
890 2, /* size */
891 16, /* bitsize */
892 false, /* pc_relative */
893 0, /* bitpos */
894 complain_overflow_bitfield, /* complain_on_overflow */
895 0, /* special_function */
896 "R_CAI", /* name */
897 true, /* partial_inplace */
898 0xffff, /* src_mask */
899 0xffff, /* dst_mask */
900 false), /* pcrel_offset */
901
902 /* 0x17: Modifiable call relative. */
903 HOWTO (R_CREL, /* type */
904 0, /* rightshift */
905 2, /* size */
906 16, /* bitsize */
907 false, /* pc_relative */
908 0, /* bitpos */
909 complain_overflow_bitfield, /* complain_on_overflow */
910 0, /* special_function */
911 "R_CREL", /* name */
912 true, /* partial_inplace */
913 0xffff, /* src_mask */
914 0xffff, /* dst_mask */
915 false), /* pcrel_offset */
916
917 /* 0x18: Modifiable branch absolute. */
918 HOWTO (R_RBA, /* type */
919 0, /* rightshift */
920 4, /* size */
921 26, /* bitsize */
922 false, /* pc_relative */
923 0, /* bitpos */
924 complain_overflow_bitfield, /* complain_on_overflow */
925 0, /* special_function */
926 "R_RBA", /* name */
927 true, /* partial_inplace */
928 0x03fffffc, /* src_mask */
929 0x03fffffc, /* dst_mask */
930 false), /* pcrel_offset */
931
932 /* 0x19: Modifiable branch absolute. */
933 HOWTO (R_RBAC, /* type */
934 0, /* rightshift */
935 4, /* size */
936 32, /* bitsize */
937 false, /* pc_relative */
938 0, /* bitpos */
939 complain_overflow_bitfield, /* complain_on_overflow */
940 0, /* special_function */
941 "R_RBAC", /* name */
942 true, /* partial_inplace */
943 0xffffffff, /* src_mask */
944 0xffffffff, /* dst_mask */
945 false), /* pcrel_offset */
946
947 /* 0x1a: Modifiable branch relative. */
948 HOWTO (R_RBR, /* type */
949 0, /* rightshift */
950 4, /* size */
951 26, /* bitsize */
952 false, /* pc_relative */
953 0, /* bitpos */
954 complain_overflow_signed, /* complain_on_overflow */
955 0, /* special_function */
956 "R_RBR_26", /* name */
957 true, /* partial_inplace */
958 0x03fffffc, /* src_mask */
959 0x03fffffc, /* dst_mask */
960 false), /* pcrel_offset */
961
962 /* 0x1b: Modifiable branch absolute. */
963 HOWTO (R_RBRC, /* type */
964 0, /* rightshift */
965 2, /* size */
966 16, /* bitsize */
967 false, /* pc_relative */
968 0, /* bitpos */
969 complain_overflow_bitfield, /* complain_on_overflow */
970 0, /* special_function */
971 "R_RBRC", /* name */
972 true, /* partial_inplace */
973 0xffff, /* src_mask */
974 0xffff, /* dst_mask */
975 false), /* pcrel_offset */
976
977 /* 0x1c: 16 bit Non modifiable absolute branch. */
978 HOWTO (R_BA, /* type */
979 0, /* rightshift */
980 2, /* size */
981 16, /* bitsize */
982 false, /* pc_relative */
983 0, /* bitpos */
984 complain_overflow_bitfield, /* complain_on_overflow */
985 0, /* special_function */
986 "R_BA_16", /* name */
987 true, /* partial_inplace */
988 0xfffc, /* src_mask */
989 0xfffc, /* dst_mask */
990 false), /* pcrel_offset */
991
992 /* 0x1d: Modifiable branch relative. */
993 HOWTO (R_RBR, /* type */
994 0, /* rightshift */
995 2, /* size */
996 16, /* bitsize */
997 true, /* pc_relative */
998 0, /* bitpos */
999 complain_overflow_signed, /* complain_on_overflow */
1000 0, /* special_function */
1001 "R_RBR_16", /* name */
1002 true, /* partial_inplace */
1003 0xfffc, /* src_mask */
1004 0xfffc, /* dst_mask */
1005 false), /* pcrel_offset */
1006
1007 /* 0x1e: Modifiable branch relative. */
1008 HOWTO (R_RBA, /* type */
1009 0, /* rightshift */
1010 2, /* size */
1011 16, /* bitsize */
1012 false, /* pc_relative */
1013 0, /* bitpos */
1014 complain_overflow_signed, /* complain_on_overflow */
1015 0, /* special_function */
1016 "R_RBA_16", /* name */
1017 true, /* partial_inplace */
1018 0xffff, /* src_mask */
1019 0xffff, /* dst_mask */
1020 false), /* pcrel_offset */
1021
1022 EMPTY_HOWTO (0x1f),
1023
1024 /* 0x20: General-dynamic TLS relocation. */
1025 HOWTO (R_TLS, /* type */
1026 0, /* rightshift */
1027 4, /* size */
1028 32, /* bitsize */
1029 false, /* pc_relative */
1030 0, /* bitpos */
1031 complain_overflow_bitfield, /* complain_on_overflow */
1032 0, /* special_function */
1033 "R_TLS", /* name */
1034 true, /* partial_inplace */
1035 0xffffffff, /* src_mask */
1036 0xffffffff, /* dst_mask */
1037 false), /* pcrel_offset */
1038
1039 /* 0x21: Initial-exec TLS relocation. */
1040 HOWTO (R_TLS_IE, /* type */
1041 0, /* rightshift */
1042 4, /* size */
1043 32, /* bitsize */
1044 false, /* pc_relative */
1045 0, /* bitpos */
1046 complain_overflow_bitfield, /* complain_on_overflow */
1047 0, /* special_function */
1048 "R_TLS_IE", /* name */
1049 true, /* partial_inplace */
1050 0xffffffff, /* src_mask */
1051 0xffffffff, /* dst_mask */
1052 false), /* pcrel_offset */
1053
1054 /* 0x22: Local-dynamic TLS relocation. */
1055 HOWTO (R_TLS_LD, /* type */
1056 0, /* rightshift */
1057 4, /* size */
1058 32, /* bitsize */
1059 false, /* pc_relative */
1060 0, /* bitpos */
1061 complain_overflow_bitfield, /* complain_on_overflow */
1062 0, /* special_function */
1063 "R_TLS_LD", /* name */
1064 true, /* partial_inplace */
1065 0xffffffff, /* src_mask */
1066 0xffffffff, /* dst_mask */
1067 false), /* pcrel_offset */
1068
1069 /* 0x23: Local-exec TLS relocation. */
1070 HOWTO (R_TLS_LE, /* type */
1071 0, /* rightshift */
1072 4, /* size */
1073 32, /* bitsize */
1074 false, /* pc_relative */
1075 0, /* bitpos */
1076 complain_overflow_bitfield, /* complain_on_overflow */
1077 0, /* special_function */
1078 "R_TLS_LE", /* name */
1079 true, /* partial_inplace */
1080 0xffffffff, /* src_mask */
1081 0xffffffff, /* dst_mask */
1082 false), /* pcrel_offset */
1083
1084 /* 0x24: TLS relocation. */
1085 HOWTO (R_TLSM, /* type */
1086 0, /* rightshift */
1087 4, /* size */
1088 32, /* bitsize */
1089 false, /* pc_relative */
1090 0, /* bitpos */
1091 complain_overflow_bitfield, /* complain_on_overflow */
1092 0, /* special_function */
1093 "R_TLSM", /* name */
1094 true, /* partial_inplace */
1095 0xffffffff, /* src_mask */
1096 0xffffffff, /* dst_mask */
1097 false), /* pcrel_offset */
1098
1099
1100 /* 0x25: TLS module relocation. */
1101 HOWTO (R_TLSML, /* type */
1102 0, /* rightshift */
1103 4, /* size */
1104 32, /* bitsize */
1105 false, /* pc_relative */
1106 0, /* bitpos */
1107 complain_overflow_bitfield, /* complain_on_overflow */
1108 0, /* special_function */
1109 "R_TLSML", /* name */
1110 true, /* partial_inplace */
1111 0xffffffff, /* src_mask */
1112 0xffffffff, /* dst_mask */
1113 false), /* pcrel_offset */
1114
1115 EMPTY_HOWTO(0x26),
1116 EMPTY_HOWTO(0x27),
1117 EMPTY_HOWTO(0x28),
1118 EMPTY_HOWTO(0x29),
1119 EMPTY_HOWTO(0x2a),
1120 EMPTY_HOWTO(0x2b),
1121 EMPTY_HOWTO(0x2c),
1122 EMPTY_HOWTO(0x2d),
1123 EMPTY_HOWTO(0x2e),
1124 EMPTY_HOWTO(0x2f),
1125
1126 /* 0x30: High-order 16 bit TOC relative relocation. */
1127 HOWTO (R_TOCU, /* type */
1128 16, /* rightshift */
1129 2, /* size */
1130 16, /* bitsize */
1131 false, /* pc_relative */
1132 0, /* bitpos */
1133 complain_overflow_bitfield, /* complain_on_overflow */
1134 0, /* special_function */
1135 "R_TOCU", /* name */
1136 true, /* partial_inplace */
1137 0, /* src_mask */
1138 0xffff, /* dst_mask */
1139 false), /* pcrel_offset */
1140
1141 /* 0x31: Low-order 16 bit TOC relative relocation. */
1142 HOWTO (R_TOCL, /* type */
1143 0, /* rightshift */
1144 2, /* size */
1145 16, /* bitsize */
1146 false, /* pc_relative */
1147 0, /* bitpos */
1148 complain_overflow_dont, /* complain_on_overflow */
1149 0, /* special_function */
1150 "R_TOCL", /* name */
1151 true, /* partial_inplace */
1152 0, /* src_mask */
1153 0xffff, /* dst_mask */
1154 false), /* pcrel_offset */
1155
1156 };
1157
1158 void
1159 xcoff_rtype2howto (arelent *relent, struct internal_reloc *internal)
1160 {
1161 if (internal->r_type > R_TOCL)
1162 abort ();
1163
1164 /* Default howto layout works most of the time */
1165 relent->howto = &xcoff_howto_table[internal->r_type];
1166
1167 /* Special case some 16 bit reloc */
1168 if (15 == (internal->r_size & 0x1f))
1169 {
1170 if (R_BA == internal->r_type)
1171 relent->howto = &xcoff_howto_table[0x1c];
1172 else if (R_RBR == internal->r_type)
1173 relent->howto = &xcoff_howto_table[0x1d];
1174 else if (R_RBA == internal->r_type)
1175 relent->howto = &xcoff_howto_table[0x1e];
1176 }
1177
1178 /* The r_size field of an XCOFF reloc encodes the bitsize of the
1179 relocation, as well as indicating whether it is signed or not.
1180 Doublecheck that the relocation information gathered from the
1181 type matches this information. The bitsize is not significant
1182 for R_REF relocs. */
1183 if (relent->howto->dst_mask != 0
1184 && (relent->howto->bitsize
1185 != ((unsigned int) internal->r_size & 0x1f) + 1))
1186 abort ();
1187 }
1188
1189 reloc_howto_type *
1190 _bfd_xcoff_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1191 bfd_reloc_code_real_type code)
1192 {
1193 switch (code)
1194 {
1195 case BFD_RELOC_PPC_B26:
1196 return &xcoff_howto_table[0xa];
1197 case BFD_RELOC_PPC_BA16:
1198 return &xcoff_howto_table[0x1c];
1199 case BFD_RELOC_PPC_BA26:
1200 return &xcoff_howto_table[8];
1201 case BFD_RELOC_PPC_TOC16:
1202 return &xcoff_howto_table[3];
1203 case BFD_RELOC_PPC_TOC16_HI:
1204 return &xcoff_howto_table[0x30];
1205 case BFD_RELOC_PPC_TOC16_LO:
1206 return &xcoff_howto_table[0x31];
1207 case BFD_RELOC_PPC_B16:
1208 return &xcoff_howto_table[0x1d];
1209 case BFD_RELOC_32:
1210 case BFD_RELOC_CTOR:
1211 return &xcoff_howto_table[0];
1212 case BFD_RELOC_NONE:
1213 return &xcoff_howto_table[0xf];
1214 case BFD_RELOC_PPC_NEG:
1215 return &xcoff_howto_table[0x1];
1216 case BFD_RELOC_PPC_TLSGD:
1217 return &xcoff_howto_table[0x20];
1218 case BFD_RELOC_PPC_TLSIE:
1219 return &xcoff_howto_table[0x21];
1220 case BFD_RELOC_PPC_TLSLD:
1221 return &xcoff_howto_table[0x22];
1222 case BFD_RELOC_PPC_TLSLE:
1223 return &xcoff_howto_table[0x23];
1224 case BFD_RELOC_PPC_TLSM:
1225 return &xcoff_howto_table[0x24];
1226 case BFD_RELOC_PPC_TLSML:
1227 return &xcoff_howto_table[0x25];
1228 default:
1229 return NULL;
1230 }
1231 }
1232
1233 static reloc_howto_type *
1234 _bfd_xcoff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1235 const char *r_name)
1236 {
1237 unsigned int i;
1238
1239 for (i = 0;
1240 i < sizeof (xcoff_howto_table) / sizeof (xcoff_howto_table[0]);
1241 i++)
1242 if (xcoff_howto_table[i].name != NULL
1243 && strcasecmp (xcoff_howto_table[i].name, r_name) == 0)
1244 return &xcoff_howto_table[i];
1245
1246 return NULL;
1247 }
1248 \f
1249 /* XCOFF archive support. The original version of this code was by
1250 Damon A. Permezel. It was enhanced to permit cross support, and
1251 writing archive files, by Ian Lance Taylor, Cygnus Support.
1252
1253 XCOFF uses its own archive format. Everything is hooked together
1254 with file offset links, so it is possible to rapidly update an
1255 archive in place. Of course, we don't do that. An XCOFF archive
1256 has a real file header, not just an ARMAG string. The structure of
1257 the file header and of each archive header appear below.
1258
1259 An XCOFF archive also has a member table, which is a list of
1260 elements in the archive (you can get that by looking through the
1261 linked list, but you have to read a lot more of the file). The
1262 member table has a normal archive header with an empty name. It is
1263 normally (and perhaps must be) the second to last entry in the
1264 archive. The member table data is almost printable ASCII. It
1265 starts with a 12 character decimal string which is the number of
1266 entries in the table. For each entry it has a 12 character decimal
1267 string which is the offset in the archive of that member. These
1268 entries are followed by a series of null terminated strings which
1269 are the member names for each entry.
1270
1271 Finally, an XCOFF archive has a global symbol table, which is what
1272 we call the armap. The global symbol table has a normal archive
1273 header with an empty name. It is normally (and perhaps must be)
1274 the last entry in the archive. The contents start with a four byte
1275 binary number which is the number of entries. This is followed by
1276 a that many four byte binary numbers; each is the file offset of an
1277 entry in the archive. These numbers are followed by a series of
1278 null terminated strings, which are symbol names.
1279
1280 AIX 4.3 introduced a new archive format which can handle larger
1281 files and also 32- and 64-bit objects in the same archive. The
1282 things said above remain true except that there is now more than
1283 one global symbol table. The one is used to index 32-bit objects,
1284 the other for 64-bit objects.
1285
1286 The new archives (recognizable by the new ARMAG string) has larger
1287 field lengths so that we cannot really share any code. Also we have
1288 to take care that we are not generating the new form of archives
1289 on AIX 4.2 or earlier systems. */
1290
1291 /* PR 21786: The PE/COFF standard does not require NUL termination for any of
1292 the ASCII fields in the archive headers. So in order to be able to extract
1293 numerical values we provide our own versions of strtol and strtoll which
1294 take a maximum length as an additional parameter. Also - just to save space,
1295 we omit the endptr return parameter, since we know that it is never used. */
1296
1297 static long
1298 _bfd_strntol (const char * nptr, int base, unsigned int maxlen)
1299 {
1300 char buf[24]; /* Should be enough. */
1301
1302 BFD_ASSERT (maxlen < (sizeof (buf) - 1));
1303
1304 memcpy (buf, nptr, maxlen);
1305 buf[maxlen] = 0;
1306 return strtol (buf, NULL, base);
1307 }
1308
1309 static long long
1310 _bfd_strntoll (const char * nptr, int base, unsigned int maxlen)
1311 {
1312 char buf[32]; /* Should be enough. */
1313
1314 BFD_ASSERT (maxlen < (sizeof (buf) - 1));
1315
1316 memcpy (buf, nptr, maxlen);
1317 buf[maxlen] = 0;
1318 return strtoll (buf, NULL, base);
1319 }
1320
1321 /* Macro to read an ASCII value stored in an archive header field. */
1322 #define GET_VALUE_IN_FIELD(VAR, FIELD, BASE) \
1323 do \
1324 { \
1325 (VAR) = (sizeof (VAR) > sizeof (long) \
1326 ? _bfd_strntoll (FIELD, BASE, sizeof FIELD) \
1327 : _bfd_strntol (FIELD, BASE, sizeof FIELD)); \
1328 } \
1329 while (0)
1330
1331 #define EQ_VALUE_IN_FIELD(VAR, FIELD, BASE) \
1332 (sizeof (VAR) > sizeof (long) \
1333 ? (VAR) == _bfd_strntoll (FIELD, BASE, sizeof FIELD) \
1334 : (VAR) == _bfd_strntol (FIELD, BASE, sizeof FIELD))
1335
1336 /* Read in the armap of an XCOFF archive. */
1337
1338 bool
1339 _bfd_xcoff_slurp_armap (bfd *abfd)
1340 {
1341 file_ptr off;
1342 size_t namlen;
1343 bfd_size_type sz;
1344 bfd_byte *contents, *cend;
1345 bfd_vma c, i;
1346 carsym *arsym;
1347 bfd_byte *p;
1348
1349 if (xcoff_ardata (abfd) == NULL)
1350 {
1351 abfd->has_armap = false;
1352 return true;
1353 }
1354
1355 if (! xcoff_big_format_p (abfd))
1356 {
1357 /* This is for the old format. */
1358 struct xcoff_ar_hdr hdr;
1359
1360 GET_VALUE_IN_FIELD (off, xcoff_ardata (abfd)->symoff, 10);
1361 if (off == 0)
1362 {
1363 abfd->has_armap = false;
1364 return true;
1365 }
1366
1367 if (bfd_seek (abfd, off, SEEK_SET) != 0)
1368 return false;
1369
1370 /* The symbol table starts with a normal archive header. */
1371 if (bfd_bread (&hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
1372 != SIZEOF_AR_HDR)
1373 return false;
1374
1375 /* Skip the name (normally empty). */
1376 GET_VALUE_IN_FIELD (namlen, hdr.namlen, 10);
1377 off = ((namlen + 1) & ~ (size_t) 1) + SXCOFFARFMAG;
1378 if (bfd_seek (abfd, off, SEEK_CUR) != 0)
1379 return false;
1380
1381 GET_VALUE_IN_FIELD (sz, hdr.size, 10);
1382 if (sz + 1 < 5)
1383 {
1384 bfd_set_error (bfd_error_bad_value);
1385 return false;
1386 }
1387
1388 /* Read in the entire symbol table. */
1389 contents = (bfd_byte *) _bfd_alloc_and_read (abfd, sz + 1, sz);
1390 if (contents == NULL)
1391 return false;
1392
1393 /* Ensure strings are NULL terminated so we don't wander off the
1394 end of the buffer. */
1395 contents[sz] = 0;
1396
1397 /* The symbol table starts with a four byte count. */
1398 c = H_GET_32 (abfd, contents);
1399
1400 if (c >= sz / 4)
1401 {
1402 bfd_set_error (bfd_error_bad_value);
1403 return false;
1404 }
1405
1406 bfd_ardata (abfd)->symdefs =
1407 ((carsym *) bfd_alloc (abfd, c * sizeof (carsym)));
1408 if (bfd_ardata (abfd)->symdefs == NULL)
1409 return false;
1410
1411 /* After the count comes a list of four byte file offsets. */
1412 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 4;
1413 i < c;
1414 ++i, ++arsym, p += 4)
1415 arsym->file_offset = H_GET_32 (abfd, p);
1416 }
1417 else
1418 {
1419 /* This is for the new format. */
1420 struct xcoff_ar_hdr_big hdr;
1421
1422 GET_VALUE_IN_FIELD (off, xcoff_ardata_big (abfd)->symoff, 10);
1423 if (off == 0)
1424 {
1425 abfd->has_armap = false;
1426 return true;
1427 }
1428
1429 if (bfd_seek (abfd, off, SEEK_SET) != 0)
1430 return false;
1431
1432 /* The symbol table starts with a normal archive header. */
1433 if (bfd_bread (&hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
1434 != SIZEOF_AR_HDR_BIG)
1435 return false;
1436
1437 /* Skip the name (normally empty). */
1438 GET_VALUE_IN_FIELD (namlen, hdr.namlen, 10);
1439 off = ((namlen + 1) & ~ (size_t) 1) + SXCOFFARFMAG;
1440 if (bfd_seek (abfd, off, SEEK_CUR) != 0)
1441 return false;
1442
1443 GET_VALUE_IN_FIELD (sz, hdr.size, 10);
1444 if (sz + 1 < 9)
1445 {
1446 bfd_set_error (bfd_error_bad_value);
1447 return false;
1448 }
1449
1450 /* Read in the entire symbol table. */
1451 contents = (bfd_byte *) _bfd_alloc_and_read (abfd, sz + 1, sz);
1452 if (contents == NULL)
1453 return false;
1454
1455 /* Ensure strings are NULL terminated so we don't wander off the
1456 end of the buffer. */
1457 contents[sz] = 0;
1458
1459 /* The symbol table starts with an eight byte count. */
1460 c = H_GET_64 (abfd, contents);
1461
1462 if (c >= sz / 8)
1463 {
1464 bfd_set_error (bfd_error_bad_value);
1465 return false;
1466 }
1467
1468 bfd_ardata (abfd)->symdefs =
1469 ((carsym *) bfd_alloc (abfd, c * sizeof (carsym)));
1470 if (bfd_ardata (abfd)->symdefs == NULL)
1471 return false;
1472
1473 /* After the count comes a list of eight byte file offsets. */
1474 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 8;
1475 i < c;
1476 ++i, ++arsym, p += 8)
1477 arsym->file_offset = H_GET_64 (abfd, p);
1478 }
1479
1480 /* After the file offsets come null terminated symbol names. */
1481 cend = contents + sz;
1482 for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
1483 i < c;
1484 ++i, ++arsym, p += strlen ((char *) p) + 1)
1485 {
1486 if (p >= cend)
1487 {
1488 bfd_set_error (bfd_error_bad_value);
1489 return false;
1490 }
1491 arsym->name = (char *) p;
1492 }
1493
1494 bfd_ardata (abfd)->symdef_count = c;
1495 abfd->has_armap = true;
1496
1497 return true;
1498 }
1499
1500 /* See if this is an XCOFF archive. */
1501
1502 bfd_cleanup
1503 _bfd_xcoff_archive_p (bfd *abfd)
1504 {
1505 struct artdata *tdata_hold;
1506 char magic[SXCOFFARMAG];
1507 size_t amt = SXCOFFARMAG;
1508
1509 if (bfd_bread (magic, amt, abfd) != amt)
1510 {
1511 if (bfd_get_error () != bfd_error_system_call)
1512 bfd_set_error (bfd_error_wrong_format);
1513 return NULL;
1514 }
1515
1516 if (strncmp (magic, XCOFFARMAG, SXCOFFARMAG) != 0
1517 && strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0)
1518 {
1519 bfd_set_error (bfd_error_wrong_format);
1520 return NULL;
1521 }
1522
1523 tdata_hold = bfd_ardata (abfd);
1524
1525 amt = sizeof (struct artdata);
1526 bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
1527 if (bfd_ardata (abfd) == (struct artdata *) NULL)
1528 goto error_ret_restore;
1529
1530 /* Cleared by bfd_zalloc above.
1531 bfd_ardata (abfd)->cache = NULL;
1532 bfd_ardata (abfd)->archive_head = NULL;
1533 bfd_ardata (abfd)->symdefs = NULL;
1534 bfd_ardata (abfd)->extended_names = NULL;
1535 bfd_ardata (abfd)->extended_names_size = 0; */
1536
1537 /* Now handle the two formats. */
1538 if (magic[1] != 'b')
1539 {
1540 /* This is the old format. */
1541 struct xcoff_ar_file_hdr hdr;
1542
1543 /* Copy over the magic string. */
1544 memcpy (hdr.magic, magic, SXCOFFARMAG);
1545
1546 /* Now read the rest of the file header. */
1547 amt = SIZEOF_AR_FILE_HDR - SXCOFFARMAG;
1548 if (bfd_bread (&hdr.memoff, amt, abfd) != amt)
1549 {
1550 if (bfd_get_error () != bfd_error_system_call)
1551 bfd_set_error (bfd_error_wrong_format);
1552 goto error_ret;
1553 }
1554
1555 GET_VALUE_IN_FIELD (bfd_ardata (abfd)->first_file_filepos,
1556 hdr.firstmemoff, 10);
1557
1558 amt = SIZEOF_AR_FILE_HDR;
1559 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
1560 if (bfd_ardata (abfd)->tdata == NULL)
1561 goto error_ret;
1562
1563 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR);
1564 }
1565 else
1566 {
1567 /* This is the new format. */
1568 struct xcoff_ar_file_hdr_big hdr;
1569
1570 /* Copy over the magic string. */
1571 memcpy (hdr.magic, magic, SXCOFFARMAG);
1572
1573 /* Now read the rest of the file header. */
1574 amt = SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG;
1575 if (bfd_bread (&hdr.memoff, amt, abfd) != amt)
1576 {
1577 if (bfd_get_error () != bfd_error_system_call)
1578 bfd_set_error (bfd_error_wrong_format);
1579 goto error_ret;
1580 }
1581
1582 bfd_ardata (abfd)->first_file_filepos = bfd_scan_vma (hdr.firstmemoff,
1583 (const char **) 0,
1584 10);
1585
1586 amt = SIZEOF_AR_FILE_HDR_BIG;
1587 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
1588 if (bfd_ardata (abfd)->tdata == NULL)
1589 goto error_ret;
1590
1591 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
1592 }
1593
1594 if (! _bfd_xcoff_slurp_armap (abfd))
1595 {
1596 error_ret:
1597 bfd_release (abfd, bfd_ardata (abfd));
1598 error_ret_restore:
1599 bfd_ardata (abfd) = tdata_hold;
1600 return NULL;
1601 }
1602
1603 return _bfd_no_cleanup;
1604 }
1605
1606 /* Read the archive header in an XCOFF archive. */
1607
1608 void *
1609 _bfd_xcoff_read_ar_hdr (bfd *abfd)
1610 {
1611 bfd_size_type namlen;
1612 struct areltdata *ret;
1613 bfd_size_type amt;
1614
1615 if (! xcoff_big_format_p (abfd))
1616 {
1617 struct xcoff_ar_hdr hdr;
1618 struct xcoff_ar_hdr *hdrp;
1619
1620 if (bfd_bread (&hdr, SIZEOF_AR_HDR, abfd) != SIZEOF_AR_HDR)
1621 return NULL;
1622
1623 GET_VALUE_IN_FIELD (namlen, hdr.namlen, 10);
1624 if (namlen > bfd_get_file_size (abfd))
1625 return NULL;
1626 amt = sizeof (struct areltdata) + SIZEOF_AR_HDR + namlen + 1;
1627 ret = (struct areltdata *) bfd_malloc (amt);
1628 if (ret == NULL)
1629 return ret;
1630
1631 hdrp = (struct xcoff_ar_hdr *) (ret + 1);
1632 memcpy (hdrp, &hdr, SIZEOF_AR_HDR);
1633 if (bfd_bread ((char *) hdrp + SIZEOF_AR_HDR, namlen, abfd) != namlen)
1634 {
1635 free (ret);
1636 return NULL;
1637 }
1638 ((char *) hdrp)[SIZEOF_AR_HDR + namlen] = '\0';
1639
1640 ret->arch_header = (char *) hdrp;
1641 GET_VALUE_IN_FIELD (ret->parsed_size, hdr.size, 10);
1642 ret->filename = (char *) hdrp + SIZEOF_AR_HDR;
1643 }
1644 else
1645 {
1646 struct xcoff_ar_hdr_big hdr;
1647 struct xcoff_ar_hdr_big *hdrp;
1648
1649 if (bfd_bread (&hdr, SIZEOF_AR_HDR_BIG, abfd) != SIZEOF_AR_HDR_BIG)
1650 return NULL;
1651
1652 GET_VALUE_IN_FIELD (namlen, hdr.namlen, 10);
1653 if (namlen > bfd_get_file_size (abfd))
1654 return NULL;
1655 amt = sizeof (struct areltdata) + SIZEOF_AR_HDR_BIG + namlen + 1;
1656 ret = (struct areltdata *) bfd_malloc (amt);
1657 if (ret == NULL)
1658 return ret;
1659
1660 hdrp = (struct xcoff_ar_hdr_big *) (ret + 1);
1661 memcpy (hdrp, &hdr, SIZEOF_AR_HDR_BIG);
1662 if (bfd_bread ((char *) hdrp + SIZEOF_AR_HDR_BIG, namlen, abfd) != namlen)
1663 {
1664 free (ret);
1665 return NULL;
1666 }
1667 ((char *) hdrp)[SIZEOF_AR_HDR_BIG + namlen] = '\0';
1668
1669 ret->arch_header = (char *) hdrp;
1670 GET_VALUE_IN_FIELD (ret->parsed_size, hdr.size, 10);
1671 ret->filename = (char *) hdrp + SIZEOF_AR_HDR_BIG;
1672 }
1673
1674 /* Size occupied by the header above that covered in the fixed
1675 SIZEOF_AR_HDR or SIZEOF_AR_HDR_BIG. */
1676 ret->extra_size = namlen + (namlen & 1) + SXCOFFARFMAG;
1677
1678 /* Skip over the XCOFFARFMAG at the end of the file name. */
1679 if (bfd_seek (abfd, (file_ptr) ((namlen & 1) + SXCOFFARFMAG), SEEK_CUR) != 0)
1680 return NULL;
1681
1682 return ret;
1683 }
1684
1685 /* Open the next element in an XCOFF archive. */
1686
1687 bfd *
1688 _bfd_xcoff_openr_next_archived_file (bfd *archive, bfd *last_file)
1689 {
1690 file_ptr filestart;
1691 file_ptr laststart, lastend;
1692
1693 if (xcoff_ardata (archive) == NULL)
1694 {
1695 bfd_set_error (bfd_error_invalid_operation);
1696 return NULL;
1697 }
1698
1699 if (! xcoff_big_format_p (archive))
1700 {
1701 if (last_file == NULL)
1702 {
1703 filestart = bfd_ardata (archive)->first_file_filepos;
1704 laststart = 0;
1705 lastend = SIZEOF_AR_FILE_HDR;
1706 }
1707 else
1708 {
1709 struct areltdata *arel = arch_eltdata (last_file);
1710
1711 GET_VALUE_IN_FIELD (filestart, arch_xhdr (last_file)->nextoff, 10);
1712 laststart = last_file->proxy_origin;
1713 lastend = laststart + arel->parsed_size;
1714 laststart -= SIZEOF_AR_HDR + arel->extra_size;
1715 }
1716
1717 /* Sanity check that we aren't pointing into the previous element,
1718 or into the header. */
1719 if (filestart != 0
1720 && (filestart < SIZEOF_AR_FILE_HDR
1721 || (filestart >= laststart && filestart < lastend)))
1722 {
1723 bfd_set_error (bfd_error_malformed_archive);
1724 return NULL;
1725 }
1726
1727 if (filestart == 0
1728 || EQ_VALUE_IN_FIELD (filestart, xcoff_ardata (archive)->memoff, 10)
1729 || EQ_VALUE_IN_FIELD (filestart, xcoff_ardata (archive)->symoff, 10))
1730 {
1731 bfd_set_error (bfd_error_no_more_archived_files);
1732 return NULL;
1733 }
1734 }
1735 else
1736 {
1737 if (last_file == NULL)
1738 {
1739 filestart = bfd_ardata (archive)->first_file_filepos;
1740 laststart = 0;
1741 lastend = SIZEOF_AR_FILE_HDR_BIG;
1742 }
1743 else
1744 {
1745 struct areltdata *arel = arch_eltdata (last_file);
1746
1747 GET_VALUE_IN_FIELD (filestart, arch_xhdr_big (last_file)->nextoff, 10);
1748 laststart = last_file->proxy_origin;
1749 lastend = laststart + arel->parsed_size;
1750 laststart -= SIZEOF_AR_HDR_BIG + arel->extra_size;
1751 }
1752
1753 /* Sanity check that we aren't pointing into the previous element
1754 or into the header. */
1755 if (filestart != 0
1756 && (filestart < SIZEOF_AR_FILE_HDR_BIG
1757 || (filestart >= laststart && filestart < lastend)))
1758 {
1759 bfd_set_error (bfd_error_malformed_archive);
1760 return NULL;
1761 }
1762
1763 if (filestart == 0
1764 || EQ_VALUE_IN_FIELD (filestart, xcoff_ardata_big (archive)->memoff, 10)
1765 || EQ_VALUE_IN_FIELD (filestart, xcoff_ardata_big (archive)->symoff, 10))
1766 {
1767 bfd_set_error (bfd_error_no_more_archived_files);
1768 return NULL;
1769 }
1770 }
1771
1772 return _bfd_get_elt_at_filepos (archive, filestart, NULL);
1773 }
1774
1775 /* Stat an element in an XCOFF archive. */
1776
1777 int
1778 _bfd_xcoff_stat_arch_elt (bfd *abfd, struct stat *s)
1779 {
1780 if (abfd->arelt_data == NULL)
1781 {
1782 bfd_set_error (bfd_error_invalid_operation);
1783 return -1;
1784 }
1785
1786 if (! xcoff_big_format_p (abfd->my_archive))
1787 {
1788 struct xcoff_ar_hdr *hdrp = arch_xhdr (abfd);
1789
1790 GET_VALUE_IN_FIELD (s->st_mtime, hdrp->date, 10);
1791 GET_VALUE_IN_FIELD (s->st_uid, hdrp->uid, 10);
1792 GET_VALUE_IN_FIELD (s->st_gid, hdrp->gid, 10);
1793 GET_VALUE_IN_FIELD (s->st_mode, hdrp->mode, 8);
1794 s->st_size = arch_eltdata (abfd)->parsed_size;
1795 }
1796 else
1797 {
1798 struct xcoff_ar_hdr_big *hdrp = arch_xhdr_big (abfd);
1799
1800 GET_VALUE_IN_FIELD (s->st_mtime, hdrp->date, 10);
1801 GET_VALUE_IN_FIELD (s->st_uid, hdrp->uid, 10);
1802 GET_VALUE_IN_FIELD (s->st_gid, hdrp->gid, 10);
1803 GET_VALUE_IN_FIELD (s->st_mode, hdrp->mode, 8);
1804 s->st_size = arch_eltdata (abfd)->parsed_size;
1805 }
1806
1807 return 0;
1808 }
1809
1810 /* Normalize a file name for inclusion in an archive. */
1811
1812 static const char *
1813 normalize_filename (bfd *abfd)
1814 {
1815 const char *file;
1816 const char *filename;
1817
1818 file = bfd_get_filename (abfd);
1819 filename = strrchr (file, '/');
1820 if (filename != NULL)
1821 filename++;
1822 else
1823 filename = file;
1824 return filename;
1825 }
1826
1827 /* Write out an XCOFF armap. */
1828
1829 static bool
1830 xcoff_write_armap_old (bfd *abfd, unsigned int elength ATTRIBUTE_UNUSED,
1831 struct orl *map, unsigned int orl_count, int stridx)
1832 {
1833 struct archive_iterator iterator;
1834 struct xcoff_ar_hdr hdr;
1835 char *p;
1836 unsigned char buf[4];
1837 unsigned int i;
1838
1839 memset (&hdr, 0, sizeof hdr);
1840 sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
1841 sprintf (hdr.nextoff, "%d", 0);
1842 memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, XCOFFARMAG_ELEMENT_SIZE);
1843 sprintf (hdr.date, "%d", 0);
1844 sprintf (hdr.uid, "%d", 0);
1845 sprintf (hdr.gid, "%d", 0);
1846 sprintf (hdr.mode, "%d", 0);
1847 sprintf (hdr.namlen, "%d", 0);
1848
1849 /* We need spaces, not null bytes, in the header. */
1850 for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR; p++)
1851 if (*p == '\0')
1852 *p = ' ';
1853
1854 if (bfd_bwrite (&hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
1855 != SIZEOF_AR_HDR
1856 || (bfd_bwrite (XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
1857 != SXCOFFARFMAG))
1858 return false;
1859
1860 H_PUT_32 (abfd, orl_count, buf);
1861 if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
1862 return false;
1863
1864 i = 0;
1865 archive_iterator_begin (&iterator, abfd);
1866 while (i < orl_count && archive_iterator_next (&iterator))
1867 while (map[i].u.abfd == iterator.current.member)
1868 {
1869 H_PUT_32 (abfd, iterator.current.offset, buf);
1870 if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
1871 return false;
1872 ++i;
1873 }
1874
1875 for (i = 0; i < orl_count; i++)
1876 {
1877 const char *name;
1878 size_t namlen;
1879
1880 name = *map[i].name;
1881 namlen = strlen (name);
1882 if (bfd_bwrite (name, (bfd_size_type) (namlen + 1), abfd) != namlen + 1)
1883 return false;
1884 }
1885
1886 if ((stridx & 1) != 0)
1887 {
1888 char b;
1889
1890 b = '\0';
1891 if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
1892 return false;
1893 }
1894
1895 return true;
1896 }
1897
1898 static char buff20[XCOFFARMAGBIG_ELEMENT_SIZE + 1];
1899 #define FMT20 "%-20" PRId64
1900 #define FMT12 "%-12d"
1901 #define FMT12_OCTAL "%-12o"
1902 #define FMT4 "%-4d"
1903 #define PRINT20(d, v) \
1904 sprintf (buff20, FMT20, (uint64_t) (v)), \
1905 memcpy ((void *) (d), buff20, 20)
1906
1907 #define PRINT12(d, v) \
1908 sprintf (buff20, FMT12, (int)(v)), \
1909 memcpy ((void *) (d), buff20, 12)
1910
1911 #define PRINT12_OCTAL(d, v) \
1912 sprintf (buff20, FMT12_OCTAL, (unsigned int)(v)), \
1913 memcpy ((void *) (d), buff20, 12)
1914
1915 #define PRINT4(d, v) \
1916 sprintf (buff20, FMT4, (int)(v)), \
1917 memcpy ((void *) (d), buff20, 4)
1918
1919 #define READ20(d, v) \
1920 buff20[20] = 0, \
1921 memcpy (buff20, (d), 20), \
1922 (v) = bfd_scan_vma (buff20, (const char **) NULL, 10)
1923
1924 static bool
1925 do_pad (bfd *abfd, unsigned int number)
1926 {
1927 bfd_byte b = 0;
1928
1929 /* Limit pad to <= 4096. */
1930 if (number > 4096)
1931 return false;
1932
1933 while (number--)
1934 if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
1935 return false;
1936
1937 return true;
1938 }
1939
1940 static bool
1941 do_copy (bfd *out_bfd, bfd *in_bfd)
1942 {
1943 bfd_size_type remaining;
1944 bfd_byte buffer[DEFAULT_BUFFERSIZE];
1945
1946 if (bfd_seek (in_bfd, (file_ptr) 0, SEEK_SET) != 0)
1947 return false;
1948
1949 remaining = arelt_size (in_bfd);
1950
1951 while (remaining >= DEFAULT_BUFFERSIZE)
1952 {
1953 if (bfd_bread (buffer, DEFAULT_BUFFERSIZE, in_bfd) != DEFAULT_BUFFERSIZE
1954 || bfd_bwrite (buffer, DEFAULT_BUFFERSIZE, out_bfd) != DEFAULT_BUFFERSIZE)
1955 return false;
1956
1957 remaining -= DEFAULT_BUFFERSIZE;
1958 }
1959
1960 if (remaining)
1961 {
1962 if (bfd_bread (buffer, remaining, in_bfd) != remaining
1963 || bfd_bwrite (buffer, remaining, out_bfd) != remaining)
1964 return false;
1965 }
1966
1967 return true;
1968 }
1969
1970 static bool
1971 xcoff_write_armap_big (bfd *abfd, unsigned int elength ATTRIBUTE_UNUSED,
1972 struct orl *map, unsigned int orl_count, int stridx)
1973 {
1974 struct archive_iterator iterator;
1975 struct xcoff_ar_file_hdr_big *fhdr;
1976 bfd_vma i, sym_32, sym_64, str_32, str_64;
1977 const bfd_arch_info_type *arch_info;
1978 bfd *current_bfd;
1979 size_t string_length;
1980 file_ptr nextoff, prevoff;
1981
1982 /* First, we look through the symbols and work out which are
1983 from 32-bit objects and which from 64-bit ones. */
1984 sym_32 = sym_64 = str_32 = str_64 = 0;
1985
1986 i = 0;
1987 for (current_bfd = abfd->archive_head;
1988 current_bfd != NULL && i < orl_count;
1989 current_bfd = current_bfd->archive_next)
1990 {
1991 arch_info = bfd_get_arch_info (current_bfd);
1992 while (map[i].u.abfd == current_bfd)
1993 {
1994 string_length = strlen (*map[i].name) + 1;
1995 if (arch_info->bits_per_address == 64)
1996 {
1997 sym_64++;
1998 str_64 += string_length;
1999 }
2000 else
2001 {
2002 sym_32++;
2003 str_32 += string_length;
2004 }
2005 i++;
2006 }
2007 }
2008
2009 /* A quick sanity check... */
2010 BFD_ASSERT (sym_64 + sym_32 == orl_count);
2011 /* Explicit cast to int for compiler. */
2012 BFD_ASSERT ((int)(str_64 + str_32) == stridx);
2013
2014 fhdr = xcoff_ardata_big (abfd);
2015
2016 /* xcoff_write_archive_contents_big passes nextoff in symoff. */
2017 READ20 (fhdr->memoff, prevoff);
2018 READ20 (fhdr->symoff, nextoff);
2019
2020 BFD_ASSERT (nextoff == bfd_tell (abfd));
2021
2022 /* Write out the symbol table.
2023 Layout :
2024
2025 standard big archive header
2026 0x0000 ar_size [0x14]
2027 0x0014 ar_nxtmem [0x14]
2028 0x0028 ar_prvmem [0x14]
2029 0x003C ar_date [0x0C]
2030 0x0048 ar_uid [0x0C]
2031 0x0054 ar_gid [0x0C]
2032 0x0060 ar_mod [0x0C]
2033 0x006C ar_namelen[0x04]
2034 0x0070 ar_fmag [SXCOFFARFMAG]
2035
2036 Symbol table
2037 0x0072 num_syms [0x08], binary
2038 0x0078 offsets [0x08 * num_syms], binary
2039 0x0086 + 0x08 * num_syms names [??]
2040 ?? pad to even bytes.
2041 */
2042
2043 if (sym_32)
2044 {
2045 struct xcoff_ar_hdr_big *hdr;
2046 char *symbol_table;
2047 char *st;
2048
2049 bfd_vma symbol_table_size =
2050 SIZEOF_AR_HDR_BIG
2051 + SXCOFFARFMAG
2052 + 8
2053 + 8 * sym_32
2054 + str_32 + (str_32 & 1);
2055
2056 symbol_table = bfd_zmalloc (symbol_table_size);
2057 if (symbol_table == NULL)
2058 return false;
2059
2060 hdr = (struct xcoff_ar_hdr_big *) symbol_table;
2061
2062 PRINT20 (hdr->size, 8 + 8 * sym_32 + str_32 + (str_32 & 1));
2063
2064 if (sym_64)
2065 PRINT20 (hdr->nextoff, nextoff + symbol_table_size);
2066 else
2067 PRINT20 (hdr->nextoff, 0);
2068
2069 PRINT20 (hdr->prevoff, prevoff);
2070 PRINT12 (hdr->date, 0);
2071 PRINT12 (hdr->uid, 0);
2072 PRINT12 (hdr->gid, 0);
2073 PRINT12 (hdr->mode, 0);
2074 PRINT4 (hdr->namlen, 0) ;
2075
2076 st = symbol_table + SIZEOF_AR_HDR_BIG;
2077 memcpy (st, XCOFFARFMAG, SXCOFFARFMAG);
2078 st += SXCOFFARFMAG;
2079
2080 bfd_h_put_64 (abfd, sym_32, st);
2081 st += 8;
2082
2083 /* loop over the 32 bit offsets */
2084 i = 0;
2085 archive_iterator_begin (&iterator, abfd);
2086 while (i < orl_count && archive_iterator_next (&iterator))
2087 {
2088 arch_info = bfd_get_arch_info (iterator.current.member);
2089 while (map[i].u.abfd == iterator.current.member)
2090 {
2091 if (arch_info->bits_per_address == 32)
2092 {
2093 bfd_h_put_64 (abfd, iterator.current.offset, st);
2094 st += 8;
2095 }
2096 i++;
2097 }
2098 }
2099
2100 /* loop over the 32 bit symbol names */
2101 i = 0;
2102 for (current_bfd = abfd->archive_head;
2103 current_bfd != NULL && i < orl_count;
2104 current_bfd = current_bfd->archive_next)
2105 {
2106 arch_info = bfd_get_arch_info (current_bfd);
2107 while (map[i].u.abfd == current_bfd)
2108 {
2109 if (arch_info->bits_per_address == 32)
2110 {
2111 string_length = sprintf (st, "%s", *map[i].name);
2112 st += string_length + 1;
2113 }
2114 i++;
2115 }
2116 }
2117
2118 bfd_bwrite (symbol_table, symbol_table_size, abfd);
2119
2120 free (symbol_table);
2121
2122 prevoff = nextoff;
2123 nextoff = nextoff + symbol_table_size;
2124 }
2125 else
2126 PRINT20 (fhdr->symoff, 0);
2127
2128 if (sym_64)
2129 {
2130 struct xcoff_ar_hdr_big *hdr;
2131 char *symbol_table;
2132 char *st;
2133
2134 bfd_vma symbol_table_size =
2135 SIZEOF_AR_HDR_BIG
2136 + SXCOFFARFMAG
2137 + 8
2138 + 8 * sym_64
2139 + str_64 + (str_64 & 1);
2140
2141 symbol_table = bfd_zmalloc (symbol_table_size);
2142 if (symbol_table == NULL)
2143 return false;
2144
2145 hdr = (struct xcoff_ar_hdr_big *) symbol_table;
2146
2147 PRINT20 (hdr->size, 8 + 8 * sym_64 + str_64 + (str_64 & 1));
2148 PRINT20 (hdr->nextoff, 0);
2149 PRINT20 (hdr->prevoff, prevoff);
2150 PRINT12 (hdr->date, 0);
2151 PRINT12 (hdr->uid, 0);
2152 PRINT12 (hdr->gid, 0);
2153 PRINT12 (hdr->mode, 0);
2154 PRINT4 (hdr->namlen, 0);
2155
2156 st = symbol_table + SIZEOF_AR_HDR_BIG;
2157 memcpy (st, XCOFFARFMAG, SXCOFFARFMAG);
2158 st += SXCOFFARFMAG;
2159
2160 bfd_h_put_64 (abfd, sym_64, st);
2161 st += 8;
2162
2163 /* loop over the 64 bit offsets */
2164 i = 0;
2165 archive_iterator_begin (&iterator, abfd);
2166 while (i < orl_count && archive_iterator_next (&iterator))
2167 {
2168 arch_info = bfd_get_arch_info (iterator.current.member);
2169 while (map[i].u.abfd == iterator.current.member)
2170 {
2171 if (arch_info->bits_per_address == 64)
2172 {
2173 bfd_h_put_64 (abfd, iterator.current.offset, st);
2174 st += 8;
2175 }
2176 i++;
2177 }
2178 }
2179
2180 /* loop over the 64 bit symbol names */
2181 i = 0;
2182 for (current_bfd = abfd->archive_head;
2183 current_bfd != NULL && i < orl_count;
2184 current_bfd = current_bfd->archive_next)
2185 {
2186 arch_info = bfd_get_arch_info (current_bfd);
2187 while (map[i].u.abfd == current_bfd)
2188 {
2189 if (arch_info->bits_per_address == 64)
2190 {
2191 string_length = sprintf (st, "%s", *map[i].name);
2192 st += string_length + 1;
2193 }
2194 i++;
2195 }
2196 }
2197
2198 bfd_bwrite (symbol_table, symbol_table_size, abfd);
2199
2200 free (symbol_table);
2201
2202 PRINT20 (fhdr->symoff64, nextoff);
2203 }
2204 else
2205 PRINT20 (fhdr->symoff64, 0);
2206
2207 return true;
2208 }
2209
2210 bool
2211 _bfd_xcoff_write_armap (bfd *abfd, unsigned int elength ATTRIBUTE_UNUSED,
2212 struct orl *map, unsigned int orl_count, int stridx)
2213 {
2214 if (! xcoff_big_format_p (abfd))
2215 return xcoff_write_armap_old (abfd, elength, map, orl_count, stridx);
2216 else
2217 return xcoff_write_armap_big (abfd, elength, map, orl_count, stridx);
2218 }
2219
2220 /* Write out an XCOFF archive. We always write an entire archive,
2221 rather than fussing with the freelist and so forth. */
2222
2223 static bool
2224 xcoff_write_archive_contents_old (bfd *abfd)
2225 {
2226 struct archive_iterator iterator;
2227 struct xcoff_ar_file_hdr fhdr;
2228 bfd_size_type count;
2229 bfd_size_type total_namlen;
2230 file_ptr *offsets;
2231 bool makemap;
2232 bool hasobjects;
2233 file_ptr prevoff, nextoff;
2234 bfd *sub;
2235 size_t i;
2236 struct xcoff_ar_hdr ahdr;
2237 bfd_size_type size;
2238 char *p;
2239 char decbuf[XCOFFARMAG_ELEMENT_SIZE + 1];
2240
2241 memset (&fhdr, 0, sizeof fhdr);
2242 (void) memcpy (fhdr.magic, XCOFFARMAG, SXCOFFARMAG);
2243 sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR);
2244 sprintf (fhdr.freeoff, "%d", 0);
2245
2246 count = 0;
2247 total_namlen = 0;
2248 for (sub = abfd->archive_head; sub != NULL; sub = sub->archive_next)
2249 {
2250 ++count;
2251 total_namlen += strlen (normalize_filename (sub)) + 1;
2252 if (sub->arelt_data == NULL)
2253 {
2254 sub->arelt_data = bfd_zmalloc (sizeof (struct areltdata));
2255 if (sub->arelt_data == NULL)
2256 return false;
2257 }
2258 if (arch_xhdr (sub) == NULL)
2259 {
2260 struct xcoff_ar_hdr *ahdrp;
2261 struct stat s;
2262
2263 if ((sub->flags & BFD_IN_MEMORY) != 0)
2264 {
2265 /* Assume we just "made" the member, and fake it. */
2266 struct bfd_in_memory *bim
2267 = (struct bfd_in_memory *) sub->iostream;
2268 time (&s.st_mtime);
2269 s.st_uid = getuid ();
2270 s.st_gid = getgid ();
2271 s.st_mode = 0644;
2272 s.st_size = bim->size;
2273 }
2274 else if (stat (bfd_get_filename (sub), &s) != 0)
2275 {
2276 bfd_set_input_error (sub, bfd_error_system_call);
2277 return false;
2278 }
2279
2280 if ((abfd->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
2281 {
2282 s.st_mtime = 0;
2283 s.st_uid = 0;
2284 s.st_gid = 0;
2285 s.st_mode = 0644;
2286 }
2287
2288 ahdrp = bfd_zalloc (sub, sizeof (*ahdrp));
2289 if (ahdrp == NULL)
2290 return false;
2291
2292 sprintf (ahdrp->size, "%ld", (long) s.st_size);
2293 sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
2294 sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
2295 sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
2296 sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
2297
2298 arch_eltdata (sub)->arch_header = (char *) ahdrp;
2299 arch_eltdata (sub)->parsed_size = s.st_size;
2300 }
2301 }
2302 offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
2303 if (offsets == NULL)
2304 return false;
2305
2306 if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR, SEEK_SET) != 0)
2307 return false;
2308
2309 makemap = bfd_has_map (abfd);
2310 hasobjects = false;
2311 prevoff = 0;
2312 for (archive_iterator_begin (&iterator, abfd), i = 0;
2313 archive_iterator_next (&iterator);
2314 i++)
2315 {
2316 bfd_size_type namlen;
2317 struct xcoff_ar_hdr *ahdrp;
2318
2319 if (makemap && ! hasobjects)
2320 {
2321 if (bfd_check_format (iterator.current.member, bfd_object))
2322 hasobjects = true;
2323 }
2324
2325 ahdrp = arch_xhdr (iterator.current.member);
2326 sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
2327 sprintf (ahdrp->namlen, "%ld", (long) iterator.current.namlen);
2328 sprintf (ahdrp->nextoff, "%ld", (long) iterator.next.offset);
2329
2330 /* We need spaces, not null bytes, in the header. */
2331 for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR; p++)
2332 if (*p == '\0')
2333 *p = ' ';
2334
2335 if (!do_pad (abfd, iterator.current.leading_padding))
2336 return false;
2337
2338 BFD_ASSERT (iterator.current.offset == bfd_tell (abfd));
2339 namlen = iterator.current.padded_namlen;
2340 if (bfd_bwrite (ahdrp, SIZEOF_AR_HDR, abfd) != SIZEOF_AR_HDR
2341 || bfd_bwrite (iterator.current.name, namlen, abfd) != namlen
2342 || bfd_bwrite (XCOFFARFMAG, SXCOFFARFMAG, abfd) != SXCOFFARFMAG
2343 || bfd_seek (iterator.current.member, 0, SEEK_SET) != 0
2344 || !do_copy (abfd, iterator.current.member)
2345 || !do_pad (abfd, iterator.current.trailing_padding))
2346 return false;
2347
2348 offsets[i] = iterator.current.offset;
2349 prevoff = iterator.current.offset;
2350 }
2351
2352 sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
2353
2354 /* Write out the member table. */
2355
2356 nextoff = iterator.next.offset;
2357 BFD_ASSERT (nextoff == bfd_tell (abfd));
2358 sprintf (fhdr.memoff, "%ld", (long) nextoff);
2359
2360 memset (&ahdr, 0, sizeof ahdr);
2361 sprintf (ahdr.size, "%ld", (long) (XCOFFARMAG_ELEMENT_SIZE
2362 + count * XCOFFARMAG_ELEMENT_SIZE
2363 + total_namlen));
2364 sprintf (ahdr.prevoff, "%ld", (long) prevoff);
2365 sprintf (ahdr.date, "%d", 0);
2366 sprintf (ahdr.uid, "%d", 0);
2367 sprintf (ahdr.gid, "%d", 0);
2368 sprintf (ahdr.mode, "%d", 0);
2369 sprintf (ahdr.namlen, "%d", 0);
2370
2371 size = (SIZEOF_AR_HDR
2372 + XCOFFARMAG_ELEMENT_SIZE
2373 + count * XCOFFARMAG_ELEMENT_SIZE
2374 + total_namlen
2375 + SXCOFFARFMAG);
2376
2377 prevoff = nextoff;
2378 nextoff += size + (size & 1);
2379
2380 if (makemap && hasobjects)
2381 sprintf (ahdr.nextoff, "%ld", (long) nextoff);
2382 else
2383 sprintf (ahdr.nextoff, "%d", 0);
2384
2385 /* We need spaces, not null bytes, in the header. */
2386 for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR; p++)
2387 if (*p == '\0')
2388 *p = ' ';
2389
2390 if ((bfd_bwrite (&ahdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
2391 != SIZEOF_AR_HDR)
2392 || (bfd_bwrite (XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
2393 != SXCOFFARFMAG))
2394 return false;
2395
2396 sprintf (decbuf, "%-12ld", (long) count);
2397 if (bfd_bwrite (decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE, abfd)
2398 != XCOFFARMAG_ELEMENT_SIZE)
2399 return false;
2400 for (i = 0; i < (size_t) count; i++)
2401 {
2402 sprintf (decbuf, "%-12ld", (long) offsets[i]);
2403 if (bfd_bwrite (decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE,
2404 abfd) != XCOFFARMAG_ELEMENT_SIZE)
2405 return false;
2406 }
2407 for (sub = abfd->archive_head; sub != NULL; sub = sub->archive_next)
2408 {
2409 const char *name;
2410 bfd_size_type namlen;
2411
2412 name = normalize_filename (sub);
2413 namlen = strlen (name);
2414 if (bfd_bwrite (name, namlen + 1, abfd) != namlen + 1)
2415 return false;
2416 }
2417
2418 if (! do_pad (abfd, size & 1))
2419 return false;
2420
2421 /* Write out the armap, if appropriate. */
2422 if (! makemap || ! hasobjects)
2423 sprintf (fhdr.symoff, "%d", 0);
2424 else
2425 {
2426 BFD_ASSERT (nextoff == bfd_tell (abfd));
2427 sprintf (fhdr.symoff, "%ld", (long) nextoff);
2428 bfd_ardata (abfd)->tdata = &fhdr;
2429 if (! _bfd_compute_and_write_armap (abfd, 0))
2430 return false;
2431 }
2432
2433 /* Write out the archive file header. */
2434
2435 /* We need spaces, not null bytes, in the header. */
2436 for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR; p++)
2437 if (*p == '\0')
2438 *p = ' ';
2439
2440 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2441 || (bfd_bwrite (&fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR, abfd)
2442 != SIZEOF_AR_FILE_HDR))
2443 return false;
2444
2445 return true;
2446 }
2447
2448 static bool
2449 xcoff_write_archive_contents_big (bfd *abfd)
2450 {
2451 struct xcoff_ar_file_hdr_big fhdr;
2452 bfd_size_type count;
2453 bfd_size_type total_namlen;
2454 file_ptr *offsets;
2455 bool makemap;
2456 bool hasobjects;
2457 file_ptr prevoff, nextoff;
2458 bfd *current_bfd;
2459 size_t i;
2460 struct xcoff_ar_hdr_big *hdr;
2461 bfd_size_type size;
2462 char *member_table, *mt;
2463 bfd_vma member_table_size;
2464 struct archive_iterator iterator;
2465
2466 memset (&fhdr, 0, SIZEOF_AR_FILE_HDR_BIG);
2467 memcpy (fhdr.magic, XCOFFARMAGBIG, SXCOFFARMAG);
2468
2469 if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR_BIG, SEEK_SET) != 0)
2470 return false;
2471
2472 /* Calculate count and total_namlen. */
2473 makemap = bfd_has_map (abfd);
2474 hasobjects = false;
2475 for (current_bfd = abfd->archive_head, count = 0, total_namlen = 0;
2476 current_bfd != NULL;
2477 current_bfd = current_bfd->archive_next, count++)
2478 {
2479 total_namlen += strlen (normalize_filename (current_bfd)) + 1;
2480
2481 if (makemap
2482 && ! hasobjects
2483 && bfd_check_format (current_bfd, bfd_object))
2484 hasobjects = true;
2485
2486 if (current_bfd->arelt_data == NULL)
2487 {
2488 size = sizeof (struct areltdata);
2489 current_bfd->arelt_data = bfd_zmalloc (size);
2490 if (current_bfd->arelt_data == NULL)
2491 return false;
2492 }
2493
2494 if (arch_xhdr_big (current_bfd) == NULL)
2495 {
2496 struct xcoff_ar_hdr_big *ahdrp;
2497 struct stat s;
2498
2499 if ((current_bfd->flags & BFD_IN_MEMORY) != 0)
2500 {
2501 /* Assume we just "made" the member, and fake it. */
2502 struct bfd_in_memory *bim
2503 = (struct bfd_in_memory *) current_bfd->iostream;
2504 time (&s.st_mtime);
2505 s.st_uid = getuid ();
2506 s.st_gid = getgid ();
2507 s.st_mode = 0644;
2508 s.st_size = bim->size;
2509 }
2510 else if (stat (bfd_get_filename (current_bfd), &s) != 0)
2511 {
2512 bfd_set_input_error (current_bfd, bfd_error_system_call);
2513 return false;
2514 }
2515
2516 if ((abfd->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
2517 {
2518 s.st_mtime = 0;
2519 s.st_uid = 0;
2520 s.st_gid = 0;
2521 s.st_mode = 0644;
2522 }
2523
2524 ahdrp = bfd_zalloc (current_bfd, sizeof (*ahdrp));
2525 if (ahdrp == NULL)
2526 return false;
2527
2528 PRINT20 (ahdrp->size, s.st_size);
2529 PRINT12 (ahdrp->date, s.st_mtime);
2530 PRINT12 (ahdrp->uid, s.st_uid);
2531 PRINT12 (ahdrp->gid, s.st_gid);
2532 PRINT12_OCTAL (ahdrp->mode, s.st_mode);
2533
2534 arch_eltdata (current_bfd)->arch_header = (char *) ahdrp;
2535 arch_eltdata (current_bfd)->parsed_size = s.st_size;
2536 }
2537 }
2538
2539 offsets = NULL;
2540 if (count)
2541 {
2542 offsets = (file_ptr *) bfd_malloc (count * sizeof (file_ptr));
2543 if (offsets == NULL)
2544 return false;
2545 }
2546
2547 prevoff = 0;
2548 for (archive_iterator_begin (&iterator, abfd), i = 0;
2549 archive_iterator_next (&iterator);
2550 i++)
2551 {
2552 bfd_size_type namlen;
2553 struct xcoff_ar_hdr_big *ahdrp;
2554
2555 ahdrp = arch_xhdr_big (iterator.current.member);
2556 PRINT20 (ahdrp->prevoff, prevoff);
2557 PRINT4 (ahdrp->namlen, iterator.current.namlen);
2558 PRINT20 (ahdrp->nextoff, iterator.next.offset);
2559
2560 if (!do_pad (abfd, iterator.current.leading_padding))
2561 {
2562 free (offsets);
2563 return false;
2564 }
2565
2566 BFD_ASSERT (iterator.current.offset == bfd_tell (abfd));
2567 namlen = iterator.current.padded_namlen;
2568 if (bfd_bwrite (ahdrp, SIZEOF_AR_HDR_BIG, abfd) != SIZEOF_AR_HDR_BIG
2569 || bfd_bwrite (iterator.current.name, namlen, abfd) != namlen
2570 || bfd_bwrite (XCOFFARFMAG, SXCOFFARFMAG, abfd) != SXCOFFARFMAG
2571 || bfd_seek (iterator.current.member, 0, SEEK_SET) != 0
2572 || !do_copy (abfd, iterator.current.member)
2573 || !do_pad (abfd, iterator.current.trailing_padding))
2574 {
2575 free (offsets);
2576 return false;
2577 }
2578
2579 offsets[i] = iterator.current.offset;
2580 prevoff = iterator.current.offset;
2581 }
2582
2583 if (count)
2584 {
2585 PRINT20 (fhdr.firstmemoff, offsets[0]);
2586 PRINT20 (fhdr.lastmemoff, prevoff);
2587 }
2588
2589 /* Write out the member table.
2590 Layout :
2591
2592 standard big archive header
2593 0x0000 ar_size [0x14]
2594 0x0014 ar_nxtmem [0x14]
2595 0x0028 ar_prvmem [0x14]
2596 0x003C ar_date [0x0C]
2597 0x0048 ar_uid [0x0C]
2598 0x0054 ar_gid [0x0C]
2599 0x0060 ar_mod [0x0C]
2600 0x006C ar_namelen[0x04]
2601 0x0070 ar_fmag [0x02]
2602
2603 Member table
2604 0x0072 count [0x14]
2605 0x0086 offsets [0x14 * counts]
2606 0x0086 + 0x14 * counts names [??]
2607 ?? pad to even bytes.
2608 */
2609
2610 nextoff = iterator.next.offset;
2611 BFD_ASSERT (nextoff == bfd_tell (abfd));
2612
2613 member_table_size = (SIZEOF_AR_HDR_BIG
2614 + SXCOFFARFMAG
2615 + XCOFFARMAGBIG_ELEMENT_SIZE
2616 + count * XCOFFARMAGBIG_ELEMENT_SIZE
2617 + total_namlen);
2618
2619 member_table_size += member_table_size & 1;
2620 member_table = bfd_zmalloc (member_table_size);
2621 if (member_table == NULL)
2622 {
2623 free (offsets);
2624 return false;
2625 }
2626
2627 hdr = (struct xcoff_ar_hdr_big *) member_table;
2628
2629 PRINT20 (hdr->size, (XCOFFARMAGBIG_ELEMENT_SIZE
2630 + count * XCOFFARMAGBIG_ELEMENT_SIZE
2631 + total_namlen + (total_namlen & 1)));
2632 if (makemap && hasobjects)
2633 PRINT20 (hdr->nextoff, nextoff + member_table_size);
2634 else
2635 PRINT20 (hdr->nextoff, 0);
2636 PRINT20 (hdr->prevoff, prevoff);
2637 PRINT12 (hdr->date, 0);
2638 PRINT12 (hdr->uid, 0);
2639 PRINT12 (hdr->gid, 0);
2640 PRINT12 (hdr->mode, 0);
2641 PRINT4 (hdr->namlen, 0);
2642
2643 mt = member_table + SIZEOF_AR_HDR_BIG;
2644 memcpy (mt, XCOFFARFMAG, SXCOFFARFMAG);
2645 mt += SXCOFFARFMAG;
2646
2647 PRINT20 (mt, count);
2648 mt += XCOFFARMAGBIG_ELEMENT_SIZE;
2649 for (i = 0; i < (size_t) count; i++)
2650 {
2651 PRINT20 (mt, offsets[i]);
2652 mt += XCOFFARMAGBIG_ELEMENT_SIZE;
2653 }
2654
2655 if (count)
2656 {
2657 free (offsets);
2658 offsets = NULL;
2659 }
2660
2661 for (current_bfd = abfd->archive_head;
2662 current_bfd != NULL;
2663 current_bfd = current_bfd->archive_next)
2664 {
2665 const char *name;
2666 size_t namlen;
2667
2668 name = normalize_filename (current_bfd);
2669 namlen = sprintf (mt, "%s", name);
2670 mt += namlen + 1;
2671 }
2672
2673 if (bfd_bwrite (member_table, member_table_size, abfd) != member_table_size)
2674 return false;
2675
2676 free (member_table);
2677
2678 PRINT20 (fhdr.memoff, nextoff);
2679
2680 prevoff = nextoff;
2681 nextoff += member_table_size;
2682
2683 /* Write out the armap, if appropriate. */
2684
2685 if (! makemap || ! hasobjects)
2686 PRINT20 (fhdr.symoff, 0);
2687 else
2688 {
2689 BFD_ASSERT (nextoff == bfd_tell (abfd));
2690
2691 /* Save nextoff in fhdr.symoff so the armap routine can use it. */
2692 PRINT20 (fhdr.symoff, nextoff);
2693
2694 bfd_ardata (abfd)->tdata = &fhdr;
2695 if (! _bfd_compute_and_write_armap (abfd, 0))
2696 return false;
2697 }
2698
2699 /* Write out the archive file header. */
2700
2701 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2702 || (bfd_bwrite (&fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR_BIG,
2703 abfd) != SIZEOF_AR_FILE_HDR_BIG))
2704 return false;
2705
2706 return true;
2707 }
2708
2709 bool
2710 _bfd_xcoff_write_archive_contents (bfd *abfd)
2711 {
2712 if (! xcoff_big_format_p (abfd))
2713 return xcoff_write_archive_contents_old (abfd);
2714 else
2715 return xcoff_write_archive_contents_big (abfd);
2716 }
2717 \f
2718 /* We can't use the usual coff_sizeof_headers routine, because AIX
2719 always uses an a.out header. */
2720
2721 int
2722 _bfd_xcoff_sizeof_headers (bfd *abfd,
2723 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2724 {
2725 int size;
2726
2727 size = FILHSZ;
2728 if (xcoff_data (abfd)->full_aouthdr)
2729 size += AOUTSZ;
2730 else
2731 size += SMALL_AOUTSZ;
2732 size += abfd->section_count * SCNHSZ;
2733
2734 if (info->strip != strip_all)
2735 {
2736 /* There can be additional sections just for dealing with overflow in
2737 reloc and lineno counts. But the numbers of relocs and lineno aren't
2738 known when bfd_sizeof_headers is called, so we compute them by
2739 summing the numbers from input sections. */
2740 struct nbr_reloc_lineno
2741 {
2742 unsigned int reloc_count;
2743 unsigned int lineno_count;
2744 };
2745 struct nbr_reloc_lineno *n_rl;
2746 bfd *sub;
2747 unsigned int max_index;
2748 asection *s;
2749
2750 /* Although the number of sections is known, the maximum value of
2751 section->index isn't (because some sections may have been removed).
2752 Don't try to renumber sections, just compute the upper bound. */
2753 max_index = 0;
2754 for (s = abfd->sections; s != NULL; s = s->next)
2755 if (s->index > max_index)
2756 max_index = s->index;
2757
2758 /* Allocate the per section counters. It could be possible to use a
2759 preallocated array as the number of sections is limited on XCOFF,
2760 but this creates a maintainance issue. */
2761 n_rl = bfd_zmalloc ((max_index + 1) * sizeof (*n_rl));
2762 if (n_rl == NULL)
2763 return -1;
2764
2765 /* Sum. */
2766 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
2767 for (s = sub->sections; s != NULL; s = s->next)
2768 if (s->output_section->owner == abfd
2769 && !bfd_section_removed_from_list (abfd, s->output_section))
2770 {
2771 struct nbr_reloc_lineno *e = &n_rl[s->output_section->index];
2772 e->reloc_count += s->reloc_count;
2773 e->lineno_count += s->lineno_count;
2774 }
2775
2776 /* Add the size of a section for each section with an overflow. */
2777 for (s = abfd->sections; s != NULL; s = s->next)
2778 {
2779 struct nbr_reloc_lineno *e = &n_rl[s->index];
2780
2781 if (e->reloc_count >= 0xffff
2782 || (e->lineno_count >= 0xffff && info->strip != strip_debugger))
2783 size += SCNHSZ;
2784 }
2785
2786 free (n_rl);
2787 }
2788
2789 return size;
2790 }
2791 \f
2792 /* Routines to swap information in the XCOFF .loader section. If we
2793 ever need to write an XCOFF loader, this stuff will need to be
2794 moved to another file shared by the linker (which XCOFF calls the
2795 ``binder'') and the loader. */
2796
2797 /* Swap in the ldhdr structure. */
2798
2799 static void
2800 xcoff_swap_ldhdr_in (bfd *abfd, const void * s, struct internal_ldhdr *dst)
2801 {
2802 const struct external_ldhdr *src = (const struct external_ldhdr *) s;
2803
2804 dst->l_version = bfd_get_32 (abfd, src->l_version);
2805 dst->l_nsyms = bfd_get_32 (abfd, src->l_nsyms);
2806 dst->l_nreloc = bfd_get_32 (abfd, src->l_nreloc);
2807 dst->l_istlen = bfd_get_32 (abfd, src->l_istlen);
2808 dst->l_nimpid = bfd_get_32 (abfd, src->l_nimpid);
2809 dst->l_impoff = bfd_get_32 (abfd, src->l_impoff);
2810 dst->l_stlen = bfd_get_32 (abfd, src->l_stlen);
2811 dst->l_stoff = bfd_get_32 (abfd, src->l_stoff);
2812 }
2813
2814 /* Swap out the ldhdr structure. */
2815
2816 static void
2817 xcoff_swap_ldhdr_out (bfd *abfd, const struct internal_ldhdr *src, void * d)
2818 {
2819 struct external_ldhdr *dst = (struct external_ldhdr *) d;
2820
2821 bfd_put_32 (abfd, (bfd_vma) src->l_version, dst->l_version);
2822 bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
2823 bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
2824 bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
2825 bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
2826 bfd_put_32 (abfd, src->l_impoff, dst->l_impoff);
2827 bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
2828 bfd_put_32 (abfd, src->l_stoff, dst->l_stoff);
2829 }
2830
2831 /* Swap in the ldsym structure. */
2832
2833 static void
2834 xcoff_swap_ldsym_in (bfd *abfd, const void * s, struct internal_ldsym *dst)
2835 {
2836 const struct external_ldsym *src = (const struct external_ldsym *) s;
2837
2838 if (bfd_get_32 (abfd, src->_l._l_l._l_zeroes) != 0) {
2839 memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
2840 } else {
2841 dst->_l._l_l._l_zeroes = 0;
2842 dst->_l._l_l._l_offset = bfd_get_32 (abfd, src->_l._l_l._l_offset);
2843 }
2844 dst->l_value = bfd_get_32 (abfd, src->l_value);
2845 dst->l_scnum = bfd_get_16 (abfd, src->l_scnum);
2846 dst->l_smtype = bfd_get_8 (abfd, src->l_smtype);
2847 dst->l_smclas = bfd_get_8 (abfd, src->l_smclas);
2848 dst->l_ifile = bfd_get_32 (abfd, src->l_ifile);
2849 dst->l_parm = bfd_get_32 (abfd, src->l_parm);
2850 }
2851
2852 /* Swap out the ldsym structure. */
2853
2854 static void
2855 xcoff_swap_ldsym_out (bfd *abfd, const struct internal_ldsym *src, void * d)
2856 {
2857 struct external_ldsym *dst = (struct external_ldsym *) d;
2858
2859 if (src->_l._l_l._l_zeroes != 0)
2860 memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
2861 else
2862 {
2863 bfd_put_32 (abfd, (bfd_vma) 0, dst->_l._l_l._l_zeroes);
2864 bfd_put_32 (abfd, (bfd_vma) src->_l._l_l._l_offset,
2865 dst->_l._l_l._l_offset);
2866 }
2867 bfd_put_32 (abfd, src->l_value, dst->l_value);
2868 bfd_put_16 (abfd, (bfd_vma) src->l_scnum, dst->l_scnum);
2869 bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
2870 bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
2871 bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
2872 bfd_put_32 (abfd, src->l_parm, dst->l_parm);
2873 }
2874
2875 static void
2876 xcoff_swap_reloc_in (bfd *abfd, void * s, void * d)
2877 {
2878 struct external_reloc *src = (struct external_reloc *) s;
2879 struct internal_reloc *dst = (struct internal_reloc *) d;
2880
2881 memset (dst, 0, sizeof (struct internal_reloc));
2882
2883 dst->r_vaddr = bfd_get_32 (abfd, src->r_vaddr);
2884 dst->r_symndx = bfd_get_32 (abfd, src->r_symndx);
2885 dst->r_size = bfd_get_8 (abfd, src->r_size);
2886 dst->r_type = bfd_get_8 (abfd, src->r_type);
2887 }
2888
2889 static unsigned int
2890 xcoff_swap_reloc_out (bfd *abfd, void * s, void * d)
2891 {
2892 struct internal_reloc *src = (struct internal_reloc *) s;
2893 struct external_reloc *dst = (struct external_reloc *) d;
2894
2895 bfd_put_32 (abfd, src->r_vaddr, dst->r_vaddr);
2896 bfd_put_32 (abfd, src->r_symndx, dst->r_symndx);
2897 bfd_put_8 (abfd, src->r_type, dst->r_type);
2898 bfd_put_8 (abfd, src->r_size, dst->r_size);
2899
2900 return bfd_coff_relsz (abfd);
2901 }
2902
2903 /* Swap in the ldrel structure. */
2904
2905 static void
2906 xcoff_swap_ldrel_in (bfd *abfd, const void * s, struct internal_ldrel *dst)
2907 {
2908 const struct external_ldrel *src = (const struct external_ldrel *) s;
2909
2910 dst->l_vaddr = bfd_get_32 (abfd, src->l_vaddr);
2911 dst->l_symndx = bfd_get_32 (abfd, src->l_symndx);
2912 dst->l_rtype = bfd_get_16 (abfd, src->l_rtype);
2913 dst->l_rsecnm = bfd_get_16 (abfd, src->l_rsecnm);
2914 }
2915
2916 /* Swap out the ldrel structure. */
2917
2918 static void
2919 xcoff_swap_ldrel_out (bfd *abfd, const struct internal_ldrel *src, void * d)
2920 {
2921 struct external_ldrel *dst = (struct external_ldrel *) d;
2922
2923 bfd_put_32 (abfd, src->l_vaddr, dst->l_vaddr);
2924 bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
2925 bfd_put_16 (abfd, (bfd_vma) src->l_rtype, dst->l_rtype);
2926 bfd_put_16 (abfd, (bfd_vma) src->l_rsecnm, dst->l_rsecnm);
2927 }
2928 \f
2929
2930 bool
2931 xcoff_reloc_type_noop (bfd *input_bfd ATTRIBUTE_UNUSED,
2932 asection *input_section ATTRIBUTE_UNUSED,
2933 bfd *output_bfd ATTRIBUTE_UNUSED,
2934 struct internal_reloc *rel ATTRIBUTE_UNUSED,
2935 struct internal_syment *sym ATTRIBUTE_UNUSED,
2936 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED,
2937 bfd_vma val ATTRIBUTE_UNUSED,
2938 bfd_vma addend ATTRIBUTE_UNUSED,
2939 bfd_vma *relocation ATTRIBUTE_UNUSED,
2940 bfd_byte *contents ATTRIBUTE_UNUSED,
2941 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2942 {
2943 return true;
2944 }
2945
2946 bool
2947 xcoff_reloc_type_fail (bfd *input_bfd,
2948 asection *input_section ATTRIBUTE_UNUSED,
2949 bfd *output_bfd ATTRIBUTE_UNUSED,
2950 struct internal_reloc *rel,
2951 struct internal_syment *sym ATTRIBUTE_UNUSED,
2952 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED,
2953 bfd_vma val ATTRIBUTE_UNUSED,
2954 bfd_vma addend ATTRIBUTE_UNUSED,
2955 bfd_vma *relocation ATTRIBUTE_UNUSED,
2956 bfd_byte *contents ATTRIBUTE_UNUSED,
2957 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2958 {
2959 _bfd_error_handler
2960 /* xgettext: c-format */
2961 (_("%pB: unsupported relocation type %#x"),
2962 input_bfd, (unsigned int) rel->r_type);
2963 bfd_set_error (bfd_error_bad_value);
2964 return false;
2965 }
2966
2967 bool
2968 xcoff_reloc_type_pos (bfd *input_bfd ATTRIBUTE_UNUSED,
2969 asection *input_section ATTRIBUTE_UNUSED,
2970 bfd *output_bfd ATTRIBUTE_UNUSED,
2971 struct internal_reloc *rel ATTRIBUTE_UNUSED,
2972 struct internal_syment *sym ATTRIBUTE_UNUSED,
2973 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED,
2974 bfd_vma val,
2975 bfd_vma addend,
2976 bfd_vma *relocation,
2977 bfd_byte *contents ATTRIBUTE_UNUSED,
2978 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2979 {
2980 *relocation = val + addend;
2981 return true;
2982 }
2983
2984 bool
2985 xcoff_reloc_type_neg (bfd *input_bfd ATTRIBUTE_UNUSED,
2986 asection *input_section ATTRIBUTE_UNUSED,
2987 bfd *output_bfd ATTRIBUTE_UNUSED,
2988 struct internal_reloc *rel ATTRIBUTE_UNUSED,
2989 struct internal_syment *sym ATTRIBUTE_UNUSED,
2990 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED,
2991 bfd_vma val,
2992 bfd_vma addend,
2993 bfd_vma *relocation,
2994 bfd_byte *contents ATTRIBUTE_UNUSED,
2995 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2996 {
2997 *relocation = - val - addend;
2998 return true;
2999 }
3000
3001 bool
3002 xcoff_reloc_type_rel (bfd *input_bfd ATTRIBUTE_UNUSED,
3003 asection *input_section,
3004 bfd *output_bfd ATTRIBUTE_UNUSED,
3005 struct internal_reloc *rel ATTRIBUTE_UNUSED,
3006 struct internal_syment *sym ATTRIBUTE_UNUSED,
3007 struct reloc_howto_struct *howto,
3008 bfd_vma val,
3009 bfd_vma addend,
3010 bfd_vma *relocation,
3011 bfd_byte *contents ATTRIBUTE_UNUSED,
3012 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3013 {
3014 howto->pc_relative = true;
3015
3016 /* A PC relative reloc includes the section address. */
3017 addend += input_section->vma;
3018
3019 *relocation = val + addend;
3020 *relocation -= (input_section->output_section->vma
3021 + input_section->output_offset);
3022 return true;
3023 }
3024
3025 bool
3026 xcoff_reloc_type_toc (bfd *input_bfd,
3027 asection *input_section ATTRIBUTE_UNUSED,
3028 bfd *output_bfd,
3029 struct internal_reloc *rel,
3030 struct internal_syment *sym ATTRIBUTE_UNUSED,
3031 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED,
3032 bfd_vma val,
3033 bfd_vma addend ATTRIBUTE_UNUSED,
3034 bfd_vma *relocation,
3035 bfd_byte *contents ATTRIBUTE_UNUSED,
3036 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3037 {
3038 struct xcoff_link_hash_entry *h;
3039
3040 if (0 > rel->r_symndx)
3041 return false;
3042
3043 h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
3044
3045 if (h != NULL && h->smclas != XMC_TD)
3046 {
3047 if (h->toc_section == NULL)
3048 {
3049 _bfd_error_handler
3050 /* xgettext: c-format */
3051 (_("%pB: TOC reloc at %#" PRIx64 " to symbol `%s' with no TOC entry"),
3052 input_bfd, (uint64_t) rel->r_vaddr, h->root.root.string);
3053 bfd_set_error (bfd_error_bad_value);
3054 return false;
3055 }
3056
3057 BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
3058 val = (h->toc_section->output_section->vma
3059 + h->toc_section->output_offset);
3060 }
3061
3062 /* We can't use the preexisting value written down by the
3063 assembly, as R_TOCU needs to be adjusted when the final
3064 R_TOCL value is signed. */
3065 *relocation = val - xcoff_data (output_bfd)->toc;
3066
3067 if (rel->r_type == R_TOCU)
3068 *relocation = ((*relocation + 0x8000) >> 16) & 0xffff;
3069 if (rel->r_type == R_TOCL)
3070 *relocation = *relocation & 0x0000ffff;
3071
3072 return true;
3073 }
3074
3075 bool
3076 xcoff_reloc_type_ba (bfd *input_bfd ATTRIBUTE_UNUSED,
3077 asection *input_section ATTRIBUTE_UNUSED,
3078 bfd *output_bfd ATTRIBUTE_UNUSED,
3079 struct internal_reloc *rel ATTRIBUTE_UNUSED,
3080 struct internal_syment *sym ATTRIBUTE_UNUSED,
3081 struct reloc_howto_struct *howto,
3082 bfd_vma val,
3083 bfd_vma addend,
3084 bfd_vma *relocation,
3085 bfd_byte *contents ATTRIBUTE_UNUSED,
3086 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3087 {
3088 howto->src_mask &= ~3;
3089 howto->dst_mask = howto->src_mask;
3090
3091 *relocation = val + addend;
3092
3093 return true;
3094 }
3095
3096 static bool
3097 xcoff_reloc_type_br (bfd *input_bfd,
3098 asection *input_section,
3099 bfd *output_bfd ATTRIBUTE_UNUSED,
3100 struct internal_reloc *rel,
3101 struct internal_syment *sym ATTRIBUTE_UNUSED,
3102 struct reloc_howto_struct *howto,
3103 bfd_vma val,
3104 bfd_vma addend,
3105 bfd_vma *relocation,
3106 bfd_byte *contents,
3107 struct bfd_link_info *info)
3108 {
3109 struct xcoff_link_hash_entry *h;
3110 bfd_vma section_offset;
3111 struct xcoff_stub_hash_entry *stub_entry = NULL;
3112 enum xcoff_stub_type stub_type;
3113
3114 if (0 > rel->r_symndx)
3115 return false;
3116
3117 h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
3118 section_offset = rel->r_vaddr - input_section->vma;
3119
3120 /* If we see an R_BR or R_RBR reloc which is jumping to global
3121 linkage code, and it is followed by an appropriate cror nop
3122 instruction, we replace the cror with lwz r2,20(r1). This
3123 restores the TOC after the glink code. Contrariwise, if the
3124 call is followed by a lwz r2,20(r1), but the call is not
3125 going to global linkage code, we can replace the load with a
3126 cror. */
3127 if (NULL != h
3128 && (bfd_link_hash_defined == h->root.type
3129 || bfd_link_hash_defweak == h->root.type)
3130 && section_offset + 8 <= input_section->size)
3131 {
3132 bfd_byte *pnext;
3133 unsigned long next;
3134
3135 pnext = contents + section_offset + 4;
3136 next = bfd_get_32 (input_bfd, pnext);
3137
3138 /* The _ptrgl function is magic. It is used by the AIX
3139 compiler to call a function through a pointer. */
3140 if (h->smclas == XMC_GL || strcmp (h->root.root.string, "._ptrgl") == 0)
3141 {
3142 if (next == 0x4def7b82 /* cror 15,15,15 */
3143 || next == 0x4ffffb82 /* cror 31,31,31 */
3144 || next == 0x60000000) /* ori r0,r0,0 */
3145 bfd_put_32 (input_bfd, 0x80410014, pnext); /* lwz r2,20(r1) */
3146
3147 }
3148 else
3149 {
3150 if (next == 0x80410014) /* lwz r2,20(r1) */
3151 bfd_put_32 (input_bfd, 0x60000000, pnext); /* ori r0,r0,0 */
3152 }
3153 }
3154 else if (NULL != h && bfd_link_hash_undefined == h->root.type)
3155 {
3156 /* Normally, this relocation is against a defined symbol. In the
3157 case where this is a partial link and the output section offset
3158 is greater than 2^25, the linker will return an invalid error
3159 message that the relocation has been truncated. Yes it has been
3160 truncated but no it not important. For this case, disable the
3161 overflow checking. */
3162
3163 howto->complain_on_overflow = complain_overflow_dont;
3164 }
3165
3166 /* Check if a stub is needed. */
3167 stub_type = bfd_xcoff_type_of_stub (input_section, rel, val, h);
3168 if (stub_type != xcoff_stub_none)
3169 {
3170 asection *stub_csect;
3171
3172 stub_entry = bfd_xcoff_get_stub_entry (input_section, h, info);
3173 if (stub_entry == NULL)
3174 {
3175 _bfd_error_handler (_("Unable to find the stub entry targeting %s"),
3176 h->root.root.string);
3177 bfd_set_error (bfd_error_bad_value);
3178 return false;
3179 }
3180
3181 stub_csect = stub_entry->hcsect->root.u.def.section;
3182 val = (stub_entry->stub_offset
3183 + stub_csect->output_section->vma
3184 + stub_csect->output_offset);
3185 }
3186
3187 /* The original PC-relative relocation is biased by -r_vaddr, so adding
3188 the value below will give the absolute target address. */
3189 *relocation = val + addend + rel->r_vaddr;
3190
3191 howto->src_mask &= ~3;
3192 howto->dst_mask = howto->src_mask;
3193
3194 if (h != NULL
3195 && (h->root.type == bfd_link_hash_defined
3196 || h->root.type == bfd_link_hash_defweak)
3197 && bfd_is_abs_section (h->root.u.def.section)
3198 && section_offset + 4 <= input_section->size)
3199 {
3200 bfd_byte *ptr;
3201 bfd_vma insn;
3202
3203 /* Turn the relative branch into an absolute one by setting the
3204 AA bit. */
3205 ptr = contents + section_offset;
3206 insn = bfd_get_32 (input_bfd, ptr);
3207 insn |= 2;
3208 bfd_put_32 (input_bfd, insn, ptr);
3209
3210 /* Make the howto absolute too. */
3211 howto->pc_relative = false;
3212 howto->complain_on_overflow = complain_overflow_bitfield;
3213 }
3214 else
3215 {
3216 /* Use a PC-relative howto and subtract the instruction's address
3217 from the target address we calculated above. */
3218 howto->pc_relative = true;
3219 *relocation -= (input_section->output_section->vma
3220 + input_section->output_offset
3221 + section_offset);
3222 }
3223 return true;
3224 }
3225
3226 bool
3227 xcoff_reloc_type_crel (bfd *input_bfd ATTRIBUTE_UNUSED,
3228 asection *input_section,
3229 bfd *output_bfd ATTRIBUTE_UNUSED,
3230 struct internal_reloc *rel ATTRIBUTE_UNUSED,
3231 struct internal_syment *sym ATTRIBUTE_UNUSED,
3232 struct reloc_howto_struct *howto,
3233 bfd_vma val ATTRIBUTE_UNUSED,
3234 bfd_vma addend,
3235 bfd_vma *relocation,
3236 bfd_byte *contents ATTRIBUTE_UNUSED,
3237 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3238 {
3239 howto->pc_relative = true;
3240 howto->src_mask &= ~3;
3241 howto->dst_mask = howto->src_mask;
3242
3243 /* A PC relative reloc includes the section address. */
3244 addend += input_section->vma;
3245
3246 *relocation = val + addend;
3247 *relocation -= (input_section->output_section->vma
3248 + input_section->output_offset);
3249 return true;
3250 }
3251
3252 bool
3253 xcoff_reloc_type_tls (bfd *input_bfd ATTRIBUTE_UNUSED,
3254 asection *input_section ATTRIBUTE_UNUSED,
3255 bfd *output_bfd ATTRIBUTE_UNUSED,
3256 struct internal_reloc *rel ATTRIBUTE_UNUSED,
3257 struct internal_syment *sym ATTRIBUTE_UNUSED,
3258 struct reloc_howto_struct *howto,
3259 bfd_vma val,
3260 bfd_vma addend,
3261 bfd_vma *relocation,
3262 bfd_byte *contents ATTRIBUTE_UNUSED,
3263 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3264 {
3265 struct xcoff_link_hash_entry *h;
3266
3267 if (0 > rel->r_symndx)
3268 return false;
3269
3270 h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
3271
3272 /* R_TLSML is handled by the loader but must be from a
3273 TOC entry targeting itslef. This is already verified in
3274 xcoff_link_add_symbols.
3275 The value must be 0. */
3276 if (howto->type == R_TLSML)
3277 {
3278 *relocation = 0;
3279 return true;
3280 }
3281
3282 /* The target symbol should always be available even if it's not
3283 exported. */
3284 BFD_ASSERT (h != NULL);
3285
3286 /* TLS relocations must target a TLS symbol. */
3287 if (h->smclas != XMC_TL && h->smclas != XMC_UL)
3288 {
3289 _bfd_error_handler
3290 (_("%pB: TLS relocation at 0x%" PRIx64 " over non-TLS symbol %s (0x%x)\n"),
3291 input_bfd, (uint64_t) rel->r_vaddr, h->root.root.string, h->smclas);
3292 return false;
3293 }
3294
3295 /* Local TLS relocations must target a local symbol, ie
3296 non-imported. */
3297 if ((rel->r_type == R_TLS_LD || rel->r_type == R_TLS_LE)
3298 && (((h->flags & XCOFF_DEF_REGULAR) == 0
3299 && (h->flags & XCOFF_DEF_DYNAMIC) != 0)
3300 || (h->flags & XCOFF_IMPORT) != 0))
3301 {
3302 _bfd_error_handler
3303 (_("%pB: TLS local relocation at 0x%" PRIx64 " over imported symbol %s\n"),
3304 input_bfd, (uint64_t) rel->r_vaddr, h->root.root.string);
3305 return false;
3306 }
3307
3308 /* R_TLSM are relocations used by the loader.
3309 The value must be 0. */
3310 if (howto->type == R_TLSM)
3311 {
3312 *relocation = 0;
3313 return true;
3314 }
3315
3316 /* Other TLS relocations aims to put offsets from TLS pointers
3317 starting at -0x7c00 (or -0x7800 in XCOFF64). It becomes a
3318 simple R_POS relocation as long as .tdata and .tbss addresses
3319 start at the same value. This is done in aix ld scripts.
3320 TODO: implement optimization when tls size is < 62K. */
3321 *relocation = val + addend;
3322
3323 return true;
3324 }
3325
3326 static bool
3327 xcoff_complain_overflow_dont_func (bfd *input_bfd ATTRIBUTE_UNUSED,
3328 bfd_vma val ATTRIBUTE_UNUSED,
3329 bfd_vma relocation ATTRIBUTE_UNUSED,
3330 struct reloc_howto_struct *
3331 howto ATTRIBUTE_UNUSED)
3332 {
3333 return false;
3334 }
3335
3336 static bool
3337 xcoff_complain_overflow_bitfield_func (bfd *input_bfd,
3338 bfd_vma val,
3339 bfd_vma relocation,
3340 struct reloc_howto_struct *howto)
3341 {
3342 bfd_vma fieldmask, signmask, ss;
3343 bfd_vma a, b, sum;
3344
3345 /* Get the values to be added together. For signed and unsigned
3346 relocations, we assume that all values should be truncated to
3347 the size of an address. For bitfields, all the bits matter.
3348 See also bfd_check_overflow. */
3349 fieldmask = N_ONES (howto->bitsize);
3350 a = relocation;
3351 b = val & howto->src_mask;
3352
3353 /* Much like unsigned, except no trimming with addrmask. In
3354 addition, the sum overflows if there is a carry out of
3355 the bfd_vma, i.e., the sum is less than either input
3356 operand. */
3357 a >>= howto->rightshift;
3358 b >>= howto->bitpos;
3359
3360 /* Bitfields are sometimes used for signed numbers; for
3361 example, a 13-bit field sometimes represents values in
3362 0..8191 and sometimes represents values in -4096..4095.
3363 If the field is signed and a is -4095 (0x1001) and b is
3364 -1 (0x1fff), the sum is -4096 (0x1000), but (0x1001 +
3365 0x1fff is 0x3000). It's not clear how to handle this
3366 everywhere, since there is not way to know how many bits
3367 are significant in the relocation, but the original code
3368 assumed that it was fully sign extended, and we will keep
3369 that assumption. */
3370 signmask = (fieldmask >> 1) + 1;
3371
3372 if ((a & ~ fieldmask) != 0)
3373 {
3374 /* Some bits out of the field are set. This might not
3375 be a problem: if this is a signed bitfield, it is OK
3376 iff all the high bits are set, including the sign
3377 bit. We'll try setting all but the most significant
3378 bit in the original relocation value: if this is all
3379 ones, we are OK, assuming a signed bitfield. */
3380 ss = (signmask << howto->rightshift) - 1;
3381 if ((ss | relocation) != ~ (bfd_vma) 0)
3382 return true;
3383 a &= fieldmask;
3384 }
3385
3386 /* We just assume (b & ~ fieldmask) == 0. */
3387
3388 /* We explicitly permit wrap around if this relocation
3389 covers the high bit of an address. The Linux kernel
3390 relies on it, and it is the only way to write assembler
3391 code which can run when loaded at a location 0x80000000
3392 away from the location at which it is linked. */
3393 if ((unsigned) howto->bitsize + howto->rightshift
3394 == bfd_arch_bits_per_address (input_bfd))
3395 return false;
3396
3397 sum = a + b;
3398 if (sum < a || (sum & ~ fieldmask) != 0)
3399 {
3400 /* There was a carry out, or the field overflow. Test
3401 for signed operands again. Here is the overflow test
3402 is as for complain_overflow_signed. */
3403 if (((~ (a ^ b)) & (a ^ sum)) & signmask)
3404 return true;
3405 }
3406
3407 return false;
3408 }
3409
3410 static bool
3411 xcoff_complain_overflow_signed_func (bfd *input_bfd,
3412 bfd_vma val,
3413 bfd_vma relocation,
3414 struct reloc_howto_struct *howto)
3415 {
3416 bfd_vma addrmask, fieldmask, signmask, ss;
3417 bfd_vma a, b, sum;
3418
3419 /* Get the values to be added together. For signed and unsigned
3420 relocations, we assume that all values should be truncated to
3421 the size of an address. For bitfields, all the bits matter.
3422 See also bfd_check_overflow. */
3423 fieldmask = N_ONES (howto->bitsize);
3424 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
3425 a = relocation;
3426 b = val & howto->src_mask;
3427
3428 a = (a & addrmask) >> howto->rightshift;
3429
3430 /* If any sign bits are set, all sign bits must be set.
3431 That is, A must be a valid negative address after
3432 shifting. */
3433 signmask = ~ (fieldmask >> 1);
3434 ss = a & signmask;
3435 if (ss != 0 && ss != ((addrmask >> howto->rightshift) & signmask))
3436 return true;
3437
3438 /* We only need this next bit of code if the sign bit of B
3439 is below the sign bit of A. This would only happen if
3440 SRC_MASK had fewer bits than BITSIZE. Note that if
3441 SRC_MASK has more bits than BITSIZE, we can get into
3442 trouble; we would need to verify that B is in range, as
3443 we do for A above. */
3444 signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
3445 if ((b & signmask) != 0)
3446 {
3447 /* Set all the bits above the sign bit. */
3448 b -= signmask <<= 1;
3449 }
3450
3451 b = (b & addrmask) >> howto->bitpos;
3452
3453 /* Now we can do the addition. */
3454 sum = a + b;
3455
3456 /* See if the result has the correct sign. Bits above the
3457 sign bit are junk now; ignore them. If the sum is
3458 positive, make sure we did not have all negative inputs;
3459 if the sum is negative, make sure we did not have all
3460 positive inputs. The test below looks only at the sign
3461 bits, and it really just
3462 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
3463 */
3464 signmask = (fieldmask >> 1) + 1;
3465 if (((~ (a ^ b)) & (a ^ sum)) & signmask)
3466 return true;
3467
3468 return false;
3469 }
3470
3471 static bool
3472 xcoff_complain_overflow_unsigned_func (bfd *input_bfd,
3473 bfd_vma val,
3474 bfd_vma relocation,
3475 struct reloc_howto_struct *howto)
3476 {
3477 bfd_vma addrmask, fieldmask;
3478 bfd_vma a, b, sum;
3479
3480 /* Get the values to be added together. For signed and unsigned
3481 relocations, we assume that all values should be truncated to
3482 the size of an address. For bitfields, all the bits matter.
3483 See also bfd_check_overflow. */
3484 fieldmask = N_ONES (howto->bitsize);
3485 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
3486 a = relocation;
3487 b = val & howto->src_mask;
3488
3489 /* Checking for an unsigned overflow is relatively easy:
3490 trim the addresses and add, and trim the result as well.
3491 Overflow is normally indicated when the result does not
3492 fit in the field. However, we also need to consider the
3493 case when, e.g., fieldmask is 0x7fffffff or smaller, an
3494 input is 0x80000000, and bfd_vma is only 32 bits; then we
3495 will get sum == 0, but there is an overflow, since the
3496 inputs did not fit in the field. Instead of doing a
3497 separate test, we can check for this by or-ing in the
3498 operands when testing for the sum overflowing its final
3499 field. */
3500 a = (a & addrmask) >> howto->rightshift;
3501 b = (b & addrmask) >> howto->bitpos;
3502 sum = (a + b) & addrmask;
3503 if ((a | b | sum) & ~ fieldmask)
3504 return true;
3505
3506 return false;
3507 }
3508
3509 /* This is the relocation function for the RS/6000/POWER/PowerPC.
3510 This is currently the only processor which uses XCOFF; I hope that
3511 will never change.
3512
3513 The original version was based on two documents:
3514 the PowerPC AIX Version 4 Application Binary Interface, First
3515 Edition (April 1992), and the PowerOpen ABI, Big-Endian
3516 32-Bit Hardware Implementation (June 30, 1994). Differences
3517 between the documents are noted below.
3518 Now, IBM has released an official documentation about XCOFF
3519 format:
3520 https://www.ibm.com/support/knowledgecenter/ssw_aix_72/filesreference/XCOFF.html
3521
3522 Unsupported r_type's
3523
3524 R_RTB:
3525 R_RRTBI:
3526 R_RRTBA:
3527
3528 These relocs are defined by the PowerPC ABI to be
3529 relative branches which use half of the difference
3530 between the symbol and the program counter. I can't
3531 quite figure out when this is useful. These relocs are
3532 not defined by the PowerOpen ABI.
3533
3534 Supported r_type's
3535
3536 R_POS:
3537 Simple positive relocation.
3538
3539 R_NEG:
3540 Simple negative relocation.
3541
3542 R_REL:
3543 Simple PC relative relocation.
3544
3545 R_TOC:
3546 TOC relative relocation. The value in the instruction in
3547 the input file is the offset from the input file TOC to
3548 the desired location. We want the offset from the final
3549 TOC to the desired location. We have:
3550 isym = iTOC + in
3551 iinsn = in + o
3552 osym = oTOC + on
3553 oinsn = on + o
3554 so we must change insn by on - in.
3555 This relocation allows the linker to perform optimizations
3556 by transforming a load instruction into a add-immediate
3557 when possible. The relocation is, then, changed to R_TRLA
3558 in the output file.
3559 TODO: Currently, the optimisation isn't implemented.
3560
3561 R_TRL:
3562 TOC relative relocation. Same as R_TOC, except that
3563 the optimization isn't allowed
3564
3565 R_TRLA:
3566 TOC relative relocation. This is a TOC relative load
3567 address instruction which have been changed to an add-
3568 immediate instruction.
3569
3570 R_GL:
3571 GL linkage relocation. The value of this relocation
3572 is the address of the external symbol in the TOC
3573 section.
3574
3575 R_TCL:
3576 Local object TOC address. I can't figure out the
3577 difference between this and case R_GL.
3578
3579 R_RL:
3580 The PowerPC AIX ABI describes this as a load which may be
3581 changed to a load address. The PowerOpen ABI says this
3582 is the same as case R_POS.
3583
3584 R_RLA:
3585 The PowerPC AIX ABI describes this as a load address
3586 which may be changed to a load. The PowerOpen ABI says
3587 this is the same as R_POS.
3588
3589 R_REF:
3590 Not a relocation but a way to prevent the garbage
3591 collector of AIX linker to remove symbols.
3592 This is not needed in our case.
3593
3594 R_BA:
3595 The PowerOpen ABI says this is the same as R_RBA.
3596
3597 R_RBA:
3598 Absolute branch which may be modified to become a
3599 relative branch.
3600
3601 R_BR:
3602 The PowerOpen ABI says this is the same as R_RBR.
3603
3604 R_RBR:
3605 A relative branch which may be modified to become an
3606 absolute branch.
3607
3608 R_CAI:
3609 The PowerPC ABI defines this as an absolute call which
3610 may be modified to become a relative call. The PowerOpen
3611 ABI does not define this relocation type.
3612
3613 R_CREL:
3614 The PowerPC ABI defines this as a relative call which may
3615 be modified to become an absolute call. The PowerOpen
3616 ABI does not define this relocation type.
3617
3618 R_RBAC:
3619 The PowerPC ABI defines this as an absolute branch to a
3620 fixed address which may be modified to an absolute branch
3621 to a symbol. The PowerOpen ABI does not define this
3622 relocation type.
3623
3624 R_RBRC:
3625 The PowerPC ABI defines this as an absolute branch to a
3626 fixed address which may be modified to a relative branch.
3627 The PowerOpen ABI does not define this relocation type.
3628
3629 R_TLS:
3630 Thread-local storage relocation using general-dynamic
3631 model.
3632
3633 R_TLS_IE:
3634 Thread-local storage relocation using initial-exec model.
3635
3636 R_TLS_LD:
3637 Thread-local storage relocation using local-dynamic model.
3638
3639 R_TLS_LE:
3640 Thread-local storage relocation using local-exec model.
3641
3642 R_TLSM:
3643 Tread-local storage relocation used by the loader.
3644
3645 R_TLSML:
3646 Tread-local storage relocation used by the loader.
3647
3648 R_TOCU:
3649 Upper TOC relative relocation. The value is the
3650 high-order 16 bit of a TOC relative relocation.
3651
3652 R_TOCL:
3653 Lower TOC relative relocation. The value is the
3654 low-order 16 bit of a TOC relative relocation.
3655 */
3656
3657 bool
3658 xcoff_ppc_relocate_section (bfd *output_bfd,
3659 struct bfd_link_info *info,
3660 bfd *input_bfd,
3661 asection *input_section,
3662 bfd_byte *contents,
3663 struct internal_reloc *relocs,
3664 struct internal_syment *syms,
3665 asection **sections)
3666 {
3667 struct internal_reloc *rel;
3668 struct internal_reloc *relend;
3669
3670 rel = relocs;
3671 relend = rel + input_section->reloc_count;
3672 for (; rel < relend; rel++)
3673 {
3674 long symndx;
3675 struct xcoff_link_hash_entry *h;
3676 struct internal_syment *sym;
3677 bfd_vma addend;
3678 bfd_vma val;
3679 struct reloc_howto_struct howto;
3680 bfd_vma relocation;
3681 bfd_vma value_to_relocate;
3682 bfd_vma address;
3683 bfd_byte *location;
3684
3685 /* Relocation type R_REF is a special relocation type which is
3686 merely used to prevent garbage collection from occurring for
3687 the csect including the symbol which it references. */
3688 if (rel->r_type == R_REF)
3689 continue;
3690
3691 /* Retrieve default value in HOWTO table and fix up according
3692 to r_size field, if it can be different.
3693 This should be made during relocation reading but the algorithms
3694 are expecting constant howtos. */
3695 memcpy (&howto, &xcoff_howto_table[rel->r_type], sizeof (howto));
3696 if (howto.bitsize != (rel->r_size & 0x1f) + 1)
3697 {
3698 switch (rel->r_type)
3699 {
3700 case R_POS:
3701 case R_NEG:
3702 howto.bitsize = (rel->r_size & 0x1f) + 1;
3703 howto.size = HOWTO_RSIZE (howto.bitsize > 16 ? 4 : 2);
3704 howto.src_mask = howto.dst_mask = N_ONES (howto.bitsize);
3705 break;
3706
3707 default:
3708 _bfd_error_handler
3709 (_("%pB: relocation (%d) at 0x%" PRIx64 " has wrong r_rsize (0x%x)\n"),
3710 input_bfd, rel->r_type, (uint64_t) rel->r_vaddr, rel->r_size);
3711 return false;
3712 }
3713 }
3714
3715 howto.complain_on_overflow = (rel->r_size & 0x80
3716 ? complain_overflow_signed
3717 : complain_overflow_bitfield);
3718
3719 /* symbol */
3720 val = 0;
3721 addend = 0;
3722 h = NULL;
3723 sym = NULL;
3724 symndx = rel->r_symndx;
3725
3726 if (-1 != symndx)
3727 {
3728 asection *sec;
3729
3730 h = obj_xcoff_sym_hashes (input_bfd)[symndx];
3731 sym = syms + symndx;
3732 addend = - sym->n_value;
3733
3734 if (NULL == h)
3735 {
3736 sec = sections[symndx];
3737 /* Hack to make sure we use the right TOC anchor value
3738 if this reloc is against the TOC anchor. */
3739 if (sec->name[3] == '0'
3740 && strcmp (sec->name, ".tc0") == 0)
3741 val = xcoff_data (output_bfd)->toc;
3742 else
3743 val = (sec->output_section->vma
3744 + sec->output_offset
3745 + sym->n_value
3746 - sec->vma);
3747 }
3748 else
3749 {
3750 if (info->unresolved_syms_in_objects != RM_IGNORE
3751 && (h->flags & XCOFF_WAS_UNDEFINED) != 0)
3752 (*info->callbacks->undefined_symbol)
3753 (info, h->root.root.string,
3754 input_bfd, input_section,
3755 rel->r_vaddr - input_section->vma,
3756 info->unresolved_syms_in_objects == RM_DIAGNOSE &&
3757 !info->warn_unresolved_syms);
3758
3759 if (h->root.type == bfd_link_hash_defined
3760 || h->root.type == bfd_link_hash_defweak)
3761 {
3762 sec = h->root.u.def.section;
3763 val = (h->root.u.def.value
3764 + sec->output_section->vma
3765 + sec->output_offset);
3766 }
3767 else if (h->root.type == bfd_link_hash_common)
3768 {
3769 sec = h->root.u.c.p->section;
3770 val = (sec->output_section->vma
3771 + sec->output_offset);
3772
3773 }
3774 else
3775 {
3776 BFD_ASSERT (bfd_link_relocatable (info)
3777 || (info->static_link
3778 && (h->flags & XCOFF_WAS_UNDEFINED) != 0)
3779 || (h->flags & XCOFF_DEF_DYNAMIC) != 0
3780 || (h->flags & XCOFF_IMPORT) != 0);
3781 }
3782 }
3783 }
3784
3785 if (rel->r_type >= XCOFF_MAX_CALCULATE_RELOCATION
3786 || !((*xcoff_calculate_relocation[rel->r_type])
3787 (input_bfd, input_section, output_bfd, rel, sym, &howto, val,
3788 addend, &relocation, contents, info)))
3789 return false;
3790
3791 /* address */
3792 address = rel->r_vaddr - input_section->vma;
3793 location = contents + address;
3794
3795 if (address > input_section->size)
3796 abort ();
3797
3798 /* Get the value we are going to relocate. */
3799 if (2 == bfd_get_reloc_size (&howto))
3800 value_to_relocate = bfd_get_16 (input_bfd, location);
3801 else
3802 value_to_relocate = bfd_get_32 (input_bfd, location);
3803
3804 /* overflow.
3805
3806 FIXME: We may drop bits during the addition
3807 which we don't check for. We must either check at every single
3808 operation, which would be tedious, or we must do the computations
3809 in a type larger than bfd_vma, which would be inefficient. */
3810
3811 if (((*xcoff_complain_overflow[howto.complain_on_overflow])
3812 (input_bfd, value_to_relocate, relocation, &howto)))
3813 {
3814 const char *name;
3815 char buf[SYMNMLEN + 1];
3816 char reloc_type_name[10];
3817
3818 if (symndx == -1)
3819 {
3820 name = "*ABS*";
3821 }
3822 else if (h != NULL)
3823 {
3824 name = NULL;
3825 }
3826 else
3827 {
3828 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3829 if (name == NULL)
3830 name = "UNKNOWN";
3831 }
3832 sprintf (reloc_type_name, "0x%02x", rel->r_type);
3833
3834 (*info->callbacks->reloc_overflow)
3835 (info, (h ? &h->root : NULL), name, reloc_type_name,
3836 (bfd_vma) 0, input_bfd, input_section,
3837 rel->r_vaddr - input_section->vma);
3838 }
3839
3840 /* Add RELOCATION to the right bits of VALUE_TO_RELOCATE. */
3841 value_to_relocate = ((value_to_relocate & ~howto.dst_mask)
3842 | (((value_to_relocate & howto.src_mask)
3843 + relocation) & howto.dst_mask));
3844
3845 /* Put the value back in the object file. */
3846 if (2 == bfd_get_reloc_size (&howto))
3847 bfd_put_16 (input_bfd, value_to_relocate, location);
3848 else
3849 bfd_put_32 (input_bfd, value_to_relocate, location);
3850 }
3851
3852 return true;
3853 }
3854
3855 /* gcc-8 warns (*) on all the strncpy calls in this function about
3856 possible string truncation. The "truncation" is not a bug. We
3857 have an external representation of structs with fields that are not
3858 necessarily NULL terminated and corresponding internal
3859 representation fields that are one larger so that they can always
3860 be NULL terminated.
3861 gcc versions between 4.2 and 4.6 do not allow pragma control of
3862 diagnostics inside functions, giving a hard error if you try to use
3863 the finer control available with later versions.
3864 gcc prior to 4.2 warns about diagnostic push and pop.
3865 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
3866 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
3867 (*) Depending on your system header files! */
3868 #if GCC_VERSION >= 8000
3869 # pragma GCC diagnostic push
3870 # pragma GCC diagnostic ignored "-Wstringop-truncation"
3871 #endif
3872 static bool
3873 _bfd_xcoff_put_ldsymbol_name (bfd *abfd ATTRIBUTE_UNUSED,
3874 struct xcoff_loader_info *ldinfo,
3875 struct internal_ldsym *ldsym,
3876 const char *name)
3877 {
3878 size_t len;
3879 len = strlen (name);
3880
3881 if (len <= SYMNMLEN)
3882 strncpy (ldsym->_l._l_name, name, SYMNMLEN);
3883 else
3884 {
3885 if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
3886 {
3887 bfd_size_type newalc;
3888 char *newstrings;
3889
3890 newalc = ldinfo->string_alc * 2;
3891 if (newalc == 0)
3892 newalc = 32;
3893 while (ldinfo->string_size + len + 3 > newalc)
3894 newalc *= 2;
3895
3896 newstrings = bfd_realloc (ldinfo->strings, newalc);
3897 if (newstrings == NULL)
3898 {
3899 ldinfo->failed = true;
3900 return false;
3901 }
3902 ldinfo->string_alc = newalc;
3903 ldinfo->strings = newstrings;
3904 }
3905
3906 ldinfo->strings[ldinfo->string_size] = ((len + 1) >> 8) & 0xff;
3907 ldinfo->strings[ldinfo->string_size + 1] = ((len + 1)) & 0xff;
3908 strcpy (ldinfo->strings + ldinfo->string_size + 2, name);
3909 ldsym->_l._l_l._l_zeroes = 0;
3910 ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
3911 ldinfo->string_size += len + 3;
3912 }
3913
3914 return true;
3915 }
3916
3917 static bool
3918 _bfd_xcoff_put_symbol_name (struct bfd_link_info *info,
3919 struct bfd_strtab_hash *strtab,
3920 struct internal_syment *sym,
3921 const char *name)
3922 {
3923 if (strlen (name) <= SYMNMLEN)
3924 {
3925 strncpy (sym->_n._n_name, name, SYMNMLEN);
3926 }
3927 else
3928 {
3929 bool hash;
3930 bfd_size_type indx;
3931
3932 hash = !info->traditional_format;
3933 indx = _bfd_stringtab_add (strtab, name, hash, false);
3934 if (indx == (bfd_size_type) -1)
3935 return false;
3936 sym->_n._n_n._n_zeroes = 0;
3937 sym->_n._n_n._n_offset = STRING_SIZE_SIZE + indx;
3938 }
3939 return true;
3940 }
3941 #if GCC_VERSION >= 8000
3942 # pragma GCC diagnostic pop
3943 #endif
3944
3945 static asection *
3946 xcoff_create_csect_from_smclas (bfd *abfd,
3947 union internal_auxent *aux,
3948 const char *symbol_name)
3949 {
3950 asection *return_value = NULL;
3951
3952 /* .sv64 = x_smclas == 17
3953 This is an invalid csect for 32 bit apps. */
3954 static const char * const names[] =
3955 {
3956 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo", /* 0 - 7 */
3957 ".sv", ".bs", ".ds", ".uc", ".ti", ".tb", NULL, ".tc0", /* 8 - 15 */
3958 ".td", NULL, ".sv3264", NULL, ".tl", ".ul", ".te"
3959 };
3960
3961 if ((aux->x_csect.x_smclas < ARRAY_SIZE (names))
3962 && (NULL != names[aux->x_csect.x_smclas]))
3963 {
3964 return_value = bfd_make_section_anyway
3965 (abfd, names[aux->x_csect.x_smclas]);
3966 }
3967 else
3968 {
3969 _bfd_error_handler
3970 /* xgettext: c-format */
3971 (_("%pB: symbol `%s' has unrecognized smclas %d"),
3972 abfd, symbol_name, aux->x_csect.x_smclas);
3973 bfd_set_error (bfd_error_bad_value);
3974 }
3975
3976 return return_value;
3977 }
3978
3979 static bool
3980 xcoff_is_lineno_count_overflow (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma value)
3981 {
3982 if (0xffff <= value)
3983 return true;
3984
3985 return false;
3986 }
3987
3988 static bool
3989 xcoff_is_reloc_count_overflow (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma value)
3990 {
3991 if (0xffff <= value)
3992 return true;
3993
3994 return false;
3995 }
3996
3997 static bfd_vma
3998 xcoff_loader_symbol_offset (bfd *abfd,
3999 struct internal_ldhdr *ldhdr ATTRIBUTE_UNUSED)
4000 {
4001 return bfd_xcoff_ldhdrsz (abfd);
4002 }
4003
4004 static bfd_vma
4005 xcoff_loader_reloc_offset (bfd *abfd, struct internal_ldhdr *ldhdr)
4006 {
4007 return bfd_xcoff_ldhdrsz (abfd) + ldhdr->l_nsyms * bfd_xcoff_ldsymsz (abfd);
4008 }
4009
4010 static bool
4011 xcoff_generate_rtinit (bfd *abfd, const char *init, const char *fini,
4012 bool rtld)
4013 {
4014 bfd_byte filehdr_ext[FILHSZ];
4015 bfd_byte scnhdr_ext[SCNHSZ];
4016 bfd_byte syment_ext[SYMESZ * 10];
4017 bfd_byte reloc_ext[RELSZ * 3];
4018 bfd_byte *data_buffer;
4019 bfd_size_type data_buffer_size;
4020 bfd_byte *string_table = NULL, *st_tmp = NULL;
4021 bfd_size_type string_table_size;
4022 bfd_vma val;
4023 size_t initsz, finisz;
4024 struct internal_filehdr filehdr;
4025 struct internal_scnhdr scnhdr;
4026 struct internal_syment syment;
4027 union internal_auxent auxent;
4028 struct internal_reloc reloc;
4029
4030 char *data_name = ".data";
4031 char *rtinit_name = "__rtinit";
4032 char *rtld_name = "__rtld";
4033
4034 if (! bfd_xcoff_rtinit_size (abfd))
4035 return false;
4036
4037 initsz = (init == NULL ? 0 : 1 + strlen (init));
4038 finisz = (fini == NULL ? 0 : 1 + strlen (fini));
4039
4040 /* file header */
4041 memset (filehdr_ext, 0, FILHSZ);
4042 memset (&filehdr, 0, sizeof (struct internal_filehdr));
4043 filehdr.f_magic = bfd_xcoff_magic_number (abfd);
4044 filehdr.f_nscns = 1;
4045 filehdr.f_timdat = 0;
4046 filehdr.f_nsyms = 0; /* at least 6, no more than 10 */
4047 filehdr.f_symptr = 0; /* set below */
4048 filehdr.f_opthdr = 0;
4049 filehdr.f_flags = 0;
4050
4051 /* section header */
4052 memset (scnhdr_ext, 0, SCNHSZ);
4053 memset (&scnhdr, 0, sizeof (struct internal_scnhdr));
4054 memcpy (scnhdr.s_name, data_name, strlen (data_name));
4055 scnhdr.s_paddr = 0;
4056 scnhdr.s_vaddr = 0;
4057 scnhdr.s_size = 0; /* set below */
4058 scnhdr.s_scnptr = FILHSZ + SCNHSZ;
4059 scnhdr.s_relptr = 0; /* set below */
4060 scnhdr.s_lnnoptr = 0;
4061 scnhdr.s_nreloc = 0; /* either 1 or 2 */
4062 scnhdr.s_nlnno = 0;
4063 scnhdr.s_flags = STYP_DATA;
4064
4065 /* .data
4066 0x0000 0x00000000 : rtl
4067 0x0004 0x00000010 : offset to init, or 0
4068 0x0008 0x00000028 : offset to fini, or 0
4069 0x000C 0x0000000C : size of descriptor
4070 0x0010 0x00000000 : init, needs a reloc
4071 0x0014 0x00000040 : offset to init name
4072 0x0018 0x00000000 : flags, padded to a word
4073 0x001C 0x00000000 : empty init
4074 0x0020 0x00000000 :
4075 0x0024 0x00000000 :
4076 0x0028 0x00000000 : fini, needs a reloc
4077 0x002C 0x00000??? : offset to fini name
4078 0x0030 0x00000000 : flags, padded to a word
4079 0x0034 0x00000000 : empty fini
4080 0x0038 0x00000000 :
4081 0x003C 0x00000000 :
4082 0x0040 init name
4083 0x0040 + initsz fini name */
4084
4085 data_buffer_size = 0x0040 + initsz + finisz;
4086 data_buffer_size = (data_buffer_size + 7) &~ (bfd_size_type) 7;
4087 data_buffer = NULL;
4088 data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size);
4089 if (data_buffer == NULL)
4090 return false;
4091
4092 if (initsz)
4093 {
4094 val = 0x10;
4095 bfd_h_put_32 (abfd, val, &data_buffer[0x04]);
4096 val = 0x40;
4097 bfd_h_put_32 (abfd, val, &data_buffer[0x14]);
4098 memcpy (&data_buffer[val], init, initsz);
4099 }
4100
4101 if (finisz)
4102 {
4103 val = 0x28;
4104 bfd_h_put_32 (abfd, val, &data_buffer[0x08]);
4105 val = 0x40 + initsz;
4106 bfd_h_put_32 (abfd, val, &data_buffer[0x2C]);
4107 memcpy (&data_buffer[val], fini, finisz);
4108 }
4109
4110 val = 0x0C;
4111 bfd_h_put_32 (abfd, val, &data_buffer[0x0C]);
4112
4113 scnhdr.s_size = data_buffer_size;
4114
4115 /* string table */
4116 string_table_size = 0;
4117 if (initsz > 9)
4118 string_table_size += initsz;
4119 if (finisz > 9)
4120 string_table_size += finisz;
4121 if (string_table_size)
4122 {
4123 string_table_size += 4;
4124 string_table = (bfd_byte *) bfd_zmalloc (string_table_size);
4125 if (string_table == NULL)
4126 return false;
4127
4128 val = string_table_size;
4129 bfd_h_put_32 (abfd, val, &string_table[0]);
4130 st_tmp = string_table + 4;
4131 }
4132
4133 /* symbols
4134 0. .data csect
4135 2. __rtinit
4136 4. init function
4137 6. fini function
4138 8. __rtld */
4139 memset (syment_ext, 0, 10 * SYMESZ);
4140 memset (reloc_ext, 0, 3 * RELSZ);
4141
4142 /* .data csect */
4143 memset (&syment, 0, sizeof (struct internal_syment));
4144 memset (&auxent, 0, sizeof (union internal_auxent));
4145 memcpy (syment._n._n_name, data_name, strlen (data_name));
4146 syment.n_scnum = 1;
4147 syment.n_sclass = C_HIDEXT;
4148 syment.n_numaux = 1;
4149 auxent.x_csect.x_scnlen.l = data_buffer_size;
4150 auxent.x_csect.x_smtyp = 3 << 3 | XTY_SD;
4151 auxent.x_csect.x_smclas = XMC_RW;
4152 bfd_coff_swap_sym_out (abfd, &syment,
4153 &syment_ext[filehdr.f_nsyms * SYMESZ]);
4154 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
4155 syment.n_numaux,
4156 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
4157 filehdr.f_nsyms += 2;
4158
4159 /* __rtinit */
4160 memset (&syment, 0, sizeof (struct internal_syment));
4161 memset (&auxent, 0, sizeof (union internal_auxent));
4162 memcpy (syment._n._n_name, rtinit_name, strlen (rtinit_name));
4163 syment.n_scnum = 1;
4164 syment.n_sclass = C_EXT;
4165 syment.n_numaux = 1;
4166 auxent.x_csect.x_smtyp = XTY_LD;
4167 auxent.x_csect.x_smclas = XMC_RW;
4168 bfd_coff_swap_sym_out (abfd, &syment,
4169 &syment_ext[filehdr.f_nsyms * SYMESZ]);
4170 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
4171 syment.n_numaux,
4172 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
4173 filehdr.f_nsyms += 2;
4174
4175 /* init */
4176 if (initsz)
4177 {
4178 memset (&syment, 0, sizeof (struct internal_syment));
4179 memset (&auxent, 0, sizeof (union internal_auxent));
4180
4181 if (initsz > 9)
4182 {
4183 syment._n._n_n._n_offset = st_tmp - string_table;
4184 memcpy (st_tmp, init, initsz);
4185 st_tmp += initsz;
4186 }
4187 else
4188 memcpy (syment._n._n_name, init, initsz - 1);
4189
4190 syment.n_sclass = C_EXT;
4191 syment.n_numaux = 1;
4192 bfd_coff_swap_sym_out (abfd, &syment,
4193 &syment_ext[filehdr.f_nsyms * SYMESZ]);
4194 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
4195 syment.n_numaux,
4196 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
4197
4198 /* reloc */
4199 memset (&reloc, 0, sizeof (struct internal_reloc));
4200 reloc.r_vaddr = 0x0010;
4201 reloc.r_symndx = filehdr.f_nsyms;
4202 reloc.r_type = R_POS;
4203 reloc.r_size = 31;
4204 bfd_coff_swap_reloc_out (abfd, &reloc, &reloc_ext[0]);
4205
4206 filehdr.f_nsyms += 2;
4207 scnhdr.s_nreloc += 1;
4208 }
4209
4210 /* fini */
4211 if (finisz)
4212 {
4213 memset (&syment, 0, sizeof (struct internal_syment));
4214 memset (&auxent, 0, sizeof (union internal_auxent));
4215
4216 if (finisz > 9)
4217 {
4218 syment._n._n_n._n_offset = st_tmp - string_table;
4219 memcpy (st_tmp, fini, finisz);
4220 st_tmp += finisz;
4221 }
4222 else
4223 memcpy (syment._n._n_name, fini, finisz - 1);
4224
4225 syment.n_sclass = C_EXT;
4226 syment.n_numaux = 1;
4227 bfd_coff_swap_sym_out (abfd, &syment,
4228 &syment_ext[filehdr.f_nsyms * SYMESZ]);
4229 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
4230 syment.n_numaux,
4231 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
4232
4233 /* reloc */
4234 memset (&reloc, 0, sizeof (struct internal_reloc));
4235 reloc.r_vaddr = 0x0028;
4236 reloc.r_symndx = filehdr.f_nsyms;
4237 reloc.r_type = R_POS;
4238 reloc.r_size = 31;
4239 bfd_coff_swap_reloc_out (abfd, &reloc,
4240 &reloc_ext[scnhdr.s_nreloc * RELSZ]);
4241
4242 filehdr.f_nsyms += 2;
4243 scnhdr.s_nreloc += 1;
4244 }
4245
4246 if (rtld)
4247 {
4248 memset (&syment, 0, sizeof (struct internal_syment));
4249 memset (&auxent, 0, sizeof (union internal_auxent));
4250 memcpy (syment._n._n_name, rtld_name, strlen (rtld_name));
4251 syment.n_sclass = C_EXT;
4252 syment.n_numaux = 1;
4253 bfd_coff_swap_sym_out (abfd, &syment,
4254 &syment_ext[filehdr.f_nsyms * SYMESZ]);
4255 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
4256 syment.n_numaux,
4257 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
4258
4259 /* reloc */
4260 memset (&reloc, 0, sizeof (struct internal_reloc));
4261 reloc.r_vaddr = 0x0000;
4262 reloc.r_symndx = filehdr.f_nsyms;
4263 reloc.r_type = R_POS;
4264 reloc.r_size = 31;
4265 bfd_coff_swap_reloc_out (abfd, &reloc,
4266 &reloc_ext[scnhdr.s_nreloc * RELSZ]);
4267
4268 filehdr.f_nsyms += 2;
4269 scnhdr.s_nreloc += 1;
4270 }
4271
4272 scnhdr.s_relptr = scnhdr.s_scnptr + data_buffer_size;
4273 filehdr.f_symptr = scnhdr.s_relptr + scnhdr.s_nreloc * RELSZ;
4274
4275 bfd_coff_swap_filehdr_out (abfd, &filehdr, filehdr_ext);
4276 bfd_bwrite (filehdr_ext, FILHSZ, abfd);
4277 bfd_coff_swap_scnhdr_out (abfd, &scnhdr, scnhdr_ext);
4278 bfd_bwrite (scnhdr_ext, SCNHSZ, abfd);
4279 bfd_bwrite (data_buffer, data_buffer_size, abfd);
4280 bfd_bwrite (reloc_ext, scnhdr.s_nreloc * RELSZ, abfd);
4281 bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd);
4282 bfd_bwrite (string_table, string_table_size, abfd);
4283
4284 free (data_buffer);
4285 data_buffer = NULL;
4286
4287 return true;
4288 }
4289
4290
4291 static reloc_howto_type xcoff_dynamic_reloc =
4292 HOWTO (0, /* type */
4293 0, /* rightshift */
4294 4, /* size */
4295 32, /* bitsize */
4296 false, /* pc_relative */
4297 0, /* bitpos */
4298 complain_overflow_bitfield, /* complain_on_overflow */
4299 0, /* special_function */
4300 "R_POS", /* name */
4301 true, /* partial_inplace */
4302 0xffffffff, /* src_mask */
4303 0xffffffff, /* dst_mask */
4304 false); /* pcrel_offset */
4305
4306 /* Indirect call stub
4307 The first word of the code must be modified by filling in
4308 the correct TOC offset. */
4309
4310 static const unsigned long xcoff_stub_indirect_call_code[4] =
4311 {
4312 0x81820000, /* lwz r12,0(r2) */
4313 0x800c0000, /* lwz r0,0(r12) */
4314 0x7c0903a6, /* mtctr r0 */
4315 0x4e800420, /* bctr */
4316 };
4317
4318 /* Shared call stub
4319 The first word of the code must be modified by filling in
4320 the correct TOC offset.
4321 This is exactly as the glink code but without the traceback,
4322 as it won't be an independent function. */
4323
4324 static const unsigned long xcoff_stub_shared_call_code[6] =
4325 {
4326 0x81820000, /* lwz r12,0(r2) */
4327 0x90410014, /* stw r2,20(r1) */
4328 0x800c0000, /* lwz r0,0(r12) */
4329 0x804c0004, /* lwz r2,4(r12) */
4330 0x7c0903a6, /* mtctr r0 */
4331 0x4e800420, /* bctr */
4332 };
4333
4334 /* glink
4335
4336 The first word of global linkage code must be modified by filling in
4337 the correct TOC offset. */
4338
4339 static const unsigned long xcoff_glink_code[9] =
4340 {
4341 0x81820000, /* lwz r12,0(r2) */
4342 0x90410014, /* stw r2,20(r1) */
4343 0x800c0000, /* lwz r0,0(r12) */
4344 0x804c0004, /* lwz r2,4(r12) */
4345 0x7c0903a6, /* mtctr r0 */
4346 0x4e800420, /* bctr */
4347 0x00000000, /* start of traceback table */
4348 0x000c8000, /* traceback table */
4349 0x00000000, /* traceback table */
4350 };
4351
4352 /* Table to convert DWARF flags to section names.
4353 Remember to update binutils/dwarf.c:debug_displays
4354 if new DWARF sections are supported by XCOFF. */
4355
4356 const struct xcoff_dwsect_name xcoff_dwsect_names[] = {
4357 { SSUBTYP_DWINFO, ".dwinfo", ".debug_info", true },
4358 { SSUBTYP_DWLINE, ".dwline", ".debug_line", true },
4359 { SSUBTYP_DWPBNMS, ".dwpbnms", ".debug_pubnames", true },
4360 { SSUBTYP_DWPBTYP, ".dwpbtyp", ".debug_pubtypes", true },
4361 { SSUBTYP_DWARNGE, ".dwarnge", ".debug_aranges", true },
4362 { SSUBTYP_DWABREV, ".dwabrev", ".debug_abbrev", false },
4363 { SSUBTYP_DWSTR, ".dwstr", ".debug_str", true },
4364 { SSUBTYP_DWRNGES, ".dwrnges", ".debug_ranges", true },
4365 { SSUBTYP_DWLOC, ".dwloc", ".debug_loc", true },
4366 { SSUBTYP_DWFRAME, ".dwframe", ".debug_frame", true },
4367 { SSUBTYP_DWMAC, ".dwmac", ".debug_macro", true }
4368 };
4369
4370 /* For generic entry points. */
4371 #define _bfd_xcoff_close_and_cleanup _bfd_coff_close_and_cleanup
4372 #define _bfd_xcoff_bfd_free_cached_info _bfd_bool_bfd_true
4373 #define _bfd_xcoff_new_section_hook coff_new_section_hook
4374 #define _bfd_xcoff_get_section_contents _bfd_generic_get_section_contents
4375 #define _bfd_xcoff_get_section_contents_in_window \
4376 _bfd_generic_get_section_contents_in_window
4377
4378 /* For copy private data entry points. */
4379 #define _bfd_xcoff_bfd_copy_private_bfd_data \
4380 _bfd_xcoff_copy_private_bfd_data
4381 #define _bfd_xcoff_bfd_merge_private_bfd_data \
4382 _bfd_generic_bfd_merge_private_bfd_data
4383 #define _bfd_xcoff_bfd_copy_private_section_data \
4384 _bfd_generic_bfd_copy_private_section_data
4385 #define _bfd_xcoff_bfd_copy_private_symbol_data \
4386 _bfd_generic_bfd_copy_private_symbol_data
4387 #define _bfd_xcoff_bfd_copy_private_header_data \
4388 _bfd_generic_bfd_copy_private_header_data
4389 #define _bfd_xcoff_bfd_set_private_flags \
4390 _bfd_generic_bfd_set_private_flags
4391 #define _bfd_xcoff_bfd_print_private_bfd_data \
4392 _bfd_generic_bfd_print_private_bfd_data
4393
4394 /* For archive entry points. */
4395 #define _bfd_xcoff_slurp_extended_name_table \
4396 _bfd_noarchive_slurp_extended_name_table
4397 #define _bfd_xcoff_construct_extended_name_table \
4398 _bfd_noarchive_construct_extended_name_table
4399 #define _bfd_xcoff_truncate_arname bfd_dont_truncate_arname
4400 #define _bfd_xcoff_write_ar_hdr _bfd_generic_write_ar_hdr
4401 #define _bfd_xcoff_get_elt_at_index _bfd_generic_get_elt_at_index
4402 #define _bfd_xcoff_generic_stat_arch_elt _bfd_xcoff_stat_arch_elt
4403 #define _bfd_xcoff_update_armap_timestamp _bfd_bool_bfd_true
4404
4405 /* For symbols entry points. */
4406 #define _bfd_xcoff_get_symtab_upper_bound coff_get_symtab_upper_bound
4407 #define _bfd_xcoff_canonicalize_symtab coff_canonicalize_symtab
4408 #define _bfd_xcoff_make_empty_symbol coff_make_empty_symbol
4409 #define _bfd_xcoff_print_symbol coff_print_symbol
4410 #define _bfd_xcoff_get_symbol_info coff_get_symbol_info
4411 #define _bfd_xcoff_get_symbol_version_string \
4412 _bfd_nosymbols_get_symbol_version_string
4413 #define _bfd_xcoff_bfd_is_local_label_name _bfd_xcoff_is_local_label_name
4414 #define _bfd_xcoff_bfd_is_target_special_symbol \
4415 coff_bfd_is_target_special_symbol
4416 #define _bfd_xcoff_get_lineno coff_get_lineno
4417 #define _bfd_xcoff_find_nearest_line coff_find_nearest_line
4418 #define _bfd_xcoff_find_nearest_line_with_alt \
4419 coff_find_nearest_line_with_alt
4420 #define _bfd_xcoff_find_line coff_find_line
4421 #define _bfd_xcoff_find_inliner_info coff_find_inliner_info
4422 #define _bfd_xcoff_bfd_make_debug_symbol coff_bfd_make_debug_symbol
4423 #define _bfd_xcoff_read_minisymbols _bfd_generic_read_minisymbols
4424 #define _bfd_xcoff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
4425
4426 /* For reloc entry points. */
4427 #define _bfd_xcoff_get_reloc_upper_bound coff_get_reloc_upper_bound
4428 #define _bfd_xcoff_canonicalize_reloc coff_canonicalize_reloc
4429 #define _bfd_xcoff_set_reloc _bfd_generic_set_reloc
4430 #define _bfd_xcoff_bfd_reloc_type_lookup _bfd_xcoff_reloc_type_lookup
4431 #define _bfd_xcoff_bfd_reloc_name_lookup _bfd_xcoff_reloc_name_lookup
4432
4433 /* For link entry points. */
4434 #define _bfd_xcoff_bfd_get_relocated_section_contents \
4435 bfd_generic_get_relocated_section_contents
4436 #define _bfd_xcoff_bfd_relax_section bfd_generic_relax_section
4437 #define _bfd_xcoff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
4438 #define _bfd_xcoff_bfd_link_just_syms _bfd_generic_link_just_syms
4439 #define _bfd_xcoff_bfd_copy_link_hash_symbol_type \
4440 _bfd_generic_copy_link_hash_symbol_type
4441 #define _bfd_xcoff_bfd_link_split_section _bfd_generic_link_split_section
4442 #define _bfd_xcoff_bfd_gc_sections bfd_generic_gc_sections
4443 #define _bfd_xcoff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
4444 #define _bfd_xcoff_bfd_merge_sections bfd_generic_merge_sections
4445 #define _bfd_xcoff_bfd_is_group_section bfd_generic_is_group_section
4446 #define _bfd_xcoff_bfd_group_name bfd_generic_group_name
4447 #define _bfd_xcoff_bfd_discard_group bfd_generic_discard_group
4448 #define _bfd_xcoff_section_already_linked _bfd_generic_section_already_linked
4449 #define _bfd_xcoff_bfd_define_common_symbol _bfd_xcoff_define_common_symbol
4450 #define _bfd_xcoff_bfd_link_hide_symbol _bfd_generic_link_hide_symbol
4451 #define _bfd_xcoff_bfd_define_start_stop bfd_generic_define_start_stop
4452 #define _bfd_xcoff_bfd_link_check_relocs _bfd_generic_link_check_relocs
4453
4454 /* For dynamic symbols and relocs entry points. */
4455 #define _bfd_xcoff_get_synthetic_symtab _bfd_nodynamic_get_synthetic_symtab
4456
4457 static const struct xcoff_backend_data_rec bfd_xcoff_backend_data =
4458 {
4459 { /* COFF backend, defined in libcoff.h. */
4460 _bfd_xcoff_swap_aux_in,
4461 _bfd_xcoff_swap_sym_in,
4462 coff_swap_lineno_in,
4463 _bfd_xcoff_swap_aux_out,
4464 _bfd_xcoff_swap_sym_out,
4465 coff_swap_lineno_out,
4466 xcoff_swap_reloc_out,
4467 coff_swap_filehdr_out,
4468 coff_swap_aouthdr_out,
4469 coff_swap_scnhdr_out,
4470 FILHSZ,
4471 AOUTSZ,
4472 SCNHSZ,
4473 SYMESZ,
4474 AUXESZ,
4475 RELSZ,
4476 LINESZ,
4477 FILNMLEN,
4478 true, /* _bfd_coff_long_filenames */
4479 XCOFF_NO_LONG_SECTION_NAMES, /* _bfd_coff_long_section_names */
4480 3, /* _bfd_coff_default_section_alignment_power */
4481 false, /* _bfd_coff_force_symnames_in_strings */
4482 2, /* _bfd_coff_debug_string_prefix_length */
4483 32768, /* _bfd_coff_max_nscns */
4484 coff_swap_filehdr_in,
4485 coff_swap_aouthdr_in,
4486 coff_swap_scnhdr_in,
4487 xcoff_swap_reloc_in,
4488 coff_bad_format_hook,
4489 coff_set_arch_mach_hook,
4490 coff_mkobject_hook,
4491 styp_to_sec_flags,
4492 coff_set_alignment_hook,
4493 coff_slurp_symbol_table,
4494 symname_in_debug_hook,
4495 coff_pointerize_aux_hook,
4496 coff_print_aux,
4497 dummy_reloc16_extra_cases,
4498 dummy_reloc16_estimate,
4499 NULL, /* bfd_coff_sym_is_global */
4500 coff_compute_section_file_positions,
4501 NULL, /* _bfd_coff_start_final_link */
4502 xcoff_ppc_relocate_section,
4503 coff_rtype_to_howto,
4504 NULL, /* _bfd_coff_adjust_symndx */
4505 _bfd_generic_link_add_one_symbol,
4506 coff_link_output_has_begun,
4507 coff_final_link_postscript,
4508 NULL /* print_pdata. */
4509 },
4510
4511 0x01DF, /* magic number */
4512 bfd_arch_rs6000,
4513 bfd_mach_rs6k,
4514
4515 /* Function pointers to xcoff specific swap routines. */
4516 xcoff_swap_ldhdr_in,
4517 xcoff_swap_ldhdr_out,
4518 xcoff_swap_ldsym_in,
4519 xcoff_swap_ldsym_out,
4520 xcoff_swap_ldrel_in,
4521 xcoff_swap_ldrel_out,
4522
4523 /* Sizes. */
4524 LDHDRSZ,
4525 LDSYMSZ,
4526 LDRELSZ,
4527 12, /* _xcoff_function_descriptor_size */
4528 SMALL_AOUTSZ,
4529
4530 /* Versions. */
4531 1, /* _xcoff_ldhdr_version */
4532
4533 _bfd_xcoff_put_symbol_name,
4534 _bfd_xcoff_put_ldsymbol_name,
4535 &xcoff_dynamic_reloc,
4536 xcoff_create_csect_from_smclas,
4537
4538 /* Lineno and reloc count overflow. */
4539 xcoff_is_lineno_count_overflow,
4540 xcoff_is_reloc_count_overflow,
4541
4542 xcoff_loader_symbol_offset,
4543 xcoff_loader_reloc_offset,
4544
4545 /* glink. */
4546 &xcoff_glink_code[0],
4547 36, /* _xcoff_glink_size */
4548
4549 /* rtinit */
4550 64, /* _xcoff_rtinit_size */
4551 xcoff_generate_rtinit,
4552
4553 /* Stub indirect call. */
4554 &xcoff_stub_indirect_call_code[0],
4555 16, /* _xcoff_stub_indirect_call_size */
4556
4557 /* Stub shared call. */
4558 &xcoff_stub_shared_call_code[0],
4559 24, /* _xcoff_stub_shared_call_size */
4560 };
4561
4562 /* The transfer vector that leads the outside world to all of the above. */
4563 const bfd_target rs6000_xcoff_vec =
4564 {
4565 "aixcoff-rs6000",
4566 bfd_target_xcoff_flavour,
4567 BFD_ENDIAN_BIG, /* data byte order is big */
4568 BFD_ENDIAN_BIG, /* header byte order is big */
4569
4570 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
4571 | HAS_SYMS | HAS_LOCALS | WP_TEXT),
4572
4573 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
4574 0, /* leading char */
4575 '/', /* ar_pad_char */
4576 15, /* ar_max_namelen */
4577 0, /* match priority. */
4578 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */
4579
4580 /* data */
4581 bfd_getb64,
4582 bfd_getb_signed_64,
4583 bfd_putb64,
4584 bfd_getb32,
4585 bfd_getb_signed_32,
4586 bfd_putb32,
4587 bfd_getb16,
4588 bfd_getb_signed_16,
4589 bfd_putb16,
4590
4591 /* hdrs */
4592 bfd_getb64,
4593 bfd_getb_signed_64,
4594 bfd_putb64,
4595 bfd_getb32,
4596 bfd_getb_signed_32,
4597 bfd_putb32,
4598 bfd_getb16,
4599 bfd_getb_signed_16,
4600 bfd_putb16,
4601
4602 { /* bfd_check_format */
4603 _bfd_dummy_target,
4604 coff_object_p,
4605 _bfd_xcoff_archive_p,
4606 CORE_FILE_P
4607 },
4608
4609 { /* bfd_set_format */
4610 _bfd_bool_bfd_false_error,
4611 coff_mkobject,
4612 _bfd_generic_mkarchive,
4613 _bfd_bool_bfd_false_error
4614 },
4615
4616 {/* bfd_write_contents */
4617 _bfd_bool_bfd_false_error,
4618 coff_write_object_contents,
4619 _bfd_xcoff_write_archive_contents,
4620 _bfd_bool_bfd_false_error
4621 },
4622
4623 BFD_JUMP_TABLE_GENERIC (_bfd_xcoff),
4624 BFD_JUMP_TABLE_COPY (_bfd_xcoff),
4625 BFD_JUMP_TABLE_CORE (coff),
4626 BFD_JUMP_TABLE_ARCHIVE (_bfd_xcoff),
4627 BFD_JUMP_TABLE_SYMBOLS (_bfd_xcoff),
4628 BFD_JUMP_TABLE_RELOCS (_bfd_xcoff),
4629 BFD_JUMP_TABLE_WRITE (coff),
4630 BFD_JUMP_TABLE_LINK (_bfd_xcoff),
4631 BFD_JUMP_TABLE_DYNAMIC (_bfd_xcoff),
4632
4633 /* Opposite endian version, none exists */
4634 NULL,
4635
4636 & bfd_xcoff_backend_data,
4637 };
4638
4639 /* xcoff-powermac target
4640 Old target.
4641 Only difference between this target and the rs6000 target is the
4642 the default architecture and machine type used in coffcode.h
4643
4644 PowerPC Macs use the same magic numbers as RS/6000
4645 (because that's how they were bootstrapped originally),
4646 but they are always PowerPC architecture. */
4647 static const struct xcoff_backend_data_rec bfd_pmac_xcoff_backend_data =
4648 {
4649 { /* COFF backend, defined in libcoff.h. */
4650 _bfd_xcoff_swap_aux_in,
4651 _bfd_xcoff_swap_sym_in,
4652 coff_swap_lineno_in,
4653 _bfd_xcoff_swap_aux_out,
4654 _bfd_xcoff_swap_sym_out,
4655 coff_swap_lineno_out,
4656 xcoff_swap_reloc_out,
4657 coff_swap_filehdr_out,
4658 coff_swap_aouthdr_out,
4659 coff_swap_scnhdr_out,
4660 FILHSZ,
4661 AOUTSZ,
4662 SCNHSZ,
4663 SYMESZ,
4664 AUXESZ,
4665 RELSZ,
4666 LINESZ,
4667 FILNMLEN,
4668 true, /* _bfd_coff_long_filenames */
4669 XCOFF_NO_LONG_SECTION_NAMES, /* _bfd_coff_long_section_names */
4670 3, /* _bfd_coff_default_section_alignment_power */
4671 false, /* _bfd_coff_force_symnames_in_strings */
4672 2, /* _bfd_coff_debug_string_prefix_length */
4673 32768, /* _bfd_coff_max_nscns */
4674 coff_swap_filehdr_in,
4675 coff_swap_aouthdr_in,
4676 coff_swap_scnhdr_in,
4677 xcoff_swap_reloc_in,
4678 coff_bad_format_hook,
4679 coff_set_arch_mach_hook,
4680 coff_mkobject_hook,
4681 styp_to_sec_flags,
4682 coff_set_alignment_hook,
4683 coff_slurp_symbol_table,
4684 symname_in_debug_hook,
4685 coff_pointerize_aux_hook,
4686 coff_print_aux,
4687 dummy_reloc16_extra_cases,
4688 dummy_reloc16_estimate,
4689 NULL, /* bfd_coff_sym_is_global */
4690 coff_compute_section_file_positions,
4691 NULL, /* _bfd_coff_start_final_link */
4692 xcoff_ppc_relocate_section,
4693 coff_rtype_to_howto,
4694 NULL, /* _bfd_coff_adjust_symndx */
4695 _bfd_generic_link_add_one_symbol,
4696 coff_link_output_has_begun,
4697 coff_final_link_postscript,
4698 NULL /* print_pdata. */
4699 },
4700
4701 0x01DF, /* magic number */
4702 bfd_arch_powerpc,
4703 bfd_mach_ppc,
4704
4705 /* Function pointers to xcoff specific swap routines. */
4706 xcoff_swap_ldhdr_in,
4707 xcoff_swap_ldhdr_out,
4708 xcoff_swap_ldsym_in,
4709 xcoff_swap_ldsym_out,
4710 xcoff_swap_ldrel_in,
4711 xcoff_swap_ldrel_out,
4712
4713 /* Sizes. */
4714 LDHDRSZ,
4715 LDSYMSZ,
4716 LDRELSZ,
4717 12, /* _xcoff_function_descriptor_size */
4718 SMALL_AOUTSZ,
4719
4720 /* Versions. */
4721 1, /* _xcoff_ldhdr_version */
4722
4723 _bfd_xcoff_put_symbol_name,
4724 _bfd_xcoff_put_ldsymbol_name,
4725 &xcoff_dynamic_reloc,
4726 xcoff_create_csect_from_smclas,
4727
4728 /* Lineno and reloc count overflow. */
4729 xcoff_is_lineno_count_overflow,
4730 xcoff_is_reloc_count_overflow,
4731
4732 xcoff_loader_symbol_offset,
4733 xcoff_loader_reloc_offset,
4734
4735 /* glink. */
4736 &xcoff_glink_code[0],
4737 36, /* _xcoff_glink_size */
4738
4739 /* rtinit */
4740 0, /* _xcoff_rtinit_size */
4741 xcoff_generate_rtinit,
4742
4743 /* Stub indirect call. */
4744 &xcoff_stub_indirect_call_code[0],
4745 16, /* _xcoff_stub_indirect_call_size */
4746
4747 /* Stub shared call. */
4748 &xcoff_stub_shared_call_code[0],
4749 24, /* _xcoff_stub_shared_call_size */
4750 };
4751
4752 /* The transfer vector that leads the outside world to all of the above. */
4753 const bfd_target powerpc_xcoff_vec =
4754 {
4755 "xcoff-powermac",
4756 bfd_target_xcoff_flavour,
4757 BFD_ENDIAN_BIG, /* data byte order is big */
4758 BFD_ENDIAN_BIG, /* header byte order is big */
4759
4760 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
4761 | HAS_SYMS | HAS_LOCALS | WP_TEXT),
4762
4763 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
4764 0, /* leading char */
4765 '/', /* ar_pad_char */
4766 15, /* ar_max_namelen */
4767 0, /* match priority. */
4768 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */
4769
4770 /* data */
4771 bfd_getb64,
4772 bfd_getb_signed_64,
4773 bfd_putb64,
4774 bfd_getb32,
4775 bfd_getb_signed_32,
4776 bfd_putb32,
4777 bfd_getb16,
4778 bfd_getb_signed_16,
4779 bfd_putb16,
4780
4781 /* hdrs */
4782 bfd_getb64,
4783 bfd_getb_signed_64,
4784 bfd_putb64,
4785 bfd_getb32,
4786 bfd_getb_signed_32,
4787 bfd_putb32,
4788 bfd_getb16,
4789 bfd_getb_signed_16,
4790 bfd_putb16,
4791
4792 { /* bfd_check_format */
4793 _bfd_dummy_target,
4794 coff_object_p,
4795 _bfd_xcoff_archive_p,
4796 CORE_FILE_P
4797 },
4798
4799 { /* bfd_set_format */
4800 _bfd_bool_bfd_false_error,
4801 coff_mkobject,
4802 _bfd_generic_mkarchive,
4803 _bfd_bool_bfd_false_error
4804 },
4805
4806 {/* bfd_write_contents */
4807 _bfd_bool_bfd_false_error,
4808 coff_write_object_contents,
4809 _bfd_xcoff_write_archive_contents,
4810 _bfd_bool_bfd_false_error
4811 },
4812
4813 BFD_JUMP_TABLE_GENERIC (_bfd_xcoff),
4814 BFD_JUMP_TABLE_COPY (_bfd_xcoff),
4815 BFD_JUMP_TABLE_CORE (coff),
4816 BFD_JUMP_TABLE_ARCHIVE (_bfd_xcoff),
4817 BFD_JUMP_TABLE_SYMBOLS (_bfd_xcoff),
4818 BFD_JUMP_TABLE_RELOCS (_bfd_xcoff),
4819 BFD_JUMP_TABLE_WRITE (coff),
4820 BFD_JUMP_TABLE_LINK (_bfd_xcoff),
4821 BFD_JUMP_TABLE_DYNAMIC (_bfd_xcoff),
4822
4823 /* Opposite endian version, none exists */
4824 NULL,
4825
4826 & bfd_pmac_xcoff_backend_data,
4827 };