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 amt
= section
->reloc_count
;
1627 amt
*= sizeof (arelent
);
1628 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
1630 external_reloc_size
= backend
->external_reloc_size
;
1631 amt
= external_reloc_size
* section
->reloc_count
;
1632 external_relocs
= (char *) bfd_alloc (abfd
, amt
);
1633 if (internal_relocs
== NULL
|| external_relocs
== NULL
)
1635 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1637 if (bfd_bread (external_relocs
, amt
, abfd
) != amt
)
1640 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1642 struct internal_reloc intern
;
1644 (*backend
->swap_reloc_in
) (abfd
,
1645 external_relocs
+ i
* external_reloc_size
,
1648 if (intern
.r_extern
)
1650 /* r_symndx is an index into the external symbols. */
1651 BFD_ASSERT (intern
.r_symndx
>= 0
1653 < (ecoff_data (abfd
)
1654 ->debug_info
.symbolic_header
.iextMax
)));
1655 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1658 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1659 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1661 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1666 const char *sec_name
;
1669 /* r_symndx is a section key. */
1670 switch (intern
.r_symndx
)
1672 case RELOC_SECTION_TEXT
: sec_name
= _TEXT
; break;
1673 case RELOC_SECTION_RDATA
: sec_name
= _RDATA
; break;
1674 case RELOC_SECTION_DATA
: sec_name
= _DATA
; break;
1675 case RELOC_SECTION_SDATA
: sec_name
= _SDATA
; break;
1676 case RELOC_SECTION_SBSS
: sec_name
= _SBSS
; break;
1677 case RELOC_SECTION_BSS
: sec_name
= _BSS
; break;
1678 case RELOC_SECTION_INIT
: sec_name
= _INIT
; break;
1679 case RELOC_SECTION_LIT8
: sec_name
= _LIT8
; break;
1680 case RELOC_SECTION_LIT4
: sec_name
= _LIT4
; break;
1681 case RELOC_SECTION_XDATA
: sec_name
= _XDATA
; break;
1682 case RELOC_SECTION_PDATA
: sec_name
= _PDATA
; break;
1683 case RELOC_SECTION_FINI
: sec_name
= _FINI
; break;
1684 case RELOC_SECTION_LITA
: sec_name
= _LITA
; break;
1685 case RELOC_SECTION_RCONST
: sec_name
= _RCONST
; break;
1689 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1692 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1694 rptr
->addend
= - bfd_section_vma (sec
);
1697 rptr
->address
= intern
.r_vaddr
- bfd_section_vma (section
);
1699 /* Let the backend select the howto field and do any other
1700 required processing. */
1701 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1704 bfd_release (abfd
, external_relocs
);
1706 section
->relocation
= internal_relocs
;
1711 /* Get a canonical list of relocs. */
1714 _bfd_ecoff_canonicalize_reloc (bfd
*abfd
,
1721 if (section
->flags
& SEC_CONSTRUCTOR
)
1723 arelent_chain
*chain
;
1725 /* This section has relocs made up by us, not the file, so take
1726 them out of their chain and place them into the data area
1728 for (count
= 0, chain
= section
->constructor_chain
;
1729 count
< section
->reloc_count
;
1730 count
++, chain
= chain
->next
)
1731 *relptr
++ = &chain
->relent
;
1737 if (! ecoff_slurp_reloc_table (abfd
, section
, symbols
))
1740 tblptr
= section
->relocation
;
1742 for (count
= 0; count
< section
->reloc_count
; count
++)
1743 *relptr
++ = tblptr
++;
1748 return section
->reloc_count
;
1751 /* Provided a BFD, a section and an offset into the section, calculate
1752 and return the name of the source file and the line nearest to the
1756 _bfd_ecoff_find_nearest_line (bfd
*abfd
,
1757 asymbol
**symbols ATTRIBUTE_UNUSED
,
1760 const char **filename_ptr
,
1761 const char **functionname_ptr
,
1762 unsigned int *retline_ptr
,
1763 unsigned int *discriminator_ptr
)
1765 const struct ecoff_debug_swap
* const debug_swap
1766 = &ecoff_backend (abfd
)->debug_swap
;
1767 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1768 struct ecoff_find_line
*line_info
;
1770 /* Make sure we have the FDR's. */
1771 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
, debug_info
)
1772 || bfd_get_symcount (abfd
) == 0)
1775 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1777 size_t amt
= sizeof (struct ecoff_find_line
);
1779 ecoff_data (abfd
)->find_line_info
=
1780 (struct ecoff_find_line
*) bfd_zalloc (abfd
, amt
);
1781 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1785 if (discriminator_ptr
)
1786 *discriminator_ptr
= 0;
1787 line_info
= ecoff_data (abfd
)->find_line_info
;
1788 return _bfd_ecoff_locate_line (abfd
, section
, offset
, debug_info
,
1789 debug_swap
, line_info
, filename_ptr
,
1790 functionname_ptr
, retline_ptr
);
1793 /* Copy private BFD data. This is called by objcopy and strip. We
1794 use it to copy the ECOFF debugging information from one BFD to the
1795 other. It would be theoretically possible to represent the ECOFF
1796 debugging information in the symbol table. However, it would be a
1797 lot of work, and there would be little gain (gas, gdb, and ld
1798 already access the ECOFF debugging information via the
1799 ecoff_debug_info structure, and that structure would have to be
1800 retained in order to support ECOFF debugging in MIPS ELF).
1802 The debugging information for the ECOFF external symbols comes from
1803 the symbol table, so this function only handles the other debugging
1807 _bfd_ecoff_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1809 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
1810 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
1812 asymbol
**sym_ptr_ptr
;
1816 /* We only want to copy information over if both BFD's use ECOFF
1818 if (bfd_get_flavour (ibfd
) != bfd_target_ecoff_flavour
1819 || bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
1822 /* Copy the GP value and the register masks. */
1823 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
1824 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
1825 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
1826 for (i
= 0; i
< 3; i
++)
1827 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
1829 /* Copy the version stamp. */
1830 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
1832 /* If there are no symbols, don't copy any debugging information. */
1833 c
= bfd_get_symcount (obfd
);
1834 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1835 if (c
== 0 || sym_ptr_ptr
== NULL
)
1838 /* See if there are any local symbols. */
1840 for (; c
> 0; c
--, sym_ptr_ptr
++)
1842 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
1851 /* There are some local symbols. We just bring over all the
1852 debugging information. FIXME: This is not quite the right
1853 thing to do. If the user has asked us to discard all
1854 debugging information, then we are probably going to wind up
1855 keeping it because there will probably be some local symbol
1856 which objcopy did not discard. We should actually break
1857 apart the debugging information and only keep that which
1858 applies to the symbols we want to keep. */
1859 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
1860 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
1861 oinfo
->line
= iinfo
->line
;
1863 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
1864 oinfo
->external_dnr
= iinfo
->external_dnr
;
1866 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
1867 oinfo
->external_pdr
= iinfo
->external_pdr
;
1869 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
1870 oinfo
->external_sym
= iinfo
->external_sym
;
1872 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
1873 oinfo
->external_opt
= iinfo
->external_opt
;
1875 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
1876 oinfo
->external_aux
= iinfo
->external_aux
;
1878 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
1879 oinfo
->ss
= iinfo
->ss
;
1881 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
1882 oinfo
->external_fdr
= iinfo
->external_fdr
;
1884 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
1885 oinfo
->external_rfd
= iinfo
->external_rfd
;
1889 /* We are discarding all the local symbol information. Look
1890 through the external symbols and remove all references to FDR
1891 or aux information. */
1892 c
= bfd_get_symcount (obfd
);
1893 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1894 for (; c
> 0; c
--, sym_ptr_ptr
++)
1898 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
1899 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
1901 esym
.asym
.index
= indexNil
;
1902 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
1903 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
1910 /* Set the architecture. The supported architecture is stored in the
1911 backend pointer. We always set the architecture anyhow, since many
1912 callers ignore the return value. */
1915 _bfd_ecoff_set_arch_mach (bfd
*abfd
,
1916 enum bfd_architecture arch
,
1917 unsigned long machine
)
1919 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1920 return arch
== ecoff_backend (abfd
)->arch
;
1923 /* Get the size of the section headers. */
1926 _bfd_ecoff_sizeof_headers (bfd
*abfd
,
1927 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1934 for (current
= abfd
->sections
;
1936 current
= current
->next
)
1939 ret
= (bfd_coff_filhsz (abfd
)
1940 + bfd_coff_aoutsz (abfd
)
1941 + c
* bfd_coff_scnhsz (abfd
));
1942 return (int) BFD_ALIGN (ret
, 16);
1945 /* Get the contents of a section. */
1948 _bfd_ecoff_get_section_contents (bfd
*abfd
,
1952 bfd_size_type count
)
1954 return _bfd_generic_get_section_contents (abfd
, section
, location
,
1958 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
1959 called via qsort. */
1962 ecoff_sort_hdrs (const void * arg1
, const void * arg2
)
1964 const asection
*hdr1
= *(const asection
**) arg1
;
1965 const asection
*hdr2
= *(const asection
**) arg2
;
1967 if ((hdr1
->flags
& SEC_ALLOC
) != 0)
1969 if ((hdr2
->flags
& SEC_ALLOC
) == 0)
1974 if ((hdr2
->flags
& SEC_ALLOC
) != 0)
1977 if (hdr1
->vma
< hdr2
->vma
)
1979 else if (hdr1
->vma
> hdr2
->vma
)
1985 /* Calculate the file position for each section, and set
1989 ecoff_compute_section_file_positions (bfd
*abfd
)
1991 file_ptr sofar
, file_sofar
;
1992 asection
**sorted_hdrs
;
1996 bfd_boolean rdata_in_text
;
1997 bfd_boolean first_data
, first_nonalloc
;
1998 const bfd_vma round
= ecoff_backend (abfd
)->round
;
2001 sofar
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2004 /* Sort the sections by VMA. */
2005 amt
= abfd
->section_count
;
2006 amt
*= sizeof (asection
*);
2007 sorted_hdrs
= (asection
**) bfd_malloc (amt
);
2008 if (sorted_hdrs
== NULL
)
2010 for (current
= abfd
->sections
, i
= 0;
2012 current
= current
->next
, i
++)
2013 sorted_hdrs
[i
] = current
;
2014 BFD_ASSERT (i
== abfd
->section_count
);
2016 qsort (sorted_hdrs
, abfd
->section_count
, sizeof (asection
*),
2019 /* Some versions of the OSF linker put the .rdata section in the
2020 text segment, and some do not. */
2021 rdata_in_text
= ecoff_backend (abfd
)->rdata_in_text
;
2024 for (i
= 0; i
< abfd
->section_count
; i
++)
2026 current
= sorted_hdrs
[i
];
2027 if (streq (current
->name
, _RDATA
))
2029 if ((current
->flags
& SEC_CODE
) == 0
2030 && ! streq (current
->name
, _PDATA
)
2031 && ! streq (current
->name
, _RCONST
))
2033 rdata_in_text
= FALSE
;
2038 ecoff_data (abfd
)->rdata_in_text
= rdata_in_text
;
2041 first_nonalloc
= TRUE
;
2042 for (i
= 0; i
< abfd
->section_count
; i
++)
2044 unsigned int alignment_power
;
2046 current
= sorted_hdrs
[i
];
2048 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2049 supposed to indicate the number of .pdata entries that are
2050 really in the section. Each entry is 8 bytes. We store this
2051 away in line_filepos before increasing the section size. */
2052 if (streq (current
->name
, _PDATA
))
2053 current
->line_filepos
= current
->size
/ 8;
2055 alignment_power
= current
->alignment_power
;
2057 /* On Ultrix, the data sections in an executable file must be
2058 aligned to a page boundary within the file. This does not
2059 affect the section size, though. FIXME: Does this work for
2060 other platforms? It requires some modification for the
2061 Alpha, because .rdata on the Alpha goes with the text, not
2063 if ((abfd
->flags
& EXEC_P
) != 0
2064 && (abfd
->flags
& D_PAGED
) != 0
2066 && (current
->flags
& SEC_CODE
) == 0
2068 || ! streq (current
->name
, _RDATA
))
2069 && ! streq (current
->name
, _PDATA
)
2070 && ! streq (current
->name
, _RCONST
))
2072 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2073 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2076 else if (streq (current
->name
, _LIB
))
2078 /* On Irix 4, the location of contents of the .lib section
2079 from a shared library section is also rounded up to a
2082 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2083 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2085 else if (first_nonalloc
2086 && (current
->flags
& SEC_ALLOC
) == 0
2087 && (abfd
->flags
& D_PAGED
) != 0)
2089 /* Skip up to the next page for an unallocated section, such
2090 as the .comment section on the Alpha. This leaves room
2091 for the .bss section. */
2092 first_nonalloc
= FALSE
;
2093 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2094 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2097 /* Align the sections in the file to the same boundary on
2098 which they are aligned in virtual memory. */
2099 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2100 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2101 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2103 if ((abfd
->flags
& D_PAGED
) != 0
2104 && (current
->flags
& SEC_ALLOC
) != 0)
2106 sofar
+= (current
->vma
- sofar
) % round
;
2107 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2108 file_sofar
+= (current
->vma
- file_sofar
) % round
;
2111 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) != 0)
2112 current
->filepos
= file_sofar
;
2114 sofar
+= current
->size
;
2115 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2116 file_sofar
+= current
->size
;
2118 /* Make sure that this section is of the right size too. */
2120 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2121 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2122 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2123 current
->size
+= sofar
- old_sofar
;
2129 ecoff_data (abfd
)->reloc_filepos
= file_sofar
;
2134 /* Determine the location of the relocs for all the sections in the
2135 output file, as well as the location of the symbolic debugging
2138 static bfd_size_type
2139 ecoff_compute_reloc_file_positions (bfd
*abfd
)
2141 const bfd_size_type external_reloc_size
=
2142 ecoff_backend (abfd
)->external_reloc_size
;
2143 file_ptr reloc_base
;
2144 bfd_size_type reloc_size
;
2148 if (! abfd
->output_has_begun
)
2150 if (! ecoff_compute_section_file_positions (abfd
))
2152 abfd
->output_has_begun
= TRUE
;
2155 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2158 for (current
= abfd
->sections
;
2160 current
= current
->next
)
2162 if (current
->reloc_count
== 0)
2163 current
->rel_filepos
= 0;
2166 bfd_size_type relsize
;
2168 current
->rel_filepos
= reloc_base
;
2169 relsize
= current
->reloc_count
* external_reloc_size
;
2170 reloc_size
+= relsize
;
2171 reloc_base
+= relsize
;
2175 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2177 /* At least on Ultrix, the symbol table of an executable file must
2178 be aligned to a page boundary. FIXME: Is this true on other
2180 if ((abfd
->flags
& EXEC_P
) != 0
2181 && (abfd
->flags
& D_PAGED
) != 0)
2182 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2183 &~ (ecoff_backend (abfd
)->round
- 1));
2185 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2190 /* Set the contents of a section. */
2193 _bfd_ecoff_set_section_contents (bfd
*abfd
,
2195 const void * location
,
2197 bfd_size_type count
)
2201 /* This must be done first, because bfd_set_section_contents is
2202 going to set output_has_begun to TRUE. */
2203 if (! abfd
->output_has_begun
2204 && ! ecoff_compute_section_file_positions (abfd
))
2207 /* Handle the .lib section specially so that Irix 4 shared libraries
2208 work out. See coff_set_section_contents in coffcode.h. */
2209 if (streq (section
->name
, _LIB
))
2211 bfd_byte
*rec
, *recend
;
2213 rec
= (bfd_byte
*) location
;
2214 recend
= rec
+ count
;
2215 while (rec
< recend
)
2218 rec
+= bfd_get_32 (abfd
, rec
) * 4;
2221 BFD_ASSERT (rec
== recend
);
2227 pos
= section
->filepos
+ offset
;
2228 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2229 || bfd_bwrite (location
, count
, abfd
) != count
)
2235 /* Set the GP value for an ECOFF file. This is a hook used by the
2239 bfd_ecoff_set_gp_value (bfd
*abfd
, bfd_vma gp_value
)
2241 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2242 || bfd_get_format (abfd
) != bfd_object
)
2244 bfd_set_error (bfd_error_invalid_operation
);
2248 ecoff_data (abfd
)->gp
= gp_value
;
2253 /* Set the register masks for an ECOFF file. This is a hook used by
2257 bfd_ecoff_set_regmasks (bfd
*abfd
,
2258 unsigned long gprmask
,
2259 unsigned long fprmask
,
2260 unsigned long *cprmask
)
2262 ecoff_data_type
*tdata
;
2264 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2265 || bfd_get_format (abfd
) != bfd_object
)
2267 bfd_set_error (bfd_error_invalid_operation
);
2271 tdata
= ecoff_data (abfd
);
2272 tdata
->gprmask
= gprmask
;
2273 tdata
->fprmask
= fprmask
;
2274 if (cprmask
!= NULL
)
2278 for (i
= 0; i
< 3; i
++)
2279 tdata
->cprmask
[i
] = cprmask
[i
];
2285 /* Get ECOFF EXTR information for an external symbol. This function
2286 is passed to bfd_ecoff_debug_externals. */
2289 ecoff_get_extr (asymbol
*sym
, EXTR
*esym
)
2291 ecoff_symbol_type
*ecoff_sym_ptr
;
2294 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2295 || ecoffsymbol (sym
)->native
== NULL
)
2297 /* Don't include debugging, local, or section symbols. */
2298 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2299 || (sym
->flags
& BSF_LOCAL
) != 0
2300 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2304 esym
->cobol_main
= 0;
2305 esym
->weakext
= (sym
->flags
& BSF_WEAK
) != 0;
2308 /* FIXME: we can do better than this for st and sc. */
2309 esym
->asym
.st
= stGlobal
;
2310 esym
->asym
.sc
= scAbs
;
2311 esym
->asym
.reserved
= 0;
2312 esym
->asym
.index
= indexNil
;
2316 ecoff_sym_ptr
= ecoffsymbol (sym
);
2318 if (ecoff_sym_ptr
->local
)
2321 input_bfd
= bfd_asymbol_bfd (sym
);
2322 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2323 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2325 /* If the symbol was defined by the linker, then esym will be
2326 undefined but sym will not be. Get a better class for such a
2328 if ((esym
->asym
.sc
== scUndefined
2329 || esym
->asym
.sc
== scSUndefined
)
2330 && ! bfd_is_und_section (bfd_asymbol_section (sym
)))
2331 esym
->asym
.sc
= scAbs
;
2333 /* Adjust the FDR index for the symbol by that used for the input
2335 if (esym
->ifd
!= -1)
2337 struct ecoff_debug_info
*input_debug
;
2339 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2340 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2341 if (input_debug
->ifdmap
!= NULL
)
2342 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2348 /* Set the external symbol index. This routine is passed to
2349 bfd_ecoff_debug_externals. */
2352 ecoff_set_index (asymbol
*sym
, bfd_size_type indx
)
2354 ecoff_set_sym_index (sym
, indx
);
2357 /* Write out an ECOFF file. */
2360 _bfd_ecoff_write_object_contents (bfd
*abfd
)
2362 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2363 const bfd_vma round
= backend
->round
;
2364 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2365 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2366 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2367 const bfd_size_type external_hdr_size
2368 = backend
->debug_swap
.external_hdr_size
;
2369 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2370 void (* const adjust_reloc_out
) (bfd
*, const arelent
*, struct internal_reloc
*)
2371 = backend
->adjust_reloc_out
;
2372 void (* const swap_reloc_out
) (bfd
*, const struct internal_reloc
*, void *)
2373 = backend
->swap_reloc_out
;
2374 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2375 HDRR
* const symhdr
= &debug
->symbolic_header
;
2378 bfd_size_type reloc_size
;
2379 bfd_size_type text_size
;
2381 bfd_boolean set_text_start
;
2382 bfd_size_type data_size
;
2384 bfd_boolean set_data_start
;
2385 bfd_size_type bss_size
;
2387 void * reloc_buff
= NULL
;
2388 struct internal_filehdr internal_f
;
2389 struct internal_aouthdr internal_a
;
2392 /* Determine where the sections and relocs will go in the output
2394 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2397 for (current
= abfd
->sections
;
2399 current
= current
->next
)
2401 current
->target_index
= count
;
2405 if ((abfd
->flags
& D_PAGED
) != 0)
2406 text_size
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2410 set_text_start
= FALSE
;
2413 set_data_start
= FALSE
;
2416 /* Write section headers to the file. */
2418 /* Allocate buff big enough to hold a section header,
2419 file header, or a.out header. */
2428 buff
= bfd_malloc (siz
);
2433 internal_f
.f_nscns
= 0;
2434 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2437 for (current
= abfd
->sections
;
2439 current
= current
->next
)
2441 struct internal_scnhdr section
;
2444 ++internal_f
.f_nscns
;
2446 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2448 /* This seems to be correct for Irix 4 shared libraries. */
2449 vma
= bfd_section_vma (current
);
2450 if (streq (current
->name
, _LIB
))
2451 section
.s_vaddr
= 0;
2453 section
.s_vaddr
= vma
;
2455 section
.s_paddr
= current
->lma
;
2456 section
.s_size
= current
->size
;
2458 /* If this section is unloadable then the scnptr will be 0. */
2459 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2460 section
.s_scnptr
= 0;
2462 section
.s_scnptr
= current
->filepos
;
2463 section
.s_relptr
= current
->rel_filepos
;
2465 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2466 object file produced by the assembler is supposed to point to
2467 information about how much room is required by objects of
2468 various different sizes. I think this only matters if we
2469 want the linker to compute the best size to use, or
2470 something. I don't know what happens if the information is
2472 if (! streq (current
->name
, _PDATA
))
2473 section
.s_lnnoptr
= 0;
2476 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2477 hold the number of entries in the section (each entry is
2478 8 bytes). We stored this in the line_filepos field in
2479 ecoff_compute_section_file_positions. */
2480 section
.s_lnnoptr
= current
->line_filepos
;
2483 section
.s_nreloc
= current
->reloc_count
;
2484 section
.s_nlnno
= 0;
2485 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2488 if (bfd_coff_swap_scnhdr_out (abfd
, (void *) §ion
, buff
) == 0
2489 || bfd_bwrite (buff
, scnhsz
, abfd
) != scnhsz
)
2492 if ((section
.s_flags
& STYP_TEXT
) != 0
2493 || ((section
.s_flags
& STYP_RDATA
) != 0
2494 && ecoff_data (abfd
)->rdata_in_text
)
2495 || section
.s_flags
== STYP_PDATA
2496 || (section
.s_flags
& STYP_DYNAMIC
) != 0
2497 || (section
.s_flags
& STYP_LIBLIST
) != 0
2498 || (section
.s_flags
& STYP_RELDYN
) != 0
2499 || section
.s_flags
== STYP_CONFLIC
2500 || (section
.s_flags
& STYP_DYNSTR
) != 0
2501 || (section
.s_flags
& STYP_DYNSYM
) != 0
2502 || (section
.s_flags
& STYP_HASH
) != 0
2503 || (section
.s_flags
& STYP_ECOFF_INIT
) != 0
2504 || (section
.s_flags
& STYP_ECOFF_FINI
) != 0
2505 || section
.s_flags
== STYP_RCONST
)
2507 text_size
+= current
->size
;
2508 if (! set_text_start
|| text_start
> vma
)
2511 set_text_start
= TRUE
;
2514 else if ((section
.s_flags
& STYP_RDATA
) != 0
2515 || (section
.s_flags
& STYP_DATA
) != 0
2516 || (section
.s_flags
& STYP_LITA
) != 0
2517 || (section
.s_flags
& STYP_LIT8
) != 0
2518 || (section
.s_flags
& STYP_LIT4
) != 0
2519 || (section
.s_flags
& STYP_SDATA
) != 0
2520 || section
.s_flags
== STYP_XDATA
2521 || (section
.s_flags
& STYP_GOT
) != 0)
2523 data_size
+= current
->size
;
2524 if (! set_data_start
|| data_start
> vma
)
2527 set_data_start
= TRUE
;
2530 else if ((section
.s_flags
& STYP_BSS
) != 0
2531 || (section
.s_flags
& STYP_SBSS
) != 0)
2532 bss_size
+= current
->size
;
2533 else if (section
.s_flags
== 0
2534 || (section
.s_flags
& STYP_ECOFF_LIB
) != 0
2535 || section
.s_flags
== STYP_COMMENT
)
2541 /* Set up the file header. */
2542 internal_f
.f_magic
= ecoff_get_magic (abfd
);
2544 /* We will NOT put a fucking timestamp in the header here. Every
2545 time you put it back, I will come in and take it out again. I'm
2546 sorry. This field does not belong here. We fill it with a 0 so
2547 it compares the same but is not a reasonable time. --
2549 internal_f
.f_timdat
= 0;
2551 if (bfd_get_symcount (abfd
) != 0)
2553 /* The ECOFF f_nsyms field is not actually the number of
2554 symbols, it's the size of symbolic information header. */
2555 internal_f
.f_nsyms
= external_hdr_size
;
2556 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
2560 internal_f
.f_nsyms
= 0;
2561 internal_f
.f_symptr
= 0;
2564 internal_f
.f_opthdr
= aoutsz
;
2566 internal_f
.f_flags
= F_LNNO
;
2567 if (reloc_size
== 0)
2568 internal_f
.f_flags
|= F_RELFLG
;
2569 if (bfd_get_symcount (abfd
) == 0)
2570 internal_f
.f_flags
|= F_LSYMS
;
2571 if (abfd
->flags
& EXEC_P
)
2572 internal_f
.f_flags
|= F_EXEC
;
2574 if (bfd_little_endian (abfd
))
2575 internal_f
.f_flags
|= F_AR32WR
;
2577 internal_f
.f_flags
|= F_AR32W
;
2579 /* Set up the ``optional'' header. */
2580 if ((abfd
->flags
& D_PAGED
) != 0)
2581 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
2583 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
2585 /* FIXME: Is this really correct? */
2586 internal_a
.vstamp
= symhdr
->vstamp
;
2588 /* At least on Ultrix, these have to be rounded to page boundaries.
2589 FIXME: Is this true on other platforms? */
2590 if ((abfd
->flags
& D_PAGED
) != 0)
2592 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
2593 internal_a
.text_start
= text_start
&~ (round
- 1);
2594 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
2595 internal_a
.data_start
= data_start
&~ (round
- 1);
2599 internal_a
.tsize
= text_size
;
2600 internal_a
.text_start
= text_start
;
2601 internal_a
.dsize
= data_size
;
2602 internal_a
.data_start
= data_start
;
2605 /* On Ultrix, the initial portions of the .sbss and .bss segments
2606 are at the end of the data section. The bsize field in the
2607 optional header records how many bss bytes are required beyond
2608 those in the data section. The value is not rounded to a page
2610 if (bss_size
< internal_a
.dsize
- data_size
)
2613 bss_size
-= internal_a
.dsize
- data_size
;
2614 internal_a
.bsize
= bss_size
;
2615 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
2617 internal_a
.entry
= bfd_get_start_address (abfd
);
2619 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
2621 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
2622 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
2623 for (i
= 0; i
< 4; i
++)
2624 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
2626 /* Let the backend adjust the headers if necessary. */
2627 if (backend
->adjust_headers
)
2629 if (! (*backend
->adjust_headers
) (abfd
, &internal_f
, &internal_a
))
2633 /* Write out the file header and the optional header. */
2634 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2637 bfd_coff_swap_filehdr_out (abfd
, (void *) &internal_f
, buff
);
2638 if (bfd_bwrite (buff
, filhsz
, abfd
) != filhsz
)
2641 bfd_coff_swap_aouthdr_out (abfd
, (void *) &internal_a
, buff
);
2642 if (bfd_bwrite (buff
, aoutsz
, abfd
) != aoutsz
)
2645 /* Build the external symbol information. This must be done before
2646 writing out the relocs so that we know the symbol indices. We
2647 don't do this if this BFD was created by the backend linker,
2648 since it will have already handled the symbols and relocs. */
2649 if (! ecoff_data (abfd
)->linker
)
2651 symhdr
->iextMax
= 0;
2652 symhdr
->issExtMax
= 0;
2653 debug
->external_ext
= debug
->external_ext_end
= NULL
;
2654 debug
->ssext
= debug
->ssext_end
= NULL
;
2655 if (! bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
2656 (abfd
->flags
& EXEC_P
) == 0,
2657 ecoff_get_extr
, ecoff_set_index
))
2660 /* Write out the relocs. */
2661 for (current
= abfd
->sections
;
2663 current
= current
->next
)
2665 arelent
**reloc_ptr_ptr
;
2666 arelent
**reloc_end
;
2670 if (current
->reloc_count
== 0)
2673 amt
= current
->reloc_count
* external_reloc_size
;
2674 reloc_buff
= bfd_alloc (abfd
, amt
);
2675 if (reloc_buff
== NULL
)
2678 reloc_ptr_ptr
= current
->orelocation
;
2679 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
2680 out_ptr
= (char *) reloc_buff
;
2683 reloc_ptr_ptr
< reloc_end
;
2684 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
2688 struct internal_reloc in
;
2690 memset ((void *) &in
, 0, sizeof in
);
2692 reloc
= *reloc_ptr_ptr
;
2693 sym
= *reloc
->sym_ptr_ptr
;
2695 /* If the howto field has not been initialised then skip this reloc.
2696 This assumes that an error message has been issued elsewhere. */
2697 if (reloc
->howto
== NULL
)
2700 in
.r_vaddr
= reloc
->address
+ bfd_section_vma (current
);
2701 in
.r_type
= reloc
->howto
->type
;
2703 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2705 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2719 { _TEXT
, RELOC_SECTION_TEXT
},
2720 { _RDATA
, RELOC_SECTION_RDATA
},
2721 { _DATA
, RELOC_SECTION_DATA
},
2722 { _SDATA
, RELOC_SECTION_SDATA
},
2723 { _SBSS
, RELOC_SECTION_SBSS
},
2724 { _BSS
, RELOC_SECTION_BSS
},
2725 { _INIT
, RELOC_SECTION_INIT
},
2726 { _LIT8
, RELOC_SECTION_LIT8
},
2727 { _LIT4
, RELOC_SECTION_LIT4
},
2728 { _XDATA
, RELOC_SECTION_XDATA
},
2729 { _PDATA
, RELOC_SECTION_PDATA
},
2730 { _FINI
, RELOC_SECTION_FINI
},
2731 { _LITA
, RELOC_SECTION_LITA
},
2732 { "*ABS*", RELOC_SECTION_ABS
},
2733 { _RCONST
, RELOC_SECTION_RCONST
}
2736 name
= bfd_section_name (bfd_asymbol_section (sym
));
2738 for (j
= 0; j
< ARRAY_SIZE (section_symndx
); j
++)
2739 if (streq (name
, section_symndx
[j
].name
))
2741 in
.r_symndx
= section_symndx
[j
].r_symndx
;
2745 if (j
== ARRAY_SIZE (section_symndx
))
2750 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2752 (*swap_reloc_out
) (abfd
, &in
, (void *) out_ptr
);
2755 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2757 amt
= current
->reloc_count
* external_reloc_size
;
2758 if (bfd_bwrite (reloc_buff
, amt
, abfd
) != amt
)
2760 bfd_release (abfd
, reloc_buff
);
2764 /* Write out the symbolic debugging information. */
2765 if (bfd_get_symcount (abfd
) > 0)
2767 /* Write out the debugging information. */
2768 if (! bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2769 ecoff_data (abfd
)->sym_filepos
))
2774 /* The .bss section of a demand paged executable must receive an
2775 entire page. If there are symbols, the symbols will start on the
2776 next page. If there are no symbols, we must fill out the page by
2778 if (bfd_get_symcount (abfd
) == 0
2779 && (abfd
->flags
& EXEC_P
) != 0
2780 && (abfd
->flags
& D_PAGED
) != 0)
2784 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2787 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) == 0)
2789 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2792 if (bfd_bwrite (&c
, (bfd_size_type
) 1, abfd
) != 1)
2796 if (reloc_buff
!= NULL
)
2797 bfd_release (abfd
, reloc_buff
);
2802 if (reloc_buff
!= NULL
)
2803 bfd_release (abfd
, reloc_buff
);
2809 /* Archive handling. ECOFF uses what appears to be a unique type of
2810 archive header (armap). The byte ordering of the armap and the
2811 contents are encoded in the name of the armap itself. At least for
2812 now, we only support archives with the same byte ordering in the
2813 armap and the contents.
2815 The first four bytes in the armap are the number of symbol
2816 definitions. This is always a power of two.
2818 This is followed by the symbol definitions. Each symbol definition
2819 occupies 8 bytes. The first four bytes are the offset from the
2820 start of the armap strings to the null-terminated string naming
2821 this symbol. The second four bytes are the file offset to the
2822 archive member which defines this symbol. If the second four bytes
2823 are 0, then this is not actually a symbol definition, and it should
2826 The symbols are hashed into the armap with a closed hashing scheme.
2827 See the functions below for the details of the algorithm.
2829 After the symbol definitions comes four bytes holding the size of
2830 the string table, followed by the string table itself. */
2832 /* The name of an archive headers looks like this:
2833 __________E[BL]E[BL]_ (with a trailing space).
2834 The trailing space is changed to an X if the archive is changed to
2835 indicate that the armap is out of date.
2837 The Alpha seems to use ________64E[BL]E[BL]_. */
2839 #define ARMAP_BIG_ENDIAN 'B'
2840 #define ARMAP_LITTLE_ENDIAN 'L'
2841 #define ARMAP_MARKER 'E'
2842 #define ARMAP_START_LENGTH 10
2843 #define ARMAP_HEADER_MARKER_INDEX 10
2844 #define ARMAP_HEADER_ENDIAN_INDEX 11
2845 #define ARMAP_OBJECT_MARKER_INDEX 12
2846 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2847 #define ARMAP_END_INDEX 14
2848 #define ARMAP_END "_ "
2850 /* This is a magic number used in the hashing algorithm. */
2851 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2853 /* This returns the hash value to use for a string. It also sets
2854 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2855 is the number of entries in the hash table, and HLOG is the log
2859 ecoff_armap_hash (const char *s
,
2860 unsigned int *rehash
,
2870 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2871 hash
*= ARMAP_HASH_MAGIC
;
2872 *rehash
= (hash
& (size
- 1)) | 1;
2873 return hash
>> (32 - hlog
);
2876 /* Read in the armap. */
2879 _bfd_ecoff_slurp_armap (bfd
*abfd
)
2883 struct areltdata
*mapdata
;
2884 bfd_size_type parsed_size
;
2886 struct artdata
*ardata
;
2893 /* Get the name of the first element. */
2894 i
= bfd_bread ((void *) nextname
, (bfd_size_type
) 16, abfd
);
2900 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2903 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2904 standard COFF armap. We could move the ECOFF armap stuff into
2905 bfd_slurp_armap, but that seems inappropriate since no other
2906 target uses this format. Instead, we check directly for a COFF
2908 if (CONST_STRNEQ (nextname
, "/ "))
2909 return bfd_slurp_armap (abfd
);
2911 /* See if the first element is an armap. */
2912 if (! strneq (nextname
, ecoff_backend (abfd
)->armap_start
, ARMAP_START_LENGTH
)
2913 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
2914 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2915 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2916 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
2917 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2918 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2919 || ! strneq (nextname
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1))
2921 abfd
->has_armap
= FALSE
;
2925 /* Make sure we have the right byte ordering. */
2926 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2927 ^ (bfd_header_big_endian (abfd
)))
2928 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2929 ^ (bfd_big_endian (abfd
))))
2931 bfd_set_error (bfd_error_wrong_format
);
2935 /* Read in the armap. */
2936 ardata
= bfd_ardata (abfd
);
2937 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
2938 if (mapdata
== NULL
)
2940 parsed_size
= mapdata
->parsed_size
;
2943 raw_armap
= (char *) bfd_alloc (abfd
, parsed_size
);
2944 if (raw_armap
== NULL
)
2947 if (bfd_bread ((void *) raw_armap
, parsed_size
, abfd
) != parsed_size
)
2949 if (bfd_get_error () != bfd_error_system_call
)
2950 bfd_set_error (bfd_error_malformed_archive
);
2951 bfd_release (abfd
, (void *) raw_armap
);
2955 ardata
->tdata
= (void *) raw_armap
;
2957 count
= H_GET_32 (abfd
, raw_armap
);
2959 ardata
->symdef_count
= 0;
2960 ardata
->cache
= NULL
;
2962 /* This code used to overlay the symdefs over the raw archive data,
2963 but that doesn't work on a 64 bit host. */
2964 stringbase
= raw_armap
+ count
* 8 + 8;
2966 #ifdef CHECK_ARMAP_HASH
2970 /* Double check that I have the hashing algorithm right by making
2971 sure that every symbol can be looked up successfully. */
2973 for (i
= 1; i
< count
; i
<<= 1)
2975 BFD_ASSERT (i
== count
);
2977 raw_ptr
= raw_armap
+ 4;
2978 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2980 unsigned int name_offset
, file_offset
;
2981 unsigned int hash
, rehash
, srch
;
2983 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2984 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2985 if (file_offset
== 0)
2987 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
2992 /* See if we can rehash to this location. */
2993 for (srch
= (hash
+ rehash
) & (count
- 1);
2994 srch
!= hash
&& srch
!= i
;
2995 srch
= (srch
+ rehash
) & (count
- 1))
2996 BFD_ASSERT (H_GET_32 (abfd
, (raw_armap
+ 8 + srch
* 8)) != 0);
2997 BFD_ASSERT (srch
== i
);
3001 #endif /* CHECK_ARMAP_HASH */
3003 raw_ptr
= raw_armap
+ 4;
3004 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3005 if (H_GET_32 (abfd
, (raw_ptr
+ 4)) != 0)
3006 ++ardata
->symdef_count
;
3008 amt
= ardata
->symdef_count
;
3009 amt
*= sizeof (carsym
);
3010 symdef_ptr
= (carsym
*) bfd_alloc (abfd
, amt
);
3014 ardata
->symdefs
= symdef_ptr
;
3016 raw_ptr
= raw_armap
+ 4;
3017 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3019 unsigned int name_offset
, file_offset
;
3021 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
3022 if (file_offset
== 0)
3024 name_offset
= H_GET_32 (abfd
, raw_ptr
);
3025 symdef_ptr
->name
= stringbase
+ name_offset
;
3026 symdef_ptr
->file_offset
= file_offset
;
3030 ardata
->first_file_filepos
= bfd_tell (abfd
);
3031 /* Pad to an even boundary. */
3032 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
3034 abfd
->has_armap
= TRUE
;
3039 /* Write out an armap. */
3042 _bfd_ecoff_write_armap (bfd
*abfd
,
3043 unsigned int elength
,
3045 unsigned int orl_count
,
3048 unsigned int hashsize
, hashlog
;
3049 bfd_size_type symdefsize
;
3051 unsigned int stringsize
;
3052 unsigned int mapsize
;
3055 struct stat statbuf
;
3058 bfd_byte
*hashtable
;
3062 /* Ultrix appears to use as a hash table size the least power of two
3063 greater than twice the number of entries. */
3064 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3066 hashsize
= 1 << hashlog
;
3068 symdefsize
= hashsize
* 8;
3070 stringsize
= stridx
+ padit
;
3072 /* Include 8 bytes to store symdefsize and stringsize in output. */
3073 mapsize
= symdefsize
+ stringsize
+ 8;
3075 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3077 memset ((void *) &hdr
, 0, sizeof hdr
);
3079 /* Work out the ECOFF armap name. */
3080 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3081 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3082 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3083 (bfd_header_big_endian (abfd
)
3085 : ARMAP_LITTLE_ENDIAN
);
3086 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3087 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3088 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3089 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3091 /* Write the timestamp of the archive header to be just a little bit
3092 later than the timestamp of the file, otherwise the linker will
3093 complain that the index is out of date. Actually, the Ultrix
3094 linker just checks the archive name; the GNU linker may check the
3096 stat (abfd
->filename
, &statbuf
);
3097 _bfd_ar_spacepad (hdr
.ar_date
, sizeof (hdr
.ar_date
), "%ld",
3098 (long) (statbuf
.st_mtime
+ 60));
3100 /* The DECstation uses zeroes for the uid, gid and mode of the
3102 hdr
.ar_uid
[0] = '0';
3103 hdr
.ar_gid
[0] = '0';
3104 /* Building gcc ends up extracting the armap as a file - twice. */
3105 hdr
.ar_mode
[0] = '6';
3106 hdr
.ar_mode
[1] = '4';
3107 hdr
.ar_mode
[2] = '4';
3109 _bfd_ar_spacepad (hdr
.ar_size
, sizeof (hdr
.ar_size
), "%-10ld", mapsize
);
3111 hdr
.ar_fmag
[0] = '`';
3112 hdr
.ar_fmag
[1] = '\012';
3114 /* Turn all null bytes in the header into spaces. */
3115 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3116 if (((char *) (&hdr
))[i
] == '\0')
3117 (((char *) (&hdr
))[i
]) = ' ';
3119 if (bfd_bwrite ((void *) &hdr
, (bfd_size_type
) sizeof (struct ar_hdr
), abfd
)
3120 != sizeof (struct ar_hdr
))
3123 H_PUT_32 (abfd
, hashsize
, temp
);
3124 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3127 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3131 current
= abfd
->archive_head
;
3133 for (i
= 0; i
< orl_count
; i
++)
3135 unsigned int hash
, rehash
= 0;
3137 /* Advance firstreal to the file position of this archive
3139 if (map
[i
].u
.abfd
!= last_elt
)
3143 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3144 firstreal
+= firstreal
% 2;
3145 current
= current
->archive_next
;
3147 while (current
!= map
[i
].u
.abfd
);
3152 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3153 if (H_GET_32 (abfd
, (hashtable
+ (hash
* 8) + 4)) != 0)
3157 /* The desired slot is already taken. */
3158 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3160 srch
= (srch
+ rehash
) & (hashsize
- 1))
3161 if (H_GET_32 (abfd
, (hashtable
+ (srch
* 8) + 4)) == 0)
3164 BFD_ASSERT (srch
!= hash
);
3169 H_PUT_32 (abfd
, map
[i
].namidx
, (hashtable
+ hash
* 8));
3170 H_PUT_32 (abfd
, firstreal
, (hashtable
+ hash
* 8 + 4));
3173 if (bfd_bwrite ((void *) hashtable
, symdefsize
, abfd
) != symdefsize
)
3176 bfd_release (abfd
, hashtable
);
3178 /* Now write the strings. */
3179 H_PUT_32 (abfd
, stringsize
, temp
);
3180 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3182 for (i
= 0; i
< orl_count
; i
++)
3186 len
= strlen (*map
[i
].name
) + 1;
3187 if (bfd_bwrite ((void *) (*map
[i
].name
), len
, abfd
) != len
)
3191 /* The spec sez this should be a newline. But in order to be
3192 bug-compatible for DECstation ar we use a null. */
3195 if (bfd_bwrite ("", (bfd_size_type
) 1, abfd
) != 1)
3202 /* ECOFF linker code. */
3204 /* Routine to create an entry in an ECOFF link hash table. */
3206 static struct bfd_hash_entry
*
3207 ecoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
3208 struct bfd_hash_table
*table
,
3211 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3213 /* Allocate the structure if it has not already been allocated by a
3216 ret
= ((struct ecoff_link_hash_entry
*)
3217 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3221 /* Call the allocation method of the superclass. */
3222 ret
= ((struct ecoff_link_hash_entry
*)
3223 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3228 /* Set local fields. */
3234 memset ((void *) &ret
->esym
, 0, sizeof ret
->esym
);
3236 return (struct bfd_hash_entry
*) ret
;
3239 /* Create an ECOFF link hash table. */
3241 struct bfd_link_hash_table
*
3242 _bfd_ecoff_bfd_link_hash_table_create (bfd
*abfd
)
3244 struct ecoff_link_hash_table
*ret
;
3245 size_t amt
= sizeof (struct ecoff_link_hash_table
);
3247 ret
= (struct ecoff_link_hash_table
*) bfd_malloc (amt
);
3250 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
,
3251 ecoff_link_hash_newfunc
,
3252 sizeof (struct ecoff_link_hash_entry
)))
3260 /* Look up an entry in an ECOFF link hash table. */
3262 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3263 ((struct ecoff_link_hash_entry *) \
3264 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3266 /* Get the ECOFF link hash table from the info structure. This is
3269 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3271 /* Add the external symbols of an object file to the global linker
3272 hash table. The external symbols and strings we are passed are
3273 just allocated on the stack, and will be discarded. We must
3274 explicitly save any information we may need later on in the link.
3275 We do not want to read the external symbol information again. */
3278 ecoff_link_add_externals (bfd
*abfd
,
3279 struct bfd_link_info
*info
,
3280 void * external_ext
,
3283 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3284 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3285 = backend
->debug_swap
.swap_ext_in
;
3286 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3287 unsigned long ext_count
;
3288 struct bfd_link_hash_entry
**sym_hash
;
3293 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3296 amt
*= sizeof (struct bfd_link_hash_entry
*);
3297 sym_hash
= (struct bfd_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3300 ecoff_data (abfd
)->sym_hashes
= (struct ecoff_link_hash_entry
**) sym_hash
;
3302 ext_ptr
= (char *) external_ext
;
3303 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3304 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3311 struct ecoff_link_hash_entry
*h
;
3315 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3317 /* Skip debugging symbols. */
3319 switch (esym
.asym
.st
)
3335 /* Get the information for this symbol. */
3336 value
= esym
.asym
.value
;
3337 switch (esym
.asym
.sc
)
3357 section
= bfd_make_section_old_way (abfd
, _TEXT
);
3358 value
-= section
->vma
;
3361 section
= bfd_make_section_old_way (abfd
, _DATA
);
3362 value
-= section
->vma
;
3365 section
= bfd_make_section_old_way (abfd
, _BSS
);
3366 value
-= section
->vma
;
3369 section
= bfd_abs_section_ptr
;
3372 section
= bfd_und_section_ptr
;
3375 section
= bfd_make_section_old_way (abfd
, _SDATA
);
3376 value
-= section
->vma
;
3379 section
= bfd_make_section_old_way (abfd
, _SBSS
);
3380 value
-= section
->vma
;
3383 section
= bfd_make_section_old_way (abfd
, _RDATA
);
3384 value
-= section
->vma
;
3387 if (value
> ecoff_data (abfd
)->gp_size
)
3389 section
= bfd_com_section_ptr
;
3394 if (ecoff_scom_section
.name
== NULL
)
3396 /* Initialize the small common section. */
3397 ecoff_scom_section
.name
= SCOMMON
;
3398 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
3399 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
3400 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
3401 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
3402 ecoff_scom_symbol
.name
= SCOMMON
;
3403 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
3404 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
3405 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
3407 section
= &ecoff_scom_section
;
3410 section
= bfd_und_section_ptr
;
3413 section
= bfd_make_section_old_way (abfd
, _INIT
);
3414 value
-= section
->vma
;
3417 section
= bfd_make_section_old_way (abfd
, _FINI
);
3418 value
-= section
->vma
;
3421 section
= bfd_make_section_old_way (abfd
, _RCONST
);
3422 value
-= section
->vma
;
3426 if (section
== NULL
)
3429 name
= ssext
+ esym
.asym
.iss
;
3431 if (! (_bfd_generic_link_add_one_symbol
3433 (flagword
) (esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
),
3434 section
, value
, NULL
, TRUE
, TRUE
, sym_hash
)))
3437 h
= (struct ecoff_link_hash_entry
*) *sym_hash
;
3439 /* If we are building an ECOFF hash table, save the external
3440 symbol information. */
3441 if (bfd_get_flavour (info
->output_bfd
) == bfd_get_flavour (abfd
))
3444 || (! bfd_is_und_section (section
)
3445 && (! bfd_is_com_section (section
)
3446 || (h
->root
.type
!= bfd_link_hash_defined
3447 && h
->root
.type
!= bfd_link_hash_defweak
))))
3453 /* Remember whether this symbol was small undefined. */
3454 if (esym
.asym
.sc
== scSUndefined
)
3457 /* If this symbol was ever small undefined, it needs to wind
3458 up in a GP relative section. We can't control the
3459 section of a defined symbol, but we can control the
3460 section of a common symbol. This case is actually needed
3461 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3463 && h
->root
.type
== bfd_link_hash_common
3464 && streq (h
->root
.u
.c
.p
->section
->name
, SCOMMON
))
3466 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
3468 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
3469 if (h
->esym
.asym
.sc
== scCommon
)
3470 h
->esym
.asym
.sc
= scSCommon
;
3478 /* Add symbols from an ECOFF object file to the global linker hash
3482 ecoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3485 bfd_size_type external_ext_size
;
3486 void * external_ext
= NULL
;
3487 bfd_size_type esize
;
3491 if (! ecoff_slurp_symbolic_header (abfd
))
3494 /* If there are no symbols, we don't want it. */
3495 if (bfd_get_symcount (abfd
) == 0)
3498 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3500 /* Read in the external symbols and external strings. */
3501 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3502 esize
= symhdr
->iextMax
* external_ext_size
;
3503 external_ext
= bfd_malloc (esize
);
3504 if (external_ext
== NULL
&& esize
!= 0)
3507 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbExtOffset
, SEEK_SET
) != 0
3508 || bfd_bread (external_ext
, esize
, abfd
) != esize
)
3511 ssext
= (char *) bfd_malloc ((bfd_size_type
) symhdr
->issExtMax
);
3512 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3515 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
3516 || (bfd_bread (ssext
, (bfd_size_type
) symhdr
->issExtMax
, abfd
)
3517 != (bfd_size_type
) symhdr
->issExtMax
))
3520 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3524 if (external_ext
!= NULL
)
3525 free (external_ext
);
3531 if (external_ext
!= NULL
)
3532 free (external_ext
);
3536 /* This is called if we used _bfd_generic_link_add_archive_symbols
3537 because we were not dealing with an ECOFF archive. */
3540 ecoff_link_check_archive_element (bfd
*abfd
,
3541 struct bfd_link_info
*info
,
3542 struct bfd_link_hash_entry
*h
,
3544 bfd_boolean
*pneeded
)
3548 /* Unlike the generic linker, we do not pull in elements because
3549 of common symbols. */
3550 if (h
->type
!= bfd_link_hash_undefined
)
3553 /* Include this element? */
3554 if (!(*info
->callbacks
->add_archive_element
) (info
, abfd
, name
, &abfd
))
3558 return ecoff_link_add_object_symbols (abfd
, info
);
3561 /* Add the symbols from an archive file to the global hash table.
3562 This looks through the undefined symbols, looks each one up in the
3563 archive hash table, and adds any associated object file. We do not
3564 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3565 already have a hash table, so there is no reason to construct
3569 ecoff_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3571 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3572 const bfd_byte
*raw_armap
;
3573 struct bfd_link_hash_entry
**pundef
;
3574 unsigned int armap_count
;
3575 unsigned int armap_log
;
3577 const bfd_byte
*hashtable
;
3578 const char *stringbase
;
3580 if (! bfd_has_map (abfd
))
3582 /* An empty archive is a special case. */
3583 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
3585 bfd_set_error (bfd_error_no_armap
);
3589 /* If we don't have any raw data for this archive, as can happen on
3590 Irix 4.0.5F, we call the generic routine.
3591 FIXME: We should be more clever about this, since someday tdata
3592 may get to something for a generic archive. */
3593 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3594 if (raw_armap
== NULL
)
3595 return (_bfd_generic_link_add_archive_symbols
3596 (abfd
, info
, ecoff_link_check_archive_element
));
3598 armap_count
= H_GET_32 (abfd
, raw_armap
);
3601 for (i
= 1; i
< armap_count
; i
<<= 1)
3603 BFD_ASSERT (i
== armap_count
);
3605 hashtable
= raw_armap
+ 4;
3606 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3608 /* Look through the list of undefined symbols. */
3609 pundef
= &info
->hash
->undefs
;
3610 while (*pundef
!= NULL
)
3612 struct bfd_link_hash_entry
*h
;
3613 unsigned int hash
, rehash
= 0;
3614 unsigned int file_offset
;
3620 /* When a symbol is defined, it is not necessarily removed from
3622 if (h
->type
!= bfd_link_hash_undefined
3623 && h
->type
!= bfd_link_hash_common
)
3625 /* Remove this entry from the list, for general cleanliness
3626 and because we are going to look through the list again
3627 if we search any more libraries. We can't remove the
3628 entry if it is the tail, because that would lose any
3629 entries we add to the list later on. */
3630 if (*pundef
!= info
->hash
->undefs_tail
)
3631 *pundef
= (*pundef
)->u
.undef
.next
;
3633 pundef
= &(*pundef
)->u
.undef
.next
;
3637 /* Native ECOFF linkers do not pull in archive elements merely
3638 to satisfy common definitions, so neither do we. We leave
3639 them on the list, though, in case we are linking against some
3640 other object format. */
3641 if (h
->type
!= bfd_link_hash_undefined
)
3643 pundef
= &(*pundef
)->u
.undef
.next
;
3647 /* Look for this symbol in the archive hash table. */
3648 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3651 file_offset
= H_GET_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3652 if (file_offset
== 0)
3654 /* Nothing in this slot. */
3655 pundef
= &(*pundef
)->u
.undef
.next
;
3659 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (hash
* 8));
3660 if (name
[0] != h
->root
.string
[0]
3661 || ! streq (name
, h
->root
.string
))
3666 /* That was the wrong symbol. Try rehashing. */
3668 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3670 srch
= (srch
+ rehash
) & (armap_count
- 1))
3672 file_offset
= H_GET_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3673 if (file_offset
== 0)
3675 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (srch
* 8));
3676 if (name
[0] == h
->root
.string
[0]
3677 && streq (name
, h
->root
.string
))
3686 pundef
= &(*pundef
)->u
.undef
.next
;
3693 element
= (*backend
->get_elt_at_filepos
) (abfd
, (file_ptr
) file_offset
);
3694 if (element
== NULL
)
3697 if (! bfd_check_format (element
, bfd_object
))
3700 /* Unlike the generic linker, we know that this element provides
3701 a definition for an undefined symbol and we know that we want
3702 to include it. We don't need to check anything. */
3703 if (!(*info
->callbacks
3704 ->add_archive_element
) (info
, element
, name
, &element
))
3706 if (! ecoff_link_add_object_symbols (element
, info
))
3709 pundef
= &(*pundef
)->u
.undef
.next
;
3715 /* Given an ECOFF BFD, add symbols to the global hash table as
3719 _bfd_ecoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3721 switch (bfd_get_format (abfd
))
3724 return ecoff_link_add_object_symbols (abfd
, info
);
3726 return ecoff_link_add_archive_symbols (abfd
, info
);
3728 bfd_set_error (bfd_error_wrong_format
);
3734 /* ECOFF final link routines. */
3736 /* Structure used to pass information to ecoff_link_write_external. */
3741 struct bfd_link_info
*info
;
3744 /* Accumulate the debugging information for an input BFD into the
3745 output BFD. This must read in the symbolic information of the
3749 ecoff_final_link_debug_accumulate (bfd
*output_bfd
,
3751 struct bfd_link_info
*info
,
3754 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
3755 const struct ecoff_debug_swap
* const swap
=
3756 &ecoff_backend (input_bfd
)->debug_swap
;
3757 HDRR
*symhdr
= &debug
->symbolic_header
;
3760 #define READ(ptr, offset, count, size, type) \
3764 debug->ptr = NULL; \
3765 if (symhdr->count == 0) \
3767 if (_bfd_mul_overflow (size, symhdr->count, &amt)) \
3769 bfd_set_error (bfd_error_file_too_big); \
3771 goto return_something; \
3773 debug->ptr = (type) bfd_malloc (amt); \
3774 if (debug->ptr == NULL) \
3777 goto return_something; \
3779 if (bfd_seek (input_bfd, symhdr->offset, SEEK_SET) != 0 \
3780 || bfd_bread (debug->ptr, amt, input_bfd) != amt) \
3783 goto return_something; \
3787 /* If raw_syments is not NULL, then the data was already by read by
3788 _bfd_ecoff_slurp_symbolic_info. */
3789 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3791 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
3793 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
3794 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
3795 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
3796 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
3797 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3799 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3800 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
3801 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
3805 /* We do not read the external strings or the external symbols. */
3807 ret
= (bfd_ecoff_debug_accumulate
3808 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
3809 &ecoff_backend (output_bfd
)->debug_swap
,
3810 input_bfd
, debug
, swap
, info
));
3813 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3815 if (debug
->line
!= NULL
)
3817 if (debug
->external_dnr
!= NULL
)
3818 free (debug
->external_dnr
);
3819 if (debug
->external_pdr
!= NULL
)
3820 free (debug
->external_pdr
);
3821 if (debug
->external_sym
!= NULL
)
3822 free (debug
->external_sym
);
3823 if (debug
->external_opt
!= NULL
)
3824 free (debug
->external_opt
);
3825 if (debug
->external_aux
!= NULL
)
3826 free (debug
->external_aux
);
3827 if (debug
->ss
!= NULL
)
3829 if (debug
->external_fdr
!= NULL
)
3830 free (debug
->external_fdr
);
3831 if (debug
->external_rfd
!= NULL
)
3832 free (debug
->external_rfd
);
3834 /* Make sure we don't accidentally follow one of these pointers
3835 into freed memory. */
3837 debug
->external_dnr
= NULL
;
3838 debug
->external_pdr
= NULL
;
3839 debug
->external_sym
= NULL
;
3840 debug
->external_opt
= NULL
;
3841 debug
->external_aux
= NULL
;
3843 debug
->external_fdr
= NULL
;
3844 debug
->external_rfd
= NULL
;
3850 /* Relocate and write an ECOFF section into an ECOFF output file. */
3853 ecoff_indirect_link_order (bfd
*output_bfd
,
3854 struct bfd_link_info
*info
,
3855 asection
*output_section
,
3856 struct bfd_link_order
*link_order
)
3858 asection
*input_section
;
3860 bfd_byte
*contents
= NULL
;
3861 bfd_size_type external_reloc_size
;
3862 bfd_size_type external_relocs_size
;
3863 void * external_relocs
= NULL
;
3865 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
3867 input_section
= link_order
->u
.indirect
.section
;
3868 input_bfd
= input_section
->owner
;
3869 if (input_section
->size
== 0)
3872 BFD_ASSERT (input_section
->output_section
== output_section
);
3873 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
3874 BFD_ASSERT (input_section
->size
== link_order
->size
);
3876 /* Get the section contents. */
3877 if (!bfd_malloc_and_get_section (input_bfd
, input_section
, &contents
))
3880 /* Get the relocs. If we are relaxing MIPS code, they will already
3881 have been read in. Otherwise, we read them in now. */
3882 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
3883 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
3885 external_relocs
= bfd_malloc (external_relocs_size
);
3886 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
3889 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3890 || (bfd_bread (external_relocs
, external_relocs_size
, input_bfd
)
3891 != external_relocs_size
))
3894 /* Relocate the section contents. */
3895 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
3896 (output_bfd
, info
, input_bfd
, input_section
, contents
,
3900 /* Write out the relocated section. */
3901 if (! bfd_set_section_contents (output_bfd
,
3904 input_section
->output_offset
,
3905 input_section
->size
))
3908 /* If we are producing relocatable output, the relocs were
3909 modified, and we write them out now. We use the reloc_count
3910 field of output_section to keep track of the number of relocs we
3911 have output so far. */
3912 if (bfd_link_relocatable (info
))
3914 file_ptr pos
= (output_section
->rel_filepos
3915 + output_section
->reloc_count
* external_reloc_size
);
3916 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
3917 || (bfd_bwrite (external_relocs
, external_relocs_size
, output_bfd
)
3918 != external_relocs_size
))
3920 output_section
->reloc_count
+= input_section
->reloc_count
;
3923 if (contents
!= NULL
)
3925 if (external_relocs
!= NULL
)
3926 free (external_relocs
);
3930 if (contents
!= NULL
)
3932 if (external_relocs
!= NULL
)
3933 free (external_relocs
);
3937 /* Generate a reloc when linking an ECOFF file. This is a reloc
3938 requested by the linker, and does come from any input file. This
3939 is used to build constructor and destructor tables when linking
3943 ecoff_reloc_link_order (bfd
*output_bfd
,
3944 struct bfd_link_info
*info
,
3945 asection
*output_section
,
3946 struct bfd_link_order
*link_order
)
3948 enum bfd_link_order_type type
;
3952 struct internal_reloc in
;
3953 bfd_size_type external_reloc_size
;
3958 type
= link_order
->type
;
3960 addend
= link_order
->u
.reloc
.p
->addend
;
3962 /* We set up an arelent to pass to the backend adjust_reloc_out
3964 rel
.address
= link_order
->offset
;
3966 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3969 bfd_set_error (bfd_error_bad_value
);
3973 if (type
== bfd_section_reloc_link_order
)
3975 section
= link_order
->u
.reloc
.p
->u
.section
;
3976 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
3980 struct bfd_link_hash_entry
*h
;
3982 /* Treat a reloc against a defined symbol as though it were
3983 actually against the section. */
3984 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3985 link_order
->u
.reloc
.p
->u
.name
,
3986 FALSE
, FALSE
, FALSE
);
3988 && (h
->type
== bfd_link_hash_defined
3989 || h
->type
== bfd_link_hash_defweak
))
3991 type
= bfd_section_reloc_link_order
;
3992 section
= h
->u
.def
.section
->output_section
;
3993 /* It seems that we ought to add the symbol value to the
3994 addend here, but in practice it has already been added
3995 because it was passed to constructor_callback. */
3996 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
4000 /* We can't set up a reloc against a symbol correctly,
4001 because we have no asymbol structure. Currently no
4002 adjust_reloc_out routine cares. */
4003 rel
.sym_ptr_ptr
= NULL
;
4007 /* All ECOFF relocs are in-place. Put the addend into the object
4010 BFD_ASSERT (rel
.howto
->partial_inplace
);
4014 bfd_reloc_status_type rstat
;
4017 size
= bfd_get_reloc_size (rel
.howto
);
4018 buf
= (bfd_byte
*) bfd_zmalloc (size
);
4019 if (buf
== NULL
&& size
!= 0)
4021 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
4022 (bfd_vma
) addend
, buf
);
4028 case bfd_reloc_outofrange
:
4030 case bfd_reloc_overflow
:
4031 (*info
->callbacks
->reloc_overflow
)
4033 (link_order
->type
== bfd_section_reloc_link_order
4034 ? bfd_section_name (section
)
4035 : link_order
->u
.reloc
.p
->u
.name
),
4036 rel
.howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0);
4039 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
4040 (file_ptr
) link_order
->offset
, size
);
4048 /* Move the information into an internal_reloc structure. */
4049 in
.r_vaddr
= rel
.address
+ bfd_section_vma (output_section
);
4050 in
.r_type
= rel
.howto
->type
;
4052 if (type
== bfd_symbol_reloc_link_order
)
4054 struct ecoff_link_hash_entry
*h
;
4056 h
= ((struct ecoff_link_hash_entry
*)
4057 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4058 link_order
->u
.reloc
.p
->u
.name
,
4059 FALSE
, FALSE
, TRUE
));
4062 in
.r_symndx
= h
->indx
;
4065 (*info
->callbacks
->unattached_reloc
)
4066 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
4082 { _TEXT
, RELOC_SECTION_TEXT
},
4083 { _RDATA
, RELOC_SECTION_RDATA
},
4084 { _DATA
, RELOC_SECTION_DATA
},
4085 { _SDATA
, RELOC_SECTION_SDATA
},
4086 { _SBSS
, RELOC_SECTION_SBSS
},
4087 { _BSS
, RELOC_SECTION_BSS
},
4088 { _INIT
, RELOC_SECTION_INIT
},
4089 { _LIT8
, RELOC_SECTION_LIT8
},
4090 { _LIT4
, RELOC_SECTION_LIT4
},
4091 { _XDATA
, RELOC_SECTION_XDATA
},
4092 { _PDATA
, RELOC_SECTION_PDATA
},
4093 { _FINI
, RELOC_SECTION_FINI
},
4094 { _LITA
, RELOC_SECTION_LITA
},
4095 { "*ABS*", RELOC_SECTION_ABS
},
4096 { _RCONST
, RELOC_SECTION_RCONST
}
4099 name
= bfd_section_name (section
);
4101 for (i
= 0; i
< ARRAY_SIZE (section_symndx
); i
++)
4102 if (streq (name
, section_symndx
[i
].name
))
4104 in
.r_symndx
= section_symndx
[i
].r_symndx
;
4108 if (i
== ARRAY_SIZE (section_symndx
))
4114 /* Let the BFD backend adjust the reloc. */
4115 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4117 /* Get some memory and swap out the reloc. */
4118 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4119 rbuf
= (bfd_byte
*) bfd_malloc (external_reloc_size
);
4123 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (void *) rbuf
);
4125 pos
= (output_section
->rel_filepos
4126 + output_section
->reloc_count
* external_reloc_size
);
4127 ok
= (bfd_seek (output_bfd
, pos
, SEEK_SET
) == 0
4128 && (bfd_bwrite ((void *) rbuf
, external_reloc_size
, output_bfd
)
4129 == external_reloc_size
));
4132 ++output_section
->reloc_count
;
4139 /* Put out information for an external symbol. These come only from
4143 ecoff_link_write_external (struct bfd_hash_entry
*bh
, void * data
)
4145 struct ecoff_link_hash_entry
*h
= (struct ecoff_link_hash_entry
*) bh
;
4146 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4147 bfd
*output_bfd
= einfo
->abfd
;
4150 if (h
->root
.type
== bfd_link_hash_warning
)
4152 h
= (struct ecoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4153 if (h
->root
.type
== bfd_link_hash_new
)
4157 /* We need to check if this symbol is being stripped. */
4158 if (h
->root
.type
== bfd_link_hash_undefined
4159 || h
->root
.type
== bfd_link_hash_undefweak
)
4161 else if (einfo
->info
->strip
== strip_all
4162 || (einfo
->info
->strip
== strip_some
4163 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4164 h
->root
.root
.string
,
4165 FALSE
, FALSE
) == NULL
))
4170 if (strip
|| h
->written
)
4173 if (h
->abfd
== NULL
)
4176 h
->esym
.cobol_main
= 0;
4177 h
->esym
.weakext
= 0;
4178 h
->esym
.reserved
= 0;
4179 h
->esym
.ifd
= ifdNil
;
4180 h
->esym
.asym
.value
= 0;
4181 h
->esym
.asym
.st
= stGlobal
;
4183 if (h
->root
.type
!= bfd_link_hash_defined
4184 && h
->root
.type
!= bfd_link_hash_defweak
)
4185 h
->esym
.asym
.sc
= scAbs
;
4188 asection
*output_section
;
4196 section_storage_classes
[] =
4200 { _SDATA
, scSData
},
4201 { _RDATA
, scRData
},
4206 { _PDATA
, scPData
},
4207 { _XDATA
, scXData
},
4208 { _RCONST
, scRConst
}
4211 output_section
= h
->root
.u
.def
.section
->output_section
;
4212 name
= bfd_section_name (output_section
);
4214 for (i
= 0; i
< ARRAY_SIZE (section_storage_classes
); i
++)
4215 if (streq (name
, section_storage_classes
[i
].name
))
4217 h
->esym
.asym
.sc
= section_storage_classes
[i
].sc
;
4221 if (i
== ARRAY_SIZE (section_storage_classes
))
4222 h
->esym
.asym
.sc
= scAbs
;
4225 h
->esym
.asym
.reserved
= 0;
4226 h
->esym
.asym
.index
= indexNil
;
4228 else if (h
->esym
.ifd
!= -1)
4230 struct ecoff_debug_info
*debug
;
4232 /* Adjust the FDR index for the symbol by that used for the
4234 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4235 BFD_ASSERT (h
->esym
.ifd
>= 0
4236 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4237 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4240 switch (h
->root
.type
)
4243 case bfd_link_hash_warning
:
4244 case bfd_link_hash_new
:
4246 case bfd_link_hash_undefined
:
4247 case bfd_link_hash_undefweak
:
4248 if (h
->esym
.asym
.sc
!= scUndefined
4249 && h
->esym
.asym
.sc
!= scSUndefined
)
4250 h
->esym
.asym
.sc
= scUndefined
;
4252 case bfd_link_hash_defined
:
4253 case bfd_link_hash_defweak
:
4254 if (h
->esym
.asym
.sc
== scUndefined
4255 || h
->esym
.asym
.sc
== scSUndefined
)
4256 h
->esym
.asym
.sc
= scAbs
;
4257 else if (h
->esym
.asym
.sc
== scCommon
)
4258 h
->esym
.asym
.sc
= scBss
;
4259 else if (h
->esym
.asym
.sc
== scSCommon
)
4260 h
->esym
.asym
.sc
= scSBss
;
4261 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4262 + h
->root
.u
.def
.section
->output_section
->vma
4263 + h
->root
.u
.def
.section
->output_offset
);
4265 case bfd_link_hash_common
:
4266 if (h
->esym
.asym
.sc
!= scCommon
4267 && h
->esym
.asym
.sc
!= scSCommon
)
4268 h
->esym
.asym
.sc
= scCommon
;
4269 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4271 case bfd_link_hash_indirect
:
4272 /* We ignore these symbols, since the indirected symbol is
4273 already in the hash table. */
4277 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4279 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4282 return (bfd_ecoff_debug_one_external
4283 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4284 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4288 /* ECOFF final link routine. This looks through all the input BFDs
4289 and gathers together all the debugging information, and then
4290 processes all the link order information. This may cause it to
4291 close and reopen some input BFDs; I'll see how bad this is. */
4294 _bfd_ecoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
4296 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4297 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4302 struct bfd_link_order
*p
;
4303 struct extsym_info einfo
;
4305 /* We accumulate the debugging information counts in the symbolic
4307 symhdr
= &debug
->symbolic_header
;
4309 symhdr
->ilineMax
= 0;
4313 symhdr
->isymMax
= 0;
4314 symhdr
->ioptMax
= 0;
4315 symhdr
->iauxMax
= 0;
4317 symhdr
->issExtMax
= 0;
4320 symhdr
->iextMax
= 0;
4322 /* We accumulate the debugging information itself in the debug_info
4325 debug
->external_dnr
= NULL
;
4326 debug
->external_pdr
= NULL
;
4327 debug
->external_sym
= NULL
;
4328 debug
->external_opt
= NULL
;
4329 debug
->external_aux
= NULL
;
4331 debug
->ssext
= debug
->ssext_end
= NULL
;
4332 debug
->external_fdr
= NULL
;
4333 debug
->external_rfd
= NULL
;
4334 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4336 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4340 /* Accumulate the debugging symbols from each input BFD. */
4341 for (input_bfd
= info
->input_bfds
;
4343 input_bfd
= input_bfd
->link
.next
)
4347 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4349 /* Arbitrarily set the symbolic header vstamp to the vstamp
4350 of the first object file in the link. */
4351 if (symhdr
->vstamp
== 0)
4353 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4354 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4358 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4359 debug
, &backend
->debug_swap
,
4364 /* Combine the register masks. */
4365 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4366 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4367 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4368 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4369 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4370 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4373 /* Write out the external symbols. */
4376 bfd_hash_traverse (&info
->hash
->table
, ecoff_link_write_external
, &einfo
);
4378 if (bfd_link_relocatable (info
))
4380 /* We need to make a pass over the link_orders to count up the
4381 number of relocations we will need to output, so that we know
4382 how much space they will take up. */
4383 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4386 for (p
= o
->map_head
.link_order
;
4389 if (p
->type
== bfd_indirect_link_order
)
4390 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4391 else if (p
->type
== bfd_section_reloc_link_order
4392 || p
->type
== bfd_symbol_reloc_link_order
)
4397 /* Compute the reloc and symbol file positions. */
4398 ecoff_compute_reloc_file_positions (abfd
);
4400 /* Write out the debugging information. */
4401 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4402 &backend
->debug_swap
, info
,
4403 ecoff_data (abfd
)->sym_filepos
))
4406 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4408 if (bfd_link_relocatable (info
))
4410 /* Now reset the reloc_count field of the sections in the output
4411 BFD to 0, so that we can use them to keep track of how many
4412 relocs we have output thus far. */
4413 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4417 /* Get a value for the GP register. */
4418 if (ecoff_data (abfd
)->gp
== 0)
4420 struct bfd_link_hash_entry
*h
;
4422 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
4424 && h
->type
== bfd_link_hash_defined
)
4425 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4426 + h
->u
.def
.section
->output_section
->vma
4427 + h
->u
.def
.section
->output_offset
);
4428 else if (bfd_link_relocatable (info
))
4432 /* Make up a value. */
4434 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4437 && (streq (o
->name
, _SBSS
)
4438 || streq (o
->name
, _SDATA
)
4439 || streq (o
->name
, _LIT4
)
4440 || streq (o
->name
, _LIT8
)
4441 || streq (o
->name
, _LITA
)))
4444 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4448 /* If the relocate_section function needs to do a reloc
4449 involving the GP value, it should make a reloc_dangerous
4450 callback to warn that GP is not defined. */
4454 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4456 for (p
= o
->map_head
.link_order
;
4460 if (p
->type
== bfd_indirect_link_order
4461 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4462 == bfd_target_ecoff_flavour
))
4464 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4467 else if (p
->type
== bfd_section_reloc_link_order
4468 || p
->type
== bfd_symbol_reloc_link_order
)
4470 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4475 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4481 abfd
->symcount
= symhdr
->iextMax
+ symhdr
->isymMax
;
4483 ecoff_data (abfd
)->linker
= TRUE
;