1/* Routines to link ECOFF debugging information.
2   Copyright 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002, 2003,
3   2004, 2005, 2006, 2007, 2008, 2009  Free Software Foundation, Inc.
4   Written by Ian Lance Taylor, Cygnus Support, <ian@cygnus.com>.
5
6   This file is part of BFD, the Binary File Descriptor library.
7
8   This program is free software; you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 3 of the License, or
11   (at your option) any later version.
12
13   This program is distributed in the hope that it will be useful,
14   but WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16   GNU General Public License for more details.
17
18   You should have received a copy of the GNU General Public License
19   along with this program; if not, write to the Free Software
20   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21   MA 02110-1301, USA.  */
22
23#include "sysdep.h"
24#include "bfd.h"
25#include "bfdlink.h"
26#include "libbfd.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"
35
36static bfd_boolean ecoff_add_bytes
37  PARAMS ((char **buf, char **bufend, size_t need));
38static struct bfd_hash_entry *string_hash_newfunc
39  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
40	   const char *));
41static void ecoff_align_debug
42  PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
43	   const struct ecoff_debug_swap *swap));
44static bfd_boolean ecoff_write_symhdr
45  PARAMS ((bfd *, struct ecoff_debug_info *, const struct ecoff_debug_swap *,
46	   file_ptr where));
47static int cmp_fdrtab_entry
48  PARAMS ((const PTR, const PTR));
49static bfd_boolean mk_fdrtab
50  PARAMS ((bfd *, struct ecoff_debug_info * const,
51	   const struct ecoff_debug_swap * const, struct ecoff_find_line *));
52static long fdrtab_lookup
53  PARAMS ((struct ecoff_find_line *, bfd_vma));
54static bfd_boolean lookup_line
55  PARAMS ((bfd *, struct ecoff_debug_info * const,
56	   const struct ecoff_debug_swap * const, struct ecoff_find_line *));
57
58/* Routines to swap auxiliary information in and out.  I am assuming
59   that the auxiliary information format is always going to be target
60   independent.  */
61
62/* Swap in a type information record.
63   BIGEND says whether AUX symbols are big-endian or little-endian; this
64   info comes from the file header record (fh-fBigendian).  */
65
66void
67_bfd_ecoff_swap_tir_in (bigend, ext_copy, intern)
68     int bigend;
69     const struct tir_ext *ext_copy;
70     TIR *intern;
71{
72  struct tir_ext ext[1];
73
74  *ext = *ext_copy;		/* Make it reasonable to do in-place.  */
75
76  /* now the fun stuff...  */
77  if (bigend) {
78    intern->fBitfield   = 0 != (ext->t_bits1[0] & TIR_BITS1_FBITFIELD_BIG);
79    intern->continued   = 0 != (ext->t_bits1[0] & TIR_BITS1_CONTINUED_BIG);
80    intern->bt          = (ext->t_bits1[0] & TIR_BITS1_BT_BIG)
81			>>		    TIR_BITS1_BT_SH_BIG;
82    intern->tq4         = (ext->t_tq45[0] & TIR_BITS_TQ4_BIG)
83			>>		    TIR_BITS_TQ4_SH_BIG;
84    intern->tq5         = (ext->t_tq45[0] & TIR_BITS_TQ5_BIG)
85			>>		    TIR_BITS_TQ5_SH_BIG;
86    intern->tq0         = (ext->t_tq01[0] & TIR_BITS_TQ0_BIG)
87			>>		    TIR_BITS_TQ0_SH_BIG;
88    intern->tq1         = (ext->t_tq01[0] & TIR_BITS_TQ1_BIG)
89			>>		    TIR_BITS_TQ1_SH_BIG;
90    intern->tq2         = (ext->t_tq23[0] & TIR_BITS_TQ2_BIG)
91			>>		    TIR_BITS_TQ2_SH_BIG;
92    intern->tq3         = (ext->t_tq23[0] & TIR_BITS_TQ3_BIG)
93			>>		    TIR_BITS_TQ3_SH_BIG;
94  } else {
95    intern->fBitfield   = 0 != (ext->t_bits1[0] & TIR_BITS1_FBITFIELD_LITTLE);
96    intern->continued   = 0 != (ext->t_bits1[0] & TIR_BITS1_CONTINUED_LITTLE);
97    intern->bt          = (ext->t_bits1[0] & TIR_BITS1_BT_LITTLE)
98			>>		    TIR_BITS1_BT_SH_LITTLE;
99    intern->tq4         = (ext->t_tq45[0] & TIR_BITS_TQ4_LITTLE)
100			>>		    TIR_BITS_TQ4_SH_LITTLE;
101    intern->tq5         = (ext->t_tq45[0] & TIR_BITS_TQ5_LITTLE)
102			>>		    TIR_BITS_TQ5_SH_LITTLE;
103    intern->tq0         = (ext->t_tq01[0] & TIR_BITS_TQ0_LITTLE)
104			>>		    TIR_BITS_TQ0_SH_LITTLE;
105    intern->tq1         = (ext->t_tq01[0] & TIR_BITS_TQ1_LITTLE)
106			>>		    TIR_BITS_TQ1_SH_LITTLE;
107    intern->tq2         = (ext->t_tq23[0] & TIR_BITS_TQ2_LITTLE)
108			>>		    TIR_BITS_TQ2_SH_LITTLE;
109    intern->tq3         = (ext->t_tq23[0] & TIR_BITS_TQ3_LITTLE)
110			>>		    TIR_BITS_TQ3_SH_LITTLE;
111  }
112
113#ifdef TEST
114  if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
115    abort ();
116#endif
117}
118
119/* Swap out a type information record.
120   BIGEND says whether AUX symbols are big-endian or little-endian; this
121   info comes from the file header record (fh-fBigendian).  */
122
123void
124_bfd_ecoff_swap_tir_out (bigend, intern_copy, ext)
125     int bigend;
126     const TIR *intern_copy;
127     struct tir_ext *ext;
128{
129  TIR intern[1];
130
131  *intern = *intern_copy;	/* Make it reasonable to do in-place.  */
132
133  /* now the fun stuff...  */
134  if (bigend) {
135    ext->t_bits1[0] = ((intern->fBitfield ? TIR_BITS1_FBITFIELD_BIG : 0)
136		       | (intern->continued ? TIR_BITS1_CONTINUED_BIG : 0)
137		       | ((intern->bt << TIR_BITS1_BT_SH_BIG)
138			  & TIR_BITS1_BT_BIG));
139    ext->t_tq45[0] = (((intern->tq4 << TIR_BITS_TQ4_SH_BIG)
140		       & TIR_BITS_TQ4_BIG)
141		      | ((intern->tq5 << TIR_BITS_TQ5_SH_BIG)
142			 & TIR_BITS_TQ5_BIG));
143    ext->t_tq01[0] = (((intern->tq0 << TIR_BITS_TQ0_SH_BIG)
144		       & TIR_BITS_TQ0_BIG)
145		      | ((intern->tq1 << TIR_BITS_TQ1_SH_BIG)
146			 & TIR_BITS_TQ1_BIG));
147    ext->t_tq23[0] = (((intern->tq2 << TIR_BITS_TQ2_SH_BIG)
148		       & TIR_BITS_TQ2_BIG)
149		      | ((intern->tq3 << TIR_BITS_TQ3_SH_BIG)
150			 & TIR_BITS_TQ3_BIG));
151  } else {
152    ext->t_bits1[0] = ((intern->fBitfield ? TIR_BITS1_FBITFIELD_LITTLE : 0)
153		       | (intern->continued ? TIR_BITS1_CONTINUED_LITTLE : 0)
154		       | ((intern->bt << TIR_BITS1_BT_SH_LITTLE)
155			  & TIR_BITS1_BT_LITTLE));
156    ext->t_tq45[0] = (((intern->tq4 << TIR_BITS_TQ4_SH_LITTLE)
157		       & TIR_BITS_TQ4_LITTLE)
158		      | ((intern->tq5 << TIR_BITS_TQ5_SH_LITTLE)
159			 & TIR_BITS_TQ5_LITTLE));
160    ext->t_tq01[0] = (((intern->tq0 << TIR_BITS_TQ0_SH_LITTLE)
161		       & TIR_BITS_TQ0_LITTLE)
162		      | ((intern->tq1 << TIR_BITS_TQ1_SH_LITTLE)
163			 & TIR_BITS_TQ1_LITTLE));
164    ext->t_tq23[0] = (((intern->tq2 << TIR_BITS_TQ2_SH_LITTLE)
165		       & TIR_BITS_TQ2_LITTLE)
166		      | ((intern->tq3 << TIR_BITS_TQ3_SH_LITTLE)
167			 & TIR_BITS_TQ3_LITTLE));
168  }
169
170#ifdef TEST
171  if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
172    abort ();
173#endif
174}
175
176/* Swap in a relative symbol record.  BIGEND says whether it is in
177   big-endian or little-endian format.*/
178
179void
180_bfd_ecoff_swap_rndx_in (bigend, ext_copy, intern)
181     int bigend;
182     const struct rndx_ext *ext_copy;
183     RNDXR *intern;
184{
185  struct rndx_ext ext[1];
186
187  *ext = *ext_copy;		/* Make it reasonable to do in-place.  */
188
189  /* now the fun stuff...  */
190  if (bigend) {
191    intern->rfd   = (ext->r_bits[0] << RNDX_BITS0_RFD_SH_LEFT_BIG)
192		  | ((ext->r_bits[1] & RNDX_BITS1_RFD_BIG)
193		    		    >> RNDX_BITS1_RFD_SH_BIG);
194    intern->index = ((ext->r_bits[1] & RNDX_BITS1_INDEX_BIG)
195		    		    << RNDX_BITS1_INDEX_SH_LEFT_BIG)
196		  | (ext->r_bits[2] << RNDX_BITS2_INDEX_SH_LEFT_BIG)
197		  | (ext->r_bits[3] << RNDX_BITS3_INDEX_SH_LEFT_BIG);
198  } else {
199    intern->rfd   = (ext->r_bits[0] << RNDX_BITS0_RFD_SH_LEFT_LITTLE)
200		  | ((ext->r_bits[1] & RNDX_BITS1_RFD_LITTLE)
201		    		    << RNDX_BITS1_RFD_SH_LEFT_LITTLE);
202    intern->index = ((ext->r_bits[1] & RNDX_BITS1_INDEX_LITTLE)
203		    		    >> RNDX_BITS1_INDEX_SH_LITTLE)
204		  | (ext->r_bits[2] << RNDX_BITS2_INDEX_SH_LEFT_LITTLE)
205		  | ((unsigned int) ext->r_bits[3]
206		     << RNDX_BITS3_INDEX_SH_LEFT_LITTLE);
207  }
208
209#ifdef TEST
210  if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
211    abort ();
212#endif
213}
214
215/* Swap out a relative symbol record.  BIGEND says whether it is in
216   big-endian or little-endian format.*/
217
218void
219_bfd_ecoff_swap_rndx_out (bigend, intern_copy, ext)
220     int bigend;
221     const RNDXR *intern_copy;
222     struct rndx_ext *ext;
223{
224  RNDXR intern[1];
225
226  *intern = *intern_copy;	/* Make it reasonable to do in-place.  */
227
228  /* now the fun stuff...  */
229  if (bigend) {
230    ext->r_bits[0] = intern->rfd >> RNDX_BITS0_RFD_SH_LEFT_BIG;
231    ext->r_bits[1] = (((intern->rfd << RNDX_BITS1_RFD_SH_BIG)
232		       & RNDX_BITS1_RFD_BIG)
233		      | ((intern->index >> RNDX_BITS1_INDEX_SH_LEFT_BIG)
234			 & RNDX_BITS1_INDEX_BIG));
235    ext->r_bits[2] = intern->index >> RNDX_BITS2_INDEX_SH_LEFT_BIG;
236    ext->r_bits[3] = intern->index >> RNDX_BITS3_INDEX_SH_LEFT_BIG;
237  } else {
238    ext->r_bits[0] = intern->rfd >> RNDX_BITS0_RFD_SH_LEFT_LITTLE;
239    ext->r_bits[1] = (((intern->rfd >> RNDX_BITS1_RFD_SH_LEFT_LITTLE)
240		       & RNDX_BITS1_RFD_LITTLE)
241		      | ((intern->index << RNDX_BITS1_INDEX_SH_LITTLE)
242			 & RNDX_BITS1_INDEX_LITTLE));
243    ext->r_bits[2] = intern->index >> RNDX_BITS2_INDEX_SH_LEFT_LITTLE;
244    ext->r_bits[3] = intern->index >> RNDX_BITS3_INDEX_SH_LEFT_LITTLE;
245  }
246
247#ifdef TEST
248  if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0)
249    abort ();
250#endif
251}
252
253/* The minimum amount of data to allocate.  */
254#define ALLOC_SIZE (4064)
255
256/* Add bytes to a buffer.  Return success.  */
257
258static bfd_boolean
259ecoff_add_bytes (buf, bufend, need)
260     char **buf;
261     char **bufend;
262     size_t need;
263{
264  size_t have;
265  size_t want;
266  char *newbuf;
267
268  have = *bufend - *buf;
269  if (have > need)
270    want = ALLOC_SIZE;
271  else
272    {
273      want = need - have;
274      if (want < ALLOC_SIZE)
275	want = ALLOC_SIZE;
276    }
277  newbuf = (char *) bfd_realloc (*buf, (bfd_size_type) have + want);
278  if (newbuf == NULL)
279    return FALSE;
280  *buf = newbuf;
281  *bufend = *buf + have + want;
282  return TRUE;
283}
284
285/* We keep a hash table which maps strings to numbers.  We use it to
286   map FDR names to indices in the output file, and to map local
287   strings when combining stabs debugging information.  */
288
289struct string_hash_entry
290{
291  struct bfd_hash_entry root;
292  /* FDR index or string table offset.  */
293  long val;
294  /* Next entry in string table.  */
295  struct string_hash_entry *next;
296};
297
298struct string_hash_table
299{
300  struct bfd_hash_table table;
301};
302
303/* Routine to create an entry in a string hash table.  */
304
305static struct bfd_hash_entry *
306string_hash_newfunc (entry, table, string)
307     struct bfd_hash_entry *entry;
308     struct bfd_hash_table *table;
309     const char *string;
310{
311  struct string_hash_entry *ret = (struct string_hash_entry *) entry;
312
313  /* Allocate the structure if it has not already been allocated by a
314     subclass.  */
315  if (ret == (struct string_hash_entry *) NULL)
316    ret = ((struct string_hash_entry *)
317	   bfd_hash_allocate (table, sizeof (struct string_hash_entry)));
318  if (ret == (struct string_hash_entry *) NULL)
319    return NULL;
320
321  /* Call the allocation method of the superclass.  */
322  ret = ((struct string_hash_entry *)
323	 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
324
325  if (ret)
326    {
327      /* Initialize the local fields.  */
328      ret->val = -1;
329      ret->next = NULL;
330    }
331
332  return (struct bfd_hash_entry *) ret;
333}
334
335/* Look up an entry in an string hash table.  */
336
337#define string_hash_lookup(t, string, create, copy) \
338  ((struct string_hash_entry *) \
339   bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
340
341/* We can't afford to read in all the debugging information when we do
342   a link.  Instead, we build a list of these structures to show how
343   different parts of the input file map to the output file.  */
344
345struct shuffle
346{
347  /* The next entry in this linked list.  */
348  struct shuffle *next;
349  /* The length of the information.  */
350  unsigned long size;
351  /* Whether this information comes from a file or not.  */
352  bfd_boolean filep;
353  union
354    {
355      struct
356	{
357	  /* The BFD the data comes from.  */
358	  bfd *input_bfd;
359	  /* The offset within input_bfd.  */
360	  file_ptr offset;
361	} file;
362      /* The data to be written out.  */
363      PTR memory;
364    } u;
365};
366
367/* This structure holds information across calls to
368   bfd_ecoff_debug_accumulate.  */
369
370struct accumulate
371{
372  /* The FDR hash table.  */
373  struct string_hash_table fdr_hash;
374  /* The strings hash table.  */
375  struct string_hash_table str_hash;
376  /* Linked lists describing how to shuffle the input debug
377     information into the output file.  We keep a pointer to both the
378     head and the tail.  */
379  struct shuffle *line;
380  struct shuffle *line_end;
381  struct shuffle *pdr;
382  struct shuffle *pdr_end;
383  struct shuffle *sym;
384  struct shuffle *sym_end;
385  struct shuffle *opt;
386  struct shuffle *opt_end;
387  struct shuffle *aux;
388  struct shuffle *aux_end;
389  struct shuffle *ss;
390  struct shuffle *ss_end;
391  struct string_hash_entry *ss_hash;
392  struct string_hash_entry *ss_hash_end;
393  struct shuffle *fdr;
394  struct shuffle *fdr_end;
395  struct shuffle *rfd;
396  struct shuffle *rfd_end;
397  /* The size of the largest file shuffle.  */
398  unsigned long largest_file_shuffle;
399  /* An objalloc for debugging information.  */
400  struct objalloc *memory;
401};
402
403/* Add a file entry to a shuffle list.  */
404
405static bfd_boolean add_file_shuffle
406  PARAMS ((struct accumulate *, struct shuffle **, struct shuffle **,
407	   bfd *, file_ptr, unsigned long));
408
409static bfd_boolean
410add_file_shuffle (ainfo, head, tail, input_bfd, offset, size)
411     struct accumulate *ainfo;
412     struct shuffle **head;
413     struct shuffle **tail;
414     bfd *input_bfd;
415     file_ptr offset;
416     unsigned long size;
417{
418  struct shuffle *n;
419
420  if (*tail != (struct shuffle *) NULL
421      && (*tail)->filep
422      && (*tail)->u.file.input_bfd == input_bfd
423      && (*tail)->u.file.offset + (*tail)->size == (unsigned long) offset)
424    {
425      /* Just merge this entry onto the existing one.  */
426      (*tail)->size += size;
427      if ((*tail)->size > ainfo->largest_file_shuffle)
428	ainfo->largest_file_shuffle = (*tail)->size;
429      return TRUE;
430    }
431
432  n = (struct shuffle *) objalloc_alloc (ainfo->memory,
433					 sizeof (struct shuffle));
434  if (!n)
435    {
436      bfd_set_error (bfd_error_no_memory);
437      return FALSE;
438    }
439  n->next = NULL;
440  n->size = size;
441  n->filep = TRUE;
442  n->u.file.input_bfd = input_bfd;
443  n->u.file.offset = offset;
444  if (*head == (struct shuffle *) NULL)
445    *head = n;
446  if (*tail != (struct shuffle *) NULL)
447    (*tail)->next = n;
448  *tail = n;
449  if (size > ainfo->largest_file_shuffle)
450    ainfo->largest_file_shuffle = size;
451  return TRUE;
452}
453
454/* Add a memory entry to a shuffle list.  */
455
456static bfd_boolean add_memory_shuffle
457  PARAMS ((struct accumulate *, struct shuffle **head, struct shuffle **tail,
458	   bfd_byte *data, unsigned long size));
459
460static bfd_boolean
461add_memory_shuffle (ainfo, head, tail, data, size)
462     struct accumulate *ainfo;
463     struct shuffle **head;
464     struct shuffle **tail;
465     bfd_byte *data;
466     unsigned long size;
467{
468  struct shuffle *n;
469
470  n = (struct shuffle *) objalloc_alloc (ainfo->memory,
471					 sizeof (struct shuffle));
472  if (!n)
473    {
474      bfd_set_error (bfd_error_no_memory);
475      return FALSE;
476    }
477  n->next = NULL;
478  n->size = size;
479  n->filep = FALSE;
480  n->u.memory = (PTR) data;
481  if (*head == (struct shuffle *) NULL)
482    *head = n;
483  if (*tail != (struct shuffle *) NULL)
484    (*tail)->next = n;
485  *tail = n;
486  return TRUE;
487}
488
489/* Initialize the FDR hash table.  This returns a handle which is then
490   passed in to bfd_ecoff_debug_accumulate, et. al.  */
491
492PTR
493bfd_ecoff_debug_init (output_bfd, output_debug, output_swap, info)
494     bfd *output_bfd ATTRIBUTE_UNUSED;
495     struct ecoff_debug_info *output_debug;
496     const struct ecoff_debug_swap *output_swap ATTRIBUTE_UNUSED;
497     struct bfd_link_info *info;
498{
499  struct accumulate *ainfo;
500  bfd_size_type amt = sizeof (struct accumulate);
501
502  ainfo = (struct accumulate *) bfd_malloc (amt);
503  if (!ainfo)
504    return NULL;
505  if (!bfd_hash_table_init_n (&ainfo->fdr_hash.table, string_hash_newfunc,
506			      sizeof (struct string_hash_entry), 1021))
507    return NULL;
508
509  ainfo->line = NULL;
510  ainfo->line_end = NULL;
511  ainfo->pdr = NULL;
512  ainfo->pdr_end = NULL;
513  ainfo->sym = NULL;
514  ainfo->sym_end = NULL;
515  ainfo->opt = NULL;
516  ainfo->opt_end = NULL;
517  ainfo->aux = NULL;
518  ainfo->aux_end = NULL;
519  ainfo->ss = NULL;
520  ainfo->ss_end = NULL;
521  ainfo->ss_hash = NULL;
522  ainfo->ss_hash_end = NULL;
523  ainfo->fdr = NULL;
524  ainfo->fdr_end = NULL;
525  ainfo->rfd = NULL;
526  ainfo->rfd_end = NULL;
527
528  ainfo->largest_file_shuffle = 0;
529
530  if (! info->relocatable)
531    {
532      if (!bfd_hash_table_init (&ainfo->str_hash.table, string_hash_newfunc,
533				sizeof (struct string_hash_entry)))
534	return NULL;
535
536      /* The first entry in the string table is the empty string.  */
537      output_debug->symbolic_header.issMax = 1;
538    }
539
540  ainfo->memory = objalloc_create ();
541  if (ainfo->memory == NULL)
542    {
543      bfd_set_error (bfd_error_no_memory);
544      return NULL;
545    }
546
547  return (PTR) ainfo;
548}
549
550/* Free the accumulated debugging information.  */
551
552void
553bfd_ecoff_debug_free (handle, output_bfd, output_debug, output_swap, info)
554     PTR handle;
555     bfd *output_bfd ATTRIBUTE_UNUSED;
556     struct ecoff_debug_info *output_debug ATTRIBUTE_UNUSED;
557     const struct ecoff_debug_swap *output_swap ATTRIBUTE_UNUSED;
558     struct bfd_link_info *info;
559{
560  struct accumulate *ainfo = (struct accumulate *) handle;
561
562  bfd_hash_table_free (&ainfo->fdr_hash.table);
563
564  if (! info->relocatable)
565    bfd_hash_table_free (&ainfo->str_hash.table);
566
567  objalloc_free (ainfo->memory);
568
569  free (ainfo);
570}
571
572/* Accumulate the debugging information from INPUT_BFD into
573   OUTPUT_BFD.  The INPUT_DEBUG argument points to some ECOFF
574   debugging information which we want to link into the information
575   pointed to by the OUTPUT_DEBUG argument.  OUTPUT_SWAP and
576   INPUT_SWAP point to the swapping information needed.  INFO is the
577   linker information structure.  HANDLE is returned by
578   bfd_ecoff_debug_init.  */
579
580bfd_boolean
581bfd_ecoff_debug_accumulate (handle, output_bfd, output_debug, output_swap,
582			    input_bfd, input_debug, input_swap,
583			    info)
584     PTR handle;
585     bfd *output_bfd;
586     struct ecoff_debug_info *output_debug;
587     const struct ecoff_debug_swap *output_swap;
588     bfd *input_bfd;
589     struct ecoff_debug_info *input_debug;
590     const struct ecoff_debug_swap *input_swap;
591     struct bfd_link_info *info;
592{
593  struct accumulate *ainfo = (struct accumulate *) handle;
594  void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *))
595    = input_swap->swap_sym_in;
596  void (* const swap_rfd_in) PARAMS ((bfd *, PTR, RFDT *))
597    = input_swap->swap_rfd_in;
598  void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
599    = output_swap->swap_sym_out;
600  void (* const swap_fdr_out) PARAMS ((bfd *, const FDR *, PTR))
601    = output_swap->swap_fdr_out;
602  void (* const swap_rfd_out) PARAMS ((bfd *, const RFDT *, PTR))
603    = output_swap->swap_rfd_out;
604  bfd_size_type external_pdr_size = output_swap->external_pdr_size;
605  bfd_size_type external_sym_size = output_swap->external_sym_size;
606  bfd_size_type external_opt_size = output_swap->external_opt_size;
607  bfd_size_type external_fdr_size = output_swap->external_fdr_size;
608  bfd_size_type external_rfd_size = output_swap->external_rfd_size;
609  HDRR * const output_symhdr = &output_debug->symbolic_header;
610  HDRR * const input_symhdr = &input_debug->symbolic_header;
611  bfd_vma section_adjust[scMax];
612  asection *sec;
613  bfd_byte *fdr_start;
614  bfd_byte *fdr_ptr;
615  bfd_byte *fdr_end;
616  bfd_size_type fdr_add;
617  unsigned int copied;
618  RFDT i;
619  unsigned long sz;
620  bfd_byte *rfd_out;
621  bfd_byte *rfd_in;
622  bfd_byte *rfd_end;
623  long newrfdbase = 0;
624  long oldrfdbase = 0;
625  bfd_byte *fdr_out;
626  bfd_size_type amt;
627
628  /* Use section_adjust to hold the value to add to a symbol in a
629     particular section.  */
630  memset ((PTR) section_adjust, 0, sizeof section_adjust);
631
632#define SET(name, indx) \
633  sec = bfd_get_section_by_name (input_bfd, name); \
634  if (sec != NULL) \
635    section_adjust[indx] = (sec->output_section->vma \
636			    + sec->output_offset \
637			    - sec->vma);
638
639  SET (".text", scText);
640  SET (".data", scData);
641  SET (".bss", scBss);
642  SET (".sdata", scSData);
643  SET (".sbss", scSBss);
644  /* scRdata section may be either .rdata or .rodata.  */
645  SET (".rdata", scRData);
646  SET (".rodata", scRData);
647  SET (".init", scInit);
648  SET (".fini", scFini);
649  SET (".rconst", scRConst);
650
651#undef SET
652
653  /* Find all the debugging information based on the FDR's.  We need
654     to handle them whether they are swapped or not.  */
655  if (input_debug->fdr != (FDR *) NULL)
656    {
657      fdr_start = (bfd_byte *) input_debug->fdr;
658      fdr_add = sizeof (FDR);
659    }
660  else
661    {
662      fdr_start = (bfd_byte *) input_debug->external_fdr;
663      fdr_add = input_swap->external_fdr_size;
664    }
665  fdr_end = fdr_start + input_symhdr->ifdMax * fdr_add;
666
667  amt = input_symhdr->ifdMax;
668  amt *= sizeof (RFDT);
669  input_debug->ifdmap = (RFDT *) bfd_alloc (input_bfd, amt);
670
671  sz = (input_symhdr->crfd + input_symhdr->ifdMax) * external_rfd_size;
672  rfd_out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz);
673  if (!input_debug->ifdmap || !rfd_out)
674    {
675      bfd_set_error (bfd_error_no_memory);
676      return FALSE;
677    }
678  if (!add_memory_shuffle (ainfo, &ainfo->rfd, &ainfo->rfd_end, rfd_out, sz))
679    return FALSE;
680
681  copied = 0;
682
683  /* Look through the FDR's to see which ones we are going to include
684     in the final output.  We do not want duplicate FDR information
685     for header files, because ECOFF debugging is often very large.
686     When we find an FDR with no line information which can be merged,
687     we look it up in a hash table to ensure that we only include it
688     once.  We keep a table mapping FDR numbers to the final number
689     they get with the BFD, so that we can refer to it when we write
690     out the external symbols.  */
691  for (fdr_ptr = fdr_start, i = 0;
692       fdr_ptr < fdr_end;
693       fdr_ptr += fdr_add, i++, rfd_out += external_rfd_size)
694    {
695      FDR fdr;
696
697      if (input_debug->fdr != (FDR *) NULL)
698	fdr = *(FDR *) fdr_ptr;
699      else
700	(*input_swap->swap_fdr_in) (input_bfd, (PTR) fdr_ptr, &fdr);
701
702      /* See if this FDR can be merged with an existing one.  */
703      if (fdr.cbLine == 0 && fdr.rss != -1 && fdr.fMerge)
704	{
705	  const char *name;
706	  char *lookup;
707	  struct string_hash_entry *fh;
708
709	  /* We look up a string formed from the file name and the
710	     number of symbols and aux entries.  Sometimes an include
711	     file will conditionally define a typedef or something
712	     based on the order of include files.  Using the number of
713	     symbols and aux entries as a hash reduces the chance that
714	     we will merge symbol information that should not be
715	     merged.  */
716	  name = input_debug->ss + fdr.issBase + fdr.rss;
717
718	  lookup = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 20);
719	  if (lookup == NULL)
720	    return FALSE;
721	  sprintf (lookup, "%s %lx %lx", name, (unsigned long) fdr.csym,
722		   (unsigned long) fdr.caux);
723
724	  fh = string_hash_lookup (&ainfo->fdr_hash, lookup, TRUE, TRUE);
725	  free (lookup);
726	  if (fh == (struct string_hash_entry *) NULL)
727	    return FALSE;
728
729	  if (fh->val != -1)
730	    {
731	      input_debug->ifdmap[i] = fh->val;
732	      (*swap_rfd_out) (output_bfd, input_debug->ifdmap + i,
733			       (PTR) rfd_out);
734
735	      /* Don't copy this FDR.  */
736	      continue;
737	    }
738
739	  fh->val = output_symhdr->ifdMax + copied;
740	}
741
742      input_debug->ifdmap[i] = output_symhdr->ifdMax + copied;
743      (*swap_rfd_out) (output_bfd, input_debug->ifdmap + i, (PTR) rfd_out);
744      ++copied;
745    }
746
747  newrfdbase = output_symhdr->crfd;
748  output_symhdr->crfd += input_symhdr->ifdMax;
749
750  /* Copy over any existing RFD's.  RFD's are only created by the
751     linker, so this will only happen for input files which are the
752     result of a partial link.  */
753  rfd_in = (bfd_byte *) input_debug->external_rfd;
754  rfd_end = rfd_in + input_symhdr->crfd * input_swap->external_rfd_size;
755  for (;
756       rfd_in < rfd_end;
757       rfd_in += input_swap->external_rfd_size)
758    {
759      RFDT rfd;
760
761      (*swap_rfd_in) (input_bfd, (PTR) rfd_in, &rfd);
762      BFD_ASSERT (rfd >= 0 && rfd < input_symhdr->ifdMax);
763      rfd = input_debug->ifdmap[rfd];
764      (*swap_rfd_out) (output_bfd, &rfd, (PTR) rfd_out);
765      rfd_out += external_rfd_size;
766    }
767
768  oldrfdbase = output_symhdr->crfd;
769  output_symhdr->crfd += input_symhdr->crfd;
770
771  /* Look through the FDR's and copy over all associated debugging
772     information.  */
773  sz = copied * external_fdr_size;
774  fdr_out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz);
775  if (!fdr_out)
776    {
777      bfd_set_error (bfd_error_no_memory);
778      return FALSE;
779    }
780  if (!add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end, fdr_out, sz))
781    return FALSE;
782  for (fdr_ptr = fdr_start, i = 0;
783       fdr_ptr < fdr_end;
784       fdr_ptr += fdr_add, i++)
785    {
786      FDR fdr;
787      bfd_byte *sym_out;
788      bfd_byte *lraw_src;
789      bfd_byte *lraw_end;
790      bfd_boolean fgotfilename;
791
792      if (input_debug->ifdmap[i] < output_symhdr->ifdMax)
793	{
794	  /* We are not copying this FDR.  */
795	  continue;
796	}
797
798      if (input_debug->fdr != (FDR *) NULL)
799	fdr = *(FDR *) fdr_ptr;
800      else
801	(*input_swap->swap_fdr_in) (input_bfd, (PTR) fdr_ptr, &fdr);
802
803      /* FIXME: It is conceivable that this FDR points to the .init or
804	 .fini section, in which case this will not do the right
805	 thing.  */
806      fdr.adr += section_adjust[scText];
807
808      /* Swap in the local symbols, adjust their values, and swap them
809	 out again.  */
810      fgotfilename = FALSE;
811      sz = fdr.csym * external_sym_size;
812      sym_out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz);
813      if (!sym_out)
814	{
815	  bfd_set_error (bfd_error_no_memory);
816	  return FALSE;
817	}
818      if (!add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end, sym_out,
819			       sz))
820	return FALSE;
821      lraw_src = ((bfd_byte *) input_debug->external_sym
822		  + fdr.isymBase * input_swap->external_sym_size);
823      lraw_end = lraw_src + fdr.csym * input_swap->external_sym_size;
824      for (;  lraw_src < lraw_end;  lraw_src += input_swap->external_sym_size)
825	{
826	  SYMR internal_sym;
827
828	  (*swap_sym_in) (input_bfd, (PTR) lraw_src, &internal_sym);
829
830	  BFD_ASSERT (internal_sym.sc != scCommon
831		      && internal_sym.sc != scSCommon);
832
833	  /* Adjust the symbol value if appropriate.  */
834	  switch (internal_sym.st)
835	    {
836	    case stNil:
837	      if (ECOFF_IS_STAB (&internal_sym))
838		break;
839	      /* Fall through.  */
840	    case stGlobal:
841	    case stStatic:
842	    case stLabel:
843	    case stProc:
844	    case stStaticProc:
845	      internal_sym.value += section_adjust[internal_sym.sc];
846	      break;
847
848	    default:
849	      break;
850	    }
851
852	  /* If we are doing a final link, we hash all the strings in
853	     the local symbol table together.  This reduces the amount
854	     of space required by debugging information.  We don't do
855	     this when performing a relocatable link because it would
856	     prevent us from easily merging different FDR's.  */
857	  if (! info->relocatable)
858	    {
859	      bfd_boolean ffilename;
860	      const char *name;
861
862	      if (! fgotfilename && internal_sym.iss == fdr.rss)
863		ffilename = TRUE;
864	      else
865		ffilename = FALSE;
866
867	      /* Hash the name into the string table.  */
868	      name = input_debug->ss + fdr.issBase + internal_sym.iss;
869	      if (*name == '\0')
870		internal_sym.iss = 0;
871	      else
872		{
873		  struct string_hash_entry *sh;
874
875		  sh = string_hash_lookup (&ainfo->str_hash, name, TRUE, TRUE);
876		  if (sh == (struct string_hash_entry *) NULL)
877		    return FALSE;
878		  if (sh->val == -1)
879		    {
880		      sh->val = output_symhdr->issMax;
881		      output_symhdr->issMax += strlen (name) + 1;
882		      if (ainfo->ss_hash == (struct string_hash_entry *) NULL)
883			ainfo->ss_hash = sh;
884		      if (ainfo->ss_hash_end
885			  != (struct string_hash_entry *) NULL)
886			ainfo->ss_hash_end->next = sh;
887		      ainfo->ss_hash_end = sh;
888		    }
889		  internal_sym.iss = sh->val;
890		}
891
892	      if (ffilename)
893		{
894		  fdr.rss = internal_sym.iss;
895		  fgotfilename = TRUE;
896		}
897	    }
898
899	  (*swap_sym_out) (output_bfd, &internal_sym, sym_out);
900	  sym_out += external_sym_size;
901	}
902
903      fdr.isymBase = output_symhdr->isymMax;
904      output_symhdr->isymMax += fdr.csym;
905
906      /* Copy the information that does not need swapping.  */
907
908      /* FIXME: If we are relaxing, we need to adjust the line
909	 numbers.  Frankly, forget it.  Anybody using stabs debugging
910	 information will not use this line number information, and
911	 stabs are adjusted correctly.  */
912      if (fdr.cbLine > 0)
913	{
914	  file_ptr pos = input_symhdr->cbLineOffset + fdr.cbLineOffset;
915	  if (!add_file_shuffle (ainfo, &ainfo->line, &ainfo->line_end,
916				 input_bfd, pos, (unsigned long) fdr.cbLine))
917	    return FALSE;
918	  fdr.ilineBase = output_symhdr->ilineMax;
919	  fdr.cbLineOffset = output_symhdr->cbLine;
920	  output_symhdr->ilineMax += fdr.cline;
921	  output_symhdr->cbLine += fdr.cbLine;
922	}
923      if (fdr.caux > 0)
924	{
925	  file_ptr pos = (input_symhdr->cbAuxOffset
926			  + fdr.iauxBase * sizeof (union aux_ext));
927	  if (!add_file_shuffle (ainfo, &ainfo->aux, &ainfo->aux_end,
928				 input_bfd, pos,
929				 fdr.caux * sizeof (union aux_ext)))
930	    return FALSE;
931	  fdr.iauxBase = output_symhdr->iauxMax;
932	  output_symhdr->iauxMax += fdr.caux;
933	}
934      if (! info->relocatable)
935	{
936
937	  /* When are are hashing strings, we lie about the number of
938	     strings attached to each FDR.  We need to set cbSs
939	     because some versions of dbx apparently use it to decide
940	     how much of the string table to read in.  */
941	  fdr.issBase = 0;
942	  fdr.cbSs = output_symhdr->issMax;
943	}
944      else if (fdr.cbSs > 0)
945	{
946	  file_ptr pos = input_symhdr->cbSsOffset + fdr.issBase;
947	  if (!add_file_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end,
948				 input_bfd, pos, (unsigned long) fdr.cbSs))
949	    return FALSE;
950	  fdr.issBase = output_symhdr->issMax;
951	  output_symhdr->issMax += fdr.cbSs;
952	}
953
954      if (output_bfd->xvec->header_byteorder
955	  == input_bfd->xvec->header_byteorder)
956	{
957	  /* The two BFD's have the same endianness, and we don't have
958	     to adjust the PDR addresses, so simply copying the
959	     information will suffice.  */
960	  BFD_ASSERT (external_pdr_size == input_swap->external_pdr_size);
961	  if (fdr.cpd > 0)
962	    {
963	      file_ptr pos = (input_symhdr->cbPdOffset
964			      + fdr.ipdFirst * external_pdr_size);
965	      unsigned long size = fdr.cpd * external_pdr_size;
966	      if (!add_file_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end,
967				     input_bfd, pos, size))
968		return FALSE;
969	    }
970	  BFD_ASSERT (external_opt_size == input_swap->external_opt_size);
971	  if (fdr.copt > 0)
972	    {
973	      file_ptr pos = (input_symhdr->cbOptOffset
974			      + fdr.ioptBase * external_opt_size);
975	      unsigned long size = fdr.copt * external_opt_size;
976	      if (!add_file_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end,
977				     input_bfd, pos, size))
978		return FALSE;
979	    }
980	}
981      else
982	{
983	  bfd_size_type outsz, insz;
984	  bfd_byte *in;
985	  bfd_byte *end;
986	  bfd_byte *out;
987
988	  /* The two BFD's have different endianness, so we must swap
989	     everything in and out.  This code would always work, but
990	     it would be unnecessarily slow in the normal case.  */
991	  outsz = external_pdr_size;
992	  insz = input_swap->external_pdr_size;
993	  in = ((bfd_byte *) input_debug->external_pdr
994		+ fdr.ipdFirst * insz);
995	  end = in + fdr.cpd * insz;
996	  sz = fdr.cpd * outsz;
997	  out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz);
998	  if (!out)
999	    {
1000	      bfd_set_error (bfd_error_no_memory);
1001	      return FALSE;
1002	    }
1003	  if (!add_memory_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end, out,
1004				   sz))
1005	    return FALSE;
1006	  for (; in < end; in += insz, out += outsz)
1007	    {
1008	      PDR pdr;
1009
1010	      (*input_swap->swap_pdr_in) (input_bfd, (PTR) in, &pdr);
1011	      (*output_swap->swap_pdr_out) (output_bfd, &pdr, (PTR) out);
1012	    }
1013
1014	  /* Swap over the optimization information.  */
1015	  outsz = external_opt_size;
1016	  insz = input_swap->external_opt_size;
1017	  in = ((bfd_byte *) input_debug->external_opt
1018		+ fdr.ioptBase * insz);
1019	  end = in + fdr.copt * insz;
1020	  sz = fdr.copt * outsz;
1021	  out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz);
1022	  if (!out)
1023	    {
1024	      bfd_set_error (bfd_error_no_memory);
1025	      return FALSE;
1026	    }
1027	  if (!add_memory_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end, out,
1028				   sz))
1029	    return FALSE;
1030	  for (; in < end; in += insz, out += outsz)
1031	    {
1032	      OPTR opt;
1033
1034	      (*input_swap->swap_opt_in) (input_bfd, (PTR) in, &opt);
1035	      (*output_swap->swap_opt_out) (output_bfd, &opt, (PTR) out);
1036	    }
1037	}
1038
1039      fdr.ipdFirst = output_symhdr->ipdMax;
1040      output_symhdr->ipdMax += fdr.cpd;
1041      fdr.ioptBase = output_symhdr->ioptMax;
1042      output_symhdr->ioptMax += fdr.copt;
1043
1044      if (fdr.crfd <= 0)
1045	{
1046	  /* Point this FDR at the table of RFD's we created.  */
1047	  fdr.rfdBase = newrfdbase;
1048	  fdr.crfd = input_symhdr->ifdMax;
1049	}
1050      else
1051	{
1052	  /* Point this FDR at the remapped RFD's.  */
1053	  fdr.rfdBase += oldrfdbase;
1054	}
1055
1056      (*swap_fdr_out) (output_bfd, &fdr, fdr_out);
1057      fdr_out += external_fdr_size;
1058      ++output_symhdr->ifdMax;
1059    }
1060
1061  return TRUE;
1062}
1063
1064/* Add a string to the debugging information we are accumulating.
1065   Return the offset from the fdr string base.  */
1066
1067static long ecoff_add_string
1068  PARAMS ((struct accumulate *, struct bfd_link_info *,
1069	   struct ecoff_debug_info *, FDR *fdr, const char *string));
1070
1071static long
1072ecoff_add_string (ainfo, info, debug, fdr, string)
1073     struct accumulate *ainfo;
1074     struct bfd_link_info *info;
1075     struct ecoff_debug_info *debug;
1076     FDR *fdr;
1077     const char *string;
1078{
1079  HDRR *symhdr;
1080  size_t len;
1081  bfd_size_type ret;
1082
1083  symhdr = &debug->symbolic_header;
1084  len = strlen (string);
1085  if (info->relocatable)
1086    {
1087      if (!add_memory_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end,
1088                               (bfd_byte *) string, len + 1))
1089	return -1;
1090      ret = symhdr->issMax;
1091      symhdr->issMax += len + 1;
1092      fdr->cbSs += len + 1;
1093    }
1094  else
1095    {
1096      struct string_hash_entry *sh;
1097
1098      sh = string_hash_lookup (&ainfo->str_hash, string, TRUE, TRUE);
1099      if (sh == (struct string_hash_entry *) NULL)
1100	return -1;
1101      if (sh->val == -1)
1102	{
1103	  sh->val = symhdr->issMax;
1104	  symhdr->issMax += len + 1;
1105	  if (ainfo->ss_hash == (struct string_hash_entry *) NULL)
1106	    ainfo->ss_hash = sh;
1107	  if (ainfo->ss_hash_end
1108	      != (struct string_hash_entry *) NULL)
1109	    ainfo->ss_hash_end->next = sh;
1110	  ainfo->ss_hash_end = sh;
1111	}
1112      ret = sh->val;
1113    }
1114
1115  return ret;
1116}
1117
1118/* Add debugging information from a non-ECOFF file.  */
1119
1120bfd_boolean
1121bfd_ecoff_debug_accumulate_other (handle, output_bfd, output_debug,
1122				  output_swap, input_bfd, info)
1123     PTR handle;
1124     bfd *output_bfd;
1125     struct ecoff_debug_info *output_debug;
1126     const struct ecoff_debug_swap *output_swap;
1127     bfd *input_bfd;
1128     struct bfd_link_info *info;
1129{
1130  struct accumulate *ainfo = (struct accumulate *) handle;
1131  void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
1132    = output_swap->swap_sym_out;
1133  HDRR *output_symhdr = &output_debug->symbolic_header;
1134  FDR fdr;
1135  asection *sec;
1136  asymbol **symbols;
1137  asymbol **sym_ptr;
1138  asymbol **sym_end;
1139  long symsize;
1140  long symcount;
1141  PTR external_fdr;
1142
1143  memset ((PTR) &fdr, 0, sizeof fdr);
1144
1145  sec = bfd_get_section_by_name (input_bfd, ".text");
1146  if (sec != NULL)
1147    fdr.adr = sec->output_section->vma + sec->output_offset;
1148  else
1149    {
1150      /* FIXME: What about .init or .fini?  */
1151      fdr.adr = 0;
1152    }
1153
1154  fdr.issBase = output_symhdr->issMax;
1155  fdr.cbSs = 0;
1156  fdr.rss = ecoff_add_string (ainfo, info, output_debug, &fdr,
1157			      input_bfd->filename);
1158  if (fdr.rss == -1)
1159    return FALSE;
1160  fdr.isymBase = output_symhdr->isymMax;
1161
1162  /* Get the local symbols from the input BFD.  */
1163  symsize = bfd_get_symtab_upper_bound (input_bfd);
1164  if (symsize < 0)
1165    return FALSE;
1166  symbols = (asymbol **) bfd_alloc (output_bfd, (bfd_size_type) symsize);
1167  if (symbols == (asymbol **) NULL)
1168    return FALSE;
1169  symcount = bfd_canonicalize_symtab (input_bfd, symbols);
1170  if (symcount < 0)
1171    return FALSE;
1172  sym_end = symbols + symcount;
1173
1174  /* Handle the local symbols.  Any external symbols are handled
1175     separately.  */
1176  fdr.csym = 0;
1177  for (sym_ptr = symbols; sym_ptr != sym_end; sym_ptr++)
1178    {
1179      SYMR internal_sym;
1180      PTR external_sym;
1181
1182      if (((*sym_ptr)->flags & BSF_EXPORT) != 0)
1183	continue;
1184      memset ((PTR) &internal_sym, 0, sizeof internal_sym);
1185      internal_sym.iss = ecoff_add_string (ainfo, info, output_debug, &fdr,
1186					   (*sym_ptr)->name);
1187
1188      if (internal_sym.iss == -1)
1189	return FALSE;
1190      if (bfd_is_com_section ((*sym_ptr)->section)
1191	  || bfd_is_und_section ((*sym_ptr)->section))
1192	internal_sym.value = (*sym_ptr)->value;
1193      else
1194	internal_sym.value = ((*sym_ptr)->value
1195			      + (*sym_ptr)->section->output_offset
1196			      + (*sym_ptr)->section->output_section->vma);
1197      internal_sym.st = stNil;
1198      internal_sym.sc = scUndefined;
1199      internal_sym.index = indexNil;
1200
1201      external_sym = (PTR) objalloc_alloc (ainfo->memory,
1202					   output_swap->external_sym_size);
1203      if (!external_sym)
1204	{
1205	  bfd_set_error (bfd_error_no_memory);
1206	  return FALSE;
1207	}
1208      (*swap_sym_out) (output_bfd, &internal_sym, external_sym);
1209      add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end,
1210			  (bfd_byte *) external_sym,
1211			  (unsigned long) output_swap->external_sym_size);
1212      ++fdr.csym;
1213      ++output_symhdr->isymMax;
1214    }
1215
1216  bfd_release (output_bfd, (PTR) symbols);
1217
1218  /* Leave everything else in the FDR zeroed out.  This will cause
1219     the lang field to be langC.  The fBigendian field will
1220     indicate little endian format, but it doesn't matter because
1221     it only applies to aux fields and there are none.  */
1222  external_fdr = (PTR) objalloc_alloc (ainfo->memory,
1223				       output_swap->external_fdr_size);
1224  if (!external_fdr)
1225    {
1226      bfd_set_error (bfd_error_no_memory);
1227      return FALSE;
1228    }
1229  (*output_swap->swap_fdr_out) (output_bfd, &fdr, external_fdr);
1230  add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end,
1231		      (bfd_byte *) external_fdr,
1232		      (unsigned long) output_swap->external_fdr_size);
1233
1234  ++output_symhdr->ifdMax;
1235
1236  return TRUE;
1237}
1238
1239/* Set up ECOFF debugging information for the external symbols.
1240   FIXME: This is done using a memory buffer, but it should be
1241   probably be changed to use a shuffle structure.  The assembler uses
1242   this interface, so that must be changed to do something else.  */
1243
1244bfd_boolean
1245bfd_ecoff_debug_externals (abfd, debug, swap, relocatable, get_extr,
1246			   set_index)
1247     bfd *abfd;
1248     struct ecoff_debug_info *debug;
1249     const struct ecoff_debug_swap *swap;
1250     bfd_boolean relocatable;
1251     bfd_boolean (*get_extr) PARAMS ((asymbol *, EXTR *));
1252     void (*set_index) PARAMS ((asymbol *, bfd_size_type));
1253{
1254  HDRR * const symhdr = &debug->symbolic_header;
1255  asymbol **sym_ptr_ptr;
1256  size_t c;
1257
1258  sym_ptr_ptr = bfd_get_outsymbols (abfd);
1259  if (sym_ptr_ptr == NULL)
1260    return TRUE;
1261
1262  for (c = bfd_get_symcount (abfd); c > 0; c--, sym_ptr_ptr++)
1263    {
1264      asymbol *sym_ptr;
1265      EXTR esym;
1266
1267      sym_ptr = *sym_ptr_ptr;
1268
1269      /* Get the external symbol information.  */
1270      if (! (*get_extr) (sym_ptr, &esym))
1271	continue;
1272
1273      /* If we're producing an executable, move common symbols into
1274	 bss.  */
1275      if (! relocatable)
1276	{
1277	  if (esym.asym.sc == scCommon)
1278	    esym.asym.sc = scBss;
1279	  else if (esym.asym.sc == scSCommon)
1280	    esym.asym.sc = scSBss;
1281	}
1282
1283      if (bfd_is_com_section (sym_ptr->section)
1284	  || bfd_is_und_section (sym_ptr->section)
1285	  || sym_ptr->section->output_section == (asection *) NULL)
1286	{
1287	  /* FIXME: gas does not keep the value of a small undefined
1288	     symbol in the symbol itself, because of relocation
1289	     problems.  */
1290	  if (esym.asym.sc != scSUndefined
1291	      || esym.asym.value == 0
1292	      || sym_ptr->value != 0)
1293	    esym.asym.value = sym_ptr->value;
1294	}
1295      else
1296	esym.asym.value = (sym_ptr->value
1297			   + sym_ptr->section->output_offset
1298			   + sym_ptr->section->output_section->vma);
1299
1300      if (set_index)
1301	(*set_index) (sym_ptr, (bfd_size_type) symhdr->iextMax);
1302
1303      if (! bfd_ecoff_debug_one_external (abfd, debug, swap,
1304					  sym_ptr->name, &esym))
1305	return FALSE;
1306    }
1307
1308  return TRUE;
1309}
1310
1311/* Add a single external symbol to the debugging information.  */
1312
1313bfd_boolean
1314bfd_ecoff_debug_one_external (abfd, debug, swap, name, esym)
1315     bfd *abfd;
1316     struct ecoff_debug_info *debug;
1317     const struct ecoff_debug_swap *swap;
1318     const char *name;
1319     EXTR *esym;
1320{
1321  const bfd_size_type external_ext_size = swap->external_ext_size;
1322  void (* const swap_ext_out) PARAMS ((bfd *, const EXTR *, PTR))
1323    = swap->swap_ext_out;
1324  HDRR * const symhdr = &debug->symbolic_header;
1325  size_t namelen;
1326
1327  namelen = strlen (name);
1328
1329  if ((size_t) (debug->ssext_end - debug->ssext)
1330      < symhdr->issExtMax + namelen + 1)
1331    {
1332      if (! ecoff_add_bytes ((char **) &debug->ssext,
1333			     (char **) &debug->ssext_end,
1334			     symhdr->issExtMax + namelen + 1))
1335	return FALSE;
1336    }
1337  if ((size_t) ((char *) debug->external_ext_end
1338		- (char *) debug->external_ext)
1339      < (symhdr->iextMax + 1) * external_ext_size)
1340    {
1341      char *external_ext = (char *) debug->external_ext;
1342      char *external_ext_end = (char *) debug->external_ext_end;
1343      if (! ecoff_add_bytes ((char **) &external_ext,
1344			     (char **) &external_ext_end,
1345			     (symhdr->iextMax + 1) * (size_t) external_ext_size))
1346	return FALSE;
1347      debug->external_ext = external_ext;
1348      debug->external_ext_end = external_ext_end;
1349    }
1350
1351  esym->asym.iss = symhdr->issExtMax;
1352
1353  (*swap_ext_out) (abfd, esym,
1354		   ((char *) debug->external_ext
1355		    + symhdr->iextMax * swap->external_ext_size));
1356
1357  ++symhdr->iextMax;
1358
1359  strcpy (debug->ssext + symhdr->issExtMax, name);
1360  symhdr->issExtMax += namelen + 1;
1361
1362  return TRUE;
1363}
1364
1365/* Align the ECOFF debugging information.  */
1366
1367static void
1368ecoff_align_debug (abfd, debug, swap)
1369     bfd *abfd ATTRIBUTE_UNUSED;
1370     struct ecoff_debug_info *debug;
1371     const struct ecoff_debug_swap *swap;
1372{
1373  HDRR * const symhdr = &debug->symbolic_header;
1374  bfd_size_type debug_align, aux_align, rfd_align;
1375  size_t add;
1376
1377  /* Adjust the counts so that structures are aligned.  */
1378  debug_align = swap->debug_align;
1379  aux_align = debug_align / sizeof (union aux_ext);
1380  rfd_align = debug_align / swap->external_rfd_size;
1381
1382  add = debug_align - (symhdr->cbLine & (debug_align - 1));
1383  if (add != debug_align)
1384    {
1385      if (debug->line != (unsigned char *) NULL)
1386	memset ((PTR) (debug->line + symhdr->cbLine), 0, add);
1387      symhdr->cbLine += add;
1388    }
1389
1390  add = debug_align - (symhdr->issMax & (debug_align - 1));
1391  if (add != debug_align)
1392    {
1393      if (debug->ss != (char *) NULL)
1394	memset ((PTR) (debug->ss + symhdr->issMax), 0, add);
1395      symhdr->issMax += add;
1396    }
1397
1398  add = debug_align - (symhdr->issExtMax & (debug_align - 1));
1399  if (add != debug_align)
1400    {
1401      if (debug->ssext != (char *) NULL)
1402	memset ((PTR) (debug->ssext + symhdr->issExtMax), 0, add);
1403      symhdr->issExtMax += add;
1404    }
1405
1406  add = aux_align - (symhdr->iauxMax & (aux_align - 1));
1407  if (add != aux_align)
1408    {
1409      if (debug->external_aux != (union aux_ext *) NULL)
1410	memset ((PTR) (debug->external_aux + symhdr->iauxMax), 0,
1411		add * sizeof (union aux_ext));
1412      symhdr->iauxMax += add;
1413    }
1414
1415  add = rfd_align - (symhdr->crfd & (rfd_align - 1));
1416  if (add != rfd_align)
1417    {
1418      if (debug->external_rfd != (PTR) NULL)
1419	memset ((PTR) ((char *) debug->external_rfd
1420		       + symhdr->crfd * swap->external_rfd_size),
1421		0, (size_t) (add * swap->external_rfd_size));
1422      symhdr->crfd += add;
1423    }
1424}
1425
1426/* Return the size required by the ECOFF debugging information.  */
1427
1428bfd_size_type
1429bfd_ecoff_debug_size (abfd, debug, swap)
1430     bfd *abfd;
1431     struct ecoff_debug_info *debug;
1432     const struct ecoff_debug_swap *swap;
1433{
1434  bfd_size_type tot;
1435
1436  ecoff_align_debug (abfd, debug, swap);
1437  tot = swap->external_hdr_size;
1438
1439#define ADD(count, size) \
1440  tot += debug->symbolic_header.count * size
1441
1442  ADD (cbLine, sizeof (unsigned char));
1443  ADD (idnMax, swap->external_dnr_size);
1444  ADD (ipdMax, swap->external_pdr_size);
1445  ADD (isymMax, swap->external_sym_size);
1446  ADD (ioptMax, swap->external_opt_size);
1447  ADD (iauxMax, sizeof (union aux_ext));
1448  ADD (issMax, sizeof (char));
1449  ADD (issExtMax, sizeof (char));
1450  ADD (ifdMax, swap->external_fdr_size);
1451  ADD (crfd, swap->external_rfd_size);
1452  ADD (iextMax, swap->external_ext_size);
1453
1454#undef ADD
1455
1456  return tot;
1457}
1458
1459/* Write out the ECOFF symbolic header, given the file position it is
1460   going to be placed at.  This assumes that the counts are set
1461   correctly.  */
1462
1463static bfd_boolean
1464ecoff_write_symhdr (abfd, debug, swap, where)
1465     bfd *abfd;
1466     struct ecoff_debug_info *debug;
1467     const struct ecoff_debug_swap *swap;
1468     file_ptr where;
1469{
1470  HDRR * const symhdr = &debug->symbolic_header;
1471  char *buff = NULL;
1472
1473  ecoff_align_debug (abfd, debug, swap);
1474
1475  /* Go to the right location in the file.  */
1476  if (bfd_seek (abfd, where, SEEK_SET) != 0)
1477    return FALSE;
1478
1479  where += swap->external_hdr_size;
1480
1481  symhdr->magic = swap->sym_magic;
1482
1483  /* Fill in the file offsets.  */
1484#define SET(offset, count, size) \
1485  if (symhdr->count == 0) \
1486    symhdr->offset = 0; \
1487  else \
1488    { \
1489      symhdr->offset = where; \
1490      where += symhdr->count * size; \
1491    }
1492
1493  SET (cbLineOffset, cbLine, sizeof (unsigned char));
1494  SET (cbDnOffset, idnMax, swap->external_dnr_size);
1495  SET (cbPdOffset, ipdMax, swap->external_pdr_size);
1496  SET (cbSymOffset, isymMax, swap->external_sym_size);
1497  SET (cbOptOffset, ioptMax, swap->external_opt_size);
1498  SET (cbAuxOffset, iauxMax, sizeof (union aux_ext));
1499  SET (cbSsOffset, issMax, sizeof (char));
1500  SET (cbSsExtOffset, issExtMax, sizeof (char));
1501  SET (cbFdOffset, ifdMax, swap->external_fdr_size);
1502  SET (cbRfdOffset, crfd, swap->external_rfd_size);
1503  SET (cbExtOffset, iextMax, swap->external_ext_size);
1504#undef SET
1505
1506  buff = (char *) bfd_malloc (swap->external_hdr_size);
1507  if (buff == NULL && swap->external_hdr_size != 0)
1508    goto error_return;
1509
1510  (*swap->swap_hdr_out) (abfd, symhdr, buff);
1511  if (bfd_bwrite (buff, swap->external_hdr_size, abfd)
1512      != swap->external_hdr_size)
1513    goto error_return;
1514
1515  if (buff != NULL)
1516    free (buff);
1517  return TRUE;
1518 error_return:
1519  if (buff != NULL)
1520    free (buff);
1521  return FALSE;
1522}
1523
1524/* Write out the ECOFF debugging information.  This function assumes
1525   that the information (the pointers and counts) in *DEBUG have been
1526   set correctly.  WHERE is the position in the file to write the
1527   information to.  This function fills in the file offsets in the
1528   symbolic header.  */
1529
1530bfd_boolean
1531bfd_ecoff_write_debug (abfd, debug, swap, where)
1532     bfd *abfd;
1533     struct ecoff_debug_info *debug;
1534     const struct ecoff_debug_swap *swap;
1535     file_ptr where;
1536{
1537  HDRR * const symhdr = &debug->symbolic_header;
1538
1539  if (! ecoff_write_symhdr (abfd, debug, swap, where))
1540    return FALSE;
1541
1542#define WRITE(ptr, count, size, offset) \
1543  BFD_ASSERT (symhdr->offset == 0 \
1544	      || (bfd_vma) bfd_tell (abfd) == symhdr->offset); \
1545  if (bfd_bwrite ((PTR) debug->ptr, (bfd_size_type) size * symhdr->count, abfd)\
1546      != size * symhdr->count) \
1547    return FALSE;
1548
1549  WRITE (line, cbLine, sizeof (unsigned char), cbLineOffset);
1550  WRITE (external_dnr, idnMax, swap->external_dnr_size, cbDnOffset);
1551  WRITE (external_pdr, ipdMax, swap->external_pdr_size, cbPdOffset);
1552  WRITE (external_sym, isymMax, swap->external_sym_size, cbSymOffset);
1553  WRITE (external_opt, ioptMax, swap->external_opt_size, cbOptOffset);
1554  WRITE (external_aux, iauxMax, (bfd_size_type) sizeof (union aux_ext),
1555	 cbAuxOffset);
1556  WRITE (ss, issMax, sizeof (char), cbSsOffset);
1557  WRITE (ssext, issExtMax, sizeof (char), cbSsExtOffset);
1558  WRITE (external_fdr, ifdMax, swap->external_fdr_size, cbFdOffset);
1559  WRITE (external_rfd, crfd, swap->external_rfd_size, cbRfdOffset);
1560  WRITE (external_ext, iextMax, swap->external_ext_size, cbExtOffset);
1561#undef WRITE
1562
1563  return TRUE;
1564}
1565
1566/* Write out a shuffle list.  */
1567
1568static bfd_boolean ecoff_write_shuffle
1569  PARAMS ((bfd *, const struct ecoff_debug_swap *, struct shuffle *,
1570	   PTR space));
1571
1572static bfd_boolean
1573ecoff_write_shuffle (abfd, swap, shuffle, space)
1574     bfd *abfd;
1575     const struct ecoff_debug_swap *swap;
1576     struct shuffle *shuffle;
1577     PTR space;
1578{
1579  register struct shuffle *l;
1580  unsigned long total;
1581
1582  total = 0;
1583  for (l = shuffle; l != (struct shuffle *) NULL; l = l->next)
1584    {
1585      if (! l->filep)
1586	{
1587	  if (bfd_bwrite (l->u.memory, (bfd_size_type) l->size, abfd)
1588	      != l->size)
1589	    return FALSE;
1590	}
1591      else
1592	{
1593	  if (bfd_seek (l->u.file.input_bfd, l->u.file.offset, SEEK_SET) != 0
1594	      || bfd_bread (space, (bfd_size_type) l->size,
1595			   l->u.file.input_bfd) != l->size
1596	      || bfd_bwrite (space, (bfd_size_type) l->size, abfd) != l->size)
1597	    return FALSE;
1598	}
1599      total += l->size;
1600    }
1601
1602  if ((total & (swap->debug_align - 1)) != 0)
1603    {
1604      unsigned int i;
1605      bfd_byte *s;
1606
1607      i = swap->debug_align - (total & (swap->debug_align - 1));
1608      s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i);
1609      if (s == NULL && i != 0)
1610	return FALSE;
1611
1612      if (bfd_bwrite ((PTR) s, (bfd_size_type) i, abfd) != i)
1613	{
1614	  free (s);
1615	  return FALSE;
1616	}
1617      free (s);
1618    }
1619
1620  return TRUE;
1621}
1622
1623/* Write out debugging information using accumulated linker
1624   information.  */
1625
1626bfd_boolean
1627bfd_ecoff_write_accumulated_debug (handle, abfd, debug, swap, info, where)
1628     PTR handle;
1629     bfd *abfd;
1630     struct ecoff_debug_info *debug;
1631     const struct ecoff_debug_swap *swap;
1632     struct bfd_link_info *info;
1633     file_ptr where;
1634{
1635  struct accumulate *ainfo = (struct accumulate *) handle;
1636  PTR space = NULL;
1637  bfd_size_type amt;
1638
1639  if (! ecoff_write_symhdr (abfd, debug, swap, where))
1640    goto error_return;
1641
1642  amt = ainfo->largest_file_shuffle;
1643  space = (PTR) bfd_malloc (amt);
1644  if (space == NULL && ainfo->largest_file_shuffle != 0)
1645    goto error_return;
1646
1647  if (! ecoff_write_shuffle (abfd, swap, ainfo->line, space)
1648      || ! ecoff_write_shuffle (abfd, swap, ainfo->pdr, space)
1649      || ! ecoff_write_shuffle (abfd, swap, ainfo->sym, space)
1650      || ! ecoff_write_shuffle (abfd, swap, ainfo->opt, space)
1651      || ! ecoff_write_shuffle (abfd, swap, ainfo->aux, space))
1652    goto error_return;
1653
1654  /* The string table is written out from the hash table if this is a
1655     final link.  */
1656  if (info->relocatable)
1657    {
1658      BFD_ASSERT (ainfo->ss_hash == (struct string_hash_entry *) NULL);
1659      if (! ecoff_write_shuffle (abfd, swap, ainfo->ss, space))
1660	goto error_return;
1661    }
1662  else
1663    {
1664      unsigned long total;
1665      bfd_byte null;
1666      struct string_hash_entry *sh;
1667
1668      BFD_ASSERT (ainfo->ss == (struct shuffle *) NULL);
1669      null = 0;
1670      if (bfd_bwrite ((PTR) &null, (bfd_size_type) 1, abfd) != 1)
1671	goto error_return;
1672      total = 1;
1673      BFD_ASSERT (ainfo->ss_hash == NULL || ainfo->ss_hash->val == 1);
1674      for (sh = ainfo->ss_hash;
1675	   sh != (struct string_hash_entry *) NULL;
1676	   sh = sh->next)
1677	{
1678	  size_t len;
1679
1680	  len = strlen (sh->root.string);
1681	  amt = len + 1;
1682	  if (bfd_bwrite ((PTR) sh->root.string, amt, abfd) != amt)
1683	    goto error_return;
1684	  total += len + 1;
1685	}
1686
1687      if ((total & (swap->debug_align - 1)) != 0)
1688	{
1689	  unsigned int i;
1690	  bfd_byte *s;
1691
1692	  i = swap->debug_align - (total & (swap->debug_align - 1));
1693	  s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i);
1694	  if (s == NULL && i != 0)
1695	    goto error_return;
1696
1697	  if (bfd_bwrite ((PTR) s, (bfd_size_type) i, abfd) != i)
1698	    {
1699	      free (s);
1700	      goto error_return;
1701	    }
1702	  free (s);
1703	}
1704    }
1705
1706  /* The external strings and symbol are not converted over to using
1707     shuffles.  FIXME: They probably should be.  */
1708  amt = debug->symbolic_header.issExtMax;
1709  if (bfd_bwrite (debug->ssext, amt, abfd) != amt)
1710    goto error_return;
1711  if ((debug->symbolic_header.issExtMax & (swap->debug_align - 1)) != 0)
1712    {
1713      unsigned int i;
1714      bfd_byte *s;
1715
1716      i = (swap->debug_align
1717	   - (debug->symbolic_header.issExtMax & (swap->debug_align - 1)));
1718      s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i);
1719      if (s == NULL && i != 0)
1720	goto error_return;
1721
1722      if (bfd_bwrite ((PTR) s, (bfd_size_type) i, abfd) != i)
1723	{
1724	  free (s);
1725	  goto error_return;
1726	}
1727      free (s);
1728    }
1729
1730  if (! ecoff_write_shuffle (abfd, swap, ainfo->fdr, space)
1731      || ! ecoff_write_shuffle (abfd, swap, ainfo->rfd, space))
1732    goto error_return;
1733
1734  BFD_ASSERT (debug->symbolic_header.cbExtOffset == 0
1735	      || (debug->symbolic_header.cbExtOffset
1736		  == (bfd_vma) bfd_tell (abfd)));
1737
1738  amt = debug->symbolic_header.iextMax * swap->external_ext_size;
1739  if (bfd_bwrite (debug->external_ext, amt, abfd) != amt)
1740    goto error_return;
1741
1742  if (space != NULL)
1743    free (space);
1744  return TRUE;
1745
1746 error_return:
1747  if (space != NULL)
1748    free (space);
1749  return FALSE;
1750}
1751
1752/* Handle the find_nearest_line function for both ECOFF and MIPS ELF
1753   files.  */
1754
1755/* Compare FDR entries.  This is called via qsort.  */
1756
1757static int
1758cmp_fdrtab_entry (leftp, rightp)
1759     const PTR leftp;
1760     const PTR rightp;
1761{
1762  const struct ecoff_fdrtab_entry *lp =
1763    (const struct ecoff_fdrtab_entry *) leftp;
1764  const struct ecoff_fdrtab_entry *rp =
1765    (const struct ecoff_fdrtab_entry *) rightp;
1766
1767  if (lp->base_addr < rp->base_addr)
1768    return -1;
1769  if (lp->base_addr > rp->base_addr)
1770    return 1;
1771  return 0;
1772}
1773
1774/* Each file descriptor (FDR) has a memory address, to simplify
1775   looking up an FDR by address, we build a table covering all FDRs
1776   that have a least one procedure descriptor in them.  The final
1777   table will be sorted by address so we can look it up via binary
1778   search.  */
1779
1780static bfd_boolean
1781mk_fdrtab (abfd, debug_info, debug_swap, line_info)
1782     bfd *abfd;
1783     struct ecoff_debug_info * const debug_info;
1784     const struct ecoff_debug_swap * const debug_swap;
1785     struct ecoff_find_line *line_info;
1786{
1787  struct ecoff_fdrtab_entry *tab;
1788  FDR *fdr_ptr;
1789  FDR *fdr_start;
1790  FDR *fdr_end;
1791  bfd_boolean stabs;
1792  long len;
1793  bfd_size_type amt;
1794
1795  fdr_start = debug_info->fdr;
1796  fdr_end = fdr_start + debug_info->symbolic_header.ifdMax;
1797
1798  /* First, let's see how long the table needs to be.  */
1799  for (len = 0, fdr_ptr = fdr_start; fdr_ptr < fdr_end; fdr_ptr++)
1800    {
1801      if (fdr_ptr->cpd == 0)	/* Skip FDRs that have no PDRs.  */
1802	continue;
1803      ++len;
1804    }
1805
1806  /* Now, create and fill in the table.  */
1807  amt = (bfd_size_type) len * sizeof (struct ecoff_fdrtab_entry);
1808  line_info->fdrtab = (struct ecoff_fdrtab_entry*) bfd_zalloc (abfd, amt);
1809  if (line_info->fdrtab == NULL)
1810    return FALSE;
1811  line_info->fdrtab_len = len;
1812
1813  tab = line_info->fdrtab;
1814  for (fdr_ptr = fdr_start; fdr_ptr < fdr_end; fdr_ptr++)
1815    {
1816      if (fdr_ptr->cpd == 0)
1817	continue;
1818
1819      /* Check whether this file has stabs debugging information.  In
1820	 a file with stabs debugging information, the second local
1821	 symbol is named @stabs.  */
1822      stabs = FALSE;
1823      if (fdr_ptr->csym >= 2)
1824	{
1825	  char *sym_ptr;
1826	  SYMR sym;
1827
1828	  sym_ptr = ((char *) debug_info->external_sym
1829		     + (fdr_ptr->isymBase + 1) * debug_swap->external_sym_size);
1830	  (*debug_swap->swap_sym_in) (abfd, sym_ptr, &sym);
1831	  if (strcmp (debug_info->ss + fdr_ptr->issBase + sym.iss,
1832		      STABS_SYMBOL) == 0)
1833	    stabs = TRUE;
1834	}
1835
1836      if (!stabs)
1837	{
1838	  /* eraxxon: There are at least two problems with this computation:
1839	     1) PDRs do *not* contain offsets but full vma's; and typically the
1840	     address of the first PDR is the address of the FDR, which will
1841	     make (most) of the results of the original computation 0!
1842	     2) Once in a wacky while, the Compaq compiler generated PDR
1843	     addresses do not equal the FDR vma, but they (the PDR address)
1844	     are still vma's and not offsets.  Cf. comments in
1845	     'lookup_line'.  */
1846	  /* The address of the first PDR is the offset of that
1847	     procedure relative to the beginning of file FDR.  */
1848	  tab->base_addr = fdr_ptr->adr;
1849	}
1850      else
1851	{
1852	  /* XXX I don't know about stabs, so this is a guess
1853	     (davidm@cs.arizona.edu).  */
1854	  tab->base_addr = fdr_ptr->adr;
1855	}
1856      tab->fdr = fdr_ptr;
1857      ++tab;
1858    }
1859
1860  /* Finally, the table is sorted in increasing memory-address order.
1861     The table is mostly sorted already, but there are cases (e.g.,
1862     static functions in include files), where this does not hold.
1863     Use "odump -PFv" to verify...  */
1864  qsort ((PTR) line_info->fdrtab, (size_t) len,
1865	 sizeof (struct ecoff_fdrtab_entry), cmp_fdrtab_entry);
1866
1867  return TRUE;
1868}
1869
1870/* Return index of first FDR that covers to OFFSET.  */
1871
1872static long
1873fdrtab_lookup (line_info, offset)
1874     struct ecoff_find_line *line_info;
1875     bfd_vma offset;
1876{
1877  long low, high, len;
1878  long mid = -1;
1879  struct ecoff_fdrtab_entry *tab;
1880
1881  len = line_info->fdrtab_len;
1882  if (len == 0)
1883    return -1;
1884
1885  tab = line_info->fdrtab;
1886  for (low = 0, high = len - 1 ; low != high ;)
1887    {
1888      mid = (high + low) / 2;
1889      if (offset >= tab[mid].base_addr && offset < tab[mid + 1].base_addr)
1890	goto find_min;
1891
1892      if (tab[mid].base_addr > offset)
1893	high = mid;
1894      else
1895	low = mid + 1;
1896    }
1897
1898  /* eraxxon: at this point 'offset' is either lower than the lowest entry or
1899     higher than the highest entry. In the former case high = low = mid = 0;
1900     we want to return -1.  In the latter case, low = high and mid = low - 1;
1901     we want to return the index of the highest entry.  Only in former case
1902     will the following 'catch-all' test be true.  */
1903  ++mid;
1904
1905  /* Last entry is catch-all for all higher addresses.  */
1906  if (offset < tab[mid].base_addr)
1907    return -1;
1908
1909 find_min:
1910
1911  /* eraxxon: There may be multiple FDRs in the table with the
1912     same base_addr; make sure that we are at the first one.  */
1913  while (mid > 0 && tab[mid - 1].base_addr == tab[mid].base_addr)
1914    --mid;
1915
1916  return mid;
1917}
1918
1919/* Look up a line given an address, storing the information in
1920   LINE_INFO->cache.  */
1921
1922static bfd_boolean
1923lookup_line (abfd, debug_info, debug_swap, line_info)
1924     bfd *abfd;
1925     struct ecoff_debug_info * const debug_info;
1926     const struct ecoff_debug_swap * const debug_swap;
1927     struct ecoff_find_line *line_info;
1928{
1929  struct ecoff_fdrtab_entry *tab;
1930  bfd_vma offset;
1931  bfd_boolean stabs;
1932  FDR *fdr_ptr;
1933  int i;
1934
1935  /* eraxxon: note that 'offset' is the full vma, not a section offset.  */
1936  offset = line_info->cache.start;
1937
1938  /* Build FDR table (sorted by object file's base-address) if we
1939     don't have it already.  */
1940  if (line_info->fdrtab == NULL
1941      && !mk_fdrtab (abfd, debug_info, debug_swap, line_info))
1942    return FALSE;
1943
1944  tab = line_info->fdrtab;
1945
1946  /* Find first FDR for address OFFSET.  */
1947  i = fdrtab_lookup (line_info, offset);
1948  if (i < 0)
1949    return FALSE;		/* no FDR, no fun...  */
1950
1951  /* eraxxon: 'fdrtab_lookup' doesn't give what we want, at least for Compaq's
1952     C++ compiler 6.2.  Consider three FDRs with starting addresses of x, y,
1953     and z, respectively, such that x < y < z.  Assume further that
1954     y < 'offset' < z.  It is possible at times that the PDR for 'offset' is
1955     associated with FDR x and *not* with FDR y.  Erg!!
1956
1957     From a binary dump of my C++ test case 'moo' using Compaq's coffobjanl
1958     (output format has been edited for our purposes):
1959
1960     FDR [2]: (main.C): First instruction: 0x12000207c <x>
1961       PDR [5] for File [2]: LoopTest__Xv                 <0x1200020a0> (a)
1962       PDR [7] for File [2]: foo__Xv                      <0x120002168>
1963     FDR [1]: (-1):     First instruction: 0x1200020e8 <y>
1964       PDR [3] for File [1]:                              <0x120001ad0> (b)
1965     FDR [6]: (-1):     First instruction: 0x1200026f0 <z>
1966
1967     (a) In the case of PDR5, the vma is such that the first few instructions
1968     of the procedure can be found.  But since the size of this procedure is
1969     160b, the vma will soon cross into the 'address space' of FDR1 and no
1970     debugging info will be found.  How repugnant!
1971
1972     (b) It is also possible for a PDR to have a *lower* vma than its associated
1973     FDR; see FDR1 and PDR3.  Gross!
1974
1975     Since the FDRs that are causing so much havok (in this case) 1) do not
1976     describe actual files (fdr.rss == -1), and 2) contain only compiler
1977     generated routines, I thought a simple fix would be to exclude them from
1978     the FDR table in 'mk_fdrtab'.  But, besides not knowing for certain
1979     whether this would be correct, it creates an additional problem.  If we
1980     happen to ask for source file info on a compiler generated (procedure)
1981     symbol -- which is still in the symbol table -- the result can be
1982     information from a real procedure!  This is because compiler generated
1983     procedures with vma's higher than the last FDR in the fdr table will be
1984     associated with a PDR from this FDR, specifically the PDR with the
1985     highest vma.  This wasn't a problem before, because each procedure had a
1986     PDR.  (Yes, this problem could be eliminated if we kept the size of the
1987     last PDR around, but things are already getting ugly).
1988
1989     Probably, a better solution would be to have a sorted PDR table.  Each
1990     PDR would have a pointer to its FDR so file information could still be
1991     obtained.  A FDR table could still be constructed if necessary -- since
1992     it only contains pointers, not much extra memory would be used -- but
1993     the PDR table would be searched to locate debugging info.
1994
1995     There is still at least one remaining issue.  Sometimes a FDR can have a
1996     bogus name, but contain PDRs that should belong to another FDR with a
1997     real name.  E.g:
1998
1999     FDR [3]: 0000000120001b50 (/home/.../Array.H~alt~deccxx_5E5A62AD)
2000       PDR [a] for File [3]: 0000000120001b50
2001       PDR [b] for File [3]: 0000000120001cf0
2002       PDR [c] for File [3]: 0000000120001dc8
2003       PDR [d] for File [3]: 0000000120001e40
2004       PDR [e] for File [3]: 0000000120001eb8
2005       PDR [f] for File [3]: 0000000120001f4c
2006     FDR [4]: 0000000120001b50 (/home/.../Array.H)
2007
2008     Here, FDR4 has the correct name, but should (seemingly) contain PDRa-f.
2009     The symbol table for PDR4 does contain symbols for PDRa-f, but so does
2010     the symbol table for FDR3.  However the former is different; perhaps this
2011     can be detected easily. (I'm not sure at this point.)  This problem only
2012     seems to be associated with files with templates.  I am assuming the idea
2013     is that there is a 'fake' FDR (with PDRs) for each differently typed set
2014     of templates that must be generated.  Currently, FDR4 is completely
2015     excluded from the FDR table in 'mk_fdrtab' because it contains no PDRs.
2016
2017     Since I don't have time to prepare a real fix for this right now, be
2018     prepared for 'A Horrible Hack' to force the inspection of all non-stabs
2019     FDRs.  It's coming...  */
2020  fdr_ptr = tab[i].fdr;
2021
2022  /* Check whether this file has stabs debugging information.  In a
2023     file with stabs debugging information, the second local symbol is
2024     named @stabs.  */
2025  stabs = FALSE;
2026  if (fdr_ptr->csym >= 2)
2027    {
2028      char *sym_ptr;
2029      SYMR sym;
2030
2031      sym_ptr = ((char *) debug_info->external_sym
2032		 + (fdr_ptr->isymBase + 1) * debug_swap->external_sym_size);
2033      (*debug_swap->swap_sym_in) (abfd, sym_ptr, &sym);
2034      if (strcmp (debug_info->ss + fdr_ptr->issBase + sym.iss,
2035		  STABS_SYMBOL) == 0)
2036	stabs = TRUE;
2037    }
2038
2039  if (!stabs)
2040    {
2041      bfd_size_type external_pdr_size;
2042      char *pdr_ptr;
2043      char *best_pdr = NULL;
2044      FDR *best_fdr;
2045      bfd_signed_vma best_dist = -1;
2046      PDR pdr;
2047      unsigned char *line_ptr;
2048      unsigned char *line_end;
2049      int lineno;
2050      /* This file uses ECOFF debugging information.  Each FDR has a
2051         list of procedure descriptors (PDR).  The address in the FDR
2052         is the absolute address of the first procedure.  The address
2053         in the first PDR gives the offset of that procedure relative
2054         to the object file's base-address.  The addresses in
2055         subsequent PDRs specify each procedure's address relative to
2056         the object file's base-address.  To make things more juicy,
2057         whenever the PROF bit in the PDR is set, the real entry point
2058         of the procedure may be 16 bytes below what would normally be
2059         the procedure's entry point.  Instead, DEC came up with a
2060         wicked scheme to create profiled libraries "on the fly":
2061         instead of shipping a regular and a profiled version of each
2062         library, they insert 16 bytes of unused space in front of
2063         each procedure and set the "prof" bit in the PDR to indicate
2064         that there is a gap there (this is done automagically by "as"
2065         when option "-pg" is specified).  Thus, normally, you link
2066         against such a library and, except for lots of 16 byte gaps
2067         between functions, things will behave as usual.  However,
2068         when invoking "ld" with option "-pg", it will fill those gaps
2069         with code that calls mcount().  It then moves the function's
2070         entry point down by 16 bytes, and out pops a binary that has
2071         all functions profiled.
2072
2073         NOTE: Neither FDRs nor PDRs are strictly sorted in memory
2074               order.  For example, when including header-files that
2075               define functions, the FDRs follow behind the including
2076               file, even though their code may have been generated at
2077               a lower address.  File coff-alpha.c from libbfd
2078               illustrates this (use "odump -PFv" to look at a file's
2079               FDR/PDR).  Similarly, PDRs are sometimes out of order
2080               as well.  An example of this is OSF/1 v3.0 libc's
2081               malloc.c.  I'm not sure why this happens, but it could
2082               be due to optimizations that reorder a function's
2083               position within an object-file.
2084
2085         Strategy:
2086
2087         On the first call to this function, we build a table of FDRs
2088         that is sorted by the base-address of the object-file the FDR
2089         is referring to.  Notice that each object-file may contain
2090         code from multiple source files (e.g., due to code defined in
2091         include files).  Thus, for any given base-address, there may
2092         be multiple FDRs (but this case is, fortunately, uncommon).
2093         lookup(addr) guarantees to return the first FDR that applies
2094         to address ADDR.  Thus, after invoking lookup(), we have a
2095         list of FDRs that may contain the PDR for ADDR.  Next, we
2096         walk through the PDRs of these FDRs and locate the one that
2097         is closest to ADDR (i.e., for which the difference between
2098         ADDR and the PDR's entry point is positive and minimal).
2099         Once, the right FDR and PDR are located, we simply walk
2100         through the line-number table to lookup the line-number that
2101         best matches ADDR.  Obviously, things could be sped up by
2102         keeping a sorted list of PDRs instead of a sorted list of
2103         FDRs.  However, this would increase space requirements
2104         considerably, which is undesirable.  */
2105      external_pdr_size = debug_swap->external_pdr_size;
2106
2107      /* eraxxon: The Horrible Hack: Because of the problems above, set 'i'
2108	 to 0 so we look through all FDRs.
2109
2110	 Because FDR's without any symbols are assumed to be non-stabs,
2111	 searching through all FDRs may cause the following code to try to
2112	 read stabs FDRs as ECOFF ones.  However, I don't think this will
2113	 harm anything.  */
2114      i = 0;
2115
2116      /* Search FDR list starting at tab[i] for the PDR that best matches
2117         OFFSET.  Normally, the FDR list is only one entry long.  */
2118      best_fdr = NULL;
2119      do
2120	{
2121	  /* eraxxon: 'dist' and 'min_dist' can be negative now
2122             because we iterate over every FDR rather than just ones
2123             with a base address less than or equal to 'offset'.  */
2124	  bfd_signed_vma dist = -1, min_dist = -1;
2125	  char *pdr_hold;
2126	  char *pdr_end;
2127
2128	  fdr_ptr = tab[i].fdr;
2129
2130	  pdr_ptr = ((char *) debug_info->external_pdr
2131		     + fdr_ptr->ipdFirst * external_pdr_size);
2132	  pdr_end = pdr_ptr + fdr_ptr->cpd * external_pdr_size;
2133	  (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr);
2134	  /* Find PDR that is closest to OFFSET.  If pdr.prof is set,
2135	     the procedure entry-point *may* be 0x10 below pdr.adr.  We
2136	     simply pretend that pdr.prof *implies* a lower entry-point.
2137	     This is safe because it just means that may identify 4 NOPs
2138	     in front of the function as belonging to the function.  */
2139	  for (pdr_hold = NULL;
2140	       pdr_ptr < pdr_end;
2141	       (pdr_ptr += external_pdr_size,
2142		(*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr)))
2143	    {
2144	      if (offset >= (pdr.adr - 0x10 * pdr.prof))
2145		{
2146		  dist = offset - (pdr.adr - 0x10 * pdr.prof);
2147
2148		  /* eraxxon: 'dist' can be negative now.  Note that
2149                     'min_dist' can be negative if 'pdr_hold' below is NULL.  */
2150		  if (!pdr_hold || (dist >= 0 && dist < min_dist))
2151		    {
2152		      min_dist = dist;
2153		      pdr_hold = pdr_ptr;
2154		    }
2155		}
2156	    }
2157
2158	  if (!best_pdr || (min_dist >= 0 && min_dist < best_dist))
2159	    {
2160	      best_dist = (bfd_vma) min_dist;
2161	      best_fdr = fdr_ptr;
2162	      best_pdr = pdr_hold;
2163	    }
2164	  /* Continue looping until base_addr of next entry is different.  */
2165	}
2166      /* eraxxon: We want to iterate over all FDRs.
2167	 See previous comment about 'fdrtab_lookup'.  */
2168      while (++i < line_info->fdrtab_len);
2169
2170      if (!best_fdr || !best_pdr)
2171	return FALSE;			/* Shouldn't happen...  */
2172
2173      /* Phew, finally we got something that we can hold onto.  */
2174      fdr_ptr = best_fdr;
2175      pdr_ptr = best_pdr;
2176      (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr);
2177      /* Now we can look for the actual line number.  The line numbers
2178         are stored in a very funky format, which I won't try to
2179         describe.  The search is bounded by the end of the FDRs line
2180         number entries.  */
2181      line_end = debug_info->line + fdr_ptr->cbLineOffset + fdr_ptr->cbLine;
2182
2183      /* Make offset relative to procedure entry.  */
2184      offset -= pdr.adr - 0x10 * pdr.prof;
2185      lineno = pdr.lnLow;
2186      line_ptr = debug_info->line + fdr_ptr->cbLineOffset + pdr.cbLineOffset;
2187      while (line_ptr < line_end)
2188	{
2189	  int delta;
2190	  unsigned int count;
2191
2192	  delta = *line_ptr >> 4;
2193	  if (delta >= 0x8)
2194	    delta -= 0x10;
2195	  count = (*line_ptr & 0xf) + 1;
2196	  ++line_ptr;
2197	  if (delta == -8)
2198	    {
2199	      delta = (((line_ptr[0]) & 0xff) << 8) + ((line_ptr[1]) & 0xff);
2200	      if (delta >= 0x8000)
2201		delta -= 0x10000;
2202	      line_ptr += 2;
2203	    }
2204	  lineno += delta;
2205	  if (offset < count * 4)
2206	    {
2207	      line_info->cache.stop += count * 4 - offset;
2208	      break;
2209	    }
2210	  offset -= count * 4;
2211	}
2212
2213      /* If fdr_ptr->rss is -1, then this file does not have full
2214         symbols, at least according to gdb/mipsread.c.  */
2215      if (fdr_ptr->rss == -1)
2216	{
2217	  line_info->cache.filename = NULL;
2218	  if (pdr.isym == -1)
2219	    line_info->cache.functionname = NULL;
2220	  else
2221	    {
2222	      EXTR proc_ext;
2223
2224	      (*debug_swap->swap_ext_in)
2225		(abfd,
2226		 ((char *) debug_info->external_ext
2227		  + pdr.isym * debug_swap->external_ext_size),
2228		 &proc_ext);
2229	      line_info->cache.functionname = (debug_info->ssext
2230					       + proc_ext.asym.iss);
2231	    }
2232	}
2233      else
2234	{
2235	  SYMR proc_sym;
2236
2237	  line_info->cache.filename = (debug_info->ss
2238				       + fdr_ptr->issBase
2239				       + fdr_ptr->rss);
2240	  (*debug_swap->swap_sym_in)
2241	    (abfd,
2242	     ((char *) debug_info->external_sym
2243	      + ((fdr_ptr->isymBase + pdr.isym)
2244		 * debug_swap->external_sym_size)),
2245	     &proc_sym);
2246	  line_info->cache.functionname = (debug_info->ss
2247					   + fdr_ptr->issBase
2248					   + proc_sym.iss);
2249	}
2250      if (lineno == ilineNil)
2251	lineno = 0;
2252      line_info->cache.line_num = lineno;
2253    }
2254  else
2255    {
2256      bfd_size_type external_sym_size;
2257      const char *directory_name;
2258      const char *main_file_name;
2259      const char *current_file_name;
2260      const char *function_name;
2261      const char *line_file_name;
2262      bfd_vma low_func_vma;
2263      bfd_vma low_line_vma;
2264      bfd_boolean past_line;
2265      bfd_boolean past_fn;
2266      char *sym_ptr, *sym_ptr_end;
2267      size_t len, funclen;
2268      char *buffer = NULL;
2269
2270      /* This file uses stabs debugging information.  When gcc is not
2271	 optimizing, it will put the line number information before
2272	 the function name stabs entry.  When gcc is optimizing, it
2273	 will put the stabs entry for all the function first, followed
2274	 by the line number information.  (This appears to happen
2275	 because of the two output files used by the -mgpopt switch,
2276	 which is implied by -O).  This means that we must keep
2277	 looking through the symbols until we find both a line number
2278	 and a function name which are beyond the address we want.  */
2279
2280      line_info->cache.filename = NULL;
2281      line_info->cache.functionname = NULL;
2282      line_info->cache.line_num = 0;
2283
2284      directory_name = NULL;
2285      main_file_name = NULL;
2286      current_file_name = NULL;
2287      function_name = NULL;
2288      line_file_name = NULL;
2289      low_func_vma = 0;
2290      low_line_vma = 0;
2291      past_line = FALSE;
2292      past_fn = FALSE;
2293
2294      external_sym_size = debug_swap->external_sym_size;
2295
2296      sym_ptr = ((char *) debug_info->external_sym
2297		 + (fdr_ptr->isymBase + 2) * external_sym_size);
2298      sym_ptr_end = sym_ptr + (fdr_ptr->csym - 2) * external_sym_size;
2299      for (;
2300	   sym_ptr < sym_ptr_end && (! past_line || ! past_fn);
2301	   sym_ptr += external_sym_size)
2302	{
2303	  SYMR sym;
2304
2305	  (*debug_swap->swap_sym_in) (abfd, sym_ptr, &sym);
2306
2307	  if (ECOFF_IS_STAB (&sym))
2308	    {
2309	      switch (ECOFF_UNMARK_STAB (sym.index))
2310		{
2311		case N_SO:
2312		  main_file_name = current_file_name =
2313		    debug_info->ss + fdr_ptr->issBase + sym.iss;
2314
2315		  /* Check the next symbol to see if it is also an
2316                     N_SO symbol.  */
2317		  if (sym_ptr + external_sym_size < sym_ptr_end)
2318		    {
2319		      SYMR nextsym;
2320
2321		      (*debug_swap->swap_sym_in) (abfd,
2322						  sym_ptr + external_sym_size,
2323						  &nextsym);
2324		      if (ECOFF_IS_STAB (&nextsym)
2325			  && ECOFF_UNMARK_STAB (nextsym.index) == N_SO)
2326			{
2327 			  directory_name = current_file_name;
2328			  main_file_name = current_file_name =
2329			    debug_info->ss + fdr_ptr->issBase + nextsym.iss;
2330			  sym_ptr += external_sym_size;
2331			}
2332		    }
2333		  break;
2334
2335		case N_SOL:
2336		  current_file_name =
2337		    debug_info->ss + fdr_ptr->issBase + sym.iss;
2338		  break;
2339
2340		case N_FUN:
2341		  if (sym.value > offset)
2342		    past_fn = TRUE;
2343		  else if (sym.value >= low_func_vma)
2344		    {
2345		      low_func_vma = sym.value;
2346		      function_name =
2347			debug_info->ss + fdr_ptr->issBase + sym.iss;
2348		    }
2349		  break;
2350		}
2351	    }
2352	  else if (sym.st == stLabel && sym.index != indexNil)
2353	    {
2354	      if (sym.value > offset)
2355		past_line = TRUE;
2356	      else if (sym.value >= low_line_vma)
2357		{
2358		  low_line_vma = sym.value;
2359		  line_file_name = current_file_name;
2360		  line_info->cache.line_num = sym.index;
2361		}
2362	    }
2363	}
2364
2365      if (line_info->cache.line_num != 0)
2366	main_file_name = line_file_name;
2367
2368      /* We need to remove the stuff after the colon in the function
2369         name.  We also need to put the directory name and the file
2370         name together.  */
2371      if (function_name == NULL)
2372	len = funclen = 0;
2373      else
2374	len = funclen = strlen (function_name) + 1;
2375
2376      if (main_file_name != NULL
2377	  && directory_name != NULL
2378	  && main_file_name[0] != '/')
2379	len += strlen (directory_name) + strlen (main_file_name) + 1;
2380
2381      if (len != 0)
2382	{
2383	  if (line_info->find_buffer != NULL)
2384	    free (line_info->find_buffer);
2385	  buffer = (char *) bfd_malloc ((bfd_size_type) len);
2386	  if (buffer == NULL)
2387	    return FALSE;
2388	  line_info->find_buffer = buffer;
2389	}
2390
2391      if (function_name != NULL)
2392	{
2393	  char *colon;
2394
2395	  strcpy (buffer, function_name);
2396	  colon = strchr (buffer, ':');
2397	  if (colon != NULL)
2398	    *colon = '\0';
2399	  line_info->cache.functionname = buffer;
2400	}
2401
2402      if (main_file_name != NULL)
2403	{
2404	  if (directory_name == NULL || main_file_name[0] == '/')
2405	    line_info->cache.filename = main_file_name;
2406	  else
2407	    {
2408	      sprintf (buffer + funclen, "%s%s", directory_name,
2409		       main_file_name);
2410	      line_info->cache.filename = buffer + funclen;
2411	    }
2412	}
2413    }
2414
2415  return TRUE;
2416}
2417
2418/* Do the work of find_nearest_line.  */
2419
2420bfd_boolean
2421_bfd_ecoff_locate_line (abfd, section, offset, debug_info, debug_swap,
2422			line_info, filename_ptr, functionname_ptr, retline_ptr)
2423     bfd *abfd;
2424     asection *section;
2425     bfd_vma offset;
2426     struct ecoff_debug_info * const debug_info;
2427     const struct ecoff_debug_swap * const debug_swap;
2428     struct ecoff_find_line *line_info;
2429     const char **filename_ptr;
2430     const char **functionname_ptr;
2431     unsigned int *retline_ptr;
2432{
2433  offset += section->vma;
2434
2435  if (line_info->cache.sect == NULL
2436      || line_info->cache.sect != section
2437      || offset < line_info->cache.start
2438      || offset >= line_info->cache.stop)
2439    {
2440      line_info->cache.sect = section;
2441      line_info->cache.start = offset;
2442      line_info->cache.stop = offset;
2443      if (! lookup_line (abfd, debug_info, debug_swap, line_info))
2444	{
2445	  line_info->cache.sect = NULL;
2446	  return FALSE;
2447	}
2448    }
2449
2450  *filename_ptr = line_info->cache.filename;
2451  *functionname_ptr = line_info->cache.functionname;
2452  *retline_ptr = line_info->cache.line_num;
2453
2454  return TRUE;
2455}
2456
2457/* These routines copy symbolic information into a memory buffer.
2458
2459   FIXME: The whole point of the shuffle code is to avoid storing
2460   everything in memory, since the linker is such a memory hog.  This
2461   code makes that effort useless.  It is only called by the MIPS ELF
2462   code when generating a shared library, so it is not that big a
2463   deal, but it should be fixed eventually.  */
2464
2465/* Collect a shuffle into a memory buffer.  */
2466
2467static bfd_boolean ecoff_collect_shuffle
2468  PARAMS ((struct shuffle *, bfd_byte *));
2469
2470static bfd_boolean
2471ecoff_collect_shuffle (l, buff)
2472     struct shuffle *l;
2473     bfd_byte *buff;
2474{
2475  unsigned long total;
2476
2477  total = 0;
2478  for (; l != (struct shuffle *) NULL; l = l->next)
2479    {
2480      if (! l->filep)
2481	memcpy (buff, l->u.memory, l->size);
2482      else
2483	{
2484	  if (bfd_seek (l->u.file.input_bfd, l->u.file.offset, SEEK_SET) != 0
2485	      || (bfd_bread (buff, (bfd_size_type) l->size, l->u.file.input_bfd)
2486		  != l->size))
2487	    return FALSE;
2488	}
2489      total += l->size;
2490      buff += l->size;
2491    }
2492
2493  return TRUE;
2494}
2495
2496/* Copy PDR information into a memory buffer.  */
2497
2498bfd_boolean
2499_bfd_ecoff_get_accumulated_pdr (handle, buff)
2500     PTR handle;
2501     bfd_byte *buff;
2502{
2503  struct accumulate *ainfo = (struct accumulate *) handle;
2504
2505  return ecoff_collect_shuffle (ainfo->pdr, buff);
2506}
2507
2508/* Copy symbol information into a memory buffer.  */
2509
2510bfd_boolean
2511_bfd_ecoff_get_accumulated_sym (handle, buff)
2512     PTR handle;
2513     bfd_byte *buff;
2514{
2515  struct accumulate *ainfo = (struct accumulate *) handle;
2516
2517  return ecoff_collect_shuffle (ainfo->sym, buff);
2518}
2519
2520/* Copy the string table into a memory buffer.  */
2521
2522bfd_boolean
2523_bfd_ecoff_get_accumulated_ss (handle, buff)
2524     PTR handle;
2525     bfd_byte *buff;
2526{
2527  struct accumulate *ainfo = (struct accumulate *) handle;
2528  struct string_hash_entry *sh;
2529  unsigned long total;
2530
2531  /* The string table is written out from the hash table if this is a
2532     final link.  */
2533  BFD_ASSERT (ainfo->ss == (struct shuffle *) NULL);
2534  *buff++ = '\0';
2535  total = 1;
2536  BFD_ASSERT (ainfo->ss_hash == NULL || ainfo->ss_hash->val == 1);
2537  for (sh = ainfo->ss_hash;
2538       sh != (struct string_hash_entry *) NULL;
2539       sh = sh->next)
2540    {
2541      size_t len;
2542
2543      len = strlen (sh->root.string);
2544      memcpy (buff, (PTR) sh->root.string, len + 1);
2545      total += len + 1;
2546      buff += len + 1;
2547    }
2548
2549  return TRUE;
2550}
2551