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