1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright 1990, 1991, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
5 Original version by Per Bothner.
6 Full support added by Ian Lance Taylor, ian@cygnus.com.
8 This file is part of BFD, the Binary File Descriptor library.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
30 #include "aout/stab_gnu.h"
32 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
33 some other stuff which we don't want and which conflicts with stuff
36 #include "aout/aout64.h"
39 #undef obj_sym_filepos
41 #include "coff/internal.h"
43 #include "coff/symconst.h"
44 #include "coff/ecoff.h"
47 #include "libiberty.h"
49 #define streq(a, b) (strcmp ((a), (b)) == 0)
50 #define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0)
53 /* This stuff is somewhat copied from coffcode.h. */
54 static asection bfd_debug_section
=
56 /* name, id, index, next, prev, flags, user_set_vma, */
57 "*DEBUG*", 0, 0, NULL
, NULL
, 0, 0,
58 /* linker_mark, linker_has_input, gc_mark, compress_status, */
60 /* segment_mark, sec_info_type, use_rela_p, */
62 /* sec_flg0, sec_flg1, sec_flg2, sec_flg3, sec_flg4, sec_flg5, */
64 /* vma, lma, size, rawsize, compressed_size, relax, relax_count, */
66 /* output_offset, output_section, alignment_power, */
68 /* relocation, orelocation, reloc_count, filepos, rel_filepos, */
70 /* line_filepos, userdata, contents, lineno, lineno_count, */
71 0, NULL
, NULL
, NULL
, 0,
72 /* entsize, kept_section, moving_line_filepos, */
74 /* target_index, used_by_bfd, constructor_chain, owner, */
80 /* map_head, map_tail */
84 /* Create an ECOFF object. */
87 _bfd_ecoff_mkobject (bfd
*abfd
)
89 bfd_size_type amt
= sizeof (ecoff_data_type
);
91 abfd
->tdata
.ecoff_obj_data
= (struct ecoff_tdata
*) bfd_zalloc (abfd
, amt
);
92 if (abfd
->tdata
.ecoff_obj_data
== NULL
)
98 /* This is a hook called by coff_real_object_p to create any backend
99 specific information. */
102 _bfd_ecoff_mkobject_hook (bfd
*abfd
, void * filehdr
, void * aouthdr
)
104 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
105 struct internal_aouthdr
*internal_a
= (struct internal_aouthdr
*) aouthdr
;
106 ecoff_data_type
*ecoff
;
108 if (! _bfd_ecoff_mkobject (abfd
))
111 ecoff
= ecoff_data (abfd
);
113 ecoff
->sym_filepos
= internal_f
->f_symptr
;
115 if (internal_a
!= NULL
)
119 ecoff
->text_start
= internal_a
->text_start
;
120 ecoff
->text_end
= internal_a
->text_start
+ internal_a
->tsize
;
121 ecoff
->gp
= internal_a
->gp_value
;
122 ecoff
->gprmask
= internal_a
->gprmask
;
123 for (i
= 0; i
< 4; i
++)
124 ecoff
->cprmask
[i
] = internal_a
->cprmask
[i
];
125 ecoff
->fprmask
= internal_a
->fprmask
;
126 if (internal_a
->magic
== ECOFF_AOUT_ZMAGIC
)
127 abfd
->flags
|= D_PAGED
;
129 abfd
->flags
&=~ D_PAGED
;
132 /* It turns out that no special action is required by the MIPS or
133 Alpha ECOFF backends. They have different information in the
134 a.out header, but we just copy it all (e.g., gprmask, cprmask and
135 fprmask) and let the swapping routines ensure that only relevant
136 information is written out. */
138 return (void *) ecoff
;
141 /* Initialize a new section. */
144 _bfd_ecoff_new_section_hook (bfd
*abfd
, asection
*section
)
154 { _TEXT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
155 { _INIT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
156 { _FINI
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
157 { _DATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
},
158 { _SDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
},
159 { _RDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
160 { _LIT8
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
161 { _LIT4
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
162 { _RCONST
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
163 { _PDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
166 /* An Irix 4 shared libary. */
167 { _LIB
, SEC_COFF_SHARED_LIBRARY
}
170 section
->alignment_power
= 4;
172 for (i
= 0; i
< ARRAY_SIZE (section_flags
); i
++)
173 if (streq (section
->name
, section_flags
[i
].name
))
175 section
->flags
|= section_flags
[i
].flags
;
180 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
181 uncertain about .init on some systems and I don't know how shared
184 return _bfd_generic_new_section_hook (abfd
, section
);
187 /* Determine the machine architecture and type. This is called from
188 the generic COFF routines. It is the inverse of ecoff_get_magic,
189 below. This could be an ECOFF backend routine, with one version
190 for each target, but there aren't all that many ECOFF targets. */
193 _bfd_ecoff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
195 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
196 enum bfd_architecture arch
;
199 switch (internal_f
->f_magic
)
202 case MIPS_MAGIC_LITTLE
:
204 arch
= bfd_arch_mips
;
205 mach
= bfd_mach_mips3000
;
208 case MIPS_MAGIC_LITTLE2
:
209 case MIPS_MAGIC_BIG2
:
210 /* MIPS ISA level 2: the r6000. */
211 arch
= bfd_arch_mips
;
212 mach
= bfd_mach_mips6000
;
215 case MIPS_MAGIC_LITTLE3
:
216 case MIPS_MAGIC_BIG3
:
217 /* MIPS ISA level 3: the r4000. */
218 arch
= bfd_arch_mips
;
219 mach
= bfd_mach_mips4000
;
223 arch
= bfd_arch_alpha
;
228 arch
= bfd_arch_obscure
;
233 return bfd_default_set_arch_mach (abfd
, arch
, mach
);
237 _bfd_ecoff_no_long_sections (abfd
, enable
)
246 /* Get the magic number to use based on the architecture and machine.
247 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
250 ecoff_get_magic (bfd
*abfd
)
254 switch (bfd_get_arch (abfd
))
257 switch (bfd_get_mach (abfd
))
261 case bfd_mach_mips3000
:
262 big
= MIPS_MAGIC_BIG
;
263 little
= MIPS_MAGIC_LITTLE
;
266 case bfd_mach_mips6000
:
267 big
= MIPS_MAGIC_BIG2
;
268 little
= MIPS_MAGIC_LITTLE2
;
271 case bfd_mach_mips4000
:
272 big
= MIPS_MAGIC_BIG3
;
273 little
= MIPS_MAGIC_LITTLE3
;
277 return bfd_big_endian (abfd
) ? big
: little
;
288 /* Get the section s_flags to use for a section. */
291 ecoff_sec_to_styp_flags (const char *name
, flagword flags
)
301 { _TEXT
, STYP_TEXT
},
302 { _DATA
, STYP_DATA
},
303 { _SDATA
, STYP_SDATA
},
304 { _RDATA
, STYP_RDATA
},
305 { _LITA
, STYP_LITA
},
306 { _LIT8
, STYP_LIT8
},
307 { _LIT4
, STYP_LIT4
},
309 { _SBSS
, STYP_SBSS
},
310 { _INIT
, STYP_ECOFF_INIT
},
311 { _FINI
, STYP_ECOFF_FINI
},
312 { _PDATA
, STYP_PDATA
},
313 { _XDATA
, STYP_XDATA
},
314 { _LIB
, STYP_ECOFF_LIB
},
316 { _HASH
, STYP_HASH
},
317 { _DYNAMIC
, STYP_DYNAMIC
},
318 { _LIBLIST
, STYP_LIBLIST
},
319 { _RELDYN
, STYP_RELDYN
},
320 { _CONFLIC
, STYP_CONFLIC
},
321 { _DYNSTR
, STYP_DYNSTR
},
322 { _DYNSYM
, STYP_DYNSYM
},
323 { _RCONST
, STYP_RCONST
}
327 for (i
= 0; i
< ARRAY_SIZE (styp_flags
); i
++)
328 if (streq (name
, styp_flags
[i
].name
))
330 styp
= styp_flags
[i
].flags
;
336 if (streq (name
, _COMMENT
))
339 flags
&=~ SEC_NEVER_LOAD
;
341 else if (flags
& SEC_CODE
)
343 else if (flags
& SEC_DATA
)
345 else if (flags
& SEC_READONLY
)
347 else if (flags
& SEC_LOAD
)
353 if (flags
& SEC_NEVER_LOAD
)
359 /* Get the BFD flags to use for a section. */
362 _bfd_ecoff_styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
364 const char *name ATTRIBUTE_UNUSED
,
365 asection
*section ATTRIBUTE_UNUSED
,
366 flagword
* flags_ptr
)
368 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
369 long styp_flags
= internal_s
->s_flags
;
370 flagword sec_flags
= 0;
372 if (styp_flags
& STYP_NOLOAD
)
373 sec_flags
|= SEC_NEVER_LOAD
;
375 /* For 386 COFF, at least, an unloadable text or data section is
376 actually a shared library section. */
377 if ((styp_flags
& STYP_TEXT
)
378 || (styp_flags
& STYP_ECOFF_INIT
)
379 || (styp_flags
& STYP_ECOFF_FINI
)
380 || (styp_flags
& STYP_DYNAMIC
)
381 || (styp_flags
& STYP_LIBLIST
)
382 || (styp_flags
& STYP_RELDYN
)
383 || styp_flags
== STYP_CONFLIC
384 || (styp_flags
& STYP_DYNSTR
)
385 || (styp_flags
& STYP_DYNSYM
)
386 || (styp_flags
& STYP_HASH
))
388 if (sec_flags
& SEC_NEVER_LOAD
)
389 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
391 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
393 else if ((styp_flags
& STYP_DATA
)
394 || (styp_flags
& STYP_RDATA
)
395 || (styp_flags
& STYP_SDATA
)
396 || styp_flags
== STYP_PDATA
397 || styp_flags
== STYP_XDATA
398 || (styp_flags
& STYP_GOT
)
399 || styp_flags
== STYP_RCONST
)
401 if (sec_flags
& SEC_NEVER_LOAD
)
402 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
404 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
405 if ((styp_flags
& STYP_RDATA
)
406 || styp_flags
== STYP_PDATA
407 || styp_flags
== STYP_RCONST
)
408 sec_flags
|= SEC_READONLY
;
410 else if ((styp_flags
& STYP_BSS
)
411 || (styp_flags
& STYP_SBSS
))
412 sec_flags
|= SEC_ALLOC
;
413 else if ((styp_flags
& STYP_INFO
) || styp_flags
== STYP_COMMENT
)
414 sec_flags
|= SEC_NEVER_LOAD
;
415 else if ((styp_flags
& STYP_LITA
)
416 || (styp_flags
& STYP_LIT8
)
417 || (styp_flags
& STYP_LIT4
))
418 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
419 else if (styp_flags
& STYP_ECOFF_LIB
)
420 sec_flags
|= SEC_COFF_SHARED_LIBRARY
;
422 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
424 * flags_ptr
= sec_flags
;
428 /* Read in the symbolic header for an ECOFF object file. */
431 ecoff_slurp_symbolic_header (bfd
*abfd
)
433 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
434 bfd_size_type external_hdr_size
;
436 HDRR
*internal_symhdr
;
438 /* See if we've already read it in. */
439 if (ecoff_data (abfd
)->debug_info
.symbolic_header
.magic
==
440 backend
->debug_swap
.sym_magic
)
443 /* See whether there is a symbolic header. */
444 if (ecoff_data (abfd
)->sym_filepos
== 0)
446 bfd_get_symcount (abfd
) = 0;
450 /* At this point bfd_get_symcount (abfd) holds the number of symbols
451 as read from the file header, but on ECOFF this is always the
452 size of the symbolic information header. It would be cleaner to
453 handle this when we first read the file in coffgen.c. */
454 external_hdr_size
= backend
->debug_swap
.external_hdr_size
;
455 if (bfd_get_symcount (abfd
) != external_hdr_size
)
457 bfd_set_error (bfd_error_bad_value
);
461 /* Read the symbolic information header. */
462 raw
= bfd_malloc (external_hdr_size
);
466 if (bfd_seek (abfd
, ecoff_data (abfd
)->sym_filepos
, SEEK_SET
) != 0
467 || bfd_bread (raw
, external_hdr_size
, abfd
) != external_hdr_size
)
469 internal_symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
470 (*backend
->debug_swap
.swap_hdr_in
) (abfd
, raw
, internal_symhdr
);
472 if (internal_symhdr
->magic
!= backend
->debug_swap
.sym_magic
)
474 bfd_set_error (bfd_error_bad_value
);
478 /* Now we can get the correct number of symbols. */
479 bfd_get_symcount (abfd
) = (internal_symhdr
->isymMax
480 + internal_symhdr
->iextMax
);
491 /* Read in and swap the important symbolic information for an ECOFF
492 object file. This is called by gdb via the read_debug_info entry
493 point in the backend structure. */
496 _bfd_ecoff_slurp_symbolic_info (bfd
*abfd
,
497 asection
*ignore ATTRIBUTE_UNUSED
,
498 struct ecoff_debug_info
*debug
)
500 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
501 HDRR
*internal_symhdr
;
502 bfd_size_type raw_base
;
503 bfd_size_type raw_size
;
505 bfd_size_type external_fdr_size
;
509 bfd_size_type raw_end
;
510 bfd_size_type cb_end
;
514 BFD_ASSERT (debug
== &ecoff_data (abfd
)->debug_info
);
516 /* Check whether we've already gotten it, and whether there's any to
518 if (ecoff_data (abfd
)->raw_syments
!= NULL
)
520 if (ecoff_data (abfd
)->sym_filepos
== 0)
522 bfd_get_symcount (abfd
) = 0;
526 if (! ecoff_slurp_symbolic_header (abfd
))
529 internal_symhdr
= &debug
->symbolic_header
;
531 /* Read all the symbolic information at once. */
532 raw_base
= (ecoff_data (abfd
)->sym_filepos
533 + backend
->debug_swap
.external_hdr_size
);
535 /* Alpha ecoff makes the determination of raw_size difficult. It has
536 an undocumented debug data section between the symhdr and the first
537 documented section. And the ordering of the sections varies between
538 statically and dynamically linked executables.
539 If bfd supports SEEK_END someday, this code could be simplified. */
542 #define UPDATE_RAW_END(start, count, size) \
543 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
544 if (cb_end > raw_end) \
547 UPDATE_RAW_END (cbLineOffset
, cbLine
, sizeof (unsigned char));
548 UPDATE_RAW_END (cbDnOffset
, idnMax
, backend
->debug_swap
.external_dnr_size
);
549 UPDATE_RAW_END (cbPdOffset
, ipdMax
, backend
->debug_swap
.external_pdr_size
);
550 UPDATE_RAW_END (cbSymOffset
, isymMax
, backend
->debug_swap
.external_sym_size
);
551 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
552 optimization symtab, not the number of entries. */
553 UPDATE_RAW_END (cbOptOffset
, ioptMax
, sizeof (char));
554 UPDATE_RAW_END (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
555 UPDATE_RAW_END (cbSsOffset
, issMax
, sizeof (char));
556 UPDATE_RAW_END (cbSsExtOffset
, issExtMax
, sizeof (char));
557 UPDATE_RAW_END (cbFdOffset
, ifdMax
, backend
->debug_swap
.external_fdr_size
);
558 UPDATE_RAW_END (cbRfdOffset
, crfd
, backend
->debug_swap
.external_rfd_size
);
559 UPDATE_RAW_END (cbExtOffset
, iextMax
, backend
->debug_swap
.external_ext_size
);
561 #undef UPDATE_RAW_END
563 raw_size
= raw_end
- raw_base
;
566 ecoff_data (abfd
)->sym_filepos
= 0;
569 raw
= bfd_alloc (abfd
, raw_size
);
573 pos
= ecoff_data (abfd
)->sym_filepos
;
574 pos
+= backend
->debug_swap
.external_hdr_size
;
575 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
576 || bfd_bread (raw
, raw_size
, abfd
) != raw_size
)
578 bfd_release (abfd
, raw
);
582 ecoff_data (abfd
)->raw_syments
= raw
;
584 /* Get pointers for the numeric offsets in the HDRR structure. */
585 #define FIX(off1, off2, type) \
586 if (internal_symhdr->off1 == 0) \
587 debug->off2 = NULL; \
589 debug->off2 = (type) ((char *) raw \
590 + (internal_symhdr->off1 \
593 FIX (cbLineOffset
, line
, unsigned char *);
594 FIX (cbDnOffset
, external_dnr
, void *);
595 FIX (cbPdOffset
, external_pdr
, void *);
596 FIX (cbSymOffset
, external_sym
, void *);
597 FIX (cbOptOffset
, external_opt
, void *);
598 FIX (cbAuxOffset
, external_aux
, union aux_ext
*);
599 FIX (cbSsOffset
, ss
, char *);
600 FIX (cbSsExtOffset
, ssext
, char *);
601 FIX (cbFdOffset
, external_fdr
, void *);
602 FIX (cbRfdOffset
, external_rfd
, void *);
603 FIX (cbExtOffset
, external_ext
, void *);
606 /* I don't want to always swap all the data, because it will just
607 waste time and most programs will never look at it. The only
608 time the linker needs most of the debugging information swapped
609 is when linking big-endian and little-endian MIPS object files
610 together, which is not a common occurrence.
612 We need to look at the fdr to deal with a lot of information in
613 the symbols, so we swap them here. */
614 amt
= internal_symhdr
->ifdMax
;
615 amt
*= sizeof (struct fdr
);
616 debug
->fdr
= (FDR
*) bfd_alloc (abfd
, amt
);
617 if (debug
->fdr
== NULL
)
619 external_fdr_size
= backend
->debug_swap
.external_fdr_size
;
620 fdr_ptr
= debug
->fdr
;
621 fraw_src
= (char *) debug
->external_fdr
;
622 fraw_end
= fraw_src
+ internal_symhdr
->ifdMax
* external_fdr_size
;
623 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
624 (*backend
->debug_swap
.swap_fdr_in
) (abfd
, (void *) fraw_src
, fdr_ptr
);
629 /* ECOFF symbol table routines. The ECOFF symbol table is described
630 in gcc/mips-tfile.c. */
632 /* ECOFF uses two common sections. One is the usual one, and the
633 other is for small objects. All the small objects are kept
634 together, and then referenced via the gp pointer, which yields
635 faster assembler code. This is what we use for the small common
637 static asection ecoff_scom_section
;
638 static asymbol ecoff_scom_symbol
;
639 static asymbol
*ecoff_scom_symbol_ptr
;
641 /* Create an empty symbol. */
644 _bfd_ecoff_make_empty_symbol (bfd
*abfd
)
646 ecoff_symbol_type
*new_symbol
;
647 bfd_size_type amt
= sizeof (ecoff_symbol_type
);
649 new_symbol
= (ecoff_symbol_type
*) bfd_zalloc (abfd
, amt
);
650 if (new_symbol
== NULL
)
652 new_symbol
->symbol
.section
= NULL
;
653 new_symbol
->fdr
= NULL
;
654 new_symbol
->local
= FALSE
;
655 new_symbol
->native
= NULL
;
656 new_symbol
->symbol
.the_bfd
= abfd
;
657 return &new_symbol
->symbol
;
660 /* Set the BFD flags and section for an ECOFF symbol. */
663 ecoff_set_symbol_info (bfd
*abfd
,
669 asym
->the_bfd
= abfd
;
670 asym
->value
= ecoff_sym
->value
;
671 asym
->section
= &bfd_debug_section
;
674 /* Most symbol types are just for debugging. */
675 switch (ecoff_sym
->st
)
684 if (ECOFF_IS_STAB (ecoff_sym
))
686 asym
->flags
= BSF_DEBUGGING
;
691 asym
->flags
= BSF_DEBUGGING
;
696 asym
->flags
= BSF_EXPORT
| BSF_WEAK
;
698 asym
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
701 asym
->flags
= BSF_LOCAL
;
702 /* Normally, a local stProc symbol will have a corresponding
703 external symbol. We mark the local symbol as a debugging
704 symbol, in order to prevent nm from printing both out.
705 Similarly, we mark stLabel and stabs symbols as debugging
706 symbols. In both cases, we do want to set the value
707 correctly based on the symbol class. */
708 if (ecoff_sym
->st
== stProc
709 || ecoff_sym
->st
== stLabel
710 || ECOFF_IS_STAB (ecoff_sym
))
711 asym
->flags
|= BSF_DEBUGGING
;
714 if (ecoff_sym
->st
== stProc
|| ecoff_sym
->st
== stStaticProc
)
715 asym
->flags
|= BSF_FUNCTION
;
717 switch (ecoff_sym
->sc
)
720 /* Used for compiler generated labels. Leave them in the
721 debugging section, and mark them as local. If BSF_DEBUGGING
722 is set, then nm does not display them for some reason. If no
723 flags are set then the linker whines about them. */
724 asym
->flags
= BSF_LOCAL
;
727 asym
->section
= bfd_make_section_old_way (abfd
, _TEXT
);
728 asym
->value
-= asym
->section
->vma
;
731 asym
->section
= bfd_make_section_old_way (abfd
, _DATA
);
732 asym
->value
-= asym
->section
->vma
;
735 asym
->section
= bfd_make_section_old_way (abfd
, _BSS
);
736 asym
->value
-= asym
->section
->vma
;
739 asym
->flags
= BSF_DEBUGGING
;
742 asym
->section
= bfd_abs_section_ptr
;
745 asym
->section
= bfd_und_section_ptr
;
755 asym
->flags
= BSF_DEBUGGING
;
758 asym
->section
= bfd_make_section_old_way (abfd
, ".sdata");
759 asym
->value
-= asym
->section
->vma
;
762 asym
->section
= bfd_make_section_old_way (abfd
, ".sbss");
763 asym
->value
-= asym
->section
->vma
;
766 asym
->section
= bfd_make_section_old_way (abfd
, ".rdata");
767 asym
->value
-= asym
->section
->vma
;
770 asym
->flags
= BSF_DEBUGGING
;
773 if (asym
->value
> ecoff_data (abfd
)->gp_size
)
775 asym
->section
= bfd_com_section_ptr
;
781 if (ecoff_scom_section
.name
== NULL
)
783 /* Initialize the small common section. */
784 ecoff_scom_section
.name
= SCOMMON
;
785 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
786 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
787 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
788 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
789 ecoff_scom_symbol
.name
= SCOMMON
;
790 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
791 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
792 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
794 asym
->section
= &ecoff_scom_section
;
799 asym
->flags
= BSF_DEBUGGING
;
802 asym
->section
= bfd_und_section_ptr
;
807 asym
->section
= bfd_make_section_old_way (abfd
, ".init");
808 asym
->value
-= asym
->section
->vma
;
813 asym
->flags
= BSF_DEBUGGING
;
816 asym
->section
= bfd_make_section_old_way (abfd
, ".fini");
817 asym
->value
-= asym
->section
->vma
;
820 asym
->section
= bfd_make_section_old_way (abfd
, ".rconst");
821 asym
->value
-= asym
->section
->vma
;
827 /* Look for special constructors symbols and make relocation entries
828 in a special construction section. These are produced by the
829 -fgnu-linker argument to g++. */
830 if (ECOFF_IS_STAB (ecoff_sym
))
832 switch (ECOFF_UNMARK_STAB (ecoff_sym
->index
))
841 /* Mark the symbol as a constructor. */
842 asym
->flags
|= BSF_CONSTRUCTOR
;
849 /* Read an ECOFF symbol table. */
852 _bfd_ecoff_slurp_symbol_table (bfd
*abfd
)
854 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
855 const bfd_size_type external_ext_size
856 = backend
->debug_swap
.external_ext_size
;
857 const bfd_size_type external_sym_size
858 = backend
->debug_swap
.external_sym_size
;
859 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
860 = backend
->debug_swap
.swap_ext_in
;
861 void (* const swap_sym_in
) (bfd
*, void *, SYMR
*)
862 = backend
->debug_swap
.swap_sym_in
;
863 bfd_size_type internal_size
;
864 ecoff_symbol_type
*internal
;
865 ecoff_symbol_type
*internal_ptr
;
871 /* If we've already read in the symbol table, do nothing. */
872 if (ecoff_data (abfd
)->canonical_symbols
!= NULL
)
875 /* Get the symbolic information. */
876 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
877 &ecoff_data (abfd
)->debug_info
))
879 if (bfd_get_symcount (abfd
) == 0)
882 internal_size
= bfd_get_symcount (abfd
);
883 internal_size
*= sizeof (ecoff_symbol_type
);
884 internal
= (ecoff_symbol_type
*) bfd_alloc (abfd
, internal_size
);
885 if (internal
== NULL
)
888 internal_ptr
= internal
;
889 eraw_src
= (char *) ecoff_data (abfd
)->debug_info
.external_ext
;
891 + (ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
892 * external_ext_size
));
893 for (; eraw_src
< eraw_end
; eraw_src
+= external_ext_size
, internal_ptr
++)
897 (*swap_ext_in
) (abfd
, (void *) eraw_src
, &internal_esym
);
898 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ssext
899 + internal_esym
.asym
.iss
);
900 if (!ecoff_set_symbol_info (abfd
, &internal_esym
.asym
,
901 &internal_ptr
->symbol
, 1,
902 internal_esym
.weakext
))
904 /* The alpha uses a negative ifd field for section symbols. */
905 if (internal_esym
.ifd
>= 0)
906 internal_ptr
->fdr
= (ecoff_data (abfd
)->debug_info
.fdr
907 + internal_esym
.ifd
);
909 internal_ptr
->fdr
= NULL
;
910 internal_ptr
->local
= FALSE
;
911 internal_ptr
->native
= (void *) eraw_src
;
914 /* The local symbols must be accessed via the fdr's, because the
915 string and aux indices are relative to the fdr information. */
916 fdr_ptr
= ecoff_data (abfd
)->debug_info
.fdr
;
917 fdr_end
= fdr_ptr
+ ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
;
918 for (; fdr_ptr
< fdr_end
; fdr_ptr
++)
923 lraw_src
= ((char *) ecoff_data (abfd
)->debug_info
.external_sym
924 + fdr_ptr
->isymBase
* external_sym_size
);
925 lraw_end
= lraw_src
+ fdr_ptr
->csym
* external_sym_size
;
928 lraw_src
+= external_sym_size
, internal_ptr
++)
932 (*swap_sym_in
) (abfd
, (void *) lraw_src
, &internal_sym
);
933 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ss
936 if (!ecoff_set_symbol_info (abfd
, &internal_sym
,
937 &internal_ptr
->symbol
, 0, 0))
939 internal_ptr
->fdr
= fdr_ptr
;
940 internal_ptr
->local
= TRUE
;
941 internal_ptr
->native
= (void *) lraw_src
;
945 ecoff_data (abfd
)->canonical_symbols
= internal
;
950 /* Return the amount of space needed for the canonical symbols. */
953 _bfd_ecoff_get_symtab_upper_bound (bfd
*abfd
)
955 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
956 &ecoff_data (abfd
)->debug_info
))
959 if (bfd_get_symcount (abfd
) == 0)
962 return (bfd_get_symcount (abfd
) + 1) * (sizeof (ecoff_symbol_type
*));
965 /* Get the canonical symbols. */
968 _bfd_ecoff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
970 unsigned int counter
= 0;
971 ecoff_symbol_type
*symbase
;
972 ecoff_symbol_type
**location
= (ecoff_symbol_type
**) alocation
;
974 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
976 if (bfd_get_symcount (abfd
) == 0)
979 symbase
= ecoff_data (abfd
)->canonical_symbols
;
980 while (counter
< bfd_get_symcount (abfd
))
982 *(location
++) = symbase
++;
986 return bfd_get_symcount (abfd
);
989 /* Turn ECOFF type information into a printable string.
990 ecoff_emit_aggregate and ecoff_type_to_string are from
991 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
993 /* Write aggregate information to a string. */
996 ecoff_emit_aggregate (bfd
*abfd
,
1003 const struct ecoff_debug_swap
* const debug_swap
=
1004 &ecoff_backend (abfd
)->debug_swap
;
1005 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1006 unsigned int ifd
= rndx
->rfd
;
1007 unsigned int indx
= rndx
->index
;
1013 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1014 struct return type of a procedure compiled without -g. */
1015 if (ifd
== 0xffffffff
1016 || (rndx
->rfd
== 0xfff && indx
== 0))
1017 name
= "<undefined>";
1018 else if (indx
== indexNil
)
1024 if (debug_info
->external_rfd
== NULL
)
1025 fdr
= debug_info
->fdr
+ ifd
;
1030 (*debug_swap
->swap_rfd_in
) (abfd
,
1031 ((char *) debug_info
->external_rfd
1032 + ((fdr
->rfdBase
+ ifd
)
1033 * debug_swap
->external_rfd_size
)),
1035 fdr
= debug_info
->fdr
+ rfd
;
1038 indx
+= fdr
->isymBase
;
1040 (*debug_swap
->swap_sym_in
) (abfd
,
1041 ((char *) debug_info
->external_sym
1042 + indx
* debug_swap
->external_sym_size
),
1045 name
= debug_info
->ss
+ fdr
->issBase
+ sym
.iss
;
1049 "%s %s { ifd = %u, index = %lu }",
1051 ((unsigned long) indx
1052 + debug_info
->symbolic_header
.iextMax
));
1055 /* Convert the type information to string format. */
1058 ecoff_type_to_string (bfd
*abfd
, FDR
*fdr
, unsigned int indx
)
1060 union aux_ext
*aux_ptr
;
1070 unsigned int basic_type
;
1073 static char buffer2
[1024];
1078 aux_ptr
= ecoff_data (abfd
)->debug_info
.external_aux
+ fdr
->iauxBase
;
1079 bigendian
= fdr
->fBigendian
;
1081 for (i
= 0; i
< 7; i
++)
1083 qualifiers
[i
].low_bound
= 0;
1084 qualifiers
[i
].high_bound
= 0;
1085 qualifiers
[i
].stride
= 0;
1088 if (AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
]) == (bfd_vma
) -1)
1089 return "-1 (no type)";
1090 _bfd_ecoff_swap_tir_in (bigendian
, &aux_ptr
[indx
++].a_ti
, &u
.ti
);
1092 basic_type
= u
.ti
.bt
;
1093 qualifiers
[0].type
= u
.ti
.tq0
;
1094 qualifiers
[1].type
= u
.ti
.tq1
;
1095 qualifiers
[2].type
= u
.ti
.tq2
;
1096 qualifiers
[3].type
= u
.ti
.tq3
;
1097 qualifiers
[4].type
= u
.ti
.tq4
;
1098 qualifiers
[5].type
= u
.ti
.tq5
;
1099 qualifiers
[6].type
= tqNil
;
1101 /* Go get the basic type. */
1104 case btNil
: /* Undefined. */
1108 case btAdr
: /* Address - integer same size as pointer. */
1109 strcpy (p1
, "address");
1112 case btChar
: /* Character. */
1113 strcpy (p1
, "char");
1116 case btUChar
: /* Unsigned character. */
1117 strcpy (p1
, "unsigned char");
1120 case btShort
: /* Short. */
1121 strcpy (p1
, "short");
1124 case btUShort
: /* Unsigned short. */
1125 strcpy (p1
, "unsigned short");
1128 case btInt
: /* Int. */
1132 case btUInt
: /* Unsigned int. */
1133 strcpy (p1
, "unsigned int");
1136 case btLong
: /* Long. */
1137 strcpy (p1
, "long");
1140 case btULong
: /* Unsigned long. */
1141 strcpy (p1
, "unsigned long");
1144 case btFloat
: /* Float (real). */
1145 strcpy (p1
, "float");
1148 case btDouble
: /* Double (real). */
1149 strcpy (p1
, "double");
1152 /* Structures add 1-2 aux words:
1153 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1154 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1156 case btStruct
: /* Structure (Record). */
1157 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1158 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1159 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1161 indx
++; /* Skip aux words. */
1164 /* Unions add 1-2 aux words:
1165 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1166 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1168 case btUnion
: /* Union. */
1169 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1170 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1171 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1173 indx
++; /* Skip aux words. */
1176 /* Enumerations add 1-2 aux words:
1177 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1178 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1180 case btEnum
: /* Enumeration. */
1181 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1182 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1183 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1185 indx
++; /* Skip aux words. */
1188 case btTypedef
: /* Defined via a typedef, isymRef points. */
1189 strcpy (p1
, "typedef");
1192 case btRange
: /* Subrange of int. */
1193 strcpy (p1
, "subrange");
1196 case btSet
: /* Pascal sets. */
1200 case btComplex
: /* Fortran complex. */
1201 strcpy (p1
, "complex");
1204 case btDComplex
: /* Fortran double complex. */
1205 strcpy (p1
, "double complex");
1208 case btIndirect
: /* Forward or unnamed typedef. */
1209 strcpy (p1
, "forward/unamed typedef");
1212 case btFixedDec
: /* Fixed Decimal. */
1213 strcpy (p1
, "fixed decimal");
1216 case btFloatDec
: /* Float Decimal. */
1217 strcpy (p1
, "float decimal");
1220 case btString
: /* Varying Length Character String. */
1221 strcpy (p1
, "string");
1224 case btBit
: /* Aligned Bit String. */
1228 case btPicture
: /* Picture. */
1229 strcpy (p1
, "picture");
1232 case btVoid
: /* Void. */
1233 strcpy (p1
, "void");
1237 sprintf (p1
, _("Unknown basic type %d"), (int) basic_type
);
1241 p1
+= strlen (buffer1
);
1243 /* If this is a bitfield, get the bitsize. */
1248 bitsize
= AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
++]);
1249 sprintf (p1
, " : %d", bitsize
);
1250 p1
+= strlen (buffer1
);
1253 /* Deal with any qualifiers. */
1254 if (qualifiers
[0].type
!= tqNil
)
1256 /* Snarf up any array bounds in the correct order. Arrays
1257 store 5 successive words in the aux. table:
1258 word 0 RNDXR to type of the bounds (ie, int)
1259 word 1 Current file descriptor index
1261 word 3 high bound (or -1 if [])
1262 word 4 stride size in bits. */
1263 for (i
= 0; i
< 7; i
++)
1265 if (qualifiers
[i
].type
== tqArray
)
1267 qualifiers
[i
].low_bound
=
1268 AUX_GET_DNLOW (bigendian
, &aux_ptr
[indx
+2]);
1269 qualifiers
[i
].high_bound
=
1270 AUX_GET_DNHIGH (bigendian
, &aux_ptr
[indx
+3]);
1271 qualifiers
[i
].stride
=
1272 AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
+4]);
1277 /* Now print out the qualifiers. */
1278 for (i
= 0; i
< 6; i
++)
1280 switch (qualifiers
[i
].type
)
1287 strcpy (p2
, "ptr to ");
1288 p2
+= sizeof ("ptr to ")-1;
1292 strcpy (p2
, "volatile ");
1293 p2
+= sizeof ("volatile ")-1;
1297 strcpy (p2
, "far ");
1298 p2
+= sizeof ("far ")-1;
1302 strcpy (p2
, "func. ret. ");
1303 p2
+= sizeof ("func. ret. ");
1308 int first_array
= i
;
1311 /* Print array bounds reversed (ie, in the order the C
1312 programmer writes them). C is such a fun language.... */
1313 while (i
< 5 && qualifiers
[i
+1].type
== tqArray
)
1316 for (j
= i
; j
>= first_array
; j
--)
1318 strcpy (p2
, "array [");
1319 p2
+= sizeof ("array [")-1;
1320 if (qualifiers
[j
].low_bound
!= 0)
1322 "%ld:%ld {%ld bits}",
1323 (long) qualifiers
[j
].low_bound
,
1324 (long) qualifiers
[j
].high_bound
,
1325 (long) qualifiers
[j
].stride
);
1327 else if (qualifiers
[j
].high_bound
!= -1)
1330 (long) (qualifiers
[j
].high_bound
+ 1),
1331 (long) (qualifiers
[j
].stride
));
1334 sprintf (p2
, " {%ld bits}", (long) (qualifiers
[j
].stride
));
1337 strcpy (p2
, "] of ");
1338 p2
+= sizeof ("] of ")-1;
1346 strcpy (p2
, buffer1
);
1350 /* Return information about ECOFF symbol SYMBOL in RET. */
1353 _bfd_ecoff_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
1357 bfd_symbol_info (symbol
, ret
);
1360 /* Return whether this is a local label. */
1363 _bfd_ecoff_bfd_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1366 return name
[0] == '$';
1369 /* Print information about an ECOFF symbol. */
1372 _bfd_ecoff_print_symbol (bfd
*abfd
,
1375 bfd_print_symbol_type how
)
1377 const struct ecoff_debug_swap
* const debug_swap
1378 = &ecoff_backend (abfd
)->debug_swap
;
1379 FILE *file
= (FILE *)filep
;
1383 case bfd_print_symbol_name
:
1384 fprintf (file
, "%s", symbol
->name
);
1386 case bfd_print_symbol_more
:
1387 if (ecoffsymbol (symbol
)->local
)
1391 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1393 fprintf (file
, "ecoff local ");
1394 fprintf_vma (file
, (bfd_vma
) ecoff_sym
.value
);
1395 fprintf (file
, " %x %x", (unsigned) ecoff_sym
.st
,
1396 (unsigned) ecoff_sym
.sc
);
1402 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1404 fprintf (file
, "ecoff extern ");
1405 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1406 fprintf (file
, " %x %x", (unsigned) ecoff_ext
.asym
.st
,
1407 (unsigned) ecoff_ext
.asym
.sc
);
1410 case bfd_print_symbol_all
:
1411 /* Print out the symbols in a reasonable way. */
1420 if (ecoffsymbol (symbol
)->local
)
1422 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1425 pos
= ((((char *) ecoffsymbol (symbol
)->native
1426 - (char *) ecoff_data (abfd
)->debug_info
.external_sym
)
1427 / debug_swap
->external_sym_size
)
1428 + ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
);
1435 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1438 pos
= (((char *) ecoffsymbol (symbol
)->native
1439 - (char *) ecoff_data (abfd
)->debug_info
.external_ext
)
1440 / debug_swap
->external_ext_size
);
1441 jmptbl
= ecoff_ext
.jmptbl
? 'j' : ' ';
1442 cobol_main
= ecoff_ext
.cobol_main
? 'c' : ' ';
1443 weakext
= ecoff_ext
.weakext
? 'w' : ' ';
1446 fprintf (file
, "[%3d] %c ",
1448 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1449 fprintf (file
, " st %x sc %x indx %x %c%c%c %s",
1450 (unsigned) ecoff_ext
.asym
.st
,
1451 (unsigned) ecoff_ext
.asym
.sc
,
1452 (unsigned) ecoff_ext
.asym
.index
,
1453 jmptbl
, cobol_main
, weakext
,
1456 if (ecoffsymbol (symbol
)->fdr
!= NULL
1457 && ecoff_ext
.asym
.index
!= indexNil
)
1462 bfd_size_type sym_base
;
1463 union aux_ext
*aux_base
;
1465 fdr
= ecoffsymbol (symbol
)->fdr
;
1466 indx
= ecoff_ext
.asym
.index
;
1468 /* sym_base is used to map the fdr relative indices which
1469 appear in the file to the position number which we are
1471 sym_base
= fdr
->isymBase
;
1472 if (ecoffsymbol (symbol
)->local
)
1474 ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
1476 /* aux_base is the start of the aux entries for this file;
1477 asym.index is an offset from this. */
1478 aux_base
= (ecoff_data (abfd
)->debug_info
.external_aux
1481 /* The aux entries are stored in host byte order; the
1482 order is indicated by a bit in the fdr. */
1483 bigendian
= fdr
->fBigendian
;
1485 /* This switch is basically from gcc/mips-tdump.c. */
1486 switch (ecoff_ext
.asym
.st
)
1494 fprintf (file
, _("\n End+1 symbol: %ld"),
1495 (long) (indx
+ sym_base
));
1499 if (ecoff_ext
.asym
.sc
== scText
1500 || ecoff_ext
.asym
.sc
== scInfo
)
1501 fprintf (file
, _("\n First symbol: %ld"),
1502 (long) (indx
+ sym_base
));
1504 fprintf (file
, _("\n First symbol: %ld"),
1506 (AUX_GET_ISYM (bigendian
,
1507 &aux_base
[ecoff_ext
.asym
.index
])
1513 if (ECOFF_IS_STAB (&ecoff_ext
.asym
))
1515 else if (ecoffsymbol (symbol
)->local
)
1516 fprintf (file
, _("\n End+1 symbol: %-7ld Type: %s"),
1518 (AUX_GET_ISYM (bigendian
,
1519 &aux_base
[ecoff_ext
.asym
.index
])
1521 ecoff_type_to_string (abfd
, fdr
, indx
+ 1));
1523 fprintf (file
, _("\n Local symbol: %ld"),
1526 + (ecoff_data (abfd
)
1527 ->debug_info
.symbolic_header
.iextMax
)));
1531 fprintf (file
, _("\n struct; End+1 symbol: %ld"),
1532 (long) (indx
+ sym_base
));
1536 fprintf (file
, _("\n union; End+1 symbol: %ld"),
1537 (long) (indx
+ sym_base
));
1541 fprintf (file
, _("\n enum; End+1 symbol: %ld"),
1542 (long) (indx
+ sym_base
));
1546 if (! ECOFF_IS_STAB (&ecoff_ext
.asym
))
1547 fprintf (file
, _("\n Type: %s"),
1548 ecoff_type_to_string (abfd
, fdr
, indx
));
1557 /* Read in the relocs for a section. */
1560 ecoff_slurp_reloc_table (bfd
*abfd
,
1564 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1565 arelent
*internal_relocs
;
1566 bfd_size_type external_reloc_size
;
1568 char *external_relocs
;
1572 if (section
->relocation
!= NULL
1573 || section
->reloc_count
== 0
1574 || (section
->flags
& SEC_CONSTRUCTOR
) != 0)
1577 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1580 amt
= section
->reloc_count
;
1581 amt
*= sizeof (arelent
);
1582 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
1584 external_reloc_size
= backend
->external_reloc_size
;
1585 amt
= external_reloc_size
* section
->reloc_count
;
1586 external_relocs
= (char *) bfd_alloc (abfd
, amt
);
1587 if (internal_relocs
== NULL
|| external_relocs
== NULL
)
1589 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1591 if (bfd_bread (external_relocs
, amt
, abfd
) != amt
)
1594 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1596 struct internal_reloc intern
;
1598 (*backend
->swap_reloc_in
) (abfd
,
1599 external_relocs
+ i
* external_reloc_size
,
1602 if (intern
.r_extern
)
1604 /* r_symndx is an index into the external symbols. */
1605 BFD_ASSERT (intern
.r_symndx
>= 0
1607 < (ecoff_data (abfd
)
1608 ->debug_info
.symbolic_header
.iextMax
)));
1609 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1612 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1613 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1615 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1620 const char *sec_name
;
1623 /* r_symndx is a section key. */
1624 switch (intern
.r_symndx
)
1626 case RELOC_SECTION_TEXT
: sec_name
= _TEXT
; break;
1627 case RELOC_SECTION_RDATA
: sec_name
= _RDATA
; break;
1628 case RELOC_SECTION_DATA
: sec_name
= _DATA
; break;
1629 case RELOC_SECTION_SDATA
: sec_name
= _SDATA
; break;
1630 case RELOC_SECTION_SBSS
: sec_name
= _SBSS
; break;
1631 case RELOC_SECTION_BSS
: sec_name
= _BSS
; break;
1632 case RELOC_SECTION_INIT
: sec_name
= _INIT
; break;
1633 case RELOC_SECTION_LIT8
: sec_name
= _LIT8
; break;
1634 case RELOC_SECTION_LIT4
: sec_name
= _LIT4
; break;
1635 case RELOC_SECTION_XDATA
: sec_name
= _XDATA
; break;
1636 case RELOC_SECTION_PDATA
: sec_name
= _PDATA
; break;
1637 case RELOC_SECTION_FINI
: sec_name
= _FINI
; break;
1638 case RELOC_SECTION_LITA
: sec_name
= _LITA
; break;
1639 case RELOC_SECTION_RCONST
: sec_name
= _RCONST
; break;
1643 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1646 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1648 rptr
->addend
= - bfd_get_section_vma (abfd
, sec
);
1651 rptr
->address
= intern
.r_vaddr
- bfd_get_section_vma (abfd
, section
);
1653 /* Let the backend select the howto field and do any other
1654 required processing. */
1655 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1658 bfd_release (abfd
, external_relocs
);
1660 section
->relocation
= internal_relocs
;
1665 /* Get a canonical list of relocs. */
1668 _bfd_ecoff_canonicalize_reloc (bfd
*abfd
,
1675 if (section
->flags
& SEC_CONSTRUCTOR
)
1677 arelent_chain
*chain
;
1679 /* This section has relocs made up by us, not the file, so take
1680 them out of their chain and place them into the data area
1682 for (count
= 0, chain
= section
->constructor_chain
;
1683 count
< section
->reloc_count
;
1684 count
++, chain
= chain
->next
)
1685 *relptr
++ = &chain
->relent
;
1691 if (! ecoff_slurp_reloc_table (abfd
, section
, symbols
))
1694 tblptr
= section
->relocation
;
1696 for (count
= 0; count
< section
->reloc_count
; count
++)
1697 *relptr
++ = tblptr
++;
1702 return section
->reloc_count
;
1705 /* Provided a BFD, a section and an offset into the section, calculate
1706 and return the name of the source file and the line nearest to the
1710 _bfd_ecoff_find_nearest_line (bfd
*abfd
,
1712 asymbol
**ignore_symbols ATTRIBUTE_UNUSED
,
1714 const char **filename_ptr
,
1715 const char **functionname_ptr
,
1716 unsigned int *retline_ptr
)
1718 const struct ecoff_debug_swap
* const debug_swap
1719 = &ecoff_backend (abfd
)->debug_swap
;
1720 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1721 struct ecoff_find_line
*line_info
;
1723 /* Make sure we have the FDR's. */
1724 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
, debug_info
)
1725 || bfd_get_symcount (abfd
) == 0)
1728 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1730 bfd_size_type amt
= sizeof (struct ecoff_find_line
);
1732 ecoff_data (abfd
)->find_line_info
=
1733 (struct ecoff_find_line
*) bfd_zalloc (abfd
, amt
);
1734 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1737 line_info
= ecoff_data (abfd
)->find_line_info
;
1739 return _bfd_ecoff_locate_line (abfd
, section
, offset
, debug_info
,
1740 debug_swap
, line_info
, filename_ptr
,
1741 functionname_ptr
, retline_ptr
);
1744 /* Copy private BFD data. This is called by objcopy and strip. We
1745 use it to copy the ECOFF debugging information from one BFD to the
1746 other. It would be theoretically possible to represent the ECOFF
1747 debugging information in the symbol table. However, it would be a
1748 lot of work, and there would be little gain (gas, gdb, and ld
1749 already access the ECOFF debugging information via the
1750 ecoff_debug_info structure, and that structure would have to be
1751 retained in order to support ECOFF debugging in MIPS ELF).
1753 The debugging information for the ECOFF external symbols comes from
1754 the symbol table, so this function only handles the other debugging
1758 _bfd_ecoff_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1760 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
1761 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
1763 asymbol
**sym_ptr_ptr
;
1767 /* We only want to copy information over if both BFD's use ECOFF
1769 if (bfd_get_flavour (ibfd
) != bfd_target_ecoff_flavour
1770 || bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
1773 /* Copy the GP value and the register masks. */
1774 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
1775 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
1776 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
1777 for (i
= 0; i
< 3; i
++)
1778 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
1780 /* Copy the version stamp. */
1781 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
1783 /* If there are no symbols, don't copy any debugging information. */
1784 c
= bfd_get_symcount (obfd
);
1785 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1786 if (c
== 0 || sym_ptr_ptr
== NULL
)
1789 /* See if there are any local symbols. */
1791 for (; c
> 0; c
--, sym_ptr_ptr
++)
1793 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
1802 /* There are some local symbols. We just bring over all the
1803 debugging information. FIXME: This is not quite the right
1804 thing to do. If the user has asked us to discard all
1805 debugging information, then we are probably going to wind up
1806 keeping it because there will probably be some local symbol
1807 which objcopy did not discard. We should actually break
1808 apart the debugging information and only keep that which
1809 applies to the symbols we want to keep. */
1810 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
1811 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
1812 oinfo
->line
= iinfo
->line
;
1814 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
1815 oinfo
->external_dnr
= iinfo
->external_dnr
;
1817 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
1818 oinfo
->external_pdr
= iinfo
->external_pdr
;
1820 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
1821 oinfo
->external_sym
= iinfo
->external_sym
;
1823 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
1824 oinfo
->external_opt
= iinfo
->external_opt
;
1826 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
1827 oinfo
->external_aux
= iinfo
->external_aux
;
1829 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
1830 oinfo
->ss
= iinfo
->ss
;
1832 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
1833 oinfo
->external_fdr
= iinfo
->external_fdr
;
1835 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
1836 oinfo
->external_rfd
= iinfo
->external_rfd
;
1840 /* We are discarding all the local symbol information. Look
1841 through the external symbols and remove all references to FDR
1842 or aux information. */
1843 c
= bfd_get_symcount (obfd
);
1844 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1845 for (; c
> 0; c
--, sym_ptr_ptr
++)
1849 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
1850 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
1852 esym
.asym
.index
= indexNil
;
1853 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
1854 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
1861 /* Set the architecture. The supported architecture is stored in the
1862 backend pointer. We always set the architecture anyhow, since many
1863 callers ignore the return value. */
1866 _bfd_ecoff_set_arch_mach (bfd
*abfd
,
1867 enum bfd_architecture arch
,
1868 unsigned long machine
)
1870 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1871 return arch
== ecoff_backend (abfd
)->arch
;
1874 /* Get the size of the section headers. */
1877 _bfd_ecoff_sizeof_headers (bfd
*abfd
,
1878 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1885 for (current
= abfd
->sections
;
1887 current
= current
->next
)
1890 ret
= (bfd_coff_filhsz (abfd
)
1891 + bfd_coff_aoutsz (abfd
)
1892 + c
* bfd_coff_scnhsz (abfd
));
1893 return BFD_ALIGN (ret
, 16);
1896 /* Get the contents of a section. */
1899 _bfd_ecoff_get_section_contents (bfd
*abfd
,
1903 bfd_size_type count
)
1905 return _bfd_generic_get_section_contents (abfd
, section
, location
,
1909 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
1910 called via qsort. */
1913 ecoff_sort_hdrs (const void * arg1
, const void * arg2
)
1915 const asection
*hdr1
= *(const asection
**) arg1
;
1916 const asection
*hdr2
= *(const asection
**) arg2
;
1918 if ((hdr1
->flags
& SEC_ALLOC
) != 0)
1920 if ((hdr2
->flags
& SEC_ALLOC
) == 0)
1925 if ((hdr2
->flags
& SEC_ALLOC
) != 0)
1928 if (hdr1
->vma
< hdr2
->vma
)
1930 else if (hdr1
->vma
> hdr2
->vma
)
1936 /* Calculate the file position for each section, and set
1940 ecoff_compute_section_file_positions (bfd
*abfd
)
1942 file_ptr sofar
, file_sofar
;
1943 asection
**sorted_hdrs
;
1947 bfd_boolean rdata_in_text
;
1948 bfd_boolean first_data
, first_nonalloc
;
1949 const bfd_vma round
= ecoff_backend (abfd
)->round
;
1952 sofar
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
1955 /* Sort the sections by VMA. */
1956 amt
= abfd
->section_count
;
1957 amt
*= sizeof (asection
*);
1958 sorted_hdrs
= (asection
**) bfd_malloc (amt
);
1959 if (sorted_hdrs
== NULL
)
1961 for (current
= abfd
->sections
, i
= 0;
1963 current
= current
->next
, i
++)
1964 sorted_hdrs
[i
] = current
;
1965 BFD_ASSERT (i
== abfd
->section_count
);
1967 qsort (sorted_hdrs
, abfd
->section_count
, sizeof (asection
*),
1970 /* Some versions of the OSF linker put the .rdata section in the
1971 text segment, and some do not. */
1972 rdata_in_text
= ecoff_backend (abfd
)->rdata_in_text
;
1975 for (i
= 0; i
< abfd
->section_count
; i
++)
1977 current
= sorted_hdrs
[i
];
1978 if (streq (current
->name
, _RDATA
))
1980 if ((current
->flags
& SEC_CODE
) == 0
1981 && ! streq (current
->name
, _PDATA
)
1982 && ! streq (current
->name
, _RCONST
))
1984 rdata_in_text
= FALSE
;
1989 ecoff_data (abfd
)->rdata_in_text
= rdata_in_text
;
1992 first_nonalloc
= TRUE
;
1993 for (i
= 0; i
< abfd
->section_count
; i
++)
1995 unsigned int alignment_power
;
1997 current
= sorted_hdrs
[i
];
1999 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2000 supposed to indicate the number of .pdata entries that are
2001 really in the section. Each entry is 8 bytes. We store this
2002 away in line_filepos before increasing the section size. */
2003 if (streq (current
->name
, _PDATA
))
2004 current
->line_filepos
= current
->size
/ 8;
2006 alignment_power
= current
->alignment_power
;
2008 /* On Ultrix, the data sections in an executable file must be
2009 aligned to a page boundary within the file. This does not
2010 affect the section size, though. FIXME: Does this work for
2011 other platforms? It requires some modification for the
2012 Alpha, because .rdata on the Alpha goes with the text, not
2014 if ((abfd
->flags
& EXEC_P
) != 0
2015 && (abfd
->flags
& D_PAGED
) != 0
2017 && (current
->flags
& SEC_CODE
) == 0
2019 || ! streq (current
->name
, _RDATA
))
2020 && ! streq (current
->name
, _PDATA
)
2021 && ! streq (current
->name
, _RCONST
))
2023 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2024 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2027 else if (streq (current
->name
, _LIB
))
2029 /* On Irix 4, the location of contents of the .lib section
2030 from a shared library section is also rounded up to a
2033 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2034 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2036 else if (first_nonalloc
2037 && (current
->flags
& SEC_ALLOC
) == 0
2038 && (abfd
->flags
& D_PAGED
) != 0)
2040 /* Skip up to the next page for an unallocated section, such
2041 as the .comment section on the Alpha. This leaves room
2042 for the .bss section. */
2043 first_nonalloc
= FALSE
;
2044 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2045 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2048 /* Align the sections in the file to the same boundary on
2049 which they are aligned in virtual memory. */
2050 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2051 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2052 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2054 if ((abfd
->flags
& D_PAGED
) != 0
2055 && (current
->flags
& SEC_ALLOC
) != 0)
2057 sofar
+= (current
->vma
- sofar
) % round
;
2058 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2059 file_sofar
+= (current
->vma
- file_sofar
) % round
;
2062 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) != 0)
2063 current
->filepos
= file_sofar
;
2065 sofar
+= current
->size
;
2066 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2067 file_sofar
+= current
->size
;
2069 /* Make sure that this section is of the right size too. */
2071 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2072 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2073 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2074 current
->size
+= sofar
- old_sofar
;
2080 ecoff_data (abfd
)->reloc_filepos
= file_sofar
;
2085 /* Determine the location of the relocs for all the sections in the
2086 output file, as well as the location of the symbolic debugging
2089 static bfd_size_type
2090 ecoff_compute_reloc_file_positions (bfd
*abfd
)
2092 const bfd_size_type external_reloc_size
=
2093 ecoff_backend (abfd
)->external_reloc_size
;
2094 file_ptr reloc_base
;
2095 bfd_size_type reloc_size
;
2099 if (! abfd
->output_has_begun
)
2101 if (! ecoff_compute_section_file_positions (abfd
))
2103 abfd
->output_has_begun
= TRUE
;
2106 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2109 for (current
= abfd
->sections
;
2111 current
= current
->next
)
2113 if (current
->reloc_count
== 0)
2114 current
->rel_filepos
= 0;
2117 bfd_size_type relsize
;
2119 current
->rel_filepos
= reloc_base
;
2120 relsize
= current
->reloc_count
* external_reloc_size
;
2121 reloc_size
+= relsize
;
2122 reloc_base
+= relsize
;
2126 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2128 /* At least on Ultrix, the symbol table of an executable file must
2129 be aligned to a page boundary. FIXME: Is this true on other
2131 if ((abfd
->flags
& EXEC_P
) != 0
2132 && (abfd
->flags
& D_PAGED
) != 0)
2133 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2134 &~ (ecoff_backend (abfd
)->round
- 1));
2136 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2141 /* Set the contents of a section. */
2144 _bfd_ecoff_set_section_contents (bfd
*abfd
,
2146 const void * location
,
2148 bfd_size_type count
)
2152 /* This must be done first, because bfd_set_section_contents is
2153 going to set output_has_begun to TRUE. */
2154 if (! abfd
->output_has_begun
2155 && ! ecoff_compute_section_file_positions (abfd
))
2158 /* Handle the .lib section specially so that Irix 4 shared libraries
2159 work out. See coff_set_section_contents in coffcode.h. */
2160 if (streq (section
->name
, _LIB
))
2162 bfd_byte
*rec
, *recend
;
2164 rec
= (bfd_byte
*) location
;
2165 recend
= rec
+ count
;
2166 while (rec
< recend
)
2169 rec
+= bfd_get_32 (abfd
, rec
) * 4;
2172 BFD_ASSERT (rec
== recend
);
2178 pos
= section
->filepos
+ offset
;
2179 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2180 || bfd_bwrite (location
, count
, abfd
) != count
)
2186 /* Get the GP value for an ECOFF file. This is a hook used by
2190 bfd_ecoff_get_gp_value (bfd
*abfd
)
2192 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2193 || bfd_get_format (abfd
) != bfd_object
)
2195 bfd_set_error (bfd_error_invalid_operation
);
2199 return ecoff_data (abfd
)->gp
;
2202 /* Set the GP value for an ECOFF file. This is a hook used by the
2206 bfd_ecoff_set_gp_value (bfd
*abfd
, bfd_vma gp_value
)
2208 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2209 || bfd_get_format (abfd
) != bfd_object
)
2211 bfd_set_error (bfd_error_invalid_operation
);
2215 ecoff_data (abfd
)->gp
= gp_value
;
2220 /* Set the register masks for an ECOFF file. This is a hook used by
2224 bfd_ecoff_set_regmasks (bfd
*abfd
,
2225 unsigned long gprmask
,
2226 unsigned long fprmask
,
2227 unsigned long *cprmask
)
2229 ecoff_data_type
*tdata
;
2231 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2232 || bfd_get_format (abfd
) != bfd_object
)
2234 bfd_set_error (bfd_error_invalid_operation
);
2238 tdata
= ecoff_data (abfd
);
2239 tdata
->gprmask
= gprmask
;
2240 tdata
->fprmask
= fprmask
;
2241 if (cprmask
!= NULL
)
2245 for (i
= 0; i
< 3; i
++)
2246 tdata
->cprmask
[i
] = cprmask
[i
];
2252 /* Get ECOFF EXTR information for an external symbol. This function
2253 is passed to bfd_ecoff_debug_externals. */
2256 ecoff_get_extr (asymbol
*sym
, EXTR
*esym
)
2258 ecoff_symbol_type
*ecoff_sym_ptr
;
2261 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2262 || ecoffsymbol (sym
)->native
== NULL
)
2264 /* Don't include debugging, local, or section symbols. */
2265 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2266 || (sym
->flags
& BSF_LOCAL
) != 0
2267 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2271 esym
->cobol_main
= 0;
2272 esym
->weakext
= (sym
->flags
& BSF_WEAK
) != 0;
2275 /* FIXME: we can do better than this for st and sc. */
2276 esym
->asym
.st
= stGlobal
;
2277 esym
->asym
.sc
= scAbs
;
2278 esym
->asym
.reserved
= 0;
2279 esym
->asym
.index
= indexNil
;
2283 ecoff_sym_ptr
= ecoffsymbol (sym
);
2285 if (ecoff_sym_ptr
->local
)
2288 input_bfd
= bfd_asymbol_bfd (sym
);
2289 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2290 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2292 /* If the symbol was defined by the linker, then esym will be
2293 undefined but sym will not be. Get a better class for such a
2295 if ((esym
->asym
.sc
== scUndefined
2296 || esym
->asym
.sc
== scSUndefined
)
2297 && ! bfd_is_und_section (bfd_get_section (sym
)))
2298 esym
->asym
.sc
= scAbs
;
2300 /* Adjust the FDR index for the symbol by that used for the input
2302 if (esym
->ifd
!= -1)
2304 struct ecoff_debug_info
*input_debug
;
2306 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2307 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2308 if (input_debug
->ifdmap
!= NULL
)
2309 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2315 /* Set the external symbol index. This routine is passed to
2316 bfd_ecoff_debug_externals. */
2319 ecoff_set_index (asymbol
*sym
, bfd_size_type indx
)
2321 ecoff_set_sym_index (sym
, indx
);
2324 /* Write out an ECOFF file. */
2327 _bfd_ecoff_write_object_contents (bfd
*abfd
)
2329 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2330 const bfd_vma round
= backend
->round
;
2331 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2332 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2333 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2334 const bfd_size_type external_hdr_size
2335 = backend
->debug_swap
.external_hdr_size
;
2336 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2337 void (* const adjust_reloc_out
) (bfd
*, const arelent
*, struct internal_reloc
*)
2338 = backend
->adjust_reloc_out
;
2339 void (* const swap_reloc_out
) (bfd
*, const struct internal_reloc
*, void *)
2340 = backend
->swap_reloc_out
;
2341 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2342 HDRR
* const symhdr
= &debug
->symbolic_header
;
2345 bfd_size_type reloc_size
;
2346 bfd_size_type text_size
;
2348 bfd_boolean set_text_start
;
2349 bfd_size_type data_size
;
2351 bfd_boolean set_data_start
;
2352 bfd_size_type bss_size
;
2354 void * reloc_buff
= NULL
;
2355 struct internal_filehdr internal_f
;
2356 struct internal_aouthdr internal_a
;
2359 /* Determine where the sections and relocs will go in the output
2361 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2364 for (current
= abfd
->sections
;
2366 current
= current
->next
)
2368 current
->target_index
= count
;
2372 if ((abfd
->flags
& D_PAGED
) != 0)
2373 text_size
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2377 set_text_start
= FALSE
;
2380 set_data_start
= FALSE
;
2383 /* Write section headers to the file. */
2385 /* Allocate buff big enough to hold a section header,
2386 file header, or a.out header. */
2395 buff
= bfd_malloc (siz
);
2400 internal_f
.f_nscns
= 0;
2401 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2404 for (current
= abfd
->sections
;
2406 current
= current
->next
)
2408 struct internal_scnhdr section
;
2411 ++internal_f
.f_nscns
;
2413 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2415 /* This seems to be correct for Irix 4 shared libraries. */
2416 vma
= bfd_get_section_vma (abfd
, current
);
2417 if (streq (current
->name
, _LIB
))
2418 section
.s_vaddr
= 0;
2420 section
.s_vaddr
= vma
;
2422 section
.s_paddr
= current
->lma
;
2423 section
.s_size
= current
->size
;
2425 /* If this section is unloadable then the scnptr will be 0. */
2426 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2427 section
.s_scnptr
= 0;
2429 section
.s_scnptr
= current
->filepos
;
2430 section
.s_relptr
= current
->rel_filepos
;
2432 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2433 object file produced by the assembler is supposed to point to
2434 information about how much room is required by objects of
2435 various different sizes. I think this only matters if we
2436 want the linker to compute the best size to use, or
2437 something. I don't know what happens if the information is
2439 if (! streq (current
->name
, _PDATA
))
2440 section
.s_lnnoptr
= 0;
2443 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2444 hold the number of entries in the section (each entry is
2445 8 bytes). We stored this in the line_filepos field in
2446 ecoff_compute_section_file_positions. */
2447 section
.s_lnnoptr
= current
->line_filepos
;
2450 section
.s_nreloc
= current
->reloc_count
;
2451 section
.s_nlnno
= 0;
2452 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2455 if (bfd_coff_swap_scnhdr_out (abfd
, (void *) §ion
, buff
) == 0
2456 || bfd_bwrite (buff
, scnhsz
, abfd
) != scnhsz
)
2459 if ((section
.s_flags
& STYP_TEXT
) != 0
2460 || ((section
.s_flags
& STYP_RDATA
) != 0
2461 && ecoff_data (abfd
)->rdata_in_text
)
2462 || section
.s_flags
== STYP_PDATA
2463 || (section
.s_flags
& STYP_DYNAMIC
) != 0
2464 || (section
.s_flags
& STYP_LIBLIST
) != 0
2465 || (section
.s_flags
& STYP_RELDYN
) != 0
2466 || section
.s_flags
== STYP_CONFLIC
2467 || (section
.s_flags
& STYP_DYNSTR
) != 0
2468 || (section
.s_flags
& STYP_DYNSYM
) != 0
2469 || (section
.s_flags
& STYP_HASH
) != 0
2470 || (section
.s_flags
& STYP_ECOFF_INIT
) != 0
2471 || (section
.s_flags
& STYP_ECOFF_FINI
) != 0
2472 || section
.s_flags
== STYP_RCONST
)
2474 text_size
+= current
->size
;
2475 if (! set_text_start
|| text_start
> vma
)
2478 set_text_start
= TRUE
;
2481 else if ((section
.s_flags
& STYP_RDATA
) != 0
2482 || (section
.s_flags
& STYP_DATA
) != 0
2483 || (section
.s_flags
& STYP_LITA
) != 0
2484 || (section
.s_flags
& STYP_LIT8
) != 0
2485 || (section
.s_flags
& STYP_LIT4
) != 0
2486 || (section
.s_flags
& STYP_SDATA
) != 0
2487 || section
.s_flags
== STYP_XDATA
2488 || (section
.s_flags
& STYP_GOT
) != 0)
2490 data_size
+= current
->size
;
2491 if (! set_data_start
|| data_start
> vma
)
2494 set_data_start
= TRUE
;
2497 else if ((section
.s_flags
& STYP_BSS
) != 0
2498 || (section
.s_flags
& STYP_SBSS
) != 0)
2499 bss_size
+= current
->size
;
2500 else if (section
.s_flags
== 0
2501 || (section
.s_flags
& STYP_ECOFF_LIB
) != 0
2502 || section
.s_flags
== STYP_COMMENT
)
2508 /* Set up the file header. */
2509 internal_f
.f_magic
= ecoff_get_magic (abfd
);
2511 /* We will NOT put a fucking timestamp in the header here. Every
2512 time you put it back, I will come in and take it out again. I'm
2513 sorry. This field does not belong here. We fill it with a 0 so
2514 it compares the same but is not a reasonable time. --
2516 internal_f
.f_timdat
= 0;
2518 if (bfd_get_symcount (abfd
) != 0)
2520 /* The ECOFF f_nsyms field is not actually the number of
2521 symbols, it's the size of symbolic information header. */
2522 internal_f
.f_nsyms
= external_hdr_size
;
2523 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
2527 internal_f
.f_nsyms
= 0;
2528 internal_f
.f_symptr
= 0;
2531 internal_f
.f_opthdr
= aoutsz
;
2533 internal_f
.f_flags
= F_LNNO
;
2534 if (reloc_size
== 0)
2535 internal_f
.f_flags
|= F_RELFLG
;
2536 if (bfd_get_symcount (abfd
) == 0)
2537 internal_f
.f_flags
|= F_LSYMS
;
2538 if (abfd
->flags
& EXEC_P
)
2539 internal_f
.f_flags
|= F_EXEC
;
2541 if (bfd_little_endian (abfd
))
2542 internal_f
.f_flags
|= F_AR32WR
;
2544 internal_f
.f_flags
|= F_AR32W
;
2546 /* Set up the ``optional'' header. */
2547 if ((abfd
->flags
& D_PAGED
) != 0)
2548 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
2550 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
2552 /* FIXME: Is this really correct? */
2553 internal_a
.vstamp
= symhdr
->vstamp
;
2555 /* At least on Ultrix, these have to be rounded to page boundaries.
2556 FIXME: Is this true on other platforms? */
2557 if ((abfd
->flags
& D_PAGED
) != 0)
2559 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
2560 internal_a
.text_start
= text_start
&~ (round
- 1);
2561 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
2562 internal_a
.data_start
= data_start
&~ (round
- 1);
2566 internal_a
.tsize
= text_size
;
2567 internal_a
.text_start
= text_start
;
2568 internal_a
.dsize
= data_size
;
2569 internal_a
.data_start
= data_start
;
2572 /* On Ultrix, the initial portions of the .sbss and .bss segments
2573 are at the end of the data section. The bsize field in the
2574 optional header records how many bss bytes are required beyond
2575 those in the data section. The value is not rounded to a page
2577 if (bss_size
< internal_a
.dsize
- data_size
)
2580 bss_size
-= internal_a
.dsize
- data_size
;
2581 internal_a
.bsize
= bss_size
;
2582 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
2584 internal_a
.entry
= bfd_get_start_address (abfd
);
2586 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
2588 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
2589 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
2590 for (i
= 0; i
< 4; i
++)
2591 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
2593 /* Let the backend adjust the headers if necessary. */
2594 if (backend
->adjust_headers
)
2596 if (! (*backend
->adjust_headers
) (abfd
, &internal_f
, &internal_a
))
2600 /* Write out the file header and the optional header. */
2601 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2604 bfd_coff_swap_filehdr_out (abfd
, (void *) &internal_f
, buff
);
2605 if (bfd_bwrite (buff
, filhsz
, abfd
) != filhsz
)
2608 bfd_coff_swap_aouthdr_out (abfd
, (void *) &internal_a
, buff
);
2609 if (bfd_bwrite (buff
, aoutsz
, abfd
) != aoutsz
)
2612 /* Build the external symbol information. This must be done before
2613 writing out the relocs so that we know the symbol indices. We
2614 don't do this if this BFD was created by the backend linker,
2615 since it will have already handled the symbols and relocs. */
2616 if (! ecoff_data (abfd
)->linker
)
2618 symhdr
->iextMax
= 0;
2619 symhdr
->issExtMax
= 0;
2620 debug
->external_ext
= debug
->external_ext_end
= NULL
;
2621 debug
->ssext
= debug
->ssext_end
= NULL
;
2622 if (! bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
2623 (abfd
->flags
& EXEC_P
) == 0,
2624 ecoff_get_extr
, ecoff_set_index
))
2627 /* Write out the relocs. */
2628 for (current
= abfd
->sections
;
2630 current
= current
->next
)
2632 arelent
**reloc_ptr_ptr
;
2633 arelent
**reloc_end
;
2637 if (current
->reloc_count
== 0)
2640 amt
= current
->reloc_count
* external_reloc_size
;
2641 reloc_buff
= bfd_alloc (abfd
, amt
);
2642 if (reloc_buff
== NULL
)
2645 reloc_ptr_ptr
= current
->orelocation
;
2646 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
2647 out_ptr
= (char *) reloc_buff
;
2650 reloc_ptr_ptr
< reloc_end
;
2651 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
2655 struct internal_reloc in
;
2657 memset ((void *) &in
, 0, sizeof in
);
2659 reloc
= *reloc_ptr_ptr
;
2660 sym
= *reloc
->sym_ptr_ptr
;
2662 /* If the howto field has not been initialised then skip this reloc.
2663 This assumes that an error message has been issued elsewhere. */
2664 if (reloc
->howto
== NULL
)
2667 in
.r_vaddr
= (reloc
->address
2668 + bfd_get_section_vma (abfd
, current
));
2669 in
.r_type
= reloc
->howto
->type
;
2671 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2673 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2687 { _TEXT
, RELOC_SECTION_TEXT
},
2688 { _RDATA
, RELOC_SECTION_RDATA
},
2689 { _DATA
, RELOC_SECTION_DATA
},
2690 { _SDATA
, RELOC_SECTION_SDATA
},
2691 { _SBSS
, RELOC_SECTION_SBSS
},
2692 { _BSS
, RELOC_SECTION_BSS
},
2693 { _INIT
, RELOC_SECTION_INIT
},
2694 { _LIT8
, RELOC_SECTION_LIT8
},
2695 { _LIT4
, RELOC_SECTION_LIT4
},
2696 { _XDATA
, RELOC_SECTION_XDATA
},
2697 { _PDATA
, RELOC_SECTION_PDATA
},
2698 { _FINI
, RELOC_SECTION_FINI
},
2699 { _LITA
, RELOC_SECTION_LITA
},
2700 { "*ABS*", RELOC_SECTION_ABS
},
2701 { _RCONST
, RELOC_SECTION_RCONST
}
2704 name
= bfd_get_section_name (abfd
, bfd_get_section (sym
));
2706 for (j
= 0; j
< ARRAY_SIZE (section_symndx
); j
++)
2707 if (streq (name
, section_symndx
[j
].name
))
2709 in
.r_symndx
= section_symndx
[j
].r_symndx
;
2713 if (j
== ARRAY_SIZE (section_symndx
))
2718 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2720 (*swap_reloc_out
) (abfd
, &in
, (void *) out_ptr
);
2723 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2725 amt
= current
->reloc_count
* external_reloc_size
;
2726 if (bfd_bwrite (reloc_buff
, amt
, abfd
) != amt
)
2728 bfd_release (abfd
, reloc_buff
);
2732 /* Write out the symbolic debugging information. */
2733 if (bfd_get_symcount (abfd
) > 0)
2735 /* Write out the debugging information. */
2736 if (! bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2737 ecoff_data (abfd
)->sym_filepos
))
2742 /* The .bss section of a demand paged executable must receive an
2743 entire page. If there are symbols, the symbols will start on the
2744 next page. If there are no symbols, we must fill out the page by
2746 if (bfd_get_symcount (abfd
) == 0
2747 && (abfd
->flags
& EXEC_P
) != 0
2748 && (abfd
->flags
& D_PAGED
) != 0)
2752 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2755 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) == 0)
2757 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2760 if (bfd_bwrite (&c
, (bfd_size_type
) 1, abfd
) != 1)
2764 if (reloc_buff
!= NULL
)
2765 bfd_release (abfd
, reloc_buff
);
2770 if (reloc_buff
!= NULL
)
2771 bfd_release (abfd
, reloc_buff
);
2777 /* Archive handling. ECOFF uses what appears to be a unique type of
2778 archive header (armap). The byte ordering of the armap and the
2779 contents are encoded in the name of the armap itself. At least for
2780 now, we only support archives with the same byte ordering in the
2781 armap and the contents.
2783 The first four bytes in the armap are the number of symbol
2784 definitions. This is always a power of two.
2786 This is followed by the symbol definitions. Each symbol definition
2787 occupies 8 bytes. The first four bytes are the offset from the
2788 start of the armap strings to the null-terminated string naming
2789 this symbol. The second four bytes are the file offset to the
2790 archive member which defines this symbol. If the second four bytes
2791 are 0, then this is not actually a symbol definition, and it should
2794 The symbols are hashed into the armap with a closed hashing scheme.
2795 See the functions below for the details of the algorithm.
2797 After the symbol definitions comes four bytes holding the size of
2798 the string table, followed by the string table itself. */
2800 /* The name of an archive headers looks like this:
2801 __________E[BL]E[BL]_ (with a trailing space).
2802 The trailing space is changed to an X if the archive is changed to
2803 indicate that the armap is out of date.
2805 The Alpha seems to use ________64E[BL]E[BL]_. */
2807 #define ARMAP_BIG_ENDIAN 'B'
2808 #define ARMAP_LITTLE_ENDIAN 'L'
2809 #define ARMAP_MARKER 'E'
2810 #define ARMAP_START_LENGTH 10
2811 #define ARMAP_HEADER_MARKER_INDEX 10
2812 #define ARMAP_HEADER_ENDIAN_INDEX 11
2813 #define ARMAP_OBJECT_MARKER_INDEX 12
2814 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2815 #define ARMAP_END_INDEX 14
2816 #define ARMAP_END "_ "
2818 /* This is a magic number used in the hashing algorithm. */
2819 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2821 /* This returns the hash value to use for a string. It also sets
2822 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2823 is the number of entries in the hash table, and HLOG is the log
2827 ecoff_armap_hash (const char *s
,
2828 unsigned int *rehash
,
2838 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2839 hash
*= ARMAP_HASH_MAGIC
;
2840 *rehash
= (hash
& (size
- 1)) | 1;
2841 return hash
>> (32 - hlog
);
2844 /* Read in the armap. */
2847 _bfd_ecoff_slurp_armap (bfd
*abfd
)
2851 struct areltdata
*mapdata
;
2852 bfd_size_type parsed_size
;
2854 struct artdata
*ardata
;
2861 /* Get the name of the first element. */
2862 i
= bfd_bread ((void *) nextname
, (bfd_size_type
) 16, abfd
);
2868 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2871 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2872 standard COFF armap. We could move the ECOFF armap stuff into
2873 bfd_slurp_armap, but that seems inappropriate since no other
2874 target uses this format. Instead, we check directly for a COFF
2876 if (CONST_STRNEQ (nextname
, "/ "))
2877 return bfd_slurp_armap (abfd
);
2879 /* See if the first element is an armap. */
2880 if (! strneq (nextname
, ecoff_backend (abfd
)->armap_start
, ARMAP_START_LENGTH
)
2881 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
2882 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2883 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2884 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
2885 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2886 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2887 || ! strneq (nextname
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1))
2889 bfd_has_map (abfd
) = FALSE
;
2893 /* Make sure we have the right byte ordering. */
2894 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2895 ^ (bfd_header_big_endian (abfd
)))
2896 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2897 ^ (bfd_big_endian (abfd
))))
2899 bfd_set_error (bfd_error_wrong_format
);
2903 /* Read in the armap. */
2904 ardata
= bfd_ardata (abfd
);
2905 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
2906 if (mapdata
== NULL
)
2908 parsed_size
= mapdata
->parsed_size
;
2909 bfd_release (abfd
, (void *) mapdata
);
2911 raw_armap
= (char *) bfd_alloc (abfd
, parsed_size
);
2912 if (raw_armap
== NULL
)
2915 if (bfd_bread ((void *) raw_armap
, parsed_size
, abfd
) != parsed_size
)
2917 if (bfd_get_error () != bfd_error_system_call
)
2918 bfd_set_error (bfd_error_malformed_archive
);
2919 bfd_release (abfd
, (void *) raw_armap
);
2923 ardata
->tdata
= (void *) raw_armap
;
2925 count
= H_GET_32 (abfd
, raw_armap
);
2927 ardata
->symdef_count
= 0;
2928 ardata
->cache
= NULL
;
2930 /* This code used to overlay the symdefs over the raw archive data,
2931 but that doesn't work on a 64 bit host. */
2932 stringbase
= raw_armap
+ count
* 8 + 8;
2934 #ifdef CHECK_ARMAP_HASH
2938 /* Double check that I have the hashing algorithm right by making
2939 sure that every symbol can be looked up successfully. */
2941 for (i
= 1; i
< count
; i
<<= 1)
2943 BFD_ASSERT (i
== count
);
2945 raw_ptr
= raw_armap
+ 4;
2946 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2948 unsigned int name_offset
, file_offset
;
2949 unsigned int hash
, rehash
, srch
;
2951 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2952 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2953 if (file_offset
== 0)
2955 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
2960 /* See if we can rehash to this location. */
2961 for (srch
= (hash
+ rehash
) & (count
- 1);
2962 srch
!= hash
&& srch
!= i
;
2963 srch
= (srch
+ rehash
) & (count
- 1))
2964 BFD_ASSERT (H_GET_32 (abfd
, (raw_armap
+ 8 + srch
* 8)) != 0);
2965 BFD_ASSERT (srch
== i
);
2969 #endif /* CHECK_ARMAP_HASH */
2971 raw_ptr
= raw_armap
+ 4;
2972 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2973 if (H_GET_32 (abfd
, (raw_ptr
+ 4)) != 0)
2974 ++ardata
->symdef_count
;
2976 amt
= ardata
->symdef_count
;
2977 amt
*= sizeof (carsym
);
2978 symdef_ptr
= (carsym
*) bfd_alloc (abfd
, amt
);
2982 ardata
->symdefs
= symdef_ptr
;
2984 raw_ptr
= raw_armap
+ 4;
2985 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2987 unsigned int name_offset
, file_offset
;
2989 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2990 if (file_offset
== 0)
2992 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2993 symdef_ptr
->name
= stringbase
+ name_offset
;
2994 symdef_ptr
->file_offset
= file_offset
;
2998 ardata
->first_file_filepos
= bfd_tell (abfd
);
2999 /* Pad to an even boundary. */
3000 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
3002 bfd_has_map (abfd
) = TRUE
;
3007 /* Write out an armap. */
3010 _bfd_ecoff_write_armap (bfd
*abfd
,
3011 unsigned int elength
,
3013 unsigned int orl_count
,
3016 unsigned int hashsize
, hashlog
;
3017 bfd_size_type symdefsize
;
3019 unsigned int stringsize
;
3020 unsigned int mapsize
;
3023 struct stat statbuf
;
3026 bfd_byte
*hashtable
;
3030 /* Ultrix appears to use as a hash table size the least power of two
3031 greater than twice the number of entries. */
3032 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3034 hashsize
= 1 << hashlog
;
3036 symdefsize
= hashsize
* 8;
3038 stringsize
= stridx
+ padit
;
3040 /* Include 8 bytes to store symdefsize and stringsize in output. */
3041 mapsize
= symdefsize
+ stringsize
+ 8;
3043 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3045 memset ((void *) &hdr
, 0, sizeof hdr
);
3047 /* Work out the ECOFF armap name. */
3048 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3049 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3050 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3051 (bfd_header_big_endian (abfd
)
3053 : ARMAP_LITTLE_ENDIAN
);
3054 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3055 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3056 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3057 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3059 /* Write the timestamp of the archive header to be just a little bit
3060 later than the timestamp of the file, otherwise the linker will
3061 complain that the index is out of date. Actually, the Ultrix
3062 linker just checks the archive name; the GNU linker may check the
3064 stat (abfd
->filename
, &statbuf
);
3065 _bfd_ar_spacepad (hdr
.ar_date
, sizeof (hdr
.ar_date
), "%ld",
3066 (long) (statbuf
.st_mtime
+ 60));
3068 /* The DECstation uses zeroes for the uid, gid and mode of the
3070 hdr
.ar_uid
[0] = '0';
3071 hdr
.ar_gid
[0] = '0';
3072 /* Building gcc ends up extracting the armap as a file - twice. */
3073 hdr
.ar_mode
[0] = '6';
3074 hdr
.ar_mode
[1] = '4';
3075 hdr
.ar_mode
[2] = '4';
3077 _bfd_ar_spacepad (hdr
.ar_size
, sizeof (hdr
.ar_size
), "%-10ld", mapsize
);
3079 hdr
.ar_fmag
[0] = '`';
3080 hdr
.ar_fmag
[1] = '\012';
3082 /* Turn all null bytes in the header into spaces. */
3083 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3084 if (((char *) (&hdr
))[i
] == '\0')
3085 (((char *) (&hdr
))[i
]) = ' ';
3087 if (bfd_bwrite ((void *) &hdr
, (bfd_size_type
) sizeof (struct ar_hdr
), abfd
)
3088 != sizeof (struct ar_hdr
))
3091 H_PUT_32 (abfd
, hashsize
, temp
);
3092 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3095 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3099 current
= abfd
->archive_head
;
3101 for (i
= 0; i
< orl_count
; i
++)
3103 unsigned int hash
, rehash
= 0;
3105 /* Advance firstreal to the file position of this archive
3107 if (map
[i
].u
.abfd
!= last_elt
)
3111 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3112 firstreal
+= firstreal
% 2;
3113 current
= current
->archive_next
;
3115 while (current
!= map
[i
].u
.abfd
);
3120 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3121 if (H_GET_32 (abfd
, (hashtable
+ (hash
* 8) + 4)) != 0)
3125 /* The desired slot is already taken. */
3126 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3128 srch
= (srch
+ rehash
) & (hashsize
- 1))
3129 if (H_GET_32 (abfd
, (hashtable
+ (srch
* 8) + 4)) == 0)
3132 BFD_ASSERT (srch
!= hash
);
3137 H_PUT_32 (abfd
, map
[i
].namidx
, (hashtable
+ hash
* 8));
3138 H_PUT_32 (abfd
, firstreal
, (hashtable
+ hash
* 8 + 4));
3141 if (bfd_bwrite ((void *) hashtable
, symdefsize
, abfd
) != symdefsize
)
3144 bfd_release (abfd
, hashtable
);
3146 /* Now write the strings. */
3147 H_PUT_32 (abfd
, stringsize
, temp
);
3148 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3150 for (i
= 0; i
< orl_count
; i
++)
3154 len
= strlen (*map
[i
].name
) + 1;
3155 if (bfd_bwrite ((void *) (*map
[i
].name
), len
, abfd
) != len
)
3159 /* The spec sez this should be a newline. But in order to be
3160 bug-compatible for DECstation ar we use a null. */
3163 if (bfd_bwrite ("", (bfd_size_type
) 1, abfd
) != 1)
3170 /* ECOFF linker code. */
3172 /* Routine to create an entry in an ECOFF link hash table. */
3174 static struct bfd_hash_entry
*
3175 ecoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
3176 struct bfd_hash_table
*table
,
3179 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3181 /* Allocate the structure if it has not already been allocated by a
3184 ret
= ((struct ecoff_link_hash_entry
*)
3185 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3189 /* Call the allocation method of the superclass. */
3190 ret
= ((struct ecoff_link_hash_entry
*)
3191 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3196 /* Set local fields. */
3202 memset ((void *) &ret
->esym
, 0, sizeof ret
->esym
);
3204 return (struct bfd_hash_entry
*) ret
;
3207 /* Create an ECOFF link hash table. */
3209 struct bfd_link_hash_table
*
3210 _bfd_ecoff_bfd_link_hash_table_create (bfd
*abfd
)
3212 struct ecoff_link_hash_table
*ret
;
3213 bfd_size_type amt
= sizeof (struct ecoff_link_hash_table
);
3215 ret
= (struct ecoff_link_hash_table
*) bfd_malloc (amt
);
3218 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
,
3219 ecoff_link_hash_newfunc
,
3220 sizeof (struct ecoff_link_hash_entry
)))
3228 /* Look up an entry in an ECOFF link hash table. */
3230 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3231 ((struct ecoff_link_hash_entry *) \
3232 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3234 /* Get the ECOFF link hash table from the info structure. This is
3237 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3239 /* Add the external symbols of an object file to the global linker
3240 hash table. The external symbols and strings we are passed are
3241 just allocated on the stack, and will be discarded. We must
3242 explicitly save any information we may need later on in the link.
3243 We do not want to read the external symbol information again. */
3246 ecoff_link_add_externals (bfd
*abfd
,
3247 struct bfd_link_info
*info
,
3248 void * external_ext
,
3251 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3252 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3253 = backend
->debug_swap
.swap_ext_in
;
3254 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3255 unsigned long ext_count
;
3256 struct bfd_link_hash_entry
**sym_hash
;
3261 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3264 amt
*= sizeof (struct bfd_link_hash_entry
*);
3265 sym_hash
= (struct bfd_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3268 ecoff_data (abfd
)->sym_hashes
= (struct ecoff_link_hash_entry
**) sym_hash
;
3270 ext_ptr
= (char *) external_ext
;
3271 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3272 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3279 struct ecoff_link_hash_entry
*h
;
3283 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3285 /* Skip debugging symbols. */
3287 switch (esym
.asym
.st
)
3303 /* Get the information for this symbol. */
3304 value
= esym
.asym
.value
;
3305 switch (esym
.asym
.sc
)
3325 section
= bfd_make_section_old_way (abfd
, _TEXT
);
3326 value
-= section
->vma
;
3329 section
= bfd_make_section_old_way (abfd
, _DATA
);
3330 value
-= section
->vma
;
3333 section
= bfd_make_section_old_way (abfd
, _BSS
);
3334 value
-= section
->vma
;
3337 section
= bfd_abs_section_ptr
;
3340 section
= bfd_und_section_ptr
;
3343 section
= bfd_make_section_old_way (abfd
, _SDATA
);
3344 value
-= section
->vma
;
3347 section
= bfd_make_section_old_way (abfd
, _SBSS
);
3348 value
-= section
->vma
;
3351 section
= bfd_make_section_old_way (abfd
, _RDATA
);
3352 value
-= section
->vma
;
3355 if (value
> ecoff_data (abfd
)->gp_size
)
3357 section
= bfd_com_section_ptr
;
3362 if (ecoff_scom_section
.name
== NULL
)
3364 /* Initialize the small common section. */
3365 ecoff_scom_section
.name
= SCOMMON
;
3366 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
3367 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
3368 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
3369 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
3370 ecoff_scom_symbol
.name
= SCOMMON
;
3371 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
3372 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
3373 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
3375 section
= &ecoff_scom_section
;
3378 section
= bfd_und_section_ptr
;
3381 section
= bfd_make_section_old_way (abfd
, _INIT
);
3382 value
-= section
->vma
;
3385 section
= bfd_make_section_old_way (abfd
, _FINI
);
3386 value
-= section
->vma
;
3389 section
= bfd_make_section_old_way (abfd
, _RCONST
);
3390 value
-= section
->vma
;
3394 if (section
== NULL
)
3397 name
= ssext
+ esym
.asym
.iss
;
3399 if (! (_bfd_generic_link_add_one_symbol
3401 (flagword
) (esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
),
3402 section
, value
, NULL
, TRUE
, TRUE
, sym_hash
)))
3405 h
= (struct ecoff_link_hash_entry
*) *sym_hash
;
3407 /* If we are building an ECOFF hash table, save the external
3408 symbol information. */
3409 if (bfd_get_flavour (info
->output_bfd
) == bfd_get_flavour (abfd
))
3412 || (! bfd_is_und_section (section
)
3413 && (! bfd_is_com_section (section
)
3414 || (h
->root
.type
!= bfd_link_hash_defined
3415 && h
->root
.type
!= bfd_link_hash_defweak
))))
3421 /* Remember whether this symbol was small undefined. */
3422 if (esym
.asym
.sc
== scSUndefined
)
3425 /* If this symbol was ever small undefined, it needs to wind
3426 up in a GP relative section. We can't control the
3427 section of a defined symbol, but we can control the
3428 section of a common symbol. This case is actually needed
3429 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3431 && h
->root
.type
== bfd_link_hash_common
3432 && streq (h
->root
.u
.c
.p
->section
->name
, SCOMMON
))
3434 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
3436 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
3437 if (h
->esym
.asym
.sc
== scCommon
)
3438 h
->esym
.asym
.sc
= scSCommon
;
3446 /* Add symbols from an ECOFF object file to the global linker hash
3450 ecoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3453 bfd_size_type external_ext_size
;
3454 void * external_ext
= NULL
;
3455 bfd_size_type esize
;
3459 if (! ecoff_slurp_symbolic_header (abfd
))
3462 /* If there are no symbols, we don't want it. */
3463 if (bfd_get_symcount (abfd
) == 0)
3466 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3468 /* Read in the external symbols and external strings. */
3469 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3470 esize
= symhdr
->iextMax
* external_ext_size
;
3471 external_ext
= bfd_malloc (esize
);
3472 if (external_ext
== NULL
&& esize
!= 0)
3475 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbExtOffset
, SEEK_SET
) != 0
3476 || bfd_bread (external_ext
, esize
, abfd
) != esize
)
3479 ssext
= (char *) bfd_malloc ((bfd_size_type
) symhdr
->issExtMax
);
3480 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3483 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
3484 || (bfd_bread (ssext
, (bfd_size_type
) symhdr
->issExtMax
, abfd
)
3485 != (bfd_size_type
) symhdr
->issExtMax
))
3488 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3492 if (external_ext
!= NULL
)
3493 free (external_ext
);
3499 if (external_ext
!= NULL
)
3500 free (external_ext
);
3504 /* Factored out from ecoff_link_check_archive_element. */
3507 read_ext_syms_and_strs (HDRR
**symhdr
, bfd_size_type
*external_ext_size
,
3508 bfd_size_type
*esize
, void **external_ext
, char **ssext
, bfd
*abfd
,
3509 const struct ecoff_backend_data
* const backend
)
3511 if (! ecoff_slurp_symbolic_header (abfd
))
3514 /* If there are no symbols, we don't want it. */
3515 if (bfd_get_symcount (abfd
) == 0)
3518 *symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3520 *external_ext_size
= backend
->debug_swap
.external_ext_size
;
3521 *esize
= (*symhdr
)->iextMax
* *external_ext_size
;
3522 *external_ext
= bfd_malloc (*esize
);
3523 if (*external_ext
== NULL
&& *esize
!= 0)
3526 if (bfd_seek (abfd
, (file_ptr
) (*symhdr
)->cbExtOffset
, SEEK_SET
) != 0
3527 || bfd_bread (*external_ext
, *esize
, abfd
) != *esize
)
3530 *ssext
= (char *) bfd_malloc ((bfd_size_type
) (*symhdr
)->issExtMax
);
3531 if (*ssext
== NULL
&& (*symhdr
)->issExtMax
!= 0)
3534 if (bfd_seek (abfd
, (file_ptr
) (*symhdr
)->cbSsExtOffset
, SEEK_SET
) != 0
3535 || (bfd_bread (*ssext
, (bfd_size_type
) (*symhdr
)->issExtMax
, abfd
)
3536 != (bfd_size_type
) (*symhdr
)->issExtMax
))
3542 reread_ext_syms_and_strs (HDRR
**symhdr
, bfd_size_type
*external_ext_size
,
3543 bfd_size_type
*esize
, void **external_ext
, char **ssext
, bfd
*abfd
,
3544 const struct ecoff_backend_data
* const backend
)
3546 if (*external_ext
!= NULL
)
3547 free (*external_ext
);
3548 *external_ext
= NULL
;
3552 return read_ext_syms_and_strs (symhdr
, external_ext_size
, esize
,
3553 external_ext
, ssext
, abfd
, backend
);
3556 /* This is called if we used _bfd_generic_link_add_archive_symbols
3557 because we were not dealing with an ECOFF archive. */
3560 ecoff_link_check_archive_element (bfd
*abfd
,
3561 struct bfd_link_info
*info
,
3562 bfd_boolean
*pneeded
)
3564 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3565 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3566 = backend
->debug_swap
.swap_ext_in
;
3568 bfd_size_type external_ext_size
;
3569 void * external_ext
= NULL
;
3570 bfd_size_type esize
;
3577 /* Read in the external symbols and external strings. */
3578 if (!read_ext_syms_and_strs (&symhdr
, &external_ext_size
, &esize
,
3579 &external_ext
, &ssext
, abfd
, backend
))
3582 /* If there are no symbols, we don't want it. */
3583 if (bfd_get_symcount (abfd
) == 0)
3584 goto successful_return
;
3586 /* Look through the external symbols to see if they define some
3587 symbol that is currently undefined. */
3588 ext_ptr
= (char *) external_ext
;
3589 ext_end
= ext_ptr
+ esize
;
3590 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
)
3596 struct bfd_link_hash_entry
*h
;
3598 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3600 /* See if this symbol defines something. */
3601 if (esym
.asym
.st
!= stGlobal
3602 && esym
.asym
.st
!= stLabel
3603 && esym
.asym
.st
!= stProc
)
3606 switch (esym
.asym
.sc
)
3630 name
= ssext
+ esym
.asym
.iss
;
3631 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
3633 /* Unlike the generic linker, we do not pull in elements because
3634 of common symbols. */
3636 || h
->type
!= bfd_link_hash_undefined
)
3639 /* Include this element. */
3641 if (!(*info
->callbacks
3642 ->add_archive_element
) (info
, abfd
, name
, &abfd
))
3644 /* Potentially, the add_archive_element hook may have set a
3645 substitute BFD for us. */
3647 && !reread_ext_syms_and_strs (&symhdr
, &external_ext_size
, &esize
,
3648 &external_ext
, &ssext
, abfd
, backend
))
3650 if (! ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
))
3654 goto successful_return
;
3658 if (external_ext
!= NULL
)
3659 free (external_ext
);
3664 if (external_ext
!= NULL
)
3665 free (external_ext
);
3671 /* Add the symbols from an archive file to the global hash table.
3672 This looks through the undefined symbols, looks each one up in the
3673 archive hash table, and adds any associated object file. We do not
3674 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3675 already have a hash table, so there is no reason to construct
3679 ecoff_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3681 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3682 const bfd_byte
*raw_armap
;
3683 struct bfd_link_hash_entry
**pundef
;
3684 unsigned int armap_count
;
3685 unsigned int armap_log
;
3687 const bfd_byte
*hashtable
;
3688 const char *stringbase
;
3690 if (! bfd_has_map (abfd
))
3692 /* An empty archive is a special case. */
3693 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
3695 bfd_set_error (bfd_error_no_armap
);
3699 /* If we don't have any raw data for this archive, as can happen on
3700 Irix 4.0.5F, we call the generic routine.
3701 FIXME: We should be more clever about this, since someday tdata
3702 may get to something for a generic archive. */
3703 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3704 if (raw_armap
== NULL
)
3705 return (_bfd_generic_link_add_archive_symbols
3706 (abfd
, info
, ecoff_link_check_archive_element
));
3708 armap_count
= H_GET_32 (abfd
, raw_armap
);
3711 for (i
= 1; i
< armap_count
; i
<<= 1)
3713 BFD_ASSERT (i
== armap_count
);
3715 hashtable
= raw_armap
+ 4;
3716 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3718 /* Look through the list of undefined symbols. */
3719 pundef
= &info
->hash
->undefs
;
3720 while (*pundef
!= NULL
)
3722 struct bfd_link_hash_entry
*h
;
3723 unsigned int hash
, rehash
= 0;
3724 unsigned int file_offset
;
3730 /* When a symbol is defined, it is not necessarily removed from
3732 if (h
->type
!= bfd_link_hash_undefined
3733 && h
->type
!= bfd_link_hash_common
)
3735 /* Remove this entry from the list, for general cleanliness
3736 and because we are going to look through the list again
3737 if we search any more libraries. We can't remove the
3738 entry if it is the tail, because that would lose any
3739 entries we add to the list later on. */
3740 if (*pundef
!= info
->hash
->undefs_tail
)
3741 *pundef
= (*pundef
)->u
.undef
.next
;
3743 pundef
= &(*pundef
)->u
.undef
.next
;
3747 /* Native ECOFF linkers do not pull in archive elements merely
3748 to satisfy common definitions, so neither do we. We leave
3749 them on the list, though, in case we are linking against some
3750 other object format. */
3751 if (h
->type
!= bfd_link_hash_undefined
)
3753 pundef
= &(*pundef
)->u
.undef
.next
;
3757 /* Look for this symbol in the archive hash table. */
3758 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3761 file_offset
= H_GET_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3762 if (file_offset
== 0)
3764 /* Nothing in this slot. */
3765 pundef
= &(*pundef
)->u
.undef
.next
;
3769 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (hash
* 8));
3770 if (name
[0] != h
->root
.string
[0]
3771 || ! streq (name
, h
->root
.string
))
3776 /* That was the wrong symbol. Try rehashing. */
3778 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3780 srch
= (srch
+ rehash
) & (armap_count
- 1))
3782 file_offset
= H_GET_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3783 if (file_offset
== 0)
3785 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (srch
* 8));
3786 if (name
[0] == h
->root
.string
[0]
3787 && streq (name
, h
->root
.string
))
3796 pundef
= &(*pundef
)->u
.undef
.next
;
3803 element
= (*backend
->get_elt_at_filepos
) (abfd
, (file_ptr
) file_offset
);
3804 if (element
== NULL
)
3807 if (! bfd_check_format (element
, bfd_object
))
3810 /* Unlike the generic linker, we know that this element provides
3811 a definition for an undefined symbol and we know that we want
3812 to include it. We don't need to check anything. */
3813 if (!(*info
->callbacks
3814 ->add_archive_element
) (info
, element
, name
, &element
))
3816 if (! ecoff_link_add_object_symbols (element
, info
))
3819 pundef
= &(*pundef
)->u
.undef
.next
;
3825 /* Given an ECOFF BFD, add symbols to the global hash table as
3829 _bfd_ecoff_bfd_link_add_symbols (bfd
*abfd
, 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
);
3844 /* ECOFF final link routines. */
3846 /* Structure used to pass information to ecoff_link_write_external. */
3851 struct bfd_link_info
*info
;
3854 /* Accumulate the debugging information for an input BFD into the
3855 output BFD. This must read in the symbolic information of the
3859 ecoff_final_link_debug_accumulate (bfd
*output_bfd
,
3861 struct bfd_link_info
*info
,
3864 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
3865 const struct ecoff_debug_swap
* const swap
=
3866 &ecoff_backend (input_bfd
)->debug_swap
;
3867 HDRR
*symhdr
= &debug
->symbolic_header
;
3870 #define READ(ptr, offset, count, size, type) \
3871 if (symhdr->count == 0) \
3872 debug->ptr = NULL; \
3875 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
3876 debug->ptr = (type) bfd_malloc (amt); \
3877 if (debug->ptr == NULL) \
3880 goto return_something; \
3882 if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3883 || bfd_bread (debug->ptr, amt, input_bfd) != amt) \
3886 goto return_something; \
3890 /* If raw_syments is not NULL, then the data was already by read by
3891 _bfd_ecoff_slurp_symbolic_info. */
3892 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3894 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
3896 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
3897 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
3898 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
3899 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
3900 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3902 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3903 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
3904 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
3908 /* We do not read the external strings or the external symbols. */
3910 ret
= (bfd_ecoff_debug_accumulate
3911 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
3912 &ecoff_backend (output_bfd
)->debug_swap
,
3913 input_bfd
, debug
, swap
, info
));
3916 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3918 if (debug
->line
!= NULL
)
3920 if (debug
->external_dnr
!= NULL
)
3921 free (debug
->external_dnr
);
3922 if (debug
->external_pdr
!= NULL
)
3923 free (debug
->external_pdr
);
3924 if (debug
->external_sym
!= NULL
)
3925 free (debug
->external_sym
);
3926 if (debug
->external_opt
!= NULL
)
3927 free (debug
->external_opt
);
3928 if (debug
->external_aux
!= NULL
)
3929 free (debug
->external_aux
);
3930 if (debug
->ss
!= NULL
)
3932 if (debug
->external_fdr
!= NULL
)
3933 free (debug
->external_fdr
);
3934 if (debug
->external_rfd
!= NULL
)
3935 free (debug
->external_rfd
);
3937 /* Make sure we don't accidentally follow one of these pointers
3938 into freed memory. */
3940 debug
->external_dnr
= NULL
;
3941 debug
->external_pdr
= NULL
;
3942 debug
->external_sym
= NULL
;
3943 debug
->external_opt
= NULL
;
3944 debug
->external_aux
= NULL
;
3946 debug
->external_fdr
= NULL
;
3947 debug
->external_rfd
= NULL
;
3953 /* Relocate and write an ECOFF section into an ECOFF output file. */
3956 ecoff_indirect_link_order (bfd
*output_bfd
,
3957 struct bfd_link_info
*info
,
3958 asection
*output_section
,
3959 struct bfd_link_order
*link_order
)
3961 asection
*input_section
;
3963 bfd_byte
*contents
= NULL
;
3964 bfd_size_type external_reloc_size
;
3965 bfd_size_type external_relocs_size
;
3966 void * external_relocs
= NULL
;
3968 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
3970 input_section
= link_order
->u
.indirect
.section
;
3971 input_bfd
= input_section
->owner
;
3972 if (input_section
->size
== 0)
3975 BFD_ASSERT (input_section
->output_section
== output_section
);
3976 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
3977 BFD_ASSERT (input_section
->size
== link_order
->size
);
3979 /* Get the section contents. */
3980 if (!bfd_malloc_and_get_section (input_bfd
, input_section
, &contents
))
3983 /* Get the relocs. If we are relaxing MIPS code, they will already
3984 have been read in. Otherwise, we read them in now. */
3985 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
3986 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
3988 external_relocs
= bfd_malloc (external_relocs_size
);
3989 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
3992 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
3993 || (bfd_bread (external_relocs
, external_relocs_size
, input_bfd
)
3994 != external_relocs_size
))
3997 /* Relocate the section contents. */
3998 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
3999 (output_bfd
, info
, input_bfd
, input_section
, contents
,
4003 /* Write out the relocated section. */
4004 if (! bfd_set_section_contents (output_bfd
,
4007 input_section
->output_offset
,
4008 input_section
->size
))
4011 /* If we are producing relocatable output, the relocs were
4012 modified, and we write them out now. We use the reloc_count
4013 field of output_section to keep track of the number of relocs we
4014 have output so far. */
4015 if (info
->relocatable
)
4017 file_ptr pos
= (output_section
->rel_filepos
4018 + output_section
->reloc_count
* external_reloc_size
);
4019 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4020 || (bfd_bwrite (external_relocs
, external_relocs_size
, output_bfd
)
4021 != external_relocs_size
))
4023 output_section
->reloc_count
+= input_section
->reloc_count
;
4026 if (contents
!= NULL
)
4028 if (external_relocs
!= NULL
)
4029 free (external_relocs
);
4033 if (contents
!= NULL
)
4035 if (external_relocs
!= NULL
)
4036 free (external_relocs
);
4040 /* Generate a reloc when linking an ECOFF file. This is a reloc
4041 requested by the linker, and does come from any input file. This
4042 is used to build constructor and destructor tables when linking
4046 ecoff_reloc_link_order (bfd
*output_bfd
,
4047 struct bfd_link_info
*info
,
4048 asection
*output_section
,
4049 struct bfd_link_order
*link_order
)
4051 enum bfd_link_order_type type
;
4055 struct internal_reloc in
;
4056 bfd_size_type external_reloc_size
;
4061 type
= link_order
->type
;
4063 addend
= link_order
->u
.reloc
.p
->addend
;
4065 /* We set up an arelent to pass to the backend adjust_reloc_out
4067 rel
.address
= link_order
->offset
;
4069 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
4072 bfd_set_error (bfd_error_bad_value
);
4076 if (type
== bfd_section_reloc_link_order
)
4078 section
= link_order
->u
.reloc
.p
->u
.section
;
4079 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
4083 struct bfd_link_hash_entry
*h
;
4085 /* Treat a reloc against a defined symbol as though it were
4086 actually against the section. */
4087 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4088 link_order
->u
.reloc
.p
->u
.name
,
4089 FALSE
, FALSE
, FALSE
);
4091 && (h
->type
== bfd_link_hash_defined
4092 || h
->type
== bfd_link_hash_defweak
))
4094 type
= bfd_section_reloc_link_order
;
4095 section
= h
->u
.def
.section
->output_section
;
4096 /* It seems that we ought to add the symbol value to the
4097 addend here, but in practice it has already been added
4098 because it was passed to constructor_callback. */
4099 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
4103 /* We can't set up a reloc against a symbol correctly,
4104 because we have no asymbol structure. Currently no
4105 adjust_reloc_out routine cares. */
4106 rel
.sym_ptr_ptr
= NULL
;
4110 /* All ECOFF relocs are in-place. Put the addend into the object
4113 BFD_ASSERT (rel
.howto
->partial_inplace
);
4117 bfd_reloc_status_type rstat
;
4120 size
= bfd_get_reloc_size (rel
.howto
);
4121 buf
= (bfd_byte
*) bfd_zmalloc (size
);
4124 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
4125 (bfd_vma
) addend
, buf
);
4131 case bfd_reloc_outofrange
:
4133 case bfd_reloc_overflow
:
4134 if (! ((*info
->callbacks
->reloc_overflow
)
4136 (link_order
->type
== bfd_section_reloc_link_order
4137 ? bfd_section_name (output_bfd
, section
)
4138 : link_order
->u
.reloc
.p
->u
.name
),
4139 rel
.howto
->name
, addend
, NULL
,
4140 NULL
, (bfd_vma
) 0)))
4147 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
4148 (file_ptr
) link_order
->offset
, size
);
4156 /* Move the information into an internal_reloc structure. */
4157 in
.r_vaddr
= (rel
.address
4158 + bfd_get_section_vma (output_bfd
, output_section
));
4159 in
.r_type
= rel
.howto
->type
;
4161 if (type
== bfd_symbol_reloc_link_order
)
4163 struct ecoff_link_hash_entry
*h
;
4165 h
= ((struct ecoff_link_hash_entry
*)
4166 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4167 link_order
->u
.reloc
.p
->u
.name
,
4168 FALSE
, FALSE
, TRUE
));
4171 in
.r_symndx
= h
->indx
;
4174 if (! ((*info
->callbacks
->unattached_reloc
)
4175 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
,
4176 NULL
, (bfd_vma
) 0)))
4193 { _TEXT
, RELOC_SECTION_TEXT
},
4194 { _RDATA
, RELOC_SECTION_RDATA
},
4195 { _DATA
, RELOC_SECTION_DATA
},
4196 { _SDATA
, RELOC_SECTION_SDATA
},
4197 { _SBSS
, RELOC_SECTION_SBSS
},
4198 { _BSS
, RELOC_SECTION_BSS
},
4199 { _INIT
, RELOC_SECTION_INIT
},
4200 { _LIT8
, RELOC_SECTION_LIT8
},
4201 { _LIT4
, RELOC_SECTION_LIT4
},
4202 { _XDATA
, RELOC_SECTION_XDATA
},
4203 { _PDATA
, RELOC_SECTION_PDATA
},
4204 { _FINI
, RELOC_SECTION_FINI
},
4205 { _LITA
, RELOC_SECTION_LITA
},
4206 { "*ABS*", RELOC_SECTION_ABS
},
4207 { _RCONST
, RELOC_SECTION_RCONST
}
4210 name
= bfd_get_section_name (output_bfd
, section
);
4212 for (i
= 0; i
< ARRAY_SIZE (section_symndx
); i
++)
4213 if (streq (name
, section_symndx
[i
].name
))
4215 in
.r_symndx
= section_symndx
[i
].r_symndx
;
4219 if (i
== ARRAY_SIZE (section_symndx
))
4225 /* Let the BFD backend adjust the reloc. */
4226 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4228 /* Get some memory and swap out the reloc. */
4229 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4230 rbuf
= (bfd_byte
*) bfd_malloc (external_reloc_size
);
4234 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (void *) rbuf
);
4236 pos
= (output_section
->rel_filepos
4237 + output_section
->reloc_count
* external_reloc_size
);
4238 ok
= (bfd_seek (output_bfd
, pos
, SEEK_SET
) == 0
4239 && (bfd_bwrite ((void *) rbuf
, external_reloc_size
, output_bfd
)
4240 == external_reloc_size
));
4243 ++output_section
->reloc_count
;
4250 /* Put out information for an external symbol. These come only from
4254 ecoff_link_write_external (struct bfd_hash_entry
*bh
, void * data
)
4256 struct ecoff_link_hash_entry
*h
= (struct ecoff_link_hash_entry
*) bh
;
4257 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4258 bfd
*output_bfd
= einfo
->abfd
;
4261 if (h
->root
.type
== bfd_link_hash_warning
)
4263 h
= (struct ecoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4264 if (h
->root
.type
== bfd_link_hash_new
)
4268 /* We need to check if this symbol is being stripped. */
4269 if (h
->root
.type
== bfd_link_hash_undefined
4270 || h
->root
.type
== bfd_link_hash_undefweak
)
4272 else if (einfo
->info
->strip
== strip_all
4273 || (einfo
->info
->strip
== strip_some
4274 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4275 h
->root
.root
.string
,
4276 FALSE
, FALSE
) == NULL
))
4281 if (strip
|| h
->written
)
4284 if (h
->abfd
== NULL
)
4287 h
->esym
.cobol_main
= 0;
4288 h
->esym
.weakext
= 0;
4289 h
->esym
.reserved
= 0;
4290 h
->esym
.ifd
= ifdNil
;
4291 h
->esym
.asym
.value
= 0;
4292 h
->esym
.asym
.st
= stGlobal
;
4294 if (h
->root
.type
!= bfd_link_hash_defined
4295 && h
->root
.type
!= bfd_link_hash_defweak
)
4296 h
->esym
.asym
.sc
= scAbs
;
4299 asection
*output_section
;
4307 section_storage_classes
[] =
4311 { _SDATA
, scSData
},
4312 { _RDATA
, scRData
},
4317 { _PDATA
, scPData
},
4318 { _XDATA
, scXData
},
4319 { _RCONST
, scRConst
}
4322 output_section
= h
->root
.u
.def
.section
->output_section
;
4323 name
= bfd_section_name (output_section
->owner
, output_section
);
4325 for (i
= 0; i
< ARRAY_SIZE (section_storage_classes
); i
++)
4326 if (streq (name
, section_storage_classes
[i
].name
))
4328 h
->esym
.asym
.sc
= section_storage_classes
[i
].sc
;
4332 if (i
== ARRAY_SIZE (section_storage_classes
))
4333 h
->esym
.asym
.sc
= scAbs
;
4336 h
->esym
.asym
.reserved
= 0;
4337 h
->esym
.asym
.index
= indexNil
;
4339 else if (h
->esym
.ifd
!= -1)
4341 struct ecoff_debug_info
*debug
;
4343 /* Adjust the FDR index for the symbol by that used for the
4345 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4346 BFD_ASSERT (h
->esym
.ifd
>= 0
4347 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4348 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4351 switch (h
->root
.type
)
4354 case bfd_link_hash_warning
:
4355 case bfd_link_hash_new
:
4357 case bfd_link_hash_undefined
:
4358 case bfd_link_hash_undefweak
:
4359 if (h
->esym
.asym
.sc
!= scUndefined
4360 && h
->esym
.asym
.sc
!= scSUndefined
)
4361 h
->esym
.asym
.sc
= scUndefined
;
4363 case bfd_link_hash_defined
:
4364 case bfd_link_hash_defweak
:
4365 if (h
->esym
.asym
.sc
== scUndefined
4366 || h
->esym
.asym
.sc
== scSUndefined
)
4367 h
->esym
.asym
.sc
= scAbs
;
4368 else if (h
->esym
.asym
.sc
== scCommon
)
4369 h
->esym
.asym
.sc
= scBss
;
4370 else if (h
->esym
.asym
.sc
== scSCommon
)
4371 h
->esym
.asym
.sc
= scSBss
;
4372 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4373 + h
->root
.u
.def
.section
->output_section
->vma
4374 + h
->root
.u
.def
.section
->output_offset
);
4376 case bfd_link_hash_common
:
4377 if (h
->esym
.asym
.sc
!= scCommon
4378 && h
->esym
.asym
.sc
!= scSCommon
)
4379 h
->esym
.asym
.sc
= scCommon
;
4380 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4382 case bfd_link_hash_indirect
:
4383 /* We ignore these symbols, since the indirected symbol is
4384 already in the hash table. */
4388 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4390 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4393 return (bfd_ecoff_debug_one_external
4394 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4395 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4399 /* ECOFF final link routine. This looks through all the input BFDs
4400 and gathers together all the debugging information, and then
4401 processes all the link order information. This may cause it to
4402 close and reopen some input BFDs; I'll see how bad this is. */
4405 _bfd_ecoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
4407 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4408 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4413 struct bfd_link_order
*p
;
4414 struct extsym_info einfo
;
4416 /* We accumulate the debugging information counts in the symbolic
4418 symhdr
= &debug
->symbolic_header
;
4420 symhdr
->ilineMax
= 0;
4424 symhdr
->isymMax
= 0;
4425 symhdr
->ioptMax
= 0;
4426 symhdr
->iauxMax
= 0;
4428 symhdr
->issExtMax
= 0;
4431 symhdr
->iextMax
= 0;
4433 /* We accumulate the debugging information itself in the debug_info
4436 debug
->external_dnr
= NULL
;
4437 debug
->external_pdr
= NULL
;
4438 debug
->external_sym
= NULL
;
4439 debug
->external_opt
= NULL
;
4440 debug
->external_aux
= NULL
;
4442 debug
->ssext
= debug
->ssext_end
= NULL
;
4443 debug
->external_fdr
= NULL
;
4444 debug
->external_rfd
= NULL
;
4445 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4447 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4451 /* Accumulate the debugging symbols from each input BFD. */
4452 for (input_bfd
= info
->input_bfds
;
4454 input_bfd
= input_bfd
->link_next
)
4458 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4460 /* Arbitrarily set the symbolic header vstamp to the vstamp
4461 of the first object file in the link. */
4462 if (symhdr
->vstamp
== 0)
4464 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4465 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4469 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4470 debug
, &backend
->debug_swap
,
4475 /* Combine the register masks. */
4476 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4477 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4478 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4479 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4480 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4481 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4484 /* Write out the external symbols. */
4487 bfd_hash_traverse (&info
->hash
->table
, ecoff_link_write_external
, &einfo
);
4489 if (info
->relocatable
)
4491 /* We need to make a pass over the link_orders to count up the
4492 number of relocations we will need to output, so that we know
4493 how much space they will take up. */
4494 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4497 for (p
= o
->map_head
.link_order
;
4500 if (p
->type
== bfd_indirect_link_order
)
4501 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4502 else if (p
->type
== bfd_section_reloc_link_order
4503 || p
->type
== bfd_symbol_reloc_link_order
)
4508 /* Compute the reloc and symbol file positions. */
4509 ecoff_compute_reloc_file_positions (abfd
);
4511 /* Write out the debugging information. */
4512 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4513 &backend
->debug_swap
, info
,
4514 ecoff_data (abfd
)->sym_filepos
))
4517 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4519 if (info
->relocatable
)
4521 /* Now reset the reloc_count field of the sections in the output
4522 BFD to 0, so that we can use them to keep track of how many
4523 relocs we have output thus far. */
4524 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4528 /* Get a value for the GP register. */
4529 if (ecoff_data (abfd
)->gp
== 0)
4531 struct bfd_link_hash_entry
*h
;
4533 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
4535 && h
->type
== bfd_link_hash_defined
)
4536 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4537 + h
->u
.def
.section
->output_section
->vma
4538 + h
->u
.def
.section
->output_offset
);
4539 else if (info
->relocatable
)
4543 /* Make up a value. */
4545 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4548 && (streq (o
->name
, _SBSS
)
4549 || streq (o
->name
, _SDATA
)
4550 || streq (o
->name
, _LIT4
)
4551 || streq (o
->name
, _LIT8
)
4552 || streq (o
->name
, _LITA
)))
4555 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4559 /* If the relocate_section function needs to do a reloc
4560 involving the GP value, it should make a reloc_dangerous
4561 callback to warn that GP is not defined. */
4565 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4567 for (p
= o
->map_head
.link_order
;
4571 if (p
->type
== bfd_indirect_link_order
4572 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4573 == bfd_target_ecoff_flavour
))
4575 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4578 else if (p
->type
== bfd_section_reloc_link_order
4579 || p
->type
== bfd_symbol_reloc_link_order
)
4581 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4586 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4592 bfd_get_symcount (abfd
) = symhdr
->iextMax
+ symhdr
->isymMax
;
4594 ecoff_data (abfd
)->linker
= TRUE
;