bfd/coffgen.c

   1 /* Support for the generic parts of COFF, for BFD.
   2    Copyright (C) 1990-2014 Free Software Foundation, Inc.
   3    Written by 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 /* Most of this hacked by  Steve Chamberlain, sac@cygnus.com.
  23    Split out of coffcode.h by Ian Taylor, ian@cygnus.com.  */
  24
  25 /* This file contains COFF code that is not dependent on any
  26    particular COFF target.  There is only one version of this file in
  27    libbfd.a, so no target specific code may be put in here.  Or, to
  28    put it another way,
  29
  30    ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
  31
  32    If you need to add some target specific behaviour, add a new hook
  33    function to bfd_coff_backend_data.
  34
  35    Some of these functions are also called by the ECOFF routines.
  36    Those functions may not use any COFF specific information, such as
  37    coff_data (abfd).  */
  38
  39 #include "sysdep.h"
  40 #include "bfd.h"
  41 #include "libbfd.h"
  42 #include "coff/internal.h"
  43 #include "libcoff.h"
  44
  45 /* Take a section header read from a coff file (in HOST byte order),
  46    and make a BFD "section" out of it.  This is used by ECOFF.  */
  47
  48 static bfd_boolean
  49 make_a_section_from_file (bfd *abfd,
  50                           struct internal_scnhdr *hdr,
  51                           unsigned int target_index)
  52 {
  53   asection *return_section;
  54   char *name;
  55   bfd_boolean result = TRUE;
  56   flagword flags;
  57
  58   name = NULL;
  59
  60   /* Handle long section names as in PE.  On reading, we want to
  61     accept long names if the format permits them at all, regardless
  62     of the current state of the flag that dictates if we would generate
  63     them in outputs; this construct checks if that is the case by
  64     attempting to set the flag, without changing its state; the call
  65     will fail for formats that do not support long names at all.  */
  66   if (bfd_coff_set_long_section_names (abfd, bfd_coff_long_section_names (abfd))
  67       && hdr->s_name[0] == '/')
  68     {
  69       char buf[SCNNMLEN];
  70       long strindex;
  71       char *p;
  72       const char *strings;
  73
  74       /* Flag that this BFD uses long names, even though the format might
  75          expect them to be off by default.  This won't directly affect the
  76          format of any output BFD created from this one, but the information
  77          can be used to decide what to do.  */
  78       bfd_coff_set_long_section_names (abfd, TRUE);
  79       memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1);
  80       buf[SCNNMLEN - 1] = '\0';
  81       strindex = strtol (buf, &p, 10);
  82       if (*p == '\0' && strindex >= 0)
  83         {
  84           strings = _bfd_coff_read_string_table (abfd);
  85           if (strings == NULL)
  86             return FALSE;
  87           if ((bfd_size_type)(strindex + 2) >= obj_coff_strings_len (abfd))
  88             return FALSE;
  89           strings += strindex;
  90           name = (char *) bfd_alloc (abfd,
  91                                      (bfd_size_type) strlen (strings) + 1 + 1);
  92           if (name == NULL)
  93             return FALSE;
  94           strcpy (name, strings);
  95         }
  96     }
  97
  98   if (name == NULL)
  99     {
 100       /* Assorted wastage to null-terminate the name, thanks AT&T! */
 101       name = (char *) bfd_alloc (abfd,
 102                                  (bfd_size_type) sizeof (hdr->s_name) + 1 + 1);
 103       if (name == NULL)
 104         return FALSE;
 105       strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
 106       name[sizeof (hdr->s_name)] = 0;
 107     }
 108
 109   return_section = bfd_make_section_anyway (abfd, name);
 110   if (return_section == NULL)
 111     return FALSE;
 112
 113   return_section->vma = hdr->s_vaddr;
 114   return_section->lma = hdr->s_paddr;
 115   return_section->size = hdr->s_size;
 116   return_section->filepos = hdr->s_scnptr;
 117   return_section->rel_filepos = hdr->s_relptr;
 118   return_section->reloc_count = hdr->s_nreloc;
 119
 120   bfd_coff_set_alignment_hook (abfd, return_section, hdr);
 121
 122   return_section->line_filepos = hdr->s_lnnoptr;
 123
 124   return_section->lineno_count = hdr->s_nlnno;
 125   return_section->userdata = NULL;
 126   return_section->next = NULL;
 127   return_section->target_index = target_index;
 128
 129   if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section,
 130                                          & flags))
 131     result = FALSE;
 132
 133   return_section->flags = flags;
 134
 135   /* At least on i386-coff, the line number count for a shared library
 136      section must be ignored.  */
 137   if ((return_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
 138     return_section->lineno_count = 0;
 139
 140   if (hdr->s_nreloc != 0)
 141     return_section->flags |= SEC_RELOC;
 142   /* FIXME: should this check 'hdr->s_size > 0'.  */
 143   if (hdr->s_scnptr != 0)
 144     return_section->flags |= SEC_HAS_CONTENTS;
 145
 146   /* Compress/decompress DWARF debug sections with names: .debug_* and
 147      .zdebug_*, after the section flags is set.  */
 148   if ((flags & SEC_DEBUGGING)
 149       && strlen (name) > 7
 150       && ((name[1] == 'd' && name[6] == '_')
 151           || (strlen (name) > 8 && name[1] == 'z' && name[7] == '_')))
 152     {
 153       enum { nothing, compress, decompress } action = nothing;
 154       char *new_name = NULL;
 155
 156       if (bfd_is_section_compressed (abfd, return_section))
 157         {
 158           /* Compressed section.  Check if we should decompress.  */
 159           if ((abfd->flags & BFD_DECOMPRESS))
 160             action = decompress;
 161         }
 162       else if (!bfd_is_section_compressed (abfd, return_section))
 163         {
 164           /* Normal section.  Check if we should compress.  */
 165           if ((abfd->flags & BFD_COMPRESS) && return_section->size != 0)
 166             action = compress;
 167         }
 168
 169       switch (action)
 170         {
 171         case nothing:
 172           break;
 173         case compress:
 174           if (!bfd_init_section_compress_status (abfd, return_section))
 175             {
 176               (*_bfd_error_handler)
 177                 (_("%B: unable to initialize compress status for section %s"),
 178                  abfd, name);
 179               return FALSE;
 180             }
 181           if (name[1] != 'z')
 182             {
 183               unsigned int len = strlen (name);
 184
 185               new_name = bfd_alloc (abfd, len + 2);
 186               if (new_name == NULL)
 187                 return FALSE;
 188               new_name[0] = '.';
 189               new_name[1] = 'z';
 190               memcpy (new_name + 2, name + 1, len);
 191             }
 192           break;
 193         case decompress:
 194           if (!bfd_init_section_decompress_status (abfd, return_section))
 195             {
 196               (*_bfd_error_handler)
 197                 (_("%B: unable to initialize decompress status for section %s"),
 198                  abfd, name);
 199               return FALSE;
 200             }
 201           if (name[1] == 'z')
 202             {
 203               unsigned int len = strlen (name);
 204
 205               new_name = bfd_alloc (abfd, len);
 206               if (new_name == NULL)
 207                 return FALSE;
 208               new_name[0] = '.';
 209               memcpy (new_name + 1, name + 2, len - 1);
 210             }
 211           break;
 212         }
 213       if (new_name != NULL)
 214         bfd_rename_section (abfd, return_section, new_name);
 215     }
 216
 217   return result;
 218 }
 219
 220 /* Read in a COFF object and make it into a BFD.  This is used by
 221    ECOFF as well.  */
 222 const bfd_target *
 223 coff_real_object_p (bfd *,
 224                     unsigned,
 225                     struct internal_filehdr *,
 226                     struct internal_aouthdr *);
 227 const bfd_target *
 228 coff_real_object_p (bfd *abfd,
 229                     unsigned nscns,
 230                     struct internal_filehdr *internal_f,
 231                     struct internal_aouthdr *internal_a)
 232 {
 233   flagword oflags = abfd->flags;
 234   bfd_vma ostart = bfd_get_start_address (abfd);
 235   void * tdata;
 236   void * tdata_save;
 237   bfd_size_type readsize;       /* Length of file_info.  */
 238   unsigned int scnhsz;
 239   char *external_sections;
 240
 241   if (!(internal_f->f_flags & F_RELFLG))
 242     abfd->flags |= HAS_RELOC;
 243   if ((internal_f->f_flags & F_EXEC))
 244     abfd->flags |= EXEC_P;
 245   if (!(internal_f->f_flags & F_LNNO))
 246     abfd->flags |= HAS_LINENO;
 247   if (!(internal_f->f_flags & F_LSYMS))
 248     abfd->flags |= HAS_LOCALS;
 249
 250   /* FIXME: How can we set D_PAGED correctly?  */
 251   if ((internal_f->f_flags & F_EXEC) != 0)
 252     abfd->flags |= D_PAGED;
 253
 254   bfd_get_symcount (abfd) = internal_f->f_nsyms;
 255   if (internal_f->f_nsyms)
 256     abfd->flags |= HAS_SYMS;
 257
 258   if (internal_a != (struct internal_aouthdr *) NULL)
 259     bfd_get_start_address (abfd) = internal_a->entry;
 260   else
 261     bfd_get_start_address (abfd) = 0;
 262
 263   /* Set up the tdata area.  ECOFF uses its own routine, and overrides
 264      abfd->flags.  */
 265   tdata_save = abfd->tdata.any;
 266   tdata = bfd_coff_mkobject_hook (abfd, (void *) internal_f, (void *) internal_a);
 267   if (tdata == NULL)
 268     goto fail2;
 269
 270   scnhsz = bfd_coff_scnhsz (abfd);
 271   readsize = (bfd_size_type) nscns * scnhsz;
 272   external_sections = (char *) bfd_alloc (abfd, readsize);
 273   if (!external_sections)
 274     goto fail;
 275
 276   if (bfd_bread ((void *) external_sections, readsize, abfd) != readsize)
 277     goto fail;
 278
 279   /* Set the arch/mach *before* swapping in sections; section header swapping
 280      may depend on arch/mach info.  */
 281   if (! bfd_coff_set_arch_mach_hook (abfd, (void *) internal_f))
 282     goto fail;
 283
 284   /* Now copy data as required; construct all asections etc.  */
 285   if (nscns != 0)
 286     {
 287       unsigned int i;
 288       for (i = 0; i < nscns; i++)
 289         {
 290           struct internal_scnhdr tmp;
 291           bfd_coff_swap_scnhdr_in (abfd,
 292                                    (void *) (external_sections + i * scnhsz),
 293                                    (void *) & tmp);
 294           if (! make_a_section_from_file (abfd, &tmp, i + 1))
 295             goto fail;
 296         }
 297     }
 298
 299   return abfd->xvec;
 300
 301  fail:
 302   bfd_release (abfd, tdata);
 303  fail2:
 304   abfd->tdata.any = tdata_save;
 305   abfd->flags = oflags;
 306   bfd_get_start_address (abfd) = ostart;
 307   return (const bfd_target *) NULL;
 308 }
 309
 310 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
 311    not a COFF file.  This is also used by ECOFF.  */
 312
 313 const bfd_target *
 314 coff_object_p (bfd *abfd)
 315 {
 316   bfd_size_type filhsz;
 317   bfd_size_type aoutsz;
 318   unsigned int nscns;
 319   void * filehdr;
 320   struct internal_filehdr internal_f;
 321   struct internal_aouthdr internal_a;
 322
 323   /* Figure out how much to read.  */
 324   filhsz = bfd_coff_filhsz (abfd);
 325   aoutsz = bfd_coff_aoutsz (abfd);
 326
 327   filehdr = bfd_alloc (abfd, filhsz);
 328   if (filehdr == NULL)
 329     return NULL;
 330   if (bfd_bread (filehdr, filhsz, abfd) != filhsz)
 331     {
 332       if (bfd_get_error () != bfd_error_system_call)
 333         bfd_set_error (bfd_error_wrong_format);
 334       bfd_release (abfd, filehdr);
 335       return NULL;
 336     }
 337   bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f);
 338   bfd_release (abfd, filehdr);
 339
 340   /* The XCOFF format has two sizes for the f_opthdr.  SMALL_AOUTSZ
 341      (less than aoutsz) used in object files and AOUTSZ (equal to
 342      aoutsz) in executables.  The bfd_coff_swap_aouthdr_in function
 343      expects this header to be aoutsz bytes in length, so we use that
 344      value in the call to bfd_alloc below.  But we must be careful to
 345      only read in f_opthdr bytes in the call to bfd_bread.  We should
 346      also attempt to catch corrupt or non-COFF binaries with a strange
 347      value for f_opthdr.  */
 348   if (! bfd_coff_bad_format_hook (abfd, &internal_f)
 349       || internal_f.f_opthdr > aoutsz)
 350     {
 351       bfd_set_error (bfd_error_wrong_format);
 352       return NULL;
 353     }
 354   nscns = internal_f.f_nscns;
 355
 356   if (internal_f.f_opthdr)
 357     {
 358       void * opthdr;
 359
 360       opthdr = bfd_alloc (abfd, aoutsz);
 361       if (opthdr == NULL)
 362         return NULL;
 363       if (bfd_bread (opthdr, (bfd_size_type) internal_f.f_opthdr, abfd)
 364           != internal_f.f_opthdr)
 365         {
 366           bfd_release (abfd, opthdr);
 367           return NULL;
 368         }
 369       /* PR 17512: file: 11056-1136-0.004.  */
 370       if (internal_f.f_opthdr < aoutsz)
 371         memset (((char *) opthdr) + internal_f.f_opthdr, 0, aoutsz - internal_f.f_opthdr);
 372
 373       bfd_coff_swap_aouthdr_in (abfd, opthdr, (void *) &internal_a);
 374       bfd_release (abfd, opthdr);
 375     }
 376
 377   return coff_real_object_p (abfd, nscns, &internal_f,
 378                              (internal_f.f_opthdr != 0
 379                               ? &internal_a
 380                               : (struct internal_aouthdr *) NULL));
 381 }
 382
 383 /* Get the BFD section from a COFF symbol section number.  */
 384
 385 asection *
 386 coff_section_from_bfd_index (bfd *abfd, int section_index)
 387 {
 388   struct bfd_section *answer = abfd->sections;
 389
 390   if (section_index == N_ABS)
 391     return bfd_abs_section_ptr;
 392   if (section_index == N_UNDEF)
 393     return bfd_und_section_ptr;
 394   if (section_index == N_DEBUG)
 395     return bfd_abs_section_ptr;
 396
 397   while (answer)
 398     {
 399       if (answer->target_index == section_index)
 400         return answer;
 401       answer = answer->next;
 402     }
 403
 404   /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
 405      has a bad symbol table in biglitpow.o.  */
 406   return bfd_und_section_ptr;
 407 }
 408
 409 /* Get the upper bound of a COFF symbol table.  */
 410
 411 long
 412 coff_get_symtab_upper_bound (bfd *abfd)
 413 {
 414   if (!bfd_coff_slurp_symbol_table (abfd))
 415     return -1;
 416
 417   return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *));
 418 }
 419
 420 /* Canonicalize a COFF symbol table.  */
 421
 422 long
 423 coff_canonicalize_symtab (bfd *abfd, asymbol **alocation)
 424 {
 425   unsigned int counter;
 426   coff_symbol_type *symbase;
 427   coff_symbol_type **location = (coff_symbol_type **) alocation;
 428
 429   if (!bfd_coff_slurp_symbol_table (abfd))
 430     return -1;
 431
 432   symbase = obj_symbols (abfd);
 433   counter = bfd_get_symcount (abfd);
 434   while (counter-- > 0)
 435     *location++ = symbase++;
 436
 437   *location = NULL;
 438
 439   return bfd_get_symcount (abfd);
 440 }
 441
 442 /* Get the name of a symbol.  The caller must pass in a buffer of size
 443    >= SYMNMLEN + 1.  */
 444
 445 const char *
 446 _bfd_coff_internal_syment_name (bfd *abfd,
 447                                 const struct internal_syment *sym,
 448                                 char *buf)
 449 {
 450   /* FIXME: It's not clear this will work correctly if sizeof
 451      (_n_zeroes) != 4.  */
 452   if (sym->_n._n_n._n_zeroes != 0
 453       || sym->_n._n_n._n_offset == 0)
 454     {
 455       memcpy (buf, sym->_n._n_name, SYMNMLEN);
 456       buf[SYMNMLEN] = '\0';
 457       return buf;
 458     }
 459   else
 460     {
 461       const char *strings;
 462
 463       BFD_ASSERT (sym->_n._n_n._n_offset >= STRING_SIZE_SIZE);
 464       strings = obj_coff_strings (abfd);
 465       if (strings == NULL)
 466         {
 467           strings = _bfd_coff_read_string_table (abfd);
 468           if (strings == NULL)
 469             return NULL;
 470         }
 471       if (sym->_n._n_n._n_offset >= obj_coff_strings_len (abfd))
 472         return NULL;
 473       return strings + sym->_n._n_n._n_offset;
 474     }
 475 }
 476
 477 /* Read in and swap the relocs.  This returns a buffer holding the
 478    relocs for section SEC in file ABFD.  If CACHE is TRUE and
 479    INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
 480    the function is called again.  If EXTERNAL_RELOCS is not NULL, it
 481    is a buffer large enough to hold the unswapped relocs.  If
 482    INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
 483    the swapped relocs.  If REQUIRE_INTERNAL is TRUE, then the return
 484    value must be INTERNAL_RELOCS.  The function returns NULL on error.  */
 485
 486 struct internal_reloc *
 487 _bfd_coff_read_internal_relocs (bfd *abfd,
 488                                 asection *sec,
 489                                 bfd_boolean cache,
 490                                 bfd_byte *external_relocs,
 491                                 bfd_boolean require_internal,
 492                                 struct internal_reloc *internal_relocs)
 493 {
 494   bfd_size_type relsz;
 495   bfd_byte *free_external = NULL;
 496   struct internal_reloc *free_internal = NULL;
 497   bfd_byte *erel;
 498   bfd_byte *erel_end;
 499   struct internal_reloc *irel;
 500   bfd_size_type amt;
 501
 502   if (sec->reloc_count == 0)
 503     return internal_relocs;     /* Nothing to do.  */
 504
 505   if (coff_section_data (abfd, sec) != NULL
 506       && coff_section_data (abfd, sec)->relocs != NULL)
 507     {
 508       if (! require_internal)
 509         return coff_section_data (abfd, sec)->relocs;
 510       memcpy (internal_relocs, coff_section_data (abfd, sec)->relocs,
 511               sec->reloc_count * sizeof (struct internal_reloc));
 512       return internal_relocs;
 513     }
 514
 515   relsz = bfd_coff_relsz (abfd);
 516
 517   amt = sec->reloc_count * relsz;
 518   if (external_relocs == NULL)
 519     {
 520       free_external = (bfd_byte *) bfd_malloc (amt);
 521       if (free_external == NULL)
 522         goto error_return;
 523       external_relocs = free_external;
 524     }
 525
 526   if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
 527       || bfd_bread (external_relocs, amt, abfd) != amt)
 528     goto error_return;
 529
 530   if (internal_relocs == NULL)
 531     {
 532       amt = sec->reloc_count;
 533       amt *= sizeof (struct internal_reloc);
 534       free_internal = (struct internal_reloc *) bfd_malloc (amt);
 535       if (free_internal == NULL)
 536         goto error_return;
 537       internal_relocs = free_internal;
 538     }
 539
 540   /* Swap in the relocs.  */
 541   erel = external_relocs;
 542   erel_end = erel + relsz * sec->reloc_count;
 543   irel = internal_relocs;
 544   for (; erel < erel_end; erel += relsz, irel++)
 545     bfd_coff_swap_reloc_in (abfd, (void *) erel, (void *) irel);
 546
 547   if (free_external != NULL)
 548     {
 549       free (free_external);
 550       free_external = NULL;
 551     }
 552
 553   if (cache && free_internal != NULL)
 554     {
 555       if (coff_section_data (abfd, sec) == NULL)
 556         {
 557           amt = sizeof (struct coff_section_tdata);
 558           sec->used_by_bfd = bfd_zalloc (abfd, amt);
 559           if (sec->used_by_bfd == NULL)
 560             goto error_return;
 561           coff_section_data (abfd, sec)->contents = NULL;
 562         }
 563       coff_section_data (abfd, sec)->relocs = free_internal;
 564     }
 565
 566   return internal_relocs;
 567
 568  error_return:
 569   if (free_external != NULL)
 570     free (free_external);
 571   if (free_internal != NULL)
 572     free (free_internal);
 573   return NULL;
 574 }
 575
 576 /* Set lineno_count for the output sections of a COFF file.  */
 577
 578 int
 579 coff_count_linenumbers (bfd *abfd)
 580 {
 581   unsigned int limit = bfd_get_symcount (abfd);
 582   unsigned int i;
 583   int total = 0;
 584   asymbol **p;
 585   asection *s;
 586
 587   if (limit == 0)
 588     {
 589       /* This may be from the backend linker, in which case the
 590          lineno_count in the sections is correct.  */
 591       for (s = abfd->sections; s != NULL; s = s->next)
 592         total += s->lineno_count;
 593       return total;
 594     }
 595
 596   for (s = abfd->sections; s != NULL; s = s->next)
 597     BFD_ASSERT (s->lineno_count == 0);
 598
 599   for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
 600     {
 601       asymbol *q_maybe = *p;
 602
 603       if (bfd_family_coff (bfd_asymbol_bfd (q_maybe)))
 604         {
 605           coff_symbol_type *q = coffsymbol (q_maybe);
 606
 607           /* The AIX 4.1 compiler can sometimes generate line numbers
 608              attached to debugging symbols.  We try to simply ignore
 609              those here.  */
 610           if (q->lineno != NULL
 611               && q->symbol.section->owner != NULL)
 612             {
 613               /* This symbol has line numbers.  Increment the owning
 614                  section's linenumber count.  */
 615               alent *l = q->lineno;
 616
 617               do
 618                 {
 619                   asection * sec = q->symbol.section->output_section;
 620
 621                   /* Do not try to update fields in read-only sections.  */
 622                   if (! bfd_is_const_section (sec))
 623                     sec->lineno_count ++;
 624
 625                   ++total;
 626                   ++l;
 627                 }
 628               while (l->line_number != 0);
 629             }
 630         }
 631     }
 632
 633   return total;
 634 }
 635
 636 static void
 637 fixup_symbol_value (bfd *abfd,
 638                     coff_symbol_type *coff_symbol_ptr,
 639                     struct internal_syment *syment)
 640 {
 641   /* Normalize the symbol flags.  */
 642   if (coff_symbol_ptr->symbol.section
 643       && bfd_is_com_section (coff_symbol_ptr->symbol.section))
 644     {
 645       /* A common symbol is undefined with a value.  */
 646       syment->n_scnum = N_UNDEF;
 647       syment->n_value = coff_symbol_ptr->symbol.value;
 648     }
 649   else if ((coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) != 0
 650            && (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING_RELOC) == 0)
 651     {
 652       syment->n_value = coff_symbol_ptr->symbol.value;
 653     }
 654   else if (bfd_is_und_section (coff_symbol_ptr->symbol.section))
 655     {
 656       syment->n_scnum = N_UNDEF;
 657       syment->n_value = 0;
 658     }
 659   /* FIXME: Do we need to handle the absolute section here?  */
 660   else
 661     {
 662       if (coff_symbol_ptr->symbol.section)
 663         {
 664           syment->n_scnum =
 665             coff_symbol_ptr->symbol.section->output_section->target_index;
 666
 667           syment->n_value = (coff_symbol_ptr->symbol.value
 668                              + coff_symbol_ptr->symbol.section->output_offset);
 669           if (! obj_pe (abfd))
 670             {
 671               syment->n_value += (syment->n_sclass == C_STATLAB)
 672                 ? coff_symbol_ptr->symbol.section->output_section->lma
 673                 : coff_symbol_ptr->symbol.section->output_section->vma;
 674             }
 675         }
 676       else
 677         {
 678           BFD_ASSERT (0);
 679           /* This can happen, but I don't know why yet (steve@cygnus.com) */
 680           syment->n_scnum = N_ABS;
 681           syment->n_value = coff_symbol_ptr->symbol.value;
 682         }
 683     }
 684 }
 685
 686 /* Run through all the symbols in the symbol table and work out what
 687    their indexes into the symbol table will be when output.
 688
 689    Coff requires that each C_FILE symbol points to the next one in the
 690    chain, and that the last one points to the first external symbol. We
 691    do that here too.  */
 692
 693 bfd_boolean
 694 coff_renumber_symbols (bfd *bfd_ptr, int *first_undef)
 695 {
 696   unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
 697   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
 698   unsigned int native_index = 0;
 699   struct internal_syment *last_file = NULL;
 700   unsigned int symbol_index;
 701
 702   /* COFF demands that undefined symbols come after all other symbols.
 703      Since we don't need to impose this extra knowledge on all our
 704      client programs, deal with that here.  Sort the symbol table;
 705      just move the undefined symbols to the end, leaving the rest
 706      alone.  The O'Reilly book says that defined global symbols come
 707      at the end before the undefined symbols, so we do that here as
 708      well.  */
 709   /* @@ Do we have some condition we could test for, so we don't always
 710      have to do this?  I don't think relocatability is quite right, but
 711      I'm not certain.  [raeburn:19920508.1711EST]  */
 712   {
 713     asymbol **newsyms;
 714     unsigned int i;
 715     bfd_size_type amt;
 716
 717     amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);
 718     newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt);
 719     if (!newsyms)
 720       return FALSE;
 721     bfd_ptr->outsymbols = newsyms;
 722     for (i = 0; i < symbol_count; i++)
 723       if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0
 724           || (!bfd_is_und_section (symbol_ptr_ptr[i]->section)
 725               && !bfd_is_com_section (symbol_ptr_ptr[i]->section)
 726               && ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) != 0
 727                   || ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
 728                       == 0))))
 729         *newsyms++ = symbol_ptr_ptr[i];
 730
 731     for (i = 0; i < symbol_count; i++)
 732       if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
 733           && !bfd_is_und_section (symbol_ptr_ptr[i]->section)
 734           && (bfd_is_com_section (symbol_ptr_ptr[i]->section)
 735               || ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) == 0
 736                   && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
 737                       != 0))))
 738         *newsyms++ = symbol_ptr_ptr[i];
 739
 740     *first_undef = newsyms - bfd_ptr->outsymbols;
 741
 742     for (i = 0; i < symbol_count; i++)
 743       if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
 744           && bfd_is_und_section (symbol_ptr_ptr[i]->section))
 745         *newsyms++ = symbol_ptr_ptr[i];
 746     *newsyms = (asymbol *) NULL;
 747     symbol_ptr_ptr = bfd_ptr->outsymbols;
 748   }
 749
 750   for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
 751     {
 752       coff_symbol_type *coff_symbol_ptr;
 753
 754       coff_symbol_ptr = coff_symbol_from (symbol_ptr_ptr[symbol_index]);
 755       symbol_ptr_ptr[symbol_index]->udata.i = symbol_index;
 756       if (coff_symbol_ptr && coff_symbol_ptr->native)
 757         {
 758           combined_entry_type *s = coff_symbol_ptr->native;
 759           int i;
 760
 761           BFD_ASSERT (s->is_sym);
 762           if (s->u.syment.n_sclass == C_FILE)
 763             {
 764               if (last_file != NULL)
 765                 last_file->n_value = native_index;
 766               last_file = &(s->u.syment);
 767             }
 768           else
 769             /* Modify the symbol values according to their section and
 770                type.  */
 771             fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));
 772
 773           for (i = 0; i < s->u.syment.n_numaux + 1; i++)
 774             s[i].offset = native_index++;
 775         }
 776       else
 777         native_index++;
 778     }
 779
 780   obj_conv_table_size (bfd_ptr) = native_index;
 781
 782   return TRUE;
 783 }
 784
 785 /* Run thorough the symbol table again, and fix it so that all
 786    pointers to entries are changed to the entries' index in the output
 787    symbol table.  */
 788
 789 void
 790 coff_mangle_symbols (bfd *bfd_ptr)
 791 {
 792   unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
 793   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
 794   unsigned int symbol_index;
 795
 796   for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
 797     {
 798       coff_symbol_type *coff_symbol_ptr;
 799
 800       coff_symbol_ptr = coff_symbol_from (symbol_ptr_ptr[symbol_index]);
 801       if (coff_symbol_ptr && coff_symbol_ptr->native)
 802         {
 803           int i;
 804           combined_entry_type *s = coff_symbol_ptr->native;
 805
 806           BFD_ASSERT (s->is_sym);
 807           if (s->fix_value)
 808             {
 809               /* FIXME: We should use a union here.  */
 810               s->u.syment.n_value =
 811                 (bfd_hostptr_t) ((combined_entry_type *)
 812                           ((bfd_hostptr_t) s->u.syment.n_value))->offset;
 813               s->fix_value = 0;
 814             }
 815           if (s->fix_line)
 816             {
 817               /* The value is the offset into the line number entries
 818                  for the symbol's section.  On output, the symbol's
 819                  section should be N_DEBUG.  */
 820               s->u.syment.n_value =
 821                 (coff_symbol_ptr->symbol.section->output_section->line_filepos
 822                  + s->u.syment.n_value * bfd_coff_linesz (bfd_ptr));
 823               coff_symbol_ptr->symbol.section =
 824                 coff_section_from_bfd_index (bfd_ptr, N_DEBUG);
 825               BFD_ASSERT (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING);
 826             }
 827           for (i = 0; i < s->u.syment.n_numaux; i++)
 828             {
 829               combined_entry_type *a = s + i + 1;
 830
 831               BFD_ASSERT (! a->is_sym);
 832               if (a->fix_tag)
 833                 {
 834                   a->u.auxent.x_sym.x_tagndx.l =
 835                     a->u.auxent.x_sym.x_tagndx.p->offset;
 836                   a->fix_tag = 0;
 837                 }
 838               if (a->fix_end)
 839                 {
 840                   a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
 841                     a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
 842                   a->fix_end = 0;
 843                 }
 844               if (a->fix_scnlen)
 845                 {
 846                   a->u.auxent.x_csect.x_scnlen.l =
 847                     a->u.auxent.x_csect.x_scnlen.p->offset;
 848                   a->fix_scnlen = 0;
 849                 }
 850             }
 851         }
 852     }
 853 }
 854
 855 static void
 856 coff_fix_symbol_name (bfd *abfd,
 857                       asymbol *symbol,
 858                       combined_entry_type *native,
 859                       bfd_size_type *string_size_p,
 860                       asection **debug_string_section_p,
 861                       bfd_size_type *debug_string_size_p)
 862 {
 863   unsigned int name_length;
 864   union internal_auxent *auxent;
 865   char *name = (char *) (symbol->name);
 866
 867   if (name == NULL)
 868     {
 869       /* COFF symbols always have names, so we'll make one up.  */
 870       symbol->name = "strange";
 871       name = (char *) symbol->name;
 872     }
 873   name_length = strlen (name);
 874
 875   BFD_ASSERT (native->is_sym);
 876   if (native->u.syment.n_sclass == C_FILE
 877       && native->u.syment.n_numaux > 0)
 878     {
 879       unsigned int filnmlen;
 880
 881       if (bfd_coff_force_symnames_in_strings (abfd))
 882         {
 883           native->u.syment._n._n_n._n_offset =
 884               (*string_size_p + STRING_SIZE_SIZE);
 885           native->u.syment._n._n_n._n_zeroes = 0;
 886           *string_size_p += 6;  /* strlen(".file") + 1 */
 887         }
 888       else
 889         strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN);
 890
 891       BFD_ASSERT (! (native + 1)->is_sym);
 892       auxent = &(native + 1)->u.auxent;
 893
 894       filnmlen = bfd_coff_filnmlen (abfd);
 895
 896       if (bfd_coff_long_filenames (abfd))
 897         {
 898           if (name_length <= filnmlen)
 899             strncpy (auxent->x_file.x_fname, name, filnmlen);
 900           else
 901             {
 902               auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE;
 903               auxent->x_file.x_n.x_zeroes = 0;
 904               *string_size_p += name_length + 1;
 905             }
 906         }
 907       else
 908         {
 909           strncpy (auxent->x_file.x_fname, name, filnmlen);
 910           if (name_length > filnmlen)
 911             name[filnmlen] = '\0';
 912         }
 913     }
 914   else
 915     {
 916       if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd))
 917         /* This name will fit into the symbol neatly.  */
 918         strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
 919
 920       else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
 921         {
 922           native->u.syment._n._n_n._n_offset = (*string_size_p
 923                                                 + STRING_SIZE_SIZE);
 924           native->u.syment._n._n_n._n_zeroes = 0;
 925           *string_size_p += name_length + 1;
 926         }
 927       else
 928         {
 929           file_ptr filepos;
 930           bfd_byte buf[4];
 931           int prefix_len = bfd_coff_debug_string_prefix_length (abfd);
 932
 933           /* This name should be written into the .debug section.  For
 934              some reason each name is preceded by a two byte length
 935              and also followed by a null byte.  FIXME: We assume that
 936              the .debug section has already been created, and that it
 937              is large enough.  */
 938           if (*debug_string_section_p == (asection *) NULL)
 939             *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug");
 940           filepos = bfd_tell (abfd);
 941           if (prefix_len == 4)
 942             bfd_put_32 (abfd, (bfd_vma) (name_length + 1), buf);
 943           else
 944             bfd_put_16 (abfd, (bfd_vma) (name_length + 1), buf);
 945
 946           if (!bfd_set_section_contents (abfd,
 947                                          *debug_string_section_p,
 948                                          (void *) buf,
 949                                          (file_ptr) *debug_string_size_p,
 950                                          (bfd_size_type) prefix_len)
 951               || !bfd_set_section_contents (abfd,
 952                                             *debug_string_section_p,
 953                                             (void *) symbol->name,
 954                                             (file_ptr) (*debug_string_size_p
 955                                                         + prefix_len),
 956                                             (bfd_size_type) name_length + 1))
 957             abort ();
 958           if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
 959             abort ();
 960           native->u.syment._n._n_n._n_offset =
 961               *debug_string_size_p + prefix_len;
 962           native->u.syment._n._n_n._n_zeroes = 0;
 963           *debug_string_size_p += name_length + 1 + prefix_len;
 964         }
 965     }
 966 }
 967
 968 /* We need to keep track of the symbol index so that when we write out
 969    the relocs we can get the index for a symbol.  This method is a
 970    hack.  FIXME.  */
 971
 972 #define set_index(symbol, idx)  ((symbol)->udata.i = (idx))
 973
 974 /* Write a symbol out to a COFF file.  */
 975
 976 static bfd_boolean
 977 coff_write_symbol (bfd *abfd,
 978                    asymbol *symbol,
 979                    combined_entry_type *native,
 980                    bfd_vma *written,
 981                    bfd_size_type *string_size_p,
 982                    asection **debug_string_section_p,
 983                    bfd_size_type *debug_string_size_p)
 984 {
 985   unsigned int numaux = native->u.syment.n_numaux;
 986   int type = native->u.syment.n_type;
 987   int n_sclass = (int) native->u.syment.n_sclass;
 988   asection *output_section = symbol->section->output_section
 989                                ? symbol->section->output_section
 990                                : symbol->section;
 991   void * buf;
 992   bfd_size_type symesz;
 993
 994   BFD_ASSERT (native->is_sym);
 995
 996   if (native->u.syment.n_sclass == C_FILE)
 997     symbol->flags |= BSF_DEBUGGING;
 998
 999   if (symbol->flags & BSF_DEBUGGING
1000       && bfd_is_abs_section (symbol->section))
1001     native->u.syment.n_scnum = N_DEBUG;
1002
1003   else if (bfd_is_abs_section (symbol->section))
1004     native->u.syment.n_scnum = N_ABS;
1005
1006   else if (bfd_is_und_section (symbol->section))
1007     native->u.syment.n_scnum = N_UNDEF;
1008
1009   else
1010     native->u.syment.n_scnum =
1011       output_section->target_index;
1012
1013   coff_fix_symbol_name (abfd, symbol, native, string_size_p,
1014                         debug_string_section_p, debug_string_size_p);
1015
1016   symesz = bfd_coff_symesz (abfd);
1017   buf = bfd_alloc (abfd, symesz);
1018   if (!buf)
1019     return FALSE;
1020   bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
1021   if (bfd_bwrite (buf, symesz, abfd) != symesz)
1022     return FALSE;
1023   bfd_release (abfd, buf);
1024
1025   if (native->u.syment.n_numaux > 0)
1026     {
1027       bfd_size_type auxesz;
1028       unsigned int j;
1029
1030       auxesz = bfd_coff_auxesz (abfd);
1031       buf = bfd_alloc (abfd, auxesz);
1032       if (!buf)
1033         return FALSE;
1034       for (j = 0; j < native->u.syment.n_numaux; j++)
1035         {
1036           BFD_ASSERT (! (native + j + 1)->is_sym);
1037           bfd_coff_swap_aux_out (abfd,
1038                                  &((native + j + 1)->u.auxent),
1039                                  type, n_sclass, (int) j,
1040                                  native->u.syment.n_numaux,
1041                                  buf);
1042           if (bfd_bwrite (buf, auxesz, abfd) != auxesz)
1043             return FALSE;
1044         }
1045       bfd_release (abfd, buf);
1046     }
1047
1048   /* Store the index for use when we write out the relocs.  */
1049   set_index (symbol, *written);
1050
1051   *written += numaux + 1;
1052   return TRUE;
1053 }
1054
1055 /* Write out a symbol to a COFF file that does not come from a COFF
1056    file originally.  This symbol may have been created by the linker,
1057    or we may be linking a non COFF file to a COFF file.  */
1058
1059 bfd_boolean
1060 coff_write_alien_symbol (bfd *abfd,
1061                          asymbol *symbol,
1062                          struct internal_syment *isym,
1063                          bfd_vma *written,
1064                          bfd_size_type *string_size_p,
1065                          asection **debug_string_section_p,
1066                          bfd_size_type *debug_string_size_p)
1067 {
1068   combined_entry_type *native;
1069   combined_entry_type dummy[2];
1070   asection *output_section = symbol->section->output_section
1071                                ? symbol->section->output_section
1072                                : symbol->section;
1073   struct bfd_link_info *link_info = coff_data (abfd)->link_info;
1074   bfd_boolean ret;
1075
1076   if ((!link_info || link_info->strip_discarded)
1077       && !bfd_is_abs_section (symbol->section)
1078       && symbol->section->output_section == bfd_abs_section_ptr)
1079     {
1080       symbol->name = "";
1081       if (isym != NULL)
1082         memset (isym, 0, sizeof (*isym));
1083       return TRUE;
1084     }
1085   native = dummy;
1086   native->is_sym = TRUE;
1087   native[1].is_sym = FALSE;
1088   native->u.syment.n_type = T_NULL;
1089   native->u.syment.n_flags = 0;
1090   native->u.syment.n_numaux = 0;
1091   if (bfd_is_und_section (symbol->section))
1092     {
1093       native->u.syment.n_scnum = N_UNDEF;
1094       native->u.syment.n_value = symbol->value;
1095     }
1096   else if (bfd_is_com_section (symbol->section))
1097     {
1098       native->u.syment.n_scnum = N_UNDEF;
1099       native->u.syment.n_value = symbol->value;
1100     }
1101   else if (symbol->flags & BSF_FILE)
1102     {
1103       native->u.syment.n_scnum = N_DEBUG;
1104       native->u.syment.n_numaux = 1;
1105     }
1106   else if (symbol->flags & BSF_DEBUGGING)
1107     {
1108       /* There isn't much point to writing out a debugging symbol
1109          unless we are prepared to convert it into COFF debugging
1110          format.  So, we just ignore them.  We must clobber the symbol
1111          name to keep it from being put in the string table.  */
1112       symbol->name = "";
1113       if (isym != NULL)
1114         memset (isym, 0, sizeof (*isym));
1115       return TRUE;
1116     }
1117   else
1118     {
1119       native->u.syment.n_scnum = output_section->target_index;
1120       native->u.syment.n_value = (symbol->value
1121                                   + symbol->section->output_offset);
1122       if (! obj_pe (abfd))
1123         native->u.syment.n_value += output_section->vma;
1124
1125       /* Copy the any flags from the file header into the symbol.
1126          FIXME: Why?  */
1127       {
1128         coff_symbol_type *c = coff_symbol_from (symbol);
1129         if (c != (coff_symbol_type *) NULL)
1130           native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags;
1131       }
1132     }
1133
1134   native->u.syment.n_type = 0;
1135   if (symbol->flags & BSF_FILE)
1136     native->u.syment.n_sclass = C_FILE;
1137   else if (symbol->flags & BSF_LOCAL)
1138     native->u.syment.n_sclass = C_STAT;
1139   else if (symbol->flags & BSF_WEAK)
1140     native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1141   else
1142     native->u.syment.n_sclass = C_EXT;
1143
1144   ret = coff_write_symbol (abfd, symbol, native, written, string_size_p,
1145                            debug_string_section_p, debug_string_size_p);
1146   if (isym != NULL)
1147     *isym = native->u.syment;
1148   return ret;
1149 }
1150
1151 /* Write a native symbol to a COFF file.  */
1152
1153 static bfd_boolean
1154 coff_write_native_symbol (bfd *abfd,
1155                           coff_symbol_type *symbol,
1156                           bfd_vma *written,
1157                           bfd_size_type *string_size_p,
1158                           asection **debug_string_section_p,
1159                           bfd_size_type *debug_string_size_p)
1160 {
1161   combined_entry_type *native = symbol->native;
1162   alent *lineno = symbol->lineno;
1163   struct bfd_link_info *link_info = coff_data (abfd)->link_info;
1164
1165   if ((!link_info || link_info->strip_discarded)
1166       && !bfd_is_abs_section (symbol->symbol.section)
1167       && symbol->symbol.section->output_section == bfd_abs_section_ptr)
1168     {
1169       symbol->symbol.name = "";
1170       return TRUE;
1171     }
1172
1173   BFD_ASSERT (native->is_sym);
1174   /* If this symbol has an associated line number, we must store the
1175      symbol index in the line number field.  We also tag the auxent to
1176      point to the right place in the lineno table.  */
1177   if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL)
1178     {
1179       unsigned int count = 0;
1180
1181       lineno[count].u.offset = *written;
1182       if (native->u.syment.n_numaux)
1183         {
1184           union internal_auxent *a = &((native + 1)->u.auxent);
1185
1186           a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
1187             symbol->symbol.section->output_section->moving_line_filepos;
1188         }
1189
1190       /* Count and relocate all other linenumbers.  */
1191       count++;
1192       while (lineno[count].line_number != 0)
1193         {
1194           lineno[count].u.offset +=
1195             (symbol->symbol.section->output_section->vma
1196              + symbol->symbol.section->output_offset);
1197           count++;
1198         }
1199       symbol->done_lineno = TRUE;
1200
1201       if (! bfd_is_const_section (symbol->symbol.section->output_section))
1202         symbol->symbol.section->output_section->moving_line_filepos +=
1203           count * bfd_coff_linesz (abfd);
1204     }
1205
1206   return coff_write_symbol (abfd, &(symbol->symbol), native, written,
1207                             string_size_p, debug_string_section_p,
1208                             debug_string_size_p);
1209 }
1210
1211 static void
1212 null_error_handler (const char * fmt ATTRIBUTE_UNUSED, ...)
1213 {
1214 }
1215
1216 /* Write out the COFF symbols.  */
1217
1218 bfd_boolean
1219 coff_write_symbols (bfd *abfd)
1220 {
1221   bfd_size_type string_size;
1222   asection *debug_string_section;
1223   bfd_size_type debug_string_size;
1224   unsigned int i;
1225   unsigned int limit = bfd_get_symcount (abfd);
1226   bfd_vma written = 0;
1227   asymbol **p;
1228
1229   string_size = 0;
1230   debug_string_section = NULL;
1231   debug_string_size = 0;
1232
1233   /* If this target supports long section names, they must be put into
1234      the string table.  This is supported by PE.  This code must
1235      handle section names just as they are handled in
1236      coff_write_object_contents.  */
1237   if (bfd_coff_long_section_names (abfd))
1238     {
1239       asection *o;
1240
1241       for (o = abfd->sections; o != NULL; o = o->next)
1242         {
1243           size_t len;
1244
1245           len = strlen (o->name);
1246           if (len > SCNNMLEN)
1247             string_size += len + 1;
1248         }
1249     }
1250
1251   /* Seek to the right place.  */
1252   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
1253     return FALSE;
1254
1255   /* Output all the symbols we have.  */
1256   written = 0;
1257   for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
1258     {
1259       asymbol *symbol = *p;
1260       coff_symbol_type *c_symbol = coff_symbol_from (symbol);
1261
1262       if (c_symbol == (coff_symbol_type *) NULL
1263           || c_symbol->native == (combined_entry_type *) NULL)
1264         {
1265           if (!coff_write_alien_symbol (abfd, symbol, NULL, &written,
1266                                         &string_size, &debug_string_section,
1267                                         &debug_string_size))
1268             return FALSE;
1269         }
1270       else
1271         {
1272           if (coff_backend_info (abfd)->_bfd_coff_classify_symbol != NULL)
1273             {
1274               bfd_error_handler_type current_error_handler;
1275               enum coff_symbol_classification sym_class;
1276               unsigned char *n_sclass;
1277
1278               /* Suppress error reporting by bfd_coff_classify_symbol.
1279                  Error messages can be generated when we are processing a local
1280                  symbol which has no associated section and we do not have to
1281                  worry about this, all we need to know is that it is local.  */
1282               current_error_handler = bfd_set_error_handler (null_error_handler);
1283               BFD_ASSERT (c_symbol->native->is_sym);
1284               sym_class = bfd_coff_classify_symbol (abfd,
1285                                                     &c_symbol->native->u.syment);
1286               (void) bfd_set_error_handler (current_error_handler);
1287
1288               n_sclass = &c_symbol->native->u.syment.n_sclass;
1289
1290               /* If the symbol class has been changed (eg objcopy/ld script/etc)
1291                  we cannot retain the existing sclass from the original symbol.
1292                  Weak symbols only have one valid sclass, so just set it always.
1293                  If it is not local class and should be, set it C_STAT.
1294                  If it is global and not classified as global, or if it is
1295                  weak (which is also classified as global), set it C_EXT.  */
1296
1297               if (symbol->flags & BSF_WEAK)
1298                 *n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1299               else if (symbol->flags & BSF_LOCAL && sym_class != COFF_SYMBOL_LOCAL)
1300                 *n_sclass = C_STAT;
1301               else if (symbol->flags & BSF_GLOBAL
1302                        && (sym_class != COFF_SYMBOL_GLOBAL
1303 #ifdef COFF_WITH_PE
1304                            || *n_sclass == C_NT_WEAK
1305 #endif
1306                            || *n_sclass == C_WEAKEXT))
1307                 c_symbol->native->u.syment.n_sclass = C_EXT;
1308             }
1309
1310           if (!coff_write_native_symbol (abfd, c_symbol, &written,
1311                                          &string_size, &debug_string_section,
1312                                          &debug_string_size))
1313             return FALSE;
1314         }
1315     }
1316
1317   obj_raw_syment_count (abfd) = written;
1318
1319   /* Now write out strings.  */
1320   if (string_size != 0)
1321     {
1322       unsigned int size = string_size + STRING_SIZE_SIZE;
1323       bfd_byte buffer[STRING_SIZE_SIZE];
1324
1325 #if STRING_SIZE_SIZE == 4
1326       H_PUT_32 (abfd, size, buffer);
1327 #else
1328  #error Change H_PUT_32
1329 #endif
1330       if (bfd_bwrite ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd)
1331           != sizeof (buffer))
1332         return FALSE;
1333
1334       /* Handle long section names.  This code must handle section
1335          names just as they are handled in coff_write_object_contents.  */
1336       if (bfd_coff_long_section_names (abfd))
1337         {
1338           asection *o;
1339
1340           for (o = abfd->sections; o != NULL; o = o->next)
1341             {
1342               size_t len;
1343
1344               len = strlen (o->name);
1345               if (len > SCNNMLEN)
1346                 {
1347                   if (bfd_bwrite (o->name, (bfd_size_type) (len + 1), abfd)
1348                       != len + 1)
1349                     return FALSE;
1350                 }
1351             }
1352         }
1353
1354       for (p = abfd->outsymbols, i = 0;
1355            i < limit;
1356            i++, p++)
1357         {
1358           asymbol *q = *p;
1359           size_t name_length = strlen (q->name);
1360           coff_symbol_type *c_symbol = coff_symbol_from (q);
1361           size_t maxlen;
1362
1363           /* Figure out whether the symbol name should go in the string
1364              table.  Symbol names that are short enough are stored
1365              directly in the syment structure.  File names permit a
1366              different, longer, length in the syment structure.  On
1367              XCOFF, some symbol names are stored in the .debug section
1368              rather than in the string table.  */
1369
1370           if (c_symbol == NULL
1371               || c_symbol->native == NULL)
1372             /* This is not a COFF symbol, so it certainly is not a
1373                file name, nor does it go in the .debug section.  */
1374             maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1375
1376           else if (! c_symbol->native->is_sym)
1377             maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1378
1379           else if (bfd_coff_symname_in_debug (abfd,
1380                                               &c_symbol->native->u.syment))
1381             /* This symbol name is in the XCOFF .debug section.
1382                Don't write it into the string table.  */
1383             maxlen = name_length;
1384
1385           else if (c_symbol->native->u.syment.n_sclass == C_FILE
1386                    && c_symbol->native->u.syment.n_numaux > 0)
1387             {
1388               if (bfd_coff_force_symnames_in_strings (abfd))
1389                 {
1390                   if (bfd_bwrite (".file", (bfd_size_type) 6, abfd) != 6)
1391                     return FALSE;
1392                 }
1393               maxlen = bfd_coff_filnmlen (abfd);
1394             }
1395           else
1396             maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1397
1398           if (name_length > maxlen)
1399             {
1400               if (bfd_bwrite ((void *) (q->name), (bfd_size_type) name_length + 1,
1401                              abfd) != name_length + 1)
1402                 return FALSE;
1403             }
1404         }
1405     }
1406   else
1407     {
1408       /* We would normally not write anything here, but we'll write
1409          out 4 so that any stupid coff reader which tries to read the
1410          string table even when there isn't one won't croak.  */
1411       unsigned int size = STRING_SIZE_SIZE;
1412       bfd_byte buffer[STRING_SIZE_SIZE];
1413
1414 #if STRING_SIZE_SIZE == 4
1415       H_PUT_32 (abfd, size, buffer);
1416 #else
1417  #error Change H_PUT_32
1418 #endif
1419       if (bfd_bwrite ((void *) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd)
1420           != STRING_SIZE_SIZE)
1421         return FALSE;
1422     }
1423
1424   /* Make sure the .debug section was created to be the correct size.
1425      We should create it ourselves on the fly, but we don't because
1426      BFD won't let us write to any section until we know how large all
1427      the sections are.  We could still do it by making another pass
1428      over the symbols.  FIXME.  */
1429   BFD_ASSERT (debug_string_size == 0
1430               || (debug_string_section != (asection *) NULL
1431                   && (BFD_ALIGN (debug_string_size,
1432                                  1 << debug_string_section->alignment_power)
1433                       == debug_string_section->size)));
1434
1435   return TRUE;
1436 }
1437
1438 bfd_boolean
1439 coff_write_linenumbers (bfd *abfd)
1440 {
1441   asection *s;
1442   bfd_size_type linesz;
1443   void * buff;
1444
1445   linesz = bfd_coff_linesz (abfd);
1446   buff = bfd_alloc (abfd, linesz);
1447   if (!buff)
1448     return FALSE;
1449   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1450     {
1451       if (s->lineno_count)
1452         {
1453           asymbol **q = abfd->outsymbols;
1454           if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
1455             return FALSE;
1456           /* Find all the linenumbers in this section.  */
1457           while (*q)
1458             {
1459               asymbol *p = *q;
1460               if (p->section->output_section == s)
1461                 {
1462                   alent *l =
1463                   BFD_SEND (bfd_asymbol_bfd (p), _get_lineno,
1464                             (bfd_asymbol_bfd (p), p));
1465                   if (l)
1466                     {
1467                       /* Found a linenumber entry, output.  */
1468                       struct internal_lineno out;
1469
1470                       memset ((void *) & out, 0, sizeof (out));
1471                       out.l_lnno = 0;
1472                       out.l_addr.l_symndx = l->u.offset;
1473                       bfd_coff_swap_lineno_out (abfd, &out, buff);
1474                       if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
1475                           != linesz)
1476                         return FALSE;
1477                       l++;
1478                       while (l->line_number)
1479                         {
1480                           out.l_lnno = l->line_number;
1481                           out.l_addr.l_symndx = l->u.offset;
1482                           bfd_coff_swap_lineno_out (abfd, &out, buff);
1483                           if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
1484                               != linesz)
1485                             return FALSE;
1486                           l++;
1487                         }
1488                     }
1489                 }
1490               q++;
1491             }
1492         }
1493     }
1494   bfd_release (abfd, buff);
1495   return TRUE;
1496 }
1497
1498 alent *
1499 coff_get_lineno (bfd *ignore_abfd ATTRIBUTE_UNUSED, asymbol *symbol)
1500 {
1501   return coffsymbol (symbol)->lineno;
1502 }
1503
1504 /* This function transforms the offsets into the symbol table into
1505    pointers to syments.  */
1506
1507 static void
1508 coff_pointerize_aux (bfd *abfd,
1509                      combined_entry_type *table_base,
1510                      combined_entry_type *symbol,
1511                      unsigned int indaux,
1512                      combined_entry_type *auxent)
1513 {
1514   unsigned int type = symbol->u.syment.n_type;
1515   unsigned int n_sclass = symbol->u.syment.n_sclass;
1516
1517   BFD_ASSERT (symbol->is_sym);
1518   if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1519     {
1520       if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1521           (abfd, table_base, symbol, indaux, auxent))
1522         return;
1523     }
1524
1525   /* Don't bother if this is a file or a section.  */
1526   if (n_sclass == C_STAT && type == T_NULL)
1527     return;
1528   if (n_sclass == C_FILE)
1529     return;
1530
1531   BFD_ASSERT (! auxent->is_sym);
1532   /* Otherwise patch up.  */
1533 #define N_TMASK coff_data  (abfd)->local_n_tmask
1534 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1535
1536   if ((ISFCN (type) || ISTAG (n_sclass) || n_sclass == C_BLOCK
1537        || n_sclass == C_FCN)
1538       && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0)
1539     {
1540       auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
1541         table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
1542       auxent->fix_end = 1;
1543     }
1544   /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1545      generate one, so we must be careful to ignore it.  */
1546   if (auxent->u.auxent.x_sym.x_tagndx.l > 0)
1547     {
1548       auxent->u.auxent.x_sym.x_tagndx.p =
1549         table_base + auxent->u.auxent.x_sym.x_tagndx.l;
1550       auxent->fix_tag = 1;
1551     }
1552 }
1553
1554 /* Allocate space for the ".debug" section, and read it.
1555    We did not read the debug section until now, because
1556    we didn't want to go to the trouble until someone needed it.  */
1557
1558 static char *
1559 build_debug_section (bfd *abfd, asection ** sect_return)
1560 {
1561   char *debug_section;
1562   file_ptr position;
1563   bfd_size_type sec_size;
1564
1565   asection *sect = bfd_get_section_by_name (abfd, ".debug");
1566
1567   if (!sect)
1568     {
1569       bfd_set_error (bfd_error_no_debug_section);
1570       return NULL;
1571     }
1572
1573   sec_size = sect->size;
1574   debug_section = (char *) bfd_alloc (abfd, sec_size);
1575   if (debug_section == NULL)
1576     return NULL;
1577
1578   /* Seek to the beginning of the `.debug' section and read it.
1579      Save the current position first; it is needed by our caller.
1580      Then read debug section and reset the file pointer.  */
1581
1582   position = bfd_tell (abfd);
1583   if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
1584       || bfd_bread (debug_section, sec_size, abfd) != sec_size
1585       || bfd_seek (abfd, position, SEEK_SET) != 0)
1586     return NULL;
1587
1588   * sect_return = sect;
1589   return debug_section;
1590 }
1591
1592 /* Return a pointer to a malloc'd copy of 'name'.  'name' may not be
1593    \0-terminated, but will not exceed 'maxlen' characters.  The copy *will*
1594    be \0-terminated.  */
1595
1596 static char *
1597 copy_name (bfd *abfd, char *name, size_t maxlen)
1598 {
1599   size_t len;
1600   char *newname;
1601
1602   for (len = 0; len < maxlen; ++len)
1603     if (name[len] == '\0')
1604       break;
1605
1606   if ((newname = (char *) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
1607     return NULL;
1608
1609   strncpy (newname, name, len);
1610   newname[len] = '\0';
1611   return newname;
1612 }
1613
1614 /* Read in the external symbols.  */
1615
1616 bfd_boolean
1617 _bfd_coff_get_external_symbols (bfd *abfd)
1618 {
1619   bfd_size_type symesz;
1620   bfd_size_type size;
1621   void * syms;
1622
1623   if (obj_coff_external_syms (abfd) != NULL)
1624     return TRUE;
1625
1626   symesz = bfd_coff_symesz (abfd);
1627
1628   size = obj_raw_syment_count (abfd) * symesz;
1629   if (size == 0)
1630     return TRUE;
1631
1632   syms = bfd_malloc (size);
1633   if (syms == NULL)
1634     return FALSE;
1635
1636   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1637       || bfd_bread (syms, size, abfd) != size)
1638     {
1639       if (syms != NULL)
1640         free (syms);
1641       return FALSE;
1642     }
1643
1644   obj_coff_external_syms (abfd) = syms;
1645
1646   return TRUE;
1647 }
1648
1649 /* Read in the external strings.  The strings are not loaded until
1650    they are needed.  This is because we have no simple way of
1651    detecting a missing string table in an archive.  If the strings
1652    are loaded then the STRINGS and STRINGS_LEN fields in the
1653    coff_tdata structure will be set.  */
1654
1655 const char *
1656 _bfd_coff_read_string_table (bfd *abfd)
1657 {
1658   char extstrsize[STRING_SIZE_SIZE];
1659   bfd_size_type strsize;
1660   char *strings;
1661   file_ptr pos;
1662
1663   if (obj_coff_strings (abfd) != NULL)
1664     return obj_coff_strings (abfd);
1665
1666   if (obj_sym_filepos (abfd) == 0)
1667     {
1668       bfd_set_error (bfd_error_no_symbols);
1669       return NULL;
1670     }
1671
1672   pos = obj_sym_filepos (abfd);
1673   pos += obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
1674   if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1675     return NULL;
1676
1677   if (bfd_bread (extstrsize, (bfd_size_type) sizeof extstrsize, abfd)
1678       != sizeof extstrsize)
1679     {
1680       if (bfd_get_error () != bfd_error_file_truncated)
1681         return NULL;
1682
1683       /* There is no string table.  */
1684       strsize = STRING_SIZE_SIZE;
1685     }
1686   else
1687     {
1688 #if STRING_SIZE_SIZE == 4
1689       strsize = H_GET_32 (abfd, extstrsize);
1690 #else
1691  #error Change H_GET_32
1692 #endif
1693     }
1694
1695   if (strsize < STRING_SIZE_SIZE)
1696     {
1697       (*_bfd_error_handler)
1698         (_("%B: bad string table size %lu"), abfd, (unsigned long) strsize);
1699       bfd_set_error (bfd_error_bad_value);
1700       return NULL;
1701     }
1702
1703   strings = (char *) bfd_malloc (strsize + 1);
1704   if (strings == NULL)
1705     return NULL;
1706
1707   /* PR 17521 file: 079-54929-0.004.
1708      A corrupt file could contain an index that points into the first
1709      STRING_SIZE_SIZE bytes of the string table, so make sure that
1710      they are zero.  */
1711   memset (strings, 0, STRING_SIZE_SIZE);
1712
1713   if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
1714       != strsize - STRING_SIZE_SIZE)
1715     {
1716       free (strings);
1717       return NULL;
1718     }
1719
1720   obj_coff_strings (abfd) = strings;
1721   obj_coff_strings_len (abfd) = strsize;
1722   /* Terminate the string table, just in case.  */
1723   strings[strsize] = 0;
1724   return strings;
1725 }
1726
1727 /* Free up the external symbols and strings read from a COFF file.  */
1728
1729 bfd_boolean
1730 _bfd_coff_free_symbols (bfd *abfd)
1731 {
1732   if (obj_coff_external_syms (abfd) != NULL
1733       && ! obj_coff_keep_syms (abfd))
1734     {
1735       free (obj_coff_external_syms (abfd));
1736       obj_coff_external_syms (abfd) = NULL;
1737     }
1738   if (obj_coff_strings (abfd) != NULL
1739       && ! obj_coff_keep_strings (abfd))
1740     {
1741       free (obj_coff_strings (abfd));
1742       obj_coff_strings (abfd) = NULL;
1743       obj_coff_strings_len (abfd) = 0;
1744     }
1745   return TRUE;
1746 }
1747
1748 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1749    knit the symbol names into a normalized form.  By normalized here I
1750    mean that all symbols have an n_offset pointer that points to a null-
1751    terminated string.  */
1752
1753 combined_entry_type *
1754 coff_get_normalized_symtab (bfd *abfd)
1755 {
1756   combined_entry_type *internal;
1757   combined_entry_type *internal_ptr;
1758   combined_entry_type *symbol_ptr;
1759   combined_entry_type *internal_end;
1760   size_t symesz;
1761   char *raw_src;
1762   char *raw_end;
1763   const char *string_table = NULL;
1764   asection * debug_sec = NULL;
1765   char *debug_sec_data = NULL;
1766   bfd_size_type size;
1767
1768   if (obj_raw_syments (abfd) != NULL)
1769     return obj_raw_syments (abfd);
1770
1771   if (! _bfd_coff_get_external_symbols (abfd))
1772     return NULL;
1773
1774   size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
1775   internal = (combined_entry_type *) bfd_zalloc (abfd, size);
1776   if (internal == NULL && size != 0)
1777     return NULL;
1778   internal_end = internal + obj_raw_syment_count (abfd);
1779
1780   raw_src = (char *) obj_coff_external_syms (abfd);
1781
1782   /* Mark the end of the symbols.  */
1783   symesz = bfd_coff_symesz (abfd);
1784   raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz;
1785
1786   /* FIXME SOMEDAY.  A string table size of zero is very weird, but
1787      probably possible.  If one shows up, it will probably kill us.  */
1788
1789   /* Swap all the raw entries.  */
1790   for (internal_ptr = internal;
1791        raw_src < raw_end;
1792        raw_src += symesz, internal_ptr++)
1793     {
1794       unsigned int i;
1795
1796       bfd_coff_swap_sym_in (abfd, (void *) raw_src,
1797                             (void *) & internal_ptr->u.syment);
1798       symbol_ptr = internal_ptr;
1799       internal_ptr->is_sym = TRUE;
1800
1801       /* PR 17512: file: 1353-1166-0.004.  */
1802       if (symbol_ptr->u.syment.n_sclass == C_FILE
1803           && symbol_ptr->u.syment.n_numaux > 0
1804           && raw_src + symesz + symbol_ptr->u.syment.n_numaux
1805           * sizeof (union internal_auxent) >= raw_end)
1806         {
1807           bfd_release (abfd, internal);
1808           return NULL;
1809         }
1810
1811       for (i = 0;
1812            i < symbol_ptr->u.syment.n_numaux;
1813            i++)
1814         {
1815           internal_ptr++;
1816           /* PR 17512: Prevent buffer overrun.  */
1817           if (internal_ptr >= internal_end)
1818             {
1819               bfd_release (abfd, internal);
1820               return NULL;
1821             }
1822
1823           raw_src += symesz;
1824
1825           bfd_coff_swap_aux_in (abfd, (void *) raw_src,
1826                                 symbol_ptr->u.syment.n_type,
1827                                 symbol_ptr->u.syment.n_sclass,
1828                                 (int) i, symbol_ptr->u.syment.n_numaux,
1829                                 &(internal_ptr->u.auxent));
1830
1831           internal_ptr->is_sym = FALSE;
1832           coff_pointerize_aux (abfd, internal, symbol_ptr, i,
1833                                internal_ptr);
1834         }
1835     }
1836
1837   /* Free the raw symbols, but not the strings (if we have them).  */
1838   obj_coff_keep_strings (abfd) = TRUE;
1839   if (! _bfd_coff_free_symbols (abfd))
1840     return NULL;
1841
1842   for (internal_ptr = internal; internal_ptr < internal_end;
1843        internal_ptr++)
1844     {
1845       BFD_ASSERT (internal_ptr->is_sym);
1846
1847       if (internal_ptr->u.syment.n_sclass == C_FILE
1848           && internal_ptr->u.syment.n_numaux > 0)
1849         {
1850           combined_entry_type * aux = internal_ptr + 1;
1851
1852           /* Make a file symbol point to the name in the auxent, since
1853              the text ".file" is redundant.  */
1854           BFD_ASSERT (! aux->is_sym);
1855
1856           if (aux->u.auxent.x_file.x_n.x_zeroes == 0)
1857             {
1858               /* The filename is a long one, point into the string table.  */
1859               if (string_table == NULL)
1860                 {
1861                   string_table = _bfd_coff_read_string_table (abfd);
1862                   if (string_table == NULL)
1863                     return NULL;
1864                 }
1865
1866               if ((bfd_size_type)(aux->u.auxent.x_file.x_n.x_offset)
1867                   >= obj_coff_strings_len (abfd))
1868                 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
1869               else
1870                 internal_ptr->u.syment._n._n_n._n_offset =
1871                   (bfd_hostptr_t) (string_table + (aux->u.auxent.x_file.x_n.x_offset));
1872             }
1873           else
1874             {
1875               /* Ordinary short filename, put into memory anyway.  The
1876                  Microsoft PE tools sometimes store a filename in
1877                  multiple AUX entries.  */
1878               if (internal_ptr->u.syment.n_numaux > 1
1879                   && coff_data (abfd)->pe)
1880                 internal_ptr->u.syment._n._n_n._n_offset =
1881                   (bfd_hostptr_t)
1882                   copy_name (abfd,
1883                              aux->u.auxent.x_file.x_fname,
1884                              internal_ptr->u.syment.n_numaux * symesz);
1885               else
1886                 internal_ptr->u.syment._n._n_n._n_offset =
1887                   ((bfd_hostptr_t)
1888                    copy_name (abfd,
1889                               aux->u.auxent.x_file.x_fname,
1890                               (size_t) bfd_coff_filnmlen (abfd)));
1891             }
1892         }
1893       else
1894         {
1895           if (internal_ptr->u.syment._n._n_n._n_zeroes != 0)
1896             {
1897               /* This is a "short" name.  Make it long.  */
1898               size_t i;
1899               char *newstring;
1900
1901               /* Find the length of this string without walking into memory
1902                  that isn't ours.  */
1903               for (i = 0; i < 8; ++i)
1904                 if (internal_ptr->u.syment._n._n_name[i] == '\0')
1905                   break;
1906
1907               newstring = (char *) bfd_zalloc (abfd, (bfd_size_type) (i + 1));
1908               if (newstring == NULL)
1909                 return NULL;
1910               strncpy (newstring, internal_ptr->u.syment._n._n_name, i);
1911               internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) newstring;
1912               internal_ptr->u.syment._n._n_n._n_zeroes = 0;
1913             }
1914           else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
1915             internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) "";
1916           else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment))
1917             {
1918               /* Long name already.  Point symbol at the string in the
1919                  table.  */
1920               if (string_table == NULL)
1921                 {
1922                   string_table = _bfd_coff_read_string_table (abfd);
1923                   if (string_table == NULL)
1924                     return NULL;
1925                 }
1926               if (internal_ptr->u.syment._n._n_n._n_offset >= obj_coff_strings_len (abfd)
1927                   || string_table + internal_ptr->u.syment._n._n_n._n_offset < string_table)
1928                 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
1929               else
1930                 internal_ptr->u.syment._n._n_n._n_offset =
1931                   ((bfd_hostptr_t)
1932                    (string_table
1933                     + internal_ptr->u.syment._n._n_n._n_offset));
1934             }
1935           else
1936             {
1937               /* Long name in debug section.  Very similar.  */
1938               if (debug_sec_data == NULL)
1939                 debug_sec_data = build_debug_section (abfd, & debug_sec);
1940               if (debug_sec_data != NULL)
1941                 {
1942                   BFD_ASSERT (debug_sec != NULL);
1943                   /* PR binutils/17512: Catch out of range offsets into the debug data.  */
1944                   if (internal_ptr->u.syment._n._n_n._n_offset > debug_sec->size
1945                       || debug_sec_data + internal_ptr->u.syment._n._n_n._n_offset < debug_sec_data)
1946                     internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
1947                   else
1948                     internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t)
1949                       (debug_sec_data + internal_ptr->u.syment._n._n_n._n_offset);
1950                 }
1951               else
1952                 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) "";
1953             }
1954         }
1955       internal_ptr += internal_ptr->u.syment.n_numaux;
1956     }
1957
1958   obj_raw_syments (abfd) = internal;
1959   BFD_ASSERT (obj_raw_syment_count (abfd)
1960               == (unsigned int) (internal_ptr - internal));
1961
1962   return internal;
1963 }
1964
1965 long
1966 coff_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
1967 {
1968   if (bfd_get_format (abfd) != bfd_object)
1969     {
1970       bfd_set_error (bfd_error_invalid_operation);
1971       return -1;
1972     }
1973   return (asect->reloc_count + 1) * sizeof (arelent *);
1974 }
1975
1976 asymbol *
1977 coff_make_empty_symbol (bfd *abfd)
1978 {
1979   bfd_size_type amt = sizeof (coff_symbol_type);
1980   coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_zalloc (abfd, amt);
1981
1982   if (new_symbol == NULL)
1983     return NULL;
1984   new_symbol->symbol.section = 0;
1985   new_symbol->native = NULL;
1986   new_symbol->lineno = NULL;
1987   new_symbol->done_lineno = FALSE;
1988   new_symbol->symbol.the_bfd = abfd;
1989
1990   return & new_symbol->symbol;
1991 }
1992
1993 /* Make a debugging symbol.  */
1994
1995 asymbol *
1996 coff_bfd_make_debug_symbol (bfd *abfd,
1997                             void * ptr ATTRIBUTE_UNUSED,
1998                             unsigned long sz ATTRIBUTE_UNUSED)
1999 {
2000   bfd_size_type amt = sizeof (coff_symbol_type);
2001   coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_alloc (abfd, amt);
2002
2003   if (new_symbol == NULL)
2004     return NULL;
2005   /* @@ The 10 is a guess at a plausible maximum number of aux entries
2006      (but shouldn't be a constant).  */
2007   amt = sizeof (combined_entry_type) * 10;
2008   new_symbol->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
2009   if (!new_symbol->native)
2010     return NULL;
2011   new_symbol->native->is_sym = TRUE;
2012   new_symbol->symbol.section = bfd_abs_section_ptr;
2013   new_symbol->symbol.flags = BSF_DEBUGGING;
2014   new_symbol->lineno = NULL;
2015   new_symbol->done_lineno = FALSE;
2016   new_symbol->symbol.the_bfd = abfd;
2017
2018   return & new_symbol->symbol;
2019 }
2020
2021 void
2022 coff_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret)
2023 {
2024   bfd_symbol_info (symbol, ret);
2025
2026   if (coffsymbol (symbol)->native != NULL
2027       && coffsymbol (symbol)->native->fix_value
2028       && coffsymbol (symbol)->native->is_sym)
2029     ret->value = coffsymbol (symbol)->native->u.syment.n_value -
2030       (bfd_hostptr_t) obj_raw_syments (abfd);
2031 }
2032
2033 /* Print out information about COFF symbol.  */
2034
2035 void
2036 coff_print_symbol (bfd *abfd,
2037                    void * filep,
2038                    asymbol *symbol,
2039                    bfd_print_symbol_type how)
2040 {
2041   FILE * file = (FILE *) filep;
2042
2043   switch (how)
2044     {
2045     case bfd_print_symbol_name:
2046       fprintf (file, "%s", symbol->name);
2047       break;
2048
2049     case bfd_print_symbol_more:
2050       fprintf (file, "coff %s %s",
2051                coffsymbol (symbol)->native ? "n" : "g",
2052                coffsymbol (symbol)->lineno ? "l" : " ");
2053       break;
2054
2055     case bfd_print_symbol_all:
2056       if (coffsymbol (symbol)->native)
2057         {
2058           bfd_vma val;
2059           unsigned int aux;
2060           combined_entry_type *combined = coffsymbol (symbol)->native;
2061           combined_entry_type *root = obj_raw_syments (abfd);
2062           struct lineno_cache_entry *l = coffsymbol (symbol)->lineno;
2063
2064           fprintf (file, "[%3ld]", (long) (combined - root));
2065
2066           /* PR 17512: file: 079-33786-0.001:0.1.  */
2067           if (combined < obj_raw_syments (abfd)
2068               || combined >= obj_raw_syments (abfd) + obj_raw_syment_count (abfd))
2069             {
2070               fprintf (file, _("<corrupt info> %s"), symbol->name);
2071               break;
2072             }
2073
2074           BFD_ASSERT (combined->is_sym);
2075           if (! combined->fix_value)
2076             val = (bfd_vma) combined->u.syment.n_value;
2077           else
2078             val = combined->u.syment.n_value - (bfd_hostptr_t) root;
2079
2080           fprintf (file, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2081                    combined->u.syment.n_scnum,
2082                    combined->u.syment.n_flags,
2083                    combined->u.syment.n_type,
2084                    combined->u.syment.n_sclass,
2085                    combined->u.syment.n_numaux);
2086           bfd_fprintf_vma (abfd, file, val);
2087           fprintf (file, " %s", symbol->name);
2088
2089           for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
2090             {
2091               combined_entry_type *auxp = combined + aux + 1;
2092               long tagndx;
2093
2094               BFD_ASSERT (! auxp->is_sym);
2095               if (auxp->fix_tag)
2096                 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
2097               else
2098                 tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
2099
2100               fprintf (file, "\n");
2101
2102               if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux))
2103                 continue;
2104
2105               switch (combined->u.syment.n_sclass)
2106                 {
2107                 case C_FILE:
2108                   fprintf (file, "File ");
2109                   break;
2110
2111                 case C_STAT:
2112                   if (combined->u.syment.n_type == T_NULL)
2113                     /* Probably a section symbol ?  */
2114                     {
2115                       fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2116                                (unsigned long) auxp->u.auxent.x_scn.x_scnlen,
2117                                auxp->u.auxent.x_scn.x_nreloc,
2118                                auxp->u.auxent.x_scn.x_nlinno);
2119                       if (auxp->u.auxent.x_scn.x_checksum != 0
2120                           || auxp->u.auxent.x_scn.x_associated != 0
2121                           || auxp->u.auxent.x_scn.x_comdat != 0)
2122                         fprintf (file, " checksum 0x%lx assoc %d comdat %d",
2123                                  auxp->u.auxent.x_scn.x_checksum,
2124                                  auxp->u.auxent.x_scn.x_associated,
2125                                  auxp->u.auxent.x_scn.x_comdat);
2126                       break;
2127                     }
2128                     /* Otherwise fall through.  */
2129                 case C_EXT:
2130                 case C_AIX_WEAKEXT:
2131                   if (ISFCN (combined->u.syment.n_type))
2132                     {
2133                       long next, llnos;
2134
2135                       if (auxp->fix_end)
2136                         next = (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2137                                - root);
2138                       else
2139                         next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
2140                       llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr;
2141                       fprintf (file,
2142                                "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2143                                tagndx,
2144                                (unsigned long) auxp->u.auxent.x_sym.x_misc.x_fsize,
2145                                llnos, next);
2146                       break;
2147                     }
2148                   /* Otherwise fall through.  */
2149                 default:
2150                   fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
2151                            auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
2152                            auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
2153                            tagndx);
2154                   if (auxp->fix_end)
2155                     fprintf (file, " endndx %ld",
2156                              ((long)
2157                               (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2158                                - root)));
2159                   break;
2160                 }
2161             }
2162
2163           if (l)
2164             {
2165               fprintf (file, "\n%s :", l->u.sym->name);
2166               l++;
2167               while (l->line_number)
2168                 {
2169                   if (l->line_number > 0)
2170                     {
2171                       fprintf (file, "\n%4d : ", l->line_number);
2172                       bfd_fprintf_vma (abfd, file, l->u.offset + symbol->section->vma);
2173                     }
2174                   l++;
2175                 }
2176             }
2177         }
2178       else
2179         {
2180           bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2181           fprintf (file, " %-5s %s %s %s",
2182                    symbol->section->name,
2183                    coffsymbol (symbol)->native ? "n" : "g",
2184                    coffsymbol (symbol)->lineno ? "l" : " ",
2185                    symbol->name);
2186         }
2187     }
2188 }
2189
2190 /* Return whether a symbol name implies a local symbol.  In COFF,
2191    local symbols generally start with ``.L''.  Most targets use this
2192    function for the is_local_label_name entry point, but some may
2193    override it.  */
2194
2195 bfd_boolean
2196 _bfd_coff_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
2197                                const char *name)
2198 {
2199   return name[0] == '.' && name[1] == 'L';
2200 }
2201
2202 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2203    section, calculate and return the name of the source file and the line
2204    nearest to the wanted location.  */
2205
2206 bfd_boolean
2207 coff_find_nearest_line_with_names (bfd *abfd,
2208                                    asymbol **symbols,
2209                                    asection *section,
2210                                    bfd_vma offset,
2211                                    const char **filename_ptr,
2212                                    const char **functionname_ptr,
2213                                    unsigned int *line_ptr,
2214                                    const struct dwarf_debug_section *debug_sections)
2215 {
2216   bfd_boolean found;
2217   unsigned int i;
2218   unsigned int line_base;
2219   coff_data_type *cof = coff_data (abfd);
2220   /* Run through the raw syments if available.  */
2221   combined_entry_type *p;
2222   combined_entry_type *pend;
2223   alent *l;
2224   struct coff_section_tdata *sec_data;
2225   bfd_size_type amt;
2226
2227   /* Before looking through the symbol table, try to use a .stab
2228      section to find the information.  */
2229   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2230                                              &found, filename_ptr,
2231                                              functionname_ptr, line_ptr,
2232                                              &coff_data(abfd)->line_info))
2233     return FALSE;
2234
2235   if (found)
2236     return TRUE;
2237
2238   /* Also try examining DWARF2 debugging information.  */
2239   if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
2240                                      filename_ptr, functionname_ptr,
2241                                      line_ptr, NULL, debug_sections, 0,
2242                                      &coff_data(abfd)->dwarf2_find_line_info))
2243     return TRUE;
2244
2245   *filename_ptr = 0;
2246   *functionname_ptr = 0;
2247   *line_ptr = 0;
2248
2249   /* Don't try and find line numbers in a non coff file.  */
2250   if (!bfd_family_coff (abfd))
2251     return FALSE;
2252
2253   if (cof == NULL)
2254     return FALSE;
2255
2256   /* Find the first C_FILE symbol.  */
2257   p = cof->raw_syments;
2258   if (!p)
2259     return FALSE;
2260
2261   pend = p + cof->raw_syment_count;
2262   while (p < pend)
2263     {
2264       BFD_ASSERT (p->is_sym);
2265       if (p->u.syment.n_sclass == C_FILE)
2266         break;
2267       p += 1 + p->u.syment.n_numaux;
2268     }
2269
2270   if (p < pend)
2271     {
2272       bfd_vma sec_vma;
2273       bfd_vma maxdiff;
2274
2275       /* Look through the C_FILE symbols to find the best one.  */
2276       sec_vma = bfd_get_section_vma (abfd, section);
2277       *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2278       maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
2279       while (1)
2280         {
2281           bfd_vma file_addr;
2282           combined_entry_type *p2;
2283
2284           for (p2 = p + 1 + p->u.syment.n_numaux;
2285                p2 < pend;
2286                p2 += 1 + p2->u.syment.n_numaux)
2287             {
2288               BFD_ASSERT (p2->is_sym);
2289               if (p2->u.syment.n_scnum > 0
2290                   && (section
2291                       == coff_section_from_bfd_index (abfd,
2292                                                       p2->u.syment.n_scnum)))
2293                 break;
2294               if (p2->u.syment.n_sclass == C_FILE)
2295                 {
2296                   p2 = pend;
2297                   break;
2298                 }
2299             }
2300           if (p2 >= pend)
2301             break;
2302
2303           file_addr = (bfd_vma) p2->u.syment.n_value;
2304           /* PR 11512: Include the section address of the function name symbol.  */
2305           if (p2->u.syment.n_scnum > 0)
2306             file_addr += coff_section_from_bfd_index (abfd,
2307                                                       p2->u.syment.n_scnum)->vma;
2308           /* We use <= MAXDIFF here so that if we get a zero length
2309              file, we actually use the next file entry.  */
2310           if (p2 < pend
2311               && offset + sec_vma >= file_addr
2312               && offset + sec_vma - file_addr <= maxdiff)
2313             {
2314               *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2315               maxdiff = offset + sec_vma - p2->u.syment.n_value;
2316             }
2317
2318           /* Avoid endless loops on erroneous files by ensuring that
2319              we always move forward in the file.  */
2320           if (p >= cof->raw_syments + p->u.syment.n_value)
2321             break;
2322
2323           p = cof->raw_syments + p->u.syment.n_value;
2324           if (p > pend || p->u.syment.n_sclass != C_FILE)
2325             break;
2326         }
2327     }
2328
2329   /* Now wander though the raw linenumbers of the section.  */
2330   /* If we have been called on this section before, and the offset we
2331      want is further down then we can prime the lookup loop.  */
2332   sec_data = coff_section_data (abfd, section);
2333   if (sec_data != NULL
2334       && sec_data->i > 0
2335       && offset >= sec_data->offset)
2336     {
2337       i = sec_data->i;
2338       *functionname_ptr = sec_data->function;
2339       line_base = sec_data->line_base;
2340     }
2341   else
2342     {
2343       i = 0;
2344       line_base = 0;
2345     }
2346
2347   if (section->lineno != NULL)
2348     {
2349       bfd_vma last_value = 0;
2350
2351       l = &section->lineno[i];
2352
2353       for (; i < section->lineno_count; i++)
2354         {
2355           if (l->line_number == 0)
2356             {
2357               /* Get the symbol this line number points at.  */
2358               coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
2359               if (coff->symbol.value > offset)
2360                 break;
2361               *functionname_ptr = coff->symbol.name;
2362               last_value = coff->symbol.value;
2363               if (coff->native)
2364                 {
2365                   combined_entry_type *s = coff->native;
2366
2367                   BFD_ASSERT (s->is_sym);
2368                   s = s + 1 + s->u.syment.n_numaux;
2369
2370                   /* In XCOFF a debugging symbol can follow the
2371                      function symbol.  */
2372                   if (s->u.syment.n_scnum == N_DEBUG)
2373                     s = s + 1 + s->u.syment.n_numaux;
2374
2375                   /* S should now point to the .bf of the function.  */
2376                   if (s->u.syment.n_numaux)
2377                     {
2378                       /* The linenumber is stored in the auxent.  */
2379                       union internal_auxent *a = &((s + 1)->u.auxent);
2380
2381                       line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
2382                       *line_ptr = line_base;
2383                     }
2384                 }
2385             }
2386           else
2387             {
2388               if (l->u.offset > offset)
2389                 break;
2390               *line_ptr = l->line_number + line_base - 1;
2391             }
2392           l++;
2393         }
2394
2395       /* If we fell off the end of the loop, then assume that this
2396          symbol has no line number info.  Otherwise, symbols with no
2397          line number info get reported with the line number of the
2398          last line of the last symbol which does have line number
2399          info.  We use 0x100 as a slop to account for cases where the
2400          last line has executable code.  */
2401       if (i >= section->lineno_count
2402           && last_value != 0
2403           && offset - last_value > 0x100)
2404         {
2405           *functionname_ptr = NULL;
2406           *line_ptr = 0;
2407         }
2408     }
2409
2410   /* Cache the results for the next call.  */
2411   if (sec_data == NULL && section->owner == abfd)
2412     {
2413       amt = sizeof (struct coff_section_tdata);
2414       section->used_by_bfd = bfd_zalloc (abfd, amt);
2415       sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2416     }
2417   if (sec_data != NULL)
2418     {
2419       sec_data->offset = offset;
2420       sec_data->i = i - 1;
2421       sec_data->function = *functionname_ptr;
2422       sec_data->line_base = line_base;
2423     }
2424
2425   return TRUE;
2426 }
2427
2428 bfd_boolean
2429 coff_find_nearest_line (bfd *abfd,
2430                         asymbol **symbols,
2431                         asection *section,
2432                         bfd_vma offset,
2433                         const char **filename_ptr,
2434                         const char **functionname_ptr,
2435                         unsigned int *line_ptr,
2436                         unsigned int *discriminator_ptr)
2437 {
2438   if (discriminator_ptr)
2439     *discriminator_ptr = 0;
2440   return coff_find_nearest_line_with_names (abfd, symbols, section, offset,
2441                                             filename_ptr, functionname_ptr,
2442                                             line_ptr, dwarf_debug_sections);
2443 }
2444
2445 bfd_boolean
2446 coff_find_inliner_info (bfd *abfd,
2447                         const char **filename_ptr,
2448                         const char **functionname_ptr,
2449                         unsigned int *line_ptr)
2450 {
2451   bfd_boolean found;
2452
2453   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
2454                                          functionname_ptr, line_ptr,
2455                                          &coff_data(abfd)->dwarf2_find_line_info);
2456   return (found);
2457 }
2458
2459 int
2460 coff_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
2461 {
2462   size_t size;
2463
2464   if (!info->relocatable)
2465     size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
2466   else
2467     size = bfd_coff_filhsz (abfd);
2468
2469   size += abfd->section_count * bfd_coff_scnhsz (abfd);
2470   return size;
2471 }
2472
2473 /* Change the class of a coff symbol held by BFD.  */
2474
2475 bfd_boolean
2476 bfd_coff_set_symbol_class (bfd *         abfd,
2477                            asymbol *     symbol,
2478                            unsigned int  symbol_class)
2479 {
2480   coff_symbol_type * csym;
2481
2482   csym = coff_symbol_from (symbol);
2483   if (csym == NULL)
2484     {
2485       bfd_set_error (bfd_error_invalid_operation);
2486       return FALSE;
2487     }
2488   else if (csym->native == NULL)
2489     {
2490       /* This is an alien symbol which no native coff backend data.
2491          We cheat here by creating a fake native entry for it and
2492          then filling in the class.  This code is based on that in
2493          coff_write_alien_symbol().  */
2494
2495       combined_entry_type * native;
2496       bfd_size_type amt = sizeof (* native);
2497
2498       native = (combined_entry_type *) bfd_zalloc (abfd, amt);
2499       if (native == NULL)
2500         return FALSE;
2501
2502       native->is_sym = TRUE;
2503       native->u.syment.n_type   = T_NULL;
2504       native->u.syment.n_sclass = symbol_class;
2505
2506       if (bfd_is_und_section (symbol->section))
2507         {
2508           native->u.syment.n_scnum = N_UNDEF;
2509           native->u.syment.n_value = symbol->value;
2510         }
2511       else if (bfd_is_com_section (symbol->section))
2512         {
2513           native->u.syment.n_scnum = N_UNDEF;
2514           native->u.syment.n_value = symbol->value;
2515         }
2516       else
2517         {
2518           native->u.syment.n_scnum =
2519             symbol->section->output_section->target_index;
2520           native->u.syment.n_value = (symbol->value
2521                                       + symbol->section->output_offset);
2522           if (! obj_pe (abfd))
2523             native->u.syment.n_value += symbol->section->output_section->vma;
2524
2525           /* Copy the any flags from the file header into the symbol.
2526              FIXME: Why?  */
2527           native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags;
2528         }
2529
2530       csym->native = native;
2531     }
2532   else
2533     csym->native->u.syment.n_sclass = symbol_class;
2534
2535   return TRUE;
2536 }
2537
2538 bfd_boolean
2539 _bfd_coff_section_already_linked (bfd *abfd,
2540                                   asection *sec,
2541                                   struct bfd_link_info *info)
2542 {
2543   flagword flags;
2544   const char *name, *key;
2545   struct bfd_section_already_linked *l;
2546   struct bfd_section_already_linked_hash_entry *already_linked_list;
2547   struct coff_comdat_info *s_comdat;
2548
2549   flags = sec->flags;
2550   if ((flags & SEC_LINK_ONCE) == 0)
2551     return FALSE;
2552
2553   /* The COFF backend linker doesn't support group sections.  */
2554   if ((flags & SEC_GROUP) != 0)
2555     return FALSE;
2556
2557   name = bfd_get_section_name (abfd, sec);
2558   s_comdat = bfd_coff_get_comdat_section (abfd, sec);
2559
2560   if (s_comdat != NULL)
2561     key = s_comdat->name;
2562   else
2563     {
2564       if (CONST_STRNEQ (name, ".gnu.linkonce.")
2565           && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
2566         key++;
2567       else
2568         /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2569            .xdata$<key> and .pdata$<key> only the first of which has a
2570            comdat key.  Should these all match the LTO IR key?  */
2571         key = name;
2572     }
2573
2574   already_linked_list = bfd_section_already_linked_table_lookup (key);
2575
2576   for (l = already_linked_list->entry; l != NULL; l = l->next)
2577     {
2578       struct coff_comdat_info *l_comdat;
2579
2580       l_comdat = bfd_coff_get_comdat_section (l->sec->owner, l->sec);
2581
2582       /* The section names must match, and both sections must be
2583          comdat and have the same comdat name, or both sections must
2584          be non-comdat.  LTO IR plugin sections are an exception.  They
2585          are always named .gnu.linkonce.t.<key> (<key> is some string)
2586          and match any comdat section with comdat name of <key>, and
2587          any linkonce section with the same suffix, ie.
2588          .gnu.linkonce.*.<key>.  */
2589       if (((s_comdat != NULL) == (l_comdat != NULL)
2590            && strcmp (name, l->sec->name) == 0)
2591           || (l->sec->owner->flags & BFD_PLUGIN) != 0)
2592         {
2593           /* The section has already been linked.  See if we should
2594              issue a warning.  */
2595           return _bfd_handle_already_linked (sec, l, info);
2596         }
2597     }
2598
2599   /* This is the first section with this name.  Record it.  */
2600   if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
2601     info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
2602   return FALSE;
2603 }