bfd/coffgen.c

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