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