bfd/ecoff.c

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