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
;
519 BFD_ASSERT (debug
== &ecoff_data (abfd
)->debug_info
);
521 /* Check whether we've already gotten it, and whether there's any to
523 if (ecoff_data (abfd
)->raw_syments
!= NULL
)
525 if (ecoff_data (abfd
)->sym_filepos
== 0)
531 if (! ecoff_slurp_symbolic_header (abfd
))
534 internal_symhdr
= &debug
->symbolic_header
;
536 /* Read all the symbolic information at once. */
537 raw_base
= (ecoff_data (abfd
)->sym_filepos
538 + backend
->debug_swap
.external_hdr_size
);
540 /* Alpha ecoff makes the determination of raw_size difficult. It has
541 an undocumented debug data section between the symhdr and the first
542 documented section. And the ordering of the sections varies between
543 statically and dynamically linked executables.
544 If bfd supports SEEK_END someday, this code could be simplified. */
547 #define UPDATE_RAW_END(start, count, size) \
548 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
549 if (cb_end > raw_end) \
552 UPDATE_RAW_END (cbLineOffset
, cbLine
, sizeof (unsigned char));
553 UPDATE_RAW_END (cbDnOffset
, idnMax
, backend
->debug_swap
.external_dnr_size
);
554 UPDATE_RAW_END (cbPdOffset
, ipdMax
, backend
->debug_swap
.external_pdr_size
);
555 UPDATE_RAW_END (cbSymOffset
, isymMax
, backend
->debug_swap
.external_sym_size
);
556 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
557 optimization symtab, not the number of entries. */
558 UPDATE_RAW_END (cbOptOffset
, ioptMax
, sizeof (char));
559 UPDATE_RAW_END (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
560 UPDATE_RAW_END (cbSsOffset
, issMax
, sizeof (char));
561 UPDATE_RAW_END (cbSsExtOffset
, issExtMax
, sizeof (char));
562 UPDATE_RAW_END (cbFdOffset
, ifdMax
, backend
->debug_swap
.external_fdr_size
);
563 UPDATE_RAW_END (cbRfdOffset
, crfd
, backend
->debug_swap
.external_rfd_size
);
564 UPDATE_RAW_END (cbExtOffset
, iextMax
, backend
->debug_swap
.external_ext_size
);
566 #undef UPDATE_RAW_END
568 raw_size
= raw_end
- raw_base
;
571 ecoff_data (abfd
)->sym_filepos
= 0;
574 raw
= bfd_alloc (abfd
, raw_size
);
578 pos
= ecoff_data (abfd
)->sym_filepos
;
579 pos
+= backend
->debug_swap
.external_hdr_size
;
580 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
581 || bfd_bread (raw
, raw_size
, abfd
) != raw_size
)
583 bfd_release (abfd
, raw
);
587 ecoff_data (abfd
)->raw_syments
= raw
;
589 /* Get pointers for the numeric offsets in the HDRR structure. */
590 #define FIX(off1, off2, type) \
591 if (internal_symhdr->off1 == 0) \
592 debug->off2 = NULL; \
594 debug->off2 = (type) ((char *) raw \
595 + (internal_symhdr->off1 \
598 FIX (cbLineOffset
, line
, unsigned char *);
599 FIX (cbDnOffset
, external_dnr
, void *);
600 FIX (cbPdOffset
, external_pdr
, void *);
601 FIX (cbSymOffset
, external_sym
, void *);
602 FIX (cbOptOffset
, external_opt
, void *);
603 FIX (cbAuxOffset
, external_aux
, union aux_ext
*);
604 FIX (cbSsOffset
, ss
, char *);
605 FIX (cbSsExtOffset
, ssext
, char *);
606 FIX (cbFdOffset
, external_fdr
, void *);
607 FIX (cbRfdOffset
, external_rfd
, void *);
608 FIX (cbExtOffset
, external_ext
, void *);
611 /* I don't want to always swap all the data, because it will just
612 waste time and most programs will never look at it. The only
613 time the linker needs most of the debugging information swapped
614 is when linking big-endian and little-endian MIPS object files
615 together, which is not a common occurrence.
617 We need to look at the fdr to deal with a lot of information in
618 the symbols, so we swap them here. */
619 if (_bfd_mul_overflow ((unsigned long) internal_symhdr
->ifdMax
,
620 sizeof (struct fdr
), &amt
))
622 bfd_set_error (bfd_error_file_too_big
);
625 debug
->fdr
= (FDR
*) bfd_alloc (abfd
, amt
);
626 if (debug
->fdr
== NULL
)
628 external_fdr_size
= backend
->debug_swap
.external_fdr_size
;
629 fdr_ptr
= debug
->fdr
;
630 fraw_src
= (char *) debug
->external_fdr
;
631 /* PR 17512: file: 3372-1243-0.004. */
632 if (fraw_src
== NULL
&& internal_symhdr
->ifdMax
> 0)
634 fraw_end
= fraw_src
+ internal_symhdr
->ifdMax
* external_fdr_size
;
635 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
636 (*backend
->debug_swap
.swap_fdr_in
) (abfd
, (void *) fraw_src
, fdr_ptr
);
641 /* ECOFF symbol table routines. The ECOFF symbol table is described
642 in gcc/mips-tfile.c. */
644 /* ECOFF uses two common sections. One is the usual one, and the
645 other is for small objects. All the small objects are kept
646 together, and then referenced via the gp pointer, which yields
647 faster assembler code. This is what we use for the small common
649 static asection ecoff_scom_section
;
650 static asymbol ecoff_scom_symbol
;
651 static asymbol
*ecoff_scom_symbol_ptr
;
653 /* Create an empty symbol. */
656 _bfd_ecoff_make_empty_symbol (bfd
*abfd
)
658 ecoff_symbol_type
*new_symbol
;
659 size_t amt
= sizeof (ecoff_symbol_type
);
661 new_symbol
= (ecoff_symbol_type
*) bfd_zalloc (abfd
, amt
);
662 if (new_symbol
== NULL
)
664 new_symbol
->symbol
.section
= NULL
;
665 new_symbol
->fdr
= NULL
;
666 new_symbol
->local
= FALSE
;
667 new_symbol
->native
= NULL
;
668 new_symbol
->symbol
.the_bfd
= abfd
;
669 return &new_symbol
->symbol
;
672 /* Set the BFD flags and section for an ECOFF symbol. */
675 ecoff_set_symbol_info (bfd
*abfd
,
681 asym
->the_bfd
= abfd
;
682 asym
->value
= ecoff_sym
->value
;
683 asym
->section
= &bfd_debug_section
;
686 /* Most symbol types are just for debugging. */
687 switch (ecoff_sym
->st
)
696 if (ECOFF_IS_STAB (ecoff_sym
))
698 asym
->flags
= BSF_DEBUGGING
;
703 asym
->flags
= BSF_DEBUGGING
;
708 asym
->flags
= BSF_EXPORT
| BSF_WEAK
;
710 asym
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
713 asym
->flags
= BSF_LOCAL
;
714 /* Normally, a local stProc symbol will have a corresponding
715 external symbol. We mark the local symbol as a debugging
716 symbol, in order to prevent nm from printing both out.
717 Similarly, we mark stLabel and stabs symbols as debugging
718 symbols. In both cases, we do want to set the value
719 correctly based on the symbol class. */
720 if (ecoff_sym
->st
== stProc
721 || ecoff_sym
->st
== stLabel
722 || ECOFF_IS_STAB (ecoff_sym
))
723 asym
->flags
|= BSF_DEBUGGING
;
726 if (ecoff_sym
->st
== stProc
|| ecoff_sym
->st
== stStaticProc
)
727 asym
->flags
|= BSF_FUNCTION
;
729 switch (ecoff_sym
->sc
)
732 /* Used for compiler generated labels. Leave them in the
733 debugging section, and mark them as local. If BSF_DEBUGGING
734 is set, then nm does not display them for some reason. If no
735 flags are set then the linker whines about them. */
736 asym
->flags
= BSF_LOCAL
;
739 asym
->section
= bfd_make_section_old_way (abfd
, _TEXT
);
740 asym
->value
-= asym
->section
->vma
;
743 asym
->section
= bfd_make_section_old_way (abfd
, _DATA
);
744 asym
->value
-= asym
->section
->vma
;
747 asym
->section
= bfd_make_section_old_way (abfd
, _BSS
);
748 asym
->value
-= asym
->section
->vma
;
751 asym
->flags
= BSF_DEBUGGING
;
754 asym
->section
= bfd_abs_section_ptr
;
757 asym
->section
= bfd_und_section_ptr
;
767 asym
->flags
= BSF_DEBUGGING
;
770 asym
->section
= bfd_make_section_old_way (abfd
, ".sdata");
771 asym
->value
-= asym
->section
->vma
;
774 asym
->section
= bfd_make_section_old_way (abfd
, ".sbss");
775 asym
->value
-= asym
->section
->vma
;
778 asym
->section
= bfd_make_section_old_way (abfd
, ".rdata");
779 asym
->value
-= asym
->section
->vma
;
782 asym
->flags
= BSF_DEBUGGING
;
785 if (asym
->value
> ecoff_data (abfd
)->gp_size
)
787 asym
->section
= bfd_com_section_ptr
;
793 if (ecoff_scom_section
.name
== NULL
)
795 /* Initialize the small common section. */
796 ecoff_scom_section
.name
= SCOMMON
;
797 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
798 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
799 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
800 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
801 ecoff_scom_symbol
.name
= SCOMMON
;
802 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
803 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
804 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
806 asym
->section
= &ecoff_scom_section
;
811 asym
->flags
= BSF_DEBUGGING
;
814 asym
->section
= bfd_und_section_ptr
;
819 asym
->section
= bfd_make_section_old_way (abfd
, ".init");
820 asym
->value
-= asym
->section
->vma
;
825 asym
->flags
= BSF_DEBUGGING
;
828 asym
->section
= bfd_make_section_old_way (abfd
, ".fini");
829 asym
->value
-= asym
->section
->vma
;
832 asym
->section
= bfd_make_section_old_way (abfd
, ".rconst");
833 asym
->value
-= asym
->section
->vma
;
839 /* Look for special constructors symbols and make relocation entries
840 in a special construction section. These are produced by the
841 -fgnu-linker argument to g++. */
842 if (ECOFF_IS_STAB (ecoff_sym
))
844 switch (ECOFF_UNMARK_STAB (ecoff_sym
->index
))
853 /* Mark the symbol as a constructor. */
854 asym
->flags
|= BSF_CONSTRUCTOR
;
861 /* Read an ECOFF symbol table. */
864 _bfd_ecoff_slurp_symbol_table (bfd
*abfd
)
866 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
867 const bfd_size_type external_ext_size
868 = backend
->debug_swap
.external_ext_size
;
869 const bfd_size_type external_sym_size
870 = backend
->debug_swap
.external_sym_size
;
871 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
872 = backend
->debug_swap
.swap_ext_in
;
873 void (* const swap_sym_in
) (bfd
*, void *, SYMR
*)
874 = backend
->debug_swap
.swap_sym_in
;
875 ecoff_symbol_type
*internal
;
876 ecoff_symbol_type
*internal_ptr
;
883 /* If we've already read in the symbol table, do nothing. */
884 if (ecoff_data (abfd
)->canonical_symbols
!= NULL
)
887 /* Get the symbolic information. */
888 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
889 &ecoff_data (abfd
)->debug_info
))
891 if (bfd_get_symcount (abfd
) == 0)
894 if (_bfd_mul_overflow (bfd_get_symcount (abfd
),
895 sizeof (ecoff_symbol_type
), &amt
))
897 bfd_set_error (bfd_error_file_too_big
);
900 internal
= (ecoff_symbol_type
*) bfd_alloc (abfd
, amt
);
901 if (internal
== NULL
)
904 internal_ptr
= internal
;
905 eraw_src
= (char *) ecoff_data (abfd
)->debug_info
.external_ext
;
907 + (ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
908 * external_ext_size
));
909 for (; eraw_src
< eraw_end
; eraw_src
+= external_ext_size
, internal_ptr
++)
913 (*swap_ext_in
) (abfd
, (void *) eraw_src
, &internal_esym
);
915 /* PR 17512: file: 3372-1000-0.004. */
916 if (internal_esym
.asym
.iss
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.issExtMax
917 || internal_esym
.asym
.iss
< 0)
920 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ssext
921 + internal_esym
.asym
.iss
);
923 if (!ecoff_set_symbol_info (abfd
, &internal_esym
.asym
,
924 &internal_ptr
->symbol
, 1,
925 internal_esym
.weakext
))
928 /* The alpha uses a negative ifd field for section symbols. */
929 if (internal_esym
.ifd
>= 0)
931 /* PR 17512: file: 3372-1983-0.004. */
932 if (internal_esym
.ifd
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
)
933 internal_ptr
->fdr
= NULL
;
935 internal_ptr
->fdr
= (ecoff_data (abfd
)->debug_info
.fdr
936 + internal_esym
.ifd
);
939 internal_ptr
->fdr
= NULL
;
940 internal_ptr
->local
= FALSE
;
941 internal_ptr
->native
= (void *) eraw_src
;
944 /* The local symbols must be accessed via the fdr's, because the
945 string and aux indices are relative to the fdr information. */
946 fdr_ptr
= ecoff_data (abfd
)->debug_info
.fdr
;
947 fdr_end
= fdr_ptr
+ ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
;
948 for (; fdr_ptr
< fdr_end
; fdr_ptr
++)
953 lraw_src
= ((char *) ecoff_data (abfd
)->debug_info
.external_sym
954 + fdr_ptr
->isymBase
* external_sym_size
);
955 lraw_end
= lraw_src
+ fdr_ptr
->csym
* external_sym_size
;
958 lraw_src
+= external_sym_size
, internal_ptr
++)
962 (*swap_sym_in
) (abfd
, (void *) lraw_src
, &internal_sym
);
963 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ss
966 if (!ecoff_set_symbol_info (abfd
, &internal_sym
,
967 &internal_ptr
->symbol
, 0, 0))
969 internal_ptr
->fdr
= fdr_ptr
;
970 internal_ptr
->local
= TRUE
;
971 internal_ptr
->native
= (void *) lraw_src
;
975 /* PR 17512: file: 3372-3080-0.004.
976 A discrepancy between ecoff_data (abfd)->debug_info.symbolic_header.isymMax
977 and ecoff_data (abfd)->debug_info.symbolic_header.ifdMax can mean that
978 we have fewer symbols than we were expecting. Allow for this by updating
979 the symbol count and warning the user. */
980 if (internal_ptr
- internal
< (ptrdiff_t) bfd_get_symcount (abfd
))
982 abfd
->symcount
= internal_ptr
- internal
;
984 /* xgettext:c-format */
985 (_("%pB: warning: isymMax (%ld) is greater than ifdMax (%ld)"),
986 abfd
, ecoff_data (abfd
)->debug_info
.symbolic_header
.isymMax
,
987 ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
);
990 ecoff_data (abfd
)->canonical_symbols
= internal
;
995 /* Return the amount of space needed for the canonical symbols. */
998 _bfd_ecoff_get_symtab_upper_bound (bfd
*abfd
)
1000 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
1001 &ecoff_data (abfd
)->debug_info
))
1004 if (bfd_get_symcount (abfd
) == 0)
1007 return (bfd_get_symcount (abfd
) + 1) * (sizeof (ecoff_symbol_type
*));
1010 /* Get the canonical symbols. */
1013 _bfd_ecoff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
1015 unsigned int counter
= 0;
1016 ecoff_symbol_type
*symbase
;
1017 ecoff_symbol_type
**location
= (ecoff_symbol_type
**) alocation
;
1019 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1021 if (bfd_get_symcount (abfd
) == 0)
1024 symbase
= ecoff_data (abfd
)->canonical_symbols
;
1025 while (counter
< bfd_get_symcount (abfd
))
1027 *(location
++) = symbase
++;
1031 return bfd_get_symcount (abfd
);
1034 /* Turn ECOFF type information into a printable string.
1035 ecoff_emit_aggregate and ecoff_type_to_string are from
1036 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1038 /* Write aggregate information to a string. */
1041 ecoff_emit_aggregate (bfd
*abfd
,
1048 const struct ecoff_debug_swap
* const debug_swap
=
1049 &ecoff_backend (abfd
)->debug_swap
;
1050 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1051 unsigned int ifd
= rndx
->rfd
;
1052 unsigned int indx
= rndx
->index
;
1058 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1059 struct return type of a procedure compiled without -g. */
1060 if (ifd
== 0xffffffff
1061 || (rndx
->rfd
== 0xfff && indx
== 0))
1062 name
= "<undefined>";
1063 else if (indx
== indexNil
)
1069 if (debug_info
->external_rfd
== NULL
)
1070 fdr
= debug_info
->fdr
+ ifd
;
1075 (*debug_swap
->swap_rfd_in
) (abfd
,
1076 ((char *) debug_info
->external_rfd
1077 + ((fdr
->rfdBase
+ ifd
)
1078 * debug_swap
->external_rfd_size
)),
1080 fdr
= debug_info
->fdr
+ rfd
;
1083 indx
+= fdr
->isymBase
;
1085 (*debug_swap
->swap_sym_in
) (abfd
,
1086 ((char *) debug_info
->external_sym
1087 + indx
* debug_swap
->external_sym_size
),
1090 name
= debug_info
->ss
+ fdr
->issBase
+ sym
.iss
;
1094 "%s %s { ifd = %u, index = %lu }",
1096 ((unsigned long) indx
1097 + debug_info
->symbolic_header
.iextMax
));
1100 /* Convert the type information to string format. */
1103 ecoff_type_to_string (bfd
*abfd
, FDR
*fdr
, unsigned int indx
)
1105 union aux_ext
*aux_ptr
;
1115 unsigned int basic_type
;
1118 static char buffer2
[1024];
1123 aux_ptr
= ecoff_data (abfd
)->debug_info
.external_aux
+ fdr
->iauxBase
;
1124 bigendian
= fdr
->fBigendian
;
1126 for (i
= 0; i
< 7; i
++)
1128 qualifiers
[i
].low_bound
= 0;
1129 qualifiers
[i
].high_bound
= 0;
1130 qualifiers
[i
].stride
= 0;
1133 if (AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
]) == (bfd_vma
) -1)
1134 return "-1 (no type)";
1135 _bfd_ecoff_swap_tir_in (bigendian
, &aux_ptr
[indx
++].a_ti
, &u
.ti
);
1137 basic_type
= u
.ti
.bt
;
1138 qualifiers
[0].type
= u
.ti
.tq0
;
1139 qualifiers
[1].type
= u
.ti
.tq1
;
1140 qualifiers
[2].type
= u
.ti
.tq2
;
1141 qualifiers
[3].type
= u
.ti
.tq3
;
1142 qualifiers
[4].type
= u
.ti
.tq4
;
1143 qualifiers
[5].type
= u
.ti
.tq5
;
1144 qualifiers
[6].type
= tqNil
;
1146 /* Go get the basic type. */
1149 case btNil
: /* Undefined. */
1153 case btAdr
: /* Address - integer same size as pointer. */
1154 strcpy (p1
, "address");
1157 case btChar
: /* Character. */
1158 strcpy (p1
, "char");
1161 case btUChar
: /* Unsigned character. */
1162 strcpy (p1
, "unsigned char");
1165 case btShort
: /* Short. */
1166 strcpy (p1
, "short");
1169 case btUShort
: /* Unsigned short. */
1170 strcpy (p1
, "unsigned short");
1173 case btInt
: /* Int. */
1177 case btUInt
: /* Unsigned int. */
1178 strcpy (p1
, "unsigned int");
1181 case btLong
: /* Long. */
1182 strcpy (p1
, "long");
1185 case btULong
: /* Unsigned long. */
1186 strcpy (p1
, "unsigned long");
1189 case btFloat
: /* Float (real). */
1190 strcpy (p1
, "float");
1193 case btDouble
: /* Double (real). */
1194 strcpy (p1
, "double");
1197 /* Structures add 1-2 aux words:
1198 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1199 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1201 case btStruct
: /* Structure (Record). */
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 /* Unions add 1-2 aux words:
1210 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1211 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1213 case btUnion
: /* Union. */
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 /* Enumerations add 1-2 aux words:
1222 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1223 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1225 case btEnum
: /* Enumeration. */
1226 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1227 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1228 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1230 indx
++; /* Skip aux words. */
1233 case btTypedef
: /* Defined via a typedef, isymRef points. */
1234 strcpy (p1
, "typedef");
1237 case btRange
: /* Subrange of int. */
1238 strcpy (p1
, "subrange");
1241 case btSet
: /* Pascal sets. */
1245 case btComplex
: /* Fortran complex. */
1246 strcpy (p1
, "complex");
1249 case btDComplex
: /* Fortran double complex. */
1250 strcpy (p1
, "double complex");
1253 case btIndirect
: /* Forward or unnamed typedef. */
1254 strcpy (p1
, "forward/unamed typedef");
1257 case btFixedDec
: /* Fixed Decimal. */
1258 strcpy (p1
, "fixed decimal");
1261 case btFloatDec
: /* Float Decimal. */
1262 strcpy (p1
, "float decimal");
1265 case btString
: /* Varying Length Character String. */
1266 strcpy (p1
, "string");
1269 case btBit
: /* Aligned Bit String. */
1273 case btPicture
: /* Picture. */
1274 strcpy (p1
, "picture");
1277 case btVoid
: /* Void. */
1278 strcpy (p1
, "void");
1282 sprintf (p1
, _("unknown basic type %d"), (int) basic_type
);
1286 p1
+= strlen (buffer1
);
1288 /* If this is a bitfield, get the bitsize. */
1293 bitsize
= AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
++]);
1294 sprintf (p1
, " : %d", bitsize
);
1295 p1
+= strlen (buffer1
);
1298 /* Deal with any qualifiers. */
1299 if (qualifiers
[0].type
!= tqNil
)
1301 /* Snarf up any array bounds in the correct order. Arrays
1302 store 5 successive words in the aux. table:
1303 word 0 RNDXR to type of the bounds (ie, int)
1304 word 1 Current file descriptor index
1306 word 3 high bound (or -1 if [])
1307 word 4 stride size in bits. */
1308 for (i
= 0; i
< 7; i
++)
1310 if (qualifiers
[i
].type
== tqArray
)
1312 qualifiers
[i
].low_bound
=
1313 AUX_GET_DNLOW (bigendian
, &aux_ptr
[indx
+2]);
1314 qualifiers
[i
].high_bound
=
1315 AUX_GET_DNHIGH (bigendian
, &aux_ptr
[indx
+3]);
1316 qualifiers
[i
].stride
=
1317 AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
+4]);
1322 /* Now print out the qualifiers. */
1323 for (i
= 0; i
< 6; i
++)
1325 switch (qualifiers
[i
].type
)
1332 strcpy (p2
, "ptr to ");
1333 p2
+= sizeof ("ptr to ")-1;
1337 strcpy (p2
, "volatile ");
1338 p2
+= sizeof ("volatile ")-1;
1342 strcpy (p2
, "far ");
1343 p2
+= sizeof ("far ")-1;
1347 strcpy (p2
, "func. ret. ");
1348 p2
+= sizeof ("func. ret. ");
1353 int first_array
= i
;
1356 /* Print array bounds reversed (ie, in the order the C
1357 programmer writes them). C is such a fun language.... */
1358 while (i
< 5 && qualifiers
[i
+1].type
== tqArray
)
1361 for (j
= i
; j
>= first_array
; j
--)
1363 strcpy (p2
, "array [");
1364 p2
+= sizeof ("array [")-1;
1365 if (qualifiers
[j
].low_bound
!= 0)
1367 "%ld:%ld {%ld bits}",
1368 (long) qualifiers
[j
].low_bound
,
1369 (long) qualifiers
[j
].high_bound
,
1370 (long) qualifiers
[j
].stride
);
1372 else if (qualifiers
[j
].high_bound
!= -1)
1375 (long) (qualifiers
[j
].high_bound
+ 1),
1376 (long) (qualifiers
[j
].stride
));
1379 sprintf (p2
, " {%ld bits}", (long) (qualifiers
[j
].stride
));
1382 strcpy (p2
, "] of ");
1383 p2
+= sizeof ("] of ")-1;
1391 strcpy (p2
, buffer1
);
1395 /* Return information about ECOFF symbol SYMBOL in RET. */
1398 _bfd_ecoff_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
1402 bfd_symbol_info (symbol
, ret
);
1405 /* Return whether this is a local label. */
1408 _bfd_ecoff_bfd_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1411 return name
[0] == '$';
1414 /* Print information about an ECOFF symbol. */
1417 _bfd_ecoff_print_symbol (bfd
*abfd
,
1420 bfd_print_symbol_type how
)
1422 const struct ecoff_debug_swap
* const debug_swap
1423 = &ecoff_backend (abfd
)->debug_swap
;
1424 FILE *file
= (FILE *)filep
;
1428 case bfd_print_symbol_name
:
1429 fprintf (file
, "%s", symbol
->name
);
1431 case bfd_print_symbol_more
:
1432 if (ecoffsymbol (symbol
)->local
)
1436 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1438 fprintf (file
, "ecoff local ");
1439 fprintf_vma (file
, (bfd_vma
) ecoff_sym
.value
);
1440 fprintf (file
, " %x %x", (unsigned) ecoff_sym
.st
,
1441 (unsigned) ecoff_sym
.sc
);
1447 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1449 fprintf (file
, "ecoff extern ");
1450 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1451 fprintf (file
, " %x %x", (unsigned) ecoff_ext
.asym
.st
,
1452 (unsigned) ecoff_ext
.asym
.sc
);
1455 case bfd_print_symbol_all
:
1456 /* Print out the symbols in a reasonable way. */
1465 if (ecoffsymbol (symbol
)->local
)
1467 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1470 pos
= ((((char *) ecoffsymbol (symbol
)->native
1471 - (char *) ecoff_data (abfd
)->debug_info
.external_sym
)
1472 / debug_swap
->external_sym_size
)
1473 + ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
);
1480 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1483 pos
= (((char *) ecoffsymbol (symbol
)->native
1484 - (char *) ecoff_data (abfd
)->debug_info
.external_ext
)
1485 / debug_swap
->external_ext_size
);
1486 jmptbl
= ecoff_ext
.jmptbl
? 'j' : ' ';
1487 cobol_main
= ecoff_ext
.cobol_main
? 'c' : ' ';
1488 weakext
= ecoff_ext
.weakext
? 'w' : ' ';
1491 fprintf (file
, "[%3d] %c ",
1493 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1494 fprintf (file
, " st %x sc %x indx %x %c%c%c %s",
1495 (unsigned) ecoff_ext
.asym
.st
,
1496 (unsigned) ecoff_ext
.asym
.sc
,
1497 (unsigned) ecoff_ext
.asym
.index
,
1498 jmptbl
, cobol_main
, weakext
,
1501 if (ecoffsymbol (symbol
)->fdr
!= NULL
1502 && ecoff_ext
.asym
.index
!= indexNil
)
1507 bfd_size_type sym_base
;
1508 union aux_ext
*aux_base
;
1510 fdr
= ecoffsymbol (symbol
)->fdr
;
1511 indx
= ecoff_ext
.asym
.index
;
1513 /* sym_base is used to map the fdr relative indices which
1514 appear in the file to the position number which we are
1516 sym_base
= fdr
->isymBase
;
1517 if (ecoffsymbol (symbol
)->local
)
1519 ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
1521 /* aux_base is the start of the aux entries for this file;
1522 asym.index is an offset from this. */
1523 aux_base
= (ecoff_data (abfd
)->debug_info
.external_aux
1526 /* The aux entries are stored in host byte order; the
1527 order is indicated by a bit in the fdr. */
1528 bigendian
= fdr
->fBigendian
;
1530 /* This switch is basically from gcc/mips-tdump.c. */
1531 switch (ecoff_ext
.asym
.st
)
1539 fprintf (file
, _("\n End+1 symbol: %ld"),
1540 (long) (indx
+ sym_base
));
1544 if (ecoff_ext
.asym
.sc
== scText
1545 || ecoff_ext
.asym
.sc
== scInfo
)
1546 fprintf (file
, _("\n First symbol: %ld"),
1547 (long) (indx
+ sym_base
));
1549 fprintf (file
, _("\n First symbol: %ld"),
1551 (AUX_GET_ISYM (bigendian
,
1552 &aux_base
[ecoff_ext
.asym
.index
])
1558 if (ECOFF_IS_STAB (&ecoff_ext
.asym
))
1560 else if (ecoffsymbol (symbol
)->local
)
1561 /* xgettext:c-format */
1562 fprintf (file
, _("\n End+1 symbol: %-7ld Type: %s"),
1564 (AUX_GET_ISYM (bigendian
,
1565 &aux_base
[ecoff_ext
.asym
.index
])
1567 ecoff_type_to_string (abfd
, fdr
, indx
+ 1));
1569 fprintf (file
, _("\n Local symbol: %ld"),
1572 + (ecoff_data (abfd
)
1573 ->debug_info
.symbolic_header
.iextMax
)));
1577 fprintf (file
, _("\n struct; End+1 symbol: %ld"),
1578 (long) (indx
+ sym_base
));
1582 fprintf (file
, _("\n union; End+1 symbol: %ld"),
1583 (long) (indx
+ sym_base
));
1587 fprintf (file
, _("\n enum; End+1 symbol: %ld"),
1588 (long) (indx
+ sym_base
));
1592 if (! ECOFF_IS_STAB (&ecoff_ext
.asym
))
1593 fprintf (file
, _("\n Type: %s"),
1594 ecoff_type_to_string (abfd
, fdr
, indx
));
1603 /* Read in the relocs for a section. */
1606 ecoff_slurp_reloc_table (bfd
*abfd
,
1610 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1611 arelent
*internal_relocs
;
1612 bfd_size_type external_reloc_size
;
1614 char *external_relocs
;
1618 if (section
->relocation
!= NULL
1619 || section
->reloc_count
== 0
1620 || (section
->flags
& SEC_CONSTRUCTOR
) != 0)
1623 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1626 external_reloc_size
= backend
->external_reloc_size
;
1627 amt
= external_reloc_size
* section
->reloc_count
;
1628 external_relocs
= (char *) bfd_alloc (abfd
, amt
);
1629 if (external_relocs
== NULL
)
1631 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1633 if (bfd_bread (external_relocs
, amt
, abfd
) != amt
)
1636 amt
= section
->reloc_count
;
1637 amt
*= sizeof (arelent
);
1638 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
1639 if (internal_relocs
== NULL
)
1641 bfd_release (abfd
, external_relocs
);
1645 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1647 struct internal_reloc intern
;
1649 (*backend
->swap_reloc_in
) (abfd
,
1650 external_relocs
+ i
* external_reloc_size
,
1653 if (intern
.r_extern
)
1655 /* r_symndx is an index into the external symbols. */
1656 BFD_ASSERT (intern
.r_symndx
>= 0
1658 < (ecoff_data (abfd
)
1659 ->debug_info
.symbolic_header
.iextMax
)));
1660 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1663 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1664 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1666 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1671 const char *sec_name
;
1674 /* r_symndx is a section key. */
1675 switch (intern
.r_symndx
)
1677 case RELOC_SECTION_TEXT
: sec_name
= _TEXT
; break;
1678 case RELOC_SECTION_RDATA
: sec_name
= _RDATA
; break;
1679 case RELOC_SECTION_DATA
: sec_name
= _DATA
; break;
1680 case RELOC_SECTION_SDATA
: sec_name
= _SDATA
; break;
1681 case RELOC_SECTION_SBSS
: sec_name
= _SBSS
; break;
1682 case RELOC_SECTION_BSS
: sec_name
= _BSS
; break;
1683 case RELOC_SECTION_INIT
: sec_name
= _INIT
; break;
1684 case RELOC_SECTION_LIT8
: sec_name
= _LIT8
; break;
1685 case RELOC_SECTION_LIT4
: sec_name
= _LIT4
; break;
1686 case RELOC_SECTION_XDATA
: sec_name
= _XDATA
; break;
1687 case RELOC_SECTION_PDATA
: sec_name
= _PDATA
; break;
1688 case RELOC_SECTION_FINI
: sec_name
= _FINI
; break;
1689 case RELOC_SECTION_LITA
: sec_name
= _LITA
; break;
1690 case RELOC_SECTION_RCONST
: sec_name
= _RCONST
; break;
1694 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1697 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1699 rptr
->addend
= - bfd_section_vma (sec
);
1702 rptr
->address
= intern
.r_vaddr
- bfd_section_vma (section
);
1704 /* Let the backend select the howto field and do any other
1705 required processing. */
1706 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1709 bfd_release (abfd
, external_relocs
);
1711 section
->relocation
= internal_relocs
;
1716 /* Get a canonical list of relocs. */
1719 _bfd_ecoff_canonicalize_reloc (bfd
*abfd
,
1726 if (section
->flags
& SEC_CONSTRUCTOR
)
1728 arelent_chain
*chain
;
1730 /* This section has relocs made up by us, not the file, so take
1731 them out of their chain and place them into the data area
1733 for (count
= 0, chain
= section
->constructor_chain
;
1734 count
< section
->reloc_count
;
1735 count
++, chain
= chain
->next
)
1736 *relptr
++ = &chain
->relent
;
1742 if (! ecoff_slurp_reloc_table (abfd
, section
, symbols
))
1745 tblptr
= section
->relocation
;
1747 for (count
= 0; count
< section
->reloc_count
; count
++)
1748 *relptr
++ = tblptr
++;
1753 return section
->reloc_count
;
1756 /* Provided a BFD, a section and an offset into the section, calculate
1757 and return the name of the source file and the line nearest to the
1761 _bfd_ecoff_find_nearest_line (bfd
*abfd
,
1762 asymbol
**symbols ATTRIBUTE_UNUSED
,
1765 const char **filename_ptr
,
1766 const char **functionname_ptr
,
1767 unsigned int *retline_ptr
,
1768 unsigned int *discriminator_ptr
)
1770 const struct ecoff_debug_swap
* const debug_swap
1771 = &ecoff_backend (abfd
)->debug_swap
;
1772 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1773 struct ecoff_find_line
*line_info
;
1775 /* Make sure we have the FDR's. */
1776 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
, debug_info
)
1777 || bfd_get_symcount (abfd
) == 0)
1780 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1782 size_t amt
= sizeof (struct ecoff_find_line
);
1784 ecoff_data (abfd
)->find_line_info
=
1785 (struct ecoff_find_line
*) bfd_zalloc (abfd
, amt
);
1786 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1790 if (discriminator_ptr
)
1791 *discriminator_ptr
= 0;
1792 line_info
= ecoff_data (abfd
)->find_line_info
;
1793 return _bfd_ecoff_locate_line (abfd
, section
, offset
, debug_info
,
1794 debug_swap
, line_info
, filename_ptr
,
1795 functionname_ptr
, retline_ptr
);
1798 /* Copy private BFD data. This is called by objcopy and strip. We
1799 use it to copy the ECOFF debugging information from one BFD to the
1800 other. It would be theoretically possible to represent the ECOFF
1801 debugging information in the symbol table. However, it would be a
1802 lot of work, and there would be little gain (gas, gdb, and ld
1803 already access the ECOFF debugging information via the
1804 ecoff_debug_info structure, and that structure would have to be
1805 retained in order to support ECOFF debugging in MIPS ELF).
1807 The debugging information for the ECOFF external symbols comes from
1808 the symbol table, so this function only handles the other debugging
1812 _bfd_ecoff_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1814 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
1815 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
1817 asymbol
**sym_ptr_ptr
;
1821 /* We only want to copy information over if both BFD's use ECOFF
1823 if (bfd_get_flavour (ibfd
) != bfd_target_ecoff_flavour
1824 || bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
1827 /* Copy the GP value and the register masks. */
1828 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
1829 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
1830 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
1831 for (i
= 0; i
< 3; i
++)
1832 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
1834 /* Copy the version stamp. */
1835 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
1837 /* If there are no symbols, don't copy any debugging information. */
1838 c
= bfd_get_symcount (obfd
);
1839 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1840 if (c
== 0 || sym_ptr_ptr
== NULL
)
1843 /* See if there are any local symbols. */
1845 for (; c
> 0; c
--, sym_ptr_ptr
++)
1847 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
1856 /* There are some local symbols. We just bring over all the
1857 debugging information. FIXME: This is not quite the right
1858 thing to do. If the user has asked us to discard all
1859 debugging information, then we are probably going to wind up
1860 keeping it because there will probably be some local symbol
1861 which objcopy did not discard. We should actually break
1862 apart the debugging information and only keep that which
1863 applies to the symbols we want to keep. */
1864 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
1865 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
1866 oinfo
->line
= iinfo
->line
;
1868 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
1869 oinfo
->external_dnr
= iinfo
->external_dnr
;
1871 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
1872 oinfo
->external_pdr
= iinfo
->external_pdr
;
1874 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
1875 oinfo
->external_sym
= iinfo
->external_sym
;
1877 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
1878 oinfo
->external_opt
= iinfo
->external_opt
;
1880 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
1881 oinfo
->external_aux
= iinfo
->external_aux
;
1883 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
1884 oinfo
->ss
= iinfo
->ss
;
1886 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
1887 oinfo
->external_fdr
= iinfo
->external_fdr
;
1889 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
1890 oinfo
->external_rfd
= iinfo
->external_rfd
;
1894 /* We are discarding all the local symbol information. Look
1895 through the external symbols and remove all references to FDR
1896 or aux information. */
1897 c
= bfd_get_symcount (obfd
);
1898 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1899 for (; c
> 0; c
--, sym_ptr_ptr
++)
1903 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
1904 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
1906 esym
.asym
.index
= indexNil
;
1907 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
1908 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
1915 /* Set the architecture. The supported architecture is stored in the
1916 backend pointer. We always set the architecture anyhow, since many
1917 callers ignore the return value. */
1920 _bfd_ecoff_set_arch_mach (bfd
*abfd
,
1921 enum bfd_architecture arch
,
1922 unsigned long machine
)
1924 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1925 return arch
== ecoff_backend (abfd
)->arch
;
1928 /* Get the size of the section headers. */
1931 _bfd_ecoff_sizeof_headers (bfd
*abfd
,
1932 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1939 for (current
= abfd
->sections
;
1941 current
= current
->next
)
1944 ret
= (bfd_coff_filhsz (abfd
)
1945 + bfd_coff_aoutsz (abfd
)
1946 + c
* bfd_coff_scnhsz (abfd
));
1947 return (int) BFD_ALIGN (ret
, 16);
1950 /* Get the contents of a section. */
1953 _bfd_ecoff_get_section_contents (bfd
*abfd
,
1957 bfd_size_type count
)
1959 return _bfd_generic_get_section_contents (abfd
, section
, location
,
1963 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
1964 called via qsort. */
1967 ecoff_sort_hdrs (const void * arg1
, const void * arg2
)
1969 const asection
*hdr1
= *(const asection
**) arg1
;
1970 const asection
*hdr2
= *(const asection
**) arg2
;
1972 if ((hdr1
->flags
& SEC_ALLOC
) != 0)
1974 if ((hdr2
->flags
& SEC_ALLOC
) == 0)
1979 if ((hdr2
->flags
& SEC_ALLOC
) != 0)
1982 if (hdr1
->vma
< hdr2
->vma
)
1984 else if (hdr1
->vma
> hdr2
->vma
)
1990 /* Calculate the file position for each section, and set
1994 ecoff_compute_section_file_positions (bfd
*abfd
)
1996 file_ptr sofar
, file_sofar
;
1997 asection
**sorted_hdrs
;
2001 bfd_boolean rdata_in_text
;
2002 bfd_boolean first_data
, first_nonalloc
;
2003 const bfd_vma round
= ecoff_backend (abfd
)->round
;
2006 sofar
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2009 /* Sort the sections by VMA. */
2010 amt
= abfd
->section_count
;
2011 amt
*= sizeof (asection
*);
2012 sorted_hdrs
= (asection
**) bfd_malloc (amt
);
2013 if (sorted_hdrs
== NULL
)
2015 for (current
= abfd
->sections
, i
= 0;
2017 current
= current
->next
, i
++)
2018 sorted_hdrs
[i
] = current
;
2019 BFD_ASSERT (i
== abfd
->section_count
);
2021 qsort (sorted_hdrs
, abfd
->section_count
, sizeof (asection
*),
2024 /* Some versions of the OSF linker put the .rdata section in the
2025 text segment, and some do not. */
2026 rdata_in_text
= ecoff_backend (abfd
)->rdata_in_text
;
2029 for (i
= 0; i
< abfd
->section_count
; i
++)
2031 current
= sorted_hdrs
[i
];
2032 if (streq (current
->name
, _RDATA
))
2034 if ((current
->flags
& SEC_CODE
) == 0
2035 && ! streq (current
->name
, _PDATA
)
2036 && ! streq (current
->name
, _RCONST
))
2038 rdata_in_text
= FALSE
;
2043 ecoff_data (abfd
)->rdata_in_text
= rdata_in_text
;
2046 first_nonalloc
= TRUE
;
2047 for (i
= 0; i
< abfd
->section_count
; i
++)
2049 unsigned int alignment_power
;
2051 current
= sorted_hdrs
[i
];
2053 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2054 supposed to indicate the number of .pdata entries that are
2055 really in the section. Each entry is 8 bytes. We store this
2056 away in line_filepos before increasing the section size. */
2057 if (streq (current
->name
, _PDATA
))
2058 current
->line_filepos
= current
->size
/ 8;
2060 alignment_power
= current
->alignment_power
;
2062 /* On Ultrix, the data sections in an executable file must be
2063 aligned to a page boundary within the file. This does not
2064 affect the section size, though. FIXME: Does this work for
2065 other platforms? It requires some modification for the
2066 Alpha, because .rdata on the Alpha goes with the text, not
2068 if ((abfd
->flags
& EXEC_P
) != 0
2069 && (abfd
->flags
& D_PAGED
) != 0
2071 && (current
->flags
& SEC_CODE
) == 0
2073 || ! streq (current
->name
, _RDATA
))
2074 && ! streq (current
->name
, _PDATA
)
2075 && ! streq (current
->name
, _RCONST
))
2077 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2078 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2081 else if (streq (current
->name
, _LIB
))
2083 /* On Irix 4, the location of contents of the .lib section
2084 from a shared library section is also rounded up to a
2087 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2088 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2090 else if (first_nonalloc
2091 && (current
->flags
& SEC_ALLOC
) == 0
2092 && (abfd
->flags
& D_PAGED
) != 0)
2094 /* Skip up to the next page for an unallocated section, such
2095 as the .comment section on the Alpha. This leaves room
2096 for the .bss section. */
2097 first_nonalloc
= FALSE
;
2098 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2099 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2102 /* Align the sections in the file to the same boundary on
2103 which they are aligned in virtual memory. */
2104 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2105 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2106 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2108 if ((abfd
->flags
& D_PAGED
) != 0
2109 && (current
->flags
& SEC_ALLOC
) != 0)
2111 sofar
+= (current
->vma
- sofar
) % round
;
2112 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2113 file_sofar
+= (current
->vma
- file_sofar
) % round
;
2116 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) != 0)
2117 current
->filepos
= file_sofar
;
2119 sofar
+= current
->size
;
2120 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2121 file_sofar
+= current
->size
;
2123 /* Make sure that this section is of the right size too. */
2125 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2126 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2127 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2128 current
->size
+= sofar
- old_sofar
;
2134 ecoff_data (abfd
)->reloc_filepos
= file_sofar
;
2139 /* Determine the location of the relocs for all the sections in the
2140 output file, as well as the location of the symbolic debugging
2143 static bfd_size_type
2144 ecoff_compute_reloc_file_positions (bfd
*abfd
)
2146 const bfd_size_type external_reloc_size
=
2147 ecoff_backend (abfd
)->external_reloc_size
;
2148 file_ptr reloc_base
;
2149 bfd_size_type reloc_size
;
2153 if (! abfd
->output_has_begun
)
2155 if (! ecoff_compute_section_file_positions (abfd
))
2157 abfd
->output_has_begun
= TRUE
;
2160 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2163 for (current
= abfd
->sections
;
2165 current
= current
->next
)
2167 if (current
->reloc_count
== 0)
2168 current
->rel_filepos
= 0;
2171 bfd_size_type relsize
;
2173 current
->rel_filepos
= reloc_base
;
2174 relsize
= current
->reloc_count
* external_reloc_size
;
2175 reloc_size
+= relsize
;
2176 reloc_base
+= relsize
;
2180 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2182 /* At least on Ultrix, the symbol table of an executable file must
2183 be aligned to a page boundary. FIXME: Is this true on other
2185 if ((abfd
->flags
& EXEC_P
) != 0
2186 && (abfd
->flags
& D_PAGED
) != 0)
2187 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2188 &~ (ecoff_backend (abfd
)->round
- 1));
2190 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2195 /* Set the contents of a section. */
2198 _bfd_ecoff_set_section_contents (bfd
*abfd
,
2200 const void * location
,
2202 bfd_size_type count
)
2206 /* This must be done first, because bfd_set_section_contents is
2207 going to set output_has_begun to TRUE. */
2208 if (! abfd
->output_has_begun
2209 && ! ecoff_compute_section_file_positions (abfd
))
2212 /* Handle the .lib section specially so that Irix 4 shared libraries
2213 work out. See coff_set_section_contents in coffcode.h. */
2214 if (streq (section
->name
, _LIB
))
2216 bfd_byte
*rec
, *recend
;
2218 rec
= (bfd_byte
*) location
;
2219 recend
= rec
+ count
;
2220 while (rec
< recend
)
2223 rec
+= bfd_get_32 (abfd
, rec
) * 4;
2226 BFD_ASSERT (rec
== recend
);
2232 pos
= section
->filepos
+ offset
;
2233 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2234 || bfd_bwrite (location
, count
, abfd
) != count
)
2240 /* Set the GP value for an ECOFF file. This is a hook used by the
2244 bfd_ecoff_set_gp_value (bfd
*abfd
, bfd_vma gp_value
)
2246 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2247 || bfd_get_format (abfd
) != bfd_object
)
2249 bfd_set_error (bfd_error_invalid_operation
);
2253 ecoff_data (abfd
)->gp
= gp_value
;
2258 /* Set the register masks for an ECOFF file. This is a hook used by
2262 bfd_ecoff_set_regmasks (bfd
*abfd
,
2263 unsigned long gprmask
,
2264 unsigned long fprmask
,
2265 unsigned long *cprmask
)
2267 ecoff_data_type
*tdata
;
2269 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2270 || bfd_get_format (abfd
) != bfd_object
)
2272 bfd_set_error (bfd_error_invalid_operation
);
2276 tdata
= ecoff_data (abfd
);
2277 tdata
->gprmask
= gprmask
;
2278 tdata
->fprmask
= fprmask
;
2279 if (cprmask
!= NULL
)
2283 for (i
= 0; i
< 3; i
++)
2284 tdata
->cprmask
[i
] = cprmask
[i
];
2290 /* Get ECOFF EXTR information for an external symbol. This function
2291 is passed to bfd_ecoff_debug_externals. */
2294 ecoff_get_extr (asymbol
*sym
, EXTR
*esym
)
2296 ecoff_symbol_type
*ecoff_sym_ptr
;
2299 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2300 || ecoffsymbol (sym
)->native
== NULL
)
2302 /* Don't include debugging, local, or section symbols. */
2303 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2304 || (sym
->flags
& BSF_LOCAL
) != 0
2305 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2309 esym
->cobol_main
= 0;
2310 esym
->weakext
= (sym
->flags
& BSF_WEAK
) != 0;
2313 /* FIXME: we can do better than this for st and sc. */
2314 esym
->asym
.st
= stGlobal
;
2315 esym
->asym
.sc
= scAbs
;
2316 esym
->asym
.reserved
= 0;
2317 esym
->asym
.index
= indexNil
;
2321 ecoff_sym_ptr
= ecoffsymbol (sym
);
2323 if (ecoff_sym_ptr
->local
)
2326 input_bfd
= bfd_asymbol_bfd (sym
);
2327 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2328 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2330 /* If the symbol was defined by the linker, then esym will be
2331 undefined but sym will not be. Get a better class for such a
2333 if ((esym
->asym
.sc
== scUndefined
2334 || esym
->asym
.sc
== scSUndefined
)
2335 && ! bfd_is_und_section (bfd_asymbol_section (sym
)))
2336 esym
->asym
.sc
= scAbs
;
2338 /* Adjust the FDR index for the symbol by that used for the input
2340 if (esym
->ifd
!= -1)
2342 struct ecoff_debug_info
*input_debug
;
2344 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2345 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2346 if (input_debug
->ifdmap
!= NULL
)
2347 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2353 /* Set the external symbol index. This routine is passed to
2354 bfd_ecoff_debug_externals. */
2357 ecoff_set_index (asymbol
*sym
, bfd_size_type indx
)
2359 ecoff_set_sym_index (sym
, indx
);
2362 /* Write out an ECOFF file. */
2365 _bfd_ecoff_write_object_contents (bfd
*abfd
)
2367 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2368 const bfd_vma round
= backend
->round
;
2369 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2370 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2371 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2372 const bfd_size_type external_hdr_size
2373 = backend
->debug_swap
.external_hdr_size
;
2374 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2375 void (* const adjust_reloc_out
) (bfd
*, const arelent
*, struct internal_reloc
*)
2376 = backend
->adjust_reloc_out
;
2377 void (* const swap_reloc_out
) (bfd
*, const struct internal_reloc
*, void *)
2378 = backend
->swap_reloc_out
;
2379 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2380 HDRR
* const symhdr
= &debug
->symbolic_header
;
2383 bfd_size_type reloc_size
;
2384 bfd_size_type text_size
;
2386 bfd_boolean set_text_start
;
2387 bfd_size_type data_size
;
2389 bfd_boolean set_data_start
;
2390 bfd_size_type bss_size
;
2392 void * reloc_buff
= NULL
;
2393 struct internal_filehdr internal_f
;
2394 struct internal_aouthdr internal_a
;
2397 /* Determine where the sections and relocs will go in the output
2399 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2402 for (current
= abfd
->sections
;
2404 current
= current
->next
)
2406 current
->target_index
= count
;
2410 if ((abfd
->flags
& D_PAGED
) != 0)
2411 text_size
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2415 set_text_start
= FALSE
;
2418 set_data_start
= FALSE
;
2421 /* Write section headers to the file. */
2423 /* Allocate buff big enough to hold a section header,
2424 file header, or a.out header. */
2433 buff
= bfd_malloc (siz
);
2438 internal_f
.f_nscns
= 0;
2439 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2442 for (current
= abfd
->sections
;
2444 current
= current
->next
)
2446 struct internal_scnhdr section
;
2449 ++internal_f
.f_nscns
;
2451 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2453 /* This seems to be correct for Irix 4 shared libraries. */
2454 vma
= bfd_section_vma (current
);
2455 if (streq (current
->name
, _LIB
))
2456 section
.s_vaddr
= 0;
2458 section
.s_vaddr
= vma
;
2460 section
.s_paddr
= current
->lma
;
2461 section
.s_size
= current
->size
;
2463 /* If this section is unloadable then the scnptr will be 0. */
2464 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2465 section
.s_scnptr
= 0;
2467 section
.s_scnptr
= current
->filepos
;
2468 section
.s_relptr
= current
->rel_filepos
;
2470 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2471 object file produced by the assembler is supposed to point to
2472 information about how much room is required by objects of
2473 various different sizes. I think this only matters if we
2474 want the linker to compute the best size to use, or
2475 something. I don't know what happens if the information is
2477 if (! streq (current
->name
, _PDATA
))
2478 section
.s_lnnoptr
= 0;
2481 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2482 hold the number of entries in the section (each entry is
2483 8 bytes). We stored this in the line_filepos field in
2484 ecoff_compute_section_file_positions. */
2485 section
.s_lnnoptr
= current
->line_filepos
;
2488 section
.s_nreloc
= current
->reloc_count
;
2489 section
.s_nlnno
= 0;
2490 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2493 if (bfd_coff_swap_scnhdr_out (abfd
, (void *) §ion
, buff
) == 0
2494 || bfd_bwrite (buff
, scnhsz
, abfd
) != scnhsz
)
2497 if ((section
.s_flags
& STYP_TEXT
) != 0
2498 || ((section
.s_flags
& STYP_RDATA
) != 0
2499 && ecoff_data (abfd
)->rdata_in_text
)
2500 || section
.s_flags
== STYP_PDATA
2501 || (section
.s_flags
& STYP_DYNAMIC
) != 0
2502 || (section
.s_flags
& STYP_LIBLIST
) != 0
2503 || (section
.s_flags
& STYP_RELDYN
) != 0
2504 || section
.s_flags
== STYP_CONFLIC
2505 || (section
.s_flags
& STYP_DYNSTR
) != 0
2506 || (section
.s_flags
& STYP_DYNSYM
) != 0
2507 || (section
.s_flags
& STYP_HASH
) != 0
2508 || (section
.s_flags
& STYP_ECOFF_INIT
) != 0
2509 || (section
.s_flags
& STYP_ECOFF_FINI
) != 0
2510 || section
.s_flags
== STYP_RCONST
)
2512 text_size
+= current
->size
;
2513 if (! set_text_start
|| text_start
> vma
)
2516 set_text_start
= TRUE
;
2519 else if ((section
.s_flags
& STYP_RDATA
) != 0
2520 || (section
.s_flags
& STYP_DATA
) != 0
2521 || (section
.s_flags
& STYP_LITA
) != 0
2522 || (section
.s_flags
& STYP_LIT8
) != 0
2523 || (section
.s_flags
& STYP_LIT4
) != 0
2524 || (section
.s_flags
& STYP_SDATA
) != 0
2525 || section
.s_flags
== STYP_XDATA
2526 || (section
.s_flags
& STYP_GOT
) != 0)
2528 data_size
+= current
->size
;
2529 if (! set_data_start
|| data_start
> vma
)
2532 set_data_start
= TRUE
;
2535 else if ((section
.s_flags
& STYP_BSS
) != 0
2536 || (section
.s_flags
& STYP_SBSS
) != 0)
2537 bss_size
+= current
->size
;
2538 else if (section
.s_flags
== 0
2539 || (section
.s_flags
& STYP_ECOFF_LIB
) != 0
2540 || section
.s_flags
== STYP_COMMENT
)
2546 /* Set up the file header. */
2547 internal_f
.f_magic
= ecoff_get_magic (abfd
);
2549 /* We will NOT put a fucking timestamp in the header here. Every
2550 time you put it back, I will come in and take it out again. I'm
2551 sorry. This field does not belong here. We fill it with a 0 so
2552 it compares the same but is not a reasonable time. --
2554 internal_f
.f_timdat
= 0;
2556 if (bfd_get_symcount (abfd
) != 0)
2558 /* The ECOFF f_nsyms field is not actually the number of
2559 symbols, it's the size of symbolic information header. */
2560 internal_f
.f_nsyms
= external_hdr_size
;
2561 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
2565 internal_f
.f_nsyms
= 0;
2566 internal_f
.f_symptr
= 0;
2569 internal_f
.f_opthdr
= aoutsz
;
2571 internal_f
.f_flags
= F_LNNO
;
2572 if (reloc_size
== 0)
2573 internal_f
.f_flags
|= F_RELFLG
;
2574 if (bfd_get_symcount (abfd
) == 0)
2575 internal_f
.f_flags
|= F_LSYMS
;
2576 if (abfd
->flags
& EXEC_P
)
2577 internal_f
.f_flags
|= F_EXEC
;
2579 if (bfd_little_endian (abfd
))
2580 internal_f
.f_flags
|= F_AR32WR
;
2582 internal_f
.f_flags
|= F_AR32W
;
2584 /* Set up the ``optional'' header. */
2585 if ((abfd
->flags
& D_PAGED
) != 0)
2586 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
2588 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
2590 /* FIXME: Is this really correct? */
2591 internal_a
.vstamp
= symhdr
->vstamp
;
2593 /* At least on Ultrix, these have to be rounded to page boundaries.
2594 FIXME: Is this true on other platforms? */
2595 if ((abfd
->flags
& D_PAGED
) != 0)
2597 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
2598 internal_a
.text_start
= text_start
&~ (round
- 1);
2599 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
2600 internal_a
.data_start
= data_start
&~ (round
- 1);
2604 internal_a
.tsize
= text_size
;
2605 internal_a
.text_start
= text_start
;
2606 internal_a
.dsize
= data_size
;
2607 internal_a
.data_start
= data_start
;
2610 /* On Ultrix, the initial portions of the .sbss and .bss segments
2611 are at the end of the data section. The bsize field in the
2612 optional header records how many bss bytes are required beyond
2613 those in the data section. The value is not rounded to a page
2615 if (bss_size
< internal_a
.dsize
- data_size
)
2618 bss_size
-= internal_a
.dsize
- data_size
;
2619 internal_a
.bsize
= bss_size
;
2620 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
2622 internal_a
.entry
= bfd_get_start_address (abfd
);
2624 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
2626 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
2627 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
2628 for (i
= 0; i
< 4; i
++)
2629 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
2631 /* Let the backend adjust the headers if necessary. */
2632 if (backend
->adjust_headers
)
2634 if (! (*backend
->adjust_headers
) (abfd
, &internal_f
, &internal_a
))
2638 /* Write out the file header and the optional header. */
2639 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2642 bfd_coff_swap_filehdr_out (abfd
, (void *) &internal_f
, buff
);
2643 if (bfd_bwrite (buff
, filhsz
, abfd
) != filhsz
)
2646 bfd_coff_swap_aouthdr_out (abfd
, (void *) &internal_a
, buff
);
2647 if (bfd_bwrite (buff
, aoutsz
, abfd
) != aoutsz
)
2650 /* Build the external symbol information. This must be done before
2651 writing out the relocs so that we know the symbol indices. We
2652 don't do this if this BFD was created by the backend linker,
2653 since it will have already handled the symbols and relocs. */
2654 if (! ecoff_data (abfd
)->linker
)
2656 symhdr
->iextMax
= 0;
2657 symhdr
->issExtMax
= 0;
2658 debug
->external_ext
= debug
->external_ext_end
= NULL
;
2659 debug
->ssext
= debug
->ssext_end
= NULL
;
2660 if (! bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
2661 (abfd
->flags
& EXEC_P
) == 0,
2662 ecoff_get_extr
, ecoff_set_index
))
2665 /* Write out the relocs. */
2666 for (current
= abfd
->sections
;
2668 current
= current
->next
)
2670 arelent
**reloc_ptr_ptr
;
2671 arelent
**reloc_end
;
2675 if (current
->reloc_count
== 0)
2678 amt
= current
->reloc_count
* external_reloc_size
;
2679 reloc_buff
= bfd_alloc (abfd
, amt
);
2680 if (reloc_buff
== NULL
)
2683 reloc_ptr_ptr
= current
->orelocation
;
2684 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
2685 out_ptr
= (char *) reloc_buff
;
2688 reloc_ptr_ptr
< reloc_end
;
2689 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
2693 struct internal_reloc in
;
2695 memset ((void *) &in
, 0, sizeof in
);
2697 reloc
= *reloc_ptr_ptr
;
2698 sym
= *reloc
->sym_ptr_ptr
;
2700 /* If the howto field has not been initialised then skip this reloc.
2701 This assumes that an error message has been issued elsewhere. */
2702 if (reloc
->howto
== NULL
)
2705 in
.r_vaddr
= reloc
->address
+ bfd_section_vma (current
);
2706 in
.r_type
= reloc
->howto
->type
;
2708 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2710 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2724 { _TEXT
, RELOC_SECTION_TEXT
},
2725 { _RDATA
, RELOC_SECTION_RDATA
},
2726 { _DATA
, RELOC_SECTION_DATA
},
2727 { _SDATA
, RELOC_SECTION_SDATA
},
2728 { _SBSS
, RELOC_SECTION_SBSS
},
2729 { _BSS
, RELOC_SECTION_BSS
},
2730 { _INIT
, RELOC_SECTION_INIT
},
2731 { _LIT8
, RELOC_SECTION_LIT8
},
2732 { _LIT4
, RELOC_SECTION_LIT4
},
2733 { _XDATA
, RELOC_SECTION_XDATA
},
2734 { _PDATA
, RELOC_SECTION_PDATA
},
2735 { _FINI
, RELOC_SECTION_FINI
},
2736 { _LITA
, RELOC_SECTION_LITA
},
2737 { "*ABS*", RELOC_SECTION_ABS
},
2738 { _RCONST
, RELOC_SECTION_RCONST
}
2741 name
= bfd_section_name (bfd_asymbol_section (sym
));
2743 for (j
= 0; j
< ARRAY_SIZE (section_symndx
); j
++)
2744 if (streq (name
, section_symndx
[j
].name
))
2746 in
.r_symndx
= section_symndx
[j
].r_symndx
;
2750 if (j
== ARRAY_SIZE (section_symndx
))
2755 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2757 (*swap_reloc_out
) (abfd
, &in
, (void *) out_ptr
);
2760 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2762 amt
= current
->reloc_count
* external_reloc_size
;
2763 if (bfd_bwrite (reloc_buff
, amt
, abfd
) != amt
)
2765 bfd_release (abfd
, reloc_buff
);
2769 /* Write out the symbolic debugging information. */
2770 if (bfd_get_symcount (abfd
) > 0)
2772 /* Write out the debugging information. */
2773 if (! bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2774 ecoff_data (abfd
)->sym_filepos
))
2779 /* The .bss section of a demand paged executable must receive an
2780 entire page. If there are symbols, the symbols will start on the
2781 next page. If there are no symbols, we must fill out the page by
2783 if (bfd_get_symcount (abfd
) == 0
2784 && (abfd
->flags
& EXEC_P
) != 0
2785 && (abfd
->flags
& D_PAGED
) != 0)
2789 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2792 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) == 0)
2794 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2797 if (bfd_bwrite (&c
, (bfd_size_type
) 1, abfd
) != 1)
2801 if (reloc_buff
!= NULL
)
2802 bfd_release (abfd
, reloc_buff
);
2807 if (reloc_buff
!= NULL
)
2808 bfd_release (abfd
, reloc_buff
);
2814 /* Archive handling. ECOFF uses what appears to be a unique type of
2815 archive header (armap). The byte ordering of the armap and the
2816 contents are encoded in the name of the armap itself. At least for
2817 now, we only support archives with the same byte ordering in the
2818 armap and the contents.
2820 The first four bytes in the armap are the number of symbol
2821 definitions. This is always a power of two.
2823 This is followed by the symbol definitions. Each symbol definition
2824 occupies 8 bytes. The first four bytes are the offset from the
2825 start of the armap strings to the null-terminated string naming
2826 this symbol. The second four bytes are the file offset to the
2827 archive member which defines this symbol. If the second four bytes
2828 are 0, then this is not actually a symbol definition, and it should
2831 The symbols are hashed into the armap with a closed hashing scheme.
2832 See the functions below for the details of the algorithm.
2834 After the symbol definitions comes four bytes holding the size of
2835 the string table, followed by the string table itself. */
2837 /* The name of an archive headers looks like this:
2838 __________E[BL]E[BL]_ (with a trailing space).
2839 The trailing space is changed to an X if the archive is changed to
2840 indicate that the armap is out of date.
2842 The Alpha seems to use ________64E[BL]E[BL]_. */
2844 #define ARMAP_BIG_ENDIAN 'B'
2845 #define ARMAP_LITTLE_ENDIAN 'L'
2846 #define ARMAP_MARKER 'E'
2847 #define ARMAP_START_LENGTH 10
2848 #define ARMAP_HEADER_MARKER_INDEX 10
2849 #define ARMAP_HEADER_ENDIAN_INDEX 11
2850 #define ARMAP_OBJECT_MARKER_INDEX 12
2851 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2852 #define ARMAP_END_INDEX 14
2853 #define ARMAP_END "_ "
2855 /* This is a magic number used in the hashing algorithm. */
2856 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2858 /* This returns the hash value to use for a string. It also sets
2859 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2860 is the number of entries in the hash table, and HLOG is the log
2864 ecoff_armap_hash (const char *s
,
2865 unsigned int *rehash
,
2875 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2876 hash
*= ARMAP_HASH_MAGIC
;
2877 *rehash
= (hash
& (size
- 1)) | 1;
2878 return hash
>> (32 - hlog
);
2881 /* Read in the armap. */
2884 _bfd_ecoff_slurp_armap (bfd
*abfd
)
2888 struct areltdata
*mapdata
;
2889 bfd_size_type parsed_size
;
2891 struct artdata
*ardata
;
2898 /* Get the name of the first element. */
2899 i
= bfd_bread ((void *) nextname
, (bfd_size_type
) 16, abfd
);
2905 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2908 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2909 standard COFF armap. We could move the ECOFF armap stuff into
2910 bfd_slurp_armap, but that seems inappropriate since no other
2911 target uses this format. Instead, we check directly for a COFF
2913 if (CONST_STRNEQ (nextname
, "/ "))
2914 return bfd_slurp_armap (abfd
);
2916 /* See if the first element is an armap. */
2917 if (! strneq (nextname
, ecoff_backend (abfd
)->armap_start
, ARMAP_START_LENGTH
)
2918 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
2919 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2920 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2921 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
2922 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2923 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2924 || ! strneq (nextname
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1))
2926 abfd
->has_armap
= FALSE
;
2930 /* Make sure we have the right byte ordering. */
2931 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2932 ^ (bfd_header_big_endian (abfd
)))
2933 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2934 ^ (bfd_big_endian (abfd
))))
2936 bfd_set_error (bfd_error_wrong_format
);
2940 /* Read in the armap. */
2941 ardata
= bfd_ardata (abfd
);
2942 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
2943 if (mapdata
== NULL
)
2945 parsed_size
= mapdata
->parsed_size
;
2948 raw_armap
= (char *) bfd_alloc (abfd
, parsed_size
);
2949 if (raw_armap
== NULL
)
2952 if (bfd_bread ((void *) raw_armap
, parsed_size
, abfd
) != parsed_size
)
2954 if (bfd_get_error () != bfd_error_system_call
)
2955 bfd_set_error (bfd_error_malformed_archive
);
2956 bfd_release (abfd
, (void *) raw_armap
);
2960 ardata
->tdata
= (void *) raw_armap
;
2962 count
= H_GET_32 (abfd
, raw_armap
);
2964 ardata
->symdef_count
= 0;
2965 ardata
->cache
= NULL
;
2967 /* This code used to overlay the symdefs over the raw archive data,
2968 but that doesn't work on a 64 bit host. */
2969 stringbase
= raw_armap
+ count
* 8 + 8;
2971 #ifdef CHECK_ARMAP_HASH
2975 /* Double check that I have the hashing algorithm right by making
2976 sure that every symbol can be looked up successfully. */
2978 for (i
= 1; i
< count
; i
<<= 1)
2980 BFD_ASSERT (i
== count
);
2982 raw_ptr
= raw_armap
+ 4;
2983 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2985 unsigned int name_offset
, file_offset
;
2986 unsigned int hash
, rehash
, srch
;
2988 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2989 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2990 if (file_offset
== 0)
2992 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
2997 /* See if we can rehash to this location. */
2998 for (srch
= (hash
+ rehash
) & (count
- 1);
2999 srch
!= hash
&& srch
!= i
;
3000 srch
= (srch
+ rehash
) & (count
- 1))
3001 BFD_ASSERT (H_GET_32 (abfd
, (raw_armap
+ 8 + srch
* 8)) != 0);
3002 BFD_ASSERT (srch
== i
);
3006 #endif /* CHECK_ARMAP_HASH */
3008 raw_ptr
= raw_armap
+ 4;
3009 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3010 if (H_GET_32 (abfd
, (raw_ptr
+ 4)) != 0)
3011 ++ardata
->symdef_count
;
3013 amt
= ardata
->symdef_count
;
3014 amt
*= sizeof (carsym
);
3015 symdef_ptr
= (carsym
*) bfd_alloc (abfd
, amt
);
3019 ardata
->symdefs
= symdef_ptr
;
3021 raw_ptr
= raw_armap
+ 4;
3022 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3024 unsigned int name_offset
, file_offset
;
3026 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
3027 if (file_offset
== 0)
3029 name_offset
= H_GET_32 (abfd
, raw_ptr
);
3030 symdef_ptr
->name
= stringbase
+ name_offset
;
3031 symdef_ptr
->file_offset
= file_offset
;
3035 ardata
->first_file_filepos
= bfd_tell (abfd
);
3036 /* Pad to an even boundary. */
3037 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
3039 abfd
->has_armap
= TRUE
;
3044 /* Write out an armap. */
3047 _bfd_ecoff_write_armap (bfd
*abfd
,
3048 unsigned int elength
,
3050 unsigned int orl_count
,
3053 unsigned int hashsize
, hashlog
;
3054 bfd_size_type symdefsize
;
3056 unsigned int stringsize
;
3057 unsigned int mapsize
;
3060 struct stat statbuf
;
3063 bfd_byte
*hashtable
;
3067 /* Ultrix appears to use as a hash table size the least power of two
3068 greater than twice the number of entries. */
3069 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3071 hashsize
= 1 << hashlog
;
3073 symdefsize
= hashsize
* 8;
3075 stringsize
= stridx
+ padit
;
3077 /* Include 8 bytes to store symdefsize and stringsize in output. */
3078 mapsize
= symdefsize
+ stringsize
+ 8;
3080 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3082 memset ((void *) &hdr
, 0, sizeof hdr
);
3084 /* Work out the ECOFF armap name. */
3085 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3086 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3087 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3088 (bfd_header_big_endian (abfd
)
3090 : ARMAP_LITTLE_ENDIAN
);
3091 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3092 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3093 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3094 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3096 /* Write the timestamp of the archive header to be just a little bit
3097 later than the timestamp of the file, otherwise the linker will
3098 complain that the index is out of date. Actually, the Ultrix
3099 linker just checks the archive name; the GNU linker may check the
3101 stat (abfd
->filename
, &statbuf
);
3102 _bfd_ar_spacepad (hdr
.ar_date
, sizeof (hdr
.ar_date
), "%ld",
3103 (long) (statbuf
.st_mtime
+ 60));
3105 /* The DECstation uses zeroes for the uid, gid and mode of the
3107 hdr
.ar_uid
[0] = '0';
3108 hdr
.ar_gid
[0] = '0';
3109 /* Building gcc ends up extracting the armap as a file - twice. */
3110 hdr
.ar_mode
[0] = '6';
3111 hdr
.ar_mode
[1] = '4';
3112 hdr
.ar_mode
[2] = '4';
3114 _bfd_ar_spacepad (hdr
.ar_size
, sizeof (hdr
.ar_size
), "%-10ld", mapsize
);
3116 hdr
.ar_fmag
[0] = '`';
3117 hdr
.ar_fmag
[1] = '\012';
3119 /* Turn all null bytes in the header into spaces. */
3120 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3121 if (((char *) (&hdr
))[i
] == '\0')
3122 (((char *) (&hdr
))[i
]) = ' ';
3124 if (bfd_bwrite ((void *) &hdr
, (bfd_size_type
) sizeof (struct ar_hdr
), abfd
)
3125 != sizeof (struct ar_hdr
))
3128 H_PUT_32 (abfd
, hashsize
, temp
);
3129 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3132 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3136 current
= abfd
->archive_head
;
3138 for (i
= 0; i
< orl_count
; i
++)
3140 unsigned int hash
, rehash
= 0;
3142 /* Advance firstreal to the file position of this archive
3144 if (map
[i
].u
.abfd
!= last_elt
)
3148 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3149 firstreal
+= firstreal
% 2;
3150 current
= current
->archive_next
;
3152 while (current
!= map
[i
].u
.abfd
);
3157 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3158 if (H_GET_32 (abfd
, (hashtable
+ (hash
* 8) + 4)) != 0)
3162 /* The desired slot is already taken. */
3163 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3165 srch
= (srch
+ rehash
) & (hashsize
- 1))
3166 if (H_GET_32 (abfd
, (hashtable
+ (srch
* 8) + 4)) == 0)
3169 BFD_ASSERT (srch
!= hash
);
3174 H_PUT_32 (abfd
, map
[i
].namidx
, (hashtable
+ hash
* 8));
3175 H_PUT_32 (abfd
, firstreal
, (hashtable
+ hash
* 8 + 4));
3178 if (bfd_bwrite ((void *) hashtable
, symdefsize
, abfd
) != symdefsize
)
3181 bfd_release (abfd
, hashtable
);
3183 /* Now write the strings. */
3184 H_PUT_32 (abfd
, stringsize
, temp
);
3185 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3187 for (i
= 0; i
< orl_count
; i
++)
3191 len
= strlen (*map
[i
].name
) + 1;
3192 if (bfd_bwrite ((void *) (*map
[i
].name
), len
, abfd
) != len
)
3196 /* The spec sez this should be a newline. But in order to be
3197 bug-compatible for DECstation ar we use a null. */
3200 if (bfd_bwrite ("", (bfd_size_type
) 1, abfd
) != 1)
3207 /* ECOFF linker code. */
3209 /* Routine to create an entry in an ECOFF link hash table. */
3211 static struct bfd_hash_entry
*
3212 ecoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
3213 struct bfd_hash_table
*table
,
3216 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3218 /* Allocate the structure if it has not already been allocated by a
3221 ret
= ((struct ecoff_link_hash_entry
*)
3222 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3226 /* Call the allocation method of the superclass. */
3227 ret
= ((struct ecoff_link_hash_entry
*)
3228 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3233 /* Set local fields. */
3239 memset ((void *) &ret
->esym
, 0, sizeof ret
->esym
);
3241 return (struct bfd_hash_entry
*) ret
;
3244 /* Create an ECOFF link hash table. */
3246 struct bfd_link_hash_table
*
3247 _bfd_ecoff_bfd_link_hash_table_create (bfd
*abfd
)
3249 struct ecoff_link_hash_table
*ret
;
3250 size_t amt
= sizeof (struct ecoff_link_hash_table
);
3252 ret
= (struct ecoff_link_hash_table
*) bfd_malloc (amt
);
3255 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
,
3256 ecoff_link_hash_newfunc
,
3257 sizeof (struct ecoff_link_hash_entry
)))
3265 /* Look up an entry in an ECOFF link hash table. */
3267 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3268 ((struct ecoff_link_hash_entry *) \
3269 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3271 /* Get the ECOFF link hash table from the info structure. This is
3274 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3276 /* Add the external symbols of an object file to the global linker
3277 hash table. The external symbols and strings we are passed are
3278 just allocated on the stack, and will be discarded. We must
3279 explicitly save any information we may need later on in the link.
3280 We do not want to read the external symbol information again. */
3283 ecoff_link_add_externals (bfd
*abfd
,
3284 struct bfd_link_info
*info
,
3285 void * external_ext
,
3288 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3289 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3290 = backend
->debug_swap
.swap_ext_in
;
3291 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3292 unsigned long ext_count
;
3293 struct bfd_link_hash_entry
**sym_hash
;
3298 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3301 amt
*= sizeof (struct bfd_link_hash_entry
*);
3302 sym_hash
= (struct bfd_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3305 ecoff_data (abfd
)->sym_hashes
= (struct ecoff_link_hash_entry
**) sym_hash
;
3307 ext_ptr
= (char *) external_ext
;
3308 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3309 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3316 struct ecoff_link_hash_entry
*h
;
3320 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3322 /* Skip debugging symbols. */
3324 switch (esym
.asym
.st
)
3340 /* Get the information for this symbol. */
3341 value
= esym
.asym
.value
;
3342 switch (esym
.asym
.sc
)
3362 section
= bfd_make_section_old_way (abfd
, _TEXT
);
3363 value
-= section
->vma
;
3366 section
= bfd_make_section_old_way (abfd
, _DATA
);
3367 value
-= section
->vma
;
3370 section
= bfd_make_section_old_way (abfd
, _BSS
);
3371 value
-= section
->vma
;
3374 section
= bfd_abs_section_ptr
;
3377 section
= bfd_und_section_ptr
;
3380 section
= bfd_make_section_old_way (abfd
, _SDATA
);
3381 value
-= section
->vma
;
3384 section
= bfd_make_section_old_way (abfd
, _SBSS
);
3385 value
-= section
->vma
;
3388 section
= bfd_make_section_old_way (abfd
, _RDATA
);
3389 value
-= section
->vma
;
3392 if (value
> ecoff_data (abfd
)->gp_size
)
3394 section
= bfd_com_section_ptr
;
3399 if (ecoff_scom_section
.name
== NULL
)
3401 /* Initialize the small common section. */
3402 ecoff_scom_section
.name
= SCOMMON
;
3403 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
3404 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
3405 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
3406 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
3407 ecoff_scom_symbol
.name
= SCOMMON
;
3408 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
3409 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
3410 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
3412 section
= &ecoff_scom_section
;
3415 section
= bfd_und_section_ptr
;
3418 section
= bfd_make_section_old_way (abfd
, _INIT
);
3419 value
-= section
->vma
;
3422 section
= bfd_make_section_old_way (abfd
, _FINI
);
3423 value
-= section
->vma
;
3426 section
= bfd_make_section_old_way (abfd
, _RCONST
);
3427 value
-= section
->vma
;
3431 if (section
== NULL
)
3434 name
= ssext
+ esym
.asym
.iss
;
3436 if (! (_bfd_generic_link_add_one_symbol
3438 (flagword
) (esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
),
3439 section
, value
, NULL
, TRUE
, TRUE
, sym_hash
)))
3442 h
= (struct ecoff_link_hash_entry
*) *sym_hash
;
3444 /* If we are building an ECOFF hash table, save the external
3445 symbol information. */
3446 if (bfd_get_flavour (info
->output_bfd
) == bfd_get_flavour (abfd
))
3449 || (! bfd_is_und_section (section
)
3450 && (! bfd_is_com_section (section
)
3451 || (h
->root
.type
!= bfd_link_hash_defined
3452 && h
->root
.type
!= bfd_link_hash_defweak
))))
3458 /* Remember whether this symbol was small undefined. */
3459 if (esym
.asym
.sc
== scSUndefined
)
3462 /* If this symbol was ever small undefined, it needs to wind
3463 up in a GP relative section. We can't control the
3464 section of a defined symbol, but we can control the
3465 section of a common symbol. This case is actually needed
3466 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3468 && h
->root
.type
== bfd_link_hash_common
3469 && streq (h
->root
.u
.c
.p
->section
->name
, SCOMMON
))
3471 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
3473 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
3474 if (h
->esym
.asym
.sc
== scCommon
)
3475 h
->esym
.asym
.sc
= scSCommon
;
3483 /* Add symbols from an ECOFF object file to the global linker hash
3487 ecoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3490 bfd_size_type external_ext_size
;
3491 void * external_ext
= NULL
;
3492 bfd_size_type esize
;
3496 if (! ecoff_slurp_symbolic_header (abfd
))
3499 /* If there are no symbols, we don't want it. */
3500 if (bfd_get_symcount (abfd
) == 0)
3503 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3505 /* Read in the external symbols and external strings. */
3506 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3507 esize
= symhdr
->iextMax
* external_ext_size
;
3508 external_ext
= bfd_malloc (esize
);
3509 if (external_ext
== NULL
&& esize
!= 0)
3512 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbExtOffset
, SEEK_SET
) != 0
3513 || bfd_bread (external_ext
, esize
, abfd
) != esize
)
3516 ssext
= (char *) bfd_malloc ((bfd_size_type
) symhdr
->issExtMax
);
3517 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3520 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
3521 || (bfd_bread (ssext
, (bfd_size_type
) symhdr
->issExtMax
, abfd
)
3522 != (bfd_size_type
) symhdr
->issExtMax
))
3525 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3529 if (external_ext
!= NULL
)
3530 free (external_ext
);
3536 if (external_ext
!= NULL
)
3537 free (external_ext
);
3541 /* This is called if we used _bfd_generic_link_add_archive_symbols
3542 because we were not dealing with an ECOFF archive. */
3545 ecoff_link_check_archive_element (bfd
*abfd
,
3546 struct bfd_link_info
*info
,
3547 struct bfd_link_hash_entry
*h
,
3549 bfd_boolean
*pneeded
)
3553 /* Unlike the generic linker, we do not pull in elements because
3554 of common symbols. */
3555 if (h
->type
!= bfd_link_hash_undefined
)
3558 /* Include this element? */
3559 if (!(*info
->callbacks
->add_archive_element
) (info
, abfd
, name
, &abfd
))
3563 return ecoff_link_add_object_symbols (abfd
, info
);
3566 /* Add the symbols from an archive file to the global hash table.
3567 This looks through the undefined symbols, looks each one up in the
3568 archive hash table, and adds any associated object file. We do not
3569 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3570 already have a hash table, so there is no reason to construct
3574 ecoff_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3576 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3577 const bfd_byte
*raw_armap
;
3578 struct bfd_link_hash_entry
**pundef
;
3579 unsigned int armap_count
;
3580 unsigned int armap_log
;
3582 const bfd_byte
*hashtable
;
3583 const char *stringbase
;
3585 if (! bfd_has_map (abfd
))
3587 /* An empty archive is a special case. */
3588 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
3590 bfd_set_error (bfd_error_no_armap
);
3594 /* If we don't have any raw data for this archive, as can happen on
3595 Irix 4.0.5F, we call the generic routine.
3596 FIXME: We should be more clever about this, since someday tdata
3597 may get to something for a generic archive. */
3598 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3599 if (raw_armap
== NULL
)
3600 return (_bfd_generic_link_add_archive_symbols
3601 (abfd
, info
, ecoff_link_check_archive_element
));
3603 armap_count
= H_GET_32 (abfd
, raw_armap
);
3606 for (i
= 1; i
< armap_count
; i
<<= 1)
3608 BFD_ASSERT (i
== armap_count
);
3610 hashtable
= raw_armap
+ 4;
3611 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3613 /* Look through the list of undefined symbols. */
3614 pundef
= &info
->hash
->undefs
;
3615 while (*pundef
!= NULL
)
3617 struct bfd_link_hash_entry
*h
;
3618 unsigned int hash
, rehash
= 0;
3619 unsigned int file_offset
;
3625 /* When a symbol is defined, it is not necessarily removed from
3627 if (h
->type
!= bfd_link_hash_undefined
3628 && h
->type
!= bfd_link_hash_common
)
3630 /* Remove this entry from the list, for general cleanliness
3631 and because we are going to look through the list again
3632 if we search any more libraries. We can't remove the
3633 entry if it is the tail, because that would lose any
3634 entries we add to the list later on. */
3635 if (*pundef
!= info
->hash
->undefs_tail
)
3636 *pundef
= (*pundef
)->u
.undef
.next
;
3638 pundef
= &(*pundef
)->u
.undef
.next
;
3642 /* Native ECOFF linkers do not pull in archive elements merely
3643 to satisfy common definitions, so neither do we. We leave
3644 them on the list, though, in case we are linking against some
3645 other object format. */
3646 if (h
->type
!= bfd_link_hash_undefined
)
3648 pundef
= &(*pundef
)->u
.undef
.next
;
3652 /* Look for this symbol in the archive hash table. */
3653 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3656 file_offset
= H_GET_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3657 if (file_offset
== 0)
3659 /* Nothing in this slot. */
3660 pundef
= &(*pundef
)->u
.undef
.next
;
3664 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (hash
* 8));
3665 if (name
[0] != h
->root
.string
[0]
3666 || ! streq (name
, h
->root
.string
))
3671 /* That was the wrong symbol. Try rehashing. */
3673 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3675 srch
= (srch
+ rehash
) & (armap_count
- 1))
3677 file_offset
= H_GET_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3678 if (file_offset
== 0)
3680 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (srch
* 8));
3681 if (name
[0] == h
->root
.string
[0]
3682 && streq (name
, h
->root
.string
))
3691 pundef
= &(*pundef
)->u
.undef
.next
;
3698 element
= (*backend
->get_elt_at_filepos
) (abfd
, (file_ptr
) file_offset
);
3699 if (element
== NULL
)
3702 if (! bfd_check_format (element
, bfd_object
))
3705 /* Unlike the generic linker, we know that this element provides
3706 a definition for an undefined symbol and we know that we want
3707 to include it. We don't need to check anything. */
3708 if (!(*info
->callbacks
3709 ->add_archive_element
) (info
, element
, name
, &element
))
3711 if (! ecoff_link_add_object_symbols (element
, info
))
3714 pundef
= &(*pundef
)->u
.undef
.next
;
3720 /* Given an ECOFF BFD, add symbols to the global hash table as
3724 _bfd_ecoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3726 switch (bfd_get_format (abfd
))
3729 return ecoff_link_add_object_symbols (abfd
, info
);
3731 return ecoff_link_add_archive_symbols (abfd
, info
);
3733 bfd_set_error (bfd_error_wrong_format
);
3739 /* ECOFF final link routines. */
3741 /* Structure used to pass information to ecoff_link_write_external. */
3746 struct bfd_link_info
*info
;
3749 /* Accumulate the debugging information for an input BFD into the
3750 output BFD. This must read in the symbolic information of the
3754 ecoff_final_link_debug_accumulate (bfd
*output_bfd
,
3756 struct bfd_link_info
*info
,
3759 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
3760 const struct ecoff_debug_swap
* const swap
=
3761 &ecoff_backend (input_bfd
)->debug_swap
;
3762 HDRR
*symhdr
= &debug
->symbolic_header
;
3765 #define READ(ptr, offset, count, size, type) \
3769 debug->ptr = NULL; \
3770 if (symhdr->count == 0) \
3772 if (_bfd_mul_overflow (size, symhdr->count, &amt)) \
3774 bfd_set_error (bfd_error_file_too_big); \
3776 goto return_something; \
3778 debug->ptr = (type) bfd_malloc (amt); \
3779 if (debug->ptr == NULL) \
3782 goto return_something; \
3784 if (bfd_seek (input_bfd, symhdr->offset, SEEK_SET) != 0 \
3785 || bfd_bread (debug->ptr, amt, input_bfd) != amt) \
3788 goto return_something; \
3792 /* If raw_syments is not NULL, then the data was already by read by
3793 _bfd_ecoff_slurp_symbolic_info. */
3794 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3796 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
3798 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
3799 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
3800 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
3801 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
3802 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3804 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3805 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
3806 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
3810 /* We do not read the external strings or the external symbols. */
3812 ret
= (bfd_ecoff_debug_accumulate
3813 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
3814 &ecoff_backend (output_bfd
)->debug_swap
,
3815 input_bfd
, debug
, swap
, info
));
3818 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3820 if (debug
->line
!= NULL
)
3822 if (debug
->external_dnr
!= NULL
)
3823 free (debug
->external_dnr
);
3824 if (debug
->external_pdr
!= NULL
)
3825 free (debug
->external_pdr
);
3826 if (debug
->external_sym
!= NULL
)
3827 free (debug
->external_sym
);
3828 if (debug
->external_opt
!= NULL
)
3829 free (debug
->external_opt
);
3830 if (debug
->external_aux
!= NULL
)
3831 free (debug
->external_aux
);
3832 if (debug
->ss
!= NULL
)
3834 if (debug
->external_fdr
!= NULL
)
3835 free (debug
->external_fdr
);
3836 if (debug
->external_rfd
!= NULL
)
3837 free (debug
->external_rfd
);
3839 /* Make sure we don't accidentally follow one of these pointers
3840 into freed memory. */
3842 debug
->external_dnr
= NULL
;
3843 debug
->external_pdr
= NULL
;
3844 debug
->external_sym
= NULL
;
3845 debug
->external_opt
= NULL
;
3846 debug
->external_aux
= NULL
;
3848 debug
->external_fdr
= NULL
;
3849 debug
->external_rfd
= NULL
;
3855 /* Relocate and write an ECOFF section into an ECOFF output file. */
3858 ecoff_indirect_link_order (bfd
*output_bfd
,
3859 struct bfd_link_info
*info
,
3860 asection
*output_section
,
3861 struct bfd_link_order
*link_order
)
3863 asection
*input_section
;
3865 bfd_byte
*contents
= NULL
;
3866 bfd_size_type external_reloc_size
;
3867 bfd_size_type external_relocs_size
;
3868 void * external_relocs
= NULL
;
3870 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
3872 input_section
= link_order
->u
.indirect
.section
;
3873 input_bfd
= input_section
->owner
;
3874 if (input_section
->size
== 0)
3877 BFD_ASSERT (input_section
->output_section
== output_section
);
3878 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
3879 BFD_ASSERT (input_section
->size
== link_order
->size
);
3881 /* Get the section contents. */
3882 if (!bfd_malloc_and_get_section (input_bfd
, input_section
, &contents
))
3885 /* Get the relocs. If we are relaxing MIPS code, they will already
3886 have been read in. Otherwise, we read them in now. */
3887 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
3888 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
3890 external_relocs
= bfd_malloc (external_relocs_size
);
3891 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
3894 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3895 || (bfd_bread (external_relocs
, external_relocs_size
, input_bfd
)
3896 != external_relocs_size
))
3899 /* Relocate the section contents. */
3900 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
3901 (output_bfd
, info
, input_bfd
, input_section
, contents
,
3905 /* Write out the relocated section. */
3906 if (! bfd_set_section_contents (output_bfd
,
3909 input_section
->output_offset
,
3910 input_section
->size
))
3913 /* If we are producing relocatable output, the relocs were
3914 modified, and we write them out now. We use the reloc_count
3915 field of output_section to keep track of the number of relocs we
3916 have output so far. */
3917 if (bfd_link_relocatable (info
))
3919 file_ptr pos
= (output_section
->rel_filepos
3920 + output_section
->reloc_count
* external_reloc_size
);
3921 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
3922 || (bfd_bwrite (external_relocs
, external_relocs_size
, output_bfd
)
3923 != external_relocs_size
))
3925 output_section
->reloc_count
+= input_section
->reloc_count
;
3928 if (contents
!= NULL
)
3930 if (external_relocs
!= NULL
)
3931 free (external_relocs
);
3935 if (contents
!= NULL
)
3937 if (external_relocs
!= NULL
)
3938 free (external_relocs
);
3942 /* Generate a reloc when linking an ECOFF file. This is a reloc
3943 requested by the linker, and does come from any input file. This
3944 is used to build constructor and destructor tables when linking
3948 ecoff_reloc_link_order (bfd
*output_bfd
,
3949 struct bfd_link_info
*info
,
3950 asection
*output_section
,
3951 struct bfd_link_order
*link_order
)
3953 enum bfd_link_order_type type
;
3957 struct internal_reloc in
;
3958 bfd_size_type external_reloc_size
;
3963 type
= link_order
->type
;
3965 addend
= link_order
->u
.reloc
.p
->addend
;
3967 /* We set up an arelent to pass to the backend adjust_reloc_out
3969 rel
.address
= link_order
->offset
;
3971 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3974 bfd_set_error (bfd_error_bad_value
);
3978 if (type
== bfd_section_reloc_link_order
)
3980 section
= link_order
->u
.reloc
.p
->u
.section
;
3981 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
3985 struct bfd_link_hash_entry
*h
;
3987 /* Treat a reloc against a defined symbol as though it were
3988 actually against the section. */
3989 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3990 link_order
->u
.reloc
.p
->u
.name
,
3991 FALSE
, FALSE
, FALSE
);
3993 && (h
->type
== bfd_link_hash_defined
3994 || h
->type
== bfd_link_hash_defweak
))
3996 type
= bfd_section_reloc_link_order
;
3997 section
= h
->u
.def
.section
->output_section
;
3998 /* It seems that we ought to add the symbol value to the
3999 addend here, but in practice it has already been added
4000 because it was passed to constructor_callback. */
4001 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
4005 /* We can't set up a reloc against a symbol correctly,
4006 because we have no asymbol structure. Currently no
4007 adjust_reloc_out routine cares. */
4008 rel
.sym_ptr_ptr
= NULL
;
4012 /* All ECOFF relocs are in-place. Put the addend into the object
4015 BFD_ASSERT (rel
.howto
->partial_inplace
);
4019 bfd_reloc_status_type rstat
;
4022 size
= bfd_get_reloc_size (rel
.howto
);
4023 buf
= (bfd_byte
*) bfd_zmalloc (size
);
4024 if (buf
== NULL
&& size
!= 0)
4026 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
4027 (bfd_vma
) addend
, buf
);
4033 case bfd_reloc_outofrange
:
4035 case bfd_reloc_overflow
:
4036 (*info
->callbacks
->reloc_overflow
)
4038 (link_order
->type
== bfd_section_reloc_link_order
4039 ? bfd_section_name (section
)
4040 : link_order
->u
.reloc
.p
->u
.name
),
4041 rel
.howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0);
4044 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
4045 (file_ptr
) link_order
->offset
, size
);
4053 /* Move the information into an internal_reloc structure. */
4054 in
.r_vaddr
= rel
.address
+ bfd_section_vma (output_section
);
4055 in
.r_type
= rel
.howto
->type
;
4057 if (type
== bfd_symbol_reloc_link_order
)
4059 struct ecoff_link_hash_entry
*h
;
4061 h
= ((struct ecoff_link_hash_entry
*)
4062 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4063 link_order
->u
.reloc
.p
->u
.name
,
4064 FALSE
, FALSE
, TRUE
));
4067 in
.r_symndx
= h
->indx
;
4070 (*info
->callbacks
->unattached_reloc
)
4071 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
4087 { _TEXT
, RELOC_SECTION_TEXT
},
4088 { _RDATA
, RELOC_SECTION_RDATA
},
4089 { _DATA
, RELOC_SECTION_DATA
},
4090 { _SDATA
, RELOC_SECTION_SDATA
},
4091 { _SBSS
, RELOC_SECTION_SBSS
},
4092 { _BSS
, RELOC_SECTION_BSS
},
4093 { _INIT
, RELOC_SECTION_INIT
},
4094 { _LIT8
, RELOC_SECTION_LIT8
},
4095 { _LIT4
, RELOC_SECTION_LIT4
},
4096 { _XDATA
, RELOC_SECTION_XDATA
},
4097 { _PDATA
, RELOC_SECTION_PDATA
},
4098 { _FINI
, RELOC_SECTION_FINI
},
4099 { _LITA
, RELOC_SECTION_LITA
},
4100 { "*ABS*", RELOC_SECTION_ABS
},
4101 { _RCONST
, RELOC_SECTION_RCONST
}
4104 name
= bfd_section_name (section
);
4106 for (i
= 0; i
< ARRAY_SIZE (section_symndx
); i
++)
4107 if (streq (name
, section_symndx
[i
].name
))
4109 in
.r_symndx
= section_symndx
[i
].r_symndx
;
4113 if (i
== ARRAY_SIZE (section_symndx
))
4119 /* Let the BFD backend adjust the reloc. */
4120 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4122 /* Get some memory and swap out the reloc. */
4123 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4124 rbuf
= (bfd_byte
*) bfd_malloc (external_reloc_size
);
4128 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (void *) rbuf
);
4130 pos
= (output_section
->rel_filepos
4131 + output_section
->reloc_count
* external_reloc_size
);
4132 ok
= (bfd_seek (output_bfd
, pos
, SEEK_SET
) == 0
4133 && (bfd_bwrite ((void *) rbuf
, external_reloc_size
, output_bfd
)
4134 == external_reloc_size
));
4137 ++output_section
->reloc_count
;
4144 /* Put out information for an external symbol. These come only from
4148 ecoff_link_write_external (struct bfd_hash_entry
*bh
, void * data
)
4150 struct ecoff_link_hash_entry
*h
= (struct ecoff_link_hash_entry
*) bh
;
4151 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4152 bfd
*output_bfd
= einfo
->abfd
;
4155 if (h
->root
.type
== bfd_link_hash_warning
)
4157 h
= (struct ecoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4158 if (h
->root
.type
== bfd_link_hash_new
)
4162 /* We need to check if this symbol is being stripped. */
4163 if (h
->root
.type
== bfd_link_hash_undefined
4164 || h
->root
.type
== bfd_link_hash_undefweak
)
4166 else if (einfo
->info
->strip
== strip_all
4167 || (einfo
->info
->strip
== strip_some
4168 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4169 h
->root
.root
.string
,
4170 FALSE
, FALSE
) == NULL
))
4175 if (strip
|| h
->written
)
4178 if (h
->abfd
== NULL
)
4181 h
->esym
.cobol_main
= 0;
4182 h
->esym
.weakext
= 0;
4183 h
->esym
.reserved
= 0;
4184 h
->esym
.ifd
= ifdNil
;
4185 h
->esym
.asym
.value
= 0;
4186 h
->esym
.asym
.st
= stGlobal
;
4188 if (h
->root
.type
!= bfd_link_hash_defined
4189 && h
->root
.type
!= bfd_link_hash_defweak
)
4190 h
->esym
.asym
.sc
= scAbs
;
4193 asection
*output_section
;
4201 section_storage_classes
[] =
4205 { _SDATA
, scSData
},
4206 { _RDATA
, scRData
},
4211 { _PDATA
, scPData
},
4212 { _XDATA
, scXData
},
4213 { _RCONST
, scRConst
}
4216 output_section
= h
->root
.u
.def
.section
->output_section
;
4217 name
= bfd_section_name (output_section
);
4219 for (i
= 0; i
< ARRAY_SIZE (section_storage_classes
); i
++)
4220 if (streq (name
, section_storage_classes
[i
].name
))
4222 h
->esym
.asym
.sc
= section_storage_classes
[i
].sc
;
4226 if (i
== ARRAY_SIZE (section_storage_classes
))
4227 h
->esym
.asym
.sc
= scAbs
;
4230 h
->esym
.asym
.reserved
= 0;
4231 h
->esym
.asym
.index
= indexNil
;
4233 else if (h
->esym
.ifd
!= -1)
4235 struct ecoff_debug_info
*debug
;
4237 /* Adjust the FDR index for the symbol by that used for the
4239 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4240 BFD_ASSERT (h
->esym
.ifd
>= 0
4241 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4242 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4245 switch (h
->root
.type
)
4248 case bfd_link_hash_warning
:
4249 case bfd_link_hash_new
:
4251 case bfd_link_hash_undefined
:
4252 case bfd_link_hash_undefweak
:
4253 if (h
->esym
.asym
.sc
!= scUndefined
4254 && h
->esym
.asym
.sc
!= scSUndefined
)
4255 h
->esym
.asym
.sc
= scUndefined
;
4257 case bfd_link_hash_defined
:
4258 case bfd_link_hash_defweak
:
4259 if (h
->esym
.asym
.sc
== scUndefined
4260 || h
->esym
.asym
.sc
== scSUndefined
)
4261 h
->esym
.asym
.sc
= scAbs
;
4262 else if (h
->esym
.asym
.sc
== scCommon
)
4263 h
->esym
.asym
.sc
= scBss
;
4264 else if (h
->esym
.asym
.sc
== scSCommon
)
4265 h
->esym
.asym
.sc
= scSBss
;
4266 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4267 + h
->root
.u
.def
.section
->output_section
->vma
4268 + h
->root
.u
.def
.section
->output_offset
);
4270 case bfd_link_hash_common
:
4271 if (h
->esym
.asym
.sc
!= scCommon
4272 && h
->esym
.asym
.sc
!= scSCommon
)
4273 h
->esym
.asym
.sc
= scCommon
;
4274 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4276 case bfd_link_hash_indirect
:
4277 /* We ignore these symbols, since the indirected symbol is
4278 already in the hash table. */
4282 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4284 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4287 return (bfd_ecoff_debug_one_external
4288 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4289 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4293 /* ECOFF final link routine. This looks through all the input BFDs
4294 and gathers together all the debugging information, and then
4295 processes all the link order information. This may cause it to
4296 close and reopen some input BFDs; I'll see how bad this is. */
4299 _bfd_ecoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
4301 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4302 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4307 struct bfd_link_order
*p
;
4308 struct extsym_info einfo
;
4310 /* We accumulate the debugging information counts in the symbolic
4312 symhdr
= &debug
->symbolic_header
;
4314 symhdr
->ilineMax
= 0;
4318 symhdr
->isymMax
= 0;
4319 symhdr
->ioptMax
= 0;
4320 symhdr
->iauxMax
= 0;
4322 symhdr
->issExtMax
= 0;
4325 symhdr
->iextMax
= 0;
4327 /* We accumulate the debugging information itself in the debug_info
4330 debug
->external_dnr
= NULL
;
4331 debug
->external_pdr
= NULL
;
4332 debug
->external_sym
= NULL
;
4333 debug
->external_opt
= NULL
;
4334 debug
->external_aux
= NULL
;
4336 debug
->ssext
= debug
->ssext_end
= NULL
;
4337 debug
->external_fdr
= NULL
;
4338 debug
->external_rfd
= NULL
;
4339 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4341 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4345 /* Accumulate the debugging symbols from each input BFD. */
4346 for (input_bfd
= info
->input_bfds
;
4348 input_bfd
= input_bfd
->link
.next
)
4352 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4354 /* Arbitrarily set the symbolic header vstamp to the vstamp
4355 of the first object file in the link. */
4356 if (symhdr
->vstamp
== 0)
4358 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4359 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4363 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4364 debug
, &backend
->debug_swap
,
4369 /* Combine the register masks. */
4370 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4371 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4372 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4373 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4374 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4375 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4378 /* Write out the external symbols. */
4381 bfd_hash_traverse (&info
->hash
->table
, ecoff_link_write_external
, &einfo
);
4383 if (bfd_link_relocatable (info
))
4385 /* We need to make a pass over the link_orders to count up the
4386 number of relocations we will need to output, so that we know
4387 how much space they will take up. */
4388 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4391 for (p
= o
->map_head
.link_order
;
4394 if (p
->type
== bfd_indirect_link_order
)
4395 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4396 else if (p
->type
== bfd_section_reloc_link_order
4397 || p
->type
== bfd_symbol_reloc_link_order
)
4402 /* Compute the reloc and symbol file positions. */
4403 ecoff_compute_reloc_file_positions (abfd
);
4405 /* Write out the debugging information. */
4406 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4407 &backend
->debug_swap
, info
,
4408 ecoff_data (abfd
)->sym_filepos
))
4411 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4413 if (bfd_link_relocatable (info
))
4415 /* Now reset the reloc_count field of the sections in the output
4416 BFD to 0, so that we can use them to keep track of how many
4417 relocs we have output thus far. */
4418 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4422 /* Get a value for the GP register. */
4423 if (ecoff_data (abfd
)->gp
== 0)
4425 struct bfd_link_hash_entry
*h
;
4427 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
4429 && h
->type
== bfd_link_hash_defined
)
4430 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4431 + h
->u
.def
.section
->output_section
->vma
4432 + h
->u
.def
.section
->output_offset
);
4433 else if (bfd_link_relocatable (info
))
4437 /* Make up a value. */
4439 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4442 && (streq (o
->name
, _SBSS
)
4443 || streq (o
->name
, _SDATA
)
4444 || streq (o
->name
, _LIT4
)
4445 || streq (o
->name
, _LIT8
)
4446 || streq (o
->name
, _LITA
)))
4449 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4453 /* If the relocate_section function needs to do a reloc
4454 involving the GP value, it should make a reloc_dangerous
4455 callback to warn that GP is not defined. */
4459 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4461 for (p
= o
->map_head
.link_order
;
4465 if (p
->type
== bfd_indirect_link_order
4466 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4467 == bfd_target_ecoff_flavour
))
4469 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4472 else if (p
->type
== bfd_section_reloc_link_order
4473 || p
->type
== bfd_symbol_reloc_link_order
)
4475 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4480 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4486 abfd
->symcount
= symhdr
->iextMax
+ symhdr
->isymMax
;
4488 ecoff_data (abfd
)->linker
= TRUE
;