contrib/binutils-2.25/bfd/cofflink.c

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