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_section_vma (sec
);
1682 rptr
->address
= intern
.r_vaddr
- bfd_section_vma (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_asymbol_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_section_vma (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
+ bfd_section_vma (current
);
2686 in
.r_type
= reloc
->howto
->type
;
2688 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2690 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2704 { _TEXT
, RELOC_SECTION_TEXT
},
2705 { _RDATA
, RELOC_SECTION_RDATA
},
2706 { _DATA
, RELOC_SECTION_DATA
},
2707 { _SDATA
, RELOC_SECTION_SDATA
},
2708 { _SBSS
, RELOC_SECTION_SBSS
},
2709 { _BSS
, RELOC_SECTION_BSS
},
2710 { _INIT
, RELOC_SECTION_INIT
},
2711 { _LIT8
, RELOC_SECTION_LIT8
},
2712 { _LIT4
, RELOC_SECTION_LIT4
},
2713 { _XDATA
, RELOC_SECTION_XDATA
},
2714 { _PDATA
, RELOC_SECTION_PDATA
},
2715 { _FINI
, RELOC_SECTION_FINI
},
2716 { _LITA
, RELOC_SECTION_LITA
},
2717 { "*ABS*", RELOC_SECTION_ABS
},
2718 { _RCONST
, RELOC_SECTION_RCONST
}
2721 name
= bfd_section_name (bfd_asymbol_section (sym
));
2723 for (j
= 0; j
< ARRAY_SIZE (section_symndx
); j
++)
2724 if (streq (name
, section_symndx
[j
].name
))
2726 in
.r_symndx
= section_symndx
[j
].r_symndx
;
2730 if (j
== ARRAY_SIZE (section_symndx
))
2735 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2737 (*swap_reloc_out
) (abfd
, &in
, (void *) out_ptr
);
2740 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2742 amt
= current
->reloc_count
* external_reloc_size
;
2743 if (bfd_bwrite (reloc_buff
, amt
, abfd
) != amt
)
2745 bfd_release (abfd
, reloc_buff
);
2749 /* Write out the symbolic debugging information. */
2750 if (bfd_get_symcount (abfd
) > 0)
2752 /* Write out the debugging information. */
2753 if (! bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2754 ecoff_data (abfd
)->sym_filepos
))
2759 /* The .bss section of a demand paged executable must receive an
2760 entire page. If there are symbols, the symbols will start on the
2761 next page. If there are no symbols, we must fill out the page by
2763 if (bfd_get_symcount (abfd
) == 0
2764 && (abfd
->flags
& EXEC_P
) != 0
2765 && (abfd
->flags
& D_PAGED
) != 0)
2769 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2772 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) == 0)
2774 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2777 if (bfd_bwrite (&c
, (bfd_size_type
) 1, abfd
) != 1)
2781 if (reloc_buff
!= NULL
)
2782 bfd_release (abfd
, reloc_buff
);
2787 if (reloc_buff
!= NULL
)
2788 bfd_release (abfd
, reloc_buff
);
2794 /* Archive handling. ECOFF uses what appears to be a unique type of
2795 archive header (armap). The byte ordering of the armap and the
2796 contents are encoded in the name of the armap itself. At least for
2797 now, we only support archives with the same byte ordering in the
2798 armap and the contents.
2800 The first four bytes in the armap are the number of symbol
2801 definitions. This is always a power of two.
2803 This is followed by the symbol definitions. Each symbol definition
2804 occupies 8 bytes. The first four bytes are the offset from the
2805 start of the armap strings to the null-terminated string naming
2806 this symbol. The second four bytes are the file offset to the
2807 archive member which defines this symbol. If the second four bytes
2808 are 0, then this is not actually a symbol definition, and it should
2811 The symbols are hashed into the armap with a closed hashing scheme.
2812 See the functions below for the details of the algorithm.
2814 After the symbol definitions comes four bytes holding the size of
2815 the string table, followed by the string table itself. */
2817 /* The name of an archive headers looks like this:
2818 __________E[BL]E[BL]_ (with a trailing space).
2819 The trailing space is changed to an X if the archive is changed to
2820 indicate that the armap is out of date.
2822 The Alpha seems to use ________64E[BL]E[BL]_. */
2824 #define ARMAP_BIG_ENDIAN 'B'
2825 #define ARMAP_LITTLE_ENDIAN 'L'
2826 #define ARMAP_MARKER 'E'
2827 #define ARMAP_START_LENGTH 10
2828 #define ARMAP_HEADER_MARKER_INDEX 10
2829 #define ARMAP_HEADER_ENDIAN_INDEX 11
2830 #define ARMAP_OBJECT_MARKER_INDEX 12
2831 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2832 #define ARMAP_END_INDEX 14
2833 #define ARMAP_END "_ "
2835 /* This is a magic number used in the hashing algorithm. */
2836 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2838 /* This returns the hash value to use for a string. It also sets
2839 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2840 is the number of entries in the hash table, and HLOG is the log
2844 ecoff_armap_hash (const char *s
,
2845 unsigned int *rehash
,
2855 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2856 hash
*= ARMAP_HASH_MAGIC
;
2857 *rehash
= (hash
& (size
- 1)) | 1;
2858 return hash
>> (32 - hlog
);
2861 /* Read in the armap. */
2864 _bfd_ecoff_slurp_armap (bfd
*abfd
)
2868 struct areltdata
*mapdata
;
2869 bfd_size_type parsed_size
;
2871 struct artdata
*ardata
;
2878 /* Get the name of the first element. */
2879 i
= bfd_bread ((void *) nextname
, (bfd_size_type
) 16, abfd
);
2885 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2888 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2889 standard COFF armap. We could move the ECOFF armap stuff into
2890 bfd_slurp_armap, but that seems inappropriate since no other
2891 target uses this format. Instead, we check directly for a COFF
2893 if (CONST_STRNEQ (nextname
, "/ "))
2894 return bfd_slurp_armap (abfd
);
2896 /* See if the first element is an armap. */
2897 if (! strneq (nextname
, ecoff_backend (abfd
)->armap_start
, ARMAP_START_LENGTH
)
2898 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
2899 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2900 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2901 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
2902 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2903 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2904 || ! strneq (nextname
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1))
2906 abfd
->has_armap
= FALSE
;
2910 /* Make sure we have the right byte ordering. */
2911 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2912 ^ (bfd_header_big_endian (abfd
)))
2913 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2914 ^ (bfd_big_endian (abfd
))))
2916 bfd_set_error (bfd_error_wrong_format
);
2920 /* Read in the armap. */
2921 ardata
= bfd_ardata (abfd
);
2922 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
2923 if (mapdata
== NULL
)
2925 parsed_size
= mapdata
->parsed_size
;
2928 raw_armap
= (char *) bfd_alloc (abfd
, parsed_size
);
2929 if (raw_armap
== NULL
)
2932 if (bfd_bread ((void *) raw_armap
, parsed_size
, abfd
) != parsed_size
)
2934 if (bfd_get_error () != bfd_error_system_call
)
2935 bfd_set_error (bfd_error_malformed_archive
);
2936 bfd_release (abfd
, (void *) raw_armap
);
2940 ardata
->tdata
= (void *) raw_armap
;
2942 count
= H_GET_32 (abfd
, raw_armap
);
2944 ardata
->symdef_count
= 0;
2945 ardata
->cache
= NULL
;
2947 /* This code used to overlay the symdefs over the raw archive data,
2948 but that doesn't work on a 64 bit host. */
2949 stringbase
= raw_armap
+ count
* 8 + 8;
2951 #ifdef CHECK_ARMAP_HASH
2955 /* Double check that I have the hashing algorithm right by making
2956 sure that every symbol can be looked up successfully. */
2958 for (i
= 1; i
< count
; i
<<= 1)
2960 BFD_ASSERT (i
== count
);
2962 raw_ptr
= raw_armap
+ 4;
2963 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2965 unsigned int name_offset
, file_offset
;
2966 unsigned int hash
, rehash
, srch
;
2968 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2969 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2970 if (file_offset
== 0)
2972 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
2977 /* See if we can rehash to this location. */
2978 for (srch
= (hash
+ rehash
) & (count
- 1);
2979 srch
!= hash
&& srch
!= i
;
2980 srch
= (srch
+ rehash
) & (count
- 1))
2981 BFD_ASSERT (H_GET_32 (abfd
, (raw_armap
+ 8 + srch
* 8)) != 0);
2982 BFD_ASSERT (srch
== i
);
2986 #endif /* CHECK_ARMAP_HASH */
2988 raw_ptr
= raw_armap
+ 4;
2989 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2990 if (H_GET_32 (abfd
, (raw_ptr
+ 4)) != 0)
2991 ++ardata
->symdef_count
;
2993 amt
= ardata
->symdef_count
;
2994 amt
*= sizeof (carsym
);
2995 symdef_ptr
= (carsym
*) bfd_alloc (abfd
, amt
);
2999 ardata
->symdefs
= symdef_ptr
;
3001 raw_ptr
= raw_armap
+ 4;
3002 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3004 unsigned int name_offset
, file_offset
;
3006 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
3007 if (file_offset
== 0)
3009 name_offset
= H_GET_32 (abfd
, raw_ptr
);
3010 symdef_ptr
->name
= stringbase
+ name_offset
;
3011 symdef_ptr
->file_offset
= file_offset
;
3015 ardata
->first_file_filepos
= bfd_tell (abfd
);
3016 /* Pad to an even boundary. */
3017 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
3019 abfd
->has_armap
= TRUE
;
3024 /* Write out an armap. */
3027 _bfd_ecoff_write_armap (bfd
*abfd
,
3028 unsigned int elength
,
3030 unsigned int orl_count
,
3033 unsigned int hashsize
, hashlog
;
3034 bfd_size_type symdefsize
;
3036 unsigned int stringsize
;
3037 unsigned int mapsize
;
3040 struct stat statbuf
;
3043 bfd_byte
*hashtable
;
3047 /* Ultrix appears to use as a hash table size the least power of two
3048 greater than twice the number of entries. */
3049 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3051 hashsize
= 1 << hashlog
;
3053 symdefsize
= hashsize
* 8;
3055 stringsize
= stridx
+ padit
;
3057 /* Include 8 bytes to store symdefsize and stringsize in output. */
3058 mapsize
= symdefsize
+ stringsize
+ 8;
3060 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3062 memset ((void *) &hdr
, 0, sizeof hdr
);
3064 /* Work out the ECOFF armap name. */
3065 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3066 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3067 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3068 (bfd_header_big_endian (abfd
)
3070 : ARMAP_LITTLE_ENDIAN
);
3071 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3072 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3073 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3074 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3076 /* Write the timestamp of the archive header to be just a little bit
3077 later than the timestamp of the file, otherwise the linker will
3078 complain that the index is out of date. Actually, the Ultrix
3079 linker just checks the archive name; the GNU linker may check the
3081 stat (abfd
->filename
, &statbuf
);
3082 _bfd_ar_spacepad (hdr
.ar_date
, sizeof (hdr
.ar_date
), "%ld",
3083 (long) (statbuf
.st_mtime
+ 60));
3085 /* The DECstation uses zeroes for the uid, gid and mode of the
3087 hdr
.ar_uid
[0] = '0';
3088 hdr
.ar_gid
[0] = '0';
3089 /* Building gcc ends up extracting the armap as a file - twice. */
3090 hdr
.ar_mode
[0] = '6';
3091 hdr
.ar_mode
[1] = '4';
3092 hdr
.ar_mode
[2] = '4';
3094 _bfd_ar_spacepad (hdr
.ar_size
, sizeof (hdr
.ar_size
), "%-10ld", mapsize
);
3096 hdr
.ar_fmag
[0] = '`';
3097 hdr
.ar_fmag
[1] = '\012';
3099 /* Turn all null bytes in the header into spaces. */
3100 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3101 if (((char *) (&hdr
))[i
] == '\0')
3102 (((char *) (&hdr
))[i
]) = ' ';
3104 if (bfd_bwrite ((void *) &hdr
, (bfd_size_type
) sizeof (struct ar_hdr
), abfd
)
3105 != sizeof (struct ar_hdr
))
3108 H_PUT_32 (abfd
, hashsize
, temp
);
3109 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3112 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3116 current
= abfd
->archive_head
;
3118 for (i
= 0; i
< orl_count
; i
++)
3120 unsigned int hash
, rehash
= 0;
3122 /* Advance firstreal to the file position of this archive
3124 if (map
[i
].u
.abfd
!= last_elt
)
3128 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3129 firstreal
+= firstreal
% 2;
3130 current
= current
->archive_next
;
3132 while (current
!= map
[i
].u
.abfd
);
3137 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3138 if (H_GET_32 (abfd
, (hashtable
+ (hash
* 8) + 4)) != 0)
3142 /* The desired slot is already taken. */
3143 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3145 srch
= (srch
+ rehash
) & (hashsize
- 1))
3146 if (H_GET_32 (abfd
, (hashtable
+ (srch
* 8) + 4)) == 0)
3149 BFD_ASSERT (srch
!= hash
);
3154 H_PUT_32 (abfd
, map
[i
].namidx
, (hashtable
+ hash
* 8));
3155 H_PUT_32 (abfd
, firstreal
, (hashtable
+ hash
* 8 + 4));
3158 if (bfd_bwrite ((void *) hashtable
, symdefsize
, abfd
) != symdefsize
)
3161 bfd_release (abfd
, hashtable
);
3163 /* Now write the strings. */
3164 H_PUT_32 (abfd
, stringsize
, temp
);
3165 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3167 for (i
= 0; i
< orl_count
; i
++)
3171 len
= strlen (*map
[i
].name
) + 1;
3172 if (bfd_bwrite ((void *) (*map
[i
].name
), len
, abfd
) != len
)
3176 /* The spec sez this should be a newline. But in order to be
3177 bug-compatible for DECstation ar we use a null. */
3180 if (bfd_bwrite ("", (bfd_size_type
) 1, abfd
) != 1)
3187 /* ECOFF linker code. */
3189 /* Routine to create an entry in an ECOFF link hash table. */
3191 static struct bfd_hash_entry
*
3192 ecoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
3193 struct bfd_hash_table
*table
,
3196 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3198 /* Allocate the structure if it has not already been allocated by a
3201 ret
= ((struct ecoff_link_hash_entry
*)
3202 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3206 /* Call the allocation method of the superclass. */
3207 ret
= ((struct ecoff_link_hash_entry
*)
3208 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3213 /* Set local fields. */
3219 memset ((void *) &ret
->esym
, 0, sizeof ret
->esym
);
3221 return (struct bfd_hash_entry
*) ret
;
3224 /* Create an ECOFF link hash table. */
3226 struct bfd_link_hash_table
*
3227 _bfd_ecoff_bfd_link_hash_table_create (bfd
*abfd
)
3229 struct ecoff_link_hash_table
*ret
;
3230 bfd_size_type amt
= sizeof (struct ecoff_link_hash_table
);
3232 ret
= (struct ecoff_link_hash_table
*) bfd_malloc (amt
);
3235 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
,
3236 ecoff_link_hash_newfunc
,
3237 sizeof (struct ecoff_link_hash_entry
)))
3245 /* Look up an entry in an ECOFF link hash table. */
3247 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3248 ((struct ecoff_link_hash_entry *) \
3249 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3251 /* Get the ECOFF link hash table from the info structure. This is
3254 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3256 /* Add the external symbols of an object file to the global linker
3257 hash table. The external symbols and strings we are passed are
3258 just allocated on the stack, and will be discarded. We must
3259 explicitly save any information we may need later on in the link.
3260 We do not want to read the external symbol information again. */
3263 ecoff_link_add_externals (bfd
*abfd
,
3264 struct bfd_link_info
*info
,
3265 void * external_ext
,
3268 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3269 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3270 = backend
->debug_swap
.swap_ext_in
;
3271 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3272 unsigned long ext_count
;
3273 struct bfd_link_hash_entry
**sym_hash
;
3278 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3281 amt
*= sizeof (struct bfd_link_hash_entry
*);
3282 sym_hash
= (struct bfd_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3285 ecoff_data (abfd
)->sym_hashes
= (struct ecoff_link_hash_entry
**) sym_hash
;
3287 ext_ptr
= (char *) external_ext
;
3288 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3289 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3296 struct ecoff_link_hash_entry
*h
;
3300 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3302 /* Skip debugging symbols. */
3304 switch (esym
.asym
.st
)
3320 /* Get the information for this symbol. */
3321 value
= esym
.asym
.value
;
3322 switch (esym
.asym
.sc
)
3342 section
= bfd_make_section_old_way (abfd
, _TEXT
);
3343 value
-= section
->vma
;
3346 section
= bfd_make_section_old_way (abfd
, _DATA
);
3347 value
-= section
->vma
;
3350 section
= bfd_make_section_old_way (abfd
, _BSS
);
3351 value
-= section
->vma
;
3354 section
= bfd_abs_section_ptr
;
3357 section
= bfd_und_section_ptr
;
3360 section
= bfd_make_section_old_way (abfd
, _SDATA
);
3361 value
-= section
->vma
;
3364 section
= bfd_make_section_old_way (abfd
, _SBSS
);
3365 value
-= section
->vma
;
3368 section
= bfd_make_section_old_way (abfd
, _RDATA
);
3369 value
-= section
->vma
;
3372 if (value
> ecoff_data (abfd
)->gp_size
)
3374 section
= bfd_com_section_ptr
;
3379 if (ecoff_scom_section
.name
== NULL
)
3381 /* Initialize the small common section. */
3382 ecoff_scom_section
.name
= SCOMMON
;
3383 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
3384 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
3385 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
3386 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
3387 ecoff_scom_symbol
.name
= SCOMMON
;
3388 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
3389 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
3390 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
3392 section
= &ecoff_scom_section
;
3395 section
= bfd_und_section_ptr
;
3398 section
= bfd_make_section_old_way (abfd
, _INIT
);
3399 value
-= section
->vma
;
3402 section
= bfd_make_section_old_way (abfd
, _FINI
);
3403 value
-= section
->vma
;
3406 section
= bfd_make_section_old_way (abfd
, _RCONST
);
3407 value
-= section
->vma
;
3411 if (section
== NULL
)
3414 name
= ssext
+ esym
.asym
.iss
;
3416 if (! (_bfd_generic_link_add_one_symbol
3418 (flagword
) (esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
),
3419 section
, value
, NULL
, TRUE
, TRUE
, sym_hash
)))
3422 h
= (struct ecoff_link_hash_entry
*) *sym_hash
;
3424 /* If we are building an ECOFF hash table, save the external
3425 symbol information. */
3426 if (bfd_get_flavour (info
->output_bfd
) == bfd_get_flavour (abfd
))
3429 || (! bfd_is_und_section (section
)
3430 && (! bfd_is_com_section (section
)
3431 || (h
->root
.type
!= bfd_link_hash_defined
3432 && h
->root
.type
!= bfd_link_hash_defweak
))))
3438 /* Remember whether this symbol was small undefined. */
3439 if (esym
.asym
.sc
== scSUndefined
)
3442 /* If this symbol was ever small undefined, it needs to wind
3443 up in a GP relative section. We can't control the
3444 section of a defined symbol, but we can control the
3445 section of a common symbol. This case is actually needed
3446 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3448 && h
->root
.type
== bfd_link_hash_common
3449 && streq (h
->root
.u
.c
.p
->section
->name
, SCOMMON
))
3451 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
3453 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
3454 if (h
->esym
.asym
.sc
== scCommon
)
3455 h
->esym
.asym
.sc
= scSCommon
;
3463 /* Add symbols from an ECOFF object file to the global linker hash
3467 ecoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3470 bfd_size_type external_ext_size
;
3471 void * external_ext
= NULL
;
3472 bfd_size_type esize
;
3476 if (! ecoff_slurp_symbolic_header (abfd
))
3479 /* If there are no symbols, we don't want it. */
3480 if (bfd_get_symcount (abfd
) == 0)
3483 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3485 /* Read in the external symbols and external strings. */
3486 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3487 esize
= symhdr
->iextMax
* external_ext_size
;
3488 external_ext
= bfd_malloc (esize
);
3489 if (external_ext
== NULL
&& esize
!= 0)
3492 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbExtOffset
, SEEK_SET
) != 0
3493 || bfd_bread (external_ext
, esize
, abfd
) != esize
)
3496 ssext
= (char *) bfd_malloc ((bfd_size_type
) symhdr
->issExtMax
);
3497 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3500 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
3501 || (bfd_bread (ssext
, (bfd_size_type
) symhdr
->issExtMax
, abfd
)
3502 != (bfd_size_type
) symhdr
->issExtMax
))
3505 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3509 if (external_ext
!= NULL
)
3510 free (external_ext
);
3516 if (external_ext
!= NULL
)
3517 free (external_ext
);
3521 /* This is called if we used _bfd_generic_link_add_archive_symbols
3522 because we were not dealing with an ECOFF archive. */
3525 ecoff_link_check_archive_element (bfd
*abfd
,
3526 struct bfd_link_info
*info
,
3527 struct bfd_link_hash_entry
*h
,
3529 bfd_boolean
*pneeded
)
3533 /* Unlike the generic linker, we do not pull in elements because
3534 of common symbols. */
3535 if (h
->type
!= bfd_link_hash_undefined
)
3538 /* Include this element? */
3539 if (!(*info
->callbacks
->add_archive_element
) (info
, abfd
, name
, &abfd
))
3543 return ecoff_link_add_object_symbols (abfd
, info
);
3546 /* Add the symbols from an archive file to the global hash table.
3547 This looks through the undefined symbols, looks each one up in the
3548 archive hash table, and adds any associated object file. We do not
3549 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3550 already have a hash table, so there is no reason to construct
3554 ecoff_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3556 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3557 const bfd_byte
*raw_armap
;
3558 struct bfd_link_hash_entry
**pundef
;
3559 unsigned int armap_count
;
3560 unsigned int armap_log
;
3562 const bfd_byte
*hashtable
;
3563 const char *stringbase
;
3565 if (! bfd_has_map (abfd
))
3567 /* An empty archive is a special case. */
3568 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
3570 bfd_set_error (bfd_error_no_armap
);
3574 /* If we don't have any raw data for this archive, as can happen on
3575 Irix 4.0.5F, we call the generic routine.
3576 FIXME: We should be more clever about this, since someday tdata
3577 may get to something for a generic archive. */
3578 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3579 if (raw_armap
== NULL
)
3580 return (_bfd_generic_link_add_archive_symbols
3581 (abfd
, info
, ecoff_link_check_archive_element
));
3583 armap_count
= H_GET_32 (abfd
, raw_armap
);
3586 for (i
= 1; i
< armap_count
; i
<<= 1)
3588 BFD_ASSERT (i
== armap_count
);
3590 hashtable
= raw_armap
+ 4;
3591 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3593 /* Look through the list of undefined symbols. */
3594 pundef
= &info
->hash
->undefs
;
3595 while (*pundef
!= NULL
)
3597 struct bfd_link_hash_entry
*h
;
3598 unsigned int hash
, rehash
= 0;
3599 unsigned int file_offset
;
3605 /* When a symbol is defined, it is not necessarily removed from
3607 if (h
->type
!= bfd_link_hash_undefined
3608 && h
->type
!= bfd_link_hash_common
)
3610 /* Remove this entry from the list, for general cleanliness
3611 and because we are going to look through the list again
3612 if we search any more libraries. We can't remove the
3613 entry if it is the tail, because that would lose any
3614 entries we add to the list later on. */
3615 if (*pundef
!= info
->hash
->undefs_tail
)
3616 *pundef
= (*pundef
)->u
.undef
.next
;
3618 pundef
= &(*pundef
)->u
.undef
.next
;
3622 /* Native ECOFF linkers do not pull in archive elements merely
3623 to satisfy common definitions, so neither do we. We leave
3624 them on the list, though, in case we are linking against some
3625 other object format. */
3626 if (h
->type
!= bfd_link_hash_undefined
)
3628 pundef
= &(*pundef
)->u
.undef
.next
;
3632 /* Look for this symbol in the archive hash table. */
3633 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3636 file_offset
= H_GET_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3637 if (file_offset
== 0)
3639 /* Nothing in this slot. */
3640 pundef
= &(*pundef
)->u
.undef
.next
;
3644 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (hash
* 8));
3645 if (name
[0] != h
->root
.string
[0]
3646 || ! streq (name
, h
->root
.string
))
3651 /* That was the wrong symbol. Try rehashing. */
3653 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3655 srch
= (srch
+ rehash
) & (armap_count
- 1))
3657 file_offset
= H_GET_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3658 if (file_offset
== 0)
3660 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (srch
* 8));
3661 if (name
[0] == h
->root
.string
[0]
3662 && streq (name
, h
->root
.string
))
3671 pundef
= &(*pundef
)->u
.undef
.next
;
3678 element
= (*backend
->get_elt_at_filepos
) (abfd
, (file_ptr
) file_offset
);
3679 if (element
== NULL
)
3682 if (! bfd_check_format (element
, bfd_object
))
3685 /* Unlike the generic linker, we know that this element provides
3686 a definition for an undefined symbol and we know that we want
3687 to include it. We don't need to check anything. */
3688 if (!(*info
->callbacks
3689 ->add_archive_element
) (info
, element
, name
, &element
))
3691 if (! ecoff_link_add_object_symbols (element
, info
))
3694 pundef
= &(*pundef
)->u
.undef
.next
;
3700 /* Given an ECOFF BFD, add symbols to the global hash table as
3704 _bfd_ecoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3706 switch (bfd_get_format (abfd
))
3709 return ecoff_link_add_object_symbols (abfd
, info
);
3711 return ecoff_link_add_archive_symbols (abfd
, info
);
3713 bfd_set_error (bfd_error_wrong_format
);
3719 /* ECOFF final link routines. */
3721 /* Structure used to pass information to ecoff_link_write_external. */
3726 struct bfd_link_info
*info
;
3729 /* Accumulate the debugging information for an input BFD into the
3730 output BFD. This must read in the symbolic information of the
3734 ecoff_final_link_debug_accumulate (bfd
*output_bfd
,
3736 struct bfd_link_info
*info
,
3739 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
3740 const struct ecoff_debug_swap
* const swap
=
3741 &ecoff_backend (input_bfd
)->debug_swap
;
3742 HDRR
*symhdr
= &debug
->symbolic_header
;
3745 #define READ(ptr, offset, count, size, type) \
3746 if (symhdr->count == 0) \
3747 debug->ptr = NULL; \
3750 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
3751 debug->ptr = (type) bfd_malloc (amt); \
3752 if (debug->ptr == NULL) \
3755 goto return_something; \
3757 if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3758 || bfd_bread (debug->ptr, amt, input_bfd) != amt) \
3761 goto return_something; \
3765 /* If raw_syments is not NULL, then the data was already by read by
3766 _bfd_ecoff_slurp_symbolic_info. */
3767 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3769 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
3771 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
3772 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
3773 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
3774 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
3775 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3777 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3778 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
3779 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
3783 /* We do not read the external strings or the external symbols. */
3785 ret
= (bfd_ecoff_debug_accumulate
3786 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
3787 &ecoff_backend (output_bfd
)->debug_swap
,
3788 input_bfd
, debug
, swap
, info
));
3791 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3793 if (debug
->line
!= NULL
)
3795 if (debug
->external_dnr
!= NULL
)
3796 free (debug
->external_dnr
);
3797 if (debug
->external_pdr
!= NULL
)
3798 free (debug
->external_pdr
);
3799 if (debug
->external_sym
!= NULL
)
3800 free (debug
->external_sym
);
3801 if (debug
->external_opt
!= NULL
)
3802 free (debug
->external_opt
);
3803 if (debug
->external_aux
!= NULL
)
3804 free (debug
->external_aux
);
3805 if (debug
->ss
!= NULL
)
3807 if (debug
->external_fdr
!= NULL
)
3808 free (debug
->external_fdr
);
3809 if (debug
->external_rfd
!= NULL
)
3810 free (debug
->external_rfd
);
3812 /* Make sure we don't accidentally follow one of these pointers
3813 into freed memory. */
3815 debug
->external_dnr
= NULL
;
3816 debug
->external_pdr
= NULL
;
3817 debug
->external_sym
= NULL
;
3818 debug
->external_opt
= NULL
;
3819 debug
->external_aux
= NULL
;
3821 debug
->external_fdr
= NULL
;
3822 debug
->external_rfd
= NULL
;
3828 /* Relocate and write an ECOFF section into an ECOFF output file. */
3831 ecoff_indirect_link_order (bfd
*output_bfd
,
3832 struct bfd_link_info
*info
,
3833 asection
*output_section
,
3834 struct bfd_link_order
*link_order
)
3836 asection
*input_section
;
3838 bfd_byte
*contents
= NULL
;
3839 bfd_size_type external_reloc_size
;
3840 bfd_size_type external_relocs_size
;
3841 void * external_relocs
= NULL
;
3843 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
3845 input_section
= link_order
->u
.indirect
.section
;
3846 input_bfd
= input_section
->owner
;
3847 if (input_section
->size
== 0)
3850 BFD_ASSERT (input_section
->output_section
== output_section
);
3851 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
3852 BFD_ASSERT (input_section
->size
== link_order
->size
);
3854 /* Get the section contents. */
3855 if (!bfd_malloc_and_get_section (input_bfd
, input_section
, &contents
))
3858 /* Get the relocs. If we are relaxing MIPS code, they will already
3859 have been read in. Otherwise, we read them in now. */
3860 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
3861 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
3863 external_relocs
= bfd_malloc (external_relocs_size
);
3864 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
3867 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3868 || (bfd_bread (external_relocs
, external_relocs_size
, input_bfd
)
3869 != external_relocs_size
))
3872 /* Relocate the section contents. */
3873 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
3874 (output_bfd
, info
, input_bfd
, input_section
, contents
,
3878 /* Write out the relocated section. */
3879 if (! bfd_set_section_contents (output_bfd
,
3882 input_section
->output_offset
,
3883 input_section
->size
))
3886 /* If we are producing relocatable output, the relocs were
3887 modified, and we write them out now. We use the reloc_count
3888 field of output_section to keep track of the number of relocs we
3889 have output so far. */
3890 if (bfd_link_relocatable (info
))
3892 file_ptr pos
= (output_section
->rel_filepos
3893 + output_section
->reloc_count
* external_reloc_size
);
3894 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
3895 || (bfd_bwrite (external_relocs
, external_relocs_size
, output_bfd
)
3896 != external_relocs_size
))
3898 output_section
->reloc_count
+= input_section
->reloc_count
;
3901 if (contents
!= NULL
)
3903 if (external_relocs
!= NULL
)
3904 free (external_relocs
);
3908 if (contents
!= NULL
)
3910 if (external_relocs
!= NULL
)
3911 free (external_relocs
);
3915 /* Generate a reloc when linking an ECOFF file. This is a reloc
3916 requested by the linker, and does come from any input file. This
3917 is used to build constructor and destructor tables when linking
3921 ecoff_reloc_link_order (bfd
*output_bfd
,
3922 struct bfd_link_info
*info
,
3923 asection
*output_section
,
3924 struct bfd_link_order
*link_order
)
3926 enum bfd_link_order_type type
;
3930 struct internal_reloc in
;
3931 bfd_size_type external_reloc_size
;
3936 type
= link_order
->type
;
3938 addend
= link_order
->u
.reloc
.p
->addend
;
3940 /* We set up an arelent to pass to the backend adjust_reloc_out
3942 rel
.address
= link_order
->offset
;
3944 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3947 bfd_set_error (bfd_error_bad_value
);
3951 if (type
== bfd_section_reloc_link_order
)
3953 section
= link_order
->u
.reloc
.p
->u
.section
;
3954 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
3958 struct bfd_link_hash_entry
*h
;
3960 /* Treat a reloc against a defined symbol as though it were
3961 actually against the section. */
3962 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3963 link_order
->u
.reloc
.p
->u
.name
,
3964 FALSE
, FALSE
, FALSE
);
3966 && (h
->type
== bfd_link_hash_defined
3967 || h
->type
== bfd_link_hash_defweak
))
3969 type
= bfd_section_reloc_link_order
;
3970 section
= h
->u
.def
.section
->output_section
;
3971 /* It seems that we ought to add the symbol value to the
3972 addend here, but in practice it has already been added
3973 because it was passed to constructor_callback. */
3974 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
3978 /* We can't set up a reloc against a symbol correctly,
3979 because we have no asymbol structure. Currently no
3980 adjust_reloc_out routine cares. */
3981 rel
.sym_ptr_ptr
= NULL
;
3985 /* All ECOFF relocs are in-place. Put the addend into the object
3988 BFD_ASSERT (rel
.howto
->partial_inplace
);
3992 bfd_reloc_status_type rstat
;
3995 size
= bfd_get_reloc_size (rel
.howto
);
3996 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3997 if (buf
== NULL
&& size
!= 0)
3999 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
4000 (bfd_vma
) addend
, buf
);
4006 case bfd_reloc_outofrange
:
4008 case bfd_reloc_overflow
:
4009 (*info
->callbacks
->reloc_overflow
)
4011 (link_order
->type
== bfd_section_reloc_link_order
4012 ? bfd_section_name (section
)
4013 : link_order
->u
.reloc
.p
->u
.name
),
4014 rel
.howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0);
4017 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
4018 (file_ptr
) link_order
->offset
, size
);
4026 /* Move the information into an internal_reloc structure. */
4027 in
.r_vaddr
= rel
.address
+ bfd_section_vma (output_section
);
4028 in
.r_type
= rel
.howto
->type
;
4030 if (type
== bfd_symbol_reloc_link_order
)
4032 struct ecoff_link_hash_entry
*h
;
4034 h
= ((struct ecoff_link_hash_entry
*)
4035 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4036 link_order
->u
.reloc
.p
->u
.name
,
4037 FALSE
, FALSE
, TRUE
));
4040 in
.r_symndx
= h
->indx
;
4043 (*info
->callbacks
->unattached_reloc
)
4044 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
4060 { _TEXT
, RELOC_SECTION_TEXT
},
4061 { _RDATA
, RELOC_SECTION_RDATA
},
4062 { _DATA
, RELOC_SECTION_DATA
},
4063 { _SDATA
, RELOC_SECTION_SDATA
},
4064 { _SBSS
, RELOC_SECTION_SBSS
},
4065 { _BSS
, RELOC_SECTION_BSS
},
4066 { _INIT
, RELOC_SECTION_INIT
},
4067 { _LIT8
, RELOC_SECTION_LIT8
},
4068 { _LIT4
, RELOC_SECTION_LIT4
},
4069 { _XDATA
, RELOC_SECTION_XDATA
},
4070 { _PDATA
, RELOC_SECTION_PDATA
},
4071 { _FINI
, RELOC_SECTION_FINI
},
4072 { _LITA
, RELOC_SECTION_LITA
},
4073 { "*ABS*", RELOC_SECTION_ABS
},
4074 { _RCONST
, RELOC_SECTION_RCONST
}
4077 name
= bfd_section_name (section
);
4079 for (i
= 0; i
< ARRAY_SIZE (section_symndx
); i
++)
4080 if (streq (name
, section_symndx
[i
].name
))
4082 in
.r_symndx
= section_symndx
[i
].r_symndx
;
4086 if (i
== ARRAY_SIZE (section_symndx
))
4092 /* Let the BFD backend adjust the reloc. */
4093 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4095 /* Get some memory and swap out the reloc. */
4096 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4097 rbuf
= (bfd_byte
*) bfd_malloc (external_reloc_size
);
4101 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (void *) rbuf
);
4103 pos
= (output_section
->rel_filepos
4104 + output_section
->reloc_count
* external_reloc_size
);
4105 ok
= (bfd_seek (output_bfd
, pos
, SEEK_SET
) == 0
4106 && (bfd_bwrite ((void *) rbuf
, external_reloc_size
, output_bfd
)
4107 == external_reloc_size
));
4110 ++output_section
->reloc_count
;
4117 /* Put out information for an external symbol. These come only from
4121 ecoff_link_write_external (struct bfd_hash_entry
*bh
, void * data
)
4123 struct ecoff_link_hash_entry
*h
= (struct ecoff_link_hash_entry
*) bh
;
4124 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4125 bfd
*output_bfd
= einfo
->abfd
;
4128 if (h
->root
.type
== bfd_link_hash_warning
)
4130 h
= (struct ecoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4131 if (h
->root
.type
== bfd_link_hash_new
)
4135 /* We need to check if this symbol is being stripped. */
4136 if (h
->root
.type
== bfd_link_hash_undefined
4137 || h
->root
.type
== bfd_link_hash_undefweak
)
4139 else if (einfo
->info
->strip
== strip_all
4140 || (einfo
->info
->strip
== strip_some
4141 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4142 h
->root
.root
.string
,
4143 FALSE
, FALSE
) == NULL
))
4148 if (strip
|| h
->written
)
4151 if (h
->abfd
== NULL
)
4154 h
->esym
.cobol_main
= 0;
4155 h
->esym
.weakext
= 0;
4156 h
->esym
.reserved
= 0;
4157 h
->esym
.ifd
= ifdNil
;
4158 h
->esym
.asym
.value
= 0;
4159 h
->esym
.asym
.st
= stGlobal
;
4161 if (h
->root
.type
!= bfd_link_hash_defined
4162 && h
->root
.type
!= bfd_link_hash_defweak
)
4163 h
->esym
.asym
.sc
= scAbs
;
4166 asection
*output_section
;
4174 section_storage_classes
[] =
4178 { _SDATA
, scSData
},
4179 { _RDATA
, scRData
},
4184 { _PDATA
, scPData
},
4185 { _XDATA
, scXData
},
4186 { _RCONST
, scRConst
}
4189 output_section
= h
->root
.u
.def
.section
->output_section
;
4190 name
= bfd_section_name (output_section
);
4192 for (i
= 0; i
< ARRAY_SIZE (section_storage_classes
); i
++)
4193 if (streq (name
, section_storage_classes
[i
].name
))
4195 h
->esym
.asym
.sc
= section_storage_classes
[i
].sc
;
4199 if (i
== ARRAY_SIZE (section_storage_classes
))
4200 h
->esym
.asym
.sc
= scAbs
;
4203 h
->esym
.asym
.reserved
= 0;
4204 h
->esym
.asym
.index
= indexNil
;
4206 else if (h
->esym
.ifd
!= -1)
4208 struct ecoff_debug_info
*debug
;
4210 /* Adjust the FDR index for the symbol by that used for the
4212 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4213 BFD_ASSERT (h
->esym
.ifd
>= 0
4214 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4215 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4218 switch (h
->root
.type
)
4221 case bfd_link_hash_warning
:
4222 case bfd_link_hash_new
:
4224 case bfd_link_hash_undefined
:
4225 case bfd_link_hash_undefweak
:
4226 if (h
->esym
.asym
.sc
!= scUndefined
4227 && h
->esym
.asym
.sc
!= scSUndefined
)
4228 h
->esym
.asym
.sc
= scUndefined
;
4230 case bfd_link_hash_defined
:
4231 case bfd_link_hash_defweak
:
4232 if (h
->esym
.asym
.sc
== scUndefined
4233 || h
->esym
.asym
.sc
== scSUndefined
)
4234 h
->esym
.asym
.sc
= scAbs
;
4235 else if (h
->esym
.asym
.sc
== scCommon
)
4236 h
->esym
.asym
.sc
= scBss
;
4237 else if (h
->esym
.asym
.sc
== scSCommon
)
4238 h
->esym
.asym
.sc
= scSBss
;
4239 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4240 + h
->root
.u
.def
.section
->output_section
->vma
4241 + h
->root
.u
.def
.section
->output_offset
);
4243 case bfd_link_hash_common
:
4244 if (h
->esym
.asym
.sc
!= scCommon
4245 && h
->esym
.asym
.sc
!= scSCommon
)
4246 h
->esym
.asym
.sc
= scCommon
;
4247 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4249 case bfd_link_hash_indirect
:
4250 /* We ignore these symbols, since the indirected symbol is
4251 already in the hash table. */
4255 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4257 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4260 return (bfd_ecoff_debug_one_external
4261 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4262 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4266 /* ECOFF final link routine. This looks through all the input BFDs
4267 and gathers together all the debugging information, and then
4268 processes all the link order information. This may cause it to
4269 close and reopen some input BFDs; I'll see how bad this is. */
4272 _bfd_ecoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
4274 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4275 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4280 struct bfd_link_order
*p
;
4281 struct extsym_info einfo
;
4283 /* We accumulate the debugging information counts in the symbolic
4285 symhdr
= &debug
->symbolic_header
;
4287 symhdr
->ilineMax
= 0;
4291 symhdr
->isymMax
= 0;
4292 symhdr
->ioptMax
= 0;
4293 symhdr
->iauxMax
= 0;
4295 symhdr
->issExtMax
= 0;
4298 symhdr
->iextMax
= 0;
4300 /* We accumulate the debugging information itself in the debug_info
4303 debug
->external_dnr
= NULL
;
4304 debug
->external_pdr
= NULL
;
4305 debug
->external_sym
= NULL
;
4306 debug
->external_opt
= NULL
;
4307 debug
->external_aux
= NULL
;
4309 debug
->ssext
= debug
->ssext_end
= NULL
;
4310 debug
->external_fdr
= NULL
;
4311 debug
->external_rfd
= NULL
;
4312 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4314 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4318 /* Accumulate the debugging symbols from each input BFD. */
4319 for (input_bfd
= info
->input_bfds
;
4321 input_bfd
= input_bfd
->link
.next
)
4325 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4327 /* Arbitrarily set the symbolic header vstamp to the vstamp
4328 of the first object file in the link. */
4329 if (symhdr
->vstamp
== 0)
4331 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4332 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4336 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4337 debug
, &backend
->debug_swap
,
4342 /* Combine the register masks. */
4343 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4344 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4345 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4346 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4347 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4348 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4351 /* Write out the external symbols. */
4354 bfd_hash_traverse (&info
->hash
->table
, ecoff_link_write_external
, &einfo
);
4356 if (bfd_link_relocatable (info
))
4358 /* We need to make a pass over the link_orders to count up the
4359 number of relocations we will need to output, so that we know
4360 how much space they will take up. */
4361 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4364 for (p
= o
->map_head
.link_order
;
4367 if (p
->type
== bfd_indirect_link_order
)
4368 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4369 else if (p
->type
== bfd_section_reloc_link_order
4370 || p
->type
== bfd_symbol_reloc_link_order
)
4375 /* Compute the reloc and symbol file positions. */
4376 ecoff_compute_reloc_file_positions (abfd
);
4378 /* Write out the debugging information. */
4379 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4380 &backend
->debug_swap
, info
,
4381 ecoff_data (abfd
)->sym_filepos
))
4384 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4386 if (bfd_link_relocatable (info
))
4388 /* Now reset the reloc_count field of the sections in the output
4389 BFD to 0, so that we can use them to keep track of how many
4390 relocs we have output thus far. */
4391 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4395 /* Get a value for the GP register. */
4396 if (ecoff_data (abfd
)->gp
== 0)
4398 struct bfd_link_hash_entry
*h
;
4400 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
4402 && h
->type
== bfd_link_hash_defined
)
4403 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4404 + h
->u
.def
.section
->output_section
->vma
4405 + h
->u
.def
.section
->output_offset
);
4406 else if (bfd_link_relocatable (info
))
4410 /* Make up a value. */
4412 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4415 && (streq (o
->name
, _SBSS
)
4416 || streq (o
->name
, _SDATA
)
4417 || streq (o
->name
, _LIT4
)
4418 || streq (o
->name
, _LIT8
)
4419 || streq (o
->name
, _LITA
)))
4422 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4426 /* If the relocate_section function needs to do a reloc
4427 involving the GP value, it should make a reloc_dangerous
4428 callback to warn that GP is not defined. */
4432 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4434 for (p
= o
->map_head
.link_order
;
4438 if (p
->type
== bfd_indirect_link_order
4439 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4440 == bfd_target_ecoff_flavour
))
4442 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4445 else if (p
->type
== bfd_section_reloc_link_order
4446 || p
->type
== bfd_symbol_reloc_link_order
)
4448 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4453 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4459 abfd
->symcount
= symhdr
->iextMax
+ symhdr
->isymMax
;
4461 ecoff_data (abfd
)->linker
= TRUE
;