1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright 1990, 1991, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
4 Original version by Per Bothner.
5 Full support added by Ian Lance Taylor, ian@cygnus.com.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #include "aout/ranlib.h"
29 #include "aout/stab_gnu.h"
31 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
32 some other stuff which we don't want and which conflicts with stuff
35 #include "aout/aout64.h"
38 #undef obj_sym_filepos
40 #include "coff/internal.h"
42 #include "coff/symconst.h"
43 #include "coff/ecoff.h"
47 /* Prototypes for static functions. */
49 static int ecoff_get_magic
PARAMS ((bfd
*abfd
));
50 static long ecoff_sec_to_styp_flags
PARAMS ((const char *name
,
52 static boolean ecoff_slurp_symbolic_header
PARAMS ((bfd
*abfd
));
53 static boolean ecoff_set_symbol_info
PARAMS ((bfd
*abfd
, SYMR
*ecoff_sym
,
54 asymbol
*asym
, int ext
, int weak
));
55 static void ecoff_emit_aggregate
PARAMS ((bfd
*abfd
, FDR
*fdr
,
57 RNDXR
*rndx
, long isym
,
59 static char *ecoff_type_to_string
PARAMS ((bfd
*abfd
, FDR
*fdr
,
61 static boolean ecoff_slurp_reloc_table
PARAMS ((bfd
*abfd
, asection
*section
,
63 static int ecoff_sort_hdrs
PARAMS ((const PTR
, const PTR
));
64 static boolean ecoff_compute_section_file_positions
PARAMS ((bfd
*abfd
));
65 static bfd_size_type ecoff_compute_reloc_file_positions
PARAMS ((bfd
*abfd
));
66 static boolean ecoff_get_extr
PARAMS ((asymbol
*, EXTR
*));
67 static void ecoff_set_index
PARAMS ((asymbol
*, bfd_size_type
));
68 static unsigned int ecoff_armap_hash
PARAMS ((const char *s
,
73 /* This stuff is somewhat copied from coffcode.h. */
75 static asection bfd_debug_section
=
77 /* name, id, index, next, flags, user_set_vma, reloc_done, */
78 "*DEBUG*", 0, 0, NULL
, 0, 0, 0,
79 /* linker_mark, linker_has_input, gc_mark, segment_mark, */
81 /* vma, lma, _cooked_size, _raw_size, */
83 /* output_offset, output_section, alignment_power, */
85 /* relocation, orelocation, reloc_count, filepos, rel_filepos, */
87 /* line_filepos, userdata, contents, lineno, lineno_count, */
88 0, NULL
, NULL
, NULL
, 0,
89 /* entsize, comdat, moving_line_filepos, */
91 /* target_index, used_by_bfd, constructor_chain, owner, */
94 (struct symbol_cache_entry
*) NULL
,
96 (struct symbol_cache_entry
**) NULL
,
97 /* link_order_head, link_order_tail */
101 /* Create an ECOFF object. */
104 _bfd_ecoff_mkobject (abfd
)
107 bfd_size_type amt
= sizeof (ecoff_data_type
);
108 abfd
->tdata
.ecoff_obj_data
= (struct ecoff_tdata
*) bfd_zalloc (abfd
, amt
);
109 if (abfd
->tdata
.ecoff_obj_data
== NULL
)
115 /* This is a hook called by coff_real_object_p to create any backend
116 specific information. */
119 _bfd_ecoff_mkobject_hook (abfd
, filehdr
, aouthdr
)
124 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
125 struct internal_aouthdr
*internal_a
= (struct internal_aouthdr
*) aouthdr
;
126 ecoff_data_type
*ecoff
;
128 if (! _bfd_ecoff_mkobject (abfd
))
131 ecoff
= ecoff_data (abfd
);
133 ecoff
->sym_filepos
= internal_f
->f_symptr
;
135 if (internal_a
!= (struct internal_aouthdr
*) NULL
)
139 ecoff
->text_start
= internal_a
->text_start
;
140 ecoff
->text_end
= internal_a
->text_start
+ internal_a
->tsize
;
141 ecoff
->gp
= internal_a
->gp_value
;
142 ecoff
->gprmask
= internal_a
->gprmask
;
143 for (i
= 0; i
< 4; i
++)
144 ecoff
->cprmask
[i
] = internal_a
->cprmask
[i
];
145 ecoff
->fprmask
= internal_a
->fprmask
;
146 if (internal_a
->magic
== ECOFF_AOUT_ZMAGIC
)
147 abfd
->flags
|= D_PAGED
;
149 abfd
->flags
&=~ D_PAGED
;
152 /* It turns out that no special action is required by the MIPS or
153 Alpha ECOFF backends. They have different information in the
154 a.out header, but we just copy it all (e.g., gprmask, cprmask and
155 fprmask) and let the swapping routines ensure that only relevant
156 information is written out. */
161 /* Initialize a new section. */
164 _bfd_ecoff_new_section_hook (abfd
, section
)
165 bfd
*abfd ATTRIBUTE_UNUSED
;
168 section
->alignment_power
= 4;
170 if (strcmp (section
->name
, _TEXT
) == 0
171 || strcmp (section
->name
, _INIT
) == 0
172 || strcmp (section
->name
, _FINI
) == 0)
173 section
->flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
174 else if (strcmp (section
->name
, _DATA
) == 0
175 || strcmp (section
->name
, _SDATA
) == 0)
176 section
->flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
177 else if (strcmp (section
->name
, _RDATA
) == 0
178 || strcmp (section
->name
, _LIT8
) == 0
179 || strcmp (section
->name
, _LIT4
) == 0
180 || strcmp (section
->name
, _RCONST
) == 0
181 || strcmp (section
->name
, _PDATA
) == 0)
182 section
->flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
183 else if (strcmp (section
->name
, _BSS
) == 0
184 || strcmp (section
->name
, _SBSS
) == 0)
185 section
->flags
|= SEC_ALLOC
;
186 else if (strcmp (section
->name
, _LIB
) == 0)
188 /* An Irix 4 shared libary. */
189 section
->flags
|= SEC_COFF_SHARED_LIBRARY
;
192 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
193 uncertain about .init on some systems and I don't know how shared
199 /* Determine the machine architecture and type. This is called from
200 the generic COFF routines. It is the inverse of ecoff_get_magic,
201 below. This could be an ECOFF backend routine, with one version
202 for each target, but there aren't all that many ECOFF targets. */
205 _bfd_ecoff_set_arch_mach_hook (abfd
, filehdr
)
209 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
210 enum bfd_architecture arch
;
213 switch (internal_f
->f_magic
)
216 case MIPS_MAGIC_LITTLE
:
218 arch
= bfd_arch_mips
;
222 case MIPS_MAGIC_LITTLE2
:
223 case MIPS_MAGIC_BIG2
:
224 /* MIPS ISA level 2: the r6000 */
225 arch
= bfd_arch_mips
;
229 case MIPS_MAGIC_LITTLE3
:
230 case MIPS_MAGIC_BIG3
:
231 /* MIPS ISA level 3: the r4000 */
232 arch
= bfd_arch_mips
;
237 arch
= bfd_arch_alpha
;
242 arch
= bfd_arch_obscure
;
247 return bfd_default_set_arch_mach (abfd
, arch
, mach
);
250 /* Get the magic number to use based on the architecture and machine.
251 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
254 ecoff_get_magic (abfd
)
259 switch (bfd_get_arch (abfd
))
262 switch (bfd_get_mach (abfd
))
267 big
= MIPS_MAGIC_BIG
;
268 little
= MIPS_MAGIC_LITTLE
;
272 big
= MIPS_MAGIC_BIG2
;
273 little
= MIPS_MAGIC_LITTLE2
;
277 big
= MIPS_MAGIC_BIG3
;
278 little
= MIPS_MAGIC_LITTLE3
;
282 return bfd_big_endian (abfd
) ? big
: little
;
293 /* Get the section s_flags to use for a section. */
296 ecoff_sec_to_styp_flags (name
, flags
)
304 if (strcmp (name
, _TEXT
) == 0)
306 else if (strcmp (name
, _DATA
) == 0)
308 else if (strcmp (name
, _SDATA
) == 0)
310 else if (strcmp (name
, _RDATA
) == 0)
312 else if (strcmp (name
, _LITA
) == 0)
314 else if (strcmp (name
, _LIT8
) == 0)
316 else if (strcmp (name
, _LIT4
) == 0)
318 else if (strcmp (name
, _BSS
) == 0)
320 else if (strcmp (name
, _SBSS
) == 0)
322 else if (strcmp (name
, _INIT
) == 0)
323 styp
= STYP_ECOFF_INIT
;
324 else if (strcmp (name
, _FINI
) == 0)
325 styp
= STYP_ECOFF_FINI
;
326 else if (strcmp (name
, _PDATA
) == 0)
328 else if (strcmp (name
, _XDATA
) == 0)
330 else if (strcmp (name
, _LIB
) == 0)
331 styp
= STYP_ECOFF_LIB
;
332 else if (strcmp (name
, _GOT
) == 0)
334 else if (strcmp (name
, _HASH
) == 0)
336 else if (strcmp (name
, _DYNAMIC
) == 0)
338 else if (strcmp (name
, _LIBLIST
) == 0)
340 else if (strcmp (name
, _RELDYN
) == 0)
342 else if (strcmp (name
, _CONFLIC
) == 0)
344 else if (strcmp (name
, _DYNSTR
) == 0)
346 else if (strcmp (name
, _DYNSYM
) == 0)
348 else if (strcmp (name
, _COMMENT
) == 0)
351 flags
&=~ SEC_NEVER_LOAD
;
353 else if (strcmp (name
, _RCONST
) == 0)
355 else if (flags
& SEC_CODE
)
357 else if (flags
& SEC_DATA
)
359 else if (flags
& SEC_READONLY
)
361 else if (flags
& SEC_LOAD
)
366 if (flags
& SEC_NEVER_LOAD
)
372 /* Get the BFD flags to use for a section. */
375 _bfd_ecoff_styp_to_sec_flags (abfd
, hdr
, name
, section
, flags_ptr
)
376 bfd
*abfd ATTRIBUTE_UNUSED
;
378 const char *name ATTRIBUTE_UNUSED
;
379 asection
*section ATTRIBUTE_UNUSED
;
380 flagword
* flags_ptr
;
382 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
383 long styp_flags
= internal_s
->s_flags
;
384 flagword sec_flags
= 0;
386 if (styp_flags
& STYP_NOLOAD
)
387 sec_flags
|= SEC_NEVER_LOAD
;
389 /* For 386 COFF, at least, an unloadable text or data section is
390 actually a shared library section. */
391 if ((styp_flags
& STYP_TEXT
)
392 || (styp_flags
& STYP_ECOFF_INIT
)
393 || (styp_flags
& STYP_ECOFF_FINI
)
394 || (styp_flags
& STYP_DYNAMIC
)
395 || (styp_flags
& STYP_LIBLIST
)
396 || (styp_flags
& STYP_RELDYN
)
397 || styp_flags
== STYP_CONFLIC
398 || (styp_flags
& STYP_DYNSTR
)
399 || (styp_flags
& STYP_DYNSYM
)
400 || (styp_flags
& STYP_HASH
))
402 if (sec_flags
& SEC_NEVER_LOAD
)
403 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
405 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
407 else if ((styp_flags
& STYP_DATA
)
408 || (styp_flags
& STYP_RDATA
)
409 || (styp_flags
& STYP_SDATA
)
410 || styp_flags
== STYP_PDATA
411 || styp_flags
== STYP_XDATA
412 || (styp_flags
& STYP_GOT
)
413 || styp_flags
== STYP_RCONST
)
415 if (sec_flags
& SEC_NEVER_LOAD
)
416 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
418 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
419 if ((styp_flags
& STYP_RDATA
)
420 || styp_flags
== STYP_PDATA
421 || styp_flags
== STYP_RCONST
)
422 sec_flags
|= SEC_READONLY
;
424 else if ((styp_flags
& STYP_BSS
)
425 || (styp_flags
& STYP_SBSS
))
426 sec_flags
|= SEC_ALLOC
;
427 else if ((styp_flags
& STYP_INFO
) || styp_flags
== STYP_COMMENT
)
428 sec_flags
|= SEC_NEVER_LOAD
;
429 else if ((styp_flags
& STYP_LITA
)
430 || (styp_flags
& STYP_LIT8
)
431 || (styp_flags
& STYP_LIT4
))
432 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
433 else if (styp_flags
& STYP_ECOFF_LIB
)
434 sec_flags
|= SEC_COFF_SHARED_LIBRARY
;
436 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
438 * flags_ptr
= sec_flags
;
442 /* Read in the symbolic header for an ECOFF object file. */
445 ecoff_slurp_symbolic_header (abfd
)
448 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
449 bfd_size_type external_hdr_size
;
451 HDRR
*internal_symhdr
;
453 /* See if we've already read it in. */
454 if (ecoff_data (abfd
)->debug_info
.symbolic_header
.magic
==
455 backend
->debug_swap
.sym_magic
)
458 /* See whether there is a symbolic header. */
459 if (ecoff_data (abfd
)->sym_filepos
== 0)
461 bfd_get_symcount (abfd
) = 0;
465 /* At this point bfd_get_symcount (abfd) holds the number of symbols
466 as read from the file header, but on ECOFF this is always the
467 size of the symbolic information header. It would be cleaner to
468 handle this when we first read the file in coffgen.c. */
469 external_hdr_size
= backend
->debug_swap
.external_hdr_size
;
470 if (bfd_get_symcount (abfd
) != external_hdr_size
)
472 bfd_set_error (bfd_error_bad_value
);
476 /* Read the symbolic information header. */
477 raw
= (PTR
) bfd_malloc (external_hdr_size
);
481 if (bfd_seek (abfd
, ecoff_data (abfd
)->sym_filepos
, SEEK_SET
) != 0
482 || bfd_bread (raw
, external_hdr_size
, abfd
) != external_hdr_size
)
484 internal_symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
485 (*backend
->debug_swap
.swap_hdr_in
) (abfd
, raw
, internal_symhdr
);
487 if (internal_symhdr
->magic
!= backend
->debug_swap
.sym_magic
)
489 bfd_set_error (bfd_error_bad_value
);
493 /* Now we can get the correct number of symbols. */
494 bfd_get_symcount (abfd
) = (internal_symhdr
->isymMax
495 + internal_symhdr
->iextMax
);
506 /* Read in and swap the important symbolic information for an ECOFF
507 object file. This is called by gdb via the read_debug_info entry
508 point in the backend structure. */
511 _bfd_ecoff_slurp_symbolic_info (abfd
, ignore
, debug
)
513 asection
*ignore ATTRIBUTE_UNUSED
;
514 struct ecoff_debug_info
*debug
;
516 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
517 HDRR
*internal_symhdr
;
518 bfd_size_type raw_base
;
519 bfd_size_type raw_size
;
521 bfd_size_type external_fdr_size
;
525 bfd_size_type raw_end
;
526 bfd_size_type cb_end
;
530 BFD_ASSERT (debug
== &ecoff_data (abfd
)->debug_info
);
532 /* Check whether we've already gotten it, and whether there's any to
534 if (ecoff_data (abfd
)->raw_syments
!= (PTR
) NULL
)
536 if (ecoff_data (abfd
)->sym_filepos
== 0)
538 bfd_get_symcount (abfd
) = 0;
542 if (! ecoff_slurp_symbolic_header (abfd
))
545 internal_symhdr
= &debug
->symbolic_header
;
547 /* Read all the symbolic information at once. */
548 raw_base
= (ecoff_data (abfd
)->sym_filepos
549 + backend
->debug_swap
.external_hdr_size
);
551 /* Alpha ecoff makes the determination of raw_size difficult. It has
552 an undocumented debug data section between the symhdr and the first
553 documented section. And the ordering of the sections varies between
554 statically and dynamically linked executables.
555 If bfd supports SEEK_END someday, this code could be simplified. */
559 #define UPDATE_RAW_END(start, count, size) \
560 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
561 if (cb_end > raw_end) \
564 UPDATE_RAW_END (cbLineOffset
, cbLine
, sizeof (unsigned char));
565 UPDATE_RAW_END (cbDnOffset
, idnMax
, backend
->debug_swap
.external_dnr_size
);
566 UPDATE_RAW_END (cbPdOffset
, ipdMax
, backend
->debug_swap
.external_pdr_size
);
567 UPDATE_RAW_END (cbSymOffset
, isymMax
, backend
->debug_swap
.external_sym_size
);
568 UPDATE_RAW_END (cbOptOffset
, ioptMax
, backend
->debug_swap
.external_opt_size
);
569 UPDATE_RAW_END (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
570 UPDATE_RAW_END (cbSsOffset
, issMax
, sizeof (char));
571 UPDATE_RAW_END (cbSsExtOffset
, issExtMax
, sizeof (char));
572 UPDATE_RAW_END (cbFdOffset
, ifdMax
, backend
->debug_swap
.external_fdr_size
);
573 UPDATE_RAW_END (cbRfdOffset
, crfd
, backend
->debug_swap
.external_rfd_size
);
574 UPDATE_RAW_END (cbExtOffset
, iextMax
, backend
->debug_swap
.external_ext_size
);
576 #undef UPDATE_RAW_END
578 raw_size
= raw_end
- raw_base
;
581 ecoff_data (abfd
)->sym_filepos
= 0;
584 raw
= (PTR
) bfd_alloc (abfd
, raw_size
);
588 pos
= ecoff_data (abfd
)->sym_filepos
;
589 pos
+= backend
->debug_swap
.external_hdr_size
;
590 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
591 || bfd_bread (raw
, raw_size
, abfd
) != raw_size
)
593 bfd_release (abfd
, raw
);
597 ecoff_data (abfd
)->raw_syments
= raw
;
599 /* Get pointers for the numeric offsets in the HDRR structure. */
600 #define FIX(off1, off2, type) \
601 if (internal_symhdr->off1 == 0) \
602 debug->off2 = (type) NULL; \
604 debug->off2 = (type) ((char *) raw \
605 + (internal_symhdr->off1 \
607 FIX (cbLineOffset
, line
, unsigned char *);
608 FIX (cbDnOffset
, external_dnr
, PTR
);
609 FIX (cbPdOffset
, external_pdr
, PTR
);
610 FIX (cbSymOffset
, external_sym
, PTR
);
611 FIX (cbOptOffset
, external_opt
, PTR
);
612 FIX (cbAuxOffset
, external_aux
, union aux_ext
*);
613 FIX (cbSsOffset
, ss
, char *);
614 FIX (cbSsExtOffset
, ssext
, char *);
615 FIX (cbFdOffset
, external_fdr
, PTR
);
616 FIX (cbRfdOffset
, external_rfd
, PTR
);
617 FIX (cbExtOffset
, external_ext
, PTR
);
620 /* I don't want to always swap all the data, because it will just
621 waste time and most programs will never look at it. The only
622 time the linker needs most of the debugging information swapped
623 is when linking big-endian and little-endian MIPS object files
624 together, which is not a common occurrence.
626 We need to look at the fdr to deal with a lot of information in
627 the symbols, so we swap them here. */
628 amt
= internal_symhdr
->ifdMax
;
629 amt
*= sizeof (struct fdr
);
630 debug
->fdr
= (struct fdr
*) bfd_alloc (abfd
, amt
);
631 if (debug
->fdr
== NULL
)
633 external_fdr_size
= backend
->debug_swap
.external_fdr_size
;
634 fdr_ptr
= debug
->fdr
;
635 fraw_src
= (char *) debug
->external_fdr
;
636 fraw_end
= fraw_src
+ internal_symhdr
->ifdMax
* external_fdr_size
;
637 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
638 (*backend
->debug_swap
.swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
643 /* ECOFF symbol table routines. The ECOFF symbol table is described
644 in gcc/mips-tfile.c. */
646 /* ECOFF uses two common sections. One is the usual one, and the
647 other is for small objects. All the small objects are kept
648 together, and then referenced via the gp pointer, which yields
649 faster assembler code. This is what we use for the small common
651 static asection ecoff_scom_section
;
652 static asymbol ecoff_scom_symbol
;
653 static asymbol
*ecoff_scom_symbol_ptr
;
655 /* Create an empty symbol. */
658 _bfd_ecoff_make_empty_symbol (abfd
)
661 ecoff_symbol_type
*new;
662 bfd_size_type amt
= sizeof (ecoff_symbol_type
);
664 new = (ecoff_symbol_type
*) bfd_zalloc (abfd
, amt
);
665 if (new == (ecoff_symbol_type
*) NULL
)
666 return (asymbol
*) NULL
;
667 new->symbol
.section
= (asection
*) NULL
;
668 new->fdr
= (FDR
*) NULL
;
671 new->symbol
.the_bfd
= abfd
;
675 /* Set the BFD flags and section for an ECOFF symbol. */
678 ecoff_set_symbol_info (abfd
, ecoff_sym
, asym
, ext
, weak
)
685 asym
->the_bfd
= abfd
;
686 asym
->value
= ecoff_sym
->value
;
687 asym
->section
= &bfd_debug_section
;
690 /* Most symbol types are just for debugging. */
691 switch (ecoff_sym
->st
)
700 if (ECOFF_IS_STAB (ecoff_sym
))
702 asym
->flags
= BSF_DEBUGGING
;
707 asym
->flags
= BSF_DEBUGGING
;
712 asym
->flags
= BSF_EXPORT
| BSF_WEAK
;
714 asym
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
717 asym
->flags
= BSF_LOCAL
;
718 /* Normally, a local stProc symbol will have a corresponding
719 external symbol. We mark the local symbol as a debugging
720 symbol, in order to prevent nm from printing both out.
721 Similarly, we mark stLabel and stabs symbols as debugging
722 symbols. In both cases, we do want to set the value
723 correctly based on the symbol class. */
724 if (ecoff_sym
->st
== stProc
725 || ecoff_sym
->st
== stLabel
726 || ECOFF_IS_STAB (ecoff_sym
))
727 asym
->flags
|= BSF_DEBUGGING
;
729 switch (ecoff_sym
->sc
)
732 /* Used for compiler generated labels. Leave them in the
733 debugging section, and mark them as local. If BSF_DEBUGGING
734 is set, then nm does not display them for some reason. If no
735 flags are set then the linker whines about them. */
736 asym
->flags
= BSF_LOCAL
;
739 asym
->section
= bfd_make_section_old_way (abfd
, ".text");
740 asym
->value
-= asym
->section
->vma
;
743 asym
->section
= bfd_make_section_old_way (abfd
, ".data");
744 asym
->value
-= asym
->section
->vma
;
747 asym
->section
= bfd_make_section_old_way (abfd
, ".bss");
748 asym
->value
-= asym
->section
->vma
;
751 asym
->flags
= BSF_DEBUGGING
;
754 asym
->section
= bfd_abs_section_ptr
;
757 asym
->section
= bfd_und_section_ptr
;
767 asym
->flags
= BSF_DEBUGGING
;
770 asym
->section
= bfd_make_section_old_way (abfd
, ".sdata");
771 asym
->value
-= asym
->section
->vma
;
774 asym
->section
= bfd_make_section_old_way (abfd
, ".sbss");
775 asym
->value
-= asym
->section
->vma
;
778 asym
->section
= bfd_make_section_old_way (abfd
, ".rdata");
779 asym
->value
-= asym
->section
->vma
;
782 asym
->flags
= BSF_DEBUGGING
;
785 if (asym
->value
> ecoff_data (abfd
)->gp_size
)
787 asym
->section
= bfd_com_section_ptr
;
793 if (ecoff_scom_section
.name
== NULL
)
795 /* Initialize the small common section. */
796 ecoff_scom_section
.name
= SCOMMON
;
797 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
798 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
799 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
800 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
801 ecoff_scom_symbol
.name
= SCOMMON
;
802 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
803 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
804 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
806 asym
->section
= &ecoff_scom_section
;
811 asym
->flags
= BSF_DEBUGGING
;
814 asym
->section
= bfd_und_section_ptr
;
819 asym
->section
= bfd_make_section_old_way (abfd
, ".init");
820 asym
->value
-= asym
->section
->vma
;
825 asym
->flags
= BSF_DEBUGGING
;
828 asym
->section
= bfd_make_section_old_way (abfd
, ".fini");
829 asym
->value
-= asym
->section
->vma
;
832 asym
->section
= bfd_make_section_old_way (abfd
, ".rconst");
833 asym
->value
-= asym
->section
->vma
;
839 /* Look for special constructors symbols and make relocation entries
840 in a special construction section. These are produced by the
841 -fgnu-linker argument to g++. */
842 if (ECOFF_IS_STAB (ecoff_sym
))
844 switch (ECOFF_UNMARK_STAB (ecoff_sym
->index
))
854 /* This code is no longer needed. It used to be used to
855 make the linker handle set symbols, but they are now
856 handled in the add_symbols routine instead. */
860 arelent_chain
*reloc_chain
;
861 unsigned int bitsize
;
864 /* Get a section with the same name as the symbol (usually
865 __CTOR_LIST__ or __DTOR_LIST__). FIXME: gcc uses the
866 name ___CTOR_LIST (three underscores). We need
867 __CTOR_LIST (two underscores), since ECOFF doesn't use
868 a leading underscore. This should be handled by gcc,
869 but instead we do it here. Actually, this should all
870 be done differently anyhow. */
871 name
= bfd_asymbol_name (asym
);
872 if (name
[0] == '_' && name
[1] == '_' && name
[2] == '_')
877 section
= bfd_get_section_by_name (abfd
, name
);
878 if (section
== (asection
*) NULL
)
882 amt
= strlen (name
) + 1;
883 copy
= (char *) bfd_alloc (abfd
, amt
);
887 section
= bfd_make_section (abfd
, copy
);
890 /* Build a reloc pointing to this constructor. */
891 amt
= sizeof (arelent_chain
);
892 reloc_chain
= (arelent_chain
*) bfd_alloc (abfd
, amt
);
895 reloc_chain
->relent
.sym_ptr_ptr
=
896 bfd_get_section (asym
)->symbol_ptr_ptr
;
897 reloc_chain
->relent
.address
= section
->_raw_size
;
898 reloc_chain
->relent
.addend
= asym
->value
;
899 reloc_chain
->relent
.howto
=
900 ecoff_backend (abfd
)->constructor_reloc
;
902 /* Set up the constructor section to hold the reloc. */
903 section
->flags
= SEC_CONSTRUCTOR
;
904 ++section
->reloc_count
;
906 /* Constructor sections must be rounded to a boundary
907 based on the bitsize. These are not real sections--
908 they are handled specially by the linker--so the ECOFF
909 16 byte alignment restriction does not apply. */
910 bitsize
= ecoff_backend (abfd
)->constructor_bitsize
;
911 section
->alignment_power
= 1;
912 while ((1 << section
->alignment_power
) < bitsize
/ 8)
913 ++section
->alignment_power
;
915 reloc_chain
->next
= section
->constructor_chain
;
916 section
->constructor_chain
= reloc_chain
;
917 section
->_raw_size
+= bitsize
/ 8;
921 /* Mark the symbol as a constructor. */
922 asym
->flags
|= BSF_CONSTRUCTOR
;
930 /* Read an ECOFF symbol table. */
933 _bfd_ecoff_slurp_symbol_table (abfd
)
936 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
937 const bfd_size_type external_ext_size
938 = backend
->debug_swap
.external_ext_size
;
939 const bfd_size_type external_sym_size
940 = backend
->debug_swap
.external_sym_size
;
941 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
942 = backend
->debug_swap
.swap_ext_in
;
943 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
944 = backend
->debug_swap
.swap_sym_in
;
945 bfd_size_type internal_size
;
946 ecoff_symbol_type
*internal
;
947 ecoff_symbol_type
*internal_ptr
;
953 /* If we've already read in the symbol table, do nothing. */
954 if (ecoff_data (abfd
)->canonical_symbols
!= NULL
)
957 /* Get the symbolic information. */
958 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, (asection
*) NULL
,
959 &ecoff_data (abfd
)->debug_info
))
961 if (bfd_get_symcount (abfd
) == 0)
964 internal_size
= bfd_get_symcount (abfd
);
965 internal_size
*= sizeof (ecoff_symbol_type
);
966 internal
= (ecoff_symbol_type
*) bfd_alloc (abfd
, internal_size
);
967 if (internal
== NULL
)
970 internal_ptr
= internal
;
971 eraw_src
= (char *) ecoff_data (abfd
)->debug_info
.external_ext
;
973 + (ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
974 * external_ext_size
));
975 for (; eraw_src
< eraw_end
; eraw_src
+= external_ext_size
, internal_ptr
++)
979 (*swap_ext_in
) (abfd
, (PTR
) eraw_src
, &internal_esym
);
980 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ssext
981 + internal_esym
.asym
.iss
);
982 if (!ecoff_set_symbol_info (abfd
, &internal_esym
.asym
,
983 &internal_ptr
->symbol
, 1,
984 internal_esym
.weakext
))
986 /* The alpha uses a negative ifd field for section symbols. */
987 if (internal_esym
.ifd
>= 0)
988 internal_ptr
->fdr
= (ecoff_data (abfd
)->debug_info
.fdr
989 + internal_esym
.ifd
);
991 internal_ptr
->fdr
= NULL
;
992 internal_ptr
->local
= false;
993 internal_ptr
->native
= (PTR
) eraw_src
;
996 /* The local symbols must be accessed via the fdr's, because the
997 string and aux indices are relative to the fdr information. */
998 fdr_ptr
= ecoff_data (abfd
)->debug_info
.fdr
;
999 fdr_end
= fdr_ptr
+ ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
;
1000 for (; fdr_ptr
< fdr_end
; fdr_ptr
++)
1005 lraw_src
= ((char *) ecoff_data (abfd
)->debug_info
.external_sym
1006 + fdr_ptr
->isymBase
* external_sym_size
);
1007 lraw_end
= lraw_src
+ fdr_ptr
->csym
* external_sym_size
;
1009 lraw_src
< lraw_end
;
1010 lraw_src
+= external_sym_size
, internal_ptr
++)
1014 (*swap_sym_in
) (abfd
, (PTR
) lraw_src
, &internal_sym
);
1015 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ss
1017 + internal_sym
.iss
);
1018 if (!ecoff_set_symbol_info (abfd
, &internal_sym
,
1019 &internal_ptr
->symbol
, 0, 0))
1021 internal_ptr
->fdr
= fdr_ptr
;
1022 internal_ptr
->local
= true;
1023 internal_ptr
->native
= (PTR
) lraw_src
;
1027 ecoff_data (abfd
)->canonical_symbols
= internal
;
1032 /* Return the amount of space needed for the canonical symbols. */
1035 _bfd_ecoff_get_symtab_upper_bound (abfd
)
1038 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, (asection
*) NULL
,
1039 &ecoff_data (abfd
)->debug_info
))
1042 if (bfd_get_symcount (abfd
) == 0)
1045 return (bfd_get_symcount (abfd
) + 1) * (sizeof (ecoff_symbol_type
*));
1048 /* Get the canonical symbols. */
1051 _bfd_ecoff_get_symtab (abfd
, alocation
)
1053 asymbol
**alocation
;
1055 unsigned int counter
= 0;
1056 ecoff_symbol_type
*symbase
;
1057 ecoff_symbol_type
**location
= (ecoff_symbol_type
**) alocation
;
1059 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1061 if (bfd_get_symcount (abfd
) == 0)
1064 symbase
= ecoff_data (abfd
)->canonical_symbols
;
1065 while (counter
< bfd_get_symcount (abfd
))
1067 *(location
++) = symbase
++;
1070 *location
++ = (ecoff_symbol_type
*) NULL
;
1071 return bfd_get_symcount (abfd
);
1074 /* Turn ECOFF type information into a printable string.
1075 ecoff_emit_aggregate and ecoff_type_to_string are from
1076 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1078 /* Write aggregate information to a string. */
1081 ecoff_emit_aggregate (abfd
, fdr
, string
, rndx
, isym
, which
)
1089 const struct ecoff_debug_swap
* const debug_swap
=
1090 &ecoff_backend (abfd
)->debug_swap
;
1091 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1092 unsigned int ifd
= rndx
->rfd
;
1093 unsigned int indx
= rndx
->index
;
1099 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1100 struct return type of a procedure compiled without -g. */
1101 if (ifd
== 0xffffffff
1102 || (rndx
->rfd
== 0xfff && indx
== 0))
1103 name
= "<undefined>";
1104 else if (indx
== indexNil
)
1110 if (debug_info
->external_rfd
== NULL
)
1111 fdr
= debug_info
->fdr
+ ifd
;
1116 (*debug_swap
->swap_rfd_in
) (abfd
,
1117 ((char *) debug_info
->external_rfd
1118 + ((fdr
->rfdBase
+ ifd
)
1119 * debug_swap
->external_rfd_size
)),
1121 fdr
= debug_info
->fdr
+ rfd
;
1124 indx
+= fdr
->isymBase
;
1126 (*debug_swap
->swap_sym_in
) (abfd
,
1127 ((char *) debug_info
->external_sym
1128 + indx
* debug_swap
->external_sym_size
),
1131 name
= debug_info
->ss
+ fdr
->issBase
+ sym
.iss
;
1135 "%s %s { ifd = %u, index = %lu }",
1138 + debug_info
->symbolic_header
.iextMax
));
1141 /* Convert the type information to string format. */
1144 ecoff_type_to_string (abfd
, fdr
, indx
)
1149 union aux_ext
*aux_ptr
;
1158 unsigned int basic_type
;
1161 static char buffer2
[1024];
1166 aux_ptr
= ecoff_data (abfd
)->debug_info
.external_aux
+ fdr
->iauxBase
;
1167 bigendian
= fdr
->fBigendian
;
1169 for (i
= 0; i
< 7; i
++)
1171 qualifiers
[i
].low_bound
= 0;
1172 qualifiers
[i
].high_bound
= 0;
1173 qualifiers
[i
].stride
= 0;
1176 if (AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
]) == (bfd_vma
) -1)
1177 return "-1 (no type)";
1178 _bfd_ecoff_swap_tir_in (bigendian
, &aux_ptr
[indx
++].a_ti
, &u
.ti
);
1180 basic_type
= u
.ti
.bt
;
1181 qualifiers
[0].type
= u
.ti
.tq0
;
1182 qualifiers
[1].type
= u
.ti
.tq1
;
1183 qualifiers
[2].type
= u
.ti
.tq2
;
1184 qualifiers
[3].type
= u
.ti
.tq3
;
1185 qualifiers
[4].type
= u
.ti
.tq4
;
1186 qualifiers
[5].type
= u
.ti
.tq5
;
1187 qualifiers
[6].type
= tqNil
;
1190 * Go get the basic type.
1194 case btNil
: /* undefined */
1198 case btAdr
: /* address - integer same size as pointer */
1199 strcpy (p1
, "address");
1202 case btChar
: /* character */
1203 strcpy (p1
, "char");
1206 case btUChar
: /* unsigned character */
1207 strcpy (p1
, "unsigned char");
1210 case btShort
: /* short */
1211 strcpy (p1
, "short");
1214 case btUShort
: /* unsigned short */
1215 strcpy (p1
, "unsigned short");
1218 case btInt
: /* int */
1222 case btUInt
: /* unsigned int */
1223 strcpy (p1
, "unsigned int");
1226 case btLong
: /* long */
1227 strcpy (p1
, "long");
1230 case btULong
: /* unsigned long */
1231 strcpy (p1
, "unsigned long");
1234 case btFloat
: /* float (real) */
1235 strcpy (p1
, "float");
1238 case btDouble
: /* Double (real) */
1239 strcpy (p1
, "double");
1242 /* Structures add 1-2 aux words:
1243 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1244 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1246 case btStruct
: /* Structure (Record) */
1247 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1248 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1249 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1251 indx
++; /* skip aux words */
1254 /* Unions add 1-2 aux words:
1255 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1256 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1258 case btUnion
: /* Union */
1259 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1260 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1261 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1263 indx
++; /* skip aux words */
1266 /* Enumerations add 1-2 aux words:
1267 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1268 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1270 case btEnum
: /* Enumeration */
1271 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1272 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1273 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1275 indx
++; /* skip aux words */
1278 case btTypedef
: /* defined via a typedef, isymRef points */
1279 strcpy (p1
, "typedef");
1282 case btRange
: /* subrange of int */
1283 strcpy (p1
, "subrange");
1286 case btSet
: /* pascal sets */
1290 case btComplex
: /* fortran complex */
1291 strcpy (p1
, "complex");
1294 case btDComplex
: /* fortran double complex */
1295 strcpy (p1
, "double complex");
1298 case btIndirect
: /* forward or unnamed typedef */
1299 strcpy (p1
, "forward/unamed typedef");
1302 case btFixedDec
: /* Fixed Decimal */
1303 strcpy (p1
, "fixed decimal");
1306 case btFloatDec
: /* Float Decimal */
1307 strcpy (p1
, "float decimal");
1310 case btString
: /* Varying Length Character String */
1311 strcpy (p1
, "string");
1314 case btBit
: /* Aligned Bit String */
1318 case btPicture
: /* Picture */
1319 strcpy (p1
, "picture");
1322 case btVoid
: /* Void */
1323 strcpy (p1
, "void");
1327 sprintf (p1
, _("Unknown basic type %d"), (int) basic_type
);
1331 p1
+= strlen (buffer1
);
1334 * If this is a bitfield, get the bitsize.
1340 bitsize
= AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
++]);
1341 sprintf (p1
, " : %d", bitsize
);
1342 p1
+= strlen (buffer1
);
1346 * Deal with any qualifiers.
1348 if (qualifiers
[0].type
!= tqNil
)
1351 * Snarf up any array bounds in the correct order. Arrays
1352 * store 5 successive words in the aux. table:
1353 * word 0 RNDXR to type of the bounds (ie, int)
1354 * word 1 Current file descriptor index
1356 * word 3 high bound (or -1 if [])
1357 * word 4 stride size in bits
1359 for (i
= 0; i
< 7; i
++)
1361 if (qualifiers
[i
].type
== tqArray
)
1363 qualifiers
[i
].low_bound
=
1364 AUX_GET_DNLOW (bigendian
, &aux_ptr
[indx
+2]);
1365 qualifiers
[i
].high_bound
=
1366 AUX_GET_DNHIGH (bigendian
, &aux_ptr
[indx
+3]);
1367 qualifiers
[i
].stride
=
1368 AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
+4]);
1374 * Now print out the qualifiers.
1376 for (i
= 0; i
< 6; i
++)
1378 switch (qualifiers
[i
].type
)
1385 strcpy (p2
, "ptr to ");
1386 p2
+= sizeof ("ptr to ")-1;
1390 strcpy (p2
, "volatile ");
1391 p2
+= sizeof ("volatile ")-1;
1395 strcpy (p2
, "far ");
1396 p2
+= sizeof ("far ")-1;
1400 strcpy (p2
, "func. ret. ");
1401 p2
+= sizeof ("func. ret. ");
1406 int first_array
= i
;
1409 /* Print array bounds reversed (ie, in the order the C
1410 programmer writes them). C is such a fun language.... */
1412 while (i
< 5 && qualifiers
[i
+1].type
== tqArray
)
1415 for (j
= i
; j
>= first_array
; j
--)
1417 strcpy (p2
, "array [");
1418 p2
+= sizeof ("array [")-1;
1419 if (qualifiers
[j
].low_bound
!= 0)
1421 "%ld:%ld {%ld bits}",
1422 (long) qualifiers
[j
].low_bound
,
1423 (long) qualifiers
[j
].high_bound
,
1424 (long) qualifiers
[j
].stride
);
1426 else if (qualifiers
[j
].high_bound
!= -1)
1429 (long) (qualifiers
[j
].high_bound
+ 1),
1430 (long) (qualifiers
[j
].stride
));
1433 sprintf (p2
, " {%ld bits}", (long) (qualifiers
[j
].stride
));
1436 strcpy (p2
, "] of ");
1437 p2
+= sizeof ("] of ")-1;
1445 strcpy (p2
, buffer1
);
1449 /* Return information about ECOFF symbol SYMBOL in RET. */
1452 _bfd_ecoff_get_symbol_info (abfd
, symbol
, ret
)
1453 bfd
*abfd ATTRIBUTE_UNUSED
;
1457 bfd_symbol_info (symbol
, ret
);
1460 /* Return whether this is a local label. */
1463 _bfd_ecoff_bfd_is_local_label_name (abfd
, name
)
1464 bfd
*abfd ATTRIBUTE_UNUSED
;
1467 return name
[0] == '$';
1470 /* Print information about an ECOFF symbol. */
1473 _bfd_ecoff_print_symbol (abfd
, filep
, symbol
, how
)
1477 bfd_print_symbol_type how
;
1479 const struct ecoff_debug_swap
* const debug_swap
1480 = &ecoff_backend (abfd
)->debug_swap
;
1481 FILE *file
= (FILE *)filep
;
1485 case bfd_print_symbol_name
:
1486 fprintf (file
, "%s", symbol
->name
);
1488 case bfd_print_symbol_more
:
1489 if (ecoffsymbol (symbol
)->local
)
1493 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1495 fprintf (file
, "ecoff local ");
1496 fprintf_vma (file
, (bfd_vma
) ecoff_sym
.value
);
1497 fprintf (file
, " %x %x", (unsigned) ecoff_sym
.st
,
1498 (unsigned) ecoff_sym
.sc
);
1504 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1506 fprintf (file
, "ecoff extern ");
1507 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1508 fprintf (file
, " %x %x", (unsigned) ecoff_ext
.asym
.st
,
1509 (unsigned) ecoff_ext
.asym
.sc
);
1512 case bfd_print_symbol_all
:
1513 /* Print out the symbols in a reasonable way */
1522 if (ecoffsymbol (symbol
)->local
)
1524 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1527 pos
= ((((char *) ecoffsymbol (symbol
)->native
1528 - (char *) ecoff_data (abfd
)->debug_info
.external_sym
)
1529 / debug_swap
->external_sym_size
)
1530 + ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
);
1537 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1540 pos
= (((char *) ecoffsymbol (symbol
)->native
1541 - (char *) ecoff_data (abfd
)->debug_info
.external_ext
)
1542 / debug_swap
->external_ext_size
);
1543 jmptbl
= ecoff_ext
.jmptbl
? 'j' : ' ';
1544 cobol_main
= ecoff_ext
.cobol_main
? 'c' : ' ';
1545 weakext
= ecoff_ext
.weakext
? 'w' : ' ';
1548 fprintf (file
, "[%3d] %c ",
1550 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1551 fprintf (file
, " st %x sc %x indx %x %c%c%c %s",
1552 (unsigned) ecoff_ext
.asym
.st
,
1553 (unsigned) ecoff_ext
.asym
.sc
,
1554 (unsigned) ecoff_ext
.asym
.index
,
1555 jmptbl
, cobol_main
, weakext
,
1558 if (ecoffsymbol (symbol
)->fdr
!= NULL
1559 && ecoff_ext
.asym
.index
!= indexNil
)
1564 bfd_size_type sym_base
;
1565 union aux_ext
*aux_base
;
1567 fdr
= ecoffsymbol (symbol
)->fdr
;
1568 indx
= ecoff_ext
.asym
.index
;
1570 /* sym_base is used to map the fdr relative indices which
1571 appear in the file to the position number which we are
1573 sym_base
= fdr
->isymBase
;
1574 if (ecoffsymbol (symbol
)->local
)
1576 ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
1578 /* aux_base is the start of the aux entries for this file;
1579 asym.index is an offset from this. */
1580 aux_base
= (ecoff_data (abfd
)->debug_info
.external_aux
1583 /* The aux entries are stored in host byte order; the
1584 order is indicated by a bit in the fdr. */
1585 bigendian
= fdr
->fBigendian
;
1587 /* This switch is basically from gcc/mips-tdump.c */
1588 switch (ecoff_ext
.asym
.st
)
1596 fprintf (file
, _("\n End+1 symbol: %ld"),
1597 (long) (indx
+ sym_base
));
1601 if (ecoff_ext
.asym
.sc
== scText
1602 || ecoff_ext
.asym
.sc
== scInfo
)
1603 fprintf (file
, _("\n First symbol: %ld"),
1604 (long) (indx
+ sym_base
));
1606 fprintf (file
, _("\n First symbol: %ld"),
1608 (AUX_GET_ISYM (bigendian
,
1609 &aux_base
[ecoff_ext
.asym
.index
])
1615 if (ECOFF_IS_STAB (&ecoff_ext
.asym
))
1617 else if (ecoffsymbol (symbol
)->local
)
1618 fprintf (file
, _("\n End+1 symbol: %-7ld Type: %s"),
1620 (AUX_GET_ISYM (bigendian
,
1621 &aux_base
[ecoff_ext
.asym
.index
])
1623 ecoff_type_to_string (abfd
, fdr
, indx
+ 1));
1625 fprintf (file
, _("\n Local symbol: %ld"),
1628 + (ecoff_data (abfd
)
1629 ->debug_info
.symbolic_header
.iextMax
)));
1633 fprintf (file
, _("\n struct; End+1 symbol: %ld"),
1634 (long) (indx
+ sym_base
));
1638 fprintf (file
, _("\n union; End+1 symbol: %ld"),
1639 (long) (indx
+ sym_base
));
1643 fprintf (file
, _("\n enum; End+1 symbol: %ld"),
1644 (long) (indx
+ sym_base
));
1648 if (! ECOFF_IS_STAB (&ecoff_ext
.asym
))
1649 fprintf (file
, _("\n Type: %s"),
1650 ecoff_type_to_string (abfd
, fdr
, indx
));
1659 /* Read in the relocs for a section. */
1662 ecoff_slurp_reloc_table (abfd
, section
, symbols
)
1667 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1668 arelent
*internal_relocs
;
1669 bfd_size_type external_reloc_size
;
1671 char *external_relocs
;
1675 if (section
->relocation
!= (arelent
*) NULL
1676 || section
->reloc_count
== 0
1677 || (section
->flags
& SEC_CONSTRUCTOR
) != 0)
1680 if (! _bfd_ecoff_slurp_symbol_table (abfd
))
1683 amt
= section
->reloc_count
;
1684 amt
*= sizeof (arelent
);
1685 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
1687 external_reloc_size
= backend
->external_reloc_size
;
1688 amt
= external_reloc_size
* section
->reloc_count
;
1689 external_relocs
= (char *) bfd_alloc (abfd
, amt
);
1690 if (internal_relocs
== (arelent
*) NULL
1691 || external_relocs
== (char *) NULL
)
1693 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1695 if (bfd_bread (external_relocs
, amt
, abfd
) != amt
)
1698 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1700 struct internal_reloc intern
;
1702 (*backend
->swap_reloc_in
) (abfd
,
1703 external_relocs
+ i
* external_reloc_size
,
1706 if (intern
.r_extern
)
1708 /* r_symndx is an index into the external symbols. */
1709 BFD_ASSERT (intern
.r_symndx
>= 0
1711 < (ecoff_data (abfd
)
1712 ->debug_info
.symbolic_header
.iextMax
)));
1713 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1716 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1717 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1719 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1724 const char *sec_name
;
1727 /* r_symndx is a section key. */
1728 switch (intern
.r_symndx
)
1730 case RELOC_SECTION_TEXT
: sec_name
= ".text"; break;
1731 case RELOC_SECTION_RDATA
: sec_name
= ".rdata"; break;
1732 case RELOC_SECTION_DATA
: sec_name
= ".data"; break;
1733 case RELOC_SECTION_SDATA
: sec_name
= ".sdata"; break;
1734 case RELOC_SECTION_SBSS
: sec_name
= ".sbss"; break;
1735 case RELOC_SECTION_BSS
: sec_name
= ".bss"; break;
1736 case RELOC_SECTION_INIT
: sec_name
= ".init"; break;
1737 case RELOC_SECTION_LIT8
: sec_name
= ".lit8"; break;
1738 case RELOC_SECTION_LIT4
: sec_name
= ".lit4"; break;
1739 case RELOC_SECTION_XDATA
: sec_name
= ".xdata"; break;
1740 case RELOC_SECTION_PDATA
: sec_name
= ".pdata"; break;
1741 case RELOC_SECTION_FINI
: sec_name
= ".fini"; break;
1742 case RELOC_SECTION_LITA
: sec_name
= ".lita"; break;
1743 case RELOC_SECTION_RCONST
: sec_name
= ".rconst"; break;
1747 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1748 if (sec
== (asection
*) NULL
)
1750 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1752 rptr
->addend
= - bfd_get_section_vma (abfd
, sec
);
1755 rptr
->address
= intern
.r_vaddr
- bfd_get_section_vma (abfd
, section
);
1757 /* Let the backend select the howto field and do any other
1758 required processing. */
1759 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1762 bfd_release (abfd
, external_relocs
);
1764 section
->relocation
= internal_relocs
;
1769 /* Get a canonical list of relocs. */
1772 _bfd_ecoff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
1780 if (section
->flags
& SEC_CONSTRUCTOR
)
1782 arelent_chain
*chain
;
1784 /* This section has relocs made up by us, not the file, so take
1785 them out of their chain and place them into the data area
1787 for (count
= 0, chain
= section
->constructor_chain
;
1788 count
< section
->reloc_count
;
1789 count
++, chain
= chain
->next
)
1790 *relptr
++ = &chain
->relent
;
1796 if (! ecoff_slurp_reloc_table (abfd
, section
, symbols
))
1799 tblptr
= section
->relocation
;
1801 for (count
= 0; count
< section
->reloc_count
; count
++)
1802 *relptr
++ = tblptr
++;
1805 *relptr
= (arelent
*) NULL
;
1807 return section
->reloc_count
;
1810 /* Provided a BFD, a section and an offset into the section, calculate
1811 and return the name of the source file and the line nearest to the
1815 _bfd_ecoff_find_nearest_line (abfd
, section
, ignore_symbols
, offset
,
1816 filename_ptr
, functionname_ptr
, retline_ptr
)
1819 asymbol
**ignore_symbols ATTRIBUTE_UNUSED
;
1821 const char **filename_ptr
;
1822 const char **functionname_ptr
;
1823 unsigned int *retline_ptr
;
1825 const struct ecoff_debug_swap
* const debug_swap
1826 = &ecoff_backend (abfd
)->debug_swap
;
1827 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1828 struct ecoff_find_line
*line_info
;
1830 /* Make sure we have the FDR's. */
1831 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, (asection
*) NULL
, debug_info
)
1832 || bfd_get_symcount (abfd
) == 0)
1835 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1837 bfd_size_type amt
= sizeof (struct ecoff_find_line
);
1838 ecoff_data (abfd
)->find_line_info
1839 = (struct ecoff_find_line
*) bfd_zalloc (abfd
, amt
);
1840 if (ecoff_data (abfd
)->find_line_info
== NULL
)
1843 line_info
= ecoff_data (abfd
)->find_line_info
;
1845 return _bfd_ecoff_locate_line (abfd
, section
, offset
, debug_info
,
1846 debug_swap
, line_info
, filename_ptr
,
1847 functionname_ptr
, retline_ptr
);
1850 /* Copy private BFD data. This is called by objcopy and strip. We
1851 use it to copy the ECOFF debugging information from one BFD to the
1852 other. It would be theoretically possible to represent the ECOFF
1853 debugging information in the symbol table. However, it would be a
1854 lot of work, and there would be little gain (gas, gdb, and ld
1855 already access the ECOFF debugging information via the
1856 ecoff_debug_info structure, and that structure would have to be
1857 retained in order to support ECOFF debugging in MIPS ELF).
1859 The debugging information for the ECOFF external symbols comes from
1860 the symbol table, so this function only handles the other debugging
1864 _bfd_ecoff_bfd_copy_private_bfd_data (ibfd
, obfd
)
1868 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
1869 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
1871 asymbol
**sym_ptr_ptr
;
1875 /* We only want to copy information over if both BFD's use ECOFF
1877 if (bfd_get_flavour (ibfd
) != bfd_target_ecoff_flavour
1878 || bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
1881 /* Copy the GP value and the register masks. */
1882 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
1883 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
1884 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
1885 for (i
= 0; i
< 3; i
++)
1886 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
1888 /* Copy the version stamp. */
1889 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
1891 /* If there are no symbols, don't copy any debugging information. */
1892 c
= bfd_get_symcount (obfd
);
1893 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1894 if (c
== 0 || sym_ptr_ptr
== (asymbol
**) NULL
)
1897 /* See if there are any local symbols. */
1899 for (; c
> 0; c
--, sym_ptr_ptr
++)
1901 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
1910 /* There are some local symbols. We just bring over all the
1911 debugging information. FIXME: This is not quite the right
1912 thing to do. If the user has asked us to discard all
1913 debugging information, then we are probably going to wind up
1914 keeping it because there will probably be some local symbol
1915 which objcopy did not discard. We should actually break
1916 apart the debugging information and only keep that which
1917 applies to the symbols we want to keep. */
1918 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
1919 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
1920 oinfo
->line
= iinfo
->line
;
1922 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
1923 oinfo
->external_dnr
= iinfo
->external_dnr
;
1925 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
1926 oinfo
->external_pdr
= iinfo
->external_pdr
;
1928 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
1929 oinfo
->external_sym
= iinfo
->external_sym
;
1931 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
1932 oinfo
->external_opt
= iinfo
->external_opt
;
1934 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
1935 oinfo
->external_aux
= iinfo
->external_aux
;
1937 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
1938 oinfo
->ss
= iinfo
->ss
;
1940 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
1941 oinfo
->external_fdr
= iinfo
->external_fdr
;
1943 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
1944 oinfo
->external_rfd
= iinfo
->external_rfd
;
1948 /* We are discarding all the local symbol information. Look
1949 through the external symbols and remove all references to FDR
1950 or aux information. */
1951 c
= bfd_get_symcount (obfd
);
1952 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
1953 for (; c
> 0; c
--, sym_ptr_ptr
++)
1957 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
1958 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
1960 esym
.asym
.index
= indexNil
;
1961 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
1962 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
1969 /* Set the architecture. The supported architecture is stored in the
1970 backend pointer. We always set the architecture anyhow, since many
1971 callers ignore the return value. */
1974 _bfd_ecoff_set_arch_mach (abfd
, arch
, machine
)
1976 enum bfd_architecture arch
;
1977 unsigned long machine
;
1979 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1980 return arch
== ecoff_backend (abfd
)->arch
;
1983 /* Get the size of the section headers. */
1986 _bfd_ecoff_sizeof_headers (abfd
, reloc
)
1988 boolean reloc ATTRIBUTE_UNUSED
;
1995 for (current
= abfd
->sections
;
1996 current
!= (asection
*)NULL
;
1997 current
= current
->next
)
2000 ret
= (bfd_coff_filhsz (abfd
)
2001 + bfd_coff_aoutsz (abfd
)
2002 + c
* bfd_coff_scnhsz (abfd
));
2003 return BFD_ALIGN (ret
, 16);
2006 /* Get the contents of a section. */
2009 _bfd_ecoff_get_section_contents (abfd
, section
, location
, offset
, count
)
2014 bfd_size_type count
;
2016 return _bfd_generic_get_section_contents (abfd
, section
, location
,
2020 /* Sort sections by VMA, but put SEC_ALLOC sections first. This is
2021 called via qsort. */
2024 ecoff_sort_hdrs (arg1
, arg2
)
2028 const asection
*hdr1
= *(const asection
**) arg1
;
2029 const asection
*hdr2
= *(const asection
**) arg2
;
2031 if ((hdr1
->flags
& SEC_ALLOC
) != 0)
2033 if ((hdr2
->flags
& SEC_ALLOC
) == 0)
2038 if ((hdr2
->flags
& SEC_ALLOC
) != 0)
2041 if (hdr1
->vma
< hdr2
->vma
)
2043 else if (hdr1
->vma
> hdr2
->vma
)
2049 /* Calculate the file position for each section, and set
2053 ecoff_compute_section_file_positions (abfd
)
2056 file_ptr sofar
, file_sofar
;
2057 asection
**sorted_hdrs
;
2061 boolean rdata_in_text
;
2062 boolean first_data
, first_nonalloc
;
2063 const bfd_vma round
= ecoff_backend (abfd
)->round
;
2066 sofar
= _bfd_ecoff_sizeof_headers (abfd
, false);
2069 /* Sort the sections by VMA. */
2070 amt
= abfd
->section_count
;
2071 amt
*= sizeof (asection
*);
2072 sorted_hdrs
= (asection
**) bfd_malloc (amt
);
2073 if (sorted_hdrs
== NULL
)
2075 for (current
= abfd
->sections
, i
= 0;
2077 current
= current
->next
, i
++)
2078 sorted_hdrs
[i
] = current
;
2079 BFD_ASSERT (i
== abfd
->section_count
);
2081 qsort (sorted_hdrs
, abfd
->section_count
, sizeof (asection
*),
2084 /* Some versions of the OSF linker put the .rdata section in the
2085 text segment, and some do not. */
2086 rdata_in_text
= ecoff_backend (abfd
)->rdata_in_text
;
2089 for (i
= 0; i
< abfd
->section_count
; i
++)
2091 current
= sorted_hdrs
[i
];
2092 if (strcmp (current
->name
, _RDATA
) == 0)
2094 if ((current
->flags
& SEC_CODE
) == 0
2095 && strcmp (current
->name
, _PDATA
) != 0
2096 && strcmp (current
->name
, _RCONST
) != 0)
2098 rdata_in_text
= false;
2103 ecoff_data (abfd
)->rdata_in_text
= rdata_in_text
;
2106 first_nonalloc
= true;
2107 for (i
= 0; i
< abfd
->section_count
; i
++)
2109 unsigned int alignment_power
;
2111 current
= sorted_hdrs
[i
];
2113 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2114 supposed to indicate the number of .pdata entries that are
2115 really in the section. Each entry is 8 bytes. We store this
2116 away in line_filepos before increasing the section size. */
2117 if (strcmp (current
->name
, _PDATA
) == 0)
2118 current
->line_filepos
= current
->_raw_size
/ 8;
2120 alignment_power
= current
->alignment_power
;
2122 /* On Ultrix, the data sections in an executable file must be
2123 aligned to a page boundary within the file. This does not
2124 affect the section size, though. FIXME: Does this work for
2125 other platforms? It requires some modification for the
2126 Alpha, because .rdata on the Alpha goes with the text, not
2128 if ((abfd
->flags
& EXEC_P
) != 0
2129 && (abfd
->flags
& D_PAGED
) != 0
2131 && (current
->flags
& SEC_CODE
) == 0
2133 || strcmp (current
->name
, _RDATA
) != 0)
2134 && strcmp (current
->name
, _PDATA
) != 0
2135 && strcmp (current
->name
, _RCONST
) != 0)
2137 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2138 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2141 else if (strcmp (current
->name
, _LIB
) == 0)
2143 /* On Irix 4, the location of contents of the .lib section
2144 from a shared library section is also rounded up to a
2147 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2148 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2150 else if (first_nonalloc
2151 && (current
->flags
& SEC_ALLOC
) == 0
2152 && (abfd
->flags
& D_PAGED
) != 0)
2154 /* Skip up to the next page for an unallocated section, such
2155 as the .comment section on the Alpha. This leaves room
2156 for the .bss section. */
2157 first_nonalloc
= false;
2158 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2159 file_sofar
= (file_sofar
+ round
- 1) &~ (round
- 1);
2162 /* Align the sections in the file to the same boundary on
2163 which they are aligned in virtual memory. */
2164 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2165 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2166 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2168 if ((abfd
->flags
& D_PAGED
) != 0
2169 && (current
->flags
& SEC_ALLOC
) != 0)
2171 sofar
+= (current
->vma
- sofar
) % round
;
2172 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2173 file_sofar
+= (current
->vma
- file_sofar
) % round
;
2176 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) != 0)
2177 current
->filepos
= file_sofar
;
2179 sofar
+= current
->_raw_size
;
2180 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2181 file_sofar
+= current
->_raw_size
;
2183 /* make sure that this section is of the right size too */
2185 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2186 if ((current
->flags
& SEC_HAS_CONTENTS
) != 0)
2187 file_sofar
= BFD_ALIGN (file_sofar
, 1 << alignment_power
);
2188 current
->_raw_size
+= sofar
- old_sofar
;
2194 ecoff_data (abfd
)->reloc_filepos
= file_sofar
;
2199 /* Determine the location of the relocs for all the sections in the
2200 output file, as well as the location of the symbolic debugging
2203 static bfd_size_type
2204 ecoff_compute_reloc_file_positions (abfd
)
2207 const bfd_size_type external_reloc_size
=
2208 ecoff_backend (abfd
)->external_reloc_size
;
2209 file_ptr reloc_base
;
2210 bfd_size_type reloc_size
;
2214 if (! abfd
->output_has_begun
)
2216 if (! ecoff_compute_section_file_positions (abfd
))
2218 abfd
->output_has_begun
= true;
2221 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2224 for (current
= abfd
->sections
;
2225 current
!= (asection
*)NULL
;
2226 current
= current
->next
)
2228 if (current
->reloc_count
== 0)
2229 current
->rel_filepos
= 0;
2232 bfd_size_type relsize
;
2234 current
->rel_filepos
= reloc_base
;
2235 relsize
= current
->reloc_count
* external_reloc_size
;
2236 reloc_size
+= relsize
;
2237 reloc_base
+= relsize
;
2241 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2243 /* At least on Ultrix, the symbol table of an executable file must
2244 be aligned to a page boundary. FIXME: Is this true on other
2246 if ((abfd
->flags
& EXEC_P
) != 0
2247 && (abfd
->flags
& D_PAGED
) != 0)
2248 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2249 &~ (ecoff_backend (abfd
)->round
- 1));
2251 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2256 /* Set the contents of a section. */
2259 _bfd_ecoff_set_section_contents (abfd
, section
, location
, offset
, count
)
2264 bfd_size_type count
;
2268 /* This must be done first, because bfd_set_section_contents is
2269 going to set output_has_begun to true. */
2270 if (! abfd
->output_has_begun
)
2272 if (! ecoff_compute_section_file_positions (abfd
))
2276 /* Handle the .lib section specially so that Irix 4 shared libraries
2277 work out. See coff_set_section_contents in coffcode.h. */
2278 if (strcmp (section
->name
, _LIB
) == 0)
2280 bfd_byte
*rec
, *recend
;
2282 rec
= (bfd_byte
*) location
;
2283 recend
= rec
+ count
;
2284 while (rec
< recend
)
2287 rec
+= bfd_get_32 (abfd
, rec
) * 4;
2290 BFD_ASSERT (rec
== recend
);
2296 pos
= section
->filepos
+ offset
;
2297 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2298 || bfd_bwrite (location
, count
, abfd
) != count
)
2304 /* Get the GP value for an ECOFF file. This is a hook used by
2308 bfd_ecoff_get_gp_value (abfd
)
2311 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2312 || bfd_get_format (abfd
) != bfd_object
)
2314 bfd_set_error (bfd_error_invalid_operation
);
2318 return ecoff_data (abfd
)->gp
;
2321 /* Set the GP value for an ECOFF file. This is a hook used by the
2325 bfd_ecoff_set_gp_value (abfd
, gp_value
)
2329 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2330 || bfd_get_format (abfd
) != bfd_object
)
2332 bfd_set_error (bfd_error_invalid_operation
);
2336 ecoff_data (abfd
)->gp
= gp_value
;
2341 /* Set the register masks for an ECOFF file. This is a hook used by
2345 bfd_ecoff_set_regmasks (abfd
, gprmask
, fprmask
, cprmask
)
2347 unsigned long gprmask
;
2348 unsigned long fprmask
;
2349 unsigned long *cprmask
;
2351 ecoff_data_type
*tdata
;
2353 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2354 || bfd_get_format (abfd
) != bfd_object
)
2356 bfd_set_error (bfd_error_invalid_operation
);
2360 tdata
= ecoff_data (abfd
);
2361 tdata
->gprmask
= gprmask
;
2362 tdata
->fprmask
= fprmask
;
2363 if (cprmask
!= (unsigned long *) NULL
)
2367 for (i
= 0; i
< 3; i
++)
2368 tdata
->cprmask
[i
] = cprmask
[i
];
2374 /* Get ECOFF EXTR information for an external symbol. This function
2375 is passed to bfd_ecoff_debug_externals. */
2378 ecoff_get_extr (sym
, esym
)
2382 ecoff_symbol_type
*ecoff_sym_ptr
;
2385 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2386 || ecoffsymbol (sym
)->native
== NULL
)
2388 /* Don't include debugging, local, or section symbols. */
2389 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2390 || (sym
->flags
& BSF_LOCAL
) != 0
2391 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2395 esym
->cobol_main
= 0;
2396 esym
->weakext
= (sym
->flags
& BSF_WEAK
) != 0;
2399 /* FIXME: we can do better than this for st and sc. */
2400 esym
->asym
.st
= stGlobal
;
2401 esym
->asym
.sc
= scAbs
;
2402 esym
->asym
.reserved
= 0;
2403 esym
->asym
.index
= indexNil
;
2407 ecoff_sym_ptr
= ecoffsymbol (sym
);
2409 if (ecoff_sym_ptr
->local
)
2412 input_bfd
= bfd_asymbol_bfd (sym
);
2413 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2414 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2416 /* If the symbol was defined by the linker, then esym will be
2417 undefined but sym will not be. Get a better class for such a
2419 if ((esym
->asym
.sc
== scUndefined
2420 || esym
->asym
.sc
== scSUndefined
)
2421 && ! bfd_is_und_section (bfd_get_section (sym
)))
2422 esym
->asym
.sc
= scAbs
;
2424 /* Adjust the FDR index for the symbol by that used for the input
2426 if (esym
->ifd
!= -1)
2428 struct ecoff_debug_info
*input_debug
;
2430 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2431 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2432 if (input_debug
->ifdmap
!= (RFDT
*) NULL
)
2433 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2439 /* Set the external symbol index. This routine is passed to
2440 bfd_ecoff_debug_externals. */
2443 ecoff_set_index (sym
, indx
)
2447 ecoff_set_sym_index (sym
, indx
);
2450 /* Write out an ECOFF file. */
2453 _bfd_ecoff_write_object_contents (abfd
)
2456 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2457 const bfd_vma round
= backend
->round
;
2458 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2459 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2460 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2461 const bfd_size_type external_hdr_size
2462 = backend
->debug_swap
.external_hdr_size
;
2463 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2464 void (* const adjust_reloc_out
) PARAMS ((bfd
*,
2466 struct internal_reloc
*))
2467 = backend
->adjust_reloc_out
;
2468 void (* const swap_reloc_out
) PARAMS ((bfd
*,
2469 const struct internal_reloc
*,
2471 = backend
->swap_reloc_out
;
2472 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2473 HDRR
* const symhdr
= &debug
->symbolic_header
;
2476 bfd_size_type reloc_size
;
2477 bfd_size_type text_size
;
2479 boolean set_text_start
;
2480 bfd_size_type data_size
;
2482 boolean set_data_start
;
2483 bfd_size_type bss_size
;
2485 PTR reloc_buff
= NULL
;
2486 struct internal_filehdr internal_f
;
2487 struct internal_aouthdr internal_a
;
2490 /* Determine where the sections and relocs will go in the output
2492 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2495 for (current
= abfd
->sections
;
2496 current
!= (asection
*)NULL
;
2497 current
= current
->next
)
2499 current
->target_index
= count
;
2503 if ((abfd
->flags
& D_PAGED
) != 0)
2504 text_size
= _bfd_ecoff_sizeof_headers (abfd
, false);
2508 set_text_start
= false;
2511 set_data_start
= false;
2514 /* Write section headers to the file. */
2516 /* Allocate buff big enough to hold a section header,
2517 file header, or a.out header. */
2525 buff
= (PTR
) bfd_malloc (siz
);
2530 internal_f
.f_nscns
= 0;
2531 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2533 for (current
= abfd
->sections
;
2534 current
!= (asection
*) NULL
;
2535 current
= current
->next
)
2537 struct internal_scnhdr section
;
2540 ++internal_f
.f_nscns
;
2542 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2544 /* This seems to be correct for Irix 4 shared libraries. */
2545 vma
= bfd_get_section_vma (abfd
, current
);
2546 if (strcmp (current
->name
, _LIB
) == 0)
2547 section
.s_vaddr
= 0;
2549 section
.s_vaddr
= vma
;
2551 section
.s_paddr
= current
->lma
;
2552 section
.s_size
= bfd_get_section_size_before_reloc (current
);
2554 /* If this section is unloadable then the scnptr will be 0. */
2555 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2556 section
.s_scnptr
= 0;
2558 section
.s_scnptr
= current
->filepos
;
2559 section
.s_relptr
= current
->rel_filepos
;
2561 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2562 object file produced by the assembler is supposed to point to
2563 information about how much room is required by objects of
2564 various different sizes. I think this only matters if we
2565 want the linker to compute the best size to use, or
2566 something. I don't know what happens if the information is
2568 if (strcmp (current
->name
, _PDATA
) != 0)
2569 section
.s_lnnoptr
= 0;
2572 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2573 hold the number of entries in the section (each entry is
2574 8 bytes). We stored this in the line_filepos field in
2575 ecoff_compute_section_file_positions. */
2576 section
.s_lnnoptr
= current
->line_filepos
;
2579 section
.s_nreloc
= current
->reloc_count
;
2580 section
.s_nlnno
= 0;
2581 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2584 if (bfd_coff_swap_scnhdr_out (abfd
, (PTR
) §ion
, buff
) == 0
2585 || bfd_bwrite (buff
, scnhsz
, abfd
) != scnhsz
)
2588 if ((section
.s_flags
& STYP_TEXT
) != 0
2589 || ((section
.s_flags
& STYP_RDATA
) != 0
2590 && ecoff_data (abfd
)->rdata_in_text
)
2591 || section
.s_flags
== STYP_PDATA
2592 || (section
.s_flags
& STYP_DYNAMIC
) != 0
2593 || (section
.s_flags
& STYP_LIBLIST
) != 0
2594 || (section
.s_flags
& STYP_RELDYN
) != 0
2595 || section
.s_flags
== STYP_CONFLIC
2596 || (section
.s_flags
& STYP_DYNSTR
) != 0
2597 || (section
.s_flags
& STYP_DYNSYM
) != 0
2598 || (section
.s_flags
& STYP_HASH
) != 0
2599 || (section
.s_flags
& STYP_ECOFF_INIT
) != 0
2600 || (section
.s_flags
& STYP_ECOFF_FINI
) != 0
2601 || section
.s_flags
== STYP_RCONST
)
2603 text_size
+= bfd_get_section_size_before_reloc (current
);
2604 if (! set_text_start
|| text_start
> vma
)
2607 set_text_start
= true;
2610 else if ((section
.s_flags
& STYP_RDATA
) != 0
2611 || (section
.s_flags
& STYP_DATA
) != 0
2612 || (section
.s_flags
& STYP_LITA
) != 0
2613 || (section
.s_flags
& STYP_LIT8
) != 0
2614 || (section
.s_flags
& STYP_LIT4
) != 0
2615 || (section
.s_flags
& STYP_SDATA
) != 0
2616 || section
.s_flags
== STYP_XDATA
2617 || (section
.s_flags
& STYP_GOT
) != 0)
2619 data_size
+= bfd_get_section_size_before_reloc (current
);
2620 if (! set_data_start
|| data_start
> vma
)
2623 set_data_start
= true;
2626 else if ((section
.s_flags
& STYP_BSS
) != 0
2627 || (section
.s_flags
& STYP_SBSS
) != 0)
2628 bss_size
+= bfd_get_section_size_before_reloc (current
);
2629 else if (section
.s_flags
== 0
2630 || (section
.s_flags
& STYP_ECOFF_LIB
) != 0
2631 || section
.s_flags
== STYP_COMMENT
)
2637 /* Set up the file header. */
2639 internal_f
.f_magic
= ecoff_get_magic (abfd
);
2641 /* We will NOT put a fucking timestamp in the header here. Every
2642 time you put it back, I will come in and take it out again. I'm
2643 sorry. This field does not belong here. We fill it with a 0 so
2644 it compares the same but is not a reasonable time. --
2646 internal_f
.f_timdat
= 0;
2648 if (bfd_get_symcount (abfd
) != 0)
2650 /* The ECOFF f_nsyms field is not actually the number of
2651 symbols, it's the size of symbolic information header. */
2652 internal_f
.f_nsyms
= external_hdr_size
;
2653 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
2657 internal_f
.f_nsyms
= 0;
2658 internal_f
.f_symptr
= 0;
2661 internal_f
.f_opthdr
= aoutsz
;
2663 internal_f
.f_flags
= F_LNNO
;
2664 if (reloc_size
== 0)
2665 internal_f
.f_flags
|= F_RELFLG
;
2666 if (bfd_get_symcount (abfd
) == 0)
2667 internal_f
.f_flags
|= F_LSYMS
;
2668 if (abfd
->flags
& EXEC_P
)
2669 internal_f
.f_flags
|= F_EXEC
;
2671 if (bfd_little_endian (abfd
))
2672 internal_f
.f_flags
|= F_AR32WR
;
2674 internal_f
.f_flags
|= F_AR32W
;
2676 /* Set up the ``optional'' header. */
2677 if ((abfd
->flags
& D_PAGED
) != 0)
2678 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
2680 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
2682 /* FIXME: Is this really correct? */
2683 internal_a
.vstamp
= symhdr
->vstamp
;
2685 /* At least on Ultrix, these have to be rounded to page boundaries.
2686 FIXME: Is this true on other platforms? */
2687 if ((abfd
->flags
& D_PAGED
) != 0)
2689 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
2690 internal_a
.text_start
= text_start
&~ (round
- 1);
2691 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
2692 internal_a
.data_start
= data_start
&~ (round
- 1);
2696 internal_a
.tsize
= text_size
;
2697 internal_a
.text_start
= text_start
;
2698 internal_a
.dsize
= data_size
;
2699 internal_a
.data_start
= data_start
;
2702 /* On Ultrix, the initial portions of the .sbss and .bss segments
2703 are at the end of the data section. The bsize field in the
2704 optional header records how many bss bytes are required beyond
2705 those in the data section. The value is not rounded to a page
2707 if (bss_size
< internal_a
.dsize
- data_size
)
2710 bss_size
-= internal_a
.dsize
- data_size
;
2711 internal_a
.bsize
= bss_size
;
2712 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
2714 internal_a
.entry
= bfd_get_start_address (abfd
);
2716 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
2718 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
2719 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
2720 for (i
= 0; i
< 4; i
++)
2721 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
2723 /* Let the backend adjust the headers if necessary. */
2724 if (backend
->adjust_headers
)
2726 if (! (*backend
->adjust_headers
) (abfd
, &internal_f
, &internal_a
))
2730 /* Write out the file header and the optional header. */
2732 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2735 bfd_coff_swap_filehdr_out (abfd
, (PTR
) &internal_f
, buff
);
2736 if (bfd_bwrite (buff
, filhsz
, abfd
) != filhsz
)
2739 bfd_coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, buff
);
2740 if (bfd_bwrite (buff
, aoutsz
, abfd
) != aoutsz
)
2743 /* Build the external symbol information. This must be done before
2744 writing out the relocs so that we know the symbol indices. We
2745 don't do this if this BFD was created by the backend linker,
2746 since it will have already handled the symbols and relocs. */
2747 if (! ecoff_data (abfd
)->linker
)
2749 symhdr
->iextMax
= 0;
2750 symhdr
->issExtMax
= 0;
2751 debug
->external_ext
= debug
->external_ext_end
= NULL
;
2752 debug
->ssext
= debug
->ssext_end
= NULL
;
2753 if (! bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
2754 (abfd
->flags
& EXEC_P
) == 0,
2755 ecoff_get_extr
, ecoff_set_index
))
2758 /* Write out the relocs. */
2759 for (current
= abfd
->sections
;
2760 current
!= (asection
*) NULL
;
2761 current
= current
->next
)
2763 arelent
**reloc_ptr_ptr
;
2764 arelent
**reloc_end
;
2768 if (current
->reloc_count
== 0)
2771 amt
= current
->reloc_count
* external_reloc_size
;
2772 reloc_buff
= bfd_alloc (abfd
, amt
);
2773 if (reloc_buff
== NULL
)
2776 reloc_ptr_ptr
= current
->orelocation
;
2777 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
2778 out_ptr
= (char *) reloc_buff
;
2780 reloc_ptr_ptr
< reloc_end
;
2781 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
2785 struct internal_reloc in
;
2787 memset ((PTR
) &in
, 0, sizeof in
);
2789 reloc
= *reloc_ptr_ptr
;
2790 sym
= *reloc
->sym_ptr_ptr
;
2792 in
.r_vaddr
= (reloc
->address
2793 + bfd_get_section_vma (abfd
, current
));
2794 in
.r_type
= reloc
->howto
->type
;
2796 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
2798 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
2805 name
= bfd_get_section_name (abfd
, bfd_get_section (sym
));
2806 if (strcmp (name
, ".text") == 0)
2807 in
.r_symndx
= RELOC_SECTION_TEXT
;
2808 else if (strcmp (name
, ".rdata") == 0)
2809 in
.r_symndx
= RELOC_SECTION_RDATA
;
2810 else if (strcmp (name
, ".data") == 0)
2811 in
.r_symndx
= RELOC_SECTION_DATA
;
2812 else if (strcmp (name
, ".sdata") == 0)
2813 in
.r_symndx
= RELOC_SECTION_SDATA
;
2814 else if (strcmp (name
, ".sbss") == 0)
2815 in
.r_symndx
= RELOC_SECTION_SBSS
;
2816 else if (strcmp (name
, ".bss") == 0)
2817 in
.r_symndx
= RELOC_SECTION_BSS
;
2818 else if (strcmp (name
, ".init") == 0)
2819 in
.r_symndx
= RELOC_SECTION_INIT
;
2820 else if (strcmp (name
, ".lit8") == 0)
2821 in
.r_symndx
= RELOC_SECTION_LIT8
;
2822 else if (strcmp (name
, ".lit4") == 0)
2823 in
.r_symndx
= RELOC_SECTION_LIT4
;
2824 else if (strcmp (name
, ".xdata") == 0)
2825 in
.r_symndx
= RELOC_SECTION_XDATA
;
2826 else if (strcmp (name
, ".pdata") == 0)
2827 in
.r_symndx
= RELOC_SECTION_PDATA
;
2828 else if (strcmp (name
, ".fini") == 0)
2829 in
.r_symndx
= RELOC_SECTION_FINI
;
2830 else if (strcmp (name
, ".lita") == 0)
2831 in
.r_symndx
= RELOC_SECTION_LITA
;
2832 else if (strcmp (name
, "*ABS*") == 0)
2833 in
.r_symndx
= RELOC_SECTION_ABS
;
2834 else if (strcmp (name
, ".rconst") == 0)
2835 in
.r_symndx
= RELOC_SECTION_RCONST
;
2841 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
2843 (*swap_reloc_out
) (abfd
, &in
, (PTR
) out_ptr
);
2846 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
2848 amt
= current
->reloc_count
* external_reloc_size
;
2849 if (bfd_bwrite (reloc_buff
, amt
, abfd
) != amt
)
2851 bfd_release (abfd
, reloc_buff
);
2855 /* Write out the symbolic debugging information. */
2856 if (bfd_get_symcount (abfd
) > 0)
2858 /* Write out the debugging information. */
2859 if (! bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
2860 ecoff_data (abfd
)->sym_filepos
))
2865 /* The .bss section of a demand paged executable must receive an
2866 entire page. If there are symbols, the symbols will start on the
2867 next page. If there are no symbols, we must fill out the page by
2869 if (bfd_get_symcount (abfd
) == 0
2870 && (abfd
->flags
& EXEC_P
) != 0
2871 && (abfd
->flags
& D_PAGED
) != 0)
2875 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2878 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) == 0)
2880 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
2883 if (bfd_bwrite (&c
, (bfd_size_type
) 1, abfd
) != 1)
2887 if (reloc_buff
!= NULL
)
2888 bfd_release (abfd
, reloc_buff
);
2893 if (reloc_buff
!= NULL
)
2894 bfd_release (abfd
, reloc_buff
);
2900 /* Archive handling. ECOFF uses what appears to be a unique type of
2901 archive header (armap). The byte ordering of the armap and the
2902 contents are encoded in the name of the armap itself. At least for
2903 now, we only support archives with the same byte ordering in the
2904 armap and the contents.
2906 The first four bytes in the armap are the number of symbol
2907 definitions. This is always a power of two.
2909 This is followed by the symbol definitions. Each symbol definition
2910 occupies 8 bytes. The first four bytes are the offset from the
2911 start of the armap strings to the null-terminated string naming
2912 this symbol. The second four bytes are the file offset to the
2913 archive member which defines this symbol. If the second four bytes
2914 are 0, then this is not actually a symbol definition, and it should
2917 The symbols are hashed into the armap with a closed hashing scheme.
2918 See the functions below for the details of the algorithm.
2920 After the symbol definitions comes four bytes holding the size of
2921 the string table, followed by the string table itself. */
2923 /* The name of an archive headers looks like this:
2924 __________E[BL]E[BL]_ (with a trailing space).
2925 The trailing space is changed to an X if the archive is changed to
2926 indicate that the armap is out of date.
2928 The Alpha seems to use ________64E[BL]E[BL]_. */
2930 #define ARMAP_BIG_ENDIAN 'B'
2931 #define ARMAP_LITTLE_ENDIAN 'L'
2932 #define ARMAP_MARKER 'E'
2933 #define ARMAP_START_LENGTH 10
2934 #define ARMAP_HEADER_MARKER_INDEX 10
2935 #define ARMAP_HEADER_ENDIAN_INDEX 11
2936 #define ARMAP_OBJECT_MARKER_INDEX 12
2937 #define ARMAP_OBJECT_ENDIAN_INDEX 13
2938 #define ARMAP_END_INDEX 14
2939 #define ARMAP_END "_ "
2941 /* This is a magic number used in the hashing algorithm. */
2942 #define ARMAP_HASH_MAGIC 0x9dd68ab5
2944 /* This returns the hash value to use for a string. It also sets
2945 *REHASH to the rehash adjustment if the first slot is taken. SIZE
2946 is the number of entries in the hash table, and HLOG is the log
2950 ecoff_armap_hash (s
, rehash
, size
, hlog
)
2952 unsigned int *rehash
;
2962 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
2963 hash
*= ARMAP_HASH_MAGIC
;
2964 *rehash
= (hash
& (size
- 1)) | 1;
2965 return hash
>> (32 - hlog
);
2968 /* Read in the armap. */
2971 _bfd_ecoff_slurp_armap (abfd
)
2976 struct areltdata
*mapdata
;
2977 bfd_size_type parsed_size
;
2979 struct artdata
*ardata
;
2982 struct symdef
*symdef_ptr
;
2986 /* Get the name of the first element. */
2987 i
= bfd_bread ((PTR
) nextname
, (bfd_size_type
) 16, abfd
);
2993 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
2996 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2997 standard COFF armap. We could move the ECOFF armap stuff into
2998 bfd_slurp_armap, but that seems inappropriate since no other
2999 target uses this format. Instead, we check directly for a COFF
3001 if (strncmp (nextname
, "/ ", 16) == 0)
3002 return bfd_slurp_armap (abfd
);
3004 /* See if the first element is an armap. */
3005 if (strncmp (nextname
, ecoff_backend (abfd
)->armap_start
,
3006 ARMAP_START_LENGTH
) != 0
3007 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
3008 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
3009 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
3010 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
3011 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
3012 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
3013 || strncmp (nextname
+ ARMAP_END_INDEX
,
3014 ARMAP_END
, sizeof ARMAP_END
- 1) != 0)
3016 bfd_has_map (abfd
) = false;
3020 /* Make sure we have the right byte ordering. */
3021 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
3022 ^ (bfd_header_big_endian (abfd
)))
3023 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
3024 ^ (bfd_big_endian (abfd
))))
3026 bfd_set_error (bfd_error_wrong_format
);
3030 /* Read in the armap. */
3031 ardata
= bfd_ardata (abfd
);
3032 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
3033 if (mapdata
== (struct areltdata
*) NULL
)
3035 parsed_size
= mapdata
->parsed_size
;
3036 bfd_release (abfd
, (PTR
) mapdata
);
3038 raw_armap
= (char *) bfd_alloc (abfd
, parsed_size
);
3039 if (raw_armap
== (char *) NULL
)
3042 if (bfd_bread ((PTR
) raw_armap
, parsed_size
, abfd
) != parsed_size
)
3044 if (bfd_get_error () != bfd_error_system_call
)
3045 bfd_set_error (bfd_error_malformed_archive
);
3046 bfd_release (abfd
, (PTR
) raw_armap
);
3050 ardata
->tdata
= (PTR
) raw_armap
;
3052 count
= H_GET_32 (abfd
, raw_armap
);
3054 ardata
->symdef_count
= 0;
3055 ardata
->cache
= (struct ar_cache
*) NULL
;
3057 /* This code used to overlay the symdefs over the raw archive data,
3058 but that doesn't work on a 64 bit host. */
3060 stringbase
= raw_armap
+ count
* 8 + 8;
3062 #ifdef CHECK_ARMAP_HASH
3066 /* Double check that I have the hashing algorithm right by making
3067 sure that every symbol can be looked up successfully. */
3069 for (i
= 1; i
< count
; i
<<= 1)
3071 BFD_ASSERT (i
== count
);
3073 raw_ptr
= raw_armap
+ 4;
3074 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3076 unsigned int name_offset
, file_offset
;
3077 unsigned int hash
, rehash
, srch
;
3079 name_offset
= H_GET_32 (abfd
, raw_ptr
);
3080 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
3081 if (file_offset
== 0)
3083 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
3088 /* See if we can rehash to this location. */
3089 for (srch
= (hash
+ rehash
) & (count
- 1);
3090 srch
!= hash
&& srch
!= i
;
3091 srch
= (srch
+ rehash
) & (count
- 1))
3092 BFD_ASSERT (H_GET_32 (abfd
, (raw_armap
+ 8 + srch
* 8)) != 0);
3093 BFD_ASSERT (srch
== i
);
3097 #endif /* CHECK_ARMAP_HASH */
3099 raw_ptr
= raw_armap
+ 4;
3100 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3101 if (H_GET_32 (abfd
, (raw_ptr
+ 4)) != 0)
3102 ++ardata
->symdef_count
;
3104 amt
= ardata
->symdef_count
;
3105 amt
*= sizeof (struct symdef
);
3106 symdef_ptr
= (struct symdef
*) bfd_alloc (abfd
, amt
);
3110 ardata
->symdefs
= (carsym
*) symdef_ptr
;
3112 raw_ptr
= raw_armap
+ 4;
3113 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3115 unsigned int name_offset
, file_offset
;
3117 file_offset
= H_GET_32 (abfd
, (raw_ptr
+ 4));
3118 if (file_offset
== 0)
3120 name_offset
= H_GET_32 (abfd
, raw_ptr
);
3121 symdef_ptr
->s
.name
= stringbase
+ name_offset
;
3122 symdef_ptr
->file_offset
= file_offset
;
3126 ardata
->first_file_filepos
= bfd_tell (abfd
);
3127 /* Pad to an even boundary. */
3128 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
3130 bfd_has_map (abfd
) = true;
3135 /* Write out an armap. */
3138 _bfd_ecoff_write_armap (abfd
, elength
, map
, orl_count
, stridx
)
3140 unsigned int elength
;
3142 unsigned int orl_count
;
3145 unsigned int hashsize
, hashlog
;
3146 bfd_size_type symdefsize
;
3148 unsigned int stringsize
;
3149 unsigned int mapsize
;
3152 struct stat statbuf
;
3155 bfd_byte
*hashtable
;
3159 /* Ultrix appears to use as a hash table size the least power of two
3160 greater than twice the number of entries. */
3161 for (hashlog
= 0; ((unsigned int) 1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3163 hashsize
= 1 << hashlog
;
3165 symdefsize
= hashsize
* 8;
3167 stringsize
= stridx
+ padit
;
3169 /* Include 8 bytes to store symdefsize and stringsize in output. */
3170 mapsize
= symdefsize
+ stringsize
+ 8;
3172 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3174 memset ((PTR
) &hdr
, 0, sizeof hdr
);
3176 /* Work out the ECOFF armap name. */
3177 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3178 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3179 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3180 (bfd_header_big_endian (abfd
)
3182 : ARMAP_LITTLE_ENDIAN
);
3183 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3184 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3185 bfd_big_endian (abfd
) ? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3186 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3188 /* Write the timestamp of the archive header to be just a little bit
3189 later than the timestamp of the file, otherwise the linker will
3190 complain that the index is out of date. Actually, the Ultrix
3191 linker just checks the archive name; the GNU linker may check the
3193 stat (abfd
->filename
, &statbuf
);
3194 sprintf (hdr
.ar_date
, "%ld", (long) (statbuf
.st_mtime
+ 60));
3196 /* The DECstation uses zeroes for the uid, gid and mode of the
3198 hdr
.ar_uid
[0] = '0';
3199 hdr
.ar_gid
[0] = '0';
3201 hdr
.ar_mode
[0] = '0';
3203 /* Building gcc ends up extracting the armap as a file - twice. */
3204 hdr
.ar_mode
[0] = '6';
3205 hdr
.ar_mode
[1] = '4';
3206 hdr
.ar_mode
[2] = '4';
3209 sprintf (hdr
.ar_size
, "%-10d", (int) mapsize
);
3211 hdr
.ar_fmag
[0] = '`';
3212 hdr
.ar_fmag
[1] = '\012';
3214 /* Turn all null bytes in the header into spaces. */
3215 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3216 if (((char *) (&hdr
))[i
] == '\0')
3217 (((char *) (&hdr
))[i
]) = ' ';
3219 if (bfd_bwrite ((PTR
) &hdr
, (bfd_size_type
) sizeof (struct ar_hdr
), abfd
)
3220 != sizeof (struct ar_hdr
))
3223 H_PUT_32 (abfd
, hashsize
, temp
);
3224 if (bfd_bwrite ((PTR
) temp
, (bfd_size_type
) 4, abfd
) != 4)
3227 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3231 current
= abfd
->archive_head
;
3233 for (i
= 0; i
< orl_count
; i
++)
3235 unsigned int hash
, rehash
;
3237 /* Advance firstreal to the file position of this archive
3239 if (map
[i
].u
.abfd
!= last_elt
)
3243 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3244 firstreal
+= firstreal
% 2;
3245 current
= current
->next
;
3247 while (current
!= map
[i
].u
.abfd
);
3252 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3253 if (H_GET_32 (abfd
, (hashtable
+ (hash
* 8) + 4)) != 0)
3257 /* The desired slot is already taken. */
3258 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3260 srch
= (srch
+ rehash
) & (hashsize
- 1))
3261 if (H_GET_32 (abfd
, (hashtable
+ (srch
* 8) + 4)) == 0)
3264 BFD_ASSERT (srch
!= hash
);
3269 H_PUT_32 (abfd
, map
[i
].namidx
, (hashtable
+ hash
* 8));
3270 H_PUT_32 (abfd
, firstreal
, (hashtable
+ hash
* 8 + 4));
3273 if (bfd_bwrite ((PTR
) hashtable
, symdefsize
, abfd
) != symdefsize
)
3276 bfd_release (abfd
, hashtable
);
3278 /* Now write the strings. */
3279 H_PUT_32 (abfd
, stringsize
, temp
);
3280 if (bfd_bwrite ((PTR
) temp
, (bfd_size_type
) 4, abfd
) != 4)
3282 for (i
= 0; i
< orl_count
; i
++)
3286 len
= strlen (*map
[i
].name
) + 1;
3287 if (bfd_bwrite ((PTR
) (*map
[i
].name
), len
, abfd
) != len
)
3291 /* The spec sez this should be a newline. But in order to be
3292 bug-compatible for DECstation ar we use a null. */
3295 if (bfd_bwrite ("", (bfd_size_type
) 1, abfd
) != 1)
3302 /* See whether this BFD is an archive. If it is, read in the armap
3303 and the extended name table. */
3306 _bfd_ecoff_archive_p (abfd
)
3309 struct artdata
*tdata_hold
;
3310 char armag
[SARMAG
+ 1];
3313 tdata_hold
= abfd
->tdata
.aout_ar_data
;
3315 if (bfd_bread ((PTR
) armag
, (bfd_size_type
) SARMAG
, abfd
) != SARMAG
)
3317 if (bfd_get_error () != bfd_error_system_call
)
3318 bfd_set_error (bfd_error_wrong_format
);
3319 return (const bfd_target
*) NULL
;
3322 if (strncmp (armag
, ARMAG
, SARMAG
) != 0)
3324 bfd_set_error (bfd_error_wrong_format
);
3328 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
3329 involves a cast, we can't do it as the left operand of
3331 amt
= sizeof (struct artdata
);
3332 abfd
->tdata
.aout_ar_data
= (struct artdata
*) bfd_zalloc (abfd
, amt
);
3334 if (bfd_ardata (abfd
) == (struct artdata
*) NULL
)
3336 abfd
->tdata
.aout_ar_data
= tdata_hold
;
3337 return (const bfd_target
*) NULL
;
3340 bfd_ardata (abfd
)->first_file_filepos
= SARMAG
;
3341 bfd_ardata (abfd
)->cache
= NULL
;
3342 bfd_ardata (abfd
)->archive_head
= NULL
;
3343 bfd_ardata (abfd
)->symdefs
= NULL
;
3344 bfd_ardata (abfd
)->extended_names
= NULL
;
3345 bfd_ardata (abfd
)->tdata
= NULL
;
3347 if (! _bfd_ecoff_slurp_armap (abfd
)
3348 || ! _bfd_ecoff_slurp_extended_name_table (abfd
))
3350 bfd_release (abfd
, bfd_ardata (abfd
));
3351 abfd
->tdata
.aout_ar_data
= tdata_hold
;
3352 return (const bfd_target
*) NULL
;
3355 if (bfd_has_map (abfd
))
3359 /* This archive has a map, so we may presume that the contents
3360 are object files. Make sure that if the first file in the
3361 archive can be recognized as an object file, it is for this
3362 target. If not, assume that this is the wrong format. If
3363 the first file is not an object file, somebody is doing
3364 something weird, and we permit it so that ar -t will work. */
3366 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
3371 first
->target_defaulted
= false;
3373 if (bfd_check_format (first
, bfd_object
)
3374 && first
->xvec
!= abfd
->xvec
)
3376 (void) bfd_close (first
);
3377 bfd_release (abfd
, bfd_ardata (abfd
));
3378 abfd
->tdata
.aout_ar_data
= tdata_hold
;
3379 bfd_set_error (bfd_error_wrong_format
);
3383 /* We ought to close first here, but we can't, because we
3384 have no way to remove it from the archive cache. FIXME. */
3391 /* ECOFF linker code. */
3393 static struct bfd_hash_entry
*ecoff_link_hash_newfunc
3394 PARAMS ((struct bfd_hash_entry
*entry
,
3395 struct bfd_hash_table
*table
,
3396 const char *string
));
3397 static boolean ecoff_link_add_archive_symbols
3398 PARAMS ((bfd
*, struct bfd_link_info
*));
3399 static boolean ecoff_link_check_archive_element
3400 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*pneeded
));
3401 static boolean ecoff_link_add_object_symbols
3402 PARAMS ((bfd
*, struct bfd_link_info
*));
3403 static boolean ecoff_link_add_externals
3404 PARAMS ((bfd
*, struct bfd_link_info
*, PTR
, char *));
3406 /* Routine to create an entry in an ECOFF link hash table. */
3408 static struct bfd_hash_entry
*
3409 ecoff_link_hash_newfunc (entry
, table
, string
)
3410 struct bfd_hash_entry
*entry
;
3411 struct bfd_hash_table
*table
;
3414 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3416 /* Allocate the structure if it has not already been allocated by a
3418 if (ret
== (struct ecoff_link_hash_entry
*) NULL
)
3419 ret
= ((struct ecoff_link_hash_entry
*)
3420 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3421 if (ret
== (struct ecoff_link_hash_entry
*) NULL
)
3424 /* Call the allocation method of the superclass. */
3425 ret
= ((struct ecoff_link_hash_entry
*)
3426 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3431 /* Set local fields. */
3437 memset ((PTR
) &ret
->esym
, 0, sizeof ret
->esym
);
3439 return (struct bfd_hash_entry
*) ret
;
3442 /* Create an ECOFF link hash table. */
3444 struct bfd_link_hash_table
*
3445 _bfd_ecoff_bfd_link_hash_table_create (abfd
)
3448 struct ecoff_link_hash_table
*ret
;
3449 bfd_size_type amt
= sizeof (struct ecoff_link_hash_table
);
3451 ret
= (struct ecoff_link_hash_table
*) bfd_malloc (amt
);
3454 if (! _bfd_link_hash_table_init (&ret
->root
, abfd
,
3455 ecoff_link_hash_newfunc
))
3458 return (struct bfd_link_hash_table
*) NULL
;
3463 /* Look up an entry in an ECOFF link hash table. */
3465 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3466 ((struct ecoff_link_hash_entry *) \
3467 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3469 /* Traverse an ECOFF link hash table. */
3471 #define ecoff_link_hash_traverse(table, func, info) \
3472 (bfd_link_hash_traverse \
3474 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
3477 /* Get the ECOFF link hash table from the info structure. This is
3480 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3482 /* Given an ECOFF BFD, add symbols to the global hash table as
3486 _bfd_ecoff_bfd_link_add_symbols (abfd
, info
)
3488 struct bfd_link_info
*info
;
3490 switch (bfd_get_format (abfd
))
3493 return ecoff_link_add_object_symbols (abfd
, info
);
3495 return ecoff_link_add_archive_symbols (abfd
, info
);
3497 bfd_set_error (bfd_error_wrong_format
);
3502 /* Add the symbols from an archive file to the global hash table.
3503 This looks through the undefined symbols, looks each one up in the
3504 archive hash table, and adds any associated object file. We do not
3505 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3506 already have a hash table, so there is no reason to construct
3510 ecoff_link_add_archive_symbols (abfd
, info
)
3512 struct bfd_link_info
*info
;
3514 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3515 const bfd_byte
*raw_armap
;
3516 struct bfd_link_hash_entry
**pundef
;
3517 unsigned int armap_count
;
3518 unsigned int armap_log
;
3520 const bfd_byte
*hashtable
;
3521 const char *stringbase
;
3523 if (! bfd_has_map (abfd
))
3525 /* An empty archive is a special case. */
3526 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
3528 bfd_set_error (bfd_error_no_armap
);
3532 /* If we don't have any raw data for this archive, as can happen on
3533 Irix 4.0.5F, we call the generic routine.
3534 FIXME: We should be more clever about this, since someday tdata
3535 may get to something for a generic archive. */
3536 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3537 if (raw_armap
== (bfd_byte
*) NULL
)
3538 return (_bfd_generic_link_add_archive_symbols
3539 (abfd
, info
, ecoff_link_check_archive_element
));
3541 armap_count
= H_GET_32 (abfd
, raw_armap
);
3544 for (i
= 1; i
< armap_count
; i
<<= 1)
3546 BFD_ASSERT (i
== armap_count
);
3548 hashtable
= raw_armap
+ 4;
3549 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3551 /* Look through the list of undefined symbols. */
3552 pundef
= &info
->hash
->undefs
;
3553 while (*pundef
!= (struct bfd_link_hash_entry
*) NULL
)
3555 struct bfd_link_hash_entry
*h
;
3556 unsigned int hash
, rehash
;
3557 unsigned int file_offset
;
3563 /* When a symbol is defined, it is not necessarily removed from
3565 if (h
->type
!= bfd_link_hash_undefined
3566 && h
->type
!= bfd_link_hash_common
)
3568 /* Remove this entry from the list, for general cleanliness
3569 and because we are going to look through the list again
3570 if we search any more libraries. We can't remove the
3571 entry if it is the tail, because that would lose any
3572 entries we add to the list later on. */
3573 if (*pundef
!= info
->hash
->undefs_tail
)
3574 *pundef
= (*pundef
)->next
;
3576 pundef
= &(*pundef
)->next
;
3580 /* Native ECOFF linkers do not pull in archive elements merely
3581 to satisfy common definitions, so neither do we. We leave
3582 them on the list, though, in case we are linking against some
3583 other object format. */
3584 if (h
->type
!= bfd_link_hash_undefined
)
3586 pundef
= &(*pundef
)->next
;
3590 /* Look for this symbol in the archive hash table. */
3591 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3594 file_offset
= H_GET_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3595 if (file_offset
== 0)
3597 /* Nothing in this slot. */
3598 pundef
= &(*pundef
)->next
;
3602 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (hash
* 8));
3603 if (name
[0] != h
->root
.string
[0]
3604 || strcmp (name
, h
->root
.string
) != 0)
3609 /* That was the wrong symbol. Try rehashing. */
3611 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3613 srch
= (srch
+ rehash
) & (armap_count
- 1))
3615 file_offset
= H_GET_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3616 if (file_offset
== 0)
3618 name
= stringbase
+ H_GET_32 (abfd
, hashtable
+ (srch
* 8));
3619 if (name
[0] == h
->root
.string
[0]
3620 && strcmp (name
, h
->root
.string
) == 0)
3629 pundef
= &(*pundef
)->next
;
3636 element
= (*backend
->get_elt_at_filepos
) (abfd
, (file_ptr
) file_offset
);
3637 if (element
== (bfd
*) NULL
)
3640 if (! bfd_check_format (element
, bfd_object
))
3643 /* Unlike the generic linker, we know that this element provides
3644 a definition for an undefined symbol and we know that we want
3645 to include it. We don't need to check anything. */
3646 if (! (*info
->callbacks
->add_archive_element
) (info
, element
, name
))
3648 if (! ecoff_link_add_object_symbols (element
, info
))
3651 pundef
= &(*pundef
)->next
;
3657 /* This is called if we used _bfd_generic_link_add_archive_symbols
3658 because we were not dealing with an ECOFF archive. */
3661 ecoff_link_check_archive_element (abfd
, info
, pneeded
)
3663 struct bfd_link_info
*info
;
3666 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3667 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
3668 = backend
->debug_swap
.swap_ext_in
;
3670 bfd_size_type external_ext_size
;
3671 PTR external_ext
= NULL
;
3672 bfd_size_type esize
;
3679 if (! ecoff_slurp_symbolic_header (abfd
))
3682 /* If there are no symbols, we don't want it. */
3683 if (bfd_get_symcount (abfd
) == 0)
3684 goto successful_return
;
3686 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3688 /* Read in the external symbols and external strings. */
3689 external_ext_size
= backend
->debug_swap
.external_ext_size
;
3690 esize
= symhdr
->iextMax
* external_ext_size
;
3691 external_ext
= (PTR
) bfd_malloc (esize
);
3692 if (external_ext
== NULL
&& esize
!= 0)
3695 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbExtOffset
, SEEK_SET
) != 0
3696 || bfd_bread (external_ext
, esize
, abfd
) != esize
)
3699 ssext
= (char *) bfd_malloc ((bfd_size_type
) symhdr
->issExtMax
);
3700 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3703 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
3704 || (bfd_bread (ssext
, (bfd_size_type
) symhdr
->issExtMax
, abfd
)
3705 != (bfd_size_type
) symhdr
->issExtMax
))
3708 /* Look through the external symbols to see if they define some
3709 symbol that is currently undefined. */
3710 ext_ptr
= (char *) external_ext
;
3711 ext_end
= ext_ptr
+ esize
;
3712 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
)
3717 struct bfd_link_hash_entry
*h
;
3719 (*swap_ext_in
) (abfd
, (PTR
) ext_ptr
, &esym
);
3721 /* See if this symbol defines something. */
3722 if (esym
.asym
.st
!= stGlobal
3723 && esym
.asym
.st
!= stLabel
3724 && esym
.asym
.st
!= stProc
)
3727 switch (esym
.asym
.sc
)
3751 name
= ssext
+ esym
.asym
.iss
;
3752 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
3754 /* Unlike the generic linker, we do not pull in elements because
3755 of common symbols. */
3756 if (h
== (struct bfd_link_hash_entry
*) NULL
3757 || h
->type
!= bfd_link_hash_undefined
)
3760 /* Include this element. */
3761 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
3763 if (! ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
))
3767 goto successful_return
;
3771 if (external_ext
!= NULL
)
3772 free (external_ext
);
3777 if (external_ext
!= NULL
)
3778 free (external_ext
);
3784 /* Add symbols from an ECOFF object file to the global linker hash
3788 ecoff_link_add_object_symbols (abfd
, info
)
3790 struct bfd_link_info
*info
;
3793 bfd_size_type external_ext_size
;
3794 PTR external_ext
= NULL
;
3795 bfd_size_type esize
;
3799 if (! ecoff_slurp_symbolic_header (abfd
))
3802 /* If there are no symbols, we don't want it. */
3803 if (bfd_get_symcount (abfd
) == 0)
3806 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
3808 /* Read in the external symbols and external strings. */
3809 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
3810 esize
= symhdr
->iextMax
* external_ext_size
;
3811 external_ext
= (PTR
) bfd_malloc (esize
);
3812 if (external_ext
== NULL
&& esize
!= 0)
3815 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbExtOffset
, SEEK_SET
) != 0
3816 || bfd_bread (external_ext
, esize
, abfd
) != esize
)
3819 ssext
= (char *) bfd_malloc ((bfd_size_type
) symhdr
->issExtMax
);
3820 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
3823 if (bfd_seek (abfd
, (file_ptr
) symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
3824 || (bfd_bread (ssext
, (bfd_size_type
) symhdr
->issExtMax
, abfd
)
3825 != (bfd_size_type
) symhdr
->issExtMax
))
3828 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
3832 if (external_ext
!= NULL
)
3833 free (external_ext
);
3839 if (external_ext
!= NULL
)
3840 free (external_ext
);
3844 /* Add the external symbols of an object file to the global linker
3845 hash table. The external symbols and strings we are passed are
3846 just allocated on the stack, and will be discarded. We must
3847 explicitly save any information we may need later on in the link.
3848 We do not want to read the external symbol information again. */
3851 ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
)
3853 struct bfd_link_info
*info
;
3857 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3858 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
3859 = backend
->debug_swap
.swap_ext_in
;
3860 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
3861 unsigned long ext_count
;
3862 struct ecoff_link_hash_entry
**sym_hash
;
3867 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
3870 amt
*= sizeof (struct bfd_link_hash_entry
*);
3871 sym_hash
= (struct ecoff_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3874 ecoff_data (abfd
)->sym_hashes
= sym_hash
;
3876 ext_ptr
= (char *) external_ext
;
3877 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
3878 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
3885 struct ecoff_link_hash_entry
*h
;
3889 (*swap_ext_in
) (abfd
, (PTR
) ext_ptr
, &esym
);
3891 /* Skip debugging symbols. */
3893 switch (esym
.asym
.st
)
3909 /* Get the information for this symbol. */
3910 value
= esym
.asym
.value
;
3911 switch (esym
.asym
.sc
)
3931 section
= bfd_make_section_old_way (abfd
, ".text");
3932 value
-= section
->vma
;
3935 section
= bfd_make_section_old_way (abfd
, ".data");
3936 value
-= section
->vma
;
3939 section
= bfd_make_section_old_way (abfd
, ".bss");
3940 value
-= section
->vma
;
3943 section
= bfd_abs_section_ptr
;
3946 section
= bfd_und_section_ptr
;
3949 section
= bfd_make_section_old_way (abfd
, ".sdata");
3950 value
-= section
->vma
;
3953 section
= bfd_make_section_old_way (abfd
, ".sbss");
3954 value
-= section
->vma
;
3957 section
= bfd_make_section_old_way (abfd
, ".rdata");
3958 value
-= section
->vma
;
3961 if (value
> ecoff_data (abfd
)->gp_size
)
3963 section
= bfd_com_section_ptr
;
3968 if (ecoff_scom_section
.name
== NULL
)
3970 /* Initialize the small common section. */
3971 ecoff_scom_section
.name
= SCOMMON
;
3972 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
3973 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
3974 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
3975 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
3976 ecoff_scom_symbol
.name
= SCOMMON
;
3977 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
3978 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
3979 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
3981 section
= &ecoff_scom_section
;
3984 section
= bfd_und_section_ptr
;
3987 section
= bfd_make_section_old_way (abfd
, ".init");
3988 value
-= section
->vma
;
3991 section
= bfd_make_section_old_way (abfd
, ".fini");
3992 value
-= section
->vma
;
3995 section
= bfd_make_section_old_way (abfd
, ".rconst");
3996 value
-= section
->vma
;
4000 if (section
== (asection
*) NULL
)
4003 name
= ssext
+ esym
.asym
.iss
;
4006 if (! (_bfd_generic_link_add_one_symbol
4008 (flagword
) (esym
.weakext
? BSF_WEAK
: BSF_GLOBAL
),
4009 section
, value
, (const char *) NULL
, true, true,
4010 (struct bfd_link_hash_entry
**) &h
)))
4015 /* If we are building an ECOFF hash table, save the external
4016 symbol information. */
4017 if (info
->hash
->creator
->flavour
== bfd_get_flavour (abfd
))
4019 if (h
->abfd
== (bfd
*) NULL
4020 || (! bfd_is_und_section (section
)
4021 && (! bfd_is_com_section (section
)
4022 || (h
->root
.type
!= bfd_link_hash_defined
4023 && h
->root
.type
!= bfd_link_hash_defweak
))))
4029 /* Remember whether this symbol was small undefined. */
4030 if (esym
.asym
.sc
== scSUndefined
)
4033 /* If this symbol was ever small undefined, it needs to wind
4034 up in a GP relative section. We can't control the
4035 section of a defined symbol, but we can control the
4036 section of a common symbol. This case is actually needed
4037 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
4039 && h
->root
.type
== bfd_link_hash_common
4040 && strcmp (h
->root
.u
.c
.p
->section
->name
, SCOMMON
) != 0)
4042 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
4044 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
4045 if (h
->esym
.asym
.sc
== scCommon
)
4046 h
->esym
.asym
.sc
= scSCommon
;
4054 /* ECOFF final link routines. */
4056 static boolean ecoff_final_link_debug_accumulate
4057 PARAMS ((bfd
*output_bfd
, bfd
*input_bfd
, struct bfd_link_info
*,
4059 static boolean ecoff_link_write_external
4060 PARAMS ((struct ecoff_link_hash_entry
*, PTR
));
4061 static boolean ecoff_indirect_link_order
4062 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
4063 struct bfd_link_order
*));
4064 static boolean ecoff_reloc_link_order
4065 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
4066 struct bfd_link_order
*));
4068 /* Structure used to pass information to ecoff_link_write_external. */
4073 struct bfd_link_info
*info
;
4076 /* ECOFF final link routine. This looks through all the input BFDs
4077 and gathers together all the debugging information, and then
4078 processes all the link order information. This may cause it to
4079 close and reopen some input BFDs; I'll see how bad this is. */
4082 _bfd_ecoff_bfd_final_link (abfd
, info
)
4084 struct bfd_link_info
*info
;
4086 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4087 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4090 register bfd
*input_bfd
;
4092 struct bfd_link_order
*p
;
4093 struct extsym_info einfo
;
4095 /* We accumulate the debugging information counts in the symbolic
4097 symhdr
= &debug
->symbolic_header
;
4099 symhdr
->ilineMax
= 0;
4103 symhdr
->isymMax
= 0;
4104 symhdr
->ioptMax
= 0;
4105 symhdr
->iauxMax
= 0;
4107 symhdr
->issExtMax
= 0;
4110 symhdr
->iextMax
= 0;
4112 /* We accumulate the debugging information itself in the debug_info
4115 debug
->external_dnr
= NULL
;
4116 debug
->external_pdr
= NULL
;
4117 debug
->external_sym
= NULL
;
4118 debug
->external_opt
= NULL
;
4119 debug
->external_aux
= NULL
;
4121 debug
->ssext
= debug
->ssext_end
= NULL
;
4122 debug
->external_fdr
= NULL
;
4123 debug
->external_rfd
= NULL
;
4124 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4126 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4127 if (handle
== (PTR
) NULL
)
4130 /* Accumulate the debugging symbols from each input BFD. */
4131 for (input_bfd
= info
->input_bfds
;
4132 input_bfd
!= (bfd
*) NULL
;
4133 input_bfd
= input_bfd
->link_next
)
4137 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4139 /* Abitrarily set the symbolic header vstamp to the vstamp
4140 of the first object file in the link. */
4141 if (symhdr
->vstamp
== 0)
4143 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4144 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4148 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4149 debug
, &backend
->debug_swap
,
4154 /* Combine the register masks. */
4155 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4156 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4157 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4158 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4159 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4160 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4163 /* Write out the external symbols. */
4166 ecoff_link_hash_traverse (ecoff_hash_table (info
),
4167 ecoff_link_write_external
,
4170 if (info
->relocateable
)
4172 /* We need to make a pass over the link_orders to count up the
4173 number of relocations we will need to output, so that we know
4174 how much space they will take up. */
4175 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4178 for (p
= o
->link_order_head
;
4179 p
!= (struct bfd_link_order
*) NULL
;
4181 if (p
->type
== bfd_indirect_link_order
)
4182 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4183 else if (p
->type
== bfd_section_reloc_link_order
4184 || p
->type
== bfd_symbol_reloc_link_order
)
4189 /* Compute the reloc and symbol file positions. */
4190 ecoff_compute_reloc_file_positions (abfd
);
4192 /* Write out the debugging information. */
4193 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4194 &backend
->debug_swap
, info
,
4195 ecoff_data (abfd
)->sym_filepos
))
4198 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4200 if (info
->relocateable
)
4202 /* Now reset the reloc_count field of the sections in the output
4203 BFD to 0, so that we can use them to keep track of how many
4204 relocs we have output thus far. */
4205 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4209 /* Get a value for the GP register. */
4210 if (ecoff_data (abfd
)->gp
== 0)
4212 struct bfd_link_hash_entry
*h
;
4214 h
= bfd_link_hash_lookup (info
->hash
, "_gp", false, false, true);
4215 if (h
!= (struct bfd_link_hash_entry
*) NULL
4216 && h
->type
== bfd_link_hash_defined
)
4217 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4218 + h
->u
.def
.section
->output_section
->vma
4219 + h
->u
.def
.section
->output_offset
);
4220 else if (info
->relocateable
)
4224 /* Make up a value. */
4226 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4229 && (strcmp (o
->name
, _SBSS
) == 0
4230 || strcmp (o
->name
, _SDATA
) == 0
4231 || strcmp (o
->name
, _LIT4
) == 0
4232 || strcmp (o
->name
, _LIT8
) == 0
4233 || strcmp (o
->name
, _LITA
) == 0))
4236 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4240 /* If the relocate_section function needs to do a reloc
4241 involving the GP value, it should make a reloc_dangerous
4242 callback to warn that GP is not defined. */
4246 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4248 for (p
= o
->link_order_head
;
4249 p
!= (struct bfd_link_order
*) NULL
;
4252 if (p
->type
== bfd_indirect_link_order
4253 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4254 == bfd_target_ecoff_flavour
))
4256 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4259 else if (p
->type
== bfd_section_reloc_link_order
4260 || p
->type
== bfd_symbol_reloc_link_order
)
4262 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4267 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4273 bfd_get_symcount (abfd
) = symhdr
->iextMax
+ symhdr
->isymMax
;
4275 ecoff_data (abfd
)->linker
= true;
4280 /* Accumulate the debugging information for an input BFD into the
4281 output BFD. This must read in the symbolic information of the
4285 ecoff_final_link_debug_accumulate (output_bfd
, input_bfd
, info
, handle
)
4288 struct bfd_link_info
*info
;
4291 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
4292 const struct ecoff_debug_swap
* const swap
=
4293 &ecoff_backend (input_bfd
)->debug_swap
;
4294 HDRR
*symhdr
= &debug
->symbolic_header
;
4297 #define READ(ptr, offset, count, size, type) \
4298 if (symhdr->count == 0) \
4299 debug->ptr = NULL; \
4302 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
4303 debug->ptr = (type) bfd_malloc (amt); \
4304 if (debug->ptr == NULL) \
4307 goto return_something; \
4309 if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
4310 || bfd_bread (debug->ptr, amt, input_bfd) != amt) \
4313 goto return_something; \
4317 /* If raw_syments is not NULL, then the data was already by read by
4318 _bfd_ecoff_slurp_symbolic_info. */
4319 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
4321 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
4323 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
4324 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
4325 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
4326 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
4327 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
4329 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
4330 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
4331 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
4335 /* We do not read the external strings or the external symbols. */
4337 ret
= (bfd_ecoff_debug_accumulate
4338 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4339 &ecoff_backend (output_bfd
)->debug_swap
,
4340 input_bfd
, debug
, swap
, info
));
4343 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
4345 if (debug
->line
!= NULL
)
4347 if (debug
->external_dnr
!= NULL
)
4348 free (debug
->external_dnr
);
4349 if (debug
->external_pdr
!= NULL
)
4350 free (debug
->external_pdr
);
4351 if (debug
->external_sym
!= NULL
)
4352 free (debug
->external_sym
);
4353 if (debug
->external_opt
!= NULL
)
4354 free (debug
->external_opt
);
4355 if (debug
->external_aux
!= NULL
)
4356 free (debug
->external_aux
);
4357 if (debug
->ss
!= NULL
)
4359 if (debug
->external_fdr
!= NULL
)
4360 free (debug
->external_fdr
);
4361 if (debug
->external_rfd
!= NULL
)
4362 free (debug
->external_rfd
);
4364 /* Make sure we don't accidentally follow one of these pointers
4365 into freed memory. */
4367 debug
->external_dnr
= NULL
;
4368 debug
->external_pdr
= NULL
;
4369 debug
->external_sym
= NULL
;
4370 debug
->external_opt
= NULL
;
4371 debug
->external_aux
= NULL
;
4373 debug
->external_fdr
= NULL
;
4374 debug
->external_rfd
= NULL
;
4380 /* Put out information for an external symbol. These come only from
4384 ecoff_link_write_external (h
, data
)
4385 struct ecoff_link_hash_entry
*h
;
4388 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4389 bfd
*output_bfd
= einfo
->abfd
;
4392 if (h
->root
.type
== bfd_link_hash_warning
)
4394 h
= (struct ecoff_link_hash_entry
*) h
->root
.u
.i
.link
;
4395 if (h
->root
.type
== bfd_link_hash_new
)
4399 /* We need to check if this symbol is being stripped. */
4400 if (h
->root
.type
== bfd_link_hash_undefined
4401 || h
->root
.type
== bfd_link_hash_undefweak
)
4403 else if (einfo
->info
->strip
== strip_all
4404 || (einfo
->info
->strip
== strip_some
4405 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4406 h
->root
.root
.string
,
4407 false, false) == NULL
))
4412 if (strip
|| h
->written
)
4415 if (h
->abfd
== (bfd
*) NULL
)
4418 h
->esym
.cobol_main
= 0;
4419 h
->esym
.weakext
= 0;
4420 h
->esym
.reserved
= 0;
4421 h
->esym
.ifd
= ifdNil
;
4422 h
->esym
.asym
.value
= 0;
4423 h
->esym
.asym
.st
= stGlobal
;
4425 if (h
->root
.type
!= bfd_link_hash_defined
4426 && h
->root
.type
!= bfd_link_hash_defweak
)
4427 h
->esym
.asym
.sc
= scAbs
;
4430 asection
*output_section
;
4433 output_section
= h
->root
.u
.def
.section
->output_section
;
4434 name
= bfd_section_name (output_section
->owner
, output_section
);
4436 if (strcmp (name
, _TEXT
) == 0)
4437 h
->esym
.asym
.sc
= scText
;
4438 else if (strcmp (name
, _DATA
) == 0)
4439 h
->esym
.asym
.sc
= scData
;
4440 else if (strcmp (name
, _SDATA
) == 0)
4441 h
->esym
.asym
.sc
= scSData
;
4442 else if (strcmp (name
, _RDATA
) == 0)
4443 h
->esym
.asym
.sc
= scRData
;
4444 else if (strcmp (name
, _BSS
) == 0)
4445 h
->esym
.asym
.sc
= scBss
;
4446 else if (strcmp (name
, _SBSS
) == 0)
4447 h
->esym
.asym
.sc
= scSBss
;
4448 else if (strcmp (name
, _INIT
) == 0)
4449 h
->esym
.asym
.sc
= scInit
;
4450 else if (strcmp (name
, _FINI
) == 0)
4451 h
->esym
.asym
.sc
= scFini
;
4452 else if (strcmp (name
, _PDATA
) == 0)
4453 h
->esym
.asym
.sc
= scPData
;
4454 else if (strcmp (name
, _XDATA
) == 0)
4455 h
->esym
.asym
.sc
= scXData
;
4456 else if (strcmp (name
, _RCONST
) == 0)
4457 h
->esym
.asym
.sc
= scRConst
;
4459 h
->esym
.asym
.sc
= scAbs
;
4462 h
->esym
.asym
.reserved
= 0;
4463 h
->esym
.asym
.index
= indexNil
;
4465 else if (h
->esym
.ifd
!= -1)
4467 struct ecoff_debug_info
*debug
;
4469 /* Adjust the FDR index for the symbol by that used for the
4471 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4472 BFD_ASSERT (h
->esym
.ifd
>= 0
4473 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4474 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4477 switch (h
->root
.type
)
4480 case bfd_link_hash_warning
:
4481 case bfd_link_hash_new
:
4483 case bfd_link_hash_undefined
:
4484 case bfd_link_hash_undefweak
:
4485 if (h
->esym
.asym
.sc
!= scUndefined
4486 && h
->esym
.asym
.sc
!= scSUndefined
)
4487 h
->esym
.asym
.sc
= scUndefined
;
4489 case bfd_link_hash_defined
:
4490 case bfd_link_hash_defweak
:
4491 if (h
->esym
.asym
.sc
== scUndefined
4492 || h
->esym
.asym
.sc
== scSUndefined
)
4493 h
->esym
.asym
.sc
= scAbs
;
4494 else if (h
->esym
.asym
.sc
== scCommon
)
4495 h
->esym
.asym
.sc
= scBss
;
4496 else if (h
->esym
.asym
.sc
== scSCommon
)
4497 h
->esym
.asym
.sc
= scSBss
;
4498 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4499 + h
->root
.u
.def
.section
->output_section
->vma
4500 + h
->root
.u
.def
.section
->output_offset
);
4502 case bfd_link_hash_common
:
4503 if (h
->esym
.asym
.sc
!= scCommon
4504 && h
->esym
.asym
.sc
!= scSCommon
)
4505 h
->esym
.asym
.sc
= scCommon
;
4506 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4508 case bfd_link_hash_indirect
:
4509 /* We ignore these symbols, since the indirected symbol is
4510 already in the hash table. */
4514 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4516 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4519 return (bfd_ecoff_debug_one_external
4520 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4521 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4525 /* Relocate and write an ECOFF section into an ECOFF output file. */
4528 ecoff_indirect_link_order (output_bfd
, info
, output_section
, link_order
)
4530 struct bfd_link_info
*info
;
4531 asection
*output_section
;
4532 struct bfd_link_order
*link_order
;
4534 asection
*input_section
;
4536 struct ecoff_section_tdata
*section_tdata
;
4537 bfd_size_type raw_size
;
4538 bfd_size_type cooked_size
;
4539 bfd_byte
*contents
= NULL
;
4540 bfd_size_type external_reloc_size
;
4541 bfd_size_type external_relocs_size
;
4542 PTR external_relocs
= NULL
;
4545 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
4547 if (link_order
->size
== 0)
4550 input_section
= link_order
->u
.indirect
.section
;
4551 input_bfd
= input_section
->owner
;
4552 section_tdata
= ecoff_section_data (input_bfd
, input_section
);
4554 raw_size
= input_section
->_raw_size
;
4555 cooked_size
= input_section
->_cooked_size
;
4556 if (cooked_size
== 0)
4557 cooked_size
= raw_size
;
4559 BFD_ASSERT (input_section
->output_section
== output_section
);
4560 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
4561 BFD_ASSERT (cooked_size
== link_order
->size
);
4563 /* Get the section contents. We allocate memory for the larger of
4564 the size before relocating and the size after relocating. */
4565 amt
= raw_size
>= cooked_size
? raw_size
: cooked_size
;
4566 contents
= (bfd_byte
*) bfd_malloc (amt
);
4567 if (contents
== NULL
&& amt
!= 0)
4570 /* If we are relaxing, the contents may have already been read into
4571 memory, in which case we copy them into our new buffer. We don't
4572 simply reuse the old buffer in case cooked_size > raw_size. */
4573 if (section_tdata
!= (struct ecoff_section_tdata
*) NULL
4574 && section_tdata
->contents
!= (bfd_byte
*) NULL
)
4575 memcpy (contents
, section_tdata
->contents
, (size_t) raw_size
);
4578 if (! bfd_get_section_contents (input_bfd
, input_section
,
4580 (file_ptr
) 0, raw_size
))
4584 /* Get the relocs. If we are relaxing MIPS code, they will already
4585 have been read in. Otherwise, we read them in now. */
4586 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
4587 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
4589 if (section_tdata
!= (struct ecoff_section_tdata
*) NULL
4590 && section_tdata
->external_relocs
!= NULL
)
4591 external_relocs
= section_tdata
->external_relocs
;
4594 external_relocs
= (PTR
) bfd_malloc (external_relocs_size
);
4595 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
4598 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
4599 || (bfd_bread (external_relocs
, external_relocs_size
, input_bfd
)
4600 != external_relocs_size
))
4604 /* Relocate the section contents. */
4605 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
4606 (output_bfd
, info
, input_bfd
, input_section
, contents
,
4610 /* Write out the relocated section. */
4611 if (! bfd_set_section_contents (output_bfd
,
4614 (file_ptr
) input_section
->output_offset
,
4618 /* If we are producing relocateable output, the relocs were
4619 modified, and we write them out now. We use the reloc_count
4620 field of output_section to keep track of the number of relocs we
4621 have output so far. */
4622 if (info
->relocateable
)
4624 file_ptr pos
= (output_section
->rel_filepos
4625 + output_section
->reloc_count
* external_reloc_size
);
4626 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
4627 || (bfd_bwrite (external_relocs
, external_relocs_size
, output_bfd
)
4628 != external_relocs_size
))
4630 output_section
->reloc_count
+= input_section
->reloc_count
;
4633 if (contents
!= NULL
)
4635 if (external_relocs
!= NULL
&& section_tdata
== NULL
)
4636 free (external_relocs
);
4640 if (contents
!= NULL
)
4642 if (external_relocs
!= NULL
&& section_tdata
== NULL
)
4643 free (external_relocs
);
4647 /* Generate a reloc when linking an ECOFF file. This is a reloc
4648 requested by the linker, and does come from any input file. This
4649 is used to build constructor and destructor tables when linking
4653 ecoff_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
4655 struct bfd_link_info
*info
;
4656 asection
*output_section
;
4657 struct bfd_link_order
*link_order
;
4659 enum bfd_link_order_type type
;
4663 struct internal_reloc in
;
4664 bfd_size_type external_reloc_size
;
4669 type
= link_order
->type
;
4671 addend
= link_order
->u
.reloc
.p
->addend
;
4673 /* We set up an arelent to pass to the backend adjust_reloc_out
4675 rel
.address
= link_order
->offset
;
4677 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
4680 bfd_set_error (bfd_error_bad_value
);
4684 if (type
== bfd_section_reloc_link_order
)
4686 section
= link_order
->u
.reloc
.p
->u
.section
;
4687 rel
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
4691 struct bfd_link_hash_entry
*h
;
4693 /* Treat a reloc against a defined symbol as though it were
4694 actually against the section. */
4695 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4696 link_order
->u
.reloc
.p
->u
.name
,
4697 false, false, false);
4699 && (h
->type
== bfd_link_hash_defined
4700 || h
->type
== bfd_link_hash_defweak
))
4702 type
= bfd_section_reloc_link_order
;
4703 section
= h
->u
.def
.section
->output_section
;
4704 /* It seems that we ought to add the symbol value to the
4705 addend here, but in practice it has already been added
4706 because it was passed to constructor_callback. */
4707 addend
+= section
->vma
+ h
->u
.def
.section
->output_offset
;
4711 /* We can't set up a reloc against a symbol correctly,
4712 because we have no asymbol structure. Currently no
4713 adjust_reloc_out routine cares. */
4714 rel
.sym_ptr_ptr
= (asymbol
**) NULL
;
4718 /* All ECOFF relocs are in-place. Put the addend into the object
4721 BFD_ASSERT (rel
.howto
->partial_inplace
);
4725 bfd_reloc_status_type rstat
;
4728 size
= bfd_get_reloc_size (rel
.howto
);
4729 buf
= (bfd_byte
*) bfd_zmalloc (size
);
4730 if (buf
== (bfd_byte
*) NULL
)
4732 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
4733 (bfd_vma
) addend
, buf
);
4739 case bfd_reloc_outofrange
:
4741 case bfd_reloc_overflow
:
4742 if (! ((*info
->callbacks
->reloc_overflow
)
4744 (link_order
->type
== bfd_section_reloc_link_order
4745 ? bfd_section_name (output_bfd
, section
)
4746 : link_order
->u
.reloc
.p
->u
.name
),
4747 rel
.howto
->name
, addend
, (bfd
*) NULL
,
4748 (asection
*) NULL
, (bfd_vma
) 0)))
4755 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
4756 (file_ptr
) link_order
->offset
, size
);
4764 /* Move the information into an internal_reloc structure. */
4765 in
.r_vaddr
= (rel
.address
4766 + bfd_get_section_vma (output_bfd
, output_section
));
4767 in
.r_type
= rel
.howto
->type
;
4769 if (type
== bfd_symbol_reloc_link_order
)
4771 struct ecoff_link_hash_entry
*h
;
4773 h
= ((struct ecoff_link_hash_entry
*)
4774 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4775 link_order
->u
.reloc
.p
->u
.name
,
4776 false, false, true));
4777 if (h
!= (struct ecoff_link_hash_entry
*) NULL
4779 in
.r_symndx
= h
->indx
;
4782 if (! ((*info
->callbacks
->unattached_reloc
)
4783 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
4784 (asection
*) NULL
, (bfd_vma
) 0)))
4794 name
= bfd_get_section_name (output_bfd
, section
);
4795 if (strcmp (name
, ".text") == 0)
4796 in
.r_symndx
= RELOC_SECTION_TEXT
;
4797 else if (strcmp (name
, ".rdata") == 0)
4798 in
.r_symndx
= RELOC_SECTION_RDATA
;
4799 else if (strcmp (name
, ".data") == 0)
4800 in
.r_symndx
= RELOC_SECTION_DATA
;
4801 else if (strcmp (name
, ".sdata") == 0)
4802 in
.r_symndx
= RELOC_SECTION_SDATA
;
4803 else if (strcmp (name
, ".sbss") == 0)
4804 in
.r_symndx
= RELOC_SECTION_SBSS
;
4805 else if (strcmp (name
, ".bss") == 0)
4806 in
.r_symndx
= RELOC_SECTION_BSS
;
4807 else if (strcmp (name
, ".init") == 0)
4808 in
.r_symndx
= RELOC_SECTION_INIT
;
4809 else if (strcmp (name
, ".lit8") == 0)
4810 in
.r_symndx
= RELOC_SECTION_LIT8
;
4811 else if (strcmp (name
, ".lit4") == 0)
4812 in
.r_symndx
= RELOC_SECTION_LIT4
;
4813 else if (strcmp (name
, ".xdata") == 0)
4814 in
.r_symndx
= RELOC_SECTION_XDATA
;
4815 else if (strcmp (name
, ".pdata") == 0)
4816 in
.r_symndx
= RELOC_SECTION_PDATA
;
4817 else if (strcmp (name
, ".fini") == 0)
4818 in
.r_symndx
= RELOC_SECTION_FINI
;
4819 else if (strcmp (name
, ".lita") == 0)
4820 in
.r_symndx
= RELOC_SECTION_LITA
;
4821 else if (strcmp (name
, "*ABS*") == 0)
4822 in
.r_symndx
= RELOC_SECTION_ABS
;
4823 else if (strcmp (name
, ".rconst") == 0)
4824 in
.r_symndx
= RELOC_SECTION_RCONST
;
4830 /* Let the BFD backend adjust the reloc. */
4831 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
4833 /* Get some memory and swap out the reloc. */
4834 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
4835 rbuf
= (bfd_byte
*) bfd_malloc (external_reloc_size
);
4836 if (rbuf
== (bfd_byte
*) NULL
)
4839 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (PTR
) rbuf
);
4841 pos
= (output_section
->rel_filepos
4842 + output_section
->reloc_count
* external_reloc_size
);
4843 ok
= (bfd_seek (output_bfd
, pos
, SEEK_SET
) == 0
4844 && (bfd_bwrite ((PTR
) rbuf
, external_reloc_size
, output_bfd
)
4845 == external_reloc_size
));
4848 ++output_section
->reloc_count
;