bfd/ecoff.c

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