1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright 1990, 91, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
3 Original version by Per Bothner.
4 Full support added by Ian Lance Taylor, ian@cygnus.com.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 #include "aout/ranlib.h"
28 #include "aout/stab_gnu.h"
30 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
31 some other stuff which we don't want and which conflicts with stuff
34 #include "aout/aout64.h"
37 #undef obj_sym_filepos
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
46 /* Prototypes for static functions. */
48 static int ecoff_get_magic PARAMS ((bfd *abfd));
49 static long ecoff_sec_to_styp_flags PARAMS ((const char *name,
51 static boolean ecoff_slurp_symbolic_header PARAMS ((bfd *abfd));
52 static boolean ecoff_set_symbol_info PARAMS ((bfd *abfd, SYMR *ecoff_sym,
53 asymbol *asym, int ext, int weak));
54 static void ecoff_emit_aggregate PARAMS ((bfd *abfd, FDR *fdr,
56 RNDXR *rndx, long isym,
58 static char *ecoff_type_to_string PARAMS ((bfd *abfd, FDR *fdr,
60 static boolean ecoff_slurp_reloc_table PARAMS ((bfd *abfd, asection *section,
62 static int ecoff_sort_hdrs PARAMS ((const PTR, const PTR));
63 static boolean ecoff_compute_section_file_positions PARAMS ((bfd *abfd));
64 static bfd_size_type ecoff_compute_reloc_file_positions PARAMS ((bfd *abfd));
65 static boolean ecoff_get_extr PARAMS ((asymbol *, EXTR *));
66 static void ecoff_set_index PARAMS ((asymbol *, bfd_size_type));
67 static unsigned int ecoff_armap_hash PARAMS ((CONST char *s,
72 /* This stuff is somewhat copied from coffcode.h. */
74 static asection bfd_debug_section = { "*DEBUG*" };
76 /* Create an ECOFF object. */
79 _bfd_ecoff_mkobject (abfd)
82 abfd->tdata.ecoff_obj_data = ((struct ecoff_tdata *)
83 bfd_zalloc (abfd, sizeof (ecoff_data_type)));
84 if (abfd->tdata.ecoff_obj_data == NULL)
90 /* This is a hook called by coff_real_object_p to create any backend
91 specific information. */
94 _bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr)
99 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
100 struct internal_aouthdr *internal_a = (struct internal_aouthdr *) aouthdr;
101 ecoff_data_type *ecoff;
103 if (_bfd_ecoff_mkobject (abfd) == false)
106 ecoff = ecoff_data (abfd);
108 ecoff->sym_filepos = internal_f->f_symptr;
110 if (internal_a != (struct internal_aouthdr *) NULL)
114 ecoff->text_start = internal_a->text_start;
115 ecoff->text_end = internal_a->text_start + internal_a->tsize;
116 ecoff->gp = internal_a->gp_value;
117 ecoff->gprmask = internal_a->gprmask;
118 for (i = 0; i < 4; i++)
119 ecoff->cprmask[i] = internal_a->cprmask[i];
120 ecoff->fprmask = internal_a->fprmask;
121 if (internal_a->magic == ECOFF_AOUT_ZMAGIC)
122 abfd->flags |= D_PAGED;
124 abfd->flags &=~ D_PAGED;
127 /* It turns out that no special action is required by the MIPS or
128 Alpha ECOFF backends. They have different information in the
129 a.out header, but we just copy it all (e.g., gprmask, cprmask and
130 fprmask) and let the swapping routines ensure that only relevant
131 information is written out. */
136 /* Initialize a new section. */
139 _bfd_ecoff_new_section_hook (abfd, section)
143 /* For the .pdata section, which has a special meaning on the Alpha,
144 we set the alignment power to 3. We correct this later in
145 ecoff_compute_section_file_positions. We do this hackery because
146 we need to know the exact unaligned size of the .pdata section in
147 order to set the lnnoptr field correctly. For every other
148 section we use an alignment power of 4; this could be made target
149 dependent by adding a field to ecoff_backend_data, but 4 appears
150 to be correct for both the MIPS and the Alpha. */
151 if (strcmp (section->name, _PDATA) == 0)
152 section->alignment_power = 3;
154 section->alignment_power = 4;
156 if (strcmp (section->name, _TEXT) == 0)
157 section->flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
158 else if (strcmp (section->name, _DATA) == 0
159 || strcmp (section->name, _SDATA) == 0)
160 section->flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
161 else if (strcmp (section->name, _RDATA) == 0
162 || strcmp (section->name, _LIT8) == 0
163 || strcmp (section->name, _LIT4) == 0
164 || strcmp (section->name, _RCONST) == 0)
165 section->flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY;
166 else if (strcmp (section->name, _BSS) == 0
167 || strcmp (section->name, _SBSS) == 0)
168 section->flags |= SEC_ALLOC;
169 else if (strcmp (section->name, _LIB) == 0)
171 /* An Irix 4 shared libary. */
172 section->flags |= SEC_COFF_SHARED_LIBRARY;
175 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
176 uncertain about .init on some systems and I don't know how shared
182 /* Determine the machine architecture and type. This is called from
183 the generic COFF routines. It is the inverse of ecoff_get_magic,
184 below. This could be an ECOFF backend routine, with one version
185 for each target, but there aren't all that many ECOFF targets. */
188 _bfd_ecoff_set_arch_mach_hook (abfd, filehdr)
192 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
193 enum bfd_architecture arch;
196 switch (internal_f->f_magic)
199 case MIPS_MAGIC_LITTLE:
201 arch = bfd_arch_mips;
205 case MIPS_MAGIC_LITTLE2:
206 case MIPS_MAGIC_BIG2:
207 /* MIPS ISA level 2: the r6000 */
208 arch = bfd_arch_mips;
212 case MIPS_MAGIC_LITTLE3:
213 case MIPS_MAGIC_BIG3:
214 /* MIPS ISA level 3: the r4000 */
215 arch = bfd_arch_mips;
220 arch = bfd_arch_alpha;
225 arch = bfd_arch_obscure;
230 return bfd_default_set_arch_mach (abfd, arch, mach);
233 /* Get the magic number to use based on the architecture and machine.
234 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
237 ecoff_get_magic (abfd)
242 switch (bfd_get_arch (abfd))
245 switch (bfd_get_mach (abfd))
250 big = MIPS_MAGIC_BIG;
251 little = MIPS_MAGIC_LITTLE;
255 big = MIPS_MAGIC_BIG2;
256 little = MIPS_MAGIC_LITTLE2;
260 big = MIPS_MAGIC_BIG3;
261 little = MIPS_MAGIC_LITTLE3;
265 return bfd_big_endian (abfd) ? big : little;
276 /* Get the section s_flags to use for a section. */
279 ecoff_sec_to_styp_flags (name, flags)
287 if (strcmp (name, _TEXT) == 0)
289 else if (strcmp (name, _DATA) == 0)
291 else if (strcmp (name, _SDATA) == 0)
293 else if (strcmp (name, _RDATA) == 0)
295 else if (strcmp (name, _LITA) == 0)
297 else if (strcmp (name, _LIT8) == 0)
299 else if (strcmp (name, _LIT4) == 0)
301 else if (strcmp (name, _BSS) == 0)
303 else if (strcmp (name, _SBSS) == 0)
305 else if (strcmp (name, _INIT) == 0)
306 styp = STYP_ECOFF_INIT;
307 else if (strcmp (name, _FINI) == 0)
308 styp = STYP_ECOFF_FINI;
309 else if (strcmp (name, _PDATA) == 0)
311 else if (strcmp (name, _XDATA) == 0)
313 else if (strcmp (name, _LIB) == 0)
314 styp = STYP_ECOFF_LIB;
315 else if (strcmp (name, _GOT) == 0)
317 else if (strcmp (name, _HASH) == 0)
319 else if (strcmp (name, _DYNAMIC) == 0)
321 else if (strcmp (name, _LIBLIST) == 0)
323 else if (strcmp (name, _RELDYN) == 0)
325 else if (strcmp (name, _CONFLIC) == 0)
327 else if (strcmp (name, _DYNSTR) == 0)
329 else if (strcmp (name, _DYNSYM) == 0)
331 else if (strcmp (name, _COMMENT) == 0)
334 flags &=~ SEC_NEVER_LOAD;
336 else if (strcmp (name, _RCONST) == 0)
338 else if (flags & SEC_CODE)
340 else if (flags & SEC_DATA)
342 else if (flags & SEC_READONLY)
344 else if (flags & SEC_LOAD)
349 if (flags & SEC_NEVER_LOAD)
355 /* Get the BFD flags to use for a section. */
359 _bfd_ecoff_styp_to_sec_flags (abfd, hdr, name)
364 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
365 long styp_flags = internal_s->s_flags;
366 flagword sec_flags=0;
368 if (styp_flags & STYP_NOLOAD)
369 sec_flags |= SEC_NEVER_LOAD;
371 /* For 386 COFF, at least, an unloadable text or data section is
372 actually a shared library section. */
373 if ((styp_flags & STYP_TEXT)
374 || (styp_flags & STYP_ECOFF_INIT)
375 || (styp_flags & STYP_ECOFF_FINI)
376 || (styp_flags & STYP_DYNAMIC)
377 || (styp_flags & STYP_LIBLIST)
378 || (styp_flags & STYP_RELDYN)
379 || styp_flags == STYP_CONFLIC
380 || (styp_flags & STYP_DYNSTR)
381 || (styp_flags & STYP_DYNSYM)
382 || (styp_flags & STYP_HASH))
384 if (sec_flags & SEC_NEVER_LOAD)
385 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
387 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
389 else if ((styp_flags & STYP_DATA)
390 || (styp_flags & STYP_RDATA)
391 || (styp_flags & STYP_SDATA)
392 || styp_flags == STYP_PDATA
393 || styp_flags == STYP_XDATA
394 || (styp_flags & STYP_GOT)
395 || styp_flags == STYP_RCONST)
397 if (sec_flags & SEC_NEVER_LOAD)
398 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
400 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
401 if ((styp_flags & STYP_RDATA)
402 || styp_flags == STYP_PDATA
403 || styp_flags == STYP_RCONST)
404 sec_flags |= SEC_READONLY;
406 else if ((styp_flags & STYP_BSS)
407 || (styp_flags & STYP_SBSS))
409 sec_flags |= SEC_ALLOC;
411 else if ((styp_flags & STYP_INFO) || styp_flags == STYP_COMMENT)
413 sec_flags |= SEC_NEVER_LOAD;
415 else if ((styp_flags & STYP_LITA)
416 || (styp_flags & STYP_LIT8)
417 || (styp_flags & STYP_LIT4))
419 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY;
421 else if (styp_flags & STYP_ECOFF_LIB)
423 sec_flags |= SEC_COFF_SHARED_LIBRARY;
427 sec_flags |= SEC_ALLOC | SEC_LOAD;
433 /* Read in the symbolic header for an ECOFF object file. */
436 ecoff_slurp_symbolic_header (abfd)
439 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
440 bfd_size_type external_hdr_size;
442 HDRR *internal_symhdr;
444 /* See if we've already read it in. */
445 if (ecoff_data (abfd)->debug_info.symbolic_header.magic ==
446 backend->debug_swap.sym_magic)
449 /* See whether there is a symbolic header. */
450 if (ecoff_data (abfd)->sym_filepos == 0)
452 bfd_get_symcount (abfd) = 0;
456 /* At this point bfd_get_symcount (abfd) holds the number of symbols
457 as read from the file header, but on ECOFF this is always the
458 size of the symbolic information header. It would be cleaner to
459 handle this when we first read the file in coffgen.c. */
460 external_hdr_size = backend->debug_swap.external_hdr_size;
461 if (bfd_get_symcount (abfd) != external_hdr_size)
463 bfd_set_error (bfd_error_bad_value);
467 /* Read the symbolic information header. */
468 raw = (PTR) bfd_malloc ((size_t) external_hdr_size);
472 if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) == -1
473 || (bfd_read (raw, external_hdr_size, 1, abfd)
474 != external_hdr_size))
476 internal_symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
477 (*backend->debug_swap.swap_hdr_in) (abfd, raw, internal_symhdr);
479 if (internal_symhdr->magic != backend->debug_swap.sym_magic)
481 bfd_set_error (bfd_error_bad_value);
485 /* Now we can get the correct number of symbols. */
486 bfd_get_symcount (abfd) = (internal_symhdr->isymMax
487 + internal_symhdr->iextMax);
498 /* Read in and swap the important symbolic information for an ECOFF
499 object file. This is called by gdb via the read_debug_info entry
500 point in the backend structure. */
504 _bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug)
507 struct ecoff_debug_info *debug;
509 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
510 HDRR *internal_symhdr;
511 bfd_size_type raw_base;
512 bfd_size_type raw_size;
514 bfd_size_type external_fdr_size;
518 bfd_size_type raw_end;
519 bfd_size_type cb_end;
521 BFD_ASSERT (debug == &ecoff_data (abfd)->debug_info);
523 /* Check whether we've already gotten it, and whether there's any to
525 if (ecoff_data (abfd)->raw_syments != (PTR) NULL)
527 if (ecoff_data (abfd)->sym_filepos == 0)
529 bfd_get_symcount (abfd) = 0;
533 if (! ecoff_slurp_symbolic_header (abfd))
536 internal_symhdr = &debug->symbolic_header;
538 /* Read all the symbolic information at once. */
539 raw_base = (ecoff_data (abfd)->sym_filepos
540 + backend->debug_swap.external_hdr_size);
542 /* Alpha ecoff makes the determination of raw_size difficult. It has
543 an undocumented debug data section between the symhdr and the first
544 documented section. And the ordering of the sections varies between
545 statically and dynamically linked executables.
546 If bfd supports SEEK_END someday, this code could be simplified. */
550 #define UPDATE_RAW_END(start, count, size) \
551 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
552 if (cb_end > raw_end) \
555 UPDATE_RAW_END (cbLineOffset, cbLine, sizeof (unsigned char));
556 UPDATE_RAW_END (cbDnOffset, idnMax, backend->debug_swap.external_dnr_size);
557 UPDATE_RAW_END (cbPdOffset, ipdMax, backend->debug_swap.external_pdr_size);
558 UPDATE_RAW_END (cbSymOffset, isymMax, backend->debug_swap.external_sym_size);
559 UPDATE_RAW_END (cbOptOffset, ioptMax, backend->debug_swap.external_opt_size);
560 UPDATE_RAW_END (cbAuxOffset, iauxMax, sizeof (union aux_ext));
561 UPDATE_RAW_END (cbSsOffset, issMax, sizeof (char));
562 UPDATE_RAW_END (cbSsExtOffset, issExtMax, sizeof (char));
563 UPDATE_RAW_END (cbFdOffset, ifdMax, backend->debug_swap.external_fdr_size);
564 UPDATE_RAW_END (cbRfdOffset, crfd, backend->debug_swap.external_rfd_size);
565 UPDATE_RAW_END (cbExtOffset, iextMax, backend->debug_swap.external_ext_size);
567 #undef UPDATE_RAW_END
569 raw_size = raw_end - raw_base;
572 ecoff_data (abfd)->sym_filepos = 0;
575 raw = (PTR) bfd_alloc (abfd, raw_size);
579 (ecoff_data (abfd)->sym_filepos
580 + backend->debug_swap.external_hdr_size),
582 || bfd_read (raw, raw_size, 1, abfd) != raw_size)
584 bfd_release (abfd, raw);
588 ecoff_data (abfd)->raw_syments = raw;
590 /* Get pointers for the numeric offsets in the HDRR structure. */
591 #define FIX(off1, off2, type) \
592 if (internal_symhdr->off1 == 0) \
593 debug->off2 = (type) NULL; \
595 debug->off2 = (type) ((char *) raw \
596 + (internal_symhdr->off1 \
598 FIX (cbLineOffset, line, unsigned char *);
599 FIX (cbDnOffset, external_dnr, PTR);
600 FIX (cbPdOffset, external_pdr, PTR);
601 FIX (cbSymOffset, external_sym, PTR);
602 FIX (cbOptOffset, external_opt, PTR);
603 FIX (cbAuxOffset, external_aux, union aux_ext *);
604 FIX (cbSsOffset, ss, char *);
605 FIX (cbSsExtOffset, ssext, char *);
606 FIX (cbFdOffset, external_fdr, PTR);
607 FIX (cbRfdOffset, external_rfd, PTR);
608 FIX (cbExtOffset, external_ext, PTR);
611 /* I don't want to always swap all the data, because it will just
612 waste time and most programs will never look at it. The only
613 time the linker needs most of the debugging information swapped
614 is when linking big-endian and little-endian MIPS object files
615 together, which is not a common occurrence.
617 We need to look at the fdr to deal with a lot of information in
618 the symbols, so we swap them here. */
619 debug->fdr = (struct fdr *) bfd_alloc (abfd,
620 (internal_symhdr->ifdMax *
621 sizeof (struct fdr)));
622 if (debug->fdr == NULL)
624 external_fdr_size = backend->debug_swap.external_fdr_size;
625 fdr_ptr = debug->fdr;
626 fraw_src = (char *) debug->external_fdr;
627 fraw_end = fraw_src + internal_symhdr->ifdMax * external_fdr_size;
628 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
629 (*backend->debug_swap.swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
634 /* ECOFF symbol table routines. The ECOFF symbol table is described
635 in gcc/mips-tfile.c. */
637 /* ECOFF uses two common sections. One is the usual one, and the
638 other is for small objects. All the small objects are kept
639 together, and then referenced via the gp pointer, which yields
640 faster assembler code. This is what we use for the small common
642 static asection ecoff_scom_section;
643 static asymbol ecoff_scom_symbol;
644 static asymbol *ecoff_scom_symbol_ptr;
646 /* Create an empty symbol. */
649 _bfd_ecoff_make_empty_symbol (abfd)
652 ecoff_symbol_type *new;
654 new = (ecoff_symbol_type *) bfd_alloc (abfd, sizeof (ecoff_symbol_type));
655 if (new == (ecoff_symbol_type *) NULL)
656 return (asymbol *) NULL;
657 memset ((PTR) new, 0, sizeof *new);
658 new->symbol.section = (asection *) NULL;
659 new->fdr = (FDR *) NULL;
662 new->symbol.the_bfd = abfd;
666 /* Set the BFD flags and section for an ECOFF symbol. */
669 ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, weak)
676 asym->the_bfd = abfd;
677 asym->value = ecoff_sym->value;
678 asym->section = &bfd_debug_section;
681 /* Most symbol types are just for debugging. */
682 switch (ecoff_sym->st)
691 if (ECOFF_IS_STAB (ecoff_sym))
693 asym->flags = BSF_DEBUGGING;
698 asym->flags = BSF_DEBUGGING;
703 asym->flags = BSF_EXPORT | BSF_WEAK;
705 asym->flags = BSF_EXPORT | BSF_GLOBAL;
708 asym->flags = BSF_LOCAL;
709 /* Normally, a local stProc symbol will have a corresponding
710 external symbol. We mark the local symbol as a debugging
711 symbol, in order to prevent nm from printing both out.
712 Similarly, we mark stLabel and stabs symbols as debugging
713 symbols. In both cases, we do want to set the value
714 correctly based on the symbol class. */
715 if (ecoff_sym->st == stProc
716 || ecoff_sym->st == stLabel
717 || ECOFF_IS_STAB (ecoff_sym))
718 asym->flags |= BSF_DEBUGGING;
720 switch (ecoff_sym->sc)
723 /* Used for compiler generated labels. Leave them in the
724 debugging section, and mark them as local. If BSF_DEBUGGING
725 is set, then nm does not display them for some reason. If no
726 flags are set then the linker whines about them. */
727 asym->flags = BSF_LOCAL;
730 asym->section = bfd_make_section_old_way (abfd, ".text");
731 asym->value -= asym->section->vma;
734 asym->section = bfd_make_section_old_way (abfd, ".data");
735 asym->value -= asym->section->vma;
738 asym->section = bfd_make_section_old_way (abfd, ".bss");
739 asym->value -= asym->section->vma;
742 asym->flags = BSF_DEBUGGING;
745 asym->section = bfd_abs_section_ptr;
748 asym->section = bfd_und_section_ptr;
758 asym->flags = BSF_DEBUGGING;
761 asym->section = bfd_make_section_old_way (abfd, ".sdata");
762 asym->value -= asym->section->vma;
765 asym->section = bfd_make_section_old_way (abfd, ".sbss");
766 asym->value -= asym->section->vma;
769 asym->section = bfd_make_section_old_way (abfd, ".rdata");
770 asym->value -= asym->section->vma;
773 asym->flags = BSF_DEBUGGING;
776 if (asym->value > ecoff_data (abfd)->gp_size)
778 asym->section = bfd_com_section_ptr;
784 if (ecoff_scom_section.name == NULL)
786 /* Initialize the small common section. */
787 ecoff_scom_section.name = SCOMMON;
788 ecoff_scom_section.flags = SEC_IS_COMMON;
789 ecoff_scom_section.output_section = &ecoff_scom_section;
790 ecoff_scom_section.symbol = &ecoff_scom_symbol;
791 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
792 ecoff_scom_symbol.name = SCOMMON;
793 ecoff_scom_symbol.flags = BSF_SECTION_SYM;
794 ecoff_scom_symbol.section = &ecoff_scom_section;
795 ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
797 asym->section = &ecoff_scom_section;
802 asym->flags = BSF_DEBUGGING;
805 asym->section = bfd_und_section_ptr;
810 asym->section = bfd_make_section_old_way (abfd, ".init");
811 asym->value -= asym->section->vma;
816 asym->flags = BSF_DEBUGGING;
819 asym->section = bfd_make_section_old_way (abfd, ".fini");
820 asym->value -= asym->section->vma;
823 asym->section = bfd_make_section_old_way (abfd, ".rconst");
824 asym->value -= asym->section->vma;
830 /* Look for special constructors symbols and make relocation entries
831 in a special construction section. These are produced by the
832 -fgnu-linker argument to g++. */
833 if (ECOFF_IS_STAB (ecoff_sym))
835 switch (ECOFF_UNMARK_STAB (ecoff_sym->index))
847 arelent_chain *reloc_chain;
848 unsigned int bitsize;
850 /* Get a section with the same name as the symbol (usually
851 __CTOR_LIST__ or __DTOR_LIST__). FIXME: gcc uses the
852 name ___CTOR_LIST (three underscores). We need
853 __CTOR_LIST (two underscores), since ECOFF doesn't use
854 a leading underscore. This should be handled by gcc,
855 but instead we do it here. Actually, this should all
856 be done differently anyhow. */
857 name = bfd_asymbol_name (asym);
858 if (name[0] == '_' && name[1] == '_' && name[2] == '_')
863 section = bfd_get_section_by_name (abfd, name);
864 if (section == (asection *) NULL)
868 copy = (char *) bfd_alloc (abfd, strlen (name) + 1);
872 section = bfd_make_section (abfd, copy);
875 /* Build a reloc pointing to this constructor. */
877 (arelent_chain *) bfd_alloc (abfd, sizeof (arelent_chain));
880 reloc_chain->relent.sym_ptr_ptr =
881 bfd_get_section (asym)->symbol_ptr_ptr;
882 reloc_chain->relent.address = section->_raw_size;
883 reloc_chain->relent.addend = asym->value;
884 reloc_chain->relent.howto =
885 ecoff_backend (abfd)->constructor_reloc;
887 /* Set up the constructor section to hold the reloc. */
888 section->flags = SEC_CONSTRUCTOR;
889 ++section->reloc_count;
891 /* Constructor sections must be rounded to a boundary
892 based on the bitsize. These are not real sections--
893 they are handled specially by the linker--so the ECOFF
894 16 byte alignment restriction does not apply. */
895 bitsize = ecoff_backend (abfd)->constructor_bitsize;
896 section->alignment_power = 1;
897 while ((1 << section->alignment_power) < bitsize / 8)
898 ++section->alignment_power;
900 reloc_chain->next = section->constructor_chain;
901 section->constructor_chain = reloc_chain;
902 section->_raw_size += bitsize / 8;
904 /* Mark the symbol as a constructor. */
905 asym->flags |= BSF_CONSTRUCTOR;
913 /* Read an ECOFF symbol table. */
916 _bfd_ecoff_slurp_symbol_table (abfd)
919 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
920 const bfd_size_type external_ext_size
921 = backend->debug_swap.external_ext_size;
922 const bfd_size_type external_sym_size
923 = backend->debug_swap.external_sym_size;
924 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
925 = backend->debug_swap.swap_ext_in;
926 void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *))
927 = backend->debug_swap.swap_sym_in;
928 bfd_size_type internal_size;
929 ecoff_symbol_type *internal;
930 ecoff_symbol_type *internal_ptr;
936 /* If we've already read in the symbol table, do nothing. */
937 if (ecoff_data (abfd)->canonical_symbols != NULL)
940 /* Get the symbolic information. */
941 if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL,
942 &ecoff_data (abfd)->debug_info))
944 if (bfd_get_symcount (abfd) == 0)
947 internal_size = bfd_get_symcount (abfd) * sizeof (ecoff_symbol_type);
948 internal = (ecoff_symbol_type *) bfd_alloc (abfd, internal_size);
949 if (internal == NULL)
952 internal_ptr = internal;
953 eraw_src = (char *) ecoff_data (abfd)->debug_info.external_ext;
955 + (ecoff_data (abfd)->debug_info.symbolic_header.iextMax
956 * external_ext_size));
957 for (; eraw_src < eraw_end; eraw_src += external_ext_size, internal_ptr++)
961 (*swap_ext_in) (abfd, (PTR) eraw_src, &internal_esym);
962 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ssext
963 + internal_esym.asym.iss);
964 if (!ecoff_set_symbol_info (abfd, &internal_esym.asym,
965 &internal_ptr->symbol, 1,
966 internal_esym.weakext))
968 /* The alpha uses a negative ifd field for section symbols. */
969 if (internal_esym.ifd >= 0)
970 internal_ptr->fdr = (ecoff_data (abfd)->debug_info.fdr
971 + internal_esym.ifd);
973 internal_ptr->fdr = NULL;
974 internal_ptr->local = false;
975 internal_ptr->native = (PTR) eraw_src;
978 /* The local symbols must be accessed via the fdr's, because the
979 string and aux indices are relative to the fdr information. */
980 fdr_ptr = ecoff_data (abfd)->debug_info.fdr;
981 fdr_end = fdr_ptr + ecoff_data (abfd)->debug_info.symbolic_header.ifdMax;
982 for (; fdr_ptr < fdr_end; fdr_ptr++)
987 lraw_src = ((char *) ecoff_data (abfd)->debug_info.external_sym
988 + fdr_ptr->isymBase * external_sym_size);
989 lraw_end = lraw_src + fdr_ptr->csym * external_sym_size;
992 lraw_src += external_sym_size, internal_ptr++)
996 (*swap_sym_in) (abfd, (PTR) lraw_src, &internal_sym);
997 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ss
1000 if (!ecoff_set_symbol_info (abfd, &internal_sym,
1001 &internal_ptr->symbol, 0, 0))
1003 internal_ptr->fdr = fdr_ptr;
1004 internal_ptr->local = true;
1005 internal_ptr->native = (PTR) lraw_src;
1009 ecoff_data (abfd)->canonical_symbols = internal;
1014 /* Return the amount of space needed for the canonical symbols. */
1017 _bfd_ecoff_get_symtab_upper_bound (abfd)
1020 if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL,
1021 &ecoff_data (abfd)->debug_info))
1024 if (bfd_get_symcount (abfd) == 0)
1027 return (bfd_get_symcount (abfd) + 1) * (sizeof (ecoff_symbol_type *));
1030 /* Get the canonical symbols. */
1033 _bfd_ecoff_get_symtab (abfd, alocation)
1035 asymbol **alocation;
1037 unsigned int counter = 0;
1038 ecoff_symbol_type *symbase;
1039 ecoff_symbol_type **location = (ecoff_symbol_type **) alocation;
1041 if (_bfd_ecoff_slurp_symbol_table (abfd) == false)
1043 if (bfd_get_symcount (abfd) == 0)
1046 symbase = ecoff_data (abfd)->canonical_symbols;
1047 while (counter < bfd_get_symcount (abfd))
1049 *(location++) = symbase++;
1052 *location++ = (ecoff_symbol_type *) NULL;
1053 return bfd_get_symcount (abfd);
1056 /* Turn ECOFF type information into a printable string.
1057 ecoff_emit_aggregate and ecoff_type_to_string are from
1058 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1060 /* Write aggregate information to a string. */
1063 ecoff_emit_aggregate (abfd, fdr, string, rndx, isym, which)
1071 const struct ecoff_debug_swap * const debug_swap =
1072 &ecoff_backend (abfd)->debug_swap;
1073 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info;
1074 unsigned int ifd = rndx->rfd;
1075 unsigned int indx = rndx->index;
1081 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1082 struct return type of a procedure compiled without -g. */
1083 if (ifd == 0xffffffff
1084 || (rndx->rfd == 0xfff && indx == 0))
1085 name = "<undefined>";
1086 else if (indx == indexNil)
1092 if (debug_info->external_rfd == NULL)
1093 fdr = debug_info->fdr + ifd;
1098 (*debug_swap->swap_rfd_in) (abfd,
1099 ((char *) debug_info->external_rfd
1100 + ((fdr->rfdBase + ifd)
1101 * debug_swap->external_rfd_size)),
1103 fdr = debug_info->fdr + rfd;
1106 indx += fdr->isymBase;
1108 (*debug_swap->swap_sym_in) (abfd,
1109 ((char *) debug_info->external_sym
1110 + indx * debug_swap->external_sym_size),
1113 name = debug_info->ss + fdr->issBase + sym.iss;
1117 "%s %s { ifd = %u, index = %lu }",
1120 + debug_info->symbolic_header.iextMax));
1123 /* Convert the type information to string format. */
1126 ecoff_type_to_string (abfd, fdr, indx)
1131 union aux_ext *aux_ptr;
1140 unsigned int basic_type;
1143 static char buffer2[1024];
1148 aux_ptr = ecoff_data (abfd)->debug_info.external_aux + fdr->iauxBase;
1149 bigendian = fdr->fBigendian;
1151 for (i = 0; i < 7; i++)
1153 qualifiers[i].low_bound = 0;
1154 qualifiers[i].high_bound = 0;
1155 qualifiers[i].stride = 0;
1158 if (AUX_GET_ISYM (bigendian, &aux_ptr[indx]) == (bfd_vma) -1)
1159 return "-1 (no type)";
1160 _bfd_ecoff_swap_tir_in (bigendian, &aux_ptr[indx++].a_ti, &u.ti);
1162 basic_type = u.ti.bt;
1163 qualifiers[0].type = u.ti.tq0;
1164 qualifiers[1].type = u.ti.tq1;
1165 qualifiers[2].type = u.ti.tq2;
1166 qualifiers[3].type = u.ti.tq3;
1167 qualifiers[4].type = u.ti.tq4;
1168 qualifiers[5].type = u.ti.tq5;
1169 qualifiers[6].type = tqNil;
1172 * Go get the basic type.
1176 case btNil: /* undefined */
1180 case btAdr: /* address - integer same size as pointer */
1181 strcpy (p1, "address");
1184 case btChar: /* character */
1185 strcpy (p1, "char");
1188 case btUChar: /* unsigned character */
1189 strcpy (p1, "unsigned char");
1192 case btShort: /* short */
1193 strcpy (p1, "short");
1196 case btUShort: /* unsigned short */
1197 strcpy (p1, "unsigned short");
1200 case btInt: /* int */
1204 case btUInt: /* unsigned int */
1205 strcpy (p1, "unsigned int");
1208 case btLong: /* long */
1209 strcpy (p1, "long");
1212 case btULong: /* unsigned long */
1213 strcpy (p1, "unsigned long");
1216 case btFloat: /* float (real) */
1217 strcpy (p1, "float");
1220 case btDouble: /* Double (real) */
1221 strcpy (p1, "double");
1224 /* Structures add 1-2 aux words:
1225 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1226 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1228 case btStruct: /* Structure (Record) */
1229 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1230 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1231 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1233 indx++; /* skip aux words */
1236 /* Unions add 1-2 aux words:
1237 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1238 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1240 case btUnion: /* Union */
1241 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1242 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1243 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1245 indx++; /* skip aux words */
1248 /* Enumerations add 1-2 aux words:
1249 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1250 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1252 case btEnum: /* Enumeration */
1253 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1254 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1255 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1257 indx++; /* skip aux words */
1260 case btTypedef: /* defined via a typedef, isymRef points */
1261 strcpy (p1, "typedef");
1264 case btRange: /* subrange of int */
1265 strcpy (p1, "subrange");
1268 case btSet: /* pascal sets */
1272 case btComplex: /* fortran complex */
1273 strcpy (p1, "complex");
1276 case btDComplex: /* fortran double complex */
1277 strcpy (p1, "double complex");
1280 case btIndirect: /* forward or unnamed typedef */
1281 strcpy (p1, "forward/unamed typedef");
1284 case btFixedDec: /* Fixed Decimal */
1285 strcpy (p1, "fixed decimal");
1288 case btFloatDec: /* Float Decimal */
1289 strcpy (p1, "float decimal");
1292 case btString: /* Varying Length Character String */
1293 strcpy (p1, "string");
1296 case btBit: /* Aligned Bit String */
1300 case btPicture: /* Picture */
1301 strcpy (p1, "picture");
1304 case btVoid: /* Void */
1305 strcpy (p1, "void");
1309 sprintf (p1, "Unknown basic type %d", (int) basic_type);
1313 p1 += strlen (buffer1);
1316 * If this is a bitfield, get the bitsize.
1322 bitsize = AUX_GET_WIDTH (bigendian, &aux_ptr[indx++]);
1323 sprintf (p1, " : %d", bitsize);
1324 p1 += strlen (buffer1);
1329 * Deal with any qualifiers.
1331 if (qualifiers[0].type != tqNil)
1334 * Snarf up any array bounds in the correct order. Arrays
1335 * store 5 successive words in the aux. table:
1336 * word 0 RNDXR to type of the bounds (ie, int)
1337 * word 1 Current file descriptor index
1339 * word 3 high bound (or -1 if [])
1340 * word 4 stride size in bits
1342 for (i = 0; i < 7; i++)
1344 if (qualifiers[i].type == tqArray)
1346 qualifiers[i].low_bound =
1347 AUX_GET_DNLOW (bigendian, &aux_ptr[indx+2]);
1348 qualifiers[i].high_bound =
1349 AUX_GET_DNHIGH (bigendian, &aux_ptr[indx+3]);
1350 qualifiers[i].stride =
1351 AUX_GET_WIDTH (bigendian, &aux_ptr[indx+4]);
1357 * Now print out the qualifiers.
1359 for (i = 0; i < 6; i++)
1361 switch (qualifiers[i].type)
1368 strcpy (p2, "ptr to ");
1369 p2 += sizeof ("ptr to ")-1;
1373 strcpy (p2, "volatile ");
1374 p2 += sizeof ("volatile ")-1;
1378 strcpy (p2, "far ");
1379 p2 += sizeof ("far ")-1;
1383 strcpy (p2, "func. ret. ");
1384 p2 += sizeof ("func. ret. ");
1389 int first_array = i;
1392 /* Print array bounds reversed (ie, in the order the C
1393 programmer writes them). C is such a fun language.... */
1395 while (i < 5 && qualifiers[i+1].type == tqArray)
1398 for (j = i; j >= first_array; j--)
1400 strcpy (p2, "array [");
1401 p2 += sizeof ("array [")-1;
1402 if (qualifiers[j].low_bound != 0)
1404 "%ld:%ld {%ld bits}",
1405 (long) qualifiers[j].low_bound,
1406 (long) qualifiers[j].high_bound,
1407 (long) qualifiers[j].stride);
1409 else if (qualifiers[j].high_bound != -1)
1412 (long) (qualifiers[j].high_bound + 1),
1413 (long) (qualifiers[j].stride));
1416 sprintf (p2, " {%ld bits}", (long) (qualifiers[j].stride));
1419 strcpy (p2, "] of ");
1420 p2 += sizeof ("] of ")-1;
1428 strcpy (p2, buffer1);
1432 /* Return information about ECOFF symbol SYMBOL in RET. */
1436 _bfd_ecoff_get_symbol_info (abfd, symbol, ret)
1437 bfd *abfd; /* Ignored. */
1441 bfd_symbol_info (symbol, ret);
1444 /* Return whether this is a local label. */
1448 _bfd_ecoff_bfd_is_local_label (abfd, symbol)
1452 return symbol->name[0] == '$';
1455 /* Print information about an ECOFF symbol. */
1458 _bfd_ecoff_print_symbol (abfd, filep, symbol, how)
1462 bfd_print_symbol_type how;
1464 const struct ecoff_debug_swap * const debug_swap
1465 = &ecoff_backend (abfd)->debug_swap;
1466 FILE *file = (FILE *)filep;
1470 case bfd_print_symbol_name:
1471 fprintf (file, "%s", symbol->name);
1473 case bfd_print_symbol_more:
1474 if (ecoffsymbol (symbol)->local)
1478 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
1480 fprintf (file, "ecoff local ");
1481 fprintf_vma (file, (bfd_vma) ecoff_sym.value);
1482 fprintf (file, " %x %x", (unsigned) ecoff_sym.st,
1483 (unsigned) ecoff_sym.sc);
1489 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
1491 fprintf (file, "ecoff extern ");
1492 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
1493 fprintf (file, " %x %x", (unsigned) ecoff_ext.asym.st,
1494 (unsigned) ecoff_ext.asym.sc);
1497 case bfd_print_symbol_all:
1498 /* Print out the symbols in a reasonable way */
1507 if (ecoffsymbol (symbol)->local)
1509 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
1512 pos = ((((char *) ecoffsymbol (symbol)->native
1513 - (char *) ecoff_data (abfd)->debug_info.external_sym)
1514 / debug_swap->external_sym_size)
1515 + ecoff_data (abfd)->debug_info.symbolic_header.iextMax);
1522 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
1525 pos = (((char *) ecoffsymbol (symbol)->native
1526 - (char *) ecoff_data (abfd)->debug_info.external_ext)
1527 / debug_swap->external_ext_size);
1528 jmptbl = ecoff_ext.jmptbl ? 'j' : ' ';
1529 cobol_main = ecoff_ext.cobol_main ? 'c' : ' ';
1530 weakext = ecoff_ext.weakext ? 'w' : ' ';
1533 fprintf (file, "[%3d] %c ",
1535 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
1536 fprintf (file, " st %x sc %x indx %x %c%c%c %s",
1537 (unsigned) ecoff_ext.asym.st,
1538 (unsigned) ecoff_ext.asym.sc,
1539 (unsigned) ecoff_ext.asym.index,
1540 jmptbl, cobol_main, weakext,
1543 if (ecoffsymbol (symbol)->fdr != NULL
1544 && ecoff_ext.asym.index != indexNil)
1549 bfd_size_type sym_base;
1550 union aux_ext *aux_base;
1552 fdr = ecoffsymbol (symbol)->fdr;
1553 indx = ecoff_ext.asym.index;
1555 /* sym_base is used to map the fdr relative indices which
1556 appear in the file to the position number which we are
1558 sym_base = fdr->isymBase;
1559 if (ecoffsymbol (symbol)->local)
1561 ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
1563 /* aux_base is the start of the aux entries for this file;
1564 asym.index is an offset from this. */
1565 aux_base = (ecoff_data (abfd)->debug_info.external_aux
1568 /* The aux entries are stored in host byte order; the
1569 order is indicated by a bit in the fdr. */
1570 bigendian = fdr->fBigendian;
1572 /* This switch is basically from gcc/mips-tdump.c */
1573 switch (ecoff_ext.asym.st)
1581 fprintf (file, "\n End+1 symbol: %ld",
1582 (long) (indx + sym_base));
1586 if (ecoff_ext.asym.sc == scText
1587 || ecoff_ext.asym.sc == scInfo)
1588 fprintf (file, "\n First symbol: %ld",
1589 (long) (indx + sym_base));
1591 fprintf (file, "\n First symbol: %ld",
1593 (AUX_GET_ISYM (bigendian,
1594 &aux_base[ecoff_ext.asym.index])
1600 if (ECOFF_IS_STAB (&ecoff_ext.asym))
1602 else if (ecoffsymbol (symbol)->local)
1603 fprintf (file, "\n End+1 symbol: %-7ld Type: %s",
1605 (AUX_GET_ISYM (bigendian,
1606 &aux_base[ecoff_ext.asym.index])
1608 ecoff_type_to_string (abfd, fdr, indx + 1));
1610 fprintf (file, "\n Local symbol: %ld",
1613 + (ecoff_data (abfd)
1614 ->debug_info.symbolic_header.iextMax)));
1618 fprintf (file, "\n struct; End+1 symbol: %ld",
1619 (long) (indx + sym_base));
1623 fprintf (file, "\n union; End+1 symbol: %ld",
1624 (long) (indx + sym_base));
1628 fprintf (file, "\n enum; End+1 symbol: %ld",
1629 (long) (indx + sym_base));
1633 if (! ECOFF_IS_STAB (&ecoff_ext.asym))
1634 fprintf (file, "\n Type: %s",
1635 ecoff_type_to_string (abfd, fdr, indx));
1644 /* Read in the relocs for a section. */
1647 ecoff_slurp_reloc_table (abfd, section, symbols)
1652 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
1653 arelent *internal_relocs;
1654 bfd_size_type external_reloc_size;
1655 bfd_size_type external_relocs_size;
1656 char *external_relocs;
1660 if (section->relocation != (arelent *) NULL
1661 || section->reloc_count == 0
1662 || (section->flags & SEC_CONSTRUCTOR) != 0)
1665 if (_bfd_ecoff_slurp_symbol_table (abfd) == false)
1668 internal_relocs = (arelent *) bfd_alloc (abfd,
1670 * section->reloc_count));
1671 external_reloc_size = backend->external_reloc_size;
1672 external_relocs_size = external_reloc_size * section->reloc_count;
1673 external_relocs = (char *) bfd_alloc (abfd, external_relocs_size);
1674 if (internal_relocs == (arelent *) NULL
1675 || external_relocs == (char *) NULL)
1677 if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0)
1679 if (bfd_read (external_relocs, 1, external_relocs_size, abfd)
1680 != external_relocs_size)
1683 for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++)
1685 struct internal_reloc intern;
1687 (*backend->swap_reloc_in) (abfd,
1688 external_relocs + i * external_reloc_size,
1691 if (intern.r_extern)
1693 /* r_symndx is an index into the external symbols. */
1694 BFD_ASSERT (intern.r_symndx >= 0
1696 < (ecoff_data (abfd)
1697 ->debug_info.symbolic_header.iextMax)));
1698 rptr->sym_ptr_ptr = symbols + intern.r_symndx;
1701 else if (intern.r_symndx == RELOC_SECTION_NONE
1702 || intern.r_symndx == RELOC_SECTION_ABS)
1704 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1709 CONST char *sec_name;
1712 /* r_symndx is a section key. */
1713 switch (intern.r_symndx)
1715 case RELOC_SECTION_TEXT: sec_name = ".text"; break;
1716 case RELOC_SECTION_RDATA: sec_name = ".rdata"; break;
1717 case RELOC_SECTION_DATA: sec_name = ".data"; break;
1718 case RELOC_SECTION_SDATA: sec_name = ".sdata"; break;
1719 case RELOC_SECTION_SBSS: sec_name = ".sbss"; break;
1720 case RELOC_SECTION_BSS: sec_name = ".bss"; break;
1721 case RELOC_SECTION_INIT: sec_name = ".init"; break;
1722 case RELOC_SECTION_LIT8: sec_name = ".lit8"; break;
1723 case RELOC_SECTION_LIT4: sec_name = ".lit4"; break;
1724 case RELOC_SECTION_XDATA: sec_name = ".xdata"; break;
1725 case RELOC_SECTION_PDATA: sec_name = ".pdata"; break;
1726 case RELOC_SECTION_FINI: sec_name = ".fini"; break;
1727 case RELOC_SECTION_LITA: sec_name = ".lita"; break;
1728 case RELOC_SECTION_RCONST: sec_name = ".rconst"; break;
1732 sec = bfd_get_section_by_name (abfd, sec_name);
1733 if (sec == (asection *) NULL)
1735 rptr->sym_ptr_ptr = sec->symbol_ptr_ptr;
1737 rptr->addend = - bfd_get_section_vma (abfd, sec);
1740 rptr->address = intern.r_vaddr - bfd_get_section_vma (abfd, section);
1742 /* Let the backend select the howto field and do any other
1743 required processing. */
1744 (*backend->adjust_reloc_in) (abfd, &intern, rptr);
1747 bfd_release (abfd, external_relocs);
1749 section->relocation = internal_relocs;
1754 /* Get a canonical list of relocs. */
1757 _bfd_ecoff_canonicalize_reloc (abfd, section, relptr, symbols)
1765 if (section->flags & SEC_CONSTRUCTOR)
1767 arelent_chain *chain;
1769 /* This section has relocs made up by us, not the file, so take
1770 them out of their chain and place them into the data area
1772 for (count = 0, chain = section->constructor_chain;
1773 count < section->reloc_count;
1774 count++, chain = chain->next)
1775 *relptr++ = &chain->relent;
1781 if (ecoff_slurp_reloc_table (abfd, section, symbols) == false)
1784 tblptr = section->relocation;
1786 for (count = 0; count < section->reloc_count; count++)
1787 *relptr++ = tblptr++;
1790 *relptr = (arelent *) NULL;
1792 return section->reloc_count;
1795 /* Provided a BFD, a section and an offset into the section, calculate
1796 and return the name of the source file and the line nearest to the
1801 _bfd_ecoff_find_nearest_line (abfd, section, ignore_symbols, offset,
1802 filename_ptr, functionname_ptr, retline_ptr)
1805 asymbol **ignore_symbols;
1807 CONST char **filename_ptr;
1808 CONST char **functionname_ptr;
1809 unsigned int *retline_ptr;
1811 const struct ecoff_debug_swap * const debug_swap
1812 = &ecoff_backend (abfd)->debug_swap;
1813 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info;
1814 struct ecoff_find_line *line_info;
1816 /* Make sure we have the FDR's. */
1817 if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL, debug_info)
1818 || bfd_get_symcount (abfd) == 0)
1821 if (ecoff_data (abfd)->find_line_info == NULL)
1823 ecoff_data (abfd)->find_line_info =
1824 ((struct ecoff_find_line *)
1825 bfd_alloc (abfd, sizeof (struct ecoff_find_line)));
1826 if (ecoff_data (abfd)->find_line_info == NULL)
1828 ecoff_data (abfd)->find_line_info->find_buffer = NULL;
1829 ecoff_data (abfd)->find_line_info->fdrtab_len = 0;
1830 ecoff_data (abfd)->find_line_info->fdrtab = NULL;
1832 line_info = ecoff_data (abfd)->find_line_info;
1834 return _bfd_ecoff_locate_line (abfd, section, offset, debug_info,
1835 debug_swap, line_info, filename_ptr,
1836 functionname_ptr, retline_ptr);
1839 /* Copy private BFD data. This is called by objcopy and strip. We
1840 use it to copy the ECOFF debugging information from one BFD to the
1841 other. It would be theoretically possible to represent the ECOFF
1842 debugging information in the symbol table. However, it would be a
1843 lot of work, and there would be little gain (gas, gdb, and ld
1844 already access the ECOFF debugging information via the
1845 ecoff_debug_info structure, and that structure would have to be
1846 retained in order to support ECOFF debugging in MIPS ELF).
1848 The debugging information for the ECOFF external symbols comes from
1849 the symbol table, so this function only handles the other debugging
1853 _bfd_ecoff_bfd_copy_private_bfd_data (ibfd, obfd)
1857 struct ecoff_debug_info *iinfo = &ecoff_data (ibfd)->debug_info;
1858 struct ecoff_debug_info *oinfo = &ecoff_data (obfd)->debug_info;
1860 asymbol **sym_ptr_ptr;
1864 /* This function is selected based on the input vector. We only
1865 want to copy information over if the output BFD also uses ECOFF
1867 if (bfd_get_flavour (obfd) != bfd_target_ecoff_flavour)
1870 /* Copy the GP value and the register masks. */
1871 ecoff_data (obfd)->gp = ecoff_data (ibfd)->gp;
1872 ecoff_data (obfd)->gprmask = ecoff_data (ibfd)->gprmask;
1873 ecoff_data (obfd)->fprmask = ecoff_data (ibfd)->fprmask;
1874 for (i = 0; i < 3; i++)
1875 ecoff_data (obfd)->cprmask[i] = ecoff_data (ibfd)->cprmask[i];
1877 /* Copy the version stamp. */
1878 oinfo->symbolic_header.vstamp = iinfo->symbolic_header.vstamp;
1880 /* If there are no symbols, don't copy any debugging information. */
1881 c = bfd_get_symcount (obfd);
1882 sym_ptr_ptr = bfd_get_outsymbols (obfd);
1883 if (c == 0 || sym_ptr_ptr == (asymbol **) NULL)
1886 /* See if there are any local symbols. */
1888 for (; c > 0; c--, sym_ptr_ptr++)
1890 if (ecoffsymbol (*sym_ptr_ptr)->local)
1899 /* There are some local symbols. We just bring over all the
1900 debugging information. FIXME: This is not quite the right
1901 thing to do. If the user has asked us to discard all
1902 debugging information, then we are probably going to wind up
1903 keeping it because there will probably be some local symbol
1904 which objcopy did not discard. We should actually break
1905 apart the debugging information and only keep that which
1906 applies to the symbols we want to keep. */
1907 oinfo->symbolic_header.ilineMax = iinfo->symbolic_header.ilineMax;
1908 oinfo->symbolic_header.cbLine = iinfo->symbolic_header.cbLine;
1909 oinfo->line = iinfo->line;
1911 oinfo->symbolic_header.idnMax = iinfo->symbolic_header.idnMax;
1912 oinfo->external_dnr = iinfo->external_dnr;
1914 oinfo->symbolic_header.ipdMax = iinfo->symbolic_header.ipdMax;
1915 oinfo->external_pdr = iinfo->external_pdr;
1917 oinfo->symbolic_header.isymMax = iinfo->symbolic_header.isymMax;
1918 oinfo->external_sym = iinfo->external_sym;
1920 oinfo->symbolic_header.ioptMax = iinfo->symbolic_header.ioptMax;
1921 oinfo->external_opt = iinfo->external_opt;
1923 oinfo->symbolic_header.iauxMax = iinfo->symbolic_header.iauxMax;
1924 oinfo->external_aux = iinfo->external_aux;
1926 oinfo->symbolic_header.issMax = iinfo->symbolic_header.issMax;
1927 oinfo->ss = iinfo->ss;
1929 oinfo->symbolic_header.ifdMax = iinfo->symbolic_header.ifdMax;
1930 oinfo->external_fdr = iinfo->external_fdr;
1932 oinfo->symbolic_header.crfd = iinfo->symbolic_header.crfd;
1933 oinfo->external_rfd = iinfo->external_rfd;
1937 /* We are discarding all the local symbol information. Look
1938 through the external symbols and remove all references to FDR
1939 or aux information. */
1940 c = bfd_get_symcount (obfd);
1941 sym_ptr_ptr = bfd_get_outsymbols (obfd);
1942 for (; c > 0; c--, sym_ptr_ptr++)
1946 (*(ecoff_backend (obfd)->debug_swap.swap_ext_in))
1947 (obfd, ecoffsymbol (*sym_ptr_ptr)->native, &esym);
1949 esym.asym.index = indexNil;
1950 (*(ecoff_backend (obfd)->debug_swap.swap_ext_out))
1951 (obfd, &esym, ecoffsymbol (*sym_ptr_ptr)->native);
1958 /* Set the architecture. The supported architecture is stored in the
1959 backend pointer. We always set the architecture anyhow, since many
1960 callers ignore the return value. */
1963 _bfd_ecoff_set_arch_mach (abfd, arch, machine)
1965 enum bfd_architecture arch;
1966 unsigned long machine;
1968 bfd_default_set_arch_mach (abfd, arch, machine);
1969 return arch == ecoff_backend (abfd)->arch;
1972 /* Get the size of the section headers. */
1976 _bfd_ecoff_sizeof_headers (abfd, reloc)
1985 for (current = abfd->sections;
1986 current != (asection *)NULL;
1987 current = current->next)
1990 ret = (bfd_coff_filhsz (abfd)
1991 + bfd_coff_aoutsz (abfd)
1992 + c * bfd_coff_scnhsz (abfd));
1993 return BFD_ALIGN (ret, 16);
1996 /* Get the contents of a section. */
1999 _bfd_ecoff_get_section_contents (abfd, section, location, offset, count)
2004 bfd_size_type count;
2006 return _bfd_generic_get_section_contents (abfd, section, location,
2010 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
2011 called via qsort. */
2014 ecoff_sort_hdrs (arg1, arg2)
2018 const asection *hdr1 = *(const asection **) arg1;
2019 const asection *hdr2 = *(const asection **) arg2;
2021 if ((hdr1->flags & SEC_ALLOC) != 0)
2023 if ((hdr2->flags & SEC_ALLOC) == 0)
2028 if ((hdr2->flags & SEC_ALLOC) != 0)
2031 if (hdr1->vma < hdr2->vma)
2033 else if (hdr1->vma > hdr2->vma)
2039 /* Calculate the file position for each section, and set
2043 ecoff_compute_section_file_positions (abfd)
2047 asection **sorted_hdrs;
2051 boolean first_data, first_nonalloc;
2052 const bfd_vma round = ecoff_backend (abfd)->round;
2054 sofar = _bfd_ecoff_sizeof_headers (abfd, false);
2056 /* Sort the sections by VMA. */
2057 sorted_hdrs = (asection **) bfd_malloc (abfd->section_count
2058 * sizeof (asection *));
2059 if (sorted_hdrs == NULL)
2061 for (current = abfd->sections, i = 0;
2063 current = current->next, i++)
2064 sorted_hdrs[i] = current;
2065 BFD_ASSERT (i == abfd->section_count);
2067 qsort (sorted_hdrs, abfd->section_count, sizeof (asection *),
2071 first_nonalloc = true;
2072 for (i = 0; i < abfd->section_count; i++)
2074 unsigned int alignment_power;
2076 current = sorted_hdrs[i];
2078 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2079 supposed to indicate the number of .pdata entries that are
2080 really in the section. Each entry is 8 bytes. We store this
2081 away in line_filepos before increasing the section size. */
2082 if (strcmp (current->name, _PDATA) != 0)
2083 alignment_power = current->alignment_power;
2086 current->line_filepos = current->_raw_size / 8;
2087 alignment_power = 4;
2090 /* On Ultrix, the data sections in an executable file must be
2091 aligned to a page boundary within the file. This does not
2092 affect the section size, though. FIXME: Does this work for
2093 other platforms? It requires some modification for the
2094 Alpha, because .rdata on the Alpha goes with the text, not
2096 if ((abfd->flags & EXEC_P) != 0
2097 && (abfd->flags & D_PAGED) != 0
2099 && (current->flags & SEC_CODE) == 0
2100 && (! ecoff_backend (abfd)->rdata_in_text
2101 || strcmp (current->name, _RDATA) != 0)
2102 && strcmp (current->name, _PDATA) != 0
2103 && strcmp (current->name, _RCONST) != 0)
2105 sofar = (sofar + round - 1) &~ (round - 1);
2108 else if (strcmp (current->name, _LIB) == 0)
2110 /* On Irix 4, the location of contents of the .lib section
2111 from a shared library section is also rounded up to a
2114 sofar = (sofar + round - 1) &~ (round - 1);
2116 else if (first_nonalloc
2117 && (current->flags & SEC_ALLOC) == 0
2118 && (abfd->flags & D_PAGED) != 0)
2120 /* Skip up to the next page for an unallocated section, such
2121 as the .comment section on the Alpha. This leaves room
2122 for the .bss section. */
2123 first_nonalloc = false;
2124 sofar = (sofar + round - 1) &~ (round - 1);
2127 /* Align the sections in the file to the same boundary on
2128 which they are aligned in virtual memory. */
2130 sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2132 if ((abfd->flags & D_PAGED) != 0
2133 && (current->flags & SEC_ALLOC) != 0)
2134 sofar += (current->vma - sofar) % round;
2136 if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) != 0)
2137 current->filepos = sofar;
2139 sofar += current->_raw_size;
2141 /* make sure that this section is of the right size too */
2143 sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2144 current->_raw_size += sofar - old_sofar;
2150 ecoff_data (abfd)->reloc_filepos = sofar;
2155 /* Determine the location of the relocs for all the sections in the
2156 output file, as well as the location of the symbolic debugging
2159 static bfd_size_type
2160 ecoff_compute_reloc_file_positions (abfd)
2163 const bfd_size_type external_reloc_size =
2164 ecoff_backend (abfd)->external_reloc_size;
2165 file_ptr reloc_base;
2166 bfd_size_type reloc_size;
2170 if (! abfd->output_has_begun)
2172 if (! ecoff_compute_section_file_positions (abfd))
2174 abfd->output_has_begun = true;
2177 reloc_base = ecoff_data (abfd)->reloc_filepos;
2180 for (current = abfd->sections;
2181 current != (asection *)NULL;
2182 current = current->next)
2184 if (current->reloc_count == 0)
2185 current->rel_filepos = 0;
2188 bfd_size_type relsize;
2190 current->rel_filepos = reloc_base;
2191 relsize = current->reloc_count * external_reloc_size;
2192 reloc_size += relsize;
2193 reloc_base += relsize;
2197 sym_base = ecoff_data (abfd)->reloc_filepos + reloc_size;
2199 /* At least on Ultrix, the symbol table of an executable file must
2200 be aligned to a page boundary. FIXME: Is this true on other
2202 if ((abfd->flags & EXEC_P) != 0
2203 && (abfd->flags & D_PAGED) != 0)
2204 sym_base = ((sym_base + ecoff_backend (abfd)->round - 1)
2205 &~ (ecoff_backend (abfd)->round - 1));
2207 ecoff_data (abfd)->sym_filepos = sym_base;
2212 /* Set the contents of a section. */
2215 _bfd_ecoff_set_section_contents (abfd, section, location, offset, count)
2220 bfd_size_type count;
2222 /* This must be done first, because bfd_set_section_contents is
2223 going to set output_has_begun to true. */
2224 if (abfd->output_has_begun == false)
2226 if (! ecoff_compute_section_file_positions (abfd))
2230 /* If this is a .lib section, bump the vma address so that it winds
2231 up being the number of .lib sections output. This is right for
2232 Irix 4. Ian Taylor <ian@cygnus.com>. */
2233 if (strcmp (section->name, _LIB) == 0)
2239 if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
2240 || bfd_write (location, 1, count, abfd) != count)
2246 /* Get the GP value for an ECOFF file. This is a hook used by
2250 bfd_ecoff_get_gp_value (abfd)
2253 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2254 || bfd_get_format (abfd) != bfd_object)
2256 bfd_set_error (bfd_error_invalid_operation);
2260 return ecoff_data (abfd)->gp;
2263 /* Set the GP value for an ECOFF file. This is a hook used by the
2267 bfd_ecoff_set_gp_value (abfd, gp_value)
2271 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2272 || bfd_get_format (abfd) != bfd_object)
2274 bfd_set_error (bfd_error_invalid_operation);
2278 ecoff_data (abfd)->gp = gp_value;
2283 /* Set the register masks for an ECOFF file. This is a hook used by
2287 bfd_ecoff_set_regmasks (abfd, gprmask, fprmask, cprmask)
2289 unsigned long gprmask;
2290 unsigned long fprmask;
2291 unsigned long *cprmask;
2293 ecoff_data_type *tdata;
2295 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2296 || bfd_get_format (abfd) != bfd_object)
2298 bfd_set_error (bfd_error_invalid_operation);
2302 tdata = ecoff_data (abfd);
2303 tdata->gprmask = gprmask;
2304 tdata->fprmask = fprmask;
2305 if (cprmask != (unsigned long *) NULL)
2309 for (i = 0; i < 3; i++)
2310 tdata->cprmask[i] = cprmask[i];
2316 /* Get ECOFF EXTR information for an external symbol. This function
2317 is passed to bfd_ecoff_debug_externals. */
2320 ecoff_get_extr (sym, esym)
2324 ecoff_symbol_type *ecoff_sym_ptr;
2327 if (bfd_asymbol_flavour (sym) != bfd_target_ecoff_flavour
2328 || ecoffsymbol (sym)->native == NULL)
2330 /* Don't include debugging, local, or section symbols. */
2331 if ((sym->flags & BSF_DEBUGGING) != 0
2332 || (sym->flags & BSF_LOCAL) != 0
2333 || (sym->flags & BSF_SECTION_SYM) != 0)
2337 esym->cobol_main = 0;
2338 esym->weakext = (sym->flags & BSF_WEAK) != 0;
2341 /* FIXME: we can do better than this for st and sc. */
2342 esym->asym.st = stGlobal;
2343 esym->asym.sc = scAbs;
2344 esym->asym.reserved = 0;
2345 esym->asym.index = indexNil;
2349 ecoff_sym_ptr = ecoffsymbol (sym);
2351 if (ecoff_sym_ptr->local)
2354 input_bfd = bfd_asymbol_bfd (sym);
2355 (*(ecoff_backend (input_bfd)->debug_swap.swap_ext_in))
2356 (input_bfd, ecoff_sym_ptr->native, esym);
2358 /* If the symbol was defined by the linker, then esym will be
2359 undefined but sym will not be. Get a better class for such a
2361 if ((esym->asym.sc == scUndefined
2362 || esym->asym.sc == scSUndefined)
2363 && ! bfd_is_und_section (bfd_get_section (sym)))
2364 esym->asym.sc = scAbs;
2366 /* Adjust the FDR index for the symbol by that used for the input
2368 if (esym->ifd != -1)
2370 struct ecoff_debug_info *input_debug;
2372 input_debug = &ecoff_data (input_bfd)->debug_info;
2373 BFD_ASSERT (esym->ifd < input_debug->symbolic_header.ifdMax);
2374 if (input_debug->ifdmap != (RFDT *) NULL)
2375 esym->ifd = input_debug->ifdmap[esym->ifd];
2381 /* Set the external symbol index. This routine is passed to
2382 bfd_ecoff_debug_externals. */
2385 ecoff_set_index (sym, indx)
2389 ecoff_set_sym_index (sym, indx);
2392 /* Write out an ECOFF file. */
2395 _bfd_ecoff_write_object_contents (abfd)
2398 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
2399 const bfd_vma round = backend->round;
2400 const bfd_size_type filhsz = bfd_coff_filhsz (abfd);
2401 const bfd_size_type aoutsz = bfd_coff_aoutsz (abfd);
2402 const bfd_size_type scnhsz = bfd_coff_scnhsz (abfd);
2403 const bfd_size_type external_hdr_size
2404 = backend->debug_swap.external_hdr_size;
2405 const bfd_size_type external_reloc_size = backend->external_reloc_size;
2406 void (* const adjust_reloc_out) PARAMS ((bfd *,
2408 struct internal_reloc *))
2409 = backend->adjust_reloc_out;
2410 void (* const swap_reloc_out) PARAMS ((bfd *,
2411 const struct internal_reloc *,
2413 = backend->swap_reloc_out;
2414 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
2415 HDRR * const symhdr = &debug->symbolic_header;
2418 bfd_size_type reloc_size;
2419 bfd_size_type text_size;
2421 boolean set_text_start;
2422 bfd_size_type data_size;
2424 boolean set_data_start;
2425 bfd_size_type bss_size;
2427 PTR reloc_buff = NULL;
2428 struct internal_filehdr internal_f;
2429 struct internal_aouthdr internal_a;
2432 /* Determine where the sections and relocs will go in the output
2434 reloc_size = ecoff_compute_reloc_file_positions (abfd);
2437 for (current = abfd->sections;
2438 current != (asection *)NULL;
2439 current = current->next)
2441 current->target_index = count;
2445 if ((abfd->flags & D_PAGED) != 0)
2446 text_size = _bfd_ecoff_sizeof_headers (abfd, false);
2450 set_text_start = false;
2453 set_data_start = false;
2456 /* Write section headers to the file. */
2458 /* Allocate buff big enough to hold a section header,
2459 file header, or a.out header. */
2467 buff = (PTR) bfd_malloc ((size_t) siz);
2472 internal_f.f_nscns = 0;
2473 if (bfd_seek (abfd, (file_ptr) (filhsz + aoutsz), SEEK_SET) != 0)
2475 for (current = abfd->sections;
2476 current != (asection *) NULL;
2477 current = current->next)
2479 struct internal_scnhdr section;
2482 ++internal_f.f_nscns;
2484 strncpy (section.s_name, current->name, sizeof section.s_name);
2486 /* This seems to be correct for Irix 4 shared libraries. */
2487 vma = bfd_get_section_vma (abfd, current);
2488 if (strcmp (current->name, _LIB) == 0)
2489 section.s_vaddr = 0;
2491 section.s_vaddr = vma;
2493 section.s_paddr = current->lma;
2494 section.s_size = bfd_get_section_size_before_reloc (current);
2496 /* If this section is unloadable then the scnptr will be 0. */
2497 if ((current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2498 section.s_scnptr = 0;
2500 section.s_scnptr = current->filepos;
2501 section.s_relptr = current->rel_filepos;
2503 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2504 object file produced by the assembler is supposed to point to
2505 information about how much room is required by objects of
2506 various different sizes. I think this only matters if we
2507 want the linker to compute the best size to use, or
2508 something. I don't know what happens if the information is
2510 if (strcmp (current->name, _PDATA) != 0)
2511 section.s_lnnoptr = 0;
2514 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2515 hold the number of entries in the section (each entry is
2516 8 bytes). We stored this in the line_filepos field in
2517 ecoff_compute_section_file_positions. */
2518 section.s_lnnoptr = current->line_filepos;
2521 section.s_nreloc = current->reloc_count;
2522 section.s_nlnno = 0;
2523 section.s_flags = ecoff_sec_to_styp_flags (current->name,
2526 if (bfd_coff_swap_scnhdr_out (abfd, (PTR) §ion, buff) == 0
2527 || bfd_write (buff, 1, scnhsz, abfd) != scnhsz)
2530 if ((section.s_flags & STYP_TEXT) != 0
2531 || ((section.s_flags & STYP_RDATA) != 0
2532 && backend->rdata_in_text)
2533 || section.s_flags == STYP_PDATA
2534 || (section.s_flags & STYP_DYNAMIC) != 0
2535 || (section.s_flags & STYP_LIBLIST) != 0
2536 || (section.s_flags & STYP_RELDYN) != 0
2537 || section.s_flags == STYP_CONFLIC
2538 || (section.s_flags & STYP_DYNSTR) != 0
2539 || (section.s_flags & STYP_DYNSYM) != 0
2540 || (section.s_flags & STYP_HASH) != 0
2541 || (section.s_flags & STYP_ECOFF_INIT) != 0
2542 || (section.s_flags & STYP_ECOFF_FINI) != 0
2543 || section.s_flags == STYP_RCONST)
2545 text_size += bfd_get_section_size_before_reloc (current);
2546 if (! set_text_start || text_start > vma)
2549 set_text_start = true;
2552 else if ((section.s_flags & STYP_RDATA) != 0
2553 || (section.s_flags & STYP_DATA) != 0
2554 || (section.s_flags & STYP_LITA) != 0
2555 || (section.s_flags & STYP_LIT8) != 0
2556 || (section.s_flags & STYP_LIT4) != 0
2557 || (section.s_flags & STYP_SDATA) != 0
2558 || section.s_flags == STYP_XDATA
2559 || (section.s_flags & STYP_GOT) != 0)
2561 data_size += bfd_get_section_size_before_reloc (current);
2562 if (! set_data_start || data_start > vma)
2565 set_data_start = true;
2568 else if ((section.s_flags & STYP_BSS) != 0
2569 || (section.s_flags & STYP_SBSS) != 0)
2570 bss_size += bfd_get_section_size_before_reloc (current);
2571 else if (section.s_flags == 0
2572 || (section.s_flags & STYP_ECOFF_LIB) != 0
2573 || section.s_flags == STYP_COMMENT)
2579 /* Set up the file header. */
2581 internal_f.f_magic = ecoff_get_magic (abfd);
2583 /* We will NOT put a fucking timestamp in the header here. Every
2584 time you put it back, I will come in and take it out again. I'm
2585 sorry. This field does not belong here. We fill it with a 0 so
2586 it compares the same but is not a reasonable time. --
2588 internal_f.f_timdat = 0;
2590 if (bfd_get_symcount (abfd) != 0)
2592 /* The ECOFF f_nsyms field is not actually the number of
2593 symbols, it's the size of symbolic information header. */
2594 internal_f.f_nsyms = external_hdr_size;
2595 internal_f.f_symptr = ecoff_data (abfd)->sym_filepos;
2599 internal_f.f_nsyms = 0;
2600 internal_f.f_symptr = 0;
2603 internal_f.f_opthdr = aoutsz;
2605 internal_f.f_flags = F_LNNO;
2606 if (reloc_size == 0)
2607 internal_f.f_flags |= F_RELFLG;
2608 if (bfd_get_symcount (abfd) == 0)
2609 internal_f.f_flags |= F_LSYMS;
2610 if (abfd->flags & EXEC_P)
2611 internal_f.f_flags |= F_EXEC;
2613 if (bfd_little_endian (abfd))
2614 internal_f.f_flags |= F_AR32WR;
2616 internal_f.f_flags |= F_AR32W;
2618 /* Set up the ``optional'' header. */
2619 if ((abfd->flags & D_PAGED) != 0)
2620 internal_a.magic = ECOFF_AOUT_ZMAGIC;
2622 internal_a.magic = ECOFF_AOUT_OMAGIC;
2624 /* FIXME: Is this really correct? */
2625 internal_a.vstamp = symhdr->vstamp;
2627 /* At least on Ultrix, these have to be rounded to page boundaries.
2628 FIXME: Is this true on other platforms? */
2629 if ((abfd->flags & D_PAGED) != 0)
2631 internal_a.tsize = (text_size + round - 1) &~ (round - 1);
2632 internal_a.text_start = text_start &~ (round - 1);
2633 internal_a.dsize = (data_size + round - 1) &~ (round - 1);
2634 internal_a.data_start = data_start &~ (round - 1);
2638 internal_a.tsize = text_size;
2639 internal_a.text_start = text_start;
2640 internal_a.dsize = data_size;
2641 internal_a.data_start = data_start;
2644 /* On Ultrix, the initial portions of the .sbss and .bss segments
2645 are at the end of the data section. The bsize field in the
2646 optional header records how many bss bytes are required beyond
2647 those in the data section. The value is not rounded to a page
2649 if (bss_size < internal_a.dsize - data_size)
2652 bss_size -= internal_a.dsize - data_size;
2653 internal_a.bsize = bss_size;
2654 internal_a.bss_start = internal_a.data_start + internal_a.dsize;
2656 internal_a.entry = bfd_get_start_address (abfd);
2658 internal_a.gp_value = ecoff_data (abfd)->gp;
2660 internal_a.gprmask = ecoff_data (abfd)->gprmask;
2661 internal_a.fprmask = ecoff_data (abfd)->fprmask;
2662 for (i = 0; i < 4; i++)
2663 internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i];
2665 /* Let the backend adjust the headers if necessary. */
2666 if (backend->adjust_headers)
2668 if (! (*backend->adjust_headers) (abfd, &internal_f, &internal_a))
2672 /* Write out the file header and the optional header. */
2674 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
2677 bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, buff);
2678 if (bfd_write (buff, 1, filhsz, abfd) != filhsz)
2681 bfd_coff_swap_aouthdr_out (abfd, (PTR) &internal_a, buff);
2682 if (bfd_write (buff, 1, aoutsz, abfd) != aoutsz)
2685 /* Build the external symbol information. This must be done before
2686 writing out the relocs so that we know the symbol indices. We
2687 don't do this if this BFD was created by the backend linker,
2688 since it will have already handled the symbols and relocs. */
2689 if (! ecoff_data (abfd)->linker)
2691 symhdr->iextMax = 0;
2692 symhdr->issExtMax = 0;
2693 debug->external_ext = debug->external_ext_end = NULL;
2694 debug->ssext = debug->ssext_end = NULL;
2695 if (bfd_ecoff_debug_externals (abfd, debug, &backend->debug_swap,
2696 (((abfd->flags & EXEC_P) == 0)
2698 ecoff_get_extr, ecoff_set_index)
2702 /* Write out the relocs. */
2703 for (current = abfd->sections;
2704 current != (asection *) NULL;
2705 current = current->next)
2707 arelent **reloc_ptr_ptr;
2708 arelent **reloc_end;
2711 if (current->reloc_count == 0)
2715 bfd_alloc (abfd, current->reloc_count * external_reloc_size);
2716 if (reloc_buff == NULL)
2719 reloc_ptr_ptr = current->orelocation;
2720 reloc_end = reloc_ptr_ptr + current->reloc_count;
2721 out_ptr = (char *) reloc_buff;
2723 reloc_ptr_ptr < reloc_end;
2724 reloc_ptr_ptr++, out_ptr += external_reloc_size)
2728 struct internal_reloc in;
2730 memset ((PTR) &in, 0, sizeof in);
2732 reloc = *reloc_ptr_ptr;
2733 sym = *reloc->sym_ptr_ptr;
2735 in.r_vaddr = (reloc->address
2736 + bfd_get_section_vma (abfd, current));
2737 in.r_type = reloc->howto->type;
2739 if ((sym->flags & BSF_SECTION_SYM) == 0)
2741 in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr);
2748 name = bfd_get_section_name (abfd, bfd_get_section (sym));
2749 if (strcmp (name, ".text") == 0)
2750 in.r_symndx = RELOC_SECTION_TEXT;
2751 else if (strcmp (name, ".rdata") == 0)
2752 in.r_symndx = RELOC_SECTION_RDATA;
2753 else if (strcmp (name, ".data") == 0)
2754 in.r_symndx = RELOC_SECTION_DATA;
2755 else if (strcmp (name, ".sdata") == 0)
2756 in.r_symndx = RELOC_SECTION_SDATA;
2757 else if (strcmp (name, ".sbss") == 0)
2758 in.r_symndx = RELOC_SECTION_SBSS;
2759 else if (strcmp (name, ".bss") == 0)
2760 in.r_symndx = RELOC_SECTION_BSS;
2761 else if (strcmp (name, ".init") == 0)
2762 in.r_symndx = RELOC_SECTION_INIT;
2763 else if (strcmp (name, ".lit8") == 0)
2764 in.r_symndx = RELOC_SECTION_LIT8;
2765 else if (strcmp (name, ".lit4") == 0)
2766 in.r_symndx = RELOC_SECTION_LIT4;
2767 else if (strcmp (name, ".xdata") == 0)
2768 in.r_symndx = RELOC_SECTION_XDATA;
2769 else if (strcmp (name, ".pdata") == 0)
2770 in.r_symndx = RELOC_SECTION_PDATA;
2771 else if (strcmp (name, ".fini") == 0)
2772 in.r_symndx = RELOC_SECTION_FINI;
2773 else if (strcmp (name, ".lita") == 0)
2774 in.r_symndx = RELOC_SECTION_LITA;
2775 else if (strcmp (name, "*ABS*") == 0)
2776 in.r_symndx = RELOC_SECTION_ABS;
2777 else if (strcmp (name, ".rconst") == 0)
2778 in.r_symndx = RELOC_SECTION_RCONST;
2784 (*adjust_reloc_out) (abfd, reloc, &in);
2786 (*swap_reloc_out) (abfd, &in, (PTR) out_ptr);
2789 if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0)
2791 if (bfd_write (reloc_buff,
2792 external_reloc_size, current->reloc_count, abfd)
2793 != external_reloc_size * current->reloc_count)
2795 bfd_release (abfd, reloc_buff);
2799 /* Write out the symbolic debugging information. */
2800 if (bfd_get_symcount (abfd) > 0)
2802 /* Write out the debugging information. */
2803 if (bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap,
2804 ecoff_data (abfd)->sym_filepos)
2810 /* The .bss section of a demand paged executable must receive an
2811 entire page. If there are symbols, the symbols will start on the
2812 next page. If there are no symbols, we must fill out the page by
2814 if (bfd_get_symcount (abfd) == 0
2815 && (abfd->flags & EXEC_P) != 0
2816 && (abfd->flags & D_PAGED) != 0)
2820 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2823 if (bfd_read (&c, 1, 1, abfd) == 0)
2825 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2828 if (bfd_write (&c, 1, 1, abfd) != 1)
2832 if (reloc_buff != NULL)
2833 bfd_release (abfd, reloc_buff);
2838 if (reloc_buff != NULL)
2839 bfd_release (abfd, reloc_buff);
2845 /* Archive handling. ECOFF uses what appears to be a unique type of
2846 archive header (armap). The byte ordering of the armap and the
2847 contents are encoded in the name of the armap itself. At least for
2848 now, we only support archives with the same byte ordering in the
2849 armap and the contents.
2851 The first four bytes in the armap are the number of symbol
2852 definitions. This is always a power of two.
2854 This is followed by the symbol definitions. Each symbol definition
2855 occupies 8 bytes. The first four bytes are the offset from the
2856 start of the armap strings to the null-terminated string naming
2857 this symbol. The second four bytes are the file offset to the
2858 archive member which defines this symbol. If the second four bytes
2859 are 0, then this is not actually a symbol definition, and it should
2862 The symbols are hashed into the armap with a closed hashing scheme.
2863 See the functions below for the details of the algorithm.
2865 After the symbol definitions comes four bytes holding the size of
2866 the string table, followed by the string table itself. */
2868 /* The name of an archive headers looks like this:
2869 __________E[BL]E[BL]_ (with a trailing space).
2870 The trailing space is changed to an X if the archive is changed to
2871 indicate that the armap is out of date.
2873 The Alpha seems to use ________64E[BL]E[BL]_. */
2875 #define ARMAP_BIG_ENDIAN 'B'
2876 #define ARMAP_LITTLE_ENDIAN 'L'
2877 #define ARMAP_MARKER 'E'
2878 #define ARMAP_START_LENGTH 10
2879 #define ARMAP_HEADER_MARKER_INDEX 10
2880 #define ARMAP_HEADER_ENDIAN_INDEX 11
2881 #define ARMAP_OBJECT_MARKER_INDEX 12
2882 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2883 #define ARMAP_END_INDEX 14
2884 #define ARMAP_END "_ "
2886 /* This is a magic number used in the hashing algorithm. */
2887 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2889 /* This returns the hash value to use for a string. It also sets
2890 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2891 is the number of entries in the hash table, and HLOG is the log
2895 ecoff_armap_hash (s, rehash, size, hlog)
2897 unsigned int *rehash;
2905 hash = ((hash >> 27) | (hash << 5)) + *s++;
2906 hash *= ARMAP_HASH_MAGIC;
2907 *rehash = (hash & (size - 1)) | 1;
2908 return hash >> (32 - hlog);
2911 /* Read in the armap. */
2914 _bfd_ecoff_slurp_armap (abfd)
2919 struct areltdata *mapdata;
2920 bfd_size_type parsed_size;
2922 struct artdata *ardata;
2925 struct symdef *symdef_ptr;
2928 /* Get the name of the first element. */
2929 i = bfd_read ((PTR) nextname, 1, 16, abfd);
2935 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
2938 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2939 standard COFF armap. We could move the ECOFF armap stuff into
2940 bfd_slurp_armap, but that seems inappropriate since no other
2941 target uses this format. Instead, we check directly for a COFF
2943 if (strncmp (nextname, "/ ", 16) == 0)
2944 return bfd_slurp_armap (abfd);
2946 /* See if the first element is an armap. */
2947 if (strncmp (nextname, ecoff_backend (abfd)->armap_start,
2948 ARMAP_START_LENGTH) != 0
2949 || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER
2950 || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2951 && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2952 || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER
2953 || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2954 && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2955 || strncmp (nextname + ARMAP_END_INDEX,
2956 ARMAP_END, sizeof ARMAP_END - 1) != 0)
2958 bfd_has_map (abfd) = false;
2962 /* Make sure we have the right byte ordering. */
2963 if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2964 ^ (bfd_header_big_endian (abfd)))
2965 || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2966 ^ (bfd_big_endian (abfd))))
2968 bfd_set_error (bfd_error_wrong_format);
2972 /* Read in the armap. */
2973 ardata = bfd_ardata (abfd);
2974 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
2975 if (mapdata == (struct areltdata *) NULL)
2977 parsed_size = mapdata->parsed_size;
2978 bfd_release (abfd, (PTR) mapdata);
2980 raw_armap = (char *) bfd_alloc (abfd, parsed_size);
2981 if (raw_armap == (char *) NULL)
2984 if (bfd_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size)
2986 if (bfd_get_error () != bfd_error_system_call)
2987 bfd_set_error (bfd_error_malformed_archive);
2988 bfd_release (abfd, (PTR) raw_armap);
2992 ardata->tdata = (PTR) raw_armap;
2994 count = bfd_h_get_32 (abfd, (PTR) raw_armap);
2996 ardata->symdef_count = 0;
2997 ardata->cache = (struct ar_cache *) NULL;
2999 /* This code used to overlay the symdefs over the raw archive data,
3000 but that doesn't work on a 64 bit host. */
3002 stringbase = raw_armap + count * 8 + 8;
3004 #ifdef CHECK_ARMAP_HASH
3008 /* Double check that I have the hashing algorithm right by making
3009 sure that every symbol can be looked up successfully. */
3011 for (i = 1; i < count; i <<= 1)
3013 BFD_ASSERT (i == count);
3015 raw_ptr = raw_armap + 4;
3016 for (i = 0; i < count; i++, raw_ptr += 8)
3018 unsigned int name_offset, file_offset;
3019 unsigned int hash, rehash, srch;
3021 name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
3022 file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4));
3023 if (file_offset == 0)
3025 hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count,
3030 /* See if we can rehash to this location. */
3031 for (srch = (hash + rehash) & (count - 1);
3032 srch != hash && srch != i;
3033 srch = (srch + rehash) & (count - 1))
3034 BFD_ASSERT (bfd_h_get_32 (abfd, (PTR) (raw_armap + 8 + srch * 8))
3036 BFD_ASSERT (srch == i);
3040 #endif /* CHECK_ARMAP_HASH */
3042 raw_ptr = raw_armap + 4;
3043 for (i = 0; i < count; i++, raw_ptr += 8)
3044 if (bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4)) != 0)
3045 ++ardata->symdef_count;
3047 symdef_ptr = ((struct symdef *)
3049 ardata->symdef_count * sizeof (struct symdef)));
3053 ardata->symdefs = (carsym *) symdef_ptr;
3055 raw_ptr = raw_armap + 4;
3056 for (i = 0; i < count; i++, raw_ptr += 8)
3058 unsigned int name_offset, file_offset;
3060 file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4));
3061 if (file_offset == 0)
3063 name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
3064 symdef_ptr->s.name = stringbase + name_offset;
3065 symdef_ptr->file_offset = file_offset;
3069 ardata->first_file_filepos = bfd_tell (abfd);
3070 /* Pad to an even boundary. */
3071 ardata->first_file_filepos += ardata->first_file_filepos % 2;
3073 bfd_has_map (abfd) = true;
3078 /* Write out an armap. */
3081 _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx)
3083 unsigned int elength;
3085 unsigned int orl_count;
3088 unsigned int hashsize, hashlog;
3089 unsigned int symdefsize;
3091 unsigned int stringsize;
3092 unsigned int mapsize;
3095 struct stat statbuf;
3098 bfd_byte *hashtable;
3102 /* Ultrix appears to use as a hash table size the least power of two
3103 greater than twice the number of entries. */
3104 for (hashlog = 0; (1 << hashlog) <= 2 * orl_count; hashlog++)
3106 hashsize = 1 << hashlog;
3108 symdefsize = hashsize * 8;
3110 stringsize = stridx + padit;
3112 /* Include 8 bytes to store symdefsize and stringsize in output. */
3113 mapsize = symdefsize + stringsize + 8;
3115 firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength;
3117 memset ((PTR) &hdr, 0, sizeof hdr);
3119 /* Work out the ECOFF armap name. */
3120 strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start);
3121 hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER;
3122 hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] =
3123 (bfd_header_big_endian (abfd)
3125 : ARMAP_LITTLE_ENDIAN);
3126 hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER;
3127 hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] =
3128 bfd_big_endian (abfd) ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN;
3129 memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1);
3131 /* Write the timestamp of the archive header to be just a little bit
3132 later than the timestamp of the file, otherwise the linker will
3133 complain that the index is out of date. Actually, the Ultrix
3134 linker just checks the archive name; the GNU linker may check the
3136 stat (abfd->filename, &statbuf);
3137 sprintf (hdr.ar_date, "%ld", (long) (statbuf.st_mtime + 60));
3139 /* The DECstation uses zeroes for the uid, gid and mode of the
3141 hdr.ar_uid[0] = '0';
3142 hdr.ar_gid[0] = '0';
3143 hdr.ar_mode[0] = '0';
3145 sprintf (hdr.ar_size, "%-10d", (int) mapsize);
3147 hdr.ar_fmag[0] = '`';
3148 hdr.ar_fmag[1] = '\012';
3150 /* Turn all null bytes in the header into spaces. */
3151 for (i = 0; i < sizeof (struct ar_hdr); i++)
3152 if (((char *)(&hdr))[i] == '\0')
3153 (((char *)(&hdr))[i]) = ' ';
3155 if (bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), abfd)
3156 != sizeof (struct ar_hdr))
3159 bfd_h_put_32 (abfd, (bfd_vma) hashsize, temp);
3160 if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
3163 hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize);
3167 current = abfd->archive_head;
3169 for (i = 0; i < orl_count; i++)
3171 unsigned int hash, rehash;
3173 /* Advance firstreal to the file position of this archive
3175 if (((bfd *) map[i].pos) != last_elt)
3179 firstreal += arelt_size (current) + sizeof (struct ar_hdr);
3180 firstreal += firstreal % 2;
3181 current = current->next;
3183 while (current != (bfd *) map[i].pos);
3188 hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog);
3189 if (bfd_h_get_32 (abfd, (PTR) (hashtable + (hash * 8) + 4)) != 0)
3193 /* The desired slot is already taken. */
3194 for (srch = (hash + rehash) & (hashsize - 1);
3196 srch = (srch + rehash) & (hashsize - 1))
3197 if (bfd_h_get_32 (abfd, (PTR) (hashtable + (srch * 8) + 4)) == 0)
3200 BFD_ASSERT (srch != hash);
3205 bfd_h_put_32 (abfd, (bfd_vma) map[i].namidx,
3206 (PTR) (hashtable + hash * 8));
3207 bfd_h_put_32 (abfd, (bfd_vma) firstreal,
3208 (PTR) (hashtable + hash * 8 + 4));
3211 if (bfd_write ((PTR) hashtable, 1, symdefsize, abfd) != symdefsize)
3214 bfd_release (abfd, hashtable);
3216 /* Now write the strings. */
3217 bfd_h_put_32 (abfd, (bfd_vma) stringsize, temp);
3218 if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
3220 for (i = 0; i < orl_count; i++)
3224 len = strlen (*map[i].name) + 1;
3225 if (bfd_write ((PTR) (*map[i].name), 1, len, abfd) != len)
3229 /* The spec sez this should be a newline. But in order to be
3230 bug-compatible for DECstation ar we use a null. */
3233 if (bfd_write ("", 1, 1, abfd) != 1)
3240 /* See whether this BFD is an archive. If it is, read in the armap
3241 and the extended name table. */
3244 _bfd_ecoff_archive_p (abfd)
3247 char armag[SARMAG + 1];
3249 if (bfd_read ((PTR) armag, 1, SARMAG, abfd) != SARMAG
3250 || strncmp (armag, ARMAG, SARMAG) != 0)
3252 if (bfd_get_error () != bfd_error_system_call)
3253 bfd_set_error (bfd_error_wrong_format);
3254 return (const bfd_target *) NULL;
3257 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
3258 involves a cast, we can't do it as the left operand of
3260 abfd->tdata.aout_ar_data =
3261 (struct artdata *) bfd_zalloc (abfd, sizeof (struct artdata));
3263 if (bfd_ardata (abfd) == (struct artdata *) NULL)
3264 return (const bfd_target *) NULL;
3266 bfd_ardata (abfd)->first_file_filepos = SARMAG;
3267 bfd_ardata (abfd)->cache = NULL;
3268 bfd_ardata (abfd)->archive_head = NULL;
3269 bfd_ardata (abfd)->symdefs = NULL;
3270 bfd_ardata (abfd)->extended_names = NULL;
3271 bfd_ardata (abfd)->tdata = NULL;
3273 if (_bfd_ecoff_slurp_armap (abfd) == false
3274 || _bfd_ecoff_slurp_extended_name_table (abfd) == false)
3276 bfd_release (abfd, bfd_ardata (abfd));
3277 abfd->tdata.aout_ar_data = (struct artdata *) NULL;
3278 return (const bfd_target *) NULL;
3284 /* ECOFF linker code. */
3286 static struct bfd_hash_entry *ecoff_link_hash_newfunc
3287 PARAMS ((struct bfd_hash_entry *entry,
3288 struct bfd_hash_table *table,
3289 const char *string));
3290 static boolean ecoff_link_add_archive_symbols
3291 PARAMS ((bfd *, struct bfd_link_info *));
3292 static boolean ecoff_link_check_archive_element
3293 PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
3294 static boolean ecoff_link_add_object_symbols
3295 PARAMS ((bfd *, struct bfd_link_info *));
3296 static boolean ecoff_link_add_externals
3297 PARAMS ((bfd *, struct bfd_link_info *, PTR, char *));
3299 /* Routine to create an entry in an ECOFF link hash table. */
3301 static struct bfd_hash_entry *
3302 ecoff_link_hash_newfunc (entry, table, string)
3303 struct bfd_hash_entry *entry;
3304 struct bfd_hash_table *table;
3307 struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry;
3309 /* Allocate the structure if it has not already been allocated by a
3311 if (ret == (struct ecoff_link_hash_entry *) NULL)
3312 ret = ((struct ecoff_link_hash_entry *)
3313 bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry)));
3314 if (ret == (struct ecoff_link_hash_entry *) NULL)
3317 /* Call the allocation method of the superclass. */
3318 ret = ((struct ecoff_link_hash_entry *)
3319 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3324 /* Set local fields. */
3330 memset ((PTR) &ret->esym, 0, sizeof ret->esym);
3332 return (struct bfd_hash_entry *) ret;
3335 /* Create an ECOFF link hash table. */
3337 struct bfd_link_hash_table *
3338 _bfd_ecoff_bfd_link_hash_table_create (abfd)
3341 struct ecoff_link_hash_table *ret;
3343 ret = ((struct ecoff_link_hash_table *)
3344 bfd_alloc (abfd, sizeof (struct ecoff_link_hash_table)));
3347 if (! _bfd_link_hash_table_init (&ret->root, abfd,
3348 ecoff_link_hash_newfunc))
3351 return (struct bfd_link_hash_table *) NULL;
3356 /* Look up an entry in an ECOFF link hash table. */
3358 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3359 ((struct ecoff_link_hash_entry *) \
3360 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3362 /* Traverse an ECOFF link hash table. */
3364 #define ecoff_link_hash_traverse(table, func, info) \
3365 (bfd_link_hash_traverse \
3367 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
3370 /* Get the ECOFF link hash table from the info structure. This is
3373 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3375 /* Given an ECOFF BFD, add symbols to the global hash table as
3379 _bfd_ecoff_bfd_link_add_symbols (abfd, info)
3381 struct bfd_link_info *info;
3383 switch (bfd_get_format (abfd))
3386 return ecoff_link_add_object_symbols (abfd, info);
3388 return ecoff_link_add_archive_symbols (abfd, info);
3390 bfd_set_error (bfd_error_wrong_format);
3395 /* Add the symbols from an archive file to the global hash table.
3396 This looks through the undefined symbols, looks each one up in the
3397 archive hash table, and adds any associated object file. We do not
3398 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3399 already have a hash table, so there is no reason to construct
3403 ecoff_link_add_archive_symbols (abfd, info)
3405 struct bfd_link_info *info;
3407 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3408 const bfd_byte *raw_armap;
3409 struct bfd_link_hash_entry **pundef;
3410 unsigned int armap_count;
3411 unsigned int armap_log;
3413 const bfd_byte *hashtable;
3414 const char *stringbase;
3416 if (! bfd_has_map (abfd))
3418 /* An empty archive is a special case. */
3419 if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
3421 bfd_set_error (bfd_error_no_armap);
3425 /* If we don't have any raw data for this archive, as can happen on
3426 Irix 4.0.5F, we call the generic routine.
3427 FIXME: We should be more clever about this, since someday tdata
3428 may get to something for a generic archive. */
3429 raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata;
3430 if (raw_armap == (bfd_byte *) NULL)
3431 return (_bfd_generic_link_add_archive_symbols
3432 (abfd, info, ecoff_link_check_archive_element));
3434 armap_count = bfd_h_get_32 (abfd, raw_armap);
3437 for (i = 1; i < armap_count; i <<= 1)
3439 BFD_ASSERT (i == armap_count);
3441 hashtable = raw_armap + 4;
3442 stringbase = (const char *) raw_armap + armap_count * 8 + 8;
3444 /* Look through the list of undefined symbols. */
3445 pundef = &info->hash->undefs;
3446 while (*pundef != (struct bfd_link_hash_entry *) NULL)
3448 struct bfd_link_hash_entry *h;
3449 unsigned int hash, rehash;
3450 unsigned int file_offset;
3456 /* When a symbol is defined, it is not necessarily removed from
3458 if (h->type != bfd_link_hash_undefined
3459 && h->type != bfd_link_hash_common)
3461 /* Remove this entry from the list, for general cleanliness
3462 and because we are going to look through the list again
3463 if we search any more libraries. We can't remove the
3464 entry if it is the tail, because that would lose any
3465 entries we add to the list later on. */
3466 if (*pundef != info->hash->undefs_tail)
3467 *pundef = (*pundef)->next;
3469 pundef = &(*pundef)->next;
3473 /* Native ECOFF linkers do not pull in archive elements merely
3474 to satisfy common definitions, so neither do we. We leave
3475 them on the list, though, in case we are linking against some
3476 other object format. */
3477 if (h->type != bfd_link_hash_undefined)
3479 pundef = &(*pundef)->next;
3483 /* Look for this symbol in the archive hash table. */
3484 hash = ecoff_armap_hash (h->root.string, &rehash, armap_count,
3487 file_offset = bfd_h_get_32 (abfd, hashtable + (hash * 8) + 4);
3488 if (file_offset == 0)
3490 /* Nothing in this slot. */
3491 pundef = &(*pundef)->next;
3495 name = stringbase + bfd_h_get_32 (abfd, hashtable + (hash * 8));
3496 if (name[0] != h->root.string[0]
3497 || strcmp (name, h->root.string) != 0)
3502 /* That was the wrong symbol. Try rehashing. */
3504 for (srch = (hash + rehash) & (armap_count - 1);
3506 srch = (srch + rehash) & (armap_count - 1))
3508 file_offset = bfd_h_get_32 (abfd, hashtable + (srch * 8) + 4);
3509 if (file_offset == 0)
3511 name = stringbase + bfd_h_get_32 (abfd, hashtable + (srch * 8));
3512 if (name[0] == h->root.string[0]
3513 && strcmp (name, h->root.string) == 0)
3522 pundef = &(*pundef)->next;
3529 element = (*backend->get_elt_at_filepos) (abfd, file_offset);
3530 if (element == (bfd *) NULL)
3533 if (! bfd_check_format (element, bfd_object))
3536 /* Unlike the generic linker, we know that this element provides
3537 a definition for an undefined symbol and we know that we want
3538 to include it. We don't need to check anything. */
3539 if (! (*info->callbacks->add_archive_element) (info, element, name))
3541 if (! ecoff_link_add_object_symbols (element, info))
3544 pundef = &(*pundef)->next;
3550 /* This is called if we used _bfd_generic_link_add_archive_symbols
3551 because we were not dealing with an ECOFF archive. */
3554 ecoff_link_check_archive_element (abfd, info, pneeded)
3556 struct bfd_link_info *info;
3559 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3560 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
3561 = backend->debug_swap.swap_ext_in;
3563 bfd_size_type external_ext_size;
3564 PTR external_ext = NULL;
3572 if (! ecoff_slurp_symbolic_header (abfd))
3575 /* If there are no symbols, we don't want it. */
3576 if (bfd_get_symcount (abfd) == 0)
3577 goto successful_return;
3579 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3581 /* Read in the external symbols and external strings. */
3582 external_ext_size = backend->debug_swap.external_ext_size;
3583 esize = symhdr->iextMax * external_ext_size;
3584 external_ext = (PTR) bfd_malloc (esize);
3585 if (external_ext == NULL && esize != 0)
3588 if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
3589 || bfd_read (external_ext, 1, esize, abfd) != esize)
3592 ssext = (char *) bfd_malloc (symhdr->issExtMax);
3593 if (ssext == NULL && symhdr->issExtMax != 0)
3596 if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
3597 || (bfd_read (ssext, 1, symhdr->issExtMax, abfd) !=
3598 (bfd_size_type) symhdr->issExtMax))
3601 /* Look through the external symbols to see if they define some
3602 symbol that is currently undefined. */
3603 ext_ptr = (char *) external_ext;
3604 ext_end = ext_ptr + esize;
3605 for (; ext_ptr < ext_end; ext_ptr += external_ext_size)
3610 struct bfd_link_hash_entry *h;
3612 (*swap_ext_in) (abfd, (PTR) ext_ptr, &esym);
3614 /* See if this symbol defines something. */
3615 if (esym.asym.st != stGlobal
3616 && esym.asym.st != stLabel
3617 && esym.asym.st != stProc)
3620 switch (esym.asym.sc)
3644 name = ssext + esym.asym.iss;
3645 h = bfd_link_hash_lookup (info->hash, name, false, false, true);
3647 /* Unlike the generic linker, we do not pull in elements because
3648 of common symbols. */
3649 if (h == (struct bfd_link_hash_entry *) NULL
3650 || h->type != bfd_link_hash_undefined)
3653 /* Include this element. */
3654 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3656 if (! ecoff_link_add_externals (abfd, info, external_ext, ssext))
3660 goto successful_return;
3664 if (external_ext != NULL)
3665 free (external_ext);
3670 if (external_ext != NULL)
3671 free (external_ext);
3677 /* Add symbols from an ECOFF object file to the global linker hash
3681 ecoff_link_add_object_symbols (abfd, info)
3683 struct bfd_link_info *info;
3686 bfd_size_type external_ext_size;
3687 PTR external_ext = NULL;
3692 if (! ecoff_slurp_symbolic_header (abfd))
3695 /* If there are no symbols, we don't want it. */
3696 if (bfd_get_symcount (abfd) == 0)
3699 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3701 /* Read in the external symbols and external strings. */
3702 external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size;
3703 esize = symhdr->iextMax * external_ext_size;
3704 external_ext = (PTR) bfd_malloc (esize);
3705 if (external_ext == NULL && esize != 0)
3708 if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
3709 || bfd_read (external_ext, 1, esize, abfd) != esize)
3712 ssext = (char *) bfd_malloc (symhdr->issExtMax);
3713 if (ssext == NULL && symhdr->issExtMax != 0)
3716 if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
3717 || (bfd_read (ssext, 1, symhdr->issExtMax, abfd)
3718 != (bfd_size_type) symhdr->issExtMax))
3721 result = ecoff_link_add_externals (abfd, info, external_ext, ssext);
3725 if (external_ext != NULL)
3726 free (external_ext);
3732 if (external_ext != NULL)
3733 free (external_ext);
3737 /* Add the external symbols of an object file to the global linker
3738 hash table. The external symbols and strings we are passed are
3739 just allocated on the stack, and will be discarded. We must
3740 explicitly save any information we may need later on in the link.
3741 We do not want to read the external symbol information again. */
3744 ecoff_link_add_externals (abfd, info, external_ext, ssext)
3746 struct bfd_link_info *info;
3750 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3751 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
3752 = backend->debug_swap.swap_ext_in;
3753 bfd_size_type external_ext_size = backend->debug_swap.external_ext_size;
3754 unsigned long ext_count;
3755 struct ecoff_link_hash_entry **sym_hash;
3759 ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
3761 sym_hash = ((struct ecoff_link_hash_entry **)
3763 ext_count * sizeof (struct bfd_link_hash_entry *)));
3766 ecoff_data (abfd)->sym_hashes = sym_hash;
3768 ext_ptr = (char *) external_ext;
3769 ext_end = ext_ptr + ext_count * external_ext_size;
3770 for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++)
3777 struct ecoff_link_hash_entry *h;
3781 (*swap_ext_in) (abfd, (PTR) ext_ptr, &esym);
3783 /* Skip debugging symbols. */
3785 switch (esym.asym.st)
3801 /* Get the information for this symbol. */
3802 value = esym.asym.value;
3803 switch (esym.asym.sc)
3823 section = bfd_make_section_old_way (abfd, ".text");
3824 value -= section->vma;
3827 section = bfd_make_section_old_way (abfd, ".data");
3828 value -= section->vma;
3831 section = bfd_make_section_old_way (abfd, ".bss");
3832 value -= section->vma;
3835 section = bfd_abs_section_ptr;
3838 section = bfd_und_section_ptr;
3841 section = bfd_make_section_old_way (abfd, ".sdata");
3842 value -= section->vma;
3845 section = bfd_make_section_old_way (abfd, ".sbss");
3846 value -= section->vma;
3849 section = bfd_make_section_old_way (abfd, ".rdata");
3850 value -= section->vma;
3853 if (value > ecoff_data (abfd)->gp_size)
3855 section = bfd_com_section_ptr;
3860 if (ecoff_scom_section.name == NULL)
3862 /* Initialize the small common section. */
3863 ecoff_scom_section.name = SCOMMON;
3864 ecoff_scom_section.flags = SEC_IS_COMMON;
3865 ecoff_scom_section.output_section = &ecoff_scom_section;
3866 ecoff_scom_section.symbol = &ecoff_scom_symbol;
3867 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
3868 ecoff_scom_symbol.name = SCOMMON;
3869 ecoff_scom_symbol.flags = BSF_SECTION_SYM;
3870 ecoff_scom_symbol.section = &ecoff_scom_section;
3871 ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
3873 section = &ecoff_scom_section;
3876 section = bfd_und_section_ptr;
3879 section = bfd_make_section_old_way (abfd, ".init");
3880 value -= section->vma;
3883 section = bfd_make_section_old_way (abfd, ".fini");
3884 value -= section->vma;
3887 section = bfd_make_section_old_way (abfd, ".rconst");
3888 value -= section->vma;
3892 if (section == (asection *) NULL)
3895 name = ssext + esym.asym.iss;
3898 if (! (_bfd_generic_link_add_one_symbol
3900 esym.weakext ? BSF_WEAK : BSF_GLOBAL,
3901 section, value, (const char *) NULL, true, true,
3902 (struct bfd_link_hash_entry **) &h)))
3907 /* If we are building an ECOFF hash table, save the external
3908 symbol information. */
3909 if (info->hash->creator->flavour == bfd_get_flavour (abfd))
3911 if (h->abfd == (bfd *) NULL
3912 || (! bfd_is_und_section (section)
3913 && (! bfd_is_com_section (section)
3914 || (h->root.type != bfd_link_hash_defined
3915 && h->root.type != bfd_link_hash_defweak))))
3921 /* Remember whether this symbol was small undefined. */
3922 if (esym.asym.sc == scSUndefined)
3925 /* If this symbol was ever small undefined, it needs to wind
3926 up in a GP relative section. We can't control the
3927 section of a defined symbol, but we can control the
3928 section of a common symbol. This case is actually needed
3929 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3931 && h->root.type == bfd_link_hash_common
3932 && strcmp (h->root.u.c.p->section->name, SCOMMON) != 0)
3934 h->root.u.c.p->section = bfd_make_section_old_way (abfd,
3936 h->root.u.c.p->section->flags = SEC_ALLOC;
3937 if (h->esym.asym.sc == scCommon)
3938 h->esym.asym.sc = scSCommon;
3946 /* ECOFF final link routines. */
3948 static boolean ecoff_final_link_debug_accumulate
3949 PARAMS ((bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *,
3951 static boolean ecoff_link_write_external
3952 PARAMS ((struct ecoff_link_hash_entry *, PTR));
3953 static boolean ecoff_indirect_link_order
3954 PARAMS ((bfd *, struct bfd_link_info *, asection *,
3955 struct bfd_link_order *));
3956 static boolean ecoff_reloc_link_order
3957 PARAMS ((bfd *, struct bfd_link_info *, asection *,
3958 struct bfd_link_order *));
3960 /* Structure used to pass information to ecoff_link_write_external. */
3965 struct bfd_link_info *info;
3968 /* ECOFF final link routine. This looks through all the input BFDs
3969 and gathers together all the debugging information, and then
3970 processes all the link order information. This may cause it to
3971 close and reopen some input BFDs; I'll see how bad this is. */
3974 _bfd_ecoff_bfd_final_link (abfd, info)
3976 struct bfd_link_info *info;
3978 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3979 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
3982 register bfd *input_bfd;
3984 struct bfd_link_order *p;
3985 struct extsym_info einfo;
3987 /* We accumulate the debugging information counts in the symbolic
3989 symhdr = &debug->symbolic_header;
3991 symhdr->ilineMax = 0;
3995 symhdr->isymMax = 0;
3996 symhdr->ioptMax = 0;
3997 symhdr->iauxMax = 0;
3999 symhdr->issExtMax = 0;
4002 symhdr->iextMax = 0;
4004 /* We accumulate the debugging information itself in the debug_info
4007 debug->external_dnr = NULL;
4008 debug->external_pdr = NULL;
4009 debug->external_sym = NULL;
4010 debug->external_opt = NULL;
4011 debug->external_aux = NULL;
4013 debug->ssext = debug->ssext_end = NULL;
4014 debug->external_fdr = NULL;
4015 debug->external_rfd = NULL;
4016 debug->external_ext = debug->external_ext_end = NULL;
4018 handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info);
4019 if (handle == (PTR) NULL)
4022 /* Accumulate the debugging symbols from each input BFD. */
4023 for (input_bfd = info->input_bfds;
4024 input_bfd != (bfd *) NULL;
4025 input_bfd = input_bfd->link_next)
4029 if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour)
4031 /* Abitrarily set the symbolic header vstamp to the vstamp
4032 of the first object file in the link. */
4033 if (symhdr->vstamp == 0)
4035 = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp;
4036 ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info,
4040 ret = bfd_ecoff_debug_accumulate_other (handle, abfd,
4041 debug, &backend->debug_swap,
4046 /* Combine the register masks. */
4047 ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask;
4048 ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask;
4049 ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0];
4050 ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1];
4051 ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2];
4052 ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3];
4055 /* Write out the external symbols. */
4058 ecoff_link_hash_traverse (ecoff_hash_table (info),
4059 ecoff_link_write_external,
4062 if (info->relocateable)
4064 /* We need to make a pass over the link_orders to count up the
4065 number of relocations we will need to output, so that we know
4066 how much space they will take up. */
4067 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4070 for (p = o->link_order_head;
4071 p != (struct bfd_link_order *) NULL;
4073 if (p->type == bfd_indirect_link_order)
4074 o->reloc_count += p->u.indirect.section->reloc_count;
4075 else if (p->type == bfd_section_reloc_link_order
4076 || p->type == bfd_symbol_reloc_link_order)
4081 /* Compute the reloc and symbol file positions. */
4082 ecoff_compute_reloc_file_positions (abfd);
4084 /* Write out the debugging information. */
4085 if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug,
4086 &backend->debug_swap, info,
4087 ecoff_data (abfd)->sym_filepos))
4090 bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info);
4092 if (info->relocateable)
4094 /* Now reset the reloc_count field of the sections in the output
4095 BFD to 0, so that we can use them to keep track of how many
4096 relocs we have output thus far. */
4097 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4101 /* Get a value for the GP register. */
4102 if (ecoff_data (abfd)->gp == 0)
4104 struct bfd_link_hash_entry *h;
4106 h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
4107 if (h != (struct bfd_link_hash_entry *) NULL
4108 && h->type == bfd_link_hash_defined)
4109 ecoff_data (abfd)->gp = (h->u.def.value
4110 + h->u.def.section->output_section->vma
4111 + h->u.def.section->output_offset);
4112 else if (info->relocateable)
4116 /* Make up a value. */
4118 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4121 && (strcmp (o->name, _SBSS) == 0
4122 || strcmp (o->name, _SDATA) == 0
4123 || strcmp (o->name, _LIT4) == 0
4124 || strcmp (o->name, _LIT8) == 0
4125 || strcmp (o->name, _LITA) == 0))
4128 ecoff_data (abfd)->gp = lo + 0x8000;
4132 /* If the relocate_section function needs to do a reloc
4133 involving the GP value, it should make a reloc_dangerous
4134 callback to warn that GP is not defined. */
4138 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4140 for (p = o->link_order_head;
4141 p != (struct bfd_link_order *) NULL;
4144 if (p->type == bfd_indirect_link_order
4145 && (bfd_get_flavour (p->u.indirect.section->owner)
4146 == bfd_target_ecoff_flavour))
4148 if (! ecoff_indirect_link_order (abfd, info, o, p))
4151 else if (p->type == bfd_section_reloc_link_order
4152 || p->type == bfd_symbol_reloc_link_order)
4154 if (! ecoff_reloc_link_order (abfd, info, o, p))
4159 if (! _bfd_default_link_order (abfd, info, o, p))
4165 bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax;
4167 ecoff_data (abfd)->linker = true;
4172 /* Accumulate the debugging information for an input BFD into the
4173 output BFD. This must read in the symbolic information of the
4177 ecoff_final_link_debug_accumulate (output_bfd, input_bfd, info, handle)
4180 struct bfd_link_info *info;
4183 struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info;
4184 const struct ecoff_debug_swap * const swap =
4185 &ecoff_backend (input_bfd)->debug_swap;
4186 HDRR *symhdr = &debug->symbolic_header;
4189 #define READ(ptr, offset, count, size, type) \
4190 if (symhdr->count == 0) \
4191 debug->ptr = NULL; \
4194 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
4195 if (debug->ptr == NULL) \
4198 goto return_something; \
4200 if ((bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) \
4202 || (bfd_read (debug->ptr, size, symhdr->count, \
4203 input_bfd) != size * symhdr->count)) \
4206 goto return_something; \
4210 /* If raw_syments is not NULL, then the data was already by read by
4211 _bfd_ecoff_slurp_symbolic_info. */
4212 if (ecoff_data (input_bfd)->raw_syments == NULL)
4214 READ (line, cbLineOffset, cbLine, sizeof (unsigned char),
4216 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
4217 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
4218 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
4219 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
4220 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
4222 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
4223 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
4224 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
4228 /* We do not read the external strings or the external symbols. */
4230 ret = (bfd_ecoff_debug_accumulate
4231 (handle, output_bfd, &ecoff_data (output_bfd)->debug_info,
4232 &ecoff_backend (output_bfd)->debug_swap,
4233 input_bfd, debug, swap, info));
4236 if (ecoff_data (input_bfd)->raw_syments == NULL)
4238 if (debug->line != NULL)
4240 if (debug->external_dnr != NULL)
4241 free (debug->external_dnr);
4242 if (debug->external_pdr != NULL)
4243 free (debug->external_pdr);
4244 if (debug->external_sym != NULL)
4245 free (debug->external_sym);
4246 if (debug->external_opt != NULL)
4247 free (debug->external_opt);
4248 if (debug->external_aux != NULL)
4249 free (debug->external_aux);
4250 if (debug->ss != NULL)
4252 if (debug->external_fdr != NULL)
4253 free (debug->external_fdr);
4254 if (debug->external_rfd != NULL)
4255 free (debug->external_rfd);
4257 /* Make sure we don't accidentally follow one of these pointers
4258 into freed memory. */
4260 debug->external_dnr = NULL;
4261 debug->external_pdr = NULL;
4262 debug->external_sym = NULL;
4263 debug->external_opt = NULL;
4264 debug->external_aux = NULL;
4266 debug->external_fdr = NULL;
4267 debug->external_rfd = NULL;
4273 /* Put out information for an external symbol. These come only from
4277 ecoff_link_write_external (h, data)
4278 struct ecoff_link_hash_entry *h;
4281 struct extsym_info *einfo = (struct extsym_info *) data;
4282 bfd *output_bfd = einfo->abfd;
4285 /* We need to check if this symbol is being stripped. */
4286 if (h->root.type == bfd_link_hash_undefined
4287 || h->root.type == bfd_link_hash_undefweak)
4289 else if (einfo->info->strip == strip_all
4290 || (einfo->info->strip == strip_some
4291 && bfd_hash_lookup (einfo->info->keep_hash,
4292 h->root.root.string,
4293 false, false) == NULL))
4298 if (strip || h->written)
4301 if (h->abfd == (bfd *) NULL)
4304 h->esym.cobol_main = 0;
4305 h->esym.weakext = 0;
4306 h->esym.reserved = 0;
4307 h->esym.ifd = ifdNil;
4308 h->esym.asym.value = 0;
4309 h->esym.asym.st = stGlobal;
4311 if (h->root.type != bfd_link_hash_defined
4312 && h->root.type != bfd_link_hash_defweak)
4313 h->esym.asym.sc = scAbs;
4316 asection *output_section;
4319 output_section = h->root.u.def.section->output_section;
4320 name = bfd_section_name (output_section->owner, output_section);
4322 if (strcmp (name, _TEXT) == 0)
4323 h->esym.asym.sc = scText;
4324 else if (strcmp (name, _DATA) == 0)
4325 h->esym.asym.sc = scData;
4326 else if (strcmp (name, _SDATA) == 0)
4327 h->esym.asym.sc = scSData;
4328 else if (strcmp (name, _RDATA) == 0)
4329 h->esym.asym.sc = scRData;
4330 else if (strcmp (name, _BSS) == 0)
4331 h->esym.asym.sc = scBss;
4332 else if (strcmp (name, _SBSS) == 0)
4333 h->esym.asym.sc = scSBss;
4334 else if (strcmp (name, _INIT) == 0)
4335 h->esym.asym.sc = scInit;
4336 else if (strcmp (name, _FINI) == 0)
4337 h->esym.asym.sc = scFini;
4338 else if (strcmp (name, _PDATA) == 0)
4339 h->esym.asym.sc = scPData;
4340 else if (strcmp (name, _XDATA) == 0)
4341 h->esym.asym.sc = scXData;
4342 else if (strcmp (name, _RCONST) == 0)
4343 h->esym.asym.sc = scRConst;
4345 h->esym.asym.sc = scAbs;
4348 h->esym.asym.reserved = 0;
4349 h->esym.asym.index = indexNil;
4351 else if (h->esym.ifd != -1)
4353 struct ecoff_debug_info *debug;
4355 /* Adjust the FDR index for the symbol by that used for the
4357 debug = &ecoff_data (h->abfd)->debug_info;
4358 BFD_ASSERT (h->esym.ifd >= 0
4359 && h->esym.ifd < debug->symbolic_header.ifdMax);
4360 h->esym.ifd = debug->ifdmap[h->esym.ifd];
4363 switch (h->root.type)
4366 case bfd_link_hash_new:
4368 case bfd_link_hash_undefined:
4369 case bfd_link_hash_undefweak:
4370 if (h->esym.asym.sc != scUndefined
4371 && h->esym.asym.sc != scSUndefined)
4372 h->esym.asym.sc = scUndefined;
4374 case bfd_link_hash_defined:
4375 case bfd_link_hash_defweak:
4376 if (h->esym.asym.sc == scUndefined
4377 || h->esym.asym.sc == scSUndefined)
4378 h->esym.asym.sc = scAbs;
4379 else if (h->esym.asym.sc == scCommon)
4380 h->esym.asym.sc = scBss;
4381 else if (h->esym.asym.sc == scSCommon)
4382 h->esym.asym.sc = scSBss;
4383 h->esym.asym.value = (h->root.u.def.value
4384 + h->root.u.def.section->output_section->vma
4385 + h->root.u.def.section->output_offset);
4387 case bfd_link_hash_common:
4388 if (h->esym.asym.sc != scCommon
4389 && h->esym.asym.sc != scSCommon)
4390 h->esym.asym.sc = scCommon;
4391 h->esym.asym.value = h->root.u.c.size;
4393 case bfd_link_hash_indirect:
4394 case bfd_link_hash_warning:
4395 /* FIXME: Ignore these for now. The circumstances under which
4396 they should be written out are not clear to me. */
4400 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4402 h->indx = ecoff_data (output_bfd)->debug_info.symbolic_header.iextMax;
4405 return (bfd_ecoff_debug_one_external
4406 (output_bfd, &ecoff_data (output_bfd)->debug_info,
4407 &ecoff_backend (output_bfd)->debug_swap, h->root.root.string,
4411 /* Relocate and write an ECOFF section into an ECOFF output file. */
4414 ecoff_indirect_link_order (output_bfd, info, output_section, link_order)
4416 struct bfd_link_info *info;
4417 asection *output_section;
4418 struct bfd_link_order *link_order;
4420 asection *input_section;
4422 struct ecoff_section_tdata *section_tdata;
4423 bfd_size_type raw_size;
4424 bfd_size_type cooked_size;
4425 bfd_byte *contents = NULL;
4426 bfd_size_type external_reloc_size;
4427 bfd_size_type external_relocs_size;
4428 PTR external_relocs = NULL;
4430 BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
4432 if (link_order->size == 0)
4435 input_section = link_order->u.indirect.section;
4436 input_bfd = input_section->owner;
4437 section_tdata = ecoff_section_data (input_bfd, input_section);
4439 raw_size = input_section->_raw_size;
4440 cooked_size = input_section->_cooked_size;
4441 if (cooked_size == 0)
4442 cooked_size = raw_size;
4444 BFD_ASSERT (input_section->output_section == output_section);
4445 BFD_ASSERT (input_section->output_offset == link_order->offset);
4446 BFD_ASSERT (cooked_size == link_order->size);
4448 /* Get the section contents. We allocate memory for the larger of
4449 the size before relocating and the size after relocating. */
4450 contents = (bfd_byte *) bfd_malloc (raw_size >= cooked_size
4452 : (size_t) cooked_size);
4453 if (contents == NULL && raw_size != 0)
4456 /* If we are relaxing, the contents may have already been read into
4457 memory, in which case we copy them into our new buffer. We don't
4458 simply reuse the old buffer in case cooked_size > raw_size. */
4459 if (section_tdata != (struct ecoff_section_tdata *) NULL
4460 && section_tdata->contents != (bfd_byte *) NULL)
4461 memcpy (contents, section_tdata->contents, (size_t) raw_size);
4464 if (! bfd_get_section_contents (input_bfd, input_section,
4466 (file_ptr) 0, raw_size))
4470 /* Get the relocs. If we are relaxing MIPS code, they will already
4471 have been read in. Otherwise, we read them in now. */
4472 external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size;
4473 external_relocs_size = external_reloc_size * input_section->reloc_count;
4475 if (section_tdata != (struct ecoff_section_tdata *) NULL
4476 && section_tdata->external_relocs != NULL)
4477 external_relocs = section_tdata->external_relocs;
4480 external_relocs = (PTR) bfd_malloc ((size_t) external_relocs_size);
4481 if (external_relocs == NULL && external_relocs_size != 0)
4484 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4485 || (bfd_read (external_relocs, 1, external_relocs_size, input_bfd)
4486 != external_relocs_size))
4490 /* Relocate the section contents. */
4491 if (! ((*ecoff_backend (input_bfd)->relocate_section)
4492 (output_bfd, info, input_bfd, input_section, contents,
4496 /* Write out the relocated section. */
4497 if (! bfd_set_section_contents (output_bfd,
4500 input_section->output_offset,
4504 /* If we are producing relocateable output, the relocs were
4505 modified, and we write them out now. We use the reloc_count
4506 field of output_section to keep track of the number of relocs we
4507 have output so far. */
4508 if (info->relocateable)
4510 if (bfd_seek (output_bfd,
4511 (output_section->rel_filepos +
4512 output_section->reloc_count * external_reloc_size),
4514 || (bfd_write (external_relocs, 1, external_relocs_size, output_bfd)
4515 != external_relocs_size))
4517 output_section->reloc_count += input_section->reloc_count;
4520 if (contents != NULL)
4522 if (external_relocs != NULL && section_tdata == NULL)
4523 free (external_relocs);
4527 if (contents != NULL)
4529 if (external_relocs != NULL && section_tdata == NULL)
4530 free (external_relocs);
4534 /* Generate a reloc when linking an ECOFF file. This is a reloc
4535 requested by the linker, and does come from any input file. This
4536 is used to build constructor and destructor tables when linking
4540 ecoff_reloc_link_order (output_bfd, info, output_section, link_order)
4542 struct bfd_link_info *info;
4543 asection *output_section;
4544 struct bfd_link_order *link_order;
4546 enum bfd_link_order_type type;
4550 struct internal_reloc in;
4551 bfd_size_type external_reloc_size;
4555 type = link_order->type;
4557 addend = link_order->u.reloc.p->addend;
4559 /* We set up an arelent to pass to the backend adjust_reloc_out
4561 rel.address = link_order->offset;
4563 rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
4566 bfd_set_error (bfd_error_bad_value);
4570 if (type == bfd_section_reloc_link_order)
4572 section = link_order->u.reloc.p->u.section;
4573 rel.sym_ptr_ptr = section->symbol_ptr_ptr;
4577 struct bfd_link_hash_entry *h;
4579 /* Treat a reloc against a defined symbol as though it were
4580 actually against the section. */
4581 h = bfd_wrapped_link_hash_lookup (output_bfd, info,
4582 link_order->u.reloc.p->u.name,
4583 false, false, false);
4585 && (h->type == bfd_link_hash_defined
4586 || h->type == bfd_link_hash_defweak))
4588 type = bfd_section_reloc_link_order;
4589 section = h->u.def.section->output_section;
4590 /* It seems that we ought to add the symbol value to the
4591 addend here, but in practice it has already been added
4592 because it was passed to constructor_callback. */
4593 addend += section->vma + h->u.def.section->output_offset;
4597 /* We can't set up a reloc against a symbol correctly,
4598 because we have no asymbol structure. Currently no
4599 adjust_reloc_out routine cares. */
4600 rel.sym_ptr_ptr = (asymbol **) NULL;
4604 /* All ECOFF relocs are in-place. Put the addend into the object
4607 BFD_ASSERT (rel.howto->partial_inplace);
4611 bfd_reloc_status_type rstat;
4615 size = bfd_get_reloc_size (rel.howto);
4616 buf = (bfd_byte *) bfd_zmalloc (size);
4617 if (buf == (bfd_byte *) NULL)
4619 rstat = _bfd_relocate_contents (rel.howto, output_bfd, addend, buf);
4625 case bfd_reloc_outofrange:
4627 case bfd_reloc_overflow:
4628 if (! ((*info->callbacks->reloc_overflow)
4630 (link_order->type == bfd_section_reloc_link_order
4631 ? bfd_section_name (output_bfd, section)
4632 : link_order->u.reloc.p->u.name),
4633 rel.howto->name, addend, (bfd *) NULL,
4634 (asection *) NULL, (bfd_vma) 0)))
4641 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
4642 (file_ptr) link_order->offset, size);
4650 /* Move the information into a internal_reloc structure. */
4651 in.r_vaddr = (rel.address
4652 + bfd_get_section_vma (output_bfd, output_section));
4653 in.r_type = rel.howto->type;
4655 if (type == bfd_symbol_reloc_link_order)
4657 struct ecoff_link_hash_entry *h;
4659 h = ((struct ecoff_link_hash_entry *)
4660 bfd_wrapped_link_hash_lookup (output_bfd, info,
4661 link_order->u.reloc.p->u.name,
4662 false, false, true));
4663 if (h != (struct ecoff_link_hash_entry *) NULL
4665 in.r_symndx = h->indx;
4668 if (! ((*info->callbacks->unattached_reloc)
4669 (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
4670 (asection *) NULL, (bfd_vma) 0)))
4680 name = bfd_get_section_name (output_bfd, section);
4681 if (strcmp (name, ".text") == 0)
4682 in.r_symndx = RELOC_SECTION_TEXT;
4683 else if (strcmp (name, ".rdata") == 0)
4684 in.r_symndx = RELOC_SECTION_RDATA;
4685 else if (strcmp (name, ".data") == 0)
4686 in.r_symndx = RELOC_SECTION_DATA;
4687 else if (strcmp (name, ".sdata") == 0)
4688 in.r_symndx = RELOC_SECTION_SDATA;
4689 else if (strcmp (name, ".sbss") == 0)
4690 in.r_symndx = RELOC_SECTION_SBSS;
4691 else if (strcmp (name, ".bss") == 0)
4692 in.r_symndx = RELOC_SECTION_BSS;
4693 else if (strcmp (name, ".init") == 0)
4694 in.r_symndx = RELOC_SECTION_INIT;
4695 else if (strcmp (name, ".lit8") == 0)
4696 in.r_symndx = RELOC_SECTION_LIT8;
4697 else if (strcmp (name, ".lit4") == 0)
4698 in.r_symndx = RELOC_SECTION_LIT4;
4699 else if (strcmp (name, ".xdata") == 0)
4700 in.r_symndx = RELOC_SECTION_XDATA;
4701 else if (strcmp (name, ".pdata") == 0)
4702 in.r_symndx = RELOC_SECTION_PDATA;
4703 else if (strcmp (name, ".fini") == 0)
4704 in.r_symndx = RELOC_SECTION_FINI;
4705 else if (strcmp (name, ".lita") == 0)
4706 in.r_symndx = RELOC_SECTION_LITA;
4707 else if (strcmp (name, "*ABS*") == 0)
4708 in.r_symndx = RELOC_SECTION_ABS;
4709 else if (strcmp (name, ".rconst") == 0)
4710 in.r_symndx = RELOC_SECTION_RCONST;
4716 /* Let the BFD backend adjust the reloc. */
4717 (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in);
4719 /* Get some memory and swap out the reloc. */
4720 external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
4721 rbuf = (bfd_byte *) bfd_malloc ((size_t) external_reloc_size);
4722 if (rbuf == (bfd_byte *) NULL)
4725 (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (PTR) rbuf);
4727 ok = (bfd_seek (output_bfd,
4728 (output_section->rel_filepos +
4729 output_section->reloc_count * external_reloc_size),
4731 && (bfd_write ((PTR) rbuf, 1, external_reloc_size, output_bfd)
4732 == external_reloc_size));
4735 ++output_section->reloc_count;