projects / deliverable / binutils-gdb.git / blob
? search:


dec690ce4895f237828fad3e4e37925b10b7b8c0
[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 bfd_vma 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 /* Read in the entire symbol table. */
1138 contents = (bfd_byte *) bfd_alloc (abfd, sz);
1139 if (contents == NULL)
1140 return false;
1141 if (bfd_read ((PTR) contents, 1, sz, abfd) != sz)
1142 return false;
1143
1144 /* The symbol table starts with a four byte count. */
1145 c = bfd_h_get_32 (abfd, contents);
1146
1147 if (c * 4 >= sz)
1148 {
1149 bfd_set_error (bfd_error_bad_value);
1150 return false;
1151 }
1152
1153 bfd_ardata (abfd)->symdefs = ((carsym *)
1154 bfd_alloc (abfd, c * sizeof (carsym)));
1155 if (bfd_ardata (abfd)->symdefs == NULL)
1156 return false;
1157
1158 /* After the count comes a list of four byte file offsets. */
1159 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 4;
1160 i < c;
1161 ++i, ++arsym, p += 4)
1162 arsym->file_offset = bfd_h_get_32 (abfd, p);
1163 }
1164 else
1165 {
1166 /* This is for the new format. */
1167 struct xcoff_ar_hdr_big hdr;
1168
1169 off = strtol (xcoff_ardata_big (abfd)->symoff, (char **) NULL, 10);
1170 if (off == 0)
1171 {
1172 bfd_has_map (abfd) = false;
1173 return true;
1174 }
1175
1176 if (bfd_seek (abfd, off, SEEK_SET) != 0)
1177 return false;
1178
1179 /* The symbol table starts with a normal archive header. */
1180 if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR_BIG, 1, abfd)
1181 != SIZEOF_AR_HDR_BIG)
1182 return false;
1183
1184 /* Skip the name (normally empty). */
1185 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1186 if (bfd_seek (abfd, ((namlen + 1) & ~1) + SXCOFFARFMAG, SEEK_CUR) != 0)
1187 return false;
1188
1189 /* XXX This actually has to be a call to strtoll (at least on 32-bit
1190 machines) since the field width is 20 and there numbers with more
1191 than 32 bits can be represented. */
1192 sz = strtol (hdr.size, (char **) NULL, 10);
1193
1194 /* Read in the entire symbol table. */
1195 contents = (bfd_byte *) bfd_alloc (abfd, sz);
1196 if (contents == NULL)
1197 return false;
1198 if (bfd_read ((PTR) contents, 1, sz, abfd) != sz)
1199 return false;
1200
1201 /* The symbol table starts with an eight byte count. */
1202 c = bfd_h_get_64 (abfd, contents);
1203
1204 if (c * 8 >= sz)
1205 {
1206 bfd_set_error (bfd_error_bad_value);
1207 return false;
1208 }
1209
1210 bfd_ardata (abfd)->symdefs = ((carsym *)
1211 bfd_alloc (abfd, c * sizeof (carsym)));
1212 if (bfd_ardata (abfd)->symdefs == NULL)
1213 return false;
1214
1215 /* After the count comes a list of eight byte file offsets. */
1216 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 8;
1217 i < c;
1218 ++i, ++arsym, p += 8)
1219 arsym->file_offset = bfd_h_get_64 (abfd, p);
1220 }
1221
1222 /* After the file offsets come null terminated symbol names. */
1223 cend = contents + sz;
1224 for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
1225 i < c;
1226 ++i, ++arsym, p += strlen ((char *) p) + 1)
1227 {
1228 if (p >= cend)
1229 {
1230 bfd_set_error (bfd_error_bad_value);
1231 return false;
1232 }
1233 arsym->name = (char *) p;
1234 }
1235
1236 bfd_ardata (abfd)->symdef_count = c;
1237 bfd_has_map (abfd) = true;
1238
1239 return true;
1240 }
1241
1242 /* See if this is an XCOFF archive. */
1243
1244 const bfd_target *
1245 _bfd_xcoff_archive_p (abfd)
1246 bfd *abfd;
1247 {
1248 char magic[SXCOFFARMAG];
1249
1250 if (bfd_read ((PTR) magic, SXCOFFARMAG, 1, abfd) != SXCOFFARMAG)
1251 {
1252 if (bfd_get_error () != bfd_error_system_call)
1253 bfd_set_error (bfd_error_wrong_format);
1254 return NULL;
1255 }
1256
1257 if (strncmp (magic, XCOFFARMAG, SXCOFFARMAG) != 0
1258 && strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0)
1259 {
1260 bfd_set_error (bfd_error_wrong_format);
1261 return NULL;
1262 }
1263
1264 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
1265 involves a cast, we can't do it as the left operand of
1266 assignment. */
1267 abfd->tdata.aout_ar_data =
1268 (struct artdata *) bfd_zalloc (abfd, sizeof (struct artdata));
1269
1270 if (bfd_ardata (abfd) == (struct artdata *) NULL)
1271 return NULL;
1272
1273 bfd_ardata (abfd)->cache = NULL;
1274 bfd_ardata (abfd)->archive_head = NULL;
1275 bfd_ardata (abfd)->symdefs = NULL;
1276 bfd_ardata (abfd)->extended_names = NULL;
1277
1278 /* Now handle the two formats. */
1279 if (magic[1] != 'b')
1280 {
1281 /* This is the old format. */
1282 struct xcoff_ar_file_hdr hdr;
1283
1284 /* Copy over the magic string. */
1285 memcpy (hdr.magic, magic, SXCOFFARMAG);
1286
1287 /* Now read the rest of the file header. */
1288 if (bfd_read ((PTR) &hdr.memoff, SIZEOF_AR_FILE_HDR - SXCOFFARMAG, 1,
1289 abfd) != SIZEOF_AR_FILE_HDR - SXCOFFARMAG)
1290 {
1291 if (bfd_get_error () != bfd_error_system_call)
1292 bfd_set_error (bfd_error_wrong_format);
1293 return NULL;
1294 }
1295
1296 bfd_ardata (abfd)->first_file_filepos = strtol (hdr.firstmemoff,
1297 (char **) NULL, 10);
1298
1299 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, SIZEOF_AR_FILE_HDR);
1300 if (bfd_ardata (abfd)->tdata == NULL)
1301 return NULL;
1302
1303 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR);
1304 }
1305 else
1306 {
1307 /* This is the new format. */
1308 struct xcoff_ar_file_hdr_big hdr;
1309
1310 /* Copy over the magic string. */
1311 memcpy (hdr.magic, magic, SXCOFFARMAG);
1312
1313 /* Now read the rest of the file header. */
1314 if (bfd_read ((PTR) &hdr.memoff, SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG, 1,
1315 abfd) != SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG)
1316 {
1317 if (bfd_get_error () != bfd_error_system_call)
1318 bfd_set_error (bfd_error_wrong_format);
1319 return NULL;
1320 }
1321
1322 /* XXX This actually has to be a call to strtoll (at least on 32-bit
1323 machines) since the field width is 20 and there numbers with more
1324 than 32 bits can be represented. */
1325 bfd_ardata (abfd)->first_file_filepos = strtol (hdr.firstmemoff,
1326 (char **) NULL, 10);
1327
1328 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, SIZEOF_AR_FILE_HDR_BIG);
1329 if (bfd_ardata (abfd)->tdata == NULL)
1330 return NULL;
1331
1332 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
1333 }
1334
1335 if (! _bfd_xcoff_slurp_armap (abfd))
1336 {
1337 bfd_release (abfd, bfd_ardata (abfd));
1338 abfd->tdata.aout_ar_data = (struct artdata *) NULL;
1339 return NULL;
1340 }
1341
1342 return abfd->xvec;
1343 }
1344
1345 /* Read the archive header in an XCOFF archive. */
1346
1347 PTR
1348 _bfd_xcoff_read_ar_hdr (abfd)
1349 bfd *abfd;
1350 {
1351 size_t namlen;
1352 struct areltdata *ret;
1353
1354 ret = (struct areltdata *) bfd_alloc (abfd, sizeof (struct areltdata));
1355 if (ret == NULL)
1356 return NULL;
1357
1358 if (! xcoff_big_format_p (abfd))
1359 {
1360 struct xcoff_ar_hdr hdr;
1361 struct xcoff_ar_hdr *hdrp;
1362
1363 if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR, 1, abfd) != SIZEOF_AR_HDR)
1364 {
1365 free (ret);
1366 return NULL;
1367 }
1368
1369 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1370 hdrp = (struct xcoff_ar_hdr *) bfd_alloc (abfd,
1371 SIZEOF_AR_HDR + namlen + 1);
1372 if (hdrp == NULL)
1373 {
1374 free (ret);
1375 return NULL;
1376 }
1377 memcpy (hdrp, &hdr, SIZEOF_AR_HDR);
1378 if (bfd_read ((char *) hdrp + SIZEOF_AR_HDR, 1, namlen, abfd) != namlen)
1379 {
1380 free (ret);
1381 return NULL;
1382 }
1383 ((char *) hdrp)[SIZEOF_AR_HDR + namlen] = '\0';
1384
1385 ret->arch_header = (char *) hdrp;
1386 ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
1387 ret->filename = (char *) hdrp + SIZEOF_AR_HDR;
1388 }
1389 else
1390 {
1391 struct xcoff_ar_hdr_big hdr;
1392 struct xcoff_ar_hdr_big *hdrp;
1393
1394 if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR_BIG, 1, abfd)
1395 != SIZEOF_AR_HDR_BIG)
1396 {
1397 free (ret);
1398 return NULL;
1399 }
1400
1401 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1402 hdrp = (struct xcoff_ar_hdr_big *) bfd_alloc (abfd,
1403 SIZEOF_AR_HDR_BIG
1404 + namlen + 1);
1405 if (hdrp == NULL)
1406 {
1407 free (ret);
1408 return NULL;
1409 }
1410 memcpy (hdrp, &hdr, SIZEOF_AR_HDR_BIG);
1411 if (bfd_read ((char *) hdrp + SIZEOF_AR_HDR_BIG, 1, namlen, abfd) != namlen)
1412 {
1413 free (ret);
1414 return NULL;
1415 }
1416 ((char *) hdrp)[SIZEOF_AR_HDR_BIG + namlen] = '\0';
1417
1418 ret->arch_header = (char *) hdrp;
1419 /* XXX This actually has to be a call to strtoll (at least on 32-bit
1420 machines) since the field width is 20 and there numbers with more
1421 than 32 bits can be represented. */
1422 ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
1423 ret->filename = (char *) hdrp + SIZEOF_AR_HDR_BIG;
1424 }
1425
1426 /* Skip over the XCOFFARFMAG at the end of the file name. */
1427 if (bfd_seek (abfd, (namlen & 1) + SXCOFFARFMAG, SEEK_CUR) != 0)
1428 return NULL;
1429
1430 return (PTR) ret;
1431 }
1432
1433 /* Open the next element in an XCOFF archive. */
1434
1435 bfd *
1436 _bfd_xcoff_openr_next_archived_file (archive, last_file)
1437 bfd *archive;
1438 bfd *last_file;
1439 {
1440 file_ptr filestart;
1441
1442 if (xcoff_ardata (archive) == NULL)
1443 {
1444 bfd_set_error (bfd_error_invalid_operation);
1445 return NULL;
1446 }
1447
1448 if (! xcoff_big_format_p (archive))
1449 {
1450 if (last_file == NULL)
1451 filestart = bfd_ardata (archive)->first_file_filepos;
1452 else
1453 filestart = strtol (arch_xhdr (last_file)->nextoff, (char **) NULL,
1454 10);
1455
1456 if (filestart == 0
1457 || filestart == strtol (xcoff_ardata (archive)->memoff,
1458 (char **) NULL, 10)
1459 || filestart == strtol (xcoff_ardata (archive)->symoff,
1460 (char **) NULL, 10))
1461 {
1462 bfd_set_error (bfd_error_no_more_archived_files);
1463 return NULL;
1464 }
1465 }
1466 else
1467 {
1468 if (last_file == NULL)
1469 filestart = bfd_ardata (archive)->first_file_filepos;
1470 else
1471 /* XXX These actually have to be a calls to strtoll (at least
1472 on 32-bit machines) since the fields's width is 20 and
1473 there numbers with more than 32 bits can be represented. */
1474 filestart = strtol (arch_xhdr_big (last_file)->nextoff, (char **) NULL,
1475 10);
1476
1477 /* XXX These actually have to be calls to strtoll (at least on 32-bit
1478 machines) since the fields's width is 20 and there numbers with more
1479 than 32 bits can be represented. */
1480 if (filestart == 0
1481 || filestart == strtol (xcoff_ardata_big (archive)->memoff,
1482 (char **) NULL, 10)
1483 || filestart == strtol (xcoff_ardata_big (archive)->symoff,
1484 (char **) NULL, 10))
1485 {
1486 bfd_set_error (bfd_error_no_more_archived_files);
1487 return NULL;
1488 }
1489 }
1490
1491 return _bfd_get_elt_at_filepos (archive, filestart);
1492 }
1493
1494 /* Stat an element in an XCOFF archive. */
1495
1496 int
1497 _bfd_xcoff_generic_stat_arch_elt (abfd, s)
1498 bfd *abfd;
1499 struct stat *s;
1500 {
1501 if (abfd->arelt_data == NULL)
1502 {
1503 bfd_set_error (bfd_error_invalid_operation);
1504 return -1;
1505 }
1506
1507 if (! xcoff_big_format_p (abfd))
1508 {
1509 struct xcoff_ar_hdr *hdrp = arch_xhdr (abfd);
1510
1511 s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
1512 s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
1513 s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
1514 s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
1515 s->st_size = arch_eltdata (abfd)->parsed_size;
1516 }
1517 else
1518 {
1519 struct xcoff_ar_hdr_big *hdrp = arch_xhdr_big (abfd);
1520
1521 s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
1522 s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
1523 s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
1524 s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
1525 s->st_size = arch_eltdata (abfd)->parsed_size;
1526 }
1527
1528 return 0;
1529 }
1530
1531 /* Normalize a file name for inclusion in an archive. */
1532
1533 static const char *
1534 normalize_filename (abfd)
1535 bfd *abfd;
1536 {
1537 const char *file;
1538 const char *filename;
1539
1540 file = bfd_get_filename (abfd);
1541 filename = strrchr (file, '/');
1542 if (filename != NULL)
1543 filename++;
1544 else
1545 filename = file;
1546 return filename;
1547 }
1548
1549 /* Write out an XCOFF armap. */
1550
1551 /*ARGSUSED*/
1552 static boolean
1553 xcoff_write_armap_old (abfd, elength, map, orl_count, stridx)
1554 bfd *abfd;
1555 unsigned int elength ATTRIBUTE_UNUSED;
1556 struct orl *map;
1557 unsigned int orl_count;
1558 int stridx;
1559 {
1560 struct xcoff_ar_hdr hdr;
1561 char *p;
1562 unsigned char buf[4];
1563 bfd *sub;
1564 file_ptr fileoff;
1565 unsigned int i;
1566
1567 memset (&hdr, 0, sizeof hdr);
1568 sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
1569 sprintf (hdr.nextoff, "%d", 0);
1570 memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, 12);
1571 sprintf (hdr.date, "%d", 0);
1572 sprintf (hdr.uid, "%d", 0);
1573 sprintf (hdr.gid, "%d", 0);
1574 sprintf (hdr.mode, "%d", 0);
1575 sprintf (hdr.namlen, "%d", 0);
1576
1577 /* We need spaces, not null bytes, in the header. */
1578 for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR; p++)
1579 if (*p == '\0')
1580 *p = ' ';
1581
1582 if (bfd_write ((PTR) &hdr, SIZEOF_AR_HDR, 1, abfd) != SIZEOF_AR_HDR
1583 || bfd_write (XCOFFARFMAG, 1, SXCOFFARFMAG, abfd) != SXCOFFARFMAG)
1584 return false;
1585
1586 bfd_h_put_32 (abfd, orl_count, buf);
1587 if (bfd_write (buf, 1, 4, abfd) != 4)
1588 return false;
1589
1590 sub = abfd->archive_head;
1591 fileoff = SIZEOF_AR_FILE_HDR;
1592 i = 0;
1593 while (sub != NULL && i < orl_count)
1594 {
1595 size_t namlen;
1596
1597 while (((bfd *) (map[i]).pos) == sub)
1598 {
1599 bfd_h_put_32 (abfd, fileoff, buf);
1600 if (bfd_write (buf, 1, 4, abfd) != 4)
1601 return false;
1602 ++i;
1603 }
1604 namlen = strlen (normalize_filename (sub));
1605 namlen = (namlen + 1) &~ 1;
1606 fileoff += (SIZEOF_AR_HDR
1607 + namlen
1608 + SXCOFFARFMAG
1609 + arelt_size (sub));
1610 fileoff = (fileoff + 1) &~ 1;
1611 sub = sub->next;
1612 }
1613
1614 for (i = 0; i < orl_count; i++)
1615 {
1616 const char *name;
1617 size_t namlen;
1618
1619 name = *map[i].name;
1620 namlen = strlen (name);
1621 if (bfd_write (name, 1, namlen + 1, abfd) != namlen + 1)
1622 return false;
1623 }
1624
1625 if ((stridx & 1) != 0)
1626 {
1627 char b;
1628
1629 b = '\0';
1630 if (bfd_write (&b, 1, 1, abfd) != 1)
1631 return false;
1632 }
1633
1634 return true;
1635 }
1636
1637 /* Write a single armap in the big format. */
1638 static boolean
1639 xcoff_write_one_armap_big (abfd, map, orl_count, orl_ccount, stridx, bits64,
1640 prevoff, nextoff)
1641 bfd *abfd;
1642 struct orl *map;
1643 unsigned int orl_count;
1644 unsigned int orl_ccount;
1645 unsigned int stridx;
1646 int bits64;
1647 const char *prevoff;
1648 char *nextoff;
1649 {
1650 struct xcoff_ar_hdr_big hdr;
1651 char *p;
1652 unsigned char buf[4];
1653 bfd *sub;
1654 file_ptr fileoff;
1655 const bfd_arch_info_type *arch_info;
1656 bfd *object_bfd;
1657 unsigned int i;
1658
1659 memset (&hdr, 0, sizeof hdr);
1660 /* XXX This call actually should use %lld (at least on 32-bit
1661 machines) since the fields's width is 20 and there numbers with
1662 more than 32 bits can be represented. */
1663 sprintf (hdr.size, "%ld", (long) (4 + orl_ccount * 4 + stridx));
1664 if (bits64)
1665 sprintf (hdr.nextoff, "%d", 0);
1666 else
1667 sprintf (hdr.nextoff, "%d", (strtol (prevoff, (char **) NULL, 10)
1668 + 4 + orl_ccount * 4 + stridx));
1669 memcpy (hdr.prevoff, prevoff, sizeof (hdr.prevoff));
1670 sprintf (hdr.date, "%d", 0);
1671 sprintf (hdr.uid, "%d", 0);
1672 sprintf (hdr.gid, "%d", 0);
1673 sprintf (hdr.mode, "%d", 0);
1674 sprintf (hdr.namlen, "%d", 0);
1675
1676 /* We need spaces, not null bytes, in the header. */
1677 for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR_BIG; p++)
1678 if (*p == '\0')
1679 *p = ' ';
1680
1681 memcpy (nextoff, hdr.nextoff, sizeof (hdr.nextoff));
1682
1683 if (bfd_write ((PTR) &hdr, SIZEOF_AR_HDR_BIG, 1, abfd) != SIZEOF_AR_HDR_BIG
1684 || bfd_write (XCOFFARFMAG, 1, SXCOFFARFMAG, abfd) != SXCOFFARFMAG)
1685 return false;
1686
1687 bfd_h_put_32 (abfd, orl_ccount, buf);
1688 if (bfd_write (buf, 1, 4, abfd) != 4)
1689 return false;
1690
1691 sub = abfd->archive_head;
1692 fileoff = SIZEOF_AR_FILE_HDR_BIG;
1693 i = 0;
1694 while (sub != NULL && i < orl_count)
1695 {
1696 size_t namlen;
1697
1698 if ((bfd_arch_bits_per_address ((bfd *) map[i].pos) == 64) == bits64)
1699 while (((bfd *) (map[i]).pos) == sub)
1700 {
1701 bfd_h_put_32 (abfd, fileoff, buf);
1702 if (bfd_write (buf, 1, 4, abfd) != 4)
1703 return false;
1704 i++;
1705 }
1706 else
1707 while (((bfd *) (map[i]).pos) == sub)
1708 i++;
1709
1710 namlen = strlen (normalize_filename (sub));
1711 namlen = (namlen + 1) &~ 1;
1712 fileoff += (SIZEOF_AR_HDR_BIG
1713 + namlen
1714 + SXCOFFARFMAG
1715 + arelt_size (sub));
1716 fileoff = (fileoff + 1) &~ 1;
1717 sub = sub->next;
1718 }
1719
1720 object_bfd = NULL;
1721 for (i = 0; i < orl_count; i++)
1722 {
1723 const char *name;
1724 size_t namlen;
1725 bfd *ob = (bfd *)map[i].pos;
1726
1727 if (ob != object_bfd)
1728 arch_info = bfd_get_arch_info (ob);
1729 if ((arch_info->bits_per_address == 64) != bits64)
1730 continue;
1731
1732 name = *map[i].name;
1733 namlen = strlen (name);
1734 if (bfd_write (name, 1, namlen + 1, abfd) != namlen + 1)
1735 return false;
1736 }
1737
1738 if ((stridx & 1) != 0)
1739 {
1740 char b;
1741
1742 b = '\0';
1743 if (bfd_write (&b, 1, 1, abfd) != 1)
1744 return false;
1745 }
1746
1747 return true;
1748 }
1749
1750 /*ARGSUSED*/
1751 static boolean
1752 xcoff_write_armap_big (abfd, elength, map, orl_count, stridx)
1753 bfd *abfd;
1754 unsigned int elength ATTRIBUTE_UNUSED;
1755 struct orl *map;
1756 unsigned int orl_count;
1757 int stridx;
1758 {
1759 unsigned int i;
1760 unsigned int orl_count_32, orl_count_64;
1761 unsigned int stridx_32, stridx_64;
1762 const bfd_arch_info_type *arch_info;
1763 bfd *object_bfd;
1764
1765 /* First, we look through the symbols and work out which are
1766 from 32-bit objects and which from 64-bit ones. */
1767 orl_count_32 = 0;
1768 orl_count_64 = 0;
1769 stridx_32 = 0;
1770 stridx_64 = 0;
1771 object_bfd = NULL;
1772 for (i = 0; i < orl_count; i++)
1773 {
1774 bfd *ob = (bfd *)map[i].pos;
1775 unsigned int len;
1776 if (ob != object_bfd)
1777 arch_info = bfd_get_arch_info (ob);
1778 len = strlen (*map[i].name) + 1;
1779 if (arch_info->bits_per_address == 64)
1780 {
1781 orl_count_64++;
1782 stridx_64 += len;
1783 }
1784 else
1785 {
1786 orl_count_32++;
1787 stridx_32 += len;
1788 }
1789 object_bfd = ob;
1790 }
1791 /* A quick sanity check... */
1792 BFD_ASSERT (orl_count_64 + orl_count_32 == orl_count);
1793 BFD_ASSERT (stridx_64 + stridx_32 == stridx);
1794
1795 /* Now write out each map. */
1796 if (! xcoff_write_one_armap_big (abfd, map, orl_count, orl_count_32,
1797 stridx_32, false,
1798 xcoff_ardata_big (abfd)->memoff,
1799 xcoff_ardata_big (abfd)->symoff))
1800 return false;
1801 if (! xcoff_write_one_armap_big (abfd, map, orl_count, orl_count_64,
1802 stridx_64, true,
1803 xcoff_ardata_big (abfd)->symoff,
1804 xcoff_ardata_big (abfd)->symoff64))
1805 return false;
1806
1807 return true;
1808 }
1809
1810 /*ARGSUSED*/
1811 boolean
1812 _bfd_xcoff_write_armap (abfd, elength, map, orl_count, stridx)
1813 bfd *abfd;
1814 unsigned int elength ATTRIBUTE_UNUSED;
1815 struct orl *map;
1816 unsigned int orl_count;
1817 int stridx;
1818 {
1819 if (! xcoff_big_format_p (abfd))
1820 return xcoff_write_armap_old (abfd, elength, map, orl_count, stridx);
1821 else
1822 return xcoff_write_armap_big (abfd, elength, map, orl_count, stridx);
1823 }
1824
1825 /* Write out an XCOFF archive. We always write an entire archive,
1826 rather than fussing with the freelist and so forth. */
1827
1828 static boolean
1829 xcoff_write_archive_contents_old (abfd)
1830 bfd *abfd;
1831 {
1832 struct xcoff_ar_file_hdr fhdr;
1833 size_t count;
1834 size_t total_namlen;
1835 file_ptr *offsets;
1836 boolean makemap;
1837 boolean hasobjects;
1838 file_ptr prevoff, nextoff;
1839 bfd *sub;
1840 unsigned int i;
1841 struct xcoff_ar_hdr ahdr;
1842 bfd_size_type size;
1843 char *p;
1844 char decbuf[13];
1845
1846 memset (&fhdr, 0, sizeof fhdr);
1847 strncpy (fhdr.magic, XCOFFARMAG, SXCOFFARMAG);
1848 sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR);
1849 sprintf (fhdr.freeoff, "%d", 0);
1850
1851 count = 0;
1852 total_namlen = 0;
1853 for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
1854 {
1855 ++count;
1856 total_namlen += strlen (normalize_filename (sub)) + 1;
1857 }
1858 offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
1859 if (offsets == NULL)
1860 return false;
1861
1862 if (bfd_seek (abfd, SIZEOF_AR_FILE_HDR, SEEK_SET) != 0)
1863 return false;
1864
1865 makemap = bfd_has_map (abfd);
1866 hasobjects = false;
1867 prevoff = 0;
1868 nextoff = SIZEOF_AR_FILE_HDR;
1869 for (sub = abfd->archive_head, i = 0; sub != NULL; sub = sub->next, i++)
1870 {
1871 const char *name;
1872 size_t namlen;
1873 struct xcoff_ar_hdr *ahdrp;
1874 bfd_size_type remaining;
1875
1876 if (makemap && ! hasobjects)
1877 {
1878 if (bfd_check_format (sub, bfd_object))
1879 hasobjects = true;
1880 }
1881
1882 name = normalize_filename (sub);
1883 namlen = strlen (name);
1884
1885 if (sub->arelt_data != NULL)
1886 ahdrp = arch_xhdr (sub);
1887 else
1888 ahdrp = NULL;
1889
1890 if (ahdrp == NULL)
1891 {
1892 struct stat s;
1893
1894 memset (&ahdr, 0, sizeof ahdr);
1895 ahdrp = &ahdr;
1896 if (stat (bfd_get_filename (sub), &s) != 0)
1897 {
1898 bfd_set_error (bfd_error_system_call);
1899 return false;
1900 }
1901
1902 sprintf (ahdrp->size, "%ld", (long) s.st_size);
1903 sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
1904 sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
1905 sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
1906 sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
1907
1908 if (sub->arelt_data == NULL)
1909 {
1910 sub->arelt_data = bfd_alloc (sub, sizeof (struct areltdata));
1911 if (sub->arelt_data == NULL)
1912 return false;
1913 }
1914
1915 arch_eltdata (sub)->parsed_size = s.st_size;
1916 }
1917
1918 sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
1919 sprintf (ahdrp->namlen, "%ld", (long) namlen);
1920
1921 /* If the length of the name is odd, we write out the null byte
1922 after the name as well. */
1923 namlen = (namlen + 1) &~ 1;
1924
1925 remaining = arelt_size (sub);
1926 size = (SIZEOF_AR_HDR
1927 + namlen
1928 + SXCOFFARFMAG
1929 + remaining);
1930
1931 BFD_ASSERT (nextoff == bfd_tell (abfd));
1932
1933 offsets[i] = nextoff;
1934
1935 prevoff = nextoff;
1936 nextoff += size + (size & 1);
1937
1938 sprintf (ahdrp->nextoff, "%ld", (long) nextoff);
1939
1940 /* We need spaces, not null bytes, in the header. */
1941 for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR; p++)
1942 if (*p == '\0')
1943 *p = ' ';
1944
1945 if (bfd_write ((PTR) ahdrp, 1, SIZEOF_AR_HDR, abfd) != SIZEOF_AR_HDR
1946 || bfd_write ((PTR) name, 1, namlen, abfd) != namlen
1947 || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
1948 != SXCOFFARFMAG))
1949 return false;
1950
1951 if (bfd_seek (sub, (file_ptr) 0, SEEK_SET) != 0)
1952 return false;
1953 while (remaining != 0)
1954 {
1955 bfd_size_type amt;
1956 bfd_byte buffer[DEFAULT_BUFFERSIZE];
1957
1958 amt = sizeof buffer;
1959 if (amt > remaining)
1960 amt = remaining;
1961 if (bfd_read (buffer, 1, amt, sub) != amt
1962 || bfd_write (buffer, 1, amt, abfd) != amt)
1963 return false;
1964 remaining -= amt;
1965 }
1966
1967 if ((size & 1) != 0)
1968 {
1969 bfd_byte b;
1970
1971 b = '\0';
1972 if (bfd_write (&b, 1, 1, abfd) != 1)
1973 return false;
1974 }
1975 }
1976
1977 sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
1978
1979 /* Write out the member table. */
1980
1981 BFD_ASSERT (nextoff == bfd_tell (abfd));
1982 sprintf (fhdr.memoff, "%ld", (long) nextoff);
1983
1984 memset (&ahdr, 0, sizeof ahdr);
1985 sprintf (ahdr.size, "%ld", (long) (12 + count * 12 + total_namlen));
1986 sprintf (ahdr.prevoff, "%ld", (long) prevoff);
1987 sprintf (ahdr.date, "%d", 0);
1988 sprintf (ahdr.uid, "%d", 0);
1989 sprintf (ahdr.gid, "%d", 0);
1990 sprintf (ahdr.mode, "%d", 0);
1991 sprintf (ahdr.namlen, "%d", 0);
1992
1993 size = (SIZEOF_AR_HDR
1994 + 12
1995 + count * 12
1996 + total_namlen
1997 + SXCOFFARFMAG);
1998
1999 prevoff = nextoff;
2000 nextoff += size + (size & 1);
2001
2002 if (makemap && hasobjects)
2003 sprintf (ahdr.nextoff, "%ld", (long) nextoff);
2004 else
2005 sprintf (ahdr.nextoff, "%d", 0);
2006
2007 /* We need spaces, not null bytes, in the header. */
2008 for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR; p++)
2009 if (*p == '\0')
2010 *p = ' ';
2011
2012 if (bfd_write ((PTR) &ahdr, 1, SIZEOF_AR_HDR, abfd) != SIZEOF_AR_HDR
2013 || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
2014 != SXCOFFARFMAG))
2015 return false;
2016
2017 sprintf (decbuf, "%-12ld", (long) count);
2018 if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
2019 return false;
2020 for (i = 0; i < count; i++)
2021 {
2022 sprintf (decbuf, "%-12ld", (long) offsets[i]);
2023 if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
2024 return false;
2025 }
2026 for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
2027 {
2028 const char *name;
2029 size_t namlen;
2030
2031 name = normalize_filename (sub);
2032 namlen = strlen (name);
2033 if (bfd_write ((PTR) name, 1, namlen + 1, abfd) != namlen + 1)
2034 return false;
2035 }
2036 if ((size & 1) != 0)
2037 {
2038 bfd_byte b;
2039
2040 b = '\0';
2041 if (bfd_write ((PTR) &b, 1, 1, abfd) != 1)
2042 return false;
2043 }
2044
2045 /* Write out the armap, if appropriate. */
2046
2047 if (! makemap || ! hasobjects)
2048 sprintf (fhdr.symoff, "%d", 0);
2049 else
2050 {
2051 BFD_ASSERT (nextoff == bfd_tell (abfd));
2052 sprintf (fhdr.symoff, "%ld", (long) nextoff);
2053 bfd_ardata (abfd)->tdata = (PTR) &fhdr;
2054 if (! _bfd_compute_and_write_armap (abfd, 0))
2055 return false;
2056 }
2057
2058 /* Write out the archive file header. */
2059
2060 /* We need spaces, not null bytes, in the header. */
2061 for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR; p++)
2062 if (*p == '\0')
2063 *p = ' ';
2064
2065 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2066 || (bfd_write ((PTR) &fhdr, SIZEOF_AR_FILE_HDR, 1, abfd) !=
2067 SIZEOF_AR_FILE_HDR))
2068 return false;
2069
2070 return true;
2071 }
2072
2073 static boolean
2074 xcoff_write_archive_contents_big (abfd)
2075 bfd *abfd;
2076 {
2077 struct xcoff_ar_file_hdr_big fhdr;
2078 size_t count;
2079 size_t total_namlen;
2080 file_ptr *offsets;
2081 boolean makemap;
2082 boolean hasobjects;
2083 file_ptr prevoff, nextoff;
2084 bfd *sub;
2085 unsigned int i;
2086 struct xcoff_ar_hdr_big ahdr;
2087 bfd_size_type size;
2088 char *p;
2089 char decbuf[13];
2090
2091 memset (&fhdr, 0, sizeof fhdr);
2092 strncpy (fhdr.magic, XCOFFARMAGBIG, SXCOFFARMAG);
2093 sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR_BIG);
2094 sprintf (fhdr.freeoff, "%d", 0);
2095
2096 count = 0;
2097 total_namlen = 0;
2098 for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
2099 {
2100 ++count;
2101 total_namlen += strlen (normalize_filename (sub)) + 1;
2102 }
2103 offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
2104 if (offsets == NULL)
2105 return false;
2106
2107 if (bfd_seek (abfd, SIZEOF_AR_FILE_HDR_BIG, SEEK_SET) != 0)
2108 return false;
2109
2110 makemap = bfd_has_map (abfd);
2111 hasobjects = false;
2112 prevoff = 0;
2113 nextoff = SIZEOF_AR_FILE_HDR_BIG;
2114 for (sub = abfd->archive_head, i = 0; sub != NULL; sub = sub->next, i++)
2115 {
2116 const char *name;
2117 size_t namlen;
2118 struct xcoff_ar_hdr_big *ahdrp;
2119 bfd_size_type remaining;
2120
2121 if (makemap && ! hasobjects)
2122 {
2123 if (bfd_check_format (sub, bfd_object))
2124 hasobjects = true;
2125 }
2126
2127 name = normalize_filename (sub);
2128 namlen = strlen (name);
2129
2130 if (sub->arelt_data != NULL)
2131 ahdrp = arch_xhdr_big (sub);
2132 else
2133 ahdrp = NULL;
2134
2135 if (ahdrp == NULL)
2136 {
2137 struct stat s;
2138
2139 memset (&ahdr, 0, sizeof ahdr);
2140 ahdrp = &ahdr;
2141 /* XXX This should actually be a call to stat64 (at least on
2142 32-bit machines). */
2143 if (stat (bfd_get_filename (sub), &s) != 0)
2144 {
2145 bfd_set_error (bfd_error_system_call);
2146 return false;
2147 }
2148
2149 /* XXX This call actually should use %lld (at least on 32-bit
2150 machines) since the fields's width is 20 and there numbers with
2151 more than 32 bits can be represented. */
2152 sprintf (ahdrp->size, "%ld", (long) s.st_size);
2153 sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
2154 sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
2155 sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
2156 sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
2157
2158 if (sub->arelt_data == NULL)
2159 {
2160 sub->arelt_data = bfd_alloc (sub, sizeof (struct areltdata));
2161 if (sub->arelt_data == NULL)
2162 return false;
2163 }
2164
2165 arch_eltdata (sub)->parsed_size = s.st_size;
2166 }
2167
2168 /* XXX These calls actually should use %lld (at least on 32-bit
2169 machines) since the fields's width is 20 and there numbers with
2170 more than 32 bits can be represented. */
2171 sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
2172 sprintf (ahdrp->namlen, "%ld", (long) namlen);
2173
2174 /* If the length of the name is odd, we write out the null byte
2175 after the name as well. */
2176 namlen = (namlen + 1) &~ 1;
2177
2178 remaining = arelt_size (sub);
2179 size = (SIZEOF_AR_HDR_BIG
2180 + namlen
2181 + SXCOFFARFMAG
2182 + remaining);
2183
2184 BFD_ASSERT (nextoff == bfd_tell (abfd));
2185
2186 offsets[i] = nextoff;
2187
2188 prevoff = nextoff;
2189 nextoff += size + (size & 1);
2190
2191 sprintf (ahdrp->nextoff, "%ld", (long) nextoff);
2192
2193 /* We need spaces, not null bytes, in the header. */
2194 for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR_BIG; p++)
2195 if (*p == '\0')
2196 *p = ' ';
2197
2198 if (bfd_write ((PTR) ahdrp, 1, SIZEOF_AR_HDR_BIG, abfd)
2199 != SIZEOF_AR_HDR_BIG
2200 || bfd_write ((PTR) name, 1, namlen, abfd) != namlen
2201 || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
2202 != SXCOFFARFMAG))
2203 return false;
2204
2205 if (bfd_seek (sub, (file_ptr) 0, SEEK_SET) != 0)
2206 return false;
2207 while (remaining != 0)
2208 {
2209 bfd_size_type amt;
2210 bfd_byte buffer[DEFAULT_BUFFERSIZE];
2211
2212 amt = sizeof buffer;
2213 if (amt > remaining)
2214 amt = remaining;
2215 if (bfd_read (buffer, 1, amt, sub) != amt
2216 || bfd_write (buffer, 1, amt, abfd) != amt)
2217 return false;
2218 remaining -= amt;
2219 }
2220
2221 if ((size & 1) != 0)
2222 {
2223 bfd_byte b;
2224
2225 b = '\0';
2226 if (bfd_write (&b, 1, 1, abfd) != 1)
2227 return false;
2228 }
2229 }
2230
2231 /* XXX This call actually should use %lld (at least on 32-bit
2232 machines) since the fields's width is 20 and there numbers with
2233 more than 32 bits can be represented. */
2234 sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
2235
2236 /* Write out the member table. */
2237
2238 BFD_ASSERT (nextoff == bfd_tell (abfd));
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 (fhdr.memoff, "%ld", (long) nextoff);
2243
2244 memset (&ahdr, 0, sizeof ahdr);
2245 /* XXX The next two calls actually should use %lld (at least on 32-bit
2246 machines) since the fields's width is 20 and there numbers with
2247 more than 32 bits can be represented. */
2248 sprintf (ahdr.size, "%ld", (long) (12 + count * 12 + total_namlen));
2249 sprintf (ahdr.prevoff, "%ld", (long) prevoff);
2250 sprintf (ahdr.date, "%d", 0);
2251 sprintf (ahdr.uid, "%d", 0);
2252 sprintf (ahdr.gid, "%d", 0);
2253 sprintf (ahdr.mode, "%d", 0);
2254 sprintf (ahdr.namlen, "%d", 0);
2255
2256 size = (SIZEOF_AR_HDR_BIG
2257 + 12
2258 + count * 12
2259 + total_namlen
2260 + SXCOFFARFMAG);
2261
2262 prevoff = nextoff;
2263 nextoff += size + (size & 1);
2264
2265 if (makemap && hasobjects)
2266 /* XXX This call actually should use %lld (at least on 32-bit
2267 machines) since the fields's width is 20 and there numbers with
2268 more than 32 bits can be represented. */
2269 sprintf (ahdr.nextoff, "%ld", (long) nextoff);
2270 else
2271 sprintf (ahdr.nextoff, "%d", 0);
2272
2273 /* We need spaces, not null bytes, in the header. */
2274 for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR_BIG; p++)
2275 if (*p == '\0')
2276 *p = ' ';
2277
2278 if (bfd_write ((PTR) &ahdr, 1, SIZEOF_AR_HDR_BIG, abfd) != SIZEOF_AR_HDR_BIG
2279 || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
2280 != SXCOFFARFMAG))
2281 return false;
2282
2283 sprintf (decbuf, "%-12ld", (long) count);
2284 if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
2285 return false;
2286 for (i = 0; i < count; i++)
2287 {
2288 sprintf (decbuf, "%-12ld", (long) offsets[i]);
2289 if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
2290 return false;
2291 }
2292 for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
2293 {
2294 const char *name;
2295 size_t namlen;
2296
2297 name = normalize_filename (sub);
2298 namlen = strlen (name);
2299 if (bfd_write ((PTR) name, 1, namlen + 1, abfd) != namlen + 1)
2300 return false;
2301 }
2302 if ((size & 1) != 0)
2303 {
2304 bfd_byte b;
2305
2306 b = '\0';
2307 if (bfd_write ((PTR) &b, 1, 1, abfd) != 1)
2308 return false;
2309 }
2310
2311 /* Write out the armap, if appropriate. */
2312
2313 if (! makemap || ! hasobjects)
2314 sprintf (fhdr.symoff, "%d", 0);
2315 else
2316 {
2317 BFD_ASSERT (nextoff == bfd_tell (abfd));
2318 /* XXX This call actually should use %lld (at least on 32-bit
2319 machines) since the fields's width is 20 and there numbers with
2320 more than 32 bits can be represented. */
2321 bfd_ardata (abfd)->tdata = (PTR) &fhdr;
2322 if (! _bfd_compute_and_write_armap (abfd, 0))
2323 return false;
2324 }
2325
2326 /* Write out the archive file header. */
2327
2328 /* We need spaces, not null bytes, in the header. */
2329 for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR_BIG; p++)
2330 if (*p == '\0')
2331 *p = ' ';
2332
2333 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2334 || (bfd_write ((PTR) &fhdr, SIZEOF_AR_FILE_HDR_BIG, 1, abfd) !=
2335 SIZEOF_AR_FILE_HDR_BIG))
2336 return false;
2337
2338 return true;
2339 }
2340
2341 boolean
2342 _bfd_xcoff_write_archive_contents (abfd)
2343 bfd *abfd;
2344 {
2345 if (! xcoff_big_format_p (abfd))
2346 return xcoff_write_archive_contents_old (abfd);
2347 else
2348 return xcoff_write_archive_contents_big (abfd);
2349 }
2350 \f
2351 /* We can't use the usual coff_sizeof_headers routine, because AIX
2352 always uses an a.out header. */
2353
2354 /*ARGSUSED*/
2355 int
2356 _bfd_xcoff_sizeof_headers (abfd, reloc)
2357 bfd *abfd;
2358 boolean reloc ATTRIBUTE_UNUSED;
2359 {
2360 int size;
2361
2362 size = FILHSZ;
2363 if (xcoff_data (abfd)->full_aouthdr)
2364 size += AOUTSZ;
2365 else
2366 size += SMALL_AOUTSZ;
2367 size += abfd->section_count * SCNHSZ;
2368 return size;
2369 }
2370 \f
2371
GDB Binutils - Deliverables
This page took 0.101998 seconds and 4 git commands to generate.