1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
3 Original version by Per Bothner.
4 Full support added by Ian Lance Taylor, ian@cygnus.com.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
27 #include "aout/ranlib.h"
28 #include "aout/stab_gnu.h"
30 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
31 some other stuff which we don't want and which conflicts with stuff
34 #include "aout/aout64.h"
37 #undef obj_sym_filepos
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
46 /* Prototypes for static functions. */
48 static int ecoff_get_magic PARAMS ((bfd *abfd));
49 static long ecoff_sec_to_styp_flags PARAMS ((const char *name,
51 static boolean ecoff_slurp_symbolic_header PARAMS ((bfd *abfd));
52 static boolean ecoff_set_symbol_info PARAMS ((bfd *abfd, SYMR *ecoff_sym,
53 asymbol *asym, int ext,
54 asymbol **indirect_ptr_ptr));
55 static void ecoff_emit_aggregate PARAMS ((bfd *abfd, FDR *fdr,
57 RNDXR *rndx, long isym,
59 static char *ecoff_type_to_string PARAMS ((bfd *abfd, FDR *fdr,
61 static boolean ecoff_slurp_reloc_table PARAMS ((bfd *abfd, asection *section,
63 static void ecoff_compute_section_file_positions PARAMS ((bfd *abfd));
64 static bfd_size_type ecoff_compute_reloc_file_positions PARAMS ((bfd *abfd));
65 static boolean ecoff_get_extr PARAMS ((asymbol *, EXTR *));
66 static void ecoff_set_index PARAMS ((asymbol *, bfd_size_type));
67 static unsigned int ecoff_armap_hash PARAMS ((CONST char *s,
72 /* This stuff is somewhat copied from coffcode.h. */
74 static asection bfd_debug_section = { "*DEBUG*" };
76 /* Create an ECOFF object. */
79 _bfd_ecoff_mkobject (abfd)
82 abfd->tdata.ecoff_obj_data = ((struct ecoff_tdata *)
83 bfd_zalloc (abfd, sizeof (ecoff_data_type)));
84 if (abfd->tdata.ecoff_obj_data == NULL)
86 bfd_set_error (bfd_error_no_memory);
93 /* This is a hook called by coff_real_object_p to create any backend
94 specific information. */
97 _bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr)
102 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
103 struct internal_aouthdr *internal_a = (struct internal_aouthdr *) aouthdr;
104 ecoff_data_type *ecoff;
106 if (_bfd_ecoff_mkobject (abfd) == false)
109 ecoff = ecoff_data (abfd);
111 ecoff->sym_filepos = internal_f->f_symptr;
113 if (internal_a != (struct internal_aouthdr *) NULL)
117 ecoff->text_start = internal_a->text_start;
118 ecoff->text_end = internal_a->text_start + internal_a->tsize;
119 ecoff->gp = internal_a->gp_value;
120 ecoff->gprmask = internal_a->gprmask;
121 for (i = 0; i < 4; i++)
122 ecoff->cprmask[i] = internal_a->cprmask[i];
123 ecoff->fprmask = internal_a->fprmask;
124 if (internal_a->magic == ECOFF_AOUT_ZMAGIC)
125 abfd->flags |= D_PAGED;
128 /* It turns out that no special action is required by the MIPS or
129 Alpha ECOFF backends. They have different information in the
130 a.out header, but we just copy it all (e.g., gprmask, cprmask and
131 fprmask) and let the swapping routines ensure that only relevant
132 information is written out. */
137 /* This is a hook needed by SCO COFF, but we have nothing to do. */
141 _bfd_ecoff_make_section_hook (abfd, name)
145 return (asection *) NULL;
148 /* Initialize a new section. */
151 _bfd_ecoff_new_section_hook (abfd, section)
155 /* For the .pdata section, which has a special meaning on the Alpha,
156 we set the alignment power to 3. We correct this later in
157 ecoff_compute_section_file_positions. We do this hackery because
158 we need to know the exact unaligned size of the .pdata section in
159 order to set the lnnoptr field correctly. For every other
160 section we use an alignment power of 4; this could be made target
161 dependent by adding a field to ecoff_backend_data, but 4 appears
162 to be correct for both the MIPS and the Alpha. */
163 if (strcmp (section->name, _PDATA) == 0)
164 section->alignment_power = 3;
166 section->alignment_power = 4;
168 if (strcmp (section->name, _TEXT) == 0)
169 section->flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
170 else if (strcmp (section->name, _DATA) == 0
171 || strcmp (section->name, _SDATA) == 0)
172 section->flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
173 else if (strcmp (section->name, _RDATA) == 0
174 || strcmp (section->name, _LIT8) == 0
175 || strcmp (section->name, _LIT4) == 0)
176 section->flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY;
177 else if (strcmp (section->name, _BSS) == 0
178 || strcmp (section->name, _SBSS) == 0)
179 section->flags |= SEC_ALLOC;
180 else if (strcmp (section->name, _LIB) == 0)
182 /* An Irix 4 shared libary. */
183 section->flags |= SEC_COFF_SHARED_LIBRARY;
186 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
187 uncertain about .init on some systems and I don't know how shared
193 /* Determine the machine architecture and type. This is called from
194 the generic COFF routines. It is the inverse of ecoff_get_magic,
195 below. This could be an ECOFF backend routine, with one version
196 for each target, but there aren't all that many ECOFF targets. */
199 _bfd_ecoff_set_arch_mach_hook (abfd, filehdr)
203 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
204 enum bfd_architecture arch;
207 switch (internal_f->f_magic)
210 case MIPS_MAGIC_LITTLE:
212 arch = bfd_arch_mips;
216 case MIPS_MAGIC_LITTLE2:
217 case MIPS_MAGIC_BIG2:
218 /* MIPS ISA level 2: the r6000 */
219 arch = bfd_arch_mips;
223 case MIPS_MAGIC_LITTLE3:
224 case MIPS_MAGIC_BIG3:
225 /* MIPS ISA level 3: the r4000 */
226 arch = bfd_arch_mips;
231 arch = bfd_arch_alpha;
236 arch = bfd_arch_obscure;
241 return bfd_default_set_arch_mach (abfd, arch, mach);
244 /* Get the magic number to use based on the architecture and machine.
245 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
248 ecoff_get_magic (abfd)
253 switch (bfd_get_arch (abfd))
256 switch (bfd_get_mach (abfd))
261 big = MIPS_MAGIC_BIG;
262 little = MIPS_MAGIC_LITTLE;
266 big = MIPS_MAGIC_BIG2;
267 little = MIPS_MAGIC_LITTLE2;
271 big = MIPS_MAGIC_BIG3;
272 little = MIPS_MAGIC_LITTLE3;
276 return abfd->xvec->byteorder_big_p ? big : little;
287 /* Get the section s_flags to use for a section. */
290 ecoff_sec_to_styp_flags (name, flags)
298 if (strcmp (name, _TEXT) == 0)
300 else if (strcmp (name, _DATA) == 0)
302 else if (strcmp (name, _SDATA) == 0)
304 else if (strcmp (name, _RDATA) == 0)
306 else if (strcmp (name, _LITA) == 0)
308 else if (strcmp (name, _LIT8) == 0)
310 else if (strcmp (name, _LIT4) == 0)
312 else if (strcmp (name, _BSS) == 0)
314 else if (strcmp (name, _SBSS) == 0)
316 else if (strcmp (name, _INIT) == 0)
317 styp = STYP_ECOFF_INIT;
318 else if (strcmp (name, _FINI) == 0)
319 styp = STYP_ECOFF_FINI;
320 else if (strcmp (name, _PDATA) == 0)
322 else if (strcmp (name, _XDATA) == 0)
324 else if (strcmp (name, _LIB) == 0)
325 styp = STYP_ECOFF_LIB;
326 else if (flags & SEC_CODE)
328 else if (flags & SEC_DATA)
330 else if (flags & SEC_READONLY)
332 else if (flags & SEC_LOAD)
337 if (flags & SEC_NEVER_LOAD)
343 /* Get the BFD flags to use for a section. */
347 _bfd_ecoff_styp_to_sec_flags (abfd, hdr, name)
352 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
353 long styp_flags = internal_s->s_flags;
354 flagword sec_flags=0;
356 if (styp_flags & STYP_NOLOAD)
357 sec_flags |= SEC_NEVER_LOAD;
359 /* For 386 COFF, at least, an unloadable text or data section is
360 actually a shared library section. */
361 if ((styp_flags & STYP_TEXT)
362 || (styp_flags & STYP_ECOFF_INIT)
363 || (styp_flags & STYP_ECOFF_FINI))
365 if (sec_flags & SEC_NEVER_LOAD)
366 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
368 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
370 else if ((styp_flags & STYP_DATA)
371 || (styp_flags & STYP_RDATA)
372 || (styp_flags & STYP_SDATA)
373 || styp_flags == STYP_PDATA
374 || styp_flags == STYP_XDATA)
376 if (sec_flags & SEC_NEVER_LOAD)
377 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
379 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
380 if ((styp_flags & STYP_RDATA)
381 || styp_flags == STYP_PDATA)
382 sec_flags |= SEC_READONLY;
384 else if ((styp_flags & STYP_BSS)
385 || (styp_flags & STYP_SBSS))
387 sec_flags |= SEC_ALLOC;
389 else if ((styp_flags & STYP_INFO) || styp_flags == STYP_COMMENT)
391 sec_flags |= SEC_NEVER_LOAD;
393 else if ((styp_flags & STYP_LITA)
394 || (styp_flags & STYP_LIT8)
395 || (styp_flags & STYP_LIT4))
397 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY;
399 else if (styp_flags & STYP_ECOFF_LIB)
401 sec_flags |= SEC_COFF_SHARED_LIBRARY;
405 sec_flags |= SEC_ALLOC | SEC_LOAD;
411 /* Routines to swap auxiliary information in and out. I am assuming
412 that the auxiliary information format is always going to be target
415 /* Swap in a type information record.
416 BIGEND says whether AUX symbols are big-endian or little-endian; this
417 info comes from the file header record (fh-fBigendian). */
420 _bfd_ecoff_swap_tir_in (bigend, ext_copy, intern)
422 const struct tir_ext *ext_copy;
425 struct tir_ext ext[1];
427 *ext = *ext_copy; /* Make it reasonable to do in-place. */
429 /* now the fun stuff... */
431 intern->fBitfield = 0 != (ext->t_bits1[0] & TIR_BITS1_FBITFIELD_BIG);
432 intern->continued = 0 != (ext->t_bits1[0] & TIR_BITS1_CONTINUED_BIG);
433 intern->bt = (ext->t_bits1[0] & TIR_BITS1_BT_BIG)
434 >> TIR_BITS1_BT_SH_BIG;
435 intern->tq4 = (ext->t_tq45[0] & TIR_BITS_TQ4_BIG)
436 >> TIR_BITS_TQ4_SH_BIG;
437 intern->tq5 = (ext->t_tq45[0] & TIR_BITS_TQ5_BIG)
438 >> TIR_BITS_TQ5_SH_BIG;
439 intern->tq0 = (ext->t_tq01[0] & TIR_BITS_TQ0_BIG)
440 >> TIR_BITS_TQ0_SH_BIG;
441 intern->tq1 = (ext->t_tq01[0] & TIR_BITS_TQ1_BIG)
442 >> TIR_BITS_TQ1_SH_BIG;
443 intern->tq2 = (ext->t_tq23[0] & TIR_BITS_TQ2_BIG)
444 >> TIR_BITS_TQ2_SH_BIG;
445 intern->tq3 = (ext->t_tq23[0] & TIR_BITS_TQ3_BIG)
446 >> TIR_BITS_TQ3_SH_BIG;
448 intern->fBitfield = 0 != (ext->t_bits1[0] & TIR_BITS1_FBITFIELD_LITTLE);
449 intern->continued = 0 != (ext->t_bits1[0] & TIR_BITS1_CONTINUED_LITTLE);
450 intern->bt = (ext->t_bits1[0] & TIR_BITS1_BT_LITTLE)
451 >> TIR_BITS1_BT_SH_LITTLE;
452 intern->tq4 = (ext->t_tq45[0] & TIR_BITS_TQ4_LITTLE)
453 >> TIR_BITS_TQ4_SH_LITTLE;
454 intern->tq5 = (ext->t_tq45[0] & TIR_BITS_TQ5_LITTLE)
455 >> TIR_BITS_TQ5_SH_LITTLE;
456 intern->tq0 = (ext->t_tq01[0] & TIR_BITS_TQ0_LITTLE)
457 >> TIR_BITS_TQ0_SH_LITTLE;
458 intern->tq1 = (ext->t_tq01[0] & TIR_BITS_TQ1_LITTLE)
459 >> TIR_BITS_TQ1_SH_LITTLE;
460 intern->tq2 = (ext->t_tq23[0] & TIR_BITS_TQ2_LITTLE)
461 >> TIR_BITS_TQ2_SH_LITTLE;
462 intern->tq3 = (ext->t_tq23[0] & TIR_BITS_TQ3_LITTLE)
463 >> TIR_BITS_TQ3_SH_LITTLE;
467 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
472 /* Swap out a type information record.
473 BIGEND says whether AUX symbols are big-endian or little-endian; this
474 info comes from the file header record (fh-fBigendian). */
477 _bfd_ecoff_swap_tir_out (bigend, intern_copy, ext)
479 const TIR *intern_copy;
484 *intern = *intern_copy; /* Make it reasonable to do in-place. */
486 /* now the fun stuff... */
488 ext->t_bits1[0] = ((intern->fBitfield ? TIR_BITS1_FBITFIELD_BIG : 0)
489 | (intern->continued ? TIR_BITS1_CONTINUED_BIG : 0)
490 | ((intern->bt << TIR_BITS1_BT_SH_BIG)
491 & TIR_BITS1_BT_BIG));
492 ext->t_tq45[0] = (((intern->tq4 << TIR_BITS_TQ4_SH_BIG)
494 | ((intern->tq5 << TIR_BITS_TQ5_SH_BIG)
495 & TIR_BITS_TQ5_BIG));
496 ext->t_tq01[0] = (((intern->tq0 << TIR_BITS_TQ0_SH_BIG)
498 | ((intern->tq1 << TIR_BITS_TQ1_SH_BIG)
499 & TIR_BITS_TQ1_BIG));
500 ext->t_tq23[0] = (((intern->tq2 << TIR_BITS_TQ2_SH_BIG)
502 | ((intern->tq3 << TIR_BITS_TQ3_SH_BIG)
503 & TIR_BITS_TQ3_BIG));
505 ext->t_bits1[0] = ((intern->fBitfield ? TIR_BITS1_FBITFIELD_LITTLE : 0)
506 | (intern->continued ? TIR_BITS1_CONTINUED_LITTLE : 0)
507 | ((intern->bt << TIR_BITS1_BT_SH_LITTLE)
508 & TIR_BITS1_BT_LITTLE));
509 ext->t_tq45[0] = (((intern->tq4 << TIR_BITS_TQ4_SH_LITTLE)
510 & TIR_BITS_TQ4_LITTLE)
511 | ((intern->tq5 << TIR_BITS_TQ5_SH_LITTLE)
512 & TIR_BITS_TQ5_LITTLE));
513 ext->t_tq01[0] = (((intern->tq0 << TIR_BITS_TQ0_SH_LITTLE)
514 & TIR_BITS_TQ0_LITTLE)
515 | ((intern->tq1 << TIR_BITS_TQ1_SH_LITTLE)
516 & TIR_BITS_TQ1_LITTLE));
517 ext->t_tq23[0] = (((intern->tq2 << TIR_BITS_TQ2_SH_LITTLE)
518 & TIR_BITS_TQ2_LITTLE)
519 | ((intern->tq3 << TIR_BITS_TQ3_SH_LITTLE)
520 & TIR_BITS_TQ3_LITTLE));
524 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
529 /* Swap in a relative symbol record. BIGEND says whether it is in
530 big-endian or little-endian format.*/
533 _bfd_ecoff_swap_rndx_in (bigend, ext_copy, intern)
535 const struct rndx_ext *ext_copy;
538 struct rndx_ext ext[1];
540 *ext = *ext_copy; /* Make it reasonable to do in-place. */
542 /* now the fun stuff... */
544 intern->rfd = (ext->r_bits[0] << RNDX_BITS0_RFD_SH_LEFT_BIG)
545 | ((ext->r_bits[1] & RNDX_BITS1_RFD_BIG)
546 >> RNDX_BITS1_RFD_SH_BIG);
547 intern->index = ((ext->r_bits[1] & RNDX_BITS1_INDEX_BIG)
548 << RNDX_BITS1_INDEX_SH_LEFT_BIG)
549 | (ext->r_bits[2] << RNDX_BITS2_INDEX_SH_LEFT_BIG)
550 | (ext->r_bits[3] << RNDX_BITS3_INDEX_SH_LEFT_BIG);
552 intern->rfd = (ext->r_bits[0] << RNDX_BITS0_RFD_SH_LEFT_LITTLE)
553 | ((ext->r_bits[1] & RNDX_BITS1_RFD_LITTLE)
554 << RNDX_BITS1_RFD_SH_LEFT_LITTLE);
555 intern->index = ((ext->r_bits[1] & RNDX_BITS1_INDEX_LITTLE)
556 >> RNDX_BITS1_INDEX_SH_LITTLE)
557 | (ext->r_bits[2] << RNDX_BITS2_INDEX_SH_LEFT_LITTLE)
558 | ((unsigned int) ext->r_bits[3]
559 << RNDX_BITS3_INDEX_SH_LEFT_LITTLE);
563 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
568 /* Swap out a relative symbol record. BIGEND says whether it is in
569 big-endian or little-endian format.*/
572 _bfd_ecoff_swap_rndx_out (bigend, intern_copy, ext)
574 const RNDXR *intern_copy;
575 struct rndx_ext *ext;
579 *intern = *intern_copy; /* Make it reasonable to do in-place. */
581 /* now the fun stuff... */
583 ext->r_bits[0] = intern->rfd >> RNDX_BITS0_RFD_SH_LEFT_BIG;
584 ext->r_bits[1] = (((intern->rfd << RNDX_BITS1_RFD_SH_BIG)
585 & RNDX_BITS1_RFD_BIG)
586 | ((intern->index >> RNDX_BITS1_INDEX_SH_LEFT_BIG)
587 & RNDX_BITS1_INDEX_BIG));
588 ext->r_bits[2] = intern->index >> RNDX_BITS2_INDEX_SH_LEFT_BIG;
589 ext->r_bits[3] = intern->index >> RNDX_BITS3_INDEX_SH_LEFT_BIG;
591 ext->r_bits[0] = intern->rfd >> RNDX_BITS0_RFD_SH_LEFT_LITTLE;
592 ext->r_bits[1] = (((intern->rfd >> RNDX_BITS1_RFD_SH_LEFT_LITTLE)
593 & RNDX_BITS1_RFD_LITTLE)
594 | ((intern->index << RNDX_BITS1_INDEX_SH_LITTLE)
595 & RNDX_BITS1_INDEX_LITTLE));
596 ext->r_bits[2] = intern->index >> RNDX_BITS2_INDEX_SH_LEFT_LITTLE;
597 ext->r_bits[3] = intern->index >> RNDX_BITS3_INDEX_SH_LEFT_LITTLE;
601 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
606 /* Read in the symbolic header for an ECOFF object file. */
609 ecoff_slurp_symbolic_header (abfd)
612 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
613 bfd_size_type external_hdr_size;
615 HDRR *internal_symhdr;
617 /* See if we've already read it in. */
618 if (ecoff_data (abfd)->debug_info.symbolic_header.magic ==
619 backend->debug_swap.sym_magic)
622 /* See whether there is a symbolic header. */
623 if (ecoff_data (abfd)->sym_filepos == 0)
625 bfd_get_symcount (abfd) = 0;
629 /* At this point bfd_get_symcount (abfd) holds the number of symbols
630 as read from the file header, but on ECOFF this is always the
631 size of the symbolic information header. It would be cleaner to
632 handle this when we first read the file in coffgen.c. */
633 external_hdr_size = backend->debug_swap.external_hdr_size;
634 if (bfd_get_symcount (abfd) != external_hdr_size)
636 bfd_set_error (bfd_error_bad_value);
640 /* Read the symbolic information header. */
641 raw = (PTR) malloc ((size_t) external_hdr_size);
644 bfd_set_error (bfd_error_no_memory);
648 if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) == -1
649 || (bfd_read (raw, external_hdr_size, 1, abfd)
650 != external_hdr_size))
652 internal_symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
653 (*backend->debug_swap.swap_hdr_in) (abfd, raw, internal_symhdr);
655 if (internal_symhdr->magic != backend->debug_swap.sym_magic)
657 bfd_set_error (bfd_error_bad_value);
661 /* Now we can get the correct number of symbols. */
662 bfd_get_symcount (abfd) = (internal_symhdr->isymMax
663 + internal_symhdr->iextMax);
674 /* Read in and swap the important symbolic information for an ECOFF
675 object file. This is called by gdb via the read_debug_info entry
676 point in the backend structure. */
680 _bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug)
683 struct ecoff_debug_info *debug;
685 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
686 HDRR *internal_symhdr;
687 bfd_size_type raw_base;
688 bfd_size_type raw_size;
690 bfd_size_type external_fdr_size;
694 bfd_size_type raw_end;
695 bfd_size_type cb_end;
697 BFD_ASSERT (debug == &ecoff_data (abfd)->debug_info);
699 /* Check whether we've already gotten it, and whether there's any to
701 if (ecoff_data (abfd)->raw_syments != (PTR) NULL)
703 if (ecoff_data (abfd)->sym_filepos == 0)
705 bfd_get_symcount (abfd) = 0;
709 if (! ecoff_slurp_symbolic_header (abfd))
712 internal_symhdr = &debug->symbolic_header;
714 /* Read all the symbolic information at once. */
715 raw_base = (ecoff_data (abfd)->sym_filepos
716 + backend->debug_swap.external_hdr_size);
718 /* Alpha ecoff makes the determination of raw_size difficult. It has
719 an undocumented debug data section between the symhdr and the first
720 documented section. And the ordering of the sections varies between
721 statically and dynamically linked executables.
722 If bfd supports SEEK_END someday, this code could be simplified. */
726 #define UPDATE_RAW_END(start, count, size) \
727 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
728 if (cb_end > raw_end) \
731 UPDATE_RAW_END (cbLineOffset, cbLine, sizeof (unsigned char));
732 UPDATE_RAW_END (cbDnOffset, idnMax, backend->debug_swap.external_dnr_size);
733 UPDATE_RAW_END (cbPdOffset, ipdMax, backend->debug_swap.external_pdr_size);
734 UPDATE_RAW_END (cbSymOffset, isymMax, backend->debug_swap.external_sym_size);
735 UPDATE_RAW_END (cbOptOffset, ioptMax, backend->debug_swap.external_opt_size);
736 UPDATE_RAW_END (cbAuxOffset, iauxMax, sizeof (union aux_ext));
737 UPDATE_RAW_END (cbSsOffset, issMax, sizeof (char));
738 UPDATE_RAW_END (cbSsExtOffset, issExtMax, sizeof (char));
739 UPDATE_RAW_END (cbFdOffset, ifdMax, backend->debug_swap.external_fdr_size);
740 UPDATE_RAW_END (cbRfdOffset, crfd, backend->debug_swap.external_rfd_size);
741 UPDATE_RAW_END (cbExtOffset, iextMax, backend->debug_swap.external_ext_size);
743 #undef UPDATE_RAW_END
745 raw_size = raw_end - raw_base;
748 ecoff_data (abfd)->sym_filepos = 0;
751 raw = (PTR) bfd_alloc (abfd, raw_size);
754 bfd_set_error (bfd_error_no_memory);
758 (ecoff_data (abfd)->sym_filepos
759 + backend->debug_swap.external_hdr_size),
761 || bfd_read (raw, raw_size, 1, abfd) != raw_size)
763 bfd_release (abfd, raw);
767 ecoff_data (abfd)->raw_syments = raw;
769 /* Get pointers for the numeric offsets in the HDRR structure. */
770 #define FIX(off1, off2, type) \
771 if (internal_symhdr->off1 == 0) \
772 debug->off2 = (type) NULL; \
774 debug->off2 = (type) ((char *) raw \
775 + internal_symhdr->off1 \
777 FIX (cbLineOffset, line, unsigned char *);
778 FIX (cbDnOffset, external_dnr, PTR);
779 FIX (cbPdOffset, external_pdr, PTR);
780 FIX (cbSymOffset, external_sym, PTR);
781 FIX (cbOptOffset, external_opt, PTR);
782 FIX (cbAuxOffset, external_aux, union aux_ext *);
783 FIX (cbSsOffset, ss, char *);
784 FIX (cbSsExtOffset, ssext, char *);
785 FIX (cbFdOffset, external_fdr, PTR);
786 FIX (cbRfdOffset, external_rfd, PTR);
787 FIX (cbExtOffset, external_ext, PTR);
790 /* I don't want to always swap all the data, because it will just
791 waste time and most programs will never look at it. The only
792 time the linker needs most of the debugging information swapped
793 is when linking big-endian and little-endian MIPS object files
794 together, which is not a common occurrence.
796 We need to look at the fdr to deal with a lot of information in
797 the symbols, so we swap them here. */
798 debug->fdr = (struct fdr *) bfd_alloc (abfd,
799 (internal_symhdr->ifdMax *
800 sizeof (struct fdr)));
801 if (debug->fdr == NULL)
803 bfd_set_error (bfd_error_no_memory);
806 external_fdr_size = backend->debug_swap.external_fdr_size;
807 fdr_ptr = debug->fdr;
808 fraw_src = (char *) debug->external_fdr;
809 fraw_end = fraw_src + internal_symhdr->ifdMax * external_fdr_size;
810 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
811 (*backend->debug_swap.swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
816 /* ECOFF symbol table routines. The ECOFF symbol table is described
817 in gcc/mips-tfile.c. */
819 /* ECOFF uses two common sections. One is the usual one, and the
820 other is for small objects. All the small objects are kept
821 together, and then referenced via the gp pointer, which yields
822 faster assembler code. This is what we use for the small common
824 static asection ecoff_scom_section;
825 static asymbol ecoff_scom_symbol;
826 static asymbol *ecoff_scom_symbol_ptr;
828 /* Create an empty symbol. */
831 _bfd_ecoff_make_empty_symbol (abfd)
834 ecoff_symbol_type *new;
836 new = (ecoff_symbol_type *) bfd_alloc (abfd, sizeof (ecoff_symbol_type));
837 if (new == (ecoff_symbol_type *) NULL)
839 bfd_set_error (bfd_error_no_memory);
840 return (asymbol *) NULL;
842 memset ((PTR) new, 0, sizeof *new);
843 new->symbol.section = (asection *) NULL;
844 new->fdr = (FDR *) NULL;
847 new->symbol.the_bfd = abfd;
851 /* Set the BFD flags and section for an ECOFF symbol. */
854 ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, indirect_ptr_ptr)
859 asymbol **indirect_ptr_ptr;
861 asym->the_bfd = abfd;
862 asym->value = ecoff_sym->value;
863 asym->section = &bfd_debug_section;
866 /* An indirect symbol requires two consecutive stabs symbols. */
867 if (*indirect_ptr_ptr != (asymbol *) NULL)
869 BFD_ASSERT (ECOFF_IS_STAB (ecoff_sym));
871 /* @@ Stuffing pointers into integers is a no-no.
872 We can usually get away with it if the integer is
873 large enough though. */
874 if (sizeof (asym) > sizeof (bfd_vma))
876 (*indirect_ptr_ptr)->value = (bfd_vma) asym;
878 asym->flags = BSF_DEBUGGING;
879 asym->section = bfd_und_section_ptr;
880 *indirect_ptr_ptr = NULL;
884 if (ECOFF_IS_STAB (ecoff_sym)
885 && (ECOFF_UNMARK_STAB (ecoff_sym->index) | N_EXT) == (N_INDR | N_EXT))
887 asym->flags = BSF_DEBUGGING | BSF_INDIRECT;
888 asym->section = bfd_ind_section_ptr;
889 /* Pass this symbol on to the next call to this function. */
890 *indirect_ptr_ptr = asym;
894 /* Most symbol types are just for debugging. */
895 switch (ecoff_sym->st)
904 if (ECOFF_IS_STAB (ecoff_sym))
906 asym->flags = BSF_DEBUGGING;
911 asym->flags = BSF_DEBUGGING;
916 asym->flags = BSF_EXPORT | BSF_GLOBAL;
919 asym->flags = BSF_LOCAL;
920 /* Normally, a local stProc symbol will have a corresponding
921 external symbol. We mark the local symbol as a debugging
922 symbol, in order to prevent nm from printing both out.
923 Similarly, we mark stLabel and stabs symbols as debugging
924 symbols. In both cases, we do want to set the value
925 correctly based on the symbol class. */
926 if (ecoff_sym->st == stProc
927 || ecoff_sym->st == stLabel
928 || ECOFF_IS_STAB (ecoff_sym))
929 asym->flags |= BSF_DEBUGGING;
931 switch (ecoff_sym->sc)
934 /* Used for compiler generated labels. Leave them in the
935 debugging section, and mark them as local. If BSF_DEBUGGING
936 is set, then nm does not display them for some reason. If no
937 flags are set then the linker whines about them. */
938 asym->flags = BSF_LOCAL;
941 asym->section = bfd_make_section_old_way (abfd, ".text");
942 asym->value -= asym->section->vma;
945 asym->section = bfd_make_section_old_way (abfd, ".data");
946 asym->value -= asym->section->vma;
949 asym->section = bfd_make_section_old_way (abfd, ".bss");
950 asym->value -= asym->section->vma;
953 asym->flags = BSF_DEBUGGING;
956 asym->section = bfd_abs_section_ptr;
959 asym->section = bfd_und_section_ptr;
969 asym->flags = BSF_DEBUGGING;
972 asym->section = bfd_make_section_old_way (abfd, ".sdata");
973 asym->value -= asym->section->vma;
976 asym->section = bfd_make_section_old_way (abfd, ".sbss");
977 asym->value -= asym->section->vma;
980 asym->section = bfd_make_section_old_way (abfd, ".rdata");
981 asym->value -= asym->section->vma;
984 asym->flags = BSF_DEBUGGING;
987 if (asym->value > ecoff_data (abfd)->gp_size)
989 asym->section = bfd_com_section_ptr;
995 if (ecoff_scom_section.name == NULL)
997 /* Initialize the small common section. */
998 ecoff_scom_section.name = SCOMMON;
999 ecoff_scom_section.flags = SEC_IS_COMMON;
1000 ecoff_scom_section.output_section = &ecoff_scom_section;
1001 ecoff_scom_section.symbol = &ecoff_scom_symbol;
1002 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
1003 ecoff_scom_symbol.name = SCOMMON;
1004 ecoff_scom_symbol.flags = BSF_SECTION_SYM;
1005 ecoff_scom_symbol.section = &ecoff_scom_section;
1006 ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
1008 asym->section = &ecoff_scom_section;
1013 asym->flags = BSF_DEBUGGING;
1016 asym->section = bfd_und_section_ptr;
1021 asym->section = bfd_make_section_old_way (abfd, ".init");
1022 asym->value -= asym->section->vma;
1027 asym->flags = BSF_DEBUGGING;
1030 asym->section = bfd_make_section_old_way (abfd, ".fini");
1031 asym->value -= asym->section->vma;
1037 /* Look for special constructors symbols and make relocation entries
1038 in a special construction section. These are produced by the
1039 -fgnu-linker argument to g++. */
1040 if (ECOFF_IS_STAB (ecoff_sym))
1042 switch (ECOFF_UNMARK_STAB (ecoff_sym->index))
1054 arelent_chain *reloc_chain;
1055 unsigned int bitsize;
1057 /* Get a section with the same name as the symbol (usually
1058 __CTOR_LIST__ or __DTOR_LIST__). FIXME: gcc uses the
1059 name ___CTOR_LIST (three underscores). We need
1060 __CTOR_LIST (two underscores), since ECOFF doesn't use
1061 a leading underscore. This should be handled by gcc,
1062 but instead we do it here. Actually, this should all
1063 be done differently anyhow. */
1064 name = bfd_asymbol_name (asym);
1065 if (name[0] == '_' && name[1] == '_' && name[2] == '_')
1070 section = bfd_get_section_by_name (abfd, name);
1071 if (section == (asection *) NULL)
1075 copy = (char *) bfd_alloc (abfd, strlen (name) + 1);
1078 bfd_set_error (bfd_error_no_memory);
1081 strcpy (copy, name);
1082 section = bfd_make_section (abfd, copy);
1085 /* Build a reloc pointing to this constructor. */
1087 (arelent_chain *) bfd_alloc (abfd, sizeof (arelent_chain));
1090 bfd_set_error (bfd_error_no_memory);
1093 reloc_chain->relent.sym_ptr_ptr =
1094 bfd_get_section (asym)->symbol_ptr_ptr;
1095 reloc_chain->relent.address = section->_raw_size;
1096 reloc_chain->relent.addend = asym->value;
1097 reloc_chain->relent.howto =
1098 ecoff_backend (abfd)->constructor_reloc;
1100 /* Set up the constructor section to hold the reloc. */
1101 section->flags = SEC_CONSTRUCTOR;
1102 ++section->reloc_count;
1104 /* Constructor sections must be rounded to a boundary
1105 based on the bitsize. These are not real sections--
1106 they are handled specially by the linker--so the ECOFF
1107 16 byte alignment restriction does not apply. */
1108 bitsize = ecoff_backend (abfd)->constructor_bitsize;
1109 section->alignment_power = 1;
1110 while ((1 << section->alignment_power) < bitsize / 8)
1111 ++section->alignment_power;
1113 reloc_chain->next = section->constructor_chain;
1114 section->constructor_chain = reloc_chain;
1115 section->_raw_size += bitsize / 8;
1117 /* Mark the symbol as a constructor. */
1118 asym->flags |= BSF_CONSTRUCTOR;
1126 /* Read an ECOFF symbol table. */
1129 _bfd_ecoff_slurp_symbol_table (abfd)
1132 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
1133 const bfd_size_type external_ext_size
1134 = backend->debug_swap.external_ext_size;
1135 const bfd_size_type external_sym_size
1136 = backend->debug_swap.external_sym_size;
1137 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
1138 = backend->debug_swap.swap_ext_in;
1139 void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *))
1140 = backend->debug_swap.swap_sym_in;
1141 bfd_size_type internal_size;
1142 ecoff_symbol_type *internal;
1143 ecoff_symbol_type *internal_ptr;
1144 asymbol *indirect_ptr;
1150 /* If we've already read in the symbol table, do nothing. */
1151 if (ecoff_data (abfd)->canonical_symbols != NULL)
1154 /* Get the symbolic information. */
1155 if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL,
1156 &ecoff_data (abfd)->debug_info))
1158 if (bfd_get_symcount (abfd) == 0)
1161 internal_size = bfd_get_symcount (abfd) * sizeof (ecoff_symbol_type);
1162 internal = (ecoff_symbol_type *) bfd_alloc (abfd, internal_size);
1163 if (internal == NULL)
1165 bfd_set_error (bfd_error_no_memory);
1169 internal_ptr = internal;
1170 indirect_ptr = NULL;
1171 eraw_src = (char *) ecoff_data (abfd)->debug_info.external_ext;
1172 eraw_end = (eraw_src
1173 + (ecoff_data (abfd)->debug_info.symbolic_header.iextMax
1174 * external_ext_size));
1175 for (; eraw_src < eraw_end; eraw_src += external_ext_size, internal_ptr++)
1179 (*swap_ext_in) (abfd, (PTR) eraw_src, &internal_esym);
1180 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ssext
1181 + internal_esym.asym.iss);
1182 if (!ecoff_set_symbol_info (abfd, &internal_esym.asym,
1183 &internal_ptr->symbol, 1, &indirect_ptr))
1185 /* The alpha uses a negative ifd field for section symbols. */
1186 if (internal_esym.ifd >= 0)
1187 internal_ptr->fdr = (ecoff_data (abfd)->debug_info.fdr
1188 + internal_esym.ifd);
1190 internal_ptr->fdr = NULL;
1191 internal_ptr->local = false;
1192 internal_ptr->native = (PTR) eraw_src;
1194 BFD_ASSERT (indirect_ptr == (asymbol *) NULL);
1196 /* The local symbols must be accessed via the fdr's, because the
1197 string and aux indices are relative to the fdr information. */
1198 fdr_ptr = ecoff_data (abfd)->debug_info.fdr;
1199 fdr_end = fdr_ptr + ecoff_data (abfd)->debug_info.symbolic_header.ifdMax;
1200 for (; fdr_ptr < fdr_end; fdr_ptr++)
1205 lraw_src = ((char *) ecoff_data (abfd)->debug_info.external_sym
1206 + fdr_ptr->isymBase * external_sym_size);
1207 lraw_end = lraw_src + fdr_ptr->csym * external_sym_size;
1209 lraw_src < lraw_end;
1210 lraw_src += external_sym_size, internal_ptr++)
1214 (*swap_sym_in) (abfd, (PTR) lraw_src, &internal_sym);
1215 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ss
1217 + internal_sym.iss);
1218 if (!ecoff_set_symbol_info (abfd, &internal_sym,
1219 &internal_ptr->symbol, 0, &indirect_ptr))
1221 internal_ptr->fdr = fdr_ptr;
1222 internal_ptr->local = true;
1223 internal_ptr->native = (PTR) lraw_src;
1226 BFD_ASSERT (indirect_ptr == (asymbol *) NULL);
1228 ecoff_data (abfd)->canonical_symbols = internal;
1233 /* Return the amount of space needed for the canonical symbols. */
1236 _bfd_ecoff_get_symtab_upper_bound (abfd)
1239 if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL,
1240 &ecoff_data (abfd)->debug_info))
1243 if (bfd_get_symcount (abfd) == 0)
1246 return (bfd_get_symcount (abfd) + 1) * (sizeof (ecoff_symbol_type *));
1249 /* Get the canonical symbols. */
1252 _bfd_ecoff_get_symtab (abfd, alocation)
1254 asymbol **alocation;
1256 unsigned int counter = 0;
1257 ecoff_symbol_type *symbase;
1258 ecoff_symbol_type **location = (ecoff_symbol_type **) alocation;
1260 if (_bfd_ecoff_slurp_symbol_table (abfd) == false)
1262 if (bfd_get_symcount (abfd) == 0)
1265 symbase = ecoff_data (abfd)->canonical_symbols;
1266 while (counter < bfd_get_symcount (abfd))
1268 *(location++) = symbase++;
1271 *location++ = (ecoff_symbol_type *) NULL;
1272 return bfd_get_symcount (abfd);
1275 /* Turn ECOFF type information into a printable string.
1276 ecoff_emit_aggregate and ecoff_type_to_string are from
1277 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1279 /* Write aggregate information to a string. */
1282 ecoff_emit_aggregate (abfd, fdr, string, rndx, isym, which)
1290 const struct ecoff_debug_swap * const debug_swap =
1291 &ecoff_backend (abfd)->debug_swap;
1292 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info;
1293 unsigned int ifd = rndx->rfd;
1294 unsigned int indx = rndx->index;
1300 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1301 struct return type of a procedure compiled without -g. */
1302 if (ifd == 0xffffffff
1303 || (rndx->rfd == 0xfff && indx == 0))
1304 name = "<undefined>";
1305 else if (indx == indexNil)
1311 if (debug_info->external_rfd == NULL)
1312 fdr = debug_info->fdr + ifd;
1317 (*debug_swap->swap_rfd_in) (abfd,
1318 ((char *) debug_info->external_rfd
1319 + ((fdr->rfdBase + ifd)
1320 * debug_swap->external_rfd_size)),
1322 fdr = debug_info->fdr + rfd;
1325 indx += fdr->isymBase;
1327 (*debug_swap->swap_sym_in) (abfd,
1328 ((char *) debug_info->external_sym
1329 + indx * debug_swap->external_sym_size),
1332 name = debug_info->ss + fdr->issBase + sym.iss;
1336 "%s %s { ifd = %u, index = %lu }",
1339 + debug_info->symbolic_header.iextMax));
1342 /* Convert the type information to string format. */
1345 ecoff_type_to_string (abfd, fdr, indx)
1350 union aux_ext *aux_ptr;
1359 unsigned int basic_type;
1362 static char buffer2[1024];
1367 aux_ptr = ecoff_data (abfd)->debug_info.external_aux + fdr->iauxBase;
1368 bigendian = fdr->fBigendian;
1370 for (i = 0; i < 7; i++)
1372 qualifiers[i].low_bound = 0;
1373 qualifiers[i].high_bound = 0;
1374 qualifiers[i].stride = 0;
1377 if (AUX_GET_ISYM (bigendian, &aux_ptr[indx]) == -1)
1378 return "-1 (no type)";
1379 _bfd_ecoff_swap_tir_in (bigendian, &aux_ptr[indx++].a_ti, &u.ti);
1381 basic_type = u.ti.bt;
1382 qualifiers[0].type = u.ti.tq0;
1383 qualifiers[1].type = u.ti.tq1;
1384 qualifiers[2].type = u.ti.tq2;
1385 qualifiers[3].type = u.ti.tq3;
1386 qualifiers[4].type = u.ti.tq4;
1387 qualifiers[5].type = u.ti.tq5;
1388 qualifiers[6].type = tqNil;
1391 * Go get the basic type.
1395 case btNil: /* undefined */
1399 case btAdr: /* address - integer same size as pointer */
1400 strcpy (p1, "address");
1403 case btChar: /* character */
1404 strcpy (p1, "char");
1407 case btUChar: /* unsigned character */
1408 strcpy (p1, "unsigned char");
1411 case btShort: /* short */
1412 strcpy (p1, "short");
1415 case btUShort: /* unsigned short */
1416 strcpy (p1, "unsigned short");
1419 case btInt: /* int */
1423 case btUInt: /* unsigned int */
1424 strcpy (p1, "unsigned int");
1427 case btLong: /* long */
1428 strcpy (p1, "long");
1431 case btULong: /* unsigned long */
1432 strcpy (p1, "unsigned long");
1435 case btFloat: /* float (real) */
1436 strcpy (p1, "float");
1439 case btDouble: /* Double (real) */
1440 strcpy (p1, "double");
1443 /* Structures add 1-2 aux words:
1444 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1445 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1447 case btStruct: /* Structure (Record) */
1448 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1449 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1450 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1452 indx++; /* skip aux words */
1455 /* Unions add 1-2 aux words:
1456 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1457 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1459 case btUnion: /* Union */
1460 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1461 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1462 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1464 indx++; /* skip aux words */
1467 /* Enumerations add 1-2 aux words:
1468 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1469 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1471 case btEnum: /* Enumeration */
1472 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1473 ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1474 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1476 indx++; /* skip aux words */
1479 case btTypedef: /* defined via a typedef, isymRef points */
1480 strcpy (p1, "typedef");
1483 case btRange: /* subrange of int */
1484 strcpy (p1, "subrange");
1487 case btSet: /* pascal sets */
1491 case btComplex: /* fortran complex */
1492 strcpy (p1, "complex");
1495 case btDComplex: /* fortran double complex */
1496 strcpy (p1, "double complex");
1499 case btIndirect: /* forward or unnamed typedef */
1500 strcpy (p1, "forward/unamed typedef");
1503 case btFixedDec: /* Fixed Decimal */
1504 strcpy (p1, "fixed decimal");
1507 case btFloatDec: /* Float Decimal */
1508 strcpy (p1, "float decimal");
1511 case btString: /* Varying Length Character String */
1512 strcpy (p1, "string");
1515 case btBit: /* Aligned Bit String */
1519 case btPicture: /* Picture */
1520 strcpy (p1, "picture");
1523 case btVoid: /* Void */
1524 strcpy (p1, "void");
1528 sprintf (p1, "Unknown basic type %d", (int) basic_type);
1532 p1 += strlen (buffer1);
1535 * If this is a bitfield, get the bitsize.
1541 bitsize = AUX_GET_WIDTH (bigendian, &aux_ptr[indx++]);
1542 sprintf (p1, " : %d", bitsize);
1543 p1 += strlen (buffer1);
1548 * Deal with any qualifiers.
1550 if (qualifiers[0].type != tqNil)
1553 * Snarf up any array bounds in the correct order. Arrays
1554 * store 5 successive words in the aux. table:
1555 * word 0 RNDXR to type of the bounds (ie, int)
1556 * word 1 Current file descriptor index
1558 * word 3 high bound (or -1 if [])
1559 * word 4 stride size in bits
1561 for (i = 0; i < 7; i++)
1563 if (qualifiers[i].type == tqArray)
1565 qualifiers[i].low_bound =
1566 AUX_GET_DNLOW (bigendian, &aux_ptr[indx+2]);
1567 qualifiers[i].high_bound =
1568 AUX_GET_DNHIGH (bigendian, &aux_ptr[indx+3]);
1569 qualifiers[i].stride =
1570 AUX_GET_WIDTH (bigendian, &aux_ptr[indx+4]);
1576 * Now print out the qualifiers.
1578 for (i = 0; i < 6; i++)
1580 switch (qualifiers[i].type)
1587 strcpy (p2, "ptr to ");
1588 p2 += sizeof ("ptr to ")-1;
1592 strcpy (p2, "volatile ");
1593 p2 += sizeof ("volatile ")-1;
1597 strcpy (p2, "far ");
1598 p2 += sizeof ("far ")-1;
1602 strcpy (p2, "func. ret. ");
1603 p2 += sizeof ("func. ret. ");
1608 int first_array = i;
1611 /* Print array bounds reversed (ie, in the order the C
1612 programmer writes them). C is such a fun language.... */
1614 while (i < 5 && qualifiers[i+1].type == tqArray)
1617 for (j = i; j >= first_array; j--)
1619 strcpy (p2, "array [");
1620 p2 += sizeof ("array [")-1;
1621 if (qualifiers[j].low_bound != 0)
1623 "%ld:%ld {%ld bits}",
1624 (long) qualifiers[j].low_bound,
1625 (long) qualifiers[j].high_bound,
1626 (long) qualifiers[j].stride);
1628 else if (qualifiers[j].high_bound != -1)
1631 (long) (qualifiers[j].high_bound + 1),
1632 (long) (qualifiers[j].stride));
1635 sprintf (p2, " {%ld bits}", (long) (qualifiers[j].stride));
1638 strcpy (p2, "] of ");
1639 p2 += sizeof ("] of ")-1;
1647 strcpy (p2, buffer1);
1651 /* Return information about ECOFF symbol SYMBOL in RET. */
1655 _bfd_ecoff_get_symbol_info (abfd, symbol, ret)
1656 bfd *abfd; /* Ignored. */
1660 bfd_symbol_info (symbol, ret);
1663 /* Print information about an ECOFF symbol. */
1666 _bfd_ecoff_print_symbol (abfd, filep, symbol, how)
1670 bfd_print_symbol_type how;
1672 const struct ecoff_debug_swap * const debug_swap
1673 = &ecoff_backend (abfd)->debug_swap;
1674 FILE *file = (FILE *)filep;
1678 case bfd_print_symbol_name:
1679 fprintf (file, "%s", symbol->name);
1681 case bfd_print_symbol_more:
1682 if (ecoffsymbol (symbol)->local)
1686 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
1688 fprintf (file, "ecoff local ");
1689 fprintf_vma (file, (bfd_vma) ecoff_sym.value);
1690 fprintf (file, " %x %x", (unsigned) ecoff_sym.st,
1691 (unsigned) ecoff_sym.sc);
1697 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
1699 fprintf (file, "ecoff extern ");
1700 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
1701 fprintf (file, " %x %x", (unsigned) ecoff_ext.asym.st,
1702 (unsigned) ecoff_ext.asym.sc);
1705 case bfd_print_symbol_all:
1706 /* Print out the symbols in a reasonable way */
1715 if (ecoffsymbol (symbol)->local)
1717 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
1720 pos = ((((char *) ecoffsymbol (symbol)->native
1721 - (char *) ecoff_data (abfd)->debug_info.external_sym)
1722 / debug_swap->external_sym_size)
1723 + ecoff_data (abfd)->debug_info.symbolic_header.iextMax);
1730 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
1733 pos = (((char *) ecoffsymbol (symbol)->native
1734 - (char *) ecoff_data (abfd)->debug_info.external_ext)
1735 / debug_swap->external_ext_size);
1736 jmptbl = ecoff_ext.jmptbl ? 'j' : ' ';
1737 cobol_main = ecoff_ext.cobol_main ? 'c' : ' ';
1738 weakext = ecoff_ext.weakext ? 'w' : ' ';
1741 fprintf (file, "[%3d] %c ",
1743 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
1744 fprintf (file, " st %x sc %x indx %x %c%c%c %s",
1745 (unsigned) ecoff_ext.asym.st,
1746 (unsigned) ecoff_ext.asym.sc,
1747 (unsigned) ecoff_ext.asym.index,
1748 jmptbl, cobol_main, weakext,
1751 if (ecoffsymbol (symbol)->fdr != NULL
1752 && ecoff_ext.asym.index != indexNil)
1757 bfd_size_type sym_base;
1758 union aux_ext *aux_base;
1760 fdr = ecoffsymbol (symbol)->fdr;
1761 indx = ecoff_ext.asym.index;
1763 /* sym_base is used to map the fdr relative indices which
1764 appear in the file to the position number which we are
1766 sym_base = fdr->isymBase;
1767 if (ecoffsymbol (symbol)->local)
1769 ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
1771 /* aux_base is the start of the aux entries for this file;
1772 asym.index is an offset from this. */
1773 aux_base = (ecoff_data (abfd)->debug_info.external_aux
1776 /* The aux entries are stored in host byte order; the
1777 order is indicated by a bit in the fdr. */
1778 bigendian = fdr->fBigendian;
1780 /* This switch is basically from gcc/mips-tdump.c */
1781 switch (ecoff_ext.asym.st)
1789 fprintf (file, "\n End+1 symbol: %ld",
1790 (long) (indx + sym_base));
1794 if (ecoff_ext.asym.sc == scText
1795 || ecoff_ext.asym.sc == scInfo)
1796 fprintf (file, "\n First symbol: %ld",
1797 (long) (indx + sym_base));
1799 fprintf (file, "\n First symbol: %ld",
1801 (AUX_GET_ISYM (bigendian,
1802 &aux_base[ecoff_ext.asym.index])
1808 if (ECOFF_IS_STAB (&ecoff_ext.asym))
1810 else if (ecoffsymbol (symbol)->local)
1811 fprintf (file, "\n End+1 symbol: %-7ld Type: %s",
1813 (AUX_GET_ISYM (bigendian,
1814 &aux_base[ecoff_ext.asym.index])
1816 ecoff_type_to_string (abfd, fdr, indx + 1));
1818 fprintf (file, "\n Local symbol: %ld",
1821 + (ecoff_data (abfd)
1822 ->debug_info.symbolic_header.iextMax)));
1826 fprintf (file, "\n struct; End+1 symbol: %ld",
1827 (long) (indx + sym_base));
1831 fprintf (file, "\n union; End+1 symbol: %ld",
1832 (long) (indx + sym_base));
1836 fprintf (file, "\n enum; End+1 symbol: %ld",
1837 (long) (indx + sym_base));
1841 if (! ECOFF_IS_STAB (&ecoff_ext.asym))
1842 fprintf (file, "\n Type: %s",
1843 ecoff_type_to_string (abfd, fdr, indx));
1852 /* Read in the relocs for a section. */
1855 ecoff_slurp_reloc_table (abfd, section, symbols)
1860 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
1861 arelent *internal_relocs;
1862 bfd_size_type external_reloc_size;
1863 bfd_size_type external_relocs_size;
1864 char *external_relocs;
1868 if (section->relocation != (arelent *) NULL
1869 || section->reloc_count == 0
1870 || (section->flags & SEC_CONSTRUCTOR) != 0)
1873 if (_bfd_ecoff_slurp_symbol_table (abfd) == false)
1876 internal_relocs = (arelent *) bfd_alloc (abfd,
1878 * section->reloc_count));
1879 external_reloc_size = backend->external_reloc_size;
1880 external_relocs_size = external_reloc_size * section->reloc_count;
1881 external_relocs = (char *) bfd_alloc (abfd, external_relocs_size);
1882 if (internal_relocs == (arelent *) NULL
1883 || external_relocs == (char *) NULL)
1885 bfd_set_error (bfd_error_no_memory);
1888 if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0)
1890 if (bfd_read (external_relocs, 1, external_relocs_size, abfd)
1891 != external_relocs_size)
1894 for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++)
1896 struct internal_reloc intern;
1898 (*backend->swap_reloc_in) (abfd,
1899 external_relocs + i * external_reloc_size,
1902 if (intern.r_extern)
1904 /* r_symndx is an index into the external symbols. */
1905 BFD_ASSERT (intern.r_symndx >= 0
1907 < (ecoff_data (abfd)
1908 ->debug_info.symbolic_header.iextMax)));
1909 rptr->sym_ptr_ptr = symbols + intern.r_symndx;
1912 else if (intern.r_symndx == RELOC_SECTION_NONE
1913 || intern.r_symndx == RELOC_SECTION_ABS)
1915 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1920 CONST char *sec_name;
1923 /* r_symndx is a section key. */
1924 switch (intern.r_symndx)
1926 case RELOC_SECTION_TEXT: sec_name = ".text"; break;
1927 case RELOC_SECTION_RDATA: sec_name = ".rdata"; break;
1928 case RELOC_SECTION_DATA: sec_name = ".data"; break;
1929 case RELOC_SECTION_SDATA: sec_name = ".sdata"; break;
1930 case RELOC_SECTION_SBSS: sec_name = ".sbss"; break;
1931 case RELOC_SECTION_BSS: sec_name = ".bss"; break;
1932 case RELOC_SECTION_INIT: sec_name = ".init"; break;
1933 case RELOC_SECTION_LIT8: sec_name = ".lit8"; break;
1934 case RELOC_SECTION_LIT4: sec_name = ".lit4"; break;
1935 case RELOC_SECTION_XDATA: sec_name = ".xdata"; break;
1936 case RELOC_SECTION_PDATA: sec_name = ".pdata"; break;
1937 case RELOC_SECTION_FINI: sec_name = ".fini"; break;
1938 case RELOC_SECTION_LITA: sec_name = ".lita"; break;
1942 sec = bfd_get_section_by_name (abfd, sec_name);
1943 if (sec == (asection *) NULL)
1945 rptr->sym_ptr_ptr = sec->symbol_ptr_ptr;
1947 rptr->addend = - bfd_get_section_vma (abfd, sec);
1950 rptr->address = intern.r_vaddr - bfd_get_section_vma (abfd, section);
1952 /* Let the backend select the howto field and do any other
1953 required processing. */
1954 (*backend->adjust_reloc_in) (abfd, &intern, rptr);
1957 bfd_release (abfd, external_relocs);
1959 section->relocation = internal_relocs;
1964 /* Get a canonical list of relocs. */
1967 _bfd_ecoff_canonicalize_reloc (abfd, section, relptr, symbols)
1975 if (section->flags & SEC_CONSTRUCTOR)
1977 arelent_chain *chain;
1979 /* This section has relocs made up by us, not the file, so take
1980 them out of their chain and place them into the data area
1982 for (count = 0, chain = section->constructor_chain;
1983 count < section->reloc_count;
1984 count++, chain = chain->next)
1985 *relptr++ = &chain->relent;
1991 if (ecoff_slurp_reloc_table (abfd, section, symbols) == false)
1994 tblptr = section->relocation;
1996 for (count = 0; count < section->reloc_count; count++)
1997 *relptr++ = tblptr++;
2000 *relptr = (arelent *) NULL;
2002 return section->reloc_count;
2005 /* Provided a BFD, a section and an offset into the section, calculate
2006 and return the name of the source file and the line nearest to the
2011 _bfd_ecoff_find_nearest_line (abfd, section, ignore_symbols, offset,
2012 filename_ptr, functionname_ptr, retline_ptr)
2015 asymbol **ignore_symbols;
2017 CONST char **filename_ptr;
2018 CONST char **functionname_ptr;
2019 unsigned int *retline_ptr;
2021 const struct ecoff_debug_swap * const debug_swap
2022 = &ecoff_backend (abfd)->debug_swap;
2023 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info;
2030 offset += section->vma;
2032 /* If we're not in the .text section, we don't have any line
2034 if (strcmp (section->name, _TEXT) != 0
2035 || offset < ecoff_data (abfd)->text_start
2036 || offset >= ecoff_data (abfd)->text_end)
2039 /* Make sure we have the FDR's. */
2040 if (! _bfd_ecoff_slurp_symbolic_info (abfd, (asection *) NULL, debug_info)
2041 || bfd_get_symcount (abfd) == 0)
2044 /* Each file descriptor (FDR) has a memory address. Here we track
2045 down which FDR we want. The FDR's are stored in increasing
2046 memory order. If speed is ever important, this can become a
2047 binary search. We must ignore FDR's with no PDR entries; they
2048 will have the adr of the FDR before or after them. */
2049 fdr_start = debug_info->fdr;
2050 fdr_end = fdr_start + debug_info->symbolic_header.ifdMax;
2051 fdr_hold = (FDR *) NULL;
2052 for (fdr_ptr = fdr_start; fdr_ptr < fdr_end; fdr_ptr++)
2054 if (fdr_ptr->cpd == 0)
2056 if (offset < fdr_ptr->adr)
2060 if (fdr_hold == (FDR *) NULL)
2064 /* Check whether this file has stabs debugging information. In a
2065 file with stabs debugging information, the second local symbol is
2068 if (fdr_ptr->csym >= 2)
2073 sym_ptr = ((char *) debug_info->external_sym
2074 + (fdr_ptr->isymBase + 1) * debug_swap->external_sym_size);
2075 (*debug_swap->swap_sym_in) (abfd, sym_ptr, &sym);
2076 if (strcmp (debug_info->ss + fdr_ptr->issBase + sym.iss,
2083 bfd_size_type external_pdr_size;
2088 unsigned char *line_ptr;
2089 unsigned char *line_end;
2092 /* This file uses ECOFF debugging information. Each FDR has a
2093 list of procedure descriptors (PDR). PDR's also have an
2094 address, which is relative to the FDR address, and are also
2095 stored in increasing memory order. */
2096 if (offset < fdr_ptr->adr)
2098 offset -= fdr_ptr->adr;
2099 external_pdr_size = debug_swap->external_pdr_size;
2100 pdr_ptr = ((char *) debug_info->external_pdr
2101 + fdr_ptr->ipdFirst * external_pdr_size);
2102 pdr_end = pdr_ptr + fdr_ptr->cpd * external_pdr_size;
2103 (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr);
2105 /* The address of the first PDR is an offset which applies to
2106 the addresses of all the PDR's. */
2107 first_off = pdr.adr;
2109 for (pdr_ptr += external_pdr_size;
2111 pdr_ptr += external_pdr_size)
2113 (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr);
2114 if (offset < pdr.adr - first_off)
2118 /* Now we can look for the actual line number. The line numbers
2119 are stored in a very funky format, which I won't try to
2120 describe. Note that right here pdr_ptr and pdr hold the PDR
2121 *after* the one we want; we need this to compute line_end. */
2122 line_end = debug_info->line;
2123 if (pdr_ptr == pdr_end)
2124 line_end += fdr_ptr->cbLineOffset + fdr_ptr->cbLine;
2126 line_end += fdr_ptr->cbLineOffset + pdr.cbLineOffset;
2128 /* Now change pdr and pdr_ptr to the one we want. */
2129 pdr_ptr -= external_pdr_size;
2130 (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr);
2132 offset -= pdr.adr - first_off;
2134 line_ptr = debug_info->line + fdr_ptr->cbLineOffset + pdr.cbLineOffset;
2135 while (line_ptr < line_end)
2140 delta = *line_ptr >> 4;
2143 count = (*line_ptr & 0xf) + 1;
2147 delta = (((line_ptr[0]) & 0xff) << 8) + ((line_ptr[1]) & 0xff);
2148 if (delta >= 0x8000)
2153 if (offset < count * 4)
2155 offset -= count * 4;
2158 /* If fdr_ptr->rss is -1, then this file does not have full
2159 symbols, at least according to gdb/mipsread.c. */
2160 if (fdr_ptr->rss == -1)
2162 *filename_ptr = NULL;
2164 *functionname_ptr = NULL;
2169 (*debug_swap->swap_ext_in)
2171 ((char *) debug_info->external_ext
2172 + pdr.isym * debug_swap->external_ext_size),
2174 *functionname_ptr = debug_info->ssext + proc_ext.asym.iss;
2181 *filename_ptr = debug_info->ss + fdr_ptr->issBase + fdr_ptr->rss;
2182 (*debug_swap->swap_sym_in)
2184 ((char *) debug_info->external_sym
2185 + (fdr_ptr->isymBase + pdr.isym) * debug_swap->external_sym_size),
2187 *functionname_ptr = debug_info->ss + fdr_ptr->issBase + proc_sym.iss;
2189 if (lineno == ilineNil)
2191 *retline_ptr = lineno;
2195 bfd_size_type external_sym_size;
2196 const char *directory_name;
2197 const char *main_file_name;
2198 const char *current_file_name;
2199 const char *function_name;
2200 const char *line_file_name;
2201 bfd_vma low_func_vma;
2202 bfd_vma low_line_vma;
2203 char *sym_ptr, *sym_ptr_end;
2204 size_t len, funclen;
2205 char *buffer = NULL;
2207 /* This file uses stabs debugging information. */
2209 *filename_ptr = NULL;
2210 *functionname_ptr = NULL;
2213 directory_name = NULL;
2214 main_file_name = NULL;
2215 current_file_name = NULL;
2216 function_name = NULL;
2217 line_file_name = NULL;
2221 external_sym_size = debug_swap->external_sym_size;
2223 sym_ptr = ((char *) debug_info->external_sym
2224 + (fdr_ptr->isymBase + 2) * external_sym_size);
2225 sym_ptr_end = sym_ptr + fdr_ptr->csym * external_sym_size;
2226 for (; sym_ptr < sym_ptr_end; sym_ptr += external_sym_size)
2230 (*debug_swap->swap_sym_in) (abfd, sym_ptr, &sym);
2232 if (ECOFF_IS_STAB (&sym))
2234 switch (ECOFF_UNMARK_STAB (sym.index))
2237 main_file_name = current_file_name =
2238 debug_info->ss + fdr_ptr->issBase + sym.iss;
2240 /* Check the next symbol to see if it is also an
2242 if (sym_ptr + external_sym_size < sym_ptr_end)
2246 (*debug_swap->swap_sym_in) (abfd,
2247 sym_ptr + external_sym_size,
2249 if (ECOFF_IS_STAB (&nextsym)
2250 && ECOFF_UNMARK_STAB (nextsym.index) == N_SO)
2252 directory_name = current_file_name;
2253 main_file_name = current_file_name =
2254 debug_info->ss + fdr_ptr->issBase + sym.iss;
2255 sym_ptr += external_sym_size;
2262 debug_info->ss + fdr_ptr->issBase + sym.iss;
2266 if (sym.value >= low_func_vma
2267 && sym.value <= offset + section->vma)
2269 low_func_vma = sym.value;
2271 debug_info->ss + fdr_ptr->issBase + sym.iss;
2276 else if (sym.st == stLabel && sym.index != indexNil)
2278 if (sym.value > offset + section->vma)
2280 /* We have passed the location in the file we are
2281 looking for, so we can get out of the loop. */
2285 if (sym.value >= low_line_vma)
2287 low_line_vma = sym.value;
2288 line_file_name = current_file_name;
2289 *retline_ptr = sym.index;
2294 if (*retline_ptr != 0)
2295 main_file_name = line_file_name;
2297 /* We need to remove the stuff after the colon in the function
2298 name. We also need to put the directory name and the file
2300 if (function_name == NULL)
2303 len = funclen = strlen (function_name) + 1;
2305 if (main_file_name != NULL
2306 && directory_name != NULL
2307 && main_file_name[0] != '/')
2308 len += strlen (directory_name) + strlen (main_file_name) + 1;
2312 if (ecoff_data (abfd)->find_buffer != NULL)
2313 free (ecoff_data (abfd)->find_buffer);
2314 buffer = (char *) malloc (len);
2317 bfd_set_error (bfd_error_no_memory);
2320 ecoff_data (abfd)->find_buffer = buffer;
2323 if (function_name != NULL)
2327 strcpy (buffer, function_name);
2328 colon = strchr (buffer, ':');
2331 *functionname_ptr = buffer;
2334 if (main_file_name != NULL)
2336 if (directory_name == NULL || main_file_name[0] == '/')
2337 *filename_ptr = main_file_name;
2340 sprintf (buffer + funclen, "%s%s", directory_name,
2342 *filename_ptr = buffer + funclen;
2350 /* Copy private BFD data. This is called by objcopy and strip. We
2351 use it to copy the ECOFF debugging information from one BFD to the
2352 other. It would be theoretically possible to represent the ECOFF
2353 debugging information in the symbol table. However, it would be a
2354 lot of work, and there would be little gain (gas, gdb, and ld
2355 already access the ECOFF debugging information via the
2356 ecoff_debug_info structure, and that structure would have to be
2357 retained in order to support ECOFF debugging in MIPS ELF).
2359 The debugging information for the ECOFF external symbols comes from
2360 the symbol table, so this function only handles the other debugging
2364 _bfd_ecoff_bfd_copy_private_bfd_data (ibfd, obfd)
2368 struct ecoff_debug_info *iinfo = &ecoff_data (ibfd)->debug_info;
2369 struct ecoff_debug_info *oinfo = &ecoff_data (obfd)->debug_info;
2371 asymbol **sym_ptr_ptr;
2375 /* This function is selected based on the input vector. We only
2376 want to copy information over if the output BFD also uses ECOFF
2378 if (bfd_get_flavour (obfd) != bfd_target_ecoff_flavour)
2381 /* Copy the GP value and the register masks. */
2382 ecoff_data (obfd)->gp = ecoff_data (ibfd)->gp;
2383 ecoff_data (obfd)->gprmask = ecoff_data (ibfd)->gprmask;
2384 ecoff_data (obfd)->fprmask = ecoff_data (ibfd)->fprmask;
2385 for (i = 0; i < 3; i++)
2386 ecoff_data (obfd)->cprmask[i] = ecoff_data (ibfd)->cprmask[i];
2388 /* Copy the version stamp. */
2389 oinfo->symbolic_header.vstamp = iinfo->symbolic_header.vstamp;
2391 /* If there are no symbols, don't copy any debugging information. */
2392 c = bfd_get_symcount (obfd);
2393 sym_ptr_ptr = bfd_get_outsymbols (obfd);
2394 if (c == 0 || sym_ptr_ptr == (asymbol **) NULL)
2397 /* See if there are any local symbols. */
2399 for (; c > 0; c--, sym_ptr_ptr++)
2401 if (ecoffsymbol (*sym_ptr_ptr)->local)
2410 /* There are some local symbols. We just bring over all the
2411 debugging information. FIXME: This is not quite the right
2412 thing to do. If the user has asked us to discard all
2413 debugging information, then we are probably going to wind up
2414 keeping it because there will probably be some local symbol
2415 which objcopy did not discard. We should actually break
2416 apart the debugging information and only keep that which
2417 applies to the symbols we want to keep. */
2418 oinfo->symbolic_header.ilineMax = iinfo->symbolic_header.ilineMax;
2419 oinfo->symbolic_header.cbLine = iinfo->symbolic_header.cbLine;
2420 oinfo->line = iinfo->line;
2422 oinfo->symbolic_header.idnMax = iinfo->symbolic_header.idnMax;
2423 oinfo->external_dnr = iinfo->external_dnr;
2425 oinfo->symbolic_header.ipdMax = iinfo->symbolic_header.ipdMax;
2426 oinfo->external_pdr = iinfo->external_pdr;
2428 oinfo->symbolic_header.isymMax = iinfo->symbolic_header.isymMax;
2429 oinfo->external_sym = iinfo->external_sym;
2431 oinfo->symbolic_header.ioptMax = iinfo->symbolic_header.ioptMax;
2432 oinfo->external_opt = iinfo->external_opt;
2434 oinfo->symbolic_header.iauxMax = iinfo->symbolic_header.iauxMax;
2435 oinfo->external_aux = iinfo->external_aux;
2437 oinfo->symbolic_header.issMax = iinfo->symbolic_header.issMax;
2438 oinfo->ss = iinfo->ss;
2440 oinfo->symbolic_header.ifdMax = iinfo->symbolic_header.ifdMax;
2441 oinfo->external_fdr = iinfo->external_fdr;
2443 oinfo->symbolic_header.crfd = iinfo->symbolic_header.crfd;
2444 oinfo->external_rfd = iinfo->external_rfd;
2448 /* We are discarding all the local symbol information. Look
2449 through the external symbols and remove all references to FDR
2450 or aux information. */
2451 c = bfd_get_symcount (obfd);
2452 sym_ptr_ptr = bfd_get_outsymbols (obfd);
2453 for (; c > 0; c--, sym_ptr_ptr++)
2457 (*(ecoff_backend (obfd)->debug_swap.swap_ext_in))
2458 (obfd, ecoffsymbol (*sym_ptr_ptr)->native, &esym);
2460 esym.asym.index = indexNil;
2461 (*(ecoff_backend (obfd)->debug_swap.swap_ext_out))
2462 (obfd, &esym, ecoffsymbol (*sym_ptr_ptr)->native);
2469 /* Set the architecture. The supported architecture is stored in the
2470 backend pointer. We always set the architecture anyhow, since many
2471 callers ignore the return value. */
2474 _bfd_ecoff_set_arch_mach (abfd, arch, machine)
2476 enum bfd_architecture arch;
2477 unsigned long machine;
2479 bfd_default_set_arch_mach (abfd, arch, machine);
2480 return arch == ecoff_backend (abfd)->arch;
2483 /* Get the size of the section headers. */
2487 _bfd_ecoff_sizeof_headers (abfd, reloc)
2496 for (current = abfd->sections;
2497 current != (asection *)NULL;
2498 current = current->next)
2501 ret = (bfd_coff_filhsz (abfd)
2502 + bfd_coff_aoutsz (abfd)
2503 + c * bfd_coff_scnhsz (abfd));
2504 return BFD_ALIGN (ret, 16);
2507 /* Get the contents of a section. */
2510 _bfd_ecoff_get_section_contents (abfd, section, location, offset, count)
2515 bfd_size_type count;
2517 return _bfd_generic_get_section_contents (abfd, section, location,
2521 /* Calculate the file position for each section, and set
2525 ecoff_compute_section_file_positions (abfd)
2533 sofar = _bfd_ecoff_sizeof_headers (abfd, false);
2536 for (current = abfd->sections;
2537 current != (asection *) NULL;
2538 current = current->next)
2540 unsigned int alignment_power;
2542 /* Only deal with sections which have contents */
2543 if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) == 0)
2546 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2547 supposed to indicate the number of .pdata entries that are
2548 really in the section. Each entry is 8 bytes. We store this
2549 away in line_filepos before increasing the section size. */
2550 if (strcmp (current->name, _PDATA) != 0)
2551 alignment_power = current->alignment_power;
2554 current->line_filepos = current->_raw_size / 8;
2555 alignment_power = 4;
2558 /* On Ultrix, the data sections in an executable file must be
2559 aligned to a page boundary within the file. This does not
2560 affect the section size, though. FIXME: Does this work for
2561 other platforms? It requires some modification for the
2562 Alpha, because .rdata on the Alpha goes with the text, not
2564 if ((abfd->flags & EXEC_P) != 0
2565 && (abfd->flags & D_PAGED) != 0
2566 && first_data != false
2567 && (current->flags & SEC_CODE) == 0
2568 && (! ecoff_backend (abfd)->rdata_in_text
2569 || strcmp (current->name, _RDATA) != 0)
2570 && strcmp (current->name, _PDATA) != 0)
2572 const bfd_vma round = ecoff_backend (abfd)->round;
2574 sofar = (sofar + round - 1) &~ (round - 1);
2577 else if (strcmp (current->name, _LIB) == 0)
2579 const bfd_vma round = ecoff_backend (abfd)->round;
2580 /* On Irix 4, the location of contents of the .lib section
2581 from a shared library section is also rounded up to a
2584 sofar = (sofar + round - 1) &~ (round - 1);
2587 /* Align the sections in the file to the same boundary on
2588 which they are aligned in virtual memory. */
2590 sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2592 current->filepos = sofar;
2594 sofar += current->_raw_size;
2596 /* make sure that this section is of the right size too */
2598 sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2599 current->_raw_size += sofar - old_sofar;
2602 ecoff_data (abfd)->reloc_filepos = sofar;
2605 /* Determine the location of the relocs for all the sections in the
2606 output file, as well as the location of the symbolic debugging
2609 static bfd_size_type
2610 ecoff_compute_reloc_file_positions (abfd)
2613 const bfd_size_type external_reloc_size =
2614 ecoff_backend (abfd)->external_reloc_size;
2615 file_ptr reloc_base;
2616 bfd_size_type reloc_size;
2620 if (! abfd->output_has_begun)
2622 ecoff_compute_section_file_positions (abfd);
2623 abfd->output_has_begun = true;
2626 reloc_base = ecoff_data (abfd)->reloc_filepos;
2629 for (current = abfd->sections;
2630 current != (asection *)NULL;
2631 current = current->next)
2633 if (current->reloc_count == 0)
2634 current->rel_filepos = 0;
2637 bfd_size_type relsize;
2639 current->rel_filepos = reloc_base;
2640 relsize = current->reloc_count * external_reloc_size;
2641 reloc_size += relsize;
2642 reloc_base += relsize;
2646 sym_base = ecoff_data (abfd)->reloc_filepos + reloc_size;
2648 /* At least on Ultrix, the symbol table of an executable file must
2649 be aligned to a page boundary. FIXME: Is this true on other
2651 if ((abfd->flags & EXEC_P) != 0
2652 && (abfd->flags & D_PAGED) != 0)
2653 sym_base = ((sym_base + ecoff_backend (abfd)->round - 1)
2654 &~ (ecoff_backend (abfd)->round - 1));
2656 ecoff_data (abfd)->sym_filepos = sym_base;
2661 /* Set the contents of a section. */
2664 _bfd_ecoff_set_section_contents (abfd, section, location, offset, count)
2669 bfd_size_type count;
2671 /* This must be done first, because bfd_set_section_contents is
2672 going to set output_has_begun to true. */
2673 if (abfd->output_has_begun == false)
2674 ecoff_compute_section_file_positions (abfd);
2676 /* If this is a .lib section, bump the vma address so that it winds
2677 up being the number of .lib sections output. This is right for
2678 Irix 4. Ian Taylor <ian@cygnus.com>. */
2679 if (strcmp (section->name, _LIB) == 0)
2685 if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
2686 || bfd_write (location, 1, count, abfd) != count)
2692 /* Get the GP value for an ECOFF file. This is a hook used by
2696 bfd_ecoff_get_gp_value (abfd)
2699 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2700 || bfd_get_format (abfd) != bfd_object)
2702 bfd_set_error (bfd_error_invalid_operation);
2706 return ecoff_data (abfd)->gp;
2709 /* Set the GP value for an ECOFF file. This is a hook used by the
2713 bfd_ecoff_set_gp_value (abfd, gp_value)
2717 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2718 || bfd_get_format (abfd) != bfd_object)
2720 bfd_set_error (bfd_error_invalid_operation);
2724 ecoff_data (abfd)->gp = gp_value;
2729 /* Set the register masks for an ECOFF file. This is a hook used by
2733 bfd_ecoff_set_regmasks (abfd, gprmask, fprmask, cprmask)
2735 unsigned long gprmask;
2736 unsigned long fprmask;
2737 unsigned long *cprmask;
2739 ecoff_data_type *tdata;
2741 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2742 || bfd_get_format (abfd) != bfd_object)
2744 bfd_set_error (bfd_error_invalid_operation);
2748 tdata = ecoff_data (abfd);
2749 tdata->gprmask = gprmask;
2750 tdata->fprmask = fprmask;
2751 if (cprmask != (unsigned long *) NULL)
2755 for (i = 0; i < 3; i++)
2756 tdata->cprmask[i] = cprmask[i];
2762 /* Get ECOFF EXTR information for an external symbol. This function
2763 is passed to bfd_ecoff_debug_externals. */
2766 ecoff_get_extr (sym, esym)
2770 ecoff_symbol_type *ecoff_sym_ptr;
2773 if (bfd_asymbol_flavour (sym) != bfd_target_ecoff_flavour
2774 || ecoffsymbol (sym)->native == NULL)
2776 /* Don't include debugging, local, or section symbols. */
2777 if ((sym->flags & BSF_DEBUGGING) != 0
2778 || (sym->flags & BSF_LOCAL) != 0
2779 || (sym->flags & BSF_SECTION_SYM) != 0)
2783 esym->cobol_main = 0;
2787 /* FIXME: we can do better than this for st and sc. */
2788 esym->asym.st = stGlobal;
2789 esym->asym.sc = scAbs;
2790 esym->asym.reserved = 0;
2791 esym->asym.index = indexNil;
2795 ecoff_sym_ptr = ecoffsymbol (sym);
2797 if (ecoff_sym_ptr->local)
2800 input_bfd = bfd_asymbol_bfd (sym);
2801 (*(ecoff_backend (input_bfd)->debug_swap.swap_ext_in))
2802 (input_bfd, ecoff_sym_ptr->native, esym);
2804 /* If the symbol was defined by the linker, then esym will be
2805 undefined but sym will not be. Get a better class for such a
2807 if ((esym->asym.sc == scUndefined
2808 || esym->asym.sc == scSUndefined)
2809 && ! bfd_is_und_section (bfd_get_section (sym)))
2810 esym->asym.sc = scAbs;
2812 /* Adjust the FDR index for the symbol by that used for the input
2814 if (esym->ifd != -1)
2816 struct ecoff_debug_info *input_debug;
2818 input_debug = &ecoff_data (input_bfd)->debug_info;
2819 BFD_ASSERT (esym->ifd < input_debug->symbolic_header.ifdMax);
2820 if (input_debug->ifdmap != (RFDT *) NULL)
2821 esym->ifd = input_debug->ifdmap[esym->ifd];
2827 /* Set the external symbol index. This routine is passed to
2828 bfd_ecoff_debug_externals. */
2831 ecoff_set_index (sym, indx)
2835 ecoff_set_sym_index (sym, indx);
2838 /* Write out an ECOFF file. */
2841 _bfd_ecoff_write_object_contents (abfd)
2844 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
2845 const bfd_vma round = backend->round;
2846 const bfd_size_type filhsz = bfd_coff_filhsz (abfd);
2847 const bfd_size_type aoutsz = bfd_coff_aoutsz (abfd);
2848 const bfd_size_type scnhsz = bfd_coff_scnhsz (abfd);
2849 const bfd_size_type external_hdr_size
2850 = backend->debug_swap.external_hdr_size;
2851 const bfd_size_type external_reloc_size = backend->external_reloc_size;
2852 void (* const adjust_reloc_out) PARAMS ((bfd *,
2854 struct internal_reloc *))
2855 = backend->adjust_reloc_out;
2856 void (* const swap_reloc_out) PARAMS ((bfd *,
2857 const struct internal_reloc *,
2859 = backend->swap_reloc_out;
2860 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
2861 HDRR * const symhdr = &debug->symbolic_header;
2864 bfd_size_type reloc_size;
2865 bfd_size_type text_size;
2867 boolean set_text_start;
2868 bfd_size_type data_size;
2870 boolean set_data_start;
2871 bfd_size_type bss_size;
2873 PTR reloc_buff = NULL;
2874 struct internal_filehdr internal_f;
2875 struct internal_aouthdr internal_a;
2878 /* Determine where the sections and relocs will go in the output
2880 reloc_size = ecoff_compute_reloc_file_positions (abfd);
2883 for (current = abfd->sections;
2884 current != (asection *)NULL;
2885 current = current->next)
2887 current->target_index = count;
2891 if ((abfd->flags & D_PAGED) != 0)
2892 text_size = _bfd_ecoff_sizeof_headers (abfd, false);
2896 set_text_start = false;
2899 set_data_start = false;
2902 /* Write section headers to the file. */
2904 /* Allocate buff big enough to hold a section header,
2905 file header, or a.out header. */
2913 buff = (PTR) malloc (siz);
2916 bfd_set_error (bfd_error_no_memory);
2921 internal_f.f_nscns = 0;
2922 if (bfd_seek (abfd, (file_ptr) (filhsz + aoutsz), SEEK_SET) != 0)
2924 for (current = abfd->sections;
2925 current != (asection *) NULL;
2926 current = current->next)
2928 struct internal_scnhdr section;
2931 ++internal_f.f_nscns;
2933 strncpy (section.s_name, current->name, sizeof section.s_name);
2935 /* This seems to be correct for Irix 4 shared libraries. */
2936 vma = bfd_get_section_vma (abfd, current);
2937 if (strcmp (current->name, _LIB) == 0)
2938 section.s_vaddr = 0;
2940 section.s_vaddr = vma;
2942 section.s_paddr = vma;
2943 section.s_size = bfd_get_section_size_before_reloc (current);
2945 /* If this section is unloadable then the scnptr will be 0. */
2946 if ((current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2947 section.s_scnptr = 0;
2949 section.s_scnptr = current->filepos;
2950 section.s_relptr = current->rel_filepos;
2952 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2953 object file produced by the assembler is supposed to point to
2954 information about how much room is required by objects of
2955 various different sizes. I think this only matters if we
2956 want the linker to compute the best size to use, or
2957 something. I don't know what happens if the information is
2959 if (strcmp (current->name, _PDATA) != 0)
2960 section.s_lnnoptr = 0;
2963 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2964 hold the number of entries in the section (each entry is
2965 8 bytes). We stored this in the line_filepos field in
2966 ecoff_compute_section_file_positions. */
2967 section.s_lnnoptr = current->line_filepos;
2970 section.s_nreloc = current->reloc_count;
2971 section.s_nlnno = 0;
2972 section.s_flags = ecoff_sec_to_styp_flags (current->name,
2975 bfd_coff_swap_scnhdr_out (abfd, (PTR) §ion, buff);
2976 if (bfd_write (buff, 1, scnhsz, abfd) != scnhsz)
2979 if ((section.s_flags & STYP_TEXT) != 0
2980 || ((section.s_flags & STYP_RDATA) != 0
2981 && backend->rdata_in_text)
2982 || strcmp (current->name, _PDATA) == 0)
2984 text_size += bfd_get_section_size_before_reloc (current);
2985 if (! set_text_start || text_start > vma)
2988 set_text_start = true;
2991 else if ((section.s_flags & STYP_RDATA) != 0
2992 || (section.s_flags & STYP_DATA) != 0
2993 || (section.s_flags & STYP_LITA) != 0
2994 || (section.s_flags & STYP_LIT8) != 0
2995 || (section.s_flags & STYP_LIT4) != 0
2996 || (section.s_flags & STYP_SDATA) != 0
2997 || strcmp (current->name, _XDATA) == 0)
2999 data_size += bfd_get_section_size_before_reloc (current);
3000 if (! set_data_start || data_start > vma)
3003 set_data_start = true;
3006 else if ((section.s_flags & STYP_BSS) != 0
3007 || (section.s_flags & STYP_SBSS) != 0)
3008 bss_size += bfd_get_section_size_before_reloc (current);
3009 else if ((section.s_flags & STYP_ECOFF_LIB) != 0)
3015 /* Set up the file header. */
3017 internal_f.f_magic = ecoff_get_magic (abfd);
3019 /* We will NOT put a fucking timestamp in the header here. Every
3020 time you put it back, I will come in and take it out again. I'm
3021 sorry. This field does not belong here. We fill it with a 0 so
3022 it compares the same but is not a reasonable time. --
3024 internal_f.f_timdat = 0;
3026 if (bfd_get_symcount (abfd) != 0)
3028 /* The ECOFF f_nsyms field is not actually the number of
3029 symbols, it's the size of symbolic information header. */
3030 internal_f.f_nsyms = external_hdr_size;
3031 internal_f.f_symptr = ecoff_data (abfd)->sym_filepos;
3035 internal_f.f_nsyms = 0;
3036 internal_f.f_symptr = 0;
3039 internal_f.f_opthdr = aoutsz;
3041 internal_f.f_flags = F_LNNO;
3042 if (reloc_size == 0)
3043 internal_f.f_flags |= F_RELFLG;
3044 if (bfd_get_symcount (abfd) == 0)
3045 internal_f.f_flags |= F_LSYMS;
3046 if (abfd->flags & EXEC_P)
3047 internal_f.f_flags |= F_EXEC;
3049 if (! abfd->xvec->byteorder_big_p)
3050 internal_f.f_flags |= F_AR32WR;
3052 internal_f.f_flags |= F_AR32W;
3054 /* Set up the ``optional'' header. */
3055 if ((abfd->flags & D_PAGED) != 0)
3056 internal_a.magic = ECOFF_AOUT_ZMAGIC;
3058 internal_a.magic = ECOFF_AOUT_OMAGIC;
3060 /* FIXME: Is this really correct? */
3061 internal_a.vstamp = symhdr->vstamp;
3063 /* At least on Ultrix, these have to be rounded to page boundaries.
3064 FIXME: Is this true on other platforms? */
3065 if ((abfd->flags & D_PAGED) != 0)
3067 internal_a.tsize = (text_size + round - 1) &~ (round - 1);
3068 internal_a.text_start = text_start &~ (round - 1);
3069 internal_a.dsize = (data_size + round - 1) &~ (round - 1);
3070 internal_a.data_start = data_start &~ (round - 1);
3074 internal_a.tsize = text_size;
3075 internal_a.text_start = text_start;
3076 internal_a.dsize = data_size;
3077 internal_a.data_start = data_start;
3080 /* On Ultrix, the initial portions of the .sbss and .bss segments
3081 are at the end of the data section. The bsize field in the
3082 optional header records how many bss bytes are required beyond
3083 those in the data section. The value is not rounded to a page
3085 if (bss_size < internal_a.dsize - data_size)
3088 bss_size -= internal_a.dsize - data_size;
3089 internal_a.bsize = bss_size;
3090 internal_a.bss_start = internal_a.data_start + internal_a.dsize;
3092 internal_a.entry = bfd_get_start_address (abfd);
3094 internal_a.gp_value = ecoff_data (abfd)->gp;
3096 internal_a.gprmask = ecoff_data (abfd)->gprmask;
3097 internal_a.fprmask = ecoff_data (abfd)->fprmask;
3098 for (i = 0; i < 4; i++)
3099 internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i];
3101 /* Write out the file header and the optional header. */
3103 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3106 bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, buff);
3107 if (bfd_write (buff, 1, filhsz, abfd) != filhsz)
3110 bfd_coff_swap_aouthdr_out (abfd, (PTR) &internal_a, buff);
3111 if (bfd_write (buff, 1, aoutsz, abfd) != aoutsz)
3114 /* Build the external symbol information. This must be done before
3115 writing out the relocs so that we know the symbol indices. We
3116 don't do this if this BFD was created by the backend linker,
3117 since it will have already handled the symbols and relocs. */
3118 if (! ecoff_data (abfd)->linker)
3120 symhdr->iextMax = 0;
3121 symhdr->issExtMax = 0;
3122 debug->external_ext = debug->external_ext_end = NULL;
3123 debug->ssext = debug->ssext_end = NULL;
3124 if (bfd_ecoff_debug_externals (abfd, debug, &backend->debug_swap,
3125 (((abfd->flags & EXEC_P) == 0)
3127 ecoff_get_extr, ecoff_set_index)
3131 /* Write out the relocs. */
3132 for (current = abfd->sections;
3133 current != (asection *) NULL;
3134 current = current->next)
3136 arelent **reloc_ptr_ptr;
3137 arelent **reloc_end;
3140 if (current->reloc_count == 0)
3144 bfd_alloc (abfd, current->reloc_count * external_reloc_size);
3145 if (reloc_buff == NULL)
3147 bfd_set_error (bfd_error_no_memory);
3151 reloc_ptr_ptr = current->orelocation;
3152 reloc_end = reloc_ptr_ptr + current->reloc_count;
3153 out_ptr = (char *) reloc_buff;
3155 reloc_ptr_ptr < reloc_end;
3156 reloc_ptr_ptr++, out_ptr += external_reloc_size)
3160 struct internal_reloc in;
3162 memset ((PTR) &in, 0, sizeof in);
3164 reloc = *reloc_ptr_ptr;
3165 sym = *reloc->sym_ptr_ptr;
3167 in.r_vaddr = (reloc->address
3168 + bfd_get_section_vma (abfd, current));
3169 in.r_type = reloc->howto->type;
3171 if ((sym->flags & BSF_SECTION_SYM) == 0)
3173 in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr);
3180 name = bfd_get_section_name (abfd, bfd_get_section (sym));
3181 if (strcmp (name, ".text") == 0)
3182 in.r_symndx = RELOC_SECTION_TEXT;
3183 else if (strcmp (name, ".rdata") == 0)
3184 in.r_symndx = RELOC_SECTION_RDATA;
3185 else if (strcmp (name, ".data") == 0)
3186 in.r_symndx = RELOC_SECTION_DATA;
3187 else if (strcmp (name, ".sdata") == 0)
3188 in.r_symndx = RELOC_SECTION_SDATA;
3189 else if (strcmp (name, ".sbss") == 0)
3190 in.r_symndx = RELOC_SECTION_SBSS;
3191 else if (strcmp (name, ".bss") == 0)
3192 in.r_symndx = RELOC_SECTION_BSS;
3193 else if (strcmp (name, ".init") == 0)
3194 in.r_symndx = RELOC_SECTION_INIT;
3195 else if (strcmp (name, ".lit8") == 0)
3196 in.r_symndx = RELOC_SECTION_LIT8;
3197 else if (strcmp (name, ".lit4") == 0)
3198 in.r_symndx = RELOC_SECTION_LIT4;
3199 else if (strcmp (name, ".xdata") == 0)
3200 in.r_symndx = RELOC_SECTION_XDATA;
3201 else if (strcmp (name, ".pdata") == 0)
3202 in.r_symndx = RELOC_SECTION_PDATA;
3203 else if (strcmp (name, ".fini") == 0)
3204 in.r_symndx = RELOC_SECTION_FINI;
3205 else if (strcmp (name, ".lita") == 0)
3206 in.r_symndx = RELOC_SECTION_LITA;
3207 else if (strcmp (name, "*ABS*") == 0)
3208 in.r_symndx = RELOC_SECTION_ABS;
3214 (*adjust_reloc_out) (abfd, reloc, &in);
3216 (*swap_reloc_out) (abfd, &in, (PTR) out_ptr);
3219 if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0)
3221 if (bfd_write (reloc_buff,
3222 external_reloc_size, current->reloc_count, abfd)
3223 != external_reloc_size * current->reloc_count)
3225 bfd_release (abfd, reloc_buff);
3229 /* Write out the symbolic debugging information. */
3230 if (bfd_get_symcount (abfd) > 0)
3232 /* Write out the debugging information. */
3233 if (bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap,
3234 ecoff_data (abfd)->sym_filepos)
3240 /* The .bss section of a demand paged executable must receive an
3241 entire page. If there are symbols, the symbols will start on the
3242 next page. If there are no symbols, we must fill out the page by
3244 if (bfd_get_symcount (abfd) == 0
3245 && (abfd->flags & EXEC_P) != 0
3246 && (abfd->flags & D_PAGED) != 0)
3250 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
3253 if (bfd_read (&c, 1, 1, abfd) == 0)
3255 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
3258 if (bfd_write (&c, 1, 1, abfd) != 1)
3262 if (reloc_buff != NULL)
3263 bfd_release (abfd, reloc_buff);
3268 if (reloc_buff != NULL)
3269 bfd_release (abfd, reloc_buff);
3275 /* Archive handling. ECOFF uses what appears to be a unique type of
3276 archive header (armap). The byte ordering of the armap and the
3277 contents are encoded in the name of the armap itself. At least for
3278 now, we only support archives with the same byte ordering in the
3279 armap and the contents.
3281 The first four bytes in the armap are the number of symbol
3282 definitions. This is always a power of two.
3284 This is followed by the symbol definitions. Each symbol definition
3285 occupies 8 bytes. The first four bytes are the offset from the
3286 start of the armap strings to the null-terminated string naming
3287 this symbol. The second four bytes are the file offset to the
3288 archive member which defines this symbol. If the second four bytes
3289 are 0, then this is not actually a symbol definition, and it should
3292 The symbols are hashed into the armap with a closed hashing scheme.
3293 See the functions below for the details of the algorithm.
3295 After the symbol definitions comes four bytes holding the size of
3296 the string table, followed by the string table itself. */
3298 /* The name of an archive headers looks like this:
3299 __________E[BL]E[BL]_ (with a trailing space).
3300 The trailing space is changed to an X if the archive is changed to
3301 indicate that the armap is out of date.
3303 The Alpha seems to use ________64E[BL]E[BL]_. */
3305 #define ARMAP_BIG_ENDIAN 'B'
3306 #define ARMAP_LITTLE_ENDIAN 'L'
3307 #define ARMAP_MARKER 'E'
3308 #define ARMAP_START_LENGTH 10
3309 #define ARMAP_HEADER_MARKER_INDEX 10
3310 #define ARMAP_HEADER_ENDIAN_INDEX 11
3311 #define ARMAP_OBJECT_MARKER_INDEX 12
3312 #define ARMAP_OBJECT_ENDIAN_INDEX 13
3313 #define ARMAP_END_INDEX 14
3314 #define ARMAP_END "_ "
3316 /* This is a magic number used in the hashing algorithm. */
3317 #define ARMAP_HASH_MAGIC 0x9dd68ab5
3319 /* This returns the hash value to use for a string. It also sets
3320 *REHASH to the rehash adjustment if the first slot is taken. SIZE
3321 is the number of entries in the hash table, and HLOG is the log
3325 ecoff_armap_hash (s, rehash, size, hlog)
3327 unsigned int *rehash;
3335 hash = ((hash >> 27) | (hash << 5)) + *s++;
3336 hash *= ARMAP_HASH_MAGIC;
3337 *rehash = (hash & (size - 1)) | 1;
3338 return hash >> (32 - hlog);
3341 /* Read in the armap. */
3344 _bfd_ecoff_slurp_armap (abfd)
3349 struct areltdata *mapdata;
3350 bfd_size_type parsed_size;
3352 struct artdata *ardata;
3355 struct symdef *symdef_ptr;
3358 /* Get the name of the first element. */
3359 i = bfd_read ((PTR) nextname, 1, 16, abfd);
3365 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
3368 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
3369 standard COFF armap. We could move the ECOFF armap stuff into
3370 bfd_slurp_armap, but that seems inappropriate since no other
3371 target uses this format. Instead, we check directly for a COFF
3373 if (strncmp (nextname, "/ ", 16) == 0)
3374 return bfd_slurp_armap (abfd);
3376 /* See if the first element is an armap. */
3377 if (strncmp (nextname, ecoff_backend (abfd)->armap_start,
3378 ARMAP_START_LENGTH) != 0
3379 || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER
3380 || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
3381 && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
3382 || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER
3383 || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
3384 && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
3385 || strncmp (nextname + ARMAP_END_INDEX,
3386 ARMAP_END, sizeof ARMAP_END - 1) != 0)
3388 bfd_has_map (abfd) = false;
3392 /* Make sure we have the right byte ordering. */
3393 if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
3394 ^ (abfd->xvec->header_byteorder_big_p != false))
3395 || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
3396 ^ (abfd->xvec->byteorder_big_p != false)))
3398 bfd_set_error (bfd_error_wrong_format);
3402 /* Read in the armap. */
3403 ardata = bfd_ardata (abfd);
3404 mapdata = _bfd_snarf_ar_hdr (abfd);
3405 if (mapdata == (struct areltdata *) NULL)
3407 parsed_size = mapdata->parsed_size;
3408 bfd_release (abfd, (PTR) mapdata);
3410 raw_armap = (char *) bfd_alloc (abfd, parsed_size);
3411 if (raw_armap == (char *) NULL)
3413 bfd_set_error (bfd_error_no_memory);
3417 if (bfd_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size)
3419 if (bfd_get_error () != bfd_error_system_call)
3420 bfd_set_error (bfd_error_malformed_archive);
3421 bfd_release (abfd, (PTR) raw_armap);
3425 ardata->tdata = (PTR) raw_armap;
3427 count = bfd_h_get_32 (abfd, (PTR) raw_armap);
3429 ardata->symdef_count = 0;
3430 ardata->cache = (struct ar_cache *) NULL;
3432 /* This code used to overlay the symdefs over the raw archive data,
3433 but that doesn't work on a 64 bit host. */
3435 stringbase = raw_armap + count * 8 + 8;
3437 #ifdef CHECK_ARMAP_HASH
3441 /* Double check that I have the hashing algorithm right by making
3442 sure that every symbol can be looked up successfully. */
3444 for (i = 1; i < count; i <<= 1)
3446 BFD_ASSERT (i == count);
3448 raw_ptr = raw_armap + 4;
3449 for (i = 0; i < count; i++, raw_ptr += 8)
3451 unsigned int name_offset, file_offset;
3452 unsigned int hash, rehash, srch;
3454 name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
3455 file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4));
3456 if (file_offset == 0)
3458 hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count,
3463 /* See if we can rehash to this location. */
3464 for (srch = (hash + rehash) & (count - 1);
3465 srch != hash && srch != i;
3466 srch = (srch + rehash) & (count - 1))
3467 BFD_ASSERT (bfd_h_get_32 (abfd, (PTR) (raw_armap + 8 + srch * 8))
3469 BFD_ASSERT (srch == i);
3473 #endif /* CHECK_ARMAP_HASH */
3475 raw_ptr = raw_armap + 4;
3476 for (i = 0; i < count; i++, raw_ptr += 8)
3477 if (bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4)) != 0)
3478 ++ardata->symdef_count;
3480 symdef_ptr = ((struct symdef *)
3482 ardata->symdef_count * sizeof (struct symdef)));
3485 bfd_set_error (bfd_error_no_memory);
3489 ardata->symdefs = (carsym *) symdef_ptr;
3491 raw_ptr = raw_armap + 4;
3492 for (i = 0; i < count; i++, raw_ptr += 8)
3494 unsigned int name_offset, file_offset;
3496 file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4));
3497 if (file_offset == 0)
3499 name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
3500 symdef_ptr->s.name = stringbase + name_offset;
3501 symdef_ptr->file_offset = file_offset;
3505 ardata->first_file_filepos = bfd_tell (abfd);
3506 /* Pad to an even boundary. */
3507 ardata->first_file_filepos += ardata->first_file_filepos % 2;
3509 bfd_has_map (abfd) = true;
3514 /* Write out an armap. */
3517 _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx)
3519 unsigned int elength;
3521 unsigned int orl_count;
3524 unsigned int hashsize, hashlog;
3525 unsigned int symdefsize;
3527 unsigned int stringsize;
3528 unsigned int mapsize;
3531 struct stat statbuf;
3534 bfd_byte *hashtable;
3538 /* Ultrix appears to use as a hash table size the least power of two
3539 greater than twice the number of entries. */
3540 for (hashlog = 0; (1 << hashlog) <= 2 * orl_count; hashlog++)
3542 hashsize = 1 << hashlog;
3544 symdefsize = hashsize * 8;
3546 stringsize = stridx + padit;
3548 /* Include 8 bytes to store symdefsize and stringsize in output. */
3549 mapsize = symdefsize + stringsize + 8;
3551 firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength;
3553 memset ((PTR) &hdr, 0, sizeof hdr);
3555 /* Work out the ECOFF armap name. */
3556 strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start);
3557 hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER;
3558 hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] =
3559 (abfd->xvec->header_byteorder_big_p
3561 : ARMAP_LITTLE_ENDIAN);
3562 hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER;
3563 hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] =
3564 abfd->xvec->byteorder_big_p ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN;
3565 memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1);
3567 /* Write the timestamp of the archive header to be just a little bit
3568 later than the timestamp of the file, otherwise the linker will
3569 complain that the index is out of date. Actually, the Ultrix
3570 linker just checks the archive name; the GNU linker may check the
3572 stat (abfd->filename, &statbuf);
3573 sprintf (hdr.ar_date, "%ld", (long) (statbuf.st_mtime + 60));
3575 /* The DECstation uses zeroes for the uid, gid and mode of the
3577 hdr.ar_uid[0] = '0';
3578 hdr.ar_gid[0] = '0';
3579 hdr.ar_mode[0] = '0';
3581 sprintf (hdr.ar_size, "%-10d", (int) mapsize);
3583 hdr.ar_fmag[0] = '`';
3584 hdr.ar_fmag[1] = '\012';
3586 /* Turn all null bytes in the header into spaces. */
3587 for (i = 0; i < sizeof (struct ar_hdr); i++)
3588 if (((char *)(&hdr))[i] == '\0')
3589 (((char *)(&hdr))[i]) = ' ';
3591 if (bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), abfd)
3592 != sizeof (struct ar_hdr))
3595 bfd_h_put_32 (abfd, (bfd_vma) hashsize, temp);
3596 if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
3599 hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize);
3602 bfd_set_error (bfd_error_no_memory);
3606 current = abfd->archive_head;
3608 for (i = 0; i < orl_count; i++)
3610 unsigned int hash, rehash;
3612 /* Advance firstreal to the file position of this archive
3614 if (((bfd *) map[i].pos) != last_elt)
3618 firstreal += arelt_size (current) + sizeof (struct ar_hdr);
3619 firstreal += firstreal % 2;
3620 current = current->next;
3622 while (current != (bfd *) map[i].pos);
3627 hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog);
3628 if (bfd_h_get_32 (abfd, (PTR) (hashtable + (hash * 8) + 4)) != 0)
3632 /* The desired slot is already taken. */
3633 for (srch = (hash + rehash) & (hashsize - 1);
3635 srch = (srch + rehash) & (hashsize - 1))
3636 if (bfd_h_get_32 (abfd, (PTR) (hashtable + (srch * 8) + 4)) == 0)
3639 BFD_ASSERT (srch != hash);
3644 bfd_h_put_32 (abfd, (bfd_vma) map[i].namidx,
3645 (PTR) (hashtable + hash * 8));
3646 bfd_h_put_32 (abfd, (bfd_vma) firstreal,
3647 (PTR) (hashtable + hash * 8 + 4));
3650 if (bfd_write ((PTR) hashtable, 1, symdefsize, abfd) != symdefsize)
3653 bfd_release (abfd, hashtable);
3655 /* Now write the strings. */
3656 bfd_h_put_32 (abfd, (bfd_vma) stringsize, temp);
3657 if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
3659 for (i = 0; i < orl_count; i++)
3663 len = strlen (*map[i].name) + 1;
3664 if (bfd_write ((PTR) (*map[i].name), 1, len, abfd) != len)
3668 /* The spec sez this should be a newline. But in order to be
3669 bug-compatible for DECstation ar we use a null. */
3672 if (bfd_write ("", 1, 1, abfd) != 1)
3679 /* See whether this BFD is an archive. If it is, read in the armap
3680 and the extended name table. */
3683 _bfd_ecoff_archive_p (abfd)
3686 char armag[SARMAG + 1];
3688 if (bfd_read ((PTR) armag, 1, SARMAG, abfd) != SARMAG
3689 || strncmp (armag, ARMAG, SARMAG) != 0)
3691 if (bfd_get_error () != bfd_error_system_call)
3692 bfd_set_error (bfd_error_wrong_format);
3693 return (const bfd_target *) NULL;
3696 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
3697 involves a cast, we can't do it as the left operand of
3699 abfd->tdata.aout_ar_data =
3700 (struct artdata *) bfd_zalloc (abfd, sizeof (struct artdata));
3702 if (bfd_ardata (abfd) == (struct artdata *) NULL)
3704 bfd_set_error (bfd_error_no_memory);
3705 return (const bfd_target *) NULL;
3708 bfd_ardata (abfd)->first_file_filepos = SARMAG;
3709 bfd_ardata (abfd)->cache = NULL;
3710 bfd_ardata (abfd)->archive_head = NULL;
3711 bfd_ardata (abfd)->symdefs = NULL;
3712 bfd_ardata (abfd)->extended_names = NULL;
3713 bfd_ardata (abfd)->tdata = NULL;
3715 if (_bfd_ecoff_slurp_armap (abfd) == false
3716 || _bfd_ecoff_slurp_extended_name_table (abfd) == false)
3718 bfd_release (abfd, bfd_ardata (abfd));
3719 abfd->tdata.aout_ar_data = (struct artdata *) NULL;
3720 return (const bfd_target *) NULL;
3726 /* ECOFF linker code. */
3728 static struct bfd_hash_entry *ecoff_link_hash_newfunc
3729 PARAMS ((struct bfd_hash_entry *entry,
3730 struct bfd_hash_table *table,
3731 const char *string));
3732 static boolean ecoff_link_add_archive_symbols
3733 PARAMS ((bfd *, struct bfd_link_info *));
3734 static boolean ecoff_link_check_archive_element
3735 PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
3736 static boolean ecoff_link_add_object_symbols
3737 PARAMS ((bfd *, struct bfd_link_info *));
3738 static boolean ecoff_link_add_externals
3739 PARAMS ((bfd *, struct bfd_link_info *, PTR, char *));
3741 /* Routine to create an entry in an ECOFF link hash table. */
3743 static struct bfd_hash_entry *
3744 ecoff_link_hash_newfunc (entry, table, string)
3745 struct bfd_hash_entry *entry;
3746 struct bfd_hash_table *table;
3749 struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry;
3751 /* Allocate the structure if it has not already been allocated by a
3753 if (ret == (struct ecoff_link_hash_entry *) NULL)
3754 ret = ((struct ecoff_link_hash_entry *)
3755 bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry)));
3756 if (ret == (struct ecoff_link_hash_entry *) NULL)
3758 bfd_set_error (bfd_error_no_memory);
3762 /* Call the allocation method of the superclass. */
3763 ret = ((struct ecoff_link_hash_entry *)
3764 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3769 /* Set local fields. */
3775 memset ((PTR) &ret->esym, 0, sizeof ret->esym);
3777 return (struct bfd_hash_entry *) ret;
3780 /* Create an ECOFF link hash table. */
3782 struct bfd_link_hash_table *
3783 _bfd_ecoff_bfd_link_hash_table_create (abfd)
3786 struct ecoff_link_hash_table *ret;
3788 ret = ((struct ecoff_link_hash_table *)
3789 malloc (sizeof (struct ecoff_link_hash_table)));
3792 bfd_set_error (bfd_error_no_memory);
3795 if (! _bfd_link_hash_table_init (&ret->root, abfd,
3796 ecoff_link_hash_newfunc))
3799 return (struct bfd_link_hash_table *) NULL;
3804 /* Look up an entry in an ECOFF link hash table. */
3806 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3807 ((struct ecoff_link_hash_entry *) \
3808 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3810 /* Traverse an ECOFF link hash table. */
3812 #define ecoff_link_hash_traverse(table, func, info) \
3813 (bfd_link_hash_traverse \
3815 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
3818 /* Get the ECOFF link hash table from the info structure. This is
3821 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3823 /* Given an ECOFF BFD, add symbols to the global hash table as
3827 _bfd_ecoff_bfd_link_add_symbols (abfd, info)
3829 struct bfd_link_info *info;
3831 switch (bfd_get_format (abfd))
3834 return ecoff_link_add_object_symbols (abfd, info);
3836 return ecoff_link_add_archive_symbols (abfd, info);
3838 bfd_set_error (bfd_error_wrong_format);
3843 /* Add the symbols from an archive file to the global hash table.
3844 This looks through the undefined symbols, looks each one up in the
3845 archive hash table, and adds any associated object file. We do not
3846 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3847 already have a hash table, so there is no reason to construct
3851 ecoff_link_add_archive_symbols (abfd, info)
3853 struct bfd_link_info *info;
3855 const bfd_byte *raw_armap;
3856 struct bfd_link_hash_entry **pundef;
3857 unsigned int armap_count;
3858 unsigned int armap_log;
3860 const bfd_byte *hashtable;
3861 const char *stringbase;
3863 if (! bfd_has_map (abfd))
3865 /* An empty archive is a special case. */
3866 if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
3868 bfd_set_error (bfd_error_no_symbols);
3872 /* If we don't have any raw data for this archive, as can happen on
3873 Irix 4.0.5F, we call the generic routine.
3874 FIXME: We should be more clever about this, since someday tdata
3875 may get to something for a generic archive. */
3876 raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata;
3877 if (raw_armap == (bfd_byte *) NULL)
3878 return (_bfd_generic_link_add_archive_symbols
3879 (abfd, info, ecoff_link_check_archive_element));
3881 armap_count = bfd_h_get_32 (abfd, raw_armap);
3884 for (i = 1; i < armap_count; i <<= 1)
3886 BFD_ASSERT (i == armap_count);
3888 hashtable = raw_armap + 4;
3889 stringbase = (const char *) raw_armap + armap_count * 8 + 8;
3891 /* Look through the list of undefined symbols. */
3892 pundef = &info->hash->undefs;
3893 while (*pundef != (struct bfd_link_hash_entry *) NULL)
3895 struct bfd_link_hash_entry *h;
3896 unsigned int hash, rehash;
3897 unsigned int file_offset;
3903 /* When a symbol is defined, it is not necessarily removed from
3905 if (h->type != bfd_link_hash_undefined
3906 && h->type != bfd_link_hash_common)
3908 /* Remove this entry from the list, for general cleanliness
3909 and because we are going to look through the list again
3910 if we search any more libraries. We can't remove the
3911 entry if it is the tail, because that would lose any
3912 entries we add to the list later on. */
3913 if (*pundef != info->hash->undefs_tail)
3914 *pundef = (*pundef)->next;
3916 pundef = &(*pundef)->next;
3920 /* Native ECOFF linkers do not pull in archive elements merely
3921 to satisfy common definitions, so neither do we. We leave
3922 them on the list, though, in case we are linking against some
3923 other object format. */
3924 if (h->type != bfd_link_hash_undefined)
3926 pundef = &(*pundef)->next;
3930 /* Look for this symbol in the archive hash table. */
3931 hash = ecoff_armap_hash (h->root.string, &rehash, armap_count,
3934 file_offset = bfd_h_get_32 (abfd, hashtable + (hash * 8) + 4);
3935 if (file_offset == 0)
3937 /* Nothing in this slot. */
3938 pundef = &(*pundef)->next;
3942 name = stringbase + bfd_h_get_32 (abfd, hashtable + (hash * 8));
3943 if (name[0] != h->root.string[0]
3944 || strcmp (name, h->root.string) != 0)
3949 /* That was the wrong symbol. Try rehashing. */
3951 for (srch = (hash + rehash) & (armap_count - 1);
3953 srch = (srch + rehash) & (armap_count - 1))
3955 file_offset = bfd_h_get_32 (abfd, hashtable + (srch * 8) + 4);
3956 if (file_offset == 0)
3958 name = stringbase + bfd_h_get_32 (abfd, hashtable + (srch * 8));
3959 if (name[0] == h->root.string[0]
3960 && strcmp (name, h->root.string) == 0)
3969 pundef = &(*pundef)->next;
3976 element = _bfd_get_elt_at_filepos (abfd, file_offset);
3977 if (element == (bfd *) NULL)
3980 if (! bfd_check_format (element, bfd_object))
3983 /* Unlike the generic linker, we know that this element provides
3984 a definition for an undefined symbol and we know that we want
3985 to include it. We don't need to check anything. */
3986 if (! (*info->callbacks->add_archive_element) (info, element, name))
3988 if (! ecoff_link_add_object_symbols (element, info))
3991 pundef = &(*pundef)->next;
3997 /* This is called if we used _bfd_generic_link_add_archive_symbols
3998 because we were not dealing with an ECOFF archive. */
4001 ecoff_link_check_archive_element (abfd, info, pneeded)
4003 struct bfd_link_info *info;
4006 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
4007 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
4008 = backend->debug_swap.swap_ext_in;
4010 bfd_size_type external_ext_size;
4011 PTR external_ext = NULL;
4019 if (! ecoff_slurp_symbolic_header (abfd))
4022 /* If there are no symbols, we don't want it. */
4023 if (bfd_get_symcount (abfd) == 0)
4024 goto successful_return;
4026 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
4028 /* Read in the external symbols and external strings. */
4029 external_ext_size = backend->debug_swap.external_ext_size;
4030 esize = symhdr->iextMax * external_ext_size;
4031 external_ext = (PTR) malloc (esize);
4032 if (external_ext == NULL && esize != 0)
4034 bfd_set_error (bfd_error_no_memory);
4038 if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
4039 || bfd_read (external_ext, 1, esize, abfd) != esize)
4042 ssext = (char *) malloc (symhdr->issExtMax);
4043 if (ssext == NULL && symhdr->issExtMax != 0)
4045 bfd_set_error (bfd_error_no_memory);
4049 if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
4050 || bfd_read (ssext, 1, symhdr->issExtMax, abfd) != symhdr->issExtMax)
4053 /* Look through the external symbols to see if they define some
4054 symbol that is currently undefined. */
4055 ext_ptr = (char *) external_ext;
4056 ext_end = ext_ptr + esize;
4057 for (; ext_ptr < ext_end; ext_ptr += external_ext_size)
4062 struct bfd_link_hash_entry *h;
4064 (*swap_ext_in) (abfd, (PTR) ext_ptr, &esym);
4066 /* See if this symbol defines something. */
4067 if (esym.asym.st != stGlobal
4068 && esym.asym.st != stLabel
4069 && esym.asym.st != stProc)
4072 switch (esym.asym.sc)
4095 name = ssext + esym.asym.iss;
4096 h = bfd_link_hash_lookup (info->hash, name, false, false, true);
4098 /* Unlike the generic linker, we do not pull in elements because
4099 of common symbols. */
4100 if (h == (struct bfd_link_hash_entry *) NULL
4101 || h->type != bfd_link_hash_undefined)
4104 /* Include this element. */
4105 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
4107 if (! ecoff_link_add_externals (abfd, info, external_ext, ssext))
4111 goto successful_return;
4115 if (external_ext != NULL)
4116 free (external_ext);
4121 if (external_ext != NULL)
4122 free (external_ext);
4128 /* Add symbols from an ECOFF object file to the global linker hash
4132 ecoff_link_add_object_symbols (abfd, info)
4134 struct bfd_link_info *info;
4137 bfd_size_type external_ext_size;
4138 PTR external_ext = NULL;
4143 if (! ecoff_slurp_symbolic_header (abfd))
4146 /* If there are no symbols, we don't want it. */
4147 if (bfd_get_symcount (abfd) == 0)
4150 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
4152 /* Read in the external symbols and external strings. */
4153 external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size;
4154 esize = symhdr->iextMax * external_ext_size;
4155 external_ext = (PTR) malloc (esize);
4156 if (external_ext == NULL && esize != 0)
4158 bfd_set_error (bfd_error_no_memory);
4162 if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
4163 || bfd_read (external_ext, 1, esize, abfd) != esize)
4166 ssext = (char *) malloc (symhdr->issExtMax);
4167 if (ssext == NULL && symhdr->issExtMax != 0)
4169 bfd_set_error (bfd_error_no_memory);
4173 if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
4174 || bfd_read (ssext, 1, symhdr->issExtMax, abfd) != symhdr->issExtMax)
4177 result = ecoff_link_add_externals (abfd, info, external_ext, ssext);
4181 if (external_ext != NULL)
4182 free (external_ext);
4188 if (external_ext != NULL)
4189 free (external_ext);
4193 /* Add the external symbols of an object file to the global linker
4194 hash table. The external symbols and strings we are passed are
4195 just allocated on the stack, and will be discarded. We must
4196 explicitly save any information we may need later on in the link.
4197 We do not want to read the external symbol information again. */
4200 ecoff_link_add_externals (abfd, info, external_ext, ssext)
4202 struct bfd_link_info *info;
4206 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
4207 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
4208 = backend->debug_swap.swap_ext_in;
4209 bfd_size_type external_ext_size = backend->debug_swap.external_ext_size;
4210 unsigned long ext_count;
4211 struct ecoff_link_hash_entry **sym_hash;
4215 ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
4217 sym_hash = ((struct ecoff_link_hash_entry **)
4219 ext_count * sizeof (struct bfd_link_hash_entry *)));
4222 bfd_set_error (bfd_error_no_memory);
4225 ecoff_data (abfd)->sym_hashes = sym_hash;
4227 ext_ptr = (char *) external_ext;
4228 ext_end = ext_ptr + ext_count * external_ext_size;
4229 for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++)
4236 struct ecoff_link_hash_entry *h;
4240 (*swap_ext_in) (abfd, (PTR) ext_ptr, &esym);
4242 /* Skip debugging symbols. */
4244 switch (esym.asym.st)
4260 /* Get the information for this symbol. */
4261 value = esym.asym.value;
4262 switch (esym.asym.sc)
4282 section = bfd_make_section_old_way (abfd, ".text");
4283 value -= section->vma;
4286 section = bfd_make_section_old_way (abfd, ".data");
4287 value -= section->vma;
4290 section = bfd_make_section_old_way (abfd, ".bss");
4291 value -= section->vma;
4294 section = bfd_abs_section_ptr;
4297 section = bfd_und_section_ptr;
4300 section = bfd_make_section_old_way (abfd, ".sdata");
4301 value -= section->vma;
4304 section = bfd_make_section_old_way (abfd, ".sbss");
4305 value -= section->vma;
4308 section = bfd_make_section_old_way (abfd, ".rdata");
4309 value -= section->vma;
4312 if (value > ecoff_data (abfd)->gp_size)
4314 section = bfd_com_section_ptr;
4319 if (ecoff_scom_section.name == NULL)
4321 /* Initialize the small common section. */
4322 ecoff_scom_section.name = SCOMMON;
4323 ecoff_scom_section.flags = SEC_IS_COMMON;
4324 ecoff_scom_section.output_section = &ecoff_scom_section;
4325 ecoff_scom_section.symbol = &ecoff_scom_symbol;
4326 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
4327 ecoff_scom_symbol.name = SCOMMON;
4328 ecoff_scom_symbol.flags = BSF_SECTION_SYM;
4329 ecoff_scom_symbol.section = &ecoff_scom_section;
4330 ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
4332 section = &ecoff_scom_section;
4335 section = bfd_und_section_ptr;
4338 section = bfd_make_section_old_way (abfd, ".init");
4339 value -= section->vma;
4342 section = bfd_make_section_old_way (abfd, ".fini");
4343 value -= section->vma;
4347 if (section == (asection *) NULL)
4350 name = ssext + esym.asym.iss;
4353 if (! (_bfd_generic_link_add_one_symbol
4354 (info, abfd, name, BSF_GLOBAL, section, value,
4355 (const char *) NULL, true, true,
4356 (struct bfd_link_hash_entry **) &h)))
4361 /* If we are building an ECOFF hash table, save the external
4362 symbol information. */
4363 if (info->hash->creator->flavour == bfd_get_flavour (abfd))
4365 if (h->abfd == (bfd *) NULL
4366 || (! bfd_is_und_section (section)
4367 && (! bfd_is_com_section (section)
4368 || (h->root.type != bfd_link_hash_defined
4369 && h->root.type != bfd_link_hash_defweak))))
4375 /* Remember whether this symbol was small undefined. */
4376 if (esym.asym.sc == scSUndefined)
4379 /* If this symbol was ever small undefined, it needs to wind
4380 up in a GP relative section. We can't control the
4381 section of a defined symbol, but we can control the
4382 section of a common symbol. This case is actually needed
4383 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
4385 && h->root.type == bfd_link_hash_common
4386 && strcmp (h->root.u.c.section->name, SCOMMON) != 0)
4388 h->root.u.c.section = bfd_make_section_old_way (abfd, SCOMMON);
4389 h->root.u.c.section->flags = SEC_ALLOC;
4390 if (h->esym.asym.sc == scCommon)
4391 h->esym.asym.sc = scSCommon;
4399 /* ECOFF final link routines. */
4401 static boolean ecoff_final_link_debug_accumulate
4402 PARAMS ((bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *,
4404 static boolean ecoff_link_write_external
4405 PARAMS ((struct ecoff_link_hash_entry *, PTR));
4406 static boolean ecoff_indirect_link_order
4407 PARAMS ((bfd *, struct bfd_link_info *, asection *,
4408 struct bfd_link_order *));
4409 static boolean ecoff_reloc_link_order
4410 PARAMS ((bfd *, struct bfd_link_info *, asection *,
4411 struct bfd_link_order *));
4413 /* ECOFF final link routine. This looks through all the input BFDs
4414 and gathers together all the debugging information, and then
4415 processes all the link order information. This may cause it to
4416 close and reopen some input BFDs; I'll see how bad this is. */
4419 _bfd_ecoff_bfd_final_link (abfd, info)
4421 struct bfd_link_info *info;
4423 const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
4424 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
4427 register bfd *input_bfd;
4429 struct bfd_link_order *p;
4431 /* We accumulate the debugging information counts in the symbolic
4433 symhdr = &debug->symbolic_header;
4435 symhdr->ilineMax = 0;
4439 symhdr->isymMax = 0;
4440 symhdr->ioptMax = 0;
4441 symhdr->iauxMax = 0;
4443 symhdr->issExtMax = 0;
4446 symhdr->iextMax = 0;
4448 /* We accumulate the debugging information itself in the debug_info
4451 debug->external_dnr = NULL;
4452 debug->external_pdr = NULL;
4453 debug->external_sym = NULL;
4454 debug->external_opt = NULL;
4455 debug->external_aux = NULL;
4457 debug->ssext = debug->ssext_end = NULL;
4458 debug->external_fdr = NULL;
4459 debug->external_rfd = NULL;
4460 debug->external_ext = debug->external_ext_end = NULL;
4462 handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info);
4463 if (handle == (PTR) NULL)
4466 /* Accumulate the debugging symbols from each input BFD. */
4467 for (input_bfd = info->input_bfds;
4468 input_bfd != (bfd *) NULL;
4469 input_bfd = input_bfd->link_next)
4473 if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour)
4475 /* Abitrarily set the symbolic header vstamp to the vstamp
4476 of the first object file in the link. */
4477 if (symhdr->vstamp == 0)
4479 = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp;
4480 ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info,
4484 ret = bfd_ecoff_debug_accumulate_other (handle, abfd,
4485 debug, &backend->debug_swap,
4490 /* Combine the register masks. */
4491 ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask;
4492 ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask;
4493 ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0];
4494 ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1];
4495 ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2];
4496 ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3];
4499 /* Write out the external symbols. */
4500 ecoff_link_hash_traverse (ecoff_hash_table (info),
4501 ecoff_link_write_external,
4504 if (info->relocateable)
4506 /* We need to make a pass over the link_orders to count up the
4507 number of relocations we will need to output, so that we know
4508 how much space they will take up. */
4509 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4512 for (p = o->link_order_head;
4513 p != (struct bfd_link_order *) NULL;
4515 if (p->type == bfd_indirect_link_order)
4516 o->reloc_count += p->u.indirect.section->reloc_count;
4517 else if (p->type == bfd_section_reloc_link_order
4518 || p->type == bfd_symbol_reloc_link_order)
4523 /* Compute the reloc and symbol file positions. */
4524 ecoff_compute_reloc_file_positions (abfd);
4526 /* Write out the debugging information. */
4527 if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug,
4528 &backend->debug_swap, info,
4529 ecoff_data (abfd)->sym_filepos))
4532 bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info);
4534 if (info->relocateable)
4536 /* Now reset the reloc_count field of the sections in the output
4537 BFD to 0, so that we can use them to keep track of how many
4538 relocs we have output thus far. */
4539 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4543 /* Get a value for the GP register. */
4544 if (ecoff_data (abfd)->gp == 0)
4546 struct bfd_link_hash_entry *h;
4548 h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
4549 if (h != (struct bfd_link_hash_entry *) NULL
4550 && h->type == bfd_link_hash_defined)
4551 ecoff_data (abfd)->gp = (h->u.def.value
4552 + h->u.def.section->output_section->vma
4553 + h->u.def.section->output_offset);
4554 else if (info->relocateable)
4558 /* Make up a value. */
4560 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4563 && (strcmp (o->name, _SBSS) == 0
4564 || strcmp (o->name, _SDATA) == 0
4565 || strcmp (o->name, _LIT4) == 0
4566 || strcmp (o->name, _LIT8) == 0
4567 || strcmp (o->name, _LITA) == 0))
4570 ecoff_data (abfd)->gp = lo + 0x8000;
4574 /* If the relocate_section function needs to do a reloc
4575 involving the GP value, it should make a reloc_dangerous
4576 callback to warn that GP is not defined. */
4580 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4582 for (p = o->link_order_head;
4583 p != (struct bfd_link_order *) NULL;
4586 if (p->type == bfd_indirect_link_order
4587 && (bfd_get_flavour (p->u.indirect.section->owner)
4588 == bfd_target_ecoff_flavour))
4590 if (! ecoff_indirect_link_order (abfd, info, o, p))
4593 else if (p->type == bfd_section_reloc_link_order
4594 || p->type == bfd_symbol_reloc_link_order)
4596 if (! ecoff_reloc_link_order (abfd, info, o, p))
4601 if (! _bfd_default_link_order (abfd, info, o, p))
4607 bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax;
4609 ecoff_data (abfd)->linker = true;
4614 /* Accumulate the debugging information for an input BFD into the
4615 output BFD. This must read in the symbolic information of the
4619 ecoff_final_link_debug_accumulate (output_bfd, input_bfd, info, handle)
4622 struct bfd_link_info *info;
4625 struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info;
4626 const struct ecoff_debug_swap * const swap =
4627 &ecoff_backend (input_bfd)->debug_swap;
4628 HDRR *symhdr = &debug->symbolic_header;
4631 #define READ(ptr, offset, count, size, type) \
4632 if (symhdr->count == 0) \
4633 debug->ptr = NULL; \
4636 debug->ptr = (type) malloc (size * symhdr->count); \
4637 if (debug->ptr == NULL) \
4639 bfd_set_error (bfd_error_no_memory); \
4641 goto return_something; \
4643 if ((bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) \
4645 || (bfd_read (debug->ptr, size, symhdr->count, \
4646 input_bfd) != size * symhdr->count)) \
4649 goto return_something; \
4653 /* If raw_syments is not NULL, then the data was already by read by
4654 _bfd_ecoff_slurp_symbolic_info. */
4655 if (ecoff_data (input_bfd)->raw_syments == NULL)
4657 READ (line, cbLineOffset, cbLine, sizeof (unsigned char),
4659 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
4660 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
4661 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
4662 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
4663 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
4665 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
4666 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
4667 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
4671 /* We do not read the external strings or the external symbols. */
4673 ret = (bfd_ecoff_debug_accumulate
4674 (handle, output_bfd, &ecoff_data (output_bfd)->debug_info,
4675 &ecoff_backend (output_bfd)->debug_swap,
4676 input_bfd, debug, swap, info));
4679 if (ecoff_data (input_bfd)->raw_syments == NULL)
4681 if (debug->line != NULL)
4683 if (debug->external_dnr != NULL)
4684 free (debug->external_dnr);
4685 if (debug->external_pdr != NULL)
4686 free (debug->external_pdr);
4687 if (debug->external_sym != NULL)
4688 free (debug->external_sym);
4689 if (debug->external_opt != NULL)
4690 free (debug->external_opt);
4691 if (debug->external_aux != NULL)
4692 free (debug->external_aux);
4693 if (debug->ss != NULL)
4695 if (debug->external_fdr != NULL)
4696 free (debug->external_fdr);
4697 if (debug->external_rfd != NULL)
4698 free (debug->external_rfd);
4700 /* Make sure we don't accidentally follow one of these pointers
4701 into freed memory. */
4703 debug->external_dnr = NULL;
4704 debug->external_pdr = NULL;
4705 debug->external_sym = NULL;
4706 debug->external_opt = NULL;
4707 debug->external_aux = NULL;
4709 debug->external_fdr = NULL;
4710 debug->external_rfd = NULL;
4716 /* Put out information for an external symbol. These come only from
4720 ecoff_link_write_external (h, data)
4721 struct ecoff_link_hash_entry *h;
4724 bfd *output_bfd = (bfd *) data;
4726 /* FIXME: We should check if this symbol is being stripped. */
4731 if (h->abfd == (bfd *) NULL)
4734 h->esym.cobol_main = 0;
4735 h->esym.weakext = 0;
4736 h->esym.reserved = 0;
4737 h->esym.ifd = ifdNil;
4738 h->esym.asym.value = 0;
4739 h->esym.asym.st = stGlobal;
4741 if (h->root.type != bfd_link_hash_defined
4742 && h->root.type != bfd_link_hash_defweak)
4743 h->esym.asym.sc = scAbs;
4746 asection *output_section;
4749 output_section = h->root.u.def.section->output_section;
4750 name = bfd_section_name (output_section->owner, output_section);
4752 if (strcmp (name, _TEXT) == 0)
4753 h->esym.asym.sc = scText;
4754 else if (strcmp (name, _DATA) == 0)
4755 h->esym.asym.sc = scData;
4756 else if (strcmp (name, _SDATA) == 0)
4757 h->esym.asym.sc = scSData;
4758 else if (strcmp (name, _RDATA) == 0)
4759 h->esym.asym.sc = scRData;
4760 else if (strcmp (name, _BSS) == 0)
4761 h->esym.asym.sc = scBss;
4762 else if (strcmp (name, _SBSS) == 0)
4763 h->esym.asym.sc = scSBss;
4764 else if (strcmp (name, _INIT) == 0)
4765 h->esym.asym.sc = scInit;
4766 else if (strcmp (name, _FINI) == 0)
4767 h->esym.asym.sc = scFini;
4768 else if (strcmp (name, _PDATA) == 0)
4769 h->esym.asym.sc = scPData;
4770 else if (strcmp (name, _XDATA) == 0)
4771 h->esym.asym.sc = scXData;
4773 h->esym.asym.sc = scAbs;
4776 h->esym.asym.reserved = 0;
4777 h->esym.asym.index = indexNil;
4779 else if (h->esym.ifd != -1)
4781 struct ecoff_debug_info *debug;
4783 /* Adjust the FDR index for the symbol by that used for the
4785 debug = &ecoff_data (h->abfd)->debug_info;
4786 BFD_ASSERT (h->esym.ifd >= 0
4787 && h->esym.ifd < debug->symbolic_header.ifdMax);
4788 h->esym.ifd = debug->ifdmap[h->esym.ifd];
4791 switch (h->root.type)
4794 case bfd_link_hash_new:
4796 case bfd_link_hash_undefined:
4797 case bfd_link_hash_undefweak:
4798 if (h->esym.asym.sc != scUndefined
4799 && h->esym.asym.sc != scSUndefined)
4800 h->esym.asym.sc = scUndefined;
4802 case bfd_link_hash_defined:
4803 case bfd_link_hash_defweak:
4804 if (h->esym.asym.sc == scUndefined
4805 || h->esym.asym.sc == scSUndefined)
4806 h->esym.asym.sc = scAbs;
4807 else if (h->esym.asym.sc == scCommon)
4808 h->esym.asym.sc = scBss;
4809 else if (h->esym.asym.sc == scSCommon)
4810 h->esym.asym.sc = scSBss;
4811 h->esym.asym.value = (h->root.u.def.value
4812 + h->root.u.def.section->output_section->vma
4813 + h->root.u.def.section->output_offset);
4815 case bfd_link_hash_common:
4816 if (h->esym.asym.sc != scCommon
4817 && h->esym.asym.sc != scSCommon)
4818 h->esym.asym.sc = scCommon;
4819 h->esym.asym.value = h->root.u.c.size;
4821 case bfd_link_hash_indirect:
4822 case bfd_link_hash_warning:
4823 /* FIXME: Ignore these for now. The circumstances under which
4824 they should be written out are not clear to me. */
4828 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4830 h->indx = ecoff_data (output_bfd)->debug_info.symbolic_header.iextMax;
4833 return (bfd_ecoff_debug_one_external
4834 (output_bfd, &ecoff_data (output_bfd)->debug_info,
4835 &ecoff_backend (output_bfd)->debug_swap, h->root.root.string,
4839 /* Relocate and write an ECOFF section into an ECOFF output file. */
4842 ecoff_indirect_link_order (output_bfd, info, output_section, link_order)
4844 struct bfd_link_info *info;
4845 asection *output_section;
4846 struct bfd_link_order *link_order;
4848 asection *input_section;
4850 struct ecoff_section_tdata *section_tdata;
4851 bfd_size_type raw_size;
4852 bfd_size_type cooked_size;
4853 bfd_byte *contents = NULL;
4854 bfd_size_type external_reloc_size;
4855 bfd_size_type external_relocs_size;
4856 PTR external_relocs = NULL;
4858 BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
4860 if (link_order->size == 0)
4863 input_section = link_order->u.indirect.section;
4864 input_bfd = input_section->owner;
4865 section_tdata = ecoff_section_data (input_bfd, input_section);
4867 raw_size = input_section->_raw_size;
4868 cooked_size = input_section->_cooked_size;
4869 if (cooked_size == 0)
4870 cooked_size = raw_size;
4872 BFD_ASSERT (input_section->output_section == output_section);
4873 BFD_ASSERT (input_section->output_offset == link_order->offset);
4874 BFD_ASSERT (cooked_size == link_order->size);
4876 /* Get the section contents. We allocate memory for the larger of
4877 the size before relocating and the size after relocating. */
4878 contents = (bfd_byte *) malloc (raw_size >= cooked_size
4881 if (contents == NULL && raw_size != 0)
4883 bfd_set_error (bfd_error_no_memory);
4887 /* If we are relaxing, the contents may have already been read into
4888 memory, in which case we copy them into our new buffer. We don't
4889 simply reuse the old buffer in case cooked_size > raw_size. */
4890 if (section_tdata != (struct ecoff_section_tdata *) NULL
4891 && section_tdata->contents != (bfd_byte *) NULL)
4892 memcpy (contents, section_tdata->contents, raw_size);
4895 if (! bfd_get_section_contents (input_bfd, input_section,
4897 (file_ptr) 0, raw_size))
4901 /* Get the relocs. If we are relaxing MIPS code, they will already
4902 have been read in. Otherwise, we read them in now. */
4903 external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size;
4904 external_relocs_size = external_reloc_size * input_section->reloc_count;
4906 if (section_tdata != (struct ecoff_section_tdata *) NULL)
4907 external_relocs = section_tdata->external_relocs;
4910 external_relocs = (PTR) malloc (external_relocs_size);
4911 if (external_relocs == NULL && external_relocs_size != 0)
4913 bfd_set_error (bfd_error_no_memory);
4917 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4918 || (bfd_read (external_relocs, 1, external_relocs_size, input_bfd)
4919 != external_relocs_size))
4923 /* Relocate the section contents. */
4924 if (! ((*ecoff_backend (input_bfd)->relocate_section)
4925 (output_bfd, info, input_bfd, input_section, contents,
4929 /* Write out the relocated section. */
4930 if (! bfd_set_section_contents (output_bfd,
4933 input_section->output_offset,
4937 /* If we are producing relocateable output, the relocs were
4938 modified, and we write them out now. We use the reloc_count
4939 field of output_section to keep track of the number of relocs we
4940 have output so far. */
4941 if (info->relocateable)
4943 if (bfd_seek (output_bfd,
4944 (output_section->rel_filepos +
4945 output_section->reloc_count * external_reloc_size),
4947 || (bfd_write (external_relocs, 1, external_relocs_size, output_bfd)
4948 != external_relocs_size))
4950 output_section->reloc_count += input_section->reloc_count;
4953 if (contents != NULL)
4955 if (external_relocs != NULL && section_tdata == NULL)
4956 free (external_relocs);
4960 if (contents != NULL)
4962 if (external_relocs != NULL && section_tdata == NULL)
4963 free (external_relocs);
4967 /* Generate a reloc when linking an ECOFF file. This is a reloc
4968 requested by the linker, and does come from any input file. This
4969 is used to build constructor and destructor tables when linking
4973 ecoff_reloc_link_order (output_bfd, info, output_section, link_order)
4975 struct bfd_link_info *info;
4976 asection *output_section;
4977 struct bfd_link_order *link_order;
4980 struct internal_reloc in;
4981 bfd_size_type external_reloc_size;
4985 /* We set up an arelent to pass to the backend adjust_reloc_out
4987 rel.address = link_order->offset;
4989 rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
4992 bfd_set_error (bfd_error_bad_value);
4996 if (link_order->type == bfd_section_reloc_link_order)
4997 rel.sym_ptr_ptr = link_order->u.reloc.p->u.section->symbol_ptr_ptr;
5000 /* We can't set up a reloc against a symbol correctly, because
5001 we have no asymbol structure. Currently no adjust_reloc_out
5003 rel.sym_ptr_ptr = (asymbol **) NULL;
5006 /* All ECOFF relocs are in-place. Put the addend into the object
5009 BFD_ASSERT (rel.howto->partial_inplace);
5010 if (link_order->u.reloc.p->addend != 0)
5013 bfd_reloc_status_type rstat;
5017 size = bfd_get_reloc_size (rel.howto);
5018 buf = (bfd_byte *) bfd_zmalloc (size);
5019 if (buf == (bfd_byte *) NULL)
5021 bfd_set_error (bfd_error_no_memory);
5024 rstat = _bfd_relocate_contents (rel.howto, output_bfd,
5025 link_order->u.reloc.p->addend, buf);
5031 case bfd_reloc_outofrange:
5033 case bfd_reloc_overflow:
5034 if (! ((*info->callbacks->reloc_overflow)
5036 (link_order->type == bfd_section_reloc_link_order
5037 ? bfd_section_name (output_bfd,
5038 link_order->u.reloc.p->u.section)
5039 : link_order->u.reloc.p->u.name),
5040 rel.howto->name, link_order->u.reloc.p->addend,
5041 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
5048 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
5049 (file_ptr) link_order->offset, size);
5057 /* Move the information into a internal_reloc structure. */
5058 in.r_vaddr = (rel.address
5059 + bfd_get_section_vma (output_bfd, output_section));
5060 in.r_type = rel.howto->type;
5062 if (link_order->type == bfd_symbol_reloc_link_order)
5064 struct ecoff_link_hash_entry *h;
5066 h = ecoff_link_hash_lookup (ecoff_hash_table (info),
5067 link_order->u.reloc.p->u.name,
5068 false, false, true);
5069 if (h != (struct ecoff_link_hash_entry *) NULL
5071 in.r_symndx = h->indx;
5074 if (! ((*info->callbacks->unattached_reloc)
5075 (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
5076 (asection *) NULL, (bfd_vma) 0)))
5086 name = bfd_get_section_name (output_bfd,
5087 link_order->u.reloc.p->u.section);
5088 if (strcmp (name, ".text") == 0)
5089 in.r_symndx = RELOC_SECTION_TEXT;
5090 else if (strcmp (name, ".rdata") == 0)
5091 in.r_symndx = RELOC_SECTION_RDATA;
5092 else if (strcmp (name, ".data") == 0)
5093 in.r_symndx = RELOC_SECTION_DATA;
5094 else if (strcmp (name, ".sdata") == 0)
5095 in.r_symndx = RELOC_SECTION_SDATA;
5096 else if (strcmp (name, ".sbss") == 0)
5097 in.r_symndx = RELOC_SECTION_SBSS;
5098 else if (strcmp (name, ".bss") == 0)
5099 in.r_symndx = RELOC_SECTION_BSS;
5100 else if (strcmp (name, ".init") == 0)
5101 in.r_symndx = RELOC_SECTION_INIT;
5102 else if (strcmp (name, ".lit8") == 0)
5103 in.r_symndx = RELOC_SECTION_LIT8;
5104 else if (strcmp (name, ".lit4") == 0)
5105 in.r_symndx = RELOC_SECTION_LIT4;
5106 else if (strcmp (name, ".xdata") == 0)
5107 in.r_symndx = RELOC_SECTION_XDATA;
5108 else if (strcmp (name, ".pdata") == 0)
5109 in.r_symndx = RELOC_SECTION_PDATA;
5110 else if (strcmp (name, ".fini") == 0)
5111 in.r_symndx = RELOC_SECTION_FINI;
5112 else if (strcmp (name, ".lita") == 0)
5113 in.r_symndx = RELOC_SECTION_LITA;
5114 else if (strcmp (name, "*ABS*") == 0)
5115 in.r_symndx = RELOC_SECTION_ABS;
5121 /* Let the BFD backend adjust the reloc. */
5122 (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in);
5124 /* Get some memory and swap out the reloc. */
5125 external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
5126 rbuf = (bfd_byte *) malloc (external_reloc_size);
5127 if (rbuf == (bfd_byte *) NULL)
5129 bfd_set_error (bfd_error_no_memory);
5133 (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (PTR) rbuf);
5135 ok = (bfd_seek (output_bfd,
5136 (output_section->rel_filepos +
5137 output_section->reloc_count * external_reloc_size),
5139 && (bfd_write ((PTR) rbuf, 1, external_reloc_size, output_bfd)
5140 == external_reloc_size));
5143 ++output_section->reloc_count;