1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
3 Original version by Per Bothner.
4 Full support added by Ian Lance Taylor, ian@cygnus.com.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 #include "aout/ranlib.h"
28 #include "aout/stab_gnu.h"
30 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
31 some other stuff which we don't want and which conflicts with stuff
34 #include "aout/aout64.h"
37 #undef obj_sym_filepos
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
46 /* Prototypes for static functions. */
48 static int ecoff_get_magic PARAMS ((bfd *abfd));
49 static long ecoff_sec_to_styp_flags PARAMS ((const char *name,
51 static boolean ecoff_slurp_symbolic_header PARAMS ((bfd *abfd));
52 static boolean ecoff_set_symbol_info PARAMS ((bfd *abfd, SYMR *ecoff_sym,
53 asymbol *asym, int ext, int weak));
54 static void ecoff_emit_aggregate PARAMS ((bfd *abfd, FDR *fdr,
56 RNDXR *rndx, long isym,
58 static char *ecoff_type_to_string PARAMS ((bfd *abfd, FDR *fdr,
60 static boolean ecoff_slurp_reloc_table PARAMS ((bfd *abfd, asection *section,
62 static int ecoff_sort_hdrs PARAMS ((const PTR, const PTR));
63 static boolean ecoff_compute_section_file_positions PARAMS ((bfd *abfd));
64 static bfd_size_type ecoff_compute_reloc_file_positions PARAMS ((bfd *abfd));
65 static boolean ecoff_get_extr PARAMS ((asymbol *, EXTR *));
66 static void ecoff_set_index PARAMS ((asymbol *, bfd_size_type));
67 static unsigned int ecoff_armap_hash PARAMS ((CONST char *s,
72 /* This stuff is somewhat copied from coffcode.h. */
74 static asection bfd_debug_section = { "*DEBUG*" };
76 /* Create an ECOFF object. */
79 _bfd_ecoff_mkobject (abfd)
82 abfd->tdata.ecoff_obj_data = ((struct ecoff_tdata *)
83 bfd_zalloc (abfd, sizeof (ecoff_data_type)));
84 if (abfd->tdata.ecoff_obj_data == NULL)
86 bfd_set_error (bfd_error_no_memory);
93 /* This is a hook called by coff_real_object_p to create any backend
94 specific information. */
97 _bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr)
102 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
103 struct internal_aouthdr *internal_a = (struct internal_aouthdr *) aouthdr;
104 ecoff_data_type *ecoff;
106 if (_bfd_ecoff_mkobject (abfd) == false)
109 ecoff = ecoff_data (abfd);
111 ecoff->sym_filepos = internal_f->f_symptr;
113 if (internal_a != (struct internal_aouthdr *) NULL)
117 ecoff->text_start = internal_a->text_start;
118 ecoff->text_end = internal_a->text_start + internal_a->tsize;
119 ecoff->gp = internal_a->gp_value;
120 ecoff->gprmask = internal_a->gprmask;
121 for (i = 0; i < 4; i++)
122 ecoff->cprmask[i] = internal_a->cprmask[i];
123 ecoff->fprmask = internal_a->fprmask;
124 if (internal_a->magic == ECOFF_AOUT_ZMAGIC)
125 abfd->flags |= D_PAGED;
127 abfd->flags &=~ D_PAGED;
130 /* It turns out that no special action is required by the MIPS or
131 Alpha ECOFF backends. They have different information in the
132 a.out header, but we just copy it all (e.g., gprmask, cprmask and
133 fprmask) and let the swapping routines ensure that only relevant
134 information is written out. */
139 /* Initialize a new section. */
142 _bfd_ecoff_new_section_hook (abfd, section)
146 /* For the .pdata section, which has a special meaning on the Alpha,
147 we set the alignment power to 3. We correct this later in
148 ecoff_compute_section_file_positions. We do this hackery because
149 we need to know the exact unaligned size of the .pdata section in
150 order to set the lnnoptr field correctly. For every other
151 section we use an alignment power of 4; this could be made target
152 dependent by adding a field to ecoff_backend_data, but 4 appears
153 to be correct for both the MIPS and the Alpha. */
154 if (strcmp (section->name, _PDATA) == 0)
155 section->alignment_power = 3;
157 section->alignment_power = 4;
159 if (strcmp (section->name, _TEXT) == 0)
160 section->flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
161 else if (strcmp (section->name, _DATA) == 0
162 || strcmp (section->name, _SDATA) == 0)
163 section->flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
164 else if (strcmp (section->name, _RDATA) == 0
165 || strcmp (section->name, _LIT8) == 0
166 || strcmp (section->name, _LIT4) == 0)
167 section->flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY;
168 else if (strcmp (section->name, _BSS) == 0
169 || strcmp (section->name, _SBSS) == 0)
170 section->flags |= SEC_ALLOC;
171 else if (strcmp (section->name, _LIB) == 0)
173 /* An Irix 4 shared libary. */
174 section->flags |= SEC_COFF_SHARED_LIBRARY;
177 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
178 uncertain about .init on some systems and I don't know how shared
184 /* Determine the machine architecture and type. This is called from
185 the generic COFF routines. It is the inverse of ecoff_get_magic,
186 below. This could be an ECOFF backend routine, with one version
187 for each target, but there aren't all that many ECOFF targets. */
190 _bfd_ecoff_set_arch_mach_hook (abfd, filehdr)
194 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
195 enum bfd_architecture arch;
198 switch (internal_f->f_magic)
201 case MIPS_MAGIC_LITTLE:
203 arch = bfd_arch_mips;
207 case MIPS_MAGIC_LITTLE2:
208 case MIPS_MAGIC_BIG2:
209 /* MIPS ISA level 2: the r6000 */
210 arch = bfd_arch_mips;
214 case MIPS_MAGIC_LITTLE3:
215 case MIPS_MAGIC_BIG3:
216 /* MIPS ISA level 3: the r4000 */
217 arch = bfd_arch_mips;
222 arch = bfd_arch_alpha;
227 arch = bfd_arch_obscure;
232 return bfd_default_set_arch_mach (abfd, arch, mach);
235 /* Get the magic number to use based on the architecture and machine.
236 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
239 ecoff_get_magic (abfd)
244 switch (bfd_get_arch (abfd))
247 switch (bfd_get_mach (abfd))
252 big = MIPS_MAGIC_BIG;
253 little = MIPS_MAGIC_LITTLE;
257 big = MIPS_MAGIC_BIG2;
258 little = MIPS_MAGIC_LITTLE2;
262 big = MIPS_MAGIC_BIG3;
263 little = MIPS_MAGIC_LITTLE3;
267 return abfd->xvec->byteorder_big_p ? big : little;
278 /* Get the section s_flags to use for a section. */
281 ecoff_sec_to_styp_flags (name, flags)
289 if (strcmp (name, _TEXT) == 0)
291 else if (strcmp (name, _DATA) == 0)
293 else if (strcmp (name, _SDATA) == 0)
295 else if (strcmp (name, _RDATA) == 0)
297 else if (strcmp (name, _LITA) == 0)
299 else if (strcmp (name, _LIT8) == 0)
301 else if (strcmp (name, _LIT4) == 0)
303 else if (strcmp (name, _BSS) == 0)
305 else if (strcmp (name, _SBSS) == 0)
307 else if (strcmp (name, _INIT) == 0)
308 styp = STYP_ECOFF_INIT;
309 else if (strcmp (name, _FINI) == 0)
310 styp = STYP_ECOFF_FINI;
311 else if (strcmp (name, _PDATA) == 0)
313 else if (strcmp (name, _XDATA) == 0)
315 else if (strcmp (name, _LIB) == 0)
316 styp = STYP_ECOFF_LIB;
317 else if (strcmp (name, _GOT) == 0)
319 else if (strcmp (name, _HASH) == 0)
321 else if (strcmp (name, _DYNAMIC) == 0)
323 else if (strcmp (name, _LIBLIST) == 0)
325 else if (strcmp (name, _RELDYN) == 0)
327 else if (strcmp (name, _CONFLIC) == 0)
329 else if (strcmp (name, _DYNSTR) == 0)
331 else if (strcmp (name, _DYNSYM) == 0)
333 else if (strcmp (name, _COMMENT) == 0)
336 flags &=~ SEC_NEVER_LOAD;
338 else if (flags & SEC_CODE)
340 else if (flags & SEC_DATA)
342 else if (flags & SEC_READONLY)
344 else if (flags & SEC_LOAD)
349 if (flags & SEC_NEVER_LOAD)
355 /* Get the BFD flags to use for a section. */
359 _bfd_ecoff_styp_to_sec_flags (abfd, hdr, name)
364 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
365 long styp_flags = internal_s->s_flags;
366 flagword sec_flags=0;
368 if (styp_flags & STYP_NOLOAD)
369 sec_flags |= SEC_NEVER_LOAD;
371 /* For 386 COFF, at least, an unloadable text or data section is
372 actually a shared library section. */
373 if ((styp_flags & STYP_TEXT)
374 || (styp_flags & STYP_ECOFF_INIT)
375 || (styp_flags & STYP_ECOFF_FINI)
376 || (styp_flags & STYP_DYNAMIC)
377 || (styp_flags & STYP_LIBLIST)
378 || (styp_flags & STYP_RELDYN)
379 || styp_flags == STYP_CONFLIC
380 || (styp_flags & STYP_DYNSTR)
381 || (styp_flags & STYP_DYNSYM)
382 || (styp_flags & STYP_HASH))
384 if (sec_flags & SEC_NEVER_LOAD)
385 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
387 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
389 else if ((styp_flags & STYP_DATA)
390 || (styp_flags & STYP_RDATA)
391 || (styp_flags & STYP_SDATA)
392 || styp_flags == STYP_PDATA
393 || styp_flags == STYP_XDATA
394 || (styp_flags & STYP_GOT))
396 if (sec_flags & SEC_NEVER_LOAD)
397 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
399 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
400 if ((styp_flags & STYP_RDATA)
401 || styp_flags == STYP_PDATA)
402 sec_flags |= SEC_READONLY;
404 else if ((styp_flags & STYP_BSS)
405 || (styp_flags & STYP_SBSS))
407 sec_flags |= SEC_ALLOC;
409 else if ((styp_flags & STYP_INFO) || styp_flags == STYP_COMMENT)
411 sec_flags |= SEC_NEVER_LOAD;
413 else if ((styp_flags & STYP_LITA)
414 || (styp_flags & STYP_LIT8)
415 || (styp_flags & STYP_LIT4))
417 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY;
419 else if (styp_flags & STYP_ECOFF_LIB)
421 sec_flags |= SEC_COFF_SHARED_LIBRARY;
425 sec_flags |= SEC_ALLOC | SEC_LOAD;
431 /* Read in the symbolic header for an ECOFF object file. */
434 ecoff_slurp_symbolic_header (abfd)
437 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
438 bfd_size_type external_hdr_size;
440 HDRR *internal_symhdr;
442 /* See if we've already read it in. */
443 if (ecoff_data (abfd)->debug_info.symbolic_header.magic ==
444 backend->debug_swap.sym_magic)
447 /* See whether there is a symbolic header. */
448 if (ecoff_data (abfd)->sym_filepos == 0)
450 bfd_get_symcount (abfd) = 0;
454 /* At this point bfd_get_symcount (abfd) holds the number of symbols
455 as read from the file header, but on ECOFF this is always the
456 size of the symbolic information header. It would be cleaner to
457 handle this when we first read the file in coffgen.c. */
458 external_hdr_size = backend->debug_swap.external_hdr_size;
459 if (bfd_get_symcount (abfd) != external_hdr_size)
461 bfd_set_error (bfd_error_bad_value);
465 /* Read the symbolic information header. */
466 raw = (PTR) malloc ((size_t) external_hdr_size);
469 bfd_set_error (bfd_error_no_memory);
473 if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) == -1
474 || (bfd_read (raw, external_hdr_size, 1, abfd)
475 != external_hdr_size))
477 internal_symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
478 (*backend->debug_swap.swap_hdr_in) (abfd, raw, internal_symhdr);
480 if (internal_symhdr->magic != backend->debug_swap.sym_magic)
482 bfd_set_error (bfd_error_bad_value);
486 /* Now we can get the correct number of symbols. */
487 bfd_get_symcount (abfd) = (internal_symhdr->isymMax
488 + internal_symhdr->iextMax);
499 /* Read in and swap the important symbolic information for an ECOFF
500 object file. This is called by gdb via the read_debug_info entry
501 point in the backend structure. */
505 _bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug)
508 struct ecoff_debug_info *debug;
510 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
511 HDRR *internal_symhdr;
512 bfd_size_type raw_base;
513 bfd_size_type raw_size;
515 bfd_size_type external_fdr_size;
519 bfd_size_type raw_end;
520 bfd_size_type cb_end;
522 BFD_ASSERT (debug == &ecoff_data (abfd)->debug_info);
524 /* Check whether we've already gotten it, and whether there's any to
526 if (ecoff_data (abfd)->raw_syments != (PTR) NULL)
528 if (ecoff_data (abfd)->sym_filepos == 0)
530 bfd_get_symcount (abfd) = 0;
534 if (! ecoff_slurp_symbolic_header (abfd))
537 internal_symhdr = &debug->symbolic_header;
539 /* Read all the symbolic information at once. */
540 raw_base = (ecoff_data (abfd)->sym_filepos
541 + backend->debug_swap.external_hdr_size);
543 /* Alpha ecoff makes the determination of raw_size difficult. It has
544 an undocumented debug data section between the symhdr and the first
545 documented section. And the ordering of the sections varies between
546 statically and dynamically linked executables.
547 If bfd supports SEEK_END someday, this code could be simplified. */
551 #define UPDATE_RAW_END(start, count, size) \
552 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
553 if (cb_end > raw_end) \
556 UPDATE_RAW_END (cbLineOffset, cbLine, sizeof (unsigned char));
557 UPDATE_RAW_END (cbDnOffset, idnMax, backend->debug_swap.external_dnr_size);
558 UPDATE_RAW_END (cbPdOffset, ipdMax, backend->debug_swap.external_pdr_size);
559 UPDATE_RAW_END (cbSymOffset, isymMax, backend->debug_swap.external_sym_size);
560 UPDATE_RAW_END (cbOptOffset, ioptMax, backend->debug_swap.external_opt_size);
561 UPDATE_RAW_END (cbAuxOffset, iauxMax, sizeof (union aux_ext));
562 UPDATE_RAW_END (cbSsOffset, issMax, sizeof (char));
563 UPDATE_RAW_END (cbSsExtOffset, issExtMax, sizeof (char));
564 UPDATE_RAW_END (cbFdOffset, ifdMax, backend->debug_swap.external_fdr_size);
565 UPDATE_RAW_END (cbRfdOffset, crfd, backend->debug_swap.external_rfd_size);
566 UPDATE_RAW_END (cbExtOffset, iextMax, backend->debug_swap.external_ext_size);
568 #undef UPDATE_RAW_END
570 raw_size = raw_end - raw_base;
573 ecoff_data (abfd)->sym_filepos = 0;
576 raw = (PTR) bfd_alloc (abfd, raw_size);
579 bfd_set_error (bfd_error_no_memory);
583 (ecoff_data (abfd)->sym_filepos
584 + backend->debug_swap.external_hdr_size),
586 || bfd_read (raw, raw_size, 1, abfd) != raw_size)
588 bfd_release (abfd, raw);
592 ecoff_data (abfd)->raw_syments = raw;
594 /* Get pointers for the numeric offsets in the HDRR structure. */
595 #define FIX(off1, off2, type) \
596 if (internal_symhdr->off1 == 0) \
597 debug->off2 = (type) NULL; \
599 debug->off2 = (type) ((char *) raw \
600 + (internal_symhdr->off1 \
602 FIX (cbLineOffset, line, unsigned char *);
603 FIX (cbDnOffset, external_dnr, PTR);
604 FIX (cbPdOffset, external_pdr, PTR);
605 FIX (cbSymOffset, external_sym, PTR);
606 FIX (cbOptOffset, external_opt, PTR);
607 FIX (cbAuxOffset, external_aux, union aux_ext *);
608 FIX (cbSsOffset, ss, char *);
609 FIX (cbSsExtOffset, ssext, char *);
610 FIX (cbFdOffset, external_fdr, PTR);
611 FIX (cbRfdOffset, external_rfd, PTR);
612 FIX (cbExtOffset, external_ext, PTR);
615 /* I don't want to always swap all the data, because it will just
616 waste time and most programs will never look at it. The only
617 time the linker needs most of the debugging information swapped
618 is when linking big-endian and little-endian MIPS object files
619 together, which is not a common occurrence.
621 We need to look at the fdr to deal with a lot of information in
622 the symbols, so we swap them here. */
623 debug->fdr = (struct fdr *) bfd_alloc (abfd,
624 (internal_symhdr->ifdMax *
625 sizeof (struct fdr)));
626 if (debug->fdr == NULL)
628 bfd_set_error (bfd_error_no_memory);
631 external_fdr_size = backend->debug_swap.external_fdr_size;
632 fdr_ptr = debug->fdr;
633 fraw_src = (char *) debug->external_fdr;
634 fraw_end = fraw_src + internal_symhdr->ifdMax * external_fdr_size;
635 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
636 (*backend->debug_swap.swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
641 /* ECOFF symbol table routines. The ECOFF symbol table is described
642 in gcc/mips-tfile.c. */
644 /* ECOFF uses two common sections. One is the usual one, and the
645 other is for small objects. All the small objects are kept
646 together, and then referenced via the gp pointer, which yields
647 faster assembler code. This is what we use for the small common
649 static asection ecoff_scom_section;
650 static asymbol ecoff_scom_symbol;
651 static asymbol *ecoff_scom_symbol_ptr;
653 /* Create an empty symbol. */
656 _bfd_ecoff_make_empty_symbol (abfd)
659 ecoff_symbol_type *new;
661 new = (ecoff_symbol_type *) bfd_alloc (abfd, sizeof (ecoff_symbol_type));
662 if (new == (ecoff_symbol_type *) NULL)
664 bfd_set_error (bfd_error_no_memory);
665 return (asymbol *) NULL;
667 memset ((PTR) new, 0, sizeof *new);
668 new->symbol.section = (asection *) NULL;
669 new->fdr = (FDR *) NULL;
672 new->symbol.the_bfd = abfd;
676 /* Set the BFD flags and section for an ECOFF symbol. */
679 ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, weak)
686 asym->the_bfd = abfd;
687 asym->value = ecoff_sym->value;
688 asym->section = &bfd_debug_section;
691 /* Most symbol types are just for debugging. */
692 switch (ecoff_sym->st)
701 if (ECOFF_IS_STAB (ecoff_sym))
703 asym->flags = BSF_DEBUGGING;
708 asym->flags = BSF_DEBUGGING;
713 asym->flags = BSF_EXPORT | BSF_WEAK;
715 asym->flags = BSF_EXPORT | BSF_GLOBAL;
718 asym->flags = BSF_LOCAL;
719 /* Normally, a local stProc symbol will have a corresponding
720 external symbol. We mark the local symbol as a debugging
721 symbol, in order to prevent nm from printing both out.
722 Similarly, we mark stLabel and stabs symbols as debugging
723 symbols. In both cases, we do want to set the value
724 correctly based on the symbol class. */
725 if (ecoff_sym->st == stProc
726 || ecoff_sym->st == stLabel
727 || ECOFF_IS_STAB (ecoff_sym))
728 asym->flags |= BSF_DEBUGGING;
730 switch (ecoff_sym->sc)
733 /* Used for compiler generated labels. Leave them in the
734 debugging section, and mark them as local. If BSF_DEBUGGING
735 is set, then nm does not display them for some reason. If no
736 flags are set then the linker whines about them. */
737 asym->flags = BSF_LOCAL;
740 asym->section = bfd_make_section_old_way (abfd, ".text");
741 asym->value -= asym->section->vma;
744 asym->section = bfd_make_section_old_way (abfd, ".data");
745 asym->value -= asym->section->vma;
748 asym->section = bfd_make_section_old_way (abfd, ".bss");
749 asym->value -= asym->section->vma;
752 asym->flags = BSF_DEBUGGING;
755 asym->section = bfd_abs_section_ptr;
758 asym->section = bfd_und_section_ptr;
768 asym->flags = BSF_DEBUGGING;
771 asym->section = bfd_make_section_old_way (abfd, ".sdata");
772 asym->value -= asym->section->vma;
775 asym->section = bfd_make_section_old_way (abfd, ".sbss");
776 asym->value -= asym->section->vma;
779 asym->section = bfd_make_section_old_way (abfd, ".rdata");
780 asym->value -= asym->section->vma;
783 asym->flags = BSF_DEBUGGING;
786 if (asym->value > ecoff_data (abfd)->gp_size)
788 asym->section = bfd_com_section_ptr;
794 if (ecoff_scom_section.name == NULL)
796 /* Initialize the small common section. */
797 ecoff_scom_section.name = SCOMMON;
798 ecoff_scom_section.flags = SEC_IS_COMMON;
799 ecoff_scom_section.output_section = &ecoff_scom_section;
800 ecoff_scom_section.symbol = &ecoff_scom_symbol;
801 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
802 ecoff_scom_symbol.name = SCOMMON;
803 ecoff_scom_symbol.flags = BSF_SECTION_SYM;
804 ecoff_scom_symbol.section = &ecoff_scom_section;
805 ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
807 asym->section = &ecoff_scom_section;
812 asym->flags = BSF_DEBUGGING;
815 asym->section = bfd_und_section_ptr;
820 asym->section = bfd_make_section_old_way (abfd, ".init");
821 asym->value -= asym->section->vma;
826 asym->flags = BSF_DEBUGGING;
829 asym->section = bfd_make_section_old_way (abfd, ".fini");
830 asym->value -= asym->section->vma;
836 /* Look for special constructors symbols and make relocation entries
837 in a special construction section. These are produced by the
838 -fgnu-linker argument to g++. */
839 if (ECOFF_IS_STAB (ecoff_sym))
841 switch (ECOFF_UNMARK_STAB (ecoff_sym->index))
853 arelent_chain *reloc_chain;
854 unsigned int bitsize;
856 /* Get a section with the same name as the symbol (usually
857 __CTOR_LIST__ or __DTOR_LIST__). FIXME: gcc uses the
858 name ___CTOR_LIST (three underscores). We need
859 __CTOR_LIST (two underscores), since ECOFF doesn't use
860 a leading underscore. This should be handled by gcc,
861 but instead we do it here. Actually, this should all
862 be done differently anyhow. */
863 name = bfd_asymbol_name (asym);
864 if (name[0] == '_' && name[1] == '_' && name[2] == '_')
869 section = bfd_get_section_by_name (abfd, name);
870 if (section == (asection *) NULL)
874 copy = (char *) bfd_alloc (abfd, strlen (name) + 1);
877 bfd_set_error (bfd_error_no_memory);
881 section = bfd_make_section (abfd, copy);
884 /* Build a reloc pointing to this constructor. */
886 (arelent_chain *) bfd_alloc (abfd, sizeof (arelent_chain));
889 bfd_set_error (bfd_error_no_memory);
892 reloc_chain->relent.sym_ptr_ptr =
893 bfd_get_section (asym)->symbol_ptr_ptr;
894 reloc_chain->relent.address = section->_raw_size;
895 reloc_chain->relent.addend = asym->value;
896 reloc_chain->relent.howto =
897 ecoff_backend (abfd)->constructor_reloc;
899 /* Set up the constructor section to hold the reloc. */
900 section->flags = SEC_CONSTRUCTOR;
901 ++section->reloc_count;
903 /* Constructor sections must be rounded to a boundary
904 based on the bitsize. These are not real sections--
905 they are handled specially by the linker--so the ECOFF
906 16 byte alignment restriction does not apply. */
907 bitsize = ecoff_backend (abfd)->constructor_bitsize;
908 section->alignment_power = 1;
909 while ((1 << section->alignment_power) < bitsize / 8)
910 ++section->alignment_power;
912 reloc_chain->next = section->constructor_chain;
913 section->constructor_chain = reloc_chain;
914 section->_raw_size += bitsize / 8;
916 /* Mark the symbol as a constructor. */
917 asym->flags |= BSF_CONSTRUCTOR;
925 /* Read an ECOFF symbol table. */
928 _bfd_ecoff_slurp_symbol_table (abfd)
931 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
932 const bfd_size_type external_ext_size
933 = backend->debug_swap.external_ext_size;
934 const bfd_size_type external_sym_size
935 = backend->debug_swap.external_sym_size;
936 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
937 = backend->debug_swap.swap_ext_in;
938 void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *))
939 = backend->debug_swap.swap_sym_in;
940 bfd_size_type internal_size;
941 ecoff_symbol_type *internal;
942 ecoff_symbol_type *internal_ptr;
948 /* If we've already read in the symbol table, do nothing. */
949 if (ecoff_data (abfd)->canonical_symbols != NULL)
952 /* Get the symbolic information. */
953 if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL,
954 &ecoff_data (abfd)->debug_info))
956 if (bfd_get_symcount (abfd) == 0)
959 internal_size = bfd_get_symcount (abfd) * sizeof (ecoff_symbol_type);
960 internal = (ecoff_symbol_type *) bfd_alloc (abfd, internal_size);
961 if (internal == NULL)
963 bfd_set_error (bfd_error_no_memory);
967 internal_ptr = internal;
968 eraw_src = (char *) ecoff_data (abfd)->debug_info.external_ext;
970 + (ecoff_data (abfd)->debug_info.symbolic_header.iextMax
971 * external_ext_size));
972 for (; eraw_src < eraw_end; eraw_src += external_ext_size, internal_ptr++)
976 (*swap_ext_in) (abfd, (PTR) eraw_src, &internal_esym);
977 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ssext
978 + internal_esym.asym.iss);
979 if (!ecoff_set_symbol_info (abfd, &internal_esym.asym,
980 &internal_ptr->symbol, 1,
981 internal_esym.weakext))
983 /* The alpha uses a negative ifd field for section symbols. */
984 if (internal_esym.ifd >= 0)
985 internal_ptr->fdr = (ecoff_data (abfd)->debug_info.fdr
986 + internal_esym.ifd);
988 internal_ptr->fdr = NULL;
989 internal_ptr->local = false;
990 internal_ptr->native = (PTR) eraw_src;
993 /* The local symbols must be accessed via the fdr's, because the
994 string and aux indices are relative to the fdr information. */
995 fdr_ptr = ecoff_data (abfd)->debug_info.fdr;
996 fdr_end = fdr_ptr + ecoff_data (abfd)->debug_info.symbolic_header.ifdMax;
997 for (; fdr_ptr < fdr_end; fdr_ptr++)
1002 lraw_src = ((char *) ecoff_data (abfd)->debug_info.external_sym
1003 + fdr_ptr->isymBase * external_sym_size);
1004 lraw_end = lraw_src + fdr_ptr->csym * external_sym_size;
1006 lraw_src < lraw_end;
1007 lraw_src += external_sym_size, internal_ptr++)
1011 (*swap_sym_in) (abfd, (PTR) lraw_src, &internal_sym);
1012 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ss
1014 + internal_sym.iss);
1015 if (!ecoff_set_symbol_info (abfd, &internal_sym,
1016 &internal_ptr->symbol, 0, 0))
1018 internal_ptr->fdr = fdr_ptr;
1019 internal_ptr->local = true;
1020 internal_ptr->native = (PTR) lraw_src;
1024 ecoff_data (abfd)->canonical_symbols = internal;
1029 /* Return the amount of space needed for the canonical symbols. */
1032 _bfd_ecoff_get_symtab_upper_bound (abfd)
1035 if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL,
1036 &ecoff_data (abfd)->debug_info))
1039 if (bfd_get_symcount (abfd) == 0)
1042 return (bfd_get_symcount (abfd) + 1) * (sizeof (ecoff_symbol_type *));
1045 /* Get the canonical symbols. */
1048 _bfd_ecoff_get_symtab (abfd, alocation)
1050 asymbol **alocation;
1052 unsigned int counter = 0;
1053 ecoff_symbol_type *symbase;
1054 ecoff_symbol_type **location = (ecoff_symbol_type **) alocation;
1056 if (_bfd_ecoff_slurp_symbol_table (abfd) == false)
1058 if (bfd_get_symcount (abfd) == 0)
1061 symbase = ecoff_data (abfd)->canonical_symbols;
1062 while (counter < bfd_get_symcount (abfd))
1064 *(location++) = symbase++;
1067 *location++ = (ecoff_symbol_type *) NULL;
1068 return bfd_get_symcount (abfd);
1071 /* Turn ECOFF type information into a printable string.
1072 ecoff_emit_aggregate and ecoff_type_to_string are from
1073 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1075 /* Write aggregate information to a string. */
1078 ecoff_emit_aggregate (abfd, fdr, string, rndx, isym, which)
1086 const struct ecoff_debug_swap * const debug_swap =
1087 &ecoff_backend (abfd)->debug_swap;
1088 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info;
1089 unsigned int ifd = rndx->rfd;
1090 unsigned int indx = rndx->index;
1096 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1097 struct return type of a procedure compiled without -g. */
1098 if (ifd == 0xffffffff
1099 || (rndx->rfd == 0xfff && indx == 0))
1100 name = "<undefined>";
1101 else if (indx == indexNil)
1107 if (debug_info->external_rfd == NULL)
1108 fdr = debug_info->fdr + ifd;
1113 (*debug_swap->swap_rfd_in) (abfd,
1114 ((char *) debug_info->external_rfd
1115 + ((fdr->rfdBase + ifd)
1116 * debug_swap->external_rfd_size)),
1118 fdr = debug_info->fdr + rfd;
1121 indx += fdr->isymBase;
1123 (*debug_swap->swap_sym_in) (abfd,
1124 ((char *) debug_info->external_sym
1125 + indx * debug_swap->external_sym_size),
1128 name = debug_info->ss + fdr->issBase + sym.iss;
1132 "%s %s { ifd = %u, index = %lu }",
1135 + debug_info->symbolic_header.iextMax));
1138 /* Convert the type information to string format. */
1141 ecoff_type_to_string (abfd, fdr, indx)
1146 union aux_ext *aux_ptr;
1155 unsigned int basic_type;
1158 static char buffer2[1024];
1163 aux_ptr = ecoff_data (abfd)->debug_info.external_aux + fdr->iauxBase;
1164 bigendian = fdr->fBigendian;
1166 for (i = 0; i < 7; i++)
1168 qualifiers[i].low_bound = 0;
1169 qualifiers[i].high_bound = 0;
1170 qualifiers[i].stride = 0;
1173 if (AUX_GET_ISYM (bigendian, &aux_ptr[indx]) == (bfd_vma) -1)
1174 return "-1 (no type)";
1175 _bfd_ecoff_swap_tir_in (bigendian, &aux_ptr[indx++].a_ti, &u.ti);
1177 basic_type = u.ti.bt;
1178 qualifiers[0].type = u.ti.tq0;
1179 qualifiers[1].type = u.ti.tq1;
1180 qualifiers[2].type = u.ti.tq2;
1181 qualifiers[3].type = u.ti.tq3;
1182 qualifiers[4].type = u.ti.tq4;
1183 qualifiers[5].type = u.ti.tq5;
1184 qualifiers[6].type = tqNil;
1187 * Go get the basic type.
1191 case btNil: /* undefined */
1195 case btAdr: /* address - integer same size as pointer */
1196 strcpy (p1, "address");
1199 case btChar: /* character */
1200 strcpy (p1, "char");
1203 case btUChar: /* unsigned character */
1204 strcpy (p1, "unsigned char");
1207 case btShort: /* short */
1208 strcpy (p1, "short");
1211 case btUShort: /* unsigned short */
1212 strcpy (p1, "unsigned short");
1215 case btInt: /* int */
1219 case btUInt: /* unsigned int */
1220 strcpy (p1, "unsigned int");
1223 case btLong: /* long */
1224 strcpy (p1, "long");
1227 case btULong: /* unsigned long */
1228 strcpy (p1, "unsigned long");
1231 case btFloat: /* float (real) */
1232 strcpy (p1, "float");
1235 case btDouble: /* Double (real) */
1236 strcpy (p1, "double");
1239 /* Structures add 1-2 aux words:
1240 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1241 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1243 case btStruct: /* Structure (Record) */
1244 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1245 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1246 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1248 indx++; /* skip aux words */
1251 /* Unions add 1-2 aux words:
1252 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1253 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1255 case btUnion: /* Union */
1256 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1257 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1258 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1260 indx++; /* skip aux words */
1263 /* Enumerations add 1-2 aux words:
1264 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1265 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1267 case btEnum: /* Enumeration */
1268 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1269 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1270 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1272 indx++; /* skip aux words */
1275 case btTypedef: /* defined via a typedef, isymRef points */
1276 strcpy (p1, "typedef");
1279 case btRange: /* subrange of int */
1280 strcpy (p1, "subrange");
1283 case btSet: /* pascal sets */
1287 case btComplex: /* fortran complex */
1288 strcpy (p1, "complex");
1291 case btDComplex: /* fortran double complex */
1292 strcpy (p1, "double complex");
1295 case btIndirect: /* forward or unnamed typedef */
1296 strcpy (p1, "forward/unamed typedef");
1299 case btFixedDec: /* Fixed Decimal */
1300 strcpy (p1, "fixed decimal");
1303 case btFloatDec: /* Float Decimal */
1304 strcpy (p1, "float decimal");
1307 case btString: /* Varying Length Character String */
1308 strcpy (p1, "string");
1311 case btBit: /* Aligned Bit String */
1315 case btPicture: /* Picture */
1316 strcpy (p1, "picture");
1319 case btVoid: /* Void */
1320 strcpy (p1, "void");
1324 sprintf (p1, "Unknown basic type %d", (int) basic_type);
1328 p1 += strlen (buffer1);
1331 * If this is a bitfield, get the bitsize.
1337 bitsize = AUX_GET_WIDTH (bigendian, &aux_ptr[indx++]);
1338 sprintf (p1, " : %d", bitsize);
1339 p1 += strlen (buffer1);
1344 * Deal with any qualifiers.
1346 if (qualifiers[0].type != tqNil)
1349 * Snarf up any array bounds in the correct order. Arrays
1350 * store 5 successive words in the aux. table:
1351 * word 0 RNDXR to type of the bounds (ie, int)
1352 * word 1 Current file descriptor index
1354 * word 3 high bound (or -1 if [])
1355 * word 4 stride size in bits
1357 for (i = 0; i < 7; i++)
1359 if (qualifiers[i].type == tqArray)
1361 qualifiers[i].low_bound =
1362 AUX_GET_DNLOW (bigendian, &aux_ptr[indx+2]);
1363 qualifiers[i].high_bound =
1364 AUX_GET_DNHIGH (bigendian, &aux_ptr[indx+3]);
1365 qualifiers[i].stride =
1366 AUX_GET_WIDTH (bigendian, &aux_ptr[indx+4]);
1372 * Now print out the qualifiers.
1374 for (i = 0; i < 6; i++)
1376 switch (qualifiers[i].type)
1383 strcpy (p2, "ptr to ");
1384 p2 += sizeof ("ptr to ")-1;
1388 strcpy (p2, "volatile ");
1389 p2 += sizeof ("volatile ")-1;
1393 strcpy (p2, "far ");
1394 p2 += sizeof ("far ")-1;
1398 strcpy (p2, "func. ret. ");
1399 p2 += sizeof ("func. ret. ");
1404 int first_array = i;
1407 /* Print array bounds reversed (ie, in the order the C
1408 programmer writes them). C is such a fun language.... */
1410 while (i < 5 && qualifiers[i+1].type == tqArray)
1413 for (j = i; j >= first_array; j--)
1415 strcpy (p2, "array [");
1416 p2 += sizeof ("array [")-1;
1417 if (qualifiers[j].low_bound != 0)
1419 "%ld:%ld {%ld bits}",
1420 (long) qualifiers[j].low_bound,
1421 (long) qualifiers[j].high_bound,
1422 (long) qualifiers[j].stride);
1424 else if (qualifiers[j].high_bound != -1)
1427 (long) (qualifiers[j].high_bound + 1),
1428 (long) (qualifiers[j].stride));
1431 sprintf (p2, " {%ld bits}", (long) (qualifiers[j].stride));
1434 strcpy (p2, "] of ");
1435 p2 += sizeof ("] of ")-1;
1443 strcpy (p2, buffer1);
1447 /* Return information about ECOFF symbol SYMBOL in RET. */
1451 _bfd_ecoff_get_symbol_info (abfd, symbol, ret)
1452 bfd *abfd; /* Ignored. */
1456 bfd_symbol_info (symbol, ret);
1459 /* Return whether this is a local label. */
1463 _bfd_ecoff_bfd_is_local_label (abfd, symbol)
1467 return symbol->name[0] == '$';
1470 /* Print information about an ECOFF symbol. */
1473 _bfd_ecoff_print_symbol (abfd, filep, symbol, how)
1477 bfd_print_symbol_type how;
1479 const struct ecoff_debug_swap * const debug_swap
1480 = &ecoff_backend (abfd)->debug_swap;
1481 FILE *file = (FILE *)filep;
1485 case bfd_print_symbol_name:
1486 fprintf (file, "%s", symbol->name);
1488 case bfd_print_symbol_more:
1489 if (ecoffsymbol (symbol)->local)
1493 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
1495 fprintf (file, "ecoff local ");
1496 fprintf_vma (file, (bfd_vma) ecoff_sym.value);
1497 fprintf (file, " %x %x", (unsigned) ecoff_sym.st,
1498 (unsigned) ecoff_sym.sc);
1504 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
1506 fprintf (file, "ecoff extern ");
1507 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
1508 fprintf (file, " %x %x", (unsigned) ecoff_ext.asym.st,
1509 (unsigned) ecoff_ext.asym.sc);
1512 case bfd_print_symbol_all:
1513 /* Print out the symbols in a reasonable way */
1522 if (ecoffsymbol (symbol)->local)
1524 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
1527 pos = ((((char *) ecoffsymbol (symbol)->native
1528 - (char *) ecoff_data (abfd)->debug_info.external_sym)
1529 / debug_swap->external_sym_size)
1530 + ecoff_data (abfd)->debug_info.symbolic_header.iextMax);
1537 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
1540 pos = (((char *) ecoffsymbol (symbol)->native
1541 - (char *) ecoff_data (abfd)->debug_info.external_ext)
1542 / debug_swap->external_ext_size);
1543 jmptbl = ecoff_ext.jmptbl ? 'j' : ' ';
1544 cobol_main = ecoff_ext.cobol_main ? 'c' : ' ';
1545 weakext = ecoff_ext.weakext ? 'w' : ' ';
1548 fprintf (file, "[%3d] %c ",
1550 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
1551 fprintf (file, " st %x sc %x indx %x %c%c%c %s",
1552 (unsigned) ecoff_ext.asym.st,
1553 (unsigned) ecoff_ext.asym.sc,
1554 (unsigned) ecoff_ext.asym.index,
1555 jmptbl, cobol_main, weakext,
1558 if (ecoffsymbol (symbol)->fdr != NULL
1559 && ecoff_ext.asym.index != indexNil)
1564 bfd_size_type sym_base;
1565 union aux_ext *aux_base;
1567 fdr = ecoffsymbol (symbol)->fdr;
1568 indx = ecoff_ext.asym.index;
1570 /* sym_base is used to map the fdr relative indices which
1571 appear in the file to the position number which we are
1573 sym_base = fdr->isymBase;
1574 if (ecoffsymbol (symbol)->local)
1576 ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
1578 /* aux_base is the start of the aux entries for this file;
1579 asym.index is an offset from this. */
1580 aux_base = (ecoff_data (abfd)->debug_info.external_aux
1583 /* The aux entries are stored in host byte order; the
1584 order is indicated by a bit in the fdr. */
1585 bigendian = fdr->fBigendian;
1587 /* This switch is basically from gcc/mips-tdump.c */
1588 switch (ecoff_ext.asym.st)
1596 fprintf (file, "\n End+1 symbol: %ld",
1597 (long) (indx + sym_base));
1601 if (ecoff_ext.asym.sc == scText
1602 || ecoff_ext.asym.sc == scInfo)
1603 fprintf (file, "\n First symbol: %ld",
1604 (long) (indx + sym_base));
1606 fprintf (file, "\n First symbol: %ld",
1608 (AUX_GET_ISYM (bigendian,
1609 &aux_base[ecoff_ext.asym.index])
1615 if (ECOFF_IS_STAB (&ecoff_ext.asym))
1617 else if (ecoffsymbol (symbol)->local)
1618 fprintf (file, "\n End+1 symbol: %-7ld Type: %s",
1620 (AUX_GET_ISYM (bigendian,
1621 &aux_base[ecoff_ext.asym.index])
1623 ecoff_type_to_string (abfd, fdr, indx + 1));
1625 fprintf (file, "\n Local symbol: %ld",
1628 + (ecoff_data (abfd)
1629 ->debug_info.symbolic_header.iextMax)));
1633 fprintf (file, "\n struct; End+1 symbol: %ld",
1634 (long) (indx + sym_base));
1638 fprintf (file, "\n union; End+1 symbol: %ld",
1639 (long) (indx + sym_base));
1643 fprintf (file, "\n enum; End+1 symbol: %ld",
1644 (long) (indx + sym_base));
1648 if (! ECOFF_IS_STAB (&ecoff_ext.asym))
1649 fprintf (file, "\n Type: %s",
1650 ecoff_type_to_string (abfd, fdr, indx));
1659 /* Read in the relocs for a section. */
1662 ecoff_slurp_reloc_table (abfd, section, symbols)
1667 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
1668 arelent *internal_relocs;
1669 bfd_size_type external_reloc_size;
1670 bfd_size_type external_relocs_size;
1671 char *external_relocs;
1675 if (section->relocation != (arelent *) NULL
1676 || section->reloc_count == 0
1677 || (section->flags & SEC_CONSTRUCTOR) != 0)
1680 if (_bfd_ecoff_slurp_symbol_table (abfd) == false)
1683 internal_relocs = (arelent *) bfd_alloc (abfd,
1685 * section->reloc_count));
1686 external_reloc_size = backend->external_reloc_size;
1687 external_relocs_size = external_reloc_size * section->reloc_count;
1688 external_relocs = (char *) bfd_alloc (abfd, external_relocs_size);
1689 if (internal_relocs == (arelent *) NULL
1690 || external_relocs == (char *) NULL)
1692 bfd_set_error (bfd_error_no_memory);
1695 if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0)
1697 if (bfd_read (external_relocs, 1, external_relocs_size, abfd)
1698 != external_relocs_size)
1701 for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++)
1703 struct internal_reloc intern;
1705 (*backend->swap_reloc_in) (abfd,
1706 external_relocs + i * external_reloc_size,
1709 if (intern.r_extern)
1711 /* r_symndx is an index into the external symbols. */
1712 BFD_ASSERT (intern.r_symndx >= 0
1714 < (ecoff_data (abfd)
1715 ->debug_info.symbolic_header.iextMax)));
1716 rptr->sym_ptr_ptr = symbols + intern.r_symndx;
1719 else if (intern.r_symndx == RELOC_SECTION_NONE
1720 || intern.r_symndx == RELOC_SECTION_ABS)
1722 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1727 CONST char *sec_name;
1730 /* r_symndx is a section key. */
1731 switch (intern.r_symndx)
1733 case RELOC_SECTION_TEXT: sec_name = ".text"; break;
1734 case RELOC_SECTION_RDATA: sec_name = ".rdata"; break;
1735 case RELOC_SECTION_DATA: sec_name = ".data"; break;
1736 case RELOC_SECTION_SDATA: sec_name = ".sdata"; break;
1737 case RELOC_SECTION_SBSS: sec_name = ".sbss"; break;
1738 case RELOC_SECTION_BSS: sec_name = ".bss"; break;
1739 case RELOC_SECTION_INIT: sec_name = ".init"; break;
1740 case RELOC_SECTION_LIT8: sec_name = ".lit8"; break;
1741 case RELOC_SECTION_LIT4: sec_name = ".lit4"; break;
1742 case RELOC_SECTION_XDATA: sec_name = ".xdata"; break;
1743 case RELOC_SECTION_PDATA: sec_name = ".pdata"; break;
1744 case RELOC_SECTION_FINI: sec_name = ".fini"; break;
1745 case RELOC_SECTION_LITA: sec_name = ".lita"; 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
1818 _bfd_ecoff_find_nearest_line (abfd, section, ignore_symbols, offset,
1819 filename_ptr, functionname_ptr, retline_ptr)
1822 asymbol **ignore_symbols;
1824 CONST char **filename_ptr;
1825 CONST char **functionname_ptr;
1826 unsigned int *retline_ptr;
1828 const struct ecoff_debug_swap * const debug_swap
1829 = &ecoff_backend (abfd)->debug_swap;
1830 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info;
1831 struct ecoff_find_line *line_info;
1833 /* If we're not in the .text section, we don't have any line
1835 if (strcmp (section->name, _TEXT) != 0
1836 || offset >= bfd_section_size (abfd, section))
1839 /* Make sure we have the FDR's. */
1840 if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL, debug_info)
1841 || bfd_get_symcount (abfd) == 0)
1844 if (ecoff_data (abfd)->find_line_info == NULL)
1846 ecoff_data (abfd)->find_line_info =
1847 ((struct ecoff_find_line *)
1848 bfd_alloc (abfd, sizeof (struct ecoff_find_line)));
1849 if (ecoff_data (abfd)->find_line_info == NULL)
1851 bfd_set_error (bfd_error_no_memory);
1854 ecoff_data (abfd)->find_line_info->find_buffer = NULL;
1855 ecoff_data (abfd)->find_line_info->fdrtab_len = 0;
1856 ecoff_data (abfd)->find_line_info->fdrtab = NULL;
1858 line_info = ecoff_data (abfd)->find_line_info;
1860 return _bfd_ecoff_locate_line (abfd, section, offset, debug_info,
1861 debug_swap, line_info, filename_ptr,
1862 functionname_ptr, retline_ptr);
1865 /* Copy private BFD data. This is called by objcopy and strip. We
1866 use it to copy the ECOFF debugging information from one BFD to the
1867 other. It would be theoretically possible to represent the ECOFF
1868 debugging information in the symbol table. However, it would be a
1869 lot of work, and there would be little gain (gas, gdb, and ld
1870 already access the ECOFF debugging information via the
1871 ecoff_debug_info structure, and that structure would have to be
1872 retained in order to support ECOFF debugging in MIPS ELF).
1874 The debugging information for the ECOFF external symbols comes from
1875 the symbol table, so this function only handles the other debugging
1879 _bfd_ecoff_bfd_copy_private_bfd_data (ibfd, obfd)
1883 struct ecoff_debug_info *iinfo = &ecoff_data (ibfd)->debug_info;
1884 struct ecoff_debug_info *oinfo = &ecoff_data (obfd)->debug_info;
1886 asymbol **sym_ptr_ptr;
1890 /* This function is selected based on the input vector. We only
1891 want to copy information over if the output BFD also uses ECOFF
1893 if (bfd_get_flavour (obfd) != bfd_target_ecoff_flavour)
1896 /* Copy the GP value and the register masks. */
1897 ecoff_data (obfd)->gp = ecoff_data (ibfd)->gp;
1898 ecoff_data (obfd)->gprmask = ecoff_data (ibfd)->gprmask;
1899 ecoff_data (obfd)->fprmask = ecoff_data (ibfd)->fprmask;
1900 for (i = 0; i < 3; i++)
1901 ecoff_data (obfd)->cprmask[i] = ecoff_data (ibfd)->cprmask[i];
1903 /* Copy the version stamp. */
1904 oinfo->symbolic_header.vstamp = iinfo->symbolic_header.vstamp;
1906 /* If there are no symbols, don't copy any debugging information. */
1907 c = bfd_get_symcount (obfd);
1908 sym_ptr_ptr = bfd_get_outsymbols (obfd);
1909 if (c == 0 || sym_ptr_ptr == (asymbol **) NULL)
1912 /* See if there are any local symbols. */
1914 for (; c > 0; c--, sym_ptr_ptr++)
1916 if (ecoffsymbol (*sym_ptr_ptr)->local)
1925 /* There are some local symbols. We just bring over all the
1926 debugging information. FIXME: This is not quite the right
1927 thing to do. If the user has asked us to discard all
1928 debugging information, then we are probably going to wind up
1929 keeping it because there will probably be some local symbol
1930 which objcopy did not discard. We should actually break
1931 apart the debugging information and only keep that which
1932 applies to the symbols we want to keep. */
1933 oinfo->symbolic_header.ilineMax = iinfo->symbolic_header.ilineMax;
1934 oinfo->symbolic_header.cbLine = iinfo->symbolic_header.cbLine;
1935 oinfo->line = iinfo->line;
1937 oinfo->symbolic_header.idnMax = iinfo->symbolic_header.idnMax;
1938 oinfo->external_dnr = iinfo->external_dnr;
1940 oinfo->symbolic_header.ipdMax = iinfo->symbolic_header.ipdMax;
1941 oinfo->external_pdr = iinfo->external_pdr;
1943 oinfo->symbolic_header.isymMax = iinfo->symbolic_header.isymMax;
1944 oinfo->external_sym = iinfo->external_sym;
1946 oinfo->symbolic_header.ioptMax = iinfo->symbolic_header.ioptMax;
1947 oinfo->external_opt = iinfo->external_opt;
1949 oinfo->symbolic_header.iauxMax = iinfo->symbolic_header.iauxMax;
1950 oinfo->external_aux = iinfo->external_aux;
1952 oinfo->symbolic_header.issMax = iinfo->symbolic_header.issMax;
1953 oinfo->ss = iinfo->ss;
1955 oinfo->symbolic_header.ifdMax = iinfo->symbolic_header.ifdMax;
1956 oinfo->external_fdr = iinfo->external_fdr;
1958 oinfo->symbolic_header.crfd = iinfo->symbolic_header.crfd;
1959 oinfo->external_rfd = iinfo->external_rfd;
1963 /* We are discarding all the local symbol information. Look
1964 through the external symbols and remove all references to FDR
1965 or aux information. */
1966 c = bfd_get_symcount (obfd);
1967 sym_ptr_ptr = bfd_get_outsymbols (obfd);
1968 for (; c > 0; c--, sym_ptr_ptr++)
1972 (*(ecoff_backend (obfd)->debug_swap.swap_ext_in))
1973 (obfd, ecoffsymbol (*sym_ptr_ptr)->native, &esym);
1975 esym.asym.index = indexNil;
1976 (*(ecoff_backend (obfd)->debug_swap.swap_ext_out))
1977 (obfd, &esym, ecoffsymbol (*sym_ptr_ptr)->native);
1984 /* Set the architecture. The supported architecture is stored in the
1985 backend pointer. We always set the architecture anyhow, since many
1986 callers ignore the return value. */
1989 _bfd_ecoff_set_arch_mach (abfd, arch, machine)
1991 enum bfd_architecture arch;
1992 unsigned long machine;
1994 bfd_default_set_arch_mach (abfd, arch, machine);
1995 return arch == ecoff_backend (abfd)->arch;
1998 /* Get the size of the section headers. */
2002 _bfd_ecoff_sizeof_headers (abfd, reloc)
2011 for (current = abfd->sections;
2012 current != (asection *)NULL;
2013 current = current->next)
2016 ret = (bfd_coff_filhsz (abfd)
2017 + bfd_coff_aoutsz (abfd)
2018 + c * bfd_coff_scnhsz (abfd));
2019 return BFD_ALIGN (ret, 16);
2022 /* Get the contents of a section. */
2025 _bfd_ecoff_get_section_contents (abfd, section, location, offset, count)
2030 bfd_size_type count;
2032 return _bfd_generic_get_section_contents (abfd, section, location,
2036 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
2037 called via qsort. */
2040 ecoff_sort_hdrs (arg1, arg2)
2044 const asection *hdr1 = *(const asection **) arg1;
2045 const asection *hdr2 = *(const asection **) arg2;
2047 if ((hdr1->flags & SEC_ALLOC) != 0)
2049 if ((hdr2->flags & SEC_ALLOC) == 0)
2054 if ((hdr2->flags & SEC_ALLOC) != 0)
2057 if (hdr1->vma < hdr2->vma)
2059 else if (hdr1->vma > hdr2->vma)
2065 /* Calculate the file position for each section, and set
2069 ecoff_compute_section_file_positions (abfd)
2073 asection **sorted_hdrs;
2077 boolean first_data, first_nonalloc;
2078 const bfd_vma round = ecoff_backend (abfd)->round;
2080 sofar = _bfd_ecoff_sizeof_headers (abfd, false);
2082 /* Sort the sections by VMA. */
2083 sorted_hdrs = (asection **) malloc (abfd->section_count
2084 * sizeof (asection *));
2085 if (sorted_hdrs == NULL)
2087 bfd_set_error (bfd_error_no_memory);
2090 for (current = abfd->sections, i = 0;
2092 current = current->next, i++)
2093 sorted_hdrs[i] = current;
2094 BFD_ASSERT (i == abfd->section_count);
2096 qsort (sorted_hdrs, abfd->section_count, sizeof (asection *),
2100 first_nonalloc = true;
2101 for (i = 0; i < abfd->section_count; i++)
2103 unsigned int alignment_power;
2105 current = sorted_hdrs[i];
2107 /* Only deal with sections which have contents */
2108 if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) == 0)
2111 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2112 supposed to indicate the number of .pdata entries that are
2113 really in the section. Each entry is 8 bytes. We store this
2114 away in line_filepos before increasing the section size. */
2115 if (strcmp (current->name, _PDATA) != 0)
2116 alignment_power = current->alignment_power;
2119 current->line_filepos = current->_raw_size / 8;
2120 alignment_power = 4;
2123 /* On Ultrix, the data sections in an executable file must be
2124 aligned to a page boundary within the file. This does not
2125 affect the section size, though. FIXME: Does this work for
2126 other platforms? It requires some modification for the
2127 Alpha, because .rdata on the Alpha goes with the text, not
2129 if ((abfd->flags & EXEC_P) != 0
2130 && (abfd->flags & D_PAGED) != 0
2131 && first_data != false
2132 && (current->flags & SEC_CODE) == 0
2133 && (! ecoff_backend (abfd)->rdata_in_text
2134 || strcmp (current->name, _RDATA) != 0)
2135 && strcmp (current->name, _PDATA) != 0)
2137 sofar = (sofar + round - 1) &~ (round - 1);
2140 else if (strcmp (current->name, _LIB) == 0)
2142 /* On Irix 4, the location of contents of the .lib section
2143 from a shared library section is also rounded up to a
2146 sofar = (sofar + round - 1) &~ (round - 1);
2148 else if (first_nonalloc
2149 && (current->flags & SEC_ALLOC) == 0
2150 && (abfd->flags & D_PAGED) != 0)
2152 /* Skip up to the next page for an unallocated section, such
2153 as the .comment section on the Alpha. This leaves room
2154 for the .bss section. */
2155 first_nonalloc = false;
2156 sofar = (sofar + round - 1) &~ (round - 1);
2159 /* Align the sections in the file to the same boundary on
2160 which they are aligned in virtual memory. */
2162 sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2164 if ((abfd->flags & D_PAGED) != 0
2165 && (current->flags & SEC_ALLOC) != 0)
2166 sofar += (current->vma - sofar) % round;
2168 current->filepos = sofar;
2170 sofar += current->_raw_size;
2172 /* make sure that this section is of the right size too */
2174 sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2175 current->_raw_size += sofar - old_sofar;
2181 ecoff_data (abfd)->reloc_filepos = sofar;
2186 /* Determine the location of the relocs for all the sections in the
2187 output file, as well as the location of the symbolic debugging
2190 static bfd_size_type
2191 ecoff_compute_reloc_file_positions (abfd)
2194 const bfd_size_type external_reloc_size =
2195 ecoff_backend (abfd)->external_reloc_size;
2196 file_ptr reloc_base;
2197 bfd_size_type reloc_size;
2201 if (! abfd->output_has_begun)
2203 if (! ecoff_compute_section_file_positions (abfd))
2205 abfd->output_has_begun = true;
2208 reloc_base = ecoff_data (abfd)->reloc_filepos;
2211 for (current = abfd->sections;
2212 current != (asection *)NULL;
2213 current = current->next)
2215 if (current->reloc_count == 0)
2216 current->rel_filepos = 0;
2219 bfd_size_type relsize;
2221 current->rel_filepos = reloc_base;
2222 relsize = current->reloc_count * external_reloc_size;
2223 reloc_size += relsize;
2224 reloc_base += relsize;
2228 sym_base = ecoff_data (abfd)->reloc_filepos + reloc_size;
2230 /* At least on Ultrix, the symbol table of an executable file must
2231 be aligned to a page boundary. FIXME: Is this true on other
2233 if ((abfd->flags & EXEC_P) != 0
2234 && (abfd->flags & D_PAGED) != 0)
2235 sym_base = ((sym_base + ecoff_backend (abfd)->round - 1)
2236 &~ (ecoff_backend (abfd)->round - 1));
2238 ecoff_data (abfd)->sym_filepos = sym_base;
2243 /* Set the contents of a section. */
2246 _bfd_ecoff_set_section_contents (abfd, section, location, offset, count)
2251 bfd_size_type count;
2253 /* This must be done first, because bfd_set_section_contents is
2254 going to set output_has_begun to true. */
2255 if (abfd->output_has_begun == false)
2257 if (! ecoff_compute_section_file_positions (abfd))
2261 /* If this is a .lib section, bump the vma address so that it winds
2262 up being the number of .lib sections output. This is right for
2263 Irix 4. Ian Taylor <ian@cygnus.com>. */
2264 if (strcmp (section->name, _LIB) == 0)
2270 if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
2271 || bfd_write (location, 1, count, abfd) != count)
2277 /* Get the GP value for an ECOFF file. This is a hook used by
2281 bfd_ecoff_get_gp_value (abfd)
2284 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2285 || bfd_get_format (abfd) != bfd_object)
2287 bfd_set_error (bfd_error_invalid_operation);
2291 return ecoff_data (abfd)->gp;
2294 /* Set the GP value for an ECOFF file. This is a hook used by the
2298 bfd_ecoff_set_gp_value (abfd, gp_value)
2302 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2303 || bfd_get_format (abfd) != bfd_object)
2305 bfd_set_error (bfd_error_invalid_operation);
2309 ecoff_data (abfd)->gp = gp_value;
2314 /* Set the register masks for an ECOFF file. This is a hook used by
2318 bfd_ecoff_set_regmasks (abfd, gprmask, fprmask, cprmask)
2320 unsigned long gprmask;
2321 unsigned long fprmask;
2322 unsigned long *cprmask;
2324 ecoff_data_type *tdata;
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 tdata = ecoff_data (abfd);
2334 tdata->gprmask = gprmask;
2335 tdata->fprmask = fprmask;
2336 if (cprmask != (unsigned long *) NULL)
2340 for (i = 0; i < 3; i++)
2341 tdata->cprmask[i] = cprmask[i];
2347 /* Get ECOFF EXTR information for an external symbol. This function
2348 is passed to bfd_ecoff_debug_externals. */
2351 ecoff_get_extr (sym, esym)
2355 ecoff_symbol_type *ecoff_sym_ptr;
2358 if (bfd_asymbol_flavour (sym) != bfd_target_ecoff_flavour
2359 || ecoffsymbol (sym)->native == NULL)
2361 /* Don't include debugging, local, or section symbols. */
2362 if ((sym->flags & BSF_DEBUGGING) != 0
2363 || (sym->flags & BSF_LOCAL) != 0
2364 || (sym->flags & BSF_SECTION_SYM) != 0)
2368 esym->cobol_main = 0;
2369 esym->weakext = (sym->flags & BSF_WEAK) != 0;
2372 /* FIXME: we can do better than this for st and sc. */
2373 esym->asym.st = stGlobal;
2374 esym->asym.sc = scAbs;
2375 esym->asym.reserved = 0;
2376 esym->asym.index = indexNil;
2380 ecoff_sym_ptr = ecoffsymbol (sym);
2382 if (ecoff_sym_ptr->local)
2385 input_bfd = bfd_asymbol_bfd (sym);
2386 (*(ecoff_backend (input_bfd)->debug_swap.swap_ext_in))
2387 (input_bfd, ecoff_sym_ptr->native, esym);
2389 /* If the symbol was defined by the linker, then esym will be
2390 undefined but sym will not be. Get a better class for such a
2392 if ((esym->asym.sc == scUndefined
2393 || esym->asym.sc == scSUndefined)
2394 && ! bfd_is_und_section (bfd_get_section (sym)))
2395 esym->asym.sc = scAbs;
2397 /* Adjust the FDR index for the symbol by that used for the input
2399 if (esym->ifd != -1)
2401 struct ecoff_debug_info *input_debug;
2403 input_debug = &ecoff_data (input_bfd)->debug_info;
2404 BFD_ASSERT (esym->ifd < input_debug->symbolic_header.ifdMax);
2405 if (input_debug->ifdmap != (RFDT *) NULL)
2406 esym->ifd = input_debug->ifdmap[esym->ifd];
2412 /* Set the external symbol index. This routine is passed to
2413 bfd_ecoff_debug_externals. */
2416 ecoff_set_index (sym, indx)
2420 ecoff_set_sym_index (sym, indx);
2423 /* Write out an ECOFF file. */
2426 _bfd_ecoff_write_object_contents (abfd)
2429 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
2430 const bfd_vma round = backend->round;
2431 const bfd_size_type filhsz = bfd_coff_filhsz (abfd);
2432 const bfd_size_type aoutsz = bfd_coff_aoutsz (abfd);
2433 const bfd_size_type scnhsz = bfd_coff_scnhsz (abfd);
2434 const bfd_size_type external_hdr_size
2435 = backend->debug_swap.external_hdr_size;
2436 const bfd_size_type external_reloc_size = backend->external_reloc_size;
2437 void (* const adjust_reloc_out) PARAMS ((bfd *,
2439 struct internal_reloc *))
2440 = backend->adjust_reloc_out;
2441 void (* const swap_reloc_out) PARAMS ((bfd *,
2442 const struct internal_reloc *,
2444 = backend->swap_reloc_out;
2445 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
2446 HDRR * const symhdr = &debug->symbolic_header;
2449 bfd_size_type reloc_size;
2450 bfd_size_type text_size;
2452 boolean set_text_start;
2453 bfd_size_type data_size;
2455 boolean set_data_start;
2456 bfd_size_type bss_size;
2458 PTR reloc_buff = NULL;
2459 struct internal_filehdr internal_f;
2460 struct internal_aouthdr internal_a;
2463 /* Determine where the sections and relocs will go in the output
2465 reloc_size = ecoff_compute_reloc_file_positions (abfd);
2468 for (current = abfd->sections;
2469 current != (asection *)NULL;
2470 current = current->next)
2472 current->target_index = count;
2476 if ((abfd->flags & D_PAGED) != 0)
2477 text_size = _bfd_ecoff_sizeof_headers (abfd, false);
2481 set_text_start = false;
2484 set_data_start = false;
2487 /* Write section headers to the file. */
2489 /* Allocate buff big enough to hold a section header,
2490 file header, or a.out header. */
2498 buff = (PTR) malloc ((size_t) siz);
2501 bfd_set_error (bfd_error_no_memory);
2506 internal_f.f_nscns = 0;
2507 if (bfd_seek (abfd, (file_ptr) (filhsz + aoutsz), SEEK_SET) != 0)
2509 for (current = abfd->sections;
2510 current != (asection *) NULL;
2511 current = current->next)
2513 struct internal_scnhdr section;
2516 ++internal_f.f_nscns;
2518 strncpy (section.s_name, current->name, sizeof section.s_name);
2520 /* This seems to be correct for Irix 4 shared libraries. */
2521 vma = bfd_get_section_vma (abfd, current);
2522 if (strcmp (current->name, _LIB) == 0)
2523 section.s_vaddr = 0;
2525 section.s_vaddr = vma;
2527 section.s_paddr = vma;
2528 section.s_size = bfd_get_section_size_before_reloc (current);
2530 /* If this section is unloadable then the scnptr will be 0. */
2531 if ((current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2532 section.s_scnptr = 0;
2534 section.s_scnptr = current->filepos;
2535 section.s_relptr = current->rel_filepos;
2537 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2538 object file produced by the assembler is supposed to point to
2539 information about how much room is required by objects of
2540 various different sizes. I think this only matters if we
2541 want the linker to compute the best size to use, or
2542 something. I don't know what happens if the information is
2544 if (strcmp (current->name, _PDATA) != 0)
2545 section.s_lnnoptr = 0;
2548 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2549 hold the number of entries in the section (each entry is
2550 8 bytes). We stored this in the line_filepos field in
2551 ecoff_compute_section_file_positions. */
2552 section.s_lnnoptr = current->line_filepos;
2555 section.s_nreloc = current->reloc_count;
2556 section.s_nlnno = 0;
2557 section.s_flags = ecoff_sec_to_styp_flags (current->name,
2560 if (bfd_coff_swap_scnhdr_out (abfd, (PTR) §ion, buff) == 0
2561 || bfd_write (buff, 1, scnhsz, abfd) != scnhsz)
2564 if ((section.s_flags & STYP_TEXT) != 0
2565 || ((section.s_flags & STYP_RDATA) != 0
2566 && backend->rdata_in_text)
2567 || section.s_flags == STYP_PDATA
2568 || (section.s_flags & STYP_DYNAMIC) != 0
2569 || (section.s_flags & STYP_LIBLIST) != 0
2570 || (section.s_flags & STYP_RELDYN) != 0
2571 || section.s_flags == STYP_CONFLIC
2572 || (section.s_flags & STYP_DYNSTR) != 0
2573 || (section.s_flags & STYP_DYNSYM) != 0
2574 || (section.s_flags & STYP_HASH) != 0
2575 || (section.s_flags & STYP_ECOFF_INIT) != 0
2576 || (section.s_flags & STYP_ECOFF_FINI) != 0)
2578 text_size += bfd_get_section_size_before_reloc (current);
2579 if (! set_text_start || text_start > vma)
2582 set_text_start = true;
2585 else if ((section.s_flags & STYP_RDATA) != 0
2586 || (section.s_flags & STYP_DATA) != 0
2587 || (section.s_flags & STYP_LITA) != 0
2588 || (section.s_flags & STYP_LIT8) != 0
2589 || (section.s_flags & STYP_LIT4) != 0
2590 || (section.s_flags & STYP_SDATA) != 0
2591 || section.s_flags == STYP_XDATA
2592 || (section.s_flags & STYP_GOT) != 0)
2594 data_size += bfd_get_section_size_before_reloc (current);
2595 if (! set_data_start || data_start > vma)
2598 set_data_start = true;
2601 else if ((section.s_flags & STYP_BSS) != 0
2602 || (section.s_flags & STYP_SBSS) != 0)
2603 bss_size += bfd_get_section_size_before_reloc (current);
2604 else if (section.s_flags == 0
2605 || (section.s_flags & STYP_ECOFF_LIB) != 0
2606 || section.s_flags == STYP_COMMENT)
2612 /* Set up the file header. */
2614 internal_f.f_magic = ecoff_get_magic (abfd);
2616 /* We will NOT put a fucking timestamp in the header here. Every
2617 time you put it back, I will come in and take it out again. I'm
2618 sorry. This field does not belong here. We fill it with a 0 so
2619 it compares the same but is not a reasonable time. --
2621 internal_f.f_timdat = 0;
2623 if (bfd_get_symcount (abfd) != 0)
2625 /* The ECOFF f_nsyms field is not actually the number of
2626 symbols, it's the size of symbolic information header. */
2627 internal_f.f_nsyms = external_hdr_size;
2628 internal_f.f_symptr = ecoff_data (abfd)->sym_filepos;
2632 internal_f.f_nsyms = 0;
2633 internal_f.f_symptr = 0;
2636 internal_f.f_opthdr = aoutsz;
2638 internal_f.f_flags = F_LNNO;
2639 if (reloc_size == 0)
2640 internal_f.f_flags |= F_RELFLG;
2641 if (bfd_get_symcount (abfd) == 0)
2642 internal_f.f_flags |= F_LSYMS;
2643 if (abfd->flags & EXEC_P)
2644 internal_f.f_flags |= F_EXEC;
2646 if (! abfd->xvec->byteorder_big_p)
2647 internal_f.f_flags |= F_AR32WR;
2649 internal_f.f_flags |= F_AR32W;
2651 /* Set up the ``optional'' header. */
2652 if ((abfd->flags & D_PAGED) != 0)
2653 internal_a.magic = ECOFF_AOUT_ZMAGIC;
2655 internal_a.magic = ECOFF_AOUT_OMAGIC;
2657 /* FIXME: Is this really correct? */
2658 internal_a.vstamp = symhdr->vstamp;
2660 /* At least on Ultrix, these have to be rounded to page boundaries.
2661 FIXME: Is this true on other platforms? */
2662 if ((abfd->flags & D_PAGED) != 0)
2664 internal_a.tsize = (text_size + round - 1) &~ (round - 1);
2665 internal_a.text_start = text_start &~ (round - 1);
2666 internal_a.dsize = (data_size + round - 1) &~ (round - 1);
2667 internal_a.data_start = data_start &~ (round - 1);
2671 internal_a.tsize = text_size;
2672 internal_a.text_start = text_start;
2673 internal_a.dsize = data_size;
2674 internal_a.data_start = data_start;
2677 /* On Ultrix, the initial portions of the .sbss and .bss segments
2678 are at the end of the data section. The bsize field in the
2679 optional header records how many bss bytes are required beyond
2680 those in the data section. The value is not rounded to a page
2682 if (bss_size < internal_a.dsize - data_size)
2685 bss_size -= internal_a.dsize - data_size;
2686 internal_a.bsize = bss_size;
2687 internal_a.bss_start = internal_a.data_start + internal_a.dsize;
2689 internal_a.entry = bfd_get_start_address (abfd);
2691 internal_a.gp_value = ecoff_data (abfd)->gp;
2693 internal_a.gprmask = ecoff_data (abfd)->gprmask;
2694 internal_a.fprmask = ecoff_data (abfd)->fprmask;
2695 for (i = 0; i < 4; i++)
2696 internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i];
2698 /* Let the backend adjust the headers if necessary. */
2699 if (backend->adjust_headers)
2701 if (! (*backend->adjust_headers) (abfd, &internal_f, &internal_a))
2705 /* Write out the file header and the optional header. */
2707 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
2710 bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, buff);
2711 if (bfd_write (buff, 1, filhsz, abfd) != filhsz)
2714 bfd_coff_swap_aouthdr_out (abfd, (PTR) &internal_a, buff);
2715 if (bfd_write (buff, 1, aoutsz, abfd) != aoutsz)
2718 /* Build the external symbol information. This must be done before
2719 writing out the relocs so that we know the symbol indices. We
2720 don't do this if this BFD was created by the backend linker,
2721 since it will have already handled the symbols and relocs. */
2722 if (! ecoff_data (abfd)->linker)
2724 symhdr->iextMax = 0;
2725 symhdr->issExtMax = 0;
2726 debug->external_ext = debug->external_ext_end = NULL;
2727 debug->ssext = debug->ssext_end = NULL;
2728 if (bfd_ecoff_debug_externals (abfd, debug, &backend->debug_swap,
2729 (((abfd->flags & EXEC_P) == 0)
2731 ecoff_get_extr, ecoff_set_index)
2735 /* Write out the relocs. */
2736 for (current = abfd->sections;
2737 current != (asection *) NULL;
2738 current = current->next)
2740 arelent **reloc_ptr_ptr;
2741 arelent **reloc_end;
2744 if (current->reloc_count == 0)
2748 bfd_alloc (abfd, current->reloc_count * external_reloc_size);
2749 if (reloc_buff == NULL)
2751 bfd_set_error (bfd_error_no_memory);
2755 reloc_ptr_ptr = current->orelocation;
2756 reloc_end = reloc_ptr_ptr + current->reloc_count;
2757 out_ptr = (char *) reloc_buff;
2759 reloc_ptr_ptr < reloc_end;
2760 reloc_ptr_ptr++, out_ptr += external_reloc_size)
2764 struct internal_reloc in;
2766 memset ((PTR) &in, 0, sizeof in);
2768 reloc = *reloc_ptr_ptr;
2769 sym = *reloc->sym_ptr_ptr;
2771 in.r_vaddr = (reloc->address
2772 + bfd_get_section_vma (abfd, current));
2773 in.r_type = reloc->howto->type;
2775 if ((sym->flags & BSF_SECTION_SYM) == 0)
2777 in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr);
2784 name = bfd_get_section_name (abfd, bfd_get_section (sym));
2785 if (strcmp (name, ".text") == 0)
2786 in.r_symndx = RELOC_SECTION_TEXT;
2787 else if (strcmp (name, ".rdata") == 0)
2788 in.r_symndx = RELOC_SECTION_RDATA;
2789 else if (strcmp (name, ".data") == 0)
2790 in.r_symndx = RELOC_SECTION_DATA;
2791 else if (strcmp (name, ".sdata") == 0)
2792 in.r_symndx = RELOC_SECTION_SDATA;
2793 else if (strcmp (name, ".sbss") == 0)
2794 in.r_symndx = RELOC_SECTION_SBSS;
2795 else if (strcmp (name, ".bss") == 0)
2796 in.r_symndx = RELOC_SECTION_BSS;
2797 else if (strcmp (name, ".init") == 0)
2798 in.r_symndx = RELOC_SECTION_INIT;
2799 else if (strcmp (name, ".lit8") == 0)
2800 in.r_symndx = RELOC_SECTION_LIT8;
2801 else if (strcmp (name, ".lit4") == 0)
2802 in.r_symndx = RELOC_SECTION_LIT4;
2803 else if (strcmp (name, ".xdata") == 0)
2804 in.r_symndx = RELOC_SECTION_XDATA;
2805 else if (strcmp (name, ".pdata") == 0)
2806 in.r_symndx = RELOC_SECTION_PDATA;
2807 else if (strcmp (name, ".fini") == 0)
2808 in.r_symndx = RELOC_SECTION_FINI;
2809 else if (strcmp (name, ".lita") == 0)
2810 in.r_symndx = RELOC_SECTION_LITA;
2811 else if (strcmp (name, "*ABS*") == 0)
2812 in.r_symndx = RELOC_SECTION_ABS;
2818 (*adjust_reloc_out) (abfd, reloc, &in);
2820 (*swap_reloc_out) (abfd, &in, (PTR) out_ptr);
2823 if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0)
2825 if (bfd_write (reloc_buff,
2826 external_reloc_size, current->reloc_count, abfd)
2827 != external_reloc_size * current->reloc_count)
2829 bfd_release (abfd, reloc_buff);
2833 /* Write out the symbolic debugging information. */
2834 if (bfd_get_symcount (abfd) > 0)
2836 /* Write out the debugging information. */
2837 if (bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap,
2838 ecoff_data (abfd)->sym_filepos)
2844 /* The .bss section of a demand paged executable must receive an
2845 entire page. If there are symbols, the symbols will start on the
2846 next page. If there are no symbols, we must fill out the page by
2848 if (bfd_get_symcount (abfd) == 0
2849 && (abfd->flags & EXEC_P) != 0
2850 && (abfd->flags & D_PAGED) != 0)
2854 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2857 if (bfd_read (&c, 1, 1, abfd) == 0)
2859 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2862 if (bfd_write (&c, 1, 1, abfd) != 1)
2866 if (reloc_buff != NULL)
2867 bfd_release (abfd, reloc_buff);
2872 if (reloc_buff != NULL)
2873 bfd_release (abfd, reloc_buff);
2879 /* Archive handling. ECOFF uses what appears to be a unique type of
2880 archive header (armap). The byte ordering of the armap and the
2881 contents are encoded in the name of the armap itself. At least for
2882 now, we only support archives with the same byte ordering in the
2883 armap and the contents.
2885 The first four bytes in the armap are the number of symbol
2886 definitions. This is always a power of two.
2888 This is followed by the symbol definitions. Each symbol definition
2889 occupies 8 bytes. The first four bytes are the offset from the
2890 start of the armap strings to the null-terminated string naming
2891 this symbol. The second four bytes are the file offset to the
2892 archive member which defines this symbol. If the second four bytes
2893 are 0, then this is not actually a symbol definition, and it should
2896 The symbols are hashed into the armap with a closed hashing scheme.
2897 See the functions below for the details of the algorithm.
2899 After the symbol definitions comes four bytes holding the size of
2900 the string table, followed by the string table itself. */
2902 /* The name of an archive headers looks like this:
2903 __________E[BL]E[BL]_ (with a trailing space).
2904 The trailing space is changed to an X if the archive is changed to
2905 indicate that the armap is out of date.
2907 The Alpha seems to use ________64E[BL]E[BL]_. */
2909 #define ARMAP_BIG_ENDIAN 'B'
2910 #define ARMAP_LITTLE_ENDIAN 'L'
2911 #define ARMAP_MARKER 'E'
2912 #define ARMAP_START_LENGTH 10
2913 #define ARMAP_HEADER_MARKER_INDEX 10
2914 #define ARMAP_HEADER_ENDIAN_INDEX 11
2915 #define ARMAP_OBJECT_MARKER_INDEX 12
2916 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2917 #define ARMAP_END_INDEX 14
2918 #define ARMAP_END "_ "
2920 /* This is a magic number used in the hashing algorithm. */
2921 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2923 /* This returns the hash value to use for a string. It also sets
2924 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2925 is the number of entries in the hash table, and HLOG is the log
2929 ecoff_armap_hash (s, rehash, size, hlog)
2931 unsigned int *rehash;
2939 hash = ((hash >> 27) | (hash << 5)) + *s++;
2940 hash *= ARMAP_HASH_MAGIC;
2941 *rehash = (hash & (size - 1)) | 1;
2942 return hash >> (32 - hlog);
2945 /* Read in the armap. */
2948 _bfd_ecoff_slurp_armap (abfd)
2953 struct areltdata *mapdata;
2954 bfd_size_type parsed_size;
2956 struct artdata *ardata;
2959 struct symdef *symdef_ptr;
2962 /* Get the name of the first element. */
2963 i = bfd_read ((PTR) nextname, 1, 16, abfd);
2969 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
2972 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2973 standard COFF armap. We could move the ECOFF armap stuff into
2974 bfd_slurp_armap, but that seems inappropriate since no other
2975 target uses this format. Instead, we check directly for a COFF
2977 if (strncmp (nextname, "/ ", 16) == 0)
2978 return bfd_slurp_armap (abfd);
2980 /* See if the first element is an armap. */
2981 if (strncmp (nextname, ecoff_backend (abfd)->armap_start,
2982 ARMAP_START_LENGTH) != 0
2983 || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER
2984 || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2985 && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2986 || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER
2987 || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2988 && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2989 || strncmp (nextname + ARMAP_END_INDEX,
2990 ARMAP_END, sizeof ARMAP_END - 1) != 0)
2992 bfd_has_map (abfd) = false;
2996 /* Make sure we have the right byte ordering. */
2997 if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2998 ^ (abfd->xvec->header_byteorder_big_p != false))
2999 || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
3000 ^ (abfd->xvec->byteorder_big_p != false)))
3002 bfd_set_error (bfd_error_wrong_format);
3006 /* Read in the armap. */
3007 ardata = bfd_ardata (abfd);
3008 mapdata = _bfd_read_ar_hdr (abfd);
3009 if (mapdata == (struct areltdata *) NULL)
3011 parsed_size = mapdata->parsed_size;
3012 bfd_release (abfd, (PTR) mapdata);
3014 raw_armap = (char *) bfd_alloc (abfd, parsed_size);
3015 if (raw_armap == (char *) NULL)
3017 bfd_set_error (bfd_error_no_memory);
3021 if (bfd_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size)
3023 if (bfd_get_error () != bfd_error_system_call)
3024 bfd_set_error (bfd_error_malformed_archive);
3025 bfd_release (abfd, (PTR) raw_armap);
3029 ardata->tdata = (PTR) raw_armap;
3031 count = bfd_h_get_32 (abfd, (PTR) raw_armap);
3033 ardata->symdef_count = 0;
3034 ardata->cache = (struct ar_cache *) NULL;
3036 /* This code used to overlay the symdefs over the raw archive data,
3037 but that doesn't work on a 64 bit host. */
3039 stringbase = raw_armap + count * 8 + 8;
3041 #ifdef CHECK_ARMAP_HASH
3045 /* Double check that I have the hashing algorithm right by making
3046 sure that every symbol can be looked up successfully. */
3048 for (i = 1; i < count; i <<= 1)
3050 BFD_ASSERT (i == count);
3052 raw_ptr = raw_armap + 4;
3053 for (i = 0; i < count; i++, raw_ptr += 8)
3055 unsigned int name_offset, file_offset;
3056 unsigned int hash, rehash, srch;
3058 name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
3059 file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4));
3060 if (file_offset == 0)
3062 hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count,
3067 /* See if we can rehash to this location. */
3068 for (srch = (hash + rehash) & (count - 1);
3069 srch != hash && srch != i;
3070 srch = (srch + rehash) & (count - 1))
3071 BFD_ASSERT (bfd_h_get_32 (abfd, (PTR) (raw_armap + 8 + srch * 8))
3073 BFD_ASSERT (srch == i);
3077 #endif /* CHECK_ARMAP_HASH */
3079 raw_ptr = raw_armap + 4;
3080 for (i = 0; i < count; i++, raw_ptr += 8)
3081 if (bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4)) != 0)
3082 ++ardata->symdef_count;
3084 symdef_ptr = ((struct symdef *)
3086 ardata->symdef_count * sizeof (struct symdef)));
3089 bfd_set_error (bfd_error_no_memory);
3093 ardata->symdefs = (carsym *) symdef_ptr;
3095 raw_ptr = raw_armap + 4;
3096 for (i = 0; i < count; i++, raw_ptr += 8)
3098 unsigned int name_offset, file_offset;
3100 file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4));
3101 if (file_offset == 0)
3103 name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
3104 symdef_ptr->s.name = stringbase + name_offset;
3105 symdef_ptr->file_offset = file_offset;
3109 ardata->first_file_filepos = bfd_tell (abfd);
3110 /* Pad to an even boundary. */
3111 ardata->first_file_filepos += ardata->first_file_filepos % 2;
3113 bfd_has_map (abfd) = true;
3118 /* Write out an armap. */
3121 _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx)
3123 unsigned int elength;
3125 unsigned int orl_count;
3128 unsigned int hashsize, hashlog;
3129 unsigned int symdefsize;
3131 unsigned int stringsize;
3132 unsigned int mapsize;
3135 struct stat statbuf;
3138 bfd_byte *hashtable;
3142 /* Ultrix appears to use as a hash table size the least power of two
3143 greater than twice the number of entries. */
3144 for (hashlog = 0; (1 << hashlog) <= 2 * orl_count; hashlog++)
3146 hashsize = 1 << hashlog;
3148 symdefsize = hashsize * 8;
3150 stringsize = stridx + padit;
3152 /* Include 8 bytes to store symdefsize and stringsize in output. */
3153 mapsize = symdefsize + stringsize + 8;
3155 firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength;
3157 memset ((PTR) &hdr, 0, sizeof hdr);
3159 /* Work out the ECOFF armap name. */
3160 strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start);
3161 hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER;
3162 hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] =
3163 (abfd->xvec->header_byteorder_big_p
3165 : ARMAP_LITTLE_ENDIAN);
3166 hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER;
3167 hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] =
3168 abfd->xvec->byteorder_big_p ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN;
3169 memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1);
3171 /* Write the timestamp of the archive header to be just a little bit
3172 later than the timestamp of the file, otherwise the linker will
3173 complain that the index is out of date. Actually, the Ultrix
3174 linker just checks the archive name; the GNU linker may check the
3176 stat (abfd->filename, &statbuf);
3177 sprintf (hdr.ar_date, "%ld", (long) (statbuf.st_mtime + 60));
3179 /* The DECstation uses zeroes for the uid, gid and mode of the
3181 hdr.ar_uid[0] = '0';
3182 hdr.ar_gid[0] = '0';
3183 hdr.ar_mode[0] = '0';
3185 sprintf (hdr.ar_size, "%-10d", (int) mapsize);
3187 hdr.ar_fmag[0] = '`';
3188 hdr.ar_fmag[1] = '\012';
3190 /* Turn all null bytes in the header into spaces. */
3191 for (i = 0; i < sizeof (struct ar_hdr); i++)
3192 if (((char *)(&hdr))[i] == '\0')
3193 (((char *)(&hdr))[i]) = ' ';
3195 if (bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), abfd)
3196 != sizeof (struct ar_hdr))
3199 bfd_h_put_32 (abfd, (bfd_vma) hashsize, temp);
3200 if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
3203 hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize);
3206 bfd_set_error (bfd_error_no_memory);
3210 current = abfd->archive_head;
3212 for (i = 0; i < orl_count; i++)
3214 unsigned int hash, rehash;
3216 /* Advance firstreal to the file position of this archive
3218 if (((bfd *) map[i].pos) != last_elt)
3222 firstreal += arelt_size (current) + sizeof (struct ar_hdr);
3223 firstreal += firstreal % 2;
3224 current = current->next;
3226 while (current != (bfd *) map[i].pos);
3231 hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog);
3232 if (bfd_h_get_32 (abfd, (PTR) (hashtable + (hash * 8) + 4)) != 0)
3236 /* The desired slot is already taken. */
3237 for (srch = (hash + rehash) & (hashsize - 1);
3239 srch = (srch + rehash) & (hashsize - 1))
3240 if (bfd_h_get_32 (abfd, (PTR) (hashtable + (srch * 8) + 4)) == 0)
3243 BFD_ASSERT (srch != hash);
3248 bfd_h_put_32 (abfd, (bfd_vma) map[i].namidx,
3249 (PTR) (hashtable + hash * 8));
3250 bfd_h_put_32 (abfd, (bfd_vma) firstreal,
3251 (PTR) (hashtable + hash * 8 + 4));
3254 if (bfd_write ((PTR) hashtable, 1, symdefsize, abfd) != symdefsize)
3257 bfd_release (abfd, hashtable);
3259 /* Now write the strings. */
3260 bfd_h_put_32 (abfd, (bfd_vma) stringsize, temp);
3261 if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
3263 for (i = 0; i < orl_count; i++)
3267 len = strlen (*map[i].name) + 1;
3268 if (bfd_write ((PTR) (*map[i].name), 1, len, abfd) != len)
3272 /* The spec sez this should be a newline. But in order to be
3273 bug-compatible for DECstation ar we use a null. */
3276 if (bfd_write ("", 1, 1, abfd) != 1)
3283 /* See whether this BFD is an archive. If it is, read in the armap
3284 and the extended name table. */
3287 _bfd_ecoff_archive_p (abfd)
3290 char armag[SARMAG + 1];
3292 if (bfd_read ((PTR) armag, 1, SARMAG, abfd) != SARMAG
3293 || strncmp (armag, ARMAG, SARMAG) != 0)
3295 if (bfd_get_error () != bfd_error_system_call)
3296 bfd_set_error (bfd_error_wrong_format);
3297 return (const bfd_target *) NULL;
3300 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
3301 involves a cast, we can't do it as the left operand of
3303 abfd->tdata.aout_ar_data =
3304 (struct artdata *) bfd_zalloc (abfd, sizeof (struct artdata));
3306 if (bfd_ardata (abfd) == (struct artdata *) NULL)
3308 bfd_set_error (bfd_error_no_memory);
3309 return (const bfd_target *) NULL;
3312 bfd_ardata (abfd)->first_file_filepos = SARMAG;
3313 bfd_ardata (abfd)->cache = NULL;
3314 bfd_ardata (abfd)->archive_head = NULL;
3315 bfd_ardata (abfd)->symdefs = NULL;
3316 bfd_ardata (abfd)->extended_names = NULL;
3317 bfd_ardata (abfd)->tdata = NULL;
3319 if (_bfd_ecoff_slurp_armap (abfd) == false
3320 || _bfd_ecoff_slurp_extended_name_table (abfd) == false)
3322 bfd_release (abfd, bfd_ardata (abfd));
3323 abfd->tdata.aout_ar_data = (struct artdata *) NULL;
3324 return (const bfd_target *) NULL;
3330 /* ECOFF linker code. */
3332 static struct bfd_hash_entry *ecoff_link_hash_newfunc
3333 PARAMS ((struct bfd_hash_entry *entry,
3334 struct bfd_hash_table *table,
3335 const char *string));
3336 static boolean ecoff_link_add_archive_symbols
3337 PARAMS ((bfd *, struct bfd_link_info *));
3338 static boolean ecoff_link_check_archive_element
3339 PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
3340 static boolean ecoff_link_add_object_symbols
3341 PARAMS ((bfd *, struct bfd_link_info *));
3342 static boolean ecoff_link_add_externals
3343 PARAMS ((bfd *, struct bfd_link_info *, PTR, char *));
3345 /* Routine to create an entry in an ECOFF link hash table. */
3347 static struct bfd_hash_entry *
3348 ecoff_link_hash_newfunc (entry, table, string)
3349 struct bfd_hash_entry *entry;
3350 struct bfd_hash_table *table;
3353 struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry;
3355 /* Allocate the structure if it has not already been allocated by a
3357 if (ret == (struct ecoff_link_hash_entry *) NULL)
3358 ret = ((struct ecoff_link_hash_entry *)
3359 bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry)));
3360 if (ret == (struct ecoff_link_hash_entry *) NULL)
3362 bfd_set_error (bfd_error_no_memory);
3366 /* Call the allocation method of the superclass. */
3367 ret = ((struct ecoff_link_hash_entry *)
3368 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3373 /* Set local fields. */
3379 memset ((PTR) &ret->esym, 0, sizeof ret->esym);
3381 return (struct bfd_hash_entry *) ret;
3384 /* Create an ECOFF link hash table. */
3386 struct bfd_link_hash_table *
3387 _bfd_ecoff_bfd_link_hash_table_create (abfd)
3390 struct ecoff_link_hash_table *ret;
3392 ret = ((struct ecoff_link_hash_table *)
3393 bfd_alloc (abfd, sizeof (struct ecoff_link_hash_table)));
3396 bfd_set_error (bfd_error_no_memory);
3399 if (! _bfd_link_hash_table_init (&ret->root, abfd,
3400 ecoff_link_hash_newfunc))
3403 return (struct bfd_link_hash_table *) NULL;
3408 /* Look up an entry in an ECOFF link hash table. */
3410 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3411 ((struct ecoff_link_hash_entry *) \
3412 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3414 /* Traverse an ECOFF link hash table. */
3416 #define ecoff_link_hash_traverse(table, func, info) \
3417 (bfd_link_hash_traverse \
3419 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
3422 /* Get the ECOFF link hash table from the info structure. This is
3425 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3427 /* Given an ECOFF BFD, add symbols to the global hash table as
3431 _bfd_ecoff_bfd_link_add_symbols (abfd, info)
3433 struct bfd_link_info *info;
3435 switch (bfd_get_format (abfd))
3438 return ecoff_link_add_object_symbols (abfd, info);
3440 return ecoff_link_add_archive_symbols (abfd, info);
3442 bfd_set_error (bfd_error_wrong_format);
3447 /* Add the symbols from an archive file to the global hash table.
3448 This looks through the undefined symbols, looks each one up in the
3449 archive hash table, and adds any associated object file. We do not
3450 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3451 already have a hash table, so there is no reason to construct
3455 ecoff_link_add_archive_symbols (abfd, info)
3457 struct bfd_link_info *info;
3459 const bfd_byte *raw_armap;
3460 struct bfd_link_hash_entry **pundef;
3461 unsigned int armap_count;
3462 unsigned int armap_log;
3464 const bfd_byte *hashtable;
3465 const char *stringbase;
3467 if (! bfd_has_map (abfd))
3469 /* An empty archive is a special case. */
3470 if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
3472 bfd_set_error (bfd_error_no_armap);
3476 /* If we don't have any raw data for this archive, as can happen on
3477 Irix 4.0.5F, we call the generic routine.
3478 FIXME: We should be more clever about this, since someday tdata
3479 may get to something for a generic archive. */
3480 raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata;
3481 if (raw_armap == (bfd_byte *) NULL)
3482 return (_bfd_generic_link_add_archive_symbols
3483 (abfd, info, ecoff_link_check_archive_element));
3485 armap_count = bfd_h_get_32 (abfd, raw_armap);
3488 for (i = 1; i < armap_count; i <<= 1)
3490 BFD_ASSERT (i == armap_count);
3492 hashtable = raw_armap + 4;
3493 stringbase = (const char *) raw_armap + armap_count * 8 + 8;
3495 /* Look through the list of undefined symbols. */
3496 pundef = &info->hash->undefs;
3497 while (*pundef != (struct bfd_link_hash_entry *) NULL)
3499 struct bfd_link_hash_entry *h;
3500 unsigned int hash, rehash;
3501 unsigned int file_offset;
3507 /* When a symbol is defined, it is not necessarily removed from
3509 if (h->type != bfd_link_hash_undefined
3510 && h->type != bfd_link_hash_common)
3512 /* Remove this entry from the list, for general cleanliness
3513 and because we are going to look through the list again
3514 if we search any more libraries. We can't remove the
3515 entry if it is the tail, because that would lose any
3516 entries we add to the list later on. */
3517 if (*pundef != info->hash->undefs_tail)
3518 *pundef = (*pundef)->next;
3520 pundef = &(*pundef)->next;
3524 /* Native ECOFF linkers do not pull in archive elements merely
3525 to satisfy common definitions, so neither do we. We leave
3526 them on the list, though, in case we are linking against some
3527 other object format. */
3528 if (h->type != bfd_link_hash_undefined)
3530 pundef = &(*pundef)->next;
3534 /* Look for this symbol in the archive hash table. */
3535 hash = ecoff_armap_hash (h->root.string, &rehash, armap_count,
3538 file_offset = bfd_h_get_32 (abfd, hashtable + (hash * 8) + 4);
3539 if (file_offset == 0)
3541 /* Nothing in this slot. */
3542 pundef = &(*pundef)->next;
3546 name = stringbase + bfd_h_get_32 (abfd, hashtable + (hash * 8));
3547 if (name[0] != h->root.string[0]
3548 || strcmp (name, h->root.string) != 0)
3553 /* That was the wrong symbol. Try rehashing. */
3555 for (srch = (hash + rehash) & (armap_count - 1);
3557 srch = (srch + rehash) & (armap_count - 1))
3559 file_offset = bfd_h_get_32 (abfd, hashtable + (srch * 8) + 4);
3560 if (file_offset == 0)
3562 name = stringbase + bfd_h_get_32 (abfd, hashtable + (srch * 8));
3563 if (name[0] == h->root.string[0]
3564 && strcmp (name, h->root.string) == 0)
3573 pundef = &(*pundef)->next;
3580 element = _bfd_get_elt_at_filepos (abfd, file_offset);
3581 if (element == (bfd *) NULL)
3584 if (! bfd_check_format (element, bfd_object))
3587 /* Unlike the generic linker, we know that this element provides
3588 a definition for an undefined symbol and we know that we want
3589 to include it. We don't need to check anything. */
3590 if (! (*info->callbacks->add_archive_element) (info, element, name))
3592 if (! ecoff_link_add_object_symbols (element, info))
3595 pundef = &(*pundef)->next;
3601 /* This is called if we used _bfd_generic_link_add_archive_symbols
3602 because we were not dealing with an ECOFF archive. */
3605 ecoff_link_check_archive_element (abfd, info, pneeded)
3607 struct bfd_link_info *info;
3610 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3611 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
3612 = backend->debug_swap.swap_ext_in;
3614 bfd_size_type external_ext_size;
3615 PTR external_ext = NULL;
3623 if (! ecoff_slurp_symbolic_header (abfd))
3626 /* If there are no symbols, we don't want it. */
3627 if (bfd_get_symcount (abfd) == 0)
3628 goto successful_return;
3630 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3632 /* Read in the external symbols and external strings. */
3633 external_ext_size = backend->debug_swap.external_ext_size;
3634 esize = symhdr->iextMax * external_ext_size;
3635 external_ext = (PTR) malloc (esize);
3636 if (external_ext == NULL && esize != 0)
3638 bfd_set_error (bfd_error_no_memory);
3642 if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
3643 || bfd_read (external_ext, 1, esize, abfd) != esize)
3646 ssext = (char *) malloc (symhdr->issExtMax);
3647 if (ssext == NULL && symhdr->issExtMax != 0)
3649 bfd_set_error (bfd_error_no_memory);
3653 if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
3654 || (bfd_read (ssext, 1, symhdr->issExtMax, abfd) !=
3655 (bfd_size_type) symhdr->issExtMax))
3658 /* Look through the external symbols to see if they define some
3659 symbol that is currently undefined. */
3660 ext_ptr = (char *) external_ext;
3661 ext_end = ext_ptr + esize;
3662 for (; ext_ptr < ext_end; ext_ptr += external_ext_size)
3667 struct bfd_link_hash_entry *h;
3669 (*swap_ext_in) (abfd, (PTR) ext_ptr, &esym);
3671 /* See if this symbol defines something. */
3672 if (esym.asym.st != stGlobal
3673 && esym.asym.st != stLabel
3674 && esym.asym.st != stProc)
3677 switch (esym.asym.sc)
3700 name = ssext + esym.asym.iss;
3701 h = bfd_link_hash_lookup (info->hash, name, false, false, true);
3703 /* Unlike the generic linker, we do not pull in elements because
3704 of common symbols. */
3705 if (h == (struct bfd_link_hash_entry *) NULL
3706 || h->type != bfd_link_hash_undefined)
3709 /* Include this element. */
3710 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3712 if (! ecoff_link_add_externals (abfd, info, external_ext, ssext))
3716 goto successful_return;
3720 if (external_ext != NULL)
3721 free (external_ext);
3726 if (external_ext != NULL)
3727 free (external_ext);
3733 /* Add symbols from an ECOFF object file to the global linker hash
3737 ecoff_link_add_object_symbols (abfd, info)
3739 struct bfd_link_info *info;
3742 bfd_size_type external_ext_size;
3743 PTR external_ext = NULL;
3748 if (! ecoff_slurp_symbolic_header (abfd))
3751 /* If there are no symbols, we don't want it. */
3752 if (bfd_get_symcount (abfd) == 0)
3755 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3757 /* Read in the external symbols and external strings. */
3758 external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size;
3759 esize = symhdr->iextMax * external_ext_size;
3760 external_ext = (PTR) malloc (esize);
3761 if (external_ext == NULL && esize != 0)
3763 bfd_set_error (bfd_error_no_memory);
3767 if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
3768 || bfd_read (external_ext, 1, esize, abfd) != esize)
3771 ssext = (char *) malloc (symhdr->issExtMax);
3772 if (ssext == NULL && symhdr->issExtMax != 0)
3774 bfd_set_error (bfd_error_no_memory);
3778 if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
3779 || (bfd_read (ssext, 1, symhdr->issExtMax, abfd)
3780 != (bfd_size_type) symhdr->issExtMax))
3783 result = ecoff_link_add_externals (abfd, info, external_ext, ssext);
3787 if (external_ext != NULL)
3788 free (external_ext);
3794 if (external_ext != NULL)
3795 free (external_ext);
3799 /* Add the external symbols of an object file to the global linker
3800 hash table. The external symbols and strings we are passed are
3801 just allocated on the stack, and will be discarded. We must
3802 explicitly save any information we may need later on in the link.
3803 We do not want to read the external symbol information again. */
3806 ecoff_link_add_externals (abfd, info, external_ext, ssext)
3808 struct bfd_link_info *info;
3812 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3813 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
3814 = backend->debug_swap.swap_ext_in;
3815 bfd_size_type external_ext_size = backend->debug_swap.external_ext_size;
3816 unsigned long ext_count;
3817 struct ecoff_link_hash_entry **sym_hash;
3821 ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
3823 sym_hash = ((struct ecoff_link_hash_entry **)
3825 ext_count * sizeof (struct bfd_link_hash_entry *)));
3828 bfd_set_error (bfd_error_no_memory);
3831 ecoff_data (abfd)->sym_hashes = sym_hash;
3833 ext_ptr = (char *) external_ext;
3834 ext_end = ext_ptr + ext_count * external_ext_size;
3835 for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++)
3842 struct ecoff_link_hash_entry *h;
3846 (*swap_ext_in) (abfd, (PTR) ext_ptr, &esym);
3848 /* Skip debugging symbols. */
3850 switch (esym.asym.st)
3866 /* Get the information for this symbol. */
3867 value = esym.asym.value;
3868 switch (esym.asym.sc)
3888 section = bfd_make_section_old_way (abfd, ".text");
3889 value -= section->vma;
3892 section = bfd_make_section_old_way (abfd, ".data");
3893 value -= section->vma;
3896 section = bfd_make_section_old_way (abfd, ".bss");
3897 value -= section->vma;
3900 section = bfd_abs_section_ptr;
3903 section = bfd_und_section_ptr;
3906 section = bfd_make_section_old_way (abfd, ".sdata");
3907 value -= section->vma;
3910 section = bfd_make_section_old_way (abfd, ".sbss");
3911 value -= section->vma;
3914 section = bfd_make_section_old_way (abfd, ".rdata");
3915 value -= section->vma;
3918 if (value > ecoff_data (abfd)->gp_size)
3920 section = bfd_com_section_ptr;
3925 if (ecoff_scom_section.name == NULL)
3927 /* Initialize the small common section. */
3928 ecoff_scom_section.name = SCOMMON;
3929 ecoff_scom_section.flags = SEC_IS_COMMON;
3930 ecoff_scom_section.output_section = &ecoff_scom_section;
3931 ecoff_scom_section.symbol = &ecoff_scom_symbol;
3932 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
3933 ecoff_scom_symbol.name = SCOMMON;
3934 ecoff_scom_symbol.flags = BSF_SECTION_SYM;
3935 ecoff_scom_symbol.section = &ecoff_scom_section;
3936 ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
3938 section = &ecoff_scom_section;
3941 section = bfd_und_section_ptr;
3944 section = bfd_make_section_old_way (abfd, ".init");
3945 value -= section->vma;
3948 section = bfd_make_section_old_way (abfd, ".fini");
3949 value -= section->vma;
3953 if (section == (asection *) NULL)
3956 name = ssext + esym.asym.iss;
3959 if (! (_bfd_generic_link_add_one_symbol
3961 esym.weakext ? BSF_WEAK : BSF_GLOBAL,
3962 section, value, (const char *) NULL, true, true,
3963 (struct bfd_link_hash_entry **) &h)))
3968 /* If we are building an ECOFF hash table, save the external
3969 symbol information. */
3970 if (info->hash->creator->flavour == bfd_get_flavour (abfd))
3972 if (h->abfd == (bfd *) NULL
3973 || (! bfd_is_und_section (section)
3974 && (! bfd_is_com_section (section)
3975 || (h->root.type != bfd_link_hash_defined
3976 && h->root.type != bfd_link_hash_defweak))))
3982 /* Remember whether this symbol was small undefined. */
3983 if (esym.asym.sc == scSUndefined)
3986 /* If this symbol was ever small undefined, it needs to wind
3987 up in a GP relative section. We can't control the
3988 section of a defined symbol, but we can control the
3989 section of a common symbol. This case is actually needed
3990 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3992 && h->root.type == bfd_link_hash_common
3993 && strcmp (h->root.u.c.p->section->name, SCOMMON) != 0)
3995 h->root.u.c.p->section = bfd_make_section_old_way (abfd,
3997 h->root.u.c.p->section->flags = SEC_ALLOC;
3998 if (h->esym.asym.sc == scCommon)
3999 h->esym.asym.sc = scSCommon;
4007 /* ECOFF final link routines. */
4009 static boolean ecoff_final_link_debug_accumulate
4010 PARAMS ((bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *,
4012 static boolean ecoff_link_write_external
4013 PARAMS ((struct ecoff_link_hash_entry *, PTR));
4014 static boolean ecoff_indirect_link_order
4015 PARAMS ((bfd *, struct bfd_link_info *, asection *,
4016 struct bfd_link_order *));
4017 static boolean ecoff_reloc_link_order
4018 PARAMS ((bfd *, struct bfd_link_info *, asection *,
4019 struct bfd_link_order *));
4021 /* ECOFF final link routine. This looks through all the input BFDs
4022 and gathers together all the debugging information, and then
4023 processes all the link order information. This may cause it to
4024 close and reopen some input BFDs; I'll see how bad this is. */
4027 _bfd_ecoff_bfd_final_link (abfd, info)
4029 struct bfd_link_info *info;
4031 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
4032 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
4035 register bfd *input_bfd;
4037 struct bfd_link_order *p;
4039 /* We accumulate the debugging information counts in the symbolic
4041 symhdr = &debug->symbolic_header;
4043 symhdr->ilineMax = 0;
4047 symhdr->isymMax = 0;
4048 symhdr->ioptMax = 0;
4049 symhdr->iauxMax = 0;
4051 symhdr->issExtMax = 0;
4054 symhdr->iextMax = 0;
4056 /* We accumulate the debugging information itself in the debug_info
4059 debug->external_dnr = NULL;
4060 debug->external_pdr = NULL;
4061 debug->external_sym = NULL;
4062 debug->external_opt = NULL;
4063 debug->external_aux = NULL;
4065 debug->ssext = debug->ssext_end = NULL;
4066 debug->external_fdr = NULL;
4067 debug->external_rfd = NULL;
4068 debug->external_ext = debug->external_ext_end = NULL;
4070 handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info);
4071 if (handle == (PTR) NULL)
4074 /* Accumulate the debugging symbols from each input BFD. */
4075 for (input_bfd = info->input_bfds;
4076 input_bfd != (bfd *) NULL;
4077 input_bfd = input_bfd->link_next)
4081 if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour)
4083 /* Abitrarily set the symbolic header vstamp to the vstamp
4084 of the first object file in the link. */
4085 if (symhdr->vstamp == 0)
4087 = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp;
4088 ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info,
4092 ret = bfd_ecoff_debug_accumulate_other (handle, abfd,
4093 debug, &backend->debug_swap,
4098 /* Combine the register masks. */
4099 ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask;
4100 ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask;
4101 ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0];
4102 ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1];
4103 ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2];
4104 ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3];
4107 /* Write out the external symbols. */
4108 ecoff_link_hash_traverse (ecoff_hash_table (info),
4109 ecoff_link_write_external,
4112 if (info->relocateable)
4114 /* We need to make a pass over the link_orders to count up the
4115 number of relocations we will need to output, so that we know
4116 how much space they will take up. */
4117 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4120 for (p = o->link_order_head;
4121 p != (struct bfd_link_order *) NULL;
4123 if (p->type == bfd_indirect_link_order)
4124 o->reloc_count += p->u.indirect.section->reloc_count;
4125 else if (p->type == bfd_section_reloc_link_order
4126 || p->type == bfd_symbol_reloc_link_order)
4131 /* Compute the reloc and symbol file positions. */
4132 ecoff_compute_reloc_file_positions (abfd);
4134 /* Write out the debugging information. */
4135 if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug,
4136 &backend->debug_swap, info,
4137 ecoff_data (abfd)->sym_filepos))
4140 bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info);
4142 if (info->relocateable)
4144 /* Now reset the reloc_count field of the sections in the output
4145 BFD to 0, so that we can use them to keep track of how many
4146 relocs we have output thus far. */
4147 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4151 /* Get a value for the GP register. */
4152 if (ecoff_data (abfd)->gp == 0)
4154 struct bfd_link_hash_entry *h;
4156 h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
4157 if (h != (struct bfd_link_hash_entry *) NULL
4158 && h->type == bfd_link_hash_defined)
4159 ecoff_data (abfd)->gp = (h->u.def.value
4160 + h->u.def.section->output_section->vma
4161 + h->u.def.section->output_offset);
4162 else if (info->relocateable)
4166 /* Make up a value. */
4168 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4171 && (strcmp (o->name, _SBSS) == 0
4172 || strcmp (o->name, _SDATA) == 0
4173 || strcmp (o->name, _LIT4) == 0
4174 || strcmp (o->name, _LIT8) == 0
4175 || strcmp (o->name, _LITA) == 0))
4178 ecoff_data (abfd)->gp = lo + 0x8000;
4182 /* If the relocate_section function needs to do a reloc
4183 involving the GP value, it should make a reloc_dangerous
4184 callback to warn that GP is not defined. */
4188 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4190 for (p = o->link_order_head;
4191 p != (struct bfd_link_order *) NULL;
4194 if (p->type == bfd_indirect_link_order
4195 && (bfd_get_flavour (p->u.indirect.section->owner)
4196 == bfd_target_ecoff_flavour))
4198 if (! ecoff_indirect_link_order (abfd, info, o, p))
4201 else if (p->type == bfd_section_reloc_link_order
4202 || p->type == bfd_symbol_reloc_link_order)
4204 if (! ecoff_reloc_link_order (abfd, info, o, p))
4209 if (! _bfd_default_link_order (abfd, info, o, p))
4215 bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax;
4217 ecoff_data (abfd)->linker = true;
4222 /* Accumulate the debugging information for an input BFD into the
4223 output BFD. This must read in the symbolic information of the
4227 ecoff_final_link_debug_accumulate (output_bfd, input_bfd, info, handle)
4230 struct bfd_link_info *info;
4233 struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info;
4234 const struct ecoff_debug_swap * const swap =
4235 &ecoff_backend (input_bfd)->debug_swap;
4236 HDRR *symhdr = &debug->symbolic_header;
4239 #define READ(ptr, offset, count, size, type) \
4240 if (symhdr->count == 0) \
4241 debug->ptr = NULL; \
4244 debug->ptr = (type) malloc ((size_t) (size * symhdr->count)); \
4245 if (debug->ptr == NULL) \
4247 bfd_set_error (bfd_error_no_memory); \
4249 goto return_something; \
4251 if ((bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) \
4253 || (bfd_read (debug->ptr, size, symhdr->count, \
4254 input_bfd) != size * symhdr->count)) \
4257 goto return_something; \
4261 /* If raw_syments is not NULL, then the data was already by read by
4262 _bfd_ecoff_slurp_symbolic_info. */
4263 if (ecoff_data (input_bfd)->raw_syments == NULL)
4265 READ (line, cbLineOffset, cbLine, sizeof (unsigned char),
4267 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
4268 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
4269 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
4270 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
4271 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
4273 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
4274 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
4275 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
4279 /* We do not read the external strings or the external symbols. */
4281 ret = (bfd_ecoff_debug_accumulate
4282 (handle, output_bfd, &ecoff_data (output_bfd)->debug_info,
4283 &ecoff_backend (output_bfd)->debug_swap,
4284 input_bfd, debug, swap, info));
4287 if (ecoff_data (input_bfd)->raw_syments == NULL)
4289 if (debug->line != NULL)
4291 if (debug->external_dnr != NULL)
4292 free (debug->external_dnr);
4293 if (debug->external_pdr != NULL)
4294 free (debug->external_pdr);
4295 if (debug->external_sym != NULL)
4296 free (debug->external_sym);
4297 if (debug->external_opt != NULL)
4298 free (debug->external_opt);
4299 if (debug->external_aux != NULL)
4300 free (debug->external_aux);
4301 if (debug->ss != NULL)
4303 if (debug->external_fdr != NULL)
4304 free (debug->external_fdr);
4305 if (debug->external_rfd != NULL)
4306 free (debug->external_rfd);
4308 /* Make sure we don't accidentally follow one of these pointers
4309 into freed memory. */
4311 debug->external_dnr = NULL;
4312 debug->external_pdr = NULL;
4313 debug->external_sym = NULL;
4314 debug->external_opt = NULL;
4315 debug->external_aux = NULL;
4317 debug->external_fdr = NULL;
4318 debug->external_rfd = NULL;
4324 /* Put out information for an external symbol. These come only from
4328 ecoff_link_write_external (h, data)
4329 struct ecoff_link_hash_entry *h;
4332 bfd *output_bfd = (bfd *) data;
4334 /* FIXME: We should check if this symbol is being stripped. */
4339 if (h->abfd == (bfd *) NULL)
4342 h->esym.cobol_main = 0;
4343 h->esym.weakext = 0;
4344 h->esym.reserved = 0;
4345 h->esym.ifd = ifdNil;
4346 h->esym.asym.value = 0;
4347 h->esym.asym.st = stGlobal;
4349 if (h->root.type != bfd_link_hash_defined
4350 && h->root.type != bfd_link_hash_defweak)
4351 h->esym.asym.sc = scAbs;
4354 asection *output_section;
4357 output_section = h->root.u.def.section->output_section;
4358 name = bfd_section_name (output_section->owner, output_section);
4360 if (strcmp (name, _TEXT) == 0)
4361 h->esym.asym.sc = scText;
4362 else if (strcmp (name, _DATA) == 0)
4363 h->esym.asym.sc = scData;
4364 else if (strcmp (name, _SDATA) == 0)
4365 h->esym.asym.sc = scSData;
4366 else if (strcmp (name, _RDATA) == 0)
4367 h->esym.asym.sc = scRData;
4368 else if (strcmp (name, _BSS) == 0)
4369 h->esym.asym.sc = scBss;
4370 else if (strcmp (name, _SBSS) == 0)
4371 h->esym.asym.sc = scSBss;
4372 else if (strcmp (name, _INIT) == 0)
4373 h->esym.asym.sc = scInit;
4374 else if (strcmp (name, _FINI) == 0)
4375 h->esym.asym.sc = scFini;
4376 else if (strcmp (name, _PDATA) == 0)
4377 h->esym.asym.sc = scPData;
4378 else if (strcmp (name, _XDATA) == 0)
4379 h->esym.asym.sc = scXData;
4381 h->esym.asym.sc = scAbs;
4384 h->esym.asym.reserved = 0;
4385 h->esym.asym.index = indexNil;
4387 else if (h->esym.ifd != -1)
4389 struct ecoff_debug_info *debug;
4391 /* Adjust the FDR index for the symbol by that used for the
4393 debug = &ecoff_data (h->abfd)->debug_info;
4394 BFD_ASSERT (h->esym.ifd >= 0
4395 && h->esym.ifd < debug->symbolic_header.ifdMax);
4396 h->esym.ifd = debug->ifdmap[h->esym.ifd];
4399 switch (h->root.type)
4402 case bfd_link_hash_new:
4404 case bfd_link_hash_undefined:
4405 case bfd_link_hash_undefweak:
4406 if (h->esym.asym.sc != scUndefined
4407 && h->esym.asym.sc != scSUndefined)
4408 h->esym.asym.sc = scUndefined;
4410 case bfd_link_hash_defined:
4411 case bfd_link_hash_defweak:
4412 if (h->esym.asym.sc == scUndefined
4413 || h->esym.asym.sc == scSUndefined)
4414 h->esym.asym.sc = scAbs;
4415 else if (h->esym.asym.sc == scCommon)
4416 h->esym.asym.sc = scBss;
4417 else if (h->esym.asym.sc == scSCommon)
4418 h->esym.asym.sc = scSBss;
4419 h->esym.asym.value = (h->root.u.def.value
4420 + h->root.u.def.section->output_section->vma
4421 + h->root.u.def.section->output_offset);
4423 case bfd_link_hash_common:
4424 if (h->esym.asym.sc != scCommon
4425 && h->esym.asym.sc != scSCommon)
4426 h->esym.asym.sc = scCommon;
4427 h->esym.asym.value = h->root.u.c.size;
4429 case bfd_link_hash_indirect:
4430 case bfd_link_hash_warning:
4431 /* FIXME: Ignore these for now. The circumstances under which
4432 they should be written out are not clear to me. */
4436 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4438 h->indx = ecoff_data (output_bfd)->debug_info.symbolic_header.iextMax;
4441 return (bfd_ecoff_debug_one_external
4442 (output_bfd, &ecoff_data (output_bfd)->debug_info,
4443 &ecoff_backend (output_bfd)->debug_swap, h->root.root.string,
4447 /* Relocate and write an ECOFF section into an ECOFF output file. */
4450 ecoff_indirect_link_order (output_bfd, info, output_section, link_order)
4452 struct bfd_link_info *info;
4453 asection *output_section;
4454 struct bfd_link_order *link_order;
4456 asection *input_section;
4458 struct ecoff_section_tdata *section_tdata;
4459 bfd_size_type raw_size;
4460 bfd_size_type cooked_size;
4461 bfd_byte *contents = NULL;
4462 bfd_size_type external_reloc_size;
4463 bfd_size_type external_relocs_size;
4464 PTR external_relocs = NULL;
4466 BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
4468 if (link_order->size == 0)
4471 input_section = link_order->u.indirect.section;
4472 input_bfd = input_section->owner;
4473 section_tdata = ecoff_section_data (input_bfd, input_section);
4475 raw_size = input_section->_raw_size;
4476 cooked_size = input_section->_cooked_size;
4477 if (cooked_size == 0)
4478 cooked_size = raw_size;
4480 BFD_ASSERT (input_section->output_section == output_section);
4481 BFD_ASSERT (input_section->output_offset == link_order->offset);
4482 BFD_ASSERT (cooked_size == link_order->size);
4484 /* Get the section contents. We allocate memory for the larger of
4485 the size before relocating and the size after relocating. */
4486 contents = (bfd_byte *) malloc (raw_size >= cooked_size
4488 : (size_t) cooked_size);
4489 if (contents == NULL && raw_size != 0)
4491 bfd_set_error (bfd_error_no_memory);
4495 /* If we are relaxing, the contents may have already been read into
4496 memory, in which case we copy them into our new buffer. We don't
4497 simply reuse the old buffer in case cooked_size > raw_size. */
4498 if (section_tdata != (struct ecoff_section_tdata *) NULL
4499 && section_tdata->contents != (bfd_byte *) NULL)
4500 memcpy (contents, section_tdata->contents, (size_t) raw_size);
4503 if (! bfd_get_section_contents (input_bfd, input_section,
4505 (file_ptr) 0, raw_size))
4509 /* Get the relocs. If we are relaxing MIPS code, they will already
4510 have been read in. Otherwise, we read them in now. */
4511 external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size;
4512 external_relocs_size = external_reloc_size * input_section->reloc_count;
4514 if (section_tdata != (struct ecoff_section_tdata *) NULL
4515 && section_tdata->external_relocs != NULL)
4516 external_relocs = section_tdata->external_relocs;
4519 external_relocs = (PTR) malloc ((size_t) external_relocs_size);
4520 if (external_relocs == NULL && external_relocs_size != 0)
4522 bfd_set_error (bfd_error_no_memory);
4526 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4527 || (bfd_read (external_relocs, 1, external_relocs_size, input_bfd)
4528 != external_relocs_size))
4532 /* Relocate the section contents. */
4533 if (! ((*ecoff_backend (input_bfd)->relocate_section)
4534 (output_bfd, info, input_bfd, input_section, contents,
4538 /* Write out the relocated section. */
4539 if (! bfd_set_section_contents (output_bfd,
4542 input_section->output_offset,
4546 /* If we are producing relocateable output, the relocs were
4547 modified, and we write them out now. We use the reloc_count
4548 field of output_section to keep track of the number of relocs we
4549 have output so far. */
4550 if (info->relocateable)
4552 if (bfd_seek (output_bfd,
4553 (output_section->rel_filepos +
4554 output_section->reloc_count * external_reloc_size),
4556 || (bfd_write (external_relocs, 1, external_relocs_size, output_bfd)
4557 != external_relocs_size))
4559 output_section->reloc_count += input_section->reloc_count;
4562 if (contents != NULL)
4564 if (external_relocs != NULL && section_tdata == NULL)
4565 free (external_relocs);
4569 if (contents != NULL)
4571 if (external_relocs != NULL && section_tdata == NULL)
4572 free (external_relocs);
4576 /* Generate a reloc when linking an ECOFF file. This is a reloc
4577 requested by the linker, and does come from any input file. This
4578 is used to build constructor and destructor tables when linking
4582 ecoff_reloc_link_order (output_bfd, info, output_section, link_order)
4584 struct bfd_link_info *info;
4585 asection *output_section;
4586 struct bfd_link_order *link_order;
4589 struct internal_reloc in;
4590 bfd_size_type external_reloc_size;
4594 /* We set up an arelent to pass to the backend adjust_reloc_out
4596 rel.address = link_order->offset;
4598 rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
4601 bfd_set_error (bfd_error_bad_value);
4605 if (link_order->type == bfd_section_reloc_link_order)
4606 rel.sym_ptr_ptr = link_order->u.reloc.p->u.section->symbol_ptr_ptr;
4609 /* We can't set up a reloc against a symbol correctly, because
4610 we have no asymbol structure. Currently no adjust_reloc_out
4612 rel.sym_ptr_ptr = (asymbol **) NULL;
4615 /* All ECOFF relocs are in-place. Put the addend into the object
4618 BFD_ASSERT (rel.howto->partial_inplace);
4619 if (link_order->u.reloc.p->addend != 0)
4622 bfd_reloc_status_type rstat;
4626 size = bfd_get_reloc_size (rel.howto);
4627 buf = (bfd_byte *) bfd_zmalloc (size);
4628 if (buf == (bfd_byte *) NULL)
4630 bfd_set_error (bfd_error_no_memory);
4633 rstat = _bfd_relocate_contents (rel.howto, output_bfd,
4634 link_order->u.reloc.p->addend, buf);
4640 case bfd_reloc_outofrange:
4642 case bfd_reloc_overflow:
4643 if (! ((*info->callbacks->reloc_overflow)
4645 (link_order->type == bfd_section_reloc_link_order
4646 ? bfd_section_name (output_bfd,
4647 link_order->u.reloc.p->u.section)
4648 : link_order->u.reloc.p->u.name),
4649 rel.howto->name, link_order->u.reloc.p->addend,
4650 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
4657 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
4658 (file_ptr) link_order->offset, size);
4666 /* Move the information into a internal_reloc structure. */
4667 in.r_vaddr = (rel.address
4668 + bfd_get_section_vma (output_bfd, output_section));
4669 in.r_type = rel.howto->type;
4671 if (link_order->type == bfd_symbol_reloc_link_order)
4673 struct ecoff_link_hash_entry *h;
4675 h = ecoff_link_hash_lookup (ecoff_hash_table (info),
4676 link_order->u.reloc.p->u.name,
4677 false, false, true);
4678 if (h != (struct ecoff_link_hash_entry *) NULL
4680 in.r_symndx = h->indx;
4683 if (! ((*info->callbacks->unattached_reloc)
4684 (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
4685 (asection *) NULL, (bfd_vma) 0)))
4695 name = bfd_get_section_name (output_bfd,
4696 link_order->u.reloc.p->u.section);
4697 if (strcmp (name, ".text") == 0)
4698 in.r_symndx = RELOC_SECTION_TEXT;
4699 else if (strcmp (name, ".rdata") == 0)
4700 in.r_symndx = RELOC_SECTION_RDATA;
4701 else if (strcmp (name, ".data") == 0)
4702 in.r_symndx = RELOC_SECTION_DATA;
4703 else if (strcmp (name, ".sdata") == 0)
4704 in.r_symndx = RELOC_SECTION_SDATA;
4705 else if (strcmp (name, ".sbss") == 0)
4706 in.r_symndx = RELOC_SECTION_SBSS;
4707 else if (strcmp (name, ".bss") == 0)
4708 in.r_symndx = RELOC_SECTION_BSS;
4709 else if (strcmp (name, ".init") == 0)
4710 in.r_symndx = RELOC_SECTION_INIT;
4711 else if (strcmp (name, ".lit8") == 0)
4712 in.r_symndx = RELOC_SECTION_LIT8;
4713 else if (strcmp (name, ".lit4") == 0)
4714 in.r_symndx = RELOC_SECTION_LIT4;
4715 else if (strcmp (name, ".xdata") == 0)
4716 in.r_symndx = RELOC_SECTION_XDATA;
4717 else if (strcmp (name, ".pdata") == 0)
4718 in.r_symndx = RELOC_SECTION_PDATA;
4719 else if (strcmp (name, ".fini") == 0)
4720 in.r_symndx = RELOC_SECTION_FINI;
4721 else if (strcmp (name, ".lita") == 0)
4722 in.r_symndx = RELOC_SECTION_LITA;
4723 else if (strcmp (name, "*ABS*") == 0)
4724 in.r_symndx = RELOC_SECTION_ABS;
4730 /* Let the BFD backend adjust the reloc. */
4731 (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in);
4733 /* Get some memory and swap out the reloc. */
4734 external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
4735 rbuf = (bfd_byte *) malloc ((size_t) external_reloc_size);
4736 if (rbuf == (bfd_byte *) NULL)
4738 bfd_set_error (bfd_error_no_memory);
4742 (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (PTR) rbuf);
4744 ok = (bfd_seek (output_bfd,
4745 (output_section->rel_filepos +
4746 output_section->reloc_count * external_reloc_size),
4748 && (bfd_write ((PTR) rbuf, 1, external_reloc_size, output_bfd)
4749 == external_reloc_size));
4752 ++output_section->reloc_count;