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