projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* build fix for cygwin
[deliverable/binutils-gdb.git] / bfd / coff-rs6000.c
CommitLineData
252b5132 1/* BFD back-end for IBM RS/6000 "XCOFF" files.
5f771d47
ILT		 2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
252b5132
RH		 4 FIXME: Can someone provide a transliteration of this name into ASCII?
5 Using the following chars caused a compiler warning on HIUX (so I replaced
6 them with octal escapes), and isn't useful without an understanding of what
7 character set it is.
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
13This file is part of BFD, the Binary File Descriptor library.
14
15This program is free software; you can redistribute it and/or modify
16it under the terms of the GNU General Public License as published by
17the Free Software Foundation; either version 2 of the License, or
18(at your option) any later version.
19
20This program is distributed in the hope that it will be useful,
21but WITHOUT ANY WARRANTY; without even the implied warranty of
22MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23GNU General Public License for more details.
24
25You should have received a copy of the GNU General Public License
26along with this program; if not, write to the Free Software
27Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28
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
41static boolean xcoff_mkobject PARAMS ((bfd *));
42static boolean xcoff_copy_private_bfd_data PARAMS ((bfd *, bfd *));
43static boolean xcoff_is_local_label_name PARAMS ((bfd *, const char *));
44static void xcoff_rtype2howto
45 PARAMS ((arelent *, struct internal_reloc *));
46static reloc_howto_type *xcoff_reloc_type_lookup
47 PARAMS ((bfd *, bfd_reloc_code_real_type));
48static boolean xcoff_slurp_armap PARAMS ((bfd *));
49static const bfd_target *xcoff_archive_p PARAMS ((bfd *));
50static PTR xcoff_read_ar_hdr PARAMS ((bfd *));
51static bfd *xcoff_openr_next_archived_file PARAMS ((bfd *, bfd *));
52static int xcoff_generic_stat_arch_elt PARAMS ((bfd *, struct stat *));
53static const char *normalize_filename PARAMS ((bfd *));
54static boolean xcoff_write_armap
55 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int));
56static boolean xcoff_write_archive_contents PARAMS ((bfd *));
57static int _bfd_xcoff_sizeof_headers PARAMS ((bfd *, boolean));
58\f
59/* We use our own tdata type. Its first field is the COFF tdata type,
60 so the COFF routines are compatible. */
61
62static boolean
63xcoff_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
93static boolean
94xcoff_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
141static boolean
142xcoff_is_local_label_name (abfd, name)
5f771d47
ILT		 143 bfd *abfd ATTRIBUTE_UNUSED;
144 const char *name ATTRIBUTE_UNUSED;
252b5132
RH		 145{
146 return false;
147}
148\f
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
155static 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
5f771d47 262 EMPTY_HOWTO (7),
252b5132
RH		 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
5f771d47 279 EMPTY_HOWTO (9),
252b5132
RH		 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
5f771d47 296 EMPTY_HOWTO (0xb),
252b5132
RH		 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
5f771d47 328 EMPTY_HOWTO (0xe),
252b5132
RH		 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
5f771d47
ILT		 345 EMPTY_HOWTO (0x10),
346 EMPTY_HOWTO (0x11),
252b5132
RH		 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
499static void
500xcoff_rtype2howto (relent, internal)
501 arelent *relent;
502 struct internal_reloc *internal;
503{
504 relent->howto = xcoff_howto_table + internal->r_type;
505
506 /* The r_size field of an XCOFF reloc encodes the bitsize of the
507 relocation, as well as indicating whether it is signed or not.
508 Doublecheck that the relocation information gathered from the
509 type matches this information. */
510 if (relent->howto->bitsize != ((unsigned int) internal->r_size & 0x1f) + 1)
511 abort ();
512#if 0
513 if ((internal->r_size & 0x80) != 0
514 ? (relent->howto->complain_on_overflow != complain_overflow_signed)
515 : (relent->howto->complain_on_overflow != complain_overflow_bitfield))
516 abort ();
517#endif
518}
519
520static reloc_howto_type *
521xcoff_reloc_type_lookup (abfd, code)
5f771d47 522 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 523 bfd_reloc_code_real_type code;
524{
525 switch (code)
526 {
527 case BFD_RELOC_PPC_B26:
528 return &xcoff_howto_table[0xa];
529 case BFD_RELOC_PPC_BA26:
530 return &xcoff_howto_table[8];
531 case BFD_RELOC_PPC_TOC16:
532 return &xcoff_howto_table[3];
533 case BFD_RELOC_32:
534 case BFD_RELOC_CTOR:
535 return &xcoff_howto_table[0];
536 default:
537 return NULL;
538 }
539}
540
541#define SELECT_RELOC(internal, howto) \
542 { \
543 internal.r_type = howto->type; \
544 internal.r_size = \
545 ((howto->complain_on_overflow == complain_overflow_signed \
546 ? 0x80 \
547 : 0) \
548 | (howto->bitsize - 1)); \
549 }
550\f
551#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
552
553#define COFF_LONG_FILENAMES
554
555#define RTYPE2HOWTO(cache_ptr, dst) xcoff_rtype2howto (cache_ptr, dst)
556
557#define coff_mkobject xcoff_mkobject
558#define coff_bfd_copy_private_bfd_data xcoff_copy_private_bfd_data
559#define coff_bfd_is_local_label_name xcoff_is_local_label_name
560#define coff_bfd_reloc_type_lookup xcoff_reloc_type_lookup
561#define coff_relocate_section _bfd_ppc_xcoff_relocate_section
562
563#include "coffcode.h"
564\f
565/* XCOFF archive support. The original version of this code was by
566 Damon A. Permezel. It was enhanced to permit cross support, and
567 writing archive files, by Ian Lance Taylor, Cygnus Support.
568
569 XCOFF uses its own archive format. Everything is hooked together
570 with file offset links, so it is possible to rapidly update an
571 archive in place. Of course, we don't do that. An XCOFF archive
572 has a real file header, not just an ARMAG string. The structure of
573 the file header and of each archive header appear below.
574
575 An XCOFF archive also has a member table, which is a list of
576 elements in the archive (you can get that by looking through the
577 linked list, but you have to read a lot more of the file). The
578 member table has a normal archive header with an empty name. It is
579 normally (and perhaps must be) the second to last entry in the
580 archive. The member table data is almost printable ASCII. It
581 starts with a 12 character decimal string which is the number of
582 entries in the table. For each entry it has a 12 character decimal
583 string which is the offset in the archive of that member. These
584 entries are followed by a series of null terminated strings which
585 are the member names for each entry.
586
587 Finally, an XCOFF archive has a global symbol table, which is what
588 we call the armap. The global symbol table has a normal archive
589 header with an empty name. It is normally (and perhaps must be)
590 the last entry in the archive. The contents start with a four byte
591 binary number which is the number of entries. This is followed by
592 a that many four byte binary numbers; each is the file offset of an
593 entry in the archive. These numbers are followed by a series of
594 null terminated strings, which are symbol names. */
595
596/* XCOFF archives use this as a magic string. */
597
598#define XCOFFARMAG "<aiaff>\012"
599#define SXCOFFARMAG 8
600
601/* This terminates an XCOFF archive member name. */
602
603#define XCOFFARFMAG "`\012"
604#define SXCOFFARFMAG 2
605
606/* XCOFF archives start with this (printable) structure. */
607
608struct xcoff_ar_file_hdr
609{
610 /* Magic string. */
611 char magic[SXCOFFARMAG];
612
613 /* Offset of the member table (decimal ASCII string). */
614 char memoff[12];
615
616 /* Offset of the global symbol table (decimal ASCII string). */
617 char symoff[12];
618
619 /* Offset of the first member in the archive (decimal ASCII string). */
620 char firstmemoff[12];
621
622 /* Offset of the last member in the archive (decimal ASCII string). */
623 char lastmemoff[12];
624
625 /* Offset of the first member on the free list (decimal ASCII
626 string). */
627 char freeoff[12];
628};
629
630#define SIZEOF_AR_FILE_HDR (5 * 12 + SXCOFFARMAG)
631
632/* Each XCOFF archive member starts with this (printable) structure. */
633
634struct xcoff_ar_hdr
635{
636 /* File size not including the header (decimal ASCII string). */
637 char size[12];
638
639 /* File offset of next archive member (decimal ASCII string). */
640 char nextoff[12];
641
642 /* File offset of previous archive member (decimal ASCII string). */
643 char prevoff[12];
644
645 /* File mtime (decimal ASCII string). */
646 char date[12];
647
648 /* File UID (decimal ASCII string). */
649 char uid[12];
650
651 /* File GID (decimal ASCII string). */
652 char gid[12];
653
654 /* File mode (octal ASCII string). */
655 char mode[12];
656
657 /* Length of file name (decimal ASCII string). */
658 char namlen[4];
659
660 /* This structure is followed by the file name. The length of the
661 name is given in the namlen field. If the length of the name is
662 odd, the name is followed by a null byte. The name and optional
663 null byte are followed by XCOFFARFMAG, which is not included in
664 namlen. The contents of the archive member follow; the number of
665 bytes is given in the size field. */
666};
667
668#define SIZEOF_AR_HDR (7 * 12 + 4)
669
670/* We store a copy of the xcoff_ar_file_hdr in the tdata field of the
671 artdata structure. */
672#define xcoff_ardata(abfd) \
673 ((struct xcoff_ar_file_hdr *) bfd_ardata (abfd)->tdata)
674
675/* We store a copy of the xcoff_ar_hdr in the arelt_data field of an
676 archive element. */
677#define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
678#define arch_xhdr(bfd) \
679 ((struct xcoff_ar_hdr *) arch_eltdata (bfd)->arch_header)
680
681/* XCOFF archives do not have anything which corresponds to an
682 extended name table. */
683
684#define xcoff_slurp_extended_name_table bfd_false
685#define xcoff_construct_extended_name_table \
686 ((boolean (*) PARAMS ((bfd *, char **, bfd_size_type *, const char **))) \
687 bfd_false)
688#define xcoff_truncate_arname bfd_dont_truncate_arname
689
690/* We can use the standard get_elt_at_index routine. */
691
692#define xcoff_get_elt_at_index _bfd_generic_get_elt_at_index
693
694/* XCOFF archives do not have a timestamp. */
695
696#define xcoff_update_armap_timestamp bfd_true
697
698/* Read in the armap of an XCOFF archive. */
699
700static boolean
701xcoff_slurp_armap (abfd)
702 bfd *abfd;
703{
704 file_ptr off;
705 struct xcoff_ar_hdr hdr;
706 size_t namlen;
707 bfd_size_type sz;
708 bfd_byte *contents, *cend;
709 unsigned int c, i;
710 carsym *arsym;
711 bfd_byte *p;
712
713 if (xcoff_ardata (abfd) == NULL)
714 {
715 bfd_has_map (abfd) = false;
716 return true;
717 }
718
719 off = strtol (xcoff_ardata (abfd)->symoff, (char **) NULL, 10);
720 if (off == 0)
721 {
722 bfd_has_map (abfd) = false;
723 return true;
724 }
725
726 if (bfd_seek (abfd, off, SEEK_SET) != 0)
727 return false;
728
729 /* The symbol table starts with a normal archive header. */
730 if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR, 1, abfd) != SIZEOF_AR_HDR)
731 return false;
732
733 /* Skip the name (normally empty). */
734 namlen = strtol (hdr.namlen, (char **) NULL, 10);
735 if (bfd_seek (abfd, ((namlen + 1) & ~1) + SXCOFFARFMAG, SEEK_CUR) != 0)
736 return false;
737
738 /* Read in the entire symbol table. */
739 sz = strtol (hdr.size, (char **) NULL, 10);
740 contents = (bfd_byte *) bfd_alloc (abfd, sz);
741 if (contents == NULL)
742 return false;
743 if (bfd_read ((PTR) contents, 1, sz, abfd) != sz)
744 return false;
745
746 /* The symbol table starts with a four byte count. */
747 c = bfd_h_get_32 (abfd, contents);
748
749 if (c * 4 >= sz)
750 {
751 bfd_set_error (bfd_error_bad_value);
752 return false;
753 }
754
755 bfd_ardata (abfd)->symdefs = ((carsym *)
756 bfd_alloc (abfd, c * sizeof (carsym)));
757 if (bfd_ardata (abfd)->symdefs == NULL)
758 return false;
759
760 /* After the count comes a list of four byte file offsets. */
761 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 4;
762 i < c;
763 ++i, ++arsym, p += 4)
764 arsym->file_offset = bfd_h_get_32 (abfd, p);
765
766 /* After the file offsets come null terminated symbol names. */
767 cend = contents + sz;
768 for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
769 i < c;
770 ++i, ++arsym, p += strlen ((char *) p) + 1)
771 {
772 if (p >= cend)
773 {
774 bfd_set_error (bfd_error_bad_value);
775 return false;
776 }
777 arsym->name = (char *) p;
778 }
779
780 bfd_ardata (abfd)->symdef_count = c;
781 bfd_has_map (abfd) = true;
782
783 return true;
784}
785
786/* See if this is an XCOFF archive. */
787
788static const bfd_target *
789xcoff_archive_p (abfd)
790 bfd *abfd;
791{
792 struct xcoff_ar_file_hdr hdr;
793
794 if (bfd_read ((PTR) &hdr, SIZEOF_AR_FILE_HDR, 1, abfd)
795 != SIZEOF_AR_FILE_HDR)
796 {
797 if (bfd_get_error () != bfd_error_system_call)
798 bfd_set_error (bfd_error_wrong_format);
799 return NULL;
800 }
801
802 if (strncmp (hdr.magic, XCOFFARMAG, SXCOFFARMAG) != 0)
803 {
804 bfd_set_error (bfd_error_wrong_format);
805 return NULL;
806 }
807
808 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
809 involves a cast, we can't do it as the left operand of
810 assignment. */
811 abfd->tdata.aout_ar_data =
812 (struct artdata *) bfd_zalloc (abfd, sizeof (struct artdata));
813
814 if (bfd_ardata (abfd) == (struct artdata *) NULL)
815 return NULL;
816
817 bfd_ardata (abfd)->first_file_filepos = strtol (hdr.firstmemoff,
818 (char **) NULL, 10);
819 bfd_ardata (abfd)->cache = NULL;
820 bfd_ardata (abfd)->archive_head = NULL;
821 bfd_ardata (abfd)->symdefs = NULL;
822 bfd_ardata (abfd)->extended_names = NULL;
823
824 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, SIZEOF_AR_FILE_HDR);
825 if (bfd_ardata (abfd)->tdata == NULL)
826 return NULL;
827
828 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR);
829
830 if (! xcoff_slurp_armap (abfd))
831 {
832 bfd_release (abfd, bfd_ardata (abfd));
833 abfd->tdata.aout_ar_data = (struct artdata *) NULL;
834 return NULL;
835 }
836
837 return abfd->xvec;
838}
839
840/* Read the archive header in an XCOFF archive. */
841
842static PTR
843xcoff_read_ar_hdr (abfd)
844 bfd *abfd;
845{
846 struct xcoff_ar_hdr hdr;
847 size_t namlen;
848 struct xcoff_ar_hdr *hdrp;
849 struct areltdata *ret;
850
851 if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR, 1, abfd) != SIZEOF_AR_HDR)
852 return NULL;
853
854 namlen = strtol (hdr.namlen, (char **) NULL, 10);
855 hdrp = (struct xcoff_ar_hdr *) bfd_alloc (abfd, SIZEOF_AR_HDR + namlen + 1);
856 if (hdrp == NULL)
857 return NULL;
858 memcpy (hdrp, &hdr, SIZEOF_AR_HDR);
859 if (bfd_read ((char *) hdrp + SIZEOF_AR_HDR, 1, namlen, abfd) != namlen)
860 return NULL;
861 ((char *) hdrp)[SIZEOF_AR_HDR + namlen] = '\0';
862
863 ret = (struct areltdata *) bfd_alloc (abfd, sizeof (struct areltdata));
864 if (ret == NULL)
865 return NULL;
866 ret->arch_header = (char *) hdrp;
867 ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
868 ret->filename = (char *) hdrp + SIZEOF_AR_HDR;
869
870 /* Skip over the XCOFFARFMAG at the end of the file name. */
871 if (bfd_seek (abfd, (namlen & 1) + SXCOFFARFMAG, SEEK_CUR) != 0)
872 return NULL;
873
874 return (PTR) ret;
875}
876
877/* Open the next element in an XCOFF archive. */
878
879static bfd *
880xcoff_openr_next_archived_file (archive, last_file)
881 bfd *archive;
882 bfd *last_file;
883{
884 file_ptr filestart;
885
886 if (xcoff_ardata (archive) == NULL)
887 {
888 bfd_set_error (bfd_error_invalid_operation);
889 return NULL;
890 }
891
892 if (last_file == NULL)
893 filestart = bfd_ardata (archive)->first_file_filepos;
894 else
895 filestart = strtol (arch_xhdr (last_file)->nextoff, (char **) NULL, 10);
896
897 if (filestart == 0
898 || filestart == strtol (xcoff_ardata (archive)->memoff,
899 (char **) NULL, 10)
900 || filestart == strtol (xcoff_ardata (archive)->symoff,
901 (char **) NULL, 10))
902 {
903 bfd_set_error (bfd_error_no_more_archived_files);
904 return NULL;
905 }
906
907 return _bfd_get_elt_at_filepos (archive, filestart);
908}
909
910/* Stat an element in an XCOFF archive. */
911
912static int
913xcoff_generic_stat_arch_elt (abfd, s)
914 bfd *abfd;
915 struct stat *s;
916{
917 struct xcoff_ar_hdr *hdrp;
918
919 if (abfd->arelt_data == NULL)
920 {
921 bfd_set_error (bfd_error_invalid_operation);
922 return -1;
923 }
924
925 hdrp = arch_xhdr (abfd);
926
927 s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
928 s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
929 s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
930 s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
931 s->st_size = arch_eltdata (abfd)->parsed_size;
932
933 return 0;
934}
935
936/* Normalize a file name for inclusion in an archive. */
937
938static const char *
939normalize_filename (abfd)
940 bfd *abfd;
941{
942 const char *file;
943 const char *filename;
944
945 file = bfd_get_filename (abfd);
946 filename = strrchr (file, '/');
947 if (filename != NULL)
948 filename++;
949 else
950 filename = file;
951 return filename;
952}
953
954/* Write out an XCOFF armap. */
955
956/*ARGSUSED*/
957static boolean
958xcoff_write_armap (abfd, elength, map, orl_count, stridx)
959 bfd *abfd;
5f771d47 960 unsigned int elength ATTRIBUTE_UNUSED;
252b5132
RH		 961 struct orl *map;
962 unsigned int orl_count;
963 int stridx;
964{
965 struct xcoff_ar_hdr hdr;
966 char *p;
967 unsigned char buf[4];
968 bfd *sub;
969 file_ptr fileoff;
970 unsigned int i;
971
972 memset (&hdr, 0, sizeof hdr);
973 sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
974 sprintf (hdr.nextoff, "%d", 0);
975 memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, 12);
976 sprintf (hdr.date, "%d", 0);
977 sprintf (hdr.uid, "%d", 0);
978 sprintf (hdr.gid, "%d", 0);
979 sprintf (hdr.mode, "%d", 0);
980 sprintf (hdr.namlen, "%d", 0);
981
982 /* We need spaces, not null bytes, in the header. */
983 for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR; p++)
984 if (*p == '\0')
985 *p = ' ';
986
987 if (bfd_write ((PTR) &hdr, SIZEOF_AR_HDR, 1, abfd) != SIZEOF_AR_HDR
988 || bfd_write (XCOFFARFMAG, 1, SXCOFFARFMAG, abfd) != SXCOFFARFMAG)
989 return false;
990
991 bfd_h_put_32 (abfd, orl_count, buf);
992 if (bfd_write (buf, 1, 4, abfd) != 4)
993 return false;
994
995 sub = abfd->archive_head;
996 fileoff = SIZEOF_AR_FILE_HDR;
997 i = 0;
998 while (sub != NULL && i < orl_count)
999 {
1000 size_t namlen;
1001
1002 while (((bfd *) (map[i]).pos) == sub)
1003 {
1004 bfd_h_put_32 (abfd, fileoff, buf);
1005 if (bfd_write (buf, 1, 4, abfd) != 4)
1006 return false;
1007 ++i;
1008 }
1009 namlen = strlen (normalize_filename (sub));
1010 namlen = (namlen + 1) &~ 1;
1011 fileoff += (SIZEOF_AR_HDR
1012 + namlen
1013 + SXCOFFARFMAG
1014 + arelt_size (sub));
1015 fileoff = (fileoff + 1) &~ 1;
1016 sub = sub->next;
1017 }
1018
1019 for (i = 0; i < orl_count; i++)
1020 {
1021 const char *name;
1022 size_t namlen;
1023
1024 name = *map[i].name;
1025 namlen = strlen (name);
1026 if (bfd_write (name, 1, namlen + 1, abfd) != namlen + 1)
1027 return false;
1028 }
1029
1030 if ((stridx & 1) != 0)
1031 {
1032 char b;
1033
1034 b = '\0';
1035 if (bfd_write (&b, 1, 1, abfd) != 1)
1036 return false;
1037 }
1038
1039 return true;
1040}
1041
1042/* Write out an XCOFF archive. We always write an entire archive,
1043 rather than fussing with the freelist and so forth. */
1044
1045static boolean
1046xcoff_write_archive_contents (abfd)
1047 bfd *abfd;
1048{
1049 struct xcoff_ar_file_hdr fhdr;
1050 size_t count;
1051 size_t total_namlen;
1052 file_ptr *offsets;
1053 boolean makemap;
1054 boolean hasobjects;
1055 file_ptr prevoff, nextoff;
1056 bfd *sub;
1057 unsigned int i;
1058 struct xcoff_ar_hdr ahdr;
1059 bfd_size_type size;
1060 char *p;
1061 char decbuf[13];
1062
1063 memset (&fhdr, 0, sizeof fhdr);
1064 strncpy (fhdr.magic, XCOFFARMAG, SXCOFFARMAG);
1065 sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR);
1066 sprintf (fhdr.freeoff, "%d", 0);
1067
1068 count = 0;
1069 total_namlen = 0;
1070 for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
1071 {
1072 ++count;
1073 total_namlen += strlen (normalize_filename (sub)) + 1;
1074 }
1075 offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
1076 if (offsets == NULL)
1077 return false;
1078
1079 if (bfd_seek (abfd, SIZEOF_AR_FILE_HDR, SEEK_SET) != 0)
1080 return false;
1081
1082 makemap = bfd_has_map (abfd);
1083 hasobjects = false;
1084 prevoff = 0;
1085 nextoff = SIZEOF_AR_FILE_HDR;
1086 for (sub = abfd->archive_head, i = 0; sub != NULL; sub = sub->next, i++)
1087 {
1088 const char *name;
1089 size_t namlen;
1090 struct xcoff_ar_hdr *ahdrp;
1091 bfd_size_type remaining;
1092
1093 if (makemap && ! hasobjects)
1094 {
1095 if (bfd_check_format (sub, bfd_object))
1096 hasobjects = true;
1097 }
1098
1099 name = normalize_filename (sub);
1100 namlen = strlen (name);
1101
1102 if (sub->arelt_data != NULL)
1103 ahdrp = arch_xhdr (sub);
1104 else
1105 ahdrp = NULL;
1106
1107 if (ahdrp == NULL)
1108 {
1109 struct stat s;
1110
1111 memset (&ahdr, 0, sizeof ahdr);
1112 ahdrp = &ahdr;
1113 if (stat (bfd_get_filename (sub), &s) != 0)
1114 {
1115 bfd_set_error (bfd_error_system_call);
1116 return false;
1117 }
1118
1119 sprintf (ahdrp->size, "%ld", (long) s.st_size);
1120 sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
1121 sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
1122 sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
1123 sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
1124
1125 if (sub->arelt_data == NULL)
1126 {
1127 sub->arelt_data = bfd_alloc (sub, sizeof (struct areltdata));
1128 if (sub->arelt_data == NULL)
1129 return false;
1130 }
1131
1132 arch_eltdata (sub)->parsed_size = s.st_size;
1133 }
1134
1135 sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
1136 sprintf (ahdrp->namlen, "%ld", (long) namlen);
1137
1138 /* If the length of the name is odd, we write out the null byte
1139 after the name as well. */
1140 namlen = (namlen + 1) &~ 1;
1141
1142 remaining = arelt_size (sub);
1143 size = (SIZEOF_AR_HDR
1144 + namlen
1145 + SXCOFFARFMAG
1146 + remaining);
1147
1148 BFD_ASSERT (nextoff == bfd_tell (abfd));
1149
1150 offsets[i] = nextoff;
1151
1152 prevoff = nextoff;
1153 nextoff += size + (size & 1);
1154
1155 sprintf (ahdrp->nextoff, "%ld", (long) nextoff);
1156
1157 /* We need spaces, not null bytes, in the header. */
1158 for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR; p++)
1159 if (*p == '\0')
1160 *p = ' ';
1161
1162 if (bfd_write ((PTR) ahdrp, 1, SIZEOF_AR_HDR, abfd) != SIZEOF_AR_HDR
1163 || bfd_write ((PTR) name, 1, namlen, abfd) != namlen
1164 || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
1165 != SXCOFFARFMAG))
1166 return false;
1167
1168 if (bfd_seek (sub, (file_ptr) 0, SEEK_SET) != 0)
1169 return false;
1170 while (remaining != 0)
1171 {
1172 bfd_size_type amt;
1173 bfd_byte buffer[DEFAULT_BUFFERSIZE];
1174
1175 amt = sizeof buffer;
1176 if (amt > remaining)
1177 amt = remaining;
1178 if (bfd_read (buffer, 1, amt, sub) != amt
1179 || bfd_write (buffer, 1, amt, abfd) != amt)
1180 return false;
1181 remaining -= amt;
1182 }
1183
1184 if ((size & 1) != 0)
1185 {
1186 bfd_byte b;
1187
1188 b = '\0';
1189 if (bfd_write (&b, 1, 1, abfd) != 1)
1190 return false;
1191 }
1192 }
1193
1194 sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
1195
1196 /* Write out the member table. */
1197
1198 BFD_ASSERT (nextoff == bfd_tell (abfd));
1199 sprintf (fhdr.memoff, "%ld", (long) nextoff);
1200
1201 memset (&ahdr, 0, sizeof ahdr);
1202 sprintf (ahdr.size, "%ld", (long) (12 + count * 12 + total_namlen));
1203 sprintf (ahdr.prevoff, "%ld", (long) prevoff);
1204 sprintf (ahdr.date, "%d", 0);
1205 sprintf (ahdr.uid, "%d", 0);
1206 sprintf (ahdr.gid, "%d", 0);
1207 sprintf (ahdr.mode, "%d", 0);
1208 sprintf (ahdr.namlen, "%d", 0);
1209
1210 size = (SIZEOF_AR_HDR
1211 + 12
1212 + count * 12
1213 + total_namlen
1214 + SXCOFFARFMAG);
1215
1216 prevoff = nextoff;
1217 nextoff += size + (size & 1);
1218
1219 if (makemap && hasobjects)
1220 sprintf (ahdr.nextoff, "%ld", (long) nextoff);
1221 else
1222 sprintf (ahdr.nextoff, "%d", 0);
1223
1224 /* We need spaces, not null bytes, in the header. */
1225 for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR; p++)
1226 if (*p == '\0')
1227 *p = ' ';
1228
1229 if (bfd_write ((PTR) &ahdr, 1, SIZEOF_AR_HDR, abfd) != SIZEOF_AR_HDR
1230 || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
1231 != SXCOFFARFMAG))
1232 return false;
1233
1234 sprintf (decbuf, "%-12ld", (long) count);
1235 if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
1236 return false;
1237 for (i = 0; i < count; i++)
1238 {
1239 sprintf (decbuf, "%-12ld", (long) offsets[i]);
1240 if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
1241 return false;
1242 }
1243 for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
1244 {
1245 const char *name;
1246 size_t namlen;
1247
1248 name = normalize_filename (sub);
1249 namlen = strlen (name);
1250 if (bfd_write ((PTR) name, 1, namlen + 1, abfd) != namlen + 1)
1251 return false;
1252 }
1253 if ((size & 1) != 0)
1254 {
1255 bfd_byte b;
1256
1257 b = '\0';
1258 if (bfd_write ((PTR) &b, 1, 1, abfd) != 1)
1259 return false;
1260 }
1261
1262 /* Write out the armap, if appropriate. */
1263
1264 if (! makemap || ! hasobjects)
1265 sprintf (fhdr.symoff, "%d", 0);
1266 else
1267 {
1268 BFD_ASSERT (nextoff == bfd_tell (abfd));
1269 sprintf (fhdr.symoff, "%ld", (long) nextoff);
1270 bfd_ardata (abfd)->tdata = (PTR) &fhdr;
1271 if (! _bfd_compute_and_write_armap (abfd, 0))
1272 return false;
1273 }
1274
1275 /* Write out the archive file header. */
1276
1277 /* We need spaces, not null bytes, in the header. */
1278 for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR; p++)
1279 if (*p == '\0')
1280 *p = ' ';
1281
1282 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1283 || (bfd_write ((PTR) &fhdr, SIZEOF_AR_FILE_HDR, 1, abfd) !=
1284 SIZEOF_AR_FILE_HDR))
1285 return false;
1286
1287 return true;
1288}
1289\f
1290/* We can't use the usual coff_sizeof_headers routine, because AIX
1291 always uses an a.out header. */
1292
1293/*ARGSUSED*/
1294static int
1295_bfd_xcoff_sizeof_headers (abfd, reloc)
1296 bfd *abfd;
5f771d47 1297 boolean reloc ATTRIBUTE_UNUSED;
252b5132
RH		 1298{
1299 int size;
1300
1301 size = FILHSZ;
1302 if (xcoff_data (abfd)->full_aouthdr)
1303 size += AOUTSZ;
1304 else
1305 size += SMALL_AOUTSZ;
1306 size += abfd->section_count * SCNHSZ;
1307 return size;
1308}
1309\f
1310#define CORE_FILE_P _bfd_dummy_target
1311
1312#define coff_core_file_failing_command _bfd_nocore_core_file_failing_command
1313#define coff_core_file_failing_signal _bfd_nocore_core_file_failing_signal
1314#define coff_core_file_matches_executable_p \
1315 _bfd_nocore_core_file_matches_executable_p
1316
1317#ifdef AIX_CORE
1318#undef CORE_FILE_P
1319#define CORE_FILE_P rs6000coff_core_p
1320extern const bfd_target * rs6000coff_core_p ();
1321extern boolean rs6000coff_get_section_contents ();
1322extern boolean rs6000coff_core_file_matches_executable_p ();
1323
1324#undef coff_core_file_matches_executable_p
1325#define coff_core_file_matches_executable_p \
1326 rs6000coff_core_file_matches_executable_p
1327
1328extern char *rs6000coff_core_file_failing_command PARAMS ((bfd *abfd));
1329#undef coff_core_file_failing_command
1330#define coff_core_file_failing_command rs6000coff_core_file_failing_command
1331
1332extern int rs6000coff_core_file_failing_signal PARAMS ((bfd *abfd));
1333#undef coff_core_file_failing_signal
1334#define coff_core_file_failing_signal rs6000coff_core_file_failing_signal
1335
1336#undef coff_get_section_contents
1337#define coff_get_section_contents rs6000coff_get_section_contents
1338#endif /* AIX_CORE */
1339
1340#ifdef LYNX_CORE
1341
1342#undef CORE_FILE_P
1343#define CORE_FILE_P lynx_core_file_p
1344extern const bfd_target *lynx_core_file_p PARAMS ((bfd *abfd));
1345
1346extern boolean lynx_core_file_matches_executable_p PARAMS ((bfd *core_bfd,
1347 bfd *exec_bfd));
1348#undef coff_core_file_matches_executable_p
1349#define coff_core_file_matches_executable_p lynx_core_file_matches_executable_p
1350
1351extern char *lynx_core_file_failing_command PARAMS ((bfd *abfd));
1352#undef coff_core_file_failing_command
1353#define coff_core_file_failing_command lynx_core_file_failing_command
1354
1355extern int lynx_core_file_failing_signal PARAMS ((bfd *abfd));
1356#undef coff_core_file_failing_signal
1357#define coff_core_file_failing_signal lynx_core_file_failing_signal
1358
1359#endif /* LYNX_CORE */
1360
1361#define _bfd_xcoff_bfd_get_relocated_section_contents \
1362 coff_bfd_get_relocated_section_contents
1363#define _bfd_xcoff_bfd_relax_section coff_bfd_relax_section
1364#define _bfd_xcoff_bfd_gc_sections coff_bfd_gc_sections
1365#define _bfd_xcoff_bfd_link_split_section coff_bfd_link_split_section
1366
1367/* The transfer vector that leads the outside world to all of the above. */
1368
1369const bfd_target
1370#ifdef TARGET_SYM
1371 TARGET_SYM =
1372#else
1373 rs6000coff_vec =
1374#endif
1375{
1376#ifdef TARGET_NAME
1377 TARGET_NAME,
1378#else
1379 "aixcoff-rs6000", /* name */
1380#endif
1381 bfd_target_coff_flavour,
1382 BFD_ENDIAN_BIG, /* data byte order is big */
1383 BFD_ENDIAN_BIG, /* header byte order is big */
1384
1385 (HAS_RELOC | EXEC_P | /* object flags */
1386 HAS_LINENO | HAS_DEBUG | DYNAMIC |
1387 HAS_SYMS | HAS_LOCALS | WP_TEXT),
1388
1389 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1390 0, /* leading char */
1391 '/', /* ar_pad_char */
1392 15, /* ar_max_namelen??? FIXMEmgo */
1393
1394 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1395 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1396 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1397 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1398 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1399 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1400
1401 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1402 xcoff_archive_p, CORE_FILE_P},
1403 {bfd_false, coff_mkobject, /* bfd_set_format */
1404 _bfd_generic_mkarchive, bfd_false},
1405 {bfd_false, coff_write_object_contents, /* bfd_write_contents */
1406 xcoff_write_archive_contents, bfd_false},
1407
1408 BFD_JUMP_TABLE_GENERIC (coff),
1409 BFD_JUMP_TABLE_COPY (coff),
1410 BFD_JUMP_TABLE_CORE (coff),
1411 BFD_JUMP_TABLE_ARCHIVE (xcoff),
1412 BFD_JUMP_TABLE_SYMBOLS (coff),
1413 BFD_JUMP_TABLE_RELOCS (coff),
1414 BFD_JUMP_TABLE_WRITE (coff),
1415 BFD_JUMP_TABLE_LINK (_bfd_xcoff),
1416 BFD_JUMP_TABLE_DYNAMIC (_bfd_xcoff),
1417
c3c89269
NC		 1418 NULL,
1419
1420 COFF_SWAP_TABLE
252b5132 1421};
GDB Binutils - Deliverables
This page took 0.089373 seconds and 4 git commands to generate.