contrib/binutils-2.27/bfd/cofflink.c

   1 /* COFF specific linker code.
   2    Copyright (C) 1994-2016 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Cygnus Support.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 /* This file contains the COFF backend linker code.  */
  23
  24 #include "sysdep.h"
  25 #include "bfd.h"
  26 #include "bfdlink.h"
  27 #include "libbfd.h"
  28 #include "coff/internal.h"
  29 #include "libcoff.h"
  30 #include "safe-ctype.h"
  31
  32 static bfd_boolean coff_link_add_object_symbols (bfd *, struct bfd_link_info *);
  33 static bfd_boolean coff_link_check_archive_element
  34   (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
  35    bfd_boolean *);
  36 static bfd_boolean coff_link_add_symbols (bfd *, struct bfd_link_info *);
  37
  38 /* Return TRUE if SYM is a weak, external symbol.  */
  39 #define IS_WEAK_EXTERNAL(abfd, sym)                     \
  40   ((sym).n_sclass == C_WEAKEXT                          \
  41    || (obj_pe (abfd) && (sym).n_sclass == C_NT_WEAK))
  42
  43 /* Return TRUE if SYM is an external symbol.  */
  44 #define IS_EXTERNAL(abfd, sym)                          \
  45   ((sym).n_sclass == C_EXT || IS_WEAK_EXTERNAL (abfd, sym))
  46
  47 /* Define macros so that the ISFCN, et. al., macros work correctly.
  48    These macros are defined in include/coff/internal.h in terms of
  49    N_TMASK, etc.  These definitions require a user to define local
  50    variables with the appropriate names, and with values from the
  51    coff_data (abfd) structure.  */
  52
  53 #define N_TMASK n_tmask
  54 #define N_BTSHFT n_btshft
  55 #define N_BTMASK n_btmask
  56
  57 /* Create an entry in a COFF linker hash table.  */
  58
  59 struct bfd_hash_entry *
  60 _bfd_coff_link_hash_newfunc (struct bfd_hash_entry *entry,
  61                              struct bfd_hash_table *table,
  62                              const char *string)
  63 {
  64   struct coff_link_hash_entry *ret = (struct coff_link_hash_entry *) entry;
  65
  66   /* Allocate the structure if it has not already been allocated by a
  67      subclass.  */
  68   if (ret == (struct coff_link_hash_entry *) NULL)
  69     ret = ((struct coff_link_hash_entry *)
  70            bfd_hash_allocate (table, sizeof (struct coff_link_hash_entry)));
  71   if (ret == (struct coff_link_hash_entry *) NULL)
  72     return (struct bfd_hash_entry *) ret;
  73
  74   /* Call the allocation method of the superclass.  */
  75   ret = ((struct coff_link_hash_entry *)
  76          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
  77                                  table, string));
  78   if (ret != (struct coff_link_hash_entry *) NULL)
  79     {
  80       /* Set local fields.  */
  81       ret->indx = -1;
  82       ret->type = T_NULL;
  83       ret->symbol_class = C_NULL;
  84       ret->numaux = 0;
  85       ret->auxbfd = NULL;
  86       ret->aux = NULL;
  87     }
  88
  89   return (struct bfd_hash_entry *) ret;
  90 }
  91
  92 /* Initialize a COFF linker hash table.  */
  93
  94 bfd_boolean
  95 _bfd_coff_link_hash_table_init (struct coff_link_hash_table *table,
  96                                 bfd *abfd,
  97                                 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
  98                                                                    struct bfd_hash_table *,
  99                                                                    const char *),
 100                                 unsigned int entsize)
 101 {
 102   memset (&table->stab_info, 0, sizeof (table->stab_info));
 103   return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
 104 }
 105
 106 /* Create a COFF linker hash table.  */
 107
 108 struct bfd_link_hash_table *
 109 _bfd_coff_link_hash_table_create (bfd *abfd)
 110 {
 111   struct coff_link_hash_table *ret;
 112   bfd_size_type amt = sizeof (struct coff_link_hash_table);
 113
 114   ret = (struct coff_link_hash_table *) bfd_malloc (amt);
 115   if (ret == NULL)
 116     return NULL;
 117
 118   if (! _bfd_coff_link_hash_table_init (ret, abfd,
 119                                         _bfd_coff_link_hash_newfunc,
 120                                         sizeof (struct coff_link_hash_entry)))
 121     {
 122       free (ret);
 123       return (struct bfd_link_hash_table *) NULL;
 124     }
 125   return &ret->root;
 126 }
 127
 128 /* Create an entry in a COFF debug merge hash table.  */
 129
 130 struct bfd_hash_entry *
 131 _bfd_coff_debug_merge_hash_newfunc (struct bfd_hash_entry *entry,
 132                                     struct bfd_hash_table *table,
 133                                     const char *string)
 134 {
 135   struct coff_debug_merge_hash_entry *ret =
 136     (struct coff_debug_merge_hash_entry *) entry;
 137
 138   /* Allocate the structure if it has not already been allocated by a
 139      subclass.  */
 140   if (ret == (struct coff_debug_merge_hash_entry *) NULL)
 141     ret = ((struct coff_debug_merge_hash_entry *)
 142            bfd_hash_allocate (table,
 143                               sizeof (struct coff_debug_merge_hash_entry)));
 144   if (ret == (struct coff_debug_merge_hash_entry *) NULL)
 145     return (struct bfd_hash_entry *) ret;
 146
 147   /* Call the allocation method of the superclass.  */
 148   ret = ((struct coff_debug_merge_hash_entry *)
 149          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
 150   if (ret != (struct coff_debug_merge_hash_entry *) NULL)
 151     {
 152       /* Set local fields.  */
 153       ret->types = NULL;
 154     }
 155
 156   return (struct bfd_hash_entry *) ret;
 157 }
 158
 159 /* Given a COFF BFD, add symbols to the global hash table as
 160    appropriate.  */
 161
 162 bfd_boolean
 163 _bfd_coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
 164 {
 165   switch (bfd_get_format (abfd))
 166     {
 167     case bfd_object:
 168       return coff_link_add_object_symbols (abfd, info);
 169     case bfd_archive:
 170       return _bfd_generic_link_add_archive_symbols
 171         (abfd, info, coff_link_check_archive_element);
 172     default:
 173       bfd_set_error (bfd_error_wrong_format);
 174       return FALSE;
 175     }
 176 }
 177
 178 /* Add symbols from a COFF object file.  */
 179
 180 static bfd_boolean
 181 coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 182 {
 183   if (! _bfd_coff_get_external_symbols (abfd))
 184     return FALSE;
 185   if (! coff_link_add_symbols (abfd, info))
 186     return FALSE;
 187
 188   if (! info->keep_memory
 189       && ! _bfd_coff_free_symbols (abfd))
 190     return FALSE;
 191
 192   return TRUE;
 193 }
 194
 195 /* Check a single archive element to see if we need to include it in
 196    the link.  *PNEEDED is set according to whether this element is
 197    needed in the link or not.  This is called via
 198    _bfd_generic_link_add_archive_symbols.  */
 199
 200 static bfd_boolean
 201 coff_link_check_archive_element (bfd *abfd,
 202                                  struct bfd_link_info *info,
 203                                  struct bfd_link_hash_entry *h,
 204                                  const char *name,
 205                                  bfd_boolean *pneeded)
 206 {
 207   *pneeded = FALSE;
 208
 209   /* We are only interested in symbols that are currently undefined.
 210      If a symbol is currently known to be common, COFF linkers do not
 211      bring in an object file which defines it.  */
 212   if (h->type != bfd_link_hash_undefined)
 213     return TRUE;
 214
 215   /* Include this element?  */
 216   if (!(*info->callbacks->add_archive_element) (info, abfd, name, &abfd))
 217     return TRUE;
 218   *pneeded = TRUE;
 219
 220   return coff_link_add_object_symbols (abfd, info);
 221 }
 222
 223 /* Add all the symbols from an object file to the hash table.  */
 224
 225 static bfd_boolean
 226 coff_link_add_symbols (bfd *abfd,
 227                        struct bfd_link_info *info)
 228 {
 229   unsigned int n_tmask = coff_data (abfd)->local_n_tmask;
 230   unsigned int n_btshft = coff_data (abfd)->local_n_btshft;
 231   unsigned int n_btmask = coff_data (abfd)->local_n_btmask;
 232   bfd_boolean keep_syms;
 233   bfd_boolean default_copy;
 234   bfd_size_type symcount;
 235   struct coff_link_hash_entry **sym_hash;
 236   bfd_size_type symesz;
 237   bfd_byte *esym;
 238   bfd_byte *esym_end;
 239   bfd_size_type amt;
 240
 241   symcount = obj_raw_syment_count (abfd);
 242
 243   if (symcount == 0)
 244     return TRUE;                /* Nothing to do.  */
 245
 246   /* Keep the symbols during this function, in case the linker needs
 247      to read the generic symbols in order to report an error message.  */
 248   keep_syms = obj_coff_keep_syms (abfd);
 249   obj_coff_keep_syms (abfd) = TRUE;
 250
 251   if (info->keep_memory)
 252     default_copy = FALSE;
 253   else
 254     default_copy = TRUE;
 255
 256   /* We keep a list of the linker hash table entries that correspond
 257      to particular symbols.  */
 258   amt = symcount * sizeof (struct coff_link_hash_entry *);
 259   sym_hash = (struct coff_link_hash_entry **) bfd_zalloc (abfd, amt);
 260   if (sym_hash == NULL)
 261     goto error_return;
 262   obj_coff_sym_hashes (abfd) = sym_hash;
 263
 264   symesz = bfd_coff_symesz (abfd);
 265   BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
 266   esym = (bfd_byte *) obj_coff_external_syms (abfd);
 267   esym_end = esym + symcount * symesz;
 268   while (esym < esym_end)
 269     {
 270       struct internal_syment sym;
 271       enum coff_symbol_classification classification;
 272       bfd_boolean copy;
 273
 274       bfd_coff_swap_sym_in (abfd, esym, &sym);
 275
 276       classification = bfd_coff_classify_symbol (abfd, &sym);
 277       if (classification != COFF_SYMBOL_LOCAL)
 278         {
 279           const char *name;
 280           char buf[SYMNMLEN + 1];
 281           flagword flags;
 282           asection *section;
 283           bfd_vma value;
 284           bfd_boolean addit;
 285
 286           /* This symbol is externally visible.  */
 287
 288           name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
 289           if (name == NULL)
 290             goto error_return;
 291
 292           /* We must copy the name into memory if we got it from the
 293              syment itself, rather than the string table.  */
 294           copy = default_copy;
 295           if (sym._n._n_n._n_zeroes != 0
 296               || sym._n._n_n._n_offset == 0)
 297             copy = TRUE;
 298
 299           value = sym.n_value;
 300
 301           switch (classification)
 302             {
 303             default:
 304               abort ();
 305
 306             case COFF_SYMBOL_GLOBAL:
 307               flags = BSF_EXPORT | BSF_GLOBAL;
 308               section = coff_section_from_bfd_index (abfd, sym.n_scnum);
 309               if (! obj_pe (abfd))
 310                 value -= section->vma;
 311               break;
 312
 313             case COFF_SYMBOL_UNDEFINED:
 314               flags = 0;
 315               section = bfd_und_section_ptr;
 316               break;
 317
 318             case COFF_SYMBOL_COMMON:
 319               flags = BSF_GLOBAL;
 320               section = bfd_com_section_ptr;
 321               break;
 322
 323             case COFF_SYMBOL_PE_SECTION:
 324               flags = BSF_SECTION_SYM | BSF_GLOBAL;
 325               section = coff_section_from_bfd_index (abfd, sym.n_scnum);
 326               break;
 327             }
 328
 329           if (IS_WEAK_EXTERNAL (abfd, sym))
 330             flags = BSF_WEAK;
 331
 332           addit = TRUE;
 333
 334           /* In the PE format, section symbols actually refer to the
 335              start of the output section.  We handle them specially
 336              here.  */
 337           if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
 338             {
 339               *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
 340                                                  name, FALSE, copy, FALSE);
 341               if (*sym_hash != NULL)
 342                 {
 343                   if (((*sym_hash)->coff_link_hash_flags
 344                        & COFF_LINK_HASH_PE_SECTION_SYMBOL) == 0
 345                       && (*sym_hash)->root.type != bfd_link_hash_undefined
 346                       && (*sym_hash)->root.type != bfd_link_hash_undefweak)
 347                     (*_bfd_error_handler)
 348                       ("Warning: symbol `%s' is both section and non-section",
 349                        name);
 350
 351                   addit = FALSE;
 352                 }
 353             }
 354
 355           /* The Microsoft Visual C compiler does string pooling by
 356              hashing the constants to an internal symbol name, and
 357              relying on the linker comdat support to discard
 358              duplicate names.  However, if one string is a literal and
 359              one is a data initializer, one will end up in the .data
 360              section and one will end up in the .rdata section.  The
 361              Microsoft linker will combine them into the .data
 362              section, which seems to be wrong since it might cause the
 363              literal to change.
 364
 365              As long as there are no external references to the
 366              symbols, which there shouldn't be, we can treat the .data
 367              and .rdata instances as separate symbols.  The comdat
 368              code in the linker will do the appropriate merging.  Here
 369              we avoid getting a multiple definition error for one of
 370              these special symbols.
 371
 372              FIXME: I don't think this will work in the case where
 373              there are two object files which use the constants as a
 374              literal and two object files which use it as a data
 375              initializer.  One or the other of the second object files
 376              is going to wind up with an inappropriate reference.  */
 377           if (obj_pe (abfd)
 378               && (classification == COFF_SYMBOL_GLOBAL
 379                   || classification == COFF_SYMBOL_PE_SECTION)
 380               && coff_section_data (abfd, section) != NULL
 381               && coff_section_data (abfd, section)->comdat != NULL
 382               && CONST_STRNEQ (name, "??_")
 383               && strcmp (name, coff_section_data (abfd, section)->comdat->name) == 0)
 384             {
 385               if (*sym_hash == NULL)
 386                 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
 387                                                    name, FALSE, copy, FALSE);
 388               if (*sym_hash != NULL
 389                   && (*sym_hash)->root.type == bfd_link_hash_defined
 390                   && coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat != NULL
 391                   && strcmp (coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat->name,
 392                              coff_section_data (abfd, section)->comdat->name) == 0)
 393                 addit = FALSE;
 394             }
 395
 396           if (addit)
 397             {
 398               if (! (bfd_coff_link_add_one_symbol
 399                      (info, abfd, name, flags, section, value,
 400                       (const char *) NULL, copy, FALSE,
 401                       (struct bfd_link_hash_entry **) sym_hash)))
 402                 goto error_return;
 403             }
 404
 405           if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
 406             (*sym_hash)->coff_link_hash_flags |=
 407               COFF_LINK_HASH_PE_SECTION_SYMBOL;
 408
 409           /* Limit the alignment of a common symbol to the possible
 410              alignment of a section.  There is no point to permitting
 411              a higher alignment for a common symbol: we can not
 412              guarantee it, and it may cause us to allocate extra space
 413              in the common section.  */
 414           if (section == bfd_com_section_ptr
 415               && (*sym_hash)->root.type == bfd_link_hash_common
 416               && ((*sym_hash)->root.u.c.p->alignment_power
 417                   > bfd_coff_default_section_alignment_power (abfd)))
 418             (*sym_hash)->root.u.c.p->alignment_power
 419               = bfd_coff_default_section_alignment_power (abfd);
 420
 421           if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd))
 422             {
 423               /* If we don't have any symbol information currently in
 424                  the hash table, or if we are looking at a symbol
 425                  definition, then update the symbol class and type in
 426                  the hash table.  */
 427               if (((*sym_hash)->symbol_class == C_NULL
 428                    && (*sym_hash)->type == T_NULL)
 429                   || sym.n_scnum != 0
 430                   || (sym.n_value != 0
 431                       && (*sym_hash)->root.type != bfd_link_hash_defined
 432                       && (*sym_hash)->root.type != bfd_link_hash_defweak))
 433                 {
 434                   (*sym_hash)->symbol_class = sym.n_sclass;
 435                   if (sym.n_type != T_NULL)
 436                     {
 437                       /* We want to warn if the type changed, but not
 438                          if it changed from an unspecified type.
 439                          Testing the whole type byte may work, but the
 440                          change from (e.g.) a function of unspecified
 441                          type to function of known type also wants to
 442                          skip the warning.  */
 443                       if ((*sym_hash)->type != T_NULL
 444                           && (*sym_hash)->type != sym.n_type
 445                           && !(DTYPE ((*sym_hash)->type) == DTYPE (sym.n_type)
 446                                && (BTYPE ((*sym_hash)->type) == T_NULL
 447                                    || BTYPE (sym.n_type) == T_NULL)))
 448                         (*_bfd_error_handler)
 449                           (_("Warning: type of symbol `%s' changed from %d to %d in %B"),
 450                            abfd, name, (*sym_hash)->type, sym.n_type);
 451
 452                       /* We don't want to change from a meaningful
 453                          base type to a null one, but if we know
 454                          nothing, take what little we might now know.  */
 455                       if (BTYPE (sym.n_type) != T_NULL
 456                           || (*sym_hash)->type == T_NULL)
 457                         (*sym_hash)->type = sym.n_type;
 458                     }
 459                   (*sym_hash)->auxbfd = abfd;
 460                   if (sym.n_numaux != 0)
 461                     {
 462                       union internal_auxent *alloc;
 463                       unsigned int i;
 464                       bfd_byte *eaux;
 465                       union internal_auxent *iaux;
 466
 467                       (*sym_hash)->numaux = sym.n_numaux;
 468                       alloc = ((union internal_auxent *)
 469                                bfd_hash_allocate (&info->hash->table,
 470                                                   (sym.n_numaux
 471                                                    * sizeof (*alloc))));
 472                       if (alloc == NULL)
 473                         goto error_return;
 474                       for (i = 0, eaux = esym + symesz, iaux = alloc;
 475                            i < sym.n_numaux;
 476                            i++, eaux += symesz, iaux++)
 477                         bfd_coff_swap_aux_in (abfd, eaux, sym.n_type,
 478                                               sym.n_sclass, (int) i,
 479                                               sym.n_numaux, iaux);
 480                       (*sym_hash)->aux = alloc;
 481                     }
 482                 }
 483             }
 484
 485           if (classification == COFF_SYMBOL_PE_SECTION
 486               && (*sym_hash)->numaux != 0)
 487             {
 488               /* Some PE sections (such as .bss) have a zero size in
 489                  the section header, but a non-zero size in the AUX
 490                  record.  Correct that here.
 491
 492                  FIXME: This is not at all the right place to do this.
 493                  For example, it won't help objdump.  This needs to be
 494                  done when we swap in the section header.  */
 495               BFD_ASSERT ((*sym_hash)->numaux == 1);
 496               if (section->size == 0)
 497                 section->size = (*sym_hash)->aux[0].x_scn.x_scnlen;
 498
 499               /* FIXME: We could test whether the section sizes
 500                  matches the size in the aux entry, but apparently
 501                  that sometimes fails unexpectedly.  */
 502             }
 503         }
 504
 505       esym += (sym.n_numaux + 1) * symesz;
 506       sym_hash += sym.n_numaux + 1;
 507     }
 508
 509   /* If this is a non-traditional, non-relocatable link, try to
 510      optimize the handling of any .stab/.stabstr sections.  */
 511   if (! bfd_link_relocatable (info)
 512       && ! info->traditional_format
 513       && bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd)
 514       && (info->strip != strip_all && info->strip != strip_debugger))
 515     {
 516       asection *stabstr;
 517
 518       stabstr = bfd_get_section_by_name (abfd, ".stabstr");
 519
 520       if (stabstr != NULL)
 521         {
 522           bfd_size_type string_offset = 0;
 523           asection *stab;
 524
 525           for (stab = abfd->sections; stab; stab = stab->next)
 526             if (CONST_STRNEQ (stab->name, ".stab")
 527                 && (!stab->name[5]
 528                     || (stab->name[5] == '.' && ISDIGIT (stab->name[6]))))
 529             {
 530               struct coff_link_hash_table *table;
 531               struct coff_section_tdata *secdata
 532                 = coff_section_data (abfd, stab);
 533
 534               if (secdata == NULL)
 535                 {
 536                   amt = sizeof (struct coff_section_tdata);
 537                   stab->used_by_bfd = bfd_zalloc (abfd, amt);
 538                   if (stab->used_by_bfd == NULL)
 539                     goto error_return;
 540                   secdata = coff_section_data (abfd, stab);
 541                 }
 542
 543               table = coff_hash_table (info);
 544
 545               if (! _bfd_link_section_stabs (abfd, &table->stab_info,
 546                                              stab, stabstr,
 547                                              &secdata->stab_info,
 548                                              &string_offset))
 549                 goto error_return;
 550             }
 551         }
 552     }
 553
 554   obj_coff_keep_syms (abfd) = keep_syms;
 555
 556   return TRUE;
 557
 558  error_return:
 559   obj_coff_keep_syms (abfd) = keep_syms;
 560   return FALSE;
 561 }
 562 \f
 563 /* Do the final link step.  */
 564
 565 bfd_boolean
 566 _bfd_coff_final_link (bfd *abfd,
 567                       struct bfd_link_info *info)
 568 {
 569   bfd_size_type symesz;
 570   struct coff_final_link_info flaginfo;
 571   bfd_boolean debug_merge_allocated;
 572   bfd_boolean long_section_names;
 573   asection *o;
 574   struct bfd_link_order *p;
 575   bfd_size_type max_sym_count;
 576   bfd_size_type max_lineno_count;
 577   bfd_size_type max_reloc_count;
 578   bfd_size_type max_output_reloc_count;
 579   bfd_size_type max_contents_size;
 580   file_ptr rel_filepos;
 581   unsigned int relsz;
 582   file_ptr line_filepos;
 583   unsigned int linesz;
 584   bfd *sub;
 585   bfd_byte *external_relocs = NULL;
 586   char strbuf[STRING_SIZE_SIZE];
 587   bfd_size_type amt;
 588
 589   symesz = bfd_coff_symesz (abfd);
 590
 591   flaginfo.info = info;
 592   flaginfo.output_bfd = abfd;
 593   flaginfo.strtab = NULL;
 594   flaginfo.section_info = NULL;
 595   flaginfo.last_file_index = -1;
 596   flaginfo.last_bf_index = -1;
 597   flaginfo.internal_syms = NULL;
 598   flaginfo.sec_ptrs = NULL;
 599   flaginfo.sym_indices = NULL;
 600   flaginfo.outsyms = NULL;
 601   flaginfo.linenos = NULL;
 602   flaginfo.contents = NULL;
 603   flaginfo.external_relocs = NULL;
 604   flaginfo.internal_relocs = NULL;
 605   flaginfo.global_to_static = FALSE;
 606   debug_merge_allocated = FALSE;
 607
 608   coff_data (abfd)->link_info = info;
 609
 610   flaginfo.strtab = _bfd_stringtab_init ();
 611   if (flaginfo.strtab == NULL)
 612     goto error_return;
 613
 614   if (! coff_debug_merge_hash_table_init (&flaginfo.debug_merge))
 615     goto error_return;
 616   debug_merge_allocated = TRUE;
 617
 618   /* Compute the file positions for all the sections.  */
 619   if (! abfd->output_has_begun)
 620     {
 621       if (! bfd_coff_compute_section_file_positions (abfd))
 622         goto error_return;
 623     }
 624
 625   /* Count the line numbers and relocation entries required for the
 626      output file.  Set the file positions for the relocs.  */
 627   rel_filepos = obj_relocbase (abfd);
 628   relsz = bfd_coff_relsz (abfd);
 629   max_contents_size = 0;
 630   max_lineno_count = 0;
 631   max_reloc_count = 0;
 632
 633   long_section_names = FALSE;
 634   for (o = abfd->sections; o != NULL; o = o->next)
 635     {
 636       o->reloc_count = 0;
 637       o->lineno_count = 0;
 638       for (p = o->map_head.link_order; p != NULL; p = p->next)
 639         {
 640           if (p->type == bfd_indirect_link_order)
 641             {
 642               asection *sec;
 643
 644               sec = p->u.indirect.section;
 645
 646               /* Mark all sections which are to be included in the
 647                  link.  This will normally be every section.  We need
 648                  to do this so that we can identify any sections which
 649                  the linker has decided to not include.  */
 650               sec->linker_mark = TRUE;
 651
 652               if (info->strip == strip_none
 653                   || info->strip == strip_some)
 654                 o->lineno_count += sec->lineno_count;
 655
 656               if (bfd_link_relocatable (info))
 657                 o->reloc_count += sec->reloc_count;
 658
 659               if (sec->rawsize > max_contents_size)
 660                 max_contents_size = sec->rawsize;
 661               if (sec->size > max_contents_size)
 662                 max_contents_size = sec->size;
 663               if (sec->lineno_count > max_lineno_count)
 664                 max_lineno_count = sec->lineno_count;
 665               if (sec->reloc_count > max_reloc_count)
 666                 max_reloc_count = sec->reloc_count;
 667             }
 668           else if (bfd_link_relocatable (info)
 669                    && (p->type == bfd_section_reloc_link_order
 670                        || p->type == bfd_symbol_reloc_link_order))
 671             ++o->reloc_count;
 672         }
 673       if (o->reloc_count == 0)
 674         o->rel_filepos = 0;
 675       else
 676         {
 677           o->flags |= SEC_RELOC;
 678           o->rel_filepos = rel_filepos;
 679           rel_filepos += o->reloc_count * relsz;
 680           /* In PE COFF, if there are at least 0xffff relocations an
 681              extra relocation will be written out to encode the count.  */
 682           if (obj_pe (abfd) && o->reloc_count >= 0xffff)
 683             rel_filepos += relsz;
 684         }
 685
 686       if (bfd_coff_long_section_names (abfd)
 687           && strlen (o->name) > SCNNMLEN)
 688         {
 689           /* This section has a long name which must go in the string
 690              table.  This must correspond to the code in
 691              coff_write_object_contents which puts the string index
 692              into the s_name field of the section header.  That is why
 693              we pass hash as FALSE.  */
 694           if (_bfd_stringtab_add (flaginfo.strtab, o->name, FALSE, FALSE)
 695               == (bfd_size_type) -1)
 696             goto error_return;
 697           long_section_names = TRUE;
 698         }
 699     }
 700
 701   /* If doing a relocatable link, allocate space for the pointers we
 702      need to keep.  */
 703   if (bfd_link_relocatable (info))
 704     {
 705       unsigned int i;
 706
 707       /* We use section_count + 1, rather than section_count, because
 708          the target_index fields are 1 based.  */
 709       amt = abfd->section_count + 1;
 710       amt *= sizeof (struct coff_link_section_info);
 711       flaginfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
 712       if (flaginfo.section_info == NULL)
 713         goto error_return;
 714       for (i = 0; i <= abfd->section_count; i++)
 715         {
 716           flaginfo.section_info[i].relocs = NULL;
 717           flaginfo.section_info[i].rel_hashes = NULL;
 718         }
 719     }
 720
 721   /* We now know the size of the relocs, so we can determine the file
 722      positions of the line numbers.  */
 723   line_filepos = rel_filepos;
 724   linesz = bfd_coff_linesz (abfd);
 725   max_output_reloc_count = 0;
 726   for (o = abfd->sections; o != NULL; o = o->next)
 727     {
 728       if (o->lineno_count == 0)
 729         o->line_filepos = 0;
 730       else
 731         {
 732           o->line_filepos = line_filepos;
 733           line_filepos += o->lineno_count * linesz;
 734         }
 735
 736       if (o->reloc_count != 0)
 737         {
 738           /* We don't know the indices of global symbols until we have
 739              written out all the local symbols.  For each section in
 740              the output file, we keep an array of pointers to hash
 741              table entries.  Each entry in the array corresponds to a
 742              reloc.  When we find a reloc against a global symbol, we
 743              set the corresponding entry in this array so that we can
 744              fix up the symbol index after we have written out all the
 745              local symbols.
 746
 747              Because of this problem, we also keep the relocs in
 748              memory until the end of the link.  This wastes memory,
 749              but only when doing a relocatable link, which is not the
 750              common case.  */
 751           BFD_ASSERT (bfd_link_relocatable (info));
 752           amt = o->reloc_count;
 753           amt *= sizeof (struct internal_reloc);
 754           flaginfo.section_info[o->target_index].relocs =
 755               (struct internal_reloc *) bfd_malloc (amt);
 756           amt = o->reloc_count;
 757           amt *= sizeof (struct coff_link_hash_entry *);
 758           flaginfo.section_info[o->target_index].rel_hashes =
 759               (struct coff_link_hash_entry **) bfd_malloc (amt);
 760           if (flaginfo.section_info[o->target_index].relocs == NULL
 761               || flaginfo.section_info[o->target_index].rel_hashes == NULL)
 762             goto error_return;
 763
 764           if (o->reloc_count > max_output_reloc_count)
 765             max_output_reloc_count = o->reloc_count;
 766         }
 767
 768       /* Reset the reloc and lineno counts, so that we can use them to
 769          count the number of entries we have output so far.  */
 770       o->reloc_count = 0;
 771       o->lineno_count = 0;
 772     }
 773
 774   obj_sym_filepos (abfd) = line_filepos;
 775
 776   /* Figure out the largest number of symbols in an input BFD.  Take
 777      the opportunity to clear the output_has_begun fields of all the
 778      input BFD's.  */
 779   max_sym_count = 0;
 780   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
 781     {
 782       size_t sz;
 783
 784       sub->output_has_begun = FALSE;
 785       sz = bfd_family_coff (sub) ? obj_raw_syment_count (sub) : 2;
 786       if (sz > max_sym_count)
 787         max_sym_count = sz;
 788     }
 789
 790   /* Allocate some buffers used while linking.  */
 791   amt = max_sym_count * sizeof (struct internal_syment);
 792   flaginfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
 793   amt = max_sym_count * sizeof (asection *);
 794   flaginfo.sec_ptrs = (asection **) bfd_malloc (amt);
 795   amt = max_sym_count * sizeof (long);
 796   flaginfo.sym_indices = (long int *) bfd_malloc (amt);
 797   flaginfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz);
 798   amt = max_lineno_count * bfd_coff_linesz (abfd);
 799   flaginfo.linenos = (bfd_byte *) bfd_malloc (amt);
 800   flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
 801   amt = max_reloc_count * relsz;
 802   flaginfo.external_relocs = (bfd_byte *) bfd_malloc (amt);
 803   if (! bfd_link_relocatable (info))
 804     {
 805       amt = max_reloc_count * sizeof (struct internal_reloc);
 806       flaginfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
 807     }
 808   if ((flaginfo.internal_syms == NULL && max_sym_count > 0)
 809       || (flaginfo.sec_ptrs == NULL && max_sym_count > 0)
 810       || (flaginfo.sym_indices == NULL && max_sym_count > 0)
 811       || flaginfo.outsyms == NULL
 812       || (flaginfo.linenos == NULL && max_lineno_count > 0)
 813       || (flaginfo.contents == NULL && max_contents_size > 0)
 814       || (flaginfo.external_relocs == NULL && max_reloc_count > 0)
 815       || (! bfd_link_relocatable (info)
 816           && flaginfo.internal_relocs == NULL
 817           && max_reloc_count > 0))
 818     goto error_return;
 819
 820   /* We now know the position of everything in the file, except that
 821      we don't know the size of the symbol table and therefore we don't
 822      know where the string table starts.  We just build the string
 823      table in memory as we go along.  We process all the relocations
 824      for a single input file at once.  */
 825   obj_raw_syment_count (abfd) = 0;
 826
 827   if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
 828     {
 829       if (! bfd_coff_start_final_link (abfd, info))
 830         goto error_return;
 831     }
 832
 833   for (o = abfd->sections; o != NULL; o = o->next)
 834     {
 835       for (p = o->map_head.link_order; p != NULL; p = p->next)
 836         {
 837           if (p->type == bfd_indirect_link_order
 838               && bfd_family_coff (p->u.indirect.section->owner))
 839             {
 840               sub = p->u.indirect.section->owner;
 841               if (! bfd_coff_link_output_has_begun (sub, & flaginfo))
 842                 {
 843                   if (! _bfd_coff_link_input_bfd (&flaginfo, sub))
 844                     goto error_return;
 845                   sub->output_has_begun = TRUE;
 846                 }
 847             }
 848           else if (p->type == bfd_section_reloc_link_order
 849                    || p->type == bfd_symbol_reloc_link_order)
 850             {
 851               if (! _bfd_coff_reloc_link_order (abfd, &flaginfo, o, p))
 852                 goto error_return;
 853             }
 854           else
 855             {
 856               if (! _bfd_default_link_order (abfd, info, o, p))
 857                 goto error_return;
 858             }
 859         }
 860     }
 861
 862   if (flaginfo.info->strip != strip_all && flaginfo.info->discard != discard_all)
 863     {
 864       /* Add local symbols from foreign inputs.  */
 865       for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
 866         {
 867           unsigned int i;
 868
 869           if (bfd_family_coff (sub) || ! bfd_get_outsymbols (sub))
 870             continue;
 871           for (i = 0; i < bfd_get_symcount (sub); ++i)
 872             {
 873               asymbol *sym = bfd_get_outsymbols (sub) [i];
 874               file_ptr pos;
 875               struct internal_syment isym;
 876               union internal_auxent iaux;
 877               bfd_size_type string_size = 0, indx;
 878               bfd_vma written = 0;
 879               bfd_boolean rewrite = FALSE, hash;
 880
 881               if (! (sym->flags & BSF_LOCAL)
 882                   || (sym->flags & (BSF_SECTION_SYM | BSF_DEBUGGING_RELOC
 883                                     | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC
 884                                     | BSF_SYNTHETIC))
 885                   || ((sym->flags & BSF_DEBUGGING)
 886                       && ! (sym->flags & BSF_FILE)))
 887                 continue;
 888
 889               /* See if we are discarding symbols with this name.  */
 890               if ((flaginfo.info->strip == strip_some
 891                    && (bfd_hash_lookup (flaginfo.info->keep_hash,
 892                                         bfd_asymbol_name(sym), FALSE, FALSE)
 893                        == NULL))
 894                   || (((flaginfo.info->discard == discard_sec_merge
 895                         && (bfd_get_section (sym)->flags & SEC_MERGE)
 896                         && ! bfd_link_relocatable (flaginfo.info))
 897                        || flaginfo.info->discard == discard_l)
 898                       && bfd_is_local_label_name (sub, bfd_asymbol_name(sym))))
 899                 continue;
 900
 901               pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd)
 902                                              * symesz;
 903               if (bfd_seek (abfd, pos, SEEK_SET) != 0)
 904                 goto error_return;
 905               if (! coff_write_alien_symbol(abfd, sym, &isym, &iaux, &written,
 906                                             &string_size, NULL, NULL))
 907                 goto error_return;
 908
 909               hash = !flaginfo.info->traditional_format;
 910
 911               if (string_size >= 6 && isym.n_sclass == C_FILE
 912                   && ! isym._n._n_n._n_zeroes && isym.n_numaux)
 913                 {
 914                   indx = _bfd_stringtab_add (flaginfo.strtab, ".file", hash,
 915                                              FALSE);
 916                   if (indx == (bfd_size_type) -1)
 917                     goto error_return;
 918                   isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
 919                   bfd_coff_swap_sym_out (abfd, &isym, flaginfo.outsyms);
 920                   if (bfd_seek (abfd, pos, SEEK_SET) != 0
 921                       || bfd_bwrite (flaginfo.outsyms, symesz,
 922                                      abfd) != symesz)
 923                     goto error_return;
 924                   string_size -= 6;
 925                 }
 926
 927               if (string_size)
 928                 {
 929                   indx = _bfd_stringtab_add (flaginfo.strtab,
 930                                              bfd_asymbol_name (sym), hash,
 931                                              FALSE);
 932                   if (indx == (bfd_size_type) -1)
 933                     goto error_return;
 934                   if (isym.n_sclass != C_FILE)
 935                     {
 936                       isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
 937                       bfd_coff_swap_sym_out (abfd, &isym, flaginfo.outsyms);
 938                       rewrite = TRUE;
 939                     }
 940                   else
 941                     {
 942                       BFD_ASSERT (isym.n_numaux == 1);
 943                       iaux.x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
 944                       bfd_coff_swap_aux_out (abfd, &iaux, isym.n_type, C_FILE,
 945                                              0, 1, flaginfo.outsyms + symesz);
 946                       if (bfd_seek (abfd, pos + symesz, SEEK_SET) != 0
 947                           || bfd_bwrite (flaginfo.outsyms + symesz, symesz,
 948                                          abfd) != symesz)
 949                         goto error_return;
 950                     }
 951                 }
 952
 953               if (isym.n_sclass == C_FILE)
 954                 {
 955                   if (flaginfo.last_file_index != -1)
 956                     {
 957                       flaginfo.last_file.n_value = obj_raw_syment_count (abfd);
 958                       bfd_coff_swap_sym_out (abfd, &flaginfo.last_file,
 959                                              flaginfo.outsyms);
 960                       pos = obj_sym_filepos (abfd) + flaginfo.last_file_index
 961                                                      * symesz;
 962                       rewrite = TRUE;
 963                     }
 964                   flaginfo.last_file_index = obj_raw_syment_count (abfd);
 965                   flaginfo.last_file = isym;
 966                 }
 967
 968               if (rewrite
 969                   && (bfd_seek (abfd, pos, SEEK_SET) != 0
 970                       || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz))
 971                 goto error_return;
 972
 973               obj_raw_syment_count (abfd) += written;
 974             }
 975         }
 976     }
 977
 978   if (! bfd_coff_final_link_postscript (abfd, & flaginfo))
 979     goto error_return;
 980
 981   /* Free up the buffers used by _bfd_coff_link_input_bfd.  */
 982
 983   coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
 984   debug_merge_allocated = FALSE;
 985
 986   if (flaginfo.internal_syms != NULL)
 987     {
 988       free (flaginfo.internal_syms);
 989       flaginfo.internal_syms = NULL;
 990     }
 991   if (flaginfo.sec_ptrs != NULL)
 992     {
 993       free (flaginfo.sec_ptrs);
 994       flaginfo.sec_ptrs = NULL;
 995     }
 996   if (flaginfo.sym_indices != NULL)
 997     {
 998       free (flaginfo.sym_indices);
 999       flaginfo.sym_indices = NULL;
1000     }
1001   if (flaginfo.linenos != NULL)
1002     {
1003       free (flaginfo.linenos);
1004       flaginfo.linenos = NULL;
1005     }
1006   if (flaginfo.contents != NULL)
1007     {
1008       free (flaginfo.contents);
1009       flaginfo.contents = NULL;
1010     }
1011   if (flaginfo.external_relocs != NULL)
1012     {
1013       free (flaginfo.external_relocs);
1014       flaginfo.external_relocs = NULL;
1015     }
1016   if (flaginfo.internal_relocs != NULL)
1017     {
1018       free (flaginfo.internal_relocs);
1019       flaginfo.internal_relocs = NULL;
1020     }
1021
1022   /* The value of the last C_FILE symbol is supposed to be the symbol
1023      index of the first external symbol.  Write it out again if
1024      necessary.  */
1025   if (flaginfo.last_file_index != -1
1026       && (unsigned int) flaginfo.last_file.n_value != obj_raw_syment_count (abfd))
1027     {
1028       file_ptr pos;
1029
1030       flaginfo.last_file.n_value = obj_raw_syment_count (abfd);
1031       bfd_coff_swap_sym_out (abfd, &flaginfo.last_file,
1032                              flaginfo.outsyms);
1033
1034       pos = obj_sym_filepos (abfd) + flaginfo.last_file_index * symesz;
1035       if (bfd_seek (abfd, pos, SEEK_SET) != 0
1036           || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz)
1037         return FALSE;
1038     }
1039
1040   /* If doing task linking (ld --task-link) then make a pass through the
1041      global symbols, writing out any that are defined, and making them
1042      static.  */
1043   if (info->task_link)
1044     {
1045       flaginfo.failed = FALSE;
1046       coff_link_hash_traverse (coff_hash_table (info),
1047                                _bfd_coff_write_task_globals, &flaginfo);
1048       if (flaginfo.failed)
1049         goto error_return;
1050     }
1051
1052   /* Write out the global symbols.  */
1053   flaginfo.failed = FALSE;
1054   bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &flaginfo);
1055   if (flaginfo.failed)
1056     goto error_return;
1057
1058   /* The outsyms buffer is used by _bfd_coff_write_global_sym.  */
1059   if (flaginfo.outsyms != NULL)
1060     {
1061       free (flaginfo.outsyms);
1062       flaginfo.outsyms = NULL;
1063     }
1064
1065   if (bfd_link_relocatable (info) && max_output_reloc_count > 0)
1066     {
1067       /* Now that we have written out all the global symbols, we know
1068          the symbol indices to use for relocs against them, and we can
1069          finally write out the relocs.  */
1070       amt = max_output_reloc_count * relsz;
1071       external_relocs = (bfd_byte *) bfd_malloc (amt);
1072       if (external_relocs == NULL)
1073         goto error_return;
1074
1075       for (o = abfd->sections; o != NULL; o = o->next)
1076         {
1077           struct internal_reloc *irel;
1078           struct internal_reloc *irelend;
1079           struct coff_link_hash_entry **rel_hash;
1080           bfd_byte *erel;
1081
1082           if (o->reloc_count == 0)
1083             continue;
1084
1085           irel = flaginfo.section_info[o->target_index].relocs;
1086           irelend = irel + o->reloc_count;
1087           rel_hash = flaginfo.section_info[o->target_index].rel_hashes;
1088           erel = external_relocs;
1089           for (; irel < irelend; irel++, rel_hash++, erel += relsz)
1090             {
1091               if (*rel_hash != NULL)
1092                 {
1093                   BFD_ASSERT ((*rel_hash)->indx >= 0);
1094                   irel->r_symndx = (*rel_hash)->indx;
1095                 }
1096               bfd_coff_swap_reloc_out (abfd, irel, erel);
1097             }
1098
1099           if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0)
1100             goto error_return;
1101           if (obj_pe (abfd) && o->reloc_count >= 0xffff)
1102             {
1103               /* In PE COFF, write the count of relocs as the first
1104                  reloc.  The header overflow bit will be set
1105                  elsewhere. */
1106               struct internal_reloc incount;
1107               bfd_byte *excount = (bfd_byte *)bfd_malloc (relsz);
1108
1109               memset (&incount, 0, sizeof (incount));
1110               incount.r_vaddr = o->reloc_count + 1;
1111               bfd_coff_swap_reloc_out (abfd, &incount, excount);
1112               if (bfd_bwrite (excount, relsz, abfd) != relsz)
1113                 /* We'll leak, but it's an error anyway. */
1114                 goto error_return;
1115               free (excount);
1116             }
1117           if (bfd_bwrite (external_relocs,
1118                           (bfd_size_type) relsz * o->reloc_count, abfd)
1119               != (bfd_size_type) relsz * o->reloc_count)
1120             goto error_return;
1121         }
1122
1123       free (external_relocs);
1124       external_relocs = NULL;
1125     }
1126
1127   /* Free up the section information.  */
1128   if (flaginfo.section_info != NULL)
1129     {
1130       unsigned int i;
1131
1132       for (i = 0; i < abfd->section_count; i++)
1133         {
1134           if (flaginfo.section_info[i].relocs != NULL)
1135             free (flaginfo.section_info[i].relocs);
1136           if (flaginfo.section_info[i].rel_hashes != NULL)
1137             free (flaginfo.section_info[i].rel_hashes);
1138         }
1139       free (flaginfo.section_info);
1140       flaginfo.section_info = NULL;
1141     }
1142
1143   /* If we have optimized stabs strings, output them.  */
1144   if (coff_hash_table (info)->stab_info.stabstr != NULL)
1145     {
1146       if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
1147         return FALSE;
1148     }
1149
1150   /* Write out the string table.  */
1151   if (obj_raw_syment_count (abfd) != 0 || long_section_names)
1152     {
1153       file_ptr pos;
1154
1155       pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
1156       if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1157         return FALSE;
1158
1159 #if STRING_SIZE_SIZE == 4
1160       H_PUT_32 (abfd,
1161                 _bfd_stringtab_size (flaginfo.strtab) + STRING_SIZE_SIZE,
1162                 strbuf);
1163 #else
1164  #error Change H_PUT_32 above
1165 #endif
1166
1167       if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
1168           != STRING_SIZE_SIZE)
1169         return FALSE;
1170
1171       if (! _bfd_stringtab_emit (abfd, flaginfo.strtab))
1172         return FALSE;
1173
1174       obj_coff_strings_written (abfd) = TRUE;
1175     }
1176
1177   _bfd_stringtab_free (flaginfo.strtab);
1178
1179   /* Setting bfd_get_symcount to 0 will cause write_object_contents to
1180      not try to write out the symbols.  */
1181   bfd_get_symcount (abfd) = 0;
1182
1183   return TRUE;
1184
1185  error_return:
1186   if (debug_merge_allocated)
1187     coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
1188   if (flaginfo.strtab != NULL)
1189     _bfd_stringtab_free (flaginfo.strtab);
1190   if (flaginfo.section_info != NULL)
1191     {
1192       unsigned int i;
1193
1194       for (i = 0; i < abfd->section_count; i++)
1195         {
1196           if (flaginfo.section_info[i].relocs != NULL)
1197             free (flaginfo.section_info[i].relocs);
1198           if (flaginfo.section_info[i].rel_hashes != NULL)
1199             free (flaginfo.section_info[i].rel_hashes);
1200         }
1201       free (flaginfo.section_info);
1202     }
1203   if (flaginfo.internal_syms != NULL)
1204     free (flaginfo.internal_syms);
1205   if (flaginfo.sec_ptrs != NULL)
1206     free (flaginfo.sec_ptrs);
1207   if (flaginfo.sym_indices != NULL)
1208     free (flaginfo.sym_indices);
1209   if (flaginfo.outsyms != NULL)
1210     free (flaginfo.outsyms);
1211   if (flaginfo.linenos != NULL)
1212     free (flaginfo.linenos);
1213   if (flaginfo.contents != NULL)
1214     free (flaginfo.contents);
1215   if (flaginfo.external_relocs != NULL)
1216     free (flaginfo.external_relocs);
1217   if (flaginfo.internal_relocs != NULL)
1218     free (flaginfo.internal_relocs);
1219   if (external_relocs != NULL)
1220     free (external_relocs);
1221   return FALSE;
1222 }
1223
1224 /* Parse out a -heap <reserved>,<commit> line.  */
1225
1226 static char *
1227 dores_com (char *ptr, bfd *output_bfd, int heap)
1228 {
1229   if (coff_data(output_bfd)->pe)
1230     {
1231       int val = strtoul (ptr, &ptr, 0);
1232
1233       if (heap)
1234         pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val;
1235       else
1236         pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve = val;
1237
1238       if (ptr[0] == ',')
1239         {
1240           val = strtoul (ptr+1, &ptr, 0);
1241           if (heap)
1242             pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit = val;
1243           else
1244             pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit = val;
1245         }
1246     }
1247   return ptr;
1248 }
1249
1250 static char *
1251 get_name (char *ptr, char **dst)
1252 {
1253   while (*ptr == ' ')
1254     ptr++;
1255   *dst = ptr;
1256   while (*ptr && *ptr != ' ')
1257     ptr++;
1258   *ptr = 0;
1259   return ptr+1;
1260 }
1261
1262 /* Process any magic embedded commands in a section called .drectve.  */
1263
1264 static int
1265 process_embedded_commands (bfd *output_bfd,
1266                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
1267                            bfd *abfd)
1268 {
1269   asection *sec = bfd_get_section_by_name (abfd, ".drectve");
1270   char *s;
1271   char *e;
1272   bfd_byte *copy;
1273
1274   if (!sec)
1275     return 1;
1276
1277   if (!bfd_malloc_and_get_section (abfd, sec, &copy))
1278     {
1279       if (copy != NULL)
1280         free (copy);
1281       return 0;
1282     }
1283   e = (char *) copy + sec->size;
1284
1285   for (s = (char *) copy; s < e ; )
1286     {
1287       if (s[0] != '-')
1288         {
1289           s++;
1290           continue;
1291         }
1292       if (CONST_STRNEQ (s, "-attr"))
1293         {
1294           char *name;
1295           char *attribs;
1296           asection *asec;
1297           int loop = 1;
1298           int had_write = 0;
1299           int had_exec= 0;
1300
1301           s += 5;
1302           s = get_name (s, &name);
1303           s = get_name (s, &attribs);
1304
1305           while (loop)
1306             {
1307               switch (*attribs++)
1308                 {
1309                 case 'W':
1310                   had_write = 1;
1311                   break;
1312                 case 'R':
1313                   break;
1314                 case 'S':
1315                   break;
1316                 case 'X':
1317                   had_exec = 1;
1318                   break;
1319                 default:
1320                   loop = 0;
1321                 }
1322             }
1323           asec = bfd_get_section_by_name (abfd, name);
1324           if (asec)
1325             {
1326               if (had_exec)
1327                 asec->flags |= SEC_CODE;
1328               if (!had_write)
1329                 asec->flags |= SEC_READONLY;
1330             }
1331         }
1332       else if (CONST_STRNEQ (s, "-heap"))
1333         s = dores_com (s + 5, output_bfd, 1);
1334
1335       else if (CONST_STRNEQ (s, "-stack"))
1336         s = dores_com (s + 6, output_bfd, 0);
1337
1338       /* GNU extension for aligned commons.  */
1339       else if (CONST_STRNEQ (s, "-aligncomm:"))
1340         {
1341           /* Common symbols must be aligned on reading, as it
1342           is too late to do anything here, after they have
1343           already been allocated, so just skip the directive.  */
1344           s += 11;
1345         }
1346
1347       else
1348         s++;
1349     }
1350   free (copy);
1351   return 1;
1352 }
1353
1354 /* Place a marker against all symbols which are used by relocations.
1355    This marker can be picked up by the 'do we skip this symbol ?'
1356    loop in _bfd_coff_link_input_bfd() and used to prevent skipping
1357    that symbol.  */
1358
1359 static void
1360 mark_relocs (struct coff_final_link_info *flaginfo, bfd *input_bfd)
1361 {
1362   asection * a;
1363
1364   if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0)
1365     return;
1366
1367   for (a = input_bfd->sections; a != (asection *) NULL; a = a->next)
1368     {
1369       struct internal_reloc *   internal_relocs;
1370       struct internal_reloc *   irel;
1371       struct internal_reloc *   irelend;
1372
1373       if ((a->flags & SEC_RELOC) == 0 || a->reloc_count  < 1
1374           || a->linker_mark == 0)
1375         continue;
1376       /* Don't mark relocs in excluded sections.  */
1377       if (a->output_section == bfd_abs_section_ptr)
1378         continue;
1379
1380       /* Read in the relocs.  */
1381       internal_relocs = _bfd_coff_read_internal_relocs
1382         (input_bfd, a, FALSE,
1383          flaginfo->external_relocs,
1384          bfd_link_relocatable (flaginfo->info),
1385          (bfd_link_relocatable (flaginfo->info)
1386           ? (flaginfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
1387           : flaginfo->internal_relocs)
1388         );
1389
1390       if (internal_relocs == NULL)
1391         continue;
1392
1393       irel     = internal_relocs;
1394       irelend  = irel + a->reloc_count;
1395
1396       /* Place a mark in the sym_indices array (whose entries have
1397          been initialised to 0) for all of the symbols that are used
1398          in the relocation table.  This will then be picked up in the
1399          skip/don't-skip pass.  */
1400       for (; irel < irelend; irel++)
1401         flaginfo->sym_indices[ irel->r_symndx ] = -1;
1402     }
1403 }
1404
1405 /* Link an input file into the linker output file.  This function
1406    handles all the sections and relocations of the input file at once.  */
1407
1408 bfd_boolean
1409 _bfd_coff_link_input_bfd (struct coff_final_link_info *flaginfo, bfd *input_bfd)
1410 {
1411   unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
1412   unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
1413   bfd_boolean (*adjust_symndx)
1414     (bfd *, struct bfd_link_info *, bfd *, asection *,
1415      struct internal_reloc *, bfd_boolean *);
1416   bfd *output_bfd;
1417   const char *strings;
1418   bfd_size_type syment_base;
1419   bfd_boolean copy, hash;
1420   bfd_size_type isymesz;
1421   bfd_size_type osymesz;
1422   bfd_size_type linesz;
1423   bfd_byte *esym;
1424   bfd_byte *esym_end;
1425   struct internal_syment *isymp;
1426   asection **secpp;
1427   long *indexp;
1428   unsigned long output_index;
1429   bfd_byte *outsym;
1430   struct coff_link_hash_entry **sym_hash;
1431   asection *o;
1432
1433   /* Move all the symbols to the output file.  */
1434
1435   output_bfd = flaginfo->output_bfd;
1436   strings = NULL;
1437   syment_base = obj_raw_syment_count (output_bfd);
1438   isymesz = bfd_coff_symesz (input_bfd);
1439   osymesz = bfd_coff_symesz (output_bfd);
1440   linesz = bfd_coff_linesz (input_bfd);
1441   BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
1442
1443   copy = FALSE;
1444   if (! flaginfo->info->keep_memory)
1445     copy = TRUE;
1446   hash = TRUE;
1447   if (flaginfo->info->traditional_format)
1448     hash = FALSE;
1449
1450   if (! _bfd_coff_get_external_symbols (input_bfd))
1451     return FALSE;
1452
1453   esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1454   esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1455   isymp = flaginfo->internal_syms;
1456   secpp = flaginfo->sec_ptrs;
1457   indexp = flaginfo->sym_indices;
1458   output_index = syment_base;
1459   outsym = flaginfo->outsyms;
1460
1461   if (coff_data (output_bfd)->pe
1462       && ! process_embedded_commands (output_bfd, flaginfo->info, input_bfd))
1463     return FALSE;
1464
1465   /* If we are going to perform relocations and also strip/discard some
1466      symbols then we must make sure that we do not strip/discard those
1467      symbols that are going to be involved in the relocations.  */
1468   if ((   flaginfo->info->strip   != strip_none
1469        || flaginfo->info->discard != discard_none)
1470       && bfd_link_relocatable (flaginfo->info))
1471     {
1472       /* Mark the symbol array as 'not-used'.  */
1473       memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
1474
1475       mark_relocs (flaginfo, input_bfd);
1476     }
1477
1478   while (esym < esym_end)
1479     {
1480       struct internal_syment isym;
1481       enum coff_symbol_classification classification;
1482       bfd_boolean skip;
1483       bfd_boolean global;
1484       bfd_boolean dont_skip_symbol;
1485       int add;
1486
1487       bfd_coff_swap_sym_in (input_bfd, esym, isymp);
1488
1489       /* Make a copy of *isymp so that the relocate_section function
1490          always sees the original values.  This is more reliable than
1491          always recomputing the symbol value even if we are stripping
1492          the symbol.  */
1493       isym = *isymp;
1494
1495       classification = bfd_coff_classify_symbol (input_bfd, &isym);
1496       switch (classification)
1497         {
1498         default:
1499           abort ();
1500         case COFF_SYMBOL_GLOBAL:
1501         case COFF_SYMBOL_PE_SECTION:
1502         case COFF_SYMBOL_LOCAL:
1503           *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);
1504           break;
1505         case COFF_SYMBOL_COMMON:
1506           *secpp = bfd_com_section_ptr;
1507           break;
1508         case COFF_SYMBOL_UNDEFINED:
1509           *secpp = bfd_und_section_ptr;
1510           break;
1511         }
1512
1513       /* Extract the flag indicating if this symbol is used by a
1514          relocation.  */
1515       if ((flaginfo->info->strip != strip_none
1516            || flaginfo->info->discard != discard_none)
1517           && bfd_link_relocatable (flaginfo->info))
1518         dont_skip_symbol = *indexp;
1519       else
1520         dont_skip_symbol = FALSE;
1521
1522       *indexp = -1;
1523
1524       skip = FALSE;
1525       global = FALSE;
1526       add = 1 + isym.n_numaux;
1527
1528       /* If we are stripping all symbols, we want to skip this one.  */
1529       if (flaginfo->info->strip == strip_all && ! dont_skip_symbol)
1530         skip = TRUE;
1531
1532       if (! skip)
1533         {
1534           switch (classification)
1535             {
1536             default:
1537               abort ();
1538             case COFF_SYMBOL_GLOBAL:
1539             case COFF_SYMBOL_COMMON:
1540             case COFF_SYMBOL_PE_SECTION:
1541               /* This is a global symbol.  Global symbols come at the
1542                  end of the symbol table, so skip them for now.
1543                  Locally defined function symbols, however, are an
1544                  exception, and are not moved to the end.  */
1545               global = TRUE;
1546               if (! ISFCN (isym.n_type))
1547                 skip = TRUE;
1548               break;
1549
1550             case COFF_SYMBOL_UNDEFINED:
1551               /* Undefined symbols are left for the end.  */
1552               global = TRUE;
1553               skip = TRUE;
1554               break;
1555
1556             case COFF_SYMBOL_LOCAL:
1557               /* This is a local symbol.  Skip it if we are discarding
1558                  local symbols.  */
1559               if (flaginfo->info->discard == discard_all && ! dont_skip_symbol)
1560                 skip = TRUE;
1561               break;
1562             }
1563         }
1564
1565 #ifndef COFF_WITH_PE
1566       /* Skip section symbols for sections which are not going to be
1567          emitted.  */
1568       if (!skip
1569           && !dont_skip_symbol
1570           && isym.n_sclass == C_STAT
1571           && isym.n_type == T_NULL
1572           && isym.n_numaux > 0
1573           && ((*secpp)->output_section == bfd_abs_section_ptr
1574               || bfd_section_removed_from_list (output_bfd,
1575                                                 (*secpp)->output_section)))
1576         skip = TRUE;
1577 #endif
1578
1579       /* If we stripping debugging symbols, and this is a debugging
1580          symbol, then skip it.  FIXME: gas sets the section to N_ABS
1581          for some types of debugging symbols; I don't know if this is
1582          a bug or not.  In any case, we handle it here.  */
1583       if (! skip
1584           && flaginfo->info->strip == strip_debugger
1585           && ! dont_skip_symbol
1586           && (isym.n_scnum == N_DEBUG
1587               || (isym.n_scnum == N_ABS
1588                   && (isym.n_sclass == C_AUTO
1589                       || isym.n_sclass == C_REG
1590                       || isym.n_sclass == C_MOS
1591                       || isym.n_sclass == C_MOE
1592                       || isym.n_sclass == C_MOU
1593                       || isym.n_sclass == C_ARG
1594                       || isym.n_sclass == C_REGPARM
1595                       || isym.n_sclass == C_FIELD
1596                       || isym.n_sclass == C_EOS))))
1597         skip = TRUE;
1598
1599       /* If some symbols are stripped based on the name, work out the
1600          name and decide whether to skip this symbol.  */
1601       if (! skip
1602           && (flaginfo->info->strip == strip_some
1603               || flaginfo->info->discard == discard_l))
1604         {
1605           const char *name;
1606           char buf[SYMNMLEN + 1];
1607
1608           name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1609           if (name == NULL)
1610             return FALSE;
1611
1612           if (! dont_skip_symbol
1613               && ((flaginfo->info->strip == strip_some
1614                    && (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE,
1615                                     FALSE) == NULL))
1616                    || (! global
1617                        && flaginfo->info->discard == discard_l
1618                        && bfd_is_local_label_name (input_bfd, name))))
1619             skip = TRUE;
1620         }
1621
1622       /* If this is an enum, struct, or union tag, see if we have
1623          already output an identical type.  */
1624       if (! skip
1625           && !flaginfo->info->traditional_format
1626           && (isym.n_sclass == C_ENTAG
1627               || isym.n_sclass == C_STRTAG
1628               || isym.n_sclass == C_UNTAG)
1629           && isym.n_numaux == 1)
1630         {
1631           const char *name;
1632           char buf[SYMNMLEN + 1];
1633           struct coff_debug_merge_hash_entry *mh;
1634           struct coff_debug_merge_type *mt;
1635           union internal_auxent aux;
1636           struct coff_debug_merge_element **epp;
1637           bfd_byte *esl, *eslend;
1638           struct internal_syment *islp;
1639           bfd_size_type amt;
1640
1641           name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1642           if (name == NULL)
1643             return FALSE;
1644
1645           /* Ignore fake names invented by compiler; treat them all as
1646              the same name.  */
1647           if (*name == '~' || *name == '.' || *name == '$'
1648               || (*name == bfd_get_symbol_leading_char (input_bfd)
1649                   && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
1650             name = "";
1651
1652           mh = coff_debug_merge_hash_lookup (&flaginfo->debug_merge, name,
1653                                              TRUE, TRUE);
1654           if (mh == NULL)
1655             return FALSE;
1656
1657           /* Allocate memory to hold type information.  If this turns
1658              out to be a duplicate, we pass this address to
1659              bfd_release.  */
1660           amt = sizeof (struct coff_debug_merge_type);
1661           mt = (struct coff_debug_merge_type *) bfd_alloc (input_bfd, amt);
1662           if (mt == NULL)
1663             return FALSE;
1664           mt->type_class = isym.n_sclass;
1665
1666           /* Pick up the aux entry, which points to the end of the tag
1667              entries.  */
1668           bfd_coff_swap_aux_in (input_bfd, (esym + isymesz),
1669                                 isym.n_type, isym.n_sclass, 0, isym.n_numaux,
1670                                 &aux);
1671
1672           /* Gather the elements.  */
1673           epp = &mt->elements;
1674           mt->elements = NULL;
1675           islp = isymp + 2;
1676           esl = esym + 2 * isymesz;
1677           eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)
1678                     + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);
1679           while (esl < eslend)
1680             {
1681               const char *elename;
1682               char elebuf[SYMNMLEN + 1];
1683               char *name_copy;
1684
1685               bfd_coff_swap_sym_in (input_bfd, esl, islp);
1686
1687               amt = sizeof (struct coff_debug_merge_element);
1688               *epp = (struct coff_debug_merge_element *)
1689                   bfd_alloc (input_bfd, amt);
1690               if (*epp == NULL)
1691                 return FALSE;
1692
1693               elename = _bfd_coff_internal_syment_name (input_bfd, islp,
1694                                                         elebuf);
1695               if (elename == NULL)
1696                 return FALSE;
1697
1698               amt = strlen (elename) + 1;
1699               name_copy = (char *) bfd_alloc (input_bfd, amt);
1700               if (name_copy == NULL)
1701                 return FALSE;
1702               strcpy (name_copy, elename);
1703
1704               (*epp)->name = name_copy;
1705               (*epp)->type = islp->n_type;
1706               (*epp)->tagndx = 0;
1707               if (islp->n_numaux >= 1
1708                   && islp->n_type != T_NULL
1709                   && islp->n_sclass != C_EOS)
1710                 {
1711                   union internal_auxent eleaux;
1712                   long indx;
1713
1714                   bfd_coff_swap_aux_in (input_bfd, (esl + isymesz),
1715                                         islp->n_type, islp->n_sclass, 0,
1716                                         islp->n_numaux, &eleaux);
1717                   indx = eleaux.x_sym.x_tagndx.l;
1718
1719                   /* FIXME: If this tagndx entry refers to a symbol
1720                      defined later in this file, we just ignore it.
1721                      Handling this correctly would be tedious, and may
1722                      not be required.  */
1723                   if (indx > 0
1724                       && (indx
1725                           < ((esym -
1726                               (bfd_byte *) obj_coff_external_syms (input_bfd))
1727                              / (long) isymesz)))
1728                     {
1729                       (*epp)->tagndx = flaginfo->sym_indices[indx];
1730                       if ((*epp)->tagndx < 0)
1731                         (*epp)->tagndx = 0;
1732                     }
1733                 }
1734               epp = &(*epp)->next;
1735               *epp = NULL;
1736
1737               esl += (islp->n_numaux + 1) * isymesz;
1738               islp += islp->n_numaux + 1;
1739             }
1740
1741           /* See if we already have a definition which matches this
1742              type.  We always output the type if it has no elements,
1743              for simplicity.  */
1744           if (mt->elements == NULL)
1745             bfd_release (input_bfd, mt);
1746           else
1747             {
1748               struct coff_debug_merge_type *mtl;
1749
1750               for (mtl = mh->types; mtl != NULL; mtl = mtl->next)
1751                 {
1752                   struct coff_debug_merge_element *me, *mel;
1753
1754                   if (mtl->type_class != mt->type_class)
1755                     continue;
1756
1757                   for (me = mt->elements, mel = mtl->elements;
1758                        me != NULL && mel != NULL;
1759                        me = me->next, mel = mel->next)
1760                     {
1761                       if (strcmp (me->name, mel->name) != 0
1762                           || me->type != mel->type
1763                           || me->tagndx != mel->tagndx)
1764                         break;
1765                     }
1766
1767                   if (me == NULL && mel == NULL)
1768                     break;
1769                 }
1770
1771               if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)
1772                 {
1773                   /* This is the first definition of this type.  */
1774                   mt->indx = output_index;
1775                   mt->next = mh->types;
1776                   mh->types = mt;
1777                 }
1778               else
1779                 {
1780                   /* This is a redefinition which can be merged.  */
1781                   bfd_release (input_bfd, mt);
1782                   *indexp = mtl->indx;
1783                   add = (eslend - esym) / isymesz;
1784                   skip = TRUE;
1785                 }
1786             }
1787         }
1788
1789       /* We now know whether we are to skip this symbol or not.  */
1790       if (! skip)
1791         {
1792           /* Adjust the symbol in order to output it.  */
1793
1794           if (isym._n._n_n._n_zeroes == 0
1795               && isym._n._n_n._n_offset != 0)
1796             {
1797               const char *name;
1798               bfd_size_type indx;
1799
1800               /* This symbol has a long name.  Enter it in the string
1801                  table we are building.  Note that we do not check
1802                  bfd_coff_symname_in_debug.  That is only true for
1803                  XCOFF, and XCOFF requires different linking code
1804                  anyhow.  */
1805               name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL);
1806               if (name == NULL)
1807                 return FALSE;
1808               indx = _bfd_stringtab_add (flaginfo->strtab, name, hash, copy);
1809               if (indx == (bfd_size_type) -1)
1810                 return FALSE;
1811               isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1812             }
1813
1814           switch (isym.n_sclass)
1815             {
1816             case C_AUTO:
1817             case C_MOS:
1818             case C_EOS:
1819             case C_MOE:
1820             case C_MOU:
1821             case C_UNTAG:
1822             case C_STRTAG:
1823             case C_ENTAG:
1824             case C_TPDEF:
1825             case C_ARG:
1826             case C_USTATIC:
1827             case C_REG:
1828             case C_REGPARM:
1829             case C_FIELD:
1830               /* The symbol value should not be modified.  */
1831               break;
1832
1833             case C_FCN:
1834               if (obj_pe (input_bfd)
1835                   && strcmp (isym.n_name, ".bf") != 0
1836                   && isym.n_scnum > 0)
1837                 {
1838                   /* For PE, .lf and .ef get their value left alone,
1839                      while .bf gets relocated.  However, they all have
1840                      "real" section numbers, and need to be moved into
1841                      the new section.  */
1842                   isym.n_scnum = (*secpp)->output_section->target_index;
1843                   break;
1844                 }
1845               /* Fall through.  */
1846             default:
1847             case C_LABEL:  /* Not completely sure about these 2 */
1848             case C_EXTDEF:
1849             case C_BLOCK:
1850             case C_EFCN:
1851             case C_NULL:
1852             case C_EXT:
1853             case C_STAT:
1854             case C_SECTION:
1855             case C_NT_WEAK:
1856               /* Compute new symbol location.  */
1857             if (isym.n_scnum > 0)
1858               {
1859                 isym.n_scnum = (*secpp)->output_section->target_index;
1860                 isym.n_value += (*secpp)->output_offset;
1861                 if (! obj_pe (input_bfd))
1862                   isym.n_value -= (*secpp)->vma;
1863                 if (! obj_pe (flaginfo->output_bfd))
1864                   isym.n_value += (*secpp)->output_section->vma;
1865               }
1866             break;
1867
1868             case C_FILE:
1869               /* The value of a C_FILE symbol is the symbol index of
1870                  the next C_FILE symbol.  The value of the last C_FILE
1871                  symbol is the symbol index to the first external
1872                  symbol (actually, coff_renumber_symbols does not get
1873                  this right--it just sets the value of the last C_FILE
1874                  symbol to zero--and nobody has ever complained about
1875                  it).  We try to get this right, below, just before we
1876                  write the symbols out, but in the general case we may
1877                  have to write the symbol out twice.  */
1878               if (flaginfo->last_file_index != -1
1879                   && flaginfo->last_file.n_value != (bfd_vma) output_index)
1880                 {
1881                   /* We must correct the value of the last C_FILE
1882                      entry.  */
1883                   flaginfo->last_file.n_value = output_index;
1884                   if ((bfd_size_type) flaginfo->last_file_index >= syment_base)
1885                     {
1886                       /* The last C_FILE symbol is in this input file.  */
1887                       bfd_coff_swap_sym_out (output_bfd,
1888                                              &flaginfo->last_file,
1889                                              (flaginfo->outsyms
1890                                               + ((flaginfo->last_file_index
1891                                                   - syment_base)
1892                                                  * osymesz)));
1893                     }
1894                   else
1895                     {
1896                       file_ptr pos;
1897
1898                       /* We have already written out the last C_FILE
1899                          symbol.  We need to write it out again.  We
1900                          borrow *outsym temporarily.  */
1901                       bfd_coff_swap_sym_out (output_bfd,
1902                                              &flaginfo->last_file, outsym);
1903                       pos = obj_sym_filepos (output_bfd);
1904                       pos += flaginfo->last_file_index * osymesz;
1905                       if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
1906                           || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
1907                         return FALSE;
1908                     }
1909                 }
1910
1911               flaginfo->last_file_index = output_index;
1912               flaginfo->last_file = isym;
1913               break;
1914             }
1915
1916           /* If doing task linking, convert normal global function symbols to
1917              static functions.  */
1918           if (flaginfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
1919             isym.n_sclass = C_STAT;
1920
1921           /* Output the symbol.  */
1922           bfd_coff_swap_sym_out (output_bfd, &isym, outsym);
1923
1924           *indexp = output_index;
1925
1926           if (global)
1927             {
1928               long indx;
1929               struct coff_link_hash_entry *h;
1930
1931               indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
1932                       / isymesz);
1933               h = obj_coff_sym_hashes (input_bfd)[indx];
1934               if (h == NULL)
1935                 {
1936                   /* This can happen if there were errors earlier in
1937                      the link.  */
1938                   bfd_set_error (bfd_error_bad_value);
1939                   return FALSE;
1940                 }
1941               h->indx = output_index;
1942             }
1943
1944           output_index += add;
1945           outsym += add * osymesz;
1946         }
1947
1948       esym += add * isymesz;
1949       isymp += add;
1950       ++secpp;
1951       ++indexp;
1952       for (--add; add > 0; --add)
1953         {
1954           *secpp++ = NULL;
1955           *indexp++ = -1;
1956         }
1957     }
1958
1959   /* Fix up the aux entries.  This must be done in a separate pass,
1960      because we don't know the correct symbol indices until we have
1961      already decided which symbols we are going to keep.  */
1962   esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1963   esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1964   isymp = flaginfo->internal_syms;
1965   indexp = flaginfo->sym_indices;
1966   sym_hash = obj_coff_sym_hashes (input_bfd);
1967   outsym = flaginfo->outsyms;
1968
1969   while (esym < esym_end)
1970     {
1971       int add;
1972
1973       add = 1 + isymp->n_numaux;
1974
1975       if ((*indexp < 0
1976            || (bfd_size_type) *indexp < syment_base)
1977           && (*sym_hash == NULL
1978               || (*sym_hash)->auxbfd != input_bfd))
1979         esym += add * isymesz;
1980       else
1981         {
1982           struct coff_link_hash_entry *h;
1983           int i;
1984
1985           h = NULL;
1986           if (*indexp < 0)
1987             {
1988               h = *sym_hash;
1989
1990               /* The m68k-motorola-sysv assembler will sometimes
1991                  generate two symbols with the same name, but only one
1992                  will have aux entries.  */
1993               BFD_ASSERT (isymp->n_numaux == 0
1994                           || h->numaux == 0
1995                           || h->numaux == isymp->n_numaux);
1996             }
1997
1998           esym += isymesz;
1999
2000           if (h == NULL)
2001             outsym += osymesz;
2002
2003           /* Handle the aux entries.  This handling is based on
2004              coff_pointerize_aux.  I don't know if it always correct.  */
2005           for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
2006             {
2007               union internal_auxent aux;
2008               union internal_auxent *auxp;
2009
2010               if (h != NULL && h->aux != NULL && (h->numaux > i))
2011                 auxp = h->aux + i;
2012               else
2013                 {
2014                   bfd_coff_swap_aux_in (input_bfd, esym, isymp->n_type,
2015                                         isymp->n_sclass, i, isymp->n_numaux, &aux);
2016                   auxp = &aux;
2017                 }
2018
2019               if (isymp->n_sclass == C_FILE)
2020                 {
2021                   /* If this is a long filename, we must put it in the
2022                      string table.  */
2023                   if (auxp->x_file.x_n.x_zeroes == 0
2024                       && auxp->x_file.x_n.x_offset != 0)
2025                     {
2026                       const char *filename;
2027                       bfd_size_type indx;
2028
2029                       BFD_ASSERT (auxp->x_file.x_n.x_offset
2030                                   >= STRING_SIZE_SIZE);
2031                       if (strings == NULL)
2032                         {
2033                           strings = _bfd_coff_read_string_table (input_bfd);
2034                           if (strings == NULL)
2035                             return FALSE;
2036                         }
2037                       if ((bfd_size_type) auxp->x_file.x_n.x_offset >= obj_coff_strings_len (input_bfd))
2038                         filename = _("<corrupt>");
2039                       else
2040                         filename = strings + auxp->x_file.x_n.x_offset;
2041                       indx = _bfd_stringtab_add (flaginfo->strtab, filename,
2042                                                  hash, copy);
2043                       if (indx == (bfd_size_type) -1)
2044                         return FALSE;
2045                       auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
2046                     }
2047                 }
2048               else if ((isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
2049                        && isymp->n_sclass != C_NT_WEAK)
2050                 {
2051                   unsigned long indx;
2052
2053                   if (ISFCN (isymp->n_type)
2054                       || ISTAG (isymp->n_sclass)
2055                       || isymp->n_sclass == C_BLOCK
2056                       || isymp->n_sclass == C_FCN)
2057                     {
2058                       indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;
2059                       if (indx > 0
2060                           && indx < obj_raw_syment_count (input_bfd))
2061                         {
2062                           /* We look forward through the symbol for
2063                              the index of the next symbol we are going
2064                              to include.  I don't know if this is
2065                              entirely right.  */
2066                           while ((flaginfo->sym_indices[indx] < 0
2067                                   || ((bfd_size_type) flaginfo->sym_indices[indx]
2068                                       < syment_base))
2069                                  && indx < obj_raw_syment_count (input_bfd))
2070                             ++indx;
2071                           if (indx >= obj_raw_syment_count (input_bfd))
2072                             indx = output_index;
2073                           else
2074                             indx = flaginfo->sym_indices[indx];
2075                           auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
2076                         }
2077                     }
2078
2079                   indx = auxp->x_sym.x_tagndx.l;
2080                   if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
2081                     {
2082                       long symindx;
2083
2084                       symindx = flaginfo->sym_indices[indx];
2085                       if (symindx < 0)
2086                         auxp->x_sym.x_tagndx.l = 0;
2087                       else
2088                         auxp->x_sym.x_tagndx.l = symindx;
2089                     }
2090
2091                   /* The .bf symbols are supposed to be linked through
2092                      the endndx field.  We need to carry this list
2093                      across object files.  */
2094                   if (i == 0
2095                       && h == NULL
2096                       && isymp->n_sclass == C_FCN
2097                       && (isymp->_n._n_n._n_zeroes != 0
2098                           || isymp->_n._n_n._n_offset == 0)
2099                       && isymp->_n._n_name[0] == '.'
2100                       && isymp->_n._n_name[1] == 'b'
2101                       && isymp->_n._n_name[2] == 'f'
2102                       && isymp->_n._n_name[3] == '\0')
2103                     {
2104                       if (flaginfo->last_bf_index != -1)
2105                         {
2106                           flaginfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
2107                             *indexp;
2108
2109                           if ((bfd_size_type) flaginfo->last_bf_index
2110                               >= syment_base)
2111                             {
2112                               void *auxout;
2113
2114                               /* The last .bf symbol is in this input
2115                                  file.  This will only happen if the
2116                                  assembler did not set up the .bf
2117                                  endndx symbols correctly.  */
2118                               auxout = (flaginfo->outsyms
2119                                         + ((flaginfo->last_bf_index
2120                                             - syment_base)
2121                                            * osymesz));
2122
2123                               bfd_coff_swap_aux_out (output_bfd,
2124                                                      &flaginfo->last_bf,
2125                                                      isymp->n_type,
2126                                                      isymp->n_sclass,
2127                                                      0, isymp->n_numaux,
2128                                                      auxout);
2129                             }
2130                           else
2131                             {
2132                               file_ptr pos;
2133
2134                               /* We have already written out the last
2135                                  .bf aux entry.  We need to write it
2136                                  out again.  We borrow *outsym
2137                                  temporarily.  FIXME: This case should
2138                                  be made faster.  */
2139                               bfd_coff_swap_aux_out (output_bfd,
2140                                                      &flaginfo->last_bf,
2141                                                      isymp->n_type,
2142                                                      isymp->n_sclass,
2143                                                      0, isymp->n_numaux,
2144                                                      outsym);
2145                               pos = obj_sym_filepos (output_bfd);
2146                               pos += flaginfo->last_bf_index * osymesz;
2147                               if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2148                                   || (bfd_bwrite (outsym, osymesz, output_bfd)
2149                                       != osymesz))
2150                                 return FALSE;
2151                             }
2152                         }
2153
2154                       if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
2155                         flaginfo->last_bf_index = -1;
2156                       else
2157                         {
2158                           /* The endndx field of this aux entry must
2159                              be updated with the symbol number of the
2160                              next .bf symbol.  */
2161                           flaginfo->last_bf = *auxp;
2162                           flaginfo->last_bf_index = (((outsym - flaginfo->outsyms)
2163                                                    / osymesz)
2164                                                   + syment_base);
2165                         }
2166                     }
2167                 }
2168
2169               if (h == NULL)
2170                 {
2171                   bfd_coff_swap_aux_out (output_bfd, auxp, isymp->n_type,
2172                                          isymp->n_sclass, i, isymp->n_numaux,
2173                                          outsym);
2174                   outsym += osymesz;
2175                 }
2176
2177               esym += isymesz;
2178             }
2179         }
2180
2181       indexp += add;
2182       isymp += add;
2183       sym_hash += add;
2184     }
2185
2186   /* Relocate the line numbers, unless we are stripping them.  */
2187   if (flaginfo->info->strip == strip_none
2188       || flaginfo->info->strip == strip_some)
2189     {
2190       for (o = input_bfd->sections; o != NULL; o = o->next)
2191         {
2192           bfd_vma offset;
2193           bfd_byte *eline;
2194           bfd_byte *elineend;
2195           bfd_byte *oeline;
2196           bfd_boolean skipping;
2197           file_ptr pos;
2198           bfd_size_type amt;
2199
2200           /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
2201              build_link_order in ldwrite.c will not have created a
2202              link order, which means that we will not have seen this
2203              input section in _bfd_coff_final_link, which means that
2204              we will not have allocated space for the line numbers of
2205              this section.  I don't think line numbers can be
2206              meaningful for a section which does not have
2207              SEC_HAS_CONTENTS set, but, if they do, this must be
2208              changed.  */
2209           if (o->lineno_count == 0
2210               || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
2211             continue;
2212
2213           if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
2214               || bfd_bread (flaginfo->linenos, linesz * o->lineno_count,
2215                            input_bfd) != linesz * o->lineno_count)
2216             return FALSE;
2217
2218           offset = o->output_section->vma + o->output_offset - o->vma;
2219           eline = flaginfo->linenos;
2220           oeline = flaginfo->linenos;
2221           elineend = eline + linesz * o->lineno_count;
2222           skipping = FALSE;
2223           for (; eline < elineend; eline += linesz)
2224             {
2225               struct internal_lineno iline;
2226
2227               bfd_coff_swap_lineno_in (input_bfd, eline, &iline);
2228
2229               if (iline.l_lnno != 0)
2230                 iline.l_addr.l_paddr += offset;
2231               else if (iline.l_addr.l_symndx >= 0
2232                        && ((unsigned long) iline.l_addr.l_symndx
2233                            < obj_raw_syment_count (input_bfd)))
2234                 {
2235                   long indx;
2236
2237                   indx = flaginfo->sym_indices[iline.l_addr.l_symndx];
2238
2239                   if (indx < 0)
2240                     {
2241                       /* These line numbers are attached to a symbol
2242                          which we are stripping.  We must discard the
2243                          line numbers because reading them back with
2244                          no associated symbol (or associating them all
2245                          with symbol #0) will fail.  We can't regain
2246                          the space in the output file, but at least
2247                          they're dense.  */
2248                       skipping = TRUE;
2249                     }
2250                   else
2251                     {
2252                       struct internal_syment is;
2253                       union internal_auxent ia;
2254
2255                       /* Fix up the lnnoptr field in the aux entry of
2256                          the symbol.  It turns out that we can't do
2257                          this when we modify the symbol aux entries,
2258                          because gas sometimes screws up the lnnoptr
2259                          field and makes it an offset from the start
2260                          of the line numbers rather than an absolute
2261                          file index.  */
2262                       bfd_coff_swap_sym_in (output_bfd,
2263                                             (flaginfo->outsyms
2264                                              + ((indx - syment_base)
2265                                                 * osymesz)), &is);
2266                       if ((ISFCN (is.n_type)
2267                            || is.n_sclass == C_BLOCK)
2268                           && is.n_numaux >= 1)
2269                         {
2270                           void *auxptr;
2271
2272                           auxptr = (flaginfo->outsyms
2273                                     + ((indx - syment_base + 1)
2274                                        * osymesz));
2275                           bfd_coff_swap_aux_in (output_bfd, auxptr,
2276                                                 is.n_type, is.n_sclass,
2277                                                 0, is.n_numaux, &ia);
2278                           ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
2279                             (o->output_section->line_filepos
2280                              + o->output_section->lineno_count * linesz
2281                              + eline - flaginfo->linenos);
2282                           bfd_coff_swap_aux_out (output_bfd, &ia,
2283                                                  is.n_type, is.n_sclass, 0,
2284                                                  is.n_numaux, auxptr);
2285                         }
2286
2287                       skipping = FALSE;
2288                     }
2289
2290                   iline.l_addr.l_symndx = indx;
2291                 }
2292
2293               if (!skipping)
2294                 {
2295                   bfd_coff_swap_lineno_out (output_bfd, &iline, oeline);
2296                   oeline += linesz;
2297                 }
2298             }
2299
2300           pos = o->output_section->line_filepos;
2301           pos += o->output_section->lineno_count * linesz;
2302           amt = oeline - flaginfo->linenos;
2303           if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2304               || bfd_bwrite (flaginfo->linenos, amt, output_bfd) != amt)
2305             return FALSE;
2306
2307           o->output_section->lineno_count += amt / linesz;
2308         }
2309     }
2310
2311   /* If we swapped out a C_FILE symbol, guess that the next C_FILE
2312      symbol will be the first symbol in the next input file.  In the
2313      normal case, this will save us from writing out the C_FILE symbol
2314      again.  */
2315   if (flaginfo->last_file_index != -1
2316       && (bfd_size_type) flaginfo->last_file_index >= syment_base)
2317     {
2318       flaginfo->last_file.n_value = output_index;
2319       bfd_coff_swap_sym_out (output_bfd, &flaginfo->last_file,
2320                              (flaginfo->outsyms
2321                               + ((flaginfo->last_file_index - syment_base)
2322                                  * osymesz)));
2323     }
2324
2325   /* Write the modified symbols to the output file.  */
2326   if (outsym > flaginfo->outsyms)
2327     {
2328       file_ptr pos;
2329       bfd_size_type amt;
2330
2331       pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
2332       amt = outsym - flaginfo->outsyms;
2333       if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2334           || bfd_bwrite (flaginfo->outsyms, amt, output_bfd) != amt)
2335         return FALSE;
2336
2337       BFD_ASSERT ((obj_raw_syment_count (output_bfd)
2338                    + (outsym - flaginfo->outsyms) / osymesz)
2339                   == output_index);
2340
2341       obj_raw_syment_count (output_bfd) = output_index;
2342     }
2343
2344   /* Relocate the contents of each section.  */
2345   adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;
2346   for (o = input_bfd->sections; o != NULL; o = o->next)
2347     {
2348       bfd_byte *contents;
2349       struct coff_section_tdata *secdata;
2350
2351       if (! o->linker_mark)
2352         /* This section was omitted from the link.  */
2353         continue;
2354
2355       if ((o->flags & SEC_LINKER_CREATED) != 0)
2356         continue;
2357
2358       if ((o->flags & SEC_HAS_CONTENTS) == 0
2359           || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
2360         {
2361           if ((o->flags & SEC_RELOC) != 0
2362               && o->reloc_count != 0)
2363             {
2364               (*_bfd_error_handler)
2365                 (_("%B: relocs in section `%A', but it has no contents"),
2366                  input_bfd, o);
2367               bfd_set_error (bfd_error_no_contents);
2368               return FALSE;
2369             }
2370
2371           continue;
2372         }
2373
2374       secdata = coff_section_data (input_bfd, o);
2375       if (secdata != NULL && secdata->contents != NULL)
2376         contents = secdata->contents;
2377       else
2378         {
2379           contents = flaginfo->contents;
2380           if (! bfd_get_full_section_contents (input_bfd, o, &contents))
2381             return FALSE;
2382         }
2383
2384       if ((o->flags & SEC_RELOC) != 0)
2385         {
2386           int target_index;
2387           struct internal_reloc *internal_relocs;
2388           struct internal_reloc *irel;
2389
2390           /* Read in the relocs.  */
2391           target_index = o->output_section->target_index;
2392           internal_relocs = (_bfd_coff_read_internal_relocs
2393                              (input_bfd, o, FALSE, flaginfo->external_relocs,
2394                               bfd_link_relocatable (flaginfo->info),
2395                               (bfd_link_relocatable (flaginfo->info)
2396                                ? (flaginfo->section_info[target_index].relocs
2397                                   + o->output_section->reloc_count)
2398                                : flaginfo->internal_relocs)));
2399           if (internal_relocs == NULL
2400               && o->reloc_count > 0)
2401             return FALSE;
2402
2403           /* Run through the relocs looking for relocs against symbols
2404              coming from discarded sections and complain about them.  */
2405           irel = internal_relocs;
2406           for (; irel < &internal_relocs[o->reloc_count]; irel++)
2407             {
2408               struct coff_link_hash_entry *h;
2409               asection *ps = NULL;
2410               long symndx = irel->r_symndx;
2411               if (symndx < 0)
2412                 continue;
2413               h = obj_coff_sym_hashes (input_bfd)[symndx];
2414               if (h == NULL)
2415                 continue;
2416               while (h->root.type == bfd_link_hash_indirect
2417                      || h->root.type == bfd_link_hash_warning)
2418                 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2419               if (h->root.type == bfd_link_hash_defined
2420                   || h->root.type == bfd_link_hash_defweak)
2421                 ps = h->root.u.def.section;
2422               if (ps == NULL)
2423                 continue;
2424               /* Complain if definition comes from an excluded section.  */
2425               if (ps->flags & SEC_EXCLUDE)
2426                 (*flaginfo->info->callbacks->einfo)
2427                   (_("%X`%s' referenced in section `%A' of %B: "
2428                      "defined in discarded section `%A' of %B\n"),
2429                    h->root.root.string, o, input_bfd, ps, ps->owner);
2430             }
2431
2432           /* Call processor specific code to relocate the section
2433              contents.  */
2434           if (! bfd_coff_relocate_section (output_bfd, flaginfo->info,
2435                                            input_bfd, o,
2436                                            contents,
2437                                            internal_relocs,
2438                                            flaginfo->internal_syms,
2439                                            flaginfo->sec_ptrs))
2440             return FALSE;
2441
2442           if (bfd_link_relocatable (flaginfo->info))
2443             {
2444               bfd_vma offset;
2445               struct internal_reloc *irelend;
2446               struct coff_link_hash_entry **rel_hash;
2447
2448               offset = o->output_section->vma + o->output_offset - o->vma;
2449               irel = internal_relocs;
2450               irelend = irel + o->reloc_count;
2451               rel_hash = (flaginfo->section_info[target_index].rel_hashes
2452                           + o->output_section->reloc_count);
2453               for (; irel < irelend; irel++, rel_hash++)
2454                 {
2455                   struct coff_link_hash_entry *h;
2456                   bfd_boolean adjusted;
2457
2458                   *rel_hash = NULL;
2459
2460                   /* Adjust the reloc address and symbol index.  */
2461                   irel->r_vaddr += offset;
2462
2463                   if (irel->r_symndx == -1)
2464                     continue;
2465
2466                   if (adjust_symndx)
2467                     {
2468                       if (! (*adjust_symndx) (output_bfd, flaginfo->info,
2469                                               input_bfd, o, irel,
2470                                               &adjusted))
2471                         return FALSE;
2472                       if (adjusted)
2473                         continue;
2474                     }
2475
2476                   h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];
2477                   if (h != NULL)
2478                     {
2479                       /* This is a global symbol.  */
2480                       if (h->indx >= 0)
2481                         irel->r_symndx = h->indx;
2482                       else
2483                         {
2484                           /* This symbol is being written at the end
2485                              of the file, and we do not yet know the
2486                              symbol index.  We save the pointer to the
2487                              hash table entry in the rel_hash list.
2488                              We set the indx field to -2 to indicate
2489                              that this symbol must not be stripped.  */
2490                           *rel_hash = h;
2491                           h->indx = -2;
2492                         }
2493                     }
2494                   else
2495                     {
2496                       long indx;
2497
2498                       indx = flaginfo->sym_indices[irel->r_symndx];
2499                       if (indx != -1)
2500                         irel->r_symndx = indx;
2501                       else
2502                         {
2503                           struct internal_syment *is;
2504                           const char *name;
2505                           char buf[SYMNMLEN + 1];
2506
2507                           /* This reloc is against a symbol we are
2508                              stripping.  This should have been handled
2509                              by the 'dont_skip_symbol' code in the while
2510                              loop at the top of this function.  */
2511                           is = flaginfo->internal_syms + irel->r_symndx;
2512
2513                           name = (_bfd_coff_internal_syment_name
2514                                   (input_bfd, is, buf));
2515                           if (name == NULL)
2516                             return FALSE;
2517
2518                           (*flaginfo->info->callbacks->unattached_reloc)
2519                             (flaginfo->info, name, input_bfd, o, irel->r_vaddr);
2520                         }
2521                     }
2522                 }
2523
2524               o->output_section->reloc_count += o->reloc_count;
2525             }
2526         }
2527
2528       /* Write out the modified section contents.  */
2529       if (secdata == NULL || secdata->stab_info == NULL)
2530         {
2531           file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd);
2532           if (! bfd_set_section_contents (output_bfd, o->output_section,
2533                                           contents, loc, o->size))
2534             return FALSE;
2535         }
2536       else
2537         {
2538           if (! (_bfd_write_section_stabs
2539                  (output_bfd, &coff_hash_table (flaginfo->info)->stab_info,
2540                   o, &secdata->stab_info, contents)))
2541             return FALSE;
2542         }
2543     }
2544
2545   if (! flaginfo->info->keep_memory
2546       && ! _bfd_coff_free_symbols (input_bfd))
2547     return FALSE;
2548
2549   return TRUE;
2550 }
2551
2552 /* Write out a global symbol.  Called via bfd_hash_traverse.  */
2553
2554 bfd_boolean
2555 _bfd_coff_write_global_sym (struct bfd_hash_entry *bh, void *data)
2556 {
2557   struct coff_link_hash_entry *h = (struct coff_link_hash_entry *) bh;
2558   struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;
2559   bfd *output_bfd;
2560   struct internal_syment isym;
2561   bfd_size_type symesz;
2562   unsigned int i;
2563   file_ptr pos;
2564
2565   output_bfd = flaginfo->output_bfd;
2566
2567   if (h->root.type == bfd_link_hash_warning)
2568     {
2569       h = (struct coff_link_hash_entry *) h->root.u.i.link;
2570       if (h->root.type == bfd_link_hash_new)
2571         return TRUE;
2572     }
2573
2574   if (h->indx >= 0)
2575     return TRUE;
2576
2577   if (h->indx != -2
2578       && (flaginfo->info->strip == strip_all
2579           || (flaginfo->info->strip == strip_some
2580               && (bfd_hash_lookup (flaginfo->info->keep_hash,
2581                                    h->root.root.string, FALSE, FALSE)
2582                   == NULL))))
2583     return TRUE;
2584
2585   switch (h->root.type)
2586     {
2587     default:
2588     case bfd_link_hash_new:
2589     case bfd_link_hash_warning:
2590       abort ();
2591       return FALSE;
2592
2593     case bfd_link_hash_undefined:
2594     case bfd_link_hash_undefweak:
2595       isym.n_scnum = N_UNDEF;
2596       isym.n_value = 0;
2597       break;
2598
2599     case bfd_link_hash_defined:
2600     case bfd_link_hash_defweak:
2601       {
2602         asection *sec;
2603
2604         sec = h->root.u.def.section->output_section;
2605         if (bfd_is_abs_section (sec))
2606           isym.n_scnum = N_ABS;
2607         else
2608           isym.n_scnum = sec->target_index;
2609         isym.n_value = (h->root.u.def.value
2610                         + h->root.u.def.section->output_offset);
2611         if (! obj_pe (flaginfo->output_bfd))
2612           isym.n_value += sec->vma;
2613       }
2614       break;
2615
2616     case bfd_link_hash_common:
2617       isym.n_scnum = N_UNDEF;
2618       isym.n_value = h->root.u.c.size;
2619       break;
2620
2621     case bfd_link_hash_indirect:
2622       /* Just ignore these.  They can't be handled anyhow.  */
2623       return TRUE;
2624     }
2625
2626   if (strlen (h->root.root.string) <= SYMNMLEN)
2627     strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
2628   else
2629     {
2630       bfd_boolean hash;
2631       bfd_size_type indx;
2632
2633       hash = TRUE;
2634       if (flaginfo->info->traditional_format)
2635         hash = FALSE;
2636       indx = _bfd_stringtab_add (flaginfo->strtab, h->root.root.string, hash,
2637                                  FALSE);
2638       if (indx == (bfd_size_type) -1)
2639         {
2640           flaginfo->failed = TRUE;
2641           return FALSE;
2642         }
2643       isym._n._n_n._n_zeroes = 0;
2644       isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
2645     }
2646
2647   isym.n_sclass = h->symbol_class;
2648   isym.n_type = h->type;
2649
2650   if (isym.n_sclass == C_NULL)
2651     isym.n_sclass = C_EXT;
2652
2653   /* If doing task linking and this is the pass where we convert
2654      defined globals to statics, then do that conversion now.  If the
2655      symbol is not being converted, just ignore it and it will be
2656      output during a later pass.  */
2657   if (flaginfo->global_to_static)
2658     {
2659       if (! IS_EXTERNAL (output_bfd, isym))
2660         return TRUE;
2661
2662       isym.n_sclass = C_STAT;
2663     }
2664
2665   /* When a weak symbol is not overridden by a strong one,
2666      turn it into an external symbol when not building a
2667      shared or relocatable object.  */
2668   if (! bfd_link_pic (flaginfo->info)
2669       && ! bfd_link_relocatable (flaginfo->info)
2670       && IS_WEAK_EXTERNAL (flaginfo->output_bfd, isym))
2671     isym.n_sclass = C_EXT;
2672
2673   isym.n_numaux = h->numaux;
2674
2675   bfd_coff_swap_sym_out (output_bfd, &isym, flaginfo->outsyms);
2676
2677   symesz = bfd_coff_symesz (output_bfd);
2678
2679   pos = obj_sym_filepos (output_bfd);
2680   pos += obj_raw_syment_count (output_bfd) * symesz;
2681   if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2682       || bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)
2683     {
2684       flaginfo->failed = TRUE;
2685       return FALSE;
2686     }
2687
2688   h->indx = obj_raw_syment_count (output_bfd);
2689
2690   ++obj_raw_syment_count (output_bfd);
2691
2692   /* Write out any associated aux entries.  Most of the aux entries
2693      will have been modified in _bfd_coff_link_input_bfd.  We have to
2694      handle section aux entries here, now that we have the final
2695      relocation and line number counts.  */
2696   for (i = 0; i < isym.n_numaux; i++)
2697     {
2698       union internal_auxent *auxp;
2699
2700       auxp = h->aux + i;
2701
2702       /* Look for a section aux entry here using the same tests that
2703          coff_swap_aux_out uses.  */
2704       if (i == 0
2705           && (isym.n_sclass == C_STAT
2706               || isym.n_sclass == C_HIDDEN)
2707           && isym.n_type == T_NULL
2708           && (h->root.type == bfd_link_hash_defined
2709               || h->root.type == bfd_link_hash_defweak))
2710         {
2711           asection *sec;
2712
2713           sec = h->root.u.def.section->output_section;
2714           if (sec != NULL)
2715             {
2716               auxp->x_scn.x_scnlen = sec->size;
2717
2718               /* For PE, an overflow on the final link reportedly does
2719                  not matter.  FIXME: Why not?  */
2720               if (sec->reloc_count > 0xffff
2721                   && (! obj_pe (output_bfd)
2722                       || bfd_link_relocatable (flaginfo->info)))
2723                 (*_bfd_error_handler)
2724                   (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
2725                    bfd_get_filename (output_bfd),
2726                    bfd_get_section_name (output_bfd, sec),
2727                    sec->reloc_count);
2728
2729               if (sec->lineno_count > 0xffff
2730                   && (! obj_pe (output_bfd)
2731                       || bfd_link_relocatable (flaginfo->info)))
2732                 (*_bfd_error_handler)
2733                   (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
2734                    bfd_get_filename (output_bfd),
2735                    bfd_get_section_name (output_bfd, sec),
2736                    sec->lineno_count);
2737
2738               auxp->x_scn.x_nreloc = sec->reloc_count;
2739               auxp->x_scn.x_nlinno = sec->lineno_count;
2740               auxp->x_scn.x_checksum = 0;
2741               auxp->x_scn.x_associated = 0;
2742               auxp->x_scn.x_comdat = 0;
2743             }
2744         }
2745
2746       bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type,
2747                              isym.n_sclass, (int) i, isym.n_numaux,
2748                              flaginfo->outsyms);
2749       if (bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)
2750         {
2751           flaginfo->failed = TRUE;
2752           return FALSE;
2753         }
2754       ++obj_raw_syment_count (output_bfd);
2755     }
2756
2757   return TRUE;
2758 }
2759
2760 /* Write out task global symbols, converting them to statics.  Called
2761    via coff_link_hash_traverse.  Calls bfd_coff_write_global_sym to do
2762    the dirty work, if the symbol we are processing needs conversion.  */
2763
2764 bfd_boolean
2765 _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
2766 {
2767   struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;
2768   bfd_boolean rtnval = TRUE;
2769   bfd_boolean save_global_to_static;
2770
2771   if (h->root.type == bfd_link_hash_warning)
2772     h = (struct coff_link_hash_entry *) h->root.u.i.link;
2773
2774   if (h->indx < 0)
2775     {
2776       switch (h->root.type)
2777         {
2778         case bfd_link_hash_defined:
2779         case bfd_link_hash_defweak:
2780           save_global_to_static = flaginfo->global_to_static;
2781           flaginfo->global_to_static = TRUE;
2782           rtnval = _bfd_coff_write_global_sym (&h->root.root, data);
2783           flaginfo->global_to_static = save_global_to_static;
2784           break;
2785         default:
2786           break;
2787         }
2788     }
2789   return (rtnval);
2790 }
2791
2792 /* Handle a link order which is supposed to generate a reloc.  */
2793
2794 bfd_boolean
2795 _bfd_coff_reloc_link_order (bfd *output_bfd,
2796                             struct coff_final_link_info *flaginfo,
2797                             asection *output_section,
2798                             struct bfd_link_order *link_order)
2799 {
2800   reloc_howto_type *howto;
2801   struct internal_reloc *irel;
2802   struct coff_link_hash_entry **rel_hash_ptr;
2803
2804   howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2805   if (howto == NULL)
2806     {
2807       bfd_set_error (bfd_error_bad_value);
2808       return FALSE;
2809     }
2810
2811   if (link_order->u.reloc.p->addend != 0)
2812     {
2813       bfd_size_type size;
2814       bfd_byte *buf;
2815       bfd_reloc_status_type rstat;
2816       bfd_boolean ok;
2817       file_ptr loc;
2818
2819       size = bfd_get_reloc_size (howto);
2820       buf = (bfd_byte *) bfd_zmalloc (size);
2821       if (buf == NULL && size != 0)
2822         return FALSE;
2823
2824       rstat = _bfd_relocate_contents (howto, output_bfd,
2825                                       (bfd_vma) link_order->u.reloc.p->addend,\
2826                                       buf);
2827       switch (rstat)
2828         {
2829         case bfd_reloc_ok:
2830           break;
2831         default:
2832         case bfd_reloc_outofrange:
2833           abort ();
2834         case bfd_reloc_overflow:
2835           (*flaginfo->info->callbacks->reloc_overflow)
2836             (flaginfo->info, NULL,
2837              (link_order->type == bfd_section_reloc_link_order
2838               ? bfd_section_name (output_bfd,
2839                                   link_order->u.reloc.p->u.section)
2840               : link_order->u.reloc.p->u.name),
2841              howto->name, link_order->u.reloc.p->addend,
2842              (bfd *) NULL, (asection *) NULL, (bfd_vma) 0);
2843           break;
2844         }
2845       loc = link_order->offset * bfd_octets_per_byte (output_bfd);
2846       ok = bfd_set_section_contents (output_bfd, output_section, buf,
2847                                      loc, size);
2848       free (buf);
2849       if (! ok)
2850         return FALSE;
2851     }
2852
2853   /* Store the reloc information in the right place.  It will get
2854      swapped and written out at the end of the final_link routine.  */
2855   irel = (flaginfo->section_info[output_section->target_index].relocs
2856           + output_section->reloc_count);
2857   rel_hash_ptr = (flaginfo->section_info[output_section->target_index].rel_hashes
2858                   + output_section->reloc_count);
2859
2860   memset (irel, 0, sizeof (struct internal_reloc));
2861   *rel_hash_ptr = NULL;
2862
2863   irel->r_vaddr = output_section->vma + link_order->offset;
2864
2865   if (link_order->type == bfd_section_reloc_link_order)
2866     {
2867       /* We need to somehow locate a symbol in the right section.  The
2868          symbol must either have a value of zero, or we must adjust
2869          the addend by the value of the symbol.  FIXME: Write this
2870          when we need it.  The old linker couldn't handle this anyhow.  */
2871       abort ();
2872       *rel_hash_ptr = NULL;
2873       irel->r_symndx = 0;
2874     }
2875   else
2876     {
2877       struct coff_link_hash_entry *h;
2878
2879       h = ((struct coff_link_hash_entry *)
2880            bfd_wrapped_link_hash_lookup (output_bfd, flaginfo->info,
2881                                          link_order->u.reloc.p->u.name,
2882                                          FALSE, FALSE, TRUE));
2883       if (h != NULL)
2884         {
2885           if (h->indx >= 0)
2886             irel->r_symndx = h->indx;
2887           else
2888             {
2889               /* Set the index to -2 to force this symbol to get
2890                  written out.  */
2891               h->indx = -2;
2892               *rel_hash_ptr = h;
2893               irel->r_symndx = 0;
2894             }
2895         }
2896       else
2897         {
2898           (*flaginfo->info->callbacks->unattached_reloc)
2899             (flaginfo->info, link_order->u.reloc.p->u.name,
2900              (bfd *) NULL, (asection *) NULL, (bfd_vma) 0);
2901           irel->r_symndx = 0;
2902         }
2903     }
2904
2905   /* FIXME: Is this always right?  */
2906   irel->r_type = howto->type;
2907
2908   /* r_size is only used on the RS/6000, which needs its own linker
2909      routines anyhow.  r_extern is only used for ECOFF.  */
2910
2911   /* FIXME: What is the right value for r_offset?  Is zero OK?  */
2912   ++output_section->reloc_count;
2913
2914   return TRUE;
2915 }
2916
2917 /* A basic reloc handling routine which may be used by processors with
2918    simple relocs.  */
2919
2920 bfd_boolean
2921 _bfd_coff_generic_relocate_section (bfd *output_bfd,
2922                                     struct bfd_link_info *info,
2923                                     bfd *input_bfd,
2924                                     asection *input_section,
2925                                     bfd_byte *contents,
2926                                     struct internal_reloc *relocs,
2927                                     struct internal_syment *syms,
2928                                     asection **sections)
2929 {
2930   struct internal_reloc *rel;
2931   struct internal_reloc *relend;
2932
2933   rel = relocs;
2934   relend = rel + input_section->reloc_count;
2935   for (; rel < relend; rel++)
2936     {
2937       long symndx;
2938       struct coff_link_hash_entry *h;
2939       struct internal_syment *sym;
2940       bfd_vma addend;
2941       bfd_vma val;
2942       asection *sec;
2943       reloc_howto_type *howto;
2944       bfd_reloc_status_type rstat;
2945
2946       symndx = rel->r_symndx;
2947
2948       if (symndx == -1)
2949         {
2950           h = NULL;
2951           sym = NULL;
2952         }
2953       else if (symndx < 0
2954                || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
2955         {
2956           (*_bfd_error_handler)
2957             ("%B: illegal symbol index %ld in relocs", input_bfd, symndx);
2958           return FALSE;
2959         }
2960       else
2961         {
2962           h = obj_coff_sym_hashes (input_bfd)[symndx];
2963           sym = syms + symndx;
2964         }
2965
2966       /* COFF treats common symbols in one of two ways.  Either the
2967          size of the symbol is included in the section contents, or it
2968          is not.  We assume that the size is not included, and force
2969          the rtype_to_howto function to adjust the addend as needed.  */
2970       if (sym != NULL && sym->n_scnum != 0)
2971         addend = - sym->n_value;
2972       else
2973         addend = 0;
2974
2975       howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
2976                                        sym, &addend);
2977       if (howto == NULL)
2978         return FALSE;
2979
2980       /* If we are doing a relocatable link, then we can just ignore
2981          a PC relative reloc that is pcrel_offset.  It will already
2982          have the correct value.  If this is not a relocatable link,
2983          then we should ignore the symbol value.  */
2984       if (howto->pc_relative && howto->pcrel_offset)
2985         {
2986           if (bfd_link_relocatable (info))
2987             continue;
2988           if (sym != NULL && sym->n_scnum != 0)
2989             addend += sym->n_value;
2990         }
2991
2992       val = 0;
2993       sec = NULL;
2994       if (h == NULL)
2995         {
2996           if (symndx == -1)
2997             {
2998               sec = bfd_abs_section_ptr;
2999               val = 0;
3000             }
3001           else
3002             {
3003               sec = sections[symndx];
3004
3005               /* PR 19623: Relocations against symbols in
3006                  the absolute sections should ignored.  */
3007               if (bfd_is_abs_section (sec))
3008                 continue;
3009
3010               val = (sec->output_section->vma
3011                      + sec->output_offset
3012                      + sym->n_value);
3013               if (! obj_pe (input_bfd))
3014                 val -= sec->vma;
3015             }
3016         }
3017       else
3018         {
3019           if (h->root.type == bfd_link_hash_defined
3020               || h->root.type == bfd_link_hash_defweak)
3021             {
3022               /* Defined weak symbols are a GNU extension. */
3023               sec = h->root.u.def.section;
3024               val = (h->root.u.def.value
3025                      + sec->output_section->vma
3026                      + sec->output_offset);
3027             }
3028
3029           else if (h->root.type == bfd_link_hash_undefweak)
3030             {
3031               if (h->symbol_class == C_NT_WEAK && h->numaux == 1)
3032                 {
3033                   /* See _Microsoft Portable Executable and Common Object
3034                      File Format Specification_, section 5.5.3.
3035                      Note that weak symbols without aux records are a GNU
3036                      extension.
3037                      FIXME: All weak externals are treated as having
3038                      characteristic IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY (1).
3039                      These behave as per SVR4 ABI:  A library member
3040                      will resolve a weak external only if a normal
3041                      external causes the library member to be linked.
3042                      See also linker.c: generic_link_check_archive_element. */
3043                   struct coff_link_hash_entry *h2 =
3044                     h->auxbfd->tdata.coff_obj_data->sym_hashes[
3045                     h->aux->x_sym.x_tagndx.l];
3046
3047                   if (!h2 || h2->root.type == bfd_link_hash_undefined)
3048                     {
3049                       sec = bfd_abs_section_ptr;
3050                       val = 0;
3051                     }
3052                   else
3053                     {
3054                       sec = h2->root.u.def.section;
3055                       val = h2->root.u.def.value
3056                         + sec->output_section->vma + sec->output_offset;
3057                     }
3058                 }
3059               else
3060                 /* This is a GNU extension.  */
3061                 val = 0;
3062             }
3063
3064           else if (! bfd_link_relocatable (info))
3065             (*info->callbacks->undefined_symbol)
3066               (info, h->root.root.string, input_bfd, input_section,
3067                rel->r_vaddr - input_section->vma, TRUE);
3068         }
3069
3070       /* If the input section defining the symbol has been discarded
3071          then zero this reloc field.  */
3072       if (sec != NULL && discarded_section (sec))
3073         {
3074           _bfd_clear_contents (howto, input_bfd, input_section,
3075                                contents + (rel->r_vaddr - input_section->vma));
3076           continue;
3077         }
3078
3079       if (info->base_file)
3080         {
3081           /* Emit a reloc if the backend thinks it needs it.  */
3082           if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
3083             {
3084               /* Relocation to a symbol in a section which isn't
3085                  absolute.  We output the address here to a file.
3086                  This file is then read by dlltool when generating the
3087                  reloc section.  Note that the base file is not
3088                  portable between systems.  We write out a bfd_vma here,
3089                  and dlltool reads in a bfd_vma.  */
3090               bfd_vma addr = (rel->r_vaddr
3091                            - input_section->vma
3092                            + input_section->output_offset
3093                            + input_section->output_section->vma);
3094               if (coff_data (output_bfd)->pe)
3095                 addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
3096               if (fwrite (&addr, 1, sizeof (bfd_vma), (FILE *) info->base_file)
3097                   != sizeof (bfd_vma))
3098                 {
3099                   bfd_set_error (bfd_error_system_call);
3100                   return FALSE;
3101                 }
3102             }
3103         }
3104
3105       rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
3106                                         contents,
3107                                         rel->r_vaddr - input_section->vma,
3108                                         val, addend);
3109
3110       switch (rstat)
3111         {
3112         default:
3113           abort ();
3114         case bfd_reloc_ok:
3115           break;
3116         case bfd_reloc_outofrange:
3117           (*_bfd_error_handler)
3118             (_("%B: bad reloc address 0x%lx in section `%A'"),
3119              input_bfd, input_section, (unsigned long) rel->r_vaddr);
3120           return FALSE;
3121         case bfd_reloc_overflow:
3122           {
3123             const char *name;
3124             char buf[SYMNMLEN + 1];
3125
3126             if (symndx == -1)
3127               name = "*ABS*";
3128             else if (h != NULL)
3129               name = NULL;
3130             else
3131               {
3132                 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3133                 if (name == NULL)
3134                   return FALSE;
3135               }
3136
3137             (*info->callbacks->reloc_overflow)
3138               (info, (h ? &h->root : NULL), name, howto->name,
3139                (bfd_vma) 0, input_bfd, input_section,
3140                rel->r_vaddr - input_section->vma);
3141           }
3142         }
3143     }
3144   return TRUE;
3145 }