1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright (C) 1990-2020 Free Software Foundation, Inc.
3 Original version by Per Bothner.
4 Full support added by Ian Lance Taylor, ian@cygnus.com.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "ecoff-bfd.h"
29 #include "aout/stab_gnu.h"
31 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
32 some other stuff which we don't want and which conflicts with stuff
35 #include "aout/aout64.h"
38 #undef obj_sym_filepos
40 #include "coff/internal.h"
42 #include "coff/symconst.h"
43 #include "coff/ecoff.h"
46 #include "libiberty.h"
48 #define streq(a, b) (strcmp ((a), (b)) == 0)
49 #define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0)
52 /* This stuff is somewhat copied from coffcode.h. */
53 static asection bfd_debug_section
=
55 /* name, id, section_id, index, next, prev, flags, */
56 "*DEBUG*", 0, 0, 0, NULL
, NULL
, 0,
59 /* linker_mark, linker_has_input, gc_mark, compress_status, */
61 /* segment_mark, sec_info_type, use_rela_p, */
63 /* sec_flg0, sec_flg1, sec_flg2, sec_flg3, sec_flg4, sec_flg5, */
65 /* vma, lma, size, rawsize, compressed_size, relax, relax_count, */
67 /* output_offset, output_section, alignment_power, */
69 /* relocation, orelocation, reloc_count, filepos, rel_filepos, */
71 /* line_filepos, userdata, contents, lineno, lineno_count, */
72 0, NULL
, NULL
, NULL
, 0,
73 /* entsize, kept_section, moving_line_filepos, */
75 /* target_index, used_by_bfd, constructor_chain, owner, */
81 /* map_head, map_tail, */
83 /* already_assigned */
87 /* Create an ECOFF object. */
90 _bfd_ecoff_mkobject (bfd
*abfd
)
92 size_t amt
= sizeof (ecoff_data_type
);
94 abfd
->tdata
.ecoff_obj_data
= (struct ecoff_tdata
*) bfd_zalloc (abfd
, amt
);
95 if (abfd
->tdata
.ecoff_obj_data
== NULL
)
101 /* This is a hook called by coff_real_object_p to create any backend
102 specific information. */
105 _bfd_ecoff_mkobject_hook (bfd
*abfd
, void * filehdr
, void * aouthdr
)
107 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
108 struct internal_aouthdr
*internal_a
= (struct internal_aouthdr
*) aouthdr
;
109 ecoff_data_type
*ecoff
;
111 if (! _bfd_ecoff_mkobject (abfd
))
114 ecoff
= ecoff_data (abfd
);
116 ecoff
->sym_filepos
= internal_f
->f_symptr
;
118 if (internal_a
!= NULL
)
122 ecoff
->text_start
= internal_a
->text_start
;
123 ecoff
->text_end
= internal_a
->text_start
+ internal_a
->tsize
;
124 ecoff
->gp
= internal_a
->gp_value
;
125 ecoff
->gprmask
= internal_a
->gprmask
;
126 for (i
= 0; i
< 4; i
++)
127 ecoff
->cprmask
[i
] = internal_a
->cprmask
[i
];
128 ecoff
->fprmask
= internal_a
->fprmask
;
129 if (internal_a
->magic
== ECOFF_AOUT_ZMAGIC
)
130 abfd
->flags
|= D_PAGED
;
132 abfd
->flags
&=~ D_PAGED
;
135 /* It turns out that no special action is required by the MIPS or
136 Alpha ECOFF backends. They have different information in the
137 a.out header, but we just copy it all (e.g., gprmask, cprmask and
138 fprmask) and let the swapping routines ensure that only relevant
139 information is written out. */
141 return (void *) ecoff
;
144 /* Initialize a new section. */
147 _bfd_ecoff_new_section_hook (bfd
*abfd
, asection
*section
)
157 { _TEXT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
158 { _INIT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
159 { _FINI
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
160 { _DATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
},
161 { _SDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_SMALL_DATA
},
162 { _RDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
163 { _LIT8
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
| SEC_SMALL_DATA
},
164 { _LIT4
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
| SEC_SMALL_DATA
},
165 { _RCONST
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
166 { _PDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
168 { _SBSS
, SEC_ALLOC
| SEC_SMALL_DATA
},
169 /* An Irix 4 shared libary. */
170 { _LIB
, SEC_COFF_SHARED_LIBRARY
}
173 section
->alignment_power
= 4;
175 for (i
= 0; i
< ARRAY_SIZE (section_flags
); i
++)
176 if (streq (section
->name
, section_flags
[i
].name
))
178 section
->flags
|= section_flags
[i
].flags
;
183 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
184 uncertain about .init on some systems and I don't know how shared
187 return _bfd_generic_new_section_hook (abfd
, section
);
191 _bfd_ecoff_set_alignment_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
192 asection
*section ATTRIBUTE_UNUSED
,
193 void *scnhdr ATTRIBUTE_UNUSED
)
197 /* Determine the machine architecture and type. This is called from
198 the generic COFF routines. It is the inverse of ecoff_get_magic,
199 below. This could be an ECOFF backend routine, with one version
200 for each target, but there aren't all that many ECOFF targets. */
203 _bfd_ecoff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
205 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
206 enum bfd_architecture arch
;
209 switch (internal_f
->f_magic
)
212 case MIPS_MAGIC_LITTLE
:
214 arch
= bfd_arch_mips
;
215 mach
= bfd_mach_mips3000
;
218 case MIPS_MAGIC_LITTLE2
:
219 case MIPS_MAGIC_BIG2
:
220 /* MIPS ISA level 2: the r6000. */
221 arch
= bfd_arch_mips
;
222 mach
= bfd_mach_mips6000
;
225 case MIPS_MAGIC_LITTLE3
:
226 case MIPS_MAGIC_BIG3
:
227 /* MIPS ISA level 3: the r4000. */
228 arch
= bfd_arch_mips
;
229 mach
= bfd_mach_mips4000
;
233 arch
= bfd_arch_alpha
;
238 arch
= bfd_arch_obscure
;
243 return bfd_default_set_arch_mach (abfd
, arch
, mach
);
247 _bfd_ecoff_no_long_sections (bfd
*abfd
, int enable
)
254 /* Get the magic number to use based on the architecture and machine.
255 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
258 ecoff_get_magic (bfd
*abfd
)
262 switch (bfd_get_arch (abfd
))
265 switch (bfd_get_mach (abfd
))
269 case bfd_mach_mips3000
:
270 big
= MIPS_MAGIC_BIG
;
271 little
= MIPS_MAGIC_LITTLE
;
274 case bfd_mach_mips6000
:
275 big
= MIPS_MAGIC_BIG2
;
276 little
= MIPS_MAGIC_LITTLE2
;
279 case bfd_mach_mips4000
:
280 big
= MIPS_MAGIC_BIG3
;
281 little
= MIPS_MAGIC_LITTLE3
;
285 return bfd_big_endian (abfd
) ? big
: little
;
296 /* Get the section s_flags to use for a section. */
299 ecoff_sec_to_styp_flags (const char *name
, flagword flags
)
309 { _TEXT
, STYP_TEXT
},
310 { _DATA
, STYP_DATA
},
311 { _SDATA
, STYP_SDATA
},
312 { _RDATA
, STYP_RDATA
},
313 { _LITA
, STYP_LITA
},
314 { _LIT8
, STYP_LIT8
},
315 { _LIT4
, STYP_LIT4
},
317 { _SBSS
, STYP_SBSS
},
318 { _INIT
, STYP_ECOFF_INIT
},
319 { _FINI
, STYP_ECOFF_FINI
},
320 { _PDATA
, STYP_PDATA
},
321 { _XDATA
, STYP_XDATA
},
322 { _LIB
, STYP_ECOFF_LIB
},
324 { _HASH
, STYP_HASH
},
325 { _DYNAMIC
, STYP_DYNAMIC
},
326 { _LIBLIST
, STYP_LIBLIST
},
327 { _RELDYN
, STYP_RELDYN
},
328 { _CONFLIC
, STYP_CONFLIC
},
329 { _DYNSTR
, STYP_DYNSTR
},
330 { _DYNSYM
, STYP_DYNSYM
},
331 { _RCONST
, STYP_RCONST
}
335 for (i
= 0; i
< ARRAY_SIZE (styp_flags
); i
++)
336 if (streq (name
, styp_flags
[i
].name
))
338 styp
= styp_flags
[i
].flags
;
344 if (streq (name
, _COMMENT
))
347 flags
&=~ SEC_NEVER_LOAD
;
349 else if (flags
& SEC_CODE
)
351 else if (flags
& SEC_DATA
)
353 else if (flags
& SEC_READONLY
)
355 else if (flags
& SEC_LOAD
)
361 if (flags
& SEC_NEVER_LOAD
)
367 /* Get the BFD flags to use for a section. */
370 _bfd_ecoff_styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
372 const char *name ATTRIBUTE_UNUSED
,
373 asection
*section ATTRIBUTE_UNUSED
,
374 flagword
* flags_ptr
)
376 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
377 long styp_flags
= internal_s
->s_flags
;
378 flagword sec_flags
= 0;
380 if (styp_flags
& STYP_NOLOAD
)
381 sec_flags
|= SEC_NEVER_LOAD
;
383 /* For 386 COFF, at least, an unloadable text or data section is
384 actually a shared library section. */
385 if ((styp_flags
& STYP_TEXT
)
386 || (styp_flags
& STYP_ECOFF_INIT
)
387 || (styp_flags
& STYP_ECOFF_FINI
)
388 || (styp_flags
& STYP_DYNAMIC
)
389 || (styp_flags
& STYP_LIBLIST
)
390 || (styp_flags
& STYP_RELDYN
)
391 || styp_flags
== STYP_CONFLIC
392 || (styp_flags
& STYP_DYNSTR
)
393 || (styp_flags
& STYP_DYNSYM
)
394 || (styp_flags
& STYP_HASH
))
396 if (sec_flags
& SEC_NEVER_LOAD
)
397 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
399 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
401 else if ((styp_flags
& STYP_DATA
)
402 || (styp_flags
& STYP_RDATA
)
403 || (styp_flags
& STYP_SDATA
)
404 || styp_flags
== STYP_PDATA
405 || styp_flags
== STYP_XDATA
406 || (styp_flags
& STYP_GOT
)
407 || styp_flags
== STYP_RCONST
)
409 if (sec_flags
& SEC_NEVER_LOAD
)
410 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
412 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
413 if ((styp_flags
& STYP_RDATA
)
414 || styp_flags
== STYP_PDATA
415 || styp_flags
== STYP_RCONST
)
416 sec_flags
|= SEC_READONLY
;
417 if (styp_flags
& STYP_SDATA
)
418 sec_flags
|= SEC_SMALL_DATA
;
420 else if (styp_flags
& STYP_SBSS
)
421 sec_flags
|= SEC_ALLOC
| SEC_SMALL_DATA
;
422 else if (styp_flags
& STYP_BSS
)
423 sec_flags
|= SEC_ALLOC
;
424 else if ((styp_flags
& STYP_INFO
) || styp_flags
== STYP_COMMENT
)
425 sec_flags
|= SEC_NEVER_LOAD
;
426 else if ((styp_flags
& STYP_LITA
)
427 || (styp_flags
& STYP_LIT8
)
428 || (styp_flags
& STYP_LIT4
))
429 sec_flags
|= SEC_DATA
|SEC_SMALL_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
430 else if (styp_flags
& STYP_ECOFF_LIB
)
431 sec_flags
|= SEC_COFF_SHARED_LIBRARY
;
433 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
435 * flags_ptr
= sec_flags
;
439 /* Read in the symbolic header for an ECOFF object file. */
442 ecoff_slurp_symbolic_header (bfd
*abfd
)
444 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
445 bfd_size_type external_hdr_size
;
447 HDRR
*internal_symhdr
;
449 /* See if we've already read it in. */
450 if (ecoff_data (abfd
)->debug_info
.symbolic_header
.magic
==
451 backend
->debug_swap
.sym_magic
)
454 /* See whether there is a symbolic header. */
455 if (ecoff_data (abfd
)->sym_filepos
== 0)
461 /* At this point bfd_get_symcount (abfd) holds the number of symbols
462 as read from the file header, but on ECOFF this is always the
463 size of the symbolic information header. It would be cleaner to
464 handle this when we first read the file in coffgen.c. */
465 external_hdr_size
= backend
->debug_swap
.external_hdr_size
;
466 if (bfd_get_symcount (abfd
) != external_hdr_size
)
468 bfd_set_error (bfd_error_bad_value
);
472 /* Read the symbolic information header. */
473 if (bfd_seek (abfd
, ecoff_data (abfd
)->sym_filepos
, SEEK_SET
) != 0)
475 raw
= _bfd_malloc_and_read (abfd
, external_hdr_size
, external_hdr_size
);
479 internal_symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
480 (*backend
->debug_swap
.swap_hdr_in
) (abfd
, raw
, internal_symhdr
);
482 if (internal_symhdr
->magic
!= backend
->debug_swap
.sym_magic
)
484 bfd_set_error (bfd_error_bad_value
);
488 /* Now we can get the correct number of symbols. */
489 abfd
->symcount
= internal_symhdr
->isymMax
+ internal_symhdr
->iextMax
;
500 /* Read in and swap the important symbolic information for an ECOFF
501 object file. This is called by gdb via the read_debug_info entry
502 point in the backend structure. */
505 _bfd_ecoff_slurp_symbolic_info (bfd
*abfd
,
506 asection
*ignore ATTRIBUTE_UNUSED
,
507 struct ecoff_debug_info
*debug
)
509 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
510 HDRR
*internal_symhdr
;
511 bfd_size_type raw_base
;
512 bfd_size_type raw_size
;
514 bfd_size_type external_fdr_size
;
518 bfd_size_type raw_end
;
519 bfd_size_type cb_end
;
523 BFD_ASSERT (debug
== &ecoff_data (abfd
)->debug_info
);
525 /* Check whether we've already gotten it, and whether there's any to
527 if (ecoff_data (abfd
)->raw_syments
!= NULL
)
529 if (ecoff_data (abfd
)->sym_filepos
== 0)
535 if (! ecoff_slurp_symbolic_header (abfd
))
538 internal_symhdr
= &debug
->symbolic_header
;
540 /* Read all the symbolic information at once. */
541 raw_base
= (ecoff_data (abfd
)->sym_filepos
542 + backend
->debug_swap
.external_hdr_size
);
544 /* Alpha ecoff makes the determination of raw_size difficult. It has
545 an undocumented debug data section between the symhdr and the first
546 documented section. And the ordering of the sections varies between
547 statically and dynamically linked executables.
548 If bfd supports SEEK_END someday, this code could be simplified. */
551 #define UPDATE_RAW_END(start, count, size) \
552 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
553 if (cb_end > raw_end) \
556 UPDATE_RAW_END (cbLineOffset
, cbLine
, sizeof (unsigned char));
557 UPDATE_RAW_END (cbDnOffset
, idnMax
, backend
->debug_swap
.external_dnr_size
);
558 UPDATE_RAW_END (cbPdOffset
, ipdMax
, backend
->debug_swap
.external_pdr_size
);
559 UPDATE_RAW_END (cbSymOffset
, isymMax
, backend
->debug_swap
.external_sym_size
);
560 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
561 optimization symtab, not the number of entries. */
562 UPDATE_RAW_END (cbOptOffset
, ioptMax
, sizeof (char));
563 UPDATE_RAW_END (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
564 UPDATE_RAW_END (cbSsOffset
, issMax
, sizeof (char));
565 UPDATE_RAW_END (cbSsExtOffset
, issExtMax
, sizeof (char));
566 UPDATE_RAW_END (cbFdOffset
, ifdMax
, backend
->debug_swap
.external_fdr_size
);
567 UPDATE_RAW_END (cbRfdOffset
, crfd
, backend
->debug_swap
.external_rfd_size
);
568 UPDATE_RAW_END (cbExtOffset
, iextMax
, backend
->debug_swap
.external_ext_size
);
570 #undef UPDATE_RAW_END
572 raw_size
= raw_end
- raw_base
;
575 ecoff_data (abfd
)->sym_filepos
= 0;
578 pos
= ecoff_data (abfd
)->sym_filepos
;
579 pos
+= backend
->debug_swap
.external_hdr_size
;
580 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
582 raw
= _bfd_alloc_and_read (abfd
, raw_size
, raw_size
);
586 ecoff_data (abfd
)->raw_syments
= raw
;
588 /* Get pointers for the numeric offsets in the HDRR structure. */
589 #define FIX(off1, off2, type) \
590 if (internal_symhdr->off1 == 0) \
591 debug->off2 = NULL; \
593 debug->off2 = (type) ((char *) raw \
594 + (internal_symhdr->off1 \
597 FIX (cbLineOffset
, line
, unsigned char *);
598 FIX (cbDnOffset
, external_dnr
, void *);
599 FIX (cbPdOffset
, external_pdr
, void *);
600 FIX (cbSymOffset
, external_sym
, void *);
601 FIX (cbOptOffset
, external_opt
, void *);
602 FIX (cbAuxOffset
, external_aux
, union aux_ext
*);
603 FIX (cbSsOffset
, ss
, char *);
604 FIX (cbSsExtOffset
, ssext
, char *);
605 FIX (cbFdOffset
, external_fdr
, void *);
606 FIX (cbRfdOffset
, external_rfd
, void *);
607 FIX (cbExtOffset
, external_ext
, void *);
610 /* I don't want to always swap all the data, because it will just
611 waste time and most programs will never look at it. The only
612 time the linker needs most of the debugging information swapped
613 is when linking big-endian and little-endian MIPS object files
614 together, which is not a common occurrence.
616 We need to look at the fdr to deal with a lot of information in
617 the symbols, so we swap them here. */
618 if (_bfd_mul_overflow ((unsigned long) internal_symhdr
->ifdMax
,
619 sizeof (struct fdr
), &amt
))
621 bfd_set_error (bfd_error_file_too_big
);
624 debug
->fdr
= (FDR
*) bfd_alloc (abfd
, amt
);
625 if (debug
->fdr
== NULL
)
627 external_fdr_size
= backend
->debug_swap
.external_fdr_size
;
628 fdr_ptr
= debug
->fdr
;
629 fraw_src
= (char *) debug
->external_fdr
;
630 /* PR 17512: file: 3372-1243-0.004. */
631 if (fraw_src
== NULL
&& internal_symhdr
->ifdMax
> 0)
633 fraw_end
= fraw_src
+ internal_symhdr
->ifdMax
* external_fdr_size
;
634 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
635 (*backend
->debug_swap
.swap_fdr_in
) (abfd
, (void *) fraw_src
, fdr_ptr
);
640 /* ECOFF symbol table routines. The ECOFF symbol table is described
641 in gcc/mips-tfile.c. */
643 /* ECOFF uses two common sections. One is the usual one, and the
644 other is for small objects. All the small objects are kept
645 together, and then referenced via the gp pointer, which yields
646 faster assembler code. This is what we use for the small common
648 static asection ecoff_scom_section
;
649 static asymbol ecoff_scom_symbol
;
650 static asymbol
*ecoff_scom_symbol_ptr
;
652 /* Create an empty symbol. */
655 _bfd_ecoff_make_empty_symbol (bfd
*abfd
)
657 ecoff_symbol_type
*new_symbol
;
658 size_t amt
= sizeof (ecoff_symbol_type
);
660 new_symbol
= (ecoff_symbol_type
*) bfd_zalloc (abfd
, amt
);
661 if (new_symbol
== NULL
)
663 new_symbol
->symbol
.section
= NULL
;
664 new_symbol
->fdr
= NULL
;
665 new_symbol
->local
= FALSE
;
666 new_symbol
->native
= NULL
;
667 new_symbol
->symbol
.the_bfd
= abfd
;
668 return &new_symbol
->symbol
;
671 /* Set the BFD flags and section for an ECOFF symbol. */
674 ecoff_set_symbol_info (bfd
*abfd
,
680 asym
->the_bfd
= abfd
;
681 asym
->value
= ecoff_sym
->value
;
682 asym
->section
= &bfd_debug_section
;
685 /* Most symbol types are just for debugging. */
686 switch (ecoff_sym
->st
)
695 if (ECOFF_IS_STAB (ecoff_sym
))
697 asym
->flags
= BSF_DEBUGGING
;
702 asym
->flags
= BSF_DEBUGGING
;
707 asym
->flags
= BSF_EXPORT
| BSF_WEAK
;
709 asym
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
712 asym
->flags
= BSF_LOCAL
;
713 /* Normally, a local stProc symbol will have a corresponding
714 external symbol. We mark the local symbol as a debugging
715 symbol, in order to prevent nm from printing both out.
716 Similarly, we mark stLabel and stabs symbols as debugging
717 symbols. In both cases, we do want to set the value
718 correctly based on the symbol class. */
719 if (ecoff_sym
->st
== stProc
720 || ecoff_sym
->st
== stLabel
721 || ECOFF_IS_STAB (ecoff_sym
))
722 asym
->flags
|= BSF_DEBUGGING
;
725 if (ecoff_sym
->st
== stProc
|| ecoff_sym
->st
== stStaticProc
)
726 asym
->flags
|= BSF_FUNCTION
;
728 switch (ecoff_sym
->sc
)
731 /* Used for compiler generated labels. Leave them in the
732 debugging section, and mark them as local. If BSF_DEBUGGING
733 is set, then nm does not display them for some reason. If no
734 flags are set then the linker whines about them. */
735 asym
->flags
= BSF_LOCAL
;
738 asym
->section
= bfd_make_section_old_way (abfd
, _TEXT
);
739 asym
->value
-= asym
->section
->vma
;
742 asym
->section
= bfd_make_section_old_way (abfd
, _DATA
);
743 asym
->value
-= asym
->section
->vma
;
746 asym
->section
= bfd_make_section_old_way (abfd
, _BSS
);
747 asym
->value
-= asym
->section
->vma
;
750 asym
->flags
= BSF_DEBUGGING
;
753 asym
->section
= bfd_abs_section_ptr
;
756 asym
->section
= bfd_und_section_ptr
;
766 asym
->flags
= BSF_DEBUGGING
;
769 asym
->section
= bfd_make_section_old_way (abfd
, ".sdata");
770 asym
->value
-= asym
->section
->vma
;
773 asym
->section
= bfd_make_section_old_way (abfd
, ".sbss");
774 asym
->value
-= asym
->section
->vma
;
777 asym
->section
= bfd_make_section_old_way (abfd
, ".rdata");
778 asym
->value
-= asym
->section
->vma
;
781 asym
->flags
= BSF_DEBUGGING
;
784 if (asym
->value
> ecoff_data (abfd
)->gp_size
)
786 asym
->section
= bfd_com_section_ptr
;
792 if (ecoff_scom_section
.name
== NULL
)
794 /* Initialize the small common section. */
795 ecoff_scom_section
.name
= SCOMMON
;
796 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
797 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
798 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
799 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
800 ecoff_scom_symbol
.name
= SCOMMON
;
801 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
802 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
803 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
805 asym
->section
= &ecoff_scom_section
;
810 asym
->flags
= BSF_DEBUGGING
;
813 asym
->section
= bfd_und_section_ptr
;
818 asym
->section
= bfd_make_section_old_way (abfd
, ".init");
819 asym
->value
-= asym
->section
->vma
;
824 asym
->flags
= BSF_DEBUGGING
;
827 asym
->section
= bfd_make_section_old_way (abfd
, ".fini");
828 asym
->value
-= asym
->section
->vma
;
831 asym
->section
= bfd_make_section_old_way (abfd
, ".rconst");
832 asym
->value
-= asym
->section
->vma
;
838 /* Look for special constructors symbols and make relocation entries
839 in a special construction section. These are produced by the
840 -fgnu-linker argument to g++. */
841 if (ECOFF_IS_STAB (ecoff_sym
))
843 switch (ECOFF_UNMARK_STAB (ecoff_sym
->index
))
852 /* Mark the symbol as a constructor. */
853 asym
->flags
|= BSF_CONSTRUCTOR
;
860 /* Read an ECOFF symbol table. */
863 _bfd_ecoff_slurp_symbol_table (bfd
*abfd
)
865 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
866 const bfd_size_type external_ext_size
867 = backend
->debug_swap
.external_ext_size
;
868 const bfd_size_type external_sym_size
869 = backend
->debug_swap
.external_sym_size
;
870 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
871 = backend
->debug_swap
.swap_ext_in
;
872 void (* const swap_sym_in
) (bfd
*, void *, SYMR
*)
873 = backend
->debug_swap
.swap_sym_in
;
874 ecoff_symbol_type
*internal
;
875 ecoff_symbol_type
*internal_ptr
;
882 /* If we've already read in the symbol table, do nothing. */
883 if (ecoff_data (abfd
)->canonical_symbols
!= NULL
)
886 /* Get the symbolic information. */
887 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
888 &ecoff_data (abfd
)->debug_info
))
890 if (bfd_get_symcount (abfd
) == 0)
893 if (_bfd_mul_overflow (bfd_get_symcount (abfd
),
894 sizeof (ecoff_symbol_type
), &amt
))
896 bfd_set_error (bfd_error_file_too_big
);
899 internal
= (ecoff_symbol_type
*) bfd_alloc (abfd
, amt
);
900 if (internal
== NULL
)
903 internal_ptr
= internal
;
904 eraw_src
= (char *) ecoff_data (abfd
)->debug_info
.external_ext
;
906 + (ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
907 * external_ext_size
));
908 for (; eraw_src
< eraw_end
; eraw_src
+= external_ext_size
, internal_ptr
++)
912 (*swap_ext_in
) (abfd
, (void *) eraw_src
, &internal_esym
);
914 /* PR 17512: file: 3372-1000-0.004. */
915 if (internal_esym
.asym
.iss
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.issExtMax
916 || internal_esym
.asym
.iss
< 0)
919 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ssext
920 + internal_esym
.asym
.iss
);
922 if (!ecoff_set_symbol_info (abfd
, &internal_esym
.asym
,
923 &internal_ptr
->symbol
, 1,
924 internal_esym
.weakext
))
927 /* The alpha uses a negative ifd field for section symbols. */
928 if (internal_esym
.ifd
>= 0)
930 /* PR 17512: file: 3372-1983-0.004. */
931 if (internal_esym
.ifd
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
)
932 internal_ptr
->fdr
= NULL
;
934 internal_ptr
->fdr
= (ecoff_data (abfd
)->debug_info
.fdr
935 + internal_esym
.ifd
);
938 internal_ptr
->fdr
= NULL
;
939 internal_ptr
->local
= FALSE
;
940 internal_ptr
->native
= (void *) eraw_src
;
943 /* The local symbols must be accessed via the fdr's, because the
944 string and aux indices are relative to the fdr information. */
945 fdr_ptr
= ecoff_data (abfd
)->debug_info
.fdr
;
946 fdr_end
= fdr_ptr
+ ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
;
947 for (; fdr_ptr
< fdr_end
; fdr_ptr
++)
952 lraw_src
= ((char *) ecoff_data (abfd
)->debug_info
.external_sym
953 + fdr_ptr
->isymBase
* external_sym_size
);
954 lraw_end
= lraw_src
+ fdr_ptr
->csym
* external_sym_size
;
957 lraw_src
+= external_sym_size
, internal_ptr
++)
961 (*swap_sym_in
) (abfd
, (void *) lraw_src
, &internal_sym
);
962 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ss
965 if (!ecoff_set_symbol_info (abfd
, &internal_sym
,
966 &internal_ptr
->symbol
, 0, 0))
968 internal_ptr
->fdr
= fdr_ptr
;
969 internal_ptr
->local
= TRUE
;
970 internal_ptr
->native
= (void *) lraw_src
;
974 /* PR 17512: file: 3372-3080-0.004.
975 A discrepancy between ecoff_data (abfd)->debug_info.symbolic_header.isymMax
976 and ecoff_data (abfd)->debug_info.symbolic_header.ifdMax can mean that
977 we have fewer symbols than we were expecting. Allow for this by updating
978 the symbol count and warning the user. */
979 if (internal_ptr
- internal
< (ptrdiff_t) bfd_get_symcount (abfd
))
981 abfd
->symcount
= internal_ptr
- internal
;
983 /* xgettext:c-format */
984 (_("%pB: warning: isymMax (%ld) is greater than ifdMax (%ld)"),
985 abfd
, ecoff_data (abfd
)->debug_info
.symbolic_header
.isymMax
,
986 ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
);
989 ecoff_data (abfd
)->canonical_symbols
= internal
;
994 /* Return the amount of space needed for the canonical symbols. */
997 _bfd_ecoff_get_symtab_upper_bound (bfd
*abfd
)
999 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
1000 &ecoff_data (abfd
)->debug_info
))
1003 if (bfd_get_symcount (abfd
) == 0)
1006 return (bfd_get_symcount (abfd
) + 1) * (sizeof (ecoff_symbol_type
*));
1009 /* Get the canonical symbols. */
1012 _bfd_ecoff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
1014 unsigned int counter
= 0;
1015 ecoff_symbol_type
*symbase
;
1016 ecoff_symbol_type
**location
= (ecoff_symbol_type
**) alocation
;
1018 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1020 if (bfd_get_symcount (abfd
) == 0)
1023 symbase
= ecoff_data (abfd
)->canonical_symbols
;
1024 while (counter
< bfd_get_symcount (abfd
))
1026 *(location
++) = symbase
++;
1030 return bfd_get_symcount (abfd
);
1033 /* Turn ECOFF type information into a printable string.
1034 ecoff_emit_aggregate and ecoff_type_to_string are from
1035 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1037 /* Write aggregate information to a string. */
1040 ecoff_emit_aggregate (bfd
*abfd
,
1047 const struct ecoff_debug_swap
* const debug_swap
=
1048 &ecoff_backend (abfd
)->debug_swap
;
1049 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1050 unsigned int ifd
= rndx
->rfd
;
1051 unsigned int indx
= rndx
->index
;
1057 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1058 struct return type of a procedure compiled without -g. */
1059 if (ifd
== 0xffffffff
1060 || (rndx
->rfd
== 0xfff && indx
== 0))
1061 name
= "<undefined>";
1062 else if (indx
== indexNil
)
1068 if (debug_info
->external_rfd
== NULL
)
1069 fdr
= debug_info
->fdr
+ ifd
;
1074 (*debug_swap
->swap_rfd_in
) (abfd
,
1075 ((char *) debug_info
->external_rfd
1076 + ((fdr
->rfdBase
+ ifd
)
1077 * debug_swap
->external_rfd_size
)),
1079 fdr
= debug_info
->fdr
+ rfd
;
1082 indx
+= fdr
->isymBase
;
1084 (*debug_swap
->swap_sym_in
) (abfd
,
1085 ((char *) debug_info
->external_sym
1086 + indx
* debug_swap
->external_sym_size
),
1089 name
= debug_info
->ss
+ fdr
->issBase
+ sym
.iss
;
1093 "%s %s { ifd = %u, index = %lu }",
1095 ((unsigned long) indx
1096 + debug_info
->symbolic_header
.iextMax
));
1099 /* Convert the type information to string format. */
1102 ecoff_type_to_string (bfd
*abfd
, FDR
*fdr
, unsigned int indx
)
1104 union aux_ext
*aux_ptr
;
1114 unsigned int basic_type
;
1117 static char buffer2
[1024];
1122 aux_ptr
= ecoff_data (abfd
)->debug_info
.external_aux
+ fdr
->iauxBase
;
1123 bigendian
= fdr
->fBigendian
;
1125 for (i
= 0; i
< 7; i
++)
1127 qualifiers
[i
].low_bound
= 0;
1128 qualifiers
[i
].high_bound
= 0;
1129 qualifiers
[i
].stride
= 0;
1132 if (AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
]) == (bfd_vma
) -1)
1133 return "-1 (no type)";
1134 _bfd_ecoff_swap_tir_in (bigendian
, &aux_ptr
[indx
++].a_ti
, &u
.ti
);
1136 basic_type
= u
.ti
.bt
;
1137 qualifiers
[0].type
= u
.ti
.tq0
;
1138 qualifiers
[1].type
= u
.ti
.tq1
;
1139 qualifiers
[2].type
= u
.ti
.tq2
;
1140 qualifiers
[3].type
= u
.ti
.tq3
;
1141 qualifiers
[4].type
= u
.ti
.tq4
;
1142 qualifiers
[5].type
= u
.ti
.tq5
;
1143 qualifiers
[6].type
= tqNil
;
1145 /* Go get the basic type. */
1148 case btNil
: /* Undefined. */
1152 case btAdr
: /* Address - integer same size as pointer. */
1153 strcpy (p1
, "address");
1156 case btChar
: /* Character. */
1157 strcpy (p1
, "char");
1160 case btUChar
: /* Unsigned character. */
1161 strcpy (p1
, "unsigned char");
1164 case btShort
: /* Short. */
1165 strcpy (p1
, "short");
1168 case btUShort
: /* Unsigned short. */
1169 strcpy (p1
, "unsigned short");
1172 case btInt
: /* Int. */
1176 case btUInt
: /* Unsigned int. */
1177 strcpy (p1
, "unsigned int");
1180 case btLong
: /* Long. */
1181 strcpy (p1
, "long");
1184 case btULong
: /* Unsigned long. */
1185 strcpy (p1
, "unsigned long");
1188 case btFloat
: /* Float (real). */
1189 strcpy (p1
, "float");
1192 case btDouble
: /* Double (real). */
1193 strcpy (p1
, "double");
1196 /* Structures add 1-2 aux words:
1197 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1198 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1200 case btStruct
: /* Structure (Record). */
1201 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1202 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1203 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1205 indx
++; /* Skip aux words. */
1208 /* Unions add 1-2 aux words:
1209 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1210 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1212 case btUnion
: /* Union. */
1213 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1214 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1215 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1217 indx
++; /* Skip aux words. */
1220 /* Enumerations add 1-2 aux words:
1221 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1222 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1224 case btEnum
: /* Enumeration. */
1225 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1226 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1227 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1229 indx
++; /* Skip aux words. */
1232 case btTypedef
: /* Defined via a typedef, isymRef points. */
1233 strcpy (p1
, "typedef");
1236 case btRange
: /* Subrange of int. */
1237 strcpy (p1
, "subrange");
1240 case btSet
: /* Pascal sets. */
1244 case btComplex
: /* Fortran complex. */
1245 strcpy (p1
, "complex");
1248 case btDComplex
: /* Fortran double complex. */
1249 strcpy (p1
, "double complex");
1252 case btIndirect
: /* Forward or unnamed typedef. */
1253 strcpy (p1
, "forward/unamed typedef");
1256 case btFixedDec
: /* Fixed Decimal. */
1257 strcpy (p1
, "fixed decimal");
1260 case btFloatDec
: /* Float Decimal. */
1261 strcpy (p1
, "float decimal");
1264 case btString
: /* Varying Length Character String. */
1265 strcpy (p1
, "string");
1268 case btBit
: /* Aligned Bit String. */
1272 case btPicture
: /* Picture. */
1273 strcpy (p1
, "picture");
1276 case btVoid
: /* Void. */
1277 strcpy (p1
, "void");
1281 sprintf (p1
, _("unknown basic type %d"), (int) basic_type
);
1285 p1
+= strlen (buffer1
);
1287 /* If this is a bitfield, get the bitsize. */
1292 bitsize
= AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
++]);
1293 sprintf (p1
, " : %d", bitsize
);
1294 p1
+= strlen (buffer1
);
1297 /* Deal with any qualifiers. */
1298 if (qualifiers
[0].type
!= tqNil
)
1300 /* Snarf up any array bounds in the correct order. Arrays
1301 store 5 successive words in the aux. table:
1302 word 0 RNDXR to type of the bounds (ie, int)
1303 word 1 Current file descriptor index
1305 word 3 high bound (or -1 if [])
1306 word 4 stride size in bits. */
1307 for (i
= 0; i
< 7; i
++)
1309 if (qualifiers
[i
].type
== tqArray
)
1311 qualifiers
[i
].low_bound
=
1312 AUX_GET_DNLOW (bigendian
, &aux_ptr
[indx
+2]);
1313 qualifiers
[i
].high_bound
=
1314 AUX_GET_DNHIGH (bigendian
, &aux_ptr
[indx
+3]);
1315 qualifiers
[i
].stride
=
1316 AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
+4]);
1321 /* Now print out the qualifiers. */
1322 for (i
= 0; i
< 6; i
++)
1324 switch (qualifiers
[i
].type
)
1331 strcpy (p2
, "ptr to ");
1332 p2
+= sizeof ("ptr to ")-1;
1336 strcpy (p2
, "volatile ");
1337 p2
+= sizeof ("volatile ")-1;
1341 strcpy (p2
, "far ");
1342 p2
+= sizeof ("far ")-1;
1346 strcpy (p2
, "func. ret. ");
1347 p2
+= sizeof ("func. ret. ");
1352 int first_array
= i
;
1355 /* Print array bounds reversed (ie, in the order the C
1356 programmer writes them). C is such a fun language.... */
1357 while (i
< 5 && qualifiers
[i
+1].type
== tqArray
)
1360 for (j
= i
; j
>= first_array
; j
--)
1362 strcpy (p2
, "array [");
1363 p2
+= sizeof ("array [")-1;
1364 if (qualifiers
[j
].low_bound
!= 0)
1366 "%ld:%ld {%ld bits}",
1367 (long) qualifiers
[j
].low_bound
,
1368 (long) qualifiers
[j
].high_bound
,
1369 (long) qualifiers
[j
].stride
);
1371 else if (qualifiers
[j
].high_bound
!= -1)
1374 (long) (qualifiers
[j
].high_bound
+ 1),
1375 (long) (qualifiers
[j
].stride
));
1378 sprintf (p2
, " {%ld bits}", (long) (qualifiers
[j
].stride
));
1381 strcpy (p2
, "] of ");
1382 p2
+= sizeof ("] of ")-1;
1390 strcpy (p2
, buffer1
);
1394 /* Return information about ECOFF symbol SYMBOL in RET. */
1397 _bfd_ecoff_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
1401 bfd_symbol_info (symbol
, ret
);
1404 /* Return whether this is a local label. */
1407 _bfd_ecoff_bfd_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1410 return name
[0] == '$';
1413 /* Print information about an ECOFF symbol. */
1416 _bfd_ecoff_print_symbol (bfd
*abfd
,
1419 bfd_print_symbol_type how
)
1421 const struct ecoff_debug_swap
* const debug_swap
1422 = &ecoff_backend (abfd
)->debug_swap
;
1423 FILE *file
= (FILE *)filep
;
1427 case bfd_print_symbol_name
:
1428 fprintf (file
, "%s", symbol
->name
);
1430 case bfd_print_symbol_more
:
1431 if (ecoffsymbol (symbol
)->local
)
1435 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1437 fprintf (file
, "ecoff local ");
1438 fprintf_vma (file
, (bfd_vma
) ecoff_sym
.value
);
1439 fprintf (file
, " %x %x", (unsigned) ecoff_sym
.st
,
1440 (unsigned) ecoff_sym
.sc
);
1446 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1448 fprintf (file
, "ecoff extern ");
1449 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1450 fprintf (file
, " %x %x", (unsigned) ecoff_ext
.asym
.st
,
1451 (unsigned) ecoff_ext
.asym
.sc
);
1454 case bfd_print_symbol_all
:
1455 /* Print out the symbols in a reasonable way. */
1464 if (ecoffsymbol (symbol
)->local
)
1466 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1469 pos
= ((((char *) ecoffsymbol (symbol
)->native
1470 - (char *) ecoff_data (abfd
)->debug_info
.external_sym
)
1471 / debug_swap
->external_sym_size
)
1472 + ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
);
1479 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1482 pos
= (((char *) ecoffsymbol (symbol
)->native
1483 - (char *) ecoff_data (abfd
)->debug_info
.external_ext
)
1484 / debug_swap
->external_ext_size
);
1485 jmptbl
= ecoff_ext
.jmptbl
? 'j' : ' ';
1486 cobol_main
= ecoff_ext
.cobol_main
? 'c' : ' ';
1487 weakext
= ecoff_ext
.weakext
? 'w' : ' ';
1490 fprintf (file
, "[%3d] %c ",
1492 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1493 fprintf (file
, " st %x sc %x indx %x %c%c%c %s",
1494 (unsigned) ecoff_ext
.asym
.st
,
1495 (unsigned) ecoff_ext
.asym
.sc
,
1496 (unsigned) ecoff_ext
.asym
.index
,
1497 jmptbl
, cobol_main
, weakext
,
1500 if (ecoffsymbol (symbol
)->fdr
!= NULL
1501 && ecoff_ext
.asym
.index
!= indexNil
)
1506 bfd_size_type sym_base
;
1507 union aux_ext
*aux_base
;
1509 fdr
= ecoffsymbol (symbol
)->fdr
;
1510 indx
= ecoff_ext
.asym
.index
;
1512 /* sym_base is used to map the fdr relative indices which
1513 appear in the file to the position number which we are
1515 sym_base
= fdr
->isymBase
;
1516 if (ecoffsymbol (symbol
)->local
)
1518 ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
1520 /* aux_base is the start of the aux entries for this file;
1521 asym.index is an offset from this. */
1522 aux_base
= (ecoff_data (abfd
)->debug_info
.external_aux
1525 /* The aux entries are stored in host byte order; the
1526 order is indicated by a bit in the fdr. */
1527 bigendian
= fdr
->fBigendian
;
1529 /* This switch is basically from gcc/mips-tdump.c. */
1530 switch (ecoff_ext
.asym
.st
)
1538 fprintf (file
, _("\n End+1 symbol: %ld"),
1539 (long) (indx
+ sym_base
));
1543 if (ecoff_ext
.asym
.sc
== scText
1544 || ecoff_ext
.asym
.sc
== scInfo
)
1545 fprintf (file
, _("\n First symbol: %ld"),
1546 (long) (indx
+ sym_base
));
1548 fprintf (file
, _("\n First symbol: %ld"),
1550 (AUX_GET_ISYM (bigendian
,
1551 &aux_base
[ecoff_ext
.asym
.index
])
1557 if (ECOFF_IS_STAB (&ecoff_ext
.asym
))
1559 else if (ecoffsymbol (symbol
)->local
)
1560 /* xgettext:c-format */
1561 fprintf (file
, _("\n End+1 symbol: %-7ld Type: %s"),
1563 (AUX_GET_ISYM (bigendian
,
1564 &aux_base
[ecoff_ext
.asym
.index
])
1566 ecoff_type_to_string (abfd
, fdr
, indx
+ 1));
1568 fprintf (file
, _("\n Local symbol: %ld"),
1571 + (ecoff_data (abfd
)
1572 ->debug_info
.symbolic_header
.iextMax
)));
1576 fprintf (file
, _("\n struct; End+1 symbol: %ld"),
1577 (long) (indx
+ sym_base
));
1581 fprintf (file
, _("\n union; End+1 symbol: %ld"),
1582 (long) (indx
+ sym_base
));
1586 fprintf (file
, _("\n enum; End+1 symbol: %ld"),
1587 (long) (indx
+ sym_base
));
1591 if (! ECOFF_IS_STAB (&ecoff_ext
.asym
))
1592 fprintf (file
, _("\n Type: %s"),
1593 ecoff_type_to_string (abfd
, fdr
, indx
));
1602 /* Read in the relocs for a section. */
1605 ecoff_slurp_reloc_table (bfd
*abfd
,
1609 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1610 arelent
*internal_relocs
;
1611 bfd_size_type external_reloc_size
;
1613 bfd_byte
*external_relocs
;
1617 if (section
->relocation
!= NULL
1618 || section
->reloc_count
== 0
1619 || (section
->flags
& SEC_CONSTRUCTOR
) != 0)
1622 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1625 external_reloc_size
= backend
->external_reloc_size
;
1626 amt
= external_reloc_size
* section
->reloc_count
;
1627 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1629 external_relocs
= _bfd_malloc_and_read (abfd
, amt
, amt
);
1630 if (external_relocs
== NULL
)
1633 amt
= section
->reloc_count
;
1634 amt
*= sizeof (arelent
);
1635 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
1636 if (internal_relocs
== NULL
)
1638 free (external_relocs
);
1642 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1644 struct internal_reloc intern
;
1646 (*backend
->swap_reloc_in
) (abfd
,
1647 external_relocs
+ i
* external_reloc_size
,
1650 if (intern
.r_extern
)
1652 /* r_symndx is an index into the external symbols. */
1653 BFD_ASSERT (intern
.r_symndx
>= 0
1655 < (ecoff_data (abfd
)
1656 ->debug_info
.symbolic_header
.iextMax
)));
1657 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1660 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1661 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1663 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1668 const char *sec_name
;
1671 /* r_symndx is a section key. */
1672 switch (intern
.r_symndx
)
1674 case RELOC_SECTION_TEXT
: sec_name
= _TEXT
; break;
1675 case RELOC_SECTION_RDATA
: sec_name
= _RDATA
; break;
1676 case RELOC_SECTION_DATA
: sec_name
= _DATA
; break;
1677 case RELOC_SECTION_SDATA
: sec_name
= _SDATA
; break;
1678 case RELOC_SECTION_SBSS
: sec_name
= _SBSS
; break;
1679 case RELOC_SECTION_BSS
: sec_name
= _BSS
; break;
1680 case RELOC_SECTION_INIT
: sec_name
= _INIT
; break;
1681 case RELOC_SECTION_LIT8
: sec_name
= _LIT8
; break;
1682 case RELOC_SECTION_LIT4
: sec_name
= _LIT4
; break;
1683 case RELOC_SECTION_XDATA
: sec_name
= _XDATA
; break;
1684 case RELOC_SECTION_PDATA
: sec_name
= _PDATA
; break;
1685 case RELOC_SECTION_FINI
: sec_name
= _FINI
; break;
1686 case RELOC_SECTION_LITA
: sec_name
= _LITA
; break;
1687 case RELOC_SECTION_RCONST
: sec_name
= _RCONST
; break;
1691 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1694 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1696 rptr
->addend
= - bfd_section_vma (sec
);
1699 rptr
->address
= intern
.r_vaddr
- bfd_section_vma (section
);
1701 /* Let the backend select the howto field and do any other
1702 required processing. */
1703 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1706 free (external_relocs
);
1708 section
->relocation
= internal_relocs
;
1713 /* Get a canonical list of relocs. */
1716 _bfd_ecoff_canonicalize_reloc (bfd
*abfd
,
1723 if (section
->flags
& SEC_CONSTRUCTOR
)
1725 arelent_chain
*chain
;
1727 /* This section has relocs made up by us, not the file, so take
1728 them out of their chain and place them into the data area
1730 for (count
= 0, chain
= section
->constructor_chain
;
1731 count
< section
->reloc_count
;
1732 count
++, chain
= chain
->next
)
1733 *relptr
++ = &chain
->relent
;
1739 if (! ecoff_slurp_reloc_table (abfd
, section
, symbols
))
1742 tblptr
= section
->relocation
;
1744 for (count
= 0; count
< section
->reloc_count
; count
++)
1745 *relptr
++ = tblptr
++;
1750 return section
->reloc_count
;
1753 /* Provided a BFD, a section and an offset into the section, calculate
1754 and return the name of the source file and the line nearest to the
1758 _bfd_ecoff_find_nearest_line (bfd
*abfd
,
1759 asymbol
**symbols ATTRIBUTE_UNUSED
,
1762 const char **filename_ptr
,
1763 const char **functionname_ptr
,
1764 unsigned int *retline_ptr
,
1765 unsigned int *discriminator_ptr
)
1767 const struct ecoff_debug_swap
* const debug_swap
1768 = &ecoff_backend (abfd
)->debug_swap
;
1769 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1770 struct ecoff_find_line
*line_info
;
1772 /* Make sure we have the FDR's. */
1773 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
, debug_info
)
1774 || bfd_get_symcount (abfd
) == 0)
1777 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1779 size_t amt
= sizeof (struct ecoff_find_line
);
1781 ecoff_data (abfd
)->find_line_info
=
1782 (struct ecoff_find_line
*) bfd_zalloc (abfd
, amt
);
1783 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1787 if (discriminator_ptr
)
1788 *discriminator_ptr
= 0;
1789 line_info
= ecoff_data (abfd
)->find_line_info
;
1790 return _bfd_ecoff_locate_line (abfd
, section
, offset
, debug_info
,
1791 debug_swap
, line_info
, filename_ptr
,
1792 functionname_ptr
, retline_ptr
);
1795 /* Copy private BFD data. This is called by objcopy and strip. We
1796 use it to copy the ECOFF debugging information from one BFD to the
1797 other. It would be theoretically possible to represent the ECOFF
1798 debugging information in the symbol table. However, it would be a
1799 lot of work, and there would be little gain (gas, gdb, and ld
1800 already access the ECOFF debugging information via the
1801 ecoff_debug_info structure, and that structure would have to be
1802 retained in order to support ECOFF debugging in MIPS ELF).
1804 The debugging information for the ECOFF external symbols comes from
1805 the symbol table, so this function only handles the other debugging
1809 _bfd_ecoff_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1811 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
1812 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
1814 asymbol
**sym_ptr_ptr
;
1818 /* We only want to copy information over if both BFD's use ECOFF
1820 if (bfd_get_flavour (ibfd
) != bfd_target_ecoff_flavour
1821 || bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
1824 /* Copy the GP value and the register masks. */
1825 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
1826 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
1827 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
1828 for (i
= 0; i
< 3; i
++)
1829 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
1831 /* Copy the version stamp. */
1832 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
1834 /* If there are no symbols, don't copy any debugging information. */
1835 c
= bfd_get_symcount (obfd
);
1836 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1837 if (c
== 0 || sym_ptr_ptr
== NULL
)
1840 /* See if there are any local symbols. */
1842 for (; c
> 0; c
--, sym_ptr_ptr
++)
1844 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
1853 /* There are some local symbols. We just bring over all the
1854 debugging information. FIXME: This is not quite the right
1855 thing to do. If the user has asked us to discard all
1856 debugging information, then we are probably going to wind up
1857 keeping it because there will probably be some local symbol
1858 which objcopy did not discard. We should actually break
1859 apart the debugging information and only keep that which
1860 applies to the symbols we want to keep. */
1861 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
1862 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
1863 oinfo
->line
= iinfo
->line
;
1865 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
1866 oinfo
->external_dnr
= iinfo
->external_dnr
;
1868 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
1869 oinfo
->external_pdr
= iinfo
->external_pdr
;
1871 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
1872 oinfo
->external_sym
= iinfo
->external_sym
;
1874 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
1875 oinfo
->external_opt
= iinfo
->external_opt
;
1877 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
1878 oinfo
->external_aux
= iinfo
->external_aux
;
1880 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
1881 oinfo
->ss
= iinfo
->ss
;
1883 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
1884 oinfo
->external_fdr
= iinfo
->external_fdr
;
1886 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
1887 oinfo
->external_rfd
= iinfo
->external_rfd
;
1891 /* We are discarding all the local symbol information. Look
1892 through the external symbols and remove all references to FDR
1893 or aux information. */
1894 c
= bfd_get_symcount (obfd
);
1895 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1896 for (; c
> 0; c
--, sym_ptr_ptr
++)
1900 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
1901 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
1903 esym
.asym
.index
= indexNil
;
1904 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
1905 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
1912 /* Set the architecture. The supported architecture is stored in the
1913 backend pointer. We always set the architecture anyhow, since many
1914 callers ignore the return value. */
1917 _bfd_ecoff_set_arch_mach (bfd
*abfd
,
1918 enum bfd_architecture arch
,
1919 unsigned long machine
)
1921 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1922 return arch
== ecoff_backend (abfd
)->arch
;
1925 /* Get the size of the section headers. */
1928 _bfd_ecoff_sizeof_headers (bfd
*abfd
,
1929 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1936 for (current
= abfd
->sections
;
1938 current
= current
->next
)
1941 ret
= (bfd_coff_filhsz (abfd
)
1942 + bfd_coff_aoutsz (abfd
)
1943 + c
* bfd_coff_scnhsz (abfd
));
1944 return (int) BFD_ALIGN (ret
, 16);
1947 /* Get the contents of a section. */
1950 _bfd_ecoff_get_section_contents (bfd
*abfd
,
1954 bfd_size_type count
)
1956 return _bfd_generic_get_section_contents (abfd
, section
, location
,
1960 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
1961 called via qsort. */
1964 ecoff_sort_hdrs (const void * arg1
, const void * arg2
)
1966 const asection
*hdr1
= *(const asection
**) arg1
;
1967 const asection
*hdr2
= *(const asection
**) arg2
;
1969 if ((hdr1
->flags
& SEC_ALLOC
) != 0)
1971 if ((hdr2
->flags
& SEC_ALLOC
) == 0)
1976 if ((hdr2
->flags
& SEC_ALLOC
) != 0)
1979 if (hdr1
->vma
< hdr2
->vma
)
1981 else if (hdr1
->vma
> hdr2
->vma
)
1987 /* Calculate the file position for each section, and set
1991 ecoff_compute_section_file_positions (bfd
*abfd
)
1993 file_ptr sofar
, file_sofar
;
1994 asection
**sorted_hdrs
;
1998 bfd_boolean rdata_in_text
;
1999 bfd_boolean first_data
, first_nonalloc
;
2000 const bfd_vma round
= ecoff_backend (abfd
)->round
;
2003 sofar
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2006 /* Sort the sections by VMA. */
2007 amt
= abfd
->section_count
;
2008 amt
*= sizeof (asection
*);
2009 sorted_hdrs
= (asection
**) bfd_malloc (amt
);
2010 if (sorted_hdrs
== NULL
)
2012 for (current
= abfd
->sections
, i
= 0;
2014 current
= current
->next
, i
++)
2015 sorted_hdrs
[i
] = current
;
2016 BFD_ASSERT (i
== abfd
->section_count
);
2018 qsort (sorted_hdrs
, abfd
->section_count
, sizeof (asection
*),
2021 /* Some versions of the OSF linker put the .rdata section in the
2022 text segment, and some do not. */
2023 rdata_in_text
= ecoff_backend (abfd
)->rdata_in_text
;
2026 for (i
= 0; i
< abfd
->section_count
; i
++)
2028 current
= sorted_hdrs
[i
];
2029 if (streq (current
->name
, _RDATA
))
2031 if ((current
->flags
& SEC_CODE
) == 0
2032 && ! streq (current
->name
, _PDATA
)
2033 && ! streq (current
->name
, _RCONST
))
2035 rdata_in_text
= FALSE
;
2040 ecoff_data (abfd
)->rdata_in_text
= rdata_in_text
;
2043 first_nonalloc
= TRUE
;
2044 for (i
= 0; i
< abfd
->section_count
; i
++)
2046 unsigned int alignment_power
;
2048 current
= sorted_hdrs
[i
];
2050 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2051 supposed to indicate the number of .pdata entries that are
2052 really in the section. Each entry is 8 bytes. We store this
2053 away in line_filepos before increasing the section size. */
2054 if (streq (current
->name
, _PDATA
))
2055 current
->line_filepos
= current
->size
/ 8;
2057 alignment_power
= current
->alignment_power
;
2059 /* On Ultrix, the data sections in an executable file must be
2060 aligned to a page boundary within the file. This does not
2061 affect the section size, though. FIXME: Does this work for
2062 other platforms? It requires some modification for the
2063 Alpha, because .rdata on the Alpha goes with the text, not
2065 if ((abfd
->flags
& EXEC_P
) != 0
2066 && (abfd
->flags
& D_PAGED
) != 0
2068 && (current
->flags
& SEC_CODE
) == 0
2070 || ! streq (current
->name
, _RDATA
))
2071 && ! streq (current
->name
, _PDATA
)
2072 && ! streq (current
->name
, _RCONST
))
2074 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2075 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2078 else if (streq (current
->name
, _LIB
))
2080 /* On Irix 4, the location of contents of the .lib section
2081 from a shared library section is also rounded up to a
2084 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2085 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2087 else if (first_nonalloc
2088 && (current
->flags
& SEC_ALLOC
) == 0
2089 && (abfd
->flags
& D_PAGED
) != 0)
2091 /* Skip up to the next page for an unallocated section, such
2092 as the .comment section on the Alpha. This leaves room
2093 for the .bss section. */
2094 first_nonalloc
= FALSE
;
2095 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2096 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2099 /* Align the sections in the file to the same boundary on
2100 which they are aligned in virtual memory. */
2101 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2102 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2103 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2105 if ((abfd
->flags
& D_PAGED
) != 0
2106 && (current
->flags
& SEC_ALLOC
) != 0)
2108 sofar
+= (current
->vma
- sofar
) % round
;
2109 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2110 file_sofar
+= (current
->vma
- file_sofar
) % round
;
2113 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) != 0)
2114 current
->filepos
= file_sofar
;
2116 sofar
+= current
->size
;
2117 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2118 file_sofar
+= current
->size
;
2120 /* Make sure that this section is of the right size too. */
2122 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2123 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2124 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2125 current
->size
+= sofar
- old_sofar
;
2131 ecoff_data (abfd
)->reloc_filepos
= file_sofar
;
2136 /* Determine the location of the relocs for all the sections in the
2137 output file, as well as the location of the symbolic debugging
2140 static bfd_size_type
2141 ecoff_compute_reloc_file_positions (bfd
*abfd
)
2143 const bfd_size_type external_reloc_size
=
2144 ecoff_backend (abfd
)->external_reloc_size
;
2145 file_ptr reloc_base
;
2146 bfd_size_type reloc_size
;
2150 if (! abfd
->output_has_begun
)
2152 if (! ecoff_compute_section_file_positions (abfd
))
2154 abfd
->output_has_begun
= TRUE
;
2157 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2160 for (current
= abfd
->sections
;
2162 current
= current
->next
)
2164 if (current
->reloc_count
== 0)
2165 current
->rel_filepos
= 0;
2168 bfd_size_type relsize
;
2170 current
->rel_filepos
= reloc_base
;
2171 relsize
= current
->reloc_count
* external_reloc_size
;
2172 reloc_size
+= relsize
;
2173 reloc_base
+= relsize
;
2177 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2179 /* At least on Ultrix, the symbol table of an executable file must
2180 be aligned to a page boundary. FIXME: Is this true on other
2182 if ((abfd
->flags
& EXEC_P
) != 0
2183 && (abfd
->flags
& D_PAGED
) != 0)
2184 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2185 &~ (ecoff_backend (abfd
)->round
- 1));
2187 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2192 /* Set the contents of a section. */
2195 _bfd_ecoff_set_section_contents (bfd
*abfd
,
2197 const void * location
,
2199 bfd_size_type count
)
2203 /* This must be done first, because bfd_set_section_contents is
2204 going to set output_has_begun to TRUE. */
2205 if (! abfd
->output_has_begun
2206 && ! ecoff_compute_section_file_positions (abfd
))
2209 /* Handle the .lib section specially so that Irix 4 shared libraries
2210 work out. See coff_set_section_contents in coffcode.h. */
2211 if (streq (section
->name
, _LIB
))
2213 bfd_byte
*rec
, *recend
;
2215 rec
= (bfd_byte
*) location
;
2216 recend
= rec
+ count
;
2217 while (rec
< recend
)
2220 rec
+= bfd_get_32 (abfd
, rec
) * 4;
2223 BFD_ASSERT (rec
== recend
);
2229 pos
= section
->filepos
+ offset
;
2230 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2231 || bfd_bwrite (location
, count
, abfd
) != count
)
2237 /* Set the GP value for an ECOFF file. This is a hook used by the
2241 bfd_ecoff_set_gp_value (bfd
*abfd
, bfd_vma gp_value
)
2243 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2244 || bfd_get_format (abfd
) != bfd_object
)
2246 bfd_set_error (bfd_error_invalid_operation
);
2250 ecoff_data (abfd
)->gp
= gp_value
;
2255 /* Set the register masks for an ECOFF file. This is a hook used by
2259 bfd_ecoff_set_regmasks (bfd
*abfd
,
2260 unsigned long gprmask
,
2261 unsigned long fprmask
,
2262 unsigned long *cprmask
)
2264 ecoff_data_type
*tdata
;
2266 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2267 || bfd_get_format (abfd
) != bfd_object
)
2269 bfd_set_error (bfd_error_invalid_operation
);
2273 tdata
= ecoff_data (abfd
);
2274 tdata
->gprmask
= gprmask
;
2275 tdata
->fprmask
= fprmask
;
2276 if (cprmask
!= NULL
)
2280 for (i
= 0; i
< 3; i
++)
2281 tdata
->cprmask
[i
] = cprmask
[i
];
2287 /* Get ECOFF EXTR information for an external symbol. This function
2288 is passed to bfd_ecoff_debug_externals. */
2291 ecoff_get_extr (asymbol
*sym
, EXTR
*esym
)
2293 ecoff_symbol_type
*ecoff_sym_ptr
;
2296 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2297 || ecoffsymbol (sym
)->native
== NULL
)
2299 /* Don't include debugging, local, or section symbols. */
2300 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2301 || (sym
->flags
& BSF_LOCAL
) != 0
2302 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2306 esym
->cobol_main
= 0;
2307 esym
->weakext
= (sym
->flags
& BSF_WEAK
) != 0;
2310 /* FIXME: we can do better than this for st and sc. */
2311 esym
->asym
.st
= stGlobal
;
2312 esym
->asym
.sc
= scAbs
;
2313 esym
->asym
.reserved
= 0;
2314 esym
->asym
.index
= indexNil
;
2318 ecoff_sym_ptr
= ecoffsymbol (sym
);
2320 if (ecoff_sym_ptr
->local
)
2323 input_bfd
= bfd_asymbol_bfd (sym
);
2324 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2325 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2327 /* If the symbol was defined by the linker, then esym will be
2328 undefined but sym will not be. Get a better class for such a
2330 if ((esym
->asym
.sc
== scUndefined
2331 || esym
->asym
.sc
== scSUndefined
)
2332 && ! bfd_is_und_section (bfd_asymbol_section (sym
)))
2333 esym
->asym
.sc
= scAbs
;
2335 /* Adjust the FDR index for the symbol by that used for the input
2337 if (esym
->ifd
!= -1)
2339 struct ecoff_debug_info
*input_debug
;
2341 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2342 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2343 if (input_debug
->ifdmap
!= NULL
)
2344 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2350 /* Set the external symbol index. This routine is passed to
2351 bfd_ecoff_debug_externals. */
2354 ecoff_set_index (asymbol
*sym
, bfd_size_type indx
)
2356 ecoff_set_sym_index (sym
, indx
);
2359 /* Write out an ECOFF file. */
2362 _bfd_ecoff_write_object_contents (bfd
*abfd
)
2364 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2365 const bfd_vma round
= backend
->round
;
2366 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2367 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2368 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2369 const bfd_size_type external_hdr_size
2370 = backend
->debug_swap
.external_hdr_size
;
2371 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2372 void (* const adjust_reloc_out
) (bfd
*, const arelent
*, struct internal_reloc
*)
2373 = backend
->adjust_reloc_out
;
2374 void (* const swap_reloc_out
) (bfd
*, const struct internal_reloc
*, void *)
2375 = backend
->swap_reloc_out
;
2376 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2377 HDRR
* const symhdr
= &debug
->symbolic_header
;
2380 bfd_size_type reloc_size
;
2381 bfd_size_type text_size
;
2383 bfd_boolean set_text_start
;
2384 bfd_size_type data_size
;
2386 bfd_boolean set_data_start
;
2387 bfd_size_type bss_size
;
2389 void * reloc_buff
= NULL
;
2390 struct internal_filehdr internal_f
;
2391 struct internal_aouthdr internal_a
;
2394 /* Determine where the sections and relocs will go in the output
2396 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2399 for (current
= abfd
->sections
;
2401 current
= current
->next
)
2403 current
->target_index
= count
;
2407 if ((abfd
->flags
& D_PAGED
) != 0)
2408 text_size
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2412 set_text_start
= FALSE
;
2415 set_data_start
= FALSE
;
2418 /* Write section headers to the file. */
2420 /* Allocate buff big enough to hold a section header,
2421 file header, or a.out header. */
2430 buff
= bfd_malloc (siz
);
2435 internal_f
.f_nscns
= 0;
2436 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2439 for (current
= abfd
->sections
;
2441 current
= current
->next
)
2443 struct internal_scnhdr section
;
2446 ++internal_f
.f_nscns
;
2448 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2450 /* This seems to be correct for Irix 4 shared libraries. */
2451 vma
= bfd_section_vma (current
);
2452 if (streq (current
->name
, _LIB
))
2453 section
.s_vaddr
= 0;
2455 section
.s_vaddr
= vma
;
2457 section
.s_paddr
= current
->lma
;
2458 section
.s_size
= current
->size
;
2460 /* If this section is unloadable then the scnptr will be 0. */
2461 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2462 section
.s_scnptr
= 0;
2464 section
.s_scnptr
= current
->filepos
;
2465 section
.s_relptr
= current
->rel_filepos
;
2467 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2468 object file produced by the assembler is supposed to point to
2469 information about how much room is required by objects of
2470 various different sizes. I think this only matters if we
2471 want the linker to compute the best size to use, or
2472 something. I don't know what happens if the information is
2474 if (! streq (current
->name
, _PDATA
))
2475 section
.s_lnnoptr
= 0;
2478 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2479 hold the number of entries in the section (each entry is
2480 8 bytes). We stored this in the line_filepos field in
2481 ecoff_compute_section_file_positions. */
2482 section
.s_lnnoptr
= current
->line_filepos
;
2485 section
.s_nreloc
= current
->reloc_count
;
2486 section
.s_nlnno
= 0;
2487 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2490 if (bfd_coff_swap_scnhdr_out (abfd
, (void *) §ion
, buff
) == 0
2491 || bfd_bwrite (buff
, scnhsz
, abfd
) != scnhsz
)
2494 if ((section
.s_flags
& STYP_TEXT
) != 0
2495 || ((section
.s_flags
& STYP_RDATA
) != 0
2496 && ecoff_data (abfd
)->rdata_in_text
)
2497 || section
.s_flags
== STYP_PDATA
2498 || (section
.s_flags
& STYP_DYNAMIC
) != 0
2499 || (section
.s_flags
& STYP_LIBLIST
) != 0
2500 || (section
.s_flags
& STYP_RELDYN
) != 0
2501 || section
.s_flags
== STYP_CONFLIC
2502 || (section
.s_flags
& STYP_DYNSTR
) != 0
2503 || (section
.s_flags
& STYP_DYNSYM
) != 0
2504 || (section
.s_flags
& STYP_HASH
) != 0
2505 || (section
.s_flags
& STYP_ECOFF_INIT
) != 0
2506 || (section
.s_flags
& STYP_ECOFF_FINI
) != 0
2507 || section
.s_flags
== STYP_RCONST
)
2509 text_size
+= current
->size
;
2510 if (! set_text_start
|| text_start
> vma
)
2513 set_text_start
= TRUE
;
2516 else if ((section
.s_flags
& STYP_RDATA
) != 0
2517 || (section
.s_flags
& STYP_DATA
) != 0
2518 || (section
.s_flags
& STYP_LITA
) != 0
2519 || (section
.s_flags
& STYP_LIT8
) != 0
2520 || (section
.s_flags
& STYP_LIT4
) != 0
2521 || (section
.s_flags
& STYP_SDATA
) != 0
2522 || section
.s_flags
== STYP_XDATA
2523 || (section
.s_flags
& STYP_GOT
) != 0)
2525 data_size
+= current
->size
;
2526 if (! set_data_start
|| data_start
> vma
)
2529 set_data_start
= TRUE
;
2532 else if ((section
.s_flags
& STYP_BSS
) != 0
2533 || (section
.s_flags
& STYP_SBSS
) != 0)
2534 bss_size
+= current
->size
;
2535 else if (section
.s_flags
== 0
2536 || (section
.s_flags
& STYP_ECOFF_LIB
) != 0
2537 || section
.s_flags
== STYP_COMMENT
)
2543 /* Set up the file header. */
2544 internal_f
.f_magic
= ecoff_get_magic (abfd
);
2546 /* We will NOT put a fucking timestamp in the header here. Every
2547 time you put it back, I will come in and take it out again. I'm
2548 sorry. This field does not belong here. We fill it with a 0 so
2549 it compares the same but is not a reasonable time. --
2551 internal_f
.f_timdat
= 0;
2553 if (bfd_get_symcount (abfd
) != 0)
2555 /* The ECOFF f_nsyms field is not actually the number of
2556 symbols, it's the size of symbolic information header. */
2557 internal_f
.f_nsyms
= external_hdr_size
;
2558 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
2562 internal_f
.f_nsyms
= 0;
2563 internal_f
.f_symptr
= 0;
2566 internal_f
.f_opthdr
= aoutsz
;
2568 internal_f
.f_flags
= F_LNNO
;
2569 if (reloc_size
== 0)
2570 internal_f
.f_flags
|= F_RELFLG
;
2571 if (bfd_get_symcount (abfd
) == 0)
2572 internal_f
.f_flags
|= F_LSYMS
;
2573 if (abfd
->flags
& EXEC_P
)
2574 internal_f
.f_flags
|= F_EXEC
;
2576 if (bfd_little_endian (abfd
))
2577 internal_f
.f_flags
|= F_AR32WR
;
2579 internal_f
.f_flags
|= F_AR32W
;
2581 /* Set up the ``optional'' header. */
2582 if ((abfd
->flags
& D_PAGED
) != 0)
2583 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
2585 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
2587 /* FIXME: Is this really correct? */
2588 internal_a
.vstamp
= symhdr
->vstamp
;
2590 /* At least on Ultrix, these have to be rounded to page boundaries.
2591 FIXME: Is this true on other platforms? */
2592 if ((abfd
->flags
& D_PAGED
) != 0)
2594 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
2595 internal_a
.text_start
= text_start
&~ (round
- 1);
2596 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
2597 internal_a
.data_start
= data_start
&~ (round
- 1);
2601 internal_a
.tsize
= text_size
;
2602 internal_a
.text_start
= text_start
;
2603 internal_a
.dsize
= data_size
;
2604 internal_a
.data_start
= data_start
;
2607 /* On Ultrix, the initial portions of the .sbss and .bss segments
2608 are at the end of the data section. The bsize field in the
2609 optional header records how many bss bytes are required beyond
2610 those in the data section. The value is not rounded to a page
2612 if (bss_size
< internal_a
.dsize
- data_size
)
2615 bss_size
-= internal_a
.dsize
- data_size
;
2616 internal_a
.bsize
= bss_size
;
2617 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
2619 internal_a
.entry
= bfd_get_start_address (abfd
);
2621 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
2623 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
2624 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
2625 for (i
= 0; i
< 4; i
++)
2626 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
2628 /* Let the backend adjust the headers if necessary. */
2629 if (backend
->adjust_headers
)
2631 if (! (*backend
->adjust_headers
) (abfd
, &internal_f
, &internal_a
))
2635 /* Write out the file header and the optional header. */
2636 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2639 bfd_coff_swap_filehdr_out (abfd
, (void *) &internal_f
, buff
);
2640 if (bfd_bwrite (buff
, filhsz
, abfd
) != filhsz
)
2643 bfd_coff_swap_aouthdr_out (abfd
, (void *) &internal_a
, buff
);
2644 if (bfd_bwrite (buff
, aoutsz
, abfd
) != aoutsz
)
2647 /* Build the external symbol information. This must be done before
2648 writing out the relocs so that we know the symbol indices. We
2649 don't do this if this BFD was created by the backend linker,
2650 since it will have already handled the symbols and relocs. */
2651 if (! ecoff_data (abfd
)->linker
)
2653 symhdr
->iextMax
= 0;
2654 symhdr
->issExtMax
= 0;
2655 debug
->external_ext
= debug
->external_ext_end
= NULL
;
2656 debug
->ssext
= debug
->ssext_end
= NULL
;
2657 if (! bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
2658 (abfd
->flags
& EXEC_P
) == 0,
2659 ecoff_get_extr
, ecoff_set_index
))
2662 /* Write out the relocs. */
2663 for (current
= abfd
->sections
;
2665 current
= current
->next
)
2667 arelent
**reloc_ptr_ptr
;
2668 arelent
**reloc_end
;
2672 if (current
->reloc_count
== 0)
2675 amt
= current
->reloc_count
* external_reloc_size
;
2676 reloc_buff
= bfd_alloc (abfd
, amt
);
2677 if (reloc_buff
== NULL
)
2680 reloc_ptr_ptr
= current
->orelocation
;
2681 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
2682 out_ptr
= (char *) reloc_buff
;
2685 reloc_ptr_ptr
< reloc_end
;
2686 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
2690 struct internal_reloc in
;
2692 memset ((void *) &in
, 0, sizeof in
);
2694 reloc
= *reloc_ptr_ptr
;
2695 sym
= *reloc
->sym_ptr_ptr
;
2697 /* If the howto field has not been initialised then skip this reloc.
2698 This assumes that an error message has been issued elsewhere. */
2699 if (reloc
->howto
== NULL
)
2702 in
.r_vaddr
= reloc
->address
+ bfd_section_vma (current
);
2703 in
.r_type
= reloc
->howto
->type
;
2705 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2707 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2721 { _TEXT
, RELOC_SECTION_TEXT
},
2722 { _RDATA
, RELOC_SECTION_RDATA
},
2723 { _DATA
, RELOC_SECTION_DATA
},
2724 { _SDATA
, RELOC_SECTION_SDATA
},
2725 { _SBSS
, RELOC_SECTION_SBSS
},
2726 { _BSS
, RELOC_SECTION_BSS
},
2727 { _INIT
, RELOC_SECTION_INIT
},
2728 { _LIT8
, RELOC_SECTION_LIT8
},
2729 { _LIT4
, RELOC_SECTION_LIT4
},
2730 { _XDATA
, RELOC_SECTION_XDATA
},
2731 { _PDATA
, RELOC_SECTION_PDATA
},
2732 { _FINI
, RELOC_SECTION_FINI
},
2733 { _LITA
, RELOC_SECTION_LITA
},
2734 { "*ABS*", RELOC_SECTION_ABS
},
2735 { _RCONST
, RELOC_SECTION_RCONST
}
2738 name
= bfd_section_name (bfd_asymbol_section (sym
));
2740 for (j
= 0; j
< ARRAY_SIZE (section_symndx
); j
++)
2741 if (streq (name
, section_symndx
[j
].name
))
2743 in
.r_symndx
= section_symndx
[j
].r_symndx
;
2747 if (j
== ARRAY_SIZE (section_symndx
))
2752 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2754 (*swap_reloc_out
) (abfd
, &in
, (void *) out_ptr
);
2757 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2759 amt
= current
->reloc_count
* external_reloc_size
;
2760 if (bfd_bwrite (reloc_buff
, amt
, abfd
) != amt
)
2762 bfd_release (abfd
, reloc_buff
);
2766 /* Write out the symbolic debugging information. */
2767 if (bfd_get_symcount (abfd
) > 0)
2769 /* Write out the debugging information. */
2770 if (! bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2771 ecoff_data (abfd
)->sym_filepos
))
2776 /* The .bss section of a demand paged executable must receive an
2777 entire page. If there are symbols, the symbols will start on the
2778 next page. If there are no symbols, we must fill out the page by
2780 if (bfd_get_symcount (abfd
) == 0
2781 && (abfd
->flags
& EXEC_P
) != 0
2782 && (abfd
->flags
& D_PAGED
) != 0)
2786 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2789 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) == 0)
2791 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2794 if (bfd_bwrite (&c
, (bfd_size_type
) 1, abfd
) != 1)
2798 if (reloc_buff
!= NULL
)
2799 bfd_release (abfd
, reloc_buff
);
2804 if (reloc_buff
!= NULL
)
2805 bfd_release (abfd
, reloc_buff
);
2811 /* Archive handling. ECOFF uses what appears to be a unique type of
2812 archive header (armap). The byte ordering of the armap and the
2813 contents are encoded in the name of the armap itself. At least for
2814 now, we only support archives with the same byte ordering in the
2815 armap and the contents.
2817 The first four bytes in the armap are the number of symbol
2818 definitions. This is always a power of two.
2820 This is followed by the symbol definitions. Each symbol definition
2821 occupies 8 bytes. The first four bytes are the offset from the
2822 start of the armap strings to the null-terminated string naming
2823 this symbol. The second four bytes are the file offset to the
2824 archive member which defines this symbol. If the second four bytes
2825 are 0, then this is not actually a symbol definition, and it should
2828 The symbols are hashed into the armap with a closed hashing scheme.
2829 See the functions below for the details of the algorithm.
2831 After the symbol definitions comes four bytes holding the size of
2832 the string table, followed by the string table itself. */
2834 /* The name of an archive headers looks like this:
2835 __________E[BL]E[BL]_ (with a trailing space).
2836 The trailing space is changed to an X if the archive is changed to
2837 indicate that the armap is out of date.
2839 The Alpha seems to use ________64E[BL]E[BL]_. */
2841 #define ARMAP_BIG_ENDIAN 'B'
2842 #define ARMAP_LITTLE_ENDIAN 'L'
2843 #define ARMAP_MARKER 'E'
2844 #define ARMAP_START_LENGTH 10
2845 #define ARMAP_HEADER_MARKER_INDEX 10
2846 #define ARMAP_HEADER_ENDIAN_INDEX 11
2847 #define ARMAP_OBJECT_MARKER_INDEX 12
2848 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2849 #define ARMAP_END_INDEX 14
2850 #define ARMAP_END "_ "
2852 /* This is a magic number used in the hashing algorithm. */
2853 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2855 /* This returns the hash value to use for a string. It also sets
2856 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2857 is the number of entries in the hash table, and HLOG is the log
2861 ecoff_armap_hash (const char *s
,
2862 unsigned int *rehash
,
2872 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2873 hash
*= ARMAP_HASH_MAGIC
;
2874 *rehash
= (hash
& (size
- 1)) | 1;
2875 return hash
>> (32 - hlog
);
2878 /* Read in the armap. */
2881 _bfd_ecoff_slurp_armap (bfd
*abfd
)
2885 struct areltdata
*mapdata
;
2886 bfd_size_type parsed_size
, stringsize
;
2888 struct artdata
*ardata
;
2895 /* Get the name of the first element. */
2896 i
= bfd_bread ((void *) nextname
, (bfd_size_type
) 16, abfd
);
2902 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2905 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2906 standard COFF armap. We could move the ECOFF armap stuff into
2907 bfd_slurp_armap, but that seems inappropriate since no other
2908 target uses this format. Instead, we check directly for a COFF
2910 if (CONST_STRNEQ (nextname
, "/ "))
2911 return bfd_slurp_armap (abfd
);
2913 /* See if the first element is an armap. */
2914 if (! strneq (nextname
, ecoff_backend (abfd
)->armap_start
, ARMAP_START_LENGTH
)
2915 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
2916 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2917 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2918 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
2919 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2920 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2921 || ! strneq (nextname
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1))
2923 abfd
->has_armap
= FALSE
;
2927 /* Make sure we have the right byte ordering. */
2928 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2929 ^ (bfd_header_big_endian (abfd
)))
2930 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2931 ^ (bfd_big_endian (abfd
))))
2933 bfd_set_error (bfd_error_wrong_format
);
2937 /* Read in the armap. */
2938 ardata
= bfd_ardata (abfd
);
2939 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
2940 if (mapdata
== NULL
)
2942 parsed_size
= mapdata
->parsed_size
;
2945 if (parsed_size
+ 1 < 9)
2947 bfd_set_error (bfd_error_malformed_archive
);
2951 raw_armap
= (char *) _bfd_alloc_and_read (abfd
, parsed_size
+ 1, parsed_size
);
2952 if (raw_armap
== NULL
)
2954 raw_armap
[parsed_size
] = 0;
2956 ardata
->tdata
= (void *) raw_armap
;
2958 count
= H_GET_32 (abfd
, raw_armap
);
2959 if ((parsed_size
- 8) / 8 < count
)
2960 goto error_malformed
;
2962 ardata
->symdef_count
= 0;
2963 ardata
->cache
= NULL
;
2965 /* This code used to overlay the symdefs over the raw archive data,
2966 but that doesn't work on a 64 bit host. */
2967 stringbase
= raw_armap
+ count
* 8 + 8;
2968 stringsize
= parsed_size
- (count
* 8 + 8);
2970 #ifdef CHECK_ARMAP_HASH
2974 /* Double check that I have the hashing algorithm right by making
2975 sure that every symbol can be looked up successfully. */
2977 for (i
= 1; i
< count
; i
<<= 1)
2979 BFD_ASSERT (i
== count
);
2981 raw_ptr
= raw_armap
+ 4;
2982 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2984 unsigned int name_offset
, file_offset
;
2985 unsigned int hash
, rehash
, srch
;
2987 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2988 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2989 if (file_offset
== 0)
2991 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
2996 /* See if we can rehash to this location. */
2997 for (srch
= (hash
+ rehash
) & (count
- 1);
2998 srch
!= hash
&& srch
!= i
;
2999 srch
= (srch
+ rehash
) & (count
- 1))
3000 BFD_ASSERT (H_GET_32 (abfd
, (raw_armap
+ 8 + srch
* 8)) != 0);
3001 BFD_ASSERT (srch
== i
);
3005 #endif /* CHECK_ARMAP_HASH */
3007 raw_ptr
= raw_armap
+ 4;
3008 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3009 if (H_GET_32 (abfd
, (raw_ptr
+ 4)) != 0)
3010 ++ardata
->symdef_count
;
3012 amt
= ardata
->symdef_count
;
3013 amt
*= sizeof (carsym
);
3014 symdef_ptr
= (carsym
*) bfd_alloc (abfd
, amt
);
3018 ardata
->symdefs
= symdef_ptr
;
3020 raw_ptr
= raw_armap
+ 4;
3021 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3023 unsigned int name_offset
, file_offset
;
3025 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
3026 if (file_offset
== 0)
3028 name_offset
= H_GET_32 (abfd
, raw_ptr
);
3029 if (name_offset
> stringsize
)
3030 goto error_malformed
;
3031 symdef_ptr
->name
= stringbase
+ name_offset
;
3032 symdef_ptr
->file_offset
= file_offset
;
3036 ardata
->first_file_filepos
= bfd_tell (abfd
);
3037 /* Pad to an even boundary. */
3038 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
3039 abfd
->has_armap
= TRUE
;
3043 bfd_set_error (bfd_error_malformed_archive
);
3045 ardata
->symdef_count
= 0;
3046 ardata
->symdefs
= NULL
;
3047 ardata
->tdata
= NULL
;
3048 bfd_release (abfd
, raw_armap
);
3052 /* Write out an armap. */
3055 _bfd_ecoff_write_armap (bfd
*abfd
,
3056 unsigned int elength
,
3058 unsigned int orl_count
,
3061 unsigned int hashsize
, hashlog
;
3062 bfd_size_type symdefsize
;
3064 unsigned int stringsize
;
3065 unsigned int mapsize
;
3068 struct stat statbuf
;
3071 bfd_byte
*hashtable
;
3075 /* Ultrix appears to use as a hash table size the least power of two
3076 greater than twice the number of entries. */
3077 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3079 hashsize
= 1 << hashlog
;
3081 symdefsize
= hashsize
* 8;
3083 stringsize
= stridx
+ padit
;
3085 /* Include 8 bytes to store symdefsize and stringsize in output. */
3086 mapsize
= symdefsize
+ stringsize
+ 8;
3088 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3090 memset ((void *) &hdr
, 0, sizeof hdr
);
3092 /* Work out the ECOFF armap name. */
3093 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3094 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3095 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3096 (bfd_header_big_endian (abfd
)
3098 : ARMAP_LITTLE_ENDIAN
);
3099 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3100 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3101 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3102 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3104 /* Write the timestamp of the archive header to be just a little bit
3105 later than the timestamp of the file, otherwise the linker will
3106 complain that the index is out of date. Actually, the Ultrix
3107 linker just checks the archive name; the GNU linker may check the
3109 stat (bfd_get_filename (abfd
), &statbuf
);
3110 _bfd_ar_spacepad (hdr
.ar_date
, sizeof (hdr
.ar_date
), "%ld",
3111 (long) (statbuf
.st_mtime
+ 60));
3113 /* The DECstation uses zeroes for the uid, gid and mode of the
3115 hdr
.ar_uid
[0] = '0';
3116 hdr
.ar_gid
[0] = '0';
3117 /* Building gcc ends up extracting the armap as a file - twice. */
3118 hdr
.ar_mode
[0] = '6';
3119 hdr
.ar_mode
[1] = '4';
3120 hdr
.ar_mode
[2] = '4';
3122 _bfd_ar_spacepad (hdr
.ar_size
, sizeof (hdr
.ar_size
), "%-10ld", mapsize
);
3124 hdr
.ar_fmag
[0] = '`';
3125 hdr
.ar_fmag
[1] = '\012';
3127 /* Turn all null bytes in the header into spaces. */
3128 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3129 if (((char *) (&hdr
))[i
] == '\0')
3130 (((char *) (&hdr
))[i
]) = ' ';
3132 if (bfd_bwrite ((void *) &hdr
, (bfd_size_type
) sizeof (struct ar_hdr
), abfd
)
3133 != sizeof (struct ar_hdr
))
3136 H_PUT_32 (abfd
, hashsize
, temp
);
3137 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3140 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3144 current
= abfd
->archive_head
;
3146 for (i
= 0; i
< orl_count
; i
++)
3148 unsigned int hash
, rehash
= 0;
3150 /* Advance firstreal to the file position of this archive
3152 if (map
[i
].u
.abfd
!= last_elt
)
3156 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3157 firstreal
+= firstreal
% 2;
3158 current
= current
->archive_next
;
3160 while (current
!= map
[i
].u
.abfd
);
3165 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3166 if (H_GET_32 (abfd
, (hashtable
+ (hash
* 8) + 4)) != 0)
3170 /* The desired slot is already taken. */
3171 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3173 srch
= (srch
+ rehash
) & (hashsize
- 1))
3174 if (H_GET_32 (abfd
, (hashtable
+ (srch
* 8) + 4)) == 0)
3177 BFD_ASSERT (srch
!= hash
);
3182 H_PUT_32 (abfd
, map
[i
].namidx
, (hashtable
+ hash
* 8));
3183 H_PUT_32 (abfd
, firstreal
, (hashtable
+ hash
* 8 + 4));
3186 if (bfd_bwrite ((void *) hashtable
, symdefsize
, abfd
) != symdefsize
)
3189 bfd_release (abfd
, hashtable
);
3191 /* Now write the strings. */
3192 H_PUT_32 (abfd
, stringsize
, temp
);
3193 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3195 for (i
= 0; i
< orl_count
; i
++)
3199 len
= strlen (*map
[i
].name
) + 1;
3200 if (bfd_bwrite ((void *) (*map
[i
].name
), len
, abfd
) != len
)
3204 /* The spec sez this should be a newline. But in order to be
3205 bug-compatible for DECstation ar we use a null. */
3208 if (bfd_bwrite ("", (bfd_size_type
) 1, abfd
) != 1)
3215 /* ECOFF linker code. */
3217 /* Routine to create an entry in an ECOFF link hash table. */
3219 static struct bfd_hash_entry
*
3220 ecoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
3221 struct bfd_hash_table
*table
,
3224 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3226 /* Allocate the structure if it has not already been allocated by a
3229 ret
= ((struct ecoff_link_hash_entry
*)
3230 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3234 /* Call the allocation method of the superclass. */
3235 ret
= ((struct ecoff_link_hash_entry
*)
3236 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3241 /* Set local fields. */
3247 memset ((void *) &ret
->esym
, 0, sizeof ret
->esym
);
3249 return (struct bfd_hash_entry
*) ret
;
3252 /* Create an ECOFF link hash table. */
3254 struct bfd_link_hash_table
*
3255 _bfd_ecoff_bfd_link_hash_table_create (bfd
*abfd
)
3257 struct ecoff_link_hash_table
*ret
;
3258 size_t amt
= sizeof (struct ecoff_link_hash_table
);
3260 ret
= (struct ecoff_link_hash_table
*) bfd_malloc (amt
);
3263 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
,
3264 ecoff_link_hash_newfunc
,
3265 sizeof (struct ecoff_link_hash_entry
)))
3273 /* Look up an entry in an ECOFF link hash table. */
3275 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3276 ((struct ecoff_link_hash_entry *) \
3277 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3279 /* Get the ECOFF link hash table from the info structure. This is
3282 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3284 /* Add the external symbols of an object file to the global linker
3285 hash table. The external symbols and strings we are passed are
3286 just allocated on the stack, and will be discarded. We must
3287 explicitly save any information we may need later on in the link.
3288 We do not want to read the external symbol information again. */
3291 ecoff_link_add_externals (bfd
*abfd
,
3292 struct bfd_link_info
*info
,
3293 void * external_ext
,
3296 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3297 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3298 = backend
->debug_swap
.swap_ext_in
;
3299 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3300 unsigned long ext_count
;
3301 struct bfd_link_hash_entry
**sym_hash
;
3306 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3309 amt
*= sizeof (struct bfd_link_hash_entry
*);
3310 sym_hash
= (struct bfd_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3313 ecoff_data (abfd
)->sym_hashes
= (struct ecoff_link_hash_entry
**) sym_hash
;
3315 ext_ptr
= (char *) external_ext
;
3316 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3317 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3324 struct ecoff_link_hash_entry
*h
;
3328 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3330 /* Skip debugging symbols. */
3332 switch (esym
.asym
.st
)
3348 /* Get the information for this symbol. */
3349 value
= esym
.asym
.value
;
3350 switch (esym
.asym
.sc
)
3370 section
= bfd_make_section_old_way (abfd
, _TEXT
);
3371 value
-= section
->vma
;
3374 section
= bfd_make_section_old_way (abfd
, _DATA
);
3375 value
-= section
->vma
;
3378 section
= bfd_make_section_old_way (abfd
, _BSS
);
3379 value
-= section
->vma
;
3382 section
= bfd_abs_section_ptr
;
3385 section
= bfd_und_section_ptr
;
3388 section
= bfd_make_section_old_way (abfd
, _SDATA
);
3389 value
-= section
->vma
;
3392 section
= bfd_make_section_old_way (abfd
, _SBSS
);
3393 value
-= section
->vma
;
3396 section
= bfd_make_section_old_way (abfd
, _RDATA
);
3397 value
-= section
->vma
;
3400 if (value
> ecoff_data (abfd
)->gp_size
)
3402 section
= bfd_com_section_ptr
;
3407 if (ecoff_scom_section
.name
== NULL
)
3409 /* Initialize the small common section. */
3410 ecoff_scom_section
.name
= SCOMMON
;
3411 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
3412 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
3413 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
3414 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
3415 ecoff_scom_symbol
.name
= SCOMMON
;
3416 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
3417 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
3418 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
3420 section
= &ecoff_scom_section
;
3423 section
= bfd_und_section_ptr
;
3426 section
= bfd_make_section_old_way (abfd
, _INIT
);
3427 value
-= section
->vma
;
3430 section
= bfd_make_section_old_way (abfd
, _FINI
);
3431 value
-= section
->vma
;
3434 section
= bfd_make_section_old_way (abfd
, _RCONST
);
3435 value
-= section
->vma
;
3439 if (section
== NULL
)
3442 name
= ssext
+ esym
.asym
.iss
;
3444 if (! (_bfd_generic_link_add_one_symbol
3446 (flagword
) (esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
),
3447 section
, value
, NULL
, TRUE
, TRUE
, sym_hash
)))
3450 h
= (struct ecoff_link_hash_entry
*) *sym_hash
;
3452 /* If we are building an ECOFF hash table, save the external
3453 symbol information. */
3454 if (bfd_get_flavour (info
->output_bfd
) == bfd_get_flavour (abfd
))
3457 || (! bfd_is_und_section (section
)
3458 && (! bfd_is_com_section (section
)
3459 || (h
->root
.type
!= bfd_link_hash_defined
3460 && h
->root
.type
!= bfd_link_hash_defweak
))))
3466 /* Remember whether this symbol was small undefined. */
3467 if (esym
.asym
.sc
== scSUndefined
)
3470 /* If this symbol was ever small undefined, it needs to wind
3471 up in a GP relative section. We can't control the
3472 section of a defined symbol, but we can control the
3473 section of a common symbol. This case is actually needed
3474 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3476 && h
->root
.type
== bfd_link_hash_common
3477 && streq (h
->root
.u
.c
.p
->section
->name
, SCOMMON
))
3479 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
3481 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
3482 if (h
->esym
.asym
.sc
== scCommon
)
3483 h
->esym
.asym
.sc
= scSCommon
;
3491 /* Add symbols from an ECOFF object file to the global linker hash
3495 ecoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3498 bfd_size_type external_ext_size
;
3499 void * external_ext
= NULL
;
3500 bfd_size_type esize
;
3504 if (! ecoff_slurp_symbolic_header (abfd
))
3507 /* If there are no symbols, we don't want it. */
3508 if (bfd_get_symcount (abfd
) == 0)
3511 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3513 /* Read in the external symbols and external strings. */
3514 if (bfd_seek (abfd
, symhdr
->cbExtOffset
, SEEK_SET
) != 0)
3516 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3517 esize
= symhdr
->iextMax
* external_ext_size
;
3518 external_ext
= _bfd_malloc_and_read (abfd
, esize
, esize
);
3519 if (external_ext
== NULL
&& esize
!= 0)
3522 if (bfd_seek (abfd
, symhdr
->cbSsExtOffset
, SEEK_SET
) != 0)
3524 ssext
= (char *) _bfd_malloc_and_read (abfd
, symhdr
->issExtMax
,
3526 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3529 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3533 if (external_ext
!= NULL
)
3534 free (external_ext
);
3540 if (external_ext
!= NULL
)
3541 free (external_ext
);
3545 /* This is called if we used _bfd_generic_link_add_archive_symbols
3546 because we were not dealing with an ECOFF archive. */
3549 ecoff_link_check_archive_element (bfd
*abfd
,
3550 struct bfd_link_info
*info
,
3551 struct bfd_link_hash_entry
*h
,
3553 bfd_boolean
*pneeded
)
3557 /* Unlike the generic linker, we do not pull in elements because
3558 of common symbols. */
3559 if (h
->type
!= bfd_link_hash_undefined
)
3562 /* Include this element? */
3563 if (!(*info
->callbacks
->add_archive_element
) (info
, abfd
, name
, &abfd
))
3567 return ecoff_link_add_object_symbols (abfd
, info
);
3570 /* Add the symbols from an archive file to the global hash table.
3571 This looks through the undefined symbols, looks each one up in the
3572 archive hash table, and adds any associated object file. We do not
3573 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3574 already have a hash table, so there is no reason to construct
3578 ecoff_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3580 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3581 const bfd_byte
*raw_armap
;
3582 struct bfd_link_hash_entry
**pundef
;
3583 unsigned int armap_count
;
3584 unsigned int armap_log
;
3586 const bfd_byte
*hashtable
;
3587 const char *stringbase
;
3589 if (! bfd_has_map (abfd
))
3591 /* An empty archive is a special case. */
3592 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
3594 bfd_set_error (bfd_error_no_armap
);
3598 /* If we don't have any raw data for this archive, as can happen on
3599 Irix 4.0.5F, we call the generic routine.
3600 FIXME: We should be more clever about this, since someday tdata
3601 may get to something for a generic archive. */
3602 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3603 if (raw_armap
== NULL
)
3604 return (_bfd_generic_link_add_archive_symbols
3605 (abfd
, info
, ecoff_link_check_archive_element
));
3607 armap_count
= H_GET_32 (abfd
, raw_armap
);
3610 for (i
= 1; i
< armap_count
; i
<<= 1)
3612 BFD_ASSERT (i
== armap_count
);
3614 hashtable
= raw_armap
+ 4;
3615 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3617 /* Look through the list of undefined symbols. */
3618 pundef
= &info
->hash
->undefs
;
3619 while (*pundef
!= NULL
)
3621 struct bfd_link_hash_entry
*h
;
3622 unsigned int hash
, rehash
= 0;
3623 unsigned int file_offset
;
3629 /* When a symbol is defined, it is not necessarily removed from
3631 if (h
->type
!= bfd_link_hash_undefined
3632 && h
->type
!= bfd_link_hash_common
)
3634 /* Remove this entry from the list, for general cleanliness
3635 and because we are going to look through the list again
3636 if we search any more libraries. We can't remove the
3637 entry if it is the tail, because that would lose any
3638 entries we add to the list later on. */
3639 if (*pundef
!= info
->hash
->undefs_tail
)
3640 *pundef
= (*pundef
)->u
.undef
.next
;
3642 pundef
= &(*pundef
)->u
.undef
.next
;
3646 /* Native ECOFF linkers do not pull in archive elements merely
3647 to satisfy common definitions, so neither do we. We leave
3648 them on the list, though, in case we are linking against some
3649 other object format. */
3650 if (h
->type
!= bfd_link_hash_undefined
)
3652 pundef
= &(*pundef
)->u
.undef
.next
;
3656 /* Look for this symbol in the archive hash table. */
3657 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3660 file_offset
= H_GET_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3661 if (file_offset
== 0)
3663 /* Nothing in this slot. */
3664 pundef
= &(*pundef
)->u
.undef
.next
;
3668 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (hash
* 8));
3669 if (name
[0] != h
->root
.string
[0]
3670 || ! streq (name
, h
->root
.string
))
3675 /* That was the wrong symbol. Try rehashing. */
3677 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3679 srch
= (srch
+ rehash
) & (armap_count
- 1))
3681 file_offset
= H_GET_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3682 if (file_offset
== 0)
3684 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (srch
* 8));
3685 if (name
[0] == h
->root
.string
[0]
3686 && streq (name
, h
->root
.string
))
3695 pundef
= &(*pundef
)->u
.undef
.next
;
3702 element
= (*backend
->get_elt_at_filepos
) (abfd
, (file_ptr
) file_offset
);
3703 if (element
== NULL
)
3706 if (! bfd_check_format (element
, bfd_object
))
3709 /* Unlike the generic linker, we know that this element provides
3710 a definition for an undefined symbol and we know that we want
3711 to include it. We don't need to check anything. */
3712 if (!(*info
->callbacks
3713 ->add_archive_element
) (info
, element
, name
, &element
))
3715 if (! ecoff_link_add_object_symbols (element
, info
))
3718 pundef
= &(*pundef
)->u
.undef
.next
;
3724 /* Given an ECOFF BFD, add symbols to the global hash table as
3728 _bfd_ecoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3730 switch (bfd_get_format (abfd
))
3733 return ecoff_link_add_object_symbols (abfd
, info
);
3735 return ecoff_link_add_archive_symbols (abfd
, info
);
3737 bfd_set_error (bfd_error_wrong_format
);
3743 /* ECOFF final link routines. */
3745 /* Structure used to pass information to ecoff_link_write_external. */
3750 struct bfd_link_info
*info
;
3753 /* Accumulate the debugging information for an input BFD into the
3754 output BFD. This must read in the symbolic information of the
3758 ecoff_final_link_debug_accumulate (bfd
*output_bfd
,
3760 struct bfd_link_info
*info
,
3763 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
3764 const struct ecoff_debug_swap
* const swap
=
3765 &ecoff_backend (input_bfd
)->debug_swap
;
3766 HDRR
*symhdr
= &debug
->symbolic_header
;
3769 #define READ(ptr, offset, count, size, type) \
3773 debug->ptr = NULL; \
3774 if (symhdr->count == 0) \
3776 if (_bfd_mul_overflow (size, symhdr->count, &amt)) \
3778 bfd_set_error (bfd_error_file_too_big); \
3780 goto return_something; \
3782 if (bfd_seek (input_bfd, symhdr->offset, SEEK_SET) != 0) \
3785 goto return_something; \
3787 debug->ptr = (type) _bfd_malloc_and_read (input_bfd, amt, amt); \
3788 if (debug->ptr == NULL) \
3791 goto return_something; \
3795 /* If raw_syments is not NULL, then the data was already by read by
3796 _bfd_ecoff_slurp_symbolic_info. */
3797 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3799 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
3801 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
3802 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
3803 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
3804 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
3805 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3807 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3808 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
3809 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
3813 /* We do not read the external strings or the external symbols. */
3815 ret
= (bfd_ecoff_debug_accumulate
3816 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
3817 &ecoff_backend (output_bfd
)->debug_swap
,
3818 input_bfd
, debug
, swap
, info
));
3821 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3823 if (debug
->line
!= NULL
)
3825 if (debug
->external_dnr
!= NULL
)
3826 free (debug
->external_dnr
);
3827 if (debug
->external_pdr
!= NULL
)
3828 free (debug
->external_pdr
);
3829 if (debug
->external_sym
!= NULL
)
3830 free (debug
->external_sym
);
3831 if (debug
->external_opt
!= NULL
)
3832 free (debug
->external_opt
);
3833 if (debug
->external_aux
!= NULL
)
3834 free (debug
->external_aux
);
3835 if (debug
->ss
!= NULL
)
3837 if (debug
->external_fdr
!= NULL
)
3838 free (debug
->external_fdr
);
3839 if (debug
->external_rfd
!= NULL
)
3840 free (debug
->external_rfd
);
3842 /* Make sure we don't accidentally follow one of these pointers
3843 into freed memory. */
3845 debug
->external_dnr
= NULL
;
3846 debug
->external_pdr
= NULL
;
3847 debug
->external_sym
= NULL
;
3848 debug
->external_opt
= NULL
;
3849 debug
->external_aux
= NULL
;
3851 debug
->external_fdr
= NULL
;
3852 debug
->external_rfd
= NULL
;
3858 /* Relocate and write an ECOFF section into an ECOFF output file. */
3861 ecoff_indirect_link_order (bfd
*output_bfd
,
3862 struct bfd_link_info
*info
,
3863 asection
*output_section
,
3864 struct bfd_link_order
*link_order
)
3866 asection
*input_section
;
3868 bfd_byte
*contents
= NULL
;
3869 bfd_size_type external_reloc_size
;
3870 bfd_size_type external_relocs_size
;
3871 void * external_relocs
= NULL
;
3873 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
3875 input_section
= link_order
->u
.indirect
.section
;
3876 input_bfd
= input_section
->owner
;
3877 if (input_section
->size
== 0)
3880 BFD_ASSERT (input_section
->output_section
== output_section
);
3881 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
3882 BFD_ASSERT (input_section
->size
== link_order
->size
);
3884 /* Get the section contents. */
3885 if (!bfd_malloc_and_get_section (input_bfd
, input_section
, &contents
))
3888 /* Get the relocs. If we are relaxing MIPS code, they will already
3889 have been read in. Otherwise, we read them in now. */
3890 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
3891 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
3893 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0)
3895 external_relocs
= _bfd_malloc_and_read (input_bfd
, external_relocs_size
,
3896 external_relocs_size
);
3897 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
3900 /* Relocate the section contents. */
3901 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
3902 (output_bfd
, info
, input_bfd
, input_section
, contents
,
3906 /* Write out the relocated section. */
3907 if (! bfd_set_section_contents (output_bfd
,
3910 input_section
->output_offset
,
3911 input_section
->size
))
3914 /* If we are producing relocatable output, the relocs were
3915 modified, and we write them out now. We use the reloc_count
3916 field of output_section to keep track of the number of relocs we
3917 have output so far. */
3918 if (bfd_link_relocatable (info
))
3920 file_ptr pos
= (output_section
->rel_filepos
3921 + output_section
->reloc_count
* external_reloc_size
);
3922 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
3923 || (bfd_bwrite (external_relocs
, external_relocs_size
, output_bfd
)
3924 != external_relocs_size
))
3926 output_section
->reloc_count
+= input_section
->reloc_count
;
3929 if (contents
!= NULL
)
3931 if (external_relocs
!= NULL
)
3932 free (external_relocs
);
3936 if (contents
!= NULL
)
3938 if (external_relocs
!= NULL
)
3939 free (external_relocs
);
3943 /* Generate a reloc when linking an ECOFF file. This is a reloc
3944 requested by the linker, and does come from any input file. This
3945 is used to build constructor and destructor tables when linking
3949 ecoff_reloc_link_order (bfd
*output_bfd
,
3950 struct bfd_link_info
*info
,
3951 asection
*output_section
,
3952 struct bfd_link_order
*link_order
)
3954 enum bfd_link_order_type type
;
3958 struct internal_reloc in
;
3959 bfd_size_type external_reloc_size
;
3964 type
= link_order
->type
;
3966 addend
= link_order
->u
.reloc
.p
->addend
;
3968 /* We set up an arelent to pass to the backend adjust_reloc_out
3970 rel
.address
= link_order
->offset
;
3972 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3975 bfd_set_error (bfd_error_bad_value
);
3979 if (type
== bfd_section_reloc_link_order
)
3981 section
= link_order
->u
.reloc
.p
->u
.section
;
3982 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
3986 struct bfd_link_hash_entry
*h
;
3988 /* Treat a reloc against a defined symbol as though it were
3989 actually against the section. */
3990 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3991 link_order
->u
.reloc
.p
->u
.name
,
3992 FALSE
, FALSE
, FALSE
);
3994 && (h
->type
== bfd_link_hash_defined
3995 || h
->type
== bfd_link_hash_defweak
))
3997 type
= bfd_section_reloc_link_order
;
3998 section
= h
->u
.def
.section
->output_section
;
3999 /* It seems that we ought to add the symbol value to the
4000 addend here, but in practice it has already been added
4001 because it was passed to constructor_callback. */
4002 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
4006 /* We can't set up a reloc against a symbol correctly,
4007 because we have no asymbol structure. Currently no
4008 adjust_reloc_out routine cares. */
4009 rel
.sym_ptr_ptr
= NULL
;
4013 /* All ECOFF relocs are in-place. Put the addend into the object
4016 BFD_ASSERT (rel
.howto
->partial_inplace
);
4020 bfd_reloc_status_type rstat
;
4023 size
= bfd_get_reloc_size (rel
.howto
);
4024 buf
= (bfd_byte
*) bfd_zmalloc (size
);
4025 if (buf
== NULL
&& size
!= 0)
4027 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
4028 (bfd_vma
) addend
, buf
);
4034 case bfd_reloc_outofrange
:
4036 case bfd_reloc_overflow
:
4037 (*info
->callbacks
->reloc_overflow
)
4039 (link_order
->type
== bfd_section_reloc_link_order
4040 ? bfd_section_name (section
)
4041 : link_order
->u
.reloc
.p
->u
.name
),
4042 rel
.howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0);
4045 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
4046 (file_ptr
) link_order
->offset
, size
);
4054 /* Move the information into an internal_reloc structure. */
4055 in
.r_vaddr
= rel
.address
+ bfd_section_vma (output_section
);
4056 in
.r_type
= rel
.howto
->type
;
4058 if (type
== bfd_symbol_reloc_link_order
)
4060 struct ecoff_link_hash_entry
*h
;
4062 h
= ((struct ecoff_link_hash_entry
*)
4063 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4064 link_order
->u
.reloc
.p
->u
.name
,
4065 FALSE
, FALSE
, TRUE
));
4068 in
.r_symndx
= h
->indx
;
4071 (*info
->callbacks
->unattached_reloc
)
4072 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
4088 { _TEXT
, RELOC_SECTION_TEXT
},
4089 { _RDATA
, RELOC_SECTION_RDATA
},
4090 { _DATA
, RELOC_SECTION_DATA
},
4091 { _SDATA
, RELOC_SECTION_SDATA
},
4092 { _SBSS
, RELOC_SECTION_SBSS
},
4093 { _BSS
, RELOC_SECTION_BSS
},
4094 { _INIT
, RELOC_SECTION_INIT
},
4095 { _LIT8
, RELOC_SECTION_LIT8
},
4096 { _LIT4
, RELOC_SECTION_LIT4
},
4097 { _XDATA
, RELOC_SECTION_XDATA
},
4098 { _PDATA
, RELOC_SECTION_PDATA
},
4099 { _FINI
, RELOC_SECTION_FINI
},
4100 { _LITA
, RELOC_SECTION_LITA
},
4101 { "*ABS*", RELOC_SECTION_ABS
},
4102 { _RCONST
, RELOC_SECTION_RCONST
}
4105 name
= bfd_section_name (section
);
4107 for (i
= 0; i
< ARRAY_SIZE (section_symndx
); i
++)
4108 if (streq (name
, section_symndx
[i
].name
))
4110 in
.r_symndx
= section_symndx
[i
].r_symndx
;
4114 if (i
== ARRAY_SIZE (section_symndx
))
4120 /* Let the BFD backend adjust the reloc. */
4121 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4123 /* Get some memory and swap out the reloc. */
4124 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4125 rbuf
= (bfd_byte
*) bfd_malloc (external_reloc_size
);
4129 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (void *) rbuf
);
4131 pos
= (output_section
->rel_filepos
4132 + output_section
->reloc_count
* external_reloc_size
);
4133 ok
= (bfd_seek (output_bfd
, pos
, SEEK_SET
) == 0
4134 && (bfd_bwrite ((void *) rbuf
, external_reloc_size
, output_bfd
)
4135 == external_reloc_size
));
4138 ++output_section
->reloc_count
;
4145 /* Put out information for an external symbol. These come only from
4149 ecoff_link_write_external (struct bfd_hash_entry
*bh
, void * data
)
4151 struct ecoff_link_hash_entry
*h
= (struct ecoff_link_hash_entry
*) bh
;
4152 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4153 bfd
*output_bfd
= einfo
->abfd
;
4156 if (h
->root
.type
== bfd_link_hash_warning
)
4158 h
= (struct ecoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4159 if (h
->root
.type
== bfd_link_hash_new
)
4163 /* We need to check if this symbol is being stripped. */
4164 if (h
->root
.type
== bfd_link_hash_undefined
4165 || h
->root
.type
== bfd_link_hash_undefweak
)
4167 else if (einfo
->info
->strip
== strip_all
4168 || (einfo
->info
->strip
== strip_some
4169 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4170 h
->root
.root
.string
,
4171 FALSE
, FALSE
) == NULL
))
4176 if (strip
|| h
->written
)
4179 if (h
->abfd
== NULL
)
4182 h
->esym
.cobol_main
= 0;
4183 h
->esym
.weakext
= 0;
4184 h
->esym
.reserved
= 0;
4185 h
->esym
.ifd
= ifdNil
;
4186 h
->esym
.asym
.value
= 0;
4187 h
->esym
.asym
.st
= stGlobal
;
4189 if (h
->root
.type
!= bfd_link_hash_defined
4190 && h
->root
.type
!= bfd_link_hash_defweak
)
4191 h
->esym
.asym
.sc
= scAbs
;
4194 asection
*output_section
;
4202 section_storage_classes
[] =
4206 { _SDATA
, scSData
},
4207 { _RDATA
, scRData
},
4212 { _PDATA
, scPData
},
4213 { _XDATA
, scXData
},
4214 { _RCONST
, scRConst
}
4217 output_section
= h
->root
.u
.def
.section
->output_section
;
4218 name
= bfd_section_name (output_section
);
4220 for (i
= 0; i
< ARRAY_SIZE (section_storage_classes
); i
++)
4221 if (streq (name
, section_storage_classes
[i
].name
))
4223 h
->esym
.asym
.sc
= section_storage_classes
[i
].sc
;
4227 if (i
== ARRAY_SIZE (section_storage_classes
))
4228 h
->esym
.asym
.sc
= scAbs
;
4231 h
->esym
.asym
.reserved
= 0;
4232 h
->esym
.asym
.index
= indexNil
;
4234 else if (h
->esym
.ifd
!= -1)
4236 struct ecoff_debug_info
*debug
;
4238 /* Adjust the FDR index for the symbol by that used for the
4240 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4241 BFD_ASSERT (h
->esym
.ifd
>= 0
4242 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4243 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4246 switch (h
->root
.type
)
4249 case bfd_link_hash_warning
:
4250 case bfd_link_hash_new
:
4252 case bfd_link_hash_undefined
:
4253 case bfd_link_hash_undefweak
:
4254 if (h
->esym
.asym
.sc
!= scUndefined
4255 && h
->esym
.asym
.sc
!= scSUndefined
)
4256 h
->esym
.asym
.sc
= scUndefined
;
4258 case bfd_link_hash_defined
:
4259 case bfd_link_hash_defweak
:
4260 if (h
->esym
.asym
.sc
== scUndefined
4261 || h
->esym
.asym
.sc
== scSUndefined
)
4262 h
->esym
.asym
.sc
= scAbs
;
4263 else if (h
->esym
.asym
.sc
== scCommon
)
4264 h
->esym
.asym
.sc
= scBss
;
4265 else if (h
->esym
.asym
.sc
== scSCommon
)
4266 h
->esym
.asym
.sc
= scSBss
;
4267 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4268 + h
->root
.u
.def
.section
->output_section
->vma
4269 + h
->root
.u
.def
.section
->output_offset
);
4271 case bfd_link_hash_common
:
4272 if (h
->esym
.asym
.sc
!= scCommon
4273 && h
->esym
.asym
.sc
!= scSCommon
)
4274 h
->esym
.asym
.sc
= scCommon
;
4275 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4277 case bfd_link_hash_indirect
:
4278 /* We ignore these symbols, since the indirected symbol is
4279 already in the hash table. */
4283 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4285 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4288 return (bfd_ecoff_debug_one_external
4289 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4290 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4294 /* ECOFF final link routine. This looks through all the input BFDs
4295 and gathers together all the debugging information, and then
4296 processes all the link order information. This may cause it to
4297 close and reopen some input BFDs; I'll see how bad this is. */
4300 _bfd_ecoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
4302 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4303 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4308 struct bfd_link_order
*p
;
4309 struct extsym_info einfo
;
4311 /* We accumulate the debugging information counts in the symbolic
4313 symhdr
= &debug
->symbolic_header
;
4315 symhdr
->ilineMax
= 0;
4319 symhdr
->isymMax
= 0;
4320 symhdr
->ioptMax
= 0;
4321 symhdr
->iauxMax
= 0;
4323 symhdr
->issExtMax
= 0;
4326 symhdr
->iextMax
= 0;
4328 /* We accumulate the debugging information itself in the debug_info
4331 debug
->external_dnr
= NULL
;
4332 debug
->external_pdr
= NULL
;
4333 debug
->external_sym
= NULL
;
4334 debug
->external_opt
= NULL
;
4335 debug
->external_aux
= NULL
;
4337 debug
->ssext
= debug
->ssext_end
= NULL
;
4338 debug
->external_fdr
= NULL
;
4339 debug
->external_rfd
= NULL
;
4340 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4342 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4346 /* Accumulate the debugging symbols from each input BFD. */
4347 for (input_bfd
= info
->input_bfds
;
4349 input_bfd
= input_bfd
->link
.next
)
4353 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4355 /* Arbitrarily set the symbolic header vstamp to the vstamp
4356 of the first object file in the link. */
4357 if (symhdr
->vstamp
== 0)
4359 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4360 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4364 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4365 debug
, &backend
->debug_swap
,
4370 /* Combine the register masks. */
4371 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4372 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4373 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4374 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4375 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4376 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4379 /* Write out the external symbols. */
4382 bfd_hash_traverse (&info
->hash
->table
, ecoff_link_write_external
, &einfo
);
4384 if (bfd_link_relocatable (info
))
4386 /* We need to make a pass over the link_orders to count up the
4387 number of relocations we will need to output, so that we know
4388 how much space they will take up. */
4389 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4392 for (p
= o
->map_head
.link_order
;
4395 if (p
->type
== bfd_indirect_link_order
)
4396 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4397 else if (p
->type
== bfd_section_reloc_link_order
4398 || p
->type
== bfd_symbol_reloc_link_order
)
4403 /* Compute the reloc and symbol file positions. */
4404 ecoff_compute_reloc_file_positions (abfd
);
4406 /* Write out the debugging information. */
4407 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4408 &backend
->debug_swap
, info
,
4409 ecoff_data (abfd
)->sym_filepos
))
4412 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4414 if (bfd_link_relocatable (info
))
4416 /* Now reset the reloc_count field of the sections in the output
4417 BFD to 0, so that we can use them to keep track of how many
4418 relocs we have output thus far. */
4419 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4423 /* Get a value for the GP register. */
4424 if (ecoff_data (abfd
)->gp
== 0)
4426 struct bfd_link_hash_entry
*h
;
4428 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
4430 && h
->type
== bfd_link_hash_defined
)
4431 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4432 + h
->u
.def
.section
->output_section
->vma
4433 + h
->u
.def
.section
->output_offset
);
4434 else if (bfd_link_relocatable (info
))
4438 /* Make up a value. */
4440 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4443 && (streq (o
->name
, _SBSS
)
4444 || streq (o
->name
, _SDATA
)
4445 || streq (o
->name
, _LIT4
)
4446 || streq (o
->name
, _LIT8
)
4447 || streq (o
->name
, _LITA
)))
4450 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4454 /* If the relocate_section function needs to do a reloc
4455 involving the GP value, it should make a reloc_dangerous
4456 callback to warn that GP is not defined. */
4460 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4462 for (p
= o
->map_head
.link_order
;
4466 if (p
->type
== bfd_indirect_link_order
4467 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4468 == bfd_target_ecoff_flavour
))
4470 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4473 else if (p
->type
== bfd_section_reloc_link_order
4474 || p
->type
== bfd_symbol_reloc_link_order
)
4476 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4481 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4487 abfd
->symcount
= symhdr
->iextMax
+ symhdr
->isymMax
;
4489 ecoff_data (abfd
)->linker
= TRUE
;