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