1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright (C) 1990-2020 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)
49 #define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0)
52 /* This stuff is somewhat copied from coffcode.h. */
53 static asection bfd_debug_section
=
54 BFD_FAKE_SECTION (bfd_debug_section
, NULL
, "*DEBUG*", 0, 0);
56 /* Create an ECOFF object. */
59 _bfd_ecoff_mkobject (bfd
*abfd
)
61 size_t amt
= sizeof (ecoff_data_type
);
63 abfd
->tdata
.ecoff_obj_data
= (struct ecoff_tdata
*) bfd_zalloc (abfd
, amt
);
64 if (abfd
->tdata
.ecoff_obj_data
== NULL
)
70 /* This is a hook called by coff_real_object_p to create any backend
71 specific information. */
74 _bfd_ecoff_mkobject_hook (bfd
*abfd
, void * filehdr
, void * aouthdr
)
76 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
77 struct internal_aouthdr
*internal_a
= (struct internal_aouthdr
*) aouthdr
;
78 ecoff_data_type
*ecoff
;
80 if (! _bfd_ecoff_mkobject (abfd
))
83 ecoff
= ecoff_data (abfd
);
85 ecoff
->sym_filepos
= internal_f
->f_symptr
;
87 if (internal_a
!= NULL
)
91 ecoff
->text_start
= internal_a
->text_start
;
92 ecoff
->text_end
= internal_a
->text_start
+ internal_a
->tsize
;
93 ecoff
->gp
= internal_a
->gp_value
;
94 ecoff
->gprmask
= internal_a
->gprmask
;
95 for (i
= 0; i
< 4; i
++)
96 ecoff
->cprmask
[i
] = internal_a
->cprmask
[i
];
97 ecoff
->fprmask
= internal_a
->fprmask
;
98 if (internal_a
->magic
== ECOFF_AOUT_ZMAGIC
)
99 abfd
->flags
|= D_PAGED
;
101 abfd
->flags
&=~ D_PAGED
;
104 /* It turns out that no special action is required by the MIPS or
105 Alpha ECOFF backends. They have different information in the
106 a.out header, but we just copy it all (e.g., gprmask, cprmask and
107 fprmask) and let the swapping routines ensure that only relevant
108 information is written out. */
110 return (void *) ecoff
;
113 /* Initialize a new section. */
116 _bfd_ecoff_new_section_hook (bfd
*abfd
, asection
*section
)
126 { _TEXT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
127 { _INIT
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
128 { _FINI
, SEC_ALLOC
| SEC_CODE
| SEC_LOAD
},
129 { _DATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
},
130 { _SDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_SMALL_DATA
},
131 { _RDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
132 { _LIT8
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
| SEC_SMALL_DATA
},
133 { _LIT4
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
| SEC_SMALL_DATA
},
134 { _RCONST
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
135 { _PDATA
, SEC_ALLOC
| SEC_DATA
| SEC_LOAD
| SEC_READONLY
},
137 { _SBSS
, SEC_ALLOC
| SEC_SMALL_DATA
},
138 /* An Irix 4 shared libary. */
139 { _LIB
, SEC_COFF_SHARED_LIBRARY
}
142 section
->alignment_power
= 4;
144 for (i
= 0; i
< ARRAY_SIZE (section_flags
); i
++)
145 if (streq (section
->name
, section_flags
[i
].name
))
147 section
->flags
|= section_flags
[i
].flags
;
152 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
153 uncertain about .init on some systems and I don't know how shared
156 return _bfd_generic_new_section_hook (abfd
, section
);
160 _bfd_ecoff_set_alignment_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
161 asection
*section ATTRIBUTE_UNUSED
,
162 void *scnhdr ATTRIBUTE_UNUSED
)
166 /* Determine the machine architecture and type. This is called from
167 the generic COFF routines. It is the inverse of ecoff_get_magic,
168 below. This could be an ECOFF backend routine, with one version
169 for each target, but there aren't all that many ECOFF targets. */
172 _bfd_ecoff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
174 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
175 enum bfd_architecture arch
;
178 switch (internal_f
->f_magic
)
181 case MIPS_MAGIC_LITTLE
:
183 arch
= bfd_arch_mips
;
184 mach
= bfd_mach_mips3000
;
187 case MIPS_MAGIC_LITTLE2
:
188 case MIPS_MAGIC_BIG2
:
189 /* MIPS ISA level 2: the r6000. */
190 arch
= bfd_arch_mips
;
191 mach
= bfd_mach_mips6000
;
194 case MIPS_MAGIC_LITTLE3
:
195 case MIPS_MAGIC_BIG3
:
196 /* MIPS ISA level 3: the r4000. */
197 arch
= bfd_arch_mips
;
198 mach
= bfd_mach_mips4000
;
202 arch
= bfd_arch_alpha
;
207 arch
= bfd_arch_obscure
;
212 return bfd_default_set_arch_mach (abfd
, arch
, mach
);
216 _bfd_ecoff_no_long_sections (bfd
*abfd
, int enable
)
223 /* Get the magic number to use based on the architecture and machine.
224 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
227 ecoff_get_magic (bfd
*abfd
)
231 switch (bfd_get_arch (abfd
))
234 switch (bfd_get_mach (abfd
))
238 case bfd_mach_mips3000
:
239 big
= MIPS_MAGIC_BIG
;
240 little
= MIPS_MAGIC_LITTLE
;
243 case bfd_mach_mips6000
:
244 big
= MIPS_MAGIC_BIG2
;
245 little
= MIPS_MAGIC_LITTLE2
;
248 case bfd_mach_mips4000
:
249 big
= MIPS_MAGIC_BIG3
;
250 little
= MIPS_MAGIC_LITTLE3
;
254 return bfd_big_endian (abfd
) ? big
: little
;
265 /* Get the section s_flags to use for a section. */
268 ecoff_sec_to_styp_flags (const char *name
, flagword flags
)
278 { _TEXT
, STYP_TEXT
},
279 { _DATA
, STYP_DATA
},
280 { _SDATA
, STYP_SDATA
},
281 { _RDATA
, STYP_RDATA
},
282 { _LITA
, STYP_LITA
},
283 { _LIT8
, STYP_LIT8
},
284 { _LIT4
, STYP_LIT4
},
286 { _SBSS
, STYP_SBSS
},
287 { _INIT
, STYP_ECOFF_INIT
},
288 { _FINI
, STYP_ECOFF_FINI
},
289 { _PDATA
, STYP_PDATA
},
290 { _XDATA
, STYP_XDATA
},
291 { _LIB
, STYP_ECOFF_LIB
},
293 { _HASH
, STYP_HASH
},
294 { _DYNAMIC
, STYP_DYNAMIC
},
295 { _LIBLIST
, STYP_LIBLIST
},
296 { _RELDYN
, STYP_RELDYN
},
297 { _CONFLIC
, STYP_CONFLIC
},
298 { _DYNSTR
, STYP_DYNSTR
},
299 { _DYNSYM
, STYP_DYNSYM
},
300 { _RCONST
, STYP_RCONST
}
304 for (i
= 0; i
< ARRAY_SIZE (styp_flags
); i
++)
305 if (streq (name
, styp_flags
[i
].name
))
307 styp
= styp_flags
[i
].flags
;
313 if (streq (name
, _COMMENT
))
316 flags
&=~ SEC_NEVER_LOAD
;
318 else if (flags
& SEC_CODE
)
320 else if (flags
& SEC_DATA
)
322 else if (flags
& SEC_READONLY
)
324 else if (flags
& SEC_LOAD
)
330 if (flags
& SEC_NEVER_LOAD
)
336 /* Get the BFD flags to use for a section. */
339 _bfd_ecoff_styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
341 const char *name ATTRIBUTE_UNUSED
,
342 asection
*section ATTRIBUTE_UNUSED
,
343 flagword
* flags_ptr
)
345 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
346 long styp_flags
= internal_s
->s_flags
;
347 flagword sec_flags
= 0;
349 if (styp_flags
& STYP_NOLOAD
)
350 sec_flags
|= SEC_NEVER_LOAD
;
352 /* For 386 COFF, at least, an unloadable text or data section is
353 actually a shared library section. */
354 if ((styp_flags
& STYP_TEXT
)
355 || (styp_flags
& STYP_ECOFF_INIT
)
356 || (styp_flags
& STYP_ECOFF_FINI
)
357 || (styp_flags
& STYP_DYNAMIC
)
358 || (styp_flags
& STYP_LIBLIST
)
359 || (styp_flags
& STYP_RELDYN
)
360 || styp_flags
== STYP_CONFLIC
361 || (styp_flags
& STYP_DYNSTR
)
362 || (styp_flags
& STYP_DYNSYM
)
363 || (styp_flags
& STYP_HASH
))
365 if (sec_flags
& SEC_NEVER_LOAD
)
366 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
368 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
370 else if ((styp_flags
& STYP_DATA
)
371 || (styp_flags
& STYP_RDATA
)
372 || (styp_flags
& STYP_SDATA
)
373 || styp_flags
== STYP_PDATA
374 || styp_flags
== STYP_XDATA
375 || (styp_flags
& STYP_GOT
)
376 || styp_flags
== STYP_RCONST
)
378 if (sec_flags
& SEC_NEVER_LOAD
)
379 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
381 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
382 if ((styp_flags
& STYP_RDATA
)
383 || styp_flags
== STYP_PDATA
384 || styp_flags
== STYP_RCONST
)
385 sec_flags
|= SEC_READONLY
;
386 if (styp_flags
& STYP_SDATA
)
387 sec_flags
|= SEC_SMALL_DATA
;
389 else if (styp_flags
& STYP_SBSS
)
390 sec_flags
|= SEC_ALLOC
| SEC_SMALL_DATA
;
391 else if (styp_flags
& STYP_BSS
)
392 sec_flags
|= SEC_ALLOC
;
393 else if ((styp_flags
& STYP_INFO
) || styp_flags
== STYP_COMMENT
)
394 sec_flags
|= SEC_NEVER_LOAD
;
395 else if ((styp_flags
& STYP_LITA
)
396 || (styp_flags
& STYP_LIT8
)
397 || (styp_flags
& STYP_LIT4
))
398 sec_flags
|= SEC_DATA
|SEC_SMALL_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
399 else if (styp_flags
& STYP_ECOFF_LIB
)
400 sec_flags
|= SEC_COFF_SHARED_LIBRARY
;
402 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
404 * flags_ptr
= sec_flags
;
408 /* Read in the symbolic header for an ECOFF object file. */
411 ecoff_slurp_symbolic_header (bfd
*abfd
)
413 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
414 bfd_size_type external_hdr_size
;
416 HDRR
*internal_symhdr
;
418 /* See if we've already read it in. */
419 if (ecoff_data (abfd
)->debug_info
.symbolic_header
.magic
==
420 backend
->debug_swap
.sym_magic
)
423 /* See whether there is a symbolic header. */
424 if (ecoff_data (abfd
)->sym_filepos
== 0)
430 /* At this point bfd_get_symcount (abfd) holds the number of symbols
431 as read from the file header, but on ECOFF this is always the
432 size of the symbolic information header. It would be cleaner to
433 handle this when we first read the file in coffgen.c. */
434 external_hdr_size
= backend
->debug_swap
.external_hdr_size
;
435 if (bfd_get_symcount (abfd
) != external_hdr_size
)
437 bfd_set_error (bfd_error_bad_value
);
441 /* Read the symbolic information header. */
442 if (bfd_seek (abfd
, ecoff_data (abfd
)->sym_filepos
, SEEK_SET
) != 0)
444 raw
= _bfd_malloc_and_read (abfd
, external_hdr_size
, external_hdr_size
);
448 internal_symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
449 (*backend
->debug_swap
.swap_hdr_in
) (abfd
, raw
, internal_symhdr
);
451 if (internal_symhdr
->magic
!= backend
->debug_swap
.sym_magic
)
453 bfd_set_error (bfd_error_bad_value
);
457 /* Now we can get the correct number of symbols. */
458 abfd
->symcount
= internal_symhdr
->isymMax
+ internal_symhdr
->iextMax
;
467 /* Read in and swap the important symbolic information for an ECOFF
468 object file. This is called by gdb via the read_debug_info entry
469 point in the backend structure. */
472 _bfd_ecoff_slurp_symbolic_info (bfd
*abfd
,
473 asection
*ignore ATTRIBUTE_UNUSED
,
474 struct ecoff_debug_info
*debug
)
476 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
477 HDRR
*internal_symhdr
;
478 bfd_size_type raw_base
;
479 bfd_size_type raw_size
;
481 bfd_size_type external_fdr_size
;
485 bfd_size_type raw_end
;
486 bfd_size_type cb_end
;
490 BFD_ASSERT (debug
== &ecoff_data (abfd
)->debug_info
);
492 /* Check whether we've already gotten it, and whether there's any to
494 if (ecoff_data (abfd
)->raw_syments
!= NULL
)
496 if (ecoff_data (abfd
)->sym_filepos
== 0)
502 if (! ecoff_slurp_symbolic_header (abfd
))
505 internal_symhdr
= &debug
->symbolic_header
;
507 /* Read all the symbolic information at once. */
508 raw_base
= (ecoff_data (abfd
)->sym_filepos
509 + backend
->debug_swap
.external_hdr_size
);
511 /* Alpha ecoff makes the determination of raw_size difficult. It has
512 an undocumented debug data section between the symhdr and the first
513 documented section. And the ordering of the sections varies between
514 statically and dynamically linked executables.
515 If bfd supports SEEK_END someday, this code could be simplified. */
518 #define UPDATE_RAW_END(start, count, size) \
519 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
520 if (cb_end > raw_end) \
523 UPDATE_RAW_END (cbLineOffset
, cbLine
, sizeof (unsigned char));
524 UPDATE_RAW_END (cbDnOffset
, idnMax
, backend
->debug_swap
.external_dnr_size
);
525 UPDATE_RAW_END (cbPdOffset
, ipdMax
, backend
->debug_swap
.external_pdr_size
);
526 UPDATE_RAW_END (cbSymOffset
, isymMax
, backend
->debug_swap
.external_sym_size
);
527 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
528 optimization symtab, not the number of entries. */
529 UPDATE_RAW_END (cbOptOffset
, ioptMax
, sizeof (char));
530 UPDATE_RAW_END (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
531 UPDATE_RAW_END (cbSsOffset
, issMax
, sizeof (char));
532 UPDATE_RAW_END (cbSsExtOffset
, issExtMax
, sizeof (char));
533 UPDATE_RAW_END (cbFdOffset
, ifdMax
, backend
->debug_swap
.external_fdr_size
);
534 UPDATE_RAW_END (cbRfdOffset
, crfd
, backend
->debug_swap
.external_rfd_size
);
535 UPDATE_RAW_END (cbExtOffset
, iextMax
, backend
->debug_swap
.external_ext_size
);
537 #undef UPDATE_RAW_END
539 raw_size
= raw_end
- raw_base
;
542 ecoff_data (abfd
)->sym_filepos
= 0;
545 pos
= ecoff_data (abfd
)->sym_filepos
;
546 pos
+= backend
->debug_swap
.external_hdr_size
;
547 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
549 raw
= _bfd_alloc_and_read (abfd
, raw_size
, raw_size
);
553 ecoff_data (abfd
)->raw_syments
= raw
;
555 /* Get pointers for the numeric offsets in the HDRR structure. */
556 #define FIX(off1, off2, type) \
557 if (internal_symhdr->off1 == 0) \
558 debug->off2 = NULL; \
560 debug->off2 = (type) ((char *) raw \
561 + (internal_symhdr->off1 \
564 FIX (cbLineOffset
, line
, unsigned char *);
565 FIX (cbDnOffset
, external_dnr
, void *);
566 FIX (cbPdOffset
, external_pdr
, void *);
567 FIX (cbSymOffset
, external_sym
, void *);
568 FIX (cbOptOffset
, external_opt
, void *);
569 FIX (cbAuxOffset
, external_aux
, union aux_ext
*);
570 FIX (cbSsOffset
, ss
, char *);
571 FIX (cbSsExtOffset
, ssext
, char *);
572 FIX (cbFdOffset
, external_fdr
, void *);
573 FIX (cbRfdOffset
, external_rfd
, void *);
574 FIX (cbExtOffset
, external_ext
, void *);
577 /* I don't want to always swap all the data, because it will just
578 waste time and most programs will never look at it. The only
579 time the linker needs most of the debugging information swapped
580 is when linking big-endian and little-endian MIPS object files
581 together, which is not a common occurrence.
583 We need to look at the fdr to deal with a lot of information in
584 the symbols, so we swap them here. */
585 if (_bfd_mul_overflow ((unsigned long) internal_symhdr
->ifdMax
,
586 sizeof (struct fdr
), &amt
))
588 bfd_set_error (bfd_error_file_too_big
);
591 debug
->fdr
= (FDR
*) bfd_alloc (abfd
, amt
);
592 if (debug
->fdr
== NULL
)
594 external_fdr_size
= backend
->debug_swap
.external_fdr_size
;
595 fdr_ptr
= debug
->fdr
;
596 fraw_src
= (char *) debug
->external_fdr
;
597 /* PR 17512: file: 3372-1243-0.004. */
598 if (fraw_src
== NULL
&& internal_symhdr
->ifdMax
> 0)
600 fraw_end
= fraw_src
+ internal_symhdr
->ifdMax
* external_fdr_size
;
601 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
602 (*backend
->debug_swap
.swap_fdr_in
) (abfd
, (void *) fraw_src
, fdr_ptr
);
607 /* ECOFF symbol table routines. The ECOFF symbol table is described
608 in gcc/mips-tfile.c. */
610 /* ECOFF uses two common sections. One is the usual one, and the
611 other is for small objects. All the small objects are kept
612 together, and then referenced via the gp pointer, which yields
613 faster assembler code. This is what we use for the small common
615 static asection ecoff_scom_section
;
616 static const asymbol ecoff_scom_symbol
=
617 GLOBAL_SYM_INIT (SCOMMON
, &ecoff_scom_section
);
618 static asection ecoff_scom_section
=
619 BFD_FAKE_SECTION (ecoff_scom_section
, &ecoff_scom_symbol
,
620 SCOMMON
, 0, SEC_IS_COMMON
| SEC_SMALL_DATA
);
622 /* Create an empty symbol. */
625 _bfd_ecoff_make_empty_symbol (bfd
*abfd
)
627 ecoff_symbol_type
*new_symbol
;
628 size_t amt
= sizeof (ecoff_symbol_type
);
630 new_symbol
= (ecoff_symbol_type
*) bfd_zalloc (abfd
, amt
);
631 if (new_symbol
== NULL
)
633 new_symbol
->symbol
.section
= NULL
;
634 new_symbol
->fdr
= NULL
;
635 new_symbol
->local
= FALSE
;
636 new_symbol
->native
= NULL
;
637 new_symbol
->symbol
.the_bfd
= abfd
;
638 return &new_symbol
->symbol
;
641 /* Set the BFD flags and section for an ECOFF symbol. */
644 ecoff_set_symbol_info (bfd
*abfd
,
650 asym
->the_bfd
= abfd
;
651 asym
->value
= ecoff_sym
->value
;
652 asym
->section
= &bfd_debug_section
;
655 /* Most symbol types are just for debugging. */
656 switch (ecoff_sym
->st
)
665 if (ECOFF_IS_STAB (ecoff_sym
))
667 asym
->flags
= BSF_DEBUGGING
;
672 asym
->flags
= BSF_DEBUGGING
;
677 asym
->flags
= BSF_EXPORT
| BSF_WEAK
;
679 asym
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
682 asym
->flags
= BSF_LOCAL
;
683 /* Normally, a local stProc symbol will have a corresponding
684 external symbol. We mark the local symbol as a debugging
685 symbol, in order to prevent nm from printing both out.
686 Similarly, we mark stLabel and stabs symbols as debugging
687 symbols. In both cases, we do want to set the value
688 correctly based on the symbol class. */
689 if (ecoff_sym
->st
== stProc
690 || ecoff_sym
->st
== stLabel
691 || ECOFF_IS_STAB (ecoff_sym
))
692 asym
->flags
|= BSF_DEBUGGING
;
695 if (ecoff_sym
->st
== stProc
|| ecoff_sym
->st
== stStaticProc
)
696 asym
->flags
|= BSF_FUNCTION
;
698 switch (ecoff_sym
->sc
)
701 /* Used for compiler generated labels. Leave them in the
702 debugging section, and mark them as local. If BSF_DEBUGGING
703 is set, then nm does not display them for some reason. If no
704 flags are set then the linker whines about them. */
705 asym
->flags
= BSF_LOCAL
;
708 asym
->section
= bfd_make_section_old_way (abfd
, _TEXT
);
709 asym
->value
-= asym
->section
->vma
;
712 asym
->section
= bfd_make_section_old_way (abfd
, _DATA
);
713 asym
->value
-= asym
->section
->vma
;
716 asym
->section
= bfd_make_section_old_way (abfd
, _BSS
);
717 asym
->value
-= asym
->section
->vma
;
720 asym
->flags
= BSF_DEBUGGING
;
723 asym
->section
= bfd_abs_section_ptr
;
726 asym
->section
= bfd_und_section_ptr
;
736 asym
->flags
= BSF_DEBUGGING
;
739 asym
->section
= bfd_make_section_old_way (abfd
, ".sdata");
740 asym
->value
-= asym
->section
->vma
;
743 asym
->section
= bfd_make_section_old_way (abfd
, ".sbss");
744 asym
->value
-= asym
->section
->vma
;
747 asym
->section
= bfd_make_section_old_way (abfd
, ".rdata");
748 asym
->value
-= asym
->section
->vma
;
751 asym
->flags
= BSF_DEBUGGING
;
754 if (asym
->value
> ecoff_data (abfd
)->gp_size
)
756 asym
->section
= bfd_com_section_ptr
;
762 asym
->section
= &ecoff_scom_section
;
767 asym
->flags
= BSF_DEBUGGING
;
770 asym
->section
= bfd_und_section_ptr
;
775 asym
->section
= bfd_make_section_old_way (abfd
, ".init");
776 asym
->value
-= asym
->section
->vma
;
781 asym
->flags
= BSF_DEBUGGING
;
784 asym
->section
= bfd_make_section_old_way (abfd
, ".fini");
785 asym
->value
-= asym
->section
->vma
;
788 asym
->section
= bfd_make_section_old_way (abfd
, ".rconst");
789 asym
->value
-= asym
->section
->vma
;
795 /* Look for special constructors symbols and make relocation entries
796 in a special construction section. These are produced by the
797 -fgnu-linker argument to g++. */
798 if (ECOFF_IS_STAB (ecoff_sym
))
800 switch (ECOFF_UNMARK_STAB (ecoff_sym
->index
))
809 /* Mark the symbol as a constructor. */
810 asym
->flags
|= BSF_CONSTRUCTOR
;
817 /* Read an ECOFF symbol table. */
820 _bfd_ecoff_slurp_symbol_table (bfd
*abfd
)
822 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
823 const bfd_size_type external_ext_size
824 = backend
->debug_swap
.external_ext_size
;
825 const bfd_size_type external_sym_size
826 = backend
->debug_swap
.external_sym_size
;
827 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
828 = backend
->debug_swap
.swap_ext_in
;
829 void (* const swap_sym_in
) (bfd
*, void *, SYMR
*)
830 = backend
->debug_swap
.swap_sym_in
;
831 ecoff_symbol_type
*internal
;
832 ecoff_symbol_type
*internal_ptr
;
839 /* If we've already read in the symbol table, do nothing. */
840 if (ecoff_data (abfd
)->canonical_symbols
!= NULL
)
843 /* Get the symbolic information. */
844 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
845 &ecoff_data (abfd
)->debug_info
))
847 if (bfd_get_symcount (abfd
) == 0)
850 if (_bfd_mul_overflow (bfd_get_symcount (abfd
),
851 sizeof (ecoff_symbol_type
), &amt
))
853 bfd_set_error (bfd_error_file_too_big
);
856 internal
= (ecoff_symbol_type
*) bfd_alloc (abfd
, amt
);
857 if (internal
== NULL
)
860 internal_ptr
= internal
;
861 eraw_src
= (char *) ecoff_data (abfd
)->debug_info
.external_ext
;
863 + (ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
864 * external_ext_size
));
865 for (; eraw_src
< eraw_end
; eraw_src
+= external_ext_size
, internal_ptr
++)
869 (*swap_ext_in
) (abfd
, (void *) eraw_src
, &internal_esym
);
871 /* PR 17512: file: 3372-1000-0.004. */
872 if (internal_esym
.asym
.iss
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.issExtMax
873 || internal_esym
.asym
.iss
< 0)
876 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ssext
877 + internal_esym
.asym
.iss
);
879 if (!ecoff_set_symbol_info (abfd
, &internal_esym
.asym
,
880 &internal_ptr
->symbol
, 1,
881 internal_esym
.weakext
))
884 /* The alpha uses a negative ifd field for section symbols. */
885 if (internal_esym
.ifd
>= 0)
887 /* PR 17512: file: 3372-1983-0.004. */
888 if (internal_esym
.ifd
>= ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
)
889 internal_ptr
->fdr
= NULL
;
891 internal_ptr
->fdr
= (ecoff_data (abfd
)->debug_info
.fdr
892 + internal_esym
.ifd
);
895 internal_ptr
->fdr
= NULL
;
896 internal_ptr
->local
= FALSE
;
897 internal_ptr
->native
= (void *) eraw_src
;
900 /* The local symbols must be accessed via the fdr's, because the
901 string and aux indices are relative to the fdr information. */
902 fdr_ptr
= ecoff_data (abfd
)->debug_info
.fdr
;
903 fdr_end
= fdr_ptr
+ ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
;
904 for (; fdr_ptr
< fdr_end
; fdr_ptr
++)
909 lraw_src
= ((char *) ecoff_data (abfd
)->debug_info
.external_sym
910 + fdr_ptr
->isymBase
* external_sym_size
);
911 lraw_end
= lraw_src
+ fdr_ptr
->csym
* external_sym_size
;
914 lraw_src
+= external_sym_size
, internal_ptr
++)
918 (*swap_sym_in
) (abfd
, (void *) lraw_src
, &internal_sym
);
919 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ss
922 if (!ecoff_set_symbol_info (abfd
, &internal_sym
,
923 &internal_ptr
->symbol
, 0, 0))
925 internal_ptr
->fdr
= fdr_ptr
;
926 internal_ptr
->local
= TRUE
;
927 internal_ptr
->native
= (void *) lraw_src
;
931 /* PR 17512: file: 3372-3080-0.004.
932 A discrepancy between ecoff_data (abfd)->debug_info.symbolic_header.isymMax
933 and ecoff_data (abfd)->debug_info.symbolic_header.ifdMax can mean that
934 we have fewer symbols than we were expecting. Allow for this by updating
935 the symbol count and warning the user. */
936 if (internal_ptr
- internal
< (ptrdiff_t) bfd_get_symcount (abfd
))
938 abfd
->symcount
= internal_ptr
- internal
;
940 /* xgettext:c-format */
941 (_("%pB: warning: isymMax (%ld) is greater than ifdMax (%ld)"),
942 abfd
, ecoff_data (abfd
)->debug_info
.symbolic_header
.isymMax
,
943 ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
);
946 ecoff_data (abfd
)->canonical_symbols
= internal
;
951 /* Return the amount of space needed for the canonical symbols. */
954 _bfd_ecoff_get_symtab_upper_bound (bfd
*abfd
)
956 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
,
957 &ecoff_data (abfd
)->debug_info
))
960 if (bfd_get_symcount (abfd
) == 0)
963 return (bfd_get_symcount (abfd
) + 1) * (sizeof (ecoff_symbol_type
*));
966 /* Get the canonical symbols. */
969 _bfd_ecoff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
971 unsigned int counter
= 0;
972 ecoff_symbol_type
*symbase
;
973 ecoff_symbol_type
**location
= (ecoff_symbol_type
**) alocation
;
975 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
977 if (bfd_get_symcount (abfd
) == 0)
980 symbase
= ecoff_data (abfd
)->canonical_symbols
;
981 while (counter
< bfd_get_symcount (abfd
))
983 *(location
++) = symbase
++;
987 return bfd_get_symcount (abfd
);
990 /* Turn ECOFF type information into a printable string.
991 ecoff_emit_aggregate and ecoff_type_to_string are from
992 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
994 /* Write aggregate information to a string. */
997 ecoff_emit_aggregate (bfd
*abfd
,
1004 const struct ecoff_debug_swap
* const debug_swap
=
1005 &ecoff_backend (abfd
)->debug_swap
;
1006 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1007 unsigned int ifd
= rndx
->rfd
;
1008 unsigned int indx
= rndx
->index
;
1014 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1015 struct return type of a procedure compiled without -g. */
1016 if (ifd
== 0xffffffff
1017 || (rndx
->rfd
== 0xfff && indx
== 0))
1018 name
= "<undefined>";
1019 else if (indx
== indexNil
)
1025 if (debug_info
->external_rfd
== NULL
)
1026 fdr
= debug_info
->fdr
+ ifd
;
1031 (*debug_swap
->swap_rfd_in
) (abfd
,
1032 ((char *) debug_info
->external_rfd
1033 + ((fdr
->rfdBase
+ ifd
)
1034 * debug_swap
->external_rfd_size
)),
1036 fdr
= debug_info
->fdr
+ rfd
;
1039 indx
+= fdr
->isymBase
;
1041 (*debug_swap
->swap_sym_in
) (abfd
,
1042 ((char *) debug_info
->external_sym
1043 + indx
* debug_swap
->external_sym_size
),
1046 name
= debug_info
->ss
+ fdr
->issBase
+ sym
.iss
;
1050 "%s %s { ifd = %u, index = %lu }",
1052 ((unsigned long) indx
1053 + debug_info
->symbolic_header
.iextMax
));
1056 /* Convert the type information to string format. */
1059 ecoff_type_to_string (bfd
*abfd
, FDR
*fdr
, unsigned int indx
)
1061 union aux_ext
*aux_ptr
;
1071 unsigned int basic_type
;
1074 static char buffer2
[1024];
1079 aux_ptr
= ecoff_data (abfd
)->debug_info
.external_aux
+ fdr
->iauxBase
;
1080 bigendian
= fdr
->fBigendian
;
1082 for (i
= 0; i
< 7; i
++)
1084 qualifiers
[i
].low_bound
= 0;
1085 qualifiers
[i
].high_bound
= 0;
1086 qualifiers
[i
].stride
= 0;
1089 if (AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
]) == (bfd_vma
) -1)
1090 return "-1 (no type)";
1091 _bfd_ecoff_swap_tir_in (bigendian
, &aux_ptr
[indx
++].a_ti
, &u
.ti
);
1093 basic_type
= u
.ti
.bt
;
1094 qualifiers
[0].type
= u
.ti
.tq0
;
1095 qualifiers
[1].type
= u
.ti
.tq1
;
1096 qualifiers
[2].type
= u
.ti
.tq2
;
1097 qualifiers
[3].type
= u
.ti
.tq3
;
1098 qualifiers
[4].type
= u
.ti
.tq4
;
1099 qualifiers
[5].type
= u
.ti
.tq5
;
1100 qualifiers
[6].type
= tqNil
;
1102 /* Go get the basic type. */
1105 case btNil
: /* Undefined. */
1109 case btAdr
: /* Address - integer same size as pointer. */
1110 strcpy (p1
, "address");
1113 case btChar
: /* Character. */
1114 strcpy (p1
, "char");
1117 case btUChar
: /* Unsigned character. */
1118 strcpy (p1
, "unsigned char");
1121 case btShort
: /* Short. */
1122 strcpy (p1
, "short");
1125 case btUShort
: /* Unsigned short. */
1126 strcpy (p1
, "unsigned short");
1129 case btInt
: /* Int. */
1133 case btUInt
: /* Unsigned int. */
1134 strcpy (p1
, "unsigned int");
1137 case btLong
: /* Long. */
1138 strcpy (p1
, "long");
1141 case btULong
: /* Unsigned long. */
1142 strcpy (p1
, "unsigned long");
1145 case btFloat
: /* Float (real). */
1146 strcpy (p1
, "float");
1149 case btDouble
: /* Double (real). */
1150 strcpy (p1
, "double");
1153 /* Structures add 1-2 aux words:
1154 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1155 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1157 case btStruct
: /* Structure (Record). */
1158 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1159 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1160 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1162 indx
++; /* Skip aux words. */
1165 /* Unions add 1-2 aux words:
1166 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1167 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1169 case btUnion
: /* Union. */
1170 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1171 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1172 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1174 indx
++; /* Skip aux words. */
1177 /* Enumerations add 1-2 aux words:
1178 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1179 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1181 case btEnum
: /* Enumeration. */
1182 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1183 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1184 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1186 indx
++; /* Skip aux words. */
1189 case btTypedef
: /* Defined via a typedef, isymRef points. */
1190 strcpy (p1
, "typedef");
1193 case btRange
: /* Subrange of int. */
1194 strcpy (p1
, "subrange");
1197 case btSet
: /* Pascal sets. */
1201 case btComplex
: /* Fortran complex. */
1202 strcpy (p1
, "complex");
1205 case btDComplex
: /* Fortran double complex. */
1206 strcpy (p1
, "double complex");
1209 case btIndirect
: /* Forward or unnamed typedef. */
1210 strcpy (p1
, "forward/unamed typedef");
1213 case btFixedDec
: /* Fixed Decimal. */
1214 strcpy (p1
, "fixed decimal");
1217 case btFloatDec
: /* Float Decimal. */
1218 strcpy (p1
, "float decimal");
1221 case btString
: /* Varying Length Character String. */
1222 strcpy (p1
, "string");
1225 case btBit
: /* Aligned Bit String. */
1229 case btPicture
: /* Picture. */
1230 strcpy (p1
, "picture");
1233 case btVoid
: /* Void. */
1234 strcpy (p1
, "void");
1238 sprintf (p1
, _("unknown basic type %d"), (int) basic_type
);
1242 p1
+= strlen (buffer1
);
1244 /* If this is a bitfield, get the bitsize. */
1249 bitsize
= AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
++]);
1250 sprintf (p1
, " : %d", bitsize
);
1251 p1
+= strlen (buffer1
);
1254 /* Deal with any qualifiers. */
1255 if (qualifiers
[0].type
!= tqNil
)
1257 /* Snarf up any array bounds in the correct order. Arrays
1258 store 5 successive words in the aux. table:
1259 word 0 RNDXR to type of the bounds (ie, int)
1260 word 1 Current file descriptor index
1262 word 3 high bound (or -1 if [])
1263 word 4 stride size in bits. */
1264 for (i
= 0; i
< 7; i
++)
1266 if (qualifiers
[i
].type
== tqArray
)
1268 qualifiers
[i
].low_bound
=
1269 AUX_GET_DNLOW (bigendian
, &aux_ptr
[indx
+2]);
1270 qualifiers
[i
].high_bound
=
1271 AUX_GET_DNHIGH (bigendian
, &aux_ptr
[indx
+3]);
1272 qualifiers
[i
].stride
=
1273 AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
+4]);
1278 /* Now print out the qualifiers. */
1279 for (i
= 0; i
< 6; i
++)
1281 switch (qualifiers
[i
].type
)
1288 strcpy (p2
, "ptr to ");
1289 p2
+= sizeof ("ptr to ")-1;
1293 strcpy (p2
, "volatile ");
1294 p2
+= sizeof ("volatile ")-1;
1298 strcpy (p2
, "far ");
1299 p2
+= sizeof ("far ")-1;
1303 strcpy (p2
, "func. ret. ");
1304 p2
+= sizeof ("func. ret. ");
1309 int first_array
= i
;
1312 /* Print array bounds reversed (ie, in the order the C
1313 programmer writes them). C is such a fun language.... */
1314 while (i
< 5 && qualifiers
[i
+1].type
== tqArray
)
1317 for (j
= i
; j
>= first_array
; j
--)
1319 strcpy (p2
, "array [");
1320 p2
+= sizeof ("array [")-1;
1321 if (qualifiers
[j
].low_bound
!= 0)
1323 "%ld:%ld {%ld bits}",
1324 (long) qualifiers
[j
].low_bound
,
1325 (long) qualifiers
[j
].high_bound
,
1326 (long) qualifiers
[j
].stride
);
1328 else if (qualifiers
[j
].high_bound
!= -1)
1331 (long) (qualifiers
[j
].high_bound
+ 1),
1332 (long) (qualifiers
[j
].stride
));
1335 sprintf (p2
, " {%ld bits}", (long) (qualifiers
[j
].stride
));
1338 strcpy (p2
, "] of ");
1339 p2
+= sizeof ("] of ")-1;
1347 strcpy (p2
, buffer1
);
1351 /* Return information about ECOFF symbol SYMBOL in RET. */
1354 _bfd_ecoff_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
1358 bfd_symbol_info (symbol
, ret
);
1361 /* Return whether this is a local label. */
1364 _bfd_ecoff_bfd_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1367 return name
[0] == '$';
1370 /* Print information about an ECOFF symbol. */
1373 _bfd_ecoff_print_symbol (bfd
*abfd
,
1376 bfd_print_symbol_type how
)
1378 const struct ecoff_debug_swap
* const debug_swap
1379 = &ecoff_backend (abfd
)->debug_swap
;
1380 FILE *file
= (FILE *)filep
;
1384 case bfd_print_symbol_name
:
1385 fprintf (file
, "%s", symbol
->name
);
1387 case bfd_print_symbol_more
:
1388 if (ecoffsymbol (symbol
)->local
)
1392 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1394 fprintf (file
, "ecoff local ");
1395 fprintf_vma (file
, (bfd_vma
) ecoff_sym
.value
);
1396 fprintf (file
, " %x %x", (unsigned) ecoff_sym
.st
,
1397 (unsigned) ecoff_sym
.sc
);
1403 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1405 fprintf (file
, "ecoff extern ");
1406 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1407 fprintf (file
, " %x %x", (unsigned) ecoff_ext
.asym
.st
,
1408 (unsigned) ecoff_ext
.asym
.sc
);
1411 case bfd_print_symbol_all
:
1412 /* Print out the symbols in a reasonable way. */
1421 if (ecoffsymbol (symbol
)->local
)
1423 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1426 pos
= ((((char *) ecoffsymbol (symbol
)->native
1427 - (char *) ecoff_data (abfd
)->debug_info
.external_sym
)
1428 / debug_swap
->external_sym_size
)
1429 + ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
);
1436 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1439 pos
= (((char *) ecoffsymbol (symbol
)->native
1440 - (char *) ecoff_data (abfd
)->debug_info
.external_ext
)
1441 / debug_swap
->external_ext_size
);
1442 jmptbl
= ecoff_ext
.jmptbl
? 'j' : ' ';
1443 cobol_main
= ecoff_ext
.cobol_main
? 'c' : ' ';
1444 weakext
= ecoff_ext
.weakext
? 'w' : ' ';
1447 fprintf (file
, "[%3d] %c ",
1449 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1450 fprintf (file
, " st %x sc %x indx %x %c%c%c %s",
1451 (unsigned) ecoff_ext
.asym
.st
,
1452 (unsigned) ecoff_ext
.asym
.sc
,
1453 (unsigned) ecoff_ext
.asym
.index
,
1454 jmptbl
, cobol_main
, weakext
,
1457 if (ecoffsymbol (symbol
)->fdr
!= NULL
1458 && ecoff_ext
.asym
.index
!= indexNil
)
1463 bfd_size_type sym_base
;
1464 union aux_ext
*aux_base
;
1466 fdr
= ecoffsymbol (symbol
)->fdr
;
1467 indx
= ecoff_ext
.asym
.index
;
1469 /* sym_base is used to map the fdr relative indices which
1470 appear in the file to the position number which we are
1472 sym_base
= fdr
->isymBase
;
1473 if (ecoffsymbol (symbol
)->local
)
1475 ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
1477 /* aux_base is the start of the aux entries for this file;
1478 asym.index is an offset from this. */
1479 aux_base
= (ecoff_data (abfd
)->debug_info
.external_aux
1482 /* The aux entries are stored in host byte order; the
1483 order is indicated by a bit in the fdr. */
1484 bigendian
= fdr
->fBigendian
;
1486 /* This switch is basically from gcc/mips-tdump.c. */
1487 switch (ecoff_ext
.asym
.st
)
1495 fprintf (file
, _("\n End+1 symbol: %ld"),
1496 (long) (indx
+ sym_base
));
1500 if (ecoff_ext
.asym
.sc
== scText
1501 || ecoff_ext
.asym
.sc
== scInfo
)
1502 fprintf (file
, _("\n First symbol: %ld"),
1503 (long) (indx
+ sym_base
));
1505 fprintf (file
, _("\n First symbol: %ld"),
1507 (AUX_GET_ISYM (bigendian
,
1508 &aux_base
[ecoff_ext
.asym
.index
])
1514 if (ECOFF_IS_STAB (&ecoff_ext
.asym
))
1516 else if (ecoffsymbol (symbol
)->local
)
1517 /* xgettext:c-format */
1518 fprintf (file
, _("\n End+1 symbol: %-7ld Type: %s"),
1520 (AUX_GET_ISYM (bigendian
,
1521 &aux_base
[ecoff_ext
.asym
.index
])
1523 ecoff_type_to_string (abfd
, fdr
, indx
+ 1));
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
))
1549 fprintf (file
, _("\n Type: %s"),
1550 ecoff_type_to_string (abfd
, fdr
, indx
));
1559 /* Read in the relocs for a section. */
1562 ecoff_slurp_reloc_table (bfd
*abfd
,
1566 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1567 arelent
*internal_relocs
;
1568 bfd_size_type external_reloc_size
;
1570 bfd_byte
*external_relocs
;
1574 if (section
->relocation
!= NULL
1575 || section
->reloc_count
== 0
1576 || (section
->flags
& SEC_CONSTRUCTOR
) != 0)
1579 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1582 external_reloc_size
= backend
->external_reloc_size
;
1583 amt
= external_reloc_size
* section
->reloc_count
;
1584 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1586 external_relocs
= _bfd_malloc_and_read (abfd
, amt
, amt
);
1587 if (external_relocs
== NULL
)
1590 amt
= section
->reloc_count
;
1591 amt
*= sizeof (arelent
);
1592 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
1593 if (internal_relocs
== NULL
)
1595 free (external_relocs
);
1599 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1601 struct internal_reloc intern
;
1603 (*backend
->swap_reloc_in
) (abfd
,
1604 external_relocs
+ i
* external_reloc_size
,
1607 if (intern
.r_extern
)
1609 /* r_symndx is an index into the external symbols. */
1610 BFD_ASSERT (intern
.r_symndx
>= 0
1612 < (ecoff_data (abfd
)
1613 ->debug_info
.symbolic_header
.iextMax
)));
1614 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1617 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1618 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1620 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1625 const char *sec_name
;
1628 /* r_symndx is a section key. */
1629 switch (intern
.r_symndx
)
1631 case RELOC_SECTION_TEXT
: sec_name
= _TEXT
; break;
1632 case RELOC_SECTION_RDATA
: sec_name
= _RDATA
; break;
1633 case RELOC_SECTION_DATA
: sec_name
= _DATA
; break;
1634 case RELOC_SECTION_SDATA
: sec_name
= _SDATA
; break;
1635 case RELOC_SECTION_SBSS
: sec_name
= _SBSS
; break;
1636 case RELOC_SECTION_BSS
: sec_name
= _BSS
; break;
1637 case RELOC_SECTION_INIT
: sec_name
= _INIT
; break;
1638 case RELOC_SECTION_LIT8
: sec_name
= _LIT8
; break;
1639 case RELOC_SECTION_LIT4
: sec_name
= _LIT4
; break;
1640 case RELOC_SECTION_XDATA
: sec_name
= _XDATA
; break;
1641 case RELOC_SECTION_PDATA
: sec_name
= _PDATA
; break;
1642 case RELOC_SECTION_FINI
: sec_name
= _FINI
; break;
1643 case RELOC_SECTION_LITA
: sec_name
= _LITA
; break;
1644 case RELOC_SECTION_RCONST
: sec_name
= _RCONST
; break;
1648 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1651 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1653 rptr
->addend
= - bfd_section_vma (sec
);
1656 rptr
->address
= intern
.r_vaddr
- bfd_section_vma (section
);
1658 /* Let the backend select the howto field and do any other
1659 required processing. */
1660 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1663 free (external_relocs
);
1665 section
->relocation
= internal_relocs
;
1670 /* Get a canonical list of relocs. */
1673 _bfd_ecoff_canonicalize_reloc (bfd
*abfd
,
1680 if (section
->flags
& SEC_CONSTRUCTOR
)
1682 arelent_chain
*chain
;
1684 /* This section has relocs made up by us, not the file, so take
1685 them out of their chain and place them into the data area
1687 for (count
= 0, chain
= section
->constructor_chain
;
1688 count
< section
->reloc_count
;
1689 count
++, chain
= chain
->next
)
1690 *relptr
++ = &chain
->relent
;
1696 if (! ecoff_slurp_reloc_table (abfd
, section
, symbols
))
1699 tblptr
= section
->relocation
;
1701 for (count
= 0; count
< section
->reloc_count
; count
++)
1702 *relptr
++ = tblptr
++;
1707 return section
->reloc_count
;
1710 /* Provided a BFD, a section and an offset into the section, calculate
1711 and return the name of the source file and the line nearest to the
1715 _bfd_ecoff_find_nearest_line (bfd
*abfd
,
1716 asymbol
**symbols ATTRIBUTE_UNUSED
,
1719 const char **filename_ptr
,
1720 const char **functionname_ptr
,
1721 unsigned int *retline_ptr
,
1722 unsigned int *discriminator_ptr
)
1724 const struct ecoff_debug_swap
* const debug_swap
1725 = &ecoff_backend (abfd
)->debug_swap
;
1726 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1727 struct ecoff_find_line
*line_info
;
1729 /* Make sure we have the FDR's. */
1730 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, NULL
, debug_info
)
1731 || bfd_get_symcount (abfd
) == 0)
1734 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1736 size_t amt
= sizeof (struct ecoff_find_line
);
1738 ecoff_data (abfd
)->find_line_info
=
1739 (struct ecoff_find_line
*) bfd_zalloc (abfd
, amt
);
1740 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1744 if (discriminator_ptr
)
1745 *discriminator_ptr
= 0;
1746 line_info
= ecoff_data (abfd
)->find_line_info
;
1747 return _bfd_ecoff_locate_line (abfd
, section
, offset
, debug_info
,
1748 debug_swap
, line_info
, filename_ptr
,
1749 functionname_ptr
, retline_ptr
);
1752 /* Copy private BFD data. This is called by objcopy and strip. We
1753 use it to copy the ECOFF debugging information from one BFD to the
1754 other. It would be theoretically possible to represent the ECOFF
1755 debugging information in the symbol table. However, it would be a
1756 lot of work, and there would be little gain (gas, gdb, and ld
1757 already access the ECOFF debugging information via the
1758 ecoff_debug_info structure, and that structure would have to be
1759 retained in order to support ECOFF debugging in MIPS ELF).
1761 The debugging information for the ECOFF external symbols comes from
1762 the symbol table, so this function only handles the other debugging
1766 _bfd_ecoff_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1768 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
1769 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
1771 asymbol
**sym_ptr_ptr
;
1775 /* We only want to copy information over if both BFD's use ECOFF
1777 if (bfd_get_flavour (ibfd
) != bfd_target_ecoff_flavour
1778 || bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
1781 /* Copy the GP value and the register masks. */
1782 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
1783 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
1784 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
1785 for (i
= 0; i
< 3; i
++)
1786 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
1788 /* Copy the version stamp. */
1789 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
1791 /* If there are no symbols, don't copy any debugging information. */
1792 c
= bfd_get_symcount (obfd
);
1793 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1794 if (c
== 0 || sym_ptr_ptr
== NULL
)
1797 /* See if there are any local symbols. */
1799 for (; c
> 0; c
--, sym_ptr_ptr
++)
1801 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
1810 /* There are some local symbols. We just bring over all the
1811 debugging information. FIXME: This is not quite the right
1812 thing to do. If the user has asked us to discard all
1813 debugging information, then we are probably going to wind up
1814 keeping it because there will probably be some local symbol
1815 which objcopy did not discard. We should actually break
1816 apart the debugging information and only keep that which
1817 applies to the symbols we want to keep. */
1818 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
1819 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
1820 oinfo
->line
= iinfo
->line
;
1822 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
1823 oinfo
->external_dnr
= iinfo
->external_dnr
;
1825 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
1826 oinfo
->external_pdr
= iinfo
->external_pdr
;
1828 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
1829 oinfo
->external_sym
= iinfo
->external_sym
;
1831 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
1832 oinfo
->external_opt
= iinfo
->external_opt
;
1834 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
1835 oinfo
->external_aux
= iinfo
->external_aux
;
1837 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
1838 oinfo
->ss
= iinfo
->ss
;
1840 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
1841 oinfo
->external_fdr
= iinfo
->external_fdr
;
1843 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
1844 oinfo
->external_rfd
= iinfo
->external_rfd
;
1848 /* We are discarding all the local symbol information. Look
1849 through the external symbols and remove all references to FDR
1850 or aux information. */
1851 c
= bfd_get_symcount (obfd
);
1852 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1853 for (; c
> 0; c
--, sym_ptr_ptr
++)
1857 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
1858 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
1860 esym
.asym
.index
= indexNil
;
1861 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
1862 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
1869 /* Set the architecture. The supported architecture is stored in the
1870 backend pointer. We always set the architecture anyhow, since many
1871 callers ignore the return value. */
1874 _bfd_ecoff_set_arch_mach (bfd
*abfd
,
1875 enum bfd_architecture arch
,
1876 unsigned long machine
)
1878 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1879 return arch
== ecoff_backend (abfd
)->arch
;
1882 /* Get the size of the section headers. */
1885 _bfd_ecoff_sizeof_headers (bfd
*abfd
,
1886 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1893 for (current
= abfd
->sections
;
1895 current
= current
->next
)
1898 ret
= (bfd_coff_filhsz (abfd
)
1899 + bfd_coff_aoutsz (abfd
)
1900 + c
* bfd_coff_scnhsz (abfd
));
1901 return (int) BFD_ALIGN (ret
, 16);
1904 /* Get the contents of a section. */
1907 _bfd_ecoff_get_section_contents (bfd
*abfd
,
1911 bfd_size_type count
)
1913 return _bfd_generic_get_section_contents (abfd
, section
, location
,
1917 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
1918 called via qsort. */
1921 ecoff_sort_hdrs (const void * arg1
, const void * arg2
)
1923 const asection
*hdr1
= *(const asection
**) arg1
;
1924 const asection
*hdr2
= *(const asection
**) arg2
;
1926 if ((hdr1
->flags
& SEC_ALLOC
) != 0)
1928 if ((hdr2
->flags
& SEC_ALLOC
) == 0)
1933 if ((hdr2
->flags
& SEC_ALLOC
) != 0)
1936 if (hdr1
->vma
< hdr2
->vma
)
1938 else if (hdr1
->vma
> hdr2
->vma
)
1944 /* Calculate the file position for each section, and set
1948 ecoff_compute_section_file_positions (bfd
*abfd
)
1950 file_ptr sofar
, file_sofar
;
1951 asection
**sorted_hdrs
;
1955 bfd_boolean rdata_in_text
;
1956 bfd_boolean first_data
, first_nonalloc
;
1957 const bfd_vma round
= ecoff_backend (abfd
)->round
;
1960 sofar
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
1963 /* Sort the sections by VMA. */
1964 amt
= abfd
->section_count
;
1965 amt
*= sizeof (asection
*);
1966 sorted_hdrs
= (asection
**) bfd_malloc (amt
);
1967 if (sorted_hdrs
== NULL
)
1969 for (current
= abfd
->sections
, i
= 0;
1971 current
= current
->next
, i
++)
1972 sorted_hdrs
[i
] = current
;
1973 BFD_ASSERT (i
== abfd
->section_count
);
1975 qsort (sorted_hdrs
, abfd
->section_count
, sizeof (asection
*),
1978 /* Some versions of the OSF linker put the .rdata section in the
1979 text segment, and some do not. */
1980 rdata_in_text
= ecoff_backend (abfd
)->rdata_in_text
;
1983 for (i
= 0; i
< abfd
->section_count
; i
++)
1985 current
= sorted_hdrs
[i
];
1986 if (streq (current
->name
, _RDATA
))
1988 if ((current
->flags
& SEC_CODE
) == 0
1989 && ! streq (current
->name
, _PDATA
)
1990 && ! streq (current
->name
, _RCONST
))
1992 rdata_in_text
= FALSE
;
1997 ecoff_data (abfd
)->rdata_in_text
= rdata_in_text
;
2000 first_nonalloc
= TRUE
;
2001 for (i
= 0; i
< abfd
->section_count
; i
++)
2003 unsigned int alignment_power
;
2005 current
= sorted_hdrs
[i
];
2007 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2008 supposed to indicate the number of .pdata entries that are
2009 really in the section. Each entry is 8 bytes. We store this
2010 away in line_filepos before increasing the section size. */
2011 if (streq (current
->name
, _PDATA
))
2012 current
->line_filepos
= current
->size
/ 8;
2014 alignment_power
= current
->alignment_power
;
2016 /* On Ultrix, the data sections in an executable file must be
2017 aligned to a page boundary within the file. This does not
2018 affect the section size, though. FIXME: Does this work for
2019 other platforms? It requires some modification for the
2020 Alpha, because .rdata on the Alpha goes with the text, not
2022 if ((abfd
->flags
& EXEC_P
) != 0
2023 && (abfd
->flags
& D_PAGED
) != 0
2025 && (current
->flags
& SEC_CODE
) == 0
2027 || ! streq (current
->name
, _RDATA
))
2028 && ! streq (current
->name
, _PDATA
)
2029 && ! streq (current
->name
, _RCONST
))
2031 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2032 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2035 else if (streq (current
->name
, _LIB
))
2037 /* On Irix 4, the location of contents of the .lib section
2038 from a shared library section is also rounded up to a
2041 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2042 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2044 else if (first_nonalloc
2045 && (current
->flags
& SEC_ALLOC
) == 0
2046 && (abfd
->flags
& D_PAGED
) != 0)
2048 /* Skip up to the next page for an unallocated section, such
2049 as the .comment section on the Alpha. This leaves room
2050 for the .bss section. */
2051 first_nonalloc
= FALSE
;
2052 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2053 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2056 /* Align the sections in the file to the same boundary on
2057 which they are aligned in virtual memory. */
2058 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2059 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2060 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2062 if ((abfd
->flags
& D_PAGED
) != 0
2063 && (current
->flags
& SEC_ALLOC
) != 0)
2065 sofar
+= (current
->vma
- sofar
) % round
;
2066 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2067 file_sofar
+= (current
->vma
- file_sofar
) % round
;
2070 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) != 0)
2071 current
->filepos
= file_sofar
;
2073 sofar
+= current
->size
;
2074 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2075 file_sofar
+= current
->size
;
2077 /* Make sure that this section is of the right size too. */
2079 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2080 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2081 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2082 current
->size
+= sofar
- old_sofar
;
2088 ecoff_data (abfd
)->reloc_filepos
= file_sofar
;
2093 /* Determine the location of the relocs for all the sections in the
2094 output file, as well as the location of the symbolic debugging
2097 static bfd_size_type
2098 ecoff_compute_reloc_file_positions (bfd
*abfd
)
2100 const bfd_size_type external_reloc_size
=
2101 ecoff_backend (abfd
)->external_reloc_size
;
2102 file_ptr reloc_base
;
2103 bfd_size_type reloc_size
;
2107 if (! abfd
->output_has_begun
)
2109 if (! ecoff_compute_section_file_positions (abfd
))
2111 abfd
->output_has_begun
= TRUE
;
2114 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2117 for (current
= abfd
->sections
;
2119 current
= current
->next
)
2121 if (current
->reloc_count
== 0)
2122 current
->rel_filepos
= 0;
2125 bfd_size_type relsize
;
2127 current
->rel_filepos
= reloc_base
;
2128 relsize
= current
->reloc_count
* external_reloc_size
;
2129 reloc_size
+= relsize
;
2130 reloc_base
+= relsize
;
2134 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2136 /* At least on Ultrix, the symbol table of an executable file must
2137 be aligned to a page boundary. FIXME: Is this true on other
2139 if ((abfd
->flags
& EXEC_P
) != 0
2140 && (abfd
->flags
& D_PAGED
) != 0)
2141 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2142 &~ (ecoff_backend (abfd
)->round
- 1));
2144 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2149 /* Set the contents of a section. */
2152 _bfd_ecoff_set_section_contents (bfd
*abfd
,
2154 const void * location
,
2156 bfd_size_type count
)
2160 /* This must be done first, because bfd_set_section_contents is
2161 going to set output_has_begun to TRUE. */
2162 if (! abfd
->output_has_begun
2163 && ! ecoff_compute_section_file_positions (abfd
))
2166 /* Handle the .lib section specially so that Irix 4 shared libraries
2167 work out. See coff_set_section_contents in coffcode.h. */
2168 if (streq (section
->name
, _LIB
))
2170 bfd_byte
*rec
, *recend
;
2172 rec
= (bfd_byte
*) location
;
2173 recend
= rec
+ count
;
2174 while (rec
< recend
)
2177 rec
+= bfd_get_32 (abfd
, rec
) * 4;
2180 BFD_ASSERT (rec
== recend
);
2186 pos
= section
->filepos
+ offset
;
2187 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2188 || bfd_bwrite (location
, count
, abfd
) != count
)
2194 /* Set the GP value for an ECOFF file. This is a hook used by the
2198 bfd_ecoff_set_gp_value (bfd
*abfd
, bfd_vma gp_value
)
2200 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2201 || bfd_get_format (abfd
) != bfd_object
)
2203 bfd_set_error (bfd_error_invalid_operation
);
2207 ecoff_data (abfd
)->gp
= gp_value
;
2212 /* Set the register masks for an ECOFF file. This is a hook used by
2216 bfd_ecoff_set_regmasks (bfd
*abfd
,
2217 unsigned long gprmask
,
2218 unsigned long fprmask
,
2219 unsigned long *cprmask
)
2221 ecoff_data_type
*tdata
;
2223 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2224 || bfd_get_format (abfd
) != bfd_object
)
2226 bfd_set_error (bfd_error_invalid_operation
);
2230 tdata
= ecoff_data (abfd
);
2231 tdata
->gprmask
= gprmask
;
2232 tdata
->fprmask
= fprmask
;
2233 if (cprmask
!= NULL
)
2237 for (i
= 0; i
< 3; i
++)
2238 tdata
->cprmask
[i
] = cprmask
[i
];
2244 /* Get ECOFF EXTR information for an external symbol. This function
2245 is passed to bfd_ecoff_debug_externals. */
2248 ecoff_get_extr (asymbol
*sym
, EXTR
*esym
)
2250 ecoff_symbol_type
*ecoff_sym_ptr
;
2253 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2254 || ecoffsymbol (sym
)->native
== NULL
)
2256 /* Don't include debugging, local, or section symbols. */
2257 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2258 || (sym
->flags
& BSF_LOCAL
) != 0
2259 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2263 esym
->cobol_main
= 0;
2264 esym
->weakext
= (sym
->flags
& BSF_WEAK
) != 0;
2267 /* FIXME: we can do better than this for st and sc. */
2268 esym
->asym
.st
= stGlobal
;
2269 esym
->asym
.sc
= scAbs
;
2270 esym
->asym
.reserved
= 0;
2271 esym
->asym
.index
= indexNil
;
2275 ecoff_sym_ptr
= ecoffsymbol (sym
);
2277 if (ecoff_sym_ptr
->local
)
2280 input_bfd
= bfd_asymbol_bfd (sym
);
2281 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2282 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2284 /* If the symbol was defined by the linker, then esym will be
2285 undefined but sym will not be. Get a better class for such a
2287 if ((esym
->asym
.sc
== scUndefined
2288 || esym
->asym
.sc
== scSUndefined
)
2289 && ! bfd_is_und_section (bfd_asymbol_section (sym
)))
2290 esym
->asym
.sc
= scAbs
;
2292 /* Adjust the FDR index for the symbol by that used for the input
2294 if (esym
->ifd
!= -1)
2296 struct ecoff_debug_info
*input_debug
;
2298 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2299 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2300 if (input_debug
->ifdmap
!= NULL
)
2301 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2307 /* Set the external symbol index. This routine is passed to
2308 bfd_ecoff_debug_externals. */
2311 ecoff_set_index (asymbol
*sym
, bfd_size_type indx
)
2313 ecoff_set_sym_index (sym
, indx
);
2316 /* Write out an ECOFF file. */
2319 _bfd_ecoff_write_object_contents (bfd
*abfd
)
2321 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2322 const bfd_vma round
= backend
->round
;
2323 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2324 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2325 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2326 const bfd_size_type external_hdr_size
2327 = backend
->debug_swap
.external_hdr_size
;
2328 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2329 void (* const adjust_reloc_out
) (bfd
*, const arelent
*, struct internal_reloc
*)
2330 = backend
->adjust_reloc_out
;
2331 void (* const swap_reloc_out
) (bfd
*, const struct internal_reloc
*, void *)
2332 = backend
->swap_reloc_out
;
2333 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2334 HDRR
* const symhdr
= &debug
->symbolic_header
;
2337 bfd_size_type reloc_size
;
2338 bfd_size_type text_size
;
2340 bfd_boolean set_text_start
;
2341 bfd_size_type data_size
;
2343 bfd_boolean set_data_start
;
2344 bfd_size_type bss_size
;
2346 void * reloc_buff
= NULL
;
2347 struct internal_filehdr internal_f
;
2348 struct internal_aouthdr internal_a
;
2351 /* Determine where the sections and relocs will go in the output
2353 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2356 for (current
= abfd
->sections
;
2358 current
= current
->next
)
2360 current
->target_index
= count
;
2364 if ((abfd
->flags
& D_PAGED
) != 0)
2365 text_size
= _bfd_ecoff_sizeof_headers (abfd
, NULL
);
2369 set_text_start
= FALSE
;
2372 set_data_start
= FALSE
;
2375 /* Write section headers to the file. */
2377 /* Allocate buff big enough to hold a section header,
2378 file header, or a.out header. */
2387 buff
= bfd_malloc (siz
);
2392 internal_f
.f_nscns
= 0;
2393 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2396 for (current
= abfd
->sections
;
2398 current
= current
->next
)
2400 struct internal_scnhdr section
;
2403 ++internal_f
.f_nscns
;
2405 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2407 /* This seems to be correct for Irix 4 shared libraries. */
2408 vma
= bfd_section_vma (current
);
2409 if (streq (current
->name
, _LIB
))
2410 section
.s_vaddr
= 0;
2412 section
.s_vaddr
= vma
;
2414 section
.s_paddr
= current
->lma
;
2415 section
.s_size
= current
->size
;
2417 /* If this section is unloadable then the scnptr will be 0. */
2418 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2419 section
.s_scnptr
= 0;
2421 section
.s_scnptr
= current
->filepos
;
2422 section
.s_relptr
= current
->rel_filepos
;
2424 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2425 object file produced by the assembler is supposed to point to
2426 information about how much room is required by objects of
2427 various different sizes. I think this only matters if we
2428 want the linker to compute the best size to use, or
2429 something. I don't know what happens if the information is
2431 if (! streq (current
->name
, _PDATA
))
2432 section
.s_lnnoptr
= 0;
2435 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2436 hold the number of entries in the section (each entry is
2437 8 bytes). We stored this in the line_filepos field in
2438 ecoff_compute_section_file_positions. */
2439 section
.s_lnnoptr
= current
->line_filepos
;
2442 section
.s_nreloc
= current
->reloc_count
;
2443 section
.s_nlnno
= 0;
2444 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2447 if (bfd_coff_swap_scnhdr_out (abfd
, (void *) §ion
, buff
) == 0
2448 || bfd_bwrite (buff
, scnhsz
, abfd
) != scnhsz
)
2451 if ((section
.s_flags
& STYP_TEXT
) != 0
2452 || ((section
.s_flags
& STYP_RDATA
) != 0
2453 && ecoff_data (abfd
)->rdata_in_text
)
2454 || section
.s_flags
== STYP_PDATA
2455 || (section
.s_flags
& STYP_DYNAMIC
) != 0
2456 || (section
.s_flags
& STYP_LIBLIST
) != 0
2457 || (section
.s_flags
& STYP_RELDYN
) != 0
2458 || section
.s_flags
== STYP_CONFLIC
2459 || (section
.s_flags
& STYP_DYNSTR
) != 0
2460 || (section
.s_flags
& STYP_DYNSYM
) != 0
2461 || (section
.s_flags
& STYP_HASH
) != 0
2462 || (section
.s_flags
& STYP_ECOFF_INIT
) != 0
2463 || (section
.s_flags
& STYP_ECOFF_FINI
) != 0
2464 || section
.s_flags
== STYP_RCONST
)
2466 text_size
+= current
->size
;
2467 if (! set_text_start
|| text_start
> vma
)
2470 set_text_start
= TRUE
;
2473 else if ((section
.s_flags
& STYP_RDATA
) != 0
2474 || (section
.s_flags
& STYP_DATA
) != 0
2475 || (section
.s_flags
& STYP_LITA
) != 0
2476 || (section
.s_flags
& STYP_LIT8
) != 0
2477 || (section
.s_flags
& STYP_LIT4
) != 0
2478 || (section
.s_flags
& STYP_SDATA
) != 0
2479 || section
.s_flags
== STYP_XDATA
2480 || (section
.s_flags
& STYP_GOT
) != 0)
2482 data_size
+= current
->size
;
2483 if (! set_data_start
|| data_start
> vma
)
2486 set_data_start
= TRUE
;
2489 else if ((section
.s_flags
& STYP_BSS
) != 0
2490 || (section
.s_flags
& STYP_SBSS
) != 0)
2491 bss_size
+= current
->size
;
2492 else if (section
.s_flags
== 0
2493 || (section
.s_flags
& STYP_ECOFF_LIB
) != 0
2494 || section
.s_flags
== STYP_COMMENT
)
2500 /* Set up the file header. */
2501 internal_f
.f_magic
= ecoff_get_magic (abfd
);
2503 /* We will NOT put a fucking timestamp in the header here. Every
2504 time you put it back, I will come in and take it out again. I'm
2505 sorry. This field does not belong here. We fill it with a 0 so
2506 it compares the same but is not a reasonable time. --
2508 internal_f
.f_timdat
= 0;
2510 if (bfd_get_symcount (abfd
) != 0)
2512 /* The ECOFF f_nsyms field is not actually the number of
2513 symbols, it's the size of symbolic information header. */
2514 internal_f
.f_nsyms
= external_hdr_size
;
2515 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
2519 internal_f
.f_nsyms
= 0;
2520 internal_f
.f_symptr
= 0;
2523 internal_f
.f_opthdr
= aoutsz
;
2525 internal_f
.f_flags
= F_LNNO
;
2526 if (reloc_size
== 0)
2527 internal_f
.f_flags
|= F_RELFLG
;
2528 if (bfd_get_symcount (abfd
) == 0)
2529 internal_f
.f_flags
|= F_LSYMS
;
2530 if (abfd
->flags
& EXEC_P
)
2531 internal_f
.f_flags
|= F_EXEC
;
2533 if (bfd_little_endian (abfd
))
2534 internal_f
.f_flags
|= F_AR32WR
;
2536 internal_f
.f_flags
|= F_AR32W
;
2538 /* Set up the ``optional'' header. */
2539 if ((abfd
->flags
& D_PAGED
) != 0)
2540 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
2542 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
2544 /* FIXME: Is this really correct? */
2545 internal_a
.vstamp
= symhdr
->vstamp
;
2547 /* At least on Ultrix, these have to be rounded to page boundaries.
2548 FIXME: Is this true on other platforms? */
2549 if ((abfd
->flags
& D_PAGED
) != 0)
2551 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
2552 internal_a
.text_start
= text_start
&~ (round
- 1);
2553 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
2554 internal_a
.data_start
= data_start
&~ (round
- 1);
2558 internal_a
.tsize
= text_size
;
2559 internal_a
.text_start
= text_start
;
2560 internal_a
.dsize
= data_size
;
2561 internal_a
.data_start
= data_start
;
2564 /* On Ultrix, the initial portions of the .sbss and .bss segments
2565 are at the end of the data section. The bsize field in the
2566 optional header records how many bss bytes are required beyond
2567 those in the data section. The value is not rounded to a page
2569 if (bss_size
< internal_a
.dsize
- data_size
)
2572 bss_size
-= internal_a
.dsize
- data_size
;
2573 internal_a
.bsize
= bss_size
;
2574 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
2576 internal_a
.entry
= bfd_get_start_address (abfd
);
2578 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
2580 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
2581 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
2582 for (i
= 0; i
< 4; i
++)
2583 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
2585 /* Let the backend adjust the headers if necessary. */
2586 if (backend
->adjust_headers
)
2588 if (! (*backend
->adjust_headers
) (abfd
, &internal_f
, &internal_a
))
2592 /* Write out the file header and the optional header. */
2593 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2596 bfd_coff_swap_filehdr_out (abfd
, (void *) &internal_f
, buff
);
2597 if (bfd_bwrite (buff
, filhsz
, abfd
) != filhsz
)
2600 bfd_coff_swap_aouthdr_out (abfd
, (void *) &internal_a
, buff
);
2601 if (bfd_bwrite (buff
, aoutsz
, abfd
) != aoutsz
)
2604 /* Build the external symbol information. This must be done before
2605 writing out the relocs so that we know the symbol indices. We
2606 don't do this if this BFD was created by the backend linker,
2607 since it will have already handled the symbols and relocs. */
2608 if (! ecoff_data (abfd
)->linker
)
2610 symhdr
->iextMax
= 0;
2611 symhdr
->issExtMax
= 0;
2612 debug
->external_ext
= debug
->external_ext_end
= NULL
;
2613 debug
->ssext
= debug
->ssext_end
= NULL
;
2614 if (! bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
2615 (abfd
->flags
& EXEC_P
) == 0,
2616 ecoff_get_extr
, ecoff_set_index
))
2619 /* Write out the relocs. */
2620 for (current
= abfd
->sections
;
2622 current
= current
->next
)
2624 arelent
**reloc_ptr_ptr
;
2625 arelent
**reloc_end
;
2629 if (current
->reloc_count
== 0)
2632 amt
= current
->reloc_count
* external_reloc_size
;
2633 reloc_buff
= bfd_alloc (abfd
, amt
);
2634 if (reloc_buff
== NULL
)
2637 reloc_ptr_ptr
= current
->orelocation
;
2638 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
2639 out_ptr
= (char *) reloc_buff
;
2642 reloc_ptr_ptr
< reloc_end
;
2643 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
2647 struct internal_reloc in
;
2649 memset ((void *) &in
, 0, sizeof in
);
2651 reloc
= *reloc_ptr_ptr
;
2652 sym
= *reloc
->sym_ptr_ptr
;
2654 /* If the howto field has not been initialised then skip this reloc.
2655 This assumes that an error message has been issued elsewhere. */
2656 if (reloc
->howto
== NULL
)
2659 in
.r_vaddr
= reloc
->address
+ bfd_section_vma (current
);
2660 in
.r_type
= reloc
->howto
->type
;
2662 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2664 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2678 { _TEXT
, RELOC_SECTION_TEXT
},
2679 { _RDATA
, RELOC_SECTION_RDATA
},
2680 { _DATA
, RELOC_SECTION_DATA
},
2681 { _SDATA
, RELOC_SECTION_SDATA
},
2682 { _SBSS
, RELOC_SECTION_SBSS
},
2683 { _BSS
, RELOC_SECTION_BSS
},
2684 { _INIT
, RELOC_SECTION_INIT
},
2685 { _LIT8
, RELOC_SECTION_LIT8
},
2686 { _LIT4
, RELOC_SECTION_LIT4
},
2687 { _XDATA
, RELOC_SECTION_XDATA
},
2688 { _PDATA
, RELOC_SECTION_PDATA
},
2689 { _FINI
, RELOC_SECTION_FINI
},
2690 { _LITA
, RELOC_SECTION_LITA
},
2691 { "*ABS*", RELOC_SECTION_ABS
},
2692 { _RCONST
, RELOC_SECTION_RCONST
}
2695 name
= bfd_section_name (bfd_asymbol_section (sym
));
2697 for (j
= 0; j
< ARRAY_SIZE (section_symndx
); j
++)
2698 if (streq (name
, section_symndx
[j
].name
))
2700 in
.r_symndx
= section_symndx
[j
].r_symndx
;
2704 if (j
== ARRAY_SIZE (section_symndx
))
2709 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2711 (*swap_reloc_out
) (abfd
, &in
, (void *) out_ptr
);
2714 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2716 amt
= current
->reloc_count
* external_reloc_size
;
2717 if (bfd_bwrite (reloc_buff
, amt
, abfd
) != amt
)
2719 bfd_release (abfd
, reloc_buff
);
2723 /* Write out the symbolic debugging information. */
2724 if (bfd_get_symcount (abfd
) > 0)
2726 /* Write out the debugging information. */
2727 if (! bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2728 ecoff_data (abfd
)->sym_filepos
))
2733 /* The .bss section of a demand paged executable must receive an
2734 entire page. If there are symbols, the symbols will start on the
2735 next page. If there are no symbols, we must fill out the page by
2737 if (bfd_get_symcount (abfd
) == 0
2738 && (abfd
->flags
& EXEC_P
) != 0
2739 && (abfd
->flags
& D_PAGED
) != 0)
2743 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2746 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) == 0)
2748 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2751 if (bfd_bwrite (&c
, (bfd_size_type
) 1, abfd
) != 1)
2755 if (reloc_buff
!= NULL
)
2756 bfd_release (abfd
, reloc_buff
);
2760 if (reloc_buff
!= NULL
)
2761 bfd_release (abfd
, reloc_buff
);
2766 /* Archive handling. ECOFF uses what appears to be a unique type of
2767 archive header (armap). The byte ordering of the armap and the
2768 contents are encoded in the name of the armap itself. At least for
2769 now, we only support archives with the same byte ordering in the
2770 armap and the contents.
2772 The first four bytes in the armap are the number of symbol
2773 definitions. This is always a power of two.
2775 This is followed by the symbol definitions. Each symbol definition
2776 occupies 8 bytes. The first four bytes are the offset from the
2777 start of the armap strings to the null-terminated string naming
2778 this symbol. The second four bytes are the file offset to the
2779 archive member which defines this symbol. If the second four bytes
2780 are 0, then this is not actually a symbol definition, and it should
2783 The symbols are hashed into the armap with a closed hashing scheme.
2784 See the functions below for the details of the algorithm.
2786 After the symbol definitions comes four bytes holding the size of
2787 the string table, followed by the string table itself. */
2789 /* The name of an archive headers looks like this:
2790 __________E[BL]E[BL]_ (with a trailing space).
2791 The trailing space is changed to an X if the archive is changed to
2792 indicate that the armap is out of date.
2794 The Alpha seems to use ________64E[BL]E[BL]_. */
2796 #define ARMAP_BIG_ENDIAN 'B'
2797 #define ARMAP_LITTLE_ENDIAN 'L'
2798 #define ARMAP_MARKER 'E'
2799 #define ARMAP_START_LENGTH 10
2800 #define ARMAP_HEADER_MARKER_INDEX 10
2801 #define ARMAP_HEADER_ENDIAN_INDEX 11
2802 #define ARMAP_OBJECT_MARKER_INDEX 12
2803 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2804 #define ARMAP_END_INDEX 14
2805 #define ARMAP_END "_ "
2807 /* This is a magic number used in the hashing algorithm. */
2808 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2810 /* This returns the hash value to use for a string. It also sets
2811 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2812 is the number of entries in the hash table, and HLOG is the log
2816 ecoff_armap_hash (const char *s
,
2817 unsigned int *rehash
,
2827 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2828 hash
*= ARMAP_HASH_MAGIC
;
2829 *rehash
= (hash
& (size
- 1)) | 1;
2830 return hash
>> (32 - hlog
);
2833 /* Read in the armap. */
2836 _bfd_ecoff_slurp_armap (bfd
*abfd
)
2840 struct areltdata
*mapdata
;
2841 bfd_size_type parsed_size
, stringsize
;
2843 struct artdata
*ardata
;
2850 /* Get the name of the first element. */
2851 i
= bfd_bread ((void *) nextname
, (bfd_size_type
) 16, abfd
);
2857 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2860 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2861 standard COFF armap. We could move the ECOFF armap stuff into
2862 bfd_slurp_armap, but that seems inappropriate since no other
2863 target uses this format. Instead, we check directly for a COFF
2865 if (CONST_STRNEQ (nextname
, "/ "))
2866 return bfd_slurp_armap (abfd
);
2868 /* See if the first element is an armap. */
2869 if (! strneq (nextname
, ecoff_backend (abfd
)->armap_start
, ARMAP_START_LENGTH
)
2870 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
2871 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2872 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2873 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
2874 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
2875 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
2876 || ! strneq (nextname
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1))
2878 abfd
->has_armap
= FALSE
;
2882 /* Make sure we have the right byte ordering. */
2883 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2884 ^ (bfd_header_big_endian (abfd
)))
2885 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
2886 ^ (bfd_big_endian (abfd
))))
2888 bfd_set_error (bfd_error_wrong_format
);
2892 /* Read in the armap. */
2893 ardata
= bfd_ardata (abfd
);
2894 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
2895 if (mapdata
== NULL
)
2897 parsed_size
= mapdata
->parsed_size
;
2900 if (parsed_size
+ 1 < 9)
2902 bfd_set_error (bfd_error_malformed_archive
);
2906 raw_armap
= (char *) _bfd_alloc_and_read (abfd
, parsed_size
+ 1, parsed_size
);
2907 if (raw_armap
== NULL
)
2909 raw_armap
[parsed_size
] = 0;
2911 ardata
->tdata
= (void *) raw_armap
;
2913 count
= H_GET_32 (abfd
, raw_armap
);
2914 if ((parsed_size
- 8) / 8 < count
)
2915 goto error_malformed
;
2917 ardata
->symdef_count
= 0;
2918 ardata
->cache
= NULL
;
2920 /* This code used to overlay the symdefs over the raw archive data,
2921 but that doesn't work on a 64 bit host. */
2922 stringbase
= raw_armap
+ count
* 8 + 8;
2923 stringsize
= parsed_size
- (count
* 8 + 8);
2925 #ifdef CHECK_ARMAP_HASH
2929 /* Double check that I have the hashing algorithm right by making
2930 sure that every symbol can be looked up successfully. */
2932 for (i
= 1; i
< count
; i
<<= 1)
2934 BFD_ASSERT (i
== count
);
2936 raw_ptr
= raw_armap
+ 4;
2937 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2939 unsigned int name_offset
, file_offset
;
2940 unsigned int hash
, rehash
, srch
;
2942 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2943 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2944 if (file_offset
== 0)
2946 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
2951 /* See if we can rehash to this location. */
2952 for (srch
= (hash
+ rehash
) & (count
- 1);
2953 srch
!= hash
&& srch
!= i
;
2954 srch
= (srch
+ rehash
) & (count
- 1))
2955 BFD_ASSERT (H_GET_32 (abfd
, (raw_armap
+ 8 + srch
* 8)) != 0);
2956 BFD_ASSERT (srch
== i
);
2960 #endif /* CHECK_ARMAP_HASH */
2962 raw_ptr
= raw_armap
+ 4;
2963 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2964 if (H_GET_32 (abfd
, (raw_ptr
+ 4)) != 0)
2965 ++ardata
->symdef_count
;
2967 amt
= ardata
->symdef_count
;
2968 amt
*= sizeof (carsym
);
2969 symdef_ptr
= (carsym
*) bfd_alloc (abfd
, amt
);
2973 ardata
->symdefs
= symdef_ptr
;
2975 raw_ptr
= raw_armap
+ 4;
2976 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
2978 unsigned int name_offset
, file_offset
;
2980 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
2981 if (file_offset
== 0)
2983 name_offset
= H_GET_32 (abfd
, raw_ptr
);
2984 if (name_offset
> stringsize
)
2985 goto error_malformed
;
2986 symdef_ptr
->name
= stringbase
+ name_offset
;
2987 symdef_ptr
->file_offset
= file_offset
;
2991 ardata
->first_file_filepos
= bfd_tell (abfd
);
2992 /* Pad to an even boundary. */
2993 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
2994 abfd
->has_armap
= TRUE
;
2998 bfd_set_error (bfd_error_malformed_archive
);
3000 ardata
->symdef_count
= 0;
3001 ardata
->symdefs
= NULL
;
3002 ardata
->tdata
= NULL
;
3003 bfd_release (abfd
, raw_armap
);
3007 /* Write out an armap. */
3010 _bfd_ecoff_write_armap (bfd
*abfd
,
3011 unsigned int elength
,
3013 unsigned int orl_count
,
3016 unsigned int hashsize
, hashlog
;
3017 bfd_size_type symdefsize
;
3019 unsigned int stringsize
;
3020 unsigned int mapsize
;
3023 struct stat statbuf
;
3026 bfd_byte
*hashtable
;
3030 /* Ultrix appears to use as a hash table size the least power of two
3031 greater than twice the number of entries. */
3032 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3034 hashsize
= 1 << hashlog
;
3036 symdefsize
= hashsize
* 8;
3038 stringsize
= stridx
+ padit
;
3040 /* Include 8 bytes to store symdefsize and stringsize in output. */
3041 mapsize
= symdefsize
+ stringsize
+ 8;
3043 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3045 memset ((void *) &hdr
, 0, sizeof hdr
);
3047 /* Work out the ECOFF armap name. */
3048 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3049 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3050 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3051 (bfd_header_big_endian (abfd
)
3053 : ARMAP_LITTLE_ENDIAN
);
3054 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3055 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3056 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3057 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3059 /* Write the timestamp of the archive header to be just a little bit
3060 later than the timestamp of the file, otherwise the linker will
3061 complain that the index is out of date. Actually, the Ultrix
3062 linker just checks the archive name; the GNU linker may check the
3064 stat (bfd_get_filename (abfd
), &statbuf
);
3065 _bfd_ar_spacepad (hdr
.ar_date
, sizeof (hdr
.ar_date
), "%ld",
3066 (long) (statbuf
.st_mtime
+ 60));
3068 /* The DECstation uses zeroes for the uid, gid and mode of the
3070 hdr
.ar_uid
[0] = '0';
3071 hdr
.ar_gid
[0] = '0';
3072 /* Building gcc ends up extracting the armap as a file - twice. */
3073 hdr
.ar_mode
[0] = '6';
3074 hdr
.ar_mode
[1] = '4';
3075 hdr
.ar_mode
[2] = '4';
3077 _bfd_ar_spacepad (hdr
.ar_size
, sizeof (hdr
.ar_size
), "%-10ld", mapsize
);
3079 hdr
.ar_fmag
[0] = '`';
3080 hdr
.ar_fmag
[1] = '\012';
3082 /* Turn all null bytes in the header into spaces. */
3083 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3084 if (((char *) (&hdr
))[i
] == '\0')
3085 (((char *) (&hdr
))[i
]) = ' ';
3087 if (bfd_bwrite ((void *) &hdr
, (bfd_size_type
) sizeof (struct ar_hdr
), abfd
)
3088 != sizeof (struct ar_hdr
))
3091 H_PUT_32 (abfd
, hashsize
, temp
);
3092 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3095 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3099 current
= abfd
->archive_head
;
3101 for (i
= 0; i
< orl_count
; i
++)
3103 unsigned int hash
, rehash
= 0;
3105 /* Advance firstreal to the file position of this archive
3107 if (map
[i
].u
.abfd
!= last_elt
)
3111 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3112 firstreal
+= firstreal
% 2;
3113 current
= current
->archive_next
;
3115 while (current
!= map
[i
].u
.abfd
);
3120 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3121 if (H_GET_32 (abfd
, (hashtable
+ (hash
* 8) + 4)) != 0)
3125 /* The desired slot is already taken. */
3126 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3128 srch
= (srch
+ rehash
) & (hashsize
- 1))
3129 if (H_GET_32 (abfd
, (hashtable
+ (srch
* 8) + 4)) == 0)
3132 BFD_ASSERT (srch
!= hash
);
3137 H_PUT_32 (abfd
, map
[i
].namidx
, (hashtable
+ hash
* 8));
3138 H_PUT_32 (abfd
, firstreal
, (hashtable
+ hash
* 8 + 4));
3141 if (bfd_bwrite ((void *) hashtable
, symdefsize
, abfd
) != symdefsize
)
3144 bfd_release (abfd
, hashtable
);
3146 /* Now write the strings. */
3147 H_PUT_32 (abfd
, stringsize
, temp
);
3148 if (bfd_bwrite ((void *) temp
, (bfd_size_type
) 4, abfd
) != 4)
3150 for (i
= 0; i
< orl_count
; i
++)
3154 len
= strlen (*map
[i
].name
) + 1;
3155 if (bfd_bwrite ((void *) (*map
[i
].name
), len
, abfd
) != len
)
3159 /* The spec sez this should be a newline. But in order to be
3160 bug-compatible for DECstation ar we use a null. */
3163 if (bfd_bwrite ("", (bfd_size_type
) 1, abfd
) != 1)
3170 /* ECOFF linker code. */
3172 /* Routine to create an entry in an ECOFF link hash table. */
3174 static struct bfd_hash_entry
*
3175 ecoff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
3176 struct bfd_hash_table
*table
,
3179 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3181 /* Allocate the structure if it has not already been allocated by a
3184 ret
= ((struct ecoff_link_hash_entry
*)
3185 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3189 /* Call the allocation method of the superclass. */
3190 ret
= ((struct ecoff_link_hash_entry
*)
3191 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3196 /* Set local fields. */
3202 memset ((void *) &ret
->esym
, 0, sizeof ret
->esym
);
3204 return (struct bfd_hash_entry
*) ret
;
3207 /* Create an ECOFF link hash table. */
3209 struct bfd_link_hash_table
*
3210 _bfd_ecoff_bfd_link_hash_table_create (bfd
*abfd
)
3212 struct ecoff_link_hash_table
*ret
;
3213 size_t amt
= sizeof (struct ecoff_link_hash_table
);
3215 ret
= (struct ecoff_link_hash_table
*) bfd_malloc (amt
);
3218 if (!_bfd_link_hash_table_init (&ret
->root
, abfd
,
3219 ecoff_link_hash_newfunc
,
3220 sizeof (struct ecoff_link_hash_entry
)))
3228 /* Look up an entry in an ECOFF link hash table. */
3230 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3231 ((struct ecoff_link_hash_entry *) \
3232 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3234 /* Get the ECOFF link hash table from the info structure. This is
3237 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3239 /* Add the external symbols of an object file to the global linker
3240 hash table. The external symbols and strings we are passed are
3241 just allocated on the stack, and will be discarded. We must
3242 explicitly save any information we may need later on in the link.
3243 We do not want to read the external symbol information again. */
3246 ecoff_link_add_externals (bfd
*abfd
,
3247 struct bfd_link_info
*info
,
3248 void * external_ext
,
3251 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3252 void (* const swap_ext_in
) (bfd
*, void *, EXTR
*)
3253 = backend
->debug_swap
.swap_ext_in
;
3254 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3255 unsigned long ext_count
;
3256 struct bfd_link_hash_entry
**sym_hash
;
3261 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3264 amt
*= sizeof (struct bfd_link_hash_entry
*);
3265 sym_hash
= (struct bfd_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3268 ecoff_data (abfd
)->sym_hashes
= (struct ecoff_link_hash_entry
**) sym_hash
;
3270 ext_ptr
= (char *) external_ext
;
3271 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3272 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3279 struct ecoff_link_hash_entry
*h
;
3283 (*swap_ext_in
) (abfd
, (void *) ext_ptr
, &esym
);
3285 /* Skip debugging symbols. */
3287 switch (esym
.asym
.st
)
3303 /* Get the information for this symbol. */
3304 value
= esym
.asym
.value
;
3305 switch (esym
.asym
.sc
)
3325 section
= bfd_make_section_old_way (abfd
, _TEXT
);
3326 value
-= section
->vma
;
3329 section
= bfd_make_section_old_way (abfd
, _DATA
);
3330 value
-= section
->vma
;
3333 section
= bfd_make_section_old_way (abfd
, _BSS
);
3334 value
-= section
->vma
;
3337 section
= bfd_abs_section_ptr
;
3340 section
= bfd_und_section_ptr
;
3343 section
= bfd_make_section_old_way (abfd
, _SDATA
);
3344 value
-= section
->vma
;
3347 section
= bfd_make_section_old_way (abfd
, _SBSS
);
3348 value
-= section
->vma
;
3351 section
= bfd_make_section_old_way (abfd
, _RDATA
);
3352 value
-= section
->vma
;
3355 if (value
> ecoff_data (abfd
)->gp_size
)
3357 section
= bfd_com_section_ptr
;
3362 section
= &ecoff_scom_section
;
3365 section
= bfd_und_section_ptr
;
3368 section
= bfd_make_section_old_way (abfd
, _INIT
);
3369 value
-= section
->vma
;
3372 section
= bfd_make_section_old_way (abfd
, _FINI
);
3373 value
-= section
->vma
;
3376 section
= bfd_make_section_old_way (abfd
, _RCONST
);
3377 value
-= section
->vma
;
3381 if (section
== NULL
)
3384 name
= ssext
+ esym
.asym
.iss
;
3386 if (! (_bfd_generic_link_add_one_symbol
3388 (flagword
) (esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
),
3389 section
, value
, NULL
, TRUE
, TRUE
, sym_hash
)))
3392 h
= (struct ecoff_link_hash_entry
*) *sym_hash
;
3394 /* If we are building an ECOFF hash table, save the external
3395 symbol information. */
3396 if (bfd_get_flavour (info
->output_bfd
) == bfd_get_flavour (abfd
))
3399 || (! bfd_is_und_section (section
)
3400 && (! bfd_is_com_section (section
)
3401 || (h
->root
.type
!= bfd_link_hash_defined
3402 && h
->root
.type
!= bfd_link_hash_defweak
))))
3408 /* Remember whether this symbol was small undefined. */
3409 if (esym
.asym
.sc
== scSUndefined
)
3412 /* If this symbol was ever small undefined, it needs to wind
3413 up in a GP relative section. We can't control the
3414 section of a defined symbol, but we can control the
3415 section of a common symbol. This case is actually needed
3416 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
3418 && h
->root
.type
== bfd_link_hash_common
3419 && streq (h
->root
.u
.c
.p
->section
->name
, SCOMMON
))
3421 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
3423 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
3424 if (h
->esym
.asym
.sc
== scCommon
)
3425 h
->esym
.asym
.sc
= scSCommon
;
3433 /* Add symbols from an ECOFF object file to the global linker hash
3437 ecoff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3440 bfd_size_type external_ext_size
;
3441 void * external_ext
= NULL
;
3442 bfd_size_type esize
;
3446 if (! ecoff_slurp_symbolic_header (abfd
))
3449 /* If there are no symbols, we don't want it. */
3450 if (bfd_get_symcount (abfd
) == 0)
3453 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3455 /* Read in the external symbols and external strings. */
3456 if (bfd_seek (abfd
, symhdr
->cbExtOffset
, SEEK_SET
) != 0)
3458 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3459 esize
= symhdr
->iextMax
* external_ext_size
;
3460 external_ext
= _bfd_malloc_and_read (abfd
, esize
, esize
);
3461 if (external_ext
== NULL
&& esize
!= 0)
3464 if (bfd_seek (abfd
, symhdr
->cbSsExtOffset
, SEEK_SET
) != 0)
3466 ssext
= (char *) _bfd_malloc_and_read (abfd
, symhdr
->issExtMax
,
3468 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3471 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3474 free (external_ext
);
3479 free (external_ext
);
3483 /* This is called if we used _bfd_generic_link_add_archive_symbols
3484 because we were not dealing with an ECOFF archive. */
3487 ecoff_link_check_archive_element (bfd
*abfd
,
3488 struct bfd_link_info
*info
,
3489 struct bfd_link_hash_entry
*h
,
3491 bfd_boolean
*pneeded
)
3495 /* Unlike the generic linker, we do not pull in elements because
3496 of common symbols. */
3497 if (h
->type
!= bfd_link_hash_undefined
)
3500 /* Include this element? */
3501 if (!(*info
->callbacks
->add_archive_element
) (info
, abfd
, name
, &abfd
))
3505 return ecoff_link_add_object_symbols (abfd
, info
);
3508 /* Add the symbols from an archive file to the global hash table.
3509 This looks through the undefined symbols, looks each one up in the
3510 archive hash table, and adds any associated object file. We do not
3511 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3512 already have a hash table, so there is no reason to construct
3516 ecoff_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3518 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3519 const bfd_byte
*raw_armap
;
3520 struct bfd_link_hash_entry
**pundef
;
3521 unsigned int armap_count
;
3522 unsigned int armap_log
;
3524 const bfd_byte
*hashtable
;
3525 const char *stringbase
;
3527 if (! bfd_has_map (abfd
))
3529 /* An empty archive is a special case. */
3530 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
3532 bfd_set_error (bfd_error_no_armap
);
3536 /* If we don't have any raw data for this archive, as can happen on
3537 Irix 4.0.5F, we call the generic routine.
3538 FIXME: We should be more clever about this, since someday tdata
3539 may get to something for a generic archive. */
3540 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3541 if (raw_armap
== NULL
)
3542 return (_bfd_generic_link_add_archive_symbols
3543 (abfd
, info
, ecoff_link_check_archive_element
));
3545 armap_count
= H_GET_32 (abfd
, raw_armap
);
3548 for (i
= 1; i
< armap_count
; i
<<= 1)
3550 BFD_ASSERT (i
== armap_count
);
3552 hashtable
= raw_armap
+ 4;
3553 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3555 /* Look through the list of undefined symbols. */
3556 pundef
= &info
->hash
->undefs
;
3557 while (*pundef
!= NULL
)
3559 struct bfd_link_hash_entry
*h
;
3560 unsigned int hash
, rehash
= 0;
3561 unsigned int file_offset
;
3567 /* When a symbol is defined, it is not necessarily removed from
3569 if (h
->type
!= bfd_link_hash_undefined
3570 && h
->type
!= bfd_link_hash_common
)
3572 /* Remove this entry from the list, for general cleanliness
3573 and because we are going to look through the list again
3574 if we search any more libraries. We can't remove the
3575 entry if it is the tail, because that would lose any
3576 entries we add to the list later on. */
3577 if (*pundef
!= info
->hash
->undefs_tail
)
3578 *pundef
= (*pundef
)->u
.undef
.next
;
3580 pundef
= &(*pundef
)->u
.undef
.next
;
3584 /* Native ECOFF linkers do not pull in archive elements merely
3585 to satisfy common definitions, so neither do we. We leave
3586 them on the list, though, in case we are linking against some
3587 other object format. */
3588 if (h
->type
!= bfd_link_hash_undefined
)
3590 pundef
= &(*pundef
)->u
.undef
.next
;
3594 /* Look for this symbol in the archive hash table. */
3595 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3598 file_offset
= H_GET_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3599 if (file_offset
== 0)
3601 /* Nothing in this slot. */
3602 pundef
= &(*pundef
)->u
.undef
.next
;
3606 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (hash
* 8));
3607 if (name
[0] != h
->root
.string
[0]
3608 || ! streq (name
, h
->root
.string
))
3613 /* That was the wrong symbol. Try rehashing. */
3615 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3617 srch
= (srch
+ rehash
) & (armap_count
- 1))
3619 file_offset
= H_GET_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3620 if (file_offset
== 0)
3622 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (srch
* 8));
3623 if (name
[0] == h
->root
.string
[0]
3624 && streq (name
, h
->root
.string
))
3633 pundef
= &(*pundef
)->u
.undef
.next
;
3640 element
= (*backend
->get_elt_at_filepos
) (abfd
, (file_ptr
) file_offset
);
3641 if (element
== NULL
)
3644 if (! bfd_check_format (element
, bfd_object
))
3647 /* Unlike the generic linker, we know that this element provides
3648 a definition for an undefined symbol and we know that we want
3649 to include it. We don't need to check anything. */
3650 if (!(*info
->callbacks
3651 ->add_archive_element
) (info
, element
, name
, &element
))
3653 if (! ecoff_link_add_object_symbols (element
, info
))
3656 pundef
= &(*pundef
)->u
.undef
.next
;
3662 /* Given an ECOFF BFD, add symbols to the global hash table as
3666 _bfd_ecoff_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3668 switch (bfd_get_format (abfd
))
3671 return ecoff_link_add_object_symbols (abfd
, info
);
3673 return ecoff_link_add_archive_symbols (abfd
, info
);
3675 bfd_set_error (bfd_error_wrong_format
);
3681 /* ECOFF final link routines. */
3683 /* Structure used to pass information to ecoff_link_write_external. */
3688 struct bfd_link_info
*info
;
3691 /* Accumulate the debugging information for an input BFD into the
3692 output BFD. This must read in the symbolic information of the
3696 ecoff_final_link_debug_accumulate (bfd
*output_bfd
,
3698 struct bfd_link_info
*info
,
3701 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
3702 const struct ecoff_debug_swap
* const swap
=
3703 &ecoff_backend (input_bfd
)->debug_swap
;
3704 HDRR
*symhdr
= &debug
->symbolic_header
;
3707 #define READ(ptr, offset, count, size, type) \
3711 debug->ptr = NULL; \
3712 if (symhdr->count == 0) \
3714 if (_bfd_mul_overflow (size, symhdr->count, &amt)) \
3716 bfd_set_error (bfd_error_file_too_big); \
3718 goto return_something; \
3720 if (bfd_seek (input_bfd, symhdr->offset, SEEK_SET) != 0) \
3723 goto return_something; \
3725 debug->ptr = (type) _bfd_malloc_and_read (input_bfd, amt, amt); \
3726 if (debug->ptr == NULL) \
3729 goto return_something; \
3733 /* If raw_syments is not NULL, then the data was already by read by
3734 _bfd_ecoff_slurp_symbolic_info. */
3735 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3737 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
3739 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
3740 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
3741 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
3742 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
3743 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3745 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3746 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
3747 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
3751 /* We do not read the external strings or the external symbols. */
3753 ret
= (bfd_ecoff_debug_accumulate
3754 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
3755 &ecoff_backend (output_bfd
)->debug_swap
,
3756 input_bfd
, debug
, swap
, info
));
3759 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
3762 free (debug
->external_dnr
);
3763 free (debug
->external_pdr
);
3764 free (debug
->external_sym
);
3765 free (debug
->external_opt
);
3766 free (debug
->external_aux
);
3768 free (debug
->external_fdr
);
3769 free (debug
->external_rfd
);
3771 /* Make sure we don't accidentally follow one of these pointers
3772 into freed memory. */
3774 debug
->external_dnr
= NULL
;
3775 debug
->external_pdr
= NULL
;
3776 debug
->external_sym
= NULL
;
3777 debug
->external_opt
= NULL
;
3778 debug
->external_aux
= NULL
;
3780 debug
->external_fdr
= NULL
;
3781 debug
->external_rfd
= NULL
;
3787 /* Relocate and write an ECOFF section into an ECOFF output file. */
3790 ecoff_indirect_link_order (bfd
*output_bfd
,
3791 struct bfd_link_info
*info
,
3792 asection
*output_section
,
3793 struct bfd_link_order
*link_order
)
3795 asection
*input_section
;
3797 bfd_byte
*contents
= NULL
;
3798 bfd_size_type external_reloc_size
;
3799 bfd_size_type external_relocs_size
;
3800 void * external_relocs
= NULL
;
3802 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
3804 input_section
= link_order
->u
.indirect
.section
;
3805 input_bfd
= input_section
->owner
;
3806 if (input_section
->size
== 0)
3809 BFD_ASSERT (input_section
->output_section
== output_section
);
3810 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
3811 BFD_ASSERT (input_section
->size
== link_order
->size
);
3813 /* Get the section contents. */
3814 if (!bfd_malloc_and_get_section (input_bfd
, input_section
, &contents
))
3817 /* Get the relocs. If we are relaxing MIPS code, they will already
3818 have been read in. Otherwise, we read them in now. */
3819 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
3820 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
3822 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0)
3824 external_relocs
= _bfd_malloc_and_read (input_bfd
, external_relocs_size
,
3825 external_relocs_size
);
3826 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
3829 /* Relocate the section contents. */
3830 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
3831 (output_bfd
, info
, input_bfd
, input_section
, contents
,
3835 /* Write out the relocated section. */
3836 if (! bfd_set_section_contents (output_bfd
,
3839 input_section
->output_offset
,
3840 input_section
->size
))
3843 /* If we are producing relocatable output, the relocs were
3844 modified, and we write them out now. We use the reloc_count
3845 field of output_section to keep track of the number of relocs we
3846 have output so far. */
3847 if (bfd_link_relocatable (info
))
3849 file_ptr pos
= (output_section
->rel_filepos
3850 + output_section
->reloc_count
* external_reloc_size
);
3851 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
3852 || (bfd_bwrite (external_relocs
, external_relocs_size
, output_bfd
)
3853 != external_relocs_size
))
3855 output_section
->reloc_count
+= input_section
->reloc_count
;
3859 free (external_relocs
);
3864 free (external_relocs
);
3868 /* Generate a reloc when linking an ECOFF file. This is a reloc
3869 requested by the linker, and does come from any input file. This
3870 is used to build constructor and destructor tables when linking
3874 ecoff_reloc_link_order (bfd
*output_bfd
,
3875 struct bfd_link_info
*info
,
3876 asection
*output_section
,
3877 struct bfd_link_order
*link_order
)
3879 enum bfd_link_order_type type
;
3883 struct internal_reloc in
;
3884 bfd_size_type external_reloc_size
;
3889 type
= link_order
->type
;
3891 addend
= link_order
->u
.reloc
.p
->addend
;
3893 /* We set up an arelent to pass to the backend adjust_reloc_out
3895 rel
.address
= link_order
->offset
;
3897 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3900 bfd_set_error (bfd_error_bad_value
);
3904 if (type
== bfd_section_reloc_link_order
)
3906 section
= link_order
->u
.reloc
.p
->u
.section
;
3907 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
3911 struct bfd_link_hash_entry
*h
;
3913 /* Treat a reloc against a defined symbol as though it were
3914 actually against the section. */
3915 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3916 link_order
->u
.reloc
.p
->u
.name
,
3917 FALSE
, FALSE
, FALSE
);
3919 && (h
->type
== bfd_link_hash_defined
3920 || h
->type
== bfd_link_hash_defweak
))
3922 type
= bfd_section_reloc_link_order
;
3923 section
= h
->u
.def
.section
->output_section
;
3924 /* It seems that we ought to add the symbol value to the
3925 addend here, but in practice it has already been added
3926 because it was passed to constructor_callback. */
3927 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
3931 /* We can't set up a reloc against a symbol correctly,
3932 because we have no asymbol structure. Currently no
3933 adjust_reloc_out routine cares. */
3934 rel
.sym_ptr_ptr
= NULL
;
3938 /* All ECOFF relocs are in-place. Put the addend into the object
3941 BFD_ASSERT (rel
.howto
->partial_inplace
);
3945 bfd_reloc_status_type rstat
;
3948 size
= bfd_get_reloc_size (rel
.howto
);
3949 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3950 if (buf
== NULL
&& size
!= 0)
3952 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
3953 (bfd_vma
) addend
, buf
);
3959 case bfd_reloc_outofrange
:
3961 case bfd_reloc_overflow
:
3962 (*info
->callbacks
->reloc_overflow
)
3964 (link_order
->type
== bfd_section_reloc_link_order
3965 ? bfd_section_name (section
)
3966 : link_order
->u
.reloc
.p
->u
.name
),
3967 rel
.howto
->name
, addend
, NULL
, NULL
, (bfd_vma
) 0);
3970 ok
= bfd_set_section_contents (output_bfd
, output_section
, (void *) buf
,
3971 (file_ptr
) link_order
->offset
, size
);
3979 /* Move the information into an internal_reloc structure. */
3980 in
.r_vaddr
= rel
.address
+ bfd_section_vma (output_section
);
3981 in
.r_type
= rel
.howto
->type
;
3983 if (type
== bfd_symbol_reloc_link_order
)
3985 struct ecoff_link_hash_entry
*h
;
3987 h
= ((struct ecoff_link_hash_entry
*)
3988 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3989 link_order
->u
.reloc
.p
->u
.name
,
3990 FALSE
, FALSE
, TRUE
));
3993 in
.r_symndx
= h
->indx
;
3996 (*info
->callbacks
->unattached_reloc
)
3997 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, (bfd_vma
) 0);
4013 { _TEXT
, RELOC_SECTION_TEXT
},
4014 { _RDATA
, RELOC_SECTION_RDATA
},
4015 { _DATA
, RELOC_SECTION_DATA
},
4016 { _SDATA
, RELOC_SECTION_SDATA
},
4017 { _SBSS
, RELOC_SECTION_SBSS
},
4018 { _BSS
, RELOC_SECTION_BSS
},
4019 { _INIT
, RELOC_SECTION_INIT
},
4020 { _LIT8
, RELOC_SECTION_LIT8
},
4021 { _LIT4
, RELOC_SECTION_LIT4
},
4022 { _XDATA
, RELOC_SECTION_XDATA
},
4023 { _PDATA
, RELOC_SECTION_PDATA
},
4024 { _FINI
, RELOC_SECTION_FINI
},
4025 { _LITA
, RELOC_SECTION_LITA
},
4026 { "*ABS*", RELOC_SECTION_ABS
},
4027 { _RCONST
, RELOC_SECTION_RCONST
}
4030 name
= bfd_section_name (section
);
4032 for (i
= 0; i
< ARRAY_SIZE (section_symndx
); i
++)
4033 if (streq (name
, section_symndx
[i
].name
))
4035 in
.r_symndx
= section_symndx
[i
].r_symndx
;
4039 if (i
== ARRAY_SIZE (section_symndx
))
4045 /* Let the BFD backend adjust the reloc. */
4046 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4048 /* Get some memory and swap out the reloc. */
4049 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4050 rbuf
= (bfd_byte
*) bfd_malloc (external_reloc_size
);
4054 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (void *) rbuf
);
4056 pos
= (output_section
->rel_filepos
4057 + output_section
->reloc_count
* external_reloc_size
);
4058 ok
= (bfd_seek (output_bfd
, pos
, SEEK_SET
) == 0
4059 && (bfd_bwrite ((void *) rbuf
, external_reloc_size
, output_bfd
)
4060 == external_reloc_size
));
4063 ++output_section
->reloc_count
;
4070 /* Put out information for an external symbol. These come only from
4074 ecoff_link_write_external (struct bfd_hash_entry
*bh
, void * data
)
4076 struct ecoff_link_hash_entry
*h
= (struct ecoff_link_hash_entry
*) bh
;
4077 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4078 bfd
*output_bfd
= einfo
->abfd
;
4081 if (h
->root
.type
== bfd_link_hash_warning
)
4083 h
= (struct ecoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4084 if (h
->root
.type
== bfd_link_hash_new
)
4088 /* We need to check if this symbol is being stripped. */
4089 if (h
->root
.type
== bfd_link_hash_undefined
4090 || h
->root
.type
== bfd_link_hash_undefweak
)
4092 else if (einfo
->info
->strip
== strip_all
4093 || (einfo
->info
->strip
== strip_some
4094 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4095 h
->root
.root
.string
,
4096 FALSE
, FALSE
) == NULL
))
4101 if (strip
|| h
->written
)
4104 if (h
->abfd
== NULL
)
4107 h
->esym
.cobol_main
= 0;
4108 h
->esym
.weakext
= 0;
4109 h
->esym
.reserved
= 0;
4110 h
->esym
.ifd
= ifdNil
;
4111 h
->esym
.asym
.value
= 0;
4112 h
->esym
.asym
.st
= stGlobal
;
4114 if (h
->root
.type
!= bfd_link_hash_defined
4115 && h
->root
.type
!= bfd_link_hash_defweak
)
4116 h
->esym
.asym
.sc
= scAbs
;
4119 asection
*output_section
;
4127 section_storage_classes
[] =
4131 { _SDATA
, scSData
},
4132 { _RDATA
, scRData
},
4137 { _PDATA
, scPData
},
4138 { _XDATA
, scXData
},
4139 { _RCONST
, scRConst
}
4142 output_section
= h
->root
.u
.def
.section
->output_section
;
4143 name
= bfd_section_name (output_section
);
4145 for (i
= 0; i
< ARRAY_SIZE (section_storage_classes
); i
++)
4146 if (streq (name
, section_storage_classes
[i
].name
))
4148 h
->esym
.asym
.sc
= section_storage_classes
[i
].sc
;
4152 if (i
== ARRAY_SIZE (section_storage_classes
))
4153 h
->esym
.asym
.sc
= scAbs
;
4156 h
->esym
.asym
.reserved
= 0;
4157 h
->esym
.asym
.index
= indexNil
;
4159 else if (h
->esym
.ifd
!= -1)
4161 struct ecoff_debug_info
*debug
;
4163 /* Adjust the FDR index for the symbol by that used for the
4165 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4166 BFD_ASSERT (h
->esym
.ifd
>= 0
4167 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4168 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4171 switch (h
->root
.type
)
4174 case bfd_link_hash_warning
:
4175 case bfd_link_hash_new
:
4177 case bfd_link_hash_undefined
:
4178 case bfd_link_hash_undefweak
:
4179 if (h
->esym
.asym
.sc
!= scUndefined
4180 && h
->esym
.asym
.sc
!= scSUndefined
)
4181 h
->esym
.asym
.sc
= scUndefined
;
4183 case bfd_link_hash_defined
:
4184 case bfd_link_hash_defweak
:
4185 if (h
->esym
.asym
.sc
== scUndefined
4186 || h
->esym
.asym
.sc
== scSUndefined
)
4187 h
->esym
.asym
.sc
= scAbs
;
4188 else if (h
->esym
.asym
.sc
== scCommon
)
4189 h
->esym
.asym
.sc
= scBss
;
4190 else if (h
->esym
.asym
.sc
== scSCommon
)
4191 h
->esym
.asym
.sc
= scSBss
;
4192 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4193 + h
->root
.u
.def
.section
->output_section
->vma
4194 + h
->root
.u
.def
.section
->output_offset
);
4196 case bfd_link_hash_common
:
4197 if (h
->esym
.asym
.sc
!= scCommon
4198 && h
->esym
.asym
.sc
!= scSCommon
)
4199 h
->esym
.asym
.sc
= scCommon
;
4200 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4202 case bfd_link_hash_indirect
:
4203 /* We ignore these symbols, since the indirected symbol is
4204 already in the hash table. */
4208 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4210 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4213 return (bfd_ecoff_debug_one_external
4214 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4215 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4219 /* ECOFF final link routine. This looks through all the input BFDs
4220 and gathers together all the debugging information, and then
4221 processes all the link order information. This may cause it to
4222 close and reopen some input BFDs; I'll see how bad this is. */
4225 _bfd_ecoff_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
4227 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4228 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4233 struct bfd_link_order
*p
;
4234 struct extsym_info einfo
;
4236 /* We accumulate the debugging information counts in the symbolic
4238 symhdr
= &debug
->symbolic_header
;
4240 symhdr
->ilineMax
= 0;
4244 symhdr
->isymMax
= 0;
4245 symhdr
->ioptMax
= 0;
4246 symhdr
->iauxMax
= 0;
4248 symhdr
->issExtMax
= 0;
4251 symhdr
->iextMax
= 0;
4253 /* We accumulate the debugging information itself in the debug_info
4256 debug
->external_dnr
= NULL
;
4257 debug
->external_pdr
= NULL
;
4258 debug
->external_sym
= NULL
;
4259 debug
->external_opt
= NULL
;
4260 debug
->external_aux
= NULL
;
4262 debug
->ssext
= debug
->ssext_end
= NULL
;
4263 debug
->external_fdr
= NULL
;
4264 debug
->external_rfd
= NULL
;
4265 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4267 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4271 /* Accumulate the debugging symbols from each input BFD. */
4272 for (input_bfd
= info
->input_bfds
;
4274 input_bfd
= input_bfd
->link
.next
)
4278 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4280 /* Arbitrarily set the symbolic header vstamp to the vstamp
4281 of the first object file in the link. */
4282 if (symhdr
->vstamp
== 0)
4284 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4285 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4289 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4290 debug
, &backend
->debug_swap
,
4295 /* Combine the register masks. */
4296 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4297 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4298 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4299 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4300 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4301 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4304 /* Write out the external symbols. */
4307 bfd_hash_traverse (&info
->hash
->table
, ecoff_link_write_external
, &einfo
);
4309 if (bfd_link_relocatable (info
))
4311 /* We need to make a pass over the link_orders to count up the
4312 number of relocations we will need to output, so that we know
4313 how much space they will take up. */
4314 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4317 for (p
= o
->map_head
.link_order
;
4320 if (p
->type
== bfd_indirect_link_order
)
4321 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4322 else if (p
->type
== bfd_section_reloc_link_order
4323 || p
->type
== bfd_symbol_reloc_link_order
)
4328 /* Compute the reloc and symbol file positions. */
4329 ecoff_compute_reloc_file_positions (abfd
);
4331 /* Write out the debugging information. */
4332 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4333 &backend
->debug_swap
, info
,
4334 ecoff_data (abfd
)->sym_filepos
))
4337 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4339 if (bfd_link_relocatable (info
))
4341 /* Now reset the reloc_count field of the sections in the output
4342 BFD to 0, so that we can use them to keep track of how many
4343 relocs we have output thus far. */
4344 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4348 /* Get a value for the GP register. */
4349 if (ecoff_data (abfd
)->gp
== 0)
4351 struct bfd_link_hash_entry
*h
;
4353 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
4355 && h
->type
== bfd_link_hash_defined
)
4356 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4357 + h
->u
.def
.section
->output_section
->vma
4358 + h
->u
.def
.section
->output_offset
);
4359 else if (bfd_link_relocatable (info
))
4363 /* Make up a value. */
4365 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4368 && (streq (o
->name
, _SBSS
)
4369 || streq (o
->name
, _SDATA
)
4370 || streq (o
->name
, _LIT4
)
4371 || streq (o
->name
, _LIT8
)
4372 || streq (o
->name
, _LITA
)))
4375 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4379 /* If the relocate_section function needs to do a reloc
4380 involving the GP value, it should make a reloc_dangerous
4381 callback to warn that GP is not defined. */
4385 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4387 for (p
= o
->map_head
.link_order
;
4391 if (p
->type
== bfd_indirect_link_order
4392 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4393 == bfd_target_ecoff_flavour
))
4395 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4398 else if (p
->type
== bfd_section_reloc_link_order
4399 || p
->type
== bfd_symbol_reloc_link_order
)
4401 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4406 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4412 abfd
->symcount
= symhdr
->iextMax
+ symhdr
->isymMax
;
4414 ecoff_data (abfd
)->linker
= TRUE
;