1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright (C) 1990-2020 Free Software Foundation, Inc.
3 Original version by Per Bothner.
4 Full support added by Ian Lance Taylor, ian@cygnus.com.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "ecoff-bfd.h"
29 #include "aout/stab_gnu.h"
31 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
32 some other stuff which we don't want and which conflicts with stuff
35 #include "aout/aout64.h"
38 #undef obj_sym_filepos
40 #include "coff/internal.h"
42 #include "coff/symconst.h"
43 #include "coff/ecoff.h"
46 #include "libiberty.h"
48 #define streq(a, b) (strcmp ((a), (b)) == 0)
49 #define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0)
52 /* This stuff is somewhat copied from coffcode.h. */
53 static asection bfd_debug_section
=
55 /* name, id, section_id, index, next, prev, flags, */
56 "*DEBUG*", 0, 0, 0, NULL
, NULL
, 0,
59 /* linker_mark, linker_has_input, gc_mark, compress_status, */
61 /* segment_mark, sec_info_type, use_rela_p, */
63 /* sec_flg0, sec_flg1, sec_flg2, sec_flg3, sec_flg4, sec_flg5, */
65 /* vma, lma, size, rawsize, compressed_size, relax, relax_count, */
67 /* output_offset, output_section, alignment_power, */
69 /* relocation, orelocation, reloc_count, filepos, rel_filepos, */
71 /* line_filepos, userdata, contents, lineno, lineno_count, */
72 0, NULL
, NULL
, NULL
, 0,
73 /* entsize, kept_section, moving_line_filepos, */
75 /* target_index, used_by_bfd, constructor_chain, owner, */
81 /* map_head, map_tail */
85 /* Create an ECOFF object. */
88 _bfd_ecoff_mkobject (bfd
*abfd
)
90 size_t amt
= sizeof (ecoff_data_type
);
92 abfd
->tdata
.ecoff_obj_data
= (struct ecoff_tdata
*) bfd_zalloc (abfd
, amt
);
93 if (abfd
->tdata
.ecoff_obj_data
== NULL
)
99 /* This is a hook called by coff_real_object_p to create any backend
100 specific information. */
103 _bfd_ecoff_mkobject_hook (bfd
*abfd
, void * filehdr
, void * aouthdr
)
105 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
106 struct internal_aouthdr
*internal_a
= (struct internal_aouthdr
*) aouthdr
;
107 ecoff_data_type
*ecoff
;
109 if (! _bfd_ecoff_mkobject (abfd
))
112 ecoff
= ecoff_data (abfd
);
114 ecoff
->sym_filepos
= internal_f
->f_symptr
;
116 if (internal_a
!= NULL
)
120 ecoff
->text_start
= internal_a
->text_start
;
121 ecoff
->text_end
= internal_a
->text_start
+ internal_a
->tsize
;
122 ecoff
->gp
= internal_a
->gp_value
;
123 ecoff
->gprmask
= internal_a
->gprmask
;
124 for (i
= 0; i
< 4; i
++)
125 ecoff
->cprmask
[i
] = internal_a
->cprmask
[i
];
126 ecoff
->fprmask
= internal_a
->fprmask
;
127 if (internal_a
->magic
== ECOFF_AOUT_ZMAGIC
)
128 abfd
->flags
|= D_PAGED
;
130 abfd
->flags
&=~ D_PAGED
;
133 /* It turns out that no special action is required by the MIPS or
134 Alpha ECOFF backends. They have different information in the
135 a.out header, but we just copy it all (e.g., gprmask, cprmask and
136 fprmask) and let the swapping routines ensure that only relevant
137 information is written out. */
139 return (void *) ecoff
;
142 /* Initialize a new section. */
145 _bfd_ecoff_new_section_hook (bfd
*abfd
, asection
*section
)
155 { _TEXT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
156 { _INIT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
157 { _FINI
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
158 { _DATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
},
159 { _SDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_SMALL_DATA
},
160 { _RDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
161 { _LIT8
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
| SEC_SMALL_DATA
},
162 { _LIT4
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
| SEC_SMALL_DATA
},
163 { _RCONST
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
164 { _PDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
166 { _SBSS
, SEC_ALLOC
| SEC_SMALL_DATA
},
167 /* An Irix 4 shared libary. */
168 { _LIB
, SEC_COFF_SHARED_LIBRARY
}
171 section
->alignment_power
= 4;
173 for (i
= 0; i
< ARRAY_SIZE (section_flags
); i
++)
174 if (streq (section
->name
, section_flags
[i
].name
))
176 section
->flags
|= section_flags
[i
].flags
;
181 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
182 uncertain about .init on some systems and I don't know how shared
185 return _bfd_generic_new_section_hook (abfd
, section
);
189 _bfd_ecoff_set_alignment_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
190 asection
*section ATTRIBUTE_UNUSED
,
191 void *scnhdr ATTRIBUTE_UNUSED
)
195 /* Determine the machine architecture and type. This is called from
196 the generic COFF routines. It is the inverse of ecoff_get_magic,
197 below. This could be an ECOFF backend routine, with one version
198 for each target, but there aren't all that many ECOFF targets. */
201 _bfd_ecoff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
203 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
204 enum bfd_architecture arch
;
207 switch (internal_f
->f_magic
)
210 case MIPS_MAGIC_LITTLE
:
212 arch
= bfd_arch_mips
;
213 mach
= bfd_mach_mips3000
;
216 case MIPS_MAGIC_LITTLE2
:
217 case MIPS_MAGIC_BIG2
:
218 /* MIPS ISA level 2: the r6000. */
219 arch
= bfd_arch_mips
;
220 mach
= bfd_mach_mips6000
;
223 case MIPS_MAGIC_LITTLE3
:
224 case MIPS_MAGIC_BIG3
:
225 /* MIPS ISA level 3: the r4000. */
226 arch
= bfd_arch_mips
;
227 mach
= bfd_mach_mips4000
;
231 arch
= bfd_arch_alpha
;
236 arch
= bfd_arch_obscure
;
241 return bfd_default_set_arch_mach (abfd
, arch
, mach
);
245 _bfd_ecoff_no_long_sections (bfd
*abfd
, int enable
)
252 /* Get the magic number to use based on the architecture and machine.
253 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
256 ecoff_get_magic (bfd
*abfd
)
260 switch (bfd_get_arch (abfd
))
263 switch (bfd_get_mach (abfd
))
267 case bfd_mach_mips3000
:
268 big
= MIPS_MAGIC_BIG
;
269 little
= MIPS_MAGIC_LITTLE
;
272 case bfd_mach_mips6000
:
273 big
= MIPS_MAGIC_BIG2
;
274 little
= MIPS_MAGIC_LITTLE2
;
277 case bfd_mach_mips4000
:
278 big
= MIPS_MAGIC_BIG3
;
279 little
= MIPS_MAGIC_LITTLE3
;
283 return bfd_big_endian (abfd
) ? big
: little
;
294 /* Get the section s_flags to use for a section. */
297 ecoff_sec_to_styp_flags (const char *name
, flagword flags
)
307 { _TEXT
, STYP_TEXT
},
308 { _DATA
, STYP_DATA
},
309 { _SDATA
, STYP_SDATA
},
310 { _RDATA
, STYP_RDATA
},
311 { _LITA
, STYP_LITA
},
312 { _LIT8
, STYP_LIT8
},
313 { _LIT4
, STYP_LIT4
},
315 { _SBSS
, STYP_SBSS
},
316 { _INIT
, STYP_ECOFF_INIT
},
317 { _FINI
, STYP_ECOFF_FINI
},
318 { _PDATA
, STYP_PDATA
},
319 { _XDATA
, STYP_XDATA
},
320 { _LIB
, STYP_ECOFF_LIB
},
322 { _HASH
, STYP_HASH
},
323 { _DYNAMIC
, STYP_DYNAMIC
},
324 { _LIBLIST
, STYP_LIBLIST
},
325 { _RELDYN
, STYP_RELDYN
},
326 { _CONFLIC
, STYP_CONFLIC
},
327 { _DYNSTR
, STYP_DYNSTR
},
328 { _DYNSYM
, STYP_DYNSYM
},
329 { _RCONST
, STYP_RCONST
}
333 for (i
= 0; i
< ARRAY_SIZE (styp_flags
); i
++)
334 if (streq (name
, styp_flags
[i
].name
))
336 styp
= styp_flags
[i
].flags
;
342 if (streq (name
, _COMMENT
))
345 flags
&=~ SEC_NEVER_LOAD
;
347 else if (flags
& SEC_CODE
)
349 else if (flags
& SEC_DATA
)
351 else if (flags
& SEC_READONLY
)
353 else if (flags
& SEC_LOAD
)
359 if (flags
& SEC_NEVER_LOAD
)
365 /* Get the BFD flags to use for a section. */
368 _bfd_ecoff_styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
370 const char *name ATTRIBUTE_UNUSED
,
371 asection
*section ATTRIBUTE_UNUSED
,
372 flagword
* flags_ptr
)
374 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
375 long styp_flags
= internal_s
->s_flags
;
376 flagword sec_flags
= 0;
378 if (styp_flags
& STYP_NOLOAD
)
379 sec_flags
|= SEC_NEVER_LOAD
;
381 /* For 386 COFF, at least, an unloadable text or data section is
382 actually a shared library section. */
383 if ((styp_flags
& STYP_TEXT
)
384 || (styp_flags
& STYP_ECOFF_INIT
)
385 || (styp_flags
& STYP_ECOFF_FINI
)
386 || (styp_flags
& STYP_DYNAMIC
)
387 || (styp_flags
& STYP_LIBLIST
)
388 || (styp_flags
& STYP_RELDYN
)
389 || styp_flags
== STYP_CONFLIC
390 || (styp_flags
& STYP_DYNSTR
)
391 || (styp_flags
& STYP_DYNSYM
)
392 || (styp_flags
& STYP_HASH
))
394 if (sec_flags
& SEC_NEVER_LOAD
)
395 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
397 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
399 else if ((styp_flags
& STYP_DATA
)
400 || (styp_flags
& STYP_RDATA
)
401 || (styp_flags
& STYP_SDATA
)
402 || styp_flags
== STYP_PDATA
403 || styp_flags
== STYP_XDATA
404 || (styp_flags
& STYP_GOT
)
405 || styp_flags
== STYP_RCONST
)
407 if (sec_flags
& SEC_NEVER_LOAD
)
408 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
410 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
411 if ((styp_flags
& STYP_RDATA
)
412 || styp_flags
== STYP_PDATA
413 || styp_flags
== STYP_RCONST
)
414 sec_flags
|= SEC_READONLY
;
415 if (styp_flags
& STYP_SDATA
)
416 sec_flags
|= SEC_SMALL_DATA
;
418 else if (styp_flags
& STYP_SBSS
)
419 sec_flags
|= SEC_ALLOC
| SEC_SMALL_DATA
;
420 else if (styp_flags
& STYP_BSS
)
421 sec_flags
|= SEC_ALLOC
;
422 else if ((styp_flags
& STYP_INFO
) || styp_flags
== STYP_COMMENT
)
423 sec_flags
|= SEC_NEVER_LOAD
;
424 else if ((styp_flags
& STYP_LITA
)
425 || (styp_flags
& STYP_LIT8
)
426 || (styp_flags
& STYP_LIT4
))
427 sec_flags
|= SEC_DATA
|SEC_SMALL_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
428 else if (styp_flags
& STYP_ECOFF_LIB
)
429 sec_flags
|= SEC_COFF_SHARED_LIBRARY
;
431 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
433 * flags_ptr
= sec_flags
;
437 /* Read in the symbolic header for an ECOFF object file. */
440 ecoff_slurp_symbolic_header (bfd
*abfd
)
442 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
443 bfd_size_type external_hdr_size
;
445 HDRR
*internal_symhdr
;
447 /* See if we've already read it in. */
448 if (ecoff_data (abfd
)->debug_info
.symbolic_header
.magic
==
449 backend
->debug_swap
.sym_magic
)
452 /* See whether there is a symbolic header. */
453 if (ecoff_data (abfd
)->sym_filepos
== 0)
459 /* At this point bfd_get_symcount (abfd) holds the number of symbols
460 as read from the file header, but on ECOFF this is always the
461 size of the symbolic information header. It would be cleaner to
462 handle this when we first read the file in coffgen.c. */
463 external_hdr_size
= backend
->debug_swap
.external_hdr_size
;
464 if (bfd_get_symcount (abfd
) != external_hdr_size
)
466 bfd_set_error (bfd_error_bad_value
);
470 /* Read the symbolic information header. */
471 if (bfd_seek (abfd
, ecoff_data (abfd
)->sym_filepos
, SEEK_SET
) != 0)
473 raw
= _bfd_malloc_and_read (abfd
, external_hdr_size
, external_hdr_size
);
477 internal_symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
478 (*backend
->debug_swap
.swap_hdr_in
) (abfd
, raw
, internal_symhdr
);
480 if (internal_symhdr
->magic
!= backend
->debug_swap
.sym_magic
)
482 bfd_set_error (bfd_error_bad_value
);
486 /* Now we can get the correct number of symbols. */
487 abfd
->symcount
= internal_symhdr
->isymMax
+ internal_symhdr
->iextMax
;
498 /* Read in and swap the important symbolic information for an ECOFF
499 object file. This is called by gdb via the read_debug_info entry
500 point in the backend structure. */
503 _bfd_ecoff_slurp_symbolic_info (bfd
*abfd
,
504 asection
*ignore ATTRIBUTE_UNUSED
,
505 struct ecoff_debug_info
*debug
)
507 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
508 HDRR
*internal_symhdr
;
509 bfd_size_type raw_base
;
510 bfd_size_type raw_size
;
512 bfd_size_type external_fdr_size
;
516 bfd_size_type raw_end
;
517 bfd_size_type cb_end
;
521 BFD_ASSERT (debug
== &ecoff_data (abfd
)->debug_info
);
523 /* Check whether we've already gotten it, and whether there's any to
525 if (ecoff_data (abfd
)->raw_syments
!= NULL
)
527 if (ecoff_data (abfd
)->sym_filepos
== 0)
533 if (! ecoff_slurp_symbolic_header (abfd
))
536 internal_symhdr
= &debug
->symbolic_header
;
538 /* Read all the symbolic information at once. */
539 raw_base
= (ecoff_data (abfd
)->sym_filepos
540 + backend
->debug_swap
.external_hdr_size
);
542 /* Alpha ecoff makes the determination of raw_size difficult. It has
543 an undocumented debug data section between the symhdr and the first
544 documented section. And the ordering of the sections varies between
545 statically and dynamically linked executables.
546 If bfd supports SEEK_END someday, this code could be simplified. */
549 #define UPDATE_RAW_END(start, count, size) \
550 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
551 if (cb_end > raw_end) \
554 UPDATE_RAW_END (cbLineOffset
, cbLine
, sizeof (unsigned char));
555 UPDATE_RAW_END (cbDnOffset
, idnMax
, backend
->debug_swap
.external_dnr_size
);
556 UPDATE_RAW_END (cbPdOffset
, ipdMax
, backend
->debug_swap
.external_pdr_size
);
557 UPDATE_RAW_END (cbSymOffset
, isymMax
, backend
->debug_swap
.external_sym_size
);
558 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
559 optimization symtab, not the number of entries. */
560 UPDATE_RAW_END (cbOptOffset
, ioptMax
, sizeof (char));
561 UPDATE_RAW_END (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
562 UPDATE_RAW_END (cbSsOffset
, issMax
, sizeof (char));
563 UPDATE_RAW_END (cbSsExtOffset
, issExtMax
, sizeof (char));
564 UPDATE_RAW_END (cbFdOffset
, ifdMax
, backend
->debug_swap
.external_fdr_size
);
565 UPDATE_RAW_END (cbRfdOffset
, crfd
, backend
->debug_swap
.external_rfd_size
);
566 UPDATE_RAW_END (cbExtOffset
, iextMax
, backend
->debug_swap
.external_ext_size
);
568 #undef UPDATE_RAW_END
570 raw_size
= raw_end
- raw_base
;
573 ecoff_data (abfd
)->sym_filepos
= 0;
576 pos
= ecoff_data (abfd
)->sym_filepos
;
577 pos
+= backend
->debug_swap
.external_hdr_size
;
578 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
580 raw
= _bfd_alloc_and_read (abfd
, raw_size
, raw_size
);
584 ecoff_data (abfd
)->raw_syments
= raw
;
586 /* Get pointers for the numeric offsets in the HDRR structure. */
587 #define FIX(off1, off2, type) \
588 if (internal_symhdr->off1 == 0) \
589 debug->off2 = NULL; \
591 debug->off2 = (type) ((char *) raw \
592 + (internal_symhdr->off1 \
595 FIX (cbLineOffset
, line
, unsigned char *);
596 FIX (cbDnOffset
, external_dnr
, void *);
597 FIX (cbPdOffset
, external_pdr
, void *);
598 FIX (cbSymOffset
, external_sym
, void *);
599 FIX (cbOptOffset
, external_opt
, void *);
600 FIX (cbAuxOffset
, external_aux
, union aux_ext
*);
601 FIX (cbSsOffset
, ss
, char *);
602 FIX (cbSsExtOffset
, ssext
, char *);
603 FIX (cbFdOffset
, external_fdr
, void *);
604 FIX (cbRfdOffset
, external_rfd
, void *);
605 FIX (cbExtOffset
, external_ext
, void *);
608 /* I don't want to always swap all the data, because it will just
609 waste time and most programs will never look at it. The only
610 time the linker needs most of the debugging information swapped
611 is when linking big-endian and little-endian MIPS object files
612 together, which is not a common occurrence.
614 We need to look at the fdr to deal with a lot of information in
615 the symbols, so we swap them here. */
616 if (_bfd_mul_overflow ((unsigned long) internal_symhdr
->ifdMax
,
617 sizeof (struct fdr
), &amt
))
619 bfd_set_error (bfd_error_file_too_big
);
622 debug
->fdr
= (FDR
*) bfd_alloc (abfd
, amt
);
623 if (debug
->fdr
== NULL
)
625 external_fdr_size
= backend
->debug_swap
.external_fdr_size
;
626 fdr_ptr
= debug
->fdr
;
627 fraw_src
= (char *) debug
->external_fdr
;
628 /* PR 17512: file: 3372-1243-0.004. */
629 if (fraw_src
== NULL
&& internal_symhdr
->ifdMax
> 0)
631 fraw_end
= fraw_src
+ internal_symhdr
->ifdMax
* external_fdr_size
;
632 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
633 (*backend
->debug_swap
.swap_fdr_in
) (abfd
, (void *) fraw_src
, fdr_ptr
);
638 /* ECOFF symbol table routines. The ECOFF symbol table is described
639 in gcc/mips-tfile.c. */
641 /* ECOFF uses two common sections. One is the usual one, and the
642 other is for small objects. All the small objects are kept
643 together, and then referenced via the gp pointer, which yields
644 faster assembler code. This is what we use for the small common
646 static asection ecoff_scom_section
;
647 static asymbol ecoff_scom_symbol
;
648 static asymbol
*ecoff_scom_symbol_ptr
;
650 /* Create an empty symbol. */
653 _bfd_ecoff_make_empty_symbol (bfd
*abfd
)
655 ecoff_symbol_type
*new_symbol
;
656 size_t amt
= sizeof (ecoff_symbol_type
);
658 new_symbol
= (ecoff_symbol_type
*) bfd_zalloc (abfd
, amt
);
659 if (new_symbol
== NULL
)
661 new_symbol
->symbol
.section
= NULL
;
662 new_symbol
->fdr
= NULL
;
663 new_symbol
->local
= FALSE
;
664 new_symbol
->native
= NULL
;
665 new_symbol
->symbol
.the_bfd
= abfd
;
666 return &new_symbol
->symbol
;
669 /* Set the BFD flags and section for an ECOFF symbol. */
672 ecoff_set_symbol_info (bfd
*abfd
,
678 asym
->the_bfd
= abfd
;
679 asym
->value
= ecoff_sym
->value
;
680 asym
->section
= &bfd_debug_section
;
683 /* Most symbol types are just for debugging. */
684 switch (ecoff_sym
->st
)
693 if (ECOFF_IS_STAB (ecoff_sym
))
695 asym
->flags
= BSF_DEBUGGING
;
700 asym
->flags
= BSF_DEBUGGING
;
705 asym
->flags
= BSF_EXPORT
| BSF_WEAK
;
707 asym
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
710 asym
->flags
= BSF_LOCAL
;
711 /* Normally, a local stProc symbol will have a corresponding
712 external symbol. We mark the local symbol as a debugging
713 symbol, in order to prevent nm from printing both out.
714 Similarly, we mark stLabel and stabs symbols as debugging
715 symbols. In both cases, we do want to set the value
716 correctly based on the symbol class. */
717 if (ecoff_sym
->st
== stProc
718 || ecoff_sym
->st
== stLabel
719 || ECOFF_IS_STAB (ecoff_sym
))
720 asym
->flags
|= BSF_DEBUGGING
;
723 if (ecoff_sym
->st
== stProc
|| ecoff_sym
->st
== stStaticProc
)
724 asym
->flags
|= BSF_FUNCTION
;
726 switch (ecoff_sym
->sc
)
729 /* Used for compiler generated labels. Leave them in the
730 debugging section, and mark them as local. If BSF_DEBUGGING
731 is set, then nm does not display them for some reason. If no
732 flags are set then the linker whines about them. */
733 asym
->flags
= BSF_LOCAL
;
736 asym
->section
= bfd_make_section_old_way (abfd
, _TEXT
);
737 asym
->value
-= asym
->section
->vma
;
740 asym
->section
= bfd_make_section_old_way (abfd
, _DATA
);
741 asym
->value
-= asym
->section
->vma
;
744 asym
->section
= bfd_make_section_old_way (abfd
, _BSS
);
745 asym
->value
-= asym
->section
->vma
;
748 asym
->flags
= BSF_DEBUGGING
;
751 asym
->section
= bfd_abs_section_ptr
;
754 asym
->section
= bfd_und_section_ptr
;
764 asym
->flags
= BSF_DEBUGGING
;
767 asym
->section
= bfd_make_section_old_way (abfd
, ".sdata");
768 asym
->value
-= asym
->section
->vma
;
771 asym
->section
= bfd_make_section_old_way (abfd
, ".sbss");
772 asym
->value
-= asym
->section
->vma
;
775 asym
->section
= bfd_make_section_old_way (abfd
, ".rdata");
776 asym
->value
-= asym
->section
->vma
;
779 asym
->flags
= BSF_DEBUGGING
;
782 if (asym
->value
> ecoff_data (abfd
)->gp_size
)
784 asym
->section
= bfd_com_section_ptr
;
790 if (ecoff_scom_section
.name
== NULL
)
792 /* Initialize the small common section. */
793 ecoff_scom_section
.name
= SCOMMON
;
794 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
795 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
796 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
797 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
798 ecoff_scom_symbol
.name
= SCOMMON
;
799 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
800 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
801 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
803 asym
->section
= &ecoff_scom_section
;
808 asym
->flags
= BSF_DEBUGGING
;
811 asym
->section
= bfd_und_section_ptr
;
816 asym
->section
= bfd_make_section_old_way (abfd
, ".init");
817 asym
->value
-= asym
->section
->vma
;
822 asym
->flags
= BSF_DEBUGGING
;
825 asym
->section
= bfd_make_section_old_way (abfd
, ".fini");
826 asym
->value
-= asym
->section
->vma
;
829 asym
->section
= bfd_make_section_old_way (abfd
, ".rconst");
830 asym
->value
-= asym
->section
->vma
;
836 /* Look for special constructors symbols and make relocation entries
837 in a special construction section. These are produced by the
838 -fgnu-linker argument to g++. */
839 if (ECOFF_IS_STAB (ecoff_sym
))
841 switch (ECOFF_UNMARK_STAB (ecoff_sym
->index
))
850 /* Mark the symbol as a constructor. */
851 asym
->flags
|= BSF_CONSTRUCTOR
;
858 /* Read an ECOFF symbol table. */
861 _bfd_ecoff_slurp_symbol_table (bfd
*abfd
)
863 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
864 const bfd_size_type external_ext_size
865 = backend
->debug_swap
.external_ext_size
;
866 const bfd_size_type external_sym_size
867 = backend
->debug_swap
.external_sym_size
;
868 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
869 = backend
->debug_swap
.swap_ext_in
;
870 void (* const swap_sym_in
) (bfd
*, void *, SYMR
*)
871 = backend
->debug_swap
.swap_sym_in
;
872 ecoff_symbol_type
*internal
;
873 ecoff_symbol_type
*internal_ptr
;
880 /* If we've already read in the symbol table, do nothing. */
881 if (ecoff_data (abfd
)->canonical_symbols
!= NULL
)
884 /* Get the symbolic information. */
885 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
886 &ecoff_data (abfd
)->debug_info
))
888 if (bfd_get_symcount (abfd
) == 0)
891 if (_bfd_mul_overflow (bfd_get_symcount (abfd
),
892 sizeof (ecoff_symbol_type
), &amt
))
894 bfd_set_error (bfd_error_file_too_big
);
897 internal
= (ecoff_symbol_type
*) bfd_alloc (abfd
, amt
);
898 if (internal
== NULL
)
901 internal_ptr
= internal
;
902 eraw_src
= (char *) ecoff_data (abfd
)->debug_info
.external_ext
;
904 + (ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
905 * external_ext_size
));
906 for (; eraw_src
< eraw_end
; eraw_src
+= external_ext_size
, internal_ptr
++)
910 (*swap_ext_in
) (abfd
, (void *) eraw_src
, &internal_esym
);
912 /* PR 17512: file: 3372-1000-0.004. */
913 if (internal_esym
.asym
.iss
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.issExtMax
914 || internal_esym
.asym
.iss
< 0)
917 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ssext
918 + internal_esym
.asym
.iss
);
920 if (!ecoff_set_symbol_info (abfd
, &internal_esym
.asym
,
921 &internal_ptr
->symbol
, 1,
922 internal_esym
.weakext
))
925 /* The alpha uses a negative ifd field for section symbols. */
926 if (internal_esym
.ifd
>= 0)
928 /* PR 17512: file: 3372-1983-0.004. */
929 if (internal_esym
.ifd
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
)
930 internal_ptr
->fdr
= NULL
;
932 internal_ptr
->fdr
= (ecoff_data (abfd
)->debug_info
.fdr
933 + internal_esym
.ifd
);
936 internal_ptr
->fdr
= NULL
;
937 internal_ptr
->local
= FALSE
;
938 internal_ptr
->native
= (void *) eraw_src
;
941 /* The local symbols must be accessed via the fdr's, because the
942 string and aux indices are relative to the fdr information. */
943 fdr_ptr
= ecoff_data (abfd
)->debug_info
.fdr
;
944 fdr_end
= fdr_ptr
+ ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
;
945 for (; fdr_ptr
< fdr_end
; fdr_ptr
++)
950 lraw_src
= ((char *) ecoff_data (abfd
)->debug_info
.external_sym
951 + fdr_ptr
->isymBase
* external_sym_size
);
952 lraw_end
= lraw_src
+ fdr_ptr
->csym
* external_sym_size
;
955 lraw_src
+= external_sym_size
, internal_ptr
++)
959 (*swap_sym_in
) (abfd
, (void *) lraw_src
, &internal_sym
);
960 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ss
963 if (!ecoff_set_symbol_info (abfd
, &internal_sym
,
964 &internal_ptr
->symbol
, 0, 0))
966 internal_ptr
->fdr
= fdr_ptr
;
967 internal_ptr
->local
= TRUE
;
968 internal_ptr
->native
= (void *) lraw_src
;
972 /* PR 17512: file: 3372-3080-0.004.
973 A discrepancy between ecoff_data (abfd)->debug_info.symbolic_header.isymMax
974 and ecoff_data (abfd)->debug_info.symbolic_header.ifdMax can mean that
975 we have fewer symbols than we were expecting. Allow for this by updating
976 the symbol count and warning the user. */
977 if (internal_ptr
- internal
< (ptrdiff_t) bfd_get_symcount (abfd
))
979 abfd
->symcount
= internal_ptr
- internal
;
981 /* xgettext:c-format */
982 (_("%pB: warning: isymMax (%ld) is greater than ifdMax (%ld)"),
983 abfd
, ecoff_data (abfd
)->debug_info
.symbolic_header
.isymMax
,
984 ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
);
987 ecoff_data (abfd
)->canonical_symbols
= internal
;
992 /* Return the amount of space needed for the canonical symbols. */
995 _bfd_ecoff_get_symtab_upper_bound (bfd
*abfd
)
997 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
998 &ecoff_data (abfd
)->debug_info
))
1001 if (bfd_get_symcount (abfd
) == 0)
1004 return (bfd_get_symcount (abfd
) + 1) * (sizeof (ecoff_symbol_type
*));
1007 /* Get the canonical symbols. */
1010 _bfd_ecoff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
1012 unsigned int counter
= 0;
1013 ecoff_symbol_type
*symbase
;
1014 ecoff_symbol_type
**location
= (ecoff_symbol_type
**) alocation
;
1016 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1018 if (bfd_get_symcount (abfd
) == 0)
1021 symbase
= ecoff_data (abfd
)->canonical_symbols
;
1022 while (counter
< bfd_get_symcount (abfd
))
1024 *(location
++) = symbase
++;
1028 return bfd_get_symcount (abfd
);
1031 /* Turn ECOFF type information into a printable string.
1032 ecoff_emit_aggregate and ecoff_type_to_string are from
1033 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1035 /* Write aggregate information to a string. */
1038 ecoff_emit_aggregate (bfd
*abfd
,
1045 const struct ecoff_debug_swap
* const debug_swap
=
1046 &ecoff_backend (abfd
)->debug_swap
;
1047 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1048 unsigned int ifd
= rndx
->rfd
;
1049 unsigned int indx
= rndx
->index
;
1055 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1056 struct return type of a procedure compiled without -g. */
1057 if (ifd
== 0xffffffff
1058 || (rndx
->rfd
== 0xfff && indx
== 0))
1059 name
= "<undefined>";
1060 else if (indx
== indexNil
)
1066 if (debug_info
->external_rfd
== NULL
)
1067 fdr
= debug_info
->fdr
+ ifd
;
1072 (*debug_swap
->swap_rfd_in
) (abfd
,
1073 ((char *) debug_info
->external_rfd
1074 + ((fdr
->rfdBase
+ ifd
)
1075 * debug_swap
->external_rfd_size
)),
1077 fdr
= debug_info
->fdr
+ rfd
;
1080 indx
+= fdr
->isymBase
;
1082 (*debug_swap
->swap_sym_in
) (abfd
,
1083 ((char *) debug_info
->external_sym
1084 + indx
* debug_swap
->external_sym_size
),
1087 name
= debug_info
->ss
+ fdr
->issBase
+ sym
.iss
;
1091 "%s %s { ifd = %u, index = %lu }",
1093 ((unsigned long) indx
1094 + debug_info
->symbolic_header
.iextMax
));
1097 /* Convert the type information to string format. */
1100 ecoff_type_to_string (bfd
*abfd
, FDR
*fdr
, unsigned int indx
)
1102 union aux_ext
*aux_ptr
;
1112 unsigned int basic_type
;
1115 static char buffer2
[1024];
1120 aux_ptr
= ecoff_data (abfd
)->debug_info
.external_aux
+ fdr
->iauxBase
;
1121 bigendian
= fdr
->fBigendian
;
1123 for (i
= 0; i
< 7; i
++)
1125 qualifiers
[i
].low_bound
= 0;
1126 qualifiers
[i
].high_bound
= 0;
1127 qualifiers
[i
].stride
= 0;
1130 if (AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
]) == (bfd_vma
) -1)
1131 return "-1 (no type)";
1132 _bfd_ecoff_swap_tir_in (bigendian
, &aux_ptr
[indx
++].a_ti
, &u
.ti
);
1134 basic_type
= u
.ti
.bt
;
1135 qualifiers
[0].type
= u
.ti
.tq0
;
1136 qualifiers
[1].type
= u
.ti
.tq1
;
1137 qualifiers
[2].type
= u
.ti
.tq2
;
1138 qualifiers
[3].type
= u
.ti
.tq3
;
1139 qualifiers
[4].type
= u
.ti
.tq4
;
1140 qualifiers
[5].type
= u
.ti
.tq5
;
1141 qualifiers
[6].type
= tqNil
;
1143 /* Go get the basic type. */
1146 case btNil
: /* Undefined. */
1150 case btAdr
: /* Address - integer same size as pointer. */
1151 strcpy (p1
, "address");
1154 case btChar
: /* Character. */
1155 strcpy (p1
, "char");
1158 case btUChar
: /* Unsigned character. */
1159 strcpy (p1
, "unsigned char");
1162 case btShort
: /* Short. */
1163 strcpy (p1
, "short");
1166 case btUShort
: /* Unsigned short. */
1167 strcpy (p1
, "unsigned short");
1170 case btInt
: /* Int. */
1174 case btUInt
: /* Unsigned int. */
1175 strcpy (p1
, "unsigned int");
1178 case btLong
: /* Long. */
1179 strcpy (p1
, "long");
1182 case btULong
: /* Unsigned long. */
1183 strcpy (p1
, "unsigned long");
1186 case btFloat
: /* Float (real). */
1187 strcpy (p1
, "float");
1190 case btDouble
: /* Double (real). */
1191 strcpy (p1
, "double");
1194 /* Structures add 1-2 aux words:
1195 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1196 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1198 case btStruct
: /* Structure (Record). */
1199 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1200 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1201 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1203 indx
++; /* Skip aux words. */
1206 /* Unions add 1-2 aux words:
1207 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1208 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1210 case btUnion
: /* Union. */
1211 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1212 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1213 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1215 indx
++; /* Skip aux words. */
1218 /* Enumerations add 1-2 aux words:
1219 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1220 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1222 case btEnum
: /* Enumeration. */
1223 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1224 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1225 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1227 indx
++; /* Skip aux words. */
1230 case btTypedef
: /* Defined via a typedef, isymRef points. */
1231 strcpy (p1
, "typedef");
1234 case btRange
: /* Subrange of int. */
1235 strcpy (p1
, "subrange");
1238 case btSet
: /* Pascal sets. */
1242 case btComplex
: /* Fortran complex. */
1243 strcpy (p1
, "complex");
1246 case btDComplex
: /* Fortran double complex. */
1247 strcpy (p1
, "double complex");
1250 case btIndirect
: /* Forward or unnamed typedef. */
1251 strcpy (p1
, "forward/unamed typedef");
1254 case btFixedDec
: /* Fixed Decimal. */
1255 strcpy (p1
, "fixed decimal");
1258 case btFloatDec
: /* Float Decimal. */
1259 strcpy (p1
, "float decimal");
1262 case btString
: /* Varying Length Character String. */
1263 strcpy (p1
, "string");
1266 case btBit
: /* Aligned Bit String. */
1270 case btPicture
: /* Picture. */
1271 strcpy (p1
, "picture");
1274 case btVoid
: /* Void. */
1275 strcpy (p1
, "void");
1279 sprintf (p1
, _("unknown basic type %d"), (int) basic_type
);
1283 p1
+= strlen (buffer1
);
1285 /* If this is a bitfield, get the bitsize. */
1290 bitsize
= AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
++]);
1291 sprintf (p1
, " : %d", bitsize
);
1292 p1
+= strlen (buffer1
);
1295 /* Deal with any qualifiers. */
1296 if (qualifiers
[0].type
!= tqNil
)
1298 /* Snarf up any array bounds in the correct order. Arrays
1299 store 5 successive words in the aux. table:
1300 word 0 RNDXR to type of the bounds (ie, int)
1301 word 1 Current file descriptor index
1303 word 3 high bound (or -1 if [])
1304 word 4 stride size in bits. */
1305 for (i
= 0; i
< 7; i
++)
1307 if (qualifiers
[i
].type
== tqArray
)
1309 qualifiers
[i
].low_bound
=
1310 AUX_GET_DNLOW (bigendian
, &aux_ptr
[indx
+2]);
1311 qualifiers
[i
].high_bound
=
1312 AUX_GET_DNHIGH (bigendian
, &aux_ptr
[indx
+3]);
1313 qualifiers
[i
].stride
=
1314 AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
+4]);
1319 /* Now print out the qualifiers. */
1320 for (i
= 0; i
< 6; i
++)
1322 switch (qualifiers
[i
].type
)
1329 strcpy (p2
, "ptr to ");
1330 p2
+= sizeof ("ptr to ")-1;
1334 strcpy (p2
, "volatile ");
1335 p2
+= sizeof ("volatile ")-1;
1339 strcpy (p2
, "far ");
1340 p2
+= sizeof ("far ")-1;
1344 strcpy (p2
, "func. ret. ");
1345 p2
+= sizeof ("func. ret. ");
1350 int first_array
= i
;
1353 /* Print array bounds reversed (ie, in the order the C
1354 programmer writes them). C is such a fun language.... */
1355 while (i
< 5 && qualifiers
[i
+1].type
== tqArray
)
1358 for (j
= i
; j
>= first_array
; j
--)
1360 strcpy (p2
, "array [");
1361 p2
+= sizeof ("array [")-1;
1362 if (qualifiers
[j
].low_bound
!= 0)
1364 "%ld:%ld {%ld bits}",
1365 (long) qualifiers
[j
].low_bound
,
1366 (long) qualifiers
[j
].high_bound
,
1367 (long) qualifiers
[j
].stride
);
1369 else if (qualifiers
[j
].high_bound
!= -1)
1372 (long) (qualifiers
[j
].high_bound
+ 1),
1373 (long) (qualifiers
[j
].stride
));
1376 sprintf (p2
, " {%ld bits}", (long) (qualifiers
[j
].stride
));
1379 strcpy (p2
, "] of ");
1380 p2
+= sizeof ("] of ")-1;
1388 strcpy (p2
, buffer1
);
1392 /* Return information about ECOFF symbol SYMBOL in RET. */
1395 _bfd_ecoff_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
1399 bfd_symbol_info (symbol
, ret
);
1402 /* Return whether this is a local label. */
1405 _bfd_ecoff_bfd_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1408 return name
[0] == '$';
1411 /* Print information about an ECOFF symbol. */
1414 _bfd_ecoff_print_symbol (bfd
*abfd
,
1417 bfd_print_symbol_type how
)
1419 const struct ecoff_debug_swap
* const debug_swap
1420 = &ecoff_backend (abfd
)->debug_swap
;
1421 FILE *file
= (FILE *)filep
;
1425 case bfd_print_symbol_name
:
1426 fprintf (file
, "%s", symbol
->name
);
1428 case bfd_print_symbol_more
:
1429 if (ecoffsymbol (symbol
)->local
)
1433 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1435 fprintf (file
, "ecoff local ");
1436 fprintf_vma (file
, (bfd_vma
) ecoff_sym
.value
);
1437 fprintf (file
, " %x %x", (unsigned) ecoff_sym
.st
,
1438 (unsigned) ecoff_sym
.sc
);
1444 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1446 fprintf (file
, "ecoff extern ");
1447 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1448 fprintf (file
, " %x %x", (unsigned) ecoff_ext
.asym
.st
,
1449 (unsigned) ecoff_ext
.asym
.sc
);
1452 case bfd_print_symbol_all
:
1453 /* Print out the symbols in a reasonable way. */
1462 if (ecoffsymbol (symbol
)->local
)
1464 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1467 pos
= ((((char *) ecoffsymbol (symbol
)->native
1468 - (char *) ecoff_data (abfd
)->debug_info
.external_sym
)
1469 / debug_swap
->external_sym_size
)
1470 + ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
);
1477 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1480 pos
= (((char *) ecoffsymbol (symbol
)->native
1481 - (char *) ecoff_data (abfd
)->debug_info
.external_ext
)
1482 / debug_swap
->external_ext_size
);
1483 jmptbl
= ecoff_ext
.jmptbl
? 'j' : ' ';
1484 cobol_main
= ecoff_ext
.cobol_main
? 'c' : ' ';
1485 weakext
= ecoff_ext
.weakext
? 'w' : ' ';
1488 fprintf (file
, "[%3d] %c ",
1490 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1491 fprintf (file
, " st %x sc %x indx %x %c%c%c %s",
1492 (unsigned) ecoff_ext
.asym
.st
,
1493 (unsigned) ecoff_ext
.asym
.sc
,
1494 (unsigned) ecoff_ext
.asym
.index
,
1495 jmptbl
, cobol_main
, weakext
,
1498 if (ecoffsymbol (symbol
)->fdr
!= NULL
1499 && ecoff_ext
.asym
.index
!= indexNil
)
1504 bfd_size_type sym_base
;
1505 union aux_ext
*aux_base
;
1507 fdr
= ecoffsymbol (symbol
)->fdr
;
1508 indx
= ecoff_ext
.asym
.index
;
1510 /* sym_base is used to map the fdr relative indices which
1511 appear in the file to the position number which we are
1513 sym_base
= fdr
->isymBase
;
1514 if (ecoffsymbol (symbol
)->local
)
1516 ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
1518 /* aux_base is the start of the aux entries for this file;
1519 asym.index is an offset from this. */
1520 aux_base
= (ecoff_data (abfd
)->debug_info
.external_aux
1523 /* The aux entries are stored in host byte order; the
1524 order is indicated by a bit in the fdr. */
1525 bigendian
= fdr
->fBigendian
;
1527 /* This switch is basically from gcc/mips-tdump.c. */
1528 switch (ecoff_ext
.asym
.st
)
1536 fprintf (file
, _("\n End+1 symbol: %ld"),
1537 (long) (indx
+ sym_base
));
1541 if (ecoff_ext
.asym
.sc
== scText
1542 || ecoff_ext
.asym
.sc
== scInfo
)
1543 fprintf (file
, _("\n First symbol: %ld"),
1544 (long) (indx
+ sym_base
));
1546 fprintf (file
, _("\n First symbol: %ld"),
1548 (AUX_GET_ISYM (bigendian
,
1549 &aux_base
[ecoff_ext
.asym
.index
])
1555 if (ECOFF_IS_STAB (&ecoff_ext
.asym
))
1557 else if (ecoffsymbol (symbol
)->local
)
1558 /* xgettext:c-format */
1559 fprintf (file
, _("\n End+1 symbol: %-7ld Type: %s"),
1561 (AUX_GET_ISYM (bigendian
,
1562 &aux_base
[ecoff_ext
.asym
.index
])
1564 ecoff_type_to_string (abfd
, fdr
, indx
+ 1));
1566 fprintf (file
, _("\n Local symbol: %ld"),
1569 + (ecoff_data (abfd
)
1570 ->debug_info
.symbolic_header
.iextMax
)));
1574 fprintf (file
, _("\n struct; End+1 symbol: %ld"),
1575 (long) (indx
+ sym_base
));
1579 fprintf (file
, _("\n union; End+1 symbol: %ld"),
1580 (long) (indx
+ sym_base
));
1584 fprintf (file
, _("\n enum; End+1 symbol: %ld"),
1585 (long) (indx
+ sym_base
));
1589 if (! ECOFF_IS_STAB (&ecoff_ext
.asym
))
1590 fprintf (file
, _("\n Type: %s"),
1591 ecoff_type_to_string (abfd
, fdr
, indx
));
1600 /* Read in the relocs for a section. */
1603 ecoff_slurp_reloc_table (bfd
*abfd
,
1607 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1608 arelent
*internal_relocs
;
1609 bfd_size_type external_reloc_size
;
1611 bfd_byte
*external_relocs
;
1615 if (section
->relocation
!= NULL
1616 || section
->reloc_count
== 0
1617 || (section
->flags
& SEC_CONSTRUCTOR
) != 0)
1620 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1623 external_reloc_size
= backend
->external_reloc_size
;
1624 amt
= external_reloc_size
* section
->reloc_count
;
1625 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1627 external_relocs
= _bfd_alloc_and_read (abfd
, amt
, amt
);
1628 if (external_relocs
== NULL
)
1631 amt
= section
->reloc_count
;
1632 amt
*= sizeof (arelent
);
1633 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
1634 if (internal_relocs
== NULL
)
1636 bfd_release (abfd
, external_relocs
);
1640 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1642 struct internal_reloc intern
;
1644 (*backend
->swap_reloc_in
) (abfd
,
1645 external_relocs
+ i
* external_reloc_size
,
1648 if (intern
.r_extern
)
1650 /* r_symndx is an index into the external symbols. */
1651 BFD_ASSERT (intern
.r_symndx
>= 0
1653 < (ecoff_data (abfd
)
1654 ->debug_info
.symbolic_header
.iextMax
)));
1655 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1658 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1659 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1661 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1666 const char *sec_name
;
1669 /* r_symndx is a section key. */
1670 switch (intern
.r_symndx
)
1672 case RELOC_SECTION_TEXT
: sec_name
= _TEXT
; break;
1673 case RELOC_SECTION_RDATA
: sec_name
= _RDATA
; break;
1674 case RELOC_SECTION_DATA
: sec_name
= _DATA
; break;
1675 case RELOC_SECTION_SDATA
: sec_name
= _SDATA
; break;
1676 case RELOC_SECTION_SBSS
: sec_name
= _SBSS
; break;
1677 case RELOC_SECTION_BSS
: sec_name
= _BSS
; break;
1678 case RELOC_SECTION_INIT
: sec_name
= _INIT
; break;
1679 case RELOC_SECTION_LIT8
: sec_name
= _LIT8
; break;
1680 case RELOC_SECTION_LIT4
: sec_name
= _LIT4
; break;
1681 case RELOC_SECTION_XDATA
: sec_name
= _XDATA
; break;
1682 case RELOC_SECTION_PDATA
: sec_name
= _PDATA
; break;
1683 case RELOC_SECTION_FINI
: sec_name
= _FINI
; break;
1684 case RELOC_SECTION_LITA
: sec_name
= _LITA
; break;
1685 case RELOC_SECTION_RCONST
: sec_name
= _RCONST
; break;
1689 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1692 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1694 rptr
->addend
= - bfd_section_vma (sec
);
1697 rptr
->address
= intern
.r_vaddr
- bfd_section_vma (section
);
1699 /* Let the backend select the howto field and do any other
1700 required processing. */
1701 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1704 bfd_release (abfd
, external_relocs
);
1706 section
->relocation
= internal_relocs
;
1711 /* Get a canonical list of relocs. */
1714 _bfd_ecoff_canonicalize_reloc (bfd
*abfd
,
1721 if (section
->flags
& SEC_CONSTRUCTOR
)
1723 arelent_chain
*chain
;
1725 /* This section has relocs made up by us, not the file, so take
1726 them out of their chain and place them into the data area
1728 for (count
= 0, chain
= section
->constructor_chain
;
1729 count
< section
->reloc_count
;
1730 count
++, chain
= chain
->next
)
1731 *relptr
++ = &chain
->relent
;
1737 if (! ecoff_slurp_reloc_table (abfd
, section
, symbols
))
1740 tblptr
= section
->relocation
;
1742 for (count
= 0; count
< section
->reloc_count
; count
++)
1743 *relptr
++ = tblptr
++;
1748 return section
->reloc_count
;
1751 /* Provided a BFD, a section and an offset into the section, calculate
1752 and return the name of the source file and the line nearest to the
1756 _bfd_ecoff_find_nearest_line (bfd
*abfd
,
1757 asymbol
**symbols ATTRIBUTE_UNUSED
,
1760 const char **filename_ptr
,
1761 const char **functionname_ptr
,
1762 unsigned int *retline_ptr
,
1763 unsigned int *discriminator_ptr
)
1765 const struct ecoff_debug_swap
* const debug_swap
1766 = &ecoff_backend (abfd
)->debug_swap
;
1767 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1768 struct ecoff_find_line
*line_info
;
1770 /* Make sure we have the FDR's. */
1771 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
, debug_info
)
1772 || bfd_get_symcount (abfd
) == 0)
1775 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1777 size_t amt
= sizeof (struct ecoff_find_line
);
1779 ecoff_data (abfd
)->find_line_info
=
1780 (struct ecoff_find_line
*) bfd_zalloc (abfd
, amt
);
1781 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1785 if (discriminator_ptr
)
1786 *discriminator_ptr
= 0;
1787 line_info
= ecoff_data (abfd
)->find_line_info
;
1788 return _bfd_ecoff_locate_line (abfd
, section
, offset
, debug_info
,
1789 debug_swap
, line_info
, filename_ptr
,
1790 functionname_ptr
, retline_ptr
);
1793 /* Copy private BFD data. This is called by objcopy and strip. We
1794 use it to copy the ECOFF debugging information from one BFD to the
1795 other. It would be theoretically possible to represent the ECOFF
1796 debugging information in the symbol table. However, it would be a
1797 lot of work, and there would be little gain (gas, gdb, and ld
1798 already access the ECOFF debugging information via the
1799 ecoff_debug_info structure, and that structure would have to be
1800 retained in order to support ECOFF debugging in MIPS ELF).
1802 The debugging information for the ECOFF external symbols comes from
1803 the symbol table, so this function only handles the other debugging
1807 _bfd_ecoff_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1809 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
1810 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
1812 asymbol
**sym_ptr_ptr
;
1816 /* We only want to copy information over if both BFD's use ECOFF
1818 if (bfd_get_flavour (ibfd
) != bfd_target_ecoff_flavour
1819 || bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
1822 /* Copy the GP value and the register masks. */
1823 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
1824 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
1825 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
1826 for (i
= 0; i
< 3; i
++)
1827 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
1829 /* Copy the version stamp. */
1830 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
1832 /* If there are no symbols, don't copy any debugging information. */
1833 c
= bfd_get_symcount (obfd
);
1834 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1835 if (c
== 0 || sym_ptr_ptr
== NULL
)
1838 /* See if there are any local symbols. */
1840 for (; c
> 0; c
--, sym_ptr_ptr
++)
1842 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
1851 /* There are some local symbols. We just bring over all the
1852 debugging information. FIXME: This is not quite the right
1853 thing to do. If the user has asked us to discard all
1854 debugging information, then we are probably going to wind up
1855 keeping it because there will probably be some local symbol
1856 which objcopy did not discard. We should actually break
1857 apart the debugging information and only keep that which
1858 applies to the symbols we want to keep. */
1859 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
1860 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
1861 oinfo
->line
= iinfo
->line
;
1863 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
1864 oinfo
->external_dnr
= iinfo
->external_dnr
;
1866 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
1867 oinfo
->external_pdr
= iinfo
->external_pdr
;
1869 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
1870 oinfo
->external_sym
= iinfo
->external_sym
;
1872 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
1873 oinfo
->external_opt
= iinfo
->external_opt
;
1875 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
1876 oinfo
->external_aux
= iinfo
->external_aux
;
1878 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
1879 oinfo
->ss
= iinfo
->ss
;
1881 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
1882 oinfo
->external_fdr
= iinfo
->external_fdr
;
1884 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
1885 oinfo
->external_rfd
= iinfo
->external_rfd
;
1889 /* We are discarding all the local symbol information. Look
1890 through the external symbols and remove all references to FDR
1891 or aux information. */
1892 c
= bfd_get_symcount (obfd
);
1893 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1894 for (; c
> 0; c
--, sym_ptr_ptr
++)
1898 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
1899 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
1901 esym
.asym
.index
= indexNil
;
1902 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
1903 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
1910 /* Set the architecture. The supported architecture is stored in the
1911 backend pointer. We always set the architecture anyhow, since many
1912 callers ignore the return value. */
1915 _bfd_ecoff_set_arch_mach (bfd
*abfd
,
1916 enum bfd_architecture arch
,
1917 unsigned long machine
)
1919 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1920 return arch
== ecoff_backend (abfd
)->arch
;
1923 /* Get the size of the section headers. */
1926 _bfd_ecoff_sizeof_headers (bfd
*abfd
,
1927 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1934 for (current
= abfd
->sections
;
1936 current
= current
->next
)
1939 ret
= (bfd_coff_filhsz (abfd
)
1940 + bfd_coff_aoutsz (abfd
)
1941 + c
* bfd_coff_scnhsz (abfd
));
1942 return (int) BFD_ALIGN (ret
, 16);
1945 /* Get the contents of a section. */
1948 _bfd_ecoff_get_section_contents (bfd
*abfd
,
1952 bfd_size_type count
)
1954 return _bfd_generic_get_section_contents (abfd
, section
, location
,
1958 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
1959 called via qsort. */
1962 ecoff_sort_hdrs (const void * arg1
, const void * arg2
)
1964 const asection
*hdr1
= *(const asection
**) arg1
;
1965 const asection
*hdr2
= *(const asection
**) arg2
;
1967 if ((hdr1
->flags
& SEC_ALLOC
) != 0)
1969 if ((hdr2
->flags
& SEC_ALLOC
) == 0)
1974 if ((hdr2
->flags
& SEC_ALLOC
) != 0)
1977 if (hdr1
->vma
< hdr2
->vma
)
1979 else if (hdr1
->vma
> hdr2
->vma
)
1985 /* Calculate the file position for each section, and set
1989 ecoff_compute_section_file_positions (bfd
*abfd
)
1991 file_ptr sofar
, file_sofar
;
1992 asection
**sorted_hdrs
;
1996 bfd_boolean rdata_in_text
;
1997 bfd_boolean first_data
, first_nonalloc
;
1998 const bfd_vma round
= ecoff_backend (abfd
)->round
;
2001 sofar
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2004 /* Sort the sections by VMA. */
2005 amt
= abfd
->section_count
;
2006 amt
*= sizeof (asection
*);
2007 sorted_hdrs
= (asection
**) bfd_malloc (amt
);
2008 if (sorted_hdrs
== NULL
)
2010 for (current
= abfd
->sections
, i
= 0;
2012 current
= current
->next
, i
++)
2013 sorted_hdrs
[i
] = current
;
2014 BFD_ASSERT (i
== abfd
->section_count
);
2016 qsort (sorted_hdrs
, abfd
->section_count
, sizeof (asection
*),
2019 /* Some versions of the OSF linker put the .rdata section in the
2020 text segment, and some do not. */
2021 rdata_in_text
= ecoff_backend (abfd
)->rdata_in_text
;
2024 for (i
= 0; i
< abfd
->section_count
; i
++)
2026 current
= sorted_hdrs
[i
];
2027 if (streq (current
->name
, _RDATA
))
2029 if ((current
->flags
& SEC_CODE
) == 0
2030 && ! streq (current
->name
, _PDATA
)
2031 && ! streq (current
->name
, _RCONST
))
2033 rdata_in_text
= FALSE
;
2038 ecoff_data (abfd
)->rdata_in_text
= rdata_in_text
;
2041 first_nonalloc
= TRUE
;
2042 for (i
= 0; i
< abfd
->section_count
; i
++)
2044 unsigned int alignment_power
;
2046 current
= sorted_hdrs
[i
];
2048 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2049 supposed to indicate the number of .pdata entries that are
2050 really in the section. Each entry is 8 bytes. We store this
2051 away in line_filepos before increasing the section size. */
2052 if (streq (current
->name
, _PDATA
))
2053 current
->line_filepos
= current
->size
/ 8;
2055 alignment_power
= current
->alignment_power
;
2057 /* On Ultrix, the data sections in an executable file must be
2058 aligned to a page boundary within the file. This does not
2059 affect the section size, though. FIXME: Does this work for
2060 other platforms? It requires some modification for the
2061 Alpha, because .rdata on the Alpha goes with the text, not
2063 if ((abfd
->flags
& EXEC_P
) != 0
2064 && (abfd
->flags
& D_PAGED
) != 0
2066 && (current
->flags
& SEC_CODE
) == 0
2068 || ! streq (current
->name
, _RDATA
))
2069 && ! streq (current
->name
, _PDATA
)
2070 && ! streq (current
->name
, _RCONST
))
2072 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2073 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2076 else if (streq (current
->name
, _LIB
))
2078 /* On Irix 4, the location of contents of the .lib section
2079 from a shared library section is also rounded up to a
2082 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2083 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2085 else if (first_nonalloc
2086 && (current
->flags
& SEC_ALLOC
) == 0
2087 && (abfd
->flags
& D_PAGED
) != 0)
2089 /* Skip up to the next page for an unallocated section, such
2090 as the .comment section on the Alpha. This leaves room
2091 for the .bss section. */
2092 first_nonalloc
= FALSE
;
2093 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2094 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2097 /* Align the sections in the file to the same boundary on
2098 which they are aligned in virtual memory. */
2099 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2100 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2101 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2103 if ((abfd
->flags
& D_PAGED
) != 0
2104 && (current
->flags
& SEC_ALLOC
) != 0)
2106 sofar
+= (current
->vma
- sofar
) % round
;
2107 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2108 file_sofar
+= (current
->vma
- file_sofar
) % round
;
2111 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) != 0)
2112 current
->filepos
= file_sofar
;
2114 sofar
+= current
->size
;
2115 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2116 file_sofar
+= current
->size
;
2118 /* Make sure that this section is of the right size too. */
2120 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2121 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2122 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2123 current
->size
+= sofar
- old_sofar
;
2129 ecoff_data (abfd
)->reloc_filepos
= file_sofar
;
2134 /* Determine the location of the relocs for all the sections in the
2135 output file, as well as the location of the symbolic debugging
2138 static bfd_size_type
2139 ecoff_compute_reloc_file_positions (bfd
*abfd
)
2141 const bfd_size_type external_reloc_size
=
2142 ecoff_backend (abfd
)->external_reloc_size
;
2143 file_ptr reloc_base
;
2144 bfd_size_type reloc_size
;
2148 if (! abfd
->output_has_begun
)
2150 if (! ecoff_compute_section_file_positions (abfd
))
2152 abfd
->output_has_begun
= TRUE
;
2155 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2158 for (current
= abfd
->sections
;
2160 current
= current
->next
)
2162 if (current
->reloc_count
== 0)
2163 current
->rel_filepos
= 0;
2166 bfd_size_type relsize
;
2168 current
->rel_filepos
= reloc_base
;
2169 relsize
= current
->reloc_count
* external_reloc_size
;
2170 reloc_size
+= relsize
;
2171 reloc_base
+= relsize
;
2175 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2177 /* At least on Ultrix, the symbol table of an executable file must
2178 be aligned to a page boundary. FIXME: Is this true on other
2180 if ((abfd
->flags
& EXEC_P
) != 0
2181 && (abfd
->flags
& D_PAGED
) != 0)
2182 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2183 &~ (ecoff_backend (abfd
)->round
- 1));
2185 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2190 /* Set the contents of a section. */
2193 _bfd_ecoff_set_section_contents (bfd
*abfd
,
2195 const void * location
,
2197 bfd_size_type count
)
2201 /* This must be done first, because bfd_set_section_contents is
2202 going to set output_has_begun to TRUE. */
2203 if (! abfd
->output_has_begun
2204 && ! ecoff_compute_section_file_positions (abfd
))
2207 /* Handle the .lib section specially so that Irix 4 shared libraries
2208 work out. See coff_set_section_contents in coffcode.h. */
2209 if (streq (section
->name
, _LIB
))
2211 bfd_byte
*rec
, *recend
;
2213 rec
= (bfd_byte
*) location
;
2214 recend
= rec
+ count
;
2215 while (rec
< recend
)
2218 rec
+= bfd_get_32 (abfd
, rec
) * 4;
2221 BFD_ASSERT (rec
== recend
);
2227 pos
= section
->filepos
+ offset
;
2228 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2229 || bfd_bwrite (location
, count
, abfd
) != count
)
2235 /* Set the GP value for an ECOFF file. This is a hook used by the
2239 bfd_ecoff_set_gp_value (bfd
*abfd
, bfd_vma gp_value
)
2241 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2242 || bfd_get_format (abfd
) != bfd_object
)
2244 bfd_set_error (bfd_error_invalid_operation
);
2248 ecoff_data (abfd
)->gp
= gp_value
;
2253 /* Set the register masks for an ECOFF file. This is a hook used by
2257 bfd_ecoff_set_regmasks (bfd
*abfd
,
2258 unsigned long gprmask
,
2259 unsigned long fprmask
,
2260 unsigned long *cprmask
)
2262 ecoff_data_type
*tdata
;
2264 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2265 || bfd_get_format (abfd
) != bfd_object
)
2267 bfd_set_error (bfd_error_invalid_operation
);
2271 tdata
= ecoff_data (abfd
);
2272 tdata
->gprmask
= gprmask
;
2273 tdata
->fprmask
= fprmask
;
2274 if (cprmask
!= NULL
)
2278 for (i
= 0; i
< 3; i
++)
2279 tdata
->cprmask
[i
] = cprmask
[i
];
2285 /* Get ECOFF EXTR information for an external symbol. This function
2286 is passed to bfd_ecoff_debug_externals. */
2289 ecoff_get_extr (asymbol
*sym
, EXTR
*esym
)
2291 ecoff_symbol_type
*ecoff_sym_ptr
;
2294 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2295 || ecoffsymbol (sym
)->native
== NULL
)
2297 /* Don't include debugging, local, or section symbols. */
2298 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2299 || (sym
->flags
& BSF_LOCAL
) != 0
2300 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2304 esym
->cobol_main
= 0;
2305 esym
->weakext
= (sym
->flags
& BSF_WEAK
) != 0;
2308 /* FIXME: we can do better than this for st and sc. */
2309 esym
->asym
.st
= stGlobal
;
2310 esym
->asym
.sc
= scAbs
;
2311 esym
->asym
.reserved
= 0;
2312 esym
->asym
.index
= indexNil
;
2316 ecoff_sym_ptr
= ecoffsymbol (sym
);
2318 if (ecoff_sym_ptr
->local
)
2321 input_bfd
= bfd_asymbol_bfd (sym
);
2322 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2323 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2325 /* If the symbol was defined by the linker, then esym will be
2326 undefined but sym will not be. Get a better class for such a
2328 if ((esym
->asym
.sc
== scUndefined
2329 || esym
->asym
.sc
== scSUndefined
)
2330 && ! bfd_is_und_section (bfd_asymbol_section (sym
)))
2331 esym
->asym
.sc
= scAbs
;
2333 /* Adjust the FDR index for the symbol by that used for the input
2335 if (esym
->ifd
!= -1)
2337 struct ecoff_debug_info
*input_debug
;
2339 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2340 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2341 if (input_debug
->ifdmap
!= NULL
)
2342 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2348 /* Set the external symbol index. This routine is passed to
2349 bfd_ecoff_debug_externals. */
2352 ecoff_set_index (asymbol
*sym
, bfd_size_type indx
)
2354 ecoff_set_sym_index (sym
, indx
);
2357 /* Write out an ECOFF file. */
2360 _bfd_ecoff_write_object_contents (bfd
*abfd
)
2362 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2363 const bfd_vma round
= backend
->round
;
2364 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2365 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2366 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2367 const bfd_size_type external_hdr_size
2368 = backend
->debug_swap
.external_hdr_size
;
2369 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2370 void (* const adjust_reloc_out
) (bfd
*, const arelent
*, struct internal_reloc
*)
2371 = backend
->adjust_reloc_out
;
2372 void (* const swap_reloc_out
) (bfd
*, const struct internal_reloc
*, void *)
2373 = backend
->swap_reloc_out
;
2374 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2375 HDRR
* const symhdr
= &debug
->symbolic_header
;
2378 bfd_size_type reloc_size
;
2379 bfd_size_type text_size
;
2381 bfd_boolean set_text_start
;
2382 bfd_size_type data_size
;
2384 bfd_boolean set_data_start
;
2385 bfd_size_type bss_size
;
2387 void * reloc_buff
= NULL
;
2388 struct internal_filehdr internal_f
;
2389 struct internal_aouthdr internal_a
;
2392 /* Determine where the sections and relocs will go in the output
2394 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2397 for (current
= abfd
->sections
;
2399 current
= current
->next
)
2401 current
->target_index
= count
;
2405 if ((abfd
->flags
& D_PAGED
) != 0)
2406 text_size
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2410 set_text_start
= FALSE
;
2413 set_data_start
= FALSE
;
2416 /* Write section headers to the file. */
2418 /* Allocate buff big enough to hold a section header,
2419 file header, or a.out header. */
2428 buff
= bfd_malloc (siz
);
2433 internal_f
.f_nscns
= 0;
2434 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2437 for (current
= abfd
->sections
;
2439 current
= current
->next
)
2441 struct internal_scnhdr section
;
2444 ++internal_f
.f_nscns
;
2446 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2448 /* This seems to be correct for Irix 4 shared libraries. */
2449 vma
= bfd_section_vma (current
);
2450 if (streq (current
->name
, _LIB
))
2451 section
.s_vaddr
= 0;
2453 section
.s_vaddr
= vma
;
2455 section
.s_paddr
= current
->lma
;
2456 section
.s_size
= current
->size
;
2458 /* If this section is unloadable then the scnptr will be 0. */
2459 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2460 section
.s_scnptr
= 0;
2462 section
.s_scnptr
= current
->filepos
;
2463 section
.s_relptr
= current
->rel_filepos
;
2465 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2466 object file produced by the assembler is supposed to point to
2467 information about how much room is required by objects of
2468 various different sizes. I think this only matters if we
2469 want the linker to compute the best size to use, or
2470 something. I don't know what happens if the information is
2472 if (! streq (current
->name
, _PDATA
))
2473 section
.s_lnnoptr
= 0;
2476 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2477 hold the number of entries in the section (each entry is
2478 8 bytes). We stored this in the line_filepos field in
2479 ecoff_compute_section_file_positions. */
2480 section
.s_lnnoptr
= current
->line_filepos
;
2483 section
.s_nreloc
= current
->reloc_count
;
2484 section
.s_nlnno
= 0;
2485 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2488 if (bfd_coff_swap_scnhdr_out (abfd
, (void *) §ion
, buff
) == 0
2489 || bfd_bwrite (buff
, scnhsz
, abfd
) != scnhsz
)
2492 if ((section
.s_flags
& STYP_TEXT
) != 0
2493 || ((section
.s_flags
& STYP_RDATA
) != 0
2494 && ecoff_data (abfd
)->rdata_in_text
)
2495 || section
.s_flags
== STYP_PDATA
2496 || (section
.s_flags
& STYP_DYNAMIC
) != 0
2497 || (section
.s_flags
& STYP_LIBLIST
) != 0
2498 || (section
.s_flags
& STYP_RELDYN
) != 0
2499 || section
.s_flags
== STYP_CONFLIC
2500 || (section
.s_flags
& STYP_DYNSTR
) != 0
2501 || (section
.s_flags
& STYP_DYNSYM
) != 0
2502 || (section
.s_flags
& STYP_HASH
) != 0
2503 || (section
.s_flags
& STYP_ECOFF_INIT
) != 0
2504 || (section
.s_flags
& STYP_ECOFF_FINI
) != 0
2505 || section
.s_flags
== STYP_RCONST
)
2507 text_size
+= current
->size
;
2508 if (! set_text_start
|| text_start
> vma
)
2511 set_text_start
= TRUE
;
2514 else if ((section
.s_flags
& STYP_RDATA
) != 0
2515 || (section
.s_flags
& STYP_DATA
) != 0
2516 || (section
.s_flags
& STYP_LITA
) != 0
2517 || (section
.s_flags
& STYP_LIT8
) != 0
2518 || (section
.s_flags
& STYP_LIT4
) != 0
2519 || (section
.s_flags
& STYP_SDATA
) != 0
2520 || section
.s_flags
== STYP_XDATA
2521 || (section
.s_flags
& STYP_GOT
) != 0)
2523 data_size
+= current
->size
;
2524 if (! set_data_start
|| data_start
> vma
)
2527 set_data_start
= TRUE
;
2530 else if ((section
.s_flags
& STYP_BSS
) != 0
2531 || (section
.s_flags
& STYP_SBSS
) != 0)
2532 bss_size
+= current
->size
;
2533 else if (section
.s_flags
== 0
2534 || (section
.s_flags
& STYP_ECOFF_LIB
) != 0
2535 || section
.s_flags
== STYP_COMMENT
)
2541 /* Set up the file header. */
2542 internal_f
.f_magic
= ecoff_get_magic (abfd
);
2544 /* We will NOT put a fucking timestamp in the header here. Every
2545 time you put it back, I will come in and take it out again. I'm
2546 sorry. This field does not belong here. We fill it with a 0 so
2547 it compares the same but is not a reasonable time. --
2549 internal_f
.f_timdat
= 0;
2551 if (bfd_get_symcount (abfd
) != 0)
2553 /* The ECOFF f_nsyms field is not actually the number of
2554 symbols, it's the size of symbolic information header. */
2555 internal_f
.f_nsyms
= external_hdr_size
;
2556 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
2560 internal_f
.f_nsyms
= 0;
2561 internal_f
.f_symptr
= 0;
2564 internal_f
.f_opthdr
= aoutsz
;
2566 internal_f
.f_flags
= F_LNNO
;
2567 if (reloc_size
== 0)
2568 internal_f
.f_flags
|= F_RELFLG
;
2569 if (bfd_get_symcount (abfd
) == 0)
2570 internal_f
.f_flags
|= F_LSYMS
;
2571 if (abfd
->flags
& EXEC_P
)
2572 internal_f
.f_flags
|= F_EXEC
;
2574 if (bfd_little_endian (abfd
))
2575 internal_f
.f_flags
|= F_AR32WR
;
2577 internal_f
.f_flags
|= F_AR32W
;
2579 /* Set up the ``optional'' header. */
2580 if ((abfd
->flags
& D_PAGED
) != 0)
2581 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
2583 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
2585 /* FIXME: Is this really correct? */
2586 internal_a
.vstamp
= symhdr
->vstamp
;
2588 /* At least on Ultrix, these have to be rounded to page boundaries.
2589 FIXME: Is this true on other platforms? */
2590 if ((abfd
->flags
& D_PAGED
) != 0)
2592 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
2593 internal_a
.text_start
= text_start
&~ (round
- 1);
2594 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
2595 internal_a
.data_start
= data_start
&~ (round
- 1);
2599 internal_a
.tsize
= text_size
;
2600 internal_a
.text_start
= text_start
;
2601 internal_a
.dsize
= data_size
;
2602 internal_a
.data_start
= data_start
;
2605 /* On Ultrix, the initial portions of the .sbss and .bss segments
2606 are at the end of the data section. The bsize field in the
2607 optional header records how many bss bytes are required beyond
2608 those in the data section. The value is not rounded to a page
2610 if (bss_size
< internal_a
.dsize
- data_size
)
2613 bss_size
-= internal_a
.dsize
- data_size
;
2614 internal_a
.bsize
= bss_size
;
2615 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
2617 internal_a
.entry
= bfd_get_start_address (abfd
);
2619 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
2621 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
2622 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
2623 for (i
= 0; i
< 4; i
++)
2624 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
2626 /* Let the backend adjust the headers if necessary. */
2627 if (backend
->adjust_headers
)
2629 if (! (*backend
->adjust_headers
) (abfd
, &internal_f
, &internal_a
))
2633 /* Write out the file header and the optional header. */
2634 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2637 bfd_coff_swap_filehdr_out (abfd
, (void *) &internal_f
, buff
);
2638 if (bfd_bwrite (buff
, filhsz
, abfd
) != filhsz
)
2641 bfd_coff_swap_aouthdr_out (abfd
, (void *) &internal_a
, buff
);
2642 if (bfd_bwrite (buff
, aoutsz
, abfd
) != aoutsz
)
2645 /* Build the external symbol information. This must be done before
2646 writing out the relocs so that we know the symbol indices. We
2647 don't do this if this BFD was created by the backend linker,
2648 since it will have already handled the symbols and relocs. */
2649 if (! ecoff_data (abfd
)->linker
)
2651 symhdr
->iextMax
= 0;
2652 symhdr
->issExtMax
= 0;
2653 debug
->external_ext
= debug
->external_ext_end
= NULL
;
2654 debug
->ssext
= debug
->ssext_end
= NULL
;
2655 if (! bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
2656 (abfd
->flags
& EXEC_P
) == 0,
2657 ecoff_get_extr
, ecoff_set_index
))
2660 /* Write out the relocs. */
2661 for (current
= abfd
->sections
;
2663 current
= current
->next
)
2665 arelent
**reloc_ptr_ptr
;
2666 arelent
**reloc_end
;
2670 if (current
->reloc_count
== 0)
2673 amt
= current
->reloc_count
* external_reloc_size
;
2674 reloc_buff
= bfd_alloc (abfd
, amt
);
2675 if (reloc_buff
== NULL
)
2678 reloc_ptr_ptr
= current
->orelocation
;
2679 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
2680 out_ptr
= (char *) reloc_buff
;
2683 reloc_ptr_ptr
< reloc_end
;
2684 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
2688 struct internal_reloc in
;
2690 memset ((void *) &in
, 0, sizeof in
);
2692 reloc
= *reloc_ptr_ptr
;
2693 sym
= *reloc
->sym_ptr_ptr
;
2695 /* If the howto field has not been initialised then skip this reloc.
2696 This assumes that an error message has been issued elsewhere. */
2697 if (reloc
->howto
== NULL
)
2700 in
.r_vaddr
= reloc
->address
+ bfd_section_vma (current
);
2701 in
.r_type
= reloc
->howto
->type
;
2703 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2705 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2719 { _TEXT
, RELOC_SECTION_TEXT
},
2720 { _RDATA
, RELOC_SECTION_RDATA
},
2721 { _DATA
, RELOC_SECTION_DATA
},
2722 { _SDATA
, RELOC_SECTION_SDATA
},
2723 { _SBSS
, RELOC_SECTION_SBSS
},
2724 { _BSS
, RELOC_SECTION_BSS
},
2725 { _INIT
, RELOC_SECTION_INIT
},
2726 { _LIT8
, RELOC_SECTION_LIT8
},
2727 { _LIT4
, RELOC_SECTION_LIT4
},
2728 { _XDATA
, RELOC_SECTION_XDATA
},
2729 { _PDATA
, RELOC_SECTION_PDATA
},
2730 { _FINI
, RELOC_SECTION_FINI
},
2731 { _LITA
, RELOC_SECTION_LITA
},
2732 { "*ABS*", RELOC_SECTION_ABS
},
2733 { _RCONST
, RELOC_SECTION_RCONST
}
2736 name
= bfd_section_name (bfd_asymbol_section (sym
));
2738 for (j
= 0; j
< ARRAY_SIZE (section_symndx
); j
++)
2739 if (streq (name
, section_symndx
[j
].name
))
2741 in
.r_symndx
= section_symndx
[j
].r_symndx
;
2745 if (j
== ARRAY_SIZE (section_symndx
))
2750 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2752 (*swap_reloc_out
) (abfd
, &in
, (void *) out_ptr
);
2755 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2757 amt
= current
->reloc_count
* external_reloc_size
;
2758 if (bfd_bwrite (reloc_buff
, amt
, abfd
) != amt
)
2760 bfd_release (abfd
, reloc_buff
);
2764 /* Write out the symbolic debugging information. */
2765 if (bfd_get_symcount (abfd
) > 0)
2767 /* Write out the debugging information. */
2768 if (! bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2769 ecoff_data (abfd
)->sym_filepos
))
2774 /* The .bss section of a demand paged executable must receive an
2775 entire page. If there are symbols, the symbols will start on the
2776 next page. If there are no symbols, we must fill out the page by
2778 if (bfd_get_symcount (abfd
) == 0
2779 && (abfd
->flags
& EXEC_P
) != 0
2780 && (abfd
->flags
& D_PAGED
) != 0)
2784 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2787 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) == 0)
2789 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2792 if (bfd_bwrite (&c
, (bfd_size_type
) 1, abfd
) != 1)
2796 if (reloc_buff
!= NULL
)
2797 bfd_release (abfd
, reloc_buff
);
2802 if (reloc_buff
!= NULL
)
2803 bfd_release (abfd
, reloc_buff
);
2809 /* Archive handling. ECOFF uses what appears to be a unique type of
2810 archive header (armap). The byte ordering of the armap and the
2811 contents are encoded in the name of the armap itself. At least for
2812 now, we only support archives with the same byte ordering in the
2813 armap and the contents.
2815 The first four bytes in the armap are the number of symbol
2816 definitions. This is always a power of two.
2818 This is followed by the symbol definitions. Each symbol definition
2819 occupies 8 bytes. The first four bytes are the offset from the
2820 start of the armap strings to the null-terminated string naming
2821 this symbol. The second four bytes are the file offset to the
2822 archive member which defines this symbol. If the second four bytes
2823 are 0, then this is not actually a symbol definition, and it should
2826 The symbols are hashed into the armap with a closed hashing scheme.
2827 See the functions below for the details of the algorithm.
2829 After the symbol definitions comes four bytes holding the size of
2830 the string table, followed by the string table itself. */
2832 /* The name of an archive headers looks like this:
2833 __________E[BL]E[BL]_ (with a trailing space).
2834 The trailing space is changed to an X if the archive is changed to
2835 indicate that the armap is out of date.
2837 The Alpha seems to use ________64E[BL]E[BL]_. */
2839 #define ARMAP_BIG_ENDIAN 'B'
2840 #define ARMAP_LITTLE_ENDIAN 'L'
2841 #define ARMAP_MARKER 'E'
2842 #define ARMAP_START_LENGTH 10
2843 #define ARMAP_HEADER_MARKER_INDEX 10
2844 #define ARMAP_HEADER_ENDIAN_INDEX 11
2845 #define ARMAP_OBJECT_MARKER_INDEX 12
2846 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2847 #define ARMAP_END_INDEX 14
2848 #define ARMAP_END "_ "
2850 /* This is a magic number used in the hashing algorithm. */
2851 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2853 /* This returns the hash value to use for a string. It also sets
2854 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2855 is the number of entries in the hash table, and HLOG is the log
2859 ecoff_armap_hash (const char *s
,
2860 unsigned int *rehash
,
2870 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2871 hash
*= ARMAP_HASH_MAGIC
;
2872 *rehash
= (hash
& (size
- 1)) | 1;
2873 return hash
>> (32 - hlog
);
2876 /* Read in the armap. */
2879 _bfd_ecoff_slurp_armap (bfd
*abfd
)
2883 struct areltdata
*mapdata
;
2884 bfd_size_type parsed_size
;
2886 struct artdata
*ardata
;
2893 /* Get the name of the first element. */
2894 i
= bfd_bread ((void *) nextname
, (bfd_size_type
) 16, abfd
);
2900 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2903 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2904 standard COFF armap. We could move the ECOFF armap stuff into
2905 bfd_slurp_armap, but that seems inappropriate since no other
2906 target uses this format. Instead, we check directly for a COFF
2908 if (CONST_STRNEQ (nextname
, "/ "))
2909 return bfd_slurp_armap (abfd
);
2911 /* See if the first element is an armap. */
2912 if (! strneq (nextname
, ecoff_backend (abfd
)->armap_start
, ARMAP_START_LENGTH
)
2913 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
2914 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2915 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2916 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
2917 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2918 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2919 || ! strneq (nextname
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1))
2921 abfd
->has_armap
= FALSE
;
2925 /* Make sure we have the right byte ordering. */
2926 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2927 ^ (bfd_header_big_endian (abfd
)))
2928 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2929 ^ (bfd_big_endian (abfd
))))
2931 bfd_set_error (bfd_error_wrong_format
);
2935 /* Read in the armap. */
2936 ardata
= bfd_ardata (abfd
);
2937 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
2938 if (mapdata
== NULL
)
2940 parsed_size
= mapdata
->parsed_size
;
2943 raw_armap
= (char *) _bfd_alloc_and_read (abfd
, parsed_size
, parsed_size
);
2944 if (raw_armap
== NULL
)
2946 if (bfd_get_error () != bfd_error_system_call
)
2947 bfd_set_error (bfd_error_malformed_archive
);
2951 ardata
->tdata
= (void *) raw_armap
;
2953 count
= H_GET_32 (abfd
, raw_armap
);
2955 ardata
->symdef_count
= 0;
2956 ardata
->cache
= NULL
;
2958 /* This code used to overlay the symdefs over the raw archive data,
2959 but that doesn't work on a 64 bit host. */
2960 stringbase
= raw_armap
+ count
* 8 + 8;
2962 #ifdef CHECK_ARMAP_HASH
2966 /* Double check that I have the hashing algorithm right by making
2967 sure that every symbol can be looked up successfully. */
2969 for (i
= 1; i
< count
; i
<<= 1)
2971 BFD_ASSERT (i
== count
);
2973 raw_ptr
= raw_armap
+ 4;
2974 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2976 unsigned int name_offset
, file_offset
;
2977 unsigned int hash
, rehash
, srch
;
2979 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2980 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2981 if (file_offset
== 0)
2983 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
2988 /* See if we can rehash to this location. */
2989 for (srch
= (hash
+ rehash
) & (count
- 1);
2990 srch
!= hash
&& srch
!= i
;
2991 srch
= (srch
+ rehash
) & (count
- 1))
2992 BFD_ASSERT (H_GET_32 (abfd
, (raw_armap
+ 8 + srch
* 8)) != 0);
2993 BFD_ASSERT (srch
== i
);
2997 #endif /* CHECK_ARMAP_HASH */
2999 raw_ptr
= raw_armap
+ 4;
3000 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3001 if (H_GET_32 (abfd
, (raw_ptr
+ 4)) != 0)
3002 ++ardata
->symdef_count
;
3004 amt
= ardata
->symdef_count
;
3005 amt
*= sizeof (carsym
);
3006 symdef_ptr
= (carsym
*) bfd_alloc (abfd
, amt
);
3010 ardata
->symdefs
= symdef_ptr
;
3012 raw_ptr
= raw_armap
+ 4;
3013 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3015 unsigned int name_offset
, file_offset
;
3017 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
3018 if (file_offset
== 0)
3020 name_offset
= H_GET_32 (abfd
, raw_ptr
);
3021 symdef_ptr
->name
= stringbase
+ name_offset
;
3022 symdef_ptr
->file_offset
= file_offset
;
3026 ardata
->first_file_filepos
= bfd_tell (abfd
);
3027 /* Pad to an even boundary. */
3028 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
3030 abfd
->has_armap
= TRUE
;
3035 /* Write out an armap. */
3038 _bfd_ecoff_write_armap (bfd
*abfd
,
3039 unsigned int elength
,
3041 unsigned int orl_count
,
3044 unsigned int hashsize
, hashlog
;
3045 bfd_size_type symdefsize
;
3047 unsigned int stringsize
;
3048 unsigned int mapsize
;
3051 struct stat statbuf
;
3054 bfd_byte
*hashtable
;
3058 /* Ultrix appears to use as a hash table size the least power of two
3059 greater than twice the number of entries. */
3060 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3062 hashsize
= 1 << hashlog
;
3064 symdefsize
= hashsize
* 8;
3066 stringsize
= stridx
+ padit
;
3068 /* Include 8 bytes to store symdefsize and stringsize in output. */
3069 mapsize
= symdefsize
+ stringsize
+ 8;
3071 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3073 memset ((void *) &hdr
, 0, sizeof hdr
);
3075 /* Work out the ECOFF armap name. */
3076 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3077 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3078 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3079 (bfd_header_big_endian (abfd
)
3081 : ARMAP_LITTLE_ENDIAN
);
3082 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3083 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3084 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3085 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3087 /* Write the timestamp of the archive header to be just a little bit
3088 later than the timestamp of the file, otherwise the linker will
3089 complain that the index is out of date. Actually, the Ultrix
3090 linker just checks the archive name; the GNU linker may check the
3092 stat (abfd
->filename
, &statbuf
);
3093 _bfd_ar_spacepad (hdr
.ar_date
, sizeof (hdr
.ar_date
), "%ld",
3094 (long) (statbuf
.st_mtime
+ 60));
3096 /* The DECstation uses zeroes for the uid, gid and mode of the
3098 hdr
.ar_uid
[0] = '0';
3099 hdr
.ar_gid
[0] = '0';
3100 /* Building gcc ends up extracting the armap as a file - twice. */
3101 hdr
.ar_mode
[0] = '6';
3102 hdr
.ar_mode
[1] = '4';
3103 hdr
.ar_mode
[2] = '4';
3105 _bfd_ar_spacepad (hdr
.ar_size
, sizeof (hdr
.ar_size
), "%-10ld", mapsize
);
3107 hdr
.ar_fmag
[0] = '`';
3108 hdr
.ar_fmag
[1] = '\012';
3110 /* Turn all null bytes in the header into spaces. */
3111 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3112 if (((char *) (&hdr
))[i
] == '\0')
3113 (((char *) (&hdr
))[i
]) = ' ';
3115 if (bfd_bwrite ((void *) &hdr
, (bfd_size_type
) sizeof (struct ar_hdr
), abfd
)
3116 != sizeof (struct ar_hdr
))
3119 H_PUT_32 (abfd
, hashsize
, temp
);
3120 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3123 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3127 current
= abfd
->archive_head
;
3129 for (i
= 0; i
< orl_count
; i
++)
3131 unsigned int hash
, rehash
= 0;
3133 /* Advance firstreal to the file position of this archive
3135 if (map
[i
].u
.abfd
!= last_elt
)
3139 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3140 firstreal
+= firstreal
% 2;
3141 current
= current
->archive_next
;
3143 while (current
!= map
[i
].u
.abfd
);
3148 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3149 if (H_GET_32 (abfd
, (hashtable
+ (hash
* 8) + 4)) != 0)
3153 /* The desired slot is already taken. */
3154 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3156 srch
= (srch
+ rehash
) & (hashsize
- 1))
3157 if (H_GET_32 (abfd
, (hashtable
+ (srch
* 8) + 4)) == 0)
3160 BFD_ASSERT (srch
!= hash
);
3165 H_PUT_32 (abfd
, map
[i
].namidx
, (hashtable
+ hash
* 8));
3166 H_PUT_32 (abfd
, firstreal
, (hashtable
+ hash
* 8 + 4));
3169 if (bfd_bwrite ((void *) hashtable
, symdefsize
, abfd
) != symdefsize
)
3172 bfd_release (abfd
, hashtable
);
3174 /* Now write the strings. */
3175 H_PUT_32 (abfd
, stringsize
, temp
);
3176 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3178 for (i
= 0; i
< orl_count
; i
++)
3182 len
= strlen (*map
[i
].name
) + 1;
3183 if (bfd_bwrite ((void *) (*map
[i
].name
), len
, abfd
) != len
)
3187 /* The spec sez this should be a newline. But in order to be
3188 bug-compatible for DECstation ar we use a null. */
3191 if (bfd_bwrite ("", (bfd_size_type
) 1, abfd
) != 1)
3198 /* ECOFF linker code. */
3200 /* Routine to create an entry in an ECOFF link hash table. */
3202 static struct bfd_hash_entry
*
3203 ecoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
3204 struct bfd_hash_table
*table
,
3207 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3209 /* Allocate the structure if it has not already been allocated by a
3212 ret
= ((struct ecoff_link_hash_entry
*)
3213 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3217 /* Call the allocation method of the superclass. */
3218 ret
= ((struct ecoff_link_hash_entry
*)
3219 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3224 /* Set local fields. */
3230 memset ((void *) &ret
->esym
, 0, sizeof ret
->esym
);
3232 return (struct bfd_hash_entry
*) ret
;
3235 /* Create an ECOFF link hash table. */
3237 struct bfd_link_hash_table
*
3238 _bfd_ecoff_bfd_link_hash_table_create (bfd
*abfd
)
3240 struct ecoff_link_hash_table
*ret
;
3241 size_t amt
= sizeof (struct ecoff_link_hash_table
);
3243 ret
= (struct ecoff_link_hash_table
*) bfd_malloc (amt
);
3246 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
,
3247 ecoff_link_hash_newfunc
,
3248 sizeof (struct ecoff_link_hash_entry
)))
3256 /* Look up an entry in an ECOFF link hash table. */
3258 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3259 ((struct ecoff_link_hash_entry *) \
3260 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3262 /* Get the ECOFF link hash table from the info structure. This is
3265 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3267 /* Add the external symbols of an object file to the global linker
3268 hash table. The external symbols and strings we are passed are
3269 just allocated on the stack, and will be discarded. We must
3270 explicitly save any information we may need later on in the link.
3271 We do not want to read the external symbol information again. */
3274 ecoff_link_add_externals (bfd
*abfd
,
3275 struct bfd_link_info
*info
,
3276 void * external_ext
,
3279 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3280 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3281 = backend
->debug_swap
.swap_ext_in
;
3282 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3283 unsigned long ext_count
;
3284 struct bfd_link_hash_entry
**sym_hash
;
3289 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3292 amt
*= sizeof (struct bfd_link_hash_entry
*);
3293 sym_hash
= (struct bfd_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3296 ecoff_data (abfd
)->sym_hashes
= (struct ecoff_link_hash_entry
**) sym_hash
;
3298 ext_ptr
= (char *) external_ext
;
3299 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3300 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3307 struct ecoff_link_hash_entry
*h
;
3311 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3313 /* Skip debugging symbols. */
3315 switch (esym
.asym
.st
)
3331 /* Get the information for this symbol. */
3332 value
= esym
.asym
.value
;
3333 switch (esym
.asym
.sc
)
3353 section
= bfd_make_section_old_way (abfd
, _TEXT
);
3354 value
-= section
->vma
;
3357 section
= bfd_make_section_old_way (abfd
, _DATA
);
3358 value
-= section
->vma
;
3361 section
= bfd_make_section_old_way (abfd
, _BSS
);
3362 value
-= section
->vma
;
3365 section
= bfd_abs_section_ptr
;
3368 section
= bfd_und_section_ptr
;
3371 section
= bfd_make_section_old_way (abfd
, _SDATA
);
3372 value
-= section
->vma
;
3375 section
= bfd_make_section_old_way (abfd
, _SBSS
);
3376 value
-= section
->vma
;
3379 section
= bfd_make_section_old_way (abfd
, _RDATA
);
3380 value
-= section
->vma
;
3383 if (value
> ecoff_data (abfd
)->gp_size
)
3385 section
= bfd_com_section_ptr
;
3390 if (ecoff_scom_section
.name
== NULL
)
3392 /* Initialize the small common section. */
3393 ecoff_scom_section
.name
= SCOMMON
;
3394 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
3395 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
3396 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
3397 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
3398 ecoff_scom_symbol
.name
= SCOMMON
;
3399 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
3400 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
3401 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
3403 section
= &ecoff_scom_section
;
3406 section
= bfd_und_section_ptr
;
3409 section
= bfd_make_section_old_way (abfd
, _INIT
);
3410 value
-= section
->vma
;
3413 section
= bfd_make_section_old_way (abfd
, _FINI
);
3414 value
-= section
->vma
;
3417 section
= bfd_make_section_old_way (abfd
, _RCONST
);
3418 value
-= section
->vma
;
3422 if (section
== NULL
)
3425 name
= ssext
+ esym
.asym
.iss
;
3427 if (! (_bfd_generic_link_add_one_symbol
3429 (flagword
) (esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
),
3430 section
, value
, NULL
, TRUE
, TRUE
, sym_hash
)))
3433 h
= (struct ecoff_link_hash_entry
*) *sym_hash
;
3435 /* If we are building an ECOFF hash table, save the external
3436 symbol information. */
3437 if (bfd_get_flavour (info
->output_bfd
) == bfd_get_flavour (abfd
))
3440 || (! bfd_is_und_section (section
)
3441 && (! bfd_is_com_section (section
)
3442 || (h
->root
.type
!= bfd_link_hash_defined
3443 && h
->root
.type
!= bfd_link_hash_defweak
))))
3449 /* Remember whether this symbol was small undefined. */
3450 if (esym
.asym
.sc
== scSUndefined
)
3453 /* If this symbol was ever small undefined, it needs to wind
3454 up in a GP relative section. We can't control the
3455 section of a defined symbol, but we can control the
3456 section of a common symbol. This case is actually needed
3457 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3459 && h
->root
.type
== bfd_link_hash_common
3460 && streq (h
->root
.u
.c
.p
->section
->name
, SCOMMON
))
3462 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
3464 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
3465 if (h
->esym
.asym
.sc
== scCommon
)
3466 h
->esym
.asym
.sc
= scSCommon
;
3474 /* Add symbols from an ECOFF object file to the global linker hash
3478 ecoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3481 bfd_size_type external_ext_size
;
3482 void * external_ext
= NULL
;
3483 bfd_size_type esize
;
3487 if (! ecoff_slurp_symbolic_header (abfd
))
3490 /* If there are no symbols, we don't want it. */
3491 if (bfd_get_symcount (abfd
) == 0)
3494 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3496 /* Read in the external symbols and external strings. */
3497 if (bfd_seek (abfd
, symhdr
->cbExtOffset
, SEEK_SET
) != 0)
3499 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3500 esize
= symhdr
->iextMax
* external_ext_size
;
3501 external_ext
= _bfd_malloc_and_read (abfd
, esize
, esize
);
3502 if (external_ext
== NULL
&& esize
!= 0)
3505 if (bfd_seek (abfd
, symhdr
->cbSsExtOffset
, SEEK_SET
) != 0)
3507 ssext
= (char *) _bfd_malloc_and_read (abfd
, symhdr
->issExtMax
,
3509 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3512 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3516 if (external_ext
!= NULL
)
3517 free (external_ext
);
3523 if (external_ext
!= NULL
)
3524 free (external_ext
);
3528 /* This is called if we used _bfd_generic_link_add_archive_symbols
3529 because we were not dealing with an ECOFF archive. */
3532 ecoff_link_check_archive_element (bfd
*abfd
,
3533 struct bfd_link_info
*info
,
3534 struct bfd_link_hash_entry
*h
,
3536 bfd_boolean
*pneeded
)
3540 /* Unlike the generic linker, we do not pull in elements because
3541 of common symbols. */
3542 if (h
->type
!= bfd_link_hash_undefined
)
3545 /* Include this element? */
3546 if (!(*info
->callbacks
->add_archive_element
) (info
, abfd
, name
, &abfd
))
3550 return ecoff_link_add_object_symbols (abfd
, info
);
3553 /* Add the symbols from an archive file to the global hash table.
3554 This looks through the undefined symbols, looks each one up in the
3555 archive hash table, and adds any associated object file. We do not
3556 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3557 already have a hash table, so there is no reason to construct
3561 ecoff_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3563 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3564 const bfd_byte
*raw_armap
;
3565 struct bfd_link_hash_entry
**pundef
;
3566 unsigned int armap_count
;
3567 unsigned int armap_log
;
3569 const bfd_byte
*hashtable
;
3570 const char *stringbase
;
3572 if (! bfd_has_map (abfd
))
3574 /* An empty archive is a special case. */
3575 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
3577 bfd_set_error (bfd_error_no_armap
);
3581 /* If we don't have any raw data for this archive, as can happen on
3582 Irix 4.0.5F, we call the generic routine.
3583 FIXME: We should be more clever about this, since someday tdata
3584 may get to something for a generic archive. */
3585 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3586 if (raw_armap
== NULL
)
3587 return (_bfd_generic_link_add_archive_symbols
3588 (abfd
, info
, ecoff_link_check_archive_element
));
3590 armap_count
= H_GET_32 (abfd
, raw_armap
);
3593 for (i
= 1; i
< armap_count
; i
<<= 1)
3595 BFD_ASSERT (i
== armap_count
);
3597 hashtable
= raw_armap
+ 4;
3598 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3600 /* Look through the list of undefined symbols. */
3601 pundef
= &info
->hash
->undefs
;
3602 while (*pundef
!= NULL
)
3604 struct bfd_link_hash_entry
*h
;
3605 unsigned int hash
, rehash
= 0;
3606 unsigned int file_offset
;
3612 /* When a symbol is defined, it is not necessarily removed from
3614 if (h
->type
!= bfd_link_hash_undefined
3615 && h
->type
!= bfd_link_hash_common
)
3617 /* Remove this entry from the list, for general cleanliness
3618 and because we are going to look through the list again
3619 if we search any more libraries. We can't remove the
3620 entry if it is the tail, because that would lose any
3621 entries we add to the list later on. */
3622 if (*pundef
!= info
->hash
->undefs_tail
)
3623 *pundef
= (*pundef
)->u
.undef
.next
;
3625 pundef
= &(*pundef
)->u
.undef
.next
;
3629 /* Native ECOFF linkers do not pull in archive elements merely
3630 to satisfy common definitions, so neither do we. We leave
3631 them on the list, though, in case we are linking against some
3632 other object format. */
3633 if (h
->type
!= bfd_link_hash_undefined
)
3635 pundef
= &(*pundef
)->u
.undef
.next
;
3639 /* Look for this symbol in the archive hash table. */
3640 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3643 file_offset
= H_GET_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3644 if (file_offset
== 0)
3646 /* Nothing in this slot. */
3647 pundef
= &(*pundef
)->u
.undef
.next
;
3651 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (hash
* 8));
3652 if (name
[0] != h
->root
.string
[0]
3653 || ! streq (name
, h
->root
.string
))
3658 /* That was the wrong symbol. Try rehashing. */
3660 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3662 srch
= (srch
+ rehash
) & (armap_count
- 1))
3664 file_offset
= H_GET_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3665 if (file_offset
== 0)
3667 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (srch
* 8));
3668 if (name
[0] == h
->root
.string
[0]
3669 && streq (name
, h
->root
.string
))
3678 pundef
= &(*pundef
)->u
.undef
.next
;
3685 element
= (*backend
->get_elt_at_filepos
) (abfd
, (file_ptr
) file_offset
);
3686 if (element
== NULL
)
3689 if (! bfd_check_format (element
, bfd_object
))
3692 /* Unlike the generic linker, we know that this element provides
3693 a definition for an undefined symbol and we know that we want
3694 to include it. We don't need to check anything. */
3695 if (!(*info
->callbacks
3696 ->add_archive_element
) (info
, element
, name
, &element
))
3698 if (! ecoff_link_add_object_symbols (element
, info
))
3701 pundef
= &(*pundef
)->u
.undef
.next
;
3707 /* Given an ECOFF BFD, add symbols to the global hash table as
3711 _bfd_ecoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3713 switch (bfd_get_format (abfd
))
3716 return ecoff_link_add_object_symbols (abfd
, info
);
3718 return ecoff_link_add_archive_symbols (abfd
, info
);
3720 bfd_set_error (bfd_error_wrong_format
);
3726 /* ECOFF final link routines. */
3728 /* Structure used to pass information to ecoff_link_write_external. */
3733 struct bfd_link_info
*info
;
3736 /* Accumulate the debugging information for an input BFD into the
3737 output BFD. This must read in the symbolic information of the
3741 ecoff_final_link_debug_accumulate (bfd
*output_bfd
,
3743 struct bfd_link_info
*info
,
3746 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
3747 const struct ecoff_debug_swap
* const swap
=
3748 &ecoff_backend (input_bfd
)->debug_swap
;
3749 HDRR
*symhdr
= &debug
->symbolic_header
;
3752 #define READ(ptr, offset, count, size, type) \
3756 debug->ptr = NULL; \
3757 if (symhdr->count == 0) \
3759 if (_bfd_mul_overflow (size, symhdr->count, &amt)) \
3761 bfd_set_error (bfd_error_file_too_big); \
3763 goto return_something; \
3765 if (bfd_seek (input_bfd, symhdr->offset, SEEK_SET) != 0) \
3768 goto return_something; \
3770 debug->ptr = (type) _bfd_malloc_and_read (input_bfd, amt, amt); \
3771 if (debug->ptr == NULL) \
3774 goto return_something; \
3778 /* If raw_syments is not NULL, then the data was already by read by
3779 _bfd_ecoff_slurp_symbolic_info. */
3780 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3782 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
3784 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
3785 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
3786 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
3787 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
3788 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3790 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3791 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
3792 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
3796 /* We do not read the external strings or the external symbols. */
3798 ret
= (bfd_ecoff_debug_accumulate
3799 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
3800 &ecoff_backend (output_bfd
)->debug_swap
,
3801 input_bfd
, debug
, swap
, info
));
3804 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3806 if (debug
->line
!= NULL
)
3808 if (debug
->external_dnr
!= NULL
)
3809 free (debug
->external_dnr
);
3810 if (debug
->external_pdr
!= NULL
)
3811 free (debug
->external_pdr
);
3812 if (debug
->external_sym
!= NULL
)
3813 free (debug
->external_sym
);
3814 if (debug
->external_opt
!= NULL
)
3815 free (debug
->external_opt
);
3816 if (debug
->external_aux
!= NULL
)
3817 free (debug
->external_aux
);
3818 if (debug
->ss
!= NULL
)
3820 if (debug
->external_fdr
!= NULL
)
3821 free (debug
->external_fdr
);
3822 if (debug
->external_rfd
!= NULL
)
3823 free (debug
->external_rfd
);
3825 /* Make sure we don't accidentally follow one of these pointers
3826 into freed memory. */
3828 debug
->external_dnr
= NULL
;
3829 debug
->external_pdr
= NULL
;
3830 debug
->external_sym
= NULL
;
3831 debug
->external_opt
= NULL
;
3832 debug
->external_aux
= NULL
;
3834 debug
->external_fdr
= NULL
;
3835 debug
->external_rfd
= NULL
;
3841 /* Relocate and write an ECOFF section into an ECOFF output file. */
3844 ecoff_indirect_link_order (bfd
*output_bfd
,
3845 struct bfd_link_info
*info
,
3846 asection
*output_section
,
3847 struct bfd_link_order
*link_order
)
3849 asection
*input_section
;
3851 bfd_byte
*contents
= NULL
;
3852 bfd_size_type external_reloc_size
;
3853 bfd_size_type external_relocs_size
;
3854 void * external_relocs
= NULL
;
3856 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
3858 input_section
= link_order
->u
.indirect
.section
;
3859 input_bfd
= input_section
->owner
;
3860 if (input_section
->size
== 0)
3863 BFD_ASSERT (input_section
->output_section
== output_section
);
3864 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
3865 BFD_ASSERT (input_section
->size
== link_order
->size
);
3867 /* Get the section contents. */
3868 if (!bfd_malloc_and_get_section (input_bfd
, input_section
, &contents
))
3871 /* Get the relocs. If we are relaxing MIPS code, they will already
3872 have been read in. Otherwise, we read them in now. */
3873 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
3874 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
3876 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0)
3878 external_relocs
= _bfd_malloc_and_read (input_bfd
, external_relocs_size
,
3879 external_relocs_size
);
3880 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
3883 /* Relocate the section contents. */
3884 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
3885 (output_bfd
, info
, input_bfd
, input_section
, contents
,
3889 /* Write out the relocated section. */
3890 if (! bfd_set_section_contents (output_bfd
,
3893 input_section
->output_offset
,
3894 input_section
->size
))
3897 /* If we are producing relocatable output, the relocs were
3898 modified, and we write them out now. We use the reloc_count
3899 field of output_section to keep track of the number of relocs we
3900 have output so far. */
3901 if (bfd_link_relocatable (info
))
3903 file_ptr pos
= (output_section
->rel_filepos
3904 + output_section
->reloc_count
* external_reloc_size
);
3905 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
3906 || (bfd_bwrite (external_relocs
, external_relocs_size
, output_bfd
)
3907 != external_relocs_size
))
3909 output_section
->reloc_count
+= input_section
->reloc_count
;
3912 if (contents
!= NULL
)
3914 if (external_relocs
!= NULL
)
3915 free (external_relocs
);
3919 if (contents
!= NULL
)
3921 if (external_relocs
!= NULL
)
3922 free (external_relocs
);
3926 /* Generate a reloc when linking an ECOFF file. This is a reloc
3927 requested by the linker, and does come from any input file. This
3928 is used to build constructor and destructor tables when linking
3932 ecoff_reloc_link_order (bfd
*output_bfd
,
3933 struct bfd_link_info
*info
,
3934 asection
*output_section
,
3935 struct bfd_link_order
*link_order
)
3937 enum bfd_link_order_type type
;
3941 struct internal_reloc in
;
3942 bfd_size_type external_reloc_size
;
3947 type
= link_order
->type
;
3949 addend
= link_order
->u
.reloc
.p
->addend
;
3951 /* We set up an arelent to pass to the backend adjust_reloc_out
3953 rel
.address
= link_order
->offset
;
3955 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3958 bfd_set_error (bfd_error_bad_value
);
3962 if (type
== bfd_section_reloc_link_order
)
3964 section
= link_order
->u
.reloc
.p
->u
.section
;
3965 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
3969 struct bfd_link_hash_entry
*h
;
3971 /* Treat a reloc against a defined symbol as though it were
3972 actually against the section. */
3973 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3974 link_order
->u
.reloc
.p
->u
.name
,
3975 FALSE
, FALSE
, FALSE
);
3977 && (h
->type
== bfd_link_hash_defined
3978 || h
->type
== bfd_link_hash_defweak
))
3980 type
= bfd_section_reloc_link_order
;
3981 section
= h
->u
.def
.section
->output_section
;
3982 /* It seems that we ought to add the symbol value to the
3983 addend here, but in practice it has already been added
3984 because it was passed to constructor_callback. */
3985 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
3989 /* We can't set up a reloc against a symbol correctly,
3990 because we have no asymbol structure. Currently no
3991 adjust_reloc_out routine cares. */
3992 rel
.sym_ptr_ptr
= NULL
;
3996 /* All ECOFF relocs are in-place. Put the addend into the object
3999 BFD_ASSERT (rel
.howto
->partial_inplace
);
4003 bfd_reloc_status_type rstat
;
4006 size
= bfd_get_reloc_size (rel
.howto
);
4007 buf
= (bfd_byte
*) bfd_zmalloc (size
);
4008 if (buf
== NULL
&& size
!= 0)
4010 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
4011 (bfd_vma
) addend
, buf
);
4017 case bfd_reloc_outofrange
:
4019 case bfd_reloc_overflow
:
4020 (*info
->callbacks
->reloc_overflow
)
4022 (link_order
->type
== bfd_section_reloc_link_order
4023 ? bfd_section_name (section
)
4024 : link_order
->u
.reloc
.p
->u
.name
),
4025 rel
.howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0);
4028 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
4029 (file_ptr
) link_order
->offset
, size
);
4037 /* Move the information into an internal_reloc structure. */
4038 in
.r_vaddr
= rel
.address
+ bfd_section_vma (output_section
);
4039 in
.r_type
= rel
.howto
->type
;
4041 if (type
== bfd_symbol_reloc_link_order
)
4043 struct ecoff_link_hash_entry
*h
;
4045 h
= ((struct ecoff_link_hash_entry
*)
4046 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4047 link_order
->u
.reloc
.p
->u
.name
,
4048 FALSE
, FALSE
, TRUE
));
4051 in
.r_symndx
= h
->indx
;
4054 (*info
->callbacks
->unattached_reloc
)
4055 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
4071 { _TEXT
, RELOC_SECTION_TEXT
},
4072 { _RDATA
, RELOC_SECTION_RDATA
},
4073 { _DATA
, RELOC_SECTION_DATA
},
4074 { _SDATA
, RELOC_SECTION_SDATA
},
4075 { _SBSS
, RELOC_SECTION_SBSS
},
4076 { _BSS
, RELOC_SECTION_BSS
},
4077 { _INIT
, RELOC_SECTION_INIT
},
4078 { _LIT8
, RELOC_SECTION_LIT8
},
4079 { _LIT4
, RELOC_SECTION_LIT4
},
4080 { _XDATA
, RELOC_SECTION_XDATA
},
4081 { _PDATA
, RELOC_SECTION_PDATA
},
4082 { _FINI
, RELOC_SECTION_FINI
},
4083 { _LITA
, RELOC_SECTION_LITA
},
4084 { "*ABS*", RELOC_SECTION_ABS
},
4085 { _RCONST
, RELOC_SECTION_RCONST
}
4088 name
= bfd_section_name (section
);
4090 for (i
= 0; i
< ARRAY_SIZE (section_symndx
); i
++)
4091 if (streq (name
, section_symndx
[i
].name
))
4093 in
.r_symndx
= section_symndx
[i
].r_symndx
;
4097 if (i
== ARRAY_SIZE (section_symndx
))
4103 /* Let the BFD backend adjust the reloc. */
4104 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4106 /* Get some memory and swap out the reloc. */
4107 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4108 rbuf
= (bfd_byte
*) bfd_malloc (external_reloc_size
);
4112 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (void *) rbuf
);
4114 pos
= (output_section
->rel_filepos
4115 + output_section
->reloc_count
* external_reloc_size
);
4116 ok
= (bfd_seek (output_bfd
, pos
, SEEK_SET
) == 0
4117 && (bfd_bwrite ((void *) rbuf
, external_reloc_size
, output_bfd
)
4118 == external_reloc_size
));
4121 ++output_section
->reloc_count
;
4128 /* Put out information for an external symbol. These come only from
4132 ecoff_link_write_external (struct bfd_hash_entry
*bh
, void * data
)
4134 struct ecoff_link_hash_entry
*h
= (struct ecoff_link_hash_entry
*) bh
;
4135 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4136 bfd
*output_bfd
= einfo
->abfd
;
4139 if (h
->root
.type
== bfd_link_hash_warning
)
4141 h
= (struct ecoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4142 if (h
->root
.type
== bfd_link_hash_new
)
4146 /* We need to check if this symbol is being stripped. */
4147 if (h
->root
.type
== bfd_link_hash_undefined
4148 || h
->root
.type
== bfd_link_hash_undefweak
)
4150 else if (einfo
->info
->strip
== strip_all
4151 || (einfo
->info
->strip
== strip_some
4152 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4153 h
->root
.root
.string
,
4154 FALSE
, FALSE
) == NULL
))
4159 if (strip
|| h
->written
)
4162 if (h
->abfd
== NULL
)
4165 h
->esym
.cobol_main
= 0;
4166 h
->esym
.weakext
= 0;
4167 h
->esym
.reserved
= 0;
4168 h
->esym
.ifd
= ifdNil
;
4169 h
->esym
.asym
.value
= 0;
4170 h
->esym
.asym
.st
= stGlobal
;
4172 if (h
->root
.type
!= bfd_link_hash_defined
4173 && h
->root
.type
!= bfd_link_hash_defweak
)
4174 h
->esym
.asym
.sc
= scAbs
;
4177 asection
*output_section
;
4185 section_storage_classes
[] =
4189 { _SDATA
, scSData
},
4190 { _RDATA
, scRData
},
4195 { _PDATA
, scPData
},
4196 { _XDATA
, scXData
},
4197 { _RCONST
, scRConst
}
4200 output_section
= h
->root
.u
.def
.section
->output_section
;
4201 name
= bfd_section_name (output_section
);
4203 for (i
= 0; i
< ARRAY_SIZE (section_storage_classes
); i
++)
4204 if (streq (name
, section_storage_classes
[i
].name
))
4206 h
->esym
.asym
.sc
= section_storage_classes
[i
].sc
;
4210 if (i
== ARRAY_SIZE (section_storage_classes
))
4211 h
->esym
.asym
.sc
= scAbs
;
4214 h
->esym
.asym
.reserved
= 0;
4215 h
->esym
.asym
.index
= indexNil
;
4217 else if (h
->esym
.ifd
!= -1)
4219 struct ecoff_debug_info
*debug
;
4221 /* Adjust the FDR index for the symbol by that used for the
4223 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4224 BFD_ASSERT (h
->esym
.ifd
>= 0
4225 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4226 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4229 switch (h
->root
.type
)
4232 case bfd_link_hash_warning
:
4233 case bfd_link_hash_new
:
4235 case bfd_link_hash_undefined
:
4236 case bfd_link_hash_undefweak
:
4237 if (h
->esym
.asym
.sc
!= scUndefined
4238 && h
->esym
.asym
.sc
!= scSUndefined
)
4239 h
->esym
.asym
.sc
= scUndefined
;
4241 case bfd_link_hash_defined
:
4242 case bfd_link_hash_defweak
:
4243 if (h
->esym
.asym
.sc
== scUndefined
4244 || h
->esym
.asym
.sc
== scSUndefined
)
4245 h
->esym
.asym
.sc
= scAbs
;
4246 else if (h
->esym
.asym
.sc
== scCommon
)
4247 h
->esym
.asym
.sc
= scBss
;
4248 else if (h
->esym
.asym
.sc
== scSCommon
)
4249 h
->esym
.asym
.sc
= scSBss
;
4250 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4251 + h
->root
.u
.def
.section
->output_section
->vma
4252 + h
->root
.u
.def
.section
->output_offset
);
4254 case bfd_link_hash_common
:
4255 if (h
->esym
.asym
.sc
!= scCommon
4256 && h
->esym
.asym
.sc
!= scSCommon
)
4257 h
->esym
.asym
.sc
= scCommon
;
4258 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4260 case bfd_link_hash_indirect
:
4261 /* We ignore these symbols, since the indirected symbol is
4262 already in the hash table. */
4266 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4268 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4271 return (bfd_ecoff_debug_one_external
4272 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4273 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4277 /* ECOFF final link routine. This looks through all the input BFDs
4278 and gathers together all the debugging information, and then
4279 processes all the link order information. This may cause it to
4280 close and reopen some input BFDs; I'll see how bad this is. */
4283 _bfd_ecoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
4285 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4286 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4291 struct bfd_link_order
*p
;
4292 struct extsym_info einfo
;
4294 /* We accumulate the debugging information counts in the symbolic
4296 symhdr
= &debug
->symbolic_header
;
4298 symhdr
->ilineMax
= 0;
4302 symhdr
->isymMax
= 0;
4303 symhdr
->ioptMax
= 0;
4304 symhdr
->iauxMax
= 0;
4306 symhdr
->issExtMax
= 0;
4309 symhdr
->iextMax
= 0;
4311 /* We accumulate the debugging information itself in the debug_info
4314 debug
->external_dnr
= NULL
;
4315 debug
->external_pdr
= NULL
;
4316 debug
->external_sym
= NULL
;
4317 debug
->external_opt
= NULL
;
4318 debug
->external_aux
= NULL
;
4320 debug
->ssext
= debug
->ssext_end
= NULL
;
4321 debug
->external_fdr
= NULL
;
4322 debug
->external_rfd
= NULL
;
4323 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4325 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4329 /* Accumulate the debugging symbols from each input BFD. */
4330 for (input_bfd
= info
->input_bfds
;
4332 input_bfd
= input_bfd
->link
.next
)
4336 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4338 /* Arbitrarily set the symbolic header vstamp to the vstamp
4339 of the first object file in the link. */
4340 if (symhdr
->vstamp
== 0)
4342 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4343 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4347 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4348 debug
, &backend
->debug_swap
,
4353 /* Combine the register masks. */
4354 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4355 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4356 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4357 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4358 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4359 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4362 /* Write out the external symbols. */
4365 bfd_hash_traverse (&info
->hash
->table
, ecoff_link_write_external
, &einfo
);
4367 if (bfd_link_relocatable (info
))
4369 /* We need to make a pass over the link_orders to count up the
4370 number of relocations we will need to output, so that we know
4371 how much space they will take up. */
4372 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4375 for (p
= o
->map_head
.link_order
;
4378 if (p
->type
== bfd_indirect_link_order
)
4379 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4380 else if (p
->type
== bfd_section_reloc_link_order
4381 || p
->type
== bfd_symbol_reloc_link_order
)
4386 /* Compute the reloc and symbol file positions. */
4387 ecoff_compute_reloc_file_positions (abfd
);
4389 /* Write out the debugging information. */
4390 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4391 &backend
->debug_swap
, info
,
4392 ecoff_data (abfd
)->sym_filepos
))
4395 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4397 if (bfd_link_relocatable (info
))
4399 /* Now reset the reloc_count field of the sections in the output
4400 BFD to 0, so that we can use them to keep track of how many
4401 relocs we have output thus far. */
4402 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4406 /* Get a value for the GP register. */
4407 if (ecoff_data (abfd
)->gp
== 0)
4409 struct bfd_link_hash_entry
*h
;
4411 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
4413 && h
->type
== bfd_link_hash_defined
)
4414 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4415 + h
->u
.def
.section
->output_section
->vma
4416 + h
->u
.def
.section
->output_offset
);
4417 else if (bfd_link_relocatable (info
))
4421 /* Make up a value. */
4423 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4426 && (streq (o
->name
, _SBSS
)
4427 || streq (o
->name
, _SDATA
)
4428 || streq (o
->name
, _LIT4
)
4429 || streq (o
->name
, _LIT8
)
4430 || streq (o
->name
, _LITA
)))
4433 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4437 /* If the relocate_section function needs to do a reloc
4438 involving the GP value, it should make a reloc_dangerous
4439 callback to warn that GP is not defined. */
4443 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4445 for (p
= o
->map_head
.link_order
;
4449 if (p
->type
== bfd_indirect_link_order
4450 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4451 == bfd_target_ecoff_flavour
))
4453 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4456 else if (p
->type
== bfd_section_reloc_link_order
4457 || p
->type
== bfd_symbol_reloc_link_order
)
4459 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4464 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4470 abfd
->symcount
= symhdr
->iextMax
+ symhdr
->isymMax
;
4472 ecoff_data (abfd
)->linker
= TRUE
;