1 /* Routines to link ECOFF debugging information.
2 Copyright (C) 1993-2020 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support, <ian@cygnus.com>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
26 #include "ecoff-bfd.h"
28 #include "aout/stab_gnu.h"
29 #include "coff/internal.h"
31 #include "coff/symconst.h"
32 #include "coff/ecoff.h"
36 /* Routines to swap auxiliary information in and out. I am assuming
37 that the auxiliary information format is always going to be target
40 /* Swap in a type information record.
41 BIGEND says whether AUX symbols are big-endian or little-endian; this
42 info comes from the file header record (fh-fBigendian). */
45 _bfd_ecoff_swap_tir_in (int bigend
, const struct tir_ext
*ext_copy
,
48 struct tir_ext ext
[1];
50 *ext
= *ext_copy
; /* Make it reasonable to do in-place. */
52 /* now the fun stuff... */
55 intern
->fBitfield
= 0 != (ext
->t_bits1
[0] & TIR_BITS1_FBITFIELD_BIG
);
56 intern
->continued
= 0 != (ext
->t_bits1
[0] & TIR_BITS1_CONTINUED_BIG
);
57 intern
->bt
= (ext
->t_bits1
[0] & TIR_BITS1_BT_BIG
)
58 >> TIR_BITS1_BT_SH_BIG
;
59 intern
->tq4
= (ext
->t_tq45
[0] & TIR_BITS_TQ4_BIG
)
60 >> TIR_BITS_TQ4_SH_BIG
;
61 intern
->tq5
= (ext
->t_tq45
[0] & TIR_BITS_TQ5_BIG
)
62 >> TIR_BITS_TQ5_SH_BIG
;
63 intern
->tq0
= (ext
->t_tq01
[0] & TIR_BITS_TQ0_BIG
)
64 >> TIR_BITS_TQ0_SH_BIG
;
65 intern
->tq1
= (ext
->t_tq01
[0] & TIR_BITS_TQ1_BIG
)
66 >> TIR_BITS_TQ1_SH_BIG
;
67 intern
->tq2
= (ext
->t_tq23
[0] & TIR_BITS_TQ2_BIG
)
68 >> TIR_BITS_TQ2_SH_BIG
;
69 intern
->tq3
= (ext
->t_tq23
[0] & TIR_BITS_TQ3_BIG
)
70 >> TIR_BITS_TQ3_SH_BIG
;
74 intern
->fBitfield
= 0 != (ext
->t_bits1
[0] & TIR_BITS1_FBITFIELD_LITTLE
);
75 intern
->continued
= 0 != (ext
->t_bits1
[0] & TIR_BITS1_CONTINUED_LITTLE
);
76 intern
->bt
= (ext
->t_bits1
[0] & TIR_BITS1_BT_LITTLE
)
77 >> TIR_BITS1_BT_SH_LITTLE
;
78 intern
->tq4
= (ext
->t_tq45
[0] & TIR_BITS_TQ4_LITTLE
)
79 >> TIR_BITS_TQ4_SH_LITTLE
;
80 intern
->tq5
= (ext
->t_tq45
[0] & TIR_BITS_TQ5_LITTLE
)
81 >> TIR_BITS_TQ5_SH_LITTLE
;
82 intern
->tq0
= (ext
->t_tq01
[0] & TIR_BITS_TQ0_LITTLE
)
83 >> TIR_BITS_TQ0_SH_LITTLE
;
84 intern
->tq1
= (ext
->t_tq01
[0] & TIR_BITS_TQ1_LITTLE
)
85 >> TIR_BITS_TQ1_SH_LITTLE
;
86 intern
->tq2
= (ext
->t_tq23
[0] & TIR_BITS_TQ2_LITTLE
)
87 >> TIR_BITS_TQ2_SH_LITTLE
;
88 intern
->tq3
= (ext
->t_tq23
[0] & TIR_BITS_TQ3_LITTLE
)
89 >> TIR_BITS_TQ3_SH_LITTLE
;
93 if (memcmp ((char *)ext
, (char *)intern
, sizeof (*intern
)) != 0)
98 /* Swap out a type information record.
99 BIGEND says whether AUX symbols are big-endian or little-endian; this
100 info comes from the file header record (fh-fBigendian). */
103 _bfd_ecoff_swap_tir_out (int bigend
,
104 const TIR
*intern_copy
,
109 *intern
= *intern_copy
; /* Make it reasonable to do in-place. */
111 /* now the fun stuff... */
114 ext
->t_bits1
[0] = ((intern
->fBitfield
? TIR_BITS1_FBITFIELD_BIG
: 0)
115 | (intern
->continued
? TIR_BITS1_CONTINUED_BIG
: 0)
116 | ((intern
->bt
<< TIR_BITS1_BT_SH_BIG
)
117 & TIR_BITS1_BT_BIG
));
118 ext
->t_tq45
[0] = (((intern
->tq4
<< TIR_BITS_TQ4_SH_BIG
)
120 | ((intern
->tq5
<< TIR_BITS_TQ5_SH_BIG
)
121 & TIR_BITS_TQ5_BIG
));
122 ext
->t_tq01
[0] = (((intern
->tq0
<< TIR_BITS_TQ0_SH_BIG
)
124 | ((intern
->tq1
<< TIR_BITS_TQ1_SH_BIG
)
125 & TIR_BITS_TQ1_BIG
));
126 ext
->t_tq23
[0] = (((intern
->tq2
<< TIR_BITS_TQ2_SH_BIG
)
128 | ((intern
->tq3
<< TIR_BITS_TQ3_SH_BIG
)
129 & TIR_BITS_TQ3_BIG
));
133 ext
->t_bits1
[0] = ((intern
->fBitfield
? TIR_BITS1_FBITFIELD_LITTLE
: 0)
134 | (intern
->continued
? TIR_BITS1_CONTINUED_LITTLE
: 0)
135 | ((intern
->bt
<< TIR_BITS1_BT_SH_LITTLE
)
136 & TIR_BITS1_BT_LITTLE
));
137 ext
->t_tq45
[0] = (((intern
->tq4
<< TIR_BITS_TQ4_SH_LITTLE
)
138 & TIR_BITS_TQ4_LITTLE
)
139 | ((intern
->tq5
<< TIR_BITS_TQ5_SH_LITTLE
)
140 & TIR_BITS_TQ5_LITTLE
));
141 ext
->t_tq01
[0] = (((intern
->tq0
<< TIR_BITS_TQ0_SH_LITTLE
)
142 & TIR_BITS_TQ0_LITTLE
)
143 | ((intern
->tq1
<< TIR_BITS_TQ1_SH_LITTLE
)
144 & TIR_BITS_TQ1_LITTLE
));
145 ext
->t_tq23
[0] = (((intern
->tq2
<< TIR_BITS_TQ2_SH_LITTLE
)
146 & TIR_BITS_TQ2_LITTLE
)
147 | ((intern
->tq3
<< TIR_BITS_TQ3_SH_LITTLE
)
148 & TIR_BITS_TQ3_LITTLE
));
152 if (memcmp ((char *)ext
, (char *)intern
, sizeof (*intern
)) != 0)
157 /* Swap in a relative symbol record. BIGEND says whether it is in
158 big-endian or little-endian format.*/
161 _bfd_ecoff_swap_rndx_in (int bigend
,
162 const struct rndx_ext
*ext_copy
,
165 struct rndx_ext ext
[1];
167 *ext
= *ext_copy
; /* Make it reasonable to do in-place. */
169 /* now the fun stuff... */
172 intern
->rfd
= (ext
->r_bits
[0] << RNDX_BITS0_RFD_SH_LEFT_BIG
)
173 | ((ext
->r_bits
[1] & RNDX_BITS1_RFD_BIG
)
174 >> RNDX_BITS1_RFD_SH_BIG
);
175 intern
->index
= ((ext
->r_bits
[1] & RNDX_BITS1_INDEX_BIG
)
176 << RNDX_BITS1_INDEX_SH_LEFT_BIG
)
177 | (ext
->r_bits
[2] << RNDX_BITS2_INDEX_SH_LEFT_BIG
)
178 | (ext
->r_bits
[3] << RNDX_BITS3_INDEX_SH_LEFT_BIG
);
182 intern
->rfd
= (ext
->r_bits
[0] << RNDX_BITS0_RFD_SH_LEFT_LITTLE
)
183 | ((ext
->r_bits
[1] & RNDX_BITS1_RFD_LITTLE
)
184 << RNDX_BITS1_RFD_SH_LEFT_LITTLE
);
185 intern
->index
= ((ext
->r_bits
[1] & RNDX_BITS1_INDEX_LITTLE
)
186 >> RNDX_BITS1_INDEX_SH_LITTLE
)
187 | (ext
->r_bits
[2] << RNDX_BITS2_INDEX_SH_LEFT_LITTLE
)
188 | ((unsigned int) ext
->r_bits
[3]
189 << RNDX_BITS3_INDEX_SH_LEFT_LITTLE
);
193 if (memcmp ((char *)ext
, (char *)intern
, sizeof (*intern
)) != 0)
198 /* Swap out a relative symbol record. BIGEND says whether it is in
199 big-endian or little-endian format.*/
202 _bfd_ecoff_swap_rndx_out (int bigend
,
203 const RNDXR
*intern_copy
,
204 struct rndx_ext
*ext
)
208 *intern
= *intern_copy
; /* Make it reasonable to do in-place. */
210 /* now the fun stuff... */
213 ext
->r_bits
[0] = intern
->rfd
>> RNDX_BITS0_RFD_SH_LEFT_BIG
;
214 ext
->r_bits
[1] = (((intern
->rfd
<< RNDX_BITS1_RFD_SH_BIG
)
215 & RNDX_BITS1_RFD_BIG
)
216 | ((intern
->index
>> RNDX_BITS1_INDEX_SH_LEFT_BIG
)
217 & RNDX_BITS1_INDEX_BIG
));
218 ext
->r_bits
[2] = intern
->index
>> RNDX_BITS2_INDEX_SH_LEFT_BIG
;
219 ext
->r_bits
[3] = intern
->index
>> RNDX_BITS3_INDEX_SH_LEFT_BIG
;
223 ext
->r_bits
[0] = intern
->rfd
>> RNDX_BITS0_RFD_SH_LEFT_LITTLE
;
224 ext
->r_bits
[1] = (((intern
->rfd
>> RNDX_BITS1_RFD_SH_LEFT_LITTLE
)
225 & RNDX_BITS1_RFD_LITTLE
)
226 | ((intern
->index
<< RNDX_BITS1_INDEX_SH_LITTLE
)
227 & RNDX_BITS1_INDEX_LITTLE
));
228 ext
->r_bits
[2] = intern
->index
>> RNDX_BITS2_INDEX_SH_LEFT_LITTLE
;
229 ext
->r_bits
[3] = intern
->index
>> RNDX_BITS3_INDEX_SH_LEFT_LITTLE
;
233 if (memcmp ((char *)ext
, (char *)intern
, sizeof (*intern
)) != 0)
238 /* The minimum amount of data to allocate. */
239 #define ALLOC_SIZE (4064)
241 /* Add bytes to a buffer. Return success. */
244 ecoff_add_bytes (char **buf
, char **bufend
, size_t need
)
250 have
= *bufend
- *buf
;
256 if (want
< ALLOC_SIZE
)
259 newbuf
= (char *) bfd_realloc (*buf
, (bfd_size_type
) have
+ want
);
263 *bufend
= *buf
+ have
+ want
;
267 /* We keep a hash table which maps strings to numbers. We use it to
268 map FDR names to indices in the output file, and to map local
269 strings when combining stabs debugging information. */
271 struct string_hash_entry
273 struct bfd_hash_entry root
;
274 /* FDR index or string table offset. */
276 /* Next entry in string table. */
277 struct string_hash_entry
*next
;
280 struct string_hash_table
282 struct bfd_hash_table table
;
285 /* Routine to create an entry in a string hash table. */
287 static struct bfd_hash_entry
*
288 string_hash_newfunc (struct bfd_hash_entry
*entry
,
289 struct bfd_hash_table
*table
,
292 struct string_hash_entry
*ret
= (struct string_hash_entry
*) entry
;
294 /* Allocate the structure if it has not already been allocated by a
296 if (ret
== (struct string_hash_entry
*) NULL
)
297 ret
= ((struct string_hash_entry
*)
298 bfd_hash_allocate (table
, sizeof (struct string_hash_entry
)));
299 if (ret
== (struct string_hash_entry
*) NULL
)
302 /* Call the allocation method of the superclass. */
303 ret
= ((struct string_hash_entry
*)
304 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
308 /* Initialize the local fields. */
313 return (struct bfd_hash_entry
*) ret
;
316 /* Look up an entry in an string hash table. */
318 #define string_hash_lookup(t, string, create, copy) \
319 ((struct string_hash_entry *) \
320 bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
322 /* We can't afford to read in all the debugging information when we do
323 a link. Instead, we build a list of these structures to show how
324 different parts of the input file map to the output file. */
328 /* The next entry in this linked list. */
329 struct shuffle
*next
;
330 /* The length of the information. */
332 /* Whether this information comes from a file or not. */
338 /* The BFD the data comes from. */
340 /* The offset within input_bfd. */
343 /* The data to be written out. */
348 /* This structure holds information across calls to
349 bfd_ecoff_debug_accumulate. */
353 /* The FDR hash table. */
354 struct string_hash_table fdr_hash
;
355 /* The strings hash table. */
356 struct string_hash_table str_hash
;
357 /* Linked lists describing how to shuffle the input debug
358 information into the output file. We keep a pointer to both the
359 head and the tail. */
360 struct shuffle
*line
;
361 struct shuffle
*line_end
;
363 struct shuffle
*pdr_end
;
365 struct shuffle
*sym_end
;
367 struct shuffle
*opt_end
;
369 struct shuffle
*aux_end
;
371 struct shuffle
*ss_end
;
372 struct string_hash_entry
*ss_hash
;
373 struct string_hash_entry
*ss_hash_end
;
375 struct shuffle
*fdr_end
;
377 struct shuffle
*rfd_end
;
378 /* The size of the largest file shuffle. */
379 unsigned long largest_file_shuffle
;
380 /* An objalloc for debugging information. */
381 struct objalloc
*memory
;
384 /* Add a file entry to a shuffle list. */
387 add_file_shuffle (struct accumulate
*ainfo
,
388 struct shuffle
**head
,
389 struct shuffle
**tail
,
396 if (*tail
!= (struct shuffle
*) NULL
398 && (*tail
)->u
.file
.input_bfd
== input_bfd
399 && (*tail
)->u
.file
.offset
+ (*tail
)->size
== (unsigned long) offset
)
401 /* Just merge this entry onto the existing one. */
402 (*tail
)->size
+= size
;
403 if ((*tail
)->size
> ainfo
->largest_file_shuffle
)
404 ainfo
->largest_file_shuffle
= (*tail
)->size
;
408 n
= (struct shuffle
*) objalloc_alloc (ainfo
->memory
,
409 sizeof (struct shuffle
));
412 bfd_set_error (bfd_error_no_memory
);
418 n
->u
.file
.input_bfd
= input_bfd
;
419 n
->u
.file
.offset
= offset
;
420 if (*head
== (struct shuffle
*) NULL
)
422 if (*tail
!= (struct shuffle
*) NULL
)
425 if (size
> ainfo
->largest_file_shuffle
)
426 ainfo
->largest_file_shuffle
= size
;
430 /* Add a memory entry to a shuffle list. */
433 add_memory_shuffle (struct accumulate
*ainfo
,
434 struct shuffle
**head
,
435 struct shuffle
**tail
,
441 n
= (struct shuffle
*) objalloc_alloc (ainfo
->memory
,
442 sizeof (struct shuffle
));
445 bfd_set_error (bfd_error_no_memory
);
452 if (*head
== (struct shuffle
*) NULL
)
454 if (*tail
!= (struct shuffle
*) NULL
)
460 /* Initialize the FDR hash table. This returns a handle which is then
461 passed in to bfd_ecoff_debug_accumulate, et. al. */
464 bfd_ecoff_debug_init (bfd
*output_bfd ATTRIBUTE_UNUSED
,
465 struct ecoff_debug_info
*output_debug
,
466 const struct ecoff_debug_swap
*output_swap ATTRIBUTE_UNUSED
,
467 struct bfd_link_info
*info
)
469 struct accumulate
*ainfo
;
470 size_t amt
= sizeof (struct accumulate
);
472 ainfo
= (struct accumulate
*) bfd_malloc (amt
);
475 if (!bfd_hash_table_init_n (&ainfo
->fdr_hash
.table
, string_hash_newfunc
,
476 sizeof (struct string_hash_entry
), 1021))
480 ainfo
->line_end
= NULL
;
482 ainfo
->pdr_end
= NULL
;
484 ainfo
->sym_end
= NULL
;
486 ainfo
->opt_end
= NULL
;
488 ainfo
->aux_end
= NULL
;
490 ainfo
->ss_end
= NULL
;
491 ainfo
->ss_hash
= NULL
;
492 ainfo
->ss_hash_end
= NULL
;
494 ainfo
->fdr_end
= NULL
;
496 ainfo
->rfd_end
= NULL
;
498 ainfo
->largest_file_shuffle
= 0;
500 if (! bfd_link_relocatable (info
))
502 if (!bfd_hash_table_init (&ainfo
->str_hash
.table
, string_hash_newfunc
,
503 sizeof (struct string_hash_entry
)))
506 /* The first entry in the string table is the empty string. */
507 output_debug
->symbolic_header
.issMax
= 1;
510 ainfo
->memory
= objalloc_create ();
511 if (ainfo
->memory
== NULL
)
513 bfd_set_error (bfd_error_no_memory
);
520 /* Free the accumulated debugging information. */
523 bfd_ecoff_debug_free (void * handle
,
524 bfd
*output_bfd ATTRIBUTE_UNUSED
,
525 struct ecoff_debug_info
*output_debug ATTRIBUTE_UNUSED
,
526 const struct ecoff_debug_swap
*output_swap ATTRIBUTE_UNUSED
,
527 struct bfd_link_info
*info
)
529 struct accumulate
*ainfo
= (struct accumulate
*) handle
;
531 bfd_hash_table_free (&ainfo
->fdr_hash
.table
);
533 if (! bfd_link_relocatable (info
))
534 bfd_hash_table_free (&ainfo
->str_hash
.table
);
536 objalloc_free (ainfo
->memory
);
541 /* Accumulate the debugging information from INPUT_BFD into
542 OUTPUT_BFD. The INPUT_DEBUG argument points to some ECOFF
543 debugging information which we want to link into the information
544 pointed to by the OUTPUT_DEBUG argument. OUTPUT_SWAP and
545 INPUT_SWAP point to the swapping information needed. INFO is the
546 linker information structure. HANDLE is returned by
547 bfd_ecoff_debug_init. */
550 bfd_ecoff_debug_accumulate (void * handle
,
552 struct ecoff_debug_info
*output_debug
,
553 const struct ecoff_debug_swap
*output_swap
,
555 struct ecoff_debug_info
*input_debug
,
556 const struct ecoff_debug_swap
*input_swap
,
557 struct bfd_link_info
*info
)
559 struct accumulate
*ainfo
= (struct accumulate
*) handle
;
560 void (* const swap_sym_in
) (bfd
*, void *, SYMR
*)
561 = input_swap
->swap_sym_in
;
562 void (* const swap_rfd_in
) (bfd
*, void *, RFDT
*)
563 = input_swap
->swap_rfd_in
;
564 void (* const swap_sym_out
) (bfd
*, const SYMR
*, void *)
565 = output_swap
->swap_sym_out
;
566 void (* const swap_fdr_out
) (bfd
*, const FDR
*, void *)
567 = output_swap
->swap_fdr_out
;
568 void (* const swap_rfd_out
) (bfd
*, const RFDT
*, void *)
569 = output_swap
->swap_rfd_out
;
570 bfd_size_type external_pdr_size
= output_swap
->external_pdr_size
;
571 bfd_size_type external_sym_size
= output_swap
->external_sym_size
;
572 bfd_size_type external_opt_size
= output_swap
->external_opt_size
;
573 bfd_size_type external_fdr_size
= output_swap
->external_fdr_size
;
574 bfd_size_type external_rfd_size
= output_swap
->external_rfd_size
;
575 HDRR
* const output_symhdr
= &output_debug
->symbolic_header
;
576 HDRR
* const input_symhdr
= &input_debug
->symbolic_header
;
577 bfd_vma section_adjust
[scMax
];
582 bfd_size_type fdr_add
;
594 /* Use section_adjust to hold the value to add to a symbol in a
595 particular section. */
596 memset (section_adjust
, 0, sizeof section_adjust
);
598 #define SET(name, indx) \
599 sec = bfd_get_section_by_name (input_bfd, name); \
601 section_adjust[indx] = (sec->output_section->vma \
602 + sec->output_offset \
605 SET (".text", scText
);
606 SET (".data", scData
);
608 SET (".sdata", scSData
);
609 SET (".sbss", scSBss
);
610 /* scRdata section may be either .rdata or .rodata. */
611 SET (".rdata", scRData
);
612 SET (".rodata", scRData
);
613 SET (".init", scInit
);
614 SET (".fini", scFini
);
615 SET (".rconst", scRConst
);
619 /* Find all the debugging information based on the FDR's. We need
620 to handle them whether they are swapped or not. */
621 if (input_debug
->fdr
!= (FDR
*) NULL
)
623 fdr_start
= (bfd_byte
*) input_debug
->fdr
;
624 fdr_add
= sizeof (FDR
);
628 fdr_start
= (bfd_byte
*) input_debug
->external_fdr
;
629 fdr_add
= input_swap
->external_fdr_size
;
631 fdr_end
= fdr_start
+ input_symhdr
->ifdMax
* fdr_add
;
633 amt
= input_symhdr
->ifdMax
;
634 amt
*= sizeof (RFDT
);
635 input_debug
->ifdmap
= (RFDT
*) bfd_alloc (input_bfd
, amt
);
637 sz
= (input_symhdr
->crfd
+ input_symhdr
->ifdMax
) * external_rfd_size
;
638 rfd_out
= (bfd_byte
*) objalloc_alloc (ainfo
->memory
, sz
);
639 if (!input_debug
->ifdmap
|| !rfd_out
)
641 bfd_set_error (bfd_error_no_memory
);
644 if (!add_memory_shuffle (ainfo
, &ainfo
->rfd
, &ainfo
->rfd_end
, rfd_out
, sz
))
649 /* Look through the FDR's to see which ones we are going to include
650 in the final output. We do not want duplicate FDR information
651 for header files, because ECOFF debugging is often very large.
652 When we find an FDR with no line information which can be merged,
653 we look it up in a hash table to ensure that we only include it
654 once. We keep a table mapping FDR numbers to the final number
655 they get with the BFD, so that we can refer to it when we write
656 out the external symbols. */
657 for (fdr_ptr
= fdr_start
, i
= 0;
659 fdr_ptr
+= fdr_add
, i
++, rfd_out
+= external_rfd_size
)
663 if (input_debug
->fdr
!= (FDR
*) NULL
)
664 fdr
= *(FDR
*) fdr_ptr
;
666 (*input_swap
->swap_fdr_in
) (input_bfd
, fdr_ptr
, &fdr
);
668 /* See if this FDR can be merged with an existing one. */
669 if (fdr
.cbLine
== 0 && fdr
.rss
!= -1 && fdr
.fMerge
)
673 struct string_hash_entry
*fh
;
675 /* We look up a string formed from the file name and the
676 number of symbols and aux entries. Sometimes an include
677 file will conditionally define a typedef or something
678 based on the order of include files. Using the number of
679 symbols and aux entries as a hash reduces the chance that
680 we will merge symbol information that should not be
682 name
= input_debug
->ss
+ fdr
.issBase
+ fdr
.rss
;
684 lookup
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
) + 20);
687 sprintf (lookup
, "%s %lx %lx", name
, (unsigned long) fdr
.csym
,
688 (unsigned long) fdr
.caux
);
690 fh
= string_hash_lookup (&ainfo
->fdr_hash
, lookup
, TRUE
, TRUE
);
692 if (fh
== (struct string_hash_entry
*) NULL
)
697 input_debug
->ifdmap
[i
] = fh
->val
;
698 (*swap_rfd_out
) (output_bfd
, input_debug
->ifdmap
+ i
, rfd_out
);
700 /* Don't copy this FDR. */
704 fh
->val
= output_symhdr
->ifdMax
+ copied
;
707 input_debug
->ifdmap
[i
] = output_symhdr
->ifdMax
+ copied
;
708 (*swap_rfd_out
) (output_bfd
, input_debug
->ifdmap
+ i
, rfd_out
);
712 newrfdbase
= output_symhdr
->crfd
;
713 output_symhdr
->crfd
+= input_symhdr
->ifdMax
;
715 /* Copy over any existing RFD's. RFD's are only created by the
716 linker, so this will only happen for input files which are the
717 result of a partial link. */
718 rfd_in
= (bfd_byte
*) input_debug
->external_rfd
;
719 rfd_end
= rfd_in
+ input_symhdr
->crfd
* input_swap
->external_rfd_size
;
722 rfd_in
+= input_swap
->external_rfd_size
)
726 (*swap_rfd_in
) (input_bfd
, rfd_in
, &rfd
);
727 BFD_ASSERT (rfd
>= 0 && rfd
< input_symhdr
->ifdMax
);
728 rfd
= input_debug
->ifdmap
[rfd
];
729 (*swap_rfd_out
) (output_bfd
, &rfd
, rfd_out
);
730 rfd_out
+= external_rfd_size
;
733 oldrfdbase
= output_symhdr
->crfd
;
734 output_symhdr
->crfd
+= input_symhdr
->crfd
;
736 /* Look through the FDR's and copy over all associated debugging
738 sz
= copied
* external_fdr_size
;
739 fdr_out
= (bfd_byte
*) objalloc_alloc (ainfo
->memory
, sz
);
742 bfd_set_error (bfd_error_no_memory
);
745 if (!add_memory_shuffle (ainfo
, &ainfo
->fdr
, &ainfo
->fdr_end
, fdr_out
, sz
))
747 for (fdr_ptr
= fdr_start
, i
= 0;
749 fdr_ptr
+= fdr_add
, i
++)
755 bfd_boolean fgotfilename
;
757 if (input_debug
->ifdmap
[i
] < output_symhdr
->ifdMax
)
759 /* We are not copying this FDR. */
763 if (input_debug
->fdr
!= (FDR
*) NULL
)
764 fdr
= *(FDR
*) fdr_ptr
;
766 (*input_swap
->swap_fdr_in
) (input_bfd
, fdr_ptr
, &fdr
);
768 /* FIXME: It is conceivable that this FDR points to the .init or
769 .fini section, in which case this will not do the right
771 fdr
.adr
+= section_adjust
[scText
];
773 /* Swap in the local symbols, adjust their values, and swap them
775 fgotfilename
= FALSE
;
776 sz
= fdr
.csym
* external_sym_size
;
777 sym_out
= (bfd_byte
*) objalloc_alloc (ainfo
->memory
, sz
);
780 bfd_set_error (bfd_error_no_memory
);
783 if (!add_memory_shuffle (ainfo
, &ainfo
->sym
, &ainfo
->sym_end
, sym_out
,
786 lraw_src
= ((bfd_byte
*) input_debug
->external_sym
787 + fdr
.isymBase
* input_swap
->external_sym_size
);
788 lraw_end
= lraw_src
+ fdr
.csym
* input_swap
->external_sym_size
;
789 for (; lraw_src
< lraw_end
; lraw_src
+= input_swap
->external_sym_size
)
793 (*swap_sym_in
) (input_bfd
, lraw_src
, &internal_sym
);
795 BFD_ASSERT (internal_sym
.sc
!= scCommon
796 && internal_sym
.sc
!= scSCommon
);
798 /* Adjust the symbol value if appropriate. */
799 switch (internal_sym
.st
)
802 if (ECOFF_IS_STAB (&internal_sym
))
810 internal_sym
.value
+= section_adjust
[internal_sym
.sc
];
817 /* If we are doing a final link, we hash all the strings in
818 the local symbol table together. This reduces the amount
819 of space required by debugging information. We don't do
820 this when performing a relocatable link because it would
821 prevent us from easily merging different FDR's. */
822 if (! bfd_link_relocatable (info
))
824 bfd_boolean ffilename
;
827 if (! fgotfilename
&& internal_sym
.iss
== fdr
.rss
)
832 /* Hash the name into the string table. */
833 name
= input_debug
->ss
+ fdr
.issBase
+ internal_sym
.iss
;
835 internal_sym
.iss
= 0;
838 struct string_hash_entry
*sh
;
840 sh
= string_hash_lookup (&ainfo
->str_hash
, name
, TRUE
, TRUE
);
841 if (sh
== (struct string_hash_entry
*) NULL
)
845 sh
->val
= output_symhdr
->issMax
;
846 output_symhdr
->issMax
+= strlen (name
) + 1;
847 if (ainfo
->ss_hash
== (struct string_hash_entry
*) NULL
)
849 if (ainfo
->ss_hash_end
850 != (struct string_hash_entry
*) NULL
)
851 ainfo
->ss_hash_end
->next
= sh
;
852 ainfo
->ss_hash_end
= sh
;
854 internal_sym
.iss
= sh
->val
;
859 fdr
.rss
= internal_sym
.iss
;
864 (*swap_sym_out
) (output_bfd
, &internal_sym
, sym_out
);
865 sym_out
+= external_sym_size
;
868 fdr
.isymBase
= output_symhdr
->isymMax
;
869 output_symhdr
->isymMax
+= fdr
.csym
;
871 /* Copy the information that does not need swapping. */
873 /* FIXME: If we are relaxing, we need to adjust the line
874 numbers. Frankly, forget it. Anybody using stabs debugging
875 information will not use this line number information, and
876 stabs are adjusted correctly. */
879 file_ptr pos
= input_symhdr
->cbLineOffset
+ fdr
.cbLineOffset
;
880 if (!add_file_shuffle (ainfo
, &ainfo
->line
, &ainfo
->line_end
,
881 input_bfd
, pos
, (unsigned long) fdr
.cbLine
))
883 fdr
.ilineBase
= output_symhdr
->ilineMax
;
884 fdr
.cbLineOffset
= output_symhdr
->cbLine
;
885 output_symhdr
->ilineMax
+= fdr
.cline
;
886 output_symhdr
->cbLine
+= fdr
.cbLine
;
890 file_ptr pos
= (input_symhdr
->cbAuxOffset
891 + fdr
.iauxBase
* sizeof (union aux_ext
));
892 if (!add_file_shuffle (ainfo
, &ainfo
->aux
, &ainfo
->aux_end
,
894 fdr
.caux
* sizeof (union aux_ext
)))
896 fdr
.iauxBase
= output_symhdr
->iauxMax
;
897 output_symhdr
->iauxMax
+= fdr
.caux
;
899 if (! bfd_link_relocatable (info
))
902 /* When we are hashing strings, we lie about the number of
903 strings attached to each FDR. We need to set cbSs
904 because some versions of dbx apparently use it to decide
905 how much of the string table to read in. */
907 fdr
.cbSs
= output_symhdr
->issMax
;
909 else if (fdr
.cbSs
> 0)
911 file_ptr pos
= input_symhdr
->cbSsOffset
+ fdr
.issBase
;
912 if (!add_file_shuffle (ainfo
, &ainfo
->ss
, &ainfo
->ss_end
,
913 input_bfd
, pos
, (unsigned long) fdr
.cbSs
))
915 fdr
.issBase
= output_symhdr
->issMax
;
916 output_symhdr
->issMax
+= fdr
.cbSs
;
919 if (output_bfd
->xvec
->header_byteorder
920 == input_bfd
->xvec
->header_byteorder
)
922 /* The two BFD's have the same endianness, and we don't have
923 to adjust the PDR addresses, so simply copying the
924 information will suffice. */
925 BFD_ASSERT (external_pdr_size
== input_swap
->external_pdr_size
);
928 file_ptr pos
= (input_symhdr
->cbPdOffset
929 + fdr
.ipdFirst
* external_pdr_size
);
930 unsigned long size
= fdr
.cpd
* external_pdr_size
;
931 if (!add_file_shuffle (ainfo
, &ainfo
->pdr
, &ainfo
->pdr_end
,
932 input_bfd
, pos
, size
))
935 BFD_ASSERT (external_opt_size
== input_swap
->external_opt_size
);
938 file_ptr pos
= (input_symhdr
->cbOptOffset
939 + fdr
.ioptBase
* external_opt_size
);
940 unsigned long size
= fdr
.copt
* external_opt_size
;
941 if (!add_file_shuffle (ainfo
, &ainfo
->opt
, &ainfo
->opt_end
,
942 input_bfd
, pos
, size
))
948 bfd_size_type outsz
, insz
;
953 /* The two BFD's have different endianness, so we must swap
954 everything in and out. This code would always work, but
955 it would be unnecessarily slow in the normal case. */
956 outsz
= external_pdr_size
;
957 insz
= input_swap
->external_pdr_size
;
958 in
= ((bfd_byte
*) input_debug
->external_pdr
959 + fdr
.ipdFirst
* insz
);
960 end
= in
+ fdr
.cpd
* insz
;
961 sz
= fdr
.cpd
* outsz
;
962 out
= (bfd_byte
*) objalloc_alloc (ainfo
->memory
, sz
);
965 bfd_set_error (bfd_error_no_memory
);
968 if (!add_memory_shuffle (ainfo
, &ainfo
->pdr
, &ainfo
->pdr_end
, out
,
971 for (; in
< end
; in
+= insz
, out
+= outsz
)
975 (*input_swap
->swap_pdr_in
) (input_bfd
, in
, &pdr
);
976 (*output_swap
->swap_pdr_out
) (output_bfd
, &pdr
, out
);
979 /* Swap over the optimization information. */
980 outsz
= external_opt_size
;
981 insz
= input_swap
->external_opt_size
;
982 in
= ((bfd_byte
*) input_debug
->external_opt
983 + fdr
.ioptBase
* insz
);
984 end
= in
+ fdr
.copt
* insz
;
985 sz
= fdr
.copt
* outsz
;
986 out
= (bfd_byte
*) objalloc_alloc (ainfo
->memory
, sz
);
989 bfd_set_error (bfd_error_no_memory
);
992 if (!add_memory_shuffle (ainfo
, &ainfo
->opt
, &ainfo
->opt_end
, out
,
995 for (; in
< end
; in
+= insz
, out
+= outsz
)
999 (*input_swap
->swap_opt_in
) (input_bfd
, in
, &opt
);
1000 (*output_swap
->swap_opt_out
) (output_bfd
, &opt
, out
);
1004 fdr
.ipdFirst
= output_symhdr
->ipdMax
;
1005 output_symhdr
->ipdMax
+= fdr
.cpd
;
1006 fdr
.ioptBase
= output_symhdr
->ioptMax
;
1007 output_symhdr
->ioptMax
+= fdr
.copt
;
1011 /* Point this FDR at the table of RFD's we created. */
1012 fdr
.rfdBase
= newrfdbase
;
1013 fdr
.crfd
= input_symhdr
->ifdMax
;
1017 /* Point this FDR at the remapped RFD's. */
1018 fdr
.rfdBase
+= oldrfdbase
;
1021 (*swap_fdr_out
) (output_bfd
, &fdr
, fdr_out
);
1022 fdr_out
+= external_fdr_size
;
1023 ++output_symhdr
->ifdMax
;
1029 /* Add a string to the debugging information we are accumulating.
1030 Return the offset from the fdr string base. */
1033 ecoff_add_string (struct accumulate
*ainfo
,
1034 struct bfd_link_info
*info
,
1035 struct ecoff_debug_info
*debug
,
1043 symhdr
= &debug
->symbolic_header
;
1044 len
= strlen (string
);
1045 if (bfd_link_relocatable (info
))
1047 if (!add_memory_shuffle (ainfo
, &ainfo
->ss
, &ainfo
->ss_end
,
1048 (bfd_byte
*) string
, len
+ 1))
1050 ret
= symhdr
->issMax
;
1051 symhdr
->issMax
+= len
+ 1;
1052 fdr
->cbSs
+= len
+ 1;
1056 struct string_hash_entry
*sh
;
1058 sh
= string_hash_lookup (&ainfo
->str_hash
, string
, TRUE
, TRUE
);
1059 if (sh
== (struct string_hash_entry
*) NULL
)
1063 sh
->val
= symhdr
->issMax
;
1064 symhdr
->issMax
+= len
+ 1;
1065 if (ainfo
->ss_hash
== (struct string_hash_entry
*) NULL
)
1066 ainfo
->ss_hash
= sh
;
1067 if (ainfo
->ss_hash_end
1068 != (struct string_hash_entry
*) NULL
)
1069 ainfo
->ss_hash_end
->next
= sh
;
1070 ainfo
->ss_hash_end
= sh
;
1078 /* Add debugging information from a non-ECOFF file. */
1081 bfd_ecoff_debug_accumulate_other (void * handle
,
1083 struct ecoff_debug_info
*output_debug
,
1084 const struct ecoff_debug_swap
*output_swap
,
1086 struct bfd_link_info
*info
)
1088 struct accumulate
*ainfo
= (struct accumulate
*) handle
;
1089 void (* const swap_sym_out
) (bfd
*, const SYMR
*, void *)
1090 = output_swap
->swap_sym_out
;
1091 HDRR
*output_symhdr
= &output_debug
->symbolic_header
;
1099 void * external_fdr
;
1101 memset (&fdr
, 0, sizeof fdr
);
1103 sec
= bfd_get_section_by_name (input_bfd
, ".text");
1105 fdr
.adr
= sec
->output_section
->vma
+ sec
->output_offset
;
1108 /* FIXME: What about .init or .fini? */
1112 fdr
.issBase
= output_symhdr
->issMax
;
1114 fdr
.rss
= ecoff_add_string (ainfo
, info
, output_debug
, &fdr
,
1115 bfd_get_filename (input_bfd
));
1118 fdr
.isymBase
= output_symhdr
->isymMax
;
1120 /* Get the local symbols from the input BFD. */
1121 symsize
= bfd_get_symtab_upper_bound (input_bfd
);
1124 symbols
= (asymbol
**) bfd_alloc (output_bfd
, (bfd_size_type
) symsize
);
1125 if (symbols
== (asymbol
**) NULL
)
1127 symcount
= bfd_canonicalize_symtab (input_bfd
, symbols
);
1130 sym_end
= symbols
+ symcount
;
1132 /* Handle the local symbols. Any external symbols are handled
1135 for (sym_ptr
= symbols
; sym_ptr
!= sym_end
; sym_ptr
++)
1138 void * external_sym
;
1140 if (((*sym_ptr
)->flags
& BSF_EXPORT
) != 0)
1142 memset (&internal_sym
, 0, sizeof internal_sym
);
1143 internal_sym
.iss
= ecoff_add_string (ainfo
, info
, output_debug
, &fdr
,
1146 if (internal_sym
.iss
== -1)
1148 if (bfd_is_com_section ((*sym_ptr
)->section
)
1149 || bfd_is_und_section ((*sym_ptr
)->section
))
1150 internal_sym
.value
= (*sym_ptr
)->value
;
1152 internal_sym
.value
= ((*sym_ptr
)->value
1153 + (*sym_ptr
)->section
->output_offset
1154 + (*sym_ptr
)->section
->output_section
->vma
);
1155 internal_sym
.st
= stNil
;
1156 internal_sym
.sc
= scUndefined
;
1157 internal_sym
.index
= indexNil
;
1159 external_sym
= objalloc_alloc (ainfo
->memory
,
1160 output_swap
->external_sym_size
);
1163 bfd_set_error (bfd_error_no_memory
);
1166 (*swap_sym_out
) (output_bfd
, &internal_sym
, external_sym
);
1167 add_memory_shuffle (ainfo
, &ainfo
->sym
, &ainfo
->sym_end
,
1168 (bfd_byte
*) external_sym
,
1169 (unsigned long) output_swap
->external_sym_size
);
1171 ++output_symhdr
->isymMax
;
1174 bfd_release (output_bfd
, symbols
);
1176 /* Leave everything else in the FDR zeroed out. This will cause
1177 the lang field to be langC. The fBigendian field will
1178 indicate little endian format, but it doesn't matter because
1179 it only applies to aux fields and there are none. */
1180 external_fdr
= objalloc_alloc (ainfo
->memory
,
1181 output_swap
->external_fdr_size
);
1184 bfd_set_error (bfd_error_no_memory
);
1187 (*output_swap
->swap_fdr_out
) (output_bfd
, &fdr
, external_fdr
);
1188 add_memory_shuffle (ainfo
, &ainfo
->fdr
, &ainfo
->fdr_end
,
1189 (bfd_byte
*) external_fdr
,
1190 (unsigned long) output_swap
->external_fdr_size
);
1192 ++output_symhdr
->ifdMax
;
1197 /* Set up ECOFF debugging information for the external symbols.
1198 FIXME: This is done using a memory buffer, but it should be
1199 probably be changed to use a shuffle structure. The assembler uses
1200 this interface, so that must be changed to do something else. */
1203 bfd_ecoff_debug_externals (bfd
*abfd
,
1204 struct ecoff_debug_info
*debug
,
1205 const struct ecoff_debug_swap
*swap
,
1206 bfd_boolean relocatable
,
1207 bfd_boolean (*get_extr
) (asymbol
*, EXTR
*),
1208 void (*set_index
) (asymbol
*, bfd_size_type
))
1210 HDRR
* const symhdr
= &debug
->symbolic_header
;
1211 asymbol
**sym_ptr_ptr
;
1214 sym_ptr_ptr
= bfd_get_outsymbols (abfd
);
1215 if (sym_ptr_ptr
== NULL
)
1218 for (c
= bfd_get_symcount (abfd
); c
> 0; c
--, sym_ptr_ptr
++)
1223 sym_ptr
= *sym_ptr_ptr
;
1225 /* Get the external symbol information. */
1226 if (! (*get_extr
) (sym_ptr
, &esym
))
1229 /* If we're producing an executable, move common symbols into
1233 if (esym
.asym
.sc
== scCommon
)
1234 esym
.asym
.sc
= scBss
;
1235 else if (esym
.asym
.sc
== scSCommon
)
1236 esym
.asym
.sc
= scSBss
;
1239 if (bfd_is_com_section (sym_ptr
->section
)
1240 || bfd_is_und_section (sym_ptr
->section
)
1241 || sym_ptr
->section
->output_section
== (asection
*) NULL
)
1243 /* FIXME: gas does not keep the value of a small undefined
1244 symbol in the symbol itself, because of relocation
1246 if (esym
.asym
.sc
!= scSUndefined
1247 || esym
.asym
.value
== 0
1248 || sym_ptr
->value
!= 0)
1249 esym
.asym
.value
= sym_ptr
->value
;
1252 esym
.asym
.value
= (sym_ptr
->value
1253 + sym_ptr
->section
->output_offset
1254 + sym_ptr
->section
->output_section
->vma
);
1257 (*set_index
) (sym_ptr
, (bfd_size_type
) symhdr
->iextMax
);
1259 if (! bfd_ecoff_debug_one_external (abfd
, debug
, swap
,
1260 sym_ptr
->name
, &esym
))
1267 /* Add a single external symbol to the debugging information. */
1270 bfd_ecoff_debug_one_external (bfd
*abfd
,
1271 struct ecoff_debug_info
*debug
,
1272 const struct ecoff_debug_swap
*swap
,
1276 const bfd_size_type external_ext_size
= swap
->external_ext_size
;
1277 void (* const swap_ext_out
) (bfd
*, const EXTR
*, void *)
1278 = swap
->swap_ext_out
;
1279 HDRR
* const symhdr
= &debug
->symbolic_header
;
1282 namelen
= strlen (name
);
1284 if ((size_t) (debug
->ssext_end
- debug
->ssext
)
1285 < symhdr
->issExtMax
+ namelen
+ 1)
1287 if (! ecoff_add_bytes ((char **) &debug
->ssext
,
1288 (char **) &debug
->ssext_end
,
1289 symhdr
->issExtMax
+ namelen
+ 1))
1292 if ((size_t) ((char *) debug
->external_ext_end
1293 - (char *) debug
->external_ext
)
1294 < (symhdr
->iextMax
+ 1) * external_ext_size
)
1296 char *external_ext
= (char *) debug
->external_ext
;
1297 char *external_ext_end
= (char *) debug
->external_ext_end
;
1298 if (! ecoff_add_bytes ((char **) &external_ext
,
1299 (char **) &external_ext_end
,
1300 (symhdr
->iextMax
+ 1) * (size_t) external_ext_size
))
1302 debug
->external_ext
= external_ext
;
1303 debug
->external_ext_end
= external_ext_end
;
1306 esym
->asym
.iss
= symhdr
->issExtMax
;
1308 (*swap_ext_out
) (abfd
, esym
,
1309 ((char *) debug
->external_ext
1310 + symhdr
->iextMax
* swap
->external_ext_size
));
1314 strcpy (debug
->ssext
+ symhdr
->issExtMax
, name
);
1315 symhdr
->issExtMax
+= namelen
+ 1;
1320 /* Align the ECOFF debugging information. */
1323 ecoff_align_debug (bfd
*abfd ATTRIBUTE_UNUSED
,
1324 struct ecoff_debug_info
*debug
,
1325 const struct ecoff_debug_swap
*swap
)
1327 HDRR
* const symhdr
= &debug
->symbolic_header
;
1328 bfd_size_type debug_align
, aux_align
, rfd_align
;
1331 /* Adjust the counts so that structures are aligned. */
1332 debug_align
= swap
->debug_align
;
1333 aux_align
= debug_align
/ sizeof (union aux_ext
);
1334 rfd_align
= debug_align
/ swap
->external_rfd_size
;
1336 add
= debug_align
- (symhdr
->cbLine
& (debug_align
- 1));
1337 if (add
!= debug_align
)
1339 if (debug
->line
!= (unsigned char *) NULL
)
1340 memset ((debug
->line
+ symhdr
->cbLine
), 0, add
);
1341 symhdr
->cbLine
+= add
;
1344 add
= debug_align
- (symhdr
->issMax
& (debug_align
- 1));
1345 if (add
!= debug_align
)
1347 if (debug
->ss
!= (char *) NULL
)
1348 memset ((debug
->ss
+ symhdr
->issMax
), 0, add
);
1349 symhdr
->issMax
+= add
;
1352 add
= debug_align
- (symhdr
->issExtMax
& (debug_align
- 1));
1353 if (add
!= debug_align
)
1355 if (debug
->ssext
!= (char *) NULL
)
1356 memset ((debug
->ssext
+ symhdr
->issExtMax
), 0, add
);
1357 symhdr
->issExtMax
+= add
;
1360 add
= aux_align
- (symhdr
->iauxMax
& (aux_align
- 1));
1361 if (add
!= aux_align
)
1363 if (debug
->external_aux
!= (union aux_ext
*) NULL
)
1364 memset ((debug
->external_aux
+ symhdr
->iauxMax
), 0,
1365 add
* sizeof (union aux_ext
));
1366 symhdr
->iauxMax
+= add
;
1369 add
= rfd_align
- (symhdr
->crfd
& (rfd_align
- 1));
1370 if (add
!= rfd_align
)
1372 if (debug
->external_rfd
!= NULL
)
1373 memset (((char *) debug
->external_rfd
1374 + symhdr
->crfd
* swap
->external_rfd_size
),
1375 0, (size_t) (add
* swap
->external_rfd_size
));
1376 symhdr
->crfd
+= add
;
1380 /* Return the size required by the ECOFF debugging information. */
1383 bfd_ecoff_debug_size (bfd
*abfd
,
1384 struct ecoff_debug_info
*debug
,
1385 const struct ecoff_debug_swap
*swap
)
1389 ecoff_align_debug (abfd
, debug
, swap
);
1390 tot
= swap
->external_hdr_size
;
1392 #define ADD(count, size) \
1393 tot += debug->symbolic_header.count * size
1395 ADD (cbLine
, sizeof (unsigned char));
1396 ADD (idnMax
, swap
->external_dnr_size
);
1397 ADD (ipdMax
, swap
->external_pdr_size
);
1398 ADD (isymMax
, swap
->external_sym_size
);
1399 ADD (ioptMax
, swap
->external_opt_size
);
1400 ADD (iauxMax
, sizeof (union aux_ext
));
1401 ADD (issMax
, sizeof (char));
1402 ADD (issExtMax
, sizeof (char));
1403 ADD (ifdMax
, swap
->external_fdr_size
);
1404 ADD (crfd
, swap
->external_rfd_size
);
1405 ADD (iextMax
, swap
->external_ext_size
);
1412 /* Write out the ECOFF symbolic header, given the file position it is
1413 going to be placed at. This assumes that the counts are set
1417 ecoff_write_symhdr (bfd
*abfd
,
1418 struct ecoff_debug_info
*debug
,
1419 const struct ecoff_debug_swap
*swap
,
1422 HDRR
* const symhdr
= &debug
->symbolic_header
;
1425 ecoff_align_debug (abfd
, debug
, swap
);
1427 /* Go to the right location in the file. */
1428 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1431 where
+= swap
->external_hdr_size
;
1433 symhdr
->magic
= swap
->sym_magic
;
1435 /* Fill in the file offsets. */
1436 #define SET(offset, count, size) \
1437 if (symhdr->count == 0) \
1438 symhdr->offset = 0; \
1441 symhdr->offset = where; \
1442 where += symhdr->count * size; \
1445 SET (cbLineOffset
, cbLine
, sizeof (unsigned char));
1446 SET (cbDnOffset
, idnMax
, swap
->external_dnr_size
);
1447 SET (cbPdOffset
, ipdMax
, swap
->external_pdr_size
);
1448 SET (cbSymOffset
, isymMax
, swap
->external_sym_size
);
1449 SET (cbOptOffset
, ioptMax
, swap
->external_opt_size
);
1450 SET (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
1451 SET (cbSsOffset
, issMax
, sizeof (char));
1452 SET (cbSsExtOffset
, issExtMax
, sizeof (char));
1453 SET (cbFdOffset
, ifdMax
, swap
->external_fdr_size
);
1454 SET (cbRfdOffset
, crfd
, swap
->external_rfd_size
);
1455 SET (cbExtOffset
, iextMax
, swap
->external_ext_size
);
1458 buff
= (char *) bfd_malloc (swap
->external_hdr_size
);
1459 if (buff
== NULL
&& swap
->external_hdr_size
!= 0)
1462 (*swap
->swap_hdr_out
) (abfd
, symhdr
, buff
);
1463 if (bfd_bwrite (buff
, swap
->external_hdr_size
, abfd
)
1464 != swap
->external_hdr_size
)
1474 /* Write out the ECOFF debugging information. This function assumes
1475 that the information (the pointers and counts) in *DEBUG have been
1476 set correctly. WHERE is the position in the file to write the
1477 information to. This function fills in the file offsets in the
1481 bfd_ecoff_write_debug (bfd
*abfd
,
1482 struct ecoff_debug_info
*debug
,
1483 const struct ecoff_debug_swap
*swap
,
1486 HDRR
* const symhdr
= &debug
->symbolic_header
;
1488 if (! ecoff_write_symhdr (abfd
, debug
, swap
, where
))
1491 #define WRITE(ptr, count, size, offset) \
1492 BFD_ASSERT (symhdr->offset == 0 \
1493 || (bfd_vma) bfd_tell (abfd) == symhdr->offset); \
1494 if (bfd_bwrite (debug->ptr, (bfd_size_type) size * symhdr->count, abfd)\
1495 != size * symhdr->count) \
1498 WRITE (line
, cbLine
, sizeof (unsigned char), cbLineOffset
);
1499 WRITE (external_dnr
, idnMax
, swap
->external_dnr_size
, cbDnOffset
);
1500 WRITE (external_pdr
, ipdMax
, swap
->external_pdr_size
, cbPdOffset
);
1501 WRITE (external_sym
, isymMax
, swap
->external_sym_size
, cbSymOffset
);
1502 WRITE (external_opt
, ioptMax
, swap
->external_opt_size
, cbOptOffset
);
1503 WRITE (external_aux
, iauxMax
, (bfd_size_type
) sizeof (union aux_ext
),
1505 WRITE (ss
, issMax
, sizeof (char), cbSsOffset
);
1506 WRITE (ssext
, issExtMax
, sizeof (char), cbSsExtOffset
);
1507 WRITE (external_fdr
, ifdMax
, swap
->external_fdr_size
, cbFdOffset
);
1508 WRITE (external_rfd
, crfd
, swap
->external_rfd_size
, cbRfdOffset
);
1509 WRITE (external_ext
, iextMax
, swap
->external_ext_size
, cbExtOffset
);
1515 /* Write out a shuffle list. */
1519 ecoff_write_shuffle (bfd
*abfd
,
1520 const struct ecoff_debug_swap
*swap
,
1521 struct shuffle
*shuffle
,
1525 unsigned long total
;
1528 for (l
= shuffle
; l
!= (struct shuffle
*) NULL
; l
= l
->next
)
1532 if (bfd_bwrite (l
->u
.memory
, (bfd_size_type
) l
->size
, abfd
)
1538 if (bfd_seek (l
->u
.file
.input_bfd
, l
->u
.file
.offset
, SEEK_SET
) != 0
1539 || bfd_bread (space
, (bfd_size_type
) l
->size
,
1540 l
->u
.file
.input_bfd
) != l
->size
1541 || bfd_bwrite (space
, (bfd_size_type
) l
->size
, abfd
) != l
->size
)
1547 if ((total
& (swap
->debug_align
- 1)) != 0)
1552 i
= swap
->debug_align
- (total
& (swap
->debug_align
- 1));
1553 s
= (bfd_byte
*) bfd_zmalloc ((bfd_size_type
) i
);
1554 if (s
== NULL
&& i
!= 0)
1557 if (bfd_bwrite (s
, (bfd_size_type
) i
, abfd
) != i
)
1568 /* Write out debugging information using accumulated linker
1572 bfd_ecoff_write_accumulated_debug (void * handle
,
1574 struct ecoff_debug_info
*debug
,
1575 const struct ecoff_debug_swap
*swap
,
1576 struct bfd_link_info
*info
,
1579 struct accumulate
*ainfo
= (struct accumulate
*) handle
;
1580 void * space
= NULL
;
1583 if (! ecoff_write_symhdr (abfd
, debug
, swap
, where
))
1586 amt
= ainfo
->largest_file_shuffle
;
1587 space
= bfd_malloc (amt
);
1588 if (space
== NULL
&& ainfo
->largest_file_shuffle
!= 0)
1591 if (! ecoff_write_shuffle (abfd
, swap
, ainfo
->line
, space
)
1592 || ! ecoff_write_shuffle (abfd
, swap
, ainfo
->pdr
, space
)
1593 || ! ecoff_write_shuffle (abfd
, swap
, ainfo
->sym
, space
)
1594 || ! ecoff_write_shuffle (abfd
, swap
, ainfo
->opt
, space
)
1595 || ! ecoff_write_shuffle (abfd
, swap
, ainfo
->aux
, space
))
1598 /* The string table is written out from the hash table if this is a
1600 if (bfd_link_relocatable (info
))
1602 BFD_ASSERT (ainfo
->ss_hash
== (struct string_hash_entry
*) NULL
);
1603 if (! ecoff_write_shuffle (abfd
, swap
, ainfo
->ss
, space
))
1608 unsigned long total
;
1610 struct string_hash_entry
*sh
;
1612 BFD_ASSERT (ainfo
->ss
== (struct shuffle
*) NULL
);
1614 if (bfd_bwrite (&null
, (bfd_size_type
) 1, abfd
) != 1)
1617 BFD_ASSERT (ainfo
->ss_hash
== NULL
|| ainfo
->ss_hash
->val
== 1);
1618 for (sh
= ainfo
->ss_hash
;
1619 sh
!= (struct string_hash_entry
*) NULL
;
1624 len
= strlen (sh
->root
.string
);
1626 if (bfd_bwrite (sh
->root
.string
, amt
, abfd
) != amt
)
1631 if ((total
& (swap
->debug_align
- 1)) != 0)
1636 i
= swap
->debug_align
- (total
& (swap
->debug_align
- 1));
1637 s
= (bfd_byte
*) bfd_zmalloc ((bfd_size_type
) i
);
1638 if (s
== NULL
&& i
!= 0)
1641 if (bfd_bwrite (s
, (bfd_size_type
) i
, abfd
) != i
)
1650 /* The external strings and symbol are not converted over to using
1651 shuffles. FIXME: They probably should be. */
1652 amt
= debug
->symbolic_header
.issExtMax
;
1653 if (bfd_bwrite (debug
->ssext
, amt
, abfd
) != amt
)
1655 if ((debug
->symbolic_header
.issExtMax
& (swap
->debug_align
- 1)) != 0)
1660 i
= (swap
->debug_align
1661 - (debug
->symbolic_header
.issExtMax
& (swap
->debug_align
- 1)));
1662 s
= (bfd_byte
*) bfd_zmalloc ((bfd_size_type
) i
);
1663 if (s
== NULL
&& i
!= 0)
1666 if (bfd_bwrite (s
, (bfd_size_type
) i
, abfd
) != i
)
1674 if (! ecoff_write_shuffle (abfd
, swap
, ainfo
->fdr
, space
)
1675 || ! ecoff_write_shuffle (abfd
, swap
, ainfo
->rfd
, space
))
1678 BFD_ASSERT (debug
->symbolic_header
.cbExtOffset
== 0
1679 || (debug
->symbolic_header
.cbExtOffset
1680 == (bfd_vma
) bfd_tell (abfd
)));
1682 amt
= debug
->symbolic_header
.iextMax
* swap
->external_ext_size
;
1683 if (bfd_bwrite (debug
->external_ext
, amt
, abfd
) != amt
)
1694 /* Handle the find_nearest_line function for both ECOFF and MIPS ELF
1697 /* Compare FDR entries. This is called via qsort. */
1700 cmp_fdrtab_entry (const void * leftp
, const void * rightp
)
1702 const struct ecoff_fdrtab_entry
*lp
=
1703 (const struct ecoff_fdrtab_entry
*) leftp
;
1704 const struct ecoff_fdrtab_entry
*rp
=
1705 (const struct ecoff_fdrtab_entry
*) rightp
;
1707 if (lp
->base_addr
< rp
->base_addr
)
1709 if (lp
->base_addr
> rp
->base_addr
)
1714 /* Each file descriptor (FDR) has a memory address, to simplify
1715 looking up an FDR by address, we build a table covering all FDRs
1716 that have a least one procedure descriptor in them. The final
1717 table will be sorted by address so we can look it up via binary
1721 mk_fdrtab (bfd
*abfd
,
1722 struct ecoff_debug_info
* const debug_info
,
1723 const struct ecoff_debug_swap
* const debug_swap
,
1724 struct ecoff_find_line
*line_info
)
1726 struct ecoff_fdrtab_entry
*tab
;
1734 fdr_start
= debug_info
->fdr
;
1735 fdr_end
= fdr_start
+ debug_info
->symbolic_header
.ifdMax
;
1737 /* First, let's see how long the table needs to be. */
1738 for (len
= 0, fdr_ptr
= fdr_start
; fdr_ptr
< fdr_end
; fdr_ptr
++)
1740 if (fdr_ptr
->cpd
== 0) /* Skip FDRs that have no PDRs. */
1745 /* Now, create and fill in the table. */
1746 amt
= (bfd_size_type
) len
* sizeof (struct ecoff_fdrtab_entry
);
1747 line_info
->fdrtab
= (struct ecoff_fdrtab_entry
*) bfd_zalloc (abfd
, amt
);
1748 if (line_info
->fdrtab
== NULL
)
1750 line_info
->fdrtab_len
= len
;
1752 tab
= line_info
->fdrtab
;
1753 for (fdr_ptr
= fdr_start
; fdr_ptr
< fdr_end
; fdr_ptr
++)
1755 if (fdr_ptr
->cpd
== 0)
1758 /* Check whether this file has stabs debugging information. In
1759 a file with stabs debugging information, the second local
1760 symbol is named @stabs. */
1762 if (fdr_ptr
->csym
>= 2)
1767 sym_ptr
= ((char *) debug_info
->external_sym
1768 + (fdr_ptr
->isymBase
+ 1) * debug_swap
->external_sym_size
);
1769 (*debug_swap
->swap_sym_in
) (abfd
, sym_ptr
, &sym
);
1770 if (strcmp (debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
,
1777 /* eraxxon: There are at least two problems with this computation:
1778 1) PDRs do *not* contain offsets but full vma's; and typically the
1779 address of the first PDR is the address of the FDR, which will
1780 make (most) of the results of the original computation 0!
1781 2) Once in a wacky while, the Compaq compiler generated PDR
1782 addresses do not equal the FDR vma, but they (the PDR address)
1783 are still vma's and not offsets. Cf. comments in
1785 /* The address of the first PDR is the offset of that
1786 procedure relative to the beginning of file FDR. */
1787 tab
->base_addr
= fdr_ptr
->adr
;
1791 /* XXX I don't know about stabs, so this is a guess
1792 (davidm@cs.arizona.edu). */
1793 tab
->base_addr
= fdr_ptr
->adr
;
1799 /* Finally, the table is sorted in increasing memory-address order.
1800 The table is mostly sorted already, but there are cases (e.g.,
1801 static functions in include files), where this does not hold.
1802 Use "odump -PFv" to verify... */
1803 qsort (line_info
->fdrtab
, (size_t) len
,
1804 sizeof (struct ecoff_fdrtab_entry
), cmp_fdrtab_entry
);
1809 /* Return index of first FDR that covers to OFFSET. */
1812 fdrtab_lookup (struct ecoff_find_line
*line_info
, bfd_vma offset
)
1814 long low
, high
, len
;
1816 struct ecoff_fdrtab_entry
*tab
;
1818 len
= line_info
->fdrtab_len
;
1822 tab
= line_info
->fdrtab
;
1823 for (low
= 0, high
= len
- 1 ; low
!= high
;)
1825 mid
= (high
+ low
) / 2;
1826 if (offset
>= tab
[mid
].base_addr
&& offset
< tab
[mid
+ 1].base_addr
)
1829 if (tab
[mid
].base_addr
> offset
)
1835 /* eraxxon: at this point 'offset' is either lower than the lowest entry or
1836 higher than the highest entry. In the former case high = low = mid = 0;
1837 we want to return -1. In the latter case, low = high and mid = low - 1;
1838 we want to return the index of the highest entry. Only in former case
1839 will the following 'catch-all' test be true. */
1842 /* Last entry is catch-all for all higher addresses. */
1843 if (offset
< tab
[mid
].base_addr
)
1848 /* eraxxon: There may be multiple FDRs in the table with the
1849 same base_addr; make sure that we are at the first one. */
1850 while (mid
> 0 && tab
[mid
- 1].base_addr
== tab
[mid
].base_addr
)
1856 /* Look up a line given an address, storing the information in
1857 LINE_INFO->cache. */
1860 lookup_line (bfd
*abfd
,
1861 struct ecoff_debug_info
* const debug_info
,
1862 const struct ecoff_debug_swap
* const debug_swap
,
1863 struct ecoff_find_line
*line_info
)
1865 struct ecoff_fdrtab_entry
*tab
;
1871 /* eraxxon: note that 'offset' is the full vma, not a section offset. */
1872 offset
= line_info
->cache
.start
;
1874 /* Build FDR table (sorted by object file's base-address) if we
1875 don't have it already. */
1876 if (line_info
->fdrtab
== NULL
1877 && !mk_fdrtab (abfd
, debug_info
, debug_swap
, line_info
))
1880 tab
= line_info
->fdrtab
;
1882 /* Find first FDR for address OFFSET. */
1883 i
= fdrtab_lookup (line_info
, offset
);
1885 return FALSE
; /* no FDR, no fun... */
1887 /* eraxxon: 'fdrtab_lookup' doesn't give what we want, at least for Compaq's
1888 C++ compiler 6.2. Consider three FDRs with starting addresses of x, y,
1889 and z, respectively, such that x < y < z. Assume further that
1890 y < 'offset' < z. It is possible at times that the PDR for 'offset' is
1891 associated with FDR x and *not* with FDR y. Erg!!
1893 From a binary dump of my C++ test case 'moo' using Compaq's coffobjanl
1894 (output format has been edited for our purposes):
1896 FDR [2]: (main.C): First instruction: 0x12000207c <x>
1897 PDR [5] for File [2]: LoopTest__Xv <0x1200020a0> (a)
1898 PDR [7] for File [2]: foo__Xv <0x120002168>
1899 FDR [1]: (-1): First instruction: 0x1200020e8 <y>
1900 PDR [3] for File [1]: <0x120001ad0> (b)
1901 FDR [6]: (-1): First instruction: 0x1200026f0 <z>
1903 (a) In the case of PDR5, the vma is such that the first few instructions
1904 of the procedure can be found. But since the size of this procedure is
1905 160b, the vma will soon cross into the 'address space' of FDR1 and no
1906 debugging info will be found. How repugnant!
1908 (b) It is also possible for a PDR to have a *lower* vma than its associated
1909 FDR; see FDR1 and PDR3. Gross!
1911 Since the FDRs that are causing so much havok (in this case) 1) do not
1912 describe actual files (fdr.rss == -1), and 2) contain only compiler
1913 generated routines, I thought a simple fix would be to exclude them from
1914 the FDR table in 'mk_fdrtab'. But, besides not knowing for certain
1915 whether this would be correct, it creates an additional problem. If we
1916 happen to ask for source file info on a compiler generated (procedure)
1917 symbol -- which is still in the symbol table -- the result can be
1918 information from a real procedure! This is because compiler generated
1919 procedures with vma's higher than the last FDR in the fdr table will be
1920 associated with a PDR from this FDR, specifically the PDR with the
1921 highest vma. This wasn't a problem before, because each procedure had a
1922 PDR. (Yes, this problem could be eliminated if we kept the size of the
1923 last PDR around, but things are already getting ugly).
1925 Probably, a better solution would be to have a sorted PDR table. Each
1926 PDR would have a pointer to its FDR so file information could still be
1927 obtained. A FDR table could still be constructed if necessary -- since
1928 it only contains pointers, not much extra memory would be used -- but
1929 the PDR table would be searched to locate debugging info.
1931 There is still at least one remaining issue. Sometimes a FDR can have a
1932 bogus name, but contain PDRs that should belong to another FDR with a
1935 FDR [3]: 0000000120001b50 (/home/.../Array.H~alt~deccxx_5E5A62AD)
1936 PDR [a] for File [3]: 0000000120001b50
1937 PDR [b] for File [3]: 0000000120001cf0
1938 PDR [c] for File [3]: 0000000120001dc8
1939 PDR [d] for File [3]: 0000000120001e40
1940 PDR [e] for File [3]: 0000000120001eb8
1941 PDR [f] for File [3]: 0000000120001f4c
1942 FDR [4]: 0000000120001b50 (/home/.../Array.H)
1944 Here, FDR4 has the correct name, but should (seemingly) contain PDRa-f.
1945 The symbol table for PDR4 does contain symbols for PDRa-f, but so does
1946 the symbol table for FDR3. However the former is different; perhaps this
1947 can be detected easily. (I'm not sure at this point.) This problem only
1948 seems to be associated with files with templates. I am assuming the idea
1949 is that there is a 'fake' FDR (with PDRs) for each differently typed set
1950 of templates that must be generated. Currently, FDR4 is completely
1951 excluded from the FDR table in 'mk_fdrtab' because it contains no PDRs.
1953 Since I don't have time to prepare a real fix for this right now, be
1954 prepared for 'A Horrible Hack' to force the inspection of all non-stabs
1955 FDRs. It's coming... */
1956 fdr_ptr
= tab
[i
].fdr
;
1958 /* Check whether this file has stabs debugging information. In a
1959 file with stabs debugging information, the second local symbol is
1962 if (fdr_ptr
->csym
>= 2)
1967 sym_ptr
= ((char *) debug_info
->external_sym
1968 + (fdr_ptr
->isymBase
+ 1) * debug_swap
->external_sym_size
);
1969 (*debug_swap
->swap_sym_in
) (abfd
, sym_ptr
, &sym
);
1970 if (strcmp (debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
,
1977 bfd_size_type external_pdr_size
;
1979 char *best_pdr
= NULL
;
1981 bfd_signed_vma best_dist
= -1;
1983 unsigned char *line_ptr
;
1984 unsigned char *line_end
;
1986 /* This file uses ECOFF debugging information. Each FDR has a
1987 list of procedure descriptors (PDR). The address in the FDR
1988 is the absolute address of the first procedure. The address
1989 in the first PDR gives the offset of that procedure relative
1990 to the object file's base-address. The addresses in
1991 subsequent PDRs specify each procedure's address relative to
1992 the object file's base-address. To make things more juicy,
1993 whenever the PROF bit in the PDR is set, the real entry point
1994 of the procedure may be 16 bytes below what would normally be
1995 the procedure's entry point. Instead, DEC came up with a
1996 wicked scheme to create profiled libraries "on the fly":
1997 instead of shipping a regular and a profiled version of each
1998 library, they insert 16 bytes of unused space in front of
1999 each procedure and set the "prof" bit in the PDR to indicate
2000 that there is a gap there (this is done automagically by "as"
2001 when option "-pg" is specified). Thus, normally, you link
2002 against such a library and, except for lots of 16 byte gaps
2003 between functions, things will behave as usual. However,
2004 when invoking "ld" with option "-pg", it will fill those gaps
2005 with code that calls mcount(). It then moves the function's
2006 entry point down by 16 bytes, and out pops a binary that has
2007 all functions profiled.
2009 NOTE: Neither FDRs nor PDRs are strictly sorted in memory
2010 order. For example, when including header-files that
2011 define functions, the FDRs follow behind the including
2012 file, even though their code may have been generated at
2013 a lower address. File coff-alpha.c from libbfd
2014 illustrates this (use "odump -PFv" to look at a file's
2015 FDR/PDR). Similarly, PDRs are sometimes out of order
2016 as well. An example of this is OSF/1 v3.0 libc's
2017 malloc.c. I'm not sure why this happens, but it could
2018 be due to optimizations that reorder a function's
2019 position within an object-file.
2023 On the first call to this function, we build a table of FDRs
2024 that is sorted by the base-address of the object-file the FDR
2025 is referring to. Notice that each object-file may contain
2026 code from multiple source files (e.g., due to code defined in
2027 include files). Thus, for any given base-address, there may
2028 be multiple FDRs (but this case is, fortunately, uncommon).
2029 lookup(addr) guarantees to return the first FDR that applies
2030 to address ADDR. Thus, after invoking lookup(), we have a
2031 list of FDRs that may contain the PDR for ADDR. Next, we
2032 walk through the PDRs of these FDRs and locate the one that
2033 is closest to ADDR (i.e., for which the difference between
2034 ADDR and the PDR's entry point is positive and minimal).
2035 Once, the right FDR and PDR are located, we simply walk
2036 through the line-number table to lookup the line-number that
2037 best matches ADDR. Obviously, things could be sped up by
2038 keeping a sorted list of PDRs instead of a sorted list of
2039 FDRs. However, this would increase space requirements
2040 considerably, which is undesirable. */
2041 external_pdr_size
= debug_swap
->external_pdr_size
;
2043 /* eraxxon: The Horrible Hack: Because of the problems above, set 'i'
2044 to 0 so we look through all FDRs.
2046 Because FDR's without any symbols are assumed to be non-stabs,
2047 searching through all FDRs may cause the following code to try to
2048 read stabs FDRs as ECOFF ones. However, I don't think this will
2052 /* Search FDR list starting at tab[i] for the PDR that best matches
2053 OFFSET. Normally, the FDR list is only one entry long. */
2057 /* eraxxon: 'dist' and 'min_dist' can be negative now
2058 because we iterate over every FDR rather than just ones
2059 with a base address less than or equal to 'offset'. */
2060 bfd_signed_vma dist
= -1, min_dist
= -1;
2064 fdr_ptr
= tab
[i
].fdr
;
2066 pdr_ptr
= ((char *) debug_info
->external_pdr
2067 + fdr_ptr
->ipdFirst
* external_pdr_size
);
2068 pdr_end
= pdr_ptr
+ fdr_ptr
->cpd
* external_pdr_size
;
2069 (*debug_swap
->swap_pdr_in
) (abfd
, pdr_ptr
, &pdr
);
2070 /* Find PDR that is closest to OFFSET. If pdr.prof is set,
2071 the procedure entry-point *may* be 0x10 below pdr.adr. We
2072 simply pretend that pdr.prof *implies* a lower entry-point.
2073 This is safe because it just means that may identify 4 NOPs
2074 in front of the function as belonging to the function. */
2075 for (pdr_hold
= NULL
;
2077 (pdr_ptr
+= external_pdr_size
,
2078 (*debug_swap
->swap_pdr_in
) (abfd
, pdr_ptr
, &pdr
)))
2080 if (offset
>= (pdr
.adr
- 0x10 * pdr
.prof
))
2082 dist
= offset
- (pdr
.adr
- 0x10 * pdr
.prof
);
2084 /* eraxxon: 'dist' can be negative now. Note that
2085 'min_dist' can be negative if 'pdr_hold' below is NULL. */
2086 if (!pdr_hold
|| (dist
>= 0 && dist
< min_dist
))
2094 if (!best_pdr
|| (min_dist
>= 0 && min_dist
< best_dist
))
2096 best_dist
= (bfd_vma
) min_dist
;
2098 best_pdr
= pdr_hold
;
2100 /* Continue looping until base_addr of next entry is different. */
2102 /* eraxxon: We want to iterate over all FDRs.
2103 See previous comment about 'fdrtab_lookup'. */
2104 while (++i
< line_info
->fdrtab_len
);
2106 if (!best_fdr
|| !best_pdr
)
2107 return FALSE
; /* Shouldn't happen... */
2109 /* Phew, finally we got something that we can hold onto. */
2112 (*debug_swap
->swap_pdr_in
) (abfd
, pdr_ptr
, &pdr
);
2113 /* Now we can look for the actual line number. The line numbers
2114 are stored in a very funky format, which I won't try to
2115 describe. The search is bounded by the end of the FDRs line
2117 line_end
= debug_info
->line
+ fdr_ptr
->cbLineOffset
+ fdr_ptr
->cbLine
;
2119 /* Make offset relative to procedure entry. */
2120 offset
-= pdr
.adr
- 0x10 * pdr
.prof
;
2122 line_ptr
= debug_info
->line
+ fdr_ptr
->cbLineOffset
+ pdr
.cbLineOffset
;
2123 while (line_ptr
< line_end
)
2128 delta
= *line_ptr
>> 4;
2131 count
= (*line_ptr
& 0xf) + 1;
2135 delta
= (((line_ptr
[0]) & 0xff) << 8) + ((line_ptr
[1]) & 0xff);
2136 if (delta
>= 0x8000)
2141 if (offset
< count
* 4)
2143 line_info
->cache
.stop
+= count
* 4 - offset
;
2146 offset
-= count
* 4;
2149 /* If fdr_ptr->rss is -1, then this file does not have full
2150 symbols, at least according to gdb/mipsread.c. */
2151 if (fdr_ptr
->rss
== -1)
2153 line_info
->cache
.filename
= NULL
;
2155 line_info
->cache
.functionname
= NULL
;
2160 (*debug_swap
->swap_ext_in
)
2162 ((char *) debug_info
->external_ext
2163 + pdr
.isym
* debug_swap
->external_ext_size
),
2165 line_info
->cache
.functionname
= (debug_info
->ssext
2166 + proc_ext
.asym
.iss
);
2173 line_info
->cache
.filename
= (debug_info
->ss
2176 (*debug_swap
->swap_sym_in
)
2178 ((char *) debug_info
->external_sym
2179 + ((fdr_ptr
->isymBase
+ pdr
.isym
)
2180 * debug_swap
->external_sym_size
)),
2182 line_info
->cache
.functionname
= (debug_info
->ss
2186 if (lineno
== ilineNil
)
2188 line_info
->cache
.line_num
= lineno
;
2192 bfd_size_type external_sym_size
;
2193 const char *directory_name
;
2194 const char *main_file_name
;
2195 const char *current_file_name
;
2196 const char *function_name
;
2197 const char *line_file_name
;
2198 bfd_vma low_func_vma
;
2199 bfd_vma low_line_vma
;
2200 bfd_boolean past_line
;
2201 bfd_boolean past_fn
;
2202 char *sym_ptr
, *sym_ptr_end
;
2203 size_t len
, funclen
;
2204 char *buffer
= NULL
;
2206 /* This file uses stabs debugging information. When gcc is not
2207 optimizing, it will put the line number information before
2208 the function name stabs entry. When gcc is optimizing, it
2209 will put the stabs entry for all the function first, followed
2210 by the line number information. (This appears to happen
2211 because of the two output files used by the -mgpopt switch,
2212 which is implied by -O). This means that we must keep
2213 looking through the symbols until we find both a line number
2214 and a function name which are beyond the address we want. */
2216 line_info
->cache
.filename
= NULL
;
2217 line_info
->cache
.functionname
= NULL
;
2218 line_info
->cache
.line_num
= 0;
2220 directory_name
= NULL
;
2221 main_file_name
= NULL
;
2222 current_file_name
= NULL
;
2223 function_name
= NULL
;
2224 line_file_name
= NULL
;
2230 external_sym_size
= debug_swap
->external_sym_size
;
2232 sym_ptr
= ((char *) debug_info
->external_sym
2233 + (fdr_ptr
->isymBase
+ 2) * external_sym_size
);
2234 sym_ptr_end
= sym_ptr
+ (fdr_ptr
->csym
- 2) * external_sym_size
;
2236 sym_ptr
< sym_ptr_end
&& (! past_line
|| ! past_fn
);
2237 sym_ptr
+= external_sym_size
)
2241 (*debug_swap
->swap_sym_in
) (abfd
, sym_ptr
, &sym
);
2243 if (ECOFF_IS_STAB (&sym
))
2245 switch (ECOFF_UNMARK_STAB (sym
.index
))
2248 main_file_name
= current_file_name
=
2249 debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
;
2251 /* Check the next symbol to see if it is also an
2253 if (sym_ptr
+ external_sym_size
< sym_ptr_end
)
2257 (*debug_swap
->swap_sym_in
) (abfd
,
2258 sym_ptr
+ external_sym_size
,
2260 if (ECOFF_IS_STAB (&nextsym
)
2261 && ECOFF_UNMARK_STAB (nextsym
.index
) == N_SO
)
2263 directory_name
= current_file_name
;
2264 main_file_name
= current_file_name
=
2265 debug_info
->ss
+ fdr_ptr
->issBase
+ nextsym
.iss
;
2266 sym_ptr
+= external_sym_size
;
2273 debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
;
2277 if (sym
.value
> offset
)
2279 else if (sym
.value
>= low_func_vma
)
2281 low_func_vma
= sym
.value
;
2283 debug_info
->ss
+ fdr_ptr
->issBase
+ sym
.iss
;
2288 else if (sym
.st
== stLabel
&& sym
.index
!= indexNil
)
2290 if (sym
.value
> offset
)
2292 else if (sym
.value
>= low_line_vma
)
2294 low_line_vma
= sym
.value
;
2295 line_file_name
= current_file_name
;
2296 line_info
->cache
.line_num
= sym
.index
;
2301 if (line_info
->cache
.line_num
!= 0)
2302 main_file_name
= line_file_name
;
2304 /* We need to remove the stuff after the colon in the function
2305 name. We also need to put the directory name and the file
2307 if (function_name
== NULL
)
2310 len
= funclen
= strlen (function_name
) + 1;
2312 if (main_file_name
!= NULL
2313 && directory_name
!= NULL
2314 && main_file_name
[0] != '/')
2315 len
+= strlen (directory_name
) + strlen (main_file_name
) + 1;
2319 free (line_info
->find_buffer
);
2320 buffer
= (char *) bfd_malloc ((bfd_size_type
) len
);
2321 line_info
->find_buffer
= buffer
;
2326 if (function_name
!= NULL
)
2330 strcpy (buffer
, function_name
);
2331 colon
= strchr (buffer
, ':');
2334 line_info
->cache
.functionname
= buffer
;
2337 if (main_file_name
!= NULL
)
2339 if (directory_name
== NULL
|| main_file_name
[0] == '/')
2340 line_info
->cache
.filename
= main_file_name
;
2343 sprintf (buffer
+ funclen
, "%s%s", directory_name
,
2345 line_info
->cache
.filename
= buffer
+ funclen
;
2353 /* Do the work of find_nearest_line. */
2356 _bfd_ecoff_locate_line (bfd
*abfd
,
2359 struct ecoff_debug_info
* const debug_info
,
2360 const struct ecoff_debug_swap
* const debug_swap
,
2361 struct ecoff_find_line
*line_info
,
2362 const char **filename_ptr
,
2363 const char **functionname_ptr
,
2364 unsigned int *retline_ptr
)
2366 offset
+= section
->vma
;
2368 if (line_info
->cache
.sect
== NULL
2369 || line_info
->cache
.sect
!= section
2370 || offset
< line_info
->cache
.start
2371 || offset
>= line_info
->cache
.stop
)
2373 line_info
->cache
.sect
= section
;
2374 line_info
->cache
.start
= offset
;
2375 line_info
->cache
.stop
= offset
;
2376 if (! lookup_line (abfd
, debug_info
, debug_swap
, line_info
))
2378 line_info
->cache
.sect
= NULL
;
2383 *filename_ptr
= line_info
->cache
.filename
;
2384 *functionname_ptr
= line_info
->cache
.functionname
;
2385 *retline_ptr
= line_info
->cache
.line_num
;
2390 /* These routines copy symbolic information into a memory buffer.
2392 FIXME: The whole point of the shuffle code is to avoid storing
2393 everything in memory, since the linker is such a memory hog. This
2394 code makes that effort useless. It is only called by the MIPS ELF
2395 code when generating a shared library, so it is not that big a
2396 deal, but it should be fixed eventually. */
2398 /* Collect a shuffle into a memory buffer. */
2401 ecoff_collect_shuffle (struct shuffle
*l
, bfd_byte
*buff
)
2403 unsigned long total
;
2406 for (; l
!= (struct shuffle
*) NULL
; l
= l
->next
)
2409 memcpy (buff
, l
->u
.memory
, l
->size
);
2412 if (bfd_seek (l
->u
.file
.input_bfd
, l
->u
.file
.offset
, SEEK_SET
) != 0
2413 || (bfd_bread (buff
, (bfd_size_type
) l
->size
, l
->u
.file
.input_bfd
)
2424 /* Copy PDR information into a memory buffer. */
2427 _bfd_ecoff_get_accumulated_pdr (void * handle
,
2430 struct accumulate
*ainfo
= (struct accumulate
*) handle
;
2432 return ecoff_collect_shuffle (ainfo
->pdr
, buff
);
2435 /* Copy symbol information into a memory buffer. */
2438 _bfd_ecoff_get_accumulated_sym (void * handle
, bfd_byte
*buff
)
2440 struct accumulate
*ainfo
= (struct accumulate
*) handle
;
2442 return ecoff_collect_shuffle (ainfo
->sym
, buff
);
2445 /* Copy the string table into a memory buffer. */
2448 _bfd_ecoff_get_accumulated_ss (void * handle
, bfd_byte
*buff
)
2450 struct accumulate
*ainfo
= (struct accumulate
*) handle
;
2451 struct string_hash_entry
*sh
;
2452 unsigned long total
;
2454 /* The string table is written out from the hash table if this is a
2456 BFD_ASSERT (ainfo
->ss
== (struct shuffle
*) NULL
);
2459 BFD_ASSERT (ainfo
->ss_hash
== NULL
|| ainfo
->ss_hash
->val
== 1);
2460 for (sh
= ainfo
->ss_hash
;
2461 sh
!= (struct string_hash_entry
*) NULL
;
2466 len
= strlen (sh
->root
.string
);
2467 memcpy (buff
, sh
->root
.string
, len
+ 1);