Automatic date update in version.in
[binutils-gdb.git] / bfd / ecofflink.c
blob5ad723898076ea22b678e26b04d5fd950562c4ea
1 /* Routines to link ECOFF debugging information.
2 Copyright (C) 1993-2022 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. */
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "bfdlink.h"
25 #include "libbfd.h"
26 #include "ecoff-bfd.h"
27 #include "objalloc.h"
28 #include "aout/stab_gnu.h"
29 #include "coff/internal.h"
30 #include "coff/sym.h"
31 #include "coff/symconst.h"
32 #include "coff/ecoff.h"
33 #include "libcoff.h"
34 #include "libecoff.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
38 independent. */
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). */
44 void
45 _bfd_ecoff_swap_tir_in (int bigend, const struct tir_ext *ext_copy,
46 TIR *intern)
48 struct tir_ext ext[1];
50 *ext = *ext_copy; /* Make it reasonable to do in-place. */
52 /* now the fun stuff... */
53 if (bigend)
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;
72 else
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;
92 #ifdef TEST
93 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
94 abort ();
95 #endif
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). */
102 void
103 _bfd_ecoff_swap_tir_out (int bigend,
104 const TIR *intern_copy,
105 struct tir_ext *ext)
107 TIR intern[1];
109 *intern = *intern_copy; /* Make it reasonable to do in-place. */
111 /* now the fun stuff... */
112 if (bigend)
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)
119 & TIR_BITS_TQ4_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)
123 & TIR_BITS_TQ0_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)
127 & TIR_BITS_TQ2_BIG)
128 | ((intern->tq3 << TIR_BITS_TQ3_SH_BIG)
129 & TIR_BITS_TQ3_BIG));
131 else
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));
151 #ifdef TEST
152 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
153 abort ();
154 #endif
157 /* Swap in a relative symbol record. BIGEND says whether it is in
158 big-endian or little-endian format.*/
160 void
161 _bfd_ecoff_swap_rndx_in (int bigend,
162 const struct rndx_ext *ext_copy,
163 RNDXR *intern)
165 struct rndx_ext ext[1];
167 *ext = *ext_copy; /* Make it reasonable to do in-place. */
169 /* now the fun stuff... */
170 if (bigend)
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);
180 else
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);
192 #ifdef TEST
193 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
194 abort ();
195 #endif
198 /* Swap out a relative symbol record. BIGEND says whether it is in
199 big-endian or little-endian format.*/
201 void
202 _bfd_ecoff_swap_rndx_out (int bigend,
203 const RNDXR *intern_copy,
204 struct rndx_ext *ext)
206 RNDXR intern[1];
208 *intern = *intern_copy; /* Make it reasonable to do in-place. */
210 /* now the fun stuff... */
211 if (bigend)
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;
221 else
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;
232 #ifdef TEST
233 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
234 abort ();
235 #endif
238 /* The minimum amount of data to allocate. */
239 #define ALLOC_SIZE (4064)
241 /* Add bytes to a buffer. Return success. */
243 static bool
244 ecoff_add_bytes (char **buf, char **bufend, size_t need)
246 size_t have;
247 size_t want;
248 char *newbuf;
250 have = *bufend - *buf;
251 if (have > need)
252 want = ALLOC_SIZE;
253 else
255 want = need - have;
256 if (want < ALLOC_SIZE)
257 want = ALLOC_SIZE;
259 newbuf = (char *) bfd_realloc (*buf, (bfd_size_type) have + want);
260 if (newbuf == NULL)
261 return false;
262 *buf = newbuf;
263 *bufend = *buf + have + want;
264 return true;
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. */
275 long val;
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,
290 const char *string)
292 struct string_hash_entry *ret = (struct string_hash_entry *) entry;
294 /* Allocate the structure if it has not already been allocated by a
295 subclass. */
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)
300 return 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));
306 if (ret)
308 /* Initialize the local fields. */
309 ret->val = -1;
310 ret->next = NULL;
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. */
326 struct shuffle
328 /* The next entry in this linked list. */
329 struct shuffle *next;
330 /* The length of the information. */
331 unsigned long size;
332 /* Whether this information comes from a file or not. */
333 bool filep;
334 union
336 struct
338 /* The BFD the data comes from. */
339 bfd *input_bfd;
340 /* The offset within input_bfd. */
341 file_ptr offset;
342 } file;
343 /* The data to be written out. */
344 void * memory;
345 } u;
348 /* This structure holds information across calls to
349 bfd_ecoff_debug_accumulate. */
351 struct 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;
362 struct shuffle *pdr;
363 struct shuffle *pdr_end;
364 struct shuffle *sym;
365 struct shuffle *sym_end;
366 struct shuffle *opt;
367 struct shuffle *opt_end;
368 struct shuffle *aux;
369 struct shuffle *aux_end;
370 struct shuffle *ss;
371 struct shuffle *ss_end;
372 struct string_hash_entry *ss_hash;
373 struct string_hash_entry *ss_hash_end;
374 struct shuffle *fdr;
375 struct shuffle *fdr_end;
376 struct shuffle *rfd;
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. */
386 static bool
387 add_file_shuffle (struct accumulate *ainfo,
388 struct shuffle **head,
389 struct shuffle **tail,
390 bfd *input_bfd,
391 file_ptr offset,
392 unsigned long size)
394 struct shuffle *n;
396 if (*tail != (struct shuffle *) NULL
397 && (*tail)->filep
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;
405 return true;
408 n = (struct shuffle *) objalloc_alloc (ainfo->memory,
409 sizeof (struct shuffle));
410 if (!n)
412 bfd_set_error (bfd_error_no_memory);
413 return false;
415 n->next = NULL;
416 n->size = size;
417 n->filep = true;
418 n->u.file.input_bfd = input_bfd;
419 n->u.file.offset = offset;
420 if (*head == (struct shuffle *) NULL)
421 *head = n;
422 if (*tail != (struct shuffle *) NULL)
423 (*tail)->next = n;
424 *tail = n;
425 if (size > ainfo->largest_file_shuffle)
426 ainfo->largest_file_shuffle = size;
427 return true;
430 /* Add a memory entry to a shuffle list. */
432 static bool
433 add_memory_shuffle (struct accumulate *ainfo,
434 struct shuffle **head,
435 struct shuffle **tail,
436 bfd_byte *data,
437 unsigned long size)
439 struct shuffle *n;
441 n = (struct shuffle *) objalloc_alloc (ainfo->memory,
442 sizeof (struct shuffle));
443 if (!n)
445 bfd_set_error (bfd_error_no_memory);
446 return false;
448 n->next = NULL;
449 n->size = size;
450 n->filep = false;
451 n->u.memory = data;
452 if (*head == (struct shuffle *) NULL)
453 *head = n;
454 if (*tail != (struct shuffle *) NULL)
455 (*tail)->next = n;
456 *tail = n;
457 return true;
460 /* Initialize the FDR hash table. This returns a handle which is then
461 passed in to bfd_ecoff_debug_accumulate, et. al. */
463 void *
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);
473 if (!ainfo)
474 return NULL;
475 if (!bfd_hash_table_init_n (&ainfo->fdr_hash.table, string_hash_newfunc,
476 sizeof (struct string_hash_entry), 1021))
477 return NULL;
479 ainfo->line = NULL;
480 ainfo->line_end = NULL;
481 ainfo->pdr = NULL;
482 ainfo->pdr_end = NULL;
483 ainfo->sym = NULL;
484 ainfo->sym_end = NULL;
485 ainfo->opt = NULL;
486 ainfo->opt_end = NULL;
487 ainfo->aux = NULL;
488 ainfo->aux_end = NULL;
489 ainfo->ss = NULL;
490 ainfo->ss_end = NULL;
491 ainfo->ss_hash = NULL;
492 ainfo->ss_hash_end = NULL;
493 ainfo->fdr = NULL;
494 ainfo->fdr_end = NULL;
495 ainfo->rfd = 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)))
504 return NULL;
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);
514 return NULL;
517 return ainfo;
520 /* Free the accumulated debugging information. */
522 void
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);
538 free (ainfo);
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. */
549 bool
550 bfd_ecoff_debug_accumulate (void * handle,
551 bfd *output_bfd,
552 struct ecoff_debug_info *output_debug,
553 const struct ecoff_debug_swap *output_swap,
554 bfd *input_bfd,
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];
578 asection *sec;
579 bfd_byte *fdr_start;
580 bfd_byte *fdr_ptr;
581 bfd_byte *fdr_end;
582 bfd_size_type fdr_add;
583 unsigned int copied;
584 RFDT i;
585 unsigned long sz;
586 bfd_byte *rfd_out;
587 bfd_byte *rfd_in;
588 bfd_byte *rfd_end;
589 long newrfdbase = 0;
590 long oldrfdbase = 0;
591 bfd_byte *fdr_out;
592 bfd_size_type amt;
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); \
600 if (sec != NULL) \
601 section_adjust[indx] = (sec->output_section->vma \
602 + sec->output_offset \
603 - sec->vma);
605 SET (".text", scText);
606 SET (".data", scData);
607 SET (".bss", scBss);
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);
617 #undef SET
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);
626 else
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);
642 return false;
644 if (!add_memory_shuffle (ainfo, &ainfo->rfd, &ainfo->rfd_end, rfd_out, sz))
645 return false;
647 copied = 0;
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;
658 fdr_ptr < fdr_end;
659 fdr_ptr += fdr_add, i++, rfd_out += external_rfd_size)
661 FDR fdr;
663 if (input_debug->fdr != (FDR *) NULL)
664 fdr = *(FDR *) fdr_ptr;
665 else
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)
671 const char *name;
672 char *lookup;
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
681 merged. */
682 name = input_debug->ss + fdr.issBase + fdr.rss;
684 lookup = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 20);
685 if (lookup == NULL)
686 return false;
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);
691 free (lookup);
692 if (fh == (struct string_hash_entry *) NULL)
693 return false;
695 if (fh->val != -1)
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. */
701 continue;
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);
709 ++copied;
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;
720 for (;
721 rfd_in < rfd_end;
722 rfd_in += input_swap->external_rfd_size)
724 RFDT rfd;
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
737 information. */
738 sz = copied * external_fdr_size;
739 fdr_out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz);
740 if (!fdr_out)
742 bfd_set_error (bfd_error_no_memory);
743 return false;
745 if (!add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end, fdr_out, sz))
746 return false;
747 for (fdr_ptr = fdr_start, i = 0;
748 fdr_ptr < fdr_end;
749 fdr_ptr += fdr_add, i++)
751 FDR fdr;
752 bfd_byte *sym_out;
753 bfd_byte *lraw_src;
754 bfd_byte *lraw_end;
755 bool fgotfilename;
757 if (input_debug->ifdmap[i] < output_symhdr->ifdMax)
759 /* We are not copying this FDR. */
760 continue;
763 if (input_debug->fdr != (FDR *) NULL)
764 fdr = *(FDR *) fdr_ptr;
765 else
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
770 thing. */
771 fdr.adr += section_adjust[scText];
773 /* Swap in the local symbols, adjust their values, and swap them
774 out again. */
775 fgotfilename = false;
776 sz = fdr.csym * external_sym_size;
777 sym_out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz);
778 if (!sym_out)
780 bfd_set_error (bfd_error_no_memory);
781 return false;
783 if (!add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end, sym_out,
784 sz))
785 return false;
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)
791 SYMR internal_sym;
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)
801 case stNil:
802 if (ECOFF_IS_STAB (&internal_sym))
803 break;
804 /* Fall through. */
805 case stGlobal:
806 case stStatic:
807 case stLabel:
808 case stProc:
809 case stStaticProc:
810 internal_sym.value += section_adjust[internal_sym.sc];
811 break;
813 default:
814 break;
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 bool ffilename;
825 const char *name;
827 if (! fgotfilename && internal_sym.iss == fdr.rss)
828 ffilename = true;
829 else
830 ffilename = false;
832 /* Hash the name into the string table. */
833 name = input_debug->ss + fdr.issBase + internal_sym.iss;
834 if (*name == '\0')
835 internal_sym.iss = 0;
836 else
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)
842 return false;
843 if (sh->val == -1)
845 sh->val = output_symhdr->issMax;
846 output_symhdr->issMax += strlen (name) + 1;
847 if (ainfo->ss_hash == (struct string_hash_entry *) NULL)
848 ainfo->ss_hash = sh;
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;
857 if (ffilename)
859 fdr.rss = internal_sym.iss;
860 fgotfilename = true;
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. */
877 if (fdr.cbLine > 0)
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))
882 return false;
883 fdr.ilineBase = output_symhdr->ilineMax;
884 fdr.cbLineOffset = output_symhdr->cbLine;
885 output_symhdr->ilineMax += fdr.cline;
886 output_symhdr->cbLine += fdr.cbLine;
888 if (fdr.caux > 0)
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,
893 input_bfd, pos,
894 fdr.caux * sizeof (union aux_ext)))
895 return false;
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. */
906 fdr.issBase = 0;
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))
914 return false;
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);
926 if (fdr.cpd > 0)
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))
933 return false;
935 BFD_ASSERT (external_opt_size == input_swap->external_opt_size);
936 if (fdr.copt > 0)
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))
943 return false;
946 else
948 bfd_size_type outsz, insz;
949 bfd_byte *in;
950 bfd_byte *end;
951 bfd_byte *out;
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);
963 if (!out)
965 bfd_set_error (bfd_error_no_memory);
966 return false;
968 if (!add_memory_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end, out,
969 sz))
970 return false;
971 for (; in < end; in += insz, out += outsz)
973 PDR pdr;
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);
987 if (!out)
989 bfd_set_error (bfd_error_no_memory);
990 return false;
992 if (!add_memory_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end, out,
993 sz))
994 return false;
995 for (; in < end; in += insz, out += outsz)
997 OPTR opt;
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;
1009 if (fdr.crfd <= 0)
1011 /* Point this FDR at the table of RFD's we created. */
1012 fdr.rfdBase = newrfdbase;
1013 fdr.crfd = input_symhdr->ifdMax;
1015 else
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;
1026 return true;
1029 /* Add a string to the debugging information we are accumulating.
1030 Return the offset from the fdr string base. */
1032 static long
1033 ecoff_add_string (struct accumulate *ainfo,
1034 struct bfd_link_info *info,
1035 struct ecoff_debug_info *debug,
1036 FDR *fdr,
1037 const char *string)
1039 HDRR *symhdr;
1040 size_t len;
1041 bfd_size_type ret;
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))
1049 return -1;
1050 ret = symhdr->issMax;
1051 symhdr->issMax += len + 1;
1052 fdr->cbSs += len + 1;
1054 else
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)
1060 return -1;
1061 if (sh->val == -1)
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;
1072 ret = sh->val;
1075 return ret;
1078 /* Add debugging information from a non-ECOFF file. */
1080 bool
1081 bfd_ecoff_debug_accumulate_other (void * handle,
1082 bfd *output_bfd,
1083 struct ecoff_debug_info *output_debug,
1084 const struct ecoff_debug_swap *output_swap,
1085 bfd *input_bfd,
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;
1092 FDR fdr;
1093 asection *sec;
1094 asymbol **symbols;
1095 asymbol **sym_ptr;
1096 asymbol **sym_end;
1097 long symsize;
1098 long symcount;
1099 void * external_fdr;
1101 memset (&fdr, 0, sizeof fdr);
1103 sec = bfd_get_section_by_name (input_bfd, ".text");
1104 if (sec != NULL)
1105 fdr.adr = sec->output_section->vma + sec->output_offset;
1106 else
1108 /* FIXME: What about .init or .fini? */
1109 fdr.adr = 0;
1112 fdr.issBase = output_symhdr->issMax;
1113 fdr.cbSs = 0;
1114 fdr.rss = ecoff_add_string (ainfo, info, output_debug, &fdr,
1115 bfd_get_filename (input_bfd));
1116 if (fdr.rss == -1)
1117 return false;
1118 fdr.isymBase = output_symhdr->isymMax;
1120 /* Get the local symbols from the input BFD. */
1121 symsize = bfd_get_symtab_upper_bound (input_bfd);
1122 if (symsize < 0)
1123 return false;
1124 symbols = (asymbol **) bfd_alloc (output_bfd, (bfd_size_type) symsize);
1125 if (symbols == (asymbol **) NULL)
1126 return false;
1127 symcount = bfd_canonicalize_symtab (input_bfd, symbols);
1128 if (symcount < 0)
1129 return false;
1130 sym_end = symbols + symcount;
1132 /* Handle the local symbols. Any external symbols are handled
1133 separately. */
1134 fdr.csym = 0;
1135 for (sym_ptr = symbols; sym_ptr != sym_end; sym_ptr++)
1137 SYMR internal_sym;
1138 void * external_sym;
1140 if (((*sym_ptr)->flags & BSF_EXPORT) != 0)
1141 continue;
1142 memset (&internal_sym, 0, sizeof internal_sym);
1143 internal_sym.iss = ecoff_add_string (ainfo, info, output_debug, &fdr,
1144 (*sym_ptr)->name);
1146 if (internal_sym.iss == -1)
1147 return false;
1148 if (bfd_is_com_section ((*sym_ptr)->section)
1149 || bfd_is_und_section ((*sym_ptr)->section))
1150 internal_sym.value = (*sym_ptr)->value;
1151 else
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);
1161 if (!external_sym)
1163 bfd_set_error (bfd_error_no_memory);
1164 return false;
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);
1170 ++fdr.csym;
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);
1182 if (!external_fdr)
1184 bfd_set_error (bfd_error_no_memory);
1185 return false;
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;
1194 return true;
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. */
1202 bool
1203 bfd_ecoff_debug_externals (bfd *abfd,
1204 struct ecoff_debug_info *debug,
1205 const struct ecoff_debug_swap *swap,
1206 bool relocatable,
1207 bool (*get_extr) (asymbol *, EXTR *),
1208 void (*set_index) (asymbol *, bfd_size_type))
1210 HDRR * const symhdr = &debug->symbolic_header;
1211 asymbol **sym_ptr_ptr;
1212 size_t c;
1214 sym_ptr_ptr = bfd_get_outsymbols (abfd);
1215 if (sym_ptr_ptr == NULL)
1216 return true;
1218 for (c = bfd_get_symcount (abfd); c > 0; c--, sym_ptr_ptr++)
1220 asymbol *sym_ptr;
1221 EXTR esym;
1223 sym_ptr = *sym_ptr_ptr;
1225 /* Get the external symbol information. */
1226 if (! (*get_extr) (sym_ptr, &esym))
1227 continue;
1229 /* If we're producing an executable, move common symbols into
1230 bss. */
1231 if (! relocatable)
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
1245 problems. */
1246 if (esym.asym.sc != scSUndefined
1247 || esym.asym.value == 0
1248 || sym_ptr->value != 0)
1249 esym.asym.value = sym_ptr->value;
1251 else
1252 esym.asym.value = (sym_ptr->value
1253 + sym_ptr->section->output_offset
1254 + sym_ptr->section->output_section->vma);
1256 if (set_index)
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))
1261 return false;
1264 return true;
1267 /* Add a single external symbol to the debugging information. */
1269 bool
1270 bfd_ecoff_debug_one_external (bfd *abfd,
1271 struct ecoff_debug_info *debug,
1272 const struct ecoff_debug_swap *swap,
1273 const char *name,
1274 EXTR *esym)
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;
1280 size_t namelen;
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))
1290 return false;
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))
1301 return false;
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));
1312 ++symhdr->iextMax;
1314 strcpy (debug->ssext + symhdr->issExtMax, name);
1315 symhdr->issExtMax += namelen + 1;
1317 return true;
1320 /* Align the ECOFF debugging information. */
1322 static void
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;
1329 size_t add;
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. */
1382 bfd_size_type
1383 bfd_ecoff_debug_size (bfd *abfd,
1384 struct ecoff_debug_info *debug,
1385 const struct ecoff_debug_swap *swap)
1387 bfd_size_type tot;
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);
1407 #undef ADD
1409 return tot;
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
1414 correctly. */
1416 static bool
1417 ecoff_write_symhdr (bfd *abfd,
1418 struct ecoff_debug_info *debug,
1419 const struct ecoff_debug_swap *swap,
1420 file_ptr where)
1422 HDRR * const symhdr = &debug->symbolic_header;
1423 char *buff = NULL;
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)
1429 return false;
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; \
1439 else \
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);
1456 #undef SET
1458 buff = (char *) bfd_malloc (swap->external_hdr_size);
1459 if (buff == NULL && swap->external_hdr_size != 0)
1460 goto error_return;
1462 (*swap->swap_hdr_out) (abfd, symhdr, buff);
1463 if (bfd_bwrite (buff, swap->external_hdr_size, abfd)
1464 != swap->external_hdr_size)
1465 goto error_return;
1467 free (buff);
1468 return true;
1469 error_return:
1470 free (buff);
1471 return false;
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
1478 symbolic header. */
1480 bool
1481 bfd_ecoff_write_debug (bfd *abfd,
1482 struct ecoff_debug_info *debug,
1483 const struct ecoff_debug_swap *swap,
1484 file_ptr where)
1486 HDRR * const symhdr = &debug->symbolic_header;
1488 if (! ecoff_write_symhdr (abfd, debug, swap, where))
1489 return false;
1491 #define WRITE(ptr, count, size, offset) \
1492 BFD_ASSERT (symhdr->offset == 0 \
1493 || (bfd_vma) bfd_tell (abfd) == symhdr->offset); \
1494 if (symhdr->count != 0 \
1495 && bfd_bwrite (debug->ptr, \
1496 (bfd_size_type) size * symhdr->count, \
1497 abfd) != size * symhdr->count) \
1498 return false;
1500 WRITE (line, cbLine, sizeof (unsigned char), cbLineOffset);
1501 WRITE (external_dnr, idnMax, swap->external_dnr_size, cbDnOffset);
1502 WRITE (external_pdr, ipdMax, swap->external_pdr_size, cbPdOffset);
1503 WRITE (external_sym, isymMax, swap->external_sym_size, cbSymOffset);
1504 WRITE (external_opt, ioptMax, swap->external_opt_size, cbOptOffset);
1505 WRITE (external_aux, iauxMax, (bfd_size_type) sizeof (union aux_ext),
1506 cbAuxOffset);
1507 WRITE (ss, issMax, sizeof (char), cbSsOffset);
1508 WRITE (ssext, issExtMax, sizeof (char), cbSsExtOffset);
1509 WRITE (external_fdr, ifdMax, swap->external_fdr_size, cbFdOffset);
1510 WRITE (external_rfd, crfd, swap->external_rfd_size, cbRfdOffset);
1511 WRITE (external_ext, iextMax, swap->external_ext_size, cbExtOffset);
1512 #undef WRITE
1514 return true;
1517 /* Write out a shuffle list. */
1520 static bool
1521 ecoff_write_shuffle (bfd *abfd,
1522 const struct ecoff_debug_swap *swap,
1523 struct shuffle *shuffle,
1524 void * space)
1526 struct shuffle *l;
1527 unsigned long total;
1529 total = 0;
1530 for (l = shuffle; l != (struct shuffle *) NULL; l = l->next)
1532 if (! l->filep)
1534 if (bfd_bwrite (l->u.memory, (bfd_size_type) l->size, abfd)
1535 != l->size)
1536 return false;
1538 else
1540 if (bfd_seek (l->u.file.input_bfd, l->u.file.offset, SEEK_SET) != 0
1541 || bfd_bread (space, (bfd_size_type) l->size,
1542 l->u.file.input_bfd) != l->size
1543 || bfd_bwrite (space, (bfd_size_type) l->size, abfd) != l->size)
1544 return false;
1546 total += l->size;
1549 if ((total & (swap->debug_align - 1)) != 0)
1551 unsigned int i;
1552 bfd_byte *s;
1554 i = swap->debug_align - (total & (swap->debug_align - 1));
1555 s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i);
1556 if (s == NULL && i != 0)
1557 return false;
1559 if (bfd_bwrite (s, (bfd_size_type) i, abfd) != i)
1561 free (s);
1562 return false;
1564 free (s);
1567 return true;
1570 /* Write out debugging information using accumulated linker
1571 information. */
1573 bool
1574 bfd_ecoff_write_accumulated_debug (void * handle,
1575 bfd *abfd,
1576 struct ecoff_debug_info *debug,
1577 const struct ecoff_debug_swap *swap,
1578 struct bfd_link_info *info,
1579 file_ptr where)
1581 struct accumulate *ainfo = (struct accumulate *) handle;
1582 void * space = NULL;
1583 bfd_size_type amt;
1585 if (! ecoff_write_symhdr (abfd, debug, swap, where))
1586 goto error_return;
1588 amt = ainfo->largest_file_shuffle;
1589 space = bfd_malloc (amt);
1590 if (space == NULL && ainfo->largest_file_shuffle != 0)
1591 goto error_return;
1593 if (! ecoff_write_shuffle (abfd, swap, ainfo->line, space)
1594 || ! ecoff_write_shuffle (abfd, swap, ainfo->pdr, space)
1595 || ! ecoff_write_shuffle (abfd, swap, ainfo->sym, space)
1596 || ! ecoff_write_shuffle (abfd, swap, ainfo->opt, space)
1597 || ! ecoff_write_shuffle (abfd, swap, ainfo->aux, space))
1598 goto error_return;
1600 /* The string table is written out from the hash table if this is a
1601 final link. */
1602 if (bfd_link_relocatable (info))
1604 BFD_ASSERT (ainfo->ss_hash == (struct string_hash_entry *) NULL);
1605 if (! ecoff_write_shuffle (abfd, swap, ainfo->ss, space))
1606 goto error_return;
1608 else
1610 unsigned long total;
1611 bfd_byte null;
1612 struct string_hash_entry *sh;
1614 BFD_ASSERT (ainfo->ss == (struct shuffle *) NULL);
1615 null = 0;
1616 if (bfd_bwrite (&null, (bfd_size_type) 1, abfd) != 1)
1617 goto error_return;
1618 total = 1;
1619 BFD_ASSERT (ainfo->ss_hash == NULL || ainfo->ss_hash->val == 1);
1620 for (sh = ainfo->ss_hash;
1621 sh != (struct string_hash_entry *) NULL;
1622 sh = sh->next)
1624 size_t len;
1626 len = strlen (sh->root.string);
1627 amt = len + 1;
1628 if (bfd_bwrite (sh->root.string, amt, abfd) != amt)
1629 goto error_return;
1630 total += len + 1;
1633 if ((total & (swap->debug_align - 1)) != 0)
1635 unsigned int i;
1636 bfd_byte *s;
1638 i = swap->debug_align - (total & (swap->debug_align - 1));
1639 s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i);
1640 if (s == NULL && i != 0)
1641 goto error_return;
1643 if (bfd_bwrite (s, (bfd_size_type) i, abfd) != i)
1645 free (s);
1646 goto error_return;
1648 free (s);
1652 /* The external strings and symbol are not converted over to using
1653 shuffles. FIXME: They probably should be. */
1654 amt = debug->symbolic_header.issExtMax;
1655 if (amt != 0 && bfd_bwrite (debug->ssext, amt, abfd) != amt)
1656 goto error_return;
1657 if ((debug->symbolic_header.issExtMax & (swap->debug_align - 1)) != 0)
1659 unsigned int i;
1660 bfd_byte *s;
1662 i = (swap->debug_align
1663 - (debug->symbolic_header.issExtMax & (swap->debug_align - 1)));
1664 s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i);
1665 if (s == NULL && i != 0)
1666 goto error_return;
1668 if (bfd_bwrite (s, (bfd_size_type) i, abfd) != i)
1670 free (s);
1671 goto error_return;
1673 free (s);
1676 if (! ecoff_write_shuffle (abfd, swap, ainfo->fdr, space)
1677 || ! ecoff_write_shuffle (abfd, swap, ainfo->rfd, space))
1678 goto error_return;
1680 BFD_ASSERT (debug->symbolic_header.cbExtOffset == 0
1681 || (debug->symbolic_header.cbExtOffset
1682 == (bfd_vma) bfd_tell (abfd)));
1684 amt = debug->symbolic_header.iextMax * swap->external_ext_size;
1685 if (amt != 0 && bfd_bwrite (debug->external_ext, amt, abfd) != amt)
1686 goto error_return;
1688 free (space);
1689 return true;
1691 error_return:
1692 free (space);
1693 return false;
1696 /* Handle the find_nearest_line function for both ECOFF and MIPS ELF
1697 files. */
1699 /* Compare FDR entries. This is called via qsort. */
1701 static int
1702 cmp_fdrtab_entry (const void * leftp, const void * rightp)
1704 const struct ecoff_fdrtab_entry *lp =
1705 (const struct ecoff_fdrtab_entry *) leftp;
1706 const struct ecoff_fdrtab_entry *rp =
1707 (const struct ecoff_fdrtab_entry *) rightp;
1709 if (lp->base_addr < rp->base_addr)
1710 return -1;
1711 if (lp->base_addr > rp->base_addr)
1712 return 1;
1713 return 0;
1716 /* Each file descriptor (FDR) has a memory address, to simplify
1717 looking up an FDR by address, we build a table covering all FDRs
1718 that have a least one procedure descriptor in them. The final
1719 table will be sorted by address so we can look it up via binary
1720 search. */
1722 static bool
1723 mk_fdrtab (bfd *abfd,
1724 struct ecoff_debug_info * const debug_info,
1725 const struct ecoff_debug_swap * const debug_swap,
1726 struct ecoff_find_line *line_info)
1728 struct ecoff_fdrtab_entry *tab;
1729 FDR *fdr_ptr;
1730 FDR *fdr_start;
1731 FDR *fdr_end;
1732 bool stabs;
1733 long len;
1734 bfd_size_type amt;
1736 fdr_start = debug_info->fdr;
1737 fdr_end = fdr_start + debug_info->symbolic_header.ifdMax;
1739 /* First, let's see how long the table needs to be. */
1740 for (len = 0, fdr_ptr = fdr_start; fdr_ptr < fdr_end; fdr_ptr++)
1742 if (fdr_ptr->cpd == 0) /* Skip FDRs that have no PDRs. */
1743 continue;
1744 ++len;
1747 /* Now, create and fill in the table. */
1748 amt = (bfd_size_type) len * sizeof (struct ecoff_fdrtab_entry);
1749 line_info->fdrtab = (struct ecoff_fdrtab_entry*) bfd_zalloc (abfd, amt);
1750 if (line_info->fdrtab == NULL)
1751 return false;
1752 line_info->fdrtab_len = len;
1754 tab = line_info->fdrtab;
1755 for (fdr_ptr = fdr_start; fdr_ptr < fdr_end; fdr_ptr++)
1757 if (fdr_ptr->cpd == 0)
1758 continue;
1760 /* Check whether this file has stabs debugging information. In
1761 a file with stabs debugging information, the second local
1762 symbol is named @stabs. */
1763 stabs = false;
1764 if (fdr_ptr->csym >= 2)
1766 char *sym_ptr;
1767 SYMR sym;
1769 sym_ptr = ((char *) debug_info->external_sym
1770 + (fdr_ptr->isymBase + 1) * debug_swap->external_sym_size);
1771 (*debug_swap->swap_sym_in) (abfd, sym_ptr, &sym);
1772 if (strcmp (debug_info->ss + fdr_ptr->issBase + sym.iss,
1773 STABS_SYMBOL) == 0)
1774 stabs = true;
1777 if (!stabs)
1779 /* eraxxon: There are at least two problems with this computation:
1780 1) PDRs do *not* contain offsets but full vma's; and typically the
1781 address of the first PDR is the address of the FDR, which will
1782 make (most) of the results of the original computation 0!
1783 2) Once in a wacky while, the Compaq compiler generated PDR
1784 addresses do not equal the FDR vma, but they (the PDR address)
1785 are still vma's and not offsets. Cf. comments in
1786 'lookup_line'. */
1787 /* The address of the first PDR is the offset of that
1788 procedure relative to the beginning of file FDR. */
1789 tab->base_addr = fdr_ptr->adr;
1791 else
1793 /* XXX I don't know about stabs, so this is a guess
1794 (davidm@cs.arizona.edu). */
1795 tab->base_addr = fdr_ptr->adr;
1797 tab->fdr = fdr_ptr;
1798 ++tab;
1801 /* Finally, the table is sorted in increasing memory-address order.
1802 The table is mostly sorted already, but there are cases (e.g.,
1803 static functions in include files), where this does not hold.
1804 Use "odump -PFv" to verify... */
1805 qsort (line_info->fdrtab, (size_t) len,
1806 sizeof (struct ecoff_fdrtab_entry), cmp_fdrtab_entry);
1808 return true;
1811 /* Return index of first FDR that covers to OFFSET. */
1813 static long
1814 fdrtab_lookup (struct ecoff_find_line *line_info, bfd_vma offset)
1816 long low, high, len;
1817 long mid = -1;
1818 struct ecoff_fdrtab_entry *tab;
1820 len = line_info->fdrtab_len;
1821 if (len == 0)
1822 return -1;
1824 tab = line_info->fdrtab;
1825 for (low = 0, high = len - 1 ; low != high ;)
1827 mid = (high + low) / 2;
1828 if (offset >= tab[mid].base_addr && offset < tab[mid + 1].base_addr)
1829 goto find_min;
1831 if (tab[mid].base_addr > offset)
1832 high = mid;
1833 else
1834 low = mid + 1;
1837 /* eraxxon: at this point 'offset' is either lower than the lowest entry or
1838 higher than the highest entry. In the former case high = low = mid = 0;
1839 we want to return -1. In the latter case, low = high and mid = low - 1;
1840 we want to return the index of the highest entry. Only in former case
1841 will the following 'catch-all' test be true. */
1842 ++mid;
1844 /* Last entry is catch-all for all higher addresses. */
1845 if (offset < tab[mid].base_addr)
1846 return -1;
1848 find_min:
1850 /* eraxxon: There may be multiple FDRs in the table with the
1851 same base_addr; make sure that we are at the first one. */
1852 while (mid > 0 && tab[mid - 1].base_addr == tab[mid].base_addr)
1853 --mid;
1855 return mid;
1858 /* Look up a line given an address, storing the information in
1859 LINE_INFO->cache. */
1861 static bool
1862 lookup_line (bfd *abfd,
1863 struct ecoff_debug_info * const debug_info,
1864 const struct ecoff_debug_swap * const debug_swap,
1865 struct ecoff_find_line *line_info)
1867 struct ecoff_fdrtab_entry *tab;
1868 bfd_vma offset;
1869 bool stabs;
1870 FDR *fdr_ptr;
1871 int i;
1873 /* eraxxon: note that 'offset' is the full vma, not a section offset. */
1874 offset = line_info->cache.start;
1876 /* Build FDR table (sorted by object file's base-address) if we
1877 don't have it already. */
1878 if (line_info->fdrtab == NULL
1879 && !mk_fdrtab (abfd, debug_info, debug_swap, line_info))
1880 return false;
1882 tab = line_info->fdrtab;
1884 /* Find first FDR for address OFFSET. */
1885 i = fdrtab_lookup (line_info, offset);
1886 if (i < 0)
1887 return false; /* no FDR, no fun... */
1889 /* eraxxon: 'fdrtab_lookup' doesn't give what we want, at least for Compaq's
1890 C++ compiler 6.2. Consider three FDRs with starting addresses of x, y,
1891 and z, respectively, such that x < y < z. Assume further that
1892 y < 'offset' < z. It is possible at times that the PDR for 'offset' is
1893 associated with FDR x and *not* with FDR y. Erg!!
1895 From a binary dump of my C++ test case 'moo' using Compaq's coffobjanl
1896 (output format has been edited for our purposes):
1898 FDR [2]: (main.C): First instruction: 0x12000207c <x>
1899 PDR [5] for File [2]: LoopTest__Xv <0x1200020a0> (a)
1900 PDR [7] for File [2]: foo__Xv <0x120002168>
1901 FDR [1]: (-1): First instruction: 0x1200020e8 <y>
1902 PDR [3] for File [1]: <0x120001ad0> (b)
1903 FDR [6]: (-1): First instruction: 0x1200026f0 <z>
1905 (a) In the case of PDR5, the vma is such that the first few instructions
1906 of the procedure can be found. But since the size of this procedure is
1907 160b, the vma will soon cross into the 'address space' of FDR1 and no
1908 debugging info will be found. How repugnant!
1910 (b) It is also possible for a PDR to have a *lower* vma than its associated
1911 FDR; see FDR1 and PDR3. Gross!
1913 Since the FDRs that are causing so much havok (in this case) 1) do not
1914 describe actual files (fdr.rss == -1), and 2) contain only compiler
1915 generated routines, I thought a simple fix would be to exclude them from
1916 the FDR table in 'mk_fdrtab'. But, besides not knowing for certain
1917 whether this would be correct, it creates an additional problem. If we
1918 happen to ask for source file info on a compiler generated (procedure)
1919 symbol -- which is still in the symbol table -- the result can be
1920 information from a real procedure! This is because compiler generated
1921 procedures with vma's higher than the last FDR in the fdr table will be
1922 associated with a PDR from this FDR, specifically the PDR with the
1923 highest vma. This wasn't a problem before, because each procedure had a
1924 PDR. (Yes, this problem could be eliminated if we kept the size of the
1925 last PDR around, but things are already getting ugly).
1927 Probably, a better solution would be to have a sorted PDR table. Each
1928 PDR would have a pointer to its FDR so file information could still be
1929 obtained. A FDR table could still be constructed if necessary -- since
1930 it only contains pointers, not much extra memory would be used -- but
1931 the PDR table would be searched to locate debugging info.
1933 There is still at least one remaining issue. Sometimes a FDR can have a
1934 bogus name, but contain PDRs that should belong to another FDR with a
1935 real name. E.g:
1937 FDR [3]: 0000000120001b50 (/home/.../Array.H~alt~deccxx_5E5A62AD)
1938 PDR [a] for File [3]: 0000000120001b50
1939 PDR [b] for File [3]: 0000000120001cf0
1940 PDR [c] for File [3]: 0000000120001dc8
1941 PDR [d] for File [3]: 0000000120001e40
1942 PDR [e] for File [3]: 0000000120001eb8
1943 PDR [f] for File [3]: 0000000120001f4c
1944 FDR [4]: 0000000120001b50 (/home/.../Array.H)
1946 Here, FDR4 has the correct name, but should (seemingly) contain PDRa-f.
1947 The symbol table for PDR4 does contain symbols for PDRa-f, but so does
1948 the symbol table for FDR3. However the former is different; perhaps this
1949 can be detected easily. (I'm not sure at this point.) This problem only
1950 seems to be associated with files with templates. I am assuming the idea
1951 is that there is a 'fake' FDR (with PDRs) for each differently typed set
1952 of templates that must be generated. Currently, FDR4 is completely
1953 excluded from the FDR table in 'mk_fdrtab' because it contains no PDRs.
1955 Since I don't have time to prepare a real fix for this right now, be
1956 prepared for 'A Horrible Hack' to force the inspection of all non-stabs
1957 FDRs. It's coming... */
1958 fdr_ptr = tab[i].fdr;
1960 /* Check whether this file has stabs debugging information. In a
1961 file with stabs debugging information, the second local symbol is
1962 named @stabs. */
1963 stabs = false;
1964 if (fdr_ptr->csym >= 2)
1966 char *sym_ptr;
1967 SYMR sym;
1969 sym_ptr = ((char *) debug_info->external_sym
1970 + (fdr_ptr->isymBase + 1) * debug_swap->external_sym_size);
1971 (*debug_swap->swap_sym_in) (abfd, sym_ptr, &sym);
1972 if (strcmp (debug_info->ss + fdr_ptr->issBase + sym.iss,
1973 STABS_SYMBOL) == 0)
1974 stabs = true;
1977 if (!stabs)
1979 bfd_size_type external_pdr_size;
1980 char *pdr_ptr;
1981 char *best_pdr = NULL;
1982 FDR *best_fdr;
1983 bfd_signed_vma best_dist = -1;
1984 PDR pdr;
1985 unsigned char *line_ptr;
1986 unsigned char *line_end;
1987 int lineno;
1988 /* This file uses ECOFF debugging information. Each FDR has a
1989 list of procedure descriptors (PDR). The address in the FDR
1990 is the absolute address of the first procedure. The address
1991 in the first PDR gives the offset of that procedure relative
1992 to the object file's base-address. The addresses in
1993 subsequent PDRs specify each procedure's address relative to
1994 the object file's base-address. To make things more juicy,
1995 whenever the PROF bit in the PDR is set, the real entry point
1996 of the procedure may be 16 bytes below what would normally be
1997 the procedure's entry point. Instead, DEC came up with a
1998 wicked scheme to create profiled libraries "on the fly":
1999 instead of shipping a regular and a profiled version of each
2000 library, they insert 16 bytes of unused space in front of
2001 each procedure and set the "prof" bit in the PDR to indicate
2002 that there is a gap there (this is done automagically by "as"
2003 when option "-pg" is specified). Thus, normally, you link
2004 against such a library and, except for lots of 16 byte gaps
2005 between functions, things will behave as usual. However,
2006 when invoking "ld" with option "-pg", it will fill those gaps
2007 with code that calls mcount(). It then moves the function's
2008 entry point down by 16 bytes, and out pops a binary that has
2009 all functions profiled.
2011 NOTE: Neither FDRs nor PDRs are strictly sorted in memory
2012 order. For example, when including header-files that
2013 define functions, the FDRs follow behind the including
2014 file, even though their code may have been generated at
2015 a lower address. File coff-alpha.c from libbfd
2016 illustrates this (use "odump -PFv" to look at a file's
2017 FDR/PDR). Similarly, PDRs are sometimes out of order
2018 as well. An example of this is OSF/1 v3.0 libc's
2019 malloc.c. I'm not sure why this happens, but it could
2020 be due to optimizations that reorder a function's
2021 position within an object-file.
2023 Strategy:
2025 On the first call to this function, we build a table of FDRs
2026 that is sorted by the base-address of the object-file the FDR
2027 is referring to. Notice that each object-file may contain
2028 code from multiple source files (e.g., due to code defined in
2029 include files). Thus, for any given base-address, there may
2030 be multiple FDRs (but this case is, fortunately, uncommon).
2031 lookup(addr) guarantees to return the first FDR that applies
2032 to address ADDR. Thus, after invoking lookup(), we have a
2033 list of FDRs that may contain the PDR for ADDR. Next, we
2034 walk through the PDRs of these FDRs and locate the one that
2035 is closest to ADDR (i.e., for which the difference between
2036 ADDR and the PDR's entry point is positive and minimal).
2037 Once, the right FDR and PDR are located, we simply walk
2038 through the line-number table to lookup the line-number that
2039 best matches ADDR. Obviously, things could be sped up by
2040 keeping a sorted list of PDRs instead of a sorted list of
2041 FDRs. However, this would increase space requirements
2042 considerably, which is undesirable. */
2043 external_pdr_size = debug_swap->external_pdr_size;
2045 /* eraxxon: The Horrible Hack: Because of the problems above, set 'i'
2046 to 0 so we look through all FDRs.
2048 Because FDR's without any symbols are assumed to be non-stabs,
2049 searching through all FDRs may cause the following code to try to
2050 read stabs FDRs as ECOFF ones. However, I don't think this will
2051 harm anything. */
2052 i = 0;
2054 /* Search FDR list starting at tab[i] for the PDR that best matches
2055 OFFSET. Normally, the FDR list is only one entry long. */
2056 best_fdr = NULL;
2059 /* eraxxon: 'dist' and 'min_dist' can be negative now
2060 because we iterate over every FDR rather than just ones
2061 with a base address less than or equal to 'offset'. */
2062 bfd_signed_vma dist = -1, min_dist = -1;
2063 char *pdr_hold;
2064 char *pdr_end;
2066 fdr_ptr = tab[i].fdr;
2068 pdr_ptr = ((char *) debug_info->external_pdr
2069 + fdr_ptr->ipdFirst * external_pdr_size);
2070 pdr_end = pdr_ptr + fdr_ptr->cpd * external_pdr_size;
2071 (*debug_swap->swap_pdr_in) (abfd, pdr_ptr, &pdr);
2072 /* Find PDR that is closest to OFFSET. If pdr.prof is set,
2073 the procedure entry-point *may* be 0x10 below pdr.adr. We
2074 simply pretend that pdr.prof *implies* a lower entry-point.
2075 This is safe because it just means that may identify 4 NOPs
2076 in front of the function as belonging to the function. */
2077 for (pdr_hold = NULL;
2078 pdr_ptr < pdr_end;
2079 (pdr_ptr += external_pdr_size,
2080 (*debug_swap->swap_pdr_in) (abfd, pdr_ptr, &pdr)))
2082 if (offset >= (pdr.adr - 0x10 * pdr.prof))
2084 dist = offset - (pdr.adr - 0x10 * pdr.prof);
2086 /* eraxxon: 'dist' can be negative now. Note that
2087 'min_dist' can be negative if 'pdr_hold' below is NULL. */
2088 if (!pdr_hold || (dist >= 0 && dist < min_dist))
2090 min_dist = dist;
2091 pdr_hold = pdr_ptr;
2096 if (!best_pdr || (min_dist >= 0 && min_dist < best_dist))
2098 best_dist = (bfd_vma) min_dist;
2099 best_fdr = fdr_ptr;
2100 best_pdr = pdr_hold;
2102 /* Continue looping until base_addr of next entry is different. */
2104 /* eraxxon: We want to iterate over all FDRs.
2105 See previous comment about 'fdrtab_lookup'. */
2106 while (++i < line_info->fdrtab_len);
2108 if (!best_fdr || !best_pdr)
2109 return false; /* Shouldn't happen... */
2111 /* Phew, finally we got something that we can hold onto. */
2112 fdr_ptr = best_fdr;
2113 pdr_ptr = best_pdr;
2114 (*debug_swap->swap_pdr_in) (abfd, pdr_ptr, &pdr);
2115 /* Now we can look for the actual line number. The line numbers
2116 are stored in a very funky format, which I won't try to
2117 describe. The search is bounded by the end of the FDRs line
2118 number entries. */
2119 line_end = debug_info->line + fdr_ptr->cbLineOffset + fdr_ptr->cbLine;
2121 /* Make offset relative to procedure entry. */
2122 offset -= pdr.adr - 0x10 * pdr.prof;
2123 lineno = pdr.lnLow;
2124 line_ptr = debug_info->line + fdr_ptr->cbLineOffset + pdr.cbLineOffset;
2125 while (line_ptr < line_end)
2127 int delta;
2128 unsigned int count;
2130 delta = *line_ptr >> 4;
2131 if (delta >= 0x8)
2132 delta -= 0x10;
2133 count = (*line_ptr & 0xf) + 1;
2134 ++line_ptr;
2135 if (delta == -8)
2137 delta = (((line_ptr[0]) & 0xff) << 8) + ((line_ptr[1]) & 0xff);
2138 if (delta >= 0x8000)
2139 delta -= 0x10000;
2140 line_ptr += 2;
2142 lineno += delta;
2143 if (offset < count * 4)
2145 line_info->cache.stop += count * 4 - offset;
2146 break;
2148 offset -= count * 4;
2151 /* If fdr_ptr->rss is -1, then this file does not have full
2152 symbols, at least according to gdb/mipsread.c. */
2153 if (fdr_ptr->rss == -1)
2155 line_info->cache.filename = NULL;
2156 if (pdr.isym == -1)
2157 line_info->cache.functionname = NULL;
2158 else
2160 EXTR proc_ext;
2162 (*debug_swap->swap_ext_in)
2163 (abfd,
2164 ((char *) debug_info->external_ext
2165 + pdr.isym * debug_swap->external_ext_size),
2166 &proc_ext);
2167 line_info->cache.functionname = (debug_info->ssext
2168 + proc_ext.asym.iss);
2171 else
2173 SYMR proc_sym;
2175 line_info->cache.filename = (debug_info->ss
2176 + fdr_ptr->issBase
2177 + fdr_ptr->rss);
2178 (*debug_swap->swap_sym_in)
2179 (abfd,
2180 ((char *) debug_info->external_sym
2181 + ((fdr_ptr->isymBase + pdr.isym)
2182 * debug_swap->external_sym_size)),
2183 &proc_sym);
2184 line_info->cache.functionname = (debug_info->ss
2185 + fdr_ptr->issBase
2186 + proc_sym.iss);
2188 if (lineno == ilineNil)
2189 lineno = 0;
2190 line_info->cache.line_num = lineno;
2192 else
2194 bfd_size_type external_sym_size;
2195 const char *directory_name;
2196 const char *main_file_name;
2197 const char *current_file_name;
2198 const char *function_name;
2199 const char *line_file_name;
2200 bfd_vma low_func_vma;
2201 bfd_vma low_line_vma;
2202 bool past_line;
2203 bool past_fn;
2204 char *sym_ptr, *sym_ptr_end;
2205 size_t len, funclen;
2206 char *buffer = NULL;
2208 /* This file uses stabs debugging information. When gcc is not
2209 optimizing, it will put the line number information before
2210 the function name stabs entry. When gcc is optimizing, it
2211 will put the stabs entry for all the function first, followed
2212 by the line number information. (This appears to happen
2213 because of the two output files used by the -mgpopt switch,
2214 which is implied by -O). This means that we must keep
2215 looking through the symbols until we find both a line number
2216 and a function name which are beyond the address we want. */
2218 line_info->cache.filename = NULL;
2219 line_info->cache.functionname = NULL;
2220 line_info->cache.line_num = 0;
2222 directory_name = NULL;
2223 main_file_name = NULL;
2224 current_file_name = NULL;
2225 function_name = NULL;
2226 line_file_name = NULL;
2227 low_func_vma = 0;
2228 low_line_vma = 0;
2229 past_line = false;
2230 past_fn = false;
2232 external_sym_size = debug_swap->external_sym_size;
2234 sym_ptr = ((char *) debug_info->external_sym
2235 + (fdr_ptr->isymBase + 2) * external_sym_size);
2236 sym_ptr_end = sym_ptr + (fdr_ptr->csym - 2) * external_sym_size;
2237 for (;
2238 sym_ptr < sym_ptr_end && (! past_line || ! past_fn);
2239 sym_ptr += external_sym_size)
2241 SYMR sym;
2243 (*debug_swap->swap_sym_in) (abfd, sym_ptr, &sym);
2245 if (ECOFF_IS_STAB (&sym))
2247 switch (ECOFF_UNMARK_STAB (sym.index))
2249 case N_SO:
2250 main_file_name = current_file_name =
2251 debug_info->ss + fdr_ptr->issBase + sym.iss;
2253 /* Check the next symbol to see if it is also an
2254 N_SO symbol. */
2255 if (sym_ptr + external_sym_size < sym_ptr_end)
2257 SYMR nextsym;
2259 (*debug_swap->swap_sym_in) (abfd,
2260 sym_ptr + external_sym_size,
2261 &nextsym);
2262 if (ECOFF_IS_STAB (&nextsym)
2263 && ECOFF_UNMARK_STAB (nextsym.index) == N_SO)
2265 directory_name = current_file_name;
2266 main_file_name = current_file_name =
2267 debug_info->ss + fdr_ptr->issBase + nextsym.iss;
2268 sym_ptr += external_sym_size;
2271 break;
2273 case N_SOL:
2274 current_file_name =
2275 debug_info->ss + fdr_ptr->issBase + sym.iss;
2276 break;
2278 case N_FUN:
2279 if (sym.value > offset)
2280 past_fn = true;
2281 else if (sym.value >= low_func_vma)
2283 low_func_vma = sym.value;
2284 function_name =
2285 debug_info->ss + fdr_ptr->issBase + sym.iss;
2287 break;
2290 else if (sym.st == stLabel && sym.index != indexNil)
2292 if (sym.value > offset)
2293 past_line = true;
2294 else if (sym.value >= low_line_vma)
2296 low_line_vma = sym.value;
2297 line_file_name = current_file_name;
2298 line_info->cache.line_num = sym.index;
2303 if (line_info->cache.line_num != 0)
2304 main_file_name = line_file_name;
2306 /* We need to remove the stuff after the colon in the function
2307 name. We also need to put the directory name and the file
2308 name together. */
2309 if (function_name == NULL)
2310 len = funclen = 0;
2311 else
2312 len = funclen = strlen (function_name) + 1;
2314 if (main_file_name != NULL
2315 && directory_name != NULL
2316 && main_file_name[0] != '/')
2317 len += strlen (directory_name) + strlen (main_file_name) + 1;
2319 if (len != 0)
2321 free (line_info->find_buffer);
2322 buffer = (char *) bfd_malloc ((bfd_size_type) len);
2323 line_info->find_buffer = buffer;
2324 if (buffer == NULL)
2325 return false;
2328 if (function_name != NULL)
2330 char *colon;
2332 strcpy (buffer, function_name);
2333 colon = strchr (buffer, ':');
2334 if (colon != NULL)
2335 *colon = '\0';
2336 line_info->cache.functionname = buffer;
2339 if (main_file_name != NULL)
2341 if (directory_name == NULL || main_file_name[0] == '/')
2342 line_info->cache.filename = main_file_name;
2343 else
2345 sprintf (buffer + funclen, "%s%s", directory_name,
2346 main_file_name);
2347 line_info->cache.filename = buffer + funclen;
2352 return true;
2355 /* Do the work of find_nearest_line. */
2357 bool
2358 _bfd_ecoff_locate_line (bfd *abfd,
2359 asection *section,
2360 bfd_vma offset,
2361 struct ecoff_debug_info * const debug_info,
2362 const struct ecoff_debug_swap * const debug_swap,
2363 struct ecoff_find_line *line_info,
2364 const char **filename_ptr,
2365 const char **functionname_ptr,
2366 unsigned int *retline_ptr)
2368 offset += section->vma;
2370 if (line_info->cache.sect == NULL
2371 || line_info->cache.sect != section
2372 || offset < line_info->cache.start
2373 || offset >= line_info->cache.stop)
2375 line_info->cache.sect = section;
2376 line_info->cache.start = offset;
2377 line_info->cache.stop = offset;
2378 if (! lookup_line (abfd, debug_info, debug_swap, line_info))
2380 line_info->cache.sect = NULL;
2381 return false;
2385 *filename_ptr = line_info->cache.filename;
2386 *functionname_ptr = line_info->cache.functionname;
2387 *retline_ptr = line_info->cache.line_num;
2389 return true;
2392 /* These routines copy symbolic information into a memory buffer.
2394 FIXME: The whole point of the shuffle code is to avoid storing
2395 everything in memory, since the linker is such a memory hog. This
2396 code makes that effort useless. It is only called by the MIPS ELF
2397 code when generating a shared library, so it is not that big a
2398 deal, but it should be fixed eventually. */
2400 /* Collect a shuffle into a memory buffer. */
2402 static bool
2403 ecoff_collect_shuffle (struct shuffle *l, bfd_byte *buff)
2405 for (; l != (struct shuffle *) NULL; l = l->next)
2407 if (! l->filep)
2408 memcpy (buff, l->u.memory, l->size);
2409 else
2411 if (bfd_seek (l->u.file.input_bfd, l->u.file.offset, SEEK_SET) != 0
2412 || (bfd_bread (buff, (bfd_size_type) l->size, l->u.file.input_bfd)
2413 != l->size))
2414 return false;
2416 buff += l->size;
2419 return true;
2422 /* Copy PDR information into a memory buffer. */
2424 bool
2425 _bfd_ecoff_get_accumulated_pdr (void * handle,
2426 bfd_byte *buff)
2428 struct accumulate *ainfo = (struct accumulate *) handle;
2430 return ecoff_collect_shuffle (ainfo->pdr, buff);
2433 /* Copy symbol information into a memory buffer. */
2435 bool
2436 _bfd_ecoff_get_accumulated_sym (void * handle, bfd_byte *buff)
2438 struct accumulate *ainfo = (struct accumulate *) handle;
2440 return ecoff_collect_shuffle (ainfo->sym, buff);
2443 /* Copy the string table into a memory buffer. */
2445 bool
2446 _bfd_ecoff_get_accumulated_ss (void * handle, bfd_byte *buff)
2448 struct accumulate *ainfo = (struct accumulate *) handle;
2449 struct string_hash_entry *sh;
2451 /* The string table is written out from the hash table if this is a
2452 final link. */
2453 BFD_ASSERT (ainfo->ss == (struct shuffle *) NULL);
2454 *buff++ = '\0';
2455 BFD_ASSERT (ainfo->ss_hash == NULL || ainfo->ss_hash->val == 1);
2456 for (sh = ainfo->ss_hash;
2457 sh != (struct string_hash_entry *) NULL;
2458 sh = sh->next)
2460 size_t len;
2462 len = strlen (sh->root.string);
2463 memcpy (buff, sh->root.string, len + 1);
2464 buff += len + 1;
2467 return true;