OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [bfd/] [coff-rs6000.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.