Automatic date update in version.in
[external/binutils.git] / bfd / ecoff.c
1 /* Generic ECOFF (Extended-COFF) routines.
2    Copyright (C) 1990-2018 Free Software Foundation, Inc.
3    Original version by Per Bothner.
4    Full support added by Ian Lance Taylor, ian@cygnus.com.
5
6    This file is part of BFD, the Binary File Descriptor library.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21    MA 02110-1301, USA.  */
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "libbfd.h"
27 #include "aout/ar.h"
28 #include "aout/stab_gnu.h"
29
30 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
31    some other stuff which we don't want and which conflicts with stuff
32    we do want.  */
33 #include "libaout.h"
34 #include "aout/aout64.h"
35 #undef N_ABS
36 #undef exec_hdr
37 #undef obj_sym_filepos
38
39 #include "coff/internal.h"
40 #include "coff/sym.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
43 #include "libcoff.h"
44 #include "libecoff.h"
45 #include "libiberty.h"
46
47 #define streq(a, b)     (strcmp ((a), (b)) == 0)
48 #define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0)
49
50 \f
51 /* This stuff is somewhat copied from coffcode.h.  */
52 static asection bfd_debug_section =
53 {
54   /* name,      id,  index, next, prev, flags, user_set_vma,       */
55      "*DEBUG*", 0,   0,     NULL, NULL, 0,     0,
56   /* linker_mark, linker_has_input, gc_mark, compress_status,      */
57      0,           0,                1,       0,
58   /* segment_mark, sec_info_type, use_rela_p,                      */
59      0,            0,             0,
60   /* sec_flg0, sec_flg1, sec_flg2, sec_flg3, sec_flg4, sec_flg5,   */
61      0,        0,        0,        0,        0,        0,
62   /* vma, lma, size, rawsize, compressed_size, relax, relax_count, */
63      0,   0,   0,    0,       0,               0,     0,
64   /* output_offset, output_section, alignment_power,               */
65      0,             NULL,           0,
66   /* relocation, orelocation, reloc_count, filepos, rel_filepos,   */
67      NULL,       NULL,        0,           0,       0,
68   /* line_filepos, userdata, contents, lineno, lineno_count,       */
69      0,            NULL,     NULL,     NULL,   0,
70   /* entsize, kept_section, moving_line_filepos,                   */
71      0,       NULL,         0,
72   /* target_index, used_by_bfd, constructor_chain, owner,          */
73      0,            NULL,        NULL,              NULL,
74   /* symbol,                                                       */
75      NULL,
76   /* symbol_ptr_ptr,                                               */
77      NULL,
78   /* map_head, map_tail                                            */
79      { NULL }, { NULL }
80 };
81
82 /* Create an ECOFF object.  */
83
84 bfd_boolean
85 _bfd_ecoff_mkobject (bfd *abfd)
86 {
87   bfd_size_type amt = sizeof (ecoff_data_type);
88
89   abfd->tdata.ecoff_obj_data = (struct ecoff_tdata *) bfd_zalloc (abfd, amt);
90   if (abfd->tdata.ecoff_obj_data == NULL)
91     return FALSE;
92
93   return TRUE;
94 }
95
96 /* This is a hook called by coff_real_object_p to create any backend
97    specific information.  */
98
99 void *
100 _bfd_ecoff_mkobject_hook (bfd *abfd, void * filehdr, void * aouthdr)
101 {
102   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
103   struct internal_aouthdr *internal_a = (struct internal_aouthdr *) aouthdr;
104   ecoff_data_type *ecoff;
105
106   if (! _bfd_ecoff_mkobject (abfd))
107     return NULL;
108
109   ecoff = ecoff_data (abfd);
110   ecoff->gp_size = 8;
111   ecoff->sym_filepos = internal_f->f_symptr;
112
113   if (internal_a != NULL)
114     {
115       int i;
116
117       ecoff->text_start = internal_a->text_start;
118       ecoff->text_end = internal_a->text_start + internal_a->tsize;
119       ecoff->gp = internal_a->gp_value;
120       ecoff->gprmask = internal_a->gprmask;
121       for (i = 0; i < 4; i++)
122         ecoff->cprmask[i] = internal_a->cprmask[i];
123       ecoff->fprmask = internal_a->fprmask;
124       if (internal_a->magic == ECOFF_AOUT_ZMAGIC)
125         abfd->flags |= D_PAGED;
126       else
127         abfd->flags &=~ D_PAGED;
128     }
129
130   /* It turns out that no special action is required by the MIPS or
131      Alpha ECOFF backends.  They have different information in the
132      a.out header, but we just copy it all (e.g., gprmask, cprmask and
133      fprmask) and let the swapping routines ensure that only relevant
134      information is written out.  */
135
136   return (void *) ecoff;
137 }
138
139 /* Initialize a new section.  */
140
141 bfd_boolean
142 _bfd_ecoff_new_section_hook (bfd *abfd, asection *section)
143 {
144   unsigned int i;
145   static struct
146   {
147     const char * name;
148     flagword flags;
149   }
150   section_flags [] =
151   {
152     { _TEXT,   SEC_ALLOC | SEC_CODE | SEC_LOAD },
153     { _INIT,   SEC_ALLOC | SEC_CODE | SEC_LOAD },
154     { _FINI,   SEC_ALLOC | SEC_CODE | SEC_LOAD },
155     { _DATA,   SEC_ALLOC | SEC_DATA | SEC_LOAD },
156     { _SDATA,  SEC_ALLOC | SEC_DATA | SEC_LOAD },
157     { _RDATA,  SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
158     { _LIT8,   SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
159     { _LIT4,   SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
160     { _RCONST, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
161     { _PDATA,  SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
162     { _BSS,    SEC_ALLOC},
163     { _SBSS,   SEC_ALLOC},
164     /* An Irix 4 shared libary.  */
165     { _LIB,    SEC_COFF_SHARED_LIBRARY}
166   };
167
168   section->alignment_power = 4;
169
170   for (i = 0; i < ARRAY_SIZE (section_flags); i++)
171     if (streq (section->name, section_flags[i].name))
172       {
173         section->flags |= section_flags[i].flags;
174         break;
175       }
176
177
178   /* Probably any other section name is SEC_NEVER_LOAD, but I'm
179      uncertain about .init on some systems and I don't know how shared
180      libraries work.  */
181
182   return _bfd_generic_new_section_hook (abfd, section);
183 }
184
185 void
186 _bfd_ecoff_set_alignment_hook (bfd *abfd ATTRIBUTE_UNUSED,
187                                asection *section ATTRIBUTE_UNUSED,
188                                void *scnhdr ATTRIBUTE_UNUSED)
189 {
190 }
191
192 /* Determine the machine architecture and type.  This is called from
193    the generic COFF routines.  It is the inverse of ecoff_get_magic,
194    below.  This could be an ECOFF backend routine, with one version
195    for each target, but there aren't all that many ECOFF targets.  */
196
197 bfd_boolean
198 _bfd_ecoff_set_arch_mach_hook (bfd *abfd, void * filehdr)
199 {
200   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
201   enum bfd_architecture arch;
202   unsigned long mach;
203
204   switch (internal_f->f_magic)
205     {
206     case MIPS_MAGIC_1:
207     case MIPS_MAGIC_LITTLE:
208     case MIPS_MAGIC_BIG:
209       arch = bfd_arch_mips;
210       mach = bfd_mach_mips3000;
211       break;
212
213     case MIPS_MAGIC_LITTLE2:
214     case MIPS_MAGIC_BIG2:
215       /* MIPS ISA level 2: the r6000.  */
216       arch = bfd_arch_mips;
217       mach = bfd_mach_mips6000;
218       break;
219
220     case MIPS_MAGIC_LITTLE3:
221     case MIPS_MAGIC_BIG3:
222       /* MIPS ISA level 3: the r4000.  */
223       arch = bfd_arch_mips;
224       mach = bfd_mach_mips4000;
225       break;
226
227     case ALPHA_MAGIC:
228       arch = bfd_arch_alpha;
229       mach = 0;
230       break;
231
232     default:
233       arch = bfd_arch_obscure;
234       mach = 0;
235       break;
236     }
237
238   return bfd_default_set_arch_mach (abfd, arch, mach);
239 }
240
241 bfd_boolean
242 _bfd_ecoff_no_long_sections (bfd *abfd, int enable)
243 {
244   (void) abfd;
245   (void) enable;
246   return FALSE;
247 }
248
249 /* Get the magic number to use based on the architecture and machine.
250    This is the inverse of _bfd_ecoff_set_arch_mach_hook, above.  */
251
252 static int
253 ecoff_get_magic (bfd *abfd)
254 {
255   int big, little;
256
257   switch (bfd_get_arch (abfd))
258     {
259     case bfd_arch_mips:
260       switch (bfd_get_mach (abfd))
261         {
262         default:
263         case 0:
264         case bfd_mach_mips3000:
265           big = MIPS_MAGIC_BIG;
266           little = MIPS_MAGIC_LITTLE;
267           break;
268
269         case bfd_mach_mips6000:
270           big = MIPS_MAGIC_BIG2;
271           little = MIPS_MAGIC_LITTLE2;
272           break;
273
274         case bfd_mach_mips4000:
275           big = MIPS_MAGIC_BIG3;
276           little = MIPS_MAGIC_LITTLE3;
277           break;
278         }
279
280       return bfd_big_endian (abfd) ? big : little;
281
282     case bfd_arch_alpha:
283       return ALPHA_MAGIC;
284
285     default:
286       abort ();
287       return 0;
288     }
289 }
290
291 /* Get the section s_flags to use for a section.  */
292
293 static long
294 ecoff_sec_to_styp_flags (const char *name, flagword flags)
295 {
296   unsigned int i;
297   static struct
298   {
299     const char * name;
300     long flags;
301   }
302   styp_flags [] =
303   {
304     { _TEXT,    STYP_TEXT       },
305     { _DATA,    STYP_DATA       },
306     { _SDATA,   STYP_SDATA      },
307     { _RDATA,   STYP_RDATA      },
308     { _LITA,    STYP_LITA       },
309     { _LIT8,    STYP_LIT8       },
310     { _LIT4,    STYP_LIT4       },
311     { _BSS,     STYP_BSS        },
312     { _SBSS,    STYP_SBSS       },
313     { _INIT,    STYP_ECOFF_INIT },
314     { _FINI,    STYP_ECOFF_FINI },
315     { _PDATA,   STYP_PDATA      },
316     { _XDATA,   STYP_XDATA      },
317     { _LIB,     STYP_ECOFF_LIB  },
318     { _GOT,     STYP_GOT        },
319     { _HASH,    STYP_HASH       },
320     { _DYNAMIC, STYP_DYNAMIC    },
321     { _LIBLIST, STYP_LIBLIST    },
322     { _RELDYN,  STYP_RELDYN     },
323     { _CONFLIC, STYP_CONFLIC    },
324     { _DYNSTR,  STYP_DYNSTR     },
325     { _DYNSYM,  STYP_DYNSYM     },
326     { _RCONST,  STYP_RCONST     }
327   };
328   long styp = 0;
329
330   for (i = 0; i < ARRAY_SIZE (styp_flags); i++)
331     if (streq (name, styp_flags[i].name))
332       {
333         styp = styp_flags[i].flags;
334         break;
335       }
336
337   if (styp == 0)
338     {
339       if (streq (name, _COMMENT))
340         {
341           styp = STYP_COMMENT;
342           flags &=~ SEC_NEVER_LOAD;
343         }
344       else if (flags & SEC_CODE)
345         styp = STYP_TEXT;
346       else if (flags & SEC_DATA)
347         styp = STYP_DATA;
348       else if (flags & SEC_READONLY)
349         styp = STYP_RDATA;
350       else if (flags & SEC_LOAD)
351         styp = STYP_REG;
352       else
353         styp = STYP_BSS;
354     }
355
356   if (flags & SEC_NEVER_LOAD)
357     styp |= STYP_NOLOAD;
358
359   return styp;
360 }
361
362 /* Get the BFD flags to use for a section.  */
363
364 bfd_boolean
365 _bfd_ecoff_styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED,
366                               void * hdr,
367                               const char *name ATTRIBUTE_UNUSED,
368                               asection *section ATTRIBUTE_UNUSED,
369                               flagword * flags_ptr)
370 {
371   struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
372   long styp_flags = internal_s->s_flags;
373   flagword sec_flags = 0;
374
375   if (styp_flags & STYP_NOLOAD)
376     sec_flags |= SEC_NEVER_LOAD;
377
378   /* For 386 COFF, at least, an unloadable text or data section is
379      actually a shared library section.  */
380   if ((styp_flags & STYP_TEXT)
381       || (styp_flags & STYP_ECOFF_INIT)
382       || (styp_flags & STYP_ECOFF_FINI)
383       || (styp_flags & STYP_DYNAMIC)
384       || (styp_flags & STYP_LIBLIST)
385       || (styp_flags & STYP_RELDYN)
386       || styp_flags == STYP_CONFLIC
387       || (styp_flags & STYP_DYNSTR)
388       || (styp_flags & STYP_DYNSYM)
389       || (styp_flags & STYP_HASH))
390     {
391       if (sec_flags & SEC_NEVER_LOAD)
392         sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
393       else
394         sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
395     }
396   else if ((styp_flags & STYP_DATA)
397            || (styp_flags & STYP_RDATA)
398            || (styp_flags & STYP_SDATA)
399            || styp_flags == STYP_PDATA
400            || styp_flags == STYP_XDATA
401            || (styp_flags & STYP_GOT)
402            || styp_flags == STYP_RCONST)
403     {
404       if (sec_flags & SEC_NEVER_LOAD)
405         sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
406       else
407         sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
408       if ((styp_flags & STYP_RDATA)
409           || styp_flags == STYP_PDATA
410           || styp_flags == STYP_RCONST)
411         sec_flags |= SEC_READONLY;
412     }
413   else if ((styp_flags & STYP_BSS)
414            || (styp_flags & STYP_SBSS))
415     sec_flags |= SEC_ALLOC;
416   else if ((styp_flags & STYP_INFO) || styp_flags == STYP_COMMENT)
417     sec_flags |= SEC_NEVER_LOAD;
418   else if ((styp_flags & STYP_LITA)
419            || (styp_flags & STYP_LIT8)
420            || (styp_flags & STYP_LIT4))
421     sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY;
422   else if (styp_flags & STYP_ECOFF_LIB)
423     sec_flags |= SEC_COFF_SHARED_LIBRARY;
424   else
425     sec_flags |= SEC_ALLOC | SEC_LOAD;
426
427   * flags_ptr = sec_flags;
428   return TRUE;
429 }
430 \f
431 /* Read in the symbolic header for an ECOFF object file.  */
432
433 static bfd_boolean
434 ecoff_slurp_symbolic_header (bfd *abfd)
435 {
436   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
437   bfd_size_type external_hdr_size;
438   void * raw = NULL;
439   HDRR *internal_symhdr;
440
441   /* See if we've already read it in.  */
442   if (ecoff_data (abfd)->debug_info.symbolic_header.magic ==
443       backend->debug_swap.sym_magic)
444     return TRUE;
445
446   /* See whether there is a symbolic header.  */
447   if (ecoff_data (abfd)->sym_filepos == 0)
448     {
449       bfd_get_symcount (abfd) = 0;
450       return TRUE;
451     }
452
453   /* At this point bfd_get_symcount (abfd) holds the number of symbols
454      as read from the file header, but on ECOFF this is always the
455      size of the symbolic information header.  It would be cleaner to
456      handle this when we first read the file in coffgen.c.  */
457   external_hdr_size = backend->debug_swap.external_hdr_size;
458   if (bfd_get_symcount (abfd) != external_hdr_size)
459     {
460       bfd_set_error (bfd_error_bad_value);
461       return FALSE;
462     }
463
464   /* Read the symbolic information header.  */
465   raw = bfd_malloc (external_hdr_size);
466   if (raw == NULL)
467     goto error_return;
468
469   if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) != 0
470       || bfd_bread (raw, external_hdr_size, abfd) != external_hdr_size)
471     goto error_return;
472   internal_symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
473   (*backend->debug_swap.swap_hdr_in) (abfd, raw, internal_symhdr);
474
475   if (internal_symhdr->magic != backend->debug_swap.sym_magic)
476     {
477       bfd_set_error (bfd_error_bad_value);
478       goto error_return;
479     }
480
481   /* Now we can get the correct number of symbols.  */
482   bfd_get_symcount (abfd) = (internal_symhdr->isymMax
483                              + internal_symhdr->iextMax);
484
485   if (raw != NULL)
486     free (raw);
487   return TRUE;
488  error_return:
489   if (raw != NULL)
490     free (raw);
491   return FALSE;
492 }
493
494 /* Read in and swap the important symbolic information for an ECOFF
495    object file.  This is called by gdb via the read_debug_info entry
496    point in the backend structure.  */
497
498 bfd_boolean
499 _bfd_ecoff_slurp_symbolic_info (bfd *abfd,
500                                 asection *ignore ATTRIBUTE_UNUSED,
501                                 struct ecoff_debug_info *debug)
502 {
503   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
504   HDRR *internal_symhdr;
505   bfd_size_type raw_base;
506   bfd_size_type raw_size;
507   void * raw;
508   bfd_size_type external_fdr_size;
509   char *fraw_src;
510   char *fraw_end;
511   struct fdr *fdr_ptr;
512   bfd_size_type raw_end;
513   bfd_size_type cb_end;
514   file_ptr pos;
515
516   BFD_ASSERT (debug == &ecoff_data (abfd)->debug_info);
517
518   /* Check whether we've already gotten it, and whether there's any to
519      get.  */
520   if (ecoff_data (abfd)->raw_syments != NULL)
521     return TRUE;
522   if (ecoff_data (abfd)->sym_filepos == 0)
523     {
524       bfd_get_symcount (abfd) = 0;
525       return TRUE;
526     }
527
528   if (! ecoff_slurp_symbolic_header (abfd))
529     return FALSE;
530
531   internal_symhdr = &debug->symbolic_header;
532
533   /* Read all the symbolic information at once.  */
534   raw_base = (ecoff_data (abfd)->sym_filepos
535               + backend->debug_swap.external_hdr_size);
536
537   /* Alpha ecoff makes the determination of raw_size difficult. It has
538      an undocumented debug data section between the symhdr and the first
539      documented section. And the ordering of the sections varies between
540      statically and dynamically linked executables.
541      If bfd supports SEEK_END someday, this code could be simplified.  */
542   raw_end = 0;
543
544 #define UPDATE_RAW_END(start, count, size) \
545   cb_end = internal_symhdr->start + internal_symhdr->count * (size); \
546   if (cb_end > raw_end) \
547     raw_end = cb_end
548
549   UPDATE_RAW_END (cbLineOffset, cbLine, sizeof (unsigned char));
550   UPDATE_RAW_END (cbDnOffset, idnMax, backend->debug_swap.external_dnr_size);
551   UPDATE_RAW_END (cbPdOffset, ipdMax, backend->debug_swap.external_pdr_size);
552   UPDATE_RAW_END (cbSymOffset, isymMax, backend->debug_swap.external_sym_size);
553   /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the
554      optimization symtab, not the number of entries.  */
555   UPDATE_RAW_END (cbOptOffset, ioptMax, sizeof (char));
556   UPDATE_RAW_END (cbAuxOffset, iauxMax, sizeof (union aux_ext));
557   UPDATE_RAW_END (cbSsOffset, issMax, sizeof (char));
558   UPDATE_RAW_END (cbSsExtOffset, issExtMax, sizeof (char));
559   UPDATE_RAW_END (cbFdOffset, ifdMax, backend->debug_swap.external_fdr_size);
560   UPDATE_RAW_END (cbRfdOffset, crfd, backend->debug_swap.external_rfd_size);
561   UPDATE_RAW_END (cbExtOffset, iextMax, backend->debug_swap.external_ext_size);
562
563 #undef UPDATE_RAW_END
564
565   raw_size = raw_end - raw_base;
566   if (raw_size == 0)
567     {
568       ecoff_data (abfd)->sym_filepos = 0;
569       return TRUE;
570     }
571   raw = bfd_alloc (abfd, raw_size);
572   if (raw == NULL)
573     return FALSE;
574
575   pos = ecoff_data (abfd)->sym_filepos;
576   pos += backend->debug_swap.external_hdr_size;
577   if (bfd_seek (abfd, pos, SEEK_SET) != 0
578       || bfd_bread (raw, raw_size, abfd) != raw_size)
579     {
580       bfd_release (abfd, raw);
581       return FALSE;
582     }
583
584   ecoff_data (abfd)->raw_syments = raw;
585
586   /* Get pointers for the numeric offsets in the HDRR structure.  */
587 #define FIX(off1, off2, type)                           \
588   if (internal_symhdr->off1 == 0)                       \
589     debug->off2 = NULL;                                 \
590   else                                                  \
591     debug->off2 = (type) ((char *) raw                  \
592                           + (internal_symhdr->off1      \
593                              - raw_base))
594
595   FIX (cbLineOffset, line, unsigned char *);
596   FIX (cbDnOffset, external_dnr, void *);
597   FIX (cbPdOffset, external_pdr, void *);
598   FIX (cbSymOffset, external_sym, void *);
599   FIX (cbOptOffset, external_opt, void *);
600   FIX (cbAuxOffset, external_aux, union aux_ext *);
601   FIX (cbSsOffset, ss, char *);
602   FIX (cbSsExtOffset, ssext, char *);
603   FIX (cbFdOffset, external_fdr, void *);
604   FIX (cbRfdOffset, external_rfd, void *);
605   FIX (cbExtOffset, external_ext, void *);
606 #undef FIX
607
608   /* I don't want to always swap all the data, because it will just
609      waste time and most programs will never look at it.  The only
610      time the linker needs most of the debugging information swapped
611      is when linking big-endian and little-endian MIPS object files
612      together, which is not a common occurrence.
613
614      We need to look at the fdr to deal with a lot of information in
615      the symbols, so we swap them here.  */
616   debug->fdr = (FDR *) bfd_alloc2 (abfd, internal_symhdr->ifdMax,
617                                    sizeof (struct fdr));
618   if (debug->fdr == NULL)
619     return FALSE;
620   external_fdr_size = backend->debug_swap.external_fdr_size;
621   fdr_ptr = debug->fdr;
622   fraw_src = (char *) debug->external_fdr;
623   /* PR 17512: file: 3372-1243-0.004.  */
624   if (fraw_src == NULL && internal_symhdr->ifdMax > 0)
625     return FALSE;
626   fraw_end = fraw_src + internal_symhdr->ifdMax * external_fdr_size;
627   for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
628     (*backend->debug_swap.swap_fdr_in) (abfd, (void *) fraw_src, fdr_ptr);
629
630   return TRUE;
631 }
632 \f
633 /* ECOFF symbol table routines.  The ECOFF symbol table is described
634    in gcc/mips-tfile.c.  */
635
636 /* ECOFF uses two common sections.  One is the usual one, and the
637    other is for small objects.  All the small objects are kept
638    together, and then referenced via the gp pointer, which yields
639    faster assembler code.  This is what we use for the small common
640    section.  */
641 static asection ecoff_scom_section;
642 static asymbol ecoff_scom_symbol;
643 static asymbol *ecoff_scom_symbol_ptr;
644
645 /* Create an empty symbol.  */
646
647 asymbol *
648 _bfd_ecoff_make_empty_symbol (bfd *abfd)
649 {
650   ecoff_symbol_type *new_symbol;
651   bfd_size_type amt = sizeof (ecoff_symbol_type);
652
653   new_symbol = (ecoff_symbol_type *) bfd_zalloc (abfd, amt);
654   if (new_symbol == NULL)
655     return NULL;
656   new_symbol->symbol.section = NULL;
657   new_symbol->fdr = NULL;
658   new_symbol->local = FALSE;
659   new_symbol->native = NULL;
660   new_symbol->symbol.the_bfd = abfd;
661   return &new_symbol->symbol;
662 }
663
664 /* Set the BFD flags and section for an ECOFF symbol.  */
665
666 static bfd_boolean
667 ecoff_set_symbol_info (bfd *abfd,
668                        SYMR *ecoff_sym,
669                        asymbol *asym,
670                        int ext,
671                        int weak)
672 {
673   asym->the_bfd = abfd;
674   asym->value = ecoff_sym->value;
675   asym->section = &bfd_debug_section;
676   asym->udata.i = 0;
677
678   /* Most symbol types are just for debugging.  */
679   switch (ecoff_sym->st)
680     {
681     case stGlobal:
682     case stStatic:
683     case stLabel:
684     case stProc:
685     case stStaticProc:
686       break;
687     case stNil:
688       if (ECOFF_IS_STAB (ecoff_sym))
689         {
690           asym->flags = BSF_DEBUGGING;
691           return TRUE;
692         }
693       break;
694     default:
695       asym->flags = BSF_DEBUGGING;
696       return TRUE;
697     }
698
699   if (weak)
700     asym->flags = BSF_EXPORT | BSF_WEAK;
701   else if (ext)
702     asym->flags = BSF_EXPORT | BSF_GLOBAL;
703   else
704     {
705       asym->flags = BSF_LOCAL;
706       /* Normally, a local stProc symbol will have a corresponding
707          external symbol.  We mark the local symbol as a debugging
708          symbol, in order to prevent nm from printing both out.
709          Similarly, we mark stLabel and stabs symbols as debugging
710          symbols.  In both cases, we do want to set the value
711          correctly based on the symbol class.  */
712       if (ecoff_sym->st == stProc
713           || ecoff_sym->st == stLabel
714           || ECOFF_IS_STAB (ecoff_sym))
715         asym->flags |= BSF_DEBUGGING;
716     }
717
718   if (ecoff_sym->st == stProc || ecoff_sym->st == stStaticProc)
719     asym->flags |= BSF_FUNCTION;
720
721   switch (ecoff_sym->sc)
722     {
723     case scNil:
724       /* Used for compiler generated labels.  Leave them in the
725          debugging section, and mark them as local.  If BSF_DEBUGGING
726          is set, then nm does not display them for some reason.  If no
727          flags are set then the linker whines about them.  */
728       asym->flags = BSF_LOCAL;
729       break;
730     case scText:
731       asym->section = bfd_make_section_old_way (abfd, _TEXT);
732       asym->value -= asym->section->vma;
733       break;
734     case scData:
735       asym->section = bfd_make_section_old_way (abfd, _DATA);
736       asym->value -= asym->section->vma;
737       break;
738     case scBss:
739       asym->section = bfd_make_section_old_way (abfd, _BSS);
740       asym->value -= asym->section->vma;
741       break;
742     case scRegister:
743       asym->flags = BSF_DEBUGGING;
744       break;
745     case scAbs:
746       asym->section = bfd_abs_section_ptr;
747       break;
748     case scUndefined:
749       asym->section = bfd_und_section_ptr;
750       asym->flags = 0;
751       asym->value = 0;
752       break;
753     case scCdbLocal:
754     case scBits:
755     case scCdbSystem:
756     case scRegImage:
757     case scInfo:
758     case scUserStruct:
759       asym->flags = BSF_DEBUGGING;
760       break;
761     case scSData:
762       asym->section = bfd_make_section_old_way (abfd, ".sdata");
763       asym->value -= asym->section->vma;
764       break;
765     case scSBss:
766       asym->section = bfd_make_section_old_way (abfd, ".sbss");
767       asym->value -= asym->section->vma;
768       break;
769     case scRData:
770       asym->section = bfd_make_section_old_way (abfd, ".rdata");
771       asym->value -= asym->section->vma;
772       break;
773     case scVar:
774       asym->flags = BSF_DEBUGGING;
775       break;
776     case scCommon:
777       if (asym->value > ecoff_data (abfd)->gp_size)
778         {
779           asym->section = bfd_com_section_ptr;
780           asym->flags = 0;
781           break;
782         }
783       /* Fall through.  */
784     case scSCommon:
785       if (ecoff_scom_section.name == NULL)
786         {
787           /* Initialize the small common section.  */
788           ecoff_scom_section.name = SCOMMON;
789           ecoff_scom_section.flags = SEC_IS_COMMON;
790           ecoff_scom_section.output_section = &ecoff_scom_section;
791           ecoff_scom_section.symbol = &ecoff_scom_symbol;
792           ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
793           ecoff_scom_symbol.name = SCOMMON;
794           ecoff_scom_symbol.flags = BSF_SECTION_SYM;
795           ecoff_scom_symbol.section = &ecoff_scom_section;
796           ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
797         }
798       asym->section = &ecoff_scom_section;
799       asym->flags = 0;
800       break;
801     case scVarRegister:
802     case scVariant:
803       asym->flags = BSF_DEBUGGING;
804       break;
805     case scSUndefined:
806       asym->section = bfd_und_section_ptr;
807       asym->flags = 0;
808       asym->value = 0;
809       break;
810     case scInit:
811       asym->section = bfd_make_section_old_way (abfd, ".init");
812       asym->value -= asym->section->vma;
813       break;
814     case scBasedVar:
815     case scXData:
816     case scPData:
817       asym->flags = BSF_DEBUGGING;
818       break;
819     case scFini:
820       asym->section = bfd_make_section_old_way (abfd, ".fini");
821       asym->value -= asym->section->vma;
822       break;
823     case scRConst:
824       asym->section = bfd_make_section_old_way (abfd, ".rconst");
825       asym->value -= asym->section->vma;
826       break;
827     default:
828       break;
829     }
830
831   /* Look for special constructors symbols and make relocation entries
832      in a special construction section.  These are produced by the
833      -fgnu-linker argument to g++.  */
834   if (ECOFF_IS_STAB (ecoff_sym))
835     {
836       switch (ECOFF_UNMARK_STAB (ecoff_sym->index))
837         {
838         default:
839           break;
840
841         case N_SETA:
842         case N_SETT:
843         case N_SETD:
844         case N_SETB:
845           /* Mark the symbol as a constructor.  */
846           asym->flags |= BSF_CONSTRUCTOR;
847           break;
848         }
849     }
850   return TRUE;
851 }
852
853 /* Read an ECOFF symbol table.  */
854
855 bfd_boolean
856 _bfd_ecoff_slurp_symbol_table (bfd *abfd)
857 {
858   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
859   const bfd_size_type external_ext_size
860     = backend->debug_swap.external_ext_size;
861   const bfd_size_type external_sym_size
862     = backend->debug_swap.external_sym_size;
863   void (* const swap_ext_in) (bfd *, void *, EXTR *)
864     = backend->debug_swap.swap_ext_in;
865   void (* const swap_sym_in) (bfd *, void *, SYMR *)
866     = backend->debug_swap.swap_sym_in;
867   ecoff_symbol_type *internal;
868   ecoff_symbol_type *internal_ptr;
869   char *eraw_src;
870   char *eraw_end;
871   FDR *fdr_ptr;
872   FDR *fdr_end;
873
874   /* If we've already read in the symbol table, do nothing.  */
875   if (ecoff_data (abfd)->canonical_symbols != NULL)
876     return TRUE;
877
878   /* Get the symbolic information.  */
879   if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL,
880                                         &ecoff_data (abfd)->debug_info))
881     return FALSE;
882   if (bfd_get_symcount (abfd) == 0)
883     return TRUE;
884
885   internal = (ecoff_symbol_type *) bfd_alloc2 (abfd, bfd_get_symcount (abfd),
886                                                sizeof (ecoff_symbol_type));
887   if (internal == NULL)
888     return FALSE;
889
890   internal_ptr = internal;
891   eraw_src = (char *) ecoff_data (abfd)->debug_info.external_ext;
892   eraw_end = (eraw_src
893               + (ecoff_data (abfd)->debug_info.symbolic_header.iextMax
894                  * external_ext_size));
895   for (; eraw_src < eraw_end; eraw_src += external_ext_size, internal_ptr++)
896     {
897       EXTR internal_esym;
898
899       (*swap_ext_in) (abfd, (void *) eraw_src, &internal_esym);
900
901       /* PR 17512: file: 3372-1000-0.004.  */
902       if (internal_esym.asym.iss >= ecoff_data (abfd)->debug_info.symbolic_header.issExtMax
903           || internal_esym.asym.iss < 0)
904         return FALSE;
905
906       internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ssext
907                                    + internal_esym.asym.iss);
908
909       if (!ecoff_set_symbol_info (abfd, &internal_esym.asym,
910                                   &internal_ptr->symbol, 1,
911                                   internal_esym.weakext))
912         return FALSE;
913
914       /* The alpha uses a negative ifd field for section symbols.  */
915       if (internal_esym.ifd >= 0)
916         {
917           /* PR 17512: file: 3372-1983-0.004.  */
918           if (internal_esym.ifd >= ecoff_data (abfd)->debug_info.symbolic_header.ifdMax)
919             internal_ptr->fdr = NULL;
920           else
921             internal_ptr->fdr = (ecoff_data (abfd)->debug_info.fdr
922                                  + internal_esym.ifd);
923         }
924       else
925         internal_ptr->fdr = NULL;
926       internal_ptr->local = FALSE;
927       internal_ptr->native = (void *) eraw_src;
928     }
929
930   /* The local symbols must be accessed via the fdr's, because the
931      string and aux indices are relative to the fdr information.  */
932   fdr_ptr = ecoff_data (abfd)->debug_info.fdr;
933   fdr_end = fdr_ptr + ecoff_data (abfd)->debug_info.symbolic_header.ifdMax;
934   for (; fdr_ptr < fdr_end; fdr_ptr++)
935     {
936       char *lraw_src;
937       char *lraw_end;
938
939       lraw_src = ((char *) ecoff_data (abfd)->debug_info.external_sym
940                   + fdr_ptr->isymBase * external_sym_size);
941       lraw_end = lraw_src + fdr_ptr->csym * external_sym_size;
942       for (;
943            lraw_src < lraw_end;
944            lraw_src += external_sym_size, internal_ptr++)
945         {
946           SYMR internal_sym;
947
948           (*swap_sym_in) (abfd, (void *) lraw_src, &internal_sym);
949           internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ss
950                                        + fdr_ptr->issBase
951                                        + internal_sym.iss);
952           if (!ecoff_set_symbol_info (abfd, &internal_sym,
953                                       &internal_ptr->symbol, 0, 0))
954             return FALSE;
955           internal_ptr->fdr = fdr_ptr;
956           internal_ptr->local = TRUE;
957           internal_ptr->native = (void *) lraw_src;
958         }
959     }
960
961   /* PR 17512: file: 3372-3080-0.004.
962      A discrepancy between ecoff_data (abfd)->debug_info.symbolic_header.isymMax
963      and ecoff_data (abfd)->debug_info.symbolic_header.ifdMax can mean that
964      we have fewer symbols than we were expecting.  Allow for this by updating
965      the symbol count and warning the user.  */
966   if (internal_ptr - internal < (ptrdiff_t) bfd_get_symcount (abfd))
967     {
968       bfd_get_symcount (abfd) = internal_ptr - internal;
969       _bfd_error_handler
970         /* xgettext:c-format */
971         (_("%pB: warning: isymMax (%ld) is greater than ifdMax (%ld)"),
972          abfd, ecoff_data (abfd)->debug_info.symbolic_header.isymMax,
973          ecoff_data (abfd)->debug_info.symbolic_header.ifdMax);
974     }
975
976   ecoff_data (abfd)->canonical_symbols = internal;
977
978   return TRUE;
979 }
980
981 /* Return the amount of space needed for the canonical symbols.  */
982
983 long
984 _bfd_ecoff_get_symtab_upper_bound (bfd *abfd)
985 {
986   if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL,
987                                         &ecoff_data (abfd)->debug_info))
988     return -1;
989
990   if (bfd_get_symcount (abfd) == 0)
991     return 0;
992
993   return (bfd_get_symcount (abfd) + 1) * (sizeof (ecoff_symbol_type *));
994 }
995
996 /* Get the canonical symbols.  */
997
998 long
999 _bfd_ecoff_canonicalize_symtab (bfd *abfd, asymbol **alocation)
1000 {
1001   unsigned int counter = 0;
1002   ecoff_symbol_type *symbase;
1003   ecoff_symbol_type **location = (ecoff_symbol_type **) alocation;
1004
1005   if (! _bfd_ecoff_slurp_symbol_table (abfd))
1006     return -1;
1007   if (bfd_get_symcount (abfd) == 0)
1008     return 0;
1009
1010   symbase = ecoff_data (abfd)->canonical_symbols;
1011   while (counter < bfd_get_symcount (abfd))
1012     {
1013       *(location++) = symbase++;
1014       counter++;
1015     }
1016   *location++ = NULL;
1017   return bfd_get_symcount (abfd);
1018 }
1019
1020 /* Turn ECOFF type information into a printable string.
1021    ecoff_emit_aggregate and ecoff_type_to_string are from
1022    gcc/mips-tdump.c, with swapping added and used_ptr removed.  */
1023
1024 /* Write aggregate information to a string.  */
1025
1026 static void
1027 ecoff_emit_aggregate (bfd *abfd,
1028                       FDR *fdr,
1029                       char *string,
1030                       RNDXR *rndx,
1031                       long isym,
1032                       const char *which)
1033 {
1034   const struct ecoff_debug_swap * const debug_swap =
1035     &ecoff_backend (abfd)->debug_swap;
1036   struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info;
1037   unsigned int ifd = rndx->rfd;
1038   unsigned int indx = rndx->index;
1039   const char *name;
1040
1041   if (ifd == 0xfff)
1042     ifd = isym;
1043
1044   /* An ifd of -1 is an opaque type.  An escaped index of 0 is a
1045      struct return type of a procedure compiled without -g.  */
1046   if (ifd == 0xffffffff
1047       || (rndx->rfd == 0xfff && indx == 0))
1048     name = "<undefined>";
1049   else if (indx == indexNil)
1050     name = "<no name>";
1051   else
1052     {
1053       SYMR sym;
1054
1055       if (debug_info->external_rfd == NULL)
1056         fdr = debug_info->fdr + ifd;
1057       else
1058         {
1059           RFDT rfd;
1060
1061           (*debug_swap->swap_rfd_in) (abfd,
1062                                       ((char *) debug_info->external_rfd
1063                                        + ((fdr->rfdBase + ifd)
1064                                           * debug_swap->external_rfd_size)),
1065                                       &rfd);
1066           fdr = debug_info->fdr + rfd;
1067         }
1068
1069       indx += fdr->isymBase;
1070
1071       (*debug_swap->swap_sym_in) (abfd,
1072                                   ((char *) debug_info->external_sym
1073                                    + indx * debug_swap->external_sym_size),
1074                                   &sym);
1075
1076       name = debug_info->ss + fdr->issBase + sym.iss;
1077     }
1078
1079   sprintf (string,
1080            "%s %s { ifd = %u, index = %lu }",
1081            which, name, ifd,
1082            ((unsigned long) indx
1083             + debug_info->symbolic_header.iextMax));
1084 }
1085
1086 /* Convert the type information to string format.  */
1087
1088 static char *
1089 ecoff_type_to_string (bfd *abfd, FDR *fdr, unsigned int indx)
1090 {
1091   union aux_ext *aux_ptr;
1092   int bigendian;
1093   AUXU u;
1094   struct qual
1095   {
1096     unsigned int  type;
1097     int  low_bound;
1098     int  high_bound;
1099     int  stride;
1100   } qualifiers[7];
1101   unsigned int basic_type;
1102   int i;
1103   char buffer1[1024];
1104   static char buffer2[1024];
1105   char *p1 = buffer1;
1106   char *p2 = buffer2;
1107   RNDXR rndx;
1108
1109   aux_ptr = ecoff_data (abfd)->debug_info.external_aux + fdr->iauxBase;
1110   bigendian = fdr->fBigendian;
1111
1112   for (i = 0; i < 7; i++)
1113     {
1114       qualifiers[i].low_bound = 0;
1115       qualifiers[i].high_bound = 0;
1116       qualifiers[i].stride = 0;
1117     }
1118
1119   if (AUX_GET_ISYM (bigendian, &aux_ptr[indx]) == (bfd_vma) -1)
1120     return "-1 (no type)";
1121   _bfd_ecoff_swap_tir_in (bigendian, &aux_ptr[indx++].a_ti, &u.ti);
1122
1123   basic_type = u.ti.bt;
1124   qualifiers[0].type = u.ti.tq0;
1125   qualifiers[1].type = u.ti.tq1;
1126   qualifiers[2].type = u.ti.tq2;
1127   qualifiers[3].type = u.ti.tq3;
1128   qualifiers[4].type = u.ti.tq4;
1129   qualifiers[5].type = u.ti.tq5;
1130   qualifiers[6].type = tqNil;
1131
1132   /* Go get the basic type.  */
1133   switch (basic_type)
1134     {
1135     case btNil:                 /* Undefined.  */
1136       strcpy (p1, "nil");
1137       break;
1138
1139     case btAdr:                 /* Address - integer same size as pointer.  */
1140       strcpy (p1, "address");
1141       break;
1142
1143     case btChar:                /* Character.  */
1144       strcpy (p1, "char");
1145       break;
1146
1147     case btUChar:               /* Unsigned character.  */
1148       strcpy (p1, "unsigned char");
1149       break;
1150
1151     case btShort:               /* Short.  */
1152       strcpy (p1, "short");
1153       break;
1154
1155     case btUShort:              /* Unsigned short.  */
1156       strcpy (p1, "unsigned short");
1157       break;
1158
1159     case btInt:                 /* Int.  */
1160       strcpy (p1, "int");
1161       break;
1162
1163     case btUInt:                /* Unsigned int.  */
1164       strcpy (p1, "unsigned int");
1165       break;
1166
1167     case btLong:                /* Long.  */
1168       strcpy (p1, "long");
1169       break;
1170
1171     case btULong:               /* Unsigned long.  */
1172       strcpy (p1, "unsigned long");
1173       break;
1174
1175     case btFloat:               /* Float (real).  */
1176       strcpy (p1, "float");
1177       break;
1178
1179     case btDouble:              /* Double (real).  */
1180       strcpy (p1, "double");
1181       break;
1182
1183       /* Structures add 1-2 aux words:
1184          1st word is [ST_RFDESCAPE, offset] pointer to struct def;
1185          2nd word is file index if 1st word rfd is ST_RFDESCAPE.  */
1186
1187     case btStruct:              /* Structure (Record).  */
1188       _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1189       ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1190                             (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1191                             "struct");
1192       indx++;                   /* Skip aux words.  */
1193       break;
1194
1195       /* Unions add 1-2 aux words:
1196          1st word is [ST_RFDESCAPE, offset] pointer to union def;
1197          2nd word is file index if 1st word rfd is ST_RFDESCAPE.  */
1198
1199     case btUnion:               /* Union.  */
1200       _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1201       ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1202                             (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1203                             "union");
1204       indx++;                   /* Skip aux words.  */
1205       break;
1206
1207       /* Enumerations add 1-2 aux words:
1208          1st word is [ST_RFDESCAPE, offset] pointer to enum def;
1209          2nd word is file index if 1st word rfd is ST_RFDESCAPE.  */
1210
1211     case btEnum:                /* Enumeration.  */
1212       _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx);
1213       ecoff_emit_aggregate (abfd, fdr, p1, &rndx,
1214                             (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]),
1215                             "enum");
1216       indx++;                   /* Skip aux words.  */
1217       break;
1218
1219     case btTypedef:             /* Defined via a typedef, isymRef points.  */
1220       strcpy (p1, "typedef");
1221       break;
1222
1223     case btRange:               /* Subrange of int.  */
1224       strcpy (p1, "subrange");
1225       break;
1226
1227     case btSet:                 /* Pascal sets.  */
1228       strcpy (p1, "set");
1229       break;
1230
1231     case btComplex:             /* Fortran complex.  */
1232       strcpy (p1, "complex");
1233       break;
1234
1235     case btDComplex:            /* Fortran double complex.  */
1236       strcpy (p1, "double complex");
1237       break;
1238
1239     case btIndirect:            /* Forward or unnamed typedef.  */
1240       strcpy (p1, "forward/unamed typedef");
1241       break;
1242
1243     case btFixedDec:            /* Fixed Decimal.  */
1244       strcpy (p1, "fixed decimal");
1245       break;
1246
1247     case btFloatDec:            /* Float Decimal.  */
1248       strcpy (p1, "float decimal");
1249       break;
1250
1251     case btString:              /* Varying Length Character String.  */
1252       strcpy (p1, "string");
1253       break;
1254
1255     case btBit:                 /* Aligned Bit String.  */
1256       strcpy (p1, "bit");
1257       break;
1258
1259     case btPicture:             /* Picture.  */
1260       strcpy (p1, "picture");
1261       break;
1262
1263     case btVoid:                /* Void.  */
1264       strcpy (p1, "void");
1265       break;
1266
1267     default:
1268       sprintf (p1, _("unknown basic type %d"), (int) basic_type);
1269       break;
1270     }
1271
1272   p1 += strlen (buffer1);
1273
1274   /* If this is a bitfield, get the bitsize.  */
1275   if (u.ti.fBitfield)
1276     {
1277       int bitsize;
1278
1279       bitsize = AUX_GET_WIDTH (bigendian, &aux_ptr[indx++]);
1280       sprintf (p1, " : %d", bitsize);
1281       p1 += strlen (buffer1);
1282     }
1283
1284   /* Deal with any qualifiers.  */
1285   if (qualifiers[0].type != tqNil)
1286     {
1287       /* Snarf up any array bounds in the correct order.  Arrays
1288          store 5 successive words in the aux. table:
1289                 word 0  RNDXR to type of the bounds (ie, int)
1290                 word 1  Current file descriptor index
1291                 word 2  low bound
1292                 word 3  high bound (or -1 if [])
1293                 word 4  stride size in bits.  */
1294       for (i = 0; i < 7; i++)
1295         {
1296           if (qualifiers[i].type == tqArray)
1297             {
1298               qualifiers[i].low_bound =
1299                 AUX_GET_DNLOW (bigendian, &aux_ptr[indx+2]);
1300               qualifiers[i].high_bound =
1301                 AUX_GET_DNHIGH (bigendian, &aux_ptr[indx+3]);
1302               qualifiers[i].stride =
1303                 AUX_GET_WIDTH (bigendian, &aux_ptr[indx+4]);
1304               indx += 5;
1305             }
1306         }
1307
1308       /* Now print out the qualifiers.  */
1309       for (i = 0; i < 6; i++)
1310         {
1311           switch (qualifiers[i].type)
1312             {
1313             case tqNil:
1314             case tqMax:
1315               break;
1316
1317             case tqPtr:
1318               strcpy (p2, "ptr to ");
1319               p2 += sizeof ("ptr to ")-1;
1320               break;
1321
1322             case tqVol:
1323               strcpy (p2, "volatile ");
1324               p2 += sizeof ("volatile ")-1;
1325               break;
1326
1327             case tqFar:
1328               strcpy (p2, "far ");
1329               p2 += sizeof ("far ")-1;
1330               break;
1331
1332             case tqProc:
1333               strcpy (p2, "func. ret. ");
1334               p2 += sizeof ("func. ret. ");
1335               break;
1336
1337             case tqArray:
1338               {
1339                 int first_array = i;
1340                 int j;
1341
1342                 /* Print array bounds reversed (ie, in the order the C
1343                    programmer writes them).  C is such a fun language....  */
1344                 while (i < 5 && qualifiers[i+1].type == tqArray)
1345                   i++;
1346
1347                 for (j = i; j >= first_array; j--)
1348                   {
1349                     strcpy (p2, "array [");
1350                     p2 += sizeof ("array [")-1;
1351                     if (qualifiers[j].low_bound != 0)
1352                       sprintf (p2,
1353                                "%ld:%ld {%ld bits}",
1354                                (long) qualifiers[j].low_bound,
1355                                (long) qualifiers[j].high_bound,
1356                                (long) qualifiers[j].stride);
1357
1358                     else if (qualifiers[j].high_bound != -1)
1359                       sprintf (p2,
1360                                "%ld {%ld bits}",
1361                                (long) (qualifiers[j].high_bound + 1),
1362                                (long) (qualifiers[j].stride));
1363
1364                     else
1365                       sprintf (p2, " {%ld bits}", (long) (qualifiers[j].stride));
1366
1367                     p2 += strlen (p2);
1368                     strcpy (p2, "] of ");
1369                     p2 += sizeof ("] of ")-1;
1370                   }
1371               }
1372               break;
1373             }
1374         }
1375     }
1376
1377   strcpy (p2, buffer1);
1378   return buffer2;
1379 }
1380
1381 /* Return information about ECOFF symbol SYMBOL in RET.  */
1382
1383 void
1384 _bfd_ecoff_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
1385                             asymbol *symbol,
1386                             symbol_info *ret)
1387 {
1388   bfd_symbol_info (symbol, ret);
1389 }
1390
1391 /* Return whether this is a local label.  */
1392
1393 bfd_boolean
1394 _bfd_ecoff_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
1395                                     const char *name)
1396 {
1397   return name[0] == '$';
1398 }
1399
1400 /* Print information about an ECOFF symbol.  */
1401
1402 void
1403 _bfd_ecoff_print_symbol (bfd *abfd,
1404                          void * filep,
1405                          asymbol *symbol,
1406                          bfd_print_symbol_type how)
1407 {
1408   const struct ecoff_debug_swap * const debug_swap
1409     = &ecoff_backend (abfd)->debug_swap;
1410   FILE *file = (FILE *)filep;
1411
1412   switch (how)
1413     {
1414     case bfd_print_symbol_name:
1415       fprintf (file, "%s", symbol->name);
1416       break;
1417     case bfd_print_symbol_more:
1418       if (ecoffsymbol (symbol)->local)
1419         {
1420           SYMR ecoff_sym;
1421
1422           (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
1423                                       &ecoff_sym);
1424           fprintf (file, "ecoff local ");
1425           fprintf_vma (file, (bfd_vma) ecoff_sym.value);
1426           fprintf (file, " %x %x", (unsigned) ecoff_sym.st,
1427                    (unsigned) ecoff_sym.sc);
1428         }
1429       else
1430         {
1431           EXTR ecoff_ext;
1432
1433           (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
1434                                       &ecoff_ext);
1435           fprintf (file, "ecoff extern ");
1436           fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
1437           fprintf (file, " %x %x", (unsigned) ecoff_ext.asym.st,
1438                    (unsigned) ecoff_ext.asym.sc);
1439         }
1440       break;
1441     case bfd_print_symbol_all:
1442       /* Print out the symbols in a reasonable way.  */
1443       {
1444         char type;
1445         int pos;
1446         EXTR ecoff_ext;
1447         char jmptbl;
1448         char cobol_main;
1449         char weakext;
1450
1451         if (ecoffsymbol (symbol)->local)
1452           {
1453             (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
1454                                         &ecoff_ext.asym);
1455             type = 'l';
1456             pos = ((((char *) ecoffsymbol (symbol)->native
1457                      - (char *) ecoff_data (abfd)->debug_info.external_sym)
1458                     / debug_swap->external_sym_size)
1459                    + ecoff_data (abfd)->debug_info.symbolic_header.iextMax);
1460             jmptbl = ' ';
1461             cobol_main = ' ';
1462             weakext = ' ';
1463           }
1464         else
1465           {
1466             (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native,
1467                                         &ecoff_ext);
1468             type = 'e';
1469             pos = (((char *) ecoffsymbol (symbol)->native
1470                     - (char *) ecoff_data (abfd)->debug_info.external_ext)
1471                    / debug_swap->external_ext_size);
1472             jmptbl = ecoff_ext.jmptbl ? 'j' : ' ';
1473             cobol_main = ecoff_ext.cobol_main ? 'c' : ' ';
1474             weakext = ecoff_ext.weakext ? 'w' : ' ';
1475           }
1476
1477         fprintf (file, "[%3d] %c ",
1478                  pos, type);
1479         fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value);
1480         fprintf (file, " st %x sc %x indx %x %c%c%c %s",
1481                  (unsigned) ecoff_ext.asym.st,
1482                  (unsigned) ecoff_ext.asym.sc,
1483                  (unsigned) ecoff_ext.asym.index,
1484                  jmptbl, cobol_main, weakext,
1485                  symbol->name);
1486
1487         if (ecoffsymbol (symbol)->fdr != NULL
1488             && ecoff_ext.asym.index != indexNil)
1489           {
1490             FDR *fdr;
1491             unsigned int indx;
1492             int bigendian;
1493             bfd_size_type sym_base;
1494             union aux_ext *aux_base;
1495
1496             fdr = ecoffsymbol (symbol)->fdr;
1497             indx = ecoff_ext.asym.index;
1498
1499             /* sym_base is used to map the fdr relative indices which
1500                appear in the file to the position number which we are
1501                using.  */
1502             sym_base = fdr->isymBase;
1503             if (ecoffsymbol (symbol)->local)
1504               sym_base +=
1505                 ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
1506
1507             /* aux_base is the start of the aux entries for this file;
1508                asym.index is an offset from this.  */
1509             aux_base = (ecoff_data (abfd)->debug_info.external_aux
1510                         + fdr->iauxBase);
1511
1512             /* The aux entries are stored in host byte order; the
1513                order is indicated by a bit in the fdr.  */
1514             bigendian = fdr->fBigendian;
1515
1516             /* This switch is basically from gcc/mips-tdump.c.  */
1517             switch (ecoff_ext.asym.st)
1518               {
1519               case stNil:
1520               case stLabel:
1521                 break;
1522
1523               case stFile:
1524               case stBlock:
1525                 fprintf (file, _("\n      End+1 symbol: %ld"),
1526                          (long) (indx + sym_base));
1527                 break;
1528
1529               case stEnd:
1530                 if (ecoff_ext.asym.sc == scText
1531                     || ecoff_ext.asym.sc == scInfo)
1532                   fprintf (file, _("\n      First symbol: %ld"),
1533                            (long) (indx + sym_base));
1534                 else
1535                   fprintf (file, _("\n      First symbol: %ld"),
1536                            ((long)
1537                             (AUX_GET_ISYM (bigendian,
1538                                            &aux_base[ecoff_ext.asym.index])
1539                              + sym_base)));
1540                 break;
1541
1542               case stProc:
1543               case stStaticProc:
1544                 if (ECOFF_IS_STAB (&ecoff_ext.asym))
1545                   ;
1546                 else if (ecoffsymbol (symbol)->local)
1547                   /* xgettext:c-format */
1548                   fprintf (file, _("\n      End+1 symbol: %-7ld   Type:  %s"),
1549                            ((long)
1550                             (AUX_GET_ISYM (bigendian,
1551                                            &aux_base[ecoff_ext.asym.index])
1552                              + sym_base)),
1553                            ecoff_type_to_string (abfd, fdr, indx + 1));
1554                 else
1555                   fprintf (file, _("\n      Local symbol: %ld"),
1556                            ((long) indx
1557                             + (long) sym_base
1558                             + (ecoff_data (abfd)
1559                                ->debug_info.symbolic_header.iextMax)));
1560                 break;
1561
1562               case stStruct:
1563                 fprintf (file, _("\n      struct; End+1 symbol: %ld"),
1564                          (long) (indx + sym_base));
1565                 break;
1566
1567               case stUnion:
1568                 fprintf (file, _("\n      union; End+1 symbol: %ld"),
1569                          (long) (indx + sym_base));
1570                 break;
1571
1572               case stEnum:
1573                 fprintf (file, _("\n      enum; End+1 symbol: %ld"),
1574                          (long) (indx + sym_base));
1575                 break;
1576
1577               default:
1578                 if (! ECOFF_IS_STAB (&ecoff_ext.asym))
1579                   fprintf (file, _("\n      Type: %s"),
1580                            ecoff_type_to_string (abfd, fdr, indx));
1581                 break;
1582               }
1583           }
1584       }
1585       break;
1586     }
1587 }
1588 \f
1589 /* Read in the relocs for a section.  */
1590
1591 static bfd_boolean
1592 ecoff_slurp_reloc_table (bfd *abfd,
1593                          asection *section,
1594                          asymbol **symbols)
1595 {
1596   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
1597   arelent *internal_relocs;
1598   bfd_size_type external_reloc_size;
1599   bfd_size_type amt;
1600   char *external_relocs;
1601   arelent *rptr;
1602   unsigned int i;
1603
1604   if (section->relocation != NULL
1605       || section->reloc_count == 0
1606       || (section->flags & SEC_CONSTRUCTOR) != 0)
1607     return TRUE;
1608
1609   if (! _bfd_ecoff_slurp_symbol_table (abfd))
1610     return FALSE;
1611
1612   amt = section->reloc_count;
1613   amt *= sizeof (arelent);
1614   internal_relocs = (arelent *) bfd_alloc (abfd, amt);
1615
1616   external_reloc_size = backend->external_reloc_size;
1617   amt = external_reloc_size * section->reloc_count;
1618   external_relocs = (char *) bfd_alloc (abfd, amt);
1619   if (internal_relocs == NULL || external_relocs == NULL)
1620     return FALSE;
1621   if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0)
1622     return FALSE;
1623   if (bfd_bread (external_relocs, amt, abfd) != amt)
1624     return FALSE;
1625
1626   for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++)
1627     {
1628       struct internal_reloc intern;
1629
1630       (*backend->swap_reloc_in) (abfd,
1631                                  external_relocs + i * external_reloc_size,
1632                                  &intern);
1633
1634       if (intern.r_extern)
1635         {
1636           /* r_symndx is an index into the external symbols.  */
1637           BFD_ASSERT (intern.r_symndx >= 0
1638                       && (intern.r_symndx
1639                           < (ecoff_data (abfd)
1640                              ->debug_info.symbolic_header.iextMax)));
1641           rptr->sym_ptr_ptr = symbols + intern.r_symndx;
1642           rptr->addend = 0;
1643         }
1644       else if (intern.r_symndx == RELOC_SECTION_NONE
1645                || intern.r_symndx == RELOC_SECTION_ABS)
1646         {
1647           rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1648           rptr->addend = 0;
1649         }
1650       else
1651         {
1652           const char *sec_name;
1653           asection *sec;
1654
1655           /* r_symndx is a section key.  */
1656           switch (intern.r_symndx)
1657             {
1658             case RELOC_SECTION_TEXT:  sec_name = _TEXT;  break;
1659             case RELOC_SECTION_RDATA: sec_name = _RDATA; break;
1660             case RELOC_SECTION_DATA:  sec_name = _DATA;  break;
1661             case RELOC_SECTION_SDATA: sec_name = _SDATA; break;
1662             case RELOC_SECTION_SBSS:  sec_name = _SBSS;  break;
1663             case RELOC_SECTION_BSS:   sec_name = _BSS;   break;
1664             case RELOC_SECTION_INIT:  sec_name = _INIT;  break;
1665             case RELOC_SECTION_LIT8:  sec_name = _LIT8;  break;
1666             case RELOC_SECTION_LIT4:  sec_name = _LIT4;  break;
1667             case RELOC_SECTION_XDATA: sec_name = _XDATA; break;
1668             case RELOC_SECTION_PDATA: sec_name = _PDATA; break;
1669             case RELOC_SECTION_FINI:  sec_name = _FINI;  break;
1670             case RELOC_SECTION_LITA:  sec_name = _LITA;  break;
1671             case RELOC_SECTION_RCONST: sec_name = _RCONST; break;
1672             default: abort ();
1673             }
1674
1675           sec = bfd_get_section_by_name (abfd, sec_name);
1676           if (sec == NULL)
1677             abort ();
1678           rptr->sym_ptr_ptr = sec->symbol_ptr_ptr;
1679
1680           rptr->addend = - bfd_get_section_vma (abfd, sec);
1681         }
1682
1683       rptr->address = intern.r_vaddr - bfd_get_section_vma (abfd, section);
1684
1685       /* Let the backend select the howto field and do any other
1686          required processing.  */
1687       (*backend->adjust_reloc_in) (abfd, &intern, rptr);
1688     }
1689
1690   bfd_release (abfd, external_relocs);
1691
1692   section->relocation = internal_relocs;
1693
1694   return TRUE;
1695 }
1696
1697 /* Get a canonical list of relocs.  */
1698
1699 long
1700 _bfd_ecoff_canonicalize_reloc (bfd *abfd,
1701                                asection *section,
1702                                arelent **relptr,
1703                                asymbol **symbols)
1704 {
1705   unsigned int count;
1706
1707   if (section->flags & SEC_CONSTRUCTOR)
1708     {
1709       arelent_chain *chain;
1710
1711       /* This section has relocs made up by us, not the file, so take
1712          them out of their chain and place them into the data area
1713          provided.  */
1714       for (count = 0, chain = section->constructor_chain;
1715            count < section->reloc_count;
1716            count++, chain = chain->next)
1717         *relptr++ = &chain->relent;
1718     }
1719   else
1720     {
1721       arelent *tblptr;
1722
1723       if (! ecoff_slurp_reloc_table (abfd, section, symbols))
1724         return -1;
1725
1726       tblptr = section->relocation;
1727
1728       for (count = 0; count < section->reloc_count; count++)
1729         *relptr++ = tblptr++;
1730     }
1731
1732   *relptr = NULL;
1733
1734   return section->reloc_count;
1735 }
1736 \f
1737 /* Provided a BFD, a section and an offset into the section, calculate
1738    and return the name of the source file and the line nearest to the
1739    wanted location.  */
1740
1741 bfd_boolean
1742 _bfd_ecoff_find_nearest_line (bfd *abfd,
1743                               asymbol **symbols ATTRIBUTE_UNUSED,
1744                               asection *section,
1745                               bfd_vma offset,
1746                               const char **filename_ptr,
1747                               const char **functionname_ptr,
1748                               unsigned int *retline_ptr,
1749                               unsigned int *discriminator_ptr)
1750 {
1751   const struct ecoff_debug_swap * const debug_swap
1752     = &ecoff_backend (abfd)->debug_swap;
1753   struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info;
1754   struct ecoff_find_line *line_info;
1755
1756   /* Make sure we have the FDR's.  */
1757   if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, debug_info)
1758       || bfd_get_symcount (abfd) == 0)
1759     return FALSE;
1760
1761   if (ecoff_data (abfd)->find_line_info == NULL)
1762     {
1763       bfd_size_type amt = sizeof (struct ecoff_find_line);
1764
1765       ecoff_data (abfd)->find_line_info =
1766           (struct ecoff_find_line *) bfd_zalloc (abfd, amt);
1767       if (ecoff_data (abfd)->find_line_info == NULL)
1768         return FALSE;
1769     }
1770
1771   if (discriminator_ptr)
1772     *discriminator_ptr = 0;
1773   line_info = ecoff_data (abfd)->find_line_info;
1774   return _bfd_ecoff_locate_line (abfd, section, offset, debug_info,
1775                                  debug_swap, line_info, filename_ptr,
1776                                  functionname_ptr, retline_ptr);
1777 }
1778 \f
1779 /* Copy private BFD data.  This is called by objcopy and strip.  We
1780    use it to copy the ECOFF debugging information from one BFD to the
1781    other.  It would be theoretically possible to represent the ECOFF
1782    debugging information in the symbol table.  However, it would be a
1783    lot of work, and there would be little gain (gas, gdb, and ld
1784    already access the ECOFF debugging information via the
1785    ecoff_debug_info structure, and that structure would have to be
1786    retained in order to support ECOFF debugging in MIPS ELF).
1787
1788    The debugging information for the ECOFF external symbols comes from
1789    the symbol table, so this function only handles the other debugging
1790    information.  */
1791
1792 bfd_boolean
1793 _bfd_ecoff_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1794 {
1795   struct ecoff_debug_info *iinfo = &ecoff_data (ibfd)->debug_info;
1796   struct ecoff_debug_info *oinfo = &ecoff_data (obfd)->debug_info;
1797   int i;
1798   asymbol **sym_ptr_ptr;
1799   size_t c;
1800   bfd_boolean local;
1801
1802   /* We only want to copy information over if both BFD's use ECOFF
1803      format.  */
1804   if (bfd_get_flavour (ibfd) != bfd_target_ecoff_flavour
1805       || bfd_get_flavour (obfd) != bfd_target_ecoff_flavour)
1806     return TRUE;
1807
1808   /* Copy the GP value and the register masks.  */
1809   ecoff_data (obfd)->gp = ecoff_data (ibfd)->gp;
1810   ecoff_data (obfd)->gprmask = ecoff_data (ibfd)->gprmask;
1811   ecoff_data (obfd)->fprmask = ecoff_data (ibfd)->fprmask;
1812   for (i = 0; i < 3; i++)
1813     ecoff_data (obfd)->cprmask[i] = ecoff_data (ibfd)->cprmask[i];
1814
1815   /* Copy the version stamp.  */
1816   oinfo->symbolic_header.vstamp = iinfo->symbolic_header.vstamp;
1817
1818   /* If there are no symbols, don't copy any debugging information.  */
1819   c = bfd_get_symcount (obfd);
1820   sym_ptr_ptr = bfd_get_outsymbols (obfd);
1821   if (c == 0 || sym_ptr_ptr == NULL)
1822     return TRUE;
1823
1824   /* See if there are any local symbols.  */
1825   local = FALSE;
1826   for (; c > 0; c--, sym_ptr_ptr++)
1827     {
1828       if (ecoffsymbol (*sym_ptr_ptr)->local)
1829         {
1830           local = TRUE;
1831           break;
1832         }
1833     }
1834
1835   if (local)
1836     {
1837       /* There are some local symbols.  We just bring over all the
1838          debugging information.  FIXME: This is not quite the right
1839          thing to do.  If the user has asked us to discard all
1840          debugging information, then we are probably going to wind up
1841          keeping it because there will probably be some local symbol
1842          which objcopy did not discard.  We should actually break
1843          apart the debugging information and only keep that which
1844          applies to the symbols we want to keep.  */
1845       oinfo->symbolic_header.ilineMax = iinfo->symbolic_header.ilineMax;
1846       oinfo->symbolic_header.cbLine = iinfo->symbolic_header.cbLine;
1847       oinfo->line = iinfo->line;
1848
1849       oinfo->symbolic_header.idnMax = iinfo->symbolic_header.idnMax;
1850       oinfo->external_dnr = iinfo->external_dnr;
1851
1852       oinfo->symbolic_header.ipdMax = iinfo->symbolic_header.ipdMax;
1853       oinfo->external_pdr = iinfo->external_pdr;
1854
1855       oinfo->symbolic_header.isymMax = iinfo->symbolic_header.isymMax;
1856       oinfo->external_sym = iinfo->external_sym;
1857
1858       oinfo->symbolic_header.ioptMax = iinfo->symbolic_header.ioptMax;
1859       oinfo->external_opt = iinfo->external_opt;
1860
1861       oinfo->symbolic_header.iauxMax = iinfo->symbolic_header.iauxMax;
1862       oinfo->external_aux = iinfo->external_aux;
1863
1864       oinfo->symbolic_header.issMax = iinfo->symbolic_header.issMax;
1865       oinfo->ss = iinfo->ss;
1866
1867       oinfo->symbolic_header.ifdMax = iinfo->symbolic_header.ifdMax;
1868       oinfo->external_fdr = iinfo->external_fdr;
1869
1870       oinfo->symbolic_header.crfd = iinfo->symbolic_header.crfd;
1871       oinfo->external_rfd = iinfo->external_rfd;
1872     }
1873   else
1874     {
1875       /* We are discarding all the local symbol information.  Look
1876          through the external symbols and remove all references to FDR
1877          or aux information.  */
1878       c = bfd_get_symcount (obfd);
1879       sym_ptr_ptr = bfd_get_outsymbols (obfd);
1880       for (; c > 0; c--, sym_ptr_ptr++)
1881         {
1882           EXTR esym;
1883
1884           (*(ecoff_backend (obfd)->debug_swap.swap_ext_in))
1885             (obfd, ecoffsymbol (*sym_ptr_ptr)->native, &esym);
1886           esym.ifd = ifdNil;
1887           esym.asym.index = indexNil;
1888           (*(ecoff_backend (obfd)->debug_swap.swap_ext_out))
1889             (obfd, &esym, ecoffsymbol (*sym_ptr_ptr)->native);
1890         }
1891     }
1892
1893   return TRUE;
1894 }
1895 \f
1896 /* Set the architecture.  The supported architecture is stored in the
1897    backend pointer.  We always set the architecture anyhow, since many
1898    callers ignore the return value.  */
1899
1900 bfd_boolean
1901 _bfd_ecoff_set_arch_mach (bfd *abfd,
1902                           enum bfd_architecture arch,
1903                           unsigned long machine)
1904 {
1905   bfd_default_set_arch_mach (abfd, arch, machine);
1906   return arch == ecoff_backend (abfd)->arch;
1907 }
1908
1909 /* Get the size of the section headers.  */
1910
1911 int
1912 _bfd_ecoff_sizeof_headers (bfd *abfd,
1913                            struct bfd_link_info *info ATTRIBUTE_UNUSED)
1914 {
1915   asection *current;
1916   int c;
1917   int ret;
1918
1919   c = 0;
1920   for (current = abfd->sections;
1921        current != NULL;
1922        current = current->next)
1923     ++c;
1924
1925   ret = (bfd_coff_filhsz (abfd)
1926          + bfd_coff_aoutsz (abfd)
1927          + c * bfd_coff_scnhsz (abfd));
1928   return (int) BFD_ALIGN (ret, 16);
1929 }
1930
1931 /* Get the contents of a section.  */
1932
1933 bfd_boolean
1934 _bfd_ecoff_get_section_contents (bfd *abfd,
1935                                  asection *section,
1936                                  void * location,
1937                                  file_ptr offset,
1938                                  bfd_size_type count)
1939 {
1940   return _bfd_generic_get_section_contents (abfd, section, location,
1941                                             offset, count);
1942 }
1943
1944 /* Sort sections by VMA, but put SEC_ALLOC sections first.  This is
1945    called via qsort.  */
1946
1947 static int
1948 ecoff_sort_hdrs (const void * arg1, const void * arg2)
1949 {
1950   const asection *hdr1 = *(const asection **) arg1;
1951   const asection *hdr2 = *(const asection **) arg2;
1952
1953   if ((hdr1->flags & SEC_ALLOC) != 0)
1954     {
1955       if ((hdr2->flags & SEC_ALLOC) == 0)
1956         return -1;
1957     }
1958   else
1959     {
1960       if ((hdr2->flags & SEC_ALLOC) != 0)
1961         return 1;
1962     }
1963   if (hdr1->vma < hdr2->vma)
1964     return -1;
1965   else if (hdr1->vma > hdr2->vma)
1966     return 1;
1967   else
1968     return 0;
1969 }
1970
1971 /* Calculate the file position for each section, and set
1972    reloc_filepos.  */
1973
1974 static bfd_boolean
1975 ecoff_compute_section_file_positions (bfd *abfd)
1976 {
1977   file_ptr sofar, file_sofar;
1978   asection **sorted_hdrs;
1979   asection *current;
1980   unsigned int i;
1981   file_ptr old_sofar;
1982   bfd_boolean rdata_in_text;
1983   bfd_boolean first_data, first_nonalloc;
1984   const bfd_vma round = ecoff_backend (abfd)->round;
1985   bfd_size_type amt;
1986
1987   sofar = _bfd_ecoff_sizeof_headers (abfd, NULL);
1988   file_sofar = sofar;
1989
1990   /* Sort the sections by VMA.  */
1991   amt = abfd->section_count;
1992   amt *= sizeof (asection *);
1993   sorted_hdrs = (asection **) bfd_malloc (amt);
1994   if (sorted_hdrs == NULL)
1995     return FALSE;
1996   for (current = abfd->sections, i = 0;
1997        current != NULL;
1998        current = current->next, i++)
1999     sorted_hdrs[i] = current;
2000   BFD_ASSERT (i == abfd->section_count);
2001
2002   qsort (sorted_hdrs, abfd->section_count, sizeof (asection *),
2003          ecoff_sort_hdrs);
2004
2005   /* Some versions of the OSF linker put the .rdata section in the
2006      text segment, and some do not.  */
2007   rdata_in_text = ecoff_backend (abfd)->rdata_in_text;
2008   if (rdata_in_text)
2009     {
2010       for (i = 0; i < abfd->section_count; i++)
2011         {
2012           current = sorted_hdrs[i];
2013           if (streq (current->name, _RDATA))
2014             break;
2015           if ((current->flags & SEC_CODE) == 0
2016               && ! streq (current->name, _PDATA)
2017               && ! streq (current->name, _RCONST))
2018             {
2019               rdata_in_text = FALSE;
2020               break;
2021             }
2022         }
2023     }
2024   ecoff_data (abfd)->rdata_in_text = rdata_in_text;
2025
2026   first_data = TRUE;
2027   first_nonalloc = TRUE;
2028   for (i = 0; i < abfd->section_count; i++)
2029     {
2030       unsigned int alignment_power;
2031
2032       current = sorted_hdrs[i];
2033
2034       /* For the Alpha ECOFF .pdata section the lnnoptr field is
2035          supposed to indicate the number of .pdata entries that are
2036          really in the section.  Each entry is 8 bytes.  We store this
2037          away in line_filepos before increasing the section size.  */
2038       if (streq (current->name, _PDATA))
2039         current->line_filepos = current->size / 8;
2040
2041       alignment_power = current->alignment_power;
2042
2043       /* On Ultrix, the data sections in an executable file must be
2044          aligned to a page boundary within the file.  This does not
2045          affect the section size, though.  FIXME: Does this work for
2046          other platforms?  It requires some modification for the
2047          Alpha, because .rdata on the Alpha goes with the text, not
2048          the data.  */
2049       if ((abfd->flags & EXEC_P) != 0
2050           && (abfd->flags & D_PAGED) != 0
2051           && ! first_data
2052           && (current->flags & SEC_CODE) == 0
2053           && (! rdata_in_text
2054               || ! streq (current->name, _RDATA))
2055           && ! streq (current->name, _PDATA)
2056           && ! streq (current->name, _RCONST))
2057         {
2058           sofar = (sofar + round - 1) &~ (round - 1);
2059           file_sofar = (file_sofar + round - 1) &~ (round - 1);
2060           first_data = FALSE;
2061         }
2062       else if (streq (current->name, _LIB))
2063         {
2064           /* On Irix 4, the location of contents of the .lib section
2065              from a shared library section is also rounded up to a
2066              page boundary.  */
2067
2068           sofar = (sofar + round - 1) &~ (round - 1);
2069           file_sofar = (file_sofar + round - 1) &~ (round - 1);
2070         }
2071       else if (first_nonalloc
2072                && (current->flags & SEC_ALLOC) == 0
2073                && (abfd->flags & D_PAGED) != 0)
2074         {
2075           /* Skip up to the next page for an unallocated section, such
2076              as the .comment section on the Alpha.  This leaves room
2077              for the .bss section.  */
2078           first_nonalloc = FALSE;
2079           sofar = (sofar + round - 1) &~ (round - 1);
2080           file_sofar = (file_sofar + round - 1) &~ (round - 1);
2081         }
2082
2083       /* Align the sections in the file to the same boundary on
2084          which they are aligned in virtual memory.  */
2085       sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2086       if ((current->flags & SEC_HAS_CONTENTS) != 0)
2087         file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power);
2088
2089       if ((abfd->flags & D_PAGED) != 0
2090           && (current->flags & SEC_ALLOC) != 0)
2091         {
2092           sofar += (current->vma - sofar) % round;
2093           if ((current->flags & SEC_HAS_CONTENTS) != 0)
2094             file_sofar += (current->vma - file_sofar) % round;
2095         }
2096
2097       if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) != 0)
2098         current->filepos = file_sofar;
2099
2100       sofar += current->size;
2101       if ((current->flags & SEC_HAS_CONTENTS) != 0)
2102         file_sofar += current->size;
2103
2104       /* Make sure that this section is of the right size too.  */
2105       old_sofar = sofar;
2106       sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2107       if ((current->flags & SEC_HAS_CONTENTS) != 0)
2108         file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power);
2109       current->size += sofar - old_sofar;
2110     }
2111
2112   free (sorted_hdrs);
2113   sorted_hdrs = NULL;
2114
2115   ecoff_data (abfd)->reloc_filepos = file_sofar;
2116
2117   return TRUE;
2118 }
2119
2120 /* Determine the location of the relocs for all the sections in the
2121    output file, as well as the location of the symbolic debugging
2122    information.  */
2123
2124 static bfd_size_type
2125 ecoff_compute_reloc_file_positions (bfd *abfd)
2126 {
2127   const bfd_size_type external_reloc_size =
2128     ecoff_backend (abfd)->external_reloc_size;
2129   file_ptr reloc_base;
2130   bfd_size_type reloc_size;
2131   asection *current;
2132   file_ptr sym_base;
2133
2134   if (! abfd->output_has_begun)
2135     {
2136       if (! ecoff_compute_section_file_positions (abfd))
2137         abort ();
2138       abfd->output_has_begun = TRUE;
2139     }
2140
2141   reloc_base = ecoff_data (abfd)->reloc_filepos;
2142
2143   reloc_size = 0;
2144   for (current = abfd->sections;
2145        current != NULL;
2146        current = current->next)
2147     {
2148       if (current->reloc_count == 0)
2149         current->rel_filepos = 0;
2150       else
2151         {
2152           bfd_size_type relsize;
2153
2154           current->rel_filepos = reloc_base;
2155           relsize = current->reloc_count * external_reloc_size;
2156           reloc_size += relsize;
2157           reloc_base += relsize;
2158         }
2159     }
2160
2161   sym_base = ecoff_data (abfd)->reloc_filepos + reloc_size;
2162
2163   /* At least on Ultrix, the symbol table of an executable file must
2164      be aligned to a page boundary.  FIXME: Is this true on other
2165      platforms?  */
2166   if ((abfd->flags & EXEC_P) != 0
2167       && (abfd->flags & D_PAGED) != 0)
2168     sym_base = ((sym_base + ecoff_backend (abfd)->round - 1)
2169                 &~ (ecoff_backend (abfd)->round - 1));
2170
2171   ecoff_data (abfd)->sym_filepos = sym_base;
2172
2173   return reloc_size;
2174 }
2175
2176 /* Set the contents of a section.  */
2177
2178 bfd_boolean
2179 _bfd_ecoff_set_section_contents (bfd *abfd,
2180                                  asection *section,
2181                                  const void * location,
2182                                  file_ptr offset,
2183                                  bfd_size_type count)
2184 {
2185   file_ptr pos;
2186
2187   /* This must be done first, because bfd_set_section_contents is
2188      going to set output_has_begun to TRUE.  */
2189   if (! abfd->output_has_begun
2190       && ! ecoff_compute_section_file_positions (abfd))
2191     return FALSE;
2192
2193   /* Handle the .lib section specially so that Irix 4 shared libraries
2194      work out.  See coff_set_section_contents in coffcode.h.  */
2195   if (streq (section->name, _LIB))
2196     {
2197       bfd_byte *rec, *recend;
2198
2199       rec = (bfd_byte *) location;
2200       recend = rec + count;
2201       while (rec < recend)
2202         {
2203           ++section->lma;
2204           rec += bfd_get_32 (abfd, rec) * 4;
2205         }
2206
2207       BFD_ASSERT (rec == recend);
2208     }
2209
2210   if (count == 0)
2211     return TRUE;
2212
2213   pos = section->filepos + offset;
2214   if (bfd_seek (abfd, pos, SEEK_SET) != 0
2215       || bfd_bwrite (location, count, abfd) != count)
2216     return FALSE;
2217
2218   return TRUE;
2219 }
2220
2221 /* Set the GP value for an ECOFF file.  This is a hook used by the
2222    assembler.  */
2223
2224 bfd_boolean
2225 bfd_ecoff_set_gp_value (bfd *abfd, bfd_vma gp_value)
2226 {
2227   if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2228       || bfd_get_format (abfd) != bfd_object)
2229     {
2230       bfd_set_error (bfd_error_invalid_operation);
2231       return FALSE;
2232     }
2233
2234   ecoff_data (abfd)->gp = gp_value;
2235
2236   return TRUE;
2237 }
2238
2239 /* Set the register masks for an ECOFF file.  This is a hook used by
2240    the assembler.  */
2241
2242 bfd_boolean
2243 bfd_ecoff_set_regmasks (bfd *abfd,
2244                         unsigned long gprmask,
2245                         unsigned long fprmask,
2246                         unsigned long *cprmask)
2247 {
2248   ecoff_data_type *tdata;
2249
2250   if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2251       || bfd_get_format (abfd) != bfd_object)
2252     {
2253       bfd_set_error (bfd_error_invalid_operation);
2254       return FALSE;
2255     }
2256
2257   tdata = ecoff_data (abfd);
2258   tdata->gprmask = gprmask;
2259   tdata->fprmask = fprmask;
2260   if (cprmask != NULL)
2261     {
2262       int i;
2263
2264       for (i = 0; i < 3; i++)
2265         tdata->cprmask[i] = cprmask[i];
2266     }
2267
2268   return TRUE;
2269 }
2270
2271 /* Get ECOFF EXTR information for an external symbol.  This function
2272    is passed to bfd_ecoff_debug_externals.  */
2273
2274 static bfd_boolean
2275 ecoff_get_extr (asymbol *sym, EXTR *esym)
2276 {
2277   ecoff_symbol_type *ecoff_sym_ptr;
2278   bfd *input_bfd;
2279
2280   if (bfd_asymbol_flavour (sym) != bfd_target_ecoff_flavour
2281       || ecoffsymbol (sym)->native == NULL)
2282     {
2283       /* Don't include debugging, local, or section symbols.  */
2284       if ((sym->flags & BSF_DEBUGGING) != 0
2285           || (sym->flags & BSF_LOCAL) != 0
2286           || (sym->flags & BSF_SECTION_SYM) != 0)
2287         return FALSE;
2288
2289       esym->jmptbl = 0;
2290       esym->cobol_main = 0;
2291       esym->weakext = (sym->flags & BSF_WEAK) != 0;
2292       esym->reserved = 0;
2293       esym->ifd = ifdNil;
2294       /* FIXME: we can do better than this for st and sc.  */
2295       esym->asym.st = stGlobal;
2296       esym->asym.sc = scAbs;
2297       esym->asym.reserved = 0;
2298       esym->asym.index = indexNil;
2299       return TRUE;
2300     }
2301
2302   ecoff_sym_ptr = ecoffsymbol (sym);
2303
2304   if (ecoff_sym_ptr->local)
2305     return FALSE;
2306
2307   input_bfd = bfd_asymbol_bfd (sym);
2308   (*(ecoff_backend (input_bfd)->debug_swap.swap_ext_in))
2309     (input_bfd, ecoff_sym_ptr->native, esym);
2310
2311   /* If the symbol was defined by the linker, then esym will be
2312      undefined but sym will not be.  Get a better class for such a
2313      symbol.  */
2314   if ((esym->asym.sc == scUndefined
2315        || esym->asym.sc == scSUndefined)
2316       && ! bfd_is_und_section (bfd_get_section (sym)))
2317     esym->asym.sc = scAbs;
2318
2319   /* Adjust the FDR index for the symbol by that used for the input
2320      BFD.  */
2321   if (esym->ifd != -1)
2322     {
2323       struct ecoff_debug_info *input_debug;
2324
2325       input_debug = &ecoff_data (input_bfd)->debug_info;
2326       BFD_ASSERT (esym->ifd < input_debug->symbolic_header.ifdMax);
2327       if (input_debug->ifdmap != NULL)
2328         esym->ifd = input_debug->ifdmap[esym->ifd];
2329     }
2330
2331   return TRUE;
2332 }
2333
2334 /* Set the external symbol index.  This routine is passed to
2335    bfd_ecoff_debug_externals.  */
2336
2337 static void
2338 ecoff_set_index (asymbol *sym, bfd_size_type indx)
2339 {
2340   ecoff_set_sym_index (sym, indx);
2341 }
2342
2343 /* Write out an ECOFF file.  */
2344
2345 bfd_boolean
2346 _bfd_ecoff_write_object_contents (bfd *abfd)
2347 {
2348   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
2349   const bfd_vma round = backend->round;
2350   const bfd_size_type filhsz = bfd_coff_filhsz (abfd);
2351   const bfd_size_type aoutsz = bfd_coff_aoutsz (abfd);
2352   const bfd_size_type scnhsz = bfd_coff_scnhsz (abfd);
2353   const bfd_size_type external_hdr_size
2354     = backend->debug_swap.external_hdr_size;
2355   const bfd_size_type external_reloc_size = backend->external_reloc_size;
2356   void (* const adjust_reloc_out) (bfd *, const arelent *, struct internal_reloc *)
2357     = backend->adjust_reloc_out;
2358   void (* const swap_reloc_out) (bfd *, const struct internal_reloc *, void *)
2359     = backend->swap_reloc_out;
2360   struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
2361   HDRR * const symhdr = &debug->symbolic_header;
2362   asection *current;
2363   unsigned int count;
2364   bfd_size_type reloc_size;
2365   bfd_size_type text_size;
2366   bfd_vma text_start;
2367   bfd_boolean set_text_start;
2368   bfd_size_type data_size;
2369   bfd_vma data_start;
2370   bfd_boolean set_data_start;
2371   bfd_size_type bss_size;
2372   void * buff = NULL;
2373   void * reloc_buff = NULL;
2374   struct internal_filehdr internal_f;
2375   struct internal_aouthdr internal_a;
2376   int i;
2377
2378   /* Determine where the sections and relocs will go in the output
2379      file.  */
2380   reloc_size = ecoff_compute_reloc_file_positions (abfd);
2381
2382   count = 1;
2383   for (current = abfd->sections;
2384        current != NULL;
2385        current = current->next)
2386     {
2387       current->target_index = count;
2388       ++count;
2389     }
2390
2391   if ((abfd->flags & D_PAGED) != 0)
2392     text_size = _bfd_ecoff_sizeof_headers (abfd, NULL);
2393   else
2394     text_size = 0;
2395   text_start = 0;
2396   set_text_start = FALSE;
2397   data_size = 0;
2398   data_start = 0;
2399   set_data_start = FALSE;
2400   bss_size = 0;
2401
2402   /* Write section headers to the file.  */
2403
2404   /* Allocate buff big enough to hold a section header,
2405      file header, or a.out header.  */
2406   {
2407     bfd_size_type siz;
2408
2409     siz = scnhsz;
2410     if (siz < filhsz)
2411       siz = filhsz;
2412     if (siz < aoutsz)
2413       siz = aoutsz;
2414     buff = bfd_malloc (siz);
2415     if (buff == NULL)
2416       goto error_return;
2417   }
2418
2419   internal_f.f_nscns = 0;
2420   if (bfd_seek (abfd, (file_ptr) (filhsz + aoutsz), SEEK_SET) != 0)
2421     goto error_return;
2422
2423   for (current = abfd->sections;
2424        current != NULL;
2425        current = current->next)
2426     {
2427       struct internal_scnhdr section;
2428       bfd_vma vma;
2429
2430       ++internal_f.f_nscns;
2431
2432       strncpy (section.s_name, current->name, sizeof section.s_name);
2433
2434       /* This seems to be correct for Irix 4 shared libraries.  */
2435       vma = bfd_get_section_vma (abfd, current);
2436       if (streq (current->name, _LIB))
2437         section.s_vaddr = 0;
2438       else
2439         section.s_vaddr = vma;
2440
2441       section.s_paddr = current->lma;
2442       section.s_size = current->size;
2443
2444       /* If this section is unloadable then the scnptr will be 0.  */
2445       if ((current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2446         section.s_scnptr = 0;
2447       else
2448         section.s_scnptr = current->filepos;
2449       section.s_relptr = current->rel_filepos;
2450
2451       /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2452          object file produced by the assembler is supposed to point to
2453          information about how much room is required by objects of
2454          various different sizes.  I think this only matters if we
2455          want the linker to compute the best size to use, or
2456          something.  I don't know what happens if the information is
2457          not present.  */
2458       if (! streq (current->name, _PDATA))
2459         section.s_lnnoptr = 0;
2460       else
2461         {
2462           /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2463              hold the number of entries in the section (each entry is
2464              8 bytes).  We stored this in the line_filepos field in
2465              ecoff_compute_section_file_positions.  */
2466           section.s_lnnoptr = current->line_filepos;
2467         }
2468
2469       section.s_nreloc = current->reloc_count;
2470       section.s_nlnno = 0;
2471       section.s_flags = ecoff_sec_to_styp_flags (current->name,
2472                                                  current->flags);
2473
2474       if (bfd_coff_swap_scnhdr_out (abfd, (void *) &section, buff) == 0
2475           || bfd_bwrite (buff, scnhsz, abfd) != scnhsz)
2476         goto error_return;
2477
2478       if ((section.s_flags & STYP_TEXT) != 0
2479           || ((section.s_flags & STYP_RDATA) != 0
2480               && ecoff_data (abfd)->rdata_in_text)
2481           || section.s_flags == STYP_PDATA
2482           || (section.s_flags & STYP_DYNAMIC) != 0
2483           || (section.s_flags & STYP_LIBLIST) != 0
2484           || (section.s_flags & STYP_RELDYN) != 0
2485           || section.s_flags == STYP_CONFLIC
2486           || (section.s_flags & STYP_DYNSTR) != 0
2487           || (section.s_flags & STYP_DYNSYM) != 0
2488           || (section.s_flags & STYP_HASH) != 0
2489           || (section.s_flags & STYP_ECOFF_INIT) != 0
2490           || (section.s_flags & STYP_ECOFF_FINI) != 0
2491           || section.s_flags == STYP_RCONST)
2492         {
2493           text_size += current->size;
2494           if (! set_text_start || text_start > vma)
2495             {
2496               text_start = vma;
2497               set_text_start = TRUE;
2498             }
2499         }
2500       else if ((section.s_flags & STYP_RDATA) != 0
2501                || (section.s_flags & STYP_DATA) != 0
2502                || (section.s_flags & STYP_LITA) != 0
2503                || (section.s_flags & STYP_LIT8) != 0
2504                || (section.s_flags & STYP_LIT4) != 0
2505                || (section.s_flags & STYP_SDATA) != 0
2506                || section.s_flags == STYP_XDATA
2507                || (section.s_flags & STYP_GOT) != 0)
2508         {
2509           data_size += current->size;
2510           if (! set_data_start || data_start > vma)
2511             {
2512               data_start = vma;
2513               set_data_start = TRUE;
2514             }
2515         }
2516       else if ((section.s_flags & STYP_BSS) != 0
2517                || (section.s_flags & STYP_SBSS) != 0)
2518         bss_size += current->size;
2519       else if (section.s_flags == 0
2520                || (section.s_flags & STYP_ECOFF_LIB) != 0
2521                || section.s_flags == STYP_COMMENT)
2522         /* Do nothing.  */ ;
2523       else
2524         abort ();
2525     }
2526
2527   /* Set up the file header.  */
2528   internal_f.f_magic = ecoff_get_magic (abfd);
2529
2530   /* We will NOT put a fucking timestamp in the header here. Every
2531      time you put it back, I will come in and take it out again.  I'm
2532      sorry.  This field does not belong here.  We fill it with a 0 so
2533      it compares the same but is not a reasonable time. --
2534      gnu@cygnus.com.  */
2535   internal_f.f_timdat = 0;
2536
2537   if (bfd_get_symcount (abfd) != 0)
2538     {
2539       /* The ECOFF f_nsyms field is not actually the number of
2540          symbols, it's the size of symbolic information header.  */
2541       internal_f.f_nsyms = external_hdr_size;
2542       internal_f.f_symptr = ecoff_data (abfd)->sym_filepos;
2543     }
2544   else
2545     {
2546       internal_f.f_nsyms = 0;
2547       internal_f.f_symptr = 0;
2548     }
2549
2550   internal_f.f_opthdr = aoutsz;
2551
2552   internal_f.f_flags = F_LNNO;
2553   if (reloc_size == 0)
2554     internal_f.f_flags |= F_RELFLG;
2555   if (bfd_get_symcount (abfd) == 0)
2556     internal_f.f_flags |= F_LSYMS;
2557   if (abfd->flags & EXEC_P)
2558     internal_f.f_flags |= F_EXEC;
2559
2560   if (bfd_little_endian (abfd))
2561     internal_f.f_flags |= F_AR32WR;
2562   else
2563     internal_f.f_flags |= F_AR32W;
2564
2565   /* Set up the ``optional'' header.  */
2566   if ((abfd->flags & D_PAGED) != 0)
2567     internal_a.magic = ECOFF_AOUT_ZMAGIC;
2568   else
2569     internal_a.magic = ECOFF_AOUT_OMAGIC;
2570
2571   /* FIXME: Is this really correct?  */
2572   internal_a.vstamp = symhdr->vstamp;
2573
2574   /* At least on Ultrix, these have to be rounded to page boundaries.
2575      FIXME: Is this true on other platforms?  */
2576   if ((abfd->flags & D_PAGED) != 0)
2577     {
2578       internal_a.tsize = (text_size + round - 1) &~ (round - 1);
2579       internal_a.text_start = text_start &~ (round - 1);
2580       internal_a.dsize = (data_size + round - 1) &~ (round - 1);
2581       internal_a.data_start = data_start &~ (round - 1);
2582     }
2583   else
2584     {
2585       internal_a.tsize = text_size;
2586       internal_a.text_start = text_start;
2587       internal_a.dsize = data_size;
2588       internal_a.data_start = data_start;
2589     }
2590
2591   /* On Ultrix, the initial portions of the .sbss and .bss segments
2592      are at the end of the data section.  The bsize field in the
2593      optional header records how many bss bytes are required beyond
2594      those in the data section.  The value is not rounded to a page
2595      boundary.  */
2596   if (bss_size < internal_a.dsize - data_size)
2597     bss_size = 0;
2598   else
2599     bss_size -= internal_a.dsize - data_size;
2600   internal_a.bsize = bss_size;
2601   internal_a.bss_start = internal_a.data_start + internal_a.dsize;
2602
2603   internal_a.entry = bfd_get_start_address (abfd);
2604
2605   internal_a.gp_value = ecoff_data (abfd)->gp;
2606
2607   internal_a.gprmask = ecoff_data (abfd)->gprmask;
2608   internal_a.fprmask = ecoff_data (abfd)->fprmask;
2609   for (i = 0; i < 4; i++)
2610     internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i];
2611
2612   /* Let the backend adjust the headers if necessary.  */
2613   if (backend->adjust_headers)
2614     {
2615       if (! (*backend->adjust_headers) (abfd, &internal_f, &internal_a))
2616         goto error_return;
2617     }
2618
2619   /* Write out the file header and the optional header.  */
2620   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
2621     goto error_return;
2622
2623   bfd_coff_swap_filehdr_out (abfd, (void *) &internal_f, buff);
2624   if (bfd_bwrite (buff, filhsz, abfd) != filhsz)
2625     goto error_return;
2626
2627   bfd_coff_swap_aouthdr_out (abfd, (void *) &internal_a, buff);
2628   if (bfd_bwrite (buff, aoutsz, abfd) != aoutsz)
2629     goto error_return;
2630
2631   /* Build the external symbol information.  This must be done before
2632      writing out the relocs so that we know the symbol indices.  We
2633      don't do this if this BFD was created by the backend linker,
2634      since it will have already handled the symbols and relocs.  */
2635   if (! ecoff_data (abfd)->linker)
2636     {
2637       symhdr->iextMax = 0;
2638       symhdr->issExtMax = 0;
2639       debug->external_ext = debug->external_ext_end = NULL;
2640       debug->ssext = debug->ssext_end = NULL;
2641       if (! bfd_ecoff_debug_externals (abfd, debug, &backend->debug_swap,
2642                                        (abfd->flags & EXEC_P) == 0,
2643                                        ecoff_get_extr, ecoff_set_index))
2644         goto error_return;
2645
2646       /* Write out the relocs.  */
2647       for (current = abfd->sections;
2648            current != NULL;
2649            current = current->next)
2650         {
2651           arelent **reloc_ptr_ptr;
2652           arelent **reloc_end;
2653           char *out_ptr;
2654           bfd_size_type amt;
2655
2656           if (current->reloc_count == 0)
2657             continue;
2658
2659           amt = current->reloc_count * external_reloc_size;
2660           reloc_buff = bfd_alloc (abfd, amt);
2661           if (reloc_buff == NULL)
2662             goto error_return;
2663
2664           reloc_ptr_ptr = current->orelocation;
2665           reloc_end = reloc_ptr_ptr + current->reloc_count;
2666           out_ptr = (char *) reloc_buff;
2667
2668           for (;
2669                reloc_ptr_ptr < reloc_end;
2670                reloc_ptr_ptr++, out_ptr += external_reloc_size)
2671             {
2672               arelent *reloc;
2673               asymbol *sym;
2674               struct internal_reloc in;
2675
2676               memset ((void *) &in, 0, sizeof in);
2677
2678               reloc = *reloc_ptr_ptr;
2679               sym = *reloc->sym_ptr_ptr;
2680
2681               /* If the howto field has not been initialised then skip this reloc.
2682                  This assumes that an error message has been issued elsewhere.  */
2683               if (reloc->howto == NULL)
2684                 continue;
2685
2686               in.r_vaddr = (reloc->address
2687                             + bfd_get_section_vma (abfd, current));
2688               in.r_type = reloc->howto->type;
2689
2690               if ((sym->flags & BSF_SECTION_SYM) == 0)
2691                 {
2692                   in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr);
2693                   in.r_extern = 1;
2694                 }
2695               else
2696                 {
2697                   const char *name;
2698                   unsigned int j;
2699                   static struct
2700                   {
2701                     const char * name;
2702                     long r_symndx;
2703                   }
2704                   section_symndx [] =
2705                   {
2706                     { _TEXT,   RELOC_SECTION_TEXT   },
2707                     { _RDATA,  RELOC_SECTION_RDATA  },
2708                     { _DATA,   RELOC_SECTION_DATA   },
2709                     { _SDATA,  RELOC_SECTION_SDATA  },
2710                     { _SBSS,   RELOC_SECTION_SBSS   },
2711                     { _BSS,    RELOC_SECTION_BSS    },
2712                     { _INIT,   RELOC_SECTION_INIT   },
2713                     { _LIT8,   RELOC_SECTION_LIT8   },
2714                     { _LIT4,   RELOC_SECTION_LIT4   },
2715                     { _XDATA,  RELOC_SECTION_XDATA  },
2716                     { _PDATA,  RELOC_SECTION_PDATA  },
2717                     { _FINI,   RELOC_SECTION_FINI   },
2718                     { _LITA,   RELOC_SECTION_LITA   },
2719                     { "*ABS*", RELOC_SECTION_ABS    },
2720                     { _RCONST, RELOC_SECTION_RCONST }
2721                   };
2722
2723                   name = bfd_get_section_name (abfd, bfd_get_section (sym));
2724
2725                   for (j = 0; j < ARRAY_SIZE (section_symndx); j++)
2726                     if (streq (name, section_symndx[j].name))
2727                       {
2728                         in.r_symndx = section_symndx[j].r_symndx;
2729                         break;
2730                       }
2731
2732                   if (j == ARRAY_SIZE (section_symndx))
2733                     abort ();
2734                   in.r_extern = 0;
2735                 }
2736
2737               (*adjust_reloc_out) (abfd, reloc, &in);
2738
2739               (*swap_reloc_out) (abfd, &in, (void *) out_ptr);
2740             }
2741
2742           if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0)
2743             goto error_return;
2744           amt = current->reloc_count * external_reloc_size;
2745           if (bfd_bwrite (reloc_buff, amt, abfd) != amt)
2746             goto error_return;
2747           bfd_release (abfd, reloc_buff);
2748           reloc_buff = NULL;
2749         }
2750
2751       /* Write out the symbolic debugging information.  */
2752       if (bfd_get_symcount (abfd) > 0)
2753         {
2754           /* Write out the debugging information.  */
2755           if (! bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap,
2756                                        ecoff_data (abfd)->sym_filepos))
2757             goto error_return;
2758         }
2759     }
2760
2761   /* The .bss section of a demand paged executable must receive an
2762      entire page.  If there are symbols, the symbols will start on the
2763      next page.  If there are no symbols, we must fill out the page by
2764      hand.  */
2765   if (bfd_get_symcount (abfd) == 0
2766       && (abfd->flags & EXEC_P) != 0
2767       && (abfd->flags & D_PAGED) != 0)
2768     {
2769       char c;
2770
2771       if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2772                     SEEK_SET) != 0)
2773         goto error_return;
2774       if (bfd_bread (&c, (bfd_size_type) 1, abfd) == 0)
2775         c = 0;
2776       if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2777                     SEEK_SET) != 0)
2778         goto error_return;
2779       if (bfd_bwrite (&c, (bfd_size_type) 1, abfd) != 1)
2780         goto error_return;
2781     }
2782
2783   if (reloc_buff != NULL)
2784     bfd_release (abfd, reloc_buff);
2785   if (buff != NULL)
2786     free (buff);
2787   return TRUE;
2788  error_return:
2789   if (reloc_buff != NULL)
2790     bfd_release (abfd, reloc_buff);
2791   if (buff != NULL)
2792     free (buff);
2793   return FALSE;
2794 }
2795 \f
2796 /* Archive handling.  ECOFF uses what appears to be a unique type of
2797    archive header (armap).  The byte ordering of the armap and the
2798    contents are encoded in the name of the armap itself.  At least for
2799    now, we only support archives with the same byte ordering in the
2800    armap and the contents.
2801
2802    The first four bytes in the armap are the number of symbol
2803    definitions.  This is always a power of two.
2804
2805    This is followed by the symbol definitions.  Each symbol definition
2806    occupies 8 bytes.  The first four bytes are the offset from the
2807    start of the armap strings to the null-terminated string naming
2808    this symbol.  The second four bytes are the file offset to the
2809    archive member which defines this symbol.  If the second four bytes
2810    are 0, then this is not actually a symbol definition, and it should
2811    be ignored.
2812
2813    The symbols are hashed into the armap with a closed hashing scheme.
2814    See the functions below for the details of the algorithm.
2815
2816    After the symbol definitions comes four bytes holding the size of
2817    the string table, followed by the string table itself.  */
2818
2819 /* The name of an archive headers looks like this:
2820    __________E[BL]E[BL]_ (with a trailing space).
2821    The trailing space is changed to an X if the archive is changed to
2822    indicate that the armap is out of date.
2823
2824    The Alpha seems to use ________64E[BL]E[BL]_.  */
2825
2826 #define ARMAP_BIG_ENDIAN                'B'
2827 #define ARMAP_LITTLE_ENDIAN             'L'
2828 #define ARMAP_MARKER                    'E'
2829 #define ARMAP_START_LENGTH              10
2830 #define ARMAP_HEADER_MARKER_INDEX       10
2831 #define ARMAP_HEADER_ENDIAN_INDEX       11
2832 #define ARMAP_OBJECT_MARKER_INDEX       12
2833 #define ARMAP_OBJECT_ENDIAN_INDEX       13
2834 #define ARMAP_END_INDEX                 14
2835 #define ARMAP_END                       "_ "
2836
2837 /* This is a magic number used in the hashing algorithm.  */
2838 #define ARMAP_HASH_MAGIC                0x9dd68ab5
2839
2840 /* This returns the hash value to use for a string.  It also sets
2841    *REHASH to the rehash adjustment if the first slot is taken.  SIZE
2842    is the number of entries in the hash table, and HLOG is the log
2843    base 2 of SIZE.  */
2844
2845 static unsigned int
2846 ecoff_armap_hash (const char *s,
2847                   unsigned int *rehash,
2848                   unsigned int size,
2849                   unsigned int hlog)
2850 {
2851   unsigned int hash;
2852
2853   if (hlog == 0)
2854     return 0;
2855   hash = *s++;
2856   while (*s != '\0')
2857     hash = ((hash >> 27) | (hash << 5)) + *s++;
2858   hash *= ARMAP_HASH_MAGIC;
2859   *rehash = (hash & (size - 1)) | 1;
2860   return hash >> (32 - hlog);
2861 }
2862
2863 /* Read in the armap.  */
2864
2865 bfd_boolean
2866 _bfd_ecoff_slurp_armap (bfd *abfd)
2867 {
2868   char nextname[17];
2869   unsigned int i;
2870   struct areltdata *mapdata;
2871   bfd_size_type parsed_size;
2872   char *raw_armap;
2873   struct artdata *ardata;
2874   unsigned int count;
2875   char *raw_ptr;
2876   carsym *symdef_ptr;
2877   char *stringbase;
2878   bfd_size_type amt;
2879
2880   /* Get the name of the first element.  */
2881   i = bfd_bread ((void *) nextname, (bfd_size_type) 16, abfd);
2882   if (i == 0)
2883       return TRUE;
2884   if (i != 16)
2885       return FALSE;
2886
2887   if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
2888     return FALSE;
2889
2890   /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2891      standard COFF armap.  We could move the ECOFF armap stuff into
2892      bfd_slurp_armap, but that seems inappropriate since no other
2893      target uses this format.  Instead, we check directly for a COFF
2894      armap.  */
2895   if (CONST_STRNEQ (nextname, "/               "))
2896     return bfd_slurp_armap (abfd);
2897
2898   /* See if the first element is an armap.  */
2899   if (! strneq (nextname, ecoff_backend (abfd)->armap_start, ARMAP_START_LENGTH)
2900       || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER
2901       || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2902           && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2903       || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER
2904       || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2905           && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2906       || ! strneq (nextname + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1))
2907     {
2908       bfd_has_map (abfd) = FALSE;
2909       return TRUE;
2910     }
2911
2912   /* Make sure we have the right byte ordering.  */
2913   if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2914        ^ (bfd_header_big_endian (abfd)))
2915       || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2916           ^ (bfd_big_endian (abfd))))
2917     {
2918       bfd_set_error (bfd_error_wrong_format);
2919       return FALSE;
2920     }
2921
2922   /* Read in the armap.  */
2923   ardata = bfd_ardata (abfd);
2924   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
2925   if (mapdata == NULL)
2926     return FALSE;
2927   parsed_size = mapdata->parsed_size;
2928   free (mapdata);
2929
2930   raw_armap = (char *) bfd_alloc (abfd, parsed_size);
2931   if (raw_armap == NULL)
2932     return FALSE;
2933
2934   if (bfd_bread ((void *) raw_armap, parsed_size, abfd) != parsed_size)
2935     {
2936       if (bfd_get_error () != bfd_error_system_call)
2937         bfd_set_error (bfd_error_malformed_archive);
2938       bfd_release (abfd, (void *) raw_armap);
2939       return FALSE;
2940     }
2941
2942   ardata->tdata = (void *) raw_armap;
2943
2944   count = H_GET_32 (abfd, raw_armap);
2945
2946   ardata->symdef_count = 0;
2947   ardata->cache = NULL;
2948
2949   /* This code used to overlay the symdefs over the raw archive data,
2950      but that doesn't work on a 64 bit host.  */
2951   stringbase = raw_armap + count * 8 + 8;
2952
2953 #ifdef CHECK_ARMAP_HASH
2954   {
2955     unsigned int hlog;
2956
2957     /* Double check that I have the hashing algorithm right by making
2958        sure that every symbol can be looked up successfully.  */
2959     hlog = 0;
2960     for (i = 1; i < count; i <<= 1)
2961       hlog++;
2962     BFD_ASSERT (i == count);
2963
2964     raw_ptr = raw_armap + 4;
2965     for (i = 0; i < count; i++, raw_ptr += 8)
2966       {
2967         unsigned int name_offset, file_offset;
2968         unsigned int hash, rehash, srch;
2969
2970         name_offset = H_GET_32 (abfd, raw_ptr);
2971         file_offset = H_GET_32 (abfd, (raw_ptr + 4));
2972         if (file_offset == 0)
2973           continue;
2974         hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count,
2975                                  hlog);
2976         if (hash == i)
2977           continue;
2978
2979         /* See if we can rehash to this location.  */
2980         for (srch = (hash + rehash) & (count - 1);
2981              srch != hash && srch != i;
2982              srch = (srch + rehash) & (count - 1))
2983           BFD_ASSERT (H_GET_32 (abfd, (raw_armap + 8 + srch * 8)) != 0);
2984         BFD_ASSERT (srch == i);
2985       }
2986   }
2987
2988 #endif /* CHECK_ARMAP_HASH */
2989
2990   raw_ptr = raw_armap + 4;
2991   for (i = 0; i < count; i++, raw_ptr += 8)
2992     if (H_GET_32 (abfd, (raw_ptr + 4)) != 0)
2993       ++ardata->symdef_count;
2994
2995   amt = ardata->symdef_count;
2996   amt *= sizeof (carsym);
2997   symdef_ptr = (carsym *) bfd_alloc (abfd, amt);
2998   if (!symdef_ptr)
2999     return FALSE;
3000
3001   ardata->symdefs = symdef_ptr;
3002
3003   raw_ptr = raw_armap + 4;
3004   for (i = 0; i < count; i++, raw_ptr += 8)
3005     {
3006       unsigned int name_offset, file_offset;
3007
3008       file_offset = H_GET_32 (abfd, (raw_ptr + 4));
3009       if (file_offset == 0)
3010         continue;
3011       name_offset = H_GET_32 (abfd, raw_ptr);
3012       symdef_ptr->name = stringbase + name_offset;
3013       symdef_ptr->file_offset = file_offset;
3014       ++symdef_ptr;
3015     }
3016
3017   ardata->first_file_filepos = bfd_tell (abfd);
3018   /* Pad to an even boundary.  */
3019   ardata->first_file_filepos += ardata->first_file_filepos % 2;
3020
3021   bfd_has_map (abfd) = TRUE;
3022
3023   return TRUE;
3024 }
3025
3026 /* Write out an armap.  */
3027
3028 bfd_boolean
3029 _bfd_ecoff_write_armap (bfd *abfd,
3030                         unsigned int elength,
3031                         struct orl *map,
3032                         unsigned int orl_count,
3033                         int stridx)
3034 {
3035   unsigned int hashsize, hashlog;
3036   bfd_size_type symdefsize;
3037   int padit;
3038   unsigned int stringsize;
3039   unsigned int mapsize;
3040   file_ptr firstreal;
3041   struct ar_hdr hdr;
3042   struct stat statbuf;
3043   unsigned int i;
3044   bfd_byte temp[4];
3045   bfd_byte *hashtable;
3046   bfd *current;
3047   bfd *last_elt;
3048
3049   /* Ultrix appears to use as a hash table size the least power of two
3050      greater than twice the number of entries.  */
3051   for (hashlog = 0; ((unsigned int) 1 << hashlog) <= 2 * orl_count; hashlog++)
3052     ;
3053   hashsize = 1 << hashlog;
3054
3055   symdefsize = hashsize * 8;
3056   padit = stridx % 2;
3057   stringsize = stridx + padit;
3058
3059   /* Include 8 bytes to store symdefsize and stringsize in output.  */
3060   mapsize = symdefsize + stringsize + 8;
3061
3062   firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength;
3063
3064   memset ((void *) &hdr, 0, sizeof hdr);
3065
3066   /* Work out the ECOFF armap name.  */
3067   strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start);
3068   hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER;
3069   hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] =
3070     (bfd_header_big_endian (abfd)
3071      ? ARMAP_BIG_ENDIAN
3072      : ARMAP_LITTLE_ENDIAN);
3073   hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER;
3074   hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] =
3075     bfd_big_endian (abfd) ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN;
3076   memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1);
3077
3078   /* Write the timestamp of the archive header to be just a little bit
3079      later than the timestamp of the file, otherwise the linker will
3080      complain that the index is out of date.  Actually, the Ultrix
3081      linker just checks the archive name; the GNU linker may check the
3082      date.  */
3083   stat (abfd->filename, &statbuf);
3084   _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
3085                     (long) (statbuf.st_mtime + 60));
3086
3087   /* The DECstation uses zeroes for the uid, gid and mode of the
3088      armap.  */
3089   hdr.ar_uid[0] = '0';
3090   hdr.ar_gid[0] = '0';
3091   /* Building gcc ends up extracting the armap as a file - twice.  */
3092   hdr.ar_mode[0] = '6';
3093   hdr.ar_mode[1] = '4';
3094   hdr.ar_mode[2] = '4';
3095
3096   _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld", mapsize);
3097
3098   hdr.ar_fmag[0] = '`';
3099   hdr.ar_fmag[1] = '\012';
3100
3101   /* Turn all null bytes in the header into spaces.  */
3102   for (i = 0; i < sizeof (struct ar_hdr); i++)
3103    if (((char *) (&hdr))[i] == '\0')
3104      (((char *) (&hdr))[i]) = ' ';
3105
3106   if (bfd_bwrite ((void *) &hdr, (bfd_size_type) sizeof (struct ar_hdr), abfd)
3107       != sizeof (struct ar_hdr))
3108     return FALSE;
3109
3110   H_PUT_32 (abfd, hashsize, temp);
3111   if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4)
3112     return FALSE;
3113
3114   hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize);
3115   if (!hashtable)
3116     return FALSE;
3117
3118   current = abfd->archive_head;
3119   last_elt = current;
3120   for (i = 0; i < orl_count; i++)
3121     {
3122       unsigned int hash, rehash = 0;
3123
3124       /* Advance firstreal to the file position of this archive
3125          element.  */
3126       if (map[i].u.abfd != last_elt)
3127         {
3128           do
3129             {
3130               firstreal += arelt_size (current) + sizeof (struct ar_hdr);
3131               firstreal += firstreal % 2;
3132               current = current->archive_next;
3133             }
3134           while (current != map[i].u.abfd);
3135         }
3136
3137       last_elt = current;
3138
3139       hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog);
3140       if (H_GET_32 (abfd, (hashtable + (hash * 8) + 4)) != 0)
3141         {
3142           unsigned int srch;
3143
3144           /* The desired slot is already taken.  */
3145           for (srch = (hash + rehash) & (hashsize - 1);
3146                srch != hash;
3147                srch = (srch + rehash) & (hashsize - 1))
3148             if (H_GET_32 (abfd, (hashtable + (srch * 8) + 4)) == 0)
3149               break;
3150
3151           BFD_ASSERT (srch != hash);
3152
3153           hash = srch;
3154         }
3155
3156       H_PUT_32 (abfd, map[i].namidx, (hashtable + hash * 8));
3157       H_PUT_32 (abfd, firstreal, (hashtable + hash * 8 + 4));
3158     }
3159
3160   if (bfd_bwrite ((void *) hashtable, symdefsize, abfd) != symdefsize)
3161     return FALSE;
3162
3163   bfd_release (abfd, hashtable);
3164
3165   /* Now write the strings.  */
3166   H_PUT_32 (abfd, stringsize, temp);
3167   if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4)
3168     return FALSE;
3169   for (i = 0; i < orl_count; i++)
3170     {
3171       bfd_size_type len;
3172
3173       len = strlen (*map[i].name) + 1;
3174       if (bfd_bwrite ((void *) (*map[i].name), len, abfd) != len)
3175         return FALSE;
3176     }
3177
3178   /* The spec sez this should be a newline.  But in order to be
3179      bug-compatible for DECstation ar we use a null.  */
3180   if (padit)
3181     {
3182       if (bfd_bwrite ("", (bfd_size_type) 1, abfd) != 1)
3183         return FALSE;
3184     }
3185
3186   return TRUE;
3187 }
3188 \f
3189 /* ECOFF linker code.  */
3190
3191 /* Routine to create an entry in an ECOFF link hash table.  */
3192
3193 static struct bfd_hash_entry *
3194 ecoff_link_hash_newfunc (struct bfd_hash_entry *entry,
3195                          struct bfd_hash_table *table,
3196                          const char *string)
3197 {
3198   struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry;
3199
3200   /* Allocate the structure if it has not already been allocated by a
3201      subclass.  */
3202   if (ret == NULL)
3203     ret = ((struct ecoff_link_hash_entry *)
3204            bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry)));
3205   if (ret == NULL)
3206     return NULL;
3207
3208   /* Call the allocation method of the superclass.  */
3209   ret = ((struct ecoff_link_hash_entry *)
3210          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3211                                  table, string));
3212
3213   if (ret)
3214     {
3215       /* Set local fields.  */
3216       ret->indx = -1;
3217       ret->abfd = NULL;
3218       ret->written = 0;
3219       ret->small = 0;
3220     }
3221   memset ((void *) &ret->esym, 0, sizeof ret->esym);
3222
3223   return (struct bfd_hash_entry *) ret;
3224 }
3225
3226 /* Create an ECOFF link hash table.  */
3227
3228 struct bfd_link_hash_table *
3229 _bfd_ecoff_bfd_link_hash_table_create (bfd *abfd)
3230 {
3231   struct ecoff_link_hash_table *ret;
3232   bfd_size_type amt = sizeof (struct ecoff_link_hash_table);
3233
3234   ret = (struct ecoff_link_hash_table *) bfd_malloc (amt);
3235   if (ret == NULL)
3236     return NULL;
3237   if (!_bfd_link_hash_table_init (&ret->root, abfd,
3238                                   ecoff_link_hash_newfunc,
3239                                   sizeof (struct ecoff_link_hash_entry)))
3240     {
3241       free (ret);
3242       return NULL;
3243     }
3244   return &ret->root;
3245 }
3246
3247 /* Look up an entry in an ECOFF link hash table.  */
3248
3249 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3250   ((struct ecoff_link_hash_entry *) \
3251    bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3252
3253 /* Get the ECOFF link hash table from the info structure.  This is
3254    just a cast.  */
3255
3256 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3257
3258 /* Add the external symbols of an object file to the global linker
3259    hash table.  The external symbols and strings we are passed are
3260    just allocated on the stack, and will be discarded.  We must
3261    explicitly save any information we may need later on in the link.
3262    We do not want to read the external symbol information again.  */
3263
3264 static bfd_boolean
3265 ecoff_link_add_externals (bfd *abfd,
3266                           struct bfd_link_info *info,
3267                           void * external_ext,
3268                           char *ssext)
3269 {
3270   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3271   void (* const swap_ext_in) (bfd *, void *, EXTR *)
3272     = backend->debug_swap.swap_ext_in;
3273   bfd_size_type external_ext_size = backend->debug_swap.external_ext_size;
3274   unsigned long ext_count;
3275   struct bfd_link_hash_entry **sym_hash;
3276   char *ext_ptr;
3277   char *ext_end;
3278   bfd_size_type amt;
3279
3280   ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
3281
3282   amt = ext_count;
3283   amt *= sizeof (struct bfd_link_hash_entry *);
3284   sym_hash = (struct bfd_link_hash_entry **) bfd_alloc (abfd, amt);
3285   if (!sym_hash)
3286     return FALSE;
3287   ecoff_data (abfd)->sym_hashes = (struct ecoff_link_hash_entry **) sym_hash;
3288
3289   ext_ptr = (char *) external_ext;
3290   ext_end = ext_ptr + ext_count * external_ext_size;
3291   for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++)
3292     {
3293       EXTR esym;
3294       bfd_boolean skip;
3295       bfd_vma value;
3296       asection *section;
3297       const char *name;
3298       struct ecoff_link_hash_entry *h;
3299
3300       *sym_hash = NULL;
3301
3302       (*swap_ext_in) (abfd, (void *) ext_ptr, &esym);
3303
3304       /* Skip debugging symbols.  */
3305       skip = FALSE;
3306       switch (esym.asym.st)
3307         {
3308         case stGlobal:
3309         case stStatic:
3310         case stLabel:
3311         case stProc:
3312         case stStaticProc:
3313           break;
3314         default:
3315           skip = TRUE;
3316           break;
3317         }
3318
3319       if (skip)
3320         continue;
3321
3322       /* Get the information for this symbol.  */
3323       value = esym.asym.value;
3324       switch (esym.asym.sc)
3325         {
3326         default:
3327         case scNil:
3328         case scRegister:
3329         case scCdbLocal:
3330         case scBits:
3331         case scCdbSystem:
3332         case scRegImage:
3333         case scInfo:
3334         case scUserStruct:
3335         case scVar:
3336         case scVarRegister:
3337         case scVariant:
3338         case scBasedVar:
3339         case scXData:
3340         case scPData:
3341           section = NULL;
3342           break;
3343         case scText:
3344           section = bfd_make_section_old_way (abfd, _TEXT);
3345           value -= section->vma;
3346           break;
3347         case scData:
3348           section = bfd_make_section_old_way (abfd, _DATA);
3349           value -= section->vma;
3350           break;
3351         case scBss:
3352           section = bfd_make_section_old_way (abfd, _BSS);
3353           value -= section->vma;
3354           break;
3355         case scAbs:
3356           section = bfd_abs_section_ptr;
3357           break;
3358         case scUndefined:
3359           section = bfd_und_section_ptr;
3360           break;
3361         case scSData:
3362           section = bfd_make_section_old_way (abfd, _SDATA);
3363           value -= section->vma;
3364           break;
3365         case scSBss:
3366           section = bfd_make_section_old_way (abfd, _SBSS);
3367           value -= section->vma;
3368           break;
3369         case scRData:
3370           section = bfd_make_section_old_way (abfd, _RDATA);
3371           value -= section->vma;
3372           break;
3373         case scCommon:
3374           if (value > ecoff_data (abfd)->gp_size)
3375             {
3376               section = bfd_com_section_ptr;
3377               break;
3378             }
3379           /* Fall through.  */
3380         case scSCommon:
3381           if (ecoff_scom_section.name == NULL)
3382             {
3383               /* Initialize the small common section.  */
3384               ecoff_scom_section.name = SCOMMON;
3385               ecoff_scom_section.flags = SEC_IS_COMMON;
3386               ecoff_scom_section.output_section = &ecoff_scom_section;
3387               ecoff_scom_section.symbol = &ecoff_scom_symbol;
3388               ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
3389               ecoff_scom_symbol.name = SCOMMON;
3390               ecoff_scom_symbol.flags = BSF_SECTION_SYM;
3391               ecoff_scom_symbol.section = &ecoff_scom_section;
3392               ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
3393             }
3394           section = &ecoff_scom_section;
3395           break;
3396         case scSUndefined:
3397           section = bfd_und_section_ptr;
3398           break;
3399         case scInit:
3400           section = bfd_make_section_old_way (abfd, _INIT);
3401           value -= section->vma;
3402           break;
3403         case scFini:
3404           section = bfd_make_section_old_way (abfd, _FINI);
3405           value -= section->vma;
3406           break;
3407         case scRConst:
3408           section = bfd_make_section_old_way (abfd, _RCONST);
3409           value -= section->vma;
3410           break;
3411         }
3412
3413       if (section == NULL)
3414         continue;
3415
3416       name = ssext + esym.asym.iss;
3417
3418       if (! (_bfd_generic_link_add_one_symbol
3419              (info, abfd, name,
3420               (flagword) (esym.weakext ? BSF_WEAK : BSF_GLOBAL),
3421               section, value, NULL, TRUE, TRUE, sym_hash)))
3422         return FALSE;
3423
3424       h = (struct ecoff_link_hash_entry *) *sym_hash;
3425
3426       /* If we are building an ECOFF hash table, save the external
3427          symbol information.  */
3428       if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd))
3429         {
3430           if (h->abfd == NULL
3431               || (! bfd_is_und_section (section)
3432                   && (! bfd_is_com_section (section)
3433                       || (h->root.type != bfd_link_hash_defined
3434                           && h->root.type != bfd_link_hash_defweak))))
3435             {
3436               h->abfd = abfd;
3437               h->esym = esym;
3438             }
3439
3440           /* Remember whether this symbol was small undefined.  */
3441           if (esym.asym.sc == scSUndefined)
3442             h->small = 1;
3443
3444           /* If this symbol was ever small undefined, it needs to wind
3445              up in a GP relative section.  We can't control the
3446              section of a defined symbol, but we can control the
3447              section of a common symbol.  This case is actually needed
3448              on Ultrix 4.2 to handle the symbol cred in -lckrb.  */
3449           if (h->small
3450               && h->root.type == bfd_link_hash_common
3451               && streq (h->root.u.c.p->section->name, SCOMMON))
3452             {
3453               h->root.u.c.p->section = bfd_make_section_old_way (abfd,
3454                                                                  SCOMMON);
3455               h->root.u.c.p->section->flags = SEC_ALLOC;
3456               if (h->esym.asym.sc == scCommon)
3457                 h->esym.asym.sc = scSCommon;
3458             }
3459         }
3460     }
3461
3462   return TRUE;
3463 }
3464
3465 /* Add symbols from an ECOFF object file to the global linker hash
3466    table.  */
3467
3468 static bfd_boolean
3469 ecoff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3470 {
3471   HDRR *symhdr;
3472   bfd_size_type external_ext_size;
3473   void * external_ext = NULL;
3474   bfd_size_type esize;
3475   char *ssext = NULL;
3476   bfd_boolean result;
3477
3478   if (! ecoff_slurp_symbolic_header (abfd))
3479     return FALSE;
3480
3481   /* If there are no symbols, we don't want it.  */
3482   if (bfd_get_symcount (abfd) == 0)
3483     return TRUE;
3484
3485   symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3486
3487   /* Read in the external symbols and external strings.  */
3488   external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size;
3489   esize = symhdr->iextMax * external_ext_size;
3490   external_ext = bfd_malloc (esize);
3491   if (external_ext == NULL && esize != 0)
3492     goto error_return;
3493
3494   if (bfd_seek (abfd, (file_ptr) symhdr->cbExtOffset, SEEK_SET) != 0
3495       || bfd_bread (external_ext, esize, abfd) != esize)
3496     goto error_return;
3497
3498   ssext = (char *) bfd_malloc ((bfd_size_type) symhdr->issExtMax);
3499   if (ssext == NULL && symhdr->issExtMax != 0)
3500     goto error_return;
3501
3502   if (bfd_seek (abfd, (file_ptr) symhdr->cbSsExtOffset, SEEK_SET) != 0
3503       || (bfd_bread (ssext, (bfd_size_type) symhdr->issExtMax, abfd)
3504           != (bfd_size_type) symhdr->issExtMax))
3505     goto error_return;
3506
3507   result = ecoff_link_add_externals (abfd, info, external_ext, ssext);
3508
3509   if (ssext != NULL)
3510     free (ssext);
3511   if (external_ext != NULL)
3512     free (external_ext);
3513   return result;
3514
3515  error_return:
3516   if (ssext != NULL)
3517     free (ssext);
3518   if (external_ext != NULL)
3519     free (external_ext);
3520   return FALSE;
3521 }
3522
3523 /* This is called if we used _bfd_generic_link_add_archive_symbols
3524    because we were not dealing with an ECOFF archive.  */
3525
3526 static bfd_boolean
3527 ecoff_link_check_archive_element (bfd *abfd,
3528                                   struct bfd_link_info *info,
3529                                   struct bfd_link_hash_entry *h,
3530                                   const char *name,
3531                                   bfd_boolean *pneeded)
3532 {
3533   *pneeded = FALSE;
3534
3535   /* Unlike the generic linker, we do not pull in elements because
3536      of common symbols.  */
3537   if (h->type != bfd_link_hash_undefined)
3538     return TRUE;
3539
3540   /* Include this element?  */
3541   if (!(*info->callbacks->add_archive_element) (info, abfd, name, &abfd))
3542     return TRUE;
3543   *pneeded = TRUE;
3544
3545   return ecoff_link_add_object_symbols (abfd, info);
3546 }
3547
3548 /* Add the symbols from an archive file to the global hash table.
3549    This looks through the undefined symbols, looks each one up in the
3550    archive hash table, and adds any associated object file.  We do not
3551    use _bfd_generic_link_add_archive_symbols because ECOFF archives
3552    already have a hash table, so there is no reason to construct
3553    another one.  */
3554
3555 static bfd_boolean
3556 ecoff_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
3557 {
3558   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3559   const bfd_byte *raw_armap;
3560   struct bfd_link_hash_entry **pundef;
3561   unsigned int armap_count;
3562   unsigned int armap_log;
3563   unsigned int i;
3564   const bfd_byte *hashtable;
3565   const char *stringbase;
3566
3567   if (! bfd_has_map (abfd))
3568     {
3569       /* An empty archive is a special case.  */
3570       if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
3571         return TRUE;
3572       bfd_set_error (bfd_error_no_armap);
3573       return FALSE;
3574     }
3575
3576   /* If we don't have any raw data for this archive, as can happen on
3577      Irix 4.0.5F, we call the generic routine.
3578      FIXME: We should be more clever about this, since someday tdata
3579      may get to something for a generic archive.  */
3580   raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata;
3581   if (raw_armap == NULL)
3582     return (_bfd_generic_link_add_archive_symbols
3583             (abfd, info, ecoff_link_check_archive_element));
3584
3585   armap_count = H_GET_32 (abfd, raw_armap);
3586
3587   armap_log = 0;
3588   for (i = 1; i < armap_count; i <<= 1)
3589     armap_log++;
3590   BFD_ASSERT (i == armap_count);
3591
3592   hashtable = raw_armap + 4;
3593   stringbase = (const char *) raw_armap + armap_count * 8 + 8;
3594
3595   /* Look through the list of undefined symbols.  */
3596   pundef = &info->hash->undefs;
3597   while (*pundef != NULL)
3598     {
3599       struct bfd_link_hash_entry *h;
3600       unsigned int hash, rehash = 0;
3601       unsigned int file_offset;
3602       const char *name;
3603       bfd *element;
3604
3605       h = *pundef;
3606
3607       /* When a symbol is defined, it is not necessarily removed from
3608          the list.  */
3609       if (h->type != bfd_link_hash_undefined
3610           && h->type != bfd_link_hash_common)
3611         {
3612           /* Remove this entry from the list, for general cleanliness
3613              and because we are going to look through the list again
3614              if we search any more libraries.  We can't remove the
3615              entry if it is the tail, because that would lose any
3616              entries we add to the list later on.  */
3617           if (*pundef != info->hash->undefs_tail)
3618             *pundef = (*pundef)->u.undef.next;
3619           else
3620             pundef = &(*pundef)->u.undef.next;
3621           continue;
3622         }
3623
3624       /* Native ECOFF linkers do not pull in archive elements merely
3625          to satisfy common definitions, so neither do we.  We leave
3626          them on the list, though, in case we are linking against some
3627          other object format.  */
3628       if (h->type != bfd_link_hash_undefined)
3629         {
3630           pundef = &(*pundef)->u.undef.next;
3631           continue;
3632         }
3633
3634       /* Look for this symbol in the archive hash table.  */
3635       hash = ecoff_armap_hash (h->root.string, &rehash, armap_count,
3636                                armap_log);
3637
3638       file_offset = H_GET_32 (abfd, hashtable + (hash * 8) + 4);
3639       if (file_offset == 0)
3640         {
3641           /* Nothing in this slot.  */
3642           pundef = &(*pundef)->u.undef.next;
3643           continue;
3644         }
3645
3646       name = stringbase + H_GET_32 (abfd, hashtable + (hash * 8));
3647       if (name[0] != h->root.string[0]
3648           || ! streq (name, h->root.string))
3649         {
3650           unsigned int srch;
3651           bfd_boolean found;
3652
3653           /* That was the wrong symbol.  Try rehashing.  */
3654           found = FALSE;
3655           for (srch = (hash + rehash) & (armap_count - 1);
3656                srch != hash;
3657                srch = (srch + rehash) & (armap_count - 1))
3658             {
3659               file_offset = H_GET_32 (abfd, hashtable + (srch * 8) + 4);
3660               if (file_offset == 0)
3661                 break;
3662               name = stringbase + H_GET_32 (abfd, hashtable + (srch * 8));
3663               if (name[0] == h->root.string[0]
3664                   && streq (name, h->root.string))
3665                 {
3666                   found = TRUE;
3667                   break;
3668                 }
3669             }
3670
3671           if (! found)
3672             {
3673               pundef = &(*pundef)->u.undef.next;
3674               continue;
3675             }
3676
3677           hash = srch;
3678         }
3679
3680       element = (*backend->get_elt_at_filepos) (abfd, (file_ptr) file_offset);
3681       if (element == NULL)
3682         return FALSE;
3683
3684       if (! bfd_check_format (element, bfd_object))
3685         return FALSE;
3686
3687       /* Unlike the generic linker, we know that this element provides
3688          a definition for an undefined symbol and we know that we want
3689          to include it.  We don't need to check anything.  */
3690       if (!(*info->callbacks
3691             ->add_archive_element) (info, element, name, &element))
3692         return FALSE;
3693       if (! ecoff_link_add_object_symbols (element, info))
3694         return FALSE;
3695
3696       pundef = &(*pundef)->u.undef.next;
3697     }
3698
3699   return TRUE;
3700 }
3701
3702 /* Given an ECOFF BFD, add symbols to the global hash table as
3703    appropriate.  */
3704
3705 bfd_boolean
3706 _bfd_ecoff_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
3707 {
3708   switch (bfd_get_format (abfd))
3709     {
3710     case bfd_object:
3711       return ecoff_link_add_object_symbols (abfd, info);
3712     case bfd_archive:
3713       return ecoff_link_add_archive_symbols (abfd, info);
3714     default:
3715       bfd_set_error (bfd_error_wrong_format);
3716       return FALSE;
3717     }
3718 }
3719
3720 \f
3721 /* ECOFF final link routines.  */
3722
3723 /* Structure used to pass information to ecoff_link_write_external.  */
3724
3725 struct extsym_info
3726 {
3727   bfd *abfd;
3728   struct bfd_link_info *info;
3729 };
3730
3731 /* Accumulate the debugging information for an input BFD into the
3732    output BFD.  This must read in the symbolic information of the
3733    input BFD.  */
3734
3735 static bfd_boolean
3736 ecoff_final_link_debug_accumulate (bfd *output_bfd,
3737                                    bfd *input_bfd,
3738                                    struct bfd_link_info *info,
3739                                    void * handle)
3740 {
3741   struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info;
3742   const struct ecoff_debug_swap * const swap =
3743     &ecoff_backend (input_bfd)->debug_swap;
3744   HDRR *symhdr = &debug->symbolic_header;
3745   bfd_boolean ret;
3746
3747 #define READ(ptr, offset, count, size, type)                             \
3748   if (symhdr->count == 0)                                                \
3749     debug->ptr = NULL;                                                   \
3750   else                                                                   \
3751     {                                                                    \
3752       bfd_size_type amt = (bfd_size_type) size * symhdr->count;          \
3753       debug->ptr = (type) bfd_malloc (amt);                              \
3754       if (debug->ptr == NULL)                                            \
3755         {                                                                \
3756           ret = FALSE;                                                   \
3757           goto return_something;                                         \
3758         }                                                                \
3759       if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3760           || bfd_bread (debug->ptr, amt, input_bfd) != amt)              \
3761         {                                                                \
3762           ret = FALSE;                                                   \
3763           goto return_something;                                         \
3764         }                                                                \
3765     }
3766
3767   /* If raw_syments is not NULL, then the data was already by read by
3768      _bfd_ecoff_slurp_symbolic_info.  */
3769   if (ecoff_data (input_bfd)->raw_syments == NULL)
3770     {
3771       READ (line, cbLineOffset, cbLine, sizeof (unsigned char),
3772             unsigned char *);
3773       READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
3774       READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
3775       READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
3776       READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
3777       READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
3778             union aux_ext *);
3779       READ (ss, cbSsOffset, issMax, sizeof (char), char *);
3780       READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
3781       READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
3782     }
3783 #undef READ
3784
3785   /* We do not read the external strings or the external symbols.  */
3786
3787   ret = (bfd_ecoff_debug_accumulate
3788          (handle, output_bfd, &ecoff_data (output_bfd)->debug_info,
3789           &ecoff_backend (output_bfd)->debug_swap,
3790           input_bfd, debug, swap, info));
3791
3792  return_something:
3793   if (ecoff_data (input_bfd)->raw_syments == NULL)
3794     {
3795       if (debug->line != NULL)
3796         free (debug->line);
3797       if (debug->external_dnr != NULL)
3798         free (debug->external_dnr);
3799       if (debug->external_pdr != NULL)
3800         free (debug->external_pdr);
3801       if (debug->external_sym != NULL)
3802         free (debug->external_sym);
3803       if (debug->external_opt != NULL)
3804         free (debug->external_opt);
3805       if (debug->external_aux != NULL)
3806         free (debug->external_aux);
3807       if (debug->ss != NULL)
3808         free (debug->ss);
3809       if (debug->external_fdr != NULL)
3810         free (debug->external_fdr);
3811       if (debug->external_rfd != NULL)
3812         free (debug->external_rfd);
3813
3814       /* Make sure we don't accidentally follow one of these pointers
3815          into freed memory.  */
3816       debug->line = NULL;
3817       debug->external_dnr = NULL;
3818       debug->external_pdr = NULL;
3819       debug->external_sym = NULL;
3820       debug->external_opt = NULL;
3821       debug->external_aux = NULL;
3822       debug->ss = NULL;
3823       debug->external_fdr = NULL;
3824       debug->external_rfd = NULL;
3825     }
3826
3827   return ret;
3828 }
3829
3830 /* Relocate and write an ECOFF section into an ECOFF output file.  */
3831
3832 static bfd_boolean
3833 ecoff_indirect_link_order (bfd *output_bfd,
3834                            struct bfd_link_info *info,
3835                            asection *output_section,
3836                            struct bfd_link_order *link_order)
3837 {
3838   asection *input_section;
3839   bfd *input_bfd;
3840   bfd_byte *contents = NULL;
3841   bfd_size_type external_reloc_size;
3842   bfd_size_type external_relocs_size;
3843   void * external_relocs = NULL;
3844
3845   BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
3846
3847   input_section = link_order->u.indirect.section;
3848   input_bfd = input_section->owner;
3849   if (input_section->size == 0)
3850     return TRUE;
3851
3852   BFD_ASSERT (input_section->output_section == output_section);
3853   BFD_ASSERT (input_section->output_offset == link_order->offset);
3854   BFD_ASSERT (input_section->size == link_order->size);
3855
3856   /* Get the section contents.  */
3857   if (!bfd_malloc_and_get_section (input_bfd, input_section, &contents))
3858     goto error_return;
3859
3860   /* Get the relocs.  If we are relaxing MIPS code, they will already
3861      have been read in.  Otherwise, we read them in now.  */
3862   external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size;
3863   external_relocs_size = external_reloc_size * input_section->reloc_count;
3864
3865   external_relocs = bfd_malloc (external_relocs_size);
3866   if (external_relocs == NULL && external_relocs_size != 0)
3867     goto error_return;
3868
3869   if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
3870       || (bfd_bread (external_relocs, external_relocs_size, input_bfd)
3871           != external_relocs_size))
3872     goto error_return;
3873
3874   /* Relocate the section contents.  */
3875   if (! ((*ecoff_backend (input_bfd)->relocate_section)
3876          (output_bfd, info, input_bfd, input_section, contents,
3877           external_relocs)))
3878     goto error_return;
3879
3880   /* Write out the relocated section.  */
3881   if (! bfd_set_section_contents (output_bfd,
3882                                   output_section,
3883                                   contents,
3884                                   input_section->output_offset,
3885                                   input_section->size))
3886     goto error_return;
3887
3888   /* If we are producing relocatable output, the relocs were
3889      modified, and we write them out now.  We use the reloc_count
3890      field of output_section to keep track of the number of relocs we
3891      have output so far.  */
3892   if (bfd_link_relocatable (info))
3893     {
3894       file_ptr pos = (output_section->rel_filepos
3895                       + output_section->reloc_count * external_reloc_size);
3896       if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
3897           || (bfd_bwrite (external_relocs, external_relocs_size, output_bfd)
3898               != external_relocs_size))
3899         goto error_return;
3900       output_section->reloc_count += input_section->reloc_count;
3901     }
3902
3903   if (contents != NULL)
3904     free (contents);
3905   if (external_relocs != NULL)
3906     free (external_relocs);
3907   return TRUE;
3908
3909  error_return:
3910   if (contents != NULL)
3911     free (contents);
3912   if (external_relocs != NULL)
3913     free (external_relocs);
3914   return FALSE;
3915 }
3916
3917 /* Generate a reloc when linking an ECOFF file.  This is a reloc
3918    requested by the linker, and does come from any input file.  This
3919    is used to build constructor and destructor tables when linking
3920    with -Ur.  */
3921
3922 static bfd_boolean
3923 ecoff_reloc_link_order (bfd *output_bfd,
3924                         struct bfd_link_info *info,
3925                         asection *output_section,
3926                         struct bfd_link_order *link_order)
3927 {
3928   enum bfd_link_order_type type;
3929   asection *section;
3930   bfd_vma addend;
3931   arelent rel;
3932   struct internal_reloc in;
3933   bfd_size_type external_reloc_size;
3934   bfd_byte *rbuf;
3935   bfd_boolean ok;
3936   file_ptr pos;
3937
3938   type = link_order->type;
3939   section = NULL;
3940   addend = link_order->u.reloc.p->addend;
3941
3942   /* We set up an arelent to pass to the backend adjust_reloc_out
3943      routine.  */
3944   rel.address = link_order->offset;
3945
3946   rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
3947   if (rel.howto == 0)
3948     {
3949       bfd_set_error (bfd_error_bad_value);
3950       return FALSE;
3951     }
3952
3953   if (type == bfd_section_reloc_link_order)
3954     {
3955       section = link_order->u.reloc.p->u.section;
3956       rel.sym_ptr_ptr = section->symbol_ptr_ptr;
3957     }
3958   else
3959     {
3960       struct bfd_link_hash_entry *h;
3961
3962       /* Treat a reloc against a defined symbol as though it were
3963          actually against the section.  */
3964       h = bfd_wrapped_link_hash_lookup (output_bfd, info,
3965                                         link_order->u.reloc.p->u.name,
3966                                         FALSE, FALSE, FALSE);
3967       if (h != NULL
3968           && (h->type == bfd_link_hash_defined
3969               || h->type == bfd_link_hash_defweak))
3970         {
3971           type = bfd_section_reloc_link_order;
3972           section = h->u.def.section->output_section;
3973           /* It seems that we ought to add the symbol value to the
3974              addend here, but in practice it has already been added
3975              because it was passed to constructor_callback.  */
3976           addend += section->vma + h->u.def.section->output_offset;
3977         }
3978       else
3979         {
3980           /* We can't set up a reloc against a symbol correctly,
3981              because we have no asymbol structure.  Currently no
3982              adjust_reloc_out routine cares.  */
3983           rel.sym_ptr_ptr = NULL;
3984         }
3985     }
3986
3987   /* All ECOFF relocs are in-place.  Put the addend into the object
3988      file.  */
3989
3990   BFD_ASSERT (rel.howto->partial_inplace);
3991   if (addend != 0)
3992     {
3993       bfd_size_type size;
3994       bfd_reloc_status_type rstat;
3995       bfd_byte *buf;
3996
3997       size = bfd_get_reloc_size (rel.howto);
3998       buf = (bfd_byte *) bfd_zmalloc (size);
3999       if (buf == NULL && size != 0)
4000         return FALSE;
4001       rstat = _bfd_relocate_contents (rel.howto, output_bfd,
4002                                       (bfd_vma) addend, buf);
4003       switch (rstat)
4004         {
4005         case bfd_reloc_ok:
4006           break;
4007         default:
4008         case bfd_reloc_outofrange:
4009           abort ();
4010         case bfd_reloc_overflow:
4011           (*info->callbacks->reloc_overflow)
4012             (info, NULL,
4013              (link_order->type == bfd_section_reloc_link_order
4014               ? bfd_section_name (output_bfd, section)
4015               : link_order->u.reloc.p->u.name),
4016              rel.howto->name, addend, NULL, NULL, (bfd_vma) 0);
4017           break;
4018         }
4019       ok = bfd_set_section_contents (output_bfd, output_section, (void *) buf,
4020                                      (file_ptr) link_order->offset, size);
4021       free (buf);
4022       if (! ok)
4023         return FALSE;
4024     }
4025
4026   rel.addend = 0;
4027
4028   /* Move the information into an internal_reloc structure.  */
4029   in.r_vaddr = (rel.address
4030                 + bfd_get_section_vma (output_bfd, output_section));
4031   in.r_type = rel.howto->type;
4032
4033   if (type == bfd_symbol_reloc_link_order)
4034     {
4035       struct ecoff_link_hash_entry *h;
4036
4037       h = ((struct ecoff_link_hash_entry *)
4038            bfd_wrapped_link_hash_lookup (output_bfd, info,
4039                                          link_order->u.reloc.p->u.name,
4040                                          FALSE, FALSE, TRUE));
4041       if (h != NULL
4042           && h->indx != -1)
4043         in.r_symndx = h->indx;
4044       else
4045         {
4046           (*info->callbacks->unattached_reloc)
4047             (info, link_order->u.reloc.p->u.name, NULL, NULL, (bfd_vma) 0);
4048           in.r_symndx = 0;
4049         }
4050       in.r_extern = 1;
4051     }
4052   else
4053     {
4054       const char *name;
4055       unsigned int i;
4056       static struct
4057       {
4058         const char * name;
4059         long r_symndx;
4060       }
4061       section_symndx [] =
4062       {
4063         { _TEXT,   RELOC_SECTION_TEXT   },
4064         { _RDATA,  RELOC_SECTION_RDATA  },
4065         { _DATA,   RELOC_SECTION_DATA   },
4066         { _SDATA,  RELOC_SECTION_SDATA  },
4067         { _SBSS,   RELOC_SECTION_SBSS   },
4068         { _BSS,    RELOC_SECTION_BSS    },
4069         { _INIT,   RELOC_SECTION_INIT   },
4070         { _LIT8,   RELOC_SECTION_LIT8   },
4071         { _LIT4,   RELOC_SECTION_LIT4   },
4072         { _XDATA,  RELOC_SECTION_XDATA  },
4073         { _PDATA,  RELOC_SECTION_PDATA  },
4074         { _FINI,   RELOC_SECTION_FINI   },
4075         { _LITA,   RELOC_SECTION_LITA   },
4076         { "*ABS*", RELOC_SECTION_ABS    },
4077         { _RCONST, RELOC_SECTION_RCONST }
4078       };
4079
4080       name = bfd_get_section_name (output_bfd, section);
4081
4082       for (i = 0; i < ARRAY_SIZE (section_symndx); i++)
4083         if (streq (name, section_symndx[i].name))
4084           {
4085             in.r_symndx = section_symndx[i].r_symndx;
4086             break;
4087           }
4088
4089       if (i == ARRAY_SIZE (section_symndx))
4090         abort ();
4091
4092       in.r_extern = 0;
4093     }
4094
4095   /* Let the BFD backend adjust the reloc.  */
4096   (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in);
4097
4098   /* Get some memory and swap out the reloc.  */
4099   external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
4100   rbuf = (bfd_byte *) bfd_malloc (external_reloc_size);
4101   if (rbuf == NULL)
4102     return FALSE;
4103
4104   (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (void *) rbuf);
4105
4106   pos = (output_section->rel_filepos
4107          + output_section->reloc_count * external_reloc_size);
4108   ok = (bfd_seek (output_bfd, pos, SEEK_SET) == 0
4109         && (bfd_bwrite ((void *) rbuf, external_reloc_size, output_bfd)
4110             == external_reloc_size));
4111
4112   if (ok)
4113     ++output_section->reloc_count;
4114
4115   free (rbuf);
4116
4117   return ok;
4118 }
4119
4120 /* Put out information for an external symbol.  These come only from
4121    the hash table.  */
4122
4123 static bfd_boolean
4124 ecoff_link_write_external (struct bfd_hash_entry *bh, void * data)
4125 {
4126   struct ecoff_link_hash_entry *h = (struct ecoff_link_hash_entry *) bh;
4127   struct extsym_info *einfo = (struct extsym_info *) data;
4128   bfd *output_bfd = einfo->abfd;
4129   bfd_boolean strip;
4130
4131   if (h->root.type == bfd_link_hash_warning)
4132     {
4133       h = (struct ecoff_link_hash_entry *) h->root.u.i.link;
4134       if (h->root.type == bfd_link_hash_new)
4135         return TRUE;
4136     }
4137
4138   /* We need to check if this symbol is being stripped.  */
4139   if (h->root.type == bfd_link_hash_undefined
4140       || h->root.type == bfd_link_hash_undefweak)
4141     strip = FALSE;
4142   else if (einfo->info->strip == strip_all
4143            || (einfo->info->strip == strip_some
4144                && bfd_hash_lookup (einfo->info->keep_hash,
4145                                    h->root.root.string,
4146                                    FALSE, FALSE) == NULL))
4147     strip = TRUE;
4148   else
4149     strip = FALSE;
4150
4151   if (strip || h->written)
4152     return TRUE;
4153
4154   if (h->abfd == NULL)
4155     {
4156       h->esym.jmptbl = 0;
4157       h->esym.cobol_main = 0;
4158       h->esym.weakext = 0;
4159       h->esym.reserved = 0;
4160       h->esym.ifd = ifdNil;
4161       h->esym.asym.value = 0;
4162       h->esym.asym.st = stGlobal;
4163
4164       if (h->root.type != bfd_link_hash_defined
4165           && h->root.type != bfd_link_hash_defweak)
4166         h->esym.asym.sc = scAbs;
4167       else
4168         {
4169           asection *output_section;
4170           const char *name;
4171           unsigned int i;
4172           static struct
4173           {
4174             const char * name;
4175             int sc;
4176           }
4177           section_storage_classes [] =
4178           {
4179             { _TEXT,   scText   },
4180             { _DATA,   scData   },
4181             { _SDATA,  scSData  },
4182             { _RDATA,  scRData  },
4183             { _BSS,    scBss    },
4184             { _SBSS,   scSBss   },
4185             { _INIT,   scInit   },
4186             { _FINI,   scFini   },
4187             { _PDATA,  scPData  },
4188             { _XDATA,  scXData  },
4189             { _RCONST, scRConst }
4190           };
4191
4192           output_section = h->root.u.def.section->output_section;
4193           name = bfd_section_name (output_section->owner, output_section);
4194
4195           for (i = 0; i < ARRAY_SIZE (section_storage_classes); i++)
4196             if (streq (name, section_storage_classes[i].name))
4197               {
4198                 h->esym.asym.sc = section_storage_classes[i].sc;
4199                 break;
4200               }
4201
4202           if (i == ARRAY_SIZE (section_storage_classes))
4203             h->esym.asym.sc = scAbs;
4204         }
4205
4206       h->esym.asym.reserved = 0;
4207       h->esym.asym.index = indexNil;
4208     }
4209   else if (h->esym.ifd != -1)
4210     {
4211       struct ecoff_debug_info *debug;
4212
4213       /* Adjust the FDR index for the symbol by that used for the
4214          input BFD.  */
4215       debug = &ecoff_data (h->abfd)->debug_info;
4216       BFD_ASSERT (h->esym.ifd >= 0
4217                   && h->esym.ifd < debug->symbolic_header.ifdMax);
4218       h->esym.ifd = debug->ifdmap[h->esym.ifd];
4219     }
4220
4221   switch (h->root.type)
4222     {
4223     default:
4224     case bfd_link_hash_warning:
4225     case bfd_link_hash_new:
4226       abort ();
4227     case bfd_link_hash_undefined:
4228     case bfd_link_hash_undefweak:
4229       if (h->esym.asym.sc != scUndefined
4230           && h->esym.asym.sc != scSUndefined)
4231         h->esym.asym.sc = scUndefined;
4232       break;
4233     case bfd_link_hash_defined:
4234     case bfd_link_hash_defweak:
4235       if (h->esym.asym.sc == scUndefined
4236           || h->esym.asym.sc == scSUndefined)
4237         h->esym.asym.sc = scAbs;
4238       else if (h->esym.asym.sc == scCommon)
4239         h->esym.asym.sc = scBss;
4240       else if (h->esym.asym.sc == scSCommon)
4241         h->esym.asym.sc = scSBss;
4242       h->esym.asym.value = (h->root.u.def.value
4243                             + h->root.u.def.section->output_section->vma
4244                             + h->root.u.def.section->output_offset);
4245       break;
4246     case bfd_link_hash_common:
4247       if (h->esym.asym.sc != scCommon
4248           && h->esym.asym.sc != scSCommon)
4249         h->esym.asym.sc = scCommon;
4250       h->esym.asym.value = h->root.u.c.size;
4251       break;
4252     case bfd_link_hash_indirect:
4253       /* We ignore these symbols, since the indirected symbol is
4254          already in the hash table.  */
4255       return TRUE;
4256     }
4257
4258   /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4259      symbol number.  */
4260   h->indx = ecoff_data (output_bfd)->debug_info.symbolic_header.iextMax;
4261   h->written = 1;
4262
4263   return (bfd_ecoff_debug_one_external
4264           (output_bfd, &ecoff_data (output_bfd)->debug_info,
4265            &ecoff_backend (output_bfd)->debug_swap, h->root.root.string,
4266            &h->esym));
4267 }
4268
4269 /* ECOFF final link routine.  This looks through all the input BFDs
4270    and gathers together all the debugging information, and then
4271    processes all the link order information.  This may cause it to
4272    close and reopen some input BFDs; I'll see how bad this is.  */
4273
4274 bfd_boolean
4275 _bfd_ecoff_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
4276 {
4277   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
4278   struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
4279   HDRR *symhdr;
4280   void * handle;
4281   bfd *input_bfd;
4282   asection *o;
4283   struct bfd_link_order *p;
4284   struct extsym_info einfo;
4285
4286   /* We accumulate the debugging information counts in the symbolic
4287      header.  */
4288   symhdr = &debug->symbolic_header;
4289   symhdr->vstamp = 0;
4290   symhdr->ilineMax = 0;
4291   symhdr->cbLine = 0;
4292   symhdr->idnMax = 0;
4293   symhdr->ipdMax = 0;
4294   symhdr->isymMax = 0;
4295   symhdr->ioptMax = 0;
4296   symhdr->iauxMax = 0;
4297   symhdr->issMax = 0;
4298   symhdr->issExtMax = 0;
4299   symhdr->ifdMax = 0;
4300   symhdr->crfd = 0;
4301   symhdr->iextMax = 0;
4302
4303   /* We accumulate the debugging information itself in the debug_info
4304      structure.  */
4305   debug->line = NULL;
4306   debug->external_dnr = NULL;
4307   debug->external_pdr = NULL;
4308   debug->external_sym = NULL;
4309   debug->external_opt = NULL;
4310   debug->external_aux = NULL;
4311   debug->ss = NULL;
4312   debug->ssext = debug->ssext_end = NULL;
4313   debug->external_fdr = NULL;
4314   debug->external_rfd = NULL;
4315   debug->external_ext = debug->external_ext_end = NULL;
4316
4317   handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info);
4318   if (handle == NULL)
4319     return FALSE;
4320
4321   /* Accumulate the debugging symbols from each input BFD.  */
4322   for (input_bfd = info->input_bfds;
4323        input_bfd != NULL;
4324        input_bfd = input_bfd->link.next)
4325     {
4326       bfd_boolean ret;
4327
4328       if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour)
4329         {
4330           /* Arbitrarily set the symbolic header vstamp to the vstamp
4331              of the first object file in the link.  */
4332           if (symhdr->vstamp == 0)
4333             symhdr->vstamp
4334               = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp;
4335           ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info,
4336                                                    handle);
4337         }
4338       else
4339         ret = bfd_ecoff_debug_accumulate_other (handle, abfd,
4340                                                 debug, &backend->debug_swap,
4341                                                 input_bfd, info);
4342       if (! ret)
4343         return FALSE;
4344
4345       /* Combine the register masks.  */
4346       ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask;
4347       ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask;
4348       ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0];
4349       ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1];
4350       ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2];
4351       ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3];
4352     }
4353
4354   /* Write out the external symbols.  */
4355   einfo.abfd = abfd;
4356   einfo.info = info;
4357   bfd_hash_traverse (&info->hash->table, ecoff_link_write_external, &einfo);
4358
4359   if (bfd_link_relocatable (info))
4360     {
4361       /* We need to make a pass over the link_orders to count up the
4362          number of relocations we will need to output, so that we know
4363          how much space they will take up.  */
4364       for (o = abfd->sections; o != NULL; o = o->next)
4365         {
4366           o->reloc_count = 0;
4367           for (p = o->map_head.link_order;
4368                p != NULL;
4369                p = p->next)
4370             if (p->type == bfd_indirect_link_order)
4371               o->reloc_count += p->u.indirect.section->reloc_count;
4372             else if (p->type == bfd_section_reloc_link_order
4373                      || p->type == bfd_symbol_reloc_link_order)
4374               ++o->reloc_count;
4375         }
4376     }
4377
4378   /* Compute the reloc and symbol file positions.  */
4379   ecoff_compute_reloc_file_positions (abfd);
4380
4381   /* Write out the debugging information.  */
4382   if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug,
4383                                            &backend->debug_swap, info,
4384                                            ecoff_data (abfd)->sym_filepos))
4385     return FALSE;
4386
4387   bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info);
4388
4389   if (bfd_link_relocatable (info))
4390     {
4391       /* Now reset the reloc_count field of the sections in the output
4392          BFD to 0, so that we can use them to keep track of how many
4393          relocs we have output thus far.  */
4394       for (o = abfd->sections; o != NULL; o = o->next)
4395         o->reloc_count = 0;
4396     }
4397
4398   /* Get a value for the GP register.  */
4399   if (ecoff_data (abfd)->gp == 0)
4400     {
4401       struct bfd_link_hash_entry *h;
4402
4403       h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
4404       if (h != NULL
4405           && h->type == bfd_link_hash_defined)
4406         ecoff_data (abfd)->gp = (h->u.def.value
4407                                  + h->u.def.section->output_section->vma
4408                                  + h->u.def.section->output_offset);
4409       else if (bfd_link_relocatable (info))
4410         {
4411           bfd_vma lo;
4412
4413           /* Make up a value.  */
4414           lo = (bfd_vma) -1;
4415           for (o = abfd->sections; o != NULL; o = o->next)
4416             {
4417               if (o->vma < lo
4418                   && (streq (o->name, _SBSS)
4419                       || streq (o->name, _SDATA)
4420                       || streq (o->name, _LIT4)
4421                       || streq (o->name, _LIT8)
4422                       || streq (o->name, _LITA)))
4423                 lo = o->vma;
4424             }
4425           ecoff_data (abfd)->gp = lo + 0x8000;
4426         }
4427       else
4428         {
4429           /* If the relocate_section function needs to do a reloc
4430              involving the GP value, it should make a reloc_dangerous
4431              callback to warn that GP is not defined.  */
4432         }
4433     }
4434
4435   for (o = abfd->sections; o != NULL; o = o->next)
4436     {
4437       for (p = o->map_head.link_order;
4438            p != NULL;
4439            p = p->next)
4440         {
4441           if (p->type == bfd_indirect_link_order
4442               && (bfd_get_flavour (p->u.indirect.section->owner)
4443                   == bfd_target_ecoff_flavour))
4444             {
4445               if (! ecoff_indirect_link_order (abfd, info, o, p))
4446                 return FALSE;
4447             }
4448           else if (p->type == bfd_section_reloc_link_order
4449                    || p->type == bfd_symbol_reloc_link_order)
4450             {
4451               if (! ecoff_reloc_link_order (abfd, info, o, p))
4452                 return FALSE;
4453             }
4454           else
4455             {
4456               if (! _bfd_default_link_order (abfd, info, o, p))
4457                 return FALSE;
4458             }
4459         }
4460     }
4461
4462   bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax;
4463
4464   ecoff_data (abfd)->linker = TRUE;
4465
4466   return TRUE;
4467 }