projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* coff-rs6000.c (xcoff_write_one_armap_big): New procedure.
[deliverable/binutils-gdb.git] / bfd / coff-rs6000.c
1 /* BFD back-end for IBM RS/6000 "XCOFF" files.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
4 FIXME: Can someone provide a transliteration of this name into ASCII?
5 Using the following chars caused a compiler warning on HIUX (so I replaced
6 them with octal escapes), and isn't useful without an understanding of what
7 character set it is.
8 Written by Metin G. Ozisik, Mimi Ph\373\364ng-Th\345o V\365,
9 and John Gilmore.
10 Archive support from Damon A. Permezel.
11 Contributed by IBM Corporation and Cygnus Support.
12
13 This file is part of BFD, the Binary File Descriptor library.
14
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 2 of the License, or
18 (at your option) any later version.
19
20 This program is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU General Public License for more details.
24
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28
29
30 #include "bfd.h"
31 #include "sysdep.h"
32 #include "libbfd.h"
33 #include "coff/internal.h"
34 #include "coff/rs6000.h"
35 #include "libcoff.h"
36 #define TARGET_NAME "aixcoff-rs6000"
37 #define TARGET_SYM rs6000coff_vec
38 #include "xcoff-target.h"
39
40
41 /* The main body of code is in coffcode.h. */
42
43 static const char *normalize_filename PARAMS ((bfd *));
44
45 /* We use our own tdata type. Its first field is the COFF tdata type,
46 so the COFF routines are compatible. */
47
48 boolean
49 _bfd_xcoff_mkobject (abfd)
50 bfd *abfd;
51 {
52 coff_data_type *coff;
53
54 abfd->tdata.xcoff_obj_data =
55 ((struct xcoff_tdata *)
56 bfd_zalloc (abfd, sizeof (struct xcoff_tdata)));
57 if (abfd->tdata.xcoff_obj_data == NULL)
58 return false;
59 coff = coff_data (abfd);
60 coff->symbols = (coff_symbol_type *) NULL;
61 coff->conversion_table = (unsigned int *) NULL;
62 coff->raw_syments = (struct coff_ptr_struct *) NULL;
63 coff->relocbase = 0;
64
65 xcoff_data (abfd)->modtype = ('1' << 8) | 'L';
66
67 /* We set cputype to -1 to indicate that it has not been
68 initialized. */
69 xcoff_data (abfd)->cputype = -1;
70
71 xcoff_data (abfd)->csects = NULL;
72 xcoff_data (abfd)->debug_indices = NULL;
73
74 return true;
75 }
76
77 /* Copy XCOFF data from one BFD to another. */
78
79 boolean
80 _bfd_xcoff_copy_private_bfd_data (ibfd, obfd)
81 bfd *ibfd;
82 bfd *obfd;
83 {
84 struct xcoff_tdata *ix, *ox;
85 asection *sec;
86
87 if (ibfd->xvec != obfd->xvec)
88 return true;
89 ix = xcoff_data (ibfd);
90 ox = xcoff_data (obfd);
91 ox->full_aouthdr = ix->full_aouthdr;
92 ox->toc = ix->toc;
93 if (ix->sntoc == 0)
94 ox->sntoc = 0;
95 else
96 {
97 sec = coff_section_from_bfd_index (ibfd, ix->sntoc);
98 if (sec == NULL)
99 ox->sntoc = 0;
100 else
101 ox->sntoc = sec->output_section->target_index;
102 }
103 if (ix->snentry == 0)
104 ox->snentry = 0;
105 else
106 {
107 sec = coff_section_from_bfd_index (ibfd, ix->snentry);
108 if (sec == NULL)
109 ox->snentry = 0;
110 else
111 ox->snentry = sec->output_section->target_index;
112 }
113 ox->text_align_power = ix->text_align_power;
114 ox->data_align_power = ix->data_align_power;
115 ox->modtype = ix->modtype;
116 ox->cputype = ix->cputype;
117 ox->maxdata = ix->maxdata;
118 ox->maxstack = ix->maxstack;
119 return true;
120 }
121
122 /* I don't think XCOFF really has a notion of local labels based on
123 name. This will mean that ld -X doesn't actually strip anything.
124 The AIX native linker does not have a -X option, and it ignores the
125 -x option. */
126
127 boolean
128 _bfd_xcoff_is_local_label_name (abfd, name)
129 bfd *abfd ATTRIBUTE_UNUSED;
130 const char *name ATTRIBUTE_UNUSED;
131 {
132 return false;
133 }
134 \f
135
136
137 void
138 _bfd_xcoff_swap_sym_in (abfd, ext1, in1)
139 bfd *abfd;
140 PTR ext1;
141 PTR in1;
142 {
143 SYMENT *ext = (SYMENT *)ext1;
144 struct internal_syment *in = (struct internal_syment *)in1;
145
146
147 if(ext->e.e_name[0] != 0)
148 {
149 memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN);
150 }
151 else
152 {
153 in->_n._n_n._n_zeroes = 0;
154 in->_n._n_n._n_offset =
155 bfd_h_get_32(abfd, (bfd_byte *) ext->e.e.e_offset);
156 }
157
158 in->n_value = bfd_h_get_32(abfd, (bfd_byte *) ext->e_value);
159 in->n_scnum = bfd_h_get_16(abfd, (bfd_byte *) ext->e_scnum);
160 in->n_type = bfd_h_get_16(abfd, (bfd_byte *) ext->e_type);
161 in->n_sclass = bfd_h_get_8(abfd, ext->e_sclass);
162 in->n_numaux = bfd_h_get_8(abfd, ext->e_numaux);
163 }
164
165 unsigned int
166 _bfd_xcoff_swap_sym_out (abfd, inp, extp)
167 bfd *abfd;
168 PTR inp;
169 PTR extp;
170 {
171 struct internal_syment *in = (struct internal_syment *)inp;
172 SYMENT *ext =(SYMENT *)extp;
173
174 if(in->_n._n_name[0] != 0)
175 {
176 memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN);
177 }
178 else
179 {
180 bfd_h_put_32(abfd, 0, (bfd_byte *) ext->e.e.e_zeroes);
181 bfd_h_put_32(abfd, in->_n._n_n._n_offset,
182 (bfd_byte *) ext->e.e.e_offset);
183 }
184
185 bfd_h_put_32(abfd, in->n_value , (bfd_byte *) ext->e_value);
186 bfd_h_put_16(abfd, in->n_scnum , (bfd_byte *) ext->e_scnum);
187 bfd_h_put_16(abfd, in->n_type , (bfd_byte *) ext->e_type);
188 bfd_h_put_8(abfd, in->n_sclass , ext->e_sclass);
189 bfd_h_put_8(abfd, in->n_numaux , ext->e_numaux);
190 return bfd_coff_symesz (abfd);
191 }
192
193 #define PUTWORD bfd_h_put_32
194 #define PUTHALF bfd_h_put_16
195 #define PUTBYTE bfd_h_put_8
196 #define GETWORD bfd_h_get_32
197 #define GETHALF bfd_h_get_16
198 #define GETBYTE bfd_h_get_8
199
200 void
201 _bfd_xcoff_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
202 bfd *abfd;
203 PTR ext1;
204 int type;
205 int class;
206 int indx;
207 int numaux;
208 PTR in1;
209 {
210 AUXENT *ext = (AUXENT *)ext1;
211 union internal_auxent *in = (union internal_auxent *)in1;
212
213 switch (class) {
214 case C_FILE:
215 if (ext->x_file.x_fname[0] == 0) {
216 in->x_file.x_n.x_zeroes = 0;
217 in->x_file.x_n.x_offset =
218 bfd_h_get_32(abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
219 } else {
220 if (numaux > 1)
221 {
222 if (indx == 0)
223 memcpy (in->x_file.x_fname, ext->x_file.x_fname,
224 numaux * sizeof (AUXENT));
225 }
226 else
227 {
228 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
229 }
230 }
231 goto end;
232
233 /* RS/6000 "csect" auxents */
234 case C_EXT:
235 case C_HIDEXT:
236 if (indx + 1 == numaux)
237 {
238 in->x_csect.x_scnlen.l =
239 bfd_h_get_32 (abfd, ext->x_csect.x_scnlen);
240 in->x_csect.x_parmhash = bfd_h_get_32 (abfd,
241 ext->x_csect.x_parmhash);
242 in->x_csect.x_snhash = bfd_h_get_16 (abfd, ext->x_csect.x_snhash);
243 /* We don't have to hack bitfields in x_smtyp because it's
244 defined by shifts-and-ands, which are equivalent on all
245 byte orders. */
246 in->x_csect.x_smtyp = bfd_h_get_8 (abfd, ext->x_csect.x_smtyp);
247 in->x_csect.x_smclas = bfd_h_get_8 (abfd, ext->x_csect.x_smclas);
248 in->x_csect.x_stab = bfd_h_get_32 (abfd, ext->x_csect.x_stab);
249 in->x_csect.x_snstab = bfd_h_get_16 (abfd, ext->x_csect.x_snstab);
250 goto end;
251 }
252 break;
253
254 case C_STAT:
255 case C_LEAFSTAT:
256 case C_HIDDEN:
257 if (type == T_NULL) {
258 in->x_scn.x_scnlen = bfd_h_get_32(abfd,
259 (bfd_byte *) ext->x_scn.x_scnlen);
260 in->x_scn.x_nreloc = bfd_h_get_16(abfd,
261 (bfd_byte *) ext->x_scn.x_nreloc);
262 in->x_scn.x_nlinno = bfd_h_get_16(abfd,
263 (bfd_byte *) ext->x_scn.x_nlinno);
264 /* PE defines some extra fields; we zero them out for
265 safety. */
266 in->x_scn.x_checksum = 0;
267 in->x_scn.x_associated = 0;
268 in->x_scn.x_comdat = 0;
269
270 goto end;
271 }
272 break;
273 }
274
275 in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_tagndx);
276 in->x_sym.x_tvndx = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_tvndx);
277
278 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
279 {
280 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = bfd_h_get_32(abfd, (bfd_byte *)
281 ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
282 in->x_sym.x_fcnary.x_fcn.x_endndx.l = bfd_h_get_32(abfd, (bfd_byte *)
283 ext->x_sym.x_fcnary.x_fcn.x_endndx);
284 }
285 else
286 {
287 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
288 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
289 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
290 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
291 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
292 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
293 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
294 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
295 }
296 if (ISFCN(type)) {
297 in->x_sym.x_misc.x_fsize = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
298 }
299 else {
300 in->x_sym.x_misc.x_lnsz.x_lnno = bfd_h_get_16(abfd, (bfd_byte *)
301 ext->x_sym.x_misc.x_lnsz.x_lnno);
302 in->x_sym.x_misc.x_lnsz.x_size = bfd_h_get_16(abfd, (bfd_byte *)
303 ext->x_sym.x_misc.x_lnsz.x_size);
304 }
305
306 end: ;
307 /* the semicolon is because MSVC doesn't like labels at
308 end of block. */
309
310 }
311
312
313
314 unsigned int
315 _bfd_xcoff_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
316 bfd *abfd;
317 PTR inp;
318 int type;
319 int class;
320 int indx ATTRIBUTE_UNUSED;
321 int numaux ATTRIBUTE_UNUSED;
322 PTR extp;
323 {
324 union internal_auxent *in = (union internal_auxent *)inp;
325 AUXENT *ext = (AUXENT *)extp;
326
327 memset((PTR)ext, 0, bfd_coff_auxesz (abfd));
328 switch (class)
329 {
330 case C_FILE:
331 if (in->x_file.x_fname[0] == 0)
332 {
333 PUTWORD(abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes);
334 PUTWORD(abfd,
335 in->x_file.x_n.x_offset,
336 (bfd_byte *) ext->x_file.x_n.x_offset);
337 }
338 else
339 {
340 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
341 }
342 goto end;
343
344 /* RS/6000 "csect" auxents */
345 case C_EXT:
346 case C_HIDEXT:
347 if (indx + 1 == numaux)
348 {
349 PUTWORD (abfd, in->x_csect.x_scnlen.l,ext->x_csect.x_scnlen);
350 PUTWORD (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash);
351 PUTHALF (abfd, in->x_csect.x_snhash, ext->x_csect.x_snhash);
352 /* We don't have to hack bitfields in x_smtyp because it's
353 defined by shifts-and-ands, which are equivalent on all
354 byte orders. */
355 PUTBYTE (abfd, in->x_csect.x_smtyp, ext->x_csect.x_smtyp);
356 PUTBYTE (abfd, in->x_csect.x_smclas, ext->x_csect.x_smclas);
357 PUTWORD (abfd, in->x_csect.x_stab, ext->x_csect.x_stab);
358 PUTHALF (abfd, in->x_csect.x_snstab, ext->x_csect.x_snstab);
359 goto end;
360 }
361 break;
362
363 case C_STAT:
364 case C_LEAFSTAT:
365 case C_HIDDEN:
366 if (type == T_NULL) {
367 bfd_h_put_32(abfd, in->x_scn.x_scnlen, (bfd_byte *) ext->x_scn.x_scnlen);
368 bfd_h_put_16(abfd, in->x_scn.x_nreloc, (bfd_byte *) ext->x_scn.x_nreloc);
369 bfd_h_put_16(abfd, in->x_scn.x_nlinno, (bfd_byte *) ext->x_scn.x_nlinno);
370 goto end;
371 }
372 break;
373 }
374
375 PUTWORD(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
376 PUTWORD(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx);
377
378 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
379 {
380 bfd_h_put_32(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,
381 (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
382 PUTWORD(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l,
383 (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx);
384 }
385 else
386 {
387 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
388 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
389 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
390 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
391 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
392 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
393 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
394 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
395 }
396
397 if (ISFCN (type))
398 PUTWORD (abfd, in->x_sym.x_misc.x_fsize,
399 (bfd_byte *) ext->x_sym.x_misc.x_fsize);
400 else
401 {
402 bfd_h_put_16(abfd, in->x_sym.x_misc.x_lnsz.x_lnno,
403 (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno);
404 bfd_h_put_16(abfd, in->x_sym.x_misc.x_lnsz.x_size,
405 (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_size);
406 }
407
408 end:
409 return bfd_coff_auxesz (abfd);
410 }
411
412
413 \f
414 /* The XCOFF reloc table. Actually, XCOFF relocations specify the
415 bitsize and whether they are signed or not, along with a
416 conventional type. This table is for the types, which are used for
417 different algorithms for putting in the reloc. Many of these
418 relocs need special_function entries, which I have not written. */
419
420 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
421 from smaller values. Start with zero, widen, *then* decrement. */
422 #define MINUS_ONE (((bfd_vma)0) - 1)
423
424 reloc_howto_type xcoff_howto_table[] =
425 {
426 /* Standard 32 bit relocation. */
427 HOWTO (0, /* type */
428 0, /* rightshift */
429 2, /* size (0 = byte, 1 = short, 2 = long) */
430 32, /* bitsize */
431 false, /* pc_relative */
432 0, /* bitpos */
433 complain_overflow_bitfield, /* complain_on_overflow */
434 0, /* special_function */
435 "R_POS", /* name */
436 true, /* partial_inplace */
437 0xffffffff, /* src_mask */
438 0xffffffff, /* dst_mask */
439 false), /* pcrel_offset */
440
441 /* 32 bit relocation, but store negative value. */
442 HOWTO (1, /* type */
443 0, /* rightshift */
444 -2, /* size (0 = byte, 1 = short, 2 = long) */
445 32, /* bitsize */
446 false, /* pc_relative */
447 0, /* bitpos */
448 complain_overflow_bitfield, /* complain_on_overflow */
449 0, /* special_function */
450 "R_NEG", /* name */
451 true, /* partial_inplace */
452 0xffffffff, /* src_mask */
453 0xffffffff, /* dst_mask */
454 false), /* pcrel_offset */
455
456 /* 32 bit PC relative relocation. */
457 HOWTO (2, /* type */
458 0, /* rightshift */
459 2, /* size (0 = byte, 1 = short, 2 = long) */
460 32, /* bitsize */
461 true, /* pc_relative */
462 0, /* bitpos */
463 complain_overflow_signed, /* complain_on_overflow */
464 0, /* special_function */
465 "R_REL", /* name */
466 true, /* partial_inplace */
467 0xffffffff, /* src_mask */
468 0xffffffff, /* dst_mask */
469 false), /* pcrel_offset */
470
471 /* 16 bit TOC relative relocation. */
472 HOWTO (3, /* type */
473 0, /* rightshift */
474 1, /* size (0 = byte, 1 = short, 2 = long) */
475 16, /* bitsize */
476 false, /* pc_relative */
477 0, /* bitpos */
478 complain_overflow_bitfield, /* complain_on_overflow */
479 0, /* special_function */
480 "R_TOC", /* name */
481 true, /* partial_inplace */
482 0xffff, /* src_mask */
483 0xffff, /* dst_mask */
484 false), /* pcrel_offset */
485
486 /* I don't really know what this is. */
487 HOWTO (4, /* type */
488 1, /* rightshift */
489 2, /* size (0 = byte, 1 = short, 2 = long) */
490 32, /* bitsize */
491 false, /* pc_relative */
492 0, /* bitpos */
493 complain_overflow_bitfield, /* complain_on_overflow */
494 0, /* special_function */
495 "R_RTB", /* name */
496 true, /* partial_inplace */
497 0xffffffff, /* src_mask */
498 0xffffffff, /* dst_mask */
499 false), /* pcrel_offset */
500
501 /* External TOC relative symbol. */
502 HOWTO (5, /* type */
503 0, /* rightshift */
504 2, /* size (0 = byte, 1 = short, 2 = long) */
505 16, /* bitsize */
506 false, /* pc_relative */
507 0, /* bitpos */
508 complain_overflow_bitfield, /* complain_on_overflow */
509 0, /* special_function */
510 "R_GL", /* name */
511 true, /* partial_inplace */
512 0xffff, /* src_mask */
513 0xffff, /* dst_mask */
514 false), /* pcrel_offset */
515
516 /* Local TOC relative symbol. */
517 HOWTO (6, /* type */
518 0, /* rightshift */
519 2, /* size (0 = byte, 1 = short, 2 = long) */
520 16, /* bitsize */
521 false, /* pc_relative */
522 0, /* bitpos */
523 complain_overflow_bitfield, /* complain_on_overflow */
524 0, /* special_function */
525 "R_TCL", /* name */
526 true, /* partial_inplace */
527 0xffff, /* src_mask */
528 0xffff, /* dst_mask */
529 false), /* pcrel_offset */
530
531 EMPTY_HOWTO (7),
532
533 /* Non modifiable absolute branch. */
534 HOWTO (8, /* type */
535 0, /* rightshift */
536 2, /* size (0 = byte, 1 = short, 2 = long) */
537 26, /* bitsize */
538 false, /* pc_relative */
539 0, /* bitpos */
540 complain_overflow_bitfield, /* complain_on_overflow */
541 0, /* special_function */
542 "R_BA", /* name */
543 true, /* partial_inplace */
544 0x3fffffc, /* src_mask */
545 0x3fffffc, /* dst_mask */
546 false), /* pcrel_offset */
547
548 EMPTY_HOWTO (9),
549
550 /* Non modifiable relative branch. */
551 HOWTO (0xa, /* type */
552 0, /* rightshift */
553 2, /* size (0 = byte, 1 = short, 2 = long) */
554 26, /* bitsize */
555 true, /* pc_relative */
556 0, /* bitpos */
557 complain_overflow_signed, /* complain_on_overflow */
558 0, /* special_function */
559 "R_BR", /* name */
560 true, /* partial_inplace */
561 0x3fffffc, /* src_mask */
562 0x3fffffc, /* dst_mask */
563 false), /* pcrel_offset */
564
565 EMPTY_HOWTO (0xb),
566
567 /* Indirect load. */
568 HOWTO (0xc, /* type */
569 0, /* rightshift */
570 2, /* size (0 = byte, 1 = short, 2 = long) */
571 16, /* bitsize */
572 false, /* pc_relative */
573 0, /* bitpos */
574 complain_overflow_bitfield, /* complain_on_overflow */
575 0, /* special_function */
576 "R_RL", /* name */
577 true, /* partial_inplace */
578 0xffff, /* src_mask */
579 0xffff, /* dst_mask */
580 false), /* pcrel_offset */
581
582 /* Load address. */
583 HOWTO (0xd, /* type */
584 0, /* rightshift */
585 2, /* size (0 = byte, 1 = short, 2 = long) */
586 16, /* bitsize */
587 false, /* pc_relative */
588 0, /* bitpos */
589 complain_overflow_bitfield, /* complain_on_overflow */
590 0, /* special_function */
591 "R_RLA", /* name */
592 true, /* partial_inplace */
593 0xffff, /* src_mask */
594 0xffff, /* dst_mask */
595 false), /* pcrel_offset */
596
597 EMPTY_HOWTO (0xe),
598
599 /* Non-relocating reference. */
600 HOWTO (0xf, /* type */
601 0, /* rightshift */
602 2, /* size (0 = byte, 1 = short, 2 = long) */
603 32, /* bitsize */
604 false, /* pc_relative */
605 0, /* bitpos */
606 complain_overflow_bitfield, /* complain_on_overflow */
607 0, /* special_function */
608 "R_REF", /* name */
609 false, /* partial_inplace */
610 0, /* src_mask */
611 0, /* dst_mask */
612 false), /* pcrel_offset */
613
614 EMPTY_HOWTO (0x10),
615 EMPTY_HOWTO (0x11),
616
617 /* TOC relative indirect load. */
618 HOWTO (0x12, /* type */
619 0, /* rightshift */
620 2, /* size (0 = byte, 1 = short, 2 = long) */
621 16, /* bitsize */
622 false, /* pc_relative */
623 0, /* bitpos */
624 complain_overflow_bitfield, /* complain_on_overflow */
625 0, /* special_function */
626 "R_TRL", /* name */
627 true, /* partial_inplace */
628 0xffff, /* src_mask */
629 0xffff, /* dst_mask */
630 false), /* pcrel_offset */
631
632 /* TOC relative load address. */
633 HOWTO (0x13, /* type */
634 0, /* rightshift */
635 2, /* size (0 = byte, 1 = short, 2 = long) */
636 16, /* bitsize */
637 false, /* pc_relative */
638 0, /* bitpos */
639 complain_overflow_bitfield, /* complain_on_overflow */
640 0, /* special_function */
641 "R_TRLA", /* name */
642 true, /* partial_inplace */
643 0xffff, /* src_mask */
644 0xffff, /* dst_mask */
645 false), /* pcrel_offset */
646
647 /* Modifiable relative branch. */
648 HOWTO (0x14, /* type */
649 1, /* rightshift */
650 2, /* size (0 = byte, 1 = short, 2 = long) */
651 32, /* bitsize */
652 false, /* pc_relative */
653 0, /* bitpos */
654 complain_overflow_bitfield, /* complain_on_overflow */
655 0, /* special_function */
656 "R_RRTBI", /* name */
657 true, /* partial_inplace */
658 0xffffffff, /* src_mask */
659 0xffffffff, /* dst_mask */
660 false), /* pcrel_offset */
661
662 /* Modifiable absolute branch. */
663 HOWTO (0x15, /* type */
664 1, /* rightshift */
665 2, /* size (0 = byte, 1 = short, 2 = long) */
666 32, /* bitsize */
667 false, /* pc_relative */
668 0, /* bitpos */
669 complain_overflow_bitfield, /* complain_on_overflow */
670 0, /* special_function */
671 "R_RRTBA", /* name */
672 true, /* partial_inplace */
673 0xffffffff, /* src_mask */
674 0xffffffff, /* dst_mask */
675 false), /* pcrel_offset */
676
677 /* Modifiable call absolute indirect. */
678 HOWTO (0x16, /* type */
679 0, /* rightshift */
680 2, /* size (0 = byte, 1 = short, 2 = long) */
681 16, /* bitsize */
682 false, /* pc_relative */
683 0, /* bitpos */
684 complain_overflow_bitfield, /* complain_on_overflow */
685 0, /* special_function */
686 "R_CAI", /* name */
687 true, /* partial_inplace */
688 0xffff, /* src_mask */
689 0xffff, /* dst_mask */
690 false), /* pcrel_offset */
691
692 /* Modifiable call relative. */
693 HOWTO (0x17, /* type */
694 0, /* rightshift */
695 2, /* size (0 = byte, 1 = short, 2 = long) */
696 16, /* bitsize */
697 false, /* pc_relative */
698 0, /* bitpos */
699 complain_overflow_bitfield, /* complain_on_overflow */
700 0, /* special_function */
701 "R_CREL", /* name */
702 true, /* partial_inplace */
703 0xffff, /* src_mask */
704 0xffff, /* dst_mask */
705 false), /* pcrel_offset */
706
707 /* Modifiable branch absolute. */
708 HOWTO (0x18, /* type */
709 0, /* rightshift */
710 2, /* size (0 = byte, 1 = short, 2 = long) */
711 16, /* bitsize */
712 false, /* pc_relative */
713 0, /* bitpos */
714 complain_overflow_bitfield, /* complain_on_overflow */
715 0, /* special_function */
716 "R_RBA", /* name */
717 true, /* partial_inplace */
718 0xffff, /* src_mask */
719 0xffff, /* dst_mask */
720 false), /* pcrel_offset */
721
722 /* Modifiable branch absolute. */
723 HOWTO (0x19, /* type */
724 0, /* rightshift */
725 2, /* size (0 = byte, 1 = short, 2 = long) */
726 16, /* bitsize */
727 false, /* pc_relative */
728 0, /* bitpos */
729 complain_overflow_bitfield, /* complain_on_overflow */
730 0, /* special_function */
731 "R_RBAC", /* name */
732 true, /* partial_inplace */
733 0xffff, /* src_mask */
734 0xffff, /* dst_mask */
735 false), /* pcrel_offset */
736
737 /* Modifiable branch relative. */
738 HOWTO (0x1a, /* type */
739 0, /* rightshift */
740 2, /* size (0 = byte, 1 = short, 2 = long) */
741 26, /* bitsize */
742 false, /* pc_relative */
743 0, /* bitpos */
744 complain_overflow_signed, /* complain_on_overflow */
745 0, /* special_function */
746 "R_RBR", /* name */
747 true, /* partial_inplace */
748 0xffff, /* src_mask */
749 0xffff, /* dst_mask */
750 false), /* pcrel_offset */
751
752 /* Modifiable branch absolute. */
753 HOWTO (0x1b, /* type */
754 0, /* rightshift */
755 2, /* size (0 = byte, 1 = short, 2 = long) */
756 16, /* bitsize */
757 false, /* pc_relative */
758 0, /* bitpos */
759 complain_overflow_bitfield, /* complain_on_overflow */
760 0, /* special_function */
761 "R_RBRC", /* name */
762 true, /* partial_inplace */
763 0xffff, /* src_mask */
764 0xffff, /* dst_mask */
765 false), /* pcrel_offset */
766 HOWTO (0, /* type */
767 0, /* rightshift */
768 4, /* size (0 = byte, 1 = short, 2 = long) */
769 64, /* bitsize */
770 false, /* pc_relative */
771 0, /* bitpos */
772 complain_overflow_bitfield, /* complain_on_overflow */
773 0, /* special_function */
774 "R_POS", /* name */
775 true, /* partial_inplace */
776 MINUS_ONE, /* src_mask */
777 MINUS_ONE, /* dst_mask */
778 false) /* pcrel_offset */
779
780 };
781
782 /* These are the first two like the above but for 16-bit relocs. */
783 static reloc_howto_type xcoff_howto_table_16[] =
784 {
785 /* Standard 16 bit relocation. */
786 HOWTO (0, /* type */
787 0, /* rightshift */
788 2, /* size (0 = byte, 1 = short, 2 = long) */
789 16, /* bitsize */
790 false, /* pc_relative */
791 0, /* bitpos */
792 complain_overflow_bitfield, /* complain_on_overflow */
793 0, /* special_function */
794 "R_POS_16", /* name */
795 true, /* partial_inplace */
796 0xffffffff, /* src_mask */
797 0xffffffff, /* dst_mask */
798 false), /* pcrel_offset */
799
800 /* 16 bit relocation, but store negative value. */
801 HOWTO (1, /* type */
802 0, /* rightshift */
803 -2, /* size (0 = byte, 1 = short, 2 = long) */
804 16, /* bitsize */
805 false, /* pc_relative */
806 0, /* bitpos */
807 complain_overflow_bitfield, /* complain_on_overflow */
808 0, /* special_function */
809 "R_NEG_16", /* name */
810 true, /* partial_inplace */
811 0xffffffff, /* src_mask */
812 0xffffffff, /* dst_mask */
813 false), /* pcrel_offset */
814
815 /* 16 bit PC relative relocation. */
816 HOWTO (2, /* type */
817 0, /* rightshift */
818 2, /* size (0 = byte, 1 = short, 2 = long) */
819 32, /* bitsize */
820 true, /* pc_relative */
821 0, /* bitpos */
822 complain_overflow_signed, /* complain_on_overflow */
823 0, /* special_function */
824 "R_REL_16", /* name */
825 true, /* partial_inplace */
826 0xffffffff, /* src_mask */
827 0xffffffff, /* dst_mask */
828 false) /* pcrel_offset */
829 };
830
831 void
832 _bfd_xcoff_rtype2howto (relent, internal)
833 arelent *relent;
834 struct internal_reloc *internal;
835 {
836 relent->howto = xcoff_howto_table + internal->r_type;
837
838 if (relent->howto->bitsize != ((unsigned int) internal->r_size & 0x1f) + 1
839 && (internal->r_type
840 < sizeof(xcoff_howto_table_16)/sizeof(xcoff_howto_table_16[0])))
841 relent->howto = xcoff_howto_table_16 + internal->r_type;
842
843 /* The r_size field of an XCOFF reloc encodes the bitsize of the
844 relocation, as well as indicating whether it is signed or not.
845 Doublecheck that the relocation information gathered from the
846 type matches this information. */
847 if (relent->howto->bitsize != ((unsigned int) internal->r_size & 0x1f) + 1)
848 abort ();
849 #if 0
850 if ((internal->r_size & 0x80) != 0
851 ? (relent->howto->complain_on_overflow != complain_overflow_signed)
852 : (relent->howto->complain_on_overflow != complain_overflow_bitfield))
853 abort ();
854 #endif
855 }
856
857 reloc_howto_type *
858 _bfd_xcoff_reloc_type_lookup (abfd, code)
859 bfd *abfd ATTRIBUTE_UNUSED;
860 bfd_reloc_code_real_type code;
861 {
862 switch (code)
863 {
864 case BFD_RELOC_PPC_B26:
865 return &xcoff_howto_table[0xa];
866 case BFD_RELOC_PPC_BA26:
867 return &xcoff_howto_table[8];
868 case BFD_RELOC_PPC_TOC16:
869 return &xcoff_howto_table[3];
870 case BFD_RELOC_32:
871 case BFD_RELOC_CTOR:
872 return &xcoff_howto_table[0];
873 case BFD_RELOC_64:
874 return &xcoff_howto_table[0x1c];
875 default:
876 return NULL;
877 }
878 }
879
880 \f
881 /* XCOFF archive support. The original version of this code was by
882 Damon A. Permezel. It was enhanced to permit cross support, and
883 writing archive files, by Ian Lance Taylor, Cygnus Support.
884
885 XCOFF uses its own archive format. Everything is hooked together
886 with file offset links, so it is possible to rapidly update an
887 archive in place. Of course, we don't do that. An XCOFF archive
888 has a real file header, not just an ARMAG string. The structure of
889 the file header and of each archive header appear below.
890
891 An XCOFF archive also has a member table, which is a list of
892 elements in the archive (you can get that by looking through the
893 linked list, but you have to read a lot more of the file). The
894 member table has a normal archive header with an empty name. It is
895 normally (and perhaps must be) the second to last entry in the
896 archive. The member table data is almost printable ASCII. It
897 starts with a 12 character decimal string which is the number of
898 entries in the table. For each entry it has a 12 character decimal
899 string which is the offset in the archive of that member. These
900 entries are followed by a series of null terminated strings which
901 are the member names for each entry.
902
903 Finally, an XCOFF archive has a global symbol table, which is what
904 we call the armap. The global symbol table has a normal archive
905 header with an empty name. It is normally (and perhaps must be)
906 the last entry in the archive. The contents start with a four byte
907 binary number which is the number of entries. This is followed by
908 a that many four byte binary numbers; each is the file offset of an
909 entry in the archive. These numbers are followed by a series of
910 null terminated strings, which are symbol names.
911
912 AIX 4.3 introduced a new archive format which can handle larger
913 files and also 32- and 64-bit objects in the same archive. The
914 things said above remain true except that there is now more than
915 one global symbol table. The one is used to index 32-bit objects,
916 the other for 64-bit objects.
917
918 The new archives (recognizable by the new ARMAG string) has larger
919 field lengths so that we cannot really share any code. Also we have
920 to take care that we are not generating the new form of archives
921 on AIX 4.2 or earlier systems. */
922
923 /* XCOFF archives use this as a magic string. Note that both strings
924 have the same length. */
925
926 #define XCOFFARMAG "<aiaff>\012"
927 #define XCOFFARMAGBIG "<bigaf>\012"
928 #define SXCOFFARMAG 8
929
930 /* This terminates an XCOFF archive member name. */
931
932 #define XCOFFARFMAG "`\012"
933 #define SXCOFFARFMAG 2
934
935 /* XCOFF archives start with this (printable) structure. */
936
937 struct xcoff_ar_file_hdr
938 {
939 /* Magic string. */
940 char magic[SXCOFFARMAG];
941
942 /* Offset of the member table (decimal ASCII string). */
943 char memoff[12];
944
945 /* Offset of the global symbol table (decimal ASCII string). */
946 char symoff[12];
947
948 /* Offset of the first member in the archive (decimal ASCII string). */
949 char firstmemoff[12];
950
951 /* Offset of the last member in the archive (decimal ASCII string). */
952 char lastmemoff[12];
953
954 /* Offset of the first member on the free list (decimal ASCII
955 string). */
956 char freeoff[12];
957 };
958
959 #define SIZEOF_AR_FILE_HDR (5 * 12 + SXCOFFARMAG)
960
961 /* This is the equivalent data structure for the big archive format. */
962
963 struct xcoff_ar_file_hdr_big
964 {
965 /* Magic string. */
966 char magic[SXCOFFARMAG];
967
968 /* Offset of the member table (decimal ASCII string). */
969 char memoff[20];
970
971 /* Offset of the global symbol table for 32-bit objects (decimal ASCII
972 string). */
973 char symoff[20];
974
975 /* Offset of the global symbol table for 64-bit objects (decimal ASCII
976 string). */
977 char symoff64[20];
978
979 /* Offset of the first member in the archive (decimal ASCII string). */
980 char firstmemoff[20];
981
982 /* Offset of the last member in the archive (decimal ASCII string). */
983 char lastmemoff[20];
984
985 /* Offset of the first member on the free list (decimal ASCII
986 string). */
987 char freeoff[20];
988 };
989
990 #define SIZEOF_AR_FILE_HDR_BIG (6 * 20 + SXCOFFARMAG)
991
992
993 /* Each XCOFF archive member starts with this (printable) structure. */
994
995 struct xcoff_ar_hdr
996 {
997 /* File size not including the header (decimal ASCII string). */
998 char size[12];
999
1000 /* File offset of next archive member (decimal ASCII string). */
1001 char nextoff[12];
1002
1003 /* File offset of previous archive member (decimal ASCII string). */
1004 char prevoff[12];
1005
1006 /* File mtime (decimal ASCII string). */
1007 char date[12];
1008
1009 /* File UID (decimal ASCII string). */
1010 char uid[12];
1011
1012 /* File GID (decimal ASCII string). */
1013 char gid[12];
1014
1015 /* File mode (octal ASCII string). */
1016 char mode[12];
1017
1018 /* Length of file name (decimal ASCII string). */
1019 char namlen[4];
1020
1021 /* This structure is followed by the file name. The length of the
1022 name is given in the namlen field. If the length of the name is
1023 odd, the name is followed by a null byte. The name and optional
1024 null byte are followed by XCOFFARFMAG, which is not included in
1025 namlen. The contents of the archive member follow; the number of
1026 bytes is given in the size field. */
1027 };
1028
1029 #define SIZEOF_AR_HDR (7 * 12 + 4)
1030
1031 /* The equivalent for the big archive format. */
1032
1033 struct xcoff_ar_hdr_big
1034 {
1035 /* File size not including the header (decimal ASCII string). */
1036 char size[20];
1037
1038 /* File offset of next archive member (decimal ASCII string). */
1039 char nextoff[20];
1040
1041 /* File offset of previous archive member (decimal ASCII string). */
1042 char prevoff[20];
1043
1044 /* File mtime (decimal ASCII string). */
1045 char date[12];
1046
1047 /* File UID (decimal ASCII string). */
1048 char uid[12];
1049
1050 /* File GID (decimal ASCII string). */
1051 char gid[12];
1052
1053 /* File mode (octal ASCII string). */
1054 char mode[12];
1055
1056 /* Length of file name (decimal ASCII string). */
1057 char namlen[4];
1058
1059 /* This structure is followed by the file name. The length of the
1060 name is given in the namlen field. If the length of the name is
1061 odd, the name is followed by a null byte. The name and optional
1062 null byte are followed by XCOFFARFMAG, which is not included in
1063 namlen. The contents of the archive member follow; the number of
1064 bytes is given in the size field. */
1065 };
1066
1067 #define SIZEOF_AR_HDR_BIG (3 * 20 + 4 * 12 + 4)
1068
1069
1070 /* We often have to distinguish between the old and big file format.
1071 Make it a bit cleaner. We can use `xcoff_ardata' here because the
1072 `hdr' member has the same size and position in both formats. */
1073 #define xcoff_big_format_p(abfd) \
1074 (xcoff_ardata (abfd)->magic[1] == 'b')
1075
1076 /* We store a copy of the xcoff_ar_file_hdr in the tdata field of the
1077 artdata structure. Similar for the big archive. */
1078 #define xcoff_ardata(abfd) \
1079 ((struct xcoff_ar_file_hdr *) bfd_ardata (abfd)->tdata)
1080 #define xcoff_ardata_big(abfd) \
1081 ((struct xcoff_ar_file_hdr_big *) bfd_ardata (abfd)->tdata)
1082
1083 /* We store a copy of the xcoff_ar_hdr in the arelt_data field of an
1084 archive element. Similar for the big archive. */
1085 #define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
1086 #define arch_xhdr(bfd) \
1087 ((struct xcoff_ar_hdr *) arch_eltdata (bfd)->arch_header)
1088 #define arch_xhdr_big(bfd) \
1089 ((struct xcoff_ar_hdr_big *) arch_eltdata (bfd)->arch_header)
1090
1091 /* Read in the armap of an XCOFF archive. */
1092
1093 boolean
1094 _bfd_xcoff_slurp_armap (abfd)
1095 bfd *abfd;
1096 {
1097 file_ptr off;
1098 size_t namlen;
1099 bfd_size_type sz;
1100 bfd_byte *contents, *cend;
1101 unsigned int c, i;
1102 carsym *arsym;
1103 bfd_byte *p;
1104
1105 if (xcoff_ardata (abfd) == NULL)
1106 {
1107 bfd_has_map (abfd) = false;
1108 return true;
1109 }
1110
1111 if (! xcoff_big_format_p (abfd))
1112 {
1113 /* This is for the old format. */
1114 struct xcoff_ar_hdr hdr;
1115
1116 off = strtol (xcoff_ardata (abfd)->symoff, (char **) NULL, 10);
1117 if (off == 0)
1118 {
1119 bfd_has_map (abfd) = false;
1120 return true;
1121 }
1122
1123 if (bfd_seek (abfd, off, SEEK_SET) != 0)
1124 return false;
1125
1126 /* The symbol table starts with a normal archive header. */
1127 if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR, 1, abfd) != SIZEOF_AR_HDR)
1128 return false;
1129
1130 /* Skip the name (normally empty). */
1131 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1132 if (bfd_seek (abfd, ((namlen + 1) & ~1) + SXCOFFARFMAG, SEEK_CUR) != 0)
1133 return false;
1134
1135 sz = strtol (hdr.size, (char **) NULL, 10);
1136 }
1137 else
1138 {
1139 /* This is for the new format. */
1140 struct xcoff_ar_hdr_big hdr;
1141
1142 off = strtol (xcoff_ardata_big (abfd)->symoff, (char **) NULL, 10);
1143 if (off == 0)
1144 {
1145 bfd_has_map (abfd) = false;
1146 return true;
1147 }
1148
1149 if (bfd_seek (abfd, off, SEEK_SET) != 0)
1150 return false;
1151
1152 /* The symbol table starts with a normal archive header. */
1153 if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR_BIG, 1, abfd)
1154 != SIZEOF_AR_HDR_BIG)
1155 return false;
1156
1157 /* Skip the name (normally empty). */
1158 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1159 if (bfd_seek (abfd, ((namlen + 1) & ~1) + SXCOFFARFMAG, SEEK_CUR) != 0)
1160 return false;
1161
1162 /* XXX This actually has to be a call to strtoll (at least on 32-bit
1163 machines) since the field width is 20 and there numbers with more
1164 than 32 bits can be represented. */
1165 sz = strtol (hdr.size, (char **) NULL, 10);
1166 }
1167
1168 /* Read in the entire symbol table. */
1169 contents = (bfd_byte *) bfd_alloc (abfd, sz);
1170 if (contents == NULL)
1171 return false;
1172 if (bfd_read ((PTR) contents, 1, sz, abfd) != sz)
1173 return false;
1174
1175 /* The symbol table starts with a four byte count. */
1176 c = bfd_h_get_32 (abfd, contents);
1177
1178 if (c * 4 >= sz)
1179 {
1180 bfd_set_error (bfd_error_bad_value);
1181 return false;
1182 }
1183
1184 bfd_ardata (abfd)->symdefs = ((carsym *)
1185 bfd_alloc (abfd, c * sizeof (carsym)));
1186 if (bfd_ardata (abfd)->symdefs == NULL)
1187 return false;
1188
1189 /* After the count comes a list of four byte file offsets. */
1190 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 4;
1191 i < c;
1192 ++i, ++arsym, p += 4)
1193 arsym->file_offset = bfd_h_get_32 (abfd, p);
1194
1195 /* After the file offsets come null terminated symbol names. */
1196 cend = contents + sz;
1197 for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
1198 i < c;
1199 ++i, ++arsym, p += strlen ((char *) p) + 1)
1200 {
1201 if (p >= cend)
1202 {
1203 bfd_set_error (bfd_error_bad_value);
1204 return false;
1205 }
1206 arsym->name = (char *) p;
1207 }
1208
1209 bfd_ardata (abfd)->symdef_count = c;
1210 bfd_has_map (abfd) = true;
1211
1212 return true;
1213 }
1214
1215 /* See if this is an XCOFF archive. */
1216
1217 const bfd_target *
1218 _bfd_xcoff_archive_p (abfd)
1219 bfd *abfd;
1220 {
1221 char magic[SXCOFFARMAG];
1222
1223 if (bfd_read ((PTR) magic, SXCOFFARMAG, 1, abfd) != SXCOFFARMAG)
1224 {
1225 if (bfd_get_error () != bfd_error_system_call)
1226 bfd_set_error (bfd_error_wrong_format);
1227 return NULL;
1228 }
1229
1230 if (strncmp (magic, XCOFFARMAG, SXCOFFARMAG) != 0
1231 && strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0)
1232 {
1233 bfd_set_error (bfd_error_wrong_format);
1234 return NULL;
1235 }
1236
1237 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
1238 involves a cast, we can't do it as the left operand of
1239 assignment. */
1240 abfd->tdata.aout_ar_data =
1241 (struct artdata *) bfd_zalloc (abfd, sizeof (struct artdata));
1242
1243 if (bfd_ardata (abfd) == (struct artdata *) NULL)
1244 return NULL;
1245
1246 bfd_ardata (abfd)->cache = NULL;
1247 bfd_ardata (abfd)->archive_head = NULL;
1248 bfd_ardata (abfd)->symdefs = NULL;
1249 bfd_ardata (abfd)->extended_names = NULL;
1250
1251 /* Now handle the two formats. */
1252 if (magic[1] != 'b')
1253 {
1254 /* This is the old format. */
1255 struct xcoff_ar_file_hdr hdr;
1256
1257 /* Copy over the magic string. */
1258 memcpy (hdr.magic, magic, SXCOFFARMAG);
1259
1260 /* Now read the rest of the file header. */
1261 if (bfd_read ((PTR) &hdr.memoff, SIZEOF_AR_FILE_HDR - SXCOFFARMAG, 1,
1262 abfd) != SIZEOF_AR_FILE_HDR - SXCOFFARMAG)
1263 {
1264 if (bfd_get_error () != bfd_error_system_call)
1265 bfd_set_error (bfd_error_wrong_format);
1266 return NULL;
1267 }
1268
1269 bfd_ardata (abfd)->first_file_filepos = strtol (hdr.firstmemoff,
1270 (char **) NULL, 10);
1271
1272 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, SIZEOF_AR_FILE_HDR);
1273 if (bfd_ardata (abfd)->tdata == NULL)
1274 return NULL;
1275
1276 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR);
1277 }
1278 else
1279 {
1280 /* This is the new format. */
1281 struct xcoff_ar_file_hdr_big hdr;
1282
1283 /* Copy over the magic string. */
1284 memcpy (hdr.magic, magic, SXCOFFARMAG);
1285
1286 /* Now read the rest of the file header. */
1287 if (bfd_read ((PTR) &hdr.memoff, SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG, 1,
1288 abfd) != SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG)
1289 {
1290 if (bfd_get_error () != bfd_error_system_call)
1291 bfd_set_error (bfd_error_wrong_format);
1292 return NULL;
1293 }
1294
1295 /* XXX This actually has to be a call to strtoll (at least on 32-bit
1296 machines) since the field width is 20 and there numbers with more
1297 than 32 bits can be represented. */
1298 bfd_ardata (abfd)->first_file_filepos = strtol (hdr.firstmemoff,
1299 (char **) NULL, 10);
1300
1301 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, SIZEOF_AR_FILE_HDR_BIG);
1302 if (bfd_ardata (abfd)->tdata == NULL)
1303 return NULL;
1304
1305 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
1306 }
1307
1308 if (! _bfd_xcoff_slurp_armap (abfd))
1309 {
1310 bfd_release (abfd, bfd_ardata (abfd));
1311 abfd->tdata.aout_ar_data = (struct artdata *) NULL;
1312 return NULL;
1313 }
1314
1315 return abfd->xvec;
1316 }
1317
1318 /* Read the archive header in an XCOFF archive. */
1319
1320 PTR
1321 _bfd_xcoff_read_ar_hdr (abfd)
1322 bfd *abfd;
1323 {
1324 size_t namlen;
1325 struct areltdata *ret;
1326
1327 ret = (struct areltdata *) bfd_alloc (abfd, sizeof (struct areltdata));
1328 if (ret == NULL)
1329 return NULL;
1330
1331 if (! xcoff_big_format_p (abfd))
1332 {
1333 struct xcoff_ar_hdr hdr;
1334 struct xcoff_ar_hdr *hdrp;
1335
1336 if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR, 1, abfd) != SIZEOF_AR_HDR)
1337 {
1338 free (ret);
1339 return NULL;
1340 }
1341
1342 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1343 hdrp = (struct xcoff_ar_hdr *) bfd_alloc (abfd,
1344 SIZEOF_AR_HDR + namlen + 1);
1345 if (hdrp == NULL)
1346 {
1347 free (ret);
1348 return NULL;
1349 }
1350 memcpy (hdrp, &hdr, SIZEOF_AR_HDR);
1351 if (bfd_read ((char *) hdrp + SIZEOF_AR_HDR, 1, namlen, abfd) != namlen)
1352 {
1353 free (ret);
1354 return NULL;
1355 }
1356 ((char *) hdrp)[SIZEOF_AR_HDR + namlen] = '\0';
1357
1358 ret->arch_header = (char *) hdrp;
1359 ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
1360 ret->filename = (char *) hdrp + SIZEOF_AR_HDR;
1361 }
1362 else
1363 {
1364 struct xcoff_ar_hdr_big hdr;
1365 struct xcoff_ar_hdr_big *hdrp;
1366
1367 if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR_BIG, 1, abfd)
1368 != SIZEOF_AR_HDR_BIG)
1369 {
1370 free (ret);
1371 return NULL;
1372 }
1373
1374 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1375 hdrp = (struct xcoff_ar_hdr_big *) bfd_alloc (abfd,
1376 SIZEOF_AR_HDR_BIG
1377 + namlen + 1);
1378 if (hdrp == NULL)
1379 {
1380 free (ret);
1381 return NULL;
1382 }
1383 memcpy (hdrp, &hdr, SIZEOF_AR_HDR_BIG);
1384 if (bfd_read ((char *) hdrp + SIZEOF_AR_HDR_BIG, 1, namlen, abfd) != namlen)
1385 {
1386 free (ret);
1387 return NULL;
1388 }
1389 ((char *) hdrp)[SIZEOF_AR_HDR_BIG + namlen] = '\0';
1390
1391 ret->arch_header = (char *) hdrp;
1392 /* XXX This actually has to be a call to strtoll (at least on 32-bit
1393 machines) since the field width is 20 and there numbers with more
1394 than 32 bits can be represented. */
1395 ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
1396 ret->filename = (char *) hdrp + SIZEOF_AR_HDR_BIG;
1397 }
1398
1399 /* Skip over the XCOFFARFMAG at the end of the file name. */
1400 if (bfd_seek (abfd, (namlen & 1) + SXCOFFARFMAG, SEEK_CUR) != 0)
1401 return NULL;
1402
1403 return (PTR) ret;
1404 }
1405
1406 /* Open the next element in an XCOFF archive. */
1407
1408 bfd *
1409 _bfd_xcoff_openr_next_archived_file (archive, last_file)
1410 bfd *archive;
1411 bfd *last_file;
1412 {
1413 file_ptr filestart;
1414
1415 if (xcoff_ardata (archive) == NULL)
1416 {
1417 bfd_set_error (bfd_error_invalid_operation);
1418 return NULL;
1419 }
1420
1421 if (! xcoff_big_format_p (archive))
1422 {
1423 if (last_file == NULL)
1424 filestart = bfd_ardata (archive)->first_file_filepos;
1425 else
1426 filestart = strtol (arch_xhdr (last_file)->nextoff, (char **) NULL,
1427 10);
1428
1429 if (filestart == 0
1430 || filestart == strtol (xcoff_ardata (archive)->memoff,
1431 (char **) NULL, 10)
1432 || filestart == strtol (xcoff_ardata (archive)->symoff,
1433 (char **) NULL, 10))
1434 {
1435 bfd_set_error (bfd_error_no_more_archived_files);
1436 return NULL;
1437 }
1438 }
1439 else
1440 {
1441 if (last_file == NULL)
1442 filestart = bfd_ardata (archive)->first_file_filepos;
1443 else
1444 /* XXX These actually have to be a calls to strtoll (at least
1445 on 32-bit machines) since the fields's width is 20 and
1446 there numbers with more than 32 bits can be represented. */
1447 filestart = strtol (arch_xhdr_big (last_file)->nextoff, (char **) NULL,
1448 10);
1449
1450 /* XXX These actually have to be calls to strtoll (at least on 32-bit
1451 machines) since the fields's width is 20 and there numbers with more
1452 than 32 bits can be represented. */
1453 if (filestart == 0
1454 || filestart == strtol (xcoff_ardata_big (archive)->memoff,
1455 (char **) NULL, 10)
1456 || filestart == strtol (xcoff_ardata_big (archive)->symoff,
1457 (char **) NULL, 10))
1458 {
1459 bfd_set_error (bfd_error_no_more_archived_files);
1460 return NULL;
1461 }
1462 }
1463
1464 return _bfd_get_elt_at_filepos (archive, filestart);
1465 }
1466
1467 /* Stat an element in an XCOFF archive. */
1468
1469 int
1470 _bfd_xcoff_generic_stat_arch_elt (abfd, s)
1471 bfd *abfd;
1472 struct stat *s;
1473 {
1474 if (abfd->arelt_data == NULL)
1475 {
1476 bfd_set_error (bfd_error_invalid_operation);
1477 return -1;
1478 }
1479
1480 if (! xcoff_big_format_p (abfd))
1481 {
1482 struct xcoff_ar_hdr *hdrp = arch_xhdr (abfd);
1483
1484 s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
1485 s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
1486 s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
1487 s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
1488 s->st_size = arch_eltdata (abfd)->parsed_size;
1489 }
1490 else
1491 {
1492 struct xcoff_ar_hdr_big *hdrp = arch_xhdr_big (abfd);
1493
1494 s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
1495 s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
1496 s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
1497 s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
1498 s->st_size = arch_eltdata (abfd)->parsed_size;
1499 }
1500
1501 return 0;
1502 }
1503
1504 /* Normalize a file name for inclusion in an archive. */
1505
1506 static const char *
1507 normalize_filename (abfd)
1508 bfd *abfd;
1509 {
1510 const char *file;
1511 const char *filename;
1512
1513 file = bfd_get_filename (abfd);
1514 filename = strrchr (file, '/');
1515 if (filename != NULL)
1516 filename++;
1517 else
1518 filename = file;
1519 return filename;
1520 }
1521
1522 /* Write out an XCOFF armap. */
1523
1524 /*ARGSUSED*/
1525 static boolean
1526 xcoff_write_armap_old (abfd, elength, map, orl_count, stridx)
1527 bfd *abfd;
1528 unsigned int elength ATTRIBUTE_UNUSED;
1529 struct orl *map;
1530 unsigned int orl_count;
1531 int stridx;
1532 {
1533 struct xcoff_ar_hdr hdr;
1534 char *p;
1535 unsigned char buf[4];
1536 bfd *sub;
1537 file_ptr fileoff;
1538 unsigned int i;
1539
1540 memset (&hdr, 0, sizeof hdr);
1541 sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
1542 sprintf (hdr.nextoff, "%d", 0);
1543 memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, 12);
1544 sprintf (hdr.date, "%d", 0);
1545 sprintf (hdr.uid, "%d", 0);
1546 sprintf (hdr.gid, "%d", 0);
1547 sprintf (hdr.mode, "%d", 0);
1548 sprintf (hdr.namlen, "%d", 0);
1549
1550 /* We need spaces, not null bytes, in the header. */
1551 for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR; p++)
1552 if (*p == '\0')
1553 *p = ' ';
1554
1555 if (bfd_write ((PTR) &hdr, SIZEOF_AR_HDR, 1, abfd) != SIZEOF_AR_HDR
1556 || bfd_write (XCOFFARFMAG, 1, SXCOFFARFMAG, abfd) != SXCOFFARFMAG)
1557 return false;
1558
1559 bfd_h_put_32 (abfd, orl_count, buf);
1560 if (bfd_write (buf, 1, 4, abfd) != 4)
1561 return false;
1562
1563 sub = abfd->archive_head;
1564 fileoff = SIZEOF_AR_FILE_HDR;
1565 i = 0;
1566 while (sub != NULL && i < orl_count)
1567 {
1568 size_t namlen;
1569
1570 while (((bfd *) (map[i]).pos) == sub)
1571 {
1572 bfd_h_put_32 (abfd, fileoff, buf);
1573 if (bfd_write (buf, 1, 4, abfd) != 4)
1574 return false;
1575 ++i;
1576 }
1577 namlen = strlen (normalize_filename (sub));
1578 namlen = (namlen + 1) &~ 1;
1579 fileoff += (SIZEOF_AR_HDR
1580 + namlen
1581 + SXCOFFARFMAG
1582 + arelt_size (sub));
1583 fileoff = (fileoff + 1) &~ 1;
1584 sub = sub->next;
1585 }
1586
1587 for (i = 0; i < orl_count; i++)
1588 {
1589 const char *name;
1590 size_t namlen;
1591
1592 name = *map[i].name;
1593 namlen = strlen (name);
1594 if (bfd_write (name, 1, namlen + 1, abfd) != namlen + 1)
1595 return false;
1596 }
1597
1598 if ((stridx & 1) != 0)
1599 {
1600 char b;
1601
1602 b = '\0';
1603 if (bfd_write (&b, 1, 1, abfd) != 1)
1604 return false;
1605 }
1606
1607 return true;
1608 }
1609
1610 /* Write a single armap in the big format. */
1611 static boolean
1612 xcoff_write_one_armap_big (abfd, map, orl_count, orl_ccount, stridx, bits64,
1613 prevoff, nextoff)
1614 bfd *abfd;
1615 struct orl *map;
1616 unsigned int orl_count;
1617 unsigned int orl_ccount;
1618 unsigned int stridx;
1619 int bits64;
1620 const char *prevoff;
1621 char *nextoff;
1622 {
1623 struct xcoff_ar_hdr_big hdr;
1624 char *p;
1625 unsigned char buf[4];
1626 bfd *sub;
1627 file_ptr fileoff;
1628 const bfd_arch_info_type *arch_info;
1629 bfd *object_bfd;
1630 unsigned int i;
1631
1632 memset (&hdr, 0, sizeof hdr);
1633 /* XXX This call actually should use %lld (at least on 32-bit
1634 machines) since the fields's width is 20 and there numbers with
1635 more than 32 bits can be represented. */
1636 sprintf (hdr.size, "%ld", (long) (4 + orl_ccount * 4 + stridx));
1637 if (bits64)
1638 sprintf (hdr.nextoff, "%d", 0);
1639 else
1640 sprintf (hdr.nextoff, "%d", (strtol (prevoff, (char **) NULL, 10)
1641 + 4 + orl_ccount * 4 + stridx));
1642 memcpy (hdr.prevoff, prevoff, sizeof (hdr.prevoff));
1643 sprintf (hdr.date, "%d", 0);
1644 sprintf (hdr.uid, "%d", 0);
1645 sprintf (hdr.gid, "%d", 0);
1646 sprintf (hdr.mode, "%d", 0);
1647 sprintf (hdr.namlen, "%d", 0);
1648
1649 /* We need spaces, not null bytes, in the header. */
1650 for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR_BIG; p++)
1651 if (*p == '\0')
1652 *p = ' ';
1653
1654 memcpy (nextoff, hdr.nextoff, sizeof (hdr.nextoff));
1655
1656 if (bfd_write ((PTR) &hdr, SIZEOF_AR_HDR_BIG, 1, abfd) != SIZEOF_AR_HDR_BIG
1657 || bfd_write (XCOFFARFMAG, 1, SXCOFFARFMAG, abfd) != SXCOFFARFMAG)
1658 return false;
1659
1660 bfd_h_put_32 (abfd, orl_ccount, buf);
1661 if (bfd_write (buf, 1, 4, abfd) != 4)
1662 return false;
1663
1664 sub = abfd->archive_head;
1665 fileoff = SIZEOF_AR_FILE_HDR_BIG;
1666 i = 0;
1667 while (sub != NULL && i < orl_count)
1668 {
1669 size_t namlen;
1670
1671 if ((bfd_arch_bits_per_address ((bfd *) map[i].pos) == 64) == bits64)
1672 while (((bfd *) (map[i]).pos) == sub)
1673 {
1674 bfd_h_put_32 (abfd, fileoff, buf);
1675 if (bfd_write (buf, 1, 4, abfd) != 4)
1676 return false;
1677 i++;
1678 }
1679 else
1680 while (((bfd *) (map[i]).pos) == sub)
1681 i++;
1682
1683 namlen = strlen (normalize_filename (sub));
1684 namlen = (namlen + 1) &~ 1;
1685 fileoff += (SIZEOF_AR_HDR_BIG
1686 + namlen
1687 + SXCOFFARFMAG
1688 + arelt_size (sub));
1689 fileoff = (fileoff + 1) &~ 1;
1690 sub = sub->next;
1691 }
1692
1693 object_bfd = NULL;
1694 for (i = 0; i < orl_count; i++)
1695 {
1696 const char *name;
1697 size_t namlen;
1698 bfd *ob = (bfd *)map[i].pos;
1699
1700 if (ob != object_bfd)
1701 arch_info = bfd_get_arch_info (ob);
1702 if ((arch_info->bits_per_address == 64) != bits64)
1703 continue;
1704
1705 name = *map[i].name;
1706 namlen = strlen (name);
1707 if (bfd_write (name, 1, namlen + 1, abfd) != namlen + 1)
1708 return false;
1709 }
1710
1711 if ((stridx & 1) != 0)
1712 {
1713 char b;
1714
1715 b = '\0';
1716 if (bfd_write (&b, 1, 1, abfd) != 1)
1717 return false;
1718 }
1719
1720 return true;
1721 }
1722
1723 /*ARGSUSED*/
1724 static boolean
1725 xcoff_write_armap_big (abfd, elength, map, orl_count, stridx)
1726 bfd *abfd;
1727 unsigned int elength ATTRIBUTE_UNUSED;
1728 struct orl *map;
1729 unsigned int orl_count;
1730 int stridx;
1731 {
1732 unsigned int i;
1733 unsigned int orl_count_32, orl_count_64;
1734 unsigned int stridx_32, stridx_64;
1735 const bfd_arch_info_type *arch_info;
1736 bfd *object_bfd;
1737
1738 /* First, we look through the symbols and work out which are
1739 from 32-bit objects and which from 64-bit ones. */
1740 orl_count_32 = 0;
1741 orl_count_64 = 0;
1742 stridx_32 = 0;
1743 stridx_64 = 0;
1744 object_bfd = NULL;
1745 for (i = 0; i < orl_count; i++)
1746 {
1747 bfd *ob = (bfd *)map[i].pos;
1748 unsigned int len;
1749 if (ob != object_bfd)
1750 arch_info = bfd_get_arch_info (ob);
1751 len = strlen (*map[i].name) + 1;
1752 if (arch_info->bits_per_address == 64)
1753 {
1754 orl_count_64++;
1755 stridx_64 += len;
1756 }
1757 else
1758 {
1759 orl_count_32++;
1760 stridx_32 += len;
1761 }
1762 object_bfd = ob;
1763 }
1764 /* A quick sanity check... */
1765 BFD_ASSERT (orl_count_64 + orl_count_32 == orl_count);
1766 BFD_ASSERT (stridx_64 + stridx_32 == stridx);
1767
1768 /* Now write out each map. */
1769 if (! xcoff_write_one_armap_big (abfd, map, orl_count, orl_count_32,
1770 stridx_32, false,
1771 xcoff_ardata_big (abfd)->memoff,
1772 xcoff_ardata_big (abfd)->symoff))
1773 return false;
1774 if (! xcoff_write_one_armap_big (abfd, map, orl_count, orl_count_64,
1775 stridx_64, true,
1776 xcoff_ardata_big (abfd)->symoff,
1777 xcoff_ardata_big (abfd)->symoff64))
1778 return false;
1779
1780 return true;
1781 }
1782
1783 /*ARGSUSED*/
1784 boolean
1785 _bfd_xcoff_write_armap (abfd, elength, map, orl_count, stridx)
1786 bfd *abfd;
1787 unsigned int elength ATTRIBUTE_UNUSED;
1788 struct orl *map;
1789 unsigned int orl_count;
1790 int stridx;
1791 {
1792 if (! xcoff_big_format_p (abfd))
1793 return xcoff_write_armap_old (abfd, elength, map, orl_count, stridx);
1794 else
1795 return xcoff_write_armap_big (abfd, elength, map, orl_count, stridx);
1796 }
1797
1798 /* Write out an XCOFF archive. We always write an entire archive,
1799 rather than fussing with the freelist and so forth. */
1800
1801 static boolean
1802 xcoff_write_archive_contents_old (abfd)
1803 bfd *abfd;
1804 {
1805 struct xcoff_ar_file_hdr fhdr;
1806 size_t count;
1807 size_t total_namlen;
1808 file_ptr *offsets;
1809 boolean makemap;
1810 boolean hasobjects;
1811 file_ptr prevoff, nextoff;
1812 bfd *sub;
1813 unsigned int i;
1814 struct xcoff_ar_hdr ahdr;
1815 bfd_size_type size;
1816 char *p;
1817 char decbuf[13];
1818
1819 memset (&fhdr, 0, sizeof fhdr);
1820 strncpy (fhdr.magic, XCOFFARMAG, SXCOFFARMAG);
1821 sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR);
1822 sprintf (fhdr.freeoff, "%d", 0);
1823
1824 count = 0;
1825 total_namlen = 0;
1826 for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
1827 {
1828 ++count;
1829 total_namlen += strlen (normalize_filename (sub)) + 1;
1830 }
1831 offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
1832 if (offsets == NULL)
1833 return false;
1834
1835 if (bfd_seek (abfd, SIZEOF_AR_FILE_HDR, SEEK_SET) != 0)
1836 return false;
1837
1838 makemap = bfd_has_map (abfd);
1839 hasobjects = false;
1840 prevoff = 0;
1841 nextoff = SIZEOF_AR_FILE_HDR;
1842 for (sub = abfd->archive_head, i = 0; sub != NULL; sub = sub->next, i++)
1843 {
1844 const char *name;
1845 size_t namlen;
1846 struct xcoff_ar_hdr *ahdrp;
1847 bfd_size_type remaining;
1848
1849 if (makemap && ! hasobjects)
1850 {
1851 if (bfd_check_format (sub, bfd_object))
1852 hasobjects = true;
1853 }
1854
1855 name = normalize_filename (sub);
1856 namlen = strlen (name);
1857
1858 if (sub->arelt_data != NULL)
1859 ahdrp = arch_xhdr (sub);
1860 else
1861 ahdrp = NULL;
1862
1863 if (ahdrp == NULL)
1864 {
1865 struct stat s;
1866
1867 memset (&ahdr, 0, sizeof ahdr);
1868 ahdrp = &ahdr;
1869 if (stat (bfd_get_filename (sub), &s) != 0)
1870 {
1871 bfd_set_error (bfd_error_system_call);
1872 return false;
1873 }
1874
1875 sprintf (ahdrp->size, "%ld", (long) s.st_size);
1876 sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
1877 sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
1878 sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
1879 sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
1880
1881 if (sub->arelt_data == NULL)
1882 {
1883 sub->arelt_data = bfd_alloc (sub, sizeof (struct areltdata));
1884 if (sub->arelt_data == NULL)
1885 return false;
1886 }
1887
1888 arch_eltdata (sub)->parsed_size = s.st_size;
1889 }
1890
1891 sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
1892 sprintf (ahdrp->namlen, "%ld", (long) namlen);
1893
1894 /* If the length of the name is odd, we write out the null byte
1895 after the name as well. */
1896 namlen = (namlen + 1) &~ 1;
1897
1898 remaining = arelt_size (sub);
1899 size = (SIZEOF_AR_HDR
1900 + namlen
1901 + SXCOFFARFMAG
1902 + remaining);
1903
1904 BFD_ASSERT (nextoff == bfd_tell (abfd));
1905
1906 offsets[i] = nextoff;
1907
1908 prevoff = nextoff;
1909 nextoff += size + (size & 1);
1910
1911 sprintf (ahdrp->nextoff, "%ld", (long) nextoff);
1912
1913 /* We need spaces, not null bytes, in the header. */
1914 for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR; p++)
1915 if (*p == '\0')
1916 *p = ' ';
1917
1918 if (bfd_write ((PTR) ahdrp, 1, SIZEOF_AR_HDR, abfd) != SIZEOF_AR_HDR
1919 || bfd_write ((PTR) name, 1, namlen, abfd) != namlen
1920 || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
1921 != SXCOFFARFMAG))
1922 return false;
1923
1924 if (bfd_seek (sub, (file_ptr) 0, SEEK_SET) != 0)
1925 return false;
1926 while (remaining != 0)
1927 {
1928 bfd_size_type amt;
1929 bfd_byte buffer[DEFAULT_BUFFERSIZE];
1930
1931 amt = sizeof buffer;
1932 if (amt > remaining)
1933 amt = remaining;
1934 if (bfd_read (buffer, 1, amt, sub) != amt
1935 || bfd_write (buffer, 1, amt, abfd) != amt)
1936 return false;
1937 remaining -= amt;
1938 }
1939
1940 if ((size & 1) != 0)
1941 {
1942 bfd_byte b;
1943
1944 b = '\0';
1945 if (bfd_write (&b, 1, 1, abfd) != 1)
1946 return false;
1947 }
1948 }
1949
1950 sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
1951
1952 /* Write out the member table. */
1953
1954 BFD_ASSERT (nextoff == bfd_tell (abfd));
1955 sprintf (fhdr.memoff, "%ld", (long) nextoff);
1956
1957 memset (&ahdr, 0, sizeof ahdr);
1958 sprintf (ahdr.size, "%ld", (long) (12 + count * 12 + total_namlen));
1959 sprintf (ahdr.prevoff, "%ld", (long) prevoff);
1960 sprintf (ahdr.date, "%d", 0);
1961 sprintf (ahdr.uid, "%d", 0);
1962 sprintf (ahdr.gid, "%d", 0);
1963 sprintf (ahdr.mode, "%d", 0);
1964 sprintf (ahdr.namlen, "%d", 0);
1965
1966 size = (SIZEOF_AR_HDR
1967 + 12
1968 + count * 12
1969 + total_namlen
1970 + SXCOFFARFMAG);
1971
1972 prevoff = nextoff;
1973 nextoff += size + (size & 1);
1974
1975 if (makemap && hasobjects)
1976 sprintf (ahdr.nextoff, "%ld", (long) nextoff);
1977 else
1978 sprintf (ahdr.nextoff, "%d", 0);
1979
1980 /* We need spaces, not null bytes, in the header. */
1981 for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR; p++)
1982 if (*p == '\0')
1983 *p = ' ';
1984
1985 if (bfd_write ((PTR) &ahdr, 1, SIZEOF_AR_HDR, abfd) != SIZEOF_AR_HDR
1986 || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
1987 != SXCOFFARFMAG))
1988 return false;
1989
1990 sprintf (decbuf, "%-12ld", (long) count);
1991 if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
1992 return false;
1993 for (i = 0; i < count; i++)
1994 {
1995 sprintf (decbuf, "%-12ld", (long) offsets[i]);
1996 if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
1997 return false;
1998 }
1999 for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
2000 {
2001 const char *name;
2002 size_t namlen;
2003
2004 name = normalize_filename (sub);
2005 namlen = strlen (name);
2006 if (bfd_write ((PTR) name, 1, namlen + 1, abfd) != namlen + 1)
2007 return false;
2008 }
2009 if ((size & 1) != 0)
2010 {
2011 bfd_byte b;
2012
2013 b = '\0';
2014 if (bfd_write ((PTR) &b, 1, 1, abfd) != 1)
2015 return false;
2016 }
2017
2018 /* Write out the armap, if appropriate. */
2019
2020 if (! makemap || ! hasobjects)
2021 sprintf (fhdr.symoff, "%d", 0);
2022 else
2023 {
2024 BFD_ASSERT (nextoff == bfd_tell (abfd));
2025 sprintf (fhdr.symoff, "%ld", (long) nextoff);
2026 bfd_ardata (abfd)->tdata = (PTR) &fhdr;
2027 if (! _bfd_compute_and_write_armap (abfd, 0))
2028 return false;
2029 }
2030
2031 /* Write out the archive file header. */
2032
2033 /* We need spaces, not null bytes, in the header. */
2034 for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR; p++)
2035 if (*p == '\0')
2036 *p = ' ';
2037
2038 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2039 || (bfd_write ((PTR) &fhdr, SIZEOF_AR_FILE_HDR, 1, abfd) !=
2040 SIZEOF_AR_FILE_HDR))
2041 return false;
2042
2043 return true;
2044 }
2045
2046 static boolean
2047 xcoff_write_archive_contents_big (abfd)
2048 bfd *abfd;
2049 {
2050 struct xcoff_ar_file_hdr_big fhdr;
2051 size_t count;
2052 size_t total_namlen;
2053 file_ptr *offsets;
2054 boolean makemap;
2055 boolean hasobjects;
2056 file_ptr prevoff, nextoff;
2057 bfd *sub;
2058 unsigned int i;
2059 struct xcoff_ar_hdr_big ahdr;
2060 bfd_size_type size;
2061 char *p;
2062 char decbuf[13];
2063
2064 memset (&fhdr, 0, sizeof fhdr);
2065 strncpy (fhdr.magic, XCOFFARMAGBIG, SXCOFFARMAG);
2066 sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR_BIG);
2067 sprintf (fhdr.freeoff, "%d", 0);
2068
2069 count = 0;
2070 total_namlen = 0;
2071 for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
2072 {
2073 ++count;
2074 total_namlen += strlen (normalize_filename (sub)) + 1;
2075 }
2076 offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
2077 if (offsets == NULL)
2078 return false;
2079
2080 if (bfd_seek (abfd, SIZEOF_AR_FILE_HDR_BIG, SEEK_SET) != 0)
2081 return false;
2082
2083 makemap = bfd_has_map (abfd);
2084 hasobjects = false;
2085 prevoff = 0;
2086 nextoff = SIZEOF_AR_FILE_HDR_BIG;
2087 for (sub = abfd->archive_head, i = 0; sub != NULL; sub = sub->next, i++)
2088 {
2089 const char *name;
2090 size_t namlen;
2091 struct xcoff_ar_hdr_big *ahdrp;
2092 bfd_size_type remaining;
2093
2094 if (makemap && ! hasobjects)
2095 {
2096 if (bfd_check_format (sub, bfd_object))
2097 hasobjects = true;
2098 }
2099
2100 name = normalize_filename (sub);
2101 namlen = strlen (name);
2102
2103 if (sub->arelt_data != NULL)
2104 ahdrp = arch_xhdr_big (sub);
2105 else
2106 ahdrp = NULL;
2107
2108 if (ahdrp == NULL)
2109 {
2110 struct stat s;
2111
2112 memset (&ahdr, 0, sizeof ahdr);
2113 ahdrp = &ahdr;
2114 /* XXX This should actually be a call to stat64 (at least on
2115 32-bit machines). */
2116 if (stat (bfd_get_filename (sub), &s) != 0)
2117 {
2118 bfd_set_error (bfd_error_system_call);
2119 return false;
2120 }
2121
2122 /* XXX This call actually should use %lld (at least on 32-bit
2123 machines) since the fields's width is 20 and there numbers with
2124 more than 32 bits can be represented. */
2125 sprintf (ahdrp->size, "%ld", (long) s.st_size);
2126 sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
2127 sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
2128 sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
2129 sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
2130
2131 if (sub->arelt_data == NULL)
2132 {
2133 sub->arelt_data = bfd_alloc (sub, sizeof (struct areltdata));
2134 if (sub->arelt_data == NULL)
2135 return false;
2136 }
2137
2138 arch_eltdata (sub)->parsed_size = s.st_size;
2139 }
2140
2141 /* XXX These calls actually should use %lld (at least on 32-bit
2142 machines) since the fields's width is 20 and there numbers with
2143 more than 32 bits can be represented. */
2144 sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
2145 sprintf (ahdrp->namlen, "%ld", (long) namlen);
2146
2147 /* If the length of the name is odd, we write out the null byte
2148 after the name as well. */
2149 namlen = (namlen + 1) &~ 1;
2150
2151 remaining = arelt_size (sub);
2152 size = (SIZEOF_AR_HDR_BIG
2153 + namlen
2154 + SXCOFFARFMAG
2155 + remaining);
2156
2157 BFD_ASSERT (nextoff == bfd_tell (abfd));
2158
2159 offsets[i] = nextoff;
2160
2161 prevoff = nextoff;
2162 nextoff += size + (size & 1);
2163
2164 sprintf (ahdrp->nextoff, "%ld", (long) nextoff);
2165
2166 /* We need spaces, not null bytes, in the header. */
2167 for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR_BIG; p++)
2168 if (*p == '\0')
2169 *p = ' ';
2170
2171 if (bfd_write ((PTR) ahdrp, 1, SIZEOF_AR_HDR_BIG, abfd)
2172 != SIZEOF_AR_HDR_BIG
2173 || bfd_write ((PTR) name, 1, namlen, abfd) != namlen
2174 || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
2175 != SXCOFFARFMAG))
2176 return false;
2177
2178 if (bfd_seek (sub, (file_ptr) 0, SEEK_SET) != 0)
2179 return false;
2180 while (remaining != 0)
2181 {
2182 bfd_size_type amt;
2183 bfd_byte buffer[DEFAULT_BUFFERSIZE];
2184
2185 amt = sizeof buffer;
2186 if (amt > remaining)
2187 amt = remaining;
2188 if (bfd_read (buffer, 1, amt, sub) != amt
2189 || bfd_write (buffer, 1, amt, abfd) != amt)
2190 return false;
2191 remaining -= amt;
2192 }
2193
2194 if ((size & 1) != 0)
2195 {
2196 bfd_byte b;
2197
2198 b = '\0';
2199 if (bfd_write (&b, 1, 1, abfd) != 1)
2200 return false;
2201 }
2202 }
2203
2204 /* XXX This call actually should use %lld (at least on 32-bit
2205 machines) since the fields's width is 20 and there numbers with
2206 more than 32 bits can be represented. */
2207 sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
2208
2209 /* Write out the member table. */
2210
2211 BFD_ASSERT (nextoff == bfd_tell (abfd));
2212 /* XXX This call actually should use %lld (at least on 32-bit
2213 machines) since the fields's width is 20 and there numbers with
2214 more than 32 bits can be represented. */
2215 sprintf (fhdr.memoff, "%ld", (long) nextoff);
2216
2217 memset (&ahdr, 0, sizeof ahdr);
2218 /* XXX The next two calls actually should use %lld (at least on 32-bit
2219 machines) since the fields's width is 20 and there numbers with
2220 more than 32 bits can be represented. */
2221 sprintf (ahdr.size, "%ld", (long) (12 + count * 12 + total_namlen));
2222 sprintf (ahdr.prevoff, "%ld", (long) prevoff);
2223 sprintf (ahdr.date, "%d", 0);
2224 sprintf (ahdr.uid, "%d", 0);
2225 sprintf (ahdr.gid, "%d", 0);
2226 sprintf (ahdr.mode, "%d", 0);
2227 sprintf (ahdr.namlen, "%d", 0);
2228
2229 size = (SIZEOF_AR_HDR_BIG
2230 + 12
2231 + count * 12
2232 + total_namlen
2233 + SXCOFFARFMAG);
2234
2235 prevoff = nextoff;
2236 nextoff += size + (size & 1);
2237
2238 if (makemap && hasobjects)
2239 /* XXX This call actually should use %lld (at least on 32-bit
2240 machines) since the fields's width is 20 and there numbers with
2241 more than 32 bits can be represented. */
2242 sprintf (ahdr.nextoff, "%ld", (long) nextoff);
2243 else
2244 sprintf (ahdr.nextoff, "%d", 0);
2245
2246 /* We need spaces, not null bytes, in the header. */
2247 for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR_BIG; p++)
2248 if (*p == '\0')
2249 *p = ' ';
2250
2251 if (bfd_write ((PTR) &ahdr, 1, SIZEOF_AR_HDR_BIG, abfd) != SIZEOF_AR_HDR_BIG
2252 || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
2253 != SXCOFFARFMAG))
2254 return false;
2255
2256 sprintf (decbuf, "%-12ld", (long) count);
2257 if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
2258 return false;
2259 for (i = 0; i < count; i++)
2260 {
2261 sprintf (decbuf, "%-12ld", (long) offsets[i]);
2262 if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
2263 return false;
2264 }
2265 for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
2266 {
2267 const char *name;
2268 size_t namlen;
2269
2270 name = normalize_filename (sub);
2271 namlen = strlen (name);
2272 if (bfd_write ((PTR) name, 1, namlen + 1, abfd) != namlen + 1)
2273 return false;
2274 }
2275 if ((size & 1) != 0)
2276 {
2277 bfd_byte b;
2278
2279 b = '\0';
2280 if (bfd_write ((PTR) &b, 1, 1, abfd) != 1)
2281 return false;
2282 }
2283
2284 /* Write out the armap, if appropriate. */
2285
2286 if (! makemap || ! hasobjects)
2287 sprintf (fhdr.symoff, "%d", 0);
2288 else
2289 {
2290 BFD_ASSERT (nextoff == bfd_tell (abfd));
2291 /* XXX This call actually should use %lld (at least on 32-bit
2292 machines) since the fields's width is 20 and there numbers with
2293 more than 32 bits can be represented. */
2294 bfd_ardata (abfd)->tdata = (PTR) &fhdr;
2295 if (! _bfd_compute_and_write_armap (abfd, 0))
2296 return false;
2297 }
2298
2299 /* Write out the archive file header. */
2300
2301 /* We need spaces, not null bytes, in the header. */
2302 for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR_BIG; p++)
2303 if (*p == '\0')
2304 *p = ' ';
2305
2306 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2307 || (bfd_write ((PTR) &fhdr, SIZEOF_AR_FILE_HDR_BIG, 1, abfd) !=
2308 SIZEOF_AR_FILE_HDR_BIG))
2309 return false;
2310
2311 return true;
2312 }
2313
2314 boolean
2315 _bfd_xcoff_write_archive_contents (abfd)
2316 bfd *abfd;
2317 {
2318 if (! xcoff_big_format_p (abfd))
2319 return xcoff_write_archive_contents_old (abfd);
2320 else
2321 return xcoff_write_archive_contents_big (abfd);
2322 }
2323 \f
2324 /* We can't use the usual coff_sizeof_headers routine, because AIX
2325 always uses an a.out header. */
2326
2327 /*ARGSUSED*/
2328 int
2329 _bfd_xcoff_sizeof_headers (abfd, reloc)
2330 bfd *abfd;
2331 boolean reloc ATTRIBUTE_UNUSED;
2332 {
2333 int size;
2334
2335 size = FILHSZ;
2336 if (xcoff_data (abfd)->full_aouthdr)
2337 size += AOUTSZ;
2338 else
2339 size += SMALL_AOUTSZ;
2340 size += abfd->section_count * SCNHSZ;
2341 return size;
2342 }
2343 \f
2344
GDB Binutils - Deliverables
This page took 0.093542 seconds and 4 git commands to generate.