bfd/ecoff.c

   1 /* Generic ECOFF (Extended-COFF) routines.
   2    Copyright 1990, 1991, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
   3    2002, 2003, 2004, 2005, 2006, 2007, 2008 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 3 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,
  22    MA 02110-1301, USA.  */
  23
  24 #include "sysdep.h"
  25 #include "bfd.h"
  26 #include "bfdlink.h"
  27 #include "libbfd.h"
  28 #include "aout/ar.h"
  29 #include "aout/ranlib.h"
  30 #include "aout/stab_gnu.h"
  31
  32 /* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines
  33    some other stuff which we don't want and which conflicts with stuff
  34    we do want.  */
  35 #include "libaout.h"
  36 #include "aout/aout64.h"
  37 #undef N_ABS
  38 #undef exec_hdr
  39 #undef obj_sym_filepos
  40
  41 #include "coff/internal.h"
  42 #include "coff/sym.h"
  43 #include "coff/symconst.h"
  44 #include "coff/ecoff.h"
  45 #include "libcoff.h"
  46 #include "libecoff.h"
  47 #include "libiberty.h"
  48
  49 #define streq(a, b)     (strcmp ((a), (b)) == 0)
  50 #define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0)
  51
  52 \f
  53 /* This stuff is somewhat copied from coffcode.h.  */
  54 static asection bfd_debug_section =
  55 {
  56   /* name,      id,  index, next, prev, flags, user_set_vma,       */
  57      "*DEBUG*", 0,   0,     NULL, NULL, 0,     0,
  58   /* linker_mark, linker_has_input, gc_mark,                       */
  59      0,           0,                1,
  60   /* segment_mark, sec_info_type, use_rela_p, has_tls_reloc,       */
  61      0,            0,             0,          0,
  62   /* has_gp_reloc, need_finalize_relax, reloc_done,                */
  63      0,            0,                   0,
  64   /* vma, lma, size, rawsize,                                      */
  65      0,   0,   0,    0,
  66   /* output_offset, output_section, alignment_power,               */
  67      0,             NULL,           0,
  68   /* relocation, orelocation, reloc_count, filepos, rel_filepos,   */
  69      NULL,       NULL,        0,           0,       0,
  70   /* line_filepos, userdata, contents, lineno, lineno_count,       */
  71      0,            NULL,     NULL,     NULL,   0,
  72   /* entsize, kept_section, moving_line_filepos,                   */
  73      0,       NULL,         0,
  74   /* target_index, used_by_bfd, constructor_chain, owner,          */
  75      0,            NULL,        NULL,              NULL,
  76   /* symbol,                                                       */
  77      NULL,
  78   /* symbol_ptr_ptr,                                               */
  79      NULL,
  80   /* map_head, map_tail                                            */
  81      { NULL }, { NULL }
  82 };
  83
  84 /* Create an ECOFF object.  */
  85
  86 bfd_boolean
  87 _bfd_ecoff_mkobject (bfd *abfd)
  88 {
  89   bfd_size_type amt = sizeof (ecoff_data_type);
  90
  91   abfd->tdata.ecoff_obj_data = bfd_zalloc (abfd, amt);
  92   if (abfd->tdata.ecoff_obj_data == NULL)
  93     return FALSE;
  94
  95   return TRUE;
  96 }
  97
  98 /* This is a hook called by coff_real_object_p to create any backend
  99    specific information.  */
 100
 101 void *
 102 _bfd_ecoff_mkobject_hook (bfd *abfd, void * filehdr, void * aouthdr)
 103 {
 104   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 105   struct internal_aouthdr *internal_a = (struct internal_aouthdr *) aouthdr;
 106   ecoff_data_type *ecoff;
 107
 108   if (! _bfd_ecoff_mkobject (abfd))
 109     return NULL;
 110
 111   ecoff = ecoff_data (abfd);
 112   ecoff->gp_size = 8;
 113   ecoff->sym_filepos = internal_f->f_symptr;
 114
 115   if (internal_a != NULL)
 116     {
 117       int i;
 118
 119       ecoff->text_start = internal_a->text_start;
 120       ecoff->text_end = internal_a->text_start + internal_a->tsize;
 121       ecoff->gp = internal_a->gp_value;
 122       ecoff->gprmask = internal_a->gprmask;
 123       for (i = 0; i < 4; i++)
 124         ecoff->cprmask[i] = internal_a->cprmask[i];
 125       ecoff->fprmask = internal_a->fprmask;
 126       if (internal_a->magic == ECOFF_AOUT_ZMAGIC)
 127         abfd->flags |= D_PAGED;
 128       else
 129         abfd->flags &=~ D_PAGED;
 130     }
 131
 132   /* It turns out that no special action is required by the MIPS or
 133      Alpha ECOFF backends.  They have different information in the
 134      a.out header, but we just copy it all (e.g., gprmask, cprmask and
 135      fprmask) and let the swapping routines ensure that only relevant
 136      information is written out.  */
 137
 138   return (void *) ecoff;
 139 }
 140
 141 /* Initialize a new section.  */
 142
 143 bfd_boolean
 144 _bfd_ecoff_new_section_hook (bfd *abfd, asection *section)
 145 {
 146   unsigned int i;
 147   static struct
 148   {
 149     const char * name;
 150     flagword flags;
 151   }
 152   section_flags [] =
 153   {
 154     { _TEXT,   SEC_ALLOC | SEC_CODE | SEC_LOAD },
 155     { _INIT,   SEC_ALLOC | SEC_CODE | SEC_LOAD },
 156     { _FINI,   SEC_ALLOC | SEC_CODE | SEC_LOAD },
 157     { _DATA,   SEC_ALLOC | SEC_DATA | SEC_LOAD },
 158     { _SDATA,  SEC_ALLOC | SEC_DATA | SEC_LOAD },
 159     { _RDATA,  SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
 160     { _LIT8,   SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
 161     { _LIT4,   SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
 162     { _RCONST, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
 163     { _PDATA,  SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY},
 164     { _BSS,    SEC_ALLOC},
 165     { _SBSS,   SEC_ALLOC},
 166     /* An Irix 4 shared libary.  */
 167     { _LIB,    SEC_COFF_SHARED_LIBRARY}
 168   };
 169
 170   section->alignment_power = 4;
 171
 172   for (i = 0; i < ARRAY_SIZE (section_flags); i++)
 173     if (streq (section->name, section_flags[i].name))
 174       {
 175         section->flags |= section_flags[i].flags;
 176         break;
 177       }
 178
 179
 180   /* Probably any other section name is SEC_NEVER_LOAD, but I'm
 181      uncertain about .init on some systems and I don't know how shared
 182      libraries work.  */
 183
 184   return _bfd_generic_new_section_hook (abfd, section);
 185 }
 186
 187 /* Determine the machine architecture and type.  This is called from
 188    the generic COFF routines.  It is the inverse of ecoff_get_magic,
 189    below.  This could be an ECOFF backend routine, with one version
 190    for each target, but there aren't all that many ECOFF targets.  */
 191
 192 bfd_boolean
 193 _bfd_ecoff_set_arch_mach_hook (bfd *abfd, void * filehdr)
 194 {
 195   struct internal_filehdr *internal_f = 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,
1867                            struct bfd_link_info *info ATTRIBUTE_UNUSED)
1868 {
1869   asection *current;
1870   int c;
1871   int ret;
1872
1873   c = 0;
1874   for (current = abfd->sections;
1875        current != NULL;
1876        current = current->next)
1877     ++c;
1878
1879   ret = (bfd_coff_filhsz (abfd)
1880          + bfd_coff_aoutsz (abfd)
1881          + c * bfd_coff_scnhsz (abfd));
1882   return BFD_ALIGN (ret, 16);
1883 }
1884
1885 /* Get the contents of a section.  */
1886
1887 bfd_boolean
1888 _bfd_ecoff_get_section_contents (bfd *abfd,
1889                                  asection *section,
1890                                  void * location,
1891                                  file_ptr offset,
1892                                  bfd_size_type count)
1893 {
1894   return _bfd_generic_get_section_contents (abfd, section, location,
1895                                             offset, count);
1896 }
1897
1898 /* Sort sections by VMA, but put SEC_ALLOC sections first.  This is
1899    called via qsort.  */
1900
1901 static int
1902 ecoff_sort_hdrs (const void * arg1, const void * arg2)
1903 {
1904   const asection *hdr1 = *(const asection **) arg1;
1905   const asection *hdr2 = *(const asection **) arg2;
1906
1907   if ((hdr1->flags & SEC_ALLOC) != 0)
1908     {
1909       if ((hdr2->flags & SEC_ALLOC) == 0)
1910         return -1;
1911     }
1912   else
1913     {
1914       if ((hdr2->flags & SEC_ALLOC) != 0)
1915         return 1;
1916     }
1917   if (hdr1->vma < hdr2->vma)
1918     return -1;
1919   else if (hdr1->vma > hdr2->vma)
1920     return 1;
1921   else
1922     return 0;
1923 }
1924
1925 /* Calculate the file position for each section, and set
1926    reloc_filepos.  */
1927
1928 static bfd_boolean
1929 ecoff_compute_section_file_positions (bfd *abfd)
1930 {
1931   file_ptr sofar, file_sofar;
1932   asection **sorted_hdrs;
1933   asection *current;
1934   unsigned int i;
1935   file_ptr old_sofar;
1936   bfd_boolean rdata_in_text;
1937   bfd_boolean first_data, first_nonalloc;
1938   const bfd_vma round = ecoff_backend (abfd)->round;
1939   bfd_size_type amt;
1940
1941   sofar = _bfd_ecoff_sizeof_headers (abfd, NULL);
1942   file_sofar = sofar;
1943
1944   /* Sort the sections by VMA.  */
1945   amt = abfd->section_count;
1946   amt *= sizeof (asection *);
1947   sorted_hdrs = bfd_malloc (amt);
1948   if (sorted_hdrs == NULL)
1949     return FALSE;
1950   for (current = abfd->sections, i = 0;
1951        current != NULL;
1952        current = current->next, i++)
1953     sorted_hdrs[i] = current;
1954   BFD_ASSERT (i == abfd->section_count);
1955
1956   qsort (sorted_hdrs, abfd->section_count, sizeof (asection *),
1957          ecoff_sort_hdrs);
1958
1959   /* Some versions of the OSF linker put the .rdata section in the
1960      text segment, and some do not.  */
1961   rdata_in_text = ecoff_backend (abfd)->rdata_in_text;
1962   if (rdata_in_text)
1963     {
1964       for (i = 0; i < abfd->section_count; i++)
1965         {
1966           current = sorted_hdrs[i];
1967           if (streq (current->name, _RDATA))
1968             break;
1969           if ((current->flags & SEC_CODE) == 0
1970               && ! streq (current->name, _PDATA)
1971               && ! streq (current->name, _RCONST))
1972             {
1973               rdata_in_text = FALSE;
1974               break;
1975             }
1976         }
1977     }
1978   ecoff_data (abfd)->rdata_in_text = rdata_in_text;
1979
1980   first_data = TRUE;
1981   first_nonalloc = TRUE;
1982   for (i = 0; i < abfd->section_count; i++)
1983     {
1984       unsigned int alignment_power;
1985
1986       current = sorted_hdrs[i];
1987
1988       /* For the Alpha ECOFF .pdata section the lnnoptr field is
1989          supposed to indicate the number of .pdata entries that are
1990          really in the section.  Each entry is 8 bytes.  We store this
1991          away in line_filepos before increasing the section size.  */
1992       if (streq (current->name, _PDATA))
1993         current->line_filepos = current->size / 8;
1994
1995       alignment_power = current->alignment_power;
1996
1997       /* On Ultrix, the data sections in an executable file must be
1998          aligned to a page boundary within the file.  This does not
1999          affect the section size, though.  FIXME: Does this work for
2000          other platforms?  It requires some modification for the
2001          Alpha, because .rdata on the Alpha goes with the text, not
2002          the data.  */
2003       if ((abfd->flags & EXEC_P) != 0
2004           && (abfd->flags & D_PAGED) != 0
2005           && ! first_data
2006           && (current->flags & SEC_CODE) == 0
2007           && (! rdata_in_text
2008               || ! streq (current->name, _RDATA))
2009           && ! streq (current->name, _PDATA)
2010           && ! streq (current->name, _RCONST))
2011         {
2012           sofar = (sofar + round - 1) &~ (round - 1);
2013           file_sofar = (file_sofar + round - 1) &~ (round - 1);
2014           first_data = FALSE;
2015         }
2016       else if (streq (current->name, _LIB))
2017         {
2018           /* On Irix 4, the location of contents of the .lib section
2019              from a shared library section is also rounded up to a
2020              page boundary.  */
2021
2022           sofar = (sofar + round - 1) &~ (round - 1);
2023           file_sofar = (file_sofar + round - 1) &~ (round - 1);
2024         }
2025       else if (first_nonalloc
2026                && (current->flags & SEC_ALLOC) == 0
2027                && (abfd->flags & D_PAGED) != 0)
2028         {
2029           /* Skip up to the next page for an unallocated section, such
2030              as the .comment section on the Alpha.  This leaves room
2031              for the .bss section.  */
2032           first_nonalloc = FALSE;
2033           sofar = (sofar + round - 1) &~ (round - 1);
2034           file_sofar = (file_sofar + round - 1) &~ (round - 1);
2035         }
2036
2037       /* Align the sections in the file to the same boundary on
2038          which they are aligned in virtual memory.  */
2039       sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2040       if ((current->flags & SEC_HAS_CONTENTS) != 0)
2041         file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power);
2042
2043       if ((abfd->flags & D_PAGED) != 0
2044           && (current->flags & SEC_ALLOC) != 0)
2045         {
2046           sofar += (current->vma - sofar) % round;
2047           if ((current->flags & SEC_HAS_CONTENTS) != 0)
2048             file_sofar += (current->vma - file_sofar) % round;
2049         }
2050
2051       if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) != 0)
2052         current->filepos = file_sofar;
2053
2054       sofar += current->size;
2055       if ((current->flags & SEC_HAS_CONTENTS) != 0)
2056         file_sofar += current->size;
2057
2058       /* Make sure that this section is of the right size too.  */
2059       old_sofar = sofar;
2060       sofar = BFD_ALIGN (sofar, 1 << alignment_power);
2061       if ((current->flags & SEC_HAS_CONTENTS) != 0)
2062         file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power);
2063       current->size += sofar - old_sofar;
2064     }
2065
2066   free (sorted_hdrs);
2067   sorted_hdrs = NULL;
2068
2069   ecoff_data (abfd)->reloc_filepos = file_sofar;
2070
2071   return TRUE;
2072 }
2073
2074 /* Determine the location of the relocs for all the sections in the
2075    output file, as well as the location of the symbolic debugging
2076    information.  */
2077
2078 static bfd_size_type
2079 ecoff_compute_reloc_file_positions (bfd *abfd)
2080 {
2081   const bfd_size_type external_reloc_size =
2082     ecoff_backend (abfd)->external_reloc_size;
2083   file_ptr reloc_base;
2084   bfd_size_type reloc_size;
2085   asection *current;
2086   file_ptr sym_base;
2087
2088   if (! abfd->output_has_begun)
2089     {
2090       if (! ecoff_compute_section_file_positions (abfd))
2091         abort ();
2092       abfd->output_has_begun = TRUE;
2093     }
2094
2095   reloc_base = ecoff_data (abfd)->reloc_filepos;
2096
2097   reloc_size = 0;
2098   for (current = abfd->sections;
2099        current != NULL;
2100        current = current->next)
2101     {
2102       if (current->reloc_count == 0)
2103         current->rel_filepos = 0;
2104       else
2105         {
2106           bfd_size_type relsize;
2107
2108           current->rel_filepos = reloc_base;
2109           relsize = current->reloc_count * external_reloc_size;
2110           reloc_size += relsize;
2111           reloc_base += relsize;
2112         }
2113     }
2114
2115   sym_base = ecoff_data (abfd)->reloc_filepos + reloc_size;
2116
2117   /* At least on Ultrix, the symbol table of an executable file must
2118      be aligned to a page boundary.  FIXME: Is this true on other
2119      platforms?  */
2120   if ((abfd->flags & EXEC_P) != 0
2121       && (abfd->flags & D_PAGED) != 0)
2122     sym_base = ((sym_base + ecoff_backend (abfd)->round - 1)
2123                 &~ (ecoff_backend (abfd)->round - 1));
2124
2125   ecoff_data (abfd)->sym_filepos = sym_base;
2126
2127   return reloc_size;
2128 }
2129
2130 /* Set the contents of a section.  */
2131
2132 bfd_boolean
2133 _bfd_ecoff_set_section_contents (bfd *abfd,
2134                                  asection *section,
2135                                  const void * location,
2136                                  file_ptr offset,
2137                                  bfd_size_type count)
2138 {
2139   file_ptr pos;
2140
2141   /* This must be done first, because bfd_set_section_contents is
2142      going to set output_has_begun to TRUE.  */
2143   if (! abfd->output_has_begun
2144       && ! ecoff_compute_section_file_positions (abfd))
2145     return FALSE;
2146
2147   /* Handle the .lib section specially so that Irix 4 shared libraries
2148      work out.  See coff_set_section_contents in coffcode.h.  */
2149   if (streq (section->name, _LIB))
2150     {
2151       bfd_byte *rec, *recend;
2152
2153       rec = (bfd_byte *) location;
2154       recend = rec + count;
2155       while (rec < recend)
2156         {
2157           ++section->lma;
2158           rec += bfd_get_32 (abfd, rec) * 4;
2159         }
2160
2161       BFD_ASSERT (rec == recend);
2162     }
2163
2164   if (count == 0)
2165     return TRUE;
2166
2167   pos = section->filepos + offset;
2168   if (bfd_seek (abfd, pos, SEEK_SET) != 0
2169       || bfd_bwrite (location, count, abfd) != count)
2170     return FALSE;
2171
2172   return TRUE;
2173 }
2174
2175 /* Get the GP value for an ECOFF file.  This is a hook used by
2176    nlmconv.  */
2177
2178 bfd_vma
2179 bfd_ecoff_get_gp_value (bfd *abfd)
2180 {
2181   if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2182       || bfd_get_format (abfd) != bfd_object)
2183     {
2184       bfd_set_error (bfd_error_invalid_operation);
2185       return 0;
2186     }
2187
2188   return ecoff_data (abfd)->gp;
2189 }
2190
2191 /* Set the GP value for an ECOFF file.  This is a hook used by the
2192    assembler.  */
2193
2194 bfd_boolean
2195 bfd_ecoff_set_gp_value (bfd *abfd, bfd_vma gp_value)
2196 {
2197   if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2198       || bfd_get_format (abfd) != bfd_object)
2199     {
2200       bfd_set_error (bfd_error_invalid_operation);
2201       return FALSE;
2202     }
2203
2204   ecoff_data (abfd)->gp = gp_value;
2205
2206   return TRUE;
2207 }
2208
2209 /* Set the register masks for an ECOFF file.  This is a hook used by
2210    the assembler.  */
2211
2212 bfd_boolean
2213 bfd_ecoff_set_regmasks (bfd *abfd,
2214                         unsigned long gprmask,
2215                         unsigned long fprmask,
2216                         unsigned long *cprmask)
2217 {
2218   ecoff_data_type *tdata;
2219
2220   if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour
2221       || bfd_get_format (abfd) != bfd_object)
2222     {
2223       bfd_set_error (bfd_error_invalid_operation);
2224       return FALSE;
2225     }
2226
2227   tdata = ecoff_data (abfd);
2228   tdata->gprmask = gprmask;
2229   tdata->fprmask = fprmask;
2230   if (cprmask != NULL)
2231     {
2232       int i;
2233
2234       for (i = 0; i < 3; i++)
2235         tdata->cprmask[i] = cprmask[i];
2236     }
2237
2238   return TRUE;
2239 }
2240
2241 /* Get ECOFF EXTR information for an external symbol.  This function
2242    is passed to bfd_ecoff_debug_externals.  */
2243
2244 static bfd_boolean
2245 ecoff_get_extr (asymbol *sym, EXTR *esym)
2246 {
2247   ecoff_symbol_type *ecoff_sym_ptr;
2248   bfd *input_bfd;
2249
2250   if (bfd_asymbol_flavour (sym) != bfd_target_ecoff_flavour
2251       || ecoffsymbol (sym)->native == NULL)
2252     {
2253       /* Don't include debugging, local, or section symbols.  */
2254       if ((sym->flags & BSF_DEBUGGING) != 0
2255           || (sym->flags & BSF_LOCAL) != 0
2256           || (sym->flags & BSF_SECTION_SYM) != 0)
2257         return FALSE;
2258
2259       esym->jmptbl = 0;
2260       esym->cobol_main = 0;
2261       esym->weakext = (sym->flags & BSF_WEAK) != 0;
2262       esym->reserved = 0;
2263       esym->ifd = ifdNil;
2264       /* FIXME: we can do better than this for st and sc.  */
2265       esym->asym.st = stGlobal;
2266       esym->asym.sc = scAbs;
2267       esym->asym.reserved = 0;
2268       esym->asym.index = indexNil;
2269       return TRUE;
2270     }
2271
2272   ecoff_sym_ptr = ecoffsymbol (sym);
2273
2274   if (ecoff_sym_ptr->local)
2275     return FALSE;
2276
2277   input_bfd = bfd_asymbol_bfd (sym);
2278   (*(ecoff_backend (input_bfd)->debug_swap.swap_ext_in))
2279     (input_bfd, ecoff_sym_ptr->native, esym);
2280
2281   /* If the symbol was defined by the linker, then esym will be
2282      undefined but sym will not be.  Get a better class for such a
2283      symbol.  */
2284   if ((esym->asym.sc == scUndefined
2285        || esym->asym.sc == scSUndefined)
2286       && ! bfd_is_und_section (bfd_get_section (sym)))
2287     esym->asym.sc = scAbs;
2288
2289   /* Adjust the FDR index for the symbol by that used for the input
2290      BFD.  */
2291   if (esym->ifd != -1)
2292     {
2293       struct ecoff_debug_info *input_debug;
2294
2295       input_debug = &ecoff_data (input_bfd)->debug_info;
2296       BFD_ASSERT (esym->ifd < input_debug->symbolic_header.ifdMax);
2297       if (input_debug->ifdmap != NULL)
2298         esym->ifd = input_debug->ifdmap[esym->ifd];
2299     }
2300
2301   return TRUE;
2302 }
2303
2304 /* Set the external symbol index.  This routine is passed to
2305    bfd_ecoff_debug_externals.  */
2306
2307 static void
2308 ecoff_set_index (asymbol *sym, bfd_size_type indx)
2309 {
2310   ecoff_set_sym_index (sym, indx);
2311 }
2312
2313 /* Write out an ECOFF file.  */
2314
2315 bfd_boolean
2316 _bfd_ecoff_write_object_contents (bfd *abfd)
2317 {
2318   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
2319   const bfd_vma round = backend->round;
2320   const bfd_size_type filhsz = bfd_coff_filhsz (abfd);
2321   const bfd_size_type aoutsz = bfd_coff_aoutsz (abfd);
2322   const bfd_size_type scnhsz = bfd_coff_scnhsz (abfd);
2323   const bfd_size_type external_hdr_size
2324     = backend->debug_swap.external_hdr_size;
2325   const bfd_size_type external_reloc_size = backend->external_reloc_size;
2326   void (* const adjust_reloc_out) (bfd *, const arelent *, struct internal_reloc *)
2327     = backend->adjust_reloc_out;
2328   void (* const swap_reloc_out) (bfd *, const struct internal_reloc *, void *)
2329     = backend->swap_reloc_out;
2330   struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
2331   HDRR * const symhdr = &debug->symbolic_header;
2332   asection *current;
2333   unsigned int count;
2334   bfd_size_type reloc_size;
2335   bfd_size_type text_size;
2336   bfd_vma text_start;
2337   bfd_boolean set_text_start;
2338   bfd_size_type data_size;
2339   bfd_vma data_start;
2340   bfd_boolean set_data_start;
2341   bfd_size_type bss_size;
2342   void * buff = NULL;
2343   void * reloc_buff = NULL;
2344   struct internal_filehdr internal_f;
2345   struct internal_aouthdr internal_a;
2346   int i;
2347
2348   /* Determine where the sections and relocs will go in the output
2349      file.  */
2350   reloc_size = ecoff_compute_reloc_file_positions (abfd);
2351
2352   count = 1;
2353   for (current = abfd->sections;
2354        current != NULL;
2355        current = current->next)
2356     {
2357       current->target_index = count;
2358       ++count;
2359     }
2360
2361   if ((abfd->flags & D_PAGED) != 0)
2362     text_size = _bfd_ecoff_sizeof_headers (abfd, NULL);
2363   else
2364     text_size = 0;
2365   text_start = 0;
2366   set_text_start = FALSE;
2367   data_size = 0;
2368   data_start = 0;
2369   set_data_start = FALSE;
2370   bss_size = 0;
2371
2372   /* Write section headers to the file.  */
2373
2374   /* Allocate buff big enough to hold a section header,
2375      file header, or a.out header.  */
2376   {
2377     bfd_size_type siz;
2378
2379     siz = scnhsz;
2380     if (siz < filhsz)
2381       siz = filhsz;
2382     if (siz < aoutsz)
2383       siz = aoutsz;
2384     buff = bfd_malloc (siz);
2385     if (buff == NULL)
2386       goto error_return;
2387   }
2388
2389   internal_f.f_nscns = 0;
2390   if (bfd_seek (abfd, (file_ptr) (filhsz + aoutsz), SEEK_SET) != 0)
2391     goto error_return;
2392
2393   for (current = abfd->sections;
2394        current != NULL;
2395        current = current->next)
2396     {
2397       struct internal_scnhdr section;
2398       bfd_vma vma;
2399
2400       ++internal_f.f_nscns;
2401
2402       strncpy (section.s_name, current->name, sizeof section.s_name);
2403
2404       /* This seems to be correct for Irix 4 shared libraries.  */
2405       vma = bfd_get_section_vma (abfd, current);
2406       if (streq (current->name, _LIB))
2407         section.s_vaddr = 0;
2408       else
2409         section.s_vaddr = vma;
2410
2411       section.s_paddr = current->lma;
2412       section.s_size = current->size;
2413
2414       /* If this section is unloadable then the scnptr will be 0.  */
2415       if ((current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2416         section.s_scnptr = 0;
2417       else
2418         section.s_scnptr = current->filepos;
2419       section.s_relptr = current->rel_filepos;
2420
2421       /* FIXME: the lnnoptr of the .sbss or .sdata section of an
2422          object file produced by the assembler is supposed to point to
2423          information about how much room is required by objects of
2424          various different sizes.  I think this only matters if we
2425          want the linker to compute the best size to use, or
2426          something.  I don't know what happens if the information is
2427          not present.  */
2428       if (! streq (current->name, _PDATA))
2429         section.s_lnnoptr = 0;
2430       else
2431         {
2432           /* The Alpha ECOFF .pdata section uses the lnnoptr field to
2433              hold the number of entries in the section (each entry is
2434              8 bytes).  We stored this in the line_filepos field in
2435              ecoff_compute_section_file_positions.  */
2436           section.s_lnnoptr = current->line_filepos;
2437         }
2438
2439       section.s_nreloc = current->reloc_count;
2440       section.s_nlnno = 0;
2441       section.s_flags = ecoff_sec_to_styp_flags (current->name,
2442                                                  current->flags);
2443
2444       if (bfd_coff_swap_scnhdr_out (abfd, (void *) &section, buff) == 0
2445           || bfd_bwrite (buff, scnhsz, abfd) != scnhsz)
2446         goto error_return;
2447
2448       if ((section.s_flags & STYP_TEXT) != 0
2449           || ((section.s_flags & STYP_RDATA) != 0
2450               && ecoff_data (abfd)->rdata_in_text)
2451           || section.s_flags == STYP_PDATA
2452           || (section.s_flags & STYP_DYNAMIC) != 0
2453           || (section.s_flags & STYP_LIBLIST) != 0
2454           || (section.s_flags & STYP_RELDYN) != 0
2455           || section.s_flags == STYP_CONFLIC
2456           || (section.s_flags & STYP_DYNSTR) != 0
2457           || (section.s_flags & STYP_DYNSYM) != 0
2458           || (section.s_flags & STYP_HASH) != 0
2459           || (section.s_flags & STYP_ECOFF_INIT) != 0
2460           || (section.s_flags & STYP_ECOFF_FINI) != 0
2461           || section.s_flags == STYP_RCONST)
2462         {
2463           text_size += current->size;
2464           if (! set_text_start || text_start > vma)
2465             {
2466               text_start = vma;
2467               set_text_start = TRUE;
2468             }
2469         }
2470       else if ((section.s_flags & STYP_RDATA) != 0
2471                || (section.s_flags & STYP_DATA) != 0
2472                || (section.s_flags & STYP_LITA) != 0
2473                || (section.s_flags & STYP_LIT8) != 0
2474                || (section.s_flags & STYP_LIT4) != 0
2475                || (section.s_flags & STYP_SDATA) != 0
2476                || section.s_flags == STYP_XDATA
2477                || (section.s_flags & STYP_GOT) != 0)
2478         {
2479           data_size += current->size;
2480           if (! set_data_start || data_start > vma)
2481             {
2482               data_start = vma;
2483               set_data_start = TRUE;
2484             }
2485         }
2486       else if ((section.s_flags & STYP_BSS) != 0
2487                || (section.s_flags & STYP_SBSS) != 0)
2488         bss_size += current->size;
2489       else if (section.s_flags == 0
2490                || (section.s_flags & STYP_ECOFF_LIB) != 0
2491                || section.s_flags == STYP_COMMENT)
2492         /* Do nothing.  */ ;
2493       else
2494         abort ();
2495     }
2496
2497   /* Set up the file header.  */
2498   internal_f.f_magic = ecoff_get_magic (abfd);
2499
2500   /* We will NOT put a fucking timestamp in the header here. Every
2501      time you put it back, I will come in and take it out again.  I'm
2502      sorry.  This field does not belong here.  We fill it with a 0 so
2503      it compares the same but is not a reasonable time. --
2504      gnu@cygnus.com.  */
2505   internal_f.f_timdat = 0;
2506
2507   if (bfd_get_symcount (abfd) != 0)
2508     {
2509       /* The ECOFF f_nsyms field is not actually the number of
2510          symbols, it's the size of symbolic information header.  */
2511       internal_f.f_nsyms = external_hdr_size;
2512       internal_f.f_symptr = ecoff_data (abfd)->sym_filepos;
2513     }
2514   else
2515     {
2516       internal_f.f_nsyms = 0;
2517       internal_f.f_symptr = 0;
2518     }
2519
2520   internal_f.f_opthdr = aoutsz;
2521
2522   internal_f.f_flags = F_LNNO;
2523   if (reloc_size == 0)
2524     internal_f.f_flags |= F_RELFLG;
2525   if (bfd_get_symcount (abfd) == 0)
2526     internal_f.f_flags |= F_LSYMS;
2527   if (abfd->flags & EXEC_P)
2528     internal_f.f_flags |= F_EXEC;
2529
2530   if (bfd_little_endian (abfd))
2531     internal_f.f_flags |= F_AR32WR;
2532   else
2533     internal_f.f_flags |= F_AR32W;
2534
2535   /* Set up the ``optional'' header.  */
2536   if ((abfd->flags & D_PAGED) != 0)
2537     internal_a.magic = ECOFF_AOUT_ZMAGIC;
2538   else
2539     internal_a.magic = ECOFF_AOUT_OMAGIC;
2540
2541   /* FIXME: Is this really correct?  */
2542   internal_a.vstamp = symhdr->vstamp;
2543
2544   /* At least on Ultrix, these have to be rounded to page boundaries.
2545      FIXME: Is this true on other platforms?  */
2546   if ((abfd->flags & D_PAGED) != 0)
2547     {
2548       internal_a.tsize = (text_size + round - 1) &~ (round - 1);
2549       internal_a.text_start = text_start &~ (round - 1);
2550       internal_a.dsize = (data_size + round - 1) &~ (round - 1);
2551       internal_a.data_start = data_start &~ (round - 1);
2552     }
2553   else
2554     {
2555       internal_a.tsize = text_size;
2556       internal_a.text_start = text_start;
2557       internal_a.dsize = data_size;
2558       internal_a.data_start = data_start;
2559     }
2560
2561   /* On Ultrix, the initial portions of the .sbss and .bss segments
2562      are at the end of the data section.  The bsize field in the
2563      optional header records how many bss bytes are required beyond
2564      those in the data section.  The value is not rounded to a page
2565      boundary.  */
2566   if (bss_size < internal_a.dsize - data_size)
2567     bss_size = 0;
2568   else
2569     bss_size -= internal_a.dsize - data_size;
2570   internal_a.bsize = bss_size;
2571   internal_a.bss_start = internal_a.data_start + internal_a.dsize;
2572
2573   internal_a.entry = bfd_get_start_address (abfd);
2574
2575   internal_a.gp_value = ecoff_data (abfd)->gp;
2576
2577   internal_a.gprmask = ecoff_data (abfd)->gprmask;
2578   internal_a.fprmask = ecoff_data (abfd)->fprmask;
2579   for (i = 0; i < 4; i++)
2580     internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i];
2581
2582   /* Let the backend adjust the headers if necessary.  */
2583   if (backend->adjust_headers)
2584     {
2585       if (! (*backend->adjust_headers) (abfd, &internal_f, &internal_a))
2586         goto error_return;
2587     }
2588
2589   /* Write out the file header and the optional header.  */
2590   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
2591     goto error_return;
2592
2593   bfd_coff_swap_filehdr_out (abfd, (void *) &internal_f, buff);
2594   if (bfd_bwrite (buff, filhsz, abfd) != filhsz)
2595     goto error_return;
2596
2597   bfd_coff_swap_aouthdr_out (abfd, (void *) &internal_a, buff);
2598   if (bfd_bwrite (buff, aoutsz, abfd) != aoutsz)
2599     goto error_return;
2600
2601   /* Build the external symbol information.  This must be done before
2602      writing out the relocs so that we know the symbol indices.  We
2603      don't do this if this BFD was created by the backend linker,
2604      since it will have already handled the symbols and relocs.  */
2605   if (! ecoff_data (abfd)->linker)
2606     {
2607       symhdr->iextMax = 0;
2608       symhdr->issExtMax = 0;
2609       debug->external_ext = debug->external_ext_end = NULL;
2610       debug->ssext = debug->ssext_end = NULL;
2611       if (! bfd_ecoff_debug_externals (abfd, debug, &backend->debug_swap,
2612                                        (abfd->flags & EXEC_P) == 0,
2613                                        ecoff_get_extr, ecoff_set_index))
2614         goto error_return;
2615
2616       /* Write out the relocs.  */
2617       for (current = abfd->sections;
2618            current != NULL;
2619            current = current->next)
2620         {
2621           arelent **reloc_ptr_ptr;
2622           arelent **reloc_end;
2623           char *out_ptr;
2624           bfd_size_type amt;
2625
2626           if (current->reloc_count == 0)
2627             continue;
2628
2629           amt = current->reloc_count * external_reloc_size;
2630           reloc_buff = bfd_alloc (abfd, amt);
2631           if (reloc_buff == NULL)
2632             goto error_return;
2633
2634           reloc_ptr_ptr = current->orelocation;
2635           reloc_end = reloc_ptr_ptr + current->reloc_count;
2636           out_ptr = (char *) reloc_buff;
2637
2638           for (;
2639                reloc_ptr_ptr < reloc_end;
2640                reloc_ptr_ptr++, out_ptr += external_reloc_size)
2641             {
2642               arelent *reloc;
2643               asymbol *sym;
2644               struct internal_reloc in;
2645
2646               memset ((void *) &in, 0, sizeof in);
2647
2648               reloc = *reloc_ptr_ptr;
2649               sym = *reloc->sym_ptr_ptr;
2650
2651               /* If the howto field has not been initialised then skip this reloc.
2652                  This assumes that an error message has been issued elsewhere.  */
2653               if (reloc->howto == NULL)
2654                 continue;
2655
2656               in.r_vaddr = (reloc->address
2657                             + bfd_get_section_vma (abfd, current));
2658               in.r_type = reloc->howto->type;
2659
2660               if ((sym->flags & BSF_SECTION_SYM) == 0)
2661                 {
2662                   in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr);
2663                   in.r_extern = 1;
2664                 }
2665               else
2666                 {
2667                   const char *name;
2668                   unsigned int i;
2669                   static struct
2670                   {
2671                     const char * name;
2672                     long r_symndx;
2673                   }
2674                   section_symndx [] =
2675                   {
2676                     { _TEXT,   RELOC_SECTION_TEXT   },
2677                     { _RDATA,  RELOC_SECTION_RDATA  },
2678                     { _DATA,   RELOC_SECTION_DATA   },
2679                     { _SDATA,  RELOC_SECTION_SDATA  },
2680                     { _SBSS,   RELOC_SECTION_SBSS   },
2681                     { _BSS,    RELOC_SECTION_BSS    },
2682                     { _INIT,   RELOC_SECTION_INIT   },
2683                     { _LIT8,   RELOC_SECTION_LIT8   },
2684                     { _LIT4,   RELOC_SECTION_LIT4   },
2685                     { _XDATA,  RELOC_SECTION_XDATA  },
2686                     { _PDATA,  RELOC_SECTION_PDATA  },
2687                     { _FINI,   RELOC_SECTION_FINI   },
2688                     { _LITA,   RELOC_SECTION_LITA   },
2689                     { "*ABS*", RELOC_SECTION_ABS    },
2690                     { _RCONST, RELOC_SECTION_RCONST }
2691                   };
2692
2693                   name = bfd_get_section_name (abfd, bfd_get_section (sym));
2694
2695                   for (i = 0; i < ARRAY_SIZE (section_symndx); i++)
2696                     if (streq (name, section_symndx[i].name))
2697                       {
2698                         in.r_symndx = section_symndx[i].r_symndx;
2699                         break;
2700                       }
2701
2702                   if (i == ARRAY_SIZE (section_symndx))
2703                     abort ();
2704                   in.r_extern = 0;
2705                 }
2706
2707               (*adjust_reloc_out) (abfd, reloc, &in);
2708
2709               (*swap_reloc_out) (abfd, &in, (void *) out_ptr);
2710             }
2711
2712           if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0)
2713             goto error_return;
2714           amt = current->reloc_count * external_reloc_size;
2715           if (bfd_bwrite (reloc_buff, amt, abfd) != amt)
2716             goto error_return;
2717           bfd_release (abfd, reloc_buff);
2718           reloc_buff = NULL;
2719         }
2720
2721       /* Write out the symbolic debugging information.  */
2722       if (bfd_get_symcount (abfd) > 0)
2723         {
2724           /* Write out the debugging information.  */
2725           if (! bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap,
2726                                        ecoff_data (abfd)->sym_filepos))
2727             goto error_return;
2728         }
2729     }
2730
2731   /* The .bss section of a demand paged executable must receive an
2732      entire page.  If there are symbols, the symbols will start on the
2733      next page.  If there are no symbols, we must fill out the page by
2734      hand.  */
2735   if (bfd_get_symcount (abfd) == 0
2736       && (abfd->flags & EXEC_P) != 0
2737       && (abfd->flags & D_PAGED) != 0)
2738     {
2739       char c;
2740
2741       if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2742                     SEEK_SET) != 0)
2743         goto error_return;
2744       if (bfd_bread (&c, (bfd_size_type) 1, abfd) == 0)
2745         c = 0;
2746       if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
2747                     SEEK_SET) != 0)
2748         goto error_return;
2749       if (bfd_bwrite (&c, (bfd_size_type) 1, abfd) != 1)
2750         goto error_return;
2751     }
2752
2753   if (reloc_buff != NULL)
2754     bfd_release (abfd, reloc_buff);
2755   if (buff != NULL)
2756     free (buff);
2757   return TRUE;
2758  error_return:
2759   if (reloc_buff != NULL)
2760     bfd_release (abfd, reloc_buff);
2761   if (buff != NULL)
2762     free (buff);
2763   return FALSE;
2764 }
2765 \f
2766 /* Archive handling.  ECOFF uses what appears to be a unique type of
2767    archive header (armap).  The byte ordering of the armap and the
2768    contents are encoded in the name of the armap itself.  At least for
2769    now, we only support archives with the same byte ordering in the
2770    armap and the contents.
2771
2772    The first four bytes in the armap are the number of symbol
2773    definitions.  This is always a power of two.
2774
2775    This is followed by the symbol definitions.  Each symbol definition
2776    occupies 8 bytes.  The first four bytes are the offset from the
2777    start of the armap strings to the null-terminated string naming
2778    this symbol.  The second four bytes are the file offset to the
2779    archive member which defines this symbol.  If the second four bytes
2780    are 0, then this is not actually a symbol definition, and it should
2781    be ignored.
2782
2783    The symbols are hashed into the armap with a closed hashing scheme.
2784    See the functions below for the details of the algorithm.
2785
2786    After the symbol definitions comes four bytes holding the size of
2787    the string table, followed by the string table itself.  */
2788
2789 /* The name of an archive headers looks like this:
2790    __________E[BL]E[BL]_ (with a trailing space).
2791    The trailing space is changed to an X if the archive is changed to
2792    indicate that the armap is out of date.
2793
2794    The Alpha seems to use ________64E[BL]E[BL]_.  */
2795
2796 #define ARMAP_BIG_ENDIAN                'B'
2797 #define ARMAP_LITTLE_ENDIAN             'L'
2798 #define ARMAP_MARKER                    'E'
2799 #define ARMAP_START_LENGTH              10
2800 #define ARMAP_HEADER_MARKER_INDEX       10
2801 #define ARMAP_HEADER_ENDIAN_INDEX       11
2802 #define ARMAP_OBJECT_MARKER_INDEX       12
2803 #define ARMAP_OBJECT_ENDIAN_INDEX       13
2804 #define ARMAP_END_INDEX                 14
2805 #define ARMAP_END                       "_ "
2806
2807 /* This is a magic number used in the hashing algorithm.  */
2808 #define ARMAP_HASH_MAGIC                0x9dd68ab5
2809
2810 /* This returns the hash value to use for a string.  It also sets
2811    *REHASH to the rehash adjustment if the first slot is taken.  SIZE
2812    is the number of entries in the hash table, and HLOG is the log
2813    base 2 of SIZE.  */
2814
2815 static unsigned int
2816 ecoff_armap_hash (const char *s,
2817                   unsigned int *rehash,
2818                   unsigned int size,
2819                   unsigned int hlog)
2820 {
2821   unsigned int hash;
2822
2823   if (hlog == 0)
2824     return 0;
2825   hash = *s++;
2826   while (*s != '\0')
2827     hash = ((hash >> 27) | (hash << 5)) + *s++;
2828   hash *= ARMAP_HASH_MAGIC;
2829   *rehash = (hash & (size - 1)) | 1;
2830   return hash >> (32 - hlog);
2831 }
2832
2833 /* Read in the armap.  */
2834
2835 bfd_boolean
2836 _bfd_ecoff_slurp_armap (bfd *abfd)
2837 {
2838   char nextname[17];
2839   unsigned int i;
2840   struct areltdata *mapdata;
2841   bfd_size_type parsed_size;
2842   char *raw_armap;
2843   struct artdata *ardata;
2844   unsigned int count;
2845   char *raw_ptr;
2846   struct symdef *symdef_ptr;
2847   char *stringbase;
2848   bfd_size_type amt;
2849
2850   /* Get the name of the first element.  */
2851   i = bfd_bread ((void *) nextname, (bfd_size_type) 16, abfd);
2852   if (i == 0)
2853       return TRUE;
2854   if (i != 16)
2855       return FALSE;
2856
2857   if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
2858     return FALSE;
2859
2860   /* Irix 4.0.5F apparently can use either an ECOFF armap or a
2861      standard COFF armap.  We could move the ECOFF armap stuff into
2862      bfd_slurp_armap, but that seems inappropriate since no other
2863      target uses this format.  Instead, we check directly for a COFF
2864      armap.  */
2865   if (CONST_STRNEQ (nextname, "/               "))
2866     return bfd_slurp_armap (abfd);
2867
2868   /* See if the first element is an armap.  */
2869   if (! strneq (nextname, ecoff_backend (abfd)->armap_start, ARMAP_START_LENGTH)
2870       || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER
2871       || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2872           && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2873       || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER
2874       || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN
2875           && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN)
2876       || ! strneq (nextname + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1))
2877     {
2878       bfd_has_map (abfd) = FALSE;
2879       return TRUE;
2880     }
2881
2882   /* Make sure we have the right byte ordering.  */
2883   if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2884        ^ (bfd_header_big_endian (abfd)))
2885       || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN)
2886           ^ (bfd_big_endian (abfd))))
2887     {
2888       bfd_set_error (bfd_error_wrong_format);
2889       return FALSE;
2890     }
2891
2892   /* Read in the armap.  */
2893   ardata = bfd_ardata (abfd);
2894   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
2895   if (mapdata == NULL)
2896     return FALSE;
2897   parsed_size = mapdata->parsed_size;
2898   bfd_release (abfd, (void *) mapdata);
2899
2900   raw_armap = bfd_alloc (abfd, parsed_size);
2901   if (raw_armap == NULL)
2902     return FALSE;
2903
2904   if (bfd_bread ((void *) raw_armap, parsed_size, abfd) != parsed_size)
2905     {
2906       if (bfd_get_error () != bfd_error_system_call)
2907         bfd_set_error (bfd_error_malformed_archive);
2908       bfd_release (abfd, (void *) raw_armap);
2909       return FALSE;
2910     }
2911
2912   ardata->tdata = (void *) raw_armap;
2913
2914   count = H_GET_32 (abfd, raw_armap);
2915
2916   ardata->symdef_count = 0;
2917   ardata->cache = NULL;
2918
2919   /* This code used to overlay the symdefs over the raw archive data,
2920      but that doesn't work on a 64 bit host.  */
2921   stringbase = raw_armap + count * 8 + 8;
2922
2923 #ifdef CHECK_ARMAP_HASH
2924   {
2925     unsigned int hlog;
2926
2927     /* Double check that I have the hashing algorithm right by making
2928        sure that every symbol can be looked up successfully.  */
2929     hlog = 0;
2930     for (i = 1; i < count; i <<= 1)
2931       hlog++;
2932     BFD_ASSERT (i == count);
2933
2934     raw_ptr = raw_armap + 4;
2935     for (i = 0; i < count; i++, raw_ptr += 8)
2936       {
2937         unsigned int name_offset, file_offset;
2938         unsigned int hash, rehash, srch;
2939
2940         name_offset = H_GET_32 (abfd, raw_ptr);
2941         file_offset = H_GET_32 (abfd, (raw_ptr + 4));
2942         if (file_offset == 0)
2943           continue;
2944         hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count,
2945                                  hlog);
2946         if (hash == i)
2947           continue;
2948
2949         /* See if we can rehash to this location.  */
2950         for (srch = (hash + rehash) & (count - 1);
2951              srch != hash && srch != i;
2952              srch = (srch + rehash) & (count - 1))
2953           BFD_ASSERT (H_GET_32 (abfd, (raw_armap + 8 + srch * 8)) != 0);
2954         BFD_ASSERT (srch == i);
2955       }
2956   }
2957
2958 #endif /* CHECK_ARMAP_HASH */
2959
2960   raw_ptr = raw_armap + 4;
2961   for (i = 0; i < count; i++, raw_ptr += 8)
2962     if (H_GET_32 (abfd, (raw_ptr + 4)) != 0)
2963       ++ardata->symdef_count;
2964
2965   amt = ardata->symdef_count;
2966   amt *= sizeof (struct symdef);
2967   symdef_ptr = bfd_alloc (abfd, amt);
2968   if (!symdef_ptr)
2969     return FALSE;
2970
2971   ardata->symdefs = (carsym *) symdef_ptr;
2972
2973   raw_ptr = raw_armap + 4;
2974   for (i = 0; i < count; i++, raw_ptr += 8)
2975     {
2976       unsigned int name_offset, file_offset;
2977
2978       file_offset = H_GET_32 (abfd, (raw_ptr + 4));
2979       if (file_offset == 0)
2980         continue;
2981       name_offset = H_GET_32 (abfd, raw_ptr);
2982       symdef_ptr->s.name = stringbase + name_offset;
2983       symdef_ptr->file_offset = file_offset;
2984       ++symdef_ptr;
2985     }
2986
2987   ardata->first_file_filepos = bfd_tell (abfd);
2988   /* Pad to an even boundary.  */
2989   ardata->first_file_filepos += ardata->first_file_filepos % 2;
2990
2991   bfd_has_map (abfd) = TRUE;
2992
2993   return TRUE;
2994 }
2995
2996 /* Write out an armap.  */
2997
2998 bfd_boolean
2999 _bfd_ecoff_write_armap (bfd *abfd,
3000                         unsigned int elength,
3001                         struct orl *map,
3002                         unsigned int orl_count,
3003                         int stridx)
3004 {
3005   unsigned int hashsize, hashlog;
3006   bfd_size_type symdefsize;
3007   int padit;
3008   unsigned int stringsize;
3009   unsigned int mapsize;
3010   file_ptr firstreal;
3011   struct ar_hdr hdr;
3012   struct stat statbuf;
3013   unsigned int i;
3014   bfd_byte temp[4];
3015   bfd_byte *hashtable;
3016   bfd *current;
3017   bfd *last_elt;
3018
3019   /* Ultrix appears to use as a hash table size the least power of two
3020      greater than twice the number of entries.  */
3021   for (hashlog = 0; ((unsigned int) 1 << hashlog) <= 2 * orl_count; hashlog++)
3022     ;
3023   hashsize = 1 << hashlog;
3024
3025   symdefsize = hashsize * 8;
3026   padit = stridx % 2;
3027   stringsize = stridx + padit;
3028
3029   /* Include 8 bytes to store symdefsize and stringsize in output.  */
3030   mapsize = symdefsize + stringsize + 8;
3031
3032   firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength;
3033
3034   memset ((void *) &hdr, 0, sizeof hdr);
3035
3036   /* Work out the ECOFF armap name.  */
3037   strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start);
3038   hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER;
3039   hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] =
3040     (bfd_header_big_endian (abfd)
3041      ? ARMAP_BIG_ENDIAN
3042      : ARMAP_LITTLE_ENDIAN);
3043   hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER;
3044   hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] =
3045     bfd_big_endian (abfd) ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN;
3046   memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1);
3047
3048   /* Write the timestamp of the archive header to be just a little bit
3049      later than the timestamp of the file, otherwise the linker will
3050      complain that the index is out of date.  Actually, the Ultrix
3051      linker just checks the archive name; the GNU linker may check the
3052      date.  */
3053   stat (abfd->filename, &statbuf);
3054   sprintf (hdr.ar_date, "%ld", (long) (statbuf.st_mtime + 60));
3055
3056   /* The DECstation uses zeroes for the uid, gid and mode of the
3057      armap.  */
3058   hdr.ar_uid[0] = '0';
3059   hdr.ar_gid[0] = '0';
3060   /* Building gcc ends up extracting the armap as a file - twice.  */
3061   hdr.ar_mode[0] = '6';
3062   hdr.ar_mode[1] = '4';
3063   hdr.ar_mode[2] = '4';
3064
3065   sprintf (hdr.ar_size, "%-10d", (int) mapsize);
3066
3067   hdr.ar_fmag[0] = '`';
3068   hdr.ar_fmag[1] = '\012';
3069
3070   /* Turn all null bytes in the header into spaces.  */
3071   for (i = 0; i < sizeof (struct ar_hdr); i++)
3072    if (((char *) (&hdr))[i] == '\0')
3073      (((char *) (&hdr))[i]) = ' ';
3074
3075   if (bfd_bwrite ((void *) &hdr, (bfd_size_type) sizeof (struct ar_hdr), abfd)
3076       != sizeof (struct ar_hdr))
3077     return FALSE;
3078
3079   H_PUT_32 (abfd, hashsize, temp);
3080   if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4)
3081     return FALSE;
3082
3083   hashtable = bfd_zalloc (abfd, symdefsize);
3084   if (!hashtable)
3085     return FALSE;
3086
3087   current = abfd->archive_head;
3088   last_elt = current;
3089   for (i = 0; i < orl_count; i++)
3090     {
3091       unsigned int hash, rehash = 0;
3092
3093       /* Advance firstreal to the file position of this archive
3094          element.  */
3095       if (map[i].u.abfd != last_elt)
3096         {
3097           do
3098             {
3099               firstreal += arelt_size (current) + sizeof (struct ar_hdr);
3100               firstreal += firstreal % 2;
3101               current = current->archive_next;
3102             }
3103           while (current != map[i].u.abfd);
3104         }
3105
3106       last_elt = current;
3107
3108       hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog);
3109       if (H_GET_32 (abfd, (hashtable + (hash * 8) + 4)) != 0)
3110         {
3111           unsigned int srch;
3112
3113           /* The desired slot is already taken.  */
3114           for (srch = (hash + rehash) & (hashsize - 1);
3115                srch != hash;
3116                srch = (srch + rehash) & (hashsize - 1))
3117             if (H_GET_32 (abfd, (hashtable + (srch * 8) + 4)) == 0)
3118               break;
3119
3120           BFD_ASSERT (srch != hash);
3121
3122           hash = srch;
3123         }
3124
3125       H_PUT_32 (abfd, map[i].namidx, (hashtable + hash * 8));
3126       H_PUT_32 (abfd, firstreal, (hashtable + hash * 8 + 4));
3127     }
3128
3129   if (bfd_bwrite ((void *) hashtable, symdefsize, abfd) != symdefsize)
3130     return FALSE;
3131
3132   bfd_release (abfd, hashtable);
3133
3134   /* Now write the strings.  */
3135   H_PUT_32 (abfd, stringsize, temp);
3136   if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4)
3137     return FALSE;
3138   for (i = 0; i < orl_count; i++)
3139     {
3140       bfd_size_type len;
3141
3142       len = strlen (*map[i].name) + 1;
3143       if (bfd_bwrite ((void *) (*map[i].name), len, abfd) != len)
3144         return FALSE;
3145     }
3146
3147   /* The spec sez this should be a newline.  But in order to be
3148      bug-compatible for DECstation ar we use a null.  */
3149   if (padit)
3150     {
3151       if (bfd_bwrite ("", (bfd_size_type) 1, abfd) != 1)
3152         return FALSE;
3153     }
3154
3155   return TRUE;
3156 }
3157 \f
3158 /* ECOFF linker code.  */
3159
3160 /* Routine to create an entry in an ECOFF link hash table.  */
3161
3162 static struct bfd_hash_entry *
3163 ecoff_link_hash_newfunc (struct bfd_hash_entry *entry,
3164                          struct bfd_hash_table *table,
3165                          const char *string)
3166 {
3167   struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry;
3168
3169   /* Allocate the structure if it has not already been allocated by a
3170      subclass.  */
3171   if (ret == NULL)
3172     ret = ((struct ecoff_link_hash_entry *)
3173            bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry)));
3174   if (ret == NULL)
3175     return NULL;
3176
3177   /* Call the allocation method of the superclass.  */
3178   ret = ((struct ecoff_link_hash_entry *)
3179          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3180                                  table, string));
3181
3182   if (ret)
3183     {
3184       /* Set local fields.  */
3185       ret->indx = -1;
3186       ret->abfd = NULL;
3187       ret->written = 0;
3188       ret->small = 0;
3189     }
3190   memset ((void *) &ret->esym, 0, sizeof ret->esym);
3191
3192   return (struct bfd_hash_entry *) ret;
3193 }
3194
3195 /* Create an ECOFF link hash table.  */
3196
3197 struct bfd_link_hash_table *
3198 _bfd_ecoff_bfd_link_hash_table_create (bfd *abfd)
3199 {
3200   struct ecoff_link_hash_table *ret;
3201   bfd_size_type amt = sizeof (struct ecoff_link_hash_table);
3202
3203   ret = bfd_malloc (amt);
3204   if (ret == NULL)
3205     return NULL;
3206   if (!_bfd_link_hash_table_init (&ret->root, abfd,
3207                                   ecoff_link_hash_newfunc,
3208                                   sizeof (struct ecoff_link_hash_entry)))
3209     {
3210       free (ret);
3211       return NULL;
3212     }
3213   return &ret->root;
3214 }
3215
3216 /* Look up an entry in an ECOFF link hash table.  */
3217
3218 #define ecoff_link_hash_lookup(table, string, create, copy, follow) \
3219   ((struct ecoff_link_hash_entry *) \
3220    bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow)))
3221
3222 /* Traverse an ECOFF link hash table.  */
3223
3224 #define ecoff_link_hash_traverse(table, func, info)                     \
3225   (bfd_link_hash_traverse                                               \
3226    (&(table)->root,                                                     \
3227     (bfd_boolean (*) (struct bfd_link_hash_entry *, void *)) (func),    \
3228     (info)))
3229
3230 /* Get the ECOFF link hash table from the info structure.  This is
3231    just a cast.  */
3232
3233 #define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash))
3234
3235 /* Add the external symbols of an object file to the global linker
3236    hash table.  The external symbols and strings we are passed are
3237    just allocated on the stack, and will be discarded.  We must
3238    explicitly save any information we may need later on in the link.
3239    We do not want to read the external symbol information again.  */
3240
3241 static bfd_boolean
3242 ecoff_link_add_externals (bfd *abfd,
3243                           struct bfd_link_info *info,
3244                           void * external_ext,
3245                           char *ssext)
3246 {
3247   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3248   void (* const swap_ext_in) (bfd *, void *, EXTR *)
3249     = backend->debug_swap.swap_ext_in;
3250   bfd_size_type external_ext_size = backend->debug_swap.external_ext_size;
3251   unsigned long ext_count;
3252   struct bfd_link_hash_entry **sym_hash;
3253   char *ext_ptr;
3254   char *ext_end;
3255   bfd_size_type amt;
3256
3257   ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
3258
3259   amt = ext_count;
3260   amt *= sizeof (struct bfd_link_hash_entry *);
3261   sym_hash = bfd_alloc (abfd, amt);
3262   if (!sym_hash)
3263     return FALSE;
3264   ecoff_data (abfd)->sym_hashes = (struct ecoff_link_hash_entry **) sym_hash;
3265
3266   ext_ptr = (char *) external_ext;
3267   ext_end = ext_ptr + ext_count * external_ext_size;
3268   for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++)
3269     {
3270       EXTR esym;
3271       bfd_boolean skip;
3272       bfd_vma value;
3273       asection *section;
3274       const char *name;
3275       struct ecoff_link_hash_entry *h;
3276
3277       *sym_hash = NULL;
3278
3279       (*swap_ext_in) (abfd, (void *) ext_ptr, &esym);
3280
3281       /* Skip debugging symbols.  */
3282       skip = FALSE;
3283       switch (esym.asym.st)
3284         {
3285         case stGlobal:
3286         case stStatic:
3287         case stLabel:
3288         case stProc:
3289         case stStaticProc:
3290           break;
3291         default:
3292           skip = TRUE;
3293           break;
3294         }
3295
3296       if (skip)
3297         continue;
3298
3299       /* Get the information for this symbol.  */
3300       value = esym.asym.value;
3301       switch (esym.asym.sc)
3302         {
3303         default:
3304         case scNil:
3305         case scRegister:
3306         case scCdbLocal:
3307         case scBits:
3308         case scCdbSystem:
3309         case scRegImage:
3310         case scInfo:
3311         case scUserStruct:
3312         case scVar:
3313         case scVarRegister:
3314         case scVariant:
3315         case scBasedVar:
3316         case scXData:
3317         case scPData:
3318           section = NULL;
3319           break;
3320         case scText:
3321           section = bfd_make_section_old_way (abfd, _TEXT);
3322           value -= section->vma;
3323           break;
3324         case scData:
3325           section = bfd_make_section_old_way (abfd, _DATA);
3326           value -= section->vma;
3327           break;
3328         case scBss:
3329           section = bfd_make_section_old_way (abfd, _BSS);
3330           value -= section->vma;
3331           break;
3332         case scAbs:
3333           section = bfd_abs_section_ptr;
3334           break;
3335         case scUndefined:
3336           section = bfd_und_section_ptr;
3337           break;
3338         case scSData:
3339           section = bfd_make_section_old_way (abfd, _SDATA);
3340           value -= section->vma;
3341           break;
3342         case scSBss:
3343           section = bfd_make_section_old_way (abfd, _SBSS);
3344           value -= section->vma;
3345           break;
3346         case scRData:
3347           section = bfd_make_section_old_way (abfd, _RDATA);
3348           value -= section->vma;
3349           break;
3350         case scCommon:
3351           if (value > ecoff_data (abfd)->gp_size)
3352             {
3353               section = bfd_com_section_ptr;
3354               break;
3355             }
3356           /* Fall through.  */
3357         case scSCommon:
3358           if (ecoff_scom_section.name == NULL)
3359             {
3360               /* Initialize the small common section.  */
3361               ecoff_scom_section.name = SCOMMON;
3362               ecoff_scom_section.flags = SEC_IS_COMMON;
3363               ecoff_scom_section.output_section = &ecoff_scom_section;
3364               ecoff_scom_section.symbol = &ecoff_scom_symbol;
3365               ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr;
3366               ecoff_scom_symbol.name = SCOMMON;
3367               ecoff_scom_symbol.flags = BSF_SECTION_SYM;
3368               ecoff_scom_symbol.section = &ecoff_scom_section;
3369               ecoff_scom_symbol_ptr = &ecoff_scom_symbol;
3370             }
3371           section = &ecoff_scom_section;
3372           break;
3373         case scSUndefined:
3374           section = bfd_und_section_ptr;
3375           break;
3376         case scInit:
3377           section = bfd_make_section_old_way (abfd, _INIT);
3378           value -= section->vma;
3379           break;
3380         case scFini:
3381           section = bfd_make_section_old_way (abfd, _FINI);
3382           value -= section->vma;
3383           break;
3384         case scRConst:
3385           section = bfd_make_section_old_way (abfd, _RCONST);
3386           value -= section->vma;
3387           break;
3388         }
3389
3390       if (section == NULL)
3391         continue;
3392
3393       name = ssext + esym.asym.iss;
3394
3395       if (! (_bfd_generic_link_add_one_symbol
3396              (info, abfd, name,
3397               (flagword) (esym.weakext ? BSF_WEAK : BSF_GLOBAL),
3398               section, value, NULL, TRUE, TRUE, sym_hash)))
3399         return FALSE;
3400
3401       h = (struct ecoff_link_hash_entry *) *sym_hash;
3402
3403       /* If we are building an ECOFF hash table, save the external
3404          symbol information.  */
3405       if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd))
3406         {
3407           if (h->abfd == NULL
3408               || (! bfd_is_und_section (section)
3409                   && (! bfd_is_com_section (section)
3410                       || (h->root.type != bfd_link_hash_defined
3411                           && h->root.type != bfd_link_hash_defweak))))
3412             {
3413               h->abfd = abfd;
3414               h->esym = esym;
3415             }
3416
3417           /* Remember whether this symbol was small undefined.  */
3418           if (esym.asym.sc == scSUndefined)
3419             h->small = 1;
3420
3421           /* If this symbol was ever small undefined, it needs to wind
3422              up in a GP relative section.  We can't control the
3423              section of a defined symbol, but we can control the
3424              section of a common symbol.  This case is actually needed
3425              on Ultrix 4.2 to handle the symbol cred in -lckrb.  */
3426           if (h->small
3427               && h->root.type == bfd_link_hash_common
3428               && streq (h->root.u.c.p->section->name, SCOMMON))
3429             {
3430               h->root.u.c.p->section = bfd_make_section_old_way (abfd,
3431                                                                  SCOMMON);
3432               h->root.u.c.p->section->flags = SEC_ALLOC;
3433               if (h->esym.asym.sc == scCommon)
3434                 h->esym.asym.sc = scSCommon;
3435             }
3436         }
3437     }
3438
3439   return TRUE;
3440 }
3441
3442 /* Add symbols from an ECOFF object file to the global linker hash
3443    table.  */
3444
3445 static bfd_boolean
3446 ecoff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3447 {
3448   HDRR *symhdr;
3449   bfd_size_type external_ext_size;
3450   void * external_ext = NULL;
3451   bfd_size_type esize;
3452   char *ssext = NULL;
3453   bfd_boolean result;
3454
3455   if (! ecoff_slurp_symbolic_header (abfd))
3456     return FALSE;
3457
3458   /* If there are no symbols, we don't want it.  */
3459   if (bfd_get_symcount (abfd) == 0)
3460     return TRUE;
3461
3462   symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3463
3464   /* Read in the external symbols and external strings.  */
3465   external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size;
3466   esize = symhdr->iextMax * external_ext_size;
3467   external_ext = bfd_malloc (esize);
3468   if (external_ext == NULL && esize != 0)
3469     goto error_return;
3470
3471   if (bfd_seek (abfd, (file_ptr) symhdr->cbExtOffset, SEEK_SET) != 0
3472       || bfd_bread (external_ext, esize, abfd) != esize)
3473     goto error_return;
3474
3475   ssext = bfd_malloc ((bfd_size_type) symhdr->issExtMax);
3476   if (ssext == NULL && symhdr->issExtMax != 0)
3477     goto error_return;
3478
3479   if (bfd_seek (abfd, (file_ptr) symhdr->cbSsExtOffset, SEEK_SET) != 0
3480       || (bfd_bread (ssext, (bfd_size_type) symhdr->issExtMax, abfd)
3481           != (bfd_size_type) symhdr->issExtMax))
3482     goto error_return;
3483
3484   result = ecoff_link_add_externals (abfd, info, external_ext, ssext);
3485
3486   if (ssext != NULL)
3487     free (ssext);
3488   if (external_ext != NULL)
3489     free (external_ext);
3490   return result;
3491
3492  error_return:
3493   if (ssext != NULL)
3494     free (ssext);
3495   if (external_ext != NULL)
3496     free (external_ext);
3497   return FALSE;
3498 }
3499
3500 /* This is called if we used _bfd_generic_link_add_archive_symbols
3501    because we were not dealing with an ECOFF archive.  */
3502
3503 static bfd_boolean
3504 ecoff_link_check_archive_element (bfd *abfd,
3505                                   struct bfd_link_info *info,
3506                                   bfd_boolean *pneeded)
3507 {
3508   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3509   void (* const swap_ext_in) (bfd *, void *, EXTR *)
3510     = backend->debug_swap.swap_ext_in;
3511   HDRR *symhdr;
3512   bfd_size_type external_ext_size;
3513   void * external_ext = NULL;
3514   bfd_size_type esize;
3515   char *ssext = NULL;
3516   char *ext_ptr;
3517   char *ext_end;
3518
3519   *pneeded = FALSE;
3520
3521   if (! ecoff_slurp_symbolic_header (abfd))
3522     goto error_return;
3523
3524   /* If there are no symbols, we don't want it.  */
3525   if (bfd_get_symcount (abfd) == 0)
3526     goto successful_return;
3527
3528   symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
3529
3530   /* Read in the external symbols and external strings.  */
3531   external_ext_size = backend->debug_swap.external_ext_size;
3532   esize = symhdr->iextMax * external_ext_size;
3533   external_ext = bfd_malloc (esize);
3534   if (external_ext == NULL && esize != 0)
3535     goto error_return;
3536
3537   if (bfd_seek (abfd, (file_ptr) symhdr->cbExtOffset, SEEK_SET) != 0
3538       || bfd_bread (external_ext, esize, abfd) != esize)
3539     goto error_return;
3540
3541   ssext = bfd_malloc ((bfd_size_type) symhdr->issExtMax);
3542   if (ssext == NULL && symhdr->issExtMax != 0)
3543     goto error_return;
3544
3545   if (bfd_seek (abfd, (file_ptr) symhdr->cbSsExtOffset, SEEK_SET) != 0
3546       || (bfd_bread (ssext, (bfd_size_type) symhdr->issExtMax, abfd)
3547           != (bfd_size_type) symhdr->issExtMax))
3548     goto error_return;
3549
3550   /* Look through the external symbols to see if they define some
3551      symbol that is currently undefined.  */
3552   ext_ptr = (char *) external_ext;
3553   ext_end = ext_ptr + esize;
3554   for (; ext_ptr < ext_end; ext_ptr += external_ext_size)
3555     {
3556       EXTR esym;
3557       bfd_boolean def;
3558       const char *name;
3559       struct bfd_link_hash_entry *h;
3560
3561       (*swap_ext_in) (abfd, (void *) ext_ptr, &esym);
3562
3563       /* See if this symbol defines something.  */
3564       if (esym.asym.st != stGlobal
3565           && esym.asym.st != stLabel
3566           && esym.asym.st != stProc)
3567         continue;
3568
3569       switch (esym.asym.sc)
3570         {
3571         case scText:
3572         case scData:
3573         case scBss:
3574         case scAbs:
3575         case scSData:
3576         case scSBss:
3577         case scRData:
3578         case scCommon:
3579         case scSCommon:
3580         case scInit:
3581         case scFini:
3582         case scRConst:
3583           def = TRUE;
3584           break;
3585         default:
3586           def = FALSE;
3587           break;
3588         }
3589
3590       if (! def)
3591         continue;
3592
3593       name = ssext + esym.asym.iss;
3594       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
3595
3596       /* Unlike the generic linker, we do not pull in elements because
3597          of common symbols.  */
3598       if (h == NULL
3599           || h->type != bfd_link_hash_undefined)
3600         continue;
3601
3602       /* Include this element.  */
3603       if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3604         goto error_return;
3605       if (! ecoff_link_add_externals (abfd, info, external_ext, ssext))
3606         goto error_return;
3607
3608       *pneeded = TRUE;
3609       goto successful_return;
3610     }
3611
3612  successful_return:
3613   if (external_ext != NULL)
3614     free (external_ext);
3615   if (ssext != NULL)
3616     free (ssext);
3617   return TRUE;
3618  error_return:
3619   if (external_ext != NULL)
3620     free (external_ext);
3621   if (ssext != NULL)
3622     free (ssext);
3623   return FALSE;
3624 }
3625
3626 /* Add the symbols from an archive file to the global hash table.
3627    This looks through the undefined symbols, looks each one up in the
3628    archive hash table, and adds any associated object file.  We do not
3629    use _bfd_generic_link_add_archive_symbols because ECOFF archives
3630    already have a hash table, so there is no reason to construct
3631    another one.  */
3632
3633 static bfd_boolean
3634 ecoff_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
3635 {
3636   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
3637   const bfd_byte *raw_armap;
3638   struct bfd_link_hash_entry **pundef;
3639   unsigned int armap_count;
3640   unsigned int armap_log;
3641   unsigned int i;
3642   const bfd_byte *hashtable;
3643   const char *stringbase;
3644
3645   if (! bfd_has_map (abfd))
3646     {
3647       /* An empty archive is a special case.  */
3648       if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
3649         return TRUE;
3650       bfd_set_error (bfd_error_no_armap);
3651       return FALSE;
3652     }
3653
3654   /* If we don't have any raw data for this archive, as can happen on
3655      Irix 4.0.5F, we call the generic routine.
3656      FIXME: We should be more clever about this, since someday tdata
3657      may get to something for a generic archive.  */
3658   raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata;
3659   if (raw_armap == NULL)
3660     return (_bfd_generic_link_add_archive_symbols
3661             (abfd, info, ecoff_link_check_archive_element));
3662
3663   armap_count = H_GET_32 (abfd, raw_armap);
3664
3665   armap_log = 0;
3666   for (i = 1; i < armap_count; i <<= 1)
3667     armap_log++;
3668   BFD_ASSERT (i == armap_count);
3669
3670   hashtable = raw_armap + 4;
3671   stringbase = (const char *) raw_armap + armap_count * 8 + 8;
3672
3673   /* Look through the list of undefined symbols.  */
3674   pundef = &info->hash->undefs;
3675   while (*pundef != NULL)
3676     {
3677       struct bfd_link_hash_entry *h;
3678       unsigned int hash, rehash = 0;
3679       unsigned int file_offset;
3680       const char *name;
3681       bfd *element;
3682
3683       h = *pundef;
3684
3685       /* When a symbol is defined, it is not necessarily removed from
3686          the list.  */
3687       if (h->type != bfd_link_hash_undefined
3688           && h->type != bfd_link_hash_common)
3689         {
3690           /* Remove this entry from the list, for general cleanliness
3691              and because we are going to look through the list again
3692              if we search any more libraries.  We can't remove the
3693              entry if it is the tail, because that would lose any
3694              entries we add to the list later on.  */
3695           if (*pundef != info->hash->undefs_tail)
3696             *pundef = (*pundef)->u.undef.next;
3697           else
3698             pundef = &(*pundef)->u.undef.next;
3699           continue;
3700         }
3701
3702       /* Native ECOFF linkers do not pull in archive elements merely
3703          to satisfy common definitions, so neither do we.  We leave
3704          them on the list, though, in case we are linking against some
3705          other object format.  */
3706       if (h->type != bfd_link_hash_undefined)
3707         {
3708           pundef = &(*pundef)->u.undef.next;
3709           continue;
3710         }
3711
3712       /* Look for this symbol in the archive hash table.  */
3713       hash = ecoff_armap_hash (h->root.string, &rehash, armap_count,
3714                                armap_log);
3715
3716       file_offset = H_GET_32 (abfd, hashtable + (hash * 8) + 4);
3717       if (file_offset == 0)
3718         {
3719           /* Nothing in this slot.  */
3720           pundef = &(*pundef)->u.undef.next;
3721           continue;
3722         }
3723
3724       name = stringbase + H_GET_32 (abfd, hashtable + (hash * 8));
3725       if (name[0] != h->root.string[0]
3726           || ! streq (name, h->root.string))
3727         {
3728           unsigned int srch;
3729           bfd_boolean found;
3730
3731           /* That was the wrong symbol.  Try rehashing.  */
3732           found = FALSE;
3733           for (srch = (hash + rehash) & (armap_count - 1);
3734                srch != hash;
3735                srch = (srch + rehash) & (armap_count - 1))
3736             {
3737               file_offset = H_GET_32 (abfd, hashtable + (srch * 8) + 4);
3738               if (file_offset == 0)
3739                 break;
3740               name = stringbase + H_GET_32 (abfd, hashtable + (srch * 8));
3741               if (name[0] == h->root.string[0]
3742                   && streq (name, h->root.string))
3743                 {
3744                   found = TRUE;
3745                   break;
3746                 }
3747             }
3748
3749           if (! found)
3750             {
3751               pundef = &(*pundef)->u.undef.next;
3752               continue;
3753             }
3754
3755           hash = srch;
3756         }
3757
3758       element = (*backend->get_elt_at_filepos) (abfd, (file_ptr) file_offset);
3759       if (element == NULL)
3760         return FALSE;
3761
3762       if (! bfd_check_format (element, bfd_object))
3763         return FALSE;
3764
3765       /* Unlike the generic linker, we know that this element provides
3766          a definition for an undefined symbol and we know that we want
3767          to include it.  We don't need to check anything.  */
3768       if (! (*info->callbacks->add_archive_element) (info, element, name))
3769         return FALSE;
3770       if (! ecoff_link_add_object_symbols (element, info))
3771         return FALSE;
3772
3773       pundef = &(*pundef)->u.undef.next;
3774     }
3775
3776   return TRUE;
3777 }
3778
3779 /* Given an ECOFF BFD, add symbols to the global hash table as
3780    appropriate.  */
3781
3782 bfd_boolean
3783 _bfd_ecoff_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
3784 {
3785   switch (bfd_get_format (abfd))
3786     {
3787     case bfd_object:
3788       return ecoff_link_add_object_symbols (abfd, info);
3789     case bfd_archive:
3790       return ecoff_link_add_archive_symbols (abfd, info);
3791     default:
3792       bfd_set_error (bfd_error_wrong_format);
3793       return FALSE;
3794     }
3795 }
3796
3797 \f
3798 /* ECOFF final link routines.  */
3799
3800 /* Structure used to pass information to ecoff_link_write_external.  */
3801
3802 struct extsym_info
3803 {
3804   bfd *abfd;
3805   struct bfd_link_info *info;
3806 };
3807
3808 /* Accumulate the debugging information for an input BFD into the
3809    output BFD.  This must read in the symbolic information of the
3810    input BFD.  */
3811
3812 static bfd_boolean
3813 ecoff_final_link_debug_accumulate (bfd *output_bfd,
3814                                    bfd *input_bfd,
3815                                    struct bfd_link_info *info,
3816                                    void * handle)
3817 {
3818   struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info;
3819   const struct ecoff_debug_swap * const swap =
3820     &ecoff_backend (input_bfd)->debug_swap;
3821   HDRR *symhdr = &debug->symbolic_header;
3822   bfd_boolean ret;
3823
3824 #define READ(ptr, offset, count, size, type)                             \
3825   if (symhdr->count == 0)                                                \
3826     debug->ptr = NULL;                                                   \
3827   else                                                                   \
3828     {                                                                    \
3829       bfd_size_type amt = (bfd_size_type) size * symhdr->count;          \
3830       debug->ptr = bfd_malloc (amt);                                     \
3831       if (debug->ptr == NULL)                                            \
3832         {                                                                \
3833           ret = FALSE;                                                   \
3834           goto return_something;                                         \
3835         }                                                                \
3836       if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3837           || bfd_bread (debug->ptr, amt, input_bfd) != amt)              \
3838         {                                                                \
3839           ret = FALSE;                                                   \
3840           goto return_something;                                         \
3841         }                                                                \
3842     }
3843
3844   /* If raw_syments is not NULL, then the data was already by read by
3845      _bfd_ecoff_slurp_symbolic_info.  */
3846   if (ecoff_data (input_bfd)->raw_syments == NULL)
3847     {
3848       READ (line, cbLineOffset, cbLine, sizeof (unsigned char),
3849             unsigned char *);
3850       READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
3851       READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
3852       READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
3853       READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
3854       READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
3855             union aux_ext *);
3856       READ (ss, cbSsOffset, issMax, sizeof (char), char *);
3857       READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
3858       READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
3859     }
3860 #undef READ
3861
3862   /* We do not read the external strings or the external symbols.  */
3863
3864   ret = (bfd_ecoff_debug_accumulate
3865          (handle, output_bfd, &ecoff_data (output_bfd)->debug_info,
3866           &ecoff_backend (output_bfd)->debug_swap,
3867           input_bfd, debug, swap, info));
3868
3869  return_something:
3870   if (ecoff_data (input_bfd)->raw_syments == NULL)
3871     {
3872       if (debug->line != NULL)
3873         free (debug->line);
3874       if (debug->external_dnr != NULL)
3875         free (debug->external_dnr);
3876       if (debug->external_pdr != NULL)
3877         free (debug->external_pdr);
3878       if (debug->external_sym != NULL)
3879         free (debug->external_sym);
3880       if (debug->external_opt != NULL)
3881         free (debug->external_opt);
3882       if (debug->external_aux != NULL)
3883         free (debug->external_aux);
3884       if (debug->ss != NULL)
3885         free (debug->ss);
3886       if (debug->external_fdr != NULL)
3887         free (debug->external_fdr);
3888       if (debug->external_rfd != NULL)
3889         free (debug->external_rfd);
3890
3891       /* Make sure we don't accidentally follow one of these pointers
3892          into freed memory.  */
3893       debug->line = NULL;
3894       debug->external_dnr = NULL;
3895       debug->external_pdr = NULL;
3896       debug->external_sym = NULL;
3897       debug->external_opt = NULL;
3898       debug->external_aux = NULL;
3899       debug->ss = NULL;
3900       debug->external_fdr = NULL;
3901       debug->external_rfd = NULL;
3902     }
3903
3904   return ret;
3905 }
3906
3907 /* Relocate and write an ECOFF section into an ECOFF output file.  */
3908
3909 static bfd_boolean
3910 ecoff_indirect_link_order (bfd *output_bfd,
3911                            struct bfd_link_info *info,
3912                            asection *output_section,
3913                            struct bfd_link_order *link_order)
3914 {
3915   asection *input_section;
3916   bfd *input_bfd;
3917   bfd_byte *contents = NULL;
3918   bfd_size_type external_reloc_size;
3919   bfd_size_type external_relocs_size;
3920   void * external_relocs = NULL;
3921
3922   BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
3923
3924   input_section = link_order->u.indirect.section;
3925   input_bfd = input_section->owner;
3926   if (input_section->size == 0)
3927     return TRUE;
3928
3929   BFD_ASSERT (input_section->output_section == output_section);
3930   BFD_ASSERT (input_section->output_offset == link_order->offset);
3931   BFD_ASSERT (input_section->size == link_order->size);
3932
3933   /* Get the section contents.  */
3934   if (!bfd_malloc_and_get_section (input_bfd, input_section, &contents))
3935     goto error_return;
3936
3937   /* Get the relocs.  If we are relaxing MIPS code, they will already
3938      have been read in.  Otherwise, we read them in now.  */
3939   external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size;
3940   external_relocs_size = external_reloc_size * input_section->reloc_count;
3941
3942   external_relocs = bfd_malloc (external_relocs_size);
3943   if (external_relocs == NULL && external_relocs_size != 0)
3944     goto error_return;
3945
3946   if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
3947       || (bfd_bread (external_relocs, external_relocs_size, input_bfd)
3948           != external_relocs_size))
3949     goto error_return;
3950
3951   /* Relocate the section contents.  */
3952   if (! ((*ecoff_backend (input_bfd)->relocate_section)
3953          (output_bfd, info, input_bfd, input_section, contents,
3954           external_relocs)))
3955     goto error_return;
3956
3957   /* Write out the relocated section.  */
3958   if (! bfd_set_section_contents (output_bfd,
3959                                   output_section,
3960                                   contents,
3961                                   input_section->output_offset,
3962                                   input_section->size))
3963     goto error_return;
3964
3965   /* If we are producing relocatable output, the relocs were
3966      modified, and we write them out now.  We use the reloc_count
3967      field of output_section to keep track of the number of relocs we
3968      have output so far.  */
3969   if (info->relocatable)
3970     {
3971       file_ptr pos = (output_section->rel_filepos
3972                       + output_section->reloc_count * external_reloc_size);
3973       if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
3974           || (bfd_bwrite (external_relocs, external_relocs_size, output_bfd)
3975               != external_relocs_size))
3976         goto error_return;
3977       output_section->reloc_count += input_section->reloc_count;
3978     }
3979
3980   if (contents != NULL)
3981     free (contents);
3982   if (external_relocs != NULL)
3983     free (external_relocs);
3984   return TRUE;
3985
3986  error_return:
3987   if (contents != NULL)
3988     free (contents);
3989   if (external_relocs != NULL)
3990     free (external_relocs);
3991   return FALSE;
3992 }
3993
3994 /* Generate a reloc when linking an ECOFF file.  This is a reloc
3995    requested by the linker, and does come from any input file.  This
3996    is used to build constructor and destructor tables when linking
3997    with -Ur.  */
3998
3999 static bfd_boolean
4000 ecoff_reloc_link_order (bfd *output_bfd,
4001                         struct bfd_link_info *info,
4002                         asection *output_section,
4003                         struct bfd_link_order *link_order)
4004 {
4005   enum bfd_link_order_type type;
4006   asection *section;
4007   bfd_vma addend;
4008   arelent rel;
4009   struct internal_reloc in;
4010   bfd_size_type external_reloc_size;
4011   bfd_byte *rbuf;
4012   bfd_boolean ok;
4013   file_ptr pos;
4014
4015   type = link_order->type;
4016   section = NULL;
4017   addend = link_order->u.reloc.p->addend;
4018
4019   /* We set up an arelent to pass to the backend adjust_reloc_out
4020      routine.  */
4021   rel.address = link_order->offset;
4022
4023   rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
4024   if (rel.howto == 0)
4025     {
4026       bfd_set_error (bfd_error_bad_value);
4027       return FALSE;
4028     }
4029
4030   if (type == bfd_section_reloc_link_order)
4031     {
4032       section = link_order->u.reloc.p->u.section;
4033       rel.sym_ptr_ptr = section->symbol_ptr_ptr;
4034     }
4035   else
4036     {
4037       struct bfd_link_hash_entry *h;
4038
4039       /* Treat a reloc against a defined symbol as though it were
4040          actually against the section.  */
4041       h = bfd_wrapped_link_hash_lookup (output_bfd, info,
4042                                         link_order->u.reloc.p->u.name,
4043                                         FALSE, FALSE, FALSE);
4044       if (h != NULL
4045           && (h->type == bfd_link_hash_defined
4046               || h->type == bfd_link_hash_defweak))
4047         {
4048           type = bfd_section_reloc_link_order;
4049           section = h->u.def.section->output_section;
4050           /* It seems that we ought to add the symbol value to the
4051              addend here, but in practice it has already been added
4052              because it was passed to constructor_callback.  */
4053           addend += section->vma + h->u.def.section->output_offset;
4054         }
4055       else
4056         {
4057           /* We can't set up a reloc against a symbol correctly,
4058              because we have no asymbol structure.  Currently no
4059              adjust_reloc_out routine cares.  */
4060           rel.sym_ptr_ptr = NULL;
4061         }
4062     }
4063
4064   /* All ECOFF relocs are in-place.  Put the addend into the object
4065      file.  */
4066
4067   BFD_ASSERT (rel.howto->partial_inplace);
4068   if (addend != 0)
4069     {
4070       bfd_size_type size;
4071       bfd_reloc_status_type rstat;
4072       bfd_byte *buf;
4073
4074       size = bfd_get_reloc_size (rel.howto);
4075       buf = bfd_zmalloc (size);
4076       if (buf == NULL)
4077         return FALSE;
4078       rstat = _bfd_relocate_contents (rel.howto, output_bfd,
4079                                       (bfd_vma) addend, buf);
4080       switch (rstat)
4081         {
4082         case bfd_reloc_ok:
4083           break;
4084         default:
4085         case bfd_reloc_outofrange:
4086           abort ();
4087         case bfd_reloc_overflow:
4088           if (! ((*info->callbacks->reloc_overflow)
4089                  (info, NULL,
4090                   (link_order->type == bfd_section_reloc_link_order
4091                    ? bfd_section_name (output_bfd, section)
4092                    : link_order->u.reloc.p->u.name),
4093                   rel.howto->name, addend, NULL,
4094                   NULL, (bfd_vma) 0)))
4095             {
4096               free (buf);
4097               return FALSE;
4098             }
4099           break;
4100         }
4101       ok = bfd_set_section_contents (output_bfd, output_section, (void *) buf,
4102                                      (file_ptr) link_order->offset, size);
4103       free (buf);
4104       if (! ok)
4105         return FALSE;
4106     }
4107
4108   rel.addend = 0;
4109
4110   /* Move the information into an internal_reloc structure.  */
4111   in.r_vaddr = (rel.address
4112                 + bfd_get_section_vma (output_bfd, output_section));
4113   in.r_type = rel.howto->type;
4114
4115   if (type == bfd_symbol_reloc_link_order)
4116     {
4117       struct ecoff_link_hash_entry *h;
4118
4119       h = ((struct ecoff_link_hash_entry *)
4120            bfd_wrapped_link_hash_lookup (output_bfd, info,
4121                                          link_order->u.reloc.p->u.name,
4122                                          FALSE, FALSE, TRUE));
4123       if (h != NULL
4124           && h->indx != -1)
4125         in.r_symndx = h->indx;
4126       else
4127         {
4128           if (! ((*info->callbacks->unattached_reloc)
4129                  (info, link_order->u.reloc.p->u.name, NULL,
4130                   NULL, (bfd_vma) 0)))
4131             return FALSE;
4132           in.r_symndx = 0;
4133         }
4134       in.r_extern = 1;
4135     }
4136   else
4137     {
4138       const char *name;
4139       unsigned int i;
4140       static struct
4141       {
4142         const char * name;
4143         long r_symndx;
4144       }
4145       section_symndx [] =
4146       {
4147         { _TEXT,   RELOC_SECTION_TEXT   },
4148         { _RDATA,  RELOC_SECTION_RDATA  },
4149         { _DATA,   RELOC_SECTION_DATA   },
4150         { _SDATA,  RELOC_SECTION_SDATA  },
4151         { _SBSS,   RELOC_SECTION_SBSS   },
4152         { _BSS,    RELOC_SECTION_BSS    },
4153         { _INIT,   RELOC_SECTION_INIT   },
4154         { _LIT8,   RELOC_SECTION_LIT8   },
4155         { _LIT4,   RELOC_SECTION_LIT4   },
4156         { _XDATA,  RELOC_SECTION_XDATA  },
4157         { _PDATA,  RELOC_SECTION_PDATA  },
4158         { _FINI,   RELOC_SECTION_FINI   },
4159         { _LITA,   RELOC_SECTION_LITA   },
4160         { "*ABS*", RELOC_SECTION_ABS    },
4161         { _RCONST, RELOC_SECTION_RCONST }
4162       };
4163
4164       name = bfd_get_section_name (output_bfd, section);
4165
4166       for (i = 0; i < ARRAY_SIZE (section_symndx); i++)
4167         if (streq (name, section_symndx[i].name))
4168           {
4169             in.r_symndx = section_symndx[i].r_symndx;
4170             break;
4171           }
4172
4173       if (i == ARRAY_SIZE (section_symndx))
4174         abort ();
4175
4176       in.r_extern = 0;
4177     }
4178
4179   /* Let the BFD backend adjust the reloc.  */
4180   (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in);
4181
4182   /* Get some memory and swap out the reloc.  */
4183   external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
4184   rbuf = bfd_malloc (external_reloc_size);
4185   if (rbuf == NULL)
4186     return FALSE;
4187
4188   (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (void *) rbuf);
4189
4190   pos = (output_section->rel_filepos
4191          + output_section->reloc_count * external_reloc_size);
4192   ok = (bfd_seek (output_bfd, pos, SEEK_SET) == 0
4193         && (bfd_bwrite ((void *) rbuf, external_reloc_size, output_bfd)
4194             == external_reloc_size));
4195
4196   if (ok)
4197     ++output_section->reloc_count;
4198
4199   free (rbuf);
4200
4201   return ok;
4202 }
4203
4204 /* Put out information for an external symbol.  These come only from
4205    the hash table.  */
4206
4207 static bfd_boolean
4208 ecoff_link_write_external (struct ecoff_link_hash_entry *h, void * data)
4209 {
4210   struct extsym_info *einfo = (struct extsym_info *) data;
4211   bfd *output_bfd = einfo->abfd;
4212   bfd_boolean strip;
4213
4214   if (h->root.type == bfd_link_hash_warning)
4215     {
4216       h = (struct ecoff_link_hash_entry *) h->root.u.i.link;
4217       if (h->root.type == bfd_link_hash_new)
4218         return TRUE;
4219     }
4220
4221   /* We need to check if this symbol is being stripped.  */
4222   if (h->root.type == bfd_link_hash_undefined
4223       || h->root.type == bfd_link_hash_undefweak)
4224     strip = FALSE;
4225   else if (einfo->info->strip == strip_all
4226            || (einfo->info->strip == strip_some
4227                && bfd_hash_lookup (einfo->info->keep_hash,
4228                                    h->root.root.string,
4229                                    FALSE, FALSE) == NULL))
4230     strip = TRUE;
4231   else
4232     strip = FALSE;
4233
4234   if (strip || h->written)
4235     return TRUE;
4236
4237   if (h->abfd == NULL)
4238     {
4239       h->esym.jmptbl = 0;
4240       h->esym.cobol_main = 0;
4241       h->esym.weakext = 0;
4242       h->esym.reserved = 0;
4243       h->esym.ifd = ifdNil;
4244       h->esym.asym.value = 0;
4245       h->esym.asym.st = stGlobal;
4246
4247       if (h->root.type != bfd_link_hash_defined
4248           && h->root.type != bfd_link_hash_defweak)
4249         h->esym.asym.sc = scAbs;
4250       else
4251         {
4252           asection *output_section;
4253           const char *name;
4254           unsigned int i;
4255           static struct
4256           {
4257             const char * name;
4258             int sc;
4259           }
4260           section_storage_classes [] =
4261           {
4262             { _TEXT,   scText   },
4263             { _DATA,   scData   },
4264             { _SDATA,  scSData  },
4265             { _RDATA,  scRData  },
4266             { _BSS,    scBss    },
4267             { _SBSS,   scSBss   },
4268             { _INIT,   scInit   },
4269             { _FINI,   scFini   },
4270             { _PDATA,  scPData  },
4271             { _XDATA,  scXData  },
4272             { _RCONST, scRConst }
4273           };
4274
4275           output_section = h->root.u.def.section->output_section;
4276           name = bfd_section_name (output_section->owner, output_section);
4277
4278           for (i = 0; i < ARRAY_SIZE (section_storage_classes); i++)
4279             if (streq (name, section_storage_classes[i].name))
4280               {
4281                 h->esym.asym.sc = section_storage_classes[i].sc;
4282                 break;
4283               }
4284
4285           if (i == ARRAY_SIZE (section_storage_classes))
4286             h->esym.asym.sc = scAbs;
4287         }
4288
4289       h->esym.asym.reserved = 0;
4290       h->esym.asym.index = indexNil;
4291     }
4292   else if (h->esym.ifd != -1)
4293     {
4294       struct ecoff_debug_info *debug;
4295
4296       /* Adjust the FDR index for the symbol by that used for the
4297          input BFD.  */
4298       debug = &ecoff_data (h->abfd)->debug_info;
4299       BFD_ASSERT (h->esym.ifd >= 0
4300                   && h->esym.ifd < debug->symbolic_header.ifdMax);
4301       h->esym.ifd = debug->ifdmap[h->esym.ifd];
4302     }
4303
4304   switch (h->root.type)
4305     {
4306     default:
4307     case bfd_link_hash_warning:
4308     case bfd_link_hash_new:
4309       abort ();
4310     case bfd_link_hash_undefined:
4311     case bfd_link_hash_undefweak:
4312       if (h->esym.asym.sc != scUndefined
4313           && h->esym.asym.sc != scSUndefined)
4314         h->esym.asym.sc = scUndefined;
4315       break;
4316     case bfd_link_hash_defined:
4317     case bfd_link_hash_defweak:
4318       if (h->esym.asym.sc == scUndefined
4319           || h->esym.asym.sc == scSUndefined)
4320         h->esym.asym.sc = scAbs;
4321       else if (h->esym.asym.sc == scCommon)
4322         h->esym.asym.sc = scBss;
4323       else if (h->esym.asym.sc == scSCommon)
4324         h->esym.asym.sc = scSBss;
4325       h->esym.asym.value = (h->root.u.def.value
4326                             + h->root.u.def.section->output_section->vma
4327                             + h->root.u.def.section->output_offset);
4328       break;
4329     case bfd_link_hash_common:
4330       if (h->esym.asym.sc != scCommon
4331           && h->esym.asym.sc != scSCommon)
4332         h->esym.asym.sc = scCommon;
4333       h->esym.asym.value = h->root.u.c.size;
4334       break;
4335     case bfd_link_hash_indirect:
4336       /* We ignore these symbols, since the indirected symbol is
4337          already in the hash table.  */
4338       return TRUE;
4339     }
4340
4341   /* bfd_ecoff_debug_one_external uses iextMax to keep track of the
4342      symbol number.  */
4343   h->indx = ecoff_data (output_bfd)->debug_info.symbolic_header.iextMax;
4344   h->written = 1;
4345
4346   return (bfd_ecoff_debug_one_external
4347           (output_bfd, &ecoff_data (output_bfd)->debug_info,
4348            &ecoff_backend (output_bfd)->debug_swap, h->root.root.string,
4349            &h->esym));
4350 }
4351
4352 /* ECOFF final link routine.  This looks through all the input BFDs
4353    and gathers together all the debugging information, and then
4354    processes all the link order information.  This may cause it to
4355    close and reopen some input BFDs; I'll see how bad this is.  */
4356
4357 bfd_boolean
4358 _bfd_ecoff_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
4359 {
4360   const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
4361   struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info;
4362   HDRR *symhdr;
4363   void * handle;
4364   bfd *input_bfd;
4365   asection *o;
4366   struct bfd_link_order *p;
4367   struct extsym_info einfo;
4368
4369   /* We accumulate the debugging information counts in the symbolic
4370      header.  */
4371   symhdr = &debug->symbolic_header;
4372   symhdr->vstamp = 0;
4373   symhdr->ilineMax = 0;
4374   symhdr->cbLine = 0;
4375   symhdr->idnMax = 0;
4376   symhdr->ipdMax = 0;
4377   symhdr->isymMax = 0;
4378   symhdr->ioptMax = 0;
4379   symhdr->iauxMax = 0;
4380   symhdr->issMax = 0;
4381   symhdr->issExtMax = 0;
4382   symhdr->ifdMax = 0;
4383   symhdr->crfd = 0;
4384   symhdr->iextMax = 0;
4385
4386   /* We accumulate the debugging information itself in the debug_info
4387      structure.  */
4388   debug->line = NULL;
4389   debug->external_dnr = NULL;
4390   debug->external_pdr = NULL;
4391   debug->external_sym = NULL;
4392   debug->external_opt = NULL;
4393   debug->external_aux = NULL;
4394   debug->ss = NULL;
4395   debug->ssext = debug->ssext_end = NULL;
4396   debug->external_fdr = NULL;
4397   debug->external_rfd = NULL;
4398   debug->external_ext = debug->external_ext_end = NULL;
4399
4400   handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info);
4401   if (handle == NULL)
4402     return FALSE;
4403
4404   /* Accumulate the debugging symbols from each input BFD.  */
4405   for (input_bfd = info->input_bfds;
4406        input_bfd != NULL;
4407        input_bfd = input_bfd->link_next)
4408     {
4409       bfd_boolean ret;
4410
4411       if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour)
4412         {
4413           /* Arbitrarily set the symbolic header vstamp to the vstamp
4414              of the first object file in the link.  */
4415           if (symhdr->vstamp == 0)
4416             symhdr->vstamp
4417               = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp;
4418           ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info,
4419                                                    handle);
4420         }
4421       else
4422         ret = bfd_ecoff_debug_accumulate_other (handle, abfd,
4423                                                 debug, &backend->debug_swap,
4424                                                 input_bfd, info);
4425       if (! ret)
4426         return FALSE;
4427
4428       /* Combine the register masks.  */
4429       ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask;
4430       ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask;
4431       ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0];
4432       ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1];
4433       ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2];
4434       ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3];
4435     }
4436
4437   /* Write out the external symbols.  */
4438   einfo.abfd = abfd;
4439   einfo.info = info;
4440   ecoff_link_hash_traverse (ecoff_hash_table (info),
4441                             ecoff_link_write_external,
4442                             (void *) &einfo);
4443
4444   if (info->relocatable)
4445     {
4446       /* We need to make a pass over the link_orders to count up the
4447          number of relocations we will need to output, so that we know
4448          how much space they will take up.  */
4449       for (o = abfd->sections; o != NULL; o = o->next)
4450         {
4451           o->reloc_count = 0;
4452           for (p = o->map_head.link_order;
4453                p != NULL;
4454                p = p->next)
4455             if (p->type == bfd_indirect_link_order)
4456               o->reloc_count += p->u.indirect.section->reloc_count;
4457             else if (p->type == bfd_section_reloc_link_order
4458                      || p->type == bfd_symbol_reloc_link_order)
4459               ++o->reloc_count;
4460         }
4461     }
4462
4463   /* Compute the reloc and symbol file positions.  */
4464   ecoff_compute_reloc_file_positions (abfd);
4465
4466   /* Write out the debugging information.  */
4467   if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug,
4468                                            &backend->debug_swap, info,
4469                                            ecoff_data (abfd)->sym_filepos))
4470     return FALSE;
4471
4472   bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info);
4473
4474   if (info->relocatable)
4475     {
4476       /* Now reset the reloc_count field of the sections in the output
4477          BFD to 0, so that we can use them to keep track of how many
4478          relocs we have output thus far.  */
4479       for (o = abfd->sections; o != NULL; o = o->next)
4480         o->reloc_count = 0;
4481     }
4482
4483   /* Get a value for the GP register.  */
4484   if (ecoff_data (abfd)->gp == 0)
4485     {
4486       struct bfd_link_hash_entry *h;
4487
4488       h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
4489       if (h != NULL
4490           && h->type == bfd_link_hash_defined)
4491         ecoff_data (abfd)->gp = (h->u.def.value
4492                                  + h->u.def.section->output_section->vma
4493                                  + h->u.def.section->output_offset);
4494       else if (info->relocatable)
4495         {
4496           bfd_vma lo;
4497
4498           /* Make up a value.  */
4499           lo = (bfd_vma) -1;
4500           for (o = abfd->sections; o != NULL; o = o->next)
4501             {
4502               if (o->vma < lo
4503                   && (streq (o->name, _SBSS)
4504                       || streq (o->name, _SDATA)
4505                       || streq (o->name, _LIT4)
4506                       || streq (o->name, _LIT8)
4507                       || streq (o->name, _LITA)))
4508                 lo = o->vma;
4509             }
4510           ecoff_data (abfd)->gp = lo + 0x8000;
4511         }
4512       else
4513         {
4514           /* If the relocate_section function needs to do a reloc
4515              involving the GP value, it should make a reloc_dangerous
4516              callback to warn that GP is not defined.  */
4517         }
4518     }
4519
4520   for (o = abfd->sections; o != NULL; o = o->next)
4521     {
4522       for (p = o->map_head.link_order;
4523            p != NULL;
4524            p = p->next)
4525         {
4526           if (p->type == bfd_indirect_link_order
4527               && (bfd_get_flavour (p->u.indirect.section->owner)
4528                   == bfd_target_ecoff_flavour))
4529             {
4530               if (! ecoff_indirect_link_order (abfd, info, o, p))
4531                 return FALSE;
4532             }
4533           else if (p->type == bfd_section_reloc_link_order
4534                    || p->type == bfd_symbol_reloc_link_order)
4535             {
4536               if (! ecoff_reloc_link_order (abfd, info, o, p))
4537                 return FALSE;
4538             }
4539           else
4540             {
4541               if (! _bfd_default_link_order (abfd, info, o, p))
4542                 return FALSE;
4543             }
4544         }
4545     }
4546
4547   bfd_get_symcount (abfd) = symhdr->iextMax + symhdr->isymMax;
4548
4549   ecoff_data (abfd)->linker = TRUE;
4550
4551   return TRUE;
4552 }