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