1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright 1990, 1991, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Original version by Per Bothner.
5 Full support added by Ian Lance Taylor, ian@cygnus.com.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #include "aout/ranlib.h"
29 #include "aout/stab_gnu.h"
31 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
32 some other stuff which we don't want and which conflicts with stuff
35 #include "aout/aout64.h"
38 #undef obj_sym_filepos
40 #include "coff/internal.h"
42 #include "coff/symconst.h"
43 #include "coff/ecoff.h"
47 /* Prototypes for static functions. */
49 static int ecoff_get_magic
PARAMS ((bfd
*abfd
));
50 static long ecoff_sec_to_styp_flags
PARAMS ((const char *name
,
52 static boolean ecoff_slurp_symbolic_header
PARAMS ((bfd
*abfd
));
53 static boolean ecoff_set_symbol_info
PARAMS ((bfd
*abfd
, SYMR
*ecoff_sym
,
54 asymbol
*asym
, int ext
, int weak
));
55 static void ecoff_emit_aggregate
PARAMS ((bfd
*abfd
, FDR
*fdr
,
57 RNDXR
*rndx
, long isym
,
59 static char *ecoff_type_to_string
PARAMS ((bfd
*abfd
, FDR
*fdr
,
61 static boolean ecoff_slurp_reloc_table
PARAMS ((bfd
*abfd
, asection
*section
,
63 static int ecoff_sort_hdrs
PARAMS ((const PTR
, const PTR
));
64 static boolean ecoff_compute_section_file_positions
PARAMS ((bfd
*abfd
));
65 static bfd_size_type ecoff_compute_reloc_file_positions
PARAMS ((bfd
*abfd
));
66 static boolean ecoff_get_extr
PARAMS ((asymbol
*, EXTR
*));
67 static void ecoff_set_index
PARAMS ((asymbol
*, bfd_size_type
));
68 static unsigned int ecoff_armap_hash
PARAMS ((CONST
char *s
,
73 /* This stuff is somewhat copied from coffcode.h. */
75 static asection bfd_debug_section
=
77 /* name, id, index, next, flags, user_set_vma, reloc_done, */
78 "*DEBUG*", 0, 0, 0, 0, 0, 0,
79 /* linker_mark, gc_mark, segment_mark, vma, lma, _cooked_size, */
81 /* _raw_size, output_offset, output_section, alignment_power, */
83 /* relocation, orelocation, reloc_count, filepos, rel_filepos, */
85 /* line_filepos, userdata, contents, lineno, lineno_count, */
86 0, NULL
, NULL
, NULL
, 0,
87 /* comdat, kept_section, moving_line_filepos, target_index, */
89 /* used_by_bfd, constructor_chain, owner, */
92 (struct symbol_cache_entry
*) NULL
,
94 (struct symbol_cache_entry
**) NULL
,
95 /* link_order_head, link_order_tail */
99 /* Create an ECOFF object. */
102 _bfd_ecoff_mkobject (abfd
)
105 abfd
->tdata
.ecoff_obj_data
= ((struct ecoff_tdata
*)
106 bfd_zalloc (abfd
, sizeof (ecoff_data_type
)));
107 if (abfd
->tdata
.ecoff_obj_data
== NULL
)
113 /* This is a hook called by coff_real_object_p to create any backend
114 specific information. */
117 _bfd_ecoff_mkobject_hook (abfd
, filehdr
, aouthdr
)
122 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
123 struct internal_aouthdr
*internal_a
= (struct internal_aouthdr
*) aouthdr
;
124 ecoff_data_type
*ecoff
;
126 if (_bfd_ecoff_mkobject (abfd
) == false)
129 ecoff
= ecoff_data (abfd
);
131 ecoff
->sym_filepos
= internal_f
->f_symptr
;
133 if (internal_a
!= (struct internal_aouthdr
*) NULL
)
137 ecoff
->text_start
= internal_a
->text_start
;
138 ecoff
->text_end
= internal_a
->text_start
+ internal_a
->tsize
;
139 ecoff
->gp
= internal_a
->gp_value
;
140 ecoff
->gprmask
= internal_a
->gprmask
;
141 for (i
= 0; i
< 4; i
++)
142 ecoff
->cprmask
[i
] = internal_a
->cprmask
[i
];
143 ecoff
->fprmask
= internal_a
->fprmask
;
144 if (internal_a
->magic
== ECOFF_AOUT_ZMAGIC
)
145 abfd
->flags
|= D_PAGED
;
147 abfd
->flags
&=~ D_PAGED
;
150 /* It turns out that no special action is required by the MIPS or
151 Alpha ECOFF backends. They have different information in the
152 a.out header, but we just copy it all (e.g., gprmask, cprmask and
153 fprmask) and let the swapping routines ensure that only relevant
154 information is written out. */
159 /* Initialize a new section. */
162 _bfd_ecoff_new_section_hook (abfd
, section
)
163 bfd
*abfd ATTRIBUTE_UNUSED
;
166 section
->alignment_power
= 4;
168 if (strcmp (section
->name
, _TEXT
) == 0
169 || strcmp (section
->name
, _INIT
) == 0
170 || strcmp (section
->name
, _FINI
) == 0)
171 section
->flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
172 else if (strcmp (section
->name
, _DATA
) == 0
173 || strcmp (section
->name
, _SDATA
) == 0)
174 section
->flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
175 else if (strcmp (section
->name
, _RDATA
) == 0
176 || strcmp (section
->name
, _LIT8
) == 0
177 || strcmp (section
->name
, _LIT4
) == 0
178 || strcmp (section
->name
, _RCONST
) == 0
179 || strcmp (section
->name
, _PDATA
) == 0)
180 section
->flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
181 else if (strcmp (section
->name
, _BSS
) == 0
182 || strcmp (section
->name
, _SBSS
) == 0)
183 section
->flags
|= SEC_ALLOC
;
184 else if (strcmp (section
->name
, _LIB
) == 0)
186 /* An Irix 4 shared libary. */
187 section
->flags
|= SEC_COFF_SHARED_LIBRARY
;
190 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
191 uncertain about .init on some systems and I don't know how shared
197 /* Determine the machine architecture and type. This is called from
198 the generic COFF routines. It is the inverse of ecoff_get_magic,
199 below. This could be an ECOFF backend routine, with one version
200 for each target, but there aren't all that many ECOFF targets. */
203 _bfd_ecoff_set_arch_mach_hook (abfd
, filehdr
)
207 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
208 enum bfd_architecture arch
;
211 switch (internal_f
->f_magic
)
214 case MIPS_MAGIC_LITTLE
:
216 arch
= bfd_arch_mips
;
220 case MIPS_MAGIC_LITTLE2
:
221 case MIPS_MAGIC_BIG2
:
222 /* MIPS ISA level 2: the r6000 */
223 arch
= bfd_arch_mips
;
227 case MIPS_MAGIC_LITTLE3
:
228 case MIPS_MAGIC_BIG3
:
229 /* MIPS ISA level 3: the r4000 */
230 arch
= bfd_arch_mips
;
235 arch
= bfd_arch_alpha
;
240 arch
= bfd_arch_obscure
;
245 return bfd_default_set_arch_mach (abfd
, arch
, mach
);
248 /* Get the magic number to use based on the architecture and machine.
249 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
252 ecoff_get_magic (abfd
)
257 switch (bfd_get_arch (abfd
))
260 switch (bfd_get_mach (abfd
))
265 big
= MIPS_MAGIC_BIG
;
266 little
= MIPS_MAGIC_LITTLE
;
270 big
= MIPS_MAGIC_BIG2
;
271 little
= MIPS_MAGIC_LITTLE2
;
275 big
= MIPS_MAGIC_BIG3
;
276 little
= MIPS_MAGIC_LITTLE3
;
280 return bfd_big_endian (abfd
) ? big
: little
;
291 /* Get the section s_flags to use for a section. */
294 ecoff_sec_to_styp_flags (name
, flags
)
302 if (strcmp (name
, _TEXT
) == 0)
304 else if (strcmp (name
, _DATA
) == 0)
306 else if (strcmp (name
, _SDATA
) == 0)
308 else if (strcmp (name
, _RDATA
) == 0)
310 else if (strcmp (name
, _LITA
) == 0)
312 else if (strcmp (name
, _LIT8
) == 0)
314 else if (strcmp (name
, _LIT4
) == 0)
316 else if (strcmp (name
, _BSS
) == 0)
318 else if (strcmp (name
, _SBSS
) == 0)
320 else if (strcmp (name
, _INIT
) == 0)
321 styp
= STYP_ECOFF_INIT
;
322 else if (strcmp (name
, _FINI
) == 0)
323 styp
= STYP_ECOFF_FINI
;
324 else if (strcmp (name
, _PDATA
) == 0)
326 else if (strcmp (name
, _XDATA
) == 0)
328 else if (strcmp (name
, _LIB
) == 0)
329 styp
= STYP_ECOFF_LIB
;
330 else if (strcmp (name
, _GOT
) == 0)
332 else if (strcmp (name
, _HASH
) == 0)
334 else if (strcmp (name
, _DYNAMIC
) == 0)
336 else if (strcmp (name
, _LIBLIST
) == 0)
338 else if (strcmp (name
, _RELDYN
) == 0)
340 else if (strcmp (name
, _CONFLIC
) == 0)
342 else if (strcmp (name
, _DYNSTR
) == 0)
344 else if (strcmp (name
, _DYNSYM
) == 0)
346 else if (strcmp (name
, _COMMENT
) == 0)
349 flags
&=~ SEC_NEVER_LOAD
;
351 else if (strcmp (name
, _RCONST
) == 0)
353 else if (flags
& SEC_CODE
)
355 else if (flags
& SEC_DATA
)
357 else if (flags
& SEC_READONLY
)
359 else if (flags
& SEC_LOAD
)
364 if (flags
& SEC_NEVER_LOAD
)
370 /* Get the BFD flags to use for a section. */
373 _bfd_ecoff_styp_to_sec_flags (abfd
, hdr
, name
, section
)
374 bfd
*abfd ATTRIBUTE_UNUSED
;
376 const char *name ATTRIBUTE_UNUSED
;
377 asection
*section ATTRIBUTE_UNUSED
;
379 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
380 long styp_flags
= internal_s
->s_flags
;
381 flagword sec_flags
=0;
383 if (styp_flags
& STYP_NOLOAD
)
384 sec_flags
|= SEC_NEVER_LOAD
;
386 /* For 386 COFF, at least, an unloadable text or data section is
387 actually a shared library section. */
388 if ((styp_flags
& STYP_TEXT
)
389 || (styp_flags
& STYP_ECOFF_INIT
)
390 || (styp_flags
& STYP_ECOFF_FINI
)
391 || (styp_flags
& STYP_DYNAMIC
)
392 || (styp_flags
& STYP_LIBLIST
)
393 || (styp_flags
& STYP_RELDYN
)
394 || styp_flags
== STYP_CONFLIC
395 || (styp_flags
& STYP_DYNSTR
)
396 || (styp_flags
& STYP_DYNSYM
)
397 || (styp_flags
& STYP_HASH
))
399 if (sec_flags
& SEC_NEVER_LOAD
)
400 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
402 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
404 else if ((styp_flags
& STYP_DATA
)
405 || (styp_flags
& STYP_RDATA
)
406 || (styp_flags
& STYP_SDATA
)
407 || styp_flags
== STYP_PDATA
408 || styp_flags
== STYP_XDATA
409 || (styp_flags
& STYP_GOT
)
410 || styp_flags
== STYP_RCONST
)
412 if (sec_flags
& SEC_NEVER_LOAD
)
413 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
415 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
416 if ((styp_flags
& STYP_RDATA
)
417 || styp_flags
== STYP_PDATA
418 || styp_flags
== STYP_RCONST
)
419 sec_flags
|= SEC_READONLY
;
421 else if ((styp_flags
& STYP_BSS
)
422 || (styp_flags
& STYP_SBSS
))
424 sec_flags
|= SEC_ALLOC
;
426 else if ((styp_flags
& STYP_INFO
) || styp_flags
== STYP_COMMENT
)
428 sec_flags
|= SEC_NEVER_LOAD
;
430 else if ((styp_flags
& STYP_LITA
)
431 || (styp_flags
& STYP_LIT8
)
432 || (styp_flags
& STYP_LIT4
))
434 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
436 else if (styp_flags
& STYP_ECOFF_LIB
)
438 sec_flags
|= SEC_COFF_SHARED_LIBRARY
;
442 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
448 /* Read in the symbolic header for an ECOFF object file. */
451 ecoff_slurp_symbolic_header (abfd
)
454 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
455 bfd_size_type external_hdr_size
;
457 HDRR
*internal_symhdr
;
459 /* See if we've already read it in. */
460 if (ecoff_data (abfd
)->debug_info
.symbolic_header
.magic
==
461 backend
->debug_swap
.sym_magic
)
464 /* See whether there is a symbolic header. */
465 if (ecoff_data (abfd
)->sym_filepos
== 0)
467 bfd_get_symcount (abfd
) = 0;
471 /* At this point bfd_get_symcount (abfd) holds the number of symbols
472 as read from the file header, but on ECOFF this is always the
473 size of the symbolic information header. It would be cleaner to
474 handle this when we first read the file in coffgen.c. */
475 external_hdr_size
= backend
->debug_swap
.external_hdr_size
;
476 if (bfd_get_symcount (abfd
) != external_hdr_size
)
478 bfd_set_error (bfd_error_bad_value
);
482 /* Read the symbolic information header. */
483 raw
= (PTR
) bfd_malloc ((size_t) external_hdr_size
);
487 if (bfd_seek (abfd
, ecoff_data (abfd
)->sym_filepos
, SEEK_SET
) == -1
488 || (bfd_read (raw
, external_hdr_size
, 1, abfd
)
489 != external_hdr_size
))
491 internal_symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
492 (*backend
->debug_swap
.swap_hdr_in
) (abfd
, raw
, internal_symhdr
);
494 if (internal_symhdr
->magic
!= backend
->debug_swap
.sym_magic
)
496 bfd_set_error (bfd_error_bad_value
);
500 /* Now we can get the correct number of symbols. */
501 bfd_get_symcount (abfd
) = (internal_symhdr
->isymMax
502 + internal_symhdr
->iextMax
);
513 /* Read in and swap the important symbolic information for an ECOFF
514 object file. This is called by gdb via the read_debug_info entry
515 point in the backend structure. */
518 _bfd_ecoff_slurp_symbolic_info (abfd
, ignore
, debug
)
520 asection
*ignore ATTRIBUTE_UNUSED
;
521 struct ecoff_debug_info
*debug
;
523 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
524 HDRR
*internal_symhdr
;
525 bfd_size_type raw_base
;
526 bfd_size_type raw_size
;
528 bfd_size_type external_fdr_size
;
532 bfd_size_type raw_end
;
533 bfd_size_type cb_end
;
535 BFD_ASSERT (debug
== &ecoff_data (abfd
)->debug_info
);
537 /* Check whether we've already gotten it, and whether there's any to
539 if (ecoff_data (abfd
)->raw_syments
!= (PTR
) NULL
)
541 if (ecoff_data (abfd
)->sym_filepos
== 0)
543 bfd_get_symcount (abfd
) = 0;
547 if (! ecoff_slurp_symbolic_header (abfd
))
550 internal_symhdr
= &debug
->symbolic_header
;
552 /* Read all the symbolic information at once. */
553 raw_base
= (ecoff_data (abfd
)->sym_filepos
554 + backend
->debug_swap
.external_hdr_size
);
556 /* Alpha ecoff makes the determination of raw_size difficult. It has
557 an undocumented debug data section between the symhdr and the first
558 documented section. And the ordering of the sections varies between
559 statically and dynamically linked executables.
560 If bfd supports SEEK_END someday, this code could be simplified. */
564 #define UPDATE_RAW_END(start, count, size) \
565 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
566 if (cb_end > raw_end) \
569 UPDATE_RAW_END (cbLineOffset
, cbLine
, sizeof (unsigned char));
570 UPDATE_RAW_END (cbDnOffset
, idnMax
, backend
->debug_swap
.external_dnr_size
);
571 UPDATE_RAW_END (cbPdOffset
, ipdMax
, backend
->debug_swap
.external_pdr_size
);
572 UPDATE_RAW_END (cbSymOffset
, isymMax
, backend
->debug_swap
.external_sym_size
);
573 UPDATE_RAW_END (cbOptOffset
, ioptMax
, backend
->debug_swap
.external_opt_size
);
574 UPDATE_RAW_END (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
575 UPDATE_RAW_END (cbSsOffset
, issMax
, sizeof (char));
576 UPDATE_RAW_END (cbSsExtOffset
, issExtMax
, sizeof (char));
577 UPDATE_RAW_END (cbFdOffset
, ifdMax
, backend
->debug_swap
.external_fdr_size
);
578 UPDATE_RAW_END (cbRfdOffset
, crfd
, backend
->debug_swap
.external_rfd_size
);
579 UPDATE_RAW_END (cbExtOffset
, iextMax
, backend
->debug_swap
.external_ext_size
);
581 #undef UPDATE_RAW_END
583 raw_size
= raw_end
- raw_base
;
586 ecoff_data (abfd
)->sym_filepos
= 0;
589 raw
= (PTR
) bfd_alloc (abfd
, raw_size
);
593 (ecoff_data (abfd
)->sym_filepos
594 + backend
->debug_swap
.external_hdr_size
),
596 || bfd_read (raw
, raw_size
, 1, abfd
) != raw_size
)
598 bfd_release (abfd
, raw
);
602 ecoff_data (abfd
)->raw_syments
= raw
;
604 /* Get pointers for the numeric offsets in the HDRR structure. */
605 #define FIX(off1, off2, type) \
606 if (internal_symhdr->off1 == 0) \
607 debug->off2 = (type) NULL; \
609 debug->off2 = (type) ((char *) raw \
610 + (internal_symhdr->off1 \
612 FIX (cbLineOffset
, line
, unsigned char *);
613 FIX (cbDnOffset
, external_dnr
, PTR
);
614 FIX (cbPdOffset
, external_pdr
, PTR
);
615 FIX (cbSymOffset
, external_sym
, PTR
);
616 FIX (cbOptOffset
, external_opt
, PTR
);
617 FIX (cbAuxOffset
, external_aux
, union aux_ext
*);
618 FIX (cbSsOffset
, ss
, char *);
619 FIX (cbSsExtOffset
, ssext
, char *);
620 FIX (cbFdOffset
, external_fdr
, PTR
);
621 FIX (cbRfdOffset
, external_rfd
, PTR
);
622 FIX (cbExtOffset
, external_ext
, PTR
);
625 /* I don't want to always swap all the data, because it will just
626 waste time and most programs will never look at it. The only
627 time the linker needs most of the debugging information swapped
628 is when linking big-endian and little-endian MIPS object files
629 together, which is not a common occurrence.
631 We need to look at the fdr to deal with a lot of information in
632 the symbols, so we swap them here. */
633 debug
->fdr
= (struct fdr
*) bfd_alloc (abfd
,
634 (internal_symhdr
->ifdMax
*
635 sizeof (struct fdr
)));
636 if (debug
->fdr
== NULL
)
638 external_fdr_size
= backend
->debug_swap
.external_fdr_size
;
639 fdr_ptr
= debug
->fdr
;
640 fraw_src
= (char *) debug
->external_fdr
;
641 fraw_end
= fraw_src
+ internal_symhdr
->ifdMax
* external_fdr_size
;
642 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
643 (*backend
->debug_swap
.swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
648 /* ECOFF symbol table routines. The ECOFF symbol table is described
649 in gcc/mips-tfile.c. */
651 /* ECOFF uses two common sections. One is the usual one, and the
652 other is for small objects. All the small objects are kept
653 together, and then referenced via the gp pointer, which yields
654 faster assembler code. This is what we use for the small common
656 static asection ecoff_scom_section
;
657 static asymbol ecoff_scom_symbol
;
658 static asymbol
*ecoff_scom_symbol_ptr
;
660 /* Create an empty symbol. */
663 _bfd_ecoff_make_empty_symbol (abfd
)
666 ecoff_symbol_type
*new;
668 new = (ecoff_symbol_type
*) bfd_alloc (abfd
, sizeof (ecoff_symbol_type
));
669 if (new == (ecoff_symbol_type
*) NULL
)
670 return (asymbol
*) NULL
;
671 memset ((PTR
) new, 0, sizeof *new);
672 new->symbol
.section
= (asection
*) NULL
;
673 new->fdr
= (FDR
*) NULL
;
676 new->symbol
.the_bfd
= abfd
;
680 /* Set the BFD flags and section for an ECOFF symbol. */
683 ecoff_set_symbol_info (abfd
, ecoff_sym
, asym
, ext
, weak
)
690 asym
->the_bfd
= abfd
;
691 asym
->value
= ecoff_sym
->value
;
692 asym
->section
= &bfd_debug_section
;
695 /* Most symbol types are just for debugging. */
696 switch (ecoff_sym
->st
)
705 if (ECOFF_IS_STAB (ecoff_sym
))
707 asym
->flags
= BSF_DEBUGGING
;
712 asym
->flags
= BSF_DEBUGGING
;
717 asym
->flags
= BSF_EXPORT
| BSF_WEAK
;
719 asym
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
722 asym
->flags
= BSF_LOCAL
;
723 /* Normally, a local stProc symbol will have a corresponding
724 external symbol. We mark the local symbol as a debugging
725 symbol, in order to prevent nm from printing both out.
726 Similarly, we mark stLabel and stabs symbols as debugging
727 symbols. In both cases, we do want to set the value
728 correctly based on the symbol class. */
729 if (ecoff_sym
->st
== stProc
730 || ecoff_sym
->st
== stLabel
731 || ECOFF_IS_STAB (ecoff_sym
))
732 asym
->flags
|= BSF_DEBUGGING
;
734 switch (ecoff_sym
->sc
)
737 /* Used for compiler generated labels. Leave them in the
738 debugging section, and mark them as local. If BSF_DEBUGGING
739 is set, then nm does not display them for some reason. If no
740 flags are set then the linker whines about them. */
741 asym
->flags
= BSF_LOCAL
;
744 asym
->section
= bfd_make_section_old_way (abfd
, ".text");
745 asym
->value
-= asym
->section
->vma
;
748 asym
->section
= bfd_make_section_old_way (abfd
, ".data");
749 asym
->value
-= asym
->section
->vma
;
752 asym
->section
= bfd_make_section_old_way (abfd
, ".bss");
753 asym
->value
-= asym
->section
->vma
;
756 asym
->flags
= BSF_DEBUGGING
;
759 asym
->section
= bfd_abs_section_ptr
;
762 asym
->section
= bfd_und_section_ptr
;
772 asym
->flags
= BSF_DEBUGGING
;
775 asym
->section
= bfd_make_section_old_way (abfd
, ".sdata");
776 asym
->value
-= asym
->section
->vma
;
779 asym
->section
= bfd_make_section_old_way (abfd
, ".sbss");
780 asym
->value
-= asym
->section
->vma
;
783 asym
->section
= bfd_make_section_old_way (abfd
, ".rdata");
784 asym
->value
-= asym
->section
->vma
;
787 asym
->flags
= BSF_DEBUGGING
;
790 if (asym
->value
> ecoff_data (abfd
)->gp_size
)
792 asym
->section
= bfd_com_section_ptr
;
798 if (ecoff_scom_section
.name
== NULL
)
800 /* Initialize the small common section. */
801 ecoff_scom_section
.name
= SCOMMON
;
802 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
803 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
804 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
805 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
806 ecoff_scom_symbol
.name
= SCOMMON
;
807 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
808 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
809 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
811 asym
->section
= &ecoff_scom_section
;
816 asym
->flags
= BSF_DEBUGGING
;
819 asym
->section
= bfd_und_section_ptr
;
824 asym
->section
= bfd_make_section_old_way (abfd
, ".init");
825 asym
->value
-= asym
->section
->vma
;
830 asym
->flags
= BSF_DEBUGGING
;
833 asym
->section
= bfd_make_section_old_way (abfd
, ".fini");
834 asym
->value
-= asym
->section
->vma
;
837 asym
->section
= bfd_make_section_old_way (abfd
, ".rconst");
838 asym
->value
-= asym
->section
->vma
;
844 /* Look for special constructors symbols and make relocation entries
845 in a special construction section. These are produced by the
846 -fgnu-linker argument to g++. */
847 if (ECOFF_IS_STAB (ecoff_sym
))
849 switch (ECOFF_UNMARK_STAB (ecoff_sym
->index
))
859 /* This code is no longer needed. It used to be used to
860 make the linker handle set symbols, but they are now
861 handled in the add_symbols routine instead. */
865 arelent_chain
*reloc_chain
;
866 unsigned int bitsize
;
868 /* Get a section with the same name as the symbol (usually
869 __CTOR_LIST__ or __DTOR_LIST__). FIXME: gcc uses the
870 name ___CTOR_LIST (three underscores). We need
871 __CTOR_LIST (two underscores), since ECOFF doesn't use
872 a leading underscore. This should be handled by gcc,
873 but instead we do it here. Actually, this should all
874 be done differently anyhow. */
875 name
= bfd_asymbol_name (asym
);
876 if (name
[0] == '_' && name
[1] == '_' && name
[2] == '_')
881 section
= bfd_get_section_by_name (abfd
, name
);
882 if (section
== (asection
*) NULL
)
886 copy
= (char *) bfd_alloc (abfd
, strlen (name
) + 1);
890 section
= bfd_make_section (abfd
, copy
);
893 /* Build a reloc pointing to this constructor. */
895 (arelent_chain
*) bfd_alloc (abfd
, sizeof (arelent_chain
));
898 reloc_chain
->relent
.sym_ptr_ptr
=
899 bfd_get_section (asym
)->symbol_ptr_ptr
;
900 reloc_chain
->relent
.address
= section
->_raw_size
;
901 reloc_chain
->relent
.addend
= asym
->value
;
902 reloc_chain
->relent
.howto
=
903 ecoff_backend (abfd
)->constructor_reloc
;
905 /* Set up the constructor section to hold the reloc. */
906 section
->flags
= SEC_CONSTRUCTOR
;
907 ++section
->reloc_count
;
909 /* Constructor sections must be rounded to a boundary
910 based on the bitsize. These are not real sections--
911 they are handled specially by the linker--so the ECOFF
912 16 byte alignment restriction does not apply. */
913 bitsize
= ecoff_backend (abfd
)->constructor_bitsize
;
914 section
->alignment_power
= 1;
915 while ((1 << section
->alignment_power
) < bitsize
/ 8)
916 ++section
->alignment_power
;
918 reloc_chain
->next
= section
->constructor_chain
;
919 section
->constructor_chain
= reloc_chain
;
920 section
->_raw_size
+= bitsize
/ 8;
924 /* Mark the symbol as a constructor. */
925 asym
->flags
|= BSF_CONSTRUCTOR
;
933 /* Read an ECOFF symbol table. */
936 _bfd_ecoff_slurp_symbol_table (abfd
)
939 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
940 const bfd_size_type external_ext_size
941 = backend
->debug_swap
.external_ext_size
;
942 const bfd_size_type external_sym_size
943 = backend
->debug_swap
.external_sym_size
;
944 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
945 = backend
->debug_swap
.swap_ext_in
;
946 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
947 = backend
->debug_swap
.swap_sym_in
;
948 bfd_size_type internal_size
;
949 ecoff_symbol_type
*internal
;
950 ecoff_symbol_type
*internal_ptr
;
956 /* If we've already read in the symbol table, do nothing. */
957 if (ecoff_data (abfd
)->canonical_symbols
!= NULL
)
960 /* Get the symbolic information. */
961 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, (asection
*) NULL
,
962 &ecoff_data (abfd
)->debug_info
))
964 if (bfd_get_symcount (abfd
) == 0)
967 internal_size
= bfd_get_symcount (abfd
) * sizeof (ecoff_symbol_type
);
968 internal
= (ecoff_symbol_type
*) bfd_alloc (abfd
, internal_size
);
969 if (internal
== NULL
)
972 internal_ptr
= internal
;
973 eraw_src
= (char *) ecoff_data (abfd
)->debug_info
.external_ext
;
975 + (ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
976 * external_ext_size
));
977 for (; eraw_src
< eraw_end
; eraw_src
+= external_ext_size
, internal_ptr
++)
981 (*swap_ext_in
) (abfd
, (PTR
) eraw_src
, &internal_esym
);
982 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ssext
983 + internal_esym
.asym
.iss
);
984 if (!ecoff_set_symbol_info (abfd
, &internal_esym
.asym
,
985 &internal_ptr
->symbol
, 1,
986 internal_esym
.weakext
))
988 /* The alpha uses a negative ifd field for section symbols. */
989 if (internal_esym
.ifd
>= 0)
990 internal_ptr
->fdr
= (ecoff_data (abfd
)->debug_info
.fdr
991 + internal_esym
.ifd
);
993 internal_ptr
->fdr
= NULL
;
994 internal_ptr
->local
= false;
995 internal_ptr
->native
= (PTR
) eraw_src
;
998 /* The local symbols must be accessed via the fdr's, because the
999 string and aux indices are relative to the fdr information. */
1000 fdr_ptr
= ecoff_data (abfd
)->debug_info
.fdr
;
1001 fdr_end
= fdr_ptr
+ ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
;
1002 for (; fdr_ptr
< fdr_end
; fdr_ptr
++)
1007 lraw_src
= ((char *) ecoff_data (abfd
)->debug_info
.external_sym
1008 + fdr_ptr
->isymBase
* external_sym_size
);
1009 lraw_end
= lraw_src
+ fdr_ptr
->csym
* external_sym_size
;
1011 lraw_src
< lraw_end
;
1012 lraw_src
+= external_sym_size
, internal_ptr
++)
1016 (*swap_sym_in
) (abfd
, (PTR
) lraw_src
, &internal_sym
);
1017 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ss
1019 + internal_sym
.iss
);
1020 if (!ecoff_set_symbol_info (abfd
, &internal_sym
,
1021 &internal_ptr
->symbol
, 0, 0))
1023 internal_ptr
->fdr
= fdr_ptr
;
1024 internal_ptr
->local
= true;
1025 internal_ptr
->native
= (PTR
) lraw_src
;
1029 ecoff_data (abfd
)->canonical_symbols
= internal
;
1034 /* Return the amount of space needed for the canonical symbols. */
1037 _bfd_ecoff_get_symtab_upper_bound (abfd
)
1040 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, (asection
*) NULL
,
1041 &ecoff_data (abfd
)->debug_info
))
1044 if (bfd_get_symcount (abfd
) == 0)
1047 return (bfd_get_symcount (abfd
) + 1) * (sizeof (ecoff_symbol_type
*));
1050 /* Get the canonical symbols. */
1053 _bfd_ecoff_get_symtab (abfd
, alocation
)
1055 asymbol
**alocation
;
1057 unsigned int counter
= 0;
1058 ecoff_symbol_type
*symbase
;
1059 ecoff_symbol_type
**location
= (ecoff_symbol_type
**) alocation
;
1061 if (_bfd_ecoff_slurp_symbol_table (abfd
) == false)
1063 if (bfd_get_symcount (abfd
) == 0)
1066 symbase
= ecoff_data (abfd
)->canonical_symbols
;
1067 while (counter
< bfd_get_symcount (abfd
))
1069 *(location
++) = symbase
++;
1072 *location
++ = (ecoff_symbol_type
*) NULL
;
1073 return bfd_get_symcount (abfd
);
1076 /* Turn ECOFF type information into a printable string.
1077 ecoff_emit_aggregate and ecoff_type_to_string are from
1078 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1080 /* Write aggregate information to a string. */
1083 ecoff_emit_aggregate (abfd
, fdr
, string
, rndx
, isym
, which
)
1091 const struct ecoff_debug_swap
* const debug_swap
=
1092 &ecoff_backend (abfd
)->debug_swap
;
1093 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1094 unsigned int ifd
= rndx
->rfd
;
1095 unsigned int indx
= rndx
->index
;
1101 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1102 struct return type of a procedure compiled without -g. */
1103 if (ifd
== 0xffffffff
1104 || (rndx
->rfd
== 0xfff && indx
== 0))
1105 name
= "<undefined>";
1106 else if (indx
== indexNil
)
1112 if (debug_info
->external_rfd
== NULL
)
1113 fdr
= debug_info
->fdr
+ ifd
;
1118 (*debug_swap
->swap_rfd_in
) (abfd
,
1119 ((char *) debug_info
->external_rfd
1120 + ((fdr
->rfdBase
+ ifd
)
1121 * debug_swap
->external_rfd_size
)),
1123 fdr
= debug_info
->fdr
+ rfd
;
1126 indx
+= fdr
->isymBase
;
1128 (*debug_swap
->swap_sym_in
) (abfd
,
1129 ((char *) debug_info
->external_sym
1130 + indx
* debug_swap
->external_sym_size
),
1133 name
= debug_info
->ss
+ fdr
->issBase
+ sym
.iss
;
1137 "%s %s { ifd = %u, index = %lu }",
1140 + debug_info
->symbolic_header
.iextMax
));
1143 /* Convert the type information to string format. */
1146 ecoff_type_to_string (abfd
, fdr
, indx
)
1151 union aux_ext
*aux_ptr
;
1160 unsigned int basic_type
;
1163 static char buffer2
[1024];
1168 aux_ptr
= ecoff_data (abfd
)->debug_info
.external_aux
+ fdr
->iauxBase
;
1169 bigendian
= fdr
->fBigendian
;
1171 for (i
= 0; i
< 7; i
++)
1173 qualifiers
[i
].low_bound
= 0;
1174 qualifiers
[i
].high_bound
= 0;
1175 qualifiers
[i
].stride
= 0;
1178 if (AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
]) == (bfd_vma
) -1)
1179 return "-1 (no type)";
1180 _bfd_ecoff_swap_tir_in (bigendian
, &aux_ptr
[indx
++].a_ti
, &u
.ti
);
1182 basic_type
= u
.ti
.bt
;
1183 qualifiers
[0].type
= u
.ti
.tq0
;
1184 qualifiers
[1].type
= u
.ti
.tq1
;
1185 qualifiers
[2].type
= u
.ti
.tq2
;
1186 qualifiers
[3].type
= u
.ti
.tq3
;
1187 qualifiers
[4].type
= u
.ti
.tq4
;
1188 qualifiers
[5].type
= u
.ti
.tq5
;
1189 qualifiers
[6].type
= tqNil
;
1192 * Go get the basic type.
1196 case btNil
: /* undefined */
1200 case btAdr
: /* address - integer same size as pointer */
1201 strcpy (p1
, "address");
1204 case btChar
: /* character */
1205 strcpy (p1
, "char");
1208 case btUChar
: /* unsigned character */
1209 strcpy (p1
, "unsigned char");
1212 case btShort
: /* short */
1213 strcpy (p1
, "short");
1216 case btUShort
: /* unsigned short */
1217 strcpy (p1
, "unsigned short");
1220 case btInt
: /* int */
1224 case btUInt
: /* unsigned int */
1225 strcpy (p1
, "unsigned int");
1228 case btLong
: /* long */
1229 strcpy (p1
, "long");
1232 case btULong
: /* unsigned long */
1233 strcpy (p1
, "unsigned long");
1236 case btFloat
: /* float (real) */
1237 strcpy (p1
, "float");
1240 case btDouble
: /* Double (real) */
1241 strcpy (p1
, "double");
1244 /* Structures add 1-2 aux words:
1245 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1246 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1248 case btStruct
: /* Structure (Record) */
1249 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1250 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1251 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1253 indx
++; /* skip aux words */
1256 /* Unions add 1-2 aux words:
1257 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1258 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1260 case btUnion
: /* Union */
1261 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1262 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1263 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1265 indx
++; /* skip aux words */
1268 /* Enumerations add 1-2 aux words:
1269 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1270 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1272 case btEnum
: /* Enumeration */
1273 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1274 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1275 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1277 indx
++; /* skip aux words */
1280 case btTypedef
: /* defined via a typedef, isymRef points */
1281 strcpy (p1
, "typedef");
1284 case btRange
: /* subrange of int */
1285 strcpy (p1
, "subrange");
1288 case btSet
: /* pascal sets */
1292 case btComplex
: /* fortran complex */
1293 strcpy (p1
, "complex");
1296 case btDComplex
: /* fortran double complex */
1297 strcpy (p1
, "double complex");
1300 case btIndirect
: /* forward or unnamed typedef */
1301 strcpy (p1
, "forward/unamed typedef");
1304 case btFixedDec
: /* Fixed Decimal */
1305 strcpy (p1
, "fixed decimal");
1308 case btFloatDec
: /* Float Decimal */
1309 strcpy (p1
, "float decimal");
1312 case btString
: /* Varying Length Character String */
1313 strcpy (p1
, "string");
1316 case btBit
: /* Aligned Bit String */
1320 case btPicture
: /* Picture */
1321 strcpy (p1
, "picture");
1324 case btVoid
: /* Void */
1325 strcpy (p1
, "void");
1329 sprintf (p1
, _("Unknown basic type %d"), (int) basic_type
);
1333 p1
+= strlen (buffer1
);
1336 * If this is a bitfield, get the bitsize.
1342 bitsize
= AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
++]);
1343 sprintf (p1
, " : %d", bitsize
);
1344 p1
+= strlen (buffer1
);
1348 * Deal with any qualifiers.
1350 if (qualifiers
[0].type
!= tqNil
)
1353 * Snarf up any array bounds in the correct order. Arrays
1354 * store 5 successive words in the aux. table:
1355 * word 0 RNDXR to type of the bounds (ie, int)
1356 * word 1 Current file descriptor index
1358 * word 3 high bound (or -1 if [])
1359 * word 4 stride size in bits
1361 for (i
= 0; i
< 7; i
++)
1363 if (qualifiers
[i
].type
== tqArray
)
1365 qualifiers
[i
].low_bound
=
1366 AUX_GET_DNLOW (bigendian
, &aux_ptr
[indx
+2]);
1367 qualifiers
[i
].high_bound
=
1368 AUX_GET_DNHIGH (bigendian
, &aux_ptr
[indx
+3]);
1369 qualifiers
[i
].stride
=
1370 AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
+4]);
1376 * Now print out the qualifiers.
1378 for (i
= 0; i
< 6; i
++)
1380 switch (qualifiers
[i
].type
)
1387 strcpy (p2
, "ptr to ");
1388 p2
+= sizeof ("ptr to ")-1;
1392 strcpy (p2
, "volatile ");
1393 p2
+= sizeof ("volatile ")-1;
1397 strcpy (p2
, "far ");
1398 p2
+= sizeof ("far ")-1;
1402 strcpy (p2
, "func. ret. ");
1403 p2
+= sizeof ("func. ret. ");
1408 int first_array
= i
;
1411 /* Print array bounds reversed (ie, in the order the C
1412 programmer writes them). C is such a fun language.... */
1414 while (i
< 5 && qualifiers
[i
+1].type
== tqArray
)
1417 for (j
= i
; j
>= first_array
; j
--)
1419 strcpy (p2
, "array [");
1420 p2
+= sizeof ("array [")-1;
1421 if (qualifiers
[j
].low_bound
!= 0)
1423 "%ld:%ld {%ld bits}",
1424 (long) qualifiers
[j
].low_bound
,
1425 (long) qualifiers
[j
].high_bound
,
1426 (long) qualifiers
[j
].stride
);
1428 else if (qualifiers
[j
].high_bound
!= -1)
1431 (long) (qualifiers
[j
].high_bound
+ 1),
1432 (long) (qualifiers
[j
].stride
));
1435 sprintf (p2
, " {%ld bits}", (long) (qualifiers
[j
].stride
));
1438 strcpy (p2
, "] of ");
1439 p2
+= sizeof ("] of ")-1;
1447 strcpy (p2
, buffer1
);
1451 /* Return information about ECOFF symbol SYMBOL in RET. */
1454 _bfd_ecoff_get_symbol_info (abfd
, symbol
, ret
)
1455 bfd
*abfd ATTRIBUTE_UNUSED
;
1459 bfd_symbol_info (symbol
, ret
);
1462 /* Return whether this is a local label. */
1465 _bfd_ecoff_bfd_is_local_label_name (abfd
, name
)
1466 bfd
*abfd ATTRIBUTE_UNUSED
;
1469 return name
[0] == '$';
1472 /* Print information about an ECOFF symbol. */
1475 _bfd_ecoff_print_symbol (abfd
, filep
, symbol
, how
)
1479 bfd_print_symbol_type how
;
1481 const struct ecoff_debug_swap
* const debug_swap
1482 = &ecoff_backend (abfd
)->debug_swap
;
1483 FILE *file
= (FILE *)filep
;
1487 case bfd_print_symbol_name
:
1488 fprintf (file
, "%s", symbol
->name
);
1490 case bfd_print_symbol_more
:
1491 if (ecoffsymbol (symbol
)->local
)
1495 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1497 fprintf (file
, "ecoff local ");
1498 fprintf_vma (file
, (bfd_vma
) ecoff_sym
.value
);
1499 fprintf (file
, " %x %x", (unsigned) ecoff_sym
.st
,
1500 (unsigned) ecoff_sym
.sc
);
1506 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1508 fprintf (file
, "ecoff extern ");
1509 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1510 fprintf (file
, " %x %x", (unsigned) ecoff_ext
.asym
.st
,
1511 (unsigned) ecoff_ext
.asym
.sc
);
1514 case bfd_print_symbol_all
:
1515 /* Print out the symbols in a reasonable way */
1524 if (ecoffsymbol (symbol
)->local
)
1526 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1529 pos
= ((((char *) ecoffsymbol (symbol
)->native
1530 - (char *) ecoff_data (abfd
)->debug_info
.external_sym
)
1531 / debug_swap
->external_sym_size
)
1532 + ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
);
1539 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1542 pos
= (((char *) ecoffsymbol (symbol
)->native
1543 - (char *) ecoff_data (abfd
)->debug_info
.external_ext
)
1544 / debug_swap
->external_ext_size
);
1545 jmptbl
= ecoff_ext
.jmptbl
? 'j' : ' ';
1546 cobol_main
= ecoff_ext
.cobol_main
? 'c' : ' ';
1547 weakext
= ecoff_ext
.weakext
? 'w' : ' ';
1550 fprintf (file
, "[%3d] %c ",
1552 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1553 fprintf (file
, " st %x sc %x indx %x %c%c%c %s",
1554 (unsigned) ecoff_ext
.asym
.st
,
1555 (unsigned) ecoff_ext
.asym
.sc
,
1556 (unsigned) ecoff_ext
.asym
.index
,
1557 jmptbl
, cobol_main
, weakext
,
1560 if (ecoffsymbol (symbol
)->fdr
!= NULL
1561 && ecoff_ext
.asym
.index
!= indexNil
)
1566 bfd_size_type sym_base
;
1567 union aux_ext
*aux_base
;
1569 fdr
= ecoffsymbol (symbol
)->fdr
;
1570 indx
= ecoff_ext
.asym
.index
;
1572 /* sym_base is used to map the fdr relative indices which
1573 appear in the file to the position number which we are
1575 sym_base
= fdr
->isymBase
;
1576 if (ecoffsymbol (symbol
)->local
)
1578 ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
1580 /* aux_base is the start of the aux entries for this file;
1581 asym.index is an offset from this. */
1582 aux_base
= (ecoff_data (abfd
)->debug_info
.external_aux
1585 /* The aux entries are stored in host byte order; the
1586 order is indicated by a bit in the fdr. */
1587 bigendian
= fdr
->fBigendian
;
1589 /* This switch is basically from gcc/mips-tdump.c */
1590 switch (ecoff_ext
.asym
.st
)
1598 fprintf (file
, _("\n End+1 symbol: %ld"),
1599 (long) (indx
+ sym_base
));
1603 if (ecoff_ext
.asym
.sc
== scText
1604 || ecoff_ext
.asym
.sc
== scInfo
)
1605 fprintf (file
, _("\n First symbol: %ld"),
1606 (long) (indx
+ sym_base
));
1608 fprintf (file
, _("\n First symbol: %ld"),
1610 (AUX_GET_ISYM (bigendian
,
1611 &aux_base
[ecoff_ext
.asym
.index
])
1617 if (ECOFF_IS_STAB (&ecoff_ext
.asym
))
1619 else if (ecoffsymbol (symbol
)->local
)
1620 fprintf (file
, _("\n End+1 symbol: %-7ld Type: %s"),
1622 (AUX_GET_ISYM (bigendian
,
1623 &aux_base
[ecoff_ext
.asym
.index
])
1625 ecoff_type_to_string (abfd
, fdr
, indx
+ 1));
1627 fprintf (file
, _("\n Local symbol: %ld"),
1630 + (ecoff_data (abfd
)
1631 ->debug_info
.symbolic_header
.iextMax
)));
1635 fprintf (file
, _("\n struct; End+1 symbol: %ld"),
1636 (long) (indx
+ sym_base
));
1640 fprintf (file
, _("\n union; End+1 symbol: %ld"),
1641 (long) (indx
+ sym_base
));
1645 fprintf (file
, _("\n enum; End+1 symbol: %ld"),
1646 (long) (indx
+ sym_base
));
1650 if (! ECOFF_IS_STAB (&ecoff_ext
.asym
))
1651 fprintf (file
, _("\n Type: %s"),
1652 ecoff_type_to_string (abfd
, fdr
, indx
));
1661 /* Read in the relocs for a section. */
1664 ecoff_slurp_reloc_table (abfd
, section
, symbols
)
1669 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1670 arelent
*internal_relocs
;
1671 bfd_size_type external_reloc_size
;
1672 bfd_size_type external_relocs_size
;
1673 char *external_relocs
;
1677 if (section
->relocation
!= (arelent
*) NULL
1678 || section
->reloc_count
== 0
1679 || (section
->flags
& SEC_CONSTRUCTOR
) != 0)
1682 if (_bfd_ecoff_slurp_symbol_table (abfd
) == false)
1685 internal_relocs
= (arelent
*) bfd_alloc (abfd
,
1687 * section
->reloc_count
));
1688 external_reloc_size
= backend
->external_reloc_size
;
1689 external_relocs_size
= external_reloc_size
* section
->reloc_count
;
1690 external_relocs
= (char *) bfd_alloc (abfd
, external_relocs_size
);
1691 if (internal_relocs
== (arelent
*) NULL
1692 || external_relocs
== (char *) NULL
)
1694 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1696 if (bfd_read (external_relocs
, 1, external_relocs_size
, abfd
)
1697 != external_relocs_size
)
1700 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1702 struct internal_reloc intern
;
1704 (*backend
->swap_reloc_in
) (abfd
,
1705 external_relocs
+ i
* external_reloc_size
,
1708 if (intern
.r_extern
)
1710 /* r_symndx is an index into the external symbols. */
1711 BFD_ASSERT (intern
.r_symndx
>= 0
1713 < (ecoff_data (abfd
)
1714 ->debug_info
.symbolic_header
.iextMax
)));
1715 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1718 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1719 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1721 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1726 CONST
char *sec_name
;
1729 /* r_symndx is a section key. */
1730 switch (intern
.r_symndx
)
1732 case RELOC_SECTION_TEXT
: sec_name
= ".text"; break;
1733 case RELOC_SECTION_RDATA
: sec_name
= ".rdata"; break;
1734 case RELOC_SECTION_DATA
: sec_name
= ".data"; break;
1735 case RELOC_SECTION_SDATA
: sec_name
= ".sdata"; break;
1736 case RELOC_SECTION_SBSS
: sec_name
= ".sbss"; break;
1737 case RELOC_SECTION_BSS
: sec_name
= ".bss"; break;
1738 case RELOC_SECTION_INIT
: sec_name
= ".init"; break;
1739 case RELOC_SECTION_LIT8
: sec_name
= ".lit8"; break;
1740 case RELOC_SECTION_LIT4
: sec_name
= ".lit4"; break;
1741 case RELOC_SECTION_XDATA
: sec_name
= ".xdata"; break;
1742 case RELOC_SECTION_PDATA
: sec_name
= ".pdata"; break;
1743 case RELOC_SECTION_FINI
: sec_name
= ".fini"; break;
1744 case RELOC_SECTION_LITA
: sec_name
= ".lita"; break;
1745 case RELOC_SECTION_RCONST
: sec_name
= ".rconst"; break;
1749 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1750 if (sec
== (asection
*) NULL
)
1752 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1754 rptr
->addend
= - bfd_get_section_vma (abfd
, sec
);
1757 rptr
->address
= intern
.r_vaddr
- bfd_get_section_vma (abfd
, section
);
1759 /* Let the backend select the howto field and do any other
1760 required processing. */
1761 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1764 bfd_release (abfd
, external_relocs
);
1766 section
->relocation
= internal_relocs
;
1771 /* Get a canonical list of relocs. */
1774 _bfd_ecoff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
1782 if (section
->flags
& SEC_CONSTRUCTOR
)
1784 arelent_chain
*chain
;
1786 /* This section has relocs made up by us, not the file, so take
1787 them out of their chain and place them into the data area
1789 for (count
= 0, chain
= section
->constructor_chain
;
1790 count
< section
->reloc_count
;
1791 count
++, chain
= chain
->next
)
1792 *relptr
++ = &chain
->relent
;
1798 if (ecoff_slurp_reloc_table (abfd
, section
, symbols
) == false)
1801 tblptr
= section
->relocation
;
1803 for (count
= 0; count
< section
->reloc_count
; count
++)
1804 *relptr
++ = tblptr
++;
1807 *relptr
= (arelent
*) NULL
;
1809 return section
->reloc_count
;
1812 /* Provided a BFD, a section and an offset into the section, calculate
1813 and return the name of the source file and the line nearest to the
1817 _bfd_ecoff_find_nearest_line (abfd
, section
, ignore_symbols
, offset
,
1818 filename_ptr
, functionname_ptr
, retline_ptr
)
1821 asymbol
**ignore_symbols ATTRIBUTE_UNUSED
;
1823 CONST
char **filename_ptr
;
1824 CONST
char **functionname_ptr
;
1825 unsigned int *retline_ptr
;
1827 const struct ecoff_debug_swap
* const debug_swap
1828 = &ecoff_backend (abfd
)->debug_swap
;
1829 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1830 struct ecoff_find_line
*line_info
;
1832 /* Make sure we have the FDR's. */
1833 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, (asection
*) NULL
, debug_info
)
1834 || bfd_get_symcount (abfd
) == 0)
1837 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1839 ecoff_data (abfd
)->find_line_info
=
1840 ((struct ecoff_find_line
*)
1841 bfd_zalloc (abfd
, sizeof (struct ecoff_find_line
)));
1842 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1845 line_info
= ecoff_data (abfd
)->find_line_info
;
1847 return _bfd_ecoff_locate_line (abfd
, section
, offset
, debug_info
,
1848 debug_swap
, line_info
, filename_ptr
,
1849 functionname_ptr
, retline_ptr
);
1852 /* Copy private BFD data. This is called by objcopy and strip. We
1853 use it to copy the ECOFF debugging information from one BFD to the
1854 other. It would be theoretically possible to represent the ECOFF
1855 debugging information in the symbol table. However, it would be a
1856 lot of work, and there would be little gain (gas, gdb, and ld
1857 already access the ECOFF debugging information via the
1858 ecoff_debug_info structure, and that structure would have to be
1859 retained in order to support ECOFF debugging in MIPS ELF).
1861 The debugging information for the ECOFF external symbols comes from
1862 the symbol table, so this function only handles the other debugging
1866 _bfd_ecoff_bfd_copy_private_bfd_data (ibfd
, obfd
)
1870 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
1871 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
1873 asymbol
**sym_ptr_ptr
;
1877 /* We only want to copy information over if both BFD's use ECOFF
1879 if (bfd_get_flavour (ibfd
) != bfd_target_ecoff_flavour
1880 || bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
1883 /* Copy the GP value and the register masks. */
1884 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
1885 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
1886 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
1887 for (i
= 0; i
< 3; i
++)
1888 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
1890 /* Copy the version stamp. */
1891 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
1893 /* If there are no symbols, don't copy any debugging information. */
1894 c
= bfd_get_symcount (obfd
);
1895 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1896 if (c
== 0 || sym_ptr_ptr
== (asymbol
**) NULL
)
1899 /* See if there are any local symbols. */
1901 for (; c
> 0; c
--, sym_ptr_ptr
++)
1903 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
1912 /* There are some local symbols. We just bring over all the
1913 debugging information. FIXME: This is not quite the right
1914 thing to do. If the user has asked us to discard all
1915 debugging information, then we are probably going to wind up
1916 keeping it because there will probably be some local symbol
1917 which objcopy did not discard. We should actually break
1918 apart the debugging information and only keep that which
1919 applies to the symbols we want to keep. */
1920 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
1921 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
1922 oinfo
->line
= iinfo
->line
;
1924 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
1925 oinfo
->external_dnr
= iinfo
->external_dnr
;
1927 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
1928 oinfo
->external_pdr
= iinfo
->external_pdr
;
1930 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
1931 oinfo
->external_sym
= iinfo
->external_sym
;
1933 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
1934 oinfo
->external_opt
= iinfo
->external_opt
;
1936 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
1937 oinfo
->external_aux
= iinfo
->external_aux
;
1939 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
1940 oinfo
->ss
= iinfo
->ss
;
1942 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
1943 oinfo
->external_fdr
= iinfo
->external_fdr
;
1945 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
1946 oinfo
->external_rfd
= iinfo
->external_rfd
;
1950 /* We are discarding all the local symbol information. Look
1951 through the external symbols and remove all references to FDR
1952 or aux information. */
1953 c
= bfd_get_symcount (obfd
);
1954 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1955 for (; c
> 0; c
--, sym_ptr_ptr
++)
1959 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
1960 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
1962 esym
.asym
.index
= indexNil
;
1963 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
1964 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
1971 /* Set the architecture. The supported architecture is stored in the
1972 backend pointer. We always set the architecture anyhow, since many
1973 callers ignore the return value. */
1976 _bfd_ecoff_set_arch_mach (abfd
, arch
, machine
)
1978 enum bfd_architecture arch
;
1979 unsigned long machine
;
1981 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1982 return arch
== ecoff_backend (abfd
)->arch
;
1985 /* Get the size of the section headers. */
1988 _bfd_ecoff_sizeof_headers (abfd
, reloc
)
1990 boolean reloc ATTRIBUTE_UNUSED
;
1997 for (current
= abfd
->sections
;
1998 current
!= (asection
*)NULL
;
1999 current
= current
->next
)
2002 ret
= (bfd_coff_filhsz (abfd
)
2003 + bfd_coff_aoutsz (abfd
)
2004 + c
* bfd_coff_scnhsz (abfd
));
2005 return BFD_ALIGN (ret
, 16);
2008 /* Get the contents of a section. */
2011 _bfd_ecoff_get_section_contents (abfd
, section
, location
, offset
, count
)
2016 bfd_size_type count
;
2018 return _bfd_generic_get_section_contents (abfd
, section
, location
,
2022 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
2023 called via qsort. */
2026 ecoff_sort_hdrs (arg1
, arg2
)
2030 const asection
*hdr1
= *(const asection
**) arg1
;
2031 const asection
*hdr2
= *(const asection
**) arg2
;
2033 if ((hdr1
->flags
& SEC_ALLOC
) != 0)
2035 if ((hdr2
->flags
& SEC_ALLOC
) == 0)
2040 if ((hdr2
->flags
& SEC_ALLOC
) != 0)
2043 if (hdr1
->vma
< hdr2
->vma
)
2045 else if (hdr1
->vma
> hdr2
->vma
)
2051 /* Calculate the file position for each section, and set
2055 ecoff_compute_section_file_positions (abfd
)
2058 file_ptr sofar
, file_sofar
;
2059 asection
**sorted_hdrs
;
2063 boolean rdata_in_text
;
2064 boolean first_data
, first_nonalloc
;
2065 const bfd_vma round
= ecoff_backend (abfd
)->round
;
2067 sofar
= _bfd_ecoff_sizeof_headers (abfd
, false);
2070 /* Sort the sections by VMA. */
2071 sorted_hdrs
= (asection
**) bfd_malloc (abfd
->section_count
2072 * sizeof (asection
*));
2073 if (sorted_hdrs
== NULL
)
2075 for (current
= abfd
->sections
, i
= 0;
2077 current
= current
->next
, i
++)
2078 sorted_hdrs
[i
] = current
;
2079 BFD_ASSERT (i
== abfd
->section_count
);
2081 qsort (sorted_hdrs
, abfd
->section_count
, sizeof (asection
*),
2084 /* Some versions of the OSF linker put the .rdata section in the
2085 text segment, and some do not. */
2086 rdata_in_text
= ecoff_backend (abfd
)->rdata_in_text
;
2089 for (i
= 0; i
< abfd
->section_count
; i
++)
2091 current
= sorted_hdrs
[i
];
2092 if (strcmp (current
->name
, _RDATA
) == 0)
2094 if ((current
->flags
& SEC_CODE
) == 0
2095 && strcmp (current
->name
, _PDATA
) != 0
2096 && strcmp (current
->name
, _RCONST
) != 0)
2098 rdata_in_text
= false;
2103 ecoff_data (abfd
)->rdata_in_text
= rdata_in_text
;
2106 first_nonalloc
= true;
2107 for (i
= 0; i
< abfd
->section_count
; i
++)
2109 unsigned int alignment_power
;
2111 current
= sorted_hdrs
[i
];
2113 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2114 supposed to indicate the number of .pdata entries that are
2115 really in the section. Each entry is 8 bytes. We store this
2116 away in line_filepos before increasing the section size. */
2117 if (strcmp (current
->name
, _PDATA
) == 0)
2118 current
->line_filepos
= current
->_raw_size
/ 8;
2120 alignment_power
= current
->alignment_power
;
2122 /* On Ultrix, the data sections in an executable file must be
2123 aligned to a page boundary within the file. This does not
2124 affect the section size, though. FIXME: Does this work for
2125 other platforms? It requires some modification for the
2126 Alpha, because .rdata on the Alpha goes with the text, not
2128 if ((abfd
->flags
& EXEC_P
) != 0
2129 && (abfd
->flags
& D_PAGED
) != 0
2131 && (current
->flags
& SEC_CODE
) == 0
2133 || strcmp (current
->name
, _RDATA
) != 0)
2134 && strcmp (current
->name
, _PDATA
) != 0
2135 && strcmp (current
->name
, _RCONST
) != 0)
2137 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2138 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2141 else if (strcmp (current
->name
, _LIB
) == 0)
2143 /* On Irix 4, the location of contents of the .lib section
2144 from a shared library section is also rounded up to a
2147 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2148 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2150 else if (first_nonalloc
2151 && (current
->flags
& SEC_ALLOC
) == 0
2152 && (abfd
->flags
& D_PAGED
) != 0)
2154 /* Skip up to the next page for an unallocated section, such
2155 as the .comment section on the Alpha. This leaves room
2156 for the .bss section. */
2157 first_nonalloc
= false;
2158 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2159 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2162 /* Align the sections in the file to the same boundary on
2163 which they are aligned in virtual memory. */
2164 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2165 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2166 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2168 if ((abfd
->flags
& D_PAGED
) != 0
2169 && (current
->flags
& SEC_ALLOC
) != 0)
2171 sofar
+= (current
->vma
- sofar
) % round
;
2172 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2173 file_sofar
+= (current
->vma
- file_sofar
) % round
;
2176 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) != 0)
2177 current
->filepos
= file_sofar
;
2179 sofar
+= current
->_raw_size
;
2180 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2181 file_sofar
+= current
->_raw_size
;
2183 /* make sure that this section is of the right size too */
2185 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2186 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2187 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2188 current
->_raw_size
+= sofar
- old_sofar
;
2194 ecoff_data (abfd
)->reloc_filepos
= file_sofar
;
2199 /* Determine the location of the relocs for all the sections in the
2200 output file, as well as the location of the symbolic debugging
2203 static bfd_size_type
2204 ecoff_compute_reloc_file_positions (abfd
)
2207 const bfd_size_type external_reloc_size
=
2208 ecoff_backend (abfd
)->external_reloc_size
;
2209 file_ptr reloc_base
;
2210 bfd_size_type reloc_size
;
2214 if (! abfd
->output_has_begun
)
2216 if (! ecoff_compute_section_file_positions (abfd
))
2218 abfd
->output_has_begun
= true;
2221 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2224 for (current
= abfd
->sections
;
2225 current
!= (asection
*)NULL
;
2226 current
= current
->next
)
2228 if (current
->reloc_count
== 0)
2229 current
->rel_filepos
= 0;
2232 bfd_size_type relsize
;
2234 current
->rel_filepos
= reloc_base
;
2235 relsize
= current
->reloc_count
* external_reloc_size
;
2236 reloc_size
+= relsize
;
2237 reloc_base
+= relsize
;
2241 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2243 /* At least on Ultrix, the symbol table of an executable file must
2244 be aligned to a page boundary. FIXME: Is this true on other
2246 if ((abfd
->flags
& EXEC_P
) != 0
2247 && (abfd
->flags
& D_PAGED
) != 0)
2248 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2249 &~ (ecoff_backend (abfd
)->round
- 1));
2251 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2256 /* Set the contents of a section. */
2259 _bfd_ecoff_set_section_contents (abfd
, section
, location
, offset
, count
)
2264 bfd_size_type count
;
2266 /* This must be done first, because bfd_set_section_contents is
2267 going to set output_has_begun to true. */
2268 if (abfd
->output_has_begun
== false)
2270 if (! ecoff_compute_section_file_positions (abfd
))
2274 /* Handle the .lib section specially so that Irix 4 shared libraries
2275 work out. See coff_set_section_contents in coffcode.h. */
2276 if (strcmp (section
->name
, _LIB
) == 0)
2278 bfd_byte
*rec
, *recend
;
2280 rec
= (bfd_byte
*) location
;
2281 recend
= rec
+ count
;
2282 while (rec
< recend
)
2285 rec
+= bfd_get_32 (abfd
, rec
) * 4;
2288 BFD_ASSERT (rec
== recend
);
2294 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0
2295 || bfd_write (location
, 1, count
, abfd
) != count
)
2301 /* Get the GP value for an ECOFF file. This is a hook used by
2305 bfd_ecoff_get_gp_value (abfd
)
2308 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2309 || bfd_get_format (abfd
) != bfd_object
)
2311 bfd_set_error (bfd_error_invalid_operation
);
2315 return ecoff_data (abfd
)->gp
;
2318 /* Set the GP value for an ECOFF file. This is a hook used by the
2322 bfd_ecoff_set_gp_value (abfd
, gp_value
)
2326 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2327 || bfd_get_format (abfd
) != bfd_object
)
2329 bfd_set_error (bfd_error_invalid_operation
);
2333 ecoff_data (abfd
)->gp
= gp_value
;
2338 /* Set the register masks for an ECOFF file. This is a hook used by
2342 bfd_ecoff_set_regmasks (abfd
, gprmask
, fprmask
, cprmask
)
2344 unsigned long gprmask
;
2345 unsigned long fprmask
;
2346 unsigned long *cprmask
;
2348 ecoff_data_type
*tdata
;
2350 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2351 || bfd_get_format (abfd
) != bfd_object
)
2353 bfd_set_error (bfd_error_invalid_operation
);
2357 tdata
= ecoff_data (abfd
);
2358 tdata
->gprmask
= gprmask
;
2359 tdata
->fprmask
= fprmask
;
2360 if (cprmask
!= (unsigned long *) NULL
)
2364 for (i
= 0; i
< 3; i
++)
2365 tdata
->cprmask
[i
] = cprmask
[i
];
2371 /* Get ECOFF EXTR information for an external symbol. This function
2372 is passed to bfd_ecoff_debug_externals. */
2375 ecoff_get_extr (sym
, esym
)
2379 ecoff_symbol_type
*ecoff_sym_ptr
;
2382 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2383 || ecoffsymbol (sym
)->native
== NULL
)
2385 /* Don't include debugging, local, or section symbols. */
2386 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2387 || (sym
->flags
& BSF_LOCAL
) != 0
2388 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2392 esym
->cobol_main
= 0;
2393 esym
->weakext
= (sym
->flags
& BSF_WEAK
) != 0;
2396 /* FIXME: we can do better than this for st and sc. */
2397 esym
->asym
.st
= stGlobal
;
2398 esym
->asym
.sc
= scAbs
;
2399 esym
->asym
.reserved
= 0;
2400 esym
->asym
.index
= indexNil
;
2404 ecoff_sym_ptr
= ecoffsymbol (sym
);
2406 if (ecoff_sym_ptr
->local
)
2409 input_bfd
= bfd_asymbol_bfd (sym
);
2410 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2411 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2413 /* If the symbol was defined by the linker, then esym will be
2414 undefined but sym will not be. Get a better class for such a
2416 if ((esym
->asym
.sc
== scUndefined
2417 || esym
->asym
.sc
== scSUndefined
)
2418 && ! bfd_is_und_section (bfd_get_section (sym
)))
2419 esym
->asym
.sc
= scAbs
;
2421 /* Adjust the FDR index for the symbol by that used for the input
2423 if (esym
->ifd
!= -1)
2425 struct ecoff_debug_info
*input_debug
;
2427 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2428 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2429 if (input_debug
->ifdmap
!= (RFDT
*) NULL
)
2430 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2436 /* Set the external symbol index. This routine is passed to
2437 bfd_ecoff_debug_externals. */
2440 ecoff_set_index (sym
, indx
)
2444 ecoff_set_sym_index (sym
, indx
);
2447 /* Write out an ECOFF file. */
2450 _bfd_ecoff_write_object_contents (abfd
)
2453 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2454 const bfd_vma round
= backend
->round
;
2455 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2456 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2457 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2458 const bfd_size_type external_hdr_size
2459 = backend
->debug_swap
.external_hdr_size
;
2460 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2461 void (* const adjust_reloc_out
) PARAMS ((bfd
*,
2463 struct internal_reloc
*))
2464 = backend
->adjust_reloc_out
;
2465 void (* const swap_reloc_out
) PARAMS ((bfd
*,
2466 const struct internal_reloc
*,
2468 = backend
->swap_reloc_out
;
2469 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2470 HDRR
* const symhdr
= &debug
->symbolic_header
;
2473 bfd_size_type reloc_size
;
2474 bfd_size_type text_size
;
2476 boolean set_text_start
;
2477 bfd_size_type data_size
;
2479 boolean set_data_start
;
2480 bfd_size_type bss_size
;
2482 PTR reloc_buff
= NULL
;
2483 struct internal_filehdr internal_f
;
2484 struct internal_aouthdr internal_a
;
2487 /* Determine where the sections and relocs will go in the output
2489 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2492 for (current
= abfd
->sections
;
2493 current
!= (asection
*)NULL
;
2494 current
= current
->next
)
2496 current
->target_index
= count
;
2500 if ((abfd
->flags
& D_PAGED
) != 0)
2501 text_size
= _bfd_ecoff_sizeof_headers (abfd
, false);
2505 set_text_start
= false;
2508 set_data_start
= false;
2511 /* Write section headers to the file. */
2513 /* Allocate buff big enough to hold a section header,
2514 file header, or a.out header. */
2522 buff
= (PTR
) bfd_malloc ((size_t) siz
);
2527 internal_f
.f_nscns
= 0;
2528 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2530 for (current
= abfd
->sections
;
2531 current
!= (asection
*) NULL
;
2532 current
= current
->next
)
2534 struct internal_scnhdr section
;
2537 ++internal_f
.f_nscns
;
2539 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2541 /* This seems to be correct for Irix 4 shared libraries. */
2542 vma
= bfd_get_section_vma (abfd
, current
);
2543 if (strcmp (current
->name
, _LIB
) == 0)
2544 section
.s_vaddr
= 0;
2546 section
.s_vaddr
= vma
;
2548 section
.s_paddr
= current
->lma
;
2549 section
.s_size
= bfd_get_section_size_before_reloc (current
);
2551 /* If this section is unloadable then the scnptr will be 0. */
2552 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2553 section
.s_scnptr
= 0;
2555 section
.s_scnptr
= current
->filepos
;
2556 section
.s_relptr
= current
->rel_filepos
;
2558 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2559 object file produced by the assembler is supposed to point to
2560 information about how much room is required by objects of
2561 various different sizes. I think this only matters if we
2562 want the linker to compute the best size to use, or
2563 something. I don't know what happens if the information is
2565 if (strcmp (current
->name
, _PDATA
) != 0)
2566 section
.s_lnnoptr
= 0;
2569 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2570 hold the number of entries in the section (each entry is
2571 8 bytes). We stored this in the line_filepos field in
2572 ecoff_compute_section_file_positions. */
2573 section
.s_lnnoptr
= current
->line_filepos
;
2576 section
.s_nreloc
= current
->reloc_count
;
2577 section
.s_nlnno
= 0;
2578 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2581 if (bfd_coff_swap_scnhdr_out (abfd
, (PTR
) §ion
, buff
) == 0
2582 || bfd_write (buff
, 1, scnhsz
, abfd
) != scnhsz
)
2585 if ((section
.s_flags
& STYP_TEXT
) != 0
2586 || ((section
.s_flags
& STYP_RDATA
) != 0
2587 && ecoff_data (abfd
)->rdata_in_text
)
2588 || section
.s_flags
== STYP_PDATA
2589 || (section
.s_flags
& STYP_DYNAMIC
) != 0
2590 || (section
.s_flags
& STYP_LIBLIST
) != 0
2591 || (section
.s_flags
& STYP_RELDYN
) != 0
2592 || section
.s_flags
== STYP_CONFLIC
2593 || (section
.s_flags
& STYP_DYNSTR
) != 0
2594 || (section
.s_flags
& STYP_DYNSYM
) != 0
2595 || (section
.s_flags
& STYP_HASH
) != 0
2596 || (section
.s_flags
& STYP_ECOFF_INIT
) != 0
2597 || (section
.s_flags
& STYP_ECOFF_FINI
) != 0
2598 || section
.s_flags
== STYP_RCONST
)
2600 text_size
+= bfd_get_section_size_before_reloc (current
);
2601 if (! set_text_start
|| text_start
> vma
)
2604 set_text_start
= true;
2607 else if ((section
.s_flags
& STYP_RDATA
) != 0
2608 || (section
.s_flags
& STYP_DATA
) != 0
2609 || (section
.s_flags
& STYP_LITA
) != 0
2610 || (section
.s_flags
& STYP_LIT8
) != 0
2611 || (section
.s_flags
& STYP_LIT4
) != 0
2612 || (section
.s_flags
& STYP_SDATA
) != 0
2613 || section
.s_flags
== STYP_XDATA
2614 || (section
.s_flags
& STYP_GOT
) != 0)
2616 data_size
+= bfd_get_section_size_before_reloc (current
);
2617 if (! set_data_start
|| data_start
> vma
)
2620 set_data_start
= true;
2623 else if ((section
.s_flags
& STYP_BSS
) != 0
2624 || (section
.s_flags
& STYP_SBSS
) != 0)
2625 bss_size
+= bfd_get_section_size_before_reloc (current
);
2626 else if (section
.s_flags
== 0
2627 || (section
.s_flags
& STYP_ECOFF_LIB
) != 0
2628 || section
.s_flags
== STYP_COMMENT
)
2634 /* Set up the file header. */
2636 internal_f
.f_magic
= ecoff_get_magic (abfd
);
2638 /* We will NOT put a fucking timestamp in the header here. Every
2639 time you put it back, I will come in and take it out again. I'm
2640 sorry. This field does not belong here. We fill it with a 0 so
2641 it compares the same but is not a reasonable time. --
2643 internal_f
.f_timdat
= 0;
2645 if (bfd_get_symcount (abfd
) != 0)
2647 /* The ECOFF f_nsyms field is not actually the number of
2648 symbols, it's the size of symbolic information header. */
2649 internal_f
.f_nsyms
= external_hdr_size
;
2650 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
2654 internal_f
.f_nsyms
= 0;
2655 internal_f
.f_symptr
= 0;
2658 internal_f
.f_opthdr
= aoutsz
;
2660 internal_f
.f_flags
= F_LNNO
;
2661 if (reloc_size
== 0)
2662 internal_f
.f_flags
|= F_RELFLG
;
2663 if (bfd_get_symcount (abfd
) == 0)
2664 internal_f
.f_flags
|= F_LSYMS
;
2665 if (abfd
->flags
& EXEC_P
)
2666 internal_f
.f_flags
|= F_EXEC
;
2668 if (bfd_little_endian (abfd
))
2669 internal_f
.f_flags
|= F_AR32WR
;
2671 internal_f
.f_flags
|= F_AR32W
;
2673 /* Set up the ``optional'' header. */
2674 if ((abfd
->flags
& D_PAGED
) != 0)
2675 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
2677 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
2679 /* FIXME: Is this really correct? */
2680 internal_a
.vstamp
= symhdr
->vstamp
;
2682 /* At least on Ultrix, these have to be rounded to page boundaries.
2683 FIXME: Is this true on other platforms? */
2684 if ((abfd
->flags
& D_PAGED
) != 0)
2686 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
2687 internal_a
.text_start
= text_start
&~ (round
- 1);
2688 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
2689 internal_a
.data_start
= data_start
&~ (round
- 1);
2693 internal_a
.tsize
= text_size
;
2694 internal_a
.text_start
= text_start
;
2695 internal_a
.dsize
= data_size
;
2696 internal_a
.data_start
= data_start
;
2699 /* On Ultrix, the initial portions of the .sbss and .bss segments
2700 are at the end of the data section. The bsize field in the
2701 optional header records how many bss bytes are required beyond
2702 those in the data section. The value is not rounded to a page
2704 if (bss_size
< internal_a
.dsize
- data_size
)
2707 bss_size
-= internal_a
.dsize
- data_size
;
2708 internal_a
.bsize
= bss_size
;
2709 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
2711 internal_a
.entry
= bfd_get_start_address (abfd
);
2713 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
2715 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
2716 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
2717 for (i
= 0; i
< 4; i
++)
2718 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
2720 /* Let the backend adjust the headers if necessary. */
2721 if (backend
->adjust_headers
)
2723 if (! (*backend
->adjust_headers
) (abfd
, &internal_f
, &internal_a
))
2727 /* Write out the file header and the optional header. */
2729 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2732 bfd_coff_swap_filehdr_out (abfd
, (PTR
) &internal_f
, buff
);
2733 if (bfd_write (buff
, 1, filhsz
, abfd
) != filhsz
)
2736 bfd_coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, buff
);
2737 if (bfd_write (buff
, 1, aoutsz
, abfd
) != aoutsz
)
2740 /* Build the external symbol information. This must be done before
2741 writing out the relocs so that we know the symbol indices. We
2742 don't do this if this BFD was created by the backend linker,
2743 since it will have already handled the symbols and relocs. */
2744 if (! ecoff_data (abfd
)->linker
)
2746 symhdr
->iextMax
= 0;
2747 symhdr
->issExtMax
= 0;
2748 debug
->external_ext
= debug
->external_ext_end
= NULL
;
2749 debug
->ssext
= debug
->ssext_end
= NULL
;
2750 if (bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
2751 (((abfd
->flags
& EXEC_P
) == 0)
2753 ecoff_get_extr
, ecoff_set_index
)
2757 /* Write out the relocs. */
2758 for (current
= abfd
->sections
;
2759 current
!= (asection
*) NULL
;
2760 current
= current
->next
)
2762 arelent
**reloc_ptr_ptr
;
2763 arelent
**reloc_end
;
2766 if (current
->reloc_count
== 0)
2770 bfd_alloc (abfd
, current
->reloc_count
* external_reloc_size
);
2771 if (reloc_buff
== NULL
)
2774 reloc_ptr_ptr
= current
->orelocation
;
2775 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
2776 out_ptr
= (char *) reloc_buff
;
2778 reloc_ptr_ptr
< reloc_end
;
2779 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
2783 struct internal_reloc in
;
2785 memset ((PTR
) &in
, 0, sizeof in
);
2787 reloc
= *reloc_ptr_ptr
;
2788 sym
= *reloc
->sym_ptr_ptr
;
2790 in
.r_vaddr
= (reloc
->address
2791 + bfd_get_section_vma (abfd
, current
));
2792 in
.r_type
= reloc
->howto
->type
;
2794 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2796 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2803 name
= bfd_get_section_name (abfd
, bfd_get_section (sym
));
2804 if (strcmp (name
, ".text") == 0)
2805 in
.r_symndx
= RELOC_SECTION_TEXT
;
2806 else if (strcmp (name
, ".rdata") == 0)
2807 in
.r_symndx
= RELOC_SECTION_RDATA
;
2808 else if (strcmp (name
, ".data") == 0)
2809 in
.r_symndx
= RELOC_SECTION_DATA
;
2810 else if (strcmp (name
, ".sdata") == 0)
2811 in
.r_symndx
= RELOC_SECTION_SDATA
;
2812 else if (strcmp (name
, ".sbss") == 0)
2813 in
.r_symndx
= RELOC_SECTION_SBSS
;
2814 else if (strcmp (name
, ".bss") == 0)
2815 in
.r_symndx
= RELOC_SECTION_BSS
;
2816 else if (strcmp (name
, ".init") == 0)
2817 in
.r_symndx
= RELOC_SECTION_INIT
;
2818 else if (strcmp (name
, ".lit8") == 0)
2819 in
.r_symndx
= RELOC_SECTION_LIT8
;
2820 else if (strcmp (name
, ".lit4") == 0)
2821 in
.r_symndx
= RELOC_SECTION_LIT4
;
2822 else if (strcmp (name
, ".xdata") == 0)
2823 in
.r_symndx
= RELOC_SECTION_XDATA
;
2824 else if (strcmp (name
, ".pdata") == 0)
2825 in
.r_symndx
= RELOC_SECTION_PDATA
;
2826 else if (strcmp (name
, ".fini") == 0)
2827 in
.r_symndx
= RELOC_SECTION_FINI
;
2828 else if (strcmp (name
, ".lita") == 0)
2829 in
.r_symndx
= RELOC_SECTION_LITA
;
2830 else if (strcmp (name
, "*ABS*") == 0)
2831 in
.r_symndx
= RELOC_SECTION_ABS
;
2832 else if (strcmp (name
, ".rconst") == 0)
2833 in
.r_symndx
= RELOC_SECTION_RCONST
;
2839 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2841 (*swap_reloc_out
) (abfd
, &in
, (PTR
) out_ptr
);
2844 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2846 if (bfd_write (reloc_buff
,
2847 external_reloc_size
, current
->reloc_count
, abfd
)
2848 != external_reloc_size
* current
->reloc_count
)
2850 bfd_release (abfd
, reloc_buff
);
2854 /* Write out the symbolic debugging information. */
2855 if (bfd_get_symcount (abfd
) > 0)
2857 /* Write out the debugging information. */
2858 if (bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2859 ecoff_data (abfd
)->sym_filepos
)
2865 /* The .bss section of a demand paged executable must receive an
2866 entire page. If there are symbols, the symbols will start on the
2867 next page. If there are no symbols, we must fill out the page by
2869 if (bfd_get_symcount (abfd
) == 0
2870 && (abfd
->flags
& EXEC_P
) != 0
2871 && (abfd
->flags
& D_PAGED
) != 0)
2875 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2878 if (bfd_read (&c
, 1, 1, abfd
) == 0)
2880 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2883 if (bfd_write (&c
, 1, 1, abfd
) != 1)
2887 if (reloc_buff
!= NULL
)
2888 bfd_release (abfd
, reloc_buff
);
2893 if (reloc_buff
!= NULL
)
2894 bfd_release (abfd
, reloc_buff
);
2900 /* Archive handling. ECOFF uses what appears to be a unique type of
2901 archive header (armap). The byte ordering of the armap and the
2902 contents are encoded in the name of the armap itself. At least for
2903 now, we only support archives with the same byte ordering in the
2904 armap and the contents.
2906 The first four bytes in the armap are the number of symbol
2907 definitions. This is always a power of two.
2909 This is followed by the symbol definitions. Each symbol definition
2910 occupies 8 bytes. The first four bytes are the offset from the
2911 start of the armap strings to the null-terminated string naming
2912 this symbol. The second four bytes are the file offset to the
2913 archive member which defines this symbol. If the second four bytes
2914 are 0, then this is not actually a symbol definition, and it should
2917 The symbols are hashed into the armap with a closed hashing scheme.
2918 See the functions below for the details of the algorithm.
2920 After the symbol definitions comes four bytes holding the size of
2921 the string table, followed by the string table itself. */
2923 /* The name of an archive headers looks like this:
2924 __________E[BL]E[BL]_ (with a trailing space).
2925 The trailing space is changed to an X if the archive is changed to
2926 indicate that the armap is out of date.
2928 The Alpha seems to use ________64E[BL]E[BL]_. */
2930 #define ARMAP_BIG_ENDIAN 'B'
2931 #define ARMAP_LITTLE_ENDIAN 'L'
2932 #define ARMAP_MARKER 'E'
2933 #define ARMAP_START_LENGTH 10
2934 #define ARMAP_HEADER_MARKER_INDEX 10
2935 #define ARMAP_HEADER_ENDIAN_INDEX 11
2936 #define ARMAP_OBJECT_MARKER_INDEX 12
2937 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2938 #define ARMAP_END_INDEX 14
2939 #define ARMAP_END "_ "
2941 /* This is a magic number used in the hashing algorithm. */
2942 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2944 /* This returns the hash value to use for a string. It also sets
2945 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2946 is the number of entries in the hash table, and HLOG is the log
2950 ecoff_armap_hash (s
, rehash
, size
, hlog
)
2952 unsigned int *rehash
;
2962 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2963 hash
*= ARMAP_HASH_MAGIC
;
2964 *rehash
= (hash
& (size
- 1)) | 1;
2965 return hash
>> (32 - hlog
);
2968 /* Read in the armap. */
2971 _bfd_ecoff_slurp_armap (abfd
)
2976 struct areltdata
*mapdata
;
2977 bfd_size_type parsed_size
;
2979 struct artdata
*ardata
;
2982 struct symdef
*symdef_ptr
;
2985 /* Get the name of the first element. */
2986 i
= bfd_read ((PTR
) nextname
, 1, 16, abfd
);
2992 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2995 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2996 standard COFF armap. We could move the ECOFF armap stuff into
2997 bfd_slurp_armap, but that seems inappropriate since no other
2998 target uses this format. Instead, we check directly for a COFF
3000 if (strncmp (nextname
, "/ ", 16) == 0)
3001 return bfd_slurp_armap (abfd
);
3003 /* See if the first element is an armap. */
3004 if (strncmp (nextname
, ecoff_backend (abfd
)->armap_start
,
3005 ARMAP_START_LENGTH
) != 0
3006 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
3007 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
3008 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
3009 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
3010 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
3011 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
3012 || strncmp (nextname
+ ARMAP_END_INDEX
,
3013 ARMAP_END
, sizeof ARMAP_END
- 1) != 0)
3015 bfd_has_map (abfd
) = false;
3019 /* Make sure we have the right byte ordering. */
3020 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
3021 ^ (bfd_header_big_endian (abfd
)))
3022 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
3023 ^ (bfd_big_endian (abfd
))))
3025 bfd_set_error (bfd_error_wrong_format
);
3029 /* Read in the armap. */
3030 ardata
= bfd_ardata (abfd
);
3031 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
3032 if (mapdata
== (struct areltdata
*) NULL
)
3034 parsed_size
= mapdata
->parsed_size
;
3035 bfd_release (abfd
, (PTR
) mapdata
);
3037 raw_armap
= (char *) bfd_alloc (abfd
, parsed_size
);
3038 if (raw_armap
== (char *) NULL
)
3041 if (bfd_read ((PTR
) raw_armap
, 1, parsed_size
, abfd
) != parsed_size
)
3043 if (bfd_get_error () != bfd_error_system_call
)
3044 bfd_set_error (bfd_error_malformed_archive
);
3045 bfd_release (abfd
, (PTR
) raw_armap
);
3049 ardata
->tdata
= (PTR
) raw_armap
;
3051 count
= bfd_h_get_32 (abfd
, (PTR
) raw_armap
);
3053 ardata
->symdef_count
= 0;
3054 ardata
->cache
= (struct ar_cache
*) NULL
;
3056 /* This code used to overlay the symdefs over the raw archive data,
3057 but that doesn't work on a 64 bit host. */
3059 stringbase
= raw_armap
+ count
* 8 + 8;
3061 #ifdef CHECK_ARMAP_HASH
3065 /* Double check that I have the hashing algorithm right by making
3066 sure that every symbol can be looked up successfully. */
3068 for (i
= 1; i
< count
; i
<<= 1)
3070 BFD_ASSERT (i
== count
);
3072 raw_ptr
= raw_armap
+ 4;
3073 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3075 unsigned int name_offset
, file_offset
;
3076 unsigned int hash
, rehash
, srch
;
3078 name_offset
= bfd_h_get_32 (abfd
, (PTR
) raw_ptr
);
3079 file_offset
= bfd_h_get_32 (abfd
, (PTR
) (raw_ptr
+ 4));
3080 if (file_offset
== 0)
3082 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
3087 /* See if we can rehash to this location. */
3088 for (srch
= (hash
+ rehash
) & (count
- 1);
3089 srch
!= hash
&& srch
!= i
;
3090 srch
= (srch
+ rehash
) & (count
- 1))
3091 BFD_ASSERT (bfd_h_get_32 (abfd
, (PTR
) (raw_armap
+ 8 + srch
* 8))
3093 BFD_ASSERT (srch
== i
);
3097 #endif /* CHECK_ARMAP_HASH */
3099 raw_ptr
= raw_armap
+ 4;
3100 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3101 if (bfd_h_get_32 (abfd
, (PTR
) (raw_ptr
+ 4)) != 0)
3102 ++ardata
->symdef_count
;
3104 symdef_ptr
= ((struct symdef
*)
3106 ardata
->symdef_count
* sizeof (struct symdef
)));
3110 ardata
->symdefs
= (carsym
*) symdef_ptr
;
3112 raw_ptr
= raw_armap
+ 4;
3113 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3115 unsigned int name_offset
, file_offset
;
3117 file_offset
= bfd_h_get_32 (abfd
, (PTR
) (raw_ptr
+ 4));
3118 if (file_offset
== 0)
3120 name_offset
= bfd_h_get_32 (abfd
, (PTR
) raw_ptr
);
3121 symdef_ptr
->s
.name
= stringbase
+ name_offset
;
3122 symdef_ptr
->file_offset
= file_offset
;
3126 ardata
->first_file_filepos
= bfd_tell (abfd
);
3127 /* Pad to an even boundary. */
3128 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
3130 bfd_has_map (abfd
) = true;
3135 /* Write out an armap. */
3138 _bfd_ecoff_write_armap (abfd
, elength
, map
, orl_count
, stridx
)
3140 unsigned int elength
;
3142 unsigned int orl_count
;
3145 unsigned int hashsize
, hashlog
;
3146 unsigned int symdefsize
;
3148 unsigned int stringsize
;
3149 unsigned int mapsize
;
3152 struct stat statbuf
;
3155 bfd_byte
*hashtable
;
3159 /* Ultrix appears to use as a hash table size the least power of two
3160 greater than twice the number of entries. */
3161 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3163 hashsize
= 1 << hashlog
;
3165 symdefsize
= hashsize
* 8;
3167 stringsize
= stridx
+ padit
;
3169 /* Include 8 bytes to store symdefsize and stringsize in output. */
3170 mapsize
= symdefsize
+ stringsize
+ 8;
3172 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3174 memset ((PTR
) &hdr
, 0, sizeof hdr
);
3176 /* Work out the ECOFF armap name. */
3177 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3178 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3179 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3180 (bfd_header_big_endian (abfd
)
3182 : ARMAP_LITTLE_ENDIAN
);
3183 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3184 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3185 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3186 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3188 /* Write the timestamp of the archive header to be just a little bit
3189 later than the timestamp of the file, otherwise the linker will
3190 complain that the index is out of date. Actually, the Ultrix
3191 linker just checks the archive name; the GNU linker may check the
3193 stat (abfd
->filename
, &statbuf
);
3194 sprintf (hdr
.ar_date
, "%ld", (long) (statbuf
.st_mtime
+ 60));
3196 /* The DECstation uses zeroes for the uid, gid and mode of the
3198 hdr
.ar_uid
[0] = '0';
3199 hdr
.ar_gid
[0] = '0';
3201 hdr
.ar_mode
[0] = '0';
3203 /* Building gcc ends up extracting the armap as a file - twice. */
3204 hdr
.ar_mode
[0] = '6';
3205 hdr
.ar_mode
[1] = '4';
3206 hdr
.ar_mode
[2] = '4';
3209 sprintf (hdr
.ar_size
, "%-10d", (int) mapsize
);
3211 hdr
.ar_fmag
[0] = '`';
3212 hdr
.ar_fmag
[1] = '\012';
3214 /* Turn all null bytes in the header into spaces. */
3215 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3216 if (((char *) (&hdr
))[i
] == '\0')
3217 (((char *) (&hdr
))[i
]) = ' ';
3219 if (bfd_write ((PTR
) &hdr
, 1, sizeof (struct ar_hdr
), abfd
)
3220 != sizeof (struct ar_hdr
))
3223 bfd_h_put_32 (abfd
, (bfd_vma
) hashsize
, temp
);
3224 if (bfd_write ((PTR
) temp
, 1, 4, abfd
) != 4)
3227 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3231 current
= abfd
->archive_head
;
3233 for (i
= 0; i
< orl_count
; i
++)
3235 unsigned int hash
, rehash
;
3237 /* Advance firstreal to the file position of this archive
3239 if (((bfd
*) map
[i
].pos
) != last_elt
)
3243 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3244 firstreal
+= firstreal
% 2;
3245 current
= current
->next
;
3247 while (current
!= (bfd
*) map
[i
].pos
);
3252 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3253 if (bfd_h_get_32 (abfd
, (PTR
) (hashtable
+ (hash
* 8) + 4)) != 0)
3257 /* The desired slot is already taken. */
3258 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3260 srch
= (srch
+ rehash
) & (hashsize
- 1))
3261 if (bfd_h_get_32 (abfd
, (PTR
) (hashtable
+ (srch
* 8) + 4)) == 0)
3264 BFD_ASSERT (srch
!= hash
);
3269 bfd_h_put_32 (abfd
, (bfd_vma
) map
[i
].namidx
,
3270 (PTR
) (hashtable
+ hash
* 8));
3271 bfd_h_put_32 (abfd
, (bfd_vma
) firstreal
,
3272 (PTR
) (hashtable
+ hash
* 8 + 4));
3275 if (bfd_write ((PTR
) hashtable
, 1, symdefsize
, abfd
) != symdefsize
)
3278 bfd_release (abfd
, hashtable
);
3280 /* Now write the strings. */
3281 bfd_h_put_32 (abfd
, (bfd_vma
) stringsize
, temp
);
3282 if (bfd_write ((PTR
) temp
, 1, 4, abfd
) != 4)
3284 for (i
= 0; i
< orl_count
; i
++)
3288 len
= strlen (*map
[i
].name
) + 1;
3289 if (bfd_write ((PTR
) (*map
[i
].name
), 1, len
, abfd
) != len
)
3293 /* The spec sez this should be a newline. But in order to be
3294 bug-compatible for DECstation ar we use a null. */
3297 if (bfd_write ("", 1, 1, abfd
) != 1)
3304 /* See whether this BFD is an archive. If it is, read in the armap
3305 and the extended name table. */
3308 _bfd_ecoff_archive_p (abfd
)
3311 struct artdata
*tdata_hold
;
3312 char armag
[SARMAG
+ 1];
3314 tdata_hold
= abfd
->tdata
.aout_ar_data
;
3316 if (bfd_read ((PTR
) armag
, 1, SARMAG
, abfd
) != SARMAG
)
3318 if (bfd_get_error () != bfd_error_system_call
)
3319 bfd_set_error (bfd_error_wrong_format
);
3320 return (const bfd_target
*) NULL
;
3323 if (strncmp (armag
, ARMAG
, SARMAG
) != 0)
3325 bfd_set_error (bfd_error_wrong_format
);
3329 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
3330 involves a cast, we can't do it as the left operand of
3332 abfd
->tdata
.aout_ar_data
=
3333 (struct artdata
*) bfd_zalloc (abfd
, sizeof (struct artdata
));
3335 if (bfd_ardata (abfd
) == (struct artdata
*) NULL
)
3337 abfd
->tdata
.aout_ar_data
= tdata_hold
;
3338 return (const bfd_target
*) NULL
;
3341 bfd_ardata (abfd
)->first_file_filepos
= SARMAG
;
3342 bfd_ardata (abfd
)->cache
= NULL
;
3343 bfd_ardata (abfd
)->archive_head
= NULL
;
3344 bfd_ardata (abfd
)->symdefs
= NULL
;
3345 bfd_ardata (abfd
)->extended_names
= NULL
;
3346 bfd_ardata (abfd
)->tdata
= NULL
;
3348 if (_bfd_ecoff_slurp_armap (abfd
) == false
3349 || _bfd_ecoff_slurp_extended_name_table (abfd
) == false)
3351 bfd_release (abfd
, bfd_ardata (abfd
));
3352 abfd
->tdata
.aout_ar_data
= tdata_hold
;
3353 return (const bfd_target
*) NULL
;
3356 if (bfd_has_map (abfd
))
3360 /* This archive has a map, so we may presume that the contents
3361 are object files. Make sure that if the first file in the
3362 archive can be recognized as an object file, it is for this
3363 target. If not, assume that this is the wrong format. If
3364 the first file is not an object file, somebody is doing
3365 something weird, and we permit it so that ar -t will work. */
3367 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
3372 first
->target_defaulted
= false;
3374 if (bfd_check_format (first
, bfd_object
)
3375 && first
->xvec
!= abfd
->xvec
)
3377 (void) bfd_close (first
);
3378 bfd_release (abfd
, bfd_ardata (abfd
));
3379 abfd
->tdata
.aout_ar_data
= tdata_hold
;
3380 bfd_set_error (bfd_error_wrong_format
);
3384 /* We ought to close first here, but we can't, because we
3385 have no way to remove it from the archive cache. FIXME. */
3392 /* ECOFF linker code. */
3394 static struct bfd_hash_entry
*ecoff_link_hash_newfunc
3395 PARAMS ((struct bfd_hash_entry
*entry
,
3396 struct bfd_hash_table
*table
,
3397 const char *string
));
3398 static boolean ecoff_link_add_archive_symbols
3399 PARAMS ((bfd
*, struct bfd_link_info
*));
3400 static boolean ecoff_link_check_archive_element
3401 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*pneeded
));
3402 static boolean ecoff_link_add_object_symbols
3403 PARAMS ((bfd
*, struct bfd_link_info
*));
3404 static boolean ecoff_link_add_externals
3405 PARAMS ((bfd
*, struct bfd_link_info
*, PTR
, char *));
3407 /* Routine to create an entry in an ECOFF link hash table. */
3409 static struct bfd_hash_entry
*
3410 ecoff_link_hash_newfunc (entry
, table
, string
)
3411 struct bfd_hash_entry
*entry
;
3412 struct bfd_hash_table
*table
;
3415 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3417 /* Allocate the structure if it has not already been allocated by a
3419 if (ret
== (struct ecoff_link_hash_entry
*) NULL
)
3420 ret
= ((struct ecoff_link_hash_entry
*)
3421 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3422 if (ret
== (struct ecoff_link_hash_entry
*) NULL
)
3425 /* Call the allocation method of the superclass. */
3426 ret
= ((struct ecoff_link_hash_entry
*)
3427 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3432 /* Set local fields. */
3438 memset ((PTR
) &ret
->esym
, 0, sizeof ret
->esym
);
3440 return (struct bfd_hash_entry
*) ret
;
3443 /* Create an ECOFF link hash table. */
3445 struct bfd_link_hash_table
*
3446 _bfd_ecoff_bfd_link_hash_table_create (abfd
)
3449 struct ecoff_link_hash_table
*ret
;
3451 ret
= ((struct ecoff_link_hash_table
*)
3452 bfd_alloc (abfd
, sizeof (struct ecoff_link_hash_table
)));
3455 if (! _bfd_link_hash_table_init (&ret
->root
, abfd
,
3456 ecoff_link_hash_newfunc
))
3459 return (struct bfd_link_hash_table
*) NULL
;
3464 /* Look up an entry in an ECOFF link hash table. */
3466 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3467 ((struct ecoff_link_hash_entry *) \
3468 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3470 /* Traverse an ECOFF link hash table. */
3472 #define ecoff_link_hash_traverse(table, func, info) \
3473 (bfd_link_hash_traverse \
3475 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
3478 /* Get the ECOFF link hash table from the info structure. This is
3481 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3483 /* Given an ECOFF BFD, add symbols to the global hash table as
3487 _bfd_ecoff_bfd_link_add_symbols (abfd
, info
)
3489 struct bfd_link_info
*info
;
3491 switch (bfd_get_format (abfd
))
3494 return ecoff_link_add_object_symbols (abfd
, info
);
3496 return ecoff_link_add_archive_symbols (abfd
, info
);
3498 bfd_set_error (bfd_error_wrong_format
);
3503 /* Add the symbols from an archive file to the global hash table.
3504 This looks through the undefined symbols, looks each one up in the
3505 archive hash table, and adds any associated object file. We do not
3506 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3507 already have a hash table, so there is no reason to construct
3511 ecoff_link_add_archive_symbols (abfd
, info
)
3513 struct bfd_link_info
*info
;
3515 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3516 const bfd_byte
*raw_armap
;
3517 struct bfd_link_hash_entry
**pundef
;
3518 unsigned int armap_count
;
3519 unsigned int armap_log
;
3521 const bfd_byte
*hashtable
;
3522 const char *stringbase
;
3524 if (! bfd_has_map (abfd
))
3526 /* An empty archive is a special case. */
3527 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
3529 bfd_set_error (bfd_error_no_armap
);
3533 /* If we don't have any raw data for this archive, as can happen on
3534 Irix 4.0.5F, we call the generic routine.
3535 FIXME: We should be more clever about this, since someday tdata
3536 may get to something for a generic archive. */
3537 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3538 if (raw_armap
== (bfd_byte
*) NULL
)
3539 return (_bfd_generic_link_add_archive_symbols
3540 (abfd
, info
, ecoff_link_check_archive_element
));
3542 armap_count
= bfd_h_get_32 (abfd
, raw_armap
);
3545 for (i
= 1; i
< armap_count
; i
<<= 1)
3547 BFD_ASSERT (i
== armap_count
);
3549 hashtable
= raw_armap
+ 4;
3550 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3552 /* Look through the list of undefined symbols. */
3553 pundef
= &info
->hash
->undefs
;
3554 while (*pundef
!= (struct bfd_link_hash_entry
*) NULL
)
3556 struct bfd_link_hash_entry
*h
;
3557 unsigned int hash
, rehash
;
3558 unsigned int file_offset
;
3564 /* When a symbol is defined, it is not necessarily removed from
3566 if (h
->type
!= bfd_link_hash_undefined
3567 && h
->type
!= bfd_link_hash_common
)
3569 /* Remove this entry from the list, for general cleanliness
3570 and because we are going to look through the list again
3571 if we search any more libraries. We can't remove the
3572 entry if it is the tail, because that would lose any
3573 entries we add to the list later on. */
3574 if (*pundef
!= info
->hash
->undefs_tail
)
3575 *pundef
= (*pundef
)->next
;
3577 pundef
= &(*pundef
)->next
;
3581 /* Native ECOFF linkers do not pull in archive elements merely
3582 to satisfy common definitions, so neither do we. We leave
3583 them on the list, though, in case we are linking against some
3584 other object format. */
3585 if (h
->type
!= bfd_link_hash_undefined
)
3587 pundef
= &(*pundef
)->next
;
3591 /* Look for this symbol in the archive hash table. */
3592 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3595 file_offset
= bfd_h_get_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3596 if (file_offset
== 0)
3598 /* Nothing in this slot. */
3599 pundef
= &(*pundef
)->next
;
3603 name
= stringbase
+ bfd_h_get_32 (abfd
, hashtable
+ (hash
* 8));
3604 if (name
[0] != h
->root
.string
[0]
3605 || strcmp (name
, h
->root
.string
) != 0)
3610 /* That was the wrong symbol. Try rehashing. */
3612 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3614 srch
= (srch
+ rehash
) & (armap_count
- 1))
3616 file_offset
= bfd_h_get_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3617 if (file_offset
== 0)
3619 name
= stringbase
+ bfd_h_get_32 (abfd
, hashtable
+ (srch
* 8));
3620 if (name
[0] == h
->root
.string
[0]
3621 && strcmp (name
, h
->root
.string
) == 0)
3630 pundef
= &(*pundef
)->next
;
3637 element
= (*backend
->get_elt_at_filepos
) (abfd
, file_offset
);
3638 if (element
== (bfd
*) NULL
)
3641 if (! bfd_check_format (element
, bfd_object
))
3644 /* Unlike the generic linker, we know that this element provides
3645 a definition for an undefined symbol and we know that we want
3646 to include it. We don't need to check anything. */
3647 if (! (*info
->callbacks
->add_archive_element
) (info
, element
, name
))
3649 if (! ecoff_link_add_object_symbols (element
, info
))
3652 pundef
= &(*pundef
)->next
;
3658 /* This is called if we used _bfd_generic_link_add_archive_symbols
3659 because we were not dealing with an ECOFF archive. */
3662 ecoff_link_check_archive_element (abfd
, info
, pneeded
)
3664 struct bfd_link_info
*info
;
3667 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3668 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
3669 = backend
->debug_swap
.swap_ext_in
;
3671 bfd_size_type external_ext_size
;
3672 PTR external_ext
= NULL
;
3680 if (! ecoff_slurp_symbolic_header (abfd
))
3683 /* If there are no symbols, we don't want it. */
3684 if (bfd_get_symcount (abfd
) == 0)
3685 goto successful_return
;
3687 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3689 /* Read in the external symbols and external strings. */
3690 external_ext_size
= backend
->debug_swap
.external_ext_size
;
3691 esize
= symhdr
->iextMax
* external_ext_size
;
3692 external_ext
= (PTR
) bfd_malloc (esize
);
3693 if (external_ext
== NULL
&& esize
!= 0)
3696 if (bfd_seek (abfd
, symhdr
->cbExtOffset
, SEEK_SET
) != 0
3697 || bfd_read (external_ext
, 1, esize
, abfd
) != esize
)
3700 ssext
= (char *) bfd_malloc (symhdr
->issExtMax
);
3701 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3704 if (bfd_seek (abfd
, symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
3705 || (bfd_read (ssext
, 1, symhdr
->issExtMax
, abfd
) !=
3706 (bfd_size_type
) symhdr
->issExtMax
))
3709 /* Look through the external symbols to see if they define some
3710 symbol that is currently undefined. */
3711 ext_ptr
= (char *) external_ext
;
3712 ext_end
= ext_ptr
+ esize
;
3713 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
)
3718 struct bfd_link_hash_entry
*h
;
3720 (*swap_ext_in
) (abfd
, (PTR
) ext_ptr
, &esym
);
3722 /* See if this symbol defines something. */
3723 if (esym
.asym
.st
!= stGlobal
3724 && esym
.asym
.st
!= stLabel
3725 && esym
.asym
.st
!= stProc
)
3728 switch (esym
.asym
.sc
)
3752 name
= ssext
+ esym
.asym
.iss
;
3753 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
3755 /* Unlike the generic linker, we do not pull in elements because
3756 of common symbols. */
3757 if (h
== (struct bfd_link_hash_entry
*) NULL
3758 || h
->type
!= bfd_link_hash_undefined
)
3761 /* Include this element. */
3762 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
3764 if (! ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
))
3768 goto successful_return
;
3772 if (external_ext
!= NULL
)
3773 free (external_ext
);
3778 if (external_ext
!= NULL
)
3779 free (external_ext
);
3785 /* Add symbols from an ECOFF object file to the global linker hash
3789 ecoff_link_add_object_symbols (abfd
, info
)
3791 struct bfd_link_info
*info
;
3794 bfd_size_type external_ext_size
;
3795 PTR external_ext
= NULL
;
3800 if (! ecoff_slurp_symbolic_header (abfd
))
3803 /* If there are no symbols, we don't want it. */
3804 if (bfd_get_symcount (abfd
) == 0)
3807 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3809 /* Read in the external symbols and external strings. */
3810 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3811 esize
= symhdr
->iextMax
* external_ext_size
;
3812 external_ext
= (PTR
) bfd_malloc (esize
);
3813 if (external_ext
== NULL
&& esize
!= 0)
3816 if (bfd_seek (abfd
, symhdr
->cbExtOffset
, SEEK_SET
) != 0
3817 || bfd_read (external_ext
, 1, esize
, abfd
) != esize
)
3820 ssext
= (char *) bfd_malloc (symhdr
->issExtMax
);
3821 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3824 if (bfd_seek (abfd
, symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
3825 || (bfd_read (ssext
, 1, symhdr
->issExtMax
, abfd
)
3826 != (bfd_size_type
) symhdr
->issExtMax
))
3829 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3833 if (external_ext
!= NULL
)
3834 free (external_ext
);
3840 if (external_ext
!= NULL
)
3841 free (external_ext
);
3845 /* Add the external symbols of an object file to the global linker
3846 hash table. The external symbols and strings we are passed are
3847 just allocated on the stack, and will be discarded. We must
3848 explicitly save any information we may need later on in the link.
3849 We do not want to read the external symbol information again. */
3852 ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
)
3854 struct bfd_link_info
*info
;
3858 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3859 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
3860 = backend
->debug_swap
.swap_ext_in
;
3861 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3862 unsigned long ext_count
;
3863 struct ecoff_link_hash_entry
**sym_hash
;
3867 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3869 sym_hash
= ((struct ecoff_link_hash_entry
**)
3871 ext_count
* sizeof (struct bfd_link_hash_entry
*)));
3874 ecoff_data (abfd
)->sym_hashes
= sym_hash
;
3876 ext_ptr
= (char *) external_ext
;
3877 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3878 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3885 struct ecoff_link_hash_entry
*h
;
3889 (*swap_ext_in
) (abfd
, (PTR
) ext_ptr
, &esym
);
3891 /* Skip debugging symbols. */
3893 switch (esym
.asym
.st
)
3909 /* Get the information for this symbol. */
3910 value
= esym
.asym
.value
;
3911 switch (esym
.asym
.sc
)
3931 section
= bfd_make_section_old_way (abfd
, ".text");
3932 value
-= section
->vma
;
3935 section
= bfd_make_section_old_way (abfd
, ".data");
3936 value
-= section
->vma
;
3939 section
= bfd_make_section_old_way (abfd
, ".bss");
3940 value
-= section
->vma
;
3943 section
= bfd_abs_section_ptr
;
3946 section
= bfd_und_section_ptr
;
3949 section
= bfd_make_section_old_way (abfd
, ".sdata");
3950 value
-= section
->vma
;
3953 section
= bfd_make_section_old_way (abfd
, ".sbss");
3954 value
-= section
->vma
;
3957 section
= bfd_make_section_old_way (abfd
, ".rdata");
3958 value
-= section
->vma
;
3961 if (value
> ecoff_data (abfd
)->gp_size
)
3963 section
= bfd_com_section_ptr
;
3968 if (ecoff_scom_section
.name
== NULL
)
3970 /* Initialize the small common section. */
3971 ecoff_scom_section
.name
= SCOMMON
;
3972 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
3973 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
3974 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
3975 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
3976 ecoff_scom_symbol
.name
= SCOMMON
;
3977 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
3978 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
3979 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
3981 section
= &ecoff_scom_section
;
3984 section
= bfd_und_section_ptr
;
3987 section
= bfd_make_section_old_way (abfd
, ".init");
3988 value
-= section
->vma
;
3991 section
= bfd_make_section_old_way (abfd
, ".fini");
3992 value
-= section
->vma
;
3995 section
= bfd_make_section_old_way (abfd
, ".rconst");
3996 value
-= section
->vma
;
4000 if (section
== (asection
*) NULL
)
4003 name
= ssext
+ esym
.asym
.iss
;
4006 if (! (_bfd_generic_link_add_one_symbol
4008 esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
,
4009 section
, value
, (const char *) NULL
, true, true,
4010 (struct bfd_link_hash_entry
**) &h
)))
4015 /* If we are building an ECOFF hash table, save the external
4016 symbol information. */
4017 if (info
->hash
->creator
->flavour
== bfd_get_flavour (abfd
))
4019 if (h
->abfd
== (bfd
*) NULL
4020 || (! bfd_is_und_section (section
)
4021 && (! bfd_is_com_section (section
)
4022 || (h
->root
.type
!= bfd_link_hash_defined
4023 && h
->root
.type
!= bfd_link_hash_defweak
))))
4029 /* Remember whether this symbol was small undefined. */
4030 if (esym
.asym
.sc
== scSUndefined
)
4033 /* If this symbol was ever small undefined, it needs to wind
4034 up in a GP relative section. We can't control the
4035 section of a defined symbol, but we can control the
4036 section of a common symbol. This case is actually needed
4037 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
4039 && h
->root
.type
== bfd_link_hash_common
4040 && strcmp (h
->root
.u
.c
.p
->section
->name
, SCOMMON
) != 0)
4042 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
4044 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
4045 if (h
->esym
.asym
.sc
== scCommon
)
4046 h
->esym
.asym
.sc
= scSCommon
;
4054 /* ECOFF final link routines. */
4056 static boolean ecoff_final_link_debug_accumulate
4057 PARAMS ((bfd
*output_bfd
, bfd
*input_bfd
, struct bfd_link_info
*,
4059 static boolean ecoff_link_write_external
4060 PARAMS ((struct ecoff_link_hash_entry
*, PTR
));
4061 static boolean ecoff_indirect_link_order
4062 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
4063 struct bfd_link_order
*));
4064 static boolean ecoff_reloc_link_order
4065 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
4066 struct bfd_link_order
*));
4068 /* Structure used to pass information to ecoff_link_write_external. */
4073 struct bfd_link_info
*info
;
4076 /* ECOFF final link routine. This looks through all the input BFDs
4077 and gathers together all the debugging information, and then
4078 processes all the link order information. This may cause it to
4079 close and reopen some input BFDs; I'll see how bad this is. */
4082 _bfd_ecoff_bfd_final_link (abfd
, info
)
4084 struct bfd_link_info
*info
;
4086 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4087 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4090 register bfd
*input_bfd
;
4092 struct bfd_link_order
*p
;
4093 struct extsym_info einfo
;
4095 /* We accumulate the debugging information counts in the symbolic
4097 symhdr
= &debug
->symbolic_header
;
4099 symhdr
->ilineMax
= 0;
4103 symhdr
->isymMax
= 0;
4104 symhdr
->ioptMax
= 0;
4105 symhdr
->iauxMax
= 0;
4107 symhdr
->issExtMax
= 0;
4110 symhdr
->iextMax
= 0;
4112 /* We accumulate the debugging information itself in the debug_info
4115 debug
->external_dnr
= NULL
;
4116 debug
->external_pdr
= NULL
;
4117 debug
->external_sym
= NULL
;
4118 debug
->external_opt
= NULL
;
4119 debug
->external_aux
= NULL
;
4121 debug
->ssext
= debug
->ssext_end
= NULL
;
4122 debug
->external_fdr
= NULL
;
4123 debug
->external_rfd
= NULL
;
4124 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4126 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4127 if (handle
== (PTR
) NULL
)
4130 /* Accumulate the debugging symbols from each input BFD. */
4131 for (input_bfd
= info
->input_bfds
;
4132 input_bfd
!= (bfd
*) NULL
;
4133 input_bfd
= input_bfd
->link_next
)
4137 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4139 /* Abitrarily set the symbolic header vstamp to the vstamp
4140 of the first object file in the link. */
4141 if (symhdr
->vstamp
== 0)
4143 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4144 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4148 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4149 debug
, &backend
->debug_swap
,
4154 /* Combine the register masks. */
4155 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4156 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4157 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4158 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4159 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4160 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4163 /* Write out the external symbols. */
4166 ecoff_link_hash_traverse (ecoff_hash_table (info
),
4167 ecoff_link_write_external
,
4170 if (info
->relocateable
)
4172 /* We need to make a pass over the link_orders to count up the
4173 number of relocations we will need to output, so that we know
4174 how much space they will take up. */
4175 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4178 for (p
= o
->link_order_head
;
4179 p
!= (struct bfd_link_order
*) NULL
;
4181 if (p
->type
== bfd_indirect_link_order
)
4182 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4183 else if (p
->type
== bfd_section_reloc_link_order
4184 || p
->type
== bfd_symbol_reloc_link_order
)
4189 /* Compute the reloc and symbol file positions. */
4190 ecoff_compute_reloc_file_positions (abfd
);
4192 /* Write out the debugging information. */
4193 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4194 &backend
->debug_swap
, info
,
4195 ecoff_data (abfd
)->sym_filepos
))
4198 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4200 if (info
->relocateable
)
4202 /* Now reset the reloc_count field of the sections in the output
4203 BFD to 0, so that we can use them to keep track of how many
4204 relocs we have output thus far. */
4205 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4209 /* Get a value for the GP register. */
4210 if (ecoff_data (abfd
)->gp
== 0)
4212 struct bfd_link_hash_entry
*h
;
4214 h
= bfd_link_hash_lookup (info
->hash
, "_gp", false, false, true);
4215 if (h
!= (struct bfd_link_hash_entry
*) NULL
4216 && h
->type
== bfd_link_hash_defined
)
4217 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4218 + h
->u
.def
.section
->output_section
->vma
4219 + h
->u
.def
.section
->output_offset
);
4220 else if (info
->relocateable
)
4224 /* Make up a value. */
4226 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4229 && (strcmp (o
->name
, _SBSS
) == 0
4230 || strcmp (o
->name
, _SDATA
) == 0
4231 || strcmp (o
->name
, _LIT4
) == 0
4232 || strcmp (o
->name
, _LIT8
) == 0
4233 || strcmp (o
->name
, _LITA
) == 0))
4236 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4240 /* If the relocate_section function needs to do a reloc
4241 involving the GP value, it should make a reloc_dangerous
4242 callback to warn that GP is not defined. */
4246 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4248 for (p
= o
->link_order_head
;
4249 p
!= (struct bfd_link_order
*) NULL
;
4252 if (p
->type
== bfd_indirect_link_order
4253 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4254 == bfd_target_ecoff_flavour
))
4256 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4259 else if (p
->type
== bfd_section_reloc_link_order
4260 || p
->type
== bfd_symbol_reloc_link_order
)
4262 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4267 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4273 bfd_get_symcount (abfd
) = symhdr
->iextMax
+ symhdr
->isymMax
;
4275 ecoff_data (abfd
)->linker
= true;
4280 /* Accumulate the debugging information for an input BFD into the
4281 output BFD. This must read in the symbolic information of the
4285 ecoff_final_link_debug_accumulate (output_bfd
, input_bfd
, info
, handle
)
4288 struct bfd_link_info
*info
;
4291 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
4292 const struct ecoff_debug_swap
* const swap
=
4293 &ecoff_backend (input_bfd
)->debug_swap
;
4294 HDRR
*symhdr
= &debug
->symbolic_header
;
4297 #define READ(ptr, offset, count, size, type) \
4298 if (symhdr->count == 0) \
4299 debug->ptr = NULL; \
4302 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
4303 if (debug->ptr == NULL) \
4306 goto return_something; \
4308 if ((bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) \
4310 || (bfd_read (debug->ptr, size, symhdr->count, \
4311 input_bfd) != size * symhdr->count)) \
4314 goto return_something; \
4318 /* If raw_syments is not NULL, then the data was already by read by
4319 _bfd_ecoff_slurp_symbolic_info. */
4320 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
4322 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
4324 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
4325 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
4326 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
4327 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
4328 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
4330 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
4331 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
4332 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
4336 /* We do not read the external strings or the external symbols. */
4338 ret
= (bfd_ecoff_debug_accumulate
4339 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4340 &ecoff_backend (output_bfd
)->debug_swap
,
4341 input_bfd
, debug
, swap
, info
));
4344 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
4346 if (debug
->line
!= NULL
)
4348 if (debug
->external_dnr
!= NULL
)
4349 free (debug
->external_dnr
);
4350 if (debug
->external_pdr
!= NULL
)
4351 free (debug
->external_pdr
);
4352 if (debug
->external_sym
!= NULL
)
4353 free (debug
->external_sym
);
4354 if (debug
->external_opt
!= NULL
)
4355 free (debug
->external_opt
);
4356 if (debug
->external_aux
!= NULL
)
4357 free (debug
->external_aux
);
4358 if (debug
->ss
!= NULL
)
4360 if (debug
->external_fdr
!= NULL
)
4361 free (debug
->external_fdr
);
4362 if (debug
->external_rfd
!= NULL
)
4363 free (debug
->external_rfd
);
4365 /* Make sure we don't accidentally follow one of these pointers
4366 into freed memory. */
4368 debug
->external_dnr
= NULL
;
4369 debug
->external_pdr
= NULL
;
4370 debug
->external_sym
= NULL
;
4371 debug
->external_opt
= NULL
;
4372 debug
->external_aux
= NULL
;
4374 debug
->external_fdr
= NULL
;
4375 debug
->external_rfd
= NULL
;
4381 /* Put out information for an external symbol. These come only from
4385 ecoff_link_write_external (h
, data
)
4386 struct ecoff_link_hash_entry
*h
;
4389 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4390 bfd
*output_bfd
= einfo
->abfd
;
4393 /* We need to check if this symbol is being stripped. */
4394 if (h
->root
.type
== bfd_link_hash_undefined
4395 || h
->root
.type
== bfd_link_hash_undefweak
)
4397 else if (einfo
->info
->strip
== strip_all
4398 || (einfo
->info
->strip
== strip_some
4399 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4400 h
->root
.root
.string
,
4401 false, false) == NULL
))
4406 if (strip
|| h
->written
)
4409 if (h
->abfd
== (bfd
*) NULL
)
4412 h
->esym
.cobol_main
= 0;
4413 h
->esym
.weakext
= 0;
4414 h
->esym
.reserved
= 0;
4415 h
->esym
.ifd
= ifdNil
;
4416 h
->esym
.asym
.value
= 0;
4417 h
->esym
.asym
.st
= stGlobal
;
4419 if (h
->root
.type
!= bfd_link_hash_defined
4420 && h
->root
.type
!= bfd_link_hash_defweak
)
4421 h
->esym
.asym
.sc
= scAbs
;
4424 asection
*output_section
;
4427 output_section
= h
->root
.u
.def
.section
->output_section
;
4428 name
= bfd_section_name (output_section
->owner
, output_section
);
4430 if (strcmp (name
, _TEXT
) == 0)
4431 h
->esym
.asym
.sc
= scText
;
4432 else if (strcmp (name
, _DATA
) == 0)
4433 h
->esym
.asym
.sc
= scData
;
4434 else if (strcmp (name
, _SDATA
) == 0)
4435 h
->esym
.asym
.sc
= scSData
;
4436 else if (strcmp (name
, _RDATA
) == 0)
4437 h
->esym
.asym
.sc
= scRData
;
4438 else if (strcmp (name
, _BSS
) == 0)
4439 h
->esym
.asym
.sc
= scBss
;
4440 else if (strcmp (name
, _SBSS
) == 0)
4441 h
->esym
.asym
.sc
= scSBss
;
4442 else if (strcmp (name
, _INIT
) == 0)
4443 h
->esym
.asym
.sc
= scInit
;
4444 else if (strcmp (name
, _FINI
) == 0)
4445 h
->esym
.asym
.sc
= scFini
;
4446 else if (strcmp (name
, _PDATA
) == 0)
4447 h
->esym
.asym
.sc
= scPData
;
4448 else if (strcmp (name
, _XDATA
) == 0)
4449 h
->esym
.asym
.sc
= scXData
;
4450 else if (strcmp (name
, _RCONST
) == 0)
4451 h
->esym
.asym
.sc
= scRConst
;
4453 h
->esym
.asym
.sc
= scAbs
;
4456 h
->esym
.asym
.reserved
= 0;
4457 h
->esym
.asym
.index
= indexNil
;
4459 else if (h
->esym
.ifd
!= -1)
4461 struct ecoff_debug_info
*debug
;
4463 /* Adjust the FDR index for the symbol by that used for the
4465 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4466 BFD_ASSERT (h
->esym
.ifd
>= 0
4467 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4468 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4471 switch (h
->root
.type
)
4474 case bfd_link_hash_new
:
4476 case bfd_link_hash_undefined
:
4477 case bfd_link_hash_undefweak
:
4478 if (h
->esym
.asym
.sc
!= scUndefined
4479 && h
->esym
.asym
.sc
!= scSUndefined
)
4480 h
->esym
.asym
.sc
= scUndefined
;
4482 case bfd_link_hash_defined
:
4483 case bfd_link_hash_defweak
:
4484 if (h
->esym
.asym
.sc
== scUndefined
4485 || h
->esym
.asym
.sc
== scSUndefined
)
4486 h
->esym
.asym
.sc
= scAbs
;
4487 else if (h
->esym
.asym
.sc
== scCommon
)
4488 h
->esym
.asym
.sc
= scBss
;
4489 else if (h
->esym
.asym
.sc
== scSCommon
)
4490 h
->esym
.asym
.sc
= scSBss
;
4491 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4492 + h
->root
.u
.def
.section
->output_section
->vma
4493 + h
->root
.u
.def
.section
->output_offset
);
4495 case bfd_link_hash_common
:
4496 if (h
->esym
.asym
.sc
!= scCommon
4497 && h
->esym
.asym
.sc
!= scSCommon
)
4498 h
->esym
.asym
.sc
= scCommon
;
4499 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4501 case bfd_link_hash_indirect
:
4502 case bfd_link_hash_warning
:
4503 /* FIXME: Ignore these for now. The circumstances under which
4504 they should be written out are not clear to me. */
4508 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4510 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4513 return (bfd_ecoff_debug_one_external
4514 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4515 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4519 /* Relocate and write an ECOFF section into an ECOFF output file. */
4522 ecoff_indirect_link_order (output_bfd
, info
, output_section
, link_order
)
4524 struct bfd_link_info
*info
;
4525 asection
*output_section
;
4526 struct bfd_link_order
*link_order
;
4528 asection
*input_section
;
4530 struct ecoff_section_tdata
*section_tdata
;
4531 bfd_size_type raw_size
;
4532 bfd_size_type cooked_size
;
4533 bfd_byte
*contents
= NULL
;
4534 bfd_size_type external_reloc_size
;
4535 bfd_size_type external_relocs_size
;
4536 PTR external_relocs
= NULL
;
4538 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
4540 if (link_order
->size
== 0)
4543 input_section
= link_order
->u
.indirect
.section
;
4544 input_bfd
= input_section
->owner
;
4545 section_tdata
= ecoff_section_data (input_bfd
, input_section
);
4547 raw_size
= input_section
->_raw_size
;
4548 cooked_size
= input_section
->_cooked_size
;
4549 if (cooked_size
== 0)
4550 cooked_size
= raw_size
;
4552 BFD_ASSERT (input_section
->output_section
== output_section
);
4553 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
4554 BFD_ASSERT (cooked_size
== link_order
->size
);
4556 /* Get the section contents. We allocate memory for the larger of
4557 the size before relocating and the size after relocating. */
4558 contents
= (bfd_byte
*) bfd_malloc (raw_size
>= cooked_size
4560 : (size_t) cooked_size
);
4561 if (contents
== NULL
&& raw_size
!= 0)
4564 /* If we are relaxing, the contents may have already been read into
4565 memory, in which case we copy them into our new buffer. We don't
4566 simply reuse the old buffer in case cooked_size > raw_size. */
4567 if (section_tdata
!= (struct ecoff_section_tdata
*) NULL
4568 && section_tdata
->contents
!= (bfd_byte
*) NULL
)
4569 memcpy (contents
, section_tdata
->contents
, (size_t) raw_size
);
4572 if (! bfd_get_section_contents (input_bfd
, input_section
,
4574 (file_ptr
) 0, raw_size
))
4578 /* Get the relocs. If we are relaxing MIPS code, they will already
4579 have been read in. Otherwise, we read them in now. */
4580 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
4581 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
4583 if (section_tdata
!= (struct ecoff_section_tdata
*) NULL
4584 && section_tdata
->external_relocs
!= NULL
)
4585 external_relocs
= section_tdata
->external_relocs
;
4588 external_relocs
= (PTR
) bfd_malloc ((size_t) external_relocs_size
);
4589 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
4592 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
4593 || (bfd_read (external_relocs
, 1, external_relocs_size
, input_bfd
)
4594 != external_relocs_size
))
4598 /* Relocate the section contents. */
4599 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
4600 (output_bfd
, info
, input_bfd
, input_section
, contents
,
4604 /* Write out the relocated section. */
4605 if (! bfd_set_section_contents (output_bfd
,
4608 input_section
->output_offset
,
4612 /* If we are producing relocateable output, the relocs were
4613 modified, and we write them out now. We use the reloc_count
4614 field of output_section to keep track of the number of relocs we
4615 have output so far. */
4616 if (info
->relocateable
)
4618 if (bfd_seek (output_bfd
,
4619 (output_section
->rel_filepos
+
4620 output_section
->reloc_count
* external_reloc_size
),
4622 || (bfd_write (external_relocs
, 1, external_relocs_size
, output_bfd
)
4623 != external_relocs_size
))
4625 output_section
->reloc_count
+= input_section
->reloc_count
;
4628 if (contents
!= NULL
)
4630 if (external_relocs
!= NULL
&& section_tdata
== NULL
)
4631 free (external_relocs
);
4635 if (contents
!= NULL
)
4637 if (external_relocs
!= NULL
&& section_tdata
== NULL
)
4638 free (external_relocs
);
4642 /* Generate a reloc when linking an ECOFF file. This is a reloc
4643 requested by the linker, and does come from any input file. This
4644 is used to build constructor and destructor tables when linking
4648 ecoff_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
4650 struct bfd_link_info
*info
;
4651 asection
*output_section
;
4652 struct bfd_link_order
*link_order
;
4654 enum bfd_link_order_type type
;
4658 struct internal_reloc in
;
4659 bfd_size_type external_reloc_size
;
4663 type
= link_order
->type
;
4665 addend
= link_order
->u
.reloc
.p
->addend
;
4667 /* We set up an arelent to pass to the backend adjust_reloc_out
4669 rel
.address
= link_order
->offset
;
4671 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
4674 bfd_set_error (bfd_error_bad_value
);
4678 if (type
== bfd_section_reloc_link_order
)
4680 section
= link_order
->u
.reloc
.p
->u
.section
;
4681 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
4685 struct bfd_link_hash_entry
*h
;
4687 /* Treat a reloc against a defined symbol as though it were
4688 actually against the section. */
4689 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4690 link_order
->u
.reloc
.p
->u
.name
,
4691 false, false, false);
4693 && (h
->type
== bfd_link_hash_defined
4694 || h
->type
== bfd_link_hash_defweak
))
4696 type
= bfd_section_reloc_link_order
;
4697 section
= h
->u
.def
.section
->output_section
;
4698 /* It seems that we ought to add the symbol value to the
4699 addend here, but in practice it has already been added
4700 because it was passed to constructor_callback. */
4701 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
4705 /* We can't set up a reloc against a symbol correctly,
4706 because we have no asymbol structure. Currently no
4707 adjust_reloc_out routine cares. */
4708 rel
.sym_ptr_ptr
= (asymbol
**) NULL
;
4712 /* All ECOFF relocs are in-place. Put the addend into the object
4715 BFD_ASSERT (rel
.howto
->partial_inplace
);
4719 bfd_reloc_status_type rstat
;
4723 size
= bfd_get_reloc_size (rel
.howto
);
4724 buf
= (bfd_byte
*) bfd_zmalloc (size
);
4725 if (buf
== (bfd_byte
*) NULL
)
4727 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
, addend
, buf
);
4733 case bfd_reloc_outofrange
:
4735 case bfd_reloc_overflow
:
4736 if (! ((*info
->callbacks
->reloc_overflow
)
4738 (link_order
->type
== bfd_section_reloc_link_order
4739 ? bfd_section_name (output_bfd
, section
)
4740 : link_order
->u
.reloc
.p
->u
.name
),
4741 rel
.howto
->name
, addend
, (bfd
*) NULL
,
4742 (asection
*) NULL
, (bfd_vma
) 0)))
4749 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
4750 (file_ptr
) link_order
->offset
, size
);
4758 /* Move the information into a internal_reloc structure. */
4759 in
.r_vaddr
= (rel
.address
4760 + bfd_get_section_vma (output_bfd
, output_section
));
4761 in
.r_type
= rel
.howto
->type
;
4763 if (type
== bfd_symbol_reloc_link_order
)
4765 struct ecoff_link_hash_entry
*h
;
4767 h
= ((struct ecoff_link_hash_entry
*)
4768 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4769 link_order
->u
.reloc
.p
->u
.name
,
4770 false, false, true));
4771 if (h
!= (struct ecoff_link_hash_entry
*) NULL
4773 in
.r_symndx
= h
->indx
;
4776 if (! ((*info
->callbacks
->unattached_reloc
)
4777 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
4778 (asection
*) NULL
, (bfd_vma
) 0)))
4788 name
= bfd_get_section_name (output_bfd
, section
);
4789 if (strcmp (name
, ".text") == 0)
4790 in
.r_symndx
= RELOC_SECTION_TEXT
;
4791 else if (strcmp (name
, ".rdata") == 0)
4792 in
.r_symndx
= RELOC_SECTION_RDATA
;
4793 else if (strcmp (name
, ".data") == 0)
4794 in
.r_symndx
= RELOC_SECTION_DATA
;
4795 else if (strcmp (name
, ".sdata") == 0)
4796 in
.r_symndx
= RELOC_SECTION_SDATA
;
4797 else if (strcmp (name
, ".sbss") == 0)
4798 in
.r_symndx
= RELOC_SECTION_SBSS
;
4799 else if (strcmp (name
, ".bss") == 0)
4800 in
.r_symndx
= RELOC_SECTION_BSS
;
4801 else if (strcmp (name
, ".init") == 0)
4802 in
.r_symndx
= RELOC_SECTION_INIT
;
4803 else if (strcmp (name
, ".lit8") == 0)
4804 in
.r_symndx
= RELOC_SECTION_LIT8
;
4805 else if (strcmp (name
, ".lit4") == 0)
4806 in
.r_symndx
= RELOC_SECTION_LIT4
;
4807 else if (strcmp (name
, ".xdata") == 0)
4808 in
.r_symndx
= RELOC_SECTION_XDATA
;
4809 else if (strcmp (name
, ".pdata") == 0)
4810 in
.r_symndx
= RELOC_SECTION_PDATA
;
4811 else if (strcmp (name
, ".fini") == 0)
4812 in
.r_symndx
= RELOC_SECTION_FINI
;
4813 else if (strcmp (name
, ".lita") == 0)
4814 in
.r_symndx
= RELOC_SECTION_LITA
;
4815 else if (strcmp (name
, "*ABS*") == 0)
4816 in
.r_symndx
= RELOC_SECTION_ABS
;
4817 else if (strcmp (name
, ".rconst") == 0)
4818 in
.r_symndx
= RELOC_SECTION_RCONST
;
4824 /* Let the BFD backend adjust the reloc. */
4825 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4827 /* Get some memory and swap out the reloc. */
4828 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4829 rbuf
= (bfd_byte
*) bfd_malloc ((size_t) external_reloc_size
);
4830 if (rbuf
== (bfd_byte
*) NULL
)
4833 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (PTR
) rbuf
);
4835 ok
= (bfd_seek (output_bfd
,
4836 (output_section
->rel_filepos
+
4837 output_section
->reloc_count
* external_reloc_size
),
4839 && (bfd_write ((PTR
) rbuf
, 1, external_reloc_size
, output_bfd
)
4840 == external_reloc_size
));
4843 ++output_section
->reloc_count
;