bfd/cofflink.c

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