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