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