1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright 1990, 1991, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
4 Original version by Per Bothner.
5 Full support added by Ian Lance Taylor, ian@cygnus.com.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
28 #include "aout/ranlib.h"
29 #include "aout/stab_gnu.h"
31 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
32 some other stuff which we don't want and which conflicts with stuff
35 #include "aout/aout64.h"
38 #undef obj_sym_filepos
40 #include "coff/internal.h"
42 #include "coff/symconst.h"
43 #include "coff/ecoff.h"
46 #include "libiberty.h"
48 #define streq(a, b) (strcmp ((a), (b)) == 0)
49 #define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0)
52 /* This stuff is somewhat copied from coffcode.h. */
53 static asection bfd_debug_section
=
55 /* name, id, index, next, prev, flags, user_set_vma, */
56 "*DEBUG*", 0, 0, NULL
, NULL
, 0, 0,
57 /* linker_mark, linker_has_input, gc_mark, gc_mark_from_eh, */
59 /* segment_mark, sec_info_type, use_rela_p, has_tls_reloc, */
61 /* has_gp_reloc, need_finalize_relax, reloc_done, */
63 /* vma, lma, size, rawsize, */
65 /* output_offset, output_section, alignment_power, */
67 /* relocation, orelocation, reloc_count, filepos, rel_filepos, */
69 /* line_filepos, userdata, contents, lineno, lineno_count, */
70 0, NULL
, NULL
, NULL
, 0,
71 /* entsize, kept_section, moving_line_filepos, */
73 /* target_index, used_by_bfd, constructor_chain, owner, */
79 /* map_head, map_tail */
83 /* Create an ECOFF object. */
86 _bfd_ecoff_mkobject (bfd
*abfd
)
88 bfd_size_type amt
= sizeof (ecoff_data_type
);
90 abfd
->tdata
.ecoff_obj_data
= bfd_zalloc (abfd
, amt
);
91 if (abfd
->tdata
.ecoff_obj_data
== NULL
)
97 /* This is a hook called by coff_real_object_p to create any backend
98 specific information. */
101 _bfd_ecoff_mkobject_hook (bfd
*abfd
, void * filehdr
, void * aouthdr
)
103 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
104 struct internal_aouthdr
*internal_a
= (struct internal_aouthdr
*) aouthdr
;
105 ecoff_data_type
*ecoff
;
107 if (! _bfd_ecoff_mkobject (abfd
))
110 ecoff
= ecoff_data (abfd
);
112 ecoff
->sym_filepos
= internal_f
->f_symptr
;
114 if (internal_a
!= NULL
)
118 ecoff
->text_start
= internal_a
->text_start
;
119 ecoff
->text_end
= internal_a
->text_start
+ internal_a
->tsize
;
120 ecoff
->gp
= internal_a
->gp_value
;
121 ecoff
->gprmask
= internal_a
->gprmask
;
122 for (i
= 0; i
< 4; i
++)
123 ecoff
->cprmask
[i
] = internal_a
->cprmask
[i
];
124 ecoff
->fprmask
= internal_a
->fprmask
;
125 if (internal_a
->magic
== ECOFF_AOUT_ZMAGIC
)
126 abfd
->flags
|= D_PAGED
;
128 abfd
->flags
&=~ D_PAGED
;
131 /* It turns out that no special action is required by the MIPS or
132 Alpha ECOFF backends. They have different information in the
133 a.out header, but we just copy it all (e.g., gprmask, cprmask and
134 fprmask) and let the swapping routines ensure that only relevant
135 information is written out. */
137 return (void *) ecoff
;
140 /* Initialize a new section. */
143 _bfd_ecoff_new_section_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
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
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
= 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
);
236 /* Get the magic number to use based on the architecture and machine.
237 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
240 ecoff_get_magic (bfd
*abfd
)
244 switch (bfd_get_arch (abfd
))
247 switch (bfd_get_mach (abfd
))
251 case bfd_mach_mips3000
:
252 big
= MIPS_MAGIC_BIG
;
253 little
= MIPS_MAGIC_LITTLE
;
256 case bfd_mach_mips6000
:
257 big
= MIPS_MAGIC_BIG2
;
258 little
= MIPS_MAGIC_LITTLE2
;
261 case bfd_mach_mips4000
:
262 big
= MIPS_MAGIC_BIG3
;
263 little
= MIPS_MAGIC_LITTLE3
;
267 return bfd_big_endian (abfd
) ? big
: little
;
278 /* Get the section s_flags to use for a section. */
281 ecoff_sec_to_styp_flags (const char *name
, flagword flags
)
291 { _TEXT
, STYP_TEXT
},
292 { _DATA
, STYP_DATA
},
293 { _SDATA
, STYP_SDATA
},
294 { _RDATA
, STYP_RDATA
},
295 { _LITA
, STYP_LITA
},
296 { _LIT8
, STYP_LIT8
},
297 { _LIT4
, STYP_LIT4
},
299 { _SBSS
, STYP_SBSS
},
300 { _INIT
, STYP_ECOFF_INIT
},
301 { _FINI
, STYP_ECOFF_FINI
},
302 { _PDATA
, STYP_PDATA
},
303 { _XDATA
, STYP_XDATA
},
304 { _LIB
, STYP_ECOFF_LIB
},
306 { _HASH
, STYP_HASH
},
307 { _DYNAMIC
, STYP_DYNAMIC
},
308 { _LIBLIST
, STYP_LIBLIST
},
309 { _RELDYN
, STYP_RELDYN
},
310 { _CONFLIC
, STYP_CONFLIC
},
311 { _DYNSTR
, STYP_DYNSTR
},
312 { _DYNSYM
, STYP_DYNSYM
},
313 { _RCONST
, STYP_RCONST
}
317 for (i
= 0; i
< ARRAY_SIZE (styp_flags
); i
++)
318 if (streq (name
, styp_flags
[i
].name
))
320 styp
= styp_flags
[i
].flags
;
326 if (streq (name
, _COMMENT
))
329 flags
&=~ SEC_NEVER_LOAD
;
331 else if (flags
& SEC_CODE
)
333 else if (flags
& SEC_DATA
)
335 else if (flags
& SEC_READONLY
)
337 else if (flags
& SEC_LOAD
)
343 if (flags
& SEC_NEVER_LOAD
)
349 /* Get the BFD flags to use for a section. */
352 _bfd_ecoff_styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
354 const char *name ATTRIBUTE_UNUSED
,
355 asection
*section ATTRIBUTE_UNUSED
,
356 flagword
* flags_ptr
)
358 struct internal_scnhdr
*internal_s
= hdr
;
359 long styp_flags
= internal_s
->s_flags
;
360 flagword sec_flags
= 0;
362 if (styp_flags
& STYP_NOLOAD
)
363 sec_flags
|= SEC_NEVER_LOAD
;
365 /* For 386 COFF, at least, an unloadable text or data section is
366 actually a shared library section. */
367 if ((styp_flags
& STYP_TEXT
)
368 || (styp_flags
& STYP_ECOFF_INIT
)
369 || (styp_flags
& STYP_ECOFF_FINI
)
370 || (styp_flags
& STYP_DYNAMIC
)
371 || (styp_flags
& STYP_LIBLIST
)
372 || (styp_flags
& STYP_RELDYN
)
373 || styp_flags
== STYP_CONFLIC
374 || (styp_flags
& STYP_DYNSTR
)
375 || (styp_flags
& STYP_DYNSYM
)
376 || (styp_flags
& STYP_HASH
))
378 if (sec_flags
& SEC_NEVER_LOAD
)
379 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
381 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
383 else if ((styp_flags
& STYP_DATA
)
384 || (styp_flags
& STYP_RDATA
)
385 || (styp_flags
& STYP_SDATA
)
386 || styp_flags
== STYP_PDATA
387 || styp_flags
== STYP_XDATA
388 || (styp_flags
& STYP_GOT
)
389 || styp_flags
== STYP_RCONST
)
391 if (sec_flags
& SEC_NEVER_LOAD
)
392 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
394 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
395 if ((styp_flags
& STYP_RDATA
)
396 || styp_flags
== STYP_PDATA
397 || styp_flags
== STYP_RCONST
)
398 sec_flags
|= SEC_READONLY
;
400 else if ((styp_flags
& STYP_BSS
)
401 || (styp_flags
& STYP_SBSS
))
402 sec_flags
|= SEC_ALLOC
;
403 else if ((styp_flags
& STYP_INFO
) || styp_flags
== STYP_COMMENT
)
404 sec_flags
|= SEC_NEVER_LOAD
;
405 else if ((styp_flags
& STYP_LITA
)
406 || (styp_flags
& STYP_LIT8
)
407 || (styp_flags
& STYP_LIT4
))
408 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
409 else if (styp_flags
& STYP_ECOFF_LIB
)
410 sec_flags
|= SEC_COFF_SHARED_LIBRARY
;
412 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
414 * flags_ptr
= sec_flags
;
418 /* Read in the symbolic header for an ECOFF object file. */
421 ecoff_slurp_symbolic_header (bfd
*abfd
)
423 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
424 bfd_size_type external_hdr_size
;
426 HDRR
*internal_symhdr
;
428 /* See if we've already read it in. */
429 if (ecoff_data (abfd
)->debug_info
.symbolic_header
.magic
==
430 backend
->debug_swap
.sym_magic
)
433 /* See whether there is a symbolic header. */
434 if (ecoff_data (abfd
)->sym_filepos
== 0)
436 bfd_get_symcount (abfd
) = 0;
440 /* At this point bfd_get_symcount (abfd) holds the number of symbols
441 as read from the file header, but on ECOFF this is always the
442 size of the symbolic information header. It would be cleaner to
443 handle this when we first read the file in coffgen.c. */
444 external_hdr_size
= backend
->debug_swap
.external_hdr_size
;
445 if (bfd_get_symcount (abfd
) != external_hdr_size
)
447 bfd_set_error (bfd_error_bad_value
);
451 /* Read the symbolic information header. */
452 raw
= bfd_malloc (external_hdr_size
);
456 if (bfd_seek (abfd
, ecoff_data (abfd
)->sym_filepos
, SEEK_SET
) != 0
457 || bfd_bread (raw
, external_hdr_size
, abfd
) != external_hdr_size
)
459 internal_symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
460 (*backend
->debug_swap
.swap_hdr_in
) (abfd
, raw
, internal_symhdr
);
462 if (internal_symhdr
->magic
!= backend
->debug_swap
.sym_magic
)
464 bfd_set_error (bfd_error_bad_value
);
468 /* Now we can get the correct number of symbols. */
469 bfd_get_symcount (abfd
) = (internal_symhdr
->isymMax
470 + internal_symhdr
->iextMax
);
481 /* Read in and swap the important symbolic information for an ECOFF
482 object file. This is called by gdb via the read_debug_info entry
483 point in the backend structure. */
486 _bfd_ecoff_slurp_symbolic_info (bfd
*abfd
,
487 asection
*ignore ATTRIBUTE_UNUSED
,
488 struct ecoff_debug_info
*debug
)
490 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
491 HDRR
*internal_symhdr
;
492 bfd_size_type raw_base
;
493 bfd_size_type raw_size
;
495 bfd_size_type external_fdr_size
;
499 bfd_size_type raw_end
;
500 bfd_size_type cb_end
;
504 BFD_ASSERT (debug
== &ecoff_data (abfd
)->debug_info
);
506 /* Check whether we've already gotten it, and whether there's any to
508 if (ecoff_data (abfd
)->raw_syments
!= NULL
)
510 if (ecoff_data (abfd
)->sym_filepos
== 0)
512 bfd_get_symcount (abfd
) = 0;
516 if (! ecoff_slurp_symbolic_header (abfd
))
519 internal_symhdr
= &debug
->symbolic_header
;
521 /* Read all the symbolic information at once. */
522 raw_base
= (ecoff_data (abfd
)->sym_filepos
523 + backend
->debug_swap
.external_hdr_size
);
525 /* Alpha ecoff makes the determination of raw_size difficult. It has
526 an undocumented debug data section between the symhdr and the first
527 documented section. And the ordering of the sections varies between
528 statically and dynamically linked executables.
529 If bfd supports SEEK_END someday, this code could be simplified. */
532 #define UPDATE_RAW_END(start, count, size) \
533 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
534 if (cb_end > raw_end) \
537 UPDATE_RAW_END (cbLineOffset
, cbLine
, sizeof (unsigned char));
538 UPDATE_RAW_END (cbDnOffset
, idnMax
, backend
->debug_swap
.external_dnr_size
);
539 UPDATE_RAW_END (cbPdOffset
, ipdMax
, backend
->debug_swap
.external_pdr_size
);
540 UPDATE_RAW_END (cbSymOffset
, isymMax
, backend
->debug_swap
.external_sym_size
);
541 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
542 optimization symtab, not the number of entries. */
543 UPDATE_RAW_END (cbOptOffset
, ioptMax
, sizeof (char));
544 UPDATE_RAW_END (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
545 UPDATE_RAW_END (cbSsOffset
, issMax
, sizeof (char));
546 UPDATE_RAW_END (cbSsExtOffset
, issExtMax
, sizeof (char));
547 UPDATE_RAW_END (cbFdOffset
, ifdMax
, backend
->debug_swap
.external_fdr_size
);
548 UPDATE_RAW_END (cbRfdOffset
, crfd
, backend
->debug_swap
.external_rfd_size
);
549 UPDATE_RAW_END (cbExtOffset
, iextMax
, backend
->debug_swap
.external_ext_size
);
551 #undef UPDATE_RAW_END
553 raw_size
= raw_end
- raw_base
;
556 ecoff_data (abfd
)->sym_filepos
= 0;
559 raw
= bfd_alloc (abfd
, raw_size
);
563 pos
= ecoff_data (abfd
)->sym_filepos
;
564 pos
+= backend
->debug_swap
.external_hdr_size
;
565 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
566 || bfd_bread (raw
, raw_size
, abfd
) != raw_size
)
568 bfd_release (abfd
, raw
);
572 ecoff_data (abfd
)->raw_syments
= raw
;
574 /* Get pointers for the numeric offsets in the HDRR structure. */
575 #define FIX(off1, off2, type) \
576 if (internal_symhdr->off1 == 0) \
577 debug->off2 = NULL; \
579 debug->off2 = (type) ((char *) raw \
580 + (internal_symhdr->off1 \
583 FIX (cbLineOffset
, line
, unsigned char *);
584 FIX (cbDnOffset
, external_dnr
, void *);
585 FIX (cbPdOffset
, external_pdr
, void *);
586 FIX (cbSymOffset
, external_sym
, void *);
587 FIX (cbOptOffset
, external_opt
, void *);
588 FIX (cbAuxOffset
, external_aux
, union aux_ext
*);
589 FIX (cbSsOffset
, ss
, char *);
590 FIX (cbSsExtOffset
, ssext
, char *);
591 FIX (cbFdOffset
, external_fdr
, void *);
592 FIX (cbRfdOffset
, external_rfd
, void *);
593 FIX (cbExtOffset
, external_ext
, void *);
596 /* I don't want to always swap all the data, because it will just
597 waste time and most programs will never look at it. The only
598 time the linker needs most of the debugging information swapped
599 is when linking big-endian and little-endian MIPS object files
600 together, which is not a common occurrence.
602 We need to look at the fdr to deal with a lot of information in
603 the symbols, so we swap them here. */
604 amt
= internal_symhdr
->ifdMax
;
605 amt
*= sizeof (struct fdr
);
606 debug
->fdr
= bfd_alloc (abfd
, amt
);
607 if (debug
->fdr
== NULL
)
609 external_fdr_size
= backend
->debug_swap
.external_fdr_size
;
610 fdr_ptr
= debug
->fdr
;
611 fraw_src
= (char *) debug
->external_fdr
;
612 fraw_end
= fraw_src
+ internal_symhdr
->ifdMax
* external_fdr_size
;
613 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
614 (*backend
->debug_swap
.swap_fdr_in
) (abfd
, (void *) fraw_src
, fdr_ptr
);
619 /* ECOFF symbol table routines. The ECOFF symbol table is described
620 in gcc/mips-tfile.c. */
622 /* ECOFF uses two common sections. One is the usual one, and the
623 other is for small objects. All the small objects are kept
624 together, and then referenced via the gp pointer, which yields
625 faster assembler code. This is what we use for the small common
627 static asection ecoff_scom_section
;
628 static asymbol ecoff_scom_symbol
;
629 static asymbol
*ecoff_scom_symbol_ptr
;
631 /* Create an empty symbol. */
634 _bfd_ecoff_make_empty_symbol (bfd
*abfd
)
636 ecoff_symbol_type
*new;
637 bfd_size_type amt
= sizeof (ecoff_symbol_type
);
639 new = bfd_zalloc (abfd
, amt
);
642 new->symbol
.section
= NULL
;
646 new->symbol
.the_bfd
= abfd
;
650 /* Set the BFD flags and section for an ECOFF symbol. */
653 ecoff_set_symbol_info (bfd
*abfd
,
659 asym
->the_bfd
= abfd
;
660 asym
->value
= ecoff_sym
->value
;
661 asym
->section
= &bfd_debug_section
;
664 /* Most symbol types are just for debugging. */
665 switch (ecoff_sym
->st
)
674 if (ECOFF_IS_STAB (ecoff_sym
))
676 asym
->flags
= BSF_DEBUGGING
;
681 asym
->flags
= BSF_DEBUGGING
;
686 asym
->flags
= BSF_EXPORT
| BSF_WEAK
;
688 asym
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
691 asym
->flags
= BSF_LOCAL
;
692 /* Normally, a local stProc symbol will have a corresponding
693 external symbol. We mark the local symbol as a debugging
694 symbol, in order to prevent nm from printing both out.
695 Similarly, we mark stLabel and stabs symbols as debugging
696 symbols. In both cases, we do want to set the value
697 correctly based on the symbol class. */
698 if (ecoff_sym
->st
== stProc
699 || ecoff_sym
->st
== stLabel
700 || ECOFF_IS_STAB (ecoff_sym
))
701 asym
->flags
|= BSF_DEBUGGING
;
704 if (ecoff_sym
->st
== stProc
|| ecoff_sym
->st
== stStaticProc
)
705 asym
->flags
|= BSF_FUNCTION
;
707 switch (ecoff_sym
->sc
)
710 /* Used for compiler generated labels. Leave them in the
711 debugging section, and mark them as local. If BSF_DEBUGGING
712 is set, then nm does not display them for some reason. If no
713 flags are set then the linker whines about them. */
714 asym
->flags
= BSF_LOCAL
;
717 asym
->section
= bfd_make_section_old_way (abfd
, _TEXT
);
718 asym
->value
-= asym
->section
->vma
;
721 asym
->section
= bfd_make_section_old_way (abfd
, _DATA
);
722 asym
->value
-= asym
->section
->vma
;
725 asym
->section
= bfd_make_section_old_way (abfd
, _BSS
);
726 asym
->value
-= asym
->section
->vma
;
729 asym
->flags
= BSF_DEBUGGING
;
732 asym
->section
= bfd_abs_section_ptr
;
735 asym
->section
= bfd_und_section_ptr
;
745 asym
->flags
= BSF_DEBUGGING
;
748 asym
->section
= bfd_make_section_old_way (abfd
, ".sdata");
749 asym
->value
-= asym
->section
->vma
;
752 asym
->section
= bfd_make_section_old_way (abfd
, ".sbss");
753 asym
->value
-= asym
->section
->vma
;
756 asym
->section
= bfd_make_section_old_way (abfd
, ".rdata");
757 asym
->value
-= asym
->section
->vma
;
760 asym
->flags
= BSF_DEBUGGING
;
763 if (asym
->value
> ecoff_data (abfd
)->gp_size
)
765 asym
->section
= bfd_com_section_ptr
;
771 if (ecoff_scom_section
.name
== NULL
)
773 /* Initialize the small common section. */
774 ecoff_scom_section
.name
= SCOMMON
;
775 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
776 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
777 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
778 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
779 ecoff_scom_symbol
.name
= SCOMMON
;
780 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
781 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
782 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
784 asym
->section
= &ecoff_scom_section
;
789 asym
->flags
= BSF_DEBUGGING
;
792 asym
->section
= bfd_und_section_ptr
;
797 asym
->section
= bfd_make_section_old_way (abfd
, ".init");
798 asym
->value
-= asym
->section
->vma
;
803 asym
->flags
= BSF_DEBUGGING
;
806 asym
->section
= bfd_make_section_old_way (abfd
, ".fini");
807 asym
->value
-= asym
->section
->vma
;
810 asym
->section
= bfd_make_section_old_way (abfd
, ".rconst");
811 asym
->value
-= asym
->section
->vma
;
817 /* Look for special constructors symbols and make relocation entries
818 in a special construction section. These are produced by the
819 -fgnu-linker argument to g++. */
820 if (ECOFF_IS_STAB (ecoff_sym
))
822 switch (ECOFF_UNMARK_STAB (ecoff_sym
->index
))
831 /* Mark the symbol as a constructor. */
832 asym
->flags
|= BSF_CONSTRUCTOR
;
839 /* Read an ECOFF symbol table. */
842 _bfd_ecoff_slurp_symbol_table (bfd
*abfd
)
844 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
845 const bfd_size_type external_ext_size
846 = backend
->debug_swap
.external_ext_size
;
847 const bfd_size_type external_sym_size
848 = backend
->debug_swap
.external_sym_size
;
849 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
850 = backend
->debug_swap
.swap_ext_in
;
851 void (* const swap_sym_in
) (bfd
*, void *, SYMR
*)
852 = backend
->debug_swap
.swap_sym_in
;
853 bfd_size_type internal_size
;
854 ecoff_symbol_type
*internal
;
855 ecoff_symbol_type
*internal_ptr
;
861 /* If we've already read in the symbol table, do nothing. */
862 if (ecoff_data (abfd
)->canonical_symbols
!= NULL
)
865 /* Get the symbolic information. */
866 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
867 &ecoff_data (abfd
)->debug_info
))
869 if (bfd_get_symcount (abfd
) == 0)
872 internal_size
= bfd_get_symcount (abfd
);
873 internal_size
*= sizeof (ecoff_symbol_type
);
874 internal
= bfd_alloc (abfd
, internal_size
);
875 if (internal
== NULL
)
878 internal_ptr
= internal
;
879 eraw_src
= (char *) ecoff_data (abfd
)->debug_info
.external_ext
;
881 + (ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
882 * external_ext_size
));
883 for (; eraw_src
< eraw_end
; eraw_src
+= external_ext_size
, internal_ptr
++)
887 (*swap_ext_in
) (abfd
, (void *) eraw_src
, &internal_esym
);
888 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ssext
889 + internal_esym
.asym
.iss
);
890 if (!ecoff_set_symbol_info (abfd
, &internal_esym
.asym
,
891 &internal_ptr
->symbol
, 1,
892 internal_esym
.weakext
))
894 /* The alpha uses a negative ifd field for section symbols. */
895 if (internal_esym
.ifd
>= 0)
896 internal_ptr
->fdr
= (ecoff_data (abfd
)->debug_info
.fdr
897 + internal_esym
.ifd
);
899 internal_ptr
->fdr
= NULL
;
900 internal_ptr
->local
= FALSE
;
901 internal_ptr
->native
= (void *) eraw_src
;
904 /* The local symbols must be accessed via the fdr's, because the
905 string and aux indices are relative to the fdr information. */
906 fdr_ptr
= ecoff_data (abfd
)->debug_info
.fdr
;
907 fdr_end
= fdr_ptr
+ ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
;
908 for (; fdr_ptr
< fdr_end
; fdr_ptr
++)
913 lraw_src
= ((char *) ecoff_data (abfd
)->debug_info
.external_sym
914 + fdr_ptr
->isymBase
* external_sym_size
);
915 lraw_end
= lraw_src
+ fdr_ptr
->csym
* external_sym_size
;
918 lraw_src
+= external_sym_size
, internal_ptr
++)
922 (*swap_sym_in
) (abfd
, (void *) lraw_src
, &internal_sym
);
923 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ss
926 if (!ecoff_set_symbol_info (abfd
, &internal_sym
,
927 &internal_ptr
->symbol
, 0, 0))
929 internal_ptr
->fdr
= fdr_ptr
;
930 internal_ptr
->local
= TRUE
;
931 internal_ptr
->native
= (void *) lraw_src
;
935 ecoff_data (abfd
)->canonical_symbols
= internal
;
940 /* Return the amount of space needed for the canonical symbols. */
943 _bfd_ecoff_get_symtab_upper_bound (bfd
*abfd
)
945 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
946 &ecoff_data (abfd
)->debug_info
))
949 if (bfd_get_symcount (abfd
) == 0)
952 return (bfd_get_symcount (abfd
) + 1) * (sizeof (ecoff_symbol_type
*));
955 /* Get the canonical symbols. */
958 _bfd_ecoff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
960 unsigned int counter
= 0;
961 ecoff_symbol_type
*symbase
;
962 ecoff_symbol_type
**location
= (ecoff_symbol_type
**) alocation
;
964 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
966 if (bfd_get_symcount (abfd
) == 0)
969 symbase
= ecoff_data (abfd
)->canonical_symbols
;
970 while (counter
< bfd_get_symcount (abfd
))
972 *(location
++) = symbase
++;
976 return bfd_get_symcount (abfd
);
979 /* Turn ECOFF type information into a printable string.
980 ecoff_emit_aggregate and ecoff_type_to_string are from
981 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
983 /* Write aggregate information to a string. */
986 ecoff_emit_aggregate (bfd
*abfd
,
993 const struct ecoff_debug_swap
* const debug_swap
=
994 &ecoff_backend (abfd
)->debug_swap
;
995 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
996 unsigned int ifd
= rndx
->rfd
;
997 unsigned int indx
= rndx
->index
;
1003 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1004 struct return type of a procedure compiled without -g. */
1005 if (ifd
== 0xffffffff
1006 || (rndx
->rfd
== 0xfff && indx
== 0))
1007 name
= "<undefined>";
1008 else if (indx
== indexNil
)
1014 if (debug_info
->external_rfd
== NULL
)
1015 fdr
= debug_info
->fdr
+ ifd
;
1020 (*debug_swap
->swap_rfd_in
) (abfd
,
1021 ((char *) debug_info
->external_rfd
1022 + ((fdr
->rfdBase
+ ifd
)
1023 * debug_swap
->external_rfd_size
)),
1025 fdr
= debug_info
->fdr
+ rfd
;
1028 indx
+= fdr
->isymBase
;
1030 (*debug_swap
->swap_sym_in
) (abfd
,
1031 ((char *) debug_info
->external_sym
1032 + indx
* debug_swap
->external_sym_size
),
1035 name
= debug_info
->ss
+ fdr
->issBase
+ sym
.iss
;
1039 "%s %s { ifd = %u, index = %lu }",
1042 + debug_info
->symbolic_header
.iextMax
));
1045 /* Convert the type information to string format. */
1048 ecoff_type_to_string (bfd
*abfd
, FDR
*fdr
, unsigned int indx
)
1050 union aux_ext
*aux_ptr
;
1060 unsigned int basic_type
;
1063 static char buffer2
[1024];
1068 aux_ptr
= ecoff_data (abfd
)->debug_info
.external_aux
+ fdr
->iauxBase
;
1069 bigendian
= fdr
->fBigendian
;
1071 for (i
= 0; i
< 7; i
++)
1073 qualifiers
[i
].low_bound
= 0;
1074 qualifiers
[i
].high_bound
= 0;
1075 qualifiers
[i
].stride
= 0;
1078 if (AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
]) == (bfd_vma
) -1)
1079 return "-1 (no type)";
1080 _bfd_ecoff_swap_tir_in (bigendian
, &aux_ptr
[indx
++].a_ti
, &u
.ti
);
1082 basic_type
= u
.ti
.bt
;
1083 qualifiers
[0].type
= u
.ti
.tq0
;
1084 qualifiers
[1].type
= u
.ti
.tq1
;
1085 qualifiers
[2].type
= u
.ti
.tq2
;
1086 qualifiers
[3].type
= u
.ti
.tq3
;
1087 qualifiers
[4].type
= u
.ti
.tq4
;
1088 qualifiers
[5].type
= u
.ti
.tq5
;
1089 qualifiers
[6].type
= tqNil
;
1091 /* Go get the basic type. */
1094 case btNil
: /* Undefined. */
1098 case btAdr
: /* Address - integer same size as pointer. */
1099 strcpy (p1
, "address");
1102 case btChar
: /* Character. */
1103 strcpy (p1
, "char");
1106 case btUChar
: /* Unsigned character. */
1107 strcpy (p1
, "unsigned char");
1110 case btShort
: /* Short. */
1111 strcpy (p1
, "short");
1114 case btUShort
: /* Unsigned short. */
1115 strcpy (p1
, "unsigned short");
1118 case btInt
: /* Int. */
1122 case btUInt
: /* Unsigned int. */
1123 strcpy (p1
, "unsigned int");
1126 case btLong
: /* Long. */
1127 strcpy (p1
, "long");
1130 case btULong
: /* Unsigned long. */
1131 strcpy (p1
, "unsigned long");
1134 case btFloat
: /* Float (real). */
1135 strcpy (p1
, "float");
1138 case btDouble
: /* Double (real). */
1139 strcpy (p1
, "double");
1142 /* Structures add 1-2 aux words:
1143 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1144 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1146 case btStruct
: /* Structure (Record). */
1147 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1148 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1149 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1151 indx
++; /* Skip aux words. */
1154 /* Unions add 1-2 aux words:
1155 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1156 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1158 case btUnion
: /* Union. */
1159 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1160 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1161 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1163 indx
++; /* Skip aux words. */
1166 /* Enumerations add 1-2 aux words:
1167 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1168 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1170 case btEnum
: /* Enumeration. */
1171 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1172 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1173 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1175 indx
++; /* Skip aux words. */
1178 case btTypedef
: /* Defined via a typedef, isymRef points. */
1179 strcpy (p1
, "typedef");
1182 case btRange
: /* Subrange of int. */
1183 strcpy (p1
, "subrange");
1186 case btSet
: /* Pascal sets. */
1190 case btComplex
: /* Fortran complex. */
1191 strcpy (p1
, "complex");
1194 case btDComplex
: /* Fortran double complex. */
1195 strcpy (p1
, "double complex");
1198 case btIndirect
: /* Forward or unnamed typedef. */
1199 strcpy (p1
, "forward/unamed typedef");
1202 case btFixedDec
: /* Fixed Decimal. */
1203 strcpy (p1
, "fixed decimal");
1206 case btFloatDec
: /* Float Decimal. */
1207 strcpy (p1
, "float decimal");
1210 case btString
: /* Varying Length Character String. */
1211 strcpy (p1
, "string");
1214 case btBit
: /* Aligned Bit String. */
1218 case btPicture
: /* Picture. */
1219 strcpy (p1
, "picture");
1222 case btVoid
: /* Void. */
1223 strcpy (p1
, "void");
1227 sprintf (p1
, _("Unknown basic type %d"), (int) basic_type
);
1231 p1
+= strlen (buffer1
);
1233 /* If this is a bitfield, get the bitsize. */
1238 bitsize
= AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
++]);
1239 sprintf (p1
, " : %d", bitsize
);
1240 p1
+= strlen (buffer1
);
1243 /* Deal with any qualifiers. */
1244 if (qualifiers
[0].type
!= tqNil
)
1246 /* Snarf up any array bounds in the correct order. Arrays
1247 store 5 successive words in the aux. table:
1248 word 0 RNDXR to type of the bounds (ie, int)
1249 word 1 Current file descriptor index
1251 word 3 high bound (or -1 if [])
1252 word 4 stride size in bits. */
1253 for (i
= 0; i
< 7; i
++)
1255 if (qualifiers
[i
].type
== tqArray
)
1257 qualifiers
[i
].low_bound
=
1258 AUX_GET_DNLOW (bigendian
, &aux_ptr
[indx
+2]);
1259 qualifiers
[i
].high_bound
=
1260 AUX_GET_DNHIGH (bigendian
, &aux_ptr
[indx
+3]);
1261 qualifiers
[i
].stride
=
1262 AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
+4]);
1267 /* Now print out the qualifiers. */
1268 for (i
= 0; i
< 6; i
++)
1270 switch (qualifiers
[i
].type
)
1277 strcpy (p2
, "ptr to ");
1278 p2
+= sizeof ("ptr to ")-1;
1282 strcpy (p2
, "volatile ");
1283 p2
+= sizeof ("volatile ")-1;
1287 strcpy (p2
, "far ");
1288 p2
+= sizeof ("far ")-1;
1292 strcpy (p2
, "func. ret. ");
1293 p2
+= sizeof ("func. ret. ");
1298 int first_array
= i
;
1301 /* Print array bounds reversed (ie, in the order the C
1302 programmer writes them). C is such a fun language.... */
1303 while (i
< 5 && qualifiers
[i
+1].type
== tqArray
)
1306 for (j
= i
; j
>= first_array
; j
--)
1308 strcpy (p2
, "array [");
1309 p2
+= sizeof ("array [")-1;
1310 if (qualifiers
[j
].low_bound
!= 0)
1312 "%ld:%ld {%ld bits}",
1313 (long) qualifiers
[j
].low_bound
,
1314 (long) qualifiers
[j
].high_bound
,
1315 (long) qualifiers
[j
].stride
);
1317 else if (qualifiers
[j
].high_bound
!= -1)
1320 (long) (qualifiers
[j
].high_bound
+ 1),
1321 (long) (qualifiers
[j
].stride
));
1324 sprintf (p2
, " {%ld bits}", (long) (qualifiers
[j
].stride
));
1327 strcpy (p2
, "] of ");
1328 p2
+= sizeof ("] of ")-1;
1336 strcpy (p2
, buffer1
);
1340 /* Return information about ECOFF symbol SYMBOL in RET. */
1343 _bfd_ecoff_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
1347 bfd_symbol_info (symbol
, ret
);
1350 /* Return whether this is a local label. */
1353 _bfd_ecoff_bfd_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1356 return name
[0] == '$';
1359 /* Print information about an ECOFF symbol. */
1362 _bfd_ecoff_print_symbol (bfd
*abfd
,
1365 bfd_print_symbol_type how
)
1367 const struct ecoff_debug_swap
* const debug_swap
1368 = &ecoff_backend (abfd
)->debug_swap
;
1369 FILE *file
= (FILE *)filep
;
1373 case bfd_print_symbol_name
:
1374 fprintf (file
, "%s", symbol
->name
);
1376 case bfd_print_symbol_more
:
1377 if (ecoffsymbol (symbol
)->local
)
1381 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1383 fprintf (file
, "ecoff local ");
1384 fprintf_vma (file
, (bfd_vma
) ecoff_sym
.value
);
1385 fprintf (file
, " %x %x", (unsigned) ecoff_sym
.st
,
1386 (unsigned) ecoff_sym
.sc
);
1392 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1394 fprintf (file
, "ecoff extern ");
1395 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1396 fprintf (file
, " %x %x", (unsigned) ecoff_ext
.asym
.st
,
1397 (unsigned) ecoff_ext
.asym
.sc
);
1400 case bfd_print_symbol_all
:
1401 /* Print out the symbols in a reasonable way. */
1410 if (ecoffsymbol (symbol
)->local
)
1412 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1415 pos
= ((((char *) ecoffsymbol (symbol
)->native
1416 - (char *) ecoff_data (abfd
)->debug_info
.external_sym
)
1417 / debug_swap
->external_sym_size
)
1418 + ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
);
1425 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1428 pos
= (((char *) ecoffsymbol (symbol
)->native
1429 - (char *) ecoff_data (abfd
)->debug_info
.external_ext
)
1430 / debug_swap
->external_ext_size
);
1431 jmptbl
= ecoff_ext
.jmptbl
? 'j' : ' ';
1432 cobol_main
= ecoff_ext
.cobol_main
? 'c' : ' ';
1433 weakext
= ecoff_ext
.weakext
? 'w' : ' ';
1436 fprintf (file
, "[%3d] %c ",
1438 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1439 fprintf (file
, " st %x sc %x indx %x %c%c%c %s",
1440 (unsigned) ecoff_ext
.asym
.st
,
1441 (unsigned) ecoff_ext
.asym
.sc
,
1442 (unsigned) ecoff_ext
.asym
.index
,
1443 jmptbl
, cobol_main
, weakext
,
1446 if (ecoffsymbol (symbol
)->fdr
!= NULL
1447 && ecoff_ext
.asym
.index
!= indexNil
)
1452 bfd_size_type sym_base
;
1453 union aux_ext
*aux_base
;
1455 fdr
= ecoffsymbol (symbol
)->fdr
;
1456 indx
= ecoff_ext
.asym
.index
;
1458 /* sym_base is used to map the fdr relative indices which
1459 appear in the file to the position number which we are
1461 sym_base
= fdr
->isymBase
;
1462 if (ecoffsymbol (symbol
)->local
)
1464 ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
1466 /* aux_base is the start of the aux entries for this file;
1467 asym.index is an offset from this. */
1468 aux_base
= (ecoff_data (abfd
)->debug_info
.external_aux
1471 /* The aux entries are stored in host byte order; the
1472 order is indicated by a bit in the fdr. */
1473 bigendian
= fdr
->fBigendian
;
1475 /* This switch is basically from gcc/mips-tdump.c. */
1476 switch (ecoff_ext
.asym
.st
)
1484 fprintf (file
, _("\n End+1 symbol: %ld"),
1485 (long) (indx
+ sym_base
));
1489 if (ecoff_ext
.asym
.sc
== scText
1490 || ecoff_ext
.asym
.sc
== scInfo
)
1491 fprintf (file
, _("\n First symbol: %ld"),
1492 (long) (indx
+ sym_base
));
1494 fprintf (file
, _("\n First symbol: %ld"),
1496 (AUX_GET_ISYM (bigendian
,
1497 &aux_base
[ecoff_ext
.asym
.index
])
1503 if (ECOFF_IS_STAB (&ecoff_ext
.asym
))
1505 else if (ecoffsymbol (symbol
)->local
)
1506 fprintf (file
, _("\n End+1 symbol: %-7ld Type: %s"),
1508 (AUX_GET_ISYM (bigendian
,
1509 &aux_base
[ecoff_ext
.asym
.index
])
1511 ecoff_type_to_string (abfd
, fdr
, indx
+ 1));
1513 fprintf (file
, _("\n Local symbol: %ld"),
1516 + (ecoff_data (abfd
)
1517 ->debug_info
.symbolic_header
.iextMax
)));
1521 fprintf (file
, _("\n struct; End+1 symbol: %ld"),
1522 (long) (indx
+ sym_base
));
1526 fprintf (file
, _("\n union; End+1 symbol: %ld"),
1527 (long) (indx
+ sym_base
));
1531 fprintf (file
, _("\n enum; End+1 symbol: %ld"),
1532 (long) (indx
+ sym_base
));
1536 if (! ECOFF_IS_STAB (&ecoff_ext
.asym
))
1537 fprintf (file
, _("\n Type: %s"),
1538 ecoff_type_to_string (abfd
, fdr
, indx
));
1547 /* Read in the relocs for a section. */
1550 ecoff_slurp_reloc_table (bfd
*abfd
,
1554 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1555 arelent
*internal_relocs
;
1556 bfd_size_type external_reloc_size
;
1558 char *external_relocs
;
1562 if (section
->relocation
!= NULL
1563 || section
->reloc_count
== 0
1564 || (section
->flags
& SEC_CONSTRUCTOR
) != 0)
1567 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1570 amt
= section
->reloc_count
;
1571 amt
*= sizeof (arelent
);
1572 internal_relocs
= bfd_alloc (abfd
, amt
);
1574 external_reloc_size
= backend
->external_reloc_size
;
1575 amt
= external_reloc_size
* section
->reloc_count
;
1576 external_relocs
= bfd_alloc (abfd
, amt
);
1577 if (internal_relocs
== NULL
|| external_relocs
== NULL
)
1579 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1581 if (bfd_bread (external_relocs
, amt
, abfd
) != amt
)
1584 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1586 struct internal_reloc intern
;
1588 (*backend
->swap_reloc_in
) (abfd
,
1589 external_relocs
+ i
* external_reloc_size
,
1592 if (intern
.r_extern
)
1594 /* r_symndx is an index into the external symbols. */
1595 BFD_ASSERT (intern
.r_symndx
>= 0
1597 < (ecoff_data (abfd
)
1598 ->debug_info
.symbolic_header
.iextMax
)));
1599 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1602 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1603 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1605 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1610 const char *sec_name
;
1613 /* r_symndx is a section key. */
1614 switch (intern
.r_symndx
)
1616 case RELOC_SECTION_TEXT
: sec_name
= _TEXT
; break;
1617 case RELOC_SECTION_RDATA
: sec_name
= _RDATA
; break;
1618 case RELOC_SECTION_DATA
: sec_name
= _DATA
; break;
1619 case RELOC_SECTION_SDATA
: sec_name
= _SDATA
; break;
1620 case RELOC_SECTION_SBSS
: sec_name
= _SBSS
; break;
1621 case RELOC_SECTION_BSS
: sec_name
= _BSS
; break;
1622 case RELOC_SECTION_INIT
: sec_name
= _INIT
; break;
1623 case RELOC_SECTION_LIT8
: sec_name
= _LIT8
; break;
1624 case RELOC_SECTION_LIT4
: sec_name
= _LIT4
; break;
1625 case RELOC_SECTION_XDATA
: sec_name
= _XDATA
; break;
1626 case RELOC_SECTION_PDATA
: sec_name
= _PDATA
; break;
1627 case RELOC_SECTION_FINI
: sec_name
= _FINI
; break;
1628 case RELOC_SECTION_LITA
: sec_name
= _LITA
; break;
1629 case RELOC_SECTION_RCONST
: sec_name
= _RCONST
; break;
1633 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1636 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1638 rptr
->addend
= - bfd_get_section_vma (abfd
, sec
);
1641 rptr
->address
= intern
.r_vaddr
- bfd_get_section_vma (abfd
, section
);
1643 /* Let the backend select the howto field and do any other
1644 required processing. */
1645 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1648 bfd_release (abfd
, external_relocs
);
1650 section
->relocation
= internal_relocs
;
1655 /* Get a canonical list of relocs. */
1658 _bfd_ecoff_canonicalize_reloc (bfd
*abfd
,
1665 if (section
->flags
& SEC_CONSTRUCTOR
)
1667 arelent_chain
*chain
;
1669 /* This section has relocs made up by us, not the file, so take
1670 them out of their chain and place them into the data area
1672 for (count
= 0, chain
= section
->constructor_chain
;
1673 count
< section
->reloc_count
;
1674 count
++, chain
= chain
->next
)
1675 *relptr
++ = &chain
->relent
;
1681 if (! ecoff_slurp_reloc_table (abfd
, section
, symbols
))
1684 tblptr
= section
->relocation
;
1686 for (count
= 0; count
< section
->reloc_count
; count
++)
1687 *relptr
++ = tblptr
++;
1692 return section
->reloc_count
;
1695 /* Provided a BFD, a section and an offset into the section, calculate
1696 and return the name of the source file and the line nearest to the
1700 _bfd_ecoff_find_nearest_line (bfd
*abfd
,
1702 asymbol
**ignore_symbols ATTRIBUTE_UNUSED
,
1704 const char **filename_ptr
,
1705 const char **functionname_ptr
,
1706 unsigned int *retline_ptr
)
1708 const struct ecoff_debug_swap
* const debug_swap
1709 = &ecoff_backend (abfd
)->debug_swap
;
1710 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1711 struct ecoff_find_line
*line_info
;
1713 /* Make sure we have the FDR's. */
1714 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
, debug_info
)
1715 || bfd_get_symcount (abfd
) == 0)
1718 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1720 bfd_size_type amt
= sizeof (struct ecoff_find_line
);
1722 ecoff_data (abfd
)->find_line_info
= bfd_zalloc (abfd
, amt
);
1723 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1726 line_info
= ecoff_data (abfd
)->find_line_info
;
1728 return _bfd_ecoff_locate_line (abfd
, section
, offset
, debug_info
,
1729 debug_swap
, line_info
, filename_ptr
,
1730 functionname_ptr
, retline_ptr
);
1733 /* Copy private BFD data. This is called by objcopy and strip. We
1734 use it to copy the ECOFF debugging information from one BFD to the
1735 other. It would be theoretically possible to represent the ECOFF
1736 debugging information in the symbol table. However, it would be a
1737 lot of work, and there would be little gain (gas, gdb, and ld
1738 already access the ECOFF debugging information via the
1739 ecoff_debug_info structure, and that structure would have to be
1740 retained in order to support ECOFF debugging in MIPS ELF).
1742 The debugging information for the ECOFF external symbols comes from
1743 the symbol table, so this function only handles the other debugging
1747 _bfd_ecoff_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1749 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
1750 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
1752 asymbol
**sym_ptr_ptr
;
1756 /* We only want to copy information over if both BFD's use ECOFF
1758 if (bfd_get_flavour (ibfd
) != bfd_target_ecoff_flavour
1759 || bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
1762 /* Copy the GP value and the register masks. */
1763 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
1764 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
1765 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
1766 for (i
= 0; i
< 3; i
++)
1767 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
1769 /* Copy the version stamp. */
1770 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
1772 /* If there are no symbols, don't copy any debugging information. */
1773 c
= bfd_get_symcount (obfd
);
1774 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1775 if (c
== 0 || sym_ptr_ptr
== NULL
)
1778 /* See if there are any local symbols. */
1780 for (; c
> 0; c
--, sym_ptr_ptr
++)
1782 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
1791 /* There are some local symbols. We just bring over all the
1792 debugging information. FIXME: This is not quite the right
1793 thing to do. If the user has asked us to discard all
1794 debugging information, then we are probably going to wind up
1795 keeping it because there will probably be some local symbol
1796 which objcopy did not discard. We should actually break
1797 apart the debugging information and only keep that which
1798 applies to the symbols we want to keep. */
1799 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
1800 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
1801 oinfo
->line
= iinfo
->line
;
1803 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
1804 oinfo
->external_dnr
= iinfo
->external_dnr
;
1806 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
1807 oinfo
->external_pdr
= iinfo
->external_pdr
;
1809 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
1810 oinfo
->external_sym
= iinfo
->external_sym
;
1812 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
1813 oinfo
->external_opt
= iinfo
->external_opt
;
1815 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
1816 oinfo
->external_aux
= iinfo
->external_aux
;
1818 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
1819 oinfo
->ss
= iinfo
->ss
;
1821 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
1822 oinfo
->external_fdr
= iinfo
->external_fdr
;
1824 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
1825 oinfo
->external_rfd
= iinfo
->external_rfd
;
1829 /* We are discarding all the local symbol information. Look
1830 through the external symbols and remove all references to FDR
1831 or aux information. */
1832 c
= bfd_get_symcount (obfd
);
1833 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1834 for (; c
> 0; c
--, sym_ptr_ptr
++)
1838 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
1839 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
1841 esym
.asym
.index
= indexNil
;
1842 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
1843 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
1850 /* Set the architecture. The supported architecture is stored in the
1851 backend pointer. We always set the architecture anyhow, since many
1852 callers ignore the return value. */
1855 _bfd_ecoff_set_arch_mach (bfd
*abfd
,
1856 enum bfd_architecture arch
,
1857 unsigned long machine
)
1859 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1860 return arch
== ecoff_backend (abfd
)->arch
;
1863 /* Get the size of the section headers. */
1866 _bfd_ecoff_sizeof_headers (bfd
*abfd
, bfd_boolean reloc ATTRIBUTE_UNUSED
)
1873 for (current
= abfd
->sections
;
1875 current
= current
->next
)
1878 ret
= (bfd_coff_filhsz (abfd
)
1879 + bfd_coff_aoutsz (abfd
)
1880 + c
* bfd_coff_scnhsz (abfd
));
1881 return BFD_ALIGN (ret
, 16);
1884 /* Get the contents of a section. */
1887 _bfd_ecoff_get_section_contents (bfd
*abfd
,
1891 bfd_size_type count
)
1893 return _bfd_generic_get_section_contents (abfd
, section
, location
,
1897 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
1898 called via qsort. */
1901 ecoff_sort_hdrs (const void * arg1
, const void * arg2
)
1903 const asection
*hdr1
= *(const asection
**) arg1
;
1904 const asection
*hdr2
= *(const asection
**) arg2
;
1906 if ((hdr1
->flags
& SEC_ALLOC
) != 0)
1908 if ((hdr2
->flags
& SEC_ALLOC
) == 0)
1913 if ((hdr2
->flags
& SEC_ALLOC
) != 0)
1916 if (hdr1
->vma
< hdr2
->vma
)
1918 else if (hdr1
->vma
> hdr2
->vma
)
1924 /* Calculate the file position for each section, and set
1928 ecoff_compute_section_file_positions (bfd
*abfd
)
1930 file_ptr sofar
, file_sofar
;
1931 asection
**sorted_hdrs
;
1935 bfd_boolean rdata_in_text
;
1936 bfd_boolean first_data
, first_nonalloc
;
1937 const bfd_vma round
= ecoff_backend (abfd
)->round
;
1940 sofar
= _bfd_ecoff_sizeof_headers (abfd
, FALSE
);
1943 /* Sort the sections by VMA. */
1944 amt
= abfd
->section_count
;
1945 amt
*= sizeof (asection
*);
1946 sorted_hdrs
= bfd_malloc (amt
);
1947 if (sorted_hdrs
== NULL
)
1949 for (current
= abfd
->sections
, i
= 0;
1951 current
= current
->next
, i
++)
1952 sorted_hdrs
[i
] = current
;
1953 BFD_ASSERT (i
== abfd
->section_count
);
1955 qsort (sorted_hdrs
, abfd
->section_count
, sizeof (asection
*),
1958 /* Some versions of the OSF linker put the .rdata section in the
1959 text segment, and some do not. */
1960 rdata_in_text
= ecoff_backend (abfd
)->rdata_in_text
;
1963 for (i
= 0; i
< abfd
->section_count
; i
++)
1965 current
= sorted_hdrs
[i
];
1966 if (streq (current
->name
, _RDATA
))
1968 if ((current
->flags
& SEC_CODE
) == 0
1969 && ! streq (current
->name
, _PDATA
)
1970 && ! streq (current
->name
, _RCONST
))
1972 rdata_in_text
= FALSE
;
1977 ecoff_data (abfd
)->rdata_in_text
= rdata_in_text
;
1980 first_nonalloc
= TRUE
;
1981 for (i
= 0; i
< abfd
->section_count
; i
++)
1983 unsigned int alignment_power
;
1985 current
= sorted_hdrs
[i
];
1987 /* For the Alpha ECOFF .pdata section the lnnoptr field is
1988 supposed to indicate the number of .pdata entries that are
1989 really in the section. Each entry is 8 bytes. We store this
1990 away in line_filepos before increasing the section size. */
1991 if (streq (current
->name
, _PDATA
))
1992 current
->line_filepos
= current
->size
/ 8;
1994 alignment_power
= current
->alignment_power
;
1996 /* On Ultrix, the data sections in an executable file must be
1997 aligned to a page boundary within the file. This does not
1998 affect the section size, though. FIXME: Does this work for
1999 other platforms? It requires some modification for the
2000 Alpha, because .rdata on the Alpha goes with the text, not
2002 if ((abfd
->flags
& EXEC_P
) != 0
2003 && (abfd
->flags
& D_PAGED
) != 0
2005 && (current
->flags
& SEC_CODE
) == 0
2007 || ! streq (current
->name
, _RDATA
))
2008 && ! streq (current
->name
, _PDATA
)
2009 && ! streq (current
->name
, _RCONST
))
2011 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2012 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2015 else if (streq (current
->name
, _LIB
))
2017 /* On Irix 4, the location of contents of the .lib section
2018 from a shared library section is also rounded up to a
2021 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2022 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2024 else if (first_nonalloc
2025 && (current
->flags
& SEC_ALLOC
) == 0
2026 && (abfd
->flags
& D_PAGED
) != 0)
2028 /* Skip up to the next page for an unallocated section, such
2029 as the .comment section on the Alpha. This leaves room
2030 for the .bss section. */
2031 first_nonalloc
= FALSE
;
2032 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2033 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2036 /* Align the sections in the file to the same boundary on
2037 which they are aligned in virtual memory. */
2038 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2039 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2040 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2042 if ((abfd
->flags
& D_PAGED
) != 0
2043 && (current
->flags
& SEC_ALLOC
) != 0)
2045 sofar
+= (current
->vma
- sofar
) % round
;
2046 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2047 file_sofar
+= (current
->vma
- file_sofar
) % round
;
2050 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) != 0)
2051 current
->filepos
= file_sofar
;
2053 sofar
+= current
->size
;
2054 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2055 file_sofar
+= current
->size
;
2057 /* Make sure that this section is of the right size too. */
2059 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2060 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2061 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2062 current
->size
+= sofar
- old_sofar
;
2068 ecoff_data (abfd
)->reloc_filepos
= file_sofar
;
2073 /* Determine the location of the relocs for all the sections in the
2074 output file, as well as the location of the symbolic debugging
2077 static bfd_size_type
2078 ecoff_compute_reloc_file_positions (bfd
*abfd
)
2080 const bfd_size_type external_reloc_size
=
2081 ecoff_backend (abfd
)->external_reloc_size
;
2082 file_ptr reloc_base
;
2083 bfd_size_type reloc_size
;
2087 if (! abfd
->output_has_begun
)
2089 if (! ecoff_compute_section_file_positions (abfd
))
2091 abfd
->output_has_begun
= TRUE
;
2094 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2097 for (current
= abfd
->sections
;
2099 current
= current
->next
)
2101 if (current
->reloc_count
== 0)
2102 current
->rel_filepos
= 0;
2105 bfd_size_type relsize
;
2107 current
->rel_filepos
= reloc_base
;
2108 relsize
= current
->reloc_count
* external_reloc_size
;
2109 reloc_size
+= relsize
;
2110 reloc_base
+= relsize
;
2114 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2116 /* At least on Ultrix, the symbol table of an executable file must
2117 be aligned to a page boundary. FIXME: Is this true on other
2119 if ((abfd
->flags
& EXEC_P
) != 0
2120 && (abfd
->flags
& D_PAGED
) != 0)
2121 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2122 &~ (ecoff_backend (abfd
)->round
- 1));
2124 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2129 /* Set the contents of a section. */
2132 _bfd_ecoff_set_section_contents (bfd
*abfd
,
2134 const void * location
,
2136 bfd_size_type count
)
2140 /* This must be done first, because bfd_set_section_contents is
2141 going to set output_has_begun to TRUE. */
2142 if (! abfd
->output_has_begun
2143 && ! ecoff_compute_section_file_positions (abfd
))
2146 /* Handle the .lib section specially so that Irix 4 shared libraries
2147 work out. See coff_set_section_contents in coffcode.h. */
2148 if (streq (section
->name
, _LIB
))
2150 bfd_byte
*rec
, *recend
;
2152 rec
= (bfd_byte
*) location
;
2153 recend
= rec
+ count
;
2154 while (rec
< recend
)
2157 rec
+= bfd_get_32 (abfd
, rec
) * 4;
2160 BFD_ASSERT (rec
== recend
);
2166 pos
= section
->filepos
+ offset
;
2167 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2168 || bfd_bwrite (location
, count
, abfd
) != count
)
2174 /* Get the GP value for an ECOFF file. This is a hook used by
2178 bfd_ecoff_get_gp_value (bfd
*abfd
)
2180 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2181 || bfd_get_format (abfd
) != bfd_object
)
2183 bfd_set_error (bfd_error_invalid_operation
);
2187 return ecoff_data (abfd
)->gp
;
2190 /* Set the GP value for an ECOFF file. This is a hook used by the
2194 bfd_ecoff_set_gp_value (bfd
*abfd
, bfd_vma gp_value
)
2196 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2197 || bfd_get_format (abfd
) != bfd_object
)
2199 bfd_set_error (bfd_error_invalid_operation
);
2203 ecoff_data (abfd
)->gp
= gp_value
;
2208 /* Set the register masks for an ECOFF file. This is a hook used by
2212 bfd_ecoff_set_regmasks (bfd
*abfd
,
2213 unsigned long gprmask
,
2214 unsigned long fprmask
,
2215 unsigned long *cprmask
)
2217 ecoff_data_type
*tdata
;
2219 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2220 || bfd_get_format (abfd
) != bfd_object
)
2222 bfd_set_error (bfd_error_invalid_operation
);
2226 tdata
= ecoff_data (abfd
);
2227 tdata
->gprmask
= gprmask
;
2228 tdata
->fprmask
= fprmask
;
2229 if (cprmask
!= NULL
)
2233 for (i
= 0; i
< 3; i
++)
2234 tdata
->cprmask
[i
] = cprmask
[i
];
2240 /* Get ECOFF EXTR information for an external symbol. This function
2241 is passed to bfd_ecoff_debug_externals. */
2244 ecoff_get_extr (asymbol
*sym
, EXTR
*esym
)
2246 ecoff_symbol_type
*ecoff_sym_ptr
;
2249 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2250 || ecoffsymbol (sym
)->native
== NULL
)
2252 /* Don't include debugging, local, or section symbols. */
2253 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2254 || (sym
->flags
& BSF_LOCAL
) != 0
2255 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2259 esym
->cobol_main
= 0;
2260 esym
->weakext
= (sym
->flags
& BSF_WEAK
) != 0;
2263 /* FIXME: we can do better than this for st and sc. */
2264 esym
->asym
.st
= stGlobal
;
2265 esym
->asym
.sc
= scAbs
;
2266 esym
->asym
.reserved
= 0;
2267 esym
->asym
.index
= indexNil
;
2271 ecoff_sym_ptr
= ecoffsymbol (sym
);
2273 if (ecoff_sym_ptr
->local
)
2276 input_bfd
= bfd_asymbol_bfd (sym
);
2277 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2278 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2280 /* If the symbol was defined by the linker, then esym will be
2281 undefined but sym will not be. Get a better class for such a
2283 if ((esym
->asym
.sc
== scUndefined
2284 || esym
->asym
.sc
== scSUndefined
)
2285 && ! bfd_is_und_section (bfd_get_section (sym
)))
2286 esym
->asym
.sc
= scAbs
;
2288 /* Adjust the FDR index for the symbol by that used for the input
2290 if (esym
->ifd
!= -1)
2292 struct ecoff_debug_info
*input_debug
;
2294 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2295 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2296 if (input_debug
->ifdmap
!= NULL
)
2297 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2303 /* Set the external symbol index. This routine is passed to
2304 bfd_ecoff_debug_externals. */
2307 ecoff_set_index (asymbol
*sym
, bfd_size_type indx
)
2309 ecoff_set_sym_index (sym
, indx
);
2312 /* Write out an ECOFF file. */
2315 _bfd_ecoff_write_object_contents (bfd
*abfd
)
2317 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2318 const bfd_vma round
= backend
->round
;
2319 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2320 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2321 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2322 const bfd_size_type external_hdr_size
2323 = backend
->debug_swap
.external_hdr_size
;
2324 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2325 void (* const adjust_reloc_out
) (bfd
*, const arelent
*, struct internal_reloc
*)
2326 = backend
->adjust_reloc_out
;
2327 void (* const swap_reloc_out
) (bfd
*, const struct internal_reloc
*, void *)
2328 = backend
->swap_reloc_out
;
2329 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2330 HDRR
* const symhdr
= &debug
->symbolic_header
;
2333 bfd_size_type reloc_size
;
2334 bfd_size_type text_size
;
2336 bfd_boolean set_text_start
;
2337 bfd_size_type data_size
;
2339 bfd_boolean set_data_start
;
2340 bfd_size_type bss_size
;
2342 void * reloc_buff
= NULL
;
2343 struct internal_filehdr internal_f
;
2344 struct internal_aouthdr internal_a
;
2347 /* Determine where the sections and relocs will go in the output
2349 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2352 for (current
= abfd
->sections
;
2354 current
= current
->next
)
2356 current
->target_index
= count
;
2360 if ((abfd
->flags
& D_PAGED
) != 0)
2361 text_size
= _bfd_ecoff_sizeof_headers (abfd
, FALSE
);
2365 set_text_start
= FALSE
;
2368 set_data_start
= FALSE
;
2371 /* Write section headers to the file. */
2373 /* Allocate buff big enough to hold a section header,
2374 file header, or a.out header. */
2383 buff
= bfd_malloc (siz
);
2388 internal_f
.f_nscns
= 0;
2389 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2392 for (current
= abfd
->sections
;
2394 current
= current
->next
)
2396 struct internal_scnhdr section
;
2399 ++internal_f
.f_nscns
;
2401 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2403 /* This seems to be correct for Irix 4 shared libraries. */
2404 vma
= bfd_get_section_vma (abfd
, current
);
2405 if (streq (current
->name
, _LIB
))
2406 section
.s_vaddr
= 0;
2408 section
.s_vaddr
= vma
;
2410 section
.s_paddr
= current
->lma
;
2411 section
.s_size
= current
->size
;
2413 /* If this section is unloadable then the scnptr will be 0. */
2414 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2415 section
.s_scnptr
= 0;
2417 section
.s_scnptr
= current
->filepos
;
2418 section
.s_relptr
= current
->rel_filepos
;
2420 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2421 object file produced by the assembler is supposed to point to
2422 information about how much room is required by objects of
2423 various different sizes. I think this only matters if we
2424 want the linker to compute the best size to use, or
2425 something. I don't know what happens if the information is
2427 if (! streq (current
->name
, _PDATA
))
2428 section
.s_lnnoptr
= 0;
2431 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2432 hold the number of entries in the section (each entry is
2433 8 bytes). We stored this in the line_filepos field in
2434 ecoff_compute_section_file_positions. */
2435 section
.s_lnnoptr
= current
->line_filepos
;
2438 section
.s_nreloc
= current
->reloc_count
;
2439 section
.s_nlnno
= 0;
2440 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2443 if (bfd_coff_swap_scnhdr_out (abfd
, (void *) §ion
, buff
) == 0
2444 || bfd_bwrite (buff
, scnhsz
, abfd
) != scnhsz
)
2447 if ((section
.s_flags
& STYP_TEXT
) != 0
2448 || ((section
.s_flags
& STYP_RDATA
) != 0
2449 && ecoff_data (abfd
)->rdata_in_text
)
2450 || section
.s_flags
== STYP_PDATA
2451 || (section
.s_flags
& STYP_DYNAMIC
) != 0
2452 || (section
.s_flags
& STYP_LIBLIST
) != 0
2453 || (section
.s_flags
& STYP_RELDYN
) != 0
2454 || section
.s_flags
== STYP_CONFLIC
2455 || (section
.s_flags
& STYP_DYNSTR
) != 0
2456 || (section
.s_flags
& STYP_DYNSYM
) != 0
2457 || (section
.s_flags
& STYP_HASH
) != 0
2458 || (section
.s_flags
& STYP_ECOFF_INIT
) != 0
2459 || (section
.s_flags
& STYP_ECOFF_FINI
) != 0
2460 || section
.s_flags
== STYP_RCONST
)
2462 text_size
+= current
->size
;
2463 if (! set_text_start
|| text_start
> vma
)
2466 set_text_start
= TRUE
;
2469 else if ((section
.s_flags
& STYP_RDATA
) != 0
2470 || (section
.s_flags
& STYP_DATA
) != 0
2471 || (section
.s_flags
& STYP_LITA
) != 0
2472 || (section
.s_flags
& STYP_LIT8
) != 0
2473 || (section
.s_flags
& STYP_LIT4
) != 0
2474 || (section
.s_flags
& STYP_SDATA
) != 0
2475 || section
.s_flags
== STYP_XDATA
2476 || (section
.s_flags
& STYP_GOT
) != 0)
2478 data_size
+= current
->size
;
2479 if (! set_data_start
|| data_start
> vma
)
2482 set_data_start
= TRUE
;
2485 else if ((section
.s_flags
& STYP_BSS
) != 0
2486 || (section
.s_flags
& STYP_SBSS
) != 0)
2487 bss_size
+= current
->size
;
2488 else if (section
.s_flags
== 0
2489 || (section
.s_flags
& STYP_ECOFF_LIB
) != 0
2490 || section
.s_flags
== STYP_COMMENT
)
2496 /* Set up the file header. */
2497 internal_f
.f_magic
= ecoff_get_magic (abfd
);
2499 /* We will NOT put a fucking timestamp in the header here. Every
2500 time you put it back, I will come in and take it out again. I'm
2501 sorry. This field does not belong here. We fill it with a 0 so
2502 it compares the same but is not a reasonable time. --
2504 internal_f
.f_timdat
= 0;
2506 if (bfd_get_symcount (abfd
) != 0)
2508 /* The ECOFF f_nsyms field is not actually the number of
2509 symbols, it's the size of symbolic information header. */
2510 internal_f
.f_nsyms
= external_hdr_size
;
2511 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
2515 internal_f
.f_nsyms
= 0;
2516 internal_f
.f_symptr
= 0;
2519 internal_f
.f_opthdr
= aoutsz
;
2521 internal_f
.f_flags
= F_LNNO
;
2522 if (reloc_size
== 0)
2523 internal_f
.f_flags
|= F_RELFLG
;
2524 if (bfd_get_symcount (abfd
) == 0)
2525 internal_f
.f_flags
|= F_LSYMS
;
2526 if (abfd
->flags
& EXEC_P
)
2527 internal_f
.f_flags
|= F_EXEC
;
2529 if (bfd_little_endian (abfd
))
2530 internal_f
.f_flags
|= F_AR32WR
;
2532 internal_f
.f_flags
|= F_AR32W
;
2534 /* Set up the ``optional'' header. */
2535 if ((abfd
->flags
& D_PAGED
) != 0)
2536 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
2538 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
2540 /* FIXME: Is this really correct? */
2541 internal_a
.vstamp
= symhdr
->vstamp
;
2543 /* At least on Ultrix, these have to be rounded to page boundaries.
2544 FIXME: Is this true on other platforms? */
2545 if ((abfd
->flags
& D_PAGED
) != 0)
2547 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
2548 internal_a
.text_start
= text_start
&~ (round
- 1);
2549 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
2550 internal_a
.data_start
= data_start
&~ (round
- 1);
2554 internal_a
.tsize
= text_size
;
2555 internal_a
.text_start
= text_start
;
2556 internal_a
.dsize
= data_size
;
2557 internal_a
.data_start
= data_start
;
2560 /* On Ultrix, the initial portions of the .sbss and .bss segments
2561 are at the end of the data section. The bsize field in the
2562 optional header records how many bss bytes are required beyond
2563 those in the data section. The value is not rounded to a page
2565 if (bss_size
< internal_a
.dsize
- data_size
)
2568 bss_size
-= internal_a
.dsize
- data_size
;
2569 internal_a
.bsize
= bss_size
;
2570 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
2572 internal_a
.entry
= bfd_get_start_address (abfd
);
2574 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
2576 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
2577 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
2578 for (i
= 0; i
< 4; i
++)
2579 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
2581 /* Let the backend adjust the headers if necessary. */
2582 if (backend
->adjust_headers
)
2584 if (! (*backend
->adjust_headers
) (abfd
, &internal_f
, &internal_a
))
2588 /* Write out the file header and the optional header. */
2589 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2592 bfd_coff_swap_filehdr_out (abfd
, (void *) &internal_f
, buff
);
2593 if (bfd_bwrite (buff
, filhsz
, abfd
) != filhsz
)
2596 bfd_coff_swap_aouthdr_out (abfd
, (void *) &internal_a
, buff
);
2597 if (bfd_bwrite (buff
, aoutsz
, abfd
) != aoutsz
)
2600 /* Build the external symbol information. This must be done before
2601 writing out the relocs so that we know the symbol indices. We
2602 don't do this if this BFD was created by the backend linker,
2603 since it will have already handled the symbols and relocs. */
2604 if (! ecoff_data (abfd
)->linker
)
2606 symhdr
->iextMax
= 0;
2607 symhdr
->issExtMax
= 0;
2608 debug
->external_ext
= debug
->external_ext_end
= NULL
;
2609 debug
->ssext
= debug
->ssext_end
= NULL
;
2610 if (! bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
2611 (abfd
->flags
& EXEC_P
) == 0,
2612 ecoff_get_extr
, ecoff_set_index
))
2615 /* Write out the relocs. */
2616 for (current
= abfd
->sections
;
2618 current
= current
->next
)
2620 arelent
**reloc_ptr_ptr
;
2621 arelent
**reloc_end
;
2625 if (current
->reloc_count
== 0)
2628 amt
= current
->reloc_count
* external_reloc_size
;
2629 reloc_buff
= bfd_alloc (abfd
, amt
);
2630 if (reloc_buff
== NULL
)
2633 reloc_ptr_ptr
= current
->orelocation
;
2634 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
2635 out_ptr
= (char *) reloc_buff
;
2638 reloc_ptr_ptr
< reloc_end
;
2639 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
2643 struct internal_reloc in
;
2645 memset ((void *) &in
, 0, sizeof in
);
2647 reloc
= *reloc_ptr_ptr
;
2648 sym
= *reloc
->sym_ptr_ptr
;
2650 /* If the howto field has not been initialised then skip this reloc.
2651 This assumes that an error message has been issued elsewhere. */
2652 if (reloc
->howto
== NULL
)
2655 in
.r_vaddr
= (reloc
->address
2656 + bfd_get_section_vma (abfd
, current
));
2657 in
.r_type
= reloc
->howto
->type
;
2659 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2661 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2675 { _TEXT
, RELOC_SECTION_TEXT
},
2676 { _RDATA
, RELOC_SECTION_RDATA
},
2677 { _DATA
, RELOC_SECTION_DATA
},
2678 { _SDATA
, RELOC_SECTION_SDATA
},
2679 { _SBSS
, RELOC_SECTION_SBSS
},
2680 { _BSS
, RELOC_SECTION_BSS
},
2681 { _INIT
, RELOC_SECTION_INIT
},
2682 { _LIT8
, RELOC_SECTION_LIT8
},
2683 { _LIT4
, RELOC_SECTION_LIT4
},
2684 { _XDATA
, RELOC_SECTION_XDATA
},
2685 { _PDATA
, RELOC_SECTION_PDATA
},
2686 { _FINI
, RELOC_SECTION_FINI
},
2687 { _LITA
, RELOC_SECTION_LITA
},
2688 { "*ABS*", RELOC_SECTION_ABS
},
2689 { _RCONST
, RELOC_SECTION_RCONST
}
2692 name
= bfd_get_section_name (abfd
, bfd_get_section (sym
));
2694 for (i
= 0; i
< ARRAY_SIZE (section_symndx
); i
++)
2695 if (streq (name
, section_symndx
[i
].name
))
2697 in
.r_symndx
= section_symndx
[i
].r_symndx
;
2701 if (i
== ARRAY_SIZE (section_symndx
))
2706 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2708 (*swap_reloc_out
) (abfd
, &in
, (void *) out_ptr
);
2711 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2713 amt
= current
->reloc_count
* external_reloc_size
;
2714 if (bfd_bwrite (reloc_buff
, amt
, abfd
) != amt
)
2716 bfd_release (abfd
, reloc_buff
);
2720 /* Write out the symbolic debugging information. */
2721 if (bfd_get_symcount (abfd
) > 0)
2723 /* Write out the debugging information. */
2724 if (! bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2725 ecoff_data (abfd
)->sym_filepos
))
2730 /* The .bss section of a demand paged executable must receive an
2731 entire page. If there are symbols, the symbols will start on the
2732 next page. If there are no symbols, we must fill out the page by
2734 if (bfd_get_symcount (abfd
) == 0
2735 && (abfd
->flags
& EXEC_P
) != 0
2736 && (abfd
->flags
& D_PAGED
) != 0)
2740 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2743 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) == 0)
2745 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2748 if (bfd_bwrite (&c
, (bfd_size_type
) 1, abfd
) != 1)
2752 if (reloc_buff
!= NULL
)
2753 bfd_release (abfd
, reloc_buff
);
2758 if (reloc_buff
!= NULL
)
2759 bfd_release (abfd
, reloc_buff
);
2765 /* Archive handling. ECOFF uses what appears to be a unique type of
2766 archive header (armap). The byte ordering of the armap and the
2767 contents are encoded in the name of the armap itself. At least for
2768 now, we only support archives with the same byte ordering in the
2769 armap and the contents.
2771 The first four bytes in the armap are the number of symbol
2772 definitions. This is always a power of two.
2774 This is followed by the symbol definitions. Each symbol definition
2775 occupies 8 bytes. The first four bytes are the offset from the
2776 start of the armap strings to the null-terminated string naming
2777 this symbol. The second four bytes are the file offset to the
2778 archive member which defines this symbol. If the second four bytes
2779 are 0, then this is not actually a symbol definition, and it should
2782 The symbols are hashed into the armap with a closed hashing scheme.
2783 See the functions below for the details of the algorithm.
2785 After the symbol definitions comes four bytes holding the size of
2786 the string table, followed by the string table itself. */
2788 /* The name of an archive headers looks like this:
2789 __________E[BL]E[BL]_ (with a trailing space).
2790 The trailing space is changed to an X if the archive is changed to
2791 indicate that the armap is out of date.
2793 The Alpha seems to use ________64E[BL]E[BL]_. */
2795 #define ARMAP_BIG_ENDIAN 'B'
2796 #define ARMAP_LITTLE_ENDIAN 'L'
2797 #define ARMAP_MARKER 'E'
2798 #define ARMAP_START_LENGTH 10
2799 #define ARMAP_HEADER_MARKER_INDEX 10
2800 #define ARMAP_HEADER_ENDIAN_INDEX 11
2801 #define ARMAP_OBJECT_MARKER_INDEX 12
2802 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2803 #define ARMAP_END_INDEX 14
2804 #define ARMAP_END "_ "
2806 /* This is a magic number used in the hashing algorithm. */
2807 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2809 /* This returns the hash value to use for a string. It also sets
2810 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2811 is the number of entries in the hash table, and HLOG is the log
2815 ecoff_armap_hash (const char *s
,
2816 unsigned int *rehash
,
2826 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2827 hash
*= ARMAP_HASH_MAGIC
;
2828 *rehash
= (hash
& (size
- 1)) | 1;
2829 return hash
>> (32 - hlog
);
2832 /* Read in the armap. */
2835 _bfd_ecoff_slurp_armap (bfd
*abfd
)
2839 struct areltdata
*mapdata
;
2840 bfd_size_type parsed_size
;
2842 struct artdata
*ardata
;
2845 struct symdef
*symdef_ptr
;
2849 /* Get the name of the first element. */
2850 i
= bfd_bread ((void *) nextname
, (bfd_size_type
) 16, abfd
);
2856 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2859 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2860 standard COFF armap. We could move the ECOFF armap stuff into
2861 bfd_slurp_armap, but that seems inappropriate since no other
2862 target uses this format. Instead, we check directly for a COFF
2864 if (strneq (nextname
, "/ ", 16))
2865 return bfd_slurp_armap (abfd
);
2867 /* See if the first element is an armap. */
2868 if (! strneq (nextname
, ecoff_backend (abfd
)->armap_start
, ARMAP_START_LENGTH
)
2869 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
2870 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2871 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2872 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
2873 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2874 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2875 || ! strneq (nextname
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1))
2877 bfd_has_map (abfd
) = FALSE
;
2881 /* Make sure we have the right byte ordering. */
2882 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2883 ^ (bfd_header_big_endian (abfd
)))
2884 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2885 ^ (bfd_big_endian (abfd
))))
2887 bfd_set_error (bfd_error_wrong_format
);
2891 /* Read in the armap. */
2892 ardata
= bfd_ardata (abfd
);
2893 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
2894 if (mapdata
== NULL
)
2896 parsed_size
= mapdata
->parsed_size
;
2897 bfd_release (abfd
, (void *) mapdata
);
2899 raw_armap
= bfd_alloc (abfd
, parsed_size
);
2900 if (raw_armap
== NULL
)
2903 if (bfd_bread ((void *) raw_armap
, parsed_size
, abfd
) != parsed_size
)
2905 if (bfd_get_error () != bfd_error_system_call
)
2906 bfd_set_error (bfd_error_malformed_archive
);
2907 bfd_release (abfd
, (void *) raw_armap
);
2911 ardata
->tdata
= (void *) raw_armap
;
2913 count
= H_GET_32 (abfd
, raw_armap
);
2915 ardata
->symdef_count
= 0;
2916 ardata
->cache
= NULL
;
2918 /* This code used to overlay the symdefs over the raw archive data,
2919 but that doesn't work on a 64 bit host. */
2920 stringbase
= raw_armap
+ count
* 8 + 8;
2922 #ifdef CHECK_ARMAP_HASH
2926 /* Double check that I have the hashing algorithm right by making
2927 sure that every symbol can be looked up successfully. */
2929 for (i
= 1; i
< count
; i
<<= 1)
2931 BFD_ASSERT (i
== count
);
2933 raw_ptr
= raw_armap
+ 4;
2934 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2936 unsigned int name_offset
, file_offset
;
2937 unsigned int hash
, rehash
, srch
;
2939 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2940 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2941 if (file_offset
== 0)
2943 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
2948 /* See if we can rehash to this location. */
2949 for (srch
= (hash
+ rehash
) & (count
- 1);
2950 srch
!= hash
&& srch
!= i
;
2951 srch
= (srch
+ rehash
) & (count
- 1))
2952 BFD_ASSERT (H_GET_32 (abfd
, (raw_armap
+ 8 + srch
* 8)) != 0);
2953 BFD_ASSERT (srch
== i
);
2957 #endif /* CHECK_ARMAP_HASH */
2959 raw_ptr
= raw_armap
+ 4;
2960 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2961 if (H_GET_32 (abfd
, (raw_ptr
+ 4)) != 0)
2962 ++ardata
->symdef_count
;
2964 amt
= ardata
->symdef_count
;
2965 amt
*= sizeof (struct symdef
);
2966 symdef_ptr
= bfd_alloc (abfd
, amt
);
2970 ardata
->symdefs
= (carsym
*) symdef_ptr
;
2972 raw_ptr
= raw_armap
+ 4;
2973 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2975 unsigned int name_offset
, file_offset
;
2977 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2978 if (file_offset
== 0)
2980 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2981 symdef_ptr
->s
.name
= stringbase
+ name_offset
;
2982 symdef_ptr
->file_offset
= file_offset
;
2986 ardata
->first_file_filepos
= bfd_tell (abfd
);
2987 /* Pad to an even boundary. */
2988 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
2990 bfd_has_map (abfd
) = TRUE
;
2995 /* Write out an armap. */
2998 _bfd_ecoff_write_armap (bfd
*abfd
,
2999 unsigned int elength
,
3001 unsigned int orl_count
,
3004 unsigned int hashsize
, hashlog
;
3005 bfd_size_type symdefsize
;
3007 unsigned int stringsize
;
3008 unsigned int mapsize
;
3011 struct stat statbuf
;
3014 bfd_byte
*hashtable
;
3018 /* Ultrix appears to use as a hash table size the least power of two
3019 greater than twice the number of entries. */
3020 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3022 hashsize
= 1 << hashlog
;
3024 symdefsize
= hashsize
* 8;
3026 stringsize
= stridx
+ padit
;
3028 /* Include 8 bytes to store symdefsize and stringsize in output. */
3029 mapsize
= symdefsize
+ stringsize
+ 8;
3031 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3033 memset ((void *) &hdr
, 0, sizeof hdr
);
3035 /* Work out the ECOFF armap name. */
3036 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3037 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3038 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3039 (bfd_header_big_endian (abfd
)
3041 : ARMAP_LITTLE_ENDIAN
);
3042 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3043 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3044 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3045 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3047 /* Write the timestamp of the archive header to be just a little bit
3048 later than the timestamp of the file, otherwise the linker will
3049 complain that the index is out of date. Actually, the Ultrix
3050 linker just checks the archive name; the GNU linker may check the
3052 stat (abfd
->filename
, &statbuf
);
3053 sprintf (hdr
.ar_date
, "%ld", (long) (statbuf
.st_mtime
+ 60));
3055 /* The DECstation uses zeroes for the uid, gid and mode of the
3057 hdr
.ar_uid
[0] = '0';
3058 hdr
.ar_gid
[0] = '0';
3059 /* Building gcc ends up extracting the armap as a file - twice. */
3060 hdr
.ar_mode
[0] = '6';
3061 hdr
.ar_mode
[1] = '4';
3062 hdr
.ar_mode
[2] = '4';
3064 sprintf (hdr
.ar_size
, "%-10d", (int) mapsize
);
3066 hdr
.ar_fmag
[0] = '`';
3067 hdr
.ar_fmag
[1] = '\012';
3069 /* Turn all null bytes in the header into spaces. */
3070 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3071 if (((char *) (&hdr
))[i
] == '\0')
3072 (((char *) (&hdr
))[i
]) = ' ';
3074 if (bfd_bwrite ((void *) &hdr
, (bfd_size_type
) sizeof (struct ar_hdr
), abfd
)
3075 != sizeof (struct ar_hdr
))
3078 H_PUT_32 (abfd
, hashsize
, temp
);
3079 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3082 hashtable
= bfd_zalloc (abfd
, symdefsize
);
3086 current
= abfd
->archive_head
;
3088 for (i
= 0; i
< orl_count
; i
++)
3090 unsigned int hash
, rehash
;
3092 /* Advance firstreal to the file position of this archive
3094 if (map
[i
].u
.abfd
!= last_elt
)
3098 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3099 firstreal
+= firstreal
% 2;
3100 current
= current
->next
;
3102 while (current
!= map
[i
].u
.abfd
);
3107 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3108 if (H_GET_32 (abfd
, (hashtable
+ (hash
* 8) + 4)) != 0)
3112 /* The desired slot is already taken. */
3113 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3115 srch
= (srch
+ rehash
) & (hashsize
- 1))
3116 if (H_GET_32 (abfd
, (hashtable
+ (srch
* 8) + 4)) == 0)
3119 BFD_ASSERT (srch
!= hash
);
3124 H_PUT_32 (abfd
, map
[i
].namidx
, (hashtable
+ hash
* 8));
3125 H_PUT_32 (abfd
, firstreal
, (hashtable
+ hash
* 8 + 4));
3128 if (bfd_bwrite ((void *) hashtable
, symdefsize
, abfd
) != symdefsize
)
3131 bfd_release (abfd
, hashtable
);
3133 /* Now write the strings. */
3134 H_PUT_32 (abfd
, stringsize
, temp
);
3135 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3137 for (i
= 0; i
< orl_count
; i
++)
3141 len
= strlen (*map
[i
].name
) + 1;
3142 if (bfd_bwrite ((void *) (*map
[i
].name
), len
, abfd
) != len
)
3146 /* The spec sez this should be a newline. But in order to be
3147 bug-compatible for DECstation ar we use a null. */
3150 if (bfd_bwrite ("", (bfd_size_type
) 1, abfd
) != 1)
3157 /* See whether this BFD is an archive. If it is, read in the armap
3158 and the extended name table. */
3161 _bfd_ecoff_archive_p (bfd
*abfd
)
3163 struct artdata
*tdata_hold
;
3164 char armag
[SARMAG
+ 1];
3167 if (bfd_bread ((void *) armag
, (bfd_size_type
) SARMAG
, abfd
) != SARMAG
)
3169 if (bfd_get_error () != bfd_error_system_call
)
3170 bfd_set_error (bfd_error_wrong_format
);
3174 if (! strneq (armag
, ARMAG
, SARMAG
))
3176 bfd_set_error (bfd_error_wrong_format
);
3180 tdata_hold
= bfd_ardata (abfd
);
3182 amt
= sizeof (struct artdata
);
3183 bfd_ardata (abfd
) = bfd_zalloc (abfd
, amt
);
3184 if (bfd_ardata (abfd
) == NULL
)
3186 bfd_ardata (abfd
) = tdata_hold
;
3190 bfd_ardata (abfd
)->first_file_filepos
= SARMAG
;
3191 /* Already cleared by bfd_zalloc above.
3192 bfd_ardata (abfd)->cache = NULL;
3193 bfd_ardata (abfd)->archive_head = NULL;
3194 bfd_ardata (abfd)->symdefs = NULL;
3195 bfd_ardata (abfd)->extended_names = NULL;
3196 bfd_ardata (abfd)->extended_names_size = 0;
3197 bfd_ardata (abfd)->tdata = NULL; */
3199 if (! _bfd_ecoff_slurp_armap (abfd
)
3200 || ! _bfd_ecoff_slurp_extended_name_table (abfd
))
3202 bfd_release (abfd
, bfd_ardata (abfd
));
3203 bfd_ardata (abfd
) = tdata_hold
;
3207 if (bfd_has_map (abfd
))
3211 /* This archive has a map, so we may presume that the contents
3212 are object files. Make sure that if the first file in the
3213 archive can be recognized as an object file, it is for this
3214 target. If not, assume that this is the wrong format. If
3215 the first file is not an object file, somebody is doing
3216 something weird, and we permit it so that ar -t will work. */
3218 first
= bfd_openr_next_archived_file (abfd
, NULL
);
3221 first
->target_defaulted
= FALSE
;
3222 if (bfd_check_format (first
, bfd_object
)
3223 && first
->xvec
!= abfd
->xvec
)
3225 /* We ought to close `first' here, but we can't, because
3226 we have no way to remove it from the archive cache.
3227 It's almost impossible to figure out when we can
3228 release bfd_ardata. FIXME. */
3229 bfd_set_error (bfd_error_wrong_object_format
);
3230 bfd_ardata (abfd
) = tdata_hold
;
3233 /* And we ought to close `first' here too. */
3240 /* ECOFF linker code. */
3242 /* Routine to create an entry in an ECOFF link hash table. */
3244 static struct bfd_hash_entry
*
3245 ecoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
3246 struct bfd_hash_table
*table
,
3249 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3251 /* Allocate the structure if it has not already been allocated by a
3254 ret
= ((struct ecoff_link_hash_entry
*)
3255 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3259 /* Call the allocation method of the superclass. */
3260 ret
= ((struct ecoff_link_hash_entry
*)
3261 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3266 /* Set local fields. */
3272 memset ((void *) &ret
->esym
, 0, sizeof ret
->esym
);
3274 return (struct bfd_hash_entry
*) ret
;
3277 /* Create an ECOFF link hash table. */
3279 struct bfd_link_hash_table
*
3280 _bfd_ecoff_bfd_link_hash_table_create (bfd
*abfd
)
3282 struct ecoff_link_hash_table
*ret
;
3283 bfd_size_type amt
= sizeof (struct ecoff_link_hash_table
);
3285 ret
= bfd_malloc (amt
);
3288 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
,
3289 ecoff_link_hash_newfunc
,
3290 sizeof (struct ecoff_link_hash_entry
)))
3298 /* Look up an entry in an ECOFF link hash table. */
3300 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3301 ((struct ecoff_link_hash_entry *) \
3302 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3304 /* Traverse an ECOFF link hash table. */
3306 #define ecoff_link_hash_traverse(table, func, info) \
3307 (bfd_link_hash_traverse \
3309 (bfd_boolean (*) (struct bfd_link_hash_entry *, void *)) (func), \
3312 /* Get the ECOFF link hash table from the info structure. This is
3315 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3317 /* Add the external symbols of an object file to the global linker
3318 hash table. The external symbols and strings we are passed are
3319 just allocated on the stack, and will be discarded. We must
3320 explicitly save any information we may need later on in the link.
3321 We do not want to read the external symbol information again. */
3324 ecoff_link_add_externals (bfd
*abfd
,
3325 struct bfd_link_info
*info
,
3326 void * external_ext
,
3329 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3330 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3331 = backend
->debug_swap
.swap_ext_in
;
3332 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3333 unsigned long ext_count
;
3334 struct bfd_link_hash_entry
**sym_hash
;
3339 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3342 amt
*= sizeof (struct bfd_link_hash_entry
*);
3343 sym_hash
= bfd_alloc (abfd
, amt
);
3346 ecoff_data (abfd
)->sym_hashes
= (struct ecoff_link_hash_entry
**) sym_hash
;
3348 ext_ptr
= (char *) external_ext
;
3349 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3350 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3357 struct ecoff_link_hash_entry
*h
;
3361 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3363 /* Skip debugging symbols. */
3365 switch (esym
.asym
.st
)
3381 /* Get the information for this symbol. */
3382 value
= esym
.asym
.value
;
3383 switch (esym
.asym
.sc
)
3403 section
= bfd_make_section_old_way (abfd
, _TEXT
);
3404 value
-= section
->vma
;
3407 section
= bfd_make_section_old_way (abfd
, _DATA
);
3408 value
-= section
->vma
;
3411 section
= bfd_make_section_old_way (abfd
, _BSS
);
3412 value
-= section
->vma
;
3415 section
= bfd_abs_section_ptr
;
3418 section
= bfd_und_section_ptr
;
3421 section
= bfd_make_section_old_way (abfd
, _SDATA
);
3422 value
-= section
->vma
;
3425 section
= bfd_make_section_old_way (abfd
, _SBSS
);
3426 value
-= section
->vma
;
3429 section
= bfd_make_section_old_way (abfd
, _RDATA
);
3430 value
-= section
->vma
;
3433 if (value
> ecoff_data (abfd
)->gp_size
)
3435 section
= bfd_com_section_ptr
;
3440 if (ecoff_scom_section
.name
== NULL
)
3442 /* Initialize the small common section. */
3443 ecoff_scom_section
.name
= SCOMMON
;
3444 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
3445 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
3446 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
3447 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
3448 ecoff_scom_symbol
.name
= SCOMMON
;
3449 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
3450 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
3451 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
3453 section
= &ecoff_scom_section
;
3456 section
= bfd_und_section_ptr
;
3459 section
= bfd_make_section_old_way (abfd
, _INIT
);
3460 value
-= section
->vma
;
3463 section
= bfd_make_section_old_way (abfd
, _FINI
);
3464 value
-= section
->vma
;
3467 section
= bfd_make_section_old_way (abfd
, _RCONST
);
3468 value
-= section
->vma
;
3472 if (section
== NULL
)
3475 name
= ssext
+ esym
.asym
.iss
;
3477 if (! (_bfd_generic_link_add_one_symbol
3479 (flagword
) (esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
),
3480 section
, value
, NULL
, TRUE
, TRUE
, sym_hash
)))
3483 h
= (struct ecoff_link_hash_entry
*) *sym_hash
;
3485 /* If we are building an ECOFF hash table, save the external
3486 symbol information. */
3487 if (info
->hash
->creator
->flavour
== bfd_get_flavour (abfd
))
3490 || (! bfd_is_und_section (section
)
3491 && (! bfd_is_com_section (section
)
3492 || (h
->root
.type
!= bfd_link_hash_defined
3493 && h
->root
.type
!= bfd_link_hash_defweak
))))
3499 /* Remember whether this symbol was small undefined. */
3500 if (esym
.asym
.sc
== scSUndefined
)
3503 /* If this symbol was ever small undefined, it needs to wind
3504 up in a GP relative section. We can't control the
3505 section of a defined symbol, but we can control the
3506 section of a common symbol. This case is actually needed
3507 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3509 && h
->root
.type
== bfd_link_hash_common
3510 && streq (h
->root
.u
.c
.p
->section
->name
, SCOMMON
))
3512 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
3514 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
3515 if (h
->esym
.asym
.sc
== scCommon
)
3516 h
->esym
.asym
.sc
= scSCommon
;
3524 /* Add symbols from an ECOFF object file to the global linker hash
3528 ecoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3531 bfd_size_type external_ext_size
;
3532 void * external_ext
= NULL
;
3533 bfd_size_type esize
;
3537 if (! ecoff_slurp_symbolic_header (abfd
))
3540 /* If there are no symbols, we don't want it. */
3541 if (bfd_get_symcount (abfd
) == 0)
3544 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3546 /* Read in the external symbols and external strings. */
3547 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3548 esize
= symhdr
->iextMax
* external_ext_size
;
3549 external_ext
= bfd_malloc (esize
);
3550 if (external_ext
== NULL
&& esize
!= 0)
3553 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbExtOffset
, SEEK_SET
) != 0
3554 || bfd_bread (external_ext
, esize
, abfd
) != esize
)
3557 ssext
= bfd_malloc ((bfd_size_type
) symhdr
->issExtMax
);
3558 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3561 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
3562 || (bfd_bread (ssext
, (bfd_size_type
) symhdr
->issExtMax
, abfd
)
3563 != (bfd_size_type
) symhdr
->issExtMax
))
3566 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3570 if (external_ext
!= NULL
)
3571 free (external_ext
);
3577 if (external_ext
!= NULL
)
3578 free (external_ext
);
3582 /* This is called if we used _bfd_generic_link_add_archive_symbols
3583 because we were not dealing with an ECOFF archive. */
3586 ecoff_link_check_archive_element (bfd
*abfd
,
3587 struct bfd_link_info
*info
,
3588 bfd_boolean
*pneeded
)
3590 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3591 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3592 = backend
->debug_swap
.swap_ext_in
;
3594 bfd_size_type external_ext_size
;
3595 void * external_ext
= NULL
;
3596 bfd_size_type esize
;
3603 if (! ecoff_slurp_symbolic_header (abfd
))
3606 /* If there are no symbols, we don't want it. */
3607 if (bfd_get_symcount (abfd
) == 0)
3608 goto successful_return
;
3610 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3612 /* Read in the external symbols and external strings. */
3613 external_ext_size
= backend
->debug_swap
.external_ext_size
;
3614 esize
= symhdr
->iextMax
* external_ext_size
;
3615 external_ext
= bfd_malloc (esize
);
3616 if (external_ext
== NULL
&& esize
!= 0)
3619 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbExtOffset
, SEEK_SET
) != 0
3620 || bfd_bread (external_ext
, esize
, abfd
) != esize
)
3623 ssext
= bfd_malloc ((bfd_size_type
) symhdr
->issExtMax
);
3624 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3627 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
3628 || (bfd_bread (ssext
, (bfd_size_type
) symhdr
->issExtMax
, abfd
)
3629 != (bfd_size_type
) symhdr
->issExtMax
))
3632 /* Look through the external symbols to see if they define some
3633 symbol that is currently undefined. */
3634 ext_ptr
= (char *) external_ext
;
3635 ext_end
= ext_ptr
+ esize
;
3636 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
)
3641 struct bfd_link_hash_entry
*h
;
3643 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3645 /* See if this symbol defines something. */
3646 if (esym
.asym
.st
!= stGlobal
3647 && esym
.asym
.st
!= stLabel
3648 && esym
.asym
.st
!= stProc
)
3651 switch (esym
.asym
.sc
)
3675 name
= ssext
+ esym
.asym
.iss
;
3676 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
3678 /* Unlike the generic linker, we do not pull in elements because
3679 of common symbols. */
3681 || h
->type
!= bfd_link_hash_undefined
)
3684 /* Include this element. */
3685 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
3687 if (! ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
))
3691 goto successful_return
;
3695 if (external_ext
!= NULL
)
3696 free (external_ext
);
3701 if (external_ext
!= NULL
)
3702 free (external_ext
);
3708 /* Add the symbols from an archive file to the global hash table.
3709 This looks through the undefined symbols, looks each one up in the
3710 archive hash table, and adds any associated object file. We do not
3711 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3712 already have a hash table, so there is no reason to construct
3716 ecoff_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3718 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3719 const bfd_byte
*raw_armap
;
3720 struct bfd_link_hash_entry
**pundef
;
3721 unsigned int armap_count
;
3722 unsigned int armap_log
;
3724 const bfd_byte
*hashtable
;
3725 const char *stringbase
;
3727 if (! bfd_has_map (abfd
))
3729 /* An empty archive is a special case. */
3730 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
3732 bfd_set_error (bfd_error_no_armap
);
3736 /* If we don't have any raw data for this archive, as can happen on
3737 Irix 4.0.5F, we call the generic routine.
3738 FIXME: We should be more clever about this, since someday tdata
3739 may get to something for a generic archive. */
3740 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3741 if (raw_armap
== NULL
)
3742 return (_bfd_generic_link_add_archive_symbols
3743 (abfd
, info
, ecoff_link_check_archive_element
));
3745 armap_count
= H_GET_32 (abfd
, raw_armap
);
3748 for (i
= 1; i
< armap_count
; i
<<= 1)
3750 BFD_ASSERT (i
== armap_count
);
3752 hashtable
= raw_armap
+ 4;
3753 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3755 /* Look through the list of undefined symbols. */
3756 pundef
= &info
->hash
->undefs
;
3757 while (*pundef
!= NULL
)
3759 struct bfd_link_hash_entry
*h
;
3760 unsigned int hash
, rehash
;
3761 unsigned int file_offset
;
3767 /* When a symbol is defined, it is not necessarily removed from
3769 if (h
->type
!= bfd_link_hash_undefined
3770 && h
->type
!= bfd_link_hash_common
)
3772 /* Remove this entry from the list, for general cleanliness
3773 and because we are going to look through the list again
3774 if we search any more libraries. We can't remove the
3775 entry if it is the tail, because that would lose any
3776 entries we add to the list later on. */
3777 if (*pundef
!= info
->hash
->undefs_tail
)
3778 *pundef
= (*pundef
)->u
.undef
.next
;
3780 pundef
= &(*pundef
)->u
.undef
.next
;
3784 /* Native ECOFF linkers do not pull in archive elements merely
3785 to satisfy common definitions, so neither do we. We leave
3786 them on the list, though, in case we are linking against some
3787 other object format. */
3788 if (h
->type
!= bfd_link_hash_undefined
)
3790 pundef
= &(*pundef
)->u
.undef
.next
;
3794 /* Look for this symbol in the archive hash table. */
3795 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3798 file_offset
= H_GET_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3799 if (file_offset
== 0)
3801 /* Nothing in this slot. */
3802 pundef
= &(*pundef
)->u
.undef
.next
;
3806 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (hash
* 8));
3807 if (name
[0] != h
->root
.string
[0]
3808 || ! streq (name
, h
->root
.string
))
3813 /* That was the wrong symbol. Try rehashing. */
3815 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3817 srch
= (srch
+ rehash
) & (armap_count
- 1))
3819 file_offset
= H_GET_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3820 if (file_offset
== 0)
3822 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (srch
* 8));
3823 if (name
[0] == h
->root
.string
[0]
3824 && streq (name
, h
->root
.string
))
3833 pundef
= &(*pundef
)->u
.undef
.next
;
3840 element
= (*backend
->get_elt_at_filepos
) (abfd
, (file_ptr
) file_offset
);
3841 if (element
== NULL
)
3844 if (! bfd_check_format (element
, bfd_object
))
3847 /* Unlike the generic linker, we know that this element provides
3848 a definition for an undefined symbol and we know that we want
3849 to include it. We don't need to check anything. */
3850 if (! (*info
->callbacks
->add_archive_element
) (info
, element
, name
))
3852 if (! ecoff_link_add_object_symbols (element
, info
))
3855 pundef
= &(*pundef
)->u
.undef
.next
;
3861 /* Given an ECOFF BFD, add symbols to the global hash table as
3865 _bfd_ecoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3867 switch (bfd_get_format (abfd
))
3870 return ecoff_link_add_object_symbols (abfd
, info
);
3872 return ecoff_link_add_archive_symbols (abfd
, info
);
3874 bfd_set_error (bfd_error_wrong_format
);
3880 /* ECOFF final link routines. */
3882 /* Structure used to pass information to ecoff_link_write_external. */
3887 struct bfd_link_info
*info
;
3890 /* Accumulate the debugging information for an input BFD into the
3891 output BFD. This must read in the symbolic information of the
3895 ecoff_final_link_debug_accumulate (bfd
*output_bfd
,
3897 struct bfd_link_info
*info
,
3900 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
3901 const struct ecoff_debug_swap
* const swap
=
3902 &ecoff_backend (input_bfd
)->debug_swap
;
3903 HDRR
*symhdr
= &debug
->symbolic_header
;
3906 #define READ(ptr, offset, count, size, type) \
3907 if (symhdr->count == 0) \
3908 debug->ptr = NULL; \
3911 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
3912 debug->ptr = bfd_malloc (amt); \
3913 if (debug->ptr == NULL) \
3916 goto return_something; \
3918 if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3919 || bfd_bread (debug->ptr, amt, input_bfd) != amt) \
3922 goto return_something; \
3926 /* If raw_syments is not NULL, then the data was already by read by
3927 _bfd_ecoff_slurp_symbolic_info. */
3928 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3930 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
3932 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
3933 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
3934 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
3935 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
3936 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3938 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3939 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
3940 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
3944 /* We do not read the external strings or the external symbols. */
3946 ret
= (bfd_ecoff_debug_accumulate
3947 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
3948 &ecoff_backend (output_bfd
)->debug_swap
,
3949 input_bfd
, debug
, swap
, info
));
3952 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3954 if (debug
->line
!= NULL
)
3956 if (debug
->external_dnr
!= NULL
)
3957 free (debug
->external_dnr
);
3958 if (debug
->external_pdr
!= NULL
)
3959 free (debug
->external_pdr
);
3960 if (debug
->external_sym
!= NULL
)
3961 free (debug
->external_sym
);
3962 if (debug
->external_opt
!= NULL
)
3963 free (debug
->external_opt
);
3964 if (debug
->external_aux
!= NULL
)
3965 free (debug
->external_aux
);
3966 if (debug
->ss
!= NULL
)
3968 if (debug
->external_fdr
!= NULL
)
3969 free (debug
->external_fdr
);
3970 if (debug
->external_rfd
!= NULL
)
3971 free (debug
->external_rfd
);
3973 /* Make sure we don't accidentally follow one of these pointers
3974 into freed memory. */
3976 debug
->external_dnr
= NULL
;
3977 debug
->external_pdr
= NULL
;
3978 debug
->external_sym
= NULL
;
3979 debug
->external_opt
= NULL
;
3980 debug
->external_aux
= NULL
;
3982 debug
->external_fdr
= NULL
;
3983 debug
->external_rfd
= NULL
;
3989 /* Relocate and write an ECOFF section into an ECOFF output file. */
3992 ecoff_indirect_link_order (bfd
*output_bfd
,
3993 struct bfd_link_info
*info
,
3994 asection
*output_section
,
3995 struct bfd_link_order
*link_order
)
3997 asection
*input_section
;
3999 bfd_byte
*contents
= NULL
;
4000 bfd_size_type external_reloc_size
;
4001 bfd_size_type external_relocs_size
;
4002 void * external_relocs
= NULL
;
4004 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
4006 input_section
= link_order
->u
.indirect
.section
;
4007 input_bfd
= input_section
->owner
;
4008 if (input_section
->size
== 0)
4011 BFD_ASSERT (input_section
->output_section
== output_section
);
4012 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
4013 BFD_ASSERT (input_section
->size
== link_order
->size
);
4015 /* Get the section contents. */
4016 if (!bfd_malloc_and_get_section (input_bfd
, input_section
, &contents
))
4019 /* Get the relocs. If we are relaxing MIPS code, they will already
4020 have been read in. Otherwise, we read them in now. */
4021 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
4022 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
4024 external_relocs
= bfd_malloc (external_relocs_size
);
4025 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
4028 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
4029 || (bfd_bread (external_relocs
, external_relocs_size
, input_bfd
)
4030 != external_relocs_size
))
4033 /* Relocate the section contents. */
4034 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
4035 (output_bfd
, info
, input_bfd
, input_section
, contents
,
4039 /* Write out the relocated section. */
4040 if (! bfd_set_section_contents (output_bfd
,
4043 input_section
->output_offset
,
4044 input_section
->size
))
4047 /* If we are producing relocatable output, the relocs were
4048 modified, and we write them out now. We use the reloc_count
4049 field of output_section to keep track of the number of relocs we
4050 have output so far. */
4051 if (info
->relocatable
)
4053 file_ptr pos
= (output_section
->rel_filepos
4054 + output_section
->reloc_count
* external_reloc_size
);
4055 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4056 || (bfd_bwrite (external_relocs
, external_relocs_size
, output_bfd
)
4057 != external_relocs_size
))
4059 output_section
->reloc_count
+= input_section
->reloc_count
;
4062 if (contents
!= NULL
)
4064 if (external_relocs
!= NULL
)
4065 free (external_relocs
);
4069 if (contents
!= NULL
)
4071 if (external_relocs
!= NULL
)
4072 free (external_relocs
);
4076 /* Generate a reloc when linking an ECOFF file. This is a reloc
4077 requested by the linker, and does come from any input file. This
4078 is used to build constructor and destructor tables when linking
4082 ecoff_reloc_link_order (bfd
*output_bfd
,
4083 struct bfd_link_info
*info
,
4084 asection
*output_section
,
4085 struct bfd_link_order
*link_order
)
4087 enum bfd_link_order_type type
;
4091 struct internal_reloc in
;
4092 bfd_size_type external_reloc_size
;
4097 type
= link_order
->type
;
4099 addend
= link_order
->u
.reloc
.p
->addend
;
4101 /* We set up an arelent to pass to the backend adjust_reloc_out
4103 rel
.address
= link_order
->offset
;
4105 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
4108 bfd_set_error (bfd_error_bad_value
);
4112 if (type
== bfd_section_reloc_link_order
)
4114 section
= link_order
->u
.reloc
.p
->u
.section
;
4115 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
4119 struct bfd_link_hash_entry
*h
;
4121 /* Treat a reloc against a defined symbol as though it were
4122 actually against the section. */
4123 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4124 link_order
->u
.reloc
.p
->u
.name
,
4125 FALSE
, FALSE
, FALSE
);
4127 && (h
->type
== bfd_link_hash_defined
4128 || h
->type
== bfd_link_hash_defweak
))
4130 type
= bfd_section_reloc_link_order
;
4131 section
= h
->u
.def
.section
->output_section
;
4132 /* It seems that we ought to add the symbol value to the
4133 addend here, but in practice it has already been added
4134 because it was passed to constructor_callback. */
4135 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
4139 /* We can't set up a reloc against a symbol correctly,
4140 because we have no asymbol structure. Currently no
4141 adjust_reloc_out routine cares. */
4142 rel
.sym_ptr_ptr
= NULL
;
4146 /* All ECOFF relocs are in-place. Put the addend into the object
4149 BFD_ASSERT (rel
.howto
->partial_inplace
);
4153 bfd_reloc_status_type rstat
;
4156 size
= bfd_get_reloc_size (rel
.howto
);
4157 buf
= bfd_zmalloc (size
);
4160 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
4161 (bfd_vma
) addend
, buf
);
4167 case bfd_reloc_outofrange
:
4169 case bfd_reloc_overflow
:
4170 if (! ((*info
->callbacks
->reloc_overflow
)
4172 (link_order
->type
== bfd_section_reloc_link_order
4173 ? bfd_section_name (output_bfd
, section
)
4174 : link_order
->u
.reloc
.p
->u
.name
),
4175 rel
.howto
->name
, addend
, NULL
,
4176 NULL
, (bfd_vma
) 0)))
4183 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
4184 (file_ptr
) link_order
->offset
, size
);
4192 /* Move the information into an internal_reloc structure. */
4193 in
.r_vaddr
= (rel
.address
4194 + bfd_get_section_vma (output_bfd
, output_section
));
4195 in
.r_type
= rel
.howto
->type
;
4197 if (type
== bfd_symbol_reloc_link_order
)
4199 struct ecoff_link_hash_entry
*h
;
4201 h
= ((struct ecoff_link_hash_entry
*)
4202 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4203 link_order
->u
.reloc
.p
->u
.name
,
4204 FALSE
, FALSE
, TRUE
));
4207 in
.r_symndx
= h
->indx
;
4210 if (! ((*info
->callbacks
->unattached_reloc
)
4211 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
,
4212 NULL
, (bfd_vma
) 0)))
4229 { _TEXT
, RELOC_SECTION_TEXT
},
4230 { _RDATA
, RELOC_SECTION_RDATA
},
4231 { _DATA
, RELOC_SECTION_DATA
},
4232 { _SDATA
, RELOC_SECTION_SDATA
},
4233 { _SBSS
, RELOC_SECTION_SBSS
},
4234 { _BSS
, RELOC_SECTION_BSS
},
4235 { _INIT
, RELOC_SECTION_INIT
},
4236 { _LIT8
, RELOC_SECTION_LIT8
},
4237 { _LIT4
, RELOC_SECTION_LIT4
},
4238 { _XDATA
, RELOC_SECTION_XDATA
},
4239 { _PDATA
, RELOC_SECTION_PDATA
},
4240 { _FINI
, RELOC_SECTION_FINI
},
4241 { _LITA
, RELOC_SECTION_LITA
},
4242 { "*ABS*", RELOC_SECTION_ABS
},
4243 { _RCONST
, RELOC_SECTION_RCONST
}
4246 name
= bfd_get_section_name (output_bfd
, section
);
4248 for (i
= 0; i
< ARRAY_SIZE (section_symndx
); i
++)
4249 if (streq (name
, section_symndx
[i
].name
))
4251 in
.r_symndx
= section_symndx
[i
].r_symndx
;
4255 if (i
== ARRAY_SIZE (section_symndx
))
4261 /* Let the BFD backend adjust the reloc. */
4262 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4264 /* Get some memory and swap out the reloc. */
4265 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4266 rbuf
= bfd_malloc (external_reloc_size
);
4270 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (void *) rbuf
);
4272 pos
= (output_section
->rel_filepos
4273 + output_section
->reloc_count
* external_reloc_size
);
4274 ok
= (bfd_seek (output_bfd
, pos
, SEEK_SET
) == 0
4275 && (bfd_bwrite ((void *) rbuf
, external_reloc_size
, output_bfd
)
4276 == external_reloc_size
));
4279 ++output_section
->reloc_count
;
4286 /* Put out information for an external symbol. These come only from
4290 ecoff_link_write_external (struct ecoff_link_hash_entry
*h
, void * data
)
4292 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4293 bfd
*output_bfd
= einfo
->abfd
;
4296 if (h
->root
.type
== bfd_link_hash_warning
)
4298 h
= (struct ecoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4299 if (h
->root
.type
== bfd_link_hash_new
)
4303 /* We need to check if this symbol is being stripped. */
4304 if (h
->root
.type
== bfd_link_hash_undefined
4305 || h
->root
.type
== bfd_link_hash_undefweak
)
4307 else if (einfo
->info
->strip
== strip_all
4308 || (einfo
->info
->strip
== strip_some
4309 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4310 h
->root
.root
.string
,
4311 FALSE
, FALSE
) == NULL
))
4316 if (strip
|| h
->written
)
4319 if (h
->abfd
== NULL
)
4322 h
->esym
.cobol_main
= 0;
4323 h
->esym
.weakext
= 0;
4324 h
->esym
.reserved
= 0;
4325 h
->esym
.ifd
= ifdNil
;
4326 h
->esym
.asym
.value
= 0;
4327 h
->esym
.asym
.st
= stGlobal
;
4329 if (h
->root
.type
!= bfd_link_hash_defined
4330 && h
->root
.type
!= bfd_link_hash_defweak
)
4331 h
->esym
.asym
.sc
= scAbs
;
4334 asection
*output_section
;
4342 section_storage_classes
[] =
4346 { _SDATA
, scSData
},
4347 { _RDATA
, scRData
},
4352 { _PDATA
, scPData
},
4353 { _XDATA
, scXData
},
4354 { _RCONST
, scRConst
}
4357 output_section
= h
->root
.u
.def
.section
->output_section
;
4358 name
= bfd_section_name (output_section
->owner
, output_section
);
4360 for (i
= 0; i
< ARRAY_SIZE (section_storage_classes
); i
++)
4361 if (streq (name
, section_storage_classes
[i
].name
))
4363 h
->esym
.asym
.sc
= section_storage_classes
[i
].sc
;
4367 if (i
== ARRAY_SIZE (section_storage_classes
))
4368 h
->esym
.asym
.sc
= scAbs
;
4371 h
->esym
.asym
.reserved
= 0;
4372 h
->esym
.asym
.index
= indexNil
;
4374 else if (h
->esym
.ifd
!= -1)
4376 struct ecoff_debug_info
*debug
;
4378 /* Adjust the FDR index for the symbol by that used for the
4380 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4381 BFD_ASSERT (h
->esym
.ifd
>= 0
4382 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4383 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4386 switch (h
->root
.type
)
4389 case bfd_link_hash_warning
:
4390 case bfd_link_hash_new
:
4392 case bfd_link_hash_undefined
:
4393 case bfd_link_hash_undefweak
:
4394 if (h
->esym
.asym
.sc
!= scUndefined
4395 && h
->esym
.asym
.sc
!= scSUndefined
)
4396 h
->esym
.asym
.sc
= scUndefined
;
4398 case bfd_link_hash_defined
:
4399 case bfd_link_hash_defweak
:
4400 if (h
->esym
.asym
.sc
== scUndefined
4401 || h
->esym
.asym
.sc
== scSUndefined
)
4402 h
->esym
.asym
.sc
= scAbs
;
4403 else if (h
->esym
.asym
.sc
== scCommon
)
4404 h
->esym
.asym
.sc
= scBss
;
4405 else if (h
->esym
.asym
.sc
== scSCommon
)
4406 h
->esym
.asym
.sc
= scSBss
;
4407 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4408 + h
->root
.u
.def
.section
->output_section
->vma
4409 + h
->root
.u
.def
.section
->output_offset
);
4411 case bfd_link_hash_common
:
4412 if (h
->esym
.asym
.sc
!= scCommon
4413 && h
->esym
.asym
.sc
!= scSCommon
)
4414 h
->esym
.asym
.sc
= scCommon
;
4415 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4417 case bfd_link_hash_indirect
:
4418 /* We ignore these symbols, since the indirected symbol is
4419 already in the hash table. */
4423 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4425 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4428 return (bfd_ecoff_debug_one_external
4429 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4430 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4434 /* ECOFF final link routine. This looks through all the input BFDs
4435 and gathers together all the debugging information, and then
4436 processes all the link order information. This may cause it to
4437 close and reopen some input BFDs; I'll see how bad this is. */
4440 _bfd_ecoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
4442 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4443 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4448 struct bfd_link_order
*p
;
4449 struct extsym_info einfo
;
4451 /* We accumulate the debugging information counts in the symbolic
4453 symhdr
= &debug
->symbolic_header
;
4455 symhdr
->ilineMax
= 0;
4459 symhdr
->isymMax
= 0;
4460 symhdr
->ioptMax
= 0;
4461 symhdr
->iauxMax
= 0;
4463 symhdr
->issExtMax
= 0;
4466 symhdr
->iextMax
= 0;
4468 /* We accumulate the debugging information itself in the debug_info
4471 debug
->external_dnr
= NULL
;
4472 debug
->external_pdr
= NULL
;
4473 debug
->external_sym
= NULL
;
4474 debug
->external_opt
= NULL
;
4475 debug
->external_aux
= NULL
;
4477 debug
->ssext
= debug
->ssext_end
= NULL
;
4478 debug
->external_fdr
= NULL
;
4479 debug
->external_rfd
= NULL
;
4480 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4482 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4486 /* Accumulate the debugging symbols from each input BFD. */
4487 for (input_bfd
= info
->input_bfds
;
4489 input_bfd
= input_bfd
->link_next
)
4493 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4495 /* Arbitrarily set the symbolic header vstamp to the vstamp
4496 of the first object file in the link. */
4497 if (symhdr
->vstamp
== 0)
4499 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4500 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4504 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4505 debug
, &backend
->debug_swap
,
4510 /* Combine the register masks. */
4511 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4512 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4513 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4514 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4515 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4516 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4519 /* Write out the external symbols. */
4522 ecoff_link_hash_traverse (ecoff_hash_table (info
),
4523 ecoff_link_write_external
,
4526 if (info
->relocatable
)
4528 /* We need to make a pass over the link_orders to count up the
4529 number of relocations we will need to output, so that we know
4530 how much space they will take up. */
4531 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4534 for (p
= o
->map_head
.link_order
;
4537 if (p
->type
== bfd_indirect_link_order
)
4538 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4539 else if (p
->type
== bfd_section_reloc_link_order
4540 || p
->type
== bfd_symbol_reloc_link_order
)
4545 /* Compute the reloc and symbol file positions. */
4546 ecoff_compute_reloc_file_positions (abfd
);
4548 /* Write out the debugging information. */
4549 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4550 &backend
->debug_swap
, info
,
4551 ecoff_data (abfd
)->sym_filepos
))
4554 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4556 if (info
->relocatable
)
4558 /* Now reset the reloc_count field of the sections in the output
4559 BFD to 0, so that we can use them to keep track of how many
4560 relocs we have output thus far. */
4561 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4565 /* Get a value for the GP register. */
4566 if (ecoff_data (abfd
)->gp
== 0)
4568 struct bfd_link_hash_entry
*h
;
4570 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
4572 && h
->type
== bfd_link_hash_defined
)
4573 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4574 + h
->u
.def
.section
->output_section
->vma
4575 + h
->u
.def
.section
->output_offset
);
4576 else if (info
->relocatable
)
4580 /* Make up a value. */
4582 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4585 && (streq (o
->name
, _SBSS
)
4586 || streq (o
->name
, _SDATA
)
4587 || streq (o
->name
, _LIT4
)
4588 || streq (o
->name
, _LIT8
)
4589 || streq (o
->name
, _LITA
)))
4592 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4596 /* If the relocate_section function needs to do a reloc
4597 involving the GP value, it should make a reloc_dangerous
4598 callback to warn that GP is not defined. */
4602 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4604 for (p
= o
->map_head
.link_order
;
4608 if (p
->type
== bfd_indirect_link_order
4609 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4610 == bfd_target_ecoff_flavour
))
4612 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4615 else if (p
->type
== bfd_section_reloc_link_order
4616 || p
->type
== bfd_symbol_reloc_link_order
)
4618 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4623 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4629 bfd_get_symcount (abfd
) = symhdr
->iextMax
+ symhdr
->isymMax
;
4631 ecoff_data (abfd
)->linker
= TRUE
;