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 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           for (;
2637                reloc_ptr_ptr < reloc_end;
2638                reloc_ptr_ptr++, out_ptr += external_reloc_size)
2639             {
2640               arelent *reloc;
2641               asymbol *sym;
2642               struct internal_reloc in;
2643
2644               memset ((void *) &in, 0, sizeof in);
2645
2646               reloc = *reloc_ptr_ptr;
2647               sym = *reloc->sym_ptr_ptr;
2648
2649               in.r_vaddr = (reloc->address
2650                             + bfd_get_section_vma (abfd, current));
2651               in.r_type = reloc->howto->type;
2652
2653               if ((sym->flags & BSF_SECTION_SYM) == 0)
2654                 {
2655                   in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr);
2656                   in.r_extern = 1;
2657                 }
2658               else
2659                 {
2660                   const char *name;
2661                   unsigned int i;
2662                   static struct
2663                   {
2664                     const char * name;
2665                     long r_symndx;
2666                   }
2667                   section_symndx [] =
2668                   {
2669                     { _TEXT,   RELOC_SECTION_TEXT   },
2670                     { _RDATA,  RELOC_SECTION_RDATA  },
2671                     { _DATA,   RELOC_SECTION_DATA   },
2672                     { _SDATA,  RELOC_SECTION_SDATA  },
2673                     { _SBSS,   RELOC_SECTION_SBSS   },
2674                     { _BSS,    RELOC_SECTION_BSS    },
2675                     { _INIT,   RELOC_SECTION_INIT   },
2676                     { _LIT8,   RELOC_SECTION_LIT8   },
2677                     { _LIT4,   RELOC_SECTION_LIT4   },
2678                     { _XDATA,  RELOC_SECTION_XDATA  },
2679                     { _PDATA,  RELOC_SECTION_PDATA  },
2680                     { _FINI,   RELOC_SECTION_FINI   },
2681                     { _LITA,   RELOC_SECTION_LITA   },
2682                     { "*ABS*", RELOC_SECTION_ABS    },
2683                     { _RCONST, RELOC_SECTION_RCONST }
2684                   };
2685
2686                   name = bfd_get_section_name (abfd, bfd_get_section (sym));
2687
2688                   for (i = 0; i < ARRAY_SIZE (section_symndx); i++)
2689                     if (streq (name, section_symndx[i].name))
2690                       {
2691                         in.r_symndx = section_symndx[i].r_symndx;
2692                         break;
2693                       }
2694
2695                   if (i == ARRAY_SIZE (section_symndx))
2696                     abort ();
2697                   in.r_extern = 0;
2698                 }
2699
2700               (*adjust_reloc_out) (abfd, reloc, &in);
2701
2702               (*swap_reloc_out) (abfd, &in, (void *) out_ptr);
2703             }
2704
2705           if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0)
2706             goto error_return;
2707           amt = current->reloc_count * external_reloc_size;
2708           if (bfd_bwrite (reloc_buff, amt, abfd) != amt)
2709             goto error_return;
2710           bfd_release (abfd, reloc_buff);
2711           reloc_buff = NULL;
2712         }
2713
2714       /* Write out the symbolic debugging information.  */
2715       if (bfd_get_symcount (abfd) > 0)
2716         {
2717           /* Write out the debugging information.  */
2718           if (! bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap,
2719                                        ecoff_data (abfd)->sym_filepos))
2720             goto error_return;
2721         }
2722     }
2723
2724   /* The .bss section of a demand paged executable must receive an
2725      entire page.  If there are symbols, the symbols will start on the
2726      next page.  If there are no symbols, we must fill out the page by
2727      hand.  */
2728   if (bfd_get_symcount (abfd) == 0
2729       && (abfd->flags & EXEC_P) != 0
2730       && (abfd->flags & D_PAGED) != 0)
2731     {
2732       char c;
2733
2734       if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2735                     SEEK_SET) != 0)
2736         goto error_return;
2737       if (bfd_bread (&c, (bfd_size_type) 1, abfd) == 0)
2738         c = 0;
2739       if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2740                     SEEK_SET) != 0)
2741         goto error_return;
2742       if (bfd_bwrite (&c, (bfd_size_type) 1, abfd) != 1)
2743         goto error_return;
2744     }
2745
2746   if (reloc_buff != NULL)
2747     bfd_release (abfd, reloc_buff);
2748   if (buff != NULL)
2749     free (buff);
2750   return TRUE;
2751  error_return:
2752   if (reloc_buff != NULL)
2753     bfd_release (abfd, reloc_buff);
2754   if (buff != NULL)
2755     free (buff);
2756   return FALSE;
2757 }
2758 \f
2759 /* Archive handling.  ECOFF uses what appears to be a unique type of
2760    archive header (armap).  The byte ordering of the armap and the
2761    contents are encoded in the name of the armap itself.  At least for
2762    now, we only support archives with the same byte ordering in the
2763    armap and the contents.
2764
2765    The first four bytes in the armap are the number of symbol
2766    definitions.  This is always a power of two.
2767
2768    This is followed by the symbol definitions.  Each symbol definition
2769    occupies 8 bytes.  The first four bytes are the offset from the
2770    start of the armap strings to the null-terminated string naming
2771    this symbol.  The second four bytes are the file offset to the
2772    archive member which defines this symbol.  If the second four bytes
2773    are 0, then this is not actually a symbol definition, and it should
2774    be ignored.
2775
2776    The symbols are hashed into the armap with a closed hashing scheme.
2777    See the functions below for the details of the algorithm.
2778
2779    After the symbol definitions comes four bytes holding the size of
2780    the string table, followed by the string table itself.  */
2781
2782 /* The name of an archive headers looks like this:
2783    __________E[BL]E[BL]_ (with a trailing space).
2784    The trailing space is changed to an X if the archive is changed to
2785    indicate that the armap is out of date.
2786
2787    The Alpha seems to use ________64E[BL]E[BL]_.  */
2788
2789 #define ARMAP_BIG_ENDIAN                'B'
2790 #define ARMAP_LITTLE_ENDIAN             'L'
2791 #define ARMAP_MARKER                    'E'
2792 #define ARMAP_START_LENGTH              10
2793 #define ARMAP_HEADER_MARKER_INDEX       10
2794 #define ARMAP_HEADER_ENDIAN_INDEX       11
2795 #define ARMAP_OBJECT_MARKER_INDEX       12
2796 #define ARMAP_OBJECT_ENDIAN_INDEX       13
2797 #define ARMAP_END_INDEX                 14
2798 #define ARMAP_END                       "_ "
2799
2800 /* This is a magic number used in the hashing algorithm.  */
2801 #define ARMAP_HASH_MAGIC                0x9dd68ab5
2802
2803 /* This returns the hash value to use for a string.  It also sets
2804    *REHASH to the rehash adjustment if the first slot is taken.  SIZE
2805    is the number of entries in the hash table, and HLOG is the log
2806    base 2 of SIZE.  */
2807
2808 static unsigned int
2809 ecoff_armap_hash (const char *s,
2810                   unsigned int *rehash,
2811                   unsigned int size,
2812                   unsigned int hlog)
2813 {
2814   unsigned int hash;
2815
2816   if (hlog == 0)
2817     return 0;
2818   hash = *s++;
2819   while (*s != '\0')
2820     hash = ((hash >> 27) | (hash << 5)) + *s++;
2821   hash *= ARMAP_HASH_MAGIC;
2822   *rehash = (hash & (size - 1)) | 1;
2823   return hash >> (32 - hlog);
2824 }
2825
2826 /* Read in the armap.  */
2827
2828 bfd_boolean
2829 _bfd_ecoff_slurp_armap (bfd *abfd)
2830 {
2831   char nextname[17];
2832   unsigned int i;
2833   struct areltdata *mapdata;
2834   bfd_size_type parsed_size;
2835   char *raw_armap;
2836   struct artdata *ardata;
2837   unsigned int count;
2838   char *raw_ptr;
2839   struct symdef *symdef_ptr;
2840   char *stringbase;
2841   bfd_size_type amt;
2842
2843   /* Get the name of the first element.  */
2844   i = bfd_bread ((void *) nextname, (bfd_size_type) 16, abfd);
2845   if (i == 0)
2846       return TRUE;
2847   if (i != 16)
2848       return FALSE;
2849
2850   if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
2851     return FALSE;
2852
2853   /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2854      standard COFF armap.  We could move the ECOFF armap stuff into
2855      bfd_slurp_armap, but that seems inappropriate since no other
2856      target uses this format.  Instead, we check directly for a COFF
2857      armap.  */
2858   if (strneq (nextname, "/               ", 16))
2859     return bfd_slurp_armap (abfd);
2860
2861   /* See if the first element is an armap.  */
2862   if (! strneq (nextname, ecoff_backend (abfd)->armap_start, ARMAP_START_LENGTH)
2863       || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER
2864       || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2865           && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2866       || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER
2867       || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2868           && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2869       || ! strneq (nextname + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1))
2870     {
2871       bfd_has_map (abfd) = FALSE;
2872       return TRUE;
2873     }
2874
2875   /* Make sure we have the right byte ordering.  */
2876   if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2877        ^ (bfd_header_big_endian (abfd)))
2878       || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2879           ^ (bfd_big_endian (abfd))))
2880     {
2881       bfd_set_error (bfd_error_wrong_format);
2882       return FALSE;
2883     }
2884
2885   /* Read in the armap.  */
2886   ardata = bfd_ardata (abfd);
2887   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
2888   if (mapdata == NULL)
2889     return FALSE;
2890   parsed_size = mapdata->parsed_size;
2891   bfd_release (abfd, (void *) mapdata);
2892
2893   raw_armap = bfd_alloc (abfd, parsed_size);
2894   if (raw_armap == NULL)
2895     return FALSE;
2896
2897   if (bfd_bread ((void *) raw_armap, parsed_size, abfd) != parsed_size)
2898     {
2899       if (bfd_get_error () != bfd_error_system_call)
2900         bfd_set_error (bfd_error_malformed_archive);
2901       bfd_release (abfd, (void *) raw_armap);
2902       return FALSE;
2903     }
2904
2905   ardata->tdata = (void *) raw_armap;
2906
2907   count = H_GET_32 (abfd, raw_armap);
2908
2909   ardata->symdef_count = 0;
2910   ardata->cache = NULL;
2911
2912   /* This code used to overlay the symdefs over the raw archive data,
2913      but that doesn't work on a 64 bit host.  */
2914   stringbase = raw_armap + count * 8 + 8;
2915
2916 #ifdef CHECK_ARMAP_HASH
2917   {
2918     unsigned int hlog;
2919
2920     /* Double check that I have the hashing algorithm right by making
2921        sure that every symbol can be looked up successfully.  */
2922     hlog = 0;
2923     for (i = 1; i < count; i <<= 1)
2924       hlog++;
2925     BFD_ASSERT (i == count);
2926
2927     raw_ptr = raw_armap + 4;
2928     for (i = 0; i < count; i++, raw_ptr += 8)
2929       {
2930         unsigned int name_offset, file_offset;
2931         unsigned int hash, rehash, srch;
2932
2933         name_offset = H_GET_32 (abfd, raw_ptr);
2934         file_offset = H_GET_32 (abfd, (raw_ptr + 4));
2935         if (file_offset == 0)
2936           continue;
2937         hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count,
2938                                  hlog);
2939         if (hash == i)
2940           continue;
2941
2942         /* See if we can rehash to this location.  */
2943         for (srch = (hash + rehash) & (count - 1);
2944              srch != hash && srch != i;
2945              srch = (srch + rehash) & (count - 1))
2946           BFD_ASSERT (H_GET_32 (abfd, (raw_armap + 8 + srch * 8)) != 0);
2947         BFD_ASSERT (srch == i);
2948       }
2949   }
2950
2951 #endif /* CHECK_ARMAP_HASH */
2952
2953   raw_ptr = raw_armap + 4;
2954   for (i = 0; i < count; i++, raw_ptr += 8)
2955     if (H_GET_32 (abfd, (raw_ptr + 4)) != 0)
2956       ++ardata->symdef_count;
2957
2958   amt = ardata->symdef_count;
2959   amt *= sizeof (struct symdef);
2960   symdef_ptr = bfd_alloc (abfd, amt);
2961   if (!symdef_ptr)
2962     return FALSE;
2963
2964   ardata->symdefs = (carsym *) symdef_ptr;
2965
2966   raw_ptr = raw_armap + 4;
2967   for (i = 0; i < count; i++, raw_ptr += 8)
2968     {
2969       unsigned int name_offset, file_offset;
2970
2971       file_offset = H_GET_32 (abfd, (raw_ptr + 4));
2972       if (file_offset == 0)
2973         continue;
2974       name_offset = H_GET_32 (abfd, raw_ptr);
2975       symdef_ptr->s.name = stringbase + name_offset;
2976       symdef_ptr->file_offset = file_offset;
2977       ++symdef_ptr;
2978     }
2979
2980   ardata->first_file_filepos = bfd_tell (abfd);
2981   /* Pad to an even boundary.  */
2982   ardata->first_file_filepos += ardata->first_file_filepos % 2;
2983
2984   bfd_has_map (abfd) = TRUE;
2985
2986   return TRUE;
2987 }
2988
2989 /* Write out an armap.  */
2990
2991 bfd_boolean
2992 _bfd_ecoff_write_armap (bfd *abfd,
2993                         unsigned int elength,
2994                         struct orl *map,
2995                         unsigned int orl_count,
2996                         int stridx)
2997 {
2998   unsigned int hashsize, hashlog;
2999   bfd_size_type symdefsize;
3000   int padit;
3001   unsigned int stringsize;
3002   unsigned int mapsize;
3003   file_ptr firstreal;
3004   struct ar_hdr hdr;
3005   struct stat statbuf;
3006   unsigned int i;
3007   bfd_byte temp[4];
3008   bfd_byte *hashtable;
3009   bfd *current;
3010   bfd *last_elt;
3011
3012   /* Ultrix appears to use as a hash table size the least power of two
3013      greater than twice the number of entries.  */
3014   for (hashlog = 0; ((unsigned int) 1 << hashlog) <= 2 * orl_count; hashlog++)
3015     ;
3016   hashsize = 1 << hashlog;
3017
3018   symdefsize = hashsize * 8;
3019   padit = stridx % 2;
3020   stringsize = stridx + padit;
3021
3022   /* Include 8 bytes to store symdefsize and stringsize in output.  */
3023   mapsize = symdefsize + stringsize + 8;
3024
3025   firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength;
3026
3027   memset ((void *) &hdr, 0, sizeof hdr);
3028
3029   /* Work out the ECOFF armap name.  */
3030   strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start);
3031   hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER;
3032   hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] =
3033     (bfd_header_big_endian (abfd)
3034      ? ARMAP_BIG_ENDIAN
3035      : ARMAP_LITTLE_ENDIAN);
3036   hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER;
3037   hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] =
3038     bfd_big_endian (abfd) ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN;
3039   memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1);
3040
3041   /* Write the timestamp of the archive header to be just a little bit
3042      later than the timestamp of the file, otherwise the linker will
3043      complain that the index is out of date.  Actually, the Ultrix
3044      linker just checks the archive name; the GNU linker may check the
3045      date.  */
3046   stat (abfd->filename, &statbuf);
3047   sprintf (hdr.ar_date, "%ld", (long) (statbuf.st_mtime + 60));
3048
3049   /* The DECstation uses zeroes for the uid, gid and mode of the
3050      armap.  */
3051   hdr.ar_uid[0] = '0';
3052   hdr.ar_gid[0] = '0';
3053   /* Building gcc ends up extracting the armap as a file - twice.  */
3054   hdr.ar_mode[0] = '6';
3055   hdr.ar_mode[1] = '4';
3056   hdr.ar_mode[2] = '4';
3057
3058   sprintf (hdr.ar_size, "%-10d", (int) mapsize);
3059
3060   hdr.ar_fmag[0] = '`';
3061   hdr.ar_fmag[1] = '\012';
3062
3063   /* Turn all null bytes in the header into spaces.  */
3064   for (i = 0; i < sizeof (struct ar_hdr); i++)
3065    if (((char *) (&hdr))[i] == '\0')
3066      (((char *) (&hdr))[i]) = ' ';
3067
3068   if (bfd_bwrite ((void *) &hdr, (bfd_size_type) sizeof (struct ar_hdr), abfd)
3069       != sizeof (struct ar_hdr))
3070     return FALSE;
3071
3072   H_PUT_32 (abfd, hashsize, temp);
3073   if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4)
3074     return FALSE;
3075
3076   hashtable = bfd_zalloc (abfd, symdefsize);
3077   if (!hashtable)
3078     return FALSE;
3079
3080   current = abfd->archive_head;
3081   last_elt = current;
3082   for (i = 0; i < orl_count; i++)
3083     {
3084       unsigned int hash, rehash;
3085
3086       /* Advance firstreal to the file position of this archive
3087          element.  */
3088       if (map[i].u.abfd != last_elt)
3089         {
3090           do
3091             {
3092               firstreal += arelt_size (current) + sizeof (struct ar_hdr);
3093               firstreal += firstreal % 2;
3094               current = current->next;
3095             }
3096           while (current != map[i].u.abfd);
3097         }
3098
3099       last_elt = current;
3100
3101       hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog);
3102       if (H_GET_32 (abfd, (hashtable + (hash * 8) + 4)) != 0)
3103         {
3104           unsigned int srch;
3105
3106           /* The desired slot is already taken.  */
3107           for (srch = (hash + rehash) & (hashsize - 1);
3108                srch != hash;
3109                srch = (srch + rehash) & (hashsize - 1))
3110             if (H_GET_32 (abfd, (hashtable + (srch * 8) + 4)) == 0)
3111               break;
3112
3113           BFD_ASSERT (srch != hash);
3114
3115           hash = srch;
3116         }
3117
3118       H_PUT_32 (abfd, map[i].namidx, (hashtable + hash * 8));
3119       H_PUT_32 (abfd, firstreal, (hashtable + hash * 8 + 4));
3120     }
3121
3122   if (bfd_bwrite ((void *) hashtable, symdefsize, abfd) != symdefsize)
3123     return FALSE;
3124
3125   bfd_release (abfd, hashtable);
3126
3127   /* Now write the strings.  */
3128   H_PUT_32 (abfd, stringsize, temp);
3129   if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4)
3130     return FALSE;
3131   for (i = 0; i < orl_count; i++)
3132     {
3133       bfd_size_type len;
3134
3135       len = strlen (*map[i].name) + 1;
3136       if (bfd_bwrite ((void *) (*map[i].name), len, abfd) != len)
3137         return FALSE;
3138     }
3139
3140   /* The spec sez this should be a newline.  But in order to be
3141      bug-compatible for DECstation ar we use a null.  */
3142   if (padit)
3143     {
3144       if (bfd_bwrite ("", (bfd_size_type) 1, abfd) != 1)
3145         return FALSE;
3146     }
3147
3148   return TRUE;
3149 }
3150
3151 /* See whether this BFD is an archive.  If it is, read in the armap
3152    and the extended name table.  */
3153
3154 const bfd_target *
3155 _bfd_ecoff_archive_p (bfd *abfd)
3156 {
3157   struct artdata *tdata_hold;
3158   char armag[SARMAG + 1];
3159   bfd_size_type amt;
3160
3161   if (bfd_bread ((void *) armag, (bfd_size_type) SARMAG, abfd) != SARMAG)
3162     {
3163       if (bfd_get_error () != bfd_error_system_call)
3164         bfd_set_error (bfd_error_wrong_format);
3165       return NULL;
3166     }
3167
3168   if (! strneq (armag, ARMAG, SARMAG))
3169     {
3170       bfd_set_error (bfd_error_wrong_format);
3171       return NULL;
3172     }
3173
3174   tdata_hold = bfd_ardata (abfd);
3175
3176   amt = sizeof (struct artdata);
3177   bfd_ardata (abfd) = bfd_zalloc (abfd, amt);
3178   if (bfd_ardata (abfd) == NULL)
3179     {
3180       bfd_ardata (abfd) = tdata_hold;
3181       return NULL;
3182     }
3183
3184   bfd_ardata (abfd)->first_file_filepos = SARMAG;
3185   /* Already cleared by bfd_zalloc above.
3186      bfd_ardata (abfd)->cache = NULL;
3187      bfd_ardata (abfd)->archive_head = NULL;
3188      bfd_ardata (abfd)->symdefs = NULL;
3189      bfd_ardata (abfd)->extended_names = NULL;
3190      bfd_ardata (abfd)->extended_names_size = 0;
3191      bfd_ardata (abfd)->tdata = NULL;  */
3192
3193   if (! _bfd_ecoff_slurp_armap (abfd)
3194       || ! _bfd_ecoff_slurp_extended_name_table (abfd))
3195     {
3196       bfd_release (abfd, bfd_ardata (abfd));
3197       bfd_ardata (abfd) = tdata_hold;
3198       return NULL;
3199     }
3200
3201   if (bfd_has_map (abfd))
3202     {
3203       bfd *first;
3204
3205       /* This archive has a map, so we may presume that the contents
3206          are object files.  Make sure that if the first file in the
3207          archive can be recognized as an object file, it is for this
3208          target.  If not, assume that this is the wrong format.  If
3209          the first file is not an object file, somebody is doing
3210          something weird, and we permit it so that ar -t will work.  */
3211
3212       first = bfd_openr_next_archived_file (abfd, NULL);
3213       if (first != NULL)
3214         {
3215           first->target_defaulted = FALSE;
3216           if (bfd_check_format (first, bfd_object)
3217               && first->xvec != abfd->xvec)
3218             {
3219               /* We ought to close `first' here, but we can't, because
3220                  we have no way to remove it from the archive cache.
3221                  It's almost impossible to figure out when we can
3222                  release bfd_ardata.  FIXME.  */
3223               bfd_set_error (bfd_error_wrong_object_format);
3224               bfd_ardata (abfd) = tdata_hold;
3225               return NULL;
3226             }
3227           /* And we ought to close `first' here too.  */
3228         }
3229     }
3230
3231   return abfd->xvec;
3232 }
3233 \f
3234 /* ECOFF linker code.  */
3235
3236 /* Routine to create an entry in an ECOFF link hash table.  */
3237
3238 static struct bfd_hash_entry *
3239 ecoff_link_hash_newfunc (struct bfd_hash_entry *entry,
3240                          struct bfd_hash_table *table,
3241                          const char *string)
3242 {
3243   struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry;
3244
3245   /* Allocate the structure if it has not already been allocated by a
3246      subclass.  */
3247   if (ret == NULL)
3248     ret = ((struct ecoff_link_hash_entry *)
3249            bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry)));
3250   if (ret == NULL)
3251     return NULL;
3252
3253   /* Call the allocation method of the superclass.  */
3254   ret = ((struct ecoff_link_hash_entry *)
3255          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3256                                  table, string));
3257
3258   if (ret)
3259     {
3260       /* Set local fields.  */
3261       ret->indx = -1;
3262       ret->abfd = NULL;
3263       ret->written = 0;
3264       ret->small = 0;
3265     }
3266   memset ((void *) &ret->esym, 0, sizeof ret->esym);
3267
3268   return (struct bfd_hash_entry *) ret;
3269 }
3270
3271 /* Create an ECOFF link hash table.  */
3272
3273 struct bfd_link_hash_table *
3274 _bfd_ecoff_bfd_link_hash_table_create (bfd *abfd)
3275 {
3276   struct ecoff_link_hash_table *ret;
3277   bfd_size_type amt = sizeof (struct ecoff_link_hash_table);
3278
3279   ret = bfd_malloc (amt);
3280   if (ret == NULL)
3281     return NULL;
3282   if (! _bfd_link_hash_table_init (&ret->root, abfd,
3283                                    ecoff_link_hash_newfunc))
3284     {
3285       free (ret);
3286       return NULL;
3287     }
3288   return &ret->root;
3289 }
3290
3291 /* Look up an entry in an ECOFF link hash table.  */
3292
3293 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3294   ((struct ecoff_link_hash_entry *) \
3295    bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3296
3297 /* Traverse an ECOFF link hash table.  */
3298
3299 #define ecoff_link_hash_traverse(table, func, info)                     \
3300   (bfd_link_hash_traverse                                               \
3301    (&(table)->root,                                                     \
3302     (bfd_boolean (*) (struct bfd_link_hash_entry *, void *)) (func),    \
3303     (info)))
3304
3305 /* Get the ECOFF link hash table from the info structure.  This is
3306    just a cast.  */
3307
3308 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3309
3310 /* Add the external symbols of an object file to the global linker
3311    hash table.  The external symbols and strings we are passed are
3312    just allocated on the stack, and will be discarded.  We must
3313    explicitly save any information we may need later on in the link.
3314    We do not want to read the external symbol information again.  */
3315
3316 static bfd_boolean
3317 ecoff_link_add_externals (bfd *abfd,
3318                           struct bfd_link_info *info,
3319                           void * external_ext,
3320                           char *ssext)
3321 {
3322   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3323   void (* const swap_ext_in) (bfd *, void *, EXTR *)
3324     = backend->debug_swap.swap_ext_in;
3325   bfd_size_type external_ext_size = backend->debug_swap.external_ext_size;
3326   unsigned long ext_count;
3327   struct bfd_link_hash_entry **sym_hash;
3328   char *ext_ptr;
3329   char *ext_end;
3330   bfd_size_type amt;
3331
3332   ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
3333
3334   amt = ext_count;
3335   amt *= sizeof (struct bfd_link_hash_entry *);
3336   sym_hash = bfd_alloc (abfd, amt);
3337   if (!sym_hash)
3338     return FALSE;
3339   ecoff_data (abfd)->sym_hashes = (struct ecoff_link_hash_entry **) sym_hash;
3340
3341   ext_ptr = (char *) external_ext;
3342   ext_end = ext_ptr + ext_count * external_ext_size;
3343   for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++)
3344     {
3345       EXTR esym;
3346       bfd_boolean skip;
3347       bfd_vma value;
3348       asection *section;
3349       const char *name;
3350       struct ecoff_link_hash_entry *h;
3351
3352       *sym_hash = NULL;
3353
3354       (*swap_ext_in) (abfd, (void *) ext_ptr, &esym);
3355
3356       /* Skip debugging symbols.  */
3357       skip = FALSE;
3358       switch (esym.asym.st)
3359         {
3360         case stGlobal:
3361         case stStatic:
3362         case stLabel:
3363         case stProc:
3364         case stStaticProc:
3365           break;
3366         default:
3367           skip = TRUE;
3368           break;
3369         }
3370
3371       if (skip)
3372         continue;
3373
3374       /* Get the information for this symbol.  */
3375       value = esym.asym.value;
3376       switch (esym.asym.sc)
3377         {
3378         default:
3379         case scNil:
3380         case scRegister:
3381         case scCdbLocal:
3382         case scBits:
3383         case scCdbSystem:
3384         case scRegImage:
3385         case scInfo:
3386         case scUserStruct:
3387         case scVar:
3388         case scVarRegister:
3389         case scVariant:
3390         case scBasedVar:
3391         case scXData:
3392         case scPData:
3393           section = NULL;
3394           break;
3395         case scText:
3396           section = bfd_make_section_old_way (abfd, _TEXT);
3397           value -= section->vma;
3398           break;
3399         case scData:
3400           section = bfd_make_section_old_way (abfd, _DATA);
3401           value -= section->vma;
3402           break;
3403         case scBss:
3404           section = bfd_make_section_old_way (abfd, _BSS);
3405           value -= section->vma;
3406           break;
3407         case scAbs:
3408           section = bfd_abs_section_ptr;
3409           break;
3410         case scUndefined:
3411           section = bfd_und_section_ptr;
3412           break;
3413         case scSData:
3414           section = bfd_make_section_old_way (abfd, _SDATA);
3415           value -= section->vma;
3416           break;
3417         case scSBss:
3418           section = bfd_make_section_old_way (abfd, _SBSS);
3419           value -= section->vma;
3420           break;
3421         case scRData:
3422           section = bfd_make_section_old_way (abfd, _RDATA);
3423           value -= section->vma;
3424           break;
3425         case scCommon:
3426           if (value > ecoff_data (abfd)->gp_size)
3427             {
3428               section = bfd_com_section_ptr;
3429               break;
3430             }
3431           /* Fall through.  */
3432         case scSCommon:
3433           if (ecoff_scom_section.name == NULL)
3434             {
3435               /* Initialize the small common section.  */
3436               ecoff_scom_section.name = SCOMMON;
3437               ecoff_scom_section.flags = SEC_IS_COMMON;
3438               ecoff_scom_section.output_section = &ecoff_scom_section;
3439               ecoff_scom_section.symbol = &ecoff_scom_symbol;
3440               ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
3441               ecoff_scom_symbol.name = SCOMMON;
3442               ecoff_scom_symbol.flags = BSF_SECTION_SYM;
3443               ecoff_scom_symbol.section = &ecoff_scom_section;
3444               ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
3445             }
3446           section = &ecoff_scom_section;
3447           break;
3448         case scSUndefined:
3449           section = bfd_und_section_ptr;
3450           break;
3451         case scInit:
3452           section = bfd_make_section_old_way (abfd, _INIT);
3453           value -= section->vma;
3454           break;
3455         case scFini:
3456           section = bfd_make_section_old_way (abfd, _FINI);
3457           value -= section->vma;
3458           break;
3459         case scRConst:
3460           section = bfd_make_section_old_way (abfd, _RCONST);
3461           value -= section->vma;
3462           break;
3463         }
3464
3465       if (section == NULL)
3466         continue;
3467
3468       name = ssext + esym.asym.iss;
3469
3470       if (! (_bfd_generic_link_add_one_symbol
3471              (info, abfd, name,
3472               (flagword) (esym.weakext ? BSF_WEAK : BSF_GLOBAL),
3473               section, value, NULL, TRUE, TRUE, sym_hash)))
3474         return FALSE;
3475
3476       h = (struct ecoff_link_hash_entry *) *sym_hash;
3477
3478       /* If we are building an ECOFF hash table, save the external
3479          symbol information.  */
3480       if (info->hash->creator->flavour == bfd_get_flavour (abfd))
3481         {
3482           if (h->abfd == NULL
3483               || (! bfd_is_und_section (section)
3484                   && (! bfd_is_com_section (section)
3485                       || (h->root.type != bfd_link_hash_defined
3486                           && h->root.type != bfd_link_hash_defweak))))
3487             {
3488               h->abfd = abfd;
3489               h->esym = esym;
3490             }
3491
3492           /* Remember whether this symbol was small undefined.  */
3493           if (esym.asym.sc == scSUndefined)
3494             h->small = 1;
3495
3496           /* If this symbol was ever small undefined, it needs to wind
3497              up in a GP relative section.  We can't control the
3498              section of a defined symbol, but we can control the
3499              section of a common symbol.  This case is actually needed
3500              on Ultrix 4.2 to handle the symbol cred in -lckrb.  */
3501           if (h->small
3502               && h->root.type == bfd_link_hash_common
3503               && streq (h->root.u.c.p->section->name, SCOMMON))
3504             {
3505               h->root.u.c.p->section = bfd_make_section_old_way (abfd,
3506                                                                  SCOMMON);
3507               h->root.u.c.p->section->flags = SEC_ALLOC;
3508               if (h->esym.asym.sc == scCommon)
3509                 h->esym.asym.sc = scSCommon;
3510             }
3511         }
3512     }
3513
3514   return TRUE;
3515 }
3516
3517 /* Add symbols from an ECOFF object file to the global linker hash
3518    table.  */
3519
3520 static bfd_boolean
3521 ecoff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3522 {
3523   HDRR *symhdr;
3524   bfd_size_type external_ext_size;
3525   void * external_ext = NULL;
3526   bfd_size_type esize;
3527   char *ssext = NULL;
3528   bfd_boolean result;
3529
3530   if (! ecoff_slurp_symbolic_header (abfd))
3531     return FALSE;
3532
3533   /* If there are no symbols, we don't want it.  */
3534   if (bfd_get_symcount (abfd) == 0)
3535     return TRUE;
3536
3537   symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3538
3539   /* Read in the external symbols and external strings.  */
3540   external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size;
3541   esize = symhdr->iextMax * external_ext_size;
3542   external_ext = bfd_malloc (esize);
3543   if (external_ext == NULL && esize != 0)
3544     goto error_return;
3545
3546   if (bfd_seek (abfd, (file_ptr) symhdr->cbExtOffset, SEEK_SET) != 0
3547       || bfd_bread (external_ext, esize, abfd) != esize)
3548     goto error_return;
3549
3550   ssext = bfd_malloc ((bfd_size_type) symhdr->issExtMax);
3551   if (ssext == NULL && symhdr->issExtMax != 0)
3552     goto error_return;
3553
3554   if (bfd_seek (abfd, (file_ptr) symhdr->cbSsExtOffset, SEEK_SET) != 0
3555       || (bfd_bread (ssext, (bfd_size_type) symhdr->issExtMax, abfd)
3556           != (bfd_size_type) symhdr->issExtMax))
3557     goto error_return;
3558
3559   result = ecoff_link_add_externals (abfd, info, external_ext, ssext);
3560
3561   if (ssext != NULL)
3562     free (ssext);
3563   if (external_ext != NULL)
3564     free (external_ext);
3565   return result;
3566
3567  error_return:
3568   if (ssext != NULL)
3569     free (ssext);
3570   if (external_ext != NULL)
3571     free (external_ext);
3572   return FALSE;
3573 }
3574
3575 /* This is called if we used _bfd_generic_link_add_archive_symbols
3576    because we were not dealing with an ECOFF archive.  */
3577
3578 static bfd_boolean
3579 ecoff_link_check_archive_element (bfd *abfd,
3580                                   struct bfd_link_info *info,
3581                                   bfd_boolean *pneeded)
3582 {
3583   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3584   void (* const swap_ext_in) (bfd *, void *, EXTR *)
3585     = backend->debug_swap.swap_ext_in;
3586   HDRR *symhdr;
3587   bfd_size_type external_ext_size;
3588   void * external_ext = NULL;
3589   bfd_size_type esize;
3590   char *ssext = NULL;
3591   char *ext_ptr;
3592   char *ext_end;
3593
3594   *pneeded = FALSE;
3595
3596   if (! ecoff_slurp_symbolic_header (abfd))
3597     goto error_return;
3598
3599   /* If there are no symbols, we don't want it.  */
3600   if (bfd_get_symcount (abfd) == 0)
3601     goto successful_return;
3602
3603   symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3604
3605   /* Read in the external symbols and external strings.  */
3606   external_ext_size = backend->debug_swap.external_ext_size;
3607   esize = symhdr->iextMax * external_ext_size;
3608   external_ext = bfd_malloc (esize);
3609   if (external_ext == NULL && esize != 0)
3610     goto error_return;
3611
3612   if (bfd_seek (abfd, (file_ptr) symhdr->cbExtOffset, SEEK_SET) != 0
3613       || bfd_bread (external_ext, esize, abfd) != esize)
3614     goto error_return;
3615
3616   ssext = bfd_malloc ((bfd_size_type) symhdr->issExtMax);
3617   if (ssext == NULL && symhdr->issExtMax != 0)
3618     goto error_return;
3619
3620   if (bfd_seek (abfd, (file_ptr) symhdr->cbSsExtOffset, SEEK_SET) != 0
3621       || (bfd_bread (ssext, (bfd_size_type) symhdr->issExtMax, abfd)
3622           != (bfd_size_type) symhdr->issExtMax))
3623     goto error_return;
3624
3625   /* Look through the external symbols to see if they define some
3626      symbol that is currently undefined.  */
3627   ext_ptr = (char *) external_ext;
3628   ext_end = ext_ptr + esize;
3629   for (; ext_ptr < ext_end; ext_ptr += external_ext_size)
3630     {
3631       EXTR esym;
3632       bfd_boolean def;
3633       const char *name;
3634       struct bfd_link_hash_entry *h;
3635
3636       (*swap_ext_in) (abfd, (void *) ext_ptr, &esym);
3637
3638       /* See if this symbol defines something.  */
3639       if (esym.asym.st != stGlobal
3640           && esym.asym.st != stLabel
3641           && esym.asym.st != stProc)
3642         continue;
3643
3644       switch (esym.asym.sc)
3645         {
3646         case scText:
3647         case scData:
3648         case scBss:
3649         case scAbs:
3650         case scSData:
3651         case scSBss:
3652         case scRData:
3653         case scCommon:
3654         case scSCommon:
3655         case scInit:
3656         case scFini:
3657         case scRConst:
3658           def = TRUE;
3659           break;
3660         default:
3661           def = FALSE;
3662           break;
3663         }
3664
3665       if (! def)
3666         continue;
3667
3668       name = ssext + esym.asym.iss;
3669       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
3670
3671       /* Unlike the generic linker, we do not pull in elements because
3672          of common symbols.  */
3673       if (h == NULL
3674           || h->type != bfd_link_hash_undefined)
3675         continue;
3676
3677       /* Include this element.  */
3678       if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3679         goto error_return;
3680       if (! ecoff_link_add_externals (abfd, info, external_ext, ssext))
3681         goto error_return;
3682
3683       *pneeded = TRUE;
3684       goto successful_return;
3685     }
3686
3687  successful_return:
3688   if (external_ext != NULL)
3689     free (external_ext);
3690   if (ssext != NULL)
3691     free (ssext);
3692   return TRUE;
3693  error_return:
3694   if (external_ext != NULL)
3695     free (external_ext);
3696   if (ssext != NULL)
3697     free (ssext);
3698   return FALSE;
3699 }
3700
3701 /* Add the symbols from an archive file to the global hash table.
3702    This looks through the undefined symbols, looks each one up in the
3703    archive hash table, and adds any associated object file.  We do not
3704    use _bfd_generic_link_add_archive_symbols because ECOFF archives
3705    already have a hash table, so there is no reason to construct
3706    another one.  */
3707
3708 static bfd_boolean
3709 ecoff_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
3710 {
3711   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3712   const bfd_byte *raw_armap;
3713   struct bfd_link_hash_entry **pundef;
3714   unsigned int armap_count;
3715   unsigned int armap_log;
3716   unsigned int i;
3717   const bfd_byte *hashtable;
3718   const char *stringbase;
3719
3720   if (! bfd_has_map (abfd))
3721     {
3722       /* An empty archive is a special case.  */
3723       if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
3724         return TRUE;
3725       bfd_set_error (bfd_error_no_armap);
3726       return FALSE;
3727     }
3728
3729   /* If we don't have any raw data for this archive, as can happen on
3730      Irix 4.0.5F, we call the generic routine.
3731      FIXME: We should be more clever about this, since someday tdata
3732      may get to something for a generic archive.  */
3733   raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata;
3734   if (raw_armap == NULL)
3735     return (_bfd_generic_link_add_archive_symbols
3736             (abfd, info, ecoff_link_check_archive_element));
3737
3738   armap_count = H_GET_32 (abfd, raw_armap);
3739
3740   armap_log = 0;
3741   for (i = 1; i < armap_count; i <<= 1)
3742     armap_log++;
3743   BFD_ASSERT (i == armap_count);
3744
3745   hashtable = raw_armap + 4;
3746   stringbase = (const char *) raw_armap + armap_count * 8 + 8;
3747
3748   /* Look through the list of undefined symbols.  */
3749   pundef = &info->hash->undefs;
3750   while (*pundef != NULL)
3751     {
3752       struct bfd_link_hash_entry *h;
3753       unsigned int hash, rehash;
3754       unsigned int file_offset;
3755       const char *name;
3756       bfd *element;
3757
3758       h = *pundef;
3759
3760       /* When a symbol is defined, it is not necessarily removed from
3761          the list.  */
3762       if (h->type != bfd_link_hash_undefined
3763           && h->type != bfd_link_hash_common)
3764         {
3765           /* Remove this entry from the list, for general cleanliness
3766              and because we are going to look through the list again
3767              if we search any more libraries.  We can't remove the
3768              entry if it is the tail, because that would lose any
3769              entries we add to the list later on.  */
3770           if (*pundef != info->hash->undefs_tail)
3771             *pundef = (*pundef)->u.undef.next;
3772           else
3773             pundef = &(*pundef)->u.undef.next;
3774           continue;
3775         }
3776
3777       /* Native ECOFF linkers do not pull in archive elements merely
3778          to satisfy common definitions, so neither do we.  We leave
3779          them on the list, though, in case we are linking against some
3780          other object format.  */
3781       if (h->type != bfd_link_hash_undefined)
3782         {
3783           pundef = &(*pundef)->u.undef.next;
3784           continue;
3785         }
3786
3787       /* Look for this symbol in the archive hash table.  */
3788       hash = ecoff_armap_hash (h->root.string, &rehash, armap_count,
3789                                armap_log);
3790
3791       file_offset = H_GET_32 (abfd, hashtable + (hash * 8) + 4);
3792       if (file_offset == 0)
3793         {
3794           /* Nothing in this slot.  */
3795           pundef = &(*pundef)->u.undef.next;
3796           continue;
3797         }
3798
3799       name = stringbase + H_GET_32 (abfd, hashtable + (hash * 8));
3800       if (name[0] != h->root.string[0]
3801           || ! streq (name, h->root.string))
3802         {
3803           unsigned int srch;
3804           bfd_boolean found;
3805
3806           /* That was the wrong symbol.  Try rehashing.  */
3807           found = FALSE;
3808           for (srch = (hash + rehash) & (armap_count - 1);
3809                srch != hash;
3810                srch = (srch + rehash) & (armap_count - 1))
3811             {
3812               file_offset = H_GET_32 (abfd, hashtable + (srch * 8) + 4);
3813               if (file_offset == 0)
3814                 break;
3815               name = stringbase + H_GET_32 (abfd, hashtable + (srch * 8));
3816               if (name[0] == h->root.string[0]
3817                   && streq (name, h->root.string))
3818                 {
3819                   found = TRUE;
3820                   break;
3821                 }
3822             }
3823
3824           if (! found)
3825             {
3826               pundef = &(*pundef)->u.undef.next;
3827               continue;
3828             }
3829
3830           hash = srch;
3831         }
3832
3833       element = (*backend->get_elt_at_filepos) (abfd, (file_ptr) file_offset);
3834       if (element == NULL)
3835         return FALSE;
3836
3837       if (! bfd_check_format (element, bfd_object))
3838         return FALSE;
3839
3840       /* Unlike the generic linker, we know that this element provides
3841          a definition for an undefined symbol and we know that we want
3842          to include it.  We don't need to check anything.  */
3843       if (! (*info->callbacks->add_archive_element) (info, element, name))
3844         return FALSE;
3845       if (! ecoff_link_add_object_symbols (element, info))
3846         return FALSE;
3847
3848       pundef = &(*pundef)->u.undef.next;
3849     }
3850
3851   return TRUE;
3852 }
3853
3854 /* Given an ECOFF BFD, add symbols to the global hash table as
3855    appropriate.  */
3856
3857 bfd_boolean
3858 _bfd_ecoff_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
3859 {
3860   switch (bfd_get_format (abfd))
3861     {
3862     case bfd_object:
3863       return ecoff_link_add_object_symbols (abfd, info);
3864     case bfd_archive:
3865       return ecoff_link_add_archive_symbols (abfd, info);
3866     default:
3867       bfd_set_error (bfd_error_wrong_format);
3868       return FALSE;
3869     }
3870 }
3871
3872 \f
3873 /* ECOFF final link routines.  */
3874
3875 /* Structure used to pass information to ecoff_link_write_external.  */
3876
3877 struct extsym_info
3878 {
3879   bfd *abfd;
3880   struct bfd_link_info *info;
3881 };
3882
3883 /* Accumulate the debugging information for an input BFD into the
3884    output BFD.  This must read in the symbolic information of the
3885    input BFD.  */
3886
3887 static bfd_boolean
3888 ecoff_final_link_debug_accumulate (bfd *output_bfd,
3889                                    bfd *input_bfd,
3890                                    struct bfd_link_info *info,
3891                                    void * handle)
3892 {
3893   struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info;
3894   const struct ecoff_debug_swap * const swap =
3895     &ecoff_backend (input_bfd)->debug_swap;
3896   HDRR *symhdr = &debug->symbolic_header;
3897   bfd_boolean ret;
3898
3899 #define READ(ptr, offset, count, size, type)                             \
3900   if (symhdr->count == 0)                                                \
3901     debug->ptr = NULL;                                                   \
3902   else                                                                   \
3903     {                                                                    \
3904       bfd_size_type amt = (bfd_size_type) size * symhdr->count;          \
3905       debug->ptr = bfd_malloc (amt);                                     \
3906       if (debug->ptr == NULL)                                            \
3907         {                                                                \
3908           ret = FALSE;                                                   \
3909           goto return_something;                                         \
3910         }                                                                \
3911       if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3912           || bfd_bread (debug->ptr, amt, input_bfd) != amt)              \
3913         {                                                                \
3914           ret = FALSE;                                                   \
3915           goto return_something;                                         \
3916         }                                                                \
3917     }
3918
3919   /* If raw_syments is not NULL, then the data was already by read by
3920      _bfd_ecoff_slurp_symbolic_info.  */
3921   if (ecoff_data (input_bfd)->raw_syments == NULL)
3922     {
3923       READ (line, cbLineOffset, cbLine, sizeof (unsigned char),
3924             unsigned char *);
3925       READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
3926       READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
3927       READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
3928       READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
3929       READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
3930             union aux_ext *);
3931       READ (ss, cbSsOffset, issMax, sizeof (char), char *);
3932       READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
3933       READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
3934     }
3935 #undef READ
3936
3937   /* We do not read the external strings or the external symbols.  */
3938
3939   ret = (bfd_ecoff_debug_accumulate
3940          (handle, output_bfd, &ecoff_data (output_bfd)->debug_info,
3941           &ecoff_backend (output_bfd)->debug_swap,
3942           input_bfd, debug, swap, info));
3943
3944  return_something:
3945   if (ecoff_data (input_bfd)->raw_syments == NULL)
3946     {
3947       if (debug->line != NULL)
3948         free (debug->line);
3949       if (debug->external_dnr != NULL)
3950         free (debug->external_dnr);
3951       if (debug->external_pdr != NULL)
3952         free (debug->external_pdr);
3953       if (debug->external_sym != NULL)
3954         free (debug->external_sym);
3955       if (debug->external_opt != NULL)
3956         free (debug->external_opt);
3957       if (debug->external_aux != NULL)
3958         free (debug->external_aux);
3959       if (debug->ss != NULL)
3960         free (debug->ss);
3961       if (debug->external_fdr != NULL)
3962         free (debug->external_fdr);
3963       if (debug->external_rfd != NULL)
3964         free (debug->external_rfd);
3965
3966       /* Make sure we don't accidentally follow one of these pointers
3967          into freed memory.  */
3968       debug->line = NULL;
3969       debug->external_dnr = NULL;
3970       debug->external_pdr = NULL;
3971       debug->external_sym = NULL;
3972       debug->external_opt = NULL;
3973       debug->external_aux = NULL;
3974       debug->ss = NULL;
3975       debug->external_fdr = NULL;
3976       debug->external_rfd = NULL;
3977     }
3978
3979   return ret;
3980 }
3981
3982 /* Relocate and write an ECOFF section into an ECOFF output file.  */
3983
3984 static bfd_boolean
3985 ecoff_indirect_link_order (bfd *output_bfd,
3986                            struct bfd_link_info *info,
3987                            asection *output_section,
3988                            struct bfd_link_order *link_order)
3989 {
3990   asection *input_section;
3991   bfd *input_bfd;
3992   bfd_byte *contents = NULL;
3993   bfd_size_type external_reloc_size;
3994   bfd_size_type external_relocs_size;
3995   void * external_relocs = NULL;
3996
3997   BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
3998
3999   if (link_order->size == 0)
4000     return TRUE;
4001
4002   input_section = link_order->u.indirect.section;
4003   input_bfd = input_section->owner;
4004
4005   BFD_ASSERT (input_section->output_section == output_section);
4006   BFD_ASSERT (input_section->output_offset == link_order->offset);
4007   BFD_ASSERT (input_section->size == link_order->size);
4008
4009   /* Get the section contents.  */
4010   if (!bfd_malloc_and_get_section (input_bfd, input_section, &contents))
4011     goto error_return;
4012
4013   /* Get the relocs.  If we are relaxing MIPS code, they will already
4014      have been read in.  Otherwise, we read them in now.  */
4015   external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size;
4016   external_relocs_size = external_reloc_size * input_section->reloc_count;
4017
4018   external_relocs = bfd_malloc (external_relocs_size);
4019   if (external_relocs == NULL && external_relocs_size != 0)
4020     goto error_return;
4021
4022   if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4023       || (bfd_bread (external_relocs, external_relocs_size, input_bfd)
4024           != external_relocs_size))
4025     goto error_return;
4026
4027   /* Relocate the section contents.  */
4028   if (! ((*ecoff_backend (input_bfd)->relocate_section)
4029          (output_bfd, info, input_bfd, input_section, contents,
4030           external_relocs)))
4031     goto error_return;
4032
4033   /* Write out the relocated section.  */
4034   if (! bfd_set_section_contents (output_bfd,
4035                                   output_section,
4036                                   contents,
4037                                   input_section->output_offset,
4038                                   input_section->size))
4039     goto error_return;
4040
4041   /* If we are producing relocatable output, the relocs were
4042      modified, and we write them out now.  We use the reloc_count
4043      field of output_section to keep track of the number of relocs we
4044      have output so far.  */
4045   if (info->relocatable)
4046     {
4047       file_ptr pos = (output_section->rel_filepos
4048                       + output_section->reloc_count * external_reloc_size);
4049       if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
4050           || (bfd_bwrite (external_relocs, external_relocs_size, output_bfd)
4051               != external_relocs_size))
4052         goto error_return;
4053       output_section->reloc_count += input_section->reloc_count;
4054     }
4055
4056   if (contents != NULL)
4057     free (contents);
4058   if (external_relocs != NULL)
4059     free (external_relocs);
4060   return TRUE;
4061
4062  error_return:
4063   if (contents != NULL)
4064     free (contents);
4065   if (external_relocs != NULL)
4066     free (external_relocs);
4067   return FALSE;
4068 }
4069
4070 /* Generate a reloc when linking an ECOFF file.  This is a reloc
4071    requested by the linker, and does come from any input file.  This
4072    is used to build constructor and destructor tables when linking
4073    with -Ur.  */
4074
4075 static bfd_boolean
4076 ecoff_reloc_link_order (bfd *output_bfd,
4077                         struct bfd_link_info *info,
4078                         asection *output_section,
4079                         struct bfd_link_order *link_order)
4080 {
4081   enum bfd_link_order_type type;
4082   asection *section;
4083   bfd_vma addend;
4084   arelent rel;
4085   struct internal_reloc in;
4086   bfd_size_type external_reloc_size;
4087   bfd_byte *rbuf;
4088   bfd_boolean ok;
4089   file_ptr pos;
4090
4091   type = link_order->type;
4092   section = NULL;
4093   addend = link_order->u.reloc.p->addend;
4094
4095   /* We set up an arelent to pass to the backend adjust_reloc_out
4096      routine.  */
4097   rel.address = link_order->offset;
4098
4099   rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
4100   if (rel.howto == 0)
4101     {
4102       bfd_set_error (bfd_error_bad_value);
4103       return FALSE;
4104     }
4105
4106   if (type == bfd_section_reloc_link_order)
4107     {
4108       section = link_order->u.reloc.p->u.section;
4109       rel.sym_ptr_ptr = section->symbol_ptr_ptr;
4110     }
4111   else
4112     {
4113       struct bfd_link_hash_entry *h;
4114
4115       /* Treat a reloc against a defined symbol as though it were
4116          actually against the section.  */
4117       h = bfd_wrapped_link_hash_lookup (output_bfd, info,
4118                                         link_order->u.reloc.p->u.name,
4119                                         FALSE, FALSE, FALSE);
4120       if (h != NULL
4121           && (h->type == bfd_link_hash_defined
4122               || h->type == bfd_link_hash_defweak))
4123         {
4124           type = bfd_section_reloc_link_order;
4125           section = h->u.def.section->output_section;
4126           /* It seems that we ought to add the symbol value to the
4127              addend here, but in practice it has already been added
4128              because it was passed to constructor_callback.  */
4129           addend += section->vma + h->u.def.section->output_offset;
4130         }
4131       else
4132         {
4133           /* We can't set up a reloc against a symbol correctly,
4134              because we have no asymbol structure.  Currently no
4135              adjust_reloc_out routine cares.  */
4136           rel.sym_ptr_ptr = NULL;
4137         }
4138     }
4139
4140   /* All ECOFF relocs are in-place.  Put the addend into the object
4141      file.  */
4142
4143   BFD_ASSERT (rel.howto->partial_inplace);
4144   if (addend != 0)
4145     {
4146       bfd_size_type size;
4147       bfd_reloc_status_type rstat;
4148       bfd_byte *buf;
4149
4150       size = bfd_get_reloc_size (rel.howto);
4151       buf = bfd_zmalloc (size);
4152       if (buf == NULL)
4153         return FALSE;
4154       rstat = _bfd_relocate_contents (rel.howto, output_bfd,
4155                                       (bfd_vma) addend, buf);
4156       switch (rstat)
4157         {
4158         case bfd_reloc_ok:
4159           break;
4160         default:
4161         case bfd_reloc_outofrange:
4162           abort ();
4163         case bfd_reloc_overflow:
4164           if (! ((*info->callbacks->reloc_overflow)
4165                  (info, NULL,
4166                   (link_order->type == bfd_section_reloc_link_order
4167                    ? bfd_section_name (output_bfd, section)
4168                    : link_order->u.reloc.p->u.name),
4169                   rel.howto->name, addend, NULL,
4170                   NULL, (bfd_vma) 0)))
4171             {
4172               free (buf);
4173               return FALSE;
4174             }
4175           break;
4176         }
4177       ok = bfd_set_section_contents (output_bfd, output_section, (void *) buf,
4178                                      (file_ptr) link_order->offset, size);
4179       free (buf);
4180       if (! ok)
4181         return FALSE;
4182     }
4183
4184   rel.addend = 0;
4185
4186   /* Move the information into an internal_reloc structure.  */
4187   in.r_vaddr = (rel.address
4188                 + bfd_get_section_vma (output_bfd, output_section));
4189   in.r_type = rel.howto->type;
4190
4191   if (type == bfd_symbol_reloc_link_order)
4192     {
4193       struct ecoff_link_hash_entry *h;
4194
4195       h = ((struct ecoff_link_hash_entry *)
4196            bfd_wrapped_link_hash_lookup (output_bfd, info,
4197                                          link_order->u.reloc.p->u.name,
4198                                          FALSE, FALSE, TRUE));
4199       if (h != NULL
4200           && h->indx != -1)
4201         in.r_symndx = h->indx;
4202       else
4203         {
4204           if (! ((*info->callbacks->unattached_reloc)
4205                  (info, link_order->u.reloc.p->u.name, NULL,
4206                   NULL, (bfd_vma) 0)))
4207             return FALSE;
4208           in.r_symndx = 0;
4209         }
4210       in.r_extern = 1;
4211     }
4212   else
4213     {
4214       const char *name;
4215       unsigned int i;
4216       static struct
4217       {
4218         const char * name;
4219         long r_symndx;
4220       }
4221       section_symndx [] =
4222       {
4223         { _TEXT,   RELOC_SECTION_TEXT   },
4224         { _RDATA,  RELOC_SECTION_RDATA  },
4225         { _DATA,   RELOC_SECTION_DATA   },
4226         { _SDATA,  RELOC_SECTION_SDATA  },
4227         { _SBSS,   RELOC_SECTION_SBSS   },
4228         { _BSS,    RELOC_SECTION_BSS    },
4229         { _INIT,   RELOC_SECTION_INIT   },
4230         { _LIT8,   RELOC_SECTION_LIT8   },
4231         { _LIT4,   RELOC_SECTION_LIT4   },
4232         { _XDATA,  RELOC_SECTION_XDATA  },
4233         { _PDATA,  RELOC_SECTION_PDATA  },
4234         { _FINI,   RELOC_SECTION_FINI   },
4235         { _LITA,   RELOC_SECTION_LITA   },
4236         { "*ABS*", RELOC_SECTION_ABS    },
4237         { _RCONST, RELOC_SECTION_RCONST }
4238       };
4239
4240       name = bfd_get_section_name (output_bfd, section);
4241
4242       for (i = 0; i < ARRAY_SIZE (section_symndx); i++)
4243         if (streq (name, section_symndx[i].name))
4244           {
4245             in.r_symndx = section_symndx[i].r_symndx;
4246             break;
4247           }
4248
4249       if (i == ARRAY_SIZE (section_symndx))
4250         abort ();
4251
4252       in.r_extern = 0;
4253     }
4254
4255   /* Let the BFD backend adjust the reloc.  */
4256   (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in);
4257
4258   /* Get some memory and swap out the reloc.  */
4259   external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
4260   rbuf = bfd_malloc (external_reloc_size);
4261   if (rbuf == NULL)
4262     return FALSE;
4263
4264   (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (void *) rbuf);
4265
4266   pos = (output_section->rel_filepos
4267          + output_section->reloc_count * external_reloc_size);
4268   ok = (bfd_seek (output_bfd, pos, SEEK_SET) == 0
4269         && (bfd_bwrite ((void *) rbuf, external_reloc_size, output_bfd)
4270             == external_reloc_size));
4271
4272   if (ok)
4273     ++output_section->reloc_count;
4274
4275   free (rbuf);
4276
4277   return ok;
4278 }
4279
4280 /* Put out information for an external symbol.  These come only from
4281    the hash table.  */
4282
4283 static bfd_boolean
4284 ecoff_link_write_external (struct ecoff_link_hash_entry *h, void * data)
4285 {
4286   struct extsym_info *einfo = (struct extsym_info *) data;
4287   bfd *output_bfd = einfo->abfd;
4288   bfd_boolean strip;
4289
4290   if (h->root.type == bfd_link_hash_warning)
4291     {
4292       h = (struct ecoff_link_hash_entry *) h->root.u.i.link;
4293       if (h->root.type == bfd_link_hash_new)
4294         return TRUE;
4295     }
4296
4297   /* We need to check if this symbol is being stripped.  */
4298   if (h->root.type == bfd_link_hash_undefined
4299       || h->root.type == bfd_link_hash_undefweak)
4300     strip = FALSE;
4301   else if (einfo->info->strip == strip_all
4302            || (einfo->info->strip == strip_some
4303                && bfd_hash_lookup (einfo->info->keep_hash,
4304                                    h->root.root.string,
4305                                    FALSE, FALSE) == NULL))
4306     strip = TRUE;
4307   else
4308     strip = FALSE;
4309
4310   if (strip || h->written)
4311     return TRUE;
4312
4313   if (h->abfd == NULL)
4314     {
4315       h->esym.jmptbl = 0;
4316       h->esym.cobol_main = 0;
4317       h->esym.weakext = 0;
4318       h->esym.reserved = 0;
4319       h->esym.ifd = ifdNil;
4320       h->esym.asym.value = 0;
4321       h->esym.asym.st = stGlobal;
4322
4323       if (h->root.type != bfd_link_hash_defined
4324           && h->root.type != bfd_link_hash_defweak)
4325         h->esym.asym.sc = scAbs;
4326       else
4327         {
4328           asection *output_section;
4329           const char *name;
4330           unsigned int i;
4331           static struct
4332           {
4333             const char * name;
4334             int sc;
4335           }
4336           section_storage_classes [] =
4337           {
4338             { _TEXT,   scText   },
4339             { _DATA,   scData   },
4340             { _SDATA,  scSData  },
4341             { _RDATA,  scRData  },
4342             { _BSS,    scBss    },
4343             { _SBSS,   scSBss   },
4344             { _INIT,   scInit   },
4345             { _FINI,   scFini   },
4346             { _PDATA,  scPData  },
4347             { _XDATA,  scXData  },
4348             { _RCONST, scRConst }
4349           };
4350
4351           output_section = h->root.u.def.section->output_section;
4352           name = bfd_section_name (output_section->owner, output_section);
4353
4354           for (i = 0; i < ARRAY_SIZE (section_storage_classes); i++)
4355             if (streq (name, section_storage_classes[i].name))
4356               {
4357                 h->esym.asym.sc = section_storage_classes[i].sc;
4358                 break;
4359               }
4360
4361           if (i == ARRAY_SIZE (section_storage_classes))
4362             h->esym.asym.sc = scAbs;
4363         }
4364
4365       h->esym.asym.reserved = 0;
4366       h->esym.asym.index = indexNil;
4367     }
4368   else if (h->esym.ifd != -1)
4369     {
4370       struct ecoff_debug_info *debug;
4371
4372       /* Adjust the FDR index for the symbol by that used for the
4373          input BFD.  */
4374       debug = &ecoff_data (h->abfd)->debug_info;
4375       BFD_ASSERT (h->esym.ifd >= 0
4376                   && h->esym.ifd < debug->symbolic_header.ifdMax);
4377       h->esym.ifd = debug->ifdmap[h->esym.ifd];
4378     }
4379
4380   switch (h->root.type)
4381     {
4382     default:
4383     case bfd_link_hash_warning:
4384     case bfd_link_hash_new:
4385       abort ();
4386     case bfd_link_hash_undefined:
4387     case bfd_link_hash_undefweak:
4388       if (h->esym.asym.sc != scUndefined
4389           && h->esym.asym.sc != scSUndefined)
4390         h->esym.asym.sc = scUndefined;
4391       break;
4392     case bfd_link_hash_defined:
4393     case bfd_link_hash_defweak:
4394       if (h->esym.asym.sc == scUndefined
4395           || h->esym.asym.sc == scSUndefined)
4396         h->esym.asym.sc = scAbs;
4397       else if (h->esym.asym.sc == scCommon)
4398         h->esym.asym.sc = scBss;
4399       else if (h->esym.asym.sc == scSCommon)
4400         h->esym.asym.sc = scSBss;
4401       h->esym.asym.value = (h->root.u.def.value
4402                             + h->root.u.def.section->output_section->vma
4403                             + h->root.u.def.section->output_offset);
4404       break;
4405     case bfd_link_hash_common:
4406       if (h->esym.asym.sc != scCommon
4407           && h->esym.asym.sc != scSCommon)
4408         h->esym.asym.sc = scCommon;
4409       h->esym.asym.value = h->root.u.c.size;
4410       break;
4411     case bfd_link_hash_indirect:
4412       /* We ignore these symbols, since the indirected symbol is
4413          already in the hash table.  */
4414       return TRUE;
4415     }
4416
4417   /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4418      symbol number.  */
4419   h->indx = ecoff_data (output_bfd)->debug_info.symbolic_header.iextMax;
4420   h->written = 1;
4421
4422   return (bfd_ecoff_debug_one_external
4423           (output_bfd, &ecoff_data (output_bfd)->debug_info,
4424            &ecoff_backend (output_bfd)->debug_swap, h->root.root.string,
4425            &h->esym));
4426 }
4427
4428 /* ECOFF final link routine.  This looks through all the input BFDs
4429    and gathers together all the debugging information, and then
4430    processes all the link order information.  This may cause it to
4431    close and reopen some input BFDs; I'll see how bad this is.  */
4432
4433 bfd_boolean
4434 _bfd_ecoff_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
4435 {
4436   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
4437   struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
4438   HDRR *symhdr;
4439   void * handle;
4440   bfd *input_bfd;
4441   asection *o;
4442   struct bfd_link_order *p;
4443   struct extsym_info einfo;
4444
4445   /* We accumulate the debugging information counts in the symbolic
4446      header.  */
4447   symhdr = &debug->symbolic_header;
4448   symhdr->vstamp = 0;
4449   symhdr->ilineMax = 0;
4450   symhdr->cbLine = 0;
4451   symhdr->idnMax = 0;
4452   symhdr->ipdMax = 0;
4453   symhdr->isymMax = 0;
4454   symhdr->ioptMax = 0;
4455   symhdr->iauxMax = 0;
4456   symhdr->issMax = 0;
4457   symhdr->issExtMax = 0;
4458   symhdr->ifdMax = 0;
4459   symhdr->crfd = 0;
4460   symhdr->iextMax = 0;
4461
4462   /* We accumulate the debugging information itself in the debug_info
4463      structure.  */
4464   debug->line = NULL;
4465   debug->external_dnr = NULL;
4466   debug->external_pdr = NULL;
4467   debug->external_sym = NULL;
4468   debug->external_opt = NULL;
4469   debug->external_aux = NULL;
4470   debug->ss = NULL;
4471   debug->ssext = debug->ssext_end = NULL;
4472   debug->external_fdr = NULL;
4473   debug->external_rfd = NULL;
4474   debug->external_ext = debug->external_ext_end = NULL;
4475
4476   handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info);
4477   if (handle == NULL)
4478     return FALSE;
4479
4480   /* Accumulate the debugging symbols from each input BFD.  */
4481   for (input_bfd = info->input_bfds;
4482        input_bfd != NULL;
4483        input_bfd = input_bfd->link_next)
4484     {
4485       bfd_boolean ret;
4486
4487       if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour)
4488         {
4489           /* Arbitrarily set the symbolic header vstamp to the vstamp
4490              of the first object file in the link.  */
4491           if (symhdr->vstamp == 0)
4492             symhdr->vstamp
4493               = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp;
4494           ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info,
4495                                                    handle);
4496         }
4497       else
4498         ret = bfd_ecoff_debug_accumulate_other (handle, abfd,
4499                                                 debug, &backend->debug_swap,
4500                                                 input_bfd, info);
4501       if (! ret)
4502         return FALSE;
4503
4504       /* Combine the register masks.  */
4505       ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask;
4506       ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask;
4507       ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0];
4508       ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1];
4509       ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2];
4510       ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3];
4511     }
4512
4513   /* Write out the external symbols.  */
4514   einfo.abfd = abfd;
4515   einfo.info = info;
4516   ecoff_link_hash_traverse (ecoff_hash_table (info),
4517                             ecoff_link_write_external,
4518                             (void *) &einfo);
4519
4520   if (info->relocatable)
4521     {
4522       /* We need to make a pass over the link_orders to count up the
4523          number of relocations we will need to output, so that we know
4524          how much space they will take up.  */
4525       for (o = abfd->sections; o != NULL; o = o->next)
4526         {
4527           o->reloc_count = 0;
4528           for (p = o->map_head.link_order;
4529                p != NULL;
4530                p = p->next)
4531             if (p->type == bfd_indirect_link_order)
4532               o->reloc_count += p->u.indirect.section->reloc_count;
4533             else if (p->type == bfd_section_reloc_link_order
4534                      || p->type == bfd_symbol_reloc_link_order)
4535               ++o->reloc_count;
4536         }
4537     }
4538
4539   /* Compute the reloc and symbol file positions.  */
4540   ecoff_compute_reloc_file_positions (abfd);
4541
4542   /* Write out the debugging information.  */
4543   if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug,
4544                                            &backend->debug_swap, info,
4545                                            ecoff_data (abfd)->sym_filepos))
4546     return FALSE;
4547
4548   bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info);
4549
4550   if (info->relocatable)
4551     {
4552       /* Now reset the reloc_count field of the sections in the output
4553          BFD to 0, so that we can use them to keep track of how many
4554          relocs we have output thus far.  */
4555       for (o = abfd->sections; o != NULL; o = o->next)
4556         o->reloc_count = 0;
4557     }
4558
4559   /* Get a value for the GP register.  */
4560   if (ecoff_data (abfd)->gp == 0)
4561     {
4562       struct bfd_link_hash_entry *h;
4563
4564       h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
4565       if (h != NULL
4566           && h->type == bfd_link_hash_defined)
4567         ecoff_data (abfd)->gp = (h->u.def.value
4568                                  + h->u.def.section->output_section->vma
4569                                  + h->u.def.section->output_offset);
4570       else if (info->relocatable)
4571         {
4572           bfd_vma lo;
4573
4574           /* Make up a value.  */
4575           lo = (bfd_vma) -1;
4576           for (o = abfd->sections; o != NULL; o = o->next)
4577             {
4578               if (o->vma < lo
4579                   && (streq (o->name, _SBSS)
4580                       || streq (o->name, _SDATA)
4581                       || streq (o->name, _LIT4)
4582                       || streq (o->name, _LIT8)
4583                       || streq (o->name, _LITA)))
4584                 lo = o->vma;
4585             }
4586           ecoff_data (abfd)->gp = lo + 0x8000;
4587         }
4588       else
4589         {
4590           /* If the relocate_section function needs to do a reloc
4591              involving the GP value, it should make a reloc_dangerous
4592              callback to warn that GP is not defined.  */
4593         }
4594     }
4595
4596   for (o = abfd->sections; o != NULL; o = o->next)
4597     {
4598       for (p = o->map_head.link_order;
4599            p != NULL;
4600            p = p->next)
4601         {
4602           if (p->type == bfd_indirect_link_order
4603               && (bfd_get_flavour (p->u.indirect.section->owner)
4604                   == bfd_target_ecoff_flavour))
4605             {
4606               if (! ecoff_indirect_link_order (abfd, info, o, p))
4607                 return FALSE;
4608             }
4609           else if (p->type == bfd_section_reloc_link_order
4610                    || p->type == bfd_symbol_reloc_link_order)
4611             {
4612               if (! ecoff_reloc_link_order (abfd, info, o, p))
4613                 return FALSE;
4614             }
4615           else
4616             {
4617               if (! _bfd_default_link_order (abfd, info, o, p))
4618                 return FALSE;
4619             }
4620         }
4621     }
4622
4623   bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax;
4624
4625   ecoff_data (abfd)->linker = TRUE;
4626
4627   return TRUE;
4628 }