1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright (C) 1990-2020 Free Software Foundation, Inc.
3 Original version by Per Bothner.
4 Full support added by Ian Lance Taylor, ian@cygnus.com.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "ecoff-bfd.h"
29 #include "aout/stab_gnu.h"
31 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
32 some other stuff which we don't want and which conflicts with stuff
35 #include "aout/aout64.h"
38 #undef obj_sym_filepos
40 #include "coff/internal.h"
42 #include "coff/symconst.h"
43 #include "coff/ecoff.h"
46 #include "libiberty.h"
48 #define streq(a, b) (strcmp ((a), (b)) == 0)
49 #define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0)
52 /* This stuff is somewhat copied from coffcode.h. */
53 static asection bfd_debug_section
=
55 /* name, id, section_id, index, next, prev, flags, */
56 "*DEBUG*", 0, 0, 0, NULL
, NULL
, 0,
59 /* linker_mark, linker_has_input, gc_mark, compress_status, */
61 /* segment_mark, sec_info_type, use_rela_p, */
63 /* sec_flg0, sec_flg1, sec_flg2, sec_flg3, sec_flg4, sec_flg5, */
65 /* vma, lma, size, rawsize, compressed_size, relax, relax_count, */
67 /* output_offset, output_section, alignment_power, */
69 /* relocation, orelocation, reloc_count, filepos, rel_filepos, */
71 /* line_filepos, userdata, contents, lineno, lineno_count, */
72 0, NULL
, NULL
, NULL
, 0,
73 /* entsize, kept_section, moving_line_filepos, */
75 /* target_index, used_by_bfd, constructor_chain, owner, */
81 /* map_head, map_tail */
85 /* Create an ECOFF object. */
88 _bfd_ecoff_mkobject (bfd
*abfd
)
90 size_t amt
= sizeof (ecoff_data_type
);
92 abfd
->tdata
.ecoff_obj_data
= (struct ecoff_tdata
*) bfd_zalloc (abfd
, amt
);
93 if (abfd
->tdata
.ecoff_obj_data
== NULL
)
99 /* This is a hook called by coff_real_object_p to create any backend
100 specific information. */
103 _bfd_ecoff_mkobject_hook (bfd
*abfd
, void * filehdr
, void * aouthdr
)
105 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
106 struct internal_aouthdr
*internal_a
= (struct internal_aouthdr
*) aouthdr
;
107 ecoff_data_type
*ecoff
;
109 if (! _bfd_ecoff_mkobject (abfd
))
112 ecoff
= ecoff_data (abfd
);
114 ecoff
->sym_filepos
= internal_f
->f_symptr
;
116 if (internal_a
!= NULL
)
120 ecoff
->text_start
= internal_a
->text_start
;
121 ecoff
->text_end
= internal_a
->text_start
+ internal_a
->tsize
;
122 ecoff
->gp
= internal_a
->gp_value
;
123 ecoff
->gprmask
= internal_a
->gprmask
;
124 for (i
= 0; i
< 4; i
++)
125 ecoff
->cprmask
[i
] = internal_a
->cprmask
[i
];
126 ecoff
->fprmask
= internal_a
->fprmask
;
127 if (internal_a
->magic
== ECOFF_AOUT_ZMAGIC
)
128 abfd
->flags
|= D_PAGED
;
130 abfd
->flags
&=~ D_PAGED
;
133 /* It turns out that no special action is required by the MIPS or
134 Alpha ECOFF backends. They have different information in the
135 a.out header, but we just copy it all (e.g., gprmask, cprmask and
136 fprmask) and let the swapping routines ensure that only relevant
137 information is written out. */
139 return (void *) ecoff
;
142 /* Initialize a new section. */
145 _bfd_ecoff_new_section_hook (bfd
*abfd
, asection
*section
)
155 { _TEXT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
156 { _INIT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
157 { _FINI
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
158 { _DATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
},
159 { _SDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
},
160 { _RDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
161 { _LIT8
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
162 { _LIT4
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
163 { _RCONST
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
164 { _PDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
167 /* An Irix 4 shared libary. */
168 { _LIB
, SEC_COFF_SHARED_LIBRARY
}
171 section
->alignment_power
= 4;
173 for (i
= 0; i
< ARRAY_SIZE (section_flags
); i
++)
174 if (streq (section
->name
, section_flags
[i
].name
))
176 section
->flags
|= section_flags
[i
].flags
;
181 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
182 uncertain about .init on some systems and I don't know how shared
185 return _bfd_generic_new_section_hook (abfd
, section
);
189 _bfd_ecoff_set_alignment_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
190 asection
*section ATTRIBUTE_UNUSED
,
191 void *scnhdr ATTRIBUTE_UNUSED
)
195 /* Determine the machine architecture and type. This is called from
196 the generic COFF routines. It is the inverse of ecoff_get_magic,
197 below. This could be an ECOFF backend routine, with one version
198 for each target, but there aren't all that many ECOFF targets. */
201 _bfd_ecoff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
203 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
204 enum bfd_architecture arch
;
207 switch (internal_f
->f_magic
)
210 case MIPS_MAGIC_LITTLE
:
212 arch
= bfd_arch_mips
;
213 mach
= bfd_mach_mips3000
;
216 case MIPS_MAGIC_LITTLE2
:
217 case MIPS_MAGIC_BIG2
:
218 /* MIPS ISA level 2: the r6000. */
219 arch
= bfd_arch_mips
;
220 mach
= bfd_mach_mips6000
;
223 case MIPS_MAGIC_LITTLE3
:
224 case MIPS_MAGIC_BIG3
:
225 /* MIPS ISA level 3: the r4000. */
226 arch
= bfd_arch_mips
;
227 mach
= bfd_mach_mips4000
;
231 arch
= bfd_arch_alpha
;
236 arch
= bfd_arch_obscure
;
241 return bfd_default_set_arch_mach (abfd
, arch
, mach
);
245 _bfd_ecoff_no_long_sections (bfd
*abfd
, int enable
)
252 /* Get the magic number to use based on the architecture and machine.
253 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
256 ecoff_get_magic (bfd
*abfd
)
260 switch (bfd_get_arch (abfd
))
263 switch (bfd_get_mach (abfd
))
267 case bfd_mach_mips3000
:
268 big
= MIPS_MAGIC_BIG
;
269 little
= MIPS_MAGIC_LITTLE
;
272 case bfd_mach_mips6000
:
273 big
= MIPS_MAGIC_BIG2
;
274 little
= MIPS_MAGIC_LITTLE2
;
277 case bfd_mach_mips4000
:
278 big
= MIPS_MAGIC_BIG3
;
279 little
= MIPS_MAGIC_LITTLE3
;
283 return bfd_big_endian (abfd
) ? big
: little
;
294 /* Get the section s_flags to use for a section. */
297 ecoff_sec_to_styp_flags (const char *name
, flagword flags
)
307 { _TEXT
, STYP_TEXT
},
308 { _DATA
, STYP_DATA
},
309 { _SDATA
, STYP_SDATA
},
310 { _RDATA
, STYP_RDATA
},
311 { _LITA
, STYP_LITA
},
312 { _LIT8
, STYP_LIT8
},
313 { _LIT4
, STYP_LIT4
},
315 { _SBSS
, STYP_SBSS
},
316 { _INIT
, STYP_ECOFF_INIT
},
317 { _FINI
, STYP_ECOFF_FINI
},
318 { _PDATA
, STYP_PDATA
},
319 { _XDATA
, STYP_XDATA
},
320 { _LIB
, STYP_ECOFF_LIB
},
322 { _HASH
, STYP_HASH
},
323 { _DYNAMIC
, STYP_DYNAMIC
},
324 { _LIBLIST
, STYP_LIBLIST
},
325 { _RELDYN
, STYP_RELDYN
},
326 { _CONFLIC
, STYP_CONFLIC
},
327 { _DYNSTR
, STYP_DYNSTR
},
328 { _DYNSYM
, STYP_DYNSYM
},
329 { _RCONST
, STYP_RCONST
}
333 for (i
= 0; i
< ARRAY_SIZE (styp_flags
); i
++)
334 if (streq (name
, styp_flags
[i
].name
))
336 styp
= styp_flags
[i
].flags
;
342 if (streq (name
, _COMMENT
))
345 flags
&=~ SEC_NEVER_LOAD
;
347 else if (flags
& SEC_CODE
)
349 else if (flags
& SEC_DATA
)
351 else if (flags
& SEC_READONLY
)
353 else if (flags
& SEC_LOAD
)
359 if (flags
& SEC_NEVER_LOAD
)
365 /* Get the BFD flags to use for a section. */
368 _bfd_ecoff_styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
370 const char *name ATTRIBUTE_UNUSED
,
371 asection
*section ATTRIBUTE_UNUSED
,
372 flagword
* flags_ptr
)
374 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
375 long styp_flags
= internal_s
->s_flags
;
376 flagword sec_flags
= 0;
378 if (styp_flags
& STYP_NOLOAD
)
379 sec_flags
|= SEC_NEVER_LOAD
;
381 /* For 386 COFF, at least, an unloadable text or data section is
382 actually a shared library section. */
383 if ((styp_flags
& STYP_TEXT
)
384 || (styp_flags
& STYP_ECOFF_INIT
)
385 || (styp_flags
& STYP_ECOFF_FINI
)
386 || (styp_flags
& STYP_DYNAMIC
)
387 || (styp_flags
& STYP_LIBLIST
)
388 || (styp_flags
& STYP_RELDYN
)
389 || styp_flags
== STYP_CONFLIC
390 || (styp_flags
& STYP_DYNSTR
)
391 || (styp_flags
& STYP_DYNSYM
)
392 || (styp_flags
& STYP_HASH
))
394 if (sec_flags
& SEC_NEVER_LOAD
)
395 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
397 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
399 else if ((styp_flags
& STYP_DATA
)
400 || (styp_flags
& STYP_RDATA
)
401 || (styp_flags
& STYP_SDATA
)
402 || styp_flags
== STYP_PDATA
403 || styp_flags
== STYP_XDATA
404 || (styp_flags
& STYP_GOT
)
405 || styp_flags
== STYP_RCONST
)
407 if (sec_flags
& SEC_NEVER_LOAD
)
408 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
410 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
411 if ((styp_flags
& STYP_RDATA
)
412 || styp_flags
== STYP_PDATA
413 || styp_flags
== STYP_RCONST
)
414 sec_flags
|= SEC_READONLY
;
416 else if ((styp_flags
& STYP_BSS
)
417 || (styp_flags
& STYP_SBSS
))
418 sec_flags
|= SEC_ALLOC
;
419 else if ((styp_flags
& STYP_INFO
) || styp_flags
== STYP_COMMENT
)
420 sec_flags
|= SEC_NEVER_LOAD
;
421 else if ((styp_flags
& STYP_LITA
)
422 || (styp_flags
& STYP_LIT8
)
423 || (styp_flags
& STYP_LIT4
))
424 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
425 else if (styp_flags
& STYP_ECOFF_LIB
)
426 sec_flags
|= SEC_COFF_SHARED_LIBRARY
;
428 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
430 * flags_ptr
= sec_flags
;
434 /* Read in the symbolic header for an ECOFF object file. */
437 ecoff_slurp_symbolic_header (bfd
*abfd
)
439 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
440 bfd_size_type external_hdr_size
;
442 HDRR
*internal_symhdr
;
444 /* See if we've already read it in. */
445 if (ecoff_data (abfd
)->debug_info
.symbolic_header
.magic
==
446 backend
->debug_swap
.sym_magic
)
449 /* See whether there is a symbolic header. */
450 if (ecoff_data (abfd
)->sym_filepos
== 0)
456 /* At this point bfd_get_symcount (abfd) holds the number of symbols
457 as read from the file header, but on ECOFF this is always the
458 size of the symbolic information header. It would be cleaner to
459 handle this when we first read the file in coffgen.c. */
460 external_hdr_size
= backend
->debug_swap
.external_hdr_size
;
461 if (bfd_get_symcount (abfd
) != external_hdr_size
)
463 bfd_set_error (bfd_error_bad_value
);
467 /* Read the symbolic information header. */
468 raw
= bfd_malloc (external_hdr_size
);
472 if (bfd_seek (abfd
, ecoff_data (abfd
)->sym_filepos
, SEEK_SET
) != 0
473 || bfd_bread (raw
, external_hdr_size
, abfd
) != external_hdr_size
)
475 internal_symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
476 (*backend
->debug_swap
.swap_hdr_in
) (abfd
, raw
, internal_symhdr
);
478 if (internal_symhdr
->magic
!= backend
->debug_swap
.sym_magic
)
480 bfd_set_error (bfd_error_bad_value
);
484 /* Now we can get the correct number of symbols. */
485 abfd
->symcount
= internal_symhdr
->isymMax
+ internal_symhdr
->iextMax
;
496 /* Read in and swap the important symbolic information for an ECOFF
497 object file. This is called by gdb via the read_debug_info entry
498 point in the backend structure. */
501 _bfd_ecoff_slurp_symbolic_info (bfd
*abfd
,
502 asection
*ignore ATTRIBUTE_UNUSED
,
503 struct ecoff_debug_info
*debug
)
505 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
506 HDRR
*internal_symhdr
;
507 bfd_size_type raw_base
;
508 bfd_size_type raw_size
;
510 bfd_size_type external_fdr_size
;
514 bfd_size_type raw_end
;
515 bfd_size_type cb_end
;
518 BFD_ASSERT (debug
== &ecoff_data (abfd
)->debug_info
);
520 /* Check whether we've already gotten it, and whether there's any to
522 if (ecoff_data (abfd
)->raw_syments
!= NULL
)
524 if (ecoff_data (abfd
)->sym_filepos
== 0)
530 if (! ecoff_slurp_symbolic_header (abfd
))
533 internal_symhdr
= &debug
->symbolic_header
;
535 /* Read all the symbolic information at once. */
536 raw_base
= (ecoff_data (abfd
)->sym_filepos
537 + backend
->debug_swap
.external_hdr_size
);
539 /* Alpha ecoff makes the determination of raw_size difficult. It has
540 an undocumented debug data section between the symhdr and the first
541 documented section. And the ordering of the sections varies between
542 statically and dynamically linked executables.
543 If bfd supports SEEK_END someday, this code could be simplified. */
546 #define UPDATE_RAW_END(start, count, size) \
547 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
548 if (cb_end > raw_end) \
551 UPDATE_RAW_END (cbLineOffset
, cbLine
, sizeof (unsigned char));
552 UPDATE_RAW_END (cbDnOffset
, idnMax
, backend
->debug_swap
.external_dnr_size
);
553 UPDATE_RAW_END (cbPdOffset
, ipdMax
, backend
->debug_swap
.external_pdr_size
);
554 UPDATE_RAW_END (cbSymOffset
, isymMax
, backend
->debug_swap
.external_sym_size
);
555 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
556 optimization symtab, not the number of entries. */
557 UPDATE_RAW_END (cbOptOffset
, ioptMax
, sizeof (char));
558 UPDATE_RAW_END (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
559 UPDATE_RAW_END (cbSsOffset
, issMax
, sizeof (char));
560 UPDATE_RAW_END (cbSsExtOffset
, issExtMax
, sizeof (char));
561 UPDATE_RAW_END (cbFdOffset
, ifdMax
, backend
->debug_swap
.external_fdr_size
);
562 UPDATE_RAW_END (cbRfdOffset
, crfd
, backend
->debug_swap
.external_rfd_size
);
563 UPDATE_RAW_END (cbExtOffset
, iextMax
, backend
->debug_swap
.external_ext_size
);
565 #undef UPDATE_RAW_END
567 raw_size
= raw_end
- raw_base
;
570 ecoff_data (abfd
)->sym_filepos
= 0;
573 raw
= bfd_alloc (abfd
, raw_size
);
577 pos
= ecoff_data (abfd
)->sym_filepos
;
578 pos
+= backend
->debug_swap
.external_hdr_size
;
579 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
580 || bfd_bread (raw
, raw_size
, abfd
) != raw_size
)
582 bfd_release (abfd
, raw
);
586 ecoff_data (abfd
)->raw_syments
= raw
;
588 /* Get pointers for the numeric offsets in the HDRR structure. */
589 #define FIX(off1, off2, type) \
590 if (internal_symhdr->off1 == 0) \
591 debug->off2 = NULL; \
593 debug->off2 = (type) ((char *) raw \
594 + (internal_symhdr->off1 \
597 FIX (cbLineOffset
, line
, unsigned char *);
598 FIX (cbDnOffset
, external_dnr
, void *);
599 FIX (cbPdOffset
, external_pdr
, void *);
600 FIX (cbSymOffset
, external_sym
, void *);
601 FIX (cbOptOffset
, external_opt
, void *);
602 FIX (cbAuxOffset
, external_aux
, union aux_ext
*);
603 FIX (cbSsOffset
, ss
, char *);
604 FIX (cbSsExtOffset
, ssext
, char *);
605 FIX (cbFdOffset
, external_fdr
, void *);
606 FIX (cbRfdOffset
, external_rfd
, void *);
607 FIX (cbExtOffset
, external_ext
, void *);
610 /* I don't want to always swap all the data, because it will just
611 waste time and most programs will never look at it. The only
612 time the linker needs most of the debugging information swapped
613 is when linking big-endian and little-endian MIPS object files
614 together, which is not a common occurrence.
616 We need to look at the fdr to deal with a lot of information in
617 the symbols, so we swap them here. */
618 debug
->fdr
= (FDR
*) bfd_alloc2 (abfd
, internal_symhdr
->ifdMax
,
619 sizeof (struct fdr
));
620 if (debug
->fdr
== NULL
)
622 external_fdr_size
= backend
->debug_swap
.external_fdr_size
;
623 fdr_ptr
= debug
->fdr
;
624 fraw_src
= (char *) debug
->external_fdr
;
625 /* PR 17512: file: 3372-1243-0.004. */
626 if (fraw_src
== NULL
&& internal_symhdr
->ifdMax
> 0)
628 fraw_end
= fraw_src
+ internal_symhdr
->ifdMax
* external_fdr_size
;
629 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
630 (*backend
->debug_swap
.swap_fdr_in
) (abfd
, (void *) fraw_src
, fdr_ptr
);
635 /* ECOFF symbol table routines. The ECOFF symbol table is described
636 in gcc/mips-tfile.c. */
638 /* ECOFF uses two common sections. One is the usual one, and the
639 other is for small objects. All the small objects are kept
640 together, and then referenced via the gp pointer, which yields
641 faster assembler code. This is what we use for the small common
643 static asection ecoff_scom_section
;
644 static asymbol ecoff_scom_symbol
;
645 static asymbol
*ecoff_scom_symbol_ptr
;
647 /* Create an empty symbol. */
650 _bfd_ecoff_make_empty_symbol (bfd
*abfd
)
652 ecoff_symbol_type
*new_symbol
;
653 size_t amt
= sizeof (ecoff_symbol_type
);
655 new_symbol
= (ecoff_symbol_type
*) bfd_zalloc (abfd
, amt
);
656 if (new_symbol
== NULL
)
658 new_symbol
->symbol
.section
= NULL
;
659 new_symbol
->fdr
= NULL
;
660 new_symbol
->local
= FALSE
;
661 new_symbol
->native
= NULL
;
662 new_symbol
->symbol
.the_bfd
= abfd
;
663 return &new_symbol
->symbol
;
666 /* Set the BFD flags and section for an ECOFF symbol. */
669 ecoff_set_symbol_info (bfd
*abfd
,
675 asym
->the_bfd
= abfd
;
676 asym
->value
= ecoff_sym
->value
;
677 asym
->section
= &bfd_debug_section
;
680 /* Most symbol types are just for debugging. */
681 switch (ecoff_sym
->st
)
690 if (ECOFF_IS_STAB (ecoff_sym
))
692 asym
->flags
= BSF_DEBUGGING
;
697 asym
->flags
= BSF_DEBUGGING
;
702 asym
->flags
= BSF_EXPORT
| BSF_WEAK
;
704 asym
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
707 asym
->flags
= BSF_LOCAL
;
708 /* Normally, a local stProc symbol will have a corresponding
709 external symbol. We mark the local symbol as a debugging
710 symbol, in order to prevent nm from printing both out.
711 Similarly, we mark stLabel and stabs symbols as debugging
712 symbols. In both cases, we do want to set the value
713 correctly based on the symbol class. */
714 if (ecoff_sym
->st
== stProc
715 || ecoff_sym
->st
== stLabel
716 || ECOFF_IS_STAB (ecoff_sym
))
717 asym
->flags
|= BSF_DEBUGGING
;
720 if (ecoff_sym
->st
== stProc
|| ecoff_sym
->st
== stStaticProc
)
721 asym
->flags
|= BSF_FUNCTION
;
723 switch (ecoff_sym
->sc
)
726 /* Used for compiler generated labels. Leave them in the
727 debugging section, and mark them as local. If BSF_DEBUGGING
728 is set, then nm does not display them for some reason. If no
729 flags are set then the linker whines about them. */
730 asym
->flags
= BSF_LOCAL
;
733 asym
->section
= bfd_make_section_old_way (abfd
, _TEXT
);
734 asym
->value
-= asym
->section
->vma
;
737 asym
->section
= bfd_make_section_old_way (abfd
, _DATA
);
738 asym
->value
-= asym
->section
->vma
;
741 asym
->section
= bfd_make_section_old_way (abfd
, _BSS
);
742 asym
->value
-= asym
->section
->vma
;
745 asym
->flags
= BSF_DEBUGGING
;
748 asym
->section
= bfd_abs_section_ptr
;
751 asym
->section
= bfd_und_section_ptr
;
761 asym
->flags
= BSF_DEBUGGING
;
764 asym
->section
= bfd_make_section_old_way (abfd
, ".sdata");
765 asym
->value
-= asym
->section
->vma
;
768 asym
->section
= bfd_make_section_old_way (abfd
, ".sbss");
769 asym
->value
-= asym
->section
->vma
;
772 asym
->section
= bfd_make_section_old_way (abfd
, ".rdata");
773 asym
->value
-= asym
->section
->vma
;
776 asym
->flags
= BSF_DEBUGGING
;
779 if (asym
->value
> ecoff_data (abfd
)->gp_size
)
781 asym
->section
= bfd_com_section_ptr
;
787 if (ecoff_scom_section
.name
== NULL
)
789 /* Initialize the small common section. */
790 ecoff_scom_section
.name
= SCOMMON
;
791 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
792 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
793 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
794 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
795 ecoff_scom_symbol
.name
= SCOMMON
;
796 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
797 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
798 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
800 asym
->section
= &ecoff_scom_section
;
805 asym
->flags
= BSF_DEBUGGING
;
808 asym
->section
= bfd_und_section_ptr
;
813 asym
->section
= bfd_make_section_old_way (abfd
, ".init");
814 asym
->value
-= asym
->section
->vma
;
819 asym
->flags
= BSF_DEBUGGING
;
822 asym
->section
= bfd_make_section_old_way (abfd
, ".fini");
823 asym
->value
-= asym
->section
->vma
;
826 asym
->section
= bfd_make_section_old_way (abfd
, ".rconst");
827 asym
->value
-= asym
->section
->vma
;
833 /* Look for special constructors symbols and make relocation entries
834 in a special construction section. These are produced by the
835 -fgnu-linker argument to g++. */
836 if (ECOFF_IS_STAB (ecoff_sym
))
838 switch (ECOFF_UNMARK_STAB (ecoff_sym
->index
))
847 /* Mark the symbol as a constructor. */
848 asym
->flags
|= BSF_CONSTRUCTOR
;
855 /* Read an ECOFF symbol table. */
858 _bfd_ecoff_slurp_symbol_table (bfd
*abfd
)
860 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
861 const bfd_size_type external_ext_size
862 = backend
->debug_swap
.external_ext_size
;
863 const bfd_size_type external_sym_size
864 = backend
->debug_swap
.external_sym_size
;
865 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
866 = backend
->debug_swap
.swap_ext_in
;
867 void (* const swap_sym_in
) (bfd
*, void *, SYMR
*)
868 = backend
->debug_swap
.swap_sym_in
;
869 ecoff_symbol_type
*internal
;
870 ecoff_symbol_type
*internal_ptr
;
876 /* If we've already read in the symbol table, do nothing. */
877 if (ecoff_data (abfd
)->canonical_symbols
!= NULL
)
880 /* Get the symbolic information. */
881 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
882 &ecoff_data (abfd
)->debug_info
))
884 if (bfd_get_symcount (abfd
) == 0)
887 internal
= (ecoff_symbol_type
*) bfd_alloc2 (abfd
, bfd_get_symcount (abfd
),
888 sizeof (ecoff_symbol_type
));
889 if (internal
== NULL
)
892 internal_ptr
= internal
;
893 eraw_src
= (char *) ecoff_data (abfd
)->debug_info
.external_ext
;
895 + (ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
896 * external_ext_size
));
897 for (; eraw_src
< eraw_end
; eraw_src
+= external_ext_size
, internal_ptr
++)
901 (*swap_ext_in
) (abfd
, (void *) eraw_src
, &internal_esym
);
903 /* PR 17512: file: 3372-1000-0.004. */
904 if (internal_esym
.asym
.iss
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.issExtMax
905 || internal_esym
.asym
.iss
< 0)
908 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ssext
909 + internal_esym
.asym
.iss
);
911 if (!ecoff_set_symbol_info (abfd
, &internal_esym
.asym
,
912 &internal_ptr
->symbol
, 1,
913 internal_esym
.weakext
))
916 /* The alpha uses a negative ifd field for section symbols. */
917 if (internal_esym
.ifd
>= 0)
919 /* PR 17512: file: 3372-1983-0.004. */
920 if (internal_esym
.ifd
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
)
921 internal_ptr
->fdr
= NULL
;
923 internal_ptr
->fdr
= (ecoff_data (abfd
)->debug_info
.fdr
924 + internal_esym
.ifd
);
927 internal_ptr
->fdr
= NULL
;
928 internal_ptr
->local
= FALSE
;
929 internal_ptr
->native
= (void *) eraw_src
;
932 /* The local symbols must be accessed via the fdr's, because the
933 string and aux indices are relative to the fdr information. */
934 fdr_ptr
= ecoff_data (abfd
)->debug_info
.fdr
;
935 fdr_end
= fdr_ptr
+ ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
;
936 for (; fdr_ptr
< fdr_end
; fdr_ptr
++)
941 lraw_src
= ((char *) ecoff_data (abfd
)->debug_info
.external_sym
942 + fdr_ptr
->isymBase
* external_sym_size
);
943 lraw_end
= lraw_src
+ fdr_ptr
->csym
* external_sym_size
;
946 lraw_src
+= external_sym_size
, internal_ptr
++)
950 (*swap_sym_in
) (abfd
, (void *) lraw_src
, &internal_sym
);
951 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ss
954 if (!ecoff_set_symbol_info (abfd
, &internal_sym
,
955 &internal_ptr
->symbol
, 0, 0))
957 internal_ptr
->fdr
= fdr_ptr
;
958 internal_ptr
->local
= TRUE
;
959 internal_ptr
->native
= (void *) lraw_src
;
963 /* PR 17512: file: 3372-3080-0.004.
964 A discrepancy between ecoff_data (abfd)->debug_info.symbolic_header.isymMax
965 and ecoff_data (abfd)->debug_info.symbolic_header.ifdMax can mean that
966 we have fewer symbols than we were expecting. Allow for this by updating
967 the symbol count and warning the user. */
968 if (internal_ptr
- internal
< (ptrdiff_t) bfd_get_symcount (abfd
))
970 abfd
->symcount
= internal_ptr
- internal
;
972 /* xgettext:c-format */
973 (_("%pB: warning: isymMax (%ld) is greater than ifdMax (%ld)"),
974 abfd
, ecoff_data (abfd
)->debug_info
.symbolic_header
.isymMax
,
975 ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
);
978 ecoff_data (abfd
)->canonical_symbols
= internal
;
983 /* Return the amount of space needed for the canonical symbols. */
986 _bfd_ecoff_get_symtab_upper_bound (bfd
*abfd
)
988 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
989 &ecoff_data (abfd
)->debug_info
))
992 if (bfd_get_symcount (abfd
) == 0)
995 return (bfd_get_symcount (abfd
) + 1) * (sizeof (ecoff_symbol_type
*));
998 /* Get the canonical symbols. */
1001 _bfd_ecoff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
1003 unsigned int counter
= 0;
1004 ecoff_symbol_type
*symbase
;
1005 ecoff_symbol_type
**location
= (ecoff_symbol_type
**) alocation
;
1007 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1009 if (bfd_get_symcount (abfd
) == 0)
1012 symbase
= ecoff_data (abfd
)->canonical_symbols
;
1013 while (counter
< bfd_get_symcount (abfd
))
1015 *(location
++) = symbase
++;
1019 return bfd_get_symcount (abfd
);
1022 /* Turn ECOFF type information into a printable string.
1023 ecoff_emit_aggregate and ecoff_type_to_string are from
1024 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1026 /* Write aggregate information to a string. */
1029 ecoff_emit_aggregate (bfd
*abfd
,
1036 const struct ecoff_debug_swap
* const debug_swap
=
1037 &ecoff_backend (abfd
)->debug_swap
;
1038 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1039 unsigned int ifd
= rndx
->rfd
;
1040 unsigned int indx
= rndx
->index
;
1046 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1047 struct return type of a procedure compiled without -g. */
1048 if (ifd
== 0xffffffff
1049 || (rndx
->rfd
== 0xfff && indx
== 0))
1050 name
= "<undefined>";
1051 else if (indx
== indexNil
)
1057 if (debug_info
->external_rfd
== NULL
)
1058 fdr
= debug_info
->fdr
+ ifd
;
1063 (*debug_swap
->swap_rfd_in
) (abfd
,
1064 ((char *) debug_info
->external_rfd
1065 + ((fdr
->rfdBase
+ ifd
)
1066 * debug_swap
->external_rfd_size
)),
1068 fdr
= debug_info
->fdr
+ rfd
;
1071 indx
+= fdr
->isymBase
;
1073 (*debug_swap
->swap_sym_in
) (abfd
,
1074 ((char *) debug_info
->external_sym
1075 + indx
* debug_swap
->external_sym_size
),
1078 name
= debug_info
->ss
+ fdr
->issBase
+ sym
.iss
;
1082 "%s %s { ifd = %u, index = %lu }",
1084 ((unsigned long) indx
1085 + debug_info
->symbolic_header
.iextMax
));
1088 /* Convert the type information to string format. */
1091 ecoff_type_to_string (bfd
*abfd
, FDR
*fdr
, unsigned int indx
)
1093 union aux_ext
*aux_ptr
;
1103 unsigned int basic_type
;
1106 static char buffer2
[1024];
1111 aux_ptr
= ecoff_data (abfd
)->debug_info
.external_aux
+ fdr
->iauxBase
;
1112 bigendian
= fdr
->fBigendian
;
1114 for (i
= 0; i
< 7; i
++)
1116 qualifiers
[i
].low_bound
= 0;
1117 qualifiers
[i
].high_bound
= 0;
1118 qualifiers
[i
].stride
= 0;
1121 if (AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
]) == (bfd_vma
) -1)
1122 return "-1 (no type)";
1123 _bfd_ecoff_swap_tir_in (bigendian
, &aux_ptr
[indx
++].a_ti
, &u
.ti
);
1125 basic_type
= u
.ti
.bt
;
1126 qualifiers
[0].type
= u
.ti
.tq0
;
1127 qualifiers
[1].type
= u
.ti
.tq1
;
1128 qualifiers
[2].type
= u
.ti
.tq2
;
1129 qualifiers
[3].type
= u
.ti
.tq3
;
1130 qualifiers
[4].type
= u
.ti
.tq4
;
1131 qualifiers
[5].type
= u
.ti
.tq5
;
1132 qualifiers
[6].type
= tqNil
;
1134 /* Go get the basic type. */
1137 case btNil
: /* Undefined. */
1141 case btAdr
: /* Address - integer same size as pointer. */
1142 strcpy (p1
, "address");
1145 case btChar
: /* Character. */
1146 strcpy (p1
, "char");
1149 case btUChar
: /* Unsigned character. */
1150 strcpy (p1
, "unsigned char");
1153 case btShort
: /* Short. */
1154 strcpy (p1
, "short");
1157 case btUShort
: /* Unsigned short. */
1158 strcpy (p1
, "unsigned short");
1161 case btInt
: /* Int. */
1165 case btUInt
: /* Unsigned int. */
1166 strcpy (p1
, "unsigned int");
1169 case btLong
: /* Long. */
1170 strcpy (p1
, "long");
1173 case btULong
: /* Unsigned long. */
1174 strcpy (p1
, "unsigned long");
1177 case btFloat
: /* Float (real). */
1178 strcpy (p1
, "float");
1181 case btDouble
: /* Double (real). */
1182 strcpy (p1
, "double");
1185 /* Structures add 1-2 aux words:
1186 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1187 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1189 case btStruct
: /* Structure (Record). */
1190 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1191 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1192 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1194 indx
++; /* Skip aux words. */
1197 /* Unions add 1-2 aux words:
1198 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1199 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1201 case btUnion
: /* Union. */
1202 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1203 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1204 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1206 indx
++; /* Skip aux words. */
1209 /* Enumerations add 1-2 aux words:
1210 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1211 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1213 case btEnum
: /* Enumeration. */
1214 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1215 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1216 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1218 indx
++; /* Skip aux words. */
1221 case btTypedef
: /* Defined via a typedef, isymRef points. */
1222 strcpy (p1
, "typedef");
1225 case btRange
: /* Subrange of int. */
1226 strcpy (p1
, "subrange");
1229 case btSet
: /* Pascal sets. */
1233 case btComplex
: /* Fortran complex. */
1234 strcpy (p1
, "complex");
1237 case btDComplex
: /* Fortran double complex. */
1238 strcpy (p1
, "double complex");
1241 case btIndirect
: /* Forward or unnamed typedef. */
1242 strcpy (p1
, "forward/unamed typedef");
1245 case btFixedDec
: /* Fixed Decimal. */
1246 strcpy (p1
, "fixed decimal");
1249 case btFloatDec
: /* Float Decimal. */
1250 strcpy (p1
, "float decimal");
1253 case btString
: /* Varying Length Character String. */
1254 strcpy (p1
, "string");
1257 case btBit
: /* Aligned Bit String. */
1261 case btPicture
: /* Picture. */
1262 strcpy (p1
, "picture");
1265 case btVoid
: /* Void. */
1266 strcpy (p1
, "void");
1270 sprintf (p1
, _("unknown basic type %d"), (int) basic_type
);
1274 p1
+= strlen (buffer1
);
1276 /* If this is a bitfield, get the bitsize. */
1281 bitsize
= AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
++]);
1282 sprintf (p1
, " : %d", bitsize
);
1283 p1
+= strlen (buffer1
);
1286 /* Deal with any qualifiers. */
1287 if (qualifiers
[0].type
!= tqNil
)
1289 /* Snarf up any array bounds in the correct order. Arrays
1290 store 5 successive words in the aux. table:
1291 word 0 RNDXR to type of the bounds (ie, int)
1292 word 1 Current file descriptor index
1294 word 3 high bound (or -1 if [])
1295 word 4 stride size in bits. */
1296 for (i
= 0; i
< 7; i
++)
1298 if (qualifiers
[i
].type
== tqArray
)
1300 qualifiers
[i
].low_bound
=
1301 AUX_GET_DNLOW (bigendian
, &aux_ptr
[indx
+2]);
1302 qualifiers
[i
].high_bound
=
1303 AUX_GET_DNHIGH (bigendian
, &aux_ptr
[indx
+3]);
1304 qualifiers
[i
].stride
=
1305 AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
+4]);
1310 /* Now print out the qualifiers. */
1311 for (i
= 0; i
< 6; i
++)
1313 switch (qualifiers
[i
].type
)
1320 strcpy (p2
, "ptr to ");
1321 p2
+= sizeof ("ptr to ")-1;
1325 strcpy (p2
, "volatile ");
1326 p2
+= sizeof ("volatile ")-1;
1330 strcpy (p2
, "far ");
1331 p2
+= sizeof ("far ")-1;
1335 strcpy (p2
, "func. ret. ");
1336 p2
+= sizeof ("func. ret. ");
1341 int first_array
= i
;
1344 /* Print array bounds reversed (ie, in the order the C
1345 programmer writes them). C is such a fun language.... */
1346 while (i
< 5 && qualifiers
[i
+1].type
== tqArray
)
1349 for (j
= i
; j
>= first_array
; j
--)
1351 strcpy (p2
, "array [");
1352 p2
+= sizeof ("array [")-1;
1353 if (qualifiers
[j
].low_bound
!= 0)
1355 "%ld:%ld {%ld bits}",
1356 (long) qualifiers
[j
].low_bound
,
1357 (long) qualifiers
[j
].high_bound
,
1358 (long) qualifiers
[j
].stride
);
1360 else if (qualifiers
[j
].high_bound
!= -1)
1363 (long) (qualifiers
[j
].high_bound
+ 1),
1364 (long) (qualifiers
[j
].stride
));
1367 sprintf (p2
, " {%ld bits}", (long) (qualifiers
[j
].stride
));
1370 strcpy (p2
, "] of ");
1371 p2
+= sizeof ("] of ")-1;
1379 strcpy (p2
, buffer1
);
1383 /* Return information about ECOFF symbol SYMBOL in RET. */
1386 _bfd_ecoff_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
1390 bfd_symbol_info (symbol
, ret
);
1393 /* Return whether this is a local label. */
1396 _bfd_ecoff_bfd_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1399 return name
[0] == '$';
1402 /* Print information about an ECOFF symbol. */
1405 _bfd_ecoff_print_symbol (bfd
*abfd
,
1408 bfd_print_symbol_type how
)
1410 const struct ecoff_debug_swap
* const debug_swap
1411 = &ecoff_backend (abfd
)->debug_swap
;
1412 FILE *file
= (FILE *)filep
;
1416 case bfd_print_symbol_name
:
1417 fprintf (file
, "%s", symbol
->name
);
1419 case bfd_print_symbol_more
:
1420 if (ecoffsymbol (symbol
)->local
)
1424 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1426 fprintf (file
, "ecoff local ");
1427 fprintf_vma (file
, (bfd_vma
) ecoff_sym
.value
);
1428 fprintf (file
, " %x %x", (unsigned) ecoff_sym
.st
,
1429 (unsigned) ecoff_sym
.sc
);
1435 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1437 fprintf (file
, "ecoff extern ");
1438 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1439 fprintf (file
, " %x %x", (unsigned) ecoff_ext
.asym
.st
,
1440 (unsigned) ecoff_ext
.asym
.sc
);
1443 case bfd_print_symbol_all
:
1444 /* Print out the symbols in a reasonable way. */
1453 if (ecoffsymbol (symbol
)->local
)
1455 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1458 pos
= ((((char *) ecoffsymbol (symbol
)->native
1459 - (char *) ecoff_data (abfd
)->debug_info
.external_sym
)
1460 / debug_swap
->external_sym_size
)
1461 + ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
);
1468 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1471 pos
= (((char *) ecoffsymbol (symbol
)->native
1472 - (char *) ecoff_data (abfd
)->debug_info
.external_ext
)
1473 / debug_swap
->external_ext_size
);
1474 jmptbl
= ecoff_ext
.jmptbl
? 'j' : ' ';
1475 cobol_main
= ecoff_ext
.cobol_main
? 'c' : ' ';
1476 weakext
= ecoff_ext
.weakext
? 'w' : ' ';
1479 fprintf (file
, "[%3d] %c ",
1481 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1482 fprintf (file
, " st %x sc %x indx %x %c%c%c %s",
1483 (unsigned) ecoff_ext
.asym
.st
,
1484 (unsigned) ecoff_ext
.asym
.sc
,
1485 (unsigned) ecoff_ext
.asym
.index
,
1486 jmptbl
, cobol_main
, weakext
,
1489 if (ecoffsymbol (symbol
)->fdr
!= NULL
1490 && ecoff_ext
.asym
.index
!= indexNil
)
1495 bfd_size_type sym_base
;
1496 union aux_ext
*aux_base
;
1498 fdr
= ecoffsymbol (symbol
)->fdr
;
1499 indx
= ecoff_ext
.asym
.index
;
1501 /* sym_base is used to map the fdr relative indices which
1502 appear in the file to the position number which we are
1504 sym_base
= fdr
->isymBase
;
1505 if (ecoffsymbol (symbol
)->local
)
1507 ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
1509 /* aux_base is the start of the aux entries for this file;
1510 asym.index is an offset from this. */
1511 aux_base
= (ecoff_data (abfd
)->debug_info
.external_aux
1514 /* The aux entries are stored in host byte order; the
1515 order is indicated by a bit in the fdr. */
1516 bigendian
= fdr
->fBigendian
;
1518 /* This switch is basically from gcc/mips-tdump.c. */
1519 switch (ecoff_ext
.asym
.st
)
1527 fprintf (file
, _("\n End+1 symbol: %ld"),
1528 (long) (indx
+ sym_base
));
1532 if (ecoff_ext
.asym
.sc
== scText
1533 || ecoff_ext
.asym
.sc
== scInfo
)
1534 fprintf (file
, _("\n First symbol: %ld"),
1535 (long) (indx
+ sym_base
));
1537 fprintf (file
, _("\n First symbol: %ld"),
1539 (AUX_GET_ISYM (bigendian
,
1540 &aux_base
[ecoff_ext
.asym
.index
])
1546 if (ECOFF_IS_STAB (&ecoff_ext
.asym
))
1548 else if (ecoffsymbol (symbol
)->local
)
1549 /* xgettext:c-format */
1550 fprintf (file
, _("\n End+1 symbol: %-7ld Type: %s"),
1552 (AUX_GET_ISYM (bigendian
,
1553 &aux_base
[ecoff_ext
.asym
.index
])
1555 ecoff_type_to_string (abfd
, fdr
, indx
+ 1));
1557 fprintf (file
, _("\n Local symbol: %ld"),
1560 + (ecoff_data (abfd
)
1561 ->debug_info
.symbolic_header
.iextMax
)));
1565 fprintf (file
, _("\n struct; End+1 symbol: %ld"),
1566 (long) (indx
+ sym_base
));
1570 fprintf (file
, _("\n union; End+1 symbol: %ld"),
1571 (long) (indx
+ sym_base
));
1575 fprintf (file
, _("\n enum; End+1 symbol: %ld"),
1576 (long) (indx
+ sym_base
));
1580 if (! ECOFF_IS_STAB (&ecoff_ext
.asym
))
1581 fprintf (file
, _("\n Type: %s"),
1582 ecoff_type_to_string (abfd
, fdr
, indx
));
1591 /* Read in the relocs for a section. */
1594 ecoff_slurp_reloc_table (bfd
*abfd
,
1598 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1599 arelent
*internal_relocs
;
1600 bfd_size_type external_reloc_size
;
1602 char *external_relocs
;
1606 if (section
->relocation
!= NULL
1607 || section
->reloc_count
== 0
1608 || (section
->flags
& SEC_CONSTRUCTOR
) != 0)
1611 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1614 amt
= section
->reloc_count
;
1615 amt
*= sizeof (arelent
);
1616 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
1618 external_reloc_size
= backend
->external_reloc_size
;
1619 amt
= external_reloc_size
* section
->reloc_count
;
1620 external_relocs
= (char *) bfd_alloc (abfd
, amt
);
1621 if (internal_relocs
== NULL
|| external_relocs
== NULL
)
1623 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1625 if (bfd_bread (external_relocs
, amt
, abfd
) != amt
)
1628 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1630 struct internal_reloc intern
;
1632 (*backend
->swap_reloc_in
) (abfd
,
1633 external_relocs
+ i
* external_reloc_size
,
1636 if (intern
.r_extern
)
1638 /* r_symndx is an index into the external symbols. */
1639 BFD_ASSERT (intern
.r_symndx
>= 0
1641 < (ecoff_data (abfd
)
1642 ->debug_info
.symbolic_header
.iextMax
)));
1643 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1646 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1647 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1649 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1654 const char *sec_name
;
1657 /* r_symndx is a section key. */
1658 switch (intern
.r_symndx
)
1660 case RELOC_SECTION_TEXT
: sec_name
= _TEXT
; break;
1661 case RELOC_SECTION_RDATA
: sec_name
= _RDATA
; break;
1662 case RELOC_SECTION_DATA
: sec_name
= _DATA
; break;
1663 case RELOC_SECTION_SDATA
: sec_name
= _SDATA
; break;
1664 case RELOC_SECTION_SBSS
: sec_name
= _SBSS
; break;
1665 case RELOC_SECTION_BSS
: sec_name
= _BSS
; break;
1666 case RELOC_SECTION_INIT
: sec_name
= _INIT
; break;
1667 case RELOC_SECTION_LIT8
: sec_name
= _LIT8
; break;
1668 case RELOC_SECTION_LIT4
: sec_name
= _LIT4
; break;
1669 case RELOC_SECTION_XDATA
: sec_name
= _XDATA
; break;
1670 case RELOC_SECTION_PDATA
: sec_name
= _PDATA
; break;
1671 case RELOC_SECTION_FINI
: sec_name
= _FINI
; break;
1672 case RELOC_SECTION_LITA
: sec_name
= _LITA
; break;
1673 case RELOC_SECTION_RCONST
: sec_name
= _RCONST
; break;
1677 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1680 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1682 rptr
->addend
= - bfd_section_vma (sec
);
1685 rptr
->address
= intern
.r_vaddr
- bfd_section_vma (section
);
1687 /* Let the backend select the howto field and do any other
1688 required processing. */
1689 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1692 bfd_release (abfd
, external_relocs
);
1694 section
->relocation
= internal_relocs
;
1699 /* Get a canonical list of relocs. */
1702 _bfd_ecoff_canonicalize_reloc (bfd
*abfd
,
1709 if (section
->flags
& SEC_CONSTRUCTOR
)
1711 arelent_chain
*chain
;
1713 /* This section has relocs made up by us, not the file, so take
1714 them out of their chain and place them into the data area
1716 for (count
= 0, chain
= section
->constructor_chain
;
1717 count
< section
->reloc_count
;
1718 count
++, chain
= chain
->next
)
1719 *relptr
++ = &chain
->relent
;
1725 if (! ecoff_slurp_reloc_table (abfd
, section
, symbols
))
1728 tblptr
= section
->relocation
;
1730 for (count
= 0; count
< section
->reloc_count
; count
++)
1731 *relptr
++ = tblptr
++;
1736 return section
->reloc_count
;
1739 /* Provided a BFD, a section and an offset into the section, calculate
1740 and return the name of the source file and the line nearest to the
1744 _bfd_ecoff_find_nearest_line (bfd
*abfd
,
1745 asymbol
**symbols ATTRIBUTE_UNUSED
,
1748 const char **filename_ptr
,
1749 const char **functionname_ptr
,
1750 unsigned int *retline_ptr
,
1751 unsigned int *discriminator_ptr
)
1753 const struct ecoff_debug_swap
* const debug_swap
1754 = &ecoff_backend (abfd
)->debug_swap
;
1755 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1756 struct ecoff_find_line
*line_info
;
1758 /* Make sure we have the FDR's. */
1759 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
, debug_info
)
1760 || bfd_get_symcount (abfd
) == 0)
1763 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1765 size_t amt
= sizeof (struct ecoff_find_line
);
1767 ecoff_data (abfd
)->find_line_info
=
1768 (struct ecoff_find_line
*) bfd_zalloc (abfd
, amt
);
1769 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1773 if (discriminator_ptr
)
1774 *discriminator_ptr
= 0;
1775 line_info
= ecoff_data (abfd
)->find_line_info
;
1776 return _bfd_ecoff_locate_line (abfd
, section
, offset
, debug_info
,
1777 debug_swap
, line_info
, filename_ptr
,
1778 functionname_ptr
, retline_ptr
);
1781 /* Copy private BFD data. This is called by objcopy and strip. We
1782 use it to copy the ECOFF debugging information from one BFD to the
1783 other. It would be theoretically possible to represent the ECOFF
1784 debugging information in the symbol table. However, it would be a
1785 lot of work, and there would be little gain (gas, gdb, and ld
1786 already access the ECOFF debugging information via the
1787 ecoff_debug_info structure, and that structure would have to be
1788 retained in order to support ECOFF debugging in MIPS ELF).
1790 The debugging information for the ECOFF external symbols comes from
1791 the symbol table, so this function only handles the other debugging
1795 _bfd_ecoff_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1797 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
1798 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
1800 asymbol
**sym_ptr_ptr
;
1804 /* We only want to copy information over if both BFD's use ECOFF
1806 if (bfd_get_flavour (ibfd
) != bfd_target_ecoff_flavour
1807 || bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
1810 /* Copy the GP value and the register masks. */
1811 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
1812 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
1813 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
1814 for (i
= 0; i
< 3; i
++)
1815 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
1817 /* Copy the version stamp. */
1818 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
1820 /* If there are no symbols, don't copy any debugging information. */
1821 c
= bfd_get_symcount (obfd
);
1822 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1823 if (c
== 0 || sym_ptr_ptr
== NULL
)
1826 /* See if there are any local symbols. */
1828 for (; c
> 0; c
--, sym_ptr_ptr
++)
1830 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
1839 /* There are some local symbols. We just bring over all the
1840 debugging information. FIXME: This is not quite the right
1841 thing to do. If the user has asked us to discard all
1842 debugging information, then we are probably going to wind up
1843 keeping it because there will probably be some local symbol
1844 which objcopy did not discard. We should actually break
1845 apart the debugging information and only keep that which
1846 applies to the symbols we want to keep. */
1847 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
1848 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
1849 oinfo
->line
= iinfo
->line
;
1851 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
1852 oinfo
->external_dnr
= iinfo
->external_dnr
;
1854 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
1855 oinfo
->external_pdr
= iinfo
->external_pdr
;
1857 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
1858 oinfo
->external_sym
= iinfo
->external_sym
;
1860 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
1861 oinfo
->external_opt
= iinfo
->external_opt
;
1863 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
1864 oinfo
->external_aux
= iinfo
->external_aux
;
1866 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
1867 oinfo
->ss
= iinfo
->ss
;
1869 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
1870 oinfo
->external_fdr
= iinfo
->external_fdr
;
1872 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
1873 oinfo
->external_rfd
= iinfo
->external_rfd
;
1877 /* We are discarding all the local symbol information. Look
1878 through the external symbols and remove all references to FDR
1879 or aux information. */
1880 c
= bfd_get_symcount (obfd
);
1881 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1882 for (; c
> 0; c
--, sym_ptr_ptr
++)
1886 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
1887 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
1889 esym
.asym
.index
= indexNil
;
1890 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
1891 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
1898 /* Set the architecture. The supported architecture is stored in the
1899 backend pointer. We always set the architecture anyhow, since many
1900 callers ignore the return value. */
1903 _bfd_ecoff_set_arch_mach (bfd
*abfd
,
1904 enum bfd_architecture arch
,
1905 unsigned long machine
)
1907 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1908 return arch
== ecoff_backend (abfd
)->arch
;
1911 /* Get the size of the section headers. */
1914 _bfd_ecoff_sizeof_headers (bfd
*abfd
,
1915 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1922 for (current
= abfd
->sections
;
1924 current
= current
->next
)
1927 ret
= (bfd_coff_filhsz (abfd
)
1928 + bfd_coff_aoutsz (abfd
)
1929 + c
* bfd_coff_scnhsz (abfd
));
1930 return (int) BFD_ALIGN (ret
, 16);
1933 /* Get the contents of a section. */
1936 _bfd_ecoff_get_section_contents (bfd
*abfd
,
1940 bfd_size_type count
)
1942 return _bfd_generic_get_section_contents (abfd
, section
, location
,
1946 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
1947 called via qsort. */
1950 ecoff_sort_hdrs (const void * arg1
, const void * arg2
)
1952 const asection
*hdr1
= *(const asection
**) arg1
;
1953 const asection
*hdr2
= *(const asection
**) arg2
;
1955 if ((hdr1
->flags
& SEC_ALLOC
) != 0)
1957 if ((hdr2
->flags
& SEC_ALLOC
) == 0)
1962 if ((hdr2
->flags
& SEC_ALLOC
) != 0)
1965 if (hdr1
->vma
< hdr2
->vma
)
1967 else if (hdr1
->vma
> hdr2
->vma
)
1973 /* Calculate the file position for each section, and set
1977 ecoff_compute_section_file_positions (bfd
*abfd
)
1979 file_ptr sofar
, file_sofar
;
1980 asection
**sorted_hdrs
;
1984 bfd_boolean rdata_in_text
;
1985 bfd_boolean first_data
, first_nonalloc
;
1986 const bfd_vma round
= ecoff_backend (abfd
)->round
;
1989 sofar
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
1992 /* Sort the sections by VMA. */
1993 amt
= abfd
->section_count
;
1994 amt
*= sizeof (asection
*);
1995 sorted_hdrs
= (asection
**) bfd_malloc (amt
);
1996 if (sorted_hdrs
== NULL
)
1998 for (current
= abfd
->sections
, i
= 0;
2000 current
= current
->next
, i
++)
2001 sorted_hdrs
[i
] = current
;
2002 BFD_ASSERT (i
== abfd
->section_count
);
2004 qsort (sorted_hdrs
, abfd
->section_count
, sizeof (asection
*),
2007 /* Some versions of the OSF linker put the .rdata section in the
2008 text segment, and some do not. */
2009 rdata_in_text
= ecoff_backend (abfd
)->rdata_in_text
;
2012 for (i
= 0; i
< abfd
->section_count
; i
++)
2014 current
= sorted_hdrs
[i
];
2015 if (streq (current
->name
, _RDATA
))
2017 if ((current
->flags
& SEC_CODE
) == 0
2018 && ! streq (current
->name
, _PDATA
)
2019 && ! streq (current
->name
, _RCONST
))
2021 rdata_in_text
= FALSE
;
2026 ecoff_data (abfd
)->rdata_in_text
= rdata_in_text
;
2029 first_nonalloc
= TRUE
;
2030 for (i
= 0; i
< abfd
->section_count
; i
++)
2032 unsigned int alignment_power
;
2034 current
= sorted_hdrs
[i
];
2036 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2037 supposed to indicate the number of .pdata entries that are
2038 really in the section. Each entry is 8 bytes. We store this
2039 away in line_filepos before increasing the section size. */
2040 if (streq (current
->name
, _PDATA
))
2041 current
->line_filepos
= current
->size
/ 8;
2043 alignment_power
= current
->alignment_power
;
2045 /* On Ultrix, the data sections in an executable file must be
2046 aligned to a page boundary within the file. This does not
2047 affect the section size, though. FIXME: Does this work for
2048 other platforms? It requires some modification for the
2049 Alpha, because .rdata on the Alpha goes with the text, not
2051 if ((abfd
->flags
& EXEC_P
) != 0
2052 && (abfd
->flags
& D_PAGED
) != 0
2054 && (current
->flags
& SEC_CODE
) == 0
2056 || ! streq (current
->name
, _RDATA
))
2057 && ! streq (current
->name
, _PDATA
)
2058 && ! streq (current
->name
, _RCONST
))
2060 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2061 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2064 else if (streq (current
->name
, _LIB
))
2066 /* On Irix 4, the location of contents of the .lib section
2067 from a shared library section is also rounded up to a
2070 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2071 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2073 else if (first_nonalloc
2074 && (current
->flags
& SEC_ALLOC
) == 0
2075 && (abfd
->flags
& D_PAGED
) != 0)
2077 /* Skip up to the next page for an unallocated section, such
2078 as the .comment section on the Alpha. This leaves room
2079 for the .bss section. */
2080 first_nonalloc
= FALSE
;
2081 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2082 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2085 /* Align the sections in the file to the same boundary on
2086 which they are aligned in virtual memory. */
2087 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2088 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2089 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2091 if ((abfd
->flags
& D_PAGED
) != 0
2092 && (current
->flags
& SEC_ALLOC
) != 0)
2094 sofar
+= (current
->vma
- sofar
) % round
;
2095 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2096 file_sofar
+= (current
->vma
- file_sofar
) % round
;
2099 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) != 0)
2100 current
->filepos
= file_sofar
;
2102 sofar
+= current
->size
;
2103 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2104 file_sofar
+= current
->size
;
2106 /* Make sure that this section is of the right size too. */
2108 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2109 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2110 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2111 current
->size
+= sofar
- old_sofar
;
2117 ecoff_data (abfd
)->reloc_filepos
= file_sofar
;
2122 /* Determine the location of the relocs for all the sections in the
2123 output file, as well as the location of the symbolic debugging
2126 static bfd_size_type
2127 ecoff_compute_reloc_file_positions (bfd
*abfd
)
2129 const bfd_size_type external_reloc_size
=
2130 ecoff_backend (abfd
)->external_reloc_size
;
2131 file_ptr reloc_base
;
2132 bfd_size_type reloc_size
;
2136 if (! abfd
->output_has_begun
)
2138 if (! ecoff_compute_section_file_positions (abfd
))
2140 abfd
->output_has_begun
= TRUE
;
2143 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2146 for (current
= abfd
->sections
;
2148 current
= current
->next
)
2150 if (current
->reloc_count
== 0)
2151 current
->rel_filepos
= 0;
2154 bfd_size_type relsize
;
2156 current
->rel_filepos
= reloc_base
;
2157 relsize
= current
->reloc_count
* external_reloc_size
;
2158 reloc_size
+= relsize
;
2159 reloc_base
+= relsize
;
2163 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2165 /* At least on Ultrix, the symbol table of an executable file must
2166 be aligned to a page boundary. FIXME: Is this true on other
2168 if ((abfd
->flags
& EXEC_P
) != 0
2169 && (abfd
->flags
& D_PAGED
) != 0)
2170 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2171 &~ (ecoff_backend (abfd
)->round
- 1));
2173 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2178 /* Set the contents of a section. */
2181 _bfd_ecoff_set_section_contents (bfd
*abfd
,
2183 const void * location
,
2185 bfd_size_type count
)
2189 /* This must be done first, because bfd_set_section_contents is
2190 going to set output_has_begun to TRUE. */
2191 if (! abfd
->output_has_begun
2192 && ! ecoff_compute_section_file_positions (abfd
))
2195 /* Handle the .lib section specially so that Irix 4 shared libraries
2196 work out. See coff_set_section_contents in coffcode.h. */
2197 if (streq (section
->name
, _LIB
))
2199 bfd_byte
*rec
, *recend
;
2201 rec
= (bfd_byte
*) location
;
2202 recend
= rec
+ count
;
2203 while (rec
< recend
)
2206 rec
+= bfd_get_32 (abfd
, rec
) * 4;
2209 BFD_ASSERT (rec
== recend
);
2215 pos
= section
->filepos
+ offset
;
2216 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2217 || bfd_bwrite (location
, count
, abfd
) != count
)
2223 /* Set the GP value for an ECOFF file. This is a hook used by the
2227 bfd_ecoff_set_gp_value (bfd
*abfd
, bfd_vma gp_value
)
2229 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2230 || bfd_get_format (abfd
) != bfd_object
)
2232 bfd_set_error (bfd_error_invalid_operation
);
2236 ecoff_data (abfd
)->gp
= gp_value
;
2241 /* Set the register masks for an ECOFF file. This is a hook used by
2245 bfd_ecoff_set_regmasks (bfd
*abfd
,
2246 unsigned long gprmask
,
2247 unsigned long fprmask
,
2248 unsigned long *cprmask
)
2250 ecoff_data_type
*tdata
;
2252 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2253 || bfd_get_format (abfd
) != bfd_object
)
2255 bfd_set_error (bfd_error_invalid_operation
);
2259 tdata
= ecoff_data (abfd
);
2260 tdata
->gprmask
= gprmask
;
2261 tdata
->fprmask
= fprmask
;
2262 if (cprmask
!= NULL
)
2266 for (i
= 0; i
< 3; i
++)
2267 tdata
->cprmask
[i
] = cprmask
[i
];
2273 /* Get ECOFF EXTR information for an external symbol. This function
2274 is passed to bfd_ecoff_debug_externals. */
2277 ecoff_get_extr (asymbol
*sym
, EXTR
*esym
)
2279 ecoff_symbol_type
*ecoff_sym_ptr
;
2282 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2283 || ecoffsymbol (sym
)->native
== NULL
)
2285 /* Don't include debugging, local, or section symbols. */
2286 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2287 || (sym
->flags
& BSF_LOCAL
) != 0
2288 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2292 esym
->cobol_main
= 0;
2293 esym
->weakext
= (sym
->flags
& BSF_WEAK
) != 0;
2296 /* FIXME: we can do better than this for st and sc. */
2297 esym
->asym
.st
= stGlobal
;
2298 esym
->asym
.sc
= scAbs
;
2299 esym
->asym
.reserved
= 0;
2300 esym
->asym
.index
= indexNil
;
2304 ecoff_sym_ptr
= ecoffsymbol (sym
);
2306 if (ecoff_sym_ptr
->local
)
2309 input_bfd
= bfd_asymbol_bfd (sym
);
2310 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2311 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2313 /* If the symbol was defined by the linker, then esym will be
2314 undefined but sym will not be. Get a better class for such a
2316 if ((esym
->asym
.sc
== scUndefined
2317 || esym
->asym
.sc
== scSUndefined
)
2318 && ! bfd_is_und_section (bfd_asymbol_section (sym
)))
2319 esym
->asym
.sc
= scAbs
;
2321 /* Adjust the FDR index for the symbol by that used for the input
2323 if (esym
->ifd
!= -1)
2325 struct ecoff_debug_info
*input_debug
;
2327 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2328 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2329 if (input_debug
->ifdmap
!= NULL
)
2330 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2336 /* Set the external symbol index. This routine is passed to
2337 bfd_ecoff_debug_externals. */
2340 ecoff_set_index (asymbol
*sym
, bfd_size_type indx
)
2342 ecoff_set_sym_index (sym
, indx
);
2345 /* Write out an ECOFF file. */
2348 _bfd_ecoff_write_object_contents (bfd
*abfd
)
2350 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2351 const bfd_vma round
= backend
->round
;
2352 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2353 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2354 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2355 const bfd_size_type external_hdr_size
2356 = backend
->debug_swap
.external_hdr_size
;
2357 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2358 void (* const adjust_reloc_out
) (bfd
*, const arelent
*, struct internal_reloc
*)
2359 = backend
->adjust_reloc_out
;
2360 void (* const swap_reloc_out
) (bfd
*, const struct internal_reloc
*, void *)
2361 = backend
->swap_reloc_out
;
2362 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2363 HDRR
* const symhdr
= &debug
->symbolic_header
;
2366 bfd_size_type reloc_size
;
2367 bfd_size_type text_size
;
2369 bfd_boolean set_text_start
;
2370 bfd_size_type data_size
;
2372 bfd_boolean set_data_start
;
2373 bfd_size_type bss_size
;
2375 void * reloc_buff
= NULL
;
2376 struct internal_filehdr internal_f
;
2377 struct internal_aouthdr internal_a
;
2380 /* Determine where the sections and relocs will go in the output
2382 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2385 for (current
= abfd
->sections
;
2387 current
= current
->next
)
2389 current
->target_index
= count
;
2393 if ((abfd
->flags
& D_PAGED
) != 0)
2394 text_size
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2398 set_text_start
= FALSE
;
2401 set_data_start
= FALSE
;
2404 /* Write section headers to the file. */
2406 /* Allocate buff big enough to hold a section header,
2407 file header, or a.out header. */
2416 buff
= bfd_malloc (siz
);
2421 internal_f
.f_nscns
= 0;
2422 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2425 for (current
= abfd
->sections
;
2427 current
= current
->next
)
2429 struct internal_scnhdr section
;
2432 ++internal_f
.f_nscns
;
2434 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2436 /* This seems to be correct for Irix 4 shared libraries. */
2437 vma
= bfd_section_vma (current
);
2438 if (streq (current
->name
, _LIB
))
2439 section
.s_vaddr
= 0;
2441 section
.s_vaddr
= vma
;
2443 section
.s_paddr
= current
->lma
;
2444 section
.s_size
= current
->size
;
2446 /* If this section is unloadable then the scnptr will be 0. */
2447 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2448 section
.s_scnptr
= 0;
2450 section
.s_scnptr
= current
->filepos
;
2451 section
.s_relptr
= current
->rel_filepos
;
2453 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2454 object file produced by the assembler is supposed to point to
2455 information about how much room is required by objects of
2456 various different sizes. I think this only matters if we
2457 want the linker to compute the best size to use, or
2458 something. I don't know what happens if the information is
2460 if (! streq (current
->name
, _PDATA
))
2461 section
.s_lnnoptr
= 0;
2464 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2465 hold the number of entries in the section (each entry is
2466 8 bytes). We stored this in the line_filepos field in
2467 ecoff_compute_section_file_positions. */
2468 section
.s_lnnoptr
= current
->line_filepos
;
2471 section
.s_nreloc
= current
->reloc_count
;
2472 section
.s_nlnno
= 0;
2473 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2476 if (bfd_coff_swap_scnhdr_out (abfd
, (void *) §ion
, buff
) == 0
2477 || bfd_bwrite (buff
, scnhsz
, abfd
) != scnhsz
)
2480 if ((section
.s_flags
& STYP_TEXT
) != 0
2481 || ((section
.s_flags
& STYP_RDATA
) != 0
2482 && ecoff_data (abfd
)->rdata_in_text
)
2483 || section
.s_flags
== STYP_PDATA
2484 || (section
.s_flags
& STYP_DYNAMIC
) != 0
2485 || (section
.s_flags
& STYP_LIBLIST
) != 0
2486 || (section
.s_flags
& STYP_RELDYN
) != 0
2487 || section
.s_flags
== STYP_CONFLIC
2488 || (section
.s_flags
& STYP_DYNSTR
) != 0
2489 || (section
.s_flags
& STYP_DYNSYM
) != 0
2490 || (section
.s_flags
& STYP_HASH
) != 0
2491 || (section
.s_flags
& STYP_ECOFF_INIT
) != 0
2492 || (section
.s_flags
& STYP_ECOFF_FINI
) != 0
2493 || section
.s_flags
== STYP_RCONST
)
2495 text_size
+= current
->size
;
2496 if (! set_text_start
|| text_start
> vma
)
2499 set_text_start
= TRUE
;
2502 else if ((section
.s_flags
& STYP_RDATA
) != 0
2503 || (section
.s_flags
& STYP_DATA
) != 0
2504 || (section
.s_flags
& STYP_LITA
) != 0
2505 || (section
.s_flags
& STYP_LIT8
) != 0
2506 || (section
.s_flags
& STYP_LIT4
) != 0
2507 || (section
.s_flags
& STYP_SDATA
) != 0
2508 || section
.s_flags
== STYP_XDATA
2509 || (section
.s_flags
& STYP_GOT
) != 0)
2511 data_size
+= current
->size
;
2512 if (! set_data_start
|| data_start
> vma
)
2515 set_data_start
= TRUE
;
2518 else if ((section
.s_flags
& STYP_BSS
) != 0
2519 || (section
.s_flags
& STYP_SBSS
) != 0)
2520 bss_size
+= current
->size
;
2521 else if (section
.s_flags
== 0
2522 || (section
.s_flags
& STYP_ECOFF_LIB
) != 0
2523 || section
.s_flags
== STYP_COMMENT
)
2529 /* Set up the file header. */
2530 internal_f
.f_magic
= ecoff_get_magic (abfd
);
2532 /* We will NOT put a fucking timestamp in the header here. Every
2533 time you put it back, I will come in and take it out again. I'm
2534 sorry. This field does not belong here. We fill it with a 0 so
2535 it compares the same but is not a reasonable time. --
2537 internal_f
.f_timdat
= 0;
2539 if (bfd_get_symcount (abfd
) != 0)
2541 /* The ECOFF f_nsyms field is not actually the number of
2542 symbols, it's the size of symbolic information header. */
2543 internal_f
.f_nsyms
= external_hdr_size
;
2544 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
2548 internal_f
.f_nsyms
= 0;
2549 internal_f
.f_symptr
= 0;
2552 internal_f
.f_opthdr
= aoutsz
;
2554 internal_f
.f_flags
= F_LNNO
;
2555 if (reloc_size
== 0)
2556 internal_f
.f_flags
|= F_RELFLG
;
2557 if (bfd_get_symcount (abfd
) == 0)
2558 internal_f
.f_flags
|= F_LSYMS
;
2559 if (abfd
->flags
& EXEC_P
)
2560 internal_f
.f_flags
|= F_EXEC
;
2562 if (bfd_little_endian (abfd
))
2563 internal_f
.f_flags
|= F_AR32WR
;
2565 internal_f
.f_flags
|= F_AR32W
;
2567 /* Set up the ``optional'' header. */
2568 if ((abfd
->flags
& D_PAGED
) != 0)
2569 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
2571 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
2573 /* FIXME: Is this really correct? */
2574 internal_a
.vstamp
= symhdr
->vstamp
;
2576 /* At least on Ultrix, these have to be rounded to page boundaries.
2577 FIXME: Is this true on other platforms? */
2578 if ((abfd
->flags
& D_PAGED
) != 0)
2580 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
2581 internal_a
.text_start
= text_start
&~ (round
- 1);
2582 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
2583 internal_a
.data_start
= data_start
&~ (round
- 1);
2587 internal_a
.tsize
= text_size
;
2588 internal_a
.text_start
= text_start
;
2589 internal_a
.dsize
= data_size
;
2590 internal_a
.data_start
= data_start
;
2593 /* On Ultrix, the initial portions of the .sbss and .bss segments
2594 are at the end of the data section. The bsize field in the
2595 optional header records how many bss bytes are required beyond
2596 those in the data section. The value is not rounded to a page
2598 if (bss_size
< internal_a
.dsize
- data_size
)
2601 bss_size
-= internal_a
.dsize
- data_size
;
2602 internal_a
.bsize
= bss_size
;
2603 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
2605 internal_a
.entry
= bfd_get_start_address (abfd
);
2607 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
2609 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
2610 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
2611 for (i
= 0; i
< 4; i
++)
2612 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
2614 /* Let the backend adjust the headers if necessary. */
2615 if (backend
->adjust_headers
)
2617 if (! (*backend
->adjust_headers
) (abfd
, &internal_f
, &internal_a
))
2621 /* Write out the file header and the optional header. */
2622 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2625 bfd_coff_swap_filehdr_out (abfd
, (void *) &internal_f
, buff
);
2626 if (bfd_bwrite (buff
, filhsz
, abfd
) != filhsz
)
2629 bfd_coff_swap_aouthdr_out (abfd
, (void *) &internal_a
, buff
);
2630 if (bfd_bwrite (buff
, aoutsz
, abfd
) != aoutsz
)
2633 /* Build the external symbol information. This must be done before
2634 writing out the relocs so that we know the symbol indices. We
2635 don't do this if this BFD was created by the backend linker,
2636 since it will have already handled the symbols and relocs. */
2637 if (! ecoff_data (abfd
)->linker
)
2639 symhdr
->iextMax
= 0;
2640 symhdr
->issExtMax
= 0;
2641 debug
->external_ext
= debug
->external_ext_end
= NULL
;
2642 debug
->ssext
= debug
->ssext_end
= NULL
;
2643 if (! bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
2644 (abfd
->flags
& EXEC_P
) == 0,
2645 ecoff_get_extr
, ecoff_set_index
))
2648 /* Write out the relocs. */
2649 for (current
= abfd
->sections
;
2651 current
= current
->next
)
2653 arelent
**reloc_ptr_ptr
;
2654 arelent
**reloc_end
;
2658 if (current
->reloc_count
== 0)
2661 amt
= current
->reloc_count
* external_reloc_size
;
2662 reloc_buff
= bfd_alloc (abfd
, amt
);
2663 if (reloc_buff
== NULL
)
2666 reloc_ptr_ptr
= current
->orelocation
;
2667 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
2668 out_ptr
= (char *) reloc_buff
;
2671 reloc_ptr_ptr
< reloc_end
;
2672 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
2676 struct internal_reloc in
;
2678 memset ((void *) &in
, 0, sizeof in
);
2680 reloc
= *reloc_ptr_ptr
;
2681 sym
= *reloc
->sym_ptr_ptr
;
2683 /* If the howto field has not been initialised then skip this reloc.
2684 This assumes that an error message has been issued elsewhere. */
2685 if (reloc
->howto
== NULL
)
2688 in
.r_vaddr
= reloc
->address
+ bfd_section_vma (current
);
2689 in
.r_type
= reloc
->howto
->type
;
2691 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2693 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2707 { _TEXT
, RELOC_SECTION_TEXT
},
2708 { _RDATA
, RELOC_SECTION_RDATA
},
2709 { _DATA
, RELOC_SECTION_DATA
},
2710 { _SDATA
, RELOC_SECTION_SDATA
},
2711 { _SBSS
, RELOC_SECTION_SBSS
},
2712 { _BSS
, RELOC_SECTION_BSS
},
2713 { _INIT
, RELOC_SECTION_INIT
},
2714 { _LIT8
, RELOC_SECTION_LIT8
},
2715 { _LIT4
, RELOC_SECTION_LIT4
},
2716 { _XDATA
, RELOC_SECTION_XDATA
},
2717 { _PDATA
, RELOC_SECTION_PDATA
},
2718 { _FINI
, RELOC_SECTION_FINI
},
2719 { _LITA
, RELOC_SECTION_LITA
},
2720 { "*ABS*", RELOC_SECTION_ABS
},
2721 { _RCONST
, RELOC_SECTION_RCONST
}
2724 name
= bfd_section_name (bfd_asymbol_section (sym
));
2726 for (j
= 0; j
< ARRAY_SIZE (section_symndx
); j
++)
2727 if (streq (name
, section_symndx
[j
].name
))
2729 in
.r_symndx
= section_symndx
[j
].r_symndx
;
2733 if (j
== ARRAY_SIZE (section_symndx
))
2738 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2740 (*swap_reloc_out
) (abfd
, &in
, (void *) out_ptr
);
2743 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2745 amt
= current
->reloc_count
* external_reloc_size
;
2746 if (bfd_bwrite (reloc_buff
, amt
, abfd
) != amt
)
2748 bfd_release (abfd
, reloc_buff
);
2752 /* Write out the symbolic debugging information. */
2753 if (bfd_get_symcount (abfd
) > 0)
2755 /* Write out the debugging information. */
2756 if (! bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2757 ecoff_data (abfd
)->sym_filepos
))
2762 /* The .bss section of a demand paged executable must receive an
2763 entire page. If there are symbols, the symbols will start on the
2764 next page. If there are no symbols, we must fill out the page by
2766 if (bfd_get_symcount (abfd
) == 0
2767 && (abfd
->flags
& EXEC_P
) != 0
2768 && (abfd
->flags
& D_PAGED
) != 0)
2772 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2775 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) == 0)
2777 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2780 if (bfd_bwrite (&c
, (bfd_size_type
) 1, abfd
) != 1)
2784 if (reloc_buff
!= NULL
)
2785 bfd_release (abfd
, reloc_buff
);
2790 if (reloc_buff
!= NULL
)
2791 bfd_release (abfd
, reloc_buff
);
2797 /* Archive handling. ECOFF uses what appears to be a unique type of
2798 archive header (armap). The byte ordering of the armap and the
2799 contents are encoded in the name of the armap itself. At least for
2800 now, we only support archives with the same byte ordering in the
2801 armap and the contents.
2803 The first four bytes in the armap are the number of symbol
2804 definitions. This is always a power of two.
2806 This is followed by the symbol definitions. Each symbol definition
2807 occupies 8 bytes. The first four bytes are the offset from the
2808 start of the armap strings to the null-terminated string naming
2809 this symbol. The second four bytes are the file offset to the
2810 archive member which defines this symbol. If the second four bytes
2811 are 0, then this is not actually a symbol definition, and it should
2814 The symbols are hashed into the armap with a closed hashing scheme.
2815 See the functions below for the details of the algorithm.
2817 After the symbol definitions comes four bytes holding the size of
2818 the string table, followed by the string table itself. */
2820 /* The name of an archive headers looks like this:
2821 __________E[BL]E[BL]_ (with a trailing space).
2822 The trailing space is changed to an X if the archive is changed to
2823 indicate that the armap is out of date.
2825 The Alpha seems to use ________64E[BL]E[BL]_. */
2827 #define ARMAP_BIG_ENDIAN 'B'
2828 #define ARMAP_LITTLE_ENDIAN 'L'
2829 #define ARMAP_MARKER 'E'
2830 #define ARMAP_START_LENGTH 10
2831 #define ARMAP_HEADER_MARKER_INDEX 10
2832 #define ARMAP_HEADER_ENDIAN_INDEX 11
2833 #define ARMAP_OBJECT_MARKER_INDEX 12
2834 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2835 #define ARMAP_END_INDEX 14
2836 #define ARMAP_END "_ "
2838 /* This is a magic number used in the hashing algorithm. */
2839 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2841 /* This returns the hash value to use for a string. It also sets
2842 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2843 is the number of entries in the hash table, and HLOG is the log
2847 ecoff_armap_hash (const char *s
,
2848 unsigned int *rehash
,
2858 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2859 hash
*= ARMAP_HASH_MAGIC
;
2860 *rehash
= (hash
& (size
- 1)) | 1;
2861 return hash
>> (32 - hlog
);
2864 /* Read in the armap. */
2867 _bfd_ecoff_slurp_armap (bfd
*abfd
)
2871 struct areltdata
*mapdata
;
2872 bfd_size_type parsed_size
;
2874 struct artdata
*ardata
;
2881 /* Get the name of the first element. */
2882 i
= bfd_bread ((void *) nextname
, (bfd_size_type
) 16, abfd
);
2888 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2891 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2892 standard COFF armap. We could move the ECOFF armap stuff into
2893 bfd_slurp_armap, but that seems inappropriate since no other
2894 target uses this format. Instead, we check directly for a COFF
2896 if (CONST_STRNEQ (nextname
, "/ "))
2897 return bfd_slurp_armap (abfd
);
2899 /* See if the first element is an armap. */
2900 if (! strneq (nextname
, ecoff_backend (abfd
)->armap_start
, ARMAP_START_LENGTH
)
2901 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
2902 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2903 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2904 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
2905 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2906 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2907 || ! strneq (nextname
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1))
2909 abfd
->has_armap
= FALSE
;
2913 /* Make sure we have the right byte ordering. */
2914 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2915 ^ (bfd_header_big_endian (abfd
)))
2916 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2917 ^ (bfd_big_endian (abfd
))))
2919 bfd_set_error (bfd_error_wrong_format
);
2923 /* Read in the armap. */
2924 ardata
= bfd_ardata (abfd
);
2925 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
2926 if (mapdata
== NULL
)
2928 parsed_size
= mapdata
->parsed_size
;
2931 raw_armap
= (char *) bfd_alloc (abfd
, parsed_size
);
2932 if (raw_armap
== NULL
)
2935 if (bfd_bread ((void *) raw_armap
, parsed_size
, abfd
) != parsed_size
)
2937 if (bfd_get_error () != bfd_error_system_call
)
2938 bfd_set_error (bfd_error_malformed_archive
);
2939 bfd_release (abfd
, (void *) raw_armap
);
2943 ardata
->tdata
= (void *) raw_armap
;
2945 count
= H_GET_32 (abfd
, raw_armap
);
2947 ardata
->symdef_count
= 0;
2948 ardata
->cache
= NULL
;
2950 /* This code used to overlay the symdefs over the raw archive data,
2951 but that doesn't work on a 64 bit host. */
2952 stringbase
= raw_armap
+ count
* 8 + 8;
2954 #ifdef CHECK_ARMAP_HASH
2958 /* Double check that I have the hashing algorithm right by making
2959 sure that every symbol can be looked up successfully. */
2961 for (i
= 1; i
< count
; i
<<= 1)
2963 BFD_ASSERT (i
== count
);
2965 raw_ptr
= raw_armap
+ 4;
2966 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2968 unsigned int name_offset
, file_offset
;
2969 unsigned int hash
, rehash
, srch
;
2971 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2972 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2973 if (file_offset
== 0)
2975 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
2980 /* See if we can rehash to this location. */
2981 for (srch
= (hash
+ rehash
) & (count
- 1);
2982 srch
!= hash
&& srch
!= i
;
2983 srch
= (srch
+ rehash
) & (count
- 1))
2984 BFD_ASSERT (H_GET_32 (abfd
, (raw_armap
+ 8 + srch
* 8)) != 0);
2985 BFD_ASSERT (srch
== i
);
2989 #endif /* CHECK_ARMAP_HASH */
2991 raw_ptr
= raw_armap
+ 4;
2992 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2993 if (H_GET_32 (abfd
, (raw_ptr
+ 4)) != 0)
2994 ++ardata
->symdef_count
;
2996 amt
= ardata
->symdef_count
;
2997 amt
*= sizeof (carsym
);
2998 symdef_ptr
= (carsym
*) bfd_alloc (abfd
, amt
);
3002 ardata
->symdefs
= symdef_ptr
;
3004 raw_ptr
= raw_armap
+ 4;
3005 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3007 unsigned int name_offset
, file_offset
;
3009 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
3010 if (file_offset
== 0)
3012 name_offset
= H_GET_32 (abfd
, raw_ptr
);
3013 symdef_ptr
->name
= stringbase
+ name_offset
;
3014 symdef_ptr
->file_offset
= file_offset
;
3018 ardata
->first_file_filepos
= bfd_tell (abfd
);
3019 /* Pad to an even boundary. */
3020 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
3022 abfd
->has_armap
= TRUE
;
3027 /* Write out an armap. */
3030 _bfd_ecoff_write_armap (bfd
*abfd
,
3031 unsigned int elength
,
3033 unsigned int orl_count
,
3036 unsigned int hashsize
, hashlog
;
3037 bfd_size_type symdefsize
;
3039 unsigned int stringsize
;
3040 unsigned int mapsize
;
3043 struct stat statbuf
;
3046 bfd_byte
*hashtable
;
3050 /* Ultrix appears to use as a hash table size the least power of two
3051 greater than twice the number of entries. */
3052 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3054 hashsize
= 1 << hashlog
;
3056 symdefsize
= hashsize
* 8;
3058 stringsize
= stridx
+ padit
;
3060 /* Include 8 bytes to store symdefsize and stringsize in output. */
3061 mapsize
= symdefsize
+ stringsize
+ 8;
3063 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3065 memset ((void *) &hdr
, 0, sizeof hdr
);
3067 /* Work out the ECOFF armap name. */
3068 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3069 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3070 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3071 (bfd_header_big_endian (abfd
)
3073 : ARMAP_LITTLE_ENDIAN
);
3074 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3075 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3076 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3077 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3079 /* Write the timestamp of the archive header to be just a little bit
3080 later than the timestamp of the file, otherwise the linker will
3081 complain that the index is out of date. Actually, the Ultrix
3082 linker just checks the archive name; the GNU linker may check the
3084 stat (abfd
->filename
, &statbuf
);
3085 _bfd_ar_spacepad (hdr
.ar_date
, sizeof (hdr
.ar_date
), "%ld",
3086 (long) (statbuf
.st_mtime
+ 60));
3088 /* The DECstation uses zeroes for the uid, gid and mode of the
3090 hdr
.ar_uid
[0] = '0';
3091 hdr
.ar_gid
[0] = '0';
3092 /* Building gcc ends up extracting the armap as a file - twice. */
3093 hdr
.ar_mode
[0] = '6';
3094 hdr
.ar_mode
[1] = '4';
3095 hdr
.ar_mode
[2] = '4';
3097 _bfd_ar_spacepad (hdr
.ar_size
, sizeof (hdr
.ar_size
), "%-10ld", mapsize
);
3099 hdr
.ar_fmag
[0] = '`';
3100 hdr
.ar_fmag
[1] = '\012';
3102 /* Turn all null bytes in the header into spaces. */
3103 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3104 if (((char *) (&hdr
))[i
] == '\0')
3105 (((char *) (&hdr
))[i
]) = ' ';
3107 if (bfd_bwrite ((void *) &hdr
, (bfd_size_type
) sizeof (struct ar_hdr
), abfd
)
3108 != sizeof (struct ar_hdr
))
3111 H_PUT_32 (abfd
, hashsize
, temp
);
3112 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3115 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3119 current
= abfd
->archive_head
;
3121 for (i
= 0; i
< orl_count
; i
++)
3123 unsigned int hash
, rehash
= 0;
3125 /* Advance firstreal to the file position of this archive
3127 if (map
[i
].u
.abfd
!= last_elt
)
3131 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3132 firstreal
+= firstreal
% 2;
3133 current
= current
->archive_next
;
3135 while (current
!= map
[i
].u
.abfd
);
3140 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3141 if (H_GET_32 (abfd
, (hashtable
+ (hash
* 8) + 4)) != 0)
3145 /* The desired slot is already taken. */
3146 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3148 srch
= (srch
+ rehash
) & (hashsize
- 1))
3149 if (H_GET_32 (abfd
, (hashtable
+ (srch
* 8) + 4)) == 0)
3152 BFD_ASSERT (srch
!= hash
);
3157 H_PUT_32 (abfd
, map
[i
].namidx
, (hashtable
+ hash
* 8));
3158 H_PUT_32 (abfd
, firstreal
, (hashtable
+ hash
* 8 + 4));
3161 if (bfd_bwrite ((void *) hashtable
, symdefsize
, abfd
) != symdefsize
)
3164 bfd_release (abfd
, hashtable
);
3166 /* Now write the strings. */
3167 H_PUT_32 (abfd
, stringsize
, temp
);
3168 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3170 for (i
= 0; i
< orl_count
; i
++)
3174 len
= strlen (*map
[i
].name
) + 1;
3175 if (bfd_bwrite ((void *) (*map
[i
].name
), len
, abfd
) != len
)
3179 /* The spec sez this should be a newline. But in order to be
3180 bug-compatible for DECstation ar we use a null. */
3183 if (bfd_bwrite ("", (bfd_size_type
) 1, abfd
) != 1)
3190 /* ECOFF linker code. */
3192 /* Routine to create an entry in an ECOFF link hash table. */
3194 static struct bfd_hash_entry
*
3195 ecoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
3196 struct bfd_hash_table
*table
,
3199 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3201 /* Allocate the structure if it has not already been allocated by a
3204 ret
= ((struct ecoff_link_hash_entry
*)
3205 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3209 /* Call the allocation method of the superclass. */
3210 ret
= ((struct ecoff_link_hash_entry
*)
3211 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3216 /* Set local fields. */
3222 memset ((void *) &ret
->esym
, 0, sizeof ret
->esym
);
3224 return (struct bfd_hash_entry
*) ret
;
3227 /* Create an ECOFF link hash table. */
3229 struct bfd_link_hash_table
*
3230 _bfd_ecoff_bfd_link_hash_table_create (bfd
*abfd
)
3232 struct ecoff_link_hash_table
*ret
;
3233 size_t amt
= sizeof (struct ecoff_link_hash_table
);
3235 ret
= (struct ecoff_link_hash_table
*) bfd_malloc (amt
);
3238 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
,
3239 ecoff_link_hash_newfunc
,
3240 sizeof (struct ecoff_link_hash_entry
)))
3248 /* Look up an entry in an ECOFF link hash table. */
3250 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3251 ((struct ecoff_link_hash_entry *) \
3252 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3254 /* Get the ECOFF link hash table from the info structure. This is
3257 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3259 /* Add the external symbols of an object file to the global linker
3260 hash table. The external symbols and strings we are passed are
3261 just allocated on the stack, and will be discarded. We must
3262 explicitly save any information we may need later on in the link.
3263 We do not want to read the external symbol information again. */
3266 ecoff_link_add_externals (bfd
*abfd
,
3267 struct bfd_link_info
*info
,
3268 void * external_ext
,
3271 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3272 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3273 = backend
->debug_swap
.swap_ext_in
;
3274 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3275 unsigned long ext_count
;
3276 struct bfd_link_hash_entry
**sym_hash
;
3281 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3284 amt
*= sizeof (struct bfd_link_hash_entry
*);
3285 sym_hash
= (struct bfd_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3288 ecoff_data (abfd
)->sym_hashes
= (struct ecoff_link_hash_entry
**) sym_hash
;
3290 ext_ptr
= (char *) external_ext
;
3291 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3292 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3299 struct ecoff_link_hash_entry
*h
;
3303 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3305 /* Skip debugging symbols. */
3307 switch (esym
.asym
.st
)
3323 /* Get the information for this symbol. */
3324 value
= esym
.asym
.value
;
3325 switch (esym
.asym
.sc
)
3345 section
= bfd_make_section_old_way (abfd
, _TEXT
);
3346 value
-= section
->vma
;
3349 section
= bfd_make_section_old_way (abfd
, _DATA
);
3350 value
-= section
->vma
;
3353 section
= bfd_make_section_old_way (abfd
, _BSS
);
3354 value
-= section
->vma
;
3357 section
= bfd_abs_section_ptr
;
3360 section
= bfd_und_section_ptr
;
3363 section
= bfd_make_section_old_way (abfd
, _SDATA
);
3364 value
-= section
->vma
;
3367 section
= bfd_make_section_old_way (abfd
, _SBSS
);
3368 value
-= section
->vma
;
3371 section
= bfd_make_section_old_way (abfd
, _RDATA
);
3372 value
-= section
->vma
;
3375 if (value
> ecoff_data (abfd
)->gp_size
)
3377 section
= bfd_com_section_ptr
;
3382 if (ecoff_scom_section
.name
== NULL
)
3384 /* Initialize the small common section. */
3385 ecoff_scom_section
.name
= SCOMMON
;
3386 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
3387 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
3388 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
3389 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
3390 ecoff_scom_symbol
.name
= SCOMMON
;
3391 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
3392 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
3393 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
3395 section
= &ecoff_scom_section
;
3398 section
= bfd_und_section_ptr
;
3401 section
= bfd_make_section_old_way (abfd
, _INIT
);
3402 value
-= section
->vma
;
3405 section
= bfd_make_section_old_way (abfd
, _FINI
);
3406 value
-= section
->vma
;
3409 section
= bfd_make_section_old_way (abfd
, _RCONST
);
3410 value
-= section
->vma
;
3414 if (section
== NULL
)
3417 name
= ssext
+ esym
.asym
.iss
;
3419 if (! (_bfd_generic_link_add_one_symbol
3421 (flagword
) (esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
),
3422 section
, value
, NULL
, TRUE
, TRUE
, sym_hash
)))
3425 h
= (struct ecoff_link_hash_entry
*) *sym_hash
;
3427 /* If we are building an ECOFF hash table, save the external
3428 symbol information. */
3429 if (bfd_get_flavour (info
->output_bfd
) == bfd_get_flavour (abfd
))
3432 || (! bfd_is_und_section (section
)
3433 && (! bfd_is_com_section (section
)
3434 || (h
->root
.type
!= bfd_link_hash_defined
3435 && h
->root
.type
!= bfd_link_hash_defweak
))))
3441 /* Remember whether this symbol was small undefined. */
3442 if (esym
.asym
.sc
== scSUndefined
)
3445 /* If this symbol was ever small undefined, it needs to wind
3446 up in a GP relative section. We can't control the
3447 section of a defined symbol, but we can control the
3448 section of a common symbol. This case is actually needed
3449 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3451 && h
->root
.type
== bfd_link_hash_common
3452 && streq (h
->root
.u
.c
.p
->section
->name
, SCOMMON
))
3454 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
3456 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
3457 if (h
->esym
.asym
.sc
== scCommon
)
3458 h
->esym
.asym
.sc
= scSCommon
;
3466 /* Add symbols from an ECOFF object file to the global linker hash
3470 ecoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3473 bfd_size_type external_ext_size
;
3474 void * external_ext
= NULL
;
3475 bfd_size_type esize
;
3479 if (! ecoff_slurp_symbolic_header (abfd
))
3482 /* If there are no symbols, we don't want it. */
3483 if (bfd_get_symcount (abfd
) == 0)
3486 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3488 /* Read in the external symbols and external strings. */
3489 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3490 esize
= symhdr
->iextMax
* external_ext_size
;
3491 external_ext
= bfd_malloc (esize
);
3492 if (external_ext
== NULL
&& esize
!= 0)
3495 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbExtOffset
, SEEK_SET
) != 0
3496 || bfd_bread (external_ext
, esize
, abfd
) != esize
)
3499 ssext
= (char *) bfd_malloc ((bfd_size_type
) symhdr
->issExtMax
);
3500 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3503 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
3504 || (bfd_bread (ssext
, (bfd_size_type
) symhdr
->issExtMax
, abfd
)
3505 != (bfd_size_type
) symhdr
->issExtMax
))
3508 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3512 if (external_ext
!= NULL
)
3513 free (external_ext
);
3519 if (external_ext
!= NULL
)
3520 free (external_ext
);
3524 /* This is called if we used _bfd_generic_link_add_archive_symbols
3525 because we were not dealing with an ECOFF archive. */
3528 ecoff_link_check_archive_element (bfd
*abfd
,
3529 struct bfd_link_info
*info
,
3530 struct bfd_link_hash_entry
*h
,
3532 bfd_boolean
*pneeded
)
3536 /* Unlike the generic linker, we do not pull in elements because
3537 of common symbols. */
3538 if (h
->type
!= bfd_link_hash_undefined
)
3541 /* Include this element? */
3542 if (!(*info
->callbacks
->add_archive_element
) (info
, abfd
, name
, &abfd
))
3546 return ecoff_link_add_object_symbols (abfd
, info
);
3549 /* Add the symbols from an archive file to the global hash table.
3550 This looks through the undefined symbols, looks each one up in the
3551 archive hash table, and adds any associated object file. We do not
3552 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3553 already have a hash table, so there is no reason to construct
3557 ecoff_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3559 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3560 const bfd_byte
*raw_armap
;
3561 struct bfd_link_hash_entry
**pundef
;
3562 unsigned int armap_count
;
3563 unsigned int armap_log
;
3565 const bfd_byte
*hashtable
;
3566 const char *stringbase
;
3568 if (! bfd_has_map (abfd
))
3570 /* An empty archive is a special case. */
3571 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
3573 bfd_set_error (bfd_error_no_armap
);
3577 /* If we don't have any raw data for this archive, as can happen on
3578 Irix 4.0.5F, we call the generic routine.
3579 FIXME: We should be more clever about this, since someday tdata
3580 may get to something for a generic archive. */
3581 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3582 if (raw_armap
== NULL
)
3583 return (_bfd_generic_link_add_archive_symbols
3584 (abfd
, info
, ecoff_link_check_archive_element
));
3586 armap_count
= H_GET_32 (abfd
, raw_armap
);
3589 for (i
= 1; i
< armap_count
; i
<<= 1)
3591 BFD_ASSERT (i
== armap_count
);
3593 hashtable
= raw_armap
+ 4;
3594 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3596 /* Look through the list of undefined symbols. */
3597 pundef
= &info
->hash
->undefs
;
3598 while (*pundef
!= NULL
)
3600 struct bfd_link_hash_entry
*h
;
3601 unsigned int hash
, rehash
= 0;
3602 unsigned int file_offset
;
3608 /* When a symbol is defined, it is not necessarily removed from
3610 if (h
->type
!= bfd_link_hash_undefined
3611 && h
->type
!= bfd_link_hash_common
)
3613 /* Remove this entry from the list, for general cleanliness
3614 and because we are going to look through the list again
3615 if we search any more libraries. We can't remove the
3616 entry if it is the tail, because that would lose any
3617 entries we add to the list later on. */
3618 if (*pundef
!= info
->hash
->undefs_tail
)
3619 *pundef
= (*pundef
)->u
.undef
.next
;
3621 pundef
= &(*pundef
)->u
.undef
.next
;
3625 /* Native ECOFF linkers do not pull in archive elements merely
3626 to satisfy common definitions, so neither do we. We leave
3627 them on the list, though, in case we are linking against some
3628 other object format. */
3629 if (h
->type
!= bfd_link_hash_undefined
)
3631 pundef
= &(*pundef
)->u
.undef
.next
;
3635 /* Look for this symbol in the archive hash table. */
3636 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3639 file_offset
= H_GET_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3640 if (file_offset
== 0)
3642 /* Nothing in this slot. */
3643 pundef
= &(*pundef
)->u
.undef
.next
;
3647 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (hash
* 8));
3648 if (name
[0] != h
->root
.string
[0]
3649 || ! streq (name
, h
->root
.string
))
3654 /* That was the wrong symbol. Try rehashing. */
3656 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3658 srch
= (srch
+ rehash
) & (armap_count
- 1))
3660 file_offset
= H_GET_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3661 if (file_offset
== 0)
3663 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (srch
* 8));
3664 if (name
[0] == h
->root
.string
[0]
3665 && streq (name
, h
->root
.string
))
3674 pundef
= &(*pundef
)->u
.undef
.next
;
3681 element
= (*backend
->get_elt_at_filepos
) (abfd
, (file_ptr
) file_offset
);
3682 if (element
== NULL
)
3685 if (! bfd_check_format (element
, bfd_object
))
3688 /* Unlike the generic linker, we know that this element provides
3689 a definition for an undefined symbol and we know that we want
3690 to include it. We don't need to check anything. */
3691 if (!(*info
->callbacks
3692 ->add_archive_element
) (info
, element
, name
, &element
))
3694 if (! ecoff_link_add_object_symbols (element
, info
))
3697 pundef
= &(*pundef
)->u
.undef
.next
;
3703 /* Given an ECOFF BFD, add symbols to the global hash table as
3707 _bfd_ecoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3709 switch (bfd_get_format (abfd
))
3712 return ecoff_link_add_object_symbols (abfd
, info
);
3714 return ecoff_link_add_archive_symbols (abfd
, info
);
3716 bfd_set_error (bfd_error_wrong_format
);
3722 /* ECOFF final link routines. */
3724 /* Structure used to pass information to ecoff_link_write_external. */
3729 struct bfd_link_info
*info
;
3732 /* Accumulate the debugging information for an input BFD into the
3733 output BFD. This must read in the symbolic information of the
3737 ecoff_final_link_debug_accumulate (bfd
*output_bfd
,
3739 struct bfd_link_info
*info
,
3742 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
3743 const struct ecoff_debug_swap
* const swap
=
3744 &ecoff_backend (input_bfd
)->debug_swap
;
3745 HDRR
*symhdr
= &debug
->symbolic_header
;
3748 #define READ(ptr, offset, count, size, type) \
3749 if (symhdr->count == 0) \
3750 debug->ptr = NULL; \
3753 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
3754 debug->ptr = (type) bfd_malloc (amt); \
3755 if (debug->ptr == NULL) \
3758 goto return_something; \
3760 if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3761 || bfd_bread (debug->ptr, amt, input_bfd) != amt) \
3764 goto return_something; \
3768 /* If raw_syments is not NULL, then the data was already by read by
3769 _bfd_ecoff_slurp_symbolic_info. */
3770 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3772 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
3774 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
3775 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
3776 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
3777 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
3778 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3780 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3781 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
3782 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
3786 /* We do not read the external strings or the external symbols. */
3788 ret
= (bfd_ecoff_debug_accumulate
3789 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
3790 &ecoff_backend (output_bfd
)->debug_swap
,
3791 input_bfd
, debug
, swap
, info
));
3794 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3796 if (debug
->line
!= NULL
)
3798 if (debug
->external_dnr
!= NULL
)
3799 free (debug
->external_dnr
);
3800 if (debug
->external_pdr
!= NULL
)
3801 free (debug
->external_pdr
);
3802 if (debug
->external_sym
!= NULL
)
3803 free (debug
->external_sym
);
3804 if (debug
->external_opt
!= NULL
)
3805 free (debug
->external_opt
);
3806 if (debug
->external_aux
!= NULL
)
3807 free (debug
->external_aux
);
3808 if (debug
->ss
!= NULL
)
3810 if (debug
->external_fdr
!= NULL
)
3811 free (debug
->external_fdr
);
3812 if (debug
->external_rfd
!= NULL
)
3813 free (debug
->external_rfd
);
3815 /* Make sure we don't accidentally follow one of these pointers
3816 into freed memory. */
3818 debug
->external_dnr
= NULL
;
3819 debug
->external_pdr
= NULL
;
3820 debug
->external_sym
= NULL
;
3821 debug
->external_opt
= NULL
;
3822 debug
->external_aux
= NULL
;
3824 debug
->external_fdr
= NULL
;
3825 debug
->external_rfd
= NULL
;
3831 /* Relocate and write an ECOFF section into an ECOFF output file. */
3834 ecoff_indirect_link_order (bfd
*output_bfd
,
3835 struct bfd_link_info
*info
,
3836 asection
*output_section
,
3837 struct bfd_link_order
*link_order
)
3839 asection
*input_section
;
3841 bfd_byte
*contents
= NULL
;
3842 bfd_size_type external_reloc_size
;
3843 bfd_size_type external_relocs_size
;
3844 void * external_relocs
= NULL
;
3846 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
3848 input_section
= link_order
->u
.indirect
.section
;
3849 input_bfd
= input_section
->owner
;
3850 if (input_section
->size
== 0)
3853 BFD_ASSERT (input_section
->output_section
== output_section
);
3854 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
3855 BFD_ASSERT (input_section
->size
== link_order
->size
);
3857 /* Get the section contents. */
3858 if (!bfd_malloc_and_get_section (input_bfd
, input_section
, &contents
))
3861 /* Get the relocs. If we are relaxing MIPS code, they will already
3862 have been read in. Otherwise, we read them in now. */
3863 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
3864 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
3866 external_relocs
= bfd_malloc (external_relocs_size
);
3867 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
3870 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3871 || (bfd_bread (external_relocs
, external_relocs_size
, input_bfd
)
3872 != external_relocs_size
))
3875 /* Relocate the section contents. */
3876 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
3877 (output_bfd
, info
, input_bfd
, input_section
, contents
,
3881 /* Write out the relocated section. */
3882 if (! bfd_set_section_contents (output_bfd
,
3885 input_section
->output_offset
,
3886 input_section
->size
))
3889 /* If we are producing relocatable output, the relocs were
3890 modified, and we write them out now. We use the reloc_count
3891 field of output_section to keep track of the number of relocs we
3892 have output so far. */
3893 if (bfd_link_relocatable (info
))
3895 file_ptr pos
= (output_section
->rel_filepos
3896 + output_section
->reloc_count
* external_reloc_size
);
3897 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
3898 || (bfd_bwrite (external_relocs
, external_relocs_size
, output_bfd
)
3899 != external_relocs_size
))
3901 output_section
->reloc_count
+= input_section
->reloc_count
;
3904 if (contents
!= NULL
)
3906 if (external_relocs
!= NULL
)
3907 free (external_relocs
);
3911 if (contents
!= NULL
)
3913 if (external_relocs
!= NULL
)
3914 free (external_relocs
);
3918 /* Generate a reloc when linking an ECOFF file. This is a reloc
3919 requested by the linker, and does come from any input file. This
3920 is used to build constructor and destructor tables when linking
3924 ecoff_reloc_link_order (bfd
*output_bfd
,
3925 struct bfd_link_info
*info
,
3926 asection
*output_section
,
3927 struct bfd_link_order
*link_order
)
3929 enum bfd_link_order_type type
;
3933 struct internal_reloc in
;
3934 bfd_size_type external_reloc_size
;
3939 type
= link_order
->type
;
3941 addend
= link_order
->u
.reloc
.p
->addend
;
3943 /* We set up an arelent to pass to the backend adjust_reloc_out
3945 rel
.address
= link_order
->offset
;
3947 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3950 bfd_set_error (bfd_error_bad_value
);
3954 if (type
== bfd_section_reloc_link_order
)
3956 section
= link_order
->u
.reloc
.p
->u
.section
;
3957 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
3961 struct bfd_link_hash_entry
*h
;
3963 /* Treat a reloc against a defined symbol as though it were
3964 actually against the section. */
3965 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3966 link_order
->u
.reloc
.p
->u
.name
,
3967 FALSE
, FALSE
, FALSE
);
3969 && (h
->type
== bfd_link_hash_defined
3970 || h
->type
== bfd_link_hash_defweak
))
3972 type
= bfd_section_reloc_link_order
;
3973 section
= h
->u
.def
.section
->output_section
;
3974 /* It seems that we ought to add the symbol value to the
3975 addend here, but in practice it has already been added
3976 because it was passed to constructor_callback. */
3977 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
3981 /* We can't set up a reloc against a symbol correctly,
3982 because we have no asymbol structure. Currently no
3983 adjust_reloc_out routine cares. */
3984 rel
.sym_ptr_ptr
= NULL
;
3988 /* All ECOFF relocs are in-place. Put the addend into the object
3991 BFD_ASSERT (rel
.howto
->partial_inplace
);
3995 bfd_reloc_status_type rstat
;
3998 size
= bfd_get_reloc_size (rel
.howto
);
3999 buf
= (bfd_byte
*) bfd_zmalloc (size
);
4000 if (buf
== NULL
&& size
!= 0)
4002 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
4003 (bfd_vma
) addend
, buf
);
4009 case bfd_reloc_outofrange
:
4011 case bfd_reloc_overflow
:
4012 (*info
->callbacks
->reloc_overflow
)
4014 (link_order
->type
== bfd_section_reloc_link_order
4015 ? bfd_section_name (section
)
4016 : link_order
->u
.reloc
.p
->u
.name
),
4017 rel
.howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0);
4020 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
4021 (file_ptr
) link_order
->offset
, size
);
4029 /* Move the information into an internal_reloc structure. */
4030 in
.r_vaddr
= rel
.address
+ bfd_section_vma (output_section
);
4031 in
.r_type
= rel
.howto
->type
;
4033 if (type
== bfd_symbol_reloc_link_order
)
4035 struct ecoff_link_hash_entry
*h
;
4037 h
= ((struct ecoff_link_hash_entry
*)
4038 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4039 link_order
->u
.reloc
.p
->u
.name
,
4040 FALSE
, FALSE
, TRUE
));
4043 in
.r_symndx
= h
->indx
;
4046 (*info
->callbacks
->unattached_reloc
)
4047 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
4063 { _TEXT
, RELOC_SECTION_TEXT
},
4064 { _RDATA
, RELOC_SECTION_RDATA
},
4065 { _DATA
, RELOC_SECTION_DATA
},
4066 { _SDATA
, RELOC_SECTION_SDATA
},
4067 { _SBSS
, RELOC_SECTION_SBSS
},
4068 { _BSS
, RELOC_SECTION_BSS
},
4069 { _INIT
, RELOC_SECTION_INIT
},
4070 { _LIT8
, RELOC_SECTION_LIT8
},
4071 { _LIT4
, RELOC_SECTION_LIT4
},
4072 { _XDATA
, RELOC_SECTION_XDATA
},
4073 { _PDATA
, RELOC_SECTION_PDATA
},
4074 { _FINI
, RELOC_SECTION_FINI
},
4075 { _LITA
, RELOC_SECTION_LITA
},
4076 { "*ABS*", RELOC_SECTION_ABS
},
4077 { _RCONST
, RELOC_SECTION_RCONST
}
4080 name
= bfd_section_name (section
);
4082 for (i
= 0; i
< ARRAY_SIZE (section_symndx
); i
++)
4083 if (streq (name
, section_symndx
[i
].name
))
4085 in
.r_symndx
= section_symndx
[i
].r_symndx
;
4089 if (i
== ARRAY_SIZE (section_symndx
))
4095 /* Let the BFD backend adjust the reloc. */
4096 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4098 /* Get some memory and swap out the reloc. */
4099 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4100 rbuf
= (bfd_byte
*) bfd_malloc (external_reloc_size
);
4104 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (void *) rbuf
);
4106 pos
= (output_section
->rel_filepos
4107 + output_section
->reloc_count
* external_reloc_size
);
4108 ok
= (bfd_seek (output_bfd
, pos
, SEEK_SET
) == 0
4109 && (bfd_bwrite ((void *) rbuf
, external_reloc_size
, output_bfd
)
4110 == external_reloc_size
));
4113 ++output_section
->reloc_count
;
4120 /* Put out information for an external symbol. These come only from
4124 ecoff_link_write_external (struct bfd_hash_entry
*bh
, void * data
)
4126 struct ecoff_link_hash_entry
*h
= (struct ecoff_link_hash_entry
*) bh
;
4127 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4128 bfd
*output_bfd
= einfo
->abfd
;
4131 if (h
->root
.type
== bfd_link_hash_warning
)
4133 h
= (struct ecoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4134 if (h
->root
.type
== bfd_link_hash_new
)
4138 /* We need to check if this symbol is being stripped. */
4139 if (h
->root
.type
== bfd_link_hash_undefined
4140 || h
->root
.type
== bfd_link_hash_undefweak
)
4142 else if (einfo
->info
->strip
== strip_all
4143 || (einfo
->info
->strip
== strip_some
4144 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4145 h
->root
.root
.string
,
4146 FALSE
, FALSE
) == NULL
))
4151 if (strip
|| h
->written
)
4154 if (h
->abfd
== NULL
)
4157 h
->esym
.cobol_main
= 0;
4158 h
->esym
.weakext
= 0;
4159 h
->esym
.reserved
= 0;
4160 h
->esym
.ifd
= ifdNil
;
4161 h
->esym
.asym
.value
= 0;
4162 h
->esym
.asym
.st
= stGlobal
;
4164 if (h
->root
.type
!= bfd_link_hash_defined
4165 && h
->root
.type
!= bfd_link_hash_defweak
)
4166 h
->esym
.asym
.sc
= scAbs
;
4169 asection
*output_section
;
4177 section_storage_classes
[] =
4181 { _SDATA
, scSData
},
4182 { _RDATA
, scRData
},
4187 { _PDATA
, scPData
},
4188 { _XDATA
, scXData
},
4189 { _RCONST
, scRConst
}
4192 output_section
= h
->root
.u
.def
.section
->output_section
;
4193 name
= bfd_section_name (output_section
);
4195 for (i
= 0; i
< ARRAY_SIZE (section_storage_classes
); i
++)
4196 if (streq (name
, section_storage_classes
[i
].name
))
4198 h
->esym
.asym
.sc
= section_storage_classes
[i
].sc
;
4202 if (i
== ARRAY_SIZE (section_storage_classes
))
4203 h
->esym
.asym
.sc
= scAbs
;
4206 h
->esym
.asym
.reserved
= 0;
4207 h
->esym
.asym
.index
= indexNil
;
4209 else if (h
->esym
.ifd
!= -1)
4211 struct ecoff_debug_info
*debug
;
4213 /* Adjust the FDR index for the symbol by that used for the
4215 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4216 BFD_ASSERT (h
->esym
.ifd
>= 0
4217 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4218 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4221 switch (h
->root
.type
)
4224 case bfd_link_hash_warning
:
4225 case bfd_link_hash_new
:
4227 case bfd_link_hash_undefined
:
4228 case bfd_link_hash_undefweak
:
4229 if (h
->esym
.asym
.sc
!= scUndefined
4230 && h
->esym
.asym
.sc
!= scSUndefined
)
4231 h
->esym
.asym
.sc
= scUndefined
;
4233 case bfd_link_hash_defined
:
4234 case bfd_link_hash_defweak
:
4235 if (h
->esym
.asym
.sc
== scUndefined
4236 || h
->esym
.asym
.sc
== scSUndefined
)
4237 h
->esym
.asym
.sc
= scAbs
;
4238 else if (h
->esym
.asym
.sc
== scCommon
)
4239 h
->esym
.asym
.sc
= scBss
;
4240 else if (h
->esym
.asym
.sc
== scSCommon
)
4241 h
->esym
.asym
.sc
= scSBss
;
4242 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4243 + h
->root
.u
.def
.section
->output_section
->vma
4244 + h
->root
.u
.def
.section
->output_offset
);
4246 case bfd_link_hash_common
:
4247 if (h
->esym
.asym
.sc
!= scCommon
4248 && h
->esym
.asym
.sc
!= scSCommon
)
4249 h
->esym
.asym
.sc
= scCommon
;
4250 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4252 case bfd_link_hash_indirect
:
4253 /* We ignore these symbols, since the indirected symbol is
4254 already in the hash table. */
4258 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4260 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4263 return (bfd_ecoff_debug_one_external
4264 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4265 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4269 /* ECOFF final link routine. This looks through all the input BFDs
4270 and gathers together all the debugging information, and then
4271 processes all the link order information. This may cause it to
4272 close and reopen some input BFDs; I'll see how bad this is. */
4275 _bfd_ecoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
4277 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4278 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4283 struct bfd_link_order
*p
;
4284 struct extsym_info einfo
;
4286 /* We accumulate the debugging information counts in the symbolic
4288 symhdr
= &debug
->symbolic_header
;
4290 symhdr
->ilineMax
= 0;
4294 symhdr
->isymMax
= 0;
4295 symhdr
->ioptMax
= 0;
4296 symhdr
->iauxMax
= 0;
4298 symhdr
->issExtMax
= 0;
4301 symhdr
->iextMax
= 0;
4303 /* We accumulate the debugging information itself in the debug_info
4306 debug
->external_dnr
= NULL
;
4307 debug
->external_pdr
= NULL
;
4308 debug
->external_sym
= NULL
;
4309 debug
->external_opt
= NULL
;
4310 debug
->external_aux
= NULL
;
4312 debug
->ssext
= debug
->ssext_end
= NULL
;
4313 debug
->external_fdr
= NULL
;
4314 debug
->external_rfd
= NULL
;
4315 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4317 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4321 /* Accumulate the debugging symbols from each input BFD. */
4322 for (input_bfd
= info
->input_bfds
;
4324 input_bfd
= input_bfd
->link
.next
)
4328 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4330 /* Arbitrarily set the symbolic header vstamp to the vstamp
4331 of the first object file in the link. */
4332 if (symhdr
->vstamp
== 0)
4334 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4335 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4339 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4340 debug
, &backend
->debug_swap
,
4345 /* Combine the register masks. */
4346 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4347 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4348 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4349 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4350 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4351 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4354 /* Write out the external symbols. */
4357 bfd_hash_traverse (&info
->hash
->table
, ecoff_link_write_external
, &einfo
);
4359 if (bfd_link_relocatable (info
))
4361 /* We need to make a pass over the link_orders to count up the
4362 number of relocations we will need to output, so that we know
4363 how much space they will take up. */
4364 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4367 for (p
= o
->map_head
.link_order
;
4370 if (p
->type
== bfd_indirect_link_order
)
4371 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4372 else if (p
->type
== bfd_section_reloc_link_order
4373 || p
->type
== bfd_symbol_reloc_link_order
)
4378 /* Compute the reloc and symbol file positions. */
4379 ecoff_compute_reloc_file_positions (abfd
);
4381 /* Write out the debugging information. */
4382 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4383 &backend
->debug_swap
, info
,
4384 ecoff_data (abfd
)->sym_filepos
))
4387 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4389 if (bfd_link_relocatable (info
))
4391 /* Now reset the reloc_count field of the sections in the output
4392 BFD to 0, so that we can use them to keep track of how many
4393 relocs we have output thus far. */
4394 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4398 /* Get a value for the GP register. */
4399 if (ecoff_data (abfd
)->gp
== 0)
4401 struct bfd_link_hash_entry
*h
;
4403 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
4405 && h
->type
== bfd_link_hash_defined
)
4406 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4407 + h
->u
.def
.section
->output_section
->vma
4408 + h
->u
.def
.section
->output_offset
);
4409 else if (bfd_link_relocatable (info
))
4413 /* Make up a value. */
4415 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4418 && (streq (o
->name
, _SBSS
)
4419 || streq (o
->name
, _SDATA
)
4420 || streq (o
->name
, _LIT4
)
4421 || streq (o
->name
, _LIT8
)
4422 || streq (o
->name
, _LITA
)))
4425 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4429 /* If the relocate_section function needs to do a reloc
4430 involving the GP value, it should make a reloc_dangerous
4431 callback to warn that GP is not defined. */
4435 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4437 for (p
= o
->map_head
.link_order
;
4441 if (p
->type
== bfd_indirect_link_order
4442 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4443 == bfd_target_ecoff_flavour
))
4445 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4448 else if (p
->type
== bfd_section_reloc_link_order
4449 || p
->type
== bfd_symbol_reloc_link_order
)
4451 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4456 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4462 abfd
->symcount
= symhdr
->iextMax
+ symhdr
->isymMax
;
4464 ecoff_data (abfd
)->linker
= TRUE
;