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