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