1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright (C) 1990-2014 Free Software Foundation, Inc.
3 Original version by Per Bothner.
4 Full support added by Ian Lance Taylor, ian@cygnus.com.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
28 #include "aout/stab_gnu.h"
30 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
31 some other stuff which we don't want and which conflicts with stuff
34 #include "aout/aout64.h"
37 #undef obj_sym_filepos
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
45 #include "libiberty.h"
47 #define streq(a, b) (strcmp ((a), (b)) == 0)
48 #define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0)
51 /* This stuff is somewhat copied from coffcode.h. */
52 static asection bfd_debug_section
=
54 /* name, id, index, next, prev, flags, user_set_vma, */
55 "*DEBUG*", 0, 0, NULL
, NULL
, 0, 0,
56 /* linker_mark, linker_has_input, gc_mark, compress_status, */
58 /* segment_mark, sec_info_type, use_rela_p, */
60 /* sec_flg0, sec_flg1, sec_flg2, sec_flg3, sec_flg4, sec_flg5, */
62 /* vma, lma, size, rawsize, compressed_size, relax, relax_count, */
64 /* output_offset, output_section, alignment_power, */
66 /* relocation, orelocation, reloc_count, filepos, rel_filepos, */
68 /* line_filepos, userdata, contents, lineno, lineno_count, */
69 0, NULL
, NULL
, NULL
, 0,
70 /* entsize, kept_section, moving_line_filepos, */
72 /* target_index, used_by_bfd, constructor_chain, owner, */
78 /* map_head, map_tail */
82 /* Create an ECOFF object. */
85 _bfd_ecoff_mkobject (bfd
*abfd
)
87 bfd_size_type amt
= sizeof (ecoff_data_type
);
89 abfd
->tdata
.ecoff_obj_data
= (struct ecoff_tdata
*) bfd_zalloc (abfd
, amt
);
90 if (abfd
->tdata
.ecoff_obj_data
== NULL
)
96 /* This is a hook called by coff_real_object_p to create any backend
97 specific information. */
100 _bfd_ecoff_mkobject_hook (bfd
*abfd
, void * filehdr
, void * aouthdr
)
102 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
103 struct internal_aouthdr
*internal_a
= (struct internal_aouthdr
*) aouthdr
;
104 ecoff_data_type
*ecoff
;
106 if (! _bfd_ecoff_mkobject (abfd
))
109 ecoff
= ecoff_data (abfd
);
111 ecoff
->sym_filepos
= internal_f
->f_symptr
;
113 if (internal_a
!= NULL
)
117 ecoff
->text_start
= internal_a
->text_start
;
118 ecoff
->text_end
= internal_a
->text_start
+ internal_a
->tsize
;
119 ecoff
->gp
= internal_a
->gp_value
;
120 ecoff
->gprmask
= internal_a
->gprmask
;
121 for (i
= 0; i
< 4; i
++)
122 ecoff
->cprmask
[i
] = internal_a
->cprmask
[i
];
123 ecoff
->fprmask
= internal_a
->fprmask
;
124 if (internal_a
->magic
== ECOFF_AOUT_ZMAGIC
)
125 abfd
->flags
|= D_PAGED
;
127 abfd
->flags
&=~ D_PAGED
;
130 /* It turns out that no special action is required by the MIPS or
131 Alpha ECOFF backends. They have different information in the
132 a.out header, but we just copy it all (e.g., gprmask, cprmask and
133 fprmask) and let the swapping routines ensure that only relevant
134 information is written out. */
136 return (void *) ecoff
;
139 /* Initialize a new section. */
142 _bfd_ecoff_new_section_hook (bfd
*abfd
, asection
*section
)
152 { _TEXT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
153 { _INIT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
154 { _FINI
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
155 { _DATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
},
156 { _SDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
},
157 { _RDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
158 { _LIT8
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
159 { _LIT4
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
160 { _RCONST
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
161 { _PDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
164 /* An Irix 4 shared libary. */
165 { _LIB
, SEC_COFF_SHARED_LIBRARY
}
168 section
->alignment_power
= 4;
170 for (i
= 0; i
< ARRAY_SIZE (section_flags
); i
++)
171 if (streq (section
->name
, section_flags
[i
].name
))
173 section
->flags
|= section_flags
[i
].flags
;
178 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
179 uncertain about .init on some systems and I don't know how shared
182 return _bfd_generic_new_section_hook (abfd
, section
);
185 /* Determine the machine architecture and type. This is called from
186 the generic COFF routines. It is the inverse of ecoff_get_magic,
187 below. This could be an ECOFF backend routine, with one version
188 for each target, but there aren't all that many ECOFF targets. */
191 _bfd_ecoff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
193 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
194 enum bfd_architecture arch
;
197 switch (internal_f
->f_magic
)
200 case MIPS_MAGIC_LITTLE
:
202 arch
= bfd_arch_mips
;
203 mach
= bfd_mach_mips3000
;
206 case MIPS_MAGIC_LITTLE2
:
207 case MIPS_MAGIC_BIG2
:
208 /* MIPS ISA level 2: the r6000. */
209 arch
= bfd_arch_mips
;
210 mach
= bfd_mach_mips6000
;
213 case MIPS_MAGIC_LITTLE3
:
214 case MIPS_MAGIC_BIG3
:
215 /* MIPS ISA level 3: the r4000. */
216 arch
= bfd_arch_mips
;
217 mach
= bfd_mach_mips4000
;
221 arch
= bfd_arch_alpha
;
226 arch
= bfd_arch_obscure
;
231 return bfd_default_set_arch_mach (abfd
, arch
, mach
);
235 _bfd_ecoff_no_long_sections (bfd
*abfd
, int enable
)
242 /* Get the magic number to use based on the architecture and machine.
243 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
246 ecoff_get_magic (bfd
*abfd
)
250 switch (bfd_get_arch (abfd
))
253 switch (bfd_get_mach (abfd
))
257 case bfd_mach_mips3000
:
258 big
= MIPS_MAGIC_BIG
;
259 little
= MIPS_MAGIC_LITTLE
;
262 case bfd_mach_mips6000
:
263 big
= MIPS_MAGIC_BIG2
;
264 little
= MIPS_MAGIC_LITTLE2
;
267 case bfd_mach_mips4000
:
268 big
= MIPS_MAGIC_BIG3
;
269 little
= MIPS_MAGIC_LITTLE3
;
273 return bfd_big_endian (abfd
) ? big
: little
;
284 /* Get the section s_flags to use for a section. */
287 ecoff_sec_to_styp_flags (const char *name
, flagword flags
)
297 { _TEXT
, STYP_TEXT
},
298 { _DATA
, STYP_DATA
},
299 { _SDATA
, STYP_SDATA
},
300 { _RDATA
, STYP_RDATA
},
301 { _LITA
, STYP_LITA
},
302 { _LIT8
, STYP_LIT8
},
303 { _LIT4
, STYP_LIT4
},
305 { _SBSS
, STYP_SBSS
},
306 { _INIT
, STYP_ECOFF_INIT
},
307 { _FINI
, STYP_ECOFF_FINI
},
308 { _PDATA
, STYP_PDATA
},
309 { _XDATA
, STYP_XDATA
},
310 { _LIB
, STYP_ECOFF_LIB
},
312 { _HASH
, STYP_HASH
},
313 { _DYNAMIC
, STYP_DYNAMIC
},
314 { _LIBLIST
, STYP_LIBLIST
},
315 { _RELDYN
, STYP_RELDYN
},
316 { _CONFLIC
, STYP_CONFLIC
},
317 { _DYNSTR
, STYP_DYNSTR
},
318 { _DYNSYM
, STYP_DYNSYM
},
319 { _RCONST
, STYP_RCONST
}
323 for (i
= 0; i
< ARRAY_SIZE (styp_flags
); i
++)
324 if (streq (name
, styp_flags
[i
].name
))
326 styp
= styp_flags
[i
].flags
;
332 if (streq (name
, _COMMENT
))
335 flags
&=~ SEC_NEVER_LOAD
;
337 else if (flags
& SEC_CODE
)
339 else if (flags
& SEC_DATA
)
341 else if (flags
& SEC_READONLY
)
343 else if (flags
& SEC_LOAD
)
349 if (flags
& SEC_NEVER_LOAD
)
355 /* Get the BFD flags to use for a section. */
358 _bfd_ecoff_styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
360 const char *name ATTRIBUTE_UNUSED
,
361 asection
*section ATTRIBUTE_UNUSED
,
362 flagword
* flags_ptr
)
364 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
365 long styp_flags
= internal_s
->s_flags
;
366 flagword sec_flags
= 0;
368 if (styp_flags
& STYP_NOLOAD
)
369 sec_flags
|= SEC_NEVER_LOAD
;
371 /* For 386 COFF, at least, an unloadable text or data section is
372 actually a shared library section. */
373 if ((styp_flags
& STYP_TEXT
)
374 || (styp_flags
& STYP_ECOFF_INIT
)
375 || (styp_flags
& STYP_ECOFF_FINI
)
376 || (styp_flags
& STYP_DYNAMIC
)
377 || (styp_flags
& STYP_LIBLIST
)
378 || (styp_flags
& STYP_RELDYN
)
379 || styp_flags
== STYP_CONFLIC
380 || (styp_flags
& STYP_DYNSTR
)
381 || (styp_flags
& STYP_DYNSYM
)
382 || (styp_flags
& STYP_HASH
))
384 if (sec_flags
& SEC_NEVER_LOAD
)
385 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
387 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
389 else if ((styp_flags
& STYP_DATA
)
390 || (styp_flags
& STYP_RDATA
)
391 || (styp_flags
& STYP_SDATA
)
392 || styp_flags
== STYP_PDATA
393 || styp_flags
== STYP_XDATA
394 || (styp_flags
& STYP_GOT
)
395 || styp_flags
== STYP_RCONST
)
397 if (sec_flags
& SEC_NEVER_LOAD
)
398 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
400 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
401 if ((styp_flags
& STYP_RDATA
)
402 || styp_flags
== STYP_PDATA
403 || styp_flags
== STYP_RCONST
)
404 sec_flags
|= SEC_READONLY
;
406 else if ((styp_flags
& STYP_BSS
)
407 || (styp_flags
& STYP_SBSS
))
408 sec_flags
|= SEC_ALLOC
;
409 else if ((styp_flags
& STYP_INFO
) || styp_flags
== STYP_COMMENT
)
410 sec_flags
|= SEC_NEVER_LOAD
;
411 else if ((styp_flags
& STYP_LITA
)
412 || (styp_flags
& STYP_LIT8
)
413 || (styp_flags
& STYP_LIT4
))
414 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
415 else if (styp_flags
& STYP_ECOFF_LIB
)
416 sec_flags
|= SEC_COFF_SHARED_LIBRARY
;
418 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
420 * flags_ptr
= sec_flags
;
424 /* Read in the symbolic header for an ECOFF object file. */
427 ecoff_slurp_symbolic_header (bfd
*abfd
)
429 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
430 bfd_size_type external_hdr_size
;
432 HDRR
*internal_symhdr
;
434 /* See if we've already read it in. */
435 if (ecoff_data (abfd
)->debug_info
.symbolic_header
.magic
==
436 backend
->debug_swap
.sym_magic
)
439 /* See whether there is a symbolic header. */
440 if (ecoff_data (abfd
)->sym_filepos
== 0)
442 bfd_get_symcount (abfd
) = 0;
446 /* At this point bfd_get_symcount (abfd) holds the number of symbols
447 as read from the file header, but on ECOFF this is always the
448 size of the symbolic information header. It would be cleaner to
449 handle this when we first read the file in coffgen.c. */
450 external_hdr_size
= backend
->debug_swap
.external_hdr_size
;
451 if (bfd_get_symcount (abfd
) != external_hdr_size
)
453 bfd_set_error (bfd_error_bad_value
);
457 /* Read the symbolic information header. */
458 raw
= bfd_malloc (external_hdr_size
);
462 if (bfd_seek (abfd
, ecoff_data (abfd
)->sym_filepos
, SEEK_SET
) != 0
463 || bfd_bread (raw
, external_hdr_size
, abfd
) != external_hdr_size
)
465 internal_symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
466 (*backend
->debug_swap
.swap_hdr_in
) (abfd
, raw
, internal_symhdr
);
468 if (internal_symhdr
->magic
!= backend
->debug_swap
.sym_magic
)
470 bfd_set_error (bfd_error_bad_value
);
474 /* Now we can get the correct number of symbols. */
475 bfd_get_symcount (abfd
) = (internal_symhdr
->isymMax
476 + internal_symhdr
->iextMax
);
487 /* Read in and swap the important symbolic information for an ECOFF
488 object file. This is called by gdb via the read_debug_info entry
489 point in the backend structure. */
492 _bfd_ecoff_slurp_symbolic_info (bfd
*abfd
,
493 asection
*ignore ATTRIBUTE_UNUSED
,
494 struct ecoff_debug_info
*debug
)
496 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
497 HDRR
*internal_symhdr
;
498 bfd_size_type raw_base
;
499 bfd_size_type raw_size
;
501 bfd_size_type external_fdr_size
;
505 bfd_size_type raw_end
;
506 bfd_size_type cb_end
;
510 BFD_ASSERT (debug
== &ecoff_data (abfd
)->debug_info
);
512 /* Check whether we've already gotten it, and whether there's any to
514 if (ecoff_data (abfd
)->raw_syments
!= NULL
)
516 if (ecoff_data (abfd
)->sym_filepos
== 0)
518 bfd_get_symcount (abfd
) = 0;
522 if (! ecoff_slurp_symbolic_header (abfd
))
525 internal_symhdr
= &debug
->symbolic_header
;
527 /* Read all the symbolic information at once. */
528 raw_base
= (ecoff_data (abfd
)->sym_filepos
529 + backend
->debug_swap
.external_hdr_size
);
531 /* Alpha ecoff makes the determination of raw_size difficult. It has
532 an undocumented debug data section between the symhdr and the first
533 documented section. And the ordering of the sections varies between
534 statically and dynamically linked executables.
535 If bfd supports SEEK_END someday, this code could be simplified. */
538 #define UPDATE_RAW_END(start, count, size) \
539 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
540 if (cb_end > raw_end) \
543 UPDATE_RAW_END (cbLineOffset
, cbLine
, sizeof (unsigned char));
544 UPDATE_RAW_END (cbDnOffset
, idnMax
, backend
->debug_swap
.external_dnr_size
);
545 UPDATE_RAW_END (cbPdOffset
, ipdMax
, backend
->debug_swap
.external_pdr_size
);
546 UPDATE_RAW_END (cbSymOffset
, isymMax
, backend
->debug_swap
.external_sym_size
);
547 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
548 optimization symtab, not the number of entries. */
549 UPDATE_RAW_END (cbOptOffset
, ioptMax
, sizeof (char));
550 UPDATE_RAW_END (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
551 UPDATE_RAW_END (cbSsOffset
, issMax
, sizeof (char));
552 UPDATE_RAW_END (cbSsExtOffset
, issExtMax
, sizeof (char));
553 UPDATE_RAW_END (cbFdOffset
, ifdMax
, backend
->debug_swap
.external_fdr_size
);
554 UPDATE_RAW_END (cbRfdOffset
, crfd
, backend
->debug_swap
.external_rfd_size
);
555 UPDATE_RAW_END (cbExtOffset
, iextMax
, backend
->debug_swap
.external_ext_size
);
557 #undef UPDATE_RAW_END
559 raw_size
= raw_end
- raw_base
;
562 ecoff_data (abfd
)->sym_filepos
= 0;
565 raw
= bfd_alloc (abfd
, raw_size
);
569 pos
= ecoff_data (abfd
)->sym_filepos
;
570 pos
+= backend
->debug_swap
.external_hdr_size
;
571 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
572 || bfd_bread (raw
, raw_size
, abfd
) != raw_size
)
574 bfd_release (abfd
, raw
);
578 ecoff_data (abfd
)->raw_syments
= raw
;
580 /* Get pointers for the numeric offsets in the HDRR structure. */
581 #define FIX(off1, off2, type) \
582 if (internal_symhdr->off1 == 0) \
583 debug->off2 = NULL; \
585 debug->off2 = (type) ((char *) raw \
586 + (internal_symhdr->off1 \
589 FIX (cbLineOffset
, line
, unsigned char *);
590 FIX (cbDnOffset
, external_dnr
, void *);
591 FIX (cbPdOffset
, external_pdr
, void *);
592 FIX (cbSymOffset
, external_sym
, void *);
593 FIX (cbOptOffset
, external_opt
, void *);
594 FIX (cbAuxOffset
, external_aux
, union aux_ext
*);
595 FIX (cbSsOffset
, ss
, char *);
596 FIX (cbSsExtOffset
, ssext
, char *);
597 FIX (cbFdOffset
, external_fdr
, void *);
598 FIX (cbRfdOffset
, external_rfd
, void *);
599 FIX (cbExtOffset
, external_ext
, void *);
602 /* I don't want to always swap all the data, because it will just
603 waste time and most programs will never look at it. The only
604 time the linker needs most of the debugging information swapped
605 is when linking big-endian and little-endian MIPS object files
606 together, which is not a common occurrence.
608 We need to look at the fdr to deal with a lot of information in
609 the symbols, so we swap them here. */
610 amt
= internal_symhdr
->ifdMax
;
611 amt
*= sizeof (struct fdr
);
612 debug
->fdr
= (FDR
*) bfd_alloc (abfd
, amt
);
613 if (debug
->fdr
== NULL
)
615 external_fdr_size
= backend
->debug_swap
.external_fdr_size
;
616 fdr_ptr
= debug
->fdr
;
617 fraw_src
= (char *) debug
->external_fdr
;
618 fraw_end
= fraw_src
+ internal_symhdr
->ifdMax
* external_fdr_size
;
619 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
620 (*backend
->debug_swap
.swap_fdr_in
) (abfd
, (void *) fraw_src
, fdr_ptr
);
625 /* ECOFF symbol table routines. The ECOFF symbol table is described
626 in gcc/mips-tfile.c. */
628 /* ECOFF uses two common sections. One is the usual one, and the
629 other is for small objects. All the small objects are kept
630 together, and then referenced via the gp pointer, which yields
631 faster assembler code. This is what we use for the small common
633 static asection ecoff_scom_section
;
634 static asymbol ecoff_scom_symbol
;
635 static asymbol
*ecoff_scom_symbol_ptr
;
637 /* Create an empty symbol. */
640 _bfd_ecoff_make_empty_symbol (bfd
*abfd
)
642 ecoff_symbol_type
*new_symbol
;
643 bfd_size_type amt
= sizeof (ecoff_symbol_type
);
645 new_symbol
= (ecoff_symbol_type
*) bfd_zalloc (abfd
, amt
);
646 if (new_symbol
== NULL
)
648 new_symbol
->symbol
.section
= NULL
;
649 new_symbol
->fdr
= NULL
;
650 new_symbol
->local
= FALSE
;
651 new_symbol
->native
= NULL
;
652 new_symbol
->symbol
.the_bfd
= abfd
;
653 return &new_symbol
->symbol
;
656 /* Set the BFD flags and section for an ECOFF symbol. */
659 ecoff_set_symbol_info (bfd
*abfd
,
665 asym
->the_bfd
= abfd
;
666 asym
->value
= ecoff_sym
->value
;
667 asym
->section
= &bfd_debug_section
;
670 /* Most symbol types are just for debugging. */
671 switch (ecoff_sym
->st
)
680 if (ECOFF_IS_STAB (ecoff_sym
))
682 asym
->flags
= BSF_DEBUGGING
;
687 asym
->flags
= BSF_DEBUGGING
;
692 asym
->flags
= BSF_EXPORT
| BSF_WEAK
;
694 asym
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
697 asym
->flags
= BSF_LOCAL
;
698 /* Normally, a local stProc symbol will have a corresponding
699 external symbol. We mark the local symbol as a debugging
700 symbol, in order to prevent nm from printing both out.
701 Similarly, we mark stLabel and stabs symbols as debugging
702 symbols. In both cases, we do want to set the value
703 correctly based on the symbol class. */
704 if (ecoff_sym
->st
== stProc
705 || ecoff_sym
->st
== stLabel
706 || ECOFF_IS_STAB (ecoff_sym
))
707 asym
->flags
|= BSF_DEBUGGING
;
710 if (ecoff_sym
->st
== stProc
|| ecoff_sym
->st
== stStaticProc
)
711 asym
->flags
|= BSF_FUNCTION
;
713 switch (ecoff_sym
->sc
)
716 /* Used for compiler generated labels. Leave them in the
717 debugging section, and mark them as local. If BSF_DEBUGGING
718 is set, then nm does not display them for some reason. If no
719 flags are set then the linker whines about them. */
720 asym
->flags
= BSF_LOCAL
;
723 asym
->section
= bfd_make_section_old_way (abfd
, _TEXT
);
724 asym
->value
-= asym
->section
->vma
;
727 asym
->section
= bfd_make_section_old_way (abfd
, _DATA
);
728 asym
->value
-= asym
->section
->vma
;
731 asym
->section
= bfd_make_section_old_way (abfd
, _BSS
);
732 asym
->value
-= asym
->section
->vma
;
735 asym
->flags
= BSF_DEBUGGING
;
738 asym
->section
= bfd_abs_section_ptr
;
741 asym
->section
= bfd_und_section_ptr
;
751 asym
->flags
= BSF_DEBUGGING
;
754 asym
->section
= bfd_make_section_old_way (abfd
, ".sdata");
755 asym
->value
-= asym
->section
->vma
;
758 asym
->section
= bfd_make_section_old_way (abfd
, ".sbss");
759 asym
->value
-= asym
->section
->vma
;
762 asym
->section
= bfd_make_section_old_way (abfd
, ".rdata");
763 asym
->value
-= asym
->section
->vma
;
766 asym
->flags
= BSF_DEBUGGING
;
769 if (asym
->value
> ecoff_data (abfd
)->gp_size
)
771 asym
->section
= bfd_com_section_ptr
;
777 if (ecoff_scom_section
.name
== NULL
)
779 /* Initialize the small common section. */
780 ecoff_scom_section
.name
= SCOMMON
;
781 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
782 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
783 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
784 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
785 ecoff_scom_symbol
.name
= SCOMMON
;
786 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
787 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
788 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
790 asym
->section
= &ecoff_scom_section
;
795 asym
->flags
= BSF_DEBUGGING
;
798 asym
->section
= bfd_und_section_ptr
;
803 asym
->section
= bfd_make_section_old_way (abfd
, ".init");
804 asym
->value
-= asym
->section
->vma
;
809 asym
->flags
= BSF_DEBUGGING
;
812 asym
->section
= bfd_make_section_old_way (abfd
, ".fini");
813 asym
->value
-= asym
->section
->vma
;
816 asym
->section
= bfd_make_section_old_way (abfd
, ".rconst");
817 asym
->value
-= asym
->section
->vma
;
823 /* Look for special constructors symbols and make relocation entries
824 in a special construction section. These are produced by the
825 -fgnu-linker argument to g++. */
826 if (ECOFF_IS_STAB (ecoff_sym
))
828 switch (ECOFF_UNMARK_STAB (ecoff_sym
->index
))
837 /* Mark the symbol as a constructor. */
838 asym
->flags
|= BSF_CONSTRUCTOR
;
845 /* Read an ECOFF symbol table. */
848 _bfd_ecoff_slurp_symbol_table (bfd
*abfd
)
850 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
851 const bfd_size_type external_ext_size
852 = backend
->debug_swap
.external_ext_size
;
853 const bfd_size_type external_sym_size
854 = backend
->debug_swap
.external_sym_size
;
855 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
856 = backend
->debug_swap
.swap_ext_in
;
857 void (* const swap_sym_in
) (bfd
*, void *, SYMR
*)
858 = backend
->debug_swap
.swap_sym_in
;
859 bfd_size_type internal_size
;
860 ecoff_symbol_type
*internal
;
861 ecoff_symbol_type
*internal_ptr
;
867 /* If we've already read in the symbol table, do nothing. */
868 if (ecoff_data (abfd
)->canonical_symbols
!= NULL
)
871 /* Get the symbolic information. */
872 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
873 &ecoff_data (abfd
)->debug_info
))
875 if (bfd_get_symcount (abfd
) == 0)
878 internal_size
= bfd_get_symcount (abfd
);
879 internal_size
*= sizeof (ecoff_symbol_type
);
880 internal
= (ecoff_symbol_type
*) bfd_alloc (abfd
, internal_size
);
881 if (internal
== NULL
)
884 internal_ptr
= internal
;
885 eraw_src
= (char *) ecoff_data (abfd
)->debug_info
.external_ext
;
887 + (ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
888 * external_ext_size
));
889 for (; eraw_src
< eraw_end
; eraw_src
+= external_ext_size
, internal_ptr
++)
893 (*swap_ext_in
) (abfd
, (void *) eraw_src
, &internal_esym
);
894 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ssext
895 + internal_esym
.asym
.iss
);
896 if (!ecoff_set_symbol_info (abfd
, &internal_esym
.asym
,
897 &internal_ptr
->symbol
, 1,
898 internal_esym
.weakext
))
900 /* The alpha uses a negative ifd field for section symbols. */
901 if (internal_esym
.ifd
>= 0)
902 internal_ptr
->fdr
= (ecoff_data (abfd
)->debug_info
.fdr
903 + internal_esym
.ifd
);
905 internal_ptr
->fdr
= NULL
;
906 internal_ptr
->local
= FALSE
;
907 internal_ptr
->native
= (void *) eraw_src
;
910 /* The local symbols must be accessed via the fdr's, because the
911 string and aux indices are relative to the fdr information. */
912 fdr_ptr
= ecoff_data (abfd
)->debug_info
.fdr
;
913 fdr_end
= fdr_ptr
+ ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
;
914 for (; fdr_ptr
< fdr_end
; fdr_ptr
++)
919 lraw_src
= ((char *) ecoff_data (abfd
)->debug_info
.external_sym
920 + fdr_ptr
->isymBase
* external_sym_size
);
921 lraw_end
= lraw_src
+ fdr_ptr
->csym
* external_sym_size
;
924 lraw_src
+= external_sym_size
, internal_ptr
++)
928 (*swap_sym_in
) (abfd
, (void *) lraw_src
, &internal_sym
);
929 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ss
932 if (!ecoff_set_symbol_info (abfd
, &internal_sym
,
933 &internal_ptr
->symbol
, 0, 0))
935 internal_ptr
->fdr
= fdr_ptr
;
936 internal_ptr
->local
= TRUE
;
937 internal_ptr
->native
= (void *) lraw_src
;
941 ecoff_data (abfd
)->canonical_symbols
= internal
;
946 /* Return the amount of space needed for the canonical symbols. */
949 _bfd_ecoff_get_symtab_upper_bound (bfd
*abfd
)
951 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
952 &ecoff_data (abfd
)->debug_info
))
955 if (bfd_get_symcount (abfd
) == 0)
958 return (bfd_get_symcount (abfd
) + 1) * (sizeof (ecoff_symbol_type
*));
961 /* Get the canonical symbols. */
964 _bfd_ecoff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
966 unsigned int counter
= 0;
967 ecoff_symbol_type
*symbase
;
968 ecoff_symbol_type
**location
= (ecoff_symbol_type
**) alocation
;
970 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
972 if (bfd_get_symcount (abfd
) == 0)
975 symbase
= ecoff_data (abfd
)->canonical_symbols
;
976 while (counter
< bfd_get_symcount (abfd
))
978 *(location
++) = symbase
++;
982 return bfd_get_symcount (abfd
);
985 /* Turn ECOFF type information into a printable string.
986 ecoff_emit_aggregate and ecoff_type_to_string are from
987 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
989 /* Write aggregate information to a string. */
992 ecoff_emit_aggregate (bfd
*abfd
,
999 const struct ecoff_debug_swap
* const debug_swap
=
1000 &ecoff_backend (abfd
)->debug_swap
;
1001 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1002 unsigned int ifd
= rndx
->rfd
;
1003 unsigned int indx
= rndx
->index
;
1009 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1010 struct return type of a procedure compiled without -g. */
1011 if (ifd
== 0xffffffff
1012 || (rndx
->rfd
== 0xfff && indx
== 0))
1013 name
= "<undefined>";
1014 else if (indx
== indexNil
)
1020 if (debug_info
->external_rfd
== NULL
)
1021 fdr
= debug_info
->fdr
+ ifd
;
1026 (*debug_swap
->swap_rfd_in
) (abfd
,
1027 ((char *) debug_info
->external_rfd
1028 + ((fdr
->rfdBase
+ ifd
)
1029 * debug_swap
->external_rfd_size
)),
1031 fdr
= debug_info
->fdr
+ rfd
;
1034 indx
+= fdr
->isymBase
;
1036 (*debug_swap
->swap_sym_in
) (abfd
,
1037 ((char *) debug_info
->external_sym
1038 + indx
* debug_swap
->external_sym_size
),
1041 name
= debug_info
->ss
+ fdr
->issBase
+ sym
.iss
;
1045 "%s %s { ifd = %u, index = %lu }",
1047 ((unsigned long) indx
1048 + debug_info
->symbolic_header
.iextMax
));
1051 /* Convert the type information to string format. */
1054 ecoff_type_to_string (bfd
*abfd
, FDR
*fdr
, unsigned int indx
)
1056 union aux_ext
*aux_ptr
;
1066 unsigned int basic_type
;
1069 static char buffer2
[1024];
1074 aux_ptr
= ecoff_data (abfd
)->debug_info
.external_aux
+ fdr
->iauxBase
;
1075 bigendian
= fdr
->fBigendian
;
1077 for (i
= 0; i
< 7; i
++)
1079 qualifiers
[i
].low_bound
= 0;
1080 qualifiers
[i
].high_bound
= 0;
1081 qualifiers
[i
].stride
= 0;
1084 if (AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
]) == (bfd_vma
) -1)
1085 return "-1 (no type)";
1086 _bfd_ecoff_swap_tir_in (bigendian
, &aux_ptr
[indx
++].a_ti
, &u
.ti
);
1088 basic_type
= u
.ti
.bt
;
1089 qualifiers
[0].type
= u
.ti
.tq0
;
1090 qualifiers
[1].type
= u
.ti
.tq1
;
1091 qualifiers
[2].type
= u
.ti
.tq2
;
1092 qualifiers
[3].type
= u
.ti
.tq3
;
1093 qualifiers
[4].type
= u
.ti
.tq4
;
1094 qualifiers
[5].type
= u
.ti
.tq5
;
1095 qualifiers
[6].type
= tqNil
;
1097 /* Go get the basic type. */
1100 case btNil
: /* Undefined. */
1104 case btAdr
: /* Address - integer same size as pointer. */
1105 strcpy (p1
, "address");
1108 case btChar
: /* Character. */
1109 strcpy (p1
, "char");
1112 case btUChar
: /* Unsigned character. */
1113 strcpy (p1
, "unsigned char");
1116 case btShort
: /* Short. */
1117 strcpy (p1
, "short");
1120 case btUShort
: /* Unsigned short. */
1121 strcpy (p1
, "unsigned short");
1124 case btInt
: /* Int. */
1128 case btUInt
: /* Unsigned int. */
1129 strcpy (p1
, "unsigned int");
1132 case btLong
: /* Long. */
1133 strcpy (p1
, "long");
1136 case btULong
: /* Unsigned long. */
1137 strcpy (p1
, "unsigned long");
1140 case btFloat
: /* Float (real). */
1141 strcpy (p1
, "float");
1144 case btDouble
: /* Double (real). */
1145 strcpy (p1
, "double");
1148 /* Structures add 1-2 aux words:
1149 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1150 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1152 case btStruct
: /* Structure (Record). */
1153 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1154 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1155 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1157 indx
++; /* Skip aux words. */
1160 /* Unions add 1-2 aux words:
1161 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1162 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1164 case btUnion
: /* Union. */
1165 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1166 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1167 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1169 indx
++; /* Skip aux words. */
1172 /* Enumerations add 1-2 aux words:
1173 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1174 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1176 case btEnum
: /* Enumeration. */
1177 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1178 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1179 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1181 indx
++; /* Skip aux words. */
1184 case btTypedef
: /* Defined via a typedef, isymRef points. */
1185 strcpy (p1
, "typedef");
1188 case btRange
: /* Subrange of int. */
1189 strcpy (p1
, "subrange");
1192 case btSet
: /* Pascal sets. */
1196 case btComplex
: /* Fortran complex. */
1197 strcpy (p1
, "complex");
1200 case btDComplex
: /* Fortran double complex. */
1201 strcpy (p1
, "double complex");
1204 case btIndirect
: /* Forward or unnamed typedef. */
1205 strcpy (p1
, "forward/unamed typedef");
1208 case btFixedDec
: /* Fixed Decimal. */
1209 strcpy (p1
, "fixed decimal");
1212 case btFloatDec
: /* Float Decimal. */
1213 strcpy (p1
, "float decimal");
1216 case btString
: /* Varying Length Character String. */
1217 strcpy (p1
, "string");
1220 case btBit
: /* Aligned Bit String. */
1224 case btPicture
: /* Picture. */
1225 strcpy (p1
, "picture");
1228 case btVoid
: /* Void. */
1229 strcpy (p1
, "void");
1233 sprintf (p1
, _("Unknown basic type %d"), (int) basic_type
);
1237 p1
+= strlen (buffer1
);
1239 /* If this is a bitfield, get the bitsize. */
1244 bitsize
= AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
++]);
1245 sprintf (p1
, " : %d", bitsize
);
1246 p1
+= strlen (buffer1
);
1249 /* Deal with any qualifiers. */
1250 if (qualifiers
[0].type
!= tqNil
)
1252 /* Snarf up any array bounds in the correct order. Arrays
1253 store 5 successive words in the aux. table:
1254 word 0 RNDXR to type of the bounds (ie, int)
1255 word 1 Current file descriptor index
1257 word 3 high bound (or -1 if [])
1258 word 4 stride size in bits. */
1259 for (i
= 0; i
< 7; i
++)
1261 if (qualifiers
[i
].type
== tqArray
)
1263 qualifiers
[i
].low_bound
=
1264 AUX_GET_DNLOW (bigendian
, &aux_ptr
[indx
+2]);
1265 qualifiers
[i
].high_bound
=
1266 AUX_GET_DNHIGH (bigendian
, &aux_ptr
[indx
+3]);
1267 qualifiers
[i
].stride
=
1268 AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
+4]);
1273 /* Now print out the qualifiers. */
1274 for (i
= 0; i
< 6; i
++)
1276 switch (qualifiers
[i
].type
)
1283 strcpy (p2
, "ptr to ");
1284 p2
+= sizeof ("ptr to ")-1;
1288 strcpy (p2
, "volatile ");
1289 p2
+= sizeof ("volatile ")-1;
1293 strcpy (p2
, "far ");
1294 p2
+= sizeof ("far ")-1;
1298 strcpy (p2
, "func. ret. ");
1299 p2
+= sizeof ("func. ret. ");
1304 int first_array
= i
;
1307 /* Print array bounds reversed (ie, in the order the C
1308 programmer writes them). C is such a fun language.... */
1309 while (i
< 5 && qualifiers
[i
+1].type
== tqArray
)
1312 for (j
= i
; j
>= first_array
; j
--)
1314 strcpy (p2
, "array [");
1315 p2
+= sizeof ("array [")-1;
1316 if (qualifiers
[j
].low_bound
!= 0)
1318 "%ld:%ld {%ld bits}",
1319 (long) qualifiers
[j
].low_bound
,
1320 (long) qualifiers
[j
].high_bound
,
1321 (long) qualifiers
[j
].stride
);
1323 else if (qualifiers
[j
].high_bound
!= -1)
1326 (long) (qualifiers
[j
].high_bound
+ 1),
1327 (long) (qualifiers
[j
].stride
));
1330 sprintf (p2
, " {%ld bits}", (long) (qualifiers
[j
].stride
));
1333 strcpy (p2
, "] of ");
1334 p2
+= sizeof ("] of ")-1;
1342 strcpy (p2
, buffer1
);
1346 /* Return information about ECOFF symbol SYMBOL in RET. */
1349 _bfd_ecoff_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
1353 bfd_symbol_info (symbol
, ret
);
1356 /* Return whether this is a local label. */
1359 _bfd_ecoff_bfd_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1362 return name
[0] == '$';
1365 /* Print information about an ECOFF symbol. */
1368 _bfd_ecoff_print_symbol (bfd
*abfd
,
1371 bfd_print_symbol_type how
)
1373 const struct ecoff_debug_swap
* const debug_swap
1374 = &ecoff_backend (abfd
)->debug_swap
;
1375 FILE *file
= (FILE *)filep
;
1379 case bfd_print_symbol_name
:
1380 fprintf (file
, "%s", symbol
->name
);
1382 case bfd_print_symbol_more
:
1383 if (ecoffsymbol (symbol
)->local
)
1387 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1389 fprintf (file
, "ecoff local ");
1390 fprintf_vma (file
, (bfd_vma
) ecoff_sym
.value
);
1391 fprintf (file
, " %x %x", (unsigned) ecoff_sym
.st
,
1392 (unsigned) ecoff_sym
.sc
);
1398 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1400 fprintf (file
, "ecoff extern ");
1401 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1402 fprintf (file
, " %x %x", (unsigned) ecoff_ext
.asym
.st
,
1403 (unsigned) ecoff_ext
.asym
.sc
);
1406 case bfd_print_symbol_all
:
1407 /* Print out the symbols in a reasonable way. */
1416 if (ecoffsymbol (symbol
)->local
)
1418 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1421 pos
= ((((char *) ecoffsymbol (symbol
)->native
1422 - (char *) ecoff_data (abfd
)->debug_info
.external_sym
)
1423 / debug_swap
->external_sym_size
)
1424 + ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
);
1431 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1434 pos
= (((char *) ecoffsymbol (symbol
)->native
1435 - (char *) ecoff_data (abfd
)->debug_info
.external_ext
)
1436 / debug_swap
->external_ext_size
);
1437 jmptbl
= ecoff_ext
.jmptbl
? 'j' : ' ';
1438 cobol_main
= ecoff_ext
.cobol_main
? 'c' : ' ';
1439 weakext
= ecoff_ext
.weakext
? 'w' : ' ';
1442 fprintf (file
, "[%3d] %c ",
1444 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1445 fprintf (file
, " st %x sc %x indx %x %c%c%c %s",
1446 (unsigned) ecoff_ext
.asym
.st
,
1447 (unsigned) ecoff_ext
.asym
.sc
,
1448 (unsigned) ecoff_ext
.asym
.index
,
1449 jmptbl
, cobol_main
, weakext
,
1452 if (ecoffsymbol (symbol
)->fdr
!= NULL
1453 && ecoff_ext
.asym
.index
!= indexNil
)
1458 bfd_size_type sym_base
;
1459 union aux_ext
*aux_base
;
1461 fdr
= ecoffsymbol (symbol
)->fdr
;
1462 indx
= ecoff_ext
.asym
.index
;
1464 /* sym_base is used to map the fdr relative indices which
1465 appear in the file to the position number which we are
1467 sym_base
= fdr
->isymBase
;
1468 if (ecoffsymbol (symbol
)->local
)
1470 ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
1472 /* aux_base is the start of the aux entries for this file;
1473 asym.index is an offset from this. */
1474 aux_base
= (ecoff_data (abfd
)->debug_info
.external_aux
1477 /* The aux entries are stored in host byte order; the
1478 order is indicated by a bit in the fdr. */
1479 bigendian
= fdr
->fBigendian
;
1481 /* This switch is basically from gcc/mips-tdump.c. */
1482 switch (ecoff_ext
.asym
.st
)
1490 fprintf (file
, _("\n End+1 symbol: %ld"),
1491 (long) (indx
+ sym_base
));
1495 if (ecoff_ext
.asym
.sc
== scText
1496 || ecoff_ext
.asym
.sc
== scInfo
)
1497 fprintf (file
, _("\n First symbol: %ld"),
1498 (long) (indx
+ sym_base
));
1500 fprintf (file
, _("\n First symbol: %ld"),
1502 (AUX_GET_ISYM (bigendian
,
1503 &aux_base
[ecoff_ext
.asym
.index
])
1509 if (ECOFF_IS_STAB (&ecoff_ext
.asym
))
1511 else if (ecoffsymbol (symbol
)->local
)
1512 fprintf (file
, _("\n End+1 symbol: %-7ld Type: %s"),
1514 (AUX_GET_ISYM (bigendian
,
1515 &aux_base
[ecoff_ext
.asym
.index
])
1517 ecoff_type_to_string (abfd
, fdr
, indx
+ 1));
1519 fprintf (file
, _("\n Local symbol: %ld"),
1522 + (ecoff_data (abfd
)
1523 ->debug_info
.symbolic_header
.iextMax
)));
1527 fprintf (file
, _("\n struct; End+1 symbol: %ld"),
1528 (long) (indx
+ sym_base
));
1532 fprintf (file
, _("\n union; End+1 symbol: %ld"),
1533 (long) (indx
+ sym_base
));
1537 fprintf (file
, _("\n enum; End+1 symbol: %ld"),
1538 (long) (indx
+ sym_base
));
1542 if (! ECOFF_IS_STAB (&ecoff_ext
.asym
))
1543 fprintf (file
, _("\n Type: %s"),
1544 ecoff_type_to_string (abfd
, fdr
, indx
));
1553 /* Read in the relocs for a section. */
1556 ecoff_slurp_reloc_table (bfd
*abfd
,
1560 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1561 arelent
*internal_relocs
;
1562 bfd_size_type external_reloc_size
;
1564 char *external_relocs
;
1568 if (section
->relocation
!= NULL
1569 || section
->reloc_count
== 0
1570 || (section
->flags
& SEC_CONSTRUCTOR
) != 0)
1573 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1576 amt
= section
->reloc_count
;
1577 amt
*= sizeof (arelent
);
1578 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
1580 external_reloc_size
= backend
->external_reloc_size
;
1581 amt
= external_reloc_size
* section
->reloc_count
;
1582 external_relocs
= (char *) bfd_alloc (abfd
, amt
);
1583 if (internal_relocs
== NULL
|| external_relocs
== NULL
)
1585 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1587 if (bfd_bread (external_relocs
, amt
, abfd
) != amt
)
1590 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1592 struct internal_reloc intern
;
1594 (*backend
->swap_reloc_in
) (abfd
,
1595 external_relocs
+ i
* external_reloc_size
,
1598 if (intern
.r_extern
)
1600 /* r_symndx is an index into the external symbols. */
1601 BFD_ASSERT (intern
.r_symndx
>= 0
1603 < (ecoff_data (abfd
)
1604 ->debug_info
.symbolic_header
.iextMax
)));
1605 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1608 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1609 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1611 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1616 const char *sec_name
;
1619 /* r_symndx is a section key. */
1620 switch (intern
.r_symndx
)
1622 case RELOC_SECTION_TEXT
: sec_name
= _TEXT
; break;
1623 case RELOC_SECTION_RDATA
: sec_name
= _RDATA
; break;
1624 case RELOC_SECTION_DATA
: sec_name
= _DATA
; break;
1625 case RELOC_SECTION_SDATA
: sec_name
= _SDATA
; break;
1626 case RELOC_SECTION_SBSS
: sec_name
= _SBSS
; break;
1627 case RELOC_SECTION_BSS
: sec_name
= _BSS
; break;
1628 case RELOC_SECTION_INIT
: sec_name
= _INIT
; break;
1629 case RELOC_SECTION_LIT8
: sec_name
= _LIT8
; break;
1630 case RELOC_SECTION_LIT4
: sec_name
= _LIT4
; break;
1631 case RELOC_SECTION_XDATA
: sec_name
= _XDATA
; break;
1632 case RELOC_SECTION_PDATA
: sec_name
= _PDATA
; break;
1633 case RELOC_SECTION_FINI
: sec_name
= _FINI
; break;
1634 case RELOC_SECTION_LITA
: sec_name
= _LITA
; break;
1635 case RELOC_SECTION_RCONST
: sec_name
= _RCONST
; break;
1639 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1642 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1644 rptr
->addend
= - bfd_get_section_vma (abfd
, sec
);
1647 rptr
->address
= intern
.r_vaddr
- bfd_get_section_vma (abfd
, section
);
1649 /* Let the backend select the howto field and do any other
1650 required processing. */
1651 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1654 bfd_release (abfd
, external_relocs
);
1656 section
->relocation
= internal_relocs
;
1661 /* Get a canonical list of relocs. */
1664 _bfd_ecoff_canonicalize_reloc (bfd
*abfd
,
1671 if (section
->flags
& SEC_CONSTRUCTOR
)
1673 arelent_chain
*chain
;
1675 /* This section has relocs made up by us, not the file, so take
1676 them out of their chain and place them into the data area
1678 for (count
= 0, chain
= section
->constructor_chain
;
1679 count
< section
->reloc_count
;
1680 count
++, chain
= chain
->next
)
1681 *relptr
++ = &chain
->relent
;
1687 if (! ecoff_slurp_reloc_table (abfd
, section
, symbols
))
1690 tblptr
= section
->relocation
;
1692 for (count
= 0; count
< section
->reloc_count
; count
++)
1693 *relptr
++ = tblptr
++;
1698 return section
->reloc_count
;
1701 /* Provided a BFD, a section and an offset into the section, calculate
1702 and return the name of the source file and the line nearest to the
1706 _bfd_ecoff_find_nearest_line (bfd
*abfd
,
1707 asymbol
**symbols ATTRIBUTE_UNUSED
,
1710 const char **filename_ptr
,
1711 const char **functionname_ptr
,
1712 unsigned int *retline_ptr
,
1713 unsigned int *discriminator_ptr
)
1715 const struct ecoff_debug_swap
* const debug_swap
1716 = &ecoff_backend (abfd
)->debug_swap
;
1717 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1718 struct ecoff_find_line
*line_info
;
1720 /* Make sure we have the FDR's. */
1721 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
, debug_info
)
1722 || bfd_get_symcount (abfd
) == 0)
1725 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1727 bfd_size_type amt
= sizeof (struct ecoff_find_line
);
1729 ecoff_data (abfd
)->find_line_info
=
1730 (struct ecoff_find_line
*) bfd_zalloc (abfd
, amt
);
1731 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1735 if (discriminator_ptr
)
1736 *discriminator_ptr
= 0;
1737 line_info
= ecoff_data (abfd
)->find_line_info
;
1738 return _bfd_ecoff_locate_line (abfd
, section
, offset
, debug_info
,
1739 debug_swap
, line_info
, filename_ptr
,
1740 functionname_ptr
, retline_ptr
);
1743 /* Copy private BFD data. This is called by objcopy and strip. We
1744 use it to copy the ECOFF debugging information from one BFD to the
1745 other. It would be theoretically possible to represent the ECOFF
1746 debugging information in the symbol table. However, it would be a
1747 lot of work, and there would be little gain (gas, gdb, and ld
1748 already access the ECOFF debugging information via the
1749 ecoff_debug_info structure, and that structure would have to be
1750 retained in order to support ECOFF debugging in MIPS ELF).
1752 The debugging information for the ECOFF external symbols comes from
1753 the symbol table, so this function only handles the other debugging
1757 _bfd_ecoff_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1759 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
1760 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
1762 asymbol
**sym_ptr_ptr
;
1766 /* We only want to copy information over if both BFD's use ECOFF
1768 if (bfd_get_flavour (ibfd
) != bfd_target_ecoff_flavour
1769 || bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
1772 /* Copy the GP value and the register masks. */
1773 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
1774 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
1775 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
1776 for (i
= 0; i
< 3; i
++)
1777 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
1779 /* Copy the version stamp. */
1780 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
1782 /* If there are no symbols, don't copy any debugging information. */
1783 c
= bfd_get_symcount (obfd
);
1784 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1785 if (c
== 0 || sym_ptr_ptr
== NULL
)
1788 /* See if there are any local symbols. */
1790 for (; c
> 0; c
--, sym_ptr_ptr
++)
1792 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
1801 /* There are some local symbols. We just bring over all the
1802 debugging information. FIXME: This is not quite the right
1803 thing to do. If the user has asked us to discard all
1804 debugging information, then we are probably going to wind up
1805 keeping it because there will probably be some local symbol
1806 which objcopy did not discard. We should actually break
1807 apart the debugging information and only keep that which
1808 applies to the symbols we want to keep. */
1809 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
1810 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
1811 oinfo
->line
= iinfo
->line
;
1813 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
1814 oinfo
->external_dnr
= iinfo
->external_dnr
;
1816 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
1817 oinfo
->external_pdr
= iinfo
->external_pdr
;
1819 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
1820 oinfo
->external_sym
= iinfo
->external_sym
;
1822 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
1823 oinfo
->external_opt
= iinfo
->external_opt
;
1825 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
1826 oinfo
->external_aux
= iinfo
->external_aux
;
1828 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
1829 oinfo
->ss
= iinfo
->ss
;
1831 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
1832 oinfo
->external_fdr
= iinfo
->external_fdr
;
1834 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
1835 oinfo
->external_rfd
= iinfo
->external_rfd
;
1839 /* We are discarding all the local symbol information. Look
1840 through the external symbols and remove all references to FDR
1841 or aux information. */
1842 c
= bfd_get_symcount (obfd
);
1843 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1844 for (; c
> 0; c
--, sym_ptr_ptr
++)
1848 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
1849 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
1851 esym
.asym
.index
= indexNil
;
1852 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
1853 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
1860 /* Set the architecture. The supported architecture is stored in the
1861 backend pointer. We always set the architecture anyhow, since many
1862 callers ignore the return value. */
1865 _bfd_ecoff_set_arch_mach (bfd
*abfd
,
1866 enum bfd_architecture arch
,
1867 unsigned long machine
)
1869 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1870 return arch
== ecoff_backend (abfd
)->arch
;
1873 /* Get the size of the section headers. */
1876 _bfd_ecoff_sizeof_headers (bfd
*abfd
,
1877 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1884 for (current
= abfd
->sections
;
1886 current
= current
->next
)
1889 ret
= (bfd_coff_filhsz (abfd
)
1890 + bfd_coff_aoutsz (abfd
)
1891 + c
* bfd_coff_scnhsz (abfd
));
1892 return (int) BFD_ALIGN (ret
, 16);
1895 /* Get the contents of a section. */
1898 _bfd_ecoff_get_section_contents (bfd
*abfd
,
1902 bfd_size_type count
)
1904 return _bfd_generic_get_section_contents (abfd
, section
, location
,
1908 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
1909 called via qsort. */
1912 ecoff_sort_hdrs (const void * arg1
, const void * arg2
)
1914 const asection
*hdr1
= *(const asection
**) arg1
;
1915 const asection
*hdr2
= *(const asection
**) arg2
;
1917 if ((hdr1
->flags
& SEC_ALLOC
) != 0)
1919 if ((hdr2
->flags
& SEC_ALLOC
) == 0)
1924 if ((hdr2
->flags
& SEC_ALLOC
) != 0)
1927 if (hdr1
->vma
< hdr2
->vma
)
1929 else if (hdr1
->vma
> hdr2
->vma
)
1935 /* Calculate the file position for each section, and set
1939 ecoff_compute_section_file_positions (bfd
*abfd
)
1941 file_ptr sofar
, file_sofar
;
1942 asection
**sorted_hdrs
;
1946 bfd_boolean rdata_in_text
;
1947 bfd_boolean first_data
, first_nonalloc
;
1948 const bfd_vma round
= ecoff_backend (abfd
)->round
;
1951 sofar
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
1954 /* Sort the sections by VMA. */
1955 amt
= abfd
->section_count
;
1956 amt
*= sizeof (asection
*);
1957 sorted_hdrs
= (asection
**) bfd_malloc (amt
);
1958 if (sorted_hdrs
== NULL
)
1960 for (current
= abfd
->sections
, i
= 0;
1962 current
= current
->next
, i
++)
1963 sorted_hdrs
[i
] = current
;
1964 BFD_ASSERT (i
== abfd
->section_count
);
1966 qsort (sorted_hdrs
, abfd
->section_count
, sizeof (asection
*),
1969 /* Some versions of the OSF linker put the .rdata section in the
1970 text segment, and some do not. */
1971 rdata_in_text
= ecoff_backend (abfd
)->rdata_in_text
;
1974 for (i
= 0; i
< abfd
->section_count
; i
++)
1976 current
= sorted_hdrs
[i
];
1977 if (streq (current
->name
, _RDATA
))
1979 if ((current
->flags
& SEC_CODE
) == 0
1980 && ! streq (current
->name
, _PDATA
)
1981 && ! streq (current
->name
, _RCONST
))
1983 rdata_in_text
= FALSE
;
1988 ecoff_data (abfd
)->rdata_in_text
= rdata_in_text
;
1991 first_nonalloc
= TRUE
;
1992 for (i
= 0; i
< abfd
->section_count
; i
++)
1994 unsigned int alignment_power
;
1996 current
= sorted_hdrs
[i
];
1998 /* For the Alpha ECOFF .pdata section the lnnoptr field is
1999 supposed to indicate the number of .pdata entries that are
2000 really in the section. Each entry is 8 bytes. We store this
2001 away in line_filepos before increasing the section size. */
2002 if (streq (current
->name
, _PDATA
))
2003 current
->line_filepos
= current
->size
/ 8;
2005 alignment_power
= current
->alignment_power
;
2007 /* On Ultrix, the data sections in an executable file must be
2008 aligned to a page boundary within the file. This does not
2009 affect the section size, though. FIXME: Does this work for
2010 other platforms? It requires some modification for the
2011 Alpha, because .rdata on the Alpha goes with the text, not
2013 if ((abfd
->flags
& EXEC_P
) != 0
2014 && (abfd
->flags
& D_PAGED
) != 0
2016 && (current
->flags
& SEC_CODE
) == 0
2018 || ! streq (current
->name
, _RDATA
))
2019 && ! streq (current
->name
, _PDATA
)
2020 && ! streq (current
->name
, _RCONST
))
2022 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2023 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2026 else if (streq (current
->name
, _LIB
))
2028 /* On Irix 4, the location of contents of the .lib section
2029 from a shared library section is also rounded up to a
2032 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2033 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2035 else if (first_nonalloc
2036 && (current
->flags
& SEC_ALLOC
) == 0
2037 && (abfd
->flags
& D_PAGED
) != 0)
2039 /* Skip up to the next page for an unallocated section, such
2040 as the .comment section on the Alpha. This leaves room
2041 for the .bss section. */
2042 first_nonalloc
= FALSE
;
2043 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2044 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2047 /* Align the sections in the file to the same boundary on
2048 which they are aligned in virtual memory. */
2049 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2050 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2051 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2053 if ((abfd
->flags
& D_PAGED
) != 0
2054 && (current
->flags
& SEC_ALLOC
) != 0)
2056 sofar
+= (current
->vma
- sofar
) % round
;
2057 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2058 file_sofar
+= (current
->vma
- file_sofar
) % round
;
2061 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) != 0)
2062 current
->filepos
= file_sofar
;
2064 sofar
+= current
->size
;
2065 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2066 file_sofar
+= current
->size
;
2068 /* Make sure that this section is of the right size too. */
2070 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2071 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2072 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2073 current
->size
+= sofar
- old_sofar
;
2079 ecoff_data (abfd
)->reloc_filepos
= file_sofar
;
2084 /* Determine the location of the relocs for all the sections in the
2085 output file, as well as the location of the symbolic debugging
2088 static bfd_size_type
2089 ecoff_compute_reloc_file_positions (bfd
*abfd
)
2091 const bfd_size_type external_reloc_size
=
2092 ecoff_backend (abfd
)->external_reloc_size
;
2093 file_ptr reloc_base
;
2094 bfd_size_type reloc_size
;
2098 if (! abfd
->output_has_begun
)
2100 if (! ecoff_compute_section_file_positions (abfd
))
2102 abfd
->output_has_begun
= TRUE
;
2105 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2108 for (current
= abfd
->sections
;
2110 current
= current
->next
)
2112 if (current
->reloc_count
== 0)
2113 current
->rel_filepos
= 0;
2116 bfd_size_type relsize
;
2118 current
->rel_filepos
= reloc_base
;
2119 relsize
= current
->reloc_count
* external_reloc_size
;
2120 reloc_size
+= relsize
;
2121 reloc_base
+= relsize
;
2125 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2127 /* At least on Ultrix, the symbol table of an executable file must
2128 be aligned to a page boundary. FIXME: Is this true on other
2130 if ((abfd
->flags
& EXEC_P
) != 0
2131 && (abfd
->flags
& D_PAGED
) != 0)
2132 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2133 &~ (ecoff_backend (abfd
)->round
- 1));
2135 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2140 /* Set the contents of a section. */
2143 _bfd_ecoff_set_section_contents (bfd
*abfd
,
2145 const void * location
,
2147 bfd_size_type count
)
2151 /* This must be done first, because bfd_set_section_contents is
2152 going to set output_has_begun to TRUE. */
2153 if (! abfd
->output_has_begun
2154 && ! ecoff_compute_section_file_positions (abfd
))
2157 /* Handle the .lib section specially so that Irix 4 shared libraries
2158 work out. See coff_set_section_contents in coffcode.h. */
2159 if (streq (section
->name
, _LIB
))
2161 bfd_byte
*rec
, *recend
;
2163 rec
= (bfd_byte
*) location
;
2164 recend
= rec
+ count
;
2165 while (rec
< recend
)
2168 rec
+= bfd_get_32 (abfd
, rec
) * 4;
2171 BFD_ASSERT (rec
== recend
);
2177 pos
= section
->filepos
+ offset
;
2178 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2179 || bfd_bwrite (location
, count
, abfd
) != count
)
2185 /* Get the GP value for an ECOFF file. This is a hook used by
2189 bfd_ecoff_get_gp_value (bfd
*abfd
)
2191 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2192 || bfd_get_format (abfd
) != bfd_object
)
2194 bfd_set_error (bfd_error_invalid_operation
);
2198 return ecoff_data (abfd
)->gp
;
2201 /* Set the GP value for an ECOFF file. This is a hook used by the
2205 bfd_ecoff_set_gp_value (bfd
*abfd
, bfd_vma gp_value
)
2207 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2208 || bfd_get_format (abfd
) != bfd_object
)
2210 bfd_set_error (bfd_error_invalid_operation
);
2214 ecoff_data (abfd
)->gp
= gp_value
;
2219 /* Set the register masks for an ECOFF file. This is a hook used by
2223 bfd_ecoff_set_regmasks (bfd
*abfd
,
2224 unsigned long gprmask
,
2225 unsigned long fprmask
,
2226 unsigned long *cprmask
)
2228 ecoff_data_type
*tdata
;
2230 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2231 || bfd_get_format (abfd
) != bfd_object
)
2233 bfd_set_error (bfd_error_invalid_operation
);
2237 tdata
= ecoff_data (abfd
);
2238 tdata
->gprmask
= gprmask
;
2239 tdata
->fprmask
= fprmask
;
2240 if (cprmask
!= NULL
)
2244 for (i
= 0; i
< 3; i
++)
2245 tdata
->cprmask
[i
] = cprmask
[i
];
2251 /* Get ECOFF EXTR information for an external symbol. This function
2252 is passed to bfd_ecoff_debug_externals. */
2255 ecoff_get_extr (asymbol
*sym
, EXTR
*esym
)
2257 ecoff_symbol_type
*ecoff_sym_ptr
;
2260 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2261 || ecoffsymbol (sym
)->native
== NULL
)
2263 /* Don't include debugging, local, or section symbols. */
2264 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2265 || (sym
->flags
& BSF_LOCAL
) != 0
2266 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2270 esym
->cobol_main
= 0;
2271 esym
->weakext
= (sym
->flags
& BSF_WEAK
) != 0;
2274 /* FIXME: we can do better than this for st and sc. */
2275 esym
->asym
.st
= stGlobal
;
2276 esym
->asym
.sc
= scAbs
;
2277 esym
->asym
.reserved
= 0;
2278 esym
->asym
.index
= indexNil
;
2282 ecoff_sym_ptr
= ecoffsymbol (sym
);
2284 if (ecoff_sym_ptr
->local
)
2287 input_bfd
= bfd_asymbol_bfd (sym
);
2288 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2289 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2291 /* If the symbol was defined by the linker, then esym will be
2292 undefined but sym will not be. Get a better class for such a
2294 if ((esym
->asym
.sc
== scUndefined
2295 || esym
->asym
.sc
== scSUndefined
)
2296 && ! bfd_is_und_section (bfd_get_section (sym
)))
2297 esym
->asym
.sc
= scAbs
;
2299 /* Adjust the FDR index for the symbol by that used for the input
2301 if (esym
->ifd
!= -1)
2303 struct ecoff_debug_info
*input_debug
;
2305 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2306 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2307 if (input_debug
->ifdmap
!= NULL
)
2308 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2314 /* Set the external symbol index. This routine is passed to
2315 bfd_ecoff_debug_externals. */
2318 ecoff_set_index (asymbol
*sym
, bfd_size_type indx
)
2320 ecoff_set_sym_index (sym
, indx
);
2323 /* Write out an ECOFF file. */
2326 _bfd_ecoff_write_object_contents (bfd
*abfd
)
2328 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2329 const bfd_vma round
= backend
->round
;
2330 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2331 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2332 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2333 const bfd_size_type external_hdr_size
2334 = backend
->debug_swap
.external_hdr_size
;
2335 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2336 void (* const adjust_reloc_out
) (bfd
*, const arelent
*, struct internal_reloc
*)
2337 = backend
->adjust_reloc_out
;
2338 void (* const swap_reloc_out
) (bfd
*, const struct internal_reloc
*, void *)
2339 = backend
->swap_reloc_out
;
2340 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2341 HDRR
* const symhdr
= &debug
->symbolic_header
;
2344 bfd_size_type reloc_size
;
2345 bfd_size_type text_size
;
2347 bfd_boolean set_text_start
;
2348 bfd_size_type data_size
;
2350 bfd_boolean set_data_start
;
2351 bfd_size_type bss_size
;
2353 void * reloc_buff
= NULL
;
2354 struct internal_filehdr internal_f
;
2355 struct internal_aouthdr internal_a
;
2358 /* Determine where the sections and relocs will go in the output
2360 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2363 for (current
= abfd
->sections
;
2365 current
= current
->next
)
2367 current
->target_index
= count
;
2371 if ((abfd
->flags
& D_PAGED
) != 0)
2372 text_size
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2376 set_text_start
= FALSE
;
2379 set_data_start
= FALSE
;
2382 /* Write section headers to the file. */
2384 /* Allocate buff big enough to hold a section header,
2385 file header, or a.out header. */
2394 buff
= bfd_malloc (siz
);
2399 internal_f
.f_nscns
= 0;
2400 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2403 for (current
= abfd
->sections
;
2405 current
= current
->next
)
2407 struct internal_scnhdr section
;
2410 ++internal_f
.f_nscns
;
2412 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2414 /* This seems to be correct for Irix 4 shared libraries. */
2415 vma
= bfd_get_section_vma (abfd
, current
);
2416 if (streq (current
->name
, _LIB
))
2417 section
.s_vaddr
= 0;
2419 section
.s_vaddr
= vma
;
2421 section
.s_paddr
= current
->lma
;
2422 section
.s_size
= current
->size
;
2424 /* If this section is unloadable then the scnptr will be 0. */
2425 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2426 section
.s_scnptr
= 0;
2428 section
.s_scnptr
= current
->filepos
;
2429 section
.s_relptr
= current
->rel_filepos
;
2431 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2432 object file produced by the assembler is supposed to point to
2433 information about how much room is required by objects of
2434 various different sizes. I think this only matters if we
2435 want the linker to compute the best size to use, or
2436 something. I don't know what happens if the information is
2438 if (! streq (current
->name
, _PDATA
))
2439 section
.s_lnnoptr
= 0;
2442 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2443 hold the number of entries in the section (each entry is
2444 8 bytes). We stored this in the line_filepos field in
2445 ecoff_compute_section_file_positions. */
2446 section
.s_lnnoptr
= current
->line_filepos
;
2449 section
.s_nreloc
= current
->reloc_count
;
2450 section
.s_nlnno
= 0;
2451 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2454 if (bfd_coff_swap_scnhdr_out (abfd
, (void *) §ion
, buff
) == 0
2455 || bfd_bwrite (buff
, scnhsz
, abfd
) != scnhsz
)
2458 if ((section
.s_flags
& STYP_TEXT
) != 0
2459 || ((section
.s_flags
& STYP_RDATA
) != 0
2460 && ecoff_data (abfd
)->rdata_in_text
)
2461 || section
.s_flags
== STYP_PDATA
2462 || (section
.s_flags
& STYP_DYNAMIC
) != 0
2463 || (section
.s_flags
& STYP_LIBLIST
) != 0
2464 || (section
.s_flags
& STYP_RELDYN
) != 0
2465 || section
.s_flags
== STYP_CONFLIC
2466 || (section
.s_flags
& STYP_DYNSTR
) != 0
2467 || (section
.s_flags
& STYP_DYNSYM
) != 0
2468 || (section
.s_flags
& STYP_HASH
) != 0
2469 || (section
.s_flags
& STYP_ECOFF_INIT
) != 0
2470 || (section
.s_flags
& STYP_ECOFF_FINI
) != 0
2471 || section
.s_flags
== STYP_RCONST
)
2473 text_size
+= current
->size
;
2474 if (! set_text_start
|| text_start
> vma
)
2477 set_text_start
= TRUE
;
2480 else if ((section
.s_flags
& STYP_RDATA
) != 0
2481 || (section
.s_flags
& STYP_DATA
) != 0
2482 || (section
.s_flags
& STYP_LITA
) != 0
2483 || (section
.s_flags
& STYP_LIT8
) != 0
2484 || (section
.s_flags
& STYP_LIT4
) != 0
2485 || (section
.s_flags
& STYP_SDATA
) != 0
2486 || section
.s_flags
== STYP_XDATA
2487 || (section
.s_flags
& STYP_GOT
) != 0)
2489 data_size
+= current
->size
;
2490 if (! set_data_start
|| data_start
> vma
)
2493 set_data_start
= TRUE
;
2496 else if ((section
.s_flags
& STYP_BSS
) != 0
2497 || (section
.s_flags
& STYP_SBSS
) != 0)
2498 bss_size
+= current
->size
;
2499 else if (section
.s_flags
== 0
2500 || (section
.s_flags
& STYP_ECOFF_LIB
) != 0
2501 || section
.s_flags
== STYP_COMMENT
)
2507 /* Set up the file header. */
2508 internal_f
.f_magic
= ecoff_get_magic (abfd
);
2510 /* We will NOT put a fucking timestamp in the header here. Every
2511 time you put it back, I will come in and take it out again. I'm
2512 sorry. This field does not belong here. We fill it with a 0 so
2513 it compares the same but is not a reasonable time. --
2515 internal_f
.f_timdat
= 0;
2517 if (bfd_get_symcount (abfd
) != 0)
2519 /* The ECOFF f_nsyms field is not actually the number of
2520 symbols, it's the size of symbolic information header. */
2521 internal_f
.f_nsyms
= external_hdr_size
;
2522 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
2526 internal_f
.f_nsyms
= 0;
2527 internal_f
.f_symptr
= 0;
2530 internal_f
.f_opthdr
= aoutsz
;
2532 internal_f
.f_flags
= F_LNNO
;
2533 if (reloc_size
== 0)
2534 internal_f
.f_flags
|= F_RELFLG
;
2535 if (bfd_get_symcount (abfd
) == 0)
2536 internal_f
.f_flags
|= F_LSYMS
;
2537 if (abfd
->flags
& EXEC_P
)
2538 internal_f
.f_flags
|= F_EXEC
;
2540 if (bfd_little_endian (abfd
))
2541 internal_f
.f_flags
|= F_AR32WR
;
2543 internal_f
.f_flags
|= F_AR32W
;
2545 /* Set up the ``optional'' header. */
2546 if ((abfd
->flags
& D_PAGED
) != 0)
2547 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
2549 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
2551 /* FIXME: Is this really correct? */
2552 internal_a
.vstamp
= symhdr
->vstamp
;
2554 /* At least on Ultrix, these have to be rounded to page boundaries.
2555 FIXME: Is this true on other platforms? */
2556 if ((abfd
->flags
& D_PAGED
) != 0)
2558 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
2559 internal_a
.text_start
= text_start
&~ (round
- 1);
2560 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
2561 internal_a
.data_start
= data_start
&~ (round
- 1);
2565 internal_a
.tsize
= text_size
;
2566 internal_a
.text_start
= text_start
;
2567 internal_a
.dsize
= data_size
;
2568 internal_a
.data_start
= data_start
;
2571 /* On Ultrix, the initial portions of the .sbss and .bss segments
2572 are at the end of the data section. The bsize field in the
2573 optional header records how many bss bytes are required beyond
2574 those in the data section. The value is not rounded to a page
2576 if (bss_size
< internal_a
.dsize
- data_size
)
2579 bss_size
-= internal_a
.dsize
- data_size
;
2580 internal_a
.bsize
= bss_size
;
2581 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
2583 internal_a
.entry
= bfd_get_start_address (abfd
);
2585 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
2587 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
2588 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
2589 for (i
= 0; i
< 4; i
++)
2590 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
2592 /* Let the backend adjust the headers if necessary. */
2593 if (backend
->adjust_headers
)
2595 if (! (*backend
->adjust_headers
) (abfd
, &internal_f
, &internal_a
))
2599 /* Write out the file header and the optional header. */
2600 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2603 bfd_coff_swap_filehdr_out (abfd
, (void *) &internal_f
, buff
);
2604 if (bfd_bwrite (buff
, filhsz
, abfd
) != filhsz
)
2607 bfd_coff_swap_aouthdr_out (abfd
, (void *) &internal_a
, buff
);
2608 if (bfd_bwrite (buff
, aoutsz
, abfd
) != aoutsz
)
2611 /* Build the external symbol information. This must be done before
2612 writing out the relocs so that we know the symbol indices. We
2613 don't do this if this BFD was created by the backend linker,
2614 since it will have already handled the symbols and relocs. */
2615 if (! ecoff_data (abfd
)->linker
)
2617 symhdr
->iextMax
= 0;
2618 symhdr
->issExtMax
= 0;
2619 debug
->external_ext
= debug
->external_ext_end
= NULL
;
2620 debug
->ssext
= debug
->ssext_end
= NULL
;
2621 if (! bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
2622 (abfd
->flags
& EXEC_P
) == 0,
2623 ecoff_get_extr
, ecoff_set_index
))
2626 /* Write out the relocs. */
2627 for (current
= abfd
->sections
;
2629 current
= current
->next
)
2631 arelent
**reloc_ptr_ptr
;
2632 arelent
**reloc_end
;
2636 if (current
->reloc_count
== 0)
2639 amt
= current
->reloc_count
* external_reloc_size
;
2640 reloc_buff
= bfd_alloc (abfd
, amt
);
2641 if (reloc_buff
== NULL
)
2644 reloc_ptr_ptr
= current
->orelocation
;
2645 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
2646 out_ptr
= (char *) reloc_buff
;
2649 reloc_ptr_ptr
< reloc_end
;
2650 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
2654 struct internal_reloc in
;
2656 memset ((void *) &in
, 0, sizeof in
);
2658 reloc
= *reloc_ptr_ptr
;
2659 sym
= *reloc
->sym_ptr_ptr
;
2661 /* If the howto field has not been initialised then skip this reloc.
2662 This assumes that an error message has been issued elsewhere. */
2663 if (reloc
->howto
== NULL
)
2666 in
.r_vaddr
= (reloc
->address
2667 + bfd_get_section_vma (abfd
, current
));
2668 in
.r_type
= reloc
->howto
->type
;
2670 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2672 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2686 { _TEXT
, RELOC_SECTION_TEXT
},
2687 { _RDATA
, RELOC_SECTION_RDATA
},
2688 { _DATA
, RELOC_SECTION_DATA
},
2689 { _SDATA
, RELOC_SECTION_SDATA
},
2690 { _SBSS
, RELOC_SECTION_SBSS
},
2691 { _BSS
, RELOC_SECTION_BSS
},
2692 { _INIT
, RELOC_SECTION_INIT
},
2693 { _LIT8
, RELOC_SECTION_LIT8
},
2694 { _LIT4
, RELOC_SECTION_LIT4
},
2695 { _XDATA
, RELOC_SECTION_XDATA
},
2696 { _PDATA
, RELOC_SECTION_PDATA
},
2697 { _FINI
, RELOC_SECTION_FINI
},
2698 { _LITA
, RELOC_SECTION_LITA
},
2699 { "*ABS*", RELOC_SECTION_ABS
},
2700 { _RCONST
, RELOC_SECTION_RCONST
}
2703 name
= bfd_get_section_name (abfd
, bfd_get_section (sym
));
2705 for (j
= 0; j
< ARRAY_SIZE (section_symndx
); j
++)
2706 if (streq (name
, section_symndx
[j
].name
))
2708 in
.r_symndx
= section_symndx
[j
].r_symndx
;
2712 if (j
== ARRAY_SIZE (section_symndx
))
2717 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2719 (*swap_reloc_out
) (abfd
, &in
, (void *) out_ptr
);
2722 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2724 amt
= current
->reloc_count
* external_reloc_size
;
2725 if (bfd_bwrite (reloc_buff
, amt
, abfd
) != amt
)
2727 bfd_release (abfd
, reloc_buff
);
2731 /* Write out the symbolic debugging information. */
2732 if (bfd_get_symcount (abfd
) > 0)
2734 /* Write out the debugging information. */
2735 if (! bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2736 ecoff_data (abfd
)->sym_filepos
))
2741 /* The .bss section of a demand paged executable must receive an
2742 entire page. If there are symbols, the symbols will start on the
2743 next page. If there are no symbols, we must fill out the page by
2745 if (bfd_get_symcount (abfd
) == 0
2746 && (abfd
->flags
& EXEC_P
) != 0
2747 && (abfd
->flags
& D_PAGED
) != 0)
2751 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2754 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) == 0)
2756 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2759 if (bfd_bwrite (&c
, (bfd_size_type
) 1, abfd
) != 1)
2763 if (reloc_buff
!= NULL
)
2764 bfd_release (abfd
, reloc_buff
);
2769 if (reloc_buff
!= NULL
)
2770 bfd_release (abfd
, reloc_buff
);
2776 /* Archive handling. ECOFF uses what appears to be a unique type of
2777 archive header (armap). The byte ordering of the armap and the
2778 contents are encoded in the name of the armap itself. At least for
2779 now, we only support archives with the same byte ordering in the
2780 armap and the contents.
2782 The first four bytes in the armap are the number of symbol
2783 definitions. This is always a power of two.
2785 This is followed by the symbol definitions. Each symbol definition
2786 occupies 8 bytes. The first four bytes are the offset from the
2787 start of the armap strings to the null-terminated string naming
2788 this symbol. The second four bytes are the file offset to the
2789 archive member which defines this symbol. If the second four bytes
2790 are 0, then this is not actually a symbol definition, and it should
2793 The symbols are hashed into the armap with a closed hashing scheme.
2794 See the functions below for the details of the algorithm.
2796 After the symbol definitions comes four bytes holding the size of
2797 the string table, followed by the string table itself. */
2799 /* The name of an archive headers looks like this:
2800 __________E[BL]E[BL]_ (with a trailing space).
2801 The trailing space is changed to an X if the archive is changed to
2802 indicate that the armap is out of date.
2804 The Alpha seems to use ________64E[BL]E[BL]_. */
2806 #define ARMAP_BIG_ENDIAN 'B'
2807 #define ARMAP_LITTLE_ENDIAN 'L'
2808 #define ARMAP_MARKER 'E'
2809 #define ARMAP_START_LENGTH 10
2810 #define ARMAP_HEADER_MARKER_INDEX 10
2811 #define ARMAP_HEADER_ENDIAN_INDEX 11
2812 #define ARMAP_OBJECT_MARKER_INDEX 12
2813 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2814 #define ARMAP_END_INDEX 14
2815 #define ARMAP_END "_ "
2817 /* This is a magic number used in the hashing algorithm. */
2818 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2820 /* This returns the hash value to use for a string. It also sets
2821 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2822 is the number of entries in the hash table, and HLOG is the log
2826 ecoff_armap_hash (const char *s
,
2827 unsigned int *rehash
,
2837 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2838 hash
*= ARMAP_HASH_MAGIC
;
2839 *rehash
= (hash
& (size
- 1)) | 1;
2840 return hash
>> (32 - hlog
);
2843 /* Read in the armap. */
2846 _bfd_ecoff_slurp_armap (bfd
*abfd
)
2850 struct areltdata
*mapdata
;
2851 bfd_size_type parsed_size
;
2853 struct artdata
*ardata
;
2860 /* Get the name of the first element. */
2861 i
= bfd_bread ((void *) nextname
, (bfd_size_type
) 16, abfd
);
2867 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2870 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2871 standard COFF armap. We could move the ECOFF armap stuff into
2872 bfd_slurp_armap, but that seems inappropriate since no other
2873 target uses this format. Instead, we check directly for a COFF
2875 if (CONST_STRNEQ (nextname
, "/ "))
2876 return bfd_slurp_armap (abfd
);
2878 /* See if the first element is an armap. */
2879 if (! strneq (nextname
, ecoff_backend (abfd
)->armap_start
, ARMAP_START_LENGTH
)
2880 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
2881 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2882 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2883 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
2884 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2885 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2886 || ! strneq (nextname
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1))
2888 bfd_has_map (abfd
) = FALSE
;
2892 /* Make sure we have the right byte ordering. */
2893 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2894 ^ (bfd_header_big_endian (abfd
)))
2895 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2896 ^ (bfd_big_endian (abfd
))))
2898 bfd_set_error (bfd_error_wrong_format
);
2902 /* Read in the armap. */
2903 ardata
= bfd_ardata (abfd
);
2904 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
2905 if (mapdata
== NULL
)
2907 parsed_size
= mapdata
->parsed_size
;
2910 raw_armap
= (char *) bfd_alloc (abfd
, parsed_size
);
2911 if (raw_armap
== NULL
)
2914 if (bfd_bread ((void *) raw_armap
, parsed_size
, abfd
) != parsed_size
)
2916 if (bfd_get_error () != bfd_error_system_call
)
2917 bfd_set_error (bfd_error_malformed_archive
);
2918 bfd_release (abfd
, (void *) raw_armap
);
2922 ardata
->tdata
= (void *) raw_armap
;
2924 count
= H_GET_32 (abfd
, raw_armap
);
2926 ardata
->symdef_count
= 0;
2927 ardata
->cache
= NULL
;
2929 /* This code used to overlay the symdefs over the raw archive data,
2930 but that doesn't work on a 64 bit host. */
2931 stringbase
= raw_armap
+ count
* 8 + 8;
2933 #ifdef CHECK_ARMAP_HASH
2937 /* Double check that I have the hashing algorithm right by making
2938 sure that every symbol can be looked up successfully. */
2940 for (i
= 1; i
< count
; i
<<= 1)
2942 BFD_ASSERT (i
== count
);
2944 raw_ptr
= raw_armap
+ 4;
2945 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2947 unsigned int name_offset
, file_offset
;
2948 unsigned int hash
, rehash
, srch
;
2950 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2951 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2952 if (file_offset
== 0)
2954 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
2959 /* See if we can rehash to this location. */
2960 for (srch
= (hash
+ rehash
) & (count
- 1);
2961 srch
!= hash
&& srch
!= i
;
2962 srch
= (srch
+ rehash
) & (count
- 1))
2963 BFD_ASSERT (H_GET_32 (abfd
, (raw_armap
+ 8 + srch
* 8)) != 0);
2964 BFD_ASSERT (srch
== i
);
2968 #endif /* CHECK_ARMAP_HASH */
2970 raw_ptr
= raw_armap
+ 4;
2971 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2972 if (H_GET_32 (abfd
, (raw_ptr
+ 4)) != 0)
2973 ++ardata
->symdef_count
;
2975 amt
= ardata
->symdef_count
;
2976 amt
*= sizeof (carsym
);
2977 symdef_ptr
= (carsym
*) bfd_alloc (abfd
, amt
);
2981 ardata
->symdefs
= symdef_ptr
;
2983 raw_ptr
= raw_armap
+ 4;
2984 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2986 unsigned int name_offset
, file_offset
;
2988 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2989 if (file_offset
== 0)
2991 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2992 symdef_ptr
->name
= stringbase
+ name_offset
;
2993 symdef_ptr
->file_offset
= file_offset
;
2997 ardata
->first_file_filepos
= bfd_tell (abfd
);
2998 /* Pad to an even boundary. */
2999 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
3001 bfd_has_map (abfd
) = TRUE
;
3006 /* Write out an armap. */
3009 _bfd_ecoff_write_armap (bfd
*abfd
,
3010 unsigned int elength
,
3012 unsigned int orl_count
,
3015 unsigned int hashsize
, hashlog
;
3016 bfd_size_type symdefsize
;
3018 unsigned int stringsize
;
3019 unsigned int mapsize
;
3022 struct stat statbuf
;
3025 bfd_byte
*hashtable
;
3029 /* Ultrix appears to use as a hash table size the least power of two
3030 greater than twice the number of entries. */
3031 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3033 hashsize
= 1 << hashlog
;
3035 symdefsize
= hashsize
* 8;
3037 stringsize
= stridx
+ padit
;
3039 /* Include 8 bytes to store symdefsize and stringsize in output. */
3040 mapsize
= symdefsize
+ stringsize
+ 8;
3042 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3044 memset ((void *) &hdr
, 0, sizeof hdr
);
3046 /* Work out the ECOFF armap name. */
3047 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3048 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3049 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3050 (bfd_header_big_endian (abfd
)
3052 : ARMAP_LITTLE_ENDIAN
);
3053 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3054 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3055 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3056 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3058 /* Write the timestamp of the archive header to be just a little bit
3059 later than the timestamp of the file, otherwise the linker will
3060 complain that the index is out of date. Actually, the Ultrix
3061 linker just checks the archive name; the GNU linker may check the
3063 stat (abfd
->filename
, &statbuf
);
3064 _bfd_ar_spacepad (hdr
.ar_date
, sizeof (hdr
.ar_date
), "%ld",
3065 (long) (statbuf
.st_mtime
+ 60));
3067 /* The DECstation uses zeroes for the uid, gid and mode of the
3069 hdr
.ar_uid
[0] = '0';
3070 hdr
.ar_gid
[0] = '0';
3071 /* Building gcc ends up extracting the armap as a file - twice. */
3072 hdr
.ar_mode
[0] = '6';
3073 hdr
.ar_mode
[1] = '4';
3074 hdr
.ar_mode
[2] = '4';
3076 _bfd_ar_spacepad (hdr
.ar_size
, sizeof (hdr
.ar_size
), "%-10ld", mapsize
);
3078 hdr
.ar_fmag
[0] = '`';
3079 hdr
.ar_fmag
[1] = '\012';
3081 /* Turn all null bytes in the header into spaces. */
3082 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3083 if (((char *) (&hdr
))[i
] == '\0')
3084 (((char *) (&hdr
))[i
]) = ' ';
3086 if (bfd_bwrite ((void *) &hdr
, (bfd_size_type
) sizeof (struct ar_hdr
), abfd
)
3087 != sizeof (struct ar_hdr
))
3090 H_PUT_32 (abfd
, hashsize
, temp
);
3091 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3094 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3098 current
= abfd
->archive_head
;
3100 for (i
= 0; i
< orl_count
; i
++)
3102 unsigned int hash
, rehash
= 0;
3104 /* Advance firstreal to the file position of this archive
3106 if (map
[i
].u
.abfd
!= last_elt
)
3110 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3111 firstreal
+= firstreal
% 2;
3112 current
= current
->archive_next
;
3114 while (current
!= map
[i
].u
.abfd
);
3119 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3120 if (H_GET_32 (abfd
, (hashtable
+ (hash
* 8) + 4)) != 0)
3124 /* The desired slot is already taken. */
3125 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3127 srch
= (srch
+ rehash
) & (hashsize
- 1))
3128 if (H_GET_32 (abfd
, (hashtable
+ (srch
* 8) + 4)) == 0)
3131 BFD_ASSERT (srch
!= hash
);
3136 H_PUT_32 (abfd
, map
[i
].namidx
, (hashtable
+ hash
* 8));
3137 H_PUT_32 (abfd
, firstreal
, (hashtable
+ hash
* 8 + 4));
3140 if (bfd_bwrite ((void *) hashtable
, symdefsize
, abfd
) != symdefsize
)
3143 bfd_release (abfd
, hashtable
);
3145 /* Now write the strings. */
3146 H_PUT_32 (abfd
, stringsize
, temp
);
3147 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3149 for (i
= 0; i
< orl_count
; i
++)
3153 len
= strlen (*map
[i
].name
) + 1;
3154 if (bfd_bwrite ((void *) (*map
[i
].name
), len
, abfd
) != len
)
3158 /* The spec sez this should be a newline. But in order to be
3159 bug-compatible for DECstation ar we use a null. */
3162 if (bfd_bwrite ("", (bfd_size_type
) 1, abfd
) != 1)
3169 /* ECOFF linker code. */
3171 /* Routine to create an entry in an ECOFF link hash table. */
3173 static struct bfd_hash_entry
*
3174 ecoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
3175 struct bfd_hash_table
*table
,
3178 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3180 /* Allocate the structure if it has not already been allocated by a
3183 ret
= ((struct ecoff_link_hash_entry
*)
3184 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3188 /* Call the allocation method of the superclass. */
3189 ret
= ((struct ecoff_link_hash_entry
*)
3190 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3195 /* Set local fields. */
3201 memset ((void *) &ret
->esym
, 0, sizeof ret
->esym
);
3203 return (struct bfd_hash_entry
*) ret
;
3206 /* Create an ECOFF link hash table. */
3208 struct bfd_link_hash_table
*
3209 _bfd_ecoff_bfd_link_hash_table_create (bfd
*abfd
)
3211 struct ecoff_link_hash_table
*ret
;
3212 bfd_size_type amt
= sizeof (struct ecoff_link_hash_table
);
3214 ret
= (struct ecoff_link_hash_table
*) bfd_malloc (amt
);
3217 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
,
3218 ecoff_link_hash_newfunc
,
3219 sizeof (struct ecoff_link_hash_entry
)))
3227 /* Look up an entry in an ECOFF link hash table. */
3229 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3230 ((struct ecoff_link_hash_entry *) \
3231 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3233 /* Get the ECOFF link hash table from the info structure. This is
3236 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3238 /* Add the external symbols of an object file to the global linker
3239 hash table. The external symbols and strings we are passed are
3240 just allocated on the stack, and will be discarded. We must
3241 explicitly save any information we may need later on in the link.
3242 We do not want to read the external symbol information again. */
3245 ecoff_link_add_externals (bfd
*abfd
,
3246 struct bfd_link_info
*info
,
3247 void * external_ext
,
3250 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3251 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3252 = backend
->debug_swap
.swap_ext_in
;
3253 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3254 unsigned long ext_count
;
3255 struct bfd_link_hash_entry
**sym_hash
;
3260 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3263 amt
*= sizeof (struct bfd_link_hash_entry
*);
3264 sym_hash
= (struct bfd_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3267 ecoff_data (abfd
)->sym_hashes
= (struct ecoff_link_hash_entry
**) sym_hash
;
3269 ext_ptr
= (char *) external_ext
;
3270 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3271 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3278 struct ecoff_link_hash_entry
*h
;
3282 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3284 /* Skip debugging symbols. */
3286 switch (esym
.asym
.st
)
3302 /* Get the information for this symbol. */
3303 value
= esym
.asym
.value
;
3304 switch (esym
.asym
.sc
)
3324 section
= bfd_make_section_old_way (abfd
, _TEXT
);
3325 value
-= section
->vma
;
3328 section
= bfd_make_section_old_way (abfd
, _DATA
);
3329 value
-= section
->vma
;
3332 section
= bfd_make_section_old_way (abfd
, _BSS
);
3333 value
-= section
->vma
;
3336 section
= bfd_abs_section_ptr
;
3339 section
= bfd_und_section_ptr
;
3342 section
= bfd_make_section_old_way (abfd
, _SDATA
);
3343 value
-= section
->vma
;
3346 section
= bfd_make_section_old_way (abfd
, _SBSS
);
3347 value
-= section
->vma
;
3350 section
= bfd_make_section_old_way (abfd
, _RDATA
);
3351 value
-= section
->vma
;
3354 if (value
> ecoff_data (abfd
)->gp_size
)
3356 section
= bfd_com_section_ptr
;
3361 if (ecoff_scom_section
.name
== NULL
)
3363 /* Initialize the small common section. */
3364 ecoff_scom_section
.name
= SCOMMON
;
3365 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
3366 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
3367 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
3368 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
3369 ecoff_scom_symbol
.name
= SCOMMON
;
3370 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
3371 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
3372 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
3374 section
= &ecoff_scom_section
;
3377 section
= bfd_und_section_ptr
;
3380 section
= bfd_make_section_old_way (abfd
, _INIT
);
3381 value
-= section
->vma
;
3384 section
= bfd_make_section_old_way (abfd
, _FINI
);
3385 value
-= section
->vma
;
3388 section
= bfd_make_section_old_way (abfd
, _RCONST
);
3389 value
-= section
->vma
;
3393 if (section
== NULL
)
3396 name
= ssext
+ esym
.asym
.iss
;
3398 if (! (_bfd_generic_link_add_one_symbol
3400 (flagword
) (esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
),
3401 section
, value
, NULL
, TRUE
, TRUE
, sym_hash
)))
3404 h
= (struct ecoff_link_hash_entry
*) *sym_hash
;
3406 /* If we are building an ECOFF hash table, save the external
3407 symbol information. */
3408 if (bfd_get_flavour (info
->output_bfd
) == bfd_get_flavour (abfd
))
3411 || (! bfd_is_und_section (section
)
3412 && (! bfd_is_com_section (section
)
3413 || (h
->root
.type
!= bfd_link_hash_defined
3414 && h
->root
.type
!= bfd_link_hash_defweak
))))
3420 /* Remember whether this symbol was small undefined. */
3421 if (esym
.asym
.sc
== scSUndefined
)
3424 /* If this symbol was ever small undefined, it needs to wind
3425 up in a GP relative section. We can't control the
3426 section of a defined symbol, but we can control the
3427 section of a common symbol. This case is actually needed
3428 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3430 && h
->root
.type
== bfd_link_hash_common
3431 && streq (h
->root
.u
.c
.p
->section
->name
, SCOMMON
))
3433 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
3435 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
3436 if (h
->esym
.asym
.sc
== scCommon
)
3437 h
->esym
.asym
.sc
= scSCommon
;
3445 /* Add symbols from an ECOFF object file to the global linker hash
3449 ecoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3452 bfd_size_type external_ext_size
;
3453 void * external_ext
= NULL
;
3454 bfd_size_type esize
;
3458 if (! ecoff_slurp_symbolic_header (abfd
))
3461 /* If there are no symbols, we don't want it. */
3462 if (bfd_get_symcount (abfd
) == 0)
3465 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3467 /* Read in the external symbols and external strings. */
3468 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3469 esize
= symhdr
->iextMax
* external_ext_size
;
3470 external_ext
= bfd_malloc (esize
);
3471 if (external_ext
== NULL
&& esize
!= 0)
3474 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbExtOffset
, SEEK_SET
) != 0
3475 || bfd_bread (external_ext
, esize
, abfd
) != esize
)
3478 ssext
= (char *) bfd_malloc ((bfd_size_type
) symhdr
->issExtMax
);
3479 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3482 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
3483 || (bfd_bread (ssext
, (bfd_size_type
) symhdr
->issExtMax
, abfd
)
3484 != (bfd_size_type
) symhdr
->issExtMax
))
3487 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3491 if (external_ext
!= NULL
)
3492 free (external_ext
);
3498 if (external_ext
!= NULL
)
3499 free (external_ext
);
3503 /* This is called if we used _bfd_generic_link_add_archive_symbols
3504 because we were not dealing with an ECOFF archive. */
3507 ecoff_link_check_archive_element (bfd
*abfd
,
3508 struct bfd_link_info
*info
,
3509 struct bfd_link_hash_entry
*h
,
3511 bfd_boolean
*pneeded
)
3515 /* Unlike the generic linker, we do not pull in elements because
3516 of common symbols. */
3517 if (h
->type
!= bfd_link_hash_undefined
)
3520 /* Include this element. */
3521 if (!(*info
->callbacks
->add_archive_element
) (info
, abfd
, name
, &abfd
))
3525 return ecoff_link_add_object_symbols (abfd
, info
);
3528 /* Add the symbols from an archive file to the global hash table.
3529 This looks through the undefined symbols, looks each one up in the
3530 archive hash table, and adds any associated object file. We do not
3531 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3532 already have a hash table, so there is no reason to construct
3536 ecoff_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3538 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3539 const bfd_byte
*raw_armap
;
3540 struct bfd_link_hash_entry
**pundef
;
3541 unsigned int armap_count
;
3542 unsigned int armap_log
;
3544 const bfd_byte
*hashtable
;
3545 const char *stringbase
;
3547 if (! bfd_has_map (abfd
))
3549 /* An empty archive is a special case. */
3550 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
3552 bfd_set_error (bfd_error_no_armap
);
3556 /* If we don't have any raw data for this archive, as can happen on
3557 Irix 4.0.5F, we call the generic routine.
3558 FIXME: We should be more clever about this, since someday tdata
3559 may get to something for a generic archive. */
3560 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3561 if (raw_armap
== NULL
)
3562 return (_bfd_generic_link_add_archive_symbols
3563 (abfd
, info
, ecoff_link_check_archive_element
));
3565 armap_count
= H_GET_32 (abfd
, raw_armap
);
3568 for (i
= 1; i
< armap_count
; i
<<= 1)
3570 BFD_ASSERT (i
== armap_count
);
3572 hashtable
= raw_armap
+ 4;
3573 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3575 /* Look through the list of undefined symbols. */
3576 pundef
= &info
->hash
->undefs
;
3577 while (*pundef
!= NULL
)
3579 struct bfd_link_hash_entry
*h
;
3580 unsigned int hash
, rehash
= 0;
3581 unsigned int file_offset
;
3587 /* When a symbol is defined, it is not necessarily removed from
3589 if (h
->type
!= bfd_link_hash_undefined
3590 && h
->type
!= bfd_link_hash_common
)
3592 /* Remove this entry from the list, for general cleanliness
3593 and because we are going to look through the list again
3594 if we search any more libraries. We can't remove the
3595 entry if it is the tail, because that would lose any
3596 entries we add to the list later on. */
3597 if (*pundef
!= info
->hash
->undefs_tail
)
3598 *pundef
= (*pundef
)->u
.undef
.next
;
3600 pundef
= &(*pundef
)->u
.undef
.next
;
3604 /* Native ECOFF linkers do not pull in archive elements merely
3605 to satisfy common definitions, so neither do we. We leave
3606 them on the list, though, in case we are linking against some
3607 other object format. */
3608 if (h
->type
!= bfd_link_hash_undefined
)
3610 pundef
= &(*pundef
)->u
.undef
.next
;
3614 /* Look for this symbol in the archive hash table. */
3615 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3618 file_offset
= H_GET_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3619 if (file_offset
== 0)
3621 /* Nothing in this slot. */
3622 pundef
= &(*pundef
)->u
.undef
.next
;
3626 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (hash
* 8));
3627 if (name
[0] != h
->root
.string
[0]
3628 || ! streq (name
, h
->root
.string
))
3633 /* That was the wrong symbol. Try rehashing. */
3635 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3637 srch
= (srch
+ rehash
) & (armap_count
- 1))
3639 file_offset
= H_GET_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3640 if (file_offset
== 0)
3642 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (srch
* 8));
3643 if (name
[0] == h
->root
.string
[0]
3644 && streq (name
, h
->root
.string
))
3653 pundef
= &(*pundef
)->u
.undef
.next
;
3660 element
= (*backend
->get_elt_at_filepos
) (abfd
, (file_ptr
) file_offset
);
3661 if (element
== NULL
)
3664 if (! bfd_check_format (element
, bfd_object
))
3667 /* Unlike the generic linker, we know that this element provides
3668 a definition for an undefined symbol and we know that we want
3669 to include it. We don't need to check anything. */
3670 if (!(*info
->callbacks
3671 ->add_archive_element
) (info
, element
, name
, &element
))
3673 if (! ecoff_link_add_object_symbols (element
, info
))
3676 pundef
= &(*pundef
)->u
.undef
.next
;
3682 /* Given an ECOFF BFD, add symbols to the global hash table as
3686 _bfd_ecoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3688 switch (bfd_get_format (abfd
))
3691 return ecoff_link_add_object_symbols (abfd
, info
);
3693 return ecoff_link_add_archive_symbols (abfd
, info
);
3695 bfd_set_error (bfd_error_wrong_format
);
3701 /* ECOFF final link routines. */
3703 /* Structure used to pass information to ecoff_link_write_external. */
3708 struct bfd_link_info
*info
;
3711 /* Accumulate the debugging information for an input BFD into the
3712 output BFD. This must read in the symbolic information of the
3716 ecoff_final_link_debug_accumulate (bfd
*output_bfd
,
3718 struct bfd_link_info
*info
,
3721 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
3722 const struct ecoff_debug_swap
* const swap
=
3723 &ecoff_backend (input_bfd
)->debug_swap
;
3724 HDRR
*symhdr
= &debug
->symbolic_header
;
3727 #define READ(ptr, offset, count, size, type) \
3728 if (symhdr->count == 0) \
3729 debug->ptr = NULL; \
3732 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
3733 debug->ptr = (type) bfd_malloc (amt); \
3734 if (debug->ptr == NULL) \
3737 goto return_something; \
3739 if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3740 || bfd_bread (debug->ptr, amt, input_bfd) != amt) \
3743 goto return_something; \
3747 /* If raw_syments is not NULL, then the data was already by read by
3748 _bfd_ecoff_slurp_symbolic_info. */
3749 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3751 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
3753 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
3754 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
3755 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
3756 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
3757 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3759 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3760 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
3761 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
3765 /* We do not read the external strings or the external symbols. */
3767 ret
= (bfd_ecoff_debug_accumulate
3768 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
3769 &ecoff_backend (output_bfd
)->debug_swap
,
3770 input_bfd
, debug
, swap
, info
));
3773 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3775 if (debug
->line
!= NULL
)
3777 if (debug
->external_dnr
!= NULL
)
3778 free (debug
->external_dnr
);
3779 if (debug
->external_pdr
!= NULL
)
3780 free (debug
->external_pdr
);
3781 if (debug
->external_sym
!= NULL
)
3782 free (debug
->external_sym
);
3783 if (debug
->external_opt
!= NULL
)
3784 free (debug
->external_opt
);
3785 if (debug
->external_aux
!= NULL
)
3786 free (debug
->external_aux
);
3787 if (debug
->ss
!= NULL
)
3789 if (debug
->external_fdr
!= NULL
)
3790 free (debug
->external_fdr
);
3791 if (debug
->external_rfd
!= NULL
)
3792 free (debug
->external_rfd
);
3794 /* Make sure we don't accidentally follow one of these pointers
3795 into freed memory. */
3797 debug
->external_dnr
= NULL
;
3798 debug
->external_pdr
= NULL
;
3799 debug
->external_sym
= NULL
;
3800 debug
->external_opt
= NULL
;
3801 debug
->external_aux
= NULL
;
3803 debug
->external_fdr
= NULL
;
3804 debug
->external_rfd
= NULL
;
3810 /* Relocate and write an ECOFF section into an ECOFF output file. */
3813 ecoff_indirect_link_order (bfd
*output_bfd
,
3814 struct bfd_link_info
*info
,
3815 asection
*output_section
,
3816 struct bfd_link_order
*link_order
)
3818 asection
*input_section
;
3820 bfd_byte
*contents
= NULL
;
3821 bfd_size_type external_reloc_size
;
3822 bfd_size_type external_relocs_size
;
3823 void * external_relocs
= NULL
;
3825 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
3827 input_section
= link_order
->u
.indirect
.section
;
3828 input_bfd
= input_section
->owner
;
3829 if (input_section
->size
== 0)
3832 BFD_ASSERT (input_section
->output_section
== output_section
);
3833 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
3834 BFD_ASSERT (input_section
->size
== link_order
->size
);
3836 /* Get the section contents. */
3837 if (!bfd_malloc_and_get_section (input_bfd
, input_section
, &contents
))
3840 /* Get the relocs. If we are relaxing MIPS code, they will already
3841 have been read in. Otherwise, we read them in now. */
3842 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
3843 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
3845 external_relocs
= bfd_malloc (external_relocs_size
);
3846 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
3849 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3850 || (bfd_bread (external_relocs
, external_relocs_size
, input_bfd
)
3851 != external_relocs_size
))
3854 /* Relocate the section contents. */
3855 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
3856 (output_bfd
, info
, input_bfd
, input_section
, contents
,
3860 /* Write out the relocated section. */
3861 if (! bfd_set_section_contents (output_bfd
,
3864 input_section
->output_offset
,
3865 input_section
->size
))
3868 /* If we are producing relocatable output, the relocs were
3869 modified, and we write them out now. We use the reloc_count
3870 field of output_section to keep track of the number of relocs we
3871 have output so far. */
3872 if (info
->relocatable
)
3874 file_ptr pos
= (output_section
->rel_filepos
3875 + output_section
->reloc_count
* external_reloc_size
);
3876 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
3877 || (bfd_bwrite (external_relocs
, external_relocs_size
, output_bfd
)
3878 != external_relocs_size
))
3880 output_section
->reloc_count
+= input_section
->reloc_count
;
3883 if (contents
!= NULL
)
3885 if (external_relocs
!= NULL
)
3886 free (external_relocs
);
3890 if (contents
!= NULL
)
3892 if (external_relocs
!= NULL
)
3893 free (external_relocs
);
3897 /* Generate a reloc when linking an ECOFF file. This is a reloc
3898 requested by the linker, and does come from any input file. This
3899 is used to build constructor and destructor tables when linking
3903 ecoff_reloc_link_order (bfd
*output_bfd
,
3904 struct bfd_link_info
*info
,
3905 asection
*output_section
,
3906 struct bfd_link_order
*link_order
)
3908 enum bfd_link_order_type type
;
3912 struct internal_reloc in
;
3913 bfd_size_type external_reloc_size
;
3918 type
= link_order
->type
;
3920 addend
= link_order
->u
.reloc
.p
->addend
;
3922 /* We set up an arelent to pass to the backend adjust_reloc_out
3924 rel
.address
= link_order
->offset
;
3926 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3929 bfd_set_error (bfd_error_bad_value
);
3933 if (type
== bfd_section_reloc_link_order
)
3935 section
= link_order
->u
.reloc
.p
->u
.section
;
3936 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
3940 struct bfd_link_hash_entry
*h
;
3942 /* Treat a reloc against a defined symbol as though it were
3943 actually against the section. */
3944 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3945 link_order
->u
.reloc
.p
->u
.name
,
3946 FALSE
, FALSE
, FALSE
);
3948 && (h
->type
== bfd_link_hash_defined
3949 || h
->type
== bfd_link_hash_defweak
))
3951 type
= bfd_section_reloc_link_order
;
3952 section
= h
->u
.def
.section
->output_section
;
3953 /* It seems that we ought to add the symbol value to the
3954 addend here, but in practice it has already been added
3955 because it was passed to constructor_callback. */
3956 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
3960 /* We can't set up a reloc against a symbol correctly,
3961 because we have no asymbol structure. Currently no
3962 adjust_reloc_out routine cares. */
3963 rel
.sym_ptr_ptr
= NULL
;
3967 /* All ECOFF relocs are in-place. Put the addend into the object
3970 BFD_ASSERT (rel
.howto
->partial_inplace
);
3974 bfd_reloc_status_type rstat
;
3977 size
= bfd_get_reloc_size (rel
.howto
);
3978 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3981 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
3982 (bfd_vma
) addend
, buf
);
3988 case bfd_reloc_outofrange
:
3990 case bfd_reloc_overflow
:
3991 if (! ((*info
->callbacks
->reloc_overflow
)
3993 (link_order
->type
== bfd_section_reloc_link_order
3994 ? bfd_section_name (output_bfd
, section
)
3995 : link_order
->u
.reloc
.p
->u
.name
),
3996 rel
.howto
->name
, addend
, NULL
,
3997 NULL
, (bfd_vma
) 0)))
4004 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
4005 (file_ptr
) link_order
->offset
, size
);
4013 /* Move the information into an internal_reloc structure. */
4014 in
.r_vaddr
= (rel
.address
4015 + bfd_get_section_vma (output_bfd
, output_section
));
4016 in
.r_type
= rel
.howto
->type
;
4018 if (type
== bfd_symbol_reloc_link_order
)
4020 struct ecoff_link_hash_entry
*h
;
4022 h
= ((struct ecoff_link_hash_entry
*)
4023 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4024 link_order
->u
.reloc
.p
->u
.name
,
4025 FALSE
, FALSE
, TRUE
));
4028 in
.r_symndx
= h
->indx
;
4031 if (! ((*info
->callbacks
->unattached_reloc
)
4032 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
,
4033 NULL
, (bfd_vma
) 0)))
4050 { _TEXT
, RELOC_SECTION_TEXT
},
4051 { _RDATA
, RELOC_SECTION_RDATA
},
4052 { _DATA
, RELOC_SECTION_DATA
},
4053 { _SDATA
, RELOC_SECTION_SDATA
},
4054 { _SBSS
, RELOC_SECTION_SBSS
},
4055 { _BSS
, RELOC_SECTION_BSS
},
4056 { _INIT
, RELOC_SECTION_INIT
},
4057 { _LIT8
, RELOC_SECTION_LIT8
},
4058 { _LIT4
, RELOC_SECTION_LIT4
},
4059 { _XDATA
, RELOC_SECTION_XDATA
},
4060 { _PDATA
, RELOC_SECTION_PDATA
},
4061 { _FINI
, RELOC_SECTION_FINI
},
4062 { _LITA
, RELOC_SECTION_LITA
},
4063 { "*ABS*", RELOC_SECTION_ABS
},
4064 { _RCONST
, RELOC_SECTION_RCONST
}
4067 name
= bfd_get_section_name (output_bfd
, section
);
4069 for (i
= 0; i
< ARRAY_SIZE (section_symndx
); i
++)
4070 if (streq (name
, section_symndx
[i
].name
))
4072 in
.r_symndx
= section_symndx
[i
].r_symndx
;
4076 if (i
== ARRAY_SIZE (section_symndx
))
4082 /* Let the BFD backend adjust the reloc. */
4083 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4085 /* Get some memory and swap out the reloc. */
4086 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4087 rbuf
= (bfd_byte
*) bfd_malloc (external_reloc_size
);
4091 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (void *) rbuf
);
4093 pos
= (output_section
->rel_filepos
4094 + output_section
->reloc_count
* external_reloc_size
);
4095 ok
= (bfd_seek (output_bfd
, pos
, SEEK_SET
) == 0
4096 && (bfd_bwrite ((void *) rbuf
, external_reloc_size
, output_bfd
)
4097 == external_reloc_size
));
4100 ++output_section
->reloc_count
;
4107 /* Put out information for an external symbol. These come only from
4111 ecoff_link_write_external (struct bfd_hash_entry
*bh
, void * data
)
4113 struct ecoff_link_hash_entry
*h
= (struct ecoff_link_hash_entry
*) bh
;
4114 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4115 bfd
*output_bfd
= einfo
->abfd
;
4118 if (h
->root
.type
== bfd_link_hash_warning
)
4120 h
= (struct ecoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4121 if (h
->root
.type
== bfd_link_hash_new
)
4125 /* We need to check if this symbol is being stripped. */
4126 if (h
->root
.type
== bfd_link_hash_undefined
4127 || h
->root
.type
== bfd_link_hash_undefweak
)
4129 else if (einfo
->info
->strip
== strip_all
4130 || (einfo
->info
->strip
== strip_some
4131 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4132 h
->root
.root
.string
,
4133 FALSE
, FALSE
) == NULL
))
4138 if (strip
|| h
->written
)
4141 if (h
->abfd
== NULL
)
4144 h
->esym
.cobol_main
= 0;
4145 h
->esym
.weakext
= 0;
4146 h
->esym
.reserved
= 0;
4147 h
->esym
.ifd
= ifdNil
;
4148 h
->esym
.asym
.value
= 0;
4149 h
->esym
.asym
.st
= stGlobal
;
4151 if (h
->root
.type
!= bfd_link_hash_defined
4152 && h
->root
.type
!= bfd_link_hash_defweak
)
4153 h
->esym
.asym
.sc
= scAbs
;
4156 asection
*output_section
;
4164 section_storage_classes
[] =
4168 { _SDATA
, scSData
},
4169 { _RDATA
, scRData
},
4174 { _PDATA
, scPData
},
4175 { _XDATA
, scXData
},
4176 { _RCONST
, scRConst
}
4179 output_section
= h
->root
.u
.def
.section
->output_section
;
4180 name
= bfd_section_name (output_section
->owner
, output_section
);
4182 for (i
= 0; i
< ARRAY_SIZE (section_storage_classes
); i
++)
4183 if (streq (name
, section_storage_classes
[i
].name
))
4185 h
->esym
.asym
.sc
= section_storage_classes
[i
].sc
;
4189 if (i
== ARRAY_SIZE (section_storage_classes
))
4190 h
->esym
.asym
.sc
= scAbs
;
4193 h
->esym
.asym
.reserved
= 0;
4194 h
->esym
.asym
.index
= indexNil
;
4196 else if (h
->esym
.ifd
!= -1)
4198 struct ecoff_debug_info
*debug
;
4200 /* Adjust the FDR index for the symbol by that used for the
4202 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4203 BFD_ASSERT (h
->esym
.ifd
>= 0
4204 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4205 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4208 switch (h
->root
.type
)
4211 case bfd_link_hash_warning
:
4212 case bfd_link_hash_new
:
4214 case bfd_link_hash_undefined
:
4215 case bfd_link_hash_undefweak
:
4216 if (h
->esym
.asym
.sc
!= scUndefined
4217 && h
->esym
.asym
.sc
!= scSUndefined
)
4218 h
->esym
.asym
.sc
= scUndefined
;
4220 case bfd_link_hash_defined
:
4221 case bfd_link_hash_defweak
:
4222 if (h
->esym
.asym
.sc
== scUndefined
4223 || h
->esym
.asym
.sc
== scSUndefined
)
4224 h
->esym
.asym
.sc
= scAbs
;
4225 else if (h
->esym
.asym
.sc
== scCommon
)
4226 h
->esym
.asym
.sc
= scBss
;
4227 else if (h
->esym
.asym
.sc
== scSCommon
)
4228 h
->esym
.asym
.sc
= scSBss
;
4229 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4230 + h
->root
.u
.def
.section
->output_section
->vma
4231 + h
->root
.u
.def
.section
->output_offset
);
4233 case bfd_link_hash_common
:
4234 if (h
->esym
.asym
.sc
!= scCommon
4235 && h
->esym
.asym
.sc
!= scSCommon
)
4236 h
->esym
.asym
.sc
= scCommon
;
4237 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4239 case bfd_link_hash_indirect
:
4240 /* We ignore these symbols, since the indirected symbol is
4241 already in the hash table. */
4245 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4247 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4250 return (bfd_ecoff_debug_one_external
4251 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4252 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4256 /* ECOFF final link routine. This looks through all the input BFDs
4257 and gathers together all the debugging information, and then
4258 processes all the link order information. This may cause it to
4259 close and reopen some input BFDs; I'll see how bad this is. */
4262 _bfd_ecoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
4264 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4265 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4270 struct bfd_link_order
*p
;
4271 struct extsym_info einfo
;
4273 /* We accumulate the debugging information counts in the symbolic
4275 symhdr
= &debug
->symbolic_header
;
4277 symhdr
->ilineMax
= 0;
4281 symhdr
->isymMax
= 0;
4282 symhdr
->ioptMax
= 0;
4283 symhdr
->iauxMax
= 0;
4285 symhdr
->issExtMax
= 0;
4288 symhdr
->iextMax
= 0;
4290 /* We accumulate the debugging information itself in the debug_info
4293 debug
->external_dnr
= NULL
;
4294 debug
->external_pdr
= NULL
;
4295 debug
->external_sym
= NULL
;
4296 debug
->external_opt
= NULL
;
4297 debug
->external_aux
= NULL
;
4299 debug
->ssext
= debug
->ssext_end
= NULL
;
4300 debug
->external_fdr
= NULL
;
4301 debug
->external_rfd
= NULL
;
4302 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4304 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4308 /* Accumulate the debugging symbols from each input BFD. */
4309 for (input_bfd
= info
->input_bfds
;
4311 input_bfd
= input_bfd
->link
.next
)
4315 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4317 /* Arbitrarily set the symbolic header vstamp to the vstamp
4318 of the first object file in the link. */
4319 if (symhdr
->vstamp
== 0)
4321 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4322 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4326 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4327 debug
, &backend
->debug_swap
,
4332 /* Combine the register masks. */
4333 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4334 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4335 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4336 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4337 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4338 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4341 /* Write out the external symbols. */
4344 bfd_hash_traverse (&info
->hash
->table
, ecoff_link_write_external
, &einfo
);
4346 if (info
->relocatable
)
4348 /* We need to make a pass over the link_orders to count up the
4349 number of relocations we will need to output, so that we know
4350 how much space they will take up. */
4351 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4354 for (p
= o
->map_head
.link_order
;
4357 if (p
->type
== bfd_indirect_link_order
)
4358 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4359 else if (p
->type
== bfd_section_reloc_link_order
4360 || p
->type
== bfd_symbol_reloc_link_order
)
4365 /* Compute the reloc and symbol file positions. */
4366 ecoff_compute_reloc_file_positions (abfd
);
4368 /* Write out the debugging information. */
4369 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4370 &backend
->debug_swap
, info
,
4371 ecoff_data (abfd
)->sym_filepos
))
4374 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4376 if (info
->relocatable
)
4378 /* Now reset the reloc_count field of the sections in the output
4379 BFD to 0, so that we can use them to keep track of how many
4380 relocs we have output thus far. */
4381 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4385 /* Get a value for the GP register. */
4386 if (ecoff_data (abfd
)->gp
== 0)
4388 struct bfd_link_hash_entry
*h
;
4390 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
4392 && h
->type
== bfd_link_hash_defined
)
4393 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4394 + h
->u
.def
.section
->output_section
->vma
4395 + h
->u
.def
.section
->output_offset
);
4396 else if (info
->relocatable
)
4400 /* Make up a value. */
4402 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4405 && (streq (o
->name
, _SBSS
)
4406 || streq (o
->name
, _SDATA
)
4407 || streq (o
->name
, _LIT4
)
4408 || streq (o
->name
, _LIT8
)
4409 || streq (o
->name
, _LITA
)))
4412 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4416 /* If the relocate_section function needs to do a reloc
4417 involving the GP value, it should make a reloc_dangerous
4418 callback to warn that GP is not defined. */
4422 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4424 for (p
= o
->map_head
.link_order
;
4428 if (p
->type
== bfd_indirect_link_order
4429 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4430 == bfd_target_ecoff_flavour
))
4432 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4435 else if (p
->type
== bfd_section_reloc_link_order
4436 || p
->type
== bfd_symbol_reloc_link_order
)
4438 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4443 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4449 bfd_get_symcount (abfd
) = symhdr
->iextMax
+ symhdr
->isymMax
;
4451 ecoff_data (abfd
)->linker
= TRUE
;