bfd/coffgen.c

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