1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright (C) 1990-2017 Free Software Foundation, Inc.
3 Original version by Per Bothner.
4 Full support added by Ian Lance Taylor, ian@cygnus.com.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
28 #include "aout/stab_gnu.h"
30 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
31 some other stuff which we don't want and which conflicts with stuff
34 #include "aout/aout64.h"
37 #undef obj_sym_filepos
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
45 #include "libiberty.h"
47 #define streq(a, b) (strcmp ((a), (b)) == 0)
48 #define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0)
51 /* This stuff is somewhat copied from coffcode.h. */
52 static asection bfd_debug_section =
54 /* name, id, index, next, prev, flags, user_set_vma, */
55 "*DEBUG*", 0, 0, NULL, NULL, 0, 0,
56 /* linker_mark, linker_has_input, gc_mark, compress_status, */
58 /* segment_mark, sec_info_type, use_rela_p, */
60 /* sec_flg0, sec_flg1, sec_flg2, sec_flg3, sec_flg4, sec_flg5, */
62 /* vma, lma, size, rawsize, compressed_size, relax, relax_count, */
64 /* output_offset, output_section, alignment_power, */
66 /* relocation, orelocation, reloc_count, filepos, rel_filepos, */
68 /* line_filepos, userdata, contents, lineno, lineno_count, */
69 0, NULL, NULL, NULL, 0,
70 /* entsize, kept_section, moving_line_filepos, */
72 /* target_index, used_by_bfd, constructor_chain, owner, */
78 /* map_head, map_tail */
82 /* Create an ECOFF object. */
85 _bfd_ecoff_mkobject (bfd *abfd)
87 bfd_size_type amt = sizeof (ecoff_data_type);
89 abfd->tdata.ecoff_obj_data = (struct ecoff_tdata *) bfd_zalloc (abfd, amt);
90 if (abfd->tdata.ecoff_obj_data == NULL)
96 /* This is a hook called by coff_real_object_p to create any backend
97 specific information. */
100 _bfd_ecoff_mkobject_hook (bfd *abfd, void * filehdr, void * aouthdr)
102 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
103 struct internal_aouthdr *internal_a = (struct internal_aouthdr *) aouthdr;
104 ecoff_data_type *ecoff;
106 if (! _bfd_ecoff_mkobject (abfd))
109 ecoff = ecoff_data (abfd);
111 ecoff->sym_filepos = internal_f->f_symptr;
113 if (internal_a != NULL)
117 ecoff->text_start = internal_a->text_start;
118 ecoff->text_end = internal_a->text_start + internal_a->tsize;
119 ecoff->gp = internal_a->gp_value;
120 ecoff->gprmask = internal_a->gprmask;
121 for (i = 0; i < 4; i++)
122 ecoff->cprmask[i] = internal_a->cprmask[i];
123 ecoff->fprmask = internal_a->fprmask;
124 if (internal_a->magic == ECOFF_AOUT_ZMAGIC)
125 abfd->flags |= D_PAGED;
127 abfd->flags &=~ D_PAGED;
130 /* It turns out that no special action is required by the MIPS or
131 Alpha ECOFF backends. They have different information in the
132 a.out header, but we just copy it all (e.g., gprmask, cprmask and
133 fprmask) and let the swapping routines ensure that only relevant
134 information is written out. */
136 return (void *) ecoff;
139 /* Initialize a new section. */
142 _bfd_ecoff_new_section_hook (bfd *abfd, asection *section)
152 { _TEXT, SEC_ALLOC | SEC_CODE | SEC_LOAD },
153 { _INIT, SEC_ALLOC | SEC_CODE | SEC_LOAD },
154 { _FINI, SEC_ALLOC | SEC_CODE | SEC_LOAD },
155 { _DATA, SEC_ALLOC | SEC_DATA | SEC_LOAD },
156 { _SDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD },
157 { _RDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
158 { _LIT8, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
159 { _LIT4, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
160 { _RCONST, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
161 { _PDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
164 /* An Irix 4 shared libary. */
165 { _LIB, SEC_COFF_SHARED_LIBRARY}
168 section->alignment_power = 4;
170 for (i = 0; i < ARRAY_SIZE (section_flags); i++)
171 if (streq (section->name, section_flags[i].name))
173 section->flags |= section_flags[i].flags;
178 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
179 uncertain about .init on some systems and I don't know how shared
182 return _bfd_generic_new_section_hook (abfd, section);
185 /* Determine the machine architecture and type. This is called from
186 the generic COFF routines. It is the inverse of ecoff_get_magic,
187 below. This could be an ECOFF backend routine, with one version
188 for each target, but there aren't all that many ECOFF targets. */
191 _bfd_ecoff_set_arch_mach_hook (bfd *abfd, void * filehdr)
193 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
194 enum bfd_architecture arch;
197 switch (internal_f->f_magic)
200 case MIPS_MAGIC_LITTLE:
202 arch = bfd_arch_mips;
203 mach = bfd_mach_mips3000;
206 case MIPS_MAGIC_LITTLE2:
207 case MIPS_MAGIC_BIG2:
208 /* MIPS ISA level 2: the r6000. */
209 arch = bfd_arch_mips;
210 mach = bfd_mach_mips6000;
213 case MIPS_MAGIC_LITTLE3:
214 case MIPS_MAGIC_BIG3:
215 /* MIPS ISA level 3: the r4000. */
216 arch = bfd_arch_mips;
217 mach = bfd_mach_mips4000;
221 arch = bfd_arch_alpha;
226 arch = bfd_arch_obscure;
231 return bfd_default_set_arch_mach (abfd, arch, mach);
235 _bfd_ecoff_no_long_sections (bfd *abfd, int enable)
242 /* Get the magic number to use based on the architecture and machine.
243 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
246 ecoff_get_magic (bfd *abfd)
250 switch (bfd_get_arch (abfd))
253 switch (bfd_get_mach (abfd))
257 case bfd_mach_mips3000:
258 big = MIPS_MAGIC_BIG;
259 little = MIPS_MAGIC_LITTLE;
262 case bfd_mach_mips6000:
263 big = MIPS_MAGIC_BIG2;
264 little = MIPS_MAGIC_LITTLE2;
267 case bfd_mach_mips4000:
268 big = MIPS_MAGIC_BIG3;
269 little = MIPS_MAGIC_LITTLE3;
273 return bfd_big_endian (abfd) ? big : little;
284 /* Get the section s_flags to use for a section. */
287 ecoff_sec_to_styp_flags (const char *name, flagword flags)
297 { _TEXT, STYP_TEXT },
298 { _DATA, STYP_DATA },
299 { _SDATA, STYP_SDATA },
300 { _RDATA, STYP_RDATA },
301 { _LITA, STYP_LITA },
302 { _LIT8, STYP_LIT8 },
303 { _LIT4, STYP_LIT4 },
305 { _SBSS, STYP_SBSS },
306 { _INIT, STYP_ECOFF_INIT },
307 { _FINI, STYP_ECOFF_FINI },
308 { _PDATA, STYP_PDATA },
309 { _XDATA, STYP_XDATA },
310 { _LIB, STYP_ECOFF_LIB },
312 { _HASH, STYP_HASH },
313 { _DYNAMIC, STYP_DYNAMIC },
314 { _LIBLIST, STYP_LIBLIST },
315 { _RELDYN, STYP_RELDYN },
316 { _CONFLIC, STYP_CONFLIC },
317 { _DYNSTR, STYP_DYNSTR },
318 { _DYNSYM, STYP_DYNSYM },
319 { _RCONST, STYP_RCONST }
323 for (i = 0; i < ARRAY_SIZE (styp_flags); i++)
324 if (streq (name, styp_flags[i].name))
326 styp = styp_flags[i].flags;
332 if (streq (name, _COMMENT))
335 flags &=~ SEC_NEVER_LOAD;
337 else if (flags & SEC_CODE)
339 else if (flags & SEC_DATA)
341 else if (flags & SEC_READONLY)
343 else if (flags & SEC_LOAD)
349 if (flags & SEC_NEVER_LOAD)
355 /* Get the BFD flags to use for a section. */
358 _bfd_ecoff_styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED,
360 const char *name ATTRIBUTE_UNUSED,
361 asection *section ATTRIBUTE_UNUSED,
362 flagword * flags_ptr)
364 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
365 long styp_flags = internal_s->s_flags;
366 flagword sec_flags = 0;
368 if (styp_flags & STYP_NOLOAD)
369 sec_flags |= SEC_NEVER_LOAD;
371 /* For 386 COFF, at least, an unloadable text or data section is
372 actually a shared library section. */
373 if ((styp_flags & STYP_TEXT)
374 || (styp_flags & STYP_ECOFF_INIT)
375 || (styp_flags & STYP_ECOFF_FINI)
376 || (styp_flags & STYP_DYNAMIC)
377 || (styp_flags & STYP_LIBLIST)
378 || (styp_flags & STYP_RELDYN)
379 || styp_flags == STYP_CONFLIC
380 || (styp_flags & STYP_DYNSTR)
381 || (styp_flags & STYP_DYNSYM)
382 || (styp_flags & STYP_HASH))
384 if (sec_flags & SEC_NEVER_LOAD)
385 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
387 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
389 else if ((styp_flags & STYP_DATA)
390 || (styp_flags & STYP_RDATA)
391 || (styp_flags & STYP_SDATA)
392 || styp_flags == STYP_PDATA
393 || styp_flags == STYP_XDATA
394 || (styp_flags & STYP_GOT)
395 || styp_flags == STYP_RCONST)
397 if (sec_flags & SEC_NEVER_LOAD)
398 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
400 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
401 if ((styp_flags & STYP_RDATA)
402 || styp_flags == STYP_PDATA
403 || styp_flags == STYP_RCONST)
404 sec_flags |= SEC_READONLY;
406 else if ((styp_flags & STYP_BSS)
407 || (styp_flags & STYP_SBSS))
408 sec_flags |= SEC_ALLOC;
409 else if ((styp_flags & STYP_INFO) || styp_flags == STYP_COMMENT)
410 sec_flags |= SEC_NEVER_LOAD;
411 else if ((styp_flags & STYP_LITA)
412 || (styp_flags & STYP_LIT8)
413 || (styp_flags & STYP_LIT4))
414 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY;
415 else if (styp_flags & STYP_ECOFF_LIB)
416 sec_flags |= SEC_COFF_SHARED_LIBRARY;
418 sec_flags |= SEC_ALLOC | SEC_LOAD;
420 * flags_ptr = sec_flags;
424 /* Read in the symbolic header for an ECOFF object file. */
427 ecoff_slurp_symbolic_header (bfd *abfd)
429 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
430 bfd_size_type external_hdr_size;
432 HDRR *internal_symhdr;
434 /* See if we've already read it in. */
435 if (ecoff_data (abfd)->debug_info.symbolic_header.magic ==
436 backend->debug_swap.sym_magic)
439 /* See whether there is a symbolic header. */
440 if (ecoff_data (abfd)->sym_filepos == 0)
442 bfd_get_symcount (abfd) = 0;
446 /* At this point bfd_get_symcount (abfd) holds the number of symbols
447 as read from the file header, but on ECOFF this is always the
448 size of the symbolic information header. It would be cleaner to
449 handle this when we first read the file in coffgen.c. */
450 external_hdr_size = backend->debug_swap.external_hdr_size;
451 if (bfd_get_symcount (abfd) != external_hdr_size)
453 bfd_set_error (bfd_error_bad_value);
457 /* Read the symbolic information header. */
458 raw = bfd_malloc (external_hdr_size);
462 if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) != 0
463 || bfd_bread (raw, external_hdr_size, abfd) != external_hdr_size)
465 internal_symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
466 (*backend->debug_swap.swap_hdr_in) (abfd, raw, internal_symhdr);
468 if (internal_symhdr->magic != backend->debug_swap.sym_magic)
470 bfd_set_error (bfd_error_bad_value);
474 /* Now we can get the correct number of symbols. */
475 bfd_get_symcount (abfd) = (internal_symhdr->isymMax
476 + internal_symhdr->iextMax);
487 /* Read in and swap the important symbolic information for an ECOFF
488 object file. This is called by gdb via the read_debug_info entry
489 point in the backend structure. */
492 _bfd_ecoff_slurp_symbolic_info (bfd *abfd,
493 asection *ignore ATTRIBUTE_UNUSED,
494 struct ecoff_debug_info *debug)
496 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
497 HDRR *internal_symhdr;
498 bfd_size_type raw_base;
499 bfd_size_type raw_size;
501 bfd_size_type external_fdr_size;
505 bfd_size_type raw_end;
506 bfd_size_type cb_end;
509 BFD_ASSERT (debug == &ecoff_data (abfd)->debug_info);
511 /* Check whether we've already gotten it, and whether there's any to
513 if (ecoff_data (abfd)->raw_syments != NULL)
515 if (ecoff_data (abfd)->sym_filepos == 0)
517 bfd_get_symcount (abfd) = 0;
521 if (! ecoff_slurp_symbolic_header (abfd))
524 internal_symhdr = &debug->symbolic_header;
526 /* Read all the symbolic information at once. */
527 raw_base = (ecoff_data (abfd)->sym_filepos
528 + backend->debug_swap.external_hdr_size);
530 /* Alpha ecoff makes the determination of raw_size difficult. It has
531 an undocumented debug data section between the symhdr and the first
532 documented section. And the ordering of the sections varies between
533 statically and dynamically linked executables.
534 If bfd supports SEEK_END someday, this code could be simplified. */
537 #define UPDATE_RAW_END(start, count, size) \
538 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
539 if (cb_end > raw_end) \
542 UPDATE_RAW_END (cbLineOffset, cbLine, sizeof (unsigned char));
543 UPDATE_RAW_END (cbDnOffset, idnMax, backend->debug_swap.external_dnr_size);
544 UPDATE_RAW_END (cbPdOffset, ipdMax, backend->debug_swap.external_pdr_size);
545 UPDATE_RAW_END (cbSymOffset, isymMax, backend->debug_swap.external_sym_size);
546 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
547 optimization symtab, not the number of entries. */
548 UPDATE_RAW_END (cbOptOffset, ioptMax, sizeof (char));
549 UPDATE_RAW_END (cbAuxOffset, iauxMax, sizeof (union aux_ext));
550 UPDATE_RAW_END (cbSsOffset, issMax, sizeof (char));
551 UPDATE_RAW_END (cbSsExtOffset, issExtMax, sizeof (char));
552 UPDATE_RAW_END (cbFdOffset, ifdMax, backend->debug_swap.external_fdr_size);
553 UPDATE_RAW_END (cbRfdOffset, crfd, backend->debug_swap.external_rfd_size);
554 UPDATE_RAW_END (cbExtOffset, iextMax, backend->debug_swap.external_ext_size);
556 #undef UPDATE_RAW_END
558 raw_size = raw_end - raw_base;
561 ecoff_data (abfd)->sym_filepos = 0;
564 raw = bfd_alloc (abfd, raw_size);
568 pos = ecoff_data (abfd)->sym_filepos;
569 pos += backend->debug_swap.external_hdr_size;
570 if (bfd_seek (abfd, pos, SEEK_SET) != 0
571 || bfd_bread (raw, raw_size, abfd) != raw_size)
573 bfd_release (abfd, raw);
577 ecoff_data (abfd)->raw_syments = raw;
579 /* Get pointers for the numeric offsets in the HDRR structure. */
580 #define FIX(off1, off2, type) \
581 if (internal_symhdr->off1 == 0) \
582 debug->off2 = NULL; \
584 debug->off2 = (type) ((char *) raw \
585 + (internal_symhdr->off1 \
588 FIX (cbLineOffset, line, unsigned char *);
589 FIX (cbDnOffset, external_dnr, void *);
590 FIX (cbPdOffset, external_pdr, void *);
591 FIX (cbSymOffset, external_sym, void *);
592 FIX (cbOptOffset, external_opt, void *);
593 FIX (cbAuxOffset, external_aux, union aux_ext *);
594 FIX (cbSsOffset, ss, char *);
595 FIX (cbSsExtOffset, ssext, char *);
596 FIX (cbFdOffset, external_fdr, void *);
597 FIX (cbRfdOffset, external_rfd, void *);
598 FIX (cbExtOffset, external_ext, void *);
601 /* I don't want to always swap all the data, because it will just
602 waste time and most programs will never look at it. The only
603 time the linker needs most of the debugging information swapped
604 is when linking big-endian and little-endian MIPS object files
605 together, which is not a common occurrence.
607 We need to look at the fdr to deal with a lot of information in
608 the symbols, so we swap them here. */
609 debug->fdr = (FDR *) bfd_alloc2 (abfd, internal_symhdr->ifdMax,
610 sizeof (struct fdr));
611 if (debug->fdr == NULL)
613 external_fdr_size = backend->debug_swap.external_fdr_size;
614 fdr_ptr = debug->fdr;
615 fraw_src = (char *) debug->external_fdr;
616 /* PR 17512: file: 3372-1243-0.004. */
617 if (fraw_src == NULL && internal_symhdr->ifdMax > 0)
619 fraw_end = fraw_src + internal_symhdr->ifdMax * external_fdr_size;
620 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
621 (*backend->debug_swap.swap_fdr_in) (abfd, (void *) fraw_src, fdr_ptr);
626 /* ECOFF symbol table routines. The ECOFF symbol table is described
627 in gcc/mips-tfile.c. */
629 /* ECOFF uses two common sections. One is the usual one, and the
630 other is for small objects. All the small objects are kept
631 together, and then referenced via the gp pointer, which yields
632 faster assembler code. This is what we use for the small common
634 static asection ecoff_scom_section;
635 static asymbol ecoff_scom_symbol;
636 static asymbol *ecoff_scom_symbol_ptr;
638 /* Create an empty symbol. */
641 _bfd_ecoff_make_empty_symbol (bfd *abfd)
643 ecoff_symbol_type *new_symbol;
644 bfd_size_type amt = sizeof (ecoff_symbol_type);
646 new_symbol = (ecoff_symbol_type *) bfd_zalloc (abfd, amt);
647 if (new_symbol == NULL)
649 new_symbol->symbol.section = NULL;
650 new_symbol->fdr = NULL;
651 new_symbol->local = FALSE;
652 new_symbol->native = NULL;
653 new_symbol->symbol.the_bfd = abfd;
654 return &new_symbol->symbol;
657 /* Set the BFD flags and section for an ECOFF symbol. */
660 ecoff_set_symbol_info (bfd *abfd,
666 asym->the_bfd = abfd;
667 asym->value = ecoff_sym->value;
668 asym->section = &bfd_debug_section;
671 /* Most symbol types are just for debugging. */
672 switch (ecoff_sym->st)
681 if (ECOFF_IS_STAB (ecoff_sym))
683 asym->flags = BSF_DEBUGGING;
688 asym->flags = BSF_DEBUGGING;
693 asym->flags = BSF_EXPORT | BSF_WEAK;
695 asym->flags = BSF_EXPORT | BSF_GLOBAL;
698 asym->flags = BSF_LOCAL;
699 /* Normally, a local stProc symbol will have a corresponding
700 external symbol. We mark the local symbol as a debugging
701 symbol, in order to prevent nm from printing both out.
702 Similarly, we mark stLabel and stabs symbols as debugging
703 symbols. In both cases, we do want to set the value
704 correctly based on the symbol class. */
705 if (ecoff_sym->st == stProc
706 || ecoff_sym->st == stLabel
707 || ECOFF_IS_STAB (ecoff_sym))
708 asym->flags |= BSF_DEBUGGING;
711 if (ecoff_sym->st == stProc || ecoff_sym->st == stStaticProc)
712 asym->flags |= BSF_FUNCTION;
714 switch (ecoff_sym->sc)
717 /* Used for compiler generated labels. Leave them in the
718 debugging section, and mark them as local. If BSF_DEBUGGING
719 is set, then nm does not display them for some reason. If no
720 flags are set then the linker whines about them. */
721 asym->flags = BSF_LOCAL;
724 asym->section = bfd_make_section_old_way (abfd, _TEXT);
725 asym->value -= asym->section->vma;
728 asym->section = bfd_make_section_old_way (abfd, _DATA);
729 asym->value -= asym->section->vma;
732 asym->section = bfd_make_section_old_way (abfd, _BSS);
733 asym->value -= asym->section->vma;
736 asym->flags = BSF_DEBUGGING;
739 asym->section = bfd_abs_section_ptr;
742 asym->section = bfd_und_section_ptr;
752 asym->flags = BSF_DEBUGGING;
755 asym->section = bfd_make_section_old_way (abfd, ".sdata");
756 asym->value -= asym->section->vma;
759 asym->section = bfd_make_section_old_way (abfd, ".sbss");
760 asym->value -= asym->section->vma;
763 asym->section = bfd_make_section_old_way (abfd, ".rdata");
764 asym->value -= asym->section->vma;
767 asym->flags = BSF_DEBUGGING;
770 if (asym->value > ecoff_data (abfd)->gp_size)
772 asym->section = bfd_com_section_ptr;
778 if (ecoff_scom_section.name == NULL)
780 /* Initialize the small common section. */
781 ecoff_scom_section.name = SCOMMON;
782 ecoff_scom_section.flags = SEC_IS_COMMON;
783 ecoff_scom_section.output_section = &ecoff_scom_section;
784 ecoff_scom_section.symbol = &ecoff_scom_symbol;
785 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
786 ecoff_scom_symbol.name = SCOMMON;
787 ecoff_scom_symbol.flags = BSF_SECTION_SYM;
788 ecoff_scom_symbol.section = &ecoff_scom_section;
789 ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
791 asym->section = &ecoff_scom_section;
796 asym->flags = BSF_DEBUGGING;
799 asym->section = bfd_und_section_ptr;
804 asym->section = bfd_make_section_old_way (abfd, ".init");
805 asym->value -= asym->section->vma;
810 asym->flags = BSF_DEBUGGING;
813 asym->section = bfd_make_section_old_way (abfd, ".fini");
814 asym->value -= asym->section->vma;
817 asym->section = bfd_make_section_old_way (abfd, ".rconst");
818 asym->value -= asym->section->vma;
824 /* Look for special constructors symbols and make relocation entries
825 in a special construction section. These are produced by the
826 -fgnu-linker argument to g++. */
827 if (ECOFF_IS_STAB (ecoff_sym))
829 switch (ECOFF_UNMARK_STAB (ecoff_sym->index))
838 /* Mark the symbol as a constructor. */
839 asym->flags |= BSF_CONSTRUCTOR;
846 /* Read an ECOFF symbol table. */
849 _bfd_ecoff_slurp_symbol_table (bfd *abfd)
851 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
852 const bfd_size_type external_ext_size
853 = backend->debug_swap.external_ext_size;
854 const bfd_size_type external_sym_size
855 = backend->debug_swap.external_sym_size;
856 void (* const swap_ext_in) (bfd *, void *, EXTR *)
857 = backend->debug_swap.swap_ext_in;
858 void (* const swap_sym_in) (bfd *, void *, SYMR *)
859 = backend->debug_swap.swap_sym_in;
860 ecoff_symbol_type *internal;
861 ecoff_symbol_type *internal_ptr;
867 /* If we've already read in the symbol table, do nothing. */
868 if (ecoff_data (abfd)->canonical_symbols != NULL)
871 /* Get the symbolic information. */
872 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL,
873 &ecoff_data (abfd)->debug_info))
875 if (bfd_get_symcount (abfd) == 0)
878 internal = (ecoff_symbol_type *) bfd_alloc2 (abfd, bfd_get_symcount (abfd),
879 sizeof (ecoff_symbol_type));
880 if (internal == NULL)
883 internal_ptr = internal;
884 eraw_src = (char *) ecoff_data (abfd)->debug_info.external_ext;
886 + (ecoff_data (abfd)->debug_info.symbolic_header.iextMax
887 * external_ext_size));
888 for (; eraw_src < eraw_end; eraw_src += external_ext_size, internal_ptr++)
892 (*swap_ext_in) (abfd, (void *) eraw_src, &internal_esym);
894 /* PR 17512: file: 3372-1000-0.004. */
895 if (internal_esym.asym.iss >= ecoff_data (abfd)->debug_info.symbolic_header.issExtMax
896 || internal_esym.asym.iss < 0)
899 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ssext
900 + internal_esym.asym.iss);
902 if (!ecoff_set_symbol_info (abfd, &internal_esym.asym,
903 &internal_ptr->symbol, 1,
904 internal_esym.weakext))
907 /* The alpha uses a negative ifd field for section symbols. */
908 if (internal_esym.ifd >= 0)
910 /* PR 17512: file: 3372-1983-0.004. */
911 if (internal_esym.ifd >= ecoff_data (abfd)->debug_info.symbolic_header.ifdMax)
912 internal_ptr->fdr = NULL;
914 internal_ptr->fdr = (ecoff_data (abfd)->debug_info.fdr
915 + internal_esym.ifd);
918 internal_ptr->fdr = NULL;
919 internal_ptr->local = FALSE;
920 internal_ptr->native = (void *) eraw_src;
923 /* The local symbols must be accessed via the fdr's, because the
924 string and aux indices are relative to the fdr information. */
925 fdr_ptr = ecoff_data (abfd)->debug_info.fdr;
926 fdr_end = fdr_ptr + ecoff_data (abfd)->debug_info.symbolic_header.ifdMax;
927 for (; fdr_ptr < fdr_end; fdr_ptr++)
932 lraw_src = ((char *) ecoff_data (abfd)->debug_info.external_sym
933 + fdr_ptr->isymBase * external_sym_size);
934 lraw_end = lraw_src + fdr_ptr->csym * external_sym_size;
937 lraw_src += external_sym_size, internal_ptr++)
941 (*swap_sym_in) (abfd, (void *) lraw_src, &internal_sym);
942 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ss
945 if (!ecoff_set_symbol_info (abfd, &internal_sym,
946 &internal_ptr->symbol, 0, 0))
948 internal_ptr->fdr = fdr_ptr;
949 internal_ptr->local = TRUE;
950 internal_ptr->native = (void *) lraw_src;
954 /* PR 17512: file: 3372-3080-0.004.
955 A discrepancy between ecoff_data (abfd)->debug_info.symbolic_header.isymMax
956 and ecoff_data (abfd)->debug_info.symbolic_header.ifdMax can mean that
957 we have fewer symbols than we were expecting. Allow for this by updating
958 the symbol count and warning the user. */
959 if (internal_ptr - internal < (ptrdiff_t) bfd_get_symcount (abfd))
961 bfd_get_symcount (abfd) = internal_ptr - internal;
963 /* xgettext:c-format */
964 (_("%B: warning: isymMax (%ld) is greater than ifdMax (%ld)"),
965 abfd, ecoff_data (abfd)->debug_info.symbolic_header.isymMax,
966 ecoff_data (abfd)->debug_info.symbolic_header.ifdMax);
969 ecoff_data (abfd)->canonical_symbols = internal;
974 /* Return the amount of space needed for the canonical symbols. */
977 _bfd_ecoff_get_symtab_upper_bound (bfd *abfd)
979 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL,
980 &ecoff_data (abfd)->debug_info))
983 if (bfd_get_symcount (abfd) == 0)
986 return (bfd_get_symcount (abfd) + 1) * (sizeof (ecoff_symbol_type *));
989 /* Get the canonical symbols. */
992 _bfd_ecoff_canonicalize_symtab (bfd *abfd, asymbol **alocation)
994 unsigned int counter = 0;
995 ecoff_symbol_type *symbase;
996 ecoff_symbol_type **location = (ecoff_symbol_type **) alocation;
998 if (! _bfd_ecoff_slurp_symbol_table (abfd))
1000 if (bfd_get_symcount (abfd) == 0)
1003 symbase = ecoff_data (abfd)->canonical_symbols;
1004 while (counter < bfd_get_symcount (abfd))
1006 *(location++) = symbase++;
1010 return bfd_get_symcount (abfd);
1013 /* Turn ECOFF type information into a printable string.
1014 ecoff_emit_aggregate and ecoff_type_to_string are from
1015 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1017 /* Write aggregate information to a string. */
1020 ecoff_emit_aggregate (bfd *abfd,
1027 const struct ecoff_debug_swap * const debug_swap =
1028 &ecoff_backend (abfd)->debug_swap;
1029 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info;
1030 unsigned int ifd = rndx->rfd;
1031 unsigned int indx = rndx->index;
1037 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1038 struct return type of a procedure compiled without -g. */
1039 if (ifd == 0xffffffff
1040 || (rndx->rfd == 0xfff && indx == 0))
1041 name = "<undefined>";
1042 else if (indx == indexNil)
1048 if (debug_info->external_rfd == NULL)
1049 fdr = debug_info->fdr + ifd;
1054 (*debug_swap->swap_rfd_in) (abfd,
1055 ((char *) debug_info->external_rfd
1056 + ((fdr->rfdBase + ifd)
1057 * debug_swap->external_rfd_size)),
1059 fdr = debug_info->fdr + rfd;
1062 indx += fdr->isymBase;
1064 (*debug_swap->swap_sym_in) (abfd,
1065 ((char *) debug_info->external_sym
1066 + indx * debug_swap->external_sym_size),
1069 name = debug_info->ss + fdr->issBase + sym.iss;
1073 "%s %s { ifd = %u, index = %lu }",
1075 ((unsigned long) indx
1076 + debug_info->symbolic_header.iextMax));
1079 /* Convert the type information to string format. */
1082 ecoff_type_to_string (bfd *abfd, FDR *fdr, unsigned int indx)
1084 union aux_ext *aux_ptr;
1094 unsigned int basic_type;
1097 static char buffer2[1024];
1102 aux_ptr = ecoff_data (abfd)->debug_info.external_aux + fdr->iauxBase;
1103 bigendian = fdr->fBigendian;
1105 for (i = 0; i < 7; i++)
1107 qualifiers[i].low_bound = 0;
1108 qualifiers[i].high_bound = 0;
1109 qualifiers[i].stride = 0;
1112 if (AUX_GET_ISYM (bigendian, &aux_ptr[indx]) == (bfd_vma) -1)
1113 return "-1 (no type)";
1114 _bfd_ecoff_swap_tir_in (bigendian, &aux_ptr[indx++].a_ti, &u.ti);
1116 basic_type = u.ti.bt;
1117 qualifiers[0].type = u.ti.tq0;
1118 qualifiers[1].type = u.ti.tq1;
1119 qualifiers[2].type = u.ti.tq2;
1120 qualifiers[3].type = u.ti.tq3;
1121 qualifiers[4].type = u.ti.tq4;
1122 qualifiers[5].type = u.ti.tq5;
1123 qualifiers[6].type = tqNil;
1125 /* Go get the basic type. */
1128 case btNil: /* Undefined. */
1132 case btAdr: /* Address - integer same size as pointer. */
1133 strcpy (p1, "address");
1136 case btChar: /* Character. */
1137 strcpy (p1, "char");
1140 case btUChar: /* Unsigned character. */
1141 strcpy (p1, "unsigned char");
1144 case btShort: /* Short. */
1145 strcpy (p1, "short");
1148 case btUShort: /* Unsigned short. */
1149 strcpy (p1, "unsigned short");
1152 case btInt: /* Int. */
1156 case btUInt: /* Unsigned int. */
1157 strcpy (p1, "unsigned int");
1160 case btLong: /* Long. */
1161 strcpy (p1, "long");
1164 case btULong: /* Unsigned long. */
1165 strcpy (p1, "unsigned long");
1168 case btFloat: /* Float (real). */
1169 strcpy (p1, "float");
1172 case btDouble: /* Double (real). */
1173 strcpy (p1, "double");
1176 /* Structures add 1-2 aux words:
1177 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1178 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1180 case btStruct: /* Structure (Record). */
1181 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1182 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1183 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1185 indx++; /* Skip aux words. */
1188 /* Unions add 1-2 aux words:
1189 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1190 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1192 case btUnion: /* Union. */
1193 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1194 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1195 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1197 indx++; /* Skip aux words. */
1200 /* Enumerations add 1-2 aux words:
1201 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1202 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1204 case btEnum: /* Enumeration. */
1205 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1206 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1207 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1209 indx++; /* Skip aux words. */
1212 case btTypedef: /* Defined via a typedef, isymRef points. */
1213 strcpy (p1, "typedef");
1216 case btRange: /* Subrange of int. */
1217 strcpy (p1, "subrange");
1220 case btSet: /* Pascal sets. */
1224 case btComplex: /* Fortran complex. */
1225 strcpy (p1, "complex");
1228 case btDComplex: /* Fortran double complex. */
1229 strcpy (p1, "double complex");
1232 case btIndirect: /* Forward or unnamed typedef. */
1233 strcpy (p1, "forward/unamed typedef");
1236 case btFixedDec: /* Fixed Decimal. */
1237 strcpy (p1, "fixed decimal");
1240 case btFloatDec: /* Float Decimal. */
1241 strcpy (p1, "float decimal");
1244 case btString: /* Varying Length Character String. */
1245 strcpy (p1, "string");
1248 case btBit: /* Aligned Bit String. */
1252 case btPicture: /* Picture. */
1253 strcpy (p1, "picture");
1256 case btVoid: /* Void. */
1257 strcpy (p1, "void");
1261 sprintf (p1, _("Unknown basic type %d"), (int) basic_type);
1265 p1 += strlen (buffer1);
1267 /* If this is a bitfield, get the bitsize. */
1272 bitsize = AUX_GET_WIDTH (bigendian, &aux_ptr[indx++]);
1273 sprintf (p1, " : %d", bitsize);
1274 p1 += strlen (buffer1);
1277 /* Deal with any qualifiers. */
1278 if (qualifiers[0].type != tqNil)
1280 /* Snarf up any array bounds in the correct order. Arrays
1281 store 5 successive words in the aux. table:
1282 word 0 RNDXR to type of the bounds (ie, int)
1283 word 1 Current file descriptor index
1285 word 3 high bound (or -1 if [])
1286 word 4 stride size in bits. */
1287 for (i = 0; i < 7; i++)
1289 if (qualifiers[i].type == tqArray)
1291 qualifiers[i].low_bound =
1292 AUX_GET_DNLOW (bigendian, &aux_ptr[indx+2]);
1293 qualifiers[i].high_bound =
1294 AUX_GET_DNHIGH (bigendian, &aux_ptr[indx+3]);
1295 qualifiers[i].stride =
1296 AUX_GET_WIDTH (bigendian, &aux_ptr[indx+4]);
1301 /* Now print out the qualifiers. */
1302 for (i = 0; i < 6; i++)
1304 switch (qualifiers[i].type)
1311 strcpy (p2, "ptr to ");
1312 p2 += sizeof ("ptr to ")-1;
1316 strcpy (p2, "volatile ");
1317 p2 += sizeof ("volatile ")-1;
1321 strcpy (p2, "far ");
1322 p2 += sizeof ("far ")-1;
1326 strcpy (p2, "func. ret. ");
1327 p2 += sizeof ("func. ret. ");
1332 int first_array = i;
1335 /* Print array bounds reversed (ie, in the order the C
1336 programmer writes them). C is such a fun language.... */
1337 while (i < 5 && qualifiers[i+1].type == tqArray)
1340 for (j = i; j >= first_array; j--)
1342 strcpy (p2, "array [");
1343 p2 += sizeof ("array [")-1;
1344 if (qualifiers[j].low_bound != 0)
1346 "%ld:%ld {%ld bits}",
1347 (long) qualifiers[j].low_bound,
1348 (long) qualifiers[j].high_bound,
1349 (long) qualifiers[j].stride);
1351 else if (qualifiers[j].high_bound != -1)
1354 (long) (qualifiers[j].high_bound + 1),
1355 (long) (qualifiers[j].stride));
1358 sprintf (p2, " {%ld bits}", (long) (qualifiers[j].stride));
1361 strcpy (p2, "] of ");
1362 p2 += sizeof ("] of ")-1;
1370 strcpy (p2, buffer1);
1374 /* Return information about ECOFF symbol SYMBOL in RET. */
1377 _bfd_ecoff_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
1381 bfd_symbol_info (symbol, ret);
1384 /* Return whether this is a local label. */
1387 _bfd_ecoff_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
1390 return name[0] == '$';
1393 /* Print information about an ECOFF symbol. */
1396 _bfd_ecoff_print_symbol (bfd *abfd,
1399 bfd_print_symbol_type how)
1401 const struct ecoff_debug_swap * const debug_swap
1402 = &ecoff_backend (abfd)->debug_swap;
1403 FILE *file = (FILE *)filep;
1407 case bfd_print_symbol_name:
1408 fprintf (file, "%s", symbol->name);
1410 case bfd_print_symbol_more:
1411 if (ecoffsymbol (symbol)->local)
1415 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
1417 fprintf (file, "ecoff local ");
1418 fprintf_vma (file, (bfd_vma) ecoff_sym.value);
1419 fprintf (file, " %x %x", (unsigned) ecoff_sym.st,
1420 (unsigned) ecoff_sym.sc);
1426 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
1428 fprintf (file, "ecoff extern ");
1429 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
1430 fprintf (file, " %x %x", (unsigned) ecoff_ext.asym.st,
1431 (unsigned) ecoff_ext.asym.sc);
1434 case bfd_print_symbol_all:
1435 /* Print out the symbols in a reasonable way. */
1444 if (ecoffsymbol (symbol)->local)
1446 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
1449 pos = ((((char *) ecoffsymbol (symbol)->native
1450 - (char *) ecoff_data (abfd)->debug_info.external_sym)
1451 / debug_swap->external_sym_size)
1452 + ecoff_data (abfd)->debug_info.symbolic_header.iextMax);
1459 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
1462 pos = (((char *) ecoffsymbol (symbol)->native
1463 - (char *) ecoff_data (abfd)->debug_info.external_ext)
1464 / debug_swap->external_ext_size);
1465 jmptbl = ecoff_ext.jmptbl ? 'j' : ' ';
1466 cobol_main = ecoff_ext.cobol_main ? 'c' : ' ';
1467 weakext = ecoff_ext.weakext ? 'w' : ' ';
1470 fprintf (file, "[%3d] %c ",
1472 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
1473 fprintf (file, " st %x sc %x indx %x %c%c%c %s",
1474 (unsigned) ecoff_ext.asym.st,
1475 (unsigned) ecoff_ext.asym.sc,
1476 (unsigned) ecoff_ext.asym.index,
1477 jmptbl, cobol_main, weakext,
1480 if (ecoffsymbol (symbol)->fdr != NULL
1481 && ecoff_ext.asym.index != indexNil)
1486 bfd_size_type sym_base;
1487 union aux_ext *aux_base;
1489 fdr = ecoffsymbol (symbol)->fdr;
1490 indx = ecoff_ext.asym.index;
1492 /* sym_base is used to map the fdr relative indices which
1493 appear in the file to the position number which we are
1495 sym_base = fdr->isymBase;
1496 if (ecoffsymbol (symbol)->local)
1498 ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
1500 /* aux_base is the start of the aux entries for this file;
1501 asym.index is an offset from this. */
1502 aux_base = (ecoff_data (abfd)->debug_info.external_aux
1505 /* The aux entries are stored in host byte order; the
1506 order is indicated by a bit in the fdr. */
1507 bigendian = fdr->fBigendian;
1509 /* This switch is basically from gcc/mips-tdump.c. */
1510 switch (ecoff_ext.asym.st)
1518 fprintf (file, _("\n End+1 symbol: %ld"),
1519 (long) (indx + sym_base));
1523 if (ecoff_ext.asym.sc == scText
1524 || ecoff_ext.asym.sc == scInfo)
1525 fprintf (file, _("\n First symbol: %ld"),
1526 (long) (indx + sym_base));
1528 fprintf (file, _("\n First symbol: %ld"),
1530 (AUX_GET_ISYM (bigendian,
1531 &aux_base[ecoff_ext.asym.index])
1537 if (ECOFF_IS_STAB (&ecoff_ext.asym))
1539 else if (ecoffsymbol (symbol)->local)
1540 /* xgettext:c-format */
1541 fprintf (file, _("\n End+1 symbol: %-7ld Type: %s"),
1543 (AUX_GET_ISYM (bigendian,
1544 &aux_base[ecoff_ext.asym.index])
1546 ecoff_type_to_string (abfd, fdr, indx + 1));
1548 fprintf (file, _("\n Local symbol: %ld"),
1551 + (ecoff_data (abfd)
1552 ->debug_info.symbolic_header.iextMax)));
1556 fprintf (file, _("\n struct; End+1 symbol: %ld"),
1557 (long) (indx + sym_base));
1561 fprintf (file, _("\n union; End+1 symbol: %ld"),
1562 (long) (indx + sym_base));
1566 fprintf (file, _("\n enum; End+1 symbol: %ld"),
1567 (long) (indx + sym_base));
1571 if (! ECOFF_IS_STAB (&ecoff_ext.asym))
1572 fprintf (file, _("\n Type: %s"),
1573 ecoff_type_to_string (abfd, fdr, indx));
1582 /* Read in the relocs for a section. */
1585 ecoff_slurp_reloc_table (bfd *abfd,
1589 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
1590 arelent *internal_relocs;
1591 bfd_size_type external_reloc_size;
1593 char *external_relocs;
1597 if (section->relocation != NULL
1598 || section->reloc_count == 0
1599 || (section->flags & SEC_CONSTRUCTOR) != 0)
1602 if (! _bfd_ecoff_slurp_symbol_table (abfd))
1605 amt = section->reloc_count;
1606 amt *= sizeof (arelent);
1607 internal_relocs = (arelent *) bfd_alloc (abfd, amt);
1609 external_reloc_size = backend->external_reloc_size;
1610 amt = external_reloc_size * section->reloc_count;
1611 external_relocs = (char *) bfd_alloc (abfd, amt);
1612 if (internal_relocs == NULL || external_relocs == NULL)
1614 if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0)
1616 if (bfd_bread (external_relocs, amt, abfd) != amt)
1619 for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++)
1621 struct internal_reloc intern;
1623 (*backend->swap_reloc_in) (abfd,
1624 external_relocs + i * external_reloc_size,
1627 if (intern.r_extern)
1629 /* r_symndx is an index into the external symbols. */
1630 BFD_ASSERT (intern.r_symndx >= 0
1632 < (ecoff_data (abfd)
1633 ->debug_info.symbolic_header.iextMax)));
1634 rptr->sym_ptr_ptr = symbols + intern.r_symndx;
1637 else if (intern.r_symndx == RELOC_SECTION_NONE
1638 || intern.r_symndx == RELOC_SECTION_ABS)
1640 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1645 const char *sec_name;
1648 /* r_symndx is a section key. */
1649 switch (intern.r_symndx)
1651 case RELOC_SECTION_TEXT: sec_name = _TEXT; break;
1652 case RELOC_SECTION_RDATA: sec_name = _RDATA; break;
1653 case RELOC_SECTION_DATA: sec_name = _DATA; break;
1654 case RELOC_SECTION_SDATA: sec_name = _SDATA; break;
1655 case RELOC_SECTION_SBSS: sec_name = _SBSS; break;
1656 case RELOC_SECTION_BSS: sec_name = _BSS; break;
1657 case RELOC_SECTION_INIT: sec_name = _INIT; break;
1658 case RELOC_SECTION_LIT8: sec_name = _LIT8; break;
1659 case RELOC_SECTION_LIT4: sec_name = _LIT4; break;
1660 case RELOC_SECTION_XDATA: sec_name = _XDATA; break;
1661 case RELOC_SECTION_PDATA: sec_name = _PDATA; break;
1662 case RELOC_SECTION_FINI: sec_name = _FINI; break;
1663 case RELOC_SECTION_LITA: sec_name = _LITA; break;
1664 case RELOC_SECTION_RCONST: sec_name = _RCONST; break;
1668 sec = bfd_get_section_by_name (abfd, sec_name);
1671 rptr->sym_ptr_ptr = sec->symbol_ptr_ptr;
1673 rptr->addend = - bfd_get_section_vma (abfd, sec);
1676 rptr->address = intern.r_vaddr - bfd_get_section_vma (abfd, section);
1678 /* Let the backend select the howto field and do any other
1679 required processing. */
1680 (*backend->adjust_reloc_in) (abfd, &intern, rptr);
1683 bfd_release (abfd, external_relocs);
1685 section->relocation = internal_relocs;
1690 /* Get a canonical list of relocs. */
1693 _bfd_ecoff_canonicalize_reloc (bfd *abfd,
1700 if (section->flags & SEC_CONSTRUCTOR)
1702 arelent_chain *chain;
1704 /* This section has relocs made up by us, not the file, so take
1705 them out of their chain and place them into the data area
1707 for (count = 0, chain = section->constructor_chain;
1708 count < section->reloc_count;
1709 count++, chain = chain->next)
1710 *relptr++ = &chain->relent;
1716 if (! ecoff_slurp_reloc_table (abfd, section, symbols))
1719 tblptr = section->relocation;
1721 for (count = 0; count < section->reloc_count; count++)
1722 *relptr++ = tblptr++;
1727 return section->reloc_count;
1730 /* Provided a BFD, a section and an offset into the section, calculate
1731 and return the name of the source file and the line nearest to the
1735 _bfd_ecoff_find_nearest_line (bfd *abfd,
1736 asymbol **symbols ATTRIBUTE_UNUSED,
1739 const char **filename_ptr,
1740 const char **functionname_ptr,
1741 unsigned int *retline_ptr,
1742 unsigned int *discriminator_ptr)
1744 const struct ecoff_debug_swap * const debug_swap
1745 = &ecoff_backend (abfd)->debug_swap;
1746 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info;
1747 struct ecoff_find_line *line_info;
1749 /* Make sure we have the FDR's. */
1750 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, debug_info)
1751 || bfd_get_symcount (abfd) == 0)
1754 if (ecoff_data (abfd)->find_line_info == NULL)
1756 bfd_size_type amt = sizeof (struct ecoff_find_line);
1758 ecoff_data (abfd)->find_line_info =
1759 (struct ecoff_find_line *) bfd_zalloc (abfd, amt);
1760 if (ecoff_data (abfd)->find_line_info == NULL)
1764 if (discriminator_ptr)
1765 *discriminator_ptr = 0;
1766 line_info = ecoff_data (abfd)->find_line_info;
1767 return _bfd_ecoff_locate_line (abfd, section, offset, debug_info,
1768 debug_swap, line_info, filename_ptr,
1769 functionname_ptr, retline_ptr);
1772 /* Copy private BFD data. This is called by objcopy and strip. We
1773 use it to copy the ECOFF debugging information from one BFD to the
1774 other. It would be theoretically possible to represent the ECOFF
1775 debugging information in the symbol table. However, it would be a
1776 lot of work, and there would be little gain (gas, gdb, and ld
1777 already access the ECOFF debugging information via the
1778 ecoff_debug_info structure, and that structure would have to be
1779 retained in order to support ECOFF debugging in MIPS ELF).
1781 The debugging information for the ECOFF external symbols comes from
1782 the symbol table, so this function only handles the other debugging
1786 _bfd_ecoff_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1788 struct ecoff_debug_info *iinfo = &ecoff_data (ibfd)->debug_info;
1789 struct ecoff_debug_info *oinfo = &ecoff_data (obfd)->debug_info;
1791 asymbol **sym_ptr_ptr;
1795 /* We only want to copy information over if both BFD's use ECOFF
1797 if (bfd_get_flavour (ibfd) != bfd_target_ecoff_flavour
1798 || bfd_get_flavour (obfd) != bfd_target_ecoff_flavour)
1801 /* Copy the GP value and the register masks. */
1802 ecoff_data (obfd)->gp = ecoff_data (ibfd)->gp;
1803 ecoff_data (obfd)->gprmask = ecoff_data (ibfd)->gprmask;
1804 ecoff_data (obfd)->fprmask = ecoff_data (ibfd)->fprmask;
1805 for (i = 0; i < 3; i++)
1806 ecoff_data (obfd)->cprmask[i] = ecoff_data (ibfd)->cprmask[i];
1808 /* Copy the version stamp. */
1809 oinfo->symbolic_header.vstamp = iinfo->symbolic_header.vstamp;
1811 /* If there are no symbols, don't copy any debugging information. */
1812 c = bfd_get_symcount (obfd);
1813 sym_ptr_ptr = bfd_get_outsymbols (obfd);
1814 if (c == 0 || sym_ptr_ptr == NULL)
1817 /* See if there are any local symbols. */
1819 for (; c > 0; c--, sym_ptr_ptr++)
1821 if (ecoffsymbol (*sym_ptr_ptr)->local)
1830 /* There are some local symbols. We just bring over all the
1831 debugging information. FIXME: This is not quite the right
1832 thing to do. If the user has asked us to discard all
1833 debugging information, then we are probably going to wind up
1834 keeping it because there will probably be some local symbol
1835 which objcopy did not discard. We should actually break
1836 apart the debugging information and only keep that which
1837 applies to the symbols we want to keep. */
1838 oinfo->symbolic_header.ilineMax = iinfo->symbolic_header.ilineMax;
1839 oinfo->symbolic_header.cbLine = iinfo->symbolic_header.cbLine;
1840 oinfo->line = iinfo->line;
1842 oinfo->symbolic_header.idnMax = iinfo->symbolic_header.idnMax;
1843 oinfo->external_dnr = iinfo->external_dnr;
1845 oinfo->symbolic_header.ipdMax = iinfo->symbolic_header.ipdMax;
1846 oinfo->external_pdr = iinfo->external_pdr;
1848 oinfo->symbolic_header.isymMax = iinfo->symbolic_header.isymMax;
1849 oinfo->external_sym = iinfo->external_sym;
1851 oinfo->symbolic_header.ioptMax = iinfo->symbolic_header.ioptMax;
1852 oinfo->external_opt = iinfo->external_opt;
1854 oinfo->symbolic_header.iauxMax = iinfo->symbolic_header.iauxMax;
1855 oinfo->external_aux = iinfo->external_aux;
1857 oinfo->symbolic_header.issMax = iinfo->symbolic_header.issMax;
1858 oinfo->ss = iinfo->ss;
1860 oinfo->symbolic_header.ifdMax = iinfo->symbolic_header.ifdMax;
1861 oinfo->external_fdr = iinfo->external_fdr;
1863 oinfo->symbolic_header.crfd = iinfo->symbolic_header.crfd;
1864 oinfo->external_rfd = iinfo->external_rfd;
1868 /* We are discarding all the local symbol information. Look
1869 through the external symbols and remove all references to FDR
1870 or aux information. */
1871 c = bfd_get_symcount (obfd);
1872 sym_ptr_ptr = bfd_get_outsymbols (obfd);
1873 for (; c > 0; c--, sym_ptr_ptr++)
1877 (*(ecoff_backend (obfd)->debug_swap.swap_ext_in))
1878 (obfd, ecoffsymbol (*sym_ptr_ptr)->native, &esym);
1880 esym.asym.index = indexNil;
1881 (*(ecoff_backend (obfd)->debug_swap.swap_ext_out))
1882 (obfd, &esym, ecoffsymbol (*sym_ptr_ptr)->native);
1889 /* Set the architecture. The supported architecture is stored in the
1890 backend pointer. We always set the architecture anyhow, since many
1891 callers ignore the return value. */
1894 _bfd_ecoff_set_arch_mach (bfd *abfd,
1895 enum bfd_architecture arch,
1896 unsigned long machine)
1898 bfd_default_set_arch_mach (abfd, arch, machine);
1899 return arch == ecoff_backend (abfd)->arch;
1902 /* Get the size of the section headers. */
1905 _bfd_ecoff_sizeof_headers (bfd *abfd,
1906 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1913 for (current = abfd->sections;
1915 current = current->next)
1918 ret = (bfd_coff_filhsz (abfd)
1919 + bfd_coff_aoutsz (abfd)
1920 + c * bfd_coff_scnhsz (abfd));
1921 return (int) BFD_ALIGN (ret, 16);
1924 /* Get the contents of a section. */
1927 _bfd_ecoff_get_section_contents (bfd *abfd,
1931 bfd_size_type count)
1933 return _bfd_generic_get_section_contents (abfd, section, location,
1937 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
1938 called via qsort. */
1941 ecoff_sort_hdrs (const void * arg1, const void * arg2)
1943 const asection *hdr1 = *(const asection **) arg1;
1944 const asection *hdr2 = *(const asection **) arg2;
1946 if ((hdr1->flags & SEC_ALLOC) != 0)
1948 if ((hdr2->flags & SEC_ALLOC) == 0)
1953 if ((hdr2->flags & SEC_ALLOC) != 0)
1956 if (hdr1->vma < hdr2->vma)
1958 else if (hdr1->vma > hdr2->vma)
1964 /* Calculate the file position for each section, and set
1968 ecoff_compute_section_file_positions (bfd *abfd)
1970 file_ptr sofar, file_sofar;
1971 asection **sorted_hdrs;
1975 bfd_boolean rdata_in_text;
1976 bfd_boolean first_data, first_nonalloc;
1977 const bfd_vma round = ecoff_backend (abfd)->round;
1980 sofar = _bfd_ecoff_sizeof_headers (abfd, NULL);
1983 /* Sort the sections by VMA. */
1984 amt = abfd->section_count;
1985 amt *= sizeof (asection *);
1986 sorted_hdrs = (asection **) bfd_malloc (amt);
1987 if (sorted_hdrs == NULL)
1989 for (current = abfd->sections, i = 0;
1991 current = current->next, i++)
1992 sorted_hdrs[i] = current;
1993 BFD_ASSERT (i == abfd->section_count);
1995 qsort (sorted_hdrs, abfd->section_count, sizeof (asection *),
1998 /* Some versions of the OSF linker put the .rdata section in the
1999 text segment, and some do not. */
2000 rdata_in_text = ecoff_backend (abfd)->rdata_in_text;
2003 for (i = 0; i < abfd->section_count; i++)
2005 current = sorted_hdrs[i];
2006 if (streq (current->name, _RDATA))
2008 if ((current->flags & SEC_CODE) == 0
2009 && ! streq (current->name, _PDATA)
2010 && ! streq (current->name, _RCONST))
2012 rdata_in_text = FALSE;
2017 ecoff_data (abfd)->rdata_in_text = rdata_in_text;
2020 first_nonalloc = TRUE;
2021 for (i = 0; i < abfd->section_count; i++)
2023 unsigned int alignment_power;
2025 current = sorted_hdrs[i];
2027 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2028 supposed to indicate the number of .pdata entries that are
2029 really in the section. Each entry is 8 bytes. We store this
2030 away in line_filepos before increasing the section size. */
2031 if (streq (current->name, _PDATA))
2032 current->line_filepos = current->size / 8;
2034 alignment_power = current->alignment_power;
2036 /* On Ultrix, the data sections in an executable file must be
2037 aligned to a page boundary within the file. This does not
2038 affect the section size, though. FIXME: Does this work for
2039 other platforms? It requires some modification for the
2040 Alpha, because .rdata on the Alpha goes with the text, not
2042 if ((abfd->flags & EXEC_P) != 0
2043 && (abfd->flags & D_PAGED) != 0
2045 && (current->flags & SEC_CODE) == 0
2047 || ! streq (current->name, _RDATA))
2048 && ! streq (current->name, _PDATA)
2049 && ! streq (current->name, _RCONST))
2051 sofar = (sofar + round - 1) &~ (round - 1);
2052 file_sofar = (file_sofar + round - 1) &~ (round - 1);
2055 else if (streq (current->name, _LIB))
2057 /* On Irix 4, the location of contents of the .lib section
2058 from a shared library section is also rounded up to a
2061 sofar = (sofar + round - 1) &~ (round - 1);
2062 file_sofar = (file_sofar + round - 1) &~ (round - 1);
2064 else if (first_nonalloc
2065 && (current->flags & SEC_ALLOC) == 0
2066 && (abfd->flags & D_PAGED) != 0)
2068 /* Skip up to the next page for an unallocated section, such
2069 as the .comment section on the Alpha. This leaves room
2070 for the .bss section. */
2071 first_nonalloc = FALSE;
2072 sofar = (sofar + round - 1) &~ (round - 1);
2073 file_sofar = (file_sofar + round - 1) &~ (round - 1);
2076 /* Align the sections in the file to the same boundary on
2077 which they are aligned in virtual memory. */
2078 sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2079 if ((current->flags & SEC_HAS_CONTENTS) != 0)
2080 file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power);
2082 if ((abfd->flags & D_PAGED) != 0
2083 && (current->flags & SEC_ALLOC) != 0)
2085 sofar += (current->vma - sofar) % round;
2086 if ((current->flags & SEC_HAS_CONTENTS) != 0)
2087 file_sofar += (current->vma - file_sofar) % round;
2090 if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) != 0)
2091 current->filepos = file_sofar;
2093 sofar += current->size;
2094 if ((current->flags & SEC_HAS_CONTENTS) != 0)
2095 file_sofar += current->size;
2097 /* Make sure that this section is of the right size too. */
2099 sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2100 if ((current->flags & SEC_HAS_CONTENTS) != 0)
2101 file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power);
2102 current->size += sofar - old_sofar;
2108 ecoff_data (abfd)->reloc_filepos = file_sofar;
2113 /* Determine the location of the relocs for all the sections in the
2114 output file, as well as the location of the symbolic debugging
2117 static bfd_size_type
2118 ecoff_compute_reloc_file_positions (bfd *abfd)
2120 const bfd_size_type external_reloc_size =
2121 ecoff_backend (abfd)->external_reloc_size;
2122 file_ptr reloc_base;
2123 bfd_size_type reloc_size;
2127 if (! abfd->output_has_begun)
2129 if (! ecoff_compute_section_file_positions (abfd))
2131 abfd->output_has_begun = TRUE;
2134 reloc_base = ecoff_data (abfd)->reloc_filepos;
2137 for (current = abfd->sections;
2139 current = current->next)
2141 if (current->reloc_count == 0)
2142 current->rel_filepos = 0;
2145 bfd_size_type relsize;
2147 current->rel_filepos = reloc_base;
2148 relsize = current->reloc_count * external_reloc_size;
2149 reloc_size += relsize;
2150 reloc_base += relsize;
2154 sym_base = ecoff_data (abfd)->reloc_filepos + reloc_size;
2156 /* At least on Ultrix, the symbol table of an executable file must
2157 be aligned to a page boundary. FIXME: Is this true on other
2159 if ((abfd->flags & EXEC_P) != 0
2160 && (abfd->flags & D_PAGED) != 0)
2161 sym_base = ((sym_base + ecoff_backend (abfd)->round - 1)
2162 &~ (ecoff_backend (abfd)->round - 1));
2164 ecoff_data (abfd)->sym_filepos = sym_base;
2169 /* Set the contents of a section. */
2172 _bfd_ecoff_set_section_contents (bfd *abfd,
2174 const void * location,
2176 bfd_size_type count)
2180 /* This must be done first, because bfd_set_section_contents is
2181 going to set output_has_begun to TRUE. */
2182 if (! abfd->output_has_begun
2183 && ! ecoff_compute_section_file_positions (abfd))
2186 /* Handle the .lib section specially so that Irix 4 shared libraries
2187 work out. See coff_set_section_contents in coffcode.h. */
2188 if (streq (section->name, _LIB))
2190 bfd_byte *rec, *recend;
2192 rec = (bfd_byte *) location;
2193 recend = rec + count;
2194 while (rec < recend)
2197 rec += bfd_get_32 (abfd, rec) * 4;
2200 BFD_ASSERT (rec == recend);
2206 pos = section->filepos + offset;
2207 if (bfd_seek (abfd, pos, SEEK_SET) != 0
2208 || bfd_bwrite (location, count, abfd) != count)
2214 /* Get the GP value for an ECOFF file. This is a hook used by
2218 bfd_ecoff_get_gp_value (bfd *abfd)
2220 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2221 || bfd_get_format (abfd) != bfd_object)
2223 bfd_set_error (bfd_error_invalid_operation);
2227 return ecoff_data (abfd)->gp;
2230 /* Set the GP value for an ECOFF file. This is a hook used by the
2234 bfd_ecoff_set_gp_value (bfd *abfd, bfd_vma gp_value)
2236 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2237 || bfd_get_format (abfd) != bfd_object)
2239 bfd_set_error (bfd_error_invalid_operation);
2243 ecoff_data (abfd)->gp = gp_value;
2248 /* Set the register masks for an ECOFF file. This is a hook used by
2252 bfd_ecoff_set_regmasks (bfd *abfd,
2253 unsigned long gprmask,
2254 unsigned long fprmask,
2255 unsigned long *cprmask)
2257 ecoff_data_type *tdata;
2259 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2260 || bfd_get_format (abfd) != bfd_object)
2262 bfd_set_error (bfd_error_invalid_operation);
2266 tdata = ecoff_data (abfd);
2267 tdata->gprmask = gprmask;
2268 tdata->fprmask = fprmask;
2269 if (cprmask != NULL)
2273 for (i = 0; i < 3; i++)
2274 tdata->cprmask[i] = cprmask[i];
2280 /* Get ECOFF EXTR information for an external symbol. This function
2281 is passed to bfd_ecoff_debug_externals. */
2284 ecoff_get_extr (asymbol *sym, EXTR *esym)
2286 ecoff_symbol_type *ecoff_sym_ptr;
2289 if (bfd_asymbol_flavour (sym) != bfd_target_ecoff_flavour
2290 || ecoffsymbol (sym)->native == NULL)
2292 /* Don't include debugging, local, or section symbols. */
2293 if ((sym->flags & BSF_DEBUGGING) != 0
2294 || (sym->flags & BSF_LOCAL) != 0
2295 || (sym->flags & BSF_SECTION_SYM) != 0)
2299 esym->cobol_main = 0;
2300 esym->weakext = (sym->flags & BSF_WEAK) != 0;
2303 /* FIXME: we can do better than this for st and sc. */
2304 esym->asym.st = stGlobal;
2305 esym->asym.sc = scAbs;
2306 esym->asym.reserved = 0;
2307 esym->asym.index = indexNil;
2311 ecoff_sym_ptr = ecoffsymbol (sym);
2313 if (ecoff_sym_ptr->local)
2316 input_bfd = bfd_asymbol_bfd (sym);
2317 (*(ecoff_backend (input_bfd)->debug_swap.swap_ext_in))
2318 (input_bfd, ecoff_sym_ptr->native, esym);
2320 /* If the symbol was defined by the linker, then esym will be
2321 undefined but sym will not be. Get a better class for such a
2323 if ((esym->asym.sc == scUndefined
2324 || esym->asym.sc == scSUndefined)
2325 && ! bfd_is_und_section (bfd_get_section (sym)))
2326 esym->asym.sc = scAbs;
2328 /* Adjust the FDR index for the symbol by that used for the input
2330 if (esym->ifd != -1)
2332 struct ecoff_debug_info *input_debug;
2334 input_debug = &ecoff_data (input_bfd)->debug_info;
2335 BFD_ASSERT (esym->ifd < input_debug->symbolic_header.ifdMax);
2336 if (input_debug->ifdmap != NULL)
2337 esym->ifd = input_debug->ifdmap[esym->ifd];
2343 /* Set the external symbol index. This routine is passed to
2344 bfd_ecoff_debug_externals. */
2347 ecoff_set_index (asymbol *sym, bfd_size_type indx)
2349 ecoff_set_sym_index (sym, indx);
2352 /* Write out an ECOFF file. */
2355 _bfd_ecoff_write_object_contents (bfd *abfd)
2357 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
2358 const bfd_vma round = backend->round;
2359 const bfd_size_type filhsz = bfd_coff_filhsz (abfd);
2360 const bfd_size_type aoutsz = bfd_coff_aoutsz (abfd);
2361 const bfd_size_type scnhsz = bfd_coff_scnhsz (abfd);
2362 const bfd_size_type external_hdr_size
2363 = backend->debug_swap.external_hdr_size;
2364 const bfd_size_type external_reloc_size = backend->external_reloc_size;
2365 void (* const adjust_reloc_out) (bfd *, const arelent *, struct internal_reloc *)
2366 = backend->adjust_reloc_out;
2367 void (* const swap_reloc_out) (bfd *, const struct internal_reloc *, void *)
2368 = backend->swap_reloc_out;
2369 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
2370 HDRR * const symhdr = &debug->symbolic_header;
2373 bfd_size_type reloc_size;
2374 bfd_size_type text_size;
2376 bfd_boolean set_text_start;
2377 bfd_size_type data_size;
2379 bfd_boolean set_data_start;
2380 bfd_size_type bss_size;
2382 void * reloc_buff = NULL;
2383 struct internal_filehdr internal_f;
2384 struct internal_aouthdr internal_a;
2387 /* Determine where the sections and relocs will go in the output
2389 reloc_size = ecoff_compute_reloc_file_positions (abfd);
2392 for (current = abfd->sections;
2394 current = current->next)
2396 current->target_index = count;
2400 if ((abfd->flags & D_PAGED) != 0)
2401 text_size = _bfd_ecoff_sizeof_headers (abfd, NULL);
2405 set_text_start = FALSE;
2408 set_data_start = FALSE;
2411 /* Write section headers to the file. */
2413 /* Allocate buff big enough to hold a section header,
2414 file header, or a.out header. */
2423 buff = bfd_malloc (siz);
2428 internal_f.f_nscns = 0;
2429 if (bfd_seek (abfd, (file_ptr) (filhsz + aoutsz), SEEK_SET) != 0)
2432 for (current = abfd->sections;
2434 current = current->next)
2436 struct internal_scnhdr section;
2439 ++internal_f.f_nscns;
2441 strncpy (section.s_name, current->name, sizeof section.s_name);
2443 /* This seems to be correct for Irix 4 shared libraries. */
2444 vma = bfd_get_section_vma (abfd, current);
2445 if (streq (current->name, _LIB))
2446 section.s_vaddr = 0;
2448 section.s_vaddr = vma;
2450 section.s_paddr = current->lma;
2451 section.s_size = current->size;
2453 /* If this section is unloadable then the scnptr will be 0. */
2454 if ((current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2455 section.s_scnptr = 0;
2457 section.s_scnptr = current->filepos;
2458 section.s_relptr = current->rel_filepos;
2460 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2461 object file produced by the assembler is supposed to point to
2462 information about how much room is required by objects of
2463 various different sizes. I think this only matters if we
2464 want the linker to compute the best size to use, or
2465 something. I don't know what happens if the information is
2467 if (! streq (current->name, _PDATA))
2468 section.s_lnnoptr = 0;
2471 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2472 hold the number of entries in the section (each entry is
2473 8 bytes). We stored this in the line_filepos field in
2474 ecoff_compute_section_file_positions. */
2475 section.s_lnnoptr = current->line_filepos;
2478 section.s_nreloc = current->reloc_count;
2479 section.s_nlnno = 0;
2480 section.s_flags = ecoff_sec_to_styp_flags (current->name,
2483 if (bfd_coff_swap_scnhdr_out (abfd, (void *) §ion, buff) == 0
2484 || bfd_bwrite (buff, scnhsz, abfd) != scnhsz)
2487 if ((section.s_flags & STYP_TEXT) != 0
2488 || ((section.s_flags & STYP_RDATA) != 0
2489 && ecoff_data (abfd)->rdata_in_text)
2490 || section.s_flags == STYP_PDATA
2491 || (section.s_flags & STYP_DYNAMIC) != 0
2492 || (section.s_flags & STYP_LIBLIST) != 0
2493 || (section.s_flags & STYP_RELDYN) != 0
2494 || section.s_flags == STYP_CONFLIC
2495 || (section.s_flags & STYP_DYNSTR) != 0
2496 || (section.s_flags & STYP_DYNSYM) != 0
2497 || (section.s_flags & STYP_HASH) != 0
2498 || (section.s_flags & STYP_ECOFF_INIT) != 0
2499 || (section.s_flags & STYP_ECOFF_FINI) != 0
2500 || section.s_flags == STYP_RCONST)
2502 text_size += current->size;
2503 if (! set_text_start || text_start > vma)
2506 set_text_start = TRUE;
2509 else if ((section.s_flags & STYP_RDATA) != 0
2510 || (section.s_flags & STYP_DATA) != 0
2511 || (section.s_flags & STYP_LITA) != 0
2512 || (section.s_flags & STYP_LIT8) != 0
2513 || (section.s_flags & STYP_LIT4) != 0
2514 || (section.s_flags & STYP_SDATA) != 0
2515 || section.s_flags == STYP_XDATA
2516 || (section.s_flags & STYP_GOT) != 0)
2518 data_size += current->size;
2519 if (! set_data_start || data_start > vma)
2522 set_data_start = TRUE;
2525 else if ((section.s_flags & STYP_BSS) != 0
2526 || (section.s_flags & STYP_SBSS) != 0)
2527 bss_size += current->size;
2528 else if (section.s_flags == 0
2529 || (section.s_flags & STYP_ECOFF_LIB) != 0
2530 || section.s_flags == STYP_COMMENT)
2536 /* Set up the file header. */
2537 internal_f.f_magic = ecoff_get_magic (abfd);
2539 /* We will NOT put a fucking timestamp in the header here. Every
2540 time you put it back, I will come in and take it out again. I'm
2541 sorry. This field does not belong here. We fill it with a 0 so
2542 it compares the same but is not a reasonable time. --
2544 internal_f.f_timdat = 0;
2546 if (bfd_get_symcount (abfd) != 0)
2548 /* The ECOFF f_nsyms field is not actually the number of
2549 symbols, it's the size of symbolic information header. */
2550 internal_f.f_nsyms = external_hdr_size;
2551 internal_f.f_symptr = ecoff_data (abfd)->sym_filepos;
2555 internal_f.f_nsyms = 0;
2556 internal_f.f_symptr = 0;
2559 internal_f.f_opthdr = aoutsz;
2561 internal_f.f_flags = F_LNNO;
2562 if (reloc_size == 0)
2563 internal_f.f_flags |= F_RELFLG;
2564 if (bfd_get_symcount (abfd) == 0)
2565 internal_f.f_flags |= F_LSYMS;
2566 if (abfd->flags & EXEC_P)
2567 internal_f.f_flags |= F_EXEC;
2569 if (bfd_little_endian (abfd))
2570 internal_f.f_flags |= F_AR32WR;
2572 internal_f.f_flags |= F_AR32W;
2574 /* Set up the ``optional'' header. */
2575 if ((abfd->flags & D_PAGED) != 0)
2576 internal_a.magic = ECOFF_AOUT_ZMAGIC;
2578 internal_a.magic = ECOFF_AOUT_OMAGIC;
2580 /* FIXME: Is this really correct? */
2581 internal_a.vstamp = symhdr->vstamp;
2583 /* At least on Ultrix, these have to be rounded to page boundaries.
2584 FIXME: Is this true on other platforms? */
2585 if ((abfd->flags & D_PAGED) != 0)
2587 internal_a.tsize = (text_size + round - 1) &~ (round - 1);
2588 internal_a.text_start = text_start &~ (round - 1);
2589 internal_a.dsize = (data_size + round - 1) &~ (round - 1);
2590 internal_a.data_start = data_start &~ (round - 1);
2594 internal_a.tsize = text_size;
2595 internal_a.text_start = text_start;
2596 internal_a.dsize = data_size;
2597 internal_a.data_start = data_start;
2600 /* On Ultrix, the initial portions of the .sbss and .bss segments
2601 are at the end of the data section. The bsize field in the
2602 optional header records how many bss bytes are required beyond
2603 those in the data section. The value is not rounded to a page
2605 if (bss_size < internal_a.dsize - data_size)
2608 bss_size -= internal_a.dsize - data_size;
2609 internal_a.bsize = bss_size;
2610 internal_a.bss_start = internal_a.data_start + internal_a.dsize;
2612 internal_a.entry = bfd_get_start_address (abfd);
2614 internal_a.gp_value = ecoff_data (abfd)->gp;
2616 internal_a.gprmask = ecoff_data (abfd)->gprmask;
2617 internal_a.fprmask = ecoff_data (abfd)->fprmask;
2618 for (i = 0; i < 4; i++)
2619 internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i];
2621 /* Let the backend adjust the headers if necessary. */
2622 if (backend->adjust_headers)
2624 if (! (*backend->adjust_headers) (abfd, &internal_f, &internal_a))
2628 /* Write out the file header and the optional header. */
2629 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
2632 bfd_coff_swap_filehdr_out (abfd, (void *) &internal_f, buff);
2633 if (bfd_bwrite (buff, filhsz, abfd) != filhsz)
2636 bfd_coff_swap_aouthdr_out (abfd, (void *) &internal_a, buff);
2637 if (bfd_bwrite (buff, aoutsz, abfd) != aoutsz)
2640 /* Build the external symbol information. This must be done before
2641 writing out the relocs so that we know the symbol indices. We
2642 don't do this if this BFD was created by the backend linker,
2643 since it will have already handled the symbols and relocs. */
2644 if (! ecoff_data (abfd)->linker)
2646 symhdr->iextMax = 0;
2647 symhdr->issExtMax = 0;
2648 debug->external_ext = debug->external_ext_end = NULL;
2649 debug->ssext = debug->ssext_end = NULL;
2650 if (! bfd_ecoff_debug_externals (abfd, debug, &backend->debug_swap,
2651 (abfd->flags & EXEC_P) == 0,
2652 ecoff_get_extr, ecoff_set_index))
2655 /* Write out the relocs. */
2656 for (current = abfd->sections;
2658 current = current->next)
2660 arelent **reloc_ptr_ptr;
2661 arelent **reloc_end;
2665 if (current->reloc_count == 0)
2668 amt = current->reloc_count * external_reloc_size;
2669 reloc_buff = bfd_alloc (abfd, amt);
2670 if (reloc_buff == NULL)
2673 reloc_ptr_ptr = current->orelocation;
2674 reloc_end = reloc_ptr_ptr + current->reloc_count;
2675 out_ptr = (char *) reloc_buff;
2678 reloc_ptr_ptr < reloc_end;
2679 reloc_ptr_ptr++, out_ptr += external_reloc_size)
2683 struct internal_reloc in;
2685 memset ((void *) &in, 0, sizeof in);
2687 reloc = *reloc_ptr_ptr;
2688 sym = *reloc->sym_ptr_ptr;
2690 /* If the howto field has not been initialised then skip this reloc.
2691 This assumes that an error message has been issued elsewhere. */
2692 if (reloc->howto == NULL)
2695 in.r_vaddr = (reloc->address
2696 + bfd_get_section_vma (abfd, current));
2697 in.r_type = reloc->howto->type;
2699 if ((sym->flags & BSF_SECTION_SYM) == 0)
2701 in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr);
2715 { _TEXT, RELOC_SECTION_TEXT },
2716 { _RDATA, RELOC_SECTION_RDATA },
2717 { _DATA, RELOC_SECTION_DATA },
2718 { _SDATA, RELOC_SECTION_SDATA },
2719 { _SBSS, RELOC_SECTION_SBSS },
2720 { _BSS, RELOC_SECTION_BSS },
2721 { _INIT, RELOC_SECTION_INIT },
2722 { _LIT8, RELOC_SECTION_LIT8 },
2723 { _LIT4, RELOC_SECTION_LIT4 },
2724 { _XDATA, RELOC_SECTION_XDATA },
2725 { _PDATA, RELOC_SECTION_PDATA },
2726 { _FINI, RELOC_SECTION_FINI },
2727 { _LITA, RELOC_SECTION_LITA },
2728 { "*ABS*", RELOC_SECTION_ABS },
2729 { _RCONST, RELOC_SECTION_RCONST }
2732 name = bfd_get_section_name (abfd, bfd_get_section (sym));
2734 for (j = 0; j < ARRAY_SIZE (section_symndx); j++)
2735 if (streq (name, section_symndx[j].name))
2737 in.r_symndx = section_symndx[j].r_symndx;
2741 if (j == ARRAY_SIZE (section_symndx))
2746 (*adjust_reloc_out) (abfd, reloc, &in);
2748 (*swap_reloc_out) (abfd, &in, (void *) out_ptr);
2751 if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0)
2753 amt = current->reloc_count * external_reloc_size;
2754 if (bfd_bwrite (reloc_buff, amt, abfd) != amt)
2756 bfd_release (abfd, reloc_buff);
2760 /* Write out the symbolic debugging information. */
2761 if (bfd_get_symcount (abfd) > 0)
2763 /* Write out the debugging information. */
2764 if (! bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap,
2765 ecoff_data (abfd)->sym_filepos))
2770 /* The .bss section of a demand paged executable must receive an
2771 entire page. If there are symbols, the symbols will start on the
2772 next page. If there are no symbols, we must fill out the page by
2774 if (bfd_get_symcount (abfd) == 0
2775 && (abfd->flags & EXEC_P) != 0
2776 && (abfd->flags & D_PAGED) != 0)
2780 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2783 if (bfd_bread (&c, (bfd_size_type) 1, abfd) == 0)
2785 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2788 if (bfd_bwrite (&c, (bfd_size_type) 1, abfd) != 1)
2792 if (reloc_buff != NULL)
2793 bfd_release (abfd, reloc_buff);
2798 if (reloc_buff != NULL)
2799 bfd_release (abfd, reloc_buff);
2805 /* Archive handling. ECOFF uses what appears to be a unique type of
2806 archive header (armap). The byte ordering of the armap and the
2807 contents are encoded in the name of the armap itself. At least for
2808 now, we only support archives with the same byte ordering in the
2809 armap and the contents.
2811 The first four bytes in the armap are the number of symbol
2812 definitions. This is always a power of two.
2814 This is followed by the symbol definitions. Each symbol definition
2815 occupies 8 bytes. The first four bytes are the offset from the
2816 start of the armap strings to the null-terminated string naming
2817 this symbol. The second four bytes are the file offset to the
2818 archive member which defines this symbol. If the second four bytes
2819 are 0, then this is not actually a symbol definition, and it should
2822 The symbols are hashed into the armap with a closed hashing scheme.
2823 See the functions below for the details of the algorithm.
2825 After the symbol definitions comes four bytes holding the size of
2826 the string table, followed by the string table itself. */
2828 /* The name of an archive headers looks like this:
2829 __________E[BL]E[BL]_ (with a trailing space).
2830 The trailing space is changed to an X if the archive is changed to
2831 indicate that the armap is out of date.
2833 The Alpha seems to use ________64E[BL]E[BL]_. */
2835 #define ARMAP_BIG_ENDIAN 'B'
2836 #define ARMAP_LITTLE_ENDIAN 'L'
2837 #define ARMAP_MARKER 'E'
2838 #define ARMAP_START_LENGTH 10
2839 #define ARMAP_HEADER_MARKER_INDEX 10
2840 #define ARMAP_HEADER_ENDIAN_INDEX 11
2841 #define ARMAP_OBJECT_MARKER_INDEX 12
2842 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2843 #define ARMAP_END_INDEX 14
2844 #define ARMAP_END "_ "
2846 /* This is a magic number used in the hashing algorithm. */
2847 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2849 /* This returns the hash value to use for a string. It also sets
2850 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2851 is the number of entries in the hash table, and HLOG is the log
2855 ecoff_armap_hash (const char *s,
2856 unsigned int *rehash,
2866 hash = ((hash >> 27) | (hash << 5)) + *s++;
2867 hash *= ARMAP_HASH_MAGIC;
2868 *rehash = (hash & (size - 1)) | 1;
2869 return hash >> (32 - hlog);
2872 /* Read in the armap. */
2875 _bfd_ecoff_slurp_armap (bfd *abfd)
2879 struct areltdata *mapdata;
2880 bfd_size_type parsed_size;
2882 struct artdata *ardata;
2889 /* Get the name of the first element. */
2890 i = bfd_bread ((void *) nextname, (bfd_size_type) 16, abfd);
2896 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
2899 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2900 standard COFF armap. We could move the ECOFF armap stuff into
2901 bfd_slurp_armap, but that seems inappropriate since no other
2902 target uses this format. Instead, we check directly for a COFF
2904 if (CONST_STRNEQ (nextname, "/ "))
2905 return bfd_slurp_armap (abfd);
2907 /* See if the first element is an armap. */
2908 if (! strneq (nextname, ecoff_backend (abfd)->armap_start, ARMAP_START_LENGTH)
2909 || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER
2910 || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2911 && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2912 || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER
2913 || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2914 && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2915 || ! strneq (nextname + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1))
2917 bfd_has_map (abfd) = FALSE;
2921 /* Make sure we have the right byte ordering. */
2922 if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2923 ^ (bfd_header_big_endian (abfd)))
2924 || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2925 ^ (bfd_big_endian (abfd))))
2927 bfd_set_error (bfd_error_wrong_format);
2931 /* Read in the armap. */
2932 ardata = bfd_ardata (abfd);
2933 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
2934 if (mapdata == NULL)
2936 parsed_size = mapdata->parsed_size;
2939 raw_armap = (char *) bfd_alloc (abfd, parsed_size);
2940 if (raw_armap == NULL)
2943 if (bfd_bread ((void *) raw_armap, parsed_size, abfd) != parsed_size)
2945 if (bfd_get_error () != bfd_error_system_call)
2946 bfd_set_error (bfd_error_malformed_archive);
2947 bfd_release (abfd, (void *) raw_armap);
2951 ardata->tdata = (void *) raw_armap;
2953 count = H_GET_32 (abfd, raw_armap);
2955 ardata->symdef_count = 0;
2956 ardata->cache = NULL;
2958 /* This code used to overlay the symdefs over the raw archive data,
2959 but that doesn't work on a 64 bit host. */
2960 stringbase = raw_armap + count * 8 + 8;
2962 #ifdef CHECK_ARMAP_HASH
2966 /* Double check that I have the hashing algorithm right by making
2967 sure that every symbol can be looked up successfully. */
2969 for (i = 1; i < count; i <<= 1)
2971 BFD_ASSERT (i == count);
2973 raw_ptr = raw_armap + 4;
2974 for (i = 0; i < count; i++, raw_ptr += 8)
2976 unsigned int name_offset, file_offset;
2977 unsigned int hash, rehash, srch;
2979 name_offset = H_GET_32 (abfd, raw_ptr);
2980 file_offset = H_GET_32 (abfd, (raw_ptr + 4));
2981 if (file_offset == 0)
2983 hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count,
2988 /* See if we can rehash to this location. */
2989 for (srch = (hash + rehash) & (count - 1);
2990 srch != hash && srch != i;
2991 srch = (srch + rehash) & (count - 1))
2992 BFD_ASSERT (H_GET_32 (abfd, (raw_armap + 8 + srch * 8)) != 0);
2993 BFD_ASSERT (srch == i);
2997 #endif /* CHECK_ARMAP_HASH */
2999 raw_ptr = raw_armap + 4;
3000 for (i = 0; i < count; i++, raw_ptr += 8)
3001 if (H_GET_32 (abfd, (raw_ptr + 4)) != 0)
3002 ++ardata->symdef_count;
3004 amt = ardata->symdef_count;
3005 amt *= sizeof (carsym);
3006 symdef_ptr = (carsym *) bfd_alloc (abfd, amt);
3010 ardata->symdefs = symdef_ptr;
3012 raw_ptr = raw_armap + 4;
3013 for (i = 0; i < count; i++, raw_ptr += 8)
3015 unsigned int name_offset, file_offset;
3017 file_offset = H_GET_32 (abfd, (raw_ptr + 4));
3018 if (file_offset == 0)
3020 name_offset = H_GET_32 (abfd, raw_ptr);
3021 symdef_ptr->name = stringbase + name_offset;
3022 symdef_ptr->file_offset = file_offset;
3026 ardata->first_file_filepos = bfd_tell (abfd);
3027 /* Pad to an even boundary. */
3028 ardata->first_file_filepos += ardata->first_file_filepos % 2;
3030 bfd_has_map (abfd) = TRUE;
3035 /* Write out an armap. */
3038 _bfd_ecoff_write_armap (bfd *abfd,
3039 unsigned int elength,
3041 unsigned int orl_count,
3044 unsigned int hashsize, hashlog;
3045 bfd_size_type symdefsize;
3047 unsigned int stringsize;
3048 unsigned int mapsize;
3051 struct stat statbuf;
3054 bfd_byte *hashtable;
3058 /* Ultrix appears to use as a hash table size the least power of two
3059 greater than twice the number of entries. */
3060 for (hashlog = 0; ((unsigned int) 1 << hashlog) <= 2 * orl_count; hashlog++)
3062 hashsize = 1 << hashlog;
3064 symdefsize = hashsize * 8;
3066 stringsize = stridx + padit;
3068 /* Include 8 bytes to store symdefsize and stringsize in output. */
3069 mapsize = symdefsize + stringsize + 8;
3071 firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength;
3073 memset ((void *) &hdr, 0, sizeof hdr);
3075 /* Work out the ECOFF armap name. */
3076 strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start);
3077 hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER;
3078 hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] =
3079 (bfd_header_big_endian (abfd)
3081 : ARMAP_LITTLE_ENDIAN);
3082 hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER;
3083 hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] =
3084 bfd_big_endian (abfd) ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN;
3085 memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1);
3087 /* Write the timestamp of the archive header to be just a little bit
3088 later than the timestamp of the file, otherwise the linker will
3089 complain that the index is out of date. Actually, the Ultrix
3090 linker just checks the archive name; the GNU linker may check the
3092 stat (abfd->filename, &statbuf);
3093 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
3094 (long) (statbuf.st_mtime + 60));
3096 /* The DECstation uses zeroes for the uid, gid and mode of the
3098 hdr.ar_uid[0] = '0';
3099 hdr.ar_gid[0] = '0';
3100 /* Building gcc ends up extracting the armap as a file - twice. */
3101 hdr.ar_mode[0] = '6';
3102 hdr.ar_mode[1] = '4';
3103 hdr.ar_mode[2] = '4';
3105 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld", mapsize);
3107 hdr.ar_fmag[0] = '`';
3108 hdr.ar_fmag[1] = '\012';
3110 /* Turn all null bytes in the header into spaces. */
3111 for (i = 0; i < sizeof (struct ar_hdr); i++)
3112 if (((char *) (&hdr))[i] == '\0')
3113 (((char *) (&hdr))[i]) = ' ';
3115 if (bfd_bwrite ((void *) &hdr, (bfd_size_type) sizeof (struct ar_hdr), abfd)
3116 != sizeof (struct ar_hdr))
3119 H_PUT_32 (abfd, hashsize, temp);
3120 if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4)
3123 hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize);
3127 current = abfd->archive_head;
3129 for (i = 0; i < orl_count; i++)
3131 unsigned int hash, rehash = 0;
3133 /* Advance firstreal to the file position of this archive
3135 if (map[i].u.abfd != last_elt)
3139 firstreal += arelt_size (current) + sizeof (struct ar_hdr);
3140 firstreal += firstreal % 2;
3141 current = current->archive_next;
3143 while (current != map[i].u.abfd);
3148 hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog);
3149 if (H_GET_32 (abfd, (hashtable + (hash * 8) + 4)) != 0)
3153 /* The desired slot is already taken. */
3154 for (srch = (hash + rehash) & (hashsize - 1);
3156 srch = (srch + rehash) & (hashsize - 1))
3157 if (H_GET_32 (abfd, (hashtable + (srch * 8) + 4)) == 0)
3160 BFD_ASSERT (srch != hash);
3165 H_PUT_32 (abfd, map[i].namidx, (hashtable + hash * 8));
3166 H_PUT_32 (abfd, firstreal, (hashtable + hash * 8 + 4));
3169 if (bfd_bwrite ((void *) hashtable, symdefsize, abfd) != symdefsize)
3172 bfd_release (abfd, hashtable);
3174 /* Now write the strings. */
3175 H_PUT_32 (abfd, stringsize, temp);
3176 if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4)
3178 for (i = 0; i < orl_count; i++)
3182 len = strlen (*map[i].name) + 1;
3183 if (bfd_bwrite ((void *) (*map[i].name), len, abfd) != len)
3187 /* The spec sez this should be a newline. But in order to be
3188 bug-compatible for DECstation ar we use a null. */
3191 if (bfd_bwrite ("", (bfd_size_type) 1, abfd) != 1)
3198 /* ECOFF linker code. */
3200 /* Routine to create an entry in an ECOFF link hash table. */
3202 static struct bfd_hash_entry *
3203 ecoff_link_hash_newfunc (struct bfd_hash_entry *entry,
3204 struct bfd_hash_table *table,
3207 struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry;
3209 /* Allocate the structure if it has not already been allocated by a
3212 ret = ((struct ecoff_link_hash_entry *)
3213 bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry)));
3217 /* Call the allocation method of the superclass. */
3218 ret = ((struct ecoff_link_hash_entry *)
3219 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3224 /* Set local fields. */
3230 memset ((void *) &ret->esym, 0, sizeof ret->esym);
3232 return (struct bfd_hash_entry *) ret;
3235 /* Create an ECOFF link hash table. */
3237 struct bfd_link_hash_table *
3238 _bfd_ecoff_bfd_link_hash_table_create (bfd *abfd)
3240 struct ecoff_link_hash_table *ret;
3241 bfd_size_type amt = sizeof (struct ecoff_link_hash_table);
3243 ret = (struct ecoff_link_hash_table *) bfd_malloc (amt);
3246 if (!_bfd_link_hash_table_init (&ret->root, abfd,
3247 ecoff_link_hash_newfunc,
3248 sizeof (struct ecoff_link_hash_entry)))
3256 /* Look up an entry in an ECOFF link hash table. */
3258 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3259 ((struct ecoff_link_hash_entry *) \
3260 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3262 /* Get the ECOFF link hash table from the info structure. This is
3265 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3267 /* Add the external symbols of an object file to the global linker
3268 hash table. The external symbols and strings we are passed are
3269 just allocated on the stack, and will be discarded. We must
3270 explicitly save any information we may need later on in the link.
3271 We do not want to read the external symbol information again. */
3274 ecoff_link_add_externals (bfd *abfd,
3275 struct bfd_link_info *info,
3276 void * external_ext,
3279 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3280 void (* const swap_ext_in) (bfd *, void *, EXTR *)
3281 = backend->debug_swap.swap_ext_in;
3282 bfd_size_type external_ext_size = backend->debug_swap.external_ext_size;
3283 unsigned long ext_count;
3284 struct bfd_link_hash_entry **sym_hash;
3289 ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
3292 amt *= sizeof (struct bfd_link_hash_entry *);
3293 sym_hash = (struct bfd_link_hash_entry **) bfd_alloc (abfd, amt);
3296 ecoff_data (abfd)->sym_hashes = (struct ecoff_link_hash_entry **) sym_hash;
3298 ext_ptr = (char *) external_ext;
3299 ext_end = ext_ptr + ext_count * external_ext_size;
3300 for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++)
3307 struct ecoff_link_hash_entry *h;
3311 (*swap_ext_in) (abfd, (void *) ext_ptr, &esym);
3313 /* Skip debugging symbols. */
3315 switch (esym.asym.st)
3331 /* Get the information for this symbol. */
3332 value = esym.asym.value;
3333 switch (esym.asym.sc)
3353 section = bfd_make_section_old_way (abfd, _TEXT);
3354 value -= section->vma;
3357 section = bfd_make_section_old_way (abfd, _DATA);
3358 value -= section->vma;
3361 section = bfd_make_section_old_way (abfd, _BSS);
3362 value -= section->vma;
3365 section = bfd_abs_section_ptr;
3368 section = bfd_und_section_ptr;
3371 section = bfd_make_section_old_way (abfd, _SDATA);
3372 value -= section->vma;
3375 section = bfd_make_section_old_way (abfd, _SBSS);
3376 value -= section->vma;
3379 section = bfd_make_section_old_way (abfd, _RDATA);
3380 value -= section->vma;
3383 if (value > ecoff_data (abfd)->gp_size)
3385 section = bfd_com_section_ptr;
3390 if (ecoff_scom_section.name == NULL)
3392 /* Initialize the small common section. */
3393 ecoff_scom_section.name = SCOMMON;
3394 ecoff_scom_section.flags = SEC_IS_COMMON;
3395 ecoff_scom_section.output_section = &ecoff_scom_section;
3396 ecoff_scom_section.symbol = &ecoff_scom_symbol;
3397 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
3398 ecoff_scom_symbol.name = SCOMMON;
3399 ecoff_scom_symbol.flags = BSF_SECTION_SYM;
3400 ecoff_scom_symbol.section = &ecoff_scom_section;
3401 ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
3403 section = &ecoff_scom_section;
3406 section = bfd_und_section_ptr;
3409 section = bfd_make_section_old_way (abfd, _INIT);
3410 value -= section->vma;
3413 section = bfd_make_section_old_way (abfd, _FINI);
3414 value -= section->vma;
3417 section = bfd_make_section_old_way (abfd, _RCONST);
3418 value -= section->vma;
3422 if (section == NULL)
3425 name = ssext + esym.asym.iss;
3427 if (! (_bfd_generic_link_add_one_symbol
3429 (flagword) (esym.weakext ? BSF_WEAK : BSF_GLOBAL),
3430 section, value, NULL, TRUE, TRUE, sym_hash)))
3433 h = (struct ecoff_link_hash_entry *) *sym_hash;
3435 /* If we are building an ECOFF hash table, save the external
3436 symbol information. */
3437 if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd))
3440 || (! bfd_is_und_section (section)
3441 && (! bfd_is_com_section (section)
3442 || (h->root.type != bfd_link_hash_defined
3443 && h->root.type != bfd_link_hash_defweak))))
3449 /* Remember whether this symbol was small undefined. */
3450 if (esym.asym.sc == scSUndefined)
3453 /* If this symbol was ever small undefined, it needs to wind
3454 up in a GP relative section. We can't control the
3455 section of a defined symbol, but we can control the
3456 section of a common symbol. This case is actually needed
3457 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3459 && h->root.type == bfd_link_hash_common
3460 && streq (h->root.u.c.p->section->name, SCOMMON))
3462 h->root.u.c.p->section = bfd_make_section_old_way (abfd,
3464 h->root.u.c.p->section->flags = SEC_ALLOC;
3465 if (h->esym.asym.sc == scCommon)
3466 h->esym.asym.sc = scSCommon;
3474 /* Add symbols from an ECOFF object file to the global linker hash
3478 ecoff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3481 bfd_size_type external_ext_size;
3482 void * external_ext = NULL;
3483 bfd_size_type esize;
3487 if (! ecoff_slurp_symbolic_header (abfd))
3490 /* If there are no symbols, we don't want it. */
3491 if (bfd_get_symcount (abfd) == 0)
3494 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3496 /* Read in the external symbols and external strings. */
3497 external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size;
3498 esize = symhdr->iextMax * external_ext_size;
3499 external_ext = bfd_malloc (esize);
3500 if (external_ext == NULL && esize != 0)
3503 if (bfd_seek (abfd, (file_ptr) symhdr->cbExtOffset, SEEK_SET) != 0
3504 || bfd_bread (external_ext, esize, abfd) != esize)
3507 ssext = (char *) bfd_malloc ((bfd_size_type) symhdr->issExtMax);
3508 if (ssext == NULL && symhdr->issExtMax != 0)
3511 if (bfd_seek (abfd, (file_ptr) symhdr->cbSsExtOffset, SEEK_SET) != 0
3512 || (bfd_bread (ssext, (bfd_size_type) symhdr->issExtMax, abfd)
3513 != (bfd_size_type) symhdr->issExtMax))
3516 result = ecoff_link_add_externals (abfd, info, external_ext, ssext);
3520 if (external_ext != NULL)
3521 free (external_ext);
3527 if (external_ext != NULL)
3528 free (external_ext);
3532 /* This is called if we used _bfd_generic_link_add_archive_symbols
3533 because we were not dealing with an ECOFF archive. */
3536 ecoff_link_check_archive_element (bfd *abfd,
3537 struct bfd_link_info *info,
3538 struct bfd_link_hash_entry *h,
3540 bfd_boolean *pneeded)
3544 /* Unlike the generic linker, we do not pull in elements because
3545 of common symbols. */
3546 if (h->type != bfd_link_hash_undefined)
3549 /* Include this element? */
3550 if (!(*info->callbacks->add_archive_element) (info, abfd, name, &abfd))
3554 return ecoff_link_add_object_symbols (abfd, info);
3557 /* Add the symbols from an archive file to the global hash table.
3558 This looks through the undefined symbols, looks each one up in the
3559 archive hash table, and adds any associated object file. We do not
3560 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3561 already have a hash table, so there is no reason to construct
3565 ecoff_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
3567 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3568 const bfd_byte *raw_armap;
3569 struct bfd_link_hash_entry **pundef;
3570 unsigned int armap_count;
3571 unsigned int armap_log;
3573 const bfd_byte *hashtable;
3574 const char *stringbase;
3576 if (! bfd_has_map (abfd))
3578 /* An empty archive is a special case. */
3579 if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
3581 bfd_set_error (bfd_error_no_armap);
3585 /* If we don't have any raw data for this archive, as can happen on
3586 Irix 4.0.5F, we call the generic routine.
3587 FIXME: We should be more clever about this, since someday tdata
3588 may get to something for a generic archive. */
3589 raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata;
3590 if (raw_armap == NULL)
3591 return (_bfd_generic_link_add_archive_symbols
3592 (abfd, info, ecoff_link_check_archive_element));
3594 armap_count = H_GET_32 (abfd, raw_armap);
3597 for (i = 1; i < armap_count; i <<= 1)
3599 BFD_ASSERT (i == armap_count);
3601 hashtable = raw_armap + 4;
3602 stringbase = (const char *) raw_armap + armap_count * 8 + 8;
3604 /* Look through the list of undefined symbols. */
3605 pundef = &info->hash->undefs;
3606 while (*pundef != NULL)
3608 struct bfd_link_hash_entry *h;
3609 unsigned int hash, rehash = 0;
3610 unsigned int file_offset;
3616 /* When a symbol is defined, it is not necessarily removed from
3618 if (h->type != bfd_link_hash_undefined
3619 && h->type != bfd_link_hash_common)
3621 /* Remove this entry from the list, for general cleanliness
3622 and because we are going to look through the list again
3623 if we search any more libraries. We can't remove the
3624 entry if it is the tail, because that would lose any
3625 entries we add to the list later on. */
3626 if (*pundef != info->hash->undefs_tail)
3627 *pundef = (*pundef)->u.undef.next;
3629 pundef = &(*pundef)->u.undef.next;
3633 /* Native ECOFF linkers do not pull in archive elements merely
3634 to satisfy common definitions, so neither do we. We leave
3635 them on the list, though, in case we are linking against some
3636 other object format. */
3637 if (h->type != bfd_link_hash_undefined)
3639 pundef = &(*pundef)->u.undef.next;
3643 /* Look for this symbol in the archive hash table. */
3644 hash = ecoff_armap_hash (h->root.string, &rehash, armap_count,
3647 file_offset = H_GET_32 (abfd, hashtable + (hash * 8) + 4);
3648 if (file_offset == 0)
3650 /* Nothing in this slot. */
3651 pundef = &(*pundef)->u.undef.next;
3655 name = stringbase + H_GET_32 (abfd, hashtable + (hash * 8));
3656 if (name[0] != h->root.string[0]
3657 || ! streq (name, h->root.string))
3662 /* That was the wrong symbol. Try rehashing. */
3664 for (srch = (hash + rehash) & (armap_count - 1);
3666 srch = (srch + rehash) & (armap_count - 1))
3668 file_offset = H_GET_32 (abfd, hashtable + (srch * 8) + 4);
3669 if (file_offset == 0)
3671 name = stringbase + H_GET_32 (abfd, hashtable + (srch * 8));
3672 if (name[0] == h->root.string[0]
3673 && streq (name, h->root.string))
3682 pundef = &(*pundef)->u.undef.next;
3689 element = (*backend->get_elt_at_filepos) (abfd, (file_ptr) file_offset);
3690 if (element == NULL)
3693 if (! bfd_check_format (element, bfd_object))
3696 /* Unlike the generic linker, we know that this element provides
3697 a definition for an undefined symbol and we know that we want
3698 to include it. We don't need to check anything. */
3699 if (!(*info->callbacks
3700 ->add_archive_element) (info, element, name, &element))
3702 if (! ecoff_link_add_object_symbols (element, info))
3705 pundef = &(*pundef)->u.undef.next;
3711 /* Given an ECOFF BFD, add symbols to the global hash table as
3715 _bfd_ecoff_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
3717 switch (bfd_get_format (abfd))
3720 return ecoff_link_add_object_symbols (abfd, info);
3722 return ecoff_link_add_archive_symbols (abfd, info);
3724 bfd_set_error (bfd_error_wrong_format);
3730 /* ECOFF final link routines. */
3732 /* Structure used to pass information to ecoff_link_write_external. */
3737 struct bfd_link_info *info;
3740 /* Accumulate the debugging information for an input BFD into the
3741 output BFD. This must read in the symbolic information of the
3745 ecoff_final_link_debug_accumulate (bfd *output_bfd,
3747 struct bfd_link_info *info,
3750 struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info;
3751 const struct ecoff_debug_swap * const swap =
3752 &ecoff_backend (input_bfd)->debug_swap;
3753 HDRR *symhdr = &debug->symbolic_header;
3756 #define READ(ptr, offset, count, size, type) \
3757 if (symhdr->count == 0) \
3758 debug->ptr = NULL; \
3761 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
3762 debug->ptr = (type) bfd_malloc (amt); \
3763 if (debug->ptr == NULL) \
3766 goto return_something; \
3768 if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3769 || bfd_bread (debug->ptr, amt, input_bfd) != amt) \
3772 goto return_something; \
3776 /* If raw_syments is not NULL, then the data was already by read by
3777 _bfd_ecoff_slurp_symbolic_info. */
3778 if (ecoff_data (input_bfd)->raw_syments == NULL)
3780 READ (line, cbLineOffset, cbLine, sizeof (unsigned char),
3782 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
3783 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
3784 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
3785 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
3786 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
3788 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
3789 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
3790 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
3794 /* We do not read the external strings or the external symbols. */
3796 ret = (bfd_ecoff_debug_accumulate
3797 (handle, output_bfd, &ecoff_data (output_bfd)->debug_info,
3798 &ecoff_backend (output_bfd)->debug_swap,
3799 input_bfd, debug, swap, info));
3802 if (ecoff_data (input_bfd)->raw_syments == NULL)
3804 if (debug->line != NULL)
3806 if (debug->external_dnr != NULL)
3807 free (debug->external_dnr);
3808 if (debug->external_pdr != NULL)
3809 free (debug->external_pdr);
3810 if (debug->external_sym != NULL)
3811 free (debug->external_sym);
3812 if (debug->external_opt != NULL)
3813 free (debug->external_opt);
3814 if (debug->external_aux != NULL)
3815 free (debug->external_aux);
3816 if (debug->ss != NULL)
3818 if (debug->external_fdr != NULL)
3819 free (debug->external_fdr);
3820 if (debug->external_rfd != NULL)
3821 free (debug->external_rfd);
3823 /* Make sure we don't accidentally follow one of these pointers
3824 into freed memory. */
3826 debug->external_dnr = NULL;
3827 debug->external_pdr = NULL;
3828 debug->external_sym = NULL;
3829 debug->external_opt = NULL;
3830 debug->external_aux = NULL;
3832 debug->external_fdr = NULL;
3833 debug->external_rfd = NULL;
3839 /* Relocate and write an ECOFF section into an ECOFF output file. */
3842 ecoff_indirect_link_order (bfd *output_bfd,
3843 struct bfd_link_info *info,
3844 asection *output_section,
3845 struct bfd_link_order *link_order)
3847 asection *input_section;
3849 bfd_byte *contents = NULL;
3850 bfd_size_type external_reloc_size;
3851 bfd_size_type external_relocs_size;
3852 void * external_relocs = NULL;
3854 BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
3856 input_section = link_order->u.indirect.section;
3857 input_bfd = input_section->owner;
3858 if (input_section->size == 0)
3861 BFD_ASSERT (input_section->output_section == output_section);
3862 BFD_ASSERT (input_section->output_offset == link_order->offset);
3863 BFD_ASSERT (input_section->size == link_order->size);
3865 /* Get the section contents. */
3866 if (!bfd_malloc_and_get_section (input_bfd, input_section, &contents))
3869 /* Get the relocs. If we are relaxing MIPS code, they will already
3870 have been read in. Otherwise, we read them in now. */
3871 external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size;
3872 external_relocs_size = external_reloc_size * input_section->reloc_count;
3874 external_relocs = bfd_malloc (external_relocs_size);
3875 if (external_relocs == NULL && external_relocs_size != 0)
3878 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
3879 || (bfd_bread (external_relocs, external_relocs_size, input_bfd)
3880 != external_relocs_size))
3883 /* Relocate the section contents. */
3884 if (! ((*ecoff_backend (input_bfd)->relocate_section)
3885 (output_bfd, info, input_bfd, input_section, contents,
3889 /* Write out the relocated section. */
3890 if (! bfd_set_section_contents (output_bfd,
3893 input_section->output_offset,
3894 input_section->size))
3897 /* If we are producing relocatable output, the relocs were
3898 modified, and we write them out now. We use the reloc_count
3899 field of output_section to keep track of the number of relocs we
3900 have output so far. */
3901 if (bfd_link_relocatable (info))
3903 file_ptr pos = (output_section->rel_filepos
3904 + output_section->reloc_count * external_reloc_size);
3905 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
3906 || (bfd_bwrite (external_relocs, external_relocs_size, output_bfd)
3907 != external_relocs_size))
3909 output_section->reloc_count += input_section->reloc_count;
3912 if (contents != NULL)
3914 if (external_relocs != NULL)
3915 free (external_relocs);
3919 if (contents != NULL)
3921 if (external_relocs != NULL)
3922 free (external_relocs);
3926 /* Generate a reloc when linking an ECOFF file. This is a reloc
3927 requested by the linker, and does come from any input file. This
3928 is used to build constructor and destructor tables when linking
3932 ecoff_reloc_link_order (bfd *output_bfd,
3933 struct bfd_link_info *info,
3934 asection *output_section,
3935 struct bfd_link_order *link_order)
3937 enum bfd_link_order_type type;
3941 struct internal_reloc in;
3942 bfd_size_type external_reloc_size;
3947 type = link_order->type;
3949 addend = link_order->u.reloc.p->addend;
3951 /* We set up an arelent to pass to the backend adjust_reloc_out
3953 rel.address = link_order->offset;
3955 rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
3958 bfd_set_error (bfd_error_bad_value);
3962 if (type == bfd_section_reloc_link_order)
3964 section = link_order->u.reloc.p->u.section;
3965 rel.sym_ptr_ptr = section->symbol_ptr_ptr;
3969 struct bfd_link_hash_entry *h;
3971 /* Treat a reloc against a defined symbol as though it were
3972 actually against the section. */
3973 h = bfd_wrapped_link_hash_lookup (output_bfd, info,
3974 link_order->u.reloc.p->u.name,
3975 FALSE, FALSE, FALSE);
3977 && (h->type == bfd_link_hash_defined
3978 || h->type == bfd_link_hash_defweak))
3980 type = bfd_section_reloc_link_order;
3981 section = h->u.def.section->output_section;
3982 /* It seems that we ought to add the symbol value to the
3983 addend here, but in practice it has already been added
3984 because it was passed to constructor_callback. */
3985 addend += section->vma + h->u.def.section->output_offset;
3989 /* We can't set up a reloc against a symbol correctly,
3990 because we have no asymbol structure. Currently no
3991 adjust_reloc_out routine cares. */
3992 rel.sym_ptr_ptr = NULL;
3996 /* All ECOFF relocs are in-place. Put the addend into the object
3999 BFD_ASSERT (rel.howto->partial_inplace);
4003 bfd_reloc_status_type rstat;
4006 size = bfd_get_reloc_size (rel.howto);
4007 buf = (bfd_byte *) bfd_zmalloc (size);
4008 if (buf == NULL && size != 0)
4010 rstat = _bfd_relocate_contents (rel.howto, output_bfd,
4011 (bfd_vma) addend, buf);
4017 case bfd_reloc_outofrange:
4019 case bfd_reloc_overflow:
4020 (*info->callbacks->reloc_overflow)
4022 (link_order->type == bfd_section_reloc_link_order
4023 ? bfd_section_name (output_bfd, section)
4024 : link_order->u.reloc.p->u.name),
4025 rel.howto->name, addend, NULL, NULL, (bfd_vma) 0);
4028 ok = bfd_set_section_contents (output_bfd, output_section, (void *) buf,
4029 (file_ptr) link_order->offset, size);
4037 /* Move the information into an internal_reloc structure. */
4038 in.r_vaddr = (rel.address
4039 + bfd_get_section_vma (output_bfd, output_section));
4040 in.r_type = rel.howto->type;
4042 if (type == bfd_symbol_reloc_link_order)
4044 struct ecoff_link_hash_entry *h;
4046 h = ((struct ecoff_link_hash_entry *)
4047 bfd_wrapped_link_hash_lookup (output_bfd, info,
4048 link_order->u.reloc.p->u.name,
4049 FALSE, FALSE, TRUE));
4052 in.r_symndx = h->indx;
4055 (*info->callbacks->unattached_reloc)
4056 (info, link_order->u.reloc.p->u.name, NULL, NULL, (bfd_vma) 0);
4072 { _TEXT, RELOC_SECTION_TEXT },
4073 { _RDATA, RELOC_SECTION_RDATA },
4074 { _DATA, RELOC_SECTION_DATA },
4075 { _SDATA, RELOC_SECTION_SDATA },
4076 { _SBSS, RELOC_SECTION_SBSS },
4077 { _BSS, RELOC_SECTION_BSS },
4078 { _INIT, RELOC_SECTION_INIT },
4079 { _LIT8, RELOC_SECTION_LIT8 },
4080 { _LIT4, RELOC_SECTION_LIT4 },
4081 { _XDATA, RELOC_SECTION_XDATA },
4082 { _PDATA, RELOC_SECTION_PDATA },
4083 { _FINI, RELOC_SECTION_FINI },
4084 { _LITA, RELOC_SECTION_LITA },
4085 { "*ABS*", RELOC_SECTION_ABS },
4086 { _RCONST, RELOC_SECTION_RCONST }
4089 name = bfd_get_section_name (output_bfd, section);
4091 for (i = 0; i < ARRAY_SIZE (section_symndx); i++)
4092 if (streq (name, section_symndx[i].name))
4094 in.r_symndx = section_symndx[i].r_symndx;
4098 if (i == ARRAY_SIZE (section_symndx))
4104 /* Let the BFD backend adjust the reloc. */
4105 (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in);
4107 /* Get some memory and swap out the reloc. */
4108 external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
4109 rbuf = (bfd_byte *) bfd_malloc (external_reloc_size);
4113 (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (void *) rbuf);
4115 pos = (output_section->rel_filepos
4116 + output_section->reloc_count * external_reloc_size);
4117 ok = (bfd_seek (output_bfd, pos, SEEK_SET) == 0
4118 && (bfd_bwrite ((void *) rbuf, external_reloc_size, output_bfd)
4119 == external_reloc_size));
4122 ++output_section->reloc_count;
4129 /* Put out information for an external symbol. These come only from
4133 ecoff_link_write_external (struct bfd_hash_entry *bh, void * data)
4135 struct ecoff_link_hash_entry *h = (struct ecoff_link_hash_entry *) bh;
4136 struct extsym_info *einfo = (struct extsym_info *) data;
4137 bfd *output_bfd = einfo->abfd;
4140 if (h->root.type == bfd_link_hash_warning)
4142 h = (struct ecoff_link_hash_entry *) h->root.u.i.link;
4143 if (h->root.type == bfd_link_hash_new)
4147 /* We need to check if this symbol is being stripped. */
4148 if (h->root.type == bfd_link_hash_undefined
4149 || h->root.type == bfd_link_hash_undefweak)
4151 else if (einfo->info->strip == strip_all
4152 || (einfo->info->strip == strip_some
4153 && bfd_hash_lookup (einfo->info->keep_hash,
4154 h->root.root.string,
4155 FALSE, FALSE) == NULL))
4160 if (strip || h->written)
4163 if (h->abfd == NULL)
4166 h->esym.cobol_main = 0;
4167 h->esym.weakext = 0;
4168 h->esym.reserved = 0;
4169 h->esym.ifd = ifdNil;
4170 h->esym.asym.value = 0;
4171 h->esym.asym.st = stGlobal;
4173 if (h->root.type != bfd_link_hash_defined
4174 && h->root.type != bfd_link_hash_defweak)
4175 h->esym.asym.sc = scAbs;
4178 asection *output_section;
4186 section_storage_classes [] =
4190 { _SDATA, scSData },
4191 { _RDATA, scRData },
4196 { _PDATA, scPData },
4197 { _XDATA, scXData },
4198 { _RCONST, scRConst }
4201 output_section = h->root.u.def.section->output_section;
4202 name = bfd_section_name (output_section->owner, output_section);
4204 for (i = 0; i < ARRAY_SIZE (section_storage_classes); i++)
4205 if (streq (name, section_storage_classes[i].name))
4207 h->esym.asym.sc = section_storage_classes[i].sc;
4211 if (i == ARRAY_SIZE (section_storage_classes))
4212 h->esym.asym.sc = scAbs;
4215 h->esym.asym.reserved = 0;
4216 h->esym.asym.index = indexNil;
4218 else if (h->esym.ifd != -1)
4220 struct ecoff_debug_info *debug;
4222 /* Adjust the FDR index for the symbol by that used for the
4224 debug = &ecoff_data (h->abfd)->debug_info;
4225 BFD_ASSERT (h->esym.ifd >= 0
4226 && h->esym.ifd < debug->symbolic_header.ifdMax);
4227 h->esym.ifd = debug->ifdmap[h->esym.ifd];
4230 switch (h->root.type)
4233 case bfd_link_hash_warning:
4234 case bfd_link_hash_new:
4236 case bfd_link_hash_undefined:
4237 case bfd_link_hash_undefweak:
4238 if (h->esym.asym.sc != scUndefined
4239 && h->esym.asym.sc != scSUndefined)
4240 h->esym.asym.sc = scUndefined;
4242 case bfd_link_hash_defined:
4243 case bfd_link_hash_defweak:
4244 if (h->esym.asym.sc == scUndefined
4245 || h->esym.asym.sc == scSUndefined)
4246 h->esym.asym.sc = scAbs;
4247 else if (h->esym.asym.sc == scCommon)
4248 h->esym.asym.sc = scBss;
4249 else if (h->esym.asym.sc == scSCommon)
4250 h->esym.asym.sc = scSBss;
4251 h->esym.asym.value = (h->root.u.def.value
4252 + h->root.u.def.section->output_section->vma
4253 + h->root.u.def.section->output_offset);
4255 case bfd_link_hash_common:
4256 if (h->esym.asym.sc != scCommon
4257 && h->esym.asym.sc != scSCommon)
4258 h->esym.asym.sc = scCommon;
4259 h->esym.asym.value = h->root.u.c.size;
4261 case bfd_link_hash_indirect:
4262 /* We ignore these symbols, since the indirected symbol is
4263 already in the hash table. */
4267 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4269 h->indx = ecoff_data (output_bfd)->debug_info.symbolic_header.iextMax;
4272 return (bfd_ecoff_debug_one_external
4273 (output_bfd, &ecoff_data (output_bfd)->debug_info,
4274 &ecoff_backend (output_bfd)->debug_swap, h->root.root.string,
4278 /* ECOFF final link routine. This looks through all the input BFDs
4279 and gathers together all the debugging information, and then
4280 processes all the link order information. This may cause it to
4281 close and reopen some input BFDs; I'll see how bad this is. */
4284 _bfd_ecoff_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
4286 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
4287 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
4292 struct bfd_link_order *p;
4293 struct extsym_info einfo;
4295 /* We accumulate the debugging information counts in the symbolic
4297 symhdr = &debug->symbolic_header;
4299 symhdr->ilineMax = 0;
4303 symhdr->isymMax = 0;
4304 symhdr->ioptMax = 0;
4305 symhdr->iauxMax = 0;
4307 symhdr->issExtMax = 0;
4310 symhdr->iextMax = 0;
4312 /* We accumulate the debugging information itself in the debug_info
4315 debug->external_dnr = NULL;
4316 debug->external_pdr = NULL;
4317 debug->external_sym = NULL;
4318 debug->external_opt = NULL;
4319 debug->external_aux = NULL;
4321 debug->ssext = debug->ssext_end = NULL;
4322 debug->external_fdr = NULL;
4323 debug->external_rfd = NULL;
4324 debug->external_ext = debug->external_ext_end = NULL;
4326 handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info);
4330 /* Accumulate the debugging symbols from each input BFD. */
4331 for (input_bfd = info->input_bfds;
4333 input_bfd = input_bfd->link.next)
4337 if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour)
4339 /* Arbitrarily set the symbolic header vstamp to the vstamp
4340 of the first object file in the link. */
4341 if (symhdr->vstamp == 0)
4343 = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp;
4344 ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info,
4348 ret = bfd_ecoff_debug_accumulate_other (handle, abfd,
4349 debug, &backend->debug_swap,
4354 /* Combine the register masks. */
4355 ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask;
4356 ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask;
4357 ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0];
4358 ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1];
4359 ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2];
4360 ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3];
4363 /* Write out the external symbols. */
4366 bfd_hash_traverse (&info->hash->table, ecoff_link_write_external, &einfo);
4368 if (bfd_link_relocatable (info))
4370 /* We need to make a pass over the link_orders to count up the
4371 number of relocations we will need to output, so that we know
4372 how much space they will take up. */
4373 for (o = abfd->sections; o != NULL; o = o->next)
4376 for (p = o->map_head.link_order;
4379 if (p->type == bfd_indirect_link_order)
4380 o->reloc_count += p->u.indirect.section->reloc_count;
4381 else if (p->type == bfd_section_reloc_link_order
4382 || p->type == bfd_symbol_reloc_link_order)
4387 /* Compute the reloc and symbol file positions. */
4388 ecoff_compute_reloc_file_positions (abfd);
4390 /* Write out the debugging information. */
4391 if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug,
4392 &backend->debug_swap, info,
4393 ecoff_data (abfd)->sym_filepos))
4396 bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info);
4398 if (bfd_link_relocatable (info))
4400 /* Now reset the reloc_count field of the sections in the output
4401 BFD to 0, so that we can use them to keep track of how many
4402 relocs we have output thus far. */
4403 for (o = abfd->sections; o != NULL; o = o->next)
4407 /* Get a value for the GP register. */
4408 if (ecoff_data (abfd)->gp == 0)
4410 struct bfd_link_hash_entry *h;
4412 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
4414 && h->type == bfd_link_hash_defined)
4415 ecoff_data (abfd)->gp = (h->u.def.value
4416 + h->u.def.section->output_section->vma
4417 + h->u.def.section->output_offset);
4418 else if (bfd_link_relocatable (info))
4422 /* Make up a value. */
4424 for (o = abfd->sections; o != NULL; o = o->next)
4427 && (streq (o->name, _SBSS)
4428 || streq (o->name, _SDATA)
4429 || streq (o->name, _LIT4)
4430 || streq (o->name, _LIT8)
4431 || streq (o->name, _LITA)))
4434 ecoff_data (abfd)->gp = lo + 0x8000;
4438 /* If the relocate_section function needs to do a reloc
4439 involving the GP value, it should make a reloc_dangerous
4440 callback to warn that GP is not defined. */
4444 for (o = abfd->sections; o != NULL; o = o->next)
4446 for (p = o->map_head.link_order;
4450 if (p->type == bfd_indirect_link_order
4451 && (bfd_get_flavour (p->u.indirect.section->owner)
4452 == bfd_target_ecoff_flavour))
4454 if (! ecoff_indirect_link_order (abfd, info, o, p))
4457 else if (p->type == bfd_section_reloc_link_order
4458 || p->type == bfd_symbol_reloc_link_order)
4460 if (! ecoff_reloc_link_order (abfd, info, o, p))
4465 if (! _bfd_default_link_order (abfd, info, o, p))
4471 bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax;
4473 ecoff_data (abfd)->linker = TRUE;