1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright (C) 1990-2019 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. */
28 #include "aout/stab_gnu.h"
30 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
31 some other stuff which we don't want and which conflicts with stuff
34 #include "aout/aout64.h"
37 #undef obj_sym_filepos
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
45 #include "libiberty.h"
47 #define streq(a, b) (strcmp ((a), (b)) == 0)
48 #define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0)
51 /* This stuff is somewhat copied from coffcode.h. */
52 static asection bfd_debug_section
=
54 /* name, id, index, next, prev, flags, user_set_vma, */
55 "*DEBUG*", 0, 0, NULL
, NULL
, 0, 0,
56 /* linker_mark, linker_has_input, gc_mark, compress_status, */
58 /* segment_mark, sec_info_type, use_rela_p, */
60 /* sec_flg0, sec_flg1, sec_flg2, sec_flg3, sec_flg4, sec_flg5, */
62 /* vma, lma, size, rawsize, compressed_size, relax, relax_count, */
64 /* output_offset, output_section, alignment_power, */
66 /* relocation, orelocation, reloc_count, filepos, rel_filepos, */
68 /* line_filepos, userdata, contents, lineno, lineno_count, */
69 0, NULL
, NULL
, NULL
, 0,
70 /* entsize, kept_section, moving_line_filepos, */
72 /* target_index, used_by_bfd, constructor_chain, owner, */
78 /* map_head, map_tail */
82 /* Create an ECOFF object. */
85 _bfd_ecoff_mkobject (bfd
*abfd
)
87 bfd_size_type amt
= sizeof (ecoff_data_type
);
89 abfd
->tdata
.ecoff_obj_data
= (struct ecoff_tdata
*) bfd_zalloc (abfd
, amt
);
90 if (abfd
->tdata
.ecoff_obj_data
== NULL
)
96 /* This is a hook called by coff_real_object_p to create any backend
97 specific information. */
100 _bfd_ecoff_mkobject_hook (bfd
*abfd
, void * filehdr
, void * aouthdr
)
102 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
103 struct internal_aouthdr
*internal_a
= (struct internal_aouthdr
*) aouthdr
;
104 ecoff_data_type
*ecoff
;
106 if (! _bfd_ecoff_mkobject (abfd
))
109 ecoff
= ecoff_data (abfd
);
111 ecoff
->sym_filepos
= internal_f
->f_symptr
;
113 if (internal_a
!= NULL
)
117 ecoff
->text_start
= internal_a
->text_start
;
118 ecoff
->text_end
= internal_a
->text_start
+ internal_a
->tsize
;
119 ecoff
->gp
= internal_a
->gp_value
;
120 ecoff
->gprmask
= internal_a
->gprmask
;
121 for (i
= 0; i
< 4; i
++)
122 ecoff
->cprmask
[i
] = internal_a
->cprmask
[i
];
123 ecoff
->fprmask
= internal_a
->fprmask
;
124 if (internal_a
->magic
== ECOFF_AOUT_ZMAGIC
)
125 abfd
->flags
|= D_PAGED
;
127 abfd
->flags
&=~ D_PAGED
;
130 /* It turns out that no special action is required by the MIPS or
131 Alpha ECOFF backends. They have different information in the
132 a.out header, but we just copy it all (e.g., gprmask, cprmask and
133 fprmask) and let the swapping routines ensure that only relevant
134 information is written out. */
136 return (void *) ecoff
;
139 /* Initialize a new section. */
142 _bfd_ecoff_new_section_hook (bfd
*abfd
, asection
*section
)
152 { _TEXT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
153 { _INIT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
154 { _FINI
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
155 { _DATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
},
156 { _SDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
},
157 { _RDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
158 { _LIT8
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
159 { _LIT4
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
160 { _RCONST
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
161 { _PDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
164 /* An Irix 4 shared libary. */
165 { _LIB
, SEC_COFF_SHARED_LIBRARY
}
168 section
->alignment_power
= 4;
170 for (i
= 0; i
< ARRAY_SIZE (section_flags
); i
++)
171 if (streq (section
->name
, section_flags
[i
].name
))
173 section
->flags
|= section_flags
[i
].flags
;
178 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
179 uncertain about .init on some systems and I don't know how shared
182 return _bfd_generic_new_section_hook (abfd
, section
);
186 _bfd_ecoff_set_alignment_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
187 asection
*section ATTRIBUTE_UNUSED
,
188 void *scnhdr ATTRIBUTE_UNUSED
)
192 /* Determine the machine architecture and type. This is called from
193 the generic COFF routines. It is the inverse of ecoff_get_magic,
194 below. This could be an ECOFF backend routine, with one version
195 for each target, but there aren't all that many ECOFF targets. */
198 _bfd_ecoff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
200 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
201 enum bfd_architecture arch
;
204 switch (internal_f
->f_magic
)
207 case MIPS_MAGIC_LITTLE
:
209 arch
= bfd_arch_mips
;
210 mach
= bfd_mach_mips3000
;
213 case MIPS_MAGIC_LITTLE2
:
214 case MIPS_MAGIC_BIG2
:
215 /* MIPS ISA level 2: the r6000. */
216 arch
= bfd_arch_mips
;
217 mach
= bfd_mach_mips6000
;
220 case MIPS_MAGIC_LITTLE3
:
221 case MIPS_MAGIC_BIG3
:
222 /* MIPS ISA level 3: the r4000. */
223 arch
= bfd_arch_mips
;
224 mach
= bfd_mach_mips4000
;
228 arch
= bfd_arch_alpha
;
233 arch
= bfd_arch_obscure
;
238 return bfd_default_set_arch_mach (abfd
, arch
, mach
);
242 _bfd_ecoff_no_long_sections (bfd
*abfd
, int enable
)
249 /* Get the magic number to use based on the architecture and machine.
250 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
253 ecoff_get_magic (bfd
*abfd
)
257 switch (bfd_get_arch (abfd
))
260 switch (bfd_get_mach (abfd
))
264 case bfd_mach_mips3000
:
265 big
= MIPS_MAGIC_BIG
;
266 little
= MIPS_MAGIC_LITTLE
;
269 case bfd_mach_mips6000
:
270 big
= MIPS_MAGIC_BIG2
;
271 little
= MIPS_MAGIC_LITTLE2
;
274 case bfd_mach_mips4000
:
275 big
= MIPS_MAGIC_BIG3
;
276 little
= MIPS_MAGIC_LITTLE3
;
280 return bfd_big_endian (abfd
) ? big
: little
;
291 /* Get the section s_flags to use for a section. */
294 ecoff_sec_to_styp_flags (const char *name
, flagword flags
)
304 { _TEXT
, STYP_TEXT
},
305 { _DATA
, STYP_DATA
},
306 { _SDATA
, STYP_SDATA
},
307 { _RDATA
, STYP_RDATA
},
308 { _LITA
, STYP_LITA
},
309 { _LIT8
, STYP_LIT8
},
310 { _LIT4
, STYP_LIT4
},
312 { _SBSS
, STYP_SBSS
},
313 { _INIT
, STYP_ECOFF_INIT
},
314 { _FINI
, STYP_ECOFF_FINI
},
315 { _PDATA
, STYP_PDATA
},
316 { _XDATA
, STYP_XDATA
},
317 { _LIB
, STYP_ECOFF_LIB
},
319 { _HASH
, STYP_HASH
},
320 { _DYNAMIC
, STYP_DYNAMIC
},
321 { _LIBLIST
, STYP_LIBLIST
},
322 { _RELDYN
, STYP_RELDYN
},
323 { _CONFLIC
, STYP_CONFLIC
},
324 { _DYNSTR
, STYP_DYNSTR
},
325 { _DYNSYM
, STYP_DYNSYM
},
326 { _RCONST
, STYP_RCONST
}
330 for (i
= 0; i
< ARRAY_SIZE (styp_flags
); i
++)
331 if (streq (name
, styp_flags
[i
].name
))
333 styp
= styp_flags
[i
].flags
;
339 if (streq (name
, _COMMENT
))
342 flags
&=~ SEC_NEVER_LOAD
;
344 else if (flags
& SEC_CODE
)
346 else if (flags
& SEC_DATA
)
348 else if (flags
& SEC_READONLY
)
350 else if (flags
& SEC_LOAD
)
356 if (flags
& SEC_NEVER_LOAD
)
362 /* Get the BFD flags to use for a section. */
365 _bfd_ecoff_styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
367 const char *name ATTRIBUTE_UNUSED
,
368 asection
*section ATTRIBUTE_UNUSED
,
369 flagword
* flags_ptr
)
371 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
372 long styp_flags
= internal_s
->s_flags
;
373 flagword sec_flags
= 0;
375 if (styp_flags
& STYP_NOLOAD
)
376 sec_flags
|= SEC_NEVER_LOAD
;
378 /* For 386 COFF, at least, an unloadable text or data section is
379 actually a shared library section. */
380 if ((styp_flags
& STYP_TEXT
)
381 || (styp_flags
& STYP_ECOFF_INIT
)
382 || (styp_flags
& STYP_ECOFF_FINI
)
383 || (styp_flags
& STYP_DYNAMIC
)
384 || (styp_flags
& STYP_LIBLIST
)
385 || (styp_flags
& STYP_RELDYN
)
386 || styp_flags
== STYP_CONFLIC
387 || (styp_flags
& STYP_DYNSTR
)
388 || (styp_flags
& STYP_DYNSYM
)
389 || (styp_flags
& STYP_HASH
))
391 if (sec_flags
& SEC_NEVER_LOAD
)
392 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
394 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
396 else if ((styp_flags
& STYP_DATA
)
397 || (styp_flags
& STYP_RDATA
)
398 || (styp_flags
& STYP_SDATA
)
399 || styp_flags
== STYP_PDATA
400 || styp_flags
== STYP_XDATA
401 || (styp_flags
& STYP_GOT
)
402 || styp_flags
== STYP_RCONST
)
404 if (sec_flags
& SEC_NEVER_LOAD
)
405 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
407 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
408 if ((styp_flags
& STYP_RDATA
)
409 || styp_flags
== STYP_PDATA
410 || styp_flags
== STYP_RCONST
)
411 sec_flags
|= SEC_READONLY
;
413 else if ((styp_flags
& STYP_BSS
)
414 || (styp_flags
& STYP_SBSS
))
415 sec_flags
|= SEC_ALLOC
;
416 else if ((styp_flags
& STYP_INFO
) || styp_flags
== STYP_COMMENT
)
417 sec_flags
|= SEC_NEVER_LOAD
;
418 else if ((styp_flags
& STYP_LITA
)
419 || (styp_flags
& STYP_LIT8
)
420 || (styp_flags
& STYP_LIT4
))
421 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
422 else if (styp_flags
& STYP_ECOFF_LIB
)
423 sec_flags
|= SEC_COFF_SHARED_LIBRARY
;
425 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
427 * flags_ptr
= sec_flags
;
431 /* Read in the symbolic header for an ECOFF object file. */
434 ecoff_slurp_symbolic_header (bfd
*abfd
)
436 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
437 bfd_size_type external_hdr_size
;
439 HDRR
*internal_symhdr
;
441 /* See if we've already read it in. */
442 if (ecoff_data (abfd
)->debug_info
.symbolic_header
.magic
==
443 backend
->debug_swap
.sym_magic
)
446 /* See whether there is a symbolic header. */
447 if (ecoff_data (abfd
)->sym_filepos
== 0)
453 /* At this point bfd_get_symcount (abfd) holds the number of symbols
454 as read from the file header, but on ECOFF this is always the
455 size of the symbolic information header. It would be cleaner to
456 handle this when we first read the file in coffgen.c. */
457 external_hdr_size
= backend
->debug_swap
.external_hdr_size
;
458 if (bfd_get_symcount (abfd
) != external_hdr_size
)
460 bfd_set_error (bfd_error_bad_value
);
464 /* Read the symbolic information header. */
465 raw
= bfd_malloc (external_hdr_size
);
469 if (bfd_seek (abfd
, ecoff_data (abfd
)->sym_filepos
, SEEK_SET
) != 0
470 || bfd_bread (raw
, external_hdr_size
, abfd
) != external_hdr_size
)
472 internal_symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
473 (*backend
->debug_swap
.swap_hdr_in
) (abfd
, raw
, internal_symhdr
);
475 if (internal_symhdr
->magic
!= backend
->debug_swap
.sym_magic
)
477 bfd_set_error (bfd_error_bad_value
);
481 /* Now we can get the correct number of symbols. */
482 abfd
->symcount
= internal_symhdr
->isymMax
+ internal_symhdr
->iextMax
;
493 /* Read in and swap the important symbolic information for an ECOFF
494 object file. This is called by gdb via the read_debug_info entry
495 point in the backend structure. */
498 _bfd_ecoff_slurp_symbolic_info (bfd
*abfd
,
499 asection
*ignore ATTRIBUTE_UNUSED
,
500 struct ecoff_debug_info
*debug
)
502 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
503 HDRR
*internal_symhdr
;
504 bfd_size_type raw_base
;
505 bfd_size_type raw_size
;
507 bfd_size_type external_fdr_size
;
511 bfd_size_type raw_end
;
512 bfd_size_type cb_end
;
515 BFD_ASSERT (debug
== &ecoff_data (abfd
)->debug_info
);
517 /* Check whether we've already gotten it, and whether there's any to
519 if (ecoff_data (abfd
)->raw_syments
!= NULL
)
521 if (ecoff_data (abfd
)->sym_filepos
== 0)
527 if (! ecoff_slurp_symbolic_header (abfd
))
530 internal_symhdr
= &debug
->symbolic_header
;
532 /* Read all the symbolic information at once. */
533 raw_base
= (ecoff_data (abfd
)->sym_filepos
534 + backend
->debug_swap
.external_hdr_size
);
536 /* Alpha ecoff makes the determination of raw_size difficult. It has
537 an undocumented debug data section between the symhdr and the first
538 documented section. And the ordering of the sections varies between
539 statically and dynamically linked executables.
540 If bfd supports SEEK_END someday, this code could be simplified. */
543 #define UPDATE_RAW_END(start, count, size) \
544 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
545 if (cb_end > raw_end) \
548 UPDATE_RAW_END (cbLineOffset
, cbLine
, sizeof (unsigned char));
549 UPDATE_RAW_END (cbDnOffset
, idnMax
, backend
->debug_swap
.external_dnr_size
);
550 UPDATE_RAW_END (cbPdOffset
, ipdMax
, backend
->debug_swap
.external_pdr_size
);
551 UPDATE_RAW_END (cbSymOffset
, isymMax
, backend
->debug_swap
.external_sym_size
);
552 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
553 optimization symtab, not the number of entries. */
554 UPDATE_RAW_END (cbOptOffset
, ioptMax
, sizeof (char));
555 UPDATE_RAW_END (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
556 UPDATE_RAW_END (cbSsOffset
, issMax
, sizeof (char));
557 UPDATE_RAW_END (cbSsExtOffset
, issExtMax
, sizeof (char));
558 UPDATE_RAW_END (cbFdOffset
, ifdMax
, backend
->debug_swap
.external_fdr_size
);
559 UPDATE_RAW_END (cbRfdOffset
, crfd
, backend
->debug_swap
.external_rfd_size
);
560 UPDATE_RAW_END (cbExtOffset
, iextMax
, backend
->debug_swap
.external_ext_size
);
562 #undef UPDATE_RAW_END
564 raw_size
= raw_end
- raw_base
;
567 ecoff_data (abfd
)->sym_filepos
= 0;
570 raw
= bfd_alloc (abfd
, raw_size
);
574 pos
= ecoff_data (abfd
)->sym_filepos
;
575 pos
+= backend
->debug_swap
.external_hdr_size
;
576 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
577 || bfd_bread (raw
, raw_size
, abfd
) != raw_size
)
579 bfd_release (abfd
, raw
);
583 ecoff_data (abfd
)->raw_syments
= raw
;
585 /* Get pointers for the numeric offsets in the HDRR structure. */
586 #define FIX(off1, off2, type) \
587 if (internal_symhdr->off1 == 0) \
588 debug->off2 = NULL; \
590 debug->off2 = (type) ((char *) raw \
591 + (internal_symhdr->off1 \
594 FIX (cbLineOffset
, line
, unsigned char *);
595 FIX (cbDnOffset
, external_dnr
, void *);
596 FIX (cbPdOffset
, external_pdr
, void *);
597 FIX (cbSymOffset
, external_sym
, void *);
598 FIX (cbOptOffset
, external_opt
, void *);
599 FIX (cbAuxOffset
, external_aux
, union aux_ext
*);
600 FIX (cbSsOffset
, ss
, char *);
601 FIX (cbSsExtOffset
, ssext
, char *);
602 FIX (cbFdOffset
, external_fdr
, void *);
603 FIX (cbRfdOffset
, external_rfd
, void *);
604 FIX (cbExtOffset
, external_ext
, void *);
607 /* I don't want to always swap all the data, because it will just
608 waste time and most programs will never look at it. The only
609 time the linker needs most of the debugging information swapped
610 is when linking big-endian and little-endian MIPS object files
611 together, which is not a common occurrence.
613 We need to look at the fdr to deal with a lot of information in
614 the symbols, so we swap them here. */
615 debug
->fdr
= (FDR
*) bfd_alloc2 (abfd
, internal_symhdr
->ifdMax
,
616 sizeof (struct fdr
));
617 if (debug
->fdr
== NULL
)
619 external_fdr_size
= backend
->debug_swap
.external_fdr_size
;
620 fdr_ptr
= debug
->fdr
;
621 fraw_src
= (char *) debug
->external_fdr
;
622 /* PR 17512: file: 3372-1243-0.004. */
623 if (fraw_src
== NULL
&& internal_symhdr
->ifdMax
> 0)
625 fraw_end
= fraw_src
+ internal_symhdr
->ifdMax
* external_fdr_size
;
626 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
627 (*backend
->debug_swap
.swap_fdr_in
) (abfd
, (void *) fraw_src
, fdr_ptr
);
632 /* ECOFF symbol table routines. The ECOFF symbol table is described
633 in gcc/mips-tfile.c. */
635 /* ECOFF uses two common sections. One is the usual one, and the
636 other is for small objects. All the small objects are kept
637 together, and then referenced via the gp pointer, which yields
638 faster assembler code. This is what we use for the small common
640 static asection ecoff_scom_section
;
641 static asymbol ecoff_scom_symbol
;
642 static asymbol
*ecoff_scom_symbol_ptr
;
644 /* Create an empty symbol. */
647 _bfd_ecoff_make_empty_symbol (bfd
*abfd
)
649 ecoff_symbol_type
*new_symbol
;
650 bfd_size_type amt
= sizeof (ecoff_symbol_type
);
652 new_symbol
= (ecoff_symbol_type
*) bfd_zalloc (abfd
, amt
);
653 if (new_symbol
== NULL
)
655 new_symbol
->symbol
.section
= NULL
;
656 new_symbol
->fdr
= NULL
;
657 new_symbol
->local
= FALSE
;
658 new_symbol
->native
= NULL
;
659 new_symbol
->symbol
.the_bfd
= abfd
;
660 return &new_symbol
->symbol
;
663 /* Set the BFD flags and section for an ECOFF symbol. */
666 ecoff_set_symbol_info (bfd
*abfd
,
672 asym
->the_bfd
= abfd
;
673 asym
->value
= ecoff_sym
->value
;
674 asym
->section
= &bfd_debug_section
;
677 /* Most symbol types are just for debugging. */
678 switch (ecoff_sym
->st
)
687 if (ECOFF_IS_STAB (ecoff_sym
))
689 asym
->flags
= BSF_DEBUGGING
;
694 asym
->flags
= BSF_DEBUGGING
;
699 asym
->flags
= BSF_EXPORT
| BSF_WEAK
;
701 asym
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
704 asym
->flags
= BSF_LOCAL
;
705 /* Normally, a local stProc symbol will have a corresponding
706 external symbol. We mark the local symbol as a debugging
707 symbol, in order to prevent nm from printing both out.
708 Similarly, we mark stLabel and stabs symbols as debugging
709 symbols. In both cases, we do want to set the value
710 correctly based on the symbol class. */
711 if (ecoff_sym
->st
== stProc
712 || ecoff_sym
->st
== stLabel
713 || ECOFF_IS_STAB (ecoff_sym
))
714 asym
->flags
|= BSF_DEBUGGING
;
717 if (ecoff_sym
->st
== stProc
|| ecoff_sym
->st
== stStaticProc
)
718 asym
->flags
|= BSF_FUNCTION
;
720 switch (ecoff_sym
->sc
)
723 /* Used for compiler generated labels. Leave them in the
724 debugging section, and mark them as local. If BSF_DEBUGGING
725 is set, then nm does not display them for some reason. If no
726 flags are set then the linker whines about them. */
727 asym
->flags
= BSF_LOCAL
;
730 asym
->section
= bfd_make_section_old_way (abfd
, _TEXT
);
731 asym
->value
-= asym
->section
->vma
;
734 asym
->section
= bfd_make_section_old_way (abfd
, _DATA
);
735 asym
->value
-= asym
->section
->vma
;
738 asym
->section
= bfd_make_section_old_way (abfd
, _BSS
);
739 asym
->value
-= asym
->section
->vma
;
742 asym
->flags
= BSF_DEBUGGING
;
745 asym
->section
= bfd_abs_section_ptr
;
748 asym
->section
= bfd_und_section_ptr
;
758 asym
->flags
= BSF_DEBUGGING
;
761 asym
->section
= bfd_make_section_old_way (abfd
, ".sdata");
762 asym
->value
-= asym
->section
->vma
;
765 asym
->section
= bfd_make_section_old_way (abfd
, ".sbss");
766 asym
->value
-= asym
->section
->vma
;
769 asym
->section
= bfd_make_section_old_way (abfd
, ".rdata");
770 asym
->value
-= asym
->section
->vma
;
773 asym
->flags
= BSF_DEBUGGING
;
776 if (asym
->value
> ecoff_data (abfd
)->gp_size
)
778 asym
->section
= bfd_com_section_ptr
;
784 if (ecoff_scom_section
.name
== NULL
)
786 /* Initialize the small common section. */
787 ecoff_scom_section
.name
= SCOMMON
;
788 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
789 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
790 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
791 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
792 ecoff_scom_symbol
.name
= SCOMMON
;
793 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
794 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
795 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
797 asym
->section
= &ecoff_scom_section
;
802 asym
->flags
= BSF_DEBUGGING
;
805 asym
->section
= bfd_und_section_ptr
;
810 asym
->section
= bfd_make_section_old_way (abfd
, ".init");
811 asym
->value
-= asym
->section
->vma
;
816 asym
->flags
= BSF_DEBUGGING
;
819 asym
->section
= bfd_make_section_old_way (abfd
, ".fini");
820 asym
->value
-= asym
->section
->vma
;
823 asym
->section
= bfd_make_section_old_way (abfd
, ".rconst");
824 asym
->value
-= asym
->section
->vma
;
830 /* Look for special constructors symbols and make relocation entries
831 in a special construction section. These are produced by the
832 -fgnu-linker argument to g++. */
833 if (ECOFF_IS_STAB (ecoff_sym
))
835 switch (ECOFF_UNMARK_STAB (ecoff_sym
->index
))
844 /* Mark the symbol as a constructor. */
845 asym
->flags
|= BSF_CONSTRUCTOR
;
852 /* Read an ECOFF symbol table. */
855 _bfd_ecoff_slurp_symbol_table (bfd
*abfd
)
857 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
858 const bfd_size_type external_ext_size
859 = backend
->debug_swap
.external_ext_size
;
860 const bfd_size_type external_sym_size
861 = backend
->debug_swap
.external_sym_size
;
862 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
863 = backend
->debug_swap
.swap_ext_in
;
864 void (* const swap_sym_in
) (bfd
*, void *, SYMR
*)
865 = backend
->debug_swap
.swap_sym_in
;
866 ecoff_symbol_type
*internal
;
867 ecoff_symbol_type
*internal_ptr
;
873 /* If we've already read in the symbol table, do nothing. */
874 if (ecoff_data (abfd
)->canonical_symbols
!= NULL
)
877 /* Get the symbolic information. */
878 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
879 &ecoff_data (abfd
)->debug_info
))
881 if (bfd_get_symcount (abfd
) == 0)
884 internal
= (ecoff_symbol_type
*) bfd_alloc2 (abfd
, bfd_get_symcount (abfd
),
885 sizeof (ecoff_symbol_type
));
886 if (internal
== NULL
)
889 internal_ptr
= internal
;
890 eraw_src
= (char *) ecoff_data (abfd
)->debug_info
.external_ext
;
892 + (ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
893 * external_ext_size
));
894 for (; eraw_src
< eraw_end
; eraw_src
+= external_ext_size
, internal_ptr
++)
898 (*swap_ext_in
) (abfd
, (void *) eraw_src
, &internal_esym
);
900 /* PR 17512: file: 3372-1000-0.004. */
901 if (internal_esym
.asym
.iss
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.issExtMax
902 || internal_esym
.asym
.iss
< 0)
905 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ssext
906 + internal_esym
.asym
.iss
);
908 if (!ecoff_set_symbol_info (abfd
, &internal_esym
.asym
,
909 &internal_ptr
->symbol
, 1,
910 internal_esym
.weakext
))
913 /* The alpha uses a negative ifd field for section symbols. */
914 if (internal_esym
.ifd
>= 0)
916 /* PR 17512: file: 3372-1983-0.004. */
917 if (internal_esym
.ifd
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
)
918 internal_ptr
->fdr
= NULL
;
920 internal_ptr
->fdr
= (ecoff_data (abfd
)->debug_info
.fdr
921 + internal_esym
.ifd
);
924 internal_ptr
->fdr
= NULL
;
925 internal_ptr
->local
= FALSE
;
926 internal_ptr
->native
= (void *) eraw_src
;
929 /* The local symbols must be accessed via the fdr's, because the
930 string and aux indices are relative to the fdr information. */
931 fdr_ptr
= ecoff_data (abfd
)->debug_info
.fdr
;
932 fdr_end
= fdr_ptr
+ ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
;
933 for (; fdr_ptr
< fdr_end
; fdr_ptr
++)
938 lraw_src
= ((char *) ecoff_data (abfd
)->debug_info
.external_sym
939 + fdr_ptr
->isymBase
* external_sym_size
);
940 lraw_end
= lraw_src
+ fdr_ptr
->csym
* external_sym_size
;
943 lraw_src
+= external_sym_size
, internal_ptr
++)
947 (*swap_sym_in
) (abfd
, (void *) lraw_src
, &internal_sym
);
948 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ss
951 if (!ecoff_set_symbol_info (abfd
, &internal_sym
,
952 &internal_ptr
->symbol
, 0, 0))
954 internal_ptr
->fdr
= fdr_ptr
;
955 internal_ptr
->local
= TRUE
;
956 internal_ptr
->native
= (void *) lraw_src
;
960 /* PR 17512: file: 3372-3080-0.004.
961 A discrepancy between ecoff_data (abfd)->debug_info.symbolic_header.isymMax
962 and ecoff_data (abfd)->debug_info.symbolic_header.ifdMax can mean that
963 we have fewer symbols than we were expecting. Allow for this by updating
964 the symbol count and warning the user. */
965 if (internal_ptr
- internal
< (ptrdiff_t) bfd_get_symcount (abfd
))
967 abfd
->symcount
= internal_ptr
- internal
;
969 /* xgettext:c-format */
970 (_("%pB: warning: isymMax (%ld) is greater than ifdMax (%ld)"),
971 abfd
, ecoff_data (abfd
)->debug_info
.symbolic_header
.isymMax
,
972 ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
);
975 ecoff_data (abfd
)->canonical_symbols
= internal
;
980 /* Return the amount of space needed for the canonical symbols. */
983 _bfd_ecoff_get_symtab_upper_bound (bfd
*abfd
)
985 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
986 &ecoff_data (abfd
)->debug_info
))
989 if (bfd_get_symcount (abfd
) == 0)
992 return (bfd_get_symcount (abfd
) + 1) * (sizeof (ecoff_symbol_type
*));
995 /* Get the canonical symbols. */
998 _bfd_ecoff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
1000 unsigned int counter
= 0;
1001 ecoff_symbol_type
*symbase
;
1002 ecoff_symbol_type
**location
= (ecoff_symbol_type
**) alocation
;
1004 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1006 if (bfd_get_symcount (abfd
) == 0)
1009 symbase
= ecoff_data (abfd
)->canonical_symbols
;
1010 while (counter
< bfd_get_symcount (abfd
))
1012 *(location
++) = symbase
++;
1016 return bfd_get_symcount (abfd
);
1019 /* Turn ECOFF type information into a printable string.
1020 ecoff_emit_aggregate and ecoff_type_to_string are from
1021 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1023 /* Write aggregate information to a string. */
1026 ecoff_emit_aggregate (bfd
*abfd
,
1033 const struct ecoff_debug_swap
* const debug_swap
=
1034 &ecoff_backend (abfd
)->debug_swap
;
1035 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1036 unsigned int ifd
= rndx
->rfd
;
1037 unsigned int indx
= rndx
->index
;
1043 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1044 struct return type of a procedure compiled without -g. */
1045 if (ifd
== 0xffffffff
1046 || (rndx
->rfd
== 0xfff && indx
== 0))
1047 name
= "<undefined>";
1048 else if (indx
== indexNil
)
1054 if (debug_info
->external_rfd
== NULL
)
1055 fdr
= debug_info
->fdr
+ ifd
;
1060 (*debug_swap
->swap_rfd_in
) (abfd
,
1061 ((char *) debug_info
->external_rfd
1062 + ((fdr
->rfdBase
+ ifd
)
1063 * debug_swap
->external_rfd_size
)),
1065 fdr
= debug_info
->fdr
+ rfd
;
1068 indx
+= fdr
->isymBase
;
1070 (*debug_swap
->swap_sym_in
) (abfd
,
1071 ((char *) debug_info
->external_sym
1072 + indx
* debug_swap
->external_sym_size
),
1075 name
= debug_info
->ss
+ fdr
->issBase
+ sym
.iss
;
1079 "%s %s { ifd = %u, index = %lu }",
1081 ((unsigned long) indx
1082 + debug_info
->symbolic_header
.iextMax
));
1085 /* Convert the type information to string format. */
1088 ecoff_type_to_string (bfd
*abfd
, FDR
*fdr
, unsigned int indx
)
1090 union aux_ext
*aux_ptr
;
1100 unsigned int basic_type
;
1103 static char buffer2
[1024];
1108 aux_ptr
= ecoff_data (abfd
)->debug_info
.external_aux
+ fdr
->iauxBase
;
1109 bigendian
= fdr
->fBigendian
;
1111 for (i
= 0; i
< 7; i
++)
1113 qualifiers
[i
].low_bound
= 0;
1114 qualifiers
[i
].high_bound
= 0;
1115 qualifiers
[i
].stride
= 0;
1118 if (AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
]) == (bfd_vma
) -1)
1119 return "-1 (no type)";
1120 _bfd_ecoff_swap_tir_in (bigendian
, &aux_ptr
[indx
++].a_ti
, &u
.ti
);
1122 basic_type
= u
.ti
.bt
;
1123 qualifiers
[0].type
= u
.ti
.tq0
;
1124 qualifiers
[1].type
= u
.ti
.tq1
;
1125 qualifiers
[2].type
= u
.ti
.tq2
;
1126 qualifiers
[3].type
= u
.ti
.tq3
;
1127 qualifiers
[4].type
= u
.ti
.tq4
;
1128 qualifiers
[5].type
= u
.ti
.tq5
;
1129 qualifiers
[6].type
= tqNil
;
1131 /* Go get the basic type. */
1134 case btNil
: /* Undefined. */
1138 case btAdr
: /* Address - integer same size as pointer. */
1139 strcpy (p1
, "address");
1142 case btChar
: /* Character. */
1143 strcpy (p1
, "char");
1146 case btUChar
: /* Unsigned character. */
1147 strcpy (p1
, "unsigned char");
1150 case btShort
: /* Short. */
1151 strcpy (p1
, "short");
1154 case btUShort
: /* Unsigned short. */
1155 strcpy (p1
, "unsigned short");
1158 case btInt
: /* Int. */
1162 case btUInt
: /* Unsigned int. */
1163 strcpy (p1
, "unsigned int");
1166 case btLong
: /* Long. */
1167 strcpy (p1
, "long");
1170 case btULong
: /* Unsigned long. */
1171 strcpy (p1
, "unsigned long");
1174 case btFloat
: /* Float (real). */
1175 strcpy (p1
, "float");
1178 case btDouble
: /* Double (real). */
1179 strcpy (p1
, "double");
1182 /* Structures add 1-2 aux words:
1183 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1184 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1186 case btStruct
: /* Structure (Record). */
1187 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1188 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1189 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1191 indx
++; /* Skip aux words. */
1194 /* Unions add 1-2 aux words:
1195 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1196 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1198 case btUnion
: /* Union. */
1199 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1200 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1201 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1203 indx
++; /* Skip aux words. */
1206 /* Enumerations add 1-2 aux words:
1207 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1208 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1210 case btEnum
: /* Enumeration. */
1211 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1212 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1213 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1215 indx
++; /* Skip aux words. */
1218 case btTypedef
: /* Defined via a typedef, isymRef points. */
1219 strcpy (p1
, "typedef");
1222 case btRange
: /* Subrange of int. */
1223 strcpy (p1
, "subrange");
1226 case btSet
: /* Pascal sets. */
1230 case btComplex
: /* Fortran complex. */
1231 strcpy (p1
, "complex");
1234 case btDComplex
: /* Fortran double complex. */
1235 strcpy (p1
, "double complex");
1238 case btIndirect
: /* Forward or unnamed typedef. */
1239 strcpy (p1
, "forward/unamed typedef");
1242 case btFixedDec
: /* Fixed Decimal. */
1243 strcpy (p1
, "fixed decimal");
1246 case btFloatDec
: /* Float Decimal. */
1247 strcpy (p1
, "float decimal");
1250 case btString
: /* Varying Length Character String. */
1251 strcpy (p1
, "string");
1254 case btBit
: /* Aligned Bit String. */
1258 case btPicture
: /* Picture. */
1259 strcpy (p1
, "picture");
1262 case btVoid
: /* Void. */
1263 strcpy (p1
, "void");
1267 sprintf (p1
, _("unknown basic type %d"), (int) basic_type
);
1271 p1
+= strlen (buffer1
);
1273 /* If this is a bitfield, get the bitsize. */
1278 bitsize
= AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
++]);
1279 sprintf (p1
, " : %d", bitsize
);
1280 p1
+= strlen (buffer1
);
1283 /* Deal with any qualifiers. */
1284 if (qualifiers
[0].type
!= tqNil
)
1286 /* Snarf up any array bounds in the correct order. Arrays
1287 store 5 successive words in the aux. table:
1288 word 0 RNDXR to type of the bounds (ie, int)
1289 word 1 Current file descriptor index
1291 word 3 high bound (or -1 if [])
1292 word 4 stride size in bits. */
1293 for (i
= 0; i
< 7; i
++)
1295 if (qualifiers
[i
].type
== tqArray
)
1297 qualifiers
[i
].low_bound
=
1298 AUX_GET_DNLOW (bigendian
, &aux_ptr
[indx
+2]);
1299 qualifiers
[i
].high_bound
=
1300 AUX_GET_DNHIGH (bigendian
, &aux_ptr
[indx
+3]);
1301 qualifiers
[i
].stride
=
1302 AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
+4]);
1307 /* Now print out the qualifiers. */
1308 for (i
= 0; i
< 6; i
++)
1310 switch (qualifiers
[i
].type
)
1317 strcpy (p2
, "ptr to ");
1318 p2
+= sizeof ("ptr to ")-1;
1322 strcpy (p2
, "volatile ");
1323 p2
+= sizeof ("volatile ")-1;
1327 strcpy (p2
, "far ");
1328 p2
+= sizeof ("far ")-1;
1332 strcpy (p2
, "func. ret. ");
1333 p2
+= sizeof ("func. ret. ");
1338 int first_array
= i
;
1341 /* Print array bounds reversed (ie, in the order the C
1342 programmer writes them). C is such a fun language.... */
1343 while (i
< 5 && qualifiers
[i
+1].type
== tqArray
)
1346 for (j
= i
; j
>= first_array
; j
--)
1348 strcpy (p2
, "array [");
1349 p2
+= sizeof ("array [")-1;
1350 if (qualifiers
[j
].low_bound
!= 0)
1352 "%ld:%ld {%ld bits}",
1353 (long) qualifiers
[j
].low_bound
,
1354 (long) qualifiers
[j
].high_bound
,
1355 (long) qualifiers
[j
].stride
);
1357 else if (qualifiers
[j
].high_bound
!= -1)
1360 (long) (qualifiers
[j
].high_bound
+ 1),
1361 (long) (qualifiers
[j
].stride
));
1364 sprintf (p2
, " {%ld bits}", (long) (qualifiers
[j
].stride
));
1367 strcpy (p2
, "] of ");
1368 p2
+= sizeof ("] of ")-1;
1376 strcpy (p2
, buffer1
);
1380 /* Return information about ECOFF symbol SYMBOL in RET. */
1383 _bfd_ecoff_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
1387 bfd_symbol_info (symbol
, ret
);
1390 /* Return whether this is a local label. */
1393 _bfd_ecoff_bfd_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1396 return name
[0] == '$';
1399 /* Print information about an ECOFF symbol. */
1402 _bfd_ecoff_print_symbol (bfd
*abfd
,
1405 bfd_print_symbol_type how
)
1407 const struct ecoff_debug_swap
* const debug_swap
1408 = &ecoff_backend (abfd
)->debug_swap
;
1409 FILE *file
= (FILE *)filep
;
1413 case bfd_print_symbol_name
:
1414 fprintf (file
, "%s", symbol
->name
);
1416 case bfd_print_symbol_more
:
1417 if (ecoffsymbol (symbol
)->local
)
1421 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1423 fprintf (file
, "ecoff local ");
1424 fprintf_vma (file
, (bfd_vma
) ecoff_sym
.value
);
1425 fprintf (file
, " %x %x", (unsigned) ecoff_sym
.st
,
1426 (unsigned) ecoff_sym
.sc
);
1432 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1434 fprintf (file
, "ecoff extern ");
1435 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1436 fprintf (file
, " %x %x", (unsigned) ecoff_ext
.asym
.st
,
1437 (unsigned) ecoff_ext
.asym
.sc
);
1440 case bfd_print_symbol_all
:
1441 /* Print out the symbols in a reasonable way. */
1450 if (ecoffsymbol (symbol
)->local
)
1452 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1455 pos
= ((((char *) ecoffsymbol (symbol
)->native
1456 - (char *) ecoff_data (abfd
)->debug_info
.external_sym
)
1457 / debug_swap
->external_sym_size
)
1458 + ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
);
1465 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1468 pos
= (((char *) ecoffsymbol (symbol
)->native
1469 - (char *) ecoff_data (abfd
)->debug_info
.external_ext
)
1470 / debug_swap
->external_ext_size
);
1471 jmptbl
= ecoff_ext
.jmptbl
? 'j' : ' ';
1472 cobol_main
= ecoff_ext
.cobol_main
? 'c' : ' ';
1473 weakext
= ecoff_ext
.weakext
? 'w' : ' ';
1476 fprintf (file
, "[%3d] %c ",
1478 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1479 fprintf (file
, " st %x sc %x indx %x %c%c%c %s",
1480 (unsigned) ecoff_ext
.asym
.st
,
1481 (unsigned) ecoff_ext
.asym
.sc
,
1482 (unsigned) ecoff_ext
.asym
.index
,
1483 jmptbl
, cobol_main
, weakext
,
1486 if (ecoffsymbol (symbol
)->fdr
!= NULL
1487 && ecoff_ext
.asym
.index
!= indexNil
)
1492 bfd_size_type sym_base
;
1493 union aux_ext
*aux_base
;
1495 fdr
= ecoffsymbol (symbol
)->fdr
;
1496 indx
= ecoff_ext
.asym
.index
;
1498 /* sym_base is used to map the fdr relative indices which
1499 appear in the file to the position number which we are
1501 sym_base
= fdr
->isymBase
;
1502 if (ecoffsymbol (symbol
)->local
)
1504 ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
1506 /* aux_base is the start of the aux entries for this file;
1507 asym.index is an offset from this. */
1508 aux_base
= (ecoff_data (abfd
)->debug_info
.external_aux
1511 /* The aux entries are stored in host byte order; the
1512 order is indicated by a bit in the fdr. */
1513 bigendian
= fdr
->fBigendian
;
1515 /* This switch is basically from gcc/mips-tdump.c. */
1516 switch (ecoff_ext
.asym
.st
)
1524 fprintf (file
, _("\n End+1 symbol: %ld"),
1525 (long) (indx
+ sym_base
));
1529 if (ecoff_ext
.asym
.sc
== scText
1530 || ecoff_ext
.asym
.sc
== scInfo
)
1531 fprintf (file
, _("\n First symbol: %ld"),
1532 (long) (indx
+ sym_base
));
1534 fprintf (file
, _("\n First symbol: %ld"),
1536 (AUX_GET_ISYM (bigendian
,
1537 &aux_base
[ecoff_ext
.asym
.index
])
1543 if (ECOFF_IS_STAB (&ecoff_ext
.asym
))
1545 else if (ecoffsymbol (symbol
)->local
)
1546 /* xgettext:c-format */
1547 fprintf (file
, _("\n End+1 symbol: %-7ld Type: %s"),
1549 (AUX_GET_ISYM (bigendian
,
1550 &aux_base
[ecoff_ext
.asym
.index
])
1552 ecoff_type_to_string (abfd
, fdr
, indx
+ 1));
1554 fprintf (file
, _("\n Local symbol: %ld"),
1557 + (ecoff_data (abfd
)
1558 ->debug_info
.symbolic_header
.iextMax
)));
1562 fprintf (file
, _("\n struct; End+1 symbol: %ld"),
1563 (long) (indx
+ sym_base
));
1567 fprintf (file
, _("\n union; End+1 symbol: %ld"),
1568 (long) (indx
+ sym_base
));
1572 fprintf (file
, _("\n enum; End+1 symbol: %ld"),
1573 (long) (indx
+ sym_base
));
1577 if (! ECOFF_IS_STAB (&ecoff_ext
.asym
))
1578 fprintf (file
, _("\n Type: %s"),
1579 ecoff_type_to_string (abfd
, fdr
, indx
));
1588 /* Read in the relocs for a section. */
1591 ecoff_slurp_reloc_table (bfd
*abfd
,
1595 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1596 arelent
*internal_relocs
;
1597 bfd_size_type external_reloc_size
;
1599 char *external_relocs
;
1603 if (section
->relocation
!= NULL
1604 || section
->reloc_count
== 0
1605 || (section
->flags
& SEC_CONSTRUCTOR
) != 0)
1608 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1611 amt
= section
->reloc_count
;
1612 amt
*= sizeof (arelent
);
1613 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
1615 external_reloc_size
= backend
->external_reloc_size
;
1616 amt
= external_reloc_size
* section
->reloc_count
;
1617 external_relocs
= (char *) bfd_alloc (abfd
, amt
);
1618 if (internal_relocs
== NULL
|| external_relocs
== NULL
)
1620 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1622 if (bfd_bread (external_relocs
, amt
, abfd
) != amt
)
1625 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1627 struct internal_reloc intern
;
1629 (*backend
->swap_reloc_in
) (abfd
,
1630 external_relocs
+ i
* external_reloc_size
,
1633 if (intern
.r_extern
)
1635 /* r_symndx is an index into the external symbols. */
1636 BFD_ASSERT (intern
.r_symndx
>= 0
1638 < (ecoff_data (abfd
)
1639 ->debug_info
.symbolic_header
.iextMax
)));
1640 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1643 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1644 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1646 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1651 const char *sec_name
;
1654 /* r_symndx is a section key. */
1655 switch (intern
.r_symndx
)
1657 case RELOC_SECTION_TEXT
: sec_name
= _TEXT
; break;
1658 case RELOC_SECTION_RDATA
: sec_name
= _RDATA
; break;
1659 case RELOC_SECTION_DATA
: sec_name
= _DATA
; break;
1660 case RELOC_SECTION_SDATA
: sec_name
= _SDATA
; break;
1661 case RELOC_SECTION_SBSS
: sec_name
= _SBSS
; break;
1662 case RELOC_SECTION_BSS
: sec_name
= _BSS
; break;
1663 case RELOC_SECTION_INIT
: sec_name
= _INIT
; break;
1664 case RELOC_SECTION_LIT8
: sec_name
= _LIT8
; break;
1665 case RELOC_SECTION_LIT4
: sec_name
= _LIT4
; break;
1666 case RELOC_SECTION_XDATA
: sec_name
= _XDATA
; break;
1667 case RELOC_SECTION_PDATA
: sec_name
= _PDATA
; break;
1668 case RELOC_SECTION_FINI
: sec_name
= _FINI
; break;
1669 case RELOC_SECTION_LITA
: sec_name
= _LITA
; break;
1670 case RELOC_SECTION_RCONST
: sec_name
= _RCONST
; break;
1674 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1677 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1679 rptr
->addend
= - bfd_get_section_vma (abfd
, sec
);
1682 rptr
->address
= intern
.r_vaddr
- bfd_get_section_vma (abfd
, section
);
1684 /* Let the backend select the howto field and do any other
1685 required processing. */
1686 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1689 bfd_release (abfd
, external_relocs
);
1691 section
->relocation
= internal_relocs
;
1696 /* Get a canonical list of relocs. */
1699 _bfd_ecoff_canonicalize_reloc (bfd
*abfd
,
1706 if (section
->flags
& SEC_CONSTRUCTOR
)
1708 arelent_chain
*chain
;
1710 /* This section has relocs made up by us, not the file, so take
1711 them out of their chain and place them into the data area
1713 for (count
= 0, chain
= section
->constructor_chain
;
1714 count
< section
->reloc_count
;
1715 count
++, chain
= chain
->next
)
1716 *relptr
++ = &chain
->relent
;
1722 if (! ecoff_slurp_reloc_table (abfd
, section
, symbols
))
1725 tblptr
= section
->relocation
;
1727 for (count
= 0; count
< section
->reloc_count
; count
++)
1728 *relptr
++ = tblptr
++;
1733 return section
->reloc_count
;
1736 /* Provided a BFD, a section and an offset into the section, calculate
1737 and return the name of the source file and the line nearest to the
1741 _bfd_ecoff_find_nearest_line (bfd
*abfd
,
1742 asymbol
**symbols ATTRIBUTE_UNUSED
,
1745 const char **filename_ptr
,
1746 const char **functionname_ptr
,
1747 unsigned int *retline_ptr
,
1748 unsigned int *discriminator_ptr
)
1750 const struct ecoff_debug_swap
* const debug_swap
1751 = &ecoff_backend (abfd
)->debug_swap
;
1752 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1753 struct ecoff_find_line
*line_info
;
1755 /* Make sure we have the FDR's. */
1756 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
, debug_info
)
1757 || bfd_get_symcount (abfd
) == 0)
1760 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1762 bfd_size_type amt
= sizeof (struct ecoff_find_line
);
1764 ecoff_data (abfd
)->find_line_info
=
1765 (struct ecoff_find_line
*) bfd_zalloc (abfd
, amt
);
1766 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1770 if (discriminator_ptr
)
1771 *discriminator_ptr
= 0;
1772 line_info
= ecoff_data (abfd
)->find_line_info
;
1773 return _bfd_ecoff_locate_line (abfd
, section
, offset
, debug_info
,
1774 debug_swap
, line_info
, filename_ptr
,
1775 functionname_ptr
, retline_ptr
);
1778 /* Copy private BFD data. This is called by objcopy and strip. We
1779 use it to copy the ECOFF debugging information from one BFD to the
1780 other. It would be theoretically possible to represent the ECOFF
1781 debugging information in the symbol table. However, it would be a
1782 lot of work, and there would be little gain (gas, gdb, and ld
1783 already access the ECOFF debugging information via the
1784 ecoff_debug_info structure, and that structure would have to be
1785 retained in order to support ECOFF debugging in MIPS ELF).
1787 The debugging information for the ECOFF external symbols comes from
1788 the symbol table, so this function only handles the other debugging
1792 _bfd_ecoff_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1794 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
1795 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
1797 asymbol
**sym_ptr_ptr
;
1801 /* We only want to copy information over if both BFD's use ECOFF
1803 if (bfd_get_flavour (ibfd
) != bfd_target_ecoff_flavour
1804 || bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
1807 /* Copy the GP value and the register masks. */
1808 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
1809 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
1810 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
1811 for (i
= 0; i
< 3; i
++)
1812 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
1814 /* Copy the version stamp. */
1815 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
1817 /* If there are no symbols, don't copy any debugging information. */
1818 c
= bfd_get_symcount (obfd
);
1819 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1820 if (c
== 0 || sym_ptr_ptr
== NULL
)
1823 /* See if there are any local symbols. */
1825 for (; c
> 0; c
--, sym_ptr_ptr
++)
1827 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
1836 /* There are some local symbols. We just bring over all the
1837 debugging information. FIXME: This is not quite the right
1838 thing to do. If the user has asked us to discard all
1839 debugging information, then we are probably going to wind up
1840 keeping it because there will probably be some local symbol
1841 which objcopy did not discard. We should actually break
1842 apart the debugging information and only keep that which
1843 applies to the symbols we want to keep. */
1844 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
1845 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
1846 oinfo
->line
= iinfo
->line
;
1848 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
1849 oinfo
->external_dnr
= iinfo
->external_dnr
;
1851 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
1852 oinfo
->external_pdr
= iinfo
->external_pdr
;
1854 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
1855 oinfo
->external_sym
= iinfo
->external_sym
;
1857 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
1858 oinfo
->external_opt
= iinfo
->external_opt
;
1860 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
1861 oinfo
->external_aux
= iinfo
->external_aux
;
1863 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
1864 oinfo
->ss
= iinfo
->ss
;
1866 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
1867 oinfo
->external_fdr
= iinfo
->external_fdr
;
1869 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
1870 oinfo
->external_rfd
= iinfo
->external_rfd
;
1874 /* We are discarding all the local symbol information. Look
1875 through the external symbols and remove all references to FDR
1876 or aux information. */
1877 c
= bfd_get_symcount (obfd
);
1878 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1879 for (; c
> 0; c
--, sym_ptr_ptr
++)
1883 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
1884 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
1886 esym
.asym
.index
= indexNil
;
1887 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
1888 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
1895 /* Set the architecture. The supported architecture is stored in the
1896 backend pointer. We always set the architecture anyhow, since many
1897 callers ignore the return value. */
1900 _bfd_ecoff_set_arch_mach (bfd
*abfd
,
1901 enum bfd_architecture arch
,
1902 unsigned long machine
)
1904 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1905 return arch
== ecoff_backend (abfd
)->arch
;
1908 /* Get the size of the section headers. */
1911 _bfd_ecoff_sizeof_headers (bfd
*abfd
,
1912 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1919 for (current
= abfd
->sections
;
1921 current
= current
->next
)
1924 ret
= (bfd_coff_filhsz (abfd
)
1925 + bfd_coff_aoutsz (abfd
)
1926 + c
* bfd_coff_scnhsz (abfd
));
1927 return (int) BFD_ALIGN (ret
, 16);
1930 /* Get the contents of a section. */
1933 _bfd_ecoff_get_section_contents (bfd
*abfd
,
1937 bfd_size_type count
)
1939 return _bfd_generic_get_section_contents (abfd
, section
, location
,
1943 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
1944 called via qsort. */
1947 ecoff_sort_hdrs (const void * arg1
, const void * arg2
)
1949 const asection
*hdr1
= *(const asection
**) arg1
;
1950 const asection
*hdr2
= *(const asection
**) arg2
;
1952 if ((hdr1
->flags
& SEC_ALLOC
) != 0)
1954 if ((hdr2
->flags
& SEC_ALLOC
) == 0)
1959 if ((hdr2
->flags
& SEC_ALLOC
) != 0)
1962 if (hdr1
->vma
< hdr2
->vma
)
1964 else if (hdr1
->vma
> hdr2
->vma
)
1970 /* Calculate the file position for each section, and set
1974 ecoff_compute_section_file_positions (bfd
*abfd
)
1976 file_ptr sofar
, file_sofar
;
1977 asection
**sorted_hdrs
;
1981 bfd_boolean rdata_in_text
;
1982 bfd_boolean first_data
, first_nonalloc
;
1983 const bfd_vma round
= ecoff_backend (abfd
)->round
;
1986 sofar
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
1989 /* Sort the sections by VMA. */
1990 amt
= abfd
->section_count
;
1991 amt
*= sizeof (asection
*);
1992 sorted_hdrs
= (asection
**) bfd_malloc (amt
);
1993 if (sorted_hdrs
== NULL
)
1995 for (current
= abfd
->sections
, i
= 0;
1997 current
= current
->next
, i
++)
1998 sorted_hdrs
[i
] = current
;
1999 BFD_ASSERT (i
== abfd
->section_count
);
2001 qsort (sorted_hdrs
, abfd
->section_count
, sizeof (asection
*),
2004 /* Some versions of the OSF linker put the .rdata section in the
2005 text segment, and some do not. */
2006 rdata_in_text
= ecoff_backend (abfd
)->rdata_in_text
;
2009 for (i
= 0; i
< abfd
->section_count
; i
++)
2011 current
= sorted_hdrs
[i
];
2012 if (streq (current
->name
, _RDATA
))
2014 if ((current
->flags
& SEC_CODE
) == 0
2015 && ! streq (current
->name
, _PDATA
)
2016 && ! streq (current
->name
, _RCONST
))
2018 rdata_in_text
= FALSE
;
2023 ecoff_data (abfd
)->rdata_in_text
= rdata_in_text
;
2026 first_nonalloc
= TRUE
;
2027 for (i
= 0; i
< abfd
->section_count
; i
++)
2029 unsigned int alignment_power
;
2031 current
= sorted_hdrs
[i
];
2033 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2034 supposed to indicate the number of .pdata entries that are
2035 really in the section. Each entry is 8 bytes. We store this
2036 away in line_filepos before increasing the section size. */
2037 if (streq (current
->name
, _PDATA
))
2038 current
->line_filepos
= current
->size
/ 8;
2040 alignment_power
= current
->alignment_power
;
2042 /* On Ultrix, the data sections in an executable file must be
2043 aligned to a page boundary within the file. This does not
2044 affect the section size, though. FIXME: Does this work for
2045 other platforms? It requires some modification for the
2046 Alpha, because .rdata on the Alpha goes with the text, not
2048 if ((abfd
->flags
& EXEC_P
) != 0
2049 && (abfd
->flags
& D_PAGED
) != 0
2051 && (current
->flags
& SEC_CODE
) == 0
2053 || ! streq (current
->name
, _RDATA
))
2054 && ! streq (current
->name
, _PDATA
)
2055 && ! streq (current
->name
, _RCONST
))
2057 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2058 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2061 else if (streq (current
->name
, _LIB
))
2063 /* On Irix 4, the location of contents of the .lib section
2064 from a shared library section is also rounded up to a
2067 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2068 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2070 else if (first_nonalloc
2071 && (current
->flags
& SEC_ALLOC
) == 0
2072 && (abfd
->flags
& D_PAGED
) != 0)
2074 /* Skip up to the next page for an unallocated section, such
2075 as the .comment section on the Alpha. This leaves room
2076 for the .bss section. */
2077 first_nonalloc
= FALSE
;
2078 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2079 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2082 /* Align the sections in the file to the same boundary on
2083 which they are aligned in virtual memory. */
2084 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2085 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2086 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2088 if ((abfd
->flags
& D_PAGED
) != 0
2089 && (current
->flags
& SEC_ALLOC
) != 0)
2091 sofar
+= (current
->vma
- sofar
) % round
;
2092 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2093 file_sofar
+= (current
->vma
- file_sofar
) % round
;
2096 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) != 0)
2097 current
->filepos
= file_sofar
;
2099 sofar
+= current
->size
;
2100 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2101 file_sofar
+= current
->size
;
2103 /* Make sure that this section is of the right size too. */
2105 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2106 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2107 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2108 current
->size
+= sofar
- old_sofar
;
2114 ecoff_data (abfd
)->reloc_filepos
= file_sofar
;
2119 /* Determine the location of the relocs for all the sections in the
2120 output file, as well as the location of the symbolic debugging
2123 static bfd_size_type
2124 ecoff_compute_reloc_file_positions (bfd
*abfd
)
2126 const bfd_size_type external_reloc_size
=
2127 ecoff_backend (abfd
)->external_reloc_size
;
2128 file_ptr reloc_base
;
2129 bfd_size_type reloc_size
;
2133 if (! abfd
->output_has_begun
)
2135 if (! ecoff_compute_section_file_positions (abfd
))
2137 abfd
->output_has_begun
= TRUE
;
2140 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2143 for (current
= abfd
->sections
;
2145 current
= current
->next
)
2147 if (current
->reloc_count
== 0)
2148 current
->rel_filepos
= 0;
2151 bfd_size_type relsize
;
2153 current
->rel_filepos
= reloc_base
;
2154 relsize
= current
->reloc_count
* external_reloc_size
;
2155 reloc_size
+= relsize
;
2156 reloc_base
+= relsize
;
2160 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2162 /* At least on Ultrix, the symbol table of an executable file must
2163 be aligned to a page boundary. FIXME: Is this true on other
2165 if ((abfd
->flags
& EXEC_P
) != 0
2166 && (abfd
->flags
& D_PAGED
) != 0)
2167 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2168 &~ (ecoff_backend (abfd
)->round
- 1));
2170 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2175 /* Set the contents of a section. */
2178 _bfd_ecoff_set_section_contents (bfd
*abfd
,
2180 const void * location
,
2182 bfd_size_type count
)
2186 /* This must be done first, because bfd_set_section_contents is
2187 going to set output_has_begun to TRUE. */
2188 if (! abfd
->output_has_begun
2189 && ! ecoff_compute_section_file_positions (abfd
))
2192 /* Handle the .lib section specially so that Irix 4 shared libraries
2193 work out. See coff_set_section_contents in coffcode.h. */
2194 if (streq (section
->name
, _LIB
))
2196 bfd_byte
*rec
, *recend
;
2198 rec
= (bfd_byte
*) location
;
2199 recend
= rec
+ count
;
2200 while (rec
< recend
)
2203 rec
+= bfd_get_32 (abfd
, rec
) * 4;
2206 BFD_ASSERT (rec
== recend
);
2212 pos
= section
->filepos
+ offset
;
2213 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2214 || bfd_bwrite (location
, count
, abfd
) != count
)
2220 /* Set the GP value for an ECOFF file. This is a hook used by the
2224 bfd_ecoff_set_gp_value (bfd
*abfd
, bfd_vma gp_value
)
2226 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2227 || bfd_get_format (abfd
) != bfd_object
)
2229 bfd_set_error (bfd_error_invalid_operation
);
2233 ecoff_data (abfd
)->gp
= gp_value
;
2238 /* Set the register masks for an ECOFF file. This is a hook used by
2242 bfd_ecoff_set_regmasks (bfd
*abfd
,
2243 unsigned long gprmask
,
2244 unsigned long fprmask
,
2245 unsigned long *cprmask
)
2247 ecoff_data_type
*tdata
;
2249 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2250 || bfd_get_format (abfd
) != bfd_object
)
2252 bfd_set_error (bfd_error_invalid_operation
);
2256 tdata
= ecoff_data (abfd
);
2257 tdata
->gprmask
= gprmask
;
2258 tdata
->fprmask
= fprmask
;
2259 if (cprmask
!= NULL
)
2263 for (i
= 0; i
< 3; i
++)
2264 tdata
->cprmask
[i
] = cprmask
[i
];
2270 /* Get ECOFF EXTR information for an external symbol. This function
2271 is passed to bfd_ecoff_debug_externals. */
2274 ecoff_get_extr (asymbol
*sym
, EXTR
*esym
)
2276 ecoff_symbol_type
*ecoff_sym_ptr
;
2279 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2280 || ecoffsymbol (sym
)->native
== NULL
)
2282 /* Don't include debugging, local, or section symbols. */
2283 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2284 || (sym
->flags
& BSF_LOCAL
) != 0
2285 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2289 esym
->cobol_main
= 0;
2290 esym
->weakext
= (sym
->flags
& BSF_WEAK
) != 0;
2293 /* FIXME: we can do better than this for st and sc. */
2294 esym
->asym
.st
= stGlobal
;
2295 esym
->asym
.sc
= scAbs
;
2296 esym
->asym
.reserved
= 0;
2297 esym
->asym
.index
= indexNil
;
2301 ecoff_sym_ptr
= ecoffsymbol (sym
);
2303 if (ecoff_sym_ptr
->local
)
2306 input_bfd
= bfd_asymbol_bfd (sym
);
2307 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2308 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2310 /* If the symbol was defined by the linker, then esym will be
2311 undefined but sym will not be. Get a better class for such a
2313 if ((esym
->asym
.sc
== scUndefined
2314 || esym
->asym
.sc
== scSUndefined
)
2315 && ! bfd_is_und_section (bfd_get_section (sym
)))
2316 esym
->asym
.sc
= scAbs
;
2318 /* Adjust the FDR index for the symbol by that used for the input
2320 if (esym
->ifd
!= -1)
2322 struct ecoff_debug_info
*input_debug
;
2324 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2325 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2326 if (input_debug
->ifdmap
!= NULL
)
2327 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2333 /* Set the external symbol index. This routine is passed to
2334 bfd_ecoff_debug_externals. */
2337 ecoff_set_index (asymbol
*sym
, bfd_size_type indx
)
2339 ecoff_set_sym_index (sym
, indx
);
2342 /* Write out an ECOFF file. */
2345 _bfd_ecoff_write_object_contents (bfd
*abfd
)
2347 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2348 const bfd_vma round
= backend
->round
;
2349 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2350 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2351 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2352 const bfd_size_type external_hdr_size
2353 = backend
->debug_swap
.external_hdr_size
;
2354 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2355 void (* const adjust_reloc_out
) (bfd
*, const arelent
*, struct internal_reloc
*)
2356 = backend
->adjust_reloc_out
;
2357 void (* const swap_reloc_out
) (bfd
*, const struct internal_reloc
*, void *)
2358 = backend
->swap_reloc_out
;
2359 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2360 HDRR
* const symhdr
= &debug
->symbolic_header
;
2363 bfd_size_type reloc_size
;
2364 bfd_size_type text_size
;
2366 bfd_boolean set_text_start
;
2367 bfd_size_type data_size
;
2369 bfd_boolean set_data_start
;
2370 bfd_size_type bss_size
;
2372 void * reloc_buff
= NULL
;
2373 struct internal_filehdr internal_f
;
2374 struct internal_aouthdr internal_a
;
2377 /* Determine where the sections and relocs will go in the output
2379 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2382 for (current
= abfd
->sections
;
2384 current
= current
->next
)
2386 current
->target_index
= count
;
2390 if ((abfd
->flags
& D_PAGED
) != 0)
2391 text_size
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2395 set_text_start
= FALSE
;
2398 set_data_start
= FALSE
;
2401 /* Write section headers to the file. */
2403 /* Allocate buff big enough to hold a section header,
2404 file header, or a.out header. */
2413 buff
= bfd_malloc (siz
);
2418 internal_f
.f_nscns
= 0;
2419 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2422 for (current
= abfd
->sections
;
2424 current
= current
->next
)
2426 struct internal_scnhdr section
;
2429 ++internal_f
.f_nscns
;
2431 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2433 /* This seems to be correct for Irix 4 shared libraries. */
2434 vma
= bfd_get_section_vma (abfd
, current
);
2435 if (streq (current
->name
, _LIB
))
2436 section
.s_vaddr
= 0;
2438 section
.s_vaddr
= vma
;
2440 section
.s_paddr
= current
->lma
;
2441 section
.s_size
= current
->size
;
2443 /* If this section is unloadable then the scnptr will be 0. */
2444 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2445 section
.s_scnptr
= 0;
2447 section
.s_scnptr
= current
->filepos
;
2448 section
.s_relptr
= current
->rel_filepos
;
2450 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2451 object file produced by the assembler is supposed to point to
2452 information about how much room is required by objects of
2453 various different sizes. I think this only matters if we
2454 want the linker to compute the best size to use, or
2455 something. I don't know what happens if the information is
2457 if (! streq (current
->name
, _PDATA
))
2458 section
.s_lnnoptr
= 0;
2461 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2462 hold the number of entries in the section (each entry is
2463 8 bytes). We stored this in the line_filepos field in
2464 ecoff_compute_section_file_positions. */
2465 section
.s_lnnoptr
= current
->line_filepos
;
2468 section
.s_nreloc
= current
->reloc_count
;
2469 section
.s_nlnno
= 0;
2470 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2473 if (bfd_coff_swap_scnhdr_out (abfd
, (void *) §ion
, buff
) == 0
2474 || bfd_bwrite (buff
, scnhsz
, abfd
) != scnhsz
)
2477 if ((section
.s_flags
& STYP_TEXT
) != 0
2478 || ((section
.s_flags
& STYP_RDATA
) != 0
2479 && ecoff_data (abfd
)->rdata_in_text
)
2480 || section
.s_flags
== STYP_PDATA
2481 || (section
.s_flags
& STYP_DYNAMIC
) != 0
2482 || (section
.s_flags
& STYP_LIBLIST
) != 0
2483 || (section
.s_flags
& STYP_RELDYN
) != 0
2484 || section
.s_flags
== STYP_CONFLIC
2485 || (section
.s_flags
& STYP_DYNSTR
) != 0
2486 || (section
.s_flags
& STYP_DYNSYM
) != 0
2487 || (section
.s_flags
& STYP_HASH
) != 0
2488 || (section
.s_flags
& STYP_ECOFF_INIT
) != 0
2489 || (section
.s_flags
& STYP_ECOFF_FINI
) != 0
2490 || section
.s_flags
== STYP_RCONST
)
2492 text_size
+= current
->size
;
2493 if (! set_text_start
|| text_start
> vma
)
2496 set_text_start
= TRUE
;
2499 else if ((section
.s_flags
& STYP_RDATA
) != 0
2500 || (section
.s_flags
& STYP_DATA
) != 0
2501 || (section
.s_flags
& STYP_LITA
) != 0
2502 || (section
.s_flags
& STYP_LIT8
) != 0
2503 || (section
.s_flags
& STYP_LIT4
) != 0
2504 || (section
.s_flags
& STYP_SDATA
) != 0
2505 || section
.s_flags
== STYP_XDATA
2506 || (section
.s_flags
& STYP_GOT
) != 0)
2508 data_size
+= current
->size
;
2509 if (! set_data_start
|| data_start
> vma
)
2512 set_data_start
= TRUE
;
2515 else if ((section
.s_flags
& STYP_BSS
) != 0
2516 || (section
.s_flags
& STYP_SBSS
) != 0)
2517 bss_size
+= current
->size
;
2518 else if (section
.s_flags
== 0
2519 || (section
.s_flags
& STYP_ECOFF_LIB
) != 0
2520 || section
.s_flags
== STYP_COMMENT
)
2526 /* Set up the file header. */
2527 internal_f
.f_magic
= ecoff_get_magic (abfd
);
2529 /* We will NOT put a fucking timestamp in the header here. Every
2530 time you put it back, I will come in and take it out again. I'm
2531 sorry. This field does not belong here. We fill it with a 0 so
2532 it compares the same but is not a reasonable time. --
2534 internal_f
.f_timdat
= 0;
2536 if (bfd_get_symcount (abfd
) != 0)
2538 /* The ECOFF f_nsyms field is not actually the number of
2539 symbols, it's the size of symbolic information header. */
2540 internal_f
.f_nsyms
= external_hdr_size
;
2541 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
2545 internal_f
.f_nsyms
= 0;
2546 internal_f
.f_symptr
= 0;
2549 internal_f
.f_opthdr
= aoutsz
;
2551 internal_f
.f_flags
= F_LNNO
;
2552 if (reloc_size
== 0)
2553 internal_f
.f_flags
|= F_RELFLG
;
2554 if (bfd_get_symcount (abfd
) == 0)
2555 internal_f
.f_flags
|= F_LSYMS
;
2556 if (abfd
->flags
& EXEC_P
)
2557 internal_f
.f_flags
|= F_EXEC
;
2559 if (bfd_little_endian (abfd
))
2560 internal_f
.f_flags
|= F_AR32WR
;
2562 internal_f
.f_flags
|= F_AR32W
;
2564 /* Set up the ``optional'' header. */
2565 if ((abfd
->flags
& D_PAGED
) != 0)
2566 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
2568 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
2570 /* FIXME: Is this really correct? */
2571 internal_a
.vstamp
= symhdr
->vstamp
;
2573 /* At least on Ultrix, these have to be rounded to page boundaries.
2574 FIXME: Is this true on other platforms? */
2575 if ((abfd
->flags
& D_PAGED
) != 0)
2577 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
2578 internal_a
.text_start
= text_start
&~ (round
- 1);
2579 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
2580 internal_a
.data_start
= data_start
&~ (round
- 1);
2584 internal_a
.tsize
= text_size
;
2585 internal_a
.text_start
= text_start
;
2586 internal_a
.dsize
= data_size
;
2587 internal_a
.data_start
= data_start
;
2590 /* On Ultrix, the initial portions of the .sbss and .bss segments
2591 are at the end of the data section. The bsize field in the
2592 optional header records how many bss bytes are required beyond
2593 those in the data section. The value is not rounded to a page
2595 if (bss_size
< internal_a
.dsize
- data_size
)
2598 bss_size
-= internal_a
.dsize
- data_size
;
2599 internal_a
.bsize
= bss_size
;
2600 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
2602 internal_a
.entry
= bfd_get_start_address (abfd
);
2604 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
2606 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
2607 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
2608 for (i
= 0; i
< 4; i
++)
2609 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
2611 /* Let the backend adjust the headers if necessary. */
2612 if (backend
->adjust_headers
)
2614 if (! (*backend
->adjust_headers
) (abfd
, &internal_f
, &internal_a
))
2618 /* Write out the file header and the optional header. */
2619 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2622 bfd_coff_swap_filehdr_out (abfd
, (void *) &internal_f
, buff
);
2623 if (bfd_bwrite (buff
, filhsz
, abfd
) != filhsz
)
2626 bfd_coff_swap_aouthdr_out (abfd
, (void *) &internal_a
, buff
);
2627 if (bfd_bwrite (buff
, aoutsz
, abfd
) != aoutsz
)
2630 /* Build the external symbol information. This must be done before
2631 writing out the relocs so that we know the symbol indices. We
2632 don't do this if this BFD was created by the backend linker,
2633 since it will have already handled the symbols and relocs. */
2634 if (! ecoff_data (abfd
)->linker
)
2636 symhdr
->iextMax
= 0;
2637 symhdr
->issExtMax
= 0;
2638 debug
->external_ext
= debug
->external_ext_end
= NULL
;
2639 debug
->ssext
= debug
->ssext_end
= NULL
;
2640 if (! bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
2641 (abfd
->flags
& EXEC_P
) == 0,
2642 ecoff_get_extr
, ecoff_set_index
))
2645 /* Write out the relocs. */
2646 for (current
= abfd
->sections
;
2648 current
= current
->next
)
2650 arelent
**reloc_ptr_ptr
;
2651 arelent
**reloc_end
;
2655 if (current
->reloc_count
== 0)
2658 amt
= current
->reloc_count
* external_reloc_size
;
2659 reloc_buff
= bfd_alloc (abfd
, amt
);
2660 if (reloc_buff
== NULL
)
2663 reloc_ptr_ptr
= current
->orelocation
;
2664 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
2665 out_ptr
= (char *) reloc_buff
;
2668 reloc_ptr_ptr
< reloc_end
;
2669 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
2673 struct internal_reloc in
;
2675 memset ((void *) &in
, 0, sizeof in
);
2677 reloc
= *reloc_ptr_ptr
;
2678 sym
= *reloc
->sym_ptr_ptr
;
2680 /* If the howto field has not been initialised then skip this reloc.
2681 This assumes that an error message has been issued elsewhere. */
2682 if (reloc
->howto
== NULL
)
2685 in
.r_vaddr
= (reloc
->address
2686 + bfd_get_section_vma (abfd
, current
));
2687 in
.r_type
= reloc
->howto
->type
;
2689 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2691 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2705 { _TEXT
, RELOC_SECTION_TEXT
},
2706 { _RDATA
, RELOC_SECTION_RDATA
},
2707 { _DATA
, RELOC_SECTION_DATA
},
2708 { _SDATA
, RELOC_SECTION_SDATA
},
2709 { _SBSS
, RELOC_SECTION_SBSS
},
2710 { _BSS
, RELOC_SECTION_BSS
},
2711 { _INIT
, RELOC_SECTION_INIT
},
2712 { _LIT8
, RELOC_SECTION_LIT8
},
2713 { _LIT4
, RELOC_SECTION_LIT4
},
2714 { _XDATA
, RELOC_SECTION_XDATA
},
2715 { _PDATA
, RELOC_SECTION_PDATA
},
2716 { _FINI
, RELOC_SECTION_FINI
},
2717 { _LITA
, RELOC_SECTION_LITA
},
2718 { "*ABS*", RELOC_SECTION_ABS
},
2719 { _RCONST
, RELOC_SECTION_RCONST
}
2722 name
= bfd_get_section_name (abfd
, bfd_get_section (sym
));
2724 for (j
= 0; j
< ARRAY_SIZE (section_symndx
); j
++)
2725 if (streq (name
, section_symndx
[j
].name
))
2727 in
.r_symndx
= section_symndx
[j
].r_symndx
;
2731 if (j
== ARRAY_SIZE (section_symndx
))
2736 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2738 (*swap_reloc_out
) (abfd
, &in
, (void *) out_ptr
);
2741 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2743 amt
= current
->reloc_count
* external_reloc_size
;
2744 if (bfd_bwrite (reloc_buff
, amt
, abfd
) != amt
)
2746 bfd_release (abfd
, reloc_buff
);
2750 /* Write out the symbolic debugging information. */
2751 if (bfd_get_symcount (abfd
) > 0)
2753 /* Write out the debugging information. */
2754 if (! bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2755 ecoff_data (abfd
)->sym_filepos
))
2760 /* The .bss section of a demand paged executable must receive an
2761 entire page. If there are symbols, the symbols will start on the
2762 next page. If there are no symbols, we must fill out the page by
2764 if (bfd_get_symcount (abfd
) == 0
2765 && (abfd
->flags
& EXEC_P
) != 0
2766 && (abfd
->flags
& D_PAGED
) != 0)
2770 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2773 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) == 0)
2775 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2778 if (bfd_bwrite (&c
, (bfd_size_type
) 1, abfd
) != 1)
2782 if (reloc_buff
!= NULL
)
2783 bfd_release (abfd
, reloc_buff
);
2788 if (reloc_buff
!= NULL
)
2789 bfd_release (abfd
, reloc_buff
);
2795 /* Archive handling. ECOFF uses what appears to be a unique type of
2796 archive header (armap). The byte ordering of the armap and the
2797 contents are encoded in the name of the armap itself. At least for
2798 now, we only support archives with the same byte ordering in the
2799 armap and the contents.
2801 The first four bytes in the armap are the number of symbol
2802 definitions. This is always a power of two.
2804 This is followed by the symbol definitions. Each symbol definition
2805 occupies 8 bytes. The first four bytes are the offset from the
2806 start of the armap strings to the null-terminated string naming
2807 this symbol. The second four bytes are the file offset to the
2808 archive member which defines this symbol. If the second four bytes
2809 are 0, then this is not actually a symbol definition, and it should
2812 The symbols are hashed into the armap with a closed hashing scheme.
2813 See the functions below for the details of the algorithm.
2815 After the symbol definitions comes four bytes holding the size of
2816 the string table, followed by the string table itself. */
2818 /* The name of an archive headers looks like this:
2819 __________E[BL]E[BL]_ (with a trailing space).
2820 The trailing space is changed to an X if the archive is changed to
2821 indicate that the armap is out of date.
2823 The Alpha seems to use ________64E[BL]E[BL]_. */
2825 #define ARMAP_BIG_ENDIAN 'B'
2826 #define ARMAP_LITTLE_ENDIAN 'L'
2827 #define ARMAP_MARKER 'E'
2828 #define ARMAP_START_LENGTH 10
2829 #define ARMAP_HEADER_MARKER_INDEX 10
2830 #define ARMAP_HEADER_ENDIAN_INDEX 11
2831 #define ARMAP_OBJECT_MARKER_INDEX 12
2832 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2833 #define ARMAP_END_INDEX 14
2834 #define ARMAP_END "_ "
2836 /* This is a magic number used in the hashing algorithm. */
2837 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2839 /* This returns the hash value to use for a string. It also sets
2840 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2841 is the number of entries in the hash table, and HLOG is the log
2845 ecoff_armap_hash (const char *s
,
2846 unsigned int *rehash
,
2856 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2857 hash
*= ARMAP_HASH_MAGIC
;
2858 *rehash
= (hash
& (size
- 1)) | 1;
2859 return hash
>> (32 - hlog
);
2862 /* Read in the armap. */
2865 _bfd_ecoff_slurp_armap (bfd
*abfd
)
2869 struct areltdata
*mapdata
;
2870 bfd_size_type parsed_size
;
2872 struct artdata
*ardata
;
2879 /* Get the name of the first element. */
2880 i
= bfd_bread ((void *) nextname
, (bfd_size_type
) 16, abfd
);
2886 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2889 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2890 standard COFF armap. We could move the ECOFF armap stuff into
2891 bfd_slurp_armap, but that seems inappropriate since no other
2892 target uses this format. Instead, we check directly for a COFF
2894 if (CONST_STRNEQ (nextname
, "/ "))
2895 return bfd_slurp_armap (abfd
);
2897 /* See if the first element is an armap. */
2898 if (! strneq (nextname
, ecoff_backend (abfd
)->armap_start
, ARMAP_START_LENGTH
)
2899 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
2900 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2901 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2902 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
2903 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2904 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2905 || ! strneq (nextname
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1))
2907 abfd
->has_armap
= FALSE
;
2911 /* Make sure we have the right byte ordering. */
2912 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2913 ^ (bfd_header_big_endian (abfd
)))
2914 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2915 ^ (bfd_big_endian (abfd
))))
2917 bfd_set_error (bfd_error_wrong_format
);
2921 /* Read in the armap. */
2922 ardata
= bfd_ardata (abfd
);
2923 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
2924 if (mapdata
== NULL
)
2926 parsed_size
= mapdata
->parsed_size
;
2929 raw_armap
= (char *) bfd_alloc (abfd
, parsed_size
);
2930 if (raw_armap
== NULL
)
2933 if (bfd_bread ((void *) raw_armap
, parsed_size
, abfd
) != parsed_size
)
2935 if (bfd_get_error () != bfd_error_system_call
)
2936 bfd_set_error (bfd_error_malformed_archive
);
2937 bfd_release (abfd
, (void *) raw_armap
);
2941 ardata
->tdata
= (void *) raw_armap
;
2943 count
= H_GET_32 (abfd
, raw_armap
);
2945 ardata
->symdef_count
= 0;
2946 ardata
->cache
= NULL
;
2948 /* This code used to overlay the symdefs over the raw archive data,
2949 but that doesn't work on a 64 bit host. */
2950 stringbase
= raw_armap
+ count
* 8 + 8;
2952 #ifdef CHECK_ARMAP_HASH
2956 /* Double check that I have the hashing algorithm right by making
2957 sure that every symbol can be looked up successfully. */
2959 for (i
= 1; i
< count
; i
<<= 1)
2961 BFD_ASSERT (i
== count
);
2963 raw_ptr
= raw_armap
+ 4;
2964 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2966 unsigned int name_offset
, file_offset
;
2967 unsigned int hash
, rehash
, srch
;
2969 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2970 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2971 if (file_offset
== 0)
2973 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
2978 /* See if we can rehash to this location. */
2979 for (srch
= (hash
+ rehash
) & (count
- 1);
2980 srch
!= hash
&& srch
!= i
;
2981 srch
= (srch
+ rehash
) & (count
- 1))
2982 BFD_ASSERT (H_GET_32 (abfd
, (raw_armap
+ 8 + srch
* 8)) != 0);
2983 BFD_ASSERT (srch
== i
);
2987 #endif /* CHECK_ARMAP_HASH */
2989 raw_ptr
= raw_armap
+ 4;
2990 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2991 if (H_GET_32 (abfd
, (raw_ptr
+ 4)) != 0)
2992 ++ardata
->symdef_count
;
2994 amt
= ardata
->symdef_count
;
2995 amt
*= sizeof (carsym
);
2996 symdef_ptr
= (carsym
*) bfd_alloc (abfd
, amt
);
3000 ardata
->symdefs
= symdef_ptr
;
3002 raw_ptr
= raw_armap
+ 4;
3003 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3005 unsigned int name_offset
, file_offset
;
3007 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
3008 if (file_offset
== 0)
3010 name_offset
= H_GET_32 (abfd
, raw_ptr
);
3011 symdef_ptr
->name
= stringbase
+ name_offset
;
3012 symdef_ptr
->file_offset
= file_offset
;
3016 ardata
->first_file_filepos
= bfd_tell (abfd
);
3017 /* Pad to an even boundary. */
3018 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
3020 abfd
->has_armap
= TRUE
;
3025 /* Write out an armap. */
3028 _bfd_ecoff_write_armap (bfd
*abfd
,
3029 unsigned int elength
,
3031 unsigned int orl_count
,
3034 unsigned int hashsize
, hashlog
;
3035 bfd_size_type symdefsize
;
3037 unsigned int stringsize
;
3038 unsigned int mapsize
;
3041 struct stat statbuf
;
3044 bfd_byte
*hashtable
;
3048 /* Ultrix appears to use as a hash table size the least power of two
3049 greater than twice the number of entries. */
3050 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3052 hashsize
= 1 << hashlog
;
3054 symdefsize
= hashsize
* 8;
3056 stringsize
= stridx
+ padit
;
3058 /* Include 8 bytes to store symdefsize and stringsize in output. */
3059 mapsize
= symdefsize
+ stringsize
+ 8;
3061 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3063 memset ((void *) &hdr
, 0, sizeof hdr
);
3065 /* Work out the ECOFF armap name. */
3066 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3067 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3068 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3069 (bfd_header_big_endian (abfd
)
3071 : ARMAP_LITTLE_ENDIAN
);
3072 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3073 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3074 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3075 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3077 /* Write the timestamp of the archive header to be just a little bit
3078 later than the timestamp of the file, otherwise the linker will
3079 complain that the index is out of date. Actually, the Ultrix
3080 linker just checks the archive name; the GNU linker may check the
3082 stat (abfd
->filename
, &statbuf
);
3083 _bfd_ar_spacepad (hdr
.ar_date
, sizeof (hdr
.ar_date
), "%ld",
3084 (long) (statbuf
.st_mtime
+ 60));
3086 /* The DECstation uses zeroes for the uid, gid and mode of the
3088 hdr
.ar_uid
[0] = '0';
3089 hdr
.ar_gid
[0] = '0';
3090 /* Building gcc ends up extracting the armap as a file - twice. */
3091 hdr
.ar_mode
[0] = '6';
3092 hdr
.ar_mode
[1] = '4';
3093 hdr
.ar_mode
[2] = '4';
3095 _bfd_ar_spacepad (hdr
.ar_size
, sizeof (hdr
.ar_size
), "%-10ld", mapsize
);
3097 hdr
.ar_fmag
[0] = '`';
3098 hdr
.ar_fmag
[1] = '\012';
3100 /* Turn all null bytes in the header into spaces. */
3101 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3102 if (((char *) (&hdr
))[i
] == '\0')
3103 (((char *) (&hdr
))[i
]) = ' ';
3105 if (bfd_bwrite ((void *) &hdr
, (bfd_size_type
) sizeof (struct ar_hdr
), abfd
)
3106 != sizeof (struct ar_hdr
))
3109 H_PUT_32 (abfd
, hashsize
, temp
);
3110 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3113 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3117 current
= abfd
->archive_head
;
3119 for (i
= 0; i
< orl_count
; i
++)
3121 unsigned int hash
, rehash
= 0;
3123 /* Advance firstreal to the file position of this archive
3125 if (map
[i
].u
.abfd
!= last_elt
)
3129 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3130 firstreal
+= firstreal
% 2;
3131 current
= current
->archive_next
;
3133 while (current
!= map
[i
].u
.abfd
);
3138 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3139 if (H_GET_32 (abfd
, (hashtable
+ (hash
* 8) + 4)) != 0)
3143 /* The desired slot is already taken. */
3144 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3146 srch
= (srch
+ rehash
) & (hashsize
- 1))
3147 if (H_GET_32 (abfd
, (hashtable
+ (srch
* 8) + 4)) == 0)
3150 BFD_ASSERT (srch
!= hash
);
3155 H_PUT_32 (abfd
, map
[i
].namidx
, (hashtable
+ hash
* 8));
3156 H_PUT_32 (abfd
, firstreal
, (hashtable
+ hash
* 8 + 4));
3159 if (bfd_bwrite ((void *) hashtable
, symdefsize
, abfd
) != symdefsize
)
3162 bfd_release (abfd
, hashtable
);
3164 /* Now write the strings. */
3165 H_PUT_32 (abfd
, stringsize
, temp
);
3166 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3168 for (i
= 0; i
< orl_count
; i
++)
3172 len
= strlen (*map
[i
].name
) + 1;
3173 if (bfd_bwrite ((void *) (*map
[i
].name
), len
, abfd
) != len
)
3177 /* The spec sez this should be a newline. But in order to be
3178 bug-compatible for DECstation ar we use a null. */
3181 if (bfd_bwrite ("", (bfd_size_type
) 1, abfd
) != 1)
3188 /* ECOFF linker code. */
3190 /* Routine to create an entry in an ECOFF link hash table. */
3192 static struct bfd_hash_entry
*
3193 ecoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
3194 struct bfd_hash_table
*table
,
3197 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3199 /* Allocate the structure if it has not already been allocated by a
3202 ret
= ((struct ecoff_link_hash_entry
*)
3203 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3207 /* Call the allocation method of the superclass. */
3208 ret
= ((struct ecoff_link_hash_entry
*)
3209 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3214 /* Set local fields. */
3220 memset ((void *) &ret
->esym
, 0, sizeof ret
->esym
);
3222 return (struct bfd_hash_entry
*) ret
;
3225 /* Create an ECOFF link hash table. */
3227 struct bfd_link_hash_table
*
3228 _bfd_ecoff_bfd_link_hash_table_create (bfd
*abfd
)
3230 struct ecoff_link_hash_table
*ret
;
3231 bfd_size_type amt
= sizeof (struct ecoff_link_hash_table
);
3233 ret
= (struct ecoff_link_hash_table
*) bfd_malloc (amt
);
3236 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
,
3237 ecoff_link_hash_newfunc
,
3238 sizeof (struct ecoff_link_hash_entry
)))
3246 /* Look up an entry in an ECOFF link hash table. */
3248 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3249 ((struct ecoff_link_hash_entry *) \
3250 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3252 /* Get the ECOFF link hash table from the info structure. This is
3255 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3257 /* Add the external symbols of an object file to the global linker
3258 hash table. The external symbols and strings we are passed are
3259 just allocated on the stack, and will be discarded. We must
3260 explicitly save any information we may need later on in the link.
3261 We do not want to read the external symbol information again. */
3264 ecoff_link_add_externals (bfd
*abfd
,
3265 struct bfd_link_info
*info
,
3266 void * external_ext
,
3269 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3270 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3271 = backend
->debug_swap
.swap_ext_in
;
3272 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3273 unsigned long ext_count
;
3274 struct bfd_link_hash_entry
**sym_hash
;
3279 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3282 amt
*= sizeof (struct bfd_link_hash_entry
*);
3283 sym_hash
= (struct bfd_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3286 ecoff_data (abfd
)->sym_hashes
= (struct ecoff_link_hash_entry
**) sym_hash
;
3288 ext_ptr
= (char *) external_ext
;
3289 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3290 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3297 struct ecoff_link_hash_entry
*h
;
3301 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3303 /* Skip debugging symbols. */
3305 switch (esym
.asym
.st
)
3321 /* Get the information for this symbol. */
3322 value
= esym
.asym
.value
;
3323 switch (esym
.asym
.sc
)
3343 section
= bfd_make_section_old_way (abfd
, _TEXT
);
3344 value
-= section
->vma
;
3347 section
= bfd_make_section_old_way (abfd
, _DATA
);
3348 value
-= section
->vma
;
3351 section
= bfd_make_section_old_way (abfd
, _BSS
);
3352 value
-= section
->vma
;
3355 section
= bfd_abs_section_ptr
;
3358 section
= bfd_und_section_ptr
;
3361 section
= bfd_make_section_old_way (abfd
, _SDATA
);
3362 value
-= section
->vma
;
3365 section
= bfd_make_section_old_way (abfd
, _SBSS
);
3366 value
-= section
->vma
;
3369 section
= bfd_make_section_old_way (abfd
, _RDATA
);
3370 value
-= section
->vma
;
3373 if (value
> ecoff_data (abfd
)->gp_size
)
3375 section
= bfd_com_section_ptr
;
3380 if (ecoff_scom_section
.name
== NULL
)
3382 /* Initialize the small common section. */
3383 ecoff_scom_section
.name
= SCOMMON
;
3384 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
3385 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
3386 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
3387 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
3388 ecoff_scom_symbol
.name
= SCOMMON
;
3389 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
3390 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
3391 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
3393 section
= &ecoff_scom_section
;
3396 section
= bfd_und_section_ptr
;
3399 section
= bfd_make_section_old_way (abfd
, _INIT
);
3400 value
-= section
->vma
;
3403 section
= bfd_make_section_old_way (abfd
, _FINI
);
3404 value
-= section
->vma
;
3407 section
= bfd_make_section_old_way (abfd
, _RCONST
);
3408 value
-= section
->vma
;
3412 if (section
== NULL
)
3415 name
= ssext
+ esym
.asym
.iss
;
3417 if (! (_bfd_generic_link_add_one_symbol
3419 (flagword
) (esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
),
3420 section
, value
, NULL
, TRUE
, TRUE
, sym_hash
)))
3423 h
= (struct ecoff_link_hash_entry
*) *sym_hash
;
3425 /* If we are building an ECOFF hash table, save the external
3426 symbol information. */
3427 if (bfd_get_flavour (info
->output_bfd
) == bfd_get_flavour (abfd
))
3430 || (! bfd_is_und_section (section
)
3431 && (! bfd_is_com_section (section
)
3432 || (h
->root
.type
!= bfd_link_hash_defined
3433 && h
->root
.type
!= bfd_link_hash_defweak
))))
3439 /* Remember whether this symbol was small undefined. */
3440 if (esym
.asym
.sc
== scSUndefined
)
3443 /* If this symbol was ever small undefined, it needs to wind
3444 up in a GP relative section. We can't control the
3445 section of a defined symbol, but we can control the
3446 section of a common symbol. This case is actually needed
3447 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3449 && h
->root
.type
== bfd_link_hash_common
3450 && streq (h
->root
.u
.c
.p
->section
->name
, SCOMMON
))
3452 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
3454 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
3455 if (h
->esym
.asym
.sc
== scCommon
)
3456 h
->esym
.asym
.sc
= scSCommon
;
3464 /* Add symbols from an ECOFF object file to the global linker hash
3468 ecoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3471 bfd_size_type external_ext_size
;
3472 void * external_ext
= NULL
;
3473 bfd_size_type esize
;
3477 if (! ecoff_slurp_symbolic_header (abfd
))
3480 /* If there are no symbols, we don't want it. */
3481 if (bfd_get_symcount (abfd
) == 0)
3484 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3486 /* Read in the external symbols and external strings. */
3487 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3488 esize
= symhdr
->iextMax
* external_ext_size
;
3489 external_ext
= bfd_malloc (esize
);
3490 if (external_ext
== NULL
&& esize
!= 0)
3493 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbExtOffset
, SEEK_SET
) != 0
3494 || bfd_bread (external_ext
, esize
, abfd
) != esize
)
3497 ssext
= (char *) bfd_malloc ((bfd_size_type
) symhdr
->issExtMax
);
3498 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3501 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
3502 || (bfd_bread (ssext
, (bfd_size_type
) symhdr
->issExtMax
, abfd
)
3503 != (bfd_size_type
) symhdr
->issExtMax
))
3506 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3510 if (external_ext
!= NULL
)
3511 free (external_ext
);
3517 if (external_ext
!= NULL
)
3518 free (external_ext
);
3522 /* This is called if we used _bfd_generic_link_add_archive_symbols
3523 because we were not dealing with an ECOFF archive. */
3526 ecoff_link_check_archive_element (bfd
*abfd
,
3527 struct bfd_link_info
*info
,
3528 struct bfd_link_hash_entry
*h
,
3530 bfd_boolean
*pneeded
)
3534 /* Unlike the generic linker, we do not pull in elements because
3535 of common symbols. */
3536 if (h
->type
!= bfd_link_hash_undefined
)
3539 /* Include this element? */
3540 if (!(*info
->callbacks
->add_archive_element
) (info
, abfd
, name
, &abfd
))
3544 return ecoff_link_add_object_symbols (abfd
, info
);
3547 /* Add the symbols from an archive file to the global hash table.
3548 This looks through the undefined symbols, looks each one up in the
3549 archive hash table, and adds any associated object file. We do not
3550 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3551 already have a hash table, so there is no reason to construct
3555 ecoff_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3557 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3558 const bfd_byte
*raw_armap
;
3559 struct bfd_link_hash_entry
**pundef
;
3560 unsigned int armap_count
;
3561 unsigned int armap_log
;
3563 const bfd_byte
*hashtable
;
3564 const char *stringbase
;
3566 if (! bfd_has_map (abfd
))
3568 /* An empty archive is a special case. */
3569 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
3571 bfd_set_error (bfd_error_no_armap
);
3575 /* If we don't have any raw data for this archive, as can happen on
3576 Irix 4.0.5F, we call the generic routine.
3577 FIXME: We should be more clever about this, since someday tdata
3578 may get to something for a generic archive. */
3579 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3580 if (raw_armap
== NULL
)
3581 return (_bfd_generic_link_add_archive_symbols
3582 (abfd
, info
, ecoff_link_check_archive_element
));
3584 armap_count
= H_GET_32 (abfd
, raw_armap
);
3587 for (i
= 1; i
< armap_count
; i
<<= 1)
3589 BFD_ASSERT (i
== armap_count
);
3591 hashtable
= raw_armap
+ 4;
3592 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3594 /* Look through the list of undefined symbols. */
3595 pundef
= &info
->hash
->undefs
;
3596 while (*pundef
!= NULL
)
3598 struct bfd_link_hash_entry
*h
;
3599 unsigned int hash
, rehash
= 0;
3600 unsigned int file_offset
;
3606 /* When a symbol is defined, it is not necessarily removed from
3608 if (h
->type
!= bfd_link_hash_undefined
3609 && h
->type
!= bfd_link_hash_common
)
3611 /* Remove this entry from the list, for general cleanliness
3612 and because we are going to look through the list again
3613 if we search any more libraries. We can't remove the
3614 entry if it is the tail, because that would lose any
3615 entries we add to the list later on. */
3616 if (*pundef
!= info
->hash
->undefs_tail
)
3617 *pundef
= (*pundef
)->u
.undef
.next
;
3619 pundef
= &(*pundef
)->u
.undef
.next
;
3623 /* Native ECOFF linkers do not pull in archive elements merely
3624 to satisfy common definitions, so neither do we. We leave
3625 them on the list, though, in case we are linking against some
3626 other object format. */
3627 if (h
->type
!= bfd_link_hash_undefined
)
3629 pundef
= &(*pundef
)->u
.undef
.next
;
3633 /* Look for this symbol in the archive hash table. */
3634 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3637 file_offset
= H_GET_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3638 if (file_offset
== 0)
3640 /* Nothing in this slot. */
3641 pundef
= &(*pundef
)->u
.undef
.next
;
3645 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (hash
* 8));
3646 if (name
[0] != h
->root
.string
[0]
3647 || ! streq (name
, h
->root
.string
))
3652 /* That was the wrong symbol. Try rehashing. */
3654 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3656 srch
= (srch
+ rehash
) & (armap_count
- 1))
3658 file_offset
= H_GET_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3659 if (file_offset
== 0)
3661 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (srch
* 8));
3662 if (name
[0] == h
->root
.string
[0]
3663 && streq (name
, h
->root
.string
))
3672 pundef
= &(*pundef
)->u
.undef
.next
;
3679 element
= (*backend
->get_elt_at_filepos
) (abfd
, (file_ptr
) file_offset
);
3680 if (element
== NULL
)
3683 if (! bfd_check_format (element
, bfd_object
))
3686 /* Unlike the generic linker, we know that this element provides
3687 a definition for an undefined symbol and we know that we want
3688 to include it. We don't need to check anything. */
3689 if (!(*info
->callbacks
3690 ->add_archive_element
) (info
, element
, name
, &element
))
3692 if (! ecoff_link_add_object_symbols (element
, info
))
3695 pundef
= &(*pundef
)->u
.undef
.next
;
3701 /* Given an ECOFF BFD, add symbols to the global hash table as
3705 _bfd_ecoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3707 switch (bfd_get_format (abfd
))
3710 return ecoff_link_add_object_symbols (abfd
, info
);
3712 return ecoff_link_add_archive_symbols (abfd
, info
);
3714 bfd_set_error (bfd_error_wrong_format
);
3720 /* ECOFF final link routines. */
3722 /* Structure used to pass information to ecoff_link_write_external. */
3727 struct bfd_link_info
*info
;
3730 /* Accumulate the debugging information for an input BFD into the
3731 output BFD. This must read in the symbolic information of the
3735 ecoff_final_link_debug_accumulate (bfd
*output_bfd
,
3737 struct bfd_link_info
*info
,
3740 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
3741 const struct ecoff_debug_swap
* const swap
=
3742 &ecoff_backend (input_bfd
)->debug_swap
;
3743 HDRR
*symhdr
= &debug
->symbolic_header
;
3746 #define READ(ptr, offset, count, size, type) \
3747 if (symhdr->count == 0) \
3748 debug->ptr = NULL; \
3751 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
3752 debug->ptr = (type) bfd_malloc (amt); \
3753 if (debug->ptr == NULL) \
3756 goto return_something; \
3758 if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3759 || bfd_bread (debug->ptr, amt, input_bfd) != amt) \
3762 goto return_something; \
3766 /* If raw_syments is not NULL, then the data was already by read by
3767 _bfd_ecoff_slurp_symbolic_info. */
3768 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3770 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
3772 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
3773 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
3774 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
3775 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
3776 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3778 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3779 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
3780 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
3784 /* We do not read the external strings or the external symbols. */
3786 ret
= (bfd_ecoff_debug_accumulate
3787 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
3788 &ecoff_backend (output_bfd
)->debug_swap
,
3789 input_bfd
, debug
, swap
, info
));
3792 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3794 if (debug
->line
!= NULL
)
3796 if (debug
->external_dnr
!= NULL
)
3797 free (debug
->external_dnr
);
3798 if (debug
->external_pdr
!= NULL
)
3799 free (debug
->external_pdr
);
3800 if (debug
->external_sym
!= NULL
)
3801 free (debug
->external_sym
);
3802 if (debug
->external_opt
!= NULL
)
3803 free (debug
->external_opt
);
3804 if (debug
->external_aux
!= NULL
)
3805 free (debug
->external_aux
);
3806 if (debug
->ss
!= NULL
)
3808 if (debug
->external_fdr
!= NULL
)
3809 free (debug
->external_fdr
);
3810 if (debug
->external_rfd
!= NULL
)
3811 free (debug
->external_rfd
);
3813 /* Make sure we don't accidentally follow one of these pointers
3814 into freed memory. */
3816 debug
->external_dnr
= NULL
;
3817 debug
->external_pdr
= NULL
;
3818 debug
->external_sym
= NULL
;
3819 debug
->external_opt
= NULL
;
3820 debug
->external_aux
= NULL
;
3822 debug
->external_fdr
= NULL
;
3823 debug
->external_rfd
= NULL
;
3829 /* Relocate and write an ECOFF section into an ECOFF output file. */
3832 ecoff_indirect_link_order (bfd
*output_bfd
,
3833 struct bfd_link_info
*info
,
3834 asection
*output_section
,
3835 struct bfd_link_order
*link_order
)
3837 asection
*input_section
;
3839 bfd_byte
*contents
= NULL
;
3840 bfd_size_type external_reloc_size
;
3841 bfd_size_type external_relocs_size
;
3842 void * external_relocs
= NULL
;
3844 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
3846 input_section
= link_order
->u
.indirect
.section
;
3847 input_bfd
= input_section
->owner
;
3848 if (input_section
->size
== 0)
3851 BFD_ASSERT (input_section
->output_section
== output_section
);
3852 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
3853 BFD_ASSERT (input_section
->size
== link_order
->size
);
3855 /* Get the section contents. */
3856 if (!bfd_malloc_and_get_section (input_bfd
, input_section
, &contents
))
3859 /* Get the relocs. If we are relaxing MIPS code, they will already
3860 have been read in. Otherwise, we read them in now. */
3861 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
3862 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
3864 external_relocs
= bfd_malloc (external_relocs_size
);
3865 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
3868 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3869 || (bfd_bread (external_relocs
, external_relocs_size
, input_bfd
)
3870 != external_relocs_size
))
3873 /* Relocate the section contents. */
3874 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
3875 (output_bfd
, info
, input_bfd
, input_section
, contents
,
3879 /* Write out the relocated section. */
3880 if (! bfd_set_section_contents (output_bfd
,
3883 input_section
->output_offset
,
3884 input_section
->size
))
3887 /* If we are producing relocatable output, the relocs were
3888 modified, and we write them out now. We use the reloc_count
3889 field of output_section to keep track of the number of relocs we
3890 have output so far. */
3891 if (bfd_link_relocatable (info
))
3893 file_ptr pos
= (output_section
->rel_filepos
3894 + output_section
->reloc_count
* external_reloc_size
);
3895 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
3896 || (bfd_bwrite (external_relocs
, external_relocs_size
, output_bfd
)
3897 != external_relocs_size
))
3899 output_section
->reloc_count
+= input_section
->reloc_count
;
3902 if (contents
!= NULL
)
3904 if (external_relocs
!= NULL
)
3905 free (external_relocs
);
3909 if (contents
!= NULL
)
3911 if (external_relocs
!= NULL
)
3912 free (external_relocs
);
3916 /* Generate a reloc when linking an ECOFF file. This is a reloc
3917 requested by the linker, and does come from any input file. This
3918 is used to build constructor and destructor tables when linking
3922 ecoff_reloc_link_order (bfd
*output_bfd
,
3923 struct bfd_link_info
*info
,
3924 asection
*output_section
,
3925 struct bfd_link_order
*link_order
)
3927 enum bfd_link_order_type type
;
3931 struct internal_reloc in
;
3932 bfd_size_type external_reloc_size
;
3937 type
= link_order
->type
;
3939 addend
= link_order
->u
.reloc
.p
->addend
;
3941 /* We set up an arelent to pass to the backend adjust_reloc_out
3943 rel
.address
= link_order
->offset
;
3945 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3948 bfd_set_error (bfd_error_bad_value
);
3952 if (type
== bfd_section_reloc_link_order
)
3954 section
= link_order
->u
.reloc
.p
->u
.section
;
3955 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
3959 struct bfd_link_hash_entry
*h
;
3961 /* Treat a reloc against a defined symbol as though it were
3962 actually against the section. */
3963 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3964 link_order
->u
.reloc
.p
->u
.name
,
3965 FALSE
, FALSE
, FALSE
);
3967 && (h
->type
== bfd_link_hash_defined
3968 || h
->type
== bfd_link_hash_defweak
))
3970 type
= bfd_section_reloc_link_order
;
3971 section
= h
->u
.def
.section
->output_section
;
3972 /* It seems that we ought to add the symbol value to the
3973 addend here, but in practice it has already been added
3974 because it was passed to constructor_callback. */
3975 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
3979 /* We can't set up a reloc against a symbol correctly,
3980 because we have no asymbol structure. Currently no
3981 adjust_reloc_out routine cares. */
3982 rel
.sym_ptr_ptr
= NULL
;
3986 /* All ECOFF relocs are in-place. Put the addend into the object
3989 BFD_ASSERT (rel
.howto
->partial_inplace
);
3993 bfd_reloc_status_type rstat
;
3996 size
= bfd_get_reloc_size (rel
.howto
);
3997 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3998 if (buf
== NULL
&& size
!= 0)
4000 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
4001 (bfd_vma
) addend
, buf
);
4007 case bfd_reloc_outofrange
:
4009 case bfd_reloc_overflow
:
4010 (*info
->callbacks
->reloc_overflow
)
4012 (link_order
->type
== bfd_section_reloc_link_order
4013 ? bfd_section_name (output_bfd
, section
)
4014 : link_order
->u
.reloc
.p
->u
.name
),
4015 rel
.howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0);
4018 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
4019 (file_ptr
) link_order
->offset
, size
);
4027 /* Move the information into an internal_reloc structure. */
4028 in
.r_vaddr
= (rel
.address
4029 + bfd_get_section_vma (output_bfd
, output_section
));
4030 in
.r_type
= rel
.howto
->type
;
4032 if (type
== bfd_symbol_reloc_link_order
)
4034 struct ecoff_link_hash_entry
*h
;
4036 h
= ((struct ecoff_link_hash_entry
*)
4037 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4038 link_order
->u
.reloc
.p
->u
.name
,
4039 FALSE
, FALSE
, TRUE
));
4042 in
.r_symndx
= h
->indx
;
4045 (*info
->callbacks
->unattached_reloc
)
4046 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
4062 { _TEXT
, RELOC_SECTION_TEXT
},
4063 { _RDATA
, RELOC_SECTION_RDATA
},
4064 { _DATA
, RELOC_SECTION_DATA
},
4065 { _SDATA
, RELOC_SECTION_SDATA
},
4066 { _SBSS
, RELOC_SECTION_SBSS
},
4067 { _BSS
, RELOC_SECTION_BSS
},
4068 { _INIT
, RELOC_SECTION_INIT
},
4069 { _LIT8
, RELOC_SECTION_LIT8
},
4070 { _LIT4
, RELOC_SECTION_LIT4
},
4071 { _XDATA
, RELOC_SECTION_XDATA
},
4072 { _PDATA
, RELOC_SECTION_PDATA
},
4073 { _FINI
, RELOC_SECTION_FINI
},
4074 { _LITA
, RELOC_SECTION_LITA
},
4075 { "*ABS*", RELOC_SECTION_ABS
},
4076 { _RCONST
, RELOC_SECTION_RCONST
}
4079 name
= bfd_get_section_name (output_bfd
, section
);
4081 for (i
= 0; i
< ARRAY_SIZE (section_symndx
); i
++)
4082 if (streq (name
, section_symndx
[i
].name
))
4084 in
.r_symndx
= section_symndx
[i
].r_symndx
;
4088 if (i
== ARRAY_SIZE (section_symndx
))
4094 /* Let the BFD backend adjust the reloc. */
4095 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4097 /* Get some memory and swap out the reloc. */
4098 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4099 rbuf
= (bfd_byte
*) bfd_malloc (external_reloc_size
);
4103 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (void *) rbuf
);
4105 pos
= (output_section
->rel_filepos
4106 + output_section
->reloc_count
* external_reloc_size
);
4107 ok
= (bfd_seek (output_bfd
, pos
, SEEK_SET
) == 0
4108 && (bfd_bwrite ((void *) rbuf
, external_reloc_size
, output_bfd
)
4109 == external_reloc_size
));
4112 ++output_section
->reloc_count
;
4119 /* Put out information for an external symbol. These come only from
4123 ecoff_link_write_external (struct bfd_hash_entry
*bh
, void * data
)
4125 struct ecoff_link_hash_entry
*h
= (struct ecoff_link_hash_entry
*) bh
;
4126 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4127 bfd
*output_bfd
= einfo
->abfd
;
4130 if (h
->root
.type
== bfd_link_hash_warning
)
4132 h
= (struct ecoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4133 if (h
->root
.type
== bfd_link_hash_new
)
4137 /* We need to check if this symbol is being stripped. */
4138 if (h
->root
.type
== bfd_link_hash_undefined
4139 || h
->root
.type
== bfd_link_hash_undefweak
)
4141 else if (einfo
->info
->strip
== strip_all
4142 || (einfo
->info
->strip
== strip_some
4143 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4144 h
->root
.root
.string
,
4145 FALSE
, FALSE
) == NULL
))
4150 if (strip
|| h
->written
)
4153 if (h
->abfd
== NULL
)
4156 h
->esym
.cobol_main
= 0;
4157 h
->esym
.weakext
= 0;
4158 h
->esym
.reserved
= 0;
4159 h
->esym
.ifd
= ifdNil
;
4160 h
->esym
.asym
.value
= 0;
4161 h
->esym
.asym
.st
= stGlobal
;
4163 if (h
->root
.type
!= bfd_link_hash_defined
4164 && h
->root
.type
!= bfd_link_hash_defweak
)
4165 h
->esym
.asym
.sc
= scAbs
;
4168 asection
*output_section
;
4176 section_storage_classes
[] =
4180 { _SDATA
, scSData
},
4181 { _RDATA
, scRData
},
4186 { _PDATA
, scPData
},
4187 { _XDATA
, scXData
},
4188 { _RCONST
, scRConst
}
4191 output_section
= h
->root
.u
.def
.section
->output_section
;
4192 name
= bfd_section_name (output_section
->owner
, output_section
);
4194 for (i
= 0; i
< ARRAY_SIZE (section_storage_classes
); i
++)
4195 if (streq (name
, section_storage_classes
[i
].name
))
4197 h
->esym
.asym
.sc
= section_storage_classes
[i
].sc
;
4201 if (i
== ARRAY_SIZE (section_storage_classes
))
4202 h
->esym
.asym
.sc
= scAbs
;
4205 h
->esym
.asym
.reserved
= 0;
4206 h
->esym
.asym
.index
= indexNil
;
4208 else if (h
->esym
.ifd
!= -1)
4210 struct ecoff_debug_info
*debug
;
4212 /* Adjust the FDR index for the symbol by that used for the
4214 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4215 BFD_ASSERT (h
->esym
.ifd
>= 0
4216 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4217 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4220 switch (h
->root
.type
)
4223 case bfd_link_hash_warning
:
4224 case bfd_link_hash_new
:
4226 case bfd_link_hash_undefined
:
4227 case bfd_link_hash_undefweak
:
4228 if (h
->esym
.asym
.sc
!= scUndefined
4229 && h
->esym
.asym
.sc
!= scSUndefined
)
4230 h
->esym
.asym
.sc
= scUndefined
;
4232 case bfd_link_hash_defined
:
4233 case bfd_link_hash_defweak
:
4234 if (h
->esym
.asym
.sc
== scUndefined
4235 || h
->esym
.asym
.sc
== scSUndefined
)
4236 h
->esym
.asym
.sc
= scAbs
;
4237 else if (h
->esym
.asym
.sc
== scCommon
)
4238 h
->esym
.asym
.sc
= scBss
;
4239 else if (h
->esym
.asym
.sc
== scSCommon
)
4240 h
->esym
.asym
.sc
= scSBss
;
4241 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4242 + h
->root
.u
.def
.section
->output_section
->vma
4243 + h
->root
.u
.def
.section
->output_offset
);
4245 case bfd_link_hash_common
:
4246 if (h
->esym
.asym
.sc
!= scCommon
4247 && h
->esym
.asym
.sc
!= scSCommon
)
4248 h
->esym
.asym
.sc
= scCommon
;
4249 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4251 case bfd_link_hash_indirect
:
4252 /* We ignore these symbols, since the indirected symbol is
4253 already in the hash table. */
4257 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4259 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4262 return (bfd_ecoff_debug_one_external
4263 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4264 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4268 /* ECOFF final link routine. This looks through all the input BFDs
4269 and gathers together all the debugging information, and then
4270 processes all the link order information. This may cause it to
4271 close and reopen some input BFDs; I'll see how bad this is. */
4274 _bfd_ecoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
4276 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4277 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4282 struct bfd_link_order
*p
;
4283 struct extsym_info einfo
;
4285 /* We accumulate the debugging information counts in the symbolic
4287 symhdr
= &debug
->symbolic_header
;
4289 symhdr
->ilineMax
= 0;
4293 symhdr
->isymMax
= 0;
4294 symhdr
->ioptMax
= 0;
4295 symhdr
->iauxMax
= 0;
4297 symhdr
->issExtMax
= 0;
4300 symhdr
->iextMax
= 0;
4302 /* We accumulate the debugging information itself in the debug_info
4305 debug
->external_dnr
= NULL
;
4306 debug
->external_pdr
= NULL
;
4307 debug
->external_sym
= NULL
;
4308 debug
->external_opt
= NULL
;
4309 debug
->external_aux
= NULL
;
4311 debug
->ssext
= debug
->ssext_end
= NULL
;
4312 debug
->external_fdr
= NULL
;
4313 debug
->external_rfd
= NULL
;
4314 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4316 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4320 /* Accumulate the debugging symbols from each input BFD. */
4321 for (input_bfd
= info
->input_bfds
;
4323 input_bfd
= input_bfd
->link
.next
)
4327 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4329 /* Arbitrarily set the symbolic header vstamp to the vstamp
4330 of the first object file in the link. */
4331 if (symhdr
->vstamp
== 0)
4333 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4334 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4338 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4339 debug
, &backend
->debug_swap
,
4344 /* Combine the register masks. */
4345 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4346 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4347 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4348 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4349 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4350 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4353 /* Write out the external symbols. */
4356 bfd_hash_traverse (&info
->hash
->table
, ecoff_link_write_external
, &einfo
);
4358 if (bfd_link_relocatable (info
))
4360 /* We need to make a pass over the link_orders to count up the
4361 number of relocations we will need to output, so that we know
4362 how much space they will take up. */
4363 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4366 for (p
= o
->map_head
.link_order
;
4369 if (p
->type
== bfd_indirect_link_order
)
4370 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4371 else if (p
->type
== bfd_section_reloc_link_order
4372 || p
->type
== bfd_symbol_reloc_link_order
)
4377 /* Compute the reloc and symbol file positions. */
4378 ecoff_compute_reloc_file_positions (abfd
);
4380 /* Write out the debugging information. */
4381 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4382 &backend
->debug_swap
, info
,
4383 ecoff_data (abfd
)->sym_filepos
))
4386 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4388 if (bfd_link_relocatable (info
))
4390 /* Now reset the reloc_count field of the sections in the output
4391 BFD to 0, so that we can use them to keep track of how many
4392 relocs we have output thus far. */
4393 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4397 /* Get a value for the GP register. */
4398 if (ecoff_data (abfd
)->gp
== 0)
4400 struct bfd_link_hash_entry
*h
;
4402 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
4404 && h
->type
== bfd_link_hash_defined
)
4405 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4406 + h
->u
.def
.section
->output_section
->vma
4407 + h
->u
.def
.section
->output_offset
);
4408 else if (bfd_link_relocatable (info
))
4412 /* Make up a value. */
4414 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4417 && (streq (o
->name
, _SBSS
)
4418 || streq (o
->name
, _SDATA
)
4419 || streq (o
->name
, _LIT4
)
4420 || streq (o
->name
, _LIT8
)
4421 || streq (o
->name
, _LITA
)))
4424 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4428 /* If the relocate_section function needs to do a reloc
4429 involving the GP value, it should make a reloc_dangerous
4430 callback to warn that GP is not defined. */
4434 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4436 for (p
= o
->map_head
.link_order
;
4440 if (p
->type
== bfd_indirect_link_order
4441 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4442 == bfd_target_ecoff_flavour
))
4444 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4447 else if (p
->type
== bfd_section_reloc_link_order
4448 || p
->type
== bfd_symbol_reloc_link_order
)
4450 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4455 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4461 abfd
->symcount
= symhdr
->iextMax
+ symhdr
->isymMax
;
4463 ecoff_data (abfd
)->linker
= TRUE
;