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