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