1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
3 Original version by Per Bothner.
4 Full support added by Ian Lance Taylor, ian@cygnus.com.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
27 #include "aout/ranlib.h"
28 #include "aout/stab_gnu.h"
30 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
31 some other stuff which we don't want and which conflicts with stuff
34 #include "aout/aout64.h"
37 #undef obj_sym_filepos
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
46 /* Prototypes for static functions. */
48 static int ecoff_get_magic
PARAMS ((bfd
*abfd
));
49 static long ecoff_sec_to_styp_flags
PARAMS ((const char *name
,
51 static boolean ecoff_slurp_symbolic_header
PARAMS ((bfd
*abfd
));
52 static boolean ecoff_set_symbol_info
PARAMS ((bfd
*abfd
, SYMR
*ecoff_sym
,
53 asymbol
*asym
, int ext
,
54 asymbol
**indirect_ptr_ptr
));
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 void ecoff_compute_section_file_positions
PARAMS ((bfd
*abfd
));
64 static bfd_size_type ecoff_compute_reloc_file_positions
PARAMS ((bfd
*abfd
));
65 static boolean ecoff_get_extr
PARAMS ((asymbol
*, EXTR
*));
66 static void ecoff_set_index
PARAMS ((asymbol
*, bfd_size_type
));
67 static unsigned int ecoff_armap_hash
PARAMS ((CONST
char *s
,
72 /* This stuff is somewhat copied from coffcode.h. */
74 static asection bfd_debug_section
= { "*DEBUG*" };
76 /* Create an ECOFF object. */
79 _bfd_ecoff_mkobject (abfd
)
82 abfd
->tdata
.ecoff_obj_data
= ((struct ecoff_tdata
*)
83 bfd_zalloc (abfd
, sizeof (ecoff_data_type
)));
84 if (abfd
->tdata
.ecoff_obj_data
== NULL
)
86 bfd_set_error (bfd_error_no_memory
);
93 /* This is a hook called by coff_real_object_p to create any backend
94 specific information. */
97 _bfd_ecoff_mkobject_hook (abfd
, filehdr
, aouthdr
)
102 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
103 struct internal_aouthdr
*internal_a
= (struct internal_aouthdr
*) aouthdr
;
104 ecoff_data_type
*ecoff
;
106 if (_bfd_ecoff_mkobject (abfd
) == false)
109 ecoff
= ecoff_data (abfd
);
111 ecoff
->sym_filepos
= internal_f
->f_symptr
;
113 if (internal_a
!= (struct internal_aouthdr
*) NULL
)
117 ecoff
->text_start
= internal_a
->text_start
;
118 ecoff
->text_end
= internal_a
->text_start
+ internal_a
->tsize
;
119 ecoff
->gp
= internal_a
->gp_value
;
120 ecoff
->gprmask
= internal_a
->gprmask
;
121 for (i
= 0; i
< 4; i
++)
122 ecoff
->cprmask
[i
] = internal_a
->cprmask
[i
];
123 ecoff
->fprmask
= internal_a
->fprmask
;
124 if (internal_a
->magic
== ECOFF_AOUT_ZMAGIC
)
125 abfd
->flags
|= D_PAGED
;
128 /* It turns out that no special action is required by the MIPS or
129 Alpha ECOFF backends. They have different information in the
130 a.out header, but we just copy it all (e.g., gprmask, cprmask and
131 fprmask) and let the swapping routines ensure that only relevant
132 information is written out. */
137 /* This is a hook needed by SCO COFF, but we have nothing to do. */
141 _bfd_ecoff_make_section_hook (abfd
, name
)
145 return (asection
*) NULL
;
148 /* Initialize a new section. */
151 _bfd_ecoff_new_section_hook (abfd
, section
)
155 /* For the .pdata section, which has a special meaning on the Alpha,
156 we set the alignment power to 3. We correct this later in
157 ecoff_compute_section_file_positions. We do this hackery because
158 we need to know the exact unaligned size of the .pdata section in
159 order to set the lnnoptr field correctly. For every other
160 section we use an alignment power of 4; this could be made target
161 dependent by adding a field to ecoff_backend_data, but 4 appears
162 to be correct for both the MIPS and the Alpha. */
163 if (strcmp (section
->name
, _PDATA
) == 0)
164 section
->alignment_power
= 3;
166 section
->alignment_power
= 4;
168 if (strcmp (section
->name
, _TEXT
) == 0)
169 section
->flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
170 else if (strcmp (section
->name
, _DATA
) == 0
171 || strcmp (section
->name
, _SDATA
) == 0)
172 section
->flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
173 else if (strcmp (section
->name
, _RDATA
) == 0
174 || strcmp (section
->name
, _LIT8
) == 0
175 || strcmp (section
->name
, _LIT4
) == 0)
176 section
->flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
177 else if (strcmp (section
->name
, _BSS
) == 0
178 || strcmp (section
->name
, _SBSS
) == 0)
179 section
->flags
|= SEC_ALLOC
;
180 else if (strcmp (section
->name
, _LIB
) == 0)
182 /* An Irix 4 shared libary. */
183 section
->flags
|= SEC_COFF_SHARED_LIBRARY
;
186 /* Probably any other section name is SEC_NEVER_LOAD, but I'm
187 uncertain about .init on some systems and I don't know how shared
193 /* Determine the machine architecture and type. This is called from
194 the generic COFF routines. It is the inverse of ecoff_get_magic,
195 below. This could be an ECOFF backend routine, with one version
196 for each target, but there aren't all that many ECOFF targets. */
199 _bfd_ecoff_set_arch_mach_hook (abfd
, filehdr
)
203 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
204 enum bfd_architecture arch
;
207 switch (internal_f
->f_magic
)
210 case MIPS_MAGIC_LITTLE
:
212 arch
= bfd_arch_mips
;
216 case MIPS_MAGIC_LITTLE2
:
217 case MIPS_MAGIC_BIG2
:
218 /* MIPS ISA level 2: the r6000 */
219 arch
= bfd_arch_mips
;
223 case MIPS_MAGIC_LITTLE3
:
224 case MIPS_MAGIC_BIG3
:
225 /* MIPS ISA level 3: the r4000 */
226 arch
= bfd_arch_mips
;
231 arch
= bfd_arch_alpha
;
236 arch
= bfd_arch_obscure
;
241 return bfd_default_set_arch_mach (abfd
, arch
, mach
);
244 /* Get the magic number to use based on the architecture and machine.
245 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
248 ecoff_get_magic (abfd
)
253 switch (bfd_get_arch (abfd
))
256 switch (bfd_get_mach (abfd
))
261 big
= MIPS_MAGIC_BIG
;
262 little
= MIPS_MAGIC_LITTLE
;
266 big
= MIPS_MAGIC_BIG2
;
267 little
= MIPS_MAGIC_LITTLE2
;
271 big
= MIPS_MAGIC_BIG3
;
272 little
= MIPS_MAGIC_LITTLE3
;
276 return abfd
->xvec
->byteorder_big_p
? big
: little
;
287 /* Get the section s_flags to use for a section. */
290 ecoff_sec_to_styp_flags (name
, flags
)
298 if (strcmp (name
, _TEXT
) == 0)
300 else if (strcmp (name
, _DATA
) == 0)
302 else if (strcmp (name
, _SDATA
) == 0)
304 else if (strcmp (name
, _RDATA
) == 0)
306 else if (strcmp (name
, _LITA
) == 0)
308 else if (strcmp (name
, _LIT8
) == 0)
310 else if (strcmp (name
, _LIT4
) == 0)
312 else if (strcmp (name
, _BSS
) == 0)
314 else if (strcmp (name
, _SBSS
) == 0)
316 else if (strcmp (name
, _INIT
) == 0)
317 styp
= STYP_ECOFF_INIT
;
318 else if (strcmp (name
, _FINI
) == 0)
319 styp
= STYP_ECOFF_FINI
;
320 else if (strcmp (name
, _PDATA
) == 0)
322 else if (strcmp (name
, _XDATA
) == 0)
324 else if (strcmp (name
, _LIB
) == 0)
325 styp
= STYP_ECOFF_LIB
;
326 else if (flags
& SEC_CODE
)
328 else if (flags
& SEC_DATA
)
330 else if (flags
& SEC_READONLY
)
332 else if (flags
& SEC_LOAD
)
337 if (flags
& SEC_NEVER_LOAD
)
343 /* Get the BFD flags to use for a section. */
347 _bfd_ecoff_styp_to_sec_flags (abfd
, hdr
, name
)
352 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
353 long styp_flags
= internal_s
->s_flags
;
354 flagword sec_flags
=0;
356 if (styp_flags
& STYP_NOLOAD
)
357 sec_flags
|= SEC_NEVER_LOAD
;
359 /* For 386 COFF, at least, an unloadable text or data section is
360 actually a shared library section. */
361 if ((styp_flags
& STYP_TEXT
)
362 || (styp_flags
& STYP_ECOFF_INIT
)
363 || (styp_flags
& STYP_ECOFF_FINI
))
365 if (sec_flags
& SEC_NEVER_LOAD
)
366 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
368 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
370 else if ((styp_flags
& STYP_DATA
)
371 || (styp_flags
& STYP_RDATA
)
372 || (styp_flags
& STYP_SDATA
)
373 || styp_flags
== STYP_PDATA
374 || styp_flags
== STYP_XDATA
)
376 if (sec_flags
& SEC_NEVER_LOAD
)
377 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
379 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
380 if ((styp_flags
& STYP_RDATA
)
381 || styp_flags
== STYP_PDATA
)
382 sec_flags
|= SEC_READONLY
;
384 else if ((styp_flags
& STYP_BSS
)
385 || (styp_flags
& STYP_SBSS
))
387 sec_flags
|= SEC_ALLOC
;
389 else if ((styp_flags
& STYP_INFO
) || styp_flags
== STYP_COMMENT
)
391 sec_flags
|= SEC_NEVER_LOAD
;
393 else if ((styp_flags
& STYP_LITA
)
394 || (styp_flags
& STYP_LIT8
)
395 || (styp_flags
& STYP_LIT4
))
397 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
399 else if (styp_flags
& STYP_ECOFF_LIB
)
401 sec_flags
|= SEC_COFF_SHARED_LIBRARY
;
405 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
411 /* Routines to swap auxiliary information in and out. I am assuming
412 that the auxiliary information format is always going to be target
415 /* Swap in a type information record.
416 BIGEND says whether AUX symbols are big-endian or little-endian; this
417 info comes from the file header record (fh-fBigendian). */
420 _bfd_ecoff_swap_tir_in (bigend
, ext_copy
, intern
)
422 const struct tir_ext
*ext_copy
;
425 struct tir_ext ext
[1];
427 *ext
= *ext_copy
; /* Make it reasonable to do in-place. */
429 /* now the fun stuff... */
431 intern
->fBitfield
= 0 != (ext
->t_bits1
[0] & TIR_BITS1_FBITFIELD_BIG
);
432 intern
->continued
= 0 != (ext
->t_bits1
[0] & TIR_BITS1_CONTINUED_BIG
);
433 intern
->bt
= (ext
->t_bits1
[0] & TIR_BITS1_BT_BIG
)
434 >> TIR_BITS1_BT_SH_BIG
;
435 intern
->tq4
= (ext
->t_tq45
[0] & TIR_BITS_TQ4_BIG
)
436 >> TIR_BITS_TQ4_SH_BIG
;
437 intern
->tq5
= (ext
->t_tq45
[0] & TIR_BITS_TQ5_BIG
)
438 >> TIR_BITS_TQ5_SH_BIG
;
439 intern
->tq0
= (ext
->t_tq01
[0] & TIR_BITS_TQ0_BIG
)
440 >> TIR_BITS_TQ0_SH_BIG
;
441 intern
->tq1
= (ext
->t_tq01
[0] & TIR_BITS_TQ1_BIG
)
442 >> TIR_BITS_TQ1_SH_BIG
;
443 intern
->tq2
= (ext
->t_tq23
[0] & TIR_BITS_TQ2_BIG
)
444 >> TIR_BITS_TQ2_SH_BIG
;
445 intern
->tq3
= (ext
->t_tq23
[0] & TIR_BITS_TQ3_BIG
)
446 >> TIR_BITS_TQ3_SH_BIG
;
448 intern
->fBitfield
= 0 != (ext
->t_bits1
[0] & TIR_BITS1_FBITFIELD_LITTLE
);
449 intern
->continued
= 0 != (ext
->t_bits1
[0] & TIR_BITS1_CONTINUED_LITTLE
);
450 intern
->bt
= (ext
->t_bits1
[0] & TIR_BITS1_BT_LITTLE
)
451 >> TIR_BITS1_BT_SH_LITTLE
;
452 intern
->tq4
= (ext
->t_tq45
[0] & TIR_BITS_TQ4_LITTLE
)
453 >> TIR_BITS_TQ4_SH_LITTLE
;
454 intern
->tq5
= (ext
->t_tq45
[0] & TIR_BITS_TQ5_LITTLE
)
455 >> TIR_BITS_TQ5_SH_LITTLE
;
456 intern
->tq0
= (ext
->t_tq01
[0] & TIR_BITS_TQ0_LITTLE
)
457 >> TIR_BITS_TQ0_SH_LITTLE
;
458 intern
->tq1
= (ext
->t_tq01
[0] & TIR_BITS_TQ1_LITTLE
)
459 >> TIR_BITS_TQ1_SH_LITTLE
;
460 intern
->tq2
= (ext
->t_tq23
[0] & TIR_BITS_TQ2_LITTLE
)
461 >> TIR_BITS_TQ2_SH_LITTLE
;
462 intern
->tq3
= (ext
->t_tq23
[0] & TIR_BITS_TQ3_LITTLE
)
463 >> TIR_BITS_TQ3_SH_LITTLE
;
467 if (memcmp ((char *)ext
, (char *)intern
, sizeof (*intern
)) != 0)
472 /* Swap out a type information record.
473 BIGEND says whether AUX symbols are big-endian or little-endian; this
474 info comes from the file header record (fh-fBigendian). */
477 _bfd_ecoff_swap_tir_out (bigend
, intern_copy
, ext
)
479 const TIR
*intern_copy
;
484 *intern
= *intern_copy
; /* Make it reasonable to do in-place. */
486 /* now the fun stuff... */
488 ext
->t_bits1
[0] = ((intern
->fBitfield
? TIR_BITS1_FBITFIELD_BIG
: 0)
489 | (intern
->continued
? TIR_BITS1_CONTINUED_BIG
: 0)
490 | ((intern
->bt
<< TIR_BITS1_BT_SH_BIG
)
491 & TIR_BITS1_BT_BIG
));
492 ext
->t_tq45
[0] = (((intern
->tq4
<< TIR_BITS_TQ4_SH_BIG
)
494 | ((intern
->tq5
<< TIR_BITS_TQ5_SH_BIG
)
495 & TIR_BITS_TQ5_BIG
));
496 ext
->t_tq01
[0] = (((intern
->tq0
<< TIR_BITS_TQ0_SH_BIG
)
498 | ((intern
->tq1
<< TIR_BITS_TQ1_SH_BIG
)
499 & TIR_BITS_TQ1_BIG
));
500 ext
->t_tq23
[0] = (((intern
->tq2
<< TIR_BITS_TQ2_SH_BIG
)
502 | ((intern
->tq3
<< TIR_BITS_TQ3_SH_BIG
)
503 & TIR_BITS_TQ3_BIG
));
505 ext
->t_bits1
[0] = ((intern
->fBitfield
? TIR_BITS1_FBITFIELD_LITTLE
: 0)
506 | (intern
->continued
? TIR_BITS1_CONTINUED_LITTLE
: 0)
507 | ((intern
->bt
<< TIR_BITS1_BT_SH_LITTLE
)
508 & TIR_BITS1_BT_LITTLE
));
509 ext
->t_tq45
[0] = (((intern
->tq4
<< TIR_BITS_TQ4_SH_LITTLE
)
510 & TIR_BITS_TQ4_LITTLE
)
511 | ((intern
->tq5
<< TIR_BITS_TQ5_SH_LITTLE
)
512 & TIR_BITS_TQ5_LITTLE
));
513 ext
->t_tq01
[0] = (((intern
->tq0
<< TIR_BITS_TQ0_SH_LITTLE
)
514 & TIR_BITS_TQ0_LITTLE
)
515 | ((intern
->tq1
<< TIR_BITS_TQ1_SH_LITTLE
)
516 & TIR_BITS_TQ1_LITTLE
));
517 ext
->t_tq23
[0] = (((intern
->tq2
<< TIR_BITS_TQ2_SH_LITTLE
)
518 & TIR_BITS_TQ2_LITTLE
)
519 | ((intern
->tq3
<< TIR_BITS_TQ3_SH_LITTLE
)
520 & TIR_BITS_TQ3_LITTLE
));
524 if (memcmp ((char *)ext
, (char *)intern
, sizeof (*intern
)) != 0)
529 /* Swap in a relative symbol record. BIGEND says whether it is in
530 big-endian or little-endian format.*/
533 _bfd_ecoff_swap_rndx_in (bigend
, ext_copy
, intern
)
535 const struct rndx_ext
*ext_copy
;
538 struct rndx_ext ext
[1];
540 *ext
= *ext_copy
; /* Make it reasonable to do in-place. */
542 /* now the fun stuff... */
544 intern
->rfd
= (ext
->r_bits
[0] << RNDX_BITS0_RFD_SH_LEFT_BIG
)
545 | ((ext
->r_bits
[1] & RNDX_BITS1_RFD_BIG
)
546 >> RNDX_BITS1_RFD_SH_BIG
);
547 intern
->index
= ((ext
->r_bits
[1] & RNDX_BITS1_INDEX_BIG
)
548 << RNDX_BITS1_INDEX_SH_LEFT_BIG
)
549 | (ext
->r_bits
[2] << RNDX_BITS2_INDEX_SH_LEFT_BIG
)
550 | (ext
->r_bits
[3] << RNDX_BITS3_INDEX_SH_LEFT_BIG
);
552 intern
->rfd
= (ext
->r_bits
[0] << RNDX_BITS0_RFD_SH_LEFT_LITTLE
)
553 | ((ext
->r_bits
[1] & RNDX_BITS1_RFD_LITTLE
)
554 << RNDX_BITS1_RFD_SH_LEFT_LITTLE
);
555 intern
->index
= ((ext
->r_bits
[1] & RNDX_BITS1_INDEX_LITTLE
)
556 >> RNDX_BITS1_INDEX_SH_LITTLE
)
557 | (ext
->r_bits
[2] << RNDX_BITS2_INDEX_SH_LEFT_LITTLE
)
558 | ((unsigned int) ext
->r_bits
[3]
559 << RNDX_BITS3_INDEX_SH_LEFT_LITTLE
);
563 if (memcmp ((char *)ext
, (char *)intern
, sizeof (*intern
)) != 0)
568 /* Swap out a relative symbol record. BIGEND says whether it is in
569 big-endian or little-endian format.*/
572 _bfd_ecoff_swap_rndx_out (bigend
, intern_copy
, ext
)
574 const RNDXR
*intern_copy
;
575 struct rndx_ext
*ext
;
579 *intern
= *intern_copy
; /* Make it reasonable to do in-place. */
581 /* now the fun stuff... */
583 ext
->r_bits
[0] = intern
->rfd
>> RNDX_BITS0_RFD_SH_LEFT_BIG
;
584 ext
->r_bits
[1] = (((intern
->rfd
<< RNDX_BITS1_RFD_SH_BIG
)
585 & RNDX_BITS1_RFD_BIG
)
586 | ((intern
->index
>> RNDX_BITS1_INDEX_SH_LEFT_BIG
)
587 & RNDX_BITS1_INDEX_BIG
));
588 ext
->r_bits
[2] = intern
->index
>> RNDX_BITS2_INDEX_SH_LEFT_BIG
;
589 ext
->r_bits
[3] = intern
->index
>> RNDX_BITS3_INDEX_SH_LEFT_BIG
;
591 ext
->r_bits
[0] = intern
->rfd
>> RNDX_BITS0_RFD_SH_LEFT_LITTLE
;
592 ext
->r_bits
[1] = (((intern
->rfd
>> RNDX_BITS1_RFD_SH_LEFT_LITTLE
)
593 & RNDX_BITS1_RFD_LITTLE
)
594 | ((intern
->index
<< RNDX_BITS1_INDEX_SH_LITTLE
)
595 & RNDX_BITS1_INDEX_LITTLE
));
596 ext
->r_bits
[2] = intern
->index
>> RNDX_BITS2_INDEX_SH_LEFT_LITTLE
;
597 ext
->r_bits
[3] = intern
->index
>> RNDX_BITS3_INDEX_SH_LEFT_LITTLE
;
601 if (memcmp ((char *)ext
, (char *)intern
, sizeof (*intern
)) != 0)
606 /* Read in the symbolic header for an ECOFF object file. */
609 ecoff_slurp_symbolic_header (abfd
)
612 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
613 bfd_size_type external_hdr_size
;
615 HDRR
*internal_symhdr
;
617 /* See if we've already read it in. */
618 if (ecoff_data (abfd
)->debug_info
.symbolic_header
.magic
==
619 backend
->debug_swap
.sym_magic
)
622 /* See whether there is a symbolic header. */
623 if (ecoff_data (abfd
)->sym_filepos
== 0)
625 bfd_get_symcount (abfd
) = 0;
629 /* At this point bfd_get_symcount (abfd) holds the number of symbols
630 as read from the file header, but on ECOFF this is always the
631 size of the symbolic information header. It would be cleaner to
632 handle this when we first read the file in coffgen.c. */
633 external_hdr_size
= backend
->debug_swap
.external_hdr_size
;
634 if (bfd_get_symcount (abfd
) != external_hdr_size
)
636 bfd_set_error (bfd_error_bad_value
);
640 /* Read the symbolic information header. */
641 raw
= (PTR
) malloc ((size_t) external_hdr_size
);
644 bfd_set_error (bfd_error_no_memory
);
648 if (bfd_seek (abfd
, ecoff_data (abfd
)->sym_filepos
, SEEK_SET
) == -1
649 || (bfd_read (raw
, external_hdr_size
, 1, abfd
)
650 != external_hdr_size
))
652 internal_symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
653 (*backend
->debug_swap
.swap_hdr_in
) (abfd
, raw
, internal_symhdr
);
655 if (internal_symhdr
->magic
!= backend
->debug_swap
.sym_magic
)
657 bfd_set_error (bfd_error_bad_value
);
661 /* Now we can get the correct number of symbols. */
662 bfd_get_symcount (abfd
) = (internal_symhdr
->isymMax
663 + internal_symhdr
->iextMax
);
674 /* Read in and swap the important symbolic information for an ECOFF
675 object file. This is called by gdb via the read_debug_info entry
676 point in the backend structure. */
680 _bfd_ecoff_slurp_symbolic_info (abfd
, ignore
, debug
)
683 struct ecoff_debug_info
*debug
;
685 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
686 HDRR
*internal_symhdr
;
687 bfd_size_type raw_base
;
688 bfd_size_type raw_size
;
690 bfd_size_type external_fdr_size
;
694 bfd_size_type raw_end
;
695 bfd_size_type cb_end
;
697 BFD_ASSERT (debug
== &ecoff_data (abfd
)->debug_info
);
699 /* Check whether we've already gotten it, and whether there's any to
701 if (ecoff_data (abfd
)->raw_syments
!= (PTR
) NULL
)
703 if (ecoff_data (abfd
)->sym_filepos
== 0)
705 bfd_get_symcount (abfd
) = 0;
709 if (! ecoff_slurp_symbolic_header (abfd
))
712 internal_symhdr
= &debug
->symbolic_header
;
714 /* Read all the symbolic information at once. */
715 raw_base
= (ecoff_data (abfd
)->sym_filepos
716 + backend
->debug_swap
.external_hdr_size
);
718 /* Alpha ecoff makes the determination of raw_size difficult. It has
719 an undocumented debug data section between the symhdr and the first
720 documented section. And the ordering of the sections varies between
721 statically and dynamically linked executables.
722 If bfd supports SEEK_END someday, this code could be simplified. */
726 #define UPDATE_RAW_END(start, count, size) \
727 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
728 if (cb_end > raw_end) \
731 UPDATE_RAW_END (cbLineOffset
, cbLine
, sizeof (unsigned char));
732 UPDATE_RAW_END (cbDnOffset
, idnMax
, backend
->debug_swap
.external_dnr_size
);
733 UPDATE_RAW_END (cbPdOffset
, ipdMax
, backend
->debug_swap
.external_pdr_size
);
734 UPDATE_RAW_END (cbSymOffset
, isymMax
, backend
->debug_swap
.external_sym_size
);
735 UPDATE_RAW_END (cbOptOffset
, ioptMax
, backend
->debug_swap
.external_opt_size
);
736 UPDATE_RAW_END (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
737 UPDATE_RAW_END (cbSsOffset
, issMax
, sizeof (char));
738 UPDATE_RAW_END (cbSsExtOffset
, issExtMax
, sizeof (char));
739 UPDATE_RAW_END (cbFdOffset
, ifdMax
, backend
->debug_swap
.external_fdr_size
);
740 UPDATE_RAW_END (cbRfdOffset
, crfd
, backend
->debug_swap
.external_rfd_size
);
741 UPDATE_RAW_END (cbExtOffset
, iextMax
, backend
->debug_swap
.external_ext_size
);
743 #undef UPDATE_RAW_END
745 raw_size
= raw_end
- raw_base
;
748 ecoff_data (abfd
)->sym_filepos
= 0;
751 raw
= (PTR
) bfd_alloc (abfd
, raw_size
);
754 bfd_set_error (bfd_error_no_memory
);
758 (ecoff_data (abfd
)->sym_filepos
759 + backend
->debug_swap
.external_hdr_size
),
761 || bfd_read (raw
, raw_size
, 1, abfd
) != raw_size
)
763 bfd_release (abfd
, raw
);
767 ecoff_data (abfd
)->raw_syments
= raw
;
769 /* Get pointers for the numeric offsets in the HDRR structure. */
770 #define FIX(off1, off2, type) \
771 if (internal_symhdr->off1 == 0) \
772 debug->off2 = (type) NULL; \
774 debug->off2 = (type) ((char *) raw \
775 + internal_symhdr->off1 \
777 FIX (cbLineOffset
, line
, unsigned char *);
778 FIX (cbDnOffset
, external_dnr
, PTR
);
779 FIX (cbPdOffset
, external_pdr
, PTR
);
780 FIX (cbSymOffset
, external_sym
, PTR
);
781 FIX (cbOptOffset
, external_opt
, PTR
);
782 FIX (cbAuxOffset
, external_aux
, union aux_ext
*);
783 FIX (cbSsOffset
, ss
, char *);
784 FIX (cbSsExtOffset
, ssext
, char *);
785 FIX (cbFdOffset
, external_fdr
, PTR
);
786 FIX (cbRfdOffset
, external_rfd
, PTR
);
787 FIX (cbExtOffset
, external_ext
, PTR
);
790 /* I don't want to always swap all the data, because it will just
791 waste time and most programs will never look at it. The only
792 time the linker needs most of the debugging information swapped
793 is when linking big-endian and little-endian MIPS object files
794 together, which is not a common occurrence.
796 We need to look at the fdr to deal with a lot of information in
797 the symbols, so we swap them here. */
798 debug
->fdr
= (struct fdr
*) bfd_alloc (abfd
,
799 (internal_symhdr
->ifdMax
*
800 sizeof (struct fdr
)));
801 if (debug
->fdr
== NULL
)
803 bfd_set_error (bfd_error_no_memory
);
806 external_fdr_size
= backend
->debug_swap
.external_fdr_size
;
807 fdr_ptr
= debug
->fdr
;
808 fraw_src
= (char *) debug
->external_fdr
;
809 fraw_end
= fraw_src
+ internal_symhdr
->ifdMax
* external_fdr_size
;
810 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
811 (*backend
->debug_swap
.swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
816 /* ECOFF symbol table routines. The ECOFF symbol table is described
817 in gcc/mips-tfile.c. */
819 /* ECOFF uses two common sections. One is the usual one, and the
820 other is for small objects. All the small objects are kept
821 together, and then referenced via the gp pointer, which yields
822 faster assembler code. This is what we use for the small common
824 static asection ecoff_scom_section
;
825 static asymbol ecoff_scom_symbol
;
826 static asymbol
*ecoff_scom_symbol_ptr
;
828 /* Create an empty symbol. */
831 _bfd_ecoff_make_empty_symbol (abfd
)
834 ecoff_symbol_type
*new;
836 new = (ecoff_symbol_type
*) bfd_alloc (abfd
, sizeof (ecoff_symbol_type
));
837 if (new == (ecoff_symbol_type
*) NULL
)
839 bfd_set_error (bfd_error_no_memory
);
840 return (asymbol
*) NULL
;
842 memset ((PTR
) new, 0, sizeof *new);
843 new->symbol
.section
= (asection
*) NULL
;
844 new->fdr
= (FDR
*) NULL
;
847 new->symbol
.the_bfd
= abfd
;
851 /* Set the BFD flags and section for an ECOFF symbol. */
854 ecoff_set_symbol_info (abfd
, ecoff_sym
, asym
, ext
, indirect_ptr_ptr
)
859 asymbol
**indirect_ptr_ptr
;
861 asym
->the_bfd
= abfd
;
862 asym
->value
= ecoff_sym
->value
;
863 asym
->section
= &bfd_debug_section
;
866 /* An indirect symbol requires two consecutive stabs symbols. */
867 if (*indirect_ptr_ptr
!= (asymbol
*) NULL
)
869 BFD_ASSERT (ECOFF_IS_STAB (ecoff_sym
));
871 /* @@ Stuffing pointers into integers is a no-no.
872 We can usually get away with it if the integer is
873 large enough though. */
874 if (sizeof (asym
) > sizeof (bfd_vma
))
876 (*indirect_ptr_ptr
)->value
= (bfd_vma
) asym
;
878 asym
->flags
= BSF_DEBUGGING
;
879 asym
->section
= bfd_und_section_ptr
;
880 *indirect_ptr_ptr
= NULL
;
884 if (ECOFF_IS_STAB (ecoff_sym
)
885 && (ECOFF_UNMARK_STAB (ecoff_sym
->index
) | N_EXT
) == (N_INDR
| N_EXT
))
887 asym
->flags
= BSF_DEBUGGING
| BSF_INDIRECT
;
888 asym
->section
= bfd_ind_section_ptr
;
889 /* Pass this symbol on to the next call to this function. */
890 *indirect_ptr_ptr
= asym
;
894 /* Most symbol types are just for debugging. */
895 switch (ecoff_sym
->st
)
904 if (ECOFF_IS_STAB (ecoff_sym
))
906 asym
->flags
= BSF_DEBUGGING
;
911 asym
->flags
= BSF_DEBUGGING
;
916 asym
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
919 asym
->flags
= BSF_LOCAL
;
920 /* Normally, a local stProc symbol will have a corresponding
921 external symbol. We mark the local symbol as a debugging
922 symbol, in order to prevent nm from printing both out.
923 Similarly, we mark stLabel and stabs symbols as debugging
924 symbols. In both cases, we do want to set the value
925 correctly based on the symbol class. */
926 if (ecoff_sym
->st
== stProc
927 || ecoff_sym
->st
== stLabel
928 || ECOFF_IS_STAB (ecoff_sym
))
929 asym
->flags
|= BSF_DEBUGGING
;
931 switch (ecoff_sym
->sc
)
934 /* Used for compiler generated labels. Leave them in the
935 debugging section, and mark them as local. If BSF_DEBUGGING
936 is set, then nm does not display them for some reason. If no
937 flags are set then the linker whines about them. */
938 asym
->flags
= BSF_LOCAL
;
941 asym
->section
= bfd_make_section_old_way (abfd
, ".text");
942 asym
->value
-= asym
->section
->vma
;
945 asym
->section
= bfd_make_section_old_way (abfd
, ".data");
946 asym
->value
-= asym
->section
->vma
;
949 asym
->section
= bfd_make_section_old_way (abfd
, ".bss");
950 asym
->value
-= asym
->section
->vma
;
953 asym
->flags
= BSF_DEBUGGING
;
956 asym
->section
= bfd_abs_section_ptr
;
959 asym
->section
= bfd_und_section_ptr
;
969 asym
->flags
= BSF_DEBUGGING
;
972 asym
->section
= bfd_make_section_old_way (abfd
, ".sdata");
973 asym
->value
-= asym
->section
->vma
;
976 asym
->section
= bfd_make_section_old_way (abfd
, ".sbss");
977 asym
->value
-= asym
->section
->vma
;
980 asym
->section
= bfd_make_section_old_way (abfd
, ".rdata");
981 asym
->value
-= asym
->section
->vma
;
984 asym
->flags
= BSF_DEBUGGING
;
987 if (asym
->value
> ecoff_data (abfd
)->gp_size
)
989 asym
->section
= bfd_com_section_ptr
;
995 if (ecoff_scom_section
.name
== NULL
)
997 /* Initialize the small common section. */
998 ecoff_scom_section
.name
= SCOMMON
;
999 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
1000 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
1001 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
1002 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
1003 ecoff_scom_symbol
.name
= SCOMMON
;
1004 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
1005 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
1006 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
1008 asym
->section
= &ecoff_scom_section
;
1013 asym
->flags
= BSF_DEBUGGING
;
1016 asym
->section
= bfd_und_section_ptr
;
1021 asym
->section
= bfd_make_section_old_way (abfd
, ".init");
1022 asym
->value
-= asym
->section
->vma
;
1027 asym
->flags
= BSF_DEBUGGING
;
1030 asym
->section
= bfd_make_section_old_way (abfd
, ".fini");
1031 asym
->value
-= asym
->section
->vma
;
1037 /* Look for special constructors symbols and make relocation entries
1038 in a special construction section. These are produced by the
1039 -fgnu-linker argument to g++. */
1040 if (ECOFF_IS_STAB (ecoff_sym
))
1042 switch (ECOFF_UNMARK_STAB (ecoff_sym
->index
))
1054 arelent_chain
*reloc_chain
;
1055 unsigned int bitsize
;
1057 /* Get a section with the same name as the symbol (usually
1058 __CTOR_LIST__ or __DTOR_LIST__). FIXME: gcc uses the
1059 name ___CTOR_LIST (three underscores). We need
1060 __CTOR_LIST (two underscores), since ECOFF doesn't use
1061 a leading underscore. This should be handled by gcc,
1062 but instead we do it here. Actually, this should all
1063 be done differently anyhow. */
1064 name
= bfd_asymbol_name (asym
);
1065 if (name
[0] == '_' && name
[1] == '_' && name
[2] == '_')
1070 section
= bfd_get_section_by_name (abfd
, name
);
1071 if (section
== (asection
*) NULL
)
1075 copy
= (char *) bfd_alloc (abfd
, strlen (name
) + 1);
1078 bfd_set_error (bfd_error_no_memory
);
1081 strcpy (copy
, name
);
1082 section
= bfd_make_section (abfd
, copy
);
1085 /* Build a reloc pointing to this constructor. */
1087 (arelent_chain
*) bfd_alloc (abfd
, sizeof (arelent_chain
));
1090 bfd_set_error (bfd_error_no_memory
);
1093 reloc_chain
->relent
.sym_ptr_ptr
=
1094 bfd_get_section (asym
)->symbol_ptr_ptr
;
1095 reloc_chain
->relent
.address
= section
->_raw_size
;
1096 reloc_chain
->relent
.addend
= asym
->value
;
1097 reloc_chain
->relent
.howto
=
1098 ecoff_backend (abfd
)->constructor_reloc
;
1100 /* Set up the constructor section to hold the reloc. */
1101 section
->flags
= SEC_CONSTRUCTOR
;
1102 ++section
->reloc_count
;
1104 /* Constructor sections must be rounded to a boundary
1105 based on the bitsize. These are not real sections--
1106 they are handled specially by the linker--so the ECOFF
1107 16 byte alignment restriction does not apply. */
1108 bitsize
= ecoff_backend (abfd
)->constructor_bitsize
;
1109 section
->alignment_power
= 1;
1110 while ((1 << section
->alignment_power
) < bitsize
/ 8)
1111 ++section
->alignment_power
;
1113 reloc_chain
->next
= section
->constructor_chain
;
1114 section
->constructor_chain
= reloc_chain
;
1115 section
->_raw_size
+= bitsize
/ 8;
1117 /* Mark the symbol as a constructor. */
1118 asym
->flags
|= BSF_CONSTRUCTOR
;
1126 /* Read an ECOFF symbol table. */
1129 _bfd_ecoff_slurp_symbol_table (abfd
)
1132 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1133 const bfd_size_type external_ext_size
1134 = backend
->debug_swap
.external_ext_size
;
1135 const bfd_size_type external_sym_size
1136 = backend
->debug_swap
.external_sym_size
;
1137 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
1138 = backend
->debug_swap
.swap_ext_in
;
1139 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
1140 = backend
->debug_swap
.swap_sym_in
;
1141 bfd_size_type internal_size
;
1142 ecoff_symbol_type
*internal
;
1143 ecoff_symbol_type
*internal_ptr
;
1144 asymbol
*indirect_ptr
;
1150 /* If we've already read in the symbol table, do nothing. */
1151 if (ecoff_data (abfd
)->canonical_symbols
!= NULL
)
1154 /* Get the symbolic information. */
1155 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, (asection
*) NULL
,
1156 &ecoff_data (abfd
)->debug_info
))
1158 if (bfd_get_symcount (abfd
) == 0)
1161 internal_size
= bfd_get_symcount (abfd
) * sizeof (ecoff_symbol_type
);
1162 internal
= (ecoff_symbol_type
*) bfd_alloc (abfd
, internal_size
);
1163 if (internal
== NULL
)
1165 bfd_set_error (bfd_error_no_memory
);
1169 internal_ptr
= internal
;
1170 indirect_ptr
= NULL
;
1171 eraw_src
= (char *) ecoff_data (abfd
)->debug_info
.external_ext
;
1172 eraw_end
= (eraw_src
1173 + (ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
1174 * external_ext_size
));
1175 for (; eraw_src
< eraw_end
; eraw_src
+= external_ext_size
, internal_ptr
++)
1179 (*swap_ext_in
) (abfd
, (PTR
) eraw_src
, &internal_esym
);
1180 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ssext
1181 + internal_esym
.asym
.iss
);
1182 if (!ecoff_set_symbol_info (abfd
, &internal_esym
.asym
,
1183 &internal_ptr
->symbol
, 1, &indirect_ptr
))
1185 /* The alpha uses a negative ifd field for section symbols. */
1186 if (internal_esym
.ifd
>= 0)
1187 internal_ptr
->fdr
= (ecoff_data (abfd
)->debug_info
.fdr
1188 + internal_esym
.ifd
);
1190 internal_ptr
->fdr
= NULL
;
1191 internal_ptr
->local
= false;
1192 internal_ptr
->native
= (PTR
) eraw_src
;
1194 BFD_ASSERT (indirect_ptr
== (asymbol
*) NULL
);
1196 /* The local symbols must be accessed via the fdr's, because the
1197 string and aux indices are relative to the fdr information. */
1198 fdr_ptr
= ecoff_data (abfd
)->debug_info
.fdr
;
1199 fdr_end
= fdr_ptr
+ ecoff_data (abfd
)->debug_info
.symbolic_header
.ifdMax
;
1200 for (; fdr_ptr
< fdr_end
; fdr_ptr
++)
1205 lraw_src
= ((char *) ecoff_data (abfd
)->debug_info
.external_sym
1206 + fdr_ptr
->isymBase
* external_sym_size
);
1207 lraw_end
= lraw_src
+ fdr_ptr
->csym
* external_sym_size
;
1209 lraw_src
< lraw_end
;
1210 lraw_src
+= external_sym_size
, internal_ptr
++)
1214 (*swap_sym_in
) (abfd
, (PTR
) lraw_src
, &internal_sym
);
1215 internal_ptr
->symbol
.name
= (ecoff_data (abfd
)->debug_info
.ss
1217 + internal_sym
.iss
);
1218 if (!ecoff_set_symbol_info (abfd
, &internal_sym
,
1219 &internal_ptr
->symbol
, 0, &indirect_ptr
))
1221 internal_ptr
->fdr
= fdr_ptr
;
1222 internal_ptr
->local
= true;
1223 internal_ptr
->native
= (PTR
) lraw_src
;
1226 BFD_ASSERT (indirect_ptr
== (asymbol
*) NULL
);
1228 ecoff_data (abfd
)->canonical_symbols
= internal
;
1233 /* Return the amount of space needed for the canonical symbols. */
1236 _bfd_ecoff_get_symtab_upper_bound (abfd
)
1239 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, (asection
*) NULL
,
1240 &ecoff_data (abfd
)->debug_info
))
1243 if (bfd_get_symcount (abfd
) == 0)
1246 return (bfd_get_symcount (abfd
) + 1) * (sizeof (ecoff_symbol_type
*));
1249 /* Get the canonical symbols. */
1252 _bfd_ecoff_get_symtab (abfd
, alocation
)
1254 asymbol
**alocation
;
1256 unsigned int counter
= 0;
1257 ecoff_symbol_type
*symbase
;
1258 ecoff_symbol_type
**location
= (ecoff_symbol_type
**) alocation
;
1260 if (_bfd_ecoff_slurp_symbol_table (abfd
) == false)
1262 if (bfd_get_symcount (abfd
) == 0)
1265 symbase
= ecoff_data (abfd
)->canonical_symbols
;
1266 while (counter
< bfd_get_symcount (abfd
))
1268 *(location
++) = symbase
++;
1271 *location
++ = (ecoff_symbol_type
*) NULL
;
1272 return bfd_get_symcount (abfd
);
1275 /* Turn ECOFF type information into a printable string.
1276 ecoff_emit_aggregate and ecoff_type_to_string are from
1277 gcc/mips-tdump.c, with swapping added and used_ptr removed. */
1279 /* Write aggregate information to a string. */
1282 ecoff_emit_aggregate (abfd
, fdr
, string
, rndx
, isym
, which
)
1290 const struct ecoff_debug_swap
* const debug_swap
=
1291 &ecoff_backend (abfd
)->debug_swap
;
1292 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
1293 unsigned int ifd
= rndx
->rfd
;
1294 unsigned int indx
= rndx
->index
;
1300 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1301 struct return type of a procedure compiled without -g. */
1302 if (ifd
== 0xffffffff
1303 || (rndx
->rfd
== 0xfff && indx
== 0))
1304 name
= "<undefined>";
1305 else if (indx
== indexNil
)
1311 if (debug_info
->external_rfd
== NULL
)
1312 fdr
= debug_info
->fdr
+ ifd
;
1317 (*debug_swap
->swap_rfd_in
) (abfd
,
1318 ((char *) debug_info
->external_rfd
1319 + ((fdr
->rfdBase
+ ifd
)
1320 * debug_swap
->external_rfd_size
)),
1322 fdr
= debug_info
->fdr
+ rfd
;
1325 indx
+= fdr
->isymBase
;
1327 (*debug_swap
->swap_sym_in
) (abfd
,
1328 ((char *) debug_info
->external_sym
1329 + indx
* debug_swap
->external_sym_size
),
1332 name
= debug_info
->ss
+ fdr
->issBase
+ sym
.iss
;
1336 "%s %s { ifd = %u, index = %lu }",
1339 + debug_info
->symbolic_header
.iextMax
));
1342 /* Convert the type information to string format. */
1345 ecoff_type_to_string (abfd
, fdr
, indx
)
1350 union aux_ext
*aux_ptr
;
1359 unsigned int basic_type
;
1361 static char buffer1
[1024];
1362 static char buffer2
[1024];
1367 aux_ptr
= ecoff_data (abfd
)->debug_info
.external_aux
+ fdr
->iauxBase
;
1368 bigendian
= fdr
->fBigendian
;
1370 for (i
= 0; i
< 7; i
++)
1372 qualifiers
[i
].low_bound
= 0;
1373 qualifiers
[i
].high_bound
= 0;
1374 qualifiers
[i
].stride
= 0;
1377 if (AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
]) == -1)
1378 return "-1 (no type)";
1379 _bfd_ecoff_swap_tir_in (bigendian
, &aux_ptr
[indx
++].a_ti
, &u
.ti
);
1381 basic_type
= u
.ti
.bt
;
1382 qualifiers
[0].type
= u
.ti
.tq0
;
1383 qualifiers
[1].type
= u
.ti
.tq1
;
1384 qualifiers
[2].type
= u
.ti
.tq2
;
1385 qualifiers
[3].type
= u
.ti
.tq3
;
1386 qualifiers
[4].type
= u
.ti
.tq4
;
1387 qualifiers
[5].type
= u
.ti
.tq5
;
1388 qualifiers
[6].type
= tqNil
;
1391 * Go get the basic type.
1395 case btNil
: /* undefined */
1399 case btAdr
: /* address - integer same size as pointer */
1400 strcpy (p1
, "address");
1403 case btChar
: /* character */
1404 strcpy (p1
, "char");
1407 case btUChar
: /* unsigned character */
1408 strcpy (p1
, "unsigned char");
1411 case btShort
: /* short */
1412 strcpy (p1
, "short");
1415 case btUShort
: /* unsigned short */
1416 strcpy (p1
, "unsigned short");
1419 case btInt
: /* int */
1423 case btUInt
: /* unsigned int */
1424 strcpy (p1
, "unsigned int");
1427 case btLong
: /* long */
1428 strcpy (p1
, "long");
1431 case btULong
: /* unsigned long */
1432 strcpy (p1
, "unsigned long");
1435 case btFloat
: /* float (real) */
1436 strcpy (p1
, "float");
1439 case btDouble
: /* Double (real) */
1440 strcpy (p1
, "double");
1443 /* Structures add 1-2 aux words:
1444 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1445 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1447 case btStruct
: /* Structure (Record) */
1448 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1449 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1450 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1452 indx
++; /* skip aux words */
1455 /* Unions add 1-2 aux words:
1456 1st word is [ST_RFDESCAPE, offset] pointer to union def;
1457 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1459 case btUnion
: /* Union */
1460 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1461 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1462 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1464 indx
++; /* skip aux words */
1467 /* Enumerations add 1-2 aux words:
1468 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1469 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
1471 case btEnum
: /* Enumeration */
1472 _bfd_ecoff_swap_rndx_in (bigendian
, &aux_ptr
[indx
].a_rndx
, &rndx
);
1473 ecoff_emit_aggregate (abfd
, fdr
, p1
, &rndx
,
1474 (long) AUX_GET_ISYM (bigendian
, &aux_ptr
[indx
+1]),
1476 indx
++; /* skip aux words */
1479 case btTypedef
: /* defined via a typedef, isymRef points */
1480 strcpy (p1
, "typedef");
1483 case btRange
: /* subrange of int */
1484 strcpy (p1
, "subrange");
1487 case btSet
: /* pascal sets */
1491 case btComplex
: /* fortran complex */
1492 strcpy (p1
, "complex");
1495 case btDComplex
: /* fortran double complex */
1496 strcpy (p1
, "double complex");
1499 case btIndirect
: /* forward or unnamed typedef */
1500 strcpy (p1
, "forward/unamed typedef");
1503 case btFixedDec
: /* Fixed Decimal */
1504 strcpy (p1
, "fixed decimal");
1507 case btFloatDec
: /* Float Decimal */
1508 strcpy (p1
, "float decimal");
1511 case btString
: /* Varying Length Character String */
1512 strcpy (p1
, "string");
1515 case btBit
: /* Aligned Bit String */
1519 case btPicture
: /* Picture */
1520 strcpy (p1
, "picture");
1523 case btVoid
: /* Void */
1524 strcpy (p1
, "void");
1528 sprintf (p1
, "Unknown basic type %d", (int) basic_type
);
1532 p1
+= strlen (buffer1
);
1535 * If this is a bitfield, get the bitsize.
1541 bitsize
= AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
++]);
1542 sprintf (p1
, " : %d", bitsize
);
1543 p1
+= strlen (buffer1
);
1548 * Deal with any qualifiers.
1550 if (qualifiers
[0].type
!= tqNil
)
1553 * Snarf up any array bounds in the correct order. Arrays
1554 * store 5 successive words in the aux. table:
1555 * word 0 RNDXR to type of the bounds (ie, int)
1556 * word 1 Current file descriptor index
1558 * word 3 high bound (or -1 if [])
1559 * word 4 stride size in bits
1561 for (i
= 0; i
< 7; i
++)
1563 if (qualifiers
[i
].type
== tqArray
)
1565 qualifiers
[i
].low_bound
=
1566 AUX_GET_DNLOW (bigendian
, &aux_ptr
[indx
+2]);
1567 qualifiers
[i
].high_bound
=
1568 AUX_GET_DNHIGH (bigendian
, &aux_ptr
[indx
+3]);
1569 qualifiers
[i
].stride
=
1570 AUX_GET_WIDTH (bigendian
, &aux_ptr
[indx
+4]);
1576 * Now print out the qualifiers.
1578 for (i
= 0; i
< 6; i
++)
1580 switch (qualifiers
[i
].type
)
1587 strcpy (p2
, "ptr to ");
1588 p2
+= sizeof ("ptr to ")-1;
1592 strcpy (p2
, "volatile ");
1593 p2
+= sizeof ("volatile ")-1;
1597 strcpy (p2
, "far ");
1598 p2
+= sizeof ("far ")-1;
1602 strcpy (p2
, "func. ret. ");
1603 p2
+= sizeof ("func. ret. ");
1608 int first_array
= i
;
1611 /* Print array bounds reversed (ie, in the order the C
1612 programmer writes them). C is such a fun language.... */
1614 while (i
< 5 && qualifiers
[i
+1].type
== tqArray
)
1617 for (j
= i
; j
>= first_array
; j
--)
1619 strcpy (p2
, "array [");
1620 p2
+= sizeof ("array [")-1;
1621 if (qualifiers
[j
].low_bound
!= 0)
1623 "%ld:%ld {%ld bits}",
1624 (long) qualifiers
[j
].low_bound
,
1625 (long) qualifiers
[j
].high_bound
,
1626 (long) qualifiers
[j
].stride
);
1628 else if (qualifiers
[j
].high_bound
!= -1)
1631 (long) (qualifiers
[j
].high_bound
+ 1),
1632 (long) (qualifiers
[j
].stride
));
1635 sprintf (p2
, " {%ld bits}", (long) (qualifiers
[j
].stride
));
1638 strcpy (p2
, "] of ");
1639 p2
+= sizeof ("] of ")-1;
1647 strcpy (p2
, buffer1
);
1651 /* Return information about ECOFF symbol SYMBOL in RET. */
1655 _bfd_ecoff_get_symbol_info (abfd
, symbol
, ret
)
1656 bfd
*abfd
; /* Ignored. */
1660 bfd_symbol_info (symbol
, ret
);
1663 /* Print information about an ECOFF symbol. */
1666 _bfd_ecoff_print_symbol (abfd
, filep
, symbol
, how
)
1670 bfd_print_symbol_type how
;
1672 const struct ecoff_debug_swap
* const debug_swap
1673 = &ecoff_backend (abfd
)->debug_swap
;
1674 FILE *file
= (FILE *)filep
;
1678 case bfd_print_symbol_name
:
1679 fprintf (file
, "%s", symbol
->name
);
1681 case bfd_print_symbol_more
:
1682 if (ecoffsymbol (symbol
)->local
)
1686 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1688 fprintf (file
, "ecoff local ");
1689 fprintf_vma (file
, (bfd_vma
) ecoff_sym
.value
);
1690 fprintf (file
, " %x %x", (unsigned) ecoff_sym
.st
,
1691 (unsigned) ecoff_sym
.sc
);
1697 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1699 fprintf (file
, "ecoff extern ");
1700 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1701 fprintf (file
, " %x %x", (unsigned) ecoff_ext
.asym
.st
,
1702 (unsigned) ecoff_ext
.asym
.sc
);
1705 case bfd_print_symbol_all
:
1706 /* Print out the symbols in a reasonable way */
1715 if (ecoffsymbol (symbol
)->local
)
1717 (*debug_swap
->swap_sym_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1720 pos
= ((((char *) ecoffsymbol (symbol
)->native
1721 - (char *) ecoff_data (abfd
)->debug_info
.external_sym
)
1722 / debug_swap
->external_sym_size
)
1723 + ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
);
1730 (*debug_swap
->swap_ext_in
) (abfd
, ecoffsymbol (symbol
)->native
,
1733 pos
= (((char *) ecoffsymbol (symbol
)->native
1734 - (char *) ecoff_data (abfd
)->debug_info
.external_ext
)
1735 / debug_swap
->external_ext_size
);
1736 jmptbl
= ecoff_ext
.jmptbl
? 'j' : ' ';
1737 cobol_main
= ecoff_ext
.cobol_main
? 'c' : ' ';
1738 weakext
= ecoff_ext
.weakext
? 'w' : ' ';
1741 fprintf (file
, "[%3d] %c ",
1743 fprintf_vma (file
, (bfd_vma
) ecoff_ext
.asym
.value
);
1744 fprintf (file
, " st %x sc %x indx %x %c%c%c %s",
1745 (unsigned) ecoff_ext
.asym
.st
,
1746 (unsigned) ecoff_ext
.asym
.sc
,
1747 (unsigned) ecoff_ext
.asym
.index
,
1748 jmptbl
, cobol_main
, weakext
,
1751 if (ecoffsymbol (symbol
)->fdr
!= NULL
1752 && ecoff_ext
.asym
.index
!= indexNil
)
1757 bfd_size_type sym_base
;
1758 union aux_ext
*aux_base
;
1760 fdr
= ecoffsymbol (symbol
)->fdr
;
1761 indx
= ecoff_ext
.asym
.index
;
1763 /* sym_base is used to map the fdr relative indices which
1764 appear in the file to the position number which we are
1766 sym_base
= fdr
->isymBase
;
1767 if (ecoffsymbol (symbol
)->local
)
1769 ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
1771 /* aux_base is the start of the aux entries for this file;
1772 asym.index is an offset from this. */
1773 aux_base
= (ecoff_data (abfd
)->debug_info
.external_aux
1776 /* The aux entries are stored in host byte order; the
1777 order is indicated by a bit in the fdr. */
1778 bigendian
= fdr
->fBigendian
;
1780 /* This switch is basically from gcc/mips-tdump.c */
1781 switch (ecoff_ext
.asym
.st
)
1789 fprintf (file
, "\n End+1 symbol: %ld",
1790 (long) (indx
+ sym_base
));
1794 if (ecoff_ext
.asym
.sc
== scText
1795 || ecoff_ext
.asym
.sc
== scInfo
)
1796 fprintf (file
, "\n First symbol: %ld",
1797 (long) (indx
+ sym_base
));
1799 fprintf (file
, "\n First symbol: %ld",
1801 (AUX_GET_ISYM (bigendian
,
1802 &aux_base
[ecoff_ext
.asym
.index
])
1808 if (ECOFF_IS_STAB (&ecoff_ext
.asym
))
1810 else if (ecoffsymbol (symbol
)->local
)
1811 fprintf (file
, "\n End+1 symbol: %-7ld Type: %s",
1813 (AUX_GET_ISYM (bigendian
,
1814 &aux_base
[ecoff_ext
.asym
.index
])
1816 ecoff_type_to_string (abfd
, fdr
, indx
+ 1));
1818 fprintf (file
, "\n Local symbol: %ld",
1821 + (ecoff_data (abfd
)
1822 ->debug_info
.symbolic_header
.iextMax
)));
1826 fprintf (file
, "\n struct; End+1 symbol: %ld",
1827 (long) (indx
+ sym_base
));
1831 fprintf (file
, "\n union; End+1 symbol: %ld",
1832 (long) (indx
+ sym_base
));
1836 fprintf (file
, "\n enum; End+1 symbol: %ld",
1837 (long) (indx
+ sym_base
));
1841 if (! ECOFF_IS_STAB (&ecoff_ext
.asym
))
1842 fprintf (file
, "\n Type: %s",
1843 ecoff_type_to_string (abfd
, fdr
, indx
));
1852 /* Read in the relocs for a section. */
1855 ecoff_slurp_reloc_table (abfd
, section
, symbols
)
1860 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
1861 arelent
*internal_relocs
;
1862 bfd_size_type external_reloc_size
;
1863 bfd_size_type external_relocs_size
;
1864 char *external_relocs
;
1868 if (section
->relocation
!= (arelent
*) NULL
1869 || section
->reloc_count
== 0
1870 || (section
->flags
& SEC_CONSTRUCTOR
) != 0)
1873 if (_bfd_ecoff_slurp_symbol_table (abfd
) == false)
1876 internal_relocs
= (arelent
*) bfd_alloc (abfd
,
1878 * section
->reloc_count
));
1879 external_reloc_size
= backend
->external_reloc_size
;
1880 external_relocs_size
= external_reloc_size
* section
->reloc_count
;
1881 external_relocs
= (char *) bfd_alloc (abfd
, external_relocs_size
);
1882 if (internal_relocs
== (arelent
*) NULL
1883 || external_relocs
== (char *) NULL
)
1885 bfd_set_error (bfd_error_no_memory
);
1888 if (bfd_seek (abfd
, section
->rel_filepos
, SEEK_SET
) != 0)
1890 if (bfd_read (external_relocs
, 1, external_relocs_size
, abfd
)
1891 != external_relocs_size
)
1894 for (i
= 0, rptr
= internal_relocs
; i
< section
->reloc_count
; i
++, rptr
++)
1896 struct internal_reloc intern
;
1898 (*backend
->swap_reloc_in
) (abfd
,
1899 external_relocs
+ i
* external_reloc_size
,
1902 if (intern
.r_extern
)
1904 /* r_symndx is an index into the external symbols. */
1905 BFD_ASSERT (intern
.r_symndx
>= 0
1907 < (ecoff_data (abfd
)
1908 ->debug_info
.symbolic_header
.iextMax
)));
1909 rptr
->sym_ptr_ptr
= symbols
+ intern
.r_symndx
;
1912 else if (intern
.r_symndx
== RELOC_SECTION_NONE
1913 || intern
.r_symndx
== RELOC_SECTION_ABS
)
1915 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1920 CONST
char *sec_name
;
1923 /* r_symndx is a section key. */
1924 switch (intern
.r_symndx
)
1926 case RELOC_SECTION_TEXT
: sec_name
= ".text"; break;
1927 case RELOC_SECTION_RDATA
: sec_name
= ".rdata"; break;
1928 case RELOC_SECTION_DATA
: sec_name
= ".data"; break;
1929 case RELOC_SECTION_SDATA
: sec_name
= ".sdata"; break;
1930 case RELOC_SECTION_SBSS
: sec_name
= ".sbss"; break;
1931 case RELOC_SECTION_BSS
: sec_name
= ".bss"; break;
1932 case RELOC_SECTION_INIT
: sec_name
= ".init"; break;
1933 case RELOC_SECTION_LIT8
: sec_name
= ".lit8"; break;
1934 case RELOC_SECTION_LIT4
: sec_name
= ".lit4"; break;
1935 case RELOC_SECTION_XDATA
: sec_name
= ".xdata"; break;
1936 case RELOC_SECTION_PDATA
: sec_name
= ".pdata"; break;
1937 case RELOC_SECTION_FINI
: sec_name
= ".fini"; break;
1938 case RELOC_SECTION_LITA
: sec_name
= ".lita"; break;
1942 sec
= bfd_get_section_by_name (abfd
, sec_name
);
1943 if (sec
== (asection
*) NULL
)
1945 rptr
->sym_ptr_ptr
= sec
->symbol_ptr_ptr
;
1947 rptr
->addend
= - bfd_get_section_vma (abfd
, sec
);
1950 rptr
->address
= intern
.r_vaddr
- bfd_get_section_vma (abfd
, section
);
1952 /* Let the backend select the howto field and do any other
1953 required processing. */
1954 (*backend
->adjust_reloc_in
) (abfd
, &intern
, rptr
);
1957 bfd_release (abfd
, external_relocs
);
1959 section
->relocation
= internal_relocs
;
1964 /* Get a canonical list of relocs. */
1967 _bfd_ecoff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
1975 if (section
->flags
& SEC_CONSTRUCTOR
)
1977 arelent_chain
*chain
;
1979 /* This section has relocs made up by us, not the file, so take
1980 them out of their chain and place them into the data area
1982 for (count
= 0, chain
= section
->constructor_chain
;
1983 count
< section
->reloc_count
;
1984 count
++, chain
= chain
->next
)
1985 *relptr
++ = &chain
->relent
;
1991 if (ecoff_slurp_reloc_table (abfd
, section
, symbols
) == false)
1994 tblptr
= section
->relocation
;
1996 for (count
= 0; count
< section
->reloc_count
; count
++)
1997 *relptr
++ = tblptr
++;
2000 *relptr
= (arelent
*) NULL
;
2002 return section
->reloc_count
;
2005 /* Provided a BFD, a section and an offset into the section, calculate
2006 and return the name of the source file and the line nearest to the
2011 _bfd_ecoff_find_nearest_line (abfd
, section
, ignore_symbols
, offset
,
2012 filename_ptr
, functionname_ptr
, retline_ptr
)
2015 asymbol
**ignore_symbols
;
2017 CONST
char **filename_ptr
;
2018 CONST
char **functionname_ptr
;
2019 unsigned int *retline_ptr
;
2021 const struct ecoff_debug_swap
* const debug_swap
2022 = &ecoff_backend (abfd
)->debug_swap
;
2023 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
2030 /* If we're not in the .text section, we don't have any line
2032 if (strcmp (section
->name
, _TEXT
) != 0
2033 || offset
< ecoff_data (abfd
)->text_start
2034 || offset
>= ecoff_data (abfd
)->text_end
)
2037 /* Make sure we have the FDR's. */
2038 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, (asection
*) NULL
, debug_info
)
2039 || bfd_get_symcount (abfd
) == 0)
2042 /* Each file descriptor (FDR) has a memory address. Here we track
2043 down which FDR we want. The FDR's are stored in increasing
2044 memory order. If speed is ever important, this can become a
2045 binary search. We must ignore FDR's with no PDR entries; they
2046 will have the adr of the FDR before or after them. */
2047 fdr_start
= debug_info
->fdr
;
2048 fdr_end
= fdr_start
+ debug_info
->symbolic_header
.ifdMax
;
2049 fdr_hold
= (FDR
*) NULL
;
2050 for (fdr_ptr
= fdr_start
; fdr_ptr
< fdr_end
; fdr_ptr
++)
2052 if (fdr_ptr
->cpd
== 0)
2054 if (offset
< fdr_ptr
->adr
)
2058 if (fdr_hold
== (FDR
*) NULL
)
2062 /* Check whether this file has stabs debugging information. In a
2063 file with stabs debugging information, the second local symbol is
2066 if (fdr_ptr
->csym
>= 2)
2071 sym_ptr
= ((char *) debug_info
->external_sym
2072 + (fdr_ptr
->isymBase
+ 1) * debug_swap
->external_sym_size
);
2073 (*debug_swap
->swap_sym_in
) (abfd
, sym_ptr
, &sym
);
2074 if (strcmp (debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
,
2081 bfd_size_type external_pdr_size
;
2086 unsigned char *line_ptr
;
2087 unsigned char *line_end
;
2090 /* This file uses ECOFF debugging information. Each FDR has a
2091 list of procedure descriptors (PDR). PDR's also have an
2092 address, which is relative to the FDR address, and are also
2093 stored in increasing memory order. */
2094 offset
-= fdr_ptr
->adr
;
2095 external_pdr_size
= debug_swap
->external_pdr_size
;
2096 pdr_ptr
= ((char *) debug_info
->external_pdr
2097 + fdr_ptr
->ipdFirst
* external_pdr_size
);
2098 pdr_end
= pdr_ptr
+ fdr_ptr
->cpd
* external_pdr_size
;
2099 (*debug_swap
->swap_pdr_in
) (abfd
, (PTR
) pdr_ptr
, &pdr
);
2100 if (offset
< pdr
.adr
)
2103 /* The address of the first PDR is an offset which applies to
2104 the addresses of all the PDR's. */
2105 first_off
= pdr
.adr
;
2107 for (pdr_ptr
+= external_pdr_size
;
2109 pdr_ptr
+= external_pdr_size
)
2111 (*debug_swap
->swap_pdr_in
) (abfd
, (PTR
) pdr_ptr
, &pdr
);
2112 if (offset
< pdr
.adr
)
2116 /* Now we can look for the actual line number. The line numbers
2117 are stored in a very funky format, which I won't try to
2118 describe. Note that right here pdr_ptr and pdr hold the PDR
2119 *after* the one we want; we need this to compute line_end. */
2120 line_end
= debug_info
->line
;
2121 if (pdr_ptr
== pdr_end
)
2122 line_end
+= fdr_ptr
->cbLineOffset
+ fdr_ptr
->cbLine
;
2124 line_end
+= fdr_ptr
->cbLineOffset
+ pdr
.cbLineOffset
;
2126 /* Now change pdr and pdr_ptr to the one we want. */
2127 pdr_ptr
-= external_pdr_size
;
2128 (*debug_swap
->swap_pdr_in
) (abfd
, (PTR
) pdr_ptr
, &pdr
);
2130 offset
-= pdr
.adr
- first_off
;
2132 line_ptr
= debug_info
->line
+ fdr_ptr
->cbLineOffset
+ pdr
.cbLineOffset
;
2133 while (line_ptr
< line_end
)
2138 delta
= *line_ptr
>> 4;
2141 count
= (*line_ptr
& 0xf) + 1;
2145 delta
= (((line_ptr
[0]) & 0xff) << 8) + ((line_ptr
[1]) & 0xff);
2146 if (delta
>= 0x8000)
2151 if (offset
< count
* 4)
2153 offset
-= count
* 4;
2156 /* If fdr_ptr->rss is -1, then this file does not have full
2157 symbols, at least according to gdb/mipsread.c. */
2158 if (fdr_ptr
->rss
== -1)
2160 *filename_ptr
= NULL
;
2162 *functionname_ptr
= NULL
;
2167 (*debug_swap
->swap_ext_in
)
2169 ((char *) debug_info
->external_ext
2170 + pdr
.isym
* debug_swap
->external_ext_size
),
2172 *functionname_ptr
= debug_info
->ssext
+ proc_ext
.asym
.iss
;
2179 *filename_ptr
= debug_info
->ss
+ fdr_ptr
->issBase
+ fdr_ptr
->rss
;
2180 (*debug_swap
->swap_sym_in
)
2182 ((char *) debug_info
->external_sym
2183 + (fdr_ptr
->isymBase
+ pdr
.isym
) * debug_swap
->external_sym_size
),
2185 *functionname_ptr
= debug_info
->ss
+ fdr_ptr
->issBase
+ proc_sym
.iss
;
2187 if (lineno
== ilineNil
)
2189 *retline_ptr
= lineno
;
2193 bfd_size_type external_sym_size
;
2194 const char *directory_name
;
2195 const char *main_file_name
;
2196 const char *current_file_name
;
2197 const char *function_name
;
2198 const char *line_file_name
;
2199 bfd_vma low_func_vma
;
2200 bfd_vma low_line_vma
;
2201 char *sym_ptr
, *sym_ptr_end
;
2202 size_t len
, funclen
;
2203 char *buffer
= NULL
;
2205 /* This file uses stabs debugging information. */
2207 *filename_ptr
= NULL
;
2208 *functionname_ptr
= NULL
;
2211 directory_name
= NULL
;
2212 main_file_name
= NULL
;
2213 current_file_name
= NULL
;
2214 function_name
= NULL
;
2215 line_file_name
= NULL
;
2219 external_sym_size
= debug_swap
->external_sym_size
;
2221 sym_ptr
= ((char *) debug_info
->external_sym
2222 + (fdr_ptr
->isymBase
+ 2) * external_sym_size
);
2223 sym_ptr_end
= sym_ptr
+ fdr_ptr
->csym
* external_sym_size
;
2224 for (; sym_ptr
< sym_ptr_end
; sym_ptr
+= external_sym_size
)
2228 (*debug_swap
->swap_sym_in
) (abfd
, sym_ptr
, &sym
);
2230 if (ECOFF_IS_STAB (&sym
))
2232 switch (ECOFF_UNMARK_STAB (sym
.index
))
2235 main_file_name
= current_file_name
=
2236 debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
;
2238 /* Check the next symbol to see if it is also an
2240 if (sym_ptr
+ external_sym_size
< sym_ptr_end
)
2244 (*debug_swap
->swap_sym_in
) (abfd
,
2245 sym_ptr
+ external_sym_size
,
2247 if (ECOFF_IS_STAB (&nextsym
)
2248 && ECOFF_UNMARK_STAB (nextsym
.index
) == N_SO
)
2250 directory_name
= current_file_name
;
2251 main_file_name
= current_file_name
=
2252 debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
;
2253 sym_ptr
+= external_sym_size
;
2260 debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
;
2264 if (sym
.value
>= low_func_vma
2265 && sym
.value
<= offset
+ section
->vma
)
2267 low_func_vma
= sym
.value
;
2269 debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
;
2274 else if (sym
.st
== stLabel
&& sym
.index
!= indexNil
)
2276 if (sym
.value
> offset
+ section
->vma
)
2278 /* We have passed the location in the file we are
2279 looking for, so we can get out of the loop. */
2283 if (sym
.value
>= low_line_vma
)
2285 low_line_vma
= sym
.value
;
2286 line_file_name
= current_file_name
;
2287 *retline_ptr
= sym
.index
;
2292 if (*retline_ptr
!= 0)
2293 main_file_name
= line_file_name
;
2295 /* We need to remove the stuff after the colon in the function
2296 name. We also need to put the directory name and the file
2298 if (function_name
== NULL
)
2301 len
= funclen
= strlen (function_name
) + 1;
2303 if (main_file_name
!= NULL
2304 && directory_name
!= NULL
2305 && main_file_name
[0] != '/')
2306 len
+= strlen (directory_name
) + strlen (main_file_name
) + 1;
2310 if (ecoff_data (abfd
)->find_buffer
!= NULL
)
2311 free (ecoff_data (abfd
)->find_buffer
);
2312 buffer
= (char *) malloc (len
);
2315 bfd_set_error (bfd_error_no_memory
);
2318 ecoff_data (abfd
)->find_buffer
= buffer
;
2321 if (function_name
!= NULL
)
2325 strcpy (buffer
, function_name
);
2326 colon
= strchr (buffer
, ':');
2329 *functionname_ptr
= buffer
;
2332 if (main_file_name
!= NULL
)
2334 if (directory_name
== NULL
|| main_file_name
[0] == '/')
2335 *filename_ptr
= main_file_name
;
2338 sprintf (buffer
+ funclen
, "%s%s", directory_name
,
2340 *filename_ptr
= buffer
+ funclen
;
2348 /* Copy private BFD data. This is called by objcopy and strip. We
2349 use it to copy the ECOFF debugging information from one BFD to the
2350 other. It would be theoretically possible to represent the ECOFF
2351 debugging information in the symbol table. However, it would be a
2352 lot of work, and there would be little gain (gas, gdb, and ld
2353 already access the ECOFF debugging information via the
2354 ecoff_debug_info structure, and that structure would have to be
2355 retained in order to support ECOFF debugging in MIPS ELF).
2357 The debugging information for the ECOFF external symbols comes from
2358 the symbol table, so this function only handles the other debugging
2362 _bfd_ecoff_bfd_copy_private_bfd_data (ibfd
, obfd
)
2366 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
2367 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
2369 asymbol
**sym_ptr_ptr
;
2373 /* This function is selected based on the input vector. We only
2374 want to copy information over if the output BFD also uses ECOFF
2376 if (bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
2379 /* Copy the GP value and the register masks. */
2380 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
2381 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
2382 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
2383 for (i
= 0; i
< 3; i
++)
2384 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
2386 /* Copy the version stamp. */
2387 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
2389 /* If there are no symbols, don't copy any debugging information. */
2390 c
= bfd_get_symcount (obfd
);
2391 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
2392 if (c
== 0 || sym_ptr_ptr
== (asymbol
**) NULL
)
2395 /* See if there are any local symbols. */
2397 for (; c
> 0; c
--, sym_ptr_ptr
++)
2399 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
2408 /* There are some local symbols. We just bring over all the
2409 debugging information. FIXME: This is not quite the right
2410 thing to do. If the user has asked us to discard all
2411 debugging information, then we are probably going to wind up
2412 keeping it because there will probably be some local symbol
2413 which objcopy did not discard. We should actually break
2414 apart the debugging information and only keep that which
2415 applies to the symbols we want to keep. */
2416 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
2417 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
2418 oinfo
->line
= iinfo
->line
;
2420 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
2421 oinfo
->external_dnr
= iinfo
->external_dnr
;
2423 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
2424 oinfo
->external_pdr
= iinfo
->external_pdr
;
2426 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
2427 oinfo
->external_sym
= iinfo
->external_sym
;
2429 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
2430 oinfo
->external_opt
= iinfo
->external_opt
;
2432 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
2433 oinfo
->external_aux
= iinfo
->external_aux
;
2435 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
2436 oinfo
->ss
= iinfo
->ss
;
2438 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
2439 oinfo
->external_fdr
= iinfo
->external_fdr
;
2441 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
2442 oinfo
->external_rfd
= iinfo
->external_rfd
;
2446 /* We are discarding all the local symbol information. Look
2447 through the external symbols and remove all references to FDR
2448 or aux information. */
2449 c
= bfd_get_symcount (obfd
);
2450 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
2451 for (; c
> 0; c
--, sym_ptr_ptr
++)
2455 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
2456 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
2458 esym
.asym
.index
= indexNil
;
2459 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
2460 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
2467 /* Set the architecture. The supported architecture is stored in the
2468 backend pointer. We always set the architecture anyhow, since many
2469 callers ignore the return value. */
2472 _bfd_ecoff_set_arch_mach (abfd
, arch
, machine
)
2474 enum bfd_architecture arch
;
2475 unsigned long machine
;
2477 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2478 return arch
== ecoff_backend (abfd
)->arch
;
2481 /* Get the size of the section headers. */
2485 _bfd_ecoff_sizeof_headers (abfd
, reloc
)
2494 for (current
= abfd
->sections
;
2495 current
!= (asection
*)NULL
;
2496 current
= current
->next
)
2499 ret
= (bfd_coff_filhsz (abfd
)
2500 + bfd_coff_aoutsz (abfd
)
2501 + c
* bfd_coff_scnhsz (abfd
));
2502 return BFD_ALIGN (ret
, 16);
2505 /* Get the contents of a section. */
2508 _bfd_ecoff_get_section_contents (abfd
, section
, location
, offset
, count
)
2513 bfd_size_type count
;
2515 return _bfd_generic_get_section_contents (abfd
, section
, location
,
2519 /* Calculate the file position for each section, and set
2523 ecoff_compute_section_file_positions (abfd
)
2531 sofar
= _bfd_ecoff_sizeof_headers (abfd
, false);
2534 for (current
= abfd
->sections
;
2535 current
!= (asection
*) NULL
;
2536 current
= current
->next
)
2538 unsigned int alignment_power
;
2540 /* Only deal with sections which have contents */
2541 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) == 0)
2544 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2545 supposed to indicate the number of .pdata entries that are
2546 really in the section. Each entry is 8 bytes. We store this
2547 away in line_filepos before increasing the section size. */
2548 if (strcmp (current
->name
, _PDATA
) != 0)
2549 alignment_power
= current
->alignment_power
;
2552 current
->line_filepos
= current
->_raw_size
/ 8;
2553 alignment_power
= 4;
2556 /* On Ultrix, the data sections in an executable file must be
2557 aligned to a page boundary within the file. This does not
2558 affect the section size, though. FIXME: Does this work for
2559 other platforms? It requires some modification for the
2560 Alpha, because .rdata on the Alpha goes with the text, not
2562 if ((abfd
->flags
& EXEC_P
) != 0
2563 && (abfd
->flags
& D_PAGED
) != 0
2564 && first_data
!= false
2565 && (current
->flags
& SEC_CODE
) == 0
2566 && (! ecoff_backend (abfd
)->rdata_in_text
2567 || strcmp (current
->name
, _RDATA
) != 0)
2568 && strcmp (current
->name
, _PDATA
) != 0)
2570 const bfd_vma round
= ecoff_backend (abfd
)->round
;
2572 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2575 else if (strcmp (current
->name
, _LIB
) == 0)
2577 const bfd_vma round
= ecoff_backend (abfd
)->round
;
2578 /* On Irix 4, the location of contents of the .lib section
2579 from a shared library section is also rounded up to a
2582 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2585 /* Align the sections in the file to the same boundary on
2586 which they are aligned in virtual memory. */
2588 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2590 current
->filepos
= sofar
;
2592 sofar
+= current
->_raw_size
;
2594 /* make sure that this section is of the right size too */
2596 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2597 current
->_raw_size
+= sofar
- old_sofar
;
2600 ecoff_data (abfd
)->reloc_filepos
= sofar
;
2603 /* Determine the location of the relocs for all the sections in the
2604 output file, as well as the location of the symbolic debugging
2607 static bfd_size_type
2608 ecoff_compute_reloc_file_positions (abfd
)
2611 const bfd_size_type external_reloc_size
=
2612 ecoff_backend (abfd
)->external_reloc_size
;
2613 file_ptr reloc_base
;
2614 bfd_size_type reloc_size
;
2618 if (! abfd
->output_has_begun
)
2620 ecoff_compute_section_file_positions (abfd
);
2621 abfd
->output_has_begun
= true;
2624 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2627 for (current
= abfd
->sections
;
2628 current
!= (asection
*)NULL
;
2629 current
= current
->next
)
2631 if (current
->reloc_count
== 0)
2632 current
->rel_filepos
= 0;
2635 bfd_size_type relsize
;
2637 current
->rel_filepos
= reloc_base
;
2638 relsize
= current
->reloc_count
* external_reloc_size
;
2639 reloc_size
+= relsize
;
2640 reloc_base
+= relsize
;
2644 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2646 /* At least on Ultrix, the symbol table of an executable file must
2647 be aligned to a page boundary. FIXME: Is this true on other
2649 if ((abfd
->flags
& EXEC_P
) != 0
2650 && (abfd
->flags
& D_PAGED
) != 0)
2651 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2652 &~ (ecoff_backend (abfd
)->round
- 1));
2654 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2659 /* Set the contents of a section. */
2662 _bfd_ecoff_set_section_contents (abfd
, section
, location
, offset
, count
)
2667 bfd_size_type count
;
2669 /* This must be done first, because bfd_set_section_contents is
2670 going to set output_has_begun to true. */
2671 if (abfd
->output_has_begun
== false)
2672 ecoff_compute_section_file_positions (abfd
);
2674 /* If this is a .lib section, bump the vma address so that it winds
2675 up being the number of .lib sections output. This is right for
2676 Irix 4. Ian Taylor <ian@cygnus.com>. */
2677 if (strcmp (section
->name
, _LIB
) == 0)
2683 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0
2684 || bfd_write (location
, 1, count
, abfd
) != count
)
2690 /* Get the GP value for an ECOFF file. This is a hook used by
2694 bfd_ecoff_get_gp_value (abfd
)
2697 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2698 || bfd_get_format (abfd
) != bfd_object
)
2700 bfd_set_error (bfd_error_invalid_operation
);
2704 return ecoff_data (abfd
)->gp
;
2707 /* Set the GP value for an ECOFF file. This is a hook used by the
2711 bfd_ecoff_set_gp_value (abfd
, gp_value
)
2715 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2716 || bfd_get_format (abfd
) != bfd_object
)
2718 bfd_set_error (bfd_error_invalid_operation
);
2722 ecoff_data (abfd
)->gp
= gp_value
;
2727 /* Set the register masks for an ECOFF file. This is a hook used by
2731 bfd_ecoff_set_regmasks (abfd
, gprmask
, fprmask
, cprmask
)
2733 unsigned long gprmask
;
2734 unsigned long fprmask
;
2735 unsigned long *cprmask
;
2737 ecoff_data_type
*tdata
;
2739 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2740 || bfd_get_format (abfd
) != bfd_object
)
2742 bfd_set_error (bfd_error_invalid_operation
);
2746 tdata
= ecoff_data (abfd
);
2747 tdata
->gprmask
= gprmask
;
2748 tdata
->fprmask
= fprmask
;
2749 if (cprmask
!= (unsigned long *) NULL
)
2753 for (i
= 0; i
< 3; i
++)
2754 tdata
->cprmask
[i
] = cprmask
[i
];
2760 /* Get ECOFF EXTR information for an external symbol. This function
2761 is passed to bfd_ecoff_debug_externals. */
2764 ecoff_get_extr (sym
, esym
)
2768 ecoff_symbol_type
*ecoff_sym_ptr
;
2771 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
2772 || ecoffsymbol (sym
)->native
== NULL
)
2774 /* Don't include debugging, local, or section symbols. */
2775 if ((sym
->flags
& BSF_DEBUGGING
) != 0
2776 || (sym
->flags
& BSF_LOCAL
) != 0
2777 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
2781 esym
->cobol_main
= 0;
2785 /* FIXME: we can do better than this for st and sc. */
2786 esym
->asym
.st
= stGlobal
;
2787 esym
->asym
.sc
= scAbs
;
2788 esym
->asym
.reserved
= 0;
2789 esym
->asym
.index
= indexNil
;
2793 ecoff_sym_ptr
= ecoffsymbol (sym
);
2795 if (ecoff_sym_ptr
->local
)
2798 input_bfd
= bfd_asymbol_bfd (sym
);
2799 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
2800 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
2802 /* If the symbol was defined by the linker, then esym will be
2803 undefined but sym will not be. Get a better class for such a
2805 if ((esym
->asym
.sc
== scUndefined
2806 || esym
->asym
.sc
== scSUndefined
)
2807 && ! bfd_is_und_section (bfd_get_section (sym
)))
2808 esym
->asym
.sc
= scAbs
;
2810 /* Adjust the FDR index for the symbol by that used for the input
2812 if (esym
->ifd
!= -1)
2814 struct ecoff_debug_info
*input_debug
;
2816 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
2817 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
2818 if (input_debug
->ifdmap
!= (RFDT
*) NULL
)
2819 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
2825 /* Set the external symbol index. This routine is passed to
2826 bfd_ecoff_debug_externals. */
2829 ecoff_set_index (sym
, indx
)
2833 ecoff_set_sym_index (sym
, indx
);
2836 /* Write out an ECOFF file. */
2839 _bfd_ecoff_write_object_contents (abfd
)
2842 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
2843 const bfd_vma round
= backend
->round
;
2844 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
2845 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
2846 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
2847 const bfd_size_type external_hdr_size
2848 = backend
->debug_swap
.external_hdr_size
;
2849 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
2850 void (* const adjust_reloc_out
) PARAMS ((bfd
*,
2852 struct internal_reloc
*))
2853 = backend
->adjust_reloc_out
;
2854 void (* const swap_reloc_out
) PARAMS ((bfd
*,
2855 const struct internal_reloc
*,
2857 = backend
->swap_reloc_out
;
2858 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
2859 HDRR
* const symhdr
= &debug
->symbolic_header
;
2862 bfd_size_type reloc_size
;
2863 bfd_size_type text_size
;
2865 boolean set_text_start
;
2866 bfd_size_type data_size
;
2868 boolean set_data_start
;
2869 bfd_size_type bss_size
;
2871 PTR reloc_buff
= NULL
;
2872 struct internal_filehdr internal_f
;
2873 struct internal_aouthdr internal_a
;
2876 /* Determine where the sections and relocs will go in the output
2878 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
2881 for (current
= abfd
->sections
;
2882 current
!= (asection
*)NULL
;
2883 current
= current
->next
)
2885 current
->target_index
= count
;
2889 if ((abfd
->flags
& D_PAGED
) != 0)
2890 text_size
= _bfd_ecoff_sizeof_headers (abfd
, false);
2894 set_text_start
= false;
2897 set_data_start
= false;
2900 /* Write section headers to the file. */
2902 /* Allocate buff big enough to hold a section header,
2903 file header, or a.out header. */
2911 buff
= (PTR
) malloc (siz
);
2914 bfd_set_error (bfd_error_no_memory
);
2919 internal_f
.f_nscns
= 0;
2920 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
2922 for (current
= abfd
->sections
;
2923 current
!= (asection
*) NULL
;
2924 current
= current
->next
)
2926 struct internal_scnhdr section
;
2929 ++internal_f
.f_nscns
;
2931 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
2933 /* This seems to be correct for Irix 4 shared libraries. */
2934 vma
= bfd_get_section_vma (abfd
, current
);
2935 if (strcmp (current
->name
, _LIB
) == 0)
2936 section
.s_vaddr
= 0;
2938 section
.s_vaddr
= vma
;
2940 section
.s_paddr
= vma
;
2941 section
.s_size
= bfd_get_section_size_before_reloc (current
);
2943 /* If this section is unloadable then the scnptr will be 0. */
2944 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2945 section
.s_scnptr
= 0;
2947 section
.s_scnptr
= current
->filepos
;
2948 section
.s_relptr
= current
->rel_filepos
;
2950 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2951 object file produced by the assembler is supposed to point to
2952 information about how much room is required by objects of
2953 various different sizes. I think this only matters if we
2954 want the linker to compute the best size to use, or
2955 something. I don't know what happens if the information is
2957 if (strcmp (current
->name
, _PDATA
) != 0)
2958 section
.s_lnnoptr
= 0;
2961 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2962 hold the number of entries in the section (each entry is
2963 8 bytes). We stored this in the line_filepos field in
2964 ecoff_compute_section_file_positions. */
2965 section
.s_lnnoptr
= current
->line_filepos
;
2968 section
.s_nreloc
= current
->reloc_count
;
2969 section
.s_nlnno
= 0;
2970 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
2973 bfd_coff_swap_scnhdr_out (abfd
, (PTR
) §ion
, buff
);
2974 if (bfd_write (buff
, 1, scnhsz
, abfd
) != scnhsz
)
2977 if ((section
.s_flags
& STYP_TEXT
) != 0
2978 || ((section
.s_flags
& STYP_RDATA
) != 0
2979 && backend
->rdata_in_text
)
2980 || strcmp (current
->name
, _PDATA
) == 0)
2982 text_size
+= bfd_get_section_size_before_reloc (current
);
2983 if (! set_text_start
|| text_start
> vma
)
2986 set_text_start
= true;
2989 else if ((section
.s_flags
& STYP_RDATA
) != 0
2990 || (section
.s_flags
& STYP_DATA
) != 0
2991 || (section
.s_flags
& STYP_LITA
) != 0
2992 || (section
.s_flags
& STYP_LIT8
) != 0
2993 || (section
.s_flags
& STYP_LIT4
) != 0
2994 || (section
.s_flags
& STYP_SDATA
) != 0
2995 || strcmp (current
->name
, _XDATA
) == 0)
2997 data_size
+= bfd_get_section_size_before_reloc (current
);
2998 if (! set_data_start
|| data_start
> vma
)
3001 set_data_start
= true;
3004 else if ((section
.s_flags
& STYP_BSS
) != 0
3005 || (section
.s_flags
& STYP_SBSS
) != 0)
3006 bss_size
+= bfd_get_section_size_before_reloc (current
);
3007 else if ((section
.s_flags
& STYP_ECOFF_LIB
) != 0)
3013 /* Set up the file header. */
3015 internal_f
.f_magic
= ecoff_get_magic (abfd
);
3017 /* We will NOT put a fucking timestamp in the header here. Every
3018 time you put it back, I will come in and take it out again. I'm
3019 sorry. This field does not belong here. We fill it with a 0 so
3020 it compares the same but is not a reasonable time. --
3022 internal_f
.f_timdat
= 0;
3024 if (bfd_get_symcount (abfd
) != 0)
3026 /* The ECOFF f_nsyms field is not actually the number of
3027 symbols, it's the size of symbolic information header. */
3028 internal_f
.f_nsyms
= external_hdr_size
;
3029 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
3033 internal_f
.f_nsyms
= 0;
3034 internal_f
.f_symptr
= 0;
3037 internal_f
.f_opthdr
= aoutsz
;
3039 internal_f
.f_flags
= F_LNNO
;
3040 if (reloc_size
== 0)
3041 internal_f
.f_flags
|= F_RELFLG
;
3042 if (bfd_get_symcount (abfd
) == 0)
3043 internal_f
.f_flags
|= F_LSYMS
;
3044 if (abfd
->flags
& EXEC_P
)
3045 internal_f
.f_flags
|= F_EXEC
;
3047 if (! abfd
->xvec
->byteorder_big_p
)
3048 internal_f
.f_flags
|= F_AR32WR
;
3050 internal_f
.f_flags
|= F_AR32W
;
3052 /* Set up the ``optional'' header. */
3053 if ((abfd
->flags
& D_PAGED
) != 0)
3054 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
3056 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
3058 /* FIXME: Is this really correct? */
3059 internal_a
.vstamp
= symhdr
->vstamp
;
3061 /* At least on Ultrix, these have to be rounded to page boundaries.
3062 FIXME: Is this true on other platforms? */
3063 if ((abfd
->flags
& D_PAGED
) != 0)
3065 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
3066 internal_a
.text_start
= text_start
&~ (round
- 1);
3067 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
3068 internal_a
.data_start
= data_start
&~ (round
- 1);
3072 internal_a
.tsize
= text_size
;
3073 internal_a
.text_start
= text_start
;
3074 internal_a
.dsize
= data_size
;
3075 internal_a
.data_start
= data_start
;
3078 /* On Ultrix, the initial portions of the .sbss and .bss segments
3079 are at the end of the data section. The bsize field in the
3080 optional header records how many bss bytes are required beyond
3081 those in the data section. The value is not rounded to a page
3083 if (bss_size
< internal_a
.dsize
- data_size
)
3086 bss_size
-= internal_a
.dsize
- data_size
;
3087 internal_a
.bsize
= bss_size
;
3088 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
3090 internal_a
.entry
= bfd_get_start_address (abfd
);
3092 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
3094 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
3095 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
3096 for (i
= 0; i
< 4; i
++)
3097 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
3099 /* Write out the file header and the optional header. */
3101 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3104 bfd_coff_swap_filehdr_out (abfd
, (PTR
) &internal_f
, buff
);
3105 if (bfd_write (buff
, 1, filhsz
, abfd
) != filhsz
)
3108 bfd_coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, buff
);
3109 if (bfd_write (buff
, 1, aoutsz
, abfd
) != aoutsz
)
3112 /* Build the external symbol information. This must be done before
3113 writing out the relocs so that we know the symbol indices. We
3114 don't do this if this BFD was created by the backend linker,
3115 since it will have already handled the symbols and relocs. */
3116 if (! ecoff_data (abfd
)->linker
)
3118 symhdr
->iextMax
= 0;
3119 symhdr
->issExtMax
= 0;
3120 debug
->external_ext
= debug
->external_ext_end
= NULL
;
3121 debug
->ssext
= debug
->ssext_end
= NULL
;
3122 if (bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
3123 (((abfd
->flags
& EXEC_P
) == 0)
3125 ecoff_get_extr
, ecoff_set_index
)
3129 /* Write out the relocs. */
3130 for (current
= abfd
->sections
;
3131 current
!= (asection
*) NULL
;
3132 current
= current
->next
)
3134 arelent
**reloc_ptr_ptr
;
3135 arelent
**reloc_end
;
3138 if (current
->reloc_count
== 0)
3142 bfd_alloc (abfd
, current
->reloc_count
* external_reloc_size
);
3143 if (reloc_buff
== NULL
)
3145 bfd_set_error (bfd_error_no_memory
);
3149 reloc_ptr_ptr
= current
->orelocation
;
3150 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
3151 out_ptr
= (char *) reloc_buff
;
3153 reloc_ptr_ptr
< reloc_end
;
3154 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
3158 struct internal_reloc in
;
3160 memset ((PTR
) &in
, 0, sizeof in
);
3162 reloc
= *reloc_ptr_ptr
;
3163 sym
= *reloc
->sym_ptr_ptr
;
3165 in
.r_vaddr
= (reloc
->address
3166 + bfd_get_section_vma (abfd
, current
));
3167 in
.r_type
= reloc
->howto
->type
;
3169 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
3171 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
3178 name
= bfd_get_section_name (abfd
, bfd_get_section (sym
));
3179 if (strcmp (name
, ".text") == 0)
3180 in
.r_symndx
= RELOC_SECTION_TEXT
;
3181 else if (strcmp (name
, ".rdata") == 0)
3182 in
.r_symndx
= RELOC_SECTION_RDATA
;
3183 else if (strcmp (name
, ".data") == 0)
3184 in
.r_symndx
= RELOC_SECTION_DATA
;
3185 else if (strcmp (name
, ".sdata") == 0)
3186 in
.r_symndx
= RELOC_SECTION_SDATA
;
3187 else if (strcmp (name
, ".sbss") == 0)
3188 in
.r_symndx
= RELOC_SECTION_SBSS
;
3189 else if (strcmp (name
, ".bss") == 0)
3190 in
.r_symndx
= RELOC_SECTION_BSS
;
3191 else if (strcmp (name
, ".init") == 0)
3192 in
.r_symndx
= RELOC_SECTION_INIT
;
3193 else if (strcmp (name
, ".lit8") == 0)
3194 in
.r_symndx
= RELOC_SECTION_LIT8
;
3195 else if (strcmp (name
, ".lit4") == 0)
3196 in
.r_symndx
= RELOC_SECTION_LIT4
;
3197 else if (strcmp (name
, ".xdata") == 0)
3198 in
.r_symndx
= RELOC_SECTION_XDATA
;
3199 else if (strcmp (name
, ".pdata") == 0)
3200 in
.r_symndx
= RELOC_SECTION_PDATA
;
3201 else if (strcmp (name
, ".fini") == 0)
3202 in
.r_symndx
= RELOC_SECTION_FINI
;
3203 else if (strcmp (name
, ".lita") == 0)
3204 in
.r_symndx
= RELOC_SECTION_LITA
;
3205 else if (strcmp (name
, "*ABS*") == 0)
3206 in
.r_symndx
= RELOC_SECTION_ABS
;
3212 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
3214 (*swap_reloc_out
) (abfd
, &in
, (PTR
) out_ptr
);
3217 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
3219 if (bfd_write (reloc_buff
,
3220 external_reloc_size
, current
->reloc_count
, abfd
)
3221 != external_reloc_size
* current
->reloc_count
)
3223 bfd_release (abfd
, reloc_buff
);
3227 /* Write out the symbolic debugging information. */
3228 if (bfd_get_symcount (abfd
) > 0)
3230 /* Write out the debugging information. */
3231 if (bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
3232 ecoff_data (abfd
)->sym_filepos
)
3238 /* The .bss section of a demand paged executable must receive an
3239 entire page. If there are symbols, the symbols will start on the
3240 next page. If there are no symbols, we must fill out the page by
3242 if (bfd_get_symcount (abfd
) == 0
3243 && (abfd
->flags
& EXEC_P
) != 0
3244 && (abfd
->flags
& D_PAGED
) != 0)
3248 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
3251 if (bfd_read (&c
, 1, 1, abfd
) == 0)
3253 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
3256 if (bfd_write (&c
, 1, 1, abfd
) != 1)
3260 if (reloc_buff
!= NULL
)
3261 bfd_release (abfd
, reloc_buff
);
3266 if (reloc_buff
!= NULL
)
3267 bfd_release (abfd
, reloc_buff
);
3273 /* Archive handling. ECOFF uses what appears to be a unique type of
3274 archive header (armap). The byte ordering of the armap and the
3275 contents are encoded in the name of the armap itself. At least for
3276 now, we only support archives with the same byte ordering in the
3277 armap and the contents.
3279 The first four bytes in the armap are the number of symbol
3280 definitions. This is always a power of two.
3282 This is followed by the symbol definitions. Each symbol definition
3283 occupies 8 bytes. The first four bytes are the offset from the
3284 start of the armap strings to the null-terminated string naming
3285 this symbol. The second four bytes are the file offset to the
3286 archive member which defines this symbol. If the second four bytes
3287 are 0, then this is not actually a symbol definition, and it should
3290 The symbols are hashed into the armap with a closed hashing scheme.
3291 See the functions below for the details of the algorithm.
3293 After the symbol definitions comes four bytes holding the size of
3294 the string table, followed by the string table itself. */
3296 /* The name of an archive headers looks like this:
3297 __________E[BL]E[BL]_ (with a trailing space).
3298 The trailing space is changed to an X if the archive is changed to
3299 indicate that the armap is out of date.
3301 The Alpha seems to use ________64E[BL]E[BL]_. */
3303 #define ARMAP_BIG_ENDIAN 'B'
3304 #define ARMAP_LITTLE_ENDIAN 'L'
3305 #define ARMAP_MARKER 'E'
3306 #define ARMAP_START_LENGTH 10
3307 #define ARMAP_HEADER_MARKER_INDEX 10
3308 #define ARMAP_HEADER_ENDIAN_INDEX 11
3309 #define ARMAP_OBJECT_MARKER_INDEX 12
3310 #define ARMAP_OBJECT_ENDIAN_INDEX 13
3311 #define ARMAP_END_INDEX 14
3312 #define ARMAP_END "_ "
3314 /* This is a magic number used in the hashing algorithm. */
3315 #define ARMAP_HASH_MAGIC 0x9dd68ab5
3317 /* This returns the hash value to use for a string. It also sets
3318 *REHASH to the rehash adjustment if the first slot is taken. SIZE
3319 is the number of entries in the hash table, and HLOG is the log
3323 ecoff_armap_hash (s
, rehash
, size
, hlog
)
3325 unsigned int *rehash
;
3333 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
3334 hash
*= ARMAP_HASH_MAGIC
;
3335 *rehash
= (hash
& (size
- 1)) | 1;
3336 return hash
>> (32 - hlog
);
3339 /* Read in the armap. */
3342 _bfd_ecoff_slurp_armap (abfd
)
3347 struct areltdata
*mapdata
;
3348 bfd_size_type parsed_size
;
3350 struct artdata
*ardata
;
3353 struct symdef
*symdef_ptr
;
3356 /* Get the name of the first element. */
3357 i
= bfd_read ((PTR
) nextname
, 1, 16, abfd
);
3363 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
3366 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
3367 standard COFF armap. We could move the ECOFF armap stuff into
3368 bfd_slurp_armap, but that seems inappropriate since no other
3369 target uses this format. Instead, we check directly for a COFF
3371 if (strncmp (nextname
, "/ ", 16) == 0)
3372 return bfd_slurp_armap (abfd
);
3374 /* See if the first element is an armap. */
3375 if (strncmp (nextname
, ecoff_backend (abfd
)->armap_start
,
3376 ARMAP_START_LENGTH
) != 0
3377 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
3378 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
3379 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
3380 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
3381 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
3382 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
3383 || strncmp (nextname
+ ARMAP_END_INDEX
,
3384 ARMAP_END
, sizeof ARMAP_END
- 1) != 0)
3386 bfd_has_map (abfd
) = false;
3390 /* Make sure we have the right byte ordering. */
3391 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
3392 ^ (abfd
->xvec
->header_byteorder_big_p
!= false))
3393 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
3394 ^ (abfd
->xvec
->byteorder_big_p
!= false)))
3396 bfd_set_error (bfd_error_wrong_format
);
3400 /* Read in the armap. */
3401 ardata
= bfd_ardata (abfd
);
3402 mapdata
= _bfd_snarf_ar_hdr (abfd
);
3403 if (mapdata
== (struct areltdata
*) NULL
)
3405 parsed_size
= mapdata
->parsed_size
;
3406 bfd_release (abfd
, (PTR
) mapdata
);
3408 raw_armap
= (char *) bfd_alloc (abfd
, parsed_size
);
3409 if (raw_armap
== (char *) NULL
)
3411 bfd_set_error (bfd_error_no_memory
);
3415 if (bfd_read ((PTR
) raw_armap
, 1, parsed_size
, abfd
) != parsed_size
)
3417 if (bfd_get_error () != bfd_error_system_call
)
3418 bfd_set_error (bfd_error_malformed_archive
);
3419 bfd_release (abfd
, (PTR
) raw_armap
);
3423 ardata
->tdata
= (PTR
) raw_armap
;
3425 count
= bfd_h_get_32 (abfd
, (PTR
) raw_armap
);
3427 ardata
->symdef_count
= 0;
3428 ardata
->cache
= (struct ar_cache
*) NULL
;
3430 /* This code used to overlay the symdefs over the raw archive data,
3431 but that doesn't work on a 64 bit host. */
3433 stringbase
= raw_armap
+ count
* 8 + 8;
3435 #ifdef CHECK_ARMAP_HASH
3439 /* Double check that I have the hashing algorithm right by making
3440 sure that every symbol can be looked up successfully. */
3442 for (i
= 1; i
< count
; i
<<= 1)
3444 BFD_ASSERT (i
== count
);
3446 raw_ptr
= raw_armap
+ 4;
3447 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3449 unsigned int name_offset
, file_offset
;
3450 unsigned int hash
, rehash
, srch
;
3452 name_offset
= bfd_h_get_32 (abfd
, (PTR
) raw_ptr
);
3453 file_offset
= bfd_h_get_32 (abfd
, (PTR
) (raw_ptr
+ 4));
3454 if (file_offset
== 0)
3456 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
3461 /* See if we can rehash to this location. */
3462 for (srch
= (hash
+ rehash
) & (count
- 1);
3463 srch
!= hash
&& srch
!= i
;
3464 srch
= (srch
+ rehash
) & (count
- 1))
3465 BFD_ASSERT (bfd_h_get_32 (abfd
, (PTR
) (raw_armap
+ 8 + srch
* 8))
3467 BFD_ASSERT (srch
== i
);
3471 #endif /* CHECK_ARMAP_HASH */
3473 raw_ptr
= raw_armap
+ 4;
3474 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3475 if (bfd_h_get_32 (abfd
, (PTR
) (raw_ptr
+ 4)) != 0)
3476 ++ardata
->symdef_count
;
3478 symdef_ptr
= ((struct symdef
*)
3480 ardata
->symdef_count
* sizeof (struct symdef
)));
3483 bfd_set_error (bfd_error_no_memory
);
3487 ardata
->symdefs
= (carsym
*) symdef_ptr
;
3489 raw_ptr
= raw_armap
+ 4;
3490 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3492 unsigned int name_offset
, file_offset
;
3494 file_offset
= bfd_h_get_32 (abfd
, (PTR
) (raw_ptr
+ 4));
3495 if (file_offset
== 0)
3497 name_offset
= bfd_h_get_32 (abfd
, (PTR
) raw_ptr
);
3498 symdef_ptr
->s
.name
= stringbase
+ name_offset
;
3499 symdef_ptr
->file_offset
= file_offset
;
3503 ardata
->first_file_filepos
= bfd_tell (abfd
);
3504 /* Pad to an even boundary. */
3505 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
3507 bfd_has_map (abfd
) = true;
3512 /* Write out an armap. */
3515 _bfd_ecoff_write_armap (abfd
, elength
, map
, orl_count
, stridx
)
3517 unsigned int elength
;
3519 unsigned int orl_count
;
3522 unsigned int hashsize
, hashlog
;
3523 unsigned int symdefsize
;
3525 unsigned int stringsize
;
3526 unsigned int mapsize
;
3529 struct stat statbuf
;
3532 bfd_byte
*hashtable
;
3536 /* Ultrix appears to use as a hash table size the least power of two
3537 greater than twice the number of entries. */
3538 for (hashlog
= 0; (1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3540 hashsize
= 1 << hashlog
;
3542 symdefsize
= hashsize
* 8;
3544 stringsize
= stridx
+ padit
;
3546 /* Include 8 bytes to store symdefsize and stringsize in output. */
3547 mapsize
= symdefsize
+ stringsize
+ 8;
3549 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3551 memset ((PTR
) &hdr
, 0, sizeof hdr
);
3553 /* Work out the ECOFF armap name. */
3554 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3555 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3556 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3557 (abfd
->xvec
->header_byteorder_big_p
3559 : ARMAP_LITTLE_ENDIAN
);
3560 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3561 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3562 abfd
->xvec
->byteorder_big_p
? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3563 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3565 /* Write the timestamp of the archive header to be just a little bit
3566 later than the timestamp of the file, otherwise the linker will
3567 complain that the index is out of date. Actually, the Ultrix
3568 linker just checks the archive name; the GNU linker may check the
3570 stat (abfd
->filename
, &statbuf
);
3571 sprintf (hdr
.ar_date
, "%ld", (long) (statbuf
.st_mtime
+ 60));
3573 /* The DECstation uses zeroes for the uid, gid and mode of the
3575 hdr
.ar_uid
[0] = '0';
3576 hdr
.ar_gid
[0] = '0';
3577 hdr
.ar_mode
[0] = '0';
3579 sprintf (hdr
.ar_size
, "%-10d", (int) mapsize
);
3581 hdr
.ar_fmag
[0] = '`';
3582 hdr
.ar_fmag
[1] = '\012';
3584 /* Turn all null bytes in the header into spaces. */
3585 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3586 if (((char *)(&hdr
))[i
] == '\0')
3587 (((char *)(&hdr
))[i
]) = ' ';
3589 if (bfd_write ((PTR
) &hdr
, 1, sizeof (struct ar_hdr
), abfd
)
3590 != sizeof (struct ar_hdr
))
3593 bfd_h_put_32 (abfd
, (bfd_vma
) hashsize
, temp
);
3594 if (bfd_write ((PTR
) temp
, 1, 4, abfd
) != 4)
3597 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3600 bfd_set_error (bfd_error_no_memory
);
3604 current
= abfd
->archive_head
;
3606 for (i
= 0; i
< orl_count
; i
++)
3608 unsigned int hash
, rehash
;
3610 /* Advance firstreal to the file position of this archive
3612 if (((bfd
*) map
[i
].pos
) != last_elt
)
3616 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3617 firstreal
+= firstreal
% 2;
3618 current
= current
->next
;
3620 while (current
!= (bfd
*) map
[i
].pos
);
3625 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3626 if (bfd_h_get_32 (abfd
, (PTR
) (hashtable
+ (hash
* 8) + 4)) != 0)
3630 /* The desired slot is already taken. */
3631 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3633 srch
= (srch
+ rehash
) & (hashsize
- 1))
3634 if (bfd_h_get_32 (abfd
, (PTR
) (hashtable
+ (srch
* 8) + 4)) == 0)
3637 BFD_ASSERT (srch
!= hash
);
3642 bfd_h_put_32 (abfd
, (bfd_vma
) map
[i
].namidx
,
3643 (PTR
) (hashtable
+ hash
* 8));
3644 bfd_h_put_32 (abfd
, (bfd_vma
) firstreal
,
3645 (PTR
) (hashtable
+ hash
* 8 + 4));
3648 if (bfd_write ((PTR
) hashtable
, 1, symdefsize
, abfd
) != symdefsize
)
3651 bfd_release (abfd
, hashtable
);
3653 /* Now write the strings. */
3654 bfd_h_put_32 (abfd
, (bfd_vma
) stringsize
, temp
);
3655 if (bfd_write ((PTR
) temp
, 1, 4, abfd
) != 4)
3657 for (i
= 0; i
< orl_count
; i
++)
3661 len
= strlen (*map
[i
].name
) + 1;
3662 if (bfd_write ((PTR
) (*map
[i
].name
), 1, len
, abfd
) != len
)
3666 /* The spec sez this should be a newline. But in order to be
3667 bug-compatible for DECstation ar we use a null. */
3670 if (bfd_write ("", 1, 1, abfd
) != 1)
3677 /* See whether this BFD is an archive. If it is, read in the armap
3678 and the extended name table. */
3681 _bfd_ecoff_archive_p (abfd
)
3684 char armag
[SARMAG
+ 1];
3686 if (bfd_read ((PTR
) armag
, 1, SARMAG
, abfd
) != SARMAG
3687 || strncmp (armag
, ARMAG
, SARMAG
) != 0)
3689 if (bfd_get_error () != bfd_error_system_call
)
3690 bfd_set_error (bfd_error_wrong_format
);
3691 return (const bfd_target
*) NULL
;
3694 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
3695 involves a cast, we can't do it as the left operand of
3697 abfd
->tdata
.aout_ar_data
=
3698 (struct artdata
*) bfd_zalloc (abfd
, sizeof (struct artdata
));
3700 if (bfd_ardata (abfd
) == (struct artdata
*) NULL
)
3702 bfd_set_error (bfd_error_no_memory
);
3703 return (const bfd_target
*) NULL
;
3706 bfd_ardata (abfd
)->first_file_filepos
= SARMAG
;
3707 bfd_ardata (abfd
)->cache
= NULL
;
3708 bfd_ardata (abfd
)->archive_head
= NULL
;
3709 bfd_ardata (abfd
)->symdefs
= NULL
;
3710 bfd_ardata (abfd
)->extended_names
= NULL
;
3711 bfd_ardata (abfd
)->tdata
= NULL
;
3713 if (_bfd_ecoff_slurp_armap (abfd
) == false
3714 || _bfd_ecoff_slurp_extended_name_table (abfd
) == false)
3716 bfd_release (abfd
, bfd_ardata (abfd
));
3717 abfd
->tdata
.aout_ar_data
= (struct artdata
*) NULL
;
3718 return (const bfd_target
*) NULL
;
3724 /* ECOFF linker code. */
3726 static struct bfd_hash_entry
*ecoff_link_hash_newfunc
3727 PARAMS ((struct bfd_hash_entry
*entry
,
3728 struct bfd_hash_table
*table
,
3729 const char *string
));
3730 static boolean ecoff_link_add_archive_symbols
3731 PARAMS ((bfd
*, struct bfd_link_info
*));
3732 static boolean ecoff_link_check_archive_element
3733 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*pneeded
));
3734 static boolean ecoff_link_add_object_symbols
3735 PARAMS ((bfd
*, struct bfd_link_info
*));
3736 static boolean ecoff_link_add_externals
3737 PARAMS ((bfd
*, struct bfd_link_info
*, PTR
, char *));
3739 /* Routine to create an entry in an ECOFF link hash table. */
3741 static struct bfd_hash_entry
*
3742 ecoff_link_hash_newfunc (entry
, table
, string
)
3743 struct bfd_hash_entry
*entry
;
3744 struct bfd_hash_table
*table
;
3747 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3749 /* Allocate the structure if it has not already been allocated by a
3751 if (ret
== (struct ecoff_link_hash_entry
*) NULL
)
3752 ret
= ((struct ecoff_link_hash_entry
*)
3753 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
3754 if (ret
== (struct ecoff_link_hash_entry
*) NULL
)
3756 bfd_set_error (bfd_error_no_memory
);
3760 /* Call the allocation method of the superclass. */
3761 ret
= ((struct ecoff_link_hash_entry
*)
3762 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3767 /* Set local fields. */
3773 memset ((PTR
) &ret
->esym
, 0, sizeof ret
->esym
);
3775 return (struct bfd_hash_entry
*) ret
;
3778 /* Create an ECOFF link hash table. */
3780 struct bfd_link_hash_table
*
3781 _bfd_ecoff_bfd_link_hash_table_create (abfd
)
3784 struct ecoff_link_hash_table
*ret
;
3786 ret
= ((struct ecoff_link_hash_table
*)
3787 malloc (sizeof (struct ecoff_link_hash_table
)));
3790 bfd_set_error (bfd_error_no_memory
);
3793 if (! _bfd_link_hash_table_init (&ret
->root
, abfd
,
3794 ecoff_link_hash_newfunc
))
3797 return (struct bfd_link_hash_table
*) NULL
;
3802 /* Look up an entry in an ECOFF link hash table. */
3804 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3805 ((struct ecoff_link_hash_entry *) \
3806 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3808 /* Traverse an ECOFF link hash table. */
3810 #define ecoff_link_hash_traverse(table, func, info) \
3811 (bfd_link_hash_traverse \
3813 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
3816 /* Get the ECOFF link hash table from the info structure. This is
3819 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3821 /* Given an ECOFF BFD, add symbols to the global hash table as
3825 _bfd_ecoff_bfd_link_add_symbols (abfd
, info
)
3827 struct bfd_link_info
*info
;
3829 switch (bfd_get_format (abfd
))
3832 return ecoff_link_add_object_symbols (abfd
, info
);
3834 return ecoff_link_add_archive_symbols (abfd
, info
);
3836 bfd_set_error (bfd_error_wrong_format
);
3841 /* Add the symbols from an archive file to the global hash table.
3842 This looks through the undefined symbols, looks each one up in the
3843 archive hash table, and adds any associated object file. We do not
3844 use _bfd_generic_link_add_archive_symbols because ECOFF archives
3845 already have a hash table, so there is no reason to construct
3849 ecoff_link_add_archive_symbols (abfd
, info
)
3851 struct bfd_link_info
*info
;
3853 const bfd_byte
*raw_armap
;
3854 struct bfd_link_hash_entry
**pundef
;
3855 unsigned int armap_count
;
3856 unsigned int armap_log
;
3858 const bfd_byte
*hashtable
;
3859 const char *stringbase
;
3861 if (! bfd_has_map (abfd
))
3863 bfd_set_error (bfd_error_no_symbols
);
3867 /* If we don't have any raw data for this archive, as can happen on
3868 Irix 4.0.5F, we call the generic routine.
3869 FIXME: We should be more clever about this, since someday tdata
3870 may get to something for a generic archive. */
3871 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
3872 if (raw_armap
== (bfd_byte
*) NULL
)
3873 return (_bfd_generic_link_add_archive_symbols
3874 (abfd
, info
, ecoff_link_check_archive_element
));
3876 armap_count
= bfd_h_get_32 (abfd
, raw_armap
);
3879 for (i
= 1; i
< armap_count
; i
<<= 1)
3881 BFD_ASSERT (i
== armap_count
);
3883 hashtable
= raw_armap
+ 4;
3884 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
3886 /* Look through the list of undefined symbols. */
3887 pundef
= &info
->hash
->undefs
;
3888 while (*pundef
!= (struct bfd_link_hash_entry
*) NULL
)
3890 struct bfd_link_hash_entry
*h
;
3891 unsigned int hash
, rehash
;
3892 unsigned int file_offset
;
3898 /* When a symbol is defined, it is not necessarily removed from
3900 if (h
->type
!= bfd_link_hash_undefined
3901 && h
->type
!= bfd_link_hash_common
)
3903 /* Remove this entry from the list, for general cleanliness
3904 and because we are going to look through the list again
3905 if we search any more libraries. We can't remove the
3906 entry if it is the tail, because that would lose any
3907 entries we add to the list later on. */
3908 if (*pundef
!= info
->hash
->undefs_tail
)
3909 *pundef
= (*pundef
)->next
;
3911 pundef
= &(*pundef
)->next
;
3915 /* Native ECOFF linkers do not pull in archive elements merely
3916 to satisfy common definitions, so neither do we. We leave
3917 them on the list, though, in case we are linking against some
3918 other object format. */
3919 if (h
->type
!= bfd_link_hash_undefined
)
3921 pundef
= &(*pundef
)->next
;
3925 /* Look for this symbol in the archive hash table. */
3926 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
3929 file_offset
= bfd_h_get_32 (abfd
, hashtable
+ (hash
* 8) + 4);
3930 if (file_offset
== 0)
3932 /* Nothing in this slot. */
3933 pundef
= &(*pundef
)->next
;
3937 name
= stringbase
+ bfd_h_get_32 (abfd
, hashtable
+ (hash
* 8));
3938 if (name
[0] != h
->root
.string
[0]
3939 || strcmp (name
, h
->root
.string
) != 0)
3944 /* That was the wrong symbol. Try rehashing. */
3946 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
3948 srch
= (srch
+ rehash
) & (armap_count
- 1))
3950 file_offset
= bfd_h_get_32 (abfd
, hashtable
+ (srch
* 8) + 4);
3951 if (file_offset
== 0)
3953 name
= stringbase
+ bfd_h_get_32 (abfd
, hashtable
+ (srch
* 8));
3954 if (name
[0] == h
->root
.string
[0]
3955 && strcmp (name
, h
->root
.string
) == 0)
3964 pundef
= &(*pundef
)->next
;
3971 element
= _bfd_get_elt_at_filepos (abfd
, file_offset
);
3972 if (element
== (bfd
*) NULL
)
3975 if (! bfd_check_format (element
, bfd_object
))
3978 /* Unlike the generic linker, we know that this element provides
3979 a definition for an undefined symbol and we know that we want
3980 to include it. We don't need to check anything. */
3981 if (! (*info
->callbacks
->add_archive_element
) (info
, element
, name
))
3983 if (! ecoff_link_add_object_symbols (element
, info
))
3986 pundef
= &(*pundef
)->next
;
3992 /* This is called if we used _bfd_generic_link_add_archive_symbols
3993 because we were not dealing with an ECOFF archive. */
3996 ecoff_link_check_archive_element (abfd
, info
, pneeded
)
3998 struct bfd_link_info
*info
;
4001 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4002 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
4003 = backend
->debug_swap
.swap_ext_in
;
4005 bfd_size_type external_ext_size
;
4006 PTR external_ext
= NULL
;
4014 if (! ecoff_slurp_symbolic_header (abfd
))
4017 /* If there are no symbols, we don't want it. */
4018 if (bfd_get_symcount (abfd
) == 0)
4019 goto successful_return
;
4021 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
4023 /* Read in the external symbols and external strings. */
4024 external_ext_size
= backend
->debug_swap
.external_ext_size
;
4025 esize
= symhdr
->iextMax
* external_ext_size
;
4026 external_ext
= (PTR
) malloc (esize
);
4027 if (external_ext
== NULL
&& esize
!= 0)
4029 bfd_set_error (bfd_error_no_memory
);
4033 if (bfd_seek (abfd
, symhdr
->cbExtOffset
, SEEK_SET
) != 0
4034 || bfd_read (external_ext
, 1, esize
, abfd
) != esize
)
4037 ssext
= (char *) malloc (symhdr
->issExtMax
);
4038 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
4040 bfd_set_error (bfd_error_no_memory
);
4044 if (bfd_seek (abfd
, symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
4045 || bfd_read (ssext
, 1, symhdr
->issExtMax
, abfd
) != symhdr
->issExtMax
)
4048 /* Look through the external symbols to see if they define some
4049 symbol that is currently undefined. */
4050 ext_ptr
= (char *) external_ext
;
4051 ext_end
= ext_ptr
+ esize
;
4052 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
)
4057 struct bfd_link_hash_entry
*h
;
4059 (*swap_ext_in
) (abfd
, (PTR
) ext_ptr
, &esym
);
4061 /* See if this symbol defines something. */
4062 if (esym
.asym
.st
!= stGlobal
4063 && esym
.asym
.st
!= stLabel
4064 && esym
.asym
.st
!= stProc
)
4067 switch (esym
.asym
.sc
)
4090 name
= ssext
+ esym
.asym
.iss
;
4091 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
4093 /* Unlike the generic linker, we do not pull in elements because
4094 of common symbols. */
4095 if (h
== (struct bfd_link_hash_entry
*) NULL
4096 || h
->type
!= bfd_link_hash_undefined
)
4099 /* Include this element. */
4100 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
4102 if (! ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
))
4106 goto successful_return
;
4110 if (external_ext
!= NULL
)
4111 free (external_ext
);
4116 if (external_ext
!= NULL
)
4117 free (external_ext
);
4123 /* Add symbols from an ECOFF object file to the global linker hash
4127 ecoff_link_add_object_symbols (abfd
, info
)
4129 struct bfd_link_info
*info
;
4132 bfd_size_type external_ext_size
;
4133 PTR external_ext
= NULL
;
4138 if (! ecoff_slurp_symbolic_header (abfd
))
4141 /* If there are no symbols, we don't want it. */
4142 if (bfd_get_symcount (abfd
) == 0)
4145 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
4147 /* Read in the external symbols and external strings. */
4148 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
4149 esize
= symhdr
->iextMax
* external_ext_size
;
4150 external_ext
= (PTR
) malloc (esize
);
4151 if (external_ext
== NULL
&& esize
!= 0)
4153 bfd_set_error (bfd_error_no_memory
);
4157 if (bfd_seek (abfd
, symhdr
->cbExtOffset
, SEEK_SET
) != 0
4158 || bfd_read (external_ext
, 1, esize
, abfd
) != esize
)
4161 ssext
= (char *) malloc (symhdr
->issExtMax
);
4162 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
4164 bfd_set_error (bfd_error_no_memory
);
4168 if (bfd_seek (abfd
, symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
4169 || bfd_read (ssext
, 1, symhdr
->issExtMax
, abfd
) != symhdr
->issExtMax
)
4172 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
4176 if (external_ext
!= NULL
)
4177 free (external_ext
);
4183 if (external_ext
!= NULL
)
4184 free (external_ext
);
4188 /* Add the external symbols of an object file to the global linker
4189 hash table. The external symbols and strings we are passed are
4190 just allocated on the stack, and will be discarded. We must
4191 explicitly save any information we may need later on in the link.
4192 We do not want to read the external symbol information again. */
4195 ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
)
4197 struct bfd_link_info
*info
;
4201 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4202 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
4203 = backend
->debug_swap
.swap_ext_in
;
4204 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
4205 unsigned long ext_count
;
4206 struct ecoff_link_hash_entry
**sym_hash
;
4210 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
4212 sym_hash
= ((struct ecoff_link_hash_entry
**)
4214 ext_count
* sizeof (struct bfd_link_hash_entry
*)));
4217 bfd_set_error (bfd_error_no_memory
);
4220 ecoff_data (abfd
)->sym_hashes
= sym_hash
;
4222 ext_ptr
= (char *) external_ext
;
4223 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
4224 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
4231 struct ecoff_link_hash_entry
*h
;
4235 (*swap_ext_in
) (abfd
, (PTR
) ext_ptr
, &esym
);
4237 /* Skip debugging symbols. */
4239 switch (esym
.asym
.st
)
4255 /* Get the information for this symbol. */
4256 value
= esym
.asym
.value
;
4257 switch (esym
.asym
.sc
)
4277 section
= bfd_make_section_old_way (abfd
, ".text");
4278 value
-= section
->vma
;
4281 section
= bfd_make_section_old_way (abfd
, ".data");
4282 value
-= section
->vma
;
4285 section
= bfd_make_section_old_way (abfd
, ".bss");
4286 value
-= section
->vma
;
4289 section
= bfd_abs_section_ptr
;
4292 section
= bfd_und_section_ptr
;
4295 section
= bfd_make_section_old_way (abfd
, ".sdata");
4296 value
-= section
->vma
;
4299 section
= bfd_make_section_old_way (abfd
, ".sbss");
4300 value
-= section
->vma
;
4303 section
= bfd_make_section_old_way (abfd
, ".rdata");
4304 value
-= section
->vma
;
4307 if (value
> ecoff_data (abfd
)->gp_size
)
4309 section
= bfd_com_section_ptr
;
4314 if (ecoff_scom_section
.name
== NULL
)
4316 /* Initialize the small common section. */
4317 ecoff_scom_section
.name
= SCOMMON
;
4318 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
4319 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
4320 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
4321 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
4322 ecoff_scom_symbol
.name
= SCOMMON
;
4323 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
4324 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
4325 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
4327 section
= &ecoff_scom_section
;
4330 section
= bfd_und_section_ptr
;
4333 section
= bfd_make_section_old_way (abfd
, ".init");
4334 value
-= section
->vma
;
4337 section
= bfd_make_section_old_way (abfd
, ".fini");
4338 value
-= section
->vma
;
4342 if (section
== (asection
*) NULL
)
4345 name
= ssext
+ esym
.asym
.iss
;
4348 if (! (_bfd_generic_link_add_one_symbol
4349 (info
, abfd
, name
, BSF_GLOBAL
, section
, value
,
4350 (const char *) NULL
, true, true,
4351 (struct bfd_link_hash_entry
**) &h
)))
4356 /* If we are building an ECOFF hash table, save the external
4357 symbol information. */
4358 if (info
->hash
->creator
->flavour
== bfd_get_flavour (abfd
))
4360 if (h
->abfd
== (bfd
*) NULL
4361 || (! bfd_is_und_section (section
)
4362 && (! bfd_is_com_section (section
)
4363 || h
->root
.type
!= bfd_link_hash_defined
)))
4369 /* Remember whether this symbol was small undefined. */
4370 if (esym
.asym
.sc
== scSUndefined
)
4373 /* If this symbol was ever small undefined, it needs to wind
4374 up in a GP relative section. We can't control the
4375 section of a defined symbol, but we can control the
4376 section of a common symbol. This case is actually needed
4377 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
4379 && h
->root
.type
== bfd_link_hash_common
4380 && strcmp (h
->root
.u
.c
.section
->name
, SCOMMON
) != 0)
4382 h
->root
.u
.c
.section
= bfd_make_section_old_way (abfd
, SCOMMON
);
4383 h
->root
.u
.c
.section
->flags
= SEC_ALLOC
;
4384 if (h
->esym
.asym
.sc
== scCommon
)
4385 h
->esym
.asym
.sc
= scSCommon
;
4393 /* ECOFF final link routines. */
4395 static boolean ecoff_final_link_debug_accumulate
4396 PARAMS ((bfd
*output_bfd
, bfd
*input_bfd
, struct bfd_link_info
*,
4398 static boolean ecoff_link_write_external
4399 PARAMS ((struct ecoff_link_hash_entry
*, PTR
));
4400 static boolean ecoff_indirect_link_order
4401 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
4402 struct bfd_link_order
*));
4403 static boolean ecoff_reloc_link_order
4404 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
4405 struct bfd_link_order
*));
4407 /* ECOFF final link routine. This looks through all the input BFDs
4408 and gathers together all the debugging information, and then
4409 processes all the link order information. This may cause it to
4410 close and reopen some input BFDs; I'll see how bad this is. */
4413 _bfd_ecoff_bfd_final_link (abfd
, info
)
4415 struct bfd_link_info
*info
;
4417 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4418 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4421 register bfd
*input_bfd
;
4423 struct bfd_link_order
*p
;
4425 /* We accumulate the debugging information counts in the symbolic
4427 symhdr
= &debug
->symbolic_header
;
4429 symhdr
->ilineMax
= 0;
4433 symhdr
->isymMax
= 0;
4434 symhdr
->ioptMax
= 0;
4435 symhdr
->iauxMax
= 0;
4437 symhdr
->issExtMax
= 0;
4440 symhdr
->iextMax
= 0;
4442 /* We accumulate the debugging information itself in the debug_info
4445 debug
->external_dnr
= NULL
;
4446 debug
->external_pdr
= NULL
;
4447 debug
->external_sym
= NULL
;
4448 debug
->external_opt
= NULL
;
4449 debug
->external_aux
= NULL
;
4451 debug
->ssext
= debug
->ssext_end
= NULL
;
4452 debug
->external_fdr
= NULL
;
4453 debug
->external_rfd
= NULL
;
4454 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4456 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4457 if (handle
== (PTR
) NULL
)
4460 /* Accumulate the debugging symbols from each input BFD. */
4461 for (input_bfd
= info
->input_bfds
;
4462 input_bfd
!= (bfd
*) NULL
;
4463 input_bfd
= input_bfd
->link_next
)
4467 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4469 /* Abitrarily set the symbolic header vstamp to the vstamp
4470 of the first object file in the link. */
4471 if (symhdr
->vstamp
== 0)
4473 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4474 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4478 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4479 debug
, &backend
->debug_swap
,
4484 /* Combine the register masks. */
4485 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4486 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4487 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4488 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4489 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4490 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4493 /* Write out the external symbols. */
4494 ecoff_link_hash_traverse (ecoff_hash_table (info
),
4495 ecoff_link_write_external
,
4498 if (info
->relocateable
)
4500 /* We need to make a pass over the link_orders to count up the
4501 number of relocations we will need to output, so that we know
4502 how much space they will take up. */
4503 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4506 for (p
= o
->link_order_head
;
4507 p
!= (struct bfd_link_order
*) NULL
;
4509 if (p
->type
== bfd_indirect_link_order
)
4510 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4511 else if (p
->type
== bfd_section_reloc_link_order
4512 || p
->type
== bfd_symbol_reloc_link_order
)
4517 /* Compute the reloc and symbol file positions. */
4518 ecoff_compute_reloc_file_positions (abfd
);
4520 /* Write out the debugging information. */
4521 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4522 &backend
->debug_swap
, info
,
4523 ecoff_data (abfd
)->sym_filepos
))
4526 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4528 if (info
->relocateable
)
4530 /* Now reset the reloc_count field of the sections in the output
4531 BFD to 0, so that we can use them to keep track of how many
4532 relocs we have output thus far. */
4533 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4537 /* Get a value for the GP register. */
4538 if (ecoff_data (abfd
)->gp
== 0)
4540 struct bfd_link_hash_entry
*h
;
4542 h
= bfd_link_hash_lookup (info
->hash
, "_gp", false, false, true);
4543 if (h
!= (struct bfd_link_hash_entry
*) NULL
4544 && h
->type
== bfd_link_hash_defined
)
4545 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4546 + h
->u
.def
.section
->output_section
->vma
4547 + h
->u
.def
.section
->output_offset
);
4548 else if (info
->relocateable
)
4552 /* Make up a value. */
4554 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4557 && (strcmp (o
->name
, _SBSS
) == 0
4558 || strcmp (o
->name
, _SDATA
) == 0
4559 || strcmp (o
->name
, _LIT4
) == 0
4560 || strcmp (o
->name
, _LIT8
) == 0
4561 || strcmp (o
->name
, _LITA
) == 0))
4564 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4568 /* If the relocate_section function needs to do a reloc
4569 involving the GP value, it should make a reloc_dangerous
4570 callback to warn that GP is not defined. */
4574 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4576 for (p
= o
->link_order_head
;
4577 p
!= (struct bfd_link_order
*) NULL
;
4580 if (p
->type
== bfd_indirect_link_order
4581 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4582 == bfd_target_ecoff_flavour
))
4584 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4587 else if (p
->type
== bfd_section_reloc_link_order
4588 || p
->type
== bfd_symbol_reloc_link_order
)
4590 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4595 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4601 bfd_get_symcount (abfd
) = symhdr
->iextMax
+ symhdr
->isymMax
;
4603 ecoff_data (abfd
)->linker
= true;
4608 /* Accumulate the debugging information for an input BFD into the
4609 output BFD. This must read in the symbolic information of the
4613 ecoff_final_link_debug_accumulate (output_bfd
, input_bfd
, info
, handle
)
4616 struct bfd_link_info
*info
;
4619 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
4620 const struct ecoff_debug_swap
* const swap
=
4621 &ecoff_backend (input_bfd
)->debug_swap
;
4622 HDRR
*symhdr
= &debug
->symbolic_header
;
4625 #define READ(ptr, offset, count, size, type) \
4626 if (symhdr->count == 0) \
4627 debug->ptr = NULL; \
4630 debug->ptr = (type) malloc (size * symhdr->count); \
4631 if (debug->ptr == NULL) \
4633 bfd_set_error (bfd_error_no_memory); \
4635 goto return_something; \
4637 if ((bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) \
4639 || (bfd_read (debug->ptr, size, symhdr->count, \
4640 input_bfd) != size * symhdr->count)) \
4643 goto return_something; \
4647 /* If raw_syments is not NULL, then the data was already by read by
4648 _bfd_ecoff_slurp_symbolic_info. */
4649 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
4651 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
4653 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
4654 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
4655 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
4656 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
4657 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
4659 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
4660 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
4661 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
4665 /* We do not read the external strings or the external symbols. */
4667 ret
= (bfd_ecoff_debug_accumulate
4668 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4669 &ecoff_backend (output_bfd
)->debug_swap
,
4670 input_bfd
, debug
, swap
, info
));
4673 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
4675 if (debug
->line
!= NULL
)
4677 if (debug
->external_dnr
!= NULL
)
4678 free (debug
->external_dnr
);
4679 if (debug
->external_pdr
!= NULL
)
4680 free (debug
->external_pdr
);
4681 if (debug
->external_sym
!= NULL
)
4682 free (debug
->external_sym
);
4683 if (debug
->external_opt
!= NULL
)
4684 free (debug
->external_opt
);
4685 if (debug
->external_aux
!= NULL
)
4686 free (debug
->external_aux
);
4687 if (debug
->ss
!= NULL
)
4689 if (debug
->external_fdr
!= NULL
)
4690 free (debug
->external_fdr
);
4691 if (debug
->external_rfd
!= NULL
)
4692 free (debug
->external_rfd
);
4694 /* Make sure we don't accidentally follow one of these pointers
4695 into freed memory. */
4697 debug
->external_dnr
= NULL
;
4698 debug
->external_pdr
= NULL
;
4699 debug
->external_sym
= NULL
;
4700 debug
->external_opt
= NULL
;
4701 debug
->external_aux
= NULL
;
4703 debug
->external_fdr
= NULL
;
4704 debug
->external_rfd
= NULL
;
4710 /* Put out information for an external symbol. These come only from
4714 ecoff_link_write_external (h
, data
)
4715 struct ecoff_link_hash_entry
*h
;
4718 bfd
*output_bfd
= (bfd
*) data
;
4720 /* FIXME: We should check if this symbol is being stripped. */
4725 if (h
->abfd
== (bfd
*) NULL
)
4728 h
->esym
.cobol_main
= 0;
4729 h
->esym
.weakext
= 0;
4730 h
->esym
.reserved
= 0;
4731 h
->esym
.ifd
= ifdNil
;
4732 h
->esym
.asym
.value
= 0;
4733 h
->esym
.asym
.st
= stGlobal
;
4735 if (h
->root
.type
!= bfd_link_hash_defined
)
4736 h
->esym
.asym
.sc
= scAbs
;
4739 asection
*output_section
;
4742 output_section
= h
->root
.u
.def
.section
->output_section
;
4743 name
= bfd_section_name (output_section
->owner
, output_section
);
4745 if (strcmp (name
, _TEXT
) == 0)
4746 h
->esym
.asym
.sc
= scText
;
4747 else if (strcmp (name
, _DATA
) == 0)
4748 h
->esym
.asym
.sc
= scData
;
4749 else if (strcmp (name
, _SDATA
) == 0)
4750 h
->esym
.asym
.sc
= scSData
;
4751 else if (strcmp (name
, _RDATA
) == 0)
4752 h
->esym
.asym
.sc
= scRData
;
4753 else if (strcmp (name
, _BSS
) == 0)
4754 h
->esym
.asym
.sc
= scBss
;
4755 else if (strcmp (name
, _SBSS
) == 0)
4756 h
->esym
.asym
.sc
= scSBss
;
4757 else if (strcmp (name
, _INIT
) == 0)
4758 h
->esym
.asym
.sc
= scInit
;
4759 else if (strcmp (name
, _FINI
) == 0)
4760 h
->esym
.asym
.sc
= scFini
;
4761 else if (strcmp (name
, _PDATA
) == 0)
4762 h
->esym
.asym
.sc
= scPData
;
4763 else if (strcmp (name
, _XDATA
) == 0)
4764 h
->esym
.asym
.sc
= scXData
;
4766 h
->esym
.asym
.sc
= scAbs
;
4769 h
->esym
.asym
.reserved
= 0;
4770 h
->esym
.asym
.index
= indexNil
;
4772 else if (h
->esym
.ifd
!= -1)
4774 struct ecoff_debug_info
*debug
;
4776 /* Adjust the FDR index for the symbol by that used for the
4778 debug
= &ecoff_data (h
->abfd
)->debug_info
;
4779 BFD_ASSERT (h
->esym
.ifd
>= 0
4780 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
4781 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
4784 switch (h
->root
.type
)
4787 case bfd_link_hash_new
:
4789 case bfd_link_hash_undefined
:
4790 case bfd_link_hash_weak
:
4791 if (h
->esym
.asym
.sc
!= scUndefined
4792 && h
->esym
.asym
.sc
!= scSUndefined
)
4793 h
->esym
.asym
.sc
= scUndefined
;
4795 case bfd_link_hash_defined
:
4796 if (h
->esym
.asym
.sc
== scUndefined
4797 || h
->esym
.asym
.sc
== scSUndefined
)
4798 h
->esym
.asym
.sc
= scAbs
;
4799 else if (h
->esym
.asym
.sc
== scCommon
)
4800 h
->esym
.asym
.sc
= scBss
;
4801 else if (h
->esym
.asym
.sc
== scSCommon
)
4802 h
->esym
.asym
.sc
= scSBss
;
4803 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
4804 + h
->root
.u
.def
.section
->output_section
->vma
4805 + h
->root
.u
.def
.section
->output_offset
);
4807 case bfd_link_hash_common
:
4808 if (h
->esym
.asym
.sc
!= scCommon
4809 && h
->esym
.asym
.sc
!= scSCommon
)
4810 h
->esym
.asym
.sc
= scCommon
;
4811 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
4813 case bfd_link_hash_indirect
:
4814 case bfd_link_hash_warning
:
4815 /* FIXME: Ignore these for now. The circumstances under which
4816 they should be written out are not clear to me. */
4820 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4822 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
4825 return (bfd_ecoff_debug_one_external
4826 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4827 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
4831 /* Relocate and write an ECOFF section into an ECOFF output file. */
4834 ecoff_indirect_link_order (output_bfd
, info
, output_section
, link_order
)
4836 struct bfd_link_info
*info
;
4837 asection
*output_section
;
4838 struct bfd_link_order
*link_order
;
4840 asection
*input_section
;
4842 struct ecoff_section_tdata
*section_tdata
;
4843 bfd_size_type raw_size
;
4844 bfd_size_type cooked_size
;
4845 bfd_byte
*contents
= NULL
;
4846 bfd_size_type external_reloc_size
;
4847 bfd_size_type external_relocs_size
;
4848 PTR external_relocs
= NULL
;
4850 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
4852 if (link_order
->size
== 0)
4855 input_section
= link_order
->u
.indirect
.section
;
4856 input_bfd
= input_section
->owner
;
4857 section_tdata
= ecoff_section_data (input_bfd
, input_section
);
4859 raw_size
= input_section
->_raw_size
;
4860 cooked_size
= input_section
->_cooked_size
;
4861 if (cooked_size
== 0)
4862 cooked_size
= raw_size
;
4864 BFD_ASSERT (input_section
->output_section
== output_section
);
4865 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
4866 BFD_ASSERT (cooked_size
== link_order
->size
);
4868 /* Get the section contents. We allocate memory for the larger of
4869 the size before relocating and the size after relocating. */
4870 contents
= (bfd_byte
*) malloc (raw_size
>= cooked_size
4873 if (contents
== NULL
&& raw_size
!= 0)
4875 bfd_set_error (bfd_error_no_memory
);
4879 /* If we are relaxing, the contents may have already been read into
4880 memory, in which case we copy them into our new buffer. We don't
4881 simply reuse the old buffer in case cooked_size > raw_size. */
4882 if (section_tdata
!= (struct ecoff_section_tdata
*) NULL
4883 && section_tdata
->contents
!= (bfd_byte
*) NULL
)
4884 memcpy (contents
, section_tdata
->contents
, raw_size
);
4887 if (! bfd_get_section_contents (input_bfd
, input_section
,
4889 (file_ptr
) 0, raw_size
))
4893 /* Get the relocs. If we are relaxing MIPS code, they will already
4894 have been read in. Otherwise, we read them in now. */
4895 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
4896 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
4898 if (section_tdata
!= (struct ecoff_section_tdata
*) NULL
)
4899 external_relocs
= section_tdata
->external_relocs
;
4902 external_relocs
= (PTR
) malloc (external_relocs_size
);
4903 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
4905 bfd_set_error (bfd_error_no_memory
);
4909 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
4910 || (bfd_read (external_relocs
, 1, external_relocs_size
, input_bfd
)
4911 != external_relocs_size
))
4915 /* Relocate the section contents. */
4916 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
4917 (output_bfd
, info
, input_bfd
, input_section
, contents
,
4921 /* Write out the relocated section. */
4922 if (! bfd_set_section_contents (output_bfd
,
4925 input_section
->output_offset
,
4929 /* If we are producing relocateable output, the relocs were
4930 modified, and we write them out now. We use the reloc_count
4931 field of output_section to keep track of the number of relocs we
4932 have output so far. */
4933 if (info
->relocateable
)
4935 if (bfd_seek (output_bfd
,
4936 (output_section
->rel_filepos
+
4937 output_section
->reloc_count
* external_reloc_size
),
4939 || (bfd_write (external_relocs
, 1, external_relocs_size
, output_bfd
)
4940 != external_relocs_size
))
4942 output_section
->reloc_count
+= input_section
->reloc_count
;
4945 if (contents
!= NULL
)
4947 if (external_relocs
!= NULL
&& section_tdata
== NULL
)
4948 free (external_relocs
);
4952 if (contents
!= NULL
)
4954 if (external_relocs
!= NULL
&& section_tdata
== NULL
)
4955 free (external_relocs
);
4959 /* Generate a reloc when linking an ECOFF file. This is a reloc
4960 requested by the linker, and does come from any input file. This
4961 is used to build constructor and destructor tables when linking
4965 ecoff_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
4967 struct bfd_link_info
*info
;
4968 asection
*output_section
;
4969 struct bfd_link_order
*link_order
;
4972 struct internal_reloc in
;
4973 bfd_size_type external_reloc_size
;
4977 /* We set up an arelent to pass to the backend adjust_reloc_out
4979 rel
.address
= link_order
->offset
;
4981 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
4982 if (rel
.howto
== (const reloc_howto_type
*) NULL
)
4984 bfd_set_error (bfd_error_bad_value
);
4988 if (link_order
->type
== bfd_section_reloc_link_order
)
4989 rel
.sym_ptr_ptr
= link_order
->u
.reloc
.p
->u
.section
->symbol_ptr_ptr
;
4992 /* We can't set up a reloc against a symbol correctly, because
4993 we have no asymbol structure. Currently no adjust_reloc_out
4995 rel
.sym_ptr_ptr
= (asymbol
**) NULL
;
4998 /* All ECOFF relocs are in-place. Put the addend into the object
5001 BFD_ASSERT (rel
.howto
->partial_inplace
);
5002 if (link_order
->u
.reloc
.p
->addend
!= 0)
5005 bfd_reloc_status_type rstat
;
5009 size
= bfd_get_reloc_size (rel
.howto
);
5010 buf
= (bfd_byte
*) bfd_zmalloc (size
);
5011 if (buf
== (bfd_byte
*) NULL
)
5013 bfd_set_error (bfd_error_no_memory
);
5016 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
5017 link_order
->u
.reloc
.p
->addend
, buf
);
5023 case bfd_reloc_outofrange
:
5025 case bfd_reloc_overflow
:
5026 if (! ((*info
->callbacks
->reloc_overflow
)
5028 (link_order
->type
== bfd_section_reloc_link_order
5029 ? bfd_section_name (output_bfd
,
5030 link_order
->u
.reloc
.p
->u
.section
)
5031 : link_order
->u
.reloc
.p
->u
.name
),
5032 rel
.howto
->name
, link_order
->u
.reloc
.p
->addend
,
5033 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
5040 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
5041 (file_ptr
) link_order
->offset
, size
);
5049 /* Move the information into a internal_reloc structure. */
5050 in
.r_vaddr
= (rel
.address
5051 + bfd_get_section_vma (output_bfd
, output_section
));
5052 in
.r_type
= rel
.howto
->type
;
5054 if (link_order
->type
== bfd_symbol_reloc_link_order
)
5056 struct ecoff_link_hash_entry
*h
;
5058 h
= ecoff_link_hash_lookup (ecoff_hash_table (info
),
5059 link_order
->u
.reloc
.p
->u
.name
,
5060 false, false, true);
5061 if (h
!= (struct ecoff_link_hash_entry
*) NULL
5063 in
.r_symndx
= h
->indx
;
5066 if (! ((*info
->callbacks
->unattached_reloc
)
5067 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
5068 (asection
*) NULL
, (bfd_vma
) 0)))
5078 name
= bfd_get_section_name (output_bfd
,
5079 link_order
->u
.reloc
.p
->u
.section
);
5080 if (strcmp (name
, ".text") == 0)
5081 in
.r_symndx
= RELOC_SECTION_TEXT
;
5082 else if (strcmp (name
, ".rdata") == 0)
5083 in
.r_symndx
= RELOC_SECTION_RDATA
;
5084 else if (strcmp (name
, ".data") == 0)
5085 in
.r_symndx
= RELOC_SECTION_DATA
;
5086 else if (strcmp (name
, ".sdata") == 0)
5087 in
.r_symndx
= RELOC_SECTION_SDATA
;
5088 else if (strcmp (name
, ".sbss") == 0)
5089 in
.r_symndx
= RELOC_SECTION_SBSS
;
5090 else if (strcmp (name
, ".bss") == 0)
5091 in
.r_symndx
= RELOC_SECTION_BSS
;
5092 else if (strcmp (name
, ".init") == 0)
5093 in
.r_symndx
= RELOC_SECTION_INIT
;
5094 else if (strcmp (name
, ".lit8") == 0)
5095 in
.r_symndx
= RELOC_SECTION_LIT8
;
5096 else if (strcmp (name
, ".lit4") == 0)
5097 in
.r_symndx
= RELOC_SECTION_LIT4
;
5098 else if (strcmp (name
, ".xdata") == 0)
5099 in
.r_symndx
= RELOC_SECTION_XDATA
;
5100 else if (strcmp (name
, ".pdata") == 0)
5101 in
.r_symndx
= RELOC_SECTION_PDATA
;
5102 else if (strcmp (name
, ".fini") == 0)
5103 in
.r_symndx
= RELOC_SECTION_FINI
;
5104 else if (strcmp (name
, ".lita") == 0)
5105 in
.r_symndx
= RELOC_SECTION_LITA
;
5106 else if (strcmp (name
, "*ABS*") == 0)
5107 in
.r_symndx
= RELOC_SECTION_ABS
;
5113 /* Let the BFD backend adjust the reloc. */
5114 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
5116 /* Get some memory and swap out the reloc. */
5117 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
5118 rbuf
= (bfd_byte
*) malloc (external_reloc_size
);
5119 if (rbuf
== (bfd_byte
*) NULL
)
5121 bfd_set_error (bfd_error_no_memory
);
5125 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (PTR
) rbuf
);
5127 ok
= (bfd_seek (output_bfd
,
5128 (output_section
->rel_filepos
+
5129 output_section
->reloc_count
* external_reloc_size
),
5131 && (bfd_write ((PTR
) rbuf
, 1, external_reloc_size
, output_bfd
)
5132 == external_reloc_size
));
5135 ++output_section
->reloc_count
;