1 /* Generic ECOFF (Extended-COFF) routines.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995 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
;
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
;
2007 cmp_fdrtab_entry (const void *leftp
, const void *rightp
)
2009 const struct ecoff_fdrtab_entry
*lp
= leftp
;
2010 const struct ecoff_fdrtab_entry
*rp
= rightp
;
2012 if (lp
->base_addr
< rp
->base_addr
)
2014 if (lp
->base_addr
> rp
->base_addr
)
2020 * Each file descriptor (FDR) has a memory address, to simplify
2021 * looking up an FDR by address, we build a table covering all FDRs
2022 * that have a least one procedure descriptor in them. The final
2023 * table will be sorted by address so we can look it up via binary
2027 mk_fdrtab (bfd
*abfd
)
2029 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
2030 const struct ecoff_debug_swap
* const debug_swap
2031 = &ecoff_backend (abfd
)->debug_swap
;
2032 struct ecoff_fdrtab_entry
*tab
;
2039 /* Make sure we have the FDR's. */
2040 if (! _bfd_ecoff_slurp_symbolic_info (abfd
, (asection
*) NULL
, debug_info
)
2041 || bfd_get_symcount (abfd
) == 0)
2044 fdr_start
= debug_info
->fdr
;
2045 fdr_end
= fdr_start
+ debug_info
->symbolic_header
.ifdMax
;
2047 /* First, let's see how long the table needs to be: */
2048 for (len
= 0, fdr_ptr
= fdr_start
; fdr_ptr
< fdr_end
; fdr_ptr
++)
2050 if (fdr_ptr
->cpd
== 0) /* skip FDRs that have no PDRs */
2055 /* Now, create and fill in the table: */
2057 ecoff_data (abfd
)->fdrtab
= (struct ecoff_fdrtab_entry
*)
2058 bfd_zalloc (abfd
,len
* sizeof (struct ecoff_fdrtab_entry
));
2059 if (ecoff_data (abfd
)->fdrtab
== NULL
)
2061 bfd_set_error (bfd_error_no_memory
);
2064 ecoff_data (abfd
)->fdrtab_len
= len
;
2066 tab
= ecoff_data (abfd
)->fdrtab
;
2067 for (fdr_ptr
= fdr_start
; fdr_ptr
< fdr_end
; fdr_ptr
++)
2069 if (fdr_ptr
->cpd
== 0)
2073 * Check whether this file has stabs debugging information. In
2074 * a file with stabs debugging information, the second local
2075 * symbol is named @stabs.
2078 if (fdr_ptr
->csym
>= 2)
2083 sym_ptr
= ((char *) debug_info
->external_sym
2084 + (fdr_ptr
->isymBase
+ 1)*debug_swap
->external_sym_size
);
2085 (*debug_swap
->swap_sym_in
) (abfd
, sym_ptr
, &sym
);
2086 if (strcmp (debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
,
2093 bfd_size_type external_pdr_size
;
2097 external_pdr_size
= debug_swap
->external_pdr_size
;
2099 pdr_ptr
= ((char *) debug_info
->external_pdr
2100 + fdr_ptr
->ipdFirst
* external_pdr_size
);
2101 (*debug_swap
->swap_pdr_in
) (abfd
, (PTR
) pdr_ptr
, &pdr
);
2103 * The address of the first PDR is the offset of that
2104 * procedure relative to the beginning of file FDR.
2106 tab
->base_addr
= fdr_ptr
->adr
- pdr
.adr
;
2111 * XXX I don't know about stabs, so this is a guess
2112 * (davidm@cs.arizona.edu):
2114 tab
->base_addr
= fdr_ptr
->adr
;
2120 * Finally, the table is sorted in increasing memory-address order.
2121 * The table is mostly sorted already, but there are cases (e.g.,
2122 * static functions in include files), where this does not hold
2123 * Use "odump -PFv" to verify...
2125 qsort((char*) ecoff_data (abfd
)->fdrtab
, len
,
2126 sizeof(struct ecoff_fdrtab_entry
), cmp_fdrtab_entry
);
2132 * Return index of first FDR that covers to OFFSET.
2135 lookup (bfd
*abfd
, bfd_vma offset
)
2137 long low
, high
, len
;
2139 struct ecoff_fdrtab_entry
*tab
;
2141 len
= ecoff_data(abfd
)->fdrtab_len
;
2145 tab
= ecoff_data(abfd
)->fdrtab
;
2146 for (low
= 0, high
= len
- 1 ; low
!= high
;)
2148 mid
= (high
+ low
) / 2;
2149 if (offset
>= tab
[mid
].base_addr
&& offset
< tab
[mid
+ 1].base_addr
)
2152 if (tab
[mid
].base_addr
> offset
)
2159 /* last entry is catch-all for all higher addresses: */
2160 if (offset
< tab
[mid
].base_addr
)
2165 while (mid
> 0 && tab
[mid
- 1].base_addr
== tab
[mid
].base_addr
)
2171 /* Provided a BFD, a section and an offset into the section, calculate
2172 and return the name of the source file and the line nearest to the
2177 _bfd_ecoff_find_nearest_line (abfd
, section
, ignore_symbols
, offset
,
2178 filename_ptr
, functionname_ptr
, retline_ptr
)
2181 asymbol
**ignore_symbols
;
2183 CONST
char **filename_ptr
;
2184 CONST
char **functionname_ptr
;
2185 unsigned int *retline_ptr
;
2187 const struct ecoff_debug_swap
* const debug_swap
2188 = &ecoff_backend (abfd
)->debug_swap
;
2189 struct ecoff_debug_info
* const debug_info
= &ecoff_data (abfd
)->debug_info
;
2190 struct ecoff_fdrtab_entry
*tab
;
2195 offset
+= section
->vma
;
2197 * If we're not in the .text section, we don't have any line
2200 if (strcmp (section
->name
, _TEXT
) != 0
2201 || offset
< ecoff_data (abfd
)->text_start
2202 || offset
>= ecoff_data (abfd
)->text_end
)
2205 * Build FDR table (sorted by object file's base-address) if
2206 * we don't have it already:
2208 if (!ecoff_data (abfd
)->fdrtab
&& !mk_fdrtab (abfd
)) {
2211 tab
= ecoff_data (abfd
)->fdrtab
;
2213 i
= lookup(abfd
, offset
); /* find first FDR for address OFFSET */
2215 return false; /* no FDR, no fun... */
2216 fdr_ptr
= tab
[i
].fdr
;
2219 * Check whether this file has stabs debugging information. In a
2220 * file with stabs debugging information, the second local symbol is
2224 if (fdr_ptr
->csym
>= 2)
2229 sym_ptr
= ((char *) debug_info
->external_sym
2230 + (fdr_ptr
->isymBase
+ 1) * debug_swap
->external_sym_size
);
2231 (*debug_swap
->swap_sym_in
) (abfd
, sym_ptr
, &sym
);
2232 if (strcmp (debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
,
2239 bfd_size_type external_pdr_size
;
2241 char *best_pdr
= NULL
;
2243 bfd_vma best_dist
= ~0;
2245 unsigned char *line_ptr
;
2246 unsigned char *line_end
;
2249 * This file uses ECOFF debugging information. Each FDR has a
2250 * list of procedure descriptors (PDR). The address in the FDR
2251 * is the absolute address of the first procedure. The address
2252 * in the first PDR gives the offset of that procedure relative
2253 * to the object file's base-address. The addresses in
2254 * subsequent PDRs specify each procedure's address relative to
2255 * the object file's base-address. To make things more juicy,
2256 * whenever the PROF bit in the PDR is set, the real entry point
2257 * of the procedure may be 16 bytes below what would normally be
2258 * the procedure's entry point. Instead, DEC came up with a
2259 * wicked scheme to create profiled libraries "on the fly":
2260 * instead of shipping a regular and a profiled version of each
2261 * library, they insert 16 bytes of unused space in front of
2262 * each procedure and set the "prof" bit in the PDR to indicate
2263 * that there is a gap there (this is done automagically by "as"
2264 * when option "-pg" is specified). Thus, normally, you link
2265 * against such a library and, except for lots of 16 byte gaps
2266 * between functions, things will behave as usual. However,
2267 * when invoking "ld" with option "-pg", it will fill those gaps
2268 * with code that calls mcount(). It then moves the function's
2269 * entry point down by 16 bytes, and out pops a binary that has
2270 * all functions profiled.
2272 * NOTE: Neither FDRs nor PDRs are strictly sorted in memory order.
2273 * For example, when including header-files that define
2274 * functions, the FDRs follow behind the including file,
2275 * even though their code may have been generated at a lower
2276 * address. File coff-alpha.c from libbfd illustrates this
2277 * (use "odump -PFv" to look at a file's FDR/PDR). Similarly,
2278 * PDRs are sometimes out of order as well. An example of this
2279 * is OSF/1 v3.0 libc's malloc.c. I'm not sure why this happens,
2280 * but it could be due to optimizations that reorder a function's
2281 * position within an object-file.
2285 * On the first call to this function, we build a table of FDRs
2286 * that is sorted by the base-address of the object-file the FDR
2287 * is referring to. Notice that each object-file may contain
2288 * code from multiple source files (e.g., due to code defined in
2289 * include files). Thus, for any given base-address, there may
2290 * be multiple FDRs (but this case is, fortunately, uncommon).
2291 * lookup(addr) guarantees to return the first FDR that applies
2292 * to address ADDR. Thus, after invoking lookup(), we have a
2293 * list of FDRs that may contain the PDR for ADDR. Next, we walk
2294 * through the PDRs of these FDRs and locate the one that is
2295 * closest to ADDR (i.e., for which the difference between ADDR
2296 * and the PDR's entry point is positive and minimal). Once,
2297 * the right FDR and PDR are located, we simply walk through the
2298 * line-number table to lookup the line-number that best matches
2299 * ADDR. Obviously, things could be sped up by keeping a sorted
2300 * list of PDRs instead of a sorted list of FDRs. However, this
2301 * would increase space requirements considerably, which is
2304 external_pdr_size
= debug_swap
->external_pdr_size
;
2306 /* Make offset relative to object file's start-address: */
2307 offset
-= tab
[i
].base_addr
;
2309 * Search FDR list starting at tab[i] for the PDR that best matches
2310 * OFFSET. Normally, the FDR list is only one entry long.
2314 bfd_vma dist
, min_dist
= 0;
2318 fdr_ptr
= tab
[i
].fdr
;
2320 pdr_ptr
= ((char *) debug_info
->external_pdr
2321 + fdr_ptr
->ipdFirst
* external_pdr_size
);
2322 pdr_end
= pdr_ptr
+ fdr_ptr
->cpd
* external_pdr_size
;
2323 (*debug_swap
->swap_pdr_in
) (abfd
, (PTR
) pdr_ptr
, &pdr
);
2325 * Find PDR that is closest to OFFSET. If pdr.prof is set,
2326 * the procedure entry-point *may* be 0x10 below pdr.adr.
2327 * We simply pretend that pdr.prof *implies* a lower entry-point.
2328 * This is safe because it just means that may identify
2329 * 4 NOPs in front of the function as belonging to the function.
2331 for (pdr_hold
= NULL
;
2333 (pdr_ptr
+= external_pdr_size
,
2334 (*debug_swap
->swap_pdr_in
) (abfd
, (PTR
) pdr_ptr
, &pdr
)))
2336 if (offset
>= (pdr
.adr
- 0x10 * pdr
.prof
))
2338 dist
= offset
- (pdr
.adr
- 0x10 * pdr
.prof
);
2339 if (!pdr_hold
|| dist
< min_dist
)
2347 if (!best_pdr
|| min_dist
< best_dist
)
2349 best_dist
= min_dist
;
2351 best_pdr
= pdr_hold
;
2353 /* continue looping until base_addr of next entry is different: */
2354 } while (++i
< ecoff_data (abfd
)->fdrtab_len
2355 && tab
[i
].base_addr
== tab
[i
- 1].base_addr
);
2357 if (!best_fdr
|| !best_pdr
)
2358 return false; /* shouldn't happen... */
2360 /* phew, finally we got something that we can hold onto: */
2363 (*debug_swap
->swap_pdr_in
) (abfd
, (PTR
) pdr_ptr
, &pdr
);
2365 * Now we can look for the actual line number. The line numbers
2366 * are stored in a very funky format, which I won't try to
2367 * describe. The search is bounded by the end of the FDRs line
2370 line_end
= debug_info
->line
+ fdr_ptr
->cbLineOffset
+ fdr_ptr
->cbLine
;
2372 /* Make offset relative to procedure entry: */
2373 offset
-= pdr
.adr
- 0x10 * pdr
.prof
;
2375 line_ptr
= debug_info
->line
+ fdr_ptr
->cbLineOffset
+ pdr
.cbLineOffset
;
2376 while (line_ptr
< line_end
)
2381 delta
= *line_ptr
>> 4;
2384 count
= (*line_ptr
& 0xf) + 1;
2388 delta
= (((line_ptr
[0]) & 0xff) << 8) + ((line_ptr
[1]) & 0xff);
2389 if (delta
>= 0x8000)
2394 if (offset
< count
* 4)
2396 offset
-= count
* 4;
2400 * If fdr_ptr->rss is -1, then this file does not have full
2401 * symbols, at least according to gdb/mipsread.c.
2403 if (fdr_ptr
->rss
== -1)
2405 *filename_ptr
= NULL
;
2407 *functionname_ptr
= NULL
;
2412 (*debug_swap
->swap_ext_in
)
2414 ((char *) debug_info
->external_ext
2415 + pdr
.isym
* debug_swap
->external_ext_size
),
2417 *functionname_ptr
= debug_info
->ssext
+ proc_ext
.asym
.iss
;
2424 *filename_ptr
= debug_info
->ss
+ fdr_ptr
->issBase
+ fdr_ptr
->rss
;
2425 (*debug_swap
->swap_sym_in
)
2427 ((char *) debug_info
->external_sym
2428 + (fdr_ptr
->isymBase
+ pdr
.isym
) * debug_swap
->external_sym_size
),
2430 *functionname_ptr
= debug_info
->ss
+ fdr_ptr
->issBase
+ proc_sym
.iss
;
2432 if (lineno
== ilineNil
)
2434 *retline_ptr
= lineno
;
2438 bfd_size_type external_sym_size
;
2439 const char *directory_name
;
2440 const char *main_file_name
;
2441 const char *current_file_name
;
2442 const char *function_name
;
2443 const char *line_file_name
;
2444 bfd_vma low_func_vma
;
2445 bfd_vma low_line_vma
;
2446 char *sym_ptr
, *sym_ptr_end
;
2447 size_t len
, funclen
;
2448 char *buffer
= NULL
;
2450 /* This file uses stabs debugging information. */
2452 *filename_ptr
= NULL
;
2453 *functionname_ptr
= NULL
;
2456 directory_name
= NULL
;
2457 main_file_name
= NULL
;
2458 current_file_name
= NULL
;
2459 function_name
= NULL
;
2460 line_file_name
= NULL
;
2464 external_sym_size
= debug_swap
->external_sym_size
;
2466 sym_ptr
= ((char *) debug_info
->external_sym
2467 + (fdr_ptr
->isymBase
+ 2) * external_sym_size
);
2468 sym_ptr_end
= sym_ptr
+ fdr_ptr
->csym
* external_sym_size
;
2469 for (; sym_ptr
< sym_ptr_end
; sym_ptr
+= external_sym_size
)
2473 (*debug_swap
->swap_sym_in
) (abfd
, sym_ptr
, &sym
);
2475 if (ECOFF_IS_STAB (&sym
))
2477 switch (ECOFF_UNMARK_STAB (sym
.index
))
2480 main_file_name
= current_file_name
=
2481 debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
;
2483 /* Check the next symbol to see if it is also an
2485 if (sym_ptr
+ external_sym_size
< sym_ptr_end
)
2489 (*debug_swap
->swap_sym_in
) (abfd
,
2490 sym_ptr
+ external_sym_size
,
2492 if (ECOFF_IS_STAB (&nextsym
)
2493 && ECOFF_UNMARK_STAB (nextsym
.index
) == N_SO
)
2495 directory_name
= current_file_name
;
2496 main_file_name
= current_file_name
=
2497 debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
;
2498 sym_ptr
+= external_sym_size
;
2505 debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
;
2509 if (sym
.value
>= low_func_vma
2510 && sym
.value
<= offset
+ section
->vma
)
2512 low_func_vma
= sym
.value
;
2514 debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
;
2519 else if (sym
.st
== stLabel
&& sym
.index
!= indexNil
)
2521 if (sym
.value
> offset
+ section
->vma
)
2523 /* We have passed the location in the file we are
2524 looking for, so we can get out of the loop. */
2528 if (sym
.value
>= low_line_vma
)
2530 low_line_vma
= sym
.value
;
2531 line_file_name
= current_file_name
;
2532 *retline_ptr
= sym
.index
;
2537 if (*retline_ptr
!= 0)
2538 main_file_name
= line_file_name
;
2540 /* We need to remove the stuff after the colon in the function
2541 name. We also need to put the directory name and the file
2543 if (function_name
== NULL
)
2546 len
= funclen
= strlen (function_name
) + 1;
2548 if (main_file_name
!= NULL
2549 && directory_name
!= NULL
2550 && main_file_name
[0] != '/')
2551 len
+= strlen (directory_name
) + strlen (main_file_name
) + 1;
2555 if (ecoff_data (abfd
)->find_buffer
!= NULL
)
2556 free (ecoff_data (abfd
)->find_buffer
);
2557 buffer
= (char *) malloc (len
);
2560 bfd_set_error (bfd_error_no_memory
);
2563 ecoff_data (abfd
)->find_buffer
= buffer
;
2566 if (function_name
!= NULL
)
2570 strcpy (buffer
, function_name
);
2571 colon
= strchr (buffer
, ':');
2574 *functionname_ptr
= buffer
;
2577 if (main_file_name
!= NULL
)
2579 if (directory_name
== NULL
|| main_file_name
[0] == '/')
2580 *filename_ptr
= main_file_name
;
2583 sprintf (buffer
+ funclen
, "%s%s", directory_name
,
2585 *filename_ptr
= buffer
+ funclen
;
2594 /* Copy private BFD data. This is called by objcopy and strip. We
2595 use it to copy the ECOFF debugging information from one BFD to the
2596 other. It would be theoretically possible to represent the ECOFF
2597 debugging information in the symbol table. However, it would be a
2598 lot of work, and there would be little gain (gas, gdb, and ld
2599 already access the ECOFF debugging information via the
2600 ecoff_debug_info structure, and that structure would have to be
2601 retained in order to support ECOFF debugging in MIPS ELF).
2603 The debugging information for the ECOFF external symbols comes from
2604 the symbol table, so this function only handles the other debugging
2608 _bfd_ecoff_bfd_copy_private_bfd_data (ibfd
, obfd
)
2612 struct ecoff_debug_info
*iinfo
= &ecoff_data (ibfd
)->debug_info
;
2613 struct ecoff_debug_info
*oinfo
= &ecoff_data (obfd
)->debug_info
;
2615 asymbol
**sym_ptr_ptr
;
2619 /* This function is selected based on the input vector. We only
2620 want to copy information over if the output BFD also uses ECOFF
2622 if (bfd_get_flavour (obfd
) != bfd_target_ecoff_flavour
)
2625 /* Copy the GP value and the register masks. */
2626 ecoff_data (obfd
)->gp
= ecoff_data (ibfd
)->gp
;
2627 ecoff_data (obfd
)->gprmask
= ecoff_data (ibfd
)->gprmask
;
2628 ecoff_data (obfd
)->fprmask
= ecoff_data (ibfd
)->fprmask
;
2629 for (i
= 0; i
< 3; i
++)
2630 ecoff_data (obfd
)->cprmask
[i
] = ecoff_data (ibfd
)->cprmask
[i
];
2632 /* Copy the version stamp. */
2633 oinfo
->symbolic_header
.vstamp
= iinfo
->symbolic_header
.vstamp
;
2635 /* If there are no symbols, don't copy any debugging information. */
2636 c
= bfd_get_symcount (obfd
);
2637 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
2638 if (c
== 0 || sym_ptr_ptr
== (asymbol
**) NULL
)
2641 /* See if there are any local symbols. */
2643 for (; c
> 0; c
--, sym_ptr_ptr
++)
2645 if (ecoffsymbol (*sym_ptr_ptr
)->local
)
2654 /* There are some local symbols. We just bring over all the
2655 debugging information. FIXME: This is not quite the right
2656 thing to do. If the user has asked us to discard all
2657 debugging information, then we are probably going to wind up
2658 keeping it because there will probably be some local symbol
2659 which objcopy did not discard. We should actually break
2660 apart the debugging information and only keep that which
2661 applies to the symbols we want to keep. */
2662 oinfo
->symbolic_header
.ilineMax
= iinfo
->symbolic_header
.ilineMax
;
2663 oinfo
->symbolic_header
.cbLine
= iinfo
->symbolic_header
.cbLine
;
2664 oinfo
->line
= iinfo
->line
;
2666 oinfo
->symbolic_header
.idnMax
= iinfo
->symbolic_header
.idnMax
;
2667 oinfo
->external_dnr
= iinfo
->external_dnr
;
2669 oinfo
->symbolic_header
.ipdMax
= iinfo
->symbolic_header
.ipdMax
;
2670 oinfo
->external_pdr
= iinfo
->external_pdr
;
2672 oinfo
->symbolic_header
.isymMax
= iinfo
->symbolic_header
.isymMax
;
2673 oinfo
->external_sym
= iinfo
->external_sym
;
2675 oinfo
->symbolic_header
.ioptMax
= iinfo
->symbolic_header
.ioptMax
;
2676 oinfo
->external_opt
= iinfo
->external_opt
;
2678 oinfo
->symbolic_header
.iauxMax
= iinfo
->symbolic_header
.iauxMax
;
2679 oinfo
->external_aux
= iinfo
->external_aux
;
2681 oinfo
->symbolic_header
.issMax
= iinfo
->symbolic_header
.issMax
;
2682 oinfo
->ss
= iinfo
->ss
;
2684 oinfo
->symbolic_header
.ifdMax
= iinfo
->symbolic_header
.ifdMax
;
2685 oinfo
->external_fdr
= iinfo
->external_fdr
;
2687 oinfo
->symbolic_header
.crfd
= iinfo
->symbolic_header
.crfd
;
2688 oinfo
->external_rfd
= iinfo
->external_rfd
;
2692 /* We are discarding all the local symbol information. Look
2693 through the external symbols and remove all references to FDR
2694 or aux information. */
2695 c
= bfd_get_symcount (obfd
);
2696 sym_ptr_ptr
= bfd_get_outsymbols (obfd
);
2697 for (; c
> 0; c
--, sym_ptr_ptr
++)
2701 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_in
))
2702 (obfd
, ecoffsymbol (*sym_ptr_ptr
)->native
, &esym
);
2704 esym
.asym
.index
= indexNil
;
2705 (*(ecoff_backend (obfd
)->debug_swap
.swap_ext_out
))
2706 (obfd
, &esym
, ecoffsymbol (*sym_ptr_ptr
)->native
);
2713 /* Set the architecture. The supported architecture is stored in the
2714 backend pointer. We always set the architecture anyhow, since many
2715 callers ignore the return value. */
2718 _bfd_ecoff_set_arch_mach (abfd
, arch
, machine
)
2720 enum bfd_architecture arch
;
2721 unsigned long machine
;
2723 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2724 return arch
== ecoff_backend (abfd
)->arch
;
2727 /* Get the size of the section headers. */
2731 _bfd_ecoff_sizeof_headers (abfd
, reloc
)
2740 for (current
= abfd
->sections
;
2741 current
!= (asection
*)NULL
;
2742 current
= current
->next
)
2745 ret
= (bfd_coff_filhsz (abfd
)
2746 + bfd_coff_aoutsz (abfd
)
2747 + c
* bfd_coff_scnhsz (abfd
));
2748 return BFD_ALIGN (ret
, 16);
2751 /* Get the contents of a section. */
2754 _bfd_ecoff_get_section_contents (abfd
, section
, location
, offset
, count
)
2759 bfd_size_type count
;
2761 return _bfd_generic_get_section_contents (abfd
, section
, location
,
2765 /* Calculate the file position for each section, and set
2769 ecoff_compute_section_file_positions (abfd
)
2777 sofar
= _bfd_ecoff_sizeof_headers (abfd
, false);
2780 for (current
= abfd
->sections
;
2781 current
!= (asection
*) NULL
;
2782 current
= current
->next
)
2784 unsigned int alignment_power
;
2786 /* Only deal with sections which have contents */
2787 if ((current
->flags
& (SEC_HAS_CONTENTS
| SEC_LOAD
)) == 0)
2790 /* For the Alpha ECOFF .pdata section the lnnoptr field is
2791 supposed to indicate the number of .pdata entries that are
2792 really in the section. Each entry is 8 bytes. We store this
2793 away in line_filepos before increasing the section size. */
2794 if (strcmp (current
->name
, _PDATA
) != 0)
2795 alignment_power
= current
->alignment_power
;
2798 current
->line_filepos
= current
->_raw_size
/ 8;
2799 alignment_power
= 4;
2802 /* On Ultrix, the data sections in an executable file must be
2803 aligned to a page boundary within the file. This does not
2804 affect the section size, though. FIXME: Does this work for
2805 other platforms? It requires some modification for the
2806 Alpha, because .rdata on the Alpha goes with the text, not
2808 if ((abfd
->flags
& EXEC_P
) != 0
2809 && (abfd
->flags
& D_PAGED
) != 0
2810 && first_data
!= false
2811 && (current
->flags
& SEC_CODE
) == 0
2812 && (! ecoff_backend (abfd
)->rdata_in_text
2813 || strcmp (current
->name
, _RDATA
) != 0)
2814 && strcmp (current
->name
, _PDATA
) != 0)
2816 const bfd_vma round
= ecoff_backend (abfd
)->round
;
2818 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2821 else if (strcmp (current
->name
, _LIB
) == 0)
2823 const bfd_vma round
= ecoff_backend (abfd
)->round
;
2824 /* On Irix 4, the location of contents of the .lib section
2825 from a shared library section is also rounded up to a
2828 sofar
= (sofar
+ round
- 1) &~ (round
- 1);
2831 /* Align the sections in the file to the same boundary on
2832 which they are aligned in virtual memory. */
2834 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2836 current
->filepos
= sofar
;
2838 sofar
+= current
->_raw_size
;
2840 /* make sure that this section is of the right size too */
2842 sofar
= BFD_ALIGN (sofar
, 1 << alignment_power
);
2843 current
->_raw_size
+= sofar
- old_sofar
;
2846 ecoff_data (abfd
)->reloc_filepos
= sofar
;
2849 /* Determine the location of the relocs for all the sections in the
2850 output file, as well as the location of the symbolic debugging
2853 static bfd_size_type
2854 ecoff_compute_reloc_file_positions (abfd
)
2857 const bfd_size_type external_reloc_size
=
2858 ecoff_backend (abfd
)->external_reloc_size
;
2859 file_ptr reloc_base
;
2860 bfd_size_type reloc_size
;
2864 if (! abfd
->output_has_begun
)
2866 ecoff_compute_section_file_positions (abfd
);
2867 abfd
->output_has_begun
= true;
2870 reloc_base
= ecoff_data (abfd
)->reloc_filepos
;
2873 for (current
= abfd
->sections
;
2874 current
!= (asection
*)NULL
;
2875 current
= current
->next
)
2877 if (current
->reloc_count
== 0)
2878 current
->rel_filepos
= 0;
2881 bfd_size_type relsize
;
2883 current
->rel_filepos
= reloc_base
;
2884 relsize
= current
->reloc_count
* external_reloc_size
;
2885 reloc_size
+= relsize
;
2886 reloc_base
+= relsize
;
2890 sym_base
= ecoff_data (abfd
)->reloc_filepos
+ reloc_size
;
2892 /* At least on Ultrix, the symbol table of an executable file must
2893 be aligned to a page boundary. FIXME: Is this true on other
2895 if ((abfd
->flags
& EXEC_P
) != 0
2896 && (abfd
->flags
& D_PAGED
) != 0)
2897 sym_base
= ((sym_base
+ ecoff_backend (abfd
)->round
- 1)
2898 &~ (ecoff_backend (abfd
)->round
- 1));
2900 ecoff_data (abfd
)->sym_filepos
= sym_base
;
2905 /* Set the contents of a section. */
2908 _bfd_ecoff_set_section_contents (abfd
, section
, location
, offset
, count
)
2913 bfd_size_type count
;
2915 /* This must be done first, because bfd_set_section_contents is
2916 going to set output_has_begun to true. */
2917 if (abfd
->output_has_begun
== false)
2918 ecoff_compute_section_file_positions (abfd
);
2920 /* If this is a .lib section, bump the vma address so that it winds
2921 up being the number of .lib sections output. This is right for
2922 Irix 4. Ian Taylor <ian@cygnus.com>. */
2923 if (strcmp (section
->name
, _LIB
) == 0)
2929 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0
2930 || bfd_write (location
, 1, count
, abfd
) != count
)
2936 /* Get the GP value for an ECOFF file. This is a hook used by
2940 bfd_ecoff_get_gp_value (abfd
)
2943 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2944 || bfd_get_format (abfd
) != bfd_object
)
2946 bfd_set_error (bfd_error_invalid_operation
);
2950 return ecoff_data (abfd
)->gp
;
2953 /* Set the GP value for an ECOFF file. This is a hook used by the
2957 bfd_ecoff_set_gp_value (abfd
, gp_value
)
2961 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2962 || bfd_get_format (abfd
) != bfd_object
)
2964 bfd_set_error (bfd_error_invalid_operation
);
2968 ecoff_data (abfd
)->gp
= gp_value
;
2973 /* Set the register masks for an ECOFF file. This is a hook used by
2977 bfd_ecoff_set_regmasks (abfd
, gprmask
, fprmask
, cprmask
)
2979 unsigned long gprmask
;
2980 unsigned long fprmask
;
2981 unsigned long *cprmask
;
2983 ecoff_data_type
*tdata
;
2985 if (bfd_get_flavour (abfd
) != bfd_target_ecoff_flavour
2986 || bfd_get_format (abfd
) != bfd_object
)
2988 bfd_set_error (bfd_error_invalid_operation
);
2992 tdata
= ecoff_data (abfd
);
2993 tdata
->gprmask
= gprmask
;
2994 tdata
->fprmask
= fprmask
;
2995 if (cprmask
!= (unsigned long *) NULL
)
2999 for (i
= 0; i
< 3; i
++)
3000 tdata
->cprmask
[i
] = cprmask
[i
];
3006 /* Get ECOFF EXTR information for an external symbol. This function
3007 is passed to bfd_ecoff_debug_externals. */
3010 ecoff_get_extr (sym
, esym
)
3014 ecoff_symbol_type
*ecoff_sym_ptr
;
3017 if (bfd_asymbol_flavour (sym
) != bfd_target_ecoff_flavour
3018 || ecoffsymbol (sym
)->native
== NULL
)
3020 /* Don't include debugging, local, or section symbols. */
3021 if ((sym
->flags
& BSF_DEBUGGING
) != 0
3022 || (sym
->flags
& BSF_LOCAL
) != 0
3023 || (sym
->flags
& BSF_SECTION_SYM
) != 0)
3027 esym
->cobol_main
= 0;
3031 /* FIXME: we can do better than this for st and sc. */
3032 esym
->asym
.st
= stGlobal
;
3033 esym
->asym
.sc
= scAbs
;
3034 esym
->asym
.reserved
= 0;
3035 esym
->asym
.index
= indexNil
;
3039 ecoff_sym_ptr
= ecoffsymbol (sym
);
3041 if (ecoff_sym_ptr
->local
)
3044 input_bfd
= bfd_asymbol_bfd (sym
);
3045 (*(ecoff_backend (input_bfd
)->debug_swap
.swap_ext_in
))
3046 (input_bfd
, ecoff_sym_ptr
->native
, esym
);
3048 /* If the symbol was defined by the linker, then esym will be
3049 undefined but sym will not be. Get a better class for such a
3051 if ((esym
->asym
.sc
== scUndefined
3052 || esym
->asym
.sc
== scSUndefined
)
3053 && ! bfd_is_und_section (bfd_get_section (sym
)))
3054 esym
->asym
.sc
= scAbs
;
3056 /* Adjust the FDR index for the symbol by that used for the input
3058 if (esym
->ifd
!= -1)
3060 struct ecoff_debug_info
*input_debug
;
3062 input_debug
= &ecoff_data (input_bfd
)->debug_info
;
3063 BFD_ASSERT (esym
->ifd
< input_debug
->symbolic_header
.ifdMax
);
3064 if (input_debug
->ifdmap
!= (RFDT
*) NULL
)
3065 esym
->ifd
= input_debug
->ifdmap
[esym
->ifd
];
3071 /* Set the external symbol index. This routine is passed to
3072 bfd_ecoff_debug_externals. */
3075 ecoff_set_index (sym
, indx
)
3079 ecoff_set_sym_index (sym
, indx
);
3082 /* Write out an ECOFF file. */
3085 _bfd_ecoff_write_object_contents (abfd
)
3088 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
3089 const bfd_vma round
= backend
->round
;
3090 const bfd_size_type filhsz
= bfd_coff_filhsz (abfd
);
3091 const bfd_size_type aoutsz
= bfd_coff_aoutsz (abfd
);
3092 const bfd_size_type scnhsz
= bfd_coff_scnhsz (abfd
);
3093 const bfd_size_type external_hdr_size
3094 = backend
->debug_swap
.external_hdr_size
;
3095 const bfd_size_type external_reloc_size
= backend
->external_reloc_size
;
3096 void (* const adjust_reloc_out
) PARAMS ((bfd
*,
3098 struct internal_reloc
*))
3099 = backend
->adjust_reloc_out
;
3100 void (* const swap_reloc_out
) PARAMS ((bfd
*,
3101 const struct internal_reloc
*,
3103 = backend
->swap_reloc_out
;
3104 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
3105 HDRR
* const symhdr
= &debug
->symbolic_header
;
3108 bfd_size_type reloc_size
;
3109 bfd_size_type text_size
;
3111 boolean set_text_start
;
3112 bfd_size_type data_size
;
3114 boolean set_data_start
;
3115 bfd_size_type bss_size
;
3117 PTR reloc_buff
= NULL
;
3118 struct internal_filehdr internal_f
;
3119 struct internal_aouthdr internal_a
;
3122 /* Determine where the sections and relocs will go in the output
3124 reloc_size
= ecoff_compute_reloc_file_positions (abfd
);
3127 for (current
= abfd
->sections
;
3128 current
!= (asection
*)NULL
;
3129 current
= current
->next
)
3131 current
->target_index
= count
;
3135 if ((abfd
->flags
& D_PAGED
) != 0)
3136 text_size
= _bfd_ecoff_sizeof_headers (abfd
, false);
3140 set_text_start
= false;
3143 set_data_start
= false;
3146 /* Write section headers to the file. */
3148 /* Allocate buff big enough to hold a section header,
3149 file header, or a.out header. */
3157 buff
= (PTR
) malloc (siz
);
3160 bfd_set_error (bfd_error_no_memory
);
3165 internal_f
.f_nscns
= 0;
3166 if (bfd_seek (abfd
, (file_ptr
) (filhsz
+ aoutsz
), SEEK_SET
) != 0)
3168 for (current
= abfd
->sections
;
3169 current
!= (asection
*) NULL
;
3170 current
= current
->next
)
3172 struct internal_scnhdr section
;
3175 ++internal_f
.f_nscns
;
3177 strncpy (section
.s_name
, current
->name
, sizeof section
.s_name
);
3179 /* This seems to be correct for Irix 4 shared libraries. */
3180 vma
= bfd_get_section_vma (abfd
, current
);
3181 if (strcmp (current
->name
, _LIB
) == 0)
3182 section
.s_vaddr
= 0;
3184 section
.s_vaddr
= vma
;
3186 section
.s_paddr
= vma
;
3187 section
.s_size
= bfd_get_section_size_before_reloc (current
);
3189 /* If this section is unloadable then the scnptr will be 0. */
3190 if ((current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3191 section
.s_scnptr
= 0;
3193 section
.s_scnptr
= current
->filepos
;
3194 section
.s_relptr
= current
->rel_filepos
;
3196 /* FIXME: the lnnoptr of the .sbss or .sdata section of an
3197 object file produced by the assembler is supposed to point to
3198 information about how much room is required by objects of
3199 various different sizes. I think this only matters if we
3200 want the linker to compute the best size to use, or
3201 something. I don't know what happens if the information is
3203 if (strcmp (current
->name
, _PDATA
) != 0)
3204 section
.s_lnnoptr
= 0;
3207 /* The Alpha ECOFF .pdata section uses the lnnoptr field to
3208 hold the number of entries in the section (each entry is
3209 8 bytes). We stored this in the line_filepos field in
3210 ecoff_compute_section_file_positions. */
3211 section
.s_lnnoptr
= current
->line_filepos
;
3214 section
.s_nreloc
= current
->reloc_count
;
3215 section
.s_nlnno
= 0;
3216 section
.s_flags
= ecoff_sec_to_styp_flags (current
->name
,
3219 bfd_coff_swap_scnhdr_out (abfd
, (PTR
) §ion
, buff
);
3220 if (bfd_write (buff
, 1, scnhsz
, abfd
) != scnhsz
)
3223 if ((section
.s_flags
& STYP_TEXT
) != 0
3224 || ((section
.s_flags
& STYP_RDATA
) != 0
3225 && backend
->rdata_in_text
)
3226 || strcmp (current
->name
, _PDATA
) == 0)
3228 text_size
+= bfd_get_section_size_before_reloc (current
);
3229 if (! set_text_start
|| text_start
> vma
)
3232 set_text_start
= true;
3235 else if ((section
.s_flags
& STYP_RDATA
) != 0
3236 || (section
.s_flags
& STYP_DATA
) != 0
3237 || (section
.s_flags
& STYP_LITA
) != 0
3238 || (section
.s_flags
& STYP_LIT8
) != 0
3239 || (section
.s_flags
& STYP_LIT4
) != 0
3240 || (section
.s_flags
& STYP_SDATA
) != 0
3241 || strcmp (current
->name
, _XDATA
) == 0)
3243 data_size
+= bfd_get_section_size_before_reloc (current
);
3244 if (! set_data_start
|| data_start
> vma
)
3247 set_data_start
= true;
3250 else if ((section
.s_flags
& STYP_BSS
) != 0
3251 || (section
.s_flags
& STYP_SBSS
) != 0)
3252 bss_size
+= bfd_get_section_size_before_reloc (current
);
3253 else if ((section
.s_flags
& STYP_ECOFF_LIB
) != 0)
3259 /* Set up the file header. */
3261 internal_f
.f_magic
= ecoff_get_magic (abfd
);
3263 /* We will NOT put a fucking timestamp in the header here. Every
3264 time you put it back, I will come in and take it out again. I'm
3265 sorry. This field does not belong here. We fill it with a 0 so
3266 it compares the same but is not a reasonable time. --
3268 internal_f
.f_timdat
= 0;
3270 if (bfd_get_symcount (abfd
) != 0)
3272 /* The ECOFF f_nsyms field is not actually the number of
3273 symbols, it's the size of symbolic information header. */
3274 internal_f
.f_nsyms
= external_hdr_size
;
3275 internal_f
.f_symptr
= ecoff_data (abfd
)->sym_filepos
;
3279 internal_f
.f_nsyms
= 0;
3280 internal_f
.f_symptr
= 0;
3283 internal_f
.f_opthdr
= aoutsz
;
3285 internal_f
.f_flags
= F_LNNO
;
3286 if (reloc_size
== 0)
3287 internal_f
.f_flags
|= F_RELFLG
;
3288 if (bfd_get_symcount (abfd
) == 0)
3289 internal_f
.f_flags
|= F_LSYMS
;
3290 if (abfd
->flags
& EXEC_P
)
3291 internal_f
.f_flags
|= F_EXEC
;
3293 if (! abfd
->xvec
->byteorder_big_p
)
3294 internal_f
.f_flags
|= F_AR32WR
;
3296 internal_f
.f_flags
|= F_AR32W
;
3298 /* Set up the ``optional'' header. */
3299 if ((abfd
->flags
& D_PAGED
) != 0)
3300 internal_a
.magic
= ECOFF_AOUT_ZMAGIC
;
3302 internal_a
.magic
= ECOFF_AOUT_OMAGIC
;
3304 /* FIXME: Is this really correct? */
3305 internal_a
.vstamp
= symhdr
->vstamp
;
3307 /* At least on Ultrix, these have to be rounded to page boundaries.
3308 FIXME: Is this true on other platforms? */
3309 if ((abfd
->flags
& D_PAGED
) != 0)
3311 internal_a
.tsize
= (text_size
+ round
- 1) &~ (round
- 1);
3312 internal_a
.text_start
= text_start
&~ (round
- 1);
3313 internal_a
.dsize
= (data_size
+ round
- 1) &~ (round
- 1);
3314 internal_a
.data_start
= data_start
&~ (round
- 1);
3318 internal_a
.tsize
= text_size
;
3319 internal_a
.text_start
= text_start
;
3320 internal_a
.dsize
= data_size
;
3321 internal_a
.data_start
= data_start
;
3324 /* On Ultrix, the initial portions of the .sbss and .bss segments
3325 are at the end of the data section. The bsize field in the
3326 optional header records how many bss bytes are required beyond
3327 those in the data section. The value is not rounded to a page
3329 if (bss_size
< internal_a
.dsize
- data_size
)
3332 bss_size
-= internal_a
.dsize
- data_size
;
3333 internal_a
.bsize
= bss_size
;
3334 internal_a
.bss_start
= internal_a
.data_start
+ internal_a
.dsize
;
3336 internal_a
.entry
= bfd_get_start_address (abfd
);
3338 internal_a
.gp_value
= ecoff_data (abfd
)->gp
;
3340 internal_a
.gprmask
= ecoff_data (abfd
)->gprmask
;
3341 internal_a
.fprmask
= ecoff_data (abfd
)->fprmask
;
3342 for (i
= 0; i
< 4; i
++)
3343 internal_a
.cprmask
[i
] = ecoff_data (abfd
)->cprmask
[i
];
3345 /* Write out the file header and the optional header. */
3347 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3350 bfd_coff_swap_filehdr_out (abfd
, (PTR
) &internal_f
, buff
);
3351 if (bfd_write (buff
, 1, filhsz
, abfd
) != filhsz
)
3354 bfd_coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, buff
);
3355 if (bfd_write (buff
, 1, aoutsz
, abfd
) != aoutsz
)
3358 /* Build the external symbol information. This must be done before
3359 writing out the relocs so that we know the symbol indices. We
3360 don't do this if this BFD was created by the backend linker,
3361 since it will have already handled the symbols and relocs. */
3362 if (! ecoff_data (abfd
)->linker
)
3364 symhdr
->iextMax
= 0;
3365 symhdr
->issExtMax
= 0;
3366 debug
->external_ext
= debug
->external_ext_end
= NULL
;
3367 debug
->ssext
= debug
->ssext_end
= NULL
;
3368 if (bfd_ecoff_debug_externals (abfd
, debug
, &backend
->debug_swap
,
3369 (((abfd
->flags
& EXEC_P
) == 0)
3371 ecoff_get_extr
, ecoff_set_index
)
3375 /* Write out the relocs. */
3376 for (current
= abfd
->sections
;
3377 current
!= (asection
*) NULL
;
3378 current
= current
->next
)
3380 arelent
**reloc_ptr_ptr
;
3381 arelent
**reloc_end
;
3384 if (current
->reloc_count
== 0)
3388 bfd_alloc (abfd
, current
->reloc_count
* external_reloc_size
);
3389 if (reloc_buff
== NULL
)
3391 bfd_set_error (bfd_error_no_memory
);
3395 reloc_ptr_ptr
= current
->orelocation
;
3396 reloc_end
= reloc_ptr_ptr
+ current
->reloc_count
;
3397 out_ptr
= (char *) reloc_buff
;
3399 reloc_ptr_ptr
< reloc_end
;
3400 reloc_ptr_ptr
++, out_ptr
+= external_reloc_size
)
3404 struct internal_reloc in
;
3406 memset ((PTR
) &in
, 0, sizeof in
);
3408 reloc
= *reloc_ptr_ptr
;
3409 sym
= *reloc
->sym_ptr_ptr
;
3411 in
.r_vaddr
= (reloc
->address
3412 + bfd_get_section_vma (abfd
, current
));
3413 in
.r_type
= reloc
->howto
->type
;
3415 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
3417 in
.r_symndx
= ecoff_get_sym_index (*reloc
->sym_ptr_ptr
);
3424 name
= bfd_get_section_name (abfd
, bfd_get_section (sym
));
3425 if (strcmp (name
, ".text") == 0)
3426 in
.r_symndx
= RELOC_SECTION_TEXT
;
3427 else if (strcmp (name
, ".rdata") == 0)
3428 in
.r_symndx
= RELOC_SECTION_RDATA
;
3429 else if (strcmp (name
, ".data") == 0)
3430 in
.r_symndx
= RELOC_SECTION_DATA
;
3431 else if (strcmp (name
, ".sdata") == 0)
3432 in
.r_symndx
= RELOC_SECTION_SDATA
;
3433 else if (strcmp (name
, ".sbss") == 0)
3434 in
.r_symndx
= RELOC_SECTION_SBSS
;
3435 else if (strcmp (name
, ".bss") == 0)
3436 in
.r_symndx
= RELOC_SECTION_BSS
;
3437 else if (strcmp (name
, ".init") == 0)
3438 in
.r_symndx
= RELOC_SECTION_INIT
;
3439 else if (strcmp (name
, ".lit8") == 0)
3440 in
.r_symndx
= RELOC_SECTION_LIT8
;
3441 else if (strcmp (name
, ".lit4") == 0)
3442 in
.r_symndx
= RELOC_SECTION_LIT4
;
3443 else if (strcmp (name
, ".xdata") == 0)
3444 in
.r_symndx
= RELOC_SECTION_XDATA
;
3445 else if (strcmp (name
, ".pdata") == 0)
3446 in
.r_symndx
= RELOC_SECTION_PDATA
;
3447 else if (strcmp (name
, ".fini") == 0)
3448 in
.r_symndx
= RELOC_SECTION_FINI
;
3449 else if (strcmp (name
, ".lita") == 0)
3450 in
.r_symndx
= RELOC_SECTION_LITA
;
3451 else if (strcmp (name
, "*ABS*") == 0)
3452 in
.r_symndx
= RELOC_SECTION_ABS
;
3458 (*adjust_reloc_out
) (abfd
, reloc
, &in
);
3460 (*swap_reloc_out
) (abfd
, &in
, (PTR
) out_ptr
);
3463 if (bfd_seek (abfd
, current
->rel_filepos
, SEEK_SET
) != 0)
3465 if (bfd_write (reloc_buff
,
3466 external_reloc_size
, current
->reloc_count
, abfd
)
3467 != external_reloc_size
* current
->reloc_count
)
3469 bfd_release (abfd
, reloc_buff
);
3473 /* Write out the symbolic debugging information. */
3474 if (bfd_get_symcount (abfd
) > 0)
3476 /* Write out the debugging information. */
3477 if (bfd_ecoff_write_debug (abfd
, debug
, &backend
->debug_swap
,
3478 ecoff_data (abfd
)->sym_filepos
)
3484 /* The .bss section of a demand paged executable must receive an
3485 entire page. If there are symbols, the symbols will start on the
3486 next page. If there are no symbols, we must fill out the page by
3488 if (bfd_get_symcount (abfd
) == 0
3489 && (abfd
->flags
& EXEC_P
) != 0
3490 && (abfd
->flags
& D_PAGED
) != 0)
3494 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
3497 if (bfd_read (&c
, 1, 1, abfd
) == 0)
3499 if (bfd_seek (abfd
, (file_ptr
) ecoff_data (abfd
)->sym_filepos
- 1,
3502 if (bfd_write (&c
, 1, 1, abfd
) != 1)
3506 if (reloc_buff
!= NULL
)
3507 bfd_release (abfd
, reloc_buff
);
3512 if (reloc_buff
!= NULL
)
3513 bfd_release (abfd
, reloc_buff
);
3519 /* Archive handling. ECOFF uses what appears to be a unique type of
3520 archive header (armap). The byte ordering of the armap and the
3521 contents are encoded in the name of the armap itself. At least for
3522 now, we only support archives with the same byte ordering in the
3523 armap and the contents.
3525 The first four bytes in the armap are the number of symbol
3526 definitions. This is always a power of two.
3528 This is followed by the symbol definitions. Each symbol definition
3529 occupies 8 bytes. The first four bytes are the offset from the
3530 start of the armap strings to the null-terminated string naming
3531 this symbol. The second four bytes are the file offset to the
3532 archive member which defines this symbol. If the second four bytes
3533 are 0, then this is not actually a symbol definition, and it should
3536 The symbols are hashed into the armap with a closed hashing scheme.
3537 See the functions below for the details of the algorithm.
3539 After the symbol definitions comes four bytes holding the size of
3540 the string table, followed by the string table itself. */
3542 /* The name of an archive headers looks like this:
3543 __________E[BL]E[BL]_ (with a trailing space).
3544 The trailing space is changed to an X if the archive is changed to
3545 indicate that the armap is out of date.
3547 The Alpha seems to use ________64E[BL]E[BL]_. */
3549 #define ARMAP_BIG_ENDIAN 'B'
3550 #define ARMAP_LITTLE_ENDIAN 'L'
3551 #define ARMAP_MARKER 'E'
3552 #define ARMAP_START_LENGTH 10
3553 #define ARMAP_HEADER_MARKER_INDEX 10
3554 #define ARMAP_HEADER_ENDIAN_INDEX 11
3555 #define ARMAP_OBJECT_MARKER_INDEX 12
3556 #define ARMAP_OBJECT_ENDIAN_INDEX 13
3557 #define ARMAP_END_INDEX 14
3558 #define ARMAP_END "_ "
3560 /* This is a magic number used in the hashing algorithm. */
3561 #define ARMAP_HASH_MAGIC 0x9dd68ab5
3563 /* This returns the hash value to use for a string. It also sets
3564 *REHASH to the rehash adjustment if the first slot is taken. SIZE
3565 is the number of entries in the hash table, and HLOG is the log
3569 ecoff_armap_hash (s
, rehash
, size
, hlog
)
3571 unsigned int *rehash
;
3579 hash
= ((hash
>> 27) | (hash
<< 5)) + *s
++;
3580 hash
*= ARMAP_HASH_MAGIC
;
3581 *rehash
= (hash
& (size
- 1)) | 1;
3582 return hash
>> (32 - hlog
);
3585 /* Read in the armap. */
3588 _bfd_ecoff_slurp_armap (abfd
)
3593 struct areltdata
*mapdata
;
3594 bfd_size_type parsed_size
;
3596 struct artdata
*ardata
;
3599 struct symdef
*symdef_ptr
;
3602 /* Get the name of the first element. */
3603 i
= bfd_read ((PTR
) nextname
, 1, 16, abfd
);
3609 if (bfd_seek (abfd
, (file_ptr
) -16, SEEK_CUR
) != 0)
3612 /* Irix 4.0.5F apparently can use either an ECOFF armap or a
3613 standard COFF armap. We could move the ECOFF armap stuff into
3614 bfd_slurp_armap, but that seems inappropriate since no other
3615 target uses this format. Instead, we check directly for a COFF
3617 if (strncmp (nextname
, "/ ", 16) == 0)
3618 return bfd_slurp_armap (abfd
);
3620 /* See if the first element is an armap. */
3621 if (strncmp (nextname
, ecoff_backend (abfd
)->armap_start
,
3622 ARMAP_START_LENGTH
) != 0
3623 || nextname
[ARMAP_HEADER_MARKER_INDEX
] != ARMAP_MARKER
3624 || (nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
3625 && nextname
[ARMAP_HEADER_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
3626 || nextname
[ARMAP_OBJECT_MARKER_INDEX
] != ARMAP_MARKER
3627 || (nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_BIG_ENDIAN
3628 && nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] != ARMAP_LITTLE_ENDIAN
)
3629 || strncmp (nextname
+ ARMAP_END_INDEX
,
3630 ARMAP_END
, sizeof ARMAP_END
- 1) != 0)
3632 bfd_has_map (abfd
) = false;
3636 /* Make sure we have the right byte ordering. */
3637 if (((nextname
[ARMAP_HEADER_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
3638 ^ (abfd
->xvec
->header_byteorder_big_p
!= false))
3639 || ((nextname
[ARMAP_OBJECT_ENDIAN_INDEX
] == ARMAP_BIG_ENDIAN
)
3640 ^ (abfd
->xvec
->byteorder_big_p
!= false)))
3642 bfd_set_error (bfd_error_wrong_format
);
3646 /* Read in the armap. */
3647 ardata
= bfd_ardata (abfd
);
3648 mapdata
= _bfd_snarf_ar_hdr (abfd
);
3649 if (mapdata
== (struct areltdata
*) NULL
)
3651 parsed_size
= mapdata
->parsed_size
;
3652 bfd_release (abfd
, (PTR
) mapdata
);
3654 raw_armap
= (char *) bfd_alloc (abfd
, parsed_size
);
3655 if (raw_armap
== (char *) NULL
)
3657 bfd_set_error (bfd_error_no_memory
);
3661 if (bfd_read ((PTR
) raw_armap
, 1, parsed_size
, abfd
) != parsed_size
)
3663 if (bfd_get_error () != bfd_error_system_call
)
3664 bfd_set_error (bfd_error_malformed_archive
);
3665 bfd_release (abfd
, (PTR
) raw_armap
);
3669 ardata
->tdata
= (PTR
) raw_armap
;
3671 count
= bfd_h_get_32 (abfd
, (PTR
) raw_armap
);
3673 ardata
->symdef_count
= 0;
3674 ardata
->cache
= (struct ar_cache
*) NULL
;
3676 /* This code used to overlay the symdefs over the raw archive data,
3677 but that doesn't work on a 64 bit host. */
3679 stringbase
= raw_armap
+ count
* 8 + 8;
3681 #ifdef CHECK_ARMAP_HASH
3685 /* Double check that I have the hashing algorithm right by making
3686 sure that every symbol can be looked up successfully. */
3688 for (i
= 1; i
< count
; i
<<= 1)
3690 BFD_ASSERT (i
== count
);
3692 raw_ptr
= raw_armap
+ 4;
3693 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3695 unsigned int name_offset
, file_offset
;
3696 unsigned int hash
, rehash
, srch
;
3698 name_offset
= bfd_h_get_32 (abfd
, (PTR
) raw_ptr
);
3699 file_offset
= bfd_h_get_32 (abfd
, (PTR
) (raw_ptr
+ 4));
3700 if (file_offset
== 0)
3702 hash
= ecoff_armap_hash (stringbase
+ name_offset
, &rehash
, count
,
3707 /* See if we can rehash to this location. */
3708 for (srch
= (hash
+ rehash
) & (count
- 1);
3709 srch
!= hash
&& srch
!= i
;
3710 srch
= (srch
+ rehash
) & (count
- 1))
3711 BFD_ASSERT (bfd_h_get_32 (abfd
, (PTR
) (raw_armap
+ 8 + srch
* 8))
3713 BFD_ASSERT (srch
== i
);
3717 #endif /* CHECK_ARMAP_HASH */
3719 raw_ptr
= raw_armap
+ 4;
3720 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3721 if (bfd_h_get_32 (abfd
, (PTR
) (raw_ptr
+ 4)) != 0)
3722 ++ardata
->symdef_count
;
3724 symdef_ptr
= ((struct symdef
*)
3726 ardata
->symdef_count
* sizeof (struct symdef
)));
3729 bfd_set_error (bfd_error_no_memory
);
3733 ardata
->symdefs
= (carsym
*) symdef_ptr
;
3735 raw_ptr
= raw_armap
+ 4;
3736 for (i
= 0; i
< count
; i
++, raw_ptr
+= 8)
3738 unsigned int name_offset
, file_offset
;
3740 file_offset
= bfd_h_get_32 (abfd
, (PTR
) (raw_ptr
+ 4));
3741 if (file_offset
== 0)
3743 name_offset
= bfd_h_get_32 (abfd
, (PTR
) raw_ptr
);
3744 symdef_ptr
->s
.name
= stringbase
+ name_offset
;
3745 symdef_ptr
->file_offset
= file_offset
;
3749 ardata
->first_file_filepos
= bfd_tell (abfd
);
3750 /* Pad to an even boundary. */
3751 ardata
->first_file_filepos
+= ardata
->first_file_filepos
% 2;
3753 bfd_has_map (abfd
) = true;
3758 /* Write out an armap. */
3761 _bfd_ecoff_write_armap (abfd
, elength
, map
, orl_count
, stridx
)
3763 unsigned int elength
;
3765 unsigned int orl_count
;
3768 unsigned int hashsize
, hashlog
;
3769 unsigned int symdefsize
;
3771 unsigned int stringsize
;
3772 unsigned int mapsize
;
3775 struct stat statbuf
;
3778 bfd_byte
*hashtable
;
3782 /* Ultrix appears to use as a hash table size the least power of two
3783 greater than twice the number of entries. */
3784 for (hashlog
= 0; (1 << hashlog
) <= 2 * orl_count
; hashlog
++)
3786 hashsize
= 1 << hashlog
;
3788 symdefsize
= hashsize
* 8;
3790 stringsize
= stridx
+ padit
;
3792 /* Include 8 bytes to store symdefsize and stringsize in output. */
3793 mapsize
= symdefsize
+ stringsize
+ 8;
3795 firstreal
= SARMAG
+ sizeof (struct ar_hdr
) + mapsize
+ elength
;
3797 memset ((PTR
) &hdr
, 0, sizeof hdr
);
3799 /* Work out the ECOFF armap name. */
3800 strcpy (hdr
.ar_name
, ecoff_backend (abfd
)->armap_start
);
3801 hdr
.ar_name
[ARMAP_HEADER_MARKER_INDEX
] = ARMAP_MARKER
;
3802 hdr
.ar_name
[ARMAP_HEADER_ENDIAN_INDEX
] =
3803 (abfd
->xvec
->header_byteorder_big_p
3805 : ARMAP_LITTLE_ENDIAN
);
3806 hdr
.ar_name
[ARMAP_OBJECT_MARKER_INDEX
] = ARMAP_MARKER
;
3807 hdr
.ar_name
[ARMAP_OBJECT_ENDIAN_INDEX
] =
3808 abfd
->xvec
->byteorder_big_p
? ARMAP_BIG_ENDIAN
: ARMAP_LITTLE_ENDIAN
;
3809 memcpy (hdr
.ar_name
+ ARMAP_END_INDEX
, ARMAP_END
, sizeof ARMAP_END
- 1);
3811 /* Write the timestamp of the archive header to be just a little bit
3812 later than the timestamp of the file, otherwise the linker will
3813 complain that the index is out of date. Actually, the Ultrix
3814 linker just checks the archive name; the GNU linker may check the
3816 stat (abfd
->filename
, &statbuf
);
3817 sprintf (hdr
.ar_date
, "%ld", (long) (statbuf
.st_mtime
+ 60));
3819 /* The DECstation uses zeroes for the uid, gid and mode of the
3821 hdr
.ar_uid
[0] = '0';
3822 hdr
.ar_gid
[0] = '0';
3823 hdr
.ar_mode
[0] = '0';
3825 sprintf (hdr
.ar_size
, "%-10d", (int) mapsize
);
3827 hdr
.ar_fmag
[0] = '`';
3828 hdr
.ar_fmag
[1] = '\012';
3830 /* Turn all null bytes in the header into spaces. */
3831 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
3832 if (((char *)(&hdr
))[i
] == '\0')
3833 (((char *)(&hdr
))[i
]) = ' ';
3835 if (bfd_write ((PTR
) &hdr
, 1, sizeof (struct ar_hdr
), abfd
)
3836 != sizeof (struct ar_hdr
))
3839 bfd_h_put_32 (abfd
, (bfd_vma
) hashsize
, temp
);
3840 if (bfd_write ((PTR
) temp
, 1, 4, abfd
) != 4)
3843 hashtable
= (bfd_byte
*) bfd_zalloc (abfd
, symdefsize
);
3846 bfd_set_error (bfd_error_no_memory
);
3850 current
= abfd
->archive_head
;
3852 for (i
= 0; i
< orl_count
; i
++)
3854 unsigned int hash
, rehash
;
3856 /* Advance firstreal to the file position of this archive
3858 if (((bfd
*) map
[i
].pos
) != last_elt
)
3862 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
3863 firstreal
+= firstreal
% 2;
3864 current
= current
->next
;
3866 while (current
!= (bfd
*) map
[i
].pos
);
3871 hash
= ecoff_armap_hash (*map
[i
].name
, &rehash
, hashsize
, hashlog
);
3872 if (bfd_h_get_32 (abfd
, (PTR
) (hashtable
+ (hash
* 8) + 4)) != 0)
3876 /* The desired slot is already taken. */
3877 for (srch
= (hash
+ rehash
) & (hashsize
- 1);
3879 srch
= (srch
+ rehash
) & (hashsize
- 1))
3880 if (bfd_h_get_32 (abfd
, (PTR
) (hashtable
+ (srch
* 8) + 4)) == 0)
3883 BFD_ASSERT (srch
!= hash
);
3888 bfd_h_put_32 (abfd
, (bfd_vma
) map
[i
].namidx
,
3889 (PTR
) (hashtable
+ hash
* 8));
3890 bfd_h_put_32 (abfd
, (bfd_vma
) firstreal
,
3891 (PTR
) (hashtable
+ hash
* 8 + 4));
3894 if (bfd_write ((PTR
) hashtable
, 1, symdefsize
, abfd
) != symdefsize
)
3897 bfd_release (abfd
, hashtable
);
3899 /* Now write the strings. */
3900 bfd_h_put_32 (abfd
, (bfd_vma
) stringsize
, temp
);
3901 if (bfd_write ((PTR
) temp
, 1, 4, abfd
) != 4)
3903 for (i
= 0; i
< orl_count
; i
++)
3907 len
= strlen (*map
[i
].name
) + 1;
3908 if (bfd_write ((PTR
) (*map
[i
].name
), 1, len
, abfd
) != len
)
3912 /* The spec sez this should be a newline. But in order to be
3913 bug-compatible for DECstation ar we use a null. */
3916 if (bfd_write ("", 1, 1, abfd
) != 1)
3923 /* See whether this BFD is an archive. If it is, read in the armap
3924 and the extended name table. */
3927 _bfd_ecoff_archive_p (abfd
)
3930 char armag
[SARMAG
+ 1];
3932 if (bfd_read ((PTR
) armag
, 1, SARMAG
, abfd
) != SARMAG
3933 || strncmp (armag
, ARMAG
, SARMAG
) != 0)
3935 if (bfd_get_error () != bfd_error_system_call
)
3936 bfd_set_error (bfd_error_wrong_format
);
3937 return (const bfd_target
*) NULL
;
3940 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
3941 involves a cast, we can't do it as the left operand of
3943 abfd
->tdata
.aout_ar_data
=
3944 (struct artdata
*) bfd_zalloc (abfd
, sizeof (struct artdata
));
3946 if (bfd_ardata (abfd
) == (struct artdata
*) NULL
)
3948 bfd_set_error (bfd_error_no_memory
);
3949 return (const bfd_target
*) NULL
;
3952 bfd_ardata (abfd
)->first_file_filepos
= SARMAG
;
3953 bfd_ardata (abfd
)->cache
= NULL
;
3954 bfd_ardata (abfd
)->archive_head
= NULL
;
3955 bfd_ardata (abfd
)->symdefs
= NULL
;
3956 bfd_ardata (abfd
)->extended_names
= NULL
;
3957 bfd_ardata (abfd
)->tdata
= NULL
;
3959 if (_bfd_ecoff_slurp_armap (abfd
) == false
3960 || _bfd_ecoff_slurp_extended_name_table (abfd
) == false)
3962 bfd_release (abfd
, bfd_ardata (abfd
));
3963 abfd
->tdata
.aout_ar_data
= (struct artdata
*) NULL
;
3964 return (const bfd_target
*) NULL
;
3970 /* ECOFF linker code. */
3972 static struct bfd_hash_entry
*ecoff_link_hash_newfunc
3973 PARAMS ((struct bfd_hash_entry
*entry
,
3974 struct bfd_hash_table
*table
,
3975 const char *string
));
3976 static boolean ecoff_link_add_archive_symbols
3977 PARAMS ((bfd
*, struct bfd_link_info
*));
3978 static boolean ecoff_link_check_archive_element
3979 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
*pneeded
));
3980 static boolean ecoff_link_add_object_symbols
3981 PARAMS ((bfd
*, struct bfd_link_info
*));
3982 static boolean ecoff_link_add_externals
3983 PARAMS ((bfd
*, struct bfd_link_info
*, PTR
, char *));
3985 /* Routine to create an entry in an ECOFF link hash table. */
3987 static struct bfd_hash_entry
*
3988 ecoff_link_hash_newfunc (entry
, table
, string
)
3989 struct bfd_hash_entry
*entry
;
3990 struct bfd_hash_table
*table
;
3993 struct ecoff_link_hash_entry
*ret
= (struct ecoff_link_hash_entry
*) entry
;
3995 /* Allocate the structure if it has not already been allocated by a
3997 if (ret
== (struct ecoff_link_hash_entry
*) NULL
)
3998 ret
= ((struct ecoff_link_hash_entry
*)
3999 bfd_hash_allocate (table
, sizeof (struct ecoff_link_hash_entry
)));
4000 if (ret
== (struct ecoff_link_hash_entry
*) NULL
)
4002 bfd_set_error (bfd_error_no_memory
);
4006 /* Call the allocation method of the superclass. */
4007 ret
= ((struct ecoff_link_hash_entry
*)
4008 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
4013 /* Set local fields. */
4019 memset ((PTR
) &ret
->esym
, 0, sizeof ret
->esym
);
4021 return (struct bfd_hash_entry
*) ret
;
4024 /* Create an ECOFF link hash table. */
4026 struct bfd_link_hash_table
*
4027 _bfd_ecoff_bfd_link_hash_table_create (abfd
)
4030 struct ecoff_link_hash_table
*ret
;
4032 ret
= ((struct ecoff_link_hash_table
*)
4033 malloc (sizeof (struct ecoff_link_hash_table
)));
4036 bfd_set_error (bfd_error_no_memory
);
4039 if (! _bfd_link_hash_table_init (&ret
->root
, abfd
,
4040 ecoff_link_hash_newfunc
))
4043 return (struct bfd_link_hash_table
*) NULL
;
4048 /* Look up an entry in an ECOFF link hash table. */
4050 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
4051 ((struct ecoff_link_hash_entry *) \
4052 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
4054 /* Traverse an ECOFF link hash table. */
4056 #define ecoff_link_hash_traverse(table, func, info) \
4057 (bfd_link_hash_traverse \
4059 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
4062 /* Get the ECOFF link hash table from the info structure. This is
4065 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
4067 /* Given an ECOFF BFD, add symbols to the global hash table as
4071 _bfd_ecoff_bfd_link_add_symbols (abfd
, info
)
4073 struct bfd_link_info
*info
;
4075 switch (bfd_get_format (abfd
))
4078 return ecoff_link_add_object_symbols (abfd
, info
);
4080 return ecoff_link_add_archive_symbols (abfd
, info
);
4082 bfd_set_error (bfd_error_wrong_format
);
4087 /* Add the symbols from an archive file to the global hash table.
4088 This looks through the undefined symbols, looks each one up in the
4089 archive hash table, and adds any associated object file. We do not
4090 use _bfd_generic_link_add_archive_symbols because ECOFF archives
4091 already have a hash table, so there is no reason to construct
4095 ecoff_link_add_archive_symbols (abfd
, info
)
4097 struct bfd_link_info
*info
;
4099 const bfd_byte
*raw_armap
;
4100 struct bfd_link_hash_entry
**pundef
;
4101 unsigned int armap_count
;
4102 unsigned int armap_log
;
4104 const bfd_byte
*hashtable
;
4105 const char *stringbase
;
4107 if (! bfd_has_map (abfd
))
4109 /* An empty archive is a special case. */
4110 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
4112 bfd_set_error (bfd_error_no_symbols
);
4116 /* If we don't have any raw data for this archive, as can happen on
4117 Irix 4.0.5F, we call the generic routine.
4118 FIXME: We should be more clever about this, since someday tdata
4119 may get to something for a generic archive. */
4120 raw_armap
= (const bfd_byte
*) bfd_ardata (abfd
)->tdata
;
4121 if (raw_armap
== (bfd_byte
*) NULL
)
4122 return (_bfd_generic_link_add_archive_symbols
4123 (abfd
, info
, ecoff_link_check_archive_element
));
4125 armap_count
= bfd_h_get_32 (abfd
, raw_armap
);
4128 for (i
= 1; i
< armap_count
; i
<<= 1)
4130 BFD_ASSERT (i
== armap_count
);
4132 hashtable
= raw_armap
+ 4;
4133 stringbase
= (const char *) raw_armap
+ armap_count
* 8 + 8;
4135 /* Look through the list of undefined symbols. */
4136 pundef
= &info
->hash
->undefs
;
4137 while (*pundef
!= (struct bfd_link_hash_entry
*) NULL
)
4139 struct bfd_link_hash_entry
*h
;
4140 unsigned int hash
, rehash
;
4141 unsigned int file_offset
;
4147 /* When a symbol is defined, it is not necessarily removed from
4149 if (h
->type
!= bfd_link_hash_undefined
4150 && h
->type
!= bfd_link_hash_common
)
4152 /* Remove this entry from the list, for general cleanliness
4153 and because we are going to look through the list again
4154 if we search any more libraries. We can't remove the
4155 entry if it is the tail, because that would lose any
4156 entries we add to the list later on. */
4157 if (*pundef
!= info
->hash
->undefs_tail
)
4158 *pundef
= (*pundef
)->next
;
4160 pundef
= &(*pundef
)->next
;
4164 /* Native ECOFF linkers do not pull in archive elements merely
4165 to satisfy common definitions, so neither do we. We leave
4166 them on the list, though, in case we are linking against some
4167 other object format. */
4168 if (h
->type
!= bfd_link_hash_undefined
)
4170 pundef
= &(*pundef
)->next
;
4174 /* Look for this symbol in the archive hash table. */
4175 hash
= ecoff_armap_hash (h
->root
.string
, &rehash
, armap_count
,
4178 file_offset
= bfd_h_get_32 (abfd
, hashtable
+ (hash
* 8) + 4);
4179 if (file_offset
== 0)
4181 /* Nothing in this slot. */
4182 pundef
= &(*pundef
)->next
;
4186 name
= stringbase
+ bfd_h_get_32 (abfd
, hashtable
+ (hash
* 8));
4187 if (name
[0] != h
->root
.string
[0]
4188 || strcmp (name
, h
->root
.string
) != 0)
4193 /* That was the wrong symbol. Try rehashing. */
4195 for (srch
= (hash
+ rehash
) & (armap_count
- 1);
4197 srch
= (srch
+ rehash
) & (armap_count
- 1))
4199 file_offset
= bfd_h_get_32 (abfd
, hashtable
+ (srch
* 8) + 4);
4200 if (file_offset
== 0)
4202 name
= stringbase
+ bfd_h_get_32 (abfd
, hashtable
+ (srch
* 8));
4203 if (name
[0] == h
->root
.string
[0]
4204 && strcmp (name
, h
->root
.string
) == 0)
4213 pundef
= &(*pundef
)->next
;
4220 element
= _bfd_get_elt_at_filepos (abfd
, file_offset
);
4221 if (element
== (bfd
*) NULL
)
4224 if (! bfd_check_format (element
, bfd_object
))
4227 /* Unlike the generic linker, we know that this element provides
4228 a definition for an undefined symbol and we know that we want
4229 to include it. We don't need to check anything. */
4230 if (! (*info
->callbacks
->add_archive_element
) (info
, element
, name
))
4232 if (! ecoff_link_add_object_symbols (element
, info
))
4235 pundef
= &(*pundef
)->next
;
4241 /* This is called if we used _bfd_generic_link_add_archive_symbols
4242 because we were not dealing with an ECOFF archive. */
4245 ecoff_link_check_archive_element (abfd
, info
, pneeded
)
4247 struct bfd_link_info
*info
;
4250 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4251 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
4252 = backend
->debug_swap
.swap_ext_in
;
4254 bfd_size_type external_ext_size
;
4255 PTR external_ext
= NULL
;
4263 if (! ecoff_slurp_symbolic_header (abfd
))
4266 /* If there are no symbols, we don't want it. */
4267 if (bfd_get_symcount (abfd
) == 0)
4268 goto successful_return
;
4270 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
4272 /* Read in the external symbols and external strings. */
4273 external_ext_size
= backend
->debug_swap
.external_ext_size
;
4274 esize
= symhdr
->iextMax
* external_ext_size
;
4275 external_ext
= (PTR
) malloc (esize
);
4276 if (external_ext
== NULL
&& esize
!= 0)
4278 bfd_set_error (bfd_error_no_memory
);
4282 if (bfd_seek (abfd
, symhdr
->cbExtOffset
, SEEK_SET
) != 0
4283 || bfd_read (external_ext
, 1, esize
, abfd
) != esize
)
4286 ssext
= (char *) malloc (symhdr
->issExtMax
);
4287 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
4289 bfd_set_error (bfd_error_no_memory
);
4293 if (bfd_seek (abfd
, symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
4294 || bfd_read (ssext
, 1, symhdr
->issExtMax
, abfd
) != symhdr
->issExtMax
)
4297 /* Look through the external symbols to see if they define some
4298 symbol that is currently undefined. */
4299 ext_ptr
= (char *) external_ext
;
4300 ext_end
= ext_ptr
+ esize
;
4301 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
)
4306 struct bfd_link_hash_entry
*h
;
4308 (*swap_ext_in
) (abfd
, (PTR
) ext_ptr
, &esym
);
4310 /* See if this symbol defines something. */
4311 if (esym
.asym
.st
!= stGlobal
4312 && esym
.asym
.st
!= stLabel
4313 && esym
.asym
.st
!= stProc
)
4316 switch (esym
.asym
.sc
)
4339 name
= ssext
+ esym
.asym
.iss
;
4340 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
4342 /* Unlike the generic linker, we do not pull in elements because
4343 of common symbols. */
4344 if (h
== (struct bfd_link_hash_entry
*) NULL
4345 || h
->type
!= bfd_link_hash_undefined
)
4348 /* Include this element. */
4349 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
4351 if (! ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
))
4355 goto successful_return
;
4359 if (external_ext
!= NULL
)
4360 free (external_ext
);
4365 if (external_ext
!= NULL
)
4366 free (external_ext
);
4372 /* Add symbols from an ECOFF object file to the global linker hash
4376 ecoff_link_add_object_symbols (abfd
, info
)
4378 struct bfd_link_info
*info
;
4381 bfd_size_type external_ext_size
;
4382 PTR external_ext
= NULL
;
4387 if (! ecoff_slurp_symbolic_header (abfd
))
4390 /* If there are no symbols, we don't want it. */
4391 if (bfd_get_symcount (abfd
) == 0)
4394 symhdr
= &ecoff_data (abfd
)->debug_info
.symbolic_header
;
4396 /* Read in the external symbols and external strings. */
4397 external_ext_size
= ecoff_backend (abfd
)->debug_swap
.external_ext_size
;
4398 esize
= symhdr
->iextMax
* external_ext_size
;
4399 external_ext
= (PTR
) malloc (esize
);
4400 if (external_ext
== NULL
&& esize
!= 0)
4402 bfd_set_error (bfd_error_no_memory
);
4406 if (bfd_seek (abfd
, symhdr
->cbExtOffset
, SEEK_SET
) != 0
4407 || bfd_read (external_ext
, 1, esize
, abfd
) != esize
)
4410 ssext
= (char *) malloc (symhdr
->issExtMax
);
4411 if (ssext
== NULL
&& symhdr
->issExtMax
!= 0)
4413 bfd_set_error (bfd_error_no_memory
);
4417 if (bfd_seek (abfd
, symhdr
->cbSsExtOffset
, SEEK_SET
) != 0
4418 || bfd_read (ssext
, 1, symhdr
->issExtMax
, abfd
) != symhdr
->issExtMax
)
4421 result
= ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
);
4425 if (external_ext
!= NULL
)
4426 free (external_ext
);
4432 if (external_ext
!= NULL
)
4433 free (external_ext
);
4437 /* Add the external symbols of an object file to the global linker
4438 hash table. The external symbols and strings we are passed are
4439 just allocated on the stack, and will be discarded. We must
4440 explicitly save any information we may need later on in the link.
4441 We do not want to read the external symbol information again. */
4444 ecoff_link_add_externals (abfd
, info
, external_ext
, ssext
)
4446 struct bfd_link_info
*info
;
4450 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4451 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
4452 = backend
->debug_swap
.swap_ext_in
;
4453 bfd_size_type external_ext_size
= backend
->debug_swap
.external_ext_size
;
4454 unsigned long ext_count
;
4455 struct ecoff_link_hash_entry
**sym_hash
;
4459 ext_count
= ecoff_data (abfd
)->debug_info
.symbolic_header
.iextMax
;
4461 sym_hash
= ((struct ecoff_link_hash_entry
**)
4463 ext_count
* sizeof (struct bfd_link_hash_entry
*)));
4466 bfd_set_error (bfd_error_no_memory
);
4469 ecoff_data (abfd
)->sym_hashes
= sym_hash
;
4471 ext_ptr
= (char *) external_ext
;
4472 ext_end
= ext_ptr
+ ext_count
* external_ext_size
;
4473 for (; ext_ptr
< ext_end
; ext_ptr
+= external_ext_size
, sym_hash
++)
4480 struct ecoff_link_hash_entry
*h
;
4484 (*swap_ext_in
) (abfd
, (PTR
) ext_ptr
, &esym
);
4486 /* Skip debugging symbols. */
4488 switch (esym
.asym
.st
)
4504 /* Get the information for this symbol. */
4505 value
= esym
.asym
.value
;
4506 switch (esym
.asym
.sc
)
4526 section
= bfd_make_section_old_way (abfd
, ".text");
4527 value
-= section
->vma
;
4530 section
= bfd_make_section_old_way (abfd
, ".data");
4531 value
-= section
->vma
;
4534 section
= bfd_make_section_old_way (abfd
, ".bss");
4535 value
-= section
->vma
;
4538 section
= bfd_abs_section_ptr
;
4541 section
= bfd_und_section_ptr
;
4544 section
= bfd_make_section_old_way (abfd
, ".sdata");
4545 value
-= section
->vma
;
4548 section
= bfd_make_section_old_way (abfd
, ".sbss");
4549 value
-= section
->vma
;
4552 section
= bfd_make_section_old_way (abfd
, ".rdata");
4553 value
-= section
->vma
;
4556 if (value
> ecoff_data (abfd
)->gp_size
)
4558 section
= bfd_com_section_ptr
;
4563 if (ecoff_scom_section
.name
== NULL
)
4565 /* Initialize the small common section. */
4566 ecoff_scom_section
.name
= SCOMMON
;
4567 ecoff_scom_section
.flags
= SEC_IS_COMMON
;
4568 ecoff_scom_section
.output_section
= &ecoff_scom_section
;
4569 ecoff_scom_section
.symbol
= &ecoff_scom_symbol
;
4570 ecoff_scom_section
.symbol_ptr_ptr
= &ecoff_scom_symbol_ptr
;
4571 ecoff_scom_symbol
.name
= SCOMMON
;
4572 ecoff_scom_symbol
.flags
= BSF_SECTION_SYM
;
4573 ecoff_scom_symbol
.section
= &ecoff_scom_section
;
4574 ecoff_scom_symbol_ptr
= &ecoff_scom_symbol
;
4576 section
= &ecoff_scom_section
;
4579 section
= bfd_und_section_ptr
;
4582 section
= bfd_make_section_old_way (abfd
, ".init");
4583 value
-= section
->vma
;
4586 section
= bfd_make_section_old_way (abfd
, ".fini");
4587 value
-= section
->vma
;
4591 if (section
== (asection
*) NULL
)
4594 name
= ssext
+ esym
.asym
.iss
;
4597 if (! (_bfd_generic_link_add_one_symbol
4598 (info
, abfd
, name
, BSF_GLOBAL
, section
, value
,
4599 (const char *) NULL
, true, true,
4600 (struct bfd_link_hash_entry
**) &h
)))
4605 /* If we are building an ECOFF hash table, save the external
4606 symbol information. */
4607 if (info
->hash
->creator
->flavour
== bfd_get_flavour (abfd
))
4609 if (h
->abfd
== (bfd
*) NULL
4610 || (! bfd_is_und_section (section
)
4611 && (! bfd_is_com_section (section
)
4612 || (h
->root
.type
!= bfd_link_hash_defined
4613 && h
->root
.type
!= bfd_link_hash_defweak
))))
4619 /* Remember whether this symbol was small undefined. */
4620 if (esym
.asym
.sc
== scSUndefined
)
4623 /* If this symbol was ever small undefined, it needs to wind
4624 up in a GP relative section. We can't control the
4625 section of a defined symbol, but we can control the
4626 section of a common symbol. This case is actually needed
4627 on Ultrix 4.2 to handle the symbol cred in -lckrb. */
4629 && h
->root
.type
== bfd_link_hash_common
4630 && strcmp (h
->root
.u
.c
.section
->name
, SCOMMON
) != 0)
4632 h
->root
.u
.c
.section
= bfd_make_section_old_way (abfd
, SCOMMON
);
4633 h
->root
.u
.c
.section
->flags
= SEC_ALLOC
;
4634 if (h
->esym
.asym
.sc
== scCommon
)
4635 h
->esym
.asym
.sc
= scSCommon
;
4643 /* ECOFF final link routines. */
4645 static boolean ecoff_final_link_debug_accumulate
4646 PARAMS ((bfd
*output_bfd
, bfd
*input_bfd
, struct bfd_link_info
*,
4648 static boolean ecoff_link_write_external
4649 PARAMS ((struct ecoff_link_hash_entry
*, PTR
));
4650 static boolean ecoff_indirect_link_order
4651 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
4652 struct bfd_link_order
*));
4653 static boolean ecoff_reloc_link_order
4654 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
4655 struct bfd_link_order
*));
4657 /* ECOFF final link routine. This looks through all the input BFDs
4658 and gathers together all the debugging information, and then
4659 processes all the link order information. This may cause it to
4660 close and reopen some input BFDs; I'll see how bad this is. */
4663 _bfd_ecoff_bfd_final_link (abfd
, info
)
4665 struct bfd_link_info
*info
;
4667 const struct ecoff_backend_data
* const backend
= ecoff_backend (abfd
);
4668 struct ecoff_debug_info
* const debug
= &ecoff_data (abfd
)->debug_info
;
4671 register bfd
*input_bfd
;
4673 struct bfd_link_order
*p
;
4675 /* We accumulate the debugging information counts in the symbolic
4677 symhdr
= &debug
->symbolic_header
;
4679 symhdr
->ilineMax
= 0;
4683 symhdr
->isymMax
= 0;
4684 symhdr
->ioptMax
= 0;
4685 symhdr
->iauxMax
= 0;
4687 symhdr
->issExtMax
= 0;
4690 symhdr
->iextMax
= 0;
4692 /* We accumulate the debugging information itself in the debug_info
4695 debug
->external_dnr
= NULL
;
4696 debug
->external_pdr
= NULL
;
4697 debug
->external_sym
= NULL
;
4698 debug
->external_opt
= NULL
;
4699 debug
->external_aux
= NULL
;
4701 debug
->ssext
= debug
->ssext_end
= NULL
;
4702 debug
->external_fdr
= NULL
;
4703 debug
->external_rfd
= NULL
;
4704 debug
->external_ext
= debug
->external_ext_end
= NULL
;
4706 handle
= bfd_ecoff_debug_init (abfd
, debug
, &backend
->debug_swap
, info
);
4707 if (handle
== (PTR
) NULL
)
4710 /* Accumulate the debugging symbols from each input BFD. */
4711 for (input_bfd
= info
->input_bfds
;
4712 input_bfd
!= (bfd
*) NULL
;
4713 input_bfd
= input_bfd
->link_next
)
4717 if (bfd_get_flavour (input_bfd
) == bfd_target_ecoff_flavour
)
4719 /* Abitrarily set the symbolic header vstamp to the vstamp
4720 of the first object file in the link. */
4721 if (symhdr
->vstamp
== 0)
4723 = ecoff_data (input_bfd
)->debug_info
.symbolic_header
.vstamp
;
4724 ret
= ecoff_final_link_debug_accumulate (abfd
, input_bfd
, info
,
4728 ret
= bfd_ecoff_debug_accumulate_other (handle
, abfd
,
4729 debug
, &backend
->debug_swap
,
4734 /* Combine the register masks. */
4735 ecoff_data (abfd
)->gprmask
|= ecoff_data (input_bfd
)->gprmask
;
4736 ecoff_data (abfd
)->fprmask
|= ecoff_data (input_bfd
)->fprmask
;
4737 ecoff_data (abfd
)->cprmask
[0] |= ecoff_data (input_bfd
)->cprmask
[0];
4738 ecoff_data (abfd
)->cprmask
[1] |= ecoff_data (input_bfd
)->cprmask
[1];
4739 ecoff_data (abfd
)->cprmask
[2] |= ecoff_data (input_bfd
)->cprmask
[2];
4740 ecoff_data (abfd
)->cprmask
[3] |= ecoff_data (input_bfd
)->cprmask
[3];
4743 /* Write out the external symbols. */
4744 ecoff_link_hash_traverse (ecoff_hash_table (info
),
4745 ecoff_link_write_external
,
4748 if (info
->relocateable
)
4750 /* We need to make a pass over the link_orders to count up the
4751 number of relocations we will need to output, so that we know
4752 how much space they will take up. */
4753 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4756 for (p
= o
->link_order_head
;
4757 p
!= (struct bfd_link_order
*) NULL
;
4759 if (p
->type
== bfd_indirect_link_order
)
4760 o
->reloc_count
+= p
->u
.indirect
.section
->reloc_count
;
4761 else if (p
->type
== bfd_section_reloc_link_order
4762 || p
->type
== bfd_symbol_reloc_link_order
)
4767 /* Compute the reloc and symbol file positions. */
4768 ecoff_compute_reloc_file_positions (abfd
);
4770 /* Write out the debugging information. */
4771 if (! bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
,
4772 &backend
->debug_swap
, info
,
4773 ecoff_data (abfd
)->sym_filepos
))
4776 bfd_ecoff_debug_free (handle
, abfd
, debug
, &backend
->debug_swap
, info
);
4778 if (info
->relocateable
)
4780 /* Now reset the reloc_count field of the sections in the output
4781 BFD to 0, so that we can use them to keep track of how many
4782 relocs we have output thus far. */
4783 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4787 /* Get a value for the GP register. */
4788 if (ecoff_data (abfd
)->gp
== 0)
4790 struct bfd_link_hash_entry
*h
;
4792 h
= bfd_link_hash_lookup (info
->hash
, "_gp", false, false, true);
4793 if (h
!= (struct bfd_link_hash_entry
*) NULL
4794 && h
->type
== bfd_link_hash_defined
)
4795 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
4796 + h
->u
.def
.section
->output_section
->vma
4797 + h
->u
.def
.section
->output_offset
);
4798 else if (info
->relocateable
)
4802 /* Make up a value. */
4804 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4807 && (strcmp (o
->name
, _SBSS
) == 0
4808 || strcmp (o
->name
, _SDATA
) == 0
4809 || strcmp (o
->name
, _LIT4
) == 0
4810 || strcmp (o
->name
, _LIT8
) == 0
4811 || strcmp (o
->name
, _LITA
) == 0))
4814 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
4818 /* If the relocate_section function needs to do a reloc
4819 involving the GP value, it should make a reloc_dangerous
4820 callback to warn that GP is not defined. */
4824 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4826 for (p
= o
->link_order_head
;
4827 p
!= (struct bfd_link_order
*) NULL
;
4830 if (p
->type
== bfd_indirect_link_order
4831 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4832 == bfd_target_ecoff_flavour
))
4834 if (! ecoff_indirect_link_order (abfd
, info
, o
, p
))
4837 else if (p
->type
== bfd_section_reloc_link_order
4838 || p
->type
== bfd_symbol_reloc_link_order
)
4840 if (! ecoff_reloc_link_order (abfd
, info
, o
, p
))
4845 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4851 bfd_get_symcount (abfd
) = symhdr
->iextMax
+ symhdr
->isymMax
;
4853 ecoff_data (abfd
)->linker
= true;
4858 /* Accumulate the debugging information for an input BFD into the
4859 output BFD. This must read in the symbolic information of the
4863 ecoff_final_link_debug_accumulate (output_bfd
, input_bfd
, info
, handle
)
4866 struct bfd_link_info
*info
;
4869 struct ecoff_debug_info
* const debug
= &ecoff_data (input_bfd
)->debug_info
;
4870 const struct ecoff_debug_swap
* const swap
=
4871 &ecoff_backend (input_bfd
)->debug_swap
;
4872 HDRR
*symhdr
= &debug
->symbolic_header
;
4875 #define READ(ptr, offset, count, size, type) \
4876 if (symhdr->count == 0) \
4877 debug->ptr = NULL; \
4880 debug->ptr = (type) malloc (size * symhdr->count); \
4881 if (debug->ptr == NULL) \
4883 bfd_set_error (bfd_error_no_memory); \
4885 goto return_something; \
4887 if ((bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) \
4889 || (bfd_read (debug->ptr, size, symhdr->count, \
4890 input_bfd) != size * symhdr->count)) \
4893 goto return_something; \
4897 /* If raw_syments is not NULL, then the data was already by read by
4898 _bfd_ecoff_slurp_symbolic_info. */
4899 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
4901 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char),
4903 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
4904 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
4905 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
4906 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
4907 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
4909 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
4910 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
4911 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
4915 /* We do not read the external strings or the external symbols. */
4917 ret
= (bfd_ecoff_debug_accumulate
4918 (handle
, output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
4919 &ecoff_backend (output_bfd
)->debug_swap
,
4920 input_bfd
, debug
, swap
, info
));
4923 if (ecoff_data (input_bfd
)->raw_syments
== NULL
)
4925 if (debug
->line
!= NULL
)
4927 if (debug
->external_dnr
!= NULL
)
4928 free (debug
->external_dnr
);
4929 if (debug
->external_pdr
!= NULL
)
4930 free (debug
->external_pdr
);
4931 if (debug
->external_sym
!= NULL
)
4932 free (debug
->external_sym
);
4933 if (debug
->external_opt
!= NULL
)
4934 free (debug
->external_opt
);
4935 if (debug
->external_aux
!= NULL
)
4936 free (debug
->external_aux
);
4937 if (debug
->ss
!= NULL
)
4939 if (debug
->external_fdr
!= NULL
)
4940 free (debug
->external_fdr
);
4941 if (debug
->external_rfd
!= NULL
)
4942 free (debug
->external_rfd
);
4944 /* Make sure we don't accidentally follow one of these pointers
4945 into freed memory. */
4947 debug
->external_dnr
= NULL
;
4948 debug
->external_pdr
= NULL
;
4949 debug
->external_sym
= NULL
;
4950 debug
->external_opt
= NULL
;
4951 debug
->external_aux
= NULL
;
4953 debug
->external_fdr
= NULL
;
4954 debug
->external_rfd
= NULL
;
4960 /* Put out information for an external symbol. These come only from
4964 ecoff_link_write_external (h
, data
)
4965 struct ecoff_link_hash_entry
*h
;
4968 bfd
*output_bfd
= (bfd
*) data
;
4970 /* FIXME: We should check if this symbol is being stripped. */
4975 if (h
->abfd
== (bfd
*) NULL
)
4978 h
->esym
.cobol_main
= 0;
4979 h
->esym
.weakext
= 0;
4980 h
->esym
.reserved
= 0;
4981 h
->esym
.ifd
= ifdNil
;
4982 h
->esym
.asym
.value
= 0;
4983 h
->esym
.asym
.st
= stGlobal
;
4985 if (h
->root
.type
!= bfd_link_hash_defined
4986 && h
->root
.type
!= bfd_link_hash_defweak
)
4987 h
->esym
.asym
.sc
= scAbs
;
4990 asection
*output_section
;
4993 output_section
= h
->root
.u
.def
.section
->output_section
;
4994 name
= bfd_section_name (output_section
->owner
, output_section
);
4996 if (strcmp (name
, _TEXT
) == 0)
4997 h
->esym
.asym
.sc
= scText
;
4998 else if (strcmp (name
, _DATA
) == 0)
4999 h
->esym
.asym
.sc
= scData
;
5000 else if (strcmp (name
, _SDATA
) == 0)
5001 h
->esym
.asym
.sc
= scSData
;
5002 else if (strcmp (name
, _RDATA
) == 0)
5003 h
->esym
.asym
.sc
= scRData
;
5004 else if (strcmp (name
, _BSS
) == 0)
5005 h
->esym
.asym
.sc
= scBss
;
5006 else if (strcmp (name
, _SBSS
) == 0)
5007 h
->esym
.asym
.sc
= scSBss
;
5008 else if (strcmp (name
, _INIT
) == 0)
5009 h
->esym
.asym
.sc
= scInit
;
5010 else if (strcmp (name
, _FINI
) == 0)
5011 h
->esym
.asym
.sc
= scFini
;
5012 else if (strcmp (name
, _PDATA
) == 0)
5013 h
->esym
.asym
.sc
= scPData
;
5014 else if (strcmp (name
, _XDATA
) == 0)
5015 h
->esym
.asym
.sc
= scXData
;
5017 h
->esym
.asym
.sc
= scAbs
;
5020 h
->esym
.asym
.reserved
= 0;
5021 h
->esym
.asym
.index
= indexNil
;
5023 else if (h
->esym
.ifd
!= -1)
5025 struct ecoff_debug_info
*debug
;
5027 /* Adjust the FDR index for the symbol by that used for the
5029 debug
= &ecoff_data (h
->abfd
)->debug_info
;
5030 BFD_ASSERT (h
->esym
.ifd
>= 0
5031 && h
->esym
.ifd
< debug
->symbolic_header
.ifdMax
);
5032 h
->esym
.ifd
= debug
->ifdmap
[h
->esym
.ifd
];
5035 switch (h
->root
.type
)
5038 case bfd_link_hash_new
:
5040 case bfd_link_hash_undefined
:
5041 case bfd_link_hash_undefweak
:
5042 if (h
->esym
.asym
.sc
!= scUndefined
5043 && h
->esym
.asym
.sc
!= scSUndefined
)
5044 h
->esym
.asym
.sc
= scUndefined
;
5046 case bfd_link_hash_defined
:
5047 case bfd_link_hash_defweak
:
5048 if (h
->esym
.asym
.sc
== scUndefined
5049 || h
->esym
.asym
.sc
== scSUndefined
)
5050 h
->esym
.asym
.sc
= scAbs
;
5051 else if (h
->esym
.asym
.sc
== scCommon
)
5052 h
->esym
.asym
.sc
= scBss
;
5053 else if (h
->esym
.asym
.sc
== scSCommon
)
5054 h
->esym
.asym
.sc
= scSBss
;
5055 h
->esym
.asym
.value
= (h
->root
.u
.def
.value
5056 + h
->root
.u
.def
.section
->output_section
->vma
5057 + h
->root
.u
.def
.section
->output_offset
);
5059 case bfd_link_hash_common
:
5060 if (h
->esym
.asym
.sc
!= scCommon
5061 && h
->esym
.asym
.sc
!= scSCommon
)
5062 h
->esym
.asym
.sc
= scCommon
;
5063 h
->esym
.asym
.value
= h
->root
.u
.c
.size
;
5065 case bfd_link_hash_indirect
:
5066 case bfd_link_hash_warning
:
5067 /* FIXME: Ignore these for now. The circumstances under which
5068 they should be written out are not clear to me. */
5072 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
5074 h
->indx
= ecoff_data (output_bfd
)->debug_info
.symbolic_header
.iextMax
;
5077 return (bfd_ecoff_debug_one_external
5078 (output_bfd
, &ecoff_data (output_bfd
)->debug_info
,
5079 &ecoff_backend (output_bfd
)->debug_swap
, h
->root
.root
.string
,
5083 /* Relocate and write an ECOFF section into an ECOFF output file. */
5086 ecoff_indirect_link_order (output_bfd
, info
, output_section
, link_order
)
5088 struct bfd_link_info
*info
;
5089 asection
*output_section
;
5090 struct bfd_link_order
*link_order
;
5092 asection
*input_section
;
5094 struct ecoff_section_tdata
*section_tdata
;
5095 bfd_size_type raw_size
;
5096 bfd_size_type cooked_size
;
5097 bfd_byte
*contents
= NULL
;
5098 bfd_size_type external_reloc_size
;
5099 bfd_size_type external_relocs_size
;
5100 PTR external_relocs
= NULL
;
5102 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
5104 if (link_order
->size
== 0)
5107 input_section
= link_order
->u
.indirect
.section
;
5108 input_bfd
= input_section
->owner
;
5109 section_tdata
= ecoff_section_data (input_bfd
, input_section
);
5111 raw_size
= input_section
->_raw_size
;
5112 cooked_size
= input_section
->_cooked_size
;
5113 if (cooked_size
== 0)
5114 cooked_size
= raw_size
;
5116 BFD_ASSERT (input_section
->output_section
== output_section
);
5117 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
5118 BFD_ASSERT (cooked_size
== link_order
->size
);
5120 /* Get the section contents. We allocate memory for the larger of
5121 the size before relocating and the size after relocating. */
5122 contents
= (bfd_byte
*) malloc (raw_size
>= cooked_size
5125 if (contents
== NULL
&& raw_size
!= 0)
5127 bfd_set_error (bfd_error_no_memory
);
5131 /* If we are relaxing, the contents may have already been read into
5132 memory, in which case we copy them into our new buffer. We don't
5133 simply reuse the old buffer in case cooked_size > raw_size. */
5134 if (section_tdata
!= (struct ecoff_section_tdata
*) NULL
5135 && section_tdata
->contents
!= (bfd_byte
*) NULL
)
5136 memcpy (contents
, section_tdata
->contents
, raw_size
);
5139 if (! bfd_get_section_contents (input_bfd
, input_section
,
5141 (file_ptr
) 0, raw_size
))
5145 /* Get the relocs. If we are relaxing MIPS code, they will already
5146 have been read in. Otherwise, we read them in now. */
5147 external_reloc_size
= ecoff_backend (input_bfd
)->external_reloc_size
;
5148 external_relocs_size
= external_reloc_size
* input_section
->reloc_count
;
5150 if (section_tdata
!= (struct ecoff_section_tdata
*) NULL
)
5151 external_relocs
= section_tdata
->external_relocs
;
5154 external_relocs
= (PTR
) malloc (external_relocs_size
);
5155 if (external_relocs
== NULL
&& external_relocs_size
!= 0)
5157 bfd_set_error (bfd_error_no_memory
);
5161 if (bfd_seek (input_bfd
, input_section
->rel_filepos
, SEEK_SET
) != 0
5162 || (bfd_read (external_relocs
, 1, external_relocs_size
, input_bfd
)
5163 != external_relocs_size
))
5167 /* Relocate the section contents. */
5168 if (! ((*ecoff_backend (input_bfd
)->relocate_section
)
5169 (output_bfd
, info
, input_bfd
, input_section
, contents
,
5173 /* Write out the relocated section. */
5174 if (! bfd_set_section_contents (output_bfd
,
5177 input_section
->output_offset
,
5181 /* If we are producing relocateable output, the relocs were
5182 modified, and we write them out now. We use the reloc_count
5183 field of output_section to keep track of the number of relocs we
5184 have output so far. */
5185 if (info
->relocateable
)
5187 if (bfd_seek (output_bfd
,
5188 (output_section
->rel_filepos
+
5189 output_section
->reloc_count
* external_reloc_size
),
5191 || (bfd_write (external_relocs
, 1, external_relocs_size
, output_bfd
)
5192 != external_relocs_size
))
5194 output_section
->reloc_count
+= input_section
->reloc_count
;
5197 if (contents
!= NULL
)
5199 if (external_relocs
!= NULL
&& section_tdata
== NULL
)
5200 free (external_relocs
);
5204 if (contents
!= NULL
)
5206 if (external_relocs
!= NULL
&& section_tdata
== NULL
)
5207 free (external_relocs
);
5211 /* Generate a reloc when linking an ECOFF file. This is a reloc
5212 requested by the linker, and does come from any input file. This
5213 is used to build constructor and destructor tables when linking
5217 ecoff_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
5219 struct bfd_link_info
*info
;
5220 asection
*output_section
;
5221 struct bfd_link_order
*link_order
;
5224 struct internal_reloc in
;
5225 bfd_size_type external_reloc_size
;
5229 /* We set up an arelent to pass to the backend adjust_reloc_out
5231 rel
.address
= link_order
->offset
;
5233 rel
.howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
5236 bfd_set_error (bfd_error_bad_value
);
5240 if (link_order
->type
== bfd_section_reloc_link_order
)
5241 rel
.sym_ptr_ptr
= link_order
->u
.reloc
.p
->u
.section
->symbol_ptr_ptr
;
5244 /* We can't set up a reloc against a symbol correctly, because
5245 we have no asymbol structure. Currently no adjust_reloc_out
5247 rel
.sym_ptr_ptr
= (asymbol
**) NULL
;
5250 /* All ECOFF relocs are in-place. Put the addend into the object
5253 BFD_ASSERT (rel
.howto
->partial_inplace
);
5254 if (link_order
->u
.reloc
.p
->addend
!= 0)
5257 bfd_reloc_status_type rstat
;
5261 size
= bfd_get_reloc_size (rel
.howto
);
5262 buf
= (bfd_byte
*) bfd_zmalloc (size
);
5263 if (buf
== (bfd_byte
*) NULL
)
5265 bfd_set_error (bfd_error_no_memory
);
5268 rstat
= _bfd_relocate_contents (rel
.howto
, output_bfd
,
5269 link_order
->u
.reloc
.p
->addend
, buf
);
5275 case bfd_reloc_outofrange
:
5277 case bfd_reloc_overflow
:
5278 if (! ((*info
->callbacks
->reloc_overflow
)
5280 (link_order
->type
== bfd_section_reloc_link_order
5281 ? bfd_section_name (output_bfd
,
5282 link_order
->u
.reloc
.p
->u
.section
)
5283 : link_order
->u
.reloc
.p
->u
.name
),
5284 rel
.howto
->name
, link_order
->u
.reloc
.p
->addend
,
5285 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
5292 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
5293 (file_ptr
) link_order
->offset
, size
);
5301 /* Move the information into a internal_reloc structure. */
5302 in
.r_vaddr
= (rel
.address
5303 + bfd_get_section_vma (output_bfd
, output_section
));
5304 in
.r_type
= rel
.howto
->type
;
5306 if (link_order
->type
== bfd_symbol_reloc_link_order
)
5308 struct ecoff_link_hash_entry
*h
;
5310 h
= ecoff_link_hash_lookup (ecoff_hash_table (info
),
5311 link_order
->u
.reloc
.p
->u
.name
,
5312 false, false, true);
5313 if (h
!= (struct ecoff_link_hash_entry
*) NULL
5315 in
.r_symndx
= h
->indx
;
5318 if (! ((*info
->callbacks
->unattached_reloc
)
5319 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
5320 (asection
*) NULL
, (bfd_vma
) 0)))
5330 name
= bfd_get_section_name (output_bfd
,
5331 link_order
->u
.reloc
.p
->u
.section
);
5332 if (strcmp (name
, ".text") == 0)
5333 in
.r_symndx
= RELOC_SECTION_TEXT
;
5334 else if (strcmp (name
, ".rdata") == 0)
5335 in
.r_symndx
= RELOC_SECTION_RDATA
;
5336 else if (strcmp (name
, ".data") == 0)
5337 in
.r_symndx
= RELOC_SECTION_DATA
;
5338 else if (strcmp (name
, ".sdata") == 0)
5339 in
.r_symndx
= RELOC_SECTION_SDATA
;
5340 else if (strcmp (name
, ".sbss") == 0)
5341 in
.r_symndx
= RELOC_SECTION_SBSS
;
5342 else if (strcmp (name
, ".bss") == 0)
5343 in
.r_symndx
= RELOC_SECTION_BSS
;
5344 else if (strcmp (name
, ".init") == 0)
5345 in
.r_symndx
= RELOC_SECTION_INIT
;
5346 else if (strcmp (name
, ".lit8") == 0)
5347 in
.r_symndx
= RELOC_SECTION_LIT8
;
5348 else if (strcmp (name
, ".lit4") == 0)
5349 in
.r_symndx
= RELOC_SECTION_LIT4
;
5350 else if (strcmp (name
, ".xdata") == 0)
5351 in
.r_symndx
= RELOC_SECTION_XDATA
;
5352 else if (strcmp (name
, ".pdata") == 0)
5353 in
.r_symndx
= RELOC_SECTION_PDATA
;
5354 else if (strcmp (name
, ".fini") == 0)
5355 in
.r_symndx
= RELOC_SECTION_FINI
;
5356 else if (strcmp (name
, ".lita") == 0)
5357 in
.r_symndx
= RELOC_SECTION_LITA
;
5358 else if (strcmp (name
, "*ABS*") == 0)
5359 in
.r_symndx
= RELOC_SECTION_ABS
;
5365 /* Let the BFD backend adjust the reloc. */
5366 (*ecoff_backend (output_bfd
)->adjust_reloc_out
) (output_bfd
, &rel
, &in
);
5368 /* Get some memory and swap out the reloc. */
5369 external_reloc_size
= ecoff_backend (output_bfd
)->external_reloc_size
;
5370 rbuf
= (bfd_byte
*) malloc (external_reloc_size
);
5371 if (rbuf
== (bfd_byte
*) NULL
)
5373 bfd_set_error (bfd_error_no_memory
);
5377 (*ecoff_backend (output_bfd
)->swap_reloc_out
) (output_bfd
, &in
, (PTR
) rbuf
);
5379 ok
= (bfd_seek (output_bfd
,
5380 (output_section
->rel_filepos
+
5381 output_section
->reloc_count
* external_reloc_size
),
5383 && (bfd_write ((PTR
) rbuf
, 1, external_reloc_size
, output_bfd
)
5384 == external_reloc_size
));
5387 ++output_section
->reloc_count
;