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,
54 asymbol **indirect_ptr_ptr));
55 static void ecoff_emit_aggregate PARAMS ((bfd *abfd, FDR *fdr,
57 RNDXR *rndx, long isym,
59 static char *ecoff_type_to_string PARAMS ((bfd *abfd, FDR *fdr,
61 static boolean ecoff_slurp_reloc_table PARAMS ((bfd *abfd, asection *section,
63 static void 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 /* This is a hook needed by SCO COFF, but we have nothing to do. */
143 _bfd_ecoff_make_section_hook (abfd, name)
147 return (asection *) NULL;
150 /* Initialize a new section. */
153 _bfd_ecoff_new_section_hook (abfd, section)
157 /* For the .pdata section, which has a special meaning on the Alpha,
158 we set the alignment power to 3. We correct this later in
159 ecoff_compute_section_file_positions. We do this hackery because
160 we need to know the exact unaligned size of the .pdata section in
161 order to set the lnnoptr field correctly. For every other
162 section we use an alignment power of 4; this could be made target
163 dependent by adding a field to ecoff_backend_data, but 4 appears
164 to be correct for both the MIPS and the Alpha. */
165 if (strcmp (section->name, _PDATA) == 0)
166 section->alignment_power = 3;
168 section->alignment_power = 4;
170 if (strcmp (section->name, _TEXT) == 0)
171 section->flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
172 else if (strcmp (section->name, _DATA) == 0
173 || strcmp (section->name, _SDATA) == 0)
174 section->flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
175 else if (strcmp (section->name, _RDATA) == 0
176 || strcmp (section->name, _LIT8) == 0
177 || strcmp (section->name, _LIT4) == 0)
178 section->flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY;
179 else if (strcmp (section->name, _BSS) == 0
180 || strcmp (section->name, _SBSS) == 0)
181 section->flags |= SEC_ALLOC;
182 else if (strcmp (section->name, _LIB) == 0)
184 /* An Irix 4 shared libary. */
185 section->flags |= SEC_COFF_SHARED_LIBRARY;
188 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
189 uncertain about .init on some systems and I don't know how shared
195 /* Determine the machine architecture and type. This is called from
196 the generic COFF routines. It is the inverse of ecoff_get_magic,
197 below. This could be an ECOFF backend routine, with one version
198 for each target, but there aren't all that many ECOFF targets. */
201 _bfd_ecoff_set_arch_mach_hook (abfd, filehdr)
205 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
206 enum bfd_architecture arch;
209 switch (internal_f->f_magic)
212 case MIPS_MAGIC_LITTLE:
214 arch = bfd_arch_mips;
218 case MIPS_MAGIC_LITTLE2:
219 case MIPS_MAGIC_BIG2:
220 /* MIPS ISA level 2: the r6000 */
221 arch = bfd_arch_mips;
225 case MIPS_MAGIC_LITTLE3:
226 case MIPS_MAGIC_BIG3:
227 /* MIPS ISA level 3: the r4000 */
228 arch = bfd_arch_mips;
233 arch = bfd_arch_alpha;
238 arch = bfd_arch_obscure;
243 return bfd_default_set_arch_mach (abfd, arch, mach);
246 /* Get the magic number to use based on the architecture and machine.
247 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
250 ecoff_get_magic (abfd)
255 switch (bfd_get_arch (abfd))
258 switch (bfd_get_mach (abfd))
263 big = MIPS_MAGIC_BIG;
264 little = MIPS_MAGIC_LITTLE;
268 big = MIPS_MAGIC_BIG2;
269 little = MIPS_MAGIC_LITTLE2;
273 big = MIPS_MAGIC_BIG3;
274 little = MIPS_MAGIC_LITTLE3;
278 return abfd->xvec->byteorder_big_p ? big : little;
289 /* Get the section s_flags to use for a section. */
292 ecoff_sec_to_styp_flags (name, flags)
300 if (strcmp (name, _TEXT) == 0)
302 else if (strcmp (name, _DATA) == 0)
304 else if (strcmp (name, _SDATA) == 0)
306 else if (strcmp (name, _RDATA) == 0)
308 else if (strcmp (name, _LITA) == 0)
310 else if (strcmp (name, _LIT8) == 0)
312 else if (strcmp (name, _LIT4) == 0)
314 else if (strcmp (name, _BSS) == 0)
316 else if (strcmp (name, _SBSS) == 0)
318 else if (strcmp (name, _INIT) == 0)
319 styp = STYP_ECOFF_INIT;
320 else if (strcmp (name, _FINI) == 0)
321 styp = STYP_ECOFF_FINI;
322 else if (strcmp (name, _PDATA) == 0)
324 else if (strcmp (name, _XDATA) == 0)
326 else if (strcmp (name, _LIB) == 0)
327 styp = STYP_ECOFF_LIB;
328 else if (flags & SEC_CODE)
330 else if (flags & SEC_DATA)
332 else if (flags & SEC_READONLY)
334 else if (flags & SEC_LOAD)
339 if (flags & SEC_NEVER_LOAD)
345 /* Get the BFD flags to use for a section. */
349 _bfd_ecoff_styp_to_sec_flags (abfd, hdr, name)
354 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
355 long styp_flags = internal_s->s_flags;
356 flagword sec_flags=0;
358 if (styp_flags & STYP_NOLOAD)
359 sec_flags |= SEC_NEVER_LOAD;
361 /* For 386 COFF, at least, an unloadable text or data section is
362 actually a shared library section. */
363 if ((styp_flags & STYP_TEXT)
364 || (styp_flags & STYP_ECOFF_INIT)
365 || (styp_flags & STYP_ECOFF_FINI))
367 if (sec_flags & SEC_NEVER_LOAD)
368 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
370 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
372 else if ((styp_flags & STYP_DATA)
373 || (styp_flags & STYP_RDATA)
374 || (styp_flags & STYP_SDATA)
375 || styp_flags == STYP_PDATA
376 || styp_flags == STYP_XDATA)
378 if (sec_flags & SEC_NEVER_LOAD)
379 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
381 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
382 if ((styp_flags & STYP_RDATA)
383 || styp_flags == STYP_PDATA)
384 sec_flags |= SEC_READONLY;
386 else if ((styp_flags & STYP_BSS)
387 || (styp_flags & STYP_SBSS))
389 sec_flags |= SEC_ALLOC;
391 else if ((styp_flags & STYP_INFO) || styp_flags == STYP_COMMENT)
393 sec_flags |= SEC_NEVER_LOAD;
395 else if ((styp_flags & STYP_LITA)
396 || (styp_flags & STYP_LIT8)
397 || (styp_flags & STYP_LIT4))
399 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY;
401 else if (styp_flags & STYP_ECOFF_LIB)
403 sec_flags |= SEC_COFF_SHARED_LIBRARY;
407 sec_flags |= SEC_ALLOC | SEC_LOAD;
413 /* Read in the symbolic header for an ECOFF object file. */
416 ecoff_slurp_symbolic_header (abfd)
419 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
420 bfd_size_type external_hdr_size;
422 HDRR *internal_symhdr;
424 /* See if we've already read it in. */
425 if (ecoff_data (abfd)->debug_info.symbolic_header.magic ==
426 backend->debug_swap.sym_magic)
429 /* See whether there is a symbolic header. */
430 if (ecoff_data (abfd)->sym_filepos == 0)
432 bfd_get_symcount (abfd) = 0;
436 /* At this point bfd_get_symcount (abfd) holds the number of symbols
437 as read from the file header, but on ECOFF this is always the
438 size of the symbolic information header. It would be cleaner to
439 handle this when we first read the file in coffgen.c. */
440 external_hdr_size = backend->debug_swap.external_hdr_size;
441 if (bfd_get_symcount (abfd) != external_hdr_size)
443 bfd_set_error (bfd_error_bad_value);
447 /* Read the symbolic information header. */
448 raw = (PTR) malloc ((size_t) external_hdr_size);
451 bfd_set_error (bfd_error_no_memory);
455 if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) == -1
456 || (bfd_read (raw, external_hdr_size, 1, abfd)
457 != external_hdr_size))
459 internal_symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
460 (*backend->debug_swap.swap_hdr_in) (abfd, raw, internal_symhdr);
462 if (internal_symhdr->magic != backend->debug_swap.sym_magic)
464 bfd_set_error (bfd_error_bad_value);
468 /* Now we can get the correct number of symbols. */
469 bfd_get_symcount (abfd) = (internal_symhdr->isymMax
470 + internal_symhdr->iextMax);
481 /* Read in and swap the important symbolic information for an ECOFF
482 object file. This is called by gdb via the read_debug_info entry
483 point in the backend structure. */
487 _bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug)
490 struct ecoff_debug_info *debug;
492 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
493 HDRR *internal_symhdr;
494 bfd_size_type raw_base;
495 bfd_size_type raw_size;
497 bfd_size_type external_fdr_size;
501 bfd_size_type raw_end;
502 bfd_size_type cb_end;
504 BFD_ASSERT (debug == &ecoff_data (abfd)->debug_info);
506 /* Check whether we've already gotten it, and whether there's any to
508 if (ecoff_data (abfd)->raw_syments != (PTR) NULL)
510 if (ecoff_data (abfd)->sym_filepos == 0)
512 bfd_get_symcount (abfd) = 0;
516 if (! ecoff_slurp_symbolic_header (abfd))
519 internal_symhdr = &debug->symbolic_header;
521 /* Read all the symbolic information at once. */
522 raw_base = (ecoff_data (abfd)->sym_filepos
523 + backend->debug_swap.external_hdr_size);
525 /* Alpha ecoff makes the determination of raw_size difficult. It has
526 an undocumented debug data section between the symhdr and the first
527 documented section. And the ordering of the sections varies between
528 statically and dynamically linked executables.
529 If bfd supports SEEK_END someday, this code could be simplified. */
533 #define UPDATE_RAW_END(start, count, size) \
534 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
535 if (cb_end > raw_end) \
538 UPDATE_RAW_END (cbLineOffset, cbLine, sizeof (unsigned char));
539 UPDATE_RAW_END (cbDnOffset, idnMax, backend->debug_swap.external_dnr_size);
540 UPDATE_RAW_END (cbPdOffset, ipdMax, backend->debug_swap.external_pdr_size);
541 UPDATE_RAW_END (cbSymOffset, isymMax, backend->debug_swap.external_sym_size);
542 UPDATE_RAW_END (cbOptOffset, ioptMax, backend->debug_swap.external_opt_size);
543 UPDATE_RAW_END (cbAuxOffset, iauxMax, sizeof (union aux_ext));
544 UPDATE_RAW_END (cbSsOffset, issMax, sizeof (char));
545 UPDATE_RAW_END (cbSsExtOffset, issExtMax, sizeof (char));
546 UPDATE_RAW_END (cbFdOffset, ifdMax, backend->debug_swap.external_fdr_size);
547 UPDATE_RAW_END (cbRfdOffset, crfd, backend->debug_swap.external_rfd_size);
548 UPDATE_RAW_END (cbExtOffset, iextMax, backend->debug_swap.external_ext_size);
550 #undef UPDATE_RAW_END
552 raw_size = raw_end - raw_base;
555 ecoff_data (abfd)->sym_filepos = 0;
558 raw = (PTR) bfd_alloc (abfd, raw_size);
561 bfd_set_error (bfd_error_no_memory);
565 (ecoff_data (abfd)->sym_filepos
566 + backend->debug_swap.external_hdr_size),
568 || bfd_read (raw, raw_size, 1, abfd) != raw_size)
570 bfd_release (abfd, raw);
574 ecoff_data (abfd)->raw_syments = raw;
576 /* Get pointers for the numeric offsets in the HDRR structure. */
577 #define FIX(off1, off2, type) \
578 if (internal_symhdr->off1 == 0) \
579 debug->off2 = (type) NULL; \
581 debug->off2 = (type) ((char *) raw \
582 + (internal_symhdr->off1 \
584 FIX (cbLineOffset, line, unsigned char *);
585 FIX (cbDnOffset, external_dnr, PTR);
586 FIX (cbPdOffset, external_pdr, PTR);
587 FIX (cbSymOffset, external_sym, PTR);
588 FIX (cbOptOffset, external_opt, PTR);
589 FIX (cbAuxOffset, external_aux, union aux_ext *);
590 FIX (cbSsOffset, ss, char *);
591 FIX (cbSsExtOffset, ssext, char *);
592 FIX (cbFdOffset, external_fdr, PTR);
593 FIX (cbRfdOffset, external_rfd, PTR);
594 FIX (cbExtOffset, external_ext, PTR);
597 /* I don't want to always swap all the data, because it will just
598 waste time and most programs will never look at it. The only
599 time the linker needs most of the debugging information swapped
600 is when linking big-endian and little-endian MIPS object files
601 together, which is not a common occurrence.
603 We need to look at the fdr to deal with a lot of information in
604 the symbols, so we swap them here. */
605 debug->fdr = (struct fdr *) bfd_alloc (abfd,
606 (internal_symhdr->ifdMax *
607 sizeof (struct fdr)));
608 if (debug->fdr == NULL)
610 bfd_set_error (bfd_error_no_memory);
613 external_fdr_size = backend->debug_swap.external_fdr_size;
614 fdr_ptr = debug->fdr;
615 fraw_src = (char *) debug->external_fdr;
616 fraw_end = fraw_src + internal_symhdr->ifdMax * external_fdr_size;
617 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
618 (*backend->debug_swap.swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
623 /* ECOFF symbol table routines. The ECOFF symbol table is described
624 in gcc/mips-tfile.c. */
626 /* ECOFF uses two common sections. One is the usual one, and the
627 other is for small objects. All the small objects are kept
628 together, and then referenced via the gp pointer, which yields
629 faster assembler code. This is what we use for the small common
631 static asection ecoff_scom_section;
632 static asymbol ecoff_scom_symbol;
633 static asymbol *ecoff_scom_symbol_ptr;
635 /* Create an empty symbol. */
638 _bfd_ecoff_make_empty_symbol (abfd)
641 ecoff_symbol_type *new;
643 new = (ecoff_symbol_type *) bfd_alloc (abfd, sizeof (ecoff_symbol_type));
644 if (new == (ecoff_symbol_type *) NULL)
646 bfd_set_error (bfd_error_no_memory);
647 return (asymbol *) NULL;
649 memset ((PTR) new, 0, sizeof *new);
650 new->symbol.section = (asection *) NULL;
651 new->fdr = (FDR *) NULL;
654 new->symbol.the_bfd = abfd;
658 /* Set the BFD flags and section for an ECOFF symbol. */
661 ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr)
666 asymbol **indirect_ptr_ptr;
668 asym->the_bfd = abfd;
669 asym->value = ecoff_sym->value;
670 asym->section = &bfd_debug_section;
673 /* An indirect symbol requires two consecutive stabs symbols. */
674 if (*indirect_ptr_ptr != (asymbol *) NULL)
676 BFD_ASSERT (ECOFF_IS_STAB (ecoff_sym));
678 /* @@ Stuffing pointers into integers is a no-no.
679 We can usually get away with it if the integer is
680 large enough though. */
681 if (sizeof (asym) > sizeof (bfd_vma))
683 (*indirect_ptr_ptr)->value = (bfd_vma) asym;
685 asym->flags = BSF_DEBUGGING;
686 asym->section = bfd_und_section_ptr;
687 *indirect_ptr_ptr = NULL;
691 if (ECOFF_IS_STAB (ecoff_sym)
692 && (ECOFF_UNMARK_STAB (ecoff_sym->index) | N_EXT) == (N_INDR | N_EXT))
694 asym->flags = BSF_DEBUGGING | BSF_INDIRECT;
695 asym->section = bfd_ind_section_ptr;
696 /* Pass this symbol on to the next call to this function. */
697 *indirect_ptr_ptr = asym;
701 /* Most symbol types are just for debugging. */
702 switch (ecoff_sym->st)
711 if (ECOFF_IS_STAB (ecoff_sym))
713 asym->flags = BSF_DEBUGGING;
718 asym->flags = BSF_DEBUGGING;
723 asym->flags = BSF_EXPORT | BSF_GLOBAL;
726 asym->flags = BSF_LOCAL;
727 /* Normally, a local stProc symbol will have a corresponding
728 external symbol. We mark the local symbol as a debugging
729 symbol, in order to prevent nm from printing both out.
730 Similarly, we mark stLabel and stabs symbols as debugging
731 symbols. In both cases, we do want to set the value
732 correctly based on the symbol class. */
733 if (ecoff_sym->st == stProc
734 || ecoff_sym->st == stLabel
735 || ECOFF_IS_STAB (ecoff_sym))
736 asym->flags |= BSF_DEBUGGING;
738 switch (ecoff_sym->sc)
741 /* Used for compiler generated labels. Leave them in the
742 debugging section, and mark them as local. If BSF_DEBUGGING
743 is set, then nm does not display them for some reason. If no
744 flags are set then the linker whines about them. */
745 asym->flags = BSF_LOCAL;
748 asym->section = bfd_make_section_old_way (abfd, ".text");
749 asym->value -= asym->section->vma;
752 asym->section = bfd_make_section_old_way (abfd, ".data");
753 asym->value -= asym->section->vma;
756 asym->section = bfd_make_section_old_way (abfd, ".bss");
757 asym->value -= asym->section->vma;
760 asym->flags = BSF_DEBUGGING;
763 asym->section = bfd_abs_section_ptr;
766 asym->section = bfd_und_section_ptr;
776 asym->flags = BSF_DEBUGGING;
779 asym->section = bfd_make_section_old_way (abfd, ".sdata");
780 asym->value -= asym->section->vma;
783 asym->section = bfd_make_section_old_way (abfd, ".sbss");
784 asym->value -= asym->section->vma;
787 asym->section = bfd_make_section_old_way (abfd, ".rdata");
788 asym->value -= asym->section->vma;
791 asym->flags = BSF_DEBUGGING;
794 if (asym->value > ecoff_data (abfd)->gp_size)
796 asym->section = bfd_com_section_ptr;
802 if (ecoff_scom_section.name == NULL)
804 /* Initialize the small common section. */
805 ecoff_scom_section.name = SCOMMON;
806 ecoff_scom_section.flags = SEC_IS_COMMON;
807 ecoff_scom_section.output_section = &ecoff_scom_section;
808 ecoff_scom_section.symbol = &ecoff_scom_symbol;
809 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
810 ecoff_scom_symbol.name = SCOMMON;
811 ecoff_scom_symbol.flags = BSF_SECTION_SYM;
812 ecoff_scom_symbol.section = &ecoff_scom_section;
813 ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
815 asym->section = &ecoff_scom_section;
820 asym->flags = BSF_DEBUGGING;
823 asym->section = bfd_und_section_ptr;
828 asym->section = bfd_make_section_old_way (abfd, ".init");
829 asym->value -= asym->section->vma;
834 asym->flags = BSF_DEBUGGING;
837 asym->section = bfd_make_section_old_way (abfd, ".fini");
838 asym->value -= asym->section->vma;
844 /* Look for special constructors symbols and make relocation entries
845 in a special construction section. These are produced by the
846 -fgnu-linker argument to g++. */
847 if (ECOFF_IS_STAB (ecoff_sym))
849 switch (ECOFF_UNMARK_STAB (ecoff_sym->index))
861 arelent_chain *reloc_chain;
862 unsigned int bitsize;
864 /* Get a section with the same name as the symbol (usually
865 __CTOR_LIST__ or __DTOR_LIST__). FIXME: gcc uses the
866 name ___CTOR_LIST (three underscores). We need
867 __CTOR_LIST (two underscores), since ECOFF doesn't use
868 a leading underscore. This should be handled by gcc,
869 but instead we do it here. Actually, this should all
870 be done differently anyhow. */
871 name = bfd_asymbol_name (asym);
872 if (name[0] == '_' && name[1] == '_' && name[2] == '_')
877 section = bfd_get_section_by_name (abfd, name);
878 if (section == (asection *) NULL)
882 copy = (char *) bfd_alloc (abfd, strlen (name) + 1);
885 bfd_set_error (bfd_error_no_memory);
889 section = bfd_make_section (abfd, copy);
892 /* Build a reloc pointing to this constructor. */
894 (arelent_chain *) bfd_alloc (abfd, sizeof (arelent_chain));
897 bfd_set_error (bfd_error_no_memory);
900 reloc_chain->relent.sym_ptr_ptr =
901 bfd_get_section (asym)->symbol_ptr_ptr;
902 reloc_chain->relent.address = section->_raw_size;
903 reloc_chain->relent.addend = asym->value;
904 reloc_chain->relent.howto =
905 ecoff_backend (abfd)->constructor_reloc;
907 /* Set up the constructor section to hold the reloc. */
908 section->flags = SEC_CONSTRUCTOR;
909 ++section->reloc_count;
911 /* Constructor sections must be rounded to a boundary
912 based on the bitsize. These are not real sections--
913 they are handled specially by the linker--so the ECOFF
914 16 byte alignment restriction does not apply. */
915 bitsize = ecoff_backend (abfd)->constructor_bitsize;
916 section->alignment_power = 1;
917 while ((1 << section->alignment_power) < bitsize / 8)
918 ++section->alignment_power;
920 reloc_chain->next = section->constructor_chain;
921 section->constructor_chain = reloc_chain;
922 section->_raw_size += bitsize / 8;
924 /* Mark the symbol as a constructor. */
925 asym->flags |= BSF_CONSTRUCTOR;
933 /* Read an ECOFF symbol table. */
936 _bfd_ecoff_slurp_symbol_table (abfd)
939 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
940 const bfd_size_type external_ext_size
941 = backend->debug_swap.external_ext_size;
942 const bfd_size_type external_sym_size
943 = backend->debug_swap.external_sym_size;
944 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
945 = backend->debug_swap.swap_ext_in;
946 void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *))
947 = backend->debug_swap.swap_sym_in;
948 bfd_size_type internal_size;
949 ecoff_symbol_type *internal;
950 ecoff_symbol_type *internal_ptr;
951 asymbol *indirect_ptr;
957 /* If we've already read in the symbol table, do nothing. */
958 if (ecoff_data (abfd)->canonical_symbols != NULL)
961 /* Get the symbolic information. */
962 if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL,
963 &ecoff_data (abfd)->debug_info))
965 if (bfd_get_symcount (abfd) == 0)
968 internal_size = bfd_get_symcount (abfd) * sizeof (ecoff_symbol_type);
969 internal = (ecoff_symbol_type *) bfd_alloc (abfd, internal_size);
970 if (internal == NULL)
972 bfd_set_error (bfd_error_no_memory);
976 internal_ptr = internal;
978 eraw_src = (char *) ecoff_data (abfd)->debug_info.external_ext;
980 + (ecoff_data (abfd)->debug_info.symbolic_header.iextMax
981 * external_ext_size));
982 for (; eraw_src < eraw_end; eraw_src += external_ext_size, internal_ptr++)
986 (*swap_ext_in) (abfd, (PTR) eraw_src, &internal_esym);
987 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ssext
988 + internal_esym.asym.iss);
989 if (!ecoff_set_symbol_info (abfd, &internal_esym.asym,
990 &internal_ptr->symbol, 1, &indirect_ptr))
992 /* The alpha uses a negative ifd field for section symbols. */
993 if (internal_esym.ifd >= 0)
994 internal_ptr->fdr = (ecoff_data (abfd)->debug_info.fdr
995 + internal_esym.ifd);
997 internal_ptr->fdr = NULL;
998 internal_ptr->local = false;
999 internal_ptr->native = (PTR) eraw_src;
1001 BFD_ASSERT (indirect_ptr == (asymbol *) NULL);
1003 /* The local symbols must be accessed via the fdr's, because the
1004 string and aux indices are relative to the fdr information. */
1005 fdr_ptr = ecoff_data (abfd)->debug_info.fdr;
1006 fdr_end = fdr_ptr + ecoff_data (abfd)->debug_info.symbolic_header.ifdMax;
1007 for (; fdr_ptr < fdr_end; fdr_ptr++)
1012 lraw_src = ((char *) ecoff_data (abfd)->debug_info.external_sym
1013 + fdr_ptr->isymBase * external_sym_size);
1014 lraw_end = lraw_src + fdr_ptr->csym * external_sym_size;
1016 lraw_src < lraw_end;
1017 lraw_src += external_sym_size, internal_ptr++)
1021 (*swap_sym_in) (abfd, (PTR) lraw_src, &internal_sym);
1022 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ss
1024 + internal_sym.iss);
1025 if (!ecoff_set_symbol_info (abfd, &internal_sym,
1026 &internal_ptr->symbol, 0, &indirect_ptr))
1028 internal_ptr->fdr = fdr_ptr;
1029 internal_ptr->local = true;
1030 internal_ptr->native = (PTR) lraw_src;
1033 BFD_ASSERT (indirect_ptr == (asymbol *) NULL);
1035 ecoff_data (abfd)->canonical_symbols = internal;
1040 /* Return the amount of space needed for the canonical symbols. */
1043 _bfd_ecoff_get_symtab_upper_bound (abfd)
1046 if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL,
1047 &ecoff_data (abfd)->debug_info))
1050 if (bfd_get_symcount (abfd) == 0)
1053 return (bfd_get_symcount (abfd) + 1) * (sizeof (ecoff_symbol_type *));
1056 /* Get the canonical symbols. */
1059 _bfd_ecoff_get_symtab (abfd, alocation)
1061 asymbol **alocation;
1063 unsigned int counter = 0;
1064 ecoff_symbol_type *symbase;
1065 ecoff_symbol_type **location = (ecoff_symbol_type **) alocation;
1067 if (_bfd_ecoff_slurp_symbol_table (abfd) == false)
1069 if (bfd_get_symcount (abfd) == 0)
1072 symbase = ecoff_data (abfd)->canonical_symbols;
1073 while (counter < bfd_get_symcount (abfd))
1075 *(location++) = symbase++;
1078 *location++ = (ecoff_symbol_type *) NULL;
1079 return bfd_get_symcount (abfd);
1082 /* Turn ECOFF type information into a printable string.
1083 ecoff_emit_aggregate and ecoff_type_to_string are from
1084 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1086 /* Write aggregate information to a string. */
1089 ecoff_emit_aggregate (abfd, fdr, string, rndx, isym, which)
1097 const struct ecoff_debug_swap * const debug_swap =
1098 &ecoff_backend (abfd)->debug_swap;
1099 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info;
1100 unsigned int ifd = rndx->rfd;
1101 unsigned int indx = rndx->index;
1107 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1108 struct return type of a procedure compiled without -g. */
1109 if (ifd == 0xffffffff
1110 || (rndx->rfd == 0xfff && indx == 0))
1111 name = "<undefined>";
1112 else if (indx == indexNil)
1118 if (debug_info->external_rfd == NULL)
1119 fdr = debug_info->fdr + ifd;
1124 (*debug_swap->swap_rfd_in) (abfd,
1125 ((char *) debug_info->external_rfd
1126 + ((fdr->rfdBase + ifd)
1127 * debug_swap->external_rfd_size)),
1129 fdr = debug_info->fdr + rfd;
1132 indx += fdr->isymBase;
1134 (*debug_swap->swap_sym_in) (abfd,
1135 ((char *) debug_info->external_sym
1136 + indx * debug_swap->external_sym_size),
1139 name = debug_info->ss + fdr->issBase + sym.iss;
1143 "%s %s { ifd = %u, index = %lu }",
1146 + debug_info->symbolic_header.iextMax));
1149 /* Convert the type information to string format. */
1152 ecoff_type_to_string (abfd, fdr, indx)
1157 union aux_ext *aux_ptr;
1166 unsigned int basic_type;
1169 static char buffer2[1024];
1174 aux_ptr = ecoff_data (abfd)->debug_info.external_aux + fdr->iauxBase;
1175 bigendian = fdr->fBigendian;
1177 for (i = 0; i < 7; i++)
1179 qualifiers[i].low_bound = 0;
1180 qualifiers[i].high_bound = 0;
1181 qualifiers[i].stride = 0;
1184 if (AUX_GET_ISYM (bigendian, &aux_ptr[indx]) == (bfd_vma) -1)
1185 return "-1 (no type)";
1186 _bfd_ecoff_swap_tir_in (bigendian, &aux_ptr[indx++].a_ti, &u.ti);
1188 basic_type = u.ti.bt;
1189 qualifiers[0].type = u.ti.tq0;
1190 qualifiers[1].type = u.ti.tq1;
1191 qualifiers[2].type = u.ti.tq2;
1192 qualifiers[3].type = u.ti.tq3;
1193 qualifiers[4].type = u.ti.tq4;
1194 qualifiers[5].type = u.ti.tq5;
1195 qualifiers[6].type = tqNil;
1198 * Go get the basic type.
1202 case btNil: /* undefined */
1206 case btAdr: /* address - integer same size as pointer */
1207 strcpy (p1, "address");
1210 case btChar: /* character */
1211 strcpy (p1, "char");
1214 case btUChar: /* unsigned character */
1215 strcpy (p1, "unsigned char");
1218 case btShort: /* short */
1219 strcpy (p1, "short");
1222 case btUShort: /* unsigned short */
1223 strcpy (p1, "unsigned short");
1226 case btInt: /* int */
1230 case btUInt: /* unsigned int */
1231 strcpy (p1, "unsigned int");
1234 case btLong: /* long */
1235 strcpy (p1, "long");
1238 case btULong: /* unsigned long */
1239 strcpy (p1, "unsigned long");
1242 case btFloat: /* float (real) */
1243 strcpy (p1, "float");
1246 case btDouble: /* Double (real) */
1247 strcpy (p1, "double");
1250 /* Structures add 1-2 aux words:
1251 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1252 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1254 case btStruct: /* Structure (Record) */
1255 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1256 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1257 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1259 indx++; /* skip aux words */
1262 /* Unions add 1-2 aux words:
1263 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1264 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1266 case btUnion: /* Union */
1267 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1268 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1269 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1271 indx++; /* skip aux words */
1274 /* Enumerations add 1-2 aux words:
1275 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1276 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1278 case btEnum: /* Enumeration */
1279 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1280 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1281 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1283 indx++; /* skip aux words */
1286 case btTypedef: /* defined via a typedef, isymRef points */
1287 strcpy (p1, "typedef");
1290 case btRange: /* subrange of int */
1291 strcpy (p1, "subrange");
1294 case btSet: /* pascal sets */
1298 case btComplex: /* fortran complex */
1299 strcpy (p1, "complex");
1302 case btDComplex: /* fortran double complex */
1303 strcpy (p1, "double complex");
1306 case btIndirect: /* forward or unnamed typedef */
1307 strcpy (p1, "forward/unamed typedef");
1310 case btFixedDec: /* Fixed Decimal */
1311 strcpy (p1, "fixed decimal");
1314 case btFloatDec: /* Float Decimal */
1315 strcpy (p1, "float decimal");
1318 case btString: /* Varying Length Character String */
1319 strcpy (p1, "string");
1322 case btBit: /* Aligned Bit String */
1326 case btPicture: /* Picture */
1327 strcpy (p1, "picture");
1330 case btVoid: /* Void */
1331 strcpy (p1, "void");
1335 sprintf (p1, "Unknown basic type %d", (int) basic_type);
1339 p1 += strlen (buffer1);
1342 * If this is a bitfield, get the bitsize.
1348 bitsize = AUX_GET_WIDTH (bigendian, &aux_ptr[indx++]);
1349 sprintf (p1, " : %d", bitsize);
1350 p1 += strlen (buffer1);
1355 * Deal with any qualifiers.
1357 if (qualifiers[0].type != tqNil)
1360 * Snarf up any array bounds in the correct order. Arrays
1361 * store 5 successive words in the aux. table:
1362 * word 0 RNDXR to type of the bounds (ie, int)
1363 * word 1 Current file descriptor index
1365 * word 3 high bound (or -1 if [])
1366 * word 4 stride size in bits
1368 for (i = 0; i < 7; i++)
1370 if (qualifiers[i].type == tqArray)
1372 qualifiers[i].low_bound =
1373 AUX_GET_DNLOW (bigendian, &aux_ptr[indx+2]);
1374 qualifiers[i].high_bound =
1375 AUX_GET_DNHIGH (bigendian, &aux_ptr[indx+3]);
1376 qualifiers[i].stride =
1377 AUX_GET_WIDTH (bigendian, &aux_ptr[indx+4]);
1383 * Now print out the qualifiers.
1385 for (i = 0; i < 6; i++)
1387 switch (qualifiers[i].type)
1394 strcpy (p2, "ptr to ");
1395 p2 += sizeof ("ptr to ")-1;
1399 strcpy (p2, "volatile ");
1400 p2 += sizeof ("volatile ")-1;
1404 strcpy (p2, "far ");
1405 p2 += sizeof ("far ")-1;
1409 strcpy (p2, "func. ret. ");
1410 p2 += sizeof ("func. ret. ");
1415 int first_array = i;
1418 /* Print array bounds reversed (ie, in the order the C
1419 programmer writes them). C is such a fun language.... */
1421 while (i < 5 && qualifiers[i+1].type == tqArray)
1424 for (j = i; j >= first_array; j--)
1426 strcpy (p2, "array [");
1427 p2 += sizeof ("array [")-1;
1428 if (qualifiers[j].low_bound != 0)
1430 "%ld:%ld {%ld bits}",
1431 (long) qualifiers[j].low_bound,
1432 (long) qualifiers[j].high_bound,
1433 (long) qualifiers[j].stride);
1435 else if (qualifiers[j].high_bound != -1)
1438 (long) (qualifiers[j].high_bound + 1),
1439 (long) (qualifiers[j].stride));
1442 sprintf (p2, " {%ld bits}", (long) (qualifiers[j].stride));
1445 strcpy (p2, "] of ");
1446 p2 += sizeof ("] of ")-1;
1454 strcpy (p2, buffer1);
1458 /* Return information about ECOFF symbol SYMBOL in RET. */
1462 _bfd_ecoff_get_symbol_info (abfd, symbol, ret)
1463 bfd *abfd; /* Ignored. */
1467 bfd_symbol_info (symbol, ret);
1470 /* Return whether this is a local label. */
1474 _bfd_ecoff_bfd_is_local_label (abfd, symbol)
1478 return symbol->name[0] == '$';
1481 /* Print information about an ECOFF symbol. */
1484 _bfd_ecoff_print_symbol (abfd, filep, symbol, how)
1488 bfd_print_symbol_type how;
1490 const struct ecoff_debug_swap * const debug_swap
1491 = &ecoff_backend (abfd)->debug_swap;
1492 FILE *file = (FILE *)filep;
1496 case bfd_print_symbol_name:
1497 fprintf (file, "%s", symbol->name);
1499 case bfd_print_symbol_more:
1500 if (ecoffsymbol (symbol)->local)
1504 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
1506 fprintf (file, "ecoff local ");
1507 fprintf_vma (file, (bfd_vma) ecoff_sym.value);
1508 fprintf (file, " %x %x", (unsigned) ecoff_sym.st,
1509 (unsigned) ecoff_sym.sc);
1515 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
1517 fprintf (file, "ecoff extern ");
1518 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
1519 fprintf (file, " %x %x", (unsigned) ecoff_ext.asym.st,
1520 (unsigned) ecoff_ext.asym.sc);
1523 case bfd_print_symbol_all:
1524 /* Print out the symbols in a reasonable way */
1533 if (ecoffsymbol (symbol)->local)
1535 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
1538 pos = ((((char *) ecoffsymbol (symbol)->native
1539 - (char *) ecoff_data (abfd)->debug_info.external_sym)
1540 / debug_swap->external_sym_size)
1541 + ecoff_data (abfd)->debug_info.symbolic_header.iextMax);
1548 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
1551 pos = (((char *) ecoffsymbol (symbol)->native
1552 - (char *) ecoff_data (abfd)->debug_info.external_ext)
1553 / debug_swap->external_ext_size);
1554 jmptbl = ecoff_ext.jmptbl ? 'j' : ' ';
1555 cobol_main = ecoff_ext.cobol_main ? 'c' : ' ';
1556 weakext = ecoff_ext.weakext ? 'w' : ' ';
1559 fprintf (file, "[%3d] %c ",
1561 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
1562 fprintf (file, " st %x sc %x indx %x %c%c%c %s",
1563 (unsigned) ecoff_ext.asym.st,
1564 (unsigned) ecoff_ext.asym.sc,
1565 (unsigned) ecoff_ext.asym.index,
1566 jmptbl, cobol_main, weakext,
1569 if (ecoffsymbol (symbol)->fdr != NULL
1570 && ecoff_ext.asym.index != indexNil)
1575 bfd_size_type sym_base;
1576 union aux_ext *aux_base;
1578 fdr = ecoffsymbol (symbol)->fdr;
1579 indx = ecoff_ext.asym.index;
1581 /* sym_base is used to map the fdr relative indices which
1582 appear in the file to the position number which we are
1584 sym_base = fdr->isymBase;
1585 if (ecoffsymbol (symbol)->local)
1587 ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
1589 /* aux_base is the start of the aux entries for this file;
1590 asym.index is an offset from this. */
1591 aux_base = (ecoff_data (abfd)->debug_info.external_aux
1594 /* The aux entries are stored in host byte order; the
1595 order is indicated by a bit in the fdr. */
1596 bigendian = fdr->fBigendian;
1598 /* This switch is basically from gcc/mips-tdump.c */
1599 switch (ecoff_ext.asym.st)
1607 fprintf (file, "\n End+1 symbol: %ld",
1608 (long) (indx + sym_base));
1612 if (ecoff_ext.asym.sc == scText
1613 || ecoff_ext.asym.sc == scInfo)
1614 fprintf (file, "\n First symbol: %ld",
1615 (long) (indx + sym_base));
1617 fprintf (file, "\n First symbol: %ld",
1619 (AUX_GET_ISYM (bigendian,
1620 &aux_base[ecoff_ext.asym.index])
1626 if (ECOFF_IS_STAB (&ecoff_ext.asym))
1628 else if (ecoffsymbol (symbol)->local)
1629 fprintf (file, "\n End+1 symbol: %-7ld Type: %s",
1631 (AUX_GET_ISYM (bigendian,
1632 &aux_base[ecoff_ext.asym.index])
1634 ecoff_type_to_string (abfd, fdr, indx + 1));
1636 fprintf (file, "\n Local symbol: %ld",
1639 + (ecoff_data (abfd)
1640 ->debug_info.symbolic_header.iextMax)));
1644 fprintf (file, "\n struct; End+1 symbol: %ld",
1645 (long) (indx + sym_base));
1649 fprintf (file, "\n union; End+1 symbol: %ld",
1650 (long) (indx + sym_base));
1654 fprintf (file, "\n enum; End+1 symbol: %ld",
1655 (long) (indx + sym_base));
1659 if (! ECOFF_IS_STAB (&ecoff_ext.asym))
1660 fprintf (file, "\n Type: %s",
1661 ecoff_type_to_string (abfd, fdr, indx));
1670 /* Read in the relocs for a section. */
1673 ecoff_slurp_reloc_table (abfd, section, symbols)
1678 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
1679 arelent *internal_relocs;
1680 bfd_size_type external_reloc_size;
1681 bfd_size_type external_relocs_size;
1682 char *external_relocs;
1686 if (section->relocation != (arelent *) NULL
1687 || section->reloc_count == 0
1688 || (section->flags & SEC_CONSTRUCTOR) != 0)
1691 if (_bfd_ecoff_slurp_symbol_table (abfd) == false)
1694 internal_relocs = (arelent *) bfd_alloc (abfd,
1696 * section->reloc_count));
1697 external_reloc_size = backend->external_reloc_size;
1698 external_relocs_size = external_reloc_size * section->reloc_count;
1699 external_relocs = (char *) bfd_alloc (abfd, external_relocs_size);
1700 if (internal_relocs == (arelent *) NULL
1701 || external_relocs == (char *) NULL)
1703 bfd_set_error (bfd_error_no_memory);
1706 if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0)
1708 if (bfd_read (external_relocs, 1, external_relocs_size, abfd)
1709 != external_relocs_size)
1712 for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++)
1714 struct internal_reloc intern;
1716 (*backend->swap_reloc_in) (abfd,
1717 external_relocs + i * external_reloc_size,
1720 if (intern.r_extern)
1722 /* r_symndx is an index into the external symbols. */
1723 BFD_ASSERT (intern.r_symndx >= 0
1725 < (ecoff_data (abfd)
1726 ->debug_info.symbolic_header.iextMax)));
1727 rptr->sym_ptr_ptr = symbols + intern.r_symndx;
1730 else if (intern.r_symndx == RELOC_SECTION_NONE
1731 || intern.r_symndx == RELOC_SECTION_ABS)
1733 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1738 CONST char *sec_name;
1741 /* r_symndx is a section key. */
1742 switch (intern.r_symndx)
1744 case RELOC_SECTION_TEXT: sec_name = ".text"; break;
1745 case RELOC_SECTION_RDATA: sec_name = ".rdata"; break;
1746 case RELOC_SECTION_DATA: sec_name = ".data"; break;
1747 case RELOC_SECTION_SDATA: sec_name = ".sdata"; break;
1748 case RELOC_SECTION_SBSS: sec_name = ".sbss"; break;
1749 case RELOC_SECTION_BSS: sec_name = ".bss"; break;
1750 case RELOC_SECTION_INIT: sec_name = ".init"; break;
1751 case RELOC_SECTION_LIT8: sec_name = ".lit8"; break;
1752 case RELOC_SECTION_LIT4: sec_name = ".lit4"; break;
1753 case RELOC_SECTION_XDATA: sec_name = ".xdata"; break;
1754 case RELOC_SECTION_PDATA: sec_name = ".pdata"; break;
1755 case RELOC_SECTION_FINI: sec_name = ".fini"; break;
1756 case RELOC_SECTION_LITA: sec_name = ".lita"; break;
1760 sec = bfd_get_section_by_name (abfd, sec_name);
1761 if (sec == (asection *) NULL)
1763 rptr->sym_ptr_ptr = sec->symbol_ptr_ptr;
1765 rptr->addend = - bfd_get_section_vma (abfd, sec);
1768 rptr->address = intern.r_vaddr - bfd_get_section_vma (abfd, section);
1770 /* Let the backend select the howto field and do any other
1771 required processing. */
1772 (*backend->adjust_reloc_in) (abfd, &intern, rptr);
1775 bfd_release (abfd, external_relocs);
1777 section->relocation = internal_relocs;
1782 /* Get a canonical list of relocs. */
1785 _bfd_ecoff_canonicalize_reloc (abfd, section, relptr, symbols)
1793 if (section->flags & SEC_CONSTRUCTOR)
1795 arelent_chain *chain;
1797 /* This section has relocs made up by us, not the file, so take
1798 them out of their chain and place them into the data area
1800 for (count = 0, chain = section->constructor_chain;
1801 count < section->reloc_count;
1802 count++, chain = chain->next)
1803 *relptr++ = &chain->relent;
1809 if (ecoff_slurp_reloc_table (abfd, section, symbols) == false)
1812 tblptr = section->relocation;
1814 for (count = 0; count < section->reloc_count; count++)
1815 *relptr++ = tblptr++;
1818 *relptr = (arelent *) NULL;
1820 return section->reloc_count;
1823 /* Provided a BFD, a section and an offset into the section, calculate
1824 and return the name of the source file and the line nearest to the
1829 _bfd_ecoff_find_nearest_line (abfd, section, ignore_symbols, offset,
1830 filename_ptr, functionname_ptr, retline_ptr)
1833 asymbol **ignore_symbols;
1835 CONST char **filename_ptr;
1836 CONST char **functionname_ptr;
1837 unsigned int *retline_ptr;
1839 const struct ecoff_debug_swap * const debug_swap
1840 = &ecoff_backend (abfd)->debug_swap;
1841 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info;
1842 struct ecoff_find_line *line_info;
1844 /* If we're not in the .text section, we don't have any line
1846 if (strcmp (section->name, _TEXT) != 0
1847 || offset < ecoff_data (abfd)->text_start
1848 || offset >= ecoff_data (abfd)->text_end)
1851 /* Make sure we have the FDR's. */
1852 if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL, debug_info)
1853 || bfd_get_symcount (abfd) == 0)
1856 if (ecoff_data (abfd)->find_line_info == NULL)
1858 ecoff_data (abfd)->find_line_info =
1859 ((struct ecoff_find_line *)
1860 bfd_alloc (abfd, sizeof (struct ecoff_find_line)));
1861 if (ecoff_data (abfd)->find_line_info == NULL)
1863 bfd_set_error (bfd_error_no_memory);
1866 ecoff_data (abfd)->find_line_info->find_buffer = NULL;
1867 ecoff_data (abfd)->find_line_info->fdrtab_len = 0;
1868 ecoff_data (abfd)->find_line_info->fdrtab = NULL;
1870 line_info = ecoff_data (abfd)->find_line_info;
1872 return _bfd_ecoff_locate_line (abfd, section, offset, debug_info,
1873 debug_swap, line_info, filename_ptr,
1874 functionname_ptr, retline_ptr);
1877 /* Copy private BFD data. This is called by objcopy and strip. We
1878 use it to copy the ECOFF debugging information from one BFD to the
1879 other. It would be theoretically possible to represent the ECOFF
1880 debugging information in the symbol table. However, it would be a
1881 lot of work, and there would be little gain (gas, gdb, and ld
1882 already access the ECOFF debugging information via the
1883 ecoff_debug_info structure, and that structure would have to be
1884 retained in order to support ECOFF debugging in MIPS ELF).
1886 The debugging information for the ECOFF external symbols comes from
1887 the symbol table, so this function only handles the other debugging
1891 _bfd_ecoff_bfd_copy_private_bfd_data (ibfd, obfd)
1895 struct ecoff_debug_info *iinfo = &ecoff_data (ibfd)->debug_info;
1896 struct ecoff_debug_info *oinfo = &ecoff_data (obfd)->debug_info;
1898 asymbol **sym_ptr_ptr;
1902 /* This function is selected based on the input vector. We only
1903 want to copy information over if the output BFD also uses ECOFF
1905 if (bfd_get_flavour (obfd) != bfd_target_ecoff_flavour)
1908 /* Copy the GP value and the register masks. */
1909 ecoff_data (obfd)->gp = ecoff_data (ibfd)->gp;
1910 ecoff_data (obfd)->gprmask = ecoff_data (ibfd)->gprmask;
1911 ecoff_data (obfd)->fprmask = ecoff_data (ibfd)->fprmask;
1912 for (i = 0; i < 3; i++)
1913 ecoff_data (obfd)->cprmask[i] = ecoff_data (ibfd)->cprmask[i];
1915 /* Copy the version stamp. */
1916 oinfo->symbolic_header.vstamp = iinfo->symbolic_header.vstamp;
1918 /* If there are no symbols, don't copy any debugging information. */
1919 c = bfd_get_symcount (obfd);
1920 sym_ptr_ptr = bfd_get_outsymbols (obfd);
1921 if (c == 0 || sym_ptr_ptr == (asymbol **) NULL)
1924 /* See if there are any local symbols. */
1926 for (; c > 0; c--, sym_ptr_ptr++)
1928 if (ecoffsymbol (*sym_ptr_ptr)->local)
1937 /* There are some local symbols. We just bring over all the
1938 debugging information. FIXME: This is not quite the right
1939 thing to do. If the user has asked us to discard all
1940 debugging information, then we are probably going to wind up
1941 keeping it because there will probably be some local symbol
1942 which objcopy did not discard. We should actually break
1943 apart the debugging information and only keep that which
1944 applies to the symbols we want to keep. */
1945 oinfo->symbolic_header.ilineMax = iinfo->symbolic_header.ilineMax;
1946 oinfo->symbolic_header.cbLine = iinfo->symbolic_header.cbLine;
1947 oinfo->line = iinfo->line;
1949 oinfo->symbolic_header.idnMax = iinfo->symbolic_header.idnMax;
1950 oinfo->external_dnr = iinfo->external_dnr;
1952 oinfo->symbolic_header.ipdMax = iinfo->symbolic_header.ipdMax;
1953 oinfo->external_pdr = iinfo->external_pdr;
1955 oinfo->symbolic_header.isymMax = iinfo->symbolic_header.isymMax;
1956 oinfo->external_sym = iinfo->external_sym;
1958 oinfo->symbolic_header.ioptMax = iinfo->symbolic_header.ioptMax;
1959 oinfo->external_opt = iinfo->external_opt;
1961 oinfo->symbolic_header.iauxMax = iinfo->symbolic_header.iauxMax;
1962 oinfo->external_aux = iinfo->external_aux;
1964 oinfo->symbolic_header.issMax = iinfo->symbolic_header.issMax;
1965 oinfo->ss = iinfo->ss;
1967 oinfo->symbolic_header.ifdMax = iinfo->symbolic_header.ifdMax;
1968 oinfo->external_fdr = iinfo->external_fdr;
1970 oinfo->symbolic_header.crfd = iinfo->symbolic_header.crfd;
1971 oinfo->external_rfd = iinfo->external_rfd;
1975 /* We are discarding all the local symbol information. Look
1976 through the external symbols and remove all references to FDR
1977 or aux information. */
1978 c = bfd_get_symcount (obfd);
1979 sym_ptr_ptr = bfd_get_outsymbols (obfd);
1980 for (; c > 0; c--, sym_ptr_ptr++)
1984 (*(ecoff_backend (obfd)->debug_swap.swap_ext_in))
1985 (obfd, ecoffsymbol (*sym_ptr_ptr)->native, &esym);
1987 esym.asym.index = indexNil;
1988 (*(ecoff_backend (obfd)->debug_swap.swap_ext_out))
1989 (obfd, &esym, ecoffsymbol (*sym_ptr_ptr)->native);
1996 /* Set the architecture. The supported architecture is stored in the
1997 backend pointer. We always set the architecture anyhow, since many
1998 callers ignore the return value. */
2001 _bfd_ecoff_set_arch_mach (abfd, arch, machine)
2003 enum bfd_architecture arch;
2004 unsigned long machine;
2006 bfd_default_set_arch_mach (abfd, arch, machine);
2007 return arch == ecoff_backend (abfd)->arch;
2010 /* Get the size of the section headers. */
2014 _bfd_ecoff_sizeof_headers (abfd, reloc)
2023 for (current = abfd->sections;
2024 current != (asection *)NULL;
2025 current = current->next)
2028 ret = (bfd_coff_filhsz (abfd)
2029 + bfd_coff_aoutsz (abfd)
2030 + c * bfd_coff_scnhsz (abfd));
2031 return BFD_ALIGN (ret, 16);
2034 /* Get the contents of a section. */
2037 _bfd_ecoff_get_section_contents (abfd, section, location, offset, count)
2042 bfd_size_type count;
2044 return _bfd_generic_get_section_contents (abfd, section, location,
2048 /* Calculate the file position for each section, and set
2052 ecoff_compute_section_file_positions (abfd)
2060 sofar = _bfd_ecoff_sizeof_headers (abfd, false);
2063 for (current = abfd->sections;
2064 current != (asection *) NULL;
2065 current = current->next)
2067 unsigned int alignment_power;
2069 /* Only deal with sections which have contents */
2070 if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) == 0)
2073 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2074 supposed to indicate the number of .pdata entries that are
2075 really in the section. Each entry is 8 bytes. We store this
2076 away in line_filepos before increasing the section size. */
2077 if (strcmp (current->name, _PDATA) != 0)
2078 alignment_power = current->alignment_power;
2081 current->line_filepos = current->_raw_size / 8;
2082 alignment_power = 4;
2085 /* On Ultrix, the data sections in an executable file must be
2086 aligned to a page boundary within the file. This does not
2087 affect the section size, though. FIXME: Does this work for
2088 other platforms? It requires some modification for the
2089 Alpha, because .rdata on the Alpha goes with the text, not
2091 if ((abfd->flags & EXEC_P) != 0
2092 && (abfd->flags & D_PAGED) != 0
2093 && first_data != false
2094 && (current->flags & SEC_CODE) == 0
2095 && (! ecoff_backend (abfd)->rdata_in_text
2096 || strcmp (current->name, _RDATA) != 0)
2097 && strcmp (current->name, _PDATA) != 0)
2099 const bfd_vma round = ecoff_backend (abfd)->round;
2101 sofar = (sofar + round - 1) &~ (round - 1);
2104 else if (strcmp (current->name, _LIB) == 0)
2106 const bfd_vma round = ecoff_backend (abfd)->round;
2107 /* On Irix 4, the location of contents of the .lib section
2108 from a shared library section is also rounded up to a
2111 sofar = (sofar + round - 1) &~ (round - 1);
2114 /* Align the sections in the file to the same boundary on
2115 which they are aligned in virtual memory. */
2117 sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2119 current->filepos = sofar;
2121 sofar += current->_raw_size;
2123 /* make sure that this section is of the right size too */
2125 sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2126 current->_raw_size += sofar - old_sofar;
2129 ecoff_data (abfd)->reloc_filepos = sofar;
2132 /* Determine the location of the relocs for all the sections in the
2133 output file, as well as the location of the symbolic debugging
2136 static bfd_size_type
2137 ecoff_compute_reloc_file_positions (abfd)
2140 const bfd_size_type external_reloc_size =
2141 ecoff_backend (abfd)->external_reloc_size;
2142 file_ptr reloc_base;
2143 bfd_size_type reloc_size;
2147 if (! abfd->output_has_begun)
2149 ecoff_compute_section_file_positions (abfd);
2150 abfd->output_has_begun = true;
2153 reloc_base = ecoff_data (abfd)->reloc_filepos;
2156 for (current = abfd->sections;
2157 current != (asection *)NULL;
2158 current = current->next)
2160 if (current->reloc_count == 0)
2161 current->rel_filepos = 0;
2164 bfd_size_type relsize;
2166 current->rel_filepos = reloc_base;
2167 relsize = current->reloc_count * external_reloc_size;
2168 reloc_size += relsize;
2169 reloc_base += relsize;
2173 sym_base = ecoff_data (abfd)->reloc_filepos + reloc_size;
2175 /* At least on Ultrix, the symbol table of an executable file must
2176 be aligned to a page boundary. FIXME: Is this true on other
2178 if ((abfd->flags & EXEC_P) != 0
2179 && (abfd->flags & D_PAGED) != 0)
2180 sym_base = ((sym_base + ecoff_backend (abfd)->round - 1)
2181 &~ (ecoff_backend (abfd)->round - 1));
2183 ecoff_data (abfd)->sym_filepos = sym_base;
2188 /* Set the contents of a section. */
2191 _bfd_ecoff_set_section_contents (abfd, section, location, offset, count)
2196 bfd_size_type count;
2198 /* This must be done first, because bfd_set_section_contents is
2199 going to set output_has_begun to true. */
2200 if (abfd->output_has_begun == false)
2201 ecoff_compute_section_file_positions (abfd);
2203 /* If this is a .lib section, bump the vma address so that it winds
2204 up being the number of .lib sections output. This is right for
2205 Irix 4. Ian Taylor <ian@cygnus.com>. */
2206 if (strcmp (section->name, _LIB) == 0)
2212 if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
2213 || bfd_write (location, 1, count, abfd) != count)
2219 /* Get the GP value for an ECOFF file. This is a hook used by
2223 bfd_ecoff_get_gp_value (abfd)
2226 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2227 || bfd_get_format (abfd) != bfd_object)
2229 bfd_set_error (bfd_error_invalid_operation);
2233 return ecoff_data (abfd)->gp;
2236 /* Set the GP value for an ECOFF file. This is a hook used by the
2240 bfd_ecoff_set_gp_value (abfd, gp_value)
2244 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2245 || bfd_get_format (abfd) != bfd_object)
2247 bfd_set_error (bfd_error_invalid_operation);
2251 ecoff_data (abfd)->gp = gp_value;
2256 /* Set the register masks for an ECOFF file. This is a hook used by
2260 bfd_ecoff_set_regmasks (abfd, gprmask, fprmask, cprmask)
2262 unsigned long gprmask;
2263 unsigned long fprmask;
2264 unsigned long *cprmask;
2266 ecoff_data_type *tdata;
2268 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2269 || bfd_get_format (abfd) != bfd_object)
2271 bfd_set_error (bfd_error_invalid_operation);
2275 tdata = ecoff_data (abfd);
2276 tdata->gprmask = gprmask;
2277 tdata->fprmask = fprmask;
2278 if (cprmask != (unsigned long *) NULL)
2282 for (i = 0; i < 3; i++)
2283 tdata->cprmask[i] = cprmask[i];
2289 /* Get ECOFF EXTR information for an external symbol. This function
2290 is passed to bfd_ecoff_debug_externals. */
2293 ecoff_get_extr (sym, esym)
2297 ecoff_symbol_type *ecoff_sym_ptr;
2300 if (bfd_asymbol_flavour (sym) != bfd_target_ecoff_flavour
2301 || ecoffsymbol (sym)->native == NULL)
2303 /* Don't include debugging, local, or section symbols. */
2304 if ((sym->flags & BSF_DEBUGGING) != 0
2305 || (sym->flags & BSF_LOCAL) != 0
2306 || (sym->flags & BSF_SECTION_SYM) != 0)
2310 esym->cobol_main = 0;
2314 /* FIXME: we can do better than this for st and sc. */
2315 esym->asym.st = stGlobal;
2316 esym->asym.sc = scAbs;
2317 esym->asym.reserved = 0;
2318 esym->asym.index = indexNil;
2322 ecoff_sym_ptr = ecoffsymbol (sym);
2324 if (ecoff_sym_ptr->local)
2327 input_bfd = bfd_asymbol_bfd (sym);
2328 (*(ecoff_backend (input_bfd)->debug_swap.swap_ext_in))
2329 (input_bfd, ecoff_sym_ptr->native, esym);
2331 /* If the symbol was defined by the linker, then esym will be
2332 undefined but sym will not be. Get a better class for such a
2334 if ((esym->asym.sc == scUndefined
2335 || esym->asym.sc == scSUndefined)
2336 && ! bfd_is_und_section (bfd_get_section (sym)))
2337 esym->asym.sc = scAbs;
2339 /* Adjust the FDR index for the symbol by that used for the input
2341 if (esym->ifd != -1)
2343 struct ecoff_debug_info *input_debug;
2345 input_debug = &ecoff_data (input_bfd)->debug_info;
2346 BFD_ASSERT (esym->ifd < input_debug->symbolic_header.ifdMax);
2347 if (input_debug->ifdmap != (RFDT *) NULL)
2348 esym->ifd = input_debug->ifdmap[esym->ifd];
2354 /* Set the external symbol index. This routine is passed to
2355 bfd_ecoff_debug_externals. */
2358 ecoff_set_index (sym, indx)
2362 ecoff_set_sym_index (sym, indx);
2365 /* Write out an ECOFF file. */
2368 _bfd_ecoff_write_object_contents (abfd)
2371 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
2372 const bfd_vma round = backend->round;
2373 const bfd_size_type filhsz = bfd_coff_filhsz (abfd);
2374 const bfd_size_type aoutsz = bfd_coff_aoutsz (abfd);
2375 const bfd_size_type scnhsz = bfd_coff_scnhsz (abfd);
2376 const bfd_size_type external_hdr_size
2377 = backend->debug_swap.external_hdr_size;
2378 const bfd_size_type external_reloc_size = backend->external_reloc_size;
2379 void (* const adjust_reloc_out) PARAMS ((bfd *,
2381 struct internal_reloc *))
2382 = backend->adjust_reloc_out;
2383 void (* const swap_reloc_out) PARAMS ((bfd *,
2384 const struct internal_reloc *,
2386 = backend->swap_reloc_out;
2387 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
2388 HDRR * const symhdr = &debug->symbolic_header;
2391 bfd_size_type reloc_size;
2392 bfd_size_type text_size;
2394 boolean set_text_start;
2395 bfd_size_type data_size;
2397 boolean set_data_start;
2398 bfd_size_type bss_size;
2400 PTR reloc_buff = NULL;
2401 struct internal_filehdr internal_f;
2402 struct internal_aouthdr internal_a;
2405 /* Determine where the sections and relocs will go in the output
2407 reloc_size = ecoff_compute_reloc_file_positions (abfd);
2410 for (current = abfd->sections;
2411 current != (asection *)NULL;
2412 current = current->next)
2414 current->target_index = count;
2418 if ((abfd->flags & D_PAGED) != 0)
2419 text_size = _bfd_ecoff_sizeof_headers (abfd, false);
2423 set_text_start = false;
2426 set_data_start = false;
2429 /* Write section headers to the file. */
2431 /* Allocate buff big enough to hold a section header,
2432 file header, or a.out header. */
2440 buff = (PTR) malloc ((size_t) siz);
2443 bfd_set_error (bfd_error_no_memory);
2448 internal_f.f_nscns = 0;
2449 if (bfd_seek (abfd, (file_ptr) (filhsz + aoutsz), SEEK_SET) != 0)
2451 for (current = abfd->sections;
2452 current != (asection *) NULL;
2453 current = current->next)
2455 struct internal_scnhdr section;
2458 ++internal_f.f_nscns;
2460 strncpy (section.s_name, current->name, sizeof section.s_name);
2462 /* This seems to be correct for Irix 4 shared libraries. */
2463 vma = bfd_get_section_vma (abfd, current);
2464 if (strcmp (current->name, _LIB) == 0)
2465 section.s_vaddr = 0;
2467 section.s_vaddr = vma;
2469 section.s_paddr = vma;
2470 section.s_size = bfd_get_section_size_before_reloc (current);
2472 /* If this section is unloadable then the scnptr will be 0. */
2473 if ((current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2474 section.s_scnptr = 0;
2476 section.s_scnptr = current->filepos;
2477 section.s_relptr = current->rel_filepos;
2479 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2480 object file produced by the assembler is supposed to point to
2481 information about how much room is required by objects of
2482 various different sizes. I think this only matters if we
2483 want the linker to compute the best size to use, or
2484 something. I don't know what happens if the information is
2486 if (strcmp (current->name, _PDATA) != 0)
2487 section.s_lnnoptr = 0;
2490 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2491 hold the number of entries in the section (each entry is
2492 8 bytes). We stored this in the line_filepos field in
2493 ecoff_compute_section_file_positions. */
2494 section.s_lnnoptr = current->line_filepos;
2497 section.s_nreloc = current->reloc_count;
2498 section.s_nlnno = 0;
2499 section.s_flags = ecoff_sec_to_styp_flags (current->name,
2502 if (bfd_coff_swap_scnhdr_out (abfd, (PTR) §ion, buff) == 0
2503 || bfd_write (buff, 1, scnhsz, abfd) != scnhsz)
2506 if ((section.s_flags & STYP_TEXT) != 0
2507 || ((section.s_flags & STYP_RDATA) != 0
2508 && backend->rdata_in_text)
2509 || strcmp (current->name, _PDATA) == 0)
2511 text_size += bfd_get_section_size_before_reloc (current);
2512 if (! set_text_start || text_start > vma)
2515 set_text_start = true;
2518 else if ((section.s_flags & STYP_RDATA) != 0
2519 || (section.s_flags & STYP_DATA) != 0
2520 || (section.s_flags & STYP_LITA) != 0
2521 || (section.s_flags & STYP_LIT8) != 0
2522 || (section.s_flags & STYP_LIT4) != 0
2523 || (section.s_flags & STYP_SDATA) != 0
2524 || strcmp (current->name, _XDATA) == 0)
2526 data_size += bfd_get_section_size_before_reloc (current);
2527 if (! set_data_start || data_start > vma)
2530 set_data_start = true;
2533 else if ((section.s_flags & STYP_BSS) != 0
2534 || (section.s_flags & STYP_SBSS) != 0)
2535 bss_size += bfd_get_section_size_before_reloc (current);
2536 else if ((section.s_flags & STYP_ECOFF_LIB) != 0)
2542 /* Set up the file header. */
2544 internal_f.f_magic = ecoff_get_magic (abfd);
2546 /* We will NOT put a fucking timestamp in the header here. Every
2547 time you put it back, I will come in and take it out again. I'm
2548 sorry. This field does not belong here. We fill it with a 0 so
2549 it compares the same but is not a reasonable time. --
2551 internal_f.f_timdat = 0;
2553 if (bfd_get_symcount (abfd) != 0)
2555 /* The ECOFF f_nsyms field is not actually the number of
2556 symbols, it's the size of symbolic information header. */
2557 internal_f.f_nsyms = external_hdr_size;
2558 internal_f.f_symptr = ecoff_data (abfd)->sym_filepos;
2562 internal_f.f_nsyms = 0;
2563 internal_f.f_symptr = 0;
2566 internal_f.f_opthdr = aoutsz;
2568 internal_f.f_flags = F_LNNO;
2569 if (reloc_size == 0)
2570 internal_f.f_flags |= F_RELFLG;
2571 if (bfd_get_symcount (abfd) == 0)
2572 internal_f.f_flags |= F_LSYMS;
2573 if (abfd->flags & EXEC_P)
2574 internal_f.f_flags |= F_EXEC;
2576 if (! abfd->xvec->byteorder_big_p)
2577 internal_f.f_flags |= F_AR32WR;
2579 internal_f.f_flags |= F_AR32W;
2581 /* Set up the ``optional'' header. */
2582 if ((abfd->flags & D_PAGED) != 0)
2583 internal_a.magic = ECOFF_AOUT_ZMAGIC;
2585 internal_a.magic = ECOFF_AOUT_OMAGIC;
2587 /* FIXME: Is this really correct? */
2588 internal_a.vstamp = symhdr->vstamp;
2590 /* At least on Ultrix, these have to be rounded to page boundaries.
2591 FIXME: Is this true on other platforms? */
2592 if ((abfd->flags & D_PAGED) != 0)
2594 internal_a.tsize = (text_size + round - 1) &~ (round - 1);
2595 internal_a.text_start = text_start &~ (round - 1);
2596 internal_a.dsize = (data_size + round - 1) &~ (round - 1);
2597 internal_a.data_start = data_start &~ (round - 1);
2601 internal_a.tsize = text_size;
2602 internal_a.text_start = text_start;
2603 internal_a.dsize = data_size;
2604 internal_a.data_start = data_start;
2607 /* On Ultrix, the initial portions of the .sbss and .bss segments
2608 are at the end of the data section. The bsize field in the
2609 optional header records how many bss bytes are required beyond
2610 those in the data section. The value is not rounded to a page
2612 if (bss_size < internal_a.dsize - data_size)
2615 bss_size -= internal_a.dsize - data_size;
2616 internal_a.bsize = bss_size;
2617 internal_a.bss_start = internal_a.data_start + internal_a.dsize;
2619 internal_a.entry = bfd_get_start_address (abfd);
2621 internal_a.gp_value = ecoff_data (abfd)->gp;
2623 internal_a.gprmask = ecoff_data (abfd)->gprmask;
2624 internal_a.fprmask = ecoff_data (abfd)->fprmask;
2625 for (i = 0; i < 4; i++)
2626 internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i];
2628 /* Write out the file header and the optional header. */
2630 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
2633 bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, buff);
2634 if (bfd_write (buff, 1, filhsz, abfd) != filhsz)
2637 bfd_coff_swap_aouthdr_out (abfd, (PTR) &internal_a, buff);
2638 if (bfd_write (buff, 1, aoutsz, abfd) != aoutsz)
2641 /* Build the external symbol information. This must be done before
2642 writing out the relocs so that we know the symbol indices. We
2643 don't do this if this BFD was created by the backend linker,
2644 since it will have already handled the symbols and relocs. */
2645 if (! ecoff_data (abfd)->linker)
2647 symhdr->iextMax = 0;
2648 symhdr->issExtMax = 0;
2649 debug->external_ext = debug->external_ext_end = NULL;
2650 debug->ssext = debug->ssext_end = NULL;
2651 if (bfd_ecoff_debug_externals (abfd, debug, &backend->debug_swap,
2652 (((abfd->flags & EXEC_P) == 0)
2654 ecoff_get_extr, ecoff_set_index)
2658 /* Write out the relocs. */
2659 for (current = abfd->sections;
2660 current != (asection *) NULL;
2661 current = current->next)
2663 arelent **reloc_ptr_ptr;
2664 arelent **reloc_end;
2667 if (current->reloc_count == 0)
2671 bfd_alloc (abfd, current->reloc_count * external_reloc_size);
2672 if (reloc_buff == NULL)
2674 bfd_set_error (bfd_error_no_memory);
2678 reloc_ptr_ptr = current->orelocation;
2679 reloc_end = reloc_ptr_ptr + current->reloc_count;
2680 out_ptr = (char *) reloc_buff;
2682 reloc_ptr_ptr < reloc_end;
2683 reloc_ptr_ptr++, out_ptr += external_reloc_size)
2687 struct internal_reloc in;
2689 memset ((PTR) &in, 0, sizeof in);
2691 reloc = *reloc_ptr_ptr;
2692 sym = *reloc->sym_ptr_ptr;
2694 in.r_vaddr = (reloc->address
2695 + bfd_get_section_vma (abfd, current));
2696 in.r_type = reloc->howto->type;
2698 if ((sym->flags & BSF_SECTION_SYM) == 0)
2700 in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr);
2707 name = bfd_get_section_name (abfd, bfd_get_section (sym));
2708 if (strcmp (name, ".text") == 0)
2709 in.r_symndx = RELOC_SECTION_TEXT;
2710 else if (strcmp (name, ".rdata") == 0)
2711 in.r_symndx = RELOC_SECTION_RDATA;
2712 else if (strcmp (name, ".data") == 0)
2713 in.r_symndx = RELOC_SECTION_DATA;
2714 else if (strcmp (name, ".sdata") == 0)
2715 in.r_symndx = RELOC_SECTION_SDATA;
2716 else if (strcmp (name, ".sbss") == 0)
2717 in.r_symndx = RELOC_SECTION_SBSS;
2718 else if (strcmp (name, ".bss") == 0)
2719 in.r_symndx = RELOC_SECTION_BSS;
2720 else if (strcmp (name, ".init") == 0)
2721 in.r_symndx = RELOC_SECTION_INIT;
2722 else if (strcmp (name, ".lit8") == 0)
2723 in.r_symndx = RELOC_SECTION_LIT8;
2724 else if (strcmp (name, ".lit4") == 0)
2725 in.r_symndx = RELOC_SECTION_LIT4;
2726 else if (strcmp (name, ".xdata") == 0)
2727 in.r_symndx = RELOC_SECTION_XDATA;
2728 else if (strcmp (name, ".pdata") == 0)
2729 in.r_symndx = RELOC_SECTION_PDATA;
2730 else if (strcmp (name, ".fini") == 0)
2731 in.r_symndx = RELOC_SECTION_FINI;
2732 else if (strcmp (name, ".lita") == 0)
2733 in.r_symndx = RELOC_SECTION_LITA;
2734 else if (strcmp (name, "*ABS*") == 0)
2735 in.r_symndx = RELOC_SECTION_ABS;
2741 (*adjust_reloc_out) (abfd, reloc, &in);
2743 (*swap_reloc_out) (abfd, &in, (PTR) out_ptr);
2746 if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0)
2748 if (bfd_write (reloc_buff,
2749 external_reloc_size, current->reloc_count, abfd)
2750 != external_reloc_size * current->reloc_count)
2752 bfd_release (abfd, reloc_buff);
2756 /* Write out the symbolic debugging information. */
2757 if (bfd_get_symcount (abfd) > 0)
2759 /* Write out the debugging information. */
2760 if (bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap,
2761 ecoff_data (abfd)->sym_filepos)
2767 /* The .bss section of a demand paged executable must receive an
2768 entire page. If there are symbols, the symbols will start on the
2769 next page. If there are no symbols, we must fill out the page by
2771 if (bfd_get_symcount (abfd) == 0
2772 && (abfd->flags & EXEC_P) != 0
2773 && (abfd->flags & D_PAGED) != 0)
2777 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2780 if (bfd_read (&c, 1, 1, abfd) == 0)
2782 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2785 if (bfd_write (&c, 1, 1, abfd) != 1)
2789 if (reloc_buff != NULL)
2790 bfd_release (abfd, reloc_buff);
2795 if (reloc_buff != NULL)
2796 bfd_release (abfd, reloc_buff);
2802 /* Archive handling. ECOFF uses what appears to be a unique type of
2803 archive header (armap). The byte ordering of the armap and the
2804 contents are encoded in the name of the armap itself. At least for
2805 now, we only support archives with the same byte ordering in the
2806 armap and the contents.
2808 The first four bytes in the armap are the number of symbol
2809 definitions. This is always a power of two.
2811 This is followed by the symbol definitions. Each symbol definition
2812 occupies 8 bytes. The first four bytes are the offset from the
2813 start of the armap strings to the null-terminated string naming
2814 this symbol. The second four bytes are the file offset to the
2815 archive member which defines this symbol. If the second four bytes
2816 are 0, then this is not actually a symbol definition, and it should
2819 The symbols are hashed into the armap with a closed hashing scheme.
2820 See the functions below for the details of the algorithm.
2822 After the symbol definitions comes four bytes holding the size of
2823 the string table, followed by the string table itself. */
2825 /* The name of an archive headers looks like this:
2826 __________E[BL]E[BL]_ (with a trailing space).
2827 The trailing space is changed to an X if the archive is changed to
2828 indicate that the armap is out of date.
2830 The Alpha seems to use ________64E[BL]E[BL]_. */
2832 #define ARMAP_BIG_ENDIAN 'B'
2833 #define ARMAP_LITTLE_ENDIAN 'L'
2834 #define ARMAP_MARKER 'E'
2835 #define ARMAP_START_LENGTH 10
2836 #define ARMAP_HEADER_MARKER_INDEX 10
2837 #define ARMAP_HEADER_ENDIAN_INDEX 11
2838 #define ARMAP_OBJECT_MARKER_INDEX 12
2839 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2840 #define ARMAP_END_INDEX 14
2841 #define ARMAP_END "_ "
2843 /* This is a magic number used in the hashing algorithm. */
2844 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2846 /* This returns the hash value to use for a string. It also sets
2847 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2848 is the number of entries in the hash table, and HLOG is the log
2852 ecoff_armap_hash (s, rehash, size, hlog)
2854 unsigned int *rehash;
2862 hash = ((hash >> 27) | (hash << 5)) + *s++;
2863 hash *= ARMAP_HASH_MAGIC;
2864 *rehash = (hash & (size - 1)) | 1;
2865 return hash >> (32 - hlog);
2868 /* Read in the armap. */
2871 _bfd_ecoff_slurp_armap (abfd)
2876 struct areltdata *mapdata;
2877 bfd_size_type parsed_size;
2879 struct artdata *ardata;
2882 struct symdef *symdef_ptr;
2885 /* Get the name of the first element. */
2886 i = bfd_read ((PTR) nextname, 1, 16, abfd);
2892 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
2895 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2896 standard COFF armap. We could move the ECOFF armap stuff into
2897 bfd_slurp_armap, but that seems inappropriate since no other
2898 target uses this format. Instead, we check directly for a COFF
2900 if (strncmp (nextname, "/ ", 16) == 0)
2901 return bfd_slurp_armap (abfd);
2903 /* See if the first element is an armap. */
2904 if (strncmp (nextname, ecoff_backend (abfd)->armap_start,
2905 ARMAP_START_LENGTH) != 0
2906 || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER
2907 || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2908 && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2909 || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER
2910 || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2911 && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2912 || strncmp (nextname + ARMAP_END_INDEX,
2913 ARMAP_END, sizeof ARMAP_END - 1) != 0)
2915 bfd_has_map (abfd) = false;
2919 /* Make sure we have the right byte ordering. */
2920 if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2921 ^ (abfd->xvec->header_byteorder_big_p != false))
2922 || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2923 ^ (abfd->xvec->byteorder_big_p != false)))
2925 bfd_set_error (bfd_error_wrong_format);
2929 /* Read in the armap. */
2930 ardata = bfd_ardata (abfd);
2931 mapdata = _bfd_snarf_ar_hdr (abfd);
2932 if (mapdata == (struct areltdata *) NULL)
2934 parsed_size = mapdata->parsed_size;
2935 bfd_release (abfd, (PTR) mapdata);
2937 raw_armap = (char *) bfd_alloc (abfd, parsed_size);
2938 if (raw_armap == (char *) NULL)
2940 bfd_set_error (bfd_error_no_memory);
2944 if (bfd_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size)
2946 if (bfd_get_error () != bfd_error_system_call)
2947 bfd_set_error (bfd_error_malformed_archive);
2948 bfd_release (abfd, (PTR) raw_armap);
2952 ardata->tdata = (PTR) raw_armap;
2954 count = bfd_h_get_32 (abfd, (PTR) raw_armap);
2956 ardata->symdef_count = 0;
2957 ardata->cache = (struct ar_cache *) NULL;
2959 /* This code used to overlay the symdefs over the raw archive data,
2960 but that doesn't work on a 64 bit host. */
2962 stringbase = raw_armap + count * 8 + 8;
2964 #ifdef CHECK_ARMAP_HASH
2968 /* Double check that I have the hashing algorithm right by making
2969 sure that every symbol can be looked up successfully. */
2971 for (i = 1; i < count; i <<= 1)
2973 BFD_ASSERT (i == count);
2975 raw_ptr = raw_armap + 4;
2976 for (i = 0; i < count; i++, raw_ptr += 8)
2978 unsigned int name_offset, file_offset;
2979 unsigned int hash, rehash, srch;
2981 name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
2982 file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4));
2983 if (file_offset == 0)
2985 hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count,
2990 /* See if we can rehash to this location. */
2991 for (srch = (hash + rehash) & (count - 1);
2992 srch != hash && srch != i;
2993 srch = (srch + rehash) & (count - 1))
2994 BFD_ASSERT (bfd_h_get_32 (abfd, (PTR) (raw_armap + 8 + srch * 8))
2996 BFD_ASSERT (srch == i);
3000 #endif /* CHECK_ARMAP_HASH */
3002 raw_ptr = raw_armap + 4;
3003 for (i = 0; i < count; i++, raw_ptr += 8)
3004 if (bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4)) != 0)
3005 ++ardata->symdef_count;
3007 symdef_ptr = ((struct symdef *)
3009 ardata->symdef_count * sizeof (struct symdef)));
3012 bfd_set_error (bfd_error_no_memory);
3016 ardata->symdefs = (carsym *) symdef_ptr;
3018 raw_ptr = raw_armap + 4;
3019 for (i = 0; i < count; i++, raw_ptr += 8)
3021 unsigned int name_offset, file_offset;
3023 file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4));
3024 if (file_offset == 0)
3026 name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
3027 symdef_ptr->s.name = stringbase + name_offset;
3028 symdef_ptr->file_offset = file_offset;
3032 ardata->first_file_filepos = bfd_tell (abfd);
3033 /* Pad to an even boundary. */
3034 ardata->first_file_filepos += ardata->first_file_filepos % 2;
3036 bfd_has_map (abfd) = true;
3041 /* Write out an armap. */
3044 _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx)
3046 unsigned int elength;
3048 unsigned int orl_count;
3051 unsigned int hashsize, hashlog;
3052 unsigned int symdefsize;
3054 unsigned int stringsize;
3055 unsigned int mapsize;
3058 struct stat statbuf;
3061 bfd_byte *hashtable;
3065 /* Ultrix appears to use as a hash table size the least power of two
3066 greater than twice the number of entries. */
3067 for (hashlog = 0; (1 << hashlog) <= 2 * orl_count; hashlog++)
3069 hashsize = 1 << hashlog;
3071 symdefsize = hashsize * 8;
3073 stringsize = stridx + padit;
3075 /* Include 8 bytes to store symdefsize and stringsize in output. */
3076 mapsize = symdefsize + stringsize + 8;
3078 firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength;
3080 memset ((PTR) &hdr, 0, sizeof hdr);
3082 /* Work out the ECOFF armap name. */
3083 strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start);
3084 hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER;
3085 hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] =
3086 (abfd->xvec->header_byteorder_big_p
3088 : ARMAP_LITTLE_ENDIAN);
3089 hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER;
3090 hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] =
3091 abfd->xvec->byteorder_big_p ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN;
3092 memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1);
3094 /* Write the timestamp of the archive header to be just a little bit
3095 later than the timestamp of the file, otherwise the linker will
3096 complain that the index is out of date. Actually, the Ultrix
3097 linker just checks the archive name; the GNU linker may check the
3099 stat (abfd->filename, &statbuf);
3100 sprintf (hdr.ar_date, "%ld", (long) (statbuf.st_mtime + 60));
3102 /* The DECstation uses zeroes for the uid, gid and mode of the
3104 hdr.ar_uid[0] = '0';
3105 hdr.ar_gid[0] = '0';
3106 hdr.ar_mode[0] = '0';
3108 sprintf (hdr.ar_size, "%-10d", (int) mapsize);
3110 hdr.ar_fmag[0] = '`';
3111 hdr.ar_fmag[1] = '\012';
3113 /* Turn all null bytes in the header into spaces. */
3114 for (i = 0; i < sizeof (struct ar_hdr); i++)
3115 if (((char *)(&hdr))[i] == '\0')
3116 (((char *)(&hdr))[i]) = ' ';
3118 if (bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), abfd)
3119 != sizeof (struct ar_hdr))
3122 bfd_h_put_32 (abfd, (bfd_vma) hashsize, temp);
3123 if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
3126 hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize);
3129 bfd_set_error (bfd_error_no_memory);
3133 current = abfd->archive_head;
3135 for (i = 0; i < orl_count; i++)
3137 unsigned int hash, rehash;
3139 /* Advance firstreal to the file position of this archive
3141 if (((bfd *) map[i].pos) != last_elt)
3145 firstreal += arelt_size (current) + sizeof (struct ar_hdr);
3146 firstreal += firstreal % 2;
3147 current = current->next;
3149 while (current != (bfd *) map[i].pos);
3154 hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog);
3155 if (bfd_h_get_32 (abfd, (PTR) (hashtable + (hash * 8) + 4)) != 0)
3159 /* The desired slot is already taken. */
3160 for (srch = (hash + rehash) & (hashsize - 1);
3162 srch = (srch + rehash) & (hashsize - 1))
3163 if (bfd_h_get_32 (abfd, (PTR) (hashtable + (srch * 8) + 4)) == 0)
3166 BFD_ASSERT (srch != hash);
3171 bfd_h_put_32 (abfd, (bfd_vma) map[i].namidx,
3172 (PTR) (hashtable + hash * 8));
3173 bfd_h_put_32 (abfd, (bfd_vma) firstreal,
3174 (PTR) (hashtable + hash * 8 + 4));
3177 if (bfd_write ((PTR) hashtable, 1, symdefsize, abfd) != symdefsize)
3180 bfd_release (abfd, hashtable);
3182 /* Now write the strings. */
3183 bfd_h_put_32 (abfd, (bfd_vma) stringsize, temp);
3184 if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
3186 for (i = 0; i < orl_count; i++)
3190 len = strlen (*map[i].name) + 1;
3191 if (bfd_write ((PTR) (*map[i].name), 1, len, abfd) != len)
3195 /* The spec sez this should be a newline. But in order to be
3196 bug-compatible for DECstation ar we use a null. */
3199 if (bfd_write ("", 1, 1, abfd) != 1)
3206 /* See whether this BFD is an archive. If it is, read in the armap
3207 and the extended name table. */
3210 _bfd_ecoff_archive_p (abfd)
3213 char armag[SARMAG + 1];
3215 if (bfd_read ((PTR) armag, 1, SARMAG, abfd) != SARMAG
3216 || strncmp (armag, ARMAG, SARMAG) != 0)
3218 if (bfd_get_error () != bfd_error_system_call)
3219 bfd_set_error (bfd_error_wrong_format);
3220 return (const bfd_target *) NULL;
3223 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
3224 involves a cast, we can't do it as the left operand of
3226 abfd->tdata.aout_ar_data =
3227 (struct artdata *) bfd_zalloc (abfd, sizeof (struct artdata));
3229 if (bfd_ardata (abfd) == (struct artdata *) NULL)
3231 bfd_set_error (bfd_error_no_memory);
3232 return (const bfd_target *) NULL;
3235 bfd_ardata (abfd)->first_file_filepos = SARMAG;
3236 bfd_ardata (abfd)->cache = NULL;
3237 bfd_ardata (abfd)->archive_head = NULL;
3238 bfd_ardata (abfd)->symdefs = NULL;
3239 bfd_ardata (abfd)->extended_names = NULL;
3240 bfd_ardata (abfd)->tdata = NULL;
3242 if (_bfd_ecoff_slurp_armap (abfd) == false
3243 || _bfd_ecoff_slurp_extended_name_table (abfd) == false)
3245 bfd_release (abfd, bfd_ardata (abfd));
3246 abfd->tdata.aout_ar_data = (struct artdata *) NULL;
3247 return (const bfd_target *) NULL;
3253 /* ECOFF linker code. */
3255 static struct bfd_hash_entry *ecoff_link_hash_newfunc
3256 PARAMS ((struct bfd_hash_entry *entry,
3257 struct bfd_hash_table *table,
3258 const char *string));
3259 static boolean ecoff_link_add_archive_symbols
3260 PARAMS ((bfd *, struct bfd_link_info *));
3261 static boolean ecoff_link_check_archive_element
3262 PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
3263 static boolean ecoff_link_add_object_symbols
3264 PARAMS ((bfd *, struct bfd_link_info *));
3265 static boolean ecoff_link_add_externals
3266 PARAMS ((bfd *, struct bfd_link_info *, PTR, char *));
3268 /* Routine to create an entry in an ECOFF link hash table. */
3270 static struct bfd_hash_entry *
3271 ecoff_link_hash_newfunc (entry, table, string)
3272 struct bfd_hash_entry *entry;
3273 struct bfd_hash_table *table;
3276 struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry;
3278 /* Allocate the structure if it has not already been allocated by a
3280 if (ret == (struct ecoff_link_hash_entry *) NULL)
3281 ret = ((struct ecoff_link_hash_entry *)
3282 bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry)));
3283 if (ret == (struct ecoff_link_hash_entry *) NULL)
3285 bfd_set_error (bfd_error_no_memory);
3289 /* Call the allocation method of the superclass. */
3290 ret = ((struct ecoff_link_hash_entry *)
3291 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3296 /* Set local fields. */
3302 memset ((PTR) &ret->esym, 0, sizeof ret->esym);
3304 return (struct bfd_hash_entry *) ret;
3307 /* Create an ECOFF link hash table. */
3309 struct bfd_link_hash_table *
3310 _bfd_ecoff_bfd_link_hash_table_create (abfd)
3313 struct ecoff_link_hash_table *ret;
3315 ret = ((struct ecoff_link_hash_table *)
3316 bfd_alloc (abfd, sizeof (struct ecoff_link_hash_table)));
3319 bfd_set_error (bfd_error_no_memory);
3322 if (! _bfd_link_hash_table_init (&ret->root, abfd,
3323 ecoff_link_hash_newfunc))
3326 return (struct bfd_link_hash_table *) NULL;
3331 /* Look up an entry in an ECOFF link hash table. */
3333 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3334 ((struct ecoff_link_hash_entry *) \
3335 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3337 /* Traverse an ECOFF link hash table. */
3339 #define ecoff_link_hash_traverse(table, func, info) \
3340 (bfd_link_hash_traverse \
3342 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
3345 /* Get the ECOFF link hash table from the info structure. This is
3348 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3350 /* Given an ECOFF BFD, add symbols to the global hash table as
3354 _bfd_ecoff_bfd_link_add_symbols (abfd, info)
3356 struct bfd_link_info *info;
3358 switch (bfd_get_format (abfd))
3361 return ecoff_link_add_object_symbols (abfd, info);
3363 return ecoff_link_add_archive_symbols (abfd, info);
3365 bfd_set_error (bfd_error_wrong_format);
3370 /* Add the symbols from an archive file to the global hash table.
3371 This looks through the undefined symbols, looks each one up in the
3372 archive hash table, and adds any associated object file. We do not
3373 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3374 already have a hash table, so there is no reason to construct
3378 ecoff_link_add_archive_symbols (abfd, info)
3380 struct bfd_link_info *info;
3382 const bfd_byte *raw_armap;
3383 struct bfd_link_hash_entry **pundef;
3384 unsigned int armap_count;
3385 unsigned int armap_log;
3387 const bfd_byte *hashtable;
3388 const char *stringbase;
3390 if (! bfd_has_map (abfd))
3392 /* An empty archive is a special case. */
3393 if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
3395 bfd_set_error (bfd_error_no_armap);
3399 /* If we don't have any raw data for this archive, as can happen on
3400 Irix 4.0.5F, we call the generic routine.
3401 FIXME: We should be more clever about this, since someday tdata
3402 may get to something for a generic archive. */
3403 raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata;
3404 if (raw_armap == (bfd_byte *) NULL)
3405 return (_bfd_generic_link_add_archive_symbols
3406 (abfd, info, ecoff_link_check_archive_element));
3408 armap_count = bfd_h_get_32 (abfd, raw_armap);
3411 for (i = 1; i < armap_count; i <<= 1)
3413 BFD_ASSERT (i == armap_count);
3415 hashtable = raw_armap + 4;
3416 stringbase = (const char *) raw_armap + armap_count * 8 + 8;
3418 /* Look through the list of undefined symbols. */
3419 pundef = &info->hash->undefs;
3420 while (*pundef != (struct bfd_link_hash_entry *) NULL)
3422 struct bfd_link_hash_entry *h;
3423 unsigned int hash, rehash;
3424 unsigned int file_offset;
3430 /* When a symbol is defined, it is not necessarily removed from
3432 if (h->type != bfd_link_hash_undefined
3433 && h->type != bfd_link_hash_common)
3435 /* Remove this entry from the list, for general cleanliness
3436 and because we are going to look through the list again
3437 if we search any more libraries. We can't remove the
3438 entry if it is the tail, because that would lose any
3439 entries we add to the list later on. */
3440 if (*pundef != info->hash->undefs_tail)
3441 *pundef = (*pundef)->next;
3443 pundef = &(*pundef)->next;
3447 /* Native ECOFF linkers do not pull in archive elements merely
3448 to satisfy common definitions, so neither do we. We leave
3449 them on the list, though, in case we are linking against some
3450 other object format. */
3451 if (h->type != bfd_link_hash_undefined)
3453 pundef = &(*pundef)->next;
3457 /* Look for this symbol in the archive hash table. */
3458 hash = ecoff_armap_hash (h->root.string, &rehash, armap_count,
3461 file_offset = bfd_h_get_32 (abfd, hashtable + (hash * 8) + 4);
3462 if (file_offset == 0)
3464 /* Nothing in this slot. */
3465 pundef = &(*pundef)->next;
3469 name = stringbase + bfd_h_get_32 (abfd, hashtable + (hash * 8));
3470 if (name[0] != h->root.string[0]
3471 || strcmp (name, h->root.string) != 0)
3476 /* That was the wrong symbol. Try rehashing. */
3478 for (srch = (hash + rehash) & (armap_count - 1);
3480 srch = (srch + rehash) & (armap_count - 1))
3482 file_offset = bfd_h_get_32 (abfd, hashtable + (srch * 8) + 4);
3483 if (file_offset == 0)
3485 name = stringbase + bfd_h_get_32 (abfd, hashtable + (srch * 8));
3486 if (name[0] == h->root.string[0]
3487 && strcmp (name, h->root.string) == 0)
3496 pundef = &(*pundef)->next;
3503 element = _bfd_get_elt_at_filepos (abfd, file_offset);
3504 if (element == (bfd *) NULL)
3507 if (! bfd_check_format (element, bfd_object))
3510 /* Unlike the generic linker, we know that this element provides
3511 a definition for an undefined symbol and we know that we want
3512 to include it. We don't need to check anything. */
3513 if (! (*info->callbacks->add_archive_element) (info, element, name))
3515 if (! ecoff_link_add_object_symbols (element, info))
3518 pundef = &(*pundef)->next;
3524 /* This is called if we used _bfd_generic_link_add_archive_symbols
3525 because we were not dealing with an ECOFF archive. */
3528 ecoff_link_check_archive_element (abfd, info, pneeded)
3530 struct bfd_link_info *info;
3533 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3534 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
3535 = backend->debug_swap.swap_ext_in;
3537 bfd_size_type external_ext_size;
3538 PTR external_ext = NULL;
3546 if (! ecoff_slurp_symbolic_header (abfd))
3549 /* If there are no symbols, we don't want it. */
3550 if (bfd_get_symcount (abfd) == 0)
3551 goto successful_return;
3553 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3555 /* Read in the external symbols and external strings. */
3556 external_ext_size = backend->debug_swap.external_ext_size;
3557 esize = symhdr->iextMax * external_ext_size;
3558 external_ext = (PTR) malloc (esize);
3559 if (external_ext == NULL && esize != 0)
3561 bfd_set_error (bfd_error_no_memory);
3565 if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
3566 || bfd_read (external_ext, 1, esize, abfd) != esize)
3569 ssext = (char *) malloc (symhdr->issExtMax);
3570 if (ssext == NULL && symhdr->issExtMax != 0)
3572 bfd_set_error (bfd_error_no_memory);
3576 if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
3577 || (bfd_read (ssext, 1, symhdr->issExtMax, abfd) !=
3578 (bfd_size_type) symhdr->issExtMax))
3581 /* Look through the external symbols to see if they define some
3582 symbol that is currently undefined. */
3583 ext_ptr = (char *) external_ext;
3584 ext_end = ext_ptr + esize;
3585 for (; ext_ptr < ext_end; ext_ptr += external_ext_size)
3590 struct bfd_link_hash_entry *h;
3592 (*swap_ext_in) (abfd, (PTR) ext_ptr, &esym);
3594 /* See if this symbol defines something. */
3595 if (esym.asym.st != stGlobal
3596 && esym.asym.st != stLabel
3597 && esym.asym.st != stProc)
3600 switch (esym.asym.sc)
3623 name = ssext + esym.asym.iss;
3624 h = bfd_link_hash_lookup (info->hash, name, false, false, true);
3626 /* Unlike the generic linker, we do not pull in elements because
3627 of common symbols. */
3628 if (h == (struct bfd_link_hash_entry *) NULL
3629 || h->type != bfd_link_hash_undefined)
3632 /* Include this element. */
3633 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3635 if (! ecoff_link_add_externals (abfd, info, external_ext, ssext))
3639 goto successful_return;
3643 if (external_ext != NULL)
3644 free (external_ext);
3649 if (external_ext != NULL)
3650 free (external_ext);
3656 /* Add symbols from an ECOFF object file to the global linker hash
3660 ecoff_link_add_object_symbols (abfd, info)
3662 struct bfd_link_info *info;
3665 bfd_size_type external_ext_size;
3666 PTR external_ext = NULL;
3671 if (! ecoff_slurp_symbolic_header (abfd))
3674 /* If there are no symbols, we don't want it. */
3675 if (bfd_get_symcount (abfd) == 0)
3678 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3680 /* Read in the external symbols and external strings. */
3681 external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size;
3682 esize = symhdr->iextMax * external_ext_size;
3683 external_ext = (PTR) malloc (esize);
3684 if (external_ext == NULL && esize != 0)
3686 bfd_set_error (bfd_error_no_memory);
3690 if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
3691 || bfd_read (external_ext, 1, esize, abfd) != esize)
3694 ssext = (char *) malloc (symhdr->issExtMax);
3695 if (ssext == NULL && symhdr->issExtMax != 0)
3697 bfd_set_error (bfd_error_no_memory);
3701 if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
3702 || (bfd_read (ssext, 1, symhdr->issExtMax, abfd)
3703 != (bfd_size_type) symhdr->issExtMax))
3706 result = ecoff_link_add_externals (abfd, info, external_ext, ssext);
3710 if (external_ext != NULL)
3711 free (external_ext);
3717 if (external_ext != NULL)
3718 free (external_ext);
3722 /* Add the external symbols of an object file to the global linker
3723 hash table. The external symbols and strings we are passed are
3724 just allocated on the stack, and will be discarded. We must
3725 explicitly save any information we may need later on in the link.
3726 We do not want to read the external symbol information again. */
3729 ecoff_link_add_externals (abfd, info, external_ext, ssext)
3731 struct bfd_link_info *info;
3735 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3736 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
3737 = backend->debug_swap.swap_ext_in;
3738 bfd_size_type external_ext_size = backend->debug_swap.external_ext_size;
3739 unsigned long ext_count;
3740 struct ecoff_link_hash_entry **sym_hash;
3744 ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
3746 sym_hash = ((struct ecoff_link_hash_entry **)
3748 ext_count * sizeof (struct bfd_link_hash_entry *)));
3751 bfd_set_error (bfd_error_no_memory);
3754 ecoff_data (abfd)->sym_hashes = sym_hash;
3756 ext_ptr = (char *) external_ext;
3757 ext_end = ext_ptr + ext_count * external_ext_size;
3758 for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++)
3765 struct ecoff_link_hash_entry *h;
3769 (*swap_ext_in) (abfd, (PTR) ext_ptr, &esym);
3771 /* Skip debugging symbols. */
3773 switch (esym.asym.st)
3789 /* Get the information for this symbol. */
3790 value = esym.asym.value;
3791 switch (esym.asym.sc)
3811 section = bfd_make_section_old_way (abfd, ".text");
3812 value -= section->vma;
3815 section = bfd_make_section_old_way (abfd, ".data");
3816 value -= section->vma;
3819 section = bfd_make_section_old_way (abfd, ".bss");
3820 value -= section->vma;
3823 section = bfd_abs_section_ptr;
3826 section = bfd_und_section_ptr;
3829 section = bfd_make_section_old_way (abfd, ".sdata");
3830 value -= section->vma;
3833 section = bfd_make_section_old_way (abfd, ".sbss");
3834 value -= section->vma;
3837 section = bfd_make_section_old_way (abfd, ".rdata");
3838 value -= section->vma;
3841 if (value > ecoff_data (abfd)->gp_size)
3843 section = bfd_com_section_ptr;
3848 if (ecoff_scom_section.name == NULL)
3850 /* Initialize the small common section. */
3851 ecoff_scom_section.name = SCOMMON;
3852 ecoff_scom_section.flags = SEC_IS_COMMON;
3853 ecoff_scom_section.output_section = &ecoff_scom_section;
3854 ecoff_scom_section.symbol = &ecoff_scom_symbol;
3855 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
3856 ecoff_scom_symbol.name = SCOMMON;
3857 ecoff_scom_symbol.flags = BSF_SECTION_SYM;
3858 ecoff_scom_symbol.section = &ecoff_scom_section;
3859 ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
3861 section = &ecoff_scom_section;
3864 section = bfd_und_section_ptr;
3867 section = bfd_make_section_old_way (abfd, ".init");
3868 value -= section->vma;
3871 section = bfd_make_section_old_way (abfd, ".fini");
3872 value -= section->vma;
3876 if (section == (asection *) NULL)
3879 name = ssext + esym.asym.iss;
3882 if (! (_bfd_generic_link_add_one_symbol
3883 (info, abfd, name, BSF_GLOBAL, section, value,
3884 (const char *) NULL, true, true,
3885 (struct bfd_link_hash_entry **) &h)))
3890 /* If we are building an ECOFF hash table, save the external
3891 symbol information. */
3892 if (info->hash->creator->flavour == bfd_get_flavour (abfd))
3894 if (h->abfd == (bfd *) NULL
3895 || (! bfd_is_und_section (section)
3896 && (! bfd_is_com_section (section)
3897 || (h->root.type != bfd_link_hash_defined
3898 && h->root.type != bfd_link_hash_defweak))))
3904 /* Remember whether this symbol was small undefined. */
3905 if (esym.asym.sc == scSUndefined)
3908 /* If this symbol was ever small undefined, it needs to wind
3909 up in a GP relative section. We can't control the
3910 section of a defined symbol, but we can control the
3911 section of a common symbol. This case is actually needed
3912 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3914 && h->root.type == bfd_link_hash_common
3915 && strcmp (h->root.u.c.p->section->name, SCOMMON) != 0)
3917 h->root.u.c.p->section = bfd_make_section_old_way (abfd,
3919 h->root.u.c.p->section->flags = SEC_ALLOC;
3920 if (h->esym.asym.sc == scCommon)
3921 h->esym.asym.sc = scSCommon;
3929 /* ECOFF final link routines. */
3931 static boolean ecoff_final_link_debug_accumulate
3932 PARAMS ((bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *,
3934 static boolean ecoff_link_write_external
3935 PARAMS ((struct ecoff_link_hash_entry *, PTR));
3936 static boolean ecoff_indirect_link_order
3937 PARAMS ((bfd *, struct bfd_link_info *, asection *,
3938 struct bfd_link_order *));
3939 static boolean ecoff_reloc_link_order
3940 PARAMS ((bfd *, struct bfd_link_info *, asection *,
3941 struct bfd_link_order *));
3943 /* ECOFF final link routine. This looks through all the input BFDs
3944 and gathers together all the debugging information, and then
3945 processes all the link order information. This may cause it to
3946 close and reopen some input BFDs; I'll see how bad this is. */
3949 _bfd_ecoff_bfd_final_link (abfd, info)
3951 struct bfd_link_info *info;
3953 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3954 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
3957 register bfd *input_bfd;
3959 struct bfd_link_order *p;
3961 /* We accumulate the debugging information counts in the symbolic
3963 symhdr = &debug->symbolic_header;
3965 symhdr->ilineMax = 0;
3969 symhdr->isymMax = 0;
3970 symhdr->ioptMax = 0;
3971 symhdr->iauxMax = 0;
3973 symhdr->issExtMax = 0;
3976 symhdr->iextMax = 0;
3978 /* We accumulate the debugging information itself in the debug_info
3981 debug->external_dnr = NULL;
3982 debug->external_pdr = NULL;
3983 debug->external_sym = NULL;
3984 debug->external_opt = NULL;
3985 debug->external_aux = NULL;
3987 debug->ssext = debug->ssext_end = NULL;
3988 debug->external_fdr = NULL;
3989 debug->external_rfd = NULL;
3990 debug->external_ext = debug->external_ext_end = NULL;
3992 handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info);
3993 if (handle == (PTR) NULL)
3996 /* Accumulate the debugging symbols from each input BFD. */
3997 for (input_bfd = info->input_bfds;
3998 input_bfd != (bfd *) NULL;
3999 input_bfd = input_bfd->link_next)
4003 if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour)
4005 /* Abitrarily set the symbolic header vstamp to the vstamp
4006 of the first object file in the link. */
4007 if (symhdr->vstamp == 0)
4009 = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp;
4010 ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info,
4014 ret = bfd_ecoff_debug_accumulate_other (handle, abfd,
4015 debug, &backend->debug_swap,
4020 /* Combine the register masks. */
4021 ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask;
4022 ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask;
4023 ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0];
4024 ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1];
4025 ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2];
4026 ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3];
4029 /* Write out the external symbols. */
4030 ecoff_link_hash_traverse (ecoff_hash_table (info),
4031 ecoff_link_write_external,
4034 if (info->relocateable)
4036 /* We need to make a pass over the link_orders to count up the
4037 number of relocations we will need to output, so that we know
4038 how much space they will take up. */
4039 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4042 for (p = o->link_order_head;
4043 p != (struct bfd_link_order *) NULL;
4045 if (p->type == bfd_indirect_link_order)
4046 o->reloc_count += p->u.indirect.section->reloc_count;
4047 else if (p->type == bfd_section_reloc_link_order
4048 || p->type == bfd_symbol_reloc_link_order)
4053 /* Compute the reloc and symbol file positions. */
4054 ecoff_compute_reloc_file_positions (abfd);
4056 /* Write out the debugging information. */
4057 if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug,
4058 &backend->debug_swap, info,
4059 ecoff_data (abfd)->sym_filepos))
4062 bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info);
4064 if (info->relocateable)
4066 /* Now reset the reloc_count field of the sections in the output
4067 BFD to 0, so that we can use them to keep track of how many
4068 relocs we have output thus far. */
4069 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4073 /* Get a value for the GP register. */
4074 if (ecoff_data (abfd)->gp == 0)
4076 struct bfd_link_hash_entry *h;
4078 h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
4079 if (h != (struct bfd_link_hash_entry *) NULL
4080 && h->type == bfd_link_hash_defined)
4081 ecoff_data (abfd)->gp = (h->u.def.value
4082 + h->u.def.section->output_section->vma
4083 + h->u.def.section->output_offset);
4084 else if (info->relocateable)
4088 /* Make up a value. */
4090 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4093 && (strcmp (o->name, _SBSS) == 0
4094 || strcmp (o->name, _SDATA) == 0
4095 || strcmp (o->name, _LIT4) == 0
4096 || strcmp (o->name, _LIT8) == 0
4097 || strcmp (o->name, _LITA) == 0))
4100 ecoff_data (abfd)->gp = lo + 0x8000;
4104 /* If the relocate_section function needs to do a reloc
4105 involving the GP value, it should make a reloc_dangerous
4106 callback to warn that GP is not defined. */
4110 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4112 for (p = o->link_order_head;
4113 p != (struct bfd_link_order *) NULL;
4116 if (p->type == bfd_indirect_link_order
4117 && (bfd_get_flavour (p->u.indirect.section->owner)
4118 == bfd_target_ecoff_flavour))
4120 if (! ecoff_indirect_link_order (abfd, info, o, p))
4123 else if (p->type == bfd_section_reloc_link_order
4124 || p->type == bfd_symbol_reloc_link_order)
4126 if (! ecoff_reloc_link_order (abfd, info, o, p))
4131 if (! _bfd_default_link_order (abfd, info, o, p))
4137 bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax;
4139 ecoff_data (abfd)->linker = true;
4144 /* Accumulate the debugging information for an input BFD into the
4145 output BFD. This must read in the symbolic information of the
4149 ecoff_final_link_debug_accumulate (output_bfd, input_bfd, info, handle)
4152 struct bfd_link_info *info;
4155 struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info;
4156 const struct ecoff_debug_swap * const swap =
4157 &ecoff_backend (input_bfd)->debug_swap;
4158 HDRR *symhdr = &debug->symbolic_header;
4161 #define READ(ptr, offset, count, size, type) \
4162 if (symhdr->count == 0) \
4163 debug->ptr = NULL; \
4166 debug->ptr = (type) malloc ((size_t) (size * symhdr->count)); \
4167 if (debug->ptr == NULL) \
4169 bfd_set_error (bfd_error_no_memory); \
4171 goto return_something; \
4173 if ((bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) \
4175 || (bfd_read (debug->ptr, size, symhdr->count, \
4176 input_bfd) != size * symhdr->count)) \
4179 goto return_something; \
4183 /* If raw_syments is not NULL, then the data was already by read by
4184 _bfd_ecoff_slurp_symbolic_info. */
4185 if (ecoff_data (input_bfd)->raw_syments == NULL)
4187 READ (line, cbLineOffset, cbLine, sizeof (unsigned char),
4189 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
4190 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
4191 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
4192 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
4193 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
4195 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
4196 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
4197 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
4201 /* We do not read the external strings or the external symbols. */
4203 ret = (bfd_ecoff_debug_accumulate
4204 (handle, output_bfd, &ecoff_data (output_bfd)->debug_info,
4205 &ecoff_backend (output_bfd)->debug_swap,
4206 input_bfd, debug, swap, info));
4209 if (ecoff_data (input_bfd)->raw_syments == NULL)
4211 if (debug->line != NULL)
4213 if (debug->external_dnr != NULL)
4214 free (debug->external_dnr);
4215 if (debug->external_pdr != NULL)
4216 free (debug->external_pdr);
4217 if (debug->external_sym != NULL)
4218 free (debug->external_sym);
4219 if (debug->external_opt != NULL)
4220 free (debug->external_opt);
4221 if (debug->external_aux != NULL)
4222 free (debug->external_aux);
4223 if (debug->ss != NULL)
4225 if (debug->external_fdr != NULL)
4226 free (debug->external_fdr);
4227 if (debug->external_rfd != NULL)
4228 free (debug->external_rfd);
4230 /* Make sure we don't accidentally follow one of these pointers
4231 into freed memory. */
4233 debug->external_dnr = NULL;
4234 debug->external_pdr = NULL;
4235 debug->external_sym = NULL;
4236 debug->external_opt = NULL;
4237 debug->external_aux = NULL;
4239 debug->external_fdr = NULL;
4240 debug->external_rfd = NULL;
4246 /* Put out information for an external symbol. These come only from
4250 ecoff_link_write_external (h, data)
4251 struct ecoff_link_hash_entry *h;
4254 bfd *output_bfd = (bfd *) data;
4256 /* FIXME: We should check if this symbol is being stripped. */
4261 if (h->abfd == (bfd *) NULL)
4264 h->esym.cobol_main = 0;
4265 h->esym.weakext = 0;
4266 h->esym.reserved = 0;
4267 h->esym.ifd = ifdNil;
4268 h->esym.asym.value = 0;
4269 h->esym.asym.st = stGlobal;
4271 if (h->root.type != bfd_link_hash_defined
4272 && h->root.type != bfd_link_hash_defweak)
4273 h->esym.asym.sc = scAbs;
4276 asection *output_section;
4279 output_section = h->root.u.def.section->output_section;
4280 name = bfd_section_name (output_section->owner, output_section);
4282 if (strcmp (name, _TEXT) == 0)
4283 h->esym.asym.sc = scText;
4284 else if (strcmp (name, _DATA) == 0)
4285 h->esym.asym.sc = scData;
4286 else if (strcmp (name, _SDATA) == 0)
4287 h->esym.asym.sc = scSData;
4288 else if (strcmp (name, _RDATA) == 0)
4289 h->esym.asym.sc = scRData;
4290 else if (strcmp (name, _BSS) == 0)
4291 h->esym.asym.sc = scBss;
4292 else if (strcmp (name, _SBSS) == 0)
4293 h->esym.asym.sc = scSBss;
4294 else if (strcmp (name, _INIT) == 0)
4295 h->esym.asym.sc = scInit;
4296 else if (strcmp (name, _FINI) == 0)
4297 h->esym.asym.sc = scFini;
4298 else if (strcmp (name, _PDATA) == 0)
4299 h->esym.asym.sc = scPData;
4300 else if (strcmp (name, _XDATA) == 0)
4301 h->esym.asym.sc = scXData;
4303 h->esym.asym.sc = scAbs;
4306 h->esym.asym.reserved = 0;
4307 h->esym.asym.index = indexNil;
4309 else if (h->esym.ifd != -1)
4311 struct ecoff_debug_info *debug;
4313 /* Adjust the FDR index for the symbol by that used for the
4315 debug = &ecoff_data (h->abfd)->debug_info;
4316 BFD_ASSERT (h->esym.ifd >= 0
4317 && h->esym.ifd < debug->symbolic_header.ifdMax);
4318 h->esym.ifd = debug->ifdmap[h->esym.ifd];
4321 switch (h->root.type)
4324 case bfd_link_hash_new:
4326 case bfd_link_hash_undefined:
4327 case bfd_link_hash_undefweak:
4328 if (h->esym.asym.sc != scUndefined
4329 && h->esym.asym.sc != scSUndefined)
4330 h->esym.asym.sc = scUndefined;
4332 case bfd_link_hash_defined:
4333 case bfd_link_hash_defweak:
4334 if (h->esym.asym.sc == scUndefined
4335 || h->esym.asym.sc == scSUndefined)
4336 h->esym.asym.sc = scAbs;
4337 else if (h->esym.asym.sc == scCommon)
4338 h->esym.asym.sc = scBss;
4339 else if (h->esym.asym.sc == scSCommon)
4340 h->esym.asym.sc = scSBss;
4341 h->esym.asym.value = (h->root.u.def.value
4342 + h->root.u.def.section->output_section->vma
4343 + h->root.u.def.section->output_offset);
4345 case bfd_link_hash_common:
4346 if (h->esym.asym.sc != scCommon
4347 && h->esym.asym.sc != scSCommon)
4348 h->esym.asym.sc = scCommon;
4349 h->esym.asym.value = h->root.u.c.size;
4351 case bfd_link_hash_indirect:
4352 case bfd_link_hash_warning:
4353 /* FIXME: Ignore these for now. The circumstances under which
4354 they should be written out are not clear to me. */
4358 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4360 h->indx = ecoff_data (output_bfd)->debug_info.symbolic_header.iextMax;
4363 return (bfd_ecoff_debug_one_external
4364 (output_bfd, &ecoff_data (output_bfd)->debug_info,
4365 &ecoff_backend (output_bfd)->debug_swap, h->root.root.string,
4369 /* Relocate and write an ECOFF section into an ECOFF output file. */
4372 ecoff_indirect_link_order (output_bfd, info, output_section, link_order)
4374 struct bfd_link_info *info;
4375 asection *output_section;
4376 struct bfd_link_order *link_order;
4378 asection *input_section;
4380 struct ecoff_section_tdata *section_tdata;
4381 bfd_size_type raw_size;
4382 bfd_size_type cooked_size;
4383 bfd_byte *contents = NULL;
4384 bfd_size_type external_reloc_size;
4385 bfd_size_type external_relocs_size;
4386 PTR external_relocs = NULL;
4388 BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
4390 if (link_order->size == 0)
4393 input_section = link_order->u.indirect.section;
4394 input_bfd = input_section->owner;
4395 section_tdata = ecoff_section_data (input_bfd, input_section);
4397 raw_size = input_section->_raw_size;
4398 cooked_size = input_section->_cooked_size;
4399 if (cooked_size == 0)
4400 cooked_size = raw_size;
4402 BFD_ASSERT (input_section->output_section == output_section);
4403 BFD_ASSERT (input_section->output_offset == link_order->offset);
4404 BFD_ASSERT (cooked_size == link_order->size);
4406 /* Get the section contents. We allocate memory for the larger of
4407 the size before relocating and the size after relocating. */
4408 contents = (bfd_byte *) malloc (raw_size >= cooked_size
4410 : (size_t) cooked_size);
4411 if (contents == NULL && raw_size != 0)
4413 bfd_set_error (bfd_error_no_memory);
4417 /* If we are relaxing, the contents may have already been read into
4418 memory, in which case we copy them into our new buffer. We don't
4419 simply reuse the old buffer in case cooked_size > raw_size. */
4420 if (section_tdata != (struct ecoff_section_tdata *) NULL
4421 && section_tdata->contents != (bfd_byte *) NULL)
4422 memcpy (contents, section_tdata->contents, (size_t) raw_size);
4425 if (! bfd_get_section_contents (input_bfd, input_section,
4427 (file_ptr) 0, raw_size))
4431 /* Get the relocs. If we are relaxing MIPS code, they will already
4432 have been read in. Otherwise, we read them in now. */
4433 external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size;
4434 external_relocs_size = external_reloc_size * input_section->reloc_count;
4436 if (section_tdata != (struct ecoff_section_tdata *) NULL)
4437 external_relocs = section_tdata->external_relocs;
4440 external_relocs = (PTR) malloc ((size_t) external_relocs_size);
4441 if (external_relocs == NULL && external_relocs_size != 0)
4443 bfd_set_error (bfd_error_no_memory);
4447 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4448 || (bfd_read (external_relocs, 1, external_relocs_size, input_bfd)
4449 != external_relocs_size))
4453 /* Relocate the section contents. */
4454 if (! ((*ecoff_backend (input_bfd)->relocate_section)
4455 (output_bfd, info, input_bfd, input_section, contents,
4459 /* Write out the relocated section. */
4460 if (! bfd_set_section_contents (output_bfd,
4463 input_section->output_offset,
4467 /* If we are producing relocateable output, the relocs were
4468 modified, and we write them out now. We use the reloc_count
4469 field of output_section to keep track of the number of relocs we
4470 have output so far. */
4471 if (info->relocateable)
4473 if (bfd_seek (output_bfd,
4474 (output_section->rel_filepos +
4475 output_section->reloc_count * external_reloc_size),
4477 || (bfd_write (external_relocs, 1, external_relocs_size, output_bfd)
4478 != external_relocs_size))
4480 output_section->reloc_count += input_section->reloc_count;
4483 if (contents != NULL)
4485 if (external_relocs != NULL && section_tdata == NULL)
4486 free (external_relocs);
4490 if (contents != NULL)
4492 if (external_relocs != NULL && section_tdata == NULL)
4493 free (external_relocs);
4497 /* Generate a reloc when linking an ECOFF file. This is a reloc
4498 requested by the linker, and does come from any input file. This
4499 is used to build constructor and destructor tables when linking
4503 ecoff_reloc_link_order (output_bfd, info, output_section, link_order)
4505 struct bfd_link_info *info;
4506 asection *output_section;
4507 struct bfd_link_order *link_order;
4510 struct internal_reloc in;
4511 bfd_size_type external_reloc_size;
4515 /* We set up an arelent to pass to the backend adjust_reloc_out
4517 rel.address = link_order->offset;
4519 rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
4522 bfd_set_error (bfd_error_bad_value);
4526 if (link_order->type == bfd_section_reloc_link_order)
4527 rel.sym_ptr_ptr = link_order->u.reloc.p->u.section->symbol_ptr_ptr;
4530 /* We can't set up a reloc against a symbol correctly, because
4531 we have no asymbol structure. Currently no adjust_reloc_out
4533 rel.sym_ptr_ptr = (asymbol **) NULL;
4536 /* All ECOFF relocs are in-place. Put the addend into the object
4539 BFD_ASSERT (rel.howto->partial_inplace);
4540 if (link_order->u.reloc.p->addend != 0)
4543 bfd_reloc_status_type rstat;
4547 size = bfd_get_reloc_size (rel.howto);
4548 buf = (bfd_byte *) bfd_zmalloc (size);
4549 if (buf == (bfd_byte *) NULL)
4551 bfd_set_error (bfd_error_no_memory);
4554 rstat = _bfd_relocate_contents (rel.howto, output_bfd,
4555 link_order->u.reloc.p->addend, buf);
4561 case bfd_reloc_outofrange:
4563 case bfd_reloc_overflow:
4564 if (! ((*info->callbacks->reloc_overflow)
4566 (link_order->type == bfd_section_reloc_link_order
4567 ? bfd_section_name (output_bfd,
4568 link_order->u.reloc.p->u.section)
4569 : link_order->u.reloc.p->u.name),
4570 rel.howto->name, link_order->u.reloc.p->addend,
4571 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
4578 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
4579 (file_ptr) link_order->offset, size);
4587 /* Move the information into a internal_reloc structure. */
4588 in.r_vaddr = (rel.address
4589 + bfd_get_section_vma (output_bfd, output_section));
4590 in.r_type = rel.howto->type;
4592 if (link_order->type == bfd_symbol_reloc_link_order)
4594 struct ecoff_link_hash_entry *h;
4596 h = ecoff_link_hash_lookup (ecoff_hash_table (info),
4597 link_order->u.reloc.p->u.name,
4598 false, false, true);
4599 if (h != (struct ecoff_link_hash_entry *) NULL
4601 in.r_symndx = h->indx;
4604 if (! ((*info->callbacks->unattached_reloc)
4605 (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
4606 (asection *) NULL, (bfd_vma) 0)))
4616 name = bfd_get_section_name (output_bfd,
4617 link_order->u.reloc.p->u.section);
4618 if (strcmp (name, ".text") == 0)
4619 in.r_symndx = RELOC_SECTION_TEXT;
4620 else if (strcmp (name, ".rdata") == 0)
4621 in.r_symndx = RELOC_SECTION_RDATA;
4622 else if (strcmp (name, ".data") == 0)
4623 in.r_symndx = RELOC_SECTION_DATA;
4624 else if (strcmp (name, ".sdata") == 0)
4625 in.r_symndx = RELOC_SECTION_SDATA;
4626 else if (strcmp (name, ".sbss") == 0)
4627 in.r_symndx = RELOC_SECTION_SBSS;
4628 else if (strcmp (name, ".bss") == 0)
4629 in.r_symndx = RELOC_SECTION_BSS;
4630 else if (strcmp (name, ".init") == 0)
4631 in.r_symndx = RELOC_SECTION_INIT;
4632 else if (strcmp (name, ".lit8") == 0)
4633 in.r_symndx = RELOC_SECTION_LIT8;
4634 else if (strcmp (name, ".lit4") == 0)
4635 in.r_symndx = RELOC_SECTION_LIT4;
4636 else if (strcmp (name, ".xdata") == 0)
4637 in.r_symndx = RELOC_SECTION_XDATA;
4638 else if (strcmp (name, ".pdata") == 0)
4639 in.r_symndx = RELOC_SECTION_PDATA;
4640 else if (strcmp (name, ".fini") == 0)
4641 in.r_symndx = RELOC_SECTION_FINI;
4642 else if (strcmp (name, ".lita") == 0)
4643 in.r_symndx = RELOC_SECTION_LITA;
4644 else if (strcmp (name, "*ABS*") == 0)
4645 in.r_symndx = RELOC_SECTION_ABS;
4651 /* Let the BFD backend adjust the reloc. */
4652 (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in);
4654 /* Get some memory and swap out the reloc. */
4655 external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
4656 rbuf = (bfd_byte *) malloc ((size_t) external_reloc_size);
4657 if (rbuf == (bfd_byte *) NULL)
4659 bfd_set_error (bfd_error_no_memory);
4663 (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (PTR) rbuf);
4665 ok = (bfd_seek (output_bfd,
4666 (output_section->rel_filepos +
4667 output_section->reloc_count * external_reloc_size),
4669 && (bfd_write ((PTR) rbuf, 1, external_reloc_size, output_bfd)
4670 == external_reloc_size));
4673 ++output_section->reloc_count;