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