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