projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* Makefile.am (PROGS,bin_PROGRAMS): Add @BUILD_MISC@
[deliverable/binutils-gdb.git] / bfd / coff-rs6000.c
1 /* BFD back-end for IBM RS/6000 "XCOFF" files.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
3 FIXME: Can someone provide a transliteration of this name into ASCII?
4 Using the following chars caused a compiler warning on HIUX (so I replaced
5 them with octal escapes), and isn't useful without an understanding of what
6 character set it is.
7 Written by Metin G. Ozisik, Mimi Ph\373\364ng-Th\345o V\365,
8 and John Gilmore.
9 Archive support from Damon A. Permezel.
10 Contributed by IBM Corporation and Cygnus Support.
11
12 This file is part of BFD, the Binary File Descriptor library.
13
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
18
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27
28 /* Internalcoff.h and coffcode.h modify themselves based on this flag. */
29 #define RS6000COFF_C 1
30
31 #include "bfd.h"
32 #include "sysdep.h"
33 #include "libbfd.h"
34 #include "coff/internal.h"
35 #include "coff/rs6000.h"
36 #include "libcoff.h"
37
38 /* The main body of code is in coffcode.h. */
39
40 static boolean xcoff_mkobject PARAMS ((bfd *));
41 static boolean xcoff_copy_private_bfd_data PARAMS ((bfd *, bfd *));
42 static boolean xcoff_is_local_label_name PARAMS ((bfd *, const char *));
43 static void xcoff_rtype2howto
44 PARAMS ((arelent *, struct internal_reloc *));
45 static reloc_howto_type *xcoff_reloc_type_lookup
46 PARAMS ((bfd *, bfd_reloc_code_real_type));
47 static boolean xcoff_slurp_armap PARAMS ((bfd *));
48 static const bfd_target *xcoff_archive_p PARAMS ((bfd *));
49 static PTR xcoff_read_ar_hdr PARAMS ((bfd *));
50 static bfd *xcoff_openr_next_archived_file PARAMS ((bfd *, bfd *));
51 static int xcoff_generic_stat_arch_elt PARAMS ((bfd *, struct stat *));
52 static const char *normalize_filename PARAMS ((bfd *));
53 static boolean xcoff_write_armap
54 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int));
55 static boolean xcoff_write_archive_contents PARAMS ((bfd *));
56 \f
57 /* We use our own tdata type. Its first field is the COFF tdata type,
58 so the COFF routines are compatible. */
59
60 static boolean
61 xcoff_mkobject (abfd)
62 bfd *abfd;
63 {
64 coff_data_type *coff;
65
66 abfd->tdata.xcoff_obj_data =
67 ((struct xcoff_tdata *)
68 bfd_zalloc (abfd, sizeof (struct xcoff_tdata)));
69 if (abfd->tdata.xcoff_obj_data == NULL)
70 return false;
71 coff = coff_data (abfd);
72 coff->symbols = (coff_symbol_type *) NULL;
73 coff->conversion_table = (unsigned int *) NULL;
74 coff->raw_syments = (struct coff_ptr_struct *) NULL;
75 coff->relocbase = 0;
76
77 xcoff_data (abfd)->modtype = ('1' << 8) | 'L';
78
79 /* We set cputype to -1 to indicate that it has not been
80 initialized. */
81 xcoff_data (abfd)->cputype = -1;
82
83 xcoff_data (abfd)->csects = NULL;
84 xcoff_data (abfd)->debug_indices = NULL;
85
86 return true;
87 }
88
89 /* Copy XCOFF data from one BFD to another. */
90
91 static boolean
92 xcoff_copy_private_bfd_data (ibfd, obfd)
93 bfd *ibfd;
94 bfd *obfd;
95 {
96 struct xcoff_tdata *ix, *ox;
97 asection *sec;
98
99 if (ibfd->xvec != obfd->xvec)
100 return true;
101 ix = xcoff_data (ibfd);
102 ox = xcoff_data (obfd);
103 ox->full_aouthdr = ix->full_aouthdr;
104 ox->toc = ix->toc;
105 if (ix->sntoc == 0)
106 ox->sntoc = 0;
107 else
108 {
109 sec = coff_section_from_bfd_index (ibfd, ix->sntoc);
110 if (sec == NULL)
111 ox->sntoc = 0;
112 else
113 ox->sntoc = sec->output_section->target_index;
114 }
115 if (ix->snentry == 0)
116 ox->snentry = 0;
117 else
118 {
119 sec = coff_section_from_bfd_index (ibfd, ix->snentry);
120 if (sec == NULL)
121 ox->snentry = 0;
122 else
123 ox->snentry = sec->output_section->target_index;
124 }
125 ox->text_align_power = ix->text_align_power;
126 ox->data_align_power = ix->data_align_power;
127 ox->modtype = ix->modtype;
128 ox->cputype = ix->cputype;
129 ox->maxdata = ix->maxdata;
130 ox->maxstack = ix->maxstack;
131 return true;
132 }
133
134 /* I don't think XCOFF really has a notion of local labels based on
135 name. This will mean that ld -X doesn't actually strip anything.
136 The AIX native linker does not have a -X option, and it ignores the
137 -x option. */
138
139 static boolean
140 xcoff_is_local_label_name (abfd, name)
141 bfd *abfd;
142 const char *name;
143 {
144 return false;
145 }
146 \f
147 /* The XCOFF reloc table. Actually, XCOFF relocations specify the
148 bitsize and whether they are signed or not, along with a
149 conventional type. This table is for the types, which are used for
150 different algorithms for putting in the reloc. Many of these
151 relocs need special_function entries, which I have not written. */
152
153 static reloc_howto_type xcoff_howto_table[] =
154 {
155 /* Standard 32 bit relocation. */
156 HOWTO (0, /* type */
157 0, /* rightshift */
158 2, /* size (0 = byte, 1 = short, 2 = long) */
159 32, /* bitsize */
160 false, /* pc_relative */
161 0, /* bitpos */
162 complain_overflow_bitfield, /* complain_on_overflow */
163 0, /* special_function */
164 "R_POS", /* name */
165 true, /* partial_inplace */
166 0xffffffff, /* src_mask */
167 0xffffffff, /* dst_mask */
168 false), /* pcrel_offset */
169
170 /* 32 bit relocation, but store negative value. */
171 HOWTO (1, /* type */
172 0, /* rightshift */
173 -2, /* size (0 = byte, 1 = short, 2 = long) */
174 32, /* bitsize */
175 false, /* pc_relative */
176 0, /* bitpos */
177 complain_overflow_bitfield, /* complain_on_overflow */
178 0, /* special_function */
179 "R_NEG", /* name */
180 true, /* partial_inplace */
181 0xffffffff, /* src_mask */
182 0xffffffff, /* dst_mask */
183 false), /* pcrel_offset */
184
185 /* 32 bit PC relative relocation. */
186 HOWTO (2, /* type */
187 0, /* rightshift */
188 2, /* size (0 = byte, 1 = short, 2 = long) */
189 32, /* bitsize */
190 true, /* pc_relative */
191 0, /* bitpos */
192 complain_overflow_signed, /* complain_on_overflow */
193 0, /* special_function */
194 "R_REL", /* name */
195 true, /* partial_inplace */
196 0xffffffff, /* src_mask */
197 0xffffffff, /* dst_mask */
198 false), /* pcrel_offset */
199
200 /* 16 bit TOC relative relocation. */
201 HOWTO (3, /* type */
202 0, /* rightshift */
203 1, /* size (0 = byte, 1 = short, 2 = long) */
204 16, /* bitsize */
205 false, /* pc_relative */
206 0, /* bitpos */
207 complain_overflow_bitfield, /* complain_on_overflow */
208 0, /* special_function */
209 "R_TOC", /* name */
210 true, /* partial_inplace */
211 0xffff, /* src_mask */
212 0xffff, /* dst_mask */
213 false), /* pcrel_offset */
214
215 /* I don't really know what this is. */
216 HOWTO (4, /* type */
217 1, /* rightshift */
218 2, /* size (0 = byte, 1 = short, 2 = long) */
219 32, /* bitsize */
220 false, /* pc_relative */
221 0, /* bitpos */
222 complain_overflow_bitfield, /* complain_on_overflow */
223 0, /* special_function */
224 "R_RTB", /* name */
225 true, /* partial_inplace */
226 0xffffffff, /* src_mask */
227 0xffffffff, /* dst_mask */
228 false), /* pcrel_offset */
229
230 /* External TOC relative symbol. */
231 HOWTO (5, /* type */
232 0, /* rightshift */
233 2, /* size (0 = byte, 1 = short, 2 = long) */
234 16, /* bitsize */
235 false, /* pc_relative */
236 0, /* bitpos */
237 complain_overflow_bitfield, /* complain_on_overflow */
238 0, /* special_function */
239 "R_GL", /* name */
240 true, /* partial_inplace */
241 0xffff, /* src_mask */
242 0xffff, /* dst_mask */
243 false), /* pcrel_offset */
244
245 /* Local TOC relative symbol. */
246 HOWTO (6, /* type */
247 0, /* rightshift */
248 2, /* size (0 = byte, 1 = short, 2 = long) */
249 16, /* bitsize */
250 false, /* pc_relative */
251 0, /* bitpos */
252 complain_overflow_bitfield, /* complain_on_overflow */
253 0, /* special_function */
254 "R_TCL", /* name */
255 true, /* partial_inplace */
256 0xffff, /* src_mask */
257 0xffff, /* dst_mask */
258 false), /* pcrel_offset */
259
260 { 7 },
261
262 /* Non modifiable absolute branch. */
263 HOWTO (8, /* type */
264 0, /* rightshift */
265 2, /* size (0 = byte, 1 = short, 2 = long) */
266 26, /* bitsize */
267 false, /* pc_relative */
268 0, /* bitpos */
269 complain_overflow_bitfield, /* complain_on_overflow */
270 0, /* special_function */
271 "R_BA", /* name */
272 true, /* partial_inplace */
273 0x3fffffc, /* src_mask */
274 0x3fffffc, /* dst_mask */
275 false), /* pcrel_offset */
276
277 { 9 },
278
279 /* Non modifiable relative branch. */
280 HOWTO (0xa, /* type */
281 0, /* rightshift */
282 2, /* size (0 = byte, 1 = short, 2 = long) */
283 26, /* bitsize */
284 true, /* pc_relative */
285 0, /* bitpos */
286 complain_overflow_signed, /* complain_on_overflow */
287 0, /* special_function */
288 "R_BR", /* name */
289 true, /* partial_inplace */
290 0x3fffffc, /* src_mask */
291 0x3fffffc, /* dst_mask */
292 false), /* pcrel_offset */
293
294 { 0xb },
295
296 /* Indirect load. */
297 HOWTO (0xc, /* type */
298 0, /* rightshift */
299 2, /* size (0 = byte, 1 = short, 2 = long) */
300 16, /* bitsize */
301 false, /* pc_relative */
302 0, /* bitpos */
303 complain_overflow_bitfield, /* complain_on_overflow */
304 0, /* special_function */
305 "R_RL", /* name */
306 true, /* partial_inplace */
307 0xffff, /* src_mask */
308 0xffff, /* dst_mask */
309 false), /* pcrel_offset */
310
311 /* Load address. */
312 HOWTO (0xd, /* type */
313 0, /* rightshift */
314 2, /* size (0 = byte, 1 = short, 2 = long) */
315 16, /* bitsize */
316 false, /* pc_relative */
317 0, /* bitpos */
318 complain_overflow_bitfield, /* complain_on_overflow */
319 0, /* special_function */
320 "R_RLA", /* name */
321 true, /* partial_inplace */
322 0xffff, /* src_mask */
323 0xffff, /* dst_mask */
324 false), /* pcrel_offset */
325
326 { 0xe },
327
328 /* Non-relocating reference. */
329 HOWTO (0xf, /* type */
330 0, /* rightshift */
331 2, /* size (0 = byte, 1 = short, 2 = long) */
332 32, /* bitsize */
333 false, /* pc_relative */
334 0, /* bitpos */
335 complain_overflow_bitfield, /* complain_on_overflow */
336 0, /* special_function */
337 "R_REF", /* name */
338 false, /* partial_inplace */
339 0, /* src_mask */
340 0, /* dst_mask */
341 false), /* pcrel_offset */
342
343 { 0x10 },
344 { 0x11 },
345
346 /* TOC relative indirect load. */
347 HOWTO (0x12, /* type */
348 0, /* rightshift */
349 2, /* size (0 = byte, 1 = short, 2 = long) */
350 16, /* bitsize */
351 false, /* pc_relative */
352 0, /* bitpos */
353 complain_overflow_bitfield, /* complain_on_overflow */
354 0, /* special_function */
355 "R_TRL", /* name */
356 true, /* partial_inplace */
357 0xffff, /* src_mask */
358 0xffff, /* dst_mask */
359 false), /* pcrel_offset */
360
361 /* TOC relative load address. */
362 HOWTO (0x13, /* type */
363 0, /* rightshift */
364 2, /* size (0 = byte, 1 = short, 2 = long) */
365 16, /* bitsize */
366 false, /* pc_relative */
367 0, /* bitpos */
368 complain_overflow_bitfield, /* complain_on_overflow */
369 0, /* special_function */
370 "R_TRLA", /* name */
371 true, /* partial_inplace */
372 0xffff, /* src_mask */
373 0xffff, /* dst_mask */
374 false), /* pcrel_offset */
375
376 /* Modifiable relative branch. */
377 HOWTO (0x14, /* type */
378 1, /* rightshift */
379 2, /* size (0 = byte, 1 = short, 2 = long) */
380 32, /* bitsize */
381 false, /* pc_relative */
382 0, /* bitpos */
383 complain_overflow_bitfield, /* complain_on_overflow */
384 0, /* special_function */
385 "R_RRTBI", /* name */
386 true, /* partial_inplace */
387 0xffffffff, /* src_mask */
388 0xffffffff, /* dst_mask */
389 false), /* pcrel_offset */
390
391 /* Modifiable absolute branch. */
392 HOWTO (0x15, /* type */
393 1, /* rightshift */
394 2, /* size (0 = byte, 1 = short, 2 = long) */
395 32, /* bitsize */
396 false, /* pc_relative */
397 0, /* bitpos */
398 complain_overflow_bitfield, /* complain_on_overflow */
399 0, /* special_function */
400 "R_RRTBA", /* name */
401 true, /* partial_inplace */
402 0xffffffff, /* src_mask */
403 0xffffffff, /* dst_mask */
404 false), /* pcrel_offset */
405
406 /* Modifiable call absolute indirect. */
407 HOWTO (0x16, /* type */
408 0, /* rightshift */
409 2, /* size (0 = byte, 1 = short, 2 = long) */
410 16, /* bitsize */
411 false, /* pc_relative */
412 0, /* bitpos */
413 complain_overflow_bitfield, /* complain_on_overflow */
414 0, /* special_function */
415 "R_CAI", /* name */
416 true, /* partial_inplace */
417 0xffff, /* src_mask */
418 0xffff, /* dst_mask */
419 false), /* pcrel_offset */
420
421 /* Modifiable call relative. */
422 HOWTO (0x17, /* type */
423 0, /* rightshift */
424 2, /* size (0 = byte, 1 = short, 2 = long) */
425 16, /* bitsize */
426 false, /* pc_relative */
427 0, /* bitpos */
428 complain_overflow_bitfield, /* complain_on_overflow */
429 0, /* special_function */
430 "R_CREL", /* name */
431 true, /* partial_inplace */
432 0xffff, /* src_mask */
433 0xffff, /* dst_mask */
434 false), /* pcrel_offset */
435
436 /* Modifiable branch absolute. */
437 HOWTO (0x18, /* type */
438 0, /* rightshift */
439 2, /* size (0 = byte, 1 = short, 2 = long) */
440 16, /* bitsize */
441 false, /* pc_relative */
442 0, /* bitpos */
443 complain_overflow_bitfield, /* complain_on_overflow */
444 0, /* special_function */
445 "R_RBA", /* name */
446 true, /* partial_inplace */
447 0xffff, /* src_mask */
448 0xffff, /* dst_mask */
449 false), /* pcrel_offset */
450
451 /* Modifiable branch absolute. */
452 HOWTO (0x19, /* type */
453 0, /* rightshift */
454 2, /* size (0 = byte, 1 = short, 2 = long) */
455 16, /* bitsize */
456 false, /* pc_relative */
457 0, /* bitpos */
458 complain_overflow_bitfield, /* complain_on_overflow */
459 0, /* special_function */
460 "R_RBAC", /* name */
461 true, /* partial_inplace */
462 0xffff, /* src_mask */
463 0xffff, /* dst_mask */
464 false), /* pcrel_offset */
465
466 /* Modifiable branch relative. */
467 HOWTO (0x1a, /* type */
468 0, /* rightshift */
469 2, /* size (0 = byte, 1 = short, 2 = long) */
470 26, /* bitsize */
471 false, /* pc_relative */
472 0, /* bitpos */
473 complain_overflow_signed, /* complain_on_overflow */
474 0, /* special_function */
475 "R_RBR", /* name */
476 true, /* partial_inplace */
477 0xffff, /* src_mask */
478 0xffff, /* dst_mask */
479 false), /* pcrel_offset */
480
481 /* Modifiable branch absolute. */
482 HOWTO (0x1b, /* type */
483 0, /* rightshift */
484 2, /* size (0 = byte, 1 = short, 2 = long) */
485 16, /* bitsize */
486 false, /* pc_relative */
487 0, /* bitpos */
488 complain_overflow_bitfield, /* complain_on_overflow */
489 0, /* special_function */
490 "R_RBRC", /* name */
491 true, /* partial_inplace */
492 0xffff, /* src_mask */
493 0xffff, /* dst_mask */
494 false) /* pcrel_offset */
495 };
496
497 static void
498 xcoff_rtype2howto (relent, internal)
499 arelent *relent;
500 struct internal_reloc *internal;
501 {
502 relent->howto = xcoff_howto_table + internal->r_type;
503
504 /* The r_size field of an XCOFF reloc encodes the bitsize of the
505 relocation, as well as indicating whether it is signed or not.
506 Doublecheck that the relocation information gathered from the
507 type matches this information. */
508 if (relent->howto->bitsize != ((unsigned int) internal->r_size & 0x1f) + 1)
509 abort ();
510 #if 0
511 if ((internal->r_size & 0x80) != 0
512 ? (relent->howto->complain_on_overflow != complain_overflow_signed)
513 : (relent->howto->complain_on_overflow != complain_overflow_bitfield))
514 abort ();
515 #endif
516 }
517
518 static reloc_howto_type *
519 xcoff_reloc_type_lookup (abfd, code)
520 bfd *abfd;
521 bfd_reloc_code_real_type code;
522 {
523 switch (code)
524 {
525 case BFD_RELOC_PPC_B26:
526 return &xcoff_howto_table[0xa];
527 case BFD_RELOC_PPC_BA26:
528 return &xcoff_howto_table[8];
529 case BFD_RELOC_PPC_TOC16:
530 return &xcoff_howto_table[3];
531 case BFD_RELOC_32:
532 case BFD_RELOC_CTOR:
533 return &xcoff_howto_table[0];
534 default:
535 return NULL;
536 }
537 }
538
539 #define SELECT_RELOC(internal, howto) \
540 { \
541 internal.r_type = howto->type; \
542 internal.r_size = \
543 ((howto->complain_on_overflow == complain_overflow_signed \
544 ? 0x80 \
545 : 0) \
546 | (howto->bitsize - 1)); \
547 }
548 \f
549 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
550
551 #define COFF_LONG_FILENAMES
552
553 #define RTYPE2HOWTO(cache_ptr, dst) xcoff_rtype2howto (cache_ptr, dst)
554
555 #define coff_mkobject xcoff_mkobject
556 #define coff_bfd_copy_private_bfd_data xcoff_copy_private_bfd_data
557 #define coff_bfd_is_local_label_name xcoff_is_local_label_name
558 #define coff_bfd_reloc_type_lookup xcoff_reloc_type_lookup
559 #define coff_relocate_section _bfd_ppc_xcoff_relocate_section
560
561 #include "coffcode.h"
562 \f
563 /* XCOFF archive support. The original version of this code was by
564 Damon A. Permezel. It was enhanced to permit cross support, and
565 writing archive files, by Ian Lance Taylor, Cygnus Support.
566
567 XCOFF uses its own archive format. Everything is hooked together
568 with file offset links, so it is possible to rapidly update an
569 archive in place. Of course, we don't do that. An XCOFF archive
570 has a real file header, not just an ARMAG string. The structure of
571 the file header and of each archive header appear below.
572
573 An XCOFF archive also has a member table, which is a list of
574 elements in the archive (you can get that by looking through the
575 linked list, but you have to read a lot more of the file). The
576 member table has a normal archive header with an empty name. It is
577 normally (and perhaps must be) the second to last entry in the
578 archive. The member table data is almost printable ASCII. It
579 starts with a 12 character decimal string which is the number of
580 entries in the table. For each entry it has a 12 character decimal
581 string which is the offset in the archive of that member. These
582 entries are followed by a series of null terminated strings which
583 are the member names for each entry.
584
585 Finally, an XCOFF archive has a global symbol table, which is what
586 we call the armap. The global symbol table has a normal archive
587 header with an empty name. It is normally (and perhaps must be)
588 the last entry in the archive. The contents start with a four byte
589 binary number which is the number of entries. This is followed by
590 a that many four byte binary numbers; each is the file offset of an
591 entry in the archive. These numbers are followed by a series of
592 null terminated strings, which are symbol names. */
593
594 /* XCOFF archives use this as a magic string. */
595
596 #define XCOFFARMAG "<aiaff>\012"
597 #define SXCOFFARMAG 8
598
599 /* This terminates an XCOFF archive member name. */
600
601 #define XCOFFARFMAG "`\012"
602 #define SXCOFFARFMAG 2
603
604 /* XCOFF archives start with this (printable) structure. */
605
606 struct xcoff_ar_file_hdr
607 {
608 /* Magic string. */
609 char magic[SXCOFFARMAG];
610
611 /* Offset of the member table (decimal ASCII string). */
612 char memoff[12];
613
614 /* Offset of the global symbol table (decimal ASCII string). */
615 char symoff[12];
616
617 /* Offset of the first member in the archive (decimal ASCII string). */
618 char firstmemoff[12];
619
620 /* Offset of the last member in the archive (decimal ASCII string). */
621 char lastmemoff[12];
622
623 /* Offset of the first member on the free list (decimal ASCII
624 string). */
625 char freeoff[12];
626 };
627
628 #define SIZEOF_AR_FILE_HDR (5 * 12 + SXCOFFARMAG)
629
630 /* Each XCOFF archive member starts with this (printable) structure. */
631
632 struct xcoff_ar_hdr
633 {
634 /* File size not including the header (decimal ASCII string). */
635 char size[12];
636
637 /* File offset of next archive member (decimal ASCII string). */
638 char nextoff[12];
639
640 /* File offset of previous archive member (decimal ASCII string). */
641 char prevoff[12];
642
643 /* File mtime (decimal ASCII string). */
644 char date[12];
645
646 /* File UID (decimal ASCII string). */
647 char uid[12];
648
649 /* File GID (decimal ASCII string). */
650 char gid[12];
651
652 /* File mode (octal ASCII string). */
653 char mode[12];
654
655 /* Length of file name (decimal ASCII string). */
656 char namlen[4];
657
658 /* This structure is followed by the file name. The length of the
659 name is given in the namlen field. If the length of the name is
660 odd, the name is followed by a null byte. The name and optional
661 null byte are followed by XCOFFARFMAG, which is not included in
662 namlen. The contents of the archive member follow; the number of
663 bytes is given in the size field. */
664 };
665
666 #define SIZEOF_AR_HDR (7 * 12 + 4)
667
668 /* We store a copy of the xcoff_ar_file_hdr in the tdata field of the
669 artdata structure. */
670 #define xcoff_ardata(abfd) \
671 ((struct xcoff_ar_file_hdr *) bfd_ardata (abfd)->tdata)
672
673 /* We store a copy of the xcoff_ar_hdr in the arelt_data field of an
674 archive element. */
675 #define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
676 #define arch_xhdr(bfd) \
677 ((struct xcoff_ar_hdr *) arch_eltdata (bfd)->arch_header)
678
679 /* XCOFF archives do not have anything which corresponds to an
680 extended name table. */
681
682 #define xcoff_slurp_extended_name_table bfd_false
683 #define xcoff_construct_extended_name_table \
684 ((boolean (*) PARAMS ((bfd *, char **, bfd_size_type *, const char **))) \
685 bfd_false)
686 #define xcoff_truncate_arname bfd_dont_truncate_arname
687
688 /* We can use the standard get_elt_at_index routine. */
689
690 #define xcoff_get_elt_at_index _bfd_generic_get_elt_at_index
691
692 /* XCOFF archives do not have a timestamp. */
693
694 #define xcoff_update_armap_timestamp bfd_true
695
696 /* Read in the armap of an XCOFF archive. */
697
698 static boolean
699 xcoff_slurp_armap (abfd)
700 bfd *abfd;
701 {
702 file_ptr off;
703 struct xcoff_ar_hdr hdr;
704 size_t namlen;
705 bfd_size_type sz;
706 bfd_byte *contents, *cend;
707 unsigned int c, i;
708 carsym *arsym;
709 bfd_byte *p;
710
711 if (xcoff_ardata (abfd) == NULL)
712 {
713 bfd_has_map (abfd) = false;
714 return true;
715 }
716
717 off = strtol (xcoff_ardata (abfd)->symoff, (char **) NULL, 10);
718 if (off == 0)
719 {
720 bfd_has_map (abfd) = false;
721 return true;
722 }
723
724 if (bfd_seek (abfd, off, SEEK_SET) != 0)
725 return false;
726
727 /* The symbol table starts with a normal archive header. */
728 if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR, 1, abfd) != SIZEOF_AR_HDR)
729 return false;
730
731 /* Skip the name (normally empty). */
732 namlen = strtol (hdr.namlen, (char **) NULL, 10);
733 if (bfd_seek (abfd, ((namlen + 1) & ~1) + SXCOFFARFMAG, SEEK_CUR) != 0)
734 return false;
735
736 /* Read in the entire symbol table. */
737 sz = strtol (hdr.size, (char **) NULL, 10);
738 contents = (bfd_byte *) bfd_alloc (abfd, sz);
739 if (contents == NULL)
740 return false;
741 if (bfd_read ((PTR) contents, 1, sz, abfd) != sz)
742 return false;
743
744 /* The symbol table starts with a four byte count. */
745 c = bfd_h_get_32 (abfd, contents);
746
747 if (c * 4 >= sz)
748 {
749 bfd_set_error (bfd_error_bad_value);
750 return false;
751 }
752
753 bfd_ardata (abfd)->symdefs = ((carsym *)
754 bfd_alloc (abfd, c * sizeof (carsym)));
755 if (bfd_ardata (abfd)->symdefs == NULL)
756 return false;
757
758 /* After the count comes a list of four byte file offsets. */
759 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 4;
760 i < c;
761 ++i, ++arsym, p += 4)
762 arsym->file_offset = bfd_h_get_32 (abfd, p);
763
764 /* After the file offsets come null terminated symbol names. */
765 cend = contents + sz;
766 for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
767 i < c;
768 ++i, ++arsym, p += strlen ((char *) p) + 1)
769 {
770 if (p >= cend)
771 {
772 bfd_set_error (bfd_error_bad_value);
773 return false;
774 }
775 arsym->name = (char *) p;
776 }
777
778 bfd_ardata (abfd)->symdef_count = c;
779 bfd_has_map (abfd) = true;
780
781 return true;
782 }
783
784 /* See if this is an XCOFF archive. */
785
786 static const bfd_target *
787 xcoff_archive_p (abfd)
788 bfd *abfd;
789 {
790 struct xcoff_ar_file_hdr hdr;
791
792 if (bfd_read ((PTR) &hdr, SIZEOF_AR_FILE_HDR, 1, abfd)
793 != SIZEOF_AR_FILE_HDR)
794 {
795 if (bfd_get_error () != bfd_error_system_call)
796 bfd_set_error (bfd_error_wrong_format);
797 return NULL;
798 }
799
800 if (strncmp (hdr.magic, XCOFFARMAG, SXCOFFARMAG) != 0)
801 {
802 bfd_set_error (bfd_error_wrong_format);
803 return NULL;
804 }
805
806 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
807 involves a cast, we can't do it as the left operand of
808 assignment. */
809 abfd->tdata.aout_ar_data =
810 (struct artdata *) bfd_zalloc (abfd, sizeof (struct artdata));
811
812 if (bfd_ardata (abfd) == (struct artdata *) NULL)
813 return NULL;
814
815 bfd_ardata (abfd)->first_file_filepos = strtol (hdr.firstmemoff,
816 (char **) NULL, 10);
817 bfd_ardata (abfd)->cache = NULL;
818 bfd_ardata (abfd)->archive_head = NULL;
819 bfd_ardata (abfd)->symdefs = NULL;
820 bfd_ardata (abfd)->extended_names = NULL;
821
822 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, SIZEOF_AR_FILE_HDR);
823 if (bfd_ardata (abfd)->tdata == NULL)
824 return NULL;
825
826 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR);
827
828 if (! xcoff_slurp_armap (abfd))
829 {
830 bfd_release (abfd, bfd_ardata (abfd));
831 abfd->tdata.aout_ar_data = (struct artdata *) NULL;
832 return NULL;
833 }
834
835 return abfd->xvec;
836 }
837
838 /* Read the archive header in an XCOFF archive. */
839
840 static PTR
841 xcoff_read_ar_hdr (abfd)
842 bfd *abfd;
843 {
844 struct xcoff_ar_hdr hdr;
845 size_t namlen;
846 struct xcoff_ar_hdr *hdrp;
847 struct areltdata *ret;
848
849 if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR, 1, abfd) != SIZEOF_AR_HDR)
850 return NULL;
851
852 namlen = strtol (hdr.namlen, (char **) NULL, 10);
853 hdrp = bfd_alloc (abfd, SIZEOF_AR_HDR + namlen + 1);
854 if (hdrp == NULL)
855 return NULL;
856 memcpy (hdrp, &hdr, SIZEOF_AR_HDR);
857 if (bfd_read ((char *) hdrp + SIZEOF_AR_HDR, 1, namlen, abfd) != namlen)
858 return NULL;
859 ((char *) hdrp)[SIZEOF_AR_HDR + namlen] = '\0';
860
861 ret = (struct areltdata *) bfd_alloc (abfd, sizeof (struct areltdata));
862 if (ret == NULL)
863 return NULL;
864 ret->arch_header = (char *) hdrp;
865 ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
866 ret->filename = (char *) hdrp + SIZEOF_AR_HDR;
867
868 /* Skip over the XCOFFARFMAG at the end of the file name. */
869 if (bfd_seek (abfd, (namlen & 1) + SXCOFFARFMAG, SEEK_CUR) != 0)
870 return NULL;
871
872 return (PTR) ret;
873 }
874
875 /* Open the next element in an XCOFF archive. */
876
877 static bfd *
878 xcoff_openr_next_archived_file (archive, last_file)
879 bfd *archive;
880 bfd *last_file;
881 {
882 file_ptr filestart;
883
884 if (xcoff_ardata (archive) == NULL)
885 {
886 bfd_set_error (bfd_error_invalid_operation);
887 return NULL;
888 }
889
890 if (last_file == NULL)
891 filestart = bfd_ardata (archive)->first_file_filepos;
892 else
893 filestart = strtol (arch_xhdr (last_file)->nextoff, (char **) NULL, 10);
894
895 if (filestart == 0
896 || filestart == strtol (xcoff_ardata (archive)->memoff,
897 (char **) NULL, 10)
898 || filestart == strtol (xcoff_ardata (archive)->symoff,
899 (char **) NULL, 10))
900 {
901 bfd_set_error (bfd_error_no_more_archived_files);
902 return NULL;
903 }
904
905 return _bfd_get_elt_at_filepos (archive, filestart);
906 }
907
908 /* Stat an element in an XCOFF archive. */
909
910 static int
911 xcoff_generic_stat_arch_elt (abfd, s)
912 bfd *abfd;
913 struct stat *s;
914 {
915 struct xcoff_ar_hdr *hdrp;
916
917 if (abfd->arelt_data == NULL)
918 {
919 bfd_set_error (bfd_error_invalid_operation);
920 return -1;
921 }
922
923 hdrp = arch_xhdr (abfd);
924
925 s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
926 s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
927 s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
928 s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
929 s->st_size = arch_eltdata (abfd)->parsed_size;
930
931 return 0;
932 }
933
934 /* Normalize a file name for inclusion in an archive. */
935
936 static const char *
937 normalize_filename (abfd)
938 bfd *abfd;
939 {
940 const char *file;
941 const char *filename;
942
943 file = bfd_get_filename (abfd);
944 filename = strrchr (file, '/');
945 if (filename != NULL)
946 filename++;
947 else
948 filename = file;
949 return filename;
950 }
951
952 /* Write out an XCOFF armap. */
953
954 /*ARGSUSED*/
955 static boolean
956 xcoff_write_armap (abfd, elength, map, orl_count, stridx)
957 bfd *abfd;
958 unsigned int elength;
959 struct orl *map;
960 unsigned int orl_count;
961 int stridx;
962 {
963 struct xcoff_ar_hdr hdr;
964 char *p;
965 unsigned char buf[4];
966 bfd *sub;
967 file_ptr fileoff;
968 unsigned int i;
969
970 memset (&hdr, 0, sizeof hdr);
971 sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
972 sprintf (hdr.nextoff, "%d", 0);
973 memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, 12);
974 sprintf (hdr.date, "%d", 0);
975 sprintf (hdr.uid, "%d", 0);
976 sprintf (hdr.gid, "%d", 0);
977 sprintf (hdr.mode, "%d", 0);
978 sprintf (hdr.namlen, "%d", 0);
979
980 /* We need spaces, not null bytes, in the header. */
981 for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR; p++)
982 if (*p == '\0')
983 *p = ' ';
984
985 if (bfd_write ((PTR) &hdr, SIZEOF_AR_HDR, 1, abfd) != SIZEOF_AR_HDR
986 || bfd_write (XCOFFARFMAG, 1, SXCOFFARFMAG, abfd) != SXCOFFARFMAG)
987 return false;
988
989 bfd_h_put_32 (abfd, orl_count, buf);
990 if (bfd_write (buf, 1, 4, abfd) != 4)
991 return false;
992
993 sub = abfd->archive_head;
994 fileoff = SIZEOF_AR_FILE_HDR;
995 i = 0;
996 while (sub != NULL && i < orl_count)
997 {
998 size_t namlen;
999
1000 while (((bfd *) (map[i]).pos) == sub)
1001 {
1002 bfd_h_put_32 (abfd, fileoff, buf);
1003 if (bfd_write (buf, 1, 4, abfd) != 4)
1004 return false;
1005 ++i;
1006 }
1007 namlen = strlen (normalize_filename (sub));
1008 namlen = (namlen + 1) &~ 1;
1009 fileoff += (SIZEOF_AR_HDR
1010 + namlen
1011 + SXCOFFARFMAG
1012 + arelt_size (sub));
1013 fileoff = (fileoff + 1) &~ 1;
1014 sub = sub->next;
1015 }
1016
1017 for (i = 0; i < orl_count; i++)
1018 {
1019 const char *name;
1020 size_t namlen;
1021
1022 name = *map[i].name;
1023 namlen = strlen (name);
1024 if (bfd_write (name, 1, namlen + 1, abfd) != namlen + 1)
1025 return false;
1026 }
1027
1028 if ((stridx & 1) != 0)
1029 {
1030 char b;
1031
1032 b = '\0';
1033 if (bfd_write (&b, 1, 1, abfd) != 1)
1034 return false;
1035 }
1036
1037 return true;
1038 }
1039
1040 /* Write out an XCOFF archive. We always write an entire archive,
1041 rather than fussing with the freelist and so forth. */
1042
1043 static boolean
1044 xcoff_write_archive_contents (abfd)
1045 bfd *abfd;
1046 {
1047 struct xcoff_ar_file_hdr fhdr;
1048 size_t count;
1049 size_t total_namlen;
1050 file_ptr *offsets;
1051 boolean makemap;
1052 boolean hasobjects;
1053 file_ptr prevoff, nextoff;
1054 bfd *sub;
1055 unsigned int i;
1056 struct xcoff_ar_hdr ahdr;
1057 bfd_size_type size;
1058 char *p;
1059 char decbuf[13];
1060
1061 memset (&fhdr, 0, sizeof fhdr);
1062 strncpy (fhdr.magic, XCOFFARMAG, SXCOFFARMAG);
1063 sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR);
1064 sprintf (fhdr.freeoff, "%d", 0);
1065
1066 count = 0;
1067 total_namlen = 0;
1068 for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
1069 {
1070 ++count;
1071 total_namlen += strlen (normalize_filename (sub)) + 1;
1072 }
1073 offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
1074 if (offsets == NULL)
1075 return false;
1076
1077 if (bfd_seek (abfd, SIZEOF_AR_FILE_HDR, SEEK_SET) != 0)
1078 return false;
1079
1080 makemap = bfd_has_map (abfd);
1081 hasobjects = false;
1082 prevoff = 0;
1083 nextoff = SIZEOF_AR_FILE_HDR;
1084 for (sub = abfd->archive_head, i = 0; sub != NULL; sub = sub->next, i++)
1085 {
1086 const char *name;
1087 size_t namlen;
1088 struct xcoff_ar_hdr *ahdrp;
1089 bfd_size_type remaining;
1090
1091 if (makemap && ! hasobjects)
1092 {
1093 if (bfd_check_format (sub, bfd_object))
1094 hasobjects = true;
1095 }
1096
1097 name = normalize_filename (sub);
1098 namlen = strlen (name);
1099
1100 if (sub->arelt_data != NULL)
1101 ahdrp = arch_xhdr (sub);
1102 else
1103 ahdrp = NULL;
1104
1105 if (ahdrp == NULL)
1106 {
1107 struct stat s;
1108
1109 memset (&ahdr, 0, sizeof ahdr);
1110 ahdrp = &ahdr;
1111 if (stat (bfd_get_filename (sub), &s) != 0)
1112 {
1113 bfd_set_error (bfd_error_system_call);
1114 return false;
1115 }
1116
1117 sprintf (ahdrp->size, "%ld", (long) s.st_size);
1118 sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
1119 sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
1120 sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
1121 sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
1122
1123 if (sub->arelt_data == NULL)
1124 {
1125 sub->arelt_data = ((struct areltdata *)
1126 bfd_alloc (sub, sizeof (struct areltdata)));
1127 if (sub->arelt_data == NULL)
1128 return false;
1129 }
1130
1131 arch_eltdata (sub)->parsed_size = s.st_size;
1132 }
1133
1134 sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
1135 sprintf (ahdrp->namlen, "%ld", (long) namlen);
1136
1137 /* If the length of the name is odd, we write out the null byte
1138 after the name as well. */
1139 namlen = (namlen + 1) &~ 1;
1140
1141 remaining = arelt_size (sub);
1142 size = (SIZEOF_AR_HDR
1143 + namlen
1144 + SXCOFFARFMAG
1145 + remaining);
1146
1147 BFD_ASSERT (nextoff == bfd_tell (abfd));
1148
1149 offsets[i] = nextoff;
1150
1151 prevoff = nextoff;
1152 nextoff += size + (size & 1);
1153
1154 sprintf (ahdrp->nextoff, "%ld", (long) nextoff);
1155
1156 /* We need spaces, not null bytes, in the header. */
1157 for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR; p++)
1158 if (*p == '\0')
1159 *p = ' ';
1160
1161 if (bfd_write ((PTR) ahdrp, 1, SIZEOF_AR_HDR, abfd) != SIZEOF_AR_HDR
1162 || bfd_write ((PTR) name, 1, namlen, abfd) != namlen
1163 || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
1164 != SXCOFFARFMAG))
1165 return false;
1166
1167 if (bfd_seek (sub, (file_ptr) 0, SEEK_SET) != 0)
1168 return false;
1169 while (remaining != 0)
1170 {
1171 bfd_size_type amt;
1172 bfd_byte buffer[DEFAULT_BUFFERSIZE];
1173
1174 amt = sizeof buffer;
1175 if (amt > remaining)
1176 amt = remaining;
1177 if (bfd_read (buffer, 1, amt, sub) != amt
1178 || bfd_write (buffer, 1, amt, abfd) != amt)
1179 return false;
1180 remaining -= amt;
1181 }
1182
1183 if ((size & 1) != 0)
1184 {
1185 bfd_byte b;
1186
1187 b = '\0';
1188 if (bfd_write (&b, 1, 1, abfd) != 1)
1189 return false;
1190 }
1191 }
1192
1193 sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
1194
1195 /* Write out the member table. */
1196
1197 BFD_ASSERT (nextoff == bfd_tell (abfd));
1198 sprintf (fhdr.memoff, "%ld", (long) nextoff);
1199
1200 memset (&ahdr, 0, sizeof ahdr);
1201 sprintf (ahdr.size, "%ld", (long) (12 + count * 12 + total_namlen));
1202 sprintf (ahdr.prevoff, "%ld", (long) prevoff);
1203 sprintf (ahdr.date, "%d", 0);
1204 sprintf (ahdr.uid, "%d", 0);
1205 sprintf (ahdr.gid, "%d", 0);
1206 sprintf (ahdr.mode, "%d", 0);
1207 sprintf (ahdr.namlen, "%d", 0);
1208
1209 size = (SIZEOF_AR_HDR
1210 + 12
1211 + count * 12
1212 + total_namlen
1213 + SXCOFFARFMAG);
1214
1215 prevoff = nextoff;
1216 nextoff += size + (size & 1);
1217
1218 if (makemap && hasobjects)
1219 sprintf (ahdr.nextoff, "%ld", (long) nextoff);
1220 else
1221 sprintf (ahdr.nextoff, "%d", 0);
1222
1223 /* We need spaces, not null bytes, in the header. */
1224 for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR; p++)
1225 if (*p == '\0')
1226 *p = ' ';
1227
1228 if (bfd_write ((PTR) &ahdr, 1, SIZEOF_AR_HDR, abfd) != SIZEOF_AR_HDR
1229 || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
1230 != SXCOFFARFMAG))
1231 return false;
1232
1233 sprintf (decbuf, "%-12ld", (long) count);
1234 if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
1235 return false;
1236 for (i = 0; i < count; i++)
1237 {
1238 sprintf (decbuf, "%-12ld", (long) offsets[i]);
1239 if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
1240 return false;
1241 }
1242 for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
1243 {
1244 const char *name;
1245 size_t namlen;
1246
1247 name = normalize_filename (sub);
1248 namlen = strlen (name);
1249 if (bfd_write ((PTR) name, 1, namlen + 1, abfd) != namlen + 1)
1250 return false;
1251 }
1252 if ((size & 1) != 0)
1253 {
1254 bfd_byte b;
1255
1256 b = '\0';
1257 if (bfd_write ((PTR) &b, 1, 1, abfd) != 1)
1258 return false;
1259 }
1260
1261 /* Write out the armap, if appropriate. */
1262
1263 if (! makemap || ! hasobjects)
1264 sprintf (fhdr.symoff, "%d", 0);
1265 else
1266 {
1267 BFD_ASSERT (nextoff == bfd_tell (abfd));
1268 sprintf (fhdr.symoff, "%ld", (long) nextoff);
1269 bfd_ardata (abfd)->tdata = (PTR) &fhdr;
1270 if (! _bfd_compute_and_write_armap (abfd, 0))
1271 return false;
1272 }
1273
1274 /* Write out the archive file header. */
1275
1276 /* We need spaces, not null bytes, in the header. */
1277 for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR; p++)
1278 if (*p == '\0')
1279 *p = ' ';
1280
1281 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1282 || (bfd_write ((PTR) &fhdr, SIZEOF_AR_FILE_HDR, 1, abfd) !=
1283 SIZEOF_AR_FILE_HDR))
1284 return false;
1285
1286 return true;
1287 }
1288 \f
1289 /* We can't use the usual coff_sizeof_headers routine, because AIX
1290 always uses an a.out header. */
1291
1292 /*ARGSUSED*/
1293 static int
1294 _bfd_xcoff_sizeof_headers (abfd, reloc)
1295 bfd *abfd;
1296 boolean reloc;
1297 {
1298 int size;
1299
1300 size = FILHSZ;
1301 if (xcoff_data (abfd)->full_aouthdr)
1302 size += AOUTSZ;
1303 else
1304 size += SMALL_AOUTSZ;
1305 size += abfd->section_count * SCNHSZ;
1306 return size;
1307 }
1308 \f
1309 #define CORE_FILE_P _bfd_dummy_target
1310
1311 #define coff_core_file_failing_command _bfd_nocore_core_file_failing_command
1312 #define coff_core_file_failing_signal _bfd_nocore_core_file_failing_signal
1313 #define coff_core_file_matches_executable_p \
1314 _bfd_nocore_core_file_matches_executable_p
1315
1316 #ifdef AIX_CORE
1317 #undef CORE_FILE_P
1318 #define CORE_FILE_P rs6000coff_core_p
1319 extern const bfd_target * rs6000coff_core_p ();
1320 extern boolean rs6000coff_get_section_contents ();
1321 extern boolean rs6000coff_core_file_matches_executable_p ();
1322
1323 #undef coff_core_file_matches_executable_p
1324 #define coff_core_file_matches_executable_p \
1325 rs6000coff_core_file_matches_executable_p
1326
1327 extern char *rs6000coff_core_file_failing_command PARAMS ((bfd *abfd));
1328 #undef coff_core_file_failing_command
1329 #define coff_core_file_failing_command rs6000coff_core_file_failing_command
1330
1331 extern int rs6000coff_core_file_failing_signal PARAMS ((bfd *abfd));
1332 #undef coff_core_file_failing_signal
1333 #define coff_core_file_failing_signal rs6000coff_core_file_failing_signal
1334
1335 #undef coff_get_section_contents
1336 #define coff_get_section_contents rs6000coff_get_section_contents
1337 #endif /* AIX_CORE */
1338
1339 #ifdef LYNX_CORE
1340
1341 #undef CORE_FILE_P
1342 #define CORE_FILE_P lynx_core_file_p
1343 extern const bfd_target *lynx_core_file_p PARAMS ((bfd *abfd));
1344
1345 extern boolean lynx_core_file_matches_executable_p PARAMS ((bfd *core_bfd,
1346 bfd *exec_bfd));
1347 #undef coff_core_file_matches_executable_p
1348 #define coff_core_file_matches_executable_p lynx_core_file_matches_executable_p
1349
1350 extern char *lynx_core_file_failing_command PARAMS ((bfd *abfd));
1351 #undef coff_core_file_failing_command
1352 #define coff_core_file_failing_command lynx_core_file_failing_command
1353
1354 extern int lynx_core_file_failing_signal PARAMS ((bfd *abfd));
1355 #undef coff_core_file_failing_signal
1356 #define coff_core_file_failing_signal lynx_core_file_failing_signal
1357
1358 #endif /* LYNX_CORE */
1359
1360 #define _bfd_xcoff_bfd_get_relocated_section_contents \
1361 coff_bfd_get_relocated_section_contents
1362 #define _bfd_xcoff_bfd_relax_section coff_bfd_relax_section
1363 #define _bfd_xcoff_bfd_link_split_section coff_bfd_link_split_section
1364
1365 /* The transfer vector that leads the outside world to all of the above. */
1366
1367 const bfd_target
1368 #ifdef TARGET_SYM
1369 TARGET_SYM =
1370 #else
1371 rs6000coff_vec =
1372 #endif
1373 {
1374 #ifdef TARGET_NAME
1375 TARGET_NAME,
1376 #else
1377 "aixcoff-rs6000", /* name */
1378 #endif
1379 bfd_target_coff_flavour,
1380 BFD_ENDIAN_BIG, /* data byte order is big */
1381 BFD_ENDIAN_BIG, /* header byte order is big */
1382
1383 (HAS_RELOC | EXEC_P | /* object flags */
1384 HAS_LINENO | HAS_DEBUG | DYNAMIC |
1385 HAS_SYMS | HAS_LOCALS | WP_TEXT),
1386
1387 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1388 0, /* leading char */
1389 '/', /* ar_pad_char */
1390 15, /* ar_max_namelen??? FIXMEmgo */
1391
1392 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1393 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1394 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1395 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1396 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1397 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1398
1399 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1400 xcoff_archive_p, CORE_FILE_P},
1401 {bfd_false, coff_mkobject, /* bfd_set_format */
1402 _bfd_generic_mkarchive, bfd_false},
1403 {bfd_false, coff_write_object_contents, /* bfd_write_contents */
1404 xcoff_write_archive_contents, bfd_false},
1405
1406 BFD_JUMP_TABLE_GENERIC (coff),
1407 BFD_JUMP_TABLE_COPY (coff),
1408 BFD_JUMP_TABLE_CORE (coff),
1409 BFD_JUMP_TABLE_ARCHIVE (xcoff),
1410 BFD_JUMP_TABLE_SYMBOLS (coff),
1411 BFD_JUMP_TABLE_RELOCS (coff),
1412 BFD_JUMP_TABLE_WRITE (coff),
1413 BFD_JUMP_TABLE_LINK (_bfd_xcoff),
1414 BFD_JUMP_TABLE_DYNAMIC (_bfd_xcoff),
1415
1416 COFF_SWAP_TABLE,
1417 };
GDB Binutils - Deliverables
This page took 0.059242 seconds and 4 git commands to generate.