1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright (C) 1990-2021 Free Software Foundation, Inc.
3 Original version by Per Bothner.
4 Full support added by Ian Lance Taylor, ian@cygnus.com.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "ecoff-bfd.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)
51 /* This stuff is somewhat copied from coffcode.h. */
52 static asection bfd_debug_section
=
53 BFD_FAKE_SECTION (bfd_debug_section
, NULL
, "*DEBUG*", 0, 0);
55 /* Create an ECOFF object. */
58 _bfd_ecoff_mkobject (bfd
*abfd
)
60 size_t amt
= sizeof (ecoff_data_type
);
62 abfd
->tdata
.ecoff_obj_data
= (struct ecoff_tdata
*) bfd_zalloc (abfd
, amt
);
63 if (abfd
->tdata
.ecoff_obj_data
== NULL
)
69 /* This is a hook called by coff_real_object_p to create any backend
70 specific information. */
73 _bfd_ecoff_mkobject_hook (bfd
*abfd
, void * filehdr
, void * aouthdr
)
75 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
76 struct internal_aouthdr
*internal_a
= (struct internal_aouthdr
*) aouthdr
;
77 ecoff_data_type
*ecoff
;
79 if (! _bfd_ecoff_mkobject (abfd
))
82 ecoff
= ecoff_data (abfd
);
84 ecoff
->sym_filepos
= internal_f
->f_symptr
;
86 if (internal_a
!= NULL
)
90 ecoff
->text_start
= internal_a
->text_start
;
91 ecoff
->text_end
= internal_a
->text_start
+ internal_a
->tsize
;
92 ecoff
->gp
= internal_a
->gp_value
;
93 ecoff
->gprmask
= internal_a
->gprmask
;
94 for (i
= 0; i
< 4; i
++)
95 ecoff
->cprmask
[i
] = internal_a
->cprmask
[i
];
96 ecoff
->fprmask
= internal_a
->fprmask
;
97 if (internal_a
->magic
== ECOFF_AOUT_ZMAGIC
)
98 abfd
->flags
|= D_PAGED
;
100 abfd
->flags
&=~ D_PAGED
;
103 /* It turns out that no special action is required by the MIPS or
104 Alpha ECOFF backends. They have different information in the
105 a.out header, but we just copy it all (e.g., gprmask, cprmask and
106 fprmask) and let the swapping routines ensure that only relevant
107 information is written out. */
109 return (void *) ecoff
;
112 /* Initialize a new section. */
115 _bfd_ecoff_new_section_hook (bfd
*abfd
, asection
*section
)
125 { _TEXT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
126 { _INIT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
127 { _FINI
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
128 { _DATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
},
129 { _SDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_SMALL_DATA
},
130 { _RDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
131 { _LIT8
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
| SEC_SMALL_DATA
},
132 { _LIT4
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
| SEC_SMALL_DATA
},
133 { _RCONST
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
134 { _PDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
136 { _SBSS
, SEC_ALLOC
| SEC_SMALL_DATA
},
137 /* An Irix 4 shared libary. */
138 { _LIB
, SEC_COFF_SHARED_LIBRARY
}
141 section
->alignment_power
= 4;
143 for (i
= 0; i
< ARRAY_SIZE (section_flags
); i
++)
144 if (streq (section
->name
, section_flags
[i
].name
))
146 section
->flags
|= section_flags
[i
].flags
;
151 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
152 uncertain about .init on some systems and I don't know how shared
155 return _bfd_generic_new_section_hook (abfd
, section
);
159 _bfd_ecoff_set_alignment_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
160 asection
*section ATTRIBUTE_UNUSED
,
161 void *scnhdr ATTRIBUTE_UNUSED
)
165 /* Determine the machine architecture and type. This is called from
166 the generic COFF routines. It is the inverse of ecoff_get_magic,
167 below. This could be an ECOFF backend routine, with one version
168 for each target, but there aren't all that many ECOFF targets. */
171 _bfd_ecoff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
173 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
174 enum bfd_architecture arch
;
177 switch (internal_f
->f_magic
)
180 case MIPS_MAGIC_LITTLE
:
182 arch
= bfd_arch_mips
;
183 mach
= bfd_mach_mips3000
;
186 case MIPS_MAGIC_LITTLE2
:
187 case MIPS_MAGIC_BIG2
:
188 /* MIPS ISA level 2: the r6000. */
189 arch
= bfd_arch_mips
;
190 mach
= bfd_mach_mips6000
;
193 case MIPS_MAGIC_LITTLE3
:
194 case MIPS_MAGIC_BIG3
:
195 /* MIPS ISA level 3: the r4000. */
196 arch
= bfd_arch_mips
;
197 mach
= bfd_mach_mips4000
;
201 arch
= bfd_arch_alpha
;
206 arch
= bfd_arch_obscure
;
211 return bfd_default_set_arch_mach (abfd
, arch
, mach
);
215 _bfd_ecoff_no_long_sections (bfd
*abfd
, int enable
)
222 /* Get the magic number to use based on the architecture and machine.
223 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
226 ecoff_get_magic (bfd
*abfd
)
230 switch (bfd_get_arch (abfd
))
233 switch (bfd_get_mach (abfd
))
237 case bfd_mach_mips3000
:
238 big
= MIPS_MAGIC_BIG
;
239 little
= MIPS_MAGIC_LITTLE
;
242 case bfd_mach_mips6000
:
243 big
= MIPS_MAGIC_BIG2
;
244 little
= MIPS_MAGIC_LITTLE2
;
247 case bfd_mach_mips4000
:
248 big
= MIPS_MAGIC_BIG3
;
249 little
= MIPS_MAGIC_LITTLE3
;
253 return bfd_big_endian (abfd
) ? big
: little
;
264 /* Get the section s_flags to use for a section. */
267 ecoff_sec_to_styp_flags (const char *name
, flagword flags
)
277 { _TEXT
, STYP_TEXT
},
278 { _DATA
, STYP_DATA
},
279 { _SDATA
, STYP_SDATA
},
280 { _RDATA
, STYP_RDATA
},
281 { _LITA
, STYP_LITA
},
282 { _LIT8
, STYP_LIT8
},
283 { _LIT4
, STYP_LIT4
},
285 { _SBSS
, STYP_SBSS
},
286 { _INIT
, STYP_ECOFF_INIT
},
287 { _FINI
, STYP_ECOFF_FINI
},
288 { _PDATA
, STYP_PDATA
},
289 { _XDATA
, STYP_XDATA
},
290 { _LIB
, STYP_ECOFF_LIB
},
292 { _HASH
, STYP_HASH
},
293 { _DYNAMIC
, STYP_DYNAMIC
},
294 { _LIBLIST
, STYP_LIBLIST
},
295 { _RELDYN
, STYP_RELDYN
},
296 { _CONFLIC
, STYP_CONFLIC
},
297 { _DYNSTR
, STYP_DYNSTR
},
298 { _DYNSYM
, STYP_DYNSYM
},
299 { _RCONST
, STYP_RCONST
}
303 for (i
= 0; i
< ARRAY_SIZE (styp_flags
); i
++)
304 if (streq (name
, styp_flags
[i
].name
))
306 styp
= styp_flags
[i
].flags
;
312 if (streq (name
, _COMMENT
))
315 flags
&=~ SEC_NEVER_LOAD
;
317 else if (flags
& SEC_CODE
)
319 else if (flags
& SEC_DATA
)
321 else if (flags
& SEC_READONLY
)
323 else if (flags
& SEC_LOAD
)
329 if (flags
& SEC_NEVER_LOAD
)
335 /* Get the BFD flags to use for a section. */
338 _bfd_ecoff_styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
340 const char *name ATTRIBUTE_UNUSED
,
341 asection
*section ATTRIBUTE_UNUSED
,
342 flagword
* flags_ptr
)
344 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
345 long styp_flags
= internal_s
->s_flags
;
346 flagword sec_flags
= 0;
348 if (styp_flags
& STYP_NOLOAD
)
349 sec_flags
|= SEC_NEVER_LOAD
;
351 /* For 386 COFF, at least, an unloadable text or data section is
352 actually a shared library section. */
353 if ((styp_flags
& STYP_TEXT
)
354 || (styp_flags
& STYP_ECOFF_INIT
)
355 || (styp_flags
& STYP_ECOFF_FINI
)
356 || (styp_flags
& STYP_DYNAMIC
)
357 || (styp_flags
& STYP_LIBLIST
)
358 || (styp_flags
& STYP_RELDYN
)
359 || styp_flags
== STYP_CONFLIC
360 || (styp_flags
& STYP_DYNSTR
)
361 || (styp_flags
& STYP_DYNSYM
)
362 || (styp_flags
& STYP_HASH
))
364 if (sec_flags
& SEC_NEVER_LOAD
)
365 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
367 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
369 else if ((styp_flags
& STYP_DATA
)
370 || (styp_flags
& STYP_RDATA
)
371 || (styp_flags
& STYP_SDATA
)
372 || styp_flags
== STYP_PDATA
373 || styp_flags
== STYP_XDATA
374 || (styp_flags
& STYP_GOT
)
375 || styp_flags
== STYP_RCONST
)
377 if (sec_flags
& SEC_NEVER_LOAD
)
378 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
380 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
381 if ((styp_flags
& STYP_RDATA
)
382 || styp_flags
== STYP_PDATA
383 || styp_flags
== STYP_RCONST
)
384 sec_flags
|= SEC_READONLY
;
385 if (styp_flags
& STYP_SDATA
)
386 sec_flags
|= SEC_SMALL_DATA
;
388 else if (styp_flags
& STYP_SBSS
)
389 sec_flags
|= SEC_ALLOC
| SEC_SMALL_DATA
;
390 else if (styp_flags
& STYP_BSS
)
391 sec_flags
|= SEC_ALLOC
;
392 else if ((styp_flags
& STYP_INFO
) || styp_flags
== STYP_COMMENT
)
393 sec_flags
|= SEC_NEVER_LOAD
;
394 else if ((styp_flags
& STYP_LITA
)
395 || (styp_flags
& STYP_LIT8
)
396 || (styp_flags
& STYP_LIT4
))
397 sec_flags
|= SEC_DATA
|SEC_SMALL_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
398 else if (styp_flags
& STYP_ECOFF_LIB
)
399 sec_flags
|= SEC_COFF_SHARED_LIBRARY
;
401 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
403 * flags_ptr
= sec_flags
;
407 /* Read in the symbolic header for an ECOFF object file. */
410 ecoff_slurp_symbolic_header (bfd
*abfd
)
412 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
413 bfd_size_type external_hdr_size
;
415 HDRR
*internal_symhdr
;
417 /* See if we've already read it in. */
418 if (ecoff_data (abfd
)->debug_info
.symbolic_header
.magic
==
419 backend
->debug_swap
.sym_magic
)
422 /* See whether there is a symbolic header. */
423 if (ecoff_data (abfd
)->sym_filepos
== 0)
429 /* At this point bfd_get_symcount (abfd) holds the number of symbols
430 as read from the file header, but on ECOFF this is always the
431 size of the symbolic information header. It would be cleaner to
432 handle this when we first read the file in coffgen.c. */
433 external_hdr_size
= backend
->debug_swap
.external_hdr_size
;
434 if (bfd_get_symcount (abfd
) != external_hdr_size
)
436 bfd_set_error (bfd_error_bad_value
);
440 /* Read the symbolic information header. */
441 if (bfd_seek (abfd
, ecoff_data (abfd
)->sym_filepos
, SEEK_SET
) != 0)
443 raw
= _bfd_malloc_and_read (abfd
, external_hdr_size
, external_hdr_size
);
447 internal_symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
448 (*backend
->debug_swap
.swap_hdr_in
) (abfd
, raw
, internal_symhdr
);
450 if (internal_symhdr
->magic
!= backend
->debug_swap
.sym_magic
)
452 bfd_set_error (bfd_error_bad_value
);
456 /* Now we can get the correct number of symbols. */
457 abfd
->symcount
= internal_symhdr
->isymMax
+ internal_symhdr
->iextMax
;
466 /* Read in and swap the important symbolic information for an ECOFF
467 object file. This is called by gdb via the read_debug_info entry
468 point in the backend structure. */
471 _bfd_ecoff_slurp_symbolic_info (bfd
*abfd
,
472 asection
*ignore ATTRIBUTE_UNUSED
,
473 struct ecoff_debug_info
*debug
)
475 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
476 HDRR
*internal_symhdr
;
477 bfd_size_type raw_base
;
478 bfd_size_type raw_size
;
480 bfd_size_type external_fdr_size
;
484 bfd_size_type raw_end
;
485 bfd_size_type cb_end
;
489 BFD_ASSERT (debug
== &ecoff_data (abfd
)->debug_info
);
491 /* Check whether we've already gotten it, and whether there's any to
493 if (ecoff_data (abfd
)->raw_syments
!= NULL
)
495 if (ecoff_data (abfd
)->sym_filepos
== 0)
501 if (! ecoff_slurp_symbolic_header (abfd
))
504 internal_symhdr
= &debug
->symbolic_header
;
506 /* Read all the symbolic information at once. */
507 raw_base
= (ecoff_data (abfd
)->sym_filepos
508 + backend
->debug_swap
.external_hdr_size
);
510 /* Alpha ecoff makes the determination of raw_size difficult. It has
511 an undocumented debug data section between the symhdr and the first
512 documented section. And the ordering of the sections varies between
513 statically and dynamically linked executables.
514 If bfd supports SEEK_END someday, this code could be simplified. */
517 #define UPDATE_RAW_END(start, count, size) \
518 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
519 if (cb_end > raw_end) \
522 UPDATE_RAW_END (cbLineOffset
, cbLine
, sizeof (unsigned char));
523 UPDATE_RAW_END (cbDnOffset
, idnMax
, backend
->debug_swap
.external_dnr_size
);
524 UPDATE_RAW_END (cbPdOffset
, ipdMax
, backend
->debug_swap
.external_pdr_size
);
525 UPDATE_RAW_END (cbSymOffset
, isymMax
, backend
->debug_swap
.external_sym_size
);
526 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
527 optimization symtab, not the number of entries. */
528 UPDATE_RAW_END (cbOptOffset
, ioptMax
, sizeof (char));
529 UPDATE_RAW_END (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
530 UPDATE_RAW_END (cbSsOffset
, issMax
, sizeof (char));
531 UPDATE_RAW_END (cbSsExtOffset
, issExtMax
, sizeof (char));
532 UPDATE_RAW_END (cbFdOffset
, ifdMax
, backend
->debug_swap
.external_fdr_size
);
533 UPDATE_RAW_END (cbRfdOffset
, crfd
, backend
->debug_swap
.external_rfd_size
);
534 UPDATE_RAW_END (cbExtOffset
, iextMax
, backend
->debug_swap
.external_ext_size
);
536 #undef UPDATE_RAW_END
538 raw_size
= raw_end
- raw_base
;
541 ecoff_data (abfd
)->sym_filepos
= 0;
544 pos
= ecoff_data (abfd
)->sym_filepos
;
545 pos
+= backend
->debug_swap
.external_hdr_size
;
546 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
548 raw
= _bfd_alloc_and_read (abfd
, raw_size
, raw_size
);
552 ecoff_data (abfd
)->raw_syments
= raw
;
554 /* Get pointers for the numeric offsets in the HDRR structure. */
555 #define FIX(off1, off2, type) \
556 if (internal_symhdr->off1 == 0) \
557 debug->off2 = NULL; \
559 debug->off2 = (type) ((char *) raw \
560 + (internal_symhdr->off1 \
563 FIX (cbLineOffset
, line
, unsigned char *);
564 FIX (cbDnOffset
, external_dnr
, void *);
565 FIX (cbPdOffset
, external_pdr
, void *);
566 FIX (cbSymOffset
, external_sym
, void *);
567 FIX (cbOptOffset
, external_opt
, void *);
568 FIX (cbAuxOffset
, external_aux
, union aux_ext
*);
569 FIX (cbSsOffset
, ss
, char *);
570 FIX (cbSsExtOffset
, ssext
, char *);
571 FIX (cbFdOffset
, external_fdr
, void *);
572 FIX (cbRfdOffset
, external_rfd
, void *);
573 FIX (cbExtOffset
, external_ext
, void *);
576 /* I don't want to always swap all the data, because it will just
577 waste time and most programs will never look at it. The only
578 time the linker needs most of the debugging information swapped
579 is when linking big-endian and little-endian MIPS object files
580 together, which is not a common occurrence.
582 We need to look at the fdr to deal with a lot of information in
583 the symbols, so we swap them here. */
584 if (_bfd_mul_overflow ((unsigned long) internal_symhdr
->ifdMax
,
585 sizeof (struct fdr
), &amt
))
587 bfd_set_error (bfd_error_file_too_big
);
590 debug
->fdr
= (FDR
*) bfd_alloc (abfd
, amt
);
591 if (debug
->fdr
== NULL
)
593 external_fdr_size
= backend
->debug_swap
.external_fdr_size
;
594 fdr_ptr
= debug
->fdr
;
595 fraw_src
= (char *) debug
->external_fdr
;
596 /* PR 17512: file: 3372-1243-0.004. */
597 if (fraw_src
== NULL
&& internal_symhdr
->ifdMax
> 0)
599 fraw_end
= fraw_src
+ internal_symhdr
->ifdMax
* external_fdr_size
;
600 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
601 (*backend
->debug_swap
.swap_fdr_in
) (abfd
, (void *) fraw_src
, fdr_ptr
);
606 /* ECOFF symbol table routines. The ECOFF symbol table is described
607 in gcc/mips-tfile.c. */
609 /* ECOFF uses two common sections. One is the usual one, and the
610 other is for small objects. All the small objects are kept
611 together, and then referenced via the gp pointer, which yields
612 faster assembler code. This is what we use for the small common
614 static asection ecoff_scom_section
;
615 static const asymbol ecoff_scom_symbol
=
616 GLOBAL_SYM_INIT (SCOMMON
, &ecoff_scom_section
);
617 static asection ecoff_scom_section
=
618 BFD_FAKE_SECTION (ecoff_scom_section
, &ecoff_scom_symbol
,
619 SCOMMON
, 0, SEC_IS_COMMON
| SEC_SMALL_DATA
);
621 /* Create an empty symbol. */
624 _bfd_ecoff_make_empty_symbol (bfd
*abfd
)
626 ecoff_symbol_type
*new_symbol
;
627 size_t amt
= sizeof (ecoff_symbol_type
);
629 new_symbol
= (ecoff_symbol_type
*) bfd_zalloc (abfd
, amt
);
630 if (new_symbol
== NULL
)
632 new_symbol
->symbol
.section
= NULL
;
633 new_symbol
->fdr
= NULL
;
634 new_symbol
->local
= false;
635 new_symbol
->native
= NULL
;
636 new_symbol
->symbol
.the_bfd
= abfd
;
637 return &new_symbol
->symbol
;
640 /* Set the BFD flags and section for an ECOFF symbol. */
643 ecoff_set_symbol_info (bfd
*abfd
,
649 asym
->the_bfd
= abfd
;
650 asym
->value
= ecoff_sym
->value
;
651 asym
->section
= &bfd_debug_section
;
654 /* Most symbol types are just for debugging. */
655 switch (ecoff_sym
->st
)
664 if (ECOFF_IS_STAB (ecoff_sym
))
666 asym
->flags
= BSF_DEBUGGING
;
671 asym
->flags
= BSF_DEBUGGING
;
676 asym
->flags
= BSF_EXPORT
| BSF_WEAK
;
678 asym
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
681 asym
->flags
= BSF_LOCAL
;
682 /* Normally, a local stProc symbol will have a corresponding
683 external symbol. We mark the local symbol as a debugging
684 symbol, in order to prevent nm from printing both out.
685 Similarly, we mark stLabel and stabs symbols as debugging
686 symbols. In both cases, we do want to set the value
687 correctly based on the symbol class. */
688 if (ecoff_sym
->st
== stProc
689 || ecoff_sym
->st
== stLabel
690 || ECOFF_IS_STAB (ecoff_sym
))
691 asym
->flags
|= BSF_DEBUGGING
;
694 if (ecoff_sym
->st
== stProc
|| ecoff_sym
->st
== stStaticProc
)
695 asym
->flags
|= BSF_FUNCTION
;
697 switch (ecoff_sym
->sc
)
700 /* Used for compiler generated labels. Leave them in the
701 debugging section, and mark them as local. If BSF_DEBUGGING
702 is set, then nm does not display them for some reason. If no
703 flags are set then the linker whines about them. */
704 asym
->flags
= BSF_LOCAL
;
707 asym
->section
= bfd_make_section_old_way (abfd
, _TEXT
);
708 asym
->value
-= asym
->section
->vma
;
711 asym
->section
= bfd_make_section_old_way (abfd
, _DATA
);
712 asym
->value
-= asym
->section
->vma
;
715 asym
->section
= bfd_make_section_old_way (abfd
, _BSS
);
716 asym
->value
-= asym
->section
->vma
;
719 asym
->flags
= BSF_DEBUGGING
;
722 asym
->section
= bfd_abs_section_ptr
;
725 asym
->section
= bfd_und_section_ptr
;
735 asym
->flags
= BSF_DEBUGGING
;
738 asym
->section
= bfd_make_section_old_way (abfd
, ".sdata");
739 asym
->value
-= asym
->section
->vma
;
742 asym
->section
= bfd_make_section_old_way (abfd
, ".sbss");
743 asym
->value
-= asym
->section
->vma
;
746 asym
->section
= bfd_make_section_old_way (abfd
, ".rdata");
747 asym
->value
-= asym
->section
->vma
;
750 asym
->flags
= BSF_DEBUGGING
;
753 if (asym
->value
> ecoff_data (abfd
)->gp_size
)
755 asym
->section
= bfd_com_section_ptr
;
761 asym
->section
= &ecoff_scom_section
;
766 asym
->flags
= BSF_DEBUGGING
;
769 asym
->section
= bfd_und_section_ptr
;
774 asym
->section
= bfd_make_section_old_way (abfd
, ".init");
775 asym
->value
-= asym
->section
->vma
;
780 asym
->flags
= BSF_DEBUGGING
;
783 asym
->section
= bfd_make_section_old_way (abfd
, ".fini");
784 asym
->value
-= asym
->section
->vma
;
787 asym
->section
= bfd_make_section_old_way (abfd
, ".rconst");
788 asym
->value
-= asym
->section
->vma
;
794 /* Look for special constructors symbols and make relocation entries
795 in a special construction section. These are produced by the
796 -fgnu-linker argument to g++. */
797 if (ECOFF_IS_STAB (ecoff_sym
))
799 switch (ECOFF_UNMARK_STAB (ecoff_sym
->index
))
808 /* Mark the symbol as a constructor. */
809 asym
->flags
|= BSF_CONSTRUCTOR
;
816 /* Read an ECOFF symbol table. */
819 _bfd_ecoff_slurp_symbol_table (bfd
*abfd
)
821 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
822 const bfd_size_type external_ext_size
823 = backend
->debug_swap
.external_ext_size
;
824 const bfd_size_type external_sym_size
825 = backend
->debug_swap
.external_sym_size
;
826 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
827 = backend
->debug_swap
.swap_ext_in
;
828 void (* const swap_sym_in
) (bfd
*, void *, SYMR
*)
829 = backend
->debug_swap
.swap_sym_in
;
830 ecoff_symbol_type
*internal
;
831 ecoff_symbol_type
*internal_ptr
;
838 /* If we've already read in the symbol table, do nothing. */
839 if (ecoff_data (abfd
)->canonical_symbols
!= NULL
)
842 /* Get the symbolic information. */
843 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
844 &ecoff_data (abfd
)->debug_info
))
846 if (bfd_get_symcount (abfd
) == 0)
849 if (_bfd_mul_overflow (bfd_get_symcount (abfd
),
850 sizeof (ecoff_symbol_type
), &amt
))
852 bfd_set_error (bfd_error_file_too_big
);
855 internal
= (ecoff_symbol_type
*) bfd_alloc (abfd
, amt
);
856 if (internal
== NULL
)
859 internal_ptr
= internal
;
860 eraw_src
= (char *) ecoff_data (abfd
)->debug_info
.external_ext
;
862 + (ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
863 * external_ext_size
));
864 for (; eraw_src
< eraw_end
; eraw_src
+= external_ext_size
, internal_ptr
++)
868 (*swap_ext_in
) (abfd
, (void *) eraw_src
, &internal_esym
);
870 /* PR 17512: file: 3372-1000-0.004. */
871 if (internal_esym
.asym
.iss
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.issExtMax
872 || internal_esym
.asym
.iss
< 0)
875 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ssext
876 + internal_esym
.asym
.iss
);
878 if (!ecoff_set_symbol_info (abfd
, &internal_esym
.asym
,
879 &internal_ptr
->symbol
, 1,
880 internal_esym
.weakext
))
883 /* The alpha uses a negative ifd field for section symbols. */
884 if (internal_esym
.ifd
>= 0)
886 /* PR 17512: file: 3372-1983-0.004. */
887 if (internal_esym
.ifd
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
)
888 internal_ptr
->fdr
= NULL
;
890 internal_ptr
->fdr
= (ecoff_data (abfd
)->debug_info
.fdr
891 + internal_esym
.ifd
);
894 internal_ptr
->fdr
= NULL
;
895 internal_ptr
->local
= false;
896 internal_ptr
->native
= (void *) eraw_src
;
899 /* The local symbols must be accessed via the fdr's, because the
900 string and aux indices are relative to the fdr information. */
901 fdr_ptr
= ecoff_data (abfd
)->debug_info
.fdr
;
902 fdr_end
= fdr_ptr
+ ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
;
903 for (; fdr_ptr
< fdr_end
; fdr_ptr
++)
908 lraw_src
= ((char *) ecoff_data (abfd
)->debug_info
.external_sym
909 + fdr_ptr
->isymBase
* external_sym_size
);
910 lraw_end
= lraw_src
+ fdr_ptr
->csym
* external_sym_size
;
913 lraw_src
+= external_sym_size
, internal_ptr
++)
917 (*swap_sym_in
) (abfd
, (void *) lraw_src
, &internal_sym
);
918 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ss
921 if (!ecoff_set_symbol_info (abfd
, &internal_sym
,
922 &internal_ptr
->symbol
, 0, 0))
924 internal_ptr
->fdr
= fdr_ptr
;
925 internal_ptr
->local
= true;
926 internal_ptr
->native
= (void *) lraw_src
;
930 /* PR 17512: file: 3372-3080-0.004.
931 A discrepancy between ecoff_data (abfd)->debug_info.symbolic_header.isymMax
932 and ecoff_data (abfd)->debug_info.symbolic_header.ifdMax can mean that
933 we have fewer symbols than we were expecting. Allow for this by updating
934 the symbol count and warning the user. */
935 if (internal_ptr
- internal
< (ptrdiff_t) bfd_get_symcount (abfd
))
937 abfd
->symcount
= internal_ptr
- internal
;
939 /* xgettext:c-format */
940 (_("%pB: warning: isymMax (%ld) is greater than ifdMax (%ld)"),
941 abfd
, ecoff_data (abfd
)->debug_info
.symbolic_header
.isymMax
,
942 ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
);
945 ecoff_data (abfd
)->canonical_symbols
= internal
;
950 /* Return the amount of space needed for the canonical symbols. */
953 _bfd_ecoff_get_symtab_upper_bound (bfd
*abfd
)
955 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
956 &ecoff_data (abfd
)->debug_info
))
959 if (bfd_get_symcount (abfd
) == 0)
962 return (bfd_get_symcount (abfd
) + 1) * (sizeof (ecoff_symbol_type
*));
965 /* Get the canonical symbols. */
968 _bfd_ecoff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
970 unsigned int counter
= 0;
971 ecoff_symbol_type
*symbase
;
972 ecoff_symbol_type
**location
= (ecoff_symbol_type
**) alocation
;
974 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
976 if (bfd_get_symcount (abfd
) == 0)
979 symbase
= ecoff_data (abfd
)->canonical_symbols
;
980 while (counter
< bfd_get_symcount (abfd
))
982 *(location
++) = symbase
++;
986 return bfd_get_symcount (abfd
);
989 /* Turn ECOFF type information into a printable string.
990 ecoff_emit_aggregate and ecoff_type_to_string are from
991 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
993 /* Write aggregate information to a string. */
996 ecoff_emit_aggregate (bfd
*abfd
,
1003 const struct ecoff_debug_swap
* const debug_swap
=
1004 &ecoff_backend (abfd
)->debug_swap
;
1005 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1006 unsigned int ifd
= rndx
->rfd
;
1007 unsigned int indx
= rndx
->index
;
1013 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1014 struct return type of a procedure compiled without -g. */
1015 if (ifd
== 0xffffffff
1016 || (rndx
->rfd
== 0xfff && indx
== 0))
1017 name
= "<undefined>";
1018 else if (indx
== indexNil
)
1024 if (debug_info
->external_rfd
== NULL
)
1025 fdr
= debug_info
->fdr
+ ifd
;
1030 (*debug_swap
->swap_rfd_in
) (abfd
,
1031 ((char *) debug_info
->external_rfd
1032 + ((fdr
->rfdBase
+ ifd
)
1033 * debug_swap
->external_rfd_size
)),
1035 fdr
= debug_info
->fdr
+ rfd
;
1038 indx
+= fdr
->isymBase
;
1040 (*debug_swap
->swap_sym_in
) (abfd
,
1041 ((char *) debug_info
->external_sym
1042 + indx
* debug_swap
->external_sym_size
),
1045 name
= debug_info
->ss
+ fdr
->issBase
+ sym
.iss
;
1049 "%s %s { ifd = %u, index = %lu }",
1051 ((unsigned long) indx
1052 + debug_info
->symbolic_header
.iextMax
));
1055 /* Convert the type information to string format. */
1058 ecoff_type_to_string (bfd
*abfd
, FDR
*fdr
, unsigned int indx
, char *buff
)
1060 union aux_ext
*aux_ptr
;
1070 unsigned int basic_type
;
1077 aux_ptr
= ecoff_data (abfd
)->debug_info
.external_aux
+ fdr
->iauxBase
;
1078 bigendian
= fdr
->fBigendian
;
1080 for (i
= 0; i
< 7; i
++)
1082 qualifiers
[i
].low_bound
= 0;
1083 qualifiers
[i
].high_bound
= 0;
1084 qualifiers
[i
].stride
= 0;
1087 if (AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
]) == (bfd_vma
) -1)
1088 return "-1 (no type)";
1089 _bfd_ecoff_swap_tir_in (bigendian
, &aux_ptr
[indx
++].a_ti
, &u
.ti
);
1091 basic_type
= u
.ti
.bt
;
1092 qualifiers
[0].type
= u
.ti
.tq0
;
1093 qualifiers
[1].type
= u
.ti
.tq1
;
1094 qualifiers
[2].type
= u
.ti
.tq2
;
1095 qualifiers
[3].type
= u
.ti
.tq3
;
1096 qualifiers
[4].type
= u
.ti
.tq4
;
1097 qualifiers
[5].type
= u
.ti
.tq5
;
1098 qualifiers
[6].type
= tqNil
;
1100 /* Go get the basic type. */
1103 case btNil
: /* Undefined. */
1107 case btAdr
: /* Address - integer same size as pointer. */
1108 strcpy (p1
, "address");
1111 case btChar
: /* Character. */
1112 strcpy (p1
, "char");
1115 case btUChar
: /* Unsigned character. */
1116 strcpy (p1
, "unsigned char");
1119 case btShort
: /* Short. */
1120 strcpy (p1
, "short");
1123 case btUShort
: /* Unsigned short. */
1124 strcpy (p1
, "unsigned short");
1127 case btInt
: /* Int. */
1131 case btUInt
: /* Unsigned int. */
1132 strcpy (p1
, "unsigned int");
1135 case btLong
: /* Long. */
1136 strcpy (p1
, "long");
1139 case btULong
: /* Unsigned long. */
1140 strcpy (p1
, "unsigned long");
1143 case btFloat
: /* Float (real). */
1144 strcpy (p1
, "float");
1147 case btDouble
: /* Double (real). */
1148 strcpy (p1
, "double");
1151 /* Structures add 1-2 aux words:
1152 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1153 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1155 case btStruct
: /* Structure (Record). */
1156 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1157 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1158 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1160 indx
++; /* Skip aux words. */
1163 /* Unions add 1-2 aux words:
1164 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1165 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1167 case btUnion
: /* Union. */
1168 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1169 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1170 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1172 indx
++; /* Skip aux words. */
1175 /* Enumerations add 1-2 aux words:
1176 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1177 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1179 case btEnum
: /* Enumeration. */
1180 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1181 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1182 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1184 indx
++; /* Skip aux words. */
1187 case btTypedef
: /* Defined via a typedef, isymRef points. */
1188 strcpy (p1
, "typedef");
1191 case btRange
: /* Subrange of int. */
1192 strcpy (p1
, "subrange");
1195 case btSet
: /* Pascal sets. */
1199 case btComplex
: /* Fortran complex. */
1200 strcpy (p1
, "complex");
1203 case btDComplex
: /* Fortran double complex. */
1204 strcpy (p1
, "double complex");
1207 case btIndirect
: /* Forward or unnamed typedef. */
1208 strcpy (p1
, "forward/unamed typedef");
1211 case btFixedDec
: /* Fixed Decimal. */
1212 strcpy (p1
, "fixed decimal");
1215 case btFloatDec
: /* Float Decimal. */
1216 strcpy (p1
, "float decimal");
1219 case btString
: /* Varying Length Character String. */
1220 strcpy (p1
, "string");
1223 case btBit
: /* Aligned Bit String. */
1227 case btPicture
: /* Picture. */
1228 strcpy (p1
, "picture");
1231 case btVoid
: /* Void. */
1232 strcpy (p1
, "void");
1236 sprintf (p1
, _("unknown basic type %d"), (int) basic_type
);
1242 /* If this is a bitfield, get the bitsize. */
1247 bitsize
= AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
++]);
1248 sprintf (p1
, " : %d", bitsize
);
1251 /* Deal with any qualifiers. */
1252 if (qualifiers
[0].type
!= tqNil
)
1254 /* Snarf up any array bounds in the correct order. Arrays
1255 store 5 successive words in the aux. table:
1256 word 0 RNDXR to type of the bounds (ie, int)
1257 word 1 Current file descriptor index
1259 word 3 high bound (or -1 if [])
1260 word 4 stride size in bits. */
1261 for (i
= 0; i
< 7; i
++)
1263 if (qualifiers
[i
].type
== tqArray
)
1265 qualifiers
[i
].low_bound
=
1266 AUX_GET_DNLOW (bigendian
, &aux_ptr
[indx
+2]);
1267 qualifiers
[i
].high_bound
=
1268 AUX_GET_DNHIGH (bigendian
, &aux_ptr
[indx
+3]);
1269 qualifiers
[i
].stride
=
1270 AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
+4]);
1275 /* Now print out the qualifiers. */
1276 for (i
= 0; i
< 6; i
++)
1278 switch (qualifiers
[i
].type
)
1285 strcpy (p2
, "ptr to ");
1286 p2
+= sizeof ("ptr to ")-1;
1290 strcpy (p2
, "volatile ");
1291 p2
+= sizeof ("volatile ")-1;
1295 strcpy (p2
, "far ");
1296 p2
+= sizeof ("far ")-1;
1300 strcpy (p2
, "func. ret. ");
1301 p2
+= sizeof ("func. ret. ");
1306 int first_array
= i
;
1309 /* Print array bounds reversed (ie, in the order the C
1310 programmer writes them). C is such a fun language.... */
1311 while (i
< 5 && qualifiers
[i
+1].type
== tqArray
)
1314 for (j
= i
; j
>= first_array
; j
--)
1316 strcpy (p2
, "array [");
1317 p2
+= sizeof ("array [")-1;
1318 if (qualifiers
[j
].low_bound
!= 0)
1320 "%ld:%ld {%ld bits}",
1321 (long) qualifiers
[j
].low_bound
,
1322 (long) qualifiers
[j
].high_bound
,
1323 (long) qualifiers
[j
].stride
);
1325 else if (qualifiers
[j
].high_bound
!= -1)
1328 (long) (qualifiers
[j
].high_bound
+ 1),
1329 (long) (qualifiers
[j
].stride
));
1332 sprintf (p2
, " {%ld bits}", (long) qualifiers
[j
].stride
);
1335 strcpy (p2
, "] of ");
1336 p2
+= sizeof ("] of ")-1;
1344 strcpy (p2
, buffer1
);
1348 /* Return information about ECOFF symbol SYMBOL in RET. */
1351 _bfd_ecoff_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
1355 bfd_symbol_info (symbol
, ret
);
1358 /* Return whether this is a local label. */
1361 _bfd_ecoff_bfd_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1364 return name
[0] == '$';
1367 /* Print information about an ECOFF symbol. */
1370 _bfd_ecoff_print_symbol (bfd
*abfd
,
1373 bfd_print_symbol_type how
)
1375 const struct ecoff_debug_swap
* const debug_swap
1376 = &ecoff_backend (abfd
)->debug_swap
;
1377 FILE *file
= (FILE *)filep
;
1381 case bfd_print_symbol_name
:
1382 fprintf (file
, "%s", symbol
->name
);
1384 case bfd_print_symbol_more
:
1385 if (ecoffsymbol (symbol
)->local
)
1389 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1391 fprintf (file
, "ecoff local ");
1392 fprintf_vma (file
, (bfd_vma
) ecoff_sym
.value
);
1393 fprintf (file
, " %x %x", (unsigned) ecoff_sym
.st
,
1394 (unsigned) ecoff_sym
.sc
);
1400 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1402 fprintf (file
, "ecoff extern ");
1403 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1404 fprintf (file
, " %x %x", (unsigned) ecoff_ext
.asym
.st
,
1405 (unsigned) ecoff_ext
.asym
.sc
);
1408 case bfd_print_symbol_all
:
1409 /* Print out the symbols in a reasonable way. */
1418 if (ecoffsymbol (symbol
)->local
)
1420 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1423 pos
= ((((char *) ecoffsymbol (symbol
)->native
1424 - (char *) ecoff_data (abfd
)->debug_info
.external_sym
)
1425 / debug_swap
->external_sym_size
)
1426 + ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
);
1433 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1436 pos
= (((char *) ecoffsymbol (symbol
)->native
1437 - (char *) ecoff_data (abfd
)->debug_info
.external_ext
)
1438 / debug_swap
->external_ext_size
);
1439 jmptbl
= ecoff_ext
.jmptbl
? 'j' : ' ';
1440 cobol_main
= ecoff_ext
.cobol_main
? 'c' : ' ';
1441 weakext
= ecoff_ext
.weakext
? 'w' : ' ';
1444 fprintf (file
, "[%3d] %c ",
1446 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1447 fprintf (file
, " st %x sc %x indx %x %c%c%c %s",
1448 (unsigned) ecoff_ext
.asym
.st
,
1449 (unsigned) ecoff_ext
.asym
.sc
,
1450 (unsigned) ecoff_ext
.asym
.index
,
1451 jmptbl
, cobol_main
, weakext
,
1454 if (ecoffsymbol (symbol
)->fdr
!= NULL
1455 && ecoff_ext
.asym
.index
!= indexNil
)
1460 bfd_size_type sym_base
;
1461 union aux_ext
*aux_base
;
1463 fdr
= ecoffsymbol (symbol
)->fdr
;
1464 indx
= ecoff_ext
.asym
.index
;
1466 /* sym_base is used to map the fdr relative indices which
1467 appear in the file to the position number which we are
1469 sym_base
= fdr
->isymBase
;
1470 if (ecoffsymbol (symbol
)->local
)
1472 ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
1474 /* aux_base is the start of the aux entries for this file;
1475 asym.index is an offset from this. */
1476 aux_base
= (ecoff_data (abfd
)->debug_info
.external_aux
1479 /* The aux entries are stored in host byte order; the
1480 order is indicated by a bit in the fdr. */
1481 bigendian
= fdr
->fBigendian
;
1483 /* This switch is basically from gcc/mips-tdump.c. */
1484 switch (ecoff_ext
.asym
.st
)
1492 fprintf (file
, _("\n End+1 symbol: %ld"),
1493 (long) (indx
+ sym_base
));
1497 if (ecoff_ext
.asym
.sc
== scText
1498 || ecoff_ext
.asym
.sc
== scInfo
)
1499 fprintf (file
, _("\n First symbol: %ld"),
1500 (long) (indx
+ sym_base
));
1502 fprintf (file
, _("\n First symbol: %ld"),
1504 (AUX_GET_ISYM (bigendian
,
1505 &aux_base
[ecoff_ext
.asym
.index
])
1511 if (ECOFF_IS_STAB (&ecoff_ext
.asym
))
1513 else if (ecoffsymbol (symbol
)->local
)
1516 /* xgettext:c-format */
1517 fprintf (file
, _("\n End+1 symbol: %-7ld Type: %s"),
1519 (AUX_GET_ISYM (bigendian
,
1520 &aux_base
[ecoff_ext
.asym
.index
])
1522 ecoff_type_to_string (abfd
, fdr
, indx
+ 1, buff
));
1525 fprintf (file
, _("\n Local symbol: %ld"),
1528 + (ecoff_data (abfd
)
1529 ->debug_info
.symbolic_header
.iextMax
)));
1533 fprintf (file
, _("\n struct; End+1 symbol: %ld"),
1534 (long) (indx
+ sym_base
));
1538 fprintf (file
, _("\n union; End+1 symbol: %ld"),
1539 (long) (indx
+ sym_base
));
1543 fprintf (file
, _("\n enum; End+1 symbol: %ld"),
1544 (long) (indx
+ sym_base
));
1548 if (! ECOFF_IS_STAB (&ecoff_ext
.asym
))
1551 fprintf (file
, _("\n Type: %s"),
1552 ecoff_type_to_string (abfd
, fdr
, indx
, buff
));
1562 /* Read in the relocs for a section. */
1565 ecoff_slurp_reloc_table (bfd
*abfd
,
1569 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1570 arelent
*internal_relocs
;
1571 bfd_size_type external_reloc_size
;
1573 bfd_byte
*external_relocs
;
1577 if (section
->relocation
!= NULL
1578 || section
->reloc_count
== 0
1579 || (section
->flags
& SEC_CONSTRUCTOR
) != 0)
1582 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1585 external_reloc_size
= backend
->external_reloc_size
;
1586 amt
= external_reloc_size
* section
->reloc_count
;
1587 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1589 external_relocs
= _bfd_malloc_and_read (abfd
, amt
, amt
);
1590 if (external_relocs
== NULL
)
1593 amt
= section
->reloc_count
;
1594 amt
*= sizeof (arelent
);
1595 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
1596 if (internal_relocs
== NULL
)
1598 free (external_relocs
);
1602 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1604 struct internal_reloc intern
;
1606 (*backend
->swap_reloc_in
) (abfd
,
1607 external_relocs
+ i
* external_reloc_size
,
1610 if (intern
.r_extern
)
1612 /* r_symndx is an index into the external symbols. */
1613 BFD_ASSERT (intern
.r_symndx
>= 0
1615 < (ecoff_data (abfd
)
1616 ->debug_info
.symbolic_header
.iextMax
)));
1617 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1620 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1621 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1623 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1628 const char *sec_name
;
1631 /* r_symndx is a section key. */
1632 switch (intern
.r_symndx
)
1634 case RELOC_SECTION_TEXT
: sec_name
= _TEXT
; break;
1635 case RELOC_SECTION_RDATA
: sec_name
= _RDATA
; break;
1636 case RELOC_SECTION_DATA
: sec_name
= _DATA
; break;
1637 case RELOC_SECTION_SDATA
: sec_name
= _SDATA
; break;
1638 case RELOC_SECTION_SBSS
: sec_name
= _SBSS
; break;
1639 case RELOC_SECTION_BSS
: sec_name
= _BSS
; break;
1640 case RELOC_SECTION_INIT
: sec_name
= _INIT
; break;
1641 case RELOC_SECTION_LIT8
: sec_name
= _LIT8
; break;
1642 case RELOC_SECTION_LIT4
: sec_name
= _LIT4
; break;
1643 case RELOC_SECTION_XDATA
: sec_name
= _XDATA
; break;
1644 case RELOC_SECTION_PDATA
: sec_name
= _PDATA
; break;
1645 case RELOC_SECTION_FINI
: sec_name
= _FINI
; break;
1646 case RELOC_SECTION_LITA
: sec_name
= _LITA
; break;
1647 case RELOC_SECTION_RCONST
: sec_name
= _RCONST
; break;
1651 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1654 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1656 rptr
->addend
= - bfd_section_vma (sec
);
1659 rptr
->address
= intern
.r_vaddr
- bfd_section_vma (section
);
1661 /* Let the backend select the howto field and do any other
1662 required processing. */
1663 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1666 free (external_relocs
);
1668 section
->relocation
= internal_relocs
;
1673 /* Get a canonical list of relocs. */
1676 _bfd_ecoff_canonicalize_reloc (bfd
*abfd
,
1683 if (section
->flags
& SEC_CONSTRUCTOR
)
1685 arelent_chain
*chain
;
1687 /* This section has relocs made up by us, not the file, so take
1688 them out of their chain and place them into the data area
1690 for (count
= 0, chain
= section
->constructor_chain
;
1691 count
< section
->reloc_count
;
1692 count
++, chain
= chain
->next
)
1693 *relptr
++ = &chain
->relent
;
1699 if (! ecoff_slurp_reloc_table (abfd
, section
, symbols
))
1702 tblptr
= section
->relocation
;
1704 for (count
= 0; count
< section
->reloc_count
; count
++)
1705 *relptr
++ = tblptr
++;
1710 return section
->reloc_count
;
1713 /* Provided a BFD, a section and an offset into the section, calculate
1714 and return the name of the source file and the line nearest to the
1718 _bfd_ecoff_find_nearest_line (bfd
*abfd
,
1719 asymbol
**symbols ATTRIBUTE_UNUSED
,
1722 const char **filename_ptr
,
1723 const char **functionname_ptr
,
1724 unsigned int *retline_ptr
,
1725 unsigned int *discriminator_ptr
)
1727 const struct ecoff_debug_swap
* const debug_swap
1728 = &ecoff_backend (abfd
)->debug_swap
;
1729 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1730 struct ecoff_find_line
*line_info
;
1732 /* Make sure we have the FDR's. */
1733 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
, debug_info
)
1734 || bfd_get_symcount (abfd
) == 0)
1737 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1739 size_t amt
= sizeof (struct ecoff_find_line
);
1741 ecoff_data (abfd
)->find_line_info
=
1742 (struct ecoff_find_line
*) bfd_zalloc (abfd
, amt
);
1743 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1747 if (discriminator_ptr
)
1748 *discriminator_ptr
= 0;
1749 line_info
= ecoff_data (abfd
)->find_line_info
;
1750 return _bfd_ecoff_locate_line (abfd
, section
, offset
, debug_info
,
1751 debug_swap
, line_info
, filename_ptr
,
1752 functionname_ptr
, retline_ptr
);
1755 /* Copy private BFD data. This is called by objcopy and strip. We
1756 use it to copy the ECOFF debugging information from one BFD to the
1757 other. It would be theoretically possible to represent the ECOFF
1758 debugging information in the symbol table. However, it would be a
1759 lot of work, and there would be little gain (gas, gdb, and ld
1760 already access the ECOFF debugging information via the
1761 ecoff_debug_info structure, and that structure would have to be
1762 retained in order to support ECOFF debugging in MIPS ELF).
1764 The debugging information for the ECOFF external symbols comes from
1765 the symbol table, so this function only handles the other debugging
1769 _bfd_ecoff_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1771 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
1772 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
1774 asymbol
**sym_ptr_ptr
;
1778 /* We only want to copy information over if both BFD's use ECOFF
1780 if (bfd_get_flavour (ibfd
) != bfd_target_ecoff_flavour
1781 || bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
1784 /* Copy the GP value and the register masks. */
1785 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
1786 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
1787 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
1788 for (i
= 0; i
< 3; i
++)
1789 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
1791 /* Copy the version stamp. */
1792 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
1794 /* If there are no symbols, don't copy any debugging information. */
1795 c
= bfd_get_symcount (obfd
);
1796 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1797 if (c
== 0 || sym_ptr_ptr
== NULL
)
1800 /* See if there are any local symbols. */
1802 for (; c
> 0; c
--, sym_ptr_ptr
++)
1804 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
1813 /* There are some local symbols. We just bring over all the
1814 debugging information. FIXME: This is not quite the right
1815 thing to do. If the user has asked us to discard all
1816 debugging information, then we are probably going to wind up
1817 keeping it because there will probably be some local symbol
1818 which objcopy did not discard. We should actually break
1819 apart the debugging information and only keep that which
1820 applies to the symbols we want to keep. */
1821 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
1822 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
1823 oinfo
->line
= iinfo
->line
;
1825 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
1826 oinfo
->external_dnr
= iinfo
->external_dnr
;
1828 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
1829 oinfo
->external_pdr
= iinfo
->external_pdr
;
1831 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
1832 oinfo
->external_sym
= iinfo
->external_sym
;
1834 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
1835 oinfo
->external_opt
= iinfo
->external_opt
;
1837 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
1838 oinfo
->external_aux
= iinfo
->external_aux
;
1840 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
1841 oinfo
->ss
= iinfo
->ss
;
1843 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
1844 oinfo
->external_fdr
= iinfo
->external_fdr
;
1846 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
1847 oinfo
->external_rfd
= iinfo
->external_rfd
;
1851 /* We are discarding all the local symbol information. Look
1852 through the external symbols and remove all references to FDR
1853 or aux information. */
1854 c
= bfd_get_symcount (obfd
);
1855 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1856 for (; c
> 0; c
--, sym_ptr_ptr
++)
1860 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
1861 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
1863 esym
.asym
.index
= indexNil
;
1864 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
1865 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
1872 /* Set the architecture. The supported architecture is stored in the
1873 backend pointer. We always set the architecture anyhow, since many
1874 callers ignore the return value. */
1877 _bfd_ecoff_set_arch_mach (bfd
*abfd
,
1878 enum bfd_architecture arch
,
1879 unsigned long machine
)
1881 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1882 return arch
== ecoff_backend (abfd
)->arch
;
1885 /* Get the size of the section headers. */
1888 _bfd_ecoff_sizeof_headers (bfd
*abfd
,
1889 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1896 for (current
= abfd
->sections
;
1898 current
= current
->next
)
1901 ret
= (bfd_coff_filhsz (abfd
)
1902 + bfd_coff_aoutsz (abfd
)
1903 + c
* bfd_coff_scnhsz (abfd
));
1904 return (int) BFD_ALIGN (ret
, 16);
1907 /* Get the contents of a section. */
1910 _bfd_ecoff_get_section_contents (bfd
*abfd
,
1914 bfd_size_type count
)
1916 return _bfd_generic_get_section_contents (abfd
, section
, location
,
1920 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
1921 called via qsort. */
1924 ecoff_sort_hdrs (const void * arg1
, const void * arg2
)
1926 const asection
*hdr1
= *(const asection
**) arg1
;
1927 const asection
*hdr2
= *(const asection
**) arg2
;
1929 if ((hdr1
->flags
& SEC_ALLOC
) != 0)
1931 if ((hdr2
->flags
& SEC_ALLOC
) == 0)
1936 if ((hdr2
->flags
& SEC_ALLOC
) != 0)
1939 if (hdr1
->vma
< hdr2
->vma
)
1941 else if (hdr1
->vma
> hdr2
->vma
)
1947 /* Calculate the file position for each section, and set
1951 ecoff_compute_section_file_positions (bfd
*abfd
)
1953 file_ptr sofar
, file_sofar
;
1954 asection
**sorted_hdrs
;
1959 bool first_data
, first_nonalloc
;
1960 const bfd_vma round
= ecoff_backend (abfd
)->round
;
1963 sofar
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
1966 /* Sort the sections by VMA. */
1967 amt
= abfd
->section_count
;
1968 amt
*= sizeof (asection
*);
1969 sorted_hdrs
= (asection
**) bfd_malloc (amt
);
1970 if (sorted_hdrs
== NULL
)
1972 for (current
= abfd
->sections
, i
= 0;
1974 current
= current
->next
, i
++)
1975 sorted_hdrs
[i
] = current
;
1976 BFD_ASSERT (i
== abfd
->section_count
);
1978 qsort (sorted_hdrs
, abfd
->section_count
, sizeof (asection
*),
1981 /* Some versions of the OSF linker put the .rdata section in the
1982 text segment, and some do not. */
1983 rdata_in_text
= ecoff_backend (abfd
)->rdata_in_text
;
1986 for (i
= 0; i
< abfd
->section_count
; i
++)
1988 current
= sorted_hdrs
[i
];
1989 if (streq (current
->name
, _RDATA
))
1991 if ((current
->flags
& SEC_CODE
) == 0
1992 && ! streq (current
->name
, _PDATA
)
1993 && ! streq (current
->name
, _RCONST
))
1995 rdata_in_text
= false;
2000 ecoff_data (abfd
)->rdata_in_text
= rdata_in_text
;
2003 first_nonalloc
= true;
2004 for (i
= 0; i
< abfd
->section_count
; i
++)
2006 unsigned int alignment_power
;
2008 current
= sorted_hdrs
[i
];
2010 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2011 supposed to indicate the number of .pdata entries that are
2012 really in the section. Each entry is 8 bytes. We store this
2013 away in line_filepos before increasing the section size. */
2014 if (streq (current
->name
, _PDATA
))
2015 current
->line_filepos
= current
->size
/ 8;
2017 alignment_power
= current
->alignment_power
;
2019 /* On Ultrix, the data sections in an executable file must be
2020 aligned to a page boundary within the file. This does not
2021 affect the section size, though. FIXME: Does this work for
2022 other platforms? It requires some modification for the
2023 Alpha, because .rdata on the Alpha goes with the text, not
2025 if ((abfd
->flags
& EXEC_P
) != 0
2026 && (abfd
->flags
& D_PAGED
) != 0
2028 && (current
->flags
& SEC_CODE
) == 0
2030 || ! streq (current
->name
, _RDATA
))
2031 && ! streq (current
->name
, _PDATA
)
2032 && ! streq (current
->name
, _RCONST
))
2034 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2035 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2038 else if (streq (current
->name
, _LIB
))
2040 /* On Irix 4, the location of contents of the .lib section
2041 from a shared library section is also rounded up to a
2044 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2045 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2047 else if (first_nonalloc
2048 && (current
->flags
& SEC_ALLOC
) == 0
2049 && (abfd
->flags
& D_PAGED
) != 0)
2051 /* Skip up to the next page for an unallocated section, such
2052 as the .comment section on the Alpha. This leaves room
2053 for the .bss section. */
2054 first_nonalloc
= false;
2055 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2056 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2059 /* Align the sections in the file to the same boundary on
2060 which they are aligned in virtual memory. */
2061 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2062 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2063 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2065 if ((abfd
->flags
& D_PAGED
) != 0
2066 && (current
->flags
& SEC_ALLOC
) != 0)
2068 sofar
+= (current
->vma
- sofar
) % round
;
2069 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2070 file_sofar
+= (current
->vma
- file_sofar
) % round
;
2073 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) != 0)
2074 current
->filepos
= file_sofar
;
2076 sofar
+= current
->size
;
2077 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2078 file_sofar
+= current
->size
;
2080 /* Make sure that this section is of the right size too. */
2082 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2083 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2084 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2085 current
->size
+= sofar
- old_sofar
;
2091 ecoff_data (abfd
)->reloc_filepos
= file_sofar
;
2096 /* Determine the location of the relocs for all the sections in the
2097 output file, as well as the location of the symbolic debugging
2100 static bfd_size_type
2101 ecoff_compute_reloc_file_positions (bfd
*abfd
)
2103 const bfd_size_type external_reloc_size
=
2104 ecoff_backend (abfd
)->external_reloc_size
;
2105 file_ptr reloc_base
;
2106 bfd_size_type reloc_size
;
2110 if (! abfd
->output_has_begun
)
2112 if (! ecoff_compute_section_file_positions (abfd
))
2114 abfd
->output_has_begun
= true;
2117 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2120 for (current
= abfd
->sections
;
2122 current
= current
->next
)
2124 if (current
->reloc_count
== 0)
2125 current
->rel_filepos
= 0;
2128 bfd_size_type relsize
;
2130 current
->rel_filepos
= reloc_base
;
2131 relsize
= current
->reloc_count
* external_reloc_size
;
2132 reloc_size
+= relsize
;
2133 reloc_base
+= relsize
;
2137 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2139 /* At least on Ultrix, the symbol table of an executable file must
2140 be aligned to a page boundary. FIXME: Is this true on other
2142 if ((abfd
->flags
& EXEC_P
) != 0
2143 && (abfd
->flags
& D_PAGED
) != 0)
2144 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2145 &~ (ecoff_backend (abfd
)->round
- 1));
2147 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2152 /* Set the contents of a section. */
2155 _bfd_ecoff_set_section_contents (bfd
*abfd
,
2157 const void * location
,
2159 bfd_size_type count
)
2163 /* This must be done first, because bfd_set_section_contents is
2164 going to set output_has_begun to TRUE. */
2165 if (! abfd
->output_has_begun
2166 && ! ecoff_compute_section_file_positions (abfd
))
2169 /* Handle the .lib section specially so that Irix 4 shared libraries
2170 work out. See coff_set_section_contents in coffcode.h. */
2171 if (streq (section
->name
, _LIB
))
2173 bfd_byte
*rec
, *recend
;
2175 rec
= (bfd_byte
*) location
;
2176 recend
= rec
+ count
;
2177 while (rec
< recend
)
2180 rec
+= bfd_get_32 (abfd
, rec
) * 4;
2183 BFD_ASSERT (rec
== recend
);
2189 pos
= section
->filepos
+ offset
;
2190 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2191 || bfd_bwrite (location
, count
, abfd
) != count
)
2197 /* Set the GP value for an ECOFF file. This is a hook used by the
2201 bfd_ecoff_set_gp_value (bfd
*abfd
, bfd_vma gp_value
)
2203 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2204 || bfd_get_format (abfd
) != bfd_object
)
2206 bfd_set_error (bfd_error_invalid_operation
);
2210 ecoff_data (abfd
)->gp
= gp_value
;
2215 /* Set the register masks for an ECOFF file. This is a hook used by
2219 bfd_ecoff_set_regmasks (bfd
*abfd
,
2220 unsigned long gprmask
,
2221 unsigned long fprmask
,
2222 unsigned long *cprmask
)
2224 ecoff_data_type
*tdata
;
2226 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2227 || bfd_get_format (abfd
) != bfd_object
)
2229 bfd_set_error (bfd_error_invalid_operation
);
2233 tdata
= ecoff_data (abfd
);
2234 tdata
->gprmask
= gprmask
;
2235 tdata
->fprmask
= fprmask
;
2236 if (cprmask
!= NULL
)
2240 for (i
= 0; i
< 3; i
++)
2241 tdata
->cprmask
[i
] = cprmask
[i
];
2247 /* Get ECOFF EXTR information for an external symbol. This function
2248 is passed to bfd_ecoff_debug_externals. */
2251 ecoff_get_extr (asymbol
*sym
, EXTR
*esym
)
2253 ecoff_symbol_type
*ecoff_sym_ptr
;
2256 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2257 || ecoffsymbol (sym
)->native
== NULL
)
2259 /* Don't include debugging, local, or section symbols. */
2260 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2261 || (sym
->flags
& BSF_LOCAL
) != 0
2262 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2266 esym
->cobol_main
= 0;
2267 esym
->weakext
= (sym
->flags
& BSF_WEAK
) != 0;
2270 /* FIXME: we can do better than this for st and sc. */
2271 esym
->asym
.st
= stGlobal
;
2272 esym
->asym
.sc
= scAbs
;
2273 esym
->asym
.reserved
= 0;
2274 esym
->asym
.index
= indexNil
;
2278 ecoff_sym_ptr
= ecoffsymbol (sym
);
2280 if (ecoff_sym_ptr
->local
)
2283 input_bfd
= bfd_asymbol_bfd (sym
);
2284 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2285 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2287 /* If the symbol was defined by the linker, then esym will be
2288 undefined but sym will not be. Get a better class for such a
2290 if ((esym
->asym
.sc
== scUndefined
2291 || esym
->asym
.sc
== scSUndefined
)
2292 && ! bfd_is_und_section (bfd_asymbol_section (sym
)))
2293 esym
->asym
.sc
= scAbs
;
2295 /* Adjust the FDR index for the symbol by that used for the input
2297 if (esym
->ifd
!= -1)
2299 struct ecoff_debug_info
*input_debug
;
2301 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2302 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2303 if (input_debug
->ifdmap
!= NULL
)
2304 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2310 /* Set the external symbol index. This routine is passed to
2311 bfd_ecoff_debug_externals. */
2314 ecoff_set_index (asymbol
*sym
, bfd_size_type indx
)
2316 ecoff_set_sym_index (sym
, indx
);
2319 /* Write out an ECOFF file. */
2322 _bfd_ecoff_write_object_contents (bfd
*abfd
)
2324 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2325 const bfd_vma round
= backend
->round
;
2326 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2327 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2328 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2329 const bfd_size_type external_hdr_size
2330 = backend
->debug_swap
.external_hdr_size
;
2331 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2332 void (* const adjust_reloc_out
) (bfd
*, const arelent
*, struct internal_reloc
*)
2333 = backend
->adjust_reloc_out
;
2334 void (* const swap_reloc_out
) (bfd
*, const struct internal_reloc
*, void *)
2335 = backend
->swap_reloc_out
;
2336 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2337 HDRR
* const symhdr
= &debug
->symbolic_header
;
2340 bfd_size_type reloc_size
;
2341 bfd_size_type text_size
;
2343 bool set_text_start
;
2344 bfd_size_type data_size
;
2346 bool set_data_start
;
2347 bfd_size_type bss_size
;
2349 void * reloc_buff
= NULL
;
2350 struct internal_filehdr internal_f
;
2351 struct internal_aouthdr internal_a
;
2354 /* Determine where the sections and relocs will go in the output
2356 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2359 for (current
= abfd
->sections
;
2361 current
= current
->next
)
2363 current
->target_index
= count
;
2367 if ((abfd
->flags
& D_PAGED
) != 0)
2368 text_size
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2372 set_text_start
= false;
2375 set_data_start
= false;
2378 /* Write section headers to the file. */
2380 /* Allocate buff big enough to hold a section header,
2381 file header, or a.out header. */
2390 buff
= bfd_malloc (siz
);
2395 internal_f
.f_nscns
= 0;
2396 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2399 for (current
= abfd
->sections
;
2401 current
= current
->next
)
2403 struct internal_scnhdr section
;
2406 ++internal_f
.f_nscns
;
2408 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2410 /* This seems to be correct for Irix 4 shared libraries. */
2411 vma
= bfd_section_vma (current
);
2412 if (streq (current
->name
, _LIB
))
2413 section
.s_vaddr
= 0;
2415 section
.s_vaddr
= vma
;
2417 section
.s_paddr
= current
->lma
;
2418 section
.s_size
= current
->size
;
2420 /* If this section is unloadable then the scnptr will be 0. */
2421 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2422 section
.s_scnptr
= 0;
2424 section
.s_scnptr
= current
->filepos
;
2425 section
.s_relptr
= current
->rel_filepos
;
2427 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2428 object file produced by the assembler is supposed to point to
2429 information about how much room is required by objects of
2430 various different sizes. I think this only matters if we
2431 want the linker to compute the best size to use, or
2432 something. I don't know what happens if the information is
2434 if (! streq (current
->name
, _PDATA
))
2435 section
.s_lnnoptr
= 0;
2438 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2439 hold the number of entries in the section (each entry is
2440 8 bytes). We stored this in the line_filepos field in
2441 ecoff_compute_section_file_positions. */
2442 section
.s_lnnoptr
= current
->line_filepos
;
2445 section
.s_nreloc
= current
->reloc_count
;
2446 section
.s_nlnno
= 0;
2447 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2450 if (bfd_coff_swap_scnhdr_out (abfd
, (void *) §ion
, buff
) == 0
2451 || bfd_bwrite (buff
, scnhsz
, abfd
) != scnhsz
)
2454 if ((section
.s_flags
& STYP_TEXT
) != 0
2455 || ((section
.s_flags
& STYP_RDATA
) != 0
2456 && ecoff_data (abfd
)->rdata_in_text
)
2457 || section
.s_flags
== STYP_PDATA
2458 || (section
.s_flags
& STYP_DYNAMIC
) != 0
2459 || (section
.s_flags
& STYP_LIBLIST
) != 0
2460 || (section
.s_flags
& STYP_RELDYN
) != 0
2461 || section
.s_flags
== STYP_CONFLIC
2462 || (section
.s_flags
& STYP_DYNSTR
) != 0
2463 || (section
.s_flags
& STYP_DYNSYM
) != 0
2464 || (section
.s_flags
& STYP_HASH
) != 0
2465 || (section
.s_flags
& STYP_ECOFF_INIT
) != 0
2466 || (section
.s_flags
& STYP_ECOFF_FINI
) != 0
2467 || section
.s_flags
== STYP_RCONST
)
2469 text_size
+= current
->size
;
2470 if (! set_text_start
|| text_start
> vma
)
2473 set_text_start
= true;
2476 else if ((section
.s_flags
& STYP_RDATA
) != 0
2477 || (section
.s_flags
& STYP_DATA
) != 0
2478 || (section
.s_flags
& STYP_LITA
) != 0
2479 || (section
.s_flags
& STYP_LIT8
) != 0
2480 || (section
.s_flags
& STYP_LIT4
) != 0
2481 || (section
.s_flags
& STYP_SDATA
) != 0
2482 || section
.s_flags
== STYP_XDATA
2483 || (section
.s_flags
& STYP_GOT
) != 0)
2485 data_size
+= current
->size
;
2486 if (! set_data_start
|| data_start
> vma
)
2489 set_data_start
= true;
2492 else if ((section
.s_flags
& STYP_BSS
) != 0
2493 || (section
.s_flags
& STYP_SBSS
) != 0)
2494 bss_size
+= current
->size
;
2495 else if (section
.s_flags
== 0
2496 || (section
.s_flags
& STYP_ECOFF_LIB
) != 0
2497 || section
.s_flags
== STYP_COMMENT
)
2503 /* Set up the file header. */
2504 internal_f
.f_magic
= ecoff_get_magic (abfd
);
2506 /* We will NOT put a fucking timestamp in the header here. Every
2507 time you put it back, I will come in and take it out again. I'm
2508 sorry. This field does not belong here. We fill it with a 0 so
2509 it compares the same but is not a reasonable time. --
2511 internal_f
.f_timdat
= 0;
2513 if (bfd_get_symcount (abfd
) != 0)
2515 /* The ECOFF f_nsyms field is not actually the number of
2516 symbols, it's the size of symbolic information header. */
2517 internal_f
.f_nsyms
= external_hdr_size
;
2518 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
2522 internal_f
.f_nsyms
= 0;
2523 internal_f
.f_symptr
= 0;
2526 internal_f
.f_opthdr
= aoutsz
;
2528 internal_f
.f_flags
= F_LNNO
;
2529 if (reloc_size
== 0)
2530 internal_f
.f_flags
|= F_RELFLG
;
2531 if (bfd_get_symcount (abfd
) == 0)
2532 internal_f
.f_flags
|= F_LSYMS
;
2533 if (abfd
->flags
& EXEC_P
)
2534 internal_f
.f_flags
|= F_EXEC
;
2536 if (bfd_little_endian (abfd
))
2537 internal_f
.f_flags
|= F_AR32WR
;
2539 internal_f
.f_flags
|= F_AR32W
;
2541 /* Set up the ``optional'' header. */
2542 if ((abfd
->flags
& D_PAGED
) != 0)
2543 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
2545 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
2547 /* FIXME: Is this really correct? */
2548 internal_a
.vstamp
= symhdr
->vstamp
;
2550 /* At least on Ultrix, these have to be rounded to page boundaries.
2551 FIXME: Is this true on other platforms? */
2552 if ((abfd
->flags
& D_PAGED
) != 0)
2554 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
2555 internal_a
.text_start
= text_start
&~ (round
- 1);
2556 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
2557 internal_a
.data_start
= data_start
&~ (round
- 1);
2561 internal_a
.tsize
= text_size
;
2562 internal_a
.text_start
= text_start
;
2563 internal_a
.dsize
= data_size
;
2564 internal_a
.data_start
= data_start
;
2567 /* On Ultrix, the initial portions of the .sbss and .bss segments
2568 are at the end of the data section. The bsize field in the
2569 optional header records how many bss bytes are required beyond
2570 those in the data section. The value is not rounded to a page
2572 if (bss_size
< internal_a
.dsize
- data_size
)
2575 bss_size
-= internal_a
.dsize
- data_size
;
2576 internal_a
.bsize
= bss_size
;
2577 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
2579 internal_a
.entry
= bfd_get_start_address (abfd
);
2581 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
2583 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
2584 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
2585 for (i
= 0; i
< 4; i
++)
2586 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
2588 /* Let the backend adjust the headers if necessary. */
2589 if (backend
->adjust_headers
)
2591 if (! (*backend
->adjust_headers
) (abfd
, &internal_f
, &internal_a
))
2595 /* Write out the file header and the optional header. */
2596 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2599 bfd_coff_swap_filehdr_out (abfd
, (void *) &internal_f
, buff
);
2600 if (bfd_bwrite (buff
, filhsz
, abfd
) != filhsz
)
2603 bfd_coff_swap_aouthdr_out (abfd
, (void *) &internal_a
, buff
);
2604 if (bfd_bwrite (buff
, aoutsz
, abfd
) != aoutsz
)
2607 /* Build the external symbol information. This must be done before
2608 writing out the relocs so that we know the symbol indices. We
2609 don't do this if this BFD was created by the backend linker,
2610 since it will have already handled the symbols and relocs. */
2611 if (! ecoff_data (abfd
)->linker
)
2613 symhdr
->iextMax
= 0;
2614 symhdr
->issExtMax
= 0;
2615 debug
->external_ext
= debug
->external_ext_end
= NULL
;
2616 debug
->ssext
= debug
->ssext_end
= NULL
;
2617 if (! bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
2618 (abfd
->flags
& EXEC_P
) == 0,
2619 ecoff_get_extr
, ecoff_set_index
))
2622 /* Write out the relocs. */
2623 for (current
= abfd
->sections
;
2625 current
= current
->next
)
2627 arelent
**reloc_ptr_ptr
;
2628 arelent
**reloc_end
;
2632 if (current
->reloc_count
== 0)
2635 amt
= current
->reloc_count
* external_reloc_size
;
2636 reloc_buff
= bfd_alloc (abfd
, amt
);
2637 if (reloc_buff
== NULL
)
2640 reloc_ptr_ptr
= current
->orelocation
;
2641 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
2642 out_ptr
= (char *) reloc_buff
;
2645 reloc_ptr_ptr
< reloc_end
;
2646 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
2650 struct internal_reloc in
;
2652 memset ((void *) &in
, 0, sizeof in
);
2654 reloc
= *reloc_ptr_ptr
;
2655 sym
= *reloc
->sym_ptr_ptr
;
2657 /* If the howto field has not been initialised then skip this reloc.
2658 This assumes that an error message has been issued elsewhere. */
2659 if (reloc
->howto
== NULL
)
2662 in
.r_vaddr
= reloc
->address
+ bfd_section_vma (current
);
2663 in
.r_type
= reloc
->howto
->type
;
2665 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2667 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2681 { _TEXT
, RELOC_SECTION_TEXT
},
2682 { _RDATA
, RELOC_SECTION_RDATA
},
2683 { _DATA
, RELOC_SECTION_DATA
},
2684 { _SDATA
, RELOC_SECTION_SDATA
},
2685 { _SBSS
, RELOC_SECTION_SBSS
},
2686 { _BSS
, RELOC_SECTION_BSS
},
2687 { _INIT
, RELOC_SECTION_INIT
},
2688 { _LIT8
, RELOC_SECTION_LIT8
},
2689 { _LIT4
, RELOC_SECTION_LIT4
},
2690 { _XDATA
, RELOC_SECTION_XDATA
},
2691 { _PDATA
, RELOC_SECTION_PDATA
},
2692 { _FINI
, RELOC_SECTION_FINI
},
2693 { _LITA
, RELOC_SECTION_LITA
},
2694 { "*ABS*", RELOC_SECTION_ABS
},
2695 { _RCONST
, RELOC_SECTION_RCONST
}
2698 name
= bfd_section_name (bfd_asymbol_section (sym
));
2700 for (j
= 0; j
< ARRAY_SIZE (section_symndx
); j
++)
2701 if (streq (name
, section_symndx
[j
].name
))
2703 in
.r_symndx
= section_symndx
[j
].r_symndx
;
2707 if (j
== ARRAY_SIZE (section_symndx
))
2712 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2714 (*swap_reloc_out
) (abfd
, &in
, (void *) out_ptr
);
2717 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2719 amt
= current
->reloc_count
* external_reloc_size
;
2720 if (bfd_bwrite (reloc_buff
, amt
, abfd
) != amt
)
2722 bfd_release (abfd
, reloc_buff
);
2726 /* Write out the symbolic debugging information. */
2727 if (bfd_get_symcount (abfd
) > 0)
2729 /* Write out the debugging information. */
2730 if (! bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2731 ecoff_data (abfd
)->sym_filepos
))
2736 /* The .bss section of a demand paged executable must receive an
2737 entire page. If there are symbols, the symbols will start on the
2738 next page. If there are no symbols, we must fill out the page by
2740 if (bfd_get_symcount (abfd
) == 0
2741 && (abfd
->flags
& EXEC_P
) != 0
2742 && (abfd
->flags
& D_PAGED
) != 0)
2746 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2749 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) == 0)
2751 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2754 if (bfd_bwrite (&c
, (bfd_size_type
) 1, abfd
) != 1)
2758 if (reloc_buff
!= NULL
)
2759 bfd_release (abfd
, reloc_buff
);
2763 if (reloc_buff
!= NULL
)
2764 bfd_release (abfd
, reloc_buff
);
2769 /* Archive handling. ECOFF uses what appears to be a unique type of
2770 archive header (armap). The byte ordering of the armap and the
2771 contents are encoded in the name of the armap itself. At least for
2772 now, we only support archives with the same byte ordering in the
2773 armap and the contents.
2775 The first four bytes in the armap are the number of symbol
2776 definitions. This is always a power of two.
2778 This is followed by the symbol definitions. Each symbol definition
2779 occupies 8 bytes. The first four bytes are the offset from the
2780 start of the armap strings to the null-terminated string naming
2781 this symbol. The second four bytes are the file offset to the
2782 archive member which defines this symbol. If the second four bytes
2783 are 0, then this is not actually a symbol definition, and it should
2786 The symbols are hashed into the armap with a closed hashing scheme.
2787 See the functions below for the details of the algorithm.
2789 After the symbol definitions comes four bytes holding the size of
2790 the string table, followed by the string table itself. */
2792 /* The name of an archive headers looks like this:
2793 __________E[BL]E[BL]_ (with a trailing space).
2794 The trailing space is changed to an X if the archive is changed to
2795 indicate that the armap is out of date.
2797 The Alpha seems to use ________64E[BL]E[BL]_. */
2799 #define ARMAP_BIG_ENDIAN 'B'
2800 #define ARMAP_LITTLE_ENDIAN 'L'
2801 #define ARMAP_MARKER 'E'
2802 #define ARMAP_START_LENGTH 10
2803 #define ARMAP_HEADER_MARKER_INDEX 10
2804 #define ARMAP_HEADER_ENDIAN_INDEX 11
2805 #define ARMAP_OBJECT_MARKER_INDEX 12
2806 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2807 #define ARMAP_END_INDEX 14
2808 #define ARMAP_END "_ "
2810 /* This is a magic number used in the hashing algorithm. */
2811 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2813 /* This returns the hash value to use for a string. It also sets
2814 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2815 is the number of entries in the hash table, and HLOG is the log
2819 ecoff_armap_hash (const char *s
,
2820 unsigned int *rehash
,
2830 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2831 hash
*= ARMAP_HASH_MAGIC
;
2832 *rehash
= (hash
& (size
- 1)) | 1;
2833 return hash
>> (32 - hlog
);
2836 /* Read in the armap. */
2839 _bfd_ecoff_slurp_armap (bfd
*abfd
)
2843 struct areltdata
*mapdata
;
2844 bfd_size_type parsed_size
, stringsize
;
2846 struct artdata
*ardata
;
2853 /* Get the name of the first element. */
2854 i
= bfd_bread ((void *) nextname
, (bfd_size_type
) 16, abfd
);
2860 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2863 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2864 standard COFF armap. We could move the ECOFF armap stuff into
2865 bfd_slurp_armap, but that seems inappropriate since no other
2866 target uses this format. Instead, we check directly for a COFF
2868 if (startswith (nextname
, "/ "))
2869 return bfd_slurp_armap (abfd
);
2871 /* See if the first element is an armap. */
2872 if (strncmp (nextname
, ecoff_backend (abfd
)->armap_start
, ARMAP_START_LENGTH
) != 0
2873 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
2874 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2875 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2876 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
2877 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2878 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2879 || strncmp (nextname
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1) != 0)
2881 abfd
->has_armap
= false;
2885 /* Make sure we have the right byte ordering. */
2886 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2887 ^ (bfd_header_big_endian (abfd
)))
2888 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2889 ^ (bfd_big_endian (abfd
))))
2891 bfd_set_error (bfd_error_wrong_format
);
2895 /* Read in the armap. */
2896 ardata
= bfd_ardata (abfd
);
2897 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
2898 if (mapdata
== NULL
)
2900 parsed_size
= mapdata
->parsed_size
;
2903 if (parsed_size
+ 1 < 9)
2905 bfd_set_error (bfd_error_malformed_archive
);
2909 raw_armap
= (char *) _bfd_alloc_and_read (abfd
, parsed_size
+ 1, parsed_size
);
2910 if (raw_armap
== NULL
)
2912 raw_armap
[parsed_size
] = 0;
2914 ardata
->tdata
= (void *) raw_armap
;
2916 count
= H_GET_32 (abfd
, raw_armap
);
2917 if ((parsed_size
- 8) / 8 < count
)
2918 goto error_malformed
;
2920 ardata
->symdef_count
= 0;
2921 ardata
->cache
= NULL
;
2923 /* This code used to overlay the symdefs over the raw archive data,
2924 but that doesn't work on a 64 bit host. */
2925 stringbase
= raw_armap
+ count
* 8 + 8;
2926 stringsize
= parsed_size
- (count
* 8 + 8);
2928 #ifdef CHECK_ARMAP_HASH
2932 /* Double check that I have the hashing algorithm right by making
2933 sure that every symbol can be looked up successfully. */
2935 for (i
= 1; i
< count
; i
<<= 1)
2937 BFD_ASSERT (i
== count
);
2939 raw_ptr
= raw_armap
+ 4;
2940 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2942 unsigned int name_offset
, file_offset
;
2943 unsigned int hash
, rehash
, srch
;
2945 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2946 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2947 if (file_offset
== 0)
2949 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
2954 /* See if we can rehash to this location. */
2955 for (srch
= (hash
+ rehash
) & (count
- 1);
2956 srch
!= hash
&& srch
!= i
;
2957 srch
= (srch
+ rehash
) & (count
- 1))
2958 BFD_ASSERT (H_GET_32 (abfd
, (raw_armap
+ 8 + srch
* 8)) != 0);
2959 BFD_ASSERT (srch
== i
);
2963 #endif /* CHECK_ARMAP_HASH */
2965 raw_ptr
= raw_armap
+ 4;
2966 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2967 if (H_GET_32 (abfd
, (raw_ptr
+ 4)) != 0)
2968 ++ardata
->symdef_count
;
2970 amt
= ardata
->symdef_count
;
2971 amt
*= sizeof (carsym
);
2972 symdef_ptr
= (carsym
*) bfd_alloc (abfd
, amt
);
2976 ardata
->symdefs
= symdef_ptr
;
2978 raw_ptr
= raw_armap
+ 4;
2979 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2981 unsigned int name_offset
, file_offset
;
2983 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2984 if (file_offset
== 0)
2986 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2987 if (name_offset
> stringsize
)
2988 goto error_malformed
;
2989 symdef_ptr
->name
= stringbase
+ name_offset
;
2990 symdef_ptr
->file_offset
= file_offset
;
2994 ardata
->first_file_filepos
= bfd_tell (abfd
);
2995 /* Pad to an even boundary. */
2996 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
2997 abfd
->has_armap
= true;
3001 bfd_set_error (bfd_error_malformed_archive
);
3003 ardata
->symdef_count
= 0;
3004 ardata
->symdefs
= NULL
;
3005 ardata
->tdata
= NULL
;
3006 bfd_release (abfd
, raw_armap
);
3010 /* Write out an armap. */
3013 _bfd_ecoff_write_armap (bfd
*abfd
,
3014 unsigned int elength
,
3016 unsigned int orl_count
,
3019 unsigned int hashsize
, hashlog
;
3020 bfd_size_type symdefsize
;
3022 unsigned int stringsize
;
3023 unsigned int mapsize
;
3026 struct stat statbuf
;
3029 bfd_byte
*hashtable
;
3033 /* Ultrix appears to use as a hash table size the least power of two
3034 greater than twice the number of entries. */
3035 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3037 hashsize
= 1 << hashlog
;
3039 symdefsize
= hashsize
* 8;
3041 stringsize
= stridx
+ padit
;
3043 /* Include 8 bytes to store symdefsize and stringsize in output. */
3044 mapsize
= symdefsize
+ stringsize
+ 8;
3046 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3048 memset ((void *) &hdr
, 0, sizeof hdr
);
3050 /* Work out the ECOFF armap name. */
3051 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3052 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3053 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3054 (bfd_header_big_endian (abfd
)
3056 : ARMAP_LITTLE_ENDIAN
);
3057 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3058 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3059 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3060 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3062 /* Write the timestamp of the archive header to be just a little bit
3063 later than the timestamp of the file, otherwise the linker will
3064 complain that the index is out of date. Actually, the Ultrix
3065 linker just checks the archive name; the GNU linker may check the
3067 stat (bfd_get_filename (abfd
), &statbuf
);
3068 _bfd_ar_spacepad (hdr
.ar_date
, sizeof (hdr
.ar_date
), "%ld",
3069 (long) (statbuf
.st_mtime
+ 60));
3071 /* The DECstation uses zeroes for the uid, gid and mode of the
3073 hdr
.ar_uid
[0] = '0';
3074 hdr
.ar_gid
[0] = '0';
3075 /* Building gcc ends up extracting the armap as a file - twice. */
3076 hdr
.ar_mode
[0] = '6';
3077 hdr
.ar_mode
[1] = '4';
3078 hdr
.ar_mode
[2] = '4';
3080 _bfd_ar_spacepad (hdr
.ar_size
, sizeof (hdr
.ar_size
), "%-10ld", mapsize
);
3082 hdr
.ar_fmag
[0] = '`';
3083 hdr
.ar_fmag
[1] = '\012';
3085 /* Turn all null bytes in the header into spaces. */
3086 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3087 if (((char *) (&hdr
))[i
] == '\0')
3088 (((char *) (&hdr
))[i
]) = ' ';
3090 if (bfd_bwrite ((void *) &hdr
, (bfd_size_type
) sizeof (struct ar_hdr
), abfd
)
3091 != sizeof (struct ar_hdr
))
3094 H_PUT_32 (abfd
, hashsize
, temp
);
3095 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3098 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3102 current
= abfd
->archive_head
;
3104 for (i
= 0; i
< orl_count
; i
++)
3106 unsigned int hash
, rehash
= 0;
3108 /* Advance firstreal to the file position of this archive
3110 if (map
[i
].u
.abfd
!= last_elt
)
3114 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3115 firstreal
+= firstreal
% 2;
3116 current
= current
->archive_next
;
3118 while (current
!= map
[i
].u
.abfd
);
3123 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3124 if (H_GET_32 (abfd
, (hashtable
+ (hash
* 8) + 4)) != 0)
3128 /* The desired slot is already taken. */
3129 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3131 srch
= (srch
+ rehash
) & (hashsize
- 1))
3132 if (H_GET_32 (abfd
, (hashtable
+ (srch
* 8) + 4)) == 0)
3135 BFD_ASSERT (srch
!= hash
);
3140 H_PUT_32 (abfd
, map
[i
].namidx
, (hashtable
+ hash
* 8));
3141 H_PUT_32 (abfd
, firstreal
, (hashtable
+ hash
* 8 + 4));
3144 if (bfd_bwrite ((void *) hashtable
, symdefsize
, abfd
) != symdefsize
)
3147 bfd_release (abfd
, hashtable
);
3149 /* Now write the strings. */
3150 H_PUT_32 (abfd
, stringsize
, temp
);
3151 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3153 for (i
= 0; i
< orl_count
; i
++)
3157 len
= strlen (*map
[i
].name
) + 1;
3158 if (bfd_bwrite ((void *) (*map
[i
].name
), len
, abfd
) != len
)
3162 /* The spec sez this should be a newline. But in order to be
3163 bug-compatible for DECstation ar we use a null. */
3166 if (bfd_bwrite ("", (bfd_size_type
) 1, abfd
) != 1)
3173 /* ECOFF linker code. */
3175 /* Routine to create an entry in an ECOFF link hash table. */
3177 static struct bfd_hash_entry
*
3178 ecoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
3179 struct bfd_hash_table
*table
,
3182 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3184 /* Allocate the structure if it has not already been allocated by a
3187 ret
= ((struct ecoff_link_hash_entry
*)
3188 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3192 /* Call the allocation method of the superclass. */
3193 ret
= ((struct ecoff_link_hash_entry
*)
3194 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3199 /* Set local fields. */
3205 memset ((void *) &ret
->esym
, 0, sizeof ret
->esym
);
3207 return (struct bfd_hash_entry
*) ret
;
3210 /* Create an ECOFF link hash table. */
3212 struct bfd_link_hash_table
*
3213 _bfd_ecoff_bfd_link_hash_table_create (bfd
*abfd
)
3215 struct ecoff_link_hash_table
*ret
;
3216 size_t amt
= sizeof (struct ecoff_link_hash_table
);
3218 ret
= (struct ecoff_link_hash_table
*) bfd_malloc (amt
);
3221 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
,
3222 ecoff_link_hash_newfunc
,
3223 sizeof (struct ecoff_link_hash_entry
)))
3231 /* Look up an entry in an ECOFF link hash table. */
3233 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3234 ((struct ecoff_link_hash_entry *) \
3235 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3237 /* Get the ECOFF link hash table from the info structure. This is
3240 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3242 /* Add the external symbols of an object file to the global linker
3243 hash table. The external symbols and strings we are passed are
3244 just allocated on the stack, and will be discarded. We must
3245 explicitly save any information we may need later on in the link.
3246 We do not want to read the external symbol information again. */
3249 ecoff_link_add_externals (bfd
*abfd
,
3250 struct bfd_link_info
*info
,
3251 void * external_ext
,
3254 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3255 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3256 = backend
->debug_swap
.swap_ext_in
;
3257 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3258 unsigned long ext_count
;
3259 struct bfd_link_hash_entry
**sym_hash
;
3264 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3267 amt
*= sizeof (struct bfd_link_hash_entry
*);
3268 sym_hash
= (struct bfd_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3271 ecoff_data (abfd
)->sym_hashes
= (struct ecoff_link_hash_entry
**) sym_hash
;
3273 ext_ptr
= (char *) external_ext
;
3274 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3275 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3282 struct ecoff_link_hash_entry
*h
;
3286 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3288 /* Skip debugging symbols. */
3290 switch (esym
.asym
.st
)
3306 /* Get the information for this symbol. */
3307 value
= esym
.asym
.value
;
3308 switch (esym
.asym
.sc
)
3328 section
= bfd_make_section_old_way (abfd
, _TEXT
);
3329 value
-= section
->vma
;
3332 section
= bfd_make_section_old_way (abfd
, _DATA
);
3333 value
-= section
->vma
;
3336 section
= bfd_make_section_old_way (abfd
, _BSS
);
3337 value
-= section
->vma
;
3340 section
= bfd_abs_section_ptr
;
3343 section
= bfd_und_section_ptr
;
3346 section
= bfd_make_section_old_way (abfd
, _SDATA
);
3347 value
-= section
->vma
;
3350 section
= bfd_make_section_old_way (abfd
, _SBSS
);
3351 value
-= section
->vma
;
3354 section
= bfd_make_section_old_way (abfd
, _RDATA
);
3355 value
-= section
->vma
;
3358 if (value
> ecoff_data (abfd
)->gp_size
)
3360 section
= bfd_com_section_ptr
;
3365 section
= &ecoff_scom_section
;
3368 section
= bfd_und_section_ptr
;
3371 section
= bfd_make_section_old_way (abfd
, _INIT
);
3372 value
-= section
->vma
;
3375 section
= bfd_make_section_old_way (abfd
, _FINI
);
3376 value
-= section
->vma
;
3379 section
= bfd_make_section_old_way (abfd
, _RCONST
);
3380 value
-= section
->vma
;
3384 if (section
== NULL
)
3387 name
= ssext
+ esym
.asym
.iss
;
3389 if (! (_bfd_generic_link_add_one_symbol
3391 (flagword
) (esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
),
3392 section
, value
, NULL
, true, true, sym_hash
)))
3395 h
= (struct ecoff_link_hash_entry
*) *sym_hash
;
3397 /* If we are building an ECOFF hash table, save the external
3398 symbol information. */
3399 if (bfd_get_flavour (info
->output_bfd
) == bfd_get_flavour (abfd
))
3402 || (! bfd_is_und_section (section
)
3403 && (! bfd_is_com_section (section
)
3404 || (h
->root
.type
!= bfd_link_hash_defined
3405 && h
->root
.type
!= bfd_link_hash_defweak
))))
3411 /* Remember whether this symbol was small undefined. */
3412 if (esym
.asym
.sc
== scSUndefined
)
3415 /* If this symbol was ever small undefined, it needs to wind
3416 up in a GP relative section. We can't control the
3417 section of a defined symbol, but we can control the
3418 section of a common symbol. This case is actually needed
3419 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3421 && h
->root
.type
== bfd_link_hash_common
3422 && streq (h
->root
.u
.c
.p
->section
->name
, SCOMMON
))
3424 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
3426 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
3427 if (h
->esym
.asym
.sc
== scCommon
)
3428 h
->esym
.asym
.sc
= scSCommon
;
3436 /* Add symbols from an ECOFF object file to the global linker hash
3440 ecoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3443 bfd_size_type external_ext_size
;
3444 void * external_ext
= NULL
;
3445 bfd_size_type esize
;
3449 if (! ecoff_slurp_symbolic_header (abfd
))
3452 /* If there are no symbols, we don't want it. */
3453 if (bfd_get_symcount (abfd
) == 0)
3456 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3458 /* Read in the external symbols and external strings. */
3459 if (bfd_seek (abfd
, symhdr
->cbExtOffset
, SEEK_SET
) != 0)
3461 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3462 esize
= symhdr
->iextMax
* external_ext_size
;
3463 external_ext
= _bfd_malloc_and_read (abfd
, esize
, esize
);
3464 if (external_ext
== NULL
&& esize
!= 0)
3467 if (bfd_seek (abfd
, symhdr
->cbSsExtOffset
, SEEK_SET
) != 0)
3469 ssext
= (char *) _bfd_malloc_and_read (abfd
, symhdr
->issExtMax
,
3471 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3474 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3477 free (external_ext
);
3482 free (external_ext
);
3486 /* This is called if we used _bfd_generic_link_add_archive_symbols
3487 because we were not dealing with an ECOFF archive. */
3490 ecoff_link_check_archive_element (bfd
*abfd
,
3491 struct bfd_link_info
*info
,
3492 struct bfd_link_hash_entry
*h
,
3498 /* Unlike the generic linker, we do not pull in elements because
3499 of common symbols. */
3500 if (h
->type
!= bfd_link_hash_undefined
)
3503 /* Include this element? */
3504 if (!(*info
->callbacks
->add_archive_element
) (info
, abfd
, name
, &abfd
))
3508 return ecoff_link_add_object_symbols (abfd
, info
);
3511 /* Add the symbols from an archive file to the global hash table.
3512 This looks through the undefined symbols, looks each one up in the
3513 archive hash table, and adds any associated object file. We do not
3514 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3515 already have a hash table, so there is no reason to construct
3519 ecoff_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3521 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3522 const bfd_byte
*raw_armap
;
3523 struct bfd_link_hash_entry
**pundef
;
3524 unsigned int armap_count
;
3525 unsigned int armap_log
;
3527 const bfd_byte
*hashtable
;
3528 const char *stringbase
;
3530 if (! bfd_has_map (abfd
))
3532 /* An empty archive is a special case. */
3533 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
3535 bfd_set_error (bfd_error_no_armap
);
3539 /* If we don't have any raw data for this archive, as can happen on
3540 Irix 4.0.5F, we call the generic routine.
3541 FIXME: We should be more clever about this, since someday tdata
3542 may get to something for a generic archive. */
3543 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3544 if (raw_armap
== NULL
)
3545 return (_bfd_generic_link_add_archive_symbols
3546 (abfd
, info
, ecoff_link_check_archive_element
));
3548 armap_count
= H_GET_32 (abfd
, raw_armap
);
3551 for (i
= 1; i
< armap_count
; i
<<= 1)
3553 BFD_ASSERT (i
== armap_count
);
3555 hashtable
= raw_armap
+ 4;
3556 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3558 /* Look through the list of undefined symbols. */
3559 pundef
= &info
->hash
->undefs
;
3560 while (*pundef
!= NULL
)
3562 struct bfd_link_hash_entry
*h
;
3563 unsigned int hash
, rehash
= 0;
3564 unsigned int file_offset
;
3570 /* When a symbol is defined, it is not necessarily removed from
3572 if (h
->type
!= bfd_link_hash_undefined
3573 && h
->type
!= bfd_link_hash_common
)
3575 /* Remove this entry from the list, for general cleanliness
3576 and because we are going to look through the list again
3577 if we search any more libraries. We can't remove the
3578 entry if it is the tail, because that would lose any
3579 entries we add to the list later on. */
3580 if (*pundef
!= info
->hash
->undefs_tail
)
3581 *pundef
= (*pundef
)->u
.undef
.next
;
3583 pundef
= &(*pundef
)->u
.undef
.next
;
3587 /* Native ECOFF linkers do not pull in archive elements merely
3588 to satisfy common definitions, so neither do we. We leave
3589 them on the list, though, in case we are linking against some
3590 other object format. */
3591 if (h
->type
!= bfd_link_hash_undefined
)
3593 pundef
= &(*pundef
)->u
.undef
.next
;
3597 /* Look for this symbol in the archive hash table. */
3598 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3601 file_offset
= H_GET_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3602 if (file_offset
== 0)
3604 /* Nothing in this slot. */
3605 pundef
= &(*pundef
)->u
.undef
.next
;
3609 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (hash
* 8));
3610 if (name
[0] != h
->root
.string
[0]
3611 || ! streq (name
, h
->root
.string
))
3616 /* That was the wrong symbol. Try rehashing. */
3618 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3620 srch
= (srch
+ rehash
) & (armap_count
- 1))
3622 file_offset
= H_GET_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3623 if (file_offset
== 0)
3625 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (srch
* 8));
3626 if (name
[0] == h
->root
.string
[0]
3627 && streq (name
, h
->root
.string
))
3636 pundef
= &(*pundef
)->u
.undef
.next
;
3643 element
= (*backend
->get_elt_at_filepos
) (abfd
, (file_ptr
) file_offset
);
3644 if (element
== NULL
)
3647 if (! bfd_check_format (element
, bfd_object
))
3650 /* Unlike the generic linker, we know that this element provides
3651 a definition for an undefined symbol and we know that we want
3652 to include it. We don't need to check anything. */
3653 if (!(*info
->callbacks
3654 ->add_archive_element
) (info
, element
, name
, &element
))
3656 if (! ecoff_link_add_object_symbols (element
, info
))
3659 pundef
= &(*pundef
)->u
.undef
.next
;
3665 /* Given an ECOFF BFD, add symbols to the global hash table as
3669 _bfd_ecoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3671 switch (bfd_get_format (abfd
))
3674 return ecoff_link_add_object_symbols (abfd
, info
);
3676 return ecoff_link_add_archive_symbols (abfd
, info
);
3678 bfd_set_error (bfd_error_wrong_format
);
3684 /* ECOFF final link routines. */
3686 /* Structure used to pass information to ecoff_link_write_external. */
3691 struct bfd_link_info
*info
;
3694 /* Accumulate the debugging information for an input BFD into the
3695 output BFD. This must read in the symbolic information of the
3699 ecoff_final_link_debug_accumulate (bfd
*output_bfd
,
3701 struct bfd_link_info
*info
,
3704 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
3705 const struct ecoff_debug_swap
* const swap
=
3706 &ecoff_backend (input_bfd
)->debug_swap
;
3707 HDRR
*symhdr
= &debug
->symbolic_header
;
3710 #define READ(ptr, offset, count, size, type) \
3714 debug->ptr = NULL; \
3715 if (symhdr->count == 0) \
3717 if (_bfd_mul_overflow (size, symhdr->count, &amt)) \
3719 bfd_set_error (bfd_error_file_too_big); \
3721 goto return_something; \
3723 if (bfd_seek (input_bfd, symhdr->offset, SEEK_SET) != 0) \
3726 goto return_something; \
3728 debug->ptr = (type) _bfd_malloc_and_read (input_bfd, amt, amt); \
3729 if (debug->ptr == NULL) \
3732 goto return_something; \
3736 /* If raw_syments is not NULL, then the data was already by read by
3737 _bfd_ecoff_slurp_symbolic_info. */
3738 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3740 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
3742 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
3743 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
3744 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
3745 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
3746 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3748 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3749 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
3750 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
3754 /* We do not read the external strings or the external symbols. */
3756 ret
= (bfd_ecoff_debug_accumulate
3757 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
3758 &ecoff_backend (output_bfd
)->debug_swap
,
3759 input_bfd
, debug
, swap
, info
));
3762 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3765 free (debug
->external_dnr
);
3766 free (debug
->external_pdr
);
3767 free (debug
->external_sym
);
3768 free (debug
->external_opt
);
3769 free (debug
->external_aux
);
3771 free (debug
->external_fdr
);
3772 free (debug
->external_rfd
);
3774 /* Make sure we don't accidentally follow one of these pointers
3775 into freed memory. */
3777 debug
->external_dnr
= NULL
;
3778 debug
->external_pdr
= NULL
;
3779 debug
->external_sym
= NULL
;
3780 debug
->external_opt
= NULL
;
3781 debug
->external_aux
= NULL
;
3783 debug
->external_fdr
= NULL
;
3784 debug
->external_rfd
= NULL
;
3790 /* Relocate and write an ECOFF section into an ECOFF output file. */
3793 ecoff_indirect_link_order (bfd
*output_bfd
,
3794 struct bfd_link_info
*info
,
3795 asection
*output_section
,
3796 struct bfd_link_order
*link_order
)
3798 asection
*input_section
;
3800 bfd_byte
*contents
= NULL
;
3801 bfd_size_type external_reloc_size
;
3802 bfd_size_type external_relocs_size
;
3803 void * external_relocs
= NULL
;
3805 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
3807 input_section
= link_order
->u
.indirect
.section
;
3808 input_bfd
= input_section
->owner
;
3809 if (input_section
->size
== 0)
3812 BFD_ASSERT (input_section
->output_section
== output_section
);
3813 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
3814 BFD_ASSERT (input_section
->size
== link_order
->size
);
3816 /* Get the section contents. */
3817 if (!bfd_malloc_and_get_section (input_bfd
, input_section
, &contents
))
3820 /* Get the relocs. If we are relaxing MIPS code, they will already
3821 have been read in. Otherwise, we read them in now. */
3822 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
3823 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
3825 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0)
3827 external_relocs
= _bfd_malloc_and_read (input_bfd
, external_relocs_size
,
3828 external_relocs_size
);
3829 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
3832 /* Relocate the section contents. */
3833 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
3834 (output_bfd
, info
, input_bfd
, input_section
, contents
,
3838 /* Write out the relocated section. */
3839 if (! bfd_set_section_contents (output_bfd
,
3842 input_section
->output_offset
,
3843 input_section
->size
))
3846 /* If we are producing relocatable output, the relocs were
3847 modified, and we write them out now. We use the reloc_count
3848 field of output_section to keep track of the number of relocs we
3849 have output so far. */
3850 if (bfd_link_relocatable (info
))
3852 file_ptr pos
= (output_section
->rel_filepos
3853 + output_section
->reloc_count
* external_reloc_size
);
3854 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
3855 || (bfd_bwrite (external_relocs
, external_relocs_size
, output_bfd
)
3856 != external_relocs_size
))
3858 output_section
->reloc_count
+= input_section
->reloc_count
;
3862 free (external_relocs
);
3867 free (external_relocs
);
3871 /* Generate a reloc when linking an ECOFF file. This is a reloc
3872 requested by the linker, and does come from any input file. This
3873 is used to build constructor and destructor tables when linking
3877 ecoff_reloc_link_order (bfd
*output_bfd
,
3878 struct bfd_link_info
*info
,
3879 asection
*output_section
,
3880 struct bfd_link_order
*link_order
)
3882 enum bfd_link_order_type type
;
3886 struct internal_reloc in
;
3887 bfd_size_type external_reloc_size
;
3892 type
= link_order
->type
;
3894 addend
= link_order
->u
.reloc
.p
->addend
;
3896 /* We set up an arelent to pass to the backend adjust_reloc_out
3898 rel
.address
= link_order
->offset
;
3900 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3903 bfd_set_error (bfd_error_bad_value
);
3907 if (type
== bfd_section_reloc_link_order
)
3909 section
= link_order
->u
.reloc
.p
->u
.section
;
3910 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
3914 struct bfd_link_hash_entry
*h
;
3916 /* Treat a reloc against a defined symbol as though it were
3917 actually against the section. */
3918 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3919 link_order
->u
.reloc
.p
->u
.name
,
3920 false, false, false);
3922 && (h
->type
== bfd_link_hash_defined
3923 || h
->type
== bfd_link_hash_defweak
))
3925 type
= bfd_section_reloc_link_order
;
3926 section
= h
->u
.def
.section
->output_section
;
3927 /* It seems that we ought to add the symbol value to the
3928 addend here, but in practice it has already been added
3929 because it was passed to constructor_callback. */
3930 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
3934 /* We can't set up a reloc against a symbol correctly,
3935 because we have no asymbol structure. Currently no
3936 adjust_reloc_out routine cares. */
3937 rel
.sym_ptr_ptr
= NULL
;
3941 /* All ECOFF relocs are in-place. Put the addend into the object
3944 BFD_ASSERT (rel
.howto
->partial_inplace
);
3948 bfd_reloc_status_type rstat
;
3951 size
= bfd_get_reloc_size (rel
.howto
);
3952 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3953 if (buf
== NULL
&& size
!= 0)
3955 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
3956 (bfd_vma
) addend
, buf
);
3962 case bfd_reloc_outofrange
:
3964 case bfd_reloc_overflow
:
3965 (*info
->callbacks
->reloc_overflow
)
3967 (link_order
->type
== bfd_section_reloc_link_order
3968 ? bfd_section_name (section
)
3969 : link_order
->u
.reloc
.p
->u
.name
),
3970 rel
.howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0);
3973 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
3974 (file_ptr
) link_order
->offset
, size
);
3982 /* Move the information into an internal_reloc structure. */
3983 in
.r_vaddr
= rel
.address
+ bfd_section_vma (output_section
);
3984 in
.r_type
= rel
.howto
->type
;
3986 if (type
== bfd_symbol_reloc_link_order
)
3988 struct ecoff_link_hash_entry
*h
;
3990 h
= ((struct ecoff_link_hash_entry
*)
3991 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3992 link_order
->u
.reloc
.p
->u
.name
,
3993 false, false, true));
3996 in
.r_symndx
= h
->indx
;
3999 (*info
->callbacks
->unattached_reloc
)
4000 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
4016 { _TEXT
, RELOC_SECTION_TEXT
},
4017 { _RDATA
, RELOC_SECTION_RDATA
},
4018 { _DATA
, RELOC_SECTION_DATA
},
4019 { _SDATA
, RELOC_SECTION_SDATA
},
4020 { _SBSS
, RELOC_SECTION_SBSS
},
4021 { _BSS
, RELOC_SECTION_BSS
},
4022 { _INIT
, RELOC_SECTION_INIT
},
4023 { _LIT8
, RELOC_SECTION_LIT8
},
4024 { _LIT4
, RELOC_SECTION_LIT4
},
4025 { _XDATA
, RELOC_SECTION_XDATA
},
4026 { _PDATA
, RELOC_SECTION_PDATA
},
4027 { _FINI
, RELOC_SECTION_FINI
},
4028 { _LITA
, RELOC_SECTION_LITA
},
4029 { "*ABS*", RELOC_SECTION_ABS
},
4030 { _RCONST
, RELOC_SECTION_RCONST
}
4033 name
= bfd_section_name (section
);
4035 for (i
= 0; i
< ARRAY_SIZE (section_symndx
); i
++)
4036 if (streq (name
, section_symndx
[i
].name
))
4038 in
.r_symndx
= section_symndx
[i
].r_symndx
;
4042 if (i
== ARRAY_SIZE (section_symndx
))
4048 /* Let the BFD backend adjust the reloc. */
4049 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4051 /* Get some memory and swap out the reloc. */
4052 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4053 rbuf
= (bfd_byte
*) bfd_malloc (external_reloc_size
);
4057 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (void *) rbuf
);
4059 pos
= (output_section
->rel_filepos
4060 + output_section
->reloc_count
* external_reloc_size
);
4061 ok
= (bfd_seek (output_bfd
, pos
, SEEK_SET
) == 0
4062 && (bfd_bwrite ((void *) rbuf
, external_reloc_size
, output_bfd
)
4063 == external_reloc_size
));
4066 ++output_section
->reloc_count
;
4073 /* Put out information for an external symbol. These come only from
4077 ecoff_link_write_external (struct bfd_hash_entry
*bh
, void * data
)
4079 struct ecoff_link_hash_entry
*h
= (struct ecoff_link_hash_entry
*) bh
;
4080 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4081 bfd
*output_bfd
= einfo
->abfd
;
4084 if (h
->root
.type
== bfd_link_hash_warning
)
4086 h
= (struct ecoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4087 if (h
->root
.type
== bfd_link_hash_new
)
4091 /* We need to check if this symbol is being stripped. */
4092 if (h
->root
.type
== bfd_link_hash_undefined
4093 || h
->root
.type
== bfd_link_hash_undefweak
)
4095 else if (einfo
->info
->strip
== strip_all
4096 || (einfo
->info
->strip
== strip_some
4097 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4098 h
->root
.root
.string
,
4099 false, false) == NULL
))
4104 if (strip
|| h
->written
)
4107 if (h
->abfd
== NULL
)
4110 h
->esym
.cobol_main
= 0;
4111 h
->esym
.weakext
= 0;
4112 h
->esym
.reserved
= 0;
4113 h
->esym
.ifd
= ifdNil
;
4114 h
->esym
.asym
.value
= 0;
4115 h
->esym
.asym
.st
= stGlobal
;
4117 if (h
->root
.type
!= bfd_link_hash_defined
4118 && h
->root
.type
!= bfd_link_hash_defweak
)
4119 h
->esym
.asym
.sc
= scAbs
;
4122 asection
*output_section
;
4130 section_storage_classes
[] =
4134 { _SDATA
, scSData
},
4135 { _RDATA
, scRData
},
4140 { _PDATA
, scPData
},
4141 { _XDATA
, scXData
},
4142 { _RCONST
, scRConst
}
4145 output_section
= h
->root
.u
.def
.section
->output_section
;
4146 name
= bfd_section_name (output_section
);
4148 for (i
= 0; i
< ARRAY_SIZE (section_storage_classes
); i
++)
4149 if (streq (name
, section_storage_classes
[i
].name
))
4151 h
->esym
.asym
.sc
= section_storage_classes
[i
].sc
;
4155 if (i
== ARRAY_SIZE (section_storage_classes
))
4156 h
->esym
.asym
.sc
= scAbs
;
4159 h
->esym
.asym
.reserved
= 0;
4160 h
->esym
.asym
.index
= indexNil
;
4162 else if (h
->esym
.ifd
!= -1)
4164 struct ecoff_debug_info
*debug
;
4166 /* Adjust the FDR index for the symbol by that used for the
4168 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4169 BFD_ASSERT (h
->esym
.ifd
>= 0
4170 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4171 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4174 switch (h
->root
.type
)
4177 case bfd_link_hash_warning
:
4178 case bfd_link_hash_new
:
4180 case bfd_link_hash_undefined
:
4181 case bfd_link_hash_undefweak
:
4182 if (h
->esym
.asym
.sc
!= scUndefined
4183 && h
->esym
.asym
.sc
!= scSUndefined
)
4184 h
->esym
.asym
.sc
= scUndefined
;
4186 case bfd_link_hash_defined
:
4187 case bfd_link_hash_defweak
:
4188 if (h
->esym
.asym
.sc
== scUndefined
4189 || h
->esym
.asym
.sc
== scSUndefined
)
4190 h
->esym
.asym
.sc
= scAbs
;
4191 else if (h
->esym
.asym
.sc
== scCommon
)
4192 h
->esym
.asym
.sc
= scBss
;
4193 else if (h
->esym
.asym
.sc
== scSCommon
)
4194 h
->esym
.asym
.sc
= scSBss
;
4195 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4196 + h
->root
.u
.def
.section
->output_section
->vma
4197 + h
->root
.u
.def
.section
->output_offset
);
4199 case bfd_link_hash_common
:
4200 if (h
->esym
.asym
.sc
!= scCommon
4201 && h
->esym
.asym
.sc
!= scSCommon
)
4202 h
->esym
.asym
.sc
= scCommon
;
4203 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4205 case bfd_link_hash_indirect
:
4206 /* We ignore these symbols, since the indirected symbol is
4207 already in the hash table. */
4211 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4213 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4216 return (bfd_ecoff_debug_one_external
4217 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4218 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4222 /* ECOFF final link routine. This looks through all the input BFDs
4223 and gathers together all the debugging information, and then
4224 processes all the link order information. This may cause it to
4225 close and reopen some input BFDs; I'll see how bad this is. */
4228 _bfd_ecoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
4230 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4231 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4236 struct bfd_link_order
*p
;
4237 struct extsym_info einfo
;
4239 /* We accumulate the debugging information counts in the symbolic
4241 symhdr
= &debug
->symbolic_header
;
4243 symhdr
->ilineMax
= 0;
4247 symhdr
->isymMax
= 0;
4248 symhdr
->ioptMax
= 0;
4249 symhdr
->iauxMax
= 0;
4251 symhdr
->issExtMax
= 0;
4254 symhdr
->iextMax
= 0;
4256 /* We accumulate the debugging information itself in the debug_info
4259 debug
->external_dnr
= NULL
;
4260 debug
->external_pdr
= NULL
;
4261 debug
->external_sym
= NULL
;
4262 debug
->external_opt
= NULL
;
4263 debug
->external_aux
= NULL
;
4265 debug
->ssext
= debug
->ssext_end
= NULL
;
4266 debug
->external_fdr
= NULL
;
4267 debug
->external_rfd
= NULL
;
4268 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4270 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4274 /* Accumulate the debugging symbols from each input BFD. */
4275 for (input_bfd
= info
->input_bfds
;
4277 input_bfd
= input_bfd
->link
.next
)
4281 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4283 /* Arbitrarily set the symbolic header vstamp to the vstamp
4284 of the first object file in the link. */
4285 if (symhdr
->vstamp
== 0)
4287 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4288 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4292 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4293 debug
, &backend
->debug_swap
,
4298 /* Combine the register masks. */
4299 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4300 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4301 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4302 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4303 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4304 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4307 /* Write out the external symbols. */
4310 bfd_hash_traverse (&info
->hash
->table
, ecoff_link_write_external
, &einfo
);
4312 if (bfd_link_relocatable (info
))
4314 /* We need to make a pass over the link_orders to count up the
4315 number of relocations we will need to output, so that we know
4316 how much space they will take up. */
4317 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4320 for (p
= o
->map_head
.link_order
;
4323 if (p
->type
== bfd_indirect_link_order
)
4324 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4325 else if (p
->type
== bfd_section_reloc_link_order
4326 || p
->type
== bfd_symbol_reloc_link_order
)
4331 /* Compute the reloc and symbol file positions. */
4332 ecoff_compute_reloc_file_positions (abfd
);
4334 /* Write out the debugging information. */
4335 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4336 &backend
->debug_swap
, info
,
4337 ecoff_data (abfd
)->sym_filepos
))
4340 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4342 if (bfd_link_relocatable (info
))
4344 /* Now reset the reloc_count field of the sections in the output
4345 BFD to 0, so that we can use them to keep track of how many
4346 relocs we have output thus far. */
4347 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4351 /* Get a value for the GP register. */
4352 if (ecoff_data (abfd
)->gp
== 0)
4354 struct bfd_link_hash_entry
*h
;
4356 h
= bfd_link_hash_lookup (info
->hash
, "_gp", false, false, true);
4358 && h
->type
== bfd_link_hash_defined
)
4359 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4360 + h
->u
.def
.section
->output_section
->vma
4361 + h
->u
.def
.section
->output_offset
);
4362 else if (bfd_link_relocatable (info
))
4366 /* Make up a value. */
4368 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4371 && (streq (o
->name
, _SBSS
)
4372 || streq (o
->name
, _SDATA
)
4373 || streq (o
->name
, _LIT4
)
4374 || streq (o
->name
, _LIT8
)
4375 || streq (o
->name
, _LITA
)))
4378 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4382 /* If the relocate_section function needs to do a reloc
4383 involving the GP value, it should make a reloc_dangerous
4384 callback to warn that GP is not defined. */
4388 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4390 for (p
= o
->map_head
.link_order
;
4394 if (p
->type
== bfd_indirect_link_order
4395 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4396 == bfd_target_ecoff_flavour
))
4398 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4401 else if (p
->type
== bfd_section_reloc_link_order
4402 || p
->type
== bfd_symbol_reloc_link_order
)
4404 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4409 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4415 abfd
->symcount
= symhdr
->iextMax
+ symhdr
->isymMax
;
4417 ecoff_data (abfd
)->linker
= true;