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