bfd/ecoff.c

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