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 if (bfd_seek (abfd
, ecoff_data (abfd
)->sym_filepos
, SEEK_SET
) != 0)
470 raw
= _bfd_malloc_and_read (abfd
, external_hdr_size
, external_hdr_size
);
474 internal_symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
475 (*backend
->debug_swap
.swap_hdr_in
) (abfd
, raw
, internal_symhdr
);
477 if (internal_symhdr
->magic
!= backend
->debug_swap
.sym_magic
)
479 bfd_set_error (bfd_error_bad_value
);
483 /* Now we can get the correct number of symbols. */
484 abfd
->symcount
= internal_symhdr
->isymMax
+ internal_symhdr
->iextMax
;
495 /* Read in and swap the important symbolic information for an ECOFF
496 object file. This is called by gdb via the read_debug_info entry
497 point in the backend structure. */
500 _bfd_ecoff_slurp_symbolic_info (bfd
*abfd
,
501 asection
*ignore ATTRIBUTE_UNUSED
,
502 struct ecoff_debug_info
*debug
)
504 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
505 HDRR
*internal_symhdr
;
506 bfd_size_type raw_base
;
507 bfd_size_type raw_size
;
509 bfd_size_type external_fdr_size
;
513 bfd_size_type raw_end
;
514 bfd_size_type cb_end
;
518 BFD_ASSERT (debug
== &ecoff_data (abfd
)->debug_info
);
520 /* Check whether we've already gotten it, and whether there's any to
522 if (ecoff_data (abfd
)->raw_syments
!= NULL
)
524 if (ecoff_data (abfd
)->sym_filepos
== 0)
530 if (! ecoff_slurp_symbolic_header (abfd
))
533 internal_symhdr
= &debug
->symbolic_header
;
535 /* Read all the symbolic information at once. */
536 raw_base
= (ecoff_data (abfd
)->sym_filepos
537 + backend
->debug_swap
.external_hdr_size
);
539 /* Alpha ecoff makes the determination of raw_size difficult. It has
540 an undocumented debug data section between the symhdr and the first
541 documented section. And the ordering of the sections varies between
542 statically and dynamically linked executables.
543 If bfd supports SEEK_END someday, this code could be simplified. */
546 #define UPDATE_RAW_END(start, count, size) \
547 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
548 if (cb_end > raw_end) \
551 UPDATE_RAW_END (cbLineOffset
, cbLine
, sizeof (unsigned char));
552 UPDATE_RAW_END (cbDnOffset
, idnMax
, backend
->debug_swap
.external_dnr_size
);
553 UPDATE_RAW_END (cbPdOffset
, ipdMax
, backend
->debug_swap
.external_pdr_size
);
554 UPDATE_RAW_END (cbSymOffset
, isymMax
, backend
->debug_swap
.external_sym_size
);
555 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
556 optimization symtab, not the number of entries. */
557 UPDATE_RAW_END (cbOptOffset
, ioptMax
, sizeof (char));
558 UPDATE_RAW_END (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
559 UPDATE_RAW_END (cbSsOffset
, issMax
, sizeof (char));
560 UPDATE_RAW_END (cbSsExtOffset
, issExtMax
, sizeof (char));
561 UPDATE_RAW_END (cbFdOffset
, ifdMax
, backend
->debug_swap
.external_fdr_size
);
562 UPDATE_RAW_END (cbRfdOffset
, crfd
, backend
->debug_swap
.external_rfd_size
);
563 UPDATE_RAW_END (cbExtOffset
, iextMax
, backend
->debug_swap
.external_ext_size
);
565 #undef UPDATE_RAW_END
567 raw_size
= raw_end
- raw_base
;
570 ecoff_data (abfd
)->sym_filepos
= 0;
573 pos
= ecoff_data (abfd
)->sym_filepos
;
574 pos
+= backend
->debug_swap
.external_hdr_size
;
575 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
577 raw
= _bfd_alloc_and_read (abfd
, raw_size
, raw_size
);
581 ecoff_data (abfd
)->raw_syments
= raw
;
583 /* Get pointers for the numeric offsets in the HDRR structure. */
584 #define FIX(off1, off2, type) \
585 if (internal_symhdr->off1 == 0) \
586 debug->off2 = NULL; \
588 debug->off2 = (type) ((char *) raw \
589 + (internal_symhdr->off1 \
592 FIX (cbLineOffset
, line
, unsigned char *);
593 FIX (cbDnOffset
, external_dnr
, void *);
594 FIX (cbPdOffset
, external_pdr
, void *);
595 FIX (cbSymOffset
, external_sym
, void *);
596 FIX (cbOptOffset
, external_opt
, void *);
597 FIX (cbAuxOffset
, external_aux
, union aux_ext
*);
598 FIX (cbSsOffset
, ss
, char *);
599 FIX (cbSsExtOffset
, ssext
, char *);
600 FIX (cbFdOffset
, external_fdr
, void *);
601 FIX (cbRfdOffset
, external_rfd
, void *);
602 FIX (cbExtOffset
, external_ext
, void *);
605 /* I don't want to always swap all the data, because it will just
606 waste time and most programs will never look at it. The only
607 time the linker needs most of the debugging information swapped
608 is when linking big-endian and little-endian MIPS object files
609 together, which is not a common occurrence.
611 We need to look at the fdr to deal with a lot of information in
612 the symbols, so we swap them here. */
613 if (_bfd_mul_overflow ((unsigned long) internal_symhdr
->ifdMax
,
614 sizeof (struct fdr
), &amt
))
616 bfd_set_error (bfd_error_file_too_big
);
619 debug
->fdr
= (FDR
*) bfd_alloc (abfd
, amt
);
620 if (debug
->fdr
== NULL
)
622 external_fdr_size
= backend
->debug_swap
.external_fdr_size
;
623 fdr_ptr
= debug
->fdr
;
624 fraw_src
= (char *) debug
->external_fdr
;
625 /* PR 17512: file: 3372-1243-0.004. */
626 if (fraw_src
== NULL
&& internal_symhdr
->ifdMax
> 0)
628 fraw_end
= fraw_src
+ internal_symhdr
->ifdMax
* external_fdr_size
;
629 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
630 (*backend
->debug_swap
.swap_fdr_in
) (abfd
, (void *) fraw_src
, fdr_ptr
);
635 /* ECOFF symbol table routines. The ECOFF symbol table is described
636 in gcc/mips-tfile.c. */
638 /* ECOFF uses two common sections. One is the usual one, and the
639 other is for small objects. All the small objects are kept
640 together, and then referenced via the gp pointer, which yields
641 faster assembler code. This is what we use for the small common
643 static asection ecoff_scom_section
;
644 static asymbol ecoff_scom_symbol
;
645 static asymbol
*ecoff_scom_symbol_ptr
;
647 /* Create an empty symbol. */
650 _bfd_ecoff_make_empty_symbol (bfd
*abfd
)
652 ecoff_symbol_type
*new_symbol
;
653 size_t amt
= sizeof (ecoff_symbol_type
);
655 new_symbol
= (ecoff_symbol_type
*) bfd_zalloc (abfd
, amt
);
656 if (new_symbol
== NULL
)
658 new_symbol
->symbol
.section
= NULL
;
659 new_symbol
->fdr
= NULL
;
660 new_symbol
->local
= FALSE
;
661 new_symbol
->native
= NULL
;
662 new_symbol
->symbol
.the_bfd
= abfd
;
663 return &new_symbol
->symbol
;
666 /* Set the BFD flags and section for an ECOFF symbol. */
669 ecoff_set_symbol_info (bfd
*abfd
,
675 asym
->the_bfd
= abfd
;
676 asym
->value
= ecoff_sym
->value
;
677 asym
->section
= &bfd_debug_section
;
680 /* Most symbol types are just for debugging. */
681 switch (ecoff_sym
->st
)
690 if (ECOFF_IS_STAB (ecoff_sym
))
692 asym
->flags
= BSF_DEBUGGING
;
697 asym
->flags
= BSF_DEBUGGING
;
702 asym
->flags
= BSF_EXPORT
| BSF_WEAK
;
704 asym
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
707 asym
->flags
= BSF_LOCAL
;
708 /* Normally, a local stProc symbol will have a corresponding
709 external symbol. We mark the local symbol as a debugging
710 symbol, in order to prevent nm from printing both out.
711 Similarly, we mark stLabel and stabs symbols as debugging
712 symbols. In both cases, we do want to set the value
713 correctly based on the symbol class. */
714 if (ecoff_sym
->st
== stProc
715 || ecoff_sym
->st
== stLabel
716 || ECOFF_IS_STAB (ecoff_sym
))
717 asym
->flags
|= BSF_DEBUGGING
;
720 if (ecoff_sym
->st
== stProc
|| ecoff_sym
->st
== stStaticProc
)
721 asym
->flags
|= BSF_FUNCTION
;
723 switch (ecoff_sym
->sc
)
726 /* Used for compiler generated labels. Leave them in the
727 debugging section, and mark them as local. If BSF_DEBUGGING
728 is set, then nm does not display them for some reason. If no
729 flags are set then the linker whines about them. */
730 asym
->flags
= BSF_LOCAL
;
733 asym
->section
= bfd_make_section_old_way (abfd
, _TEXT
);
734 asym
->value
-= asym
->section
->vma
;
737 asym
->section
= bfd_make_section_old_way (abfd
, _DATA
);
738 asym
->value
-= asym
->section
->vma
;
741 asym
->section
= bfd_make_section_old_way (abfd
, _BSS
);
742 asym
->value
-= asym
->section
->vma
;
745 asym
->flags
= BSF_DEBUGGING
;
748 asym
->section
= bfd_abs_section_ptr
;
751 asym
->section
= bfd_und_section_ptr
;
761 asym
->flags
= BSF_DEBUGGING
;
764 asym
->section
= bfd_make_section_old_way (abfd
, ".sdata");
765 asym
->value
-= asym
->section
->vma
;
768 asym
->section
= bfd_make_section_old_way (abfd
, ".sbss");
769 asym
->value
-= asym
->section
->vma
;
772 asym
->section
= bfd_make_section_old_way (abfd
, ".rdata");
773 asym
->value
-= asym
->section
->vma
;
776 asym
->flags
= BSF_DEBUGGING
;
779 if (asym
->value
> ecoff_data (abfd
)->gp_size
)
781 asym
->section
= bfd_com_section_ptr
;
787 if (ecoff_scom_section
.name
== NULL
)
789 /* Initialize the small common section. */
790 ecoff_scom_section
.name
= SCOMMON
;
791 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
792 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
793 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
794 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
795 ecoff_scom_symbol
.name
= SCOMMON
;
796 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
797 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
798 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
800 asym
->section
= &ecoff_scom_section
;
805 asym
->flags
= BSF_DEBUGGING
;
808 asym
->section
= bfd_und_section_ptr
;
813 asym
->section
= bfd_make_section_old_way (abfd
, ".init");
814 asym
->value
-= asym
->section
->vma
;
819 asym
->flags
= BSF_DEBUGGING
;
822 asym
->section
= bfd_make_section_old_way (abfd
, ".fini");
823 asym
->value
-= asym
->section
->vma
;
826 asym
->section
= bfd_make_section_old_way (abfd
, ".rconst");
827 asym
->value
-= asym
->section
->vma
;
833 /* Look for special constructors symbols and make relocation entries
834 in a special construction section. These are produced by the
835 -fgnu-linker argument to g++. */
836 if (ECOFF_IS_STAB (ecoff_sym
))
838 switch (ECOFF_UNMARK_STAB (ecoff_sym
->index
))
847 /* Mark the symbol as a constructor. */
848 asym
->flags
|= BSF_CONSTRUCTOR
;
855 /* Read an ECOFF symbol table. */
858 _bfd_ecoff_slurp_symbol_table (bfd
*abfd
)
860 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
861 const bfd_size_type external_ext_size
862 = backend
->debug_swap
.external_ext_size
;
863 const bfd_size_type external_sym_size
864 = backend
->debug_swap
.external_sym_size
;
865 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
866 = backend
->debug_swap
.swap_ext_in
;
867 void (* const swap_sym_in
) (bfd
*, void *, SYMR
*)
868 = backend
->debug_swap
.swap_sym_in
;
869 ecoff_symbol_type
*internal
;
870 ecoff_symbol_type
*internal_ptr
;
877 /* If we've already read in the symbol table, do nothing. */
878 if (ecoff_data (abfd
)->canonical_symbols
!= NULL
)
881 /* Get the symbolic information. */
882 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
883 &ecoff_data (abfd
)->debug_info
))
885 if (bfd_get_symcount (abfd
) == 0)
888 if (_bfd_mul_overflow (bfd_get_symcount (abfd
),
889 sizeof (ecoff_symbol_type
), &amt
))
891 bfd_set_error (bfd_error_file_too_big
);
894 internal
= (ecoff_symbol_type
*) bfd_alloc (abfd
, amt
);
895 if (internal
== NULL
)
898 internal_ptr
= internal
;
899 eraw_src
= (char *) ecoff_data (abfd
)->debug_info
.external_ext
;
901 + (ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
902 * external_ext_size
));
903 for (; eraw_src
< eraw_end
; eraw_src
+= external_ext_size
, internal_ptr
++)
907 (*swap_ext_in
) (abfd
, (void *) eraw_src
, &internal_esym
);
909 /* PR 17512: file: 3372-1000-0.004. */
910 if (internal_esym
.asym
.iss
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.issExtMax
911 || internal_esym
.asym
.iss
< 0)
914 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ssext
915 + internal_esym
.asym
.iss
);
917 if (!ecoff_set_symbol_info (abfd
, &internal_esym
.asym
,
918 &internal_ptr
->symbol
, 1,
919 internal_esym
.weakext
))
922 /* The alpha uses a negative ifd field for section symbols. */
923 if (internal_esym
.ifd
>= 0)
925 /* PR 17512: file: 3372-1983-0.004. */
926 if (internal_esym
.ifd
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
)
927 internal_ptr
->fdr
= NULL
;
929 internal_ptr
->fdr
= (ecoff_data (abfd
)->debug_info
.fdr
930 + internal_esym
.ifd
);
933 internal_ptr
->fdr
= NULL
;
934 internal_ptr
->local
= FALSE
;
935 internal_ptr
->native
= (void *) eraw_src
;
938 /* The local symbols must be accessed via the fdr's, because the
939 string and aux indices are relative to the fdr information. */
940 fdr_ptr
= ecoff_data (abfd
)->debug_info
.fdr
;
941 fdr_end
= fdr_ptr
+ ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
;
942 for (; fdr_ptr
< fdr_end
; fdr_ptr
++)
947 lraw_src
= ((char *) ecoff_data (abfd
)->debug_info
.external_sym
948 + fdr_ptr
->isymBase
* external_sym_size
);
949 lraw_end
= lraw_src
+ fdr_ptr
->csym
* external_sym_size
;
952 lraw_src
+= external_sym_size
, internal_ptr
++)
956 (*swap_sym_in
) (abfd
, (void *) lraw_src
, &internal_sym
);
957 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ss
960 if (!ecoff_set_symbol_info (abfd
, &internal_sym
,
961 &internal_ptr
->symbol
, 0, 0))
963 internal_ptr
->fdr
= fdr_ptr
;
964 internal_ptr
->local
= TRUE
;
965 internal_ptr
->native
= (void *) lraw_src
;
969 /* PR 17512: file: 3372-3080-0.004.
970 A discrepancy between ecoff_data (abfd)->debug_info.symbolic_header.isymMax
971 and ecoff_data (abfd)->debug_info.symbolic_header.ifdMax can mean that
972 we have fewer symbols than we were expecting. Allow for this by updating
973 the symbol count and warning the user. */
974 if (internal_ptr
- internal
< (ptrdiff_t) bfd_get_symcount (abfd
))
976 abfd
->symcount
= internal_ptr
- internal
;
978 /* xgettext:c-format */
979 (_("%pB: warning: isymMax (%ld) is greater than ifdMax (%ld)"),
980 abfd
, ecoff_data (abfd
)->debug_info
.symbolic_header
.isymMax
,
981 ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
);
984 ecoff_data (abfd
)->canonical_symbols
= internal
;
989 /* Return the amount of space needed for the canonical symbols. */
992 _bfd_ecoff_get_symtab_upper_bound (bfd
*abfd
)
994 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
995 &ecoff_data (abfd
)->debug_info
))
998 if (bfd_get_symcount (abfd
) == 0)
1001 return (bfd_get_symcount (abfd
) + 1) * (sizeof (ecoff_symbol_type
*));
1004 /* Get the canonical symbols. */
1007 _bfd_ecoff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
1009 unsigned int counter
= 0;
1010 ecoff_symbol_type
*symbase
;
1011 ecoff_symbol_type
**location
= (ecoff_symbol_type
**) alocation
;
1013 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1015 if (bfd_get_symcount (abfd
) == 0)
1018 symbase
= ecoff_data (abfd
)->canonical_symbols
;
1019 while (counter
< bfd_get_symcount (abfd
))
1021 *(location
++) = symbase
++;
1025 return bfd_get_symcount (abfd
);
1028 /* Turn ECOFF type information into a printable string.
1029 ecoff_emit_aggregate and ecoff_type_to_string are from
1030 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1032 /* Write aggregate information to a string. */
1035 ecoff_emit_aggregate (bfd
*abfd
,
1042 const struct ecoff_debug_swap
* const debug_swap
=
1043 &ecoff_backend (abfd
)->debug_swap
;
1044 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1045 unsigned int ifd
= rndx
->rfd
;
1046 unsigned int indx
= rndx
->index
;
1052 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1053 struct return type of a procedure compiled without -g. */
1054 if (ifd
== 0xffffffff
1055 || (rndx
->rfd
== 0xfff && indx
== 0))
1056 name
= "<undefined>";
1057 else if (indx
== indexNil
)
1063 if (debug_info
->external_rfd
== NULL
)
1064 fdr
= debug_info
->fdr
+ ifd
;
1069 (*debug_swap
->swap_rfd_in
) (abfd
,
1070 ((char *) debug_info
->external_rfd
1071 + ((fdr
->rfdBase
+ ifd
)
1072 * debug_swap
->external_rfd_size
)),
1074 fdr
= debug_info
->fdr
+ rfd
;
1077 indx
+= fdr
->isymBase
;
1079 (*debug_swap
->swap_sym_in
) (abfd
,
1080 ((char *) debug_info
->external_sym
1081 + indx
* debug_swap
->external_sym_size
),
1084 name
= debug_info
->ss
+ fdr
->issBase
+ sym
.iss
;
1088 "%s %s { ifd = %u, index = %lu }",
1090 ((unsigned long) indx
1091 + debug_info
->symbolic_header
.iextMax
));
1094 /* Convert the type information to string format. */
1097 ecoff_type_to_string (bfd
*abfd
, FDR
*fdr
, unsigned int indx
)
1099 union aux_ext
*aux_ptr
;
1109 unsigned int basic_type
;
1112 static char buffer2
[1024];
1117 aux_ptr
= ecoff_data (abfd
)->debug_info
.external_aux
+ fdr
->iauxBase
;
1118 bigendian
= fdr
->fBigendian
;
1120 for (i
= 0; i
< 7; i
++)
1122 qualifiers
[i
].low_bound
= 0;
1123 qualifiers
[i
].high_bound
= 0;
1124 qualifiers
[i
].stride
= 0;
1127 if (AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
]) == (bfd_vma
) -1)
1128 return "-1 (no type)";
1129 _bfd_ecoff_swap_tir_in (bigendian
, &aux_ptr
[indx
++].a_ti
, &u
.ti
);
1131 basic_type
= u
.ti
.bt
;
1132 qualifiers
[0].type
= u
.ti
.tq0
;
1133 qualifiers
[1].type
= u
.ti
.tq1
;
1134 qualifiers
[2].type
= u
.ti
.tq2
;
1135 qualifiers
[3].type
= u
.ti
.tq3
;
1136 qualifiers
[4].type
= u
.ti
.tq4
;
1137 qualifiers
[5].type
= u
.ti
.tq5
;
1138 qualifiers
[6].type
= tqNil
;
1140 /* Go get the basic type. */
1143 case btNil
: /* Undefined. */
1147 case btAdr
: /* Address - integer same size as pointer. */
1148 strcpy (p1
, "address");
1151 case btChar
: /* Character. */
1152 strcpy (p1
, "char");
1155 case btUChar
: /* Unsigned character. */
1156 strcpy (p1
, "unsigned char");
1159 case btShort
: /* Short. */
1160 strcpy (p1
, "short");
1163 case btUShort
: /* Unsigned short. */
1164 strcpy (p1
, "unsigned short");
1167 case btInt
: /* Int. */
1171 case btUInt
: /* Unsigned int. */
1172 strcpy (p1
, "unsigned int");
1175 case btLong
: /* Long. */
1176 strcpy (p1
, "long");
1179 case btULong
: /* Unsigned long. */
1180 strcpy (p1
, "unsigned long");
1183 case btFloat
: /* Float (real). */
1184 strcpy (p1
, "float");
1187 case btDouble
: /* Double (real). */
1188 strcpy (p1
, "double");
1191 /* Structures add 1-2 aux words:
1192 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1193 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1195 case btStruct
: /* Structure (Record). */
1196 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1197 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1198 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1200 indx
++; /* Skip aux words. */
1203 /* Unions add 1-2 aux words:
1204 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1205 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1207 case btUnion
: /* Union. */
1208 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1209 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1210 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1212 indx
++; /* Skip aux words. */
1215 /* Enumerations add 1-2 aux words:
1216 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1217 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1219 case btEnum
: /* Enumeration. */
1220 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1221 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1222 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1224 indx
++; /* Skip aux words. */
1227 case btTypedef
: /* Defined via a typedef, isymRef points. */
1228 strcpy (p1
, "typedef");
1231 case btRange
: /* Subrange of int. */
1232 strcpy (p1
, "subrange");
1235 case btSet
: /* Pascal sets. */
1239 case btComplex
: /* Fortran complex. */
1240 strcpy (p1
, "complex");
1243 case btDComplex
: /* Fortran double complex. */
1244 strcpy (p1
, "double complex");
1247 case btIndirect
: /* Forward or unnamed typedef. */
1248 strcpy (p1
, "forward/unamed typedef");
1251 case btFixedDec
: /* Fixed Decimal. */
1252 strcpy (p1
, "fixed decimal");
1255 case btFloatDec
: /* Float Decimal. */
1256 strcpy (p1
, "float decimal");
1259 case btString
: /* Varying Length Character String. */
1260 strcpy (p1
, "string");
1263 case btBit
: /* Aligned Bit String. */
1267 case btPicture
: /* Picture. */
1268 strcpy (p1
, "picture");
1271 case btVoid
: /* Void. */
1272 strcpy (p1
, "void");
1276 sprintf (p1
, _("unknown basic type %d"), (int) basic_type
);
1280 p1
+= strlen (buffer1
);
1282 /* If this is a bitfield, get the bitsize. */
1287 bitsize
= AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
++]);
1288 sprintf (p1
, " : %d", bitsize
);
1289 p1
+= strlen (buffer1
);
1292 /* Deal with any qualifiers. */
1293 if (qualifiers
[0].type
!= tqNil
)
1295 /* Snarf up any array bounds in the correct order. Arrays
1296 store 5 successive words in the aux. table:
1297 word 0 RNDXR to type of the bounds (ie, int)
1298 word 1 Current file descriptor index
1300 word 3 high bound (or -1 if [])
1301 word 4 stride size in bits. */
1302 for (i
= 0; i
< 7; i
++)
1304 if (qualifiers
[i
].type
== tqArray
)
1306 qualifiers
[i
].low_bound
=
1307 AUX_GET_DNLOW (bigendian
, &aux_ptr
[indx
+2]);
1308 qualifiers
[i
].high_bound
=
1309 AUX_GET_DNHIGH (bigendian
, &aux_ptr
[indx
+3]);
1310 qualifiers
[i
].stride
=
1311 AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
+4]);
1316 /* Now print out the qualifiers. */
1317 for (i
= 0; i
< 6; i
++)
1319 switch (qualifiers
[i
].type
)
1326 strcpy (p2
, "ptr to ");
1327 p2
+= sizeof ("ptr to ")-1;
1331 strcpy (p2
, "volatile ");
1332 p2
+= sizeof ("volatile ")-1;
1336 strcpy (p2
, "far ");
1337 p2
+= sizeof ("far ")-1;
1341 strcpy (p2
, "func. ret. ");
1342 p2
+= sizeof ("func. ret. ");
1347 int first_array
= i
;
1350 /* Print array bounds reversed (ie, in the order the C
1351 programmer writes them). C is such a fun language.... */
1352 while (i
< 5 && qualifiers
[i
+1].type
== tqArray
)
1355 for (j
= i
; j
>= first_array
; j
--)
1357 strcpy (p2
, "array [");
1358 p2
+= sizeof ("array [")-1;
1359 if (qualifiers
[j
].low_bound
!= 0)
1361 "%ld:%ld {%ld bits}",
1362 (long) qualifiers
[j
].low_bound
,
1363 (long) qualifiers
[j
].high_bound
,
1364 (long) qualifiers
[j
].stride
);
1366 else if (qualifiers
[j
].high_bound
!= -1)
1369 (long) (qualifiers
[j
].high_bound
+ 1),
1370 (long) (qualifiers
[j
].stride
));
1373 sprintf (p2
, " {%ld bits}", (long) (qualifiers
[j
].stride
));
1376 strcpy (p2
, "] of ");
1377 p2
+= sizeof ("] of ")-1;
1385 strcpy (p2
, buffer1
);
1389 /* Return information about ECOFF symbol SYMBOL in RET. */
1392 _bfd_ecoff_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
1396 bfd_symbol_info (symbol
, ret
);
1399 /* Return whether this is a local label. */
1402 _bfd_ecoff_bfd_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1405 return name
[0] == '$';
1408 /* Print information about an ECOFF symbol. */
1411 _bfd_ecoff_print_symbol (bfd
*abfd
,
1414 bfd_print_symbol_type how
)
1416 const struct ecoff_debug_swap
* const debug_swap
1417 = &ecoff_backend (abfd
)->debug_swap
;
1418 FILE *file
= (FILE *)filep
;
1422 case bfd_print_symbol_name
:
1423 fprintf (file
, "%s", symbol
->name
);
1425 case bfd_print_symbol_more
:
1426 if (ecoffsymbol (symbol
)->local
)
1430 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1432 fprintf (file
, "ecoff local ");
1433 fprintf_vma (file
, (bfd_vma
) ecoff_sym
.value
);
1434 fprintf (file
, " %x %x", (unsigned) ecoff_sym
.st
,
1435 (unsigned) ecoff_sym
.sc
);
1441 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1443 fprintf (file
, "ecoff extern ");
1444 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1445 fprintf (file
, " %x %x", (unsigned) ecoff_ext
.asym
.st
,
1446 (unsigned) ecoff_ext
.asym
.sc
);
1449 case bfd_print_symbol_all
:
1450 /* Print out the symbols in a reasonable way. */
1459 if (ecoffsymbol (symbol
)->local
)
1461 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1464 pos
= ((((char *) ecoffsymbol (symbol
)->native
1465 - (char *) ecoff_data (abfd
)->debug_info
.external_sym
)
1466 / debug_swap
->external_sym_size
)
1467 + ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
);
1474 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1477 pos
= (((char *) ecoffsymbol (symbol
)->native
1478 - (char *) ecoff_data (abfd
)->debug_info
.external_ext
)
1479 / debug_swap
->external_ext_size
);
1480 jmptbl
= ecoff_ext
.jmptbl
? 'j' : ' ';
1481 cobol_main
= ecoff_ext
.cobol_main
? 'c' : ' ';
1482 weakext
= ecoff_ext
.weakext
? 'w' : ' ';
1485 fprintf (file
, "[%3d] %c ",
1487 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1488 fprintf (file
, " st %x sc %x indx %x %c%c%c %s",
1489 (unsigned) ecoff_ext
.asym
.st
,
1490 (unsigned) ecoff_ext
.asym
.sc
,
1491 (unsigned) ecoff_ext
.asym
.index
,
1492 jmptbl
, cobol_main
, weakext
,
1495 if (ecoffsymbol (symbol
)->fdr
!= NULL
1496 && ecoff_ext
.asym
.index
!= indexNil
)
1501 bfd_size_type sym_base
;
1502 union aux_ext
*aux_base
;
1504 fdr
= ecoffsymbol (symbol
)->fdr
;
1505 indx
= ecoff_ext
.asym
.index
;
1507 /* sym_base is used to map the fdr relative indices which
1508 appear in the file to the position number which we are
1510 sym_base
= fdr
->isymBase
;
1511 if (ecoffsymbol (symbol
)->local
)
1513 ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
1515 /* aux_base is the start of the aux entries for this file;
1516 asym.index is an offset from this. */
1517 aux_base
= (ecoff_data (abfd
)->debug_info
.external_aux
1520 /* The aux entries are stored in host byte order; the
1521 order is indicated by a bit in the fdr. */
1522 bigendian
= fdr
->fBigendian
;
1524 /* This switch is basically from gcc/mips-tdump.c. */
1525 switch (ecoff_ext
.asym
.st
)
1533 fprintf (file
, _("\n End+1 symbol: %ld"),
1534 (long) (indx
+ sym_base
));
1538 if (ecoff_ext
.asym
.sc
== scText
1539 || ecoff_ext
.asym
.sc
== scInfo
)
1540 fprintf (file
, _("\n First symbol: %ld"),
1541 (long) (indx
+ sym_base
));
1543 fprintf (file
, _("\n First symbol: %ld"),
1545 (AUX_GET_ISYM (bigendian
,
1546 &aux_base
[ecoff_ext
.asym
.index
])
1552 if (ECOFF_IS_STAB (&ecoff_ext
.asym
))
1554 else if (ecoffsymbol (symbol
)->local
)
1555 /* xgettext:c-format */
1556 fprintf (file
, _("\n End+1 symbol: %-7ld Type: %s"),
1558 (AUX_GET_ISYM (bigendian
,
1559 &aux_base
[ecoff_ext
.asym
.index
])
1561 ecoff_type_to_string (abfd
, fdr
, indx
+ 1));
1563 fprintf (file
, _("\n Local symbol: %ld"),
1566 + (ecoff_data (abfd
)
1567 ->debug_info
.symbolic_header
.iextMax
)));
1571 fprintf (file
, _("\n struct; End+1 symbol: %ld"),
1572 (long) (indx
+ sym_base
));
1576 fprintf (file
, _("\n union; End+1 symbol: %ld"),
1577 (long) (indx
+ sym_base
));
1581 fprintf (file
, _("\n enum; End+1 symbol: %ld"),
1582 (long) (indx
+ sym_base
));
1586 if (! ECOFF_IS_STAB (&ecoff_ext
.asym
))
1587 fprintf (file
, _("\n Type: %s"),
1588 ecoff_type_to_string (abfd
, fdr
, indx
));
1597 /* Read in the relocs for a section. */
1600 ecoff_slurp_reloc_table (bfd
*abfd
,
1604 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1605 arelent
*internal_relocs
;
1606 bfd_size_type external_reloc_size
;
1608 bfd_byte
*external_relocs
;
1612 if (section
->relocation
!= NULL
1613 || section
->reloc_count
== 0
1614 || (section
->flags
& SEC_CONSTRUCTOR
) != 0)
1617 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1620 external_reloc_size
= backend
->external_reloc_size
;
1621 amt
= external_reloc_size
* section
->reloc_count
;
1622 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1624 external_relocs
= _bfd_alloc_and_read (abfd
, amt
, amt
);
1625 if (external_relocs
== NULL
)
1628 amt
= section
->reloc_count
;
1629 amt
*= sizeof (arelent
);
1630 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
1631 if (internal_relocs
== NULL
)
1633 bfd_release (abfd
, external_relocs
);
1637 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1639 struct internal_reloc intern
;
1641 (*backend
->swap_reloc_in
) (abfd
,
1642 external_relocs
+ i
* external_reloc_size
,
1645 if (intern
.r_extern
)
1647 /* r_symndx is an index into the external symbols. */
1648 BFD_ASSERT (intern
.r_symndx
>= 0
1650 < (ecoff_data (abfd
)
1651 ->debug_info
.symbolic_header
.iextMax
)));
1652 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1655 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1656 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1658 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1663 const char *sec_name
;
1666 /* r_symndx is a section key. */
1667 switch (intern
.r_symndx
)
1669 case RELOC_SECTION_TEXT
: sec_name
= _TEXT
; break;
1670 case RELOC_SECTION_RDATA
: sec_name
= _RDATA
; break;
1671 case RELOC_SECTION_DATA
: sec_name
= _DATA
; break;
1672 case RELOC_SECTION_SDATA
: sec_name
= _SDATA
; break;
1673 case RELOC_SECTION_SBSS
: sec_name
= _SBSS
; break;
1674 case RELOC_SECTION_BSS
: sec_name
= _BSS
; break;
1675 case RELOC_SECTION_INIT
: sec_name
= _INIT
; break;
1676 case RELOC_SECTION_LIT8
: sec_name
= _LIT8
; break;
1677 case RELOC_SECTION_LIT4
: sec_name
= _LIT4
; break;
1678 case RELOC_SECTION_XDATA
: sec_name
= _XDATA
; break;
1679 case RELOC_SECTION_PDATA
: sec_name
= _PDATA
; break;
1680 case RELOC_SECTION_FINI
: sec_name
= _FINI
; break;
1681 case RELOC_SECTION_LITA
: sec_name
= _LITA
; break;
1682 case RELOC_SECTION_RCONST
: sec_name
= _RCONST
; break;
1686 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1689 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1691 rptr
->addend
= - bfd_section_vma (sec
);
1694 rptr
->address
= intern
.r_vaddr
- bfd_section_vma (section
);
1696 /* Let the backend select the howto field and do any other
1697 required processing. */
1698 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1701 bfd_release (abfd
, external_relocs
);
1703 section
->relocation
= internal_relocs
;
1708 /* Get a canonical list of relocs. */
1711 _bfd_ecoff_canonicalize_reloc (bfd
*abfd
,
1718 if (section
->flags
& SEC_CONSTRUCTOR
)
1720 arelent_chain
*chain
;
1722 /* This section has relocs made up by us, not the file, so take
1723 them out of their chain and place them into the data area
1725 for (count
= 0, chain
= section
->constructor_chain
;
1726 count
< section
->reloc_count
;
1727 count
++, chain
= chain
->next
)
1728 *relptr
++ = &chain
->relent
;
1734 if (! ecoff_slurp_reloc_table (abfd
, section
, symbols
))
1737 tblptr
= section
->relocation
;
1739 for (count
= 0; count
< section
->reloc_count
; count
++)
1740 *relptr
++ = tblptr
++;
1745 return section
->reloc_count
;
1748 /* Provided a BFD, a section and an offset into the section, calculate
1749 and return the name of the source file and the line nearest to the
1753 _bfd_ecoff_find_nearest_line (bfd
*abfd
,
1754 asymbol
**symbols ATTRIBUTE_UNUSED
,
1757 const char **filename_ptr
,
1758 const char **functionname_ptr
,
1759 unsigned int *retline_ptr
,
1760 unsigned int *discriminator_ptr
)
1762 const struct ecoff_debug_swap
* const debug_swap
1763 = &ecoff_backend (abfd
)->debug_swap
;
1764 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1765 struct ecoff_find_line
*line_info
;
1767 /* Make sure we have the FDR's. */
1768 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
, debug_info
)
1769 || bfd_get_symcount (abfd
) == 0)
1772 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1774 size_t amt
= sizeof (struct ecoff_find_line
);
1776 ecoff_data (abfd
)->find_line_info
=
1777 (struct ecoff_find_line
*) bfd_zalloc (abfd
, amt
);
1778 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1782 if (discriminator_ptr
)
1783 *discriminator_ptr
= 0;
1784 line_info
= ecoff_data (abfd
)->find_line_info
;
1785 return _bfd_ecoff_locate_line (abfd
, section
, offset
, debug_info
,
1786 debug_swap
, line_info
, filename_ptr
,
1787 functionname_ptr
, retline_ptr
);
1790 /* Copy private BFD data. This is called by objcopy and strip. We
1791 use it to copy the ECOFF debugging information from one BFD to the
1792 other. It would be theoretically possible to represent the ECOFF
1793 debugging information in the symbol table. However, it would be a
1794 lot of work, and there would be little gain (gas, gdb, and ld
1795 already access the ECOFF debugging information via the
1796 ecoff_debug_info structure, and that structure would have to be
1797 retained in order to support ECOFF debugging in MIPS ELF).
1799 The debugging information for the ECOFF external symbols comes from
1800 the symbol table, so this function only handles the other debugging
1804 _bfd_ecoff_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1806 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
1807 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
1809 asymbol
**sym_ptr_ptr
;
1813 /* We only want to copy information over if both BFD's use ECOFF
1815 if (bfd_get_flavour (ibfd
) != bfd_target_ecoff_flavour
1816 || bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
1819 /* Copy the GP value and the register masks. */
1820 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
1821 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
1822 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
1823 for (i
= 0; i
< 3; i
++)
1824 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
1826 /* Copy the version stamp. */
1827 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
1829 /* If there are no symbols, don't copy any debugging information. */
1830 c
= bfd_get_symcount (obfd
);
1831 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1832 if (c
== 0 || sym_ptr_ptr
== NULL
)
1835 /* See if there are any local symbols. */
1837 for (; c
> 0; c
--, sym_ptr_ptr
++)
1839 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
1848 /* There are some local symbols. We just bring over all the
1849 debugging information. FIXME: This is not quite the right
1850 thing to do. If the user has asked us to discard all
1851 debugging information, then we are probably going to wind up
1852 keeping it because there will probably be some local symbol
1853 which objcopy did not discard. We should actually break
1854 apart the debugging information and only keep that which
1855 applies to the symbols we want to keep. */
1856 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
1857 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
1858 oinfo
->line
= iinfo
->line
;
1860 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
1861 oinfo
->external_dnr
= iinfo
->external_dnr
;
1863 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
1864 oinfo
->external_pdr
= iinfo
->external_pdr
;
1866 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
1867 oinfo
->external_sym
= iinfo
->external_sym
;
1869 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
1870 oinfo
->external_opt
= iinfo
->external_opt
;
1872 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
1873 oinfo
->external_aux
= iinfo
->external_aux
;
1875 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
1876 oinfo
->ss
= iinfo
->ss
;
1878 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
1879 oinfo
->external_fdr
= iinfo
->external_fdr
;
1881 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
1882 oinfo
->external_rfd
= iinfo
->external_rfd
;
1886 /* We are discarding all the local symbol information. Look
1887 through the external symbols and remove all references to FDR
1888 or aux information. */
1889 c
= bfd_get_symcount (obfd
);
1890 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1891 for (; c
> 0; c
--, sym_ptr_ptr
++)
1895 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
1896 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
1898 esym
.asym
.index
= indexNil
;
1899 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
1900 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
1907 /* Set the architecture. The supported architecture is stored in the
1908 backend pointer. We always set the architecture anyhow, since many
1909 callers ignore the return value. */
1912 _bfd_ecoff_set_arch_mach (bfd
*abfd
,
1913 enum bfd_architecture arch
,
1914 unsigned long machine
)
1916 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1917 return arch
== ecoff_backend (abfd
)->arch
;
1920 /* Get the size of the section headers. */
1923 _bfd_ecoff_sizeof_headers (bfd
*abfd
,
1924 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1931 for (current
= abfd
->sections
;
1933 current
= current
->next
)
1936 ret
= (bfd_coff_filhsz (abfd
)
1937 + bfd_coff_aoutsz (abfd
)
1938 + c
* bfd_coff_scnhsz (abfd
));
1939 return (int) BFD_ALIGN (ret
, 16);
1942 /* Get the contents of a section. */
1945 _bfd_ecoff_get_section_contents (bfd
*abfd
,
1949 bfd_size_type count
)
1951 return _bfd_generic_get_section_contents (abfd
, section
, location
,
1955 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
1956 called via qsort. */
1959 ecoff_sort_hdrs (const void * arg1
, const void * arg2
)
1961 const asection
*hdr1
= *(const asection
**) arg1
;
1962 const asection
*hdr2
= *(const asection
**) arg2
;
1964 if ((hdr1
->flags
& SEC_ALLOC
) != 0)
1966 if ((hdr2
->flags
& SEC_ALLOC
) == 0)
1971 if ((hdr2
->flags
& SEC_ALLOC
) != 0)
1974 if (hdr1
->vma
< hdr2
->vma
)
1976 else if (hdr1
->vma
> hdr2
->vma
)
1982 /* Calculate the file position for each section, and set
1986 ecoff_compute_section_file_positions (bfd
*abfd
)
1988 file_ptr sofar
, file_sofar
;
1989 asection
**sorted_hdrs
;
1993 bfd_boolean rdata_in_text
;
1994 bfd_boolean first_data
, first_nonalloc
;
1995 const bfd_vma round
= ecoff_backend (abfd
)->round
;
1998 sofar
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2001 /* Sort the sections by VMA. */
2002 amt
= abfd
->section_count
;
2003 amt
*= sizeof (asection
*);
2004 sorted_hdrs
= (asection
**) bfd_malloc (amt
);
2005 if (sorted_hdrs
== NULL
)
2007 for (current
= abfd
->sections
, i
= 0;
2009 current
= current
->next
, i
++)
2010 sorted_hdrs
[i
] = current
;
2011 BFD_ASSERT (i
== abfd
->section_count
);
2013 qsort (sorted_hdrs
, abfd
->section_count
, sizeof (asection
*),
2016 /* Some versions of the OSF linker put the .rdata section in the
2017 text segment, and some do not. */
2018 rdata_in_text
= ecoff_backend (abfd
)->rdata_in_text
;
2021 for (i
= 0; i
< abfd
->section_count
; i
++)
2023 current
= sorted_hdrs
[i
];
2024 if (streq (current
->name
, _RDATA
))
2026 if ((current
->flags
& SEC_CODE
) == 0
2027 && ! streq (current
->name
, _PDATA
)
2028 && ! streq (current
->name
, _RCONST
))
2030 rdata_in_text
= FALSE
;
2035 ecoff_data (abfd
)->rdata_in_text
= rdata_in_text
;
2038 first_nonalloc
= TRUE
;
2039 for (i
= 0; i
< abfd
->section_count
; i
++)
2041 unsigned int alignment_power
;
2043 current
= sorted_hdrs
[i
];
2045 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2046 supposed to indicate the number of .pdata entries that are
2047 really in the section. Each entry is 8 bytes. We store this
2048 away in line_filepos before increasing the section size. */
2049 if (streq (current
->name
, _PDATA
))
2050 current
->line_filepos
= current
->size
/ 8;
2052 alignment_power
= current
->alignment_power
;
2054 /* On Ultrix, the data sections in an executable file must be
2055 aligned to a page boundary within the file. This does not
2056 affect the section size, though. FIXME: Does this work for
2057 other platforms? It requires some modification for the
2058 Alpha, because .rdata on the Alpha goes with the text, not
2060 if ((abfd
->flags
& EXEC_P
) != 0
2061 && (abfd
->flags
& D_PAGED
) != 0
2063 && (current
->flags
& SEC_CODE
) == 0
2065 || ! streq (current
->name
, _RDATA
))
2066 && ! streq (current
->name
, _PDATA
)
2067 && ! streq (current
->name
, _RCONST
))
2069 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2070 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2073 else if (streq (current
->name
, _LIB
))
2075 /* On Irix 4, the location of contents of the .lib section
2076 from a shared library section is also rounded up to a
2079 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2080 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2082 else if (first_nonalloc
2083 && (current
->flags
& SEC_ALLOC
) == 0
2084 && (abfd
->flags
& D_PAGED
) != 0)
2086 /* Skip up to the next page for an unallocated section, such
2087 as the .comment section on the Alpha. This leaves room
2088 for the .bss section. */
2089 first_nonalloc
= FALSE
;
2090 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2091 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2094 /* Align the sections in the file to the same boundary on
2095 which they are aligned in virtual memory. */
2096 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2097 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2098 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2100 if ((abfd
->flags
& D_PAGED
) != 0
2101 && (current
->flags
& SEC_ALLOC
) != 0)
2103 sofar
+= (current
->vma
- sofar
) % round
;
2104 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2105 file_sofar
+= (current
->vma
- file_sofar
) % round
;
2108 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) != 0)
2109 current
->filepos
= file_sofar
;
2111 sofar
+= current
->size
;
2112 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2113 file_sofar
+= current
->size
;
2115 /* Make sure that this section is of the right size too. */
2117 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2118 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2119 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2120 current
->size
+= sofar
- old_sofar
;
2126 ecoff_data (abfd
)->reloc_filepos
= file_sofar
;
2131 /* Determine the location of the relocs for all the sections in the
2132 output file, as well as the location of the symbolic debugging
2135 static bfd_size_type
2136 ecoff_compute_reloc_file_positions (bfd
*abfd
)
2138 const bfd_size_type external_reloc_size
=
2139 ecoff_backend (abfd
)->external_reloc_size
;
2140 file_ptr reloc_base
;
2141 bfd_size_type reloc_size
;
2145 if (! abfd
->output_has_begun
)
2147 if (! ecoff_compute_section_file_positions (abfd
))
2149 abfd
->output_has_begun
= TRUE
;
2152 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2155 for (current
= abfd
->sections
;
2157 current
= current
->next
)
2159 if (current
->reloc_count
== 0)
2160 current
->rel_filepos
= 0;
2163 bfd_size_type relsize
;
2165 current
->rel_filepos
= reloc_base
;
2166 relsize
= current
->reloc_count
* external_reloc_size
;
2167 reloc_size
+= relsize
;
2168 reloc_base
+= relsize
;
2172 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2174 /* At least on Ultrix, the symbol table of an executable file must
2175 be aligned to a page boundary. FIXME: Is this true on other
2177 if ((abfd
->flags
& EXEC_P
) != 0
2178 && (abfd
->flags
& D_PAGED
) != 0)
2179 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2180 &~ (ecoff_backend (abfd
)->round
- 1));
2182 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2187 /* Set the contents of a section. */
2190 _bfd_ecoff_set_section_contents (bfd
*abfd
,
2192 const void * location
,
2194 bfd_size_type count
)
2198 /* This must be done first, because bfd_set_section_contents is
2199 going to set output_has_begun to TRUE. */
2200 if (! abfd
->output_has_begun
2201 && ! ecoff_compute_section_file_positions (abfd
))
2204 /* Handle the .lib section specially so that Irix 4 shared libraries
2205 work out. See coff_set_section_contents in coffcode.h. */
2206 if (streq (section
->name
, _LIB
))
2208 bfd_byte
*rec
, *recend
;
2210 rec
= (bfd_byte
*) location
;
2211 recend
= rec
+ count
;
2212 while (rec
< recend
)
2215 rec
+= bfd_get_32 (abfd
, rec
) * 4;
2218 BFD_ASSERT (rec
== recend
);
2224 pos
= section
->filepos
+ offset
;
2225 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2226 || bfd_bwrite (location
, count
, abfd
) != count
)
2232 /* Set the GP value for an ECOFF file. This is a hook used by the
2236 bfd_ecoff_set_gp_value (bfd
*abfd
, bfd_vma gp_value
)
2238 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2239 || bfd_get_format (abfd
) != bfd_object
)
2241 bfd_set_error (bfd_error_invalid_operation
);
2245 ecoff_data (abfd
)->gp
= gp_value
;
2250 /* Set the register masks for an ECOFF file. This is a hook used by
2254 bfd_ecoff_set_regmasks (bfd
*abfd
,
2255 unsigned long gprmask
,
2256 unsigned long fprmask
,
2257 unsigned long *cprmask
)
2259 ecoff_data_type
*tdata
;
2261 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2262 || bfd_get_format (abfd
) != bfd_object
)
2264 bfd_set_error (bfd_error_invalid_operation
);
2268 tdata
= ecoff_data (abfd
);
2269 tdata
->gprmask
= gprmask
;
2270 tdata
->fprmask
= fprmask
;
2271 if (cprmask
!= NULL
)
2275 for (i
= 0; i
< 3; i
++)
2276 tdata
->cprmask
[i
] = cprmask
[i
];
2282 /* Get ECOFF EXTR information for an external symbol. This function
2283 is passed to bfd_ecoff_debug_externals. */
2286 ecoff_get_extr (asymbol
*sym
, EXTR
*esym
)
2288 ecoff_symbol_type
*ecoff_sym_ptr
;
2291 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2292 || ecoffsymbol (sym
)->native
== NULL
)
2294 /* Don't include debugging, local, or section symbols. */
2295 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2296 || (sym
->flags
& BSF_LOCAL
) != 0
2297 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2301 esym
->cobol_main
= 0;
2302 esym
->weakext
= (sym
->flags
& BSF_WEAK
) != 0;
2305 /* FIXME: we can do better than this for st and sc. */
2306 esym
->asym
.st
= stGlobal
;
2307 esym
->asym
.sc
= scAbs
;
2308 esym
->asym
.reserved
= 0;
2309 esym
->asym
.index
= indexNil
;
2313 ecoff_sym_ptr
= ecoffsymbol (sym
);
2315 if (ecoff_sym_ptr
->local
)
2318 input_bfd
= bfd_asymbol_bfd (sym
);
2319 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2320 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2322 /* If the symbol was defined by the linker, then esym will be
2323 undefined but sym will not be. Get a better class for such a
2325 if ((esym
->asym
.sc
== scUndefined
2326 || esym
->asym
.sc
== scSUndefined
)
2327 && ! bfd_is_und_section (bfd_asymbol_section (sym
)))
2328 esym
->asym
.sc
= scAbs
;
2330 /* Adjust the FDR index for the symbol by that used for the input
2332 if (esym
->ifd
!= -1)
2334 struct ecoff_debug_info
*input_debug
;
2336 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2337 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2338 if (input_debug
->ifdmap
!= NULL
)
2339 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2345 /* Set the external symbol index. This routine is passed to
2346 bfd_ecoff_debug_externals. */
2349 ecoff_set_index (asymbol
*sym
, bfd_size_type indx
)
2351 ecoff_set_sym_index (sym
, indx
);
2354 /* Write out an ECOFF file. */
2357 _bfd_ecoff_write_object_contents (bfd
*abfd
)
2359 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2360 const bfd_vma round
= backend
->round
;
2361 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2362 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2363 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2364 const bfd_size_type external_hdr_size
2365 = backend
->debug_swap
.external_hdr_size
;
2366 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2367 void (* const adjust_reloc_out
) (bfd
*, const arelent
*, struct internal_reloc
*)
2368 = backend
->adjust_reloc_out
;
2369 void (* const swap_reloc_out
) (bfd
*, const struct internal_reloc
*, void *)
2370 = backend
->swap_reloc_out
;
2371 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2372 HDRR
* const symhdr
= &debug
->symbolic_header
;
2375 bfd_size_type reloc_size
;
2376 bfd_size_type text_size
;
2378 bfd_boolean set_text_start
;
2379 bfd_size_type data_size
;
2381 bfd_boolean set_data_start
;
2382 bfd_size_type bss_size
;
2384 void * reloc_buff
= NULL
;
2385 struct internal_filehdr internal_f
;
2386 struct internal_aouthdr internal_a
;
2389 /* Determine where the sections and relocs will go in the output
2391 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2394 for (current
= abfd
->sections
;
2396 current
= current
->next
)
2398 current
->target_index
= count
;
2402 if ((abfd
->flags
& D_PAGED
) != 0)
2403 text_size
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2407 set_text_start
= FALSE
;
2410 set_data_start
= FALSE
;
2413 /* Write section headers to the file. */
2415 /* Allocate buff big enough to hold a section header,
2416 file header, or a.out header. */
2425 buff
= bfd_malloc (siz
);
2430 internal_f
.f_nscns
= 0;
2431 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2434 for (current
= abfd
->sections
;
2436 current
= current
->next
)
2438 struct internal_scnhdr section
;
2441 ++internal_f
.f_nscns
;
2443 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2445 /* This seems to be correct for Irix 4 shared libraries. */
2446 vma
= bfd_section_vma (current
);
2447 if (streq (current
->name
, _LIB
))
2448 section
.s_vaddr
= 0;
2450 section
.s_vaddr
= vma
;
2452 section
.s_paddr
= current
->lma
;
2453 section
.s_size
= current
->size
;
2455 /* If this section is unloadable then the scnptr will be 0. */
2456 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2457 section
.s_scnptr
= 0;
2459 section
.s_scnptr
= current
->filepos
;
2460 section
.s_relptr
= current
->rel_filepos
;
2462 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2463 object file produced by the assembler is supposed to point to
2464 information about how much room is required by objects of
2465 various different sizes. I think this only matters if we
2466 want the linker to compute the best size to use, or
2467 something. I don't know what happens if the information is
2469 if (! streq (current
->name
, _PDATA
))
2470 section
.s_lnnoptr
= 0;
2473 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2474 hold the number of entries in the section (each entry is
2475 8 bytes). We stored this in the line_filepos field in
2476 ecoff_compute_section_file_positions. */
2477 section
.s_lnnoptr
= current
->line_filepos
;
2480 section
.s_nreloc
= current
->reloc_count
;
2481 section
.s_nlnno
= 0;
2482 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2485 if (bfd_coff_swap_scnhdr_out (abfd
, (void *) §ion
, buff
) == 0
2486 || bfd_bwrite (buff
, scnhsz
, abfd
) != scnhsz
)
2489 if ((section
.s_flags
& STYP_TEXT
) != 0
2490 || ((section
.s_flags
& STYP_RDATA
) != 0
2491 && ecoff_data (abfd
)->rdata_in_text
)
2492 || section
.s_flags
== STYP_PDATA
2493 || (section
.s_flags
& STYP_DYNAMIC
) != 0
2494 || (section
.s_flags
& STYP_LIBLIST
) != 0
2495 || (section
.s_flags
& STYP_RELDYN
) != 0
2496 || section
.s_flags
== STYP_CONFLIC
2497 || (section
.s_flags
& STYP_DYNSTR
) != 0
2498 || (section
.s_flags
& STYP_DYNSYM
) != 0
2499 || (section
.s_flags
& STYP_HASH
) != 0
2500 || (section
.s_flags
& STYP_ECOFF_INIT
) != 0
2501 || (section
.s_flags
& STYP_ECOFF_FINI
) != 0
2502 || section
.s_flags
== STYP_RCONST
)
2504 text_size
+= current
->size
;
2505 if (! set_text_start
|| text_start
> vma
)
2508 set_text_start
= TRUE
;
2511 else if ((section
.s_flags
& STYP_RDATA
) != 0
2512 || (section
.s_flags
& STYP_DATA
) != 0
2513 || (section
.s_flags
& STYP_LITA
) != 0
2514 || (section
.s_flags
& STYP_LIT8
) != 0
2515 || (section
.s_flags
& STYP_LIT4
) != 0
2516 || (section
.s_flags
& STYP_SDATA
) != 0
2517 || section
.s_flags
== STYP_XDATA
2518 || (section
.s_flags
& STYP_GOT
) != 0)
2520 data_size
+= current
->size
;
2521 if (! set_data_start
|| data_start
> vma
)
2524 set_data_start
= TRUE
;
2527 else if ((section
.s_flags
& STYP_BSS
) != 0
2528 || (section
.s_flags
& STYP_SBSS
) != 0)
2529 bss_size
+= current
->size
;
2530 else if (section
.s_flags
== 0
2531 || (section
.s_flags
& STYP_ECOFF_LIB
) != 0
2532 || section
.s_flags
== STYP_COMMENT
)
2538 /* Set up the file header. */
2539 internal_f
.f_magic
= ecoff_get_magic (abfd
);
2541 /* We will NOT put a fucking timestamp in the header here. Every
2542 time you put it back, I will come in and take it out again. I'm
2543 sorry. This field does not belong here. We fill it with a 0 so
2544 it compares the same but is not a reasonable time. --
2546 internal_f
.f_timdat
= 0;
2548 if (bfd_get_symcount (abfd
) != 0)
2550 /* The ECOFF f_nsyms field is not actually the number of
2551 symbols, it's the size of symbolic information header. */
2552 internal_f
.f_nsyms
= external_hdr_size
;
2553 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
2557 internal_f
.f_nsyms
= 0;
2558 internal_f
.f_symptr
= 0;
2561 internal_f
.f_opthdr
= aoutsz
;
2563 internal_f
.f_flags
= F_LNNO
;
2564 if (reloc_size
== 0)
2565 internal_f
.f_flags
|= F_RELFLG
;
2566 if (bfd_get_symcount (abfd
) == 0)
2567 internal_f
.f_flags
|= F_LSYMS
;
2568 if (abfd
->flags
& EXEC_P
)
2569 internal_f
.f_flags
|= F_EXEC
;
2571 if (bfd_little_endian (abfd
))
2572 internal_f
.f_flags
|= F_AR32WR
;
2574 internal_f
.f_flags
|= F_AR32W
;
2576 /* Set up the ``optional'' header. */
2577 if ((abfd
->flags
& D_PAGED
) != 0)
2578 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
2580 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
2582 /* FIXME: Is this really correct? */
2583 internal_a
.vstamp
= symhdr
->vstamp
;
2585 /* At least on Ultrix, these have to be rounded to page boundaries.
2586 FIXME: Is this true on other platforms? */
2587 if ((abfd
->flags
& D_PAGED
) != 0)
2589 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
2590 internal_a
.text_start
= text_start
&~ (round
- 1);
2591 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
2592 internal_a
.data_start
= data_start
&~ (round
- 1);
2596 internal_a
.tsize
= text_size
;
2597 internal_a
.text_start
= text_start
;
2598 internal_a
.dsize
= data_size
;
2599 internal_a
.data_start
= data_start
;
2602 /* On Ultrix, the initial portions of the .sbss and .bss segments
2603 are at the end of the data section. The bsize field in the
2604 optional header records how many bss bytes are required beyond
2605 those in the data section. The value is not rounded to a page
2607 if (bss_size
< internal_a
.dsize
- data_size
)
2610 bss_size
-= internal_a
.dsize
- data_size
;
2611 internal_a
.bsize
= bss_size
;
2612 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
2614 internal_a
.entry
= bfd_get_start_address (abfd
);
2616 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
2618 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
2619 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
2620 for (i
= 0; i
< 4; i
++)
2621 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
2623 /* Let the backend adjust the headers if necessary. */
2624 if (backend
->adjust_headers
)
2626 if (! (*backend
->adjust_headers
) (abfd
, &internal_f
, &internal_a
))
2630 /* Write out the file header and the optional header. */
2631 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2634 bfd_coff_swap_filehdr_out (abfd
, (void *) &internal_f
, buff
);
2635 if (bfd_bwrite (buff
, filhsz
, abfd
) != filhsz
)
2638 bfd_coff_swap_aouthdr_out (abfd
, (void *) &internal_a
, buff
);
2639 if (bfd_bwrite (buff
, aoutsz
, abfd
) != aoutsz
)
2642 /* Build the external symbol information. This must be done before
2643 writing out the relocs so that we know the symbol indices. We
2644 don't do this if this BFD was created by the backend linker,
2645 since it will have already handled the symbols and relocs. */
2646 if (! ecoff_data (abfd
)->linker
)
2648 symhdr
->iextMax
= 0;
2649 symhdr
->issExtMax
= 0;
2650 debug
->external_ext
= debug
->external_ext_end
= NULL
;
2651 debug
->ssext
= debug
->ssext_end
= NULL
;
2652 if (! bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
2653 (abfd
->flags
& EXEC_P
) == 0,
2654 ecoff_get_extr
, ecoff_set_index
))
2657 /* Write out the relocs. */
2658 for (current
= abfd
->sections
;
2660 current
= current
->next
)
2662 arelent
**reloc_ptr_ptr
;
2663 arelent
**reloc_end
;
2667 if (current
->reloc_count
== 0)
2670 amt
= current
->reloc_count
* external_reloc_size
;
2671 reloc_buff
= bfd_alloc (abfd
, amt
);
2672 if (reloc_buff
== NULL
)
2675 reloc_ptr_ptr
= current
->orelocation
;
2676 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
2677 out_ptr
= (char *) reloc_buff
;
2680 reloc_ptr_ptr
< reloc_end
;
2681 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
2685 struct internal_reloc in
;
2687 memset ((void *) &in
, 0, sizeof in
);
2689 reloc
= *reloc_ptr_ptr
;
2690 sym
= *reloc
->sym_ptr_ptr
;
2692 /* If the howto field has not been initialised then skip this reloc.
2693 This assumes that an error message has been issued elsewhere. */
2694 if (reloc
->howto
== NULL
)
2697 in
.r_vaddr
= reloc
->address
+ bfd_section_vma (current
);
2698 in
.r_type
= reloc
->howto
->type
;
2700 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2702 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2716 { _TEXT
, RELOC_SECTION_TEXT
},
2717 { _RDATA
, RELOC_SECTION_RDATA
},
2718 { _DATA
, RELOC_SECTION_DATA
},
2719 { _SDATA
, RELOC_SECTION_SDATA
},
2720 { _SBSS
, RELOC_SECTION_SBSS
},
2721 { _BSS
, RELOC_SECTION_BSS
},
2722 { _INIT
, RELOC_SECTION_INIT
},
2723 { _LIT8
, RELOC_SECTION_LIT8
},
2724 { _LIT4
, RELOC_SECTION_LIT4
},
2725 { _XDATA
, RELOC_SECTION_XDATA
},
2726 { _PDATA
, RELOC_SECTION_PDATA
},
2727 { _FINI
, RELOC_SECTION_FINI
},
2728 { _LITA
, RELOC_SECTION_LITA
},
2729 { "*ABS*", RELOC_SECTION_ABS
},
2730 { _RCONST
, RELOC_SECTION_RCONST
}
2733 name
= bfd_section_name (bfd_asymbol_section (sym
));
2735 for (j
= 0; j
< ARRAY_SIZE (section_symndx
); j
++)
2736 if (streq (name
, section_symndx
[j
].name
))
2738 in
.r_symndx
= section_symndx
[j
].r_symndx
;
2742 if (j
== ARRAY_SIZE (section_symndx
))
2747 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2749 (*swap_reloc_out
) (abfd
, &in
, (void *) out_ptr
);
2752 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2754 amt
= current
->reloc_count
* external_reloc_size
;
2755 if (bfd_bwrite (reloc_buff
, amt
, abfd
) != amt
)
2757 bfd_release (abfd
, reloc_buff
);
2761 /* Write out the symbolic debugging information. */
2762 if (bfd_get_symcount (abfd
) > 0)
2764 /* Write out the debugging information. */
2765 if (! bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2766 ecoff_data (abfd
)->sym_filepos
))
2771 /* The .bss section of a demand paged executable must receive an
2772 entire page. If there are symbols, the symbols will start on the
2773 next page. If there are no symbols, we must fill out the page by
2775 if (bfd_get_symcount (abfd
) == 0
2776 && (abfd
->flags
& EXEC_P
) != 0
2777 && (abfd
->flags
& D_PAGED
) != 0)
2781 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2784 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) == 0)
2786 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2789 if (bfd_bwrite (&c
, (bfd_size_type
) 1, abfd
) != 1)
2793 if (reloc_buff
!= NULL
)
2794 bfd_release (abfd
, reloc_buff
);
2799 if (reloc_buff
!= NULL
)
2800 bfd_release (abfd
, reloc_buff
);
2806 /* Archive handling. ECOFF uses what appears to be a unique type of
2807 archive header (armap). The byte ordering of the armap and the
2808 contents are encoded in the name of the armap itself. At least for
2809 now, we only support archives with the same byte ordering in the
2810 armap and the contents.
2812 The first four bytes in the armap are the number of symbol
2813 definitions. This is always a power of two.
2815 This is followed by the symbol definitions. Each symbol definition
2816 occupies 8 bytes. The first four bytes are the offset from the
2817 start of the armap strings to the null-terminated string naming
2818 this symbol. The second four bytes are the file offset to the
2819 archive member which defines this symbol. If the second four bytes
2820 are 0, then this is not actually a symbol definition, and it should
2823 The symbols are hashed into the armap with a closed hashing scheme.
2824 See the functions below for the details of the algorithm.
2826 After the symbol definitions comes four bytes holding the size of
2827 the string table, followed by the string table itself. */
2829 /* The name of an archive headers looks like this:
2830 __________E[BL]E[BL]_ (with a trailing space).
2831 The trailing space is changed to an X if the archive is changed to
2832 indicate that the armap is out of date.
2834 The Alpha seems to use ________64E[BL]E[BL]_. */
2836 #define ARMAP_BIG_ENDIAN 'B'
2837 #define ARMAP_LITTLE_ENDIAN 'L'
2838 #define ARMAP_MARKER 'E'
2839 #define ARMAP_START_LENGTH 10
2840 #define ARMAP_HEADER_MARKER_INDEX 10
2841 #define ARMAP_HEADER_ENDIAN_INDEX 11
2842 #define ARMAP_OBJECT_MARKER_INDEX 12
2843 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2844 #define ARMAP_END_INDEX 14
2845 #define ARMAP_END "_ "
2847 /* This is a magic number used in the hashing algorithm. */
2848 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2850 /* This returns the hash value to use for a string. It also sets
2851 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2852 is the number of entries in the hash table, and HLOG is the log
2856 ecoff_armap_hash (const char *s
,
2857 unsigned int *rehash
,
2867 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2868 hash
*= ARMAP_HASH_MAGIC
;
2869 *rehash
= (hash
& (size
- 1)) | 1;
2870 return hash
>> (32 - hlog
);
2873 /* Read in the armap. */
2876 _bfd_ecoff_slurp_armap (bfd
*abfd
)
2880 struct areltdata
*mapdata
;
2881 bfd_size_type parsed_size
;
2883 struct artdata
*ardata
;
2890 /* Get the name of the first element. */
2891 i
= bfd_bread ((void *) nextname
, (bfd_size_type
) 16, abfd
);
2897 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2900 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2901 standard COFF armap. We could move the ECOFF armap stuff into
2902 bfd_slurp_armap, but that seems inappropriate since no other
2903 target uses this format. Instead, we check directly for a COFF
2905 if (CONST_STRNEQ (nextname
, "/ "))
2906 return bfd_slurp_armap (abfd
);
2908 /* See if the first element is an armap. */
2909 if (! strneq (nextname
, ecoff_backend (abfd
)->armap_start
, ARMAP_START_LENGTH
)
2910 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
2911 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2912 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2913 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
2914 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2915 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2916 || ! strneq (nextname
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1))
2918 abfd
->has_armap
= FALSE
;
2922 /* Make sure we have the right byte ordering. */
2923 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2924 ^ (bfd_header_big_endian (abfd
)))
2925 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2926 ^ (bfd_big_endian (abfd
))))
2928 bfd_set_error (bfd_error_wrong_format
);
2932 /* Read in the armap. */
2933 ardata
= bfd_ardata (abfd
);
2934 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
2935 if (mapdata
== NULL
)
2937 parsed_size
= mapdata
->parsed_size
;
2940 raw_armap
= (char *) _bfd_alloc_and_read (abfd
, parsed_size
, parsed_size
);
2941 if (raw_armap
== NULL
)
2943 if (bfd_get_error () != bfd_error_system_call
)
2944 bfd_set_error (bfd_error_malformed_archive
);
2948 ardata
->tdata
= (void *) raw_armap
;
2950 count
= H_GET_32 (abfd
, raw_armap
);
2952 ardata
->symdef_count
= 0;
2953 ardata
->cache
= NULL
;
2955 /* This code used to overlay the symdefs over the raw archive data,
2956 but that doesn't work on a 64 bit host. */
2957 stringbase
= raw_armap
+ count
* 8 + 8;
2959 #ifdef CHECK_ARMAP_HASH
2963 /* Double check that I have the hashing algorithm right by making
2964 sure that every symbol can be looked up successfully. */
2966 for (i
= 1; i
< count
; i
<<= 1)
2968 BFD_ASSERT (i
== count
);
2970 raw_ptr
= raw_armap
+ 4;
2971 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2973 unsigned int name_offset
, file_offset
;
2974 unsigned int hash
, rehash
, srch
;
2976 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2977 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2978 if (file_offset
== 0)
2980 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
2985 /* See if we can rehash to this location. */
2986 for (srch
= (hash
+ rehash
) & (count
- 1);
2987 srch
!= hash
&& srch
!= i
;
2988 srch
= (srch
+ rehash
) & (count
- 1))
2989 BFD_ASSERT (H_GET_32 (abfd
, (raw_armap
+ 8 + srch
* 8)) != 0);
2990 BFD_ASSERT (srch
== i
);
2994 #endif /* CHECK_ARMAP_HASH */
2996 raw_ptr
= raw_armap
+ 4;
2997 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2998 if (H_GET_32 (abfd
, (raw_ptr
+ 4)) != 0)
2999 ++ardata
->symdef_count
;
3001 amt
= ardata
->symdef_count
;
3002 amt
*= sizeof (carsym
);
3003 symdef_ptr
= (carsym
*) bfd_alloc (abfd
, amt
);
3007 ardata
->symdefs
= symdef_ptr
;
3009 raw_ptr
= raw_armap
+ 4;
3010 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3012 unsigned int name_offset
, file_offset
;
3014 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
3015 if (file_offset
== 0)
3017 name_offset
= H_GET_32 (abfd
, raw_ptr
);
3018 symdef_ptr
->name
= stringbase
+ name_offset
;
3019 symdef_ptr
->file_offset
= file_offset
;
3023 ardata
->first_file_filepos
= bfd_tell (abfd
);
3024 /* Pad to an even boundary. */
3025 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
3027 abfd
->has_armap
= TRUE
;
3032 /* Write out an armap. */
3035 _bfd_ecoff_write_armap (bfd
*abfd
,
3036 unsigned int elength
,
3038 unsigned int orl_count
,
3041 unsigned int hashsize
, hashlog
;
3042 bfd_size_type symdefsize
;
3044 unsigned int stringsize
;
3045 unsigned int mapsize
;
3048 struct stat statbuf
;
3051 bfd_byte
*hashtable
;
3055 /* Ultrix appears to use as a hash table size the least power of two
3056 greater than twice the number of entries. */
3057 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3059 hashsize
= 1 << hashlog
;
3061 symdefsize
= hashsize
* 8;
3063 stringsize
= stridx
+ padit
;
3065 /* Include 8 bytes to store symdefsize and stringsize in output. */
3066 mapsize
= symdefsize
+ stringsize
+ 8;
3068 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3070 memset ((void *) &hdr
, 0, sizeof hdr
);
3072 /* Work out the ECOFF armap name. */
3073 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3074 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3075 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3076 (bfd_header_big_endian (abfd
)
3078 : ARMAP_LITTLE_ENDIAN
);
3079 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3080 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3081 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3082 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3084 /* Write the timestamp of the archive header to be just a little bit
3085 later than the timestamp of the file, otherwise the linker will
3086 complain that the index is out of date. Actually, the Ultrix
3087 linker just checks the archive name; the GNU linker may check the
3089 stat (abfd
->filename
, &statbuf
);
3090 _bfd_ar_spacepad (hdr
.ar_date
, sizeof (hdr
.ar_date
), "%ld",
3091 (long) (statbuf
.st_mtime
+ 60));
3093 /* The DECstation uses zeroes for the uid, gid and mode of the
3095 hdr
.ar_uid
[0] = '0';
3096 hdr
.ar_gid
[0] = '0';
3097 /* Building gcc ends up extracting the armap as a file - twice. */
3098 hdr
.ar_mode
[0] = '6';
3099 hdr
.ar_mode
[1] = '4';
3100 hdr
.ar_mode
[2] = '4';
3102 _bfd_ar_spacepad (hdr
.ar_size
, sizeof (hdr
.ar_size
), "%-10ld", mapsize
);
3104 hdr
.ar_fmag
[0] = '`';
3105 hdr
.ar_fmag
[1] = '\012';
3107 /* Turn all null bytes in the header into spaces. */
3108 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3109 if (((char *) (&hdr
))[i
] == '\0')
3110 (((char *) (&hdr
))[i
]) = ' ';
3112 if (bfd_bwrite ((void *) &hdr
, (bfd_size_type
) sizeof (struct ar_hdr
), abfd
)
3113 != sizeof (struct ar_hdr
))
3116 H_PUT_32 (abfd
, hashsize
, temp
);
3117 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3120 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3124 current
= abfd
->archive_head
;
3126 for (i
= 0; i
< orl_count
; i
++)
3128 unsigned int hash
, rehash
= 0;
3130 /* Advance firstreal to the file position of this archive
3132 if (map
[i
].u
.abfd
!= last_elt
)
3136 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3137 firstreal
+= firstreal
% 2;
3138 current
= current
->archive_next
;
3140 while (current
!= map
[i
].u
.abfd
);
3145 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3146 if (H_GET_32 (abfd
, (hashtable
+ (hash
* 8) + 4)) != 0)
3150 /* The desired slot is already taken. */
3151 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3153 srch
= (srch
+ rehash
) & (hashsize
- 1))
3154 if (H_GET_32 (abfd
, (hashtable
+ (srch
* 8) + 4)) == 0)
3157 BFD_ASSERT (srch
!= hash
);
3162 H_PUT_32 (abfd
, map
[i
].namidx
, (hashtable
+ hash
* 8));
3163 H_PUT_32 (abfd
, firstreal
, (hashtable
+ hash
* 8 + 4));
3166 if (bfd_bwrite ((void *) hashtable
, symdefsize
, abfd
) != symdefsize
)
3169 bfd_release (abfd
, hashtable
);
3171 /* Now write the strings. */
3172 H_PUT_32 (abfd
, stringsize
, temp
);
3173 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3175 for (i
= 0; i
< orl_count
; i
++)
3179 len
= strlen (*map
[i
].name
) + 1;
3180 if (bfd_bwrite ((void *) (*map
[i
].name
), len
, abfd
) != len
)
3184 /* The spec sez this should be a newline. But in order to be
3185 bug-compatible for DECstation ar we use a null. */
3188 if (bfd_bwrite ("", (bfd_size_type
) 1, abfd
) != 1)
3195 /* ECOFF linker code. */
3197 /* Routine to create an entry in an ECOFF link hash table. */
3199 static struct bfd_hash_entry
*
3200 ecoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
3201 struct bfd_hash_table
*table
,
3204 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3206 /* Allocate the structure if it has not already been allocated by a
3209 ret
= ((struct ecoff_link_hash_entry
*)
3210 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3214 /* Call the allocation method of the superclass. */
3215 ret
= ((struct ecoff_link_hash_entry
*)
3216 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3221 /* Set local fields. */
3227 memset ((void *) &ret
->esym
, 0, sizeof ret
->esym
);
3229 return (struct bfd_hash_entry
*) ret
;
3232 /* Create an ECOFF link hash table. */
3234 struct bfd_link_hash_table
*
3235 _bfd_ecoff_bfd_link_hash_table_create (bfd
*abfd
)
3237 struct ecoff_link_hash_table
*ret
;
3238 size_t amt
= sizeof (struct ecoff_link_hash_table
);
3240 ret
= (struct ecoff_link_hash_table
*) bfd_malloc (amt
);
3243 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
,
3244 ecoff_link_hash_newfunc
,
3245 sizeof (struct ecoff_link_hash_entry
)))
3253 /* Look up an entry in an ECOFF link hash table. */
3255 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3256 ((struct ecoff_link_hash_entry *) \
3257 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3259 /* Get the ECOFF link hash table from the info structure. This is
3262 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3264 /* Add the external symbols of an object file to the global linker
3265 hash table. The external symbols and strings we are passed are
3266 just allocated on the stack, and will be discarded. We must
3267 explicitly save any information we may need later on in the link.
3268 We do not want to read the external symbol information again. */
3271 ecoff_link_add_externals (bfd
*abfd
,
3272 struct bfd_link_info
*info
,
3273 void * external_ext
,
3276 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3277 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3278 = backend
->debug_swap
.swap_ext_in
;
3279 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3280 unsigned long ext_count
;
3281 struct bfd_link_hash_entry
**sym_hash
;
3286 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3289 amt
*= sizeof (struct bfd_link_hash_entry
*);
3290 sym_hash
= (struct bfd_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3293 ecoff_data (abfd
)->sym_hashes
= (struct ecoff_link_hash_entry
**) sym_hash
;
3295 ext_ptr
= (char *) external_ext
;
3296 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3297 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3304 struct ecoff_link_hash_entry
*h
;
3308 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3310 /* Skip debugging symbols. */
3312 switch (esym
.asym
.st
)
3328 /* Get the information for this symbol. */
3329 value
= esym
.asym
.value
;
3330 switch (esym
.asym
.sc
)
3350 section
= bfd_make_section_old_way (abfd
, _TEXT
);
3351 value
-= section
->vma
;
3354 section
= bfd_make_section_old_way (abfd
, _DATA
);
3355 value
-= section
->vma
;
3358 section
= bfd_make_section_old_way (abfd
, _BSS
);
3359 value
-= section
->vma
;
3362 section
= bfd_abs_section_ptr
;
3365 section
= bfd_und_section_ptr
;
3368 section
= bfd_make_section_old_way (abfd
, _SDATA
);
3369 value
-= section
->vma
;
3372 section
= bfd_make_section_old_way (abfd
, _SBSS
);
3373 value
-= section
->vma
;
3376 section
= bfd_make_section_old_way (abfd
, _RDATA
);
3377 value
-= section
->vma
;
3380 if (value
> ecoff_data (abfd
)->gp_size
)
3382 section
= bfd_com_section_ptr
;
3387 if (ecoff_scom_section
.name
== NULL
)
3389 /* Initialize the small common section. */
3390 ecoff_scom_section
.name
= SCOMMON
;
3391 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
3392 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
3393 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
3394 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
3395 ecoff_scom_symbol
.name
= SCOMMON
;
3396 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
3397 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
3398 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
3400 section
= &ecoff_scom_section
;
3403 section
= bfd_und_section_ptr
;
3406 section
= bfd_make_section_old_way (abfd
, _INIT
);
3407 value
-= section
->vma
;
3410 section
= bfd_make_section_old_way (abfd
, _FINI
);
3411 value
-= section
->vma
;
3414 section
= bfd_make_section_old_way (abfd
, _RCONST
);
3415 value
-= section
->vma
;
3419 if (section
== NULL
)
3422 name
= ssext
+ esym
.asym
.iss
;
3424 if (! (_bfd_generic_link_add_one_symbol
3426 (flagword
) (esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
),
3427 section
, value
, NULL
, TRUE
, TRUE
, sym_hash
)))
3430 h
= (struct ecoff_link_hash_entry
*) *sym_hash
;
3432 /* If we are building an ECOFF hash table, save the external
3433 symbol information. */
3434 if (bfd_get_flavour (info
->output_bfd
) == bfd_get_flavour (abfd
))
3437 || (! bfd_is_und_section (section
)
3438 && (! bfd_is_com_section (section
)
3439 || (h
->root
.type
!= bfd_link_hash_defined
3440 && h
->root
.type
!= bfd_link_hash_defweak
))))
3446 /* Remember whether this symbol was small undefined. */
3447 if (esym
.asym
.sc
== scSUndefined
)
3450 /* If this symbol was ever small undefined, it needs to wind
3451 up in a GP relative section. We can't control the
3452 section of a defined symbol, but we can control the
3453 section of a common symbol. This case is actually needed
3454 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3456 && h
->root
.type
== bfd_link_hash_common
3457 && streq (h
->root
.u
.c
.p
->section
->name
, SCOMMON
))
3459 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
3461 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
3462 if (h
->esym
.asym
.sc
== scCommon
)
3463 h
->esym
.asym
.sc
= scSCommon
;
3471 /* Add symbols from an ECOFF object file to the global linker hash
3475 ecoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3478 bfd_size_type external_ext_size
;
3479 void * external_ext
= NULL
;
3480 bfd_size_type esize
;
3484 if (! ecoff_slurp_symbolic_header (abfd
))
3487 /* If there are no symbols, we don't want it. */
3488 if (bfd_get_symcount (abfd
) == 0)
3491 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3493 /* Read in the external symbols and external strings. */
3494 if (bfd_seek (abfd
, symhdr
->cbExtOffset
, SEEK_SET
) != 0)
3496 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3497 esize
= symhdr
->iextMax
* external_ext_size
;
3498 external_ext
= _bfd_malloc_and_read (abfd
, esize
, esize
);
3499 if (external_ext
== NULL
&& esize
!= 0)
3502 if (bfd_seek (abfd
, symhdr
->cbSsExtOffset
, SEEK_SET
) != 0)
3504 ssext
= (char *) _bfd_malloc_and_read (abfd
, symhdr
->issExtMax
,
3506 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3509 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3513 if (external_ext
!= NULL
)
3514 free (external_ext
);
3520 if (external_ext
!= NULL
)
3521 free (external_ext
);
3525 /* This is called if we used _bfd_generic_link_add_archive_symbols
3526 because we were not dealing with an ECOFF archive. */
3529 ecoff_link_check_archive_element (bfd
*abfd
,
3530 struct bfd_link_info
*info
,
3531 struct bfd_link_hash_entry
*h
,
3533 bfd_boolean
*pneeded
)
3537 /* Unlike the generic linker, we do not pull in elements because
3538 of common symbols. */
3539 if (h
->type
!= bfd_link_hash_undefined
)
3542 /* Include this element? */
3543 if (!(*info
->callbacks
->add_archive_element
) (info
, abfd
, name
, &abfd
))
3547 return ecoff_link_add_object_symbols (abfd
, info
);
3550 /* Add the symbols from an archive file to the global hash table.
3551 This looks through the undefined symbols, looks each one up in the
3552 archive hash table, and adds any associated object file. We do not
3553 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3554 already have a hash table, so there is no reason to construct
3558 ecoff_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3560 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3561 const bfd_byte
*raw_armap
;
3562 struct bfd_link_hash_entry
**pundef
;
3563 unsigned int armap_count
;
3564 unsigned int armap_log
;
3566 const bfd_byte
*hashtable
;
3567 const char *stringbase
;
3569 if (! bfd_has_map (abfd
))
3571 /* An empty archive is a special case. */
3572 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
3574 bfd_set_error (bfd_error_no_armap
);
3578 /* If we don't have any raw data for this archive, as can happen on
3579 Irix 4.0.5F, we call the generic routine.
3580 FIXME: We should be more clever about this, since someday tdata
3581 may get to something for a generic archive. */
3582 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3583 if (raw_armap
== NULL
)
3584 return (_bfd_generic_link_add_archive_symbols
3585 (abfd
, info
, ecoff_link_check_archive_element
));
3587 armap_count
= H_GET_32 (abfd
, raw_armap
);
3590 for (i
= 1; i
< armap_count
; i
<<= 1)
3592 BFD_ASSERT (i
== armap_count
);
3594 hashtable
= raw_armap
+ 4;
3595 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3597 /* Look through the list of undefined symbols. */
3598 pundef
= &info
->hash
->undefs
;
3599 while (*pundef
!= NULL
)
3601 struct bfd_link_hash_entry
*h
;
3602 unsigned int hash
, rehash
= 0;
3603 unsigned int file_offset
;
3609 /* When a symbol is defined, it is not necessarily removed from
3611 if (h
->type
!= bfd_link_hash_undefined
3612 && h
->type
!= bfd_link_hash_common
)
3614 /* Remove this entry from the list, for general cleanliness
3615 and because we are going to look through the list again
3616 if we search any more libraries. We can't remove the
3617 entry if it is the tail, because that would lose any
3618 entries we add to the list later on. */
3619 if (*pundef
!= info
->hash
->undefs_tail
)
3620 *pundef
= (*pundef
)->u
.undef
.next
;
3622 pundef
= &(*pundef
)->u
.undef
.next
;
3626 /* Native ECOFF linkers do not pull in archive elements merely
3627 to satisfy common definitions, so neither do we. We leave
3628 them on the list, though, in case we are linking against some
3629 other object format. */
3630 if (h
->type
!= bfd_link_hash_undefined
)
3632 pundef
= &(*pundef
)->u
.undef
.next
;
3636 /* Look for this symbol in the archive hash table. */
3637 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3640 file_offset
= H_GET_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3641 if (file_offset
== 0)
3643 /* Nothing in this slot. */
3644 pundef
= &(*pundef
)->u
.undef
.next
;
3648 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (hash
* 8));
3649 if (name
[0] != h
->root
.string
[0]
3650 || ! streq (name
, h
->root
.string
))
3655 /* That was the wrong symbol. Try rehashing. */
3657 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3659 srch
= (srch
+ rehash
) & (armap_count
- 1))
3661 file_offset
= H_GET_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3662 if (file_offset
== 0)
3664 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (srch
* 8));
3665 if (name
[0] == h
->root
.string
[0]
3666 && streq (name
, h
->root
.string
))
3675 pundef
= &(*pundef
)->u
.undef
.next
;
3682 element
= (*backend
->get_elt_at_filepos
) (abfd
, (file_ptr
) file_offset
);
3683 if (element
== NULL
)
3686 if (! bfd_check_format (element
, bfd_object
))
3689 /* Unlike the generic linker, we know that this element provides
3690 a definition for an undefined symbol and we know that we want
3691 to include it. We don't need to check anything. */
3692 if (!(*info
->callbacks
3693 ->add_archive_element
) (info
, element
, name
, &element
))
3695 if (! ecoff_link_add_object_symbols (element
, info
))
3698 pundef
= &(*pundef
)->u
.undef
.next
;
3704 /* Given an ECOFF BFD, add symbols to the global hash table as
3708 _bfd_ecoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3710 switch (bfd_get_format (abfd
))
3713 return ecoff_link_add_object_symbols (abfd
, info
);
3715 return ecoff_link_add_archive_symbols (abfd
, info
);
3717 bfd_set_error (bfd_error_wrong_format
);
3723 /* ECOFF final link routines. */
3725 /* Structure used to pass information to ecoff_link_write_external. */
3730 struct bfd_link_info
*info
;
3733 /* Accumulate the debugging information for an input BFD into the
3734 output BFD. This must read in the symbolic information of the
3738 ecoff_final_link_debug_accumulate (bfd
*output_bfd
,
3740 struct bfd_link_info
*info
,
3743 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
3744 const struct ecoff_debug_swap
* const swap
=
3745 &ecoff_backend (input_bfd
)->debug_swap
;
3746 HDRR
*symhdr
= &debug
->symbolic_header
;
3749 #define READ(ptr, offset, count, size, type) \
3753 debug->ptr = NULL; \
3754 if (symhdr->count == 0) \
3756 if (_bfd_mul_overflow (size, symhdr->count, &amt)) \
3758 bfd_set_error (bfd_error_file_too_big); \
3760 goto return_something; \
3762 if (bfd_seek (input_bfd, symhdr->offset, SEEK_SET) != 0) \
3765 goto return_something; \
3767 debug->ptr = (type) _bfd_malloc_and_read (input_bfd, amt, amt); \
3768 if (debug->ptr == NULL) \
3771 goto return_something; \
3775 /* If raw_syments is not NULL, then the data was already by read by
3776 _bfd_ecoff_slurp_symbolic_info. */
3777 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3779 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
3781 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
3782 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
3783 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
3784 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
3785 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3787 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3788 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
3789 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
3793 /* We do not read the external strings or the external symbols. */
3795 ret
= (bfd_ecoff_debug_accumulate
3796 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
3797 &ecoff_backend (output_bfd
)->debug_swap
,
3798 input_bfd
, debug
, swap
, info
));
3801 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3803 if (debug
->line
!= NULL
)
3805 if (debug
->external_dnr
!= NULL
)
3806 free (debug
->external_dnr
);
3807 if (debug
->external_pdr
!= NULL
)
3808 free (debug
->external_pdr
);
3809 if (debug
->external_sym
!= NULL
)
3810 free (debug
->external_sym
);
3811 if (debug
->external_opt
!= NULL
)
3812 free (debug
->external_opt
);
3813 if (debug
->external_aux
!= NULL
)
3814 free (debug
->external_aux
);
3815 if (debug
->ss
!= NULL
)
3817 if (debug
->external_fdr
!= NULL
)
3818 free (debug
->external_fdr
);
3819 if (debug
->external_rfd
!= NULL
)
3820 free (debug
->external_rfd
);
3822 /* Make sure we don't accidentally follow one of these pointers
3823 into freed memory. */
3825 debug
->external_dnr
= NULL
;
3826 debug
->external_pdr
= NULL
;
3827 debug
->external_sym
= NULL
;
3828 debug
->external_opt
= NULL
;
3829 debug
->external_aux
= NULL
;
3831 debug
->external_fdr
= NULL
;
3832 debug
->external_rfd
= NULL
;
3838 /* Relocate and write an ECOFF section into an ECOFF output file. */
3841 ecoff_indirect_link_order (bfd
*output_bfd
,
3842 struct bfd_link_info
*info
,
3843 asection
*output_section
,
3844 struct bfd_link_order
*link_order
)
3846 asection
*input_section
;
3848 bfd_byte
*contents
= NULL
;
3849 bfd_size_type external_reloc_size
;
3850 bfd_size_type external_relocs_size
;
3851 void * external_relocs
= NULL
;
3853 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
3855 input_section
= link_order
->u
.indirect
.section
;
3856 input_bfd
= input_section
->owner
;
3857 if (input_section
->size
== 0)
3860 BFD_ASSERT (input_section
->output_section
== output_section
);
3861 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
3862 BFD_ASSERT (input_section
->size
== link_order
->size
);
3864 /* Get the section contents. */
3865 if (!bfd_malloc_and_get_section (input_bfd
, input_section
, &contents
))
3868 /* Get the relocs. If we are relaxing MIPS code, they will already
3869 have been read in. Otherwise, we read them in now. */
3870 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
3871 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
3873 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0)
3875 external_relocs
= _bfd_malloc_and_read (input_bfd
, external_relocs_size
,
3876 external_relocs_size
);
3877 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
3880 /* Relocate the section contents. */
3881 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
3882 (output_bfd
, info
, input_bfd
, input_section
, contents
,
3886 /* Write out the relocated section. */
3887 if (! bfd_set_section_contents (output_bfd
,
3890 input_section
->output_offset
,
3891 input_section
->size
))
3894 /* If we are producing relocatable output, the relocs were
3895 modified, and we write them out now. We use the reloc_count
3896 field of output_section to keep track of the number of relocs we
3897 have output so far. */
3898 if (bfd_link_relocatable (info
))
3900 file_ptr pos
= (output_section
->rel_filepos
3901 + output_section
->reloc_count
* external_reloc_size
);
3902 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
3903 || (bfd_bwrite (external_relocs
, external_relocs_size
, output_bfd
)
3904 != external_relocs_size
))
3906 output_section
->reloc_count
+= input_section
->reloc_count
;
3909 if (contents
!= NULL
)
3911 if (external_relocs
!= NULL
)
3912 free (external_relocs
);
3916 if (contents
!= NULL
)
3918 if (external_relocs
!= NULL
)
3919 free (external_relocs
);
3923 /* Generate a reloc when linking an ECOFF file. This is a reloc
3924 requested by the linker, and does come from any input file. This
3925 is used to build constructor and destructor tables when linking
3929 ecoff_reloc_link_order (bfd
*output_bfd
,
3930 struct bfd_link_info
*info
,
3931 asection
*output_section
,
3932 struct bfd_link_order
*link_order
)
3934 enum bfd_link_order_type type
;
3938 struct internal_reloc in
;
3939 bfd_size_type external_reloc_size
;
3944 type
= link_order
->type
;
3946 addend
= link_order
->u
.reloc
.p
->addend
;
3948 /* We set up an arelent to pass to the backend adjust_reloc_out
3950 rel
.address
= link_order
->offset
;
3952 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3955 bfd_set_error (bfd_error_bad_value
);
3959 if (type
== bfd_section_reloc_link_order
)
3961 section
= link_order
->u
.reloc
.p
->u
.section
;
3962 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
3966 struct bfd_link_hash_entry
*h
;
3968 /* Treat a reloc against a defined symbol as though it were
3969 actually against the section. */
3970 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3971 link_order
->u
.reloc
.p
->u
.name
,
3972 FALSE
, FALSE
, FALSE
);
3974 && (h
->type
== bfd_link_hash_defined
3975 || h
->type
== bfd_link_hash_defweak
))
3977 type
= bfd_section_reloc_link_order
;
3978 section
= h
->u
.def
.section
->output_section
;
3979 /* It seems that we ought to add the symbol value to the
3980 addend here, but in practice it has already been added
3981 because it was passed to constructor_callback. */
3982 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
3986 /* We can't set up a reloc against a symbol correctly,
3987 because we have no asymbol structure. Currently no
3988 adjust_reloc_out routine cares. */
3989 rel
.sym_ptr_ptr
= NULL
;
3993 /* All ECOFF relocs are in-place. Put the addend into the object
3996 BFD_ASSERT (rel
.howto
->partial_inplace
);
4000 bfd_reloc_status_type rstat
;
4003 size
= bfd_get_reloc_size (rel
.howto
);
4004 buf
= (bfd_byte
*) bfd_zmalloc (size
);
4005 if (buf
== NULL
&& size
!= 0)
4007 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
4008 (bfd_vma
) addend
, buf
);
4014 case bfd_reloc_outofrange
:
4016 case bfd_reloc_overflow
:
4017 (*info
->callbacks
->reloc_overflow
)
4019 (link_order
->type
== bfd_section_reloc_link_order
4020 ? bfd_section_name (section
)
4021 : link_order
->u
.reloc
.p
->u
.name
),
4022 rel
.howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0);
4025 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
4026 (file_ptr
) link_order
->offset
, size
);
4034 /* Move the information into an internal_reloc structure. */
4035 in
.r_vaddr
= rel
.address
+ bfd_section_vma (output_section
);
4036 in
.r_type
= rel
.howto
->type
;
4038 if (type
== bfd_symbol_reloc_link_order
)
4040 struct ecoff_link_hash_entry
*h
;
4042 h
= ((struct ecoff_link_hash_entry
*)
4043 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4044 link_order
->u
.reloc
.p
->u
.name
,
4045 FALSE
, FALSE
, TRUE
));
4048 in
.r_symndx
= h
->indx
;
4051 (*info
->callbacks
->unattached_reloc
)
4052 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
4068 { _TEXT
, RELOC_SECTION_TEXT
},
4069 { _RDATA
, RELOC_SECTION_RDATA
},
4070 { _DATA
, RELOC_SECTION_DATA
},
4071 { _SDATA
, RELOC_SECTION_SDATA
},
4072 { _SBSS
, RELOC_SECTION_SBSS
},
4073 { _BSS
, RELOC_SECTION_BSS
},
4074 { _INIT
, RELOC_SECTION_INIT
},
4075 { _LIT8
, RELOC_SECTION_LIT8
},
4076 { _LIT4
, RELOC_SECTION_LIT4
},
4077 { _XDATA
, RELOC_SECTION_XDATA
},
4078 { _PDATA
, RELOC_SECTION_PDATA
},
4079 { _FINI
, RELOC_SECTION_FINI
},
4080 { _LITA
, RELOC_SECTION_LITA
},
4081 { "*ABS*", RELOC_SECTION_ABS
},
4082 { _RCONST
, RELOC_SECTION_RCONST
}
4085 name
= bfd_section_name (section
);
4087 for (i
= 0; i
< ARRAY_SIZE (section_symndx
); i
++)
4088 if (streq (name
, section_symndx
[i
].name
))
4090 in
.r_symndx
= section_symndx
[i
].r_symndx
;
4094 if (i
== ARRAY_SIZE (section_symndx
))
4100 /* Let the BFD backend adjust the reloc. */
4101 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4103 /* Get some memory and swap out the reloc. */
4104 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4105 rbuf
= (bfd_byte
*) bfd_malloc (external_reloc_size
);
4109 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (void *) rbuf
);
4111 pos
= (output_section
->rel_filepos
4112 + output_section
->reloc_count
* external_reloc_size
);
4113 ok
= (bfd_seek (output_bfd
, pos
, SEEK_SET
) == 0
4114 && (bfd_bwrite ((void *) rbuf
, external_reloc_size
, output_bfd
)
4115 == external_reloc_size
));
4118 ++output_section
->reloc_count
;
4125 /* Put out information for an external symbol. These come only from
4129 ecoff_link_write_external (struct bfd_hash_entry
*bh
, void * data
)
4131 struct ecoff_link_hash_entry
*h
= (struct ecoff_link_hash_entry
*) bh
;
4132 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4133 bfd
*output_bfd
= einfo
->abfd
;
4136 if (h
->root
.type
== bfd_link_hash_warning
)
4138 h
= (struct ecoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4139 if (h
->root
.type
== bfd_link_hash_new
)
4143 /* We need to check if this symbol is being stripped. */
4144 if (h
->root
.type
== bfd_link_hash_undefined
4145 || h
->root
.type
== bfd_link_hash_undefweak
)
4147 else if (einfo
->info
->strip
== strip_all
4148 || (einfo
->info
->strip
== strip_some
4149 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4150 h
->root
.root
.string
,
4151 FALSE
, FALSE
) == NULL
))
4156 if (strip
|| h
->written
)
4159 if (h
->abfd
== NULL
)
4162 h
->esym
.cobol_main
= 0;
4163 h
->esym
.weakext
= 0;
4164 h
->esym
.reserved
= 0;
4165 h
->esym
.ifd
= ifdNil
;
4166 h
->esym
.asym
.value
= 0;
4167 h
->esym
.asym
.st
= stGlobal
;
4169 if (h
->root
.type
!= bfd_link_hash_defined
4170 && h
->root
.type
!= bfd_link_hash_defweak
)
4171 h
->esym
.asym
.sc
= scAbs
;
4174 asection
*output_section
;
4182 section_storage_classes
[] =
4186 { _SDATA
, scSData
},
4187 { _RDATA
, scRData
},
4192 { _PDATA
, scPData
},
4193 { _XDATA
, scXData
},
4194 { _RCONST
, scRConst
}
4197 output_section
= h
->root
.u
.def
.section
->output_section
;
4198 name
= bfd_section_name (output_section
);
4200 for (i
= 0; i
< ARRAY_SIZE (section_storage_classes
); i
++)
4201 if (streq (name
, section_storage_classes
[i
].name
))
4203 h
->esym
.asym
.sc
= section_storage_classes
[i
].sc
;
4207 if (i
== ARRAY_SIZE (section_storage_classes
))
4208 h
->esym
.asym
.sc
= scAbs
;
4211 h
->esym
.asym
.reserved
= 0;
4212 h
->esym
.asym
.index
= indexNil
;
4214 else if (h
->esym
.ifd
!= -1)
4216 struct ecoff_debug_info
*debug
;
4218 /* Adjust the FDR index for the symbol by that used for the
4220 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4221 BFD_ASSERT (h
->esym
.ifd
>= 0
4222 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4223 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4226 switch (h
->root
.type
)
4229 case bfd_link_hash_warning
:
4230 case bfd_link_hash_new
:
4232 case bfd_link_hash_undefined
:
4233 case bfd_link_hash_undefweak
:
4234 if (h
->esym
.asym
.sc
!= scUndefined
4235 && h
->esym
.asym
.sc
!= scSUndefined
)
4236 h
->esym
.asym
.sc
= scUndefined
;
4238 case bfd_link_hash_defined
:
4239 case bfd_link_hash_defweak
:
4240 if (h
->esym
.asym
.sc
== scUndefined
4241 || h
->esym
.asym
.sc
== scSUndefined
)
4242 h
->esym
.asym
.sc
= scAbs
;
4243 else if (h
->esym
.asym
.sc
== scCommon
)
4244 h
->esym
.asym
.sc
= scBss
;
4245 else if (h
->esym
.asym
.sc
== scSCommon
)
4246 h
->esym
.asym
.sc
= scSBss
;
4247 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4248 + h
->root
.u
.def
.section
->output_section
->vma
4249 + h
->root
.u
.def
.section
->output_offset
);
4251 case bfd_link_hash_common
:
4252 if (h
->esym
.asym
.sc
!= scCommon
4253 && h
->esym
.asym
.sc
!= scSCommon
)
4254 h
->esym
.asym
.sc
= scCommon
;
4255 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4257 case bfd_link_hash_indirect
:
4258 /* We ignore these symbols, since the indirected symbol is
4259 already in the hash table. */
4263 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4265 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4268 return (bfd_ecoff_debug_one_external
4269 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4270 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4274 /* ECOFF final link routine. This looks through all the input BFDs
4275 and gathers together all the debugging information, and then
4276 processes all the link order information. This may cause it to
4277 close and reopen some input BFDs; I'll see how bad this is. */
4280 _bfd_ecoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
4282 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4283 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4288 struct bfd_link_order
*p
;
4289 struct extsym_info einfo
;
4291 /* We accumulate the debugging information counts in the symbolic
4293 symhdr
= &debug
->symbolic_header
;
4295 symhdr
->ilineMax
= 0;
4299 symhdr
->isymMax
= 0;
4300 symhdr
->ioptMax
= 0;
4301 symhdr
->iauxMax
= 0;
4303 symhdr
->issExtMax
= 0;
4306 symhdr
->iextMax
= 0;
4308 /* We accumulate the debugging information itself in the debug_info
4311 debug
->external_dnr
= NULL
;
4312 debug
->external_pdr
= NULL
;
4313 debug
->external_sym
= NULL
;
4314 debug
->external_opt
= NULL
;
4315 debug
->external_aux
= NULL
;
4317 debug
->ssext
= debug
->ssext_end
= NULL
;
4318 debug
->external_fdr
= NULL
;
4319 debug
->external_rfd
= NULL
;
4320 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4322 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4326 /* Accumulate the debugging symbols from each input BFD. */
4327 for (input_bfd
= info
->input_bfds
;
4329 input_bfd
= input_bfd
->link
.next
)
4333 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4335 /* Arbitrarily set the symbolic header vstamp to the vstamp
4336 of the first object file in the link. */
4337 if (symhdr
->vstamp
== 0)
4339 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4340 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4344 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4345 debug
, &backend
->debug_swap
,
4350 /* Combine the register masks. */
4351 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4352 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4353 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4354 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4355 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4356 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4359 /* Write out the external symbols. */
4362 bfd_hash_traverse (&info
->hash
->table
, ecoff_link_write_external
, &einfo
);
4364 if (bfd_link_relocatable (info
))
4366 /* We need to make a pass over the link_orders to count up the
4367 number of relocations we will need to output, so that we know
4368 how much space they will take up. */
4369 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4372 for (p
= o
->map_head
.link_order
;
4375 if (p
->type
== bfd_indirect_link_order
)
4376 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4377 else if (p
->type
== bfd_section_reloc_link_order
4378 || p
->type
== bfd_symbol_reloc_link_order
)
4383 /* Compute the reloc and symbol file positions. */
4384 ecoff_compute_reloc_file_positions (abfd
);
4386 /* Write out the debugging information. */
4387 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4388 &backend
->debug_swap
, info
,
4389 ecoff_data (abfd
)->sym_filepos
))
4392 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4394 if (bfd_link_relocatable (info
))
4396 /* Now reset the reloc_count field of the sections in the output
4397 BFD to 0, so that we can use them to keep track of how many
4398 relocs we have output thus far. */
4399 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4403 /* Get a value for the GP register. */
4404 if (ecoff_data (abfd
)->gp
== 0)
4406 struct bfd_link_hash_entry
*h
;
4408 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
4410 && h
->type
== bfd_link_hash_defined
)
4411 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4412 + h
->u
.def
.section
->output_section
->vma
4413 + h
->u
.def
.section
->output_offset
);
4414 else if (bfd_link_relocatable (info
))
4418 /* Make up a value. */
4420 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4423 && (streq (o
->name
, _SBSS
)
4424 || streq (o
->name
, _SDATA
)
4425 || streq (o
->name
, _LIT4
)
4426 || streq (o
->name
, _LIT8
)
4427 || streq (o
->name
, _LITA
)))
4430 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4434 /* If the relocate_section function needs to do a reloc
4435 involving the GP value, it should make a reloc_dangerous
4436 callback to warn that GP is not defined. */
4440 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4442 for (p
= o
->map_head
.link_order
;
4446 if (p
->type
== bfd_indirect_link_order
4447 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4448 == bfd_target_ecoff_flavour
))
4450 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4453 else if (p
->type
== bfd_section_reloc_link_order
4454 || p
->type
== bfd_symbol_reloc_link_order
)
4456 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4461 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4467 abfd
->symcount
= symhdr
->iextMax
+ symhdr
->isymMax
;
4469 ecoff_data (abfd
)->linker
= TRUE
;